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