projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
sched: refresh MAINTAINERS entry
[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
b7b3c76a
DW		 4/*
5 * cloning flags:
6 */
7#define CSIGNAL 0x000000ff /* signal mask to be sent at exit */
8#define CLONE_VM 0x00000100 /* set if VM shared between processes */
9#define CLONE_FS 0x00000200 /* set if fs info shared between processes */
10#define CLONE_FILES 0x00000400 /* set if open files shared between processes */
11#define CLONE_SIGHAND 0x00000800 /* set if signal handlers and blocked signals shared */
12#define CLONE_PTRACE 0x00002000 /* set if we want to let tracing continue on the child too */
13#define CLONE_VFORK 0x00004000 /* set if the parent wants the child to wake it up on mm_release */
14#define CLONE_PARENT 0x00008000 /* set if we want to have the same parent as the cloner */
15#define CLONE_THREAD 0x00010000 /* Same thread group? */
16#define CLONE_NEWNS 0x00020000 /* New namespace group? */
17#define CLONE_SYSVSEM 0x00040000 /* share system V SEM_UNDO semantics */
18#define CLONE_SETTLS 0x00080000 /* create a new TLS for the child */
19#define CLONE_PARENT_SETTID 0x00100000 /* set the TID in the parent */
20#define CLONE_CHILD_CLEARTID 0x00200000 /* clear the TID in the child */
21#define CLONE_DETACHED 0x00400000 /* Unused, ignored */
22#define CLONE_UNTRACED 0x00800000 /* set if the tracing process can't force CLONE_PTRACE on this clone */
23#define CLONE_CHILD_SETTID 0x01000000 /* set the TID in the child */
24#define CLONE_STOPPED 0x02000000 /* Start in stopped state */
071df104 25#define CLONE_NEWUTS 0x04000000 /* New utsname group? */
25b21cb2 26#define CLONE_NEWIPC 0x08000000 /* New ipcs */
77ec739d 27#define CLONE_NEWUSER 0x10000000 /* New user namespace */
30e49c26 28#define CLONE_NEWPID 0x20000000 /* New pid namespace */
169e3674 29#define CLONE_NEWNET 0x40000000 /* New network namespace */
fadad878 30#define CLONE_IO 0x80000000 /* Clone io context */
b7b3c76a
DW		 31
32/*
33 * Scheduling policies
34 */
35#define SCHED_NORMAL 0
36#define SCHED_FIFO 1
37#define SCHED_RR 2
38#define SCHED_BATCH 3
0e6aca43
IM		 39/* SCHED_ISO: reserved but not implemented yet */
40#define SCHED_IDLE 5
b7b3c76a 41
a3b6714e 42#ifdef __KERNEL__
b7b3c76a
DW		 43
44struct sched_param {
45 int sched_priority;
46};
47
1da177e4
LT		 48#include <asm/param.h> /* for HZ */
49
1da177e4
LT		 50#include <linux/capability.h>
51#include <linux/threads.h>
52#include <linux/kernel.h>
53#include <linux/types.h>
54#include <linux/timex.h>
55#include <linux/jiffies.h>
56#include <linux/rbtree.h>
57#include <linux/thread_info.h>
58#include <linux/cpumask.h>
59#include <linux/errno.h>
60#include <linux/nodemask.h>
c92ff1bd 61#include <linux/mm_types.h>
1da177e4
LT		 62
63#include <asm/system.h>
1da177e4
LT		 64#include <asm/page.h>
65#include <asm/ptrace.h>
1da177e4
LT		 66#include <asm/cputime.h>
67
68#include <linux/smp.h>
69#include <linux/sem.h>
70#include <linux/signal.h>
5ad4e53b 71#include <linux/path.h>
1da177e4
LT		 72#include <linux/compiler.h>
73#include <linux/completion.h>
74#include <linux/pid.h>
75#include <linux/percpu.h>
76#include <linux/topology.h>
3e26c149 77#include <linux/proportions.h>
1da177e4 78#include <linux/seccomp.h>
e56d0903 79#include <linux/rcupdate.h>
23f78d4a 80#include <linux/rtmutex.h>
1da177e4 81
a3b6714e
DW		 82#include <linux/time.h>
83#include <linux/param.h>
84#include <linux/resource.h>
85#include <linux/timer.h>
86#include <linux/hrtimer.h>
7c3ab738 87#include <linux/task_io_accounting.h>
5cb350ba 88#include <linux/kobject.h>
9745512c 89#include <linux/latencytop.h>
9e2b2dc4 90#include <linux/cred.h>
a3b6714e
DW		 91
92#include <asm/processor.h>
36d57ac4 93
78fb7466 94struct mem_cgroup;
1da177e4 95struct exec_domain;
c87e2837 96struct futex_pi_state;
286100a6 97struct robust_list_head;
d89d8796 98struct bio;
ca0002a1 99struct bts_tracer;
5ad4e53b 100struct fs_struct;
1da177e4 101
1da177e4
LT		 102/*
103 * List of flags we want to share for kernel threads,
104 * if only because they are not used by them anyway.
105 */
106#define CLONE_KERNEL (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
107
108/*
109 * These are the constant used to fake the fixed-point load-average
110 * counting. Some notes:
111 * - 11 bit fractions expand to 22 bits by the multiplies: this gives
112 * a load-average precision of 10 bits integer + 11 bits fractional
113 * - if you want to count load-averages more often, you need more
114 * precision, or rounding will get you. With 2-second counting freq,
115 * the EXP_n values would be 1981, 2034 and 2043 if still using only
116 * 11 bit fractions.
117 */
118extern unsigned long avenrun[]; /* Load averages */
119
120#define FSHIFT 11 /* nr of bits of precision */
121#define FIXED_1 (1<<FSHIFT) /* 1.0 as fixed-point */
0c2043ab 122#define LOAD_FREQ (5*HZ+1) /* 5 sec intervals */
1da177e4
LT		 123#define EXP_1 1884 /* 1/exp(5sec/1min) as fixed-point */
124#define EXP_5 2014 /* 1/exp(5sec/5min) */
125#define EXP_15 2037 /* 1/exp(5sec/15min) */
126
127#define CALC_LOAD(load,exp,n) \
128 load *= exp; \
129 load += n*(FIXED_1-exp); \
130 load >>= FSHIFT;
131
132extern unsigned long total_forks;
133extern int nr_threads;
1da177e4
LT		 134DECLARE_PER_CPU(unsigned long, process_counts);
135extern int nr_processes(void);
136extern unsigned long nr_running(void);
137extern unsigned long nr_uninterruptible(void);
db1b1fef 138extern unsigned long nr_active(void);
1da177e4
LT		 139extern unsigned long nr_iowait(void);
140
7e49fcce
SR		 141extern unsigned long get_parent_ip(unsigned long addr);
142
43ae34cb
IM		 143struct seq_file;
144struct cfs_rq;
4cf86d77 145struct task_group;
43ae34cb
IM		 146#ifdef CONFIG_SCHED_DEBUG
147extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
148extern void proc_sched_set_task(struct task_struct *p);
149extern void
5cef9eca 150print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
43ae34cb
IM		 151#else
152static inline void
153proc_sched_show_task(struct task_struct *p, struct seq_file *m)
154{
155}
156static inline void proc_sched_set_task(struct task_struct *p)
157{
158}
159static inline void
5cef9eca 160print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
43ae34cb
IM		 161{
162}
163#endif
1da177e4 164
690229a0
IM		 165extern unsigned long long time_sync_thresh;
166
4a8342d2
LT		 167/*
168 * Task state bitmask. NOTE! These bits are also
169 * encoded in fs/proc/array.c: get_task_state().
170 *
171 * We have two separate sets of flags: task->state
172 * is about runnability, while task->exit_state are
173 * about the task exiting. Confusing, but this way
174 * modifying one set can't modify the other one by
175 * mistake.
176 */
1da177e4
LT		 177#define TASK_RUNNING 0
178#define TASK_INTERRUPTIBLE 1
179#define TASK_UNINTERRUPTIBLE 2
f021a3c2
MW		 180#define __TASK_STOPPED 4
181#define __TASK_TRACED 8
4a8342d2
LT		 182/* in tsk->exit_state */
183#define EXIT_ZOMBIE 16
184#define EXIT_DEAD 32
185/* in tsk->state again */
af927232 186#define TASK_DEAD 64
f021a3c2
MW		 187#define TASK_WAKEKILL 128
188
189/* Convenience macros for the sake of set_task_state */
190#define TASK_KILLABLE (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
191#define TASK_STOPPED (TASK_WAKEKILL | __TASK_STOPPED)
192#define TASK_TRACED (TASK_WAKEKILL | __TASK_TRACED)
1da177e4 193
92a1f4bc
MW		 194/* Convenience macros for the sake of wake_up */
195#define TASK_NORMAL (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
f021a3c2 196#define TASK_ALL (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
92a1f4bc
MW		 197
198/* get_task_state() */
199#define TASK_REPORT (TASK_RUNNING | TASK_INTERRUPTIBLE | \
f021a3c2
MW		 200 TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
201 __TASK_TRACED)
92a1f4bc 202
f021a3c2
MW		 203#define task_is_traced(task) ((task->state & __TASK_TRACED) != 0)
204#define task_is_stopped(task) ((task->state & __TASK_STOPPED) != 0)
92a1f4bc 205#define task_is_stopped_or_traced(task) \
f021a3c2 206 ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
92a1f4bc
MW		 207#define task_contributes_to_load(task) \
208 ((task->state & TASK_UNINTERRUPTIBLE) != 0)
1da177e4
LT		 209
210#define __set_task_state(tsk, state_value) \
211 do { (tsk)->state = (state_value); } while (0)
212#define set_task_state(tsk, state_value) \
213 set_mb((tsk)->state, (state_value))
214
498d0c57
AM		 215/*
216 * set_current_state() includes a barrier so that the write of current->state
217 * is correctly serialised wrt the caller's subsequent test of whether to
218 * actually sleep:
219 *
220 * set_current_state(TASK_UNINTERRUPTIBLE);
221 * if (do_i_need_to_sleep())
222 * schedule();
223 *
224 * If the caller does not need such serialisation then use __set_current_state()
225 */
1da177e4
LT		 226#define __set_current_state(state_value) \
227 do { current->state = (state_value); } while (0)
228#define set_current_state(state_value) \
229 set_mb(current->state, (state_value))
230
231/* Task command name length */
232#define TASK_COMM_LEN 16
233
1da177e4
LT		 234#include <linux/spinlock.h>
235
236/*
237 * This serializes "schedule()" and also protects
238 * the run-queue from deletions/modifications (but
239 * _adding_ to the beginning of the run-queue has
240 * a separate lock).
241 */
242extern rwlock_t tasklist_lock;
243extern spinlock_t mmlist_lock;
244
36c8b586 245struct task_struct;
1da177e4
LT		 246
247extern void sched_init(void);
248extern void sched_init_smp(void);
2d07b255 249extern asmlinkage void schedule_tail(struct task_struct *prev);
36c8b586 250extern void init_idle(struct task_struct *idle, int cpu);
1df21055 251extern void init_idle_bootup_task(struct task_struct *idle);
1da177e4 252
017730c1 253extern int runqueue_is_locked(void);
ad474cac 254extern void task_rq_unlock_wait(struct task_struct *p);
017730c1 255
6a7b3dc3 256extern cpumask_var_t nohz_cpu_mask;
46cb4b7c
SS		 257#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ)
258extern int select_nohz_load_balancer(int cpu);
259#else
260static inline int select_nohz_load_balancer(int cpu)
261{
262 return 0;
263}
264#endif
1da177e4 265
e59e2ae2 266/*
39bc89fd 267 * Only dump TASK_* tasks. (0 for all tasks)
e59e2ae2
IM		 268 */
269extern void show_state_filter(unsigned long state_filter);
270
271static inline void show_state(void)
272{
39bc89fd 273 show_state_filter(0);
e59e2ae2
IM		 274}
275
1da177e4
LT		 276extern void show_regs(struct pt_regs *);
277
278/*
279 * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
280 * task), SP is the stack pointer of the first frame that should be shown in the back
281 * trace (or NULL if the entire call-chain of the task should be shown).
282 */
283extern void show_stack(struct task_struct *task, unsigned long *sp);
284
285void io_schedule(void);
286long io_schedule_timeout(long timeout);
287
288extern void cpu_init (void);
289extern void trap_init(void);
290extern void update_process_times(int user);
291extern void scheduler_tick(void);
292
82a1fcb9
IM		 293extern void sched_show_task(struct task_struct *p);
294
8446f1d3 295#ifdef CONFIG_DETECT_SOFTLOCKUP
6687a97d 296extern void softlockup_tick(void);
8446f1d3 297extern void touch_softlockup_watchdog(void);
04c9167f 298extern void touch_all_softlockup_watchdogs(void);
baf48f65
MSB		 299extern int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
300 struct file *filp, void __user *buffer,
301 size_t *lenp, loff_t *ppos);
9c44bc03 302extern unsigned int softlockup_panic;
9383d967 303extern int softlockup_thresh;
8446f1d3 304#else
6687a97d 305static inline void softlockup_tick(void)
8446f1d3
IM		 306{
307}
8446f1d3
IM		 308static inline void touch_softlockup_watchdog(void)
309{
310}
04c9167f
JF		 311static inline void touch_all_softlockup_watchdogs(void)
312{
313}
8446f1d3
IM		 314#endif
315
e162b39a
MSB		 316#ifdef CONFIG_DETECT_HUNG_TASK
317extern unsigned int sysctl_hung_task_panic;
318extern unsigned long sysctl_hung_task_check_count;
319extern unsigned long sysctl_hung_task_timeout_secs;
320extern unsigned long sysctl_hung_task_warnings;
321extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
322 struct file *filp, void __user *buffer,
323 size_t *lenp, loff_t *ppos);
324#endif
8446f1d3 325
1da177e4
LT		 326/* Attach to any functions which should be ignored in wchan output. */
327#define __sched __attribute__((__section__(".sched.text")))
deaf2227
IM		 328
329/* Linker adds these: start and end of __sched functions */
330extern char __sched_text_start[], __sched_text_end[];
331
1da177e4
LT		 332/* Is this address in the __sched functions? */
333extern int in_sched_functions(unsigned long addr);
334
335#define MAX_SCHEDULE_TIMEOUT LONG_MAX
b3c97528 336extern signed long schedule_timeout(signed long timeout);
64ed93a2 337extern signed long schedule_timeout_interruptible(signed long timeout);
294d5cc2 338extern signed long schedule_timeout_killable(signed long timeout);
64ed93a2 339extern signed long schedule_timeout_uninterruptible(signed long timeout);
41719b03 340asmlinkage void __schedule(void);
1da177e4 341asmlinkage void schedule(void);
0d66bf6d 342extern int mutex_spin_on_owner(struct mutex *lock, struct thread_info *owner);
1da177e4 343
ab516013 344struct nsproxy;
acce292c 345struct user_namespace;
1da177e4
LT		 346
347/* Maximum number of active map areas.. This is a random (large) number */
348#define DEFAULT_MAX_MAP_COUNT 65536
349
350extern int sysctl_max_map_count;
351
352#include <linux/aio.h>
353
354extern unsigned long
355arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
356 unsigned long, unsigned long);
357extern unsigned long
358arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
359 unsigned long len, unsigned long pgoff,
360 unsigned long flags);
1363c3cd
WW		 361extern void arch_unmap_area(struct mm_struct *, unsigned long);
362extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
1da177e4 363
f7d0b926 364#if USE_SPLIT_PTLOCKS
f412ac08
HD		 365/*
366 * The mm counters are not protected by its page_table_lock,
367 * so must be incremented atomically.
368 */
d3cb4871
CL		 369#define set_mm_counter(mm, member, value) atomic_long_set(&(mm)->_##member, value)
370#define get_mm_counter(mm, member) ((unsigned long)atomic_long_read(&(mm)->_##member))
371#define add_mm_counter(mm, member, value) atomic_long_add(value, &(mm)->_##member)
372#define inc_mm_counter(mm, member) atomic_long_inc(&(mm)->_##member)
373#define dec_mm_counter(mm, member) atomic_long_dec(&(mm)->_##member)
f412ac08 374
f7d0b926 375#else /* !USE_SPLIT_PTLOCKS */
f412ac08
HD		 376/*
377 * The mm counters are protected by its page_table_lock,
378 * so can be incremented directly.
379 */
1da177e4
LT		 380#define set_mm_counter(mm, member, value) (mm)->_##member = (value)
381#define get_mm_counter(mm, member) ((mm)->_##member)
382#define add_mm_counter(mm, member, value) (mm)->_##member += (value)
383#define inc_mm_counter(mm, member) (mm)->_##member++
384#define dec_mm_counter(mm, member) (mm)->_##member--
f412ac08 385
f7d0b926 386#endif /* !USE_SPLIT_PTLOCKS */
4294621f 387
f412ac08
HD		 388#define get_mm_rss(mm) \
389 (get_mm_counter(mm, file_rss) + get_mm_counter(mm, anon_rss))
365e9c87
HD		 390#define update_hiwater_rss(mm) do { \
391 unsigned long _rss = get_mm_rss(mm); \
392 if ((mm)->hiwater_rss < _rss) \
393 (mm)->hiwater_rss = _rss; \
394} while (0)
395#define update_hiwater_vm(mm) do { \
396 if ((mm)->hiwater_vm < (mm)->total_vm) \
397 (mm)->hiwater_vm = (mm)->total_vm; \
398} while (0)
399
9de1581e
ON		 400static inline unsigned long get_mm_hiwater_rss(struct mm_struct *mm)
401{
402 return max(mm->hiwater_rss, get_mm_rss(mm));
403}
404
405static inline unsigned long get_mm_hiwater_vm(struct mm_struct *mm)
406{
407 return max(mm->hiwater_vm, mm->total_vm);
408}
901608d9 409
6c5d5238
KH		 410extern void set_dumpable(struct mm_struct *mm, int value);
411extern int get_dumpable(struct mm_struct *mm);
412
413/* mm flags */
3cb4a0bb 414/* dumpable bits */
6c5d5238
KH		 415#define MMF_DUMPABLE 0 /* core dump is permitted */
416#define MMF_DUMP_SECURELY 1 /* core file is readable only by root */
3cb4a0bb
KH		 417#define MMF_DUMPABLE_BITS 2
418
419/* coredump filter bits */
420#define MMF_DUMP_ANON_PRIVATE 2
421#define MMF_DUMP_ANON_SHARED 3
422#define MMF_DUMP_MAPPED_PRIVATE 4
423#define MMF_DUMP_MAPPED_SHARED 5
82df3973 424#define MMF_DUMP_ELF_HEADERS 6
e575f111
KM		 425#define MMF_DUMP_HUGETLB_PRIVATE 7
426#define MMF_DUMP_HUGETLB_SHARED 8
3cb4a0bb 427#define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS
e575f111 428#define MMF_DUMP_FILTER_BITS 7
3cb4a0bb
KH		 429#define MMF_DUMP_FILTER_MASK \
430 (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
431#define MMF_DUMP_FILTER_DEFAULT \
e575f111 432 ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\
656eb2cd
RM		 433 (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)
434
435#ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS
436# define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS)
437#else
438# define MMF_DUMP_MASK_DEFAULT_ELF 0
439#endif
6c5d5238 440
1da177e4
LT		 441struct sighand_struct {
442 atomic_t count;
443 struct k_sigaction action[_NSIG];
444 spinlock_t siglock;
b8fceee1 445 wait_queue_head_t signalfd_wqh;
1da177e4
LT		 446};
447
0e464814 448struct pacct_struct {
f6ec29a4
KK		 449 int ac_flag;
450 long ac_exitcode;
0e464814 451 unsigned long ac_mem;
77787bfb
KK		 452 cputime_t ac_utime, ac_stime;
453 unsigned long ac_minflt, ac_majflt;
0e464814
KK		 454};
455
f06febc9
FM		 456/**
457 * struct task_cputime - collected CPU time counts
458 * @utime: time spent in user mode, in &cputime_t units
459 * @stime: time spent in kernel mode, in &cputime_t units
460 * @sum_exec_runtime: total time spent on the CPU, in nanoseconds
5ce73a4a 461 *
f06febc9
FM		 462 * This structure groups together three kinds of CPU time that are
463 * tracked for threads and thread groups. Most things considering
464 * CPU time want to group these counts together and treat all three
465 * of them in parallel.
466 */
467struct task_cputime {
468 cputime_t utime;
469 cputime_t stime;
470 unsigned long long sum_exec_runtime;
471};
472/* Alternate field names when used to cache expirations. */
473#define prof_exp stime
474#define virt_exp utime
475#define sched_exp sum_exec_runtime
476
4cd4c1b4
PZ		 477#define INIT_CPUTIME \
478 (struct task_cputime) { \
479 .utime = cputime_zero, \
480 .stime = cputime_zero, \
481 .sum_exec_runtime = 0, \
482 }
483
f06febc9 484/**
4cd4c1b4
PZ		 485 * struct thread_group_cputimer - thread group interval timer counts
486 * @cputime: thread group interval timers.
487 * @running: non-zero when there are timers running and
488 * @cputime receives updates.
489 * @lock: lock for fields in this struct.
f06febc9
FM		 490 *
491 * This structure contains the version of task_cputime, above, that is
4cd4c1b4 492 * used for thread group CPU timer calculations.
f06febc9 493 */
4cd4c1b4
PZ		 494struct thread_group_cputimer {
495 struct task_cputime cputime;
496 int running;
497 spinlock_t lock;
f06febc9 498};
f06febc9 499
1da177e4
LT		 500/*
501 * NOTE! "signal_struct" does not have it's own
502 * locking, because a shared signal_struct always
503 * implies a shared sighand_struct, so locking
504 * sighand_struct is always a proper superset of
505 * the locking of signal_struct.
506 */
507struct signal_struct {
508 atomic_t count;
509 atomic_t live;
510
511 wait_queue_head_t wait_chldexit; /* for wait4() */
512
513 /* current thread group signal load-balancing target: */
36c8b586 514 struct task_struct *curr_target;
1da177e4
LT		 515
516 /* shared signal handling: */
517 struct sigpending shared_pending;
518
519 /* thread group exit support */
520 int group_exit_code;
521 /* overloaded:
522 * - notify group_exit_task when ->count is equal to notify_count
523 * - everyone except group_exit_task is stopped during signal delivery
524 * of fatal signals, group_exit_task processes the signal.
525 */
1da177e4 526 int notify_count;
07dd20e0 527 struct task_struct *group_exit_task;
1da177e4
LT		 528
529 /* thread group stop support, overloads group_exit_code too */
530 int group_stop_count;
531 unsigned int flags; /* see SIGNAL_* flags below */
532
533 /* POSIX.1b Interval Timers */
534 struct list_head posix_timers;
535
536 /* ITIMER_REAL timer for the process */
2ff678b8 537 struct hrtimer real_timer;
fea9d175 538 struct pid *leader_pid;
2ff678b8 539 ktime_t it_real_incr;
1da177e4
LT		 540
541 /* ITIMER_PROF and ITIMER_VIRTUAL timers for the process */
542 cputime_t it_prof_expires, it_virt_expires;
543 cputime_t it_prof_incr, it_virt_incr;
544
f06febc9 545 /*
4cd4c1b4
PZ		 546 * Thread group totals for process CPU timers.
547 * See thread_group_cputimer(), et al, for details.
f06febc9 548 */
4cd4c1b4 549 struct thread_group_cputimer cputimer;
f06febc9
FM		 550
551 /* Earliest-expiration cache. */
552 struct task_cputime cputime_expires;
553
554 struct list_head cpu_timers[3];
555
ab521dc0 556 struct pid *tty_old_pgrp;
1ec320af 557
1da177e4
LT		 558 /* boolean value for session group leader */
559 int leader;
560
561 struct tty_struct *tty; /* NULL if no tty */
562
563 /*
564 * Cumulative resource counters for dead threads in the group,
565 * and for reaped dead child processes forked by this group.
566 * Live threads maintain their own counters and add to these
567 * in __exit_signal, except for the group leader.
568 */
32bd671d 569 cputime_t utime, stime, cutime, cstime;
9ac52315
LV		 570 cputime_t gtime;
571 cputime_t cgtime;
1da177e4
LT		 572 unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
573 unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
6eaeeaba 574 unsigned long inblock, oublock, cinblock, coublock;
940389b8 575 struct task_io_accounting ioac;
1da177e4 576
32bd671d
PZ		 577 /*
578 * Cumulative ns of schedule CPU time fo dead threads in the
579 * group, not including a zombie group leader, (This only differs
580 * from jiffies_to_ns(utime + stime) if sched_clock uses something
581 * other than jiffies.)
582 */
583 unsigned long long sum_sched_runtime;
584
1da177e4
LT		 585 /*
586 * We don't bother to synchronize most readers of this at all,
587 * because there is no reader checking a limit that actually needs
588 * to get both rlim_cur and rlim_max atomically, and either one
589 * alone is a single word that can safely be read normally.
590 * getrlimit/setrlimit use task_lock(current->group_leader) to
591 * protect this instead of the siglock, because they really
592 * have no need to disable irqs.
593 */
594 struct rlimit rlim[RLIM_NLIMITS];
595
0e464814
KK		 596#ifdef CONFIG_BSD_PROCESS_ACCT
597 struct pacct_struct pacct; /* per-process accounting information */
598#endif
ad4ecbcb 599#ifdef CONFIG_TASKSTATS
ad4ecbcb
SN		 600 struct taskstats *stats;
601#endif
522ed776
MT		 602#ifdef CONFIG_AUDIT
603 unsigned audit_tty;
604 struct tty_audit_buf *tty_audit_buf;
605#endif
1da177e4
LT		 606};
607
4866cde0
NP		 608/* Context switch must be unlocked if interrupts are to be enabled */
609#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
610# define __ARCH_WANT_UNLOCKED_CTXSW
611#endif
612
1da177e4
LT		 613/*
614 * Bits in flags field of signal_struct.
615 */
616#define SIGNAL_STOP_STOPPED 0x00000001 /* job control stop in effect */
617#define SIGNAL_STOP_DEQUEUED 0x00000002 /* stop signal dequeued */
618#define SIGNAL_STOP_CONTINUED 0x00000004 /* SIGCONT since WCONTINUED reap */
619#define SIGNAL_GROUP_EXIT 0x00000008 /* group exit in progress */
e4420551
ON		 620/*
621 * Pending notifications to parent.
622 */
623#define SIGNAL_CLD_STOPPED 0x00000010
624#define SIGNAL_CLD_CONTINUED 0x00000020
625#define SIGNAL_CLD_MASK (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
1da177e4 626
fae5fa44
ON		 627#define SIGNAL_UNKILLABLE 0x00000040 /* for init: ignore fatal signals */
628
ed5d2cac
ON		 629/* If true, all threads except ->group_exit_task have pending SIGKILL */
630static inline int signal_group_exit(const struct signal_struct *sig)
631{
632 return (sig->flags & SIGNAL_GROUP_EXIT) ||
633 (sig->group_exit_task != NULL);
634}
635
1da177e4
LT		 636/*
637 * Some day this will be a full-fledged user tracking system..
638 */
639struct user_struct {
640 atomic_t __count; /* reference count */
641 atomic_t processes; /* How many processes does this user have? */
642 atomic_t files; /* How many open files does this user have? */
643 atomic_t sigpending; /* How many pending signals does this user have? */
2d9048e2 644#ifdef CONFIG_INOTIFY_USER
0eeca283
RL		 645 atomic_t inotify_watches; /* How many inotify watches does this user have? */
646 atomic_t inotify_devs; /* How many inotify devs does this user have opened? */
647#endif
7ef9964e 648#ifdef CONFIG_EPOLL
7ef9964e
DL		 649 atomic_t epoll_watches; /* The number of file descriptors currently watched */
650#endif
970a8645 651#ifdef CONFIG_POSIX_MQUEUE
1da177e4
LT		 652 /* protected by mq_lock */
653 unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */
970a8645 654#endif
1da177e4
LT		 655 unsigned long locked_shm; /* How many pages of mlocked shm ? */
656
657#ifdef CONFIG_KEYS
658 struct key *uid_keyring; /* UID specific keyring */
659 struct key *session_keyring; /* UID's default session keyring */
660#endif
661
662 /* Hash table maintenance information */
735de223 663 struct hlist_node uidhash_node;
1da177e4 664 uid_t uid;
18b6e041 665 struct user_namespace *user_ns;
24e377a8 666
052f1dc7 667#ifdef CONFIG_USER_SCHED
4cf86d77 668 struct task_group *tg;
b1a8c172 669#ifdef CONFIG_SYSFS
eb41d946 670 struct kobject kobj;
5cb350ba 671 struct work_struct work;
24e377a8 672#endif
b1a8c172 673#endif
1da177e4
LT		 674};
675
eb41d946 676extern int uids_sysfs_init(void);
5cb350ba 677
1da177e4
LT		 678extern struct user_struct *find_user(uid_t);
679
680extern struct user_struct root_user;
681#define INIT_USER (&root_user)
682
b6dff3ec 683
1da177e4
LT		 684struct backing_dev_info;
685struct reclaim_state;
686
52f17b6c 687#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
1da177e4
LT		 688struct sched_info {
689 /* cumulative counters */
2d72376b 690 unsigned long pcount; /* # of times run on this cpu */
9c2c4802 691 unsigned long long run_delay; /* time spent waiting on a runqueue */
1da177e4
LT		 692
693 /* timestamps */
172ba844
BS		 694 unsigned long long last_arrival,/* when we last ran on a cpu */
695 last_queued; /* when we were last queued to run */
b8efb561
IM		 696#ifdef CONFIG_SCHEDSTATS
697 /* BKL stats */
480b9434 698 unsigned int bkl_count;
b8efb561 699#endif
1da177e4 700};
52f17b6c 701#endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
1da177e4 702
ca74e92b
SN		 703#ifdef CONFIG_TASK_DELAY_ACCT
704struct task_delay_info {
705 spinlock_t lock;
706 unsigned int flags; /* Private per-task flags */
707
708 /* For each stat XXX, add following, aligned appropriately
709 *
710 * struct timespec XXX_start, XXX_end;
711 * u64 XXX_delay;
712 * u32 XXX_count;
713 *
714 * Atomicity of updates to XXX_delay, XXX_count protected by
715 * single lock above (split into XXX_lock if contention is an issue).
716 */
0ff92245
SN		 717
718 /*
719 * XXX_count is incremented on every XXX operation, the delay
720 * associated with the operation is added to XXX_delay.
721 * XXX_delay contains the accumulated delay time in nanoseconds.
722 */
723 struct timespec blkio_start, blkio_end; /* Shared by blkio, swapin */
724 u64 blkio_delay; /* wait for sync block io completion */
725 u64 swapin_delay; /* wait for swapin block io completion */
726 u32 blkio_count; /* total count of the number of sync block */
727 /* io operations performed */
728 u32 swapin_count; /* total count of the number of swapin block */
729 /* io operations performed */
873b4771
KK		 730
731 struct timespec freepages_start, freepages_end;
732 u64 freepages_delay; /* wait for memory reclaim */
733 u32 freepages_count; /* total count of memory reclaim */
ca74e92b 734};
52f17b6c
CS		 735#endif /* CONFIG_TASK_DELAY_ACCT */
736
737static inline int sched_info_on(void)
738{
739#ifdef CONFIG_SCHEDSTATS
740 return 1;
741#elif defined(CONFIG_TASK_DELAY_ACCT)
742 extern int delayacct_on;
743 return delayacct_on;
744#else
745 return 0;
ca74e92b 746#endif
52f17b6c 747}
ca74e92b 748
d15bcfdb
IM		 749enum cpu_idle_type {
750 CPU_IDLE,
751 CPU_NOT_IDLE,
752 CPU_NEWLY_IDLE,
753 CPU_MAX_IDLE_TYPES
1da177e4
LT		 754};
755
756/*
757 * sched-domains (multiprocessor balancing) declarations:
758 */
9aa7b369
IM		 759
760/*
761 * Increase resolution of nice-level calculations:
762 */
763#define SCHED_LOAD_SHIFT 10
764#define SCHED_LOAD_SCALE (1L << SCHED_LOAD_SHIFT)
765
f8700df7 766#define SCHED_LOAD_SCALE_FUZZ SCHED_LOAD_SCALE
1da177e4 767
2dd73a4f 768#ifdef CONFIG_SMP
1da177e4
LT		 769#define SD_LOAD_BALANCE 1 /* Do load balancing on this domain. */
770#define SD_BALANCE_NEWIDLE 2 /* Balance when about to become idle */
771#define SD_BALANCE_EXEC 4 /* Balance on exec */
147cbb4b
NP		 772#define SD_BALANCE_FORK 8 /* Balance on fork, clone */
773#define SD_WAKE_IDLE 16 /* Wake to idle CPU on task wakeup */
774#define SD_WAKE_AFFINE 32 /* Wake task to waking CPU */
775#define SD_WAKE_BALANCE 64 /* Perform balancing at task wakeup */
776#define SD_SHARE_CPUPOWER 128 /* Domain members share cpu power */
5c45bf27 777#define SD_POWERSAVINGS_BALANCE 256 /* Balance for power savings */
89c4710e 778#define SD_SHARE_PKG_RESOURCES 512 /* Domain members share cpu pkg resources */
08c183f3 779#define SD_SERIALIZE 1024 /* Only a single load balancing instance */
1d3504fc 780#define SD_WAKE_IDLE_FAR 2048 /* Gain latency sacrificing cache hit */
5c45bf27 781
afb8a9b7
GS		 782enum powersavings_balance_level {
783 POWERSAVINGS_BALANCE_NONE = 0, /* No power saving load balance */
784 POWERSAVINGS_BALANCE_BASIC, /* Fill one thread/core/package
785 * first for long running threads
786 */
787 POWERSAVINGS_BALANCE_WAKEUP, /* Also bias task wakeups to semi-idle
788 * cpu package for power savings
789 */
790 MAX_POWERSAVINGS_BALANCE_LEVELS
791};
89c4710e 792
716707b2 793extern int sched_mc_power_savings, sched_smt_power_savings;
89c4710e 794
716707b2
VS		 795static inline int sd_balance_for_mc_power(void)
796{
797 if (sched_smt_power_savings)
798 return SD_POWERSAVINGS_BALANCE;
5c45bf27 799
716707b2
VS		 800 return 0;
801}
89c4710e 802
716707b2
VS		 803static inline int sd_balance_for_package_power(void)
804{
805 if (sched_mc_power_savings | sched_smt_power_savings)
806 return SD_POWERSAVINGS_BALANCE;
807
808 return 0;
809}
5c45bf27 810
100fdaee
VS		 811/*
812 * Optimise SD flags for power savings:
813 * SD_BALANCE_NEWIDLE helps agressive task consolidation and power savings.
814 * Keep default SD flags if sched_{smt,mc}_power_saving=0
815 */
816
817static inline int sd_power_saving_flags(void)
818{
819 if (sched_mc_power_savings | sched_smt_power_savings)
820 return SD_BALANCE_NEWIDLE;
821
822 return 0;
823}
1da177e4
LT		 824
825struct sched_group {
826 struct sched_group *next; /* Must be a circular list */
1da177e4
LT		 827
828 /*
829 * CPU power of this group, SCHED_LOAD_SCALE being max power for a
830 * single CPU. This is read only (except for setup, hotplug CPU).
5517d86b 831 * Note : Never change cpu_power without recompute its reciprocal
1da177e4 832 */
5517d86b
ED		 833 unsigned int __cpu_power;
834 /*
835 * reciprocal value of cpu_power to avoid expensive divides
836 * (see include/linux/reciprocal_div.h)
837 */
838 u32 reciprocal_cpu_power;
6c99e9ad
RR		 839
840 unsigned long cpumask[];
1da177e4
LT		 841};
842
758b2cdc
RR		 843static inline struct cpumask *sched_group_cpus(struct sched_group *sg)
844{
6c99e9ad 845 return to_cpumask(sg->cpumask);
758b2cdc
RR		 846}
847
1d3504fc
HS		 848enum sched_domain_level {
849 SD_LV_NONE = 0,
850 SD_LV_SIBLING,
851 SD_LV_MC,
852 SD_LV_CPU,
853 SD_LV_NODE,
854 SD_LV_ALLNODES,
855 SD_LV_MAX
856};
857
858struct sched_domain_attr {
859 int relax_domain_level;
860};
861
862#define SD_ATTR_INIT (struct sched_domain_attr) { \
863 .relax_domain_level = -1, \
864}
865
1da177e4
LT		 866struct sched_domain {
867 /* These fields must be setup */
868 struct sched_domain *parent; /* top domain must be null terminated */
1a848870 869 struct sched_domain *child; /* bottom domain must be null terminated */
1da177e4 870 struct sched_group *groups; /* the balancing groups of the domain */
1da177e4
LT		 871 unsigned long min_interval; /* Minimum balance interval ms */
872 unsigned long max_interval; /* Maximum balance interval ms */
873 unsigned int busy_factor; /* less balancing by factor if busy */
874 unsigned int imbalance_pct; /* No balance until over watermark */
1da177e4 875 unsigned int cache_nice_tries; /* Leave cache hot tasks for # tries */
7897986b
NP		 876 unsigned int busy_idx;
877 unsigned int idle_idx;
878 unsigned int newidle_idx;
879 unsigned int wake_idx;
147cbb4b 880 unsigned int forkexec_idx;
1da177e4 881 int flags; /* See SD_* */
1d3504fc 882 enum sched_domain_level level;
1da177e4
LT		 883
884 /* Runtime fields. */
885 unsigned long last_balance; /* init to jiffies. units in jiffies */
886 unsigned int balance_interval; /* initialise to 1. units in ms. */
887 unsigned int nr_balance_failed; /* initialise to 0 */
888
2398f2c6
PZ		 889 u64 last_update;
890
1da177e4
LT		 891#ifdef CONFIG_SCHEDSTATS
892 /* load_balance() stats */
480b9434
KC		 893 unsigned int lb_count[CPU_MAX_IDLE_TYPES];
894 unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
895 unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
896 unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
897 unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
898 unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
899 unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
900 unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
1da177e4
LT		 901
902 /* Active load balancing */
480b9434
KC		 903 unsigned int alb_count;
904 unsigned int alb_failed;
905 unsigned int alb_pushed;
1da177e4 906
68767a0a 907 /* SD_BALANCE_EXEC stats */
480b9434
KC		 908 unsigned int sbe_count;
909 unsigned int sbe_balanced;
910 unsigned int sbe_pushed;
1da177e4 911
68767a0a 912 /* SD_BALANCE_FORK stats */
480b9434
KC		 913 unsigned int sbf_count;
914 unsigned int sbf_balanced;
915 unsigned int sbf_pushed;
68767a0a 916
1da177e4 917 /* try_to_wake_up() stats */
480b9434
KC		 918 unsigned int ttwu_wake_remote;
919 unsigned int ttwu_move_affine;
920 unsigned int ttwu_move_balance;
1da177e4 921#endif
a5d8c348
IM		 922#ifdef CONFIG_SCHED_DEBUG
923 char *name;
924#endif
6c99e9ad
RR		 925
926 /* span of all CPUs in this domain */
927 unsigned long span[];
1da177e4
LT		 928};
929
758b2cdc
RR		 930static inline struct cpumask *sched_domain_span(struct sched_domain *sd)
931{
6c99e9ad 932 return to_cpumask(sd->span);
758b2cdc
RR		 933}
934
96f874e2 935extern void partition_sched_domains(int ndoms_new, struct cpumask *doms_new,
1d3504fc 936 struct sched_domain_attr *dattr_new);
029190c5 937
06aaf76a
IM		 938/* Test a flag in parent sched domain */
939static inline int test_sd_parent(struct sched_domain *sd, int flag)
940{
941 if (sd->parent && (sd->parent->flags & flag))
942 return 1;
943
944 return 0;
945}
029190c5 946
1b427c15 947#else /* CONFIG_SMP */
1da177e4 948
1b427c15 949struct sched_domain_attr;
d02c7a8c 950
1b427c15 951static inline void
96f874e2 952partition_sched_domains(int ndoms_new, struct cpumask *doms_new,
1b427c15
IM		 953 struct sched_domain_attr *dattr_new)
954{
d02c7a8c 955}
1b427c15 956#endif /* !CONFIG_SMP */
1da177e4
LT		 957
958struct io_context; /* See blkdev.h */
1da177e4 959
1da177e4 960
383f2835 961#ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
36c8b586 962extern void prefetch_stack(struct task_struct *t);
383f2835
KC		 963#else
964static inline void prefetch_stack(struct task_struct *t) { }
965#endif
1da177e4
LT		 966
967struct audit_context; /* See audit.c */
968struct mempolicy;
b92ce558 969struct pipe_inode_info;
4865ecf1 970struct uts_namespace;
1da177e4 971
20b8a59f
IM		 972struct rq;
973struct sched_domain;
974
975struct sched_class {
5522d5d5 976 const struct sched_class *next;
20b8a59f 977
fd390f6a 978 void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup);
f02231e5 979 void (*dequeue_task) (struct rq *rq, struct task_struct *p, int sleep);
4530d7ab 980 void (*yield_task) (struct rq *rq);
20b8a59f 981
15afe09b 982 void (*check_preempt_curr) (struct rq *rq, struct task_struct *p, int sync);
20b8a59f 983
fb8d4724 984 struct task_struct * (*pick_next_task) (struct rq *rq);
31ee529c 985 void (*put_prev_task) (struct rq *rq, struct task_struct *p);
20b8a59f 986
681f3e68 987#ifdef CONFIG_SMP
4ce72a2c
LZ		 988 int (*select_task_rq)(struct task_struct *p, int sync);
989
43010659 990 unsigned long (*load_balance) (struct rq *this_rq, int this_cpu,
e1d1484f 991 struct rq *busiest, unsigned long max_load_move,
20b8a59f 992 struct sched_domain *sd, enum cpu_idle_type idle,
a4ac01c3 993 int *all_pinned, int *this_best_prio);
20b8a59f 994
e1d1484f
PW		 995 int (*move_one_task) (struct rq *this_rq, int this_cpu,
996 struct rq *busiest, struct sched_domain *sd,
997 enum cpu_idle_type idle);
9a897c5a 998 void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
967fc046 999 int (*needs_post_schedule) (struct rq *this_rq);
9a897c5a
SR		 1000 void (*post_schedule) (struct rq *this_rq);
1001 void (*task_wake_up) (struct rq *this_rq, struct task_struct *task);
e1d1484f 1002
cd8ba7cd 1003 void (*set_cpus_allowed)(struct task_struct *p,
96f874e2 1004 const struct cpumask *newmask);
57d885fe 1005
1f11eb6a
GH		 1006 void (*rq_online)(struct rq *rq);
1007 void (*rq_offline)(struct rq *rq);
4ce72a2c
LZ		 1008#endif
1009
1010 void (*set_curr_task) (struct rq *rq);
1011 void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
1012 void (*task_new) (struct rq *rq, struct task_struct *p);
cb469845
SR		 1013
1014 void (*switched_from) (struct rq *this_rq, struct task_struct *task,
1015 int running);
1016 void (*switched_to) (struct rq *this_rq, struct task_struct *task,
1017 int running);
1018 void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
1019 int oldprio, int running);
810b3817
PZ		 1020
1021#ifdef CONFIG_FAIR_GROUP_SCHED
1022 void (*moved_group) (struct task_struct *p);
1023#endif
20b8a59f
IM		 1024};
1025
1026struct load_weight {
1027 unsigned long weight, inv_weight;
1028};
1029
1030/*
1031 * CFS stats for a schedulable entity (task, task-group etc)
1032 *
1033 * Current field usage histogram:
1034 *
1035 * 4 se->block_start
1036 * 4 se->run_node
1037 * 4 se->sleep_start
20b8a59f 1038 * 6 se->load.weight
20b8a59f
IM		 1039 */
1040struct sched_entity {
20b8a59f
IM		 1041 struct load_weight load; /* for load-balancing */
1042 struct rb_node run_node;
4a55bd5e 1043 struct list_head group_node;
20b8a59f
IM		 1044 unsigned int on_rq;
1045
94c18227
IM		 1046 u64 exec_start;
1047 u64 sum_exec_runtime;
e9acbff6 1048 u64 vruntime;
f6cf891c 1049 u64 prev_sum_exec_runtime;
94c18227 1050
4ae7d5ce
IM		 1051 u64 last_wakeup;
1052 u64 avg_overlap;
1053
34cb6135
IM		 1054 u64 start_runtime;
1055 u64 avg_wakeup;
1056 u64 nr_migrations;
1057
94c18227 1058#ifdef CONFIG_SCHEDSTATS
20b8a59f 1059 u64 wait_start;
94c18227 1060 u64 wait_max;
6d082592
AV		 1061 u64 wait_count;
1062 u64 wait_sum;
94c18227 1063
20b8a59f 1064 u64 sleep_start;
20b8a59f 1065 u64 sleep_max;
94c18227
IM		 1066 s64 sum_sleep_runtime;
1067
1068 u64 block_start;
20b8a59f
IM		 1069 u64 block_max;
1070 u64 exec_max;
eba1ed4b 1071 u64 slice_max;
cc367732 1072
cc367732
IM		 1073 u64 nr_migrations_cold;
1074 u64 nr_failed_migrations_affine;
1075 u64 nr_failed_migrations_running;
1076 u64 nr_failed_migrations_hot;
1077 u64 nr_forced_migrations;
1078 u64 nr_forced2_migrations;
1079
1080 u64 nr_wakeups;
1081 u64 nr_wakeups_sync;
1082 u64 nr_wakeups_migrate;
1083 u64 nr_wakeups_local;
1084 u64 nr_wakeups_remote;
1085 u64 nr_wakeups_affine;
1086 u64 nr_wakeups_affine_attempts;
1087 u64 nr_wakeups_passive;
1088 u64 nr_wakeups_idle;
94c18227
IM		 1089#endif
1090
20b8a59f
IM		 1091#ifdef CONFIG_FAIR_GROUP_SCHED
1092 struct sched_entity *parent;
1093 /* rq on which this entity is (to be) queued: */
1094 struct cfs_rq *cfs_rq;
1095 /* rq "owned" by this entity/group: */
1096 struct cfs_rq *my_q;
1097#endif
1098};
70b97a7f 1099
fa717060
PZ		 1100struct sched_rt_entity {
1101 struct list_head run_list;
78f2c7db 1102 unsigned long timeout;
bee367ed 1103 unsigned int time_slice;
6f505b16
PZ		 1104 int nr_cpus_allowed;
1105
58d6c2d7 1106 struct sched_rt_entity *back;
052f1dc7 1107#ifdef CONFIG_RT_GROUP_SCHED
6f505b16
PZ		 1108 struct sched_rt_entity *parent;
1109 /* rq on which this entity is (to be) queued: */
1110 struct rt_rq *rt_rq;
1111 /* rq "owned" by this entity/group: */
1112 struct rt_rq *my_q;
1113#endif
fa717060
PZ		 1114};
1115
1da177e4
LT		 1116struct task_struct {
1117 volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
f7e4217b 1118 void *stack;
1da177e4 1119 atomic_t usage;
97dc32cd
WC		 1120 unsigned int flags; /* per process flags, defined below */
1121 unsigned int ptrace;
1da177e4 1122
36772092 1123 int lock_depth; /* BKL lock depth */
1da177e4 1124
2dd73a4f
PW		 1125#ifdef CONFIG_SMP
1126#ifdef __ARCH_WANT_UNLOCKED_CTXSW
4866cde0
NP		 1127 int oncpu;
1128#endif
2dd73a4f 1129#endif
50e645a8 1130
b29739f9 1131 int prio, static_prio, normal_prio;
c7aceaba 1132 unsigned int rt_priority;
5522d5d5 1133 const struct sched_class *sched_class;
20b8a59f 1134 struct sched_entity se;
fa717060 1135 struct sched_rt_entity rt;
1da177e4 1136
e107be36
AK		 1137#ifdef CONFIG_PREEMPT_NOTIFIERS
1138 /* list of struct preempt_notifier: */
1139 struct hlist_head preempt_notifiers;
1140#endif
1141
18796aa0
AD		 1142 /*
1143 * fpu_counter contains the number of consecutive context switches
1144 * that the FPU is used. If this is over a threshold, the lazy fpu
1145 * saving becomes unlazy to save the trap. This is an unsigned char
1146 * so that after 256 times the counter wraps and the behavior turns
1147 * lazy again; this to deal with bursty apps that only use FPU for
1148 * a short time
1149 */
1150 unsigned char fpu_counter;
1151 s8 oomkilladj; /* OOM kill score adjustment (bit shift). */
6c5c9341 1152#ifdef CONFIG_BLK_DEV_IO_TRACE
2056a782 1153 unsigned int btrace_seq;
6c5c9341 1154#endif
1da177e4 1155
97dc32cd 1156 unsigned int policy;
1da177e4 1157 cpumask_t cpus_allowed;
1da177e4 1158
e260be67
PM		 1159#ifdef CONFIG_PREEMPT_RCU
1160 int rcu_read_lock_nesting;
1161 int rcu_flipctr_idx;
1162#endif /* #ifdef CONFIG_PREEMPT_RCU */
1163
52f17b6c 1164#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
1da177e4
LT		 1165 struct sched_info sched_info;
1166#endif
1167
1168 struct list_head tasks;
917b627d 1169 struct plist_node pushable_tasks;
1da177e4
LT		 1170
1171 struct mm_struct *mm, *active_mm;
1172
1173/* task state */
1174 struct linux_binfmt *binfmt;
97dc32cd 1175 int exit_state;
1da177e4
LT		 1176 int exit_code, exit_signal;
1177 int pdeath_signal; /* The signal sent when the parent dies */
1178 /* ??? */
97dc32cd 1179 unsigned int personality;
1da177e4 1180 unsigned did_exec:1;
f9ce1f1c
KT		 1181 unsigned in_execve:1; /* Tell the LSMs that the process is doing an
1182 * execve */
1da177e4
LT		 1183 pid_t pid;
1184 pid_t tgid;
0a425405 1185
0a425405
AV		 1186 /* Canary value for the -fstack-protector gcc feature */
1187 unsigned long stack_canary;
e0032087 1188
1da177e4
LT		 1189 /*
1190 * pointers to (original) parent process, youngest child, younger sibling,
1191 * older sibling, respectively. (p->father can be replaced with
f470021a 1192 * p->real_parent->pid)
1da177e4 1193 */
f470021a
RM		 1194 struct task_struct *real_parent; /* real parent process */
1195 struct task_struct *parent; /* recipient of SIGCHLD, wait4() reports */
1da177e4 1196 /*
f470021a 1197 * children/sibling forms the list of my natural children
1da177e4
LT		 1198 */
1199 struct list_head children; /* list of my children */
1200 struct list_head sibling; /* linkage in my parent's children list */
1201 struct task_struct *group_leader; /* threadgroup leader */
1202
f470021a
RM		 1203 /*
1204 * ptraced is the list of tasks this task is using ptrace on.
1205 * This includes both natural children and PTRACE_ATTACH targets.
1206 * p->ptrace_entry is p's link on the p->parent->ptraced list.
1207 */
1208 struct list_head ptraced;
1209 struct list_head ptrace_entry;
1210
ca0002a1
MM		 1211#ifdef CONFIG_X86_PTRACE_BTS
1212 /*
1213 * This is the tracer handle for the ptrace BTS extension.
1214 * This field actually belongs to the ptracer task.
1215 */
1216 struct bts_tracer *bts;
6abb11ae
MM		 1217 /*
1218 * The buffer to hold the BTS data.
1219 */
1220 void *bts_buffer;
c2724775 1221 size_t bts_size;
ca0002a1
MM		 1222#endif /* CONFIG_X86_PTRACE_BTS */
1223
1da177e4 1224 /* PID/PID hash table linkage. */
92476d7f 1225 struct pid_link pids[PIDTYPE_MAX];
47e65328 1226 struct list_head thread_group;
1da177e4
LT		 1227
1228 struct completion *vfork_done; /* for vfork() */
1229 int __user *set_child_tid; /* CLONE_CHILD_SETTID */
1230 int __user *clear_child_tid; /* CLONE_CHILD_CLEARTID */
1231
c66f08be 1232 cputime_t utime, stime, utimescaled, stimescaled;
9ac52315 1233 cputime_t gtime;
9301899b 1234 cputime_t prev_utime, prev_stime;
1da177e4 1235 unsigned long nvcsw, nivcsw; /* context switch counts */
924b42d5
TJ		 1236 struct timespec start_time; /* monotonic time */
1237 struct timespec real_start_time; /* boot based time */
1da177e4
LT		 1238/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
1239 unsigned long min_flt, maj_flt;
1240
f06febc9 1241 struct task_cputime cputime_expires;
1da177e4
LT		 1242 struct list_head cpu_timers[3];
1243
1244/* process credentials */
3b11a1de
DH		 1245 const struct cred *real_cred; /* objective and real subjective task
1246 * credentials (COW) */
1247 const struct cred *cred; /* effective (overridable) subjective task
1248 * credentials (COW) */
d84f4f99 1249 struct mutex cred_exec_mutex; /* execve vs ptrace cred calculation mutex */
b6dff3ec 1250
36772092
PBG		 1251 char comm[TASK_COMM_LEN]; /* executable name excluding path
1252 - access with [gs]et_task_comm (which lock
1253 it with task_lock())
1254 - initialized normally by flush_old_exec */
1da177e4
LT		 1255/* file system info */
1256 int link_count, total_link_count;
3d5b6fcc 1257#ifdef CONFIG_SYSVIPC
1da177e4
LT		 1258/* ipc stuff */
1259 struct sysv_sem sysvsem;
3d5b6fcc 1260#endif
e162b39a 1261#ifdef CONFIG_DETECT_HUNG_TASK
82a1fcb9 1262/* hung task detection */
82a1fcb9
IM		 1263 unsigned long last_switch_count;
1264#endif
1da177e4
LT		 1265/* CPU-specific state of this task */
1266 struct thread_struct thread;
1267/* filesystem information */
1268 struct fs_struct *fs;
1269/* open file information */
1270 struct files_struct *files;
1651e14e 1271/* namespaces */
ab516013 1272 struct nsproxy *nsproxy;
1da177e4
LT		 1273/* signal handlers */
1274 struct signal_struct *signal;
1275 struct sighand_struct *sighand;
1276
1277 sigset_t blocked, real_blocked;
f3de272b 1278 sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
1da177e4
LT		 1279 struct sigpending pending;
1280
1281 unsigned long sas_ss_sp;
1282 size_t sas_ss_size;
1283 int (*notifier)(void *priv);
1284 void *notifier_data;
1285 sigset_t *notifier_mask;
1da177e4 1286 struct audit_context *audit_context;
bfef93a5
AV		 1287#ifdef CONFIG_AUDITSYSCALL
1288 uid_t loginuid;
4746ec5b 1289 unsigned int sessionid;
bfef93a5 1290#endif
1da177e4
LT		 1291 seccomp_t seccomp;
1292
1293/* Thread group tracking */
1294 u32 parent_exec_id;
1295 u32 self_exec_id;
1296/* Protection of (de-)allocation: mm, files, fs, tty, keyrings */
1297 spinlock_t alloc_lock;
1da177e4 1298
3aa551c9
TG		 1299#ifdef CONFIG_GENERIC_HARDIRQS
1300 /* IRQ handler threads */
1301 struct irqaction *irqaction;
1302#endif
1303
b29739f9
IM		 1304 /* Protection of the PI data structures: */
1305 spinlock_t pi_lock;
1306
23f78d4a
IM		 1307#ifdef CONFIG_RT_MUTEXES
1308 /* PI waiters blocked on a rt_mutex held by this task */
1309 struct plist_head pi_waiters;
1310 /* Deadlock detection and priority inheritance handling */
1311 struct rt_mutex_waiter *pi_blocked_on;
23f78d4a
IM		 1312#endif
1313
408894ee
IM		 1314#ifdef CONFIG_DEBUG_MUTEXES
1315 /* mutex deadlock detection */
1316 struct mutex_waiter *blocked_on;
1317#endif
de30a2b3
IM		 1318#ifdef CONFIG_TRACE_IRQFLAGS
1319 unsigned int irq_events;
1320 int hardirqs_enabled;
1321 unsigned long hardirq_enable_ip;
1322 unsigned int hardirq_enable_event;
1323 unsigned long hardirq_disable_ip;
1324 unsigned int hardirq_disable_event;
1325 int softirqs_enabled;
1326 unsigned long softirq_disable_ip;
1327 unsigned int softirq_disable_event;
1328 unsigned long softirq_enable_ip;
1329 unsigned int softirq_enable_event;
1330 int hardirq_context;
1331 int softirq_context;
1332#endif
fbb9ce95 1333#ifdef CONFIG_LOCKDEP
bdb9441e 1334# define MAX_LOCK_DEPTH 48UL
fbb9ce95
IM		 1335 u64 curr_chain_key;
1336 int lockdep_depth;
fbb9ce95 1337 unsigned int lockdep_recursion;
c7aceaba 1338 struct held_lock held_locks[MAX_LOCK_DEPTH];
cf40bd16 1339 gfp_t lockdep_reclaim_gfp;
fbb9ce95 1340#endif
408894ee 1341
1da177e4
LT		 1342/* journalling filesystem info */
1343 void *journal_info;
1344
d89d8796
NB		 1345/* stacked block device info */
1346 struct bio *bio_list, **bio_tail;
1347
1da177e4
LT		 1348/* VM state */
1349 struct reclaim_state *reclaim_state;
1350
1da177e4
LT		 1351 struct backing_dev_info *backing_dev_info;
1352
1353 struct io_context *io_context;
1354
1355 unsigned long ptrace_message;
1356 siginfo_t *last_siginfo; /* For ptrace use. */
7c3ab738 1357 struct task_io_accounting ioac;
8f0ab514 1358#if defined(CONFIG_TASK_XACCT)
1da177e4
LT		 1359 u64 acct_rss_mem1; /* accumulated rss usage */
1360 u64 acct_vm_mem1; /* accumulated virtual memory usage */
49b5cf34 1361 cputime_t acct_timexpd; /* stime + utime since last update */
1da177e4
LT		 1362#endif
1363#ifdef CONFIG_CPUSETS
1da177e4
LT		 1364 nodemask_t mems_allowed;
1365 int cpuset_mems_generation;
825a46af 1366 int cpuset_mem_spread_rotor;
1da177e4 1367#endif
ddbcc7e8 1368#ifdef CONFIG_CGROUPS
817929ec
PM		 1369 /* Control Group info protected by css_set_lock */
1370 struct css_set *cgroups;
1371 /* cg_list protected by css_set_lock and tsk->alloc_lock */
1372 struct list_head cg_list;
ddbcc7e8 1373#endif
42b2dd0a 1374#ifdef CONFIG_FUTEX
0771dfef 1375 struct robust_list_head __user *robust_list;
34f192c6
IM		 1376#ifdef CONFIG_COMPAT
1377 struct compat_robust_list_head __user *compat_robust_list;
1378#endif
c87e2837
IM		 1379 struct list_head pi_state_list;
1380 struct futex_pi_state *pi_state_cache;
c7aceaba
RK		 1381#endif
1382#ifdef CONFIG_NUMA
1383 struct mempolicy *mempolicy;
1384 short il_next;
42b2dd0a 1385#endif
22e2c507 1386 atomic_t fs_excl; /* holding fs exclusive resources */
e56d0903 1387 struct rcu_head rcu;
b92ce558
JA		 1388
1389 /*
1390 * cache last used pipe for splice
1391 */
1392 struct pipe_inode_info *splice_pipe;
ca74e92b
SN		 1393#ifdef CONFIG_TASK_DELAY_ACCT
1394 struct task_delay_info *delays;
f4f154fd
AM		 1395#endif
1396#ifdef CONFIG_FAULT_INJECTION
1397 int make_it_fail;
ca74e92b 1398#endif
3e26c149 1399 struct prop_local_single dirties;
9745512c
AV		 1400#ifdef CONFIG_LATENCYTOP
1401 int latency_record_count;
1402 struct latency_record latency_record[LT_SAVECOUNT];
1403#endif
6976675d
AV		 1404 /*
1405 * time slack values; these are used to round up poll() and
1406 * select() etc timeout values. These are in nanoseconds.
1407 */
1408 unsigned long timer_slack_ns;
1409 unsigned long default_timer_slack_ns;
f8d570a4
DM		 1410
1411 struct list_head *scm_work_list;
fb52607a 1412#ifdef CONFIG_FUNCTION_GRAPH_TRACER
f201ae23
FW		 1413 /* Index of current stored adress in ret_stack */
1414 int curr_ret_stack;
1415 /* Stack of return addresses for return function tracing */
1416 struct ftrace_ret_stack *ret_stack;
8aef2d28
SR		 1417 /* time stamp for last schedule */
1418 unsigned long long ftrace_timestamp;
f201ae23
FW		 1419 /*
1420 * Number of functions that haven't been traced
1421 * because of depth overrun.
1422 */
1423 atomic_t trace_overrun;
380c4b14
FW		 1424 /* Pause for the tracing */
1425 atomic_t tracing_graph_pause;
f201ae23 1426#endif
ea4e2bc4
SR		 1427#ifdef CONFIG_TRACING
1428 /* state flags for use by tracers */
1429 unsigned long trace;
9745512c 1430#endif
1da177e4
LT		 1431};
1432
76e6eee0
RR		 1433/* Future-safe accessor for struct task_struct's cpus_allowed. */
1434#define tsk_cpumask(tsk) (&(tsk)->cpus_allowed)
1435
e05606d3
IM		 1436/*
1437 * Priority of a process goes from 0..MAX_PRIO-1, valid RT
1438 * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
1439 * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
1440 * values are inverted: lower p->prio value means higher priority.
1441 *
1442 * The MAX_USER_RT_PRIO value allows the actual maximum
1443 * RT priority to be separate from the value exported to
1444 * user-space. This allows kernel threads to set their
1445 * priority to a value higher than any user task. Note:
1446 * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
1447 */
1448
1449#define MAX_USER_RT_PRIO 100
1450#define MAX_RT_PRIO MAX_USER_RT_PRIO
1451
1452#define MAX_PRIO (MAX_RT_PRIO + 40)
1453#define DEFAULT_PRIO (MAX_RT_PRIO + 20)
1454
1455static inline int rt_prio(int prio)
1456{
1457 if (unlikely(prio < MAX_RT_PRIO))
1458 return 1;
1459 return 0;
1460}
1461
e868171a 1462static inline int rt_task(struct task_struct *p)
e05606d3
IM		 1463{
1464 return rt_prio(p->prio);
1465}
1466
e868171a 1467static inline struct pid *task_pid(struct task_struct *task)
22c935f4
EB		 1468{
1469 return task->pids[PIDTYPE_PID].pid;
1470}
1471
e868171a 1472static inline struct pid *task_tgid(struct task_struct *task)
22c935f4
EB		 1473{
1474 return task->group_leader->pids[PIDTYPE_PID].pid;
1475}
1476
6dda81f4
ON		 1477/*
1478 * Without tasklist or rcu lock it is not safe to dereference
1479 * the result of task_pgrp/task_session even if task == current,
1480 * we can race with another thread doing sys_setsid/sys_setpgid.
1481 */
e868171a 1482static inline struct pid *task_pgrp(struct task_struct *task)
22c935f4
EB		 1483{
1484 return task->group_leader->pids[PIDTYPE_PGID].pid;
1485}
1486
e868171a 1487static inline struct pid *task_session(struct task_struct *task)
22c935f4
EB		 1488{
1489 return task->group_leader->pids[PIDTYPE_SID].pid;
1490}
1491
7af57294
PE		 1492struct pid_namespace;
1493
1494/*
1495 * the helpers to get the task's different pids as they are seen
1496 * from various namespaces
1497 *
1498 * task_xid_nr() : global id, i.e. the id seen from the init namespace;
44c4e1b2
EB		 1499 * task_xid_vnr() : virtual id, i.e. the id seen from the pid namespace of
1500 * current.
7af57294
PE		 1501 * task_xid_nr_ns() : id seen from the ns specified;
1502 *
1503 * set_task_vxid() : assigns a virtual id to a task;
1504 *
7af57294
PE		 1505 * see also pid_nr() etc in include/linux/pid.h
1506 */
52ee2dfd
ON		 1507pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
1508 struct pid_namespace *ns);
7af57294 1509
e868171a 1510static inline pid_t task_pid_nr(struct task_struct *tsk)
7af57294
PE		 1511{
1512 return tsk->pid;
1513}
1514
52ee2dfd
ON		 1515static inline pid_t task_pid_nr_ns(struct task_struct *tsk,
1516 struct pid_namespace *ns)
1517{
1518 return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
1519}
7af57294
PE		 1520
1521static inline pid_t task_pid_vnr(struct task_struct *tsk)
1522{
52ee2dfd 1523 return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
7af57294
PE		 1524}
1525
1526
e868171a 1527static inline pid_t task_tgid_nr(struct task_struct *tsk)
7af57294
PE		 1528{
1529 return tsk->tgid;
1530}
1531
2f2a3a46 1532pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
7af57294
PE		 1533
1534static inline pid_t task_tgid_vnr(struct task_struct *tsk)
1535{
1536 return pid_vnr(task_tgid(tsk));
1537}
1538
1539
52ee2dfd
ON		 1540static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,
1541 struct pid_namespace *ns)
7af57294 1542{
52ee2dfd 1543 return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
7af57294
PE		 1544}
1545
7af57294
PE		 1546static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
1547{
52ee2dfd 1548 return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);
7af57294
PE		 1549}
1550
1551
52ee2dfd
ON		 1552static inline pid_t task_session_nr_ns(struct task_struct *tsk,
1553 struct pid_namespace *ns)
7af57294 1554{
52ee2dfd 1555 return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
7af57294
PE		 1556}
1557
7af57294
PE		 1558static inline pid_t task_session_vnr(struct task_struct *tsk)
1559{
52ee2dfd 1560 return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
7af57294
PE		 1561}
1562
1b0f7ffd
ON		 1563/* obsolete, do not use */
1564static inline pid_t task_pgrp_nr(struct task_struct *tsk)
1565{
1566 return task_pgrp_nr_ns(tsk, &init_pid_ns);
1567}
7af57294 1568
1da177e4
LT		 1569/**
1570 * pid_alive - check that a task structure is not stale
1571 * @p: Task structure to be checked.
1572 *
1573 * Test if a process is not yet dead (at most zombie state)
1574 * If pid_alive fails, then pointers within the task structure
1575 * can be stale and must not be dereferenced.
1576 */
e868171a 1577static inline int pid_alive(struct task_struct *p)
1da177e4 1578{
92476d7f 1579 return p->pids[PIDTYPE_PID].pid != NULL;
1da177e4
LT		 1580}
1581
f400e198 1582/**
b460cbc5 1583 * is_global_init - check if a task structure is init
3260259f
HK		 1584 * @tsk: Task structure to be checked.
1585 *
1586 * Check if a task structure is the first user space task the kernel created.
b460cbc5 1587 */
e868171a 1588static inline int is_global_init(struct task_struct *tsk)
b461cc03
PE		 1589{
1590 return tsk->pid == 1;
1591}
b460cbc5
SH		 1592
1593/*
1594 * is_container_init:
1595 * check whether in the task is init in its own pid namespace.
f400e198 1596 */
b461cc03 1597extern int is_container_init(struct task_struct *tsk);
f400e198 1598
9ec52099
CLG		 1599extern struct pid *cad_pid;
1600
1da177e4 1601extern void free_task(struct task_struct *tsk);
1da177e4 1602#define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
e56d0903 1603
158d9ebd 1604extern void __put_task_struct(struct task_struct *t);
e56d0903
IM		 1605
1606static inline void put_task_struct(struct task_struct *t)
1607{
1608 if (atomic_dec_and_test(&t->usage))
8c7904a0 1609 __put_task_struct(t);
e56d0903 1610}
1da177e4 1611
49048622
BS		 1612extern cputime_t task_utime(struct task_struct *p);
1613extern cputime_t task_stime(struct task_struct *p);
1614extern cputime_t task_gtime(struct task_struct *p);
1615
1da177e4
LT		 1616/*
1617 * Per process flags
1618 */
1619#define PF_ALIGNWARN 0x00000001 /* Print alignment warning msgs */
1620 /* Not implemented yet, only for 486*/
1621#define PF_STARTING 0x00000002 /* being created */
1622#define PF_EXITING 0x00000004 /* getting shut down */
778e9a9c 1623#define PF_EXITPIDONE 0x00000008 /* pi exit done on shut down */
94886b84 1624#define PF_VCPU 0x00000010 /* I'm a virtual CPU */
1da177e4
LT		 1625#define PF_FORKNOEXEC 0x00000040 /* forked but didn't exec */
1626#define PF_SUPERPRIV 0x00000100 /* used super-user privileges */
1627#define PF_DUMPCORE 0x00000200 /* dumped core */
1628#define PF_SIGNALED 0x00000400 /* killed by a signal */
1629#define PF_MEMALLOC 0x00000800 /* Allocating memory */
1630#define PF_FLUSHER 0x00001000 /* responsible for disk writeback */
1631#define PF_USED_MATH 0x00002000 /* if unset the fpu must be initialized before use */
1da177e4
LT		 1632#define PF_NOFREEZE 0x00008000 /* this thread should not be frozen */
1633#define PF_FROZEN 0x00010000 /* frozen for system suspend */
1634#define PF_FSTRANS 0x00020000 /* inside a filesystem transaction */
1635#define PF_KSWAPD 0x00040000 /* I am kswapd */
1636#define PF_SWAPOFF 0x00080000 /* I am in swapoff */
1637#define PF_LESS_THROTTLE 0x00100000 /* Throttle me less: I clean memory */
246bb0b1 1638#define PF_KTHREAD 0x00200000 /* I am a kernel thread */
b31dc66a
JA		 1639#define PF_RANDOMIZE 0x00400000 /* randomize virtual address space */
1640#define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */
1641#define PF_SPREAD_PAGE 0x01000000 /* Spread page cache over cpuset */
1642#define PF_SPREAD_SLAB 0x02000000 /* Spread some slab caches over cpuset */
9985b0ba 1643#define PF_THREAD_BOUND 0x04000000 /* Thread bound to specific cpu */
c61afb18 1644#define PF_MEMPOLICY 0x10000000 /* Non-default NUMA mempolicy */
61a87122 1645#define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */
ba96a0c8 1646#define PF_FREEZER_SKIP 0x40000000 /* Freezer should not count it as freezeable */
ebb12db5 1647#define PF_FREEZER_NOSIG 0x80000000 /* Freezer won't send signals to it */
1da177e4
LT		 1648
1649/*
1650 * Only the _current_ task can read/write to tsk->flags, but other
1651 * tasks can access tsk->flags in readonly mode for example
1652 * with tsk_used_math (like during threaded core dumping).
1653 * There is however an exception to this rule during ptrace
1654 * or during fork: the ptracer task is allowed to write to the
1655 * child->flags of its traced child (same goes for fork, the parent
1656 * can write to the child->flags), because we're guaranteed the
1657 * child is not running and in turn not changing child->flags
1658 * at the same time the parent does it.
1659 */
1660#define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
1661#define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
1662#define clear_used_math() clear_stopped_child_used_math(current)
1663#define set_used_math() set_stopped_child_used_math(current)
1664#define conditional_stopped_child_used_math(condition, child) \
1665 do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
1666#define conditional_used_math(condition) \
1667 conditional_stopped_child_used_math(condition, current)
1668#define copy_to_stopped_child_used_math(child) \
1669 do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
1670/* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
1671#define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
1672#define used_math() tsk_used_math(current)
1673
1674#ifdef CONFIG_SMP
cd8ba7cd 1675extern int set_cpus_allowed_ptr(struct task_struct *p,
96f874e2 1676 const struct cpumask *new_mask);
1da177e4 1677#else
cd8ba7cd 1678static inline int set_cpus_allowed_ptr(struct task_struct *p,
96f874e2 1679 const struct cpumask *new_mask)
1da177e4 1680{
96f874e2 1681 if (!cpumask_test_cpu(0, new_mask))
1da177e4
LT		 1682 return -EINVAL;
1683 return 0;
1684}
1685#endif
cd8ba7cd
MT		 1686static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
1687{
1688 return set_cpus_allowed_ptr(p, &new_mask);
1689}
1da177e4 1690
b342501c
IM		 1691/*
1692 * Architectures can set this to 1 if they have specified
1693 * CONFIG_HAVE_UNSTABLE_SCHED_CLOCK in their arch Kconfig,
1694 * but then during bootup it turns out that sched_clock()
1695 * is reliable after all:
1696 */
1697#ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
1698extern int sched_clock_stable;
1699#endif
1700
1da177e4 1701extern unsigned long long sched_clock(void);
e436d800 1702
c1955a3d
PZ		 1703extern void sched_clock_init(void);
1704extern u64 sched_clock_cpu(int cpu);
3e51f33f 1705
c1955a3d 1706#ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
3e51f33f
PZ		 1707static inline void sched_clock_tick(void)
1708{
1709}
1710
1711static inline void sched_clock_idle_sleep_event(void)
1712{
1713}
1714
1715static inline void sched_clock_idle_wakeup_event(u64 delta_ns)
1716{
1717}
1718#else
3e51f33f
PZ		 1719extern void sched_clock_tick(void);
1720extern void sched_clock_idle_sleep_event(void);
1721extern void sched_clock_idle_wakeup_event(u64 delta_ns);
1722#endif
1723
e436d800
IM		 1724/*
1725 * For kernel-internal use: high-speed (but slightly incorrect) per-cpu
1726 * clock constructed from sched_clock():
1727 */
1728extern unsigned long long cpu_clock(int cpu);
1729
36c8b586 1730extern unsigned long long
41b86e9c 1731task_sched_runtime(struct task_struct *task);
f06febc9 1732extern unsigned long long thread_group_sched_runtime(struct task_struct *task);
1da177e4
LT		 1733
1734/* sched_exec is called by processes performing an exec */
1735#ifdef CONFIG_SMP
1736extern void sched_exec(void);
1737#else
1738#define sched_exec() {}
1739#endif
1740
2aa44d05
IM		 1741extern void sched_clock_idle_sleep_event(void);
1742extern void sched_clock_idle_wakeup_event(u64 delta_ns);
bb29ab26 1743
1da177e4
LT		 1744#ifdef CONFIG_HOTPLUG_CPU
1745extern void idle_task_exit(void);
1746#else
1747static inline void idle_task_exit(void) {}
1748#endif
1749
1750extern void sched_idle_next(void);
b29739f9 1751
06d8308c
TG		 1752#if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
1753extern void wake_up_idle_cpu(int cpu);
1754#else
1755static inline void wake_up_idle_cpu(int cpu) { }
1756#endif
1757
21805085 1758extern unsigned int sysctl_sched_latency;
b2be5e96 1759extern unsigned int sysctl_sched_min_granularity;
bf0f6f24 1760extern unsigned int sysctl_sched_wakeup_granularity;
47fea2ad
JSR		 1761extern unsigned int sysctl_sched_shares_ratelimit;
1762extern unsigned int sysctl_sched_shares_thresh;
1763#ifdef CONFIG_SCHED_DEBUG
bf0f6f24
IM		 1764extern unsigned int sysctl_sched_child_runs_first;
1765extern unsigned int sysctl_sched_features;
da84d961 1766extern unsigned int sysctl_sched_migration_cost;
b82d9fdd 1767extern unsigned int sysctl_sched_nr_migrate;
b2be5e96
PZ		 1768
1769int sched_nr_latency_handler(struct ctl_table *table, int write,
1770 struct file *file, void __user *buffer, size_t *length,
1771 loff_t *ppos);
2bd8e6d4 1772#endif
9f0c1e56
PZ		 1773extern unsigned int sysctl_sched_rt_period;
1774extern int sysctl_sched_rt_runtime;
2bd8e6d4 1775
d0b27fa7
PZ		 1776int sched_rt_handler(struct ctl_table *table, int write,
1777 struct file *filp, void __user *buffer, size_t *lenp,
1778 loff_t *ppos);
1779
2bd8e6d4 1780extern unsigned int sysctl_sched_compat_yield;
bf0f6f24 1781
b29739f9 1782#ifdef CONFIG_RT_MUTEXES
36c8b586
IM		 1783extern int rt_mutex_getprio(struct task_struct *p);
1784extern void rt_mutex_setprio(struct task_struct *p, int prio);
1785extern void rt_mutex_adjust_pi(struct task_struct *p);
b29739f9 1786#else
e868171a 1787static inline int rt_mutex_getprio(struct task_struct *p)
b29739f9
IM		 1788{
1789 return p->normal_prio;
1790}
95e02ca9 1791# define rt_mutex_adjust_pi(p) do { } while (0)
b29739f9
IM		 1792#endif
1793
36c8b586
IM		 1794extern void set_user_nice(struct task_struct *p, long nice);
1795extern int task_prio(const struct task_struct *p);
1796extern int task_nice(const struct task_struct *p);
1797extern int can_nice(const struct task_struct *p, const int nice);
1798extern int task_curr(const struct task_struct *p);
1da177e4
LT		 1799extern int idle_cpu(int cpu);
1800extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
961ccddd
RR		 1801extern int sched_setscheduler_nocheck(struct task_struct *, int,
1802 struct sched_param *);
36c8b586
IM		 1803extern struct task_struct *idle_task(int cpu);
1804extern struct task_struct *curr_task(int cpu);
1805extern void set_curr_task(int cpu, struct task_struct *p);
1da177e4
LT		 1806
1807void yield(void);
1808
1809/*
1810 * The default (Linux) execution domain.
1811 */
1812extern struct exec_domain default_exec_domain;
1813
1814union thread_union {
1815 struct thread_info thread_info;
1816 unsigned long stack[THREAD_SIZE/sizeof(long)];
1817};
1818
1819#ifndef __HAVE_ARCH_KSTACK_END
1820static inline int kstack_end(void *addr)
1821{
1822 /* Reliable end of stack detection:
1823 * Some APM bios versions misalign the stack
1824 */
1825 return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
1826}
1827#endif
1828
1829extern union thread_union init_thread_union;
1830extern struct task_struct init_task;
1831
1832extern struct mm_struct init_mm;
1833
198fe21b
PE		 1834extern struct pid_namespace init_pid_ns;
1835
1836/*
1837 * find a task by one of its numerical ids
1838 *
1839 * find_task_by_pid_type_ns():
1840 * it is the most generic call - it finds a task by all id,
1841 * type and namespace specified
1842 * find_task_by_pid_ns():
1843 * finds a task by its pid in the specified namespace
228ebcbe
PE		 1844 * find_task_by_vpid():
1845 * finds a task by its virtual pid
198fe21b 1846 *
e49859e7 1847 * see also find_vpid() etc in include/linux/pid.h
198fe21b
PE		 1848 */
1849
1850extern struct task_struct *find_task_by_pid_type_ns(int type, int pid,
1851 struct pid_namespace *ns);
1852
228ebcbe
PE		 1853extern struct task_struct *find_task_by_vpid(pid_t nr);
1854extern struct task_struct *find_task_by_pid_ns(pid_t nr,
1855 struct pid_namespace *ns);
198fe21b 1856
8520d7c7 1857extern void __set_special_pids(struct pid *pid);
1da177e4
LT		 1858
1859/* per-UID process charging. */
acce292c 1860extern struct user_struct * alloc_uid(struct user_namespace *, uid_t);
1da177e4
LT		 1861static inline struct user_struct *get_uid(struct user_struct *u)
1862{
1863 atomic_inc(&u->__count);
1864 return u;
1865}
1866extern void free_uid(struct user_struct *);
28f300d2 1867extern void release_uids(struct user_namespace *ns);
1da177e4
LT		 1868
1869#include <asm/current.h>
1870
3171a030 1871extern void do_timer(unsigned long ticks);
1da177e4 1872
b3c97528
HH		 1873extern int wake_up_state(struct task_struct *tsk, unsigned int state);
1874extern int wake_up_process(struct task_struct *tsk);
1875extern void wake_up_new_task(struct task_struct *tsk,
1876 unsigned long clone_flags);
1da177e4
LT		 1877#ifdef CONFIG_SMP
1878 extern void kick_process(struct task_struct *tsk);
1879#else
1880 static inline void kick_process(struct task_struct *tsk) { }
1881#endif
ad46c2c4
IM		 1882extern void sched_fork(struct task_struct *p, int clone_flags);
1883extern void sched_dead(struct task_struct *p);
1da177e4 1884
1da177e4
LT		 1885extern void proc_caches_init(void);
1886extern void flush_signals(struct task_struct *);
10ab825b 1887extern void ignore_signals(struct task_struct *);
1da177e4
LT		 1888extern void flush_signal_handlers(struct task_struct *, int force_default);
1889extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
1890
1891static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
1892{
1893 unsigned long flags;
1894 int ret;
1895
1896 spin_lock_irqsave(&tsk->sighand->siglock, flags);
1897 ret = dequeue_signal(tsk, mask, info);
1898 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
1899
1900 return ret;
1901}
1902
1903extern void block_all_signals(int (*notifier)(void *priv), void *priv,
1904 sigset_t *mask);
1905extern void unblock_all_signals(void);
1906extern void release_task(struct task_struct * p);
1907extern int send_sig_info(int, struct siginfo *, struct task_struct *);
1da177e4
LT		 1908extern int force_sigsegv(int, struct task_struct *);
1909extern int force_sig_info(int, struct siginfo *, struct task_struct *);
c4b92fc1 1910extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
c4b92fc1 1911extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
2425c08b 1912extern int kill_pid_info_as_uid(int, struct siginfo *, struct pid *, uid_t, uid_t, u32);
c4b92fc1
EB		 1913extern int kill_pgrp(struct pid *pid, int sig, int priv);
1914extern int kill_pid(struct pid *pid, int sig, int priv);
c3de4b38 1915extern int kill_proc_info(int, struct siginfo *, pid_t);
2b2a1ff6 1916extern int do_notify_parent(struct task_struct *, int);
1da177e4
LT		 1917extern void force_sig(int, struct task_struct *);
1918extern void force_sig_specific(int, struct task_struct *);
1919extern int send_sig(int, struct task_struct *, int);
1920extern void zap_other_threads(struct task_struct *p);
1da177e4
LT		 1921extern struct sigqueue *sigqueue_alloc(void);
1922extern void sigqueue_free(struct sigqueue *);
ac5c2153 1923extern int send_sigqueue(struct sigqueue *, struct task_struct *, int group);
9ac95f2f 1924extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
1da177e4
LT		 1925extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long);
1926
9ec52099
CLG		 1927static inline int kill_cad_pid(int sig, int priv)
1928{
1929 return kill_pid(cad_pid, sig, priv);
1930}
1931
1da177e4
LT		 1932/* These can be the second arg to send_sig_info/send_group_sig_info. */
1933#define SEND_SIG_NOINFO ((struct siginfo *) 0)
1934#define SEND_SIG_PRIV ((struct siginfo *) 1)
1935#define SEND_SIG_FORCED ((struct siginfo *) 2)
1936
621d3121
ON		 1937static inline int is_si_special(const struct siginfo *info)
1938{
1939 return info <= SEND_SIG_FORCED;
1940}
1941
1da177e4
LT		 1942/* True if we are on the alternate signal stack. */
1943
1944static inline int on_sig_stack(unsigned long sp)
1945{
1946 return (sp - current->sas_ss_sp < current->sas_ss_size);
1947}
1948
1949static inline int sas_ss_flags(unsigned long sp)
1950{
1951 return (current->sas_ss_size == 0 ? SS_DISABLE
1952 : on_sig_stack(sp) ? SS_ONSTACK : 0);
1953}
1954
1da177e4
LT		 1955/*
1956 * Routines for handling mm_structs
1957 */
1958extern struct mm_struct * mm_alloc(void);
1959
1960/* mmdrop drops the mm and the page tables */
b3c97528 1961extern void __mmdrop(struct mm_struct *);
1da177e4
LT		 1962static inline void mmdrop(struct mm_struct * mm)
1963{
6fb43d7b 1964 if (unlikely(atomic_dec_and_test(&mm->mm_count)))
1da177e4
LT		 1965 __mmdrop(mm);
1966}
1967
1968/* mmput gets rid of the mappings and all user-space */
1969extern void mmput(struct mm_struct *);
1970/* Grab a reference to a task's mm, if it is not already going away */
1971extern struct mm_struct *get_task_mm(struct task_struct *task);
1972/* Remove the current tasks stale references to the old mm_struct */
1973extern void mm_release(struct task_struct *, struct mm_struct *);
402b0862
CO		 1974/* Allocate a new mm structure and copy contents from tsk->mm */
1975extern struct mm_struct *dup_mm(struct task_struct *tsk);
1da177e4 1976
6f2c55b8
AD		 1977extern int copy_thread(unsigned long, unsigned long, unsigned long,
1978 struct task_struct *, struct pt_regs *);
1da177e4
LT		 1979extern void flush_thread(void);
1980extern void exit_thread(void);
1981
1da177e4 1982extern void exit_files(struct task_struct *);
6b3934ef 1983extern void __cleanup_signal(struct signal_struct *);
a7e5328a 1984extern void __cleanup_sighand(struct sighand_struct *);
cbaffba1 1985
1da177e4 1986extern void exit_itimers(struct signal_struct *);
cbaffba1 1987extern void flush_itimer_signals(void);
1da177e4
LT		 1988
1989extern NORET_TYPE void do_group_exit(int);
1990
1da177e4
LT		 1991extern void daemonize(const char *, ...);
1992extern int allow_signal(int);
1993extern int disallow_signal(int);
1da177e4
LT		 1994
1995extern int do_execve(char *, char __user * __user *, char __user * __user *, struct pt_regs *);
1996extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
36c8b586 1997struct task_struct *fork_idle(int);
1da177e4
LT		 1998
1999extern void set_task_comm(struct task_struct *tsk, char *from);
59714d65 2000extern char *get_task_comm(char *to, struct task_struct *tsk);
1da177e4
LT		 2001
2002#ifdef CONFIG_SMP
85ba2d86 2003extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
1da177e4 2004#else
85ba2d86
RM		 2005static inline unsigned long wait_task_inactive(struct task_struct *p,
2006 long match_state)
2007{
2008 return 1;
2009}
1da177e4
LT		 2010#endif
2011
5e85d4ab 2012#define next_task(p) list_entry(rcu_dereference((p)->tasks.next), struct task_struct, tasks)
1da177e4
LT		 2013
2014#define for_each_process(p) \
2015 for (p = &init_task ; (p = next_task(p)) != &init_task ; )
2016
d84f4f99
DH		 2017extern bool is_single_threaded(struct task_struct *);
2018
1da177e4
LT		 2019/*
2020 * Careful: do_each_thread/while_each_thread is a double loop so
2021 * 'break' will not work as expected - use goto instead.
2022 */
2023#define do_each_thread(g, t) \
2024 for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
2025
2026#define while_each_thread(g, t) \
2027 while ((t = next_thread(t)) != g)
2028
de12a787
EB		 2029/* de_thread depends on thread_group_leader not being a pid based check */
2030#define thread_group_leader(p) (p == p->group_leader)
1da177e4 2031
0804ef4b
EB		 2032/* Do to the insanities of de_thread it is possible for a process
2033 * to have the pid of the thread group leader without actually being
2034 * the thread group leader. For iteration through the pids in proc
2035 * all we care about is that we have a task with the appropriate
2036 * pid, we don't actually care if we have the right task.
2037 */
e868171a 2038static inline int has_group_leader_pid(struct task_struct *p)
0804ef4b
EB		 2039{
2040 return p->pid == p->tgid;
2041}
2042
bac0abd6
PE		 2043static inline
2044int same_thread_group(struct task_struct *p1, struct task_struct *p2)
2045{
2046 return p1->tgid == p2->tgid;
2047}
2048
36c8b586 2049static inline struct task_struct *next_thread(const struct task_struct *p)
47e65328
ON		 2050{
2051 return list_entry(rcu_dereference(p->thread_group.next),
36c8b586 2052 struct task_struct, thread_group);
47e65328
ON		 2053}
2054
e868171a 2055static inline int thread_group_empty(struct task_struct *p)
1da177e4 2056{
47e65328 2057 return list_empty(&p->thread_group);
1da177e4
LT		 2058}
2059
2060#define delay_group_leader(p) \
2061 (thread_group_leader(p) && !thread_group_empty(p))
2062
39c626ae
ON		 2063static inline int task_detached(struct task_struct *p)
2064{
2065 return p->exit_signal == -1;
2066}
2067
1da177e4 2068/*
260ea101 2069 * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
22e2c507 2070 * subscriptions and synchronises with wait4(). Also used in procfs. Also
ddbcc7e8
PM		 2071 * pins the final release of task.io_context. Also protects ->cpuset and
2072 * ->cgroup.subsys[].
1da177e4
LT		 2073 *
2074 * Nests both inside and outside of read_lock(&tasklist_lock).
2075 * It must not be nested with write_lock_irq(&tasklist_lock),
2076 * neither inside nor outside.
2077 */
2078static inline void task_lock(struct task_struct *p)
2079{
2080 spin_lock(&p->alloc_lock);
2081}
2082
2083static inline void task_unlock(struct task_struct *p)
2084{
2085 spin_unlock(&p->alloc_lock);
2086}
2087
f63ee72e
ON		 2088extern struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
2089 unsigned long *flags);
2090
2091static inline void unlock_task_sighand(struct task_struct *tsk,
2092 unsigned long *flags)
2093{
2094 spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
2095}
2096
f037360f
AV		 2097#ifndef __HAVE_THREAD_FUNCTIONS
2098
f7e4217b
RZ		 2099#define task_thread_info(task) ((struct thread_info *)(task)->stack)
2100#define task_stack_page(task) ((task)->stack)
a1261f54 2101
10ebffde
AV		 2102static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
2103{
2104 *task_thread_info(p) = *task_thread_info(org);
2105 task_thread_info(p)->task = p;
2106}
2107
2108static inline unsigned long *end_of_stack(struct task_struct *p)
2109{
f7e4217b 2110 return (unsigned long *)(task_thread_info(p) + 1);
10ebffde
AV		 2111}
2112
f037360f
AV		 2113#endif
2114
8b05c7e6
FT		 2115static inline int object_is_on_stack(void *obj)
2116{
2117 void *stack = task_stack_page(current);
2118
2119 return (obj >= stack) && (obj < (stack + THREAD_SIZE));
2120}
2121
8c9843e5
BH		 2122extern void thread_info_cache_init(void);
2123
7c9f8861
ES		 2124#ifdef CONFIG_DEBUG_STACK_USAGE
2125static inline unsigned long stack_not_used(struct task_struct *p)
2126{
2127 unsigned long *n = end_of_stack(p);
2128
2129 do { /* Skip over canary */
2130 n++;
2131 } while (!*n);
2132
2133 return (unsigned long)n - (unsigned long)end_of_stack(p);
2134}
2135#endif
2136
1da177e4
LT		 2137/* set thread flags in other task's structures
2138 * - see asm/thread_info.h for TIF_xxxx flags available
2139 */
2140static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
2141{
a1261f54 2142 set_ti_thread_flag(task_thread_info(tsk), flag);
1da177e4
LT		 2143}
2144
2145static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2146{
a1261f54 2147 clear_ti_thread_flag(task_thread_info(tsk), flag);
1da177e4
LT		 2148}
2149
2150static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
2151{
a1261f54 2152 return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
1da177e4
LT		 2153}
2154
2155static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2156{
a1261f54 2157 return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
1da177e4
LT		 2158}
2159
2160static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
2161{
a1261f54 2162 return test_ti_thread_flag(task_thread_info(tsk), flag);
1da177e4
LT		 2163}
2164
2165static inline void set_tsk_need_resched(struct task_struct *tsk)
2166{
2167 set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2168}
2169
2170static inline void clear_tsk_need_resched(struct task_struct *tsk)
2171{
2172 clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2173}
2174
8ae121ac
GH		 2175static inline int test_tsk_need_resched(struct task_struct *tsk)
2176{
2177 return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
2178}
2179
1da177e4
LT		 2180static inline int signal_pending(struct task_struct *p)
2181{
2182 return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
2183}
f776d12d 2184
b3c97528 2185extern int __fatal_signal_pending(struct task_struct *p);
f776d12d
MW		 2186
2187static inline int fatal_signal_pending(struct task_struct *p)
2188{
2189 return signal_pending(p) && __fatal_signal_pending(p);
2190}
2191
16882c1e
ON		 2192static inline int signal_pending_state(long state, struct task_struct *p)
2193{
2194 if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
2195 return 0;
2196 if (!signal_pending(p))
2197 return 0;
2198
16882c1e
ON		 2199 return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
2200}
2201
1da177e4
LT		 2202static inline int need_resched(void)
2203{
9404ef02 2204 return unlikely(test_thread_flag(TIF_NEED_RESCHED));
1da177e4
LT		 2205}
2206
2207/*
2208 * cond_resched() and cond_resched_lock(): latency reduction via
2209 * explicit rescheduling in places that are safe. The return
2210 * value indicates whether a reschedule was done in fact.
2211 * cond_resched_lock() will drop the spinlock before scheduling,
2212 * cond_resched_softirq() will enable bhs before scheduling.
2213 */
c3921ab7 2214extern int _cond_resched(void);
c714a534 2215#ifdef CONFIG_PREEMPT_BKL
02b67cc3
HX		 2216static inline int cond_resched(void)
2217{
2218 return 0;
2219}
2220#else
02b67cc3
HX		 2221static inline int cond_resched(void)
2222{
2223 return _cond_resched();
2224}
2225#endif
1da177e4
LT		 2226extern int cond_resched_lock(spinlock_t * lock);
2227extern int cond_resched_softirq(void);
c3921ab7
LT		 2228static inline int cond_resched_bkl(void)
2229{
2230 return _cond_resched();
2231}
1da177e4
LT		 2232
2233/*
2234 * Does a critical section need to be broken due to another
95c354fe
NP		 2235 * task waiting?: (technically does not depend on CONFIG_PREEMPT,
2236 * but a general need for low latency)
1da177e4 2237 */
95c354fe 2238static inline int spin_needbreak(spinlock_t *lock)
1da177e4 2239{
95c354fe
NP		 2240#ifdef CONFIG_PREEMPT
2241 return spin_is_contended(lock);
2242#else
1da177e4 2243 return 0;
95c354fe 2244#endif
1da177e4
LT		 2245}
2246
f06febc9
FM		 2247/*
2248 * Thread group CPU time accounting.
2249 */
4cd4c1b4 2250void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
4da94d49 2251void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
f06febc9 2252
490dea45 2253static inline void thread_group_cputime_init(struct signal_struct *sig)
f06febc9 2254{
4cd4c1b4
PZ		 2255 sig->cputimer.cputime = INIT_CPUTIME;
2256 spin_lock_init(&sig->cputimer.lock);
2257 sig->cputimer.running = 0;
f06febc9
FM		 2258}
2259
f06febc9
FM		 2260static inline void thread_group_cputime_free(struct signal_struct *sig)
2261{
f06febc9
FM		 2262}
2263
7bb44ade
RM		 2264/*
2265 * Reevaluate whether the task has signals pending delivery.
2266 * Wake the task if so.
2267 * This is required every time the blocked sigset_t changes.
2268 * callers must hold sighand->siglock.
2269 */
2270extern void recalc_sigpending_and_wake(struct task_struct *t);
1da177e4
LT		 2271extern void recalc_sigpending(void);
2272
2273extern void signal_wake_up(struct task_struct *t, int resume_stopped);
2274
2275/*
2276 * Wrappers for p->thread_info->cpu access. No-op on UP.
2277 */
2278#ifdef CONFIG_SMP
2279
2280static inline unsigned int task_cpu(const struct task_struct *p)
2281{
a1261f54 2282 return task_thread_info(p)->cpu;
1da177e4
LT		 2283}
2284
c65cc870 2285extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
1da177e4
LT		 2286
2287#else
2288
2289static inline unsigned int task_cpu(const struct task_struct *p)
2290{
2291 return 0;
2292}
2293
2294static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
2295{
2296}
2297
2298#endif /* CONFIG_SMP */
2299
1da177e4 2300extern void arch_pick_mmap_layout(struct mm_struct *mm);
1da177e4 2301
1a3c3034
IM		 2302#ifdef CONFIG_TRACING
2303extern void
2304__trace_special(void *__tr, void *__data,
2305 unsigned long arg1, unsigned long arg2, unsigned long arg3);
1da177e4 2306#else
1a3c3034
IM		 2307static inline void
2308__trace_special(void *__tr, void *__data,
2309 unsigned long arg1, unsigned long arg2, unsigned long arg3)
1da177e4 2310{
1da177e4
LT		 2311}
2312#endif
2313
96f874e2
RR		 2314extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
2315extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
5c45bf27 2316
1da177e4
LT		 2317extern void normalize_rt_tasks(void);
2318
052f1dc7 2319#ifdef CONFIG_GROUP_SCHED
9b5b7751 2320
4cf86d77 2321extern struct task_group init_task_group;
eff766a6
PZ		 2322#ifdef CONFIG_USER_SCHED
2323extern struct task_group root_task_group;
6c415b92 2324extern void set_tg_uid(struct user_struct *user);
eff766a6 2325#endif
9b5b7751 2326
ec7dc8ac 2327extern struct task_group *sched_create_group(struct task_group *parent);
4cf86d77 2328extern void sched_destroy_group(struct task_group *tg);
9b5b7751 2329extern void sched_move_task(struct task_struct *tsk);
052f1dc7 2330#ifdef CONFIG_FAIR_GROUP_SCHED
4cf86d77 2331extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
5cb350ba 2332extern unsigned long sched_group_shares(struct task_group *tg);
052f1dc7
PZ		 2333#endif
2334#ifdef CONFIG_RT_GROUP_SCHED
9f0c1e56
PZ		 2335extern int sched_group_set_rt_runtime(struct task_group *tg,
2336 long rt_runtime_us);
2337extern long sched_group_rt_runtime(struct task_group *tg);
d0b27fa7
PZ		 2338extern int sched_group_set_rt_period(struct task_group *tg,
2339 long rt_period_us);
2340extern long sched_group_rt_period(struct task_group *tg);
54e99124 2341extern int sched_rt_can_attach(struct task_group *tg, struct task_struct *tsk);
052f1dc7 2342#endif
9b5b7751
SV		 2343#endif
2344
54e99124
DG		 2345extern int task_can_switch_user(struct user_struct *up,
2346 struct task_struct *tsk);
2347
4b98d11b
AD		 2348#ifdef CONFIG_TASK_XACCT
2349static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2350{
940389b8 2351 tsk->ioac.rchar += amt;
4b98d11b
AD		 2352}
2353
2354static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2355{
940389b8 2356 tsk->ioac.wchar += amt;
4b98d11b
AD		 2357}
2358
2359static inline void inc_syscr(struct task_struct *tsk)
2360{
940389b8 2361 tsk->ioac.syscr++;
4b98d11b
AD		 2362}
2363
2364static inline void inc_syscw(struct task_struct *tsk)
2365{
940389b8 2366 tsk->ioac.syscw++;
4b98d11b
AD		 2367}
2368#else
2369static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2370{
2371}
2372
2373static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2374{
2375}
2376
2377static inline void inc_syscr(struct task_struct *tsk)
2378{
2379}
2380
2381static inline void inc_syscw(struct task_struct *tsk)
2382{
2383}
2384#endif
2385
82455257
DH		 2386#ifndef TASK_SIZE_OF
2387#define TASK_SIZE_OF(tsk) TASK_SIZE
2388#endif
2389
cf475ad2
BS		 2390#ifdef CONFIG_MM_OWNER
2391extern void mm_update_next_owner(struct mm_struct *mm);
2392extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
2393#else
2394static inline void mm_update_next_owner(struct mm_struct *mm)
2395{
2396}
2397
2398static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
2399{
2400}
2401#endif /* CONFIG_MM_OWNER */
2402
7c731e0a
SR		 2403#define TASK_STATE_TO_CHAR_STR "RSDTtZX"
2404
1da177e4
LT		 2405#endif /* __KERNEL__ */
2406
2407#endif
kernel source for telekom puls (alcatel/mediatek)