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