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