Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux...
[deliverable/linux.git] / include / linux / sched.h
CommitLineData
1da177e4
LT
1#ifndef _LINUX_SCHED_H
2#define _LINUX_SCHED_H
3
607ca46e 4#include <uapi/linux/sched.h>
b7b3c76a 5
b7b3c76a
DW
6
7struct sched_param {
8 int sched_priority;
9};
10
1da177e4
LT
11#include <asm/param.h> /* for HZ */
12
1da177e4
LT
13#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>
19#include <linux/rbtree.h>
20#include <linux/thread_info.h>
21#include <linux/cpumask.h>
22#include <linux/errno.h>
23#include <linux/nodemask.h>
c92ff1bd 24#include <linux/mm_types.h>
1da177e4 25
1da177e4
LT
26#include <asm/page.h>
27#include <asm/ptrace.h>
1da177e4
LT
28#include <asm/cputime.h>
29
30#include <linux/smp.h>
31#include <linux/sem.h>
32#include <linux/signal.h>
1da177e4
LT
33#include <linux/compiler.h>
34#include <linux/completion.h>
35#include <linux/pid.h>
36#include <linux/percpu.h>
37#include <linux/topology.h>
3e26c149 38#include <linux/proportions.h>
1da177e4 39#include <linux/seccomp.h>
e56d0903 40#include <linux/rcupdate.h>
05725f7e 41#include <linux/rculist.h>
23f78d4a 42#include <linux/rtmutex.h>
1da177e4 43
a3b6714e
DW
44#include <linux/time.h>
45#include <linux/param.h>
46#include <linux/resource.h>
47#include <linux/timer.h>
48#include <linux/hrtimer.h>
7c3ab738 49#include <linux/task_io_accounting.h>
9745512c 50#include <linux/latencytop.h>
9e2b2dc4 51#include <linux/cred.h>
fa14ff4a 52#include <linux/llist.h>
7b44ab97 53#include <linux/uidgid.h>
21caf2fc 54#include <linux/gfp.h>
a3b6714e
DW
55
56#include <asm/processor.h>
36d57ac4 57
1da177e4 58struct exec_domain;
c87e2837 59struct futex_pi_state;
286100a6 60struct robust_list_head;
bddd87c7 61struct bio_list;
5ad4e53b 62struct fs_struct;
cdd6c482 63struct perf_event_context;
73c10101 64struct blk_plug;
1da177e4 65
1da177e4
LT
66/*
67 * List of flags we want to share for kernel threads,
68 * if only because they are not used by them anyway.
69 */
70#define CLONE_KERNEL (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
71
72/*
73 * These are the constant used to fake the fixed-point load-average
74 * counting. Some notes:
75 * - 11 bit fractions expand to 22 bits by the multiplies: this gives
76 * a load-average precision of 10 bits integer + 11 bits fractional
77 * - if you want to count load-averages more often, you need more
78 * precision, or rounding will get you. With 2-second counting freq,
79 * the EXP_n values would be 1981, 2034 and 2043 if still using only
80 * 11 bit fractions.
81 */
82extern unsigned long avenrun[]; /* Load averages */
2d02494f 83extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
1da177e4
LT
84
85#define FSHIFT 11 /* nr of bits of precision */
86#define FIXED_1 (1<<FSHIFT) /* 1.0 as fixed-point */
0c2043ab 87#define LOAD_FREQ (5*HZ+1) /* 5 sec intervals */
1da177e4
LT
88#define EXP_1 1884 /* 1/exp(5sec/1min) as fixed-point */
89#define EXP_5 2014 /* 1/exp(5sec/5min) */
90#define EXP_15 2037 /* 1/exp(5sec/15min) */
91
92#define CALC_LOAD(load,exp,n) \
93 load *= exp; \
94 load += n*(FIXED_1-exp); \
95 load >>= FSHIFT;
96
97extern unsigned long total_forks;
98extern int nr_threads;
1da177e4
LT
99DECLARE_PER_CPU(unsigned long, process_counts);
100extern int nr_processes(void);
101extern unsigned long nr_running(void);
1da177e4 102extern unsigned long nr_iowait(void);
8c215bd3 103extern unsigned long nr_iowait_cpu(int cpu);
69d25870
AV
104extern unsigned long this_cpu_load(void);
105
106
0f004f5a 107extern void calc_global_load(unsigned long ticks);
5aaa0b7a 108extern void update_cpu_load_nohz(void);
1da177e4 109
582b336e
MT
110/* Notifier for when a task gets migrated to a new CPU */
111struct task_migration_notifier {
112 struct task_struct *task;
113 int from_cpu;
114 int to_cpu;
115};
116extern void register_task_migration_notifier(struct notifier_block *n);
117
7e49fcce
SR
118extern unsigned long get_parent_ip(unsigned long addr);
119
b637a328
PM
120extern void dump_cpu_task(int cpu);
121
43ae34cb
IM
122struct seq_file;
123struct cfs_rq;
4cf86d77 124struct task_group;
43ae34cb
IM
125#ifdef CONFIG_SCHED_DEBUG
126extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
127extern void proc_sched_set_task(struct task_struct *p);
128extern void
5cef9eca 129print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
43ae34cb 130#endif
1da177e4 131
4a8342d2
LT
132/*
133 * Task state bitmask. NOTE! These bits are also
134 * encoded in fs/proc/array.c: get_task_state().
135 *
136 * We have two separate sets of flags: task->state
137 * is about runnability, while task->exit_state are
138 * about the task exiting. Confusing, but this way
139 * modifying one set can't modify the other one by
140 * mistake.
141 */
1da177e4
LT
142#define TASK_RUNNING 0
143#define TASK_INTERRUPTIBLE 1
144#define TASK_UNINTERRUPTIBLE 2
f021a3c2
MW
145#define __TASK_STOPPED 4
146#define __TASK_TRACED 8
4a8342d2
LT
147/* in tsk->exit_state */
148#define EXIT_ZOMBIE 16
149#define EXIT_DEAD 32
150/* in tsk->state again */
af927232 151#define TASK_DEAD 64
f021a3c2 152#define TASK_WAKEKILL 128
e9c84311 153#define TASK_WAKING 256
f2530dc7
TG
154#define TASK_PARKED 512
155#define TASK_STATE_MAX 1024
f021a3c2 156
f2530dc7 157#define TASK_STATE_TO_CHAR_STR "RSDTtZXxKWP"
73342151 158
e1781538
PZ
159extern char ___assert_task_state[1 - 2*!!(
160 sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1)];
f021a3c2
MW
161
162/* Convenience macros for the sake of set_task_state */
163#define TASK_KILLABLE (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
164#define TASK_STOPPED (TASK_WAKEKILL | __TASK_STOPPED)
165#define TASK_TRACED (TASK_WAKEKILL | __TASK_TRACED)
1da177e4 166
92a1f4bc
MW
167/* Convenience macros for the sake of wake_up */
168#define TASK_NORMAL (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
f021a3c2 169#define TASK_ALL (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
92a1f4bc
MW
170
171/* get_task_state() */
172#define TASK_REPORT (TASK_RUNNING | TASK_INTERRUPTIBLE | \
f021a3c2
MW
173 TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
174 __TASK_TRACED)
92a1f4bc 175
f021a3c2
MW
176#define task_is_traced(task) ((task->state & __TASK_TRACED) != 0)
177#define task_is_stopped(task) ((task->state & __TASK_STOPPED) != 0)
8f92054e 178#define task_is_dead(task) ((task)->exit_state != 0)
92a1f4bc 179#define task_is_stopped_or_traced(task) \
f021a3c2 180 ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
92a1f4bc 181#define task_contributes_to_load(task) \
e3c8ca83 182 ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
376fede8 183 (task->flags & PF_FROZEN) == 0)
1da177e4
LT
184
185#define __set_task_state(tsk, state_value) \
186 do { (tsk)->state = (state_value); } while (0)
187#define set_task_state(tsk, state_value) \
188 set_mb((tsk)->state, (state_value))
189
498d0c57
AM
190/*
191 * set_current_state() includes a barrier so that the write of current->state
192 * is correctly serialised wrt the caller's subsequent test of whether to
193 * actually sleep:
194 *
195 * set_current_state(TASK_UNINTERRUPTIBLE);
196 * if (do_i_need_to_sleep())
197 * schedule();
198 *
199 * If the caller does not need such serialisation then use __set_current_state()
200 */
1da177e4
LT
201#define __set_current_state(state_value) \
202 do { current->state = (state_value); } while (0)
203#define set_current_state(state_value) \
204 set_mb(current->state, (state_value))
205
206/* Task command name length */
207#define TASK_COMM_LEN 16
208
1da177e4
LT
209#include <linux/spinlock.h>
210
211/*
212 * This serializes "schedule()" and also protects
213 * the run-queue from deletions/modifications (but
214 * _adding_ to the beginning of the run-queue has
215 * a separate lock).
216 */
217extern rwlock_t tasklist_lock;
218extern spinlock_t mmlist_lock;
219
36c8b586 220struct task_struct;
1da177e4 221
db1466b3
PM
222#ifdef CONFIG_PROVE_RCU
223extern int lockdep_tasklist_lock_is_held(void);
224#endif /* #ifdef CONFIG_PROVE_RCU */
225
1da177e4
LT
226extern void sched_init(void);
227extern void sched_init_smp(void);
2d07b255 228extern asmlinkage void schedule_tail(struct task_struct *prev);
36c8b586 229extern void init_idle(struct task_struct *idle, int cpu);
1df21055 230extern void init_idle_bootup_task(struct task_struct *idle);
1da177e4 231
89f19f04 232extern int runqueue_is_locked(int cpu);
017730c1 233
3451d024 234#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
c1cc017c 235extern void nohz_balance_enter_idle(int cpu);
69e1e811 236extern void set_cpu_sd_state_idle(void);
83cd4fe2 237extern int get_nohz_timer_target(void);
46cb4b7c 238#else
c1cc017c 239static inline void nohz_balance_enter_idle(int cpu) { }
fdaabd80 240static inline void set_cpu_sd_state_idle(void) { }
46cb4b7c 241#endif
1da177e4 242
e59e2ae2 243/*
39bc89fd 244 * Only dump TASK_* tasks. (0 for all tasks)
e59e2ae2
IM
245 */
246extern void show_state_filter(unsigned long state_filter);
247
248static inline void show_state(void)
249{
39bc89fd 250 show_state_filter(0);
e59e2ae2
IM
251}
252
1da177e4
LT
253extern void show_regs(struct pt_regs *);
254
255/*
256 * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
257 * task), SP is the stack pointer of the first frame that should be shown in the back
258 * trace (or NULL if the entire call-chain of the task should be shown).
259 */
260extern void show_stack(struct task_struct *task, unsigned long *sp);
261
262void io_schedule(void);
263long io_schedule_timeout(long timeout);
264
265extern void cpu_init (void);
266extern void trap_init(void);
267extern void update_process_times(int user);
268extern void scheduler_tick(void);
269
82a1fcb9
IM
270extern void sched_show_task(struct task_struct *p);
271
19cc36c0 272#ifdef CONFIG_LOCKUP_DETECTOR
8446f1d3 273extern void touch_softlockup_watchdog(void);
d6ad3e28 274extern void touch_softlockup_watchdog_sync(void);
04c9167f 275extern void touch_all_softlockup_watchdogs(void);
332fbdbc
DZ
276extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
277 void __user *buffer,
278 size_t *lenp, loff_t *ppos);
9c44bc03 279extern unsigned int softlockup_panic;
004417a6 280void lockup_detector_init(void);
8446f1d3 281#else
8446f1d3
IM
282static inline void touch_softlockup_watchdog(void)
283{
284}
d6ad3e28
JW
285static inline void touch_softlockup_watchdog_sync(void)
286{
287}
04c9167f
JF
288static inline void touch_all_softlockup_watchdogs(void)
289{
290}
004417a6
PZ
291static inline void lockup_detector_init(void)
292{
293}
8446f1d3
IM
294#endif
295
1da177e4
LT
296/* Attach to any functions which should be ignored in wchan output. */
297#define __sched __attribute__((__section__(".sched.text")))
deaf2227
IM
298
299/* Linker adds these: start and end of __sched functions */
300extern char __sched_text_start[], __sched_text_end[];
301
1da177e4
LT
302/* Is this address in the __sched functions? */
303extern int in_sched_functions(unsigned long addr);
304
305#define MAX_SCHEDULE_TIMEOUT LONG_MAX
b3c97528 306extern signed long schedule_timeout(signed long timeout);
64ed93a2 307extern signed long schedule_timeout_interruptible(signed long timeout);
294d5cc2 308extern signed long schedule_timeout_killable(signed long timeout);
64ed93a2 309extern signed long schedule_timeout_uninterruptible(signed long timeout);
1da177e4 310asmlinkage void schedule(void);
c5491ea7 311extern void schedule_preempt_disabled(void);
1da177e4 312
ab516013 313struct nsproxy;
acce292c 314struct user_namespace;
1da177e4 315
efc1a3b1
DH
316#ifdef CONFIG_MMU
317extern void arch_pick_mmap_layout(struct mm_struct *mm);
1da177e4
LT
318extern unsigned long
319arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
320 unsigned long, unsigned long);
321extern unsigned long
322arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
323 unsigned long len, unsigned long pgoff,
324 unsigned long flags);
1363c3cd
WW
325extern void arch_unmap_area(struct mm_struct *, unsigned long);
326extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
efc1a3b1
DH
327#else
328static inline void arch_pick_mmap_layout(struct mm_struct *mm) {}
329#endif
1da177e4 330
901608d9 331
6c5d5238
KH
332extern void set_dumpable(struct mm_struct *mm, int value);
333extern int get_dumpable(struct mm_struct *mm);
334
335/* mm flags */
3cb4a0bb 336/* dumpable bits */
6c5d5238
KH
337#define MMF_DUMPABLE 0 /* core dump is permitted */
338#define MMF_DUMP_SECURELY 1 /* core file is readable only by root */
f8af4da3 339
3cb4a0bb 340#define MMF_DUMPABLE_BITS 2
f8af4da3 341#define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1)
3cb4a0bb
KH
342
343/* coredump filter bits */
344#define MMF_DUMP_ANON_PRIVATE 2
345#define MMF_DUMP_ANON_SHARED 3
346#define MMF_DUMP_MAPPED_PRIVATE 4
347#define MMF_DUMP_MAPPED_SHARED 5
82df3973 348#define MMF_DUMP_ELF_HEADERS 6
e575f111
KM
349#define MMF_DUMP_HUGETLB_PRIVATE 7
350#define MMF_DUMP_HUGETLB_SHARED 8
f8af4da3 351
3cb4a0bb 352#define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS
e575f111 353#define MMF_DUMP_FILTER_BITS 7
3cb4a0bb
KH
354#define MMF_DUMP_FILTER_MASK \
355 (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
356#define MMF_DUMP_FILTER_DEFAULT \
e575f111 357 ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\
656eb2cd
RM
358 (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)
359
360#ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS
361# define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS)
362#else
363# define MMF_DUMP_MASK_DEFAULT_ELF 0
364#endif
f8af4da3
HD
365 /* leave room for more dump flags */
366#define MMF_VM_MERGEABLE 16 /* KSM may merge identical pages */
ba76149f 367#define MMF_VM_HUGEPAGE 17 /* set when VM_HUGEPAGE is set on vma */
bafb282d 368#define MMF_EXE_FILE_CHANGED 18 /* see prctl_set_mm_exe_file() */
f8af4da3 369
9f68f672
ON
370#define MMF_HAS_UPROBES 19 /* has uprobes */
371#define MMF_RECALC_UPROBES 20 /* MMF_HAS_UPROBES can be wrong */
f8ac4ec9 372
f8af4da3 373#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK)
6c5d5238 374
1da177e4
LT
375struct sighand_struct {
376 atomic_t count;
377 struct k_sigaction action[_NSIG];
378 spinlock_t siglock;
b8fceee1 379 wait_queue_head_t signalfd_wqh;
1da177e4
LT
380};
381
0e464814 382struct pacct_struct {
f6ec29a4
KK
383 int ac_flag;
384 long ac_exitcode;
0e464814 385 unsigned long ac_mem;
77787bfb
KK
386 cputime_t ac_utime, ac_stime;
387 unsigned long ac_minflt, ac_majflt;
0e464814
KK
388};
389
42c4ab41
SG
390struct cpu_itimer {
391 cputime_t expires;
392 cputime_t incr;
8356b5f9
SG
393 u32 error;
394 u32 incr_error;
42c4ab41
SG
395};
396
d37f761d
FW
397/**
398 * struct cputime - snaphsot of system and user cputime
399 * @utime: time spent in user mode
400 * @stime: time spent in system mode
401 *
402 * Gathers a generic snapshot of user and system time.
403 */
404struct cputime {
405 cputime_t utime;
406 cputime_t stime;
407};
408
f06febc9
FM
409/**
410 * struct task_cputime - collected CPU time counts
411 * @utime: time spent in user mode, in &cputime_t units
412 * @stime: time spent in kernel mode, in &cputime_t units
413 * @sum_exec_runtime: total time spent on the CPU, in nanoseconds
5ce73a4a 414 *
d37f761d
FW
415 * This is an extension of struct cputime that includes the total runtime
416 * spent by the task from the scheduler point of view.
417 *
418 * As a result, this structure groups together three kinds of CPU time
419 * that are tracked for threads and thread groups. Most things considering
f06febc9
FM
420 * CPU time want to group these counts together and treat all three
421 * of them in parallel.
422 */
423struct task_cputime {
424 cputime_t utime;
425 cputime_t stime;
426 unsigned long long sum_exec_runtime;
427};
428/* Alternate field names when used to cache expirations. */
429#define prof_exp stime
430#define virt_exp utime
431#define sched_exp sum_exec_runtime
432
4cd4c1b4
PZ
433#define INIT_CPUTIME \
434 (struct task_cputime) { \
64861634
MS
435 .utime = 0, \
436 .stime = 0, \
4cd4c1b4
PZ
437 .sum_exec_runtime = 0, \
438 }
439
c99e6efe
PZ
440/*
441 * Disable preemption until the scheduler is running.
442 * Reset by start_kernel()->sched_init()->init_idle().
d86ee480
PZ
443 *
444 * We include PREEMPT_ACTIVE to avoid cond_resched() from working
445 * before the scheduler is active -- see should_resched().
c99e6efe 446 */
d86ee480 447#define INIT_PREEMPT_COUNT (1 + PREEMPT_ACTIVE)
c99e6efe 448
f06febc9 449/**
4cd4c1b4
PZ
450 * struct thread_group_cputimer - thread group interval timer counts
451 * @cputime: thread group interval timers.
452 * @running: non-zero when there are timers running and
453 * @cputime receives updates.
454 * @lock: lock for fields in this struct.
f06febc9
FM
455 *
456 * This structure contains the version of task_cputime, above, that is
4cd4c1b4 457 * used for thread group CPU timer calculations.
f06febc9 458 */
4cd4c1b4
PZ
459struct thread_group_cputimer {
460 struct task_cputime cputime;
461 int running;
ee30a7b2 462 raw_spinlock_t lock;
f06febc9 463};
f06febc9 464
4714d1d3 465#include <linux/rwsem.h>
5091faa4
MG
466struct autogroup;
467
1da177e4 468/*
e815f0a8 469 * NOTE! "signal_struct" does not have its own
1da177e4
LT
470 * locking, because a shared signal_struct always
471 * implies a shared sighand_struct, so locking
472 * sighand_struct is always a proper superset of
473 * the locking of signal_struct.
474 */
475struct signal_struct {
ea6d290c 476 atomic_t sigcnt;
1da177e4 477 atomic_t live;
b3ac022c 478 int nr_threads;
1da177e4
LT
479
480 wait_queue_head_t wait_chldexit; /* for wait4() */
481
482 /* current thread group signal load-balancing target: */
36c8b586 483 struct task_struct *curr_target;
1da177e4
LT
484
485 /* shared signal handling: */
486 struct sigpending shared_pending;
487
488 /* thread group exit support */
489 int group_exit_code;
490 /* overloaded:
491 * - notify group_exit_task when ->count is equal to notify_count
492 * - everyone except group_exit_task is stopped during signal delivery
493 * of fatal signals, group_exit_task processes the signal.
494 */
1da177e4 495 int notify_count;
07dd20e0 496 struct task_struct *group_exit_task;
1da177e4
LT
497
498 /* thread group stop support, overloads group_exit_code too */
499 int group_stop_count;
500 unsigned int flags; /* see SIGNAL_* flags below */
501
ebec18a6
LP
502 /*
503 * PR_SET_CHILD_SUBREAPER marks a process, like a service
504 * manager, to re-parent orphan (double-forking) child processes
505 * to this process instead of 'init'. The service manager is
506 * able to receive SIGCHLD signals and is able to investigate
507 * the process until it calls wait(). All children of this
508 * process will inherit a flag if they should look for a
509 * child_subreaper process at exit.
510 */
511 unsigned int is_child_subreaper:1;
512 unsigned int has_child_subreaper:1;
513
1da177e4 514 /* POSIX.1b Interval Timers */
5ed67f05
PE
515 int posix_timer_id;
516 struct list_head posix_timers;
1da177e4
LT
517
518 /* ITIMER_REAL timer for the process */
2ff678b8 519 struct hrtimer real_timer;
fea9d175 520 struct pid *leader_pid;
2ff678b8 521 ktime_t it_real_incr;
1da177e4 522
42c4ab41
SG
523 /*
524 * ITIMER_PROF and ITIMER_VIRTUAL timers for the process, we use
525 * CPUCLOCK_PROF and CPUCLOCK_VIRT for indexing array as these
526 * values are defined to 0 and 1 respectively
527 */
528 struct cpu_itimer it[2];
1da177e4 529
f06febc9 530 /*
4cd4c1b4
PZ
531 * Thread group totals for process CPU timers.
532 * See thread_group_cputimer(), et al, for details.
f06febc9 533 */
4cd4c1b4 534 struct thread_group_cputimer cputimer;
f06febc9
FM
535
536 /* Earliest-expiration cache. */
537 struct task_cputime cputime_expires;
538
539 struct list_head cpu_timers[3];
540
ab521dc0 541 struct pid *tty_old_pgrp;
1ec320af 542
1da177e4
LT
543 /* boolean value for session group leader */
544 int leader;
545
546 struct tty_struct *tty; /* NULL if no tty */
547
5091faa4
MG
548#ifdef CONFIG_SCHED_AUTOGROUP
549 struct autogroup *autogroup;
550#endif
1da177e4
LT
551 /*
552 * Cumulative resource counters for dead threads in the group,
553 * and for reaped dead child processes forked by this group.
554 * Live threads maintain their own counters and add to these
555 * in __exit_signal, except for the group leader.
556 */
32bd671d 557 cputime_t utime, stime, cutime, cstime;
9ac52315
LV
558 cputime_t gtime;
559 cputime_t cgtime;
9fbc42ea 560#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
d37f761d 561 struct cputime prev_cputime;
0cf55e1e 562#endif
1da177e4
LT
563 unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
564 unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
6eaeeaba 565 unsigned long inblock, oublock, cinblock, coublock;
1f10206c 566 unsigned long maxrss, cmaxrss;
940389b8 567 struct task_io_accounting ioac;
1da177e4 568
32bd671d
PZ
569 /*
570 * Cumulative ns of schedule CPU time fo dead threads in the
571 * group, not including a zombie group leader, (This only differs
572 * from jiffies_to_ns(utime + stime) if sched_clock uses something
573 * other than jiffies.)
574 */
575 unsigned long long sum_sched_runtime;
576
1da177e4
LT
577 /*
578 * We don't bother to synchronize most readers of this at all,
579 * because there is no reader checking a limit that actually needs
580 * to get both rlim_cur and rlim_max atomically, and either one
581 * alone is a single word that can safely be read normally.
582 * getrlimit/setrlimit use task_lock(current->group_leader) to
583 * protect this instead of the siglock, because they really
584 * have no need to disable irqs.
585 */
586 struct rlimit rlim[RLIM_NLIMITS];
587
0e464814
KK
588#ifdef CONFIG_BSD_PROCESS_ACCT
589 struct pacct_struct pacct; /* per-process accounting information */
590#endif
ad4ecbcb 591#ifdef CONFIG_TASKSTATS
ad4ecbcb
SN
592 struct taskstats *stats;
593#endif
522ed776
MT
594#ifdef CONFIG_AUDIT
595 unsigned audit_tty;
46e959ea 596 unsigned audit_tty_log_passwd;
522ed776
MT
597 struct tty_audit_buf *tty_audit_buf;
598#endif
4714d1d3
BB
599#ifdef CONFIG_CGROUPS
600 /*
77e4ef99
TH
601 * group_rwsem prevents new tasks from entering the threadgroup and
602 * member tasks from exiting,a more specifically, setting of
603 * PF_EXITING. fork and exit paths are protected with this rwsem
604 * using threadgroup_change_begin/end(). Users which require
605 * threadgroup to remain stable should use threadgroup_[un]lock()
606 * which also takes care of exec path. Currently, cgroup is the
607 * only user.
4714d1d3 608 */
257058ae 609 struct rw_semaphore group_rwsem;
4714d1d3 610#endif
28b83c51 611
e1e12d2f 612 oom_flags_t oom_flags;
a9c58b90
DR
613 short oom_score_adj; /* OOM kill score adjustment */
614 short oom_score_adj_min; /* OOM kill score adjustment min value.
615 * Only settable by CAP_SYS_RESOURCE. */
9b1bf12d
KM
616
617 struct mutex cred_guard_mutex; /* guard against foreign influences on
618 * credential calculations
619 * (notably. ptrace) */
1da177e4
LT
620};
621
622/*
623 * Bits in flags field of signal_struct.
624 */
625#define SIGNAL_STOP_STOPPED 0x00000001 /* job control stop in effect */
ee77f075
ON
626#define SIGNAL_STOP_CONTINUED 0x00000002 /* SIGCONT since WCONTINUED reap */
627#define SIGNAL_GROUP_EXIT 0x00000004 /* group exit in progress */
403bad72 628#define SIGNAL_GROUP_COREDUMP 0x00000008 /* coredump in progress */
e4420551
ON
629/*
630 * Pending notifications to parent.
631 */
632#define SIGNAL_CLD_STOPPED 0x00000010
633#define SIGNAL_CLD_CONTINUED 0x00000020
634#define SIGNAL_CLD_MASK (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
1da177e4 635
fae5fa44
ON
636#define SIGNAL_UNKILLABLE 0x00000040 /* for init: ignore fatal signals */
637
ed5d2cac
ON
638/* If true, all threads except ->group_exit_task have pending SIGKILL */
639static inline int signal_group_exit(const struct signal_struct *sig)
640{
641 return (sig->flags & SIGNAL_GROUP_EXIT) ||
642 (sig->group_exit_task != NULL);
643}
644
1da177e4
LT
645/*
646 * Some day this will be a full-fledged user tracking system..
647 */
648struct user_struct {
649 atomic_t __count; /* reference count */
650 atomic_t processes; /* How many processes does this user have? */
651 atomic_t files; /* How many open files does this user have? */
652 atomic_t sigpending; /* How many pending signals does this user have? */
2d9048e2 653#ifdef CONFIG_INOTIFY_USER
0eeca283
RL
654 atomic_t inotify_watches; /* How many inotify watches does this user have? */
655 atomic_t inotify_devs; /* How many inotify devs does this user have opened? */
656#endif
4afeff85
EP
657#ifdef CONFIG_FANOTIFY
658 atomic_t fanotify_listeners;
659#endif
7ef9964e 660#ifdef CONFIG_EPOLL
52bd19f7 661 atomic_long_t epoll_watches; /* The number of file descriptors currently watched */
7ef9964e 662#endif
970a8645 663#ifdef CONFIG_POSIX_MQUEUE
1da177e4
LT
664 /* protected by mq_lock */
665 unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */
970a8645 666#endif
1da177e4
LT
667 unsigned long locked_shm; /* How many pages of mlocked shm ? */
668
669#ifdef CONFIG_KEYS
670 struct key *uid_keyring; /* UID specific keyring */
671 struct key *session_keyring; /* UID's default session keyring */
672#endif
673
674 /* Hash table maintenance information */
735de223 675 struct hlist_node uidhash_node;
7b44ab97 676 kuid_t uid;
24e377a8 677
cdd6c482 678#ifdef CONFIG_PERF_EVENTS
789f90fc
PZ
679 atomic_long_t locked_vm;
680#endif
1da177e4
LT
681};
682
eb41d946 683extern int uids_sysfs_init(void);
5cb350ba 684
7b44ab97 685extern struct user_struct *find_user(kuid_t);
1da177e4
LT
686
687extern struct user_struct root_user;
688#define INIT_USER (&root_user)
689
b6dff3ec 690
1da177e4
LT
691struct backing_dev_info;
692struct reclaim_state;
693
52f17b6c 694#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
1da177e4
LT
695struct sched_info {
696 /* cumulative counters */
2d72376b 697 unsigned long pcount; /* # of times run on this cpu */
9c2c4802 698 unsigned long long run_delay; /* time spent waiting on a runqueue */
1da177e4
LT
699
700 /* timestamps */
172ba844
BS
701 unsigned long long last_arrival,/* when we last ran on a cpu */
702 last_queued; /* when we were last queued to run */
1da177e4 703};
52f17b6c 704#endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
1da177e4 705
ca74e92b
SN
706#ifdef CONFIG_TASK_DELAY_ACCT
707struct task_delay_info {
708 spinlock_t lock;
709 unsigned int flags; /* Private per-task flags */
710
711 /* For each stat XXX, add following, aligned appropriately
712 *
713 * struct timespec XXX_start, XXX_end;
714 * u64 XXX_delay;
715 * u32 XXX_count;
716 *
717 * Atomicity of updates to XXX_delay, XXX_count protected by
718 * single lock above (split into XXX_lock if contention is an issue).
719 */
0ff92245
SN
720
721 /*
722 * XXX_count is incremented on every XXX operation, the delay
723 * associated with the operation is added to XXX_delay.
724 * XXX_delay contains the accumulated delay time in nanoseconds.
725 */
726 struct timespec blkio_start, blkio_end; /* Shared by blkio, swapin */
727 u64 blkio_delay; /* wait for sync block io completion */
728 u64 swapin_delay; /* wait for swapin block io completion */
729 u32 blkio_count; /* total count of the number of sync block */
730 /* io operations performed */
731 u32 swapin_count; /* total count of the number of swapin block */
732 /* io operations performed */
873b4771
KK
733
734 struct timespec freepages_start, freepages_end;
735 u64 freepages_delay; /* wait for memory reclaim */
736 u32 freepages_count; /* total count of memory reclaim */
ca74e92b 737};
52f17b6c
CS
738#endif /* CONFIG_TASK_DELAY_ACCT */
739
740static inline int sched_info_on(void)
741{
742#ifdef CONFIG_SCHEDSTATS
743 return 1;
744#elif defined(CONFIG_TASK_DELAY_ACCT)
745 extern int delayacct_on;
746 return delayacct_on;
747#else
748 return 0;
ca74e92b 749#endif
52f17b6c 750}
ca74e92b 751
d15bcfdb
IM
752enum cpu_idle_type {
753 CPU_IDLE,
754 CPU_NOT_IDLE,
755 CPU_NEWLY_IDLE,
756 CPU_MAX_IDLE_TYPES
1da177e4
LT
757};
758
1399fa78
NR
759/*
760 * Increase resolution of cpu_power calculations
761 */
762#define SCHED_POWER_SHIFT 10
763#define SCHED_POWER_SCALE (1L << SCHED_POWER_SHIFT)
1da177e4 764
1399fa78
NR
765/*
766 * sched-domains (multiprocessor balancing) declarations:
767 */
2dd73a4f 768#ifdef CONFIG_SMP
b5d978e0
PZ
769#define SD_LOAD_BALANCE 0x0001 /* Do load balancing on this domain. */
770#define SD_BALANCE_NEWIDLE 0x0002 /* Balance when about to become idle */
771#define SD_BALANCE_EXEC 0x0004 /* Balance on exec */
772#define SD_BALANCE_FORK 0x0008 /* Balance on fork, clone */
c88d5910 773#define SD_BALANCE_WAKE 0x0010 /* Balance on wakeup */
b5d978e0 774#define SD_WAKE_AFFINE 0x0020 /* Wake task to waking CPU */
b5d978e0 775#define SD_SHARE_CPUPOWER 0x0080 /* Domain members share cpu power */
b5d978e0
PZ
776#define SD_SHARE_PKG_RESOURCES 0x0200 /* Domain members share cpu pkg resources */
777#define SD_SERIALIZE 0x0400 /* Only a single load balancing instance */
532cb4c4 778#define SD_ASYM_PACKING 0x0800 /* Place busy groups earlier in the domain */
b5d978e0 779#define SD_PREFER_SIBLING 0x1000 /* Prefer to place tasks in a sibling domain */
e3589f6c 780#define SD_OVERLAP 0x2000 /* sched_domains of this level overlap */
5c45bf27 781
532cb4c4
MN
782extern int __weak arch_sd_sibiling_asym_packing(void);
783
1d3504fc
HS
784struct sched_domain_attr {
785 int relax_domain_level;
786};
787
788#define SD_ATTR_INIT (struct sched_domain_attr) { \
789 .relax_domain_level = -1, \
790}
791
60495e77
PZ
792extern int sched_domain_level_max;
793
5e6521ea
LZ
794struct sched_group;
795
1da177e4
LT
796struct sched_domain {
797 /* These fields must be setup */
798 struct sched_domain *parent; /* top domain must be null terminated */
1a848870 799 struct sched_domain *child; /* bottom domain must be null terminated */
1da177e4 800 struct sched_group *groups; /* the balancing groups of the domain */
1da177e4
LT
801 unsigned long min_interval; /* Minimum balance interval ms */
802 unsigned long max_interval; /* Maximum balance interval ms */
803 unsigned int busy_factor; /* less balancing by factor if busy */
804 unsigned int imbalance_pct; /* No balance until over watermark */
1da177e4 805 unsigned int cache_nice_tries; /* Leave cache hot tasks for # tries */
7897986b
NP
806 unsigned int busy_idx;
807 unsigned int idle_idx;
808 unsigned int newidle_idx;
809 unsigned int wake_idx;
147cbb4b 810 unsigned int forkexec_idx;
a52bfd73 811 unsigned int smt_gain;
25f55d9d
VG
812
813 int nohz_idle; /* NOHZ IDLE status */
1da177e4 814 int flags; /* See SD_* */
60495e77 815 int level;
1da177e4
LT
816
817 /* Runtime fields. */
818 unsigned long last_balance; /* init to jiffies. units in jiffies */
819 unsigned int balance_interval; /* initialise to 1. units in ms. */
820 unsigned int nr_balance_failed; /* initialise to 0 */
821
2398f2c6
PZ
822 u64 last_update;
823
1da177e4
LT
824#ifdef CONFIG_SCHEDSTATS
825 /* load_balance() stats */
480b9434
KC
826 unsigned int lb_count[CPU_MAX_IDLE_TYPES];
827 unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
828 unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
829 unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
830 unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
831 unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
832 unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
833 unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
1da177e4
LT
834
835 /* Active load balancing */
480b9434
KC
836 unsigned int alb_count;
837 unsigned int alb_failed;
838 unsigned int alb_pushed;
1da177e4 839
68767a0a 840 /* SD_BALANCE_EXEC stats */
480b9434
KC
841 unsigned int sbe_count;
842 unsigned int sbe_balanced;
843 unsigned int sbe_pushed;
1da177e4 844
68767a0a 845 /* SD_BALANCE_FORK stats */
480b9434
KC
846 unsigned int sbf_count;
847 unsigned int sbf_balanced;
848 unsigned int sbf_pushed;
68767a0a 849
1da177e4 850 /* try_to_wake_up() stats */
480b9434
KC
851 unsigned int ttwu_wake_remote;
852 unsigned int ttwu_move_affine;
853 unsigned int ttwu_move_balance;
1da177e4 854#endif
a5d8c348
IM
855#ifdef CONFIG_SCHED_DEBUG
856 char *name;
857#endif
dce840a0
PZ
858 union {
859 void *private; /* used during construction */
860 struct rcu_head rcu; /* used during destruction */
861 };
6c99e9ad 862
669c55e9 863 unsigned int span_weight;
4200efd9
IM
864 /*
865 * Span of all CPUs in this domain.
866 *
867 * NOTE: this field is variable length. (Allocated dynamically
868 * by attaching extra space to the end of the structure,
869 * depending on how many CPUs the kernel has booted up with)
4200efd9
IM
870 */
871 unsigned long span[0];
1da177e4
LT
872};
873
758b2cdc
RR
874static inline struct cpumask *sched_domain_span(struct sched_domain *sd)
875{
6c99e9ad 876 return to_cpumask(sd->span);
758b2cdc
RR
877}
878
acc3f5d7 879extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
1d3504fc 880 struct sched_domain_attr *dattr_new);
029190c5 881
acc3f5d7
RR
882/* Allocate an array of sched domains, for partition_sched_domains(). */
883cpumask_var_t *alloc_sched_domains(unsigned int ndoms);
884void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms);
885
39be3501
PZ
886bool cpus_share_cache(int this_cpu, int that_cpu);
887
1b427c15 888#else /* CONFIG_SMP */
1da177e4 889
1b427c15 890struct sched_domain_attr;
d02c7a8c 891
1b427c15 892static inline void
acc3f5d7 893partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
1b427c15
IM
894 struct sched_domain_attr *dattr_new)
895{
d02c7a8c 896}
39be3501
PZ
897
898static inline bool cpus_share_cache(int this_cpu, int that_cpu)
899{
900 return true;
901}
902
1b427c15 903#endif /* !CONFIG_SMP */
1da177e4 904
47fe38fc 905
1da177e4 906struct io_context; /* See blkdev.h */
1da177e4 907
1da177e4 908
383f2835 909#ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
36c8b586 910extern void prefetch_stack(struct task_struct *t);
383f2835
CK
911#else
912static inline void prefetch_stack(struct task_struct *t) { }
913#endif
1da177e4
LT
914
915struct audit_context; /* See audit.c */
916struct mempolicy;
b92ce558 917struct pipe_inode_info;
4865ecf1 918struct uts_namespace;
1da177e4 919
20b8a59f
IM
920struct load_weight {
921 unsigned long weight, inv_weight;
922};
923
9d85f21c
PT
924struct sched_avg {
925 /*
926 * These sums represent an infinite geometric series and so are bound
239003ea 927 * above by 1024/(1-y). Thus we only need a u32 to store them for all
9d85f21c
PT
928 * choices of y < 1-2^(-32)*1024.
929 */
930 u32 runnable_avg_sum, runnable_avg_period;
931 u64 last_runnable_update;
9ee474f5 932 s64 decay_count;
2dac754e 933 unsigned long load_avg_contrib;
9d85f21c
PT
934};
935
94c18227 936#ifdef CONFIG_SCHEDSTATS
41acab88 937struct sched_statistics {
20b8a59f 938 u64 wait_start;
94c18227 939 u64 wait_max;
6d082592
AV
940 u64 wait_count;
941 u64 wait_sum;
8f0dfc34
AV
942 u64 iowait_count;
943 u64 iowait_sum;
94c18227 944
20b8a59f 945 u64 sleep_start;
20b8a59f 946 u64 sleep_max;
94c18227
IM
947 s64 sum_sleep_runtime;
948
949 u64 block_start;
20b8a59f
IM
950 u64 block_max;
951 u64 exec_max;
eba1ed4b 952 u64 slice_max;
cc367732 953
cc367732
IM
954 u64 nr_migrations_cold;
955 u64 nr_failed_migrations_affine;
956 u64 nr_failed_migrations_running;
957 u64 nr_failed_migrations_hot;
958 u64 nr_forced_migrations;
cc367732
IM
959
960 u64 nr_wakeups;
961 u64 nr_wakeups_sync;
962 u64 nr_wakeups_migrate;
963 u64 nr_wakeups_local;
964 u64 nr_wakeups_remote;
965 u64 nr_wakeups_affine;
966 u64 nr_wakeups_affine_attempts;
967 u64 nr_wakeups_passive;
968 u64 nr_wakeups_idle;
41acab88
LDM
969};
970#endif
971
972struct sched_entity {
973 struct load_weight load; /* for load-balancing */
974 struct rb_node run_node;
975 struct list_head group_node;
976 unsigned int on_rq;
977
978 u64 exec_start;
979 u64 sum_exec_runtime;
980 u64 vruntime;
981 u64 prev_sum_exec_runtime;
982
41acab88
LDM
983 u64 nr_migrations;
984
41acab88
LDM
985#ifdef CONFIG_SCHEDSTATS
986 struct sched_statistics statistics;
94c18227
IM
987#endif
988
20b8a59f
IM
989#ifdef CONFIG_FAIR_GROUP_SCHED
990 struct sched_entity *parent;
991 /* rq on which this entity is (to be) queued: */
992 struct cfs_rq *cfs_rq;
993 /* rq "owned" by this entity/group: */
994 struct cfs_rq *my_q;
995#endif
8bd75c77 996
141965c7 997#ifdef CONFIG_SMP
f4e26b12 998 /* Per-entity load-tracking */
9d85f21c
PT
999 struct sched_avg avg;
1000#endif
20b8a59f 1001};
70b97a7f 1002
fa717060
PZ
1003struct sched_rt_entity {
1004 struct list_head run_list;
78f2c7db 1005 unsigned long timeout;
57d2aa00 1006 unsigned long watchdog_stamp;
bee367ed 1007 unsigned int time_slice;
6f505b16 1008
58d6c2d7 1009 struct sched_rt_entity *back;
052f1dc7 1010#ifdef CONFIG_RT_GROUP_SCHED
6f505b16
PZ
1011 struct sched_rt_entity *parent;
1012 /* rq on which this entity is (to be) queued: */
1013 struct rt_rq *rt_rq;
1014 /* rq "owned" by this entity/group: */
1015 struct rt_rq *my_q;
1016#endif
fa717060
PZ
1017};
1018
8bd75c77 1019
86848966
PM
1020struct rcu_node;
1021
8dc85d54
PZ
1022enum perf_event_task_context {
1023 perf_invalid_context = -1,
1024 perf_hw_context = 0,
89a1e187 1025 perf_sw_context,
8dc85d54
PZ
1026 perf_nr_task_contexts,
1027};
1028
1da177e4
LT
1029struct task_struct {
1030 volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
f7e4217b 1031 void *stack;
1da177e4 1032 atomic_t usage;
97dc32cd
WC
1033 unsigned int flags; /* per process flags, defined below */
1034 unsigned int ptrace;
1da177e4 1035
2dd73a4f 1036#ifdef CONFIG_SMP
fa14ff4a 1037 struct llist_node wake_entry;
3ca7a440 1038 int on_cpu;
2dd73a4f 1039#endif
fd2f4419 1040 int on_rq;
50e645a8 1041
b29739f9 1042 int prio, static_prio, normal_prio;
c7aceaba 1043 unsigned int rt_priority;
5522d5d5 1044 const struct sched_class *sched_class;
20b8a59f 1045 struct sched_entity se;
fa717060 1046 struct sched_rt_entity rt;
8323f26c
PZ
1047#ifdef CONFIG_CGROUP_SCHED
1048 struct task_group *sched_task_group;
1049#endif
1da177e4 1050
e107be36
AK
1051#ifdef CONFIG_PREEMPT_NOTIFIERS
1052 /* list of struct preempt_notifier: */
1053 struct hlist_head preempt_notifiers;
1054#endif
1055
18796aa0
AD
1056 /*
1057 * fpu_counter contains the number of consecutive context switches
1058 * that the FPU is used. If this is over a threshold, the lazy fpu
1059 * saving becomes unlazy to save the trap. This is an unsigned char
1060 * so that after 256 times the counter wraps and the behavior turns
1061 * lazy again; this to deal with bursty apps that only use FPU for
1062 * a short time
1063 */
1064 unsigned char fpu_counter;
6c5c9341 1065#ifdef CONFIG_BLK_DEV_IO_TRACE
2056a782 1066 unsigned int btrace_seq;
6c5c9341 1067#endif
1da177e4 1068
97dc32cd 1069 unsigned int policy;
29baa747 1070 int nr_cpus_allowed;
1da177e4 1071 cpumask_t cpus_allowed;
1da177e4 1072
a57eb940 1073#ifdef CONFIG_PREEMPT_RCU
e260be67 1074 int rcu_read_lock_nesting;
f41d911f 1075 char rcu_read_unlock_special;
f41d911f 1076 struct list_head rcu_node_entry;
a57eb940
PM
1077#endif /* #ifdef CONFIG_PREEMPT_RCU */
1078#ifdef CONFIG_TREE_PREEMPT_RCU
1079 struct rcu_node *rcu_blocked_node;
f41d911f 1080#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
24278d14
PM
1081#ifdef CONFIG_RCU_BOOST
1082 struct rt_mutex *rcu_boost_mutex;
1083#endif /* #ifdef CONFIG_RCU_BOOST */
e260be67 1084
52f17b6c 1085#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
1da177e4
LT
1086 struct sched_info sched_info;
1087#endif
1088
1089 struct list_head tasks;
806c09a7 1090#ifdef CONFIG_SMP
917b627d 1091 struct plist_node pushable_tasks;
806c09a7 1092#endif
1da177e4
LT
1093
1094 struct mm_struct *mm, *active_mm;
4471a675
JK
1095#ifdef CONFIG_COMPAT_BRK
1096 unsigned brk_randomized:1;
1097#endif
34e55232
KH
1098#if defined(SPLIT_RSS_COUNTING)
1099 struct task_rss_stat rss_stat;
1100#endif
1da177e4 1101/* task state */
97dc32cd 1102 int exit_state;
1da177e4
LT
1103 int exit_code, exit_signal;
1104 int pdeath_signal; /* The signal sent when the parent dies */
a8f072c1 1105 unsigned int jobctl; /* JOBCTL_*, siglock protected */
9b89f6ba
AE
1106
1107 /* Used for emulating ABI behavior of previous Linux versions */
97dc32cd 1108 unsigned int personality;
9b89f6ba 1109
1da177e4 1110 unsigned did_exec:1;
f9ce1f1c
KT
1111 unsigned in_execve:1; /* Tell the LSMs that the process is doing an
1112 * execve */
8f0dfc34
AV
1113 unsigned in_iowait:1;
1114
259e5e6c
AL
1115 /* task may not gain privileges */
1116 unsigned no_new_privs:1;
ca94c442
LP
1117
1118 /* Revert to default priority/policy when forking */
1119 unsigned sched_reset_on_fork:1;
a8e4f2ea 1120 unsigned sched_contributes_to_load:1;
ca94c442 1121
1da177e4
LT
1122 pid_t pid;
1123 pid_t tgid;
0a425405 1124
1314562a 1125#ifdef CONFIG_CC_STACKPROTECTOR
0a425405
AV
1126 /* Canary value for the -fstack-protector gcc feature */
1127 unsigned long stack_canary;
1314562a 1128#endif
4d1d61a6 1129 /*
1da177e4 1130 * pointers to (original) parent process, youngest child, younger sibling,
4d1d61a6 1131 * older sibling, respectively. (p->father can be replaced with
f470021a 1132 * p->real_parent->pid)
1da177e4 1133 */
abd63bc3
KC
1134 struct task_struct __rcu *real_parent; /* real parent process */
1135 struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
1da177e4 1136 /*
f470021a 1137 * children/sibling forms the list of my natural children
1da177e4
LT
1138 */
1139 struct list_head children; /* list of my children */
1140 struct list_head sibling; /* linkage in my parent's children list */
1141 struct task_struct *group_leader; /* threadgroup leader */
1142
f470021a
RM
1143 /*
1144 * ptraced is the list of tasks this task is using ptrace on.
1145 * This includes both natural children and PTRACE_ATTACH targets.
1146 * p->ptrace_entry is p's link on the p->parent->ptraced list.
1147 */
1148 struct list_head ptraced;
1149 struct list_head ptrace_entry;
1150
1da177e4 1151 /* PID/PID hash table linkage. */
92476d7f 1152 struct pid_link pids[PIDTYPE_MAX];
47e65328 1153 struct list_head thread_group;
1da177e4
LT
1154
1155 struct completion *vfork_done; /* for vfork() */
1156 int __user *set_child_tid; /* CLONE_CHILD_SETTID */
1157 int __user *clear_child_tid; /* CLONE_CHILD_CLEARTID */
1158
c66f08be 1159 cputime_t utime, stime, utimescaled, stimescaled;
9ac52315 1160 cputime_t gtime;
9fbc42ea 1161#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
d37f761d 1162 struct cputime prev_cputime;
6a61671b
FW
1163#endif
1164#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
1165 seqlock_t vtime_seqlock;
1166 unsigned long long vtime_snap;
1167 enum {
1168 VTIME_SLEEPING = 0,
1169 VTIME_USER,
1170 VTIME_SYS,
1171 } vtime_snap_whence;
d99ca3b9 1172#endif
1da177e4 1173 unsigned long nvcsw, nivcsw; /* context switch counts */
924b42d5
TJ
1174 struct timespec start_time; /* monotonic time */
1175 struct timespec real_start_time; /* boot based time */
1da177e4
LT
1176/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
1177 unsigned long min_flt, maj_flt;
1178
f06febc9 1179 struct task_cputime cputime_expires;
1da177e4
LT
1180 struct list_head cpu_timers[3];
1181
1182/* process credentials */
1b0ba1c9 1183 const struct cred __rcu *real_cred; /* objective and real subjective task
3b11a1de 1184 * credentials (COW) */
1b0ba1c9 1185 const struct cred __rcu *cred; /* effective (overridable) subjective task
3b11a1de 1186 * credentials (COW) */
36772092
PBG
1187 char comm[TASK_COMM_LEN]; /* executable name excluding path
1188 - access with [gs]et_task_comm (which lock
1189 it with task_lock())
221af7f8 1190 - initialized normally by setup_new_exec */
1da177e4
LT
1191/* file system info */
1192 int link_count, total_link_count;
3d5b6fcc 1193#ifdef CONFIG_SYSVIPC
1da177e4
LT
1194/* ipc stuff */
1195 struct sysv_sem sysvsem;
3d5b6fcc 1196#endif
e162b39a 1197#ifdef CONFIG_DETECT_HUNG_TASK
82a1fcb9 1198/* hung task detection */
82a1fcb9
IM
1199 unsigned long last_switch_count;
1200#endif
1da177e4
LT
1201/* CPU-specific state of this task */
1202 struct thread_struct thread;
1203/* filesystem information */
1204 struct fs_struct *fs;
1205/* open file information */
1206 struct files_struct *files;
1651e14e 1207/* namespaces */
ab516013 1208 struct nsproxy *nsproxy;
1da177e4
LT
1209/* signal handlers */
1210 struct signal_struct *signal;
1211 struct sighand_struct *sighand;
1212
1213 sigset_t blocked, real_blocked;
f3de272b 1214 sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
1da177e4
LT
1215 struct sigpending pending;
1216
1217 unsigned long sas_ss_sp;
1218 size_t sas_ss_size;
1219 int (*notifier)(void *priv);
1220 void *notifier_data;
1221 sigset_t *notifier_mask;
67d12145 1222 struct callback_head *task_works;
e73f8959 1223
1da177e4 1224 struct audit_context *audit_context;
bfef93a5 1225#ifdef CONFIG_AUDITSYSCALL
e1760bd5 1226 kuid_t loginuid;
4746ec5b 1227 unsigned int sessionid;
bfef93a5 1228#endif
932ecebb 1229 struct seccomp seccomp;
1da177e4
LT
1230
1231/* Thread group tracking */
1232 u32 parent_exec_id;
1233 u32 self_exec_id;
58568d2a
MX
1234/* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,
1235 * mempolicy */
1da177e4 1236 spinlock_t alloc_lock;
1da177e4 1237
b29739f9 1238 /* Protection of the PI data structures: */
1d615482 1239 raw_spinlock_t pi_lock;
b29739f9 1240
23f78d4a
IM
1241#ifdef CONFIG_RT_MUTEXES
1242 /* PI waiters blocked on a rt_mutex held by this task */
1243 struct plist_head pi_waiters;
1244 /* Deadlock detection and priority inheritance handling */
1245 struct rt_mutex_waiter *pi_blocked_on;
23f78d4a
IM
1246#endif
1247
408894ee
IM
1248#ifdef CONFIG_DEBUG_MUTEXES
1249 /* mutex deadlock detection */
1250 struct mutex_waiter *blocked_on;
1251#endif
de30a2b3
IM
1252#ifdef CONFIG_TRACE_IRQFLAGS
1253 unsigned int irq_events;
de30a2b3 1254 unsigned long hardirq_enable_ip;
de30a2b3 1255 unsigned long hardirq_disable_ip;
fa1452e8 1256 unsigned int hardirq_enable_event;
de30a2b3 1257 unsigned int hardirq_disable_event;
fa1452e8
HS
1258 int hardirqs_enabled;
1259 int hardirq_context;
de30a2b3 1260 unsigned long softirq_disable_ip;
de30a2b3 1261 unsigned long softirq_enable_ip;
fa1452e8 1262 unsigned int softirq_disable_event;
de30a2b3 1263 unsigned int softirq_enable_event;
fa1452e8 1264 int softirqs_enabled;
de30a2b3
IM
1265 int softirq_context;
1266#endif
fbb9ce95 1267#ifdef CONFIG_LOCKDEP
bdb9441e 1268# define MAX_LOCK_DEPTH 48UL
fbb9ce95
IM
1269 u64 curr_chain_key;
1270 int lockdep_depth;
fbb9ce95 1271 unsigned int lockdep_recursion;
c7aceaba 1272 struct held_lock held_locks[MAX_LOCK_DEPTH];
cf40bd16 1273 gfp_t lockdep_reclaim_gfp;
fbb9ce95 1274#endif
408894ee 1275
1da177e4
LT
1276/* journalling filesystem info */
1277 void *journal_info;
1278
d89d8796 1279/* stacked block device info */
bddd87c7 1280 struct bio_list *bio_list;
d89d8796 1281
73c10101
JA
1282#ifdef CONFIG_BLOCK
1283/* stack plugging */
1284 struct blk_plug *plug;
1285#endif
1286
1da177e4
LT
1287/* VM state */
1288 struct reclaim_state *reclaim_state;
1289
1da177e4
LT
1290 struct backing_dev_info *backing_dev_info;
1291
1292 struct io_context *io_context;
1293
1294 unsigned long ptrace_message;
1295 siginfo_t *last_siginfo; /* For ptrace use. */
7c3ab738 1296 struct task_io_accounting ioac;
8f0ab514 1297#if defined(CONFIG_TASK_XACCT)
1da177e4
LT
1298 u64 acct_rss_mem1; /* accumulated rss usage */
1299 u64 acct_vm_mem1; /* accumulated virtual memory usage */
49b5cf34 1300 cputime_t acct_timexpd; /* stime + utime since last update */
1da177e4
LT
1301#endif
1302#ifdef CONFIG_CPUSETS
58568d2a 1303 nodemask_t mems_allowed; /* Protected by alloc_lock */
cc9a6c87 1304 seqcount_t mems_allowed_seq; /* Seqence no to catch updates */
825a46af 1305 int cpuset_mem_spread_rotor;
6adef3eb 1306 int cpuset_slab_spread_rotor;
1da177e4 1307#endif
ddbcc7e8 1308#ifdef CONFIG_CGROUPS
817929ec 1309 /* Control Group info protected by css_set_lock */
2c392b8c 1310 struct css_set __rcu *cgroups;
817929ec
PM
1311 /* cg_list protected by css_set_lock and tsk->alloc_lock */
1312 struct list_head cg_list;
ddbcc7e8 1313#endif
42b2dd0a 1314#ifdef CONFIG_FUTEX
0771dfef 1315 struct robust_list_head __user *robust_list;
34f192c6
IM
1316#ifdef CONFIG_COMPAT
1317 struct compat_robust_list_head __user *compat_robust_list;
1318#endif
c87e2837
IM
1319 struct list_head pi_state_list;
1320 struct futex_pi_state *pi_state_cache;
c7aceaba 1321#endif
cdd6c482 1322#ifdef CONFIG_PERF_EVENTS
8dc85d54 1323 struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
cdd6c482
IM
1324 struct mutex perf_event_mutex;
1325 struct list_head perf_event_list;
a63eaf34 1326#endif
c7aceaba 1327#ifdef CONFIG_NUMA
58568d2a 1328 struct mempolicy *mempolicy; /* Protected by alloc_lock */
c7aceaba 1329 short il_next;
207205a2 1330 short pref_node_fork;
42b2dd0a 1331#endif
cbee9f88
PZ
1332#ifdef CONFIG_NUMA_BALANCING
1333 int numa_scan_seq;
1334 int numa_migrate_seq;
1335 unsigned int numa_scan_period;
1336 u64 node_stamp; /* migration stamp */
1337 struct callback_head numa_work;
1338#endif /* CONFIG_NUMA_BALANCING */
1339
e56d0903 1340 struct rcu_head rcu;
b92ce558
JA
1341
1342 /*
1343 * cache last used pipe for splice
1344 */
1345 struct pipe_inode_info *splice_pipe;
5640f768
ED
1346
1347 struct page_frag task_frag;
1348
ca74e92b
SN
1349#ifdef CONFIG_TASK_DELAY_ACCT
1350 struct task_delay_info *delays;
f4f154fd
AM
1351#endif
1352#ifdef CONFIG_FAULT_INJECTION
1353 int make_it_fail;
ca74e92b 1354#endif
9d823e8f
WF
1355 /*
1356 * when (nr_dirtied >= nr_dirtied_pause), it's time to call
1357 * balance_dirty_pages() for some dirty throttling pause
1358 */
1359 int nr_dirtied;
1360 int nr_dirtied_pause;
83712358 1361 unsigned long dirty_paused_when; /* start of a write-and-pause period */
9d823e8f 1362
9745512c
AV
1363#ifdef CONFIG_LATENCYTOP
1364 int latency_record_count;
1365 struct latency_record latency_record[LT_SAVECOUNT];
1366#endif
6976675d
AV
1367 /*
1368 * time slack values; these are used to round up poll() and
1369 * select() etc timeout values. These are in nanoseconds.
1370 */
1371 unsigned long timer_slack_ns;
1372 unsigned long default_timer_slack_ns;
f8d570a4 1373
fb52607a 1374#ifdef CONFIG_FUNCTION_GRAPH_TRACER
3ad2f3fb 1375 /* Index of current stored address in ret_stack */
f201ae23
FW
1376 int curr_ret_stack;
1377 /* Stack of return addresses for return function tracing */
1378 struct ftrace_ret_stack *ret_stack;
8aef2d28
SR
1379 /* time stamp for last schedule */
1380 unsigned long long ftrace_timestamp;
f201ae23
FW
1381 /*
1382 * Number of functions that haven't been traced
1383 * because of depth overrun.
1384 */
1385 atomic_t trace_overrun;
380c4b14
FW
1386 /* Pause for the tracing */
1387 atomic_t tracing_graph_pause;
f201ae23 1388#endif
ea4e2bc4
SR
1389#ifdef CONFIG_TRACING
1390 /* state flags for use by tracers */
1391 unsigned long trace;
b1cff0ad 1392 /* bitmask and counter of trace recursion */
261842b7
SR
1393 unsigned long trace_recursion;
1394#endif /* CONFIG_TRACING */
c255a458 1395#ifdef CONFIG_MEMCG /* memcg uses this to do batch job */
569b846d
KH
1396 struct memcg_batch_info {
1397 int do_batch; /* incremented when batch uncharge started */
1398 struct mem_cgroup *memcg; /* target memcg of uncharge */
7ffd4ca7
JW
1399 unsigned long nr_pages; /* uncharged usage */
1400 unsigned long memsw_nr_pages; /* uncharged mem+swap usage */
569b846d 1401 } memcg_batch;
0e9d92f2 1402 unsigned int memcg_kmem_skip_account;
569b846d 1403#endif
bf26c018
FW
1404#ifdef CONFIG_HAVE_HW_BREAKPOINT
1405 atomic_t ptrace_bp_refcnt;
1406#endif
0326f5a9
SD
1407#ifdef CONFIG_UPROBES
1408 struct uprobe_task *utask;
0326f5a9 1409#endif
cafe5635
KO
1410#if defined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)
1411 unsigned int sequential_io;
1412 unsigned int sequential_io_avg;
1413#endif
1da177e4
LT
1414};
1415
76e6eee0 1416/* Future-safe accessor for struct task_struct's cpus_allowed. */
a4636818 1417#define tsk_cpus_allowed(tsk) (&(tsk)->cpus_allowed)
76e6eee0 1418
cbee9f88 1419#ifdef CONFIG_NUMA_BALANCING
b8593bfd 1420extern void task_numa_fault(int node, int pages, bool migrated);
1a687c2e 1421extern void set_numabalancing_state(bool enabled);
cbee9f88 1422#else
b8593bfd 1423static inline void task_numa_fault(int node, int pages, bool migrated)
cbee9f88
PZ
1424{
1425}
1a687c2e
MG
1426static inline void set_numabalancing_state(bool enabled)
1427{
1428}
cbee9f88
PZ
1429#endif
1430
e868171a 1431static inline struct pid *task_pid(struct task_struct *task)
22c935f4
EB
1432{
1433 return task->pids[PIDTYPE_PID].pid;
1434}
1435
e868171a 1436static inline struct pid *task_tgid(struct task_struct *task)
22c935f4
EB
1437{
1438 return task->group_leader->pids[PIDTYPE_PID].pid;
1439}
1440
6dda81f4
ON
1441/*
1442 * Without tasklist or rcu lock it is not safe to dereference
1443 * the result of task_pgrp/task_session even if task == current,
1444 * we can race with another thread doing sys_setsid/sys_setpgid.
1445 */
e868171a 1446static inline struct pid *task_pgrp(struct task_struct *task)
22c935f4
EB
1447{
1448 return task->group_leader->pids[PIDTYPE_PGID].pid;
1449}
1450
e868171a 1451static inline struct pid *task_session(struct task_struct *task)
22c935f4
EB
1452{
1453 return task->group_leader->pids[PIDTYPE_SID].pid;
1454}
1455
7af57294
PE
1456struct pid_namespace;
1457
1458/*
1459 * the helpers to get the task's different pids as they are seen
1460 * from various namespaces
1461 *
1462 * task_xid_nr() : global id, i.e. the id seen from the init namespace;
44c4e1b2
EB
1463 * task_xid_vnr() : virtual id, i.e. the id seen from the pid namespace of
1464 * current.
7af57294
PE
1465 * task_xid_nr_ns() : id seen from the ns specified;
1466 *
1467 * set_task_vxid() : assigns a virtual id to a task;
1468 *
7af57294
PE
1469 * see also pid_nr() etc in include/linux/pid.h
1470 */
52ee2dfd
ON
1471pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
1472 struct pid_namespace *ns);
7af57294 1473
e868171a 1474static inline pid_t task_pid_nr(struct task_struct *tsk)
7af57294
PE
1475{
1476 return tsk->pid;
1477}
1478
52ee2dfd
ON
1479static inline pid_t task_pid_nr_ns(struct task_struct *tsk,
1480 struct pid_namespace *ns)
1481{
1482 return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
1483}
7af57294
PE
1484
1485static inline pid_t task_pid_vnr(struct task_struct *tsk)
1486{
52ee2dfd 1487 return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
7af57294
PE
1488}
1489
1490
e868171a 1491static inline pid_t task_tgid_nr(struct task_struct *tsk)
7af57294
PE
1492{
1493 return tsk->tgid;
1494}
1495
2f2a3a46 1496pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
7af57294
PE
1497
1498static inline pid_t task_tgid_vnr(struct task_struct *tsk)
1499{
1500 return pid_vnr(task_tgid(tsk));
1501}
1502
1503
52ee2dfd
ON
1504static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,
1505 struct pid_namespace *ns)
7af57294 1506{
52ee2dfd 1507 return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
7af57294
PE
1508}
1509
7af57294
PE
1510static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
1511{
52ee2dfd 1512 return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);
7af57294
PE
1513}
1514
1515
52ee2dfd
ON
1516static inline pid_t task_session_nr_ns(struct task_struct *tsk,
1517 struct pid_namespace *ns)
7af57294 1518{
52ee2dfd 1519 return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
7af57294
PE
1520}
1521
7af57294
PE
1522static inline pid_t task_session_vnr(struct task_struct *tsk)
1523{
52ee2dfd 1524 return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
7af57294
PE
1525}
1526
1b0f7ffd
ON
1527/* obsolete, do not use */
1528static inline pid_t task_pgrp_nr(struct task_struct *tsk)
1529{
1530 return task_pgrp_nr_ns(tsk, &init_pid_ns);
1531}
7af57294 1532
1da177e4
LT
1533/**
1534 * pid_alive - check that a task structure is not stale
1535 * @p: Task structure to be checked.
1536 *
1537 * Test if a process is not yet dead (at most zombie state)
1538 * If pid_alive fails, then pointers within the task structure
1539 * can be stale and must not be dereferenced.
1540 */
e868171a 1541static inline int pid_alive(struct task_struct *p)
1da177e4 1542{
92476d7f 1543 return p->pids[PIDTYPE_PID].pid != NULL;
1da177e4
LT
1544}
1545
f400e198 1546/**
b460cbc5 1547 * is_global_init - check if a task structure is init
3260259f
H
1548 * @tsk: Task structure to be checked.
1549 *
1550 * Check if a task structure is the first user space task the kernel created.
b460cbc5 1551 */
e868171a 1552static inline int is_global_init(struct task_struct *tsk)
b461cc03
PE
1553{
1554 return tsk->pid == 1;
1555}
b460cbc5 1556
9ec52099
CLG
1557extern struct pid *cad_pid;
1558
1da177e4 1559extern void free_task(struct task_struct *tsk);
1da177e4 1560#define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
e56d0903 1561
158d9ebd 1562extern void __put_task_struct(struct task_struct *t);
e56d0903
IM
1563
1564static inline void put_task_struct(struct task_struct *t)
1565{
1566 if (atomic_dec_and_test(&t->usage))
8c7904a0 1567 __put_task_struct(t);
e56d0903 1568}
1da177e4 1569
6a61671b
FW
1570#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
1571extern void task_cputime(struct task_struct *t,
1572 cputime_t *utime, cputime_t *stime);
1573extern void task_cputime_scaled(struct task_struct *t,
1574 cputime_t *utimescaled, cputime_t *stimescaled);
1575extern cputime_t task_gtime(struct task_struct *t);
1576#else
6fac4829
FW
1577static inline void task_cputime(struct task_struct *t,
1578 cputime_t *utime, cputime_t *stime)
1579{
1580 if (utime)
1581 *utime = t->utime;
1582 if (stime)
1583 *stime = t->stime;
1584}
1585
1586static inline void task_cputime_scaled(struct task_struct *t,
1587 cputime_t *utimescaled,
1588 cputime_t *stimescaled)
1589{
1590 if (utimescaled)
1591 *utimescaled = t->utimescaled;
1592 if (stimescaled)
1593 *stimescaled = t->stimescaled;
1594}
6a61671b
FW
1595
1596static inline cputime_t task_gtime(struct task_struct *t)
1597{
1598 return t->gtime;
1599}
1600#endif
e80d0a1a
FW
1601extern void task_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
1602extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
49048622 1603
1da177e4
LT
1604/*
1605 * Per process flags
1606 */
1da177e4 1607#define PF_EXITING 0x00000004 /* getting shut down */
778e9a9c 1608#define PF_EXITPIDONE 0x00000008 /* pi exit done on shut down */
94886b84 1609#define PF_VCPU 0x00000010 /* I'm a virtual CPU */
21aa9af0 1610#define PF_WQ_WORKER 0x00000020 /* I'm a workqueue worker */
1da177e4 1611#define PF_FORKNOEXEC 0x00000040 /* forked but didn't exec */
4db96cf0 1612#define PF_MCE_PROCESS 0x00000080 /* process policy on mce errors */
1da177e4
LT
1613#define PF_SUPERPRIV 0x00000100 /* used super-user privileges */
1614#define PF_DUMPCORE 0x00000200 /* dumped core */
1615#define PF_SIGNALED 0x00000400 /* killed by a signal */
1616#define PF_MEMALLOC 0x00000800 /* Allocating memory */
72fa5997 1617#define PF_NPROC_EXCEEDED 0x00001000 /* set_user noticed that RLIMIT_NPROC was exceeded */
1da177e4 1618#define PF_USED_MATH 0x00002000 /* if unset the fpu must be initialized before use */
774a1221 1619#define PF_USED_ASYNC 0x00004000 /* used async_schedule*(), used by module init */
1da177e4
LT
1620#define PF_NOFREEZE 0x00008000 /* this thread should not be frozen */
1621#define PF_FROZEN 0x00010000 /* frozen for system suspend */
1622#define PF_FSTRANS 0x00020000 /* inside a filesystem transaction */
1623#define PF_KSWAPD 0x00040000 /* I am kswapd */
21caf2fc 1624#define PF_MEMALLOC_NOIO 0x00080000 /* Allocating memory without IO involved */
1da177e4 1625#define PF_LESS_THROTTLE 0x00100000 /* Throttle me less: I clean memory */
246bb0b1 1626#define PF_KTHREAD 0x00200000 /* I am a kernel thread */
b31dc66a
JA
1627#define PF_RANDOMIZE 0x00400000 /* randomize virtual address space */
1628#define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */
1629#define PF_SPREAD_PAGE 0x01000000 /* Spread page cache over cpuset */
1630#define PF_SPREAD_SLAB 0x02000000 /* Spread some slab caches over cpuset */
14a40ffc 1631#define PF_NO_SETAFFINITY 0x04000000 /* Userland is not allowed to meddle with cpus_allowed */
4db96cf0 1632#define PF_MCE_EARLY 0x08000000 /* Early kill for mce process policy */
c61afb18 1633#define PF_MEMPOLICY 0x10000000 /* Non-default NUMA mempolicy */
61a87122 1634#define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */
58a69cb4 1635#define PF_FREEZER_SKIP 0x40000000 /* Freezer should not count it as freezable */
1da177e4
LT
1636
1637/*
1638 * Only the _current_ task can read/write to tsk->flags, but other
1639 * tasks can access tsk->flags in readonly mode for example
1640 * with tsk_used_math (like during threaded core dumping).
1641 * There is however an exception to this rule during ptrace
1642 * or during fork: the ptracer task is allowed to write to the
1643 * child->flags of its traced child (same goes for fork, the parent
1644 * can write to the child->flags), because we're guaranteed the
1645 * child is not running and in turn not changing child->flags
1646 * at the same time the parent does it.
1647 */
1648#define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
1649#define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
1650#define clear_used_math() clear_stopped_child_used_math(current)
1651#define set_used_math() set_stopped_child_used_math(current)
1652#define conditional_stopped_child_used_math(condition, child) \
1653 do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
1654#define conditional_used_math(condition) \
1655 conditional_stopped_child_used_math(condition, current)
1656#define copy_to_stopped_child_used_math(child) \
1657 do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
1658/* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
1659#define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
1660#define used_math() tsk_used_math(current)
1661
21caf2fc
ML
1662/* __GFP_IO isn't allowed if PF_MEMALLOC_NOIO is set in current->flags */
1663static inline gfp_t memalloc_noio_flags(gfp_t flags)
1664{
1665 if (unlikely(current->flags & PF_MEMALLOC_NOIO))
1666 flags &= ~__GFP_IO;
1667 return flags;
1668}
1669
1670static inline unsigned int memalloc_noio_save(void)
1671{
1672 unsigned int flags = current->flags & PF_MEMALLOC_NOIO;
1673 current->flags |= PF_MEMALLOC_NOIO;
1674 return flags;
1675}
1676
1677static inline void memalloc_noio_restore(unsigned int flags)
1678{
1679 current->flags = (current->flags & ~PF_MEMALLOC_NOIO) | flags;
1680}
1681
e5c1902e 1682/*
a8f072c1 1683 * task->jobctl flags
e5c1902e 1684 */
a8f072c1 1685#define JOBCTL_STOP_SIGMASK 0xffff /* signr of the last group stop */
e5c1902e 1686
a8f072c1
TH
1687#define JOBCTL_STOP_DEQUEUED_BIT 16 /* stop signal dequeued */
1688#define JOBCTL_STOP_PENDING_BIT 17 /* task should stop for group stop */
1689#define JOBCTL_STOP_CONSUME_BIT 18 /* consume group stop count */
73ddff2b 1690#define JOBCTL_TRAP_STOP_BIT 19 /* trap for STOP */
fb1d910c 1691#define JOBCTL_TRAP_NOTIFY_BIT 20 /* trap for NOTIFY */
a8f072c1 1692#define JOBCTL_TRAPPING_BIT 21 /* switching to TRACED */
544b2c91 1693#define JOBCTL_LISTENING_BIT 22 /* ptracer is listening for events */
a8f072c1
TH
1694
1695#define JOBCTL_STOP_DEQUEUED (1 << JOBCTL_STOP_DEQUEUED_BIT)
1696#define JOBCTL_STOP_PENDING (1 << JOBCTL_STOP_PENDING_BIT)
1697#define JOBCTL_STOP_CONSUME (1 << JOBCTL_STOP_CONSUME_BIT)
73ddff2b 1698#define JOBCTL_TRAP_STOP (1 << JOBCTL_TRAP_STOP_BIT)
fb1d910c 1699#define JOBCTL_TRAP_NOTIFY (1 << JOBCTL_TRAP_NOTIFY_BIT)
a8f072c1 1700#define JOBCTL_TRAPPING (1 << JOBCTL_TRAPPING_BIT)
544b2c91 1701#define JOBCTL_LISTENING (1 << JOBCTL_LISTENING_BIT)
a8f072c1 1702
fb1d910c 1703#define JOBCTL_TRAP_MASK (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)
73ddff2b 1704#define JOBCTL_PENDING_MASK (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)
3759a0d9 1705
7dd3db54
TH
1706extern bool task_set_jobctl_pending(struct task_struct *task,
1707 unsigned int mask);
73ddff2b 1708extern void task_clear_jobctl_trapping(struct task_struct *task);
3759a0d9
TH
1709extern void task_clear_jobctl_pending(struct task_struct *task,
1710 unsigned int mask);
39efa3ef 1711
a57eb940 1712#ifdef CONFIG_PREEMPT_RCU
f41d911f
PM
1713
1714#define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */
1aa03f11 1715#define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */
f41d911f
PM
1716
1717static inline void rcu_copy_process(struct task_struct *p)
1718{
1719 p->rcu_read_lock_nesting = 0;
1720 p->rcu_read_unlock_special = 0;
a57eb940 1721#ifdef CONFIG_TREE_PREEMPT_RCU
dd5d19ba 1722 p->rcu_blocked_node = NULL;
24278d14
PM
1723#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
1724#ifdef CONFIG_RCU_BOOST
1725 p->rcu_boost_mutex = NULL;
1726#endif /* #ifdef CONFIG_RCU_BOOST */
f41d911f
PM
1727 INIT_LIST_HEAD(&p->rcu_node_entry);
1728}
1729
f41d911f
PM
1730#else
1731
1732static inline void rcu_copy_process(struct task_struct *p)
1733{
1734}
1735
1736#endif
1737
907aed48
MG
1738static inline void tsk_restore_flags(struct task_struct *task,
1739 unsigned long orig_flags, unsigned long flags)
1740{
1741 task->flags &= ~flags;
1742 task->flags |= orig_flags & flags;
1743}
1744
1da177e4 1745#ifdef CONFIG_SMP
1e1b6c51
KM
1746extern void do_set_cpus_allowed(struct task_struct *p,
1747 const struct cpumask *new_mask);
1748
cd8ba7cd 1749extern int set_cpus_allowed_ptr(struct task_struct *p,
96f874e2 1750 const struct cpumask *new_mask);
1da177e4 1751#else
1e1b6c51
KM
1752static inline void do_set_cpus_allowed(struct task_struct *p,
1753 const struct cpumask *new_mask)
1754{
1755}
cd8ba7cd 1756static inline int set_cpus_allowed_ptr(struct task_struct *p,
96f874e2 1757 const struct cpumask *new_mask)
1da177e4 1758{
96f874e2 1759 if (!cpumask_test_cpu(0, new_mask))
1da177e4
LT
1760 return -EINVAL;
1761 return 0;
1762}
1763#endif
e0ad9556 1764
3451d024 1765#ifdef CONFIG_NO_HZ_COMMON
5167e8d5
PZ
1766void calc_load_enter_idle(void);
1767void calc_load_exit_idle(void);
1768#else
1769static inline void calc_load_enter_idle(void) { }
1770static inline void calc_load_exit_idle(void) { }
3451d024 1771#endif /* CONFIG_NO_HZ_COMMON */
5167e8d5 1772
e0ad9556 1773#ifndef CONFIG_CPUMASK_OFFSTACK
cd8ba7cd
MT
1774static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
1775{
1776 return set_cpus_allowed_ptr(p, &new_mask);
1777}
e0ad9556 1778#endif
1da177e4 1779
b342501c 1780/*
c676329a
PZ
1781 * Do not use outside of architecture code which knows its limitations.
1782 *
1783 * sched_clock() has no promise of monotonicity or bounded drift between
1784 * CPUs, use (which you should not) requires disabling IRQs.
1785 *
1786 * Please use one of the three interfaces below.
b342501c 1787 */
1bbfa6f2 1788extern unsigned long long notrace sched_clock(void);
c676329a 1789/*
489a71b0 1790 * See the comment in kernel/sched/clock.c
c676329a
PZ
1791 */
1792extern u64 cpu_clock(int cpu);
1793extern u64 local_clock(void);
1794extern u64 sched_clock_cpu(int cpu);
1795
e436d800 1796
c1955a3d 1797extern void sched_clock_init(void);
3e51f33f 1798
c1955a3d 1799#ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
3e51f33f
PZ
1800static inline void sched_clock_tick(void)
1801{
1802}
1803
1804static inline void sched_clock_idle_sleep_event(void)
1805{
1806}
1807
1808static inline void sched_clock_idle_wakeup_event(u64 delta_ns)
1809{
1810}
1811#else
c676329a
PZ
1812/*
1813 * Architectures can set this to 1 if they have specified
1814 * CONFIG_HAVE_UNSTABLE_SCHED_CLOCK in their arch Kconfig,
1815 * but then during bootup it turns out that sched_clock()
1816 * is reliable after all:
1817 */
1818extern int sched_clock_stable;
1819
3e51f33f
PZ
1820extern void sched_clock_tick(void);
1821extern void sched_clock_idle_sleep_event(void);
1822extern void sched_clock_idle_wakeup_event(u64 delta_ns);
1823#endif
1824
b52bfee4
VP
1825#ifdef CONFIG_IRQ_TIME_ACCOUNTING
1826/*
1827 * An i/f to runtime opt-in for irq time accounting based off of sched_clock.
1828 * The reason for this explicit opt-in is not to have perf penalty with
1829 * slow sched_clocks.
1830 */
1831extern void enable_sched_clock_irqtime(void);
1832extern void disable_sched_clock_irqtime(void);
1833#else
1834static inline void enable_sched_clock_irqtime(void) {}
1835static inline void disable_sched_clock_irqtime(void) {}
1836#endif
1837
36c8b586 1838extern unsigned long long
41b86e9c 1839task_sched_runtime(struct task_struct *task);
1da177e4
LT
1840
1841/* sched_exec is called by processes performing an exec */
1842#ifdef CONFIG_SMP
1843extern void sched_exec(void);
1844#else
1845#define sched_exec() {}
1846#endif
1847
2aa44d05
IM
1848extern void sched_clock_idle_sleep_event(void);
1849extern void sched_clock_idle_wakeup_event(u64 delta_ns);
bb29ab26 1850
1da177e4
LT
1851#ifdef CONFIG_HOTPLUG_CPU
1852extern void idle_task_exit(void);
1853#else
1854static inline void idle_task_exit(void) {}
1855#endif
1856
3451d024 1857#if defined(CONFIG_NO_HZ_COMMON) && defined(CONFIG_SMP)
1c20091e 1858extern void wake_up_nohz_cpu(int cpu);
06d8308c 1859#else
1c20091e 1860static inline void wake_up_nohz_cpu(int cpu) { }
06d8308c
TG
1861#endif
1862
ce831b38
FW
1863#ifdef CONFIG_NO_HZ_FULL
1864extern bool sched_can_stop_tick(void);
265f22a9 1865extern u64 scheduler_tick_max_deferment(void);
ce831b38
FW
1866#else
1867static inline bool sched_can_stop_tick(void) { return false; }
06d8308c
TG
1868#endif
1869
5091faa4 1870#ifdef CONFIG_SCHED_AUTOGROUP
5091faa4
MG
1871extern void sched_autogroup_create_attach(struct task_struct *p);
1872extern void sched_autogroup_detach(struct task_struct *p);
1873extern void sched_autogroup_fork(struct signal_struct *sig);
1874extern void sched_autogroup_exit(struct signal_struct *sig);
1875#ifdef CONFIG_PROC_FS
1876extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m);
2e5b5b3a 1877extern int proc_sched_autogroup_set_nice(struct task_struct *p, int nice);
5091faa4
MG
1878#endif
1879#else
1880static inline void sched_autogroup_create_attach(struct task_struct *p) { }
1881static inline void sched_autogroup_detach(struct task_struct *p) { }
1882static inline void sched_autogroup_fork(struct signal_struct *sig) { }
1883static inline void sched_autogroup_exit(struct signal_struct *sig) { }
1884#endif
1885
d95f4122 1886extern bool yield_to(struct task_struct *p, bool preempt);
36c8b586
IM
1887extern void set_user_nice(struct task_struct *p, long nice);
1888extern int task_prio(const struct task_struct *p);
1889extern int task_nice(const struct task_struct *p);
1890extern int can_nice(const struct task_struct *p, const int nice);
1891extern int task_curr(const struct task_struct *p);
1da177e4 1892extern int idle_cpu(int cpu);
fe7de49f
KM
1893extern int sched_setscheduler(struct task_struct *, int,
1894 const struct sched_param *);
961ccddd 1895extern int sched_setscheduler_nocheck(struct task_struct *, int,
fe7de49f 1896 const struct sched_param *);
36c8b586 1897extern struct task_struct *idle_task(int cpu);
c4f30608
PM
1898/**
1899 * is_idle_task - is the specified task an idle task?
fa757281 1900 * @p: the task in question.
c4f30608 1901 */
7061ca3b 1902static inline bool is_idle_task(const struct task_struct *p)
c4f30608
PM
1903{
1904 return p->pid == 0;
1905}
36c8b586
IM
1906extern struct task_struct *curr_task(int cpu);
1907extern void set_curr_task(int cpu, struct task_struct *p);
1da177e4
LT
1908
1909void yield(void);
1910
1911/*
1912 * The default (Linux) execution domain.
1913 */
1914extern struct exec_domain default_exec_domain;
1915
1916union thread_union {
1917 struct thread_info thread_info;
1918 unsigned long stack[THREAD_SIZE/sizeof(long)];
1919};
1920
1921#ifndef __HAVE_ARCH_KSTACK_END
1922static inline int kstack_end(void *addr)
1923{
1924 /* Reliable end of stack detection:
1925 * Some APM bios versions misalign the stack
1926 */
1927 return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
1928}
1929#endif
1930
1931extern union thread_union init_thread_union;
1932extern struct task_struct init_task;
1933
1934extern struct mm_struct init_mm;
1935
198fe21b
PE
1936extern struct pid_namespace init_pid_ns;
1937
1938/*
1939 * find a task by one of its numerical ids
1940 *
198fe21b
PE
1941 * find_task_by_pid_ns():
1942 * finds a task by its pid in the specified namespace
228ebcbe
PE
1943 * find_task_by_vpid():
1944 * finds a task by its virtual pid
198fe21b 1945 *
e49859e7 1946 * see also find_vpid() etc in include/linux/pid.h
198fe21b
PE
1947 */
1948
228ebcbe
PE
1949extern struct task_struct *find_task_by_vpid(pid_t nr);
1950extern struct task_struct *find_task_by_pid_ns(pid_t nr,
1951 struct pid_namespace *ns);
198fe21b 1952
1da177e4 1953/* per-UID process charging. */
7b44ab97 1954extern struct user_struct * alloc_uid(kuid_t);
1da177e4
LT
1955static inline struct user_struct *get_uid(struct user_struct *u)
1956{
1957 atomic_inc(&u->__count);
1958 return u;
1959}
1960extern void free_uid(struct user_struct *);
1da177e4
LT
1961
1962#include <asm/current.h>
1963
f0af911a 1964extern void xtime_update(unsigned long ticks);
1da177e4 1965
b3c97528
HH
1966extern int wake_up_state(struct task_struct *tsk, unsigned int state);
1967extern int wake_up_process(struct task_struct *tsk);
3e51e3ed 1968extern void wake_up_new_task(struct task_struct *tsk);
1da177e4
LT
1969#ifdef CONFIG_SMP
1970 extern void kick_process(struct task_struct *tsk);
1971#else
1972 static inline void kick_process(struct task_struct *tsk) { }
1973#endif
3e51e3ed 1974extern void sched_fork(struct task_struct *p);
ad46c2c4 1975extern void sched_dead(struct task_struct *p);
1da177e4 1976
1da177e4
LT
1977extern void proc_caches_init(void);
1978extern void flush_signals(struct task_struct *);
3bcac026 1979extern void __flush_signals(struct task_struct *);
10ab825b 1980extern void ignore_signals(struct task_struct *);
1da177e4
LT
1981extern void flush_signal_handlers(struct task_struct *, int force_default);
1982extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
1983
1984static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
1985{
1986 unsigned long flags;
1987 int ret;
1988
1989 spin_lock_irqsave(&tsk->sighand->siglock, flags);
1990 ret = dequeue_signal(tsk, mask, info);
1991 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
1992
1993 return ret;
53c8f9f1 1994}
1da177e4
LT
1995
1996extern void block_all_signals(int (*notifier)(void *priv), void *priv,
1997 sigset_t *mask);
1998extern void unblock_all_signals(void);
1999extern void release_task(struct task_struct * p);
2000extern int send_sig_info(int, struct siginfo *, struct task_struct *);
1da177e4
LT
2001extern int force_sigsegv(int, struct task_struct *);
2002extern int force_sig_info(int, struct siginfo *, struct task_struct *);
c4b92fc1 2003extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
c4b92fc1 2004extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
d178bc3a
SH
2005extern int kill_pid_info_as_cred(int, struct siginfo *, struct pid *,
2006 const struct cred *, u32);
c4b92fc1
EB
2007extern int kill_pgrp(struct pid *pid, int sig, int priv);
2008extern int kill_pid(struct pid *pid, int sig, int priv);
c3de4b38 2009extern int kill_proc_info(int, struct siginfo *, pid_t);
86773473 2010extern __must_check bool do_notify_parent(struct task_struct *, int);
a7f0765e 2011extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
1da177e4 2012extern void force_sig(int, struct task_struct *);
1da177e4 2013extern int send_sig(int, struct task_struct *, int);
09faef11 2014extern int zap_other_threads(struct task_struct *p);
1da177e4
LT
2015extern struct sigqueue *sigqueue_alloc(void);
2016extern void sigqueue_free(struct sigqueue *);
ac5c2153 2017extern int send_sigqueue(struct sigqueue *, struct task_struct *, int group);
9ac95f2f 2018extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
1da177e4 2019
51a7b448
AV
2020static inline void restore_saved_sigmask(void)
2021{
2022 if (test_and_clear_restore_sigmask())
77097ae5 2023 __set_current_blocked(&current->saved_sigmask);
51a7b448
AV
2024}
2025
b7f9a11a
AV
2026static inline sigset_t *sigmask_to_save(void)
2027{
2028 sigset_t *res = &current->blocked;
2029 if (unlikely(test_restore_sigmask()))
2030 res = &current->saved_sigmask;
2031 return res;
2032}
2033
9ec52099
CLG
2034static inline int kill_cad_pid(int sig, int priv)
2035{
2036 return kill_pid(cad_pid, sig, priv);
2037}
2038
1da177e4
LT
2039/* These can be the second arg to send_sig_info/send_group_sig_info. */
2040#define SEND_SIG_NOINFO ((struct siginfo *) 0)
2041#define SEND_SIG_PRIV ((struct siginfo *) 1)
2042#define SEND_SIG_FORCED ((struct siginfo *) 2)
2043
2a855dd0
SAS
2044/*
2045 * True if we are on the alternate signal stack.
2046 */
1da177e4
LT
2047static inline int on_sig_stack(unsigned long sp)
2048{
2a855dd0
SAS
2049#ifdef CONFIG_STACK_GROWSUP
2050 return sp >= current->sas_ss_sp &&
2051 sp - current->sas_ss_sp < current->sas_ss_size;
2052#else
2053 return sp > current->sas_ss_sp &&
2054 sp - current->sas_ss_sp <= current->sas_ss_size;
2055#endif
1da177e4
LT
2056}
2057
2058static inline int sas_ss_flags(unsigned long sp)
2059{
2060 return (current->sas_ss_size == 0 ? SS_DISABLE
2061 : on_sig_stack(sp) ? SS_ONSTACK : 0);
2062}
2063
5a1b98d3
AV
2064static inline unsigned long sigsp(unsigned long sp, struct ksignal *ksig)
2065{
2066 if (unlikely((ksig->ka.sa.sa_flags & SA_ONSTACK)) && ! sas_ss_flags(sp))
2067#ifdef CONFIG_STACK_GROWSUP
2068 return current->sas_ss_sp;
2069#else
2070 return current->sas_ss_sp + current->sas_ss_size;
2071#endif
2072 return sp;
2073}
2074
1da177e4
LT
2075/*
2076 * Routines for handling mm_structs
2077 */
2078extern struct mm_struct * mm_alloc(void);
2079
2080/* mmdrop drops the mm and the page tables */
b3c97528 2081extern void __mmdrop(struct mm_struct *);
1da177e4
LT
2082static inline void mmdrop(struct mm_struct * mm)
2083{
6fb43d7b 2084 if (unlikely(atomic_dec_and_test(&mm->mm_count)))
1da177e4
LT
2085 __mmdrop(mm);
2086}
2087
2088/* mmput gets rid of the mappings and all user-space */
2089extern void mmput(struct mm_struct *);
2090/* Grab a reference to a task's mm, if it is not already going away */
2091extern struct mm_struct *get_task_mm(struct task_struct *task);
8cdb878d
CY
2092/*
2093 * Grab a reference to a task's mm, if it is not already going away
2094 * and ptrace_may_access with the mode parameter passed to it
2095 * succeeds.
2096 */
2097extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);
1da177e4
LT
2098/* Remove the current tasks stale references to the old mm_struct */
2099extern void mm_release(struct task_struct *, struct mm_struct *);
402b0862
CO
2100/* Allocate a new mm structure and copy contents from tsk->mm */
2101extern struct mm_struct *dup_mm(struct task_struct *tsk);
1da177e4 2102
6f2c55b8 2103extern int copy_thread(unsigned long, unsigned long, unsigned long,
afa86fc4 2104 struct task_struct *);
1da177e4
LT
2105extern void flush_thread(void);
2106extern void exit_thread(void);
2107
1da177e4 2108extern void exit_files(struct task_struct *);
a7e5328a 2109extern void __cleanup_sighand(struct sighand_struct *);
cbaffba1 2110
1da177e4 2111extern void exit_itimers(struct signal_struct *);
cbaffba1 2112extern void flush_itimer_signals(void);
1da177e4 2113
9402c95f 2114extern void do_group_exit(int);
1da177e4 2115
1da177e4
LT
2116extern int allow_signal(int);
2117extern int disallow_signal(int);
1da177e4 2118
d7627467
DH
2119extern int do_execve(const char *,
2120 const char __user * const __user *,
da3d4c5f 2121 const char __user * const __user *);
e80d6661 2122extern long do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *);
36c8b586 2123struct task_struct *fork_idle(int);
2aa3a7f8 2124extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
1da177e4
LT
2125
2126extern void set_task_comm(struct task_struct *tsk, char *from);
59714d65 2127extern char *get_task_comm(char *to, struct task_struct *tsk);
1da177e4
LT
2128
2129#ifdef CONFIG_SMP
317f3941 2130void scheduler_ipi(void);
85ba2d86 2131extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
1da177e4 2132#else
184748cc 2133static inline void scheduler_ipi(void) { }
85ba2d86
RM
2134static inline unsigned long wait_task_inactive(struct task_struct *p,
2135 long match_state)
2136{
2137 return 1;
2138}
1da177e4
LT
2139#endif
2140
05725f7e
JP
2141#define next_task(p) \
2142 list_entry_rcu((p)->tasks.next, struct task_struct, tasks)
1da177e4
LT
2143
2144#define for_each_process(p) \
2145 for (p = &init_task ; (p = next_task(p)) != &init_task ; )
2146
5bb459bb 2147extern bool current_is_single_threaded(void);
d84f4f99 2148
1da177e4
LT
2149/*
2150 * Careful: do_each_thread/while_each_thread is a double loop so
2151 * 'break' will not work as expected - use goto instead.
2152 */
2153#define do_each_thread(g, t) \
2154 for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
2155
2156#define while_each_thread(g, t) \
2157 while ((t = next_thread(t)) != g)
2158
7e49827c
ON
2159static inline int get_nr_threads(struct task_struct *tsk)
2160{
b3ac022c 2161 return tsk->signal->nr_threads;
7e49827c
ON
2162}
2163
087806b1
ON
2164static inline bool thread_group_leader(struct task_struct *p)
2165{
2166 return p->exit_signal >= 0;
2167}
1da177e4 2168
0804ef4b
EB
2169/* Do to the insanities of de_thread it is possible for a process
2170 * to have the pid of the thread group leader without actually being
2171 * the thread group leader. For iteration through the pids in proc
2172 * all we care about is that we have a task with the appropriate
2173 * pid, we don't actually care if we have the right task.
2174 */
e868171a 2175static inline int has_group_leader_pid(struct task_struct *p)
0804ef4b
EB
2176{
2177 return p->pid == p->tgid;
2178}
2179
bac0abd6
PE
2180static inline
2181int same_thread_group(struct task_struct *p1, struct task_struct *p2)
2182{
2183 return p1->tgid == p2->tgid;
2184}
2185
36c8b586 2186static inline struct task_struct *next_thread(const struct task_struct *p)
47e65328 2187{
05725f7e
JP
2188 return list_entry_rcu(p->thread_group.next,
2189 struct task_struct, thread_group);
47e65328
ON
2190}
2191
e868171a 2192static inline int thread_group_empty(struct task_struct *p)
1da177e4 2193{
47e65328 2194 return list_empty(&p->thread_group);
1da177e4
LT
2195}
2196
2197#define delay_group_leader(p) \
2198 (thread_group_leader(p) && !thread_group_empty(p))
2199
1da177e4 2200/*
260ea101 2201 * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
22e2c507 2202 * subscriptions and synchronises with wait4(). Also used in procfs. Also
ddbcc7e8 2203 * pins the final release of task.io_context. Also protects ->cpuset and
d68b46fe 2204 * ->cgroup.subsys[]. And ->vfork_done.
1da177e4
LT
2205 *
2206 * Nests both inside and outside of read_lock(&tasklist_lock).
2207 * It must not be nested with write_lock_irq(&tasklist_lock),
2208 * neither inside nor outside.
2209 */
2210static inline void task_lock(struct task_struct *p)
2211{
2212 spin_lock(&p->alloc_lock);
2213}
2214
2215static inline void task_unlock(struct task_struct *p)
2216{
2217 spin_unlock(&p->alloc_lock);
2218}
2219
b8ed374e 2220extern struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
f63ee72e
ON
2221 unsigned long *flags);
2222
9388dc30
AV
2223static inline struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
2224 unsigned long *flags)
2225{
2226 struct sighand_struct *ret;
2227
2228 ret = __lock_task_sighand(tsk, flags);
2229 (void)__cond_lock(&tsk->sighand->siglock, ret);
2230 return ret;
2231}
b8ed374e 2232
f63ee72e
ON
2233static inline void unlock_task_sighand(struct task_struct *tsk,
2234 unsigned long *flags)
2235{
2236 spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
2237}
2238
4714d1d3 2239#ifdef CONFIG_CGROUPS
257058ae 2240static inline void threadgroup_change_begin(struct task_struct *tsk)
4714d1d3 2241{
257058ae 2242 down_read(&tsk->signal->group_rwsem);
4714d1d3 2243}
257058ae 2244static inline void threadgroup_change_end(struct task_struct *tsk)
4714d1d3 2245{
257058ae 2246 up_read(&tsk->signal->group_rwsem);
4714d1d3 2247}
77e4ef99
TH
2248
2249/**
2250 * threadgroup_lock - lock threadgroup
2251 * @tsk: member task of the threadgroup to lock
2252 *
2253 * Lock the threadgroup @tsk belongs to. No new task is allowed to enter
2254 * and member tasks aren't allowed to exit (as indicated by PF_EXITING) or
e56fb287
ON
2255 * change ->group_leader/pid. This is useful for cases where the threadgroup
2256 * needs to stay stable across blockable operations.
77e4ef99
TH
2257 *
2258 * fork and exit paths explicitly call threadgroup_change_{begin|end}() for
2259 * synchronization. While held, no new task will be added to threadgroup
2260 * and no existing live task will have its PF_EXITING set.
2261 *
e56fb287
ON
2262 * de_thread() does threadgroup_change_{begin|end}() when a non-leader
2263 * sub-thread becomes a new leader.
77e4ef99 2264 */
257058ae 2265static inline void threadgroup_lock(struct task_struct *tsk)
4714d1d3 2266{
257058ae 2267 down_write(&tsk->signal->group_rwsem);
4714d1d3 2268}
77e4ef99
TH
2269
2270/**
2271 * threadgroup_unlock - unlock threadgroup
2272 * @tsk: member task of the threadgroup to unlock
2273 *
2274 * Reverse threadgroup_lock().
2275 */
257058ae 2276static inline void threadgroup_unlock(struct task_struct *tsk)
4714d1d3 2277{
257058ae 2278 up_write(&tsk->signal->group_rwsem);
4714d1d3
BB
2279}
2280#else
257058ae
TH
2281static inline void threadgroup_change_begin(struct task_struct *tsk) {}
2282static inline void threadgroup_change_end(struct task_struct *tsk) {}
2283static inline void threadgroup_lock(struct task_struct *tsk) {}
2284static inline void threadgroup_unlock(struct task_struct *tsk) {}
4714d1d3
BB
2285#endif
2286
f037360f
AV
2287#ifndef __HAVE_THREAD_FUNCTIONS
2288
f7e4217b
RZ
2289#define task_thread_info(task) ((struct thread_info *)(task)->stack)
2290#define task_stack_page(task) ((task)->stack)
a1261f54 2291
10ebffde
AV
2292static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
2293{
2294 *task_thread_info(p) = *task_thread_info(org);
2295 task_thread_info(p)->task = p;
2296}
2297
2298static inline unsigned long *end_of_stack(struct task_struct *p)
2299{
f7e4217b 2300 return (unsigned long *)(task_thread_info(p) + 1);
10ebffde
AV
2301}
2302
f037360f
AV
2303#endif
2304
8b05c7e6
FT
2305static inline int object_is_on_stack(void *obj)
2306{
2307 void *stack = task_stack_page(current);
2308
2309 return (obj >= stack) && (obj < (stack + THREAD_SIZE));
2310}
2311
8c9843e5
BH
2312extern void thread_info_cache_init(void);
2313
7c9f8861
ES
2314#ifdef CONFIG_DEBUG_STACK_USAGE
2315static inline unsigned long stack_not_used(struct task_struct *p)
2316{
2317 unsigned long *n = end_of_stack(p);
2318
2319 do { /* Skip over canary */
2320 n++;
2321 } while (!*n);
2322
2323 return (unsigned long)n - (unsigned long)end_of_stack(p);
2324}
2325#endif
2326
1da177e4
LT
2327/* set thread flags in other task's structures
2328 * - see asm/thread_info.h for TIF_xxxx flags available
2329 */
2330static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
2331{
a1261f54 2332 set_ti_thread_flag(task_thread_info(tsk), flag);
1da177e4
LT
2333}
2334
2335static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2336{
a1261f54 2337 clear_ti_thread_flag(task_thread_info(tsk), flag);
1da177e4
LT
2338}
2339
2340static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
2341{
a1261f54 2342 return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
1da177e4
LT
2343}
2344
2345static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2346{
a1261f54 2347 return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
1da177e4
LT
2348}
2349
2350static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
2351{
a1261f54 2352 return test_ti_thread_flag(task_thread_info(tsk), flag);
1da177e4
LT
2353}
2354
2355static inline void set_tsk_need_resched(struct task_struct *tsk)
2356{
2357 set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2358}
2359
2360static inline void clear_tsk_need_resched(struct task_struct *tsk)
2361{
2362 clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2363}
2364
8ae121ac
GH
2365static inline int test_tsk_need_resched(struct task_struct *tsk)
2366{
2367 return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
2368}
2369
690cc3ff
EB
2370static inline int restart_syscall(void)
2371{
2372 set_tsk_thread_flag(current, TIF_SIGPENDING);
2373 return -ERESTARTNOINTR;
2374}
2375
1da177e4
LT
2376static inline int signal_pending(struct task_struct *p)
2377{
2378 return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
2379}
f776d12d 2380
d9588725
RM
2381static inline int __fatal_signal_pending(struct task_struct *p)
2382{
2383 return unlikely(sigismember(&p->pending.signal, SIGKILL));
2384}
f776d12d
MW
2385
2386static inline int fatal_signal_pending(struct task_struct *p)
2387{
2388 return signal_pending(p) && __fatal_signal_pending(p);
2389}
2390
16882c1e
ON
2391static inline int signal_pending_state(long state, struct task_struct *p)
2392{
2393 if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
2394 return 0;
2395 if (!signal_pending(p))
2396 return 0;
2397
16882c1e
ON
2398 return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
2399}
2400
1da177e4
LT
2401static inline int need_resched(void)
2402{
9404ef02 2403 return unlikely(test_thread_flag(TIF_NEED_RESCHED));
1da177e4
LT
2404}
2405
2406/*
2407 * cond_resched() and cond_resched_lock(): latency reduction via
2408 * explicit rescheduling in places that are safe. The return
2409 * value indicates whether a reschedule was done in fact.
2410 * cond_resched_lock() will drop the spinlock before scheduling,
2411 * cond_resched_softirq() will enable bhs before scheduling.
2412 */
c3921ab7 2413extern int _cond_resched(void);
6f80bd98 2414
613afbf8
FW
2415#define cond_resched() ({ \
2416 __might_sleep(__FILE__, __LINE__, 0); \
2417 _cond_resched(); \
2418})
6f80bd98 2419
613afbf8
FW
2420extern int __cond_resched_lock(spinlock_t *lock);
2421
bdd4e85d 2422#ifdef CONFIG_PREEMPT_COUNT
716a4234 2423#define PREEMPT_LOCK_OFFSET PREEMPT_OFFSET
02b67cc3 2424#else
716a4234 2425#define PREEMPT_LOCK_OFFSET 0
02b67cc3 2426#endif
716a4234 2427
613afbf8 2428#define cond_resched_lock(lock) ({ \
716a4234 2429 __might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET); \
613afbf8
FW
2430 __cond_resched_lock(lock); \
2431})
2432
2433extern int __cond_resched_softirq(void);
2434
75e1056f
VP
2435#define cond_resched_softirq() ({ \
2436 __might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET); \
2437 __cond_resched_softirq(); \
613afbf8 2438})
1da177e4
LT
2439
2440/*
2441 * Does a critical section need to be broken due to another
95c354fe
NP
2442 * task waiting?: (technically does not depend on CONFIG_PREEMPT,
2443 * but a general need for low latency)
1da177e4 2444 */
95c354fe 2445static inline int spin_needbreak(spinlock_t *lock)
1da177e4 2446{
95c354fe
NP
2447#ifdef CONFIG_PREEMPT
2448 return spin_is_contended(lock);
2449#else
1da177e4 2450 return 0;
95c354fe 2451#endif
1da177e4
LT
2452}
2453
ee761f62
TG
2454/*
2455 * Idle thread specific functions to determine the need_resched
2456 * polling state. We have two versions, one based on TS_POLLING in
2457 * thread_info.status and one based on TIF_POLLING_NRFLAG in
2458 * thread_info.flags
2459 */
2460#ifdef TS_POLLING
2461static inline int tsk_is_polling(struct task_struct *p)
2462{
2463 return task_thread_info(p)->status & TS_POLLING;
2464}
3a98f871
TG
2465static inline void current_set_polling(void)
2466{
2467 current_thread_info()->status |= TS_POLLING;
2468}
2469
2470static inline void current_clr_polling(void)
2471{
2472 current_thread_info()->status &= ~TS_POLLING;
2473 smp_mb__after_clear_bit();
2474}
ee761f62
TG
2475#elif defined(TIF_POLLING_NRFLAG)
2476static inline int tsk_is_polling(struct task_struct *p)
2477{
2478 return test_tsk_thread_flag(p, TIF_POLLING_NRFLAG);
2479}
3a98f871
TG
2480static inline void current_set_polling(void)
2481{
2482 set_thread_flag(TIF_POLLING_NRFLAG);
2483}
2484
2485static inline void current_clr_polling(void)
2486{
2487 clear_thread_flag(TIF_POLLING_NRFLAG);
2488}
ee761f62
TG
2489#else
2490static inline int tsk_is_polling(struct task_struct *p) { return 0; }
3a98f871
TG
2491static inline void current_set_polling(void) { }
2492static inline void current_clr_polling(void) { }
ee761f62
TG
2493#endif
2494
f06febc9
FM
2495/*
2496 * Thread group CPU time accounting.
2497 */
4cd4c1b4 2498void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
4da94d49 2499void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
f06febc9 2500
490dea45 2501static inline void thread_group_cputime_init(struct signal_struct *sig)
f06febc9 2502{
ee30a7b2 2503 raw_spin_lock_init(&sig->cputimer.lock);
f06febc9
FM
2504}
2505
7bb44ade
RM
2506/*
2507 * Reevaluate whether the task has signals pending delivery.
2508 * Wake the task if so.
2509 * This is required every time the blocked sigset_t changes.
2510 * callers must hold sighand->siglock.
2511 */
2512extern void recalc_sigpending_and_wake(struct task_struct *t);
1da177e4
LT
2513extern void recalc_sigpending(void);
2514
910ffdb1
ON
2515extern void signal_wake_up_state(struct task_struct *t, unsigned int state);
2516
2517static inline void signal_wake_up(struct task_struct *t, bool resume)
2518{
2519 signal_wake_up_state(t, resume ? TASK_WAKEKILL : 0);
2520}
2521static inline void ptrace_signal_wake_up(struct task_struct *t, bool resume)
2522{
2523 signal_wake_up_state(t, resume ? __TASK_TRACED : 0);
2524}
1da177e4
LT
2525
2526/*
2527 * Wrappers for p->thread_info->cpu access. No-op on UP.
2528 */
2529#ifdef CONFIG_SMP
2530
2531static inline unsigned int task_cpu(const struct task_struct *p)
2532{
a1261f54 2533 return task_thread_info(p)->cpu;
1da177e4
LT
2534}
2535
c65cc870 2536extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
1da177e4
LT
2537
2538#else
2539
2540static inline unsigned int task_cpu(const struct task_struct *p)
2541{
2542 return 0;
2543}
2544
2545static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
2546{
2547}
2548
2549#endif /* CONFIG_SMP */
2550
96f874e2
RR
2551extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
2552extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
5c45bf27 2553
7c941438 2554#ifdef CONFIG_CGROUP_SCHED
07e06b01 2555extern struct task_group root_task_group;
8323f26c 2556#endif /* CONFIG_CGROUP_SCHED */
9b5b7751 2557
54e99124
DG
2558extern int task_can_switch_user(struct user_struct *up,
2559 struct task_struct *tsk);
2560
4b98d11b
AD
2561#ifdef CONFIG_TASK_XACCT
2562static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2563{
940389b8 2564 tsk->ioac.rchar += amt;
4b98d11b
AD
2565}
2566
2567static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2568{
940389b8 2569 tsk->ioac.wchar += amt;
4b98d11b
AD
2570}
2571
2572static inline void inc_syscr(struct task_struct *tsk)
2573{
940389b8 2574 tsk->ioac.syscr++;
4b98d11b
AD
2575}
2576
2577static inline void inc_syscw(struct task_struct *tsk)
2578{
940389b8 2579 tsk->ioac.syscw++;
4b98d11b
AD
2580}
2581#else
2582static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2583{
2584}
2585
2586static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2587{
2588}
2589
2590static inline void inc_syscr(struct task_struct *tsk)
2591{
2592}
2593
2594static inline void inc_syscw(struct task_struct *tsk)
2595{
2596}
2597#endif
2598
82455257
DH
2599#ifndef TASK_SIZE_OF
2600#define TASK_SIZE_OF(tsk) TASK_SIZE
2601#endif
2602
cf475ad2
BS
2603#ifdef CONFIG_MM_OWNER
2604extern void mm_update_next_owner(struct mm_struct *mm);
2605extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
2606#else
2607static inline void mm_update_next_owner(struct mm_struct *mm)
2608{
2609}
2610
2611static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
2612{
2613}
2614#endif /* CONFIG_MM_OWNER */
2615
3e10e716
JS
2616static inline unsigned long task_rlimit(const struct task_struct *tsk,
2617 unsigned int limit)
2618{
2619 return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_cur);
2620}
2621
2622static inline unsigned long task_rlimit_max(const struct task_struct *tsk,
2623 unsigned int limit)
2624{
2625 return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_max);
2626}
2627
2628static inline unsigned long rlimit(unsigned int limit)
2629{
2630 return task_rlimit(current, limit);
2631}
2632
2633static inline unsigned long rlimit_max(unsigned int limit)
2634{
2635 return task_rlimit_max(current, limit);
2636}
2637
1da177e4 2638#endif
This page took 1.780847 seconds and 5 git commands to generate.