blob: 13c53a99920fc4bc3227b32fd871ccb5d183f33f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _LINUX_SCHED_H
2#define _LINUX_SCHED_H
3
David Howells607ca462012-10-13 10:46:48 +01004#include <uapi/linux/sched.h>
David Woodhouseb7b3c762006-04-27 00:12:56 +01005
David Woodhouseb7b3c762006-04-27 00:12:56 +01006
7struct sched_param {
8 int sched_priority;
9};
10
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <asm/param.h> /* for HZ */
12
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/capability.h>
14#include <linux/threads.h>
15#include <linux/kernel.h>
16#include <linux/types.h>
17#include <linux/timex.h>
18#include <linux/jiffies.h>
Peter Zijlstrafb00aca2013-11-07 14:43:43 +010019#include <linux/plist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/rbtree.h>
21#include <linux/thread_info.h>
22#include <linux/cpumask.h>
23#include <linux/errno.h>
24#include <linux/nodemask.h>
Martin Schwidefskyc92ff1b2007-10-16 01:24:43 -070025#include <linux/mm_types.h>
Thomas Gleixner00d1a392013-09-17 18:53:09 +000026#include <linux/preempt_mask.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <asm/page.h>
29#include <asm/ptrace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <asm/cputime.h>
31
32#include <linux/smp.h>
33#include <linux/sem.h>
34#include <linux/signal.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/compiler.h>
36#include <linux/completion.h>
37#include <linux/pid.h>
38#include <linux/percpu.h>
39#include <linux/topology.h>
Peter Zijlstra3e26c142007-10-16 23:25:50 -070040#include <linux/proportions.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/seccomp.h>
Ingo Molnare56d0902006-01-08 01:01:37 -080042#include <linux/rcupdate.h>
Jiri Pirko05725f72009-04-14 20:17:16 +020043#include <linux/rculist.h>
Ingo Molnar23f78d4a2006-06-27 02:54:53 -070044#include <linux/rtmutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
David Woodhousea3b67142006-04-25 14:54:40 +010046#include <linux/time.h>
47#include <linux/param.h>
48#include <linux/resource.h>
49#include <linux/timer.h>
50#include <linux/hrtimer.h>
Andrew Morton7c3ab732006-12-10 02:19:19 -080051#include <linux/task_io_accounting.h>
Arjan van de Ven97455122008-01-25 21:08:34 +010052#include <linux/latencytop.h>
David Howells9e2b2dc2008-08-13 16:20:04 +010053#include <linux/cred.h>
Peter Zijlstrafa14ff42011-09-12 13:06:17 +020054#include <linux/llist.h>
Eric W. Biederman7b44ab92011-11-16 23:20:58 -080055#include <linux/uidgid.h>
Ming Lei21caf2f2013-02-22 16:34:08 -080056#include <linux/gfp.h>
David Woodhousea3b67142006-04-25 14:54:40 +010057
58#include <asm/processor.h>
H. J. Lu36d57ac2005-09-06 15:16:49 -070059
Dario Faggiolid50dde52013-11-07 14:43:36 +010060#define SCHED_ATTR_SIZE_VER0 48 /* sizeof first published struct */
61
62/*
63 * Extended scheduling parameters data structure.
64 *
65 * This is needed because the original struct sched_param can not be
66 * altered without introducing ABI issues with legacy applications
67 * (e.g., in sched_getparam()).
68 *
69 * However, the possibility of specifying more than just a priority for
70 * the tasks may be useful for a wide variety of application fields, e.g.,
71 * multimedia, streaming, automation and control, and many others.
72 *
73 * This variant (sched_attr) is meant at describing a so-called
74 * sporadic time-constrained task. In such model a task is specified by:
75 * - the activation period or minimum instance inter-arrival time;
76 * - the maximum (or average, depending on the actual scheduling
77 * discipline) computation time of all instances, a.k.a. runtime;
78 * - the deadline (relative to the actual activation time) of each
79 * instance.
80 * Very briefly, a periodic (sporadic) task asks for the execution of
81 * some specific computation --which is typically called an instance--
82 * (at most) every period. Moreover, each instance typically lasts no more
83 * than the runtime and must be completed by time instant t equal to
84 * the instance activation time + the deadline.
85 *
86 * This is reflected by the actual fields of the sched_attr structure:
87 *
88 * @size size of the structure, for fwd/bwd compat.
89 *
90 * @sched_policy task's scheduling policy
91 * @sched_flags for customizing the scheduler behaviour
92 * @sched_nice task's nice value (SCHED_NORMAL/BATCH)
93 * @sched_priority task's static priority (SCHED_FIFO/RR)
94 * @sched_deadline representative of the task's deadline
95 * @sched_runtime representative of the task's runtime
96 * @sched_period representative of the task's period
97 *
98 * Given this task model, there are a multiplicity of scheduling algorithms
99 * and policies, that can be used to ensure all the tasks will make their
100 * timing constraints.
Dario Faggioliaab03e02013-11-28 11:14:43 +0100101 *
102 * As of now, the SCHED_DEADLINE policy (sched_dl scheduling class) is the
103 * only user of this new interface. More information about the algorithm
104 * available in the scheduling class file or in Documentation/.
Dario Faggiolid50dde52013-11-07 14:43:36 +0100105 */
106struct sched_attr {
107 u32 size;
108
109 u32 sched_policy;
110 u64 sched_flags;
111
112 /* SCHED_NORMAL, SCHED_BATCH */
113 s32 sched_nice;
114
115 /* SCHED_FIFO, SCHED_RR */
116 u32 sched_priority;
117
118 /* SCHED_DEADLINE */
119 u64 sched_runtime;
120 u64 sched_deadline;
121 u64 sched_period;
122};
123
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124struct exec_domain;
Ingo Molnarc87e2832006-06-27 02:54:58 -0700125struct futex_pi_state;
Alexey Dobriyan286100a2008-01-25 21:08:34 +0100126struct robust_list_head;
Akinobu Mitabddd87c2010-02-23 08:55:42 +0100127struct bio_list;
Al Viro5ad4e532009-03-29 19:50:06 -0400128struct fs_struct;
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200129struct perf_event_context;
Jens Axboe73c10102011-03-08 13:19:51 +0100130struct blk_plug;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
132/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 * List of flags we want to share for kernel threads,
134 * if only because they are not used by them anyway.
135 */
136#define CLONE_KERNEL (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
137
138/*
139 * These are the constant used to fake the fixed-point load-average
140 * counting. Some notes:
141 * - 11 bit fractions expand to 22 bits by the multiplies: this gives
142 * a load-average precision of 10 bits integer + 11 bits fractional
143 * - if you want to count load-averages more often, you need more
144 * precision, or rounding will get you. With 2-second counting freq,
145 * the EXP_n values would be 1981, 2034 and 2043 if still using only
146 * 11 bit fractions.
147 */
148extern unsigned long avenrun[]; /* Load averages */
Thomas Gleixner2d024942009-05-02 20:08:52 +0200149extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
151#define FSHIFT 11 /* nr of bits of precision */
152#define FIXED_1 (1<<FSHIFT) /* 1.0 as fixed-point */
Linus Torvalds0c2043a2007-10-07 16:17:38 -0700153#define LOAD_FREQ (5*HZ+1) /* 5 sec intervals */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154#define EXP_1 1884 /* 1/exp(5sec/1min) as fixed-point */
155#define EXP_5 2014 /* 1/exp(5sec/5min) */
156#define EXP_15 2037 /* 1/exp(5sec/15min) */
157
158#define CALC_LOAD(load,exp,n) \
159 load *= exp; \
160 load += n*(FIXED_1-exp); \
161 load >>= FSHIFT;
162
163extern unsigned long total_forks;
164extern int nr_threads;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165DECLARE_PER_CPU(unsigned long, process_counts);
166extern int nr_processes(void);
167extern unsigned long nr_running(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168extern unsigned long nr_iowait(void);
Peter Zijlstra8c215bd2010-07-01 09:07:17 +0200169extern unsigned long nr_iowait_cpu(int cpu);
Arjan van de Ven69d25872009-09-21 17:04:08 -0700170extern unsigned long this_cpu_load(void);
171
172
Peter Zijlstra0f004f52010-11-30 19:48:45 +0100173extern void calc_global_load(unsigned long ticks);
Peter Zijlstra5aaa0b72012-05-17 17:15:29 +0200174extern void update_cpu_load_nohz(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Steven Rostedt7e49fcc2009-01-22 19:01:40 -0500176extern unsigned long get_parent_ip(unsigned long addr);
177
Paul E. McKenneyb637a322012-09-19 16:58:38 -0700178extern void dump_cpu_task(int cpu);
179
Ingo Molnar43ae34c2007-07-09 18:52:00 +0200180struct seq_file;
181struct cfs_rq;
Ingo Molnar4cf86d72007-10-15 17:00:14 +0200182struct task_group;
Ingo Molnar43ae34c2007-07-09 18:52:00 +0200183#ifdef CONFIG_SCHED_DEBUG
184extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
185extern void proc_sched_set_task(struct task_struct *p);
186extern void
Ingo Molnar5cef9ec2007-08-09 11:16:47 +0200187print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
Ingo Molnar43ae34c2007-07-09 18:52:00 +0200188#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189
Linus Torvalds4a8342d2005-09-29 15:18:21 -0700190/*
191 * Task state bitmask. NOTE! These bits are also
192 * encoded in fs/proc/array.c: get_task_state().
193 *
194 * We have two separate sets of flags: task->state
195 * is about runnability, while task->exit_state are
196 * about the task exiting. Confusing, but this way
197 * modifying one set can't modify the other one by
198 * mistake.
199 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200#define TASK_RUNNING 0
201#define TASK_INTERRUPTIBLE 1
202#define TASK_UNINTERRUPTIBLE 2
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500203#define __TASK_STOPPED 4
204#define __TASK_TRACED 8
Linus Torvalds4a8342d2005-09-29 15:18:21 -0700205/* in tsk->exit_state */
206#define EXIT_ZOMBIE 16
207#define EXIT_DEAD 32
208/* in tsk->state again */
Mike Galbraithaf927232007-10-15 17:00:13 +0200209#define TASK_DEAD 64
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500210#define TASK_WAKEKILL 128
Peter Zijlstrae9c84312009-09-15 14:43:03 +0200211#define TASK_WAKING 256
Thomas Gleixnerf2530dc2013-04-09 09:33:34 +0200212#define TASK_PARKED 512
213#define TASK_STATE_MAX 1024
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500214
Thomas Gleixnerf2530dc2013-04-09 09:33:34 +0200215#define TASK_STATE_TO_CHAR_STR "RSDTtZXxKWP"
Peter Zijlstra73342152009-12-17 13:16:27 +0100216
Peter Zijlstrae1781532009-12-17 13:16:30 +0100217extern char ___assert_task_state[1 - 2*!!(
218 sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1)];
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500219
220/* Convenience macros for the sake of set_task_state */
221#define TASK_KILLABLE (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
222#define TASK_STOPPED (TASK_WAKEKILL | __TASK_STOPPED)
223#define TASK_TRACED (TASK_WAKEKILL | __TASK_TRACED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500225/* Convenience macros for the sake of wake_up */
226#define TASK_NORMAL (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500227#define TASK_ALL (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500228
229/* get_task_state() */
230#define TASK_REPORT (TASK_RUNNING | TASK_INTERRUPTIBLE | \
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500231 TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
232 __TASK_TRACED)
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500233
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500234#define task_is_traced(task) ((task->state & __TASK_TRACED) != 0)
235#define task_is_stopped(task) ((task->state & __TASK_STOPPED) != 0)
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500236#define task_is_stopped_or_traced(task) \
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500237 ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500238#define task_contributes_to_load(task) \
Nathan Lynche3c8ca82009-04-08 19:45:12 -0500239 ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
Tejun Heo376fede2011-11-21 12:32:24 -0800240 (task->flags & PF_FROZEN) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
242#define __set_task_state(tsk, state_value) \
243 do { (tsk)->state = (state_value); } while (0)
244#define set_task_state(tsk, state_value) \
245 set_mb((tsk)->state, (state_value))
246
Andrew Morton498d0c52005-09-13 01:25:14 -0700247/*
248 * set_current_state() includes a barrier so that the write of current->state
249 * is correctly serialised wrt the caller's subsequent test of whether to
250 * actually sleep:
251 *
252 * set_current_state(TASK_UNINTERRUPTIBLE);
253 * if (do_i_need_to_sleep())
254 * schedule();
255 *
256 * If the caller does not need such serialisation then use __set_current_state()
257 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258#define __set_current_state(state_value) \
259 do { current->state = (state_value); } while (0)
260#define set_current_state(state_value) \
261 set_mb(current->state, (state_value))
262
263/* Task command name length */
264#define TASK_COMM_LEN 16
265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266#include <linux/spinlock.h>
267
268/*
269 * This serializes "schedule()" and also protects
270 * the run-queue from deletions/modifications (but
271 * _adding_ to the beginning of the run-queue has
272 * a separate lock).
273 */
274extern rwlock_t tasklist_lock;
275extern spinlock_t mmlist_lock;
276
Ingo Molnar36c8b582006-07-03 00:25:41 -0700277struct task_struct;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
Paul E. McKenneydb1466b2010-03-03 07:46:56 -0800279#ifdef CONFIG_PROVE_RCU
280extern int lockdep_tasklist_lock_is_held(void);
281#endif /* #ifdef CONFIG_PROVE_RCU */
282
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283extern void sched_init(void);
284extern void sched_init_smp(void);
Harvey Harrison2d07b252008-02-15 09:56:34 -0800285extern asmlinkage void schedule_tail(struct task_struct *prev);
Ingo Molnar36c8b582006-07-03 00:25:41 -0700286extern void init_idle(struct task_struct *idle, int cpu);
Ingo Molnar1df21052007-07-09 18:51:58 +0200287extern void init_idle_bootup_task(struct task_struct *idle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Andrew Morton89f19f02009-09-19 11:55:44 -0700289extern int runqueue_is_locked(int cpu);
Ingo Molnar017730c2008-05-12 21:20:52 +0200290
Frederic Weisbecker3451d022011-08-10 23:21:01 +0200291#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
Alex Shic1cc0172012-09-10 15:10:58 +0800292extern void nohz_balance_enter_idle(int cpu);
Suresh Siddha69e1e812011-12-01 17:07:33 -0800293extern void set_cpu_sd_state_idle(void);
Venkatesh Pallipadi83cd4fe2010-05-21 17:09:41 -0700294extern int get_nohz_timer_target(void);
Siddha, Suresh B46cb4b72007-05-08 00:32:51 -0700295#else
Alex Shic1cc0172012-09-10 15:10:58 +0800296static inline void nohz_balance_enter_idle(int cpu) { }
Peter Zijlstrafdaabd82011-12-06 12:47:55 +0100297static inline void set_cpu_sd_state_idle(void) { }
Siddha, Suresh B46cb4b72007-05-08 00:32:51 -0700298#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
Ingo Molnare59e2ae2006-12-06 20:35:59 -0800300/*
Ingo Molnar39bc89f2007-04-25 20:50:03 -0700301 * Only dump TASK_* tasks. (0 for all tasks)
Ingo Molnare59e2ae2006-12-06 20:35:59 -0800302 */
303extern void show_state_filter(unsigned long state_filter);
304
305static inline void show_state(void)
306{
Ingo Molnar39bc89f2007-04-25 20:50:03 -0700307 show_state_filter(0);
Ingo Molnare59e2ae2006-12-06 20:35:59 -0800308}
309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310extern void show_regs(struct pt_regs *);
311
312/*
313 * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
314 * task), SP is the stack pointer of the first frame that should be shown in the back
315 * trace (or NULL if the entire call-chain of the task should be shown).
316 */
317extern void show_stack(struct task_struct *task, unsigned long *sp);
318
319void io_schedule(void);
320long io_schedule_timeout(long timeout);
321
322extern void cpu_init (void);
323extern void trap_init(void);
324extern void update_process_times(int user);
325extern void scheduler_tick(void);
326
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100327extern void sched_show_task(struct task_struct *p);
328
Frederic Weisbecker19cc36c2010-05-13 02:30:49 +0200329#ifdef CONFIG_LOCKUP_DETECTOR
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700330extern void touch_softlockup_watchdog(void);
Jason Wesseld6ad3e22010-01-27 16:25:22 -0600331extern void touch_softlockup_watchdog_sync(void);
Jeremy Fitzhardinge04c91672007-05-08 00:28:05 -0700332extern void touch_all_softlockup_watchdogs(void);
Don Zickus332fbdb2010-05-07 17:11:45 -0400333extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
334 void __user *buffer,
335 size_t *lenp, loff_t *ppos);
Ingo Molnar9c44bc02008-05-12 21:21:04 +0200336extern unsigned int softlockup_panic;
Peter Zijlstra004417a2010-11-25 18:38:29 +0100337void lockup_detector_init(void);
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700338#else
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700339static inline void touch_softlockup_watchdog(void)
340{
341}
Jason Wesseld6ad3e22010-01-27 16:25:22 -0600342static inline void touch_softlockup_watchdog_sync(void)
343{
344}
Jeremy Fitzhardinge04c91672007-05-08 00:28:05 -0700345static inline void touch_all_softlockup_watchdogs(void)
346{
347}
Peter Zijlstra004417a2010-11-25 18:38:29 +0100348static inline void lockup_detector_init(void)
349{
350}
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700351#endif
352
Marcelo Tosatti8b414522013-10-11 21:39:26 -0300353#ifdef CONFIG_DETECT_HUNG_TASK
354void reset_hung_task_detector(void);
355#else
356static inline void reset_hung_task_detector(void)
357{
358}
359#endif
360
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361/* Attach to any functions which should be ignored in wchan output. */
362#define __sched __attribute__((__section__(".sched.text")))
Ingo Molnardeaf2222007-11-28 15:52:56 +0100363
364/* Linker adds these: start and end of __sched functions */
365extern char __sched_text_start[], __sched_text_end[];
366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367/* Is this address in the __sched functions? */
368extern int in_sched_functions(unsigned long addr);
369
370#define MAX_SCHEDULE_TIMEOUT LONG_MAX
Harvey Harrisonb3c97522008-02-13 15:03:15 -0800371extern signed long schedule_timeout(signed long timeout);
Nishanth Aravamudan64ed93a2005-09-10 00:27:21 -0700372extern signed long schedule_timeout_interruptible(signed long timeout);
Matthew Wilcox294d5cc2007-12-06 11:59:46 -0500373extern signed long schedule_timeout_killable(signed long timeout);
Nishanth Aravamudan64ed93a2005-09-10 00:27:21 -0700374extern signed long schedule_timeout_uninterruptible(signed long timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375asmlinkage void schedule(void);
Thomas Gleixnerc5491ea2011-03-21 12:09:35 +0100376extern void schedule_preempt_disabled(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
Serge E. Hallynab516012006-10-02 02:18:06 -0700378struct nsproxy;
Cedric Le Goateracce2922007-07-15 23:40:59 -0700379struct user_namespace;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
David Howellsefc1a3b2010-01-15 17:01:35 -0800381#ifdef CONFIG_MMU
382extern void arch_pick_mmap_layout(struct mm_struct *mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383extern unsigned long
384arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
385 unsigned long, unsigned long);
386extern unsigned long
387arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
388 unsigned long len, unsigned long pgoff,
389 unsigned long flags);
David Howellsefc1a3b2010-01-15 17:01:35 -0800390#else
391static inline void arch_pick_mmap_layout(struct mm_struct *mm) {}
392#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Oleg Nesterov901608d2009-01-06 14:40:29 -0800394
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700395extern void set_dumpable(struct mm_struct *mm, int value);
396extern int get_dumpable(struct mm_struct *mm);
397
Kees Cookd049f742013-11-12 15:11:17 -0800398#define SUID_DUMP_DISABLE 0 /* No setuid dumping */
399#define SUID_DUMP_USER 1 /* Dump as user of process */
400#define SUID_DUMP_ROOT 2 /* Dump as root */
401
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700402/* mm flags */
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700403/* dumpable bits */
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700404#define MMF_DUMPABLE 0 /* core dump is permitted */
405#define MMF_DUMP_SECURELY 1 /* core file is readable only by root */
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700406
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700407#define MMF_DUMPABLE_BITS 2
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700408#define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1)
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700409
410/* coredump filter bits */
411#define MMF_DUMP_ANON_PRIVATE 2
412#define MMF_DUMP_ANON_SHARED 3
413#define MMF_DUMP_MAPPED_PRIVATE 4
414#define MMF_DUMP_MAPPED_SHARED 5
Roland McGrath82df3972007-10-16 23:27:02 -0700415#define MMF_DUMP_ELF_HEADERS 6
KOSAKI Motohiroe575f112008-10-18 20:27:08 -0700416#define MMF_DUMP_HUGETLB_PRIVATE 7
417#define MMF_DUMP_HUGETLB_SHARED 8
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700418
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700419#define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS
KOSAKI Motohiroe575f112008-10-18 20:27:08 -0700420#define MMF_DUMP_FILTER_BITS 7
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700421#define MMF_DUMP_FILTER_MASK \
422 (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
423#define MMF_DUMP_FILTER_DEFAULT \
KOSAKI Motohiroe575f112008-10-18 20:27:08 -0700424 ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\
Roland McGrath656eb2c2008-10-18 20:28:23 -0700425 (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)
426
427#ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS
428# define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS)
429#else
430# define MMF_DUMP_MASK_DEFAULT_ELF 0
431#endif
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700432 /* leave room for more dump flags */
433#define MMF_VM_MERGEABLE 16 /* KSM may merge identical pages */
Andrea Arcangeliba761492011-01-13 15:46:58 -0800434#define MMF_VM_HUGEPAGE 17 /* set when VM_HUGEPAGE is set on vma */
Konstantin Khlebnikovbafb2822012-06-07 14:21:11 -0700435#define MMF_EXE_FILE_CHANGED 18 /* see prctl_set_mm_exe_file() */
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700436
Oleg Nesterov9f68f672012-08-19 16:15:09 +0200437#define MMF_HAS_UPROBES 19 /* has uprobes */
438#define MMF_RECALC_UPROBES 20 /* MMF_HAS_UPROBES can be wrong */
Oleg Nesterovf8ac4ec2012-08-08 17:11:42 +0200439
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700440#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK)
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700441
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442struct sighand_struct {
443 atomic_t count;
444 struct k_sigaction action[_NSIG];
445 spinlock_t siglock;
Davide Libenzib8fceee2007-09-20 12:40:16 -0700446 wait_queue_head_t signalfd_wqh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447};
448
KaiGai Kohei0e464812006-06-25 05:49:24 -0700449struct pacct_struct {
KaiGai Koheif6ec29a2006-06-25 05:49:25 -0700450 int ac_flag;
451 long ac_exitcode;
KaiGai Kohei0e464812006-06-25 05:49:24 -0700452 unsigned long ac_mem;
KaiGai Kohei77787bf2006-06-25 05:49:26 -0700453 cputime_t ac_utime, ac_stime;
454 unsigned long ac_minflt, ac_majflt;
KaiGai Kohei0e464812006-06-25 05:49:24 -0700455};
456
Stanislaw Gruszka42c4ab42009-07-29 12:15:26 +0200457struct cpu_itimer {
458 cputime_t expires;
459 cputime_t incr;
Stanislaw Gruszka8356b5f2009-07-29 12:15:27 +0200460 u32 error;
461 u32 incr_error;
Stanislaw Gruszka42c4ab42009-07-29 12:15:26 +0200462};
463
Frank Mayharf06febc2008-09-12 09:54:39 -0700464/**
Frederic Weisbeckerd37f761d2012-11-22 00:58:35 +0100465 * struct cputime - snaphsot of system and user cputime
466 * @utime: time spent in user mode
467 * @stime: time spent in system mode
468 *
469 * Gathers a generic snapshot of user and system time.
470 */
471struct cputime {
472 cputime_t utime;
473 cputime_t stime;
474};
475
476/**
Frank Mayharf06febc2008-09-12 09:54:39 -0700477 * struct task_cputime - collected CPU time counts
478 * @utime: time spent in user mode, in &cputime_t units
479 * @stime: time spent in kernel mode, in &cputime_t units
480 * @sum_exec_runtime: total time spent on the CPU, in nanoseconds
Ingo Molnar5ce73a42008-09-14 17:11:46 +0200481 *
Frederic Weisbeckerd37f761d2012-11-22 00:58:35 +0100482 * This is an extension of struct cputime that includes the total runtime
483 * spent by the task from the scheduler point of view.
484 *
485 * As a result, this structure groups together three kinds of CPU time
486 * that are tracked for threads and thread groups. Most things considering
Frank Mayharf06febc2008-09-12 09:54:39 -0700487 * CPU time want to group these counts together and treat all three
488 * of them in parallel.
489 */
490struct task_cputime {
491 cputime_t utime;
492 cputime_t stime;
493 unsigned long long sum_exec_runtime;
494};
495/* Alternate field names when used to cache expirations. */
496#define prof_exp stime
497#define virt_exp utime
498#define sched_exp sum_exec_runtime
499
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100500#define INIT_CPUTIME \
501 (struct task_cputime) { \
Martin Schwidefsky64861632011-12-15 14:56:09 +0100502 .utime = 0, \
503 .stime = 0, \
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100504 .sum_exec_runtime = 0, \
505 }
506
Peter Zijlstraa233f112013-09-23 19:04:26 +0200507#ifdef CONFIG_PREEMPT_COUNT
508#define PREEMPT_DISABLED (1 + PREEMPT_ENABLED)
509#else
510#define PREEMPT_DISABLED PREEMPT_ENABLED
511#endif
512
Peter Zijlstrac99e6ef2009-07-10 14:57:56 +0200513/*
514 * Disable preemption until the scheduler is running.
515 * Reset by start_kernel()->sched_init()->init_idle().
Peter Zijlstrad86ee482009-07-10 14:57:57 +0200516 *
517 * We include PREEMPT_ACTIVE to avoid cond_resched() from working
518 * before the scheduler is active -- see should_resched().
Peter Zijlstrac99e6ef2009-07-10 14:57:56 +0200519 */
Peter Zijlstraa233f112013-09-23 19:04:26 +0200520#define INIT_PREEMPT_COUNT (PREEMPT_DISABLED + PREEMPT_ACTIVE)
Peter Zijlstrac99e6ef2009-07-10 14:57:56 +0200521
Frank Mayharf06febc2008-09-12 09:54:39 -0700522/**
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100523 * struct thread_group_cputimer - thread group interval timer counts
524 * @cputime: thread group interval timers.
525 * @running: non-zero when there are timers running and
526 * @cputime receives updates.
527 * @lock: lock for fields in this struct.
Frank Mayharf06febc2008-09-12 09:54:39 -0700528 *
529 * This structure contains the version of task_cputime, above, that is
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100530 * used for thread group CPU timer calculations.
Frank Mayharf06febc2008-09-12 09:54:39 -0700531 */
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100532struct thread_group_cputimer {
533 struct task_cputime cputime;
534 int running;
Thomas Gleixneree30a7b2009-07-25 18:56:56 +0200535 raw_spinlock_t lock;
Frank Mayharf06febc2008-09-12 09:54:39 -0700536};
Frank Mayharf06febc2008-09-12 09:54:39 -0700537
Ben Blum4714d1d2011-05-26 16:25:18 -0700538#include <linux/rwsem.h>
Mike Galbraith5091faa2010-11-30 14:18:03 +0100539struct autogroup;
540
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541/*
Jonathan Neuschäfere815f0a2011-03-21 20:24:47 +0100542 * NOTE! "signal_struct" does not have its own
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 * locking, because a shared signal_struct always
544 * implies a shared sighand_struct, so locking
545 * sighand_struct is always a proper superset of
546 * the locking of signal_struct.
547 */
548struct signal_struct {
Oleg Nesterovea6d2902010-05-26 14:43:16 -0700549 atomic_t sigcnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 atomic_t live;
Oleg Nesterovb3ac0222010-05-26 14:43:24 -0700551 int nr_threads;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
553 wait_queue_head_t wait_chldexit; /* for wait4() */
554
555 /* current thread group signal load-balancing target: */
Ingo Molnar36c8b582006-07-03 00:25:41 -0700556 struct task_struct *curr_target;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
558 /* shared signal handling: */
559 struct sigpending shared_pending;
560
561 /* thread group exit support */
562 int group_exit_code;
563 /* overloaded:
564 * - notify group_exit_task when ->count is equal to notify_count
565 * - everyone except group_exit_task is stopped during signal delivery
566 * of fatal signals, group_exit_task processes the signal.
567 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 int notify_count;
Richard Kennedy07dd20e2008-08-01 13:18:04 +0100569 struct task_struct *group_exit_task;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
571 /* thread group stop support, overloads group_exit_code too */
572 int group_stop_count;
573 unsigned int flags; /* see SIGNAL_* flags below */
574
Lennart Poetteringebec18a2012-03-23 15:01:54 -0700575 /*
576 * PR_SET_CHILD_SUBREAPER marks a process, like a service
577 * manager, to re-parent orphan (double-forking) child processes
578 * to this process instead of 'init'. The service manager is
579 * able to receive SIGCHLD signals and is able to investigate
580 * the process until it calls wait(). All children of this
581 * process will inherit a flag if they should look for a
582 * child_subreaper process at exit.
583 */
584 unsigned int is_child_subreaper:1;
585 unsigned int has_child_subreaper:1;
586
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 /* POSIX.1b Interval Timers */
Pavel Emelyanov5ed67f02013-03-11 13:12:21 +0400588 int posix_timer_id;
589 struct list_head posix_timers;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
591 /* ITIMER_REAL timer for the process */
Thomas Gleixner2ff678b2006-01-09 20:52:34 -0800592 struct hrtimer real_timer;
Oleg Nesterovfea9d172008-02-08 04:19:19 -0800593 struct pid *leader_pid;
Thomas Gleixner2ff678b2006-01-09 20:52:34 -0800594 ktime_t it_real_incr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Stanislaw Gruszka42c4ab42009-07-29 12:15:26 +0200596 /*
597 * ITIMER_PROF and ITIMER_VIRTUAL timers for the process, we use
598 * CPUCLOCK_PROF and CPUCLOCK_VIRT for indexing array as these
599 * values are defined to 0 and 1 respectively
600 */
601 struct cpu_itimer it[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
Frank Mayharf06febc2008-09-12 09:54:39 -0700603 /*
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100604 * Thread group totals for process CPU timers.
605 * See thread_group_cputimer(), et al, for details.
Frank Mayharf06febc2008-09-12 09:54:39 -0700606 */
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100607 struct thread_group_cputimer cputimer;
Frank Mayharf06febc2008-09-12 09:54:39 -0700608
609 /* Earliest-expiration cache. */
610 struct task_cputime cputime_expires;
611
612 struct list_head cpu_timers[3];
613
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800614 struct pid *tty_old_pgrp;
Cedric Le Goater1ec320a2006-12-08 02:37:55 -0800615
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 /* boolean value for session group leader */
617 int leader;
618
619 struct tty_struct *tty; /* NULL if no tty */
620
Mike Galbraith5091faa2010-11-30 14:18:03 +0100621#ifdef CONFIG_SCHED_AUTOGROUP
622 struct autogroup *autogroup;
623#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 /*
625 * Cumulative resource counters for dead threads in the group,
626 * and for reaped dead child processes forked by this group.
627 * Live threads maintain their own counters and add to these
628 * in __exit_signal, except for the group leader.
629 */
Peter Zijlstra32bd6712009-02-05 12:24:15 +0100630 cputime_t utime, stime, cutime, cstime;
Laurent Vivier9ac52312007-10-15 17:00:19 +0200631 cputime_t gtime;
632 cputime_t cgtime;
Frederic Weisbecker9fbc42e2013-02-25 17:25:39 +0100633#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
Frederic Weisbeckerd37f761d2012-11-22 00:58:35 +0100634 struct cputime prev_cputime;
Hidetoshi Seto0cf55e12009-12-02 17:28:07 +0900635#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
637 unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
Eric Dumazet6eaeeab2007-05-10 22:22:37 -0700638 unsigned long inblock, oublock, cinblock, coublock;
Jiri Pirko1f102062009-09-22 16:44:10 -0700639 unsigned long maxrss, cmaxrss;
Andrea Righi940389b2008-07-28 00:48:12 +0200640 struct task_io_accounting ioac;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
642 /*
Peter Zijlstra32bd6712009-02-05 12:24:15 +0100643 * Cumulative ns of schedule CPU time fo dead threads in the
644 * group, not including a zombie group leader, (This only differs
645 * from jiffies_to_ns(utime + stime) if sched_clock uses something
646 * other than jiffies.)
647 */
648 unsigned long long sum_sched_runtime;
649
650 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 * We don't bother to synchronize most readers of this at all,
652 * because there is no reader checking a limit that actually needs
653 * to get both rlim_cur and rlim_max atomically, and either one
654 * alone is a single word that can safely be read normally.
655 * getrlimit/setrlimit use task_lock(current->group_leader) to
656 * protect this instead of the siglock, because they really
657 * have no need to disable irqs.
658 */
659 struct rlimit rlim[RLIM_NLIMITS];
660
KaiGai Kohei0e464812006-06-25 05:49:24 -0700661#ifdef CONFIG_BSD_PROCESS_ACCT
662 struct pacct_struct pacct; /* per-process accounting information */
663#endif
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700664#ifdef CONFIG_TASKSTATS
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700665 struct taskstats *stats;
666#endif
Miloslav Trmac522ed772007-07-15 23:40:56 -0700667#ifdef CONFIG_AUDIT
668 unsigned audit_tty;
Richard Guy Briggs46e959e2013-05-03 14:03:50 -0400669 unsigned audit_tty_log_passwd;
Miloslav Trmac522ed772007-07-15 23:40:56 -0700670 struct tty_audit_buf *tty_audit_buf;
671#endif
Ben Blum4714d1d2011-05-26 16:25:18 -0700672#ifdef CONFIG_CGROUPS
673 /*
Tejun Heo77e4ef92011-12-12 18:12:21 -0800674 * group_rwsem prevents new tasks from entering the threadgroup and
675 * member tasks from exiting,a more specifically, setting of
676 * PF_EXITING. fork and exit paths are protected with this rwsem
677 * using threadgroup_change_begin/end(). Users which require
678 * threadgroup to remain stable should use threadgroup_[un]lock()
679 * which also takes care of exec path. Currently, cgroup is the
680 * only user.
Ben Blum4714d1d2011-05-26 16:25:18 -0700681 */
Tejun Heo257058a2011-12-12 18:12:21 -0800682 struct rw_semaphore group_rwsem;
Ben Blum4714d1d2011-05-26 16:25:18 -0700683#endif
KOSAKI Motohiro28b83c52009-09-21 17:03:13 -0700684
David Rientjese1e12d22012-12-11 16:02:56 -0800685 oom_flags_t oom_flags;
David Rientjesa9c58b902012-12-11 16:02:54 -0800686 short oom_score_adj; /* OOM kill score adjustment */
687 short oom_score_adj_min; /* OOM kill score adjustment min value.
688 * Only settable by CAP_SYS_RESOURCE. */
KOSAKI Motohiro9b1bf122010-10-27 15:34:08 -0700689
690 struct mutex cred_guard_mutex; /* guard against foreign influences on
691 * credential calculations
692 * (notably. ptrace) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693};
694
695/*
696 * Bits in flags field of signal_struct.
697 */
698#define SIGNAL_STOP_STOPPED 0x00000001 /* job control stop in effect */
Oleg Nesterovee77f072011-04-01 20:12:38 +0200699#define SIGNAL_STOP_CONTINUED 0x00000002 /* SIGCONT since WCONTINUED reap */
700#define SIGNAL_GROUP_EXIT 0x00000004 /* group exit in progress */
Oleg Nesterov403bad72013-04-30 15:28:10 -0700701#define SIGNAL_GROUP_COREDUMP 0x00000008 /* coredump in progress */
Oleg Nesterove4420552008-04-30 00:52:44 -0700702/*
703 * Pending notifications to parent.
704 */
705#define SIGNAL_CLD_STOPPED 0x00000010
706#define SIGNAL_CLD_CONTINUED 0x00000020
707#define SIGNAL_CLD_MASK (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
Oleg Nesterovfae5fa42008-04-30 00:53:03 -0700709#define SIGNAL_UNKILLABLE 0x00000040 /* for init: ignore fatal signals */
710
Oleg Nesteroved5d2ca2008-02-04 22:27:24 -0800711/* If true, all threads except ->group_exit_task have pending SIGKILL */
712static inline int signal_group_exit(const struct signal_struct *sig)
713{
714 return (sig->flags & SIGNAL_GROUP_EXIT) ||
715 (sig->group_exit_task != NULL);
716}
717
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718/*
719 * Some day this will be a full-fledged user tracking system..
720 */
721struct user_struct {
722 atomic_t __count; /* reference count */
723 atomic_t processes; /* How many processes does this user have? */
724 atomic_t files; /* How many open files does this user have? */
725 atomic_t sigpending; /* How many pending signals does this user have? */
Amy Griffis2d9048e2006-06-01 13:10:59 -0700726#ifdef CONFIG_INOTIFY_USER
Robert Love0eeca282005-07-12 17:06:03 -0400727 atomic_t inotify_watches; /* How many inotify watches does this user have? */
728 atomic_t inotify_devs; /* How many inotify devs does this user have opened? */
729#endif
Eric Paris4afeff82010-10-28 17:21:58 -0400730#ifdef CONFIG_FANOTIFY
731 atomic_t fanotify_listeners;
732#endif
Davide Libenzi7ef99642008-12-01 13:13:55 -0800733#ifdef CONFIG_EPOLL
Robin Holt52bd19f72011-01-12 17:00:01 -0800734 atomic_long_t epoll_watches; /* The number of file descriptors currently watched */
Davide Libenzi7ef99642008-12-01 13:13:55 -0800735#endif
Alexey Dobriyan970a8642007-10-16 23:30:09 -0700736#ifdef CONFIG_POSIX_MQUEUE
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 /* protected by mq_lock */
738 unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */
Alexey Dobriyan970a8642007-10-16 23:30:09 -0700739#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 unsigned long locked_shm; /* How many pages of mlocked shm ? */
741
742#ifdef CONFIG_KEYS
743 struct key *uid_keyring; /* UID specific keyring */
744 struct key *session_keyring; /* UID's default session keyring */
745#endif
746
747 /* Hash table maintenance information */
Pavel Emelyanov735de222007-09-18 22:46:44 -0700748 struct hlist_node uidhash_node;
Eric W. Biederman7b44ab92011-11-16 23:20:58 -0800749 kuid_t uid;
Srivatsa Vaddagiri24e377a2007-10-15 17:00:09 +0200750
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200751#ifdef CONFIG_PERF_EVENTS
Peter Zijlstra789f90f2009-05-15 15:19:27 +0200752 atomic_long_t locked_vm;
753#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754};
755
Kay Sieverseb41d942007-11-02 13:47:53 +0100756extern int uids_sysfs_init(void);
Dhaval Giani5cb350b2007-10-15 17:00:14 +0200757
Eric W. Biederman7b44ab92011-11-16 23:20:58 -0800758extern struct user_struct *find_user(kuid_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
760extern struct user_struct root_user;
761#define INIT_USER (&root_user)
762
David Howellsb6dff3e2008-11-14 10:39:16 +1100763
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764struct backing_dev_info;
765struct reclaim_state;
766
Chandra Seetharaman52f17b62006-07-14 00:24:38 -0700767#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768struct sched_info {
769 /* cumulative counters */
Ingo Molnar2d723762007-10-15 17:00:12 +0200770 unsigned long pcount; /* # of times run on this cpu */
Ken Chen9c2c4802008-12-16 23:41:22 -0800771 unsigned long long run_delay; /* time spent waiting on a runqueue */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
773 /* timestamps */
Balbir Singh172ba842007-07-09 18:52:00 +0200774 unsigned long long last_arrival,/* when we last ran on a cpu */
775 last_queued; /* when we were last queued to run */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776};
Chandra Seetharaman52f17b62006-07-14 00:24:38 -0700777#endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
Shailabh Nagarca74e922006-07-14 00:24:36 -0700779#ifdef CONFIG_TASK_DELAY_ACCT
780struct task_delay_info {
781 spinlock_t lock;
782 unsigned int flags; /* Private per-task flags */
783
784 /* For each stat XXX, add following, aligned appropriately
785 *
786 * struct timespec XXX_start, XXX_end;
787 * u64 XXX_delay;
788 * u32 XXX_count;
789 *
790 * Atomicity of updates to XXX_delay, XXX_count protected by
791 * single lock above (split into XXX_lock if contention is an issue).
792 */
Shailabh Nagar0ff92242006-07-14 00:24:37 -0700793
794 /*
795 * XXX_count is incremented on every XXX operation, the delay
796 * associated with the operation is added to XXX_delay.
797 * XXX_delay contains the accumulated delay time in nanoseconds.
798 */
799 struct timespec blkio_start, blkio_end; /* Shared by blkio, swapin */
800 u64 blkio_delay; /* wait for sync block io completion */
801 u64 swapin_delay; /* wait for swapin block io completion */
802 u32 blkio_count; /* total count of the number of sync block */
803 /* io operations performed */
804 u32 swapin_count; /* total count of the number of swapin block */
805 /* io operations performed */
Keika Kobayashi873b4772008-07-25 01:48:52 -0700806
807 struct timespec freepages_start, freepages_end;
808 u64 freepages_delay; /* wait for memory reclaim */
809 u32 freepages_count; /* total count of memory reclaim */
Shailabh Nagarca74e922006-07-14 00:24:36 -0700810};
Chandra Seetharaman52f17b62006-07-14 00:24:38 -0700811#endif /* CONFIG_TASK_DELAY_ACCT */
812
813static inline int sched_info_on(void)
814{
815#ifdef CONFIG_SCHEDSTATS
816 return 1;
817#elif defined(CONFIG_TASK_DELAY_ACCT)
818 extern int delayacct_on;
819 return delayacct_on;
820#else
821 return 0;
Shailabh Nagarca74e922006-07-14 00:24:36 -0700822#endif
Chandra Seetharaman52f17b62006-07-14 00:24:38 -0700823}
Shailabh Nagarca74e922006-07-14 00:24:36 -0700824
Ingo Molnard15bcfd2007-07-09 18:51:57 +0200825enum cpu_idle_type {
826 CPU_IDLE,
827 CPU_NOT_IDLE,
828 CPU_NEWLY_IDLE,
829 CPU_MAX_IDLE_TYPES
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830};
831
832/*
Nikhil Rao1399fa72011-05-18 10:09:39 -0700833 * Increase resolution of cpu_power calculations
834 */
835#define SCHED_POWER_SHIFT 10
836#define SCHED_POWER_SCALE (1L << SCHED_POWER_SHIFT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
Nikhil Rao1399fa72011-05-18 10:09:39 -0700838/*
839 * sched-domains (multiprocessor balancing) declarations:
840 */
Peter Williams2dd73a42006-06-27 02:54:34 -0700841#ifdef CONFIG_SMP
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200842#define SD_LOAD_BALANCE 0x0001 /* Do load balancing on this domain. */
843#define SD_BALANCE_NEWIDLE 0x0002 /* Balance when about to become idle */
844#define SD_BALANCE_EXEC 0x0004 /* Balance on exec */
845#define SD_BALANCE_FORK 0x0008 /* Balance on fork, clone */
Peter Zijlstrac88d5912009-09-10 13:50:02 +0200846#define SD_BALANCE_WAKE 0x0010 /* Balance on wakeup */
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200847#define SD_WAKE_AFFINE 0x0020 /* Wake task to waking CPU */
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200848#define SD_SHARE_CPUPOWER 0x0080 /* Domain members share cpu power */
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200849#define SD_SHARE_PKG_RESOURCES 0x0200 /* Domain members share cpu pkg resources */
850#define SD_SERIALIZE 0x0400 /* Only a single load balancing instance */
Michael Neuling532cb4c2010-06-08 14:57:02 +1000851#define SD_ASYM_PACKING 0x0800 /* Place busy groups earlier in the domain */
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200852#define SD_PREFER_SIBLING 0x1000 /* Prefer to place tasks in a sibling domain */
Peter Zijlstrae3589f62011-07-15 10:35:52 +0200853#define SD_OVERLAP 0x2000 /* sched_domains of this level overlap */
Mel Gorman3a7053b2013-10-07 11:29:00 +0100854#define SD_NUMA 0x4000 /* cross-node balancing */
Siddha, Suresh B5c45bf22006-06-27 02:54:42 -0700855
Michael Neuling532cb4c2010-06-08 14:57:02 +1000856extern int __weak arch_sd_sibiling_asym_packing(void);
857
Hidetoshi Seto1d3504f2008-04-15 14:04:23 +0900858struct sched_domain_attr {
859 int relax_domain_level;
860};
861
862#define SD_ATTR_INIT (struct sched_domain_attr) { \
863 .relax_domain_level = -1, \
864}
865
Peter Zijlstra60495e72011-04-07 14:10:04 +0200866extern int sched_domain_level_max;
867
Li Zefan5e6521e2013-03-05 16:06:23 +0800868struct sched_group;
869
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870struct sched_domain {
871 /* These fields must be setup */
872 struct sched_domain *parent; /* top domain must be null terminated */
Siddha, Suresh B1a848872006-10-03 01:14:08 -0700873 struct sched_domain *child; /* bottom domain must be null terminated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 struct sched_group *groups; /* the balancing groups of the domain */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 unsigned long min_interval; /* Minimum balance interval ms */
876 unsigned long max_interval; /* Maximum balance interval ms */
877 unsigned int busy_factor; /* less balancing by factor if busy */
878 unsigned int imbalance_pct; /* No balance until over watermark */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 unsigned int cache_nice_tries; /* Leave cache hot tasks for # tries */
Nick Piggin78979862005-06-25 14:57:13 -0700880 unsigned int busy_idx;
881 unsigned int idle_idx;
882 unsigned int newidle_idx;
883 unsigned int wake_idx;
Nick Piggin147cbb42005-06-25 14:57:19 -0700884 unsigned int forkexec_idx;
Peter Zijlstraa52bfd72009-09-01 10:34:35 +0200885 unsigned int smt_gain;
Vincent Guittot25f55d92013-04-23 16:59:02 +0200886
887 int nohz_idle; /* NOHZ IDLE status */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 int flags; /* See SD_* */
Peter Zijlstra60495e72011-04-07 14:10:04 +0200889 int level;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890
891 /* Runtime fields. */
892 unsigned long last_balance; /* init to jiffies. units in jiffies */
893 unsigned int balance_interval; /* initialise to 1. units in ms. */
894 unsigned int nr_balance_failed; /* initialise to 0 */
895
Jason Lowf48627e2013-09-13 11:26:53 -0700896 /* idle_balance() stats */
Jason Low9bd721c2013-09-13 11:26:52 -0700897 u64 max_newidle_lb_cost;
Jason Lowf48627e2013-09-13 11:26:53 -0700898 unsigned long next_decay_max_lb_cost;
Peter Zijlstra2398f2c2008-06-27 13:41:35 +0200899
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900#ifdef CONFIG_SCHEDSTATS
901 /* load_balance() stats */
Ken Chen480b9432007-10-18 21:32:56 +0200902 unsigned int lb_count[CPU_MAX_IDLE_TYPES];
903 unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
904 unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
905 unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
906 unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
907 unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
908 unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
909 unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
911 /* Active load balancing */
Ken Chen480b9432007-10-18 21:32:56 +0200912 unsigned int alb_count;
913 unsigned int alb_failed;
914 unsigned int alb_pushed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915
Nick Piggin68767a02005-06-25 14:57:20 -0700916 /* SD_BALANCE_EXEC stats */
Ken Chen480b9432007-10-18 21:32:56 +0200917 unsigned int sbe_count;
918 unsigned int sbe_balanced;
919 unsigned int sbe_pushed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
Nick Piggin68767a02005-06-25 14:57:20 -0700921 /* SD_BALANCE_FORK stats */
Ken Chen480b9432007-10-18 21:32:56 +0200922 unsigned int sbf_count;
923 unsigned int sbf_balanced;
924 unsigned int sbf_pushed;
Nick Piggin68767a02005-06-25 14:57:20 -0700925
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 /* try_to_wake_up() stats */
Ken Chen480b9432007-10-18 21:32:56 +0200927 unsigned int ttwu_wake_remote;
928 unsigned int ttwu_move_affine;
929 unsigned int ttwu_move_balance;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930#endif
Ingo Molnara5d8c342008-10-09 11:35:51 +0200931#ifdef CONFIG_SCHED_DEBUG
932 char *name;
933#endif
Peter Zijlstradce840a2011-04-07 14:09:50 +0200934 union {
935 void *private; /* used during construction */
936 struct rcu_head rcu; /* used during destruction */
937 };
Rusty Russell6c99e9a2008-11-25 02:35:04 +1030938
Peter Zijlstra669c55e2010-04-16 14:59:29 +0200939 unsigned int span_weight;
Ingo Molnar4200efd2009-05-19 09:22:19 +0200940 /*
941 * Span of all CPUs in this domain.
942 *
943 * NOTE: this field is variable length. (Allocated dynamically
944 * by attaching extra space to the end of the structure,
945 * depending on how many CPUs the kernel has booted up with)
Ingo Molnar4200efd2009-05-19 09:22:19 +0200946 */
947 unsigned long span[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948};
949
Rusty Russell758b2cd2008-11-25 02:35:04 +1030950static inline struct cpumask *sched_domain_span(struct sched_domain *sd)
951{
Rusty Russell6c99e9a2008-11-25 02:35:04 +1030952 return to_cpumask(sd->span);
Rusty Russell758b2cd2008-11-25 02:35:04 +1030953}
954
Rusty Russellacc3f5d2009-11-03 14:53:40 +1030955extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
Hidetoshi Seto1d3504f2008-04-15 14:04:23 +0900956 struct sched_domain_attr *dattr_new);
Paul Jackson029190c2007-10-18 23:40:20 -0700957
Rusty Russellacc3f5d2009-11-03 14:53:40 +1030958/* Allocate an array of sched domains, for partition_sched_domains(). */
959cpumask_var_t *alloc_sched_domains(unsigned int ndoms);
960void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms);
961
Peter Zijlstra39be3502012-01-26 12:44:34 +0100962bool cpus_share_cache(int this_cpu, int that_cpu);
963
Ingo Molnar1b427c12008-07-18 14:01:39 +0200964#else /* CONFIG_SMP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965
Ingo Molnar1b427c12008-07-18 14:01:39 +0200966struct sched_domain_attr;
967
968static inline void
Rusty Russellacc3f5d2009-11-03 14:53:40 +1030969partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
Ingo Molnar1b427c12008-07-18 14:01:39 +0200970 struct sched_domain_attr *dattr_new)
Con Kolivasd02c7a82007-07-26 13:40:43 +0200971{
Con Kolivasd02c7a82007-07-26 13:40:43 +0200972}
Peter Zijlstra39be3502012-01-26 12:44:34 +0100973
974static inline bool cpus_share_cache(int this_cpu, int that_cpu)
975{
976 return true;
977}
978
Ingo Molnar1b427c12008-07-18 14:01:39 +0200979#endif /* !CONFIG_SMP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980
Peter Zijlstra47fe38f2009-09-02 13:49:18 +0200981
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982struct io_context; /* See blkdev.h */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984
Chen, Kenneth W383f2832005-09-09 13:02:02 -0700985#ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
Ingo Molnar36c8b582006-07-03 00:25:41 -0700986extern void prefetch_stack(struct task_struct *t);
Chen, Kenneth W383f2832005-09-09 13:02:02 -0700987#else
988static inline void prefetch_stack(struct task_struct *t) { }
989#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
991struct audit_context; /* See audit.c */
992struct mempolicy;
Jens Axboeb92ce552006-04-11 13:52:07 +0200993struct pipe_inode_info;
Serge E. Hallyn4865ecf2006-10-02 02:18:14 -0700994struct uts_namespace;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995
Ingo Molnar20b8a592007-07-09 18:51:58 +0200996struct load_weight {
Peter Zijlstra9dbdb152013-11-18 18:27:06 +0100997 unsigned long weight;
998 u32 inv_weight;
Ingo Molnar20b8a592007-07-09 18:51:58 +0200999};
1000
Paul Turner9d85f212012-10-04 13:18:29 +02001001struct sched_avg {
1002 /*
1003 * These sums represent an infinite geometric series and so are bound
Kamalesh Babulal239003e2013-06-27 11:34:09 +05301004 * above by 1024/(1-y). Thus we only need a u32 to store them for all
Paul Turner9d85f212012-10-04 13:18:29 +02001005 * choices of y < 1-2^(-32)*1024.
1006 */
1007 u32 runnable_avg_sum, runnable_avg_period;
1008 u64 last_runnable_update;
Paul Turner9ee474f2012-10-04 13:18:30 +02001009 s64 decay_count;
Paul Turner2dac7542012-10-04 13:18:30 +02001010 unsigned long load_avg_contrib;
Paul Turner9d85f212012-10-04 13:18:29 +02001011};
1012
Ingo Molnar94c18222007-08-02 17:41:40 +02001013#ifdef CONFIG_SCHEDSTATS
Lucas De Marchi41acab82010-03-10 23:37:45 -03001014struct sched_statistics {
Ingo Molnar94c18222007-08-02 17:41:40 +02001015 u64 wait_start;
1016 u64 wait_max;
Arjan van de Ven6d082592008-01-25 21:08:35 +01001017 u64 wait_count;
1018 u64 wait_sum;
Arjan van de Ven8f0dfc32009-07-20 11:26:58 -07001019 u64 iowait_count;
1020 u64 iowait_sum;
Ingo Molnar94c18222007-08-02 17:41:40 +02001021
1022 u64 sleep_start;
Ingo Molnar20b8a592007-07-09 18:51:58 +02001023 u64 sleep_max;
Ingo Molnar94c18222007-08-02 17:41:40 +02001024 s64 sum_sleep_runtime;
1025
1026 u64 block_start;
Ingo Molnar20b8a592007-07-09 18:51:58 +02001027 u64 block_max;
1028 u64 exec_max;
Ingo Molnareba1ed42007-10-15 17:00:02 +02001029 u64 slice_max;
Ingo Molnarcc367732007-10-15 17:00:18 +02001030
Ingo Molnarcc367732007-10-15 17:00:18 +02001031 u64 nr_migrations_cold;
1032 u64 nr_failed_migrations_affine;
1033 u64 nr_failed_migrations_running;
1034 u64 nr_failed_migrations_hot;
1035 u64 nr_forced_migrations;
Ingo Molnarcc367732007-10-15 17:00:18 +02001036
1037 u64 nr_wakeups;
1038 u64 nr_wakeups_sync;
1039 u64 nr_wakeups_migrate;
1040 u64 nr_wakeups_local;
1041 u64 nr_wakeups_remote;
1042 u64 nr_wakeups_affine;
1043 u64 nr_wakeups_affine_attempts;
1044 u64 nr_wakeups_passive;
1045 u64 nr_wakeups_idle;
Lucas De Marchi41acab82010-03-10 23:37:45 -03001046};
1047#endif
1048
1049struct sched_entity {
1050 struct load_weight load; /* for load-balancing */
1051 struct rb_node run_node;
1052 struct list_head group_node;
1053 unsigned int on_rq;
1054
1055 u64 exec_start;
1056 u64 sum_exec_runtime;
1057 u64 vruntime;
1058 u64 prev_sum_exec_runtime;
1059
Lucas De Marchi41acab82010-03-10 23:37:45 -03001060 u64 nr_migrations;
1061
Lucas De Marchi41acab82010-03-10 23:37:45 -03001062#ifdef CONFIG_SCHEDSTATS
1063 struct sched_statistics statistics;
Ingo Molnar94c18222007-08-02 17:41:40 +02001064#endif
1065
Ingo Molnar20b8a592007-07-09 18:51:58 +02001066#ifdef CONFIG_FAIR_GROUP_SCHED
1067 struct sched_entity *parent;
1068 /* rq on which this entity is (to be) queued: */
1069 struct cfs_rq *cfs_rq;
1070 /* rq "owned" by this entity/group: */
1071 struct cfs_rq *my_q;
1072#endif
Clark Williams8bd75c72013-02-07 09:47:07 -06001073
Alex Shi141965c2013-06-26 13:05:39 +08001074#ifdef CONFIG_SMP
Paul Turnerf4e26b12012-10-04 13:18:32 +02001075 /* Per-entity load-tracking */
Paul Turner9d85f212012-10-04 13:18:29 +02001076 struct sched_avg avg;
1077#endif
Ingo Molnar20b8a592007-07-09 18:51:58 +02001078};
Ingo Molnar70b97a72006-07-03 00:25:42 -07001079
Peter Zijlstrafa717062008-01-25 21:08:27 +01001080struct sched_rt_entity {
1081 struct list_head run_list;
Peter Zijlstra78f2c7d2008-01-25 21:08:27 +01001082 unsigned long timeout;
Ying Xue57d2aa02012-07-17 15:03:43 +08001083 unsigned long watchdog_stamp;
Richard Kennedybee367e2008-08-01 13:24:08 +01001084 unsigned int time_slice;
Peter Zijlstra6f505b12008-01-25 21:08:30 +01001085
Peter Zijlstra58d6c2d2008-04-19 19:45:00 +02001086 struct sched_rt_entity *back;
Peter Zijlstra052f1dc2008-02-13 15:45:40 +01001087#ifdef CONFIG_RT_GROUP_SCHED
Peter Zijlstra6f505b12008-01-25 21:08:30 +01001088 struct sched_rt_entity *parent;
1089 /* rq on which this entity is (to be) queued: */
1090 struct rt_rq *rt_rq;
1091 /* rq "owned" by this entity/group: */
1092 struct rt_rq *my_q;
1093#endif
Peter Zijlstrafa717062008-01-25 21:08:27 +01001094};
1095
Dario Faggioliaab03e02013-11-28 11:14:43 +01001096struct sched_dl_entity {
1097 struct rb_node rb_node;
1098
1099 /*
1100 * Original scheduling parameters. Copied here from sched_attr
1101 * during sched_setscheduler2(), they will remain the same until
1102 * the next sched_setscheduler2().
1103 */
1104 u64 dl_runtime; /* maximum runtime for each instance */
1105 u64 dl_deadline; /* relative deadline of each instance */
Harald Gustafsson755378a2013-11-07 14:43:40 +01001106 u64 dl_period; /* separation of two instances (period) */
Dario Faggioliaab03e02013-11-28 11:14:43 +01001107
1108 /*
1109 * Actual scheduling parameters. Initialized with the values above,
1110 * they are continously updated during task execution. Note that
1111 * the remaining runtime could be < 0 in case we are in overrun.
1112 */
1113 s64 runtime; /* remaining runtime for this instance */
1114 u64 deadline; /* absolute deadline for this instance */
1115 unsigned int flags; /* specifying the scheduler behaviour */
1116
1117 /*
1118 * Some bool flags:
1119 *
1120 * @dl_throttled tells if we exhausted the runtime. If so, the
1121 * task has to wait for a replenishment to be performed at the
1122 * next firing of dl_timer.
1123 *
1124 * @dl_new tells if a new instance arrived. If so we must
1125 * start executing it with full runtime and reset its absolute
1126 * deadline;
Dario Faggioli2d3d8912013-11-07 14:43:44 +01001127 *
1128 * @dl_boosted tells if we are boosted due to DI. If so we are
1129 * outside bandwidth enforcement mechanism (but only until we
1130 * exit the critical section).
Dario Faggioliaab03e02013-11-28 11:14:43 +01001131 */
Dario Faggioli2d3d8912013-11-07 14:43:44 +01001132 int dl_throttled, dl_new, dl_boosted;
Dario Faggioliaab03e02013-11-28 11:14:43 +01001133
1134 /*
1135 * Bandwidth enforcement timer. Each -deadline task has its
1136 * own bandwidth to be enforced, thus we need one timer per task.
1137 */
1138 struct hrtimer dl_timer;
1139};
Clark Williams8bd75c72013-02-07 09:47:07 -06001140
Paul E. McKenney86848962009-08-27 15:00:12 -07001141struct rcu_node;
1142
Peter Zijlstra8dc85d52010-09-02 16:50:03 +02001143enum perf_event_task_context {
1144 perf_invalid_context = -1,
1145 perf_hw_context = 0,
Peter Zijlstra89a1e182010-09-07 17:34:50 +02001146 perf_sw_context,
Peter Zijlstra8dc85d52010-09-02 16:50:03 +02001147 perf_nr_task_contexts,
1148};
1149
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150struct task_struct {
1151 volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
Roman Zippelf7e42172007-05-09 02:35:17 -07001152 void *stack;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 atomic_t usage;
William Cohen97dc32c2007-05-08 00:23:41 -07001154 unsigned int flags; /* per process flags, defined below */
1155 unsigned int ptrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156
Peter Williams2dd73a42006-06-27 02:54:34 -07001157#ifdef CONFIG_SMP
Peter Zijlstrafa14ff42011-09-12 13:06:17 +02001158 struct llist_node wake_entry;
Peter Zijlstra3ca7a442011-04-05 17:23:40 +02001159 int on_cpu;
Michael Wang62470412013-07-04 12:55:51 +08001160 struct task_struct *last_wakee;
1161 unsigned long wakee_flips;
1162 unsigned long wakee_flip_decay_ts;
Peter Zijlstraac66f542013-10-07 11:29:16 +01001163
1164 int wake_cpu;
Nick Piggin4866cde2005-06-25 14:57:23 -07001165#endif
Peter Zijlstrafd2f4412011-04-05 17:23:44 +02001166 int on_rq;
Ingo Molnar50e645a2007-07-09 18:52:00 +02001167
Ingo Molnarb29739f2006-06-27 02:54:51 -07001168 int prio, static_prio, normal_prio;
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001169 unsigned int rt_priority;
Ingo Molnar5522d5d2007-10-15 17:00:12 +02001170 const struct sched_class *sched_class;
Ingo Molnar20b8a592007-07-09 18:51:58 +02001171 struct sched_entity se;
Peter Zijlstrafa717062008-01-25 21:08:27 +01001172 struct sched_rt_entity rt;
Peter Zijlstra8323f262012-06-22 13:36:05 +02001173#ifdef CONFIG_CGROUP_SCHED
1174 struct task_group *sched_task_group;
1175#endif
Dario Faggioliaab03e02013-11-28 11:14:43 +01001176 struct sched_dl_entity dl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177
Avi Kivitye107be32007-07-26 13:40:43 +02001178#ifdef CONFIG_PREEMPT_NOTIFIERS
1179 /* list of struct preempt_notifier: */
1180 struct hlist_head preempt_notifiers;
1181#endif
1182
Alexey Dobriyan6c5c9342006-09-29 01:59:40 -07001183#ifdef CONFIG_BLK_DEV_IO_TRACE
Jens Axboe2056a782006-03-23 20:00:26 +01001184 unsigned int btrace_seq;
Alexey Dobriyan6c5c9342006-09-29 01:59:40 -07001185#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
William Cohen97dc32c2007-05-08 00:23:41 -07001187 unsigned int policy;
Peter Zijlstra29baa742012-04-23 12:11:21 +02001188 int nr_cpus_allowed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 cpumask_t cpus_allowed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190
Paul E. McKenneya57eb942010-06-29 16:49:16 -07001191#ifdef CONFIG_PREEMPT_RCU
Paul E. McKenneye260be62008-01-25 21:08:24 +01001192 int rcu_read_lock_nesting;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001193 char rcu_read_unlock_special;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001194 struct list_head rcu_node_entry;
Paul E. McKenneya57eb942010-06-29 16:49:16 -07001195#endif /* #ifdef CONFIG_PREEMPT_RCU */
1196#ifdef CONFIG_TREE_PREEMPT_RCU
1197 struct rcu_node *rcu_blocked_node;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001198#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
Paul E. McKenney24278d12010-09-27 17:25:23 -07001199#ifdef CONFIG_RCU_BOOST
1200 struct rt_mutex *rcu_boost_mutex;
1201#endif /* #ifdef CONFIG_RCU_BOOST */
Paul E. McKenneye260be62008-01-25 21:08:24 +01001202
Chandra Seetharaman52f17b62006-07-14 00:24:38 -07001203#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 struct sched_info sched_info;
1205#endif
1206
1207 struct list_head tasks;
Dario Faggioli806c09a2010-11-30 19:51:33 +01001208#ifdef CONFIG_SMP
Gregory Haskins917b6272008-12-29 09:39:53 -05001209 struct plist_node pushable_tasks;
Juri Lelli1baca4c2013-11-07 14:43:38 +01001210 struct rb_node pushable_dl_tasks;
Dario Faggioli806c09a2010-11-30 19:51:33 +01001211#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212
1213 struct mm_struct *mm, *active_mm;
Jiri Kosina4471a672011-04-14 15:22:09 -07001214#ifdef CONFIG_COMPAT_BRK
1215 unsigned brk_randomized:1;
1216#endif
KAMEZAWA Hiroyuki34e55232010-03-05 13:41:40 -08001217#if defined(SPLIT_RSS_COUNTING)
1218 struct task_rss_stat rss_stat;
1219#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220/* task state */
William Cohen97dc32c2007-05-08 00:23:41 -07001221 int exit_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 int exit_code, exit_signal;
1223 int pdeath_signal; /* The signal sent when the parent dies */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001224 unsigned int jobctl; /* JOBCTL_*, siglock protected */
Andrei Epure9b89f6b2013-04-11 20:30:29 +03001225
1226 /* Used for emulating ABI behavior of previous Linux versions */
William Cohen97dc32c2007-05-08 00:23:41 -07001227 unsigned int personality;
Andrei Epure9b89f6b2013-04-11 20:30:29 +03001228
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 unsigned did_exec:1;
Kentaro Takedaf9ce1f12009-02-05 17:18:11 +09001230 unsigned in_execve:1; /* Tell the LSMs that the process is doing an
1231 * execve */
Arjan van de Ven8f0dfc32009-07-20 11:26:58 -07001232 unsigned in_iowait:1;
1233
Andy Lutomirski259e5e62012-04-12 16:47:50 -05001234 /* task may not gain privileges */
1235 unsigned no_new_privs:1;
Lennart Poetteringca94c442009-06-15 17:17:47 +02001236
1237 /* Revert to default priority/policy when forking */
1238 unsigned sched_reset_on_fork:1;
Peter Zijlstraa8e4f2e2011-04-05 17:23:49 +02001239 unsigned sched_contributes_to_load:1;
Lennart Poetteringca94c442009-06-15 17:17:47 +02001240
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 pid_t pid;
1242 pid_t tgid;
Arjan van de Ven0a425402006-09-26 10:52:38 +02001243
Hiroshi Shimamoto13145622009-08-18 15:06:02 +09001244#ifdef CONFIG_CC_STACKPROTECTOR
Arjan van de Ven0a425402006-09-26 10:52:38 +02001245 /* Canary value for the -fstack-protector gcc feature */
1246 unsigned long stack_canary;
Hiroshi Shimamoto13145622009-08-18 15:06:02 +09001247#endif
Oleg Nesterov4d1d61a2012-05-11 10:59:08 +10001248 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 * pointers to (original) parent process, youngest child, younger sibling,
Oleg Nesterov4d1d61a2012-05-11 10:59:08 +10001250 * older sibling, respectively. (p->father can be replaced with
Roland McGrathf4700212008-03-24 18:36:23 -07001251 * p->real_parent->pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 */
Kees Cookabd63bc2011-12-14 14:39:26 -08001253 struct task_struct __rcu *real_parent; /* real parent process */
1254 struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 /*
Roland McGrathf4700212008-03-24 18:36:23 -07001256 * children/sibling forms the list of my natural children
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 */
1258 struct list_head children; /* list of my children */
1259 struct list_head sibling; /* linkage in my parent's children list */
1260 struct task_struct *group_leader; /* threadgroup leader */
1261
Roland McGrathf4700212008-03-24 18:36:23 -07001262 /*
1263 * ptraced is the list of tasks this task is using ptrace on.
1264 * This includes both natural children and PTRACE_ATTACH targets.
1265 * p->ptrace_entry is p's link on the p->parent->ptraced list.
1266 */
1267 struct list_head ptraced;
1268 struct list_head ptrace_entry;
1269
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 /* PID/PID hash table linkage. */
Eric W. Biederman92476d72006-03-31 02:31:42 -08001271 struct pid_link pids[PIDTYPE_MAX];
Oleg Nesterov47e65322006-03-28 16:11:25 -08001272 struct list_head thread_group;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
1274 struct completion *vfork_done; /* for vfork() */
1275 int __user *set_child_tid; /* CLONE_CHILD_SETTID */
1276 int __user *clear_child_tid; /* CLONE_CHILD_CLEARTID */
1277
Michael Neulingc66f08b2007-10-18 03:06:34 -07001278 cputime_t utime, stime, utimescaled, stimescaled;
Laurent Vivier9ac52312007-10-15 17:00:19 +02001279 cputime_t gtime;
Frederic Weisbecker9fbc42e2013-02-25 17:25:39 +01001280#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
Frederic Weisbeckerd37f761d2012-11-22 00:58:35 +01001281 struct cputime prev_cputime;
Hidetoshi Setod99ca3b2009-12-02 17:26:47 +09001282#endif
Frederic Weisbecker6a616712012-12-16 20:00:34 +01001283#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
1284 seqlock_t vtime_seqlock;
1285 unsigned long long vtime_snap;
1286 enum {
1287 VTIME_SLEEPING = 0,
1288 VTIME_USER,
1289 VTIME_SYS,
1290 } vtime_snap_whence;
1291#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 unsigned long nvcsw, nivcsw; /* context switch counts */
Tomas Janousek924b42d2007-07-15 23:39:42 -07001293 struct timespec start_time; /* monotonic time */
1294 struct timespec real_start_time; /* boot based time */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
1296 unsigned long min_flt, maj_flt;
1297
Frank Mayharf06febc2008-09-12 09:54:39 -07001298 struct task_cputime cputime_expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 struct list_head cpu_timers[3];
1300
1301/* process credentials */
Arnd Bergmann1b0ba1c2010-02-24 19:45:09 +01001302 const struct cred __rcu *real_cred; /* objective and real subjective task
David Howells3b11a1d2008-11-14 10:39:26 +11001303 * credentials (COW) */
Arnd Bergmann1b0ba1c2010-02-24 19:45:09 +01001304 const struct cred __rcu *cred; /* effective (overridable) subjective task
David Howells3b11a1d2008-11-14 10:39:26 +11001305 * credentials (COW) */
Paolo 'Blaisorblade' Giarrusso36772092005-05-05 16:16:12 -07001306 char comm[TASK_COMM_LEN]; /* executable name excluding path
1307 - access with [gs]et_task_comm (which lock
1308 it with task_lock())
Linus Torvalds221af7f2010-01-28 22:14:42 -08001309 - initialized normally by setup_new_exec */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310/* file system info */
1311 int link_count, total_link_count;
Alexey Dobriyan3d5b6fc2006-09-29 01:59:40 -07001312#ifdef CONFIG_SYSVIPC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313/* ipc stuff */
1314 struct sysv_sem sysvsem;
Alexey Dobriyan3d5b6fc2006-09-29 01:59:40 -07001315#endif
Mandeep Singh Bainese162b392009-01-15 11:08:40 -08001316#ifdef CONFIG_DETECT_HUNG_TASK
Ingo Molnar82a1fcb2008-01-25 21:08:02 +01001317/* hung task detection */
Ingo Molnar82a1fcb2008-01-25 21:08:02 +01001318 unsigned long last_switch_count;
1319#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320/* CPU-specific state of this task */
1321 struct thread_struct thread;
1322/* filesystem information */
1323 struct fs_struct *fs;
1324/* open file information */
1325 struct files_struct *files;
Serge E. Hallyn1651e142006-10-02 02:18:08 -07001326/* namespaces */
Serge E. Hallynab516012006-10-02 02:18:06 -07001327 struct nsproxy *nsproxy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328/* signal handlers */
1329 struct signal_struct *signal;
1330 struct sighand_struct *sighand;
1331
1332 sigset_t blocked, real_blocked;
Roland McGrathf3de2722008-04-30 00:53:09 -07001333 sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 struct sigpending pending;
1335
1336 unsigned long sas_ss_sp;
1337 size_t sas_ss_size;
1338 int (*notifier)(void *priv);
1339 void *notifier_data;
1340 sigset_t *notifier_mask;
Al Viro67d12142012-06-27 11:07:19 +04001341 struct callback_head *task_works;
Oleg Nesterove73f8952012-05-11 10:59:07 +10001342
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 struct audit_context *audit_context;
Al Virobfef93a2008-01-10 04:53:18 -05001344#ifdef CONFIG_AUDITSYSCALL
Eric W. Biedermane1760bd2012-09-10 22:39:43 -07001345 kuid_t loginuid;
Eric Paris4746ec52008-01-08 10:06:53 -05001346 unsigned int sessionid;
Al Virobfef93a2008-01-10 04:53:18 -05001347#endif
Will Drewry932eceb2012-04-12 16:47:54 -05001348 struct seccomp seccomp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349
1350/* Thread group tracking */
1351 u32 parent_exec_id;
1352 u32 self_exec_id;
Miao Xie58568d22009-06-16 15:31:49 -07001353/* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,
1354 * mempolicy */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 spinlock_t alloc_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
Ingo Molnarb29739f2006-06-27 02:54:51 -07001357 /* Protection of the PI data structures: */
Thomas Gleixner1d615482009-11-17 14:54:03 +01001358 raw_spinlock_t pi_lock;
Ingo Molnarb29739f2006-06-27 02:54:51 -07001359
Ingo Molnar23f78d4a2006-06-27 02:54:53 -07001360#ifdef CONFIG_RT_MUTEXES
1361 /* PI waiters blocked on a rt_mutex held by this task */
Peter Zijlstrafb00aca2013-11-07 14:43:43 +01001362 struct rb_root pi_waiters;
1363 struct rb_node *pi_waiters_leftmost;
Ingo Molnar23f78d4a2006-06-27 02:54:53 -07001364 /* Deadlock detection and priority inheritance handling */
1365 struct rt_mutex_waiter *pi_blocked_on;
Dario Faggioli2d3d8912013-11-07 14:43:44 +01001366 /* Top pi_waiters task */
1367 struct task_struct *pi_top_task;
Ingo Molnar23f78d4a2006-06-27 02:54:53 -07001368#endif
1369
Ingo Molnar408894e2006-01-09 15:59:20 -08001370#ifdef CONFIG_DEBUG_MUTEXES
1371 /* mutex deadlock detection */
1372 struct mutex_waiter *blocked_on;
1373#endif
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001374#ifdef CONFIG_TRACE_IRQFLAGS
1375 unsigned int irq_events;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001376 unsigned long hardirq_enable_ip;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001377 unsigned long hardirq_disable_ip;
Hiroshi Shimamotofa1452e2009-11-30 14:59:44 +09001378 unsigned int hardirq_enable_event;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001379 unsigned int hardirq_disable_event;
Hiroshi Shimamotofa1452e2009-11-30 14:59:44 +09001380 int hardirqs_enabled;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001381 int hardirq_context;
Hiroshi Shimamotofa1452e2009-11-30 14:59:44 +09001382 unsigned long softirq_disable_ip;
1383 unsigned long softirq_enable_ip;
1384 unsigned int softirq_disable_event;
1385 unsigned int softirq_enable_event;
1386 int softirqs_enabled;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001387 int softirq_context;
1388#endif
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001389#ifdef CONFIG_LOCKDEP
Peter Zijlstrabdb94412008-02-25 23:02:48 +01001390# define MAX_LOCK_DEPTH 48UL
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001391 u64 curr_chain_key;
1392 int lockdep_depth;
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001393 unsigned int lockdep_recursion;
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001394 struct held_lock held_locks[MAX_LOCK_DEPTH];
Nick Piggincf40bd12009-01-21 08:12:39 +01001395 gfp_t lockdep_reclaim_gfp;
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001396#endif
Ingo Molnar408894e2006-01-09 15:59:20 -08001397
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398/* journalling filesystem info */
1399 void *journal_info;
1400
Neil Brownd89d8792007-05-01 09:53:42 +02001401/* stacked block device info */
Akinobu Mitabddd87c2010-02-23 08:55:42 +01001402 struct bio_list *bio_list;
Neil Brownd89d8792007-05-01 09:53:42 +02001403
Jens Axboe73c10102011-03-08 13:19:51 +01001404#ifdef CONFIG_BLOCK
1405/* stack plugging */
1406 struct blk_plug *plug;
1407#endif
1408
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409/* VM state */
1410 struct reclaim_state *reclaim_state;
1411
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 struct backing_dev_info *backing_dev_info;
1413
1414 struct io_context *io_context;
1415
1416 unsigned long ptrace_message;
1417 siginfo_t *last_siginfo; /* For ptrace use. */
Andrew Morton7c3ab732006-12-10 02:19:19 -08001418 struct task_io_accounting ioac;
Jay Lan8f0ab512006-09-30 23:28:59 -07001419#if defined(CONFIG_TASK_XACCT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 u64 acct_rss_mem1; /* accumulated rss usage */
1421 u64 acct_vm_mem1; /* accumulated virtual memory usage */
Jonathan Lim49b5cf32008-07-25 01:48:40 -07001422 cputime_t acct_timexpd; /* stime + utime since last update */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423#endif
1424#ifdef CONFIG_CPUSETS
Miao Xie58568d22009-06-16 15:31:49 -07001425 nodemask_t mems_allowed; /* Protected by alloc_lock */
Mel Gormancc9a6c82012-03-21 16:34:11 -07001426 seqcount_t mems_allowed_seq; /* Seqence no to catch updates */
Paul Jackson825a46a2006-03-24 03:16:03 -08001427 int cpuset_mem_spread_rotor;
Jack Steiner6adef3e2010-05-26 14:42:49 -07001428 int cpuset_slab_spread_rotor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429#endif
Paul Menageddbcc7e2007-10-18 23:39:30 -07001430#ifdef CONFIG_CGROUPS
Paul Menage817929e2007-10-18 23:39:36 -07001431 /* Control Group info protected by css_set_lock */
Arnd Bergmann2c392b82010-02-24 19:41:39 +01001432 struct css_set __rcu *cgroups;
Paul Menage817929e2007-10-18 23:39:36 -07001433 /* cg_list protected by css_set_lock and tsk->alloc_lock */
1434 struct list_head cg_list;
Paul Menageddbcc7e2007-10-18 23:39:30 -07001435#endif
Alexey Dobriyan42b2dd02007-10-16 23:27:30 -07001436#ifdef CONFIG_FUTEX
Ingo Molnar0771dfe2006-03-27 01:16:22 -08001437 struct robust_list_head __user *robust_list;
Ingo Molnar34f192c2006-03-27 01:16:24 -08001438#ifdef CONFIG_COMPAT
1439 struct compat_robust_list_head __user *compat_robust_list;
1440#endif
Ingo Molnarc87e2832006-06-27 02:54:58 -07001441 struct list_head pi_state_list;
1442 struct futex_pi_state *pi_state_cache;
Alexey Dobriyan42b2dd02007-10-16 23:27:30 -07001443#endif
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001444#ifdef CONFIG_PERF_EVENTS
Peter Zijlstra8dc85d52010-09-02 16:50:03 +02001445 struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001446 struct mutex perf_event_mutex;
1447 struct list_head perf_event_list;
Paul Mackerrasa63eaf32009-05-22 14:17:31 +10001448#endif
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001449#ifdef CONFIG_NUMA
Miao Xie58568d22009-06-16 15:31:49 -07001450 struct mempolicy *mempolicy; /* Protected by alloc_lock */
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001451 short il_next;
Eric Dumazet207205a2011-03-22 16:30:44 -07001452 short pref_node_fork;
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001453#endif
Peter Zijlstracbee9f82012-10-25 14:16:43 +02001454#ifdef CONFIG_NUMA_BALANCING
1455 int numa_scan_seq;
Peter Zijlstracbee9f82012-10-25 14:16:43 +02001456 unsigned int numa_scan_period;
Mel Gorman598f0ec2013-10-07 11:28:55 +01001457 unsigned int numa_scan_period_max;
Rik van Rielde1c9ce2013-10-07 11:29:39 +01001458 int numa_preferred_nid;
1459 int numa_migrate_deferred;
Mel Gorman6b9a7462013-10-07 11:29:11 +01001460 unsigned long numa_migrate_retry;
Peter Zijlstracbee9f82012-10-25 14:16:43 +02001461 u64 node_stamp; /* migration stamp */
1462 struct callback_head numa_work;
Mel Gormanf809ca92013-10-07 11:28:57 +01001463
Peter Zijlstra8c8a7432013-10-07 11:29:21 +01001464 struct list_head numa_entry;
1465 struct numa_group *numa_group;
1466
Mel Gorman745d6142013-10-07 11:28:59 +01001467 /*
1468 * Exponential decaying average of faults on a per-node basis.
1469 * Scheduling placement decisions are made based on the these counts.
1470 * The values remain static for the duration of a PTE scan
1471 */
Mel Gormanf809ca92013-10-07 11:28:57 +01001472 unsigned long *numa_faults;
Mel Gorman83e1d2c2013-10-07 11:29:27 +01001473 unsigned long total_numa_faults;
Mel Gorman745d6142013-10-07 11:28:59 +01001474
1475 /*
1476 * numa_faults_buffer records faults per node during the current
1477 * scan window. When the scan completes, the counts in numa_faults
1478 * decay and these values are copied.
1479 */
1480 unsigned long *numa_faults_buffer;
1481
Rik van Riel04bb2f92013-10-07 11:29:36 +01001482 /*
1483 * numa_faults_locality tracks if faults recorded during the last
1484 * scan window were remote/local. The task scan period is adapted
1485 * based on the locality of the faults with different weights
1486 * depending on whether they were shared or private faults
1487 */
1488 unsigned long numa_faults_locality[2];
1489
Ingo Molnarb32e86b2013-10-07 11:29:30 +01001490 unsigned long numa_pages_migrated;
Peter Zijlstracbee9f82012-10-25 14:16:43 +02001491#endif /* CONFIG_NUMA_BALANCING */
1492
Ingo Molnare56d0902006-01-08 01:01:37 -08001493 struct rcu_head rcu;
Jens Axboeb92ce552006-04-11 13:52:07 +02001494
1495 /*
1496 * cache last used pipe for splice
1497 */
1498 struct pipe_inode_info *splice_pipe;
Eric Dumazet5640f762012-09-23 23:04:42 +00001499
1500 struct page_frag task_frag;
1501
Shailabh Nagarca74e922006-07-14 00:24:36 -07001502#ifdef CONFIG_TASK_DELAY_ACCT
1503 struct task_delay_info *delays;
1504#endif
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08001505#ifdef CONFIG_FAULT_INJECTION
1506 int make_it_fail;
1507#endif
Wu Fengguang9d823e82011-06-11 18:10:12 -06001508 /*
1509 * when (nr_dirtied >= nr_dirtied_pause), it's time to call
1510 * balance_dirty_pages() for some dirty throttling pause
1511 */
1512 int nr_dirtied;
1513 int nr_dirtied_pause;
Wu Fengguang83712352011-06-11 19:25:42 -06001514 unsigned long dirty_paused_when; /* start of a write-and-pause period */
Wu Fengguang9d823e82011-06-11 18:10:12 -06001515
Arjan van de Ven97455122008-01-25 21:08:34 +01001516#ifdef CONFIG_LATENCYTOP
1517 int latency_record_count;
1518 struct latency_record latency_record[LT_SAVECOUNT];
1519#endif
Arjan van de Ven69766752008-09-01 15:52:40 -07001520 /*
1521 * time slack values; these are used to round up poll() and
1522 * select() etc timeout values. These are in nanoseconds.
1523 */
1524 unsigned long timer_slack_ns;
1525 unsigned long default_timer_slack_ns;
David Millerf8d570a2008-11-06 00:37:40 -08001526
Frederic Weisbeckerfb526072008-11-25 21:07:04 +01001527#ifdef CONFIG_FUNCTION_GRAPH_TRACER
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08001528 /* Index of current stored address in ret_stack */
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +01001529 int curr_ret_stack;
1530 /* Stack of return addresses for return function tracing */
1531 struct ftrace_ret_stack *ret_stack;
Steven Rostedt8aef2d22009-03-24 01:10:15 -04001532 /* time stamp for last schedule */
1533 unsigned long long ftrace_timestamp;
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +01001534 /*
1535 * Number of functions that haven't been traced
1536 * because of depth overrun.
1537 */
1538 atomic_t trace_overrun;
Frederic Weisbecker380c4b12008-12-06 03:43:41 +01001539 /* Pause for the tracing */
1540 atomic_t tracing_graph_pause;
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +01001541#endif
Steven Rostedtea4e2bc2008-12-03 15:36:57 -05001542#ifdef CONFIG_TRACING
1543 /* state flags for use by tracers */
1544 unsigned long trace;
Steven Rostedtb1cff0a2011-05-25 14:27:43 -04001545 /* bitmask and counter of trace recursion */
Steven Rostedt261842b2009-04-16 21:41:52 -04001546 unsigned long trace_recursion;
1547#endif /* CONFIG_TRACING */
Andrew Mortonc255a452012-07-31 16:43:02 -07001548#ifdef CONFIG_MEMCG /* memcg uses this to do batch job */
KAMEZAWA Hiroyuki569b8462009-12-15 16:47:03 -08001549 struct memcg_batch_info {
1550 int do_batch; /* incremented when batch uncharge started */
1551 struct mem_cgroup *memcg; /* target memcg of uncharge */
Johannes Weiner7ffd4ca2011-03-23 16:42:35 -07001552 unsigned long nr_pages; /* uncharged usage */
1553 unsigned long memsw_nr_pages; /* uncharged mem+swap usage */
KAMEZAWA Hiroyuki569b8462009-12-15 16:47:03 -08001554 } memcg_batch;
Glauber Costa0e9d92f2012-12-18 14:22:42 -08001555 unsigned int memcg_kmem_skip_account;
Johannes Weiner519e5242013-09-12 15:13:42 -07001556 struct memcg_oom_info {
Johannes Weiner49426422013-10-16 13:46:59 -07001557 struct mem_cgroup *memcg;
1558 gfp_t gfp_mask;
1559 int order;
Johannes Weiner519e5242013-09-12 15:13:42 -07001560 unsigned int may_oom:1;
1561 } memcg_oom;
KAMEZAWA Hiroyuki569b8462009-12-15 16:47:03 -08001562#endif
Srikar Dronamraju0326f5a2012-03-13 23:30:11 +05301563#ifdef CONFIG_UPROBES
1564 struct uprobe_task *utask;
Srikar Dronamraju0326f5a2012-03-13 23:30:11 +05301565#endif
Kent Overstreetcafe5632013-03-23 16:11:31 -07001566#if defined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)
1567 unsigned int sequential_io;
1568 unsigned int sequential_io_avg;
1569#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570};
1571
Rusty Russell76e6eee2009-03-12 14:35:43 -06001572/* Future-safe accessor for struct task_struct's cpus_allowed. */
Rusty Russella4636812009-12-17 11:43:29 -06001573#define tsk_cpus_allowed(tsk) (&(tsk)->cpus_allowed)
Rusty Russell76e6eee2009-03-12 14:35:43 -06001574
Peter Zijlstra6688cc02013-10-07 11:29:24 +01001575#define TNF_MIGRATED 0x01
1576#define TNF_NO_GROUP 0x02
Rik van Rieldabe1d92013-10-07 11:29:34 +01001577#define TNF_SHARED 0x04
Rik van Riel04bb2f92013-10-07 11:29:36 +01001578#define TNF_FAULT_LOCAL 0x08
Peter Zijlstra6688cc02013-10-07 11:29:24 +01001579
Peter Zijlstracbee9f82012-10-25 14:16:43 +02001580#ifdef CONFIG_NUMA_BALANCING
Peter Zijlstra6688cc02013-10-07 11:29:24 +01001581extern void task_numa_fault(int last_node, int node, int pages, int flags);
Mel Gormane29cf082013-10-07 11:29:22 +01001582extern pid_t task_numa_group_id(struct task_struct *p);
Mel Gorman1a687c22012-11-22 11:16:36 +00001583extern void set_numabalancing_state(bool enabled);
Rik van Riel82727012013-10-07 11:29:28 +01001584extern void task_numa_free(struct task_struct *p);
Rik van Rielde1c9ce2013-10-07 11:29:39 +01001585
1586extern unsigned int sysctl_numa_balancing_migrate_deferred;
Peter Zijlstracbee9f82012-10-25 14:16:43 +02001587#else
Mel Gormanac8e8952013-10-07 11:29:03 +01001588static inline void task_numa_fault(int last_node, int node, int pages,
Peter Zijlstra6688cc02013-10-07 11:29:24 +01001589 int flags)
Peter Zijlstracbee9f82012-10-25 14:16:43 +02001590{
1591}
Mel Gormane29cf082013-10-07 11:29:22 +01001592static inline pid_t task_numa_group_id(struct task_struct *p)
1593{
1594 return 0;
1595}
Mel Gorman1a687c22012-11-22 11:16:36 +00001596static inline void set_numabalancing_state(bool enabled)
1597{
1598}
Rik van Riel82727012013-10-07 11:29:28 +01001599static inline void task_numa_free(struct task_struct *p)
1600{
1601}
Peter Zijlstracbee9f82012-10-25 14:16:43 +02001602#endif
1603
Alexey Dobriyane8681712007-10-26 12:17:22 +04001604static inline struct pid *task_pid(struct task_struct *task)
Eric W. Biederman22c935f2006-10-02 02:17:09 -07001605{
1606 return task->pids[PIDTYPE_PID].pid;
1607}
1608
Alexey Dobriyane8681712007-10-26 12:17:22 +04001609static inline struct pid *task_tgid(struct task_struct *task)
Eric W. Biederman22c935f2006-10-02 02:17:09 -07001610{
1611 return task->group_leader->pids[PIDTYPE_PID].pid;
1612}
1613
Oleg Nesterov6dda81f2009-04-02 16:58:35 -07001614/*
1615 * Without tasklist or rcu lock it is not safe to dereference
1616 * the result of task_pgrp/task_session even if task == current,
1617 * we can race with another thread doing sys_setsid/sys_setpgid.
1618 */
Alexey Dobriyane8681712007-10-26 12:17:22 +04001619static inline struct pid *task_pgrp(struct task_struct *task)
Eric W. Biederman22c935f2006-10-02 02:17:09 -07001620{
1621 return task->group_leader->pids[PIDTYPE_PGID].pid;
1622}
1623
Alexey Dobriyane8681712007-10-26 12:17:22 +04001624static inline struct pid *task_session(struct task_struct *task)
Eric W. Biederman22c935f2006-10-02 02:17:09 -07001625{
1626 return task->group_leader->pids[PIDTYPE_SID].pid;
1627}
1628
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001629struct pid_namespace;
1630
1631/*
1632 * the helpers to get the task's different pids as they are seen
1633 * from various namespaces
1634 *
1635 * task_xid_nr() : global id, i.e. the id seen from the init namespace;
Eric W. Biederman44c4e1b2008-02-08 04:19:15 -08001636 * task_xid_vnr() : virtual id, i.e. the id seen from the pid namespace of
1637 * current.
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001638 * task_xid_nr_ns() : id seen from the ns specified;
1639 *
1640 * set_task_vxid() : assigns a virtual id to a task;
1641 *
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001642 * see also pid_nr() etc in include/linux/pid.h
1643 */
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001644pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
1645 struct pid_namespace *ns);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001646
Alexey Dobriyane8681712007-10-26 12:17:22 +04001647static inline pid_t task_pid_nr(struct task_struct *tsk)
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001648{
1649 return tsk->pid;
1650}
1651
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001652static inline pid_t task_pid_nr_ns(struct task_struct *tsk,
1653 struct pid_namespace *ns)
1654{
1655 return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
1656}
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001657
1658static inline pid_t task_pid_vnr(struct task_struct *tsk)
1659{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001660 return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001661}
1662
1663
Alexey Dobriyane8681712007-10-26 12:17:22 +04001664static inline pid_t task_tgid_nr(struct task_struct *tsk)
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001665{
1666 return tsk->tgid;
1667}
1668
Pavel Emelyanov2f2a3a42007-10-18 23:40:19 -07001669pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001670
1671static inline pid_t task_tgid_vnr(struct task_struct *tsk)
1672{
1673 return pid_vnr(task_tgid(tsk));
1674}
1675
1676
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001677static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,
1678 struct pid_namespace *ns)
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001679{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001680 return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001681}
1682
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001683static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
1684{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001685 return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001686}
1687
1688
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001689static inline pid_t task_session_nr_ns(struct task_struct *tsk,
1690 struct pid_namespace *ns)
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001691{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001692 return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001693}
1694
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001695static inline pid_t task_session_vnr(struct task_struct *tsk)
1696{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001697 return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001698}
1699
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07001700/* obsolete, do not use */
1701static inline pid_t task_pgrp_nr(struct task_struct *tsk)
1702{
1703 return task_pgrp_nr_ns(tsk, &init_pid_ns);
1704}
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001705
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706/**
1707 * pid_alive - check that a task structure is not stale
1708 * @p: Task structure to be checked.
1709 *
1710 * Test if a process is not yet dead (at most zombie state)
1711 * If pid_alive fails, then pointers within the task structure
1712 * can be stale and must not be dereferenced.
Yacine Belkadie69f6182013-07-12 20:45:47 +02001713 *
1714 * Return: 1 if the process is alive. 0 otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 */
Alexey Dobriyane8681712007-10-26 12:17:22 +04001716static inline int pid_alive(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717{
Eric W. Biederman92476d72006-03-31 02:31:42 -08001718 return p->pids[PIDTYPE_PID].pid != NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719}
1720
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -07001721/**
Serge E. Hallynb460cbc2007-10-18 23:39:52 -07001722 * is_global_init - check if a task structure is init
Henne32602592006-10-06 00:44:01 -07001723 * @tsk: Task structure to be checked.
1724 *
1725 * Check if a task structure is the first user space task the kernel created.
Yacine Belkadie69f6182013-07-12 20:45:47 +02001726 *
1727 * Return: 1 if the task structure is init. 0 otherwise.
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -07001728 */
Alexey Dobriyane8681712007-10-26 12:17:22 +04001729static inline int is_global_init(struct task_struct *tsk)
Pavel Emelyanovb461cc02007-10-18 23:40:09 -07001730{
1731 return tsk->pid == 1;
1732}
Serge E. Hallynb460cbc2007-10-18 23:39:52 -07001733
Cedric Le Goater9ec52092006-10-02 02:19:00 -07001734extern struct pid *cad_pid;
1735
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736extern void free_task(struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737#define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
Ingo Molnare56d0902006-01-08 01:01:37 -08001738
Andrew Morton158d9eb2006-03-31 02:31:34 -08001739extern void __put_task_struct(struct task_struct *t);
Ingo Molnare56d0902006-01-08 01:01:37 -08001740
1741static inline void put_task_struct(struct task_struct *t)
1742{
1743 if (atomic_dec_and_test(&t->usage))
Eric W. Biederman8c7904a2006-03-31 02:31:37 -08001744 __put_task_struct(t);
Ingo Molnare56d0902006-01-08 01:01:37 -08001745}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746
Frederic Weisbecker6a616712012-12-16 20:00:34 +01001747#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
1748extern void task_cputime(struct task_struct *t,
1749 cputime_t *utime, cputime_t *stime);
1750extern void task_cputime_scaled(struct task_struct *t,
1751 cputime_t *utimescaled, cputime_t *stimescaled);
1752extern cputime_t task_gtime(struct task_struct *t);
1753#else
Frederic Weisbecker6fac4822012-11-13 14:20:55 +01001754static inline void task_cputime(struct task_struct *t,
1755 cputime_t *utime, cputime_t *stime)
1756{
1757 if (utime)
1758 *utime = t->utime;
1759 if (stime)
1760 *stime = t->stime;
1761}
1762
1763static inline void task_cputime_scaled(struct task_struct *t,
1764 cputime_t *utimescaled,
1765 cputime_t *stimescaled)
1766{
1767 if (utimescaled)
1768 *utimescaled = t->utimescaled;
1769 if (stimescaled)
1770 *stimescaled = t->stimescaled;
1771}
Frederic Weisbecker6a616712012-12-16 20:00:34 +01001772
1773static inline cputime_t task_gtime(struct task_struct *t)
1774{
1775 return t->gtime;
1776}
1777#endif
Frederic Weisbeckere80d0a12012-11-21 16:26:44 +01001778extern void task_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
1779extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
Balbir Singh49048622008-09-05 18:12:23 +02001780
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781/*
1782 * Per process flags
1783 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784#define PF_EXITING 0x00000004 /* getting shut down */
Alexey Kuznetsov778e9a92007-06-08 13:47:00 -07001785#define PF_EXITPIDONE 0x00000008 /* pi exit done on shut down */
Laurent Vivier94886b82007-10-15 17:00:19 +02001786#define PF_VCPU 0x00000010 /* I'm a virtual CPU */
Tejun Heo21aa9af2010-06-08 21:40:37 +02001787#define PF_WQ_WORKER 0x00000020 /* I'm a workqueue worker */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788#define PF_FORKNOEXEC 0x00000040 /* forked but didn't exec */
Andi Kleen4db96cf2009-09-16 11:50:14 +02001789#define PF_MCE_PROCESS 0x00000080 /* process policy on mce errors */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790#define PF_SUPERPRIV 0x00000100 /* used super-user privileges */
1791#define PF_DUMPCORE 0x00000200 /* dumped core */
1792#define PF_SIGNALED 0x00000400 /* killed by a signal */
1793#define PF_MEMALLOC 0x00000800 /* Allocating memory */
Vasiliy Kulikov72fa5992011-08-08 19:02:04 +04001794#define PF_NPROC_EXCEEDED 0x00001000 /* set_user noticed that RLIMIT_NPROC was exceeded */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795#define PF_USED_MATH 0x00002000 /* if unset the fpu must be initialized before use */
Tejun Heo774a1222013-01-15 18:52:51 -08001796#define PF_USED_ASYNC 0x00004000 /* used async_schedule*(), used by module init */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797#define PF_NOFREEZE 0x00008000 /* this thread should not be frozen */
1798#define PF_FROZEN 0x00010000 /* frozen for system suspend */
1799#define PF_FSTRANS 0x00020000 /* inside a filesystem transaction */
1800#define PF_KSWAPD 0x00040000 /* I am kswapd */
Ming Lei21caf2f2013-02-22 16:34:08 -08001801#define PF_MEMALLOC_NOIO 0x00080000 /* Allocating memory without IO involved */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802#define PF_LESS_THROTTLE 0x00100000 /* Throttle me less: I clean memory */
Oleg Nesterov246bb0b2008-07-25 01:47:38 -07001803#define PF_KTHREAD 0x00200000 /* I am a kernel thread */
Jens Axboeb31dc662006-06-13 08:26:10 +02001804#define PF_RANDOMIZE 0x00400000 /* randomize virtual address space */
1805#define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */
1806#define PF_SPREAD_PAGE 0x01000000 /* Spread page cache over cpuset */
1807#define PF_SPREAD_SLAB 0x02000000 /* Spread some slab caches over cpuset */
Tejun Heo14a40ff2013-03-19 13:45:20 -07001808#define PF_NO_SETAFFINITY 0x04000000 /* Userland is not allowed to meddle with cpus_allowed */
Andi Kleen4db96cf2009-09-16 11:50:14 +02001809#define PF_MCE_EARLY 0x08000000 /* Early kill for mce process policy */
Paul Jacksonc61afb12006-03-24 03:16:08 -08001810#define PF_MEMPOLICY 0x10000000 /* Non-default NUMA mempolicy */
Thomas Gleixner61a87122006-06-27 02:54:56 -07001811#define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */
Tejun Heo58a69cb2011-02-16 09:25:31 +01001812#define PF_FREEZER_SKIP 0x40000000 /* Freezer should not count it as freezable */
Colin Cross2b44c4d2013-07-24 17:41:33 -07001813#define PF_SUSPEND_TASK 0x80000000 /* this thread called freeze_processes and should not be frozen */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814
1815/*
1816 * Only the _current_ task can read/write to tsk->flags, but other
1817 * tasks can access tsk->flags in readonly mode for example
1818 * with tsk_used_math (like during threaded core dumping).
1819 * There is however an exception to this rule during ptrace
1820 * or during fork: the ptracer task is allowed to write to the
1821 * child->flags of its traced child (same goes for fork, the parent
1822 * can write to the child->flags), because we're guaranteed the
1823 * child is not running and in turn not changing child->flags
1824 * at the same time the parent does it.
1825 */
1826#define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
1827#define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
1828#define clear_used_math() clear_stopped_child_used_math(current)
1829#define set_used_math() set_stopped_child_used_math(current)
1830#define conditional_stopped_child_used_math(condition, child) \
1831 do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
1832#define conditional_used_math(condition) \
1833 conditional_stopped_child_used_math(condition, current)
1834#define copy_to_stopped_child_used_math(child) \
1835 do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
1836/* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
1837#define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
1838#define used_math() tsk_used_math(current)
1839
Ming Lei21caf2f2013-02-22 16:34:08 -08001840/* __GFP_IO isn't allowed if PF_MEMALLOC_NOIO is set in current->flags */
1841static inline gfp_t memalloc_noio_flags(gfp_t flags)
1842{
1843 if (unlikely(current->flags & PF_MEMALLOC_NOIO))
1844 flags &= ~__GFP_IO;
1845 return flags;
1846}
1847
1848static inline unsigned int memalloc_noio_save(void)
1849{
1850 unsigned int flags = current->flags & PF_MEMALLOC_NOIO;
1851 current->flags |= PF_MEMALLOC_NOIO;
1852 return flags;
1853}
1854
1855static inline void memalloc_noio_restore(unsigned int flags)
1856{
1857 current->flags = (current->flags & ~PF_MEMALLOC_NOIO) | flags;
1858}
1859
Tejun Heoe5c19022011-03-23 10:37:00 +01001860/*
Tejun Heoa8f072c2011-06-02 11:13:59 +02001861 * task->jobctl flags
Tejun Heoe5c19022011-03-23 10:37:00 +01001862 */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001863#define JOBCTL_STOP_SIGMASK 0xffff /* signr of the last group stop */
Tejun Heoe5c19022011-03-23 10:37:00 +01001864
Tejun Heoa8f072c2011-06-02 11:13:59 +02001865#define JOBCTL_STOP_DEQUEUED_BIT 16 /* stop signal dequeued */
1866#define JOBCTL_STOP_PENDING_BIT 17 /* task should stop for group stop */
1867#define JOBCTL_STOP_CONSUME_BIT 18 /* consume group stop count */
Tejun Heo73ddff22011-06-14 11:20:14 +02001868#define JOBCTL_TRAP_STOP_BIT 19 /* trap for STOP */
Tejun Heofb1d9102011-06-14 11:20:17 +02001869#define JOBCTL_TRAP_NOTIFY_BIT 20 /* trap for NOTIFY */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001870#define JOBCTL_TRAPPING_BIT 21 /* switching to TRACED */
Tejun Heo544b2c92011-06-14 11:20:18 +02001871#define JOBCTL_LISTENING_BIT 22 /* ptracer is listening for events */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001872
1873#define JOBCTL_STOP_DEQUEUED (1 << JOBCTL_STOP_DEQUEUED_BIT)
1874#define JOBCTL_STOP_PENDING (1 << JOBCTL_STOP_PENDING_BIT)
1875#define JOBCTL_STOP_CONSUME (1 << JOBCTL_STOP_CONSUME_BIT)
Tejun Heo73ddff22011-06-14 11:20:14 +02001876#define JOBCTL_TRAP_STOP (1 << JOBCTL_TRAP_STOP_BIT)
Tejun Heofb1d9102011-06-14 11:20:17 +02001877#define JOBCTL_TRAP_NOTIFY (1 << JOBCTL_TRAP_NOTIFY_BIT)
Tejun Heoa8f072c2011-06-02 11:13:59 +02001878#define JOBCTL_TRAPPING (1 << JOBCTL_TRAPPING_BIT)
Tejun Heo544b2c92011-06-14 11:20:18 +02001879#define JOBCTL_LISTENING (1 << JOBCTL_LISTENING_BIT)
Tejun Heoa8f072c2011-06-02 11:13:59 +02001880
Tejun Heofb1d9102011-06-14 11:20:17 +02001881#define JOBCTL_TRAP_MASK (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)
Tejun Heo73ddff22011-06-14 11:20:14 +02001882#define JOBCTL_PENDING_MASK (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)
Tejun Heo3759a0d2011-06-02 11:14:00 +02001883
Tejun Heo7dd3db52011-06-02 11:14:00 +02001884extern bool task_set_jobctl_pending(struct task_struct *task,
1885 unsigned int mask);
Tejun Heo73ddff22011-06-14 11:20:14 +02001886extern void task_clear_jobctl_trapping(struct task_struct *task);
Tejun Heo3759a0d2011-06-02 11:14:00 +02001887extern void task_clear_jobctl_pending(struct task_struct *task,
1888 unsigned int mask);
Tejun Heo39efa3e2011-03-23 10:37:00 +01001889
Paul E. McKenneya57eb942010-06-29 16:49:16 -07001890#ifdef CONFIG_PREEMPT_RCU
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001891
1892#define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */
Paul E. McKenney1aa03f12012-01-11 17:25:17 -08001893#define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001894
1895static inline void rcu_copy_process(struct task_struct *p)
1896{
1897 p->rcu_read_lock_nesting = 0;
1898 p->rcu_read_unlock_special = 0;
Paul E. McKenneya57eb942010-06-29 16:49:16 -07001899#ifdef CONFIG_TREE_PREEMPT_RCU
Paul E. McKenneydd5d19b2009-08-27 14:58:16 -07001900 p->rcu_blocked_node = NULL;
Paul E. McKenney24278d12010-09-27 17:25:23 -07001901#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
1902#ifdef CONFIG_RCU_BOOST
1903 p->rcu_boost_mutex = NULL;
1904#endif /* #ifdef CONFIG_RCU_BOOST */
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001905 INIT_LIST_HEAD(&p->rcu_node_entry);
1906}
1907
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001908#else
1909
1910static inline void rcu_copy_process(struct task_struct *p)
1911{
1912}
1913
1914#endif
1915
Mel Gorman907aed42012-07-31 16:44:07 -07001916static inline void tsk_restore_flags(struct task_struct *task,
1917 unsigned long orig_flags, unsigned long flags)
1918{
1919 task->flags &= ~flags;
1920 task->flags |= orig_flags & flags;
1921}
1922
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923#ifdef CONFIG_SMP
KOSAKI Motohiro1e1b6c52011-05-19 15:08:58 +09001924extern void do_set_cpus_allowed(struct task_struct *p,
1925 const struct cpumask *new_mask);
1926
Mike Traviscd8ba7c2008-03-26 14:23:49 -07001927extern int set_cpus_allowed_ptr(struct task_struct *p,
Rusty Russell96f874e2008-11-25 02:35:14 +10301928 const struct cpumask *new_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929#else
KOSAKI Motohiro1e1b6c52011-05-19 15:08:58 +09001930static inline void do_set_cpus_allowed(struct task_struct *p,
1931 const struct cpumask *new_mask)
1932{
1933}
Mike Traviscd8ba7c2008-03-26 14:23:49 -07001934static inline int set_cpus_allowed_ptr(struct task_struct *p,
Rusty Russell96f874e2008-11-25 02:35:14 +10301935 const struct cpumask *new_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936{
Rusty Russell96f874e2008-11-25 02:35:14 +10301937 if (!cpumask_test_cpu(0, new_mask))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 return -EINVAL;
1939 return 0;
1940}
1941#endif
Rusty Russelle0ad9552009-09-24 09:34:38 -06001942
Frederic Weisbecker3451d022011-08-10 23:21:01 +02001943#ifdef CONFIG_NO_HZ_COMMON
Peter Zijlstra5167e8d2012-06-22 15:52:09 +02001944void calc_load_enter_idle(void);
1945void calc_load_exit_idle(void);
1946#else
1947static inline void calc_load_enter_idle(void) { }
1948static inline void calc_load_exit_idle(void) { }
Frederic Weisbecker3451d022011-08-10 23:21:01 +02001949#endif /* CONFIG_NO_HZ_COMMON */
Peter Zijlstra5167e8d2012-06-22 15:52:09 +02001950
Rusty Russelle0ad9552009-09-24 09:34:38 -06001951#ifndef CONFIG_CPUMASK_OFFSTACK
Mike Traviscd8ba7c2008-03-26 14:23:49 -07001952static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
1953{
1954 return set_cpus_allowed_ptr(p, &new_mask);
1955}
Rusty Russelle0ad9552009-09-24 09:34:38 -06001956#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957
Ingo Molnarb3425012009-02-26 20:20:29 +01001958/*
Peter Zijlstrac6763292010-05-25 10:48:51 +02001959 * Do not use outside of architecture code which knows its limitations.
1960 *
1961 * sched_clock() has no promise of monotonicity or bounded drift between
1962 * CPUs, use (which you should not) requires disabling IRQs.
1963 *
1964 * Please use one of the three interfaces below.
Ingo Molnarb3425012009-02-26 20:20:29 +01001965 */
Mike Frysinger1bbfa6f2009-12-09 20:07:03 -05001966extern unsigned long long notrace sched_clock(void);
Peter Zijlstrac6763292010-05-25 10:48:51 +02001967/*
Hiroshi Shimamoto489a71b2012-04-02 17:00:44 +09001968 * See the comment in kernel/sched/clock.c
Peter Zijlstrac6763292010-05-25 10:48:51 +02001969 */
1970extern u64 cpu_clock(int cpu);
1971extern u64 local_clock(void);
1972extern u64 sched_clock_cpu(int cpu);
1973
Ingo Molnare436d802007-07-19 21:28:35 +02001974
Peter Zijlstrac1955a32008-08-11 08:59:03 +02001975extern void sched_clock_init(void);
Peter Zijlstrac1955a32008-08-11 08:59:03 +02001976
Peter Zijlstra3e51f332008-05-03 18:29:28 +02001977#ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
Peter Zijlstra3e51f332008-05-03 18:29:28 +02001978static inline void sched_clock_tick(void)
1979{
1980}
1981
1982static inline void sched_clock_idle_sleep_event(void)
1983{
1984}
1985
1986static inline void sched_clock_idle_wakeup_event(u64 delta_ns)
1987{
1988}
1989#else
Peter Zijlstrac6763292010-05-25 10:48:51 +02001990/*
1991 * Architectures can set this to 1 if they have specified
1992 * CONFIG_HAVE_UNSTABLE_SCHED_CLOCK in their arch Kconfig,
1993 * but then during bootup it turns out that sched_clock()
1994 * is reliable after all:
1995 */
1996extern int sched_clock_stable;
1997
Peter Zijlstra3e51f332008-05-03 18:29:28 +02001998extern void sched_clock_tick(void);
1999extern void sched_clock_idle_sleep_event(void);
2000extern void sched_clock_idle_wakeup_event(u64 delta_ns);
2001#endif
2002
Venkatesh Pallipadib52bfee2010-10-04 17:03:19 -07002003#ifdef CONFIG_IRQ_TIME_ACCOUNTING
2004/*
2005 * An i/f to runtime opt-in for irq time accounting based off of sched_clock.
2006 * The reason for this explicit opt-in is not to have perf penalty with
2007 * slow sched_clocks.
2008 */
2009extern void enable_sched_clock_irqtime(void);
2010extern void disable_sched_clock_irqtime(void);
2011#else
2012static inline void enable_sched_clock_irqtime(void) {}
2013static inline void disable_sched_clock_irqtime(void) {}
2014#endif
2015
Ingo Molnar36c8b582006-07-03 00:25:41 -07002016extern unsigned long long
Ingo Molnar41b86e92007-07-09 18:51:58 +02002017task_sched_runtime(struct task_struct *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018
2019/* sched_exec is called by processes performing an exec */
2020#ifdef CONFIG_SMP
2021extern void sched_exec(void);
2022#else
2023#define sched_exec() {}
2024#endif
2025
Ingo Molnar2aa44d02007-08-23 15:18:02 +02002026extern void sched_clock_idle_sleep_event(void);
2027extern void sched_clock_idle_wakeup_event(u64 delta_ns);
Ingo Molnarbb29ab22007-07-09 18:51:59 +02002028
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029#ifdef CONFIG_HOTPLUG_CPU
2030extern void idle_task_exit(void);
2031#else
2032static inline void idle_task_exit(void) {}
2033#endif
2034
Frederic Weisbecker3451d022011-08-10 23:21:01 +02002035#if defined(CONFIG_NO_HZ_COMMON) && defined(CONFIG_SMP)
Frederic Weisbecker1c200912011-08-10 23:21:01 +02002036extern void wake_up_nohz_cpu(int cpu);
Thomas Gleixner06d83082008-03-22 09:20:24 +01002037#else
Frederic Weisbecker1c200912011-08-10 23:21:01 +02002038static inline void wake_up_nohz_cpu(int cpu) { }
Thomas Gleixner06d83082008-03-22 09:20:24 +01002039#endif
2040
Frederic Weisbeckerce831b32013-04-20 15:15:35 +02002041#ifdef CONFIG_NO_HZ_FULL
2042extern bool sched_can_stop_tick(void);
Frederic Weisbecker265f22a2013-05-03 03:39:05 +02002043extern u64 scheduler_tick_max_deferment(void);
Frederic Weisbeckerce831b32013-04-20 15:15:35 +02002044#else
2045static inline bool sched_can_stop_tick(void) { return false; }
Ingo Molnarbf0f6f22007-07-09 18:51:58 +02002046#endif
Ingo Molnarbf0f6f22007-07-09 18:51:58 +02002047
Mike Galbraith5091faa2010-11-30 14:18:03 +01002048#ifdef CONFIG_SCHED_AUTOGROUP
Mike Galbraith5091faa2010-11-30 14:18:03 +01002049extern void sched_autogroup_create_attach(struct task_struct *p);
2050extern void sched_autogroup_detach(struct task_struct *p);
2051extern void sched_autogroup_fork(struct signal_struct *sig);
2052extern void sched_autogroup_exit(struct signal_struct *sig);
2053#ifdef CONFIG_PROC_FS
2054extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m);
Hiroshi Shimamoto2e5b5b32012-02-23 17:41:27 +09002055extern int proc_sched_autogroup_set_nice(struct task_struct *p, int nice);
Mike Galbraith5091faa2010-11-30 14:18:03 +01002056#endif
2057#else
2058static inline void sched_autogroup_create_attach(struct task_struct *p) { }
2059static inline void sched_autogroup_detach(struct task_struct *p) { }
2060static inline void sched_autogroup_fork(struct signal_struct *sig) { }
2061static inline void sched_autogroup_exit(struct signal_struct *sig) { }
2062#endif
2063
Mike Galbraithd95f4122011-02-01 09:50:51 -05002064extern bool yield_to(struct task_struct *p, bool preempt);
Ingo Molnar36c8b582006-07-03 00:25:41 -07002065extern void set_user_nice(struct task_struct *p, long nice);
2066extern int task_prio(const struct task_struct *p);
2067extern int task_nice(const struct task_struct *p);
2068extern int can_nice(const struct task_struct *p, const int nice);
2069extern int task_curr(const struct task_struct *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070extern int idle_cpu(int cpu);
KOSAKI Motohirofe7de492010-10-20 16:01:12 -07002071extern int sched_setscheduler(struct task_struct *, int,
2072 const struct sched_param *);
Rusty Russell961ccdd2008-06-23 13:55:38 +10002073extern int sched_setscheduler_nocheck(struct task_struct *, int,
KOSAKI Motohirofe7de492010-10-20 16:01:12 -07002074 const struct sched_param *);
Dario Faggiolid50dde52013-11-07 14:43:36 +01002075extern int sched_setattr(struct task_struct *,
2076 const struct sched_attr *);
Ingo Molnar36c8b582006-07-03 00:25:41 -07002077extern struct task_struct *idle_task(int cpu);
Paul E. McKenneyc4f30602011-11-10 12:41:56 -08002078/**
2079 * is_idle_task - is the specified task an idle task?
Randy Dunlapfa757282012-01-21 11:03:13 -08002080 * @p: the task in question.
Yacine Belkadie69f6182013-07-12 20:45:47 +02002081 *
2082 * Return: 1 if @p is an idle task. 0 otherwise.
Paul E. McKenneyc4f30602011-11-10 12:41:56 -08002083 */
Paul E. McKenney7061ca32011-12-20 08:20:46 -08002084static inline bool is_idle_task(const struct task_struct *p)
Paul E. McKenneyc4f30602011-11-10 12:41:56 -08002085{
2086 return p->pid == 0;
2087}
Ingo Molnar36c8b582006-07-03 00:25:41 -07002088extern struct task_struct *curr_task(int cpu);
2089extern void set_curr_task(int cpu, struct task_struct *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090
2091void yield(void);
2092
2093/*
2094 * The default (Linux) execution domain.
2095 */
2096extern struct exec_domain default_exec_domain;
2097
2098union thread_union {
2099 struct thread_info thread_info;
2100 unsigned long stack[THREAD_SIZE/sizeof(long)];
2101};
2102
2103#ifndef __HAVE_ARCH_KSTACK_END
2104static inline int kstack_end(void *addr)
2105{
2106 /* Reliable end of stack detection:
2107 * Some APM bios versions misalign the stack
2108 */
2109 return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
2110}
2111#endif
2112
2113extern union thread_union init_thread_union;
2114extern struct task_struct init_task;
2115
2116extern struct mm_struct init_mm;
2117
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002118extern struct pid_namespace init_pid_ns;
2119
2120/*
2121 * find a task by one of its numerical ids
2122 *
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002123 * find_task_by_pid_ns():
2124 * finds a task by its pid in the specified namespace
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -07002125 * find_task_by_vpid():
2126 * finds a task by its virtual pid
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002127 *
Pavel Emelyanove49859e2008-07-25 01:48:36 -07002128 * see also find_vpid() etc in include/linux/pid.h
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002129 */
2130
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -07002131extern struct task_struct *find_task_by_vpid(pid_t nr);
2132extern struct task_struct *find_task_by_pid_ns(pid_t nr,
2133 struct pid_namespace *ns);
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002134
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135/* per-UID process charging. */
Eric W. Biederman7b44ab92011-11-16 23:20:58 -08002136extern struct user_struct * alloc_uid(kuid_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137static inline struct user_struct *get_uid(struct user_struct *u)
2138{
2139 atomic_inc(&u->__count);
2140 return u;
2141}
2142extern void free_uid(struct user_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143
2144#include <asm/current.h>
2145
Torben Hohnf0af911a92011-01-27 15:59:10 +01002146extern void xtime_update(unsigned long ticks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147
Harvey Harrisonb3c97522008-02-13 15:03:15 -08002148extern int wake_up_state(struct task_struct *tsk, unsigned int state);
2149extern int wake_up_process(struct task_struct *tsk);
Samir Bellabes3e51e3e2011-05-11 18:18:05 +02002150extern void wake_up_new_task(struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151#ifdef CONFIG_SMP
2152 extern void kick_process(struct task_struct *tsk);
2153#else
2154 static inline void kick_process(struct task_struct *tsk) { }
2155#endif
Dario Faggioliaab03e02013-11-28 11:14:43 +01002156extern int sched_fork(unsigned long clone_flags, struct task_struct *p);
Ingo Molnarad46c2c2007-07-09 18:52:00 +02002157extern void sched_dead(struct task_struct *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159extern void proc_caches_init(void);
2160extern void flush_signals(struct task_struct *);
David Howells3bcac022009-04-29 13:45:05 +01002161extern void __flush_signals(struct task_struct *);
Oleg Nesterov10ab8252007-05-09 02:34:37 -07002162extern void ignore_signals(struct task_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163extern void flush_signal_handlers(struct task_struct *, int force_default);
2164extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
2165
2166static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
2167{
2168 unsigned long flags;
2169 int ret;
2170
2171 spin_lock_irqsave(&tsk->sighand->siglock, flags);
2172 ret = dequeue_signal(tsk, mask, info);
2173 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
2174
2175 return ret;
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02002176}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177
2178extern void block_all_signals(int (*notifier)(void *priv), void *priv,
2179 sigset_t *mask);
2180extern void unblock_all_signals(void);
2181extern void release_task(struct task_struct * p);
2182extern int send_sig_info(int, struct siginfo *, struct task_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183extern int force_sigsegv(int, struct task_struct *);
2184extern int force_sig_info(int, struct siginfo *, struct task_struct *);
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07002185extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07002186extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
Serge Hallynd178bc32011-09-26 10:45:18 -05002187extern int kill_pid_info_as_cred(int, struct siginfo *, struct pid *,
2188 const struct cred *, u32);
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07002189extern int kill_pgrp(struct pid *pid, int sig, int priv);
2190extern int kill_pid(struct pid *pid, int sig, int priv);
Matthew Wilcoxc3de4b32007-02-09 08:11:47 -07002191extern int kill_proc_info(int, struct siginfo *, pid_t);
Oleg Nesterov86773472011-06-22 23:09:09 +02002192extern __must_check bool do_notify_parent(struct task_struct *, int);
Oleg Nesterova7f07652009-09-23 15:56:44 -07002193extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194extern void force_sig(int, struct task_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195extern int send_sig(int, struct task_struct *, int);
Oleg Nesterov09faef12010-05-26 14:43:11 -07002196extern int zap_other_threads(struct task_struct *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197extern struct sigqueue *sigqueue_alloc(void);
2198extern void sigqueue_free(struct sigqueue *);
Oleg Nesterovac5c2152008-04-30 00:52:57 -07002199extern int send_sigqueue(struct sigqueue *, struct task_struct *, int group);
Oleg Nesterov9ac95f22006-02-09 22:41:50 +03002200extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201
Al Viro51a7b442012-05-21 23:33:55 -04002202static inline void restore_saved_sigmask(void)
2203{
2204 if (test_and_clear_restore_sigmask())
Al Viro77097ae2012-04-27 13:58:59 -04002205 __set_current_blocked(&current->saved_sigmask);
Al Viro51a7b442012-05-21 23:33:55 -04002206}
2207
Al Virob7f9a112012-05-02 09:59:21 -04002208static inline sigset_t *sigmask_to_save(void)
2209{
2210 sigset_t *res = &current->blocked;
2211 if (unlikely(test_restore_sigmask()))
2212 res = &current->saved_sigmask;
2213 return res;
2214}
2215
Cedric Le Goater9ec52092006-10-02 02:19:00 -07002216static inline int kill_cad_pid(int sig, int priv)
2217{
2218 return kill_pid(cad_pid, sig, priv);
2219}
2220
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221/* These can be the second arg to send_sig_info/send_group_sig_info. */
2222#define SEND_SIG_NOINFO ((struct siginfo *) 0)
2223#define SEND_SIG_PRIV ((struct siginfo *) 1)
2224#define SEND_SIG_FORCED ((struct siginfo *) 2)
2225
Sebastian Andrzej Siewior2a855dd2009-10-25 15:37:58 +01002226/*
2227 * True if we are on the alternate signal stack.
2228 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229static inline int on_sig_stack(unsigned long sp)
2230{
Sebastian Andrzej Siewior2a855dd2009-10-25 15:37:58 +01002231#ifdef CONFIG_STACK_GROWSUP
2232 return sp >= current->sas_ss_sp &&
2233 sp - current->sas_ss_sp < current->sas_ss_size;
2234#else
2235 return sp > current->sas_ss_sp &&
2236 sp - current->sas_ss_sp <= current->sas_ss_size;
2237#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238}
2239
2240static inline int sas_ss_flags(unsigned long sp)
2241{
2242 return (current->sas_ss_size == 0 ? SS_DISABLE
2243 : on_sig_stack(sp) ? SS_ONSTACK : 0);
2244}
2245
Al Viro5a1b98d2012-11-06 13:28:21 -05002246static inline unsigned long sigsp(unsigned long sp, struct ksignal *ksig)
2247{
2248 if (unlikely((ksig->ka.sa.sa_flags & SA_ONSTACK)) && ! sas_ss_flags(sp))
2249#ifdef CONFIG_STACK_GROWSUP
2250 return current->sas_ss_sp;
2251#else
2252 return current->sas_ss_sp + current->sas_ss_size;
2253#endif
2254 return sp;
2255}
2256
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257/*
2258 * Routines for handling mm_structs
2259 */
2260extern struct mm_struct * mm_alloc(void);
2261
2262/* mmdrop drops the mm and the page tables */
Harvey Harrisonb3c97522008-02-13 15:03:15 -08002263extern void __mmdrop(struct mm_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264static inline void mmdrop(struct mm_struct * mm)
2265{
Ingo Molnar6fb43d72007-07-09 18:52:01 +02002266 if (unlikely(atomic_dec_and_test(&mm->mm_count)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267 __mmdrop(mm);
2268}
2269
2270/* mmput gets rid of the mappings and all user-space */
2271extern void mmput(struct mm_struct *);
2272/* Grab a reference to a task's mm, if it is not already going away */
2273extern struct mm_struct *get_task_mm(struct task_struct *task);
Christopher Yeoh8cdb8782012-02-02 11:34:09 +10302274/*
2275 * Grab a reference to a task's mm, if it is not already going away
2276 * and ptrace_may_access with the mode parameter passed to it
2277 * succeeds.
2278 */
2279extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280/* Remove the current tasks stale references to the old mm_struct */
2281extern void mm_release(struct task_struct *, struct mm_struct *);
Carsten Otte402b0862008-03-25 18:47:10 +01002282/* Allocate a new mm structure and copy contents from tsk->mm */
2283extern struct mm_struct *dup_mm(struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284
Alexey Dobriyan6f2c55b2009-04-02 16:56:59 -07002285extern int copy_thread(unsigned long, unsigned long, unsigned long,
Al Viroafa86fc2012-10-22 22:51:14 -04002286 struct task_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287extern void flush_thread(void);
2288extern void exit_thread(void);
2289
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290extern void exit_files(struct task_struct *);
Oleg Nesterova7e53282006-03-28 16:11:27 -08002291extern void __cleanup_sighand(struct sighand_struct *);
Oleg Nesterovcbaffba2008-05-26 20:55:42 +04002292
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293extern void exit_itimers(struct signal_struct *);
Oleg Nesterovcbaffba2008-05-26 20:55:42 +04002294extern void flush_itimer_signals(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295
Joe Perches9402c952012-01-12 17:17:17 -08002296extern void do_group_exit(int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298extern int allow_signal(int);
2299extern int disallow_signal(int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300
David Howellsd7627462010-08-17 23:52:56 +01002301extern int do_execve(const char *,
2302 const char __user * const __user *,
Al Viroda3d4c52012-10-20 21:49:33 -04002303 const char __user * const __user *);
Al Viroe80d6662012-10-22 23:10:08 -04002304extern long do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *);
Ingo Molnar36c8b582006-07-03 00:25:41 -07002305struct task_struct *fork_idle(int);
Al Viro2aa3a7f2012-09-21 19:55:31 -04002306extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307
2308extern void set_task_comm(struct task_struct *tsk, char *from);
Andrew Morton59714d62008-02-04 22:27:21 -08002309extern char *get_task_comm(char *to, struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310
2311#ifdef CONFIG_SMP
Peter Zijlstra317f3942011-04-05 17:23:58 +02002312void scheduler_ipi(void);
Roland McGrath85ba2d82008-07-25 19:45:58 -07002313extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314#else
Peter Zijlstra184748c2011-04-05 17:23:39 +02002315static inline void scheduler_ipi(void) { }
Roland McGrath85ba2d82008-07-25 19:45:58 -07002316static inline unsigned long wait_task_inactive(struct task_struct *p,
2317 long match_state)
2318{
2319 return 1;
2320}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321#endif
2322
Jiri Pirko05725f72009-04-14 20:17:16 +02002323#define next_task(p) \
2324 list_entry_rcu((p)->tasks.next, struct task_struct, tasks)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325
2326#define for_each_process(p) \
2327 for (p = &init_task ; (p = next_task(p)) != &init_task ; )
2328
Oleg Nesterov5bb459b2009-07-10 03:48:23 +02002329extern bool current_is_single_threaded(void);
David Howellsd84f4f92008-11-14 10:39:23 +11002330
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331/*
2332 * Careful: do_each_thread/while_each_thread is a double loop so
2333 * 'break' will not work as expected - use goto instead.
2334 */
2335#define do_each_thread(g, t) \
2336 for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
2337
2338#define while_each_thread(g, t) \
2339 while ((t = next_thread(t)) != g)
2340
Oleg Nesterov7e498272010-05-26 14:43:22 -07002341static inline int get_nr_threads(struct task_struct *tsk)
2342{
Oleg Nesterovb3ac0222010-05-26 14:43:24 -07002343 return tsk->signal->nr_threads;
Oleg Nesterov7e498272010-05-26 14:43:22 -07002344}
2345
Oleg Nesterov087806b2011-06-22 23:10:26 +02002346static inline bool thread_group_leader(struct task_struct *p)
2347{
2348 return p->exit_signal >= 0;
2349}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002351/* Do to the insanities of de_thread it is possible for a process
2352 * to have the pid of the thread group leader without actually being
2353 * the thread group leader. For iteration through the pids in proc
2354 * all we care about is that we have a task with the appropriate
2355 * pid, we don't actually care if we have the right task.
2356 */
Oleg Nesterove1403b82013-09-11 14:20:06 -07002357static inline bool has_group_leader_pid(struct task_struct *p)
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002358{
Oleg Nesterove1403b82013-09-11 14:20:06 -07002359 return task_pid(p) == p->signal->leader_pid;
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002360}
2361
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -07002362static inline
Oleg Nesterove1403b82013-09-11 14:20:06 -07002363bool same_thread_group(struct task_struct *p1, struct task_struct *p2)
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -07002364{
Oleg Nesterove1403b82013-09-11 14:20:06 -07002365 return p1->signal == p2->signal;
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -07002366}
2367
Ingo Molnar36c8b582006-07-03 00:25:41 -07002368static inline struct task_struct *next_thread(const struct task_struct *p)
Oleg Nesterov47e65322006-03-28 16:11:25 -08002369{
Jiri Pirko05725f72009-04-14 20:17:16 +02002370 return list_entry_rcu(p->thread_group.next,
2371 struct task_struct, thread_group);
Oleg Nesterov47e65322006-03-28 16:11:25 -08002372}
2373
Alexey Dobriyane8681712007-10-26 12:17:22 +04002374static inline int thread_group_empty(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375{
Oleg Nesterov47e65322006-03-28 16:11:25 -08002376 return list_empty(&p->thread_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377}
2378
2379#define delay_group_leader(p) \
2380 (thread_group_leader(p) && !thread_group_empty(p))
2381
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382/*
Eric W. Biederman260ea102006-06-23 02:05:18 -07002383 * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
Jens Axboe22e2c502005-06-27 10:55:12 +02002384 * subscriptions and synchronises with wait4(). Also used in procfs. Also
Paul Menageddbcc7e2007-10-18 23:39:30 -07002385 * pins the final release of task.io_context. Also protects ->cpuset and
Oleg Nesterovd68b46f2012-03-05 14:59:13 -08002386 * ->cgroup.subsys[]. And ->vfork_done.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 *
2388 * Nests both inside and outside of read_lock(&tasklist_lock).
2389 * It must not be nested with write_lock_irq(&tasklist_lock),
2390 * neither inside nor outside.
2391 */
2392static inline void task_lock(struct task_struct *p)
2393{
2394 spin_lock(&p->alloc_lock);
2395}
2396
2397static inline void task_unlock(struct task_struct *p)
2398{
2399 spin_unlock(&p->alloc_lock);
2400}
2401
Namhyung Kimb8ed3742010-10-27 15:34:06 -07002402extern struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
Oleg Nesterovf63ee722006-03-28 16:11:13 -08002403 unsigned long *flags);
2404
Anton Vorontsov9388dc32012-02-09 20:45:19 +04002405static inline struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
2406 unsigned long *flags)
2407{
2408 struct sighand_struct *ret;
2409
2410 ret = __lock_task_sighand(tsk, flags);
2411 (void)__cond_lock(&tsk->sighand->siglock, ret);
2412 return ret;
2413}
Namhyung Kimb8ed3742010-10-27 15:34:06 -07002414
Oleg Nesterovf63ee722006-03-28 16:11:13 -08002415static inline void unlock_task_sighand(struct task_struct *tsk,
2416 unsigned long *flags)
2417{
2418 spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
2419}
2420
Ben Blum4714d1d2011-05-26 16:25:18 -07002421#ifdef CONFIG_CGROUPS
Tejun Heo257058a2011-12-12 18:12:21 -08002422static inline void threadgroup_change_begin(struct task_struct *tsk)
Ben Blum4714d1d2011-05-26 16:25:18 -07002423{
Tejun Heo257058a2011-12-12 18:12:21 -08002424 down_read(&tsk->signal->group_rwsem);
Ben Blum4714d1d2011-05-26 16:25:18 -07002425}
Tejun Heo257058a2011-12-12 18:12:21 -08002426static inline void threadgroup_change_end(struct task_struct *tsk)
Ben Blum4714d1d2011-05-26 16:25:18 -07002427{
Tejun Heo257058a2011-12-12 18:12:21 -08002428 up_read(&tsk->signal->group_rwsem);
Ben Blum4714d1d2011-05-26 16:25:18 -07002429}
Tejun Heo77e4ef92011-12-12 18:12:21 -08002430
2431/**
2432 * threadgroup_lock - lock threadgroup
2433 * @tsk: member task of the threadgroup to lock
2434 *
2435 * Lock the threadgroup @tsk belongs to. No new task is allowed to enter
2436 * and member tasks aren't allowed to exit (as indicated by PF_EXITING) or
Oleg Nesterove56fb282013-04-30 15:28:20 -07002437 * change ->group_leader/pid. This is useful for cases where the threadgroup
2438 * needs to stay stable across blockable operations.
Tejun Heo77e4ef92011-12-12 18:12:21 -08002439 *
2440 * fork and exit paths explicitly call threadgroup_change_{begin|end}() for
2441 * synchronization. While held, no new task will be added to threadgroup
2442 * and no existing live task will have its PF_EXITING set.
2443 *
Oleg Nesterove56fb282013-04-30 15:28:20 -07002444 * de_thread() does threadgroup_change_{begin|end}() when a non-leader
2445 * sub-thread becomes a new leader.
Tejun Heo77e4ef92011-12-12 18:12:21 -08002446 */
Tejun Heo257058a2011-12-12 18:12:21 -08002447static inline void threadgroup_lock(struct task_struct *tsk)
Ben Blum4714d1d2011-05-26 16:25:18 -07002448{
Tejun Heo257058a2011-12-12 18:12:21 -08002449 down_write(&tsk->signal->group_rwsem);
Ben Blum4714d1d2011-05-26 16:25:18 -07002450}
Tejun Heo77e4ef92011-12-12 18:12:21 -08002451
2452/**
2453 * threadgroup_unlock - unlock threadgroup
2454 * @tsk: member task of the threadgroup to unlock
2455 *
2456 * Reverse threadgroup_lock().
2457 */
Tejun Heo257058a2011-12-12 18:12:21 -08002458static inline void threadgroup_unlock(struct task_struct *tsk)
Ben Blum4714d1d2011-05-26 16:25:18 -07002459{
Tejun Heo257058a2011-12-12 18:12:21 -08002460 up_write(&tsk->signal->group_rwsem);
Ben Blum4714d1d2011-05-26 16:25:18 -07002461}
2462#else
Tejun Heo257058a2011-12-12 18:12:21 -08002463static inline void threadgroup_change_begin(struct task_struct *tsk) {}
2464static inline void threadgroup_change_end(struct task_struct *tsk) {}
2465static inline void threadgroup_lock(struct task_struct *tsk) {}
2466static inline void threadgroup_unlock(struct task_struct *tsk) {}
Ben Blum4714d1d2011-05-26 16:25:18 -07002467#endif
2468
Al Virof0373602005-11-13 16:06:57 -08002469#ifndef __HAVE_THREAD_FUNCTIONS
2470
Roman Zippelf7e42172007-05-09 02:35:17 -07002471#define task_thread_info(task) ((struct thread_info *)(task)->stack)
2472#define task_stack_page(task) ((task)->stack)
Al Viroa1261f52005-11-13 16:06:55 -08002473
Al Viro10ebffd2005-11-13 16:06:56 -08002474static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
2475{
2476 *task_thread_info(p) = *task_thread_info(org);
2477 task_thread_info(p)->task = p;
2478}
2479
2480static inline unsigned long *end_of_stack(struct task_struct *p)
2481{
Roman Zippelf7e42172007-05-09 02:35:17 -07002482 return (unsigned long *)(task_thread_info(p) + 1);
Al Viro10ebffd2005-11-13 16:06:56 -08002483}
2484
Al Virof0373602005-11-13 16:06:57 -08002485#endif
2486
FUJITA Tomonori8b05c7e2008-07-23 21:26:53 -07002487static inline int object_is_on_stack(void *obj)
2488{
2489 void *stack = task_stack_page(current);
2490
2491 return (obj >= stack) && (obj < (stack + THREAD_SIZE));
2492}
2493
Benjamin Herrenschmidt8c9843e2008-04-18 16:56:15 +10002494extern void thread_info_cache_init(void);
2495
Eric Sandeen7c9f8862008-04-22 16:38:23 -05002496#ifdef CONFIG_DEBUG_STACK_USAGE
2497static inline unsigned long stack_not_used(struct task_struct *p)
2498{
2499 unsigned long *n = end_of_stack(p);
2500
2501 do { /* Skip over canary */
2502 n++;
2503 } while (!*n);
2504
2505 return (unsigned long)n - (unsigned long)end_of_stack(p);
2506}
2507#endif
2508
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509/* set thread flags in other task's structures
2510 * - see asm/thread_info.h for TIF_xxxx flags available
2511 */
2512static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
2513{
Al Viroa1261f52005-11-13 16:06:55 -08002514 set_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515}
2516
2517static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2518{
Al Viroa1261f52005-11-13 16:06:55 -08002519 clear_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520}
2521
2522static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
2523{
Al Viroa1261f52005-11-13 16:06:55 -08002524 return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525}
2526
2527static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2528{
Al Viroa1261f52005-11-13 16:06:55 -08002529 return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002530}
2531
2532static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
2533{
Al Viroa1261f52005-11-13 16:06:55 -08002534 return test_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535}
2536
2537static inline void set_tsk_need_resched(struct task_struct *tsk)
2538{
2539 set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2540}
2541
2542static inline void clear_tsk_need_resched(struct task_struct *tsk)
2543{
2544 clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2545}
2546
Gregory Haskins8ae121a2008-04-23 07:13:29 -04002547static inline int test_tsk_need_resched(struct task_struct *tsk)
2548{
2549 return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
2550}
2551
Eric W. Biederman690cc3f2009-05-13 16:55:10 +00002552static inline int restart_syscall(void)
2553{
2554 set_tsk_thread_flag(current, TIF_SIGPENDING);
2555 return -ERESTARTNOINTR;
2556}
2557
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558static inline int signal_pending(struct task_struct *p)
2559{
2560 return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
2561}
Matthew Wilcoxf776d122007-12-06 11:15:50 -05002562
Roland McGrathd9588722009-09-23 15:57:04 -07002563static inline int __fatal_signal_pending(struct task_struct *p)
2564{
2565 return unlikely(sigismember(&p->pending.signal, SIGKILL));
2566}
Matthew Wilcoxf776d122007-12-06 11:15:50 -05002567
2568static inline int fatal_signal_pending(struct task_struct *p)
2569{
2570 return signal_pending(p) && __fatal_signal_pending(p);
2571}
2572
Oleg Nesterov16882c12008-06-08 21:20:41 +04002573static inline int signal_pending_state(long state, struct task_struct *p)
2574{
2575 if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
2576 return 0;
2577 if (!signal_pending(p))
2578 return 0;
2579
Oleg Nesterov16882c12008-06-08 21:20:41 +04002580 return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
2581}
2582
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583/*
2584 * cond_resched() and cond_resched_lock(): latency reduction via
2585 * explicit rescheduling in places that are safe. The return
2586 * value indicates whether a reschedule was done in fact.
2587 * cond_resched_lock() will drop the spinlock before scheduling,
2588 * cond_resched_softirq() will enable bhs before scheduling.
2589 */
Linus Torvaldsc3921ab2008-05-11 16:04:48 -07002590extern int _cond_resched(void);
Frederic Weisbecker6f80bd92009-07-16 15:44:29 +02002591
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002592#define cond_resched() ({ \
2593 __might_sleep(__FILE__, __LINE__, 0); \
2594 _cond_resched(); \
2595})
Frederic Weisbecker6f80bd92009-07-16 15:44:29 +02002596
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002597extern int __cond_resched_lock(spinlock_t *lock);
2598
Frederic Weisbeckerbdd4e852011-06-08 01:13:27 +02002599#ifdef CONFIG_PREEMPT_COUNT
Frederic Weisbecker716a4232009-07-24 20:05:23 +02002600#define PREEMPT_LOCK_OFFSET PREEMPT_OFFSET
Herbert Xu02b67cc32008-01-25 21:08:28 +01002601#else
Frederic Weisbecker716a4232009-07-24 20:05:23 +02002602#define PREEMPT_LOCK_OFFSET 0
Herbert Xu02b67cc32008-01-25 21:08:28 +01002603#endif
Frederic Weisbecker716a4232009-07-24 20:05:23 +02002604
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002605#define cond_resched_lock(lock) ({ \
Frederic Weisbecker716a4232009-07-24 20:05:23 +02002606 __might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET); \
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002607 __cond_resched_lock(lock); \
2608})
2609
2610extern int __cond_resched_softirq(void);
2611
Venkatesh Pallipadi75e10562010-10-04 17:03:16 -07002612#define cond_resched_softirq() ({ \
2613 __might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET); \
2614 __cond_resched_softirq(); \
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002615})
Linus Torvalds1da177e2005-04-16 15:20:36 -07002616
Simon Hormanf6f3c432013-05-22 14:50:31 +09002617static inline void cond_resched_rcu(void)
2618{
2619#if defined(CONFIG_DEBUG_ATOMIC_SLEEP) || !defined(CONFIG_PREEMPT_RCU)
2620 rcu_read_unlock();
2621 cond_resched();
2622 rcu_read_lock();
2623#endif
2624}
2625
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626/*
2627 * Does a critical section need to be broken due to another
Nick Piggin95c354f2008-01-30 13:31:20 +01002628 * task waiting?: (technically does not depend on CONFIG_PREEMPT,
2629 * but a general need for low latency)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630 */
Nick Piggin95c354f2008-01-30 13:31:20 +01002631static inline int spin_needbreak(spinlock_t *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632{
Nick Piggin95c354f2008-01-30 13:31:20 +01002633#ifdef CONFIG_PREEMPT
2634 return spin_is_contended(lock);
2635#else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636 return 0;
Nick Piggin95c354f2008-01-30 13:31:20 +01002637#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638}
2639
Roland McGrath7bb44ad2007-05-23 13:57:44 -07002640/*
Thomas Gleixneree761f62013-03-21 22:49:32 +01002641 * Idle thread specific functions to determine the need_resched
2642 * polling state. We have two versions, one based on TS_POLLING in
2643 * thread_info.status and one based on TIF_POLLING_NRFLAG in
2644 * thread_info.flags
2645 */
2646#ifdef TS_POLLING
2647static inline int tsk_is_polling(struct task_struct *p)
2648{
2649 return task_thread_info(p)->status & TS_POLLING;
2650}
Peter Zijlstraea811742013-09-11 12:43:13 +02002651static inline void __current_set_polling(void)
Thomas Gleixner3a98f872013-03-21 22:49:33 +01002652{
2653 current_thread_info()->status |= TS_POLLING;
2654}
2655
Peter Zijlstraea811742013-09-11 12:43:13 +02002656static inline bool __must_check current_set_polling_and_test(void)
2657{
2658 __current_set_polling();
2659
2660 /*
2661 * Polling state must be visible before we test NEED_RESCHED,
2662 * paired by resched_task()
2663 */
2664 smp_mb();
2665
2666 return unlikely(tif_need_resched());
2667}
2668
2669static inline void __current_clr_polling(void)
Thomas Gleixner3a98f872013-03-21 22:49:33 +01002670{
2671 current_thread_info()->status &= ~TS_POLLING;
Peter Zijlstraea811742013-09-11 12:43:13 +02002672}
2673
2674static inline bool __must_check current_clr_polling_and_test(void)
2675{
2676 __current_clr_polling();
2677
2678 /*
2679 * Polling state must be visible before we test NEED_RESCHED,
2680 * paired by resched_task()
2681 */
2682 smp_mb();
2683
2684 return unlikely(tif_need_resched());
Thomas Gleixner3a98f872013-03-21 22:49:33 +01002685}
Thomas Gleixneree761f62013-03-21 22:49:32 +01002686#elif defined(TIF_POLLING_NRFLAG)
2687static inline int tsk_is_polling(struct task_struct *p)
2688{
2689 return test_tsk_thread_flag(p, TIF_POLLING_NRFLAG);
2690}
Peter Zijlstraea811742013-09-11 12:43:13 +02002691
2692static inline void __current_set_polling(void)
Thomas Gleixner3a98f872013-03-21 22:49:33 +01002693{
2694 set_thread_flag(TIF_POLLING_NRFLAG);
2695}
2696
Peter Zijlstraea811742013-09-11 12:43:13 +02002697static inline bool __must_check current_set_polling_and_test(void)
2698{
2699 __current_set_polling();
2700
2701 /*
2702 * Polling state must be visible before we test NEED_RESCHED,
2703 * paired by resched_task()
2704 *
2705 * XXX: assumes set/clear bit are identical barrier wise.
2706 */
2707 smp_mb__after_clear_bit();
2708
2709 return unlikely(tif_need_resched());
2710}
2711
2712static inline void __current_clr_polling(void)
Thomas Gleixner3a98f872013-03-21 22:49:33 +01002713{
2714 clear_thread_flag(TIF_POLLING_NRFLAG);
2715}
Peter Zijlstraea811742013-09-11 12:43:13 +02002716
2717static inline bool __must_check current_clr_polling_and_test(void)
2718{
2719 __current_clr_polling();
2720
2721 /*
2722 * Polling state must be visible before we test NEED_RESCHED,
2723 * paired by resched_task()
2724 */
2725 smp_mb__after_clear_bit();
2726
2727 return unlikely(tif_need_resched());
2728}
2729
Thomas Gleixneree761f62013-03-21 22:49:32 +01002730#else
2731static inline int tsk_is_polling(struct task_struct *p) { return 0; }
Peter Zijlstraea811742013-09-11 12:43:13 +02002732static inline void __current_set_polling(void) { }
2733static inline void __current_clr_polling(void) { }
2734
2735static inline bool __must_check current_set_polling_and_test(void)
2736{
2737 return unlikely(tif_need_resched());
2738}
2739static inline bool __must_check current_clr_polling_and_test(void)
2740{
2741 return unlikely(tif_need_resched());
2742}
Thomas Gleixneree761f62013-03-21 22:49:32 +01002743#endif
2744
Peter Zijlstra75f93fe2013-09-27 17:30:03 +02002745static __always_inline bool need_resched(void)
2746{
2747 return unlikely(tif_need_resched());
2748}
2749
Thomas Gleixneree761f62013-03-21 22:49:32 +01002750/*
Frank Mayharf06febc2008-09-12 09:54:39 -07002751 * Thread group CPU time accounting.
2752 */
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +01002753void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
Peter Zijlstra4da94d492009-02-11 11:30:27 +01002754void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
Frank Mayharf06febc2008-09-12 09:54:39 -07002755
2756static inline void thread_group_cputime_init(struct signal_struct *sig)
2757{
Thomas Gleixneree30a7b2009-07-25 18:56:56 +02002758 raw_spin_lock_init(&sig->cputimer.lock);
Frank Mayharf06febc2008-09-12 09:54:39 -07002759}
2760
Frank Mayharf06febc2008-09-12 09:54:39 -07002761/*
Roland McGrath7bb44ad2007-05-23 13:57:44 -07002762 * Reevaluate whether the task has signals pending delivery.
2763 * Wake the task if so.
2764 * This is required every time the blocked sigset_t changes.
2765 * callers must hold sighand->siglock.
2766 */
2767extern void recalc_sigpending_and_wake(struct task_struct *t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768extern void recalc_sigpending(void);
2769
Oleg Nesterov910ffdb2013-01-21 20:47:41 +01002770extern void signal_wake_up_state(struct task_struct *t, unsigned int state);
2771
2772static inline void signal_wake_up(struct task_struct *t, bool resume)
2773{
2774 signal_wake_up_state(t, resume ? TASK_WAKEKILL : 0);
2775}
2776static inline void ptrace_signal_wake_up(struct task_struct *t, bool resume)
2777{
2778 signal_wake_up_state(t, resume ? __TASK_TRACED : 0);
2779}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780
2781/*
2782 * Wrappers for p->thread_info->cpu access. No-op on UP.
2783 */
2784#ifdef CONFIG_SMP
2785
2786static inline unsigned int task_cpu(const struct task_struct *p)
2787{
Al Viroa1261f52005-11-13 16:06:55 -08002788 return task_thread_info(p)->cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789}
2790
Ingo Molnarb32e86b2013-10-07 11:29:30 +01002791static inline int task_node(const struct task_struct *p)
2792{
2793 return cpu_to_node(task_cpu(p));
2794}
2795
Ingo Molnarc65cc872007-07-09 18:51:58 +02002796extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797
2798#else
2799
2800static inline unsigned int task_cpu(const struct task_struct *p)
2801{
2802 return 0;
2803}
2804
2805static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
2806{
2807}
2808
2809#endif /* CONFIG_SMP */
2810
Rusty Russell96f874e2008-11-25 02:35:14 +10302811extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
2812extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
Siddha, Suresh B5c45bf22006-06-27 02:54:42 -07002813
Dhaval Giani7c941432010-01-20 13:26:18 +01002814#ifdef CONFIG_CGROUP_SCHED
Yong Zhang07e06b02011-01-07 15:17:36 +08002815extern struct task_group root_task_group;
Peter Zijlstra8323f262012-06-22 13:36:05 +02002816#endif /* CONFIG_CGROUP_SCHED */
Srivatsa Vaddagiri9b5b7752007-10-15 17:00:09 +02002817
Dhaval Giani54e99122009-02-27 15:13:54 +05302818extern int task_can_switch_user(struct user_struct *up,
2819 struct task_struct *tsk);
2820
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002821#ifdef CONFIG_TASK_XACCT
2822static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2823{
Andrea Righi940389b2008-07-28 00:48:12 +02002824 tsk->ioac.rchar += amt;
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002825}
2826
2827static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2828{
Andrea Righi940389b2008-07-28 00:48:12 +02002829 tsk->ioac.wchar += amt;
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002830}
2831
2832static inline void inc_syscr(struct task_struct *tsk)
2833{
Andrea Righi940389b2008-07-28 00:48:12 +02002834 tsk->ioac.syscr++;
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002835}
2836
2837static inline void inc_syscw(struct task_struct *tsk)
2838{
Andrea Righi940389b2008-07-28 00:48:12 +02002839 tsk->ioac.syscw++;
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002840}
2841#else
2842static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2843{
2844}
2845
2846static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2847{
2848}
2849
2850static inline void inc_syscr(struct task_struct *tsk)
2851{
2852}
2853
2854static inline void inc_syscw(struct task_struct *tsk)
2855{
2856}
2857#endif
2858
Dave Hansen82455252008-02-04 22:28:59 -08002859#ifndef TASK_SIZE_OF
2860#define TASK_SIZE_OF(tsk) TASK_SIZE
2861#endif
2862
Balbir Singhcf475ad2008-04-29 01:00:16 -07002863#ifdef CONFIG_MM_OWNER
2864extern void mm_update_next_owner(struct mm_struct *mm);
2865extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
2866#else
2867static inline void mm_update_next_owner(struct mm_struct *mm)
2868{
2869}
2870
2871static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
2872{
2873}
2874#endif /* CONFIG_MM_OWNER */
2875
Jiri Slaby3e10e712009-11-19 17:16:37 +01002876static inline unsigned long task_rlimit(const struct task_struct *tsk,
2877 unsigned int limit)
2878{
2879 return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_cur);
2880}
2881
2882static inline unsigned long task_rlimit_max(const struct task_struct *tsk,
2883 unsigned int limit)
2884{
2885 return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_max);
2886}
2887
2888static inline unsigned long rlimit(unsigned int limit)
2889{
2890 return task_rlimit(current, limit);
2891}
2892
2893static inline unsigned long rlimit_max(unsigned int limit)
2894{
2895 return task_rlimit_max(current, limit);
2896}
2897
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898#endif