Merge tag 'v3.18' into p/abusse/merge_upgrade
[projects/modsched/linux.git] / include / linux / sched.h
1 #ifndef _LINUX_SCHED_H
2 #define _LINUX_SCHED_H
3
4 #include <uapi/linux/sched.h>
5
6 #include <linux/sched/prio.h>
7
8
9 struct sched_param {
10         int sched_priority;
11 };
12
13 #include <asm/param.h>  /* for HZ */
14
15 #include <linux/capability.h>
16 #include <linux/threads.h>
17 #include <linux/kernel.h>
18 #include <linux/types.h>
19 #include <linux/timex.h>
20 #include <linux/jiffies.h>
21 #include <linux/plist.h>
22 #include <linux/rbtree.h>
23 #include <linux/thread_info.h>
24 #include <linux/cpumask.h>
25 #include <linux/errno.h>
26 #include <linux/nodemask.h>
27 #include <linux/mm_types.h>
28 #include <linux/preempt_mask.h>
29
30 #include <asm/page.h>
31 #include <asm/ptrace.h>
32 #include <linux/cputime.h>
33
34 #include <linux/smp.h>
35 #include <linux/sem.h>
36 #include <linux/shm.h>
37 #include <linux/signal.h>
38 #include <linux/compiler.h>
39 #include <linux/completion.h>
40 #include <linux/pid.h>
41 #include <linux/percpu.h>
42 #include <linux/topology.h>
43 #include <linux/proportions.h>
44 #include <linux/seccomp.h>
45 #include <linux/rcupdate.h>
46 #include <linux/rculist.h>
47 #include <linux/rtmutex.h>
48
49 #include <linux/time.h>
50 #include <linux/param.h>
51 #include <linux/resource.h>
52 #include <linux/timer.h>
53 #include <linux/hrtimer.h>
54 #include <linux/task_io_accounting.h>
55 #include <linux/latencytop.h>
56 #include <linux/cred.h>
57 #include <linux/llist.h>
58 #include <linux/uidgid.h>
59 #include <linux/gfp.h>
60 #include <linux/magic.h>
61
62 #include <asm/processor.h>
63
64 #define SCHED_ATTR_SIZE_VER0    48      /* sizeof first published struct */
65
66 /*
67  * Extended scheduling parameters data structure.
68  *
69  * This is needed because the original struct sched_param can not be
70  * altered without introducing ABI issues with legacy applications
71  * (e.g., in sched_getparam()).
72  *
73  * However, the possibility of specifying more than just a priority for
74  * the tasks may be useful for a wide variety of application fields, e.g.,
75  * multimedia, streaming, automation and control, and many others.
76  *
77  * This variant (sched_attr) is meant at describing a so-called
78  * sporadic time-constrained task. In such model a task is specified by:
79  *  - the activation period or minimum instance inter-arrival time;
80  *  - the maximum (or average, depending on the actual scheduling
81  *    discipline) computation time of all instances, a.k.a. runtime;
82  *  - the deadline (relative to the actual activation time) of each
83  *    instance.
84  * Very briefly, a periodic (sporadic) task asks for the execution of
85  * some specific computation --which is typically called an instance--
86  * (at most) every period. Moreover, each instance typically lasts no more
87  * than the runtime and must be completed by time instant t equal to
88  * the instance activation time + the deadline.
89  *
90  * This is reflected by the actual fields of the sched_attr structure:
91  *
92  *  @size               size of the structure, for fwd/bwd compat.
93  *
94  *  @sched_policy       task's scheduling policy
95  *  @sched_flags        for customizing the scheduler behaviour
96  *  @sched_nice         task's nice value      (SCHED_NORMAL/BATCH)
97  *  @sched_priority     task's static priority (SCHED_FIFO/RR)
98  *  @sched_deadline     representative of the task's deadline
99  *  @sched_runtime      representative of the task's runtime
100  *  @sched_period       representative of the task's period
101  *
102  * Given this task model, there are a multiplicity of scheduling algorithms
103  * and policies, that can be used to ensure all the tasks will make their
104  * timing constraints.
105  *
106  * As of now, the SCHED_DEADLINE policy (sched_dl scheduling class) is the
107  * only user of this new interface. More information about the algorithm
108  * available in the scheduling class file or in Documentation/.
109  */
110 struct sched_attr {
111         u32 size;
112
113         u32 sched_policy;
114         u64 sched_flags;
115
116         /* SCHED_NORMAL, SCHED_BATCH */
117         s32 sched_nice;
118
119         /* SCHED_FIFO, SCHED_RR */
120         u32 sched_priority;
121
122         /* SCHED_DEADLINE */
123         u64 sched_runtime;
124         u64 sched_deadline;
125         u64 sched_period;
126 };
127
128 #ifdef CONFIG_MOD_SCHED
129 #include <fw_task.h>
130 #endif
131
132 struct exec_domain;
133 struct futex_pi_state;
134 struct robust_list_head;
135 struct bio_list;
136 struct fs_struct;
137 struct perf_event_context;
138 struct blk_plug;
139 struct filename;
140
141 #define VMACACHE_BITS 2
142 #define VMACACHE_SIZE (1U << VMACACHE_BITS)
143 #define VMACACHE_MASK (VMACACHE_SIZE - 1)
144
145 /*
146  * These are the constant used to fake the fixed-point load-average
147  * counting. Some notes:
148  *  - 11 bit fractions expand to 22 bits by the multiplies: this gives
149  *    a load-average precision of 10 bits integer + 11 bits fractional
150  *  - if you want to count load-averages more often, you need more
151  *    precision, or rounding will get you. With 2-second counting freq,
152  *    the EXP_n values would be 1981, 2034 and 2043 if still using only
153  *    11 bit fractions.
154  */
155 extern unsigned long avenrun[];         /* Load averages */
156 extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
157
158 #define FSHIFT          11              /* nr of bits of precision */
159 #define FIXED_1         (1<<FSHIFT)     /* 1.0 as fixed-point */
160 #define LOAD_FREQ       (5*HZ+1)        /* 5 sec intervals */
161 #define EXP_1           1884            /* 1/exp(5sec/1min) as fixed-point */
162 #define EXP_5           2014            /* 1/exp(5sec/5min) */
163 #define EXP_15          2037            /* 1/exp(5sec/15min) */
164
165 #define CALC_LOAD(load,exp,n) \
166         load *= exp; \
167         load += n*(FIXED_1-exp); \
168         load >>= FSHIFT;
169
170 extern unsigned long total_forks;
171 extern int nr_threads;
172 DECLARE_PER_CPU(unsigned long, process_counts);
173 extern int nr_processes(void);
174 extern unsigned long nr_running(void);
175 extern bool single_task_running(void);
176 extern unsigned long nr_iowait(void);
177 extern unsigned long nr_iowait_cpu(int cpu);
178 extern void get_iowait_load(unsigned long *nr_waiters, unsigned long *load);
179
180 extern void calc_global_load(unsigned long ticks);
181 extern void update_cpu_load_nohz(void);
182
183 extern unsigned long get_parent_ip(unsigned long addr);
184
185 extern void dump_cpu_task(int cpu);
186
187 struct seq_file;
188 struct cfs_rq;
189 struct task_group;
190 #ifdef CONFIG_SCHED_DEBUG
191 extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
192 extern void proc_sched_set_task(struct task_struct *p);
193 extern void
194 print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
195 #endif
196
197 /*
198  * Task state bitmask. NOTE! These bits are also
199  * encoded in fs/proc/array.c: get_task_state().
200  *
201  * We have two separate sets of flags: task->state
202  * is about runnability, while task->exit_state are
203  * about the task exiting. Confusing, but this way
204  * modifying one set can't modify the other one by
205  * mistake.
206  */
207 #define TASK_RUNNING            0
208 #define TASK_INTERRUPTIBLE      1
209 #define TASK_UNINTERRUPTIBLE    2
210 #define __TASK_STOPPED          4
211 #define __TASK_TRACED           8
212 /* in tsk->exit_state */
213 #define EXIT_DEAD               16
214 #define EXIT_ZOMBIE             32
215 #define EXIT_TRACE              (EXIT_ZOMBIE | EXIT_DEAD)
216 /* in tsk->state again */
217 #define TASK_DEAD               64
218 #define TASK_WAKEKILL           128
219 #define TASK_WAKING             256
220 #define TASK_PARKED             512
221 #define TASK_STATE_MAX          1024
222
223 #define TASK_STATE_TO_CHAR_STR "RSDTtXZxKWP"
224
225 extern char ___assert_task_state[1 - 2*!!(
226                 sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1)];
227
228 /* Convenience macros for the sake of set_task_state */
229 #define TASK_KILLABLE           (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
230 #define TASK_STOPPED            (TASK_WAKEKILL | __TASK_STOPPED)
231 #define TASK_TRACED             (TASK_WAKEKILL | __TASK_TRACED)
232
233 /* Convenience macros for the sake of wake_up */
234 #define TASK_NORMAL             (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
235 #define TASK_ALL                (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
236
237 /* get_task_state() */
238 #define TASK_REPORT             (TASK_RUNNING | TASK_INTERRUPTIBLE | \
239                                  TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
240                                  __TASK_TRACED | EXIT_ZOMBIE | EXIT_DEAD)
241
242 #define task_is_traced(task)    ((task->state & __TASK_TRACED) != 0)
243 #define task_is_stopped(task)   ((task->state & __TASK_STOPPED) != 0)
244 #define task_is_stopped_or_traced(task) \
245                         ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
246 #define task_contributes_to_load(task)  \
247                                 ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
248                                  (task->flags & PF_FROZEN) == 0)
249
250 #define __set_task_state(tsk, state_value)              \
251         do { (tsk)->state = (state_value); } while (0)
252 #define set_task_state(tsk, state_value)                \
253         set_mb((tsk)->state, (state_value))
254
255 /*
256  * set_current_state() includes a barrier so that the write of current->state
257  * is correctly serialised wrt the caller's subsequent test of whether to
258  * actually sleep:
259  *
260  *      set_current_state(TASK_UNINTERRUPTIBLE);
261  *      if (do_i_need_to_sleep())
262  *              schedule();
263  *
264  * If the caller does not need such serialisation then use __set_current_state()
265  */
266 #define __set_current_state(state_value)                        \
267         do { current->state = (state_value); } while (0)
268 #define set_current_state(state_value)          \
269         set_mb(current->state, (state_value))
270
271 /* Task command name length */
272 #define TASK_COMM_LEN 16
273
274 #include <linux/spinlock.h>
275
276 /*
277  * This serializes "schedule()" and also protects
278  * the run-queue from deletions/modifications (but
279  * _adding_ to the beginning of the run-queue has
280  * a separate lock).
281  */
282 extern rwlock_t tasklist_lock;
283 extern spinlock_t mmlist_lock;
284
285 struct task_struct;
286
287 #ifdef CONFIG_PROVE_RCU
288 extern int lockdep_tasklist_lock_is_held(void);
289 #endif /* #ifdef CONFIG_PROVE_RCU */
290
291 extern void sched_init(void);
292 extern void sched_init_smp(void);
293 extern asmlinkage void schedule_tail(struct task_struct *prev);
294 extern void init_idle(struct task_struct *idle, int cpu);
295 extern void init_idle_bootup_task(struct task_struct *idle);
296
297 extern int runqueue_is_locked(int cpu);
298
299 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
300 extern void nohz_balance_enter_idle(int cpu);
301 extern void set_cpu_sd_state_idle(void);
302 extern int get_nohz_timer_target(int pinned);
303 #else
304 static inline void nohz_balance_enter_idle(int cpu) { }
305 static inline void set_cpu_sd_state_idle(void) { }
306 static inline int get_nohz_timer_target(int pinned)
307 {
308         return smp_processor_id();
309 }
310 #endif
311
312 /*
313  * Only dump TASK_* tasks. (0 for all tasks)
314  */
315 extern void show_state_filter(unsigned long state_filter);
316
317 static inline void show_state(void)
318 {
319         show_state_filter(0);
320 }
321
322 extern void show_regs(struct pt_regs *);
323
324 /*
325  * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
326  * task), SP is the stack pointer of the first frame that should be shown in the back
327  * trace (or NULL if the entire call-chain of the task should be shown).
328  */
329 extern void show_stack(struct task_struct *task, unsigned long *sp);
330
331 void io_schedule(void);
332 long io_schedule_timeout(long timeout);
333
334 extern void cpu_init (void);
335 extern void trap_init(void);
336 extern void update_process_times(int user);
337 extern void scheduler_tick(void);
338
339 extern void sched_show_task(struct task_struct *p);
340
341 #ifdef CONFIG_LOCKUP_DETECTOR
342 extern void touch_softlockup_watchdog(void);
343 extern void touch_softlockup_watchdog_sync(void);
344 extern void touch_all_softlockup_watchdogs(void);
345 extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
346                                   void __user *buffer,
347                                   size_t *lenp, loff_t *ppos);
348 extern unsigned int  softlockup_panic;
349 void lockup_detector_init(void);
350 #else
351 static inline void touch_softlockup_watchdog(void)
352 {
353 }
354 static inline void touch_softlockup_watchdog_sync(void)
355 {
356 }
357 static inline void touch_all_softlockup_watchdogs(void)
358 {
359 }
360 static inline void lockup_detector_init(void)
361 {
362 }
363 #endif
364
365 #ifdef CONFIG_DETECT_HUNG_TASK
366 void reset_hung_task_detector(void);
367 #else
368 static inline void reset_hung_task_detector(void)
369 {
370 }
371 #endif
372
373 /* Attach to any functions which should be ignored in wchan output. */
374 #define __sched         __attribute__((__section__(".sched.text")))
375
376 /* Linker adds these: start and end of __sched functions */
377 extern char __sched_text_start[], __sched_text_end[];
378
379 /* Is this address in the __sched functions? */
380 extern int in_sched_functions(unsigned long addr);
381
382 #define MAX_SCHEDULE_TIMEOUT    LONG_MAX
383 extern signed long schedule_timeout(signed long timeout);
384 extern signed long schedule_timeout_interruptible(signed long timeout);
385 extern signed long schedule_timeout_killable(signed long timeout);
386 extern signed long schedule_timeout_uninterruptible(signed long timeout);
387 asmlinkage void schedule(void);
388 extern void schedule_preempt_disabled(void);
389
390 struct nsproxy;
391 struct user_namespace;
392
393 #ifdef CONFIG_MMU
394 extern void arch_pick_mmap_layout(struct mm_struct *mm);
395 extern unsigned long
396 arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
397                        unsigned long, unsigned long);
398 extern unsigned long
399 arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
400                           unsigned long len, unsigned long pgoff,
401                           unsigned long flags);
402 #else
403 static inline void arch_pick_mmap_layout(struct mm_struct *mm) {}
404 #endif
405
406 #define SUID_DUMP_DISABLE       0       /* No setuid dumping */
407 #define SUID_DUMP_USER          1       /* Dump as user of process */
408 #define SUID_DUMP_ROOT          2       /* Dump as root */
409
410 /* mm flags */
411
412 /* for SUID_DUMP_* above */
413 #define MMF_DUMPABLE_BITS 2
414 #define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1)
415
416 extern void set_dumpable(struct mm_struct *mm, int value);
417 /*
418  * This returns the actual value of the suid_dumpable flag. For things
419  * that are using this for checking for privilege transitions, it must
420  * test against SUID_DUMP_USER rather than treating it as a boolean
421  * value.
422  */
423 static inline int __get_dumpable(unsigned long mm_flags)
424 {
425         return mm_flags & MMF_DUMPABLE_MASK;
426 }
427
428 static inline int get_dumpable(struct mm_struct *mm)
429 {
430         return __get_dumpable(mm->flags);
431 }
432
433 /* coredump filter bits */
434 #define MMF_DUMP_ANON_PRIVATE   2
435 #define MMF_DUMP_ANON_SHARED    3
436 #define MMF_DUMP_MAPPED_PRIVATE 4
437 #define MMF_DUMP_MAPPED_SHARED  5
438 #define MMF_DUMP_ELF_HEADERS    6
439 #define MMF_DUMP_HUGETLB_PRIVATE 7
440 #define MMF_DUMP_HUGETLB_SHARED  8
441
442 #define MMF_DUMP_FILTER_SHIFT   MMF_DUMPABLE_BITS
443 #define MMF_DUMP_FILTER_BITS    7
444 #define MMF_DUMP_FILTER_MASK \
445         (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
446 #define MMF_DUMP_FILTER_DEFAULT \
447         ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\
448          (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)
449
450 #ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS
451 # define MMF_DUMP_MASK_DEFAULT_ELF      (1 << MMF_DUMP_ELF_HEADERS)
452 #else
453 # define MMF_DUMP_MASK_DEFAULT_ELF      0
454 #endif
455                                         /* leave room for more dump flags */
456 #define MMF_VM_MERGEABLE        16      /* KSM may merge identical pages */
457 #define MMF_VM_HUGEPAGE         17      /* set when VM_HUGEPAGE is set on vma */
458 #define MMF_EXE_FILE_CHANGED    18      /* see prctl_set_mm_exe_file() */
459
460 #define MMF_HAS_UPROBES         19      /* has uprobes */
461 #define MMF_RECALC_UPROBES      20      /* MMF_HAS_UPROBES can be wrong */
462
463 #define MMF_INIT_MASK           (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK)
464
465 struct sighand_struct {
466         atomic_t                count;
467         struct k_sigaction      action[_NSIG];
468         spinlock_t              siglock;
469         wait_queue_head_t       signalfd_wqh;
470 };
471
472 struct pacct_struct {
473         int                     ac_flag;
474         long                    ac_exitcode;
475         unsigned long           ac_mem;
476         cputime_t               ac_utime, ac_stime;
477         unsigned long           ac_minflt, ac_majflt;
478 };
479
480 struct cpu_itimer {
481         cputime_t expires;
482         cputime_t incr;
483         u32 error;
484         u32 incr_error;
485 };
486
487 /**
488  * struct cputime - snaphsot of system and user cputime
489  * @utime: time spent in user mode
490  * @stime: time spent in system mode
491  *
492  * Gathers a generic snapshot of user and system time.
493  */
494 struct cputime {
495         cputime_t utime;
496         cputime_t stime;
497 };
498
499 /**
500  * struct task_cputime - collected CPU time counts
501  * @utime:              time spent in user mode, in &cputime_t units
502  * @stime:              time spent in kernel mode, in &cputime_t units
503  * @sum_exec_runtime:   total time spent on the CPU, in nanoseconds
504  *
505  * This is an extension of struct cputime that includes the total runtime
506  * spent by the task from the scheduler point of view.
507  *
508  * As a result, this structure groups together three kinds of CPU time
509  * that are tracked for threads and thread groups.  Most things considering
510  * CPU time want to group these counts together and treat all three
511  * of them in parallel.
512  */
513 struct task_cputime {
514         cputime_t utime;
515         cputime_t stime;
516         unsigned long long sum_exec_runtime;
517 };
518 /* Alternate field names when used to cache expirations. */
519 #define prof_exp        stime
520 #define virt_exp        utime
521 #define sched_exp       sum_exec_runtime
522
523 #define INIT_CPUTIME    \
524         (struct task_cputime) {                                 \
525                 .utime = 0,                                     \
526                 .stime = 0,                                     \
527                 .sum_exec_runtime = 0,                          \
528         }
529
530 #ifdef CONFIG_PREEMPT_COUNT
531 #define PREEMPT_DISABLED        (1 + PREEMPT_ENABLED)
532 #else
533 #define PREEMPT_DISABLED        PREEMPT_ENABLED
534 #endif
535
536 /*
537  * Disable preemption until the scheduler is running.
538  * Reset by start_kernel()->sched_init()->init_idle().
539  *
540  * We include PREEMPT_ACTIVE to avoid cond_resched() from working
541  * before the scheduler is active -- see should_resched().
542  */
543 #define INIT_PREEMPT_COUNT      (PREEMPT_DISABLED + PREEMPT_ACTIVE)
544
545 /**
546  * struct thread_group_cputimer - thread group interval timer counts
547  * @cputime:            thread group interval timers.
548  * @running:            non-zero when there are timers running and
549  *                      @cputime receives updates.
550  * @lock:               lock for fields in this struct.
551  *
552  * This structure contains the version of task_cputime, above, that is
553  * used for thread group CPU timer calculations.
554  */
555 struct thread_group_cputimer {
556         struct task_cputime cputime;
557         int running;
558         raw_spinlock_t lock;
559 };
560
561 #include <linux/rwsem.h>
562 struct autogroup;
563
564 /*
565  * NOTE! "signal_struct" does not have its own
566  * locking, because a shared signal_struct always
567  * implies a shared sighand_struct, so locking
568  * sighand_struct is always a proper superset of
569  * the locking of signal_struct.
570  */
571 struct signal_struct {
572         atomic_t                sigcnt;
573         atomic_t                live;
574         int                     nr_threads;
575         struct list_head        thread_head;
576
577         wait_queue_head_t       wait_chldexit;  /* for wait4() */
578
579         /* current thread group signal load-balancing target: */
580         struct task_struct      *curr_target;
581
582         /* shared signal handling: */
583         struct sigpending       shared_pending;
584
585         /* thread group exit support */
586         int                     group_exit_code;
587         /* overloaded:
588          * - notify group_exit_task when ->count is equal to notify_count
589          * - everyone except group_exit_task is stopped during signal delivery
590          *   of fatal signals, group_exit_task processes the signal.
591          */
592         int                     notify_count;
593         struct task_struct      *group_exit_task;
594
595         /* thread group stop support, overloads group_exit_code too */
596         int                     group_stop_count;
597         unsigned int            flags; /* see SIGNAL_* flags below */
598
599         /*
600          * PR_SET_CHILD_SUBREAPER marks a process, like a service
601          * manager, to re-parent orphan (double-forking) child processes
602          * to this process instead of 'init'. The service manager is
603          * able to receive SIGCHLD signals and is able to investigate
604          * the process until it calls wait(). All children of this
605          * process will inherit a flag if they should look for a
606          * child_subreaper process at exit.
607          */
608         unsigned int            is_child_subreaper:1;
609         unsigned int            has_child_subreaper:1;
610
611         /* POSIX.1b Interval Timers */
612         int                     posix_timer_id;
613         struct list_head        posix_timers;
614
615         /* ITIMER_REAL timer for the process */
616         struct hrtimer real_timer;
617         struct pid *leader_pid;
618         ktime_t it_real_incr;
619
620         /*
621          * ITIMER_PROF and ITIMER_VIRTUAL timers for the process, we use
622          * CPUCLOCK_PROF and CPUCLOCK_VIRT for indexing array as these
623          * values are defined to 0 and 1 respectively
624          */
625         struct cpu_itimer it[2];
626
627         /*
628          * Thread group totals for process CPU timers.
629          * See thread_group_cputimer(), et al, for details.
630          */
631         struct thread_group_cputimer cputimer;
632
633         /* Earliest-expiration cache. */
634         struct task_cputime cputime_expires;
635
636         struct list_head cpu_timers[3];
637
638         struct pid *tty_old_pgrp;
639
640         /* boolean value for session group leader */
641         int leader;
642
643         struct tty_struct *tty; /* NULL if no tty */
644
645 #ifdef CONFIG_SCHED_AUTOGROUP
646         struct autogroup *autogroup;
647 #endif
648         /*
649          * Cumulative resource counters for dead threads in the group,
650          * and for reaped dead child processes forked by this group.
651          * Live threads maintain their own counters and add to these
652          * in __exit_signal, except for the group leader.
653          */
654         seqlock_t stats_lock;
655         cputime_t utime, stime, cutime, cstime;
656         cputime_t gtime;
657         cputime_t cgtime;
658 #ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
659         struct cputime prev_cputime;
660 #endif
661         unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
662         unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
663         unsigned long inblock, oublock, cinblock, coublock;
664         unsigned long maxrss, cmaxrss;
665         struct task_io_accounting ioac;
666
667         /*
668          * Cumulative ns of schedule CPU time fo dead threads in the
669          * group, not including a zombie group leader, (This only differs
670          * from jiffies_to_ns(utime + stime) if sched_clock uses something
671          * other than jiffies.)
672          */
673         unsigned long long sum_sched_runtime;
674
675         /*
676          * We don't bother to synchronize most readers of this at all,
677          * because there is no reader checking a limit that actually needs
678          * to get both rlim_cur and rlim_max atomically, and either one
679          * alone is a single word that can safely be read normally.
680          * getrlimit/setrlimit use task_lock(current->group_leader) to
681          * protect this instead of the siglock, because they really
682          * have no need to disable irqs.
683          */
684         struct rlimit rlim[RLIM_NLIMITS];
685
686 #ifdef CONFIG_BSD_PROCESS_ACCT
687         struct pacct_struct pacct;      /* per-process accounting information */
688 #endif
689 #ifdef CONFIG_TASKSTATS
690         struct taskstats *stats;
691 #endif
692 #ifdef CONFIG_AUDIT
693         unsigned audit_tty;
694         unsigned audit_tty_log_passwd;
695         struct tty_audit_buf *tty_audit_buf;
696 #endif
697 #ifdef CONFIG_CGROUPS
698         /*
699          * group_rwsem prevents new tasks from entering the threadgroup and
700          * member tasks from exiting,a more specifically, setting of
701          * PF_EXITING.  fork and exit paths are protected with this rwsem
702          * using threadgroup_change_begin/end().  Users which require
703          * threadgroup to remain stable should use threadgroup_[un]lock()
704          * which also takes care of exec path.  Currently, cgroup is the
705          * only user.
706          */
707         struct rw_semaphore group_rwsem;
708 #endif
709
710         oom_flags_t oom_flags;
711         short oom_score_adj;            /* OOM kill score adjustment */
712         short oom_score_adj_min;        /* OOM kill score adjustment min value.
713                                          * Only settable by CAP_SYS_RESOURCE. */
714
715         struct mutex cred_guard_mutex;  /* guard against foreign influences on
716                                          * credential calculations
717                                          * (notably. ptrace) */
718 };
719
720 /*
721  * Bits in flags field of signal_struct.
722  */
723 #define SIGNAL_STOP_STOPPED     0x00000001 /* job control stop in effect */
724 #define SIGNAL_STOP_CONTINUED   0x00000002 /* SIGCONT since WCONTINUED reap */
725 #define SIGNAL_GROUP_EXIT       0x00000004 /* group exit in progress */
726 #define SIGNAL_GROUP_COREDUMP   0x00000008 /* coredump in progress */
727 /*
728  * Pending notifications to parent.
729  */
730 #define SIGNAL_CLD_STOPPED      0x00000010
731 #define SIGNAL_CLD_CONTINUED    0x00000020
732 #define SIGNAL_CLD_MASK         (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
733
734 #define SIGNAL_UNKILLABLE       0x00000040 /* for init: ignore fatal signals */
735
736 /* If true, all threads except ->group_exit_task have pending SIGKILL */
737 static inline int signal_group_exit(const struct signal_struct *sig)
738 {
739         return  (sig->flags & SIGNAL_GROUP_EXIT) ||
740                 (sig->group_exit_task != NULL);
741 }
742
743 /*
744  * Some day this will be a full-fledged user tracking system..
745  */
746 struct user_struct {
747         atomic_t __count;       /* reference count */
748         atomic_t processes;     /* How many processes does this user have? */
749         atomic_t sigpending;    /* How many pending signals does this user have? */
750 #ifdef CONFIG_INOTIFY_USER
751         atomic_t inotify_watches; /* How many inotify watches does this user have? */
752         atomic_t inotify_devs;  /* How many inotify devs does this user have opened? */
753 #endif
754 #ifdef CONFIG_FANOTIFY
755         atomic_t fanotify_listeners;
756 #endif
757 #ifdef CONFIG_EPOLL
758         atomic_long_t epoll_watches; /* The number of file descriptors currently watched */
759 #endif
760 #ifdef CONFIG_POSIX_MQUEUE
761         /* protected by mq_lock */
762         unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */
763 #endif
764         unsigned long locked_shm; /* How many pages of mlocked shm ? */
765
766 #ifdef CONFIG_KEYS
767         struct key *uid_keyring;        /* UID specific keyring */
768         struct key *session_keyring;    /* UID's default session keyring */
769 #endif
770
771         /* Hash table maintenance information */
772         struct hlist_node uidhash_node;
773         kuid_t uid;
774
775 #ifdef CONFIG_PERF_EVENTS
776         atomic_long_t locked_vm;
777 #endif
778 };
779
780 extern int uids_sysfs_init(void);
781
782 extern struct user_struct *find_user(kuid_t);
783
784 extern struct user_struct root_user;
785 #define INIT_USER (&root_user)
786
787
788 struct backing_dev_info;
789 struct reclaim_state;
790
791 #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
792 struct sched_info {
793         /* cumulative counters */
794         unsigned long pcount;         /* # of times run on this cpu */
795         unsigned long long run_delay; /* time spent waiting on a runqueue */
796
797         /* timestamps */
798         unsigned long long last_arrival,/* when we last ran on a cpu */
799                            last_queued; /* when we were last queued to run */
800 };
801 #endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
802
803 #ifdef CONFIG_TASK_DELAY_ACCT
804 struct task_delay_info {
805         spinlock_t      lock;
806         unsigned int    flags;  /* Private per-task flags */
807
808         /* For each stat XXX, add following, aligned appropriately
809          *
810          * struct timespec XXX_start, XXX_end;
811          * u64 XXX_delay;
812          * u32 XXX_count;
813          *
814          * Atomicity of updates to XXX_delay, XXX_count protected by
815          * single lock above (split into XXX_lock if contention is an issue).
816          */
817
818         /*
819          * XXX_count is incremented on every XXX operation, the delay
820          * associated with the operation is added to XXX_delay.
821          * XXX_delay contains the accumulated delay time in nanoseconds.
822          */
823         u64 blkio_start;        /* Shared by blkio, swapin */
824         u64 blkio_delay;        /* wait for sync block io completion */
825         u64 swapin_delay;       /* wait for swapin block io completion */
826         u32 blkio_count;        /* total count of the number of sync block */
827                                 /* io operations performed */
828         u32 swapin_count;       /* total count of the number of swapin block */
829                                 /* io operations performed */
830
831         u64 freepages_start;
832         u64 freepages_delay;    /* wait for memory reclaim */
833         u32 freepages_count;    /* total count of memory reclaim */
834 };
835 #endif  /* CONFIG_TASK_DELAY_ACCT */
836
837 static inline int sched_info_on(void)
838 {
839 #ifdef CONFIG_SCHEDSTATS
840         return 1;
841 #elif defined(CONFIG_TASK_DELAY_ACCT)
842         extern int delayacct_on;
843         return delayacct_on;
844 #else
845         return 0;
846 #endif
847 }
848
849 enum cpu_idle_type {
850         CPU_IDLE,
851         CPU_NOT_IDLE,
852         CPU_NEWLY_IDLE,
853         CPU_MAX_IDLE_TYPES
854 };
855
856 /*
857  * Increase resolution of cpu_capacity calculations
858  */
859 #define SCHED_CAPACITY_SHIFT    10
860 #define SCHED_CAPACITY_SCALE    (1L << SCHED_CAPACITY_SHIFT)
861
862 /*
863  * sched-domains (multiprocessor balancing) declarations:
864  */
865 #ifdef CONFIG_SMP
866 #define SD_LOAD_BALANCE         0x0001  /* Do load balancing on this domain. */
867 #define SD_BALANCE_NEWIDLE      0x0002  /* Balance when about to become idle */
868 #define SD_BALANCE_EXEC         0x0004  /* Balance on exec */
869 #define SD_BALANCE_FORK         0x0008  /* Balance on fork, clone */
870 #define SD_BALANCE_WAKE         0x0010  /* Balance on wakeup */
871 #define SD_WAKE_AFFINE          0x0020  /* Wake task to waking CPU */
872 #define SD_SHARE_CPUCAPACITY    0x0080  /* Domain members share cpu power */
873 #define SD_SHARE_POWERDOMAIN    0x0100  /* Domain members share power domain */
874 #define SD_SHARE_PKG_RESOURCES  0x0200  /* Domain members share cpu pkg resources */
875 #define SD_SERIALIZE            0x0400  /* Only a single load balancing instance */
876 #define SD_ASYM_PACKING         0x0800  /* Place busy groups earlier in the domain */
877 #define SD_PREFER_SIBLING       0x1000  /* Prefer to place tasks in a sibling domain */
878 #define SD_OVERLAP              0x2000  /* sched_domains of this level overlap */
879 #define SD_NUMA                 0x4000  /* cross-node balancing */
880
881 #ifdef CONFIG_SCHED_SMT
882 static inline int cpu_smt_flags(void)
883 {
884         return SD_SHARE_CPUCAPACITY | SD_SHARE_PKG_RESOURCES;
885 }
886 #endif
887
888 #ifdef CONFIG_SCHED_MC
889 static inline int cpu_core_flags(void)
890 {
891         return SD_SHARE_PKG_RESOURCES;
892 }
893 #endif
894
895 #ifdef CONFIG_NUMA
896 static inline int cpu_numa_flags(void)
897 {
898         return SD_NUMA;
899 }
900 #endif
901
902 struct sched_domain_attr {
903         int relax_domain_level;
904 };
905
906 #define SD_ATTR_INIT    (struct sched_domain_attr) {    \
907         .relax_domain_level = -1,                       \
908 }
909
910 extern int sched_domain_level_max;
911
912 struct sched_group;
913
914 struct sched_domain {
915         /* These fields must be setup */
916         struct sched_domain *parent;    /* top domain must be null terminated */
917         struct sched_domain *child;     /* bottom domain must be null terminated */
918         struct sched_group *groups;     /* the balancing groups of the domain */
919         unsigned long min_interval;     /* Minimum balance interval ms */
920         unsigned long max_interval;     /* Maximum balance interval ms */
921         unsigned int busy_factor;       /* less balancing by factor if busy */
922         unsigned int imbalance_pct;     /* No balance until over watermark */
923         unsigned int cache_nice_tries;  /* Leave cache hot tasks for # tries */
924         unsigned int busy_idx;
925         unsigned int idle_idx;
926         unsigned int newidle_idx;
927         unsigned int wake_idx;
928         unsigned int forkexec_idx;
929         unsigned int smt_gain;
930
931         int nohz_idle;                  /* NOHZ IDLE status */
932         int flags;                      /* See SD_* */
933         int level;
934
935         /* Runtime fields. */
936         unsigned long last_balance;     /* init to jiffies. units in jiffies */
937         unsigned int balance_interval;  /* initialise to 1. units in ms. */
938         unsigned int nr_balance_failed; /* initialise to 0 */
939
940         /* idle_balance() stats */
941         u64 max_newidle_lb_cost;
942         unsigned long next_decay_max_lb_cost;
943
944 #ifdef CONFIG_SCHEDSTATS
945         /* load_balance() stats */
946         unsigned int lb_count[CPU_MAX_IDLE_TYPES];
947         unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
948         unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
949         unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
950         unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
951         unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
952         unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
953         unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
954
955         /* Active load balancing */
956         unsigned int alb_count;
957         unsigned int alb_failed;
958         unsigned int alb_pushed;
959
960         /* SD_BALANCE_EXEC stats */
961         unsigned int sbe_count;
962         unsigned int sbe_balanced;
963         unsigned int sbe_pushed;
964
965         /* SD_BALANCE_FORK stats */
966         unsigned int sbf_count;
967         unsigned int sbf_balanced;
968         unsigned int sbf_pushed;
969
970         /* try_to_wake_up() stats */
971         unsigned int ttwu_wake_remote;
972         unsigned int ttwu_move_affine;
973         unsigned int ttwu_move_balance;
974 #endif
975 #ifdef CONFIG_SCHED_DEBUG
976         char *name;
977 #endif
978         union {
979                 void *private;          /* used during construction */
980                 struct rcu_head rcu;    /* used during destruction */
981         };
982
983         unsigned int span_weight;
984         /*
985          * Span of all CPUs in this domain.
986          *
987          * NOTE: this field is variable length. (Allocated dynamically
988          * by attaching extra space to the end of the structure,
989          * depending on how many CPUs the kernel has booted up with)
990          */
991         unsigned long span[0];
992 };
993
994 static inline struct cpumask *sched_domain_span(struct sched_domain *sd)
995 {
996         return to_cpumask(sd->span);
997 }
998
999 extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
1000                                     struct sched_domain_attr *dattr_new);
1001
1002 /* Allocate an array of sched domains, for partition_sched_domains(). */
1003 cpumask_var_t *alloc_sched_domains(unsigned int ndoms);
1004 void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms);
1005
1006 bool cpus_share_cache(int this_cpu, int that_cpu);
1007
1008 typedef const struct cpumask *(*sched_domain_mask_f)(int cpu);
1009 typedef int (*sched_domain_flags_f)(void);
1010
1011 #define SDTL_OVERLAP    0x01
1012
1013 struct sd_data {
1014         struct sched_domain **__percpu sd;
1015         struct sched_group **__percpu sg;
1016         struct sched_group_capacity **__percpu sgc;
1017 };
1018
1019 struct sched_domain_topology_level {
1020         sched_domain_mask_f mask;
1021         sched_domain_flags_f sd_flags;
1022         int                 flags;
1023         int                 numa_level;
1024         struct sd_data      data;
1025 #ifdef CONFIG_SCHED_DEBUG
1026         char                *name;
1027 #endif
1028 };
1029
1030 extern struct sched_domain_topology_level *sched_domain_topology;
1031
1032 extern void set_sched_topology(struct sched_domain_topology_level *tl);
1033 extern void wake_up_if_idle(int cpu);
1034
1035 #ifdef CONFIG_SCHED_DEBUG
1036 # define SD_INIT_NAME(type)             .name = #type
1037 #else
1038 # define SD_INIT_NAME(type)
1039 #endif
1040
1041 #else /* CONFIG_SMP */
1042
1043 struct sched_domain_attr;
1044
1045 static inline void
1046 partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
1047                         struct sched_domain_attr *dattr_new)
1048 {
1049 }
1050
1051 static inline bool cpus_share_cache(int this_cpu, int that_cpu)
1052 {
1053         return true;
1054 }
1055
1056 #endif  /* !CONFIG_SMP */
1057
1058
1059 struct io_context;                      /* See blkdev.h */
1060
1061
1062 #ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
1063 extern void prefetch_stack(struct task_struct *t);
1064 #else
1065 static inline void prefetch_stack(struct task_struct *t) { }
1066 #endif
1067
1068 struct audit_context;           /* See audit.c */
1069 struct mempolicy;
1070 struct pipe_inode_info;
1071 struct uts_namespace;
1072
1073 struct load_weight {
1074         unsigned long weight;
1075         u32 inv_weight;
1076 };
1077
1078 struct sched_avg {
1079         /*
1080          * These sums represent an infinite geometric series and so are bound
1081          * above by 1024/(1-y).  Thus we only need a u32 to store them for all
1082          * choices of y < 1-2^(-32)*1024.
1083          */
1084         u32 runnable_avg_sum, runnable_avg_period;
1085         u64 last_runnable_update;
1086         s64 decay_count;
1087         unsigned long load_avg_contrib;
1088 };
1089
1090 #ifdef CONFIG_SCHEDSTATS
1091 struct sched_statistics {
1092         u64                     wait_start;
1093         u64                     wait_max;
1094         u64                     wait_count;
1095         u64                     wait_sum;
1096         u64                     iowait_count;
1097         u64                     iowait_sum;
1098
1099         u64                     sleep_start;
1100         u64                     sleep_max;
1101         s64                     sum_sleep_runtime;
1102
1103         u64                     block_start;
1104         u64                     block_max;
1105         u64                     exec_max;
1106         u64                     slice_max;
1107
1108         u64                     nr_migrations_cold;
1109         u64                     nr_failed_migrations_affine;
1110         u64                     nr_failed_migrations_running;
1111         u64                     nr_failed_migrations_hot;
1112         u64                     nr_forced_migrations;
1113
1114         u64                     nr_wakeups;
1115         u64                     nr_wakeups_sync;
1116         u64                     nr_wakeups_migrate;
1117         u64                     nr_wakeups_local;
1118         u64                     nr_wakeups_remote;
1119         u64                     nr_wakeups_affine;
1120         u64                     nr_wakeups_affine_attempts;
1121         u64                     nr_wakeups_passive;
1122         u64                     nr_wakeups_idle;
1123 };
1124 #endif
1125
1126 struct sched_entity {
1127         struct load_weight      load;           /* for load-balancing */
1128         struct rb_node          run_node;
1129         struct list_head        group_node;
1130         unsigned int            on_rq;
1131
1132         u64                     exec_start;
1133         u64                     sum_exec_runtime;
1134         u64                     vruntime;
1135         u64                     prev_sum_exec_runtime;
1136
1137         u64                     nr_migrations;
1138
1139 #ifdef CONFIG_SCHEDSTATS
1140         struct sched_statistics statistics;
1141 #endif
1142
1143 #ifdef CONFIG_FAIR_GROUP_SCHED
1144         int                     depth;
1145         struct sched_entity     *parent;
1146         /* rq on which this entity is (to be) queued: */
1147         struct cfs_rq           *cfs_rq;
1148         /* rq "owned" by this entity/group: */
1149         struct cfs_rq           *my_q;
1150 #endif
1151
1152 #ifdef CONFIG_SMP
1153         /* Per-entity load-tracking */
1154         struct sched_avg        avg;
1155 #endif
1156 };
1157
1158 struct sched_rt_entity {
1159         struct list_head run_list;
1160         unsigned long timeout;
1161         unsigned long watchdog_stamp;
1162         unsigned int time_slice;
1163
1164         struct sched_rt_entity *back;
1165 #ifdef CONFIG_RT_GROUP_SCHED
1166         struct sched_rt_entity  *parent;
1167         /* rq on which this entity is (to be) queued: */
1168         struct rt_rq            *rt_rq;
1169         /* rq "owned" by this entity/group: */
1170         struct rt_rq            *my_q;
1171 #endif
1172 };
1173
1174 struct sched_dl_entity {
1175         struct rb_node  rb_node;
1176
1177         /*
1178          * Original scheduling parameters. Copied here from sched_attr
1179          * during sched_setattr(), they will remain the same until
1180          * the next sched_setattr().
1181          */
1182         u64 dl_runtime;         /* maximum runtime for each instance    */
1183         u64 dl_deadline;        /* relative deadline of each instance   */
1184         u64 dl_period;          /* separation of two instances (period) */
1185         u64 dl_bw;              /* dl_runtime / dl_deadline             */
1186
1187         /*
1188          * Actual scheduling parameters. Initialized with the values above,
1189          * they are continously updated during task execution. Note that
1190          * the remaining runtime could be < 0 in case we are in overrun.
1191          */
1192         s64 runtime;            /* remaining runtime for this instance  */
1193         u64 deadline;           /* absolute deadline for this instance  */
1194         unsigned int flags;     /* specifying the scheduler behaviour   */
1195
1196         /*
1197          * Some bool flags:
1198          *
1199          * @dl_throttled tells if we exhausted the runtime. If so, the
1200          * task has to wait for a replenishment to be performed at the
1201          * next firing of dl_timer.
1202          *
1203          * @dl_new tells if a new instance arrived. If so we must
1204          * start executing it with full runtime and reset its absolute
1205          * deadline;
1206          *
1207          * @dl_boosted tells if we are boosted due to DI. If so we are
1208          * outside bandwidth enforcement mechanism (but only until we
1209          * exit the critical section);
1210          *
1211          * @dl_yielded tells if task gave up the cpu before consuming
1212          * all its available runtime during the last job.
1213          */
1214         int dl_throttled, dl_new, dl_boosted, dl_yielded;
1215
1216         /*
1217          * Bandwidth enforcement timer. Each -deadline task has its
1218          * own bandwidth to be enforced, thus we need one timer per task.
1219          */
1220         struct hrtimer dl_timer;
1221 };
1222
1223 union rcu_special {
1224         struct {
1225                 bool blocked;
1226                 bool need_qs;
1227         } b;
1228         short s;
1229 };
1230 struct rcu_node;
1231
1232 enum perf_event_task_context {
1233         perf_invalid_context = -1,
1234         perf_hw_context = 0,
1235         perf_sw_context,
1236         perf_nr_task_contexts,
1237 };
1238
1239 struct task_struct {
1240         volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
1241         void *stack;
1242         atomic_t usage;
1243         unsigned int flags;     /* per process flags, defined below */
1244         unsigned int ptrace;
1245
1246 #ifdef CONFIG_SMP
1247         struct llist_node wake_entry;
1248         int on_cpu;
1249         struct task_struct *last_wakee;
1250         unsigned long wakee_flips;
1251         unsigned long wakee_flip_decay_ts;
1252
1253         int wake_cpu;
1254 #endif
1255         int on_rq;
1256
1257         int prio, static_prio, normal_prio;
1258         unsigned int rt_priority;
1259         const struct sched_class *sched_class;
1260         struct sched_entity se;
1261         struct sched_rt_entity rt;
1262 #ifdef CONFIG_CGROUP_SCHED
1263         struct task_group *sched_task_group;
1264 #endif
1265         struct sched_dl_entity dl;
1266
1267 #ifdef CONFIG_PREEMPT_NOTIFIERS
1268         /* list of struct preempt_notifier: */
1269         struct hlist_head preempt_notifiers;
1270 #endif
1271
1272 #ifdef CONFIG_BLK_DEV_IO_TRACE
1273         unsigned int btrace_seq;
1274 #endif
1275
1276         unsigned int policy;
1277         int nr_cpus_allowed;
1278         cpumask_t cpus_allowed;
1279
1280 #ifdef CONFIG_PREEMPT_RCU
1281         int rcu_read_lock_nesting;
1282         union rcu_special rcu_read_unlock_special;
1283         struct list_head rcu_node_entry;
1284 #endif /* #ifdef CONFIG_PREEMPT_RCU */
1285 #ifdef CONFIG_TREE_PREEMPT_RCU
1286         struct rcu_node *rcu_blocked_node;
1287 #endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
1288 #ifdef CONFIG_TASKS_RCU
1289         unsigned long rcu_tasks_nvcsw;
1290         bool rcu_tasks_holdout;
1291         struct list_head rcu_tasks_holdout_list;
1292         int rcu_tasks_idle_cpu;
1293 #endif /* #ifdef CONFIG_TASKS_RCU */
1294
1295 #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
1296         struct sched_info sched_info;
1297 #endif
1298
1299         struct list_head rq_tasks;
1300         struct list_head tasks;
1301 #ifdef CONFIG_SMP
1302         struct plist_node pushable_tasks;
1303         struct rb_node pushable_dl_tasks;
1304 #endif
1305
1306         struct mm_struct *mm, *active_mm;
1307 #ifdef CONFIG_COMPAT_BRK
1308         unsigned brk_randomized:1;
1309 #endif
1310         /* per-thread vma caching */
1311         u32 vmacache_seqnum;
1312         struct vm_area_struct *vmacache[VMACACHE_SIZE];
1313 #if defined(SPLIT_RSS_COUNTING)
1314         struct task_rss_stat    rss_stat;
1315 #endif
1316 /* task state */
1317         int exit_state;
1318         int exit_code, exit_signal;
1319         int pdeath_signal;  /*  The signal sent when the parent dies  */
1320         unsigned int jobctl;    /* JOBCTL_*, siglock protected */
1321
1322         /* Used for emulating ABI behavior of previous Linux versions */
1323         unsigned int personality;
1324
1325         unsigned in_execve:1;   /* Tell the LSMs that the process is doing an
1326                                  * execve */
1327         unsigned in_iowait:1;
1328
1329         /* Revert to default priority/policy when forking */
1330         unsigned sched_reset_on_fork:1;
1331         unsigned sched_contributes_to_load:1;
1332
1333         unsigned long atomic_flags; /* Flags needing atomic access. */
1334
1335         pid_t pid;
1336         pid_t tgid;
1337
1338 #ifdef CONFIG_CC_STACKPROTECTOR
1339         /* Canary value for the -fstack-protector gcc feature */
1340         unsigned long stack_canary;
1341 #endif
1342         /*
1343          * pointers to (original) parent process, youngest child, younger sibling,
1344          * older sibling, respectively.  (p->father can be replaced with
1345          * p->real_parent->pid)
1346          */
1347         struct task_struct __rcu *real_parent; /* real parent process */
1348         struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
1349         /*
1350          * children/sibling forms the list of my natural children
1351          */
1352         struct list_head children;      /* list of my children */
1353         struct list_head sibling;       /* linkage in my parent's children list */
1354         struct task_struct *group_leader;       /* threadgroup leader */
1355
1356         /*
1357          * ptraced is the list of tasks this task is using ptrace on.
1358          * This includes both natural children and PTRACE_ATTACH targets.
1359          * p->ptrace_entry is p's link on the p->parent->ptraced list.
1360          */
1361         struct list_head ptraced;
1362         struct list_head ptrace_entry;
1363
1364         /* PID/PID hash table linkage. */
1365         struct pid_link pids[PIDTYPE_MAX];
1366         struct list_head thread_group;
1367         struct list_head thread_node;
1368
1369         struct completion *vfork_done;          /* for vfork() */
1370         int __user *set_child_tid;              /* CLONE_CHILD_SETTID */
1371         int __user *clear_child_tid;            /* CLONE_CHILD_CLEARTID */
1372
1373         cputime_t utime, stime, utimescaled, stimescaled;
1374         cputime_t gtime;
1375 #ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
1376         struct cputime prev_cputime;
1377 #endif
1378 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
1379         seqlock_t vtime_seqlock;
1380         unsigned long long vtime_snap;
1381         enum {
1382                 VTIME_SLEEPING = 0,
1383                 VTIME_USER,
1384                 VTIME_SYS,
1385         } vtime_snap_whence;
1386 #endif
1387         unsigned long nvcsw, nivcsw; /* context switch counts */
1388         u64 start_time;         /* monotonic time in nsec */
1389         u64 real_start_time;    /* boot based time in nsec */
1390 /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
1391         unsigned long min_flt, maj_flt;
1392
1393         struct task_cputime cputime_expires;
1394         struct list_head cpu_timers[3];
1395
1396 /* process credentials */
1397         const struct cred __rcu *real_cred; /* objective and real subjective task
1398                                          * credentials (COW) */
1399         const struct cred __rcu *cred;  /* effective (overridable) subjective task
1400                                          * credentials (COW) */
1401         char comm[TASK_COMM_LEN]; /* executable name excluding path
1402                                      - access with [gs]et_task_comm (which lock
1403                                        it with task_lock())
1404                                      - initialized normally by setup_new_exec */
1405 /* file system info */
1406         int link_count, total_link_count;
1407 #ifdef CONFIG_SYSVIPC
1408 /* ipc stuff */
1409         struct sysv_sem sysvsem;
1410         struct sysv_shm sysvshm;
1411 #endif
1412 #ifdef CONFIG_DETECT_HUNG_TASK
1413 /* hung task detection */
1414         unsigned long last_switch_count;
1415 #endif
1416 /* CPU-specific state of this task */
1417         struct thread_struct thread;
1418 /* filesystem information */
1419         struct fs_struct *fs;
1420 /* open file information */
1421         struct files_struct *files;
1422 /* namespaces */
1423         struct nsproxy *nsproxy;
1424 /* signal handlers */
1425         struct signal_struct *signal;
1426         struct sighand_struct *sighand;
1427
1428         sigset_t blocked, real_blocked;
1429         sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
1430         struct sigpending pending;
1431
1432         unsigned long sas_ss_sp;
1433         size_t sas_ss_size;
1434         int (*notifier)(void *priv);
1435         void *notifier_data;
1436         sigset_t *notifier_mask;
1437         struct callback_head *task_works;
1438
1439         struct audit_context *audit_context;
1440 #ifdef CONFIG_AUDITSYSCALL
1441         kuid_t loginuid;
1442         unsigned int sessionid;
1443 #endif
1444         struct seccomp seccomp;
1445
1446 /* Thread group tracking */
1447         u32 parent_exec_id;
1448         u32 self_exec_id;
1449 /* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,
1450  * mempolicy */
1451         spinlock_t alloc_lock;
1452
1453         /* Protection of the PI data structures: */
1454         raw_spinlock_t pi_lock;
1455
1456 #ifdef CONFIG_RT_MUTEXES
1457         /* PI waiters blocked on a rt_mutex held by this task */
1458         struct rb_root pi_waiters;
1459         struct rb_node *pi_waiters_leftmost;
1460         /* Deadlock detection and priority inheritance handling */
1461         struct rt_mutex_waiter *pi_blocked_on;
1462 #endif
1463
1464 #ifdef CONFIG_DEBUG_MUTEXES
1465         /* mutex deadlock detection */
1466         struct mutex_waiter *blocked_on;
1467 #endif
1468 #ifdef CONFIG_TRACE_IRQFLAGS
1469         unsigned int irq_events;
1470         unsigned long hardirq_enable_ip;
1471         unsigned long hardirq_disable_ip;
1472         unsigned int hardirq_enable_event;
1473         unsigned int hardirq_disable_event;
1474         int hardirqs_enabled;
1475         int hardirq_context;
1476         unsigned long softirq_disable_ip;
1477         unsigned long softirq_enable_ip;
1478         unsigned int softirq_disable_event;
1479         unsigned int softirq_enable_event;
1480         int softirqs_enabled;
1481         int softirq_context;
1482 #endif
1483 #ifdef CONFIG_LOCKDEP
1484 # define MAX_LOCK_DEPTH 48UL
1485         u64 curr_chain_key;
1486         int lockdep_depth;
1487         unsigned int lockdep_recursion;
1488         struct held_lock held_locks[MAX_LOCK_DEPTH];
1489         gfp_t lockdep_reclaim_gfp;
1490 #endif
1491
1492 /* journalling filesystem info */
1493         void *journal_info;
1494
1495 /* stacked block device info */
1496         struct bio_list *bio_list;
1497
1498 #ifdef CONFIG_BLOCK
1499 /* stack plugging */
1500         struct blk_plug *plug;
1501 #endif
1502
1503 /* VM state */
1504         struct reclaim_state *reclaim_state;
1505
1506         struct backing_dev_info *backing_dev_info;
1507
1508         struct io_context *io_context;
1509
1510         unsigned long ptrace_message;
1511         siginfo_t *last_siginfo; /* For ptrace use.  */
1512         struct task_io_accounting ioac;
1513 #if defined(CONFIG_TASK_XACCT)
1514         u64 acct_rss_mem1;      /* accumulated rss usage */
1515         u64 acct_vm_mem1;       /* accumulated virtual memory usage */
1516         cputime_t acct_timexpd; /* stime + utime since last update */
1517 #endif
1518 #ifdef CONFIG_CPUSETS
1519         nodemask_t mems_allowed;        /* Protected by alloc_lock */
1520         seqcount_t mems_allowed_seq;    /* Seqence no to catch updates */
1521         int cpuset_mem_spread_rotor;
1522         int cpuset_slab_spread_rotor;
1523 #endif
1524 #ifdef CONFIG_CGROUPS
1525         /* Control Group info protected by css_set_lock */
1526         struct css_set __rcu *cgroups;
1527         /* cg_list protected by css_set_lock and tsk->alloc_lock */
1528         struct list_head cg_list;
1529 #endif
1530 #ifdef CONFIG_FUTEX
1531         struct robust_list_head __user *robust_list;
1532 #ifdef CONFIG_COMPAT
1533         struct compat_robust_list_head __user *compat_robust_list;
1534 #endif
1535         struct list_head pi_state_list;
1536         struct futex_pi_state *pi_state_cache;
1537 #endif
1538 #ifdef CONFIG_PERF_EVENTS
1539         struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
1540         struct mutex perf_event_mutex;
1541         struct list_head perf_event_list;
1542 #endif
1543 #ifdef CONFIG_DEBUG_PREEMPT
1544         unsigned long preempt_disable_ip;
1545 #endif
1546 #ifdef CONFIG_NUMA
1547         struct mempolicy *mempolicy;    /* Protected by alloc_lock */
1548         short il_next;
1549         short pref_node_fork;
1550 #endif
1551 #ifdef CONFIG_NUMA_BALANCING
1552         int numa_scan_seq;
1553         unsigned int numa_scan_period;
1554         unsigned int numa_scan_period_max;
1555         int numa_preferred_nid;
1556         unsigned long numa_migrate_retry;
1557         u64 node_stamp;                 /* migration stamp  */
1558         u64 last_task_numa_placement;
1559         u64 last_sum_exec_runtime;
1560         struct callback_head numa_work;
1561
1562         struct list_head numa_entry;
1563         struct numa_group *numa_group;
1564
1565         /*
1566          * Exponential decaying average of faults on a per-node basis.
1567          * Scheduling placement decisions are made based on the these counts.
1568          * The values remain static for the duration of a PTE scan
1569          */
1570         unsigned long *numa_faults_memory;
1571         unsigned long total_numa_faults;
1572
1573         /*
1574          * numa_faults_buffer records faults per node during the current
1575          * scan window. When the scan completes, the counts in
1576          * numa_faults_memory decay and these values are copied.
1577          */
1578         unsigned long *numa_faults_buffer_memory;
1579
1580         /*
1581          * Track the nodes the process was running on when a NUMA hinting
1582          * fault was incurred.
1583          */
1584         unsigned long *numa_faults_cpu;
1585         unsigned long *numa_faults_buffer_cpu;
1586
1587         /*
1588          * numa_faults_locality tracks if faults recorded during the last
1589          * scan window were remote/local. The task scan period is adapted
1590          * based on the locality of the faults with different weights
1591          * depending on whether they were shared or private faults
1592          */
1593         unsigned long numa_faults_locality[2];
1594
1595         unsigned long numa_pages_migrated;
1596 #endif /* CONFIG_NUMA_BALANCING */
1597
1598         struct rcu_head rcu;
1599
1600         /*
1601          * cache last used pipe for splice
1602          */
1603         struct pipe_inode_info *splice_pipe;
1604
1605         struct page_frag task_frag;
1606
1607 #ifdef  CONFIG_TASK_DELAY_ACCT
1608         struct task_delay_info *delays;
1609 #endif
1610 #ifdef CONFIG_FAULT_INJECTION
1611         int make_it_fail;
1612 #endif
1613         /*
1614          * when (nr_dirtied >= nr_dirtied_pause), it's time to call
1615          * balance_dirty_pages() for some dirty throttling pause
1616          */
1617         int nr_dirtied;
1618         int nr_dirtied_pause;
1619         unsigned long dirty_paused_when; /* start of a write-and-pause period */
1620
1621 #ifdef CONFIG_LATENCYTOP
1622         int latency_record_count;
1623         struct latency_record latency_record[LT_SAVECOUNT];
1624 #endif
1625         /*
1626          * time slack values; these are used to round up poll() and
1627          * select() etc timeout values. These are in nanoseconds.
1628          */
1629         unsigned long timer_slack_ns;
1630         unsigned long default_timer_slack_ns;
1631
1632 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
1633         /* Index of current stored address in ret_stack */
1634         int curr_ret_stack;
1635         /* Stack of return addresses for return function tracing */
1636         struct ftrace_ret_stack *ret_stack;
1637         /* time stamp for last schedule */
1638         unsigned long long ftrace_timestamp;
1639         /*
1640          * Number of functions that haven't been traced
1641          * because of depth overrun.
1642          */
1643         atomic_t trace_overrun;
1644         /* Pause for the tracing */
1645         atomic_t tracing_graph_pause;
1646 #endif
1647 #ifdef CONFIG_TRACING
1648         /* state flags for use by tracers */
1649         unsigned long trace;
1650         /* bitmask and counter of trace recursion */
1651         unsigned long trace_recursion;
1652 #endif /* CONFIG_TRACING */
1653 #ifdef CONFIG_MEMCG /* memcg uses this to do batch job */
1654         unsigned int memcg_kmem_skip_account;
1655         struct memcg_oom_info {
1656                 struct mem_cgroup *memcg;
1657                 gfp_t gfp_mask;
1658                 int order;
1659                 unsigned int may_oom:1;
1660         } memcg_oom;
1661 #endif
1662 #ifdef CONFIG_UPROBES
1663         struct uprobe_task *utask;
1664 #endif
1665 #if defined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)
1666         unsigned int    sequential_io;
1667         unsigned int    sequential_io_avg;
1668 #endif
1669 #ifdef CONFIG_MOD_SCHED
1670         struct fw_task fw_task;
1671 #endif
1672 };
1673
1674 /* Future-safe accessor for struct task_struct's cpus_allowed. */
1675 #define tsk_cpus_allowed(tsk) (&(tsk)->cpus_allowed)
1676
1677 #define TNF_MIGRATED    0x01
1678 #define TNF_NO_GROUP    0x02
1679 #define TNF_SHARED      0x04
1680 #define TNF_FAULT_LOCAL 0x08
1681
1682 #ifdef CONFIG_NUMA_BALANCING
1683 extern void task_numa_fault(int last_node, int node, int pages, int flags);
1684 extern pid_t task_numa_group_id(struct task_struct *p);
1685 extern void set_numabalancing_state(bool enabled);
1686 extern void task_numa_free(struct task_struct *p);
1687 extern bool should_numa_migrate_memory(struct task_struct *p, struct page *page,
1688                                         int src_nid, int dst_cpu);
1689 #else
1690 static inline void task_numa_fault(int last_node, int node, int pages,
1691                                    int flags)
1692 {
1693 }
1694 static inline pid_t task_numa_group_id(struct task_struct *p)
1695 {
1696         return 0;
1697 }
1698 static inline void set_numabalancing_state(bool enabled)
1699 {
1700 }
1701 static inline void task_numa_free(struct task_struct *p)
1702 {
1703 }
1704 static inline bool should_numa_migrate_memory(struct task_struct *p,
1705                                 struct page *page, int src_nid, int dst_cpu)
1706 {
1707         return true;
1708 }
1709 #endif
1710
1711 static inline struct pid *task_pid(struct task_struct *task)
1712 {
1713         return task->pids[PIDTYPE_PID].pid;
1714 }
1715
1716 static inline struct pid *task_tgid(struct task_struct *task)
1717 {
1718         return task->group_leader->pids[PIDTYPE_PID].pid;
1719 }
1720
1721 /*
1722  * Without tasklist or rcu lock it is not safe to dereference
1723  * the result of task_pgrp/task_session even if task == current,
1724  * we can race with another thread doing sys_setsid/sys_setpgid.
1725  */
1726 static inline struct pid *task_pgrp(struct task_struct *task)
1727 {
1728         return task->group_leader->pids[PIDTYPE_PGID].pid;
1729 }
1730
1731 static inline struct pid *task_session(struct task_struct *task)
1732 {
1733         return task->group_leader->pids[PIDTYPE_SID].pid;
1734 }
1735
1736 struct pid_namespace;
1737
1738 /*
1739  * the helpers to get the task's different pids as they are seen
1740  * from various namespaces
1741  *
1742  * task_xid_nr()     : global id, i.e. the id seen from the init namespace;
1743  * task_xid_vnr()    : virtual id, i.e. the id seen from the pid namespace of
1744  *                     current.
1745  * task_xid_nr_ns()  : id seen from the ns specified;
1746  *
1747  * set_task_vxid()   : assigns a virtual id to a task;
1748  *
1749  * see also pid_nr() etc in include/linux/pid.h
1750  */
1751 pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
1752                         struct pid_namespace *ns);
1753
1754 static inline pid_t task_pid_nr(struct task_struct *tsk)
1755 {
1756         return tsk->pid;
1757 }
1758
1759 static inline pid_t task_pid_nr_ns(struct task_struct *tsk,
1760                                         struct pid_namespace *ns)
1761 {
1762         return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
1763 }
1764
1765 static inline pid_t task_pid_vnr(struct task_struct *tsk)
1766 {
1767         return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
1768 }
1769
1770
1771 static inline pid_t task_tgid_nr(struct task_struct *tsk)
1772 {
1773         return tsk->tgid;
1774 }
1775
1776 pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
1777
1778 static inline pid_t task_tgid_vnr(struct task_struct *tsk)
1779 {
1780         return pid_vnr(task_tgid(tsk));
1781 }
1782
1783
1784 static inline int pid_alive(const struct task_struct *p);
1785 static inline pid_t task_ppid_nr_ns(const struct task_struct *tsk, struct pid_namespace *ns)
1786 {
1787         pid_t pid = 0;
1788
1789         rcu_read_lock();
1790         if (pid_alive(tsk))
1791                 pid = task_tgid_nr_ns(rcu_dereference(tsk->real_parent), ns);
1792         rcu_read_unlock();
1793
1794         return pid;
1795 }
1796
1797 static inline pid_t task_ppid_nr(const struct task_struct *tsk)
1798 {
1799         return task_ppid_nr_ns(tsk, &init_pid_ns);
1800 }
1801
1802 static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,
1803                                         struct pid_namespace *ns)
1804 {
1805         return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
1806 }
1807
1808 static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
1809 {
1810         return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);
1811 }
1812
1813
1814 static inline pid_t task_session_nr_ns(struct task_struct *tsk,
1815                                         struct pid_namespace *ns)
1816 {
1817         return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
1818 }
1819
1820 static inline pid_t task_session_vnr(struct task_struct *tsk)
1821 {
1822         return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
1823 }
1824
1825 /* obsolete, do not use */
1826 static inline pid_t task_pgrp_nr(struct task_struct *tsk)
1827 {
1828         return task_pgrp_nr_ns(tsk, &init_pid_ns);
1829 }
1830
1831 /**
1832  * pid_alive - check that a task structure is not stale
1833  * @p: Task structure to be checked.
1834  *
1835  * Test if a process is not yet dead (at most zombie state)
1836  * If pid_alive fails, then pointers within the task structure
1837  * can be stale and must not be dereferenced.
1838  *
1839  * Return: 1 if the process is alive. 0 otherwise.
1840  */
1841 static inline int pid_alive(const struct task_struct *p)
1842 {
1843         return p->pids[PIDTYPE_PID].pid != NULL;
1844 }
1845
1846 /**
1847  * is_global_init - check if a task structure is init
1848  * @tsk: Task structure to be checked.
1849  *
1850  * Check if a task structure is the first user space task the kernel created.
1851  *
1852  * Return: 1 if the task structure is init. 0 otherwise.
1853  */
1854 static inline int is_global_init(struct task_struct *tsk)
1855 {
1856         return tsk->pid == 1;
1857 }
1858
1859 extern struct pid *cad_pid;
1860
1861 extern void free_task(struct task_struct *tsk);
1862 #define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
1863
1864 extern void __put_task_struct(struct task_struct *t);
1865
1866 static inline void put_task_struct(struct task_struct *t)
1867 {
1868         if (atomic_dec_and_test(&t->usage))
1869                 __put_task_struct(t);
1870 }
1871
1872 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
1873 extern void task_cputime(struct task_struct *t,
1874                          cputime_t *utime, cputime_t *stime);
1875 extern void task_cputime_scaled(struct task_struct *t,
1876                                 cputime_t *utimescaled, cputime_t *stimescaled);
1877 extern cputime_t task_gtime(struct task_struct *t);
1878 #else
1879 static inline void task_cputime(struct task_struct *t,
1880                                 cputime_t *utime, cputime_t *stime)
1881 {
1882         if (utime)
1883                 *utime = t->utime;
1884         if (stime)
1885                 *stime = t->stime;
1886 }
1887
1888 static inline void task_cputime_scaled(struct task_struct *t,
1889                                        cputime_t *utimescaled,
1890                                        cputime_t *stimescaled)
1891 {
1892         if (utimescaled)
1893                 *utimescaled = t->utimescaled;
1894         if (stimescaled)
1895                 *stimescaled = t->stimescaled;
1896 }
1897
1898 static inline cputime_t task_gtime(struct task_struct *t)
1899 {
1900         return t->gtime;
1901 }
1902 #endif
1903 extern void task_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
1904 extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
1905
1906 /*
1907  * Per process flags
1908  */
1909 #define PF_EXITING      0x00000004      /* getting shut down */
1910 #define PF_EXITPIDONE   0x00000008      /* pi exit done on shut down */
1911 #define PF_VCPU         0x00000010      /* I'm a virtual CPU */
1912 #define PF_WQ_WORKER    0x00000020      /* I'm a workqueue worker */
1913 #define PF_FORKNOEXEC   0x00000040      /* forked but didn't exec */
1914 #define PF_MCE_PROCESS  0x00000080      /* process policy on mce errors */
1915 #define PF_SUPERPRIV    0x00000100      /* used super-user privileges */
1916 #define PF_DUMPCORE     0x00000200      /* dumped core */
1917 #define PF_SIGNALED     0x00000400      /* killed by a signal */
1918 #define PF_MEMALLOC     0x00000800      /* Allocating memory */
1919 #define PF_NPROC_EXCEEDED 0x00001000    /* set_user noticed that RLIMIT_NPROC was exceeded */
1920 #define PF_USED_MATH    0x00002000      /* if unset the fpu must be initialized before use */
1921 #define PF_USED_ASYNC   0x00004000      /* used async_schedule*(), used by module init */
1922 #define PF_NOFREEZE     0x00008000      /* this thread should not be frozen */
1923 #define PF_FROZEN       0x00010000      /* frozen for system suspend */
1924 #define PF_FSTRANS      0x00020000      /* inside a filesystem transaction */
1925 #define PF_KSWAPD       0x00040000      /* I am kswapd */
1926 #define PF_MEMALLOC_NOIO 0x00080000     /* Allocating memory without IO involved */
1927 #define PF_LESS_THROTTLE 0x00100000     /* Throttle me less: I clean memory */
1928 #define PF_KTHREAD      0x00200000      /* I am a kernel thread */
1929 #define PF_RANDOMIZE    0x00400000      /* randomize virtual address space */
1930 #define PF_SWAPWRITE    0x00800000      /* Allowed to write to swap */
1931 #define PF_NO_SETAFFINITY 0x04000000    /* Userland is not allowed to meddle with cpus_allowed */
1932 #define PF_MCE_EARLY    0x08000000      /* Early kill for mce process policy */
1933 #define PF_MUTEX_TESTER 0x20000000      /* Thread belongs to the rt mutex tester */
1934 #define PF_FREEZER_SKIP 0x40000000      /* Freezer should not count it as freezable */
1935 #define PF_SUSPEND_TASK 0x80000000      /* this thread called freeze_processes and should not be frozen */
1936
1937 /*
1938  * Only the _current_ task can read/write to tsk->flags, but other
1939  * tasks can access tsk->flags in readonly mode for example
1940  * with tsk_used_math (like during threaded core dumping).
1941  * There is however an exception to this rule during ptrace
1942  * or during fork: the ptracer task is allowed to write to the
1943  * child->flags of its traced child (same goes for fork, the parent
1944  * can write to the child->flags), because we're guaranteed the
1945  * child is not running and in turn not changing child->flags
1946  * at the same time the parent does it.
1947  */
1948 #define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
1949 #define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
1950 #define clear_used_math() clear_stopped_child_used_math(current)
1951 #define set_used_math() set_stopped_child_used_math(current)
1952 #define conditional_stopped_child_used_math(condition, child) \
1953         do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
1954 #define conditional_used_math(condition) \
1955         conditional_stopped_child_used_math(condition, current)
1956 #define copy_to_stopped_child_used_math(child) \
1957         do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
1958 /* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
1959 #define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
1960 #define used_math() tsk_used_math(current)
1961
1962 /* __GFP_IO isn't allowed if PF_MEMALLOC_NOIO is set in current->flags
1963  * __GFP_FS is also cleared as it implies __GFP_IO.
1964  */
1965 static inline gfp_t memalloc_noio_flags(gfp_t flags)
1966 {
1967         if (unlikely(current->flags & PF_MEMALLOC_NOIO))
1968                 flags &= ~(__GFP_IO | __GFP_FS);
1969         return flags;
1970 }
1971
1972 static inline unsigned int memalloc_noio_save(void)
1973 {
1974         unsigned int flags = current->flags & PF_MEMALLOC_NOIO;
1975         current->flags |= PF_MEMALLOC_NOIO;
1976         return flags;
1977 }
1978
1979 static inline void memalloc_noio_restore(unsigned int flags)
1980 {
1981         current->flags = (current->flags & ~PF_MEMALLOC_NOIO) | flags;
1982 }
1983
1984 /* Per-process atomic flags. */
1985 #define PFA_NO_NEW_PRIVS 0      /* May not gain new privileges. */
1986 #define PFA_SPREAD_PAGE  1      /* Spread page cache over cpuset */
1987 #define PFA_SPREAD_SLAB  2      /* Spread some slab caches over cpuset */
1988
1989
1990 #define TASK_PFA_TEST(name, func)                                       \
1991         static inline bool task_##func(struct task_struct *p)           \
1992         { return test_bit(PFA_##name, &p->atomic_flags); }
1993 #define TASK_PFA_SET(name, func)                                        \
1994         static inline void task_set_##func(struct task_struct *p)       \
1995         { set_bit(PFA_##name, &p->atomic_flags); }
1996 #define TASK_PFA_CLEAR(name, func)                                      \
1997         static inline void task_clear_##func(struct task_struct *p)     \
1998         { clear_bit(PFA_##name, &p->atomic_flags); }
1999
2000 TASK_PFA_TEST(NO_NEW_PRIVS, no_new_privs)
2001 TASK_PFA_SET(NO_NEW_PRIVS, no_new_privs)
2002
2003 TASK_PFA_TEST(SPREAD_PAGE, spread_page)
2004 TASK_PFA_SET(SPREAD_PAGE, spread_page)
2005 TASK_PFA_CLEAR(SPREAD_PAGE, spread_page)
2006
2007 TASK_PFA_TEST(SPREAD_SLAB, spread_slab)
2008 TASK_PFA_SET(SPREAD_SLAB, spread_slab)
2009 TASK_PFA_CLEAR(SPREAD_SLAB, spread_slab)
2010
2011 /*
2012  * task->jobctl flags
2013  */
2014 #define JOBCTL_STOP_SIGMASK     0xffff  /* signr of the last group stop */
2015
2016 #define JOBCTL_STOP_DEQUEUED_BIT 16     /* stop signal dequeued */
2017 #define JOBCTL_STOP_PENDING_BIT 17      /* task should stop for group stop */
2018 #define JOBCTL_STOP_CONSUME_BIT 18      /* consume group stop count */
2019 #define JOBCTL_TRAP_STOP_BIT    19      /* trap for STOP */
2020 #define JOBCTL_TRAP_NOTIFY_BIT  20      /* trap for NOTIFY */
2021 #define JOBCTL_TRAPPING_BIT     21      /* switching to TRACED */
2022 #define JOBCTL_LISTENING_BIT    22      /* ptracer is listening for events */
2023
2024 #define JOBCTL_STOP_DEQUEUED    (1 << JOBCTL_STOP_DEQUEUED_BIT)
2025 #define JOBCTL_STOP_PENDING     (1 << JOBCTL_STOP_PENDING_BIT)
2026 #define JOBCTL_STOP_CONSUME     (1 << JOBCTL_STOP_CONSUME_BIT)
2027 #define JOBCTL_TRAP_STOP        (1 << JOBCTL_TRAP_STOP_BIT)
2028 #define JOBCTL_TRAP_NOTIFY      (1 << JOBCTL_TRAP_NOTIFY_BIT)
2029 #define JOBCTL_TRAPPING         (1 << JOBCTL_TRAPPING_BIT)
2030 #define JOBCTL_LISTENING        (1 << JOBCTL_LISTENING_BIT)
2031
2032 #define JOBCTL_TRAP_MASK        (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)
2033 #define JOBCTL_PENDING_MASK     (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)
2034
2035 extern bool task_set_jobctl_pending(struct task_struct *task,
2036                                     unsigned int mask);
2037 extern void task_clear_jobctl_trapping(struct task_struct *task);
2038 extern void task_clear_jobctl_pending(struct task_struct *task,
2039                                       unsigned int mask);
2040
2041 static inline void rcu_copy_process(struct task_struct *p)
2042 {
2043 #ifdef CONFIG_PREEMPT_RCU
2044         p->rcu_read_lock_nesting = 0;
2045         p->rcu_read_unlock_special.s = 0;
2046         p->rcu_blocked_node = NULL;
2047         INIT_LIST_HEAD(&p->rcu_node_entry);
2048 #endif /* #ifdef CONFIG_PREEMPT_RCU */
2049 #ifdef CONFIG_TASKS_RCU
2050         p->rcu_tasks_holdout = false;
2051         INIT_LIST_HEAD(&p->rcu_tasks_holdout_list);
2052         p->rcu_tasks_idle_cpu = -1;
2053 #endif /* #ifdef CONFIG_TASKS_RCU */
2054 }
2055
2056 static inline void tsk_restore_flags(struct task_struct *task,
2057                                 unsigned long orig_flags, unsigned long flags)
2058 {
2059         task->flags &= ~flags;
2060         task->flags |= orig_flags & flags;
2061 }
2062
2063 #ifdef CONFIG_SMP
2064 extern void do_set_cpus_allowed(struct task_struct *p,
2065                                const struct cpumask *new_mask);
2066
2067 extern int set_cpus_allowed_ptr(struct task_struct *p,
2068                                 const struct cpumask *new_mask);
2069 #else
2070 static inline void do_set_cpus_allowed(struct task_struct *p,
2071                                       const struct cpumask *new_mask)
2072 {
2073 }
2074 static inline int set_cpus_allowed_ptr(struct task_struct *p,
2075                                        const struct cpumask *new_mask)
2076 {
2077         if (!cpumask_test_cpu(0, new_mask))
2078                 return -EINVAL;
2079         return 0;
2080 }
2081 #endif
2082
2083 #ifdef CONFIG_NO_HZ_COMMON
2084 void calc_load_enter_idle(void);
2085 void calc_load_exit_idle(void);
2086 #else
2087 static inline void calc_load_enter_idle(void) { }
2088 static inline void calc_load_exit_idle(void) { }
2089 #endif /* CONFIG_NO_HZ_COMMON */
2090
2091 #ifndef CONFIG_CPUMASK_OFFSTACK
2092 static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
2093 {
2094         return set_cpus_allowed_ptr(p, &new_mask);
2095 }
2096 #endif
2097
2098 /*
2099  * Do not use outside of architecture code which knows its limitations.
2100  *
2101  * sched_clock() has no promise of monotonicity or bounded drift between
2102  * CPUs, use (which you should not) requires disabling IRQs.
2103  *
2104  * Please use one of the three interfaces below.
2105  */
2106 extern unsigned long long notrace sched_clock(void);
2107 /*
2108  * See the comment in kernel/sched/clock.c
2109  */
2110 extern u64 cpu_clock(int cpu);
2111 extern u64 local_clock(void);
2112 extern u64 sched_clock_cpu(int cpu);
2113
2114
2115 extern void sched_clock_init(void);
2116
2117 #ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
2118 static inline void sched_clock_tick(void)
2119 {
2120 }
2121
2122 static inline void sched_clock_idle_sleep_event(void)
2123 {
2124 }
2125
2126 static inline void sched_clock_idle_wakeup_event(u64 delta_ns)
2127 {
2128 }
2129 #else
2130 /*
2131  * Architectures can set this to 1 if they have specified
2132  * CONFIG_HAVE_UNSTABLE_SCHED_CLOCK in their arch Kconfig,
2133  * but then during bootup it turns out that sched_clock()
2134  * is reliable after all:
2135  */
2136 extern int sched_clock_stable(void);
2137 extern void set_sched_clock_stable(void);
2138 extern void clear_sched_clock_stable(void);
2139
2140 extern void sched_clock_tick(void);
2141 extern void sched_clock_idle_sleep_event(void);
2142 extern void sched_clock_idle_wakeup_event(u64 delta_ns);
2143 #endif
2144
2145 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
2146 /*
2147  * An i/f to runtime opt-in for irq time accounting based off of sched_clock.
2148  * The reason for this explicit opt-in is not to have perf penalty with
2149  * slow sched_clocks.
2150  */
2151 extern void enable_sched_clock_irqtime(void);
2152 extern void disable_sched_clock_irqtime(void);
2153 #else
2154 static inline void enable_sched_clock_irqtime(void) {}
2155 static inline void disable_sched_clock_irqtime(void) {}
2156 #endif
2157
2158 extern unsigned long long
2159 task_sched_runtime(struct task_struct *task);
2160
2161 /* sched_exec is called by processes performing an exec */
2162 #ifdef CONFIG_SMP
2163 extern void sched_exec(void);
2164 #else
2165 #define sched_exec()   {}
2166 #endif
2167
2168 extern void sched_clock_idle_sleep_event(void);
2169 extern void sched_clock_idle_wakeup_event(u64 delta_ns);
2170
2171 #ifdef CONFIG_HOTPLUG_CPU
2172 extern void idle_task_exit(void);
2173 #else
2174 static inline void idle_task_exit(void) {}
2175 #endif
2176
2177 #if defined(CONFIG_NO_HZ_COMMON) && defined(CONFIG_SMP)
2178 extern void wake_up_nohz_cpu(int cpu);
2179 #else
2180 static inline void wake_up_nohz_cpu(int cpu) { }
2181 #endif
2182
2183 #ifdef CONFIG_NO_HZ_FULL
2184 extern bool sched_can_stop_tick(void);
2185 extern u64 scheduler_tick_max_deferment(void);
2186 #else
2187 static inline bool sched_can_stop_tick(void) { return false; }
2188 #endif
2189
2190 #ifdef CONFIG_SCHED_AUTOGROUP
2191 extern void sched_autogroup_create_attach(struct task_struct *p);
2192 extern void sched_autogroup_detach(struct task_struct *p);
2193 extern void sched_autogroup_fork(struct signal_struct *sig);
2194 extern void sched_autogroup_exit(struct signal_struct *sig);
2195 #ifdef CONFIG_PROC_FS
2196 extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m);
2197 extern int proc_sched_autogroup_set_nice(struct task_struct *p, int nice);
2198 #endif
2199 #else
2200 static inline void sched_autogroup_create_attach(struct task_struct *p) { }
2201 static inline void sched_autogroup_detach(struct task_struct *p) { }
2202 static inline void sched_autogroup_fork(struct signal_struct *sig) { }
2203 static inline void sched_autogroup_exit(struct signal_struct *sig) { }
2204 #endif
2205
2206 extern int yield_to(struct task_struct *p, bool preempt);
2207 extern void set_user_nice(struct task_struct *p, long nice);
2208 extern int task_prio(const struct task_struct *p);
2209 /**
2210  * task_nice - return the nice value of a given task.
2211  * @p: the task in question.
2212  *
2213  * Return: The nice value [ -20 ... 0 ... 19 ].
2214  */
2215 static inline int task_nice(const struct task_struct *p)
2216 {
2217         return PRIO_TO_NICE((p)->static_prio);
2218 }
2219 extern int can_nice(const struct task_struct *p, const int nice);
2220 extern int task_curr(const struct task_struct *p);
2221 extern int idle_cpu(int cpu);
2222 extern int sched_setscheduler(struct task_struct *, int,
2223                               const struct sched_param *);
2224 extern int sched_setscheduler_nocheck(struct task_struct *, int,
2225                                       const struct sched_param *);
2226 extern int sched_setattr(struct task_struct *,
2227                          const struct sched_attr *);
2228 extern struct task_struct *idle_task(int cpu);
2229 /**
2230  * is_idle_task - is the specified task an idle task?
2231  * @p: the task in question.
2232  *
2233  * Return: 1 if @p is an idle task. 0 otherwise.
2234  */
2235 static inline bool is_idle_task(const struct task_struct *p)
2236 {
2237         return p->pid == 0;
2238 }
2239 extern struct task_struct *curr_task(int cpu);
2240 extern void set_curr_task(int cpu, struct task_struct *p);
2241
2242 void yield(void);
2243
2244 /*
2245  * The default (Linux) execution domain.
2246  */
2247 extern struct exec_domain       default_exec_domain;
2248
2249 union thread_union {
2250         struct thread_info thread_info;
2251         unsigned long stack[THREAD_SIZE/sizeof(long)];
2252 };
2253
2254 #ifndef __HAVE_ARCH_KSTACK_END
2255 static inline int kstack_end(void *addr)
2256 {
2257         /* Reliable end of stack detection:
2258          * Some APM bios versions misalign the stack
2259          */
2260         return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
2261 }
2262 #endif
2263
2264 extern union thread_union init_thread_union;
2265 extern struct task_struct init_task;
2266
2267 extern struct   mm_struct init_mm;
2268
2269 extern struct pid_namespace init_pid_ns;
2270
2271 /*
2272  * find a task by one of its numerical ids
2273  *
2274  * find_task_by_pid_ns():
2275  *      finds a task by its pid in the specified namespace
2276  * find_task_by_vpid():
2277  *      finds a task by its virtual pid
2278  *
2279  * see also find_vpid() etc in include/linux/pid.h
2280  */
2281
2282 extern struct task_struct *find_task_by_vpid(pid_t nr);
2283 extern struct task_struct *find_task_by_pid_ns(pid_t nr,
2284                 struct pid_namespace *ns);
2285
2286 /* per-UID process charging. */
2287 extern struct user_struct * alloc_uid(kuid_t);
2288 static inline struct user_struct *get_uid(struct user_struct *u)
2289 {
2290         atomic_inc(&u->__count);
2291         return u;
2292 }
2293 extern void free_uid(struct user_struct *);
2294
2295 #include <asm/current.h>
2296
2297 extern void xtime_update(unsigned long ticks);
2298
2299 extern int wake_up_state(struct task_struct *tsk, unsigned int state);
2300 extern int wake_up_process(struct task_struct *tsk);
2301 extern void wake_up_new_task(struct task_struct *tsk);
2302 #ifdef CONFIG_SMP
2303  extern void kick_process(struct task_struct *tsk);
2304 #else
2305  static inline void kick_process(struct task_struct *tsk) { }
2306 #endif
2307 extern int sched_fork(unsigned long clone_flags, struct task_struct *p);
2308 extern void sched_dead(struct task_struct *p);
2309
2310 extern void proc_caches_init(void);
2311 extern void flush_signals(struct task_struct *);
2312 extern void __flush_signals(struct task_struct *);
2313 extern void ignore_signals(struct task_struct *);
2314 extern void flush_signal_handlers(struct task_struct *, int force_default);
2315 extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
2316
2317 static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
2318 {
2319         unsigned long flags;
2320         int ret;
2321
2322         spin_lock_irqsave(&tsk->sighand->siglock, flags);
2323         ret = dequeue_signal(tsk, mask, info);
2324         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
2325
2326         return ret;
2327 }
2328
2329 extern void block_all_signals(int (*notifier)(void *priv), void *priv,
2330                               sigset_t *mask);
2331 extern void unblock_all_signals(void);
2332 extern void release_task(struct task_struct * p);
2333 extern int send_sig_info(int, struct siginfo *, struct task_struct *);
2334 extern int force_sigsegv(int, struct task_struct *);
2335 extern int force_sig_info(int, struct siginfo *, struct task_struct *);
2336 extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
2337 extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
2338 extern int kill_pid_info_as_cred(int, struct siginfo *, struct pid *,
2339                                 const struct cred *, u32);
2340 extern int kill_pgrp(struct pid *pid, int sig, int priv);
2341 extern int kill_pid(struct pid *pid, int sig, int priv);
2342 extern int kill_proc_info(int, struct siginfo *, pid_t);
2343 extern __must_check bool do_notify_parent(struct task_struct *, int);
2344 extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
2345 extern void force_sig(int, struct task_struct *);
2346 extern int send_sig(int, struct task_struct *, int);
2347 extern int zap_other_threads(struct task_struct *p);
2348 extern struct sigqueue *sigqueue_alloc(void);
2349 extern void sigqueue_free(struct sigqueue *);
2350 extern int send_sigqueue(struct sigqueue *,  struct task_struct *, int group);
2351 extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
2352
2353 static inline void restore_saved_sigmask(void)
2354 {
2355         if (test_and_clear_restore_sigmask())
2356                 __set_current_blocked(&current->saved_sigmask);
2357 }
2358
2359 static inline sigset_t *sigmask_to_save(void)
2360 {
2361         sigset_t *res = &current->blocked;
2362         if (unlikely(test_restore_sigmask()))
2363                 res = &current->saved_sigmask;
2364         return res;
2365 }
2366
2367 static inline int kill_cad_pid(int sig, int priv)
2368 {
2369         return kill_pid(cad_pid, sig, priv);
2370 }
2371
2372 /* These can be the second arg to send_sig_info/send_group_sig_info.  */
2373 #define SEND_SIG_NOINFO ((struct siginfo *) 0)
2374 #define SEND_SIG_PRIV   ((struct siginfo *) 1)
2375 #define SEND_SIG_FORCED ((struct siginfo *) 2)
2376
2377 /*
2378  * True if we are on the alternate signal stack.
2379  */
2380 static inline int on_sig_stack(unsigned long sp)
2381 {
2382 #ifdef CONFIG_STACK_GROWSUP
2383         return sp >= current->sas_ss_sp &&
2384                 sp - current->sas_ss_sp < current->sas_ss_size;
2385 #else
2386         return sp > current->sas_ss_sp &&
2387                 sp - current->sas_ss_sp <= current->sas_ss_size;
2388 #endif
2389 }
2390
2391 static inline int sas_ss_flags(unsigned long sp)
2392 {
2393         if (!current->sas_ss_size)
2394                 return SS_DISABLE;
2395
2396         return on_sig_stack(sp) ? SS_ONSTACK : 0;
2397 }
2398
2399 static inline unsigned long sigsp(unsigned long sp, struct ksignal *ksig)
2400 {
2401         if (unlikely((ksig->ka.sa.sa_flags & SA_ONSTACK)) && ! sas_ss_flags(sp))
2402 #ifdef CONFIG_STACK_GROWSUP
2403                 return current->sas_ss_sp;
2404 #else
2405                 return current->sas_ss_sp + current->sas_ss_size;
2406 #endif
2407         return sp;
2408 }
2409
2410 /*
2411  * Routines for handling mm_structs
2412  */
2413 extern struct mm_struct * mm_alloc(void);
2414
2415 /* mmdrop drops the mm and the page tables */
2416 extern void __mmdrop(struct mm_struct *);
2417 static inline void mmdrop(struct mm_struct * mm)
2418 {
2419         if (unlikely(atomic_dec_and_test(&mm->mm_count)))
2420                 __mmdrop(mm);
2421 }
2422
2423 /* mmput gets rid of the mappings and all user-space */
2424 extern void mmput(struct mm_struct *);
2425 /* Grab a reference to a task's mm, if it is not already going away */
2426 extern struct mm_struct *get_task_mm(struct task_struct *task);
2427 /*
2428  * Grab a reference to a task's mm, if it is not already going away
2429  * and ptrace_may_access with the mode parameter passed to it
2430  * succeeds.
2431  */
2432 extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);
2433 /* Remove the current tasks stale references to the old mm_struct */
2434 extern void mm_release(struct task_struct *, struct mm_struct *);
2435
2436 extern int copy_thread(unsigned long, unsigned long, unsigned long,
2437                         struct task_struct *);
2438 extern void flush_thread(void);
2439 extern void exit_thread(void);
2440
2441 extern void exit_files(struct task_struct *);
2442 extern void __cleanup_sighand(struct sighand_struct *);
2443
2444 extern void exit_itimers(struct signal_struct *);
2445 extern void flush_itimer_signals(void);
2446
2447 extern void do_group_exit(int);
2448
2449 extern int do_execve(struct filename *,
2450                      const char __user * const __user *,
2451                      const char __user * const __user *);
2452 extern long do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *);
2453 struct task_struct *fork_idle(int);
2454 extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
2455
2456 extern void __set_task_comm(struct task_struct *tsk, const char *from, bool exec);
2457 static inline void set_task_comm(struct task_struct *tsk, const char *from)
2458 {
2459         __set_task_comm(tsk, from, false);
2460 }
2461 extern char *get_task_comm(char *to, struct task_struct *tsk);
2462
2463 #ifdef CONFIG_SMP
2464 void scheduler_ipi(void);
2465 extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
2466 #else
2467 static inline void scheduler_ipi(void) { }
2468 static inline unsigned long wait_task_inactive(struct task_struct *p,
2469                                                long match_state)
2470 {
2471         return 1;
2472 }
2473 #endif
2474
2475 #define next_task(p) \
2476         list_entry_rcu((p)->tasks.next, struct task_struct, tasks)
2477
2478 #define for_each_process(p) \
2479         for (p = &init_task ; (p = next_task(p)) != &init_task ; )
2480
2481 extern bool current_is_single_threaded(void);
2482
2483 /*
2484  * Careful: do_each_thread/while_each_thread is a double loop so
2485  *          'break' will not work as expected - use goto instead.
2486  */
2487 #define do_each_thread(g, t) \
2488         for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
2489
2490 #define while_each_thread(g, t) \
2491         while ((t = next_thread(t)) != g)
2492
2493 #define __for_each_thread(signal, t)    \
2494         list_for_each_entry_rcu(t, &(signal)->thread_head, thread_node)
2495
2496 #define for_each_thread(p, t)           \
2497         __for_each_thread((p)->signal, t)
2498
2499 /* Careful: this is a double loop, 'break' won't work as expected. */
2500 #define for_each_process_thread(p, t)   \
2501         for_each_process(p) for_each_thread(p, t)
2502
2503 static inline int get_nr_threads(struct task_struct *tsk)
2504 {
2505         return tsk->signal->nr_threads;
2506 }
2507
2508 static inline bool thread_group_leader(struct task_struct *p)
2509 {
2510         return p->exit_signal >= 0;
2511 }
2512
2513 /* Do to the insanities of de_thread it is possible for a process
2514  * to have the pid of the thread group leader without actually being
2515  * the thread group leader.  For iteration through the pids in proc
2516  * all we care about is that we have a task with the appropriate
2517  * pid, we don't actually care if we have the right task.
2518  */
2519 static inline bool has_group_leader_pid(struct task_struct *p)
2520 {
2521         return task_pid(p) == p->signal->leader_pid;
2522 }
2523
2524 static inline
2525 bool same_thread_group(struct task_struct *p1, struct task_struct *p2)
2526 {
2527         return p1->signal == p2->signal;
2528 }
2529
2530 static inline struct task_struct *next_thread(const struct task_struct *p)
2531 {
2532         return list_entry_rcu(p->thread_group.next,
2533                               struct task_struct, thread_group);
2534 }
2535
2536 static inline int thread_group_empty(struct task_struct *p)
2537 {
2538         return list_empty(&p->thread_group);
2539 }
2540
2541 #define delay_group_leader(p) \
2542                 (thread_group_leader(p) && !thread_group_empty(p))
2543
2544 /*
2545  * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
2546  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
2547  * pins the final release of task.io_context.  Also protects ->cpuset and
2548  * ->cgroup.subsys[]. And ->vfork_done.
2549  *
2550  * Nests both inside and outside of read_lock(&tasklist_lock).
2551  * It must not be nested with write_lock_irq(&tasklist_lock),
2552  * neither inside nor outside.
2553  */
2554 static inline void task_lock(struct task_struct *p)
2555 {
2556         spin_lock(&p->alloc_lock);
2557 }
2558
2559 static inline void task_unlock(struct task_struct *p)
2560 {
2561         spin_unlock(&p->alloc_lock);
2562 }
2563
2564 extern struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
2565                                                         unsigned long *flags);
2566
2567 static inline struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
2568                                                        unsigned long *flags)
2569 {
2570         struct sighand_struct *ret;
2571
2572         ret = __lock_task_sighand(tsk, flags);
2573         (void)__cond_lock(&tsk->sighand->siglock, ret);
2574         return ret;
2575 }
2576
2577 static inline void unlock_task_sighand(struct task_struct *tsk,
2578                                                 unsigned long *flags)
2579 {
2580         spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
2581 }
2582
2583 #ifdef CONFIG_CGROUPS
2584 static inline void threadgroup_change_begin(struct task_struct *tsk)
2585 {
2586         down_read(&tsk->signal->group_rwsem);
2587 }
2588 static inline void threadgroup_change_end(struct task_struct *tsk)
2589 {
2590         up_read(&tsk->signal->group_rwsem);
2591 }
2592
2593 /**
2594  * threadgroup_lock - lock threadgroup
2595  * @tsk: member task of the threadgroup to lock
2596  *
2597  * Lock the threadgroup @tsk belongs to.  No new task is allowed to enter
2598  * and member tasks aren't allowed to exit (as indicated by PF_EXITING) or
2599  * change ->group_leader/pid.  This is useful for cases where the threadgroup
2600  * needs to stay stable across blockable operations.
2601  *
2602  * fork and exit paths explicitly call threadgroup_change_{begin|end}() for
2603  * synchronization.  While held, no new task will be added to threadgroup
2604  * and no existing live task will have its PF_EXITING set.
2605  *
2606  * de_thread() does threadgroup_change_{begin|end}() when a non-leader
2607  * sub-thread becomes a new leader.
2608  */
2609 static inline void threadgroup_lock(struct task_struct *tsk)
2610 {
2611         down_write(&tsk->signal->group_rwsem);
2612 }
2613
2614 /**
2615  * threadgroup_unlock - unlock threadgroup
2616  * @tsk: member task of the threadgroup to unlock
2617  *
2618  * Reverse threadgroup_lock().
2619  */
2620 static inline void threadgroup_unlock(struct task_struct *tsk)
2621 {
2622         up_write(&tsk->signal->group_rwsem);
2623 }
2624 #else
2625 static inline void threadgroup_change_begin(struct task_struct *tsk) {}
2626 static inline void threadgroup_change_end(struct task_struct *tsk) {}
2627 static inline void threadgroup_lock(struct task_struct *tsk) {}
2628 static inline void threadgroup_unlock(struct task_struct *tsk) {}
2629 #endif
2630
2631 #ifndef __HAVE_THREAD_FUNCTIONS
2632
2633 #define task_thread_info(task)  ((struct thread_info *)(task)->stack)
2634 #define task_stack_page(task)   ((task)->stack)
2635
2636 static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
2637 {
2638         *task_thread_info(p) = *task_thread_info(org);
2639         task_thread_info(p)->task = p;
2640 }
2641
2642 /*
2643  * Return the address of the last usable long on the stack.
2644  *
2645  * When the stack grows down, this is just above the thread
2646  * info struct. Going any lower will corrupt the threadinfo.
2647  *
2648  * When the stack grows up, this is the highest address.
2649  * Beyond that position, we corrupt data on the next page.
2650  */
2651 static inline unsigned long *end_of_stack(struct task_struct *p)
2652 {
2653 #ifdef CONFIG_STACK_GROWSUP
2654         return (unsigned long *)((unsigned long)task_thread_info(p) + THREAD_SIZE) - 1;
2655 #else
2656         return (unsigned long *)(task_thread_info(p) + 1);
2657 #endif
2658 }
2659
2660 #endif
2661 #define task_stack_end_corrupted(task) \
2662                 (*(end_of_stack(task)) != STACK_END_MAGIC)
2663
2664 static inline int object_is_on_stack(void *obj)
2665 {
2666         void *stack = task_stack_page(current);
2667
2668         return (obj >= stack) && (obj < (stack + THREAD_SIZE));
2669 }
2670
2671 extern void thread_info_cache_init(void);
2672
2673 #ifdef CONFIG_DEBUG_STACK_USAGE
2674 static inline unsigned long stack_not_used(struct task_struct *p)
2675 {
2676         unsigned long *n = end_of_stack(p);
2677
2678         do {    /* Skip over canary */
2679                 n++;
2680         } while (!*n);
2681
2682         return (unsigned long)n - (unsigned long)end_of_stack(p);
2683 }
2684 #endif
2685 extern void set_task_stack_end_magic(struct task_struct *tsk);
2686
2687 /* set thread flags in other task's structures
2688  * - see asm/thread_info.h for TIF_xxxx flags available
2689  */
2690 static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
2691 {
2692         set_ti_thread_flag(task_thread_info(tsk), flag);
2693 }
2694
2695 static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2696 {
2697         clear_ti_thread_flag(task_thread_info(tsk), flag);
2698 }
2699
2700 static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
2701 {
2702         return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
2703 }
2704
2705 static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2706 {
2707         return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
2708 }
2709
2710 static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
2711 {
2712         return test_ti_thread_flag(task_thread_info(tsk), flag);
2713 }
2714
2715 static inline void set_tsk_need_resched(struct task_struct *tsk)
2716 {
2717         set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2718 }
2719
2720 static inline void clear_tsk_need_resched(struct task_struct *tsk)
2721 {
2722         clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2723 }
2724
2725 static inline int test_tsk_need_resched(struct task_struct *tsk)
2726 {
2727         return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
2728 }
2729
2730 static inline int restart_syscall(void)
2731 {
2732         set_tsk_thread_flag(current, TIF_SIGPENDING);
2733         return -ERESTARTNOINTR;
2734 }
2735
2736 static inline int signal_pending(struct task_struct *p)
2737 {
2738         return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
2739 }
2740
2741 static inline int __fatal_signal_pending(struct task_struct *p)
2742 {
2743         return unlikely(sigismember(&p->pending.signal, SIGKILL));
2744 }
2745
2746 static inline int fatal_signal_pending(struct task_struct *p)
2747 {
2748         return signal_pending(p) && __fatal_signal_pending(p);
2749 }
2750
2751 static inline int signal_pending_state(long state, struct task_struct *p)
2752 {
2753         if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
2754                 return 0;
2755         if (!signal_pending(p))
2756                 return 0;
2757
2758         return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
2759 }
2760
2761 /*
2762  * cond_resched() and cond_resched_lock(): latency reduction via
2763  * explicit rescheduling in places that are safe. The return
2764  * value indicates whether a reschedule was done in fact.
2765  * cond_resched_lock() will drop the spinlock before scheduling,
2766  * cond_resched_softirq() will enable bhs before scheduling.
2767  */
2768 extern int _cond_resched(void);
2769
2770 #define cond_resched() ({                       \
2771         __might_sleep(__FILE__, __LINE__, 0);   \
2772         _cond_resched();                        \
2773 })
2774
2775 extern int __cond_resched_lock(spinlock_t *lock);
2776
2777 #ifdef CONFIG_PREEMPT_COUNT
2778 #define PREEMPT_LOCK_OFFSET     PREEMPT_OFFSET
2779 #else
2780 #define PREEMPT_LOCK_OFFSET     0
2781 #endif
2782
2783 #define cond_resched_lock(lock) ({                              \
2784         __might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET); \
2785         __cond_resched_lock(lock);                              \
2786 })
2787
2788 extern int __cond_resched_softirq(void);
2789
2790 #define cond_resched_softirq() ({                                       \
2791         __might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET);      \
2792         __cond_resched_softirq();                                       \
2793 })
2794
2795 static inline void cond_resched_rcu(void)
2796 {
2797 #if defined(CONFIG_DEBUG_ATOMIC_SLEEP) || !defined(CONFIG_PREEMPT_RCU)
2798         rcu_read_unlock();
2799         cond_resched();
2800         rcu_read_lock();
2801 #endif
2802 }
2803
2804 /*
2805  * Does a critical section need to be broken due to another
2806  * task waiting?: (technically does not depend on CONFIG_PREEMPT,
2807  * but a general need for low latency)
2808  */
2809 static inline int spin_needbreak(spinlock_t *lock)
2810 {
2811 #ifdef CONFIG_PREEMPT
2812         return spin_is_contended(lock);
2813 #else
2814         return 0;
2815 #endif
2816 }
2817
2818 /*
2819  * Idle thread specific functions to determine the need_resched
2820  * polling state.
2821  */
2822 #ifdef TIF_POLLING_NRFLAG
2823 static inline int tsk_is_polling(struct task_struct *p)
2824 {
2825         return test_tsk_thread_flag(p, TIF_POLLING_NRFLAG);
2826 }
2827
2828 static inline void __current_set_polling(void)
2829 {
2830         set_thread_flag(TIF_POLLING_NRFLAG);
2831 }
2832
2833 static inline bool __must_check current_set_polling_and_test(void)
2834 {
2835         __current_set_polling();
2836
2837         /*
2838          * Polling state must be visible before we test NEED_RESCHED,
2839          * paired by resched_curr()
2840          */
2841         smp_mb__after_atomic();
2842
2843         return unlikely(tif_need_resched());
2844 }
2845
2846 static inline void __current_clr_polling(void)
2847 {
2848         clear_thread_flag(TIF_POLLING_NRFLAG);
2849 }
2850
2851 static inline bool __must_check current_clr_polling_and_test(void)
2852 {
2853         __current_clr_polling();
2854
2855         /*
2856          * Polling state must be visible before we test NEED_RESCHED,
2857          * paired by resched_curr()
2858          */
2859         smp_mb__after_atomic();
2860
2861         return unlikely(tif_need_resched());
2862 }
2863
2864 #else
2865 static inline int tsk_is_polling(struct task_struct *p) { return 0; }
2866 static inline void __current_set_polling(void) { }
2867 static inline void __current_clr_polling(void) { }
2868
2869 static inline bool __must_check current_set_polling_and_test(void)
2870 {
2871         return unlikely(tif_need_resched());
2872 }
2873 static inline bool __must_check current_clr_polling_and_test(void)
2874 {
2875         return unlikely(tif_need_resched());
2876 }
2877 #endif
2878
2879 static inline void current_clr_polling(void)
2880 {
2881         __current_clr_polling();
2882
2883         /*
2884          * Ensure we check TIF_NEED_RESCHED after we clear the polling bit.
2885          * Once the bit is cleared, we'll get IPIs with every new
2886          * TIF_NEED_RESCHED and the IPI handler, scheduler_ipi(), will also
2887          * fold.
2888          */
2889         smp_mb(); /* paired with resched_curr() */
2890
2891         preempt_fold_need_resched();
2892 }
2893
2894 static __always_inline bool need_resched(void)
2895 {
2896         return unlikely(tif_need_resched());
2897 }
2898
2899 /*
2900  * Thread group CPU time accounting.
2901  */
2902 void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
2903 void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
2904
2905 static inline void thread_group_cputime_init(struct signal_struct *sig)
2906 {
2907         raw_spin_lock_init(&sig->cputimer.lock);
2908 }
2909
2910 /*
2911  * Reevaluate whether the task has signals pending delivery.
2912  * Wake the task if so.
2913  * This is required every time the blocked sigset_t changes.
2914  * callers must hold sighand->siglock.
2915  */
2916 extern void recalc_sigpending_and_wake(struct task_struct *t);
2917 extern void recalc_sigpending(void);
2918
2919 extern void signal_wake_up_state(struct task_struct *t, unsigned int state);
2920
2921 static inline void signal_wake_up(struct task_struct *t, bool resume)
2922 {
2923         signal_wake_up_state(t, resume ? TASK_WAKEKILL : 0);
2924 }
2925 static inline void ptrace_signal_wake_up(struct task_struct *t, bool resume)
2926 {
2927         signal_wake_up_state(t, resume ? __TASK_TRACED : 0);
2928 }
2929
2930 /*
2931  * Wrappers for p->thread_info->cpu access. No-op on UP.
2932  */
2933 #ifdef CONFIG_SMP
2934
2935 static inline unsigned int task_cpu(const struct task_struct *p)
2936 {
2937         return task_thread_info(p)->cpu;
2938 }
2939
2940 static inline int task_node(const struct task_struct *p)
2941 {
2942         return cpu_to_node(task_cpu(p));
2943 }
2944
2945 extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
2946
2947 #else
2948
2949 static inline unsigned int task_cpu(const struct task_struct *p)
2950 {
2951         return 0;
2952 }
2953
2954 static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
2955 {
2956 }
2957
2958 #endif /* CONFIG_SMP */
2959
2960 extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
2961 extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
2962
2963 #ifdef CONFIG_CGROUP_SCHED
2964 extern struct task_group root_task_group;
2965 #endif /* CONFIG_CGROUP_SCHED */
2966
2967 extern int task_can_switch_user(struct user_struct *up,
2968                                         struct task_struct *tsk);
2969
2970 #ifdef CONFIG_TASK_XACCT
2971 static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2972 {
2973         tsk->ioac.rchar += amt;
2974 }
2975
2976 static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2977 {
2978         tsk->ioac.wchar += amt;
2979 }
2980
2981 static inline void inc_syscr(struct task_struct *tsk)
2982 {
2983         tsk->ioac.syscr++;
2984 }
2985
2986 static inline void inc_syscw(struct task_struct *tsk)
2987 {
2988         tsk->ioac.syscw++;
2989 }
2990 #else
2991 static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2992 {
2993 }
2994
2995 static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2996 {
2997 }
2998
2999 static inline void inc_syscr(struct task_struct *tsk)
3000 {
3001 }
3002
3003 static inline void inc_syscw(struct task_struct *tsk)
3004 {
3005 }
3006 #endif
3007
3008 #ifndef TASK_SIZE_OF
3009 #define TASK_SIZE_OF(tsk)       TASK_SIZE
3010 #endif
3011
3012 #ifdef CONFIG_MEMCG
3013 extern void mm_update_next_owner(struct mm_struct *mm);
3014 #else
3015 static inline void mm_update_next_owner(struct mm_struct *mm)
3016 {
3017 }
3018 #endif /* CONFIG_MEMCG */
3019
3020 static inline unsigned long task_rlimit(const struct task_struct *tsk,
3021                 unsigned int limit)
3022 {
3023         return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_cur);
3024 }
3025
3026 static inline unsigned long task_rlimit_max(const struct task_struct *tsk,
3027                 unsigned int limit)
3028 {
3029         return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_max);
3030 }
3031
3032 static inline unsigned long rlimit(unsigned int limit)
3033 {
3034         return task_rlimit(current, limit);
3035 }
3036
3037 static inline unsigned long rlimit_max(unsigned int limit)
3038 {
3039         return task_rlimit_max(current, limit);
3040 }
3041
3042 #endif