xref: /linux/include/linux/sched.h (revision 4866cde064afbb6c2a488c265e696879de616daa)
11da177e4SLinus Torvalds #ifndef _LINUX_SCHED_H
21da177e4SLinus Torvalds #define _LINUX_SCHED_H
31da177e4SLinus Torvalds 
41da177e4SLinus Torvalds #include <asm/param.h>	/* for HZ */
51da177e4SLinus Torvalds 
61da177e4SLinus Torvalds #include <linux/config.h>
71da177e4SLinus Torvalds #include <linux/capability.h>
81da177e4SLinus Torvalds #include <linux/threads.h>
91da177e4SLinus Torvalds #include <linux/kernel.h>
101da177e4SLinus Torvalds #include <linux/types.h>
111da177e4SLinus Torvalds #include <linux/timex.h>
121da177e4SLinus Torvalds #include <linux/jiffies.h>
131da177e4SLinus Torvalds #include <linux/rbtree.h>
141da177e4SLinus Torvalds #include <linux/thread_info.h>
151da177e4SLinus Torvalds #include <linux/cpumask.h>
161da177e4SLinus Torvalds #include <linux/errno.h>
171da177e4SLinus Torvalds #include <linux/nodemask.h>
181da177e4SLinus Torvalds 
191da177e4SLinus Torvalds #include <asm/system.h>
201da177e4SLinus Torvalds #include <asm/semaphore.h>
211da177e4SLinus Torvalds #include <asm/page.h>
221da177e4SLinus Torvalds #include <asm/ptrace.h>
231da177e4SLinus Torvalds #include <asm/mmu.h>
241da177e4SLinus Torvalds #include <asm/cputime.h>
251da177e4SLinus Torvalds 
261da177e4SLinus Torvalds #include <linux/smp.h>
271da177e4SLinus Torvalds #include <linux/sem.h>
281da177e4SLinus Torvalds #include <linux/signal.h>
291da177e4SLinus Torvalds #include <linux/securebits.h>
301da177e4SLinus Torvalds #include <linux/fs_struct.h>
311da177e4SLinus Torvalds #include <linux/compiler.h>
321da177e4SLinus Torvalds #include <linux/completion.h>
331da177e4SLinus Torvalds #include <linux/pid.h>
341da177e4SLinus Torvalds #include <linux/percpu.h>
351da177e4SLinus Torvalds #include <linux/topology.h>
361da177e4SLinus Torvalds #include <linux/seccomp.h>
371da177e4SLinus Torvalds 
381da177e4SLinus Torvalds struct exec_domain;
391da177e4SLinus Torvalds 
401da177e4SLinus Torvalds /*
411da177e4SLinus Torvalds  * cloning flags:
421da177e4SLinus Torvalds  */
431da177e4SLinus Torvalds #define CSIGNAL		0x000000ff	/* signal mask to be sent at exit */
441da177e4SLinus Torvalds #define CLONE_VM	0x00000100	/* set if VM shared between processes */
451da177e4SLinus Torvalds #define CLONE_FS	0x00000200	/* set if fs info shared between processes */
461da177e4SLinus Torvalds #define CLONE_FILES	0x00000400	/* set if open files shared between processes */
471da177e4SLinus Torvalds #define CLONE_SIGHAND	0x00000800	/* set if signal handlers and blocked signals shared */
481da177e4SLinus Torvalds #define CLONE_PTRACE	0x00002000	/* set if we want to let tracing continue on the child too */
491da177e4SLinus Torvalds #define CLONE_VFORK	0x00004000	/* set if the parent wants the child to wake it up on mm_release */
501da177e4SLinus Torvalds #define CLONE_PARENT	0x00008000	/* set if we want to have the same parent as the cloner */
511da177e4SLinus Torvalds #define CLONE_THREAD	0x00010000	/* Same thread group? */
521da177e4SLinus Torvalds #define CLONE_NEWNS	0x00020000	/* New namespace group? */
531da177e4SLinus Torvalds #define CLONE_SYSVSEM	0x00040000	/* share system V SEM_UNDO semantics */
541da177e4SLinus Torvalds #define CLONE_SETTLS	0x00080000	/* create a new TLS for the child */
551da177e4SLinus Torvalds #define CLONE_PARENT_SETTID	0x00100000	/* set the TID in the parent */
561da177e4SLinus Torvalds #define CLONE_CHILD_CLEARTID	0x00200000	/* clear the TID in the child */
571da177e4SLinus Torvalds #define CLONE_DETACHED		0x00400000	/* Unused, ignored */
581da177e4SLinus Torvalds #define CLONE_UNTRACED		0x00800000	/* set if the tracing process can't force CLONE_PTRACE on this clone */
591da177e4SLinus Torvalds #define CLONE_CHILD_SETTID	0x01000000	/* set the TID in the child */
601da177e4SLinus Torvalds #define CLONE_STOPPED		0x02000000	/* Start in stopped state */
611da177e4SLinus Torvalds 
621da177e4SLinus Torvalds /*
631da177e4SLinus Torvalds  * List of flags we want to share for kernel threads,
641da177e4SLinus Torvalds  * if only because they are not used by them anyway.
651da177e4SLinus Torvalds  */
661da177e4SLinus Torvalds #define CLONE_KERNEL	(CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
671da177e4SLinus Torvalds 
681da177e4SLinus Torvalds /*
691da177e4SLinus Torvalds  * These are the constant used to fake the fixed-point load-average
701da177e4SLinus Torvalds  * counting. Some notes:
711da177e4SLinus Torvalds  *  - 11 bit fractions expand to 22 bits by the multiplies: this gives
721da177e4SLinus Torvalds  *    a load-average precision of 10 bits integer + 11 bits fractional
731da177e4SLinus Torvalds  *  - if you want to count load-averages more often, you need more
741da177e4SLinus Torvalds  *    precision, or rounding will get you. With 2-second counting freq,
751da177e4SLinus Torvalds  *    the EXP_n values would be 1981, 2034 and 2043 if still using only
761da177e4SLinus Torvalds  *    11 bit fractions.
771da177e4SLinus Torvalds  */
781da177e4SLinus Torvalds extern unsigned long avenrun[];		/* Load averages */
791da177e4SLinus Torvalds 
801da177e4SLinus Torvalds #define FSHIFT		11		/* nr of bits of precision */
811da177e4SLinus Torvalds #define FIXED_1		(1<<FSHIFT)	/* 1.0 as fixed-point */
821da177e4SLinus Torvalds #define LOAD_FREQ	(5*HZ)		/* 5 sec intervals */
831da177e4SLinus Torvalds #define EXP_1		1884		/* 1/exp(5sec/1min) as fixed-point */
841da177e4SLinus Torvalds #define EXP_5		2014		/* 1/exp(5sec/5min) */
851da177e4SLinus Torvalds #define EXP_15		2037		/* 1/exp(5sec/15min) */
861da177e4SLinus Torvalds 
871da177e4SLinus Torvalds #define CALC_LOAD(load,exp,n) \
881da177e4SLinus Torvalds 	load *= exp; \
891da177e4SLinus Torvalds 	load += n*(FIXED_1-exp); \
901da177e4SLinus Torvalds 	load >>= FSHIFT;
911da177e4SLinus Torvalds 
921da177e4SLinus Torvalds extern unsigned long total_forks;
931da177e4SLinus Torvalds extern int nr_threads;
941da177e4SLinus Torvalds extern int last_pid;
951da177e4SLinus Torvalds DECLARE_PER_CPU(unsigned long, process_counts);
961da177e4SLinus Torvalds extern int nr_processes(void);
971da177e4SLinus Torvalds extern unsigned long nr_running(void);
981da177e4SLinus Torvalds extern unsigned long nr_uninterruptible(void);
991da177e4SLinus Torvalds extern unsigned long nr_iowait(void);
1001da177e4SLinus Torvalds 
1011da177e4SLinus Torvalds #include <linux/time.h>
1021da177e4SLinus Torvalds #include <linux/param.h>
1031da177e4SLinus Torvalds #include <linux/resource.h>
1041da177e4SLinus Torvalds #include <linux/timer.h>
1051da177e4SLinus Torvalds 
1061da177e4SLinus Torvalds #include <asm/processor.h>
1071da177e4SLinus Torvalds 
1081da177e4SLinus Torvalds #define TASK_RUNNING		0
1091da177e4SLinus Torvalds #define TASK_INTERRUPTIBLE	1
1101da177e4SLinus Torvalds #define TASK_UNINTERRUPTIBLE	2
1111da177e4SLinus Torvalds #define TASK_STOPPED		4
1121da177e4SLinus Torvalds #define TASK_TRACED		8
1131da177e4SLinus Torvalds #define EXIT_ZOMBIE		16
1141da177e4SLinus Torvalds #define EXIT_DEAD		32
1151da177e4SLinus Torvalds 
1161da177e4SLinus Torvalds #define __set_task_state(tsk, state_value)		\
1171da177e4SLinus Torvalds 	do { (tsk)->state = (state_value); } while (0)
1181da177e4SLinus Torvalds #define set_task_state(tsk, state_value)		\
1191da177e4SLinus Torvalds 	set_mb((tsk)->state, (state_value))
1201da177e4SLinus Torvalds 
1211da177e4SLinus Torvalds #define __set_current_state(state_value)			\
1221da177e4SLinus Torvalds 	do { current->state = (state_value); } while (0)
1231da177e4SLinus Torvalds #define set_current_state(state_value)		\
1241da177e4SLinus Torvalds 	set_mb(current->state, (state_value))
1251da177e4SLinus Torvalds 
1261da177e4SLinus Torvalds /* Task command name length */
1271da177e4SLinus Torvalds #define TASK_COMM_LEN 16
1281da177e4SLinus Torvalds 
1291da177e4SLinus Torvalds /*
1301da177e4SLinus Torvalds  * Scheduling policies
1311da177e4SLinus Torvalds  */
1321da177e4SLinus Torvalds #define SCHED_NORMAL		0
1331da177e4SLinus Torvalds #define SCHED_FIFO		1
1341da177e4SLinus Torvalds #define SCHED_RR		2
1351da177e4SLinus Torvalds 
1361da177e4SLinus Torvalds struct sched_param {
1371da177e4SLinus Torvalds 	int sched_priority;
1381da177e4SLinus Torvalds };
1391da177e4SLinus Torvalds 
1401da177e4SLinus Torvalds #ifdef __KERNEL__
1411da177e4SLinus Torvalds 
1421da177e4SLinus Torvalds #include <linux/spinlock.h>
1431da177e4SLinus Torvalds 
1441da177e4SLinus Torvalds /*
1451da177e4SLinus Torvalds  * This serializes "schedule()" and also protects
1461da177e4SLinus Torvalds  * the run-queue from deletions/modifications (but
1471da177e4SLinus Torvalds  * _adding_ to the beginning of the run-queue has
1481da177e4SLinus Torvalds  * a separate lock).
1491da177e4SLinus Torvalds  */
1501da177e4SLinus Torvalds extern rwlock_t tasklist_lock;
1511da177e4SLinus Torvalds extern spinlock_t mmlist_lock;
1521da177e4SLinus Torvalds 
1531da177e4SLinus Torvalds typedef struct task_struct task_t;
1541da177e4SLinus Torvalds 
1551da177e4SLinus Torvalds extern void sched_init(void);
1561da177e4SLinus Torvalds extern void sched_init_smp(void);
1571da177e4SLinus Torvalds extern void init_idle(task_t *idle, int cpu);
1581da177e4SLinus Torvalds 
1591da177e4SLinus Torvalds extern cpumask_t nohz_cpu_mask;
1601da177e4SLinus Torvalds 
1611da177e4SLinus Torvalds extern void show_state(void);
1621da177e4SLinus Torvalds extern void show_regs(struct pt_regs *);
1631da177e4SLinus Torvalds 
1641da177e4SLinus Torvalds /*
1651da177e4SLinus Torvalds  * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
1661da177e4SLinus Torvalds  * task), SP is the stack pointer of the first frame that should be shown in the back
1671da177e4SLinus Torvalds  * trace (or NULL if the entire call-chain of the task should be shown).
1681da177e4SLinus Torvalds  */
1691da177e4SLinus Torvalds extern void show_stack(struct task_struct *task, unsigned long *sp);
1701da177e4SLinus Torvalds 
1711da177e4SLinus Torvalds void io_schedule(void);
1721da177e4SLinus Torvalds long io_schedule_timeout(long timeout);
1731da177e4SLinus Torvalds 
1741da177e4SLinus Torvalds extern void cpu_init (void);
1751da177e4SLinus Torvalds extern void trap_init(void);
1761da177e4SLinus Torvalds extern void update_process_times(int user);
1771da177e4SLinus Torvalds extern void scheduler_tick(void);
1781da177e4SLinus Torvalds 
1791da177e4SLinus Torvalds /* Attach to any functions which should be ignored in wchan output. */
1801da177e4SLinus Torvalds #define __sched		__attribute__((__section__(".sched.text")))
1811da177e4SLinus Torvalds /* Is this address in the __sched functions? */
1821da177e4SLinus Torvalds extern int in_sched_functions(unsigned long addr);
1831da177e4SLinus Torvalds 
1841da177e4SLinus Torvalds #define	MAX_SCHEDULE_TIMEOUT	LONG_MAX
1851da177e4SLinus Torvalds extern signed long FASTCALL(schedule_timeout(signed long timeout));
1861da177e4SLinus Torvalds asmlinkage void schedule(void);
1871da177e4SLinus Torvalds 
1881da177e4SLinus Torvalds struct namespace;
1891da177e4SLinus Torvalds 
1901da177e4SLinus Torvalds /* Maximum number of active map areas.. This is a random (large) number */
1911da177e4SLinus Torvalds #define DEFAULT_MAX_MAP_COUNT	65536
1921da177e4SLinus Torvalds 
1931da177e4SLinus Torvalds extern int sysctl_max_map_count;
1941da177e4SLinus Torvalds 
1951da177e4SLinus Torvalds #include <linux/aio.h>
1961da177e4SLinus Torvalds 
1971da177e4SLinus Torvalds extern unsigned long
1981da177e4SLinus Torvalds arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
1991da177e4SLinus Torvalds 		       unsigned long, unsigned long);
2001da177e4SLinus Torvalds extern unsigned long
2011da177e4SLinus Torvalds arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
2021da177e4SLinus Torvalds 			  unsigned long len, unsigned long pgoff,
2031da177e4SLinus Torvalds 			  unsigned long flags);
2041363c3cdSWolfgang Wander extern void arch_unmap_area(struct mm_struct *, unsigned long);
2051363c3cdSWolfgang Wander extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
2061da177e4SLinus Torvalds 
2071da177e4SLinus Torvalds #define set_mm_counter(mm, member, value) (mm)->_##member = (value)
2081da177e4SLinus Torvalds #define get_mm_counter(mm, member) ((mm)->_##member)
2091da177e4SLinus Torvalds #define add_mm_counter(mm, member, value) (mm)->_##member += (value)
2101da177e4SLinus Torvalds #define inc_mm_counter(mm, member) (mm)->_##member++
2111da177e4SLinus Torvalds #define dec_mm_counter(mm, member) (mm)->_##member--
2121da177e4SLinus Torvalds typedef unsigned long mm_counter_t;
2131da177e4SLinus Torvalds 
2141da177e4SLinus Torvalds struct mm_struct {
2151da177e4SLinus Torvalds 	struct vm_area_struct * mmap;		/* list of VMAs */
2161da177e4SLinus Torvalds 	struct rb_root mm_rb;
2171da177e4SLinus Torvalds 	struct vm_area_struct * mmap_cache;	/* last find_vma result */
2181da177e4SLinus Torvalds 	unsigned long (*get_unmapped_area) (struct file *filp,
2191da177e4SLinus Torvalds 				unsigned long addr, unsigned long len,
2201da177e4SLinus Torvalds 				unsigned long pgoff, unsigned long flags);
2211363c3cdSWolfgang Wander 	void (*unmap_area) (struct mm_struct *mm, unsigned long addr);
2221da177e4SLinus Torvalds         unsigned long mmap_base;		/* base of mmap area */
2231363c3cdSWolfgang Wander         unsigned long cached_hole_size;         /* if non-zero, the largest hole below free_area_cache */
2241363c3cdSWolfgang Wander 	unsigned long free_area_cache;		/* first hole of size cached_hole_size or larger */
2251da177e4SLinus Torvalds 	pgd_t * pgd;
2261da177e4SLinus Torvalds 	atomic_t mm_users;			/* How many users with user space? */
2271da177e4SLinus Torvalds 	atomic_t mm_count;			/* How many references to "struct mm_struct" (users count as 1) */
2281da177e4SLinus Torvalds 	int map_count;				/* number of VMAs */
2291da177e4SLinus Torvalds 	struct rw_semaphore mmap_sem;
2301da177e4SLinus Torvalds 	spinlock_t page_table_lock;		/* Protects page tables and some counters */
2311da177e4SLinus Torvalds 
2321da177e4SLinus Torvalds 	struct list_head mmlist;		/* List of maybe swapped mm's.  These are globally strung
2331da177e4SLinus Torvalds 						 * together off init_mm.mmlist, and are protected
2341da177e4SLinus Torvalds 						 * by mmlist_lock
2351da177e4SLinus Torvalds 						 */
2361da177e4SLinus Torvalds 
2371da177e4SLinus Torvalds 	unsigned long start_code, end_code, start_data, end_data;
2381da177e4SLinus Torvalds 	unsigned long start_brk, brk, start_stack;
2391da177e4SLinus Torvalds 	unsigned long arg_start, arg_end, env_start, env_end;
2401da177e4SLinus Torvalds 	unsigned long total_vm, locked_vm, shared_vm;
2411da177e4SLinus Torvalds 	unsigned long exec_vm, stack_vm, reserved_vm, def_flags, nr_ptes;
2421da177e4SLinus Torvalds 
2431da177e4SLinus Torvalds 	/* Special counters protected by the page_table_lock */
2441da177e4SLinus Torvalds 	mm_counter_t _rss;
2451da177e4SLinus Torvalds 	mm_counter_t _anon_rss;
2461da177e4SLinus Torvalds 
2471da177e4SLinus Torvalds 	unsigned long saved_auxv[42]; /* for /proc/PID/auxv */
2481da177e4SLinus Torvalds 
249d6e71144SAlan Cox 	unsigned dumpable:2;
2501da177e4SLinus Torvalds 	cpumask_t cpu_vm_mask;
2511da177e4SLinus Torvalds 
2521da177e4SLinus Torvalds 	/* Architecture-specific MM context */
2531da177e4SLinus Torvalds 	mm_context_t context;
2541da177e4SLinus Torvalds 
2551da177e4SLinus Torvalds 	/* Token based thrashing protection. */
2561da177e4SLinus Torvalds 	unsigned long swap_token_time;
2571da177e4SLinus Torvalds 	char recent_pagein;
2581da177e4SLinus Torvalds 
2591da177e4SLinus Torvalds 	/* coredumping support */
2601da177e4SLinus Torvalds 	int core_waiters;
2611da177e4SLinus Torvalds 	struct completion *core_startup_done, core_done;
2621da177e4SLinus Torvalds 
2631da177e4SLinus Torvalds 	/* aio bits */
2641da177e4SLinus Torvalds 	rwlock_t		ioctx_list_lock;
2651da177e4SLinus Torvalds 	struct kioctx		*ioctx_list;
2661da177e4SLinus Torvalds 
2671da177e4SLinus Torvalds 	struct kioctx		default_kioctx;
2681da177e4SLinus Torvalds 
2691da177e4SLinus Torvalds 	unsigned long hiwater_rss;	/* High-water RSS usage */
2701da177e4SLinus Torvalds 	unsigned long hiwater_vm;	/* High-water virtual memory usage */
2711da177e4SLinus Torvalds };
2721da177e4SLinus Torvalds 
2731da177e4SLinus Torvalds struct sighand_struct {
2741da177e4SLinus Torvalds 	atomic_t		count;
2751da177e4SLinus Torvalds 	struct k_sigaction	action[_NSIG];
2761da177e4SLinus Torvalds 	spinlock_t		siglock;
2771da177e4SLinus Torvalds };
2781da177e4SLinus Torvalds 
2791da177e4SLinus Torvalds /*
2801da177e4SLinus Torvalds  * NOTE! "signal_struct" does not have it's own
2811da177e4SLinus Torvalds  * locking, because a shared signal_struct always
2821da177e4SLinus Torvalds  * implies a shared sighand_struct, so locking
2831da177e4SLinus Torvalds  * sighand_struct is always a proper superset of
2841da177e4SLinus Torvalds  * the locking of signal_struct.
2851da177e4SLinus Torvalds  */
2861da177e4SLinus Torvalds struct signal_struct {
2871da177e4SLinus Torvalds 	atomic_t		count;
2881da177e4SLinus Torvalds 	atomic_t		live;
2891da177e4SLinus Torvalds 
2901da177e4SLinus Torvalds 	wait_queue_head_t	wait_chldexit;	/* for wait4() */
2911da177e4SLinus Torvalds 
2921da177e4SLinus Torvalds 	/* current thread group signal load-balancing target: */
2931da177e4SLinus Torvalds 	task_t			*curr_target;
2941da177e4SLinus Torvalds 
2951da177e4SLinus Torvalds 	/* shared signal handling: */
2961da177e4SLinus Torvalds 	struct sigpending	shared_pending;
2971da177e4SLinus Torvalds 
2981da177e4SLinus Torvalds 	/* thread group exit support */
2991da177e4SLinus Torvalds 	int			group_exit_code;
3001da177e4SLinus Torvalds 	/* overloaded:
3011da177e4SLinus Torvalds 	 * - notify group_exit_task when ->count is equal to notify_count
3021da177e4SLinus Torvalds 	 * - everyone except group_exit_task is stopped during signal delivery
3031da177e4SLinus Torvalds 	 *   of fatal signals, group_exit_task processes the signal.
3041da177e4SLinus Torvalds 	 */
3051da177e4SLinus Torvalds 	struct task_struct	*group_exit_task;
3061da177e4SLinus Torvalds 	int			notify_count;
3071da177e4SLinus Torvalds 
3081da177e4SLinus Torvalds 	/* thread group stop support, overloads group_exit_code too */
3091da177e4SLinus Torvalds 	int			group_stop_count;
3101da177e4SLinus Torvalds 	unsigned int		flags; /* see SIGNAL_* flags below */
3111da177e4SLinus Torvalds 
3121da177e4SLinus Torvalds 	/* POSIX.1b Interval Timers */
3131da177e4SLinus Torvalds 	struct list_head posix_timers;
3141da177e4SLinus Torvalds 
3151da177e4SLinus Torvalds 	/* ITIMER_REAL timer for the process */
3161da177e4SLinus Torvalds 	struct timer_list real_timer;
3171da177e4SLinus Torvalds 	unsigned long it_real_value, it_real_incr;
3181da177e4SLinus Torvalds 
3191da177e4SLinus Torvalds 	/* ITIMER_PROF and ITIMER_VIRTUAL timers for the process */
3201da177e4SLinus Torvalds 	cputime_t it_prof_expires, it_virt_expires;
3211da177e4SLinus Torvalds 	cputime_t it_prof_incr, it_virt_incr;
3221da177e4SLinus Torvalds 
3231da177e4SLinus Torvalds 	/* job control IDs */
3241da177e4SLinus Torvalds 	pid_t pgrp;
3251da177e4SLinus Torvalds 	pid_t tty_old_pgrp;
3261da177e4SLinus Torvalds 	pid_t session;
3271da177e4SLinus Torvalds 	/* boolean value for session group leader */
3281da177e4SLinus Torvalds 	int leader;
3291da177e4SLinus Torvalds 
3301da177e4SLinus Torvalds 	struct tty_struct *tty; /* NULL if no tty */
3311da177e4SLinus Torvalds 
3321da177e4SLinus Torvalds 	/*
3331da177e4SLinus Torvalds 	 * Cumulative resource counters for dead threads in the group,
3341da177e4SLinus Torvalds 	 * and for reaped dead child processes forked by this group.
3351da177e4SLinus Torvalds 	 * Live threads maintain their own counters and add to these
3361da177e4SLinus Torvalds 	 * in __exit_signal, except for the group leader.
3371da177e4SLinus Torvalds 	 */
3381da177e4SLinus Torvalds 	cputime_t utime, stime, cutime, cstime;
3391da177e4SLinus Torvalds 	unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
3401da177e4SLinus Torvalds 	unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
3411da177e4SLinus Torvalds 
3421da177e4SLinus Torvalds 	/*
3431da177e4SLinus Torvalds 	 * Cumulative ns of scheduled CPU time for dead threads in the
3441da177e4SLinus Torvalds 	 * group, not including a zombie group leader.  (This only differs
3451da177e4SLinus Torvalds 	 * from jiffies_to_ns(utime + stime) if sched_clock uses something
3461da177e4SLinus Torvalds 	 * other than jiffies.)
3471da177e4SLinus Torvalds 	 */
3481da177e4SLinus Torvalds 	unsigned long long sched_time;
3491da177e4SLinus Torvalds 
3501da177e4SLinus Torvalds 	/*
3511da177e4SLinus Torvalds 	 * We don't bother to synchronize most readers of this at all,
3521da177e4SLinus Torvalds 	 * because there is no reader checking a limit that actually needs
3531da177e4SLinus Torvalds 	 * to get both rlim_cur and rlim_max atomically, and either one
3541da177e4SLinus Torvalds 	 * alone is a single word that can safely be read normally.
3551da177e4SLinus Torvalds 	 * getrlimit/setrlimit use task_lock(current->group_leader) to
3561da177e4SLinus Torvalds 	 * protect this instead of the siglock, because they really
3571da177e4SLinus Torvalds 	 * have no need to disable irqs.
3581da177e4SLinus Torvalds 	 */
3591da177e4SLinus Torvalds 	struct rlimit rlim[RLIM_NLIMITS];
3601da177e4SLinus Torvalds 
3611da177e4SLinus Torvalds 	struct list_head cpu_timers[3];
3621da177e4SLinus Torvalds 
3631da177e4SLinus Torvalds 	/* keep the process-shared keyrings here so that they do the right
3641da177e4SLinus Torvalds 	 * thing in threads created with CLONE_THREAD */
3651da177e4SLinus Torvalds #ifdef CONFIG_KEYS
3661da177e4SLinus Torvalds 	struct key *session_keyring;	/* keyring inherited over fork */
3671da177e4SLinus Torvalds 	struct key *process_keyring;	/* keyring private to this process */
3681da177e4SLinus Torvalds #endif
3691da177e4SLinus Torvalds };
3701da177e4SLinus Torvalds 
371*4866cde0SNick Piggin /* Context switch must be unlocked if interrupts are to be enabled */
372*4866cde0SNick Piggin #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
373*4866cde0SNick Piggin # define __ARCH_WANT_UNLOCKED_CTXSW
374*4866cde0SNick Piggin #endif
375*4866cde0SNick Piggin 
3761da177e4SLinus Torvalds /*
3771da177e4SLinus Torvalds  * Bits in flags field of signal_struct.
3781da177e4SLinus Torvalds  */
3791da177e4SLinus Torvalds #define SIGNAL_STOP_STOPPED	0x00000001 /* job control stop in effect */
3801da177e4SLinus Torvalds #define SIGNAL_STOP_DEQUEUED	0x00000002 /* stop signal dequeued */
3811da177e4SLinus Torvalds #define SIGNAL_STOP_CONTINUED	0x00000004 /* SIGCONT since WCONTINUED reap */
3821da177e4SLinus Torvalds #define SIGNAL_GROUP_EXIT	0x00000008 /* group exit in progress */
3831da177e4SLinus Torvalds 
3841da177e4SLinus Torvalds 
3851da177e4SLinus Torvalds /*
3861da177e4SLinus Torvalds  * Priority of a process goes from 0..MAX_PRIO-1, valid RT
3871da177e4SLinus Torvalds  * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL tasks are
3881da177e4SLinus Torvalds  * in the range MAX_RT_PRIO..MAX_PRIO-1. Priority values
3891da177e4SLinus Torvalds  * are inverted: lower p->prio value means higher priority.
3901da177e4SLinus Torvalds  *
3911da177e4SLinus Torvalds  * The MAX_USER_RT_PRIO value allows the actual maximum
3921da177e4SLinus Torvalds  * RT priority to be separate from the value exported to
3931da177e4SLinus Torvalds  * user-space.  This allows kernel threads to set their
3941da177e4SLinus Torvalds  * priority to a value higher than any user task. Note:
3951da177e4SLinus Torvalds  * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
3961da177e4SLinus Torvalds  */
3971da177e4SLinus Torvalds 
3981da177e4SLinus Torvalds #define MAX_USER_RT_PRIO	100
3991da177e4SLinus Torvalds #define MAX_RT_PRIO		MAX_USER_RT_PRIO
4001da177e4SLinus Torvalds 
4011da177e4SLinus Torvalds #define MAX_PRIO		(MAX_RT_PRIO + 40)
4021da177e4SLinus Torvalds 
4031da177e4SLinus Torvalds #define rt_task(p)		(unlikely((p)->prio < MAX_RT_PRIO))
4041da177e4SLinus Torvalds 
4051da177e4SLinus Torvalds /*
4061da177e4SLinus Torvalds  * Some day this will be a full-fledged user tracking system..
4071da177e4SLinus Torvalds  */
4081da177e4SLinus Torvalds struct user_struct {
4091da177e4SLinus Torvalds 	atomic_t __count;	/* reference count */
4101da177e4SLinus Torvalds 	atomic_t processes;	/* How many processes does this user have? */
4111da177e4SLinus Torvalds 	atomic_t files;		/* How many open files does this user have? */
4121da177e4SLinus Torvalds 	atomic_t sigpending;	/* How many pending signals does this user have? */
4131da177e4SLinus Torvalds 	/* protected by mq_lock	*/
4141da177e4SLinus Torvalds 	unsigned long mq_bytes;	/* How many bytes can be allocated to mqueue? */
4151da177e4SLinus Torvalds 	unsigned long locked_shm; /* How many pages of mlocked shm ? */
4161da177e4SLinus Torvalds 
4171da177e4SLinus Torvalds #ifdef CONFIG_KEYS
4181da177e4SLinus Torvalds 	struct key *uid_keyring;	/* UID specific keyring */
4191da177e4SLinus Torvalds 	struct key *session_keyring;	/* UID's default session keyring */
4201da177e4SLinus Torvalds #endif
4211da177e4SLinus Torvalds 
4221da177e4SLinus Torvalds 	/* Hash table maintenance information */
4231da177e4SLinus Torvalds 	struct list_head uidhash_list;
4241da177e4SLinus Torvalds 	uid_t uid;
4251da177e4SLinus Torvalds };
4261da177e4SLinus Torvalds 
4271da177e4SLinus Torvalds extern struct user_struct *find_user(uid_t);
4281da177e4SLinus Torvalds 
4291da177e4SLinus Torvalds extern struct user_struct root_user;
4301da177e4SLinus Torvalds #define INIT_USER (&root_user)
4311da177e4SLinus Torvalds 
4321da177e4SLinus Torvalds typedef struct prio_array prio_array_t;
4331da177e4SLinus Torvalds struct backing_dev_info;
4341da177e4SLinus Torvalds struct reclaim_state;
4351da177e4SLinus Torvalds 
4361da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS
4371da177e4SLinus Torvalds struct sched_info {
4381da177e4SLinus Torvalds 	/* cumulative counters */
4391da177e4SLinus Torvalds 	unsigned long	cpu_time,	/* time spent on the cpu */
4401da177e4SLinus Torvalds 			run_delay,	/* time spent waiting on a runqueue */
4411da177e4SLinus Torvalds 			pcnt;		/* # of timeslices run on this cpu */
4421da177e4SLinus Torvalds 
4431da177e4SLinus Torvalds 	/* timestamps */
4441da177e4SLinus Torvalds 	unsigned long	last_arrival,	/* when we last ran on a cpu */
4451da177e4SLinus Torvalds 			last_queued;	/* when we were last queued to run */
4461da177e4SLinus Torvalds };
4471da177e4SLinus Torvalds 
4481da177e4SLinus Torvalds extern struct file_operations proc_schedstat_operations;
4491da177e4SLinus Torvalds #endif
4501da177e4SLinus Torvalds 
4511da177e4SLinus Torvalds enum idle_type
4521da177e4SLinus Torvalds {
4531da177e4SLinus Torvalds 	SCHED_IDLE,
4541da177e4SLinus Torvalds 	NOT_IDLE,
4551da177e4SLinus Torvalds 	NEWLY_IDLE,
4561da177e4SLinus Torvalds 	MAX_IDLE_TYPES
4571da177e4SLinus Torvalds };
4581da177e4SLinus Torvalds 
4591da177e4SLinus Torvalds /*
4601da177e4SLinus Torvalds  * sched-domains (multiprocessor balancing) declarations:
4611da177e4SLinus Torvalds  */
4621da177e4SLinus Torvalds #ifdef CONFIG_SMP
4631da177e4SLinus Torvalds #define SCHED_LOAD_SCALE	128UL	/* increase resolution of load */
4641da177e4SLinus Torvalds 
4651da177e4SLinus Torvalds #define SD_LOAD_BALANCE		1	/* Do load balancing on this domain. */
4661da177e4SLinus Torvalds #define SD_BALANCE_NEWIDLE	2	/* Balance when about to become idle */
4671da177e4SLinus Torvalds #define SD_BALANCE_EXEC		4	/* Balance on exec */
468147cbb4bSNick Piggin #define SD_BALANCE_FORK		8	/* Balance on fork, clone */
469147cbb4bSNick Piggin #define SD_WAKE_IDLE		16	/* Wake to idle CPU on task wakeup */
470147cbb4bSNick Piggin #define SD_WAKE_AFFINE		32	/* Wake task to waking CPU */
471147cbb4bSNick Piggin #define SD_WAKE_BALANCE		64	/* Perform balancing at task wakeup */
472147cbb4bSNick Piggin #define SD_SHARE_CPUPOWER	128	/* Domain members share cpu power */
4731da177e4SLinus Torvalds 
4741da177e4SLinus Torvalds struct sched_group {
4751da177e4SLinus Torvalds 	struct sched_group *next;	/* Must be a circular list */
4761da177e4SLinus Torvalds 	cpumask_t cpumask;
4771da177e4SLinus Torvalds 
4781da177e4SLinus Torvalds 	/*
4791da177e4SLinus Torvalds 	 * CPU power of this group, SCHED_LOAD_SCALE being max power for a
4801da177e4SLinus Torvalds 	 * single CPU. This is read only (except for setup, hotplug CPU).
4811da177e4SLinus Torvalds 	 */
4821da177e4SLinus Torvalds 	unsigned long cpu_power;
4831da177e4SLinus Torvalds };
4841da177e4SLinus Torvalds 
4851da177e4SLinus Torvalds struct sched_domain {
4861da177e4SLinus Torvalds 	/* These fields must be setup */
4871da177e4SLinus Torvalds 	struct sched_domain *parent;	/* top domain must be null terminated */
4881da177e4SLinus Torvalds 	struct sched_group *groups;	/* the balancing groups of the domain */
4891da177e4SLinus Torvalds 	cpumask_t span;			/* span of all CPUs in this domain */
4901da177e4SLinus Torvalds 	unsigned long min_interval;	/* Minimum balance interval ms */
4911da177e4SLinus Torvalds 	unsigned long max_interval;	/* Maximum balance interval ms */
4921da177e4SLinus Torvalds 	unsigned int busy_factor;	/* less balancing by factor if busy */
4931da177e4SLinus Torvalds 	unsigned int imbalance_pct;	/* No balance until over watermark */
4941da177e4SLinus Torvalds 	unsigned long long cache_hot_time; /* Task considered cache hot (ns) */
4951da177e4SLinus Torvalds 	unsigned int cache_nice_tries;	/* Leave cache hot tasks for # tries */
4961da177e4SLinus Torvalds 	unsigned int per_cpu_gain;	/* CPU % gained by adding domain cpus */
4977897986bSNick Piggin 	unsigned int busy_idx;
4987897986bSNick Piggin 	unsigned int idle_idx;
4997897986bSNick Piggin 	unsigned int newidle_idx;
5007897986bSNick Piggin 	unsigned int wake_idx;
501147cbb4bSNick Piggin 	unsigned int forkexec_idx;
5021da177e4SLinus Torvalds 	int flags;			/* See SD_* */
5031da177e4SLinus Torvalds 
5041da177e4SLinus Torvalds 	/* Runtime fields. */
5051da177e4SLinus Torvalds 	unsigned long last_balance;	/* init to jiffies. units in jiffies */
5061da177e4SLinus Torvalds 	unsigned int balance_interval;	/* initialise to 1. units in ms. */
5071da177e4SLinus Torvalds 	unsigned int nr_balance_failed; /* initialise to 0 */
5081da177e4SLinus Torvalds 
5091da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS
5101da177e4SLinus Torvalds 	/* load_balance() stats */
5111da177e4SLinus Torvalds 	unsigned long lb_cnt[MAX_IDLE_TYPES];
5121da177e4SLinus Torvalds 	unsigned long lb_failed[MAX_IDLE_TYPES];
5131da177e4SLinus Torvalds 	unsigned long lb_balanced[MAX_IDLE_TYPES];
5141da177e4SLinus Torvalds 	unsigned long lb_imbalance[MAX_IDLE_TYPES];
5151da177e4SLinus Torvalds 	unsigned long lb_gained[MAX_IDLE_TYPES];
5161da177e4SLinus Torvalds 	unsigned long lb_hot_gained[MAX_IDLE_TYPES];
5171da177e4SLinus Torvalds 	unsigned long lb_nobusyg[MAX_IDLE_TYPES];
5181da177e4SLinus Torvalds 	unsigned long lb_nobusyq[MAX_IDLE_TYPES];
5191da177e4SLinus Torvalds 
5201da177e4SLinus Torvalds 	/* Active load balancing */
5211da177e4SLinus Torvalds 	unsigned long alb_cnt;
5221da177e4SLinus Torvalds 	unsigned long alb_failed;
5231da177e4SLinus Torvalds 	unsigned long alb_pushed;
5241da177e4SLinus Torvalds 
52568767a0aSNick Piggin 	/* SD_BALANCE_EXEC stats */
52668767a0aSNick Piggin 	unsigned long sbe_cnt;
52768767a0aSNick Piggin 	unsigned long sbe_balanced;
5281da177e4SLinus Torvalds 	unsigned long sbe_pushed;
5291da177e4SLinus Torvalds 
53068767a0aSNick Piggin 	/* SD_BALANCE_FORK stats */
53168767a0aSNick Piggin 	unsigned long sbf_cnt;
53268767a0aSNick Piggin 	unsigned long sbf_balanced;
53368767a0aSNick Piggin 	unsigned long sbf_pushed;
53468767a0aSNick Piggin 
5351da177e4SLinus Torvalds 	/* try_to_wake_up() stats */
5361da177e4SLinus Torvalds 	unsigned long ttwu_wake_remote;
5371da177e4SLinus Torvalds 	unsigned long ttwu_move_affine;
5381da177e4SLinus Torvalds 	unsigned long ttwu_move_balance;
5391da177e4SLinus Torvalds #endif
5401da177e4SLinus Torvalds };
5411da177e4SLinus Torvalds 
5421da177e4SLinus Torvalds #ifdef ARCH_HAS_SCHED_DOMAIN
5431da177e4SLinus Torvalds /* Useful helpers that arch setup code may use. Defined in kernel/sched.c */
5441da177e4SLinus Torvalds extern cpumask_t cpu_isolated_map;
5451da177e4SLinus Torvalds extern void init_sched_build_groups(struct sched_group groups[],
5461da177e4SLinus Torvalds 	                        cpumask_t span, int (*group_fn)(int cpu));
5471da177e4SLinus Torvalds extern void cpu_attach_domain(struct sched_domain *sd, int cpu);
5481da177e4SLinus Torvalds #endif /* ARCH_HAS_SCHED_DOMAIN */
5491da177e4SLinus Torvalds #endif /* CONFIG_SMP */
5501da177e4SLinus Torvalds 
5511da177e4SLinus Torvalds 
5521da177e4SLinus Torvalds struct io_context;			/* See blkdev.h */
5531da177e4SLinus Torvalds void exit_io_context(void);
5541da177e4SLinus Torvalds struct cpuset;
5551da177e4SLinus Torvalds 
5561da177e4SLinus Torvalds #define NGROUPS_SMALL		32
5571da177e4SLinus Torvalds #define NGROUPS_PER_BLOCK	((int)(PAGE_SIZE / sizeof(gid_t)))
5581da177e4SLinus Torvalds struct group_info {
5591da177e4SLinus Torvalds 	int ngroups;
5601da177e4SLinus Torvalds 	atomic_t usage;
5611da177e4SLinus Torvalds 	gid_t small_block[NGROUPS_SMALL];
5621da177e4SLinus Torvalds 	int nblocks;
5631da177e4SLinus Torvalds 	gid_t *blocks[0];
5641da177e4SLinus Torvalds };
5651da177e4SLinus Torvalds 
5661da177e4SLinus Torvalds /*
5671da177e4SLinus Torvalds  * get_group_info() must be called with the owning task locked (via task_lock())
5681da177e4SLinus Torvalds  * when task != current.  The reason being that the vast majority of callers are
5691da177e4SLinus Torvalds  * looking at current->group_info, which can not be changed except by the
5701da177e4SLinus Torvalds  * current task.  Changing current->group_info requires the task lock, too.
5711da177e4SLinus Torvalds  */
5721da177e4SLinus Torvalds #define get_group_info(group_info) do { \
5731da177e4SLinus Torvalds 	atomic_inc(&(group_info)->usage); \
5741da177e4SLinus Torvalds } while (0)
5751da177e4SLinus Torvalds 
5761da177e4SLinus Torvalds #define put_group_info(group_info) do { \
5771da177e4SLinus Torvalds 	if (atomic_dec_and_test(&(group_info)->usage)) \
5781da177e4SLinus Torvalds 		groups_free(group_info); \
5791da177e4SLinus Torvalds } while (0)
5801da177e4SLinus Torvalds 
5813e30148cSDavid Howells extern struct group_info *groups_alloc(int gidsetsize);
5823e30148cSDavid Howells extern void groups_free(struct group_info *group_info);
5833e30148cSDavid Howells extern int set_current_groups(struct group_info *group_info);
5843e30148cSDavid Howells extern int groups_search(struct group_info *group_info, gid_t grp);
5851da177e4SLinus Torvalds /* access the groups "array" with this macro */
5861da177e4SLinus Torvalds #define GROUP_AT(gi, i) \
5871da177e4SLinus Torvalds     ((gi)->blocks[(i)/NGROUPS_PER_BLOCK][(i)%NGROUPS_PER_BLOCK])
5881da177e4SLinus Torvalds 
5891da177e4SLinus Torvalds 
5901da177e4SLinus Torvalds struct audit_context;		/* See audit.c */
5911da177e4SLinus Torvalds struct mempolicy;
5921da177e4SLinus Torvalds 
5931da177e4SLinus Torvalds struct task_struct {
5941da177e4SLinus Torvalds 	volatile long state;	/* -1 unrunnable, 0 runnable, >0 stopped */
5951da177e4SLinus Torvalds 	struct thread_info *thread_info;
5961da177e4SLinus Torvalds 	atomic_t usage;
5971da177e4SLinus Torvalds 	unsigned long flags;	/* per process flags, defined below */
5981da177e4SLinus Torvalds 	unsigned long ptrace;
5991da177e4SLinus Torvalds 
60036772092SPaolo 'Blaisorblade' Giarrusso 	int lock_depth;		/* BKL lock depth */
6011da177e4SLinus Torvalds 
602*4866cde0SNick Piggin #if defined(CONFIG_SMP) && defined(__ARCH_WANT_UNLOCKED_CTXSW)
603*4866cde0SNick Piggin 	int oncpu;
604*4866cde0SNick Piggin #endif
6051da177e4SLinus Torvalds 	int prio, static_prio;
6061da177e4SLinus Torvalds 	struct list_head run_list;
6071da177e4SLinus Torvalds 	prio_array_t *array;
6081da177e4SLinus Torvalds 
6091da177e4SLinus Torvalds 	unsigned long sleep_avg;
6101da177e4SLinus Torvalds 	unsigned long long timestamp, last_ran;
6111da177e4SLinus Torvalds 	unsigned long long sched_time; /* sched_clock time spent running */
6121da177e4SLinus Torvalds 	int activated;
6131da177e4SLinus Torvalds 
6141da177e4SLinus Torvalds 	unsigned long policy;
6151da177e4SLinus Torvalds 	cpumask_t cpus_allowed;
6161da177e4SLinus Torvalds 	unsigned int time_slice, first_time_slice;
6171da177e4SLinus Torvalds 
6181da177e4SLinus Torvalds #ifdef CONFIG_SCHEDSTATS
6191da177e4SLinus Torvalds 	struct sched_info sched_info;
6201da177e4SLinus Torvalds #endif
6211da177e4SLinus Torvalds 
6221da177e4SLinus Torvalds 	struct list_head tasks;
6231da177e4SLinus Torvalds 	/*
6241da177e4SLinus Torvalds 	 * ptrace_list/ptrace_children forms the list of my children
6251da177e4SLinus Torvalds 	 * that were stolen by a ptracer.
6261da177e4SLinus Torvalds 	 */
6271da177e4SLinus Torvalds 	struct list_head ptrace_children;
6281da177e4SLinus Torvalds 	struct list_head ptrace_list;
6291da177e4SLinus Torvalds 
6301da177e4SLinus Torvalds 	struct mm_struct *mm, *active_mm;
6311da177e4SLinus Torvalds 
6321da177e4SLinus Torvalds /* task state */
6331da177e4SLinus Torvalds 	struct linux_binfmt *binfmt;
6341da177e4SLinus Torvalds 	long exit_state;
6351da177e4SLinus Torvalds 	int exit_code, exit_signal;
6361da177e4SLinus Torvalds 	int pdeath_signal;  /*  The signal sent when the parent dies  */
6371da177e4SLinus Torvalds 	/* ??? */
6381da177e4SLinus Torvalds 	unsigned long personality;
6391da177e4SLinus Torvalds 	unsigned did_exec:1;
6401da177e4SLinus Torvalds 	pid_t pid;
6411da177e4SLinus Torvalds 	pid_t tgid;
6421da177e4SLinus Torvalds 	/*
6431da177e4SLinus Torvalds 	 * pointers to (original) parent process, youngest child, younger sibling,
6441da177e4SLinus Torvalds 	 * older sibling, respectively.  (p->father can be replaced with
6451da177e4SLinus Torvalds 	 * p->parent->pid)
6461da177e4SLinus Torvalds 	 */
6471da177e4SLinus Torvalds 	struct task_struct *real_parent; /* real parent process (when being debugged) */
6481da177e4SLinus Torvalds 	struct task_struct *parent;	/* parent process */
6491da177e4SLinus Torvalds 	/*
6501da177e4SLinus Torvalds 	 * children/sibling forms the list of my children plus the
6511da177e4SLinus Torvalds 	 * tasks I'm ptracing.
6521da177e4SLinus Torvalds 	 */
6531da177e4SLinus Torvalds 	struct list_head children;	/* list of my children */
6541da177e4SLinus Torvalds 	struct list_head sibling;	/* linkage in my parent's children list */
6551da177e4SLinus Torvalds 	struct task_struct *group_leader;	/* threadgroup leader */
6561da177e4SLinus Torvalds 
6571da177e4SLinus Torvalds 	/* PID/PID hash table linkage. */
6581da177e4SLinus Torvalds 	struct pid pids[PIDTYPE_MAX];
6591da177e4SLinus Torvalds 
6601da177e4SLinus Torvalds 	struct completion *vfork_done;		/* for vfork() */
6611da177e4SLinus Torvalds 	int __user *set_child_tid;		/* CLONE_CHILD_SETTID */
6621da177e4SLinus Torvalds 	int __user *clear_child_tid;		/* CLONE_CHILD_CLEARTID */
6631da177e4SLinus Torvalds 
6641da177e4SLinus Torvalds 	unsigned long rt_priority;
6651da177e4SLinus Torvalds 	cputime_t utime, stime;
6661da177e4SLinus Torvalds 	unsigned long nvcsw, nivcsw; /* context switch counts */
6671da177e4SLinus Torvalds 	struct timespec start_time;
6681da177e4SLinus Torvalds /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
6691da177e4SLinus Torvalds 	unsigned long min_flt, maj_flt;
6701da177e4SLinus Torvalds 
6711da177e4SLinus Torvalds   	cputime_t it_prof_expires, it_virt_expires;
6721da177e4SLinus Torvalds 	unsigned long long it_sched_expires;
6731da177e4SLinus Torvalds 	struct list_head cpu_timers[3];
6741da177e4SLinus Torvalds 
6751da177e4SLinus Torvalds /* process credentials */
6761da177e4SLinus Torvalds 	uid_t uid,euid,suid,fsuid;
6771da177e4SLinus Torvalds 	gid_t gid,egid,sgid,fsgid;
6781da177e4SLinus Torvalds 	struct group_info *group_info;
6791da177e4SLinus Torvalds 	kernel_cap_t   cap_effective, cap_inheritable, cap_permitted;
6801da177e4SLinus Torvalds 	unsigned keep_capabilities:1;
6811da177e4SLinus Torvalds 	struct user_struct *user;
6821da177e4SLinus Torvalds #ifdef CONFIG_KEYS
6831da177e4SLinus Torvalds 	struct key *thread_keyring;	/* keyring private to this thread */
6843e30148cSDavid Howells 	unsigned char jit_keyring;	/* default keyring to attach requested keys to */
6851da177e4SLinus Torvalds #endif
6861da177e4SLinus Torvalds 	int oomkilladj; /* OOM kill score adjustment (bit shift). */
68736772092SPaolo 'Blaisorblade' Giarrusso 	char comm[TASK_COMM_LEN]; /* executable name excluding path
68836772092SPaolo 'Blaisorblade' Giarrusso 				     - access with [gs]et_task_comm (which lock
68936772092SPaolo 'Blaisorblade' Giarrusso 				       it with task_lock())
69036772092SPaolo 'Blaisorblade' Giarrusso 				     - initialized normally by flush_old_exec */
6911da177e4SLinus Torvalds /* file system info */
6921da177e4SLinus Torvalds 	int link_count, total_link_count;
6931da177e4SLinus Torvalds /* ipc stuff */
6941da177e4SLinus Torvalds 	struct sysv_sem sysvsem;
6951da177e4SLinus Torvalds /* CPU-specific state of this task */
6961da177e4SLinus Torvalds 	struct thread_struct thread;
6971da177e4SLinus Torvalds /* filesystem information */
6981da177e4SLinus Torvalds 	struct fs_struct *fs;
6991da177e4SLinus Torvalds /* open file information */
7001da177e4SLinus Torvalds 	struct files_struct *files;
7011da177e4SLinus Torvalds /* namespace */
7021da177e4SLinus Torvalds 	struct namespace *namespace;
7031da177e4SLinus Torvalds /* signal handlers */
7041da177e4SLinus Torvalds 	struct signal_struct *signal;
7051da177e4SLinus Torvalds 	struct sighand_struct *sighand;
7061da177e4SLinus Torvalds 
7071da177e4SLinus Torvalds 	sigset_t blocked, real_blocked;
7081da177e4SLinus Torvalds 	struct sigpending pending;
7091da177e4SLinus Torvalds 
7101da177e4SLinus Torvalds 	unsigned long sas_ss_sp;
7111da177e4SLinus Torvalds 	size_t sas_ss_size;
7121da177e4SLinus Torvalds 	int (*notifier)(void *priv);
7131da177e4SLinus Torvalds 	void *notifier_data;
7141da177e4SLinus Torvalds 	sigset_t *notifier_mask;
7151da177e4SLinus Torvalds 
7161da177e4SLinus Torvalds 	void *security;
7171da177e4SLinus Torvalds 	struct audit_context *audit_context;
7181da177e4SLinus Torvalds 	seccomp_t seccomp;
7191da177e4SLinus Torvalds 
7201da177e4SLinus Torvalds /* Thread group tracking */
7211da177e4SLinus Torvalds    	u32 parent_exec_id;
7221da177e4SLinus Torvalds    	u32 self_exec_id;
7231da177e4SLinus Torvalds /* Protection of (de-)allocation: mm, files, fs, tty, keyrings */
7241da177e4SLinus Torvalds 	spinlock_t alloc_lock;
7251da177e4SLinus Torvalds /* Protection of proc_dentry: nesting proc_lock, dcache_lock, write_lock_irq(&tasklist_lock); */
7261da177e4SLinus Torvalds 	spinlock_t proc_lock;
7271da177e4SLinus Torvalds 
7281da177e4SLinus Torvalds /* journalling filesystem info */
7291da177e4SLinus Torvalds 	void *journal_info;
7301da177e4SLinus Torvalds 
7311da177e4SLinus Torvalds /* VM state */
7321da177e4SLinus Torvalds 	struct reclaim_state *reclaim_state;
7331da177e4SLinus Torvalds 
7341da177e4SLinus Torvalds 	struct dentry *proc_dentry;
7351da177e4SLinus Torvalds 	struct backing_dev_info *backing_dev_info;
7361da177e4SLinus Torvalds 
7371da177e4SLinus Torvalds 	struct io_context *io_context;
7381da177e4SLinus Torvalds 
7391da177e4SLinus Torvalds 	unsigned long ptrace_message;
7401da177e4SLinus Torvalds 	siginfo_t *last_siginfo; /* For ptrace use.  */
7411da177e4SLinus Torvalds /*
7421da177e4SLinus Torvalds  * current io wait handle: wait queue entry to use for io waits
7431da177e4SLinus Torvalds  * If this thread is processing aio, this points at the waitqueue
7441da177e4SLinus Torvalds  * inside the currently handled kiocb. It may be NULL (i.e. default
7451da177e4SLinus Torvalds  * to a stack based synchronous wait) if its doing sync IO.
7461da177e4SLinus Torvalds  */
7471da177e4SLinus Torvalds 	wait_queue_t *io_wait;
7481da177e4SLinus Torvalds /* i/o counters(bytes read/written, #syscalls */
7491da177e4SLinus Torvalds 	u64 rchar, wchar, syscr, syscw;
7501da177e4SLinus Torvalds #if defined(CONFIG_BSD_PROCESS_ACCT)
7511da177e4SLinus Torvalds 	u64 acct_rss_mem1;	/* accumulated rss usage */
7521da177e4SLinus Torvalds 	u64 acct_vm_mem1;	/* accumulated virtual memory usage */
7531da177e4SLinus Torvalds 	clock_t acct_stimexpd;	/* clock_t-converted stime since last update */
7541da177e4SLinus Torvalds #endif
7551da177e4SLinus Torvalds #ifdef CONFIG_NUMA
7561da177e4SLinus Torvalds   	struct mempolicy *mempolicy;
7571da177e4SLinus Torvalds 	short il_next;
7581da177e4SLinus Torvalds #endif
7591da177e4SLinus Torvalds #ifdef CONFIG_CPUSETS
7601da177e4SLinus Torvalds 	struct cpuset *cpuset;
7611da177e4SLinus Torvalds 	nodemask_t mems_allowed;
7621da177e4SLinus Torvalds 	int cpuset_mems_generation;
7631da177e4SLinus Torvalds #endif
7641da177e4SLinus Torvalds };
7651da177e4SLinus Torvalds 
7661da177e4SLinus Torvalds static inline pid_t process_group(struct task_struct *tsk)
7671da177e4SLinus Torvalds {
7681da177e4SLinus Torvalds 	return tsk->signal->pgrp;
7691da177e4SLinus Torvalds }
7701da177e4SLinus Torvalds 
7711da177e4SLinus Torvalds /**
7721da177e4SLinus Torvalds  * pid_alive - check that a task structure is not stale
7731da177e4SLinus Torvalds  * @p: Task structure to be checked.
7741da177e4SLinus Torvalds  *
7751da177e4SLinus Torvalds  * Test if a process is not yet dead (at most zombie state)
7761da177e4SLinus Torvalds  * If pid_alive fails, then pointers within the task structure
7771da177e4SLinus Torvalds  * can be stale and must not be dereferenced.
7781da177e4SLinus Torvalds  */
7791da177e4SLinus Torvalds static inline int pid_alive(struct task_struct *p)
7801da177e4SLinus Torvalds {
7811da177e4SLinus Torvalds 	return p->pids[PIDTYPE_PID].nr != 0;
7821da177e4SLinus Torvalds }
7831da177e4SLinus Torvalds 
7841da177e4SLinus Torvalds extern void free_task(struct task_struct *tsk);
7851da177e4SLinus Torvalds extern void __put_task_struct(struct task_struct *tsk);
7861da177e4SLinus Torvalds #define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
7871da177e4SLinus Torvalds #define put_task_struct(tsk) \
7881da177e4SLinus Torvalds do { if (atomic_dec_and_test(&(tsk)->usage)) __put_task_struct(tsk); } while(0)
7891da177e4SLinus Torvalds 
7901da177e4SLinus Torvalds /*
7911da177e4SLinus Torvalds  * Per process flags
7921da177e4SLinus Torvalds  */
7931da177e4SLinus Torvalds #define PF_ALIGNWARN	0x00000001	/* Print alignment warning msgs */
7941da177e4SLinus Torvalds 					/* Not implemented yet, only for 486*/
7951da177e4SLinus Torvalds #define PF_STARTING	0x00000002	/* being created */
7961da177e4SLinus Torvalds #define PF_EXITING	0x00000004	/* getting shut down */
7971da177e4SLinus Torvalds #define PF_DEAD		0x00000008	/* Dead */
7981da177e4SLinus Torvalds #define PF_FORKNOEXEC	0x00000040	/* forked but didn't exec */
7991da177e4SLinus Torvalds #define PF_SUPERPRIV	0x00000100	/* used super-user privileges */
8001da177e4SLinus Torvalds #define PF_DUMPCORE	0x00000200	/* dumped core */
8011da177e4SLinus Torvalds #define PF_SIGNALED	0x00000400	/* killed by a signal */
8021da177e4SLinus Torvalds #define PF_MEMALLOC	0x00000800	/* Allocating memory */
8031da177e4SLinus Torvalds #define PF_FLUSHER	0x00001000	/* responsible for disk writeback */
8041da177e4SLinus Torvalds #define PF_USED_MATH	0x00002000	/* if unset the fpu must be initialized before use */
8051da177e4SLinus Torvalds #define PF_FREEZE	0x00004000	/* this task is being frozen for suspend now */
8061da177e4SLinus Torvalds #define PF_NOFREEZE	0x00008000	/* this thread should not be frozen */
8071da177e4SLinus Torvalds #define PF_FROZEN	0x00010000	/* frozen for system suspend */
8081da177e4SLinus Torvalds #define PF_FSTRANS	0x00020000	/* inside a filesystem transaction */
8091da177e4SLinus Torvalds #define PF_KSWAPD	0x00040000	/* I am kswapd */
8101da177e4SLinus Torvalds #define PF_SWAPOFF	0x00080000	/* I am in swapoff */
8111da177e4SLinus Torvalds #define PF_LESS_THROTTLE 0x00100000	/* Throttle me less: I clean memory */
8121da177e4SLinus Torvalds #define PF_SYNCWRITE	0x00200000	/* I am doing a sync write */
8131da177e4SLinus Torvalds #define PF_BORROWED_MM	0x00400000	/* I am a kthread doing use_mm */
8141da177e4SLinus Torvalds #define PF_RANDOMIZE	0x00800000	/* randomize virtual address space */
8151da177e4SLinus Torvalds 
8161da177e4SLinus Torvalds /*
8171da177e4SLinus Torvalds  * Only the _current_ task can read/write to tsk->flags, but other
8181da177e4SLinus Torvalds  * tasks can access tsk->flags in readonly mode for example
8191da177e4SLinus Torvalds  * with tsk_used_math (like during threaded core dumping).
8201da177e4SLinus Torvalds  * There is however an exception to this rule during ptrace
8211da177e4SLinus Torvalds  * or during fork: the ptracer task is allowed to write to the
8221da177e4SLinus Torvalds  * child->flags of its traced child (same goes for fork, the parent
8231da177e4SLinus Torvalds  * can write to the child->flags), because we're guaranteed the
8241da177e4SLinus Torvalds  * child is not running and in turn not changing child->flags
8251da177e4SLinus Torvalds  * at the same time the parent does it.
8261da177e4SLinus Torvalds  */
8271da177e4SLinus Torvalds #define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
8281da177e4SLinus Torvalds #define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
8291da177e4SLinus Torvalds #define clear_used_math() clear_stopped_child_used_math(current)
8301da177e4SLinus Torvalds #define set_used_math() set_stopped_child_used_math(current)
8311da177e4SLinus Torvalds #define conditional_stopped_child_used_math(condition, child) \
8321da177e4SLinus Torvalds 	do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
8331da177e4SLinus Torvalds #define conditional_used_math(condition) \
8341da177e4SLinus Torvalds 	conditional_stopped_child_used_math(condition, current)
8351da177e4SLinus Torvalds #define copy_to_stopped_child_used_math(child) \
8361da177e4SLinus Torvalds 	do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
8371da177e4SLinus Torvalds /* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
8381da177e4SLinus Torvalds #define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
8391da177e4SLinus Torvalds #define used_math() tsk_used_math(current)
8401da177e4SLinus Torvalds 
8411da177e4SLinus Torvalds #ifdef CONFIG_SMP
8421da177e4SLinus Torvalds extern int set_cpus_allowed(task_t *p, cpumask_t new_mask);
8431da177e4SLinus Torvalds #else
8441da177e4SLinus Torvalds static inline int set_cpus_allowed(task_t *p, cpumask_t new_mask)
8451da177e4SLinus Torvalds {
8461da177e4SLinus Torvalds 	if (!cpus_intersects(new_mask, cpu_online_map))
8471da177e4SLinus Torvalds 		return -EINVAL;
8481da177e4SLinus Torvalds 	return 0;
8491da177e4SLinus Torvalds }
8501da177e4SLinus Torvalds #endif
8511da177e4SLinus Torvalds 
8521da177e4SLinus Torvalds extern unsigned long long sched_clock(void);
8531da177e4SLinus Torvalds extern unsigned long long current_sched_time(const task_t *current_task);
8541da177e4SLinus Torvalds 
8551da177e4SLinus Torvalds /* sched_exec is called by processes performing an exec */
8561da177e4SLinus Torvalds #ifdef CONFIG_SMP
8571da177e4SLinus Torvalds extern void sched_exec(void);
8581da177e4SLinus Torvalds #else
8591da177e4SLinus Torvalds #define sched_exec()   {}
8601da177e4SLinus Torvalds #endif
8611da177e4SLinus Torvalds 
8621da177e4SLinus Torvalds #ifdef CONFIG_HOTPLUG_CPU
8631da177e4SLinus Torvalds extern void idle_task_exit(void);
8641da177e4SLinus Torvalds #else
8651da177e4SLinus Torvalds static inline void idle_task_exit(void) {}
8661da177e4SLinus Torvalds #endif
8671da177e4SLinus Torvalds 
8681da177e4SLinus Torvalds extern void sched_idle_next(void);
8691da177e4SLinus Torvalds extern void set_user_nice(task_t *p, long nice);
8701da177e4SLinus Torvalds extern int task_prio(const task_t *p);
8711da177e4SLinus Torvalds extern int task_nice(const task_t *p);
872e43379f1SMatt Mackall extern int can_nice(const task_t *p, const int nice);
8731da177e4SLinus Torvalds extern int task_curr(const task_t *p);
8741da177e4SLinus Torvalds extern int idle_cpu(int cpu);
8751da177e4SLinus Torvalds extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
8761da177e4SLinus Torvalds extern task_t *idle_task(int cpu);
8771da177e4SLinus Torvalds 
8781da177e4SLinus Torvalds void yield(void);
8791da177e4SLinus Torvalds 
8801da177e4SLinus Torvalds /*
8811da177e4SLinus Torvalds  * The default (Linux) execution domain.
8821da177e4SLinus Torvalds  */
8831da177e4SLinus Torvalds extern struct exec_domain	default_exec_domain;
8841da177e4SLinus Torvalds 
8851da177e4SLinus Torvalds union thread_union {
8861da177e4SLinus Torvalds 	struct thread_info thread_info;
8871da177e4SLinus Torvalds 	unsigned long stack[THREAD_SIZE/sizeof(long)];
8881da177e4SLinus Torvalds };
8891da177e4SLinus Torvalds 
8901da177e4SLinus Torvalds #ifndef __HAVE_ARCH_KSTACK_END
8911da177e4SLinus Torvalds static inline int kstack_end(void *addr)
8921da177e4SLinus Torvalds {
8931da177e4SLinus Torvalds 	/* Reliable end of stack detection:
8941da177e4SLinus Torvalds 	 * Some APM bios versions misalign the stack
8951da177e4SLinus Torvalds 	 */
8961da177e4SLinus Torvalds 	return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
8971da177e4SLinus Torvalds }
8981da177e4SLinus Torvalds #endif
8991da177e4SLinus Torvalds 
9001da177e4SLinus Torvalds extern union thread_union init_thread_union;
9011da177e4SLinus Torvalds extern struct task_struct init_task;
9021da177e4SLinus Torvalds 
9031da177e4SLinus Torvalds extern struct   mm_struct init_mm;
9041da177e4SLinus Torvalds 
9051da177e4SLinus Torvalds #define find_task_by_pid(nr)	find_task_by_pid_type(PIDTYPE_PID, nr)
9061da177e4SLinus Torvalds extern struct task_struct *find_task_by_pid_type(int type, int pid);
9071da177e4SLinus Torvalds extern void set_special_pids(pid_t session, pid_t pgrp);
9081da177e4SLinus Torvalds extern void __set_special_pids(pid_t session, pid_t pgrp);
9091da177e4SLinus Torvalds 
9101da177e4SLinus Torvalds /* per-UID process charging. */
9111da177e4SLinus Torvalds extern struct user_struct * alloc_uid(uid_t);
9121da177e4SLinus Torvalds static inline struct user_struct *get_uid(struct user_struct *u)
9131da177e4SLinus Torvalds {
9141da177e4SLinus Torvalds 	atomic_inc(&u->__count);
9151da177e4SLinus Torvalds 	return u;
9161da177e4SLinus Torvalds }
9171da177e4SLinus Torvalds extern void free_uid(struct user_struct *);
9181da177e4SLinus Torvalds extern void switch_uid(struct user_struct *);
9191da177e4SLinus Torvalds 
9201da177e4SLinus Torvalds #include <asm/current.h>
9211da177e4SLinus Torvalds 
9221da177e4SLinus Torvalds extern void do_timer(struct pt_regs *);
9231da177e4SLinus Torvalds 
9241da177e4SLinus Torvalds extern int FASTCALL(wake_up_state(struct task_struct * tsk, unsigned int state));
9251da177e4SLinus Torvalds extern int FASTCALL(wake_up_process(struct task_struct * tsk));
9261da177e4SLinus Torvalds extern void FASTCALL(wake_up_new_task(struct task_struct * tsk,
9271da177e4SLinus Torvalds 						unsigned long clone_flags));
9281da177e4SLinus Torvalds #ifdef CONFIG_SMP
9291da177e4SLinus Torvalds  extern void kick_process(struct task_struct *tsk);
9301da177e4SLinus Torvalds #else
9311da177e4SLinus Torvalds  static inline void kick_process(struct task_struct *tsk) { }
9321da177e4SLinus Torvalds #endif
9331da177e4SLinus Torvalds extern void FASTCALL(sched_fork(task_t * p));
9341da177e4SLinus Torvalds extern void FASTCALL(sched_exit(task_t * p));
9351da177e4SLinus Torvalds 
9361da177e4SLinus Torvalds extern int in_group_p(gid_t);
9371da177e4SLinus Torvalds extern int in_egroup_p(gid_t);
9381da177e4SLinus Torvalds 
9391da177e4SLinus Torvalds extern void proc_caches_init(void);
9401da177e4SLinus Torvalds extern void flush_signals(struct task_struct *);
9411da177e4SLinus Torvalds extern void flush_signal_handlers(struct task_struct *, int force_default);
9421da177e4SLinus Torvalds extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
9431da177e4SLinus Torvalds 
9441da177e4SLinus Torvalds static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
9451da177e4SLinus Torvalds {
9461da177e4SLinus Torvalds 	unsigned long flags;
9471da177e4SLinus Torvalds 	int ret;
9481da177e4SLinus Torvalds 
9491da177e4SLinus Torvalds 	spin_lock_irqsave(&tsk->sighand->siglock, flags);
9501da177e4SLinus Torvalds 	ret = dequeue_signal(tsk, mask, info);
9511da177e4SLinus Torvalds 	spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
9521da177e4SLinus Torvalds 
9531da177e4SLinus Torvalds 	return ret;
9541da177e4SLinus Torvalds }
9551da177e4SLinus Torvalds 
9561da177e4SLinus Torvalds extern void block_all_signals(int (*notifier)(void *priv), void *priv,
9571da177e4SLinus Torvalds 			      sigset_t *mask);
9581da177e4SLinus Torvalds extern void unblock_all_signals(void);
9591da177e4SLinus Torvalds extern void release_task(struct task_struct * p);
9601da177e4SLinus Torvalds extern int send_sig_info(int, struct siginfo *, struct task_struct *);
9611da177e4SLinus Torvalds extern int send_group_sig_info(int, struct siginfo *, struct task_struct *);
9621da177e4SLinus Torvalds extern int force_sigsegv(int, struct task_struct *);
9631da177e4SLinus Torvalds extern int force_sig_info(int, struct siginfo *, struct task_struct *);
9641da177e4SLinus Torvalds extern int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp);
9651da177e4SLinus Torvalds extern int kill_pg_info(int, struct siginfo *, pid_t);
9661da177e4SLinus Torvalds extern int kill_proc_info(int, struct siginfo *, pid_t);
9671da177e4SLinus Torvalds extern void do_notify_parent(struct task_struct *, int);
9681da177e4SLinus Torvalds extern void force_sig(int, struct task_struct *);
9691da177e4SLinus Torvalds extern void force_sig_specific(int, struct task_struct *);
9701da177e4SLinus Torvalds extern int send_sig(int, struct task_struct *, int);
9711da177e4SLinus Torvalds extern void zap_other_threads(struct task_struct *p);
9721da177e4SLinus Torvalds extern int kill_pg(pid_t, int, int);
9731da177e4SLinus Torvalds extern int kill_sl(pid_t, int, int);
9741da177e4SLinus Torvalds extern int kill_proc(pid_t, int, int);
9751da177e4SLinus Torvalds extern struct sigqueue *sigqueue_alloc(void);
9761da177e4SLinus Torvalds extern void sigqueue_free(struct sigqueue *);
9771da177e4SLinus Torvalds extern int send_sigqueue(int, struct sigqueue *,  struct task_struct *);
9781da177e4SLinus Torvalds extern int send_group_sigqueue(int, struct sigqueue *,  struct task_struct *);
9791da177e4SLinus Torvalds extern int do_sigaction(int, const struct k_sigaction *, struct k_sigaction *);
9801da177e4SLinus Torvalds extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long);
9811da177e4SLinus Torvalds 
9821da177e4SLinus Torvalds /* These can be the second arg to send_sig_info/send_group_sig_info.  */
9831da177e4SLinus Torvalds #define SEND_SIG_NOINFO ((struct siginfo *) 0)
9841da177e4SLinus Torvalds #define SEND_SIG_PRIV	((struct siginfo *) 1)
9851da177e4SLinus Torvalds #define SEND_SIG_FORCED	((struct siginfo *) 2)
9861da177e4SLinus Torvalds 
9871da177e4SLinus Torvalds /* True if we are on the alternate signal stack.  */
9881da177e4SLinus Torvalds 
9891da177e4SLinus Torvalds static inline int on_sig_stack(unsigned long sp)
9901da177e4SLinus Torvalds {
9911da177e4SLinus Torvalds 	return (sp - current->sas_ss_sp < current->sas_ss_size);
9921da177e4SLinus Torvalds }
9931da177e4SLinus Torvalds 
9941da177e4SLinus Torvalds static inline int sas_ss_flags(unsigned long sp)
9951da177e4SLinus Torvalds {
9961da177e4SLinus Torvalds 	return (current->sas_ss_size == 0 ? SS_DISABLE
9971da177e4SLinus Torvalds 		: on_sig_stack(sp) ? SS_ONSTACK : 0);
9981da177e4SLinus Torvalds }
9991da177e4SLinus Torvalds 
10001da177e4SLinus Torvalds 
10011da177e4SLinus Torvalds #ifdef CONFIG_SECURITY
10021da177e4SLinus Torvalds /* code is in security.c */
10031da177e4SLinus Torvalds extern int capable(int cap);
10041da177e4SLinus Torvalds #else
10051da177e4SLinus Torvalds static inline int capable(int cap)
10061da177e4SLinus Torvalds {
10071da177e4SLinus Torvalds 	if (cap_raised(current->cap_effective, cap)) {
10081da177e4SLinus Torvalds 		current->flags |= PF_SUPERPRIV;
10091da177e4SLinus Torvalds 		return 1;
10101da177e4SLinus Torvalds 	}
10111da177e4SLinus Torvalds 	return 0;
10121da177e4SLinus Torvalds }
10131da177e4SLinus Torvalds #endif
10141da177e4SLinus Torvalds 
10151da177e4SLinus Torvalds /*
10161da177e4SLinus Torvalds  * Routines for handling mm_structs
10171da177e4SLinus Torvalds  */
10181da177e4SLinus Torvalds extern struct mm_struct * mm_alloc(void);
10191da177e4SLinus Torvalds 
10201da177e4SLinus Torvalds /* mmdrop drops the mm and the page tables */
10211da177e4SLinus Torvalds extern void FASTCALL(__mmdrop(struct mm_struct *));
10221da177e4SLinus Torvalds static inline void mmdrop(struct mm_struct * mm)
10231da177e4SLinus Torvalds {
10241da177e4SLinus Torvalds 	if (atomic_dec_and_test(&mm->mm_count))
10251da177e4SLinus Torvalds 		__mmdrop(mm);
10261da177e4SLinus Torvalds }
10271da177e4SLinus Torvalds 
10281da177e4SLinus Torvalds /* mmput gets rid of the mappings and all user-space */
10291da177e4SLinus Torvalds extern void mmput(struct mm_struct *);
10301da177e4SLinus Torvalds /* Grab a reference to a task's mm, if it is not already going away */
10311da177e4SLinus Torvalds extern struct mm_struct *get_task_mm(struct task_struct *task);
10321da177e4SLinus Torvalds /* Remove the current tasks stale references to the old mm_struct */
10331da177e4SLinus Torvalds extern void mm_release(struct task_struct *, struct mm_struct *);
10341da177e4SLinus Torvalds 
10351da177e4SLinus Torvalds extern int  copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
10361da177e4SLinus Torvalds extern void flush_thread(void);
10371da177e4SLinus Torvalds extern void exit_thread(void);
10381da177e4SLinus Torvalds 
10391da177e4SLinus Torvalds extern void exit_files(struct task_struct *);
10401da177e4SLinus Torvalds extern void exit_signal(struct task_struct *);
10411da177e4SLinus Torvalds extern void __exit_signal(struct task_struct *);
10421da177e4SLinus Torvalds extern void exit_sighand(struct task_struct *);
10431da177e4SLinus Torvalds extern void __exit_sighand(struct task_struct *);
10441da177e4SLinus Torvalds extern void exit_itimers(struct signal_struct *);
10451da177e4SLinus Torvalds 
10461da177e4SLinus Torvalds extern NORET_TYPE void do_group_exit(int);
10471da177e4SLinus Torvalds 
10481da177e4SLinus Torvalds extern void daemonize(const char *, ...);
10491da177e4SLinus Torvalds extern int allow_signal(int);
10501da177e4SLinus Torvalds extern int disallow_signal(int);
10511da177e4SLinus Torvalds extern task_t *child_reaper;
10521da177e4SLinus Torvalds 
10531da177e4SLinus Torvalds extern int do_execve(char *, char __user * __user *, char __user * __user *, struct pt_regs *);
10541da177e4SLinus Torvalds extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
10551da177e4SLinus Torvalds task_t *fork_idle(int);
10561da177e4SLinus Torvalds 
10571da177e4SLinus Torvalds extern void set_task_comm(struct task_struct *tsk, char *from);
10581da177e4SLinus Torvalds extern void get_task_comm(char *to, struct task_struct *tsk);
10591da177e4SLinus Torvalds 
10601da177e4SLinus Torvalds #ifdef CONFIG_SMP
10611da177e4SLinus Torvalds extern void wait_task_inactive(task_t * p);
10621da177e4SLinus Torvalds #else
10631da177e4SLinus Torvalds #define wait_task_inactive(p)	do { } while (0)
10641da177e4SLinus Torvalds #endif
10651da177e4SLinus Torvalds 
10661da177e4SLinus Torvalds #define remove_parent(p)	list_del_init(&(p)->sibling)
10671da177e4SLinus Torvalds #define add_parent(p, parent)	list_add_tail(&(p)->sibling,&(parent)->children)
10681da177e4SLinus Torvalds 
10691da177e4SLinus Torvalds #define REMOVE_LINKS(p) do {					\
10701da177e4SLinus Torvalds 	if (thread_group_leader(p))				\
10711da177e4SLinus Torvalds 		list_del_init(&(p)->tasks);			\
10721da177e4SLinus Torvalds 	remove_parent(p);					\
10731da177e4SLinus Torvalds 	} while (0)
10741da177e4SLinus Torvalds 
10751da177e4SLinus Torvalds #define SET_LINKS(p) do {					\
10761da177e4SLinus Torvalds 	if (thread_group_leader(p))				\
10771da177e4SLinus Torvalds 		list_add_tail(&(p)->tasks,&init_task.tasks);	\
10781da177e4SLinus Torvalds 	add_parent(p, (p)->parent);				\
10791da177e4SLinus Torvalds 	} while (0)
10801da177e4SLinus Torvalds 
10811da177e4SLinus Torvalds #define next_task(p)	list_entry((p)->tasks.next, struct task_struct, tasks)
10821da177e4SLinus Torvalds #define prev_task(p)	list_entry((p)->tasks.prev, struct task_struct, tasks)
10831da177e4SLinus Torvalds 
10841da177e4SLinus Torvalds #define for_each_process(p) \
10851da177e4SLinus Torvalds 	for (p = &init_task ; (p = next_task(p)) != &init_task ; )
10861da177e4SLinus Torvalds 
10871da177e4SLinus Torvalds /*
10881da177e4SLinus Torvalds  * Careful: do_each_thread/while_each_thread is a double loop so
10891da177e4SLinus Torvalds  *          'break' will not work as expected - use goto instead.
10901da177e4SLinus Torvalds  */
10911da177e4SLinus Torvalds #define do_each_thread(g, t) \
10921da177e4SLinus Torvalds 	for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
10931da177e4SLinus Torvalds 
10941da177e4SLinus Torvalds #define while_each_thread(g, t) \
10951da177e4SLinus Torvalds 	while ((t = next_thread(t)) != g)
10961da177e4SLinus Torvalds 
10971da177e4SLinus Torvalds extern task_t * FASTCALL(next_thread(const task_t *p));
10981da177e4SLinus Torvalds 
10991da177e4SLinus Torvalds #define thread_group_leader(p)	(p->pid == p->tgid)
11001da177e4SLinus Torvalds 
11011da177e4SLinus Torvalds static inline int thread_group_empty(task_t *p)
11021da177e4SLinus Torvalds {
11031da177e4SLinus Torvalds 	return list_empty(&p->pids[PIDTYPE_TGID].pid_list);
11041da177e4SLinus Torvalds }
11051da177e4SLinus Torvalds 
11061da177e4SLinus Torvalds #define delay_group_leader(p) \
11071da177e4SLinus Torvalds 		(thread_group_leader(p) && !thread_group_empty(p))
11081da177e4SLinus Torvalds 
11091da177e4SLinus Torvalds extern void unhash_process(struct task_struct *p);
11101da177e4SLinus Torvalds 
11111da177e4SLinus Torvalds /*
11121da177e4SLinus Torvalds  * Protects ->fs, ->files, ->mm, ->ptrace, ->group_info, ->comm, keyring
11131da177e4SLinus Torvalds  * subscriptions and synchronises with wait4().  Also used in procfs.
11141da177e4SLinus Torvalds  *
11151da177e4SLinus Torvalds  * Nests both inside and outside of read_lock(&tasklist_lock).
11161da177e4SLinus Torvalds  * It must not be nested with write_lock_irq(&tasklist_lock),
11171da177e4SLinus Torvalds  * neither inside nor outside.
11181da177e4SLinus Torvalds  */
11191da177e4SLinus Torvalds static inline void task_lock(struct task_struct *p)
11201da177e4SLinus Torvalds {
11211da177e4SLinus Torvalds 	spin_lock(&p->alloc_lock);
11221da177e4SLinus Torvalds }
11231da177e4SLinus Torvalds 
11241da177e4SLinus Torvalds static inline void task_unlock(struct task_struct *p)
11251da177e4SLinus Torvalds {
11261da177e4SLinus Torvalds 	spin_unlock(&p->alloc_lock);
11271da177e4SLinus Torvalds }
11281da177e4SLinus Torvalds 
11291da177e4SLinus Torvalds /* set thread flags in other task's structures
11301da177e4SLinus Torvalds  * - see asm/thread_info.h for TIF_xxxx flags available
11311da177e4SLinus Torvalds  */
11321da177e4SLinus Torvalds static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
11331da177e4SLinus Torvalds {
11341da177e4SLinus Torvalds 	set_ti_thread_flag(tsk->thread_info,flag);
11351da177e4SLinus Torvalds }
11361da177e4SLinus Torvalds 
11371da177e4SLinus Torvalds static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
11381da177e4SLinus Torvalds {
11391da177e4SLinus Torvalds 	clear_ti_thread_flag(tsk->thread_info,flag);
11401da177e4SLinus Torvalds }
11411da177e4SLinus Torvalds 
11421da177e4SLinus Torvalds static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
11431da177e4SLinus Torvalds {
11441da177e4SLinus Torvalds 	return test_and_set_ti_thread_flag(tsk->thread_info,flag);
11451da177e4SLinus Torvalds }
11461da177e4SLinus Torvalds 
11471da177e4SLinus Torvalds static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
11481da177e4SLinus Torvalds {
11491da177e4SLinus Torvalds 	return test_and_clear_ti_thread_flag(tsk->thread_info,flag);
11501da177e4SLinus Torvalds }
11511da177e4SLinus Torvalds 
11521da177e4SLinus Torvalds static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
11531da177e4SLinus Torvalds {
11541da177e4SLinus Torvalds 	return test_ti_thread_flag(tsk->thread_info,flag);
11551da177e4SLinus Torvalds }
11561da177e4SLinus Torvalds 
11571da177e4SLinus Torvalds static inline void set_tsk_need_resched(struct task_struct *tsk)
11581da177e4SLinus Torvalds {
11591da177e4SLinus Torvalds 	set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
11601da177e4SLinus Torvalds }
11611da177e4SLinus Torvalds 
11621da177e4SLinus Torvalds static inline void clear_tsk_need_resched(struct task_struct *tsk)
11631da177e4SLinus Torvalds {
11641da177e4SLinus Torvalds 	clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
11651da177e4SLinus Torvalds }
11661da177e4SLinus Torvalds 
11671da177e4SLinus Torvalds static inline int signal_pending(struct task_struct *p)
11681da177e4SLinus Torvalds {
11691da177e4SLinus Torvalds 	return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
11701da177e4SLinus Torvalds }
11711da177e4SLinus Torvalds 
11721da177e4SLinus Torvalds static inline int need_resched(void)
11731da177e4SLinus Torvalds {
11741da177e4SLinus Torvalds 	return unlikely(test_thread_flag(TIF_NEED_RESCHED));
11751da177e4SLinus Torvalds }
11761da177e4SLinus Torvalds 
11771da177e4SLinus Torvalds /*
11781da177e4SLinus Torvalds  * cond_resched() and cond_resched_lock(): latency reduction via
11791da177e4SLinus Torvalds  * explicit rescheduling in places that are safe. The return
11801da177e4SLinus Torvalds  * value indicates whether a reschedule was done in fact.
11811da177e4SLinus Torvalds  * cond_resched_lock() will drop the spinlock before scheduling,
11821da177e4SLinus Torvalds  * cond_resched_softirq() will enable bhs before scheduling.
11831da177e4SLinus Torvalds  */
11841da177e4SLinus Torvalds extern int cond_resched(void);
11851da177e4SLinus Torvalds extern int cond_resched_lock(spinlock_t * lock);
11861da177e4SLinus Torvalds extern int cond_resched_softirq(void);
11871da177e4SLinus Torvalds 
11881da177e4SLinus Torvalds /*
11891da177e4SLinus Torvalds  * Does a critical section need to be broken due to another
11901da177e4SLinus Torvalds  * task waiting?:
11911da177e4SLinus Torvalds  */
11921da177e4SLinus Torvalds #if defined(CONFIG_PREEMPT) && defined(CONFIG_SMP)
11931da177e4SLinus Torvalds # define need_lockbreak(lock) ((lock)->break_lock)
11941da177e4SLinus Torvalds #else
11951da177e4SLinus Torvalds # define need_lockbreak(lock) 0
11961da177e4SLinus Torvalds #endif
11971da177e4SLinus Torvalds 
11981da177e4SLinus Torvalds /*
11991da177e4SLinus Torvalds  * Does a critical section need to be broken due to another
12001da177e4SLinus Torvalds  * task waiting or preemption being signalled:
12011da177e4SLinus Torvalds  */
12021da177e4SLinus Torvalds static inline int lock_need_resched(spinlock_t *lock)
12031da177e4SLinus Torvalds {
12041da177e4SLinus Torvalds 	if (need_lockbreak(lock) || need_resched())
12051da177e4SLinus Torvalds 		return 1;
12061da177e4SLinus Torvalds 	return 0;
12071da177e4SLinus Torvalds }
12081da177e4SLinus Torvalds 
12091da177e4SLinus Torvalds /* Reevaluate whether the task has signals pending delivery.
12101da177e4SLinus Torvalds    This is required every time the blocked sigset_t changes.
12111da177e4SLinus Torvalds    callers must hold sighand->siglock.  */
12121da177e4SLinus Torvalds 
12131da177e4SLinus Torvalds extern FASTCALL(void recalc_sigpending_tsk(struct task_struct *t));
12141da177e4SLinus Torvalds extern void recalc_sigpending(void);
12151da177e4SLinus Torvalds 
12161da177e4SLinus Torvalds extern void signal_wake_up(struct task_struct *t, int resume_stopped);
12171da177e4SLinus Torvalds 
12181da177e4SLinus Torvalds /*
12191da177e4SLinus Torvalds  * Wrappers for p->thread_info->cpu access. No-op on UP.
12201da177e4SLinus Torvalds  */
12211da177e4SLinus Torvalds #ifdef CONFIG_SMP
12221da177e4SLinus Torvalds 
12231da177e4SLinus Torvalds static inline unsigned int task_cpu(const struct task_struct *p)
12241da177e4SLinus Torvalds {
12251da177e4SLinus Torvalds 	return p->thread_info->cpu;
12261da177e4SLinus Torvalds }
12271da177e4SLinus Torvalds 
12281da177e4SLinus Torvalds static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
12291da177e4SLinus Torvalds {
12301da177e4SLinus Torvalds 	p->thread_info->cpu = cpu;
12311da177e4SLinus Torvalds }
12321da177e4SLinus Torvalds 
12331da177e4SLinus Torvalds #else
12341da177e4SLinus Torvalds 
12351da177e4SLinus Torvalds static inline unsigned int task_cpu(const struct task_struct *p)
12361da177e4SLinus Torvalds {
12371da177e4SLinus Torvalds 	return 0;
12381da177e4SLinus Torvalds }
12391da177e4SLinus Torvalds 
12401da177e4SLinus Torvalds static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
12411da177e4SLinus Torvalds {
12421da177e4SLinus Torvalds }
12431da177e4SLinus Torvalds 
12441da177e4SLinus Torvalds #endif /* CONFIG_SMP */
12451da177e4SLinus Torvalds 
12461da177e4SLinus Torvalds #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
12471da177e4SLinus Torvalds extern void arch_pick_mmap_layout(struct mm_struct *mm);
12481da177e4SLinus Torvalds #else
12491da177e4SLinus Torvalds static inline void arch_pick_mmap_layout(struct mm_struct *mm)
12501da177e4SLinus Torvalds {
12511da177e4SLinus Torvalds 	mm->mmap_base = TASK_UNMAPPED_BASE;
12521da177e4SLinus Torvalds 	mm->get_unmapped_area = arch_get_unmapped_area;
12531da177e4SLinus Torvalds 	mm->unmap_area = arch_unmap_area;
12541da177e4SLinus Torvalds }
12551da177e4SLinus Torvalds #endif
12561da177e4SLinus Torvalds 
12571da177e4SLinus Torvalds extern long sched_setaffinity(pid_t pid, cpumask_t new_mask);
12581da177e4SLinus Torvalds extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
12591da177e4SLinus Torvalds 
12601da177e4SLinus Torvalds #ifdef CONFIG_MAGIC_SYSRQ
12611da177e4SLinus Torvalds 
12621da177e4SLinus Torvalds extern void normalize_rt_tasks(void);
12631da177e4SLinus Torvalds 
12641da177e4SLinus Torvalds #endif
12651da177e4SLinus Torvalds 
12661da177e4SLinus Torvalds /* try_to_freeze
12671da177e4SLinus Torvalds  *
12681da177e4SLinus Torvalds  * Checks whether we need to enter the refrigerator
12691da177e4SLinus Torvalds  * and returns 1 if we did so.
12701da177e4SLinus Torvalds  */
12711da177e4SLinus Torvalds #ifdef CONFIG_PM
12721da177e4SLinus Torvalds extern void refrigerator(unsigned long);
12731da177e4SLinus Torvalds extern int freeze_processes(void);
12741da177e4SLinus Torvalds extern void thaw_processes(void);
12751da177e4SLinus Torvalds 
12761da177e4SLinus Torvalds static inline int try_to_freeze(unsigned long refrigerator_flags)
12771da177e4SLinus Torvalds {
12781da177e4SLinus Torvalds 	if (unlikely(current->flags & PF_FREEZE)) {
12791da177e4SLinus Torvalds 		refrigerator(refrigerator_flags);
12801da177e4SLinus Torvalds 		return 1;
12811da177e4SLinus Torvalds 	} else
12821da177e4SLinus Torvalds 		return 0;
12831da177e4SLinus Torvalds }
12841da177e4SLinus Torvalds #else
12851da177e4SLinus Torvalds static inline void refrigerator(unsigned long flag) {}
12861da177e4SLinus Torvalds static inline int freeze_processes(void) { BUG(); return 0; }
12871da177e4SLinus Torvalds static inline void thaw_processes(void) {}
12881da177e4SLinus Torvalds 
12891da177e4SLinus Torvalds static inline int try_to_freeze(unsigned long refrigerator_flags)
12901da177e4SLinus Torvalds {
12911da177e4SLinus Torvalds 	return 0;
12921da177e4SLinus Torvalds }
12931da177e4SLinus Torvalds #endif /* CONFIG_PM */
12941da177e4SLinus Torvalds #endif /* __KERNEL__ */
12951da177e4SLinus Torvalds 
12961da177e4SLinus Torvalds #endif
1297