blob: 0c3854b0d4b180670563c461c8d0feaf4bd96c3a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _LINUX_SCHED_H
2#define _LINUX_SCHED_H
3
David Woodhouseb7b3c762006-04-27 00:12:56 +01004/*
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 */
Dave Jones43bb40c2011-01-13 15:45:40 -080024/* 0x02000000 was previously the unused CLONE_STOPPED (Start in stopped state)
25 and is now available for re-use. */
Serge E. Hallyn071df102006-10-02 02:18:17 -070026#define CLONE_NEWUTS 0x04000000 /* New utsname group? */
Kirill Korotaev25b21cb2006-10-02 02:18:19 -070027#define CLONE_NEWIPC 0x08000000 /* New ipcs */
Serge E. Hallyn77ec7392007-07-15 23:41:01 -070028#define CLONE_NEWUSER 0x10000000 /* New user namespace */
Pavel Emelyanov30e49c22007-10-18 23:40:10 -070029#define CLONE_NEWPID 0x20000000 /* New pid namespace */
Eric W. Biederman169e3672007-09-27 17:10:06 -070030#define CLONE_NEWNET 0x40000000 /* New network namespace */
Jens Axboefadad8782008-01-24 08:54:47 +010031#define CLONE_IO 0x80000000 /* Clone io context */
David Woodhouseb7b3c762006-04-27 00:12:56 +010032
33/*
34 * Scheduling policies
35 */
36#define SCHED_NORMAL 0
37#define SCHED_FIFO 1
38#define SCHED_RR 2
39#define SCHED_BATCH 3
Ingo Molnar0e6aca42007-07-09 18:51:57 +020040/* SCHED_ISO: reserved but not implemented yet */
41#define SCHED_IDLE 5
Lennart Poetteringca94c442009-06-15 17:17:47 +020042/* Can be ORed in to make sure the process is reverted back to SCHED_NORMAL on fork */
43#define SCHED_RESET_ON_FORK 0x40000000
David Woodhouseb7b3c762006-04-27 00:12:56 +010044
David Woodhousea3b67142006-04-25 14:54:40 +010045#ifdef __KERNEL__
David Woodhouseb7b3c762006-04-27 00:12:56 +010046
47struct sched_param {
48 int sched_priority;
49};
50
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <asm/param.h> /* for HZ */
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include <linux/capability.h>
54#include <linux/threads.h>
55#include <linux/kernel.h>
56#include <linux/types.h>
57#include <linux/timex.h>
58#include <linux/jiffies.h>
59#include <linux/rbtree.h>
60#include <linux/thread_info.h>
61#include <linux/cpumask.h>
62#include <linux/errno.h>
63#include <linux/nodemask.h>
Martin Schwidefskyc92ff1b2007-10-16 01:24:43 -070064#include <linux/mm_types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66#include <asm/system.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <asm/page.h>
68#include <asm/ptrace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <asm/cputime.h>
70
71#include <linux/smp.h>
72#include <linux/sem.h>
73#include <linux/signal.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#include <linux/compiler.h>
75#include <linux/completion.h>
76#include <linux/pid.h>
77#include <linux/percpu.h>
78#include <linux/topology.h>
Peter Zijlstra3e26c142007-10-16 23:25:50 -070079#include <linux/proportions.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070080#include <linux/seccomp.h>
Ingo Molnare56d0902006-01-08 01:01:37 -080081#include <linux/rcupdate.h>
Jiri Pirko05725f72009-04-14 20:17:16 +020082#include <linux/rculist.h>
Ingo Molnar23f78d4a2006-06-27 02:54:53 -070083#include <linux/rtmutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
David Woodhousea3b67142006-04-25 14:54:40 +010085#include <linux/time.h>
86#include <linux/param.h>
87#include <linux/resource.h>
88#include <linux/timer.h>
89#include <linux/hrtimer.h>
Andrew Morton7c3ab732006-12-10 02:19:19 -080090#include <linux/task_io_accounting.h>
Arjan van de Ven97455122008-01-25 21:08:34 +010091#include <linux/latencytop.h>
David Howells9e2b2dc2008-08-13 16:20:04 +010092#include <linux/cred.h>
Peter Zijlstrafa14ff42011-09-12 13:06:17 +020093#include <linux/llist.h>
David Woodhousea3b67142006-04-25 14:54:40 +010094
95#include <asm/processor.h>
H. J. Lu36d57ac2005-09-06 15:16:49 -070096
Linus Torvalds1da177e2005-04-16 15:20:36 -070097struct exec_domain;
Ingo Molnarc87e2832006-06-27 02:54:58 -070098struct futex_pi_state;
Alexey Dobriyan286100a2008-01-25 21:08:34 +010099struct robust_list_head;
Akinobu Mitabddd87c2010-02-23 08:55:42 +0100100struct bio_list;
Al Viro5ad4e532009-03-29 19:50:06 -0400101struct fs_struct;
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200102struct perf_event_context;
Jens Axboe73c10102011-03-08 13:19:51 +0100103struct blk_plug;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
105/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 * 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 */
Thomas Gleixner2d024942009-05-02 20:08:52 +0200122extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124#define FSHIFT 11 /* nr of bits of precision */
125#define FIXED_1 (1<<FSHIFT) /* 1.0 as fixed-point */
Linus Torvalds0c2043a2007-10-07 16:17:38 -0700126#define LOAD_FREQ (5*HZ+1) /* 5 sec intervals */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127#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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138DECLARE_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);
Peter Zijlstra8c215bd2010-07-01 09:07:17 +0200143extern unsigned long nr_iowait_cpu(int cpu);
Arjan van de Ven69d25872009-09-21 17:04:08 -0700144extern unsigned long this_cpu_load(void);
145
146
Peter Zijlstra0f004f52010-11-30 19:48:45 +0100147extern void calc_global_load(unsigned long ticks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
Steven Rostedt7e49fcc2009-01-22 19:01:40 -0500149extern unsigned long get_parent_ip(unsigned long addr);
150
Ingo Molnar43ae34c2007-07-09 18:52:00 +0200151struct seq_file;
152struct cfs_rq;
Ingo Molnar4cf86d72007-10-15 17:00:14 +0200153struct task_group;
Ingo Molnar43ae34c2007-07-09 18:52:00 +0200154#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
Ingo Molnar5cef9ec2007-08-09 11:16:47 +0200158print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
Ingo Molnar43ae34c2007-07-09 18:52:00 +0200159#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
Ingo Molnar5cef9ec2007-08-09 11:16:47 +0200168print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
Ingo Molnar43ae34c2007-07-09 18:52:00 +0200169{
170}
171#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
Linus Torvalds4a8342d2005-09-29 15:18:21 -0700173/*
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183#define TASK_RUNNING 0
184#define TASK_INTERRUPTIBLE 1
185#define TASK_UNINTERRUPTIBLE 2
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500186#define __TASK_STOPPED 4
187#define __TASK_TRACED 8
Linus Torvalds4a8342d2005-09-29 15:18:21 -0700188/* in tsk->exit_state */
189#define EXIT_ZOMBIE 16
190#define EXIT_DEAD 32
191/* in tsk->state again */
Mike Galbraithaf927232007-10-15 17:00:13 +0200192#define TASK_DEAD 64
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500193#define TASK_WAKEKILL 128
Peter Zijlstrae9c84312009-09-15 14:43:03 +0200194#define TASK_WAKING 256
Peter Zijlstrae1781532009-12-17 13:16:30 +0100195#define TASK_STATE_MAX 512
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500196
Peter Zijlstra44d90df2009-12-17 13:16:28 +0100197#define TASK_STATE_TO_CHAR_STR "RSDTtZXxKW"
Peter Zijlstra73342152009-12-17 13:16:27 +0100198
Peter Zijlstrae1781532009-12-17 13:16:30 +0100199extern char ___assert_task_state[1 - 2*!!(
200 sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1)];
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500201
202/* Convenience macros for the sake of set_task_state */
203#define TASK_KILLABLE (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
204#define TASK_STOPPED (TASK_WAKEKILL | __TASK_STOPPED)
205#define TASK_TRACED (TASK_WAKEKILL | __TASK_TRACED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500207/* Convenience macros for the sake of wake_up */
208#define TASK_NORMAL (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500209#define TASK_ALL (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500210
211/* get_task_state() */
212#define TASK_REPORT (TASK_RUNNING | TASK_INTERRUPTIBLE | \
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500213 TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
214 __TASK_TRACED)
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500215
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500216#define task_is_traced(task) ((task->state & __TASK_TRACED) != 0)
217#define task_is_stopped(task) ((task->state & __TASK_STOPPED) != 0)
David Howells8f920542010-07-29 12:45:55 +0100218#define task_is_dead(task) ((task)->exit_state != 0)
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500219#define task_is_stopped_or_traced(task) \
Matthew Wilcoxf021a3c2007-12-06 11:13:16 -0500220 ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
Matthew Wilcox92a1f4b2007-12-06 10:55:25 -0500221#define task_contributes_to_load(task) \
Nathan Lynche3c8ca82009-04-08 19:45:12 -0500222 ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
Tejun Heo376fede2011-11-21 12:32:24 -0800223 (task->flags & PF_FROZEN) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
225#define __set_task_state(tsk, state_value) \
226 do { (tsk)->state = (state_value); } while (0)
227#define set_task_state(tsk, state_value) \
228 set_mb((tsk)->state, (state_value))
229
Andrew Morton498d0c52005-09-13 01:25:14 -0700230/*
231 * set_current_state() includes a barrier so that the write of current->state
232 * is correctly serialised wrt the caller's subsequent test of whether to
233 * actually sleep:
234 *
235 * set_current_state(TASK_UNINTERRUPTIBLE);
236 * if (do_i_need_to_sleep())
237 * schedule();
238 *
239 * If the caller does not need such serialisation then use __set_current_state()
240 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241#define __set_current_state(state_value) \
242 do { current->state = (state_value); } while (0)
243#define set_current_state(state_value) \
244 set_mb(current->state, (state_value))
245
246/* Task command name length */
247#define TASK_COMM_LEN 16
248
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249#include <linux/spinlock.h>
250
251/*
252 * This serializes "schedule()" and also protects
253 * the run-queue from deletions/modifications (but
254 * _adding_ to the beginning of the run-queue has
255 * a separate lock).
256 */
257extern rwlock_t tasklist_lock;
258extern spinlock_t mmlist_lock;
259
Ingo Molnar36c8b582006-07-03 00:25:41 -0700260struct task_struct;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261
Paul E. McKenneydb1466b2010-03-03 07:46:56 -0800262#ifdef CONFIG_PROVE_RCU
263extern int lockdep_tasklist_lock_is_held(void);
264#endif /* #ifdef CONFIG_PROVE_RCU */
265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266extern void sched_init(void);
267extern void sched_init_smp(void);
Harvey Harrison2d07b252008-02-15 09:56:34 -0800268extern asmlinkage void schedule_tail(struct task_struct *prev);
Ingo Molnar36c8b582006-07-03 00:25:41 -0700269extern void init_idle(struct task_struct *idle, int cpu);
Ingo Molnar1df21052007-07-09 18:51:58 +0200270extern void init_idle_bootup_task(struct task_struct *idle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
Andrew Morton89f19f02009-09-19 11:55:44 -0700272extern int runqueue_is_locked(int cpu);
Ingo Molnar017730c2008-05-12 21:20:52 +0200273
Siddha, Suresh B46cb4b72007-05-08 00:32:51 -0700274#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ)
Venkatesh Pallipadi83cd4fe2010-05-21 17:09:41 -0700275extern void select_nohz_load_balancer(int stop_tick);
Suresh Siddha69e1e812011-12-01 17:07:33 -0800276extern void set_cpu_sd_state_idle(void);
Venkatesh Pallipadi83cd4fe2010-05-21 17:09:41 -0700277extern int get_nohz_timer_target(void);
Siddha, Suresh B46cb4b72007-05-08 00:32:51 -0700278#else
Venkatesh Pallipadi83cd4fe2010-05-21 17:09:41 -0700279static inline void select_nohz_load_balancer(int stop_tick) { }
Peter Zijlstrafdaabd82011-12-06 12:47:55 +0100280static inline void set_cpu_sd_state_idle(void) { }
Siddha, Suresh B46cb4b72007-05-08 00:32:51 -0700281#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
Ingo Molnare59e2ae2006-12-06 20:35:59 -0800283/*
Ingo Molnar39bc89f2007-04-25 20:50:03 -0700284 * Only dump TASK_* tasks. (0 for all tasks)
Ingo Molnare59e2ae2006-12-06 20:35:59 -0800285 */
286extern void show_state_filter(unsigned long state_filter);
287
288static inline void show_state(void)
289{
Ingo Molnar39bc89f2007-04-25 20:50:03 -0700290 show_state_filter(0);
Ingo Molnare59e2ae2006-12-06 20:35:59 -0800291}
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293extern void show_regs(struct pt_regs *);
294
295/*
296 * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
297 * task), SP is the stack pointer of the first frame that should be shown in the back
298 * trace (or NULL if the entire call-chain of the task should be shown).
299 */
300extern void show_stack(struct task_struct *task, unsigned long *sp);
301
302void io_schedule(void);
303long io_schedule_timeout(long timeout);
304
305extern void cpu_init (void);
306extern void trap_init(void);
307extern void update_process_times(int user);
308extern void scheduler_tick(void);
309
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100310extern void sched_show_task(struct task_struct *p);
311
Frederic Weisbecker19cc36c2010-05-13 02:30:49 +0200312#ifdef CONFIG_LOCKUP_DETECTOR
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700313extern void touch_softlockup_watchdog(void);
Jason Wesseld6ad3e22010-01-27 16:25:22 -0600314extern void touch_softlockup_watchdog_sync(void);
Jeremy Fitzhardinge04c91672007-05-08 00:28:05 -0700315extern void touch_all_softlockup_watchdogs(void);
Don Zickus332fbdb2010-05-07 17:11:45 -0400316extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
317 void __user *buffer,
318 size_t *lenp, loff_t *ppos);
Ingo Molnar9c44bc02008-05-12 21:21:04 +0200319extern unsigned int softlockup_panic;
Peter Zijlstra004417a2010-11-25 18:38:29 +0100320void lockup_detector_init(void);
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700321#else
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700322static inline void touch_softlockup_watchdog(void)
323{
324}
Jason Wesseld6ad3e22010-01-27 16:25:22 -0600325static inline void touch_softlockup_watchdog_sync(void)
326{
327}
Jeremy Fitzhardinge04c91672007-05-08 00:28:05 -0700328static inline void touch_all_softlockup_watchdogs(void)
329{
330}
Peter Zijlstra004417a2010-11-25 18:38:29 +0100331static inline void lockup_detector_init(void)
332{
333}
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700334#endif
335
Mandeep Singh Bainese162b392009-01-15 11:08:40 -0800336#ifdef CONFIG_DETECT_HUNG_TASK
337extern unsigned int sysctl_hung_task_panic;
338extern unsigned long sysctl_hung_task_check_count;
339extern unsigned long sysctl_hung_task_timeout_secs;
340extern unsigned long sysctl_hung_task_warnings;
341extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700342 void __user *buffer,
Mandeep Singh Bainese162b392009-01-15 11:08:40 -0800343 size_t *lenp, loff_t *ppos);
Mark Lorde4ecda12010-09-25 11:17:22 +0200344#else
345/* Avoid need for ifdefs elsewhere in the code */
346enum { sysctl_hung_task_timeout_secs = 0 };
Mandeep Singh Bainese162b392009-01-15 11:08:40 -0800347#endif
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349/* Attach to any functions which should be ignored in wchan output. */
350#define __sched __attribute__((__section__(".sched.text")))
Ingo Molnardeaf2222007-11-28 15:52:56 +0100351
352/* Linker adds these: start and end of __sched functions */
353extern char __sched_text_start[], __sched_text_end[];
354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355/* Is this address in the __sched functions? */
356extern int in_sched_functions(unsigned long addr);
357
358#define MAX_SCHEDULE_TIMEOUT LONG_MAX
Harvey Harrisonb3c97522008-02-13 15:03:15 -0800359extern signed long schedule_timeout(signed long timeout);
Nishanth Aravamudan64ed93a2005-09-10 00:27:21 -0700360extern signed long schedule_timeout_interruptible(signed long timeout);
Matthew Wilcox294d5cc2007-12-06 11:59:46 -0500361extern signed long schedule_timeout_killable(signed long timeout);
Nishanth Aravamudan64ed93a2005-09-10 00:27:21 -0700362extern signed long schedule_timeout_uninterruptible(signed long timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363asmlinkage void schedule(void);
Thomas Gleixnerc5491ea2011-03-21 12:09:35 +0100364extern void schedule_preempt_disabled(void);
Peter Zijlstrac6eb3dd2011-04-05 17:23:41 +0200365extern int mutex_spin_on_owner(struct mutex *lock, struct task_struct *owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
Serge E. Hallynab516012006-10-02 02:18:06 -0700367struct nsproxy;
Cedric Le Goateracce2922007-07-15 23:40:59 -0700368struct user_namespace;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
KAMEZAWA Hiroyuki341c87b2009-06-30 11:41:23 -0700370/*
371 * Default maximum number of active map areas, this limits the number of vmas
372 * per mm struct. Users can overwrite this number by sysctl but there is a
373 * problem.
374 *
375 * When a program's coredump is generated as ELF format, a section is created
376 * per a vma. In ELF, the number of sections is represented in unsigned short.
377 * This means the number of sections should be smaller than 65535 at coredump.
378 * Because the kernel adds some informative sections to a image of program at
379 * generating coredump, we need some margin. The number of extra sections is
380 * 1-3 now and depends on arch. We use "5" as safe margin, here.
381 */
382#define MAPCOUNT_ELF_CORE_MARGIN (5)
Alexey Dobriyan4be929b2010-05-24 14:33:03 -0700383#define DEFAULT_MAX_MAP_COUNT (USHRT_MAX - MAPCOUNT_ELF_CORE_MARGIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
385extern int sysctl_max_map_count;
386
387#include <linux/aio.h>
388
David Howellsefc1a3b2010-01-15 17:01:35 -0800389#ifdef CONFIG_MMU
390extern void arch_pick_mmap_layout(struct mm_struct *mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391extern unsigned long
392arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
393 unsigned long, unsigned long);
394extern unsigned long
395arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
396 unsigned long len, unsigned long pgoff,
397 unsigned long flags);
Wolfgang Wander1363c3c2005-06-21 17:14:49 -0700398extern void arch_unmap_area(struct mm_struct *, unsigned long);
399extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
David Howellsefc1a3b2010-01-15 17:01:35 -0800400#else
401static inline void arch_pick_mmap_layout(struct mm_struct *mm) {}
402#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Oleg Nesterov901608d2009-01-06 14:40:29 -0800404
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700405extern void set_dumpable(struct mm_struct *mm, int value);
406extern int get_dumpable(struct mm_struct *mm);
407
408/* mm flags */
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700409/* dumpable bits */
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700410#define MMF_DUMPABLE 0 /* core dump is permitted */
411#define MMF_DUMP_SECURELY 1 /* core file is readable only by root */
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700412
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700413#define MMF_DUMPABLE_BITS 2
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700414#define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1)
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700415
416/* coredump filter bits */
417#define MMF_DUMP_ANON_PRIVATE 2
418#define MMF_DUMP_ANON_SHARED 3
419#define MMF_DUMP_MAPPED_PRIVATE 4
420#define MMF_DUMP_MAPPED_SHARED 5
Roland McGrath82df3972007-10-16 23:27:02 -0700421#define MMF_DUMP_ELF_HEADERS 6
KOSAKI Motohiroe575f112008-10-18 20:27:08 -0700422#define MMF_DUMP_HUGETLB_PRIVATE 7
423#define MMF_DUMP_HUGETLB_SHARED 8
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700424
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700425#define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS
KOSAKI Motohiroe575f112008-10-18 20:27:08 -0700426#define MMF_DUMP_FILTER_BITS 7
Kawai, Hidehiro3cb4a0b2007-07-19 01:48:28 -0700427#define MMF_DUMP_FILTER_MASK \
428 (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
429#define MMF_DUMP_FILTER_DEFAULT \
KOSAKI Motohiroe575f112008-10-18 20:27:08 -0700430 ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\
Roland McGrath656eb2c2008-10-18 20:28:23 -0700431 (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)
432
433#ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS
434# define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS)
435#else
436# define MMF_DUMP_MASK_DEFAULT_ELF 0
437#endif
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700438 /* leave room for more dump flags */
439#define MMF_VM_MERGEABLE 16 /* KSM may merge identical pages */
Andrea Arcangeliba761492011-01-13 15:46:58 -0800440#define MMF_VM_HUGEPAGE 17 /* set when VM_HUGEPAGE is set on vma */
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700441
442#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK)
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700443
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444struct sighand_struct {
445 atomic_t count;
446 struct k_sigaction action[_NSIG];
447 spinlock_t siglock;
Davide Libenzib8fceee2007-09-20 12:40:16 -0700448 wait_queue_head_t signalfd_wqh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449};
450
KaiGai Kohei0e464812006-06-25 05:49:24 -0700451struct pacct_struct {
KaiGai Koheif6ec29a2006-06-25 05:49:25 -0700452 int ac_flag;
453 long ac_exitcode;
KaiGai Kohei0e464812006-06-25 05:49:24 -0700454 unsigned long ac_mem;
KaiGai Kohei77787bf2006-06-25 05:49:26 -0700455 cputime_t ac_utime, ac_stime;
456 unsigned long ac_minflt, ac_majflt;
KaiGai Kohei0e464812006-06-25 05:49:24 -0700457};
458
Stanislaw Gruszka42c4ab42009-07-29 12:15:26 +0200459struct cpu_itimer {
460 cputime_t expires;
461 cputime_t incr;
Stanislaw Gruszka8356b5f2009-07-29 12:15:27 +0200462 u32 error;
463 u32 incr_error;
Stanislaw Gruszka42c4ab42009-07-29 12:15:26 +0200464};
465
Frank Mayharf06febc2008-09-12 09:54:39 -0700466/**
467 * struct task_cputime - collected CPU time counts
468 * @utime: time spent in user mode, in &cputime_t units
469 * @stime: time spent in kernel mode, in &cputime_t units
470 * @sum_exec_runtime: total time spent on the CPU, in nanoseconds
Ingo Molnar5ce73a42008-09-14 17:11:46 +0200471 *
Frank Mayharf06febc2008-09-12 09:54:39 -0700472 * This structure groups together three kinds of CPU time that are
473 * tracked for threads and thread groups. Most things considering
474 * CPU time want to group these counts together and treat all three
475 * of them in parallel.
476 */
477struct task_cputime {
478 cputime_t utime;
479 cputime_t stime;
480 unsigned long long sum_exec_runtime;
481};
482/* Alternate field names when used to cache expirations. */
483#define prof_exp stime
484#define virt_exp utime
485#define sched_exp sum_exec_runtime
486
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100487#define INIT_CPUTIME \
488 (struct task_cputime) { \
Martin Schwidefsky64861632011-12-15 14:56:09 +0100489 .utime = 0, \
490 .stime = 0, \
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100491 .sum_exec_runtime = 0, \
492 }
493
Peter Zijlstrac99e6ef2009-07-10 14:57:56 +0200494/*
495 * Disable preemption until the scheduler is running.
496 * Reset by start_kernel()->sched_init()->init_idle().
Peter Zijlstrad86ee482009-07-10 14:57:57 +0200497 *
498 * We include PREEMPT_ACTIVE to avoid cond_resched() from working
499 * before the scheduler is active -- see should_resched().
Peter Zijlstrac99e6ef2009-07-10 14:57:56 +0200500 */
Peter Zijlstrad86ee482009-07-10 14:57:57 +0200501#define INIT_PREEMPT_COUNT (1 + PREEMPT_ACTIVE)
Peter Zijlstrac99e6ef2009-07-10 14:57:56 +0200502
Frank Mayharf06febc2008-09-12 09:54:39 -0700503/**
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100504 * struct thread_group_cputimer - thread group interval timer counts
505 * @cputime: thread group interval timers.
506 * @running: non-zero when there are timers running and
507 * @cputime receives updates.
508 * @lock: lock for fields in this struct.
Frank Mayharf06febc2008-09-12 09:54:39 -0700509 *
510 * This structure contains the version of task_cputime, above, that is
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100511 * used for thread group CPU timer calculations.
Frank Mayharf06febc2008-09-12 09:54:39 -0700512 */
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100513struct thread_group_cputimer {
514 struct task_cputime cputime;
515 int running;
Thomas Gleixneree30a7b2009-07-25 18:56:56 +0200516 raw_spinlock_t lock;
Frank Mayharf06febc2008-09-12 09:54:39 -0700517};
Frank Mayharf06febc2008-09-12 09:54:39 -0700518
Ben Blum4714d1d2011-05-26 16:25:18 -0700519#include <linux/rwsem.h>
Mike Galbraith5091faa2010-11-30 14:18:03 +0100520struct autogroup;
521
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522/*
Jonathan Neuschäfere815f0a2011-03-21 20:24:47 +0100523 * NOTE! "signal_struct" does not have its own
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 * locking, because a shared signal_struct always
525 * implies a shared sighand_struct, so locking
526 * sighand_struct is always a proper superset of
527 * the locking of signal_struct.
528 */
529struct signal_struct {
Oleg Nesterovea6d2902010-05-26 14:43:16 -0700530 atomic_t sigcnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 atomic_t live;
Oleg Nesterovb3ac0222010-05-26 14:43:24 -0700532 int nr_threads;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
534 wait_queue_head_t wait_chldexit; /* for wait4() */
535
536 /* current thread group signal load-balancing target: */
Ingo Molnar36c8b582006-07-03 00:25:41 -0700537 struct task_struct *curr_target;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
539 /* shared signal handling: */
540 struct sigpending shared_pending;
541
542 /* thread group exit support */
543 int group_exit_code;
544 /* overloaded:
545 * - notify group_exit_task when ->count is equal to notify_count
546 * - everyone except group_exit_task is stopped during signal delivery
547 * of fatal signals, group_exit_task processes the signal.
548 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 int notify_count;
Richard Kennedy07dd20e2008-08-01 13:18:04 +0100550 struct task_struct *group_exit_task;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
552 /* thread group stop support, overloads group_exit_code too */
553 int group_stop_count;
554 unsigned int flags; /* see SIGNAL_* flags below */
555
Lennart Poetteringebec18a2012-03-23 15:01:54 -0700556 /*
557 * PR_SET_CHILD_SUBREAPER marks a process, like a service
558 * manager, to re-parent orphan (double-forking) child processes
559 * to this process instead of 'init'. The service manager is
560 * able to receive SIGCHLD signals and is able to investigate
561 * the process until it calls wait(). All children of this
562 * process will inherit a flag if they should look for a
563 * child_subreaper process at exit.
564 */
565 unsigned int is_child_subreaper:1;
566 unsigned int has_child_subreaper:1;
567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 /* POSIX.1b Interval Timers */
569 struct list_head posix_timers;
570
571 /* ITIMER_REAL timer for the process */
Thomas Gleixner2ff678b2006-01-09 20:52:34 -0800572 struct hrtimer real_timer;
Oleg Nesterovfea9d172008-02-08 04:19:19 -0800573 struct pid *leader_pid;
Thomas Gleixner2ff678b2006-01-09 20:52:34 -0800574 ktime_t it_real_incr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
Stanislaw Gruszka42c4ab42009-07-29 12:15:26 +0200576 /*
577 * ITIMER_PROF and ITIMER_VIRTUAL timers for the process, we use
578 * CPUCLOCK_PROF and CPUCLOCK_VIRT for indexing array as these
579 * values are defined to 0 and 1 respectively
580 */
581 struct cpu_itimer it[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
Frank Mayharf06febc2008-09-12 09:54:39 -0700583 /*
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100584 * Thread group totals for process CPU timers.
585 * See thread_group_cputimer(), et al, for details.
Frank Mayharf06febc2008-09-12 09:54:39 -0700586 */
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +0100587 struct thread_group_cputimer cputimer;
Frank Mayharf06febc2008-09-12 09:54:39 -0700588
589 /* Earliest-expiration cache. */
590 struct task_cputime cputime_expires;
591
592 struct list_head cpu_timers[3];
593
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800594 struct pid *tty_old_pgrp;
Cedric Le Goater1ec320a2006-12-08 02:37:55 -0800595
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 /* boolean value for session group leader */
597 int leader;
598
599 struct tty_struct *tty; /* NULL if no tty */
600
Mike Galbraith5091faa2010-11-30 14:18:03 +0100601#ifdef CONFIG_SCHED_AUTOGROUP
602 struct autogroup *autogroup;
603#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 /*
605 * Cumulative resource counters for dead threads in the group,
606 * and for reaped dead child processes forked by this group.
607 * Live threads maintain their own counters and add to these
608 * in __exit_signal, except for the group leader.
609 */
Peter Zijlstra32bd6712009-02-05 12:24:15 +0100610 cputime_t utime, stime, cutime, cstime;
Laurent Vivier9ac52312007-10-15 17:00:19 +0200611 cputime_t gtime;
612 cputime_t cgtime;
Hidetoshi Seto0cf55e12009-12-02 17:28:07 +0900613#ifndef CONFIG_VIRT_CPU_ACCOUNTING
614 cputime_t prev_utime, prev_stime;
615#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
617 unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
Eric Dumazet6eaeeab2007-05-10 22:22:37 -0700618 unsigned long inblock, oublock, cinblock, coublock;
Jiri Pirko1f102062009-09-22 16:44:10 -0700619 unsigned long maxrss, cmaxrss;
Andrea Righi940389b2008-07-28 00:48:12 +0200620 struct task_io_accounting ioac;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
622 /*
Peter Zijlstra32bd6712009-02-05 12:24:15 +0100623 * Cumulative ns of schedule CPU time fo dead threads in the
624 * group, not including a zombie group leader, (This only differs
625 * from jiffies_to_ns(utime + stime) if sched_clock uses something
626 * other than jiffies.)
627 */
628 unsigned long long sum_sched_runtime;
629
630 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 * We don't bother to synchronize most readers of this at all,
632 * because there is no reader checking a limit that actually needs
633 * to get both rlim_cur and rlim_max atomically, and either one
634 * alone is a single word that can safely be read normally.
635 * getrlimit/setrlimit use task_lock(current->group_leader) to
636 * protect this instead of the siglock, because they really
637 * have no need to disable irqs.
638 */
639 struct rlimit rlim[RLIM_NLIMITS];
640
KaiGai Kohei0e464812006-06-25 05:49:24 -0700641#ifdef CONFIG_BSD_PROCESS_ACCT
642 struct pacct_struct pacct; /* per-process accounting information */
643#endif
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700644#ifdef CONFIG_TASKSTATS
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700645 struct taskstats *stats;
646#endif
Miloslav Trmac522ed772007-07-15 23:40:56 -0700647#ifdef CONFIG_AUDIT
648 unsigned audit_tty;
649 struct tty_audit_buf *tty_audit_buf;
650#endif
Ben Blum4714d1d2011-05-26 16:25:18 -0700651#ifdef CONFIG_CGROUPS
652 /*
Tejun Heo77e4ef92011-12-12 18:12:21 -0800653 * group_rwsem prevents new tasks from entering the threadgroup and
654 * member tasks from exiting,a more specifically, setting of
655 * PF_EXITING. fork and exit paths are protected with this rwsem
656 * using threadgroup_change_begin/end(). Users which require
657 * threadgroup to remain stable should use threadgroup_[un]lock()
658 * which also takes care of exec path. Currently, cgroup is the
659 * only user.
Ben Blum4714d1d2011-05-26 16:25:18 -0700660 */
Tejun Heo257058a2011-12-12 18:12:21 -0800661 struct rw_semaphore group_rwsem;
Ben Blum4714d1d2011-05-26 16:25:18 -0700662#endif
KOSAKI Motohiro28b83c52009-09-21 17:03:13 -0700663
David Rientjesa63d83f2010-08-09 17:19:46 -0700664 int oom_adj; /* OOM kill score adjustment (bit shift) */
665 int oom_score_adj; /* OOM kill score adjustment */
Mandeep Singh Bainesdabb16f2011-01-13 15:46:05 -0800666 int oom_score_adj_min; /* OOM kill score adjustment minimum value.
667 * Only settable by CAP_SYS_RESOURCE. */
KOSAKI Motohiro9b1bf122010-10-27 15:34:08 -0700668
669 struct mutex cred_guard_mutex; /* guard against foreign influences on
670 * credential calculations
671 * (notably. ptrace) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672};
673
Nick Piggin4866cde2005-06-25 14:57:23 -0700674/* Context switch must be unlocked if interrupts are to be enabled */
675#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
676# define __ARCH_WANT_UNLOCKED_CTXSW
677#endif
678
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679/*
680 * Bits in flags field of signal_struct.
681 */
682#define SIGNAL_STOP_STOPPED 0x00000001 /* job control stop in effect */
Oleg Nesterovee77f072011-04-01 20:12:38 +0200683#define SIGNAL_STOP_CONTINUED 0x00000002 /* SIGCONT since WCONTINUED reap */
684#define SIGNAL_GROUP_EXIT 0x00000004 /* group exit in progress */
Oleg Nesterove4420552008-04-30 00:52:44 -0700685/*
686 * Pending notifications to parent.
687 */
688#define SIGNAL_CLD_STOPPED 0x00000010
689#define SIGNAL_CLD_CONTINUED 0x00000020
690#define SIGNAL_CLD_MASK (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
Oleg Nesterovfae5fa42008-04-30 00:53:03 -0700692#define SIGNAL_UNKILLABLE 0x00000040 /* for init: ignore fatal signals */
693
Oleg Nesteroved5d2ca2008-02-04 22:27:24 -0800694/* If true, all threads except ->group_exit_task have pending SIGKILL */
695static inline int signal_group_exit(const struct signal_struct *sig)
696{
697 return (sig->flags & SIGNAL_GROUP_EXIT) ||
698 (sig->group_exit_task != NULL);
699}
700
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701/*
702 * Some day this will be a full-fledged user tracking system..
703 */
704struct user_struct {
705 atomic_t __count; /* reference count */
706 atomic_t processes; /* How many processes does this user have? */
707 atomic_t files; /* How many open files does this user have? */
708 atomic_t sigpending; /* How many pending signals does this user have? */
Amy Griffis2d9048e2006-06-01 13:10:59 -0700709#ifdef CONFIG_INOTIFY_USER
Robert Love0eeca282005-07-12 17:06:03 -0400710 atomic_t inotify_watches; /* How many inotify watches does this user have? */
711 atomic_t inotify_devs; /* How many inotify devs does this user have opened? */
712#endif
Eric Paris4afeff82010-10-28 17:21:58 -0400713#ifdef CONFIG_FANOTIFY
714 atomic_t fanotify_listeners;
715#endif
Davide Libenzi7ef99642008-12-01 13:13:55 -0800716#ifdef CONFIG_EPOLL
Robin Holt52bd19f72011-01-12 17:00:01 -0800717 atomic_long_t epoll_watches; /* The number of file descriptors currently watched */
Davide Libenzi7ef99642008-12-01 13:13:55 -0800718#endif
Alexey Dobriyan970a8642007-10-16 23:30:09 -0700719#ifdef CONFIG_POSIX_MQUEUE
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 /* protected by mq_lock */
721 unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */
Alexey Dobriyan970a8642007-10-16 23:30:09 -0700722#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 unsigned long locked_shm; /* How many pages of mlocked shm ? */
724
725#ifdef CONFIG_KEYS
726 struct key *uid_keyring; /* UID specific keyring */
727 struct key *session_keyring; /* UID's default session keyring */
728#endif
729
730 /* Hash table maintenance information */
Pavel Emelyanov735de222007-09-18 22:46:44 -0700731 struct hlist_node uidhash_node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 uid_t uid;
Serge Hallyn18b6e042008-10-15 16:38:45 -0500733 struct user_namespace *user_ns;
Srivatsa Vaddagiri24e377a2007-10-15 17:00:09 +0200734
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200735#ifdef CONFIG_PERF_EVENTS
Peter Zijlstra789f90f2009-05-15 15:19:27 +0200736 atomic_long_t locked_vm;
737#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738};
739
Kay Sieverseb41d942007-11-02 13:47:53 +0100740extern int uids_sysfs_init(void);
Dhaval Giani5cb350b2007-10-15 17:00:14 +0200741
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742extern struct user_struct *find_user(uid_t);
743
744extern struct user_struct root_user;
745#define INIT_USER (&root_user)
746
David Howellsb6dff3e2008-11-14 10:39:16 +1100747
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748struct backing_dev_info;
749struct reclaim_state;
750
Chandra Seetharaman52f17b62006-07-14 00:24:38 -0700751#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752struct sched_info {
753 /* cumulative counters */
Ingo Molnar2d723762007-10-15 17:00:12 +0200754 unsigned long pcount; /* # of times run on this cpu */
Ken Chen9c2c4802008-12-16 23:41:22 -0800755 unsigned long long run_delay; /* time spent waiting on a runqueue */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
757 /* timestamps */
Balbir Singh172ba842007-07-09 18:52:00 +0200758 unsigned long long last_arrival,/* when we last ran on a cpu */
759 last_queued; /* when we were last queued to run */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760};
Chandra Seetharaman52f17b62006-07-14 00:24:38 -0700761#endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
Shailabh Nagarca74e922006-07-14 00:24:36 -0700763#ifdef CONFIG_TASK_DELAY_ACCT
764struct task_delay_info {
765 spinlock_t lock;
766 unsigned int flags; /* Private per-task flags */
767
768 /* For each stat XXX, add following, aligned appropriately
769 *
770 * struct timespec XXX_start, XXX_end;
771 * u64 XXX_delay;
772 * u32 XXX_count;
773 *
774 * Atomicity of updates to XXX_delay, XXX_count protected by
775 * single lock above (split into XXX_lock if contention is an issue).
776 */
Shailabh Nagar0ff92242006-07-14 00:24:37 -0700777
778 /*
779 * XXX_count is incremented on every XXX operation, the delay
780 * associated with the operation is added to XXX_delay.
781 * XXX_delay contains the accumulated delay time in nanoseconds.
782 */
783 struct timespec blkio_start, blkio_end; /* Shared by blkio, swapin */
784 u64 blkio_delay; /* wait for sync block io completion */
785 u64 swapin_delay; /* wait for swapin block io completion */
786 u32 blkio_count; /* total count of the number of sync block */
787 /* io operations performed */
788 u32 swapin_count; /* total count of the number of swapin block */
789 /* io operations performed */
Keika Kobayashi873b4772008-07-25 01:48:52 -0700790
791 struct timespec freepages_start, freepages_end;
792 u64 freepages_delay; /* wait for memory reclaim */
793 u32 freepages_count; /* total count of memory reclaim */
Shailabh Nagarca74e922006-07-14 00:24:36 -0700794};
Chandra Seetharaman52f17b62006-07-14 00:24:38 -0700795#endif /* CONFIG_TASK_DELAY_ACCT */
796
797static inline int sched_info_on(void)
798{
799#ifdef CONFIG_SCHEDSTATS
800 return 1;
801#elif defined(CONFIG_TASK_DELAY_ACCT)
802 extern int delayacct_on;
803 return delayacct_on;
804#else
805 return 0;
Shailabh Nagarca74e922006-07-14 00:24:36 -0700806#endif
Chandra Seetharaman52f17b62006-07-14 00:24:38 -0700807}
Shailabh Nagarca74e922006-07-14 00:24:36 -0700808
Ingo Molnard15bcfd2007-07-09 18:51:57 +0200809enum cpu_idle_type {
810 CPU_IDLE,
811 CPU_NOT_IDLE,
812 CPU_NEWLY_IDLE,
813 CPU_MAX_IDLE_TYPES
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814};
815
816/*
Nikhil Raoc8b28112011-05-18 14:37:48 -0700817 * Increase resolution of nice-level calculations for 64-bit architectures.
818 * The extra resolution improves shares distribution and load balancing of
819 * low-weight task groups (eg. nice +19 on an autogroup), deeper taskgroup
820 * hierarchies, especially on larger systems. This is not a user-visible change
821 * and does not change the user-interface for setting shares/weights.
822 *
823 * We increase resolution only if we have enough bits to allow this increased
824 * resolution (i.e. BITS_PER_LONG > 32). The costs for increasing resolution
825 * when BITS_PER_LONG <= 32 are pretty high and the returns do not justify the
826 * increased costs.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 */
Peter Zijlstrae4c2fb02011-07-05 10:56:32 +0200828#if 0 /* BITS_PER_LONG > 32 -- currently broken: it increases power usage under light load */
Nikhil Raoc8b28112011-05-18 14:37:48 -0700829# define SCHED_LOAD_RESOLUTION 10
830# define scale_load(w) ((w) << SCHED_LOAD_RESOLUTION)
831# define scale_load_down(w) ((w) >> SCHED_LOAD_RESOLUTION)
832#else
833# define SCHED_LOAD_RESOLUTION 0
834# define scale_load(w) (w)
835# define scale_load_down(w) (w)
836#endif
Ingo Molnar9aa7b362007-07-09 18:51:58 +0200837
Nikhil Raoc8b28112011-05-18 14:37:48 -0700838#define SCHED_LOAD_SHIFT (10 + SCHED_LOAD_RESOLUTION)
Ingo Molnar9aa7b362007-07-09 18:51:58 +0200839#define SCHED_LOAD_SCALE (1L << SCHED_LOAD_SHIFT)
840
Nikhil Rao1399fa72011-05-18 10:09:39 -0700841/*
842 * Increase resolution of cpu_power calculations
843 */
844#define SCHED_POWER_SHIFT 10
845#define SCHED_POWER_SCALE (1L << SCHED_POWER_SHIFT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846
Nikhil Rao1399fa72011-05-18 10:09:39 -0700847/*
848 * sched-domains (multiprocessor balancing) declarations:
849 */
Peter Williams2dd73a42006-06-27 02:54:34 -0700850#ifdef CONFIG_SMP
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200851#define SD_LOAD_BALANCE 0x0001 /* Do load balancing on this domain. */
852#define SD_BALANCE_NEWIDLE 0x0002 /* Balance when about to become idle */
853#define SD_BALANCE_EXEC 0x0004 /* Balance on exec */
854#define SD_BALANCE_FORK 0x0008 /* Balance on fork, clone */
Peter Zijlstrac88d5912009-09-10 13:50:02 +0200855#define SD_BALANCE_WAKE 0x0010 /* Balance on wakeup */
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200856#define SD_WAKE_AFFINE 0x0020 /* Wake task to waking CPU */
Peter Zijlstra59abf022009-09-16 08:28:30 +0200857#define SD_PREFER_LOCAL 0x0040 /* Prefer to keep tasks local to this domain */
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200858#define SD_SHARE_CPUPOWER 0x0080 /* Domain members share cpu power */
859#define SD_POWERSAVINGS_BALANCE 0x0100 /* Balance for power savings */
860#define SD_SHARE_PKG_RESOURCES 0x0200 /* Domain members share cpu pkg resources */
861#define SD_SERIALIZE 0x0400 /* Only a single load balancing instance */
Michael Neuling532cb4c2010-06-08 14:57:02 +1000862#define SD_ASYM_PACKING 0x0800 /* Place busy groups earlier in the domain */
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200863#define SD_PREFER_SIBLING 0x1000 /* Prefer to place tasks in a sibling domain */
Peter Zijlstrae3589f62011-07-15 10:35:52 +0200864#define SD_OVERLAP 0x2000 /* sched_domains of this level overlap */
Siddha, Suresh B5c45bf22006-06-27 02:54:42 -0700865
Gautham R Shenoyafb8a9b2008-12-18 23:26:09 +0530866enum powersavings_balance_level {
867 POWERSAVINGS_BALANCE_NONE = 0, /* No power saving load balance */
868 POWERSAVINGS_BALANCE_BASIC, /* Fill one thread/core/package
869 * first for long running threads
870 */
871 POWERSAVINGS_BALANCE_WAKEUP, /* Also bias task wakeups to semi-idle
872 * cpu package for power savings
873 */
874 MAX_POWERSAVINGS_BALANCE_LEVELS
875};
Siddha, Suresh B89c47102006-10-03 01:14:09 -0700876
Vaidyanathan Srinivasan716707b2008-12-18 23:26:02 +0530877extern int sched_mc_power_savings, sched_smt_power_savings;
Siddha, Suresh B89c47102006-10-03 01:14:09 -0700878
Vaidyanathan Srinivasan716707b2008-12-18 23:26:02 +0530879static inline int sd_balance_for_mc_power(void)
880{
881 if (sched_smt_power_savings)
882 return SD_POWERSAVINGS_BALANCE;
Siddha, Suresh B5c45bf22006-06-27 02:54:42 -0700883
Vaidyanathan Srinivasan28f53182010-02-08 15:35:55 +0530884 if (!sched_mc_power_savings)
885 return SD_PREFER_SIBLING;
886
887 return 0;
Vaidyanathan Srinivasan716707b2008-12-18 23:26:02 +0530888}
889
890static inline int sd_balance_for_package_power(void)
891{
892 if (sched_mc_power_savings | sched_smt_power_savings)
893 return SD_POWERSAVINGS_BALANCE;
894
Peter Zijlstrab5d978e2009-09-01 10:34:33 +0200895 return SD_PREFER_SIBLING;
Vaidyanathan Srinivasan716707b2008-12-18 23:26:02 +0530896}
Nick Piggin147cbb42005-06-25 14:57:19 -0700897
Michael Neuling532cb4c2010-06-08 14:57:02 +1000898extern int __weak arch_sd_sibiling_asym_packing(void);
899
Vaidyanathan Srinivasan100fdae2008-12-18 23:26:47 +0530900/*
901 * Optimise SD flags for power savings:
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300902 * SD_BALANCE_NEWIDLE helps aggressive task consolidation and power savings.
Vaidyanathan Srinivasan100fdae2008-12-18 23:26:47 +0530903 * Keep default SD flags if sched_{smt,mc}_power_saving=0
904 */
905
906static inline int sd_power_saving_flags(void)
907{
908 if (sched_mc_power_savings | sched_smt_power_savings)
909 return SD_BALANCE_NEWIDLE;
910
911 return 0;
912}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
Peter Zijlstra9c3f75c2011-07-14 13:00:06 +0200914struct sched_group_power {
Peter Zijlstrae3589f62011-07-15 10:35:52 +0200915 atomic_t ref;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 /*
917 * CPU power of this group, SCHED_LOAD_SCALE being max power for a
Peter Zijlstra18a38852009-09-01 10:34:39 +0200918 * single CPU.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 */
Peter Zijlstra9c3f75c2011-07-14 13:00:06 +0200920 unsigned int power, power_orig;
Vincent Guittot4ec44122011-12-12 20:21:08 +0100921 unsigned long next_update;
Suresh Siddha69e1e812011-12-01 17:07:33 -0800922 /*
923 * Number of busy cpus in this group.
924 */
925 atomic_t nr_busy_cpus;
Peter Zijlstra9c3f75c2011-07-14 13:00:06 +0200926};
927
928struct sched_group {
929 struct sched_group *next; /* Must be a circular list */
930 atomic_t ref;
931
Suresh Siddhaaae6d3d2010-09-17 15:02:32 -0700932 unsigned int group_weight;
Peter Zijlstra9c3f75c2011-07-14 13:00:06 +0200933 struct sched_group_power *sgp;
Rusty Russell6c99e9a2008-11-25 02:35:04 +1030934
Ingo Molnar4200efd2009-05-19 09:22:19 +0200935 /*
936 * The CPUs this group covers.
937 *
938 * NOTE: this field is variable length. (Allocated dynamically
939 * by attaching extra space to the end of the structure,
940 * depending on how many CPUs the kernel has booted up with)
Ingo Molnar4200efd2009-05-19 09:22:19 +0200941 */
942 unsigned long cpumask[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943};
944
Rusty Russell758b2cd2008-11-25 02:35:04 +1030945static inline struct cpumask *sched_group_cpus(struct sched_group *sg)
946{
Rusty Russell6c99e9a2008-11-25 02:35:04 +1030947 return to_cpumask(sg->cpumask);
Rusty Russell758b2cd2008-11-25 02:35:04 +1030948}
949
Peter Zijlstra029632f2011-10-25 10:00:11 +0200950/**
951 * group_first_cpu - Returns the first cpu in the cpumask of a sched_group.
952 * @group: The group whose first cpu is to be returned.
953 */
954static inline unsigned int group_first_cpu(struct sched_group *group)
955{
956 return cpumask_first(sched_group_cpus(group));
957}
958
Hidetoshi Seto1d3504f2008-04-15 14:04:23 +0900959struct sched_domain_attr {
960 int relax_domain_level;
961};
962
963#define SD_ATTR_INIT (struct sched_domain_attr) { \
964 .relax_domain_level = -1, \
965}
966
Peter Zijlstra60495e72011-04-07 14:10:04 +0200967extern int sched_domain_level_max;
968
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969struct sched_domain {
970 /* These fields must be setup */
971 struct sched_domain *parent; /* top domain must be null terminated */
Siddha, Suresh B1a848872006-10-03 01:14:08 -0700972 struct sched_domain *child; /* bottom domain must be null terminated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 struct sched_group *groups; /* the balancing groups of the domain */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 unsigned long min_interval; /* Minimum balance interval ms */
975 unsigned long max_interval; /* Maximum balance interval ms */
976 unsigned int busy_factor; /* less balancing by factor if busy */
977 unsigned int imbalance_pct; /* No balance until over watermark */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 unsigned int cache_nice_tries; /* Leave cache hot tasks for # tries */
Nick Piggin78979862005-06-25 14:57:13 -0700979 unsigned int busy_idx;
980 unsigned int idle_idx;
981 unsigned int newidle_idx;
982 unsigned int wake_idx;
Nick Piggin147cbb42005-06-25 14:57:19 -0700983 unsigned int forkexec_idx;
Peter Zijlstraa52bfd732009-09-01 10:34:35 +0200984 unsigned int smt_gain;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 int flags; /* See SD_* */
Peter Zijlstra60495e72011-04-07 14:10:04 +0200986 int level;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987
988 /* Runtime fields. */
989 unsigned long last_balance; /* init to jiffies. units in jiffies */
990 unsigned int balance_interval; /* initialise to 1. units in ms. */
991 unsigned int nr_balance_failed; /* initialise to 0 */
992
Peter Zijlstra2398f2c2008-06-27 13:41:35 +0200993 u64 last_update;
994
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995#ifdef CONFIG_SCHEDSTATS
996 /* load_balance() stats */
Ken Chen480b9432007-10-18 21:32:56 +0200997 unsigned int lb_count[CPU_MAX_IDLE_TYPES];
998 unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
999 unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
1000 unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
1001 unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
1002 unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
1003 unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
1004 unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
1006 /* Active load balancing */
Ken Chen480b9432007-10-18 21:32:56 +02001007 unsigned int alb_count;
1008 unsigned int alb_failed;
1009 unsigned int alb_pushed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010
Nick Piggin68767a02005-06-25 14:57:20 -07001011 /* SD_BALANCE_EXEC stats */
Ken Chen480b9432007-10-18 21:32:56 +02001012 unsigned int sbe_count;
1013 unsigned int sbe_balanced;
1014 unsigned int sbe_pushed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
Nick Piggin68767a02005-06-25 14:57:20 -07001016 /* SD_BALANCE_FORK stats */
Ken Chen480b9432007-10-18 21:32:56 +02001017 unsigned int sbf_count;
1018 unsigned int sbf_balanced;
1019 unsigned int sbf_pushed;
Nick Piggin68767a02005-06-25 14:57:20 -07001020
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 /* try_to_wake_up() stats */
Ken Chen480b9432007-10-18 21:32:56 +02001022 unsigned int ttwu_wake_remote;
1023 unsigned int ttwu_move_affine;
1024 unsigned int ttwu_move_balance;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025#endif
Ingo Molnara5d8c342008-10-09 11:35:51 +02001026#ifdef CONFIG_SCHED_DEBUG
1027 char *name;
1028#endif
Peter Zijlstradce840a2011-04-07 14:09:50 +02001029 union {
1030 void *private; /* used during construction */
1031 struct rcu_head rcu; /* used during destruction */
1032 };
Rusty Russell6c99e9a2008-11-25 02:35:04 +10301033
Peter Zijlstra669c55e2010-04-16 14:59:29 +02001034 unsigned int span_weight;
Ingo Molnar4200efd2009-05-19 09:22:19 +02001035 /*
1036 * Span of all CPUs in this domain.
1037 *
1038 * NOTE: this field is variable length. (Allocated dynamically
1039 * by attaching extra space to the end of the structure,
1040 * depending on how many CPUs the kernel has booted up with)
Ingo Molnar4200efd2009-05-19 09:22:19 +02001041 */
1042 unsigned long span[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043};
1044
Rusty Russell758b2cd2008-11-25 02:35:04 +10301045static inline struct cpumask *sched_domain_span(struct sched_domain *sd)
1046{
Rusty Russell6c99e9a2008-11-25 02:35:04 +10301047 return to_cpumask(sd->span);
Rusty Russell758b2cd2008-11-25 02:35:04 +10301048}
1049
Rusty Russellacc3f5d2009-11-03 14:53:40 +10301050extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
Hidetoshi Seto1d3504f2008-04-15 14:04:23 +09001051 struct sched_domain_attr *dattr_new);
Paul Jackson029190c2007-10-18 23:40:20 -07001052
Rusty Russellacc3f5d2009-11-03 14:53:40 +10301053/* Allocate an array of sched domains, for partition_sched_domains(). */
1054cpumask_var_t *alloc_sched_domains(unsigned int ndoms);
1055void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms);
1056
Ingo Molnar06aaf762008-12-18 21:30:23 +01001057/* Test a flag in parent sched domain */
1058static inline int test_sd_parent(struct sched_domain *sd, int flag)
1059{
1060 if (sd->parent && (sd->parent->flags & flag))
1061 return 1;
1062
1063 return 0;
1064}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
Peter Zijlstra47fe38f2009-09-02 13:49:18 +02001066unsigned long default_scale_freq_power(struct sched_domain *sd, int cpu);
1067unsigned long default_scale_smt_power(struct sched_domain *sd, int cpu);
1068
Peter Zijlstra39be3502012-01-26 12:44:34 +01001069bool cpus_share_cache(int this_cpu, int that_cpu);
1070
Ingo Molnar1b427c12008-07-18 14:01:39 +02001071#else /* CONFIG_SMP */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072
Ingo Molnar1b427c12008-07-18 14:01:39 +02001073struct sched_domain_attr;
1074
1075static inline void
Rusty Russellacc3f5d2009-11-03 14:53:40 +10301076partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
Ingo Molnar1b427c12008-07-18 14:01:39 +02001077 struct sched_domain_attr *dattr_new)
Con Kolivasd02c7a82007-07-26 13:40:43 +02001078{
Con Kolivasd02c7a82007-07-26 13:40:43 +02001079}
Peter Zijlstra39be3502012-01-26 12:44:34 +01001080
1081static inline bool cpus_share_cache(int this_cpu, int that_cpu)
1082{
1083 return true;
1084}
1085
Ingo Molnar1b427c12008-07-18 14:01:39 +02001086#endif /* !CONFIG_SMP */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087
Peter Zijlstra47fe38f2009-09-02 13:49:18 +02001088
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089struct io_context; /* See blkdev.h */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091
Chen, Kenneth W383f2832005-09-09 13:02:02 -07001092#ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
Ingo Molnar36c8b582006-07-03 00:25:41 -07001093extern void prefetch_stack(struct task_struct *t);
Chen, Kenneth W383f2832005-09-09 13:02:02 -07001094#else
1095static inline void prefetch_stack(struct task_struct *t) { }
1096#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097
1098struct audit_context; /* See audit.c */
1099struct mempolicy;
Jens Axboeb92ce552006-04-11 13:52:07 +02001100struct pipe_inode_info;
Serge E. Hallyn4865ecf2006-10-02 02:18:14 -07001101struct uts_namespace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102
Ingo Molnar20b8a592007-07-09 18:51:58 +02001103struct rq;
1104struct sched_domain;
1105
Peter Zijlstra7d478722009-09-14 19:55:44 +02001106/*
1107 * wake flags
1108 */
1109#define WF_SYNC 0x01 /* waker goes to sleep after wakup */
Peter Zijlstraa7558e02009-09-14 20:02:34 +02001110#define WF_FORK 0x02 /* child wakeup after fork */
Peter Zijlstraf339b9d2011-05-31 10:49:20 +02001111#define WF_MIGRATED 0x04 /* internal use, task got migrated */
Peter Zijlstra7d478722009-09-14 19:55:44 +02001112
Peter Zijlstra371fd7e2010-03-24 16:38:48 +01001113#define ENQUEUE_WAKEUP 1
Peter Zijlstra74f8e4b2011-04-05 17:23:47 +02001114#define ENQUEUE_HEAD 2
1115#ifdef CONFIG_SMP
1116#define ENQUEUE_WAKING 4 /* sched_class::task_waking was called */
1117#else
1118#define ENQUEUE_WAKING 0
1119#endif
Peter Zijlstra371fd7e2010-03-24 16:38:48 +01001120
1121#define DEQUEUE_SLEEP 1
1122
Ingo Molnar20b8a592007-07-09 18:51:58 +02001123struct sched_class {
Ingo Molnar5522d5d2007-10-15 17:00:12 +02001124 const struct sched_class *next;
Ingo Molnar20b8a592007-07-09 18:51:58 +02001125
Peter Zijlstra371fd7e2010-03-24 16:38:48 +01001126 void (*enqueue_task) (struct rq *rq, struct task_struct *p, int flags);
1127 void (*dequeue_task) (struct rq *rq, struct task_struct *p, int flags);
Dmitry Adamushko4530d7a2007-10-15 17:00:08 +02001128 void (*yield_task) (struct rq *rq);
Mike Galbraithd95f4122011-02-01 09:50:51 -05001129 bool (*yield_to_task) (struct rq *rq, struct task_struct *p, bool preempt);
Ingo Molnar20b8a592007-07-09 18:51:58 +02001130
Peter Zijlstra7d478722009-09-14 19:55:44 +02001131 void (*check_preempt_curr) (struct rq *rq, struct task_struct *p, int flags);
Ingo Molnar20b8a592007-07-09 18:51:58 +02001132
Ingo Molnarfb8d4722007-08-09 11:16:48 +02001133 struct task_struct * (*pick_next_task) (struct rq *rq);
Ingo Molnar31ee5292007-08-09 11:16:49 +02001134 void (*put_prev_task) (struct rq *rq, struct task_struct *p);
Ingo Molnar20b8a592007-07-09 18:51:58 +02001135
Peter Williams681f3e62007-10-24 18:23:51 +02001136#ifdef CONFIG_SMP
Peter Zijlstra7608dec2011-04-05 17:23:46 +02001137 int (*select_task_rq)(struct task_struct *p, int sd_flag, int flags);
Li Zefan4ce72a22008-10-22 15:25:26 +08001138
Steven Rostedt9a897c52008-01-25 21:08:22 +01001139 void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
1140 void (*post_schedule) (struct rq *this_rq);
Peter Zijlstra74f8e4b2011-04-05 17:23:47 +02001141 void (*task_waking) (struct task_struct *task);
Peter Zijlstraefbbd052009-12-16 18:04:40 +01001142 void (*task_woken) (struct rq *this_rq, struct task_struct *task);
Peter Williamse1d14842007-10-24 18:23:51 +02001143
Mike Traviscd8ba7c2008-03-26 14:23:49 -07001144 void (*set_cpus_allowed)(struct task_struct *p,
Rusty Russell96f874e2008-11-25 02:35:14 +10301145 const struct cpumask *newmask);
Gregory Haskins57d885f2008-01-25 21:08:18 +01001146
Gregory Haskins1f11eb62008-06-04 15:04:05 -04001147 void (*rq_online)(struct rq *rq);
1148 void (*rq_offline)(struct rq *rq);
Li Zefan4ce72a22008-10-22 15:25:26 +08001149#endif
1150
1151 void (*set_curr_task) (struct rq *rq);
1152 void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
Peter Zijlstracd29fe62009-11-27 17:32:46 +01001153 void (*task_fork) (struct task_struct *p);
Steven Rostedtcb469842008-01-25 21:08:22 +01001154
Peter Zijlstrada7a7352011-01-17 17:03:27 +01001155 void (*switched_from) (struct rq *this_rq, struct task_struct *task);
1156 void (*switched_to) (struct rq *this_rq, struct task_struct *task);
Steven Rostedtcb469842008-01-25 21:08:22 +01001157 void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
Peter Zijlstrada7a7352011-01-17 17:03:27 +01001158 int oldprio);
Peter Zijlstra810b3812008-02-29 15:21:01 -05001159
Thomas Gleixnerdba091b2009-12-09 09:32:03 +01001160 unsigned int (*get_rr_interval) (struct rq *rq,
1161 struct task_struct *task);
Peter Williams0d721ce2009-09-21 01:31:53 +00001162
Peter Zijlstra810b3812008-02-29 15:21:01 -05001163#ifdef CONFIG_FAIR_GROUP_SCHED
Peter Zijlstrab2b5ce02010-10-15 15:24:15 +02001164 void (*task_move_group) (struct task_struct *p, int on_rq);
Peter Zijlstra810b3812008-02-29 15:21:01 -05001165#endif
Ingo Molnar20b8a592007-07-09 18:51:58 +02001166};
1167
1168struct load_weight {
1169 unsigned long weight, inv_weight;
1170};
1171
Ingo Molnar94c18222007-08-02 17:41:40 +02001172#ifdef CONFIG_SCHEDSTATS
Lucas De Marchi41acab82010-03-10 23:37:45 -03001173struct sched_statistics {
Ingo Molnar94c18222007-08-02 17:41:40 +02001174 u64 wait_start;
1175 u64 wait_max;
Arjan van de Ven6d082592008-01-25 21:08:35 +01001176 u64 wait_count;
1177 u64 wait_sum;
Arjan van de Ven8f0dfc32009-07-20 11:26:58 -07001178 u64 iowait_count;
1179 u64 iowait_sum;
Ingo Molnar94c18222007-08-02 17:41:40 +02001180
1181 u64 sleep_start;
Ingo Molnar20b8a592007-07-09 18:51:58 +02001182 u64 sleep_max;
Ingo Molnar94c18222007-08-02 17:41:40 +02001183 s64 sum_sleep_runtime;
1184
1185 u64 block_start;
Ingo Molnar20b8a592007-07-09 18:51:58 +02001186 u64 block_max;
1187 u64 exec_max;
Ingo Molnareba1ed42007-10-15 17:00:02 +02001188 u64 slice_max;
Ingo Molnarcc367732007-10-15 17:00:18 +02001189
Ingo Molnarcc367732007-10-15 17:00:18 +02001190 u64 nr_migrations_cold;
1191 u64 nr_failed_migrations_affine;
1192 u64 nr_failed_migrations_running;
1193 u64 nr_failed_migrations_hot;
1194 u64 nr_forced_migrations;
Ingo Molnarcc367732007-10-15 17:00:18 +02001195
1196 u64 nr_wakeups;
1197 u64 nr_wakeups_sync;
1198 u64 nr_wakeups_migrate;
1199 u64 nr_wakeups_local;
1200 u64 nr_wakeups_remote;
1201 u64 nr_wakeups_affine;
1202 u64 nr_wakeups_affine_attempts;
1203 u64 nr_wakeups_passive;
1204 u64 nr_wakeups_idle;
Lucas De Marchi41acab82010-03-10 23:37:45 -03001205};
1206#endif
1207
1208struct sched_entity {
1209 struct load_weight load; /* for load-balancing */
1210 struct rb_node run_node;
1211 struct list_head group_node;
1212 unsigned int on_rq;
1213
1214 u64 exec_start;
1215 u64 sum_exec_runtime;
1216 u64 vruntime;
1217 u64 prev_sum_exec_runtime;
1218
Lucas De Marchi41acab82010-03-10 23:37:45 -03001219 u64 nr_migrations;
1220
Lucas De Marchi41acab82010-03-10 23:37:45 -03001221#ifdef CONFIG_SCHEDSTATS
1222 struct sched_statistics statistics;
Ingo Molnar94c18222007-08-02 17:41:40 +02001223#endif
1224
Ingo Molnar20b8a592007-07-09 18:51:58 +02001225#ifdef CONFIG_FAIR_GROUP_SCHED
1226 struct sched_entity *parent;
1227 /* rq on which this entity is (to be) queued: */
1228 struct cfs_rq *cfs_rq;
1229 /* rq "owned" by this entity/group: */
1230 struct cfs_rq *my_q;
1231#endif
1232};
Ingo Molnar70b97a72006-07-03 00:25:42 -07001233
Peter Zijlstrafa717062008-01-25 21:08:27 +01001234struct sched_rt_entity {
1235 struct list_head run_list;
Peter Zijlstra78f2c7d2008-01-25 21:08:27 +01001236 unsigned long timeout;
Richard Kennedybee367e2008-08-01 13:24:08 +01001237 unsigned int time_slice;
Peter Zijlstra6f505b12008-01-25 21:08:30 +01001238 int nr_cpus_allowed;
1239
Peter Zijlstra58d6c2d2008-04-19 19:45:00 +02001240 struct sched_rt_entity *back;
Peter Zijlstra052f1dc2008-02-13 15:45:40 +01001241#ifdef CONFIG_RT_GROUP_SCHED
Peter Zijlstra6f505b12008-01-25 21:08:30 +01001242 struct sched_rt_entity *parent;
1243 /* rq on which this entity is (to be) queued: */
1244 struct rt_rq *rt_rq;
1245 /* rq "owned" by this entity/group: */
1246 struct rt_rq *my_q;
1247#endif
Peter Zijlstrafa717062008-01-25 21:08:27 +01001248};
1249
Hiroshi Shimamotode5bdff2012-02-16 14:52:21 +09001250/*
1251 * default timeslice is 100 msecs (used only for SCHED_RR tasks).
1252 * Timeslices get refilled after they expire.
1253 */
1254#define RR_TIMESLICE (100 * HZ / 1000)
1255
Paul E. McKenney86848962009-08-27 15:00:12 -07001256struct rcu_node;
1257
Peter Zijlstra8dc85d52010-09-02 16:50:03 +02001258enum perf_event_task_context {
1259 perf_invalid_context = -1,
1260 perf_hw_context = 0,
Peter Zijlstra89a1e182010-09-07 17:34:50 +02001261 perf_sw_context,
Peter Zijlstra8dc85d52010-09-02 16:50:03 +02001262 perf_nr_task_contexts,
1263};
1264
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265struct task_struct {
1266 volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
Roman Zippelf7e42172007-05-09 02:35:17 -07001267 void *stack;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 atomic_t usage;
William Cohen97dc32c2007-05-08 00:23:41 -07001269 unsigned int flags; /* per process flags, defined below */
1270 unsigned int ptrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
Peter Williams2dd73a42006-06-27 02:54:34 -07001272#ifdef CONFIG_SMP
Peter Zijlstrafa14ff42011-09-12 13:06:17 +02001273 struct llist_node wake_entry;
Peter Zijlstra3ca7a442011-04-05 17:23:40 +02001274 int on_cpu;
Nick Piggin4866cde2005-06-25 14:57:23 -07001275#endif
Peter Zijlstrafd2f4412011-04-05 17:23:44 +02001276 int on_rq;
Ingo Molnar50e645a2007-07-09 18:52:00 +02001277
Ingo Molnarb29739f2006-06-27 02:54:51 -07001278 int prio, static_prio, normal_prio;
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001279 unsigned int rt_priority;
Ingo Molnar5522d5d2007-10-15 17:00:12 +02001280 const struct sched_class *sched_class;
Ingo Molnar20b8a592007-07-09 18:51:58 +02001281 struct sched_entity se;
Peter Zijlstrafa717062008-01-25 21:08:27 +01001282 struct sched_rt_entity rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
Avi Kivitye107be32007-07-26 13:40:43 +02001284#ifdef CONFIG_PREEMPT_NOTIFIERS
1285 /* list of struct preempt_notifier: */
1286 struct hlist_head preempt_notifiers;
1287#endif
1288
Alexey Dobriyan18796aa2007-10-16 23:30:26 -07001289 /*
1290 * fpu_counter contains the number of consecutive context switches
1291 * that the FPU is used. If this is over a threshold, the lazy fpu
1292 * saving becomes unlazy to save the trap. This is an unsigned char
1293 * so that after 256 times the counter wraps and the behavior turns
1294 * lazy again; this to deal with bursty apps that only use FPU for
1295 * a short time
1296 */
1297 unsigned char fpu_counter;
Alexey Dobriyan6c5c9342006-09-29 01:59:40 -07001298#ifdef CONFIG_BLK_DEV_IO_TRACE
Jens Axboe2056a782006-03-23 20:00:26 +01001299 unsigned int btrace_seq;
Alexey Dobriyan6c5c9342006-09-29 01:59:40 -07001300#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301
William Cohen97dc32c2007-05-08 00:23:41 -07001302 unsigned int policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 cpumask_t cpus_allowed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304
Paul E. McKenneya57eb942010-06-29 16:49:16 -07001305#ifdef CONFIG_PREEMPT_RCU
Paul E. McKenneye260be62008-01-25 21:08:24 +01001306 int rcu_read_lock_nesting;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001307 char rcu_read_unlock_special;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001308 struct list_head rcu_node_entry;
Paul E. McKenneya57eb942010-06-29 16:49:16 -07001309#endif /* #ifdef CONFIG_PREEMPT_RCU */
1310#ifdef CONFIG_TREE_PREEMPT_RCU
1311 struct rcu_node *rcu_blocked_node;
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001312#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
Paul E. McKenney24278d12010-09-27 17:25:23 -07001313#ifdef CONFIG_RCU_BOOST
1314 struct rt_mutex *rcu_boost_mutex;
1315#endif /* #ifdef CONFIG_RCU_BOOST */
Paul E. McKenneye260be62008-01-25 21:08:24 +01001316
Chandra Seetharaman52f17b62006-07-14 00:24:38 -07001317#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 struct sched_info sched_info;
1319#endif
1320
1321 struct list_head tasks;
Dario Faggioli806c09a2010-11-30 19:51:33 +01001322#ifdef CONFIG_SMP
Gregory Haskins917b6272008-12-29 09:39:53 -05001323 struct plist_node pushable_tasks;
Dario Faggioli806c09a2010-11-30 19:51:33 +01001324#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325
1326 struct mm_struct *mm, *active_mm;
Jiri Kosina4471a672011-04-14 15:22:09 -07001327#ifdef CONFIG_COMPAT_BRK
1328 unsigned brk_randomized:1;
1329#endif
KAMEZAWA Hiroyuki34e55232010-03-05 13:41:40 -08001330#if defined(SPLIT_RSS_COUNTING)
1331 struct task_rss_stat rss_stat;
1332#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333/* task state */
William Cohen97dc32c2007-05-08 00:23:41 -07001334 int exit_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 int exit_code, exit_signal;
1336 int pdeath_signal; /* The signal sent when the parent dies */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001337 unsigned int jobctl; /* JOBCTL_*, siglock protected */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 /* ??? */
William Cohen97dc32c2007-05-08 00:23:41 -07001339 unsigned int personality;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 unsigned did_exec:1;
Kentaro Takedaf9ce1f12009-02-05 17:18:11 +09001341 unsigned in_execve:1; /* Tell the LSMs that the process is doing an
1342 * execve */
Arjan van de Ven8f0dfc32009-07-20 11:26:58 -07001343 unsigned in_iowait:1;
1344
Lennart Poetteringca94c442009-06-15 17:17:47 +02001345
1346 /* Revert to default priority/policy when forking */
1347 unsigned sched_reset_on_fork:1;
Peter Zijlstraa8e4f2e2011-04-05 17:23:49 +02001348 unsigned sched_contributes_to_load:1;
Lennart Poetteringca94c442009-06-15 17:17:47 +02001349
Alexander Gordeev4bcdf1d2012-03-09 14:59:26 +01001350#ifdef CONFIG_GENERIC_HARDIRQS
1351 /* IRQ handler threads */
1352 unsigned irq_thread:1;
1353#endif
1354
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 pid_t pid;
1356 pid_t tgid;
Arjan van de Ven0a4254052006-09-26 10:52:38 +02001357
Hiroshi Shimamoto13145622009-08-18 15:06:02 +09001358#ifdef CONFIG_CC_STACKPROTECTOR
Arjan van de Ven0a4254052006-09-26 10:52:38 +02001359 /* Canary value for the -fstack-protector gcc feature */
1360 unsigned long stack_canary;
Hiroshi Shimamoto13145622009-08-18 15:06:02 +09001361#endif
Ingo Molnare0032082008-02-14 08:48:23 +01001362
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 /*
1364 * pointers to (original) parent process, youngest child, younger sibling,
1365 * older sibling, respectively. (p->father can be replaced with
Roland McGrathf4700212008-03-24 18:36:23 -07001366 * p->real_parent->pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 */
Kees Cookabd63bc2011-12-14 14:39:26 -08001368 struct task_struct __rcu *real_parent; /* real parent process */
1369 struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 /*
Roland McGrathf4700212008-03-24 18:36:23 -07001371 * children/sibling forms the list of my natural children
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 */
1373 struct list_head children; /* list of my children */
1374 struct list_head sibling; /* linkage in my parent's children list */
1375 struct task_struct *group_leader; /* threadgroup leader */
1376
Roland McGrathf4700212008-03-24 18:36:23 -07001377 /*
1378 * ptraced is the list of tasks this task is using ptrace on.
1379 * This includes both natural children and PTRACE_ATTACH targets.
1380 * p->ptrace_entry is p's link on the p->parent->ptraced list.
1381 */
1382 struct list_head ptraced;
1383 struct list_head ptrace_entry;
1384
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 /* PID/PID hash table linkage. */
Eric W. Biederman92476d72006-03-31 02:31:42 -08001386 struct pid_link pids[PIDTYPE_MAX];
Oleg Nesterov47e65322006-03-28 16:11:25 -08001387 struct list_head thread_group;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388
1389 struct completion *vfork_done; /* for vfork() */
1390 int __user *set_child_tid; /* CLONE_CHILD_SETTID */
1391 int __user *clear_child_tid; /* CLONE_CHILD_CLEARTID */
1392
Michael Neulingc66f08b2007-10-18 03:06:34 -07001393 cputime_t utime, stime, utimescaled, stimescaled;
Laurent Vivier9ac52312007-10-15 17:00:19 +02001394 cputime_t gtime;
Hidetoshi Setod99ca3b2009-12-02 17:26:47 +09001395#ifndef CONFIG_VIRT_CPU_ACCOUNTING
Balbir Singh93018992007-10-30 00:26:32 +01001396 cputime_t prev_utime, prev_stime;
Hidetoshi Setod99ca3b2009-12-02 17:26:47 +09001397#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 unsigned long nvcsw, nivcsw; /* context switch counts */
Tomas Janousek924b42d2007-07-15 23:39:42 -07001399 struct timespec start_time; /* monotonic time */
1400 struct timespec real_start_time; /* boot based time */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
1402 unsigned long min_flt, maj_flt;
1403
Frank Mayharf06febc2008-09-12 09:54:39 -07001404 struct task_cputime cputime_expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 struct list_head cpu_timers[3];
1406
1407/* process credentials */
Arnd Bergmann1b0ba1c2010-02-24 19:45:09 +01001408 const struct cred __rcu *real_cred; /* objective and real subjective task
David Howells3b11a1d2008-11-14 10:39:26 +11001409 * credentials (COW) */
Arnd Bergmann1b0ba1c2010-02-24 19:45:09 +01001410 const struct cred __rcu *cred; /* effective (overridable) subjective task
David Howells3b11a1d2008-11-14 10:39:26 +11001411 * credentials (COW) */
David Howellsee18d642009-09-02 09:14:21 +01001412 struct cred *replacement_session_keyring; /* for KEYCTL_SESSION_TO_PARENT */
David Howellsb6dff3e2008-11-14 10:39:16 +11001413
Paolo 'Blaisorblade' Giarrusso36772092005-05-05 16:16:12 -07001414 char comm[TASK_COMM_LEN]; /* executable name excluding path
1415 - access with [gs]et_task_comm (which lock
1416 it with task_lock())
Linus Torvalds221af7f2010-01-28 22:14:42 -08001417 - initialized normally by setup_new_exec */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418/* file system info */
1419 int link_count, total_link_count;
Alexey Dobriyan3d5b6fc2006-09-29 01:59:40 -07001420#ifdef CONFIG_SYSVIPC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421/* ipc stuff */
1422 struct sysv_sem sysvsem;
Alexey Dobriyan3d5b6fc2006-09-29 01:59:40 -07001423#endif
Mandeep Singh Bainese162b392009-01-15 11:08:40 -08001424#ifdef CONFIG_DETECT_HUNG_TASK
Ingo Molnar82a1fcb2008-01-25 21:08:02 +01001425/* hung task detection */
Ingo Molnar82a1fcb2008-01-25 21:08:02 +01001426 unsigned long last_switch_count;
1427#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428/* CPU-specific state of this task */
1429 struct thread_struct thread;
1430/* filesystem information */
1431 struct fs_struct *fs;
1432/* open file information */
1433 struct files_struct *files;
Serge E. Hallyn1651e142006-10-02 02:18:08 -07001434/* namespaces */
Serge E. Hallynab516012006-10-02 02:18:06 -07001435 struct nsproxy *nsproxy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436/* signal handlers */
1437 struct signal_struct *signal;
1438 struct sighand_struct *sighand;
1439
1440 sigset_t blocked, real_blocked;
Roland McGrathf3de2722008-04-30 00:53:09 -07001441 sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 struct sigpending pending;
1443
1444 unsigned long sas_ss_sp;
1445 size_t sas_ss_size;
1446 int (*notifier)(void *priv);
1447 void *notifier_data;
1448 sigset_t *notifier_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 struct audit_context *audit_context;
Al Virobfef93a2008-01-10 04:53:18 -05001450#ifdef CONFIG_AUDITSYSCALL
1451 uid_t loginuid;
Eric Paris4746ec52008-01-08 10:06:53 -05001452 unsigned int sessionid;
Al Virobfef93a2008-01-10 04:53:18 -05001453#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 seccomp_t seccomp;
1455
1456/* Thread group tracking */
1457 u32 parent_exec_id;
1458 u32 self_exec_id;
Miao Xie58568d22009-06-16 15:31:49 -07001459/* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,
1460 * mempolicy */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 spinlock_t alloc_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462
Ingo Molnarb29739f2006-06-27 02:54:51 -07001463 /* Protection of the PI data structures: */
Thomas Gleixner1d615482009-11-17 14:54:03 +01001464 raw_spinlock_t pi_lock;
Ingo Molnarb29739f2006-06-27 02:54:51 -07001465
Ingo Molnar23f78d4a2006-06-27 02:54:53 -07001466#ifdef CONFIG_RT_MUTEXES
1467 /* PI waiters blocked on a rt_mutex held by this task */
1468 struct plist_head pi_waiters;
1469 /* Deadlock detection and priority inheritance handling */
1470 struct rt_mutex_waiter *pi_blocked_on;
Ingo Molnar23f78d4a2006-06-27 02:54:53 -07001471#endif
1472
Ingo Molnar408894e2006-01-09 15:59:20 -08001473#ifdef CONFIG_DEBUG_MUTEXES
1474 /* mutex deadlock detection */
1475 struct mutex_waiter *blocked_on;
1476#endif
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001477#ifdef CONFIG_TRACE_IRQFLAGS
1478 unsigned int irq_events;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001479 unsigned long hardirq_enable_ip;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001480 unsigned long hardirq_disable_ip;
Hiroshi Shimamotofa1452e2009-11-30 14:59:44 +09001481 unsigned int hardirq_enable_event;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001482 unsigned int hardirq_disable_event;
Hiroshi Shimamotofa1452e2009-11-30 14:59:44 +09001483 int hardirqs_enabled;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001484 int hardirq_context;
Hiroshi Shimamotofa1452e2009-11-30 14:59:44 +09001485 unsigned long softirq_disable_ip;
1486 unsigned long softirq_enable_ip;
1487 unsigned int softirq_disable_event;
1488 unsigned int softirq_enable_event;
1489 int softirqs_enabled;
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001490 int softirq_context;
1491#endif
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001492#ifdef CONFIG_LOCKDEP
Peter Zijlstrabdb94412008-02-25 23:02:48 +01001493# define MAX_LOCK_DEPTH 48UL
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001494 u64 curr_chain_key;
1495 int lockdep_depth;
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001496 unsigned int lockdep_recursion;
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001497 struct held_lock held_locks[MAX_LOCK_DEPTH];
Nick Piggincf40bd12009-01-21 08:12:39 +01001498 gfp_t lockdep_reclaim_gfp;
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001499#endif
Ingo Molnar408894e2006-01-09 15:59:20 -08001500
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501/* journalling filesystem info */
1502 void *journal_info;
1503
Neil Brownd89d8792007-05-01 09:53:42 +02001504/* stacked block device info */
Akinobu Mitabddd87c2010-02-23 08:55:42 +01001505 struct bio_list *bio_list;
Neil Brownd89d8792007-05-01 09:53:42 +02001506
Jens Axboe73c10102011-03-08 13:19:51 +01001507#ifdef CONFIG_BLOCK
1508/* stack plugging */
1509 struct blk_plug *plug;
1510#endif
1511
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512/* VM state */
1513 struct reclaim_state *reclaim_state;
1514
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 struct backing_dev_info *backing_dev_info;
1516
1517 struct io_context *io_context;
1518
1519 unsigned long ptrace_message;
1520 siginfo_t *last_siginfo; /* For ptrace use. */
Andrew Morton7c3ab732006-12-10 02:19:19 -08001521 struct task_io_accounting ioac;
Jay Lan8f0ab512006-09-30 23:28:59 -07001522#if defined(CONFIG_TASK_XACCT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 u64 acct_rss_mem1; /* accumulated rss usage */
1524 u64 acct_vm_mem1; /* accumulated virtual memory usage */
Jonathan Lim49b5cf32008-07-25 01:48:40 -07001525 cputime_t acct_timexpd; /* stime + utime since last update */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526#endif
1527#ifdef CONFIG_CPUSETS
Miao Xie58568d22009-06-16 15:31:49 -07001528 nodemask_t mems_allowed; /* Protected by alloc_lock */
Mel Gormancc9a6c82012-03-21 16:34:11 -07001529 seqcount_t mems_allowed_seq; /* Seqence no to catch updates */
Paul Jackson825a46a2006-03-24 03:16:03 -08001530 int cpuset_mem_spread_rotor;
Jack Steiner6adef3e2010-05-26 14:42:49 -07001531 int cpuset_slab_spread_rotor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532#endif
Paul Menageddbcc7e2007-10-18 23:39:30 -07001533#ifdef CONFIG_CGROUPS
Paul Menage817929e2007-10-18 23:39:36 -07001534 /* Control Group info protected by css_set_lock */
Arnd Bergmann2c392b82010-02-24 19:41:39 +01001535 struct css_set __rcu *cgroups;
Paul Menage817929e2007-10-18 23:39:36 -07001536 /* cg_list protected by css_set_lock and tsk->alloc_lock */
1537 struct list_head cg_list;
Paul Menageddbcc7e2007-10-18 23:39:30 -07001538#endif
Alexey Dobriyan42b2dd02007-10-16 23:27:30 -07001539#ifdef CONFIG_FUTEX
Ingo Molnar0771dfe2006-03-27 01:16:22 -08001540 struct robust_list_head __user *robust_list;
Ingo Molnar34f192c2006-03-27 01:16:24 -08001541#ifdef CONFIG_COMPAT
1542 struct compat_robust_list_head __user *compat_robust_list;
1543#endif
Ingo Molnarc87e2832006-06-27 02:54:58 -07001544 struct list_head pi_state_list;
1545 struct futex_pi_state *pi_state_cache;
Alexey Dobriyan42b2dd02007-10-16 23:27:30 -07001546#endif
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001547#ifdef CONFIG_PERF_EVENTS
Peter Zijlstra8dc85d52010-09-02 16:50:03 +02001548 struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001549 struct mutex perf_event_mutex;
1550 struct list_head perf_event_list;
Paul Mackerrasa63eaf32009-05-22 14:17:31 +10001551#endif
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001552#ifdef CONFIG_NUMA
Miao Xie58568d22009-06-16 15:31:49 -07001553 struct mempolicy *mempolicy; /* Protected by alloc_lock */
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001554 short il_next;
Eric Dumazet207205a2011-03-22 16:30:44 -07001555 short pref_node_fork;
Richard Kennedyc7aceab2008-05-15 12:09:15 +01001556#endif
Ingo Molnare56d0902006-01-08 01:01:37 -08001557 struct rcu_head rcu;
Jens Axboeb92ce552006-04-11 13:52:07 +02001558
1559 /*
1560 * cache last used pipe for splice
1561 */
1562 struct pipe_inode_info *splice_pipe;
Shailabh Nagarca74e922006-07-14 00:24:36 -07001563#ifdef CONFIG_TASK_DELAY_ACCT
1564 struct task_delay_info *delays;
1565#endif
Akinobu Mitaf4f154f2006-12-08 02:39:47 -08001566#ifdef CONFIG_FAULT_INJECTION
1567 int make_it_fail;
1568#endif
Wu Fengguang9d823e82011-06-11 18:10:12 -06001569 /*
1570 * when (nr_dirtied >= nr_dirtied_pause), it's time to call
1571 * balance_dirty_pages() for some dirty throttling pause
1572 */
1573 int nr_dirtied;
1574 int nr_dirtied_pause;
Wu Fengguang83712352011-06-11 19:25:42 -06001575 unsigned long dirty_paused_when; /* start of a write-and-pause period */
Wu Fengguang9d823e82011-06-11 18:10:12 -06001576
Arjan van de Ven97455122008-01-25 21:08:34 +01001577#ifdef CONFIG_LATENCYTOP
1578 int latency_record_count;
1579 struct latency_record latency_record[LT_SAVECOUNT];
1580#endif
Arjan van de Ven69766752008-09-01 15:52:40 -07001581 /*
1582 * time slack values; these are used to round up poll() and
1583 * select() etc timeout values. These are in nanoseconds.
1584 */
1585 unsigned long timer_slack_ns;
1586 unsigned long default_timer_slack_ns;
David Millerf8d570a2008-11-06 00:37:40 -08001587
1588 struct list_head *scm_work_list;
Frederic Weisbeckerfb526072008-11-25 21:07:04 +01001589#ifdef CONFIG_FUNCTION_GRAPH_TRACER
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08001590 /* Index of current stored address in ret_stack */
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +01001591 int curr_ret_stack;
1592 /* Stack of return addresses for return function tracing */
1593 struct ftrace_ret_stack *ret_stack;
Steven Rostedt8aef2d22009-03-24 01:10:15 -04001594 /* time stamp for last schedule */
1595 unsigned long long ftrace_timestamp;
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +01001596 /*
1597 * Number of functions that haven't been traced
1598 * because of depth overrun.
1599 */
1600 atomic_t trace_overrun;
Frederic Weisbecker380c4b12008-12-06 03:43:41 +01001601 /* Pause for the tracing */
1602 atomic_t tracing_graph_pause;
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +01001603#endif
Steven Rostedtea4e2bc2008-12-03 15:36:57 -05001604#ifdef CONFIG_TRACING
1605 /* state flags for use by tracers */
1606 unsigned long trace;
Steven Rostedtb1cff0a2011-05-25 14:27:43 -04001607 /* bitmask and counter of trace recursion */
Steven Rostedt261842b2009-04-16 21:41:52 -04001608 unsigned long trace_recursion;
1609#endif /* CONFIG_TRACING */
KAMEZAWA Hiroyuki569b8462009-12-15 16:47:03 -08001610#ifdef CONFIG_CGROUP_MEM_RES_CTLR /* memcg uses this to do batch job */
1611 struct memcg_batch_info {
1612 int do_batch; /* incremented when batch uncharge started */
1613 struct mem_cgroup *memcg; /* target memcg of uncharge */
Johannes Weiner7ffd4ca2011-03-23 16:42:35 -07001614 unsigned long nr_pages; /* uncharged usage */
1615 unsigned long memsw_nr_pages; /* uncharged mem+swap usage */
KAMEZAWA Hiroyuki569b8462009-12-15 16:47:03 -08001616 } memcg_batch;
1617#endif
Frederic Weisbeckerbf26c012011-04-07 16:53:20 +02001618#ifdef CONFIG_HAVE_HW_BREAKPOINT
1619 atomic_t ptrace_bp_refcnt;
1620#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621};
1622
Rusty Russell76e6eee2009-03-12 14:35:43 -06001623/* Future-safe accessor for struct task_struct's cpus_allowed. */
Rusty Russella4636812009-12-17 11:43:29 -06001624#define tsk_cpus_allowed(tsk) (&(tsk)->cpus_allowed)
Rusty Russell76e6eee2009-03-12 14:35:43 -06001625
Ingo Molnare05606d2007-07-09 18:51:59 +02001626/*
1627 * Priority of a process goes from 0..MAX_PRIO-1, valid RT
1628 * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
1629 * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
1630 * values are inverted: lower p->prio value means higher priority.
1631 *
1632 * The MAX_USER_RT_PRIO value allows the actual maximum
1633 * RT priority to be separate from the value exported to
1634 * user-space. This allows kernel threads to set their
1635 * priority to a value higher than any user task. Note:
1636 * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
1637 */
1638
1639#define MAX_USER_RT_PRIO 100
1640#define MAX_RT_PRIO MAX_USER_RT_PRIO
1641
1642#define MAX_PRIO (MAX_RT_PRIO + 40)
1643#define DEFAULT_PRIO (MAX_RT_PRIO + 20)
1644
1645static inline int rt_prio(int prio)
1646{
1647 if (unlikely(prio < MAX_RT_PRIO))
1648 return 1;
1649 return 0;
1650}
1651
Alexey Dobriyane8681712007-10-26 12:17:22 +04001652static inline int rt_task(struct task_struct *p)
Ingo Molnare05606d2007-07-09 18:51:59 +02001653{
1654 return rt_prio(p->prio);
1655}
1656
Alexey Dobriyane8681712007-10-26 12:17:22 +04001657static inline struct pid *task_pid(struct task_struct *task)
Eric W. Biederman22c935f2006-10-02 02:17:09 -07001658{
1659 return task->pids[PIDTYPE_PID].pid;
1660}
1661
Alexey Dobriyane8681712007-10-26 12:17:22 +04001662static inline struct pid *task_tgid(struct task_struct *task)
Eric W. Biederman22c935f2006-10-02 02:17:09 -07001663{
1664 return task->group_leader->pids[PIDTYPE_PID].pid;
1665}
1666
Oleg Nesterov6dda81f2009-04-02 16:58:35 -07001667/*
1668 * Without tasklist or rcu lock it is not safe to dereference
1669 * the result of task_pgrp/task_session even if task == current,
1670 * we can race with another thread doing sys_setsid/sys_setpgid.
1671 */
Alexey Dobriyane8681712007-10-26 12:17:22 +04001672static inline struct pid *task_pgrp(struct task_struct *task)
Eric W. Biederman22c935f2006-10-02 02:17:09 -07001673{
1674 return task->group_leader->pids[PIDTYPE_PGID].pid;
1675}
1676
Alexey Dobriyane8681712007-10-26 12:17:22 +04001677static inline struct pid *task_session(struct task_struct *task)
Eric W. Biederman22c935f2006-10-02 02:17:09 -07001678{
1679 return task->group_leader->pids[PIDTYPE_SID].pid;
1680}
1681
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001682struct pid_namespace;
1683
1684/*
1685 * the helpers to get the task's different pids as they are seen
1686 * from various namespaces
1687 *
1688 * task_xid_nr() : global id, i.e. the id seen from the init namespace;
Eric W. Biederman44c4e1b2008-02-08 04:19:15 -08001689 * task_xid_vnr() : virtual id, i.e. the id seen from the pid namespace of
1690 * current.
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001691 * task_xid_nr_ns() : id seen from the ns specified;
1692 *
1693 * set_task_vxid() : assigns a virtual id to a task;
1694 *
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001695 * see also pid_nr() etc in include/linux/pid.h
1696 */
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001697pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
1698 struct pid_namespace *ns);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001699
Alexey Dobriyane8681712007-10-26 12:17:22 +04001700static inline pid_t task_pid_nr(struct task_struct *tsk)
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001701{
1702 return tsk->pid;
1703}
1704
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001705static inline pid_t task_pid_nr_ns(struct task_struct *tsk,
1706 struct pid_namespace *ns)
1707{
1708 return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
1709}
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001710
1711static inline pid_t task_pid_vnr(struct task_struct *tsk)
1712{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001713 return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001714}
1715
1716
Alexey Dobriyane8681712007-10-26 12:17:22 +04001717static inline pid_t task_tgid_nr(struct task_struct *tsk)
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001718{
1719 return tsk->tgid;
1720}
1721
Pavel Emelyanov2f2a3a42007-10-18 23:40:19 -07001722pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001723
1724static inline pid_t task_tgid_vnr(struct task_struct *tsk)
1725{
1726 return pid_vnr(task_tgid(tsk));
1727}
1728
1729
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001730static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,
1731 struct pid_namespace *ns)
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001732{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001733 return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001734}
1735
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001736static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
1737{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001738 return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001739}
1740
1741
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001742static inline pid_t task_session_nr_ns(struct task_struct *tsk,
1743 struct pid_namespace *ns)
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001744{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001745 return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001746}
1747
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001748static inline pid_t task_session_vnr(struct task_struct *tsk)
1749{
Oleg Nesterov52ee2df2009-04-02 16:58:38 -07001750 return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001751}
1752
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07001753/* obsolete, do not use */
1754static inline pid_t task_pgrp_nr(struct task_struct *tsk)
1755{
1756 return task_pgrp_nr_ns(tsk, &init_pid_ns);
1757}
Pavel Emelyanov7af57292007-10-18 23:40:06 -07001758
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759/**
1760 * pid_alive - check that a task structure is not stale
1761 * @p: Task structure to be checked.
1762 *
1763 * Test if a process is not yet dead (at most zombie state)
1764 * If pid_alive fails, then pointers within the task structure
1765 * can be stale and must not be dereferenced.
1766 */
Alexey Dobriyane8681712007-10-26 12:17:22 +04001767static inline int pid_alive(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768{
Eric W. Biederman92476d72006-03-31 02:31:42 -08001769 return p->pids[PIDTYPE_PID].pid != NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770}
1771
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -07001772/**
Serge E. Hallynb460cbc2007-10-18 23:39:52 -07001773 * is_global_init - check if a task structure is init
Henne32602592006-10-06 00:44:01 -07001774 * @tsk: Task structure to be checked.
1775 *
1776 * Check if a task structure is the first user space task the kernel created.
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -07001777 */
Alexey Dobriyane8681712007-10-26 12:17:22 +04001778static inline int is_global_init(struct task_struct *tsk)
Pavel Emelyanovb461cc02007-10-18 23:40:09 -07001779{
1780 return tsk->pid == 1;
1781}
Serge E. Hallynb460cbc2007-10-18 23:39:52 -07001782
1783/*
1784 * is_container_init:
1785 * check whether in the task is init in its own pid namespace.
1786 */
Pavel Emelyanovb461cc02007-10-18 23:40:09 -07001787extern int is_container_init(struct task_struct *tsk);
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -07001788
Cedric Le Goater9ec52092006-10-02 02:19:00 -07001789extern struct pid *cad_pid;
1790
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791extern void free_task(struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792#define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
Ingo Molnare56d0902006-01-08 01:01:37 -08001793
Andrew Morton158d9eb2006-03-31 02:31:34 -08001794extern void __put_task_struct(struct task_struct *t);
Ingo Molnare56d0902006-01-08 01:01:37 -08001795
1796static inline void put_task_struct(struct task_struct *t)
1797{
1798 if (atomic_dec_and_test(&t->usage))
Eric W. Biederman8c7904a2006-03-31 02:31:37 -08001799 __put_task_struct(t);
Ingo Molnare56d0902006-01-08 01:01:37 -08001800}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801
Hidetoshi Setod180c5b2009-11-26 14:48:30 +09001802extern void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st);
Hidetoshi Seto0cf55e12009-12-02 17:28:07 +09001803extern void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st);
Balbir Singh49048622008-09-05 18:12:23 +02001804
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805/*
1806 * Per process flags
1807 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808#define PF_EXITING 0x00000004 /* getting shut down */
Alexey Kuznetsov778e9a92007-06-08 13:47:00 -07001809#define PF_EXITPIDONE 0x00000008 /* pi exit done on shut down */
Laurent Vivier94886b82007-10-15 17:00:19 +02001810#define PF_VCPU 0x00000010 /* I'm a virtual CPU */
Tejun Heo21aa9af2010-06-08 21:40:37 +02001811#define PF_WQ_WORKER 0x00000020 /* I'm a workqueue worker */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812#define PF_FORKNOEXEC 0x00000040 /* forked but didn't exec */
Andi Kleen4db96cf2009-09-16 11:50:14 +02001813#define PF_MCE_PROCESS 0x00000080 /* process policy on mce errors */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814#define PF_SUPERPRIV 0x00000100 /* used super-user privileges */
1815#define PF_DUMPCORE 0x00000200 /* dumped core */
1816#define PF_SIGNALED 0x00000400 /* killed by a signal */
1817#define PF_MEMALLOC 0x00000800 /* Allocating memory */
Vasiliy Kulikov72fa5992011-08-08 19:02:04 +04001818#define PF_NPROC_EXCEEDED 0x00001000 /* set_user noticed that RLIMIT_NPROC was exceeded */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819#define PF_USED_MATH 0x00002000 /* if unset the fpu must be initialized before use */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820#define PF_NOFREEZE 0x00008000 /* this thread should not be frozen */
1821#define PF_FROZEN 0x00010000 /* frozen for system suspend */
1822#define PF_FSTRANS 0x00020000 /* inside a filesystem transaction */
1823#define PF_KSWAPD 0x00040000 /* I am kswapd */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824#define PF_LESS_THROTTLE 0x00100000 /* Throttle me less: I clean memory */
Oleg Nesterov246bb0b2008-07-25 01:47:38 -07001825#define PF_KTHREAD 0x00200000 /* I am a kernel thread */
Jens Axboeb31dc662006-06-13 08:26:10 +02001826#define PF_RANDOMIZE 0x00400000 /* randomize virtual address space */
1827#define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */
1828#define PF_SPREAD_PAGE 0x01000000 /* Spread page cache over cpuset */
1829#define PF_SPREAD_SLAB 0x02000000 /* Spread some slab caches over cpuset */
David Rientjes9985b0b2008-06-05 12:57:11 -07001830#define PF_THREAD_BOUND 0x04000000 /* Thread bound to specific cpu */
Andi Kleen4db96cf2009-09-16 11:50:14 +02001831#define PF_MCE_EARLY 0x08000000 /* Early kill for mce process policy */
Paul Jacksonc61afb12006-03-24 03:16:08 -08001832#define PF_MEMPOLICY 0x10000000 /* Non-default NUMA mempolicy */
Thomas Gleixner61a87122006-06-27 02:54:56 -07001833#define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */
Tejun Heo58a69cb2011-02-16 09:25:31 +01001834#define PF_FREEZER_SKIP 0x40000000 /* Freezer should not count it as freezable */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835
1836/*
1837 * Only the _current_ task can read/write to tsk->flags, but other
1838 * tasks can access tsk->flags in readonly mode for example
1839 * with tsk_used_math (like during threaded core dumping).
1840 * There is however an exception to this rule during ptrace
1841 * or during fork: the ptracer task is allowed to write to the
1842 * child->flags of its traced child (same goes for fork, the parent
1843 * can write to the child->flags), because we're guaranteed the
1844 * child is not running and in turn not changing child->flags
1845 * at the same time the parent does it.
1846 */
1847#define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
1848#define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
1849#define clear_used_math() clear_stopped_child_used_math(current)
1850#define set_used_math() set_stopped_child_used_math(current)
1851#define conditional_stopped_child_used_math(condition, child) \
1852 do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
1853#define conditional_used_math(condition) \
1854 conditional_stopped_child_used_math(condition, current)
1855#define copy_to_stopped_child_used_math(child) \
1856 do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
1857/* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
1858#define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
1859#define used_math() tsk_used_math(current)
1860
Tejun Heoe5c19022011-03-23 10:37:00 +01001861/*
Tejun Heoa8f072c2011-06-02 11:13:59 +02001862 * task->jobctl flags
Tejun Heoe5c19022011-03-23 10:37:00 +01001863 */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001864#define JOBCTL_STOP_SIGMASK 0xffff /* signr of the last group stop */
Tejun Heoe5c19022011-03-23 10:37:00 +01001865
Tejun Heoa8f072c2011-06-02 11:13:59 +02001866#define JOBCTL_STOP_DEQUEUED_BIT 16 /* stop signal dequeued */
1867#define JOBCTL_STOP_PENDING_BIT 17 /* task should stop for group stop */
1868#define JOBCTL_STOP_CONSUME_BIT 18 /* consume group stop count */
Tejun Heo73ddff22011-06-14 11:20:14 +02001869#define JOBCTL_TRAP_STOP_BIT 19 /* trap for STOP */
Tejun Heofb1d9102011-06-14 11:20:17 +02001870#define JOBCTL_TRAP_NOTIFY_BIT 20 /* trap for NOTIFY */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001871#define JOBCTL_TRAPPING_BIT 21 /* switching to TRACED */
Tejun Heo544b2c92011-06-14 11:20:18 +02001872#define JOBCTL_LISTENING_BIT 22 /* ptracer is listening for events */
Tejun Heoa8f072c2011-06-02 11:13:59 +02001873
1874#define JOBCTL_STOP_DEQUEUED (1 << JOBCTL_STOP_DEQUEUED_BIT)
1875#define JOBCTL_STOP_PENDING (1 << JOBCTL_STOP_PENDING_BIT)
1876#define JOBCTL_STOP_CONSUME (1 << JOBCTL_STOP_CONSUME_BIT)
Tejun Heo73ddff22011-06-14 11:20:14 +02001877#define JOBCTL_TRAP_STOP (1 << JOBCTL_TRAP_STOP_BIT)
Tejun Heofb1d9102011-06-14 11:20:17 +02001878#define JOBCTL_TRAP_NOTIFY (1 << JOBCTL_TRAP_NOTIFY_BIT)
Tejun Heoa8f072c2011-06-02 11:13:59 +02001879#define JOBCTL_TRAPPING (1 << JOBCTL_TRAPPING_BIT)
Tejun Heo544b2c92011-06-14 11:20:18 +02001880#define JOBCTL_LISTENING (1 << JOBCTL_LISTENING_BIT)
Tejun Heoa8f072c2011-06-02 11:13:59 +02001881
Tejun Heofb1d9102011-06-14 11:20:17 +02001882#define JOBCTL_TRAP_MASK (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)
Tejun Heo73ddff22011-06-14 11:20:14 +02001883#define JOBCTL_PENDING_MASK (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)
Tejun Heo3759a0d2011-06-02 11:14:00 +02001884
Tejun Heo7dd3db52011-06-02 11:14:00 +02001885extern bool task_set_jobctl_pending(struct task_struct *task,
1886 unsigned int mask);
Tejun Heo73ddff22011-06-14 11:20:14 +02001887extern void task_clear_jobctl_trapping(struct task_struct *task);
Tejun Heo3759a0d2011-06-02 11:14:00 +02001888extern void task_clear_jobctl_pending(struct task_struct *task,
1889 unsigned int mask);
Tejun Heo39efa3e2011-03-23 10:37:00 +01001890
Paul E. McKenneya57eb942010-06-29 16:49:16 -07001891#ifdef CONFIG_PREEMPT_RCU
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001892
1893#define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */
Paul E. McKenney1aa03f12012-01-11 17:25:17 -08001894#define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001895
1896static inline void rcu_copy_process(struct task_struct *p)
1897{
1898 p->rcu_read_lock_nesting = 0;
1899 p->rcu_read_unlock_special = 0;
Paul E. McKenneya57eb942010-06-29 16:49:16 -07001900#ifdef CONFIG_TREE_PREEMPT_RCU
Paul E. McKenneydd5d19b2009-08-27 14:58:16 -07001901 p->rcu_blocked_node = NULL;
Paul E. McKenney24278d12010-09-27 17:25:23 -07001902#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
1903#ifdef CONFIG_RCU_BOOST
1904 p->rcu_boost_mutex = NULL;
1905#endif /* #ifdef CONFIG_RCU_BOOST */
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001906 INIT_LIST_HEAD(&p->rcu_node_entry);
1907}
1908
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001909#else
1910
1911static inline void rcu_copy_process(struct task_struct *p)
1912{
1913}
1914
1915#endif
1916
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917#ifdef CONFIG_SMP
KOSAKI Motohiro1e1b6c52011-05-19 15:08:58 +09001918extern void do_set_cpus_allowed(struct task_struct *p,
1919 const struct cpumask *new_mask);
1920
Mike Traviscd8ba7c2008-03-26 14:23:49 -07001921extern int set_cpus_allowed_ptr(struct task_struct *p,
Rusty Russell96f874e2008-11-25 02:35:14 +10301922 const struct cpumask *new_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923#else
KOSAKI Motohiro1e1b6c52011-05-19 15:08:58 +09001924static inline void do_set_cpus_allowed(struct task_struct *p,
1925 const struct cpumask *new_mask)
1926{
1927}
Mike Traviscd8ba7c2008-03-26 14:23:49 -07001928static inline int set_cpus_allowed_ptr(struct task_struct *p,
Rusty Russell96f874e2008-11-25 02:35:14 +10301929 const struct cpumask *new_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930{
Rusty Russell96f874e2008-11-25 02:35:14 +10301931 if (!cpumask_test_cpu(0, new_mask))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 return -EINVAL;
1933 return 0;
1934}
1935#endif
Rusty Russelle0ad9552009-09-24 09:34:38 -06001936
1937#ifndef CONFIG_CPUMASK_OFFSTACK
Mike Traviscd8ba7c2008-03-26 14:23:49 -07001938static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
1939{
1940 return set_cpus_allowed_ptr(p, &new_mask);
1941}
Rusty Russelle0ad9552009-09-24 09:34:38 -06001942#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943
Ingo Molnarb3425012009-02-26 20:20:29 +01001944/*
Peter Zijlstrac6763292010-05-25 10:48:51 +02001945 * Do not use outside of architecture code which knows its limitations.
1946 *
1947 * sched_clock() has no promise of monotonicity or bounded drift between
1948 * CPUs, use (which you should not) requires disabling IRQs.
1949 *
1950 * Please use one of the three interfaces below.
Ingo Molnarb3425012009-02-26 20:20:29 +01001951 */
Mike Frysinger1bbfa6f2009-12-09 20:07:03 -05001952extern unsigned long long notrace sched_clock(void);
Peter Zijlstrac6763292010-05-25 10:48:51 +02001953/*
1954 * See the comment in kernel/sched_clock.c
1955 */
1956extern u64 cpu_clock(int cpu);
1957extern u64 local_clock(void);
1958extern u64 sched_clock_cpu(int cpu);
1959
Ingo Molnare436d802007-07-19 21:28:35 +02001960
Peter Zijlstrac1955a32008-08-11 08:59:03 +02001961extern void sched_clock_init(void);
Peter Zijlstrac1955a32008-08-11 08:59:03 +02001962
Peter Zijlstra3e51f332008-05-03 18:29:28 +02001963#ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
Peter Zijlstra3e51f332008-05-03 18:29:28 +02001964static inline void sched_clock_tick(void)
1965{
1966}
1967
1968static inline void sched_clock_idle_sleep_event(void)
1969{
1970}
1971
1972static inline void sched_clock_idle_wakeup_event(u64 delta_ns)
1973{
1974}
1975#else
Peter Zijlstrac6763292010-05-25 10:48:51 +02001976/*
1977 * Architectures can set this to 1 if they have specified
1978 * CONFIG_HAVE_UNSTABLE_SCHED_CLOCK in their arch Kconfig,
1979 * but then during bootup it turns out that sched_clock()
1980 * is reliable after all:
1981 */
1982extern int sched_clock_stable;
1983
Peter Zijlstra3e51f332008-05-03 18:29:28 +02001984extern void sched_clock_tick(void);
1985extern void sched_clock_idle_sleep_event(void);
1986extern void sched_clock_idle_wakeup_event(u64 delta_ns);
1987#endif
1988
Venkatesh Pallipadib52bfee2010-10-04 17:03:19 -07001989#ifdef CONFIG_IRQ_TIME_ACCOUNTING
1990/*
1991 * An i/f to runtime opt-in for irq time accounting based off of sched_clock.
1992 * The reason for this explicit opt-in is not to have perf penalty with
1993 * slow sched_clocks.
1994 */
1995extern void enable_sched_clock_irqtime(void);
1996extern void disable_sched_clock_irqtime(void);
1997#else
1998static inline void enable_sched_clock_irqtime(void) {}
1999static inline void disable_sched_clock_irqtime(void) {}
2000#endif
2001
Ingo Molnar36c8b582006-07-03 00:25:41 -07002002extern unsigned long long
Ingo Molnar41b86e92007-07-09 18:51:58 +02002003task_sched_runtime(struct task_struct *task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004
2005/* sched_exec is called by processes performing an exec */
2006#ifdef CONFIG_SMP
2007extern void sched_exec(void);
2008#else
2009#define sched_exec() {}
2010#endif
2011
Ingo Molnar2aa44d02007-08-23 15:18:02 +02002012extern void sched_clock_idle_sleep_event(void);
2013extern void sched_clock_idle_wakeup_event(u64 delta_ns);
Ingo Molnarbb29ab22007-07-09 18:51:59 +02002014
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015#ifdef CONFIG_HOTPLUG_CPU
2016extern void idle_task_exit(void);
2017#else
2018static inline void idle_task_exit(void) {}
2019#endif
2020
Thomas Gleixner06d83082008-03-22 09:20:24 +01002021#if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
2022extern void wake_up_idle_cpu(int cpu);
2023#else
2024static inline void wake_up_idle_cpu(int cpu) { }
2025#endif
2026
Peter Zijlstra21805082007-08-25 18:41:53 +02002027extern unsigned int sysctl_sched_latency;
Peter Zijlstrab2be5e92007-11-09 22:39:37 +01002028extern unsigned int sysctl_sched_min_granularity;
Ingo Molnarbf0f6f22007-07-09 18:51:58 +02002029extern unsigned int sysctl_sched_wakeup_granularity;
Ingo Molnarbf0f6f22007-07-09 18:51:58 +02002030extern unsigned int sysctl_sched_child_runs_first;
Christian Ehrhardt1983a922009-11-30 12:16:47 +01002031
2032enum sched_tunable_scaling {
2033 SCHED_TUNABLESCALING_NONE,
2034 SCHED_TUNABLESCALING_LOG,
2035 SCHED_TUNABLESCALING_LINEAR,
2036 SCHED_TUNABLESCALING_END,
2037};
2038extern enum sched_tunable_scaling sysctl_sched_tunable_scaling;
2039
Mike Galbraith2bba22c2009-09-09 15:41:37 +02002040#ifdef CONFIG_SCHED_DEBUG
Ingo Molnarda84d962007-10-15 17:00:18 +02002041extern unsigned int sysctl_sched_migration_cost;
Peter Zijlstrab82d9fd2007-11-09 22:39:39 +01002042extern unsigned int sysctl_sched_nr_migrate;
Peter Zijlstrae9e92502009-09-01 10:34:37 +02002043extern unsigned int sysctl_sched_time_avg;
Arun R Bharadwajcd1bb942009-04-16 12:15:34 +05302044extern unsigned int sysctl_timer_migration;
Paul Turnera7a4f8a2010-11-15 15:47:06 -08002045extern unsigned int sysctl_sched_shares_window;
Peter Zijlstrab2be5e92007-11-09 22:39:37 +01002046
Christian Ehrhardt1983a922009-11-30 12:16:47 +01002047int sched_proc_update_handler(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002048 void __user *buffer, size_t *length,
Peter Zijlstrab2be5e92007-11-09 22:39:37 +01002049 loff_t *ppos);
Ingo Molnar2bd8e6d2007-10-15 17:00:02 +02002050#endif
Arun R Bharadwajeea08f32009-04-16 12:16:41 +05302051#ifdef CONFIG_SCHED_DEBUG
2052static inline unsigned int get_sysctl_timer_migration(void)
2053{
2054 return sysctl_timer_migration;
2055}
2056#else
2057static inline unsigned int get_sysctl_timer_migration(void)
2058{
2059 return 1;
2060}
2061#endif
Peter Zijlstra9f0c1e52008-02-13 15:45:39 +01002062extern unsigned int sysctl_sched_rt_period;
2063extern int sysctl_sched_rt_runtime;
Ingo Molnar2bd8e6d2007-10-15 17:00:02 +02002064
Peter Zijlstrad0b27fa2008-04-19 19:44:57 +02002065int sched_rt_handler(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002066 void __user *buffer, size_t *lenp,
Peter Zijlstrad0b27fa2008-04-19 19:44:57 +02002067 loff_t *ppos);
2068
Mike Galbraith5091faa2010-11-30 14:18:03 +01002069#ifdef CONFIG_SCHED_AUTOGROUP
2070extern unsigned int sysctl_sched_autogroup_enabled;
2071
2072extern void sched_autogroup_create_attach(struct task_struct *p);
2073extern void sched_autogroup_detach(struct task_struct *p);
2074extern void sched_autogroup_fork(struct signal_struct *sig);
2075extern void sched_autogroup_exit(struct signal_struct *sig);
2076#ifdef CONFIG_PROC_FS
2077extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m);
Hiroshi Shimamoto2e5b5b32012-02-23 17:41:27 +09002078extern int proc_sched_autogroup_set_nice(struct task_struct *p, int nice);
Mike Galbraith5091faa2010-11-30 14:18:03 +01002079#endif
2080#else
2081static inline void sched_autogroup_create_attach(struct task_struct *p) { }
2082static inline void sched_autogroup_detach(struct task_struct *p) { }
2083static inline void sched_autogroup_fork(struct signal_struct *sig) { }
2084static inline void sched_autogroup_exit(struct signal_struct *sig) { }
2085#endif
2086
Paul Turnerec12cb72011-07-21 09:43:30 -07002087#ifdef CONFIG_CFS_BANDWIDTH
2088extern unsigned int sysctl_sched_cfs_bandwidth_slice;
2089#endif
2090
Ingo Molnarb29739f2006-06-27 02:54:51 -07002091#ifdef CONFIG_RT_MUTEXES
Ingo Molnar36c8b582006-07-03 00:25:41 -07002092extern int rt_mutex_getprio(struct task_struct *p);
2093extern void rt_mutex_setprio(struct task_struct *p, int prio);
2094extern void rt_mutex_adjust_pi(struct task_struct *p);
Thomas Gleixner3c7d5182011-07-17 20:46:52 +02002095static inline bool tsk_is_pi_blocked(struct task_struct *tsk)
2096{
2097 return tsk->pi_blocked_on != NULL;
2098}
Ingo Molnarb29739f2006-06-27 02:54:51 -07002099#else
Alexey Dobriyane8681712007-10-26 12:17:22 +04002100static inline int rt_mutex_getprio(struct task_struct *p)
Ingo Molnarb29739f2006-06-27 02:54:51 -07002101{
2102 return p->normal_prio;
2103}
Thomas Gleixner95e02ca2006-06-27 02:55:02 -07002104# define rt_mutex_adjust_pi(p) do { } while (0)
Thomas Gleixner3c7d5182011-07-17 20:46:52 +02002105static inline bool tsk_is_pi_blocked(struct task_struct *tsk)
2106{
2107 return false;
2108}
Ingo Molnarb29739f2006-06-27 02:54:51 -07002109#endif
2110
Mike Galbraithd95f4122011-02-01 09:50:51 -05002111extern bool yield_to(struct task_struct *p, bool preempt);
Ingo Molnar36c8b582006-07-03 00:25:41 -07002112extern void set_user_nice(struct task_struct *p, long nice);
2113extern int task_prio(const struct task_struct *p);
2114extern int task_nice(const struct task_struct *p);
2115extern int can_nice(const struct task_struct *p, const int nice);
2116extern int task_curr(const struct task_struct *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117extern int idle_cpu(int cpu);
KOSAKI Motohirofe7de492010-10-20 16:01:12 -07002118extern int sched_setscheduler(struct task_struct *, int,
2119 const struct sched_param *);
Rusty Russell961ccdd2008-06-23 13:55:38 +10002120extern int sched_setscheduler_nocheck(struct task_struct *, int,
KOSAKI Motohirofe7de492010-10-20 16:01:12 -07002121 const struct sched_param *);
Ingo Molnar36c8b582006-07-03 00:25:41 -07002122extern struct task_struct *idle_task(int cpu);
Paul E. McKenneyc4f30602011-11-10 12:41:56 -08002123/**
2124 * is_idle_task - is the specified task an idle task?
Randy Dunlapfa757282012-01-21 11:03:13 -08002125 * @p: the task in question.
Paul E. McKenneyc4f30602011-11-10 12:41:56 -08002126 */
Paul E. McKenney7061ca32011-12-20 08:20:46 -08002127static inline bool is_idle_task(const struct task_struct *p)
Paul E. McKenneyc4f30602011-11-10 12:41:56 -08002128{
2129 return p->pid == 0;
2130}
Ingo Molnar36c8b582006-07-03 00:25:41 -07002131extern struct task_struct *curr_task(int cpu);
2132extern void set_curr_task(int cpu, struct task_struct *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133
2134void yield(void);
2135
2136/*
2137 * The default (Linux) execution domain.
2138 */
2139extern struct exec_domain default_exec_domain;
2140
2141union thread_union {
2142 struct thread_info thread_info;
2143 unsigned long stack[THREAD_SIZE/sizeof(long)];
2144};
2145
2146#ifndef __HAVE_ARCH_KSTACK_END
2147static inline int kstack_end(void *addr)
2148{
2149 /* Reliable end of stack detection:
2150 * Some APM bios versions misalign the stack
2151 */
2152 return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
2153}
2154#endif
2155
2156extern union thread_union init_thread_union;
2157extern struct task_struct init_task;
2158
2159extern struct mm_struct init_mm;
2160
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002161extern struct pid_namespace init_pid_ns;
2162
2163/*
2164 * find a task by one of its numerical ids
2165 *
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002166 * find_task_by_pid_ns():
2167 * finds a task by its pid in the specified namespace
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -07002168 * find_task_by_vpid():
2169 * finds a task by its virtual pid
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002170 *
Pavel Emelyanove49859e2008-07-25 01:48:36 -07002171 * see also find_vpid() etc in include/linux/pid.h
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002172 */
2173
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -07002174extern struct task_struct *find_task_by_vpid(pid_t nr);
2175extern struct task_struct *find_task_by_pid_ns(pid_t nr,
2176 struct pid_namespace *ns);
Pavel Emelyanov198fe212007-10-18 23:40:06 -07002177
Oleg Nesterov8520d7c2008-02-08 04:19:09 -08002178extern void __set_special_pids(struct pid *pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179
2180/* per-UID process charging. */
Cedric Le Goateracce2922007-07-15 23:40:59 -07002181extern struct user_struct * alloc_uid(struct user_namespace *, uid_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182static inline struct user_struct *get_uid(struct user_struct *u)
2183{
2184 atomic_inc(&u->__count);
2185 return u;
2186}
2187extern void free_uid(struct user_struct *);
Pavel Emelyanov28f300d2007-09-18 22:46:45 -07002188extern void release_uids(struct user_namespace *ns);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189
2190#include <asm/current.h>
2191
Torben Hohnf0af911a92011-01-27 15:59:10 +01002192extern void xtime_update(unsigned long ticks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193
Harvey Harrisonb3c97522008-02-13 15:03:15 -08002194extern int wake_up_state(struct task_struct *tsk, unsigned int state);
2195extern int wake_up_process(struct task_struct *tsk);
Samir Bellabes3e51e3e2011-05-11 18:18:05 +02002196extern void wake_up_new_task(struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197#ifdef CONFIG_SMP
2198 extern void kick_process(struct task_struct *tsk);
2199#else
2200 static inline void kick_process(struct task_struct *tsk) { }
2201#endif
Samir Bellabes3e51e3e2011-05-11 18:18:05 +02002202extern void sched_fork(struct task_struct *p);
Ingo Molnarad46c2c2007-07-09 18:52:00 +02002203extern void sched_dead(struct task_struct *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205extern void proc_caches_init(void);
2206extern void flush_signals(struct task_struct *);
David Howells3bcac022009-04-29 13:45:05 +01002207extern void __flush_signals(struct task_struct *);
Oleg Nesterov10ab8252007-05-09 02:34:37 -07002208extern void ignore_signals(struct task_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209extern void flush_signal_handlers(struct task_struct *, int force_default);
2210extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
2211
2212static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
2213{
2214 unsigned long flags;
2215 int ret;
2216
2217 spin_lock_irqsave(&tsk->sighand->siglock, flags);
2218 ret = dequeue_signal(tsk, mask, info);
2219 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
2220
2221 return ret;
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +02002222}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223
2224extern void block_all_signals(int (*notifier)(void *priv), void *priv,
2225 sigset_t *mask);
2226extern void unblock_all_signals(void);
2227extern void release_task(struct task_struct * p);
2228extern int send_sig_info(int, struct siginfo *, struct task_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229extern int force_sigsegv(int, struct task_struct *);
2230extern int force_sig_info(int, struct siginfo *, struct task_struct *);
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07002231extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07002232extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
Serge Hallynd178bc32011-09-26 10:45:18 -05002233extern int kill_pid_info_as_cred(int, struct siginfo *, struct pid *,
2234 const struct cred *, u32);
Eric W. Biedermanc4b92fc2006-10-02 02:17:10 -07002235extern int kill_pgrp(struct pid *pid, int sig, int priv);
2236extern int kill_pid(struct pid *pid, int sig, int priv);
Matthew Wilcoxc3de4b32007-02-09 08:11:47 -07002237extern int kill_proc_info(int, struct siginfo *, pid_t);
Oleg Nesterov86773472011-06-22 23:09:09 +02002238extern __must_check bool do_notify_parent(struct task_struct *, int);
Oleg Nesterova7f07652009-09-23 15:56:44 -07002239extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240extern void force_sig(int, struct task_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241extern int send_sig(int, struct task_struct *, int);
Oleg Nesterov09faef12010-05-26 14:43:11 -07002242extern int zap_other_threads(struct task_struct *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243extern struct sigqueue *sigqueue_alloc(void);
2244extern void sigqueue_free(struct sigqueue *);
Oleg Nesterovac5c2152008-04-30 00:52:57 -07002245extern int send_sigqueue(struct sigqueue *, struct task_struct *, int group);
Oleg Nesterov9ac95f22006-02-09 22:41:50 +03002246extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long);
2248
Cedric Le Goater9ec52092006-10-02 02:19:00 -07002249static inline int kill_cad_pid(int sig, int priv)
2250{
2251 return kill_pid(cad_pid, sig, priv);
2252}
2253
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254/* These can be the second arg to send_sig_info/send_group_sig_info. */
2255#define SEND_SIG_NOINFO ((struct siginfo *) 0)
2256#define SEND_SIG_PRIV ((struct siginfo *) 1)
2257#define SEND_SIG_FORCED ((struct siginfo *) 2)
2258
Sebastian Andrzej Siewior2a855dd2009-10-25 15:37:58 +01002259/*
2260 * True if we are on the alternate signal stack.
2261 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262static inline int on_sig_stack(unsigned long sp)
2263{
Sebastian Andrzej Siewior2a855dd2009-10-25 15:37:58 +01002264#ifdef CONFIG_STACK_GROWSUP
2265 return sp >= current->sas_ss_sp &&
2266 sp - current->sas_ss_sp < current->sas_ss_size;
2267#else
2268 return sp > current->sas_ss_sp &&
2269 sp - current->sas_ss_sp <= current->sas_ss_size;
2270#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271}
2272
2273static inline int sas_ss_flags(unsigned long sp)
2274{
2275 return (current->sas_ss_size == 0 ? SS_DISABLE
2276 : on_sig_stack(sp) ? SS_ONSTACK : 0);
2277}
2278
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279/*
2280 * Routines for handling mm_structs
2281 */
2282extern struct mm_struct * mm_alloc(void);
2283
2284/* mmdrop drops the mm and the page tables */
Harvey Harrisonb3c97522008-02-13 15:03:15 -08002285extern void __mmdrop(struct mm_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286static inline void mmdrop(struct mm_struct * mm)
2287{
Ingo Molnar6fb43d72007-07-09 18:52:01 +02002288 if (unlikely(atomic_dec_and_test(&mm->mm_count)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 __mmdrop(mm);
2290}
2291
2292/* mmput gets rid of the mappings and all user-space */
2293extern void mmput(struct mm_struct *);
2294/* Grab a reference to a task's mm, if it is not already going away */
2295extern struct mm_struct *get_task_mm(struct task_struct *task);
Christopher Yeoh8cdb8782012-02-02 11:34:09 +10302296/*
2297 * Grab a reference to a task's mm, if it is not already going away
2298 * and ptrace_may_access with the mode parameter passed to it
2299 * succeeds.
2300 */
2301extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302/* Remove the current tasks stale references to the old mm_struct */
2303extern void mm_release(struct task_struct *, struct mm_struct *);
Carsten Otte402b0862008-03-25 18:47:10 +01002304/* Allocate a new mm structure and copy contents from tsk->mm */
2305extern struct mm_struct *dup_mm(struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306
Alexey Dobriyan6f2c55b2009-04-02 16:56:59 -07002307extern int copy_thread(unsigned long, unsigned long, unsigned long,
2308 struct task_struct *, struct pt_regs *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309extern void flush_thread(void);
2310extern void exit_thread(void);
2311
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312extern void exit_files(struct task_struct *);
Oleg Nesterova7e53282006-03-28 16:11:27 -08002313extern void __cleanup_sighand(struct sighand_struct *);
Oleg Nesterovcbaffba2008-05-26 20:55:42 +04002314
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315extern void exit_itimers(struct signal_struct *);
Oleg Nesterovcbaffba2008-05-26 20:55:42 +04002316extern void flush_itimer_signals(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317
Joe Perches9402c952012-01-12 17:17:17 -08002318extern void do_group_exit(int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320extern void daemonize(const char *, ...);
2321extern int allow_signal(int);
2322extern int disallow_signal(int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323
David Howellsd7627462010-08-17 23:52:56 +01002324extern int do_execve(const char *,
2325 const char __user * const __user *,
2326 const char __user * const __user *, struct pt_regs *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
Ingo Molnar36c8b582006-07-03 00:25:41 -07002328struct task_struct *fork_idle(int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329
2330extern void set_task_comm(struct task_struct *tsk, char *from);
Andrew Morton59714d62008-02-04 22:27:21 -08002331extern char *get_task_comm(char *to, struct task_struct *tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332
2333#ifdef CONFIG_SMP
Peter Zijlstra317f3942011-04-05 17:23:58 +02002334void scheduler_ipi(void);
Roland McGrath85ba2d82008-07-25 19:45:58 -07002335extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336#else
Peter Zijlstra184748c2011-04-05 17:23:39 +02002337static inline void scheduler_ipi(void) { }
Roland McGrath85ba2d82008-07-25 19:45:58 -07002338static inline unsigned long wait_task_inactive(struct task_struct *p,
2339 long match_state)
2340{
2341 return 1;
2342}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343#endif
2344
Jiri Pirko05725f72009-04-14 20:17:16 +02002345#define next_task(p) \
2346 list_entry_rcu((p)->tasks.next, struct task_struct, tasks)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347
2348#define for_each_process(p) \
2349 for (p = &init_task ; (p = next_task(p)) != &init_task ; )
2350
Oleg Nesterov5bb459b2009-07-10 03:48:23 +02002351extern bool current_is_single_threaded(void);
David Howellsd84f4f92008-11-14 10:39:23 +11002352
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353/*
2354 * Careful: do_each_thread/while_each_thread is a double loop so
2355 * 'break' will not work as expected - use goto instead.
2356 */
2357#define do_each_thread(g, t) \
2358 for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
2359
2360#define while_each_thread(g, t) \
2361 while ((t = next_thread(t)) != g)
2362
Oleg Nesterov7e498272010-05-26 14:43:22 -07002363static inline int get_nr_threads(struct task_struct *tsk)
2364{
Oleg Nesterovb3ac0222010-05-26 14:43:24 -07002365 return tsk->signal->nr_threads;
Oleg Nesterov7e498272010-05-26 14:43:22 -07002366}
2367
Oleg Nesterov087806b2011-06-22 23:10:26 +02002368static inline bool thread_group_leader(struct task_struct *p)
2369{
2370 return p->exit_signal >= 0;
2371}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002373/* Do to the insanities of de_thread it is possible for a process
2374 * to have the pid of the thread group leader without actually being
2375 * the thread group leader. For iteration through the pids in proc
2376 * all we care about is that we have a task with the appropriate
2377 * pid, we don't actually care if we have the right task.
2378 */
Alexey Dobriyane8681712007-10-26 12:17:22 +04002379static inline int has_group_leader_pid(struct task_struct *p)
Eric W. Biederman0804ef42006-10-02 02:17:04 -07002380{
2381 return p->pid == p->tgid;
2382}
2383
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -07002384static inline
2385int same_thread_group(struct task_struct *p1, struct task_struct *p2)
2386{
2387 return p1->tgid == p2->tgid;
2388}
2389
Ingo Molnar36c8b582006-07-03 00:25:41 -07002390static inline struct task_struct *next_thread(const struct task_struct *p)
Oleg Nesterov47e65322006-03-28 16:11:25 -08002391{
Jiri Pirko05725f72009-04-14 20:17:16 +02002392 return list_entry_rcu(p->thread_group.next,
2393 struct task_struct, thread_group);
Oleg Nesterov47e65322006-03-28 16:11:25 -08002394}
2395
Alexey Dobriyane8681712007-10-26 12:17:22 +04002396static inline int thread_group_empty(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002397{
Oleg Nesterov47e65322006-03-28 16:11:25 -08002398 return list_empty(&p->thread_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399}
2400
2401#define delay_group_leader(p) \
2402 (thread_group_leader(p) && !thread_group_empty(p))
2403
Linus Torvalds1da177e2005-04-16 15:20:36 -07002404/*
Eric W. Biederman260ea102006-06-23 02:05:18 -07002405 * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
Jens Axboe22e2c502005-06-27 10:55:12 +02002406 * subscriptions and synchronises with wait4(). Also used in procfs. Also
Paul Menageddbcc7e2007-10-18 23:39:30 -07002407 * pins the final release of task.io_context. Also protects ->cpuset and
Oleg Nesterovd68b46f2012-03-05 14:59:13 -08002408 * ->cgroup.subsys[]. And ->vfork_done.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409 *
2410 * Nests both inside and outside of read_lock(&tasklist_lock).
2411 * It must not be nested with write_lock_irq(&tasklist_lock),
2412 * neither inside nor outside.
2413 */
2414static inline void task_lock(struct task_struct *p)
2415{
2416 spin_lock(&p->alloc_lock);
2417}
2418
2419static inline void task_unlock(struct task_struct *p)
2420{
2421 spin_unlock(&p->alloc_lock);
2422}
2423
Namhyung Kimb8ed3742010-10-27 15:34:06 -07002424extern struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
Oleg Nesterovf63ee722006-03-28 16:11:13 -08002425 unsigned long *flags);
2426
Anton Vorontsov9388dc32012-02-09 20:45:19 +04002427static inline struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
2428 unsigned long *flags)
2429{
2430 struct sighand_struct *ret;
2431
2432 ret = __lock_task_sighand(tsk, flags);
2433 (void)__cond_lock(&tsk->sighand->siglock, ret);
2434 return ret;
2435}
Namhyung Kimb8ed3742010-10-27 15:34:06 -07002436
Oleg Nesterovf63ee722006-03-28 16:11:13 -08002437static inline void unlock_task_sighand(struct task_struct *tsk,
2438 unsigned long *flags)
2439{
2440 spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
2441}
2442
Ben Blum4714d1d2011-05-26 16:25:18 -07002443#ifdef CONFIG_CGROUPS
Tejun Heo257058a2011-12-12 18:12:21 -08002444static inline void threadgroup_change_begin(struct task_struct *tsk)
Ben Blum4714d1d2011-05-26 16:25:18 -07002445{
Tejun Heo257058a2011-12-12 18:12:21 -08002446 down_read(&tsk->signal->group_rwsem);
Ben Blum4714d1d2011-05-26 16:25:18 -07002447}
Tejun Heo257058a2011-12-12 18:12:21 -08002448static inline void threadgroup_change_end(struct task_struct *tsk)
Ben Blum4714d1d2011-05-26 16:25:18 -07002449{
Tejun Heo257058a2011-12-12 18:12:21 -08002450 up_read(&tsk->signal->group_rwsem);
Ben Blum4714d1d2011-05-26 16:25:18 -07002451}
Tejun Heo77e4ef92011-12-12 18:12:21 -08002452
2453/**
2454 * threadgroup_lock - lock threadgroup
2455 * @tsk: member task of the threadgroup to lock
2456 *
2457 * Lock the threadgroup @tsk belongs to. No new task is allowed to enter
2458 * and member tasks aren't allowed to exit (as indicated by PF_EXITING) or
2459 * perform exec. This is useful for cases where the threadgroup needs to
2460 * stay stable across blockable operations.
2461 *
2462 * fork and exit paths explicitly call threadgroup_change_{begin|end}() for
2463 * synchronization. While held, no new task will be added to threadgroup
2464 * and no existing live task will have its PF_EXITING set.
2465 *
2466 * During exec, a task goes and puts its thread group through unusual
2467 * changes. After de-threading, exclusive access is assumed to resources
2468 * which are usually shared by tasks in the same group - e.g. sighand may
2469 * be replaced with a new one. Also, the exec'ing task takes over group
2470 * leader role including its pid. Exclude these changes while locked by
2471 * grabbing cred_guard_mutex which is used to synchronize exec path.
2472 */
Tejun Heo257058a2011-12-12 18:12:21 -08002473static inline void threadgroup_lock(struct task_struct *tsk)
Ben Blum4714d1d2011-05-26 16:25:18 -07002474{
Tejun Heo77e4ef92011-12-12 18:12:21 -08002475 /*
2476 * exec uses exit for de-threading nesting group_rwsem inside
2477 * cred_guard_mutex. Grab cred_guard_mutex first.
2478 */
2479 mutex_lock(&tsk->signal->cred_guard_mutex);
Tejun Heo257058a2011-12-12 18:12:21 -08002480 down_write(&tsk->signal->group_rwsem);
Ben Blum4714d1d2011-05-26 16:25:18 -07002481}
Tejun Heo77e4ef92011-12-12 18:12:21 -08002482
2483/**
2484 * threadgroup_unlock - unlock threadgroup
2485 * @tsk: member task of the threadgroup to unlock
2486 *
2487 * Reverse threadgroup_lock().
2488 */
Tejun Heo257058a2011-12-12 18:12:21 -08002489static inline void threadgroup_unlock(struct task_struct *tsk)
Ben Blum4714d1d2011-05-26 16:25:18 -07002490{
Tejun Heo257058a2011-12-12 18:12:21 -08002491 up_write(&tsk->signal->group_rwsem);
Tejun Heo77e4ef92011-12-12 18:12:21 -08002492 mutex_unlock(&tsk->signal->cred_guard_mutex);
Ben Blum4714d1d2011-05-26 16:25:18 -07002493}
2494#else
Tejun Heo257058a2011-12-12 18:12:21 -08002495static inline void threadgroup_change_begin(struct task_struct *tsk) {}
2496static inline void threadgroup_change_end(struct task_struct *tsk) {}
2497static inline void threadgroup_lock(struct task_struct *tsk) {}
2498static inline void threadgroup_unlock(struct task_struct *tsk) {}
Ben Blum4714d1d2011-05-26 16:25:18 -07002499#endif
2500
Al Virof0373602005-11-13 16:06:57 -08002501#ifndef __HAVE_THREAD_FUNCTIONS
2502
Roman Zippelf7e42172007-05-09 02:35:17 -07002503#define task_thread_info(task) ((struct thread_info *)(task)->stack)
2504#define task_stack_page(task) ((task)->stack)
Al Viroa1261f52005-11-13 16:06:55 -08002505
Al Viro10ebffd2005-11-13 16:06:56 -08002506static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
2507{
2508 *task_thread_info(p) = *task_thread_info(org);
2509 task_thread_info(p)->task = p;
2510}
2511
2512static inline unsigned long *end_of_stack(struct task_struct *p)
2513{
Roman Zippelf7e42172007-05-09 02:35:17 -07002514 return (unsigned long *)(task_thread_info(p) + 1);
Al Viro10ebffd2005-11-13 16:06:56 -08002515}
2516
Al Virof0373602005-11-13 16:06:57 -08002517#endif
2518
FUJITA Tomonori8b05c7e2008-07-23 21:26:53 -07002519static inline int object_is_on_stack(void *obj)
2520{
2521 void *stack = task_stack_page(current);
2522
2523 return (obj >= stack) && (obj < (stack + THREAD_SIZE));
2524}
2525
Benjamin Herrenschmidt8c9843e2008-04-18 16:56:15 +10002526extern void thread_info_cache_init(void);
2527
Eric Sandeen7c9f8862008-04-22 16:38:23 -05002528#ifdef CONFIG_DEBUG_STACK_USAGE
2529static inline unsigned long stack_not_used(struct task_struct *p)
2530{
2531 unsigned long *n = end_of_stack(p);
2532
2533 do { /* Skip over canary */
2534 n++;
2535 } while (!*n);
2536
2537 return (unsigned long)n - (unsigned long)end_of_stack(p);
2538}
2539#endif
2540
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541/* set thread flags in other task's structures
2542 * - see asm/thread_info.h for TIF_xxxx flags available
2543 */
2544static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
2545{
Al Viroa1261f52005-11-13 16:06:55 -08002546 set_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547}
2548
2549static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2550{
Al Viroa1261f52005-11-13 16:06:55 -08002551 clear_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552}
2553
2554static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
2555{
Al Viroa1261f52005-11-13 16:06:55 -08002556 return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557}
2558
2559static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2560{
Al Viroa1261f52005-11-13 16:06:55 -08002561 return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562}
2563
2564static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
2565{
Al Viroa1261f52005-11-13 16:06:55 -08002566 return test_ti_thread_flag(task_thread_info(tsk), flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002567}
2568
2569static inline void set_tsk_need_resched(struct task_struct *tsk)
2570{
2571 set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2572}
2573
2574static inline void clear_tsk_need_resched(struct task_struct *tsk)
2575{
2576 clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2577}
2578
Gregory Haskins8ae121a2008-04-23 07:13:29 -04002579static inline int test_tsk_need_resched(struct task_struct *tsk)
2580{
2581 return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
2582}
2583
Eric W. Biederman690cc3f2009-05-13 16:55:10 +00002584static inline int restart_syscall(void)
2585{
2586 set_tsk_thread_flag(current, TIF_SIGPENDING);
2587 return -ERESTARTNOINTR;
2588}
2589
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590static inline int signal_pending(struct task_struct *p)
2591{
2592 return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
2593}
Matthew Wilcoxf776d122007-12-06 11:15:50 -05002594
Roland McGrathd9588722009-09-23 15:57:04 -07002595static inline int __fatal_signal_pending(struct task_struct *p)
2596{
2597 return unlikely(sigismember(&p->pending.signal, SIGKILL));
2598}
Matthew Wilcoxf776d122007-12-06 11:15:50 -05002599
2600static inline int fatal_signal_pending(struct task_struct *p)
2601{
2602 return signal_pending(p) && __fatal_signal_pending(p);
2603}
2604
Oleg Nesterov16882c12008-06-08 21:20:41 +04002605static inline int signal_pending_state(long state, struct task_struct *p)
2606{
2607 if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
2608 return 0;
2609 if (!signal_pending(p))
2610 return 0;
2611
Oleg Nesterov16882c12008-06-08 21:20:41 +04002612 return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
2613}
2614
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615static inline int need_resched(void)
2616{
Linus Torvalds9404ef02008-05-12 10:14:22 -07002617 return unlikely(test_thread_flag(TIF_NEED_RESCHED));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002618}
2619
2620/*
2621 * cond_resched() and cond_resched_lock(): latency reduction via
2622 * explicit rescheduling in places that are safe. The return
2623 * value indicates whether a reschedule was done in fact.
2624 * cond_resched_lock() will drop the spinlock before scheduling,
2625 * cond_resched_softirq() will enable bhs before scheduling.
2626 */
Linus Torvaldsc3921ab2008-05-11 16:04:48 -07002627extern int _cond_resched(void);
Frederic Weisbecker6f80bd92009-07-16 15:44:29 +02002628
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002629#define cond_resched() ({ \
2630 __might_sleep(__FILE__, __LINE__, 0); \
2631 _cond_resched(); \
2632})
Frederic Weisbecker6f80bd92009-07-16 15:44:29 +02002633
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002634extern int __cond_resched_lock(spinlock_t *lock);
2635
Frederic Weisbeckerbdd4e852011-06-08 01:13:27 +02002636#ifdef CONFIG_PREEMPT_COUNT
Frederic Weisbecker716a4232009-07-24 20:05:23 +02002637#define PREEMPT_LOCK_OFFSET PREEMPT_OFFSET
Herbert Xu02b67cc32008-01-25 21:08:28 +01002638#else
Frederic Weisbecker716a4232009-07-24 20:05:23 +02002639#define PREEMPT_LOCK_OFFSET 0
Herbert Xu02b67cc32008-01-25 21:08:28 +01002640#endif
Frederic Weisbecker716a4232009-07-24 20:05:23 +02002641
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002642#define cond_resched_lock(lock) ({ \
Frederic Weisbecker716a4232009-07-24 20:05:23 +02002643 __might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET); \
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002644 __cond_resched_lock(lock); \
2645})
2646
2647extern int __cond_resched_softirq(void);
2648
Venkatesh Pallipadi75e10562010-10-04 17:03:16 -07002649#define cond_resched_softirq() ({ \
2650 __might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET); \
2651 __cond_resched_softirq(); \
Frederic Weisbecker613afbf2009-07-16 15:44:29 +02002652})
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653
2654/*
2655 * Does a critical section need to be broken due to another
Nick Piggin95c354f2008-01-30 13:31:20 +01002656 * task waiting?: (technically does not depend on CONFIG_PREEMPT,
2657 * but a general need for low latency)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002658 */
Nick Piggin95c354f2008-01-30 13:31:20 +01002659static inline int spin_needbreak(spinlock_t *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660{
Nick Piggin95c354f2008-01-30 13:31:20 +01002661#ifdef CONFIG_PREEMPT
2662 return spin_is_contended(lock);
2663#else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 return 0;
Nick Piggin95c354f2008-01-30 13:31:20 +01002665#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002666}
2667
Roland McGrath7bb44ad2007-05-23 13:57:44 -07002668/*
Frank Mayharf06febc2008-09-12 09:54:39 -07002669 * Thread group CPU time accounting.
2670 */
Peter Zijlstra4cd4c1b2009-02-05 12:24:16 +01002671void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
Peter Zijlstra4da94d492009-02-11 11:30:27 +01002672void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
Frank Mayharf06febc2008-09-12 09:54:39 -07002673
2674static inline void thread_group_cputime_init(struct signal_struct *sig)
2675{
Thomas Gleixneree30a7b2009-07-25 18:56:56 +02002676 raw_spin_lock_init(&sig->cputimer.lock);
Frank Mayharf06febc2008-09-12 09:54:39 -07002677}
2678
Frank Mayharf06febc2008-09-12 09:54:39 -07002679/*
Roland McGrath7bb44ad2007-05-23 13:57:44 -07002680 * Reevaluate whether the task has signals pending delivery.
2681 * Wake the task if so.
2682 * This is required every time the blocked sigset_t changes.
2683 * callers must hold sighand->siglock.
2684 */
2685extern void recalc_sigpending_and_wake(struct task_struct *t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686extern void recalc_sigpending(void);
2687
2688extern void signal_wake_up(struct task_struct *t, int resume_stopped);
2689
2690/*
2691 * Wrappers for p->thread_info->cpu access. No-op on UP.
2692 */
2693#ifdef CONFIG_SMP
2694
2695static inline unsigned int task_cpu(const struct task_struct *p)
2696{
Al Viroa1261f52005-11-13 16:06:55 -08002697 return task_thread_info(p)->cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698}
2699
Ingo Molnarc65cc872007-07-09 18:51:58 +02002700extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701
2702#else
2703
2704static inline unsigned int task_cpu(const struct task_struct *p)
2705{
2706 return 0;
2707}
2708
2709static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
2710{
2711}
2712
2713#endif /* CONFIG_SMP */
2714
Rusty Russell96f874e2008-11-25 02:35:14 +10302715extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
2716extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
Siddha, Suresh B5c45bf22006-06-27 02:54:42 -07002717
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718extern void normalize_rt_tasks(void);
2719
Dhaval Giani7c941432010-01-20 13:26:18 +01002720#ifdef CONFIG_CGROUP_SCHED
Srivatsa Vaddagiri9b5b7752007-10-15 17:00:09 +02002721
Yong Zhang07e06b02011-01-07 15:17:36 +08002722extern struct task_group root_task_group;
Srivatsa Vaddagiri9b5b7752007-10-15 17:00:09 +02002723
Dhaval Gianiec7dc8a2008-04-19 19:44:59 +02002724extern struct task_group *sched_create_group(struct task_group *parent);
Ingo Molnar4cf86d72007-10-15 17:00:14 +02002725extern void sched_destroy_group(struct task_group *tg);
Srivatsa Vaddagiri9b5b7752007-10-15 17:00:09 +02002726extern void sched_move_task(struct task_struct *tsk);
Peter Zijlstra052f1dc2008-02-13 15:45:40 +01002727#ifdef CONFIG_FAIR_GROUP_SCHED
Ingo Molnar4cf86d72007-10-15 17:00:14 +02002728extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
Dhaval Giani5cb350b2007-10-15 17:00:14 +02002729extern unsigned long sched_group_shares(struct task_group *tg);
Peter Zijlstra052f1dc2008-02-13 15:45:40 +01002730#endif
2731#ifdef CONFIG_RT_GROUP_SCHED
Peter Zijlstra9f0c1e52008-02-13 15:45:39 +01002732extern int sched_group_set_rt_runtime(struct task_group *tg,
2733 long rt_runtime_us);
2734extern long sched_group_rt_runtime(struct task_group *tg);
Peter Zijlstrad0b27fa2008-04-19 19:44:57 +02002735extern int sched_group_set_rt_period(struct task_group *tg,
2736 long rt_period_us);
2737extern long sched_group_rt_period(struct task_group *tg);
Dhaval Giani54e99122009-02-27 15:13:54 +05302738extern int sched_rt_can_attach(struct task_group *tg, struct task_struct *tsk);
Peter Zijlstra052f1dc2008-02-13 15:45:40 +01002739#endif
Srivatsa Vaddagiri9b5b7752007-10-15 17:00:09 +02002740#endif
2741
Dhaval Giani54e99122009-02-27 15:13:54 +05302742extern int task_can_switch_user(struct user_struct *up,
2743 struct task_struct *tsk);
2744
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002745#ifdef CONFIG_TASK_XACCT
2746static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2747{
Andrea Righi940389b2008-07-28 00:48:12 +02002748 tsk->ioac.rchar += amt;
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002749}
2750
2751static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2752{
Andrea Righi940389b2008-07-28 00:48:12 +02002753 tsk->ioac.wchar += amt;
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002754}
2755
2756static inline void inc_syscr(struct task_struct *tsk)
2757{
Andrea Righi940389b2008-07-28 00:48:12 +02002758 tsk->ioac.syscr++;
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002759}
2760
2761static inline void inc_syscw(struct task_struct *tsk)
2762{
Andrea Righi940389b2008-07-28 00:48:12 +02002763 tsk->ioac.syscw++;
Alexey Dobriyan4b98d112007-02-10 01:46:45 -08002764}
2765#else
2766static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2767{
2768}
2769
2770static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2771{
2772}
2773
2774static inline void inc_syscr(struct task_struct *tsk)
2775{
2776}
2777
2778static inline void inc_syscw(struct task_struct *tsk)
2779{
2780}
2781#endif
2782
Dave Hansen82455252008-02-04 22:28:59 -08002783#ifndef TASK_SIZE_OF
2784#define TASK_SIZE_OF(tsk) TASK_SIZE
2785#endif
2786
Balbir Singhcf475ad2008-04-29 01:00:16 -07002787#ifdef CONFIG_MM_OWNER
2788extern void mm_update_next_owner(struct mm_struct *mm);
2789extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
2790#else
2791static inline void mm_update_next_owner(struct mm_struct *mm)
2792{
2793}
2794
2795static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
2796{
2797}
2798#endif /* CONFIG_MM_OWNER */
2799
Jiri Slaby3e10e712009-11-19 17:16:37 +01002800static inline unsigned long task_rlimit(const struct task_struct *tsk,
2801 unsigned int limit)
2802{
2803 return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_cur);
2804}
2805
2806static inline unsigned long task_rlimit_max(const struct task_struct *tsk,
2807 unsigned int limit)
2808{
2809 return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_max);
2810}
2811
2812static inline unsigned long rlimit(unsigned int limit)
2813{
2814 return task_rlimit(current, limit);
2815}
2816
2817static inline unsigned long rlimit_max(unsigned int limit)
2818{
2819 return task_rlimit_max(current, limit);
2820}
2821
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822#endif /* __KERNEL__ */
2823
2824#endif