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