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