11da177e4SLinus Torvalds #ifndef _LINUX_SCHED_H 21da177e4SLinus Torvalds #define _LINUX_SCHED_H 31da177e4SLinus Torvalds 4b7b3c76aSDavid Woodhouse /* 5b7b3c76aSDavid Woodhouse * cloning flags: 6b7b3c76aSDavid Woodhouse */ 7b7b3c76aSDavid Woodhouse #define CSIGNAL 0x000000ff /* signal mask to be sent at exit */ 8b7b3c76aSDavid Woodhouse #define CLONE_VM 0x00000100 /* set if VM shared between processes */ 9b7b3c76aSDavid Woodhouse #define CLONE_FS 0x00000200 /* set if fs info shared between processes */ 10b7b3c76aSDavid Woodhouse #define CLONE_FILES 0x00000400 /* set if open files shared between processes */ 11b7b3c76aSDavid Woodhouse #define CLONE_SIGHAND 0x00000800 /* set if signal handlers and blocked signals shared */ 12b7b3c76aSDavid Woodhouse #define CLONE_PTRACE 0x00002000 /* set if we want to let tracing continue on the child too */ 13b7b3c76aSDavid Woodhouse #define CLONE_VFORK 0x00004000 /* set if the parent wants the child to wake it up on mm_release */ 14b7b3c76aSDavid Woodhouse #define CLONE_PARENT 0x00008000 /* set if we want to have the same parent as the cloner */ 15b7b3c76aSDavid Woodhouse #define CLONE_THREAD 0x00010000 /* Same thread group? */ 16b7b3c76aSDavid Woodhouse #define CLONE_NEWNS 0x00020000 /* New namespace group? */ 17b7b3c76aSDavid Woodhouse #define CLONE_SYSVSEM 0x00040000 /* share system V SEM_UNDO semantics */ 18b7b3c76aSDavid Woodhouse #define CLONE_SETTLS 0x00080000 /* create a new TLS for the child */ 19b7b3c76aSDavid Woodhouse #define CLONE_PARENT_SETTID 0x00100000 /* set the TID in the parent */ 20b7b3c76aSDavid Woodhouse #define CLONE_CHILD_CLEARTID 0x00200000 /* clear the TID in the child */ 21b7b3c76aSDavid Woodhouse #define CLONE_DETACHED 0x00400000 /* Unused, ignored */ 22b7b3c76aSDavid Woodhouse #define CLONE_UNTRACED 0x00800000 /* set if the tracing process can't force CLONE_PTRACE on this clone */ 23b7b3c76aSDavid Woodhouse #define CLONE_CHILD_SETTID 0x01000000 /* set the TID in the child */ 2443bb40c9SDave Jones /* 0x02000000 was previously the unused CLONE_STOPPED (Start in stopped state) 2543bb40c9SDave Jones and is now available for re-use. */ 26071df104SSerge E. Hallyn #define CLONE_NEWUTS 0x04000000 /* New utsname group? */ 2725b21cb2SKirill Korotaev #define CLONE_NEWIPC 0x08000000 /* New ipcs */ 2877ec739dSSerge E. Hallyn #define CLONE_NEWUSER 0x10000000 /* New user namespace */ 2930e49c26SPavel Emelyanov #define CLONE_NEWPID 0x20000000 /* New pid namespace */ 30169e3674SEric W. Biederman #define CLONE_NEWNET 0x40000000 /* New network namespace */ 31fadad878SJens Axboe #define CLONE_IO 0x80000000 /* Clone io context */ 32b7b3c76aSDavid Woodhouse 33b7b3c76aSDavid Woodhouse /* 34b7b3c76aSDavid Woodhouse * Scheduling policies 35b7b3c76aSDavid Woodhouse */ 36b7b3c76aSDavid Woodhouse #define SCHED_NORMAL 0 37b7b3c76aSDavid Woodhouse #define SCHED_FIFO 1 38b7b3c76aSDavid Woodhouse #define SCHED_RR 2 39b7b3c76aSDavid Woodhouse #define SCHED_BATCH 3 400e6aca43SIngo Molnar /* SCHED_ISO: reserved but not implemented yet */ 410e6aca43SIngo Molnar #define SCHED_IDLE 5 42ca94c442SLennart Poettering /* Can be ORed in to make sure the process is reverted back to SCHED_NORMAL on fork */ 43ca94c442SLennart Poettering #define SCHED_RESET_ON_FORK 0x40000000 44b7b3c76aSDavid Woodhouse 45a3b6714eSDavid Woodhouse #ifdef __KERNEL__ 46b7b3c76aSDavid Woodhouse 47b7b3c76aSDavid Woodhouse struct sched_param { 48b7b3c76aSDavid Woodhouse int sched_priority; 49b7b3c76aSDavid Woodhouse }; 50b7b3c76aSDavid Woodhouse 511da177e4SLinus Torvalds #include <asm/param.h> /* for HZ */ 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds #include <linux/capability.h> 541da177e4SLinus Torvalds #include <linux/threads.h> 551da177e4SLinus Torvalds #include <linux/kernel.h> 561da177e4SLinus Torvalds #include <linux/types.h> 571da177e4SLinus Torvalds #include <linux/timex.h> 581da177e4SLinus Torvalds #include <linux/jiffies.h> 591da177e4SLinus Torvalds #include <linux/rbtree.h> 601da177e4SLinus Torvalds #include <linux/thread_info.h> 611da177e4SLinus Torvalds #include <linux/cpumask.h> 621da177e4SLinus Torvalds #include <linux/errno.h> 631da177e4SLinus Torvalds #include <linux/nodemask.h> 64c92ff1bdSMartin Schwidefsky #include <linux/mm_types.h> 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds #include <asm/page.h> 671da177e4SLinus Torvalds #include <asm/ptrace.h> 681da177e4SLinus Torvalds #include <asm/cputime.h> 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds #include <linux/smp.h> 711da177e4SLinus Torvalds #include <linux/sem.h> 721da177e4SLinus Torvalds #include <linux/signal.h> 731da177e4SLinus Torvalds #include <linux/compiler.h> 741da177e4SLinus Torvalds #include <linux/completion.h> 751da177e4SLinus Torvalds #include <linux/pid.h> 761da177e4SLinus Torvalds #include <linux/percpu.h> 771da177e4SLinus Torvalds #include <linux/topology.h> 783e26c149SPeter Zijlstra #include <linux/proportions.h> 791da177e4SLinus Torvalds #include <linux/seccomp.h> 80e56d0903SIngo Molnar #include <linux/rcupdate.h> 8105725f7eSJiri Pirko #include <linux/rculist.h> 8223f78d4aSIngo Molnar #include <linux/rtmutex.h> 831da177e4SLinus Torvalds 84a3b6714eSDavid Woodhouse #include <linux/time.h> 85a3b6714eSDavid Woodhouse #include <linux/param.h> 86a3b6714eSDavid Woodhouse #include <linux/resource.h> 87a3b6714eSDavid Woodhouse #include <linux/timer.h> 88a3b6714eSDavid Woodhouse #include <linux/hrtimer.h> 897c3ab738SAndrew Morton #include <linux/task_io_accounting.h> 909745512cSArjan van de Ven #include <linux/latencytop.h> 919e2b2dc4SDavid Howells #include <linux/cred.h> 92fa14ff4aSPeter Zijlstra #include <linux/llist.h> 937b44ab97SEric W. Biederman #include <linux/uidgid.h> 94a3b6714eSDavid Woodhouse 95a3b6714eSDavid Woodhouse #include <asm/processor.h> 9636d57ac4SH. J. Lu 971da177e4SLinus Torvalds struct exec_domain; 98c87e2837SIngo Molnar struct futex_pi_state; 99286100a6SAlexey Dobriyan struct robust_list_head; 100bddd87c7SAkinobu Mita struct bio_list; 1015ad4e53bSAl Viro struct fs_struct; 102cdd6c482SIngo Molnar struct perf_event_context; 10373c10101SJens Axboe struct blk_plug; 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds /* 1061da177e4SLinus Torvalds * List of flags we want to share for kernel threads, 1071da177e4SLinus Torvalds * if only because they are not used by them anyway. 1081da177e4SLinus Torvalds */ 1091da177e4SLinus Torvalds #define CLONE_KERNEL (CLONE_FS | CLONE_FILES | CLONE_SIGHAND) 1101da177e4SLinus Torvalds 1111da177e4SLinus Torvalds /* 1121da177e4SLinus Torvalds * These are the constant used to fake the fixed-point load-average 1131da177e4SLinus Torvalds * counting. Some notes: 1141da177e4SLinus Torvalds * - 11 bit fractions expand to 22 bits by the multiplies: this gives 1151da177e4SLinus Torvalds * a load-average precision of 10 bits integer + 11 bits fractional 1161da177e4SLinus Torvalds * - if you want to count load-averages more often, you need more 1171da177e4SLinus Torvalds * precision, or rounding will get you. With 2-second counting freq, 1181da177e4SLinus Torvalds * the EXP_n values would be 1981, 2034 and 2043 if still using only 1191da177e4SLinus Torvalds * 11 bit fractions. 1201da177e4SLinus Torvalds */ 1211da177e4SLinus Torvalds extern unsigned long avenrun[]; /* Load averages */ 1222d02494fSThomas Gleixner extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift); 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds #define FSHIFT 11 /* nr of bits of precision */ 1251da177e4SLinus Torvalds #define FIXED_1 (1<<FSHIFT) /* 1.0 as fixed-point */ 1260c2043abSLinus Torvalds #define LOAD_FREQ (5*HZ+1) /* 5 sec intervals */ 1271da177e4SLinus Torvalds #define EXP_1 1884 /* 1/exp(5sec/1min) as fixed-point */ 1281da177e4SLinus Torvalds #define EXP_5 2014 /* 1/exp(5sec/5min) */ 1291da177e4SLinus Torvalds #define EXP_15 2037 /* 1/exp(5sec/15min) */ 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds #define CALC_LOAD(load,exp,n) \ 1321da177e4SLinus Torvalds load *= exp; \ 1331da177e4SLinus Torvalds load += n*(FIXED_1-exp); \ 1341da177e4SLinus Torvalds load >>= FSHIFT; 1351da177e4SLinus Torvalds 1361da177e4SLinus Torvalds extern unsigned long total_forks; 1371da177e4SLinus Torvalds extern int nr_threads; 1381da177e4SLinus Torvalds DECLARE_PER_CPU(unsigned long, process_counts); 1391da177e4SLinus Torvalds extern int nr_processes(void); 1401da177e4SLinus Torvalds extern unsigned long nr_running(void); 1411da177e4SLinus Torvalds extern unsigned long nr_uninterruptible(void); 1421da177e4SLinus Torvalds extern unsigned long nr_iowait(void); 1438c215bd3SPeter Zijlstra extern unsigned long nr_iowait_cpu(int cpu); 14469d25870SArjan van de Ven extern unsigned long this_cpu_load(void); 14569d25870SArjan van de Ven 14669d25870SArjan van de Ven 1470f004f5aSPeter Zijlstra extern void calc_global_load(unsigned long ticks); 1485aaa0b7aSPeter Zijlstra extern void update_cpu_load_nohz(void); 1491da177e4SLinus Torvalds 1507e49fcceSSteven Rostedt extern unsigned long get_parent_ip(unsigned long addr); 1517e49fcceSSteven Rostedt 15243ae34cbSIngo Molnar struct seq_file; 15343ae34cbSIngo Molnar struct cfs_rq; 1544cf86d77SIngo Molnar struct task_group; 15543ae34cbSIngo Molnar #ifdef CONFIG_SCHED_DEBUG 15643ae34cbSIngo Molnar extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m); 15743ae34cbSIngo Molnar extern void proc_sched_set_task(struct task_struct *p); 15843ae34cbSIngo Molnar extern void 1595cef9ecaSIngo Molnar print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq); 16043ae34cbSIngo Molnar #else 16143ae34cbSIngo Molnar static inline void 16243ae34cbSIngo Molnar proc_sched_show_task(struct task_struct *p, struct seq_file *m) 16343ae34cbSIngo Molnar { 16443ae34cbSIngo Molnar } 16543ae34cbSIngo Molnar static inline void proc_sched_set_task(struct task_struct *p) 16643ae34cbSIngo Molnar { 16743ae34cbSIngo Molnar } 16843ae34cbSIngo Molnar static inline void 1695cef9ecaSIngo Molnar print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq) 17043ae34cbSIngo Molnar { 17143ae34cbSIngo Molnar } 17243ae34cbSIngo Molnar #endif 1731da177e4SLinus Torvalds 1744a8342d2SLinus Torvalds /* 1754a8342d2SLinus Torvalds * Task state bitmask. NOTE! These bits are also 1764a8342d2SLinus Torvalds * encoded in fs/proc/array.c: get_task_state(). 1774a8342d2SLinus Torvalds * 1784a8342d2SLinus Torvalds * We have two separate sets of flags: task->state 1794a8342d2SLinus Torvalds * is about runnability, while task->exit_state are 1804a8342d2SLinus Torvalds * about the task exiting. Confusing, but this way 1814a8342d2SLinus Torvalds * modifying one set can't modify the other one by 1824a8342d2SLinus Torvalds * mistake. 1834a8342d2SLinus Torvalds */ 1841da177e4SLinus Torvalds #define TASK_RUNNING 0 1851da177e4SLinus Torvalds #define TASK_INTERRUPTIBLE 1 1861da177e4SLinus Torvalds #define TASK_UNINTERRUPTIBLE 2 187f021a3c2SMatthew Wilcox #define __TASK_STOPPED 4 188f021a3c2SMatthew Wilcox #define __TASK_TRACED 8 1894a8342d2SLinus Torvalds /* in tsk->exit_state */ 1904a8342d2SLinus Torvalds #define EXIT_ZOMBIE 16 1914a8342d2SLinus Torvalds #define EXIT_DEAD 32 1924a8342d2SLinus Torvalds /* in tsk->state again */ 193af927232SMike Galbraith #define TASK_DEAD 64 194f021a3c2SMatthew Wilcox #define TASK_WAKEKILL 128 195e9c84311SPeter Zijlstra #define TASK_WAKING 256 196e1781538SPeter Zijlstra #define TASK_STATE_MAX 512 197f021a3c2SMatthew Wilcox 19844d90df6SPeter Zijlstra #define TASK_STATE_TO_CHAR_STR "RSDTtZXxKW" 19973342151SPeter Zijlstra 200e1781538SPeter Zijlstra extern char ___assert_task_state[1 - 2*!!( 201e1781538SPeter Zijlstra sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1)]; 202f021a3c2SMatthew Wilcox 203f021a3c2SMatthew Wilcox /* Convenience macros for the sake of set_task_state */ 204f021a3c2SMatthew Wilcox #define TASK_KILLABLE (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE) 205f021a3c2SMatthew Wilcox #define TASK_STOPPED (TASK_WAKEKILL | __TASK_STOPPED) 206f021a3c2SMatthew Wilcox #define TASK_TRACED (TASK_WAKEKILL | __TASK_TRACED) 2071da177e4SLinus Torvalds 20892a1f4bcSMatthew Wilcox /* Convenience macros for the sake of wake_up */ 20992a1f4bcSMatthew Wilcox #define TASK_NORMAL (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE) 210f021a3c2SMatthew Wilcox #define TASK_ALL (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED) 21192a1f4bcSMatthew Wilcox 21292a1f4bcSMatthew Wilcox /* get_task_state() */ 21392a1f4bcSMatthew Wilcox #define TASK_REPORT (TASK_RUNNING | TASK_INTERRUPTIBLE | \ 214f021a3c2SMatthew Wilcox TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \ 215f021a3c2SMatthew Wilcox __TASK_TRACED) 21692a1f4bcSMatthew Wilcox 217f021a3c2SMatthew Wilcox #define task_is_traced(task) ((task->state & __TASK_TRACED) != 0) 218f021a3c2SMatthew Wilcox #define task_is_stopped(task) ((task->state & __TASK_STOPPED) != 0) 2198f92054eSDavid Howells #define task_is_dead(task) ((task)->exit_state != 0) 22092a1f4bcSMatthew Wilcox #define task_is_stopped_or_traced(task) \ 221f021a3c2SMatthew Wilcox ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0) 22292a1f4bcSMatthew Wilcox #define task_contributes_to_load(task) \ 223e3c8ca83SNathan Lynch ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \ 224376fede8STejun Heo (task->flags & PF_FROZEN) == 0) 2251da177e4SLinus Torvalds 2261da177e4SLinus Torvalds #define __set_task_state(tsk, state_value) \ 2271da177e4SLinus Torvalds do { (tsk)->state = (state_value); } while (0) 2281da177e4SLinus Torvalds #define set_task_state(tsk, state_value) \ 2291da177e4SLinus Torvalds set_mb((tsk)->state, (state_value)) 2301da177e4SLinus Torvalds 231498d0c57SAndrew Morton /* 232498d0c57SAndrew Morton * set_current_state() includes a barrier so that the write of current->state 233498d0c57SAndrew Morton * is correctly serialised wrt the caller's subsequent test of whether to 234498d0c57SAndrew Morton * actually sleep: 235498d0c57SAndrew Morton * 236498d0c57SAndrew Morton * set_current_state(TASK_UNINTERRUPTIBLE); 237498d0c57SAndrew Morton * if (do_i_need_to_sleep()) 238498d0c57SAndrew Morton * schedule(); 239498d0c57SAndrew Morton * 240498d0c57SAndrew Morton * If the caller does not need such serialisation then use __set_current_state() 241498d0c57SAndrew Morton */ 2421da177e4SLinus Torvalds #define __set_current_state(state_value) \ 2431da177e4SLinus Torvalds do { current->state = (state_value); } while (0) 2441da177e4SLinus Torvalds #define set_current_state(state_value) \ 2451da177e4SLinus Torvalds set_mb(current->state, (state_value)) 2461da177e4SLinus Torvalds 2471da177e4SLinus Torvalds /* Task command name length */ 2481da177e4SLinus Torvalds #define TASK_COMM_LEN 16 2491da177e4SLinus Torvalds 2501da177e4SLinus Torvalds #include <linux/spinlock.h> 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds /* 2531da177e4SLinus Torvalds * This serializes "schedule()" and also protects 2541da177e4SLinus Torvalds * the run-queue from deletions/modifications (but 2551da177e4SLinus Torvalds * _adding_ to the beginning of the run-queue has 2561da177e4SLinus Torvalds * a separate lock). 2571da177e4SLinus Torvalds */ 2581da177e4SLinus Torvalds extern rwlock_t tasklist_lock; 2591da177e4SLinus Torvalds extern spinlock_t mmlist_lock; 2601da177e4SLinus Torvalds 26136c8b586SIngo Molnar struct task_struct; 2621da177e4SLinus Torvalds 263db1466b3SPaul E. McKenney #ifdef CONFIG_PROVE_RCU 264db1466b3SPaul E. McKenney extern int lockdep_tasklist_lock_is_held(void); 265db1466b3SPaul E. McKenney #endif /* #ifdef CONFIG_PROVE_RCU */ 266db1466b3SPaul E. McKenney 2671da177e4SLinus Torvalds extern void sched_init(void); 2681da177e4SLinus Torvalds extern void sched_init_smp(void); 2692d07b255SHarvey Harrison extern asmlinkage void schedule_tail(struct task_struct *prev); 27036c8b586SIngo Molnar extern void init_idle(struct task_struct *idle, int cpu); 2711df21055SIngo Molnar extern void init_idle_bootup_task(struct task_struct *idle); 2721da177e4SLinus Torvalds 27389f19f04SAndrew Morton extern int runqueue_is_locked(int cpu); 274017730c1SIngo Molnar 27546cb4b7cSSiddha, Suresh B #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ) 27683cd4fe2SVenkatesh Pallipadi extern void select_nohz_load_balancer(int stop_tick); 27769e1e811SSuresh Siddha extern void set_cpu_sd_state_idle(void); 27883cd4fe2SVenkatesh Pallipadi extern int get_nohz_timer_target(void); 27946cb4b7cSSiddha, Suresh B #else 28083cd4fe2SVenkatesh Pallipadi static inline void select_nohz_load_balancer(int stop_tick) { } 281fdaabd80SPeter Zijlstra static inline void set_cpu_sd_state_idle(void) { } 28246cb4b7cSSiddha, Suresh B #endif 2831da177e4SLinus Torvalds 284e59e2ae2SIngo Molnar /* 28539bc89fdSIngo Molnar * Only dump TASK_* tasks. (0 for all tasks) 286e59e2ae2SIngo Molnar */ 287e59e2ae2SIngo Molnar extern void show_state_filter(unsigned long state_filter); 288e59e2ae2SIngo Molnar 289e59e2ae2SIngo Molnar static inline void show_state(void) 290e59e2ae2SIngo Molnar { 29139bc89fdSIngo Molnar show_state_filter(0); 292e59e2ae2SIngo Molnar } 293e59e2ae2SIngo Molnar 2941da177e4SLinus Torvalds extern void show_regs(struct pt_regs *); 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds /* 2971da177e4SLinus Torvalds * TASK is a pointer to the task whose backtrace we want to see (or NULL for current 2981da177e4SLinus Torvalds * task), SP is the stack pointer of the first frame that should be shown in the back 2991da177e4SLinus Torvalds * trace (or NULL if the entire call-chain of the task should be shown). 3001da177e4SLinus Torvalds */ 3011da177e4SLinus Torvalds extern void show_stack(struct task_struct *task, unsigned long *sp); 3021da177e4SLinus Torvalds 3031da177e4SLinus Torvalds void io_schedule(void); 3041da177e4SLinus Torvalds long io_schedule_timeout(long timeout); 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds extern void cpu_init (void); 3071da177e4SLinus Torvalds extern void trap_init(void); 3081da177e4SLinus Torvalds extern void update_process_times(int user); 3091da177e4SLinus Torvalds extern void scheduler_tick(void); 3101da177e4SLinus Torvalds 31182a1fcb9SIngo Molnar extern void sched_show_task(struct task_struct *p); 31282a1fcb9SIngo Molnar 31319cc36c0SFrederic Weisbecker #ifdef CONFIG_LOCKUP_DETECTOR 3148446f1d3SIngo Molnar extern void touch_softlockup_watchdog(void); 315d6ad3e28SJason Wessel extern void touch_softlockup_watchdog_sync(void); 31604c9167fSJeremy Fitzhardinge extern void touch_all_softlockup_watchdogs(void); 317332fbdbcSDon Zickus extern int proc_dowatchdog_thresh(struct ctl_table *table, int write, 3188d65af78SAlexey Dobriyan void __user *buffer, 319baf48f65SMandeep Singh Baines size_t *lenp, loff_t *ppos); 3209c44bc03SIngo Molnar extern unsigned int softlockup_panic; 321004417a6SPeter Zijlstra void lockup_detector_init(void); 3228446f1d3SIngo Molnar #else 3238446f1d3SIngo Molnar static inline void touch_softlockup_watchdog(void) 3248446f1d3SIngo Molnar { 3258446f1d3SIngo Molnar } 326d6ad3e28SJason Wessel static inline void touch_softlockup_watchdog_sync(void) 327d6ad3e28SJason Wessel { 328d6ad3e28SJason Wessel } 32904c9167fSJeremy Fitzhardinge static inline void touch_all_softlockup_watchdogs(void) 33004c9167fSJeremy Fitzhardinge { 33104c9167fSJeremy Fitzhardinge } 332004417a6SPeter Zijlstra static inline void lockup_detector_init(void) 333004417a6SPeter Zijlstra { 334004417a6SPeter Zijlstra } 3358446f1d3SIngo Molnar #endif 3368446f1d3SIngo Molnar 337e162b39aSMandeep Singh Baines #ifdef CONFIG_DETECT_HUNG_TASK 338e162b39aSMandeep Singh Baines extern unsigned int sysctl_hung_task_panic; 339e162b39aSMandeep Singh Baines extern unsigned long sysctl_hung_task_check_count; 340e162b39aSMandeep Singh Baines extern unsigned long sysctl_hung_task_timeout_secs; 341e162b39aSMandeep Singh Baines extern unsigned long sysctl_hung_task_warnings; 342e162b39aSMandeep Singh Baines extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write, 3438d65af78SAlexey Dobriyan void __user *buffer, 344e162b39aSMandeep Singh Baines size_t *lenp, loff_t *ppos); 345e4ecda1bSMark Lord #else 346e4ecda1bSMark Lord /* Avoid need for ifdefs elsewhere in the code */ 347e4ecda1bSMark Lord enum { sysctl_hung_task_timeout_secs = 0 }; 348e162b39aSMandeep Singh Baines #endif 3498446f1d3SIngo Molnar 3501da177e4SLinus Torvalds /* Attach to any functions which should be ignored in wchan output. */ 3511da177e4SLinus Torvalds #define __sched __attribute__((__section__(".sched.text"))) 352deaf2227SIngo Molnar 353deaf2227SIngo Molnar /* Linker adds these: start and end of __sched functions */ 354deaf2227SIngo Molnar extern char __sched_text_start[], __sched_text_end[]; 355deaf2227SIngo Molnar 3561da177e4SLinus Torvalds /* Is this address in the __sched functions? */ 3571da177e4SLinus Torvalds extern int in_sched_functions(unsigned long addr); 3581da177e4SLinus Torvalds 3591da177e4SLinus Torvalds #define MAX_SCHEDULE_TIMEOUT LONG_MAX 360b3c97528SHarvey Harrison extern signed long schedule_timeout(signed long timeout); 36164ed93a2SNishanth Aravamudan extern signed long schedule_timeout_interruptible(signed long timeout); 362294d5cc2SMatthew Wilcox extern signed long schedule_timeout_killable(signed long timeout); 36364ed93a2SNishanth Aravamudan extern signed long schedule_timeout_uninterruptible(signed long timeout); 3641da177e4SLinus Torvalds asmlinkage void schedule(void); 365c5491ea7SThomas Gleixner extern void schedule_preempt_disabled(void); 366c6eb3ddaSPeter Zijlstra extern int mutex_spin_on_owner(struct mutex *lock, struct task_struct *owner); 3671da177e4SLinus Torvalds 368ab516013SSerge E. Hallyn struct nsproxy; 369acce292cSCedric Le Goater struct user_namespace; 3701da177e4SLinus Torvalds 371341c87bfSKAMEZAWA Hiroyuki /* 372341c87bfSKAMEZAWA Hiroyuki * Default maximum number of active map areas, this limits the number of vmas 373341c87bfSKAMEZAWA Hiroyuki * per mm struct. Users can overwrite this number by sysctl but there is a 374341c87bfSKAMEZAWA Hiroyuki * problem. 375341c87bfSKAMEZAWA Hiroyuki * 376341c87bfSKAMEZAWA Hiroyuki * When a program's coredump is generated as ELF format, a section is created 377341c87bfSKAMEZAWA Hiroyuki * per a vma. In ELF, the number of sections is represented in unsigned short. 378341c87bfSKAMEZAWA Hiroyuki * This means the number of sections should be smaller than 65535 at coredump. 379341c87bfSKAMEZAWA Hiroyuki * Because the kernel adds some informative sections to a image of program at 380341c87bfSKAMEZAWA Hiroyuki * generating coredump, we need some margin. The number of extra sections is 381341c87bfSKAMEZAWA Hiroyuki * 1-3 now and depends on arch. We use "5" as safe margin, here. 382341c87bfSKAMEZAWA Hiroyuki */ 383341c87bfSKAMEZAWA Hiroyuki #define MAPCOUNT_ELF_CORE_MARGIN (5) 3844be929beSAlexey Dobriyan #define DEFAULT_MAX_MAP_COUNT (USHRT_MAX - MAPCOUNT_ELF_CORE_MARGIN) 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds extern int sysctl_max_map_count; 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds #include <linux/aio.h> 3891da177e4SLinus Torvalds 390efc1a3b1SDavid Howells #ifdef CONFIG_MMU 391efc1a3b1SDavid Howells extern void arch_pick_mmap_layout(struct mm_struct *mm); 3921da177e4SLinus Torvalds extern unsigned long 3931da177e4SLinus Torvalds arch_get_unmapped_area(struct file *, unsigned long, unsigned long, 3941da177e4SLinus Torvalds unsigned long, unsigned long); 3951da177e4SLinus Torvalds extern unsigned long 3961da177e4SLinus Torvalds arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr, 3971da177e4SLinus Torvalds unsigned long len, unsigned long pgoff, 3981da177e4SLinus Torvalds unsigned long flags); 3991363c3cdSWolfgang Wander extern void arch_unmap_area(struct mm_struct *, unsigned long); 4001363c3cdSWolfgang Wander extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long); 401efc1a3b1SDavid Howells #else 402efc1a3b1SDavid Howells static inline void arch_pick_mmap_layout(struct mm_struct *mm) {} 403efc1a3b1SDavid Howells #endif 4041da177e4SLinus Torvalds 405901608d9SOleg Nesterov 4066c5d5238SKawai, Hidehiro extern void set_dumpable(struct mm_struct *mm, int value); 4076c5d5238SKawai, Hidehiro extern int get_dumpable(struct mm_struct *mm); 4086c5d5238SKawai, Hidehiro 4096c5d5238SKawai, Hidehiro /* mm flags */ 4103cb4a0bbSKawai, Hidehiro /* dumpable bits */ 4116c5d5238SKawai, Hidehiro #define MMF_DUMPABLE 0 /* core dump is permitted */ 4126c5d5238SKawai, Hidehiro #define MMF_DUMP_SECURELY 1 /* core file is readable only by root */ 413f8af4da3SHugh Dickins 4143cb4a0bbSKawai, Hidehiro #define MMF_DUMPABLE_BITS 2 415f8af4da3SHugh Dickins #define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1) 4163cb4a0bbSKawai, Hidehiro 4173cb4a0bbSKawai, Hidehiro /* coredump filter bits */ 4183cb4a0bbSKawai, Hidehiro #define MMF_DUMP_ANON_PRIVATE 2 4193cb4a0bbSKawai, Hidehiro #define MMF_DUMP_ANON_SHARED 3 4203cb4a0bbSKawai, Hidehiro #define MMF_DUMP_MAPPED_PRIVATE 4 4213cb4a0bbSKawai, Hidehiro #define MMF_DUMP_MAPPED_SHARED 5 42282df3973SRoland McGrath #define MMF_DUMP_ELF_HEADERS 6 423e575f111SKOSAKI Motohiro #define MMF_DUMP_HUGETLB_PRIVATE 7 424e575f111SKOSAKI Motohiro #define MMF_DUMP_HUGETLB_SHARED 8 425f8af4da3SHugh Dickins 4263cb4a0bbSKawai, Hidehiro #define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS 427e575f111SKOSAKI Motohiro #define MMF_DUMP_FILTER_BITS 7 4283cb4a0bbSKawai, Hidehiro #define MMF_DUMP_FILTER_MASK \ 4293cb4a0bbSKawai, Hidehiro (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT) 4303cb4a0bbSKawai, Hidehiro #define MMF_DUMP_FILTER_DEFAULT \ 431e575f111SKOSAKI Motohiro ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\ 432656eb2cdSRoland McGrath (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF) 433656eb2cdSRoland McGrath 434656eb2cdSRoland McGrath #ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS 435656eb2cdSRoland McGrath # define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS) 436656eb2cdSRoland McGrath #else 437656eb2cdSRoland McGrath # define MMF_DUMP_MASK_DEFAULT_ELF 0 438656eb2cdSRoland McGrath #endif 439f8af4da3SHugh Dickins /* leave room for more dump flags */ 440f8af4da3SHugh Dickins #define MMF_VM_MERGEABLE 16 /* KSM may merge identical pages */ 441ba76149fSAndrea Arcangeli #define MMF_VM_HUGEPAGE 17 /* set when VM_HUGEPAGE is set on vma */ 442bafb282dSKonstantin Khlebnikov #define MMF_EXE_FILE_CHANGED 18 /* see prctl_set_mm_exe_file() */ 443f8af4da3SHugh Dickins 444f8af4da3SHugh Dickins #define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK) 4456c5d5238SKawai, Hidehiro 4461da177e4SLinus Torvalds struct sighand_struct { 4471da177e4SLinus Torvalds atomic_t count; 4481da177e4SLinus Torvalds struct k_sigaction action[_NSIG]; 4491da177e4SLinus Torvalds spinlock_t siglock; 450b8fceee1SDavide Libenzi wait_queue_head_t signalfd_wqh; 4511da177e4SLinus Torvalds }; 4521da177e4SLinus Torvalds 4530e464814SKaiGai Kohei struct pacct_struct { 454f6ec29a4SKaiGai Kohei int ac_flag; 455f6ec29a4SKaiGai Kohei long ac_exitcode; 4560e464814SKaiGai Kohei unsigned long ac_mem; 45777787bfbSKaiGai Kohei cputime_t ac_utime, ac_stime; 45877787bfbSKaiGai Kohei unsigned long ac_minflt, ac_majflt; 4590e464814SKaiGai Kohei }; 4600e464814SKaiGai Kohei 46142c4ab41SStanislaw Gruszka struct cpu_itimer { 46242c4ab41SStanislaw Gruszka cputime_t expires; 46342c4ab41SStanislaw Gruszka cputime_t incr; 4648356b5f9SStanislaw Gruszka u32 error; 4658356b5f9SStanislaw Gruszka u32 incr_error; 46642c4ab41SStanislaw Gruszka }; 46742c4ab41SStanislaw Gruszka 468f06febc9SFrank Mayhar /** 469f06febc9SFrank Mayhar * struct task_cputime - collected CPU time counts 470f06febc9SFrank Mayhar * @utime: time spent in user mode, in &cputime_t units 471f06febc9SFrank Mayhar * @stime: time spent in kernel mode, in &cputime_t units 472f06febc9SFrank Mayhar * @sum_exec_runtime: total time spent on the CPU, in nanoseconds 473f06febc9SFrank Mayhar * 474f06febc9SFrank Mayhar * This structure groups together three kinds of CPU time that are 475f06febc9SFrank Mayhar * tracked for threads and thread groups. Most things considering 476f06febc9SFrank Mayhar * CPU time want to group these counts together and treat all three 477f06febc9SFrank Mayhar * of them in parallel. 478f06febc9SFrank Mayhar */ 479f06febc9SFrank Mayhar struct task_cputime { 480f06febc9SFrank Mayhar cputime_t utime; 481f06febc9SFrank Mayhar cputime_t stime; 482f06febc9SFrank Mayhar unsigned long long sum_exec_runtime; 483f06febc9SFrank Mayhar }; 484f06febc9SFrank Mayhar /* Alternate field names when used to cache expirations. */ 485f06febc9SFrank Mayhar #define prof_exp stime 486f06febc9SFrank Mayhar #define virt_exp utime 487f06febc9SFrank Mayhar #define sched_exp sum_exec_runtime 488f06febc9SFrank Mayhar 4894cd4c1b4SPeter Zijlstra #define INIT_CPUTIME \ 4904cd4c1b4SPeter Zijlstra (struct task_cputime) { \ 49164861634SMartin Schwidefsky .utime = 0, \ 49264861634SMartin Schwidefsky .stime = 0, \ 4934cd4c1b4SPeter Zijlstra .sum_exec_runtime = 0, \ 4944cd4c1b4SPeter Zijlstra } 4954cd4c1b4SPeter Zijlstra 496c99e6efeSPeter Zijlstra /* 497c99e6efeSPeter Zijlstra * Disable preemption until the scheduler is running. 498c99e6efeSPeter Zijlstra * Reset by start_kernel()->sched_init()->init_idle(). 499d86ee480SPeter Zijlstra * 500d86ee480SPeter Zijlstra * We include PREEMPT_ACTIVE to avoid cond_resched() from working 501d86ee480SPeter Zijlstra * before the scheduler is active -- see should_resched(). 502c99e6efeSPeter Zijlstra */ 503d86ee480SPeter Zijlstra #define INIT_PREEMPT_COUNT (1 + PREEMPT_ACTIVE) 504c99e6efeSPeter Zijlstra 505f06febc9SFrank Mayhar /** 5064cd4c1b4SPeter Zijlstra * struct thread_group_cputimer - thread group interval timer counts 5074cd4c1b4SPeter Zijlstra * @cputime: thread group interval timers. 5084cd4c1b4SPeter Zijlstra * @running: non-zero when there are timers running and 5094cd4c1b4SPeter Zijlstra * @cputime receives updates. 5104cd4c1b4SPeter Zijlstra * @lock: lock for fields in this struct. 511f06febc9SFrank Mayhar * 512f06febc9SFrank Mayhar * This structure contains the version of task_cputime, above, that is 5134cd4c1b4SPeter Zijlstra * used for thread group CPU timer calculations. 514f06febc9SFrank Mayhar */ 5154cd4c1b4SPeter Zijlstra struct thread_group_cputimer { 5164cd4c1b4SPeter Zijlstra struct task_cputime cputime; 5174cd4c1b4SPeter Zijlstra int running; 518ee30a7b2SThomas Gleixner raw_spinlock_t lock; 519f06febc9SFrank Mayhar }; 520f06febc9SFrank Mayhar 5214714d1d3SBen Blum #include <linux/rwsem.h> 5225091faa4SMike Galbraith struct autogroup; 5235091faa4SMike Galbraith 5241da177e4SLinus Torvalds /* 525e815f0a8SJonathan Neuschäfer * NOTE! "signal_struct" does not have its own 5261da177e4SLinus Torvalds * locking, because a shared signal_struct always 5271da177e4SLinus Torvalds * implies a shared sighand_struct, so locking 5281da177e4SLinus Torvalds * sighand_struct is always a proper superset of 5291da177e4SLinus Torvalds * the locking of signal_struct. 5301da177e4SLinus Torvalds */ 5311da177e4SLinus Torvalds struct signal_struct { 532ea6d290cSOleg Nesterov atomic_t sigcnt; 5331da177e4SLinus Torvalds atomic_t live; 534b3ac022cSOleg Nesterov int nr_threads; 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds wait_queue_head_t wait_chldexit; /* for wait4() */ 5371da177e4SLinus Torvalds 5381da177e4SLinus Torvalds /* current thread group signal load-balancing target: */ 53936c8b586SIngo Molnar struct task_struct *curr_target; 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds /* shared signal handling: */ 5421da177e4SLinus Torvalds struct sigpending shared_pending; 5431da177e4SLinus Torvalds 5441da177e4SLinus Torvalds /* thread group exit support */ 5451da177e4SLinus Torvalds int group_exit_code; 5461da177e4SLinus Torvalds /* overloaded: 5471da177e4SLinus Torvalds * - notify group_exit_task when ->count is equal to notify_count 5481da177e4SLinus Torvalds * - everyone except group_exit_task is stopped during signal delivery 5491da177e4SLinus Torvalds * of fatal signals, group_exit_task processes the signal. 5501da177e4SLinus Torvalds */ 5511da177e4SLinus Torvalds int notify_count; 55207dd20e0SRichard Kennedy struct task_struct *group_exit_task; 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds /* thread group stop support, overloads group_exit_code too */ 5551da177e4SLinus Torvalds int group_stop_count; 5561da177e4SLinus Torvalds unsigned int flags; /* see SIGNAL_* flags below */ 5571da177e4SLinus Torvalds 558ebec18a6SLennart Poettering /* 559ebec18a6SLennart Poettering * PR_SET_CHILD_SUBREAPER marks a process, like a service 560ebec18a6SLennart Poettering * manager, to re-parent orphan (double-forking) child processes 561ebec18a6SLennart Poettering * to this process instead of 'init'. The service manager is 562ebec18a6SLennart Poettering * able to receive SIGCHLD signals and is able to investigate 563ebec18a6SLennart Poettering * the process until it calls wait(). All children of this 564ebec18a6SLennart Poettering * process will inherit a flag if they should look for a 565ebec18a6SLennart Poettering * child_subreaper process at exit. 566ebec18a6SLennart Poettering */ 567ebec18a6SLennart Poettering unsigned int is_child_subreaper:1; 568ebec18a6SLennart Poettering unsigned int has_child_subreaper:1; 569ebec18a6SLennart Poettering 5701da177e4SLinus Torvalds /* POSIX.1b Interval Timers */ 5711da177e4SLinus Torvalds struct list_head posix_timers; 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds /* ITIMER_REAL timer for the process */ 5742ff678b8SThomas Gleixner struct hrtimer real_timer; 575fea9d175SOleg Nesterov struct pid *leader_pid; 5762ff678b8SThomas Gleixner ktime_t it_real_incr; 5771da177e4SLinus Torvalds 57842c4ab41SStanislaw Gruszka /* 57942c4ab41SStanislaw Gruszka * ITIMER_PROF and ITIMER_VIRTUAL timers for the process, we use 58042c4ab41SStanislaw Gruszka * CPUCLOCK_PROF and CPUCLOCK_VIRT for indexing array as these 58142c4ab41SStanislaw Gruszka * values are defined to 0 and 1 respectively 58242c4ab41SStanislaw Gruszka */ 58342c4ab41SStanislaw Gruszka struct cpu_itimer it[2]; 5841da177e4SLinus Torvalds 585f06febc9SFrank Mayhar /* 5864cd4c1b4SPeter Zijlstra * Thread group totals for process CPU timers. 5874cd4c1b4SPeter Zijlstra * See thread_group_cputimer(), et al, for details. 588f06febc9SFrank Mayhar */ 5894cd4c1b4SPeter Zijlstra struct thread_group_cputimer cputimer; 590f06febc9SFrank Mayhar 591f06febc9SFrank Mayhar /* Earliest-expiration cache. */ 592f06febc9SFrank Mayhar struct task_cputime cputime_expires; 593f06febc9SFrank Mayhar 594f06febc9SFrank Mayhar struct list_head cpu_timers[3]; 595f06febc9SFrank Mayhar 596ab521dc0SEric W. Biederman struct pid *tty_old_pgrp; 5971ec320afSCedric Le Goater 5981da177e4SLinus Torvalds /* boolean value for session group leader */ 5991da177e4SLinus Torvalds int leader; 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds struct tty_struct *tty; /* NULL if no tty */ 6021da177e4SLinus Torvalds 6035091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 6045091faa4SMike Galbraith struct autogroup *autogroup; 6055091faa4SMike Galbraith #endif 6061da177e4SLinus Torvalds /* 6071da177e4SLinus Torvalds * Cumulative resource counters for dead threads in the group, 6081da177e4SLinus Torvalds * and for reaped dead child processes forked by this group. 6091da177e4SLinus Torvalds * Live threads maintain their own counters and add to these 6101da177e4SLinus Torvalds * in __exit_signal, except for the group leader. 6111da177e4SLinus Torvalds */ 61232bd671dSPeter Zijlstra cputime_t utime, stime, cutime, cstime; 6139ac52315SLaurent Vivier cputime_t gtime; 6149ac52315SLaurent Vivier cputime_t cgtime; 6150cf55e1eSHidetoshi Seto #ifndef CONFIG_VIRT_CPU_ACCOUNTING 6160cf55e1eSHidetoshi Seto cputime_t prev_utime, prev_stime; 6170cf55e1eSHidetoshi Seto #endif 6181da177e4SLinus Torvalds unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw; 6191da177e4SLinus Torvalds unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt; 6206eaeeabaSEric Dumazet unsigned long inblock, oublock, cinblock, coublock; 6211f10206cSJiri Pirko unsigned long maxrss, cmaxrss; 622940389b8SAndrea Righi struct task_io_accounting ioac; 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds /* 62532bd671dSPeter Zijlstra * Cumulative ns of schedule CPU time fo dead threads in the 62632bd671dSPeter Zijlstra * group, not including a zombie group leader, (This only differs 62732bd671dSPeter Zijlstra * from jiffies_to_ns(utime + stime) if sched_clock uses something 62832bd671dSPeter Zijlstra * other than jiffies.) 62932bd671dSPeter Zijlstra */ 63032bd671dSPeter Zijlstra unsigned long long sum_sched_runtime; 63132bd671dSPeter Zijlstra 63232bd671dSPeter Zijlstra /* 6331da177e4SLinus Torvalds * We don't bother to synchronize most readers of this at all, 6341da177e4SLinus Torvalds * because there is no reader checking a limit that actually needs 6351da177e4SLinus Torvalds * to get both rlim_cur and rlim_max atomically, and either one 6361da177e4SLinus Torvalds * alone is a single word that can safely be read normally. 6371da177e4SLinus Torvalds * getrlimit/setrlimit use task_lock(current->group_leader) to 6381da177e4SLinus Torvalds * protect this instead of the siglock, because they really 6391da177e4SLinus Torvalds * have no need to disable irqs. 6401da177e4SLinus Torvalds */ 6411da177e4SLinus Torvalds struct rlimit rlim[RLIM_NLIMITS]; 6421da177e4SLinus Torvalds 6430e464814SKaiGai Kohei #ifdef CONFIG_BSD_PROCESS_ACCT 6440e464814SKaiGai Kohei struct pacct_struct pacct; /* per-process accounting information */ 6450e464814SKaiGai Kohei #endif 646ad4ecbcbSShailabh Nagar #ifdef CONFIG_TASKSTATS 647ad4ecbcbSShailabh Nagar struct taskstats *stats; 648ad4ecbcbSShailabh Nagar #endif 649522ed776SMiloslav Trmac #ifdef CONFIG_AUDIT 650522ed776SMiloslav Trmac unsigned audit_tty; 651522ed776SMiloslav Trmac struct tty_audit_buf *tty_audit_buf; 652522ed776SMiloslav Trmac #endif 6534714d1d3SBen Blum #ifdef CONFIG_CGROUPS 6544714d1d3SBen Blum /* 65577e4ef99STejun Heo * group_rwsem prevents new tasks from entering the threadgroup and 65677e4ef99STejun Heo * member tasks from exiting,a more specifically, setting of 65777e4ef99STejun Heo * PF_EXITING. fork and exit paths are protected with this rwsem 65877e4ef99STejun Heo * using threadgroup_change_begin/end(). Users which require 65977e4ef99STejun Heo * threadgroup to remain stable should use threadgroup_[un]lock() 66077e4ef99STejun Heo * which also takes care of exec path. Currently, cgroup is the 66177e4ef99STejun Heo * only user. 6624714d1d3SBen Blum */ 663257058aeSTejun Heo struct rw_semaphore group_rwsem; 6644714d1d3SBen Blum #endif 66528b83c51SKOSAKI Motohiro 66628b83c51SKOSAKI Motohiro int oom_adj; /* OOM kill score adjustment (bit shift) */ 667a63d83f4SDavid Rientjes int oom_score_adj; /* OOM kill score adjustment */ 668dabb16f6SMandeep Singh Baines int oom_score_adj_min; /* OOM kill score adjustment minimum value. 669dabb16f6SMandeep Singh Baines * Only settable by CAP_SYS_RESOURCE. */ 6709b1bf12dSKOSAKI Motohiro 6719b1bf12dSKOSAKI Motohiro struct mutex cred_guard_mutex; /* guard against foreign influences on 6729b1bf12dSKOSAKI Motohiro * credential calculations 6739b1bf12dSKOSAKI Motohiro * (notably. ptrace) */ 6741da177e4SLinus Torvalds }; 6751da177e4SLinus Torvalds 6764866cde0SNick Piggin /* Context switch must be unlocked if interrupts are to be enabled */ 6774866cde0SNick Piggin #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW 6784866cde0SNick Piggin # define __ARCH_WANT_UNLOCKED_CTXSW 6794866cde0SNick Piggin #endif 6804866cde0SNick Piggin 6811da177e4SLinus Torvalds /* 6821da177e4SLinus Torvalds * Bits in flags field of signal_struct. 6831da177e4SLinus Torvalds */ 6841da177e4SLinus Torvalds #define SIGNAL_STOP_STOPPED 0x00000001 /* job control stop in effect */ 685ee77f075SOleg Nesterov #define SIGNAL_STOP_CONTINUED 0x00000002 /* SIGCONT since WCONTINUED reap */ 686ee77f075SOleg Nesterov #define SIGNAL_GROUP_EXIT 0x00000004 /* group exit in progress */ 687e4420551SOleg Nesterov /* 688e4420551SOleg Nesterov * Pending notifications to parent. 689e4420551SOleg Nesterov */ 690e4420551SOleg Nesterov #define SIGNAL_CLD_STOPPED 0x00000010 691e4420551SOleg Nesterov #define SIGNAL_CLD_CONTINUED 0x00000020 692e4420551SOleg Nesterov #define SIGNAL_CLD_MASK (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED) 6931da177e4SLinus Torvalds 694fae5fa44SOleg Nesterov #define SIGNAL_UNKILLABLE 0x00000040 /* for init: ignore fatal signals */ 695fae5fa44SOleg Nesterov 696ed5d2cacSOleg Nesterov /* If true, all threads except ->group_exit_task have pending SIGKILL */ 697ed5d2cacSOleg Nesterov static inline int signal_group_exit(const struct signal_struct *sig) 698ed5d2cacSOleg Nesterov { 699ed5d2cacSOleg Nesterov return (sig->flags & SIGNAL_GROUP_EXIT) || 700ed5d2cacSOleg Nesterov (sig->group_exit_task != NULL); 701ed5d2cacSOleg Nesterov } 702ed5d2cacSOleg Nesterov 7031da177e4SLinus Torvalds /* 7041da177e4SLinus Torvalds * Some day this will be a full-fledged user tracking system.. 7051da177e4SLinus Torvalds */ 7061da177e4SLinus Torvalds struct user_struct { 7071da177e4SLinus Torvalds atomic_t __count; /* reference count */ 7081da177e4SLinus Torvalds atomic_t processes; /* How many processes does this user have? */ 7091da177e4SLinus Torvalds atomic_t files; /* How many open files does this user have? */ 7101da177e4SLinus Torvalds atomic_t sigpending; /* How many pending signals does this user have? */ 7112d9048e2SAmy Griffis #ifdef CONFIG_INOTIFY_USER 7120eeca283SRobert Love atomic_t inotify_watches; /* How many inotify watches does this user have? */ 7130eeca283SRobert Love atomic_t inotify_devs; /* How many inotify devs does this user have opened? */ 7140eeca283SRobert Love #endif 7154afeff85SEric Paris #ifdef CONFIG_FANOTIFY 7164afeff85SEric Paris atomic_t fanotify_listeners; 7174afeff85SEric Paris #endif 7187ef9964eSDavide Libenzi #ifdef CONFIG_EPOLL 71952bd19f7SRobin Holt atomic_long_t epoll_watches; /* The number of file descriptors currently watched */ 7207ef9964eSDavide Libenzi #endif 721970a8645SAlexey Dobriyan #ifdef CONFIG_POSIX_MQUEUE 7221da177e4SLinus Torvalds /* protected by mq_lock */ 7231da177e4SLinus Torvalds unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */ 724970a8645SAlexey Dobriyan #endif 7251da177e4SLinus Torvalds unsigned long locked_shm; /* How many pages of mlocked shm ? */ 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds #ifdef CONFIG_KEYS 7281da177e4SLinus Torvalds struct key *uid_keyring; /* UID specific keyring */ 7291da177e4SLinus Torvalds struct key *session_keyring; /* UID's default session keyring */ 7301da177e4SLinus Torvalds #endif 7311da177e4SLinus Torvalds 7321da177e4SLinus Torvalds /* Hash table maintenance information */ 733735de223SPavel Emelyanov struct hlist_node uidhash_node; 7347b44ab97SEric W. Biederman kuid_t uid; 73524e377a8SSrivatsa Vaddagiri 736cdd6c482SIngo Molnar #ifdef CONFIG_PERF_EVENTS 737789f90fcSPeter Zijlstra atomic_long_t locked_vm; 738789f90fcSPeter Zijlstra #endif 7391da177e4SLinus Torvalds }; 7401da177e4SLinus Torvalds 741eb41d946SKay Sievers extern int uids_sysfs_init(void); 7425cb350baSDhaval Giani 7437b44ab97SEric W. Biederman extern struct user_struct *find_user(kuid_t); 7441da177e4SLinus Torvalds 7451da177e4SLinus Torvalds extern struct user_struct root_user; 7461da177e4SLinus Torvalds #define INIT_USER (&root_user) 7471da177e4SLinus Torvalds 748b6dff3ecSDavid Howells 7491da177e4SLinus Torvalds struct backing_dev_info; 7501da177e4SLinus Torvalds struct reclaim_state; 7511da177e4SLinus Torvalds 75252f17b6cSChandra Seetharaman #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) 7531da177e4SLinus Torvalds struct sched_info { 7541da177e4SLinus Torvalds /* cumulative counters */ 7552d72376bSIngo Molnar unsigned long pcount; /* # of times run on this cpu */ 7569c2c4802SKen Chen unsigned long long run_delay; /* time spent waiting on a runqueue */ 7571da177e4SLinus Torvalds 7581da177e4SLinus Torvalds /* timestamps */ 759172ba844SBalbir Singh unsigned long long last_arrival,/* when we last ran on a cpu */ 7601da177e4SLinus Torvalds last_queued; /* when we were last queued to run */ 7611da177e4SLinus Torvalds }; 76252f17b6cSChandra Seetharaman #endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */ 7631da177e4SLinus Torvalds 764ca74e92bSShailabh Nagar #ifdef CONFIG_TASK_DELAY_ACCT 765ca74e92bSShailabh Nagar struct task_delay_info { 766ca74e92bSShailabh Nagar spinlock_t lock; 767ca74e92bSShailabh Nagar unsigned int flags; /* Private per-task flags */ 768ca74e92bSShailabh Nagar 769ca74e92bSShailabh Nagar /* For each stat XXX, add following, aligned appropriately 770ca74e92bSShailabh Nagar * 771ca74e92bSShailabh Nagar * struct timespec XXX_start, XXX_end; 772ca74e92bSShailabh Nagar * u64 XXX_delay; 773ca74e92bSShailabh Nagar * u32 XXX_count; 774ca74e92bSShailabh Nagar * 775ca74e92bSShailabh Nagar * Atomicity of updates to XXX_delay, XXX_count protected by 776ca74e92bSShailabh Nagar * single lock above (split into XXX_lock if contention is an issue). 777ca74e92bSShailabh Nagar */ 7780ff92245SShailabh Nagar 7790ff92245SShailabh Nagar /* 7800ff92245SShailabh Nagar * XXX_count is incremented on every XXX operation, the delay 7810ff92245SShailabh Nagar * associated with the operation is added to XXX_delay. 7820ff92245SShailabh Nagar * XXX_delay contains the accumulated delay time in nanoseconds. 7830ff92245SShailabh Nagar */ 7840ff92245SShailabh Nagar struct timespec blkio_start, blkio_end; /* Shared by blkio, swapin */ 7850ff92245SShailabh Nagar u64 blkio_delay; /* wait for sync block io completion */ 7860ff92245SShailabh Nagar u64 swapin_delay; /* wait for swapin block io completion */ 7870ff92245SShailabh Nagar u32 blkio_count; /* total count of the number of sync block */ 7880ff92245SShailabh Nagar /* io operations performed */ 7890ff92245SShailabh Nagar u32 swapin_count; /* total count of the number of swapin block */ 7900ff92245SShailabh Nagar /* io operations performed */ 791873b4771SKeika Kobayashi 792873b4771SKeika Kobayashi struct timespec freepages_start, freepages_end; 793873b4771SKeika Kobayashi u64 freepages_delay; /* wait for memory reclaim */ 794873b4771SKeika Kobayashi u32 freepages_count; /* total count of memory reclaim */ 795ca74e92bSShailabh Nagar }; 79652f17b6cSChandra Seetharaman #endif /* CONFIG_TASK_DELAY_ACCT */ 79752f17b6cSChandra Seetharaman 79852f17b6cSChandra Seetharaman static inline int sched_info_on(void) 79952f17b6cSChandra Seetharaman { 80052f17b6cSChandra Seetharaman #ifdef CONFIG_SCHEDSTATS 80152f17b6cSChandra Seetharaman return 1; 80252f17b6cSChandra Seetharaman #elif defined(CONFIG_TASK_DELAY_ACCT) 80352f17b6cSChandra Seetharaman extern int delayacct_on; 80452f17b6cSChandra Seetharaman return delayacct_on; 80552f17b6cSChandra Seetharaman #else 80652f17b6cSChandra Seetharaman return 0; 807ca74e92bSShailabh Nagar #endif 80852f17b6cSChandra Seetharaman } 809ca74e92bSShailabh Nagar 810d15bcfdbSIngo Molnar enum cpu_idle_type { 811d15bcfdbSIngo Molnar CPU_IDLE, 812d15bcfdbSIngo Molnar CPU_NOT_IDLE, 813d15bcfdbSIngo Molnar CPU_NEWLY_IDLE, 814d15bcfdbSIngo Molnar CPU_MAX_IDLE_TYPES 8151da177e4SLinus Torvalds }; 8161da177e4SLinus Torvalds 8171da177e4SLinus Torvalds /* 818c8b28116SNikhil Rao * Increase resolution of nice-level calculations for 64-bit architectures. 819c8b28116SNikhil Rao * The extra resolution improves shares distribution and load balancing of 820c8b28116SNikhil Rao * low-weight task groups (eg. nice +19 on an autogroup), deeper taskgroup 821c8b28116SNikhil Rao * hierarchies, especially on larger systems. This is not a user-visible change 822c8b28116SNikhil Rao * and does not change the user-interface for setting shares/weights. 823c8b28116SNikhil Rao * 824c8b28116SNikhil Rao * We increase resolution only if we have enough bits to allow this increased 825c8b28116SNikhil Rao * resolution (i.e. BITS_PER_LONG > 32). The costs for increasing resolution 826c8b28116SNikhil Rao * when BITS_PER_LONG <= 32 are pretty high and the returns do not justify the 827c8b28116SNikhil Rao * increased costs. 8281da177e4SLinus Torvalds */ 829e4c2fb0dSPeter Zijlstra #if 0 /* BITS_PER_LONG > 32 -- currently broken: it increases power usage under light load */ 830c8b28116SNikhil Rao # define SCHED_LOAD_RESOLUTION 10 831c8b28116SNikhil Rao # define scale_load(w) ((w) << SCHED_LOAD_RESOLUTION) 832c8b28116SNikhil Rao # define scale_load_down(w) ((w) >> SCHED_LOAD_RESOLUTION) 833c8b28116SNikhil Rao #else 834c8b28116SNikhil Rao # define SCHED_LOAD_RESOLUTION 0 835c8b28116SNikhil Rao # define scale_load(w) (w) 836c8b28116SNikhil Rao # define scale_load_down(w) (w) 837c8b28116SNikhil Rao #endif 8389aa7b369SIngo Molnar 839c8b28116SNikhil Rao #define SCHED_LOAD_SHIFT (10 + SCHED_LOAD_RESOLUTION) 8409aa7b369SIngo Molnar #define SCHED_LOAD_SCALE (1L << SCHED_LOAD_SHIFT) 8419aa7b369SIngo Molnar 8421399fa78SNikhil Rao /* 8431399fa78SNikhil Rao * Increase resolution of cpu_power calculations 8441399fa78SNikhil Rao */ 8451399fa78SNikhil Rao #define SCHED_POWER_SHIFT 10 8461399fa78SNikhil Rao #define SCHED_POWER_SCALE (1L << SCHED_POWER_SHIFT) 8471da177e4SLinus Torvalds 8481399fa78SNikhil Rao /* 8491399fa78SNikhil Rao * sched-domains (multiprocessor balancing) declarations: 8501399fa78SNikhil Rao */ 8512dd73a4fSPeter Williams #ifdef CONFIG_SMP 852b5d978e0SPeter Zijlstra #define SD_LOAD_BALANCE 0x0001 /* Do load balancing on this domain. */ 853b5d978e0SPeter Zijlstra #define SD_BALANCE_NEWIDLE 0x0002 /* Balance when about to become idle */ 854b5d978e0SPeter Zijlstra #define SD_BALANCE_EXEC 0x0004 /* Balance on exec */ 855b5d978e0SPeter Zijlstra #define SD_BALANCE_FORK 0x0008 /* Balance on fork, clone */ 856c88d5910SPeter Zijlstra #define SD_BALANCE_WAKE 0x0010 /* Balance on wakeup */ 857b5d978e0SPeter Zijlstra #define SD_WAKE_AFFINE 0x0020 /* Wake task to waking CPU */ 85859abf026SPeter Zijlstra #define SD_PREFER_LOCAL 0x0040 /* Prefer to keep tasks local to this domain */ 859b5d978e0SPeter Zijlstra #define SD_SHARE_CPUPOWER 0x0080 /* Domain members share cpu power */ 860b5d978e0SPeter Zijlstra #define SD_SHARE_PKG_RESOURCES 0x0200 /* Domain members share cpu pkg resources */ 861b5d978e0SPeter Zijlstra #define SD_SERIALIZE 0x0400 /* Only a single load balancing instance */ 862532cb4c4SMichael Neuling #define SD_ASYM_PACKING 0x0800 /* Place busy groups earlier in the domain */ 863b5d978e0SPeter Zijlstra #define SD_PREFER_SIBLING 0x1000 /* Prefer to place tasks in a sibling domain */ 864e3589f6cSPeter Zijlstra #define SD_OVERLAP 0x2000 /* sched_domains of this level overlap */ 8655c45bf27SSiddha, Suresh B 866532cb4c4SMichael Neuling extern int __weak arch_sd_sibiling_asym_packing(void); 867532cb4c4SMichael Neuling 8689c3f75cbSPeter Zijlstra struct sched_group_power { 869e3589f6cSPeter Zijlstra atomic_t ref; 8701da177e4SLinus Torvalds /* 8711da177e4SLinus Torvalds * CPU power of this group, SCHED_LOAD_SCALE being max power for a 87218a3885fSPeter Zijlstra * single CPU. 8731da177e4SLinus Torvalds */ 8749c3f75cbSPeter Zijlstra unsigned int power, power_orig; 8754ec4412eSVincent Guittot unsigned long next_update; 87669e1e811SSuresh Siddha /* 87769e1e811SSuresh Siddha * Number of busy cpus in this group. 87869e1e811SSuresh Siddha */ 87969e1e811SSuresh Siddha atomic_t nr_busy_cpus; 880c1174876SPeter Zijlstra 881c1174876SPeter Zijlstra unsigned long cpumask[0]; /* iteration mask */ 8829c3f75cbSPeter Zijlstra }; 8839c3f75cbSPeter Zijlstra 8849c3f75cbSPeter Zijlstra struct sched_group { 8859c3f75cbSPeter Zijlstra struct sched_group *next; /* Must be a circular list */ 8869c3f75cbSPeter Zijlstra atomic_t ref; 8879c3f75cbSPeter Zijlstra 888aae6d3ddSSuresh Siddha unsigned int group_weight; 8899c3f75cbSPeter Zijlstra struct sched_group_power *sgp; 8906c99e9adSRusty Russell 8914200efd9SIngo Molnar /* 8924200efd9SIngo Molnar * The CPUs this group covers. 8934200efd9SIngo Molnar * 8944200efd9SIngo Molnar * NOTE: this field is variable length. (Allocated dynamically 8954200efd9SIngo Molnar * by attaching extra space to the end of the structure, 8964200efd9SIngo Molnar * depending on how many CPUs the kernel has booted up with) 8974200efd9SIngo Molnar */ 8984200efd9SIngo Molnar unsigned long cpumask[0]; 8991da177e4SLinus Torvalds }; 9001da177e4SLinus Torvalds 901758b2cdcSRusty Russell static inline struct cpumask *sched_group_cpus(struct sched_group *sg) 902758b2cdcSRusty Russell { 9036c99e9adSRusty Russell return to_cpumask(sg->cpumask); 904758b2cdcSRusty Russell } 905758b2cdcSRusty Russell 906c1174876SPeter Zijlstra /* 907c1174876SPeter Zijlstra * cpumask masking which cpus in the group are allowed to iterate up the domain 908c1174876SPeter Zijlstra * tree. 909c1174876SPeter Zijlstra */ 910c1174876SPeter Zijlstra static inline struct cpumask *sched_group_mask(struct sched_group *sg) 911c1174876SPeter Zijlstra { 912c1174876SPeter Zijlstra return to_cpumask(sg->sgp->cpumask); 913c1174876SPeter Zijlstra } 914c1174876SPeter Zijlstra 915029632fbSPeter Zijlstra /** 916029632fbSPeter Zijlstra * group_first_cpu - Returns the first cpu in the cpumask of a sched_group. 917029632fbSPeter Zijlstra * @group: The group whose first cpu is to be returned. 918029632fbSPeter Zijlstra */ 919029632fbSPeter Zijlstra static inline unsigned int group_first_cpu(struct sched_group *group) 920029632fbSPeter Zijlstra { 921029632fbSPeter Zijlstra return cpumask_first(sched_group_cpus(group)); 922029632fbSPeter Zijlstra } 923029632fbSPeter Zijlstra 9241d3504fcSHidetoshi Seto struct sched_domain_attr { 9251d3504fcSHidetoshi Seto int relax_domain_level; 9261d3504fcSHidetoshi Seto }; 9271d3504fcSHidetoshi Seto 9281d3504fcSHidetoshi Seto #define SD_ATTR_INIT (struct sched_domain_attr) { \ 9291d3504fcSHidetoshi Seto .relax_domain_level = -1, \ 9301d3504fcSHidetoshi Seto } 9311d3504fcSHidetoshi Seto 93260495e77SPeter Zijlstra extern int sched_domain_level_max; 93360495e77SPeter Zijlstra 9341da177e4SLinus Torvalds struct sched_domain { 9351da177e4SLinus Torvalds /* These fields must be setup */ 9361da177e4SLinus Torvalds struct sched_domain *parent; /* top domain must be null terminated */ 9371a848870SSiddha, Suresh B struct sched_domain *child; /* bottom domain must be null terminated */ 9381da177e4SLinus Torvalds struct sched_group *groups; /* the balancing groups of the domain */ 9391da177e4SLinus Torvalds unsigned long min_interval; /* Minimum balance interval ms */ 9401da177e4SLinus Torvalds unsigned long max_interval; /* Maximum balance interval ms */ 9411da177e4SLinus Torvalds unsigned int busy_factor; /* less balancing by factor if busy */ 9421da177e4SLinus Torvalds unsigned int imbalance_pct; /* No balance until over watermark */ 9431da177e4SLinus Torvalds unsigned int cache_nice_tries; /* Leave cache hot tasks for # tries */ 9447897986bSNick Piggin unsigned int busy_idx; 9457897986bSNick Piggin unsigned int idle_idx; 9467897986bSNick Piggin unsigned int newidle_idx; 9477897986bSNick Piggin unsigned int wake_idx; 948147cbb4bSNick Piggin unsigned int forkexec_idx; 949a52bfd73SPeter Zijlstra unsigned int smt_gain; 9501da177e4SLinus Torvalds int flags; /* See SD_* */ 95160495e77SPeter Zijlstra int level; 9521da177e4SLinus Torvalds 9531da177e4SLinus Torvalds /* Runtime fields. */ 9541da177e4SLinus Torvalds unsigned long last_balance; /* init to jiffies. units in jiffies */ 9551da177e4SLinus Torvalds unsigned int balance_interval; /* initialise to 1. units in ms. */ 9561da177e4SLinus Torvalds unsigned int nr_balance_failed; /* initialise to 0 */ 9571da177e4SLinus Torvalds 9582398f2c6SPeter Zijlstra u64 last_update; 9592398f2c6SPeter Zijlstra 9601da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS 9611da177e4SLinus Torvalds /* load_balance() stats */ 962480b9434SKen Chen unsigned int lb_count[CPU_MAX_IDLE_TYPES]; 963480b9434SKen Chen unsigned int lb_failed[CPU_MAX_IDLE_TYPES]; 964480b9434SKen Chen unsigned int lb_balanced[CPU_MAX_IDLE_TYPES]; 965480b9434SKen Chen unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES]; 966480b9434SKen Chen unsigned int lb_gained[CPU_MAX_IDLE_TYPES]; 967480b9434SKen Chen unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES]; 968480b9434SKen Chen unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES]; 969480b9434SKen Chen unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES]; 9701da177e4SLinus Torvalds 9711da177e4SLinus Torvalds /* Active load balancing */ 972480b9434SKen Chen unsigned int alb_count; 973480b9434SKen Chen unsigned int alb_failed; 974480b9434SKen Chen unsigned int alb_pushed; 9751da177e4SLinus Torvalds 97668767a0aSNick Piggin /* SD_BALANCE_EXEC stats */ 977480b9434SKen Chen unsigned int sbe_count; 978480b9434SKen Chen unsigned int sbe_balanced; 979480b9434SKen Chen unsigned int sbe_pushed; 9801da177e4SLinus Torvalds 98168767a0aSNick Piggin /* SD_BALANCE_FORK stats */ 982480b9434SKen Chen unsigned int sbf_count; 983480b9434SKen Chen unsigned int sbf_balanced; 984480b9434SKen Chen unsigned int sbf_pushed; 98568767a0aSNick Piggin 9861da177e4SLinus Torvalds /* try_to_wake_up() stats */ 987480b9434SKen Chen unsigned int ttwu_wake_remote; 988480b9434SKen Chen unsigned int ttwu_move_affine; 989480b9434SKen Chen unsigned int ttwu_move_balance; 9901da177e4SLinus Torvalds #endif 991a5d8c348SIngo Molnar #ifdef CONFIG_SCHED_DEBUG 992a5d8c348SIngo Molnar char *name; 993a5d8c348SIngo Molnar #endif 994dce840a0SPeter Zijlstra union { 995dce840a0SPeter Zijlstra void *private; /* used during construction */ 996dce840a0SPeter Zijlstra struct rcu_head rcu; /* used during destruction */ 997dce840a0SPeter Zijlstra }; 9986c99e9adSRusty Russell 999669c55e9SPeter Zijlstra unsigned int span_weight; 10004200efd9SIngo Molnar /* 10014200efd9SIngo Molnar * Span of all CPUs in this domain. 10024200efd9SIngo Molnar * 10034200efd9SIngo Molnar * NOTE: this field is variable length. (Allocated dynamically 10044200efd9SIngo Molnar * by attaching extra space to the end of the structure, 10054200efd9SIngo Molnar * depending on how many CPUs the kernel has booted up with) 10064200efd9SIngo Molnar */ 10074200efd9SIngo Molnar unsigned long span[0]; 10081da177e4SLinus Torvalds }; 10091da177e4SLinus Torvalds 1010758b2cdcSRusty Russell static inline struct cpumask *sched_domain_span(struct sched_domain *sd) 1011758b2cdcSRusty Russell { 10126c99e9adSRusty Russell return to_cpumask(sd->span); 1013758b2cdcSRusty Russell } 1014758b2cdcSRusty Russell 1015acc3f5d7SRusty Russell extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[], 10161d3504fcSHidetoshi Seto struct sched_domain_attr *dattr_new); 1017029190c5SPaul Jackson 1018acc3f5d7SRusty Russell /* Allocate an array of sched domains, for partition_sched_domains(). */ 1019acc3f5d7SRusty Russell cpumask_var_t *alloc_sched_domains(unsigned int ndoms); 1020acc3f5d7SRusty Russell void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms); 1021acc3f5d7SRusty Russell 102206aaf76aSIngo Molnar /* Test a flag in parent sched domain */ 102306aaf76aSIngo Molnar static inline int test_sd_parent(struct sched_domain *sd, int flag) 102406aaf76aSIngo Molnar { 102506aaf76aSIngo Molnar if (sd->parent && (sd->parent->flags & flag)) 102606aaf76aSIngo Molnar return 1; 102706aaf76aSIngo Molnar 102806aaf76aSIngo Molnar return 0; 102906aaf76aSIngo Molnar } 10301da177e4SLinus Torvalds 103147fe38fcSPeter Zijlstra unsigned long default_scale_freq_power(struct sched_domain *sd, int cpu); 103247fe38fcSPeter Zijlstra unsigned long default_scale_smt_power(struct sched_domain *sd, int cpu); 103347fe38fcSPeter Zijlstra 103439be3501SPeter Zijlstra bool cpus_share_cache(int this_cpu, int that_cpu); 103539be3501SPeter Zijlstra 10361b427c15SIngo Molnar #else /* CONFIG_SMP */ 10371da177e4SLinus Torvalds 10381b427c15SIngo Molnar struct sched_domain_attr; 10391b427c15SIngo Molnar 10401b427c15SIngo Molnar static inline void 1041acc3f5d7SRusty Russell partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[], 10421b427c15SIngo Molnar struct sched_domain_attr *dattr_new) 1043d02c7a8cSCon Kolivas { 1044d02c7a8cSCon Kolivas } 104539be3501SPeter Zijlstra 104639be3501SPeter Zijlstra static inline bool cpus_share_cache(int this_cpu, int that_cpu) 104739be3501SPeter Zijlstra { 104839be3501SPeter Zijlstra return true; 104939be3501SPeter Zijlstra } 105039be3501SPeter Zijlstra 10511b427c15SIngo Molnar #endif /* !CONFIG_SMP */ 10521da177e4SLinus Torvalds 105347fe38fcSPeter Zijlstra 10541da177e4SLinus Torvalds struct io_context; /* See blkdev.h */ 10551da177e4SLinus Torvalds 10561da177e4SLinus Torvalds 1057383f2835SChen, Kenneth W #ifdef ARCH_HAS_PREFETCH_SWITCH_STACK 105836c8b586SIngo Molnar extern void prefetch_stack(struct task_struct *t); 1059383f2835SChen, Kenneth W #else 1060383f2835SChen, Kenneth W static inline void prefetch_stack(struct task_struct *t) { } 1061383f2835SChen, Kenneth W #endif 10621da177e4SLinus Torvalds 10631da177e4SLinus Torvalds struct audit_context; /* See audit.c */ 10641da177e4SLinus Torvalds struct mempolicy; 1065b92ce558SJens Axboe struct pipe_inode_info; 10664865ecf1SSerge E. Hallyn struct uts_namespace; 10671da177e4SLinus Torvalds 106820b8a59fSIngo Molnar struct rq; 106920b8a59fSIngo Molnar struct sched_domain; 107020b8a59fSIngo Molnar 10717d478721SPeter Zijlstra /* 10727d478721SPeter Zijlstra * wake flags 10737d478721SPeter Zijlstra */ 10747d478721SPeter Zijlstra #define WF_SYNC 0x01 /* waker goes to sleep after wakup */ 1075a7558e01SPeter Zijlstra #define WF_FORK 0x02 /* child wakeup after fork */ 1076f339b9dcSPeter Zijlstra #define WF_MIGRATED 0x04 /* internal use, task got migrated */ 10777d478721SPeter Zijlstra 1078371fd7e7SPeter Zijlstra #define ENQUEUE_WAKEUP 1 107974f8e4b2SPeter Zijlstra #define ENQUEUE_HEAD 2 108074f8e4b2SPeter Zijlstra #ifdef CONFIG_SMP 108174f8e4b2SPeter Zijlstra #define ENQUEUE_WAKING 4 /* sched_class::task_waking was called */ 108274f8e4b2SPeter Zijlstra #else 108374f8e4b2SPeter Zijlstra #define ENQUEUE_WAKING 0 108474f8e4b2SPeter Zijlstra #endif 1085371fd7e7SPeter Zijlstra 1086371fd7e7SPeter Zijlstra #define DEQUEUE_SLEEP 1 1087371fd7e7SPeter Zijlstra 108820b8a59fSIngo Molnar struct sched_class { 10895522d5d5SIngo Molnar const struct sched_class *next; 109020b8a59fSIngo Molnar 1091371fd7e7SPeter Zijlstra void (*enqueue_task) (struct rq *rq, struct task_struct *p, int flags); 1092371fd7e7SPeter Zijlstra void (*dequeue_task) (struct rq *rq, struct task_struct *p, int flags); 10934530d7abSDmitry Adamushko void (*yield_task) (struct rq *rq); 1094d95f4122SMike Galbraith bool (*yield_to_task) (struct rq *rq, struct task_struct *p, bool preempt); 109520b8a59fSIngo Molnar 10967d478721SPeter Zijlstra void (*check_preempt_curr) (struct rq *rq, struct task_struct *p, int flags); 109720b8a59fSIngo Molnar 1098fb8d4724SIngo Molnar struct task_struct * (*pick_next_task) (struct rq *rq); 109931ee529cSIngo Molnar void (*put_prev_task) (struct rq *rq, struct task_struct *p); 110020b8a59fSIngo Molnar 1101681f3e68SPeter Williams #ifdef CONFIG_SMP 11027608dec2SPeter Zijlstra int (*select_task_rq)(struct task_struct *p, int sd_flag, int flags); 11034ce72a2cSLi Zefan 11049a897c5aSSteven Rostedt void (*pre_schedule) (struct rq *this_rq, struct task_struct *task); 11059a897c5aSSteven Rostedt void (*post_schedule) (struct rq *this_rq); 110674f8e4b2SPeter Zijlstra void (*task_waking) (struct task_struct *task); 1107efbbd05aSPeter Zijlstra void (*task_woken) (struct rq *this_rq, struct task_struct *task); 1108e1d1484fSPeter Williams 1109cd8ba7cdSMike Travis void (*set_cpus_allowed)(struct task_struct *p, 111096f874e2SRusty Russell const struct cpumask *newmask); 111157d885feSGregory Haskins 11121f11eb6aSGregory Haskins void (*rq_online)(struct rq *rq); 11131f11eb6aSGregory Haskins void (*rq_offline)(struct rq *rq); 11144ce72a2cSLi Zefan #endif 11154ce72a2cSLi Zefan 11164ce72a2cSLi Zefan void (*set_curr_task) (struct rq *rq); 11174ce72a2cSLi Zefan void (*task_tick) (struct rq *rq, struct task_struct *p, int queued); 1118cd29fe6fSPeter Zijlstra void (*task_fork) (struct task_struct *p); 1119cb469845SSteven Rostedt 1120da7a735eSPeter Zijlstra void (*switched_from) (struct rq *this_rq, struct task_struct *task); 1121da7a735eSPeter Zijlstra void (*switched_to) (struct rq *this_rq, struct task_struct *task); 1122cb469845SSteven Rostedt void (*prio_changed) (struct rq *this_rq, struct task_struct *task, 1123da7a735eSPeter Zijlstra int oldprio); 1124810b3817SPeter Zijlstra 1125dba091b9SThomas Gleixner unsigned int (*get_rr_interval) (struct rq *rq, 1126dba091b9SThomas Gleixner struct task_struct *task); 11270d721ceaSPeter Williams 1128810b3817SPeter Zijlstra #ifdef CONFIG_FAIR_GROUP_SCHED 1129b2b5ce02SPeter Zijlstra void (*task_move_group) (struct task_struct *p, int on_rq); 1130810b3817SPeter Zijlstra #endif 113120b8a59fSIngo Molnar }; 113220b8a59fSIngo Molnar 113320b8a59fSIngo Molnar struct load_weight { 113420b8a59fSIngo Molnar unsigned long weight, inv_weight; 113520b8a59fSIngo Molnar }; 113620b8a59fSIngo Molnar 113794c18227SIngo Molnar #ifdef CONFIG_SCHEDSTATS 113841acab88SLucas De Marchi struct sched_statistics { 113994c18227SIngo Molnar u64 wait_start; 114094c18227SIngo Molnar u64 wait_max; 11416d082592SArjan van de Ven u64 wait_count; 11426d082592SArjan van de Ven u64 wait_sum; 11438f0dfc34SArjan van de Ven u64 iowait_count; 11448f0dfc34SArjan van de Ven u64 iowait_sum; 114594c18227SIngo Molnar 114694c18227SIngo Molnar u64 sleep_start; 114720b8a59fSIngo Molnar u64 sleep_max; 114894c18227SIngo Molnar s64 sum_sleep_runtime; 114994c18227SIngo Molnar 115094c18227SIngo Molnar u64 block_start; 115120b8a59fSIngo Molnar u64 block_max; 115220b8a59fSIngo Molnar u64 exec_max; 1153eba1ed4bSIngo Molnar u64 slice_max; 1154cc367732SIngo Molnar 1155cc367732SIngo Molnar u64 nr_migrations_cold; 1156cc367732SIngo Molnar u64 nr_failed_migrations_affine; 1157cc367732SIngo Molnar u64 nr_failed_migrations_running; 1158cc367732SIngo Molnar u64 nr_failed_migrations_hot; 1159cc367732SIngo Molnar u64 nr_forced_migrations; 1160cc367732SIngo Molnar 1161cc367732SIngo Molnar u64 nr_wakeups; 1162cc367732SIngo Molnar u64 nr_wakeups_sync; 1163cc367732SIngo Molnar u64 nr_wakeups_migrate; 1164cc367732SIngo Molnar u64 nr_wakeups_local; 1165cc367732SIngo Molnar u64 nr_wakeups_remote; 1166cc367732SIngo Molnar u64 nr_wakeups_affine; 1167cc367732SIngo Molnar u64 nr_wakeups_affine_attempts; 1168cc367732SIngo Molnar u64 nr_wakeups_passive; 1169cc367732SIngo Molnar u64 nr_wakeups_idle; 117041acab88SLucas De Marchi }; 117141acab88SLucas De Marchi #endif 117241acab88SLucas De Marchi 117341acab88SLucas De Marchi struct sched_entity { 117441acab88SLucas De Marchi struct load_weight load; /* for load-balancing */ 117541acab88SLucas De Marchi struct rb_node run_node; 117641acab88SLucas De Marchi struct list_head group_node; 117741acab88SLucas De Marchi unsigned int on_rq; 117841acab88SLucas De Marchi 117941acab88SLucas De Marchi u64 exec_start; 118041acab88SLucas De Marchi u64 sum_exec_runtime; 118141acab88SLucas De Marchi u64 vruntime; 118241acab88SLucas De Marchi u64 prev_sum_exec_runtime; 118341acab88SLucas De Marchi 118441acab88SLucas De Marchi u64 nr_migrations; 118541acab88SLucas De Marchi 118641acab88SLucas De Marchi #ifdef CONFIG_SCHEDSTATS 118741acab88SLucas De Marchi struct sched_statistics statistics; 118894c18227SIngo Molnar #endif 118994c18227SIngo Molnar 119020b8a59fSIngo Molnar #ifdef CONFIG_FAIR_GROUP_SCHED 119120b8a59fSIngo Molnar struct sched_entity *parent; 119220b8a59fSIngo Molnar /* rq on which this entity is (to be) queued: */ 119320b8a59fSIngo Molnar struct cfs_rq *cfs_rq; 119420b8a59fSIngo Molnar /* rq "owned" by this entity/group: */ 119520b8a59fSIngo Molnar struct cfs_rq *my_q; 119620b8a59fSIngo Molnar #endif 119720b8a59fSIngo Molnar }; 119870b97a7fSIngo Molnar 1199fa717060SPeter Zijlstra struct sched_rt_entity { 1200fa717060SPeter Zijlstra struct list_head run_list; 120178f2c7dbSPeter Zijlstra unsigned long timeout; 1202bee367edSRichard Kennedy unsigned int time_slice; 12036f505b16SPeter Zijlstra 120458d6c2d7SPeter Zijlstra struct sched_rt_entity *back; 1205052f1dc7SPeter Zijlstra #ifdef CONFIG_RT_GROUP_SCHED 12066f505b16SPeter Zijlstra struct sched_rt_entity *parent; 12076f505b16SPeter Zijlstra /* rq on which this entity is (to be) queued: */ 12086f505b16SPeter Zijlstra struct rt_rq *rt_rq; 12096f505b16SPeter Zijlstra /* rq "owned" by this entity/group: */ 12106f505b16SPeter Zijlstra struct rt_rq *my_q; 12116f505b16SPeter Zijlstra #endif 1212fa717060SPeter Zijlstra }; 1213fa717060SPeter Zijlstra 1214de5bdff7SHiroshi Shimamoto /* 1215de5bdff7SHiroshi Shimamoto * default timeslice is 100 msecs (used only for SCHED_RR tasks). 1216de5bdff7SHiroshi Shimamoto * Timeslices get refilled after they expire. 1217de5bdff7SHiroshi Shimamoto */ 1218de5bdff7SHiroshi Shimamoto #define RR_TIMESLICE (100 * HZ / 1000) 1219de5bdff7SHiroshi Shimamoto 122086848966SPaul E. McKenney struct rcu_node; 122186848966SPaul E. McKenney 12228dc85d54SPeter Zijlstra enum perf_event_task_context { 12238dc85d54SPeter Zijlstra perf_invalid_context = -1, 12248dc85d54SPeter Zijlstra perf_hw_context = 0, 122589a1e187SPeter Zijlstra perf_sw_context, 12268dc85d54SPeter Zijlstra perf_nr_task_contexts, 12278dc85d54SPeter Zijlstra }; 12288dc85d54SPeter Zijlstra 12291da177e4SLinus Torvalds struct task_struct { 12301da177e4SLinus Torvalds volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */ 1231f7e4217bSRoman Zippel void *stack; 12321da177e4SLinus Torvalds atomic_t usage; 123397dc32cdSWilliam Cohen unsigned int flags; /* per process flags, defined below */ 123497dc32cdSWilliam Cohen unsigned int ptrace; 12351da177e4SLinus Torvalds 12362dd73a4fSPeter Williams #ifdef CONFIG_SMP 1237fa14ff4aSPeter Zijlstra struct llist_node wake_entry; 12383ca7a440SPeter Zijlstra int on_cpu; 12394866cde0SNick Piggin #endif 1240fd2f4419SPeter Zijlstra int on_rq; 124150e645a8SIngo Molnar 1242b29739f9SIngo Molnar int prio, static_prio, normal_prio; 1243c7aceabaSRichard Kennedy unsigned int rt_priority; 12445522d5d5SIngo Molnar const struct sched_class *sched_class; 124520b8a59fSIngo Molnar struct sched_entity se; 1246fa717060SPeter Zijlstra struct sched_rt_entity rt; 12471da177e4SLinus Torvalds 1248e107be36SAvi Kivity #ifdef CONFIG_PREEMPT_NOTIFIERS 1249e107be36SAvi Kivity /* list of struct preempt_notifier: */ 1250e107be36SAvi Kivity struct hlist_head preempt_notifiers; 1251e107be36SAvi Kivity #endif 1252e107be36SAvi Kivity 125318796aa0SAlexey Dobriyan /* 125418796aa0SAlexey Dobriyan * fpu_counter contains the number of consecutive context switches 125518796aa0SAlexey Dobriyan * that the FPU is used. If this is over a threshold, the lazy fpu 125618796aa0SAlexey Dobriyan * saving becomes unlazy to save the trap. This is an unsigned char 125718796aa0SAlexey Dobriyan * so that after 256 times the counter wraps and the behavior turns 125818796aa0SAlexey Dobriyan * lazy again; this to deal with bursty apps that only use FPU for 125918796aa0SAlexey Dobriyan * a short time 126018796aa0SAlexey Dobriyan */ 126118796aa0SAlexey Dobriyan unsigned char fpu_counter; 12626c5c9341SAlexey Dobriyan #ifdef CONFIG_BLK_DEV_IO_TRACE 12632056a782SJens Axboe unsigned int btrace_seq; 12646c5c9341SAlexey Dobriyan #endif 12651da177e4SLinus Torvalds 126697dc32cdSWilliam Cohen unsigned int policy; 126729baa747SPeter Zijlstra int nr_cpus_allowed; 12681da177e4SLinus Torvalds cpumask_t cpus_allowed; 12691da177e4SLinus Torvalds 1270a57eb940SPaul E. McKenney #ifdef CONFIG_PREEMPT_RCU 1271e260be67SPaul E. McKenney int rcu_read_lock_nesting; 1272f41d911fSPaul E. McKenney char rcu_read_unlock_special; 1273f41d911fSPaul E. McKenney struct list_head rcu_node_entry; 1274a57eb940SPaul E. McKenney #endif /* #ifdef CONFIG_PREEMPT_RCU */ 1275a57eb940SPaul E. McKenney #ifdef CONFIG_TREE_PREEMPT_RCU 1276a57eb940SPaul E. McKenney struct rcu_node *rcu_blocked_node; 1277f41d911fSPaul E. McKenney #endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */ 127824278d14SPaul E. McKenney #ifdef CONFIG_RCU_BOOST 127924278d14SPaul E. McKenney struct rt_mutex *rcu_boost_mutex; 128024278d14SPaul E. McKenney #endif /* #ifdef CONFIG_RCU_BOOST */ 1281e260be67SPaul E. McKenney 128252f17b6cSChandra Seetharaman #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) 12831da177e4SLinus Torvalds struct sched_info sched_info; 12841da177e4SLinus Torvalds #endif 12851da177e4SLinus Torvalds 12861da177e4SLinus Torvalds struct list_head tasks; 1287806c09a7SDario Faggioli #ifdef CONFIG_SMP 1288917b627dSGregory Haskins struct plist_node pushable_tasks; 1289806c09a7SDario Faggioli #endif 12901da177e4SLinus Torvalds 12911da177e4SLinus Torvalds struct mm_struct *mm, *active_mm; 12924471a675SJiri Kosina #ifdef CONFIG_COMPAT_BRK 12934471a675SJiri Kosina unsigned brk_randomized:1; 12944471a675SJiri Kosina #endif 129534e55232SKAMEZAWA Hiroyuki #if defined(SPLIT_RSS_COUNTING) 129634e55232SKAMEZAWA Hiroyuki struct task_rss_stat rss_stat; 129734e55232SKAMEZAWA Hiroyuki #endif 12981da177e4SLinus Torvalds /* task state */ 129997dc32cdSWilliam Cohen int exit_state; 13001da177e4SLinus Torvalds int exit_code, exit_signal; 13011da177e4SLinus Torvalds int pdeath_signal; /* The signal sent when the parent dies */ 1302a8f072c1STejun Heo unsigned int jobctl; /* JOBCTL_*, siglock protected */ 13031da177e4SLinus Torvalds /* ??? */ 130497dc32cdSWilliam Cohen unsigned int personality; 13051da177e4SLinus Torvalds unsigned did_exec:1; 1306f9ce1f1cSKentaro Takeda unsigned in_execve:1; /* Tell the LSMs that the process is doing an 1307f9ce1f1cSKentaro Takeda * execve */ 13088f0dfc34SArjan van de Ven unsigned in_iowait:1; 13098f0dfc34SArjan van de Ven 1310259e5e6cSAndy Lutomirski /* task may not gain privileges */ 1311259e5e6cSAndy Lutomirski unsigned no_new_privs:1; 1312ca94c442SLennart Poettering 1313ca94c442SLennart Poettering /* Revert to default priority/policy when forking */ 1314ca94c442SLennart Poettering unsigned sched_reset_on_fork:1; 1315a8e4f2eaSPeter Zijlstra unsigned sched_contributes_to_load:1; 1316ca94c442SLennart Poettering 13171da177e4SLinus Torvalds pid_t pid; 13181da177e4SLinus Torvalds pid_t tgid; 13190a425405SArjan van de Ven 13201314562aSHiroshi Shimamoto #ifdef CONFIG_CC_STACKPROTECTOR 13210a425405SArjan van de Ven /* Canary value for the -fstack-protector gcc feature */ 13220a425405SArjan van de Ven unsigned long stack_canary; 13231314562aSHiroshi Shimamoto #endif 13241da177e4SLinus Torvalds /* 13251da177e4SLinus Torvalds * pointers to (original) parent process, youngest child, younger sibling, 13261da177e4SLinus Torvalds * older sibling, respectively. (p->father can be replaced with 1327f470021aSRoland McGrath * p->real_parent->pid) 13281da177e4SLinus Torvalds */ 1329abd63bc3SKees Cook struct task_struct __rcu *real_parent; /* real parent process */ 1330abd63bc3SKees Cook struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */ 13311da177e4SLinus Torvalds /* 1332f470021aSRoland McGrath * children/sibling forms the list of my natural children 13331da177e4SLinus Torvalds */ 13341da177e4SLinus Torvalds struct list_head children; /* list of my children */ 13351da177e4SLinus Torvalds struct list_head sibling; /* linkage in my parent's children list */ 13361da177e4SLinus Torvalds struct task_struct *group_leader; /* threadgroup leader */ 13371da177e4SLinus Torvalds 1338f470021aSRoland McGrath /* 1339f470021aSRoland McGrath * ptraced is the list of tasks this task is using ptrace on. 1340f470021aSRoland McGrath * This includes both natural children and PTRACE_ATTACH targets. 1341f470021aSRoland McGrath * p->ptrace_entry is p's link on the p->parent->ptraced list. 1342f470021aSRoland McGrath */ 1343f470021aSRoland McGrath struct list_head ptraced; 1344f470021aSRoland McGrath struct list_head ptrace_entry; 1345f470021aSRoland McGrath 13461da177e4SLinus Torvalds /* PID/PID hash table linkage. */ 134792476d7fSEric W. Biederman struct pid_link pids[PIDTYPE_MAX]; 134847e65328SOleg Nesterov struct list_head thread_group; 13491da177e4SLinus Torvalds 13501da177e4SLinus Torvalds struct completion *vfork_done; /* for vfork() */ 13511da177e4SLinus Torvalds int __user *set_child_tid; /* CLONE_CHILD_SETTID */ 13521da177e4SLinus Torvalds int __user *clear_child_tid; /* CLONE_CHILD_CLEARTID */ 13531da177e4SLinus Torvalds 1354c66f08beSMichael Neuling cputime_t utime, stime, utimescaled, stimescaled; 13559ac52315SLaurent Vivier cputime_t gtime; 1356d99ca3b9SHidetoshi Seto #ifndef CONFIG_VIRT_CPU_ACCOUNTING 13579301899bSBalbir Singh cputime_t prev_utime, prev_stime; 1358d99ca3b9SHidetoshi Seto #endif 13591da177e4SLinus Torvalds unsigned long nvcsw, nivcsw; /* context switch counts */ 1360924b42d5STomas Janousek struct timespec start_time; /* monotonic time */ 1361924b42d5STomas Janousek struct timespec real_start_time; /* boot based time */ 13621da177e4SLinus Torvalds /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */ 13631da177e4SLinus Torvalds unsigned long min_flt, maj_flt; 13641da177e4SLinus Torvalds 1365f06febc9SFrank Mayhar struct task_cputime cputime_expires; 13661da177e4SLinus Torvalds struct list_head cpu_timers[3]; 13671da177e4SLinus Torvalds 13681da177e4SLinus Torvalds /* process credentials */ 13691b0ba1c9SArnd Bergmann const struct cred __rcu *real_cred; /* objective and real subjective task 13703b11a1deSDavid Howells * credentials (COW) */ 13711b0ba1c9SArnd Bergmann const struct cred __rcu *cred; /* effective (overridable) subjective task 13723b11a1deSDavid Howells * credentials (COW) */ 137336772092SPaolo 'Blaisorblade' Giarrusso char comm[TASK_COMM_LEN]; /* executable name excluding path 137436772092SPaolo 'Blaisorblade' Giarrusso - access with [gs]et_task_comm (which lock 137536772092SPaolo 'Blaisorblade' Giarrusso it with task_lock()) 1376221af7f8SLinus Torvalds - initialized normally by setup_new_exec */ 13771da177e4SLinus Torvalds /* file system info */ 13781da177e4SLinus Torvalds int link_count, total_link_count; 13793d5b6fccSAlexey Dobriyan #ifdef CONFIG_SYSVIPC 13801da177e4SLinus Torvalds /* ipc stuff */ 13811da177e4SLinus Torvalds struct sysv_sem sysvsem; 13823d5b6fccSAlexey Dobriyan #endif 1383e162b39aSMandeep Singh Baines #ifdef CONFIG_DETECT_HUNG_TASK 138482a1fcb9SIngo Molnar /* hung task detection */ 138582a1fcb9SIngo Molnar unsigned long last_switch_count; 138682a1fcb9SIngo Molnar #endif 13871da177e4SLinus Torvalds /* CPU-specific state of this task */ 13881da177e4SLinus Torvalds struct thread_struct thread; 13891da177e4SLinus Torvalds /* filesystem information */ 13901da177e4SLinus Torvalds struct fs_struct *fs; 13911da177e4SLinus Torvalds /* open file information */ 13921da177e4SLinus Torvalds struct files_struct *files; 13931651e14eSSerge E. Hallyn /* namespaces */ 1394ab516013SSerge E. Hallyn struct nsproxy *nsproxy; 13951da177e4SLinus Torvalds /* signal handlers */ 13961da177e4SLinus Torvalds struct signal_struct *signal; 13971da177e4SLinus Torvalds struct sighand_struct *sighand; 13981da177e4SLinus Torvalds 13991da177e4SLinus Torvalds sigset_t blocked, real_blocked; 1400f3de272bSRoland McGrath sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */ 14011da177e4SLinus Torvalds struct sigpending pending; 14021da177e4SLinus Torvalds 14031da177e4SLinus Torvalds unsigned long sas_ss_sp; 14041da177e4SLinus Torvalds size_t sas_ss_size; 14051da177e4SLinus Torvalds int (*notifier)(void *priv); 14061da177e4SLinus Torvalds void *notifier_data; 14071da177e4SLinus Torvalds sigset_t *notifier_mask; 1408*67d12145SAl Viro struct callback_head *task_works; 1409e73f8959SOleg Nesterov 14101da177e4SLinus Torvalds struct audit_context *audit_context; 1411bfef93a5SAl Viro #ifdef CONFIG_AUDITSYSCALL 1412bfef93a5SAl Viro uid_t loginuid; 14134746ec5bSEric Paris unsigned int sessionid; 1414bfef93a5SAl Viro #endif 1415932ecebbSWill Drewry struct seccomp seccomp; 14161da177e4SLinus Torvalds 14171da177e4SLinus Torvalds /* Thread group tracking */ 14181da177e4SLinus Torvalds u32 parent_exec_id; 14191da177e4SLinus Torvalds u32 self_exec_id; 142058568d2aSMiao Xie /* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed, 142158568d2aSMiao Xie * mempolicy */ 14221da177e4SLinus Torvalds spinlock_t alloc_lock; 14231da177e4SLinus Torvalds 1424b29739f9SIngo Molnar /* Protection of the PI data structures: */ 14251d615482SThomas Gleixner raw_spinlock_t pi_lock; 1426b29739f9SIngo Molnar 142723f78d4aSIngo Molnar #ifdef CONFIG_RT_MUTEXES 142823f78d4aSIngo Molnar /* PI waiters blocked on a rt_mutex held by this task */ 142923f78d4aSIngo Molnar struct plist_head pi_waiters; 143023f78d4aSIngo Molnar /* Deadlock detection and priority inheritance handling */ 143123f78d4aSIngo Molnar struct rt_mutex_waiter *pi_blocked_on; 143223f78d4aSIngo Molnar #endif 143323f78d4aSIngo Molnar 1434408894eeSIngo Molnar #ifdef CONFIG_DEBUG_MUTEXES 1435408894eeSIngo Molnar /* mutex deadlock detection */ 1436408894eeSIngo Molnar struct mutex_waiter *blocked_on; 1437408894eeSIngo Molnar #endif 1438de30a2b3SIngo Molnar #ifdef CONFIG_TRACE_IRQFLAGS 1439de30a2b3SIngo Molnar unsigned int irq_events; 1440de30a2b3SIngo Molnar unsigned long hardirq_enable_ip; 1441de30a2b3SIngo Molnar unsigned long hardirq_disable_ip; 1442fa1452e8SHiroshi Shimamoto unsigned int hardirq_enable_event; 1443de30a2b3SIngo Molnar unsigned int hardirq_disable_event; 1444fa1452e8SHiroshi Shimamoto int hardirqs_enabled; 1445de30a2b3SIngo Molnar int hardirq_context; 1446fa1452e8SHiroshi Shimamoto unsigned long softirq_disable_ip; 1447fa1452e8SHiroshi Shimamoto unsigned long softirq_enable_ip; 1448fa1452e8SHiroshi Shimamoto unsigned int softirq_disable_event; 1449fa1452e8SHiroshi Shimamoto unsigned int softirq_enable_event; 1450fa1452e8SHiroshi Shimamoto int softirqs_enabled; 1451de30a2b3SIngo Molnar int softirq_context; 1452de30a2b3SIngo Molnar #endif 1453fbb9ce95SIngo Molnar #ifdef CONFIG_LOCKDEP 1454bdb9441eSPeter Zijlstra # define MAX_LOCK_DEPTH 48UL 1455fbb9ce95SIngo Molnar u64 curr_chain_key; 1456fbb9ce95SIngo Molnar int lockdep_depth; 1457fbb9ce95SIngo Molnar unsigned int lockdep_recursion; 1458c7aceabaSRichard Kennedy struct held_lock held_locks[MAX_LOCK_DEPTH]; 1459cf40bd16SNick Piggin gfp_t lockdep_reclaim_gfp; 1460fbb9ce95SIngo Molnar #endif 1461408894eeSIngo Molnar 14621da177e4SLinus Torvalds /* journalling filesystem info */ 14631da177e4SLinus Torvalds void *journal_info; 14641da177e4SLinus Torvalds 1465d89d8796SNeil Brown /* stacked block device info */ 1466bddd87c7SAkinobu Mita struct bio_list *bio_list; 1467d89d8796SNeil Brown 146873c10101SJens Axboe #ifdef CONFIG_BLOCK 146973c10101SJens Axboe /* stack plugging */ 147073c10101SJens Axboe struct blk_plug *plug; 147173c10101SJens Axboe #endif 147273c10101SJens Axboe 14731da177e4SLinus Torvalds /* VM state */ 14741da177e4SLinus Torvalds struct reclaim_state *reclaim_state; 14751da177e4SLinus Torvalds 14761da177e4SLinus Torvalds struct backing_dev_info *backing_dev_info; 14771da177e4SLinus Torvalds 14781da177e4SLinus Torvalds struct io_context *io_context; 14791da177e4SLinus Torvalds 14801da177e4SLinus Torvalds unsigned long ptrace_message; 14811da177e4SLinus Torvalds siginfo_t *last_siginfo; /* For ptrace use. */ 14827c3ab738SAndrew Morton struct task_io_accounting ioac; 14838f0ab514SJay Lan #if defined(CONFIG_TASK_XACCT) 14841da177e4SLinus Torvalds u64 acct_rss_mem1; /* accumulated rss usage */ 14851da177e4SLinus Torvalds u64 acct_vm_mem1; /* accumulated virtual memory usage */ 148649b5cf34SJonathan Lim cputime_t acct_timexpd; /* stime + utime since last update */ 14871da177e4SLinus Torvalds #endif 14881da177e4SLinus Torvalds #ifdef CONFIG_CPUSETS 148958568d2aSMiao Xie nodemask_t mems_allowed; /* Protected by alloc_lock */ 1490cc9a6c87SMel Gorman seqcount_t mems_allowed_seq; /* Seqence no to catch updates */ 1491825a46afSPaul Jackson int cpuset_mem_spread_rotor; 14926adef3ebSJack Steiner int cpuset_slab_spread_rotor; 14931da177e4SLinus Torvalds #endif 1494ddbcc7e8SPaul Menage #ifdef CONFIG_CGROUPS 1495817929ecSPaul Menage /* Control Group info protected by css_set_lock */ 14962c392b8cSArnd Bergmann struct css_set __rcu *cgroups; 1497817929ecSPaul Menage /* cg_list protected by css_set_lock and tsk->alloc_lock */ 1498817929ecSPaul Menage struct list_head cg_list; 1499ddbcc7e8SPaul Menage #endif 150042b2dd0aSAlexey Dobriyan #ifdef CONFIG_FUTEX 15010771dfefSIngo Molnar struct robust_list_head __user *robust_list; 150234f192c6SIngo Molnar #ifdef CONFIG_COMPAT 150334f192c6SIngo Molnar struct compat_robust_list_head __user *compat_robust_list; 150434f192c6SIngo Molnar #endif 1505c87e2837SIngo Molnar struct list_head pi_state_list; 1506c87e2837SIngo Molnar struct futex_pi_state *pi_state_cache; 150742b2dd0aSAlexey Dobriyan #endif 1508cdd6c482SIngo Molnar #ifdef CONFIG_PERF_EVENTS 15098dc85d54SPeter Zijlstra struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts]; 1510cdd6c482SIngo Molnar struct mutex perf_event_mutex; 1511cdd6c482SIngo Molnar struct list_head perf_event_list; 1512a63eaf34SPaul Mackerras #endif 1513c7aceabaSRichard Kennedy #ifdef CONFIG_NUMA 151458568d2aSMiao Xie struct mempolicy *mempolicy; /* Protected by alloc_lock */ 1515c7aceabaSRichard Kennedy short il_next; 1516207205a2SEric Dumazet short pref_node_fork; 1517c7aceabaSRichard Kennedy #endif 1518e56d0903SIngo Molnar struct rcu_head rcu; 1519b92ce558SJens Axboe 1520b92ce558SJens Axboe /* 1521b92ce558SJens Axboe * cache last used pipe for splice 1522b92ce558SJens Axboe */ 1523b92ce558SJens Axboe struct pipe_inode_info *splice_pipe; 1524ca74e92bSShailabh Nagar #ifdef CONFIG_TASK_DELAY_ACCT 1525ca74e92bSShailabh Nagar struct task_delay_info *delays; 1526ca74e92bSShailabh Nagar #endif 1527f4f154fdSAkinobu Mita #ifdef CONFIG_FAULT_INJECTION 1528f4f154fdSAkinobu Mita int make_it_fail; 1529f4f154fdSAkinobu Mita #endif 15309d823e8fSWu Fengguang /* 15319d823e8fSWu Fengguang * when (nr_dirtied >= nr_dirtied_pause), it's time to call 15329d823e8fSWu Fengguang * balance_dirty_pages() for some dirty throttling pause 15339d823e8fSWu Fengguang */ 15349d823e8fSWu Fengguang int nr_dirtied; 15359d823e8fSWu Fengguang int nr_dirtied_pause; 153683712358SWu Fengguang unsigned long dirty_paused_when; /* start of a write-and-pause period */ 15379d823e8fSWu Fengguang 15389745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP 15399745512cSArjan van de Ven int latency_record_count; 15409745512cSArjan van de Ven struct latency_record latency_record[LT_SAVECOUNT]; 15419745512cSArjan van de Ven #endif 15426976675dSArjan van de Ven /* 15436976675dSArjan van de Ven * time slack values; these are used to round up poll() and 15446976675dSArjan van de Ven * select() etc timeout values. These are in nanoseconds. 15456976675dSArjan van de Ven */ 15466976675dSArjan van de Ven unsigned long timer_slack_ns; 15476976675dSArjan van de Ven unsigned long default_timer_slack_ns; 1548f8d570a4SDavid Miller 1549f8d570a4SDavid Miller struct list_head *scm_work_list; 1550fb52607aSFrederic Weisbecker #ifdef CONFIG_FUNCTION_GRAPH_TRACER 15513ad2f3fbSDaniel Mack /* Index of current stored address in ret_stack */ 1552f201ae23SFrederic Weisbecker int curr_ret_stack; 1553f201ae23SFrederic Weisbecker /* Stack of return addresses for return function tracing */ 1554f201ae23SFrederic Weisbecker struct ftrace_ret_stack *ret_stack; 15558aef2d28SSteven Rostedt /* time stamp for last schedule */ 15568aef2d28SSteven Rostedt unsigned long long ftrace_timestamp; 1557f201ae23SFrederic Weisbecker /* 1558f201ae23SFrederic Weisbecker * Number of functions that haven't been traced 1559f201ae23SFrederic Weisbecker * because of depth overrun. 1560f201ae23SFrederic Weisbecker */ 1561f201ae23SFrederic Weisbecker atomic_t trace_overrun; 1562380c4b14SFrederic Weisbecker /* Pause for the tracing */ 1563380c4b14SFrederic Weisbecker atomic_t tracing_graph_pause; 1564f201ae23SFrederic Weisbecker #endif 1565ea4e2bc4SSteven Rostedt #ifdef CONFIG_TRACING 1566ea4e2bc4SSteven Rostedt /* state flags for use by tracers */ 1567ea4e2bc4SSteven Rostedt unsigned long trace; 1568b1cff0adSSteven Rostedt /* bitmask and counter of trace recursion */ 1569261842b7SSteven Rostedt unsigned long trace_recursion; 1570261842b7SSteven Rostedt #endif /* CONFIG_TRACING */ 1571569b846dSKAMEZAWA Hiroyuki #ifdef CONFIG_CGROUP_MEM_RES_CTLR /* memcg uses this to do batch job */ 1572569b846dSKAMEZAWA Hiroyuki struct memcg_batch_info { 1573569b846dSKAMEZAWA Hiroyuki int do_batch; /* incremented when batch uncharge started */ 1574569b846dSKAMEZAWA Hiroyuki struct mem_cgroup *memcg; /* target memcg of uncharge */ 15757ffd4ca7SJohannes Weiner unsigned long nr_pages; /* uncharged usage */ 15767ffd4ca7SJohannes Weiner unsigned long memsw_nr_pages; /* uncharged mem+swap usage */ 1577569b846dSKAMEZAWA Hiroyuki } memcg_batch; 1578569b846dSKAMEZAWA Hiroyuki #endif 1579bf26c018SFrederic Weisbecker #ifdef CONFIG_HAVE_HW_BREAKPOINT 1580bf26c018SFrederic Weisbecker atomic_t ptrace_bp_refcnt; 1581bf26c018SFrederic Weisbecker #endif 15820326f5a9SSrikar Dronamraju #ifdef CONFIG_UPROBES 15830326f5a9SSrikar Dronamraju struct uprobe_task *utask; 15840326f5a9SSrikar Dronamraju int uprobe_srcu_id; 15850326f5a9SSrikar Dronamraju #endif 15861da177e4SLinus Torvalds }; 15871da177e4SLinus Torvalds 158876e6eee0SRusty Russell /* Future-safe accessor for struct task_struct's cpus_allowed. */ 1589a4636818SRusty Russell #define tsk_cpus_allowed(tsk) (&(tsk)->cpus_allowed) 159076e6eee0SRusty Russell 1591e05606d3SIngo Molnar /* 1592e05606d3SIngo Molnar * Priority of a process goes from 0..MAX_PRIO-1, valid RT 1593e05606d3SIngo Molnar * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH 1594e05606d3SIngo Molnar * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority 1595e05606d3SIngo Molnar * values are inverted: lower p->prio value means higher priority. 1596e05606d3SIngo Molnar * 1597e05606d3SIngo Molnar * The MAX_USER_RT_PRIO value allows the actual maximum 1598e05606d3SIngo Molnar * RT priority to be separate from the value exported to 1599e05606d3SIngo Molnar * user-space. This allows kernel threads to set their 1600e05606d3SIngo Molnar * priority to a value higher than any user task. Note: 1601e05606d3SIngo Molnar * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO. 1602e05606d3SIngo Molnar */ 1603e05606d3SIngo Molnar 1604e05606d3SIngo Molnar #define MAX_USER_RT_PRIO 100 1605e05606d3SIngo Molnar #define MAX_RT_PRIO MAX_USER_RT_PRIO 1606e05606d3SIngo Molnar 1607e05606d3SIngo Molnar #define MAX_PRIO (MAX_RT_PRIO + 40) 1608e05606d3SIngo Molnar #define DEFAULT_PRIO (MAX_RT_PRIO + 20) 1609e05606d3SIngo Molnar 1610e05606d3SIngo Molnar static inline int rt_prio(int prio) 1611e05606d3SIngo Molnar { 1612e05606d3SIngo Molnar if (unlikely(prio < MAX_RT_PRIO)) 1613e05606d3SIngo Molnar return 1; 1614e05606d3SIngo Molnar return 0; 1615e05606d3SIngo Molnar } 1616e05606d3SIngo Molnar 1617e868171aSAlexey Dobriyan static inline int rt_task(struct task_struct *p) 1618e05606d3SIngo Molnar { 1619e05606d3SIngo Molnar return rt_prio(p->prio); 1620e05606d3SIngo Molnar } 1621e05606d3SIngo Molnar 1622e868171aSAlexey Dobriyan static inline struct pid *task_pid(struct task_struct *task) 162322c935f4SEric W. Biederman { 162422c935f4SEric W. Biederman return task->pids[PIDTYPE_PID].pid; 162522c935f4SEric W. Biederman } 162622c935f4SEric W. Biederman 1627e868171aSAlexey Dobriyan static inline struct pid *task_tgid(struct task_struct *task) 162822c935f4SEric W. Biederman { 162922c935f4SEric W. Biederman return task->group_leader->pids[PIDTYPE_PID].pid; 163022c935f4SEric W. Biederman } 163122c935f4SEric W. Biederman 16326dda81f4SOleg Nesterov /* 16336dda81f4SOleg Nesterov * Without tasklist or rcu lock it is not safe to dereference 16346dda81f4SOleg Nesterov * the result of task_pgrp/task_session even if task == current, 16356dda81f4SOleg Nesterov * we can race with another thread doing sys_setsid/sys_setpgid. 16366dda81f4SOleg Nesterov */ 1637e868171aSAlexey Dobriyan static inline struct pid *task_pgrp(struct task_struct *task) 163822c935f4SEric W. Biederman { 163922c935f4SEric W. Biederman return task->group_leader->pids[PIDTYPE_PGID].pid; 164022c935f4SEric W. Biederman } 164122c935f4SEric W. Biederman 1642e868171aSAlexey Dobriyan static inline struct pid *task_session(struct task_struct *task) 164322c935f4SEric W. Biederman { 164422c935f4SEric W. Biederman return task->group_leader->pids[PIDTYPE_SID].pid; 164522c935f4SEric W. Biederman } 164622c935f4SEric W. Biederman 16477af57294SPavel Emelyanov struct pid_namespace; 16487af57294SPavel Emelyanov 16497af57294SPavel Emelyanov /* 16507af57294SPavel Emelyanov * the helpers to get the task's different pids as they are seen 16517af57294SPavel Emelyanov * from various namespaces 16527af57294SPavel Emelyanov * 16537af57294SPavel Emelyanov * task_xid_nr() : global id, i.e. the id seen from the init namespace; 165444c4e1b2SEric W. Biederman * task_xid_vnr() : virtual id, i.e. the id seen from the pid namespace of 165544c4e1b2SEric W. Biederman * current. 16567af57294SPavel Emelyanov * task_xid_nr_ns() : id seen from the ns specified; 16577af57294SPavel Emelyanov * 16587af57294SPavel Emelyanov * set_task_vxid() : assigns a virtual id to a task; 16597af57294SPavel Emelyanov * 16607af57294SPavel Emelyanov * see also pid_nr() etc in include/linux/pid.h 16617af57294SPavel Emelyanov */ 166252ee2dfdSOleg Nesterov pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type, 166352ee2dfdSOleg Nesterov struct pid_namespace *ns); 16647af57294SPavel Emelyanov 1665e868171aSAlexey Dobriyan static inline pid_t task_pid_nr(struct task_struct *tsk) 16667af57294SPavel Emelyanov { 16677af57294SPavel Emelyanov return tsk->pid; 16687af57294SPavel Emelyanov } 16697af57294SPavel Emelyanov 167052ee2dfdSOleg Nesterov static inline pid_t task_pid_nr_ns(struct task_struct *tsk, 167152ee2dfdSOleg Nesterov struct pid_namespace *ns) 167252ee2dfdSOleg Nesterov { 167352ee2dfdSOleg Nesterov return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns); 167452ee2dfdSOleg Nesterov } 16757af57294SPavel Emelyanov 16767af57294SPavel Emelyanov static inline pid_t task_pid_vnr(struct task_struct *tsk) 16777af57294SPavel Emelyanov { 167852ee2dfdSOleg Nesterov return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL); 16797af57294SPavel Emelyanov } 16807af57294SPavel Emelyanov 16817af57294SPavel Emelyanov 1682e868171aSAlexey Dobriyan static inline pid_t task_tgid_nr(struct task_struct *tsk) 16837af57294SPavel Emelyanov { 16847af57294SPavel Emelyanov return tsk->tgid; 16857af57294SPavel Emelyanov } 16867af57294SPavel Emelyanov 16872f2a3a46SPavel Emelyanov pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns); 16887af57294SPavel Emelyanov 16897af57294SPavel Emelyanov static inline pid_t task_tgid_vnr(struct task_struct *tsk) 16907af57294SPavel Emelyanov { 16917af57294SPavel Emelyanov return pid_vnr(task_tgid(tsk)); 16927af57294SPavel Emelyanov } 16937af57294SPavel Emelyanov 16947af57294SPavel Emelyanov 169552ee2dfdSOleg Nesterov static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk, 169652ee2dfdSOleg Nesterov struct pid_namespace *ns) 16977af57294SPavel Emelyanov { 169852ee2dfdSOleg Nesterov return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns); 16997af57294SPavel Emelyanov } 17007af57294SPavel Emelyanov 17017af57294SPavel Emelyanov static inline pid_t task_pgrp_vnr(struct task_struct *tsk) 17027af57294SPavel Emelyanov { 170352ee2dfdSOleg Nesterov return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL); 17047af57294SPavel Emelyanov } 17057af57294SPavel Emelyanov 17067af57294SPavel Emelyanov 170752ee2dfdSOleg Nesterov static inline pid_t task_session_nr_ns(struct task_struct *tsk, 170852ee2dfdSOleg Nesterov struct pid_namespace *ns) 17097af57294SPavel Emelyanov { 171052ee2dfdSOleg Nesterov return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns); 17117af57294SPavel Emelyanov } 17127af57294SPavel Emelyanov 17137af57294SPavel Emelyanov static inline pid_t task_session_vnr(struct task_struct *tsk) 17147af57294SPavel Emelyanov { 171552ee2dfdSOleg Nesterov return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL); 17167af57294SPavel Emelyanov } 17177af57294SPavel Emelyanov 17181b0f7ffdSOleg Nesterov /* obsolete, do not use */ 17191b0f7ffdSOleg Nesterov static inline pid_t task_pgrp_nr(struct task_struct *tsk) 17201b0f7ffdSOleg Nesterov { 17211b0f7ffdSOleg Nesterov return task_pgrp_nr_ns(tsk, &init_pid_ns); 17221b0f7ffdSOleg Nesterov } 17237af57294SPavel Emelyanov 17241da177e4SLinus Torvalds /** 17251da177e4SLinus Torvalds * pid_alive - check that a task structure is not stale 17261da177e4SLinus Torvalds * @p: Task structure to be checked. 17271da177e4SLinus Torvalds * 17281da177e4SLinus Torvalds * Test if a process is not yet dead (at most zombie state) 17291da177e4SLinus Torvalds * If pid_alive fails, then pointers within the task structure 17301da177e4SLinus Torvalds * can be stale and must not be dereferenced. 17311da177e4SLinus Torvalds */ 1732e868171aSAlexey Dobriyan static inline int pid_alive(struct task_struct *p) 17331da177e4SLinus Torvalds { 173492476d7fSEric W. Biederman return p->pids[PIDTYPE_PID].pid != NULL; 17351da177e4SLinus Torvalds } 17361da177e4SLinus Torvalds 1737f400e198SSukadev Bhattiprolu /** 1738b460cbc5SSerge E. Hallyn * is_global_init - check if a task structure is init 17393260259fSHenne * @tsk: Task structure to be checked. 17403260259fSHenne * 17413260259fSHenne * Check if a task structure is the first user space task the kernel created. 1742f400e198SSukadev Bhattiprolu */ 1743e868171aSAlexey Dobriyan static inline int is_global_init(struct task_struct *tsk) 1744b461cc03SPavel Emelyanov { 1745b461cc03SPavel Emelyanov return tsk->pid == 1; 1746b461cc03SPavel Emelyanov } 1747b460cbc5SSerge E. Hallyn 1748b460cbc5SSerge E. Hallyn /* 1749b460cbc5SSerge E. Hallyn * is_container_init: 1750b460cbc5SSerge E. Hallyn * check whether in the task is init in its own pid namespace. 1751b460cbc5SSerge E. Hallyn */ 1752b461cc03SPavel Emelyanov extern int is_container_init(struct task_struct *tsk); 1753f400e198SSukadev Bhattiprolu 17549ec52099SCedric Le Goater extern struct pid *cad_pid; 17559ec52099SCedric Le Goater 17561da177e4SLinus Torvalds extern void free_task(struct task_struct *tsk); 17571da177e4SLinus Torvalds #define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0) 1758e56d0903SIngo Molnar 1759158d9ebdSAndrew Morton extern void __put_task_struct(struct task_struct *t); 1760e56d0903SIngo Molnar 1761e56d0903SIngo Molnar static inline void put_task_struct(struct task_struct *t) 1762e56d0903SIngo Molnar { 1763e56d0903SIngo Molnar if (atomic_dec_and_test(&t->usage)) 17648c7904a0SEric W. Biederman __put_task_struct(t); 1765e56d0903SIngo Molnar } 17661da177e4SLinus Torvalds 1767d180c5bcSHidetoshi Seto extern void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st); 17680cf55e1eSHidetoshi Seto extern void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st); 176949048622SBalbir Singh 17701da177e4SLinus Torvalds /* 17711da177e4SLinus Torvalds * Per process flags 17721da177e4SLinus Torvalds */ 17731da177e4SLinus Torvalds #define PF_EXITING 0x00000004 /* getting shut down */ 1774778e9a9cSAlexey Kuznetsov #define PF_EXITPIDONE 0x00000008 /* pi exit done on shut down */ 177594886b84SLaurent Vivier #define PF_VCPU 0x00000010 /* I'm a virtual CPU */ 177621aa9af0STejun Heo #define PF_WQ_WORKER 0x00000020 /* I'm a workqueue worker */ 17771da177e4SLinus Torvalds #define PF_FORKNOEXEC 0x00000040 /* forked but didn't exec */ 17784db96cf0SAndi Kleen #define PF_MCE_PROCESS 0x00000080 /* process policy on mce errors */ 17791da177e4SLinus Torvalds #define PF_SUPERPRIV 0x00000100 /* used super-user privileges */ 17801da177e4SLinus Torvalds #define PF_DUMPCORE 0x00000200 /* dumped core */ 17811da177e4SLinus Torvalds #define PF_SIGNALED 0x00000400 /* killed by a signal */ 17821da177e4SLinus Torvalds #define PF_MEMALLOC 0x00000800 /* Allocating memory */ 178372fa5997SVasiliy Kulikov #define PF_NPROC_EXCEEDED 0x00001000 /* set_user noticed that RLIMIT_NPROC was exceeded */ 17841da177e4SLinus Torvalds #define PF_USED_MATH 0x00002000 /* if unset the fpu must be initialized before use */ 17851da177e4SLinus Torvalds #define PF_NOFREEZE 0x00008000 /* this thread should not be frozen */ 17861da177e4SLinus Torvalds #define PF_FROZEN 0x00010000 /* frozen for system suspend */ 17871da177e4SLinus Torvalds #define PF_FSTRANS 0x00020000 /* inside a filesystem transaction */ 17881da177e4SLinus Torvalds #define PF_KSWAPD 0x00040000 /* I am kswapd */ 17891da177e4SLinus Torvalds #define PF_LESS_THROTTLE 0x00100000 /* Throttle me less: I clean memory */ 1790246bb0b1SOleg Nesterov #define PF_KTHREAD 0x00200000 /* I am a kernel thread */ 1791b31dc66aSJens Axboe #define PF_RANDOMIZE 0x00400000 /* randomize virtual address space */ 1792b31dc66aSJens Axboe #define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */ 1793b31dc66aSJens Axboe #define PF_SPREAD_PAGE 0x01000000 /* Spread page cache over cpuset */ 1794b31dc66aSJens Axboe #define PF_SPREAD_SLAB 0x02000000 /* Spread some slab caches over cpuset */ 17959985b0baSDavid Rientjes #define PF_THREAD_BOUND 0x04000000 /* Thread bound to specific cpu */ 17964db96cf0SAndi Kleen #define PF_MCE_EARLY 0x08000000 /* Early kill for mce process policy */ 1797c61afb18SPaul Jackson #define PF_MEMPOLICY 0x10000000 /* Non-default NUMA mempolicy */ 179861a87122SThomas Gleixner #define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */ 179958a69cb4STejun Heo #define PF_FREEZER_SKIP 0x40000000 /* Freezer should not count it as freezable */ 18001da177e4SLinus Torvalds 18011da177e4SLinus Torvalds /* 18021da177e4SLinus Torvalds * Only the _current_ task can read/write to tsk->flags, but other 18031da177e4SLinus Torvalds * tasks can access tsk->flags in readonly mode for example 18041da177e4SLinus Torvalds * with tsk_used_math (like during threaded core dumping). 18051da177e4SLinus Torvalds * There is however an exception to this rule during ptrace 18061da177e4SLinus Torvalds * or during fork: the ptracer task is allowed to write to the 18071da177e4SLinus Torvalds * child->flags of its traced child (same goes for fork, the parent 18081da177e4SLinus Torvalds * can write to the child->flags), because we're guaranteed the 18091da177e4SLinus Torvalds * child is not running and in turn not changing child->flags 18101da177e4SLinus Torvalds * at the same time the parent does it. 18111da177e4SLinus Torvalds */ 18121da177e4SLinus Torvalds #define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0) 18131da177e4SLinus Torvalds #define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0) 18141da177e4SLinus Torvalds #define clear_used_math() clear_stopped_child_used_math(current) 18151da177e4SLinus Torvalds #define set_used_math() set_stopped_child_used_math(current) 18161da177e4SLinus Torvalds #define conditional_stopped_child_used_math(condition, child) \ 18171da177e4SLinus Torvalds do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0) 18181da177e4SLinus Torvalds #define conditional_used_math(condition) \ 18191da177e4SLinus Torvalds conditional_stopped_child_used_math(condition, current) 18201da177e4SLinus Torvalds #define copy_to_stopped_child_used_math(child) \ 18211da177e4SLinus Torvalds do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0) 18221da177e4SLinus Torvalds /* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */ 18231da177e4SLinus Torvalds #define tsk_used_math(p) ((p)->flags & PF_USED_MATH) 18241da177e4SLinus Torvalds #define used_math() tsk_used_math(current) 18251da177e4SLinus Torvalds 1826e5c1902eSTejun Heo /* 1827a8f072c1STejun Heo * task->jobctl flags 1828e5c1902eSTejun Heo */ 1829a8f072c1STejun Heo #define JOBCTL_STOP_SIGMASK 0xffff /* signr of the last group stop */ 1830e5c1902eSTejun Heo 1831a8f072c1STejun Heo #define JOBCTL_STOP_DEQUEUED_BIT 16 /* stop signal dequeued */ 1832a8f072c1STejun Heo #define JOBCTL_STOP_PENDING_BIT 17 /* task should stop for group stop */ 1833a8f072c1STejun Heo #define JOBCTL_STOP_CONSUME_BIT 18 /* consume group stop count */ 183473ddff2bSTejun Heo #define JOBCTL_TRAP_STOP_BIT 19 /* trap for STOP */ 1835fb1d910cSTejun Heo #define JOBCTL_TRAP_NOTIFY_BIT 20 /* trap for NOTIFY */ 1836a8f072c1STejun Heo #define JOBCTL_TRAPPING_BIT 21 /* switching to TRACED */ 1837544b2c91STejun Heo #define JOBCTL_LISTENING_BIT 22 /* ptracer is listening for events */ 1838a8f072c1STejun Heo 1839a8f072c1STejun Heo #define JOBCTL_STOP_DEQUEUED (1 << JOBCTL_STOP_DEQUEUED_BIT) 1840a8f072c1STejun Heo #define JOBCTL_STOP_PENDING (1 << JOBCTL_STOP_PENDING_BIT) 1841a8f072c1STejun Heo #define JOBCTL_STOP_CONSUME (1 << JOBCTL_STOP_CONSUME_BIT) 184273ddff2bSTejun Heo #define JOBCTL_TRAP_STOP (1 << JOBCTL_TRAP_STOP_BIT) 1843fb1d910cSTejun Heo #define JOBCTL_TRAP_NOTIFY (1 << JOBCTL_TRAP_NOTIFY_BIT) 1844a8f072c1STejun Heo #define JOBCTL_TRAPPING (1 << JOBCTL_TRAPPING_BIT) 1845544b2c91STejun Heo #define JOBCTL_LISTENING (1 << JOBCTL_LISTENING_BIT) 1846a8f072c1STejun Heo 1847fb1d910cSTejun Heo #define JOBCTL_TRAP_MASK (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY) 184873ddff2bSTejun Heo #define JOBCTL_PENDING_MASK (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK) 18493759a0d9STejun Heo 18507dd3db54STejun Heo extern bool task_set_jobctl_pending(struct task_struct *task, 18517dd3db54STejun Heo unsigned int mask); 185273ddff2bSTejun Heo extern void task_clear_jobctl_trapping(struct task_struct *task); 18533759a0d9STejun Heo extern void task_clear_jobctl_pending(struct task_struct *task, 18543759a0d9STejun Heo unsigned int mask); 185539efa3efSTejun Heo 1856a57eb940SPaul E. McKenney #ifdef CONFIG_PREEMPT_RCU 1857f41d911fSPaul E. McKenney 1858f41d911fSPaul E. McKenney #define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */ 18591aa03f11SPaul E. McKenney #define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */ 1860f41d911fSPaul E. McKenney 1861f41d911fSPaul E. McKenney static inline void rcu_copy_process(struct task_struct *p) 1862f41d911fSPaul E. McKenney { 1863f41d911fSPaul E. McKenney p->rcu_read_lock_nesting = 0; 1864f41d911fSPaul E. McKenney p->rcu_read_unlock_special = 0; 1865a57eb940SPaul E. McKenney #ifdef CONFIG_TREE_PREEMPT_RCU 1866dd5d19baSPaul E. McKenney p->rcu_blocked_node = NULL; 186724278d14SPaul E. McKenney #endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */ 186824278d14SPaul E. McKenney #ifdef CONFIG_RCU_BOOST 186924278d14SPaul E. McKenney p->rcu_boost_mutex = NULL; 187024278d14SPaul E. McKenney #endif /* #ifdef CONFIG_RCU_BOOST */ 1871f41d911fSPaul E. McKenney INIT_LIST_HEAD(&p->rcu_node_entry); 1872f41d911fSPaul E. McKenney } 1873f41d911fSPaul E. McKenney 1874616c310eSPaul E. McKenney static inline void rcu_switch_from(struct task_struct *prev) 1875616c310eSPaul E. McKenney { 1876616c310eSPaul E. McKenney if (prev->rcu_read_lock_nesting != 0) 1877616c310eSPaul E. McKenney rcu_preempt_note_context_switch(); 1878616c310eSPaul E. McKenney } 1879616c310eSPaul E. McKenney 1880f41d911fSPaul E. McKenney #else 1881f41d911fSPaul E. McKenney 1882f41d911fSPaul E. McKenney static inline void rcu_copy_process(struct task_struct *p) 1883f41d911fSPaul E. McKenney { 1884f41d911fSPaul E. McKenney } 1885f41d911fSPaul E. McKenney 1886616c310eSPaul E. McKenney static inline void rcu_switch_from(struct task_struct *prev) 1887616c310eSPaul E. McKenney { 1888616c310eSPaul E. McKenney } 1889616c310eSPaul E. McKenney 1890f41d911fSPaul E. McKenney #endif 1891f41d911fSPaul E. McKenney 18921da177e4SLinus Torvalds #ifdef CONFIG_SMP 18931e1b6c51SKOSAKI Motohiro extern void do_set_cpus_allowed(struct task_struct *p, 18941e1b6c51SKOSAKI Motohiro const struct cpumask *new_mask); 18951e1b6c51SKOSAKI Motohiro 1896cd8ba7cdSMike Travis extern int set_cpus_allowed_ptr(struct task_struct *p, 189796f874e2SRusty Russell const struct cpumask *new_mask); 18981da177e4SLinus Torvalds #else 18991e1b6c51SKOSAKI Motohiro static inline void do_set_cpus_allowed(struct task_struct *p, 19001e1b6c51SKOSAKI Motohiro const struct cpumask *new_mask) 19011e1b6c51SKOSAKI Motohiro { 19021e1b6c51SKOSAKI Motohiro } 1903cd8ba7cdSMike Travis static inline int set_cpus_allowed_ptr(struct task_struct *p, 190496f874e2SRusty Russell const struct cpumask *new_mask) 19051da177e4SLinus Torvalds { 190696f874e2SRusty Russell if (!cpumask_test_cpu(0, new_mask)) 19071da177e4SLinus Torvalds return -EINVAL; 19081da177e4SLinus Torvalds return 0; 19091da177e4SLinus Torvalds } 19101da177e4SLinus Torvalds #endif 1911e0ad9556SRusty Russell 1912e0ad9556SRusty Russell #ifndef CONFIG_CPUMASK_OFFSTACK 1913cd8ba7cdSMike Travis static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask) 1914cd8ba7cdSMike Travis { 1915cd8ba7cdSMike Travis return set_cpus_allowed_ptr(p, &new_mask); 1916cd8ba7cdSMike Travis } 1917e0ad9556SRusty Russell #endif 19181da177e4SLinus Torvalds 1919b342501cSIngo Molnar /* 1920c676329aSPeter Zijlstra * Do not use outside of architecture code which knows its limitations. 1921c676329aSPeter Zijlstra * 1922c676329aSPeter Zijlstra * sched_clock() has no promise of monotonicity or bounded drift between 1923c676329aSPeter Zijlstra * CPUs, use (which you should not) requires disabling IRQs. 1924c676329aSPeter Zijlstra * 1925c676329aSPeter Zijlstra * Please use one of the three interfaces below. 1926b342501cSIngo Molnar */ 19271bbfa6f2SMike Frysinger extern unsigned long long notrace sched_clock(void); 1928c676329aSPeter Zijlstra /* 1929489a71b0SHiroshi Shimamoto * See the comment in kernel/sched/clock.c 1930c676329aSPeter Zijlstra */ 1931c676329aSPeter Zijlstra extern u64 cpu_clock(int cpu); 1932c676329aSPeter Zijlstra extern u64 local_clock(void); 1933c676329aSPeter Zijlstra extern u64 sched_clock_cpu(int cpu); 1934c676329aSPeter Zijlstra 1935e436d800SIngo Molnar 1936c1955a3dSPeter Zijlstra extern void sched_clock_init(void); 1937c1955a3dSPeter Zijlstra 19383e51f33fSPeter Zijlstra #ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK 19393e51f33fSPeter Zijlstra static inline void sched_clock_tick(void) 19403e51f33fSPeter Zijlstra { 19413e51f33fSPeter Zijlstra } 19423e51f33fSPeter Zijlstra 19433e51f33fSPeter Zijlstra static inline void sched_clock_idle_sleep_event(void) 19443e51f33fSPeter Zijlstra { 19453e51f33fSPeter Zijlstra } 19463e51f33fSPeter Zijlstra 19473e51f33fSPeter Zijlstra static inline void sched_clock_idle_wakeup_event(u64 delta_ns) 19483e51f33fSPeter Zijlstra { 19493e51f33fSPeter Zijlstra } 19503e51f33fSPeter Zijlstra #else 1951c676329aSPeter Zijlstra /* 1952c676329aSPeter Zijlstra * Architectures can set this to 1 if they have specified 1953c676329aSPeter Zijlstra * CONFIG_HAVE_UNSTABLE_SCHED_CLOCK in their arch Kconfig, 1954c676329aSPeter Zijlstra * but then during bootup it turns out that sched_clock() 1955c676329aSPeter Zijlstra * is reliable after all: 1956c676329aSPeter Zijlstra */ 1957c676329aSPeter Zijlstra extern int sched_clock_stable; 1958c676329aSPeter Zijlstra 19593e51f33fSPeter Zijlstra extern void sched_clock_tick(void); 19603e51f33fSPeter Zijlstra extern void sched_clock_idle_sleep_event(void); 19613e51f33fSPeter Zijlstra extern void sched_clock_idle_wakeup_event(u64 delta_ns); 19623e51f33fSPeter Zijlstra #endif 19633e51f33fSPeter Zijlstra 1964b52bfee4SVenkatesh Pallipadi #ifdef CONFIG_IRQ_TIME_ACCOUNTING 1965b52bfee4SVenkatesh Pallipadi /* 1966b52bfee4SVenkatesh Pallipadi * An i/f to runtime opt-in for irq time accounting based off of sched_clock. 1967b52bfee4SVenkatesh Pallipadi * The reason for this explicit opt-in is not to have perf penalty with 1968b52bfee4SVenkatesh Pallipadi * slow sched_clocks. 1969b52bfee4SVenkatesh Pallipadi */ 1970b52bfee4SVenkatesh Pallipadi extern void enable_sched_clock_irqtime(void); 1971b52bfee4SVenkatesh Pallipadi extern void disable_sched_clock_irqtime(void); 1972b52bfee4SVenkatesh Pallipadi #else 1973b52bfee4SVenkatesh Pallipadi static inline void enable_sched_clock_irqtime(void) {} 1974b52bfee4SVenkatesh Pallipadi static inline void disable_sched_clock_irqtime(void) {} 1975b52bfee4SVenkatesh Pallipadi #endif 1976b52bfee4SVenkatesh Pallipadi 197736c8b586SIngo Molnar extern unsigned long long 197841b86e9cSIngo Molnar task_sched_runtime(struct task_struct *task); 19791da177e4SLinus Torvalds 19801da177e4SLinus Torvalds /* sched_exec is called by processes performing an exec */ 19811da177e4SLinus Torvalds #ifdef CONFIG_SMP 19821da177e4SLinus Torvalds extern void sched_exec(void); 19831da177e4SLinus Torvalds #else 19841da177e4SLinus Torvalds #define sched_exec() {} 19851da177e4SLinus Torvalds #endif 19861da177e4SLinus Torvalds 19872aa44d05SIngo Molnar extern void sched_clock_idle_sleep_event(void); 19882aa44d05SIngo Molnar extern void sched_clock_idle_wakeup_event(u64 delta_ns); 1989bb29ab26SIngo Molnar 19901da177e4SLinus Torvalds #ifdef CONFIG_HOTPLUG_CPU 19911da177e4SLinus Torvalds extern void idle_task_exit(void); 19921da177e4SLinus Torvalds #else 19931da177e4SLinus Torvalds static inline void idle_task_exit(void) {} 19941da177e4SLinus Torvalds #endif 19951da177e4SLinus Torvalds 199606d8308cSThomas Gleixner #if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP) 199706d8308cSThomas Gleixner extern void wake_up_idle_cpu(int cpu); 199806d8308cSThomas Gleixner #else 199906d8308cSThomas Gleixner static inline void wake_up_idle_cpu(int cpu) { } 200006d8308cSThomas Gleixner #endif 200106d8308cSThomas Gleixner 200221805085SPeter Zijlstra extern unsigned int sysctl_sched_latency; 2003b2be5e96SPeter Zijlstra extern unsigned int sysctl_sched_min_granularity; 2004bf0f6f24SIngo Molnar extern unsigned int sysctl_sched_wakeup_granularity; 2005bf0f6f24SIngo Molnar extern unsigned int sysctl_sched_child_runs_first; 20061983a922SChristian Ehrhardt 20071983a922SChristian Ehrhardt enum sched_tunable_scaling { 20081983a922SChristian Ehrhardt SCHED_TUNABLESCALING_NONE, 20091983a922SChristian Ehrhardt SCHED_TUNABLESCALING_LOG, 20101983a922SChristian Ehrhardt SCHED_TUNABLESCALING_LINEAR, 20111983a922SChristian Ehrhardt SCHED_TUNABLESCALING_END, 20121983a922SChristian Ehrhardt }; 20131983a922SChristian Ehrhardt extern enum sched_tunable_scaling sysctl_sched_tunable_scaling; 20141983a922SChristian Ehrhardt 20152bba22c5SMike Galbraith #ifdef CONFIG_SCHED_DEBUG 2016da84d961SIngo Molnar extern unsigned int sysctl_sched_migration_cost; 2017b82d9fddSPeter Zijlstra extern unsigned int sysctl_sched_nr_migrate; 2018e9e9250bSPeter Zijlstra extern unsigned int sysctl_sched_time_avg; 2019cd1bb94bSArun R Bharadwaj extern unsigned int sysctl_timer_migration; 2020a7a4f8a7SPaul Turner extern unsigned int sysctl_sched_shares_window; 2021b2be5e96SPeter Zijlstra 20221983a922SChristian Ehrhardt int sched_proc_update_handler(struct ctl_table *table, int write, 20238d65af78SAlexey Dobriyan void __user *buffer, size_t *length, 2024b2be5e96SPeter Zijlstra loff_t *ppos); 20252bd8e6d4SIngo Molnar #endif 2026eea08f32SArun R Bharadwaj #ifdef CONFIG_SCHED_DEBUG 2027eea08f32SArun R Bharadwaj static inline unsigned int get_sysctl_timer_migration(void) 2028eea08f32SArun R Bharadwaj { 2029eea08f32SArun R Bharadwaj return sysctl_timer_migration; 2030eea08f32SArun R Bharadwaj } 2031eea08f32SArun R Bharadwaj #else 2032eea08f32SArun R Bharadwaj static inline unsigned int get_sysctl_timer_migration(void) 2033eea08f32SArun R Bharadwaj { 2034eea08f32SArun R Bharadwaj return 1; 2035eea08f32SArun R Bharadwaj } 2036eea08f32SArun R Bharadwaj #endif 20379f0c1e56SPeter Zijlstra extern unsigned int sysctl_sched_rt_period; 20389f0c1e56SPeter Zijlstra extern int sysctl_sched_rt_runtime; 20392bd8e6d4SIngo Molnar 2040d0b27fa7SPeter Zijlstra int sched_rt_handler(struct ctl_table *table, int write, 20418d65af78SAlexey Dobriyan void __user *buffer, size_t *lenp, 2042d0b27fa7SPeter Zijlstra loff_t *ppos); 2043d0b27fa7SPeter Zijlstra 20445091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP 20455091faa4SMike Galbraith extern unsigned int sysctl_sched_autogroup_enabled; 20465091faa4SMike Galbraith 20475091faa4SMike Galbraith extern void sched_autogroup_create_attach(struct task_struct *p); 20485091faa4SMike Galbraith extern void sched_autogroup_detach(struct task_struct *p); 20495091faa4SMike Galbraith extern void sched_autogroup_fork(struct signal_struct *sig); 20505091faa4SMike Galbraith extern void sched_autogroup_exit(struct signal_struct *sig); 20515091faa4SMike Galbraith #ifdef CONFIG_PROC_FS 20525091faa4SMike Galbraith extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m); 20532e5b5b3aSHiroshi Shimamoto extern int proc_sched_autogroup_set_nice(struct task_struct *p, int nice); 20545091faa4SMike Galbraith #endif 20555091faa4SMike Galbraith #else 20565091faa4SMike Galbraith static inline void sched_autogroup_create_attach(struct task_struct *p) { } 20575091faa4SMike Galbraith static inline void sched_autogroup_detach(struct task_struct *p) { } 20585091faa4SMike Galbraith static inline void sched_autogroup_fork(struct signal_struct *sig) { } 20595091faa4SMike Galbraith static inline void sched_autogroup_exit(struct signal_struct *sig) { } 20605091faa4SMike Galbraith #endif 20615091faa4SMike Galbraith 2062ec12cb7fSPaul Turner #ifdef CONFIG_CFS_BANDWIDTH 2063ec12cb7fSPaul Turner extern unsigned int sysctl_sched_cfs_bandwidth_slice; 2064ec12cb7fSPaul Turner #endif 2065ec12cb7fSPaul Turner 2066b29739f9SIngo Molnar #ifdef CONFIG_RT_MUTEXES 206736c8b586SIngo Molnar extern int rt_mutex_getprio(struct task_struct *p); 206836c8b586SIngo Molnar extern void rt_mutex_setprio(struct task_struct *p, int prio); 206936c8b586SIngo Molnar extern void rt_mutex_adjust_pi(struct task_struct *p); 20703c7d5184SThomas Gleixner static inline bool tsk_is_pi_blocked(struct task_struct *tsk) 20713c7d5184SThomas Gleixner { 20723c7d5184SThomas Gleixner return tsk->pi_blocked_on != NULL; 20733c7d5184SThomas Gleixner } 2074b29739f9SIngo Molnar #else 2075e868171aSAlexey Dobriyan static inline int rt_mutex_getprio(struct task_struct *p) 2076b29739f9SIngo Molnar { 2077b29739f9SIngo Molnar return p->normal_prio; 2078b29739f9SIngo Molnar } 207995e02ca9SThomas Gleixner # define rt_mutex_adjust_pi(p) do { } while (0) 20803c7d5184SThomas Gleixner static inline bool tsk_is_pi_blocked(struct task_struct *tsk) 20813c7d5184SThomas Gleixner { 20823c7d5184SThomas Gleixner return false; 20833c7d5184SThomas Gleixner } 2084b29739f9SIngo Molnar #endif 2085b29739f9SIngo Molnar 2086d95f4122SMike Galbraith extern bool yield_to(struct task_struct *p, bool preempt); 208736c8b586SIngo Molnar extern void set_user_nice(struct task_struct *p, long nice); 208836c8b586SIngo Molnar extern int task_prio(const struct task_struct *p); 208936c8b586SIngo Molnar extern int task_nice(const struct task_struct *p); 209036c8b586SIngo Molnar extern int can_nice(const struct task_struct *p, const int nice); 209136c8b586SIngo Molnar extern int task_curr(const struct task_struct *p); 20921da177e4SLinus Torvalds extern int idle_cpu(int cpu); 2093fe7de49fSKOSAKI Motohiro extern int sched_setscheduler(struct task_struct *, int, 2094fe7de49fSKOSAKI Motohiro const struct sched_param *); 2095961ccdddSRusty Russell extern int sched_setscheduler_nocheck(struct task_struct *, int, 2096fe7de49fSKOSAKI Motohiro const struct sched_param *); 209736c8b586SIngo Molnar extern struct task_struct *idle_task(int cpu); 2098c4f30608SPaul E. McKenney /** 2099c4f30608SPaul E. McKenney * is_idle_task - is the specified task an idle task? 2100fa757281SRandy Dunlap * @p: the task in question. 2101c4f30608SPaul E. McKenney */ 21027061ca3bSPaul E. McKenney static inline bool is_idle_task(const struct task_struct *p) 2103c4f30608SPaul E. McKenney { 2104c4f30608SPaul E. McKenney return p->pid == 0; 2105c4f30608SPaul E. McKenney } 210636c8b586SIngo Molnar extern struct task_struct *curr_task(int cpu); 210736c8b586SIngo Molnar extern void set_curr_task(int cpu, struct task_struct *p); 21081da177e4SLinus Torvalds 21091da177e4SLinus Torvalds void yield(void); 21101da177e4SLinus Torvalds 21111da177e4SLinus Torvalds /* 21121da177e4SLinus Torvalds * The default (Linux) execution domain. 21131da177e4SLinus Torvalds */ 21141da177e4SLinus Torvalds extern struct exec_domain default_exec_domain; 21151da177e4SLinus Torvalds 21161da177e4SLinus Torvalds union thread_union { 21171da177e4SLinus Torvalds struct thread_info thread_info; 21181da177e4SLinus Torvalds unsigned long stack[THREAD_SIZE/sizeof(long)]; 21191da177e4SLinus Torvalds }; 21201da177e4SLinus Torvalds 21211da177e4SLinus Torvalds #ifndef __HAVE_ARCH_KSTACK_END 21221da177e4SLinus Torvalds static inline int kstack_end(void *addr) 21231da177e4SLinus Torvalds { 21241da177e4SLinus Torvalds /* Reliable end of stack detection: 21251da177e4SLinus Torvalds * Some APM bios versions misalign the stack 21261da177e4SLinus Torvalds */ 21271da177e4SLinus Torvalds return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*))); 21281da177e4SLinus Torvalds } 21291da177e4SLinus Torvalds #endif 21301da177e4SLinus Torvalds 21311da177e4SLinus Torvalds extern union thread_union init_thread_union; 21321da177e4SLinus Torvalds extern struct task_struct init_task; 21331da177e4SLinus Torvalds 21341da177e4SLinus Torvalds extern struct mm_struct init_mm; 21351da177e4SLinus Torvalds 2136198fe21bSPavel Emelyanov extern struct pid_namespace init_pid_ns; 2137198fe21bSPavel Emelyanov 2138198fe21bSPavel Emelyanov /* 2139198fe21bSPavel Emelyanov * find a task by one of its numerical ids 2140198fe21bSPavel Emelyanov * 2141198fe21bSPavel Emelyanov * find_task_by_pid_ns(): 2142198fe21bSPavel Emelyanov * finds a task by its pid in the specified namespace 2143228ebcbeSPavel Emelyanov * find_task_by_vpid(): 2144228ebcbeSPavel Emelyanov * finds a task by its virtual pid 2145198fe21bSPavel Emelyanov * 2146e49859e7SPavel Emelyanov * see also find_vpid() etc in include/linux/pid.h 2147198fe21bSPavel Emelyanov */ 2148198fe21bSPavel Emelyanov 2149228ebcbeSPavel Emelyanov extern struct task_struct *find_task_by_vpid(pid_t nr); 2150228ebcbeSPavel Emelyanov extern struct task_struct *find_task_by_pid_ns(pid_t nr, 2151228ebcbeSPavel Emelyanov struct pid_namespace *ns); 2152198fe21bSPavel Emelyanov 21538520d7c7SOleg Nesterov extern void __set_special_pids(struct pid *pid); 21541da177e4SLinus Torvalds 21551da177e4SLinus Torvalds /* per-UID process charging. */ 21567b44ab97SEric W. Biederman extern struct user_struct * alloc_uid(kuid_t); 21571da177e4SLinus Torvalds static inline struct user_struct *get_uid(struct user_struct *u) 21581da177e4SLinus Torvalds { 21591da177e4SLinus Torvalds atomic_inc(&u->__count); 21601da177e4SLinus Torvalds return u; 21611da177e4SLinus Torvalds } 21621da177e4SLinus Torvalds extern void free_uid(struct user_struct *); 21631da177e4SLinus Torvalds 21641da177e4SLinus Torvalds #include <asm/current.h> 21651da177e4SLinus Torvalds 2166f0af911aSTorben Hohn extern void xtime_update(unsigned long ticks); 21671da177e4SLinus Torvalds 2168b3c97528SHarvey Harrison extern int wake_up_state(struct task_struct *tsk, unsigned int state); 2169b3c97528SHarvey Harrison extern int wake_up_process(struct task_struct *tsk); 21703e51e3edSSamir Bellabes extern void wake_up_new_task(struct task_struct *tsk); 21711da177e4SLinus Torvalds #ifdef CONFIG_SMP 21721da177e4SLinus Torvalds extern void kick_process(struct task_struct *tsk); 21731da177e4SLinus Torvalds #else 21741da177e4SLinus Torvalds static inline void kick_process(struct task_struct *tsk) { } 21751da177e4SLinus Torvalds #endif 21763e51e3edSSamir Bellabes extern void sched_fork(struct task_struct *p); 2177ad46c2c4SIngo Molnar extern void sched_dead(struct task_struct *p); 21781da177e4SLinus Torvalds 21791da177e4SLinus Torvalds extern void proc_caches_init(void); 21801da177e4SLinus Torvalds extern void flush_signals(struct task_struct *); 21813bcac026SDavid Howells extern void __flush_signals(struct task_struct *); 218210ab825bSOleg Nesterov extern void ignore_signals(struct task_struct *); 21831da177e4SLinus Torvalds extern void flush_signal_handlers(struct task_struct *, int force_default); 21841da177e4SLinus Torvalds extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info); 21851da177e4SLinus Torvalds 21861da177e4SLinus Torvalds static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info) 21871da177e4SLinus Torvalds { 21881da177e4SLinus Torvalds unsigned long flags; 21891da177e4SLinus Torvalds int ret; 21901da177e4SLinus Torvalds 21911da177e4SLinus Torvalds spin_lock_irqsave(&tsk->sighand->siglock, flags); 21921da177e4SLinus Torvalds ret = dequeue_signal(tsk, mask, info); 21931da177e4SLinus Torvalds spin_unlock_irqrestore(&tsk->sighand->siglock, flags); 21941da177e4SLinus Torvalds 21951da177e4SLinus Torvalds return ret; 21961da177e4SLinus Torvalds } 21971da177e4SLinus Torvalds 21981da177e4SLinus Torvalds extern void block_all_signals(int (*notifier)(void *priv), void *priv, 21991da177e4SLinus Torvalds sigset_t *mask); 22001da177e4SLinus Torvalds extern void unblock_all_signals(void); 22011da177e4SLinus Torvalds extern void release_task(struct task_struct * p); 22021da177e4SLinus Torvalds extern int send_sig_info(int, struct siginfo *, struct task_struct *); 22031da177e4SLinus Torvalds extern int force_sigsegv(int, struct task_struct *); 22041da177e4SLinus Torvalds extern int force_sig_info(int, struct siginfo *, struct task_struct *); 2205c4b92fc1SEric W. Biederman extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp); 2206c4b92fc1SEric W. Biederman extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid); 2207d178bc3aSSerge Hallyn extern int kill_pid_info_as_cred(int, struct siginfo *, struct pid *, 2208d178bc3aSSerge Hallyn const struct cred *, u32); 2209c4b92fc1SEric W. Biederman extern int kill_pgrp(struct pid *pid, int sig, int priv); 2210c4b92fc1SEric W. Biederman extern int kill_pid(struct pid *pid, int sig, int priv); 2211c3de4b38SMatthew Wilcox extern int kill_proc_info(int, struct siginfo *, pid_t); 221286773473SOleg Nesterov extern __must_check bool do_notify_parent(struct task_struct *, int); 2213a7f0765eSOleg Nesterov extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent); 22141da177e4SLinus Torvalds extern void force_sig(int, struct task_struct *); 22151da177e4SLinus Torvalds extern int send_sig(int, struct task_struct *, int); 221609faef11SOleg Nesterov extern int zap_other_threads(struct task_struct *p); 22171da177e4SLinus Torvalds extern struct sigqueue *sigqueue_alloc(void); 22181da177e4SLinus Torvalds extern void sigqueue_free(struct sigqueue *); 2219ac5c2153SOleg Nesterov extern int send_sigqueue(struct sigqueue *, struct task_struct *, int group); 22209ac95f2fSOleg Nesterov extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *); 22211da177e4SLinus Torvalds extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long); 22221da177e4SLinus Torvalds 222351a7b448SAl Viro static inline void restore_saved_sigmask(void) 222451a7b448SAl Viro { 222551a7b448SAl Viro if (test_and_clear_restore_sigmask()) 222677097ae5SAl Viro __set_current_blocked(¤t->saved_sigmask); 222751a7b448SAl Viro } 222851a7b448SAl Viro 2229b7f9a11aSAl Viro static inline sigset_t *sigmask_to_save(void) 2230b7f9a11aSAl Viro { 2231b7f9a11aSAl Viro sigset_t *res = ¤t->blocked; 2232b7f9a11aSAl Viro if (unlikely(test_restore_sigmask())) 2233b7f9a11aSAl Viro res = ¤t->saved_sigmask; 2234b7f9a11aSAl Viro return res; 2235b7f9a11aSAl Viro } 2236b7f9a11aSAl Viro 22379ec52099SCedric Le Goater static inline int kill_cad_pid(int sig, int priv) 22389ec52099SCedric Le Goater { 22399ec52099SCedric Le Goater return kill_pid(cad_pid, sig, priv); 22409ec52099SCedric Le Goater } 22419ec52099SCedric Le Goater 22421da177e4SLinus Torvalds /* These can be the second arg to send_sig_info/send_group_sig_info. */ 22431da177e4SLinus Torvalds #define SEND_SIG_NOINFO ((struct siginfo *) 0) 22441da177e4SLinus Torvalds #define SEND_SIG_PRIV ((struct siginfo *) 1) 22451da177e4SLinus Torvalds #define SEND_SIG_FORCED ((struct siginfo *) 2) 22461da177e4SLinus Torvalds 22472a855dd0SSebastian Andrzej Siewior /* 22482a855dd0SSebastian Andrzej Siewior * True if we are on the alternate signal stack. 22492a855dd0SSebastian Andrzej Siewior */ 22501da177e4SLinus Torvalds static inline int on_sig_stack(unsigned long sp) 22511da177e4SLinus Torvalds { 22522a855dd0SSebastian Andrzej Siewior #ifdef CONFIG_STACK_GROWSUP 22532a855dd0SSebastian Andrzej Siewior return sp >= current->sas_ss_sp && 22542a855dd0SSebastian Andrzej Siewior sp - current->sas_ss_sp < current->sas_ss_size; 22552a855dd0SSebastian Andrzej Siewior #else 22562a855dd0SSebastian Andrzej Siewior return sp > current->sas_ss_sp && 22572a855dd0SSebastian Andrzej Siewior sp - current->sas_ss_sp <= current->sas_ss_size; 22582a855dd0SSebastian Andrzej Siewior #endif 22591da177e4SLinus Torvalds } 22601da177e4SLinus Torvalds 22611da177e4SLinus Torvalds static inline int sas_ss_flags(unsigned long sp) 22621da177e4SLinus Torvalds { 22631da177e4SLinus Torvalds return (current->sas_ss_size == 0 ? SS_DISABLE 22641da177e4SLinus Torvalds : on_sig_stack(sp) ? SS_ONSTACK : 0); 22651da177e4SLinus Torvalds } 22661da177e4SLinus Torvalds 22671da177e4SLinus Torvalds /* 22681da177e4SLinus Torvalds * Routines for handling mm_structs 22691da177e4SLinus Torvalds */ 22701da177e4SLinus Torvalds extern struct mm_struct * mm_alloc(void); 22711da177e4SLinus Torvalds 22721da177e4SLinus Torvalds /* mmdrop drops the mm and the page tables */ 2273b3c97528SHarvey Harrison extern void __mmdrop(struct mm_struct *); 22741da177e4SLinus Torvalds static inline void mmdrop(struct mm_struct * mm) 22751da177e4SLinus Torvalds { 22766fb43d7bSIngo Molnar if (unlikely(atomic_dec_and_test(&mm->mm_count))) 22771da177e4SLinus Torvalds __mmdrop(mm); 22781da177e4SLinus Torvalds } 22791da177e4SLinus Torvalds 22801da177e4SLinus Torvalds /* mmput gets rid of the mappings and all user-space */ 22811da177e4SLinus Torvalds extern void mmput(struct mm_struct *); 22821da177e4SLinus Torvalds /* Grab a reference to a task's mm, if it is not already going away */ 22831da177e4SLinus Torvalds extern struct mm_struct *get_task_mm(struct task_struct *task); 22848cdb878dSChristopher Yeoh /* 22858cdb878dSChristopher Yeoh * Grab a reference to a task's mm, if it is not already going away 22868cdb878dSChristopher Yeoh * and ptrace_may_access with the mode parameter passed to it 22878cdb878dSChristopher Yeoh * succeeds. 22888cdb878dSChristopher Yeoh */ 22898cdb878dSChristopher Yeoh extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode); 22901da177e4SLinus Torvalds /* Remove the current tasks stale references to the old mm_struct */ 22911da177e4SLinus Torvalds extern void mm_release(struct task_struct *, struct mm_struct *); 2292402b0862SCarsten Otte /* Allocate a new mm structure and copy contents from tsk->mm */ 2293402b0862SCarsten Otte extern struct mm_struct *dup_mm(struct task_struct *tsk); 22941da177e4SLinus Torvalds 22956f2c55b8SAlexey Dobriyan extern int copy_thread(unsigned long, unsigned long, unsigned long, 22966f2c55b8SAlexey Dobriyan struct task_struct *, struct pt_regs *); 22971da177e4SLinus Torvalds extern void flush_thread(void); 22981da177e4SLinus Torvalds extern void exit_thread(void); 22991da177e4SLinus Torvalds 23001da177e4SLinus Torvalds extern void exit_files(struct task_struct *); 2301a7e5328aSOleg Nesterov extern void __cleanup_sighand(struct sighand_struct *); 2302cbaffba1SOleg Nesterov 23031da177e4SLinus Torvalds extern void exit_itimers(struct signal_struct *); 2304cbaffba1SOleg Nesterov extern void flush_itimer_signals(void); 23051da177e4SLinus Torvalds 23069402c95fSJoe Perches extern void do_group_exit(int); 23071da177e4SLinus Torvalds 23081da177e4SLinus Torvalds extern void daemonize(const char *, ...); 23091da177e4SLinus Torvalds extern int allow_signal(int); 23101da177e4SLinus Torvalds extern int disallow_signal(int); 23111da177e4SLinus Torvalds 2312d7627467SDavid Howells extern int do_execve(const char *, 2313d7627467SDavid Howells const char __user * const __user *, 2314d7627467SDavid Howells const char __user * const __user *, struct pt_regs *); 23151da177e4SLinus Torvalds extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *); 231636c8b586SIngo Molnar struct task_struct *fork_idle(int); 23171da177e4SLinus Torvalds 23181da177e4SLinus Torvalds extern void set_task_comm(struct task_struct *tsk, char *from); 231959714d65SAndrew Morton extern char *get_task_comm(char *to, struct task_struct *tsk); 23201da177e4SLinus Torvalds 23211da177e4SLinus Torvalds #ifdef CONFIG_SMP 2322317f3941SPeter Zijlstra void scheduler_ipi(void); 232385ba2d86SRoland McGrath extern unsigned long wait_task_inactive(struct task_struct *, long match_state); 23241da177e4SLinus Torvalds #else 2325184748ccSPeter Zijlstra static inline void scheduler_ipi(void) { } 232685ba2d86SRoland McGrath static inline unsigned long wait_task_inactive(struct task_struct *p, 232785ba2d86SRoland McGrath long match_state) 232885ba2d86SRoland McGrath { 232985ba2d86SRoland McGrath return 1; 233085ba2d86SRoland McGrath } 23311da177e4SLinus Torvalds #endif 23321da177e4SLinus Torvalds 233305725f7eSJiri Pirko #define next_task(p) \ 233405725f7eSJiri Pirko list_entry_rcu((p)->tasks.next, struct task_struct, tasks) 23351da177e4SLinus Torvalds 23361da177e4SLinus Torvalds #define for_each_process(p) \ 23371da177e4SLinus Torvalds for (p = &init_task ; (p = next_task(p)) != &init_task ; ) 23381da177e4SLinus Torvalds 23395bb459bbSOleg Nesterov extern bool current_is_single_threaded(void); 2340d84f4f99SDavid Howells 23411da177e4SLinus Torvalds /* 23421da177e4SLinus Torvalds * Careful: do_each_thread/while_each_thread is a double loop so 23431da177e4SLinus Torvalds * 'break' will not work as expected - use goto instead. 23441da177e4SLinus Torvalds */ 23451da177e4SLinus Torvalds #define do_each_thread(g, t) \ 23461da177e4SLinus Torvalds for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do 23471da177e4SLinus Torvalds 23481da177e4SLinus Torvalds #define while_each_thread(g, t) \ 23491da177e4SLinus Torvalds while ((t = next_thread(t)) != g) 23501da177e4SLinus Torvalds 23517e49827cSOleg Nesterov static inline int get_nr_threads(struct task_struct *tsk) 23527e49827cSOleg Nesterov { 2353b3ac022cSOleg Nesterov return tsk->signal->nr_threads; 23547e49827cSOleg Nesterov } 23557e49827cSOleg Nesterov 2356087806b1SOleg Nesterov static inline bool thread_group_leader(struct task_struct *p) 2357087806b1SOleg Nesterov { 2358087806b1SOleg Nesterov return p->exit_signal >= 0; 2359087806b1SOleg Nesterov } 23601da177e4SLinus Torvalds 23610804ef4bSEric W. Biederman /* Do to the insanities of de_thread it is possible for a process 23620804ef4bSEric W. Biederman * to have the pid of the thread group leader without actually being 23630804ef4bSEric W. Biederman * the thread group leader. For iteration through the pids in proc 23640804ef4bSEric W. Biederman * all we care about is that we have a task with the appropriate 23650804ef4bSEric W. Biederman * pid, we don't actually care if we have the right task. 23660804ef4bSEric W. Biederman */ 2367e868171aSAlexey Dobriyan static inline int has_group_leader_pid(struct task_struct *p) 23680804ef4bSEric W. Biederman { 23690804ef4bSEric W. Biederman return p->pid == p->tgid; 23700804ef4bSEric W. Biederman } 23710804ef4bSEric W. Biederman 2372bac0abd6SPavel Emelyanov static inline 2373bac0abd6SPavel Emelyanov int same_thread_group(struct task_struct *p1, struct task_struct *p2) 2374bac0abd6SPavel Emelyanov { 2375bac0abd6SPavel Emelyanov return p1->tgid == p2->tgid; 2376bac0abd6SPavel Emelyanov } 2377bac0abd6SPavel Emelyanov 237836c8b586SIngo Molnar static inline struct task_struct *next_thread(const struct task_struct *p) 237947e65328SOleg Nesterov { 238005725f7eSJiri Pirko return list_entry_rcu(p->thread_group.next, 238136c8b586SIngo Molnar struct task_struct, thread_group); 238247e65328SOleg Nesterov } 238347e65328SOleg Nesterov 2384e868171aSAlexey Dobriyan static inline int thread_group_empty(struct task_struct *p) 23851da177e4SLinus Torvalds { 238647e65328SOleg Nesterov return list_empty(&p->thread_group); 23871da177e4SLinus Torvalds } 23881da177e4SLinus Torvalds 23891da177e4SLinus Torvalds #define delay_group_leader(p) \ 23901da177e4SLinus Torvalds (thread_group_leader(p) && !thread_group_empty(p)) 23911da177e4SLinus Torvalds 23921da177e4SLinus Torvalds /* 2393260ea101SEric W. Biederman * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring 239422e2c507SJens Axboe * subscriptions and synchronises with wait4(). Also used in procfs. Also 2395ddbcc7e8SPaul Menage * pins the final release of task.io_context. Also protects ->cpuset and 2396d68b46feSOleg Nesterov * ->cgroup.subsys[]. And ->vfork_done. 23971da177e4SLinus Torvalds * 23981da177e4SLinus Torvalds * Nests both inside and outside of read_lock(&tasklist_lock). 23991da177e4SLinus Torvalds * It must not be nested with write_lock_irq(&tasklist_lock), 24001da177e4SLinus Torvalds * neither inside nor outside. 24011da177e4SLinus Torvalds */ 24021da177e4SLinus Torvalds static inline void task_lock(struct task_struct *p) 24031da177e4SLinus Torvalds { 24041da177e4SLinus Torvalds spin_lock(&p->alloc_lock); 24051da177e4SLinus Torvalds } 24061da177e4SLinus Torvalds 24071da177e4SLinus Torvalds static inline void task_unlock(struct task_struct *p) 24081da177e4SLinus Torvalds { 24091da177e4SLinus Torvalds spin_unlock(&p->alloc_lock); 24101da177e4SLinus Torvalds } 24111da177e4SLinus Torvalds 2412b8ed374eSNamhyung Kim extern struct sighand_struct *__lock_task_sighand(struct task_struct *tsk, 2413f63ee72eSOleg Nesterov unsigned long *flags); 2414f63ee72eSOleg Nesterov 24159388dc30SAnton Vorontsov static inline struct sighand_struct *lock_task_sighand(struct task_struct *tsk, 24169388dc30SAnton Vorontsov unsigned long *flags) 24179388dc30SAnton Vorontsov { 24189388dc30SAnton Vorontsov struct sighand_struct *ret; 24199388dc30SAnton Vorontsov 24209388dc30SAnton Vorontsov ret = __lock_task_sighand(tsk, flags); 24219388dc30SAnton Vorontsov (void)__cond_lock(&tsk->sighand->siglock, ret); 24229388dc30SAnton Vorontsov return ret; 24239388dc30SAnton Vorontsov } 2424b8ed374eSNamhyung Kim 2425f63ee72eSOleg Nesterov static inline void unlock_task_sighand(struct task_struct *tsk, 2426f63ee72eSOleg Nesterov unsigned long *flags) 2427f63ee72eSOleg Nesterov { 2428f63ee72eSOleg Nesterov spin_unlock_irqrestore(&tsk->sighand->siglock, *flags); 2429f63ee72eSOleg Nesterov } 2430f63ee72eSOleg Nesterov 24314714d1d3SBen Blum #ifdef CONFIG_CGROUPS 2432257058aeSTejun Heo static inline void threadgroup_change_begin(struct task_struct *tsk) 24334714d1d3SBen Blum { 2434257058aeSTejun Heo down_read(&tsk->signal->group_rwsem); 24354714d1d3SBen Blum } 2436257058aeSTejun Heo static inline void threadgroup_change_end(struct task_struct *tsk) 24374714d1d3SBen Blum { 2438257058aeSTejun Heo up_read(&tsk->signal->group_rwsem); 24394714d1d3SBen Blum } 244077e4ef99STejun Heo 244177e4ef99STejun Heo /** 244277e4ef99STejun Heo * threadgroup_lock - lock threadgroup 244377e4ef99STejun Heo * @tsk: member task of the threadgroup to lock 244477e4ef99STejun Heo * 244577e4ef99STejun Heo * Lock the threadgroup @tsk belongs to. No new task is allowed to enter 244677e4ef99STejun Heo * and member tasks aren't allowed to exit (as indicated by PF_EXITING) or 244777e4ef99STejun Heo * perform exec. This is useful for cases where the threadgroup needs to 244877e4ef99STejun Heo * stay stable across blockable operations. 244977e4ef99STejun Heo * 245077e4ef99STejun Heo * fork and exit paths explicitly call threadgroup_change_{begin|end}() for 245177e4ef99STejun Heo * synchronization. While held, no new task will be added to threadgroup 245277e4ef99STejun Heo * and no existing live task will have its PF_EXITING set. 245377e4ef99STejun Heo * 245477e4ef99STejun Heo * During exec, a task goes and puts its thread group through unusual 245577e4ef99STejun Heo * changes. After de-threading, exclusive access is assumed to resources 245677e4ef99STejun Heo * which are usually shared by tasks in the same group - e.g. sighand may 245777e4ef99STejun Heo * be replaced with a new one. Also, the exec'ing task takes over group 245877e4ef99STejun Heo * leader role including its pid. Exclude these changes while locked by 245977e4ef99STejun Heo * grabbing cred_guard_mutex which is used to synchronize exec path. 246077e4ef99STejun Heo */ 2461257058aeSTejun Heo static inline void threadgroup_lock(struct task_struct *tsk) 24624714d1d3SBen Blum { 246377e4ef99STejun Heo /* 246477e4ef99STejun Heo * exec uses exit for de-threading nesting group_rwsem inside 246577e4ef99STejun Heo * cred_guard_mutex. Grab cred_guard_mutex first. 246677e4ef99STejun Heo */ 246777e4ef99STejun Heo mutex_lock(&tsk->signal->cred_guard_mutex); 2468257058aeSTejun Heo down_write(&tsk->signal->group_rwsem); 24694714d1d3SBen Blum } 247077e4ef99STejun Heo 247177e4ef99STejun Heo /** 247277e4ef99STejun Heo * threadgroup_unlock - unlock threadgroup 247377e4ef99STejun Heo * @tsk: member task of the threadgroup to unlock 247477e4ef99STejun Heo * 247577e4ef99STejun Heo * Reverse threadgroup_lock(). 247677e4ef99STejun Heo */ 2477257058aeSTejun Heo static inline void threadgroup_unlock(struct task_struct *tsk) 24784714d1d3SBen Blum { 2479257058aeSTejun Heo up_write(&tsk->signal->group_rwsem); 248077e4ef99STejun Heo mutex_unlock(&tsk->signal->cred_guard_mutex); 24814714d1d3SBen Blum } 24824714d1d3SBen Blum #else 2483257058aeSTejun Heo static inline void threadgroup_change_begin(struct task_struct *tsk) {} 2484257058aeSTejun Heo static inline void threadgroup_change_end(struct task_struct *tsk) {} 2485257058aeSTejun Heo static inline void threadgroup_lock(struct task_struct *tsk) {} 2486257058aeSTejun Heo static inline void threadgroup_unlock(struct task_struct *tsk) {} 24874714d1d3SBen Blum #endif 24884714d1d3SBen Blum 2489f037360fSAl Viro #ifndef __HAVE_THREAD_FUNCTIONS 2490f037360fSAl Viro 2491f7e4217bSRoman Zippel #define task_thread_info(task) ((struct thread_info *)(task)->stack) 2492f7e4217bSRoman Zippel #define task_stack_page(task) ((task)->stack) 2493a1261f54SAl Viro 249410ebffdeSAl Viro static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org) 249510ebffdeSAl Viro { 249610ebffdeSAl Viro *task_thread_info(p) = *task_thread_info(org); 249710ebffdeSAl Viro task_thread_info(p)->task = p; 249810ebffdeSAl Viro } 249910ebffdeSAl Viro 250010ebffdeSAl Viro static inline unsigned long *end_of_stack(struct task_struct *p) 250110ebffdeSAl Viro { 2502f7e4217bSRoman Zippel return (unsigned long *)(task_thread_info(p) + 1); 250310ebffdeSAl Viro } 250410ebffdeSAl Viro 2505f037360fSAl Viro #endif 2506f037360fSAl Viro 25078b05c7e6SFUJITA Tomonori static inline int object_is_on_stack(void *obj) 25088b05c7e6SFUJITA Tomonori { 25098b05c7e6SFUJITA Tomonori void *stack = task_stack_page(current); 25108b05c7e6SFUJITA Tomonori 25118b05c7e6SFUJITA Tomonori return (obj >= stack) && (obj < (stack + THREAD_SIZE)); 25128b05c7e6SFUJITA Tomonori } 25138b05c7e6SFUJITA Tomonori 25148c9843e5SBenjamin Herrenschmidt extern void thread_info_cache_init(void); 25158c9843e5SBenjamin Herrenschmidt 25167c9f8861SEric Sandeen #ifdef CONFIG_DEBUG_STACK_USAGE 25177c9f8861SEric Sandeen static inline unsigned long stack_not_used(struct task_struct *p) 25187c9f8861SEric Sandeen { 25197c9f8861SEric Sandeen unsigned long *n = end_of_stack(p); 25207c9f8861SEric Sandeen 25217c9f8861SEric Sandeen do { /* Skip over canary */ 25227c9f8861SEric Sandeen n++; 25237c9f8861SEric Sandeen } while (!*n); 25247c9f8861SEric Sandeen 25257c9f8861SEric Sandeen return (unsigned long)n - (unsigned long)end_of_stack(p); 25267c9f8861SEric Sandeen } 25277c9f8861SEric Sandeen #endif 25287c9f8861SEric Sandeen 25291da177e4SLinus Torvalds /* set thread flags in other task's structures 25301da177e4SLinus Torvalds * - see asm/thread_info.h for TIF_xxxx flags available 25311da177e4SLinus Torvalds */ 25321da177e4SLinus Torvalds static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag) 25331da177e4SLinus Torvalds { 2534a1261f54SAl Viro set_ti_thread_flag(task_thread_info(tsk), flag); 25351da177e4SLinus Torvalds } 25361da177e4SLinus Torvalds 25371da177e4SLinus Torvalds static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag) 25381da177e4SLinus Torvalds { 2539a1261f54SAl Viro clear_ti_thread_flag(task_thread_info(tsk), flag); 25401da177e4SLinus Torvalds } 25411da177e4SLinus Torvalds 25421da177e4SLinus Torvalds static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag) 25431da177e4SLinus Torvalds { 2544a1261f54SAl Viro return test_and_set_ti_thread_flag(task_thread_info(tsk), flag); 25451da177e4SLinus Torvalds } 25461da177e4SLinus Torvalds 25471da177e4SLinus Torvalds static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag) 25481da177e4SLinus Torvalds { 2549a1261f54SAl Viro return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag); 25501da177e4SLinus Torvalds } 25511da177e4SLinus Torvalds 25521da177e4SLinus Torvalds static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag) 25531da177e4SLinus Torvalds { 2554a1261f54SAl Viro return test_ti_thread_flag(task_thread_info(tsk), flag); 25551da177e4SLinus Torvalds } 25561da177e4SLinus Torvalds 25571da177e4SLinus Torvalds static inline void set_tsk_need_resched(struct task_struct *tsk) 25581da177e4SLinus Torvalds { 25591da177e4SLinus Torvalds set_tsk_thread_flag(tsk,TIF_NEED_RESCHED); 25601da177e4SLinus Torvalds } 25611da177e4SLinus Torvalds 25621da177e4SLinus Torvalds static inline void clear_tsk_need_resched(struct task_struct *tsk) 25631da177e4SLinus Torvalds { 25641da177e4SLinus Torvalds clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED); 25651da177e4SLinus Torvalds } 25661da177e4SLinus Torvalds 25678ae121acSGregory Haskins static inline int test_tsk_need_resched(struct task_struct *tsk) 25688ae121acSGregory Haskins { 25698ae121acSGregory Haskins return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED)); 25708ae121acSGregory Haskins } 25718ae121acSGregory Haskins 2572690cc3ffSEric W. Biederman static inline int restart_syscall(void) 2573690cc3ffSEric W. Biederman { 2574690cc3ffSEric W. Biederman set_tsk_thread_flag(current, TIF_SIGPENDING); 2575690cc3ffSEric W. Biederman return -ERESTARTNOINTR; 2576690cc3ffSEric W. Biederman } 2577690cc3ffSEric W. Biederman 25781da177e4SLinus Torvalds static inline int signal_pending(struct task_struct *p) 25791da177e4SLinus Torvalds { 25801da177e4SLinus Torvalds return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING)); 25811da177e4SLinus Torvalds } 25821da177e4SLinus Torvalds 2583d9588725SRoland McGrath static inline int __fatal_signal_pending(struct task_struct *p) 2584d9588725SRoland McGrath { 2585d9588725SRoland McGrath return unlikely(sigismember(&p->pending.signal, SIGKILL)); 2586d9588725SRoland McGrath } 2587f776d12dSMatthew Wilcox 2588f776d12dSMatthew Wilcox static inline int fatal_signal_pending(struct task_struct *p) 2589f776d12dSMatthew Wilcox { 2590f776d12dSMatthew Wilcox return signal_pending(p) && __fatal_signal_pending(p); 2591f776d12dSMatthew Wilcox } 2592f776d12dSMatthew Wilcox 259316882c1eSOleg Nesterov static inline int signal_pending_state(long state, struct task_struct *p) 259416882c1eSOleg Nesterov { 259516882c1eSOleg Nesterov if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL))) 259616882c1eSOleg Nesterov return 0; 259716882c1eSOleg Nesterov if (!signal_pending(p)) 259816882c1eSOleg Nesterov return 0; 259916882c1eSOleg Nesterov 260016882c1eSOleg Nesterov return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p); 260116882c1eSOleg Nesterov } 260216882c1eSOleg Nesterov 26031da177e4SLinus Torvalds static inline int need_resched(void) 26041da177e4SLinus Torvalds { 26059404ef02SLinus Torvalds return unlikely(test_thread_flag(TIF_NEED_RESCHED)); 26061da177e4SLinus Torvalds } 26071da177e4SLinus Torvalds 26081da177e4SLinus Torvalds /* 26091da177e4SLinus Torvalds * cond_resched() and cond_resched_lock(): latency reduction via 26101da177e4SLinus Torvalds * explicit rescheduling in places that are safe. The return 26111da177e4SLinus Torvalds * value indicates whether a reschedule was done in fact. 26121da177e4SLinus Torvalds * cond_resched_lock() will drop the spinlock before scheduling, 26131da177e4SLinus Torvalds * cond_resched_softirq() will enable bhs before scheduling. 26141da177e4SLinus Torvalds */ 2615c3921ab7SLinus Torvalds extern int _cond_resched(void); 26166f80bd98SFrederic Weisbecker 2617613afbf8SFrederic Weisbecker #define cond_resched() ({ \ 2618613afbf8SFrederic Weisbecker __might_sleep(__FILE__, __LINE__, 0); \ 2619613afbf8SFrederic Weisbecker _cond_resched(); \ 2620613afbf8SFrederic Weisbecker }) 26216f80bd98SFrederic Weisbecker 2622613afbf8SFrederic Weisbecker extern int __cond_resched_lock(spinlock_t *lock); 2623613afbf8SFrederic Weisbecker 2624bdd4e85dSFrederic Weisbecker #ifdef CONFIG_PREEMPT_COUNT 2625716a4234SFrederic Weisbecker #define PREEMPT_LOCK_OFFSET PREEMPT_OFFSET 262602b67cc3SHerbert Xu #else 2627716a4234SFrederic Weisbecker #define PREEMPT_LOCK_OFFSET 0 262802b67cc3SHerbert Xu #endif 2629716a4234SFrederic Weisbecker 2630613afbf8SFrederic Weisbecker #define cond_resched_lock(lock) ({ \ 2631716a4234SFrederic Weisbecker __might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET); \ 2632613afbf8SFrederic Weisbecker __cond_resched_lock(lock); \ 2633613afbf8SFrederic Weisbecker }) 2634613afbf8SFrederic Weisbecker 2635613afbf8SFrederic Weisbecker extern int __cond_resched_softirq(void); 2636613afbf8SFrederic Weisbecker 2637613afbf8SFrederic Weisbecker #define cond_resched_softirq() ({ \ 263875e1056fSVenkatesh Pallipadi __might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET); \ 2639613afbf8SFrederic Weisbecker __cond_resched_softirq(); \ 2640613afbf8SFrederic Weisbecker }) 26411da177e4SLinus Torvalds 26421da177e4SLinus Torvalds /* 26431da177e4SLinus Torvalds * Does a critical section need to be broken due to another 264495c354feSNick Piggin * task waiting?: (technically does not depend on CONFIG_PREEMPT, 264595c354feSNick Piggin * but a general need for low latency) 26461da177e4SLinus Torvalds */ 264795c354feSNick Piggin static inline int spin_needbreak(spinlock_t *lock) 26481da177e4SLinus Torvalds { 264995c354feSNick Piggin #ifdef CONFIG_PREEMPT 265095c354feSNick Piggin return spin_is_contended(lock); 265195c354feSNick Piggin #else 26521da177e4SLinus Torvalds return 0; 265395c354feSNick Piggin #endif 26541da177e4SLinus Torvalds } 26551da177e4SLinus Torvalds 26567bb44adeSRoland McGrath /* 2657f06febc9SFrank Mayhar * Thread group CPU time accounting. 2658f06febc9SFrank Mayhar */ 26594cd4c1b4SPeter Zijlstra void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times); 26604da94d49SPeter Zijlstra void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times); 2661f06febc9SFrank Mayhar 2662f06febc9SFrank Mayhar static inline void thread_group_cputime_init(struct signal_struct *sig) 2663f06febc9SFrank Mayhar { 2664ee30a7b2SThomas Gleixner raw_spin_lock_init(&sig->cputimer.lock); 2665f06febc9SFrank Mayhar } 2666f06febc9SFrank Mayhar 2667f06febc9SFrank Mayhar /* 26687bb44adeSRoland McGrath * Reevaluate whether the task has signals pending delivery. 26697bb44adeSRoland McGrath * Wake the task if so. 26707bb44adeSRoland McGrath * This is required every time the blocked sigset_t changes. 26717bb44adeSRoland McGrath * callers must hold sighand->siglock. 26727bb44adeSRoland McGrath */ 26737bb44adeSRoland McGrath extern void recalc_sigpending_and_wake(struct task_struct *t); 26741da177e4SLinus Torvalds extern void recalc_sigpending(void); 26751da177e4SLinus Torvalds 26761da177e4SLinus Torvalds extern void signal_wake_up(struct task_struct *t, int resume_stopped); 26771da177e4SLinus Torvalds 26781da177e4SLinus Torvalds /* 26791da177e4SLinus Torvalds * Wrappers for p->thread_info->cpu access. No-op on UP. 26801da177e4SLinus Torvalds */ 26811da177e4SLinus Torvalds #ifdef CONFIG_SMP 26821da177e4SLinus Torvalds 26831da177e4SLinus Torvalds static inline unsigned int task_cpu(const struct task_struct *p) 26841da177e4SLinus Torvalds { 2685a1261f54SAl Viro return task_thread_info(p)->cpu; 26861da177e4SLinus Torvalds } 26871da177e4SLinus Torvalds 2688c65cc870SIngo Molnar extern void set_task_cpu(struct task_struct *p, unsigned int cpu); 26891da177e4SLinus Torvalds 26901da177e4SLinus Torvalds #else 26911da177e4SLinus Torvalds 26921da177e4SLinus Torvalds static inline unsigned int task_cpu(const struct task_struct *p) 26931da177e4SLinus Torvalds { 26941da177e4SLinus Torvalds return 0; 26951da177e4SLinus Torvalds } 26961da177e4SLinus Torvalds 26971da177e4SLinus Torvalds static inline void set_task_cpu(struct task_struct *p, unsigned int cpu) 26981da177e4SLinus Torvalds { 26991da177e4SLinus Torvalds } 27001da177e4SLinus Torvalds 27011da177e4SLinus Torvalds #endif /* CONFIG_SMP */ 27021da177e4SLinus Torvalds 270396f874e2SRusty Russell extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask); 270496f874e2SRusty Russell extern long sched_getaffinity(pid_t pid, struct cpumask *mask); 27055c45bf27SSiddha, Suresh B 27061da177e4SLinus Torvalds extern void normalize_rt_tasks(void); 27071da177e4SLinus Torvalds 27087c941438SDhaval Giani #ifdef CONFIG_CGROUP_SCHED 27099b5b7751SSrivatsa Vaddagiri 271007e06b01SYong Zhang extern struct task_group root_task_group; 27119b5b7751SSrivatsa Vaddagiri 2712ec7dc8acSDhaval Giani extern struct task_group *sched_create_group(struct task_group *parent); 27134cf86d77SIngo Molnar extern void sched_destroy_group(struct task_group *tg); 27149b5b7751SSrivatsa Vaddagiri extern void sched_move_task(struct task_struct *tsk); 2715052f1dc7SPeter Zijlstra #ifdef CONFIG_FAIR_GROUP_SCHED 27164cf86d77SIngo Molnar extern int sched_group_set_shares(struct task_group *tg, unsigned long shares); 27175cb350baSDhaval Giani extern unsigned long sched_group_shares(struct task_group *tg); 2718052f1dc7SPeter Zijlstra #endif 2719052f1dc7SPeter Zijlstra #ifdef CONFIG_RT_GROUP_SCHED 27209f0c1e56SPeter Zijlstra extern int sched_group_set_rt_runtime(struct task_group *tg, 27219f0c1e56SPeter Zijlstra long rt_runtime_us); 27229f0c1e56SPeter Zijlstra extern long sched_group_rt_runtime(struct task_group *tg); 2723d0b27fa7SPeter Zijlstra extern int sched_group_set_rt_period(struct task_group *tg, 2724d0b27fa7SPeter Zijlstra long rt_period_us); 2725d0b27fa7SPeter Zijlstra extern long sched_group_rt_period(struct task_group *tg); 272654e99124SDhaval Giani extern int sched_rt_can_attach(struct task_group *tg, struct task_struct *tsk); 2727052f1dc7SPeter Zijlstra #endif 27289b5b7751SSrivatsa Vaddagiri #endif 27299b5b7751SSrivatsa Vaddagiri 273054e99124SDhaval Giani extern int task_can_switch_user(struct user_struct *up, 273154e99124SDhaval Giani struct task_struct *tsk); 273254e99124SDhaval Giani 27334b98d11bSAlexey Dobriyan #ifdef CONFIG_TASK_XACCT 27344b98d11bSAlexey Dobriyan static inline void add_rchar(struct task_struct *tsk, ssize_t amt) 27354b98d11bSAlexey Dobriyan { 2736940389b8SAndrea Righi tsk->ioac.rchar += amt; 27374b98d11bSAlexey Dobriyan } 27384b98d11bSAlexey Dobriyan 27394b98d11bSAlexey Dobriyan static inline void add_wchar(struct task_struct *tsk, ssize_t amt) 27404b98d11bSAlexey Dobriyan { 2741940389b8SAndrea Righi tsk->ioac.wchar += amt; 27424b98d11bSAlexey Dobriyan } 27434b98d11bSAlexey Dobriyan 27444b98d11bSAlexey Dobriyan static inline void inc_syscr(struct task_struct *tsk) 27454b98d11bSAlexey Dobriyan { 2746940389b8SAndrea Righi tsk->ioac.syscr++; 27474b98d11bSAlexey Dobriyan } 27484b98d11bSAlexey Dobriyan 27494b98d11bSAlexey Dobriyan static inline void inc_syscw(struct task_struct *tsk) 27504b98d11bSAlexey Dobriyan { 2751940389b8SAndrea Righi tsk->ioac.syscw++; 27524b98d11bSAlexey Dobriyan } 27534b98d11bSAlexey Dobriyan #else 27544b98d11bSAlexey Dobriyan static inline void add_rchar(struct task_struct *tsk, ssize_t amt) 27554b98d11bSAlexey Dobriyan { 27564b98d11bSAlexey Dobriyan } 27574b98d11bSAlexey Dobriyan 27584b98d11bSAlexey Dobriyan static inline void add_wchar(struct task_struct *tsk, ssize_t amt) 27594b98d11bSAlexey Dobriyan { 27604b98d11bSAlexey Dobriyan } 27614b98d11bSAlexey Dobriyan 27624b98d11bSAlexey Dobriyan static inline void inc_syscr(struct task_struct *tsk) 27634b98d11bSAlexey Dobriyan { 27644b98d11bSAlexey Dobriyan } 27654b98d11bSAlexey Dobriyan 27664b98d11bSAlexey Dobriyan static inline void inc_syscw(struct task_struct *tsk) 27674b98d11bSAlexey Dobriyan { 27684b98d11bSAlexey Dobriyan } 27694b98d11bSAlexey Dobriyan #endif 27704b98d11bSAlexey Dobriyan 277182455257SDave Hansen #ifndef TASK_SIZE_OF 277282455257SDave Hansen #define TASK_SIZE_OF(tsk) TASK_SIZE 277382455257SDave Hansen #endif 277482455257SDave Hansen 2775cf475ad2SBalbir Singh #ifdef CONFIG_MM_OWNER 2776cf475ad2SBalbir Singh extern void mm_update_next_owner(struct mm_struct *mm); 2777cf475ad2SBalbir Singh extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p); 2778cf475ad2SBalbir Singh #else 2779cf475ad2SBalbir Singh static inline void mm_update_next_owner(struct mm_struct *mm) 2780cf475ad2SBalbir Singh { 2781cf475ad2SBalbir Singh } 2782cf475ad2SBalbir Singh 2783cf475ad2SBalbir Singh static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p) 2784cf475ad2SBalbir Singh { 2785cf475ad2SBalbir Singh } 2786cf475ad2SBalbir Singh #endif /* CONFIG_MM_OWNER */ 2787cf475ad2SBalbir Singh 27883e10e716SJiri Slaby static inline unsigned long task_rlimit(const struct task_struct *tsk, 27893e10e716SJiri Slaby unsigned int limit) 27903e10e716SJiri Slaby { 27913e10e716SJiri Slaby return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_cur); 27923e10e716SJiri Slaby } 27933e10e716SJiri Slaby 27943e10e716SJiri Slaby static inline unsigned long task_rlimit_max(const struct task_struct *tsk, 27953e10e716SJiri Slaby unsigned int limit) 27963e10e716SJiri Slaby { 27973e10e716SJiri Slaby return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_max); 27983e10e716SJiri Slaby } 27993e10e716SJiri Slaby 28003e10e716SJiri Slaby static inline unsigned long rlimit(unsigned int limit) 28013e10e716SJiri Slaby { 28023e10e716SJiri Slaby return task_rlimit(current, limit); 28033e10e716SJiri Slaby } 28043e10e716SJiri Slaby 28053e10e716SJiri Slaby static inline unsigned long rlimit_max(unsigned int limit) 28063e10e716SJiri Slaby { 28073e10e716SJiri Slaby return task_rlimit_max(current, limit); 28083e10e716SJiri Slaby } 28093e10e716SJiri Slaby 28101da177e4SLinus Torvalds #endif /* __KERNEL__ */ 28111da177e4SLinus Torvalds 28121da177e4SLinus Torvalds #endif 2813