blob: 865725adb9d3f1b677616ea35ecd924693c06ef4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _LINUX_SCHED_H
2#define _LINUX_SCHED_H
3
David Woodhouseb7b3c762006-04-27 00:12:56 +01004/*
5 * cloning flags:
6 */
7#define CSIGNAL 0x000000ff /* signal mask to be sent at exit */
8#define CLONE_VM 0x00000100 /* set if VM shared between processes */
9#define CLONE_FS 0x00000200 /* set if fs info shared between processes */
10#define CLONE_FILES 0x00000400 /* set if open files shared between processes */
11#define CLONE_SIGHAND 0x00000800 /* set if signal handlers and blocked signals shared */
12#define CLONE_PTRACE 0x00002000 /* set if we want to let tracing continue on the child too */
13#define CLONE_VFORK 0x00004000 /* set if the parent wants the child to wake it up on mm_release */
14#define CLONE_PARENT 0x00008000 /* set if we want to have the same parent as the cloner */
15#define CLONE_THREAD 0x00010000 /* Same thread group? */
16#define CLONE_NEWNS 0x00020000 /* New namespace group? */
17#define CLONE_SYSVSEM 0x00040000 /* share system V SEM_UNDO semantics */
18#define CLONE_SETTLS 0x00080000 /* create a new TLS for the child */
19#define CLONE_PARENT_SETTID 0x00100000 /* set the TID in the parent */
20#define CLONE_CHILD_CLEARTID 0x00200000 /* clear the TID in the child */
21#define CLONE_DETACHED 0x00400000 /* Unused, ignored */
22#define CLONE_UNTRACED 0x00800000 /* set if the tracing process can't force CLONE_PTRACE on this clone */
23#define CLONE_CHILD_SETTID 0x01000000 /* set the TID in the child */
Dave Jones43bb40c2011-01-13 15:45:40 -080024/* 0x02000000 was previously the unused CLONE_STOPPED (Start in stopped state)
25 and is now available for re-use. */
Serge E. Hallyn071df102006-10-02 02:18:17 -070026#define CLONE_NEWUTS 0x04000000 /* New utsname group? */
Kirill Korotaev25b21cb2006-10-02 02:18:19 -070027#define CLONE_NEWIPC 0x08000000 /* New ipcs */
Serge E. Hallyn77ec7392007-07-15 23:41:01 -070028#define CLONE_NEWUSER 0x10000000 /* New user namespace */
Pavel Emelyanov30e49c22007-10-18 23:40:10 -070029#define CLONE_NEWPID 0x20000000 /* New pid namespace */
Eric W. Biederman169e3672007-09-27 17:10:06 -070030#define CLONE_NEWNET 0x40000000 /* New network namespace */
Jens Axboefadad8782008-01-24 08:54:47 +010031#define CLONE_IO 0x80000000 /* Clone io context */
David Woodhouseb7b3c762006-04-27 00:12:56 +010032
33/*
34 * Scheduling policies
35 */
36#define SCHED_NORMAL 0
37#define SCHED_FIFO 1
38#define SCHED_RR 2
39#define SCHED_BATCH 3
Ingo Molnar0e6aca42007-07-09 18:51:57 +020040/* SCHED_ISO: reserved but not implemented yet */
41#define SCHED_IDLE 5
Lennart Poetteringca94c442009-06-15 17:17:47 +020042/* Can be ORed in to make sure the process is reverted back to SCHED_NORMAL on fork */
43#define SCHED_RESET_ON_FORK 0x40000000
David Woodhouseb7b3c762006-04-27 00:12:56 +010044
David Woodhousea3b67142006-04-25 14:54:40 +010045#ifdef __KERNEL__
David Woodhouseb7b3c762006-04-27 00:12:56 +010046
47struct sched_param {
48 int sched_priority;
49};
50
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <asm/param.h> /* for HZ */
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include <linux/capability.h>
54#include <linux/threads.h>
55#include <linux/kernel.h>
56#include <linux/types.h>
57#include <linux/timex.h>
58#include <linux/jiffies.h>
59#include <linux/rbtree.h>
60#include <linux/thread_info.h>
61#include <linux/cpumask.h>
62#include <linux/errno.h>
63#include <linux/nodemask.h>
Martin Schwidefskyc92ff1b2007-10-16 01:24:43 -070064#include <linux/mm_types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#include <asm/page.h>
67#include <asm/ptrace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <asm/cputime.h>
69
70#include <linux/smp.h>
71#include <linux/sem.h>
72#include <linux/signal.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070073#include <linux/compiler.h>
74#include <linux/completion.h>
75#include <linux/pid.h>
76#include <linux/percpu.h>
77#include <linux/topology.h>
Peter Zijlstra3e26c142007-10-16 23:25:50 -070078#include <linux/proportions.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070079#include <linux/seccomp.h>
Ingo Molnare56d0902006-01-08 01:01:37 -080080#include <linux/rcupdate.h>
Jiri Pirko05725f72009-04-14 20:17:16 +020081#include <linux/rculist.h>
Ingo Molnar23f78d4a2006-06-27 02:54:53 -070082#include <linux/rtmutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
David Woodhousea3b67142006-04-25 14:54:40 +010084#include <linux/time.h>
85#include <linux/param.h>
86#include <linux/resource.h>
87#include <linux/timer.h>
88#include <linux/hrtimer.h>
Andrew Morton7c3ab732006-12-10 02:19:19 -080089#include <linux/task_io_accounting.h>
Arjan van de Ven97455122008-01-25 21:08:34 +010090#include <linux/latencytop.h>
David Howells9e2b2dc2008-08-13 16:20:04 +010091#include <linux/cred.h>
Peter Zijlstrafa14ff42011-09-12 13:06:17 +020092#include <linux/llist.h>
Eric W. Biederman7b44ab92011-11-16 23:20:58 -080093#include <linux/uidgid.h>
David Woodhousea3b67142006-04-25 14:54:40 +010094
95#include <asm/processor.h>
H. J. Lu36d57ac2005-09-06 15:16:49 -070096
Linus Torvalds1da177e2005-04-16 15:20:36 -070097struct exec_domain;
Ingo Molnarc87e2832006-06-27 02:54:58 -070098struct futex_pi_state;
Alexey Dobriyan286100a2008-01-25 21:08:34 +010099struct robust_list_head;
Akinobu Mitabddd87c2010-02-23 08:55:42 +0100100struct bio_list;
Al Viro5ad4e532009-03-29 19:50:06 -0400101struct fs_struct;
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200102struct perf_event_context;
Jens Axboe73c10102011-03-08 13:19:51 +0100103struct blk_plug;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
105/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 * List of flags we want to share for kernel threads,
107 * if only because they are not used by them anyway.
108 */
109#define CLONE_KERNEL (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
110
111/*
112 * These are the constant used to fake the fixed-point load-average
113 * counting. Some notes:
114 * - 11 bit fractions expand to 22 bits by the multiplies: this gives
115 * a load-average precision of 10 bits integer + 11 bits fractional
116 * - if you want to count load-averages more often, you need more
117 * precision, or rounding will get you. With 2-second counting freq,
118 * the EXP_n values would be 1981, 2034 and 2043 if still using only
119 * 11 bit fractions.
120 */
121extern unsigned long avenrun[]; /* Load averages */
Thomas Gleixner2d024942009-05-02 20:08:52 +0200122extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124#define FSHIFT 11 /* nr of bits of precision */
125#define FIXED_1 (1<<FSHIFT) /* 1.0 as fixed-point */
Linus Torvalds0c2043a2007-10-07 16:17:38 -0700126#define LOAD_FREQ (5*HZ+1) /* 5 sec intervals */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127#define EXP_1 1884 /* 1/exp(5sec/1min) as fixed-point */
128#define EXP_5 2014 /* 1/exp(5sec/5min) */
129#define EXP_15 2037 /* 1/exp(5sec/15min) */
130
131#define CALC_LOAD(load,exp,n) \
132 load *= exp; \
133 load += n*(FIXED_1-exp); \
134 load >>= FSHIFT;
135
136extern unsigned long total_forks;
137extern int nr_threads;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138DECLARE_PER_CPU(unsigned long, process_counts);
139extern int nr_processes(void);
140extern unsigned long nr_running(void);
141extern unsigned long nr_uninterruptible(void);
142extern unsigned long nr_iowait(void);
Peter Zijlstra8c215bd2010-07-01 09:07:17 +0200143extern unsigned long nr_iowait_cpu(int cpu);
Arjan van de Ven69d25872009-09-21 17:04:08 -0700144extern unsigned long this_cpu_load(void);
145
146
Peter Zijlstra0f004f52010-11-30 19:48:45 +0100147extern void calc_global_load(unsigned long ticks);
Peter Zijlstra5aaa0b72012-05-17 17:15:29 +0200148extern void update_cpu_load_nohz(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
Steven Rostedt7e49fcc2009-01-22 19:01:40 -0500150extern unsigned long get_parent_ip(unsigned long addr);
151
Ingo Molnar43ae34c2007-07-09 18:52:00 +0200152struct seq_file;
153struct cfs_rq;
Ingo Molnar4cf86d72007-10-15 17:00:14 +0200154struct task_group;
Ingo Molnar43ae34c2007-07-09 18:52:00 +0200155#ifdef CONFIG_SCHED_DEBUG
156extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
157extern void proc_sched_set_task(struct task_struct *p);
158extern void
Ingo Molnar5cef9ec2007-08-09 11:16:47 +0200159print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
Ingo Molnar43ae34c2007-07-09 18:52:00 +0200160#else
161static inline void
162proc_sched_show_task(struct task_struct *p, struct seq_file *m)
163{
164}
165static inline void proc_sched_set_task(struct task_struct *p)
166{
167}
168static inline void
Ingo Molnar5cef9ec2007-08-09 11:16:47 +0200169print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
Ingo Molnar43ae34c2007-07-09 18:52:00 +0200170{
171}
172#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
Linus Torvalds4a8342d2005-09-29 15:18:21 -0700174/*
175 * Task state bitmask. NOTE! These bits are also
176 * encoded in fs/proc/array.c: get_task_state().
177 *
178 * We have two separate sets of flags: task->state
179 * is about runnability, while task->exit_state are
180 * about the task exiting. Confusing, but this way
181 * modifying one set can't modify the other one by
182 * mistake.
183 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184#define TASK_RUNNING 0
185#define TASK_INTERRUPTIBLE 1
186#define TASK_UNINTERRUPTIBLE 2
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500187#define __TASK_STOPPED 4
188#define __TASK_TRACED 8
Linus Torvalds4a8342d2005-09-29 15:18:21 -0700189/* in tsk->exit_state */
190#define EXIT_ZOMBIE 16
191#define EXIT_DEAD 32
192/* in tsk->state again */
Mike Galbraithaf927232007-10-15 17:00:13 +0200193#define TASK_DEAD 64
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500194#define TASK_WAKEKILL 128
Peter Zijlstrae9c84312009-09-15 14:43:03 +0200195#define TASK_WAKING 256
Peter Zijlstrae1781532009-12-17 13:16:30 +0100196#define TASK_STATE_MAX 512
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500197
Peter Zijlstra44d90df2009-12-17 13:16:28 +0100198#define TASK_STATE_TO_CHAR_STR "RSDTtZXxKW"
Peter Zijlstra73342152009-12-17 13:16:27 +0100199
Peter Zijlstrae1781532009-12-17 13:16:30 +0100200extern char ___assert_task_state[1 - 2*!!(
201 sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1)];
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500202
203/* Convenience macros for the sake of set_task_state */
204#define TASK_KILLABLE (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
205#define TASK_STOPPED (TASK_WAKEKILL | __TASK_STOPPED)
206#define TASK_TRACED (TASK_WAKEKILL | __TASK_TRACED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500208/* Convenience macros for the sake of wake_up */
209#define TASK_NORMAL (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500210#define TASK_ALL (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500211
212/* get_task_state() */
213#define TASK_REPORT (TASK_RUNNING | TASK_INTERRUPTIBLE | \
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500214 TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
215 __TASK_TRACED)
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500216
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500217#define task_is_traced(task) ((task->state & __TASK_TRACED) != 0)
218#define task_is_stopped(task) ((task->state & __TASK_STOPPED) != 0)
David Howells8f920542010-07-29 12:45:55 +0100219#define task_is_dead(task) ((task)->exit_state != 0)
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500220#define task_is_stopped_or_traced(task) \
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500221 ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500222#define task_contributes_to_load(task) \
Nathan Lynche3c8ca82009-04-08 19:45:12 -0500223 ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
Tejun Heo376fede2011-11-21 12:32:24 -0800224 (task->flags & PF_FROZEN) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226#define __set_task_state(tsk, state_value) \
227 do { (tsk)->state = (state_value); } while (0)
228#define set_task_state(tsk, state_value) \
229 set_mb((tsk)->state, (state_value))
230
Andrew Morton498d0c52005-09-13 01:25:14 -0700231/*
232 * set_current_state() includes a barrier so that the write of current->state
233 * is correctly serialised wrt the caller's subsequent test of whether to
234 * actually sleep:
235 *
236 * set_current_state(TASK_UNINTERRUPTIBLE);
237 * if (do_i_need_to_sleep())
238 * schedule();
239 *
240 * If the caller does not need such serialisation then use __set_current_state()
241 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242#define __set_current_state(state_value) \
243 do { current->state = (state_value); } while (0)
244#define set_current_state(state_value) \
245 set_mb(current->state, (state_value))
246
247/* Task command name length */
248#define TASK_COMM_LEN 16
249
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250#include <linux/spinlock.h>
251
252/*
253 * This serializes "schedule()" and also protects
254 * the run-queue from deletions/modifications (but
255 * _adding_ to the beginning of the run-queue has
256 * a separate lock).
257 */
258extern rwlock_t tasklist_lock;
259extern spinlock_t mmlist_lock;
260
Ingo Molnar36c8b582006-07-03 00:25:41 -0700261struct task_struct;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
Paul E. McKenneydb1466b2010-03-03 07:46:56 -0800263#ifdef CONFIG_PROVE_RCU
264extern int lockdep_tasklist_lock_is_held(void);
265#endif /* #ifdef CONFIG_PROVE_RCU */
266
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267extern void sched_init(void);
268extern void sched_init_smp(void);
Harvey Harrison2d07b252008-02-15 09:56:34 -0800269extern asmlinkage void schedule_tail(struct task_struct *prev);
Ingo Molnar36c8b582006-07-03 00:25:41 -0700270extern void init_idle(struct task_struct *idle, int cpu);
Ingo Molnar1df21052007-07-09 18:51:58 +0200271extern void init_idle_bootup_task(struct task_struct *idle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Andrew Morton89f19f02009-09-19 11:55:44 -0700273extern int runqueue_is_locked(int cpu);
Ingo Molnar017730c2008-05-12 21:20:52 +0200274
Siddha, Suresh B46cb4b72007-05-08 00:32:51 -0700275#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ)
Venkatesh Pallipadi83cd4fe2010-05-21 17:09:41 -0700276extern void select_nohz_load_balancer(int stop_tick);
Suresh Siddha69e1e812011-12-01 17:07:33 -0800277extern void set_cpu_sd_state_idle(void);
Venkatesh Pallipadi83cd4fe2010-05-21 17:09:41 -0700278extern int get_nohz_timer_target(void);
Siddha, Suresh B46cb4b72007-05-08 00:32:51 -0700279#else
Venkatesh Pallipadi83cd4fe2010-05-21 17:09:41 -0700280static inline void select_nohz_load_balancer(int stop_tick) { }
Peter Zijlstrafdaabd82011-12-06 12:47:55 +0100281static inline void set_cpu_sd_state_idle(void) { }
Siddha, Suresh B46cb4b72007-05-08 00:32:51 -0700282#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
Ingo Molnare59e2ae2006-12-06 20:35:59 -0800284/*
Ingo Molnar39bc89f2007-04-25 20:50:03 -0700285 * Only dump TASK_* tasks. (0 for all tasks)
Ingo Molnare59e2ae2006-12-06 20:35:59 -0800286 */
287extern void show_state_filter(unsigned long state_filter);
288
289static inline void show_state(void)
290{
Ingo Molnar39bc89f2007-04-25 20:50:03 -0700291 show_state_filter(0);
Ingo Molnare59e2ae2006-12-06 20:35:59 -0800292}
293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294extern void show_regs(struct pt_regs *);
295
296/*
297 * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
298 * task), SP is the stack pointer of the first frame that should be shown in the back
299 * trace (or NULL if the entire call-chain of the task should be shown).
300 */
301extern void show_stack(struct task_struct *task, unsigned long *sp);
302
303void io_schedule(void);
304long io_schedule_timeout(long timeout);
305
306extern void cpu_init (void);
307extern void trap_init(void);
308extern void update_process_times(int user);
309extern void scheduler_tick(void);
310
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100311extern void sched_show_task(struct task_struct *p);
312
Frederic Weisbecker19cc36c2010-05-13 02:30:49 +0200313#ifdef CONFIG_LOCKUP_DETECTOR
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700314extern void touch_softlockup_watchdog(void);
Jason Wesseld6ad3e22010-01-27 16:25:22 -0600315extern void touch_softlockup_watchdog_sync(void);
Jeremy Fitzhardinge04c91672007-05-08 00:28:05 -0700316extern void touch_all_softlockup_watchdogs(void);
Don Zickus332fbdb2010-05-07 17:11:45 -0400317extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
318 void __user *buffer,
319 size_t *lenp, loff_t *ppos);
Ingo Molnar9c44bc02008-05-12 21:21:04 +0200320extern unsigned int softlockup_panic;
Peter Zijlstra004417a2010-11-25 18:38:29 +0100321void lockup_detector_init(void);
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700322#else
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700323static inline void touch_softlockup_watchdog(void)
324{
325}
Jason Wesseld6ad3e22010-01-27 16:25:22 -0600326static inline void touch_softlockup_watchdog_sync(void)
327{
328}
Jeremy Fitzhardinge04c91672007-05-08 00:28:05 -0700329static inline void touch_all_softlockup_watchdogs(void)
330{
331}
Peter Zijlstra004417a2010-11-25 18:38:29 +0100332static inline void lockup_detector_init(void)
333{
334}
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700335#endif
336
Sameer Nanda45226e92012-07-30 14:40:00 -0700337#if defined(CONFIG_LOCKUP_DETECTOR) && defined(CONFIG_SUSPEND)
338void lockup_detector_bootcpu_resume(void);
339#else
340static inline void lockup_detector_bootcpu_resume(void)
341{
342}
343#endif
344
Mandeep Singh Bainese162b392009-01-15 11:08:40 -0800345#ifdef CONFIG_DETECT_HUNG_TASK
346extern unsigned int sysctl_hung_task_panic;
347extern unsigned long sysctl_hung_task_check_count;
348extern unsigned long sysctl_hung_task_timeout_secs;
349extern unsigned long sysctl_hung_task_warnings;
350extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700351 void __user *buffer,
Mandeep Singh Bainese162b392009-01-15 11:08:40 -0800352 size_t *lenp, loff_t *ppos);
Mark Lorde4ecda12010-09-25 11:17:22 +0200353#else
354/* Avoid need for ifdefs elsewhere in the code */
355enum { sysctl_hung_task_timeout_secs = 0 };
Mandeep Singh Bainese162b392009-01-15 11:08:40 -0800356#endif
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358/* Attach to any functions which should be ignored in wchan output. */
359#define __sched __attribute__((__section__(".sched.text")))
Ingo Molnardeaf2222007-11-28 15:52:56 +0100360
361/* Linker adds these: start and end of __sched functions */
362extern char __sched_text_start[], __sched_text_end[];
363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364/* Is this address in the __sched functions? */
365extern int in_sched_functions(unsigned long addr);
366
367#define MAX_SCHEDULE_TIMEOUT LONG_MAX
Harvey Harrisonb3c97522008-02-13 15:03:15 -0800368extern signed long schedule_timeout(signed long timeout);
Nishanth Aravamudan64ed93a2005-09-10 00:27:21 -0700369extern signed long schedule_timeout_interruptible(signed long timeout);
Matthew Wilcox294d5cc2007-12-06 11:59:46 -0500370extern signed long schedule_timeout_killable(signed long timeout);
Nishanth Aravamudan64ed93a2005-09-10 00:27:21 -0700371extern signed long schedule_timeout_uninterruptible(signed long timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372asmlinkage void schedule(void);
Thomas Gleixnerc5491ea2011-03-21 12:09:35 +0100373extern void schedule_preempt_disabled(void);
Peter Zijlstrac6eb3dd2011-04-05 17:23:41 +0200374extern int mutex_spin_on_owner(struct mutex *lock, struct task_struct *owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
Serge E. Hallynab516012006-10-02 02:18:06 -0700376struct nsproxy;
Cedric Le Goateracce2922007-07-15 23:40:59 -0700377struct user_namespace;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
KAMEZAWA Hiroyuki341c87b2009-06-30 11:41:23 -0700379/*
380 * Default maximum number of active map areas, this limits the number of vmas
381 * per mm struct. Users can overwrite this number by sysctl but there is a
382 * problem.
383 *
384 * When a program's coredump is generated as ELF format, a section is created
385 * per a vma. In ELF, the number of sections is represented in unsigned short.
386 * This means the number of sections should be smaller than 65535 at coredump.
387 * Because the kernel adds some informative sections to a image of program at
388 * generating coredump, we need some margin. The number of extra sections is
389 * 1-3 now and depends on arch. We use "5" as safe margin, here.
390 */
391#define MAPCOUNT_ELF_CORE_MARGIN (5)
Alexey Dobriyan4be929b2010-05-24 14:33:03 -0700392#define DEFAULT_MAX_MAP_COUNT (USHRT_MAX - MAPCOUNT_ELF_CORE_MARGIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
394extern int sysctl_max_map_count;
395
396#include <linux/aio.h>
397
David Howellsefc1a3b2010-01-15 17:01:35 -0800398#ifdef CONFIG_MMU
399extern void arch_pick_mmap_layout(struct mm_struct *mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400extern unsigned long
401arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
402 unsigned long, unsigned long);
403extern unsigned long
404arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
405 unsigned long len, unsigned long pgoff,
406 unsigned long flags);
Wolfgang Wander1363c3c2005-06-21 17:14:49 -0700407extern void arch_unmap_area(struct mm_struct *, unsigned long);
408extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
David Howellsefc1a3b2010-01-15 17:01:35 -0800409#else
410static inline void arch_pick_mmap_layout(struct mm_struct *mm) {}
411#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
Oleg Nesterov901608d2009-01-06 14:40:29 -0800413
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700414extern void set_dumpable(struct mm_struct *mm, int value);
415extern int get_dumpable(struct mm_struct *mm);
416
Kees Cook54b50192012-07-30 14:39:18 -0700417/* get/set_dumpable() values */
418#define SUID_DUMPABLE_DISABLED 0
419#define SUID_DUMPABLE_ENABLED 1
420#define SUID_DUMPABLE_SAFE 2
421
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700422/* mm flags */
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700423/* dumpable bits */
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700424#define MMF_DUMPABLE 0 /* core dump is permitted */
425#define MMF_DUMP_SECURELY 1 /* core file is readable only by root */
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700426
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700427#define MMF_DUMPABLE_BITS 2
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700428#define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1)
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700429
430/* coredump filter bits */
431#define MMF_DUMP_ANON_PRIVATE 2
432#define MMF_DUMP_ANON_SHARED 3
433#define MMF_DUMP_MAPPED_PRIVATE 4
434#define MMF_DUMP_MAPPED_SHARED 5
Roland McGrath82df3972007-10-16 23:27:02 -0700435#define MMF_DUMP_ELF_HEADERS 6
KOSAKI Motohiroe575f112008-10-18 20:27:08 -0700436#define MMF_DUMP_HUGETLB_PRIVATE 7
437#define MMF_DUMP_HUGETLB_SHARED 8
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700438
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700439#define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS
KOSAKI Motohiroe575f112008-10-18 20:27:08 -0700440#define MMF_DUMP_FILTER_BITS 7
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700441#define MMF_DUMP_FILTER_MASK \
442 (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
443#define MMF_DUMP_FILTER_DEFAULT \
KOSAKI Motohiroe575f112008-10-18 20:27:08 -0700444 ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\
Roland McGrath656eb2c2008-10-18 20:28:23 -0700445 (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)
446
447#ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS
448# define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS)
449#else
450# define MMF_DUMP_MASK_DEFAULT_ELF 0
451#endif
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700452 /* leave room for more dump flags */
453#define MMF_VM_MERGEABLE 16 /* KSM may merge identical pages */
Andrea Arcangeliba761492011-01-13 15:46:58 -0800454#define MMF_VM_HUGEPAGE 17 /* set when VM_HUGEPAGE is set on vma */
Konstantin Khlebnikovbafb2822012-06-07 14:21:11 -0700455#define MMF_EXE_FILE_CHANGED 18 /* see prctl_set_mm_exe_file() */
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700456
457#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK)
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459struct sighand_struct {
460 atomic_t count;
461 struct k_sigaction action[_NSIG];
462 spinlock_t siglock;
Davide Libenzib8fceee2007-09-20 12:40:16 -0700463 wait_queue_head_t signalfd_wqh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464};
465
KaiGai Kohei0e464812006-06-25 05:49:24 -0700466struct pacct_struct {
KaiGai Koheif6ec29a2006-06-25 05:49:25 -0700467 int ac_flag;
468 long ac_exitcode;
KaiGai Kohei0e464812006-06-25 05:49:24 -0700469 unsigned long ac_mem;
KaiGai Kohei77787bf2006-06-25 05:49:26 -0700470 cputime_t ac_utime, ac_stime;
471 unsigned long ac_minflt, ac_majflt;
KaiGai Kohei0e464812006-06-25 05:49:24 -0700472};
473
Stanislaw Gruszka42c4ab42009-07-29 12:15:26 +0200474struct cpu_itimer {
475 cputime_t expires;
476 cputime_t incr;
Stanislaw Gruszka8356b5f2009-07-29 12:15:27 +0200477 u32 error;
478 u32 incr_error;
Stanislaw Gruszka42c4ab42009-07-29 12:15:26 +0200479};
480
Frank Mayharf06febc2008-09-12 09:54:39 -0700481/**
482 * struct task_cputime - collected CPU time counts
483 * @utime: time spent in user mode, in &cputime_t units
484 * @stime: time spent in kernel mode, in &cputime_t units
485 * @sum_exec_runtime: total time spent on the CPU, in nanoseconds
Ingo Molnar5ce73a42008-09-14 17:11:46 +0200486 *
Frank Mayharf06febc2008-09-12 09:54:39 -0700487 * This structure groups together three kinds of CPU time that are
488 * tracked for threads and thread groups. Most things considering
489 * CPU time want to group these counts together and treat all three
490 * of them in parallel.
491 */
492struct task_cputime {
493 cputime_t utime;
494 cputime_t stime;
495 unsigned long long sum_exec_runtime;
496};
497/* Alternate field names when used to cache expirations. */
498#define prof_exp stime
499#define virt_exp utime
500#define sched_exp sum_exec_runtime
501
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100502#define INIT_CPUTIME \
503 (struct task_cputime) { \
Martin Schwidefsky64861632011-12-15 14:56:09 +0100504 .utime = 0, \
505 .stime = 0, \
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100506 .sum_exec_runtime = 0, \
507 }
508
Peter Zijlstrac99e6ef2009-07-10 14:57:56 +0200509/*
510 * Disable preemption until the scheduler is running.
511 * Reset by start_kernel()->sched_init()->init_idle().
Peter Zijlstrad86ee482009-07-10 14:57:57 +0200512 *
513 * We include PREEMPT_ACTIVE to avoid cond_resched() from working
514 * before the scheduler is active -- see should_resched().
Peter Zijlstrac99e6ef2009-07-10 14:57:56 +0200515 */
Peter Zijlstrad86ee482009-07-10 14:57:57 +0200516#define INIT_PREEMPT_COUNT (1 + PREEMPT_ACTIVE)
Peter Zijlstrac99e6ef2009-07-10 14:57:56 +0200517
Frank Mayharf06febc2008-09-12 09:54:39 -0700518/**
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100519 * struct thread_group_cputimer - thread group interval timer counts
520 * @cputime: thread group interval timers.
521 * @running: non-zero when there are timers running and
522 * @cputime receives updates.
523 * @lock: lock for fields in this struct.
Frank Mayharf06febc2008-09-12 09:54:39 -0700524 *
525 * This structure contains the version of task_cputime, above, that is
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100526 * used for thread group CPU timer calculations.
Frank Mayharf06febc2008-09-12 09:54:39 -0700527 */
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100528struct thread_group_cputimer {
529 struct task_cputime cputime;
530 int running;
Thomas Gleixneree30a7b2009-07-25 18:56:56 +0200531 raw_spinlock_t lock;
Frank Mayharf06febc2008-09-12 09:54:39 -0700532};
Frank Mayharf06febc2008-09-12 09:54:39 -0700533
Ben Blum4714d1d2011-05-26 16:25:18 -0700534#include <linux/rwsem.h>
Mike Galbraith5091faa2010-11-30 14:18:03 +0100535struct autogroup;
536
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537/*
Jonathan Neuschäfere815f0a2011-03-21 20:24:47 +0100538 * NOTE! "signal_struct" does not have its own
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 * locking, because a shared signal_struct always
540 * implies a shared sighand_struct, so locking
541 * sighand_struct is always a proper superset of
542 * the locking of signal_struct.
543 */
544struct signal_struct {
Oleg Nesterovea6d2902010-05-26 14:43:16 -0700545 atomic_t sigcnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 atomic_t live;
Oleg Nesterovb3ac0222010-05-26 14:43:24 -0700547 int nr_threads;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
549 wait_queue_head_t wait_chldexit; /* for wait4() */
550
551 /* current thread group signal load-balancing target: */
Ingo Molnar36c8b582006-07-03 00:25:41 -0700552 struct task_struct *curr_target;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
554 /* shared signal handling: */
555 struct sigpending shared_pending;
556
557 /* thread group exit support */
558 int group_exit_code;
559 /* overloaded:
560 * - notify group_exit_task when ->count is equal to notify_count
561 * - everyone except group_exit_task is stopped during signal delivery
562 * of fatal signals, group_exit_task processes the signal.
563 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 int notify_count;
Richard Kennedy07dd20e2008-08-01 13:18:04 +0100565 struct task_struct *group_exit_task;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
567 /* thread group stop support, overloads group_exit_code too */
568 int group_stop_count;
569 unsigned int flags; /* see SIGNAL_* flags below */
570
Lennart Poetteringebec18a2012-03-23 15:01:54 -0700571 /*
572 * PR_SET_CHILD_SUBREAPER marks a process, like a service
573 * manager, to re-parent orphan (double-forking) child processes
574 * to this process instead of 'init'. The service manager is
575 * able to receive SIGCHLD signals and is able to investigate
576 * the process until it calls wait(). All children of this
577 * process will inherit a flag if they should look for a
578 * child_subreaper process at exit.
579 */
580 unsigned int is_child_subreaper:1;
581 unsigned int has_child_subreaper:1;
582
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 /* POSIX.1b Interval Timers */
584 struct list_head posix_timers;
585
586 /* ITIMER_REAL timer for the process */
Thomas Gleixner2ff678b2006-01-09 20:52:34 -0800587 struct hrtimer real_timer;
Oleg Nesterovfea9d172008-02-08 04:19:19 -0800588 struct pid *leader_pid;
Thomas Gleixner2ff678b2006-01-09 20:52:34 -0800589 ktime_t it_real_incr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Stanislaw Gruszka42c4ab42009-07-29 12:15:26 +0200591 /*
592 * ITIMER_PROF and ITIMER_VIRTUAL timers for the process, we use
593 * CPUCLOCK_PROF and CPUCLOCK_VIRT for indexing array as these
594 * values are defined to 0 and 1 respectively
595 */
596 struct cpu_itimer it[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
Frank Mayharf06febc2008-09-12 09:54:39 -0700598 /*
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100599 * Thread group totals for process CPU timers.
600 * See thread_group_cputimer(), et al, for details.
Frank Mayharf06febc2008-09-12 09:54:39 -0700601 */
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100602 struct thread_group_cputimer cputimer;
Frank Mayharf06febc2008-09-12 09:54:39 -0700603
604 /* Earliest-expiration cache. */
605 struct task_cputime cputime_expires;
606
607 struct list_head cpu_timers[3];
608
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800609 struct pid *tty_old_pgrp;
Cedric Le Goater1ec320a2006-12-08 02:37:55 -0800610
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 /* boolean value for session group leader */
612 int leader;
613
614 struct tty_struct *tty; /* NULL if no tty */
615
Mike Galbraith5091faa2010-11-30 14:18:03 +0100616#ifdef CONFIG_SCHED_AUTOGROUP
617 struct autogroup *autogroup;
618#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 /*
620 * Cumulative resource counters for dead threads in the group,
621 * and for reaped dead child processes forked by this group.
622 * Live threads maintain their own counters and add to these
623 * in __exit_signal, except for the group leader.
624 */
Peter Zijlstra32bd6712009-02-05 12:24:15 +0100625 cputime_t utime, stime, cutime, cstime;
Laurent Vivier9ac52312007-10-15 17:00:19 +0200626 cputime_t gtime;
627 cputime_t cgtime;
Hidetoshi Seto0cf55e12009-12-02 17:28:07 +0900628#ifndef CONFIG_VIRT_CPU_ACCOUNTING
629 cputime_t prev_utime, prev_stime;
630#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
632 unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
Eric Dumazet6eaeeab2007-05-10 22:22:37 -0700633 unsigned long inblock, oublock, cinblock, coublock;
Jiri Pirko1f102062009-09-22 16:44:10 -0700634 unsigned long maxrss, cmaxrss;
Andrea Righi940389b2008-07-28 00:48:12 +0200635 struct task_io_accounting ioac;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636
637 /*
Peter Zijlstra32bd6712009-02-05 12:24:15 +0100638 * Cumulative ns of schedule CPU time fo dead threads in the
639 * group, not including a zombie group leader, (This only differs
640 * from jiffies_to_ns(utime + stime) if sched_clock uses something
641 * other than jiffies.)
642 */
643 unsigned long long sum_sched_runtime;
644
645 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 * We don't bother to synchronize most readers of this at all,
647 * because there is no reader checking a limit that actually needs
648 * to get both rlim_cur and rlim_max atomically, and either one
649 * alone is a single word that can safely be read normally.
650 * getrlimit/setrlimit use task_lock(current->group_leader) to
651 * protect this instead of the siglock, because they really
652 * have no need to disable irqs.
653 */
654 struct rlimit rlim[RLIM_NLIMITS];
655
KaiGai Kohei0e464812006-06-25 05:49:24 -0700656#ifdef CONFIG_BSD_PROCESS_ACCT
657 struct pacct_struct pacct; /* per-process accounting information */
658#endif
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700659#ifdef CONFIG_TASKSTATS
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700660 struct taskstats *stats;
661#endif
Miloslav Trmac522ed772007-07-15 23:40:56 -0700662#ifdef CONFIG_AUDIT
663 unsigned audit_tty;
664 struct tty_audit_buf *tty_audit_buf;
665#endif
Ben Blum4714d1d2011-05-26 16:25:18 -0700666#ifdef CONFIG_CGROUPS
667 /*
Tejun Heo77e4ef92011-12-12 18:12:21 -0800668 * group_rwsem prevents new tasks from entering the threadgroup and
669 * member tasks from exiting,a more specifically, setting of
670 * PF_EXITING. fork and exit paths are protected with this rwsem
671 * using threadgroup_change_begin/end(). Users which require
672 * threadgroup to remain stable should use threadgroup_[un]lock()
673 * which also takes care of exec path. Currently, cgroup is the
674 * only user.
Ben Blum4714d1d2011-05-26 16:25:18 -0700675 */
Tejun Heo257058a2011-12-12 18:12:21 -0800676 struct rw_semaphore group_rwsem;
Ben Blum4714d1d2011-05-26 16:25:18 -0700677#endif
KOSAKI Motohiro28b83c52009-09-21 17:03:13 -0700678
David Rientjesa63d83f2010-08-09 17:19:46 -0700679 int oom_adj; /* OOM kill score adjustment (bit shift) */
680 int oom_score_adj; /* OOM kill score adjustment */
Mandeep Singh Bainesdabb16f2011-01-13 15:46:05 -0800681 int oom_score_adj_min; /* OOM kill score adjustment minimum value.
682 * Only settable by CAP_SYS_RESOURCE. */
KOSAKI Motohiro9b1bf122010-10-27 15:34:08 -0700683
684 struct mutex cred_guard_mutex; /* guard against foreign influences on
685 * credential calculations
686 * (notably. ptrace) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687};
688
Nick Piggin4866cde2005-06-25 14:57:23 -0700689/* Context switch must be unlocked if interrupts are to be enabled */
690#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
691# define __ARCH_WANT_UNLOCKED_CTXSW
692#endif
693
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694/*
695 * Bits in flags field of signal_struct.
696 */
697#define SIGNAL_STOP_STOPPED 0x00000001 /* job control stop in effect */
Oleg Nesterovee77f072011-04-01 20:12:38 +0200698#define SIGNAL_STOP_CONTINUED 0x00000002 /* SIGCONT since WCONTINUED reap */
699#define SIGNAL_GROUP_EXIT 0x00000004 /* group exit in progress */
Oleg Nesterove4420552008-04-30 00:52:44 -0700700/*
701 * Pending notifications to parent.
702 */
703#define SIGNAL_CLD_STOPPED 0x00000010
704#define SIGNAL_CLD_CONTINUED 0x00000020
705#define SIGNAL_CLD_MASK (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
Oleg Nesterovfae5fa42008-04-30 00:53:03 -0700707#define SIGNAL_UNKILLABLE 0x00000040 /* for init: ignore fatal signals */
708
Oleg Nesteroved5d2ca2008-02-04 22:27:24 -0800709/* If true, all threads except ->group_exit_task have pending SIGKILL */
710static inline int signal_group_exit(const struct signal_struct *sig)
711{
712 return (sig->flags & SIGNAL_GROUP_EXIT) ||
713 (sig->group_exit_task != NULL);
714}
715
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716/*
717 * Some day this will be a full-fledged user tracking system..
718 */
719struct user_struct {
720 atomic_t __count; /* reference count */
721 atomic_t processes; /* How many processes does this user have? */
722 atomic_t files; /* How many open files does this user have? */
723 atomic_t sigpending; /* How many pending signals does this user have? */
Amy Griffis2d9048e2006-06-01 13:10:59 -0700724#ifdef CONFIG_INOTIFY_USER
Robert Love0eeca282005-07-12 17:06:03 -0400725 atomic_t inotify_watches; /* How many inotify watches does this user have? */
726 atomic_t inotify_devs; /* How many inotify devs does this user have opened? */
727#endif
Eric Paris4afeff82010-10-28 17:21:58 -0400728#ifdef CONFIG_FANOTIFY
729 atomic_t fanotify_listeners;
730#endif
Davide Libenzi7ef99642008-12-01 13:13:55 -0800731#ifdef CONFIG_EPOLL
Robin Holt52bd19f72011-01-12 17:00:01 -0800732 atomic_long_t epoll_watches; /* The number of file descriptors currently watched */
Davide Libenzi7ef99642008-12-01 13:13:55 -0800733#endif
Alexey Dobriyan970a8642007-10-16 23:30:09 -0700734#ifdef CONFIG_POSIX_MQUEUE
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 /* protected by mq_lock */
736 unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */
Alexey Dobriyan970a8642007-10-16 23:30:09 -0700737#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 unsigned long locked_shm; /* How many pages of mlocked shm ? */
739
740#ifdef CONFIG_KEYS
741 struct key *uid_keyring; /* UID specific keyring */
742 struct key *session_keyring; /* UID's default session keyring */
743#endif
744
745 /* Hash table maintenance information */
Pavel Emelyanov735de222007-09-18 22:46:44 -0700746 struct hlist_node uidhash_node;
Eric W. Biederman7b44ab92011-11-16 23:20:58 -0800747 kuid_t uid;
Srivatsa Vaddagiri24e377a2007-10-15 17:00:09 +0200748
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200749#ifdef CONFIG_PERF_EVENTS
Peter Zijlstra789f90f2009-05-15 15:19:27 +0200750 atomic_long_t locked_vm;
751#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752};
753
Kay Sieverseb41d942007-11-02 13:47:53 +0100754extern int uids_sysfs_init(void);
Dhaval Giani5cb350b2007-10-15 17:00:14 +0200755
Eric W. Biederman7b44ab92011-11-16 23:20:58 -0800756extern struct user_struct *find_user(kuid_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
758extern struct user_struct root_user;
759#define INIT_USER (&root_user)
760
David Howellsb6dff3e2008-11-14 10:39:16 +1100761
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762struct backing_dev_info;
763struct reclaim_state;
764
Chandra Seetharaman52f17b62006-07-14 00:24:38 -0700765#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766struct sched_info {
767 /* cumulative counters */
Ingo Molnar2d723762007-10-15 17:00:12 +0200768 unsigned long pcount; /* # of times run on this cpu */
Ken Chen9c2c4802008-12-16 23:41:22 -0800769 unsigned long long run_delay; /* time spent waiting on a runqueue */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770
771 /* timestamps */
Balbir Singh172ba842007-07-09 18:52:00 +0200772 unsigned long long last_arrival,/* when we last ran on a cpu */
773 last_queued; /* when we were last queued to run */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774};
Chandra Seetharaman52f17b62006-07-14 00:24:38 -0700775#endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Shailabh Nagarca74e922006-07-14 00:24:36 -0700777#ifdef CONFIG_TASK_DELAY_ACCT
778struct task_delay_info {
779 spinlock_t lock;
780 unsigned int flags; /* Private per-task flags */
781
782 /* For each stat XXX, add following, aligned appropriately
783 *
784 * struct timespec XXX_start, XXX_end;
785 * u64 XXX_delay;
786 * u32 XXX_count;
787 *
788 * Atomicity of updates to XXX_delay, XXX_count protected by
789 * single lock above (split into XXX_lock if contention is an issue).
790 */
Shailabh Nagar0ff92242006-07-14 00:24:37 -0700791
792 /*
793 * XXX_count is incremented on every XXX operation, the delay
794 * associated with the operation is added to XXX_delay.
795 * XXX_delay contains the accumulated delay time in nanoseconds.
796 */
797 struct timespec blkio_start, blkio_end; /* Shared by blkio, swapin */
798 u64 blkio_delay; /* wait for sync block io completion */
799 u64 swapin_delay; /* wait for swapin block io completion */
800 u32 blkio_count; /* total count of the number of sync block */
801 /* io operations performed */
802 u32 swapin_count; /* total count of the number of swapin block */
803 /* io operations performed */
Keika Kobayashi873b4772008-07-25 01:48:52 -0700804
805 struct timespec freepages_start, freepages_end;
806 u64 freepages_delay; /* wait for memory reclaim */
807 u32 freepages_count; /* total count of memory reclaim */
Shailabh Nagarca74e922006-07-14 00:24:36 -0700808};
Chandra Seetharaman52f17b62006-07-14 00:24:38 -0700809#endif /* CONFIG_TASK_DELAY_ACCT */
810
811static inline int sched_info_on(void)
812{
813#ifdef CONFIG_SCHEDSTATS
814 return 1;
815#elif defined(CONFIG_TASK_DELAY_ACCT)
816 extern int delayacct_on;
817 return delayacct_on;
818#else
819 return 0;
Shailabh Nagarca74e922006-07-14 00:24:36 -0700820#endif
Chandra Seetharaman52f17b62006-07-14 00:24:38 -0700821}
Shailabh Nagarca74e922006-07-14 00:24:36 -0700822
Ingo Molnard15bcfd2007-07-09 18:51:57 +0200823enum cpu_idle_type {
824 CPU_IDLE,
825 CPU_NOT_IDLE,
826 CPU_NEWLY_IDLE,
827 CPU_MAX_IDLE_TYPES
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828};
829
830/*
Nikhil Raoc8b28112011-05-18 14:37:48 -0700831 * Increase resolution of nice-level calculations for 64-bit architectures.
832 * The extra resolution improves shares distribution and load balancing of
833 * low-weight task groups (eg. nice +19 on an autogroup), deeper taskgroup
834 * hierarchies, especially on larger systems. This is not a user-visible change
835 * and does not change the user-interface for setting shares/weights.
836 *
837 * We increase resolution only if we have enough bits to allow this increased
838 * resolution (i.e. BITS_PER_LONG > 32). The costs for increasing resolution
839 * when BITS_PER_LONG <= 32 are pretty high and the returns do not justify the
840 * increased costs.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 */
Peter Zijlstrae4c2fb02011-07-05 10:56:32 +0200842#if 0 /* BITS_PER_LONG > 32 -- currently broken: it increases power usage under light load */
Nikhil Raoc8b28112011-05-18 14:37:48 -0700843# define SCHED_LOAD_RESOLUTION 10
844# define scale_load(w) ((w) << SCHED_LOAD_RESOLUTION)
845# define scale_load_down(w) ((w) >> SCHED_LOAD_RESOLUTION)
846#else
847# define SCHED_LOAD_RESOLUTION 0
848# define scale_load(w) (w)
849# define scale_load_down(w) (w)
850#endif
Ingo Molnar9aa7b362007-07-09 18:51:58 +0200851
Nikhil Raoc8b28112011-05-18 14:37:48 -0700852#define SCHED_LOAD_SHIFT (10 + SCHED_LOAD_RESOLUTION)
Ingo Molnar9aa7b362007-07-09 18:51:58 +0200853#define SCHED_LOAD_SCALE (1L << SCHED_LOAD_SHIFT)
854
Nikhil Rao1399fa72011-05-18 10:09:39 -0700855/*
856 * Increase resolution of cpu_power calculations
857 */
858#define SCHED_POWER_SHIFT 10
859#define SCHED_POWER_SCALE (1L << SCHED_POWER_SHIFT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860
Nikhil Rao1399fa72011-05-18 10:09:39 -0700861/*
862 * sched-domains (multiprocessor balancing) declarations:
863 */
Peter Williams2dd73a42006-06-27 02:54:34 -0700864#ifdef CONFIG_SMP
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200865#define SD_LOAD_BALANCE 0x0001 /* Do load balancing on this domain. */
866#define SD_BALANCE_NEWIDLE 0x0002 /* Balance when about to become idle */
867#define SD_BALANCE_EXEC 0x0004 /* Balance on exec */
868#define SD_BALANCE_FORK 0x0008 /* Balance on fork, clone */
Peter Zijlstrac88d5912009-09-10 13:50:02 +0200869#define SD_BALANCE_WAKE 0x0010 /* Balance on wakeup */
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200870#define SD_WAKE_AFFINE 0x0020 /* Wake task to waking CPU */
Peter Zijlstra59abf022009-09-16 08:28:30 +0200871#define SD_PREFER_LOCAL 0x0040 /* Prefer to keep tasks local to this domain */
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200872#define SD_SHARE_CPUPOWER 0x0080 /* Domain members share cpu power */
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200873#define SD_SHARE_PKG_RESOURCES 0x0200 /* Domain members share cpu pkg resources */
874#define SD_SERIALIZE 0x0400 /* Only a single load balancing instance */
Michael Neuling532cb4c2010-06-08 14:57:02 +1000875#define SD_ASYM_PACKING 0x0800 /* Place busy groups earlier in the domain */
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200876#define SD_PREFER_SIBLING 0x1000 /* Prefer to place tasks in a sibling domain */
Peter Zijlstrae3589f62011-07-15 10:35:52 +0200877#define SD_OVERLAP 0x2000 /* sched_domains of this level overlap */
Siddha, Suresh B5c45bf22006-06-27 02:54:42 -0700878
Michael Neuling532cb4c2010-06-08 14:57:02 +1000879extern int __weak arch_sd_sibiling_asym_packing(void);
880
Peter Zijlstra9c3f75c2011-07-14 13:00:06 +0200881struct sched_group_power {
Peter Zijlstrae3589f62011-07-15 10:35:52 +0200882 atomic_t ref;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 /*
884 * CPU power of this group, SCHED_LOAD_SCALE being max power for a
Peter Zijlstra18a38852009-09-01 10:34:39 +0200885 * single CPU.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 */
Peter Zijlstra9c3f75c2011-07-14 13:00:06 +0200887 unsigned int power, power_orig;
Vincent Guittot4ec44122011-12-12 20:21:08 +0100888 unsigned long next_update;
Suresh Siddha69e1e812011-12-01 17:07:33 -0800889 /*
890 * Number of busy cpus in this group.
891 */
892 atomic_t nr_busy_cpus;
Peter Zijlstrac1174872012-05-31 14:47:33 +0200893
894 unsigned long cpumask[0]; /* iteration mask */
Peter Zijlstra9c3f75c2011-07-14 13:00:06 +0200895};
896
897struct sched_group {
898 struct sched_group *next; /* Must be a circular list */
899 atomic_t ref;
900
Suresh Siddhaaae6d3d2010-09-17 15:02:32 -0700901 unsigned int group_weight;
Peter Zijlstra9c3f75c2011-07-14 13:00:06 +0200902 struct sched_group_power *sgp;
Rusty Russell6c99e9a2008-11-25 02:35:04 +1030903
Ingo Molnar4200efd2009-05-19 09:22:19 +0200904 /*
905 * The CPUs this group covers.
906 *
907 * NOTE: this field is variable length. (Allocated dynamically
908 * by attaching extra space to the end of the structure,
909 * depending on how many CPUs the kernel has booted up with)
Ingo Molnar4200efd2009-05-19 09:22:19 +0200910 */
911 unsigned long cpumask[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912};
913
Rusty Russell758b2cd2008-11-25 02:35:04 +1030914static inline struct cpumask *sched_group_cpus(struct sched_group *sg)
915{
Rusty Russell6c99e9a2008-11-25 02:35:04 +1030916 return to_cpumask(sg->cpumask);
Rusty Russell758b2cd2008-11-25 02:35:04 +1030917}
918
Peter Zijlstrac1174872012-05-31 14:47:33 +0200919/*
920 * cpumask masking which cpus in the group are allowed to iterate up the domain
921 * tree.
922 */
923static inline struct cpumask *sched_group_mask(struct sched_group *sg)
924{
925 return to_cpumask(sg->sgp->cpumask);
926}
927
Peter Zijlstra029632f2011-10-25 10:00:11 +0200928/**
929 * group_first_cpu - Returns the first cpu in the cpumask of a sched_group.
930 * @group: The group whose first cpu is to be returned.
931 */
932static inline unsigned int group_first_cpu(struct sched_group *group)
933{
934 return cpumask_first(sched_group_cpus(group));
935}
936
Hidetoshi Seto1d3504f2008-04-15 14:04:23 +0900937struct sched_domain_attr {
938 int relax_domain_level;
939};
940
941#define SD_ATTR_INIT (struct sched_domain_attr) { \
942 .relax_domain_level = -1, \
943}
944
Peter Zijlstra60495e72011-04-07 14:10:04 +0200945extern int sched_domain_level_max;
946
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947struct sched_domain {
948 /* These fields must be setup */
949 struct sched_domain *parent; /* top domain must be null terminated */
Siddha, Suresh B1a848872006-10-03 01:14:08 -0700950 struct sched_domain *child; /* bottom domain must be null terminated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 struct sched_group *groups; /* the balancing groups of the domain */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 unsigned long min_interval; /* Minimum balance interval ms */
953 unsigned long max_interval; /* Maximum balance interval ms */
954 unsigned int busy_factor; /* less balancing by factor if busy */
955 unsigned int imbalance_pct; /* No balance until over watermark */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 unsigned int cache_nice_tries; /* Leave cache hot tasks for # tries */
Nick Piggin78979862005-06-25 14:57:13 -0700957 unsigned int busy_idx;
958 unsigned int idle_idx;
959 unsigned int newidle_idx;
960 unsigned int wake_idx;
Nick Piggin147cbb42005-06-25 14:57:19 -0700961 unsigned int forkexec_idx;
Peter Zijlstraa52bfd72009-09-01 10:34:35 +0200962 unsigned int smt_gain;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 int flags; /* See SD_* */
Peter Zijlstra60495e72011-04-07 14:10:04 +0200964 int level;
Mike Galbraith970e1782012-06-12 05:18:32 +0200965 int idle_buddy; /* cpu assigned to select_idle_sibling() */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966
967 /* Runtime fields. */
968 unsigned long last_balance; /* init to jiffies. units in jiffies */
969 unsigned int balance_interval; /* initialise to 1. units in ms. */
970 unsigned int nr_balance_failed; /* initialise to 0 */
971
Peter Zijlstra2398f2c2008-06-27 13:41:35 +0200972 u64 last_update;
973
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974#ifdef CONFIG_SCHEDSTATS
975 /* load_balance() stats */
Ken Chen480b9432007-10-18 21:32:56 +0200976 unsigned int lb_count[CPU_MAX_IDLE_TYPES];
977 unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
978 unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
979 unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
980 unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
981 unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
982 unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
983 unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984
985 /* Active load balancing */
Ken Chen480b9432007-10-18 21:32:56 +0200986 unsigned int alb_count;
987 unsigned int alb_failed;
988 unsigned int alb_pushed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989
Nick Piggin68767a02005-06-25 14:57:20 -0700990 /* SD_BALANCE_EXEC stats */
Ken Chen480b9432007-10-18 21:32:56 +0200991 unsigned int sbe_count;
992 unsigned int sbe_balanced;
993 unsigned int sbe_pushed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994
Nick Piggin68767a02005-06-25 14:57:20 -0700995 /* SD_BALANCE_FORK stats */
Ken Chen480b9432007-10-18 21:32:56 +0200996 unsigned int sbf_count;
997 unsigned int sbf_balanced;
998 unsigned int sbf_pushed;
Nick Piggin68767a02005-06-25 14:57:20 -0700999
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 /* try_to_wake_up() stats */
Ken Chen480b9432007-10-18 21:32:56 +02001001 unsigned int ttwu_wake_remote;
1002 unsigned int ttwu_move_affine;
1003 unsigned int ttwu_move_balance;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004#endif
Ingo Molnara5d8c342008-10-09 11:35:51 +02001005#ifdef CONFIG_SCHED_DEBUG
1006 char *name;
1007#endif
Peter Zijlstradce840a2011-04-07 14:09:50 +02001008 union {
1009 void *private; /* used during construction */
1010 struct rcu_head rcu; /* used during destruction */
1011 };
Rusty Russell6c99e9a2008-11-25 02:35:04 +10301012
Peter Zijlstra669c55e2010-04-16 14:59:29 +02001013 unsigned int span_weight;
Ingo Molnar4200efd2009-05-19 09:22:19 +02001014 /*
1015 * Span of all CPUs in this domain.
1016 *
1017 * NOTE: this field is variable length. (Allocated dynamically
1018 * by attaching extra space to the end of the structure,
1019 * depending on how many CPUs the kernel has booted up with)
Ingo Molnar4200efd2009-05-19 09:22:19 +02001020 */
1021 unsigned long span[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022};
1023
Rusty Russell758b2cd2008-11-25 02:35:04 +10301024static inline struct cpumask *sched_domain_span(struct sched_domain *sd)
1025{
Rusty Russell6c99e9a2008-11-25 02:35:04 +10301026 return to_cpumask(sd->span);
Rusty Russell758b2cd2008-11-25 02:35:04 +10301027}
1028
Rusty Russellacc3f5d2009-11-03 14:53:40 +10301029extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
Hidetoshi Seto1d3504f2008-04-15 14:04:23 +09001030 struct sched_domain_attr *dattr_new);
Paul Jackson029190c2007-10-18 23:40:20 -07001031
Rusty Russellacc3f5d2009-11-03 14:53:40 +10301032/* Allocate an array of sched domains, for partition_sched_domains(). */
1033cpumask_var_t *alloc_sched_domains(unsigned int ndoms);
1034void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms);
1035
Ingo Molnar06aaf762008-12-18 21:30:23 +01001036/* Test a flag in parent sched domain */
1037static inline int test_sd_parent(struct sched_domain *sd, int flag)
1038{
1039 if (sd->parent && (sd->parent->flags & flag))
1040 return 1;
1041
1042 return 0;
1043}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044
Peter Zijlstra47fe38f2009-09-02 13:49:18 +02001045unsigned long default_scale_freq_power(struct sched_domain *sd, int cpu);
1046unsigned long default_scale_smt_power(struct sched_domain *sd, int cpu);
1047
Peter Zijlstra39be3502012-01-26 12:44:34 +01001048bool cpus_share_cache(int this_cpu, int that_cpu);
1049
Ingo Molnar1b427c12008-07-18 14:01:39 +02001050#else /* CONFIG_SMP */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051
Ingo Molnar1b427c12008-07-18 14:01:39 +02001052struct sched_domain_attr;
1053
1054static inline void
Rusty Russellacc3f5d2009-11-03 14:53:40 +10301055partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
Ingo Molnar1b427c12008-07-18 14:01:39 +02001056 struct sched_domain_attr *dattr_new)
Con Kolivasd02c7a82007-07-26 13:40:43 +02001057{
Con Kolivasd02c7a82007-07-26 13:40:43 +02001058}
Peter Zijlstra39be3502012-01-26 12:44:34 +01001059
1060static inline bool cpus_share_cache(int this_cpu, int that_cpu)
1061{
1062 return true;
1063}
1064
Ingo Molnar1b427c12008-07-18 14:01:39 +02001065#endif /* !CONFIG_SMP */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066
Peter Zijlstra47fe38f2009-09-02 13:49:18 +02001067
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068struct io_context; /* See blkdev.h */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070
Chen, Kenneth W383f2832005-09-09 13:02:02 -07001071#ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
Ingo Molnar36c8b582006-07-03 00:25:41 -07001072extern void prefetch_stack(struct task_struct *t);
Chen, Kenneth W383f2832005-09-09 13:02:02 -07001073#else
1074static inline void prefetch_stack(struct task_struct *t) { }
1075#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076
1077struct audit_context; /* See audit.c */
1078struct mempolicy;
Jens Axboeb92ce552006-04-11 13:52:07 +02001079struct pipe_inode_info;
Serge E. Hallyn4865ecf2006-10-02 02:18:14 -07001080struct uts_namespace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081
Ingo Molnar20b8a592007-07-09 18:51:58 +02001082struct rq;
1083struct sched_domain;
1084
Peter Zijlstra7d478722009-09-14 19:55:44 +02001085/*
1086 * wake flags
1087 */
1088#define WF_SYNC 0x01 /* waker goes to sleep after wakup */
Peter Zijlstraa7558e02009-09-14 20:02:34 +02001089#define WF_FORK 0x02 /* child wakeup after fork */
Peter Zijlstraf339b9d2011-05-31 10:49:20 +02001090#define WF_MIGRATED 0x04 /* internal use, task got migrated */
Peter Zijlstra7d478722009-09-14 19:55:44 +02001091
Peter Zijlstra371fd7e2010-03-24 16:38:48 +01001092#define ENQUEUE_WAKEUP 1
Peter Zijlstra74f8e4b2011-04-05 17:23:47 +02001093#define ENQUEUE_HEAD 2
1094#ifdef CONFIG_SMP
1095#define ENQUEUE_WAKING 4 /* sched_class::task_waking was called */
1096#else
1097#define ENQUEUE_WAKING 0
1098#endif
Peter Zijlstra371fd7e2010-03-24 16:38:48 +01001099
1100#define DEQUEUE_SLEEP 1
1101
Ingo Molnar20b8a592007-07-09 18:51:58 +02001102struct sched_class {
Ingo Molnar5522d5d2007-10-15 17:00:12 +02001103 const struct sched_class *next;
Ingo Molnar20b8a592007-07-09 18:51:58 +02001104
Peter Zijlstra371fd7e2010-03-24 16:38:48 +01001105 void (*enqueue_task) (struct rq *rq, struct task_struct *p, int flags);
1106 void (*dequeue_task) (struct rq *rq, struct task_struct *p, int flags);
Dmitry Adamushko4530d7a2007-10-15 17:00:08 +02001107 void (*yield_task) (struct rq *rq);
Mike Galbraithd95f4122011-02-01 09:50:51 -05001108 bool (*yield_to_task) (struct rq *rq, struct task_struct *p, bool preempt);
Ingo Molnar20b8a592007-07-09 18:51:58 +02001109
Peter Zijlstra7d478722009-09-14 19:55:44 +02001110 void (*check_preempt_curr) (struct rq *rq, struct task_struct *p, int flags);
Ingo Molnar20b8a592007-07-09 18:51:58 +02001111
Ingo Molnarfb8d4722007-08-09 11:16:48 +02001112 struct task_struct * (*pick_next_task) (struct rq *rq);
Ingo Molnar31ee5292007-08-09 11:16:49 +02001113 void (*put_prev_task) (struct rq *rq, struct task_struct *p);
Ingo Molnar20b8a592007-07-09 18:51:58 +02001114
Peter Williams681f3e62007-10-24 18:23:51 +02001115#ifdef CONFIG_SMP
Peter Zijlstra7608dec2011-04-05 17:23:46 +02001116 int (*select_task_rq)(struct task_struct *p, int sd_flag, int flags);
Li Zefan4ce72a22008-10-22 15:25:26 +08001117
Steven Rostedt9a897c52008-01-25 21:08:22 +01001118 void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
1119 void (*post_schedule) (struct rq *this_rq);
Peter Zijlstra74f8e4b2011-04-05 17:23:47 +02001120 void (*task_waking) (struct task_struct *task);
Peter Zijlstraefbbd052009-12-16 18:04:40 +01001121 void (*task_woken) (struct rq *this_rq, struct task_struct *task);
Peter Williamse1d14842007-10-24 18:23:51 +02001122
Mike Traviscd8ba7c2008-03-26 14:23:49 -07001123 void (*set_cpus_allowed)(struct task_struct *p,
Rusty Russell96f874e2008-11-25 02:35:14 +10301124 const struct cpumask *newmask);
Gregory Haskins57d885f2008-01-25 21:08:18 +01001125
Gregory Haskins1f11eb62008-06-04 15:04:05 -04001126 void (*rq_online)(struct rq *rq);
1127 void (*rq_offline)(struct rq *rq);
Li Zefan4ce72a22008-10-22 15:25:26 +08001128#endif
1129
1130 void (*set_curr_task) (struct rq *rq);
1131 void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
Peter Zijlstracd29fe62009-11-27 17:32:46 +01001132 void (*task_fork) (struct task_struct *p);
Steven Rostedtcb469842008-01-25 21:08:22 +01001133
Peter Zijlstrada7a7352011-01-17 17:03:27 +01001134 void (*switched_from) (struct rq *this_rq, struct task_struct *task);
1135 void (*switched_to) (struct rq *this_rq, struct task_struct *task);
Steven Rostedtcb469842008-01-25 21:08:22 +01001136 void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
Peter Zijlstrada7a7352011-01-17 17:03:27 +01001137 int oldprio);
Peter Zijlstra810b3812008-02-29 15:21:01 -05001138
Thomas Gleixnerdba091b2009-12-09 09:32:03 +01001139 unsigned int (*get_rr_interval) (struct rq *rq,
1140 struct task_struct *task);
Peter Williams0d721ce2009-09-21 01:31:53 +00001141
Peter Zijlstra810b3812008-02-29 15:21:01 -05001142#ifdef CONFIG_FAIR_GROUP_SCHED
Peter Zijlstrab2b5ce02010-10-15 15:24:15 +02001143 void (*task_move_group) (struct task_struct *p, int on_rq);
Peter Zijlstra810b3812008-02-29 15:21:01 -05001144#endif
Ingo Molnar20b8a592007-07-09 18:51:58 +02001145};
1146
1147struct load_weight {
1148 unsigned long weight, inv_weight;
1149};
1150
Ingo Molnar94c18222007-08-02 17:41:40 +02001151#ifdef CONFIG_SCHEDSTATS
Lucas De Marchi41acab82010-03-10 23:37:45 -03001152struct sched_statistics {
Ingo Molnar94c18222007-08-02 17:41:40 +02001153 u64 wait_start;
1154 u64 wait_max;
Arjan van de Ven6d082592008-01-25 21:08:35 +01001155 u64 wait_count;
1156 u64 wait_sum;
Arjan van de Ven8f0dfc32009-07-20 11:26:58 -07001157 u64 iowait_count;
1158 u64 iowait_sum;
Ingo Molnar94c18222007-08-02 17:41:40 +02001159
1160 u64 sleep_start;
Ingo Molnar20b8a592007-07-09 18:51:58 +02001161 u64 sleep_max;
Ingo Molnar94c18222007-08-02 17:41:40 +02001162 s64 sum_sleep_runtime;
1163
1164 u64 block_start;
Ingo Molnar20b8a592007-07-09 18:51:58 +02001165 u64 block_max;
1166 u64 exec_max;
Ingo Molnareba1ed42007-10-15 17:00:02 +02001167 u64 slice_max;
Ingo Molnarcc367732007-10-15 17:00:18 +02001168
Ingo Molnarcc367732007-10-15 17:00:18 +02001169 u64 nr_migrations_cold;
1170 u64 nr_failed_migrations_affine;
1171 u64 nr_failed_migrations_running;
1172 u64 nr_failed_migrations_hot;
1173 u64 nr_forced_migrations;
Ingo Molnarcc367732007-10-15 17:00:18 +02001174
1175 u64 nr_wakeups;
1176 u64 nr_wakeups_sync;
1177 u64 nr_wakeups_migrate;
1178 u64 nr_wakeups_local;
1179 u64 nr_wakeups_remote;
1180 u64 nr_wakeups_affine;
1181 u64 nr_wakeups_affine_attempts;
1182 u64 nr_wakeups_passive;
1183 u64 nr_wakeups_idle;
Lucas De Marchi41acab82010-03-10 23:37:45 -03001184};
1185#endif
1186
1187struct sched_entity {
1188 struct load_weight load; /* for load-balancing */
1189 struct rb_node run_node;
1190 struct list_head group_node;
1191 unsigned int on_rq;
1192
1193 u64 exec_start;
1194 u64 sum_exec_runtime;
1195 u64 vruntime;
1196 u64 prev_sum_exec_runtime;
1197
Lucas De Marchi41acab82010-03-10 23:37:45 -03001198 u64 nr_migrations;
1199
Lucas De Marchi41acab82010-03-10 23:37:45 -03001200#ifdef CONFIG_SCHEDSTATS
1201 struct sched_statistics statistics;
Ingo Molnar94c18222007-08-02 17:41:40 +02001202#endif
1203
Ingo Molnar20b8a592007-07-09 18:51:58 +02001204#ifdef CONFIG_FAIR_GROUP_SCHED
1205 struct sched_entity *parent;
1206 /* rq on which this entity is (to be) queued: */
1207 struct cfs_rq *cfs_rq;
1208 /* rq "owned" by this entity/group: */
1209 struct cfs_rq *my_q;
1210#endif
1211};
Ingo Molnar70b97a72006-07-03 00:25:42 -07001212
Peter Zijlstrafa717062008-01-25 21:08:27 +01001213struct sched_rt_entity {
1214 struct list_head run_list;
Peter Zijlstra78f2c7d2008-01-25 21:08:27 +01001215 unsigned long timeout;
Richard Kennedybee367e2008-08-01 13:24:08 +01001216 unsigned int time_slice;
Peter Zijlstra6f505b12008-01-25 21:08:30 +01001217
Peter Zijlstra58d6c2d2008-04-19 19:45:00 +02001218 struct sched_rt_entity *back;
Peter Zijlstra052f1dc2008-02-13 15:45:40 +01001219#ifdef CONFIG_RT_GROUP_SCHED
Peter Zijlstra6f505b12008-01-25 21:08:30 +01001220 struct sched_rt_entity *parent;
1221 /* rq on which this entity is (to be) queued: */
1222 struct rt_rq *rt_rq;
1223 /* rq "owned" by this entity/group: */
1224 struct rt_rq *my_q;
1225#endif
Peter Zijlstrafa717062008-01-25 21:08:27 +01001226};
1227
Hiroshi Shimamotode5bdff2012-02-16 14:52:21 +09001228/*
1229 * default timeslice is 100 msecs (used only for SCHED_RR tasks).
1230 * Timeslices get refilled after they expire.
1231 */
1232#define RR_TIMESLICE (100 * HZ / 1000)
1233
Paul E. McKenney86848962009-08-27 15:00:12 -07001234struct rcu_node;
1235
Peter Zijlstra8dc85d52010-09-02 16:50:03 +02001236enum perf_event_task_context {
1237 perf_invalid_context = -1,
1238 perf_hw_context = 0,
Peter Zijlstra89a1e182010-09-07 17:34:50 +02001239 perf_sw_context,
Peter Zijlstra8dc85d52010-09-02 16:50:03 +02001240 perf_nr_task_contexts,
1241};
1242
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243struct task_struct {
1244 volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
Roman Zippelf7e42172007-05-09 02:35:17 -07001245 void *stack;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 atomic_t usage;
William Cohen97dc32c2007-05-08 00:23:41 -07001247 unsigned int flags; /* per process flags, defined below */
1248 unsigned int ptrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249
Peter Williams2dd73a42006-06-27 02:54:34 -07001250#ifdef CONFIG_SMP
Peter Zijlstrafa14ff42011-09-12 13:06:17 +02001251 struct llist_node wake_entry;
Peter Zijlstra3ca7a442011-04-05 17:23:40 +02001252 int on_cpu;
Nick Piggin4866cde2005-06-25 14:57:23 -07001253#endif
Peter Zijlstrafd2f4412011-04-05 17:23:44 +02001254 int on_rq;
Ingo Molnar50e645a2007-07-09 18:52:00 +02001255
Ingo Molnarb29739f2006-06-27 02:54:51 -07001256 int prio, static_prio, normal_prio;
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001257 unsigned int rt_priority;
Ingo Molnar5522d5d2007-10-15 17:00:12 +02001258 const struct sched_class *sched_class;
Ingo Molnar20b8a592007-07-09 18:51:58 +02001259 struct sched_entity se;
Peter Zijlstrafa717062008-01-25 21:08:27 +01001260 struct sched_rt_entity rt;
Peter Zijlstra8323f262012-06-22 13:36:05 +02001261#ifdef CONFIG_CGROUP_SCHED
1262 struct task_group *sched_task_group;
1263#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264
Avi Kivitye107be32007-07-26 13:40:43 +02001265#ifdef CONFIG_PREEMPT_NOTIFIERS
1266 /* list of struct preempt_notifier: */
1267 struct hlist_head preempt_notifiers;
1268#endif
1269
Alexey Dobriyan18796aa2007-10-16 23:30:26 -07001270 /*
1271 * fpu_counter contains the number of consecutive context switches
1272 * that the FPU is used. If this is over a threshold, the lazy fpu
1273 * saving becomes unlazy to save the trap. This is an unsigned char
1274 * so that after 256 times the counter wraps and the behavior turns
1275 * lazy again; this to deal with bursty apps that only use FPU for
1276 * a short time
1277 */
1278 unsigned char fpu_counter;
Alexey Dobriyan6c5c9342006-09-29 01:59:40 -07001279#ifdef CONFIG_BLK_DEV_IO_TRACE
Jens Axboe2056a782006-03-23 20:00:26 +01001280 unsigned int btrace_seq;
Alexey Dobriyan6c5c9342006-09-29 01:59:40 -07001281#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282
William Cohen97dc32c2007-05-08 00:23:41 -07001283 unsigned int policy;
Peter Zijlstra29baa742012-04-23 12:11:21 +02001284 int nr_cpus_allowed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 cpumask_t cpus_allowed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286
Paul E. McKenneya57eb942010-06-29 16:49:16 -07001287#ifdef CONFIG_PREEMPT_RCU
Paul E. McKenneye260be62008-01-25 21:08:24 +01001288 int rcu_read_lock_nesting;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001289 char rcu_read_unlock_special;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001290 struct list_head rcu_node_entry;
Paul E. McKenneya57eb942010-06-29 16:49:16 -07001291#endif /* #ifdef CONFIG_PREEMPT_RCU */
1292#ifdef CONFIG_TREE_PREEMPT_RCU
1293 struct rcu_node *rcu_blocked_node;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001294#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
Paul E. McKenney24278d12010-09-27 17:25:23 -07001295#ifdef CONFIG_RCU_BOOST
1296 struct rt_mutex *rcu_boost_mutex;
1297#endif /* #ifdef CONFIG_RCU_BOOST */
Paul E. McKenneye260be62008-01-25 21:08:24 +01001298
Chandra Seetharaman52f17b62006-07-14 00:24:38 -07001299#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 struct sched_info sched_info;
1301#endif
1302
1303 struct list_head tasks;
Dario Faggioli806c09a2010-11-30 19:51:33 +01001304#ifdef CONFIG_SMP
Gregory Haskins917b6272008-12-29 09:39:53 -05001305 struct plist_node pushable_tasks;
Dario Faggioli806c09a2010-11-30 19:51:33 +01001306#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307
1308 struct mm_struct *mm, *active_mm;
Jiri Kosina4471a672011-04-14 15:22:09 -07001309#ifdef CONFIG_COMPAT_BRK
1310 unsigned brk_randomized:1;
1311#endif
KAMEZAWA Hiroyuki34e55232010-03-05 13:41:40 -08001312#if defined(SPLIT_RSS_COUNTING)
1313 struct task_rss_stat rss_stat;
1314#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315/* task state */
William Cohen97dc32c2007-05-08 00:23:41 -07001316 int exit_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 int exit_code, exit_signal;
1318 int pdeath_signal; /* The signal sent when the parent dies */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001319 unsigned int jobctl; /* JOBCTL_*, siglock protected */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 /* ??? */
William Cohen97dc32c2007-05-08 00:23:41 -07001321 unsigned int personality;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 unsigned did_exec:1;
Kentaro Takedaf9ce1f12009-02-05 17:18:11 +09001323 unsigned in_execve:1; /* Tell the LSMs that the process is doing an
1324 * execve */
Arjan van de Ven8f0dfc32009-07-20 11:26:58 -07001325 unsigned in_iowait:1;
1326
Andy Lutomirski259e5e62012-04-12 16:47:50 -05001327 /* task may not gain privileges */
1328 unsigned no_new_privs:1;
Lennart Poetteringca94c442009-06-15 17:17:47 +02001329
1330 /* Revert to default priority/policy when forking */
1331 unsigned sched_reset_on_fork:1;
Peter Zijlstraa8e4f2e2011-04-05 17:23:49 +02001332 unsigned sched_contributes_to_load:1;
Lennart Poetteringca94c442009-06-15 17:17:47 +02001333
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 pid_t pid;
1335 pid_t tgid;
Arjan van de Ven0a425402006-09-26 10:52:38 +02001336
Hiroshi Shimamoto13145622009-08-18 15:06:02 +09001337#ifdef CONFIG_CC_STACKPROTECTOR
Arjan van de Ven0a425402006-09-26 10:52:38 +02001338 /* Canary value for the -fstack-protector gcc feature */
1339 unsigned long stack_canary;
Hiroshi Shimamoto13145622009-08-18 15:06:02 +09001340#endif
Oleg Nesterov4d1d61a2012-05-11 10:59:08 +10001341 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 * pointers to (original) parent process, youngest child, younger sibling,
Oleg Nesterov4d1d61a2012-05-11 10:59:08 +10001343 * older sibling, respectively. (p->father can be replaced with
Roland McGrathf4700212008-03-24 18:36:23 -07001344 * p->real_parent->pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 */
Kees Cookabd63bc2011-12-14 14:39:26 -08001346 struct task_struct __rcu *real_parent; /* real parent process */
1347 struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 /*
Roland McGrathf4700212008-03-24 18:36:23 -07001349 * children/sibling forms the list of my natural children
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 */
1351 struct list_head children; /* list of my children */
1352 struct list_head sibling; /* linkage in my parent's children list */
1353 struct task_struct *group_leader; /* threadgroup leader */
1354
Roland McGrathf4700212008-03-24 18:36:23 -07001355 /*
1356 * ptraced is the list of tasks this task is using ptrace on.
1357 * This includes both natural children and PTRACE_ATTACH targets.
1358 * p->ptrace_entry is p's link on the p->parent->ptraced list.
1359 */
1360 struct list_head ptraced;
1361 struct list_head ptrace_entry;
1362
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 /* PID/PID hash table linkage. */
Eric W. Biederman92476d72006-03-31 02:31:42 -08001364 struct pid_link pids[PIDTYPE_MAX];
Oleg Nesterov47e65322006-03-28 16:11:25 -08001365 struct list_head thread_group;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366
1367 struct completion *vfork_done; /* for vfork() */
1368 int __user *set_child_tid; /* CLONE_CHILD_SETTID */
1369 int __user *clear_child_tid; /* CLONE_CHILD_CLEARTID */
1370
Michael Neulingc66f08b2007-10-18 03:06:34 -07001371 cputime_t utime, stime, utimescaled, stimescaled;
Laurent Vivier9ac52312007-10-15 17:00:19 +02001372 cputime_t gtime;
Hidetoshi Setod99ca3b2009-12-02 17:26:47 +09001373#ifndef CONFIG_VIRT_CPU_ACCOUNTING
Balbir Singh93018992007-10-30 00:26:32 +01001374 cputime_t prev_utime, prev_stime;
Hidetoshi Setod99ca3b2009-12-02 17:26:47 +09001375#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 unsigned long nvcsw, nivcsw; /* context switch counts */
Tomas Janousek924b42d2007-07-15 23:39:42 -07001377 struct timespec start_time; /* monotonic time */
1378 struct timespec real_start_time; /* boot based time */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
1380 unsigned long min_flt, maj_flt;
1381
Frank Mayharf06febc2008-09-12 09:54:39 -07001382 struct task_cputime cputime_expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 struct list_head cpu_timers[3];
1384
1385/* process credentials */
Arnd Bergmann1b0ba1c2010-02-24 19:45:09 +01001386 const struct cred __rcu *real_cred; /* objective and real subjective task
David Howells3b11a1d2008-11-14 10:39:26 +11001387 * credentials (COW) */
Arnd Bergmann1b0ba1c2010-02-24 19:45:09 +01001388 const struct cred __rcu *cred; /* effective (overridable) subjective task
David Howells3b11a1d2008-11-14 10:39:26 +11001389 * credentials (COW) */
Paolo 'Blaisorblade' Giarrusso36772092005-05-05 16:16:12 -07001390 char comm[TASK_COMM_LEN]; /* executable name excluding path
1391 - access with [gs]et_task_comm (which lock
1392 it with task_lock())
Linus Torvalds221af7f2010-01-28 22:14:42 -08001393 - initialized normally by setup_new_exec */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394/* file system info */
1395 int link_count, total_link_count;
Alexey Dobriyan3d5b6fc2006-09-29 01:59:40 -07001396#ifdef CONFIG_SYSVIPC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397/* ipc stuff */
1398 struct sysv_sem sysvsem;
Alexey Dobriyan3d5b6fc2006-09-29 01:59:40 -07001399#endif
Mandeep Singh Bainese162b392009-01-15 11:08:40 -08001400#ifdef CONFIG_DETECT_HUNG_TASK
Ingo Molnar82a1fcb2008-01-25 21:08:02 +01001401/* hung task detection */
Ingo Molnar82a1fcb2008-01-25 21:08:02 +01001402 unsigned long last_switch_count;
1403#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404/* CPU-specific state of this task */
1405 struct thread_struct thread;
1406/* filesystem information */
1407 struct fs_struct *fs;
1408/* open file information */
1409 struct files_struct *files;
Serge E. Hallyn1651e142006-10-02 02:18:08 -07001410/* namespaces */
Serge E. Hallynab516012006-10-02 02:18:06 -07001411 struct nsproxy *nsproxy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412/* signal handlers */
1413 struct signal_struct *signal;
1414 struct sighand_struct *sighand;
1415
1416 sigset_t blocked, real_blocked;
Roland McGrathf3de2722008-04-30 00:53:09 -07001417 sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 struct sigpending pending;
1419
1420 unsigned long sas_ss_sp;
1421 size_t sas_ss_size;
1422 int (*notifier)(void *priv);
1423 void *notifier_data;
1424 sigset_t *notifier_mask;
Al Viro67d12142012-06-27 11:07:19 +04001425 struct callback_head *task_works;
Oleg Nesterove73f8952012-05-11 10:59:07 +10001426
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 struct audit_context *audit_context;
Al Virobfef93a2008-01-10 04:53:18 -05001428#ifdef CONFIG_AUDITSYSCALL
1429 uid_t loginuid;
Eric Paris4746ec52008-01-08 10:06:53 -05001430 unsigned int sessionid;
Al Virobfef93a2008-01-10 04:53:18 -05001431#endif
Will Drewry932eceb2012-04-12 16:47:54 -05001432 struct seccomp seccomp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433
1434/* Thread group tracking */
1435 u32 parent_exec_id;
1436 u32 self_exec_id;
Miao Xie58568d22009-06-16 15:31:49 -07001437/* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,
1438 * mempolicy */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 spinlock_t alloc_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
Ingo Molnarb29739f2006-06-27 02:54:51 -07001441 /* Protection of the PI data structures: */
Thomas Gleixner1d615482009-11-17 14:54:03 +01001442 raw_spinlock_t pi_lock;
Ingo Molnarb29739f2006-06-27 02:54:51 -07001443
Ingo Molnar23f78d4a2006-06-27 02:54:53 -07001444#ifdef CONFIG_RT_MUTEXES
1445 /* PI waiters blocked on a rt_mutex held by this task */
1446 struct plist_head pi_waiters;
1447 /* Deadlock detection and priority inheritance handling */
1448 struct rt_mutex_waiter *pi_blocked_on;
Ingo Molnar23f78d4a2006-06-27 02:54:53 -07001449#endif
1450
Ingo Molnar408894e2006-01-09 15:59:20 -08001451#ifdef CONFIG_DEBUG_MUTEXES
1452 /* mutex deadlock detection */
1453 struct mutex_waiter *blocked_on;
1454#endif
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001455#ifdef CONFIG_TRACE_IRQFLAGS
1456 unsigned int irq_events;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001457 unsigned long hardirq_enable_ip;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001458 unsigned long hardirq_disable_ip;
Hiroshi Shimamotofa1452e2009-11-30 14:59:44 +09001459 unsigned int hardirq_enable_event;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001460 unsigned int hardirq_disable_event;
Hiroshi Shimamotofa1452e2009-11-30 14:59:44 +09001461 int hardirqs_enabled;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001462 int hardirq_context;
Hiroshi Shimamotofa1452e2009-11-30 14:59:44 +09001463 unsigned long softirq_disable_ip;
1464 unsigned long softirq_enable_ip;
1465 unsigned int softirq_disable_event;
1466 unsigned int softirq_enable_event;
1467 int softirqs_enabled;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001468 int softirq_context;
1469#endif
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001470#ifdef CONFIG_LOCKDEP
Peter Zijlstrabdb94412008-02-25 23:02:48 +01001471# define MAX_LOCK_DEPTH 48UL
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001472 u64 curr_chain_key;
1473 int lockdep_depth;
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001474 unsigned int lockdep_recursion;
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001475 struct held_lock held_locks[MAX_LOCK_DEPTH];
Nick Piggincf40bd12009-01-21 08:12:39 +01001476 gfp_t lockdep_reclaim_gfp;
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001477#endif
Ingo Molnar408894e2006-01-09 15:59:20 -08001478
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479/* journalling filesystem info */
1480 void *journal_info;
1481
Neil Brownd89d8792007-05-01 09:53:42 +02001482/* stacked block device info */
Akinobu Mitabddd87c2010-02-23 08:55:42 +01001483 struct bio_list *bio_list;
Neil Brownd89d8792007-05-01 09:53:42 +02001484
Jens Axboe73c10102011-03-08 13:19:51 +01001485#ifdef CONFIG_BLOCK
1486/* stack plugging */
1487 struct blk_plug *plug;
1488#endif
1489
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490/* VM state */
1491 struct reclaim_state *reclaim_state;
1492
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 struct backing_dev_info *backing_dev_info;
1494
1495 struct io_context *io_context;
1496
1497 unsigned long ptrace_message;
1498 siginfo_t *last_siginfo; /* For ptrace use. */
Andrew Morton7c3ab732006-12-10 02:19:19 -08001499 struct task_io_accounting ioac;
Jay Lan8f0ab512006-09-30 23:28:59 -07001500#if defined(CONFIG_TASK_XACCT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 u64 acct_rss_mem1; /* accumulated rss usage */
1502 u64 acct_vm_mem1; /* accumulated virtual memory usage */
Jonathan Lim49b5cf32008-07-25 01:48:40 -07001503 cputime_t acct_timexpd; /* stime + utime since last update */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504#endif
1505#ifdef CONFIG_CPUSETS
Miao Xie58568d22009-06-16 15:31:49 -07001506 nodemask_t mems_allowed; /* Protected by alloc_lock */
Mel Gormancc9a6c82012-03-21 16:34:11 -07001507 seqcount_t mems_allowed_seq; /* Seqence no to catch updates */
Paul Jackson825a46a2006-03-24 03:16:03 -08001508 int cpuset_mem_spread_rotor;
Jack Steiner6adef3e2010-05-26 14:42:49 -07001509 int cpuset_slab_spread_rotor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510#endif
Paul Menageddbcc7e2007-10-18 23:39:30 -07001511#ifdef CONFIG_CGROUPS
Paul Menage817929e2007-10-18 23:39:36 -07001512 /* Control Group info protected by css_set_lock */
Arnd Bergmann2c392b82010-02-24 19:41:39 +01001513 struct css_set __rcu *cgroups;
Paul Menage817929e2007-10-18 23:39:36 -07001514 /* cg_list protected by css_set_lock and tsk->alloc_lock */
1515 struct list_head cg_list;
Paul Menageddbcc7e2007-10-18 23:39:30 -07001516#endif
Alexey Dobriyan42b2dd02007-10-16 23:27:30 -07001517#ifdef CONFIG_FUTEX
Ingo Molnar0771dfe2006-03-27 01:16:22 -08001518 struct robust_list_head __user *robust_list;
Ingo Molnar34f192c2006-03-27 01:16:24 -08001519#ifdef CONFIG_COMPAT
1520 struct compat_robust_list_head __user *compat_robust_list;
1521#endif
Ingo Molnarc87e2832006-06-27 02:54:58 -07001522 struct list_head pi_state_list;
1523 struct futex_pi_state *pi_state_cache;
Alexey Dobriyan42b2dd02007-10-16 23:27:30 -07001524#endif
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001525#ifdef CONFIG_PERF_EVENTS
Peter Zijlstra8dc85d52010-09-02 16:50:03 +02001526 struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001527 struct mutex perf_event_mutex;
1528 struct list_head perf_event_list;
Paul Mackerrasa63eaf32009-05-22 14:17:31 +10001529#endif
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001530#ifdef CONFIG_NUMA
Miao Xie58568d22009-06-16 15:31:49 -07001531 struct mempolicy *mempolicy; /* Protected by alloc_lock */
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001532 short il_next;
Eric Dumazet207205a2011-03-22 16:30:44 -07001533 short pref_node_fork;
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001534#endif
Ingo Molnare56d0902006-01-08 01:01:37 -08001535 struct rcu_head rcu;
Jens Axboeb92ce552006-04-11 13:52:07 +02001536
1537 /*
1538 * cache last used pipe for splice
1539 */
1540 struct pipe_inode_info *splice_pipe;
Shailabh Nagarca74e922006-07-14 00:24:36 -07001541#ifdef CONFIG_TASK_DELAY_ACCT
1542 struct task_delay_info *delays;
1543#endif
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08001544#ifdef CONFIG_FAULT_INJECTION
1545 int make_it_fail;
1546#endif
Wu Fengguang9d823e82011-06-11 18:10:12 -06001547 /*
1548 * when (nr_dirtied >= nr_dirtied_pause), it's time to call
1549 * balance_dirty_pages() for some dirty throttling pause
1550 */
1551 int nr_dirtied;
1552 int nr_dirtied_pause;
Wu Fengguang83712352011-06-11 19:25:42 -06001553 unsigned long dirty_paused_when; /* start of a write-and-pause period */
Wu Fengguang9d823e82011-06-11 18:10:12 -06001554
Arjan van de Ven97455122008-01-25 21:08:34 +01001555#ifdef CONFIG_LATENCYTOP
1556 int latency_record_count;
1557 struct latency_record latency_record[LT_SAVECOUNT];
1558#endif
Arjan van de Ven69766752008-09-01 15:52:40 -07001559 /*
1560 * time slack values; these are used to round up poll() and
1561 * select() etc timeout values. These are in nanoseconds.
1562 */
1563 unsigned long timer_slack_ns;
1564 unsigned long default_timer_slack_ns;
David Millerf8d570a2008-11-06 00:37:40 -08001565
Frederic Weisbeckerfb526072008-11-25 21:07:04 +01001566#ifdef CONFIG_FUNCTION_GRAPH_TRACER
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08001567 /* Index of current stored address in ret_stack */
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +01001568 int curr_ret_stack;
1569 /* Stack of return addresses for return function tracing */
1570 struct ftrace_ret_stack *ret_stack;
Steven Rostedt8aef2d22009-03-24 01:10:15 -04001571 /* time stamp for last schedule */
1572 unsigned long long ftrace_timestamp;
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +01001573 /*
1574 * Number of functions that haven't been traced
1575 * because of depth overrun.
1576 */
1577 atomic_t trace_overrun;
Frederic Weisbecker380c4b12008-12-06 03:43:41 +01001578 /* Pause for the tracing */
1579 atomic_t tracing_graph_pause;
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +01001580#endif
Steven Rostedtea4e2bc2008-12-03 15:36:57 -05001581#ifdef CONFIG_TRACING
1582 /* state flags for use by tracers */
1583 unsigned long trace;
Steven Rostedtb1cff0a2011-05-25 14:27:43 -04001584 /* bitmask and counter of trace recursion */
Steven Rostedt261842b2009-04-16 21:41:52 -04001585 unsigned long trace_recursion;
1586#endif /* CONFIG_TRACING */
Andrew Mortonc255a452012-07-31 16:43:02 -07001587#ifdef CONFIG_MEMCG /* memcg uses this to do batch job */
KAMEZAWA Hiroyuki569b8462009-12-15 16:47:03 -08001588 struct memcg_batch_info {
1589 int do_batch; /* incremented when batch uncharge started */
1590 struct mem_cgroup *memcg; /* target memcg of uncharge */
Johannes Weiner7ffd4ca2011-03-23 16:42:35 -07001591 unsigned long nr_pages; /* uncharged usage */
1592 unsigned long memsw_nr_pages; /* uncharged mem+swap usage */
KAMEZAWA Hiroyuki569b8462009-12-15 16:47:03 -08001593 } memcg_batch;
1594#endif
Frederic Weisbeckerbf26c012011-04-07 16:53:20 +02001595#ifdef CONFIG_HAVE_HW_BREAKPOINT
1596 atomic_t ptrace_bp_refcnt;
1597#endif
Srikar Dronamraju0326f5a2012-03-13 23:30:11 +05301598#ifdef CONFIG_UPROBES
1599 struct uprobe_task *utask;
Srikar Dronamraju0326f5a2012-03-13 23:30:11 +05301600#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601};
1602
Rusty Russell76e6eee2009-03-12 14:35:43 -06001603/* Future-safe accessor for struct task_struct's cpus_allowed. */
Rusty Russella4636812009-12-17 11:43:29 -06001604#define tsk_cpus_allowed(tsk) (&(tsk)->cpus_allowed)
Rusty Russell76e6eee2009-03-12 14:35:43 -06001605
Ingo Molnare05606d2007-07-09 18:51:59 +02001606/*
1607 * Priority of a process goes from 0..MAX_PRIO-1, valid RT
1608 * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
1609 * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
1610 * values are inverted: lower p->prio value means higher priority.
1611 *
1612 * The MAX_USER_RT_PRIO value allows the actual maximum
1613 * RT priority to be separate from the value exported to
1614 * user-space. This allows kernel threads to set their
1615 * priority to a value higher than any user task. Note:
1616 * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
1617 */
1618
1619#define MAX_USER_RT_PRIO 100
1620#define MAX_RT_PRIO MAX_USER_RT_PRIO
1621
1622#define MAX_PRIO (MAX_RT_PRIO + 40)
1623#define DEFAULT_PRIO (MAX_RT_PRIO + 20)
1624
1625static inline int rt_prio(int prio)
1626{
1627 if (unlikely(prio < MAX_RT_PRIO))
1628 return 1;
1629 return 0;
1630}
1631
Alexey Dobriyane8681712007-10-26 12:17:22 +04001632static inline int rt_task(struct task_struct *p)
Ingo Molnare05606d2007-07-09 18:51:59 +02001633{
1634 return rt_prio(p->prio);
1635}
1636
Alexey Dobriyane8681712007-10-26 12:17:22 +04001637static inline struct pid *task_pid(struct task_struct *task)
Eric W. Biederman22c935f2006-10-02 02:17:09 -07001638{
1639 return task->pids[PIDTYPE_PID].pid;
1640}
1641
Alexey Dobriyane8681712007-10-26 12:17:22 +04001642static inline struct pid *task_tgid(struct task_struct *task)
Eric W. Biederman22c935f2006-10-02 02:17:09 -07001643{
1644 return task->group_leader->pids[PIDTYPE_PID].pid;
1645}
1646
Oleg Nesterov6dda81f2009-04-02 16:58:35 -07001647/*
1648 * Without tasklist or rcu lock it is not safe to dereference
1649 * the result of task_pgrp/task_session even if task == current,
1650 * we can race with another thread doing sys_setsid/sys_setpgid.
1651 */
Alexey Dobriyane8681712007-10-26 12:17:22 +04001652static inline struct pid *task_pgrp(struct task_struct *task)
Eric W. Biederman22c935f2006-10-02 02:17:09 -07001653{
1654 return task->group_leader->pids[PIDTYPE_PGID].pid;
1655}
1656
Alexey Dobriyane8681712007-10-26 12:17:22 +04001657static inline struct pid *task_session(struct task_struct *task)
Eric W. Biederman22c935f2006-10-02 02:17:09 -07001658{
1659 return task->group_leader->pids[PIDTYPE_SID].pid;
1660}
1661
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001662struct pid_namespace;
1663
1664/*
1665 * the helpers to get the task's different pids as they are seen
1666 * from various namespaces
1667 *
1668 * task_xid_nr() : global id, i.e. the id seen from the init namespace;
Eric W. Biederman44c4e1b2008-02-08 04:19:15 -08001669 * task_xid_vnr() : virtual id, i.e. the id seen from the pid namespace of
1670 * current.
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001671 * task_xid_nr_ns() : id seen from the ns specified;
1672 *
1673 * set_task_vxid() : assigns a virtual id to a task;
1674 *
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001675 * see also pid_nr() etc in include/linux/pid.h
1676 */
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001677pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
1678 struct pid_namespace *ns);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001679
Alexey Dobriyane8681712007-10-26 12:17:22 +04001680static inline pid_t task_pid_nr(struct task_struct *tsk)
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001681{
1682 return tsk->pid;
1683}
1684
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001685static inline pid_t task_pid_nr_ns(struct task_struct *tsk,
1686 struct pid_namespace *ns)
1687{
1688 return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
1689}
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001690
1691static inline pid_t task_pid_vnr(struct task_struct *tsk)
1692{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001693 return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001694}
1695
1696
Alexey Dobriyane8681712007-10-26 12:17:22 +04001697static inline pid_t task_tgid_nr(struct task_struct *tsk)
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001698{
1699 return tsk->tgid;
1700}
1701
Pavel Emelyanov2f2a3a42007-10-18 23:40:19 -07001702pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001703
1704static inline pid_t task_tgid_vnr(struct task_struct *tsk)
1705{
1706 return pid_vnr(task_tgid(tsk));
1707}
1708
1709
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001710static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,
1711 struct pid_namespace *ns)
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001712{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001713 return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001714}
1715
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001716static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
1717{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001718 return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001719}
1720
1721
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001722static inline pid_t task_session_nr_ns(struct task_struct *tsk,
1723 struct pid_namespace *ns)
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001724{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001725 return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001726}
1727
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001728static inline pid_t task_session_vnr(struct task_struct *tsk)
1729{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001730 return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001731}
1732
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07001733/* obsolete, do not use */
1734static inline pid_t task_pgrp_nr(struct task_struct *tsk)
1735{
1736 return task_pgrp_nr_ns(tsk, &init_pid_ns);
1737}
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001738
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739/**
1740 * pid_alive - check that a task structure is not stale
1741 * @p: Task structure to be checked.
1742 *
1743 * Test if a process is not yet dead (at most zombie state)
1744 * If pid_alive fails, then pointers within the task structure
1745 * can be stale and must not be dereferenced.
1746 */
Alexey Dobriyane8681712007-10-26 12:17:22 +04001747static inline int pid_alive(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748{
Eric W. Biederman92476d72006-03-31 02:31:42 -08001749 return p->pids[PIDTYPE_PID].pid != NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750}
1751
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -07001752/**
Serge E. Hallynb460cbc2007-10-18 23:39:52 -07001753 * is_global_init - check if a task structure is init
Henne32602592006-10-06 00:44:01 -07001754 * @tsk: Task structure to be checked.
1755 *
1756 * Check if a task structure is the first user space task the kernel created.
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -07001757 */
Alexey Dobriyane8681712007-10-26 12:17:22 +04001758static inline int is_global_init(struct task_struct *tsk)
Pavel Emelyanovb461cc02007-10-18 23:40:09 -07001759{
1760 return tsk->pid == 1;
1761}
Serge E. Hallynb460cbc2007-10-18 23:39:52 -07001762
1763/*
1764 * is_container_init:
1765 * check whether in the task is init in its own pid namespace.
1766 */
Pavel Emelyanovb461cc02007-10-18 23:40:09 -07001767extern int is_container_init(struct task_struct *tsk);
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -07001768
Cedric Le Goater9ec52092006-10-02 02:19:00 -07001769extern struct pid *cad_pid;
1770
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771extern void free_task(struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772#define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
Ingo Molnare56d0902006-01-08 01:01:37 -08001773
Andrew Morton158d9eb2006-03-31 02:31:34 -08001774extern void __put_task_struct(struct task_struct *t);
Ingo Molnare56d0902006-01-08 01:01:37 -08001775
1776static inline void put_task_struct(struct task_struct *t)
1777{
1778 if (atomic_dec_and_test(&t->usage))
Eric W. Biederman8c7904a2006-03-31 02:31:37 -08001779 __put_task_struct(t);
Ingo Molnare56d0902006-01-08 01:01:37 -08001780}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781
Hidetoshi Setod180c5b2009-11-26 14:48:30 +09001782extern void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st);
Hidetoshi Seto0cf55e12009-12-02 17:28:07 +09001783extern void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st);
Balbir Singh49048622008-09-05 18:12:23 +02001784
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785/*
1786 * Per process flags
1787 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788#define PF_EXITING 0x00000004 /* getting shut down */
Alexey Kuznetsov778e9a92007-06-08 13:47:00 -07001789#define PF_EXITPIDONE 0x00000008 /* pi exit done on shut down */
Laurent Vivier94886b82007-10-15 17:00:19 +02001790#define PF_VCPU 0x00000010 /* I'm a virtual CPU */
Tejun Heo21aa9af2010-06-08 21:40:37 +02001791#define PF_WQ_WORKER 0x00000020 /* I'm a workqueue worker */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792#define PF_FORKNOEXEC 0x00000040 /* forked but didn't exec */
Andi Kleen4db96cf2009-09-16 11:50:14 +02001793#define PF_MCE_PROCESS 0x00000080 /* process policy on mce errors */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794#define PF_SUPERPRIV 0x00000100 /* used super-user privileges */
1795#define PF_DUMPCORE 0x00000200 /* dumped core */
1796#define PF_SIGNALED 0x00000400 /* killed by a signal */
1797#define PF_MEMALLOC 0x00000800 /* Allocating memory */
Vasiliy Kulikov72fa5992011-08-08 19:02:04 +04001798#define PF_NPROC_EXCEEDED 0x00001000 /* set_user noticed that RLIMIT_NPROC was exceeded */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799#define PF_USED_MATH 0x00002000 /* if unset the fpu must be initialized before use */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800#define PF_NOFREEZE 0x00008000 /* this thread should not be frozen */
1801#define PF_FROZEN 0x00010000 /* frozen for system suspend */
1802#define PF_FSTRANS 0x00020000 /* inside a filesystem transaction */
1803#define PF_KSWAPD 0x00040000 /* I am kswapd */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804#define PF_LESS_THROTTLE 0x00100000 /* Throttle me less: I clean memory */
Oleg Nesterov246bb0b2008-07-25 01:47:38 -07001805#define PF_KTHREAD 0x00200000 /* I am a kernel thread */
Jens Axboeb31dc662006-06-13 08:26:10 +02001806#define PF_RANDOMIZE 0x00400000 /* randomize virtual address space */
1807#define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */
1808#define PF_SPREAD_PAGE 0x01000000 /* Spread page cache over cpuset */
1809#define PF_SPREAD_SLAB 0x02000000 /* Spread some slab caches over cpuset */
David Rientjes9985b0b2008-06-05 12:57:11 -07001810#define PF_THREAD_BOUND 0x04000000 /* Thread bound to specific cpu */
Andi Kleen4db96cf2009-09-16 11:50:14 +02001811#define PF_MCE_EARLY 0x08000000 /* Early kill for mce process policy */
Paul Jacksonc61afb12006-03-24 03:16:08 -08001812#define PF_MEMPOLICY 0x10000000 /* Non-default NUMA mempolicy */
Thomas Gleixner61a87122006-06-27 02:54:56 -07001813#define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */
Tejun Heo58a69cb2011-02-16 09:25:31 +01001814#define PF_FREEZER_SKIP 0x40000000 /* Freezer should not count it as freezable */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815
1816/*
1817 * Only the _current_ task can read/write to tsk->flags, but other
1818 * tasks can access tsk->flags in readonly mode for example
1819 * with tsk_used_math (like during threaded core dumping).
1820 * There is however an exception to this rule during ptrace
1821 * or during fork: the ptracer task is allowed to write to the
1822 * child->flags of its traced child (same goes for fork, the parent
1823 * can write to the child->flags), because we're guaranteed the
1824 * child is not running and in turn not changing child->flags
1825 * at the same time the parent does it.
1826 */
1827#define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
1828#define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
1829#define clear_used_math() clear_stopped_child_used_math(current)
1830#define set_used_math() set_stopped_child_used_math(current)
1831#define conditional_stopped_child_used_math(condition, child) \
1832 do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
1833#define conditional_used_math(condition) \
1834 conditional_stopped_child_used_math(condition, current)
1835#define copy_to_stopped_child_used_math(child) \
1836 do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
1837/* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
1838#define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
1839#define used_math() tsk_used_math(current)
1840
Tejun Heoe5c19022011-03-23 10:37:00 +01001841/*
Tejun Heoa8f072c2011-06-02 11:13:59 +02001842 * task->jobctl flags
Tejun Heoe5c19022011-03-23 10:37:00 +01001843 */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001844#define JOBCTL_STOP_SIGMASK 0xffff /* signr of the last group stop */
Tejun Heoe5c19022011-03-23 10:37:00 +01001845
Tejun Heoa8f072c2011-06-02 11:13:59 +02001846#define JOBCTL_STOP_DEQUEUED_BIT 16 /* stop signal dequeued */
1847#define JOBCTL_STOP_PENDING_BIT 17 /* task should stop for group stop */
1848#define JOBCTL_STOP_CONSUME_BIT 18 /* consume group stop count */
Tejun Heo73ddff22011-06-14 11:20:14 +02001849#define JOBCTL_TRAP_STOP_BIT 19 /* trap for STOP */
Tejun Heofb1d9102011-06-14 11:20:17 +02001850#define JOBCTL_TRAP_NOTIFY_BIT 20 /* trap for NOTIFY */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001851#define JOBCTL_TRAPPING_BIT 21 /* switching to TRACED */
Tejun Heo544b2c92011-06-14 11:20:18 +02001852#define JOBCTL_LISTENING_BIT 22 /* ptracer is listening for events */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001853
1854#define JOBCTL_STOP_DEQUEUED (1 << JOBCTL_STOP_DEQUEUED_BIT)
1855#define JOBCTL_STOP_PENDING (1 << JOBCTL_STOP_PENDING_BIT)
1856#define JOBCTL_STOP_CONSUME (1 << JOBCTL_STOP_CONSUME_BIT)
Tejun Heo73ddff22011-06-14 11:20:14 +02001857#define JOBCTL_TRAP_STOP (1 << JOBCTL_TRAP_STOP_BIT)
Tejun Heofb1d9102011-06-14 11:20:17 +02001858#define JOBCTL_TRAP_NOTIFY (1 << JOBCTL_TRAP_NOTIFY_BIT)
Tejun Heoa8f072c2011-06-02 11:13:59 +02001859#define JOBCTL_TRAPPING (1 << JOBCTL_TRAPPING_BIT)
Tejun Heo544b2c92011-06-14 11:20:18 +02001860#define JOBCTL_LISTENING (1 << JOBCTL_LISTENING_BIT)
Tejun Heoa8f072c2011-06-02 11:13:59 +02001861
Tejun Heofb1d9102011-06-14 11:20:17 +02001862#define JOBCTL_TRAP_MASK (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)
Tejun Heo73ddff22011-06-14 11:20:14 +02001863#define JOBCTL_PENDING_MASK (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)
Tejun Heo3759a0d2011-06-02 11:14:00 +02001864
Tejun Heo7dd3db52011-06-02 11:14:00 +02001865extern bool task_set_jobctl_pending(struct task_struct *task,
1866 unsigned int mask);
Tejun Heo73ddff22011-06-14 11:20:14 +02001867extern void task_clear_jobctl_trapping(struct task_struct *task);
Tejun Heo3759a0d2011-06-02 11:14:00 +02001868extern void task_clear_jobctl_pending(struct task_struct *task,
1869 unsigned int mask);
Tejun Heo39efa3e2011-03-23 10:37:00 +01001870
Paul E. McKenneya57eb942010-06-29 16:49:16 -07001871#ifdef CONFIG_PREEMPT_RCU
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001872
1873#define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */
Paul E. McKenney1aa03f12012-01-11 17:25:17 -08001874#define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001875
1876static inline void rcu_copy_process(struct task_struct *p)
1877{
1878 p->rcu_read_lock_nesting = 0;
1879 p->rcu_read_unlock_special = 0;
Paul E. McKenneya57eb942010-06-29 16:49:16 -07001880#ifdef CONFIG_TREE_PREEMPT_RCU
Paul E. McKenneydd5d19b2009-08-27 14:58:16 -07001881 p->rcu_blocked_node = NULL;
Paul E. McKenney24278d12010-09-27 17:25:23 -07001882#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
1883#ifdef CONFIG_RCU_BOOST
1884 p->rcu_boost_mutex = NULL;
1885#endif /* #ifdef CONFIG_RCU_BOOST */
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001886 INIT_LIST_HEAD(&p->rcu_node_entry);
1887}
1888
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001889#else
1890
1891static inline void rcu_copy_process(struct task_struct *p)
1892{
1893}
1894
1895#endif
1896
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897#ifdef CONFIG_SMP
KOSAKI Motohiro1e1b6c52011-05-19 15:08:58 +09001898extern void do_set_cpus_allowed(struct task_struct *p,
1899 const struct cpumask *new_mask);
1900
Mike Traviscd8ba7c2008-03-26 14:23:49 -07001901extern int set_cpus_allowed_ptr(struct task_struct *p,
Rusty Russell96f874e2008-11-25 02:35:14 +10301902 const struct cpumask *new_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903#else
KOSAKI Motohiro1e1b6c52011-05-19 15:08:58 +09001904static inline void do_set_cpus_allowed(struct task_struct *p,
1905 const struct cpumask *new_mask)
1906{
1907}
Mike Traviscd8ba7c2008-03-26 14:23:49 -07001908static inline int set_cpus_allowed_ptr(struct task_struct *p,
Rusty Russell96f874e2008-11-25 02:35:14 +10301909 const struct cpumask *new_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910{
Rusty Russell96f874e2008-11-25 02:35:14 +10301911 if (!cpumask_test_cpu(0, new_mask))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 return -EINVAL;
1913 return 0;
1914}
1915#endif
Rusty Russelle0ad9552009-09-24 09:34:38 -06001916
Peter Zijlstra5167e8d2012-06-22 15:52:09 +02001917#ifdef CONFIG_NO_HZ
1918void calc_load_enter_idle(void);
1919void calc_load_exit_idle(void);
1920#else
1921static inline void calc_load_enter_idle(void) { }
1922static inline void calc_load_exit_idle(void) { }
1923#endif /* CONFIG_NO_HZ */
1924
Rusty Russelle0ad9552009-09-24 09:34:38 -06001925#ifndef CONFIG_CPUMASK_OFFSTACK
Mike Traviscd8ba7c2008-03-26 14:23:49 -07001926static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
1927{
1928 return set_cpus_allowed_ptr(p, &new_mask);
1929}
Rusty Russelle0ad9552009-09-24 09:34:38 -06001930#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931
Ingo Molnarb3425012009-02-26 20:20:29 +01001932/*
Peter Zijlstrac6763292010-05-25 10:48:51 +02001933 * Do not use outside of architecture code which knows its limitations.
1934 *
1935 * sched_clock() has no promise of monotonicity or bounded drift between
1936 * CPUs, use (which you should not) requires disabling IRQs.
1937 *
1938 * Please use one of the three interfaces below.
Ingo Molnarb3425012009-02-26 20:20:29 +01001939 */
Mike Frysinger1bbfa6f2009-12-09 20:07:03 -05001940extern unsigned long long notrace sched_clock(void);
Peter Zijlstrac6763292010-05-25 10:48:51 +02001941/*
Hiroshi Shimamoto489a71b2012-04-02 17:00:44 +09001942 * See the comment in kernel/sched/clock.c
Peter Zijlstrac6763292010-05-25 10:48:51 +02001943 */
1944extern u64 cpu_clock(int cpu);
1945extern u64 local_clock(void);
1946extern u64 sched_clock_cpu(int cpu);
1947
Ingo Molnare436d802007-07-19 21:28:35 +02001948
Peter Zijlstrac1955a32008-08-11 08:59:03 +02001949extern void sched_clock_init(void);
Peter Zijlstrac1955a32008-08-11 08:59:03 +02001950
Peter Zijlstra3e51f332008-05-03 18:29:28 +02001951#ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
Peter Zijlstra3e51f332008-05-03 18:29:28 +02001952static inline void sched_clock_tick(void)
1953{
1954}
1955
1956static inline void sched_clock_idle_sleep_event(void)
1957{
1958}
1959
1960static inline void sched_clock_idle_wakeup_event(u64 delta_ns)
1961{
1962}
1963#else
Peter Zijlstrac6763292010-05-25 10:48:51 +02001964/*
1965 * Architectures can set this to 1 if they have specified
1966 * CONFIG_HAVE_UNSTABLE_SCHED_CLOCK in their arch Kconfig,
1967 * but then during bootup it turns out that sched_clock()
1968 * is reliable after all:
1969 */
1970extern int sched_clock_stable;
1971
Peter Zijlstra3e51f332008-05-03 18:29:28 +02001972extern void sched_clock_tick(void);
1973extern void sched_clock_idle_sleep_event(void);
1974extern void sched_clock_idle_wakeup_event(u64 delta_ns);
1975#endif
1976
Venkatesh Pallipadib52bfee2010-10-04 17:03:19 -07001977#ifdef CONFIG_IRQ_TIME_ACCOUNTING
1978/*
1979 * An i/f to runtime opt-in for irq time accounting based off of sched_clock.
1980 * The reason for this explicit opt-in is not to have perf penalty with
1981 * slow sched_clocks.
1982 */
1983extern void enable_sched_clock_irqtime(void);
1984extern void disable_sched_clock_irqtime(void);
1985#else
1986static inline void enable_sched_clock_irqtime(void) {}
1987static inline void disable_sched_clock_irqtime(void) {}
1988#endif
1989
Ingo Molnar36c8b582006-07-03 00:25:41 -07001990extern unsigned long long
Ingo Molnar41b86e92007-07-09 18:51:58 +02001991task_sched_runtime(struct task_struct *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992
1993/* sched_exec is called by processes performing an exec */
1994#ifdef CONFIG_SMP
1995extern void sched_exec(void);
1996#else
1997#define sched_exec() {}
1998#endif
1999
Ingo Molnar2aa44d02007-08-23 15:18:02 +02002000extern void sched_clock_idle_sleep_event(void);
2001extern void sched_clock_idle_wakeup_event(u64 delta_ns);
Ingo Molnarbb29ab22007-07-09 18:51:59 +02002002
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003#ifdef CONFIG_HOTPLUG_CPU
2004extern void idle_task_exit(void);
2005#else
2006static inline void idle_task_exit(void) {}
2007#endif
2008
Thomas Gleixner06d83082008-03-22 09:20:24 +01002009#if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
2010extern void wake_up_idle_cpu(int cpu);
2011#else
2012static inline void wake_up_idle_cpu(int cpu) { }
2013#endif
2014
Peter Zijlstra21805082007-08-25 18:41:53 +02002015extern unsigned int sysctl_sched_latency;
Peter Zijlstrab2be5e92007-11-09 22:39:37 +01002016extern unsigned int sysctl_sched_min_granularity;
Ingo Molnarbf0f6f22007-07-09 18:51:58 +02002017extern unsigned int sysctl_sched_wakeup_granularity;
Ingo Molnarbf0f6f22007-07-09 18:51:58 +02002018extern unsigned int sysctl_sched_child_runs_first;
Christian Ehrhardt1983a922009-11-30 12:16:47 +01002019
2020enum sched_tunable_scaling {
2021 SCHED_TUNABLESCALING_NONE,
2022 SCHED_TUNABLESCALING_LOG,
2023 SCHED_TUNABLESCALING_LINEAR,
2024 SCHED_TUNABLESCALING_END,
2025};
2026extern enum sched_tunable_scaling sysctl_sched_tunable_scaling;
2027
Mike Galbraith2bba22c2009-09-09 15:41:37 +02002028#ifdef CONFIG_SCHED_DEBUG
Ingo Molnarda84d962007-10-15 17:00:18 +02002029extern unsigned int sysctl_sched_migration_cost;
Peter Zijlstrab82d9fd2007-11-09 22:39:39 +01002030extern unsigned int sysctl_sched_nr_migrate;
Peter Zijlstrae9e92502009-09-01 10:34:37 +02002031extern unsigned int sysctl_sched_time_avg;
Arun R Bharadwajcd1bb942009-04-16 12:15:34 +05302032extern unsigned int sysctl_timer_migration;
Paul Turnera7a4f8a2010-11-15 15:47:06 -08002033extern unsigned int sysctl_sched_shares_window;
Peter Zijlstrab2be5e92007-11-09 22:39:37 +01002034
Christian Ehrhardt1983a922009-11-30 12:16:47 +01002035int sched_proc_update_handler(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002036 void __user *buffer, size_t *length,
Peter Zijlstrab2be5e92007-11-09 22:39:37 +01002037 loff_t *ppos);
Ingo Molnar2bd8e6d2007-10-15 17:00:02 +02002038#endif
Arun R Bharadwajeea08f32009-04-16 12:16:41 +05302039#ifdef CONFIG_SCHED_DEBUG
2040static inline unsigned int get_sysctl_timer_migration(void)
2041{
2042 return sysctl_timer_migration;
2043}
2044#else
2045static inline unsigned int get_sysctl_timer_migration(void)
2046{
2047 return 1;
2048}
2049#endif
Peter Zijlstra9f0c1e52008-02-13 15:45:39 +01002050extern unsigned int sysctl_sched_rt_period;
2051extern int sysctl_sched_rt_runtime;
Ingo Molnar2bd8e6d2007-10-15 17:00:02 +02002052
Peter Zijlstrad0b27fa2008-04-19 19:44:57 +02002053int sched_rt_handler(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002054 void __user *buffer, size_t *lenp,
Peter Zijlstrad0b27fa2008-04-19 19:44:57 +02002055 loff_t *ppos);
2056
Mike Galbraith5091faa2010-11-30 14:18:03 +01002057#ifdef CONFIG_SCHED_AUTOGROUP
2058extern unsigned int sysctl_sched_autogroup_enabled;
2059
2060extern void sched_autogroup_create_attach(struct task_struct *p);
2061extern void sched_autogroup_detach(struct task_struct *p);
2062extern void sched_autogroup_fork(struct signal_struct *sig);
2063extern void sched_autogroup_exit(struct signal_struct *sig);
2064#ifdef CONFIG_PROC_FS
2065extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m);
Hiroshi Shimamoto2e5b5b32012-02-23 17:41:27 +09002066extern int proc_sched_autogroup_set_nice(struct task_struct *p, int nice);
Mike Galbraith5091faa2010-11-30 14:18:03 +01002067#endif
2068#else
2069static inline void sched_autogroup_create_attach(struct task_struct *p) { }
2070static inline void sched_autogroup_detach(struct task_struct *p) { }
2071static inline void sched_autogroup_fork(struct signal_struct *sig) { }
2072static inline void sched_autogroup_exit(struct signal_struct *sig) { }
2073#endif
2074
Paul Turnerec12cb72011-07-21 09:43:30 -07002075#ifdef CONFIG_CFS_BANDWIDTH
2076extern unsigned int sysctl_sched_cfs_bandwidth_slice;
2077#endif
2078
Ingo Molnarb29739f2006-06-27 02:54:51 -07002079#ifdef CONFIG_RT_MUTEXES
Ingo Molnar36c8b582006-07-03 00:25:41 -07002080extern int rt_mutex_getprio(struct task_struct *p);
2081extern void rt_mutex_setprio(struct task_struct *p, int prio);
2082extern void rt_mutex_adjust_pi(struct task_struct *p);
Thomas Gleixner3c7d5182011-07-17 20:46:52 +02002083static inline bool tsk_is_pi_blocked(struct task_struct *tsk)
2084{
2085 return tsk->pi_blocked_on != NULL;
2086}
Ingo Molnarb29739f2006-06-27 02:54:51 -07002087#else
Alexey Dobriyane8681712007-10-26 12:17:22 +04002088static inline int rt_mutex_getprio(struct task_struct *p)
Ingo Molnarb29739f2006-06-27 02:54:51 -07002089{
2090 return p->normal_prio;
2091}
Thomas Gleixner95e02ca2006-06-27 02:55:02 -07002092# define rt_mutex_adjust_pi(p) do { } while (0)
Thomas Gleixner3c7d5182011-07-17 20:46:52 +02002093static inline bool tsk_is_pi_blocked(struct task_struct *tsk)
2094{
2095 return false;
2096}
Ingo Molnarb29739f2006-06-27 02:54:51 -07002097#endif
2098
Mike Galbraithd95f4122011-02-01 09:50:51 -05002099extern bool yield_to(struct task_struct *p, bool preempt);
Ingo Molnar36c8b582006-07-03 00:25:41 -07002100extern void set_user_nice(struct task_struct *p, long nice);
2101extern int task_prio(const struct task_struct *p);
2102extern int task_nice(const struct task_struct *p);
2103extern int can_nice(const struct task_struct *p, const int nice);
2104extern int task_curr(const struct task_struct *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105extern int idle_cpu(int cpu);
KOSAKI Motohirofe7de492010-10-20 16:01:12 -07002106extern int sched_setscheduler(struct task_struct *, int,
2107 const struct sched_param *);
Rusty Russell961ccdd2008-06-23 13:55:38 +10002108extern int sched_setscheduler_nocheck(struct task_struct *, int,
KOSAKI Motohirofe7de492010-10-20 16:01:12 -07002109 const struct sched_param *);
Ingo Molnar36c8b582006-07-03 00:25:41 -07002110extern struct task_struct *idle_task(int cpu);
Paul E. McKenneyc4f30602011-11-10 12:41:56 -08002111/**
2112 * is_idle_task - is the specified task an idle task?
Randy Dunlapfa757282012-01-21 11:03:13 -08002113 * @p: the task in question.
Paul E. McKenneyc4f30602011-11-10 12:41:56 -08002114 */
Paul E. McKenney7061ca32011-12-20 08:20:46 -08002115static inline bool is_idle_task(const struct task_struct *p)
Paul E. McKenneyc4f30602011-11-10 12:41:56 -08002116{
2117 return p->pid == 0;
2118}
Ingo Molnar36c8b582006-07-03 00:25:41 -07002119extern struct task_struct *curr_task(int cpu);
2120extern void set_curr_task(int cpu, struct task_struct *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121
2122void yield(void);
2123
2124/*
2125 * The default (Linux) execution domain.
2126 */
2127extern struct exec_domain default_exec_domain;
2128
2129union thread_union {
2130 struct thread_info thread_info;
2131 unsigned long stack[THREAD_SIZE/sizeof(long)];
2132};
2133
2134#ifndef __HAVE_ARCH_KSTACK_END
2135static inline int kstack_end(void *addr)
2136{
2137 /* Reliable end of stack detection:
2138 * Some APM bios versions misalign the stack
2139 */
2140 return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
2141}
2142#endif
2143
2144extern union thread_union init_thread_union;
2145extern struct task_struct init_task;
2146
2147extern struct mm_struct init_mm;
2148
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002149extern struct pid_namespace init_pid_ns;
2150
2151/*
2152 * find a task by one of its numerical ids
2153 *
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002154 * find_task_by_pid_ns():
2155 * finds a task by its pid in the specified namespace
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -07002156 * find_task_by_vpid():
2157 * finds a task by its virtual pid
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002158 *
Pavel Emelyanove49859e2008-07-25 01:48:36 -07002159 * see also find_vpid() etc in include/linux/pid.h
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002160 */
2161
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -07002162extern struct task_struct *find_task_by_vpid(pid_t nr);
2163extern struct task_struct *find_task_by_pid_ns(pid_t nr,
2164 struct pid_namespace *ns);
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002165
Oleg Nesterov8520d7c2008-02-08 04:19:09 -08002166extern void __set_special_pids(struct pid *pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167
2168/* per-UID process charging. */
Eric W. Biederman7b44ab92011-11-16 23:20:58 -08002169extern struct user_struct * alloc_uid(kuid_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170static inline struct user_struct *get_uid(struct user_struct *u)
2171{
2172 atomic_inc(&u->__count);
2173 return u;
2174}
2175extern void free_uid(struct user_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176
2177#include <asm/current.h>
2178
Torben Hohnf0af911a92011-01-27 15:59:10 +01002179extern void xtime_update(unsigned long ticks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180
Harvey Harrisonb3c97522008-02-13 15:03:15 -08002181extern int wake_up_state(struct task_struct *tsk, unsigned int state);
2182extern int wake_up_process(struct task_struct *tsk);
Samir Bellabes3e51e3e2011-05-11 18:18:05 +02002183extern void wake_up_new_task(struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184#ifdef CONFIG_SMP
2185 extern void kick_process(struct task_struct *tsk);
2186#else
2187 static inline void kick_process(struct task_struct *tsk) { }
2188#endif
Samir Bellabes3e51e3e2011-05-11 18:18:05 +02002189extern void sched_fork(struct task_struct *p);
Ingo Molnarad46c2c2007-07-09 18:52:00 +02002190extern void sched_dead(struct task_struct *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192extern void proc_caches_init(void);
2193extern void flush_signals(struct task_struct *);
David Howells3bcac022009-04-29 13:45:05 +01002194extern void __flush_signals(struct task_struct *);
Oleg Nesterov10ab8252007-05-09 02:34:37 -07002195extern void ignore_signals(struct task_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196extern void flush_signal_handlers(struct task_struct *, int force_default);
2197extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
2198
2199static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
2200{
2201 unsigned long flags;
2202 int ret;
2203
2204 spin_lock_irqsave(&tsk->sighand->siglock, flags);
2205 ret = dequeue_signal(tsk, mask, info);
2206 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
2207
2208 return ret;
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02002209}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210
2211extern void block_all_signals(int (*notifier)(void *priv), void *priv,
2212 sigset_t *mask);
2213extern void unblock_all_signals(void);
2214extern void release_task(struct task_struct * p);
2215extern int send_sig_info(int, struct siginfo *, struct task_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216extern int force_sigsegv(int, struct task_struct *);
2217extern int force_sig_info(int, struct siginfo *, struct task_struct *);
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07002218extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07002219extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
Serge Hallynd178bc32011-09-26 10:45:18 -05002220extern int kill_pid_info_as_cred(int, struct siginfo *, struct pid *,
2221 const struct cred *, u32);
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07002222extern int kill_pgrp(struct pid *pid, int sig, int priv);
2223extern int kill_pid(struct pid *pid, int sig, int priv);
Matthew Wilcoxc3de4b32007-02-09 08:11:47 -07002224extern int kill_proc_info(int, struct siginfo *, pid_t);
Oleg Nesterov86773472011-06-22 23:09:09 +02002225extern __must_check bool do_notify_parent(struct task_struct *, int);
Oleg Nesterova7f07652009-09-23 15:56:44 -07002226extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227extern void force_sig(int, struct task_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228extern int send_sig(int, struct task_struct *, int);
Oleg Nesterov09faef12010-05-26 14:43:11 -07002229extern int zap_other_threads(struct task_struct *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230extern struct sigqueue *sigqueue_alloc(void);
2231extern void sigqueue_free(struct sigqueue *);
Oleg Nesterovac5c2152008-04-30 00:52:57 -07002232extern int send_sigqueue(struct sigqueue *, struct task_struct *, int group);
Oleg Nesterov9ac95f22006-02-09 22:41:50 +03002233extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long);
2235
Al Viro51a7b442012-05-21 23:33:55 -04002236static inline void restore_saved_sigmask(void)
2237{
2238 if (test_and_clear_restore_sigmask())
Al Viro77097ae2012-04-27 13:58:59 -04002239 __set_current_blocked(&current->saved_sigmask);
Al Viro51a7b442012-05-21 23:33:55 -04002240}
2241
Al Virob7f9a112012-05-02 09:59:21 -04002242static inline sigset_t *sigmask_to_save(void)
2243{
2244 sigset_t *res = &current->blocked;
2245 if (unlikely(test_restore_sigmask()))
2246 res = &current->saved_sigmask;
2247 return res;
2248}
2249
Cedric Le Goater9ec52092006-10-02 02:19:00 -07002250static inline int kill_cad_pid(int sig, int priv)
2251{
2252 return kill_pid(cad_pid, sig, priv);
2253}
2254
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255/* These can be the second arg to send_sig_info/send_group_sig_info. */
2256#define SEND_SIG_NOINFO ((struct siginfo *) 0)
2257#define SEND_SIG_PRIV ((struct siginfo *) 1)
2258#define SEND_SIG_FORCED ((struct siginfo *) 2)
2259
Sebastian Andrzej Siewior2a855dd2009-10-25 15:37:58 +01002260/*
2261 * True if we are on the alternate signal stack.
2262 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263static inline int on_sig_stack(unsigned long sp)
2264{
Sebastian Andrzej Siewior2a855dd2009-10-25 15:37:58 +01002265#ifdef CONFIG_STACK_GROWSUP
2266 return sp >= current->sas_ss_sp &&
2267 sp - current->sas_ss_sp < current->sas_ss_size;
2268#else
2269 return sp > current->sas_ss_sp &&
2270 sp - current->sas_ss_sp <= current->sas_ss_size;
2271#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272}
2273
2274static inline int sas_ss_flags(unsigned long sp)
2275{
2276 return (current->sas_ss_size == 0 ? SS_DISABLE
2277 : on_sig_stack(sp) ? SS_ONSTACK : 0);
2278}
2279
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280/*
2281 * Routines for handling mm_structs
2282 */
2283extern struct mm_struct * mm_alloc(void);
2284
2285/* mmdrop drops the mm and the page tables */
Harvey Harrisonb3c97522008-02-13 15:03:15 -08002286extern void __mmdrop(struct mm_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287static inline void mmdrop(struct mm_struct * mm)
2288{
Ingo Molnar6fb43d72007-07-09 18:52:01 +02002289 if (unlikely(atomic_dec_and_test(&mm->mm_count)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290 __mmdrop(mm);
2291}
2292
2293/* mmput gets rid of the mappings and all user-space */
2294extern void mmput(struct mm_struct *);
2295/* Grab a reference to a task's mm, if it is not already going away */
2296extern struct mm_struct *get_task_mm(struct task_struct *task);
Christopher Yeoh8cdb8782012-02-02 11:34:09 +10302297/*
2298 * Grab a reference to a task's mm, if it is not already going away
2299 * and ptrace_may_access with the mode parameter passed to it
2300 * succeeds.
2301 */
2302extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303/* Remove the current tasks stale references to the old mm_struct */
2304extern void mm_release(struct task_struct *, struct mm_struct *);
Carsten Otte402b0862008-03-25 18:47:10 +01002305/* Allocate a new mm structure and copy contents from tsk->mm */
2306extern struct mm_struct *dup_mm(struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307
Alexey Dobriyan6f2c55b2009-04-02 16:56:59 -07002308extern int copy_thread(unsigned long, unsigned long, unsigned long,
2309 struct task_struct *, struct pt_regs *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310extern void flush_thread(void);
2311extern void exit_thread(void);
2312
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313extern void exit_files(struct task_struct *);
Oleg Nesterova7e53282006-03-28 16:11:27 -08002314extern void __cleanup_sighand(struct sighand_struct *);
Oleg Nesterovcbaffba2008-05-26 20:55:42 +04002315
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316extern void exit_itimers(struct signal_struct *);
Oleg Nesterovcbaffba2008-05-26 20:55:42 +04002317extern void flush_itimer_signals(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318
Joe Perches9402c952012-01-12 17:17:17 -08002319extern void do_group_exit(int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321extern void daemonize(const char *, ...);
2322extern int allow_signal(int);
2323extern int disallow_signal(int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324
David Howellsd7627462010-08-17 23:52:56 +01002325extern int do_execve(const char *,
2326 const char __user * const __user *,
2327 const char __user * const __user *, struct pt_regs *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
Ingo Molnar36c8b582006-07-03 00:25:41 -07002329struct task_struct *fork_idle(int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330
2331extern void set_task_comm(struct task_struct *tsk, char *from);
Andrew Morton59714d62008-02-04 22:27:21 -08002332extern char *get_task_comm(char *to, struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333
2334#ifdef CONFIG_SMP
Peter Zijlstra317f3942011-04-05 17:23:58 +02002335void scheduler_ipi(void);
Roland McGrath85ba2d82008-07-25 19:45:58 -07002336extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337#else
Peter Zijlstra184748c2011-04-05 17:23:39 +02002338static inline void scheduler_ipi(void) { }
Roland McGrath85ba2d82008-07-25 19:45:58 -07002339static inline unsigned long wait_task_inactive(struct task_struct *p,
2340 long match_state)
2341{
2342 return 1;
2343}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344#endif
2345
Jiri Pirko05725f72009-04-14 20:17:16 +02002346#define next_task(p) \
2347 list_entry_rcu((p)->tasks.next, struct task_struct, tasks)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348
2349#define for_each_process(p) \
2350 for (p = &init_task ; (p = next_task(p)) != &init_task ; )
2351
Oleg Nesterov5bb459b2009-07-10 03:48:23 +02002352extern bool current_is_single_threaded(void);
David Howellsd84f4f92008-11-14 10:39:23 +11002353
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354/*
2355 * Careful: do_each_thread/while_each_thread is a double loop so
2356 * 'break' will not work as expected - use goto instead.
2357 */
2358#define do_each_thread(g, t) \
2359 for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
2360
2361#define while_each_thread(g, t) \
2362 while ((t = next_thread(t)) != g)
2363
Oleg Nesterov7e498272010-05-26 14:43:22 -07002364static inline int get_nr_threads(struct task_struct *tsk)
2365{
Oleg Nesterovb3ac0222010-05-26 14:43:24 -07002366 return tsk->signal->nr_threads;
Oleg Nesterov7e498272010-05-26 14:43:22 -07002367}
2368
Oleg Nesterov087806b2011-06-22 23:10:26 +02002369static inline bool thread_group_leader(struct task_struct *p)
2370{
2371 return p->exit_signal >= 0;
2372}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002374/* Do to the insanities of de_thread it is possible for a process
2375 * to have the pid of the thread group leader without actually being
2376 * the thread group leader. For iteration through the pids in proc
2377 * all we care about is that we have a task with the appropriate
2378 * pid, we don't actually care if we have the right task.
2379 */
Alexey Dobriyane8681712007-10-26 12:17:22 +04002380static inline int has_group_leader_pid(struct task_struct *p)
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002381{
2382 return p->pid == p->tgid;
2383}
2384
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -07002385static inline
2386int same_thread_group(struct task_struct *p1, struct task_struct *p2)
2387{
2388 return p1->tgid == p2->tgid;
2389}
2390
Ingo Molnar36c8b582006-07-03 00:25:41 -07002391static inline struct task_struct *next_thread(const struct task_struct *p)
Oleg Nesterov47e65322006-03-28 16:11:25 -08002392{
Jiri Pirko05725f72009-04-14 20:17:16 +02002393 return list_entry_rcu(p->thread_group.next,
2394 struct task_struct, thread_group);
Oleg Nesterov47e65322006-03-28 16:11:25 -08002395}
2396
Alexey Dobriyane8681712007-10-26 12:17:22 +04002397static inline int thread_group_empty(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398{
Oleg Nesterov47e65322006-03-28 16:11:25 -08002399 return list_empty(&p->thread_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400}
2401
2402#define delay_group_leader(p) \
2403 (thread_group_leader(p) && !thread_group_empty(p))
2404
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405/*
Eric W. Biederman260ea102006-06-23 02:05:18 -07002406 * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
Jens Axboe22e2c502005-06-27 10:55:12 +02002407 * subscriptions and synchronises with wait4(). Also used in procfs. Also
Paul Menageddbcc7e2007-10-18 23:39:30 -07002408 * pins the final release of task.io_context. Also protects ->cpuset and
Oleg Nesterovd68b46f2012-03-05 14:59:13 -08002409 * ->cgroup.subsys[]. And ->vfork_done.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 *
2411 * Nests both inside and outside of read_lock(&tasklist_lock).
2412 * It must not be nested with write_lock_irq(&tasklist_lock),
2413 * neither inside nor outside.
2414 */
2415static inline void task_lock(struct task_struct *p)
2416{
2417 spin_lock(&p->alloc_lock);
2418}
2419
2420static inline void task_unlock(struct task_struct *p)
2421{
2422 spin_unlock(&p->alloc_lock);
2423}
2424
Namhyung Kimb8ed3742010-10-27 15:34:06 -07002425extern struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
Oleg Nesterovf63ee722006-03-28 16:11:13 -08002426 unsigned long *flags);
2427
Anton Vorontsov9388dc32012-02-09 20:45:19 +04002428static inline struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
2429 unsigned long *flags)
2430{
2431 struct sighand_struct *ret;
2432
2433 ret = __lock_task_sighand(tsk, flags);
2434 (void)__cond_lock(&tsk->sighand->siglock, ret);
2435 return ret;
2436}
Namhyung Kimb8ed3742010-10-27 15:34:06 -07002437
Oleg Nesterovf63ee722006-03-28 16:11:13 -08002438static inline void unlock_task_sighand(struct task_struct *tsk,
2439 unsigned long *flags)
2440{
2441 spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
2442}
2443
Ben Blum4714d1d2011-05-26 16:25:18 -07002444#ifdef CONFIG_CGROUPS
Tejun Heo257058a2011-12-12 18:12:21 -08002445static inline void threadgroup_change_begin(struct task_struct *tsk)
Ben Blum4714d1d2011-05-26 16:25:18 -07002446{
Tejun Heo257058a2011-12-12 18:12:21 -08002447 down_read(&tsk->signal->group_rwsem);
Ben Blum4714d1d2011-05-26 16:25:18 -07002448}
Tejun Heo257058a2011-12-12 18:12:21 -08002449static inline void threadgroup_change_end(struct task_struct *tsk)
Ben Blum4714d1d2011-05-26 16:25:18 -07002450{
Tejun Heo257058a2011-12-12 18:12:21 -08002451 up_read(&tsk->signal->group_rwsem);
Ben Blum4714d1d2011-05-26 16:25:18 -07002452}
Tejun Heo77e4ef92011-12-12 18:12:21 -08002453
2454/**
2455 * threadgroup_lock - lock threadgroup
2456 * @tsk: member task of the threadgroup to lock
2457 *
2458 * Lock the threadgroup @tsk belongs to. No new task is allowed to enter
2459 * and member tasks aren't allowed to exit (as indicated by PF_EXITING) or
2460 * perform exec. This is useful for cases where the threadgroup needs to
2461 * stay stable across blockable operations.
2462 *
2463 * fork and exit paths explicitly call threadgroup_change_{begin|end}() for
2464 * synchronization. While held, no new task will be added to threadgroup
2465 * and no existing live task will have its PF_EXITING set.
2466 *
2467 * During exec, a task goes and puts its thread group through unusual
2468 * changes. After de-threading, exclusive access is assumed to resources
2469 * which are usually shared by tasks in the same group - e.g. sighand may
2470 * be replaced with a new one. Also, the exec'ing task takes over group
2471 * leader role including its pid. Exclude these changes while locked by
2472 * grabbing cred_guard_mutex which is used to synchronize exec path.
2473 */
Tejun Heo257058a2011-12-12 18:12:21 -08002474static inline void threadgroup_lock(struct task_struct *tsk)
Ben Blum4714d1d2011-05-26 16:25:18 -07002475{
Tejun Heo77e4ef92011-12-12 18:12:21 -08002476 /*
2477 * exec uses exit for de-threading nesting group_rwsem inside
2478 * cred_guard_mutex. Grab cred_guard_mutex first.
2479 */
2480 mutex_lock(&tsk->signal->cred_guard_mutex);
Tejun Heo257058a2011-12-12 18:12:21 -08002481 down_write(&tsk->signal->group_rwsem);
Ben Blum4714d1d2011-05-26 16:25:18 -07002482}
Tejun Heo77e4ef92011-12-12 18:12:21 -08002483
2484/**
2485 * threadgroup_unlock - unlock threadgroup
2486 * @tsk: member task of the threadgroup to unlock
2487 *
2488 * Reverse threadgroup_lock().
2489 */
Tejun Heo257058a2011-12-12 18:12:21 -08002490static inline void threadgroup_unlock(struct task_struct *tsk)
Ben Blum4714d1d2011-05-26 16:25:18 -07002491{
Tejun Heo257058a2011-12-12 18:12:21 -08002492 up_write(&tsk->signal->group_rwsem);
Tejun Heo77e4ef92011-12-12 18:12:21 -08002493 mutex_unlock(&tsk->signal->cred_guard_mutex);
Ben Blum4714d1d2011-05-26 16:25:18 -07002494}
2495#else
Tejun Heo257058a2011-12-12 18:12:21 -08002496static inline void threadgroup_change_begin(struct task_struct *tsk) {}
2497static inline void threadgroup_change_end(struct task_struct *tsk) {}
2498static inline void threadgroup_lock(struct task_struct *tsk) {}
2499static inline void threadgroup_unlock(struct task_struct *tsk) {}
Ben Blum4714d1d2011-05-26 16:25:18 -07002500#endif
2501
Al Virof0373602005-11-13 16:06:57 -08002502#ifndef __HAVE_THREAD_FUNCTIONS
2503
Roman Zippelf7e42172007-05-09 02:35:17 -07002504#define task_thread_info(task) ((struct thread_info *)(task)->stack)
2505#define task_stack_page(task) ((task)->stack)
Al Viroa1261f52005-11-13 16:06:55 -08002506
Al Viro10ebffd2005-11-13 16:06:56 -08002507static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
2508{
2509 *task_thread_info(p) = *task_thread_info(org);
2510 task_thread_info(p)->task = p;
2511}
2512
2513static inline unsigned long *end_of_stack(struct task_struct *p)
2514{
Roman Zippelf7e42172007-05-09 02:35:17 -07002515 return (unsigned long *)(task_thread_info(p) + 1);
Al Viro10ebffd2005-11-13 16:06:56 -08002516}
2517
Al Virof0373602005-11-13 16:06:57 -08002518#endif
2519
FUJITA Tomonori8b05c7e2008-07-23 21:26:53 -07002520static inline int object_is_on_stack(void *obj)
2521{
2522 void *stack = task_stack_page(current);
2523
2524 return (obj >= stack) && (obj < (stack + THREAD_SIZE));
2525}
2526
Benjamin Herrenschmidt8c9843e2008-04-18 16:56:15 +10002527extern void thread_info_cache_init(void);
2528
Eric Sandeen7c9f8862008-04-22 16:38:23 -05002529#ifdef CONFIG_DEBUG_STACK_USAGE
2530static inline unsigned long stack_not_used(struct task_struct *p)
2531{
2532 unsigned long *n = end_of_stack(p);
2533
2534 do { /* Skip over canary */
2535 n++;
2536 } while (!*n);
2537
2538 return (unsigned long)n - (unsigned long)end_of_stack(p);
2539}
2540#endif
2541
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542/* set thread flags in other task's structures
2543 * - see asm/thread_info.h for TIF_xxxx flags available
2544 */
2545static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
2546{
Al Viroa1261f52005-11-13 16:06:55 -08002547 set_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548}
2549
2550static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2551{
Al Viroa1261f52005-11-13 16:06:55 -08002552 clear_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553}
2554
2555static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
2556{
Al Viroa1261f52005-11-13 16:06:55 -08002557 return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558}
2559
2560static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2561{
Al Viroa1261f52005-11-13 16:06:55 -08002562 return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563}
2564
2565static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
2566{
Al Viroa1261f52005-11-13 16:06:55 -08002567 return test_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568}
2569
2570static inline void set_tsk_need_resched(struct task_struct *tsk)
2571{
2572 set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2573}
2574
2575static inline void clear_tsk_need_resched(struct task_struct *tsk)
2576{
2577 clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2578}
2579
Gregory Haskins8ae121a2008-04-23 07:13:29 -04002580static inline int test_tsk_need_resched(struct task_struct *tsk)
2581{
2582 return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
2583}
2584
Eric W. Biederman690cc3f2009-05-13 16:55:10 +00002585static inline int restart_syscall(void)
2586{
2587 set_tsk_thread_flag(current, TIF_SIGPENDING);
2588 return -ERESTARTNOINTR;
2589}
2590
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591static inline int signal_pending(struct task_struct *p)
2592{
2593 return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
2594}
Matthew Wilcoxf776d122007-12-06 11:15:50 -05002595
Roland McGrathd9588722009-09-23 15:57:04 -07002596static inline int __fatal_signal_pending(struct task_struct *p)
2597{
2598 return unlikely(sigismember(&p->pending.signal, SIGKILL));
2599}
Matthew Wilcoxf776d122007-12-06 11:15:50 -05002600
2601static inline int fatal_signal_pending(struct task_struct *p)
2602{
2603 return signal_pending(p) && __fatal_signal_pending(p);
2604}
2605
Oleg Nesterov16882c12008-06-08 21:20:41 +04002606static inline int signal_pending_state(long state, struct task_struct *p)
2607{
2608 if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
2609 return 0;
2610 if (!signal_pending(p))
2611 return 0;
2612
Oleg Nesterov16882c12008-06-08 21:20:41 +04002613 return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
2614}
2615
Linus Torvalds1da177e2005-04-16 15:20:36 -07002616static inline int need_resched(void)
2617{
Linus Torvalds9404ef02008-05-12 10:14:22 -07002618 return unlikely(test_thread_flag(TIF_NEED_RESCHED));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619}
2620
2621/*
2622 * cond_resched() and cond_resched_lock(): latency reduction via
2623 * explicit rescheduling in places that are safe. The return
2624 * value indicates whether a reschedule was done in fact.
2625 * cond_resched_lock() will drop the spinlock before scheduling,
2626 * cond_resched_softirq() will enable bhs before scheduling.
2627 */
Linus Torvaldsc3921ab2008-05-11 16:04:48 -07002628extern int _cond_resched(void);
Frederic Weisbecker6f80bd92009-07-16 15:44:29 +02002629
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002630#define cond_resched() ({ \
2631 __might_sleep(__FILE__, __LINE__, 0); \
2632 _cond_resched(); \
2633})
Frederic Weisbecker6f80bd92009-07-16 15:44:29 +02002634
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002635extern int __cond_resched_lock(spinlock_t *lock);
2636
Frederic Weisbeckerbdd4e852011-06-08 01:13:27 +02002637#ifdef CONFIG_PREEMPT_COUNT
Frederic Weisbecker716a4232009-07-24 20:05:23 +02002638#define PREEMPT_LOCK_OFFSET PREEMPT_OFFSET
Herbert Xu02b67cc32008-01-25 21:08:28 +01002639#else
Frederic Weisbecker716a4232009-07-24 20:05:23 +02002640#define PREEMPT_LOCK_OFFSET 0
Herbert Xu02b67cc32008-01-25 21:08:28 +01002641#endif
Frederic Weisbecker716a4232009-07-24 20:05:23 +02002642
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002643#define cond_resched_lock(lock) ({ \
Frederic Weisbecker716a4232009-07-24 20:05:23 +02002644 __might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET); \
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002645 __cond_resched_lock(lock); \
2646})
2647
2648extern int __cond_resched_softirq(void);
2649
Venkatesh Pallipadi75e10562010-10-04 17:03:16 -07002650#define cond_resched_softirq() ({ \
2651 __might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET); \
2652 __cond_resched_softirq(); \
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002653})
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654
2655/*
2656 * Does a critical section need to be broken due to another
Nick Piggin95c354f2008-01-30 13:31:20 +01002657 * task waiting?: (technically does not depend on CONFIG_PREEMPT,
2658 * but a general need for low latency)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 */
Nick Piggin95c354f2008-01-30 13:31:20 +01002660static inline int spin_needbreak(spinlock_t *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661{
Nick Piggin95c354f2008-01-30 13:31:20 +01002662#ifdef CONFIG_PREEMPT
2663 return spin_is_contended(lock);
2664#else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665 return 0;
Nick Piggin95c354f2008-01-30 13:31:20 +01002666#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667}
2668
Roland McGrath7bb44ad2007-05-23 13:57:44 -07002669/*
Frank Mayharf06febc2008-09-12 09:54:39 -07002670 * Thread group CPU time accounting.
2671 */
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +01002672void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
Peter Zijlstra4da94d492009-02-11 11:30:27 +01002673void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
Frank Mayharf06febc2008-09-12 09:54:39 -07002674
2675static inline void thread_group_cputime_init(struct signal_struct *sig)
2676{
Thomas Gleixneree30a7b2009-07-25 18:56:56 +02002677 raw_spin_lock_init(&sig->cputimer.lock);
Frank Mayharf06febc2008-09-12 09:54:39 -07002678}
2679
Frank Mayharf06febc2008-09-12 09:54:39 -07002680/*
Roland McGrath7bb44ad2007-05-23 13:57:44 -07002681 * Reevaluate whether the task has signals pending delivery.
2682 * Wake the task if so.
2683 * This is required every time the blocked sigset_t changes.
2684 * callers must hold sighand->siglock.
2685 */
2686extern void recalc_sigpending_and_wake(struct task_struct *t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687extern void recalc_sigpending(void);
2688
2689extern void signal_wake_up(struct task_struct *t, int resume_stopped);
2690
2691/*
2692 * Wrappers for p->thread_info->cpu access. No-op on UP.
2693 */
2694#ifdef CONFIG_SMP
2695
2696static inline unsigned int task_cpu(const struct task_struct *p)
2697{
Al Viroa1261f52005-11-13 16:06:55 -08002698 return task_thread_info(p)->cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699}
2700
Ingo Molnarc65cc872007-07-09 18:51:58 +02002701extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002702
2703#else
2704
2705static inline unsigned int task_cpu(const struct task_struct *p)
2706{
2707 return 0;
2708}
2709
2710static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
2711{
2712}
2713
2714#endif /* CONFIG_SMP */
2715
Rusty Russell96f874e2008-11-25 02:35:14 +10302716extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
2717extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
Siddha, Suresh B5c45bf22006-06-27 02:54:42 -07002718
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719extern void normalize_rt_tasks(void);
2720
Dhaval Giani7c941432010-01-20 13:26:18 +01002721#ifdef CONFIG_CGROUP_SCHED
Srivatsa Vaddagiri9b5b7752007-10-15 17:00:09 +02002722
Yong Zhang07e06b02011-01-07 15:17:36 +08002723extern struct task_group root_task_group;
Srivatsa Vaddagiri9b5b7752007-10-15 17:00:09 +02002724
Dhaval Gianiec7dc8a2008-04-19 19:44:59 +02002725extern struct task_group *sched_create_group(struct task_group *parent);
Ingo Molnar4cf86d72007-10-15 17:00:14 +02002726extern void sched_destroy_group(struct task_group *tg);
Srivatsa Vaddagiri9b5b7752007-10-15 17:00:09 +02002727extern void sched_move_task(struct task_struct *tsk);
Peter Zijlstra052f1dc2008-02-13 15:45:40 +01002728#ifdef CONFIG_FAIR_GROUP_SCHED
Ingo Molnar4cf86d72007-10-15 17:00:14 +02002729extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
Dhaval Giani5cb350b2007-10-15 17:00:14 +02002730extern unsigned long sched_group_shares(struct task_group *tg);
Peter Zijlstra052f1dc2008-02-13 15:45:40 +01002731#endif
2732#ifdef CONFIG_RT_GROUP_SCHED
Peter Zijlstra9f0c1e52008-02-13 15:45:39 +01002733extern int sched_group_set_rt_runtime(struct task_group *tg,
2734 long rt_runtime_us);
2735extern long sched_group_rt_runtime(struct task_group *tg);
Peter Zijlstrad0b27fa2008-04-19 19:44:57 +02002736extern int sched_group_set_rt_period(struct task_group *tg,
2737 long rt_period_us);
2738extern long sched_group_rt_period(struct task_group *tg);
Dhaval Giani54e99122009-02-27 15:13:54 +05302739extern int sched_rt_can_attach(struct task_group *tg, struct task_struct *tsk);
Peter Zijlstra052f1dc2008-02-13 15:45:40 +01002740#endif
Peter Zijlstra8323f262012-06-22 13:36:05 +02002741#endif /* CONFIG_CGROUP_SCHED */
Srivatsa Vaddagiri9b5b7752007-10-15 17:00:09 +02002742
Dhaval Giani54e99122009-02-27 15:13:54 +05302743extern int task_can_switch_user(struct user_struct *up,
2744 struct task_struct *tsk);
2745
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002746#ifdef CONFIG_TASK_XACCT
2747static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2748{
Andrea Righi940389b2008-07-28 00:48:12 +02002749 tsk->ioac.rchar += amt;
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002750}
2751
2752static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2753{
Andrea Righi940389b2008-07-28 00:48:12 +02002754 tsk->ioac.wchar += amt;
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002755}
2756
2757static inline void inc_syscr(struct task_struct *tsk)
2758{
Andrea Righi940389b2008-07-28 00:48:12 +02002759 tsk->ioac.syscr++;
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002760}
2761
2762static inline void inc_syscw(struct task_struct *tsk)
2763{
Andrea Righi940389b2008-07-28 00:48:12 +02002764 tsk->ioac.syscw++;
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002765}
2766#else
2767static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2768{
2769}
2770
2771static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2772{
2773}
2774
2775static inline void inc_syscr(struct task_struct *tsk)
2776{
2777}
2778
2779static inline void inc_syscw(struct task_struct *tsk)
2780{
2781}
2782#endif
2783
Dave Hansen82455252008-02-04 22:28:59 -08002784#ifndef TASK_SIZE_OF
2785#define TASK_SIZE_OF(tsk) TASK_SIZE
2786#endif
2787
Balbir Singhcf475ad2008-04-29 01:00:16 -07002788#ifdef CONFIG_MM_OWNER
2789extern void mm_update_next_owner(struct mm_struct *mm);
2790extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
2791#else
2792static inline void mm_update_next_owner(struct mm_struct *mm)
2793{
2794}
2795
2796static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
2797{
2798}
2799#endif /* CONFIG_MM_OWNER */
2800
Jiri Slaby3e10e712009-11-19 17:16:37 +01002801static inline unsigned long task_rlimit(const struct task_struct *tsk,
2802 unsigned int limit)
2803{
2804 return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_cur);
2805}
2806
2807static inline unsigned long task_rlimit_max(const struct task_struct *tsk,
2808 unsigned int limit)
2809{
2810 return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_max);
2811}
2812
2813static inline unsigned long rlimit(unsigned int limit)
2814{
2815 return task_rlimit(current, limit);
2816}
2817
2818static inline unsigned long rlimit_max(unsigned int limit)
2819{
2820 return task_rlimit_max(current, limit);
2821}
2822
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823#endif /* __KERNEL__ */
2824
2825#endif