home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / sched.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-09  |  66.9 KB  |  2,306 lines
  1. #ifndef _LINUX_SCHED_H
  2. #define _LINUX_SCHED_H
  3.  
  4. /*
  5.  * cloning flags:
  6.  */
  7. #define CSIGNAL        0x000000ff    /* signal mask to be sent at exit */
  8. #define CLONE_VM    0x00000100    /* set if VM shared between processes */
  9. #define CLONE_FS    0x00000200    /* set if fs info shared between processes */
  10. #define CLONE_FILES    0x00000400    /* set if open files shared between processes */
  11. #define CLONE_SIGHAND    0x00000800    /* set if signal handlers and blocked signals shared */
  12. #define CLONE_PTRACE    0x00002000    /* set if we want to let tracing continue on the child too */
  13. #define CLONE_VFORK    0x00004000    /* set if the parent wants the child to wake it up on mm_release */
  14. #define CLONE_PARENT    0x00008000    /* set if we want to have the same parent as the cloner */
  15. #define CLONE_THREAD    0x00010000    /* Same thread group? */
  16. #define CLONE_NEWNS    0x00020000    /* New namespace group? */
  17. #define CLONE_SYSVSEM    0x00040000    /* share system V SEM_UNDO semantics */
  18. #define CLONE_SETTLS    0x00080000    /* create a new TLS for the child */
  19. #define CLONE_PARENT_SETTID    0x00100000    /* set the TID in the parent */
  20. #define CLONE_CHILD_CLEARTID    0x00200000    /* clear the TID in the child */
  21. #define CLONE_DETACHED        0x00400000    /* Unused, ignored */
  22. #define CLONE_UNTRACED        0x00800000    /* set if the tracing process can't force CLONE_PTRACE on this clone */
  23. #define CLONE_CHILD_SETTID    0x01000000    /* set the TID in the child */
  24. #define CLONE_STOPPED        0x02000000    /* Start in stopped state */
  25. #define CLONE_NEWUTS        0x04000000    /* New utsname group? */
  26. #define CLONE_NEWIPC        0x08000000    /* New ipcs */
  27. #define CLONE_NEWUSER        0x10000000    /* New user namespace */
  28. #define CLONE_NEWPID        0x20000000    /* New pid namespace */
  29. #define CLONE_NEWNET        0x40000000    /* New network namespace */
  30. #define CLONE_IO        0x80000000    /* Clone io context */
  31.  
  32. /*
  33.  * Scheduling policies
  34.  */
  35. #define SCHED_NORMAL        0
  36. #define SCHED_FIFO        1
  37. #define SCHED_RR        2
  38. #define SCHED_BATCH        3
  39. /* SCHED_ISO: reserved but not implemented yet */
  40. #define SCHED_IDLE        5
  41.  
  42. #ifdef __KERNEL__
  43.  
  44. struct sched_param {
  45.     int sched_priority;
  46. };
  47.  
  48. #include <asm/param.h>    /* for HZ */
  49.  
  50. #include <linux/capability.h>
  51. #include <linux/threads.h>
  52. #include <linux/kernel.h>
  53. #include <linux/types.h>
  54. #include <linux/timex.h>
  55. #include <linux/jiffies.h>
  56. #include <linux/rbtree.h>
  57. #include <linux/thread_info.h>
  58. #include <linux/cpumask.h>
  59. #include <linux/errno.h>
  60. #include <linux/nodemask.h>
  61. #include <linux/mm_types.h>
  62.  
  63. #include <asm/system.h>
  64. #include <asm/page.h>
  65. #include <asm/ptrace.h>
  66. #include <asm/cputime.h>
  67.  
  68. #include <linux/smp.h>
  69. #include <linux/sem.h>
  70. #include <linux/signal.h>
  71. #include <linux/fs_struct.h>
  72. #include <linux/compiler.h>
  73. #include <linux/completion.h>
  74. #include <linux/pid.h>
  75. #include <linux/percpu.h>
  76. #include <linux/topology.h>
  77. #include <linux/proportions.h>
  78. #include <linux/seccomp.h>
  79. #include <linux/rcupdate.h>
  80. #include <linux/rtmutex.h>
  81.  
  82. #include <linux/time.h>
  83. #include <linux/param.h>
  84. #include <linux/resource.h>
  85. #include <linux/timer.h>
  86. #include <linux/hrtimer.h>
  87. #include <linux/task_io_accounting.h>
  88. #include <linux/kobject.h>
  89. #include <linux/latencytop.h>
  90. #include <linux/cred.h>
  91.  
  92. #include <asm/processor.h>
  93.  
  94. struct mem_cgroup;
  95. struct exec_domain;
  96. struct futex_pi_state;
  97. struct robust_list_head;
  98. struct bio;
  99.  
  100. /*
  101.  * List of flags we want to share for kernel threads,
  102.  * if only because they are not used by them anyway.
  103.  */
  104. #define CLONE_KERNEL    (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
  105.  
  106. /*
  107.  * These are the constant used to fake the fixed-point load-average
  108.  * counting. Some notes:
  109.  *  - 11 bit fractions expand to 22 bits by the multiplies: this gives
  110.  *    a load-average precision of 10 bits integer + 11 bits fractional
  111.  *  - if you want to count load-averages more often, you need more
  112.  *    precision, or rounding will get you. With 2-second counting freq,
  113.  *    the EXP_n values would be 1981, 2034 and 2043 if still using only
  114.  *    11 bit fractions.
  115.  */
  116. extern unsigned long avenrun[];        /* Load averages */
  117.  
  118. #define FSHIFT        11        /* nr of bits of precision */
  119. #define FIXED_1        (1<<FSHIFT)    /* 1.0 as fixed-point */
  120. #define LOAD_FREQ    (5*HZ+1)    /* 5 sec intervals */
  121. #define EXP_1        1884        /* 1/exp(5sec/1min) as fixed-point */
  122. #define EXP_5        2014        /* 1/exp(5sec/5min) */
  123. #define EXP_15        2037        /* 1/exp(5sec/15min) */
  124.  
  125. #define CALC_LOAD(load,exp,n) \
  126.     load *= exp; \
  127.     load += n*(FIXED_1-exp); \
  128.     load >>= FSHIFT;
  129.  
  130. extern unsigned long total_forks;
  131. extern int nr_threads;
  132. DECLARE_PER_CPU(unsigned long, process_counts);
  133. extern int nr_processes(void);
  134. extern unsigned long nr_running(void);
  135. extern unsigned long nr_uninterruptible(void);
  136. extern unsigned long nr_active(void);
  137. extern unsigned long nr_iowait(void);
  138.  
  139. struct seq_file;
  140. struct cfs_rq;
  141. struct task_group;
  142. #ifdef CONFIG_SCHED_DEBUG
  143. extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
  144. extern void proc_sched_set_task(struct task_struct *p);
  145. extern void
  146. print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
  147. #else
  148. static inline void
  149. proc_sched_show_task(struct task_struct *p, struct seq_file *m)
  150. {
  151. }
  152. static inline void proc_sched_set_task(struct task_struct *p)
  153. {
  154. }
  155. static inline void
  156. print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
  157. {
  158. }
  159. #endif
  160.  
  161. extern unsigned long long time_sync_thresh;
  162.  
  163. /*
  164.  * Task state bitmask. NOTE! These bits are also
  165.  * encoded in fs/proc/array.c: get_task_state().
  166.  *
  167.  * We have two separate sets of flags: task->state
  168.  * is about runnability, while task->exit_state are
  169.  * about the task exiting. Confusing, but this way
  170.  * modifying one set can't modify the other one by
  171.  * mistake.
  172.  */
  173. #define TASK_RUNNING        0
  174. #define TASK_INTERRUPTIBLE    1
  175. #define TASK_UNINTERRUPTIBLE    2
  176. #define __TASK_STOPPED        4
  177. #define __TASK_TRACED        8
  178. /* in tsk->exit_state */
  179. #define EXIT_ZOMBIE        16
  180. #define EXIT_DEAD        32
  181. /* in tsk->state again */
  182. #define TASK_DEAD        64
  183. #define TASK_WAKEKILL        128
  184.  
  185. /* Convenience macros for the sake of set_task_state */
  186. #define TASK_KILLABLE        (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
  187. #define TASK_STOPPED        (TASK_WAKEKILL | __TASK_STOPPED)
  188. #define TASK_TRACED        (TASK_WAKEKILL | __TASK_TRACED)
  189.  
  190. /* Convenience macros for the sake of wake_up */
  191. #define TASK_NORMAL        (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
  192. #define TASK_ALL        (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
  193.  
  194. /* get_task_state() */
  195. #define TASK_REPORT        (TASK_RUNNING | TASK_INTERRUPTIBLE | \
  196.                  TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
  197.                  __TASK_TRACED)
  198.  
  199. #define task_is_traced(task)    ((task->state & __TASK_TRACED) != 0)
  200. #define task_is_stopped(task)    ((task->state & __TASK_STOPPED) != 0)
  201. #define task_is_stopped_or_traced(task)    \
  202.             ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
  203. #define task_contributes_to_load(task)    \
  204.                 ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
  205.                  (task->flags & PF_FROZEN) == 0)
  206.  
  207. #define __set_task_state(tsk, state_value)        \
  208.     do { (tsk)->state = (state_value); } while (0)
  209. #define set_task_state(tsk, state_value)        \
  210.     set_mb((tsk)->state, (state_value))
  211.  
  212. /*
  213.  * set_current_state() includes a barrier so that the write of current->state
  214.  * is correctly serialised wrt the caller's subsequent test of whether to
  215.  * actually sleep:
  216.  *
  217.  *    set_current_state(TASK_UNINTERRUPTIBLE);
  218.  *    if (do_i_need_to_sleep())
  219.  *        schedule();
  220.  *
  221.  * If the caller does not need such serialisation then use __set_current_state()
  222.  */
  223. #define __set_current_state(state_value)            \
  224.     do { current->state = (state_value); } while (0)
  225. #define set_current_state(state_value)        \
  226.     set_mb(current->state, (state_value))
  227.  
  228. /* Task command name length */
  229. #define TASK_COMM_LEN 16
  230.  
  231. #include <linux/spinlock.h>
  232.  
  233. /*
  234.  * This serializes "schedule()" and also protects
  235.  * the run-queue from deletions/modifications (but
  236.  * _adding_ to the beginning of the run-queue has
  237.  * a separate lock).
  238.  */
  239. extern rwlock_t tasklist_lock;
  240. extern spinlock_t mmlist_lock;
  241.  
  242. struct task_struct;
  243.  
  244. extern void sched_init(void);
  245. extern void sched_init_smp(void);
  246. extern asmlinkage void schedule_tail(struct task_struct *prev);
  247. extern void init_idle(struct task_struct *idle, int cpu);
  248. extern void init_idle_bootup_task(struct task_struct *idle);
  249.  
  250. extern int runqueue_is_locked(void);
  251. extern void task_rq_unlock_wait(struct task_struct *p);
  252.  
  253. extern cpumask_t nohz_cpu_mask;
  254. #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ)
  255. extern int select_nohz_load_balancer(int cpu);
  256. #else
  257. static inline int select_nohz_load_balancer(int cpu)
  258. {
  259.     return 0;
  260. }
  261. #endif
  262.  
  263. extern unsigned long rt_needs_cpu(int cpu);
  264.  
  265. /*
  266.  * Only dump TASK_* tasks. (0 for all tasks)
  267.  */
  268. extern void show_state_filter(unsigned long state_filter);
  269.  
  270. static inline void show_state(void)
  271. {
  272.     show_state_filter(0);
  273. }
  274.  
  275. extern void show_regs(struct pt_regs *);
  276.  
  277. /*
  278.  * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
  279.  * task), SP is the stack pointer of the first frame that should be shown in the back
  280.  * trace (or NULL if the entire call-chain of the task should be shown).
  281.  */
  282. extern void show_stack(struct task_struct *task, unsigned long *sp);
  283.  
  284. void io_schedule(void);
  285. long io_schedule_timeout(long timeout);
  286.  
  287. extern void cpu_init (void);
  288. extern void trap_init(void);
  289. extern void account_process_tick(struct task_struct *task, int user);
  290. extern void update_process_times(int user);
  291. extern void scheduler_tick(void);
  292.  
  293. extern void sched_show_task(struct task_struct *p);
  294.  
  295. #ifdef CONFIG_DETECT_SOFTLOCKUP
  296. extern void softlockup_tick(void);
  297. extern void touch_softlockup_watchdog(void);
  298. extern void touch_all_softlockup_watchdogs(void);
  299. extern unsigned int  softlockup_panic;
  300. extern unsigned long sysctl_hung_task_check_count;
  301. extern unsigned long sysctl_hung_task_timeout_secs;
  302. extern unsigned long sysctl_hung_task_warnings;
  303. extern int softlockup_thresh;
  304. #else
  305. static inline void softlockup_tick(void)
  306. {
  307. }
  308. static inline void spawn_softlockup_task(void)
  309. {
  310. }
  311. static inline void touch_softlockup_watchdog(void)
  312. {
  313. }
  314. static inline void touch_all_softlockup_watchdogs(void)
  315. {
  316. }
  317. #endif
  318.  
  319.  
  320. /* Attach to any functions which should be ignored in wchan output. */
  321. #define __sched        __attribute__((__section__(".sched.text")))
  322.  
  323. /* Linker adds these: start and end of __sched functions */
  324. extern char __sched_text_start[], __sched_text_end[];
  325.  
  326. /* Is this address in the __sched functions? */
  327. extern int in_sched_functions(unsigned long addr);
  328.  
  329. #define    MAX_SCHEDULE_TIMEOUT    LONG_MAX
  330. extern signed long schedule_timeout(signed long timeout);
  331. extern signed long schedule_timeout_interruptible(signed long timeout);
  332. extern signed long schedule_timeout_killable(signed long timeout);
  333. extern signed long schedule_timeout_uninterruptible(signed long timeout);
  334. asmlinkage void schedule(void);
  335.  
  336. struct nsproxy;
  337. struct user_namespace;
  338.  
  339. /* Maximum number of active map areas.. This is a random (large) number */
  340. #define DEFAULT_MAX_MAP_COUNT    65536
  341.  
  342. extern int sysctl_max_map_count;
  343.  
  344. #include <linux/aio.h>
  345.  
  346. extern unsigned long
  347. arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
  348.                unsigned long, unsigned long);
  349. extern unsigned long
  350. arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
  351.               unsigned long len, unsigned long pgoff,
  352.               unsigned long flags);
  353. extern void arch_unmap_area(struct mm_struct *, unsigned long);
  354. extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
  355.  
  356. #if USE_SPLIT_PTLOCKS
  357. /*
  358.  * The mm counters are not protected by its page_table_lock,
  359.  * so must be incremented atomically.
  360.  */
  361. #define set_mm_counter(mm, member, value) atomic_long_set(&(mm)->_##member, value)
  362. #define get_mm_counter(mm, member) ((unsigned long)atomic_long_read(&(mm)->_##member))
  363. #define add_mm_counter(mm, member, value) atomic_long_add(value, &(mm)->_##member)
  364. #define inc_mm_counter(mm, member) atomic_long_inc(&(mm)->_##member)
  365. #define dec_mm_counter(mm, member) atomic_long_dec(&(mm)->_##member)
  366.  
  367. #else  /* !USE_SPLIT_PTLOCKS */
  368. /*
  369.  * The mm counters are protected by its page_table_lock,
  370.  * so can be incremented directly.
  371.  */
  372. #define set_mm_counter(mm, member, value) (mm)->_##member = (value)
  373. #define get_mm_counter(mm, member) ((mm)->_##member)
  374. #define add_mm_counter(mm, member, value) (mm)->_##member += (value)
  375. #define inc_mm_counter(mm, member) (mm)->_##member++
  376. #define dec_mm_counter(mm, member) (mm)->_##member--
  377.  
  378. #endif /* !USE_SPLIT_PTLOCKS */
  379.  
  380. #define get_mm_rss(mm)                    \
  381.     (get_mm_counter(mm, file_rss) + get_mm_counter(mm, anon_rss))
  382. #define update_hiwater_rss(mm)    do {            \
  383.     unsigned long _rss = get_mm_rss(mm);        \
  384.     if ((mm)->hiwater_rss < _rss)            \
  385.         (mm)->hiwater_rss = _rss;        \
  386. } while (0)
  387. #define update_hiwater_vm(mm)    do {            \
  388.     if ((mm)->hiwater_vm < (mm)->total_vm)        \
  389.         (mm)->hiwater_vm = (mm)->total_vm;    \
  390. } while (0)
  391.  
  392. extern void set_dumpable(struct mm_struct *mm, int value);
  393. extern int get_dumpable(struct mm_struct *mm);
  394.  
  395. /* mm flags */
  396. /* dumpable bits */
  397. #define MMF_DUMPABLE      0  /* core dump is permitted */
  398. #define MMF_DUMP_SECURELY 1  /* core file is readable only by root */
  399. #define MMF_DUMPABLE_BITS 2
  400.  
  401. /* coredump filter bits */
  402. #define MMF_DUMP_ANON_PRIVATE    2
  403. #define MMF_DUMP_ANON_SHARED    3
  404. #define MMF_DUMP_MAPPED_PRIVATE    4
  405. #define MMF_DUMP_MAPPED_SHARED    5
  406. #define MMF_DUMP_ELF_HEADERS    6
  407. #define MMF_DUMP_HUGETLB_PRIVATE 7
  408. #define MMF_DUMP_HUGETLB_SHARED  8
  409. #define MMF_DUMP_FILTER_SHIFT    MMF_DUMPABLE_BITS
  410. #define MMF_DUMP_FILTER_BITS    7
  411. #define MMF_DUMP_FILTER_MASK \
  412.     (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
  413. #define MMF_DUMP_FILTER_DEFAULT \
  414.     ((1 << MMF_DUMP_ANON_PRIVATE) |    (1 << MMF_DUMP_ANON_SHARED) |\
  415.      (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)
  416.  
  417. #ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS
  418. # define MMF_DUMP_MASK_DEFAULT_ELF    (1 << MMF_DUMP_ELF_HEADERS)
  419. #else
  420. # define MMF_DUMP_MASK_DEFAULT_ELF    0
  421. #endif
  422.  
  423. struct sighand_struct {
  424.     atomic_t        count;
  425.     struct k_sigaction    action[_NSIG];
  426.     spinlock_t        siglock;
  427.     wait_queue_head_t    signalfd_wqh;
  428. };
  429.  
  430. struct pacct_struct {
  431.     int            ac_flag;
  432.     long            ac_exitcode;
  433.     unsigned long        ac_mem;
  434.     cputime_t        ac_utime, ac_stime;
  435.     unsigned long        ac_minflt, ac_majflt;
  436. };
  437.  
  438. /**
  439.  * struct task_cputime - collected CPU time counts
  440.  * @utime:        time spent in user mode, in &cputime_t units
  441.  * @stime:        time spent in kernel mode, in &cputime_t units
  442.  * @sum_exec_runtime:    total time spent on the CPU, in nanoseconds
  443.  *
  444.  * This structure groups together three kinds of CPU time that are
  445.  * tracked for threads and thread groups.  Most things considering
  446.  * CPU time want to group these counts together and treat all three
  447.  * of them in parallel.
  448.  */
  449. struct task_cputime {
  450.     cputime_t utime;
  451.     cputime_t stime;
  452.     unsigned long long sum_exec_runtime;
  453. };
  454. /* Alternate field names when used to cache expirations. */
  455. #define prof_exp    stime
  456. #define virt_exp    utime
  457. #define sched_exp    sum_exec_runtime
  458.  
  459. /**
  460.  * struct thread_group_cputime - thread group interval timer counts
  461.  * @totals:        thread group interval timers; substructure for
  462.  *            uniprocessor kernel, per-cpu for SMP kernel.
  463.  *
  464.  * This structure contains the version of task_cputime, above, that is
  465.  * used for thread group CPU clock calculations.
  466.  */
  467. struct thread_group_cputime {
  468.     struct task_cputime *totals;
  469. };
  470.  
  471. /*
  472.  * NOTE! "signal_struct" does not have it's own
  473.  * locking, because a shared signal_struct always
  474.  * implies a shared sighand_struct, so locking
  475.  * sighand_struct is always a proper superset of
  476.  * the locking of signal_struct.
  477.  */
  478. struct signal_struct {
  479.     atomic_t        count;
  480.     atomic_t        live;
  481.  
  482.     wait_queue_head_t    wait_chldexit;    /* for wait4() */
  483.  
  484.     /* current thread group signal load-balancing target: */
  485.     struct task_struct    *curr_target;
  486.  
  487.     /* shared signal handling: */
  488.     struct sigpending    shared_pending;
  489.  
  490.     /* thread group exit support */
  491.     int            group_exit_code;
  492.     /* overloaded:
  493.      * - notify group_exit_task when ->count is equal to notify_count
  494.      * - everyone except group_exit_task is stopped during signal delivery
  495.      *   of fatal signals, group_exit_task processes the signal.
  496.      */
  497.     int            notify_count;
  498.     struct task_struct    *group_exit_task;
  499.  
  500.     /* thread group stop support, overloads group_exit_code too */
  501.     int            group_stop_count;
  502.     unsigned int        flags; /* see SIGNAL_* flags below */
  503.  
  504.     /* POSIX.1b Interval Timers */
  505.     struct list_head posix_timers;
  506.  
  507.     /* ITIMER_REAL timer for the process */
  508.     struct hrtimer real_timer;
  509.     struct pid *leader_pid;
  510.     ktime_t it_real_incr;
  511.  
  512.     /* ITIMER_PROF and ITIMER_VIRTUAL timers for the process */
  513.     cputime_t it_prof_expires, it_virt_expires;
  514.     cputime_t it_prof_incr, it_virt_incr;
  515.  
  516.     /*
  517.      * Thread group totals for process CPU clocks.
  518.      * See thread_group_cputime(), et al, for details.
  519.      */
  520.     struct thread_group_cputime cputime;
  521.  
  522.     /* Earliest-expiration cache. */
  523.     struct task_cputime cputime_expires;
  524.  
  525.     struct list_head cpu_timers[3];
  526.  
  527.     /* job control IDs */
  528.  
  529.     /*
  530.      * pgrp and session fields are deprecated.
  531.      * use the task_session_Xnr and task_pgrp_Xnr routines below
  532.      */
  533.  
  534.     union {
  535.         pid_t pgrp __deprecated;
  536.         pid_t __pgrp;
  537.     };
  538.  
  539.     struct pid *tty_old_pgrp;
  540.  
  541.     union {
  542.         pid_t session __deprecated;
  543.         pid_t __session;
  544.     };
  545.  
  546.     /* boolean value for session group leader */
  547.     int leader;
  548.  
  549.     struct tty_struct *tty; /* NULL if no tty */
  550.  
  551.     /*
  552.      * Cumulative resource counters for dead threads in the group,
  553.      * and for reaped dead child processes forked by this group.
  554.      * Live threads maintain their own counters and add to these
  555.      * in __exit_signal, except for the group leader.
  556.      */
  557.     cputime_t cutime, cstime;
  558.     cputime_t gtime;
  559.     cputime_t cgtime;
  560.     unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
  561.     unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
  562.     unsigned long inblock, oublock, cinblock, coublock;
  563.     struct task_io_accounting ioac;
  564.  
  565.     /*
  566.      * We don't bother to synchronize most readers of this at all,
  567.      * because there is no reader checking a limit that actually needs
  568.      * to get both rlim_cur and rlim_max atomically, and either one
  569.      * alone is a single word that can safely be read normally.
  570.      * getrlimit/setrlimit use task_lock(current->group_leader) to
  571.      * protect this instead of the siglock, because they really
  572.      * have no need to disable irqs.
  573.      */
  574.     struct rlimit rlim[RLIM_NLIMITS];
  575.  
  576.     /* keep the process-shared keyrings here so that they do the right
  577.      * thing in threads created with CLONE_THREAD */
  578. #ifdef CONFIG_KEYS
  579.     struct key *session_keyring;    /* keyring inherited over fork */
  580.     struct key *process_keyring;    /* keyring private to this process */
  581. #endif
  582. #ifdef CONFIG_BSD_PROCESS_ACCT
  583.     struct pacct_struct pacct;    /* per-process accounting information */
  584. #endif
  585. #ifdef CONFIG_TASKSTATS
  586.     struct taskstats *stats;
  587. #endif
  588. #ifdef CONFIG_AUDIT
  589.     unsigned audit_tty;
  590.     struct tty_audit_buf *tty_audit_buf;
  591. #endif
  592. };
  593.  
  594. /* Context switch must be unlocked if interrupts are to be enabled */
  595. #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
  596. # define __ARCH_WANT_UNLOCKED_CTXSW
  597. #endif
  598.  
  599. /*
  600.  * Bits in flags field of signal_struct.
  601.  */
  602. #define SIGNAL_STOP_STOPPED    0x00000001 /* job control stop in effect */
  603. #define SIGNAL_STOP_DEQUEUED    0x00000002 /* stop signal dequeued */
  604. #define SIGNAL_STOP_CONTINUED    0x00000004 /* SIGCONT since WCONTINUED reap */
  605. #define SIGNAL_GROUP_EXIT    0x00000008 /* group exit in progress */
  606. /*
  607.  * Pending notifications to parent.
  608.  */
  609. #define SIGNAL_CLD_STOPPED    0x00000010
  610. #define SIGNAL_CLD_CONTINUED    0x00000020
  611. #define SIGNAL_CLD_MASK        (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
  612.  
  613. #define SIGNAL_UNKILLABLE    0x00000040 /* for init: ignore fatal signals */
  614.  
  615. /* If true, all threads except ->group_exit_task have pending SIGKILL */
  616. static inline int signal_group_exit(const struct signal_struct *sig)
  617. {
  618.     return    (sig->flags & SIGNAL_GROUP_EXIT) ||
  619.         (sig->group_exit_task != NULL);
  620. }
  621.  
  622. /*
  623.  * Some day this will be a full-fledged user tracking system..
  624.  */
  625. struct user_struct {
  626.     atomic_t __count;    /* reference count */
  627.     atomic_t processes;    /* How many processes does this user have? */
  628.     atomic_t files;        /* How many open files does this user have? */
  629.     atomic_t sigpending;    /* How many pending signals does this user have? */
  630. #ifdef CONFIG_INOTIFY_USER
  631.     atomic_t inotify_watches; /* How many inotify watches does this user have? */
  632.     atomic_t inotify_devs;    /* How many inotify devs does this user have opened? */
  633. #endif
  634. #ifdef CONFIG_EPOLL
  635.     atomic_t epoll_watches;    /* The number of file descriptors currently watched */
  636. #endif
  637. #ifdef CONFIG_POSIX_MQUEUE
  638.     /* protected by mq_lock    */
  639.     unsigned long mq_bytes;    /* How many bytes can be allocated to mqueue? */
  640. #endif
  641.     unsigned long locked_shm; /* How many pages of mlocked shm ? */
  642.  
  643. #ifdef CONFIG_KEYS
  644.     struct key *uid_keyring;    /* UID specific keyring */
  645.     struct key *session_keyring;    /* UID's default session keyring */
  646. #endif
  647.  
  648.     /* Hash table maintenance information */
  649.     struct hlist_node uidhash_node;
  650.     uid_t uid;
  651.  
  652. #ifdef CONFIG_USER_SCHED
  653.     struct task_group *tg;
  654. #ifdef CONFIG_SYSFS
  655.     struct kobject kobj;
  656.     struct work_struct work;
  657. #endif
  658. #endif
  659. };
  660.  
  661. extern int uids_sysfs_init(void);
  662.  
  663. extern struct user_struct *find_user(uid_t);
  664.  
  665. extern struct user_struct root_user;
  666. #define INIT_USER (&root_user)
  667.  
  668. struct backing_dev_info;
  669. struct reclaim_state;
  670.  
  671. #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
  672. struct sched_info {
  673.     /* cumulative counters */
  674.     unsigned long pcount;          /* # of times run on this cpu */
  675.     unsigned long long cpu_time,  /* time spent on the cpu */
  676.                run_delay; /* time spent waiting on a runqueue */
  677.  
  678.     /* timestamps */
  679.     unsigned long long last_arrival,/* when we last ran on a cpu */
  680.                last_queued;    /* when we were last queued to run */
  681. #ifdef CONFIG_SCHEDSTATS
  682.     /* BKL stats */
  683.     unsigned int bkl_count;
  684. #endif
  685. };
  686. #endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
  687.  
  688. #ifdef CONFIG_TASK_DELAY_ACCT
  689. struct task_delay_info {
  690.     spinlock_t    lock;
  691.     unsigned int    flags;    /* Private per-task flags */
  692.  
  693.     /* For each stat XXX, add following, aligned appropriately
  694.      *
  695.      * struct timespec XXX_start, XXX_end;
  696.      * u64 XXX_delay;
  697.      * u32 XXX_count;
  698.      *
  699.      * Atomicity of updates to XXX_delay, XXX_count protected by
  700.      * single lock above (split into XXX_lock if contention is an issue).
  701.      */
  702.  
  703.     /*
  704.      * XXX_count is incremented on every XXX operation, the delay
  705.      * associated with the operation is added to XXX_delay.
  706.      * XXX_delay contains the accumulated delay time in nanoseconds.
  707.      */
  708.     struct timespec blkio_start, blkio_end;    /* Shared by blkio, swapin */
  709.     u64 blkio_delay;    /* wait for sync block io completion */
  710.     u64 swapin_delay;    /* wait for swapin block io completion */
  711.     u32 blkio_count;    /* total count of the number of sync block */
  712.                 /* io operations performed */
  713.     u32 swapin_count;    /* total count of the number of swapin block */
  714.                 /* io operations performed */
  715.  
  716.     struct timespec freepages_start, freepages_end;
  717.     u64 freepages_delay;    /* wait for memory reclaim */
  718.     u32 freepages_count;    /* total count of memory reclaim */
  719. };
  720. #endif    /* CONFIG_TASK_DELAY_ACCT */
  721.  
  722. static inline int sched_info_on(void)
  723. {
  724. #ifdef CONFIG_SCHEDSTATS
  725.     return 1;
  726. #elif defined(CONFIG_TASK_DELAY_ACCT)
  727.     extern int delayacct_on;
  728.     return delayacct_on;
  729. #else
  730.     return 0;
  731. #endif
  732. }
  733.  
  734. enum cpu_idle_type {
  735.     CPU_IDLE,
  736.     CPU_NOT_IDLE,
  737.     CPU_NEWLY_IDLE,
  738.     CPU_MAX_IDLE_TYPES
  739. };
  740.  
  741. /*
  742.  * sched-domains (multiprocessor balancing) declarations:
  743.  */
  744.  
  745. /*
  746.  * Increase resolution of nice-level calculations:
  747.  */
  748. #define SCHED_LOAD_SHIFT    10
  749. #define SCHED_LOAD_SCALE    (1L << SCHED_LOAD_SHIFT)
  750.  
  751. #define SCHED_LOAD_SCALE_FUZZ    SCHED_LOAD_SCALE
  752.  
  753. #ifdef CONFIG_SMP
  754. #define SD_LOAD_BALANCE        1    /* Do load balancing on this domain. */
  755. #define SD_BALANCE_NEWIDLE    2    /* Balance when about to become idle */
  756. #define SD_BALANCE_EXEC        4    /* Balance on exec */
  757. #define SD_BALANCE_FORK        8    /* Balance on fork, clone */
  758. #define SD_WAKE_IDLE        16    /* Wake to idle CPU on task wakeup */
  759. #define SD_WAKE_AFFINE        32    /* Wake task to waking CPU */
  760. #define SD_WAKE_BALANCE        64    /* Perform balancing at task wakeup */
  761. #define SD_SHARE_CPUPOWER    128    /* Domain members share cpu power */
  762. #define SD_POWERSAVINGS_BALANCE    256    /* Balance for power savings */
  763. #define SD_SHARE_PKG_RESOURCES    512    /* Domain members share cpu pkg resources */
  764. #define SD_SERIALIZE        1024    /* Only a single load balancing instance */
  765. #define SD_WAKE_IDLE_FAR    2048    /* Gain latency sacrificing cache hit */
  766.  
  767. #define BALANCE_FOR_MC_POWER    \
  768.     (sched_smt_power_savings ? SD_POWERSAVINGS_BALANCE : 0)
  769.  
  770. #define BALANCE_FOR_PKG_POWER    \
  771.     ((sched_mc_power_savings || sched_smt_power_savings) ?    \
  772.      SD_POWERSAVINGS_BALANCE : 0)
  773.  
  774. #define test_sd_parent(sd, flag)    ((sd->parent &&        \
  775.                      (sd->parent->flags & flag)) ? 1 : 0)
  776.  
  777.  
  778. struct sched_group {
  779.     struct sched_group *next;    /* Must be a circular list */
  780.     cpumask_t cpumask;
  781.  
  782.     /*
  783.      * CPU power of this group, SCHED_LOAD_SCALE being max power for a
  784.      * single CPU. This is read only (except for setup, hotplug CPU).
  785.      * Note : Never change cpu_power without recompute its reciprocal
  786.      */
  787.     unsigned int __cpu_power;
  788.     /*
  789.      * reciprocal value of cpu_power to avoid expensive divides
  790.      * (see include/linux/reciprocal_div.h)
  791.      */
  792.     u32 reciprocal_cpu_power;
  793. };
  794.  
  795. enum sched_domain_level {
  796.     SD_LV_NONE = 0,
  797.     SD_LV_SIBLING,
  798.     SD_LV_MC,
  799.     SD_LV_CPU,
  800.     SD_LV_NODE,
  801.     SD_LV_ALLNODES,
  802.     SD_LV_MAX
  803. };
  804.  
  805. struct sched_domain_attr {
  806.     int relax_domain_level;
  807. };
  808.  
  809. #define SD_ATTR_INIT    (struct sched_domain_attr) {    \
  810.     .relax_domain_level = -1,            \
  811. }
  812.  
  813. struct sched_domain {
  814.     /* These fields must be setup */
  815.     struct sched_domain *parent;    /* top domain must be null terminated */
  816.     struct sched_domain *child;    /* bottom domain must be null terminated */
  817.     struct sched_group *groups;    /* the balancing groups of the domain */
  818.     cpumask_t span;            /* span of all CPUs in this domain */
  819.     unsigned long min_interval;    /* Minimum balance interval ms */
  820.     unsigned long max_interval;    /* Maximum balance interval ms */
  821.     unsigned int busy_factor;    /* less balancing by factor if busy */
  822.     unsigned int imbalance_pct;    /* No balance until over watermark */
  823.     unsigned int cache_nice_tries;    /* Leave cache hot tasks for # tries */
  824.     unsigned int busy_idx;
  825.     unsigned int idle_idx;
  826.     unsigned int newidle_idx;
  827.     unsigned int wake_idx;
  828.     unsigned int forkexec_idx;
  829.     int flags;            /* See SD_* */
  830.     enum sched_domain_level level;
  831.  
  832.     /* Runtime fields. */
  833.     unsigned long last_balance;    /* init to jiffies. units in jiffies */
  834.     unsigned int balance_interval;    /* initialise to 1. units in ms. */
  835.     unsigned int nr_balance_failed; /* initialise to 0 */
  836.  
  837.     u64 last_update;
  838.  
  839. #ifdef CONFIG_SCHEDSTATS
  840.     /* load_balance() stats */
  841.     unsigned int lb_count[CPU_MAX_IDLE_TYPES];
  842.     unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
  843.     unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
  844.     unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
  845.     unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
  846.     unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
  847.     unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
  848.     unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
  849.  
  850.     /* Active load balancing */
  851.     unsigned int alb_count;
  852.     unsigned int alb_failed;
  853.     unsigned int alb_pushed;
  854.  
  855.     /* SD_BALANCE_EXEC stats */
  856.     unsigned int sbe_count;
  857.     unsigned int sbe_balanced;
  858.     unsigned int sbe_pushed;
  859.  
  860.     /* SD_BALANCE_FORK stats */
  861.     unsigned int sbf_count;
  862.     unsigned int sbf_balanced;
  863.     unsigned int sbf_pushed;
  864.  
  865.     /* try_to_wake_up() stats */
  866.     unsigned int ttwu_wake_remote;
  867.     unsigned int ttwu_move_affine;
  868.     unsigned int ttwu_move_balance;
  869. #endif
  870. #ifdef CONFIG_SCHED_DEBUG
  871.     char *name;
  872. #endif
  873. };
  874.  
  875. extern void partition_sched_domains(int ndoms_new, cpumask_t *doms_new,
  876.                     struct sched_domain_attr *dattr_new);
  877. extern int arch_reinit_sched_domains(void);
  878.  
  879. #else /* CONFIG_SMP */
  880.  
  881. struct sched_domain_attr;
  882.  
  883. static inline void
  884. partition_sched_domains(int ndoms_new, cpumask_t *doms_new,
  885.             struct sched_domain_attr *dattr_new)
  886. {
  887. }
  888. #endif    /* !CONFIG_SMP */
  889.  
  890. struct io_context;            /* See blkdev.h */
  891. #define NGROUPS_SMALL        32
  892. #define NGROUPS_PER_BLOCK    ((unsigned int)(PAGE_SIZE / sizeof(gid_t)))
  893. struct group_info {
  894.     int ngroups;
  895.     atomic_t usage;
  896.     gid_t small_block[NGROUPS_SMALL];
  897.     int nblocks;
  898.     gid_t *blocks[0];
  899. };
  900.  
  901. /*
  902.  * get_group_info() must be called with the owning task locked (via task_lock())
  903.  * when task != current.  The reason being that the vast majority of callers are
  904.  * looking at current->group_info, which can not be changed except by the
  905.  * current task.  Changing current->group_info requires the task lock, too.
  906.  */
  907. #define get_group_info(group_info) do { \
  908.     atomic_inc(&(group_info)->usage); \
  909. } while (0)
  910.  
  911. #define put_group_info(group_info) do { \
  912.     if (atomic_dec_and_test(&(group_info)->usage)) \
  913.         groups_free(group_info); \
  914. } while (0)
  915.  
  916. extern struct group_info *groups_alloc(int gidsetsize);
  917. extern void groups_free(struct group_info *group_info);
  918. extern int set_current_groups(struct group_info *group_info);
  919. extern int groups_search(struct group_info *group_info, gid_t grp);
  920. /* access the groups "array" with this macro */
  921. #define GROUP_AT(gi, i) \
  922.     ((gi)->blocks[(i)/NGROUPS_PER_BLOCK][(i)%NGROUPS_PER_BLOCK])
  923.  
  924. #ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
  925. extern void prefetch_stack(struct task_struct *t);
  926. #else
  927. static inline void prefetch_stack(struct task_struct *t) { }
  928. #endif
  929.  
  930. struct audit_context;        /* See audit.c */
  931. struct mempolicy;
  932. struct pipe_inode_info;
  933. struct uts_namespace;
  934.  
  935. struct rq;
  936. struct sched_domain;
  937.  
  938. struct sched_class {
  939.     const struct sched_class *next;
  940.  
  941.     void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup);
  942.     void (*dequeue_task) (struct rq *rq, struct task_struct *p, int sleep);
  943.     void (*yield_task) (struct rq *rq);
  944.  
  945.     void (*check_preempt_curr) (struct rq *rq, struct task_struct *p, int sync);
  946.  
  947.     struct task_struct * (*pick_next_task) (struct rq *rq);
  948.     void (*put_prev_task) (struct rq *rq, struct task_struct *p);
  949.  
  950. #ifdef CONFIG_SMP
  951.     int  (*select_task_rq)(struct task_struct *p, int sync);
  952.  
  953.     unsigned long (*load_balance) (struct rq *this_rq, int this_cpu,
  954.             struct rq *busiest, unsigned long max_load_move,
  955.             struct sched_domain *sd, enum cpu_idle_type idle,
  956.             int *all_pinned, int *this_best_prio);
  957.  
  958.     int (*move_one_task) (struct rq *this_rq, int this_cpu,
  959.                   struct rq *busiest, struct sched_domain *sd,
  960.                   enum cpu_idle_type idle);
  961.     void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
  962.     void (*post_schedule) (struct rq *this_rq);
  963.     void (*task_wake_up) (struct rq *this_rq, struct task_struct *task);
  964.  
  965.     void (*set_cpus_allowed)(struct task_struct *p,
  966.                  const cpumask_t *newmask);
  967.  
  968.     void (*rq_online)(struct rq *rq);
  969.     void (*rq_offline)(struct rq *rq);
  970. #endif
  971.  
  972.     void (*set_curr_task) (struct rq *rq);
  973.     void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
  974.     void (*task_new) (struct rq *rq, struct task_struct *p);
  975.  
  976.     void (*switched_from) (struct rq *this_rq, struct task_struct *task,
  977.                    int running);
  978.     void (*switched_to) (struct rq *this_rq, struct task_struct *task,
  979.                  int running);
  980.     void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
  981.                  int oldprio, int running);
  982.  
  983. #ifdef CONFIG_FAIR_GROUP_SCHED
  984.     void (*moved_group) (struct task_struct *p);
  985. #endif
  986. };
  987.  
  988. struct load_weight {
  989.     unsigned long weight, inv_weight;
  990. };
  991.  
  992. /*
  993.  * CFS stats for a schedulable entity (task, task-group etc)
  994.  *
  995.  * Current field usage histogram:
  996.  *
  997.  *     4 se->block_start
  998.  *     4 se->run_node
  999.  *     4 se->sleep_start
  1000.  *     6 se->load.weight
  1001.  */
  1002. struct sched_entity {
  1003.     struct load_weight    load;        /* for load-balancing */
  1004.     struct rb_node        run_node;
  1005.     struct list_head    group_node;
  1006.     unsigned int        on_rq;
  1007.  
  1008.     u64            exec_start;
  1009.     u64            sum_exec_runtime;
  1010.     u64            vruntime;
  1011.     u64            prev_sum_exec_runtime;
  1012.  
  1013.     u64            last_wakeup;
  1014.     u64            avg_overlap;
  1015.  
  1016. #ifdef CONFIG_SCHEDSTATS
  1017.     u64            wait_start;
  1018.     u64            wait_max;
  1019.     u64            wait_count;
  1020.     u64            wait_sum;
  1021.  
  1022.     u64            sleep_start;
  1023.     u64            sleep_max;
  1024.     s64            sum_sleep_runtime;
  1025.  
  1026.     u64            block_start;
  1027.     u64            block_max;
  1028.     u64            exec_max;
  1029.     u64            slice_max;
  1030.  
  1031.     u64            nr_migrations;
  1032.     u64            nr_migrations_cold;
  1033.     u64            nr_failed_migrations_affine;
  1034.     u64            nr_failed_migrations_running;
  1035.     u64            nr_failed_migrations_hot;
  1036.     u64            nr_forced_migrations;
  1037.     u64            nr_forced2_migrations;
  1038.  
  1039.     u64            nr_wakeups;
  1040.     u64            nr_wakeups_sync;
  1041.     u64            nr_wakeups_migrate;
  1042.     u64            nr_wakeups_local;
  1043.     u64            nr_wakeups_remote;
  1044.     u64            nr_wakeups_affine;
  1045.     u64            nr_wakeups_affine_attempts;
  1046.     u64            nr_wakeups_passive;
  1047.     u64            nr_wakeups_idle;
  1048. #endif
  1049.  
  1050. #ifdef CONFIG_FAIR_GROUP_SCHED
  1051.     struct sched_entity    *parent;
  1052.     /* rq on which this entity is (to be) queued: */
  1053.     struct cfs_rq        *cfs_rq;
  1054.     /* rq "owned" by this entity/group: */
  1055.     struct cfs_rq        *my_q;
  1056. #endif
  1057. };
  1058.  
  1059. struct sched_rt_entity {
  1060.     struct list_head run_list;
  1061.     unsigned long timeout;
  1062.     unsigned int time_slice;
  1063.     int nr_cpus_allowed;
  1064.  
  1065.     struct sched_rt_entity *back;
  1066. #ifdef CONFIG_RT_GROUP_SCHED
  1067.     struct sched_rt_entity    *parent;
  1068.     /* rq on which this entity is (to be) queued: */
  1069.     struct rt_rq        *rt_rq;
  1070.     /* rq "owned" by this entity/group: */
  1071.     struct rt_rq        *my_q;
  1072. #endif
  1073. };
  1074.  
  1075. struct task_struct {
  1076.     volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
  1077.     void *stack;
  1078.     atomic_t usage;
  1079.     unsigned int flags;    /* per process flags, defined below */
  1080.     unsigned int ptrace;
  1081.  
  1082.     int lock_depth;        /* BKL lock depth */
  1083.  
  1084. #ifdef CONFIG_SMP
  1085. #ifdef __ARCH_WANT_UNLOCKED_CTXSW
  1086.     int oncpu;
  1087. #endif
  1088. #endif
  1089.  
  1090.     int prio, static_prio, normal_prio;
  1091.     unsigned int rt_priority;
  1092.     const struct sched_class *sched_class;
  1093.     struct sched_entity se;
  1094.     struct sched_rt_entity rt;
  1095.  
  1096. #ifdef CONFIG_PREEMPT_NOTIFIERS
  1097.     /* list of struct preempt_notifier: */
  1098.     struct hlist_head preempt_notifiers;
  1099. #endif
  1100.  
  1101.     /*
  1102.      * fpu_counter contains the number of consecutive context switches
  1103.      * that the FPU is used. If this is over a threshold, the lazy fpu
  1104.      * saving becomes unlazy to save the trap. This is an unsigned char
  1105.      * so that after 256 times the counter wraps and the behavior turns
  1106.      * lazy again; this to deal with bursty apps that only use FPU for
  1107.      * a short time
  1108.      */
  1109.     unsigned char fpu_counter;
  1110.     s8 oomkilladj; /* OOM kill score adjustment (bit shift). */
  1111. #ifdef CONFIG_BLK_DEV_IO_TRACE
  1112.     unsigned int btrace_seq;
  1113. #endif
  1114.  
  1115.     unsigned int policy;
  1116.     cpumask_t cpus_allowed;
  1117.  
  1118. #ifdef CONFIG_PREEMPT_RCU
  1119.     int rcu_read_lock_nesting;
  1120.     int rcu_flipctr_idx;
  1121. #endif /* #ifdef CONFIG_PREEMPT_RCU */
  1122.  
  1123. #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
  1124.     struct sched_info sched_info;
  1125. #endif
  1126.  
  1127.     struct list_head tasks;
  1128.  
  1129.     struct mm_struct *mm, *active_mm;
  1130.  
  1131. /* task state */
  1132.     struct linux_binfmt *binfmt;
  1133.     int exit_state;
  1134.     int exit_code, exit_signal;
  1135.     int pdeath_signal;  /*  The signal sent when the parent dies  */
  1136.     /* ??? */
  1137.     unsigned int personality;
  1138.     unsigned did_exec:1;
  1139.     pid_t pid;
  1140.     pid_t tgid;
  1141.  
  1142. #ifdef CONFIG_CC_STACKPROTECTOR
  1143.     /* Canary value for the -fstack-protector gcc feature */
  1144.     unsigned long stack_canary;
  1145. #endif
  1146.     /* 
  1147.      * pointers to (original) parent process, youngest child, younger sibling,
  1148.      * older sibling, respectively.  (p->father can be replaced with 
  1149.      * p->real_parent->pid)
  1150.      */
  1151.     struct task_struct *real_parent; /* real parent process */
  1152.     struct task_struct *parent; /* recipient of SIGCHLD, wait4() reports */
  1153.     /*
  1154.      * children/sibling forms the list of my natural children
  1155.      */
  1156.     struct list_head children;    /* list of my children */
  1157.     struct list_head sibling;    /* linkage in my parent's children list */
  1158.     struct task_struct *group_leader;    /* threadgroup leader */
  1159.  
  1160.     /*
  1161.      * ptraced is the list of tasks this task is using ptrace on.
  1162.      * This includes both natural children and PTRACE_ATTACH targets.
  1163.      * p->ptrace_entry is p's link on the p->parent->ptraced list.
  1164.      */
  1165.     struct list_head ptraced;
  1166.     struct list_head ptrace_entry;
  1167.  
  1168.     /* PID/PID hash table linkage. */
  1169.     struct pid_link pids[PIDTYPE_MAX];
  1170.     struct list_head thread_group;
  1171.  
  1172.     struct completion *vfork_done;        /* for vfork() */
  1173.     int __user *set_child_tid;        /* CLONE_CHILD_SETTID */
  1174.     int __user *clear_child_tid;        /* CLONE_CHILD_CLEARTID */
  1175.  
  1176.     cputime_t utime, stime, utimescaled, stimescaled;
  1177.     cputime_t gtime;
  1178.     cputime_t prev_utime, prev_stime;
  1179.     unsigned long nvcsw, nivcsw; /* context switch counts */
  1180.     struct timespec start_time;         /* monotonic time */
  1181.     struct timespec real_start_time;    /* boot based time */
  1182. /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
  1183.     unsigned long min_flt, maj_flt;
  1184.  
  1185.     struct task_cputime cputime_expires;
  1186.     struct list_head cpu_timers[3];
  1187.  
  1188. /* process credentials */
  1189.     uid_t uid,euid,suid,fsuid;
  1190.     gid_t gid,egid,sgid,fsgid;
  1191.     struct group_info *group_info;
  1192.     kernel_cap_t   cap_effective, cap_inheritable, cap_permitted, cap_bset;
  1193.     struct user_struct *user;
  1194.     unsigned securebits;
  1195. #ifdef CONFIG_KEYS
  1196.     unsigned char jit_keyring;    /* default keyring to attach requested keys to */
  1197.     struct key *request_key_auth;    /* assumed request_key authority */
  1198.     struct key *thread_keyring;    /* keyring private to this thread */
  1199. #endif
  1200.     char comm[TASK_COMM_LEN]; /* executable name excluding path
  1201.                      - access with [gs]et_task_comm (which lock
  1202.                        it with task_lock())
  1203.                      - initialized normally by flush_old_exec */
  1204. /* file system info */
  1205.     int link_count, total_link_count;
  1206. #ifdef CONFIG_SYSVIPC
  1207. /* ipc stuff */
  1208.     struct sysv_sem sysvsem;
  1209. #endif
  1210. #ifdef CONFIG_DETECT_SOFTLOCKUP
  1211. /* hung task detection */
  1212.     unsigned long last_switch_timestamp;
  1213.     unsigned long last_switch_count;
  1214. #endif
  1215. /* CPU-specific state of this task */
  1216.     struct thread_struct thread;
  1217. /* filesystem information */
  1218.     struct fs_struct *fs;
  1219. /* open file information */
  1220.     struct files_struct *files;
  1221. /* namespaces */
  1222.     struct nsproxy *nsproxy;
  1223. /* signal handlers */
  1224.     struct signal_struct *signal;
  1225.     struct sighand_struct *sighand;
  1226.  
  1227.     sigset_t blocked, real_blocked;
  1228.     sigset_t saved_sigmask;    /* restored if set_restore_sigmask() was used */
  1229.     struct sigpending pending;
  1230.  
  1231.     unsigned long sas_ss_sp;
  1232.     size_t sas_ss_size;
  1233.     int (*notifier)(void *priv);
  1234.     void *notifier_data;
  1235.     sigset_t *notifier_mask;
  1236. #ifdef CONFIG_SECURITY
  1237.     void *security;
  1238. #endif
  1239.     struct audit_context *audit_context;
  1240. #ifdef CONFIG_AUDITSYSCALL
  1241.     uid_t loginuid;
  1242.     unsigned int sessionid;
  1243. #endif
  1244.     seccomp_t seccomp;
  1245.  
  1246. /* Thread group tracking */
  1247.        u32 parent_exec_id;
  1248.        u32 self_exec_id;
  1249. /* Protection of (de-)allocation: mm, files, fs, tty, keyrings */
  1250.     spinlock_t alloc_lock;
  1251.  
  1252.     /* Protection of the PI data structures: */
  1253.     spinlock_t pi_lock;
  1254.  
  1255. #ifdef CONFIG_RT_MUTEXES
  1256.     /* PI waiters blocked on a rt_mutex held by this task */
  1257.     struct plist_head pi_waiters;
  1258.     /* Deadlock detection and priority inheritance handling */
  1259.     struct rt_mutex_waiter *pi_blocked_on;
  1260. #endif
  1261.  
  1262. #ifdef CONFIG_DEBUG_MUTEXES
  1263.     /* mutex deadlock detection */
  1264.     struct mutex_waiter *blocked_on;
  1265. #endif
  1266. #ifdef CONFIG_TRACE_IRQFLAGS
  1267.     unsigned int irq_events;
  1268.     int hardirqs_enabled;
  1269.     unsigned long hardirq_enable_ip;
  1270.     unsigned int hardirq_enable_event;
  1271.     unsigned long hardirq_disable_ip;
  1272.     unsigned int hardirq_disable_event;
  1273.     int softirqs_enabled;
  1274.     unsigned long softirq_disable_ip;
  1275.     unsigned int softirq_disable_event;
  1276.     unsigned long softirq_enable_ip;
  1277.     unsigned int softirq_enable_event;
  1278.     int hardirq_context;
  1279.     int softirq_context;
  1280. #endif
  1281. #ifdef CONFIG_LOCKDEP
  1282. # define MAX_LOCK_DEPTH 48UL
  1283.     u64 curr_chain_key;
  1284.     int lockdep_depth;
  1285.     unsigned int lockdep_recursion;
  1286.     struct held_lock held_locks[MAX_LOCK_DEPTH];
  1287. #endif
  1288.  
  1289. /* journalling filesystem info */
  1290.     void *journal_info;
  1291.  
  1292. /* stacked block device info */
  1293.     struct bio *bio_list, **bio_tail;
  1294.  
  1295. /* VM state */
  1296.     struct reclaim_state *reclaim_state;
  1297.  
  1298.     struct backing_dev_info *backing_dev_info;
  1299.  
  1300.     struct io_context *io_context;
  1301.  
  1302.     unsigned long ptrace_message;
  1303.     siginfo_t *last_siginfo; /* For ptrace use.  */
  1304.     struct task_io_accounting ioac;
  1305. #if defined(CONFIG_TASK_XACCT)
  1306.     u64 acct_rss_mem1;    /* accumulated rss usage */
  1307.     u64 acct_vm_mem1;    /* accumulated virtual memory usage */
  1308.     cputime_t acct_timexpd;    /* stime + utime since last update */
  1309. #endif
  1310. #ifdef CONFIG_CPUSETS
  1311.     nodemask_t mems_allowed;
  1312.     int cpuset_mems_generation;
  1313.     int cpuset_mem_spread_rotor;
  1314. #endif
  1315. #ifdef CONFIG_CGROUPS
  1316.     /* Control Group info protected by css_set_lock */
  1317.     struct css_set *cgroups;
  1318.     /* cg_list protected by css_set_lock and tsk->alloc_lock */
  1319.     struct list_head cg_list;
  1320. #endif
  1321. #ifdef CONFIG_FUTEX
  1322.     struct robust_list_head __user *robust_list;
  1323. #ifdef CONFIG_COMPAT
  1324.     struct compat_robust_list_head __user *compat_robust_list;
  1325. #endif
  1326.     struct list_head pi_state_list;
  1327.     struct futex_pi_state *pi_state_cache;
  1328. #endif
  1329. #ifdef CONFIG_NUMA
  1330.     struct mempolicy *mempolicy;
  1331.     short il_next;
  1332. #endif
  1333.     atomic_t fs_excl;    /* holding fs exclusive resources */
  1334.     struct rcu_head rcu;
  1335.  
  1336.     /*
  1337.      * cache last used pipe for splice
  1338.      */
  1339.     struct pipe_inode_info *splice_pipe;
  1340. #ifdef    CONFIG_TASK_DELAY_ACCT
  1341.     struct task_delay_info *delays;
  1342. #endif
  1343. #ifdef CONFIG_FAULT_INJECTION
  1344.     int make_it_fail;
  1345. #endif
  1346.     struct prop_local_single dirties;
  1347. #ifdef CONFIG_LATENCYTOP
  1348.     int latency_record_count;
  1349.     struct latency_record latency_record[LT_SAVECOUNT];
  1350. #endif
  1351.     /*
  1352.      * time slack values; these are used to round up poll() and
  1353.      * select() etc timeout values. These are in nanoseconds.
  1354.      */
  1355.     unsigned long timer_slack_ns;
  1356.     unsigned long default_timer_slack_ns;
  1357.  
  1358.     struct list_head    *scm_work_list;
  1359. };
  1360.  
  1361. /*
  1362.  * Priority of a process goes from 0..MAX_PRIO-1, valid RT
  1363.  * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
  1364.  * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
  1365.  * values are inverted: lower p->prio value means higher priority.
  1366.  *
  1367.  * The MAX_USER_RT_PRIO value allows the actual maximum
  1368.  * RT priority to be separate from the value exported to
  1369.  * user-space.  This allows kernel threads to set their
  1370.  * priority to a value higher than any user task. Note:
  1371.  * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
  1372.  */
  1373.  
  1374. #define MAX_USER_RT_PRIO    100
  1375. #define MAX_RT_PRIO        MAX_USER_RT_PRIO
  1376.  
  1377. #define MAX_PRIO        (MAX_RT_PRIO + 40)
  1378. #define DEFAULT_PRIO        (MAX_RT_PRIO + 20)
  1379.  
  1380. static inline int rt_prio(int prio)
  1381. {
  1382.     if (unlikely(prio < MAX_RT_PRIO))
  1383.         return 1;
  1384.     return 0;
  1385. }
  1386.  
  1387. static inline int rt_task(struct task_struct *p)
  1388. {
  1389.     return rt_prio(p->prio);
  1390. }
  1391.  
  1392. static inline void set_task_session(struct task_struct *tsk, pid_t session)
  1393. {
  1394.     tsk->signal->__session = session;
  1395. }
  1396.  
  1397. static inline void set_task_pgrp(struct task_struct *tsk, pid_t pgrp)
  1398. {
  1399.     tsk->signal->__pgrp = pgrp;
  1400. }
  1401.  
  1402. static inline struct pid *task_pid(struct task_struct *task)
  1403. {
  1404.     return task->pids[PIDTYPE_PID].pid;
  1405. }
  1406.  
  1407. static inline struct pid *task_tgid(struct task_struct *task)
  1408. {
  1409.     return task->group_leader->pids[PIDTYPE_PID].pid;
  1410. }
  1411.  
  1412. static inline struct pid *task_pgrp(struct task_struct *task)
  1413. {
  1414.     return task->group_leader->pids[PIDTYPE_PGID].pid;
  1415. }
  1416.  
  1417. static inline struct pid *task_session(struct task_struct *task)
  1418. {
  1419.     return task->group_leader->pids[PIDTYPE_SID].pid;
  1420. }
  1421.  
  1422. struct pid_namespace;
  1423.  
  1424. /*
  1425.  * the helpers to get the task's different pids as they are seen
  1426.  * from various namespaces
  1427.  *
  1428.  * task_xid_nr()     : global id, i.e. the id seen from the init namespace;
  1429.  * task_xid_vnr()    : virtual id, i.e. the id seen from the pid namespace of
  1430.  *                     current.
  1431.  * task_xid_nr_ns()  : id seen from the ns specified;
  1432.  *
  1433.  * set_task_vxid()   : assigns a virtual id to a task;
  1434.  *
  1435.  * see also pid_nr() etc in include/linux/pid.h
  1436.  */
  1437.  
  1438. static inline pid_t task_pid_nr(struct task_struct *tsk)
  1439. {
  1440.     return tsk->pid;
  1441. }
  1442.  
  1443. pid_t task_pid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
  1444.  
  1445. static inline pid_t task_pid_vnr(struct task_struct *tsk)
  1446. {
  1447.     return pid_vnr(task_pid(tsk));
  1448. }
  1449.  
  1450.  
  1451. static inline pid_t task_tgid_nr(struct task_struct *tsk)
  1452. {
  1453.     return tsk->tgid;
  1454. }
  1455.  
  1456. pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
  1457.  
  1458. static inline pid_t task_tgid_vnr(struct task_struct *tsk)
  1459. {
  1460.     return pid_vnr(task_tgid(tsk));
  1461. }
  1462.  
  1463.  
  1464. static inline pid_t task_pgrp_nr(struct task_struct *tsk)
  1465. {
  1466.     return tsk->signal->__pgrp;
  1467. }
  1468.  
  1469. pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
  1470.  
  1471. static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
  1472. {
  1473.     return pid_vnr(task_pgrp(tsk));
  1474. }
  1475.  
  1476.  
  1477. static inline pid_t task_session_nr(struct task_struct *tsk)
  1478. {
  1479.     return tsk->signal->__session;
  1480. }
  1481.  
  1482. pid_t task_session_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
  1483.  
  1484. static inline pid_t task_session_vnr(struct task_struct *tsk)
  1485. {
  1486.     return pid_vnr(task_session(tsk));
  1487. }
  1488.  
  1489.  
  1490. /**
  1491.  * pid_alive - check that a task structure is not stale
  1492.  * @p: Task structure to be checked.
  1493.  *
  1494.  * Test if a process is not yet dead (at most zombie state)
  1495.  * If pid_alive fails, then pointers within the task structure
  1496.  * can be stale and must not be dereferenced.
  1497.  */
  1498. static inline int pid_alive(struct task_struct *p)
  1499. {
  1500.     return p->pids[PIDTYPE_PID].pid != NULL;
  1501. }
  1502.  
  1503. /**
  1504.  * is_global_init - check if a task structure is init
  1505.  * @tsk: Task structure to be checked.
  1506.  *
  1507.  * Check if a task structure is the first user space task the kernel created.
  1508.  */
  1509. static inline int is_global_init(struct task_struct *tsk)
  1510. {
  1511.     return tsk->pid == 1;
  1512. }
  1513.  
  1514. /*
  1515.  * is_container_init:
  1516.  * check whether in the task is init in its own pid namespace.
  1517.  */
  1518. extern int is_container_init(struct task_struct *tsk);
  1519.  
  1520. extern struct pid *cad_pid;
  1521.  
  1522. extern void free_task(struct task_struct *tsk);
  1523. #define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
  1524.  
  1525. extern void __put_task_struct(struct task_struct *t);
  1526.  
  1527. static inline void put_task_struct(struct task_struct *t)
  1528. {
  1529.     if (atomic_dec_and_test(&t->usage))
  1530.         __put_task_struct(t);
  1531. }
  1532.  
  1533. extern cputime_t task_utime(struct task_struct *p);
  1534. extern cputime_t task_stime(struct task_struct *p);
  1535. extern cputime_t task_gtime(struct task_struct *p);
  1536.  
  1537. /*
  1538.  * Per process flags
  1539.  */
  1540. #define PF_ALIGNWARN    0x00000001    /* Print alignment warning msgs */
  1541.                     /* Not implemented yet, only for 486*/
  1542. #define PF_STARTING    0x00000002    /* being created */
  1543. #define PF_EXITING    0x00000004    /* getting shut down */
  1544. #define PF_EXITPIDONE    0x00000008    /* pi exit done on shut down */
  1545. #define PF_VCPU        0x00000010    /* I'm a virtual CPU */
  1546. #define PF_FORKNOEXEC    0x00000040    /* forked but didn't exec */
  1547. #define PF_SUPERPRIV    0x00000100    /* used super-user privileges */
  1548. #define PF_DUMPCORE    0x00000200    /* dumped core */
  1549. #define PF_SIGNALED    0x00000400    /* killed by a signal */
  1550. #define PF_MEMALLOC    0x00000800    /* Allocating memory */
  1551. #define PF_FLUSHER    0x00001000    /* responsible for disk writeback */
  1552. #define PF_USED_MATH    0x00002000    /* if unset the fpu must be initialized before use */
  1553. #define PF_NOFREEZE    0x00008000    /* this thread should not be frozen */
  1554. #define PF_FROZEN    0x00010000    /* frozen for system suspend */
  1555. #define PF_FSTRANS    0x00020000    /* inside a filesystem transaction */
  1556. #define PF_KSWAPD    0x00040000    /* I am kswapd */
  1557. #define PF_SWAPOFF    0x00080000    /* I am in swapoff */
  1558. #define PF_LESS_THROTTLE 0x00100000    /* Throttle me less: I clean memory */
  1559. #define PF_KTHREAD    0x00200000    /* I am a kernel thread */
  1560. #define PF_RANDOMIZE    0x00400000    /* randomize virtual address space */
  1561. #define PF_SWAPWRITE    0x00800000    /* Allowed to write to swap */
  1562. #define PF_SPREAD_PAGE    0x01000000    /* Spread page cache over cpuset */
  1563. #define PF_SPREAD_SLAB    0x02000000    /* Spread some slab caches over cpuset */
  1564. #define PF_THREAD_BOUND    0x04000000    /* Thread bound to specific cpu */
  1565. #define PF_MEMPOLICY    0x10000000    /* Non-default NUMA mempolicy */
  1566. #define PF_MUTEX_TESTER    0x20000000    /* Thread belongs to the rt mutex tester */
  1567. #define PF_FREEZER_SKIP    0x40000000    /* Freezer should not count it as freezeable */
  1568. #define PF_FREEZER_NOSIG 0x80000000    /* Freezer won't send signals to it */
  1569.  
  1570. /*
  1571.  * Only the _current_ task can read/write to tsk->flags, but other
  1572.  * tasks can access tsk->flags in readonly mode for example
  1573.  * with tsk_used_math (like during threaded core dumping).
  1574.  * There is however an exception to this rule during ptrace
  1575.  * or during fork: the ptracer task is allowed to write to the
  1576.  * child->flags of its traced child (same goes for fork, the parent
  1577.  * can write to the child->flags), because we're guaranteed the
  1578.  * child is not running and in turn not changing child->flags
  1579.  * at the same time the parent does it.
  1580.  */
  1581. #define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
  1582. #define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
  1583. #define clear_used_math() clear_stopped_child_used_math(current)
  1584. #define set_used_math() set_stopped_child_used_math(current)
  1585. #define conditional_stopped_child_used_math(condition, child) \
  1586.     do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
  1587. #define conditional_used_math(condition) \
  1588.     conditional_stopped_child_used_math(condition, current)
  1589. #define copy_to_stopped_child_used_math(child) \
  1590.     do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
  1591. /* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
  1592. #define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
  1593. #define used_math() tsk_used_math(current)
  1594.  
  1595. #ifdef CONFIG_SMP
  1596. extern int set_cpus_allowed_ptr(struct task_struct *p,
  1597.                 const cpumask_t *new_mask);
  1598. #else
  1599. static inline int set_cpus_allowed_ptr(struct task_struct *p,
  1600.                        const cpumask_t *new_mask)
  1601. {
  1602.     if (!cpu_isset(0, *new_mask))
  1603.         return -EINVAL;
  1604.     return 0;
  1605. }
  1606. #endif
  1607. static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
  1608. {
  1609.     return set_cpus_allowed_ptr(p, &new_mask);
  1610. }
  1611.  
  1612. extern unsigned long long sched_clock(void);
  1613.  
  1614. extern void sched_clock_init(void);
  1615. extern u64 sched_clock_cpu(int cpu);
  1616.  
  1617. #ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
  1618. static inline void sched_clock_tick(void)
  1619. {
  1620. }
  1621.  
  1622. static inline void sched_clock_idle_sleep_event(void)
  1623. {
  1624. }
  1625.  
  1626. static inline void sched_clock_idle_wakeup_event(u64 delta_ns)
  1627. {
  1628. }
  1629. #else
  1630. extern void sched_clock_tick(void);
  1631. extern void sched_clock_idle_sleep_event(void);
  1632. extern void sched_clock_idle_wakeup_event(u64 delta_ns);
  1633. #endif
  1634.  
  1635. /*
  1636.  * For kernel-internal use: high-speed (but slightly incorrect) per-cpu
  1637.  * clock constructed from sched_clock():
  1638.  */
  1639. extern unsigned long long cpu_clock(int cpu);
  1640.  
  1641. extern unsigned long long
  1642. task_sched_runtime(struct task_struct *task);
  1643. extern unsigned long long thread_group_sched_runtime(struct task_struct *task);
  1644.  
  1645. /* sched_exec is called by processes performing an exec */
  1646. #ifdef CONFIG_SMP
  1647. extern void sched_exec(void);
  1648. #else
  1649. #define sched_exec()   {}
  1650. #endif
  1651.  
  1652. extern void sched_clock_idle_sleep_event(void);
  1653. extern void sched_clock_idle_wakeup_event(u64 delta_ns);
  1654.  
  1655. #ifdef CONFIG_HOTPLUG_CPU
  1656. extern void idle_task_exit(void);
  1657. #else
  1658. static inline void idle_task_exit(void) {}
  1659. #endif
  1660.  
  1661. extern void sched_idle_next(void);
  1662.  
  1663. #if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
  1664. extern void wake_up_idle_cpu(int cpu);
  1665. #else
  1666. static inline void wake_up_idle_cpu(int cpu) { }
  1667. #endif
  1668.  
  1669. #ifdef CONFIG_SCHED_DEBUG
  1670. extern unsigned int sysctl_sched_latency;
  1671. extern unsigned int sysctl_sched_min_granularity;
  1672. extern unsigned int sysctl_sched_wakeup_granularity;
  1673. extern unsigned int sysctl_sched_child_runs_first;
  1674. extern unsigned int sysctl_sched_features;
  1675. extern unsigned int sysctl_sched_migration_cost;
  1676. extern unsigned int sysctl_sched_nr_migrate;
  1677. extern unsigned int sysctl_sched_shares_ratelimit;
  1678. extern unsigned int sysctl_sched_shares_thresh;
  1679.  
  1680. int sched_nr_latency_handler(struct ctl_table *table, int write,
  1681.         struct file *file, void __user *buffer, size_t *length,
  1682.         loff_t *ppos);
  1683. #endif
  1684. extern unsigned int sysctl_sched_rt_period;
  1685. extern int sysctl_sched_rt_runtime;
  1686.  
  1687. int sched_rt_handler(struct ctl_table *table, int write,
  1688.         struct file *filp, void __user *buffer, size_t *lenp,
  1689.         loff_t *ppos);
  1690.  
  1691. extern unsigned int sysctl_sched_compat_yield;
  1692.  
  1693. #ifdef CONFIG_RT_MUTEXES
  1694. extern int rt_mutex_getprio(struct task_struct *p);
  1695. extern void rt_mutex_setprio(struct task_struct *p, int prio);
  1696. extern void rt_mutex_adjust_pi(struct task_struct *p);
  1697. #else
  1698. static inline int rt_mutex_getprio(struct task_struct *p)
  1699. {
  1700.     return p->normal_prio;
  1701. }
  1702. # define rt_mutex_adjust_pi(p)        do { } while (0)
  1703. #endif
  1704.  
  1705. extern void set_user_nice(struct task_struct *p, long nice);
  1706. extern int task_prio(const struct task_struct *p);
  1707. extern int task_nice(const struct task_struct *p);
  1708. extern int can_nice(const struct task_struct *p, const int nice);
  1709. extern int task_curr(const struct task_struct *p);
  1710. extern int idle_cpu(int cpu);
  1711. extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
  1712. extern int sched_setscheduler_nocheck(struct task_struct *, int,
  1713.                       struct sched_param *);
  1714. extern struct task_struct *idle_task(int cpu);
  1715. extern struct task_struct *curr_task(int cpu);
  1716. extern void set_curr_task(int cpu, struct task_struct *p);
  1717.  
  1718. void yield(void);
  1719.  
  1720. /*
  1721.  * The default (Linux) execution domain.
  1722.  */
  1723. extern struct exec_domain    default_exec_domain;
  1724.  
  1725. union thread_union {
  1726.     struct thread_info thread_info;
  1727.     unsigned long stack[THREAD_SIZE/sizeof(long)];
  1728. };
  1729.  
  1730. #ifndef __HAVE_ARCH_KSTACK_END
  1731. static inline int kstack_end(void *addr)
  1732. {
  1733.     /* Reliable end of stack detection:
  1734.      * Some APM bios versions misalign the stack
  1735.      */
  1736.     return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
  1737. }
  1738. #endif
  1739.  
  1740. extern union thread_union init_thread_union;
  1741. extern struct task_struct init_task;
  1742.  
  1743. extern struct   mm_struct init_mm;
  1744.  
  1745. extern struct pid_namespace init_pid_ns;
  1746.  
  1747. /*
  1748.  * find a task by one of its numerical ids
  1749.  *
  1750.  * find_task_by_pid_type_ns():
  1751.  *      it is the most generic call - it finds a task by all id,
  1752.  *      type and namespace specified
  1753.  * find_task_by_pid_ns():
  1754.  *      finds a task by its pid in the specified namespace
  1755.  * find_task_by_vpid():
  1756.  *      finds a task by its virtual pid
  1757.  *
  1758.  * see also find_vpid() etc in include/linux/pid.h
  1759.  */
  1760.  
  1761. extern struct task_struct *find_task_by_pid_type_ns(int type, int pid,
  1762.         struct pid_namespace *ns);
  1763.  
  1764. extern struct task_struct *find_task_by_vpid(pid_t nr);
  1765. extern struct task_struct *find_task_by_pid_ns(pid_t nr,
  1766.         struct pid_namespace *ns);
  1767.  
  1768. extern void __set_special_pids(struct pid *pid);
  1769.  
  1770. /* per-UID process charging. */
  1771. extern struct user_struct * alloc_uid(struct user_namespace *, uid_t);
  1772. static inline struct user_struct *get_uid(struct user_struct *u)
  1773. {
  1774.     atomic_inc(&u->__count);
  1775.     return u;
  1776. }
  1777. extern void free_uid(struct user_struct *);
  1778. extern void switch_uid(struct user_struct *);
  1779. extern void release_uids(struct user_namespace *ns);
  1780.  
  1781. #include <asm/current.h>
  1782.  
  1783. extern void do_timer(unsigned long ticks);
  1784.  
  1785. extern int wake_up_state(struct task_struct *tsk, unsigned int state);
  1786. extern int wake_up_process(struct task_struct *tsk);
  1787. extern void wake_up_new_task(struct task_struct *tsk,
  1788.                 unsigned long clone_flags);
  1789. #ifdef CONFIG_SMP
  1790.  extern void kick_process(struct task_struct *tsk);
  1791. #else
  1792.  static inline void kick_process(struct task_struct *tsk) { }
  1793. #endif
  1794. extern void sched_fork(struct task_struct *p, int clone_flags);
  1795. extern void sched_dead(struct task_struct *p);
  1796.  
  1797. extern int in_group_p(gid_t);
  1798. extern int in_egroup_p(gid_t);
  1799.  
  1800. extern void proc_caches_init(void);
  1801. extern void flush_signals(struct task_struct *);
  1802. extern void ignore_signals(struct task_struct *);
  1803. extern void flush_signal_handlers(struct task_struct *, int force_default);
  1804. extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
  1805.  
  1806. static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
  1807. {
  1808.     unsigned long flags;
  1809.     int ret;
  1810.  
  1811.     spin_lock_irqsave(&tsk->sighand->siglock, flags);
  1812.     ret = dequeue_signal(tsk, mask, info);
  1813.     spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
  1814.  
  1815.     return ret;
  1816. }    
  1817.  
  1818. extern void block_all_signals(int (*notifier)(void *priv), void *priv,
  1819.                   sigset_t *mask);
  1820. extern void unblock_all_signals(void);
  1821. extern void release_task(struct task_struct * p);
  1822. extern int send_sig_info(int, struct siginfo *, struct task_struct *);
  1823. extern int force_sigsegv(int, struct task_struct *);
  1824. extern int force_sig_info(int, struct siginfo *, struct task_struct *);
  1825. extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
  1826. extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
  1827. extern int kill_pid_info_as_uid(int, struct siginfo *, struct pid *, uid_t, uid_t, u32);
  1828. extern int kill_pgrp(struct pid *pid, int sig, int priv);
  1829. extern int kill_pid(struct pid *pid, int sig, int priv);
  1830. extern int kill_proc_info(int, struct siginfo *, pid_t);
  1831. extern int do_notify_parent(struct task_struct *, int);
  1832. extern void force_sig(int, struct task_struct *);
  1833. extern void force_sig_specific(int, struct task_struct *);
  1834. extern int send_sig(int, struct task_struct *, int);
  1835. extern void zap_other_threads(struct task_struct *p);
  1836. extern struct sigqueue *sigqueue_alloc(void);
  1837. extern void sigqueue_free(struct sigqueue *);
  1838. extern int send_sigqueue(struct sigqueue *,  struct task_struct *, int group);
  1839. extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
  1840. extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long);
  1841.  
  1842. static inline int kill_cad_pid(int sig, int priv)
  1843. {
  1844.     return kill_pid(cad_pid, sig, priv);
  1845. }
  1846.  
  1847. /* These can be the second arg to send_sig_info/send_group_sig_info.  */
  1848. #define SEND_SIG_NOINFO ((struct siginfo *) 0)
  1849. #define SEND_SIG_PRIV    ((struct siginfo *) 1)
  1850. #define SEND_SIG_FORCED    ((struct siginfo *) 2)
  1851.  
  1852. static inline int is_si_special(const struct siginfo *info)
  1853. {
  1854.     return info <= SEND_SIG_FORCED;
  1855. }
  1856.  
  1857. /* True if we are on the alternate signal stack.  */
  1858.  
  1859. static inline int on_sig_stack(unsigned long sp)
  1860. {
  1861.     return (sp - current->sas_ss_sp < current->sas_ss_size);
  1862. }
  1863.  
  1864. static inline int sas_ss_flags(unsigned long sp)
  1865. {
  1866.     return (current->sas_ss_size == 0 ? SS_DISABLE
  1867.         : on_sig_stack(sp) ? SS_ONSTACK : 0);
  1868. }
  1869.  
  1870. /*
  1871.  * Routines for handling mm_structs
  1872.  */
  1873. extern struct mm_struct * mm_alloc(void);
  1874.  
  1875. /* mmdrop drops the mm and the page tables */
  1876. extern void __mmdrop(struct mm_struct *);
  1877. static inline void mmdrop(struct mm_struct * mm)
  1878. {
  1879.     if (unlikely(atomic_dec_and_test(&mm->mm_count)))
  1880.         __mmdrop(mm);
  1881. }
  1882.  
  1883. /* mmput gets rid of the mappings and all user-space */
  1884. extern void mmput(struct mm_struct *);
  1885. /* Grab a reference to a task's mm, if it is not already going away */
  1886. extern struct mm_struct *get_task_mm(struct task_struct *task);
  1887. /* Remove the current tasks stale references to the old mm_struct */
  1888. extern void mm_release(struct task_struct *, struct mm_struct *);
  1889. /* Allocate a new mm structure and copy contents from tsk->mm */
  1890. extern struct mm_struct *dup_mm(struct task_struct *tsk);
  1891.  
  1892. extern int  copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
  1893. extern void flush_thread(void);
  1894. extern void exit_thread(void);
  1895.  
  1896. extern void exit_files(struct task_struct *);
  1897. extern void __cleanup_signal(struct signal_struct *);
  1898. extern void __cleanup_sighand(struct sighand_struct *);
  1899.  
  1900. extern void exit_itimers(struct signal_struct *);
  1901. extern void flush_itimer_signals(void);
  1902.  
  1903. extern NORET_TYPE void do_group_exit(int);
  1904.  
  1905. extern void daemonize(const char *, ...);
  1906. extern int allow_signal(int);
  1907. extern int disallow_signal(int);
  1908.  
  1909. extern int do_execve(char *, char __user * __user *, char __user * __user *, struct pt_regs *);
  1910. extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
  1911. struct task_struct *fork_idle(int);
  1912.  
  1913. extern void set_task_comm(struct task_struct *tsk, char *from);
  1914. extern char *get_task_comm(char *to, struct task_struct *tsk);
  1915.  
  1916. #ifdef CONFIG_SMP
  1917. extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
  1918. #else
  1919. static inline unsigned long wait_task_inactive(struct task_struct *p,
  1920.                            long match_state)
  1921. {
  1922.     return 1;
  1923. }
  1924. #endif
  1925.  
  1926. #define next_task(p)    list_entry(rcu_dereference((p)->tasks.next), struct task_struct, tasks)
  1927.  
  1928. #define for_each_process(p) \
  1929.     for (p = &init_task ; (p = next_task(p)) != &init_task ; )
  1930.  
  1931. /*
  1932.  * Careful: do_each_thread/while_each_thread is a double loop so
  1933.  *          'break' will not work as expected - use goto instead.
  1934.  */
  1935. #define do_each_thread(g, t) \
  1936.     for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
  1937.  
  1938. #define while_each_thread(g, t) \
  1939.     while ((t = next_thread(t)) != g)
  1940.  
  1941. /* de_thread depends on thread_group_leader not being a pid based check */
  1942. #define thread_group_leader(p)    (p == p->group_leader)
  1943.  
  1944. /* Do to the insanities of de_thread it is possible for a process
  1945.  * to have the pid of the thread group leader without actually being
  1946.  * the thread group leader.  For iteration through the pids in proc
  1947.  * all we care about is that we have a task with the appropriate
  1948.  * pid, we don't actually care if we have the right task.
  1949.  */
  1950. static inline int has_group_leader_pid(struct task_struct *p)
  1951. {
  1952.     return p->pid == p->tgid;
  1953. }
  1954.  
  1955. static inline
  1956. int same_thread_group(struct task_struct *p1, struct task_struct *p2)
  1957. {
  1958.     return p1->tgid == p2->tgid;
  1959. }
  1960.  
  1961. static inline struct task_struct *next_thread(const struct task_struct *p)
  1962. {
  1963.     return list_entry(rcu_dereference(p->thread_group.next),
  1964.               struct task_struct, thread_group);
  1965. }
  1966.  
  1967. static inline int thread_group_empty(struct task_struct *p)
  1968. {
  1969.     return list_empty(&p->thread_group);
  1970. }
  1971.  
  1972. #define delay_group_leader(p) \
  1973.         (thread_group_leader(p) && !thread_group_empty(p))
  1974.  
  1975. /*
  1976.  * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
  1977.  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
  1978.  * pins the final release of task.io_context.  Also protects ->cpuset and
  1979.  * ->cgroup.subsys[].
  1980.  *
  1981.  * Nests both inside and outside of read_lock(&tasklist_lock).
  1982.  * It must not be nested with write_lock_irq(&tasklist_lock),
  1983.  * neither inside nor outside.
  1984.  */
  1985. static inline void task_lock(struct task_struct *p)
  1986. {
  1987.     spin_lock(&p->alloc_lock);
  1988. }
  1989.  
  1990. static inline void task_unlock(struct task_struct *p)
  1991. {
  1992.     spin_unlock(&p->alloc_lock);
  1993. }
  1994.  
  1995. extern struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
  1996.                             unsigned long *flags);
  1997.  
  1998. static inline void unlock_task_sighand(struct task_struct *tsk,
  1999.                         unsigned long *flags)
  2000. {
  2001.     spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
  2002. }
  2003.  
  2004. #ifndef __HAVE_THREAD_FUNCTIONS
  2005.  
  2006. #define task_thread_info(task)    ((struct thread_info *)(task)->stack)
  2007. #define task_stack_page(task)    ((task)->stack)
  2008.  
  2009. static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
  2010. {
  2011.     *task_thread_info(p) = *task_thread_info(org);
  2012.     task_thread_info(p)->task = p;
  2013. }
  2014.  
  2015. static inline unsigned long *end_of_stack(struct task_struct *p)
  2016. {
  2017.     return (unsigned long *)(task_thread_info(p) + 1);
  2018. }
  2019.  
  2020. #endif
  2021.  
  2022. static inline int object_is_on_stack(void *obj)
  2023. {
  2024.     void *stack = task_stack_page(current);
  2025.  
  2026.     return (obj >= stack) && (obj < (stack + THREAD_SIZE));
  2027. }
  2028.  
  2029. extern void thread_info_cache_init(void);
  2030.  
  2031. /* set thread flags in other task's structures
  2032.  * - see asm/thread_info.h for TIF_xxxx flags available
  2033.  */
  2034. static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
  2035. {
  2036.     set_ti_thread_flag(task_thread_info(tsk), flag);
  2037. }
  2038.  
  2039. static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
  2040. {
  2041.     clear_ti_thread_flag(task_thread_info(tsk), flag);
  2042. }
  2043.  
  2044. static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
  2045. {
  2046.     return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
  2047. }
  2048.  
  2049. static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
  2050. {
  2051.     return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
  2052. }
  2053.  
  2054. static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
  2055. {
  2056.     return test_ti_thread_flag(task_thread_info(tsk), flag);
  2057. }
  2058.  
  2059. static inline void set_tsk_need_resched(struct task_struct *tsk)
  2060. {
  2061.     set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
  2062. }
  2063.  
  2064. static inline void clear_tsk_need_resched(struct task_struct *tsk)
  2065. {
  2066.     clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
  2067. }
  2068.  
  2069. static inline int test_tsk_need_resched(struct task_struct *tsk)
  2070. {
  2071.     return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
  2072. }
  2073.  
  2074. static inline int signal_pending(struct task_struct *p)
  2075. {
  2076.     return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
  2077. }
  2078.  
  2079. extern int __fatal_signal_pending(struct task_struct *p);
  2080.  
  2081. static inline int fatal_signal_pending(struct task_struct *p)
  2082. {
  2083.     return signal_pending(p) && __fatal_signal_pending(p);
  2084. }
  2085.  
  2086. static inline int signal_pending_state(long state, struct task_struct *p)
  2087. {
  2088.     if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
  2089.         return 0;
  2090.     if (!signal_pending(p))
  2091.         return 0;
  2092.  
  2093.     return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
  2094. }
  2095.  
  2096. static inline int need_resched(void)
  2097. {
  2098.     return unlikely(test_thread_flag(TIF_NEED_RESCHED));
  2099. }
  2100.  
  2101. /*
  2102.  * cond_resched() and cond_resched_lock(): latency reduction via
  2103.  * explicit rescheduling in places that are safe. The return
  2104.  * value indicates whether a reschedule was done in fact.
  2105.  * cond_resched_lock() will drop the spinlock before scheduling,
  2106.  * cond_resched_softirq() will enable bhs before scheduling.
  2107.  */
  2108. extern int _cond_resched(void);
  2109. #ifdef CONFIG_PREEMPT_BKL
  2110. static inline int cond_resched(void)
  2111. {
  2112.     return 0;
  2113. }
  2114. #else
  2115. static inline int cond_resched(void)
  2116. {
  2117.     return _cond_resched();
  2118. }
  2119. #endif
  2120. extern int cond_resched_lock(spinlock_t * lock);
  2121. extern int cond_resched_softirq(void);
  2122. static inline int cond_resched_bkl(void)
  2123. {
  2124.     return _cond_resched();
  2125. }
  2126.  
  2127. /*
  2128.  * Does a critical section need to be broken due to another
  2129.  * task waiting?: (technically does not depend on CONFIG_PREEMPT,
  2130.  * but a general need for low latency)
  2131.  */
  2132. static inline int spin_needbreak(spinlock_t *lock)
  2133. {
  2134. #ifdef CONFIG_PREEMPT
  2135.     return spin_is_contended(lock);
  2136. #else
  2137.     return 0;
  2138. #endif
  2139. }
  2140.  
  2141. /*
  2142.  * Thread group CPU time accounting.
  2143.  */
  2144.  
  2145. extern int thread_group_cputime_alloc(struct task_struct *);
  2146. extern void thread_group_cputime(struct task_struct *, struct task_cputime *);
  2147.  
  2148. static inline void thread_group_cputime_init(struct signal_struct *sig)
  2149. {
  2150.     sig->cputime.totals = NULL;
  2151. }
  2152.  
  2153. static inline int thread_group_cputime_clone_thread(struct task_struct *curr)
  2154. {
  2155.     if (curr->signal->cputime.totals)
  2156.         return 0;
  2157.     return thread_group_cputime_alloc(curr);
  2158. }
  2159.  
  2160. static inline void thread_group_cputime_free(struct signal_struct *sig)
  2161. {
  2162.     free_percpu(sig->cputime.totals);
  2163. }
  2164.  
  2165. /*
  2166.  * Reevaluate whether the task has signals pending delivery.
  2167.  * Wake the task if so.
  2168.  * This is required every time the blocked sigset_t changes.
  2169.  * callers must hold sighand->siglock.
  2170.  */
  2171. extern void recalc_sigpending_and_wake(struct task_struct *t);
  2172. extern void recalc_sigpending(void);
  2173.  
  2174. extern void signal_wake_up(struct task_struct *t, int resume_stopped);
  2175.  
  2176. /*
  2177.  * Wrappers for p->thread_info->cpu access. No-op on UP.
  2178.  */
  2179. #ifdef CONFIG_SMP
  2180.  
  2181. static inline unsigned int task_cpu(const struct task_struct *p)
  2182. {
  2183.     return task_thread_info(p)->cpu;
  2184. }
  2185.  
  2186. extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
  2187.  
  2188. #else
  2189.  
  2190. static inline unsigned int task_cpu(const struct task_struct *p)
  2191. {
  2192.     return 0;
  2193. }
  2194.  
  2195. static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
  2196. {
  2197. }
  2198.  
  2199. #endif /* CONFIG_SMP */
  2200.  
  2201. extern void arch_pick_mmap_layout(struct mm_struct *mm);
  2202.  
  2203. #ifdef CONFIG_TRACING
  2204. extern void
  2205. __trace_special(void *__tr, void *__data,
  2206.         unsigned long arg1, unsigned long arg2, unsigned long arg3);
  2207. #else
  2208. static inline void
  2209. __trace_special(void *__tr, void *__data,
  2210.         unsigned long arg1, unsigned long arg2, unsigned long arg3)
  2211. {
  2212. }
  2213. #endif
  2214.  
  2215. extern long sched_setaffinity(pid_t pid, const cpumask_t *new_mask);
  2216. extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
  2217.  
  2218. extern int sched_mc_power_savings, sched_smt_power_savings;
  2219.  
  2220. extern void normalize_rt_tasks(void);
  2221.  
  2222. #ifdef CONFIG_GROUP_SCHED
  2223.  
  2224. extern struct task_group init_task_group;
  2225. #ifdef CONFIG_USER_SCHED
  2226. extern struct task_group root_task_group;
  2227. #endif
  2228.  
  2229. extern struct task_group *sched_create_group(struct task_group *parent);
  2230. extern void sched_destroy_group(struct task_group *tg);
  2231. extern void sched_move_task(struct task_struct *tsk);
  2232. #ifdef CONFIG_FAIR_GROUP_SCHED
  2233. extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
  2234. extern unsigned long sched_group_shares(struct task_group *tg);
  2235. #endif
  2236. #ifdef CONFIG_RT_GROUP_SCHED
  2237. extern int sched_group_set_rt_runtime(struct task_group *tg,
  2238.                       long rt_runtime_us);
  2239. extern long sched_group_rt_runtime(struct task_group *tg);
  2240. extern int sched_group_set_rt_period(struct task_group *tg,
  2241.                       long rt_period_us);
  2242. extern long sched_group_rt_period(struct task_group *tg);
  2243. #endif
  2244. #endif
  2245.  
  2246. #ifdef CONFIG_TASK_XACCT
  2247. static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
  2248. {
  2249.     tsk->ioac.rchar += amt;
  2250. }
  2251.  
  2252. static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
  2253. {
  2254.     tsk->ioac.wchar += amt;
  2255. }
  2256.  
  2257. static inline void inc_syscr(struct task_struct *tsk)
  2258. {
  2259.     tsk->ioac.syscr++;
  2260. }
  2261.  
  2262. static inline void inc_syscw(struct task_struct *tsk)
  2263. {
  2264.     tsk->ioac.syscw++;
  2265. }
  2266. #else
  2267. static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
  2268. {
  2269. }
  2270.  
  2271. static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
  2272. {
  2273. }
  2274.  
  2275. static inline void inc_syscr(struct task_struct *tsk)
  2276. {
  2277. }
  2278.  
  2279. static inline void inc_syscw(struct task_struct *tsk)
  2280. {
  2281. }
  2282. #endif
  2283.  
  2284. #ifndef TASK_SIZE_OF
  2285. #define TASK_SIZE_OF(tsk)    TASK_SIZE
  2286. #endif
  2287.  
  2288. #ifdef CONFIG_MM_OWNER
  2289. extern void mm_update_next_owner(struct mm_struct *mm);
  2290. extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
  2291. #else
  2292. static inline void mm_update_next_owner(struct mm_struct *mm)
  2293. {
  2294. }
  2295.  
  2296. static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
  2297. {
  2298. }
  2299. #endif /* CONFIG_MM_OWNER */
  2300.  
  2301. #define TASK_STATE_TO_CHAR_STR "RSDTtZX"
  2302.  
  2303. #endif /* __KERNEL__ */
  2304.  
  2305. #endif
  2306.