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