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 #include <asm/param.h>  /* for HZ */
   9
  10 #include <linux/capability.h>
  11 #include <linux/threads.h>
  12 #include <linux/kernel.h>
  13 #include <linux/types.h>
  14 #include <linux/timex.h>
  15 #include <linux/jiffies.h>
  16 #include <linux/mutex.h>
  17 #include <linux/plist.h>
  18 #include <linux/rbtree.h>
  19 #include <linux/thread_info.h>
  20 #include <linux/cpumask.h>
  21 #include <linux/errno.h>
  22 #include <linux/nodemask.h>
  23 #include <linux/mm_types.h>
  24 #include <linux/preempt.h>
  25
  26 #include <asm/page.h>
  27 #include <asm/ptrace.h>
  28
  29 #include <linux/smp.h>
  30 #include <linux/sem.h>
  31 #include <linux/shm.h>
  32 #include <linux/signal.h>
  33 #include <linux/compiler.h>
  34 #include <linux/completion.h>
  35 #include <linux/signal_types.h>
  36 #include <linux/pid.h>
  37 #include <linux/percpu.h>
  38 #include <linux/topology.h>
  39 #include <linux/seccomp.h>
  40 #include <linux/rcupdate.h>
  41 #include <linux/rculist.h>
  42 #include <linux/rtmutex.h>
  43
  44 #include <linux/time.h>
  45 #include <linux/param.h>
  46 #include <linux/resource.h>
  47 #include <linux/timer.h>
  48 #include <linux/hrtimer.h>
  49 #include <linux/kcov.h>
  50 #include <linux/task_io_accounting.h>
  51 #include <linux/latencytop.h>
  52 #include <linux/cred.h>
  53 #include <linux/llist.h>
  54 #include <linux/uidgid.h>
  55 #include <linux/gfp.h>
  56 #include <linux/topology.h>
  57 #include <linux/magic.h>
  58 #include <linux/cgroup-defs.h>
  59
  60 #include <asm/processor.h>
  61
  62 struct sched_attr;
  63 struct sched_param;
  64
  65 struct futex_pi_state;
  66 struct robust_list_head;
  67 struct bio_list;
  68 struct fs_struct;
  69 struct perf_event_context;
  70 struct blk_plug;
  71 struct filename;
  72 struct nameidata;
  73
  74 struct signal_struct;
  75 struct sighand_struct;
  76
  77 extern unsigned long total_forks;
  78 extern int nr_threads;
  79 DECLARE_PER_CPU(unsigned long, process_counts);
  80 extern int nr_processes(void);
  81 extern unsigned long nr_running(void);
  82 extern bool single_task_running(void);
  83 extern unsigned long nr_iowait(void);
  84 extern unsigned long nr_iowait_cpu(int cpu);
  85 extern void get_iowait_load(unsigned long *nr_waiters, unsigned long *load);
  86
  87 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
  88 extern void cpu_load_update_nohz_start(void);
  89 extern void cpu_load_update_nohz_stop(void);
  90 #else
  91 static inline void cpu_load_update_nohz_start(void) { }
  92 static inline void cpu_load_update_nohz_stop(void) { }
  93 #endif
  94
  95 extern void dump_cpu_task(int cpu);
  96
  97 struct seq_file;
  98 struct cfs_rq;
  99 struct task_group;
 100 #ifdef CONFIG_SCHED_DEBUG
 101 extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
 102 extern void proc_sched_set_task(struct task_struct *p);
 103 #endif
 104
 105 /*
 106  * Task state bitmask. NOTE! These bits are also
 107  * encoded in fs/proc/array.c: get_task_state().
 108  *
 109  * We have two separate sets of flags: task->state
 110  * is about runnability, while task->exit_state are
 111  * about the task exiting. Confusing, but this way
 112  * modifying one set can't modify the other one by
 113  * mistake.
 114  */
 115 #define TASK_RUNNING            0
 116 #define TASK_INTERRUPTIBLE      1
 117 #define TASK_UNINTERRUPTIBLE    2
 118 #define __TASK_STOPPED          4
 119 #define __TASK_TRACED           8
 120 /* in tsk->exit_state */
 121 #define EXIT_DEAD               16
 122 #define EXIT_ZOMBIE             32
 123 #define EXIT_TRACE              (EXIT_ZOMBIE | EXIT_DEAD)
 124 /* in tsk->state again */
 125 #define TASK_DEAD               64
 126 #define TASK_WAKEKILL           128
 127 #define TASK_WAKING             256
 128 #define TASK_PARKED             512
 129 #define TASK_NOLOAD             1024
 130 #define TASK_NEW                2048
 131 #define TASK_STATE_MAX          4096
 132
 133 #define TASK_STATE_TO_CHAR_STR "RSDTtXZxKWPNn"
 134
 135 /* Convenience macros for the sake of set_current_state */
 136 #define TASK_KILLABLE           (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
 137 #define TASK_STOPPED            (TASK_WAKEKILL | __TASK_STOPPED)
 138 #define TASK_TRACED             (TASK_WAKEKILL | __TASK_TRACED)
 139
 140 #define TASK_IDLE               (TASK_UNINTERRUPTIBLE | TASK_NOLOAD)
 141
 142 /* Convenience macros for the sake of wake_up */
 143 #define TASK_NORMAL             (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
 144 #define TASK_ALL                (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
 145
 146 /* get_task_state() */
 147 #define TASK_REPORT             (TASK_RUNNING | TASK_INTERRUPTIBLE | \
 148                                  TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
 149                                  __TASK_TRACED | EXIT_ZOMBIE | EXIT_DEAD)
 150
 151 #define task_is_traced(task)    ((task->state & __TASK_TRACED) != 0)
 152 #define task_is_stopped(task)   ((task->state & __TASK_STOPPED) != 0)
 153 #define task_is_stopped_or_traced(task) \
 154                         ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
 155 #define task_contributes_to_load(task)  \
 156                                 ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
 157                                  (task->flags & PF_FROZEN) == 0 && \
 158                                  (task->state & TASK_NOLOAD) == 0)
 159
 160 #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
 161
 162 #define __set_current_state(state_value)                        \
 163         do {                                                    \
 164                 current->task_state_change = _THIS_IP_;         \
 165                 current->state = (state_value);                 \
 166         } while (0)
 167 #define set_current_state(state_value)                          \
 168         do {                                                    \
 169                 current->task_state_change = _THIS_IP_;         \
 170                 smp_store_mb(current->state, (state_value));    \
 171         } while (0)
 172
 173 #else
 174 /*
 175  * set_current_state() includes a barrier so that the write of current->state
 176  * is correctly serialised wrt the caller's subsequent test of whether to
 177  * actually sleep:
 178  *
 179  *   for (;;) {
 180  *      set_current_state(TASK_UNINTERRUPTIBLE);
 181  *      if (!need_sleep)
 182  *              break;
 183  *
 184  *      schedule();
 185  *   }
 186  *   __set_current_state(TASK_RUNNING);
 187  *
 188  * If the caller does not need such serialisation (because, for instance, the
 189  * condition test and condition change and wakeup are under the same lock) then
 190  * use __set_current_state().
 191  *
 192  * The above is typically ordered against the wakeup, which does:
 193  *
 194  *      need_sleep = false;
 195  *      wake_up_state(p, TASK_UNINTERRUPTIBLE);
 196  *
 197  * Where wake_up_state() (and all other wakeup primitives) imply enough
 198  * barriers to order the store of the variable against wakeup.
 199  *
 200  * Wakeup will do: if (@state & p->state) p->state = TASK_RUNNING, that is,
 201  * once it observes the TASK_UNINTERRUPTIBLE store the waking CPU can issue a
 202  * TASK_RUNNING store which can collide with __set_current_state(TASK_RUNNING).
 203  *
 204  * This is obviously fine, since they both store the exact same value.
 205  *
 206  * Also see the comments of try_to_wake_up().
 207  */
 208 #define __set_current_state(state_value)                \
 209         do { current->state = (state_value); } while (0)
 210 #define set_current_state(state_value)                  \
 211         smp_store_mb(current->state, (state_value))
 212
 213 #endif
 214
 215 /* Task command name length */
 216 #define TASK_COMM_LEN 16
 217
 218 #include <linux/spinlock.h>
 219
 220 /*
 221  * This serializes "schedule()" and also protects
 222  * the run-queue from deletions/modifications (but
 223  * _adding_ to the beginning of the run-queue has
 224  * a separate lock).
 225  */
 226 extern rwlock_t tasklist_lock;
 227 extern spinlock_t mmlist_lock;
 228
 229 struct task_struct;
 230
 231 #ifdef CONFIG_PROVE_RCU
 232 extern int lockdep_tasklist_lock_is_held(void);
 233 #endif /* #ifdef CONFIG_PROVE_RCU */
 234
 235 extern void sched_init(void);
 236 extern void sched_init_smp(void);
 237 extern asmlinkage void schedule_tail(struct task_struct *prev);
 238 extern void init_idle(struct task_struct *idle, int cpu);
 239 extern void init_idle_bootup_task(struct task_struct *idle);
 240
 241 extern cpumask_var_t cpu_isolated_map;
 242
 243 extern int runqueue_is_locked(int cpu);
 244
 245 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
 246 extern void nohz_balance_enter_idle(int cpu);
 247 extern void set_cpu_sd_state_idle(void);
 248 extern int get_nohz_timer_target(void);
 249 #else
 250 static inline void nohz_balance_enter_idle(int cpu) { }
 251 static inline void set_cpu_sd_state_idle(void) { }
 252 #endif
 253
 254 /*
 255  * Only dump TASK_* tasks. (0 for all tasks)
 256  */
 257 extern void show_state_filter(unsigned long state_filter);
 258
 259 static inline void show_state(void)
 260 {
 261         show_state_filter(0);
 262 }
 263
 264 extern void show_regs(struct pt_regs *);
 265
 266 /*
 267  * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
 268  * task), SP is the stack pointer of the first frame that should be shown in the back
 269  * trace (or NULL if the entire call-chain of the task should be shown).
 270  */
 271 extern void show_stack(struct task_struct *task, unsigned long *sp);
 272
 273 extern void cpu_init (void);
 274 extern void trap_init(void);
 275 extern void update_process_times(int user);
 276 extern void scheduler_tick(void);
 277 extern int sched_cpu_starting(unsigned int cpu);
 278 extern int sched_cpu_activate(unsigned int cpu);
 279 extern int sched_cpu_deactivate(unsigned int cpu);
 280
 281 #ifdef CONFIG_HOTPLUG_CPU
 282 extern int sched_cpu_dying(unsigned int cpu);
 283 #else
 284 # define sched_cpu_dying        NULL
 285 #endif
 286
 287 extern void sched_show_task(struct task_struct *p);
 288
 289 /* Attach to any functions which should be ignored in wchan output. */
 290 #define __sched         __attribute__((__section__(".sched.text")))
 291
 292 /* Linker adds these: start and end of __sched functions */
 293 extern char __sched_text_start[], __sched_text_end[];
 294
 295 /* Is this address in the __sched functions? */
 296 extern int in_sched_functions(unsigned long addr);
 297
 298 #define MAX_SCHEDULE_TIMEOUT    LONG_MAX
 299 extern signed long schedule_timeout(signed long timeout);
 300 extern signed long schedule_timeout_interruptible(signed long timeout);
 301 extern signed long schedule_timeout_killable(signed long timeout);
 302 extern signed long schedule_timeout_uninterruptible(signed long timeout);
 303 extern signed long schedule_timeout_idle(signed long timeout);
 304 asmlinkage void schedule(void);
 305 extern void schedule_preempt_disabled(void);
 306
 307 extern int __must_check io_schedule_prepare(void);
 308 extern void io_schedule_finish(int token);
 309 extern long io_schedule_timeout(long timeout);
 310 extern void io_schedule(void);
 311
 312 void __noreturn do_task_dead(void);
 313
 314 struct nsproxy;
 315
 316 #ifdef CONFIG_MMU
 317 extern void arch_pick_mmap_layout(struct mm_struct *mm);
 318 extern unsigned long
 319 arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
 320                        unsigned long, unsigned long);
 321 extern unsigned long
 322 arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
 323                           unsigned long len, unsigned long pgoff,
 324                           unsigned long flags);
 325 #else
 326 static inline void arch_pick_mmap_layout(struct mm_struct *mm) {}
 327 #endif
 328
 329 /**
 330  * struct prev_cputime - snaphsot of system and user cputime
 331  * @utime: time spent in user mode
 332  * @stime: time spent in system mode
 333  * @lock: protects the above two fields
 334  *
 335  * Stores previous user/system time values such that we can guarantee
 336  * monotonicity.
 337  */
 338 struct prev_cputime {
 339 #ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
 340         u64 utime;
 341         u64 stime;
 342         raw_spinlock_t lock;
 343 #endif
 344 };
 345
 346 static inline void prev_cputime_init(struct prev_cputime *prev)
 347 {
 348 #ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
 349         prev->utime = prev->stime = 0;
 350         raw_spin_lock_init(&prev->lock);
 351 #endif
 352 }
 353
 354 /**
 355  * struct task_cputime - collected CPU time counts
 356  * @utime:              time spent in user mode, in nanoseconds
 357  * @stime:              time spent in kernel mode, in nanoseconds
 358  * @sum_exec_runtime:   total time spent on the CPU, in nanoseconds
 359  *
 360  * This structure groups together three kinds of CPU time that are tracked for
 361  * threads and thread groups.  Most things considering CPU time want to group
 362  * these counts together and treat all three of them in parallel.
 363  */
 364 struct task_cputime {
 365         u64 utime;
 366         u64 stime;
 367         unsigned long long sum_exec_runtime;
 368 };
 369
 370 /* Alternate field names when used to cache expirations. */
 371 #define virt_exp        utime
 372 #define prof_exp        stime
 373 #define sched_exp       sum_exec_runtime
 374
 375 /*
 376  * This is the atomic variant of task_cputime, which can be used for
 377  * storing and updating task_cputime statistics without locking.
 378  */
 379 struct task_cputime_atomic {
 380         atomic64_t utime;
 381         atomic64_t stime;
 382         atomic64_t sum_exec_runtime;
 383 };
 384
 385 #define INIT_CPUTIME_ATOMIC \
 386         (struct task_cputime_atomic) {                          \
 387                 .utime = ATOMIC64_INIT(0),                      \
 388                 .stime = ATOMIC64_INIT(0),                      \
 389                 .sum_exec_runtime = ATOMIC64_INIT(0),           \
 390         }
 391
 392 #define PREEMPT_DISABLED        (PREEMPT_DISABLE_OFFSET + PREEMPT_ENABLED)
 393
 394 /*
 395  * Disable preemption until the scheduler is running -- use an unconditional
 396  * value so that it also works on !PREEMPT_COUNT kernels.
 397  *
 398  * Reset by start_kernel()->sched_init()->init_idle()->init_idle_preempt_count().
 399  */
 400 #define INIT_PREEMPT_COUNT      PREEMPT_OFFSET
 401
 402 /*
 403  * Initial preempt_count value; reflects the preempt_count schedule invariant
 404  * which states that during context switches:
 405  *
 406  *    preempt_count() == 2*PREEMPT_DISABLE_OFFSET
 407  *
 408  * Note: PREEMPT_DISABLE_OFFSET is 0 for !PREEMPT_COUNT kernels.
 409  * Note: See finish_task_switch().
 410  */
 411 #define FORK_PREEMPT_COUNT      (2*PREEMPT_DISABLE_OFFSET + PREEMPT_ENABLED)
 412
 413 /**
 414  * struct thread_group_cputimer - thread group interval timer counts
 415  * @cputime_atomic:     atomic thread group interval timers.
 416  * @running:            true when there are timers running and
 417  *                      @cputime_atomic receives updates.
 418  * @checking_timer:     true when a thread in the group is in the
 419  *                      process of checking for thread group timers.
 420  *
 421  * This structure contains the version of task_cputime, above, that is
 422  * used for thread group CPU timer calculations.
 423  */
 424 struct thread_group_cputimer {
 425         struct task_cputime_atomic cputime_atomic;
 426         bool running;
 427         bool checking_timer;
 428 };
 429
 430 #include <linux/rwsem.h>
 431 struct autogroup;
 432
 433 struct backing_dev_info;
 434 struct reclaim_state;
 435
 436 #ifdef CONFIG_SCHED_INFO
 437 struct sched_info {
 438         /* cumulative counters */
 439         unsigned long pcount;         /* # of times run on this cpu */
 440         unsigned long long run_delay; /* time spent waiting on a runqueue */
 441
 442         /* timestamps */
 443         unsigned long long last_arrival,/* when we last ran on a cpu */
 444                            last_queued; /* when we were last queued to run */
 445 };
 446 #endif /* CONFIG_SCHED_INFO */
 447
 448 struct task_delay_info;
 449
 450 static inline int sched_info_on(void)
 451 {
 452 #ifdef CONFIG_SCHEDSTATS
 453         return 1;
 454 #elif defined(CONFIG_TASK_DELAY_ACCT)
 455         extern int delayacct_on;
 456         return delayacct_on;
 457 #else
 458         return 0;
 459 #endif
 460 }
 461
 462 #ifdef CONFIG_SCHEDSTATS
 463 void force_schedstat_enabled(void);
 464 #endif
 465
 466 /*
 467  * Integer metrics need fixed point arithmetic, e.g., sched/fair
 468  * has a few: load, load_avg, util_avg, freq, and capacity.
 469  *
 470  * We define a basic fixed point arithmetic range, and then formalize
 471  * all these metrics based on that basic range.
 472  */
 473 # define SCHED_FIXEDPOINT_SHIFT 10
 474 # define SCHED_FIXEDPOINT_SCALE (1L << SCHED_FIXEDPOINT_SHIFT)
 475
 476 struct io_context;                      /* See blkdev.h */
 477
 478
 479 #ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
 480 extern void prefetch_stack(struct task_struct *t);
 481 #else
 482 static inline void prefetch_stack(struct task_struct *t) { }
 483 #endif
 484
 485 struct audit_context;           /* See audit.c */
 486 struct mempolicy;
 487 struct pipe_inode_info;
 488 struct uts_namespace;
 489
 490 struct load_weight {
 491         unsigned long weight;
 492         u32 inv_weight;
 493 };
 494
 495 /*
 496  * The load_avg/util_avg accumulates an infinite geometric series
 497  * (see __update_load_avg() in kernel/sched/fair.c).
 498  *
 499  * [load_avg definition]
 500  *
 501  *   load_avg = runnable% * scale_load_down(load)
 502  *
 503  * where runnable% is the time ratio that a sched_entity is runnable.
 504  * For cfs_rq, it is the aggregated load_avg of all runnable and
 505  * blocked sched_entities.
 506  *
 507  * load_avg may also take frequency scaling into account:
 508  *
 509  *   load_avg = runnable% * scale_load_down(load) * freq%
 510  *
 511  * where freq% is the CPU frequency normalized to the highest frequency.
 512  *
 513  * [util_avg definition]
 514  *
 515  *   util_avg = running% * SCHED_CAPACITY_SCALE
 516  *
 517  * where running% is the time ratio that a sched_entity is running on
 518  * a CPU. For cfs_rq, it is the aggregated util_avg of all runnable
 519  * and blocked sched_entities.
 520  *
 521  * util_avg may also factor frequency scaling and CPU capacity scaling:
 522  *
 523  *   util_avg = running% * SCHED_CAPACITY_SCALE * freq% * capacity%
 524  *
 525  * where freq% is the same as above, and capacity% is the CPU capacity
 526  * normalized to the greatest capacity (due to uarch differences, etc).
 527  *
 528  * N.B., the above ratios (runnable%, running%, freq%, and capacity%)
 529  * themselves are in the range of [0, 1]. To do fixed point arithmetics,
 530  * we therefore scale them to as large a range as necessary. This is for
 531  * example reflected by util_avg's SCHED_CAPACITY_SCALE.
 532  *
 533  * [Overflow issue]
 534  *
 535  * The 64-bit load_sum can have 4353082796 (=2^64/47742/88761) entities
 536  * with the highest load (=88761), always runnable on a single cfs_rq,
 537  * and should not overflow as the number already hits PID_MAX_LIMIT.
 538  *
 539  * For all other cases (including 32-bit kernels), struct load_weight's
 540  * weight will overflow first before we do, because:
 541  *
 542  *    Max(load_avg) <= Max(load.weight)
 543  *
 544  * Then it is the load_weight's responsibility to consider overflow
 545  * issues.
 546  */
 547 struct sched_avg {
 548         u64 last_update_time, load_sum;
 549         u32 util_sum, period_contrib;
 550         unsigned long load_avg, util_avg;
 551 };
 552
 553 #ifdef CONFIG_SCHEDSTATS
 554 struct sched_statistics {
 555         u64                     wait_start;
 556         u64                     wait_max;
 557         u64                     wait_count;
 558         u64                     wait_sum;
 559         u64                     iowait_count;
 560         u64                     iowait_sum;
 561
 562         u64                     sleep_start;
 563         u64                     sleep_max;
 564         s64                     sum_sleep_runtime;
 565
 566         u64                     block_start;
 567         u64                     block_max;
 568         u64                     exec_max;
 569         u64                     slice_max;
 570
 571         u64                     nr_migrations_cold;
 572         u64                     nr_failed_migrations_affine;
 573         u64                     nr_failed_migrations_running;
 574         u64                     nr_failed_migrations_hot;
 575         u64                     nr_forced_migrations;
 576
 577         u64                     nr_wakeups;
 578         u64                     nr_wakeups_sync;
 579         u64                     nr_wakeups_migrate;
 580         u64                     nr_wakeups_local;
 581         u64                     nr_wakeups_remote;
 582         u64                     nr_wakeups_affine;
 583         u64                     nr_wakeups_affine_attempts;
 584         u64                     nr_wakeups_passive;
 585         u64                     nr_wakeups_idle;
 586 };
 587 #endif
 588
 589 struct sched_entity {
 590         struct load_weight      load;           /* for load-balancing */
 591         struct rb_node          run_node;
 592         struct list_head        group_node;
 593         unsigned int            on_rq;
 594
 595         u64                     exec_start;
 596         u64                     sum_exec_runtime;
 597         u64                     vruntime;
 598         u64                     prev_sum_exec_runtime;
 599
 600         u64                     nr_migrations;
 601
 602 #ifdef CONFIG_SCHEDSTATS
 603         struct sched_statistics statistics;
 604 #endif
 605
 606 #ifdef CONFIG_FAIR_GROUP_SCHED
 607         int                     depth;
 608         struct sched_entity     *parent;
 609         /* rq on which this entity is (to be) queued: */
 610         struct cfs_rq           *cfs_rq;
 611         /* rq "owned" by this entity/group: */
 612         struct cfs_rq           *my_q;
 613 #endif
 614
 615 #ifdef CONFIG_SMP
 616         /*
 617          * Per entity load average tracking.
 618          *
 619          * Put into separate cache line so it does not
 620          * collide with read-mostly values above.
 621          */
 622         struct sched_avg        avg ____cacheline_aligned_in_smp;
 623 #endif
 624 };
 625
 626 struct sched_rt_entity {
 627         struct list_head run_list;
 628         unsigned long timeout;
 629         unsigned long watchdog_stamp;
 630         unsigned int time_slice;
 631         unsigned short on_rq;
 632         unsigned short on_list;
 633
 634         struct sched_rt_entity *back;
 635 #ifdef CONFIG_RT_GROUP_SCHED
 636         struct sched_rt_entity  *parent;
 637         /* rq on which this entity is (to be) queued: */
 638         struct rt_rq            *rt_rq;
 639         /* rq "owned" by this entity/group: */
 640         struct rt_rq            *my_q;
 641 #endif
 642 };
 643
 644 struct sched_dl_entity {
 645         struct rb_node  rb_node;
 646
 647         /*
 648          * Original scheduling parameters. Copied here from sched_attr
 649          * during sched_setattr(), they will remain the same until
 650          * the next sched_setattr().
 651          */
 652         u64 dl_runtime;         /* maximum runtime for each instance    */
 653         u64 dl_deadline;        /* relative deadline of each instance   */
 654         u64 dl_period;          /* separation of two instances (period) */
 655         u64 dl_bw;              /* dl_runtime / dl_deadline             */
 656
 657         /*
 658          * Actual scheduling parameters. Initialized with the values above,
 659          * they are continously updated during task execution. Note that
 660          * the remaining runtime could be < 0 in case we are in overrun.
 661          */
 662         s64 runtime;            /* remaining runtime for this instance  */
 663         u64 deadline;           /* absolute deadline for this instance  */
 664         unsigned int flags;     /* specifying the scheduler behaviour   */
 665
 666         /*
 667          * Some bool flags:
 668          *
 669          * @dl_throttled tells if we exhausted the runtime. If so, the
 670          * task has to wait for a replenishment to be performed at the
 671          * next firing of dl_timer.
 672          *
 673          * @dl_boosted tells if we are boosted due to DI. If so we are
 674          * outside bandwidth enforcement mechanism (but only until we
 675          * exit the critical section);
 676          *
 677          * @dl_yielded tells if task gave up the cpu before consuming
 678          * all its available runtime during the last job.
 679          */
 680         int dl_throttled, dl_boosted, dl_yielded;
 681
 682         /*
 683          * Bandwidth enforcement timer. Each -deadline task has its
 684          * own bandwidth to be enforced, thus we need one timer per task.
 685          */
 686         struct hrtimer dl_timer;
 687 };
 688
 689 union rcu_special {
 690         struct {
 691                 u8 blocked;
 692                 u8 need_qs;
 693                 u8 exp_need_qs;
 694                 u8 pad; /* Otherwise the compiler can store garbage here. */
 695         } b; /* Bits. */
 696         u32 s; /* Set of bits. */
 697 };
 698 struct rcu_node;
 699
 700 enum perf_event_task_context {
 701         perf_invalid_context = -1,
 702         perf_hw_context = 0,
 703         perf_sw_context,
 704         perf_nr_task_contexts,
 705 };
 706
 707 struct wake_q_node {
 708         struct wake_q_node *next;
 709 };
 710
 711 /* Track pages that require TLB flushes */
 712 struct tlbflush_unmap_batch {
 713         /*
 714          * Each bit set is a CPU that potentially has a TLB entry for one of
 715          * the PFNs being flushed. See set_tlb_ubc_flush_pending().
 716          */
 717         struct cpumask cpumask;
 718
 719         /* True if any bit in cpumask is set */
 720         bool flush_required;
 721
 722         /*
 723          * If true then the PTE was dirty when unmapped. The entry must be
 724          * flushed before IO is initiated or a stale TLB entry potentially
 725          * allows an update without redirtying the page.
 726          */
 727         bool writable;
 728 };
 729
 730 struct task_struct {
 731 #ifdef CONFIG_THREAD_INFO_IN_TASK
 732         /*
 733          * For reasons of header soup (see current_thread_info()), this
 734          * must be the first element of task_struct.
 735          */
 736         struct thread_info thread_info;
 737 #endif
 738         volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
 739         void *stack;
 740         atomic_t usage;
 741         unsigned int flags;     /* per process flags, defined below */
 742         unsigned int ptrace;
 743
 744 #ifdef CONFIG_SMP
 745         struct llist_node wake_entry;
 746         int on_cpu;
 747 #ifdef CONFIG_THREAD_INFO_IN_TASK
 748         unsigned int cpu;       /* current CPU */
 749 #endif
 750         unsigned int wakee_flips;
 751         unsigned long wakee_flip_decay_ts;
 752         struct task_struct *last_wakee;
 753
 754         int wake_cpu;
 755 #endif
 756         int on_rq;
 757
 758         int prio, static_prio, normal_prio;
 759         unsigned int rt_priority;
 760         const struct sched_class *sched_class;
 761         struct sched_entity se;
 762         struct sched_rt_entity rt;
 763 #ifdef CONFIG_CGROUP_SCHED
 764         struct task_group *sched_task_group;
 765 #endif
 766         struct sched_dl_entity dl;
 767
 768 #ifdef CONFIG_PREEMPT_NOTIFIERS
 769         /* list of struct preempt_notifier: */
 770         struct hlist_head preempt_notifiers;
 771 #endif
 772
 773 #ifdef CONFIG_BLK_DEV_IO_TRACE
 774         unsigned int btrace_seq;
 775 #endif
 776
 777         unsigned int policy;
 778         int nr_cpus_allowed;
 779         cpumask_t cpus_allowed;
 780
 781 #ifdef CONFIG_PREEMPT_RCU
 782         int rcu_read_lock_nesting;
 783         union rcu_special rcu_read_unlock_special;
 784         struct list_head rcu_node_entry;
 785         struct rcu_node *rcu_blocked_node;
 786 #endif /* #ifdef CONFIG_PREEMPT_RCU */
 787 #ifdef CONFIG_TASKS_RCU
 788         unsigned long rcu_tasks_nvcsw;
 789         bool rcu_tasks_holdout;
 790         struct list_head rcu_tasks_holdout_list;
 791         int rcu_tasks_idle_cpu;
 792 #endif /* #ifdef CONFIG_TASKS_RCU */
 793
 794 #ifdef CONFIG_SCHED_INFO
 795         struct sched_info sched_info;
 796 #endif
 797
 798         struct list_head tasks;
 799 #ifdef CONFIG_SMP
 800         struct plist_node pushable_tasks;
 801         struct rb_node pushable_dl_tasks;
 802 #endif
 803
 804         struct mm_struct *mm, *active_mm;
 805
 806         /* Per-thread vma caching: */
 807         struct vmacache vmacache;
 808
 809 #if defined(SPLIT_RSS_COUNTING)
 810         struct task_rss_stat    rss_stat;
 811 #endif
 812 /* task state */
 813         int exit_state;
 814         int exit_code, exit_signal;
 815         int pdeath_signal;  /*  The signal sent when the parent dies  */
 816         unsigned long jobctl;   /* JOBCTL_*, siglock protected */
 817
 818         /* Used for emulating ABI behavior of previous Linux versions */
 819         unsigned int personality;
 820
 821         /* scheduler bits, serialized by scheduler locks */
 822         unsigned sched_reset_on_fork:1;
 823         unsigned sched_contributes_to_load:1;
 824         unsigned sched_migrated:1;
 825         unsigned sched_remote_wakeup:1;
 826         unsigned :0; /* force alignment to the next boundary */
 827
 828         /* unserialized, strictly 'current' */
 829         unsigned in_execve:1; /* bit to tell LSMs we're in execve */
 830         unsigned in_iowait:1;
 831 #if !defined(TIF_RESTORE_SIGMASK)
 832         unsigned restore_sigmask:1;
 833 #endif
 834 #ifdef CONFIG_MEMCG
 835         unsigned memcg_may_oom:1;
 836 #ifndef CONFIG_SLOB
 837         unsigned memcg_kmem_skip_account:1;
 838 #endif
 839 #endif
 840 #ifdef CONFIG_COMPAT_BRK
 841         unsigned brk_randomized:1;
 842 #endif
 843
 844         unsigned long atomic_flags; /* Flags needing atomic access. */
 845
 846         struct restart_block restart_block;
 847
 848         pid_t pid;
 849         pid_t tgid;
 850
 851 #ifdef CONFIG_CC_STACKPROTECTOR
 852         /* Canary value for the -fstack-protector gcc feature */
 853         unsigned long stack_canary;
 854 #endif
 855         /*
 856          * pointers to (original) parent process, youngest child, younger sibling,
 857          * older sibling, respectively.  (p->father can be replaced with
 858          * p->real_parent->pid)
 859          */
 860         struct task_struct __rcu *real_parent; /* real parent process */
 861         struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
 862         /*
 863          * children/sibling forms the list of my natural children
 864          */
 865         struct list_head children;      /* list of my children */
 866         struct list_head sibling;       /* linkage in my parent's children list */
 867         struct task_struct *group_leader;       /* threadgroup leader */
 868
 869         /*
 870          * ptraced is the list of tasks this task is using ptrace on.
 871          * This includes both natural children and PTRACE_ATTACH targets.
 872          * p->ptrace_entry is p's link on the p->parent->ptraced list.
 873          */
 874         struct list_head ptraced;
 875         struct list_head ptrace_entry;
 876
 877         /* PID/PID hash table linkage. */
 878         struct pid_link pids[PIDTYPE_MAX];
 879         struct list_head thread_group;
 880         struct list_head thread_node;
 881
 882         struct completion *vfork_done;          /* for vfork() */
 883         int __user *set_child_tid;              /* CLONE_CHILD_SETTID */
 884         int __user *clear_child_tid;            /* CLONE_CHILD_CLEARTID */
 885
 886         u64 utime, stime;
 887 #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
 888         u64 utimescaled, stimescaled;
 889 #endif
 890         u64 gtime;
 891         struct prev_cputime prev_cputime;
 892 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
 893         seqcount_t vtime_seqcount;
 894         unsigned long long vtime_snap;
 895         enum {
 896                 /* Task is sleeping or running in a CPU with VTIME inactive */
 897                 VTIME_INACTIVE = 0,
 898                 /* Task runs in userspace in a CPU with VTIME active */
 899                 VTIME_USER,
 900                 /* Task runs in kernelspace in a CPU with VTIME active */
 901                 VTIME_SYS,
 902         } vtime_snap_whence;
 903 #endif
 904
 905 #ifdef CONFIG_NO_HZ_FULL
 906         atomic_t tick_dep_mask;
 907 #endif
 908         unsigned long nvcsw, nivcsw; /* context switch counts */
 909         u64 start_time;         /* monotonic time in nsec */
 910         u64 real_start_time;    /* boot based time in nsec */
 911 /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
 912         unsigned long min_flt, maj_flt;
 913
 914 #ifdef CONFIG_POSIX_TIMERS
 915         struct task_cputime cputime_expires;
 916         struct list_head cpu_timers[3];
 917 #endif
 918
 919 /* process credentials */
 920         const struct cred __rcu *ptracer_cred; /* Tracer's credentials at attach */
 921         const struct cred __rcu *real_cred; /* objective and real subjective task
 922                                          * credentials (COW) */
 923         const struct cred __rcu *cred;  /* effective (overridable) subjective task
 924                                          * credentials (COW) */
 925         char comm[TASK_COMM_LEN]; /* executable name excluding path
 926                                      - access with [gs]et_task_comm (which lock
 927                                        it with task_lock())
 928                                      - initialized normally by setup_new_exec */
 929 /* file system info */
 930         struct nameidata *nameidata;
 931 #ifdef CONFIG_SYSVIPC
 932 /* ipc stuff */
 933         struct sysv_sem sysvsem;
 934         struct sysv_shm sysvshm;
 935 #endif
 936 #ifdef CONFIG_DETECT_HUNG_TASK
 937 /* hung task detection */
 938         unsigned long last_switch_count;
 939 #endif
 940 /* filesystem information */
 941         struct fs_struct *fs;
 942 /* open file information */
 943         struct files_struct *files;
 944 /* namespaces */
 945         struct nsproxy *nsproxy;
 946 /* signal handlers */
 947         struct signal_struct *signal;
 948         struct sighand_struct *sighand;
 949
 950         sigset_t blocked, real_blocked;
 951         sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
 952         struct sigpending pending;
 953
 954         unsigned long sas_ss_sp;
 955         size_t sas_ss_size;
 956         unsigned sas_ss_flags;
 957
 958         struct callback_head *task_works;
 959
 960         struct audit_context *audit_context;
 961 #ifdef CONFIG_AUDITSYSCALL
 962         kuid_t loginuid;
 963         unsigned int sessionid;
 964 #endif
 965         struct seccomp seccomp;
 966
 967 /* Thread group tracking */
 968         u32 parent_exec_id;
 969         u32 self_exec_id;
 970 /* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,
 971  * mempolicy */
 972         spinlock_t alloc_lock;
 973
 974         /* Protection of the PI data structures: */
 975         raw_spinlock_t pi_lock;
 976
 977         struct wake_q_node wake_q;
 978
 979 #ifdef CONFIG_RT_MUTEXES
 980         /* PI waiters blocked on a rt_mutex held by this task */
 981         struct rb_root pi_waiters;
 982         struct rb_node *pi_waiters_leftmost;
 983         /* Deadlock detection and priority inheritance handling */
 984         struct rt_mutex_waiter *pi_blocked_on;
 985 #endif
 986
 987 #ifdef CONFIG_DEBUG_MUTEXES
 988         /* mutex deadlock detection */
 989         struct mutex_waiter *blocked_on;
 990 #endif
 991 #ifdef CONFIG_TRACE_IRQFLAGS
 992         unsigned int irq_events;
 993         unsigned long hardirq_enable_ip;
 994         unsigned long hardirq_disable_ip;
 995         unsigned int hardirq_enable_event;
 996         unsigned int hardirq_disable_event;
 997         int hardirqs_enabled;
 998         int hardirq_context;
 999         unsigned long softirq_disable_ip;
1000         unsigned long softirq_enable_ip;
1001         unsigned int softirq_disable_event;
1002         unsigned int softirq_enable_event;
1003         int softirqs_enabled;
1004         int softirq_context;
1005 #endif
1006 #ifdef CONFIG_LOCKDEP
1007 # define MAX_LOCK_DEPTH 48UL
1008         u64 curr_chain_key;
1009         int lockdep_depth;
1010         unsigned int lockdep_recursion;
1011         struct held_lock held_locks[MAX_LOCK_DEPTH];
1012         gfp_t lockdep_reclaim_gfp;
1013 #endif
1014 #ifdef CONFIG_UBSAN
1015         unsigned int in_ubsan;
1016 #endif
1017
1018 /* journalling filesystem info */
1019         void *journal_info;
1020
1021 /* stacked block device info */
1022         struct bio_list *bio_list;
1023
1024 #ifdef CONFIG_BLOCK
1025 /* stack plugging */
1026         struct blk_plug *plug;
1027 #endif
1028
1029 /* VM state */
1030         struct reclaim_state *reclaim_state;
1031
1032         struct backing_dev_info *backing_dev_info;
1033
1034         struct io_context *io_context;
1035
1036         unsigned long ptrace_message;
1037         siginfo_t *last_siginfo; /* For ptrace use.  */
1038         struct task_io_accounting ioac;
1039 #if defined(CONFIG_TASK_XACCT)
1040         u64 acct_rss_mem1;      /* accumulated rss usage */
1041         u64 acct_vm_mem1;       /* accumulated virtual memory usage */
1042         u64 acct_timexpd;       /* stime + utime since last update */
1043 #endif
1044 #ifdef CONFIG_CPUSETS
1045         nodemask_t mems_allowed;        /* Protected by alloc_lock */
1046         seqcount_t mems_allowed_seq;    /* Seqence no to catch updates */
1047         int cpuset_mem_spread_rotor;
1048         int cpuset_slab_spread_rotor;
1049 #endif
1050 #ifdef CONFIG_CGROUPS
1051         /* Control Group info protected by css_set_lock */
1052         struct css_set __rcu *cgroups;
1053         /* cg_list protected by css_set_lock and tsk->alloc_lock */
1054         struct list_head cg_list;
1055 #endif
1056 #ifdef CONFIG_INTEL_RDT_A
1057         int closid;
1058 #endif
1059 #ifdef CONFIG_FUTEX
1060         struct robust_list_head __user *robust_list;
1061 #ifdef CONFIG_COMPAT
1062         struct compat_robust_list_head __user *compat_robust_list;
1063 #endif
1064         struct list_head pi_state_list;
1065         struct futex_pi_state *pi_state_cache;
1066 #endif
1067 #ifdef CONFIG_PERF_EVENTS
1068         struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
1069         struct mutex perf_event_mutex;
1070         struct list_head perf_event_list;
1071 #endif
1072 #ifdef CONFIG_DEBUG_PREEMPT
1073         unsigned long preempt_disable_ip;
1074 #endif
1075 #ifdef CONFIG_NUMA
1076         struct mempolicy *mempolicy;    /* Protected by alloc_lock */
1077         short il_next;
1078         short pref_node_fork;
1079 #endif
1080 #ifdef CONFIG_NUMA_BALANCING
1081         int numa_scan_seq;
1082         unsigned int numa_scan_period;
1083         unsigned int numa_scan_period_max;
1084         int numa_preferred_nid;
1085         unsigned long numa_migrate_retry;
1086         u64 node_stamp;                 /* migration stamp  */
1087         u64 last_task_numa_placement;
1088         u64 last_sum_exec_runtime;
1089         struct callback_head numa_work;
1090
1091         struct list_head numa_entry;
1092         struct numa_group *numa_group;
1093
1094         /*
1095          * numa_faults is an array split into four regions:
1096          * faults_memory, faults_cpu, faults_memory_buffer, faults_cpu_buffer
1097          * in this precise order.
1098          *
1099          * faults_memory: Exponential decaying average of faults on a per-node
1100          * basis. Scheduling placement decisions are made based on these
1101          * counts. The values remain static for the duration of a PTE scan.
1102          * faults_cpu: Track the nodes the process was running on when a NUMA
1103          * hinting fault was incurred.
1104          * faults_memory_buffer and faults_cpu_buffer: Record faults per node
1105          * during the current scan window. When the scan completes, the counts
1106          * in faults_memory and faults_cpu decay and these values are copied.
1107          */
1108         unsigned long *numa_faults;
1109         unsigned long total_numa_faults;
1110
1111         /*
1112          * numa_faults_locality tracks if faults recorded during the last
1113          * scan window were remote/local or failed to migrate. The task scan
1114          * period is adapted based on the locality of the faults with different
1115          * weights depending on whether they were shared or private faults
1116          */
1117         unsigned long numa_faults_locality[3];
1118
1119         unsigned long numa_pages_migrated;
1120 #endif /* CONFIG_NUMA_BALANCING */
1121
1122 #ifdef CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH
1123         struct tlbflush_unmap_batch tlb_ubc;
1124 #endif
1125
1126         struct rcu_head rcu;
1127
1128         /*
1129          * cache last used pipe for splice
1130          */
1131         struct pipe_inode_info *splice_pipe;
1132
1133         struct page_frag task_frag;
1134
1135 #ifdef CONFIG_TASK_DELAY_ACCT
1136         struct task_delay_info          *delays;
1137 #endif
1138
1139 #ifdef CONFIG_FAULT_INJECTION
1140         int make_it_fail;
1141 #endif
1142         /*
1143          * when (nr_dirtied >= nr_dirtied_pause), it's time to call
1144          * balance_dirty_pages() for some dirty throttling pause
1145          */
1146         int nr_dirtied;
1147         int nr_dirtied_pause;
1148         unsigned long dirty_paused_when; /* start of a write-and-pause period */
1149
1150 #ifdef CONFIG_LATENCYTOP
1151         int latency_record_count;
1152         struct latency_record latency_record[LT_SAVECOUNT];
1153 #endif
1154         /*
1155          * time slack values; these are used to round up poll() and
1156          * select() etc timeout values. These are in nanoseconds.
1157          */
1158         u64 timer_slack_ns;
1159         u64 default_timer_slack_ns;
1160
1161 #ifdef CONFIG_KASAN
1162         unsigned int kasan_depth;
1163 #endif
1164 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
1165         /* Index of current stored address in ret_stack */
1166         int curr_ret_stack;
1167         /* Stack of return addresses for return function tracing */
1168         struct ftrace_ret_stack *ret_stack;
1169         /* time stamp for last schedule */
1170         unsigned long long ftrace_timestamp;
1171         /*
1172          * Number of functions that haven't been traced
1173          * because of depth overrun.
1174          */
1175         atomic_t trace_overrun;
1176         /* Pause for the tracing */
1177         atomic_t tracing_graph_pause;
1178 #endif
1179 #ifdef CONFIG_TRACING
1180         /* state flags for use by tracers */
1181         unsigned long trace;
1182         /* bitmask and counter of trace recursion */
1183         unsigned long trace_recursion;
1184 #endif /* CONFIG_TRACING */
1185 #ifdef CONFIG_KCOV
1186         /* Coverage collection mode enabled for this task (0 if disabled). */
1187         enum kcov_mode kcov_mode;
1188         /* Size of the kcov_area. */
1189         unsigned        kcov_size;
1190         /* Buffer for coverage collection. */
1191         void            *kcov_area;
1192         /* kcov desciptor wired with this task or NULL. */
1193         struct kcov     *kcov;
1194 #endif
1195 #ifdef CONFIG_MEMCG
1196         struct mem_cgroup *memcg_in_oom;
1197         gfp_t memcg_oom_gfp_mask;
1198         int memcg_oom_order;
1199
1200         /* number of pages to reclaim on returning to userland */
1201         unsigned int memcg_nr_pages_over_high;
1202 #endif
1203 #ifdef CONFIG_UPROBES
1204         struct uprobe_task *utask;
1205 #endif
1206 #if defined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)
1207         unsigned int    sequential_io;
1208         unsigned int    sequential_io_avg;
1209 #endif
1210 #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
1211         unsigned long   task_state_change;
1212 #endif
1213         int pagefault_disabled;
1214 #ifdef CONFIG_MMU
1215         struct task_struct *oom_reaper_list;
1216 #endif
1217 #ifdef CONFIG_VMAP_STACK
1218         struct vm_struct *stack_vm_area;
1219 #endif
1220 #ifdef CONFIG_THREAD_INFO_IN_TASK
1221         /* A live task holds one reference. */
1222         atomic_t stack_refcount;
1223 #endif
1224 /* CPU-specific state of this task */
1225         struct thread_struct thread;
1226 /*
1227  * WARNING: on x86, 'thread_struct' contains a variable-sized
1228  * structure.  It *MUST* be at the end of 'task_struct'.
1229  *
1230  * Do not put anything below here!
1231  */
1232 };
1233
1234 #ifdef CONFIG_ARCH_WANTS_DYNAMIC_TASK_STRUCT
1235 extern int arch_task_struct_size __read_mostly;
1236 #else
1237 # define arch_task_struct_size (sizeof(struct task_struct))
1238 #endif
1239
1240 #ifdef CONFIG_VMAP_STACK
1241 static inline struct vm_struct *task_stack_vm_area(const struct task_struct *t)
1242 {
1243         return t->stack_vm_area;
1244 }
1245 #else
1246 static inline struct vm_struct *task_stack_vm_area(const struct task_struct *t)
1247 {
1248         return NULL;
1249 }
1250 #endif
1251
1252 #define TNF_MIGRATED    0x01
1253 #define TNF_NO_GROUP    0x02
1254 #define TNF_SHARED      0x04
1255 #define TNF_FAULT_LOCAL 0x08
1256 #define TNF_MIGRATE_FAIL 0x10
1257
1258 static inline bool in_vfork(struct task_struct *tsk)
1259 {
1260         bool ret;
1261
1262         /*
1263          * need RCU to access ->real_parent if CLONE_VM was used along with
1264          * CLONE_PARENT.
1265          *
1266          * We check real_parent->mm == tsk->mm because CLONE_VFORK does not
1267          * imply CLONE_VM
1268          *
1269          * CLONE_VFORK can be used with CLONE_PARENT/CLONE_THREAD and thus
1270          * ->real_parent is not necessarily the task doing vfork(), so in
1271          * theory we can't rely on task_lock() if we want to dereference it.
1272          *
1273          * And in this case we can't trust the real_parent->mm == tsk->mm
1274          * check, it can be false negative. But we do not care, if init or
1275          * another oom-unkillable task does this it should blame itself.
1276          */
1277         rcu_read_lock();
1278         ret = tsk->vfork_done && tsk->real_parent->mm == tsk->mm;
1279         rcu_read_unlock();
1280
1281         return ret;
1282 }
1283
1284 #ifdef CONFIG_NUMA_BALANCING
1285 extern void task_numa_fault(int last_node, int node, int pages, int flags);
1286 extern pid_t task_numa_group_id(struct task_struct *p);
1287 extern void set_numabalancing_state(bool enabled);
1288 extern void task_numa_free(struct task_struct *p);
1289 extern bool should_numa_migrate_memory(struct task_struct *p, struct page *page,
1290                                         int src_nid, int dst_cpu);
1291 #else
1292 static inline void task_numa_fault(int last_node, int node, int pages,
1293                                    int flags)
1294 {
1295 }
1296 static inline pid_t task_numa_group_id(struct task_struct *p)
1297 {
1298         return 0;
1299 }
1300 static inline void set_numabalancing_state(bool enabled)
1301 {
1302 }
1303 static inline void task_numa_free(struct task_struct *p)
1304 {
1305 }
1306 static inline bool should_numa_migrate_memory(struct task_struct *p,
1307                                 struct page *page, int src_nid, int dst_cpu)
1308 {
1309         return true;
1310 }
1311 #endif
1312
1313 static inline struct pid *task_pid(struct task_struct *task)
1314 {
1315         return task->pids[PIDTYPE_PID].pid;
1316 }
1317
1318 static inline struct pid *task_tgid(struct task_struct *task)
1319 {
1320         return task->group_leader->pids[PIDTYPE_PID].pid;
1321 }
1322
1323 /*
1324  * Without tasklist or rcu lock it is not safe to dereference
1325  * the result of task_pgrp/task_session even if task == current,
1326  * we can race with another thread doing sys_setsid/sys_setpgid.
1327  */
1328 static inline struct pid *task_pgrp(struct task_struct *task)
1329 {
1330         return task->group_leader->pids[PIDTYPE_PGID].pid;
1331 }
1332
1333 static inline struct pid *task_session(struct task_struct *task)
1334 {
1335         return task->group_leader->pids[PIDTYPE_SID].pid;
1336 }
1337
1338 struct pid_namespace;
1339
1340 /*
1341  * the helpers to get the task's different pids as they are seen
1342  * from various namespaces
1343  *
1344  * task_xid_nr()     : global id, i.e. the id seen from the init namespace;
1345  * task_xid_vnr()    : virtual id, i.e. the id seen from the pid namespace of
1346  *                     current.
1347  * task_xid_nr_ns()  : id seen from the ns specified;
1348  *
1349  * set_task_vxid()   : assigns a virtual id to a task;
1350  *
1351  * see also pid_nr() etc in include/linux/pid.h
1352  */
1353 pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
1354                         struct pid_namespace *ns);
1355
1356 static inline pid_t task_pid_nr(struct task_struct *tsk)
1357 {
1358         return tsk->pid;
1359 }
1360
1361 static inline pid_t task_pid_nr_ns(struct task_struct *tsk,
1362                                         struct pid_namespace *ns)
1363 {
1364         return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
1365 }
1366
1367 static inline pid_t task_pid_vnr(struct task_struct *tsk)
1368 {
1369         return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
1370 }
1371
1372
1373 static inline pid_t task_tgid_nr(struct task_struct *tsk)
1374 {
1375         return tsk->tgid;
1376 }
1377
1378 pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
1379
1380 static inline pid_t task_tgid_vnr(struct task_struct *tsk)
1381 {
1382         return pid_vnr(task_tgid(tsk));
1383 }
1384
1385
1386 static inline int pid_alive(const struct task_struct *p);
1387 static inline pid_t task_ppid_nr_ns(const struct task_struct *tsk, struct pid_namespace *ns)
1388 {
1389         pid_t pid = 0;
1390
1391         rcu_read_lock();
1392         if (pid_alive(tsk))
1393                 pid = task_tgid_nr_ns(rcu_dereference(tsk->real_parent), ns);
1394         rcu_read_unlock();
1395
1396         return pid;
1397 }
1398
1399 static inline pid_t task_ppid_nr(const struct task_struct *tsk)
1400 {
1401         return task_ppid_nr_ns(tsk, &init_pid_ns);
1402 }
1403
1404 static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,
1405                                         struct pid_namespace *ns)
1406 {
1407         return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
1408 }
1409
1410 static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
1411 {
1412         return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);
1413 }
1414
1415
1416 static inline pid_t task_session_nr_ns(struct task_struct *tsk,
1417                                         struct pid_namespace *ns)
1418 {
1419         return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
1420 }
1421
1422 static inline pid_t task_session_vnr(struct task_struct *tsk)
1423 {
1424         return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
1425 }
1426
1427 /* obsolete, do not use */
1428 static inline pid_t task_pgrp_nr(struct task_struct *tsk)
1429 {
1430         return task_pgrp_nr_ns(tsk, &init_pid_ns);
1431 }
1432
1433 /**
1434  * pid_alive - check that a task structure is not stale
1435  * @p: Task structure to be checked.
1436  *
1437  * Test if a process is not yet dead (at most zombie state)
1438  * If pid_alive fails, then pointers within the task structure
1439  * can be stale and must not be dereferenced.
1440  *
1441  * Return: 1 if the process is alive. 0 otherwise.
1442  */
1443 static inline int pid_alive(const struct task_struct *p)
1444 {
1445         return p->pids[PIDTYPE_PID].pid != NULL;
1446 }
1447
1448 /**
1449  * is_global_init - check if a task structure is init. Since init
1450  * is free to have sub-threads we need to check tgid.
1451  * @tsk: Task structure to be checked.
1452  *
1453  * Check if a task structure is the first user space task the kernel created.
1454  *
1455  * Return: 1 if the task structure is init. 0 otherwise.
1456  */
1457 static inline int is_global_init(struct task_struct *tsk)
1458 {
1459         return task_tgid_nr(tsk) == 1;
1460 }
1461
1462 extern struct pid *cad_pid;
1463
1464 extern void free_task(struct task_struct *tsk);
1465 #define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
1466
1467 extern void __put_task_struct(struct task_struct *t);
1468
1469 static inline void put_task_struct(struct task_struct *t)
1470 {
1471         if (atomic_dec_and_test(&t->usage))
1472                 __put_task_struct(t);
1473 }
1474
1475 struct task_struct *task_rcu_dereference(struct task_struct **ptask);
1476 struct task_struct *try_get_task_struct(struct task_struct **ptask);
1477
1478 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
1479 extern void task_cputime(struct task_struct *t,
1480                          u64 *utime, u64 *stime);
1481 extern u64 task_gtime(struct task_struct *t);
1482 #else
1483 static inline void task_cputime(struct task_struct *t,
1484                                 u64 *utime, u64 *stime)
1485 {
1486         *utime = t->utime;
1487         *stime = t->stime;
1488 }
1489
1490 static inline u64 task_gtime(struct task_struct *t)
1491 {
1492         return t->gtime;
1493 }
1494 #endif
1495
1496 #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
1497 static inline void task_cputime_scaled(struct task_struct *t,
1498                                        u64 *utimescaled,
1499                                        u64 *stimescaled)
1500 {
1501         *utimescaled = t->utimescaled;
1502         *stimescaled = t->stimescaled;
1503 }
1504 #else
1505 static inline void task_cputime_scaled(struct task_struct *t,
1506                                        u64 *utimescaled,
1507                                        u64 *stimescaled)
1508 {
1509         task_cputime(t, utimescaled, stimescaled);
1510 }
1511 #endif
1512
1513 extern void task_cputime_adjusted(struct task_struct *p, u64 *ut, u64 *st);
1514 extern void thread_group_cputime_adjusted(struct task_struct *p, u64 *ut, u64 *st);
1515
1516 /*
1517  * Per process flags
1518  */
1519 #define PF_IDLE         0x00000002      /* I am an IDLE thread */
1520 #define PF_EXITING      0x00000004      /* getting shut down */
1521 #define PF_EXITPIDONE   0x00000008      /* pi exit done on shut down */
1522 #define PF_VCPU         0x00000010      /* I'm a virtual CPU */
1523 #define PF_WQ_WORKER    0x00000020      /* I'm a workqueue worker */
1524 #define PF_FORKNOEXEC   0x00000040      /* forked but didn't exec */
1525 #define PF_MCE_PROCESS  0x00000080      /* process policy on mce errors */
1526 #define PF_SUPERPRIV    0x00000100      /* used super-user privileges */
1527 #define PF_DUMPCORE     0x00000200      /* dumped core */
1528 #define PF_SIGNALED     0x00000400      /* killed by a signal */
1529 #define PF_MEMALLOC     0x00000800      /* Allocating memory */
1530 #define PF_NPROC_EXCEEDED 0x00001000    /* set_user noticed that RLIMIT_NPROC was exceeded */
1531 #define PF_USED_MATH    0x00002000      /* if unset the fpu must be initialized before use */
1532 #define PF_USED_ASYNC   0x00004000      /* used async_schedule*(), used by module init */
1533 #define PF_NOFREEZE     0x00008000      /* this thread should not be frozen */
1534 #define PF_FROZEN       0x00010000      /* frozen for system suspend */
1535 #define PF_FSTRANS      0x00020000      /* inside a filesystem transaction */
1536 #define PF_KSWAPD       0x00040000      /* I am kswapd */
1537 #define PF_MEMALLOC_NOIO 0x00080000     /* Allocating memory without IO involved */
1538 #define PF_LESS_THROTTLE 0x00100000     /* Throttle me less: I clean memory */
1539 #define PF_KTHREAD      0x00200000      /* I am a kernel thread */
1540 #define PF_RANDOMIZE    0x00400000      /* randomize virtual address space */
1541 #define PF_SWAPWRITE    0x00800000      /* Allowed to write to swap */
1542 #define PF_NO_SETAFFINITY 0x04000000    /* Userland is not allowed to meddle with cpus_allowed */
1543 #define PF_MCE_EARLY    0x08000000      /* Early kill for mce process policy */
1544 #define PF_MUTEX_TESTER 0x20000000      /* Thread belongs to the rt mutex tester */
1545 #define PF_FREEZER_SKIP 0x40000000      /* Freezer should not count it as freezable */
1546 #define PF_SUSPEND_TASK 0x80000000      /* this thread called freeze_processes and should not be frozen */
1547
1548 /*
1549  * Only the _current_ task can read/write to tsk->flags, but other
1550  * tasks can access tsk->flags in readonly mode for example
1551  * with tsk_used_math (like during threaded core dumping).
1552  * There is however an exception to this rule during ptrace
1553  * or during fork: the ptracer task is allowed to write to the
1554  * child->flags of its traced child (same goes for fork, the parent
1555  * can write to the child->flags), because we're guaranteed the
1556  * child is not running and in turn not changing child->flags
1557  * at the same time the parent does it.
1558  */
1559 #define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
1560 #define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
1561 #define clear_used_math() clear_stopped_child_used_math(current)
1562 #define set_used_math() set_stopped_child_used_math(current)
1563 #define conditional_stopped_child_used_math(condition, child) \
1564         do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
1565 #define conditional_used_math(condition) \
1566         conditional_stopped_child_used_math(condition, current)
1567 #define copy_to_stopped_child_used_math(child) \
1568         do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
1569 /* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
1570 #define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
1571 #define used_math() tsk_used_math(current)
1572
1573 /* __GFP_IO isn't allowed if PF_MEMALLOC_NOIO is set in current->flags
1574  * __GFP_FS is also cleared as it implies __GFP_IO.
1575  */
1576 static inline gfp_t memalloc_noio_flags(gfp_t flags)
1577 {
1578         if (unlikely(current->flags & PF_MEMALLOC_NOIO))
1579                 flags &= ~(__GFP_IO | __GFP_FS);
1580         return flags;
1581 }
1582
1583 static inline unsigned int memalloc_noio_save(void)
1584 {
1585         unsigned int flags = current->flags & PF_MEMALLOC_NOIO;
1586         current->flags |= PF_MEMALLOC_NOIO;
1587         return flags;
1588 }
1589
1590 static inline void memalloc_noio_restore(unsigned int flags)
1591 {
1592         current->flags = (current->flags & ~PF_MEMALLOC_NOIO) | flags;
1593 }
1594
1595 /* Per-process atomic flags. */
1596 #define PFA_NO_NEW_PRIVS 0      /* May not gain new privileges. */
1597 #define PFA_SPREAD_PAGE  1      /* Spread page cache over cpuset */
1598 #define PFA_SPREAD_SLAB  2      /* Spread some slab caches over cpuset */
1599 #define PFA_LMK_WAITING  3      /* Lowmemorykiller is waiting */
1600
1601
1602 #define TASK_PFA_TEST(name, func)                                       \
1603         static inline bool task_##func(struct task_struct *p)           \
1604         { return test_bit(PFA_##name, &p->atomic_flags); }
1605 #define TASK_PFA_SET(name, func)                                        \
1606         static inline void task_set_##func(struct task_struct *p)       \
1607         { set_bit(PFA_##name, &p->atomic_flags); }
1608 #define TASK_PFA_CLEAR(name, func)                                      \
1609         static inline void task_clear_##func(struct task_struct *p)     \
1610         { clear_bit(PFA_##name, &p->atomic_flags); }
1611
1612 TASK_PFA_TEST(NO_NEW_PRIVS, no_new_privs)
1613 TASK_PFA_SET(NO_NEW_PRIVS, no_new_privs)
1614
1615 TASK_PFA_TEST(SPREAD_PAGE, spread_page)
1616 TASK_PFA_SET(SPREAD_PAGE, spread_page)
1617 TASK_PFA_CLEAR(SPREAD_PAGE, spread_page)
1618
1619 TASK_PFA_TEST(SPREAD_SLAB, spread_slab)
1620 TASK_PFA_SET(SPREAD_SLAB, spread_slab)
1621 TASK_PFA_CLEAR(SPREAD_SLAB, spread_slab)
1622
1623 TASK_PFA_TEST(LMK_WAITING, lmk_waiting)
1624 TASK_PFA_SET(LMK_WAITING, lmk_waiting)
1625
1626 /*
1627  * task->jobctl flags
1628  */
1629 #define JOBCTL_STOP_SIGMASK     0xffff  /* signr of the last group stop */
1630
1631 #define JOBCTL_STOP_DEQUEUED_BIT 16     /* stop signal dequeued */
1632 #define JOBCTL_STOP_PENDING_BIT 17      /* task should stop for group stop */
1633 #define JOBCTL_STOP_CONSUME_BIT 18      /* consume group stop count */
1634 #define JOBCTL_TRAP_STOP_BIT    19      /* trap for STOP */
1635 #define JOBCTL_TRAP_NOTIFY_BIT  20      /* trap for NOTIFY */
1636 #define JOBCTL_TRAPPING_BIT     21      /* switching to TRACED */
1637 #define JOBCTL_LISTENING_BIT    22      /* ptracer is listening for events */
1638
1639 #define JOBCTL_STOP_DEQUEUED    (1UL << JOBCTL_STOP_DEQUEUED_BIT)
1640 #define JOBCTL_STOP_PENDING     (1UL << JOBCTL_STOP_PENDING_BIT)
1641 #define JOBCTL_STOP_CONSUME     (1UL << JOBCTL_STOP_CONSUME_BIT)
1642 #define JOBCTL_TRAP_STOP        (1UL << JOBCTL_TRAP_STOP_BIT)
1643 #define JOBCTL_TRAP_NOTIFY      (1UL << JOBCTL_TRAP_NOTIFY_BIT)
1644 #define JOBCTL_TRAPPING         (1UL << JOBCTL_TRAPPING_BIT)
1645 #define JOBCTL_LISTENING        (1UL << JOBCTL_LISTENING_BIT)
1646
1647 #define JOBCTL_TRAP_MASK        (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)
1648 #define JOBCTL_PENDING_MASK     (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)
1649
1650 extern bool task_set_jobctl_pending(struct task_struct *task,
1651                                     unsigned long mask);
1652 extern void task_clear_jobctl_trapping(struct task_struct *task);
1653 extern void task_clear_jobctl_pending(struct task_struct *task,
1654                                       unsigned long mask);
1655
1656 static inline void rcu_copy_process(struct task_struct *p)
1657 {
1658 #ifdef CONFIG_PREEMPT_RCU
1659         p->rcu_read_lock_nesting = 0;
1660         p->rcu_read_unlock_special.s = 0;
1661         p->rcu_blocked_node = NULL;
1662         INIT_LIST_HEAD(&p->rcu_node_entry);
1663 #endif /* #ifdef CONFIG_PREEMPT_RCU */
1664 #ifdef CONFIG_TASKS_RCU
1665         p->rcu_tasks_holdout = false;
1666         INIT_LIST_HEAD(&p->rcu_tasks_holdout_list);
1667         p->rcu_tasks_idle_cpu = -1;
1668 #endif /* #ifdef CONFIG_TASKS_RCU */
1669 }
1670
1671 static inline void tsk_restore_flags(struct task_struct *task,
1672                                 unsigned long orig_flags, unsigned long flags)
1673 {
1674         task->flags &= ~flags;
1675         task->flags |= orig_flags & flags;
1676 }
1677
1678 extern int cpuset_cpumask_can_shrink(const struct cpumask *cur,
1679                                      const struct cpumask *trial);
1680 extern int task_can_attach(struct task_struct *p,
1681                            const struct cpumask *cs_cpus_allowed);
1682 #ifdef CONFIG_SMP
1683 extern void do_set_cpus_allowed(struct task_struct *p,
1684                                const struct cpumask *new_mask);
1685
1686 extern int set_cpus_allowed_ptr(struct task_struct *p,
1687                                 const struct cpumask *new_mask);
1688 #else
1689 static inline void do_set_cpus_allowed(struct task_struct *p,
1690                                       const struct cpumask *new_mask)
1691 {
1692 }
1693 static inline int set_cpus_allowed_ptr(struct task_struct *p,
1694                                        const struct cpumask *new_mask)
1695 {
1696         if (!cpumask_test_cpu(0, new_mask))
1697                 return -EINVAL;
1698         return 0;
1699 }
1700 #endif
1701
1702 #ifdef CONFIG_NO_HZ_COMMON
1703 void calc_load_enter_idle(void);
1704 void calc_load_exit_idle(void);
1705 #else
1706 static inline void calc_load_enter_idle(void) { }
1707 static inline void calc_load_exit_idle(void) { }
1708 #endif /* CONFIG_NO_HZ_COMMON */
1709
1710 #ifndef cpu_relax_yield
1711 #define cpu_relax_yield() cpu_relax()
1712 #endif
1713
1714 extern unsigned long long
1715 task_sched_runtime(struct task_struct *task);
1716
1717 /* sched_exec is called by processes performing an exec */
1718 #ifdef CONFIG_SMP
1719 extern void sched_exec(void);
1720 #else
1721 #define sched_exec()   {}
1722 #endif
1723
1724 #ifdef CONFIG_HOTPLUG_CPU
1725 extern void idle_task_exit(void);
1726 #else
1727 static inline void idle_task_exit(void) {}
1728 #endif
1729
1730 #if defined(CONFIG_NO_HZ_COMMON) && defined(CONFIG_SMP)
1731 extern void wake_up_nohz_cpu(int cpu);
1732 #else
1733 static inline void wake_up_nohz_cpu(int cpu) { }
1734 #endif
1735
1736 #ifdef CONFIG_NO_HZ_FULL
1737 extern u64 scheduler_tick_max_deferment(void);
1738 #endif
1739
1740 extern int yield_to(struct task_struct *p, bool preempt);
1741 extern void set_user_nice(struct task_struct *p, long nice);
1742 extern int task_prio(const struct task_struct *p);
1743 /**
1744  * task_nice - return the nice value of a given task.
1745  * @p: the task in question.
1746  *
1747  * Return: The nice value [ -20 ... 0 ... 19 ].
1748  */
1749 static inline int task_nice(const struct task_struct *p)
1750 {
1751         return PRIO_TO_NICE((p)->static_prio);
1752 }
1753 extern int can_nice(const struct task_struct *p, const int nice);
1754 extern int task_curr(const struct task_struct *p);
1755 extern int idle_cpu(int cpu);
1756 extern int sched_setscheduler(struct task_struct *, int,
1757                               const struct sched_param *);
1758 extern int sched_setscheduler_nocheck(struct task_struct *, int,
1759                                       const struct sched_param *);
1760 extern int sched_setattr(struct task_struct *,
1761                          const struct sched_attr *);
1762 extern struct task_struct *idle_task(int cpu);
1763 /**
1764  * is_idle_task - is the specified task an idle task?
1765  * @p: the task in question.
1766  *
1767  * Return: 1 if @p is an idle task. 0 otherwise.
1768  */
1769 static inline bool is_idle_task(const struct task_struct *p)
1770 {
1771         return !!(p->flags & PF_IDLE);
1772 }
1773 extern struct task_struct *curr_task(int cpu);
1774 extern void ia64_set_curr_task(int cpu, struct task_struct *p);
1775
1776 void yield(void);
1777
1778 union thread_union {
1779 #ifndef CONFIG_THREAD_INFO_IN_TASK
1780         struct thread_info thread_info;
1781 #endif
1782         unsigned long stack[THREAD_SIZE/sizeof(long)];
1783 };
1784
1785 #ifndef __HAVE_ARCH_KSTACK_END
1786 static inline int kstack_end(void *addr)
1787 {
1788         /* Reliable end of stack detection:
1789          * Some APM bios versions misalign the stack
1790          */
1791         return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
1792 }
1793 #endif
1794
1795 extern union thread_union init_thread_union;
1796 extern struct task_struct init_task;
1797
1798 extern struct   mm_struct init_mm;
1799
1800 extern struct pid_namespace init_pid_ns;
1801
1802 /*
1803  * find a task by one of its numerical ids
1804  *
1805  * find_task_by_pid_ns():
1806  *      finds a task by its pid in the specified namespace
1807  * find_task_by_vpid():
1808  *      finds a task by its virtual pid
1809  *
1810  * see also find_vpid() etc in include/linux/pid.h
1811  */
1812
1813 extern struct task_struct *find_task_by_vpid(pid_t nr);
1814 extern struct task_struct *find_task_by_pid_ns(pid_t nr,
1815                 struct pid_namespace *ns);
1816
1817 #include <asm/current.h>
1818
1819 extern void xtime_update(unsigned long ticks);
1820
1821 extern int wake_up_state(struct task_struct *tsk, unsigned int state);
1822 extern int wake_up_process(struct task_struct *tsk);
1823 extern void wake_up_new_task(struct task_struct *tsk);
1824 #ifdef CONFIG_SMP
1825  extern void kick_process(struct task_struct *tsk);
1826 #else
1827  static inline void kick_process(struct task_struct *tsk) { }
1828 #endif
1829 extern int sched_fork(unsigned long clone_flags, struct task_struct *p);
1830 extern void sched_dead(struct task_struct *p);
1831
1832 extern void proc_caches_init(void);
1833
1834 extern void release_task(struct task_struct * p);
1835
1836 #ifdef CONFIG_HAVE_COPY_THREAD_TLS
1837 extern int copy_thread_tls(unsigned long, unsigned long, unsigned long,
1838                         struct task_struct *, unsigned long);
1839 #else
1840 extern int copy_thread(unsigned long, unsigned long, unsigned long,
1841                         struct task_struct *);
1842
1843 /* Architectures that haven't opted into copy_thread_tls get the tls argument
1844  * via pt_regs, so ignore the tls argument passed via C. */
1845 static inline int copy_thread_tls(
1846                 unsigned long clone_flags, unsigned long sp, unsigned long arg,
1847                 struct task_struct *p, unsigned long tls)
1848 {
1849         return copy_thread(clone_flags, sp, arg, p);
1850 }
1851 #endif
1852 extern void flush_thread(void);
1853
1854 #ifdef CONFIG_HAVE_EXIT_THREAD
1855 extern void exit_thread(struct task_struct *tsk);
1856 #else
1857 static inline void exit_thread(struct task_struct *tsk)
1858 {
1859 }
1860 #endif
1861
1862 extern void exit_files(struct task_struct *);
1863
1864 extern void exit_itimers(struct signal_struct *);
1865
1866 extern void do_group_exit(int);
1867
1868 extern int do_execve(struct filename *,
1869                      const char __user * const __user *,
1870                      const char __user * const __user *);
1871 extern int do_execveat(int, struct filename *,
1872                        const char __user * const __user *,
1873                        const char __user * const __user *,
1874                        int);
1875 extern long _do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *, unsigned long);
1876 extern long do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *);
1877 struct task_struct *fork_idle(int);
1878 extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
1879
1880 extern void __set_task_comm(struct task_struct *tsk, const char *from, bool exec);
1881 static inline void set_task_comm(struct task_struct *tsk, const char *from)
1882 {
1883         __set_task_comm(tsk, from, false);
1884 }
1885 extern char *get_task_comm(char *to, struct task_struct *tsk);
1886
1887 #ifdef CONFIG_SMP
1888 void scheduler_ipi(void);
1889 extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
1890 #else
1891 static inline void scheduler_ipi(void) { }
1892 static inline unsigned long wait_task_inactive(struct task_struct *p,
1893                                                long match_state)
1894 {
1895         return 1;
1896 }
1897 #endif
1898
1899 /*
1900  * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
1901  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
1902  * pins the final release of task.io_context.  Also protects ->cpuset and
1903  * ->cgroup.subsys[]. And ->vfork_done.
1904  *
1905  * Nests both inside and outside of read_lock(&tasklist_lock).
1906  * It must not be nested with write_lock_irq(&tasklist_lock),
1907  * neither inside nor outside.
1908  */
1909 static inline void task_lock(struct task_struct *p)
1910 {
1911         spin_lock(&p->alloc_lock);
1912 }
1913
1914 static inline void task_unlock(struct task_struct *p)
1915 {
1916         spin_unlock(&p->alloc_lock);
1917 }
1918
1919 #ifdef CONFIG_THREAD_INFO_IN_TASK
1920
1921 static inline struct thread_info *task_thread_info(struct task_struct *task)
1922 {
1923         return &task->thread_info;
1924 }
1925
1926 /*
1927  * When accessing the stack of a non-current task that might exit, use
1928  * try_get_task_stack() instead.  task_stack_page will return a pointer
1929  * that could get freed out from under you.
1930  */
1931 static inline void *task_stack_page(const struct task_struct *task)
1932 {
1933         return task->stack;
1934 }
1935
1936 #define setup_thread_stack(new,old)     do { } while(0)
1937
1938 static inline unsigned long *end_of_stack(const struct task_struct *task)
1939 {
1940         return task->stack;
1941 }
1942
1943 #elif !defined(__HAVE_THREAD_FUNCTIONS)
1944
1945 #define task_thread_info(task)  ((struct thread_info *)(task)->stack)
1946 #define task_stack_page(task)   ((void *)(task)->stack)
1947
1948 static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
1949 {
1950         *task_thread_info(p) = *task_thread_info(org);
1951         task_thread_info(p)->task = p;
1952 }
1953
1954 /*
1955  * Return the address of the last usable long on the stack.
1956  *
1957  * When the stack grows down, this is just above the thread
1958  * info struct. Going any lower will corrupt the threadinfo.
1959  *
1960  * When the stack grows up, this is the highest address.
1961  * Beyond that position, we corrupt data on the next page.
1962  */
1963 static inline unsigned long *end_of_stack(struct task_struct *p)
1964 {
1965 #ifdef CONFIG_STACK_GROWSUP
1966         return (unsigned long *)((unsigned long)task_thread_info(p) + THREAD_SIZE) - 1;
1967 #else
1968         return (unsigned long *)(task_thread_info(p) + 1);
1969 #endif
1970 }
1971
1972 #endif
1973
1974 #ifdef CONFIG_THREAD_INFO_IN_TASK
1975 static inline void *try_get_task_stack(struct task_struct *tsk)
1976 {
1977         return atomic_inc_not_zero(&tsk->stack_refcount) ?
1978                 task_stack_page(tsk) : NULL;
1979 }
1980
1981 extern void put_task_stack(struct task_struct *tsk);
1982 #else
1983 static inline void *try_get_task_stack(struct task_struct *tsk)
1984 {
1985         return task_stack_page(tsk);
1986 }
1987
1988 static inline void put_task_stack(struct task_struct *tsk) {}
1989 #endif
1990
1991 #define task_stack_end_corrupted(task) \
1992                 (*(end_of_stack(task)) != STACK_END_MAGIC)
1993
1994 static inline int object_is_on_stack(void *obj)
1995 {
1996         void *stack = task_stack_page(current);
1997
1998         return (obj >= stack) && (obj < (stack + THREAD_SIZE));
1999 }
2000
2001 extern void thread_stack_cache_init(void);
2002
2003 #ifdef CONFIG_DEBUG_STACK_USAGE
2004 static inline unsigned long stack_not_used(struct task_struct *p)
2005 {
2006         unsigned long *n = end_of_stack(p);
2007
2008         do {    /* Skip over canary */
2009 # ifdef CONFIG_STACK_GROWSUP
2010                 n--;
2011 # else
2012                 n++;
2013 # endif
2014         } while (!*n);
2015
2016 # ifdef CONFIG_STACK_GROWSUP
2017         return (unsigned long)end_of_stack(p) - (unsigned long)n;
2018 # else
2019         return (unsigned long)n - (unsigned long)end_of_stack(p);
2020 # endif
2021 }
2022 #endif
2023 extern void set_task_stack_end_magic(struct task_struct *tsk);
2024
2025 /* set thread flags in other task's structures
2026  * - see asm/thread_info.h for TIF_xxxx flags available
2027  */
2028 static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
2029 {
2030         set_ti_thread_flag(task_thread_info(tsk), flag);
2031 }
2032
2033 static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2034 {
2035         clear_ti_thread_flag(task_thread_info(tsk), flag);
2036 }
2037
2038 static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
2039 {
2040         return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
2041 }
2042
2043 static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
2044 {
2045         return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
2046 }
2047
2048 static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
2049 {
2050         return test_ti_thread_flag(task_thread_info(tsk), flag);
2051 }
2052
2053 static inline void set_tsk_need_resched(struct task_struct *tsk)
2054 {
2055         set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2056 }
2057
2058 static inline void clear_tsk_need_resched(struct task_struct *tsk)
2059 {
2060         clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
2061 }
2062
2063 static inline int test_tsk_need_resched(struct task_struct *tsk)
2064 {
2065         return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
2066 }
2067
2068 static inline int restart_syscall(void)
2069 {
2070         set_tsk_thread_flag(current, TIF_SIGPENDING);
2071         return -ERESTARTNOINTR;
2072 }
2073
2074 static inline int signal_pending(struct task_struct *p)
2075 {
2076         return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
2077 }
2078
2079 static inline int __fatal_signal_pending(struct task_struct *p)
2080 {
2081         return unlikely(sigismember(&p->pending.signal, SIGKILL));
2082 }
2083
2084 static inline int fatal_signal_pending(struct task_struct *p)
2085 {
2086         return signal_pending(p) && __fatal_signal_pending(p);
2087 }
2088
2089 static inline int signal_pending_state(long state, struct task_struct *p)
2090 {
2091         if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
2092                 return 0;
2093         if (!signal_pending(p))
2094                 return 0;
2095
2096         return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
2097 }
2098
2099 /*
2100  * cond_resched() and cond_resched_lock(): latency reduction via
2101  * explicit rescheduling in places that are safe. The return
2102  * value indicates whether a reschedule was done in fact.
2103  * cond_resched_lock() will drop the spinlock before scheduling,
2104  * cond_resched_softirq() will enable bhs before scheduling.
2105  */
2106 #ifndef CONFIG_PREEMPT
2107 extern int _cond_resched(void);
2108 #else
2109 static inline int _cond_resched(void) { return 0; }
2110 #endif
2111
2112 #define cond_resched() ({                       \
2113         ___might_sleep(__FILE__, __LINE__, 0);  \
2114         _cond_resched();                        \
2115 })
2116
2117 extern int __cond_resched_lock(spinlock_t *lock);
2118
2119 #define cond_resched_lock(lock) ({                              \
2120         ___might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET);\
2121         __cond_resched_lock(lock);                              \
2122 })
2123
2124 extern int __cond_resched_softirq(void);
2125
2126 #define cond_resched_softirq() ({                                       \
2127         ___might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET);     \
2128         __cond_resched_softirq();                                       \
2129 })
2130
2131 static inline void cond_resched_rcu(void)
2132 {
2133 #if defined(CONFIG_DEBUG_ATOMIC_SLEEP) || !defined(CONFIG_PREEMPT_RCU)
2134         rcu_read_unlock();
2135         cond_resched();
2136         rcu_read_lock();
2137 #endif
2138 }
2139
2140 /*
2141  * Does a critical section need to be broken due to another
2142  * task waiting?: (technically does not depend on CONFIG_PREEMPT,
2143  * but a general need for low latency)
2144  */
2145 static inline int spin_needbreak(spinlock_t *lock)
2146 {
2147 #ifdef CONFIG_PREEMPT
2148         return spin_is_contended(lock);
2149 #else
2150         return 0;
2151 #endif
2152 }
2153
2154 static __always_inline bool need_resched(void)
2155 {
2156         return unlikely(tif_need_resched());
2157 }
2158
2159 /*
2160  * Thread group CPU time accounting.
2161  */
2162 void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
2163 void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
2164
2165 /*
2166  * Reevaluate whether the task has signals pending delivery.
2167  * Wake the task if so.
2168  * This is required every time the blocked sigset_t changes.
2169  * callers must hold sighand->siglock.
2170  */
2171 extern void recalc_sigpending_and_wake(struct task_struct *t);
2172 extern void recalc_sigpending(void);
2173
2174 extern void signal_wake_up_state(struct task_struct *t, unsigned int state);
2175
2176 static inline void signal_wake_up(struct task_struct *t, bool resume)
2177 {
2178         signal_wake_up_state(t, resume ? TASK_WAKEKILL : 0);
2179 }
2180 static inline void ptrace_signal_wake_up(struct task_struct *t, bool resume)
2181 {
2182         signal_wake_up_state(t, resume ? __TASK_TRACED : 0);
2183 }
2184
2185 /*
2186  * Wrappers for p->thread_info->cpu access. No-op on UP.
2187  */
2188 #ifdef CONFIG_SMP
2189
2190 static inline unsigned int task_cpu(const struct task_struct *p)
2191 {
2192 #ifdef CONFIG_THREAD_INFO_IN_TASK
2193         return p->cpu;
2194 #else
2195         return task_thread_info(p)->cpu;
2196 #endif
2197 }
2198
2199 static inline int task_node(const struct task_struct *p)
2200 {
2201         return cpu_to_node(task_cpu(p));
2202 }
2203
2204 extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
2205
2206 #else
2207
2208 static inline unsigned int task_cpu(const struct task_struct *p)
2209 {
2210         return 0;
2211 }
2212
2213 static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
2214 {
2215 }
2216
2217 #endif /* CONFIG_SMP */
2218
2219 /*
2220  * In order to reduce various lock holder preemption latencies provide an
2221  * interface to see if a vCPU is currently running or not.
2222  *
2223  * This allows us to terminate optimistic spin loops and block, analogous to
2224  * the native optimistic spin heuristic of testing if the lock owner task is
2225  * running or not.
2226  */
2227 #ifndef vcpu_is_preempted
2228 # define vcpu_is_preempted(cpu) false
2229 #endif
2230
2231 extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
2232 extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
2233
2234 #ifdef CONFIG_CGROUP_SCHED
2235 extern struct task_group root_task_group;
2236 #endif /* CONFIG_CGROUP_SCHED */
2237
2238 extern int task_can_switch_user(struct user_struct *up,
2239                                         struct task_struct *tsk);
2240
2241 #ifdef CONFIG_TASK_XACCT
2242 static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2243 {
2244         tsk->ioac.rchar += amt;
2245 }
2246
2247 static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2248 {
2249         tsk->ioac.wchar += amt;
2250 }
2251
2252 static inline void inc_syscr(struct task_struct *tsk)
2253 {
2254         tsk->ioac.syscr++;
2255 }
2256
2257 static inline void inc_syscw(struct task_struct *tsk)
2258 {
2259         tsk->ioac.syscw++;
2260 }
2261 #else
2262 static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
2263 {
2264 }
2265
2266 static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
2267 {
2268 }
2269
2270 static inline void inc_syscr(struct task_struct *tsk)
2271 {
2272 }
2273
2274 static inline void inc_syscw(struct task_struct *tsk)
2275 {
2276 }
2277 #endif
2278
2279 #ifndef TASK_SIZE_OF
2280 #define TASK_SIZE_OF(tsk)       TASK_SIZE
2281 #endif
2282
2283 #ifdef CONFIG_MEMCG
2284 extern void mm_update_next_owner(struct mm_struct *mm);
2285 #else
2286 static inline void mm_update_next_owner(struct mm_struct *mm)
2287 {
2288 }
2289 #endif /* CONFIG_MEMCG */
2290
2291 #define SCHED_CPUFREQ_RT        (1U << 0)
2292 #define SCHED_CPUFREQ_DL        (1U << 1)
2293 #define SCHED_CPUFREQ_IOWAIT    (1U << 2)
2294
2295 #define SCHED_CPUFREQ_RT_DL     (SCHED_CPUFREQ_RT | SCHED_CPUFREQ_DL)
2296
2297 #ifdef CONFIG_CPU_FREQ
2298 struct update_util_data {
2299        void (*func)(struct update_util_data *data, u64 time, unsigned int flags);
2300 };
2301
2302 void cpufreq_add_update_util_hook(int cpu, struct update_util_data *data,
2303                        void (*func)(struct update_util_data *data, u64 time,
2304                                     unsigned int flags));
2305 void cpufreq_remove_update_util_hook(int cpu);
2306 #endif /* CONFIG_CPU_FREQ */
2307
2308 #endif