xref: /linux/include/linux/sched.h (revision fb52607afcd0629776f1dc9e657647ceae81dd50)
11da177e4SLinus Torvalds #ifndef _LINUX_SCHED_H
21da177e4SLinus Torvalds #define _LINUX_SCHED_H
31da177e4SLinus Torvalds 
4b7b3c76aSDavid Woodhouse /*
5b7b3c76aSDavid Woodhouse  * cloning flags:
6b7b3c76aSDavid Woodhouse  */
7b7b3c76aSDavid Woodhouse #define CSIGNAL		0x000000ff	/* signal mask to be sent at exit */
8b7b3c76aSDavid Woodhouse #define CLONE_VM	0x00000100	/* set if VM shared between processes */
9b7b3c76aSDavid Woodhouse #define CLONE_FS	0x00000200	/* set if fs info shared between processes */
10b7b3c76aSDavid Woodhouse #define CLONE_FILES	0x00000400	/* set if open files shared between processes */
11b7b3c76aSDavid Woodhouse #define CLONE_SIGHAND	0x00000800	/* set if signal handlers and blocked signals shared */
12b7b3c76aSDavid Woodhouse #define CLONE_PTRACE	0x00002000	/* set if we want to let tracing continue on the child too */
13b7b3c76aSDavid Woodhouse #define CLONE_VFORK	0x00004000	/* set if the parent wants the child to wake it up on mm_release */
14b7b3c76aSDavid Woodhouse #define CLONE_PARENT	0x00008000	/* set if we want to have the same parent as the cloner */
15b7b3c76aSDavid Woodhouse #define CLONE_THREAD	0x00010000	/* Same thread group? */
16b7b3c76aSDavid Woodhouse #define CLONE_NEWNS	0x00020000	/* New namespace group? */
17b7b3c76aSDavid Woodhouse #define CLONE_SYSVSEM	0x00040000	/* share system V SEM_UNDO semantics */
18b7b3c76aSDavid Woodhouse #define CLONE_SETTLS	0x00080000	/* create a new TLS for the child */
19b7b3c76aSDavid Woodhouse #define CLONE_PARENT_SETTID	0x00100000	/* set the TID in the parent */
20b7b3c76aSDavid Woodhouse #define CLONE_CHILD_CLEARTID	0x00200000	/* clear the TID in the child */
21b7b3c76aSDavid Woodhouse #define CLONE_DETACHED		0x00400000	/* Unused, ignored */
22b7b3c76aSDavid Woodhouse #define CLONE_UNTRACED		0x00800000	/* set if the tracing process can't force CLONE_PTRACE on this clone */
23b7b3c76aSDavid Woodhouse #define CLONE_CHILD_SETTID	0x01000000	/* set the TID in the child */
24b7b3c76aSDavid Woodhouse #define CLONE_STOPPED		0x02000000	/* Start in stopped state */
25071df104SSerge E. Hallyn #define CLONE_NEWUTS		0x04000000	/* New utsname group? */
2625b21cb2SKirill Korotaev #define CLONE_NEWIPC		0x08000000	/* New ipcs */
2777ec739dSSerge E. Hallyn #define CLONE_NEWUSER		0x10000000	/* New user namespace */
2830e49c26SPavel Emelyanov #define CLONE_NEWPID		0x20000000	/* New pid namespace */
29169e3674SEric W. Biederman #define CLONE_NEWNET		0x40000000	/* New network namespace */
30fadad878SJens Axboe #define CLONE_IO		0x80000000	/* Clone io context */
31b7b3c76aSDavid Woodhouse 
32b7b3c76aSDavid Woodhouse /*
33b7b3c76aSDavid Woodhouse  * Scheduling policies
34b7b3c76aSDavid Woodhouse  */
35b7b3c76aSDavid Woodhouse #define SCHED_NORMAL		0
36b7b3c76aSDavid Woodhouse #define SCHED_FIFO		1
37b7b3c76aSDavid Woodhouse #define SCHED_RR		2
38b7b3c76aSDavid Woodhouse #define SCHED_BATCH		3
390e6aca43SIngo Molnar /* SCHED_ISO: reserved but not implemented yet */
400e6aca43SIngo Molnar #define SCHED_IDLE		5
41b7b3c76aSDavid Woodhouse 
42a3b6714eSDavid Woodhouse #ifdef __KERNEL__
43b7b3c76aSDavid Woodhouse 
44b7b3c76aSDavid Woodhouse struct sched_param {
45b7b3c76aSDavid Woodhouse 	int sched_priority;
46b7b3c76aSDavid Woodhouse };
47b7b3c76aSDavid Woodhouse 
481da177e4SLinus Torvalds #include <asm/param.h>	/* for HZ */
491da177e4SLinus Torvalds 
501da177e4SLinus Torvalds #include <linux/capability.h>
511da177e4SLinus Torvalds #include <linux/threads.h>
521da177e4SLinus Torvalds #include <linux/kernel.h>
531da177e4SLinus Torvalds #include <linux/types.h>
541da177e4SLinus Torvalds #include <linux/timex.h>
551da177e4SLinus Torvalds #include <linux/jiffies.h>
561da177e4SLinus Torvalds #include <linux/rbtree.h>
571da177e4SLinus Torvalds #include <linux/thread_info.h>
581da177e4SLinus Torvalds #include <linux/cpumask.h>
591da177e4SLinus Torvalds #include <linux/errno.h>
601da177e4SLinus Torvalds #include <linux/nodemask.h>
61c92ff1bdSMartin Schwidefsky #include <linux/mm_types.h>
621da177e4SLinus Torvalds 
631da177e4SLinus Torvalds #include <asm/system.h>
641da177e4SLinus Torvalds #include <asm/page.h>
651da177e4SLinus Torvalds #include <asm/ptrace.h>
661da177e4SLinus Torvalds #include <asm/cputime.h>
671da177e4SLinus Torvalds 
681da177e4SLinus Torvalds #include <linux/smp.h>
691da177e4SLinus Torvalds #include <linux/sem.h>
701da177e4SLinus Torvalds #include <linux/signal.h>
711da177e4SLinus Torvalds #include <linux/fs_struct.h>
721da177e4SLinus Torvalds #include <linux/compiler.h>
731da177e4SLinus Torvalds #include <linux/completion.h>
741da177e4SLinus Torvalds #include <linux/pid.h>
751da177e4SLinus Torvalds #include <linux/percpu.h>
761da177e4SLinus Torvalds #include <linux/topology.h>
773e26c149SPeter Zijlstra #include <linux/proportions.h>
781da177e4SLinus Torvalds #include <linux/seccomp.h>
79e56d0903SIngo Molnar #include <linux/rcupdate.h>
8023f78d4aSIngo Molnar #include <linux/rtmutex.h>
811da177e4SLinus Torvalds 
82a3b6714eSDavid Woodhouse #include <linux/time.h>
83a3b6714eSDavid Woodhouse #include <linux/param.h>
84a3b6714eSDavid Woodhouse #include <linux/resource.h>
85a3b6714eSDavid Woodhouse #include <linux/timer.h>
86a3b6714eSDavid Woodhouse #include <linux/hrtimer.h>
877c3ab738SAndrew Morton #include <linux/task_io_accounting.h>
885cb350baSDhaval Giani #include <linux/kobject.h>
899745512cSArjan van de Ven #include <linux/latencytop.h>
909e2b2dc4SDavid Howells #include <linux/cred.h>
91a3b6714eSDavid Woodhouse 
92a3b6714eSDavid Woodhouse #include <asm/processor.h>
9336d57ac4SH. J. Lu 
9478fb7466SPavel Emelianov struct mem_cgroup;
951da177e4SLinus Torvalds struct exec_domain;
96c87e2837SIngo Molnar struct futex_pi_state;
97286100a6SAlexey Dobriyan struct robust_list_head;
98d89d8796SNeil Brown struct bio;
99ca0002a1SMarkus Metzger struct bts_tracer;
1001da177e4SLinus Torvalds 
1011da177e4SLinus Torvalds /*
1021da177e4SLinus Torvalds  * List of flags we want to share for kernel threads,
1031da177e4SLinus Torvalds  * if only because they are not used by them anyway.
1041da177e4SLinus Torvalds  */
1051da177e4SLinus Torvalds #define CLONE_KERNEL	(CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
1061da177e4SLinus Torvalds 
1071da177e4SLinus Torvalds /*
1081da177e4SLinus Torvalds  * These are the constant used to fake the fixed-point load-average
1091da177e4SLinus Torvalds  * counting. Some notes:
1101da177e4SLinus Torvalds  *  - 11 bit fractions expand to 22 bits by the multiplies: this gives
1111da177e4SLinus Torvalds  *    a load-average precision of 10 bits integer + 11 bits fractional
1121da177e4SLinus Torvalds  *  - if you want to count load-averages more often, you need more
1131da177e4SLinus Torvalds  *    precision, or rounding will get you. With 2-second counting freq,
1141da177e4SLinus Torvalds  *    the EXP_n values would be 1981, 2034 and 2043 if still using only
1151da177e4SLinus Torvalds  *    11 bit fractions.
1161da177e4SLinus Torvalds  */
1171da177e4SLinus Torvalds extern unsigned long avenrun[];		/* Load averages */
1181da177e4SLinus Torvalds 
1191da177e4SLinus Torvalds #define FSHIFT		11		/* nr of bits of precision */
1201da177e4SLinus Torvalds #define FIXED_1		(1<<FSHIFT)	/* 1.0 as fixed-point */
1210c2043abSLinus Torvalds #define LOAD_FREQ	(5*HZ+1)	/* 5 sec intervals */
1221da177e4SLinus Torvalds #define EXP_1		1884		/* 1/exp(5sec/1min) as fixed-point */
1231da177e4SLinus Torvalds #define EXP_5		2014		/* 1/exp(5sec/5min) */
1241da177e4SLinus Torvalds #define EXP_15		2037		/* 1/exp(5sec/15min) */
1251da177e4SLinus Torvalds 
1261da177e4SLinus Torvalds #define CALC_LOAD(load,exp,n) \
1271da177e4SLinus Torvalds 	load *= exp; \
1281da177e4SLinus Torvalds 	load += n*(FIXED_1-exp); \
1291da177e4SLinus Torvalds 	load >>= FSHIFT;
1301da177e4SLinus Torvalds 
1311da177e4SLinus Torvalds extern unsigned long total_forks;
1321da177e4SLinus Torvalds extern int nr_threads;
1331da177e4SLinus Torvalds DECLARE_PER_CPU(unsigned long, process_counts);
1341da177e4SLinus Torvalds extern int nr_processes(void);
1351da177e4SLinus Torvalds extern unsigned long nr_running(void);
1361da177e4SLinus Torvalds extern unsigned long nr_uninterruptible(void);
137db1b1fefSJack Steiner extern unsigned long nr_active(void);
1381da177e4SLinus Torvalds extern unsigned long nr_iowait(void);
1391da177e4SLinus Torvalds 
14043ae34cbSIngo Molnar struct seq_file;
14143ae34cbSIngo Molnar struct cfs_rq;
1424cf86d77SIngo Molnar struct task_group;
14343ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG
14443ae34cbSIngo Molnar extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
14543ae34cbSIngo Molnar extern void proc_sched_set_task(struct task_struct *p);
14643ae34cbSIngo Molnar extern void
1475cef9ecaSIngo Molnar print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
14843ae34cbSIngo Molnar #else
14943ae34cbSIngo Molnar static inline void
15043ae34cbSIngo Molnar proc_sched_show_task(struct task_struct *p, struct seq_file *m)
15143ae34cbSIngo Molnar {
15243ae34cbSIngo Molnar }
15343ae34cbSIngo Molnar static inline void proc_sched_set_task(struct task_struct *p)
15443ae34cbSIngo Molnar {
15543ae34cbSIngo Molnar }
15643ae34cbSIngo Molnar static inline void
1575cef9ecaSIngo Molnar print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
15843ae34cbSIngo Molnar {
15943ae34cbSIngo Molnar }
16043ae34cbSIngo Molnar #endif
1611da177e4SLinus Torvalds 
162690229a0SIngo Molnar extern unsigned long long time_sync_thresh;
163690229a0SIngo Molnar 
1644a8342d2SLinus Torvalds /*
1654a8342d2SLinus Torvalds  * Task state bitmask. NOTE! These bits are also
1664a8342d2SLinus Torvalds  * encoded in fs/proc/array.c: get_task_state().
1674a8342d2SLinus Torvalds  *
1684a8342d2SLinus Torvalds  * We have two separate sets of flags: task->state
1694a8342d2SLinus Torvalds  * is about runnability, while task->exit_state are
1704a8342d2SLinus Torvalds  * about the task exiting. Confusing, but this way
1714a8342d2SLinus Torvalds  * modifying one set can't modify the other one by
1724a8342d2SLinus Torvalds  * mistake.
1734a8342d2SLinus Torvalds  */
1741da177e4SLinus Torvalds #define TASK_RUNNING		0
1751da177e4SLinus Torvalds #define TASK_INTERRUPTIBLE	1
1761da177e4SLinus Torvalds #define TASK_UNINTERRUPTIBLE	2
177f021a3c2SMatthew Wilcox #define __TASK_STOPPED		4
178f021a3c2SMatthew Wilcox #define __TASK_TRACED		8
1794a8342d2SLinus Torvalds /* in tsk->exit_state */
1804a8342d2SLinus Torvalds #define EXIT_ZOMBIE		16
1814a8342d2SLinus Torvalds #define EXIT_DEAD		32
1824a8342d2SLinus Torvalds /* in tsk->state again */
183af927232SMike Galbraith #define TASK_DEAD		64
184f021a3c2SMatthew Wilcox #define TASK_WAKEKILL		128
185f021a3c2SMatthew Wilcox 
186f021a3c2SMatthew Wilcox /* Convenience macros for the sake of set_task_state */
187f021a3c2SMatthew Wilcox #define TASK_KILLABLE		(TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
188f021a3c2SMatthew Wilcox #define TASK_STOPPED		(TASK_WAKEKILL | __TASK_STOPPED)
189f021a3c2SMatthew Wilcox #define TASK_TRACED		(TASK_WAKEKILL | __TASK_TRACED)
1901da177e4SLinus Torvalds 
19192a1f4bcSMatthew Wilcox /* Convenience macros for the sake of wake_up */
19292a1f4bcSMatthew Wilcox #define TASK_NORMAL		(TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
193f021a3c2SMatthew Wilcox #define TASK_ALL		(TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
19492a1f4bcSMatthew Wilcox 
19592a1f4bcSMatthew Wilcox /* get_task_state() */
19692a1f4bcSMatthew Wilcox #define TASK_REPORT		(TASK_RUNNING | TASK_INTERRUPTIBLE | \
197f021a3c2SMatthew Wilcox 				 TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
198f021a3c2SMatthew Wilcox 				 __TASK_TRACED)
19992a1f4bcSMatthew Wilcox 
200f021a3c2SMatthew Wilcox #define task_is_traced(task)	((task->state & __TASK_TRACED) != 0)
201f021a3c2SMatthew Wilcox #define task_is_stopped(task)	((task->state & __TASK_STOPPED) != 0)
20292a1f4bcSMatthew Wilcox #define task_is_stopped_or_traced(task)	\
203f021a3c2SMatthew Wilcox 			((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
20492a1f4bcSMatthew Wilcox #define task_contributes_to_load(task)	\
20592a1f4bcSMatthew Wilcox 				((task->state & TASK_UNINTERRUPTIBLE) != 0)
2061da177e4SLinus Torvalds 
2071da177e4SLinus Torvalds #define __set_task_state(tsk, state_value)		\
2081da177e4SLinus Torvalds 	do { (tsk)->state = (state_value); } while (0)
2091da177e4SLinus Torvalds #define set_task_state(tsk, state_value)		\
2101da177e4SLinus Torvalds 	set_mb((tsk)->state, (state_value))
2111da177e4SLinus Torvalds 
212498d0c57SAndrew Morton /*
213498d0c57SAndrew Morton  * set_current_state() includes a barrier so that the write of current->state
214498d0c57SAndrew Morton  * is correctly serialised wrt the caller's subsequent test of whether to
215498d0c57SAndrew Morton  * actually sleep:
216498d0c57SAndrew Morton  *
217498d0c57SAndrew Morton  *	set_current_state(TASK_UNINTERRUPTIBLE);
218498d0c57SAndrew Morton  *	if (do_i_need_to_sleep())
219498d0c57SAndrew Morton  *		schedule();
220498d0c57SAndrew Morton  *
221498d0c57SAndrew Morton  * If the caller does not need such serialisation then use __set_current_state()
222498d0c57SAndrew Morton  */
2231da177e4SLinus Torvalds #define __set_current_state(state_value)			\
2241da177e4SLinus Torvalds 	do { current->state = (state_value); } while (0)
2251da177e4SLinus Torvalds #define set_current_state(state_value)		\
2261da177e4SLinus Torvalds 	set_mb(current->state, (state_value))
2271da177e4SLinus Torvalds 
2281da177e4SLinus Torvalds /* Task command name length */
2291da177e4SLinus Torvalds #define TASK_COMM_LEN 16
2301da177e4SLinus Torvalds 
2311da177e4SLinus Torvalds #include <linux/spinlock.h>
2321da177e4SLinus Torvalds 
2331da177e4SLinus Torvalds /*
2341da177e4SLinus Torvalds  * This serializes "schedule()" and also protects
2351da177e4SLinus Torvalds  * the run-queue from deletions/modifications (but
2361da177e4SLinus Torvalds  * _adding_ to the beginning of the run-queue has
2371da177e4SLinus Torvalds  * a separate lock).
2381da177e4SLinus Torvalds  */
2391da177e4SLinus Torvalds extern rwlock_t tasklist_lock;
2401da177e4SLinus Torvalds extern spinlock_t mmlist_lock;
2411da177e4SLinus Torvalds 
24236c8b586SIngo Molnar struct task_struct;
2431da177e4SLinus Torvalds 
2441da177e4SLinus Torvalds extern void sched_init(void);
2451da177e4SLinus Torvalds extern void sched_init_smp(void);
2462d07b255SHarvey Harrison extern asmlinkage void schedule_tail(struct task_struct *prev);
24736c8b586SIngo Molnar extern void init_idle(struct task_struct *idle, int cpu);
2481df21055SIngo Molnar extern void init_idle_bootup_task(struct task_struct *idle);
2491da177e4SLinus Torvalds 
250017730c1SIngo Molnar extern int runqueue_is_locked(void);
251ad474cacSOleg Nesterov extern void task_rq_unlock_wait(struct task_struct *p);
252017730c1SIngo Molnar 
2531da177e4SLinus Torvalds extern cpumask_t nohz_cpu_mask;
25446cb4b7cSSiddha, Suresh B #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ)
25546cb4b7cSSiddha, Suresh B extern int select_nohz_load_balancer(int cpu);
25646cb4b7cSSiddha, Suresh B #else
25746cb4b7cSSiddha, Suresh B static inline int select_nohz_load_balancer(int cpu)
25846cb4b7cSSiddha, Suresh B {
25946cb4b7cSSiddha, Suresh B 	return 0;
26046cb4b7cSSiddha, Suresh B }
26146cb4b7cSSiddha, Suresh B #endif
2621da177e4SLinus Torvalds 
26348d5e258SPeter Zijlstra extern unsigned long rt_needs_cpu(int cpu);
26448d5e258SPeter Zijlstra 
265e59e2ae2SIngo Molnar /*
26639bc89fdSIngo Molnar  * Only dump TASK_* tasks. (0 for all tasks)
267e59e2ae2SIngo Molnar  */
268e59e2ae2SIngo Molnar extern void show_state_filter(unsigned long state_filter);
269e59e2ae2SIngo Molnar 
270e59e2ae2SIngo Molnar static inline void show_state(void)
271e59e2ae2SIngo Molnar {
27239bc89fdSIngo Molnar 	show_state_filter(0);
273e59e2ae2SIngo Molnar }
274e59e2ae2SIngo Molnar 
2751da177e4SLinus Torvalds extern void show_regs(struct pt_regs *);
2761da177e4SLinus Torvalds 
2771da177e4SLinus Torvalds /*
2781da177e4SLinus Torvalds  * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
2791da177e4SLinus Torvalds  * task), SP is the stack pointer of the first frame that should be shown in the back
2801da177e4SLinus Torvalds  * trace (or NULL if the entire call-chain of the task should be shown).
2811da177e4SLinus Torvalds  */
2821da177e4SLinus Torvalds extern void show_stack(struct task_struct *task, unsigned long *sp);
2831da177e4SLinus Torvalds 
2841da177e4SLinus Torvalds void io_schedule(void);
2851da177e4SLinus Torvalds long io_schedule_timeout(long timeout);
2861da177e4SLinus Torvalds 
2871da177e4SLinus Torvalds extern void cpu_init (void);
2881da177e4SLinus Torvalds extern void trap_init(void);
289fa13a5a1SPaul Mackerras extern void account_process_tick(struct task_struct *task, int user);
2901da177e4SLinus Torvalds extern void update_process_times(int user);
2911da177e4SLinus Torvalds extern void scheduler_tick(void);
2921da177e4SLinus Torvalds 
29382a1fcb9SIngo Molnar extern void sched_show_task(struct task_struct *p);
29482a1fcb9SIngo Molnar 
2958446f1d3SIngo Molnar #ifdef CONFIG_DETECT_SOFTLOCKUP
2966687a97dSIngo Molnar extern void softlockup_tick(void);
2978446f1d3SIngo Molnar extern void touch_softlockup_watchdog(void);
29804c9167fSJeremy Fitzhardinge extern void touch_all_softlockup_watchdogs(void);
2999c44bc03SIngo Molnar extern unsigned int  softlockup_panic;
30082a1fcb9SIngo Molnar extern unsigned long sysctl_hung_task_check_count;
30182a1fcb9SIngo Molnar extern unsigned long sysctl_hung_task_timeout_secs;
30290739081SIngo Molnar extern unsigned long sysctl_hung_task_warnings;
3039383d967SDimitri Sivanich extern int softlockup_thresh;
3048446f1d3SIngo Molnar #else
3056687a97dSIngo Molnar static inline void softlockup_tick(void)
3068446f1d3SIngo Molnar {
3078446f1d3SIngo Molnar }
3088446f1d3SIngo Molnar static inline void spawn_softlockup_task(void)
3098446f1d3SIngo Molnar {
3108446f1d3SIngo Molnar }
3118446f1d3SIngo Molnar static inline void touch_softlockup_watchdog(void)
3128446f1d3SIngo Molnar {
3138446f1d3SIngo Molnar }
31404c9167fSJeremy Fitzhardinge static inline void touch_all_softlockup_watchdogs(void)
31504c9167fSJeremy Fitzhardinge {
31604c9167fSJeremy Fitzhardinge }
3178446f1d3SIngo Molnar #endif
3188446f1d3SIngo Molnar 
3198446f1d3SIngo Molnar 
3201da177e4SLinus Torvalds /* Attach to any functions which should be ignored in wchan output. */
3211da177e4SLinus Torvalds #define __sched		__attribute__((__section__(".sched.text")))
322deaf2227SIngo Molnar 
323deaf2227SIngo Molnar /* Linker adds these: start and end of __sched functions */
324deaf2227SIngo Molnar extern char __sched_text_start[], __sched_text_end[];
325deaf2227SIngo Molnar 
3261da177e4SLinus Torvalds /* Is this address in the __sched functions? */
3271da177e4SLinus Torvalds extern int in_sched_functions(unsigned long addr);
3281da177e4SLinus Torvalds 
3291da177e4SLinus Torvalds #define	MAX_SCHEDULE_TIMEOUT	LONG_MAX
330b3c97528SHarvey Harrison extern signed long schedule_timeout(signed long timeout);
33164ed93a2SNishanth Aravamudan extern signed long schedule_timeout_interruptible(signed long timeout);
332294d5cc2SMatthew Wilcox extern signed long schedule_timeout_killable(signed long timeout);
33364ed93a2SNishanth Aravamudan extern signed long schedule_timeout_uninterruptible(signed long timeout);
3341da177e4SLinus Torvalds asmlinkage void schedule(void);
3351da177e4SLinus Torvalds 
336ab516013SSerge E. Hallyn struct nsproxy;
337acce292cSCedric Le Goater struct user_namespace;
3381da177e4SLinus Torvalds 
3391da177e4SLinus Torvalds /* Maximum number of active map areas.. This is a random (large) number */
3401da177e4SLinus Torvalds #define DEFAULT_MAX_MAP_COUNT	65536
3411da177e4SLinus Torvalds 
3421da177e4SLinus Torvalds extern int sysctl_max_map_count;
3431da177e4SLinus Torvalds 
3441da177e4SLinus Torvalds #include <linux/aio.h>
3451da177e4SLinus Torvalds 
3461da177e4SLinus Torvalds extern unsigned long
3471da177e4SLinus Torvalds arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
3481da177e4SLinus Torvalds 		       unsigned long, unsigned long);
3491da177e4SLinus Torvalds extern unsigned long
3501da177e4SLinus Torvalds arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
3511da177e4SLinus Torvalds 			  unsigned long len, unsigned long pgoff,
3521da177e4SLinus Torvalds 			  unsigned long flags);
3531363c3cdSWolfgang Wander extern void arch_unmap_area(struct mm_struct *, unsigned long);
3541363c3cdSWolfgang Wander extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
3551da177e4SLinus Torvalds 
356f7d0b926SJeremy Fitzhardinge #if USE_SPLIT_PTLOCKS
357f412ac08SHugh Dickins /*
358f412ac08SHugh Dickins  * The mm counters are not protected by its page_table_lock,
359f412ac08SHugh Dickins  * so must be incremented atomically.
360f412ac08SHugh Dickins  */
361d3cb4871SChristoph Lameter #define set_mm_counter(mm, member, value) atomic_long_set(&(mm)->_##member, value)
362d3cb4871SChristoph Lameter #define get_mm_counter(mm, member) ((unsigned long)atomic_long_read(&(mm)->_##member))
363d3cb4871SChristoph Lameter #define add_mm_counter(mm, member, value) atomic_long_add(value, &(mm)->_##member)
364d3cb4871SChristoph Lameter #define inc_mm_counter(mm, member) atomic_long_inc(&(mm)->_##member)
365d3cb4871SChristoph Lameter #define dec_mm_counter(mm, member) atomic_long_dec(&(mm)->_##member)
366f412ac08SHugh Dickins 
367f7d0b926SJeremy Fitzhardinge #else  /* !USE_SPLIT_PTLOCKS */
368f412ac08SHugh Dickins /*
369f412ac08SHugh Dickins  * The mm counters are protected by its page_table_lock,
370f412ac08SHugh Dickins  * so can be incremented directly.
371f412ac08SHugh Dickins  */
3721da177e4SLinus Torvalds #define set_mm_counter(mm, member, value) (mm)->_##member = (value)
3731da177e4SLinus Torvalds #define get_mm_counter(mm, member) ((mm)->_##member)
3741da177e4SLinus Torvalds #define add_mm_counter(mm, member, value) (mm)->_##member += (value)
3751da177e4SLinus Torvalds #define inc_mm_counter(mm, member) (mm)->_##member++
3761da177e4SLinus Torvalds #define dec_mm_counter(mm, member) (mm)->_##member--
3774294621fSHugh Dickins 
378f7d0b926SJeremy Fitzhardinge #endif /* !USE_SPLIT_PTLOCKS */
379f412ac08SHugh Dickins 
380f412ac08SHugh Dickins #define get_mm_rss(mm)					\
381f412ac08SHugh Dickins 	(get_mm_counter(mm, file_rss) + get_mm_counter(mm, anon_rss))
382365e9c87SHugh Dickins #define update_hiwater_rss(mm)	do {			\
383365e9c87SHugh Dickins 	unsigned long _rss = get_mm_rss(mm);		\
384365e9c87SHugh Dickins 	if ((mm)->hiwater_rss < _rss)			\
385365e9c87SHugh Dickins 		(mm)->hiwater_rss = _rss;		\
386365e9c87SHugh Dickins } while (0)
387365e9c87SHugh Dickins #define update_hiwater_vm(mm)	do {			\
388365e9c87SHugh Dickins 	if ((mm)->hiwater_vm < (mm)->total_vm)		\
389365e9c87SHugh Dickins 		(mm)->hiwater_vm = (mm)->total_vm;	\
390365e9c87SHugh Dickins } while (0)
391365e9c87SHugh Dickins 
3926c5d5238SKawai, Hidehiro extern void set_dumpable(struct mm_struct *mm, int value);
3936c5d5238SKawai, Hidehiro extern int get_dumpable(struct mm_struct *mm);
3946c5d5238SKawai, Hidehiro 
3956c5d5238SKawai, Hidehiro /* mm flags */
3963cb4a0bbSKawai, Hidehiro /* dumpable bits */
3976c5d5238SKawai, Hidehiro #define MMF_DUMPABLE      0  /* core dump is permitted */
3986c5d5238SKawai, Hidehiro #define MMF_DUMP_SECURELY 1  /* core file is readable only by root */
3993cb4a0bbSKawai, Hidehiro #define MMF_DUMPABLE_BITS 2
4003cb4a0bbSKawai, Hidehiro 
4013cb4a0bbSKawai, Hidehiro /* coredump filter bits */
4023cb4a0bbSKawai, Hidehiro #define MMF_DUMP_ANON_PRIVATE	2
4033cb4a0bbSKawai, Hidehiro #define MMF_DUMP_ANON_SHARED	3
4043cb4a0bbSKawai, Hidehiro #define MMF_DUMP_MAPPED_PRIVATE	4
4053cb4a0bbSKawai, Hidehiro #define MMF_DUMP_MAPPED_SHARED	5
40682df3973SRoland McGrath #define MMF_DUMP_ELF_HEADERS	6
407e575f111SKOSAKI Motohiro #define MMF_DUMP_HUGETLB_PRIVATE 7
408e575f111SKOSAKI Motohiro #define MMF_DUMP_HUGETLB_SHARED  8
4093cb4a0bbSKawai, Hidehiro #define MMF_DUMP_FILTER_SHIFT	MMF_DUMPABLE_BITS
410e575f111SKOSAKI Motohiro #define MMF_DUMP_FILTER_BITS	7
4113cb4a0bbSKawai, Hidehiro #define MMF_DUMP_FILTER_MASK \
4123cb4a0bbSKawai, Hidehiro 	(((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
4133cb4a0bbSKawai, Hidehiro #define MMF_DUMP_FILTER_DEFAULT \
414e575f111SKOSAKI Motohiro 	((1 << MMF_DUMP_ANON_PRIVATE) |	(1 << MMF_DUMP_ANON_SHARED) |\
415656eb2cdSRoland McGrath 	 (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)
416656eb2cdSRoland McGrath 
417656eb2cdSRoland McGrath #ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS
418656eb2cdSRoland McGrath # define MMF_DUMP_MASK_DEFAULT_ELF	(1 << MMF_DUMP_ELF_HEADERS)
419656eb2cdSRoland McGrath #else
420656eb2cdSRoland McGrath # define MMF_DUMP_MASK_DEFAULT_ELF	0
421656eb2cdSRoland McGrath #endif
4226c5d5238SKawai, Hidehiro 
4231da177e4SLinus Torvalds struct sighand_struct {
4241da177e4SLinus Torvalds 	atomic_t		count;
4251da177e4SLinus Torvalds 	struct k_sigaction	action[_NSIG];
4261da177e4SLinus Torvalds 	spinlock_t		siglock;
427b8fceee1SDavide Libenzi 	wait_queue_head_t	signalfd_wqh;
4281da177e4SLinus Torvalds };
4291da177e4SLinus Torvalds 
4300e464814SKaiGai Kohei struct pacct_struct {
431f6ec29a4SKaiGai Kohei 	int			ac_flag;
432f6ec29a4SKaiGai Kohei 	long			ac_exitcode;
4330e464814SKaiGai Kohei 	unsigned long		ac_mem;
43477787bfbSKaiGai Kohei 	cputime_t		ac_utime, ac_stime;
43577787bfbSKaiGai Kohei 	unsigned long		ac_minflt, ac_majflt;
4360e464814SKaiGai Kohei };
4370e464814SKaiGai Kohei 
438f06febc9SFrank Mayhar /**
439f06febc9SFrank Mayhar  * struct task_cputime - collected CPU time counts
440f06febc9SFrank Mayhar  * @utime:		time spent in user mode, in &cputime_t units
441f06febc9SFrank Mayhar  * @stime:		time spent in kernel mode, in &cputime_t units
442f06febc9SFrank Mayhar  * @sum_exec_runtime:	total time spent on the CPU, in nanoseconds
443f06febc9SFrank Mayhar  *
444f06febc9SFrank Mayhar  * This structure groups together three kinds of CPU time that are
445f06febc9SFrank Mayhar  * tracked for threads and thread groups.  Most things considering
446f06febc9SFrank Mayhar  * CPU time want to group these counts together and treat all three
447f06febc9SFrank Mayhar  * of them in parallel.
448f06febc9SFrank Mayhar  */
449f06febc9SFrank Mayhar struct task_cputime {
450f06febc9SFrank Mayhar 	cputime_t utime;
451f06febc9SFrank Mayhar 	cputime_t stime;
452f06febc9SFrank Mayhar 	unsigned long long sum_exec_runtime;
453f06febc9SFrank Mayhar };
454f06febc9SFrank Mayhar /* Alternate field names when used to cache expirations. */
455f06febc9SFrank Mayhar #define prof_exp	stime
456f06febc9SFrank Mayhar #define virt_exp	utime
457f06febc9SFrank Mayhar #define sched_exp	sum_exec_runtime
458f06febc9SFrank Mayhar 
459f06febc9SFrank Mayhar /**
460f06febc9SFrank Mayhar  * struct thread_group_cputime - thread group interval timer counts
461f06febc9SFrank Mayhar  * @totals:		thread group interval timers; substructure for
462f06febc9SFrank Mayhar  *			uniprocessor kernel, per-cpu for SMP kernel.
463f06febc9SFrank Mayhar  *
464f06febc9SFrank Mayhar  * This structure contains the version of task_cputime, above, that is
465f06febc9SFrank Mayhar  * used for thread group CPU clock calculations.
466f06febc9SFrank Mayhar  */
467f06febc9SFrank Mayhar struct thread_group_cputime {
468f06febc9SFrank Mayhar 	struct task_cputime *totals;
469f06febc9SFrank Mayhar };
470f06febc9SFrank Mayhar 
4711da177e4SLinus Torvalds /*
4721da177e4SLinus Torvalds  * NOTE! "signal_struct" does not have it's own
4731da177e4SLinus Torvalds  * locking, because a shared signal_struct always
4741da177e4SLinus Torvalds  * implies a shared sighand_struct, so locking
4751da177e4SLinus Torvalds  * sighand_struct is always a proper superset of
4761da177e4SLinus Torvalds  * the locking of signal_struct.
4771da177e4SLinus Torvalds  */
4781da177e4SLinus Torvalds struct signal_struct {
4791da177e4SLinus Torvalds 	atomic_t		count;
4801da177e4SLinus Torvalds 	atomic_t		live;
4811da177e4SLinus Torvalds 
4821da177e4SLinus Torvalds 	wait_queue_head_t	wait_chldexit;	/* for wait4() */
4831da177e4SLinus Torvalds 
4841da177e4SLinus Torvalds 	/* current thread group signal load-balancing target: */
48536c8b586SIngo Molnar 	struct task_struct	*curr_target;
4861da177e4SLinus Torvalds 
4871da177e4SLinus Torvalds 	/* shared signal handling: */
4881da177e4SLinus Torvalds 	struct sigpending	shared_pending;
4891da177e4SLinus Torvalds 
4901da177e4SLinus Torvalds 	/* thread group exit support */
4911da177e4SLinus Torvalds 	int			group_exit_code;
4921da177e4SLinus Torvalds 	/* overloaded:
4931da177e4SLinus Torvalds 	 * - notify group_exit_task when ->count is equal to notify_count
4941da177e4SLinus Torvalds 	 * - everyone except group_exit_task is stopped during signal delivery
4951da177e4SLinus Torvalds 	 *   of fatal signals, group_exit_task processes the signal.
4961da177e4SLinus Torvalds 	 */
4971da177e4SLinus Torvalds 	int			notify_count;
49807dd20e0SRichard Kennedy 	struct task_struct	*group_exit_task;
4991da177e4SLinus Torvalds 
5001da177e4SLinus Torvalds 	/* thread group stop support, overloads group_exit_code too */
5011da177e4SLinus Torvalds 	int			group_stop_count;
5021da177e4SLinus Torvalds 	unsigned int		flags; /* see SIGNAL_* flags below */
5031da177e4SLinus Torvalds 
5041da177e4SLinus Torvalds 	/* POSIX.1b Interval Timers */
5051da177e4SLinus Torvalds 	struct list_head posix_timers;
5061da177e4SLinus Torvalds 
5071da177e4SLinus Torvalds 	/* ITIMER_REAL timer for the process */
5082ff678b8SThomas Gleixner 	struct hrtimer real_timer;
509fea9d175SOleg Nesterov 	struct pid *leader_pid;
5102ff678b8SThomas Gleixner 	ktime_t it_real_incr;
5111da177e4SLinus Torvalds 
5121da177e4SLinus Torvalds 	/* ITIMER_PROF and ITIMER_VIRTUAL timers for the process */
5131da177e4SLinus Torvalds 	cputime_t it_prof_expires, it_virt_expires;
5141da177e4SLinus Torvalds 	cputime_t it_prof_incr, it_virt_incr;
5151da177e4SLinus Torvalds 
516f06febc9SFrank Mayhar 	/*
517f06febc9SFrank Mayhar 	 * Thread group totals for process CPU clocks.
518f06febc9SFrank Mayhar 	 * See thread_group_cputime(), et al, for details.
519f06febc9SFrank Mayhar 	 */
520f06febc9SFrank Mayhar 	struct thread_group_cputime cputime;
521f06febc9SFrank Mayhar 
522f06febc9SFrank Mayhar 	/* Earliest-expiration cache. */
523f06febc9SFrank Mayhar 	struct task_cputime cputime_expires;
524f06febc9SFrank Mayhar 
525f06febc9SFrank Mayhar 	struct list_head cpu_timers[3];
526f06febc9SFrank Mayhar 
5271da177e4SLinus Torvalds 	/* job control IDs */
5289a2e7057SPavel Emelyanov 
5299a2e7057SPavel Emelyanov 	/*
5309a2e7057SPavel Emelyanov 	 * pgrp and session fields are deprecated.
5319a2e7057SPavel Emelyanov 	 * use the task_session_Xnr and task_pgrp_Xnr routines below
5329a2e7057SPavel Emelyanov 	 */
5339a2e7057SPavel Emelyanov 
5349a2e7057SPavel Emelyanov 	union {
5359a2e7057SPavel Emelyanov 		pid_t pgrp __deprecated;
5369a2e7057SPavel Emelyanov 		pid_t __pgrp;
5379a2e7057SPavel Emelyanov 	};
5389a2e7057SPavel Emelyanov 
539ab521dc0SEric W. Biederman 	struct pid *tty_old_pgrp;
5401ec320afSCedric Le Goater 
5411ec320afSCedric Le Goater 	union {
5421ec320afSCedric Le Goater 		pid_t session __deprecated;
5431ec320afSCedric Le Goater 		pid_t __session;
5441ec320afSCedric Le Goater 	};
5451ec320afSCedric Le Goater 
5461da177e4SLinus Torvalds 	/* boolean value for session group leader */
5471da177e4SLinus Torvalds 	int leader;
5481da177e4SLinus Torvalds 
5491da177e4SLinus Torvalds 	struct tty_struct *tty; /* NULL if no tty */
5501da177e4SLinus Torvalds 
5511da177e4SLinus Torvalds 	/*
5521da177e4SLinus Torvalds 	 * Cumulative resource counters for dead threads in the group,
5531da177e4SLinus Torvalds 	 * and for reaped dead child processes forked by this group.
5541da177e4SLinus Torvalds 	 * Live threads maintain their own counters and add to these
5551da177e4SLinus Torvalds 	 * in __exit_signal, except for the group leader.
5561da177e4SLinus Torvalds 	 */
557f06febc9SFrank Mayhar 	cputime_t cutime, cstime;
5589ac52315SLaurent Vivier 	cputime_t gtime;
5599ac52315SLaurent Vivier 	cputime_t cgtime;
5601da177e4SLinus Torvalds 	unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
5611da177e4SLinus Torvalds 	unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
5626eaeeabaSEric Dumazet 	unsigned long inblock, oublock, cinblock, coublock;
563940389b8SAndrea Righi 	struct task_io_accounting ioac;
5641da177e4SLinus Torvalds 
5651da177e4SLinus Torvalds 	/*
5661da177e4SLinus Torvalds 	 * We don't bother to synchronize most readers of this at all,
5671da177e4SLinus Torvalds 	 * because there is no reader checking a limit that actually needs
5681da177e4SLinus Torvalds 	 * to get both rlim_cur and rlim_max atomically, and either one
5691da177e4SLinus Torvalds 	 * alone is a single word that can safely be read normally.
5701da177e4SLinus Torvalds 	 * getrlimit/setrlimit use task_lock(current->group_leader) to
5711da177e4SLinus Torvalds 	 * protect this instead of the siglock, because they really
5721da177e4SLinus Torvalds 	 * have no need to disable irqs.
5731da177e4SLinus Torvalds 	 */
5741da177e4SLinus Torvalds 	struct rlimit rlim[RLIM_NLIMITS];
5751da177e4SLinus Torvalds 
5761da177e4SLinus Torvalds 	/* keep the process-shared keyrings here so that they do the right
5771da177e4SLinus Torvalds 	 * thing in threads created with CLONE_THREAD */
5781da177e4SLinus Torvalds #ifdef CONFIG_KEYS
5791da177e4SLinus Torvalds 	struct key *session_keyring;	/* keyring inherited over fork */
5801da177e4SLinus Torvalds 	struct key *process_keyring;	/* keyring private to this process */
5811da177e4SLinus Torvalds #endif
5820e464814SKaiGai Kohei #ifdef CONFIG_BSD_PROCESS_ACCT
5830e464814SKaiGai Kohei 	struct pacct_struct pacct;	/* per-process accounting information */
5840e464814SKaiGai Kohei #endif
585ad4ecbcbSShailabh Nagar #ifdef CONFIG_TASKSTATS
586ad4ecbcbSShailabh Nagar 	struct taskstats *stats;
587ad4ecbcbSShailabh Nagar #endif
588522ed776SMiloslav Trmac #ifdef CONFIG_AUDIT
589522ed776SMiloslav Trmac 	unsigned audit_tty;
590522ed776SMiloslav Trmac 	struct tty_audit_buf *tty_audit_buf;
591522ed776SMiloslav Trmac #endif
5921da177e4SLinus Torvalds };
5931da177e4SLinus Torvalds 
5944866cde0SNick Piggin /* Context switch must be unlocked if interrupts are to be enabled */
5954866cde0SNick Piggin #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
5964866cde0SNick Piggin # define __ARCH_WANT_UNLOCKED_CTXSW
5974866cde0SNick Piggin #endif
5984866cde0SNick Piggin 
5991da177e4SLinus Torvalds /*
6001da177e4SLinus Torvalds  * Bits in flags field of signal_struct.
6011da177e4SLinus Torvalds  */
6021da177e4SLinus Torvalds #define SIGNAL_STOP_STOPPED	0x00000001 /* job control stop in effect */
6031da177e4SLinus Torvalds #define SIGNAL_STOP_DEQUEUED	0x00000002 /* stop signal dequeued */
6041da177e4SLinus Torvalds #define SIGNAL_STOP_CONTINUED	0x00000004 /* SIGCONT since WCONTINUED reap */
6051da177e4SLinus Torvalds #define SIGNAL_GROUP_EXIT	0x00000008 /* group exit in progress */
606e4420551SOleg Nesterov /*
607e4420551SOleg Nesterov  * Pending notifications to parent.
608e4420551SOleg Nesterov  */
609e4420551SOleg Nesterov #define SIGNAL_CLD_STOPPED	0x00000010
610e4420551SOleg Nesterov #define SIGNAL_CLD_CONTINUED	0x00000020
611e4420551SOleg Nesterov #define SIGNAL_CLD_MASK		(SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
6121da177e4SLinus Torvalds 
613fae5fa44SOleg Nesterov #define SIGNAL_UNKILLABLE	0x00000040 /* for init: ignore fatal signals */
614fae5fa44SOleg Nesterov 
615ed5d2cacSOleg Nesterov /* If true, all threads except ->group_exit_task have pending SIGKILL */
616ed5d2cacSOleg Nesterov static inline int signal_group_exit(const struct signal_struct *sig)
617ed5d2cacSOleg Nesterov {
618ed5d2cacSOleg Nesterov 	return	(sig->flags & SIGNAL_GROUP_EXIT) ||
619ed5d2cacSOleg Nesterov 		(sig->group_exit_task != NULL);
620ed5d2cacSOleg Nesterov }
621ed5d2cacSOleg Nesterov 
6221da177e4SLinus Torvalds /*
6231da177e4SLinus Torvalds  * Some day this will be a full-fledged user tracking system..
6241da177e4SLinus Torvalds  */
6251da177e4SLinus Torvalds struct user_struct {
6261da177e4SLinus Torvalds 	atomic_t __count;	/* reference count */
6271da177e4SLinus Torvalds 	atomic_t processes;	/* How many processes does this user have? */
6281da177e4SLinus Torvalds 	atomic_t files;		/* How many open files does this user have? */
6291da177e4SLinus Torvalds 	atomic_t sigpending;	/* How many pending signals does this user have? */
6302d9048e2SAmy Griffis #ifdef CONFIG_INOTIFY_USER
6310eeca283SRobert Love 	atomic_t inotify_watches; /* How many inotify watches does this user have? */
6320eeca283SRobert Love 	atomic_t inotify_devs;	/* How many inotify devs does this user have opened? */
6330eeca283SRobert Love #endif
634970a8645SAlexey Dobriyan #ifdef CONFIG_POSIX_MQUEUE
6351da177e4SLinus Torvalds 	/* protected by mq_lock	*/
6361da177e4SLinus Torvalds 	unsigned long mq_bytes;	/* How many bytes can be allocated to mqueue? */
637970a8645SAlexey Dobriyan #endif
6381da177e4SLinus Torvalds 	unsigned long locked_shm; /* How many pages of mlocked shm ? */
6391da177e4SLinus Torvalds 
6401da177e4SLinus Torvalds #ifdef CONFIG_KEYS
6411da177e4SLinus Torvalds 	struct key *uid_keyring;	/* UID specific keyring */
6421da177e4SLinus Torvalds 	struct key *session_keyring;	/* UID's default session keyring */
6431da177e4SLinus Torvalds #endif
6441da177e4SLinus Torvalds 
6451da177e4SLinus Torvalds 	/* Hash table maintenance information */
646735de223SPavel Emelyanov 	struct hlist_node uidhash_node;
6471da177e4SLinus Torvalds 	uid_t uid;
64824e377a8SSrivatsa Vaddagiri 
649052f1dc7SPeter Zijlstra #ifdef CONFIG_USER_SCHED
6504cf86d77SIngo Molnar 	struct task_group *tg;
651b1a8c172SDhaval Giani #ifdef CONFIG_SYSFS
652eb41d946SKay Sievers 	struct kobject kobj;
6535cb350baSDhaval Giani 	struct work_struct work;
65424e377a8SSrivatsa Vaddagiri #endif
655b1a8c172SDhaval Giani #endif
6561da177e4SLinus Torvalds };
6571da177e4SLinus Torvalds 
658eb41d946SKay Sievers extern int uids_sysfs_init(void);
6595cb350baSDhaval Giani 
6601da177e4SLinus Torvalds extern struct user_struct *find_user(uid_t);
6611da177e4SLinus Torvalds 
6621da177e4SLinus Torvalds extern struct user_struct root_user;
6631da177e4SLinus Torvalds #define INIT_USER (&root_user)
6641da177e4SLinus Torvalds 
6651da177e4SLinus Torvalds struct backing_dev_info;
6661da177e4SLinus Torvalds struct reclaim_state;
6671da177e4SLinus Torvalds 
66852f17b6cSChandra Seetharaman #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
6691da177e4SLinus Torvalds struct sched_info {
6701da177e4SLinus Torvalds 	/* cumulative counters */
6712d72376bSIngo Molnar 	unsigned long pcount;	      /* # of times run on this cpu */
672172ba844SBalbir Singh 	unsigned long long cpu_time,  /* time spent on the cpu */
673172ba844SBalbir Singh 			   run_delay; /* time spent waiting on a runqueue */
6741da177e4SLinus Torvalds 
6751da177e4SLinus Torvalds 	/* timestamps */
676172ba844SBalbir Singh 	unsigned long long last_arrival,/* when we last ran on a cpu */
6771da177e4SLinus Torvalds 			   last_queued;	/* when we were last queued to run */
678b8efb561SIngo Molnar #ifdef CONFIG_SCHEDSTATS
679b8efb561SIngo Molnar 	/* BKL stats */
680480b9434SKen Chen 	unsigned int bkl_count;
681b8efb561SIngo Molnar #endif
6821da177e4SLinus Torvalds };
68352f17b6cSChandra Seetharaman #endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
6841da177e4SLinus Torvalds 
685ca74e92bSShailabh Nagar #ifdef CONFIG_TASK_DELAY_ACCT
686ca74e92bSShailabh Nagar struct task_delay_info {
687ca74e92bSShailabh Nagar 	spinlock_t	lock;
688ca74e92bSShailabh Nagar 	unsigned int	flags;	/* Private per-task flags */
689ca74e92bSShailabh Nagar 
690ca74e92bSShailabh Nagar 	/* For each stat XXX, add following, aligned appropriately
691ca74e92bSShailabh Nagar 	 *
692ca74e92bSShailabh Nagar 	 * struct timespec XXX_start, XXX_end;
693ca74e92bSShailabh Nagar 	 * u64 XXX_delay;
694ca74e92bSShailabh Nagar 	 * u32 XXX_count;
695ca74e92bSShailabh Nagar 	 *
696ca74e92bSShailabh Nagar 	 * Atomicity of updates to XXX_delay, XXX_count protected by
697ca74e92bSShailabh Nagar 	 * single lock above (split into XXX_lock if contention is an issue).
698ca74e92bSShailabh Nagar 	 */
6990ff92245SShailabh Nagar 
7000ff92245SShailabh Nagar 	/*
7010ff92245SShailabh Nagar 	 * XXX_count is incremented on every XXX operation, the delay
7020ff92245SShailabh Nagar 	 * associated with the operation is added to XXX_delay.
7030ff92245SShailabh Nagar 	 * XXX_delay contains the accumulated delay time in nanoseconds.
7040ff92245SShailabh Nagar 	 */
7050ff92245SShailabh Nagar 	struct timespec blkio_start, blkio_end;	/* Shared by blkio, swapin */
7060ff92245SShailabh Nagar 	u64 blkio_delay;	/* wait for sync block io completion */
7070ff92245SShailabh Nagar 	u64 swapin_delay;	/* wait for swapin block io completion */
7080ff92245SShailabh Nagar 	u32 blkio_count;	/* total count of the number of sync block */
7090ff92245SShailabh Nagar 				/* io operations performed */
7100ff92245SShailabh Nagar 	u32 swapin_count;	/* total count of the number of swapin block */
7110ff92245SShailabh Nagar 				/* io operations performed */
712873b4771SKeika Kobayashi 
713873b4771SKeika Kobayashi 	struct timespec freepages_start, freepages_end;
714873b4771SKeika Kobayashi 	u64 freepages_delay;	/* wait for memory reclaim */
715873b4771SKeika Kobayashi 	u32 freepages_count;	/* total count of memory reclaim */
716ca74e92bSShailabh Nagar };
71752f17b6cSChandra Seetharaman #endif	/* CONFIG_TASK_DELAY_ACCT */
71852f17b6cSChandra Seetharaman 
71952f17b6cSChandra Seetharaman static inline int sched_info_on(void)
72052f17b6cSChandra Seetharaman {
72152f17b6cSChandra Seetharaman #ifdef CONFIG_SCHEDSTATS
72252f17b6cSChandra Seetharaman 	return 1;
72352f17b6cSChandra Seetharaman #elif defined(CONFIG_TASK_DELAY_ACCT)
72452f17b6cSChandra Seetharaman 	extern int delayacct_on;
72552f17b6cSChandra Seetharaman 	return delayacct_on;
72652f17b6cSChandra Seetharaman #else
72752f17b6cSChandra Seetharaman 	return 0;
728ca74e92bSShailabh Nagar #endif
72952f17b6cSChandra Seetharaman }
730ca74e92bSShailabh Nagar 
731d15bcfdbSIngo Molnar enum cpu_idle_type {
732d15bcfdbSIngo Molnar 	CPU_IDLE,
733d15bcfdbSIngo Molnar 	CPU_NOT_IDLE,
734d15bcfdbSIngo Molnar 	CPU_NEWLY_IDLE,
735d15bcfdbSIngo Molnar 	CPU_MAX_IDLE_TYPES
7361da177e4SLinus Torvalds };
7371da177e4SLinus Torvalds 
7381da177e4SLinus Torvalds /*
7391da177e4SLinus Torvalds  * sched-domains (multiprocessor balancing) declarations:
7401da177e4SLinus Torvalds  */
7419aa7b369SIngo Molnar 
7429aa7b369SIngo Molnar /*
7439aa7b369SIngo Molnar  * Increase resolution of nice-level calculations:
7449aa7b369SIngo Molnar  */
7459aa7b369SIngo Molnar #define SCHED_LOAD_SHIFT	10
7469aa7b369SIngo Molnar #define SCHED_LOAD_SCALE	(1L << SCHED_LOAD_SHIFT)
7479aa7b369SIngo Molnar 
748f8700df7SSuresh Siddha #define SCHED_LOAD_SCALE_FUZZ	SCHED_LOAD_SCALE
7491da177e4SLinus Torvalds 
7502dd73a4fSPeter Williams #ifdef CONFIG_SMP
7511da177e4SLinus Torvalds #define SD_LOAD_BALANCE		1	/* Do load balancing on this domain. */
7521da177e4SLinus Torvalds #define SD_BALANCE_NEWIDLE	2	/* Balance when about to become idle */
7531da177e4SLinus Torvalds #define SD_BALANCE_EXEC		4	/* Balance on exec */
754147cbb4bSNick Piggin #define SD_BALANCE_FORK		8	/* Balance on fork, clone */
755147cbb4bSNick Piggin #define SD_WAKE_IDLE		16	/* Wake to idle CPU on task wakeup */
756147cbb4bSNick Piggin #define SD_WAKE_AFFINE		32	/* Wake task to waking CPU */
757147cbb4bSNick Piggin #define SD_WAKE_BALANCE		64	/* Perform balancing at task wakeup */
758147cbb4bSNick Piggin #define SD_SHARE_CPUPOWER	128	/* Domain members share cpu power */
7595c45bf27SSiddha, Suresh B #define SD_POWERSAVINGS_BALANCE	256	/* Balance for power savings */
76089c4710eSSiddha, Suresh B #define SD_SHARE_PKG_RESOURCES	512	/* Domain members share cpu pkg resources */
76108c183f3SChristoph Lameter #define SD_SERIALIZE		1024	/* Only a single load balancing instance */
7621d3504fcSHidetoshi Seto #define SD_WAKE_IDLE_FAR	2048	/* Gain latency sacrificing cache hit */
7635c45bf27SSiddha, Suresh B 
76489c4710eSSiddha, Suresh B #define BALANCE_FOR_MC_POWER	\
76589c4710eSSiddha, Suresh B 	(sched_smt_power_savings ? SD_POWERSAVINGS_BALANCE : 0)
76689c4710eSSiddha, Suresh B 
76789c4710eSSiddha, Suresh B #define BALANCE_FOR_PKG_POWER	\
76889c4710eSSiddha, Suresh B 	((sched_mc_power_savings || sched_smt_power_savings) ?	\
76989c4710eSSiddha, Suresh B 	 SD_POWERSAVINGS_BALANCE : 0)
77089c4710eSSiddha, Suresh B 
77189c4710eSSiddha, Suresh B #define test_sd_parent(sd, flag)	((sd->parent &&		\
77289c4710eSSiddha, Suresh B 					 (sd->parent->flags & flag)) ? 1 : 0)
7735c45bf27SSiddha, Suresh B 
7741da177e4SLinus Torvalds 
7751da177e4SLinus Torvalds struct sched_group {
7761da177e4SLinus Torvalds 	struct sched_group *next;	/* Must be a circular list */
7771da177e4SLinus Torvalds 	cpumask_t cpumask;
7781da177e4SLinus Torvalds 
7791da177e4SLinus Torvalds 	/*
7801da177e4SLinus Torvalds 	 * CPU power of this group, SCHED_LOAD_SCALE being max power for a
7811da177e4SLinus Torvalds 	 * single CPU. This is read only (except for setup, hotplug CPU).
7825517d86bSEric Dumazet 	 * Note : Never change cpu_power without recompute its reciprocal
7831da177e4SLinus Torvalds 	 */
7845517d86bSEric Dumazet 	unsigned int __cpu_power;
7855517d86bSEric Dumazet 	/*
7865517d86bSEric Dumazet 	 * reciprocal value of cpu_power to avoid expensive divides
7875517d86bSEric Dumazet 	 * (see include/linux/reciprocal_div.h)
7885517d86bSEric Dumazet 	 */
7895517d86bSEric Dumazet 	u32 reciprocal_cpu_power;
7901da177e4SLinus Torvalds };
7911da177e4SLinus Torvalds 
7921d3504fcSHidetoshi Seto enum sched_domain_level {
7931d3504fcSHidetoshi Seto 	SD_LV_NONE = 0,
7941d3504fcSHidetoshi Seto 	SD_LV_SIBLING,
7951d3504fcSHidetoshi Seto 	SD_LV_MC,
7961d3504fcSHidetoshi Seto 	SD_LV_CPU,
7971d3504fcSHidetoshi Seto 	SD_LV_NODE,
7981d3504fcSHidetoshi Seto 	SD_LV_ALLNODES,
7991d3504fcSHidetoshi Seto 	SD_LV_MAX
8001d3504fcSHidetoshi Seto };
8011d3504fcSHidetoshi Seto 
8021d3504fcSHidetoshi Seto struct sched_domain_attr {
8031d3504fcSHidetoshi Seto 	int relax_domain_level;
8041d3504fcSHidetoshi Seto };
8051d3504fcSHidetoshi Seto 
8061d3504fcSHidetoshi Seto #define SD_ATTR_INIT	(struct sched_domain_attr) {	\
8071d3504fcSHidetoshi Seto 	.relax_domain_level = -1,			\
8081d3504fcSHidetoshi Seto }
8091d3504fcSHidetoshi Seto 
8101da177e4SLinus Torvalds struct sched_domain {
8111da177e4SLinus Torvalds 	/* These fields must be setup */
8121da177e4SLinus Torvalds 	struct sched_domain *parent;	/* top domain must be null terminated */
8131a848870SSiddha, Suresh B 	struct sched_domain *child;	/* bottom domain must be null terminated */
8141da177e4SLinus Torvalds 	struct sched_group *groups;	/* the balancing groups of the domain */
8151da177e4SLinus Torvalds 	cpumask_t span;			/* span of all CPUs in this domain */
8161da177e4SLinus Torvalds 	unsigned long min_interval;	/* Minimum balance interval ms */
8171da177e4SLinus Torvalds 	unsigned long max_interval;	/* Maximum balance interval ms */
8181da177e4SLinus Torvalds 	unsigned int busy_factor;	/* less balancing by factor if busy */
8191da177e4SLinus Torvalds 	unsigned int imbalance_pct;	/* No balance until over watermark */
8201da177e4SLinus Torvalds 	unsigned int cache_nice_tries;	/* Leave cache hot tasks for # tries */
8217897986bSNick Piggin 	unsigned int busy_idx;
8227897986bSNick Piggin 	unsigned int idle_idx;
8237897986bSNick Piggin 	unsigned int newidle_idx;
8247897986bSNick Piggin 	unsigned int wake_idx;
825147cbb4bSNick Piggin 	unsigned int forkexec_idx;
8261da177e4SLinus Torvalds 	int flags;			/* See SD_* */
8271d3504fcSHidetoshi Seto 	enum sched_domain_level level;
8281da177e4SLinus Torvalds 
8291da177e4SLinus Torvalds 	/* Runtime fields. */
8301da177e4SLinus Torvalds 	unsigned long last_balance;	/* init to jiffies. units in jiffies */
8311da177e4SLinus Torvalds 	unsigned int balance_interval;	/* initialise to 1. units in ms. */
8321da177e4SLinus Torvalds 	unsigned int nr_balance_failed; /* initialise to 0 */
8331da177e4SLinus Torvalds 
8342398f2c6SPeter Zijlstra 	u64 last_update;
8352398f2c6SPeter Zijlstra 
8361da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS
8371da177e4SLinus Torvalds 	/* load_balance() stats */
838480b9434SKen Chen 	unsigned int lb_count[CPU_MAX_IDLE_TYPES];
839480b9434SKen Chen 	unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
840480b9434SKen Chen 	unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
841480b9434SKen Chen 	unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
842480b9434SKen Chen 	unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
843480b9434SKen Chen 	unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
844480b9434SKen Chen 	unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
845480b9434SKen Chen 	unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
8461da177e4SLinus Torvalds 
8471da177e4SLinus Torvalds 	/* Active load balancing */
848480b9434SKen Chen 	unsigned int alb_count;
849480b9434SKen Chen 	unsigned int alb_failed;
850480b9434SKen Chen 	unsigned int alb_pushed;
8511da177e4SLinus Torvalds 
85268767a0aSNick Piggin 	/* SD_BALANCE_EXEC stats */
853480b9434SKen Chen 	unsigned int sbe_count;
854480b9434SKen Chen 	unsigned int sbe_balanced;
855480b9434SKen Chen 	unsigned int sbe_pushed;
8561da177e4SLinus Torvalds 
85768767a0aSNick Piggin 	/* SD_BALANCE_FORK stats */
858480b9434SKen Chen 	unsigned int sbf_count;
859480b9434SKen Chen 	unsigned int sbf_balanced;
860480b9434SKen Chen 	unsigned int sbf_pushed;
86168767a0aSNick Piggin 
8621da177e4SLinus Torvalds 	/* try_to_wake_up() stats */
863480b9434SKen Chen 	unsigned int ttwu_wake_remote;
864480b9434SKen Chen 	unsigned int ttwu_move_affine;
865480b9434SKen Chen 	unsigned int ttwu_move_balance;
8661da177e4SLinus Torvalds #endif
867a5d8c348SIngo Molnar #ifdef CONFIG_SCHED_DEBUG
868a5d8c348SIngo Molnar 	char *name;
869a5d8c348SIngo Molnar #endif
8701da177e4SLinus Torvalds };
8711da177e4SLinus Torvalds 
8721d3504fcSHidetoshi Seto extern void partition_sched_domains(int ndoms_new, cpumask_t *doms_new,
8731d3504fcSHidetoshi Seto 				    struct sched_domain_attr *dattr_new);
8749aefd0abSHeiko Carstens extern int arch_reinit_sched_domains(void);
875029190c5SPaul Jackson 
8761b427c15SIngo Molnar #else /* CONFIG_SMP */
8771b427c15SIngo Molnar 
8781b427c15SIngo Molnar struct sched_domain_attr;
8791b427c15SIngo Molnar 
8801b427c15SIngo Molnar static inline void
8811b427c15SIngo Molnar partition_sched_domains(int ndoms_new, cpumask_t *doms_new,
8821b427c15SIngo Molnar 			struct sched_domain_attr *dattr_new)
8831b427c15SIngo Molnar {
8841b427c15SIngo Molnar }
8851b427c15SIngo Molnar #endif	/* !CONFIG_SMP */
8861da177e4SLinus Torvalds 
8871da177e4SLinus Torvalds struct io_context;			/* See blkdev.h */
8881da177e4SLinus Torvalds #define NGROUPS_SMALL		32
8891bf47346SEric Dumazet #define NGROUPS_PER_BLOCK	((unsigned int)(PAGE_SIZE / sizeof(gid_t)))
8901da177e4SLinus Torvalds struct group_info {
8911da177e4SLinus Torvalds 	int ngroups;
8921da177e4SLinus Torvalds 	atomic_t usage;
8931da177e4SLinus Torvalds 	gid_t small_block[NGROUPS_SMALL];
8941da177e4SLinus Torvalds 	int nblocks;
8951da177e4SLinus Torvalds 	gid_t *blocks[0];
8961da177e4SLinus Torvalds };
8971da177e4SLinus Torvalds 
8981da177e4SLinus Torvalds /*
8991da177e4SLinus Torvalds  * get_group_info() must be called with the owning task locked (via task_lock())
9001da177e4SLinus Torvalds  * when task != current.  The reason being that the vast majority of callers are
9011da177e4SLinus Torvalds  * looking at current->group_info, which can not be changed except by the
9021da177e4SLinus Torvalds  * current task.  Changing current->group_info requires the task lock, too.
9031da177e4SLinus Torvalds  */
9041da177e4SLinus Torvalds #define get_group_info(group_info) do { \
9051da177e4SLinus Torvalds 	atomic_inc(&(group_info)->usage); \
9061da177e4SLinus Torvalds } while (0)
9071da177e4SLinus Torvalds 
9081da177e4SLinus Torvalds #define put_group_info(group_info) do { \
9091da177e4SLinus Torvalds 	if (atomic_dec_and_test(&(group_info)->usage)) \
9101da177e4SLinus Torvalds 		groups_free(group_info); \
9111da177e4SLinus Torvalds } while (0)
9121da177e4SLinus Torvalds 
9133e30148cSDavid Howells extern struct group_info *groups_alloc(int gidsetsize);
9143e30148cSDavid Howells extern void groups_free(struct group_info *group_info);
9153e30148cSDavid Howells extern int set_current_groups(struct group_info *group_info);
9163e30148cSDavid Howells extern int groups_search(struct group_info *group_info, gid_t grp);
9171da177e4SLinus Torvalds /* access the groups "array" with this macro */
9181da177e4SLinus Torvalds #define GROUP_AT(gi, i) \
9191da177e4SLinus Torvalds     ((gi)->blocks[(i)/NGROUPS_PER_BLOCK][(i)%NGROUPS_PER_BLOCK])
9201da177e4SLinus Torvalds 
921383f2835SChen, Kenneth W #ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
92236c8b586SIngo Molnar extern void prefetch_stack(struct task_struct *t);
923383f2835SChen, Kenneth W #else
924383f2835SChen, Kenneth W static inline void prefetch_stack(struct task_struct *t) { }
925383f2835SChen, Kenneth W #endif
9261da177e4SLinus Torvalds 
9271da177e4SLinus Torvalds struct audit_context;		/* See audit.c */
9281da177e4SLinus Torvalds struct mempolicy;
929b92ce558SJens Axboe struct pipe_inode_info;
9304865ecf1SSerge E. Hallyn struct uts_namespace;
9311da177e4SLinus Torvalds 
93220b8a59fSIngo Molnar struct rq;
93320b8a59fSIngo Molnar struct sched_domain;
93420b8a59fSIngo Molnar 
93520b8a59fSIngo Molnar struct sched_class {
9365522d5d5SIngo Molnar 	const struct sched_class *next;
93720b8a59fSIngo Molnar 
938fd390f6aSIngo Molnar 	void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup);
939f02231e5SIngo Molnar 	void (*dequeue_task) (struct rq *rq, struct task_struct *p, int sleep);
9404530d7abSDmitry Adamushko 	void (*yield_task) (struct rq *rq);
94120b8a59fSIngo Molnar 
94215afe09bSPeter Zijlstra 	void (*check_preempt_curr) (struct rq *rq, struct task_struct *p, int sync);
94320b8a59fSIngo Molnar 
944fb8d4724SIngo Molnar 	struct task_struct * (*pick_next_task) (struct rq *rq);
94531ee529cSIngo Molnar 	void (*put_prev_task) (struct rq *rq, struct task_struct *p);
94620b8a59fSIngo Molnar 
947681f3e68SPeter Williams #ifdef CONFIG_SMP
9484ce72a2cSLi Zefan 	int  (*select_task_rq)(struct task_struct *p, int sync);
9494ce72a2cSLi Zefan 
95043010659SPeter Williams 	unsigned long (*load_balance) (struct rq *this_rq, int this_cpu,
951e1d1484fSPeter Williams 			struct rq *busiest, unsigned long max_load_move,
95220b8a59fSIngo Molnar 			struct sched_domain *sd, enum cpu_idle_type idle,
953a4ac01c3SPeter Williams 			int *all_pinned, int *this_best_prio);
95420b8a59fSIngo Molnar 
955e1d1484fSPeter Williams 	int (*move_one_task) (struct rq *this_rq, int this_cpu,
956e1d1484fSPeter Williams 			      struct rq *busiest, struct sched_domain *sd,
957e1d1484fSPeter Williams 			      enum cpu_idle_type idle);
9589a897c5aSSteven Rostedt 	void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
9599a897c5aSSteven Rostedt 	void (*post_schedule) (struct rq *this_rq);
9609a897c5aSSteven Rostedt 	void (*task_wake_up) (struct rq *this_rq, struct task_struct *task);
961e1d1484fSPeter Williams 
962cd8ba7cdSMike Travis 	void (*set_cpus_allowed)(struct task_struct *p,
963cd8ba7cdSMike Travis 				 const cpumask_t *newmask);
96457d885feSGregory Haskins 
9651f11eb6aSGregory Haskins 	void (*rq_online)(struct rq *rq);
9661f11eb6aSGregory Haskins 	void (*rq_offline)(struct rq *rq);
9674ce72a2cSLi Zefan #endif
9684ce72a2cSLi Zefan 
9694ce72a2cSLi Zefan 	void (*set_curr_task) (struct rq *rq);
9704ce72a2cSLi Zefan 	void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
9714ce72a2cSLi Zefan 	void (*task_new) (struct rq *rq, struct task_struct *p);
972cb469845SSteven Rostedt 
973cb469845SSteven Rostedt 	void (*switched_from) (struct rq *this_rq, struct task_struct *task,
974cb469845SSteven Rostedt 			       int running);
975cb469845SSteven Rostedt 	void (*switched_to) (struct rq *this_rq, struct task_struct *task,
976cb469845SSteven Rostedt 			     int running);
977cb469845SSteven Rostedt 	void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
978cb469845SSteven Rostedt 			     int oldprio, int running);
979810b3817SPeter Zijlstra 
980810b3817SPeter Zijlstra #ifdef CONFIG_FAIR_GROUP_SCHED
981810b3817SPeter Zijlstra 	void (*moved_group) (struct task_struct *p);
982810b3817SPeter Zijlstra #endif
98320b8a59fSIngo Molnar };
98420b8a59fSIngo Molnar 
98520b8a59fSIngo Molnar struct load_weight {
98620b8a59fSIngo Molnar 	unsigned long weight, inv_weight;
98720b8a59fSIngo Molnar };
98820b8a59fSIngo Molnar 
98920b8a59fSIngo Molnar /*
99020b8a59fSIngo Molnar  * CFS stats for a schedulable entity (task, task-group etc)
99120b8a59fSIngo Molnar  *
99220b8a59fSIngo Molnar  * Current field usage histogram:
99320b8a59fSIngo Molnar  *
99420b8a59fSIngo Molnar  *     4 se->block_start
99520b8a59fSIngo Molnar  *     4 se->run_node
99620b8a59fSIngo Molnar  *     4 se->sleep_start
99720b8a59fSIngo Molnar  *     6 se->load.weight
99820b8a59fSIngo Molnar  */
99920b8a59fSIngo Molnar struct sched_entity {
100020b8a59fSIngo Molnar 	struct load_weight	load;		/* for load-balancing */
100120b8a59fSIngo Molnar 	struct rb_node		run_node;
10024a55bd5eSPeter Zijlstra 	struct list_head	group_node;
100320b8a59fSIngo Molnar 	unsigned int		on_rq;
100420b8a59fSIngo Molnar 
100520b8a59fSIngo Molnar 	u64			exec_start;
100694c18227SIngo Molnar 	u64			sum_exec_runtime;
1007e9acbff6SIngo Molnar 	u64			vruntime;
1008f6cf891cSIngo Molnar 	u64			prev_sum_exec_runtime;
100994c18227SIngo Molnar 
10104ae7d5ceSIngo Molnar 	u64			last_wakeup;
10114ae7d5ceSIngo Molnar 	u64			avg_overlap;
10124ae7d5ceSIngo Molnar 
101394c18227SIngo Molnar #ifdef CONFIG_SCHEDSTATS
101494c18227SIngo Molnar 	u64			wait_start;
101594c18227SIngo Molnar 	u64			wait_max;
10166d082592SArjan van de Ven 	u64			wait_count;
10176d082592SArjan van de Ven 	u64			wait_sum;
101894c18227SIngo Molnar 
101994c18227SIngo Molnar 	u64			sleep_start;
102020b8a59fSIngo Molnar 	u64			sleep_max;
102194c18227SIngo Molnar 	s64			sum_sleep_runtime;
102294c18227SIngo Molnar 
102394c18227SIngo Molnar 	u64			block_start;
102420b8a59fSIngo Molnar 	u64			block_max;
102520b8a59fSIngo Molnar 	u64			exec_max;
1026eba1ed4bSIngo Molnar 	u64			slice_max;
1027cc367732SIngo Molnar 
1028cc367732SIngo Molnar 	u64			nr_migrations;
1029cc367732SIngo Molnar 	u64			nr_migrations_cold;
1030cc367732SIngo Molnar 	u64			nr_failed_migrations_affine;
1031cc367732SIngo Molnar 	u64			nr_failed_migrations_running;
1032cc367732SIngo Molnar 	u64			nr_failed_migrations_hot;
1033cc367732SIngo Molnar 	u64			nr_forced_migrations;
1034cc367732SIngo Molnar 	u64			nr_forced2_migrations;
1035cc367732SIngo Molnar 
1036cc367732SIngo Molnar 	u64			nr_wakeups;
1037cc367732SIngo Molnar 	u64			nr_wakeups_sync;
1038cc367732SIngo Molnar 	u64			nr_wakeups_migrate;
1039cc367732SIngo Molnar 	u64			nr_wakeups_local;
1040cc367732SIngo Molnar 	u64			nr_wakeups_remote;
1041cc367732SIngo Molnar 	u64			nr_wakeups_affine;
1042cc367732SIngo Molnar 	u64			nr_wakeups_affine_attempts;
1043cc367732SIngo Molnar 	u64			nr_wakeups_passive;
1044cc367732SIngo Molnar 	u64			nr_wakeups_idle;
104594c18227SIngo Molnar #endif
104694c18227SIngo Molnar 
104720b8a59fSIngo Molnar #ifdef CONFIG_FAIR_GROUP_SCHED
104820b8a59fSIngo Molnar 	struct sched_entity	*parent;
104920b8a59fSIngo Molnar 	/* rq on which this entity is (to be) queued: */
105020b8a59fSIngo Molnar 	struct cfs_rq		*cfs_rq;
105120b8a59fSIngo Molnar 	/* rq "owned" by this entity/group: */
105220b8a59fSIngo Molnar 	struct cfs_rq		*my_q;
105320b8a59fSIngo Molnar #endif
105420b8a59fSIngo Molnar };
105570b97a7fSIngo Molnar 
1056fa717060SPeter Zijlstra struct sched_rt_entity {
1057fa717060SPeter Zijlstra 	struct list_head run_list;
105878f2c7dbSPeter Zijlstra 	unsigned long timeout;
1059bee367edSRichard Kennedy 	unsigned int time_slice;
10606f505b16SPeter Zijlstra 	int nr_cpus_allowed;
10616f505b16SPeter Zijlstra 
106258d6c2d7SPeter Zijlstra 	struct sched_rt_entity *back;
1063052f1dc7SPeter Zijlstra #ifdef CONFIG_RT_GROUP_SCHED
10646f505b16SPeter Zijlstra 	struct sched_rt_entity	*parent;
10656f505b16SPeter Zijlstra 	/* rq on which this entity is (to be) queued: */
10666f505b16SPeter Zijlstra 	struct rt_rq		*rt_rq;
10676f505b16SPeter Zijlstra 	/* rq "owned" by this entity/group: */
10686f505b16SPeter Zijlstra 	struct rt_rq		*my_q;
10696f505b16SPeter Zijlstra #endif
1070fa717060SPeter Zijlstra };
1071fa717060SPeter Zijlstra 
10721da177e4SLinus Torvalds struct task_struct {
10731da177e4SLinus Torvalds 	volatile long state;	/* -1 unrunnable, 0 runnable, >0 stopped */
1074f7e4217bSRoman Zippel 	void *stack;
10751da177e4SLinus Torvalds 	atomic_t usage;
107697dc32cdSWilliam Cohen 	unsigned int flags;	/* per process flags, defined below */
107797dc32cdSWilliam Cohen 	unsigned int ptrace;
10781da177e4SLinus Torvalds 
107936772092SPaolo 'Blaisorblade' Giarrusso 	int lock_depth;		/* BKL lock depth */
10801da177e4SLinus Torvalds 
10812dd73a4fSPeter Williams #ifdef CONFIG_SMP
10822dd73a4fSPeter Williams #ifdef __ARCH_WANT_UNLOCKED_CTXSW
10834866cde0SNick Piggin 	int oncpu;
10844866cde0SNick Piggin #endif
10852dd73a4fSPeter Williams #endif
108650e645a8SIngo Molnar 
1087b29739f9SIngo Molnar 	int prio, static_prio, normal_prio;
1088c7aceabaSRichard Kennedy 	unsigned int rt_priority;
10895522d5d5SIngo Molnar 	const struct sched_class *sched_class;
109020b8a59fSIngo Molnar 	struct sched_entity se;
1091fa717060SPeter Zijlstra 	struct sched_rt_entity rt;
10921da177e4SLinus Torvalds 
1093e107be36SAvi Kivity #ifdef CONFIG_PREEMPT_NOTIFIERS
1094e107be36SAvi Kivity 	/* list of struct preempt_notifier: */
1095e107be36SAvi Kivity 	struct hlist_head preempt_notifiers;
1096e107be36SAvi Kivity #endif
1097e107be36SAvi Kivity 
109818796aa0SAlexey Dobriyan 	/*
109918796aa0SAlexey Dobriyan 	 * fpu_counter contains the number of consecutive context switches
110018796aa0SAlexey Dobriyan 	 * that the FPU is used. If this is over a threshold, the lazy fpu
110118796aa0SAlexey Dobriyan 	 * saving becomes unlazy to save the trap. This is an unsigned char
110218796aa0SAlexey Dobriyan 	 * so that after 256 times the counter wraps and the behavior turns
110318796aa0SAlexey Dobriyan 	 * lazy again; this to deal with bursty apps that only use FPU for
110418796aa0SAlexey Dobriyan 	 * a short time
110518796aa0SAlexey Dobriyan 	 */
110618796aa0SAlexey Dobriyan 	unsigned char fpu_counter;
110718796aa0SAlexey Dobriyan 	s8 oomkilladj; /* OOM kill score adjustment (bit shift). */
11086c5c9341SAlexey Dobriyan #ifdef CONFIG_BLK_DEV_IO_TRACE
11092056a782SJens Axboe 	unsigned int btrace_seq;
11106c5c9341SAlexey Dobriyan #endif
11111da177e4SLinus Torvalds 
111297dc32cdSWilliam Cohen 	unsigned int policy;
11131da177e4SLinus Torvalds 	cpumask_t cpus_allowed;
11141da177e4SLinus Torvalds 
1115e260be67SPaul E. McKenney #ifdef CONFIG_PREEMPT_RCU
1116e260be67SPaul E. McKenney 	int rcu_read_lock_nesting;
1117e260be67SPaul E. McKenney 	int rcu_flipctr_idx;
1118e260be67SPaul E. McKenney #endif /* #ifdef CONFIG_PREEMPT_RCU */
1119e260be67SPaul E. McKenney 
112052f17b6cSChandra Seetharaman #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
11211da177e4SLinus Torvalds 	struct sched_info sched_info;
11221da177e4SLinus Torvalds #endif
11231da177e4SLinus Torvalds 
11241da177e4SLinus Torvalds 	struct list_head tasks;
11251da177e4SLinus Torvalds 
11261da177e4SLinus Torvalds 	struct mm_struct *mm, *active_mm;
11271da177e4SLinus Torvalds 
11281da177e4SLinus Torvalds /* task state */
11291da177e4SLinus Torvalds 	struct linux_binfmt *binfmt;
113097dc32cdSWilliam Cohen 	int exit_state;
11311da177e4SLinus Torvalds 	int exit_code, exit_signal;
11321da177e4SLinus Torvalds 	int pdeath_signal;  /*  The signal sent when the parent dies  */
11331da177e4SLinus Torvalds 	/* ??? */
113497dc32cdSWilliam Cohen 	unsigned int personality;
11351da177e4SLinus Torvalds 	unsigned did_exec:1;
11361da177e4SLinus Torvalds 	pid_t pid;
11371da177e4SLinus Torvalds 	pid_t tgid;
11380a425405SArjan van de Ven 
11390a425405SArjan van de Ven #ifdef CONFIG_CC_STACKPROTECTOR
11400a425405SArjan van de Ven 	/* Canary value for the -fstack-protector gcc feature */
11410a425405SArjan van de Ven 	unsigned long stack_canary;
11420a425405SArjan van de Ven #endif
11431da177e4SLinus Torvalds 	/*
11441da177e4SLinus Torvalds 	 * pointers to (original) parent process, youngest child, younger sibling,
11451da177e4SLinus Torvalds 	 * older sibling, respectively.  (p->father can be replaced with
1146f470021aSRoland McGrath 	 * p->real_parent->pid)
11471da177e4SLinus Torvalds 	 */
1148f470021aSRoland McGrath 	struct task_struct *real_parent; /* real parent process */
1149f470021aSRoland McGrath 	struct task_struct *parent; /* recipient of SIGCHLD, wait4() reports */
11501da177e4SLinus Torvalds 	/*
1151f470021aSRoland McGrath 	 * children/sibling forms the list of my natural children
11521da177e4SLinus Torvalds 	 */
11531da177e4SLinus Torvalds 	struct list_head children;	/* list of my children */
11541da177e4SLinus Torvalds 	struct list_head sibling;	/* linkage in my parent's children list */
11551da177e4SLinus Torvalds 	struct task_struct *group_leader;	/* threadgroup leader */
11561da177e4SLinus Torvalds 
1157f470021aSRoland McGrath 	/*
1158f470021aSRoland McGrath 	 * ptraced is the list of tasks this task is using ptrace on.
1159f470021aSRoland McGrath 	 * This includes both natural children and PTRACE_ATTACH targets.
1160f470021aSRoland McGrath 	 * p->ptrace_entry is p's link on the p->parent->ptraced list.
1161f470021aSRoland McGrath 	 */
1162f470021aSRoland McGrath 	struct list_head ptraced;
1163f470021aSRoland McGrath 	struct list_head ptrace_entry;
1164f470021aSRoland McGrath 
1165ca0002a1SMarkus Metzger #ifdef CONFIG_X86_PTRACE_BTS
1166ca0002a1SMarkus Metzger 	/*
1167ca0002a1SMarkus Metzger 	 * This is the tracer handle for the ptrace BTS extension.
1168ca0002a1SMarkus Metzger 	 * This field actually belongs to the ptracer task.
1169ca0002a1SMarkus Metzger 	 */
1170ca0002a1SMarkus Metzger 	struct bts_tracer *bts;
11716abb11aeSMarkus Metzger 	/*
11726abb11aeSMarkus Metzger 	 * The buffer to hold the BTS data.
11736abb11aeSMarkus Metzger 	 */
11746abb11aeSMarkus Metzger 	void *bts_buffer;
1175ca0002a1SMarkus Metzger #endif /* CONFIG_X86_PTRACE_BTS */
1176ca0002a1SMarkus Metzger 
11771da177e4SLinus Torvalds 	/* PID/PID hash table linkage. */
117892476d7fSEric W. Biederman 	struct pid_link pids[PIDTYPE_MAX];
117947e65328SOleg Nesterov 	struct list_head thread_group;
11801da177e4SLinus Torvalds 
11811da177e4SLinus Torvalds 	struct completion *vfork_done;		/* for vfork() */
11821da177e4SLinus Torvalds 	int __user *set_child_tid;		/* CLONE_CHILD_SETTID */
11831da177e4SLinus Torvalds 	int __user *clear_child_tid;		/* CLONE_CHILD_CLEARTID */
11841da177e4SLinus Torvalds 
1185c66f08beSMichael Neuling 	cputime_t utime, stime, utimescaled, stimescaled;
11869ac52315SLaurent Vivier 	cputime_t gtime;
11879301899bSBalbir Singh 	cputime_t prev_utime, prev_stime;
11881da177e4SLinus Torvalds 	unsigned long nvcsw, nivcsw; /* context switch counts */
1189924b42d5STomas Janousek 	struct timespec start_time; 		/* monotonic time */
1190924b42d5STomas Janousek 	struct timespec real_start_time;	/* boot based time */
11911da177e4SLinus Torvalds /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
11921da177e4SLinus Torvalds 	unsigned long min_flt, maj_flt;
11931da177e4SLinus Torvalds 
1194f06febc9SFrank Mayhar 	struct task_cputime cputime_expires;
11951da177e4SLinus Torvalds 	struct list_head cpu_timers[3];
11961da177e4SLinus Torvalds 
11971da177e4SLinus Torvalds /* process credentials */
11981da177e4SLinus Torvalds 	uid_t uid,euid,suid,fsuid;
11991da177e4SLinus Torvalds 	gid_t gid,egid,sgid,fsgid;
12001da177e4SLinus Torvalds 	struct group_info *group_info;
12013b7391deSSerge E. Hallyn 	kernel_cap_t   cap_effective, cap_inheritable, cap_permitted, cap_bset;
12021da177e4SLinus Torvalds 	struct user_struct *user;
1203c7aceabaSRichard Kennedy 	unsigned securebits;
12041da177e4SLinus Torvalds #ifdef CONFIG_KEYS
1205c7aceabaSRichard Kennedy 	unsigned char jit_keyring;	/* default keyring to attach requested keys to */
1206b5f545c8SDavid Howells 	struct key *request_key_auth;	/* assumed request_key authority */
12071da177e4SLinus Torvalds 	struct key *thread_keyring;	/* keyring private to this thread */
12081da177e4SLinus Torvalds #endif
120936772092SPaolo 'Blaisorblade' Giarrusso 	char comm[TASK_COMM_LEN]; /* executable name excluding path
121036772092SPaolo 'Blaisorblade' Giarrusso 				     - access with [gs]et_task_comm (which lock
121136772092SPaolo 'Blaisorblade' Giarrusso 				       it with task_lock())
121236772092SPaolo 'Blaisorblade' Giarrusso 				     - initialized normally by flush_old_exec */
12131da177e4SLinus Torvalds /* file system info */
12141da177e4SLinus Torvalds 	int link_count, total_link_count;
12153d5b6fccSAlexey Dobriyan #ifdef CONFIG_SYSVIPC
12161da177e4SLinus Torvalds /* ipc stuff */
12171da177e4SLinus Torvalds 	struct sysv_sem sysvsem;
12183d5b6fccSAlexey Dobriyan #endif
121982a1fcb9SIngo Molnar #ifdef CONFIG_DETECT_SOFTLOCKUP
122082a1fcb9SIngo Molnar /* hung task detection */
122182a1fcb9SIngo Molnar 	unsigned long last_switch_timestamp;
122282a1fcb9SIngo Molnar 	unsigned long last_switch_count;
122382a1fcb9SIngo Molnar #endif
12241da177e4SLinus Torvalds /* CPU-specific state of this task */
12251da177e4SLinus Torvalds 	struct thread_struct thread;
12261da177e4SLinus Torvalds /* filesystem information */
12271da177e4SLinus Torvalds 	struct fs_struct *fs;
12281da177e4SLinus Torvalds /* open file information */
12291da177e4SLinus Torvalds 	struct files_struct *files;
12301651e14eSSerge E. Hallyn /* namespaces */
1231ab516013SSerge E. Hallyn 	struct nsproxy *nsproxy;
12321da177e4SLinus Torvalds /* signal handlers */
12331da177e4SLinus Torvalds 	struct signal_struct *signal;
12341da177e4SLinus Torvalds 	struct sighand_struct *sighand;
12351da177e4SLinus Torvalds 
12361da177e4SLinus Torvalds 	sigset_t blocked, real_blocked;
1237f3de272bSRoland McGrath 	sigset_t saved_sigmask;	/* restored if set_restore_sigmask() was used */
12381da177e4SLinus Torvalds 	struct sigpending pending;
12391da177e4SLinus Torvalds 
12401da177e4SLinus Torvalds 	unsigned long sas_ss_sp;
12411da177e4SLinus Torvalds 	size_t sas_ss_size;
12421da177e4SLinus Torvalds 	int (*notifier)(void *priv);
12431da177e4SLinus Torvalds 	void *notifier_data;
12441da177e4SLinus Torvalds 	sigset_t *notifier_mask;
124557c521ceSAlexey Dobriyan #ifdef CONFIG_SECURITY
12461da177e4SLinus Torvalds 	void *security;
124757c521ceSAlexey Dobriyan #endif
12481da177e4SLinus Torvalds 	struct audit_context *audit_context;
1249bfef93a5SAl Viro #ifdef CONFIG_AUDITSYSCALL
1250bfef93a5SAl Viro 	uid_t loginuid;
12514746ec5bSEric Paris 	unsigned int sessionid;
1252bfef93a5SAl Viro #endif
12531da177e4SLinus Torvalds 	seccomp_t seccomp;
12541da177e4SLinus Torvalds 
12551da177e4SLinus Torvalds /* Thread group tracking */
12561da177e4SLinus Torvalds    	u32 parent_exec_id;
12571da177e4SLinus Torvalds    	u32 self_exec_id;
12581da177e4SLinus Torvalds /* Protection of (de-)allocation: mm, files, fs, tty, keyrings */
12591da177e4SLinus Torvalds 	spinlock_t alloc_lock;
12601da177e4SLinus Torvalds 
1261b29739f9SIngo Molnar 	/* Protection of the PI data structures: */
1262b29739f9SIngo Molnar 	spinlock_t pi_lock;
1263b29739f9SIngo Molnar 
126423f78d4aSIngo Molnar #ifdef CONFIG_RT_MUTEXES
126523f78d4aSIngo Molnar 	/* PI waiters blocked on a rt_mutex held by this task */
126623f78d4aSIngo Molnar 	struct plist_head pi_waiters;
126723f78d4aSIngo Molnar 	/* Deadlock detection and priority inheritance handling */
126823f78d4aSIngo Molnar 	struct rt_mutex_waiter *pi_blocked_on;
126923f78d4aSIngo Molnar #endif
127023f78d4aSIngo Molnar 
1271408894eeSIngo Molnar #ifdef CONFIG_DEBUG_MUTEXES
1272408894eeSIngo Molnar 	/* mutex deadlock detection */
1273408894eeSIngo Molnar 	struct mutex_waiter *blocked_on;
1274408894eeSIngo Molnar #endif
1275de30a2b3SIngo Molnar #ifdef CONFIG_TRACE_IRQFLAGS
1276de30a2b3SIngo Molnar 	unsigned int irq_events;
1277de30a2b3SIngo Molnar 	int hardirqs_enabled;
1278de30a2b3SIngo Molnar 	unsigned long hardirq_enable_ip;
1279de30a2b3SIngo Molnar 	unsigned int hardirq_enable_event;
1280de30a2b3SIngo Molnar 	unsigned long hardirq_disable_ip;
1281de30a2b3SIngo Molnar 	unsigned int hardirq_disable_event;
1282de30a2b3SIngo Molnar 	int softirqs_enabled;
1283de30a2b3SIngo Molnar 	unsigned long softirq_disable_ip;
1284de30a2b3SIngo Molnar 	unsigned int softirq_disable_event;
1285de30a2b3SIngo Molnar 	unsigned long softirq_enable_ip;
1286de30a2b3SIngo Molnar 	unsigned int softirq_enable_event;
1287de30a2b3SIngo Molnar 	int hardirq_context;
1288de30a2b3SIngo Molnar 	int softirq_context;
1289de30a2b3SIngo Molnar #endif
1290fbb9ce95SIngo Molnar #ifdef CONFIG_LOCKDEP
1291bdb9441eSPeter Zijlstra # define MAX_LOCK_DEPTH 48UL
1292fbb9ce95SIngo Molnar 	u64 curr_chain_key;
1293fbb9ce95SIngo Molnar 	int lockdep_depth;
1294fbb9ce95SIngo Molnar 	unsigned int lockdep_recursion;
1295c7aceabaSRichard Kennedy 	struct held_lock held_locks[MAX_LOCK_DEPTH];
1296fbb9ce95SIngo Molnar #endif
1297408894eeSIngo Molnar 
12981da177e4SLinus Torvalds /* journalling filesystem info */
12991da177e4SLinus Torvalds 	void *journal_info;
13001da177e4SLinus Torvalds 
1301d89d8796SNeil Brown /* stacked block device info */
1302d89d8796SNeil Brown 	struct bio *bio_list, **bio_tail;
1303d89d8796SNeil Brown 
13041da177e4SLinus Torvalds /* VM state */
13051da177e4SLinus Torvalds 	struct reclaim_state *reclaim_state;
13061da177e4SLinus Torvalds 
13071da177e4SLinus Torvalds 	struct backing_dev_info *backing_dev_info;
13081da177e4SLinus Torvalds 
13091da177e4SLinus Torvalds 	struct io_context *io_context;
13101da177e4SLinus Torvalds 
13111da177e4SLinus Torvalds 	unsigned long ptrace_message;
13121da177e4SLinus Torvalds 	siginfo_t *last_siginfo; /* For ptrace use.  */
1313940389b8SAndrea Righi 	struct task_io_accounting ioac;
13148f0ab514SJay Lan #if defined(CONFIG_TASK_XACCT)
13151da177e4SLinus Torvalds 	u64 acct_rss_mem1;	/* accumulated rss usage */
13161da177e4SLinus Torvalds 	u64 acct_vm_mem1;	/* accumulated virtual memory usage */
131749b5cf34SJonathan Lim 	cputime_t acct_timexpd;	/* stime + utime since last update */
13181da177e4SLinus Torvalds #endif
13191da177e4SLinus Torvalds #ifdef CONFIG_CPUSETS
13201da177e4SLinus Torvalds 	nodemask_t mems_allowed;
13211da177e4SLinus Torvalds 	int cpuset_mems_generation;
1322825a46afSPaul Jackson 	int cpuset_mem_spread_rotor;
13231da177e4SLinus Torvalds #endif
1324ddbcc7e8SPaul Menage #ifdef CONFIG_CGROUPS
1325817929ecSPaul Menage 	/* Control Group info protected by css_set_lock */
1326817929ecSPaul Menage 	struct css_set *cgroups;
1327817929ecSPaul Menage 	/* cg_list protected by css_set_lock and tsk->alloc_lock */
1328817929ecSPaul Menage 	struct list_head cg_list;
1329ddbcc7e8SPaul Menage #endif
133042b2dd0aSAlexey Dobriyan #ifdef CONFIG_FUTEX
13310771dfefSIngo Molnar 	struct robust_list_head __user *robust_list;
133234f192c6SIngo Molnar #ifdef CONFIG_COMPAT
133334f192c6SIngo Molnar 	struct compat_robust_list_head __user *compat_robust_list;
133434f192c6SIngo Molnar #endif
1335c87e2837SIngo Molnar 	struct list_head pi_state_list;
1336c87e2837SIngo Molnar 	struct futex_pi_state *pi_state_cache;
133742b2dd0aSAlexey Dobriyan #endif
1338c7aceabaSRichard Kennedy #ifdef CONFIG_NUMA
1339c7aceabaSRichard Kennedy 	struct mempolicy *mempolicy;
1340c7aceabaSRichard Kennedy 	short il_next;
1341c7aceabaSRichard Kennedy #endif
134222e2c507SJens Axboe 	atomic_t fs_excl;	/* holding fs exclusive resources */
1343e56d0903SIngo Molnar 	struct rcu_head rcu;
1344b92ce558SJens Axboe 
1345b92ce558SJens Axboe 	/*
1346b92ce558SJens Axboe 	 * cache last used pipe for splice
1347b92ce558SJens Axboe 	 */
1348b92ce558SJens Axboe 	struct pipe_inode_info *splice_pipe;
1349ca74e92bSShailabh Nagar #ifdef	CONFIG_TASK_DELAY_ACCT
1350ca74e92bSShailabh Nagar 	struct task_delay_info *delays;
1351ca74e92bSShailabh Nagar #endif
1352f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION
1353f4f154fdSAkinobu Mita 	int make_it_fail;
1354f4f154fdSAkinobu Mita #endif
13553e26c149SPeter Zijlstra 	struct prop_local_single dirties;
13569745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP
13579745512cSArjan van de Ven 	int latency_record_count;
13589745512cSArjan van de Ven 	struct latency_record latency_record[LT_SAVECOUNT];
13599745512cSArjan van de Ven #endif
13606976675dSArjan van de Ven 	/*
13616976675dSArjan van de Ven 	 * time slack values; these are used to round up poll() and
13626976675dSArjan van de Ven 	 * select() etc timeout values. These are in nanoseconds.
13636976675dSArjan van de Ven 	 */
13646976675dSArjan van de Ven 	unsigned long timer_slack_ns;
13656976675dSArjan van de Ven 	unsigned long default_timer_slack_ns;
1366f8d570a4SDavid Miller 
1367f8d570a4SDavid Miller 	struct list_head	*scm_work_list;
1368*fb52607aSFrederic Weisbecker #ifdef CONFIG_FUNCTION_GRAPH_TRACER
1369f201ae23SFrederic Weisbecker 	/* Index of current stored adress in ret_stack */
1370f201ae23SFrederic Weisbecker 	int curr_ret_stack;
1371f201ae23SFrederic Weisbecker 	/* Stack of return addresses for return function tracing */
1372f201ae23SFrederic Weisbecker 	struct ftrace_ret_stack	*ret_stack;
1373f201ae23SFrederic Weisbecker 	/*
1374f201ae23SFrederic Weisbecker 	 * Number of functions that haven't been traced
1375f201ae23SFrederic Weisbecker 	 * because of depth overrun.
1376f201ae23SFrederic Weisbecker 	 */
1377f201ae23SFrederic Weisbecker 	atomic_t trace_overrun;
1378f201ae23SFrederic Weisbecker #endif
13791da177e4SLinus Torvalds };
13801da177e4SLinus Torvalds 
1381e05606d3SIngo Molnar /*
1382e05606d3SIngo Molnar  * Priority of a process goes from 0..MAX_PRIO-1, valid RT
1383e05606d3SIngo Molnar  * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
1384e05606d3SIngo Molnar  * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
1385e05606d3SIngo Molnar  * values are inverted: lower p->prio value means higher priority.
1386e05606d3SIngo Molnar  *
1387e05606d3SIngo Molnar  * The MAX_USER_RT_PRIO value allows the actual maximum
1388e05606d3SIngo Molnar  * RT priority to be separate from the value exported to
1389e05606d3SIngo Molnar  * user-space.  This allows kernel threads to set their
1390e05606d3SIngo Molnar  * priority to a value higher than any user task. Note:
1391e05606d3SIngo Molnar  * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
1392e05606d3SIngo Molnar  */
1393e05606d3SIngo Molnar 
1394e05606d3SIngo Molnar #define MAX_USER_RT_PRIO	100
1395e05606d3SIngo Molnar #define MAX_RT_PRIO		MAX_USER_RT_PRIO
1396e05606d3SIngo Molnar 
1397e05606d3SIngo Molnar #define MAX_PRIO		(MAX_RT_PRIO + 40)
1398e05606d3SIngo Molnar #define DEFAULT_PRIO		(MAX_RT_PRIO + 20)
1399e05606d3SIngo Molnar 
1400e05606d3SIngo Molnar static inline int rt_prio(int prio)
1401e05606d3SIngo Molnar {
1402e05606d3SIngo Molnar 	if (unlikely(prio < MAX_RT_PRIO))
1403e05606d3SIngo Molnar 		return 1;
1404e05606d3SIngo Molnar 	return 0;
1405e05606d3SIngo Molnar }
1406e05606d3SIngo Molnar 
1407e868171aSAlexey Dobriyan static inline int rt_task(struct task_struct *p)
1408e05606d3SIngo Molnar {
1409e05606d3SIngo Molnar 	return rt_prio(p->prio);
1410e05606d3SIngo Molnar }
1411e05606d3SIngo Molnar 
1412a47afb0fSPavel Emelianov static inline void set_task_session(struct task_struct *tsk, pid_t session)
1413937949d9SCedric Le Goater {
1414a47afb0fSPavel Emelianov 	tsk->signal->__session = session;
1415937949d9SCedric Le Goater }
1416937949d9SCedric Le Goater 
14179a2e7057SPavel Emelyanov static inline void set_task_pgrp(struct task_struct *tsk, pid_t pgrp)
14189a2e7057SPavel Emelyanov {
14199a2e7057SPavel Emelyanov 	tsk->signal->__pgrp = pgrp;
14209a2e7057SPavel Emelyanov }
14219a2e7057SPavel Emelyanov 
1422e868171aSAlexey Dobriyan static inline struct pid *task_pid(struct task_struct *task)
142322c935f4SEric W. Biederman {
142422c935f4SEric W. Biederman 	return task->pids[PIDTYPE_PID].pid;
142522c935f4SEric W. Biederman }
142622c935f4SEric W. Biederman 
1427e868171aSAlexey Dobriyan static inline struct pid *task_tgid(struct task_struct *task)
142822c935f4SEric W. Biederman {
142922c935f4SEric W. Biederman 	return task->group_leader->pids[PIDTYPE_PID].pid;
143022c935f4SEric W. Biederman }
143122c935f4SEric W. Biederman 
1432e868171aSAlexey Dobriyan static inline struct pid *task_pgrp(struct task_struct *task)
143322c935f4SEric W. Biederman {
143422c935f4SEric W. Biederman 	return task->group_leader->pids[PIDTYPE_PGID].pid;
143522c935f4SEric W. Biederman }
143622c935f4SEric W. Biederman 
1437e868171aSAlexey Dobriyan static inline struct pid *task_session(struct task_struct *task)
143822c935f4SEric W. Biederman {
143922c935f4SEric W. Biederman 	return task->group_leader->pids[PIDTYPE_SID].pid;
144022c935f4SEric W. Biederman }
144122c935f4SEric W. Biederman 
14427af57294SPavel Emelyanov struct pid_namespace;
14437af57294SPavel Emelyanov 
14447af57294SPavel Emelyanov /*
14457af57294SPavel Emelyanov  * the helpers to get the task's different pids as they are seen
14467af57294SPavel Emelyanov  * from various namespaces
14477af57294SPavel Emelyanov  *
14487af57294SPavel Emelyanov  * task_xid_nr()     : global id, i.e. the id seen from the init namespace;
144944c4e1b2SEric W. Biederman  * task_xid_vnr()    : virtual id, i.e. the id seen from the pid namespace of
145044c4e1b2SEric W. Biederman  *                     current.
14517af57294SPavel Emelyanov  * task_xid_nr_ns()  : id seen from the ns specified;
14527af57294SPavel Emelyanov  *
14537af57294SPavel Emelyanov  * set_task_vxid()   : assigns a virtual id to a task;
14547af57294SPavel Emelyanov  *
14557af57294SPavel Emelyanov  * see also pid_nr() etc in include/linux/pid.h
14567af57294SPavel Emelyanov  */
14577af57294SPavel Emelyanov 
1458e868171aSAlexey Dobriyan static inline pid_t task_pid_nr(struct task_struct *tsk)
14597af57294SPavel Emelyanov {
14607af57294SPavel Emelyanov 	return tsk->pid;
14617af57294SPavel Emelyanov }
14627af57294SPavel Emelyanov 
14632f2a3a46SPavel Emelyanov pid_t task_pid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
14647af57294SPavel Emelyanov 
14657af57294SPavel Emelyanov static inline pid_t task_pid_vnr(struct task_struct *tsk)
14667af57294SPavel Emelyanov {
14677af57294SPavel Emelyanov 	return pid_vnr(task_pid(tsk));
14687af57294SPavel Emelyanov }
14697af57294SPavel Emelyanov 
14707af57294SPavel Emelyanov 
1471e868171aSAlexey Dobriyan static inline pid_t task_tgid_nr(struct task_struct *tsk)
14727af57294SPavel Emelyanov {
14737af57294SPavel Emelyanov 	return tsk->tgid;
14747af57294SPavel Emelyanov }
14757af57294SPavel Emelyanov 
14762f2a3a46SPavel Emelyanov pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
14777af57294SPavel Emelyanov 
14787af57294SPavel Emelyanov static inline pid_t task_tgid_vnr(struct task_struct *tsk)
14797af57294SPavel Emelyanov {
14807af57294SPavel Emelyanov 	return pid_vnr(task_tgid(tsk));
14817af57294SPavel Emelyanov }
14827af57294SPavel Emelyanov 
14837af57294SPavel Emelyanov 
1484e868171aSAlexey Dobriyan static inline pid_t task_pgrp_nr(struct task_struct *tsk)
14857af57294SPavel Emelyanov {
14869a2e7057SPavel Emelyanov 	return tsk->signal->__pgrp;
14877af57294SPavel Emelyanov }
14887af57294SPavel Emelyanov 
14892f2a3a46SPavel Emelyanov pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
14907af57294SPavel Emelyanov 
14917af57294SPavel Emelyanov static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
14927af57294SPavel Emelyanov {
14937af57294SPavel Emelyanov 	return pid_vnr(task_pgrp(tsk));
14947af57294SPavel Emelyanov }
14957af57294SPavel Emelyanov 
14967af57294SPavel Emelyanov 
1497e868171aSAlexey Dobriyan static inline pid_t task_session_nr(struct task_struct *tsk)
14987af57294SPavel Emelyanov {
14997af57294SPavel Emelyanov 	return tsk->signal->__session;
15007af57294SPavel Emelyanov }
15017af57294SPavel Emelyanov 
15022f2a3a46SPavel Emelyanov pid_t task_session_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
15037af57294SPavel Emelyanov 
15047af57294SPavel Emelyanov static inline pid_t task_session_vnr(struct task_struct *tsk)
15057af57294SPavel Emelyanov {
15067af57294SPavel Emelyanov 	return pid_vnr(task_session(tsk));
15077af57294SPavel Emelyanov }
15087af57294SPavel Emelyanov 
15097af57294SPavel Emelyanov 
15101da177e4SLinus Torvalds /**
15111da177e4SLinus Torvalds  * pid_alive - check that a task structure is not stale
15121da177e4SLinus Torvalds  * @p: Task structure to be checked.
15131da177e4SLinus Torvalds  *
15141da177e4SLinus Torvalds  * Test if a process is not yet dead (at most zombie state)
15151da177e4SLinus Torvalds  * If pid_alive fails, then pointers within the task structure
15161da177e4SLinus Torvalds  * can be stale and must not be dereferenced.
15171da177e4SLinus Torvalds  */
1518e868171aSAlexey Dobriyan static inline int pid_alive(struct task_struct *p)
15191da177e4SLinus Torvalds {
152092476d7fSEric W. Biederman 	return p->pids[PIDTYPE_PID].pid != NULL;
15211da177e4SLinus Torvalds }
15221da177e4SLinus Torvalds 
1523f400e198SSukadev Bhattiprolu /**
1524b460cbc5SSerge E. Hallyn  * is_global_init - check if a task structure is init
15253260259fSHenne  * @tsk: Task structure to be checked.
15263260259fSHenne  *
15273260259fSHenne  * Check if a task structure is the first user space task the kernel created.
1528f400e198SSukadev Bhattiprolu  */
1529e868171aSAlexey Dobriyan static inline int is_global_init(struct task_struct *tsk)
1530b461cc03SPavel Emelyanov {
1531b461cc03SPavel Emelyanov 	return tsk->pid == 1;
1532b461cc03SPavel Emelyanov }
1533b460cbc5SSerge E. Hallyn 
1534b460cbc5SSerge E. Hallyn /*
1535b460cbc5SSerge E. Hallyn  * is_container_init:
1536b460cbc5SSerge E. Hallyn  * check whether in the task is init in its own pid namespace.
1537b460cbc5SSerge E. Hallyn  */
1538b461cc03SPavel Emelyanov extern int is_container_init(struct task_struct *tsk);
1539f400e198SSukadev Bhattiprolu 
15409ec52099SCedric Le Goater extern struct pid *cad_pid;
15419ec52099SCedric Le Goater 
15421da177e4SLinus Torvalds extern void free_task(struct task_struct *tsk);
15431da177e4SLinus Torvalds #define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
1544e56d0903SIngo Molnar 
1545158d9ebdSAndrew Morton extern void __put_task_struct(struct task_struct *t);
1546e56d0903SIngo Molnar 
1547e56d0903SIngo Molnar static inline void put_task_struct(struct task_struct *t)
1548e56d0903SIngo Molnar {
1549e56d0903SIngo Molnar 	if (atomic_dec_and_test(&t->usage))
15508c7904a0SEric W. Biederman 		__put_task_struct(t);
1551e56d0903SIngo Molnar }
15521da177e4SLinus Torvalds 
155349048622SBalbir Singh extern cputime_t task_utime(struct task_struct *p);
155449048622SBalbir Singh extern cputime_t task_stime(struct task_struct *p);
155549048622SBalbir Singh extern cputime_t task_gtime(struct task_struct *p);
155649048622SBalbir Singh 
15571da177e4SLinus Torvalds /*
15581da177e4SLinus Torvalds  * Per process flags
15591da177e4SLinus Torvalds  */
15601da177e4SLinus Torvalds #define PF_ALIGNWARN	0x00000001	/* Print alignment warning msgs */
15611da177e4SLinus Torvalds 					/* Not implemented yet, only for 486*/
15621da177e4SLinus Torvalds #define PF_STARTING	0x00000002	/* being created */
15631da177e4SLinus Torvalds #define PF_EXITING	0x00000004	/* getting shut down */
1564778e9a9cSAlexey Kuznetsov #define PF_EXITPIDONE	0x00000008	/* pi exit done on shut down */
156594886b84SLaurent Vivier #define PF_VCPU		0x00000010	/* I'm a virtual CPU */
15661da177e4SLinus Torvalds #define PF_FORKNOEXEC	0x00000040	/* forked but didn't exec */
15671da177e4SLinus Torvalds #define PF_SUPERPRIV	0x00000100	/* used super-user privileges */
15681da177e4SLinus Torvalds #define PF_DUMPCORE	0x00000200	/* dumped core */
15691da177e4SLinus Torvalds #define PF_SIGNALED	0x00000400	/* killed by a signal */
15701da177e4SLinus Torvalds #define PF_MEMALLOC	0x00000800	/* Allocating memory */
15711da177e4SLinus Torvalds #define PF_FLUSHER	0x00001000	/* responsible for disk writeback */
15721da177e4SLinus Torvalds #define PF_USED_MATH	0x00002000	/* if unset the fpu must be initialized before use */
15731da177e4SLinus Torvalds #define PF_NOFREEZE	0x00008000	/* this thread should not be frozen */
15741da177e4SLinus Torvalds #define PF_FROZEN	0x00010000	/* frozen for system suspend */
15751da177e4SLinus Torvalds #define PF_FSTRANS	0x00020000	/* inside a filesystem transaction */
15761da177e4SLinus Torvalds #define PF_KSWAPD	0x00040000	/* I am kswapd */
15771da177e4SLinus Torvalds #define PF_SWAPOFF	0x00080000	/* I am in swapoff */
15781da177e4SLinus Torvalds #define PF_LESS_THROTTLE 0x00100000	/* Throttle me less: I clean memory */
1579246bb0b1SOleg Nesterov #define PF_KTHREAD	0x00200000	/* I am a kernel thread */
1580b31dc66aSJens Axboe #define PF_RANDOMIZE	0x00400000	/* randomize virtual address space */
1581b31dc66aSJens Axboe #define PF_SWAPWRITE	0x00800000	/* Allowed to write to swap */
1582b31dc66aSJens Axboe #define PF_SPREAD_PAGE	0x01000000	/* Spread page cache over cpuset */
1583b31dc66aSJens Axboe #define PF_SPREAD_SLAB	0x02000000	/* Spread some slab caches over cpuset */
15849985b0baSDavid Rientjes #define PF_THREAD_BOUND	0x04000000	/* Thread bound to specific cpu */
1585c61afb18SPaul Jackson #define PF_MEMPOLICY	0x10000000	/* Non-default NUMA mempolicy */
158661a87122SThomas Gleixner #define PF_MUTEX_TESTER	0x20000000	/* Thread belongs to the rt mutex tester */
1587ba96a0c8SRafael J. Wysocki #define PF_FREEZER_SKIP	0x40000000	/* Freezer should not count it as freezeable */
1588ebb12db5SRafael J. Wysocki #define PF_FREEZER_NOSIG 0x80000000	/* Freezer won't send signals to it */
15891da177e4SLinus Torvalds 
15901da177e4SLinus Torvalds /*
15911da177e4SLinus Torvalds  * Only the _current_ task can read/write to tsk->flags, but other
15921da177e4SLinus Torvalds  * tasks can access tsk->flags in readonly mode for example
15931da177e4SLinus Torvalds  * with tsk_used_math (like during threaded core dumping).
15941da177e4SLinus Torvalds  * There is however an exception to this rule during ptrace
15951da177e4SLinus Torvalds  * or during fork: the ptracer task is allowed to write to the
15961da177e4SLinus Torvalds  * child->flags of its traced child (same goes for fork, the parent
15971da177e4SLinus Torvalds  * can write to the child->flags), because we're guaranteed the
15981da177e4SLinus Torvalds  * child is not running and in turn not changing child->flags
15991da177e4SLinus Torvalds  * at the same time the parent does it.
16001da177e4SLinus Torvalds  */
16011da177e4SLinus Torvalds #define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
16021da177e4SLinus Torvalds #define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
16031da177e4SLinus Torvalds #define clear_used_math() clear_stopped_child_used_math(current)
16041da177e4SLinus Torvalds #define set_used_math() set_stopped_child_used_math(current)
16051da177e4SLinus Torvalds #define conditional_stopped_child_used_math(condition, child) \
16061da177e4SLinus Torvalds 	do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
16071da177e4SLinus Torvalds #define conditional_used_math(condition) \
16081da177e4SLinus Torvalds 	conditional_stopped_child_used_math(condition, current)
16091da177e4SLinus Torvalds #define copy_to_stopped_child_used_math(child) \
16101da177e4SLinus Torvalds 	do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
16111da177e4SLinus Torvalds /* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
16121da177e4SLinus Torvalds #define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
16131da177e4SLinus Torvalds #define used_math() tsk_used_math(current)
16141da177e4SLinus Torvalds 
16151da177e4SLinus Torvalds #ifdef CONFIG_SMP
1616cd8ba7cdSMike Travis extern int set_cpus_allowed_ptr(struct task_struct *p,
1617cd8ba7cdSMike Travis 				const cpumask_t *new_mask);
16181da177e4SLinus Torvalds #else
1619cd8ba7cdSMike Travis static inline int set_cpus_allowed_ptr(struct task_struct *p,
1620cd8ba7cdSMike Travis 				       const cpumask_t *new_mask)
16211da177e4SLinus Torvalds {
1622cd8ba7cdSMike Travis 	if (!cpu_isset(0, *new_mask))
16231da177e4SLinus Torvalds 		return -EINVAL;
16241da177e4SLinus Torvalds 	return 0;
16251da177e4SLinus Torvalds }
16261da177e4SLinus Torvalds #endif
1627cd8ba7cdSMike Travis static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
1628cd8ba7cdSMike Travis {
1629cd8ba7cdSMike Travis 	return set_cpus_allowed_ptr(p, &new_mask);
1630cd8ba7cdSMike Travis }
16311da177e4SLinus Torvalds 
16321da177e4SLinus Torvalds extern unsigned long long sched_clock(void);
1633e436d800SIngo Molnar 
1634c1955a3dSPeter Zijlstra extern void sched_clock_init(void);
1635c1955a3dSPeter Zijlstra extern u64 sched_clock_cpu(int cpu);
1636c1955a3dSPeter Zijlstra 
16373e51f33fSPeter Zijlstra #ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
16383e51f33fSPeter Zijlstra static inline void sched_clock_tick(void)
16393e51f33fSPeter Zijlstra {
16403e51f33fSPeter Zijlstra }
16413e51f33fSPeter Zijlstra 
16423e51f33fSPeter Zijlstra static inline void sched_clock_idle_sleep_event(void)
16433e51f33fSPeter Zijlstra {
16443e51f33fSPeter Zijlstra }
16453e51f33fSPeter Zijlstra 
16463e51f33fSPeter Zijlstra static inline void sched_clock_idle_wakeup_event(u64 delta_ns)
16473e51f33fSPeter Zijlstra {
16483e51f33fSPeter Zijlstra }
1649e4e4e534SIngo Molnar #else
16503e51f33fSPeter Zijlstra extern void sched_clock_tick(void);
16513e51f33fSPeter Zijlstra extern void sched_clock_idle_sleep_event(void);
16523e51f33fSPeter Zijlstra extern void sched_clock_idle_wakeup_event(u64 delta_ns);
16533e51f33fSPeter Zijlstra #endif
16543e51f33fSPeter Zijlstra 
1655e436d800SIngo Molnar /*
1656e436d800SIngo Molnar  * For kernel-internal use: high-speed (but slightly incorrect) per-cpu
1657e436d800SIngo Molnar  * clock constructed from sched_clock():
1658e436d800SIngo Molnar  */
1659e436d800SIngo Molnar extern unsigned long long cpu_clock(int cpu);
1660e436d800SIngo Molnar 
166136c8b586SIngo Molnar extern unsigned long long
166241b86e9cSIngo Molnar task_sched_runtime(struct task_struct *task);
1663f06febc9SFrank Mayhar extern unsigned long long thread_group_sched_runtime(struct task_struct *task);
16641da177e4SLinus Torvalds 
16651da177e4SLinus Torvalds /* sched_exec is called by processes performing an exec */
16661da177e4SLinus Torvalds #ifdef CONFIG_SMP
16671da177e4SLinus Torvalds extern void sched_exec(void);
16681da177e4SLinus Torvalds #else
16691da177e4SLinus Torvalds #define sched_exec()   {}
16701da177e4SLinus Torvalds #endif
16711da177e4SLinus Torvalds 
16722aa44d05SIngo Molnar extern void sched_clock_idle_sleep_event(void);
16732aa44d05SIngo Molnar extern void sched_clock_idle_wakeup_event(u64 delta_ns);
1674bb29ab26SIngo Molnar 
16751da177e4SLinus Torvalds #ifdef CONFIG_HOTPLUG_CPU
16761da177e4SLinus Torvalds extern void idle_task_exit(void);
16771da177e4SLinus Torvalds #else
16781da177e4SLinus Torvalds static inline void idle_task_exit(void) {}
16791da177e4SLinus Torvalds #endif
16801da177e4SLinus Torvalds 
16811da177e4SLinus Torvalds extern void sched_idle_next(void);
1682b29739f9SIngo Molnar 
168306d8308cSThomas Gleixner #if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
168406d8308cSThomas Gleixner extern void wake_up_idle_cpu(int cpu);
168506d8308cSThomas Gleixner #else
168606d8308cSThomas Gleixner static inline void wake_up_idle_cpu(int cpu) { }
168706d8308cSThomas Gleixner #endif
168806d8308cSThomas Gleixner 
16892bd8e6d4SIngo Molnar #ifdef CONFIG_SCHED_DEBUG
169021805085SPeter Zijlstra extern unsigned int sysctl_sched_latency;
1691b2be5e96SPeter Zijlstra extern unsigned int sysctl_sched_min_granularity;
1692bf0f6f24SIngo Molnar extern unsigned int sysctl_sched_wakeup_granularity;
1693bf0f6f24SIngo Molnar extern unsigned int sysctl_sched_child_runs_first;
1694bf0f6f24SIngo Molnar extern unsigned int sysctl_sched_features;
1695da84d961SIngo Molnar extern unsigned int sysctl_sched_migration_cost;
1696b82d9fddSPeter Zijlstra extern unsigned int sysctl_sched_nr_migrate;
16972398f2c6SPeter Zijlstra extern unsigned int sysctl_sched_shares_ratelimit;
1698ffda12a1SPeter Zijlstra extern unsigned int sysctl_sched_shares_thresh;
1699b2be5e96SPeter Zijlstra 
1700b2be5e96SPeter Zijlstra int sched_nr_latency_handler(struct ctl_table *table, int write,
1701b2be5e96SPeter Zijlstra 		struct file *file, void __user *buffer, size_t *length,
1702b2be5e96SPeter Zijlstra 		loff_t *ppos);
17032bd8e6d4SIngo Molnar #endif
17049f0c1e56SPeter Zijlstra extern unsigned int sysctl_sched_rt_period;
17059f0c1e56SPeter Zijlstra extern int sysctl_sched_rt_runtime;
17062bd8e6d4SIngo Molnar 
1707d0b27fa7SPeter Zijlstra int sched_rt_handler(struct ctl_table *table, int write,
1708d0b27fa7SPeter Zijlstra 		struct file *filp, void __user *buffer, size_t *lenp,
1709d0b27fa7SPeter Zijlstra 		loff_t *ppos);
1710d0b27fa7SPeter Zijlstra 
17112bd8e6d4SIngo Molnar extern unsigned int sysctl_sched_compat_yield;
1712bf0f6f24SIngo Molnar 
1713b29739f9SIngo Molnar #ifdef CONFIG_RT_MUTEXES
171436c8b586SIngo Molnar extern int rt_mutex_getprio(struct task_struct *p);
171536c8b586SIngo Molnar extern void rt_mutex_setprio(struct task_struct *p, int prio);
171636c8b586SIngo Molnar extern void rt_mutex_adjust_pi(struct task_struct *p);
1717b29739f9SIngo Molnar #else
1718e868171aSAlexey Dobriyan static inline int rt_mutex_getprio(struct task_struct *p)
1719b29739f9SIngo Molnar {
1720b29739f9SIngo Molnar 	return p->normal_prio;
1721b29739f9SIngo Molnar }
172295e02ca9SThomas Gleixner # define rt_mutex_adjust_pi(p)		do { } while (0)
1723b29739f9SIngo Molnar #endif
1724b29739f9SIngo Molnar 
172536c8b586SIngo Molnar extern void set_user_nice(struct task_struct *p, long nice);
172636c8b586SIngo Molnar extern int task_prio(const struct task_struct *p);
172736c8b586SIngo Molnar extern int task_nice(const struct task_struct *p);
172836c8b586SIngo Molnar extern int can_nice(const struct task_struct *p, const int nice);
172936c8b586SIngo Molnar extern int task_curr(const struct task_struct *p);
17301da177e4SLinus Torvalds extern int idle_cpu(int cpu);
17311da177e4SLinus Torvalds extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
1732961ccdddSRusty Russell extern int sched_setscheduler_nocheck(struct task_struct *, int,
1733961ccdddSRusty Russell 				      struct sched_param *);
173436c8b586SIngo Molnar extern struct task_struct *idle_task(int cpu);
173536c8b586SIngo Molnar extern struct task_struct *curr_task(int cpu);
173636c8b586SIngo Molnar extern void set_curr_task(int cpu, struct task_struct *p);
17371da177e4SLinus Torvalds 
17381da177e4SLinus Torvalds void yield(void);
17391da177e4SLinus Torvalds 
17401da177e4SLinus Torvalds /*
17411da177e4SLinus Torvalds  * The default (Linux) execution domain.
17421da177e4SLinus Torvalds  */
17431da177e4SLinus Torvalds extern struct exec_domain	default_exec_domain;
17441da177e4SLinus Torvalds 
17451da177e4SLinus Torvalds union thread_union {
17461da177e4SLinus Torvalds 	struct thread_info thread_info;
17471da177e4SLinus Torvalds 	unsigned long stack[THREAD_SIZE/sizeof(long)];
17481da177e4SLinus Torvalds };
17491da177e4SLinus Torvalds 
17501da177e4SLinus Torvalds #ifndef __HAVE_ARCH_KSTACK_END
17511da177e4SLinus Torvalds static inline int kstack_end(void *addr)
17521da177e4SLinus Torvalds {
17531da177e4SLinus Torvalds 	/* Reliable end of stack detection:
17541da177e4SLinus Torvalds 	 * Some APM bios versions misalign the stack
17551da177e4SLinus Torvalds 	 */
17561da177e4SLinus Torvalds 	return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
17571da177e4SLinus Torvalds }
17581da177e4SLinus Torvalds #endif
17591da177e4SLinus Torvalds 
17601da177e4SLinus Torvalds extern union thread_union init_thread_union;
17611da177e4SLinus Torvalds extern struct task_struct init_task;
17621da177e4SLinus Torvalds 
17631da177e4SLinus Torvalds extern struct   mm_struct init_mm;
17641da177e4SLinus Torvalds 
1765198fe21bSPavel Emelyanov extern struct pid_namespace init_pid_ns;
1766198fe21bSPavel Emelyanov 
1767198fe21bSPavel Emelyanov /*
1768198fe21bSPavel Emelyanov  * find a task by one of its numerical ids
1769198fe21bSPavel Emelyanov  *
1770198fe21bSPavel Emelyanov  * find_task_by_pid_type_ns():
1771198fe21bSPavel Emelyanov  *      it is the most generic call - it finds a task by all id,
1772198fe21bSPavel Emelyanov  *      type and namespace specified
1773198fe21bSPavel Emelyanov  * find_task_by_pid_ns():
1774198fe21bSPavel Emelyanov  *      finds a task by its pid in the specified namespace
1775228ebcbeSPavel Emelyanov  * find_task_by_vpid():
1776228ebcbeSPavel Emelyanov  *      finds a task by its virtual pid
1777198fe21bSPavel Emelyanov  *
1778e49859e7SPavel Emelyanov  * see also find_vpid() etc in include/linux/pid.h
1779198fe21bSPavel Emelyanov  */
1780198fe21bSPavel Emelyanov 
1781198fe21bSPavel Emelyanov extern struct task_struct *find_task_by_pid_type_ns(int type, int pid,
1782198fe21bSPavel Emelyanov 		struct pid_namespace *ns);
1783198fe21bSPavel Emelyanov 
1784228ebcbeSPavel Emelyanov extern struct task_struct *find_task_by_vpid(pid_t nr);
1785228ebcbeSPavel Emelyanov extern struct task_struct *find_task_by_pid_ns(pid_t nr,
1786228ebcbeSPavel Emelyanov 		struct pid_namespace *ns);
1787198fe21bSPavel Emelyanov 
17888520d7c7SOleg Nesterov extern void __set_special_pids(struct pid *pid);
17891da177e4SLinus Torvalds 
17901da177e4SLinus Torvalds /* per-UID process charging. */
1791acce292cSCedric Le Goater extern struct user_struct * alloc_uid(struct user_namespace *, uid_t);
17921da177e4SLinus Torvalds static inline struct user_struct *get_uid(struct user_struct *u)
17931da177e4SLinus Torvalds {
17941da177e4SLinus Torvalds 	atomic_inc(&u->__count);
17951da177e4SLinus Torvalds 	return u;
17961da177e4SLinus Torvalds }
17971da177e4SLinus Torvalds extern void free_uid(struct user_struct *);
17981da177e4SLinus Torvalds extern void switch_uid(struct user_struct *);
179928f300d2SPavel Emelyanov extern void release_uids(struct user_namespace *ns);
18001da177e4SLinus Torvalds 
18011da177e4SLinus Torvalds #include <asm/current.h>
18021da177e4SLinus Torvalds 
18033171a030SAtsushi Nemoto extern void do_timer(unsigned long ticks);
18041da177e4SLinus Torvalds 
1805b3c97528SHarvey Harrison extern int wake_up_state(struct task_struct *tsk, unsigned int state);
1806b3c97528SHarvey Harrison extern int wake_up_process(struct task_struct *tsk);
1807b3c97528SHarvey Harrison extern void wake_up_new_task(struct task_struct *tsk,
1808b3c97528SHarvey Harrison 				unsigned long clone_flags);
18091da177e4SLinus Torvalds #ifdef CONFIG_SMP
18101da177e4SLinus Torvalds  extern void kick_process(struct task_struct *tsk);
18111da177e4SLinus Torvalds #else
18121da177e4SLinus Torvalds  static inline void kick_process(struct task_struct *tsk) { }
18131da177e4SLinus Torvalds #endif
1814ad46c2c4SIngo Molnar extern void sched_fork(struct task_struct *p, int clone_flags);
1815ad46c2c4SIngo Molnar extern void sched_dead(struct task_struct *p);
18161da177e4SLinus Torvalds 
18171da177e4SLinus Torvalds extern int in_group_p(gid_t);
18181da177e4SLinus Torvalds extern int in_egroup_p(gid_t);
18191da177e4SLinus Torvalds 
18201da177e4SLinus Torvalds extern void proc_caches_init(void);
18211da177e4SLinus Torvalds extern void flush_signals(struct task_struct *);
182210ab825bSOleg Nesterov extern void ignore_signals(struct task_struct *);
18231da177e4SLinus Torvalds extern void flush_signal_handlers(struct task_struct *, int force_default);
18241da177e4SLinus Torvalds extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
18251da177e4SLinus Torvalds 
18261da177e4SLinus Torvalds static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
18271da177e4SLinus Torvalds {
18281da177e4SLinus Torvalds 	unsigned long flags;
18291da177e4SLinus Torvalds 	int ret;
18301da177e4SLinus Torvalds 
18311da177e4SLinus Torvalds 	spin_lock_irqsave(&tsk->sighand->siglock, flags);
18321da177e4SLinus Torvalds 	ret = dequeue_signal(tsk, mask, info);
18331da177e4SLinus Torvalds 	spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
18341da177e4SLinus Torvalds 
18351da177e4SLinus Torvalds 	return ret;
18361da177e4SLinus Torvalds }
18371da177e4SLinus Torvalds 
18381da177e4SLinus Torvalds extern void block_all_signals(int (*notifier)(void *priv), void *priv,
18391da177e4SLinus Torvalds 			      sigset_t *mask);
18401da177e4SLinus Torvalds extern void unblock_all_signals(void);
18411da177e4SLinus Torvalds extern void release_task(struct task_struct * p);
18421da177e4SLinus Torvalds extern int send_sig_info(int, struct siginfo *, struct task_struct *);
18431da177e4SLinus Torvalds extern int force_sigsegv(int, struct task_struct *);
18441da177e4SLinus Torvalds extern int force_sig_info(int, struct siginfo *, struct task_struct *);
1845c4b92fc1SEric W. Biederman extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
1846c4b92fc1SEric W. Biederman extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
18472425c08bSEric W. Biederman extern int kill_pid_info_as_uid(int, struct siginfo *, struct pid *, uid_t, uid_t, u32);
1848c4b92fc1SEric W. Biederman extern int kill_pgrp(struct pid *pid, int sig, int priv);
1849c4b92fc1SEric W. Biederman extern int kill_pid(struct pid *pid, int sig, int priv);
1850c3de4b38SMatthew Wilcox extern int kill_proc_info(int, struct siginfo *, pid_t);
18512b2a1ff6SRoland McGrath extern int do_notify_parent(struct task_struct *, int);
18521da177e4SLinus Torvalds extern void force_sig(int, struct task_struct *);
18531da177e4SLinus Torvalds extern void force_sig_specific(int, struct task_struct *);
18541da177e4SLinus Torvalds extern int send_sig(int, struct task_struct *, int);
18551da177e4SLinus Torvalds extern void zap_other_threads(struct task_struct *p);
18561da177e4SLinus Torvalds extern struct sigqueue *sigqueue_alloc(void);
18571da177e4SLinus Torvalds extern void sigqueue_free(struct sigqueue *);
1858ac5c2153SOleg Nesterov extern int send_sigqueue(struct sigqueue *,  struct task_struct *, int group);
18599ac95f2fSOleg Nesterov extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
18601da177e4SLinus Torvalds extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long);
18611da177e4SLinus Torvalds 
18629ec52099SCedric Le Goater static inline int kill_cad_pid(int sig, int priv)
18639ec52099SCedric Le Goater {
18649ec52099SCedric Le Goater 	return kill_pid(cad_pid, sig, priv);
18659ec52099SCedric Le Goater }
18669ec52099SCedric Le Goater 
18671da177e4SLinus Torvalds /* These can be the second arg to send_sig_info/send_group_sig_info.  */
18681da177e4SLinus Torvalds #define SEND_SIG_NOINFO ((struct siginfo *) 0)
18691da177e4SLinus Torvalds #define SEND_SIG_PRIV	((struct siginfo *) 1)
18701da177e4SLinus Torvalds #define SEND_SIG_FORCED	((struct siginfo *) 2)
18711da177e4SLinus Torvalds 
1872621d3121SOleg Nesterov static inline int is_si_special(const struct siginfo *info)
1873621d3121SOleg Nesterov {
1874621d3121SOleg Nesterov 	return info <= SEND_SIG_FORCED;
1875621d3121SOleg Nesterov }
1876621d3121SOleg Nesterov 
18771da177e4SLinus Torvalds /* True if we are on the alternate signal stack.  */
18781da177e4SLinus Torvalds 
18791da177e4SLinus Torvalds static inline int on_sig_stack(unsigned long sp)
18801da177e4SLinus Torvalds {
18811da177e4SLinus Torvalds 	return (sp - current->sas_ss_sp < current->sas_ss_size);
18821da177e4SLinus Torvalds }
18831da177e4SLinus Torvalds 
18841da177e4SLinus Torvalds static inline int sas_ss_flags(unsigned long sp)
18851da177e4SLinus Torvalds {
18861da177e4SLinus Torvalds 	return (current->sas_ss_size == 0 ? SS_DISABLE
18871da177e4SLinus Torvalds 		: on_sig_stack(sp) ? SS_ONSTACK : 0);
18881da177e4SLinus Torvalds }
18891da177e4SLinus Torvalds 
18901da177e4SLinus Torvalds /*
18911da177e4SLinus Torvalds  * Routines for handling mm_structs
18921da177e4SLinus Torvalds  */
18931da177e4SLinus Torvalds extern struct mm_struct * mm_alloc(void);
18941da177e4SLinus Torvalds 
18951da177e4SLinus Torvalds /* mmdrop drops the mm and the page tables */
1896b3c97528SHarvey Harrison extern void __mmdrop(struct mm_struct *);
18971da177e4SLinus Torvalds static inline void mmdrop(struct mm_struct * mm)
18981da177e4SLinus Torvalds {
18996fb43d7bSIngo Molnar 	if (unlikely(atomic_dec_and_test(&mm->mm_count)))
19001da177e4SLinus Torvalds 		__mmdrop(mm);
19011da177e4SLinus Torvalds }
19021da177e4SLinus Torvalds 
19031da177e4SLinus Torvalds /* mmput gets rid of the mappings and all user-space */
19041da177e4SLinus Torvalds extern void mmput(struct mm_struct *);
19051da177e4SLinus Torvalds /* Grab a reference to a task's mm, if it is not already going away */
19061da177e4SLinus Torvalds extern struct mm_struct *get_task_mm(struct task_struct *task);
19071da177e4SLinus Torvalds /* Remove the current tasks stale references to the old mm_struct */
19081da177e4SLinus Torvalds extern void mm_release(struct task_struct *, struct mm_struct *);
1909402b0862SCarsten Otte /* Allocate a new mm structure and copy contents from tsk->mm */
1910402b0862SCarsten Otte extern struct mm_struct *dup_mm(struct task_struct *tsk);
19111da177e4SLinus Torvalds 
19121da177e4SLinus Torvalds extern int  copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
19131da177e4SLinus Torvalds extern void flush_thread(void);
19141da177e4SLinus Torvalds extern void exit_thread(void);
19151da177e4SLinus Torvalds 
19161da177e4SLinus Torvalds extern void exit_files(struct task_struct *);
19176b3934efSOleg Nesterov extern void __cleanup_signal(struct signal_struct *);
1918a7e5328aSOleg Nesterov extern void __cleanup_sighand(struct sighand_struct *);
1919cbaffba1SOleg Nesterov 
19201da177e4SLinus Torvalds extern void exit_itimers(struct signal_struct *);
1921cbaffba1SOleg Nesterov extern void flush_itimer_signals(void);
19221da177e4SLinus Torvalds 
19231da177e4SLinus Torvalds extern NORET_TYPE void do_group_exit(int);
19241da177e4SLinus Torvalds 
19251da177e4SLinus Torvalds extern void daemonize(const char *, ...);
19261da177e4SLinus Torvalds extern int allow_signal(int);
19271da177e4SLinus Torvalds extern int disallow_signal(int);
19281da177e4SLinus Torvalds 
19291da177e4SLinus Torvalds extern int do_execve(char *, char __user * __user *, char __user * __user *, struct pt_regs *);
19301da177e4SLinus Torvalds extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
193136c8b586SIngo Molnar struct task_struct *fork_idle(int);
19321da177e4SLinus Torvalds 
19331da177e4SLinus Torvalds extern void set_task_comm(struct task_struct *tsk, char *from);
193459714d65SAndrew Morton extern char *get_task_comm(char *to, struct task_struct *tsk);
19351da177e4SLinus Torvalds 
19361da177e4SLinus Torvalds #ifdef CONFIG_SMP
193785ba2d86SRoland McGrath extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
19381da177e4SLinus Torvalds #else
193985ba2d86SRoland McGrath static inline unsigned long wait_task_inactive(struct task_struct *p,
194085ba2d86SRoland McGrath 					       long match_state)
194185ba2d86SRoland McGrath {
194285ba2d86SRoland McGrath 	return 1;
194385ba2d86SRoland McGrath }
19441da177e4SLinus Torvalds #endif
19451da177e4SLinus Torvalds 
19465e85d4abSEric W. Biederman #define next_task(p)	list_entry(rcu_dereference((p)->tasks.next), struct task_struct, tasks)
19471da177e4SLinus Torvalds 
19481da177e4SLinus Torvalds #define for_each_process(p) \
19491da177e4SLinus Torvalds 	for (p = &init_task ; (p = next_task(p)) != &init_task ; )
19501da177e4SLinus Torvalds 
19511da177e4SLinus Torvalds /*
19521da177e4SLinus Torvalds  * Careful: do_each_thread/while_each_thread is a double loop so
19531da177e4SLinus Torvalds  *          'break' will not work as expected - use goto instead.
19541da177e4SLinus Torvalds  */
19551da177e4SLinus Torvalds #define do_each_thread(g, t) \
19561da177e4SLinus Torvalds 	for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
19571da177e4SLinus Torvalds 
19581da177e4SLinus Torvalds #define while_each_thread(g, t) \
19591da177e4SLinus Torvalds 	while ((t = next_thread(t)) != g)
19601da177e4SLinus Torvalds 
1961de12a787SEric W. Biederman /* de_thread depends on thread_group_leader not being a pid based check */
1962de12a787SEric W. Biederman #define thread_group_leader(p)	(p == p->group_leader)
19631da177e4SLinus Torvalds 
19640804ef4bSEric W. Biederman /* Do to the insanities of de_thread it is possible for a process
19650804ef4bSEric W. Biederman  * to have the pid of the thread group leader without actually being
19660804ef4bSEric W. Biederman  * the thread group leader.  For iteration through the pids in proc
19670804ef4bSEric W. Biederman  * all we care about is that we have a task with the appropriate
19680804ef4bSEric W. Biederman  * pid, we don't actually care if we have the right task.
19690804ef4bSEric W. Biederman  */
1970e868171aSAlexey Dobriyan static inline int has_group_leader_pid(struct task_struct *p)
19710804ef4bSEric W. Biederman {
19720804ef4bSEric W. Biederman 	return p->pid == p->tgid;
19730804ef4bSEric W. Biederman }
19740804ef4bSEric W. Biederman 
1975bac0abd6SPavel Emelyanov static inline
1976bac0abd6SPavel Emelyanov int same_thread_group(struct task_struct *p1, struct task_struct *p2)
1977bac0abd6SPavel Emelyanov {
1978bac0abd6SPavel Emelyanov 	return p1->tgid == p2->tgid;
1979bac0abd6SPavel Emelyanov }
1980bac0abd6SPavel Emelyanov 
198136c8b586SIngo Molnar static inline struct task_struct *next_thread(const struct task_struct *p)
198247e65328SOleg Nesterov {
198347e65328SOleg Nesterov 	return list_entry(rcu_dereference(p->thread_group.next),
198436c8b586SIngo Molnar 			  struct task_struct, thread_group);
198547e65328SOleg Nesterov }
198647e65328SOleg Nesterov 
1987e868171aSAlexey Dobriyan static inline int thread_group_empty(struct task_struct *p)
19881da177e4SLinus Torvalds {
198947e65328SOleg Nesterov 	return list_empty(&p->thread_group);
19901da177e4SLinus Torvalds }
19911da177e4SLinus Torvalds 
19921da177e4SLinus Torvalds #define delay_group_leader(p) \
19931da177e4SLinus Torvalds 		(thread_group_leader(p) && !thread_group_empty(p))
19941da177e4SLinus Torvalds 
19951da177e4SLinus Torvalds /*
1996260ea101SEric W. Biederman  * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
199722e2c507SJens Axboe  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
1998ddbcc7e8SPaul Menage  * pins the final release of task.io_context.  Also protects ->cpuset and
1999ddbcc7e8SPaul Menage  * ->cgroup.subsys[].
20001da177e4SLinus Torvalds  *
20011da177e4SLinus Torvalds  * Nests both inside and outside of read_lock(&tasklist_lock).
20021da177e4SLinus Torvalds  * It must not be nested with write_lock_irq(&tasklist_lock),
20031da177e4SLinus Torvalds  * neither inside nor outside.
20041da177e4SLinus Torvalds  */
20051da177e4SLinus Torvalds static inline void task_lock(struct task_struct *p)
20061da177e4SLinus Torvalds {
20071da177e4SLinus Torvalds 	spin_lock(&p->alloc_lock);
20081da177e4SLinus Torvalds }
20091da177e4SLinus Torvalds 
20101da177e4SLinus Torvalds static inline void task_unlock(struct task_struct *p)
20111da177e4SLinus Torvalds {
20121da177e4SLinus Torvalds 	spin_unlock(&p->alloc_lock);
20131da177e4SLinus Torvalds }
20141da177e4SLinus Torvalds 
2015f63ee72eSOleg Nesterov extern struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
2016f63ee72eSOleg Nesterov 							unsigned long *flags);
2017f63ee72eSOleg Nesterov 
2018f63ee72eSOleg Nesterov static inline void unlock_task_sighand(struct task_struct *tsk,
2019f63ee72eSOleg Nesterov 						unsigned long *flags)
2020f63ee72eSOleg Nesterov {
2021f63ee72eSOleg Nesterov 	spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
2022f63ee72eSOleg Nesterov }
2023f63ee72eSOleg Nesterov 
2024f037360fSAl Viro #ifndef __HAVE_THREAD_FUNCTIONS
2025f037360fSAl Viro 
2026f7e4217bSRoman Zippel #define task_thread_info(task)	((struct thread_info *)(task)->stack)
2027f7e4217bSRoman Zippel #define task_stack_page(task)	((task)->stack)
2028a1261f54SAl Viro 
202910ebffdeSAl Viro static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
203010ebffdeSAl Viro {
203110ebffdeSAl Viro 	*task_thread_info(p) = *task_thread_info(org);
203210ebffdeSAl Viro 	task_thread_info(p)->task = p;
203310ebffdeSAl Viro }
203410ebffdeSAl Viro 
203510ebffdeSAl Viro static inline unsigned long *end_of_stack(struct task_struct *p)
203610ebffdeSAl Viro {
2037f7e4217bSRoman Zippel 	return (unsigned long *)(task_thread_info(p) + 1);
203810ebffdeSAl Viro }
203910ebffdeSAl Viro 
2040f037360fSAl Viro #endif
2041f037360fSAl Viro 
20428b05c7e6SFUJITA Tomonori static inline int object_is_on_stack(void *obj)
20438b05c7e6SFUJITA Tomonori {
20448b05c7e6SFUJITA Tomonori 	void *stack = task_stack_page(current);
20458b05c7e6SFUJITA Tomonori 
20468b05c7e6SFUJITA Tomonori 	return (obj >= stack) && (obj < (stack + THREAD_SIZE));
20478b05c7e6SFUJITA Tomonori }
20488b05c7e6SFUJITA Tomonori 
20498c9843e5SBenjamin Herrenschmidt extern void thread_info_cache_init(void);
20508c9843e5SBenjamin Herrenschmidt 
20511da177e4SLinus Torvalds /* set thread flags in other task's structures
20521da177e4SLinus Torvalds  * - see asm/thread_info.h for TIF_xxxx flags available
20531da177e4SLinus Torvalds  */
20541da177e4SLinus Torvalds static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
20551da177e4SLinus Torvalds {
2056a1261f54SAl Viro 	set_ti_thread_flag(task_thread_info(tsk), flag);
20571da177e4SLinus Torvalds }
20581da177e4SLinus Torvalds 
20591da177e4SLinus Torvalds static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
20601da177e4SLinus Torvalds {
2061a1261f54SAl Viro 	clear_ti_thread_flag(task_thread_info(tsk), flag);
20621da177e4SLinus Torvalds }
20631da177e4SLinus Torvalds 
20641da177e4SLinus Torvalds static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
20651da177e4SLinus Torvalds {
2066a1261f54SAl Viro 	return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
20671da177e4SLinus Torvalds }
20681da177e4SLinus Torvalds 
20691da177e4SLinus Torvalds static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
20701da177e4SLinus Torvalds {
2071a1261f54SAl Viro 	return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
20721da177e4SLinus Torvalds }
20731da177e4SLinus Torvalds 
20741da177e4SLinus Torvalds static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
20751da177e4SLinus Torvalds {
2076a1261f54SAl Viro 	return test_ti_thread_flag(task_thread_info(tsk), flag);
20771da177e4SLinus Torvalds }
20781da177e4SLinus Torvalds 
20791da177e4SLinus Torvalds static inline void set_tsk_need_resched(struct task_struct *tsk)
20801da177e4SLinus Torvalds {
20811da177e4SLinus Torvalds 	set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
20821da177e4SLinus Torvalds }
20831da177e4SLinus Torvalds 
20841da177e4SLinus Torvalds static inline void clear_tsk_need_resched(struct task_struct *tsk)
20851da177e4SLinus Torvalds {
20861da177e4SLinus Torvalds 	clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
20871da177e4SLinus Torvalds }
20881da177e4SLinus Torvalds 
20898ae121acSGregory Haskins static inline int test_tsk_need_resched(struct task_struct *tsk)
20908ae121acSGregory Haskins {
20918ae121acSGregory Haskins 	return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
20928ae121acSGregory Haskins }
20938ae121acSGregory Haskins 
20941da177e4SLinus Torvalds static inline int signal_pending(struct task_struct *p)
20951da177e4SLinus Torvalds {
20961da177e4SLinus Torvalds 	return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
20971da177e4SLinus Torvalds }
20981da177e4SLinus Torvalds 
2099b3c97528SHarvey Harrison extern int __fatal_signal_pending(struct task_struct *p);
2100f776d12dSMatthew Wilcox 
2101f776d12dSMatthew Wilcox static inline int fatal_signal_pending(struct task_struct *p)
2102f776d12dSMatthew Wilcox {
2103f776d12dSMatthew Wilcox 	return signal_pending(p) && __fatal_signal_pending(p);
2104f776d12dSMatthew Wilcox }
2105f776d12dSMatthew Wilcox 
210616882c1eSOleg Nesterov static inline int signal_pending_state(long state, struct task_struct *p)
210716882c1eSOleg Nesterov {
210816882c1eSOleg Nesterov 	if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
210916882c1eSOleg Nesterov 		return 0;
211016882c1eSOleg Nesterov 	if (!signal_pending(p))
211116882c1eSOleg Nesterov 		return 0;
211216882c1eSOleg Nesterov 
211316882c1eSOleg Nesterov 	return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
211416882c1eSOleg Nesterov }
211516882c1eSOleg Nesterov 
21161da177e4SLinus Torvalds static inline int need_resched(void)
21171da177e4SLinus Torvalds {
21189404ef02SLinus Torvalds 	return unlikely(test_thread_flag(TIF_NEED_RESCHED));
21191da177e4SLinus Torvalds }
21201da177e4SLinus Torvalds 
21211da177e4SLinus Torvalds /*
21221da177e4SLinus Torvalds  * cond_resched() and cond_resched_lock(): latency reduction via
21231da177e4SLinus Torvalds  * explicit rescheduling in places that are safe. The return
21241da177e4SLinus Torvalds  * value indicates whether a reschedule was done in fact.
21251da177e4SLinus Torvalds  * cond_resched_lock() will drop the spinlock before scheduling,
21261da177e4SLinus Torvalds  * cond_resched_softirq() will enable bhs before scheduling.
21271da177e4SLinus Torvalds  */
2128c3921ab7SLinus Torvalds extern int _cond_resched(void);
2129c714a534SLinus Torvalds #ifdef CONFIG_PREEMPT_BKL
213002b67cc3SHerbert Xu static inline int cond_resched(void)
213102b67cc3SHerbert Xu {
213202b67cc3SHerbert Xu 	return 0;
213302b67cc3SHerbert Xu }
213402b67cc3SHerbert Xu #else
213502b67cc3SHerbert Xu static inline int cond_resched(void)
213602b67cc3SHerbert Xu {
213702b67cc3SHerbert Xu 	return _cond_resched();
213802b67cc3SHerbert Xu }
213902b67cc3SHerbert Xu #endif
21401da177e4SLinus Torvalds extern int cond_resched_lock(spinlock_t * lock);
21411da177e4SLinus Torvalds extern int cond_resched_softirq(void);
2142c3921ab7SLinus Torvalds static inline int cond_resched_bkl(void)
2143c3921ab7SLinus Torvalds {
2144c3921ab7SLinus Torvalds 	return _cond_resched();
2145c3921ab7SLinus Torvalds }
21461da177e4SLinus Torvalds 
21471da177e4SLinus Torvalds /*
21481da177e4SLinus Torvalds  * Does a critical section need to be broken due to another
214995c354feSNick Piggin  * task waiting?: (technically does not depend on CONFIG_PREEMPT,
215095c354feSNick Piggin  * but a general need for low latency)
21511da177e4SLinus Torvalds  */
215295c354feSNick Piggin static inline int spin_needbreak(spinlock_t *lock)
21531da177e4SLinus Torvalds {
215495c354feSNick Piggin #ifdef CONFIG_PREEMPT
215595c354feSNick Piggin 	return spin_is_contended(lock);
215695c354feSNick Piggin #else
21571da177e4SLinus Torvalds 	return 0;
215895c354feSNick Piggin #endif
21591da177e4SLinus Torvalds }
21601da177e4SLinus Torvalds 
21617bb44adeSRoland McGrath /*
2162f06febc9SFrank Mayhar  * Thread group CPU time accounting.
2163f06febc9SFrank Mayhar  */
2164f06febc9SFrank Mayhar 
2165bb34d92fSFrank Mayhar extern int thread_group_cputime_alloc(struct task_struct *);
2166bb34d92fSFrank Mayhar extern void thread_group_cputime(struct task_struct *, struct task_cputime *);
2167f06febc9SFrank Mayhar 
2168f06febc9SFrank Mayhar static inline void thread_group_cputime_init(struct signal_struct *sig)
2169f06febc9SFrank Mayhar {
2170f06febc9SFrank Mayhar 	sig->cputime.totals = NULL;
2171f06febc9SFrank Mayhar }
2172f06febc9SFrank Mayhar 
2173bb34d92fSFrank Mayhar static inline int thread_group_cputime_clone_thread(struct task_struct *curr)
2174f06febc9SFrank Mayhar {
2175f06febc9SFrank Mayhar 	if (curr->signal->cputime.totals)
2176f06febc9SFrank Mayhar 		return 0;
2177bb34d92fSFrank Mayhar 	return thread_group_cputime_alloc(curr);
2178f06febc9SFrank Mayhar }
2179f06febc9SFrank Mayhar 
2180f06febc9SFrank Mayhar static inline void thread_group_cputime_free(struct signal_struct *sig)
2181f06febc9SFrank Mayhar {
2182f06febc9SFrank Mayhar 	free_percpu(sig->cputime.totals);
2183f06febc9SFrank Mayhar }
2184f06febc9SFrank Mayhar 
2185f06febc9SFrank Mayhar /*
21867bb44adeSRoland McGrath  * Reevaluate whether the task has signals pending delivery.
21877bb44adeSRoland McGrath  * Wake the task if so.
21887bb44adeSRoland McGrath  * This is required every time the blocked sigset_t changes.
21897bb44adeSRoland McGrath  * callers must hold sighand->siglock.
21907bb44adeSRoland McGrath  */
21917bb44adeSRoland McGrath extern void recalc_sigpending_and_wake(struct task_struct *t);
21921da177e4SLinus Torvalds extern void recalc_sigpending(void);
21931da177e4SLinus Torvalds 
21941da177e4SLinus Torvalds extern void signal_wake_up(struct task_struct *t, int resume_stopped);
21951da177e4SLinus Torvalds 
21961da177e4SLinus Torvalds /*
21971da177e4SLinus Torvalds  * Wrappers for p->thread_info->cpu access. No-op on UP.
21981da177e4SLinus Torvalds  */
21991da177e4SLinus Torvalds #ifdef CONFIG_SMP
22001da177e4SLinus Torvalds 
22011da177e4SLinus Torvalds static inline unsigned int task_cpu(const struct task_struct *p)
22021da177e4SLinus Torvalds {
2203a1261f54SAl Viro 	return task_thread_info(p)->cpu;
22041da177e4SLinus Torvalds }
22051da177e4SLinus Torvalds 
2206c65cc870SIngo Molnar extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
22071da177e4SLinus Torvalds 
22081da177e4SLinus Torvalds #else
22091da177e4SLinus Torvalds 
22101da177e4SLinus Torvalds static inline unsigned int task_cpu(const struct task_struct *p)
22111da177e4SLinus Torvalds {
22121da177e4SLinus Torvalds 	return 0;
22131da177e4SLinus Torvalds }
22141da177e4SLinus Torvalds 
22151da177e4SLinus Torvalds static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
22161da177e4SLinus Torvalds {
22171da177e4SLinus Torvalds }
22181da177e4SLinus Torvalds 
22191da177e4SLinus Torvalds #endif /* CONFIG_SMP */
22201da177e4SLinus Torvalds 
22211da177e4SLinus Torvalds extern void arch_pick_mmap_layout(struct mm_struct *mm);
22221da177e4SLinus Torvalds 
22231a3c3034SIngo Molnar #ifdef CONFIG_TRACING
22241a3c3034SIngo Molnar extern void
22251a3c3034SIngo Molnar __trace_special(void *__tr, void *__data,
22261a3c3034SIngo Molnar 		unsigned long arg1, unsigned long arg2, unsigned long arg3);
22271a3c3034SIngo Molnar #else
22281a3c3034SIngo Molnar static inline void
22291a3c3034SIngo Molnar __trace_special(void *__tr, void *__data,
22301a3c3034SIngo Molnar 		unsigned long arg1, unsigned long arg2, unsigned long arg3)
22311a3c3034SIngo Molnar {
22321a3c3034SIngo Molnar }
22331a3c3034SIngo Molnar #endif
22341a3c3034SIngo Molnar 
2235b53e921bSMike Travis extern long sched_setaffinity(pid_t pid, const cpumask_t *new_mask);
22361da177e4SLinus Torvalds extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
22371da177e4SLinus Torvalds 
22385c45bf27SSiddha, Suresh B extern int sched_mc_power_savings, sched_smt_power_savings;
22395c45bf27SSiddha, Suresh B 
22401da177e4SLinus Torvalds extern void normalize_rt_tasks(void);
22411da177e4SLinus Torvalds 
2242052f1dc7SPeter Zijlstra #ifdef CONFIG_GROUP_SCHED
22439b5b7751SSrivatsa Vaddagiri 
22444cf86d77SIngo Molnar extern struct task_group init_task_group;
2245eff766a6SPeter Zijlstra #ifdef CONFIG_USER_SCHED
2246eff766a6SPeter Zijlstra extern struct task_group root_task_group;
2247eff766a6SPeter Zijlstra #endif
22489b5b7751SSrivatsa Vaddagiri 
2249ec7dc8acSDhaval Giani extern struct task_group *sched_create_group(struct task_group *parent);
22504cf86d77SIngo Molnar extern void sched_destroy_group(struct task_group *tg);
22519b5b7751SSrivatsa Vaddagiri extern void sched_move_task(struct task_struct *tsk);
2252052f1dc7SPeter Zijlstra #ifdef CONFIG_FAIR_GROUP_SCHED
22534cf86d77SIngo Molnar extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
22545cb350baSDhaval Giani extern unsigned long sched_group_shares(struct task_group *tg);
2255052f1dc7SPeter Zijlstra #endif
2256052f1dc7SPeter Zijlstra #ifdef CONFIG_RT_GROUP_SCHED
22579f0c1e56SPeter Zijlstra extern int sched_group_set_rt_runtime(struct task_group *tg,
22589f0c1e56SPeter Zijlstra 				      long rt_runtime_us);
22599f0c1e56SPeter Zijlstra extern long sched_group_rt_runtime(struct task_group *tg);
2260d0b27fa7SPeter Zijlstra extern int sched_group_set_rt_period(struct task_group *tg,
2261d0b27fa7SPeter Zijlstra 				      long rt_period_us);
2262d0b27fa7SPeter Zijlstra extern long sched_group_rt_period(struct task_group *tg);
2263052f1dc7SPeter Zijlstra #endif
22649b5b7751SSrivatsa Vaddagiri #endif
22659b5b7751SSrivatsa Vaddagiri 
22664b98d11bSAlexey Dobriyan #ifdef CONFIG_TASK_XACCT
22674b98d11bSAlexey Dobriyan static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
22684b98d11bSAlexey Dobriyan {
2269940389b8SAndrea Righi 	tsk->ioac.rchar += amt;
22704b98d11bSAlexey Dobriyan }
22714b98d11bSAlexey Dobriyan 
22724b98d11bSAlexey Dobriyan static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
22734b98d11bSAlexey Dobriyan {
2274940389b8SAndrea Righi 	tsk->ioac.wchar += amt;
22754b98d11bSAlexey Dobriyan }
22764b98d11bSAlexey Dobriyan 
22774b98d11bSAlexey Dobriyan static inline void inc_syscr(struct task_struct *tsk)
22784b98d11bSAlexey Dobriyan {
2279940389b8SAndrea Righi 	tsk->ioac.syscr++;
22804b98d11bSAlexey Dobriyan }
22814b98d11bSAlexey Dobriyan 
22824b98d11bSAlexey Dobriyan static inline void inc_syscw(struct task_struct *tsk)
22834b98d11bSAlexey Dobriyan {
2284940389b8SAndrea Righi 	tsk->ioac.syscw++;
22854b98d11bSAlexey Dobriyan }
22864b98d11bSAlexey Dobriyan #else
22874b98d11bSAlexey Dobriyan static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
22884b98d11bSAlexey Dobriyan {
22894b98d11bSAlexey Dobriyan }
22904b98d11bSAlexey Dobriyan 
22914b98d11bSAlexey Dobriyan static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
22924b98d11bSAlexey Dobriyan {
22934b98d11bSAlexey Dobriyan }
22944b98d11bSAlexey Dobriyan 
22954b98d11bSAlexey Dobriyan static inline void inc_syscr(struct task_struct *tsk)
22964b98d11bSAlexey Dobriyan {
22974b98d11bSAlexey Dobriyan }
22984b98d11bSAlexey Dobriyan 
22994b98d11bSAlexey Dobriyan static inline void inc_syscw(struct task_struct *tsk)
23004b98d11bSAlexey Dobriyan {
23014b98d11bSAlexey Dobriyan }
23024b98d11bSAlexey Dobriyan #endif
23034b98d11bSAlexey Dobriyan 
230482455257SDave Hansen #ifndef TASK_SIZE_OF
230582455257SDave Hansen #define TASK_SIZE_OF(tsk)	TASK_SIZE
230682455257SDave Hansen #endif
230782455257SDave Hansen 
2308cf475ad2SBalbir Singh #ifdef CONFIG_MM_OWNER
2309cf475ad2SBalbir Singh extern void mm_update_next_owner(struct mm_struct *mm);
2310cf475ad2SBalbir Singh extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
2311cf475ad2SBalbir Singh #else
2312cf475ad2SBalbir Singh static inline void mm_update_next_owner(struct mm_struct *mm)
2313cf475ad2SBalbir Singh {
2314cf475ad2SBalbir Singh }
2315cf475ad2SBalbir Singh 
2316cf475ad2SBalbir Singh static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
2317cf475ad2SBalbir Singh {
2318cf475ad2SBalbir Singh }
2319cf475ad2SBalbir Singh #endif /* CONFIG_MM_OWNER */
2320cf475ad2SBalbir Singh 
23217c731e0aSSteven Rostedt #define TASK_STATE_TO_CHAR_STR "RSDTtZX"
23227c731e0aSSteven Rostedt 
23231da177e4SLinus Torvalds #endif /* __KERNEL__ */
23241da177e4SLinus Torvalds 
23251da177e4SLinus Torvalds #endif
2326