1
2#ifndef _LINUX_SCHED_SIGNAL_H
3#define _LINUX_SCHED_SIGNAL_H
4
5#include <linux/rculist.h>
6#include <linux/signal.h>
7#include <linux/sched.h>
8#include <linux/sched/jobctl.h>
9#include <linux/sched/task.h>
10#include <linux/cred.h>
11#include <linux/refcount.h>
12#include <linux/posix-timers.h>
13#include <linux/mm_types.h>
14#include <asm/ptrace.h>
15
16
17
18
19
20struct sighand_struct {
21 spinlock_t siglock;
22 refcount_t count;
23 wait_queue_head_t signalfd_wqh;
24 struct k_sigaction action[_NSIG];
25};
26
27
28
29
30struct pacct_struct {
31 int ac_flag;
32 long ac_exitcode;
33 unsigned long ac_mem;
34 u64 ac_utime, ac_stime;
35 unsigned long ac_minflt, ac_majflt;
36};
37
38struct cpu_itimer {
39 u64 expires;
40 u64 incr;
41};
42
43
44
45
46
47struct task_cputime_atomic {
48 atomic64_t utime;
49 atomic64_t stime;
50 atomic64_t sum_exec_runtime;
51};
52
53#define INIT_CPUTIME_ATOMIC \
54 (struct task_cputime_atomic) { \
55 .utime = ATOMIC64_INIT(0), \
56 .stime = ATOMIC64_INIT(0), \
57 .sum_exec_runtime = ATOMIC64_INIT(0), \
58 }
59
60
61
62
63
64
65
66struct thread_group_cputimer {
67 struct task_cputime_atomic cputime_atomic;
68};
69
70struct multiprocess_signals {
71 sigset_t signal;
72 struct hlist_node node;
73};
74
75
76
77
78
79
80
81
82struct signal_struct {
83 refcount_t sigcnt;
84 atomic_t live;
85 int nr_threads;
86 struct list_head thread_head;
87
88 wait_queue_head_t wait_chldexit;
89
90
91 struct task_struct *curr_target;
92
93
94 struct sigpending shared_pending;
95
96
97 struct hlist_head multiprocess;
98
99
100 int group_exit_code;
101
102
103
104
105
106 int notify_count;
107 struct task_struct *group_exit_task;
108
109
110 int group_stop_count;
111 unsigned int flags;
112
113
114
115
116
117
118
119
120
121
122 unsigned int is_child_subreaper:1;
123 unsigned int has_child_subreaper:1;
124
125#ifdef CONFIG_POSIX_TIMERS
126
127
128 int posix_timer_id;
129 struct list_head posix_timers;
130
131
132 struct hrtimer real_timer;
133 ktime_t it_real_incr;
134
135
136
137
138
139
140 struct cpu_itimer it[2];
141
142
143
144
145
146 struct thread_group_cputimer cputimer;
147
148#endif
149
150 struct posix_cputimers posix_cputimers;
151
152
153 struct pid *pids[PIDTYPE_MAX];
154
155#ifdef CONFIG_NO_HZ_FULL
156 atomic_t tick_dep_mask;
157#endif
158
159 struct pid *tty_old_pgrp;
160
161
162 int leader;
163
164 struct tty_struct *tty;
165
166#ifdef CONFIG_SCHED_AUTOGROUP
167 struct autogroup *autogroup;
168#endif
169
170
171
172
173
174
175 seqlock_t stats_lock;
176 u64 utime, stime, cutime, cstime;
177 u64 gtime;
178 u64 cgtime;
179 struct prev_cputime prev_cputime;
180 unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
181 unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
182 unsigned long inblock, oublock, cinblock, coublock;
183 unsigned long maxrss, cmaxrss;
184 struct task_io_accounting ioac;
185
186
187
188
189
190
191
192 unsigned long long sum_sched_runtime;
193
194
195
196
197
198
199
200
201
202
203 struct rlimit rlim[RLIM_NLIMITS];
204
205#ifdef CONFIG_BSD_PROCESS_ACCT
206 struct pacct_struct pacct;
207#endif
208#ifdef CONFIG_TASKSTATS
209 struct taskstats *stats;
210#endif
211#ifdef CONFIG_AUDIT
212 unsigned audit_tty;
213 struct tty_audit_buf *tty_audit_buf;
214#endif
215
216
217
218
219
220 bool oom_flag_origin;
221 short oom_score_adj;
222 short oom_score_adj_min;
223
224 struct mm_struct *oom_mm;
225
226
227 struct mutex cred_guard_mutex;
228
229
230
231
232
233 struct rw_semaphore exec_update_lock;
234
235
236
237
238} __randomize_layout;
239
240
241
242
243#define SIGNAL_STOP_STOPPED 0x00000001
244#define SIGNAL_STOP_CONTINUED 0x00000002
245#define SIGNAL_GROUP_EXIT 0x00000004
246#define SIGNAL_GROUP_COREDUMP 0x00000008
247
248
249
250#define SIGNAL_CLD_STOPPED 0x00000010
251#define SIGNAL_CLD_CONTINUED 0x00000020
252#define SIGNAL_CLD_MASK (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
253
254#define SIGNAL_UNKILLABLE 0x00000040
255
256#define SIGNAL_STOP_MASK (SIGNAL_CLD_MASK | SIGNAL_STOP_STOPPED | \
257 SIGNAL_STOP_CONTINUED)
258
259static inline void signal_set_stop_flags(struct signal_struct *sig,
260 unsigned int flags)
261{
262 WARN_ON(sig->flags & (SIGNAL_GROUP_EXIT|SIGNAL_GROUP_COREDUMP));
263 sig->flags = (sig->flags & ~SIGNAL_STOP_MASK) | flags;
264}
265
266
267static inline int signal_group_exit(const struct signal_struct *sig)
268{
269 return (sig->flags & SIGNAL_GROUP_EXIT) ||
270 (sig->group_exit_task != NULL);
271}
272
273extern void flush_signals(struct task_struct *);
274extern void ignore_signals(struct task_struct *);
275extern void flush_signal_handlers(struct task_struct *, int force_default);
276extern int dequeue_signal(struct task_struct *task,
277 sigset_t *mask, kernel_siginfo_t *info);
278
279static inline int kernel_dequeue_signal(void)
280{
281 struct task_struct *task = current;
282 kernel_siginfo_t __info;
283 int ret;
284
285 spin_lock_irq(&task->sighand->siglock);
286 ret = dequeue_signal(task, &task->blocked, &__info);
287 spin_unlock_irq(&task->sighand->siglock);
288
289 return ret;
290}
291
292static inline void kernel_signal_stop(void)
293{
294 spin_lock_irq(¤t->sighand->siglock);
295 if (current->jobctl & JOBCTL_STOP_DEQUEUED)
296 set_special_state(TASK_STOPPED);
297 spin_unlock_irq(¤t->sighand->siglock);
298
299 schedule();
300}
301#ifdef __ARCH_SI_TRAPNO
302# define ___ARCH_SI_TRAPNO(_a1) , _a1
303#else
304# define ___ARCH_SI_TRAPNO(_a1)
305#endif
306#ifdef __ia64__
307# define ___ARCH_SI_IA64(_a1, _a2, _a3) , _a1, _a2, _a3
308#else
309# define ___ARCH_SI_IA64(_a1, _a2, _a3)
310#endif
311
312int force_sig_fault_to_task(int sig, int code, void __user *addr
313 ___ARCH_SI_TRAPNO(int trapno)
314 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
315 , struct task_struct *t);
316int force_sig_fault(int sig, int code, void __user *addr
317 ___ARCH_SI_TRAPNO(int trapno)
318 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr));
319int send_sig_fault(int sig, int code, void __user *addr
320 ___ARCH_SI_TRAPNO(int trapno)
321 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
322 , struct task_struct *t);
323
324int force_sig_mceerr(int code, void __user *, short);
325int send_sig_mceerr(int code, void __user *, short, struct task_struct *);
326
327int force_sig_bnderr(void __user *addr, void __user *lower, void __user *upper);
328int force_sig_pkuerr(void __user *addr, u32 pkey);
329
330int force_sig_ptrace_errno_trap(int errno, void __user *addr);
331
332extern int send_sig_info(int, struct kernel_siginfo *, struct task_struct *);
333extern void force_sigsegv(int sig);
334extern int force_sig_info(struct kernel_siginfo *);
335extern int __kill_pgrp_info(int sig, struct kernel_siginfo *info, struct pid *pgrp);
336extern int kill_pid_info(int sig, struct kernel_siginfo *info, struct pid *pid);
337extern int kill_pid_usb_asyncio(int sig, int errno, sigval_t addr, struct pid *,
338 const struct cred *);
339extern int kill_pgrp(struct pid *pid, int sig, int priv);
340extern int kill_pid(struct pid *pid, int sig, int priv);
341extern __must_check bool do_notify_parent(struct task_struct *, int);
342extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
343extern void force_sig(int);
344extern int send_sig(int, struct task_struct *, int);
345extern int zap_other_threads(struct task_struct *p);
346extern struct sigqueue *sigqueue_alloc(void);
347extern void sigqueue_free(struct sigqueue *);
348extern int send_sigqueue(struct sigqueue *, struct pid *, enum pid_type);
349extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
350
351static inline int restart_syscall(void)
352{
353 set_tsk_thread_flag(current, TIF_SIGPENDING);
354 return -ERESTARTNOINTR;
355}
356
357static inline int task_sigpending(struct task_struct *p)
358{
359 return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
360}
361
362static inline int signal_pending(struct task_struct *p)
363{
364
365
366
367
368
369 if (unlikely(test_tsk_thread_flag(p, TIF_NOTIFY_SIGNAL)))
370 return 1;
371 return task_sigpending(p);
372}
373
374static inline int __fatal_signal_pending(struct task_struct *p)
375{
376 return unlikely(sigismember(&p->pending.signal, SIGKILL));
377}
378
379static inline int fatal_signal_pending(struct task_struct *p)
380{
381 return task_sigpending(p) && __fatal_signal_pending(p);
382}
383
384static inline int signal_pending_state(long state, struct task_struct *p)
385{
386 if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
387 return 0;
388 if (!signal_pending(p))
389 return 0;
390
391 return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
392}
393
394
395
396
397
398
399
400static inline bool fault_signal_pending(vm_fault_t fault_flags,
401 struct pt_regs *regs)
402{
403 return unlikely((fault_flags & VM_FAULT_RETRY) &&
404 (fatal_signal_pending(current) ||
405 (user_mode(regs) && signal_pending(current))));
406}
407
408
409
410
411
412
413
414extern void recalc_sigpending_and_wake(struct task_struct *t);
415extern void recalc_sigpending(void);
416extern void calculate_sigpending(void);
417
418extern void signal_wake_up_state(struct task_struct *t, unsigned int state);
419
420static inline void signal_wake_up(struct task_struct *t, bool resume)
421{
422 signal_wake_up_state(t, resume ? TASK_WAKEKILL : 0);
423}
424static inline void ptrace_signal_wake_up(struct task_struct *t, bool resume)
425{
426 signal_wake_up_state(t, resume ? __TASK_TRACED : 0);
427}
428
429void task_join_group_stop(struct task_struct *task);
430
431#ifdef TIF_RESTORE_SIGMASK
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448static inline void set_restore_sigmask(void)
449{
450 set_thread_flag(TIF_RESTORE_SIGMASK);
451}
452
453static inline void clear_tsk_restore_sigmask(struct task_struct *task)
454{
455 clear_tsk_thread_flag(task, TIF_RESTORE_SIGMASK);
456}
457
458static inline void clear_restore_sigmask(void)
459{
460 clear_thread_flag(TIF_RESTORE_SIGMASK);
461}
462static inline bool test_tsk_restore_sigmask(struct task_struct *task)
463{
464 return test_tsk_thread_flag(task, TIF_RESTORE_SIGMASK);
465}
466static inline bool test_restore_sigmask(void)
467{
468 return test_thread_flag(TIF_RESTORE_SIGMASK);
469}
470static inline bool test_and_clear_restore_sigmask(void)
471{
472 return test_and_clear_thread_flag(TIF_RESTORE_SIGMASK);
473}
474
475#else
476
477
478static inline void set_restore_sigmask(void)
479{
480 current->restore_sigmask = true;
481}
482static inline void clear_tsk_restore_sigmask(struct task_struct *task)
483{
484 task->restore_sigmask = false;
485}
486static inline void clear_restore_sigmask(void)
487{
488 current->restore_sigmask = false;
489}
490static inline bool test_restore_sigmask(void)
491{
492 return current->restore_sigmask;
493}
494static inline bool test_tsk_restore_sigmask(struct task_struct *task)
495{
496 return task->restore_sigmask;
497}
498static inline bool test_and_clear_restore_sigmask(void)
499{
500 if (!current->restore_sigmask)
501 return false;
502 current->restore_sigmask = false;
503 return true;
504}
505#endif
506
507static inline void restore_saved_sigmask(void)
508{
509 if (test_and_clear_restore_sigmask())
510 __set_current_blocked(¤t->saved_sigmask);
511}
512
513extern int set_user_sigmask(const sigset_t __user *umask, size_t sigsetsize);
514
515static inline void restore_saved_sigmask_unless(bool interrupted)
516{
517 if (interrupted)
518 WARN_ON(!signal_pending(current));
519 else
520 restore_saved_sigmask();
521}
522
523static inline sigset_t *sigmask_to_save(void)
524{
525 sigset_t *res = ¤t->blocked;
526 if (unlikely(test_restore_sigmask()))
527 res = ¤t->saved_sigmask;
528 return res;
529}
530
531static inline int kill_cad_pid(int sig, int priv)
532{
533 return kill_pid(cad_pid, sig, priv);
534}
535
536
537#define SEND_SIG_NOINFO ((struct kernel_siginfo *) 0)
538#define SEND_SIG_PRIV ((struct kernel_siginfo *) 1)
539
540
541
542
543static inline int on_sig_stack(unsigned long sp)
544{
545
546
547
548
549
550
551
552
553
554 if (current->sas_ss_flags & SS_AUTODISARM)
555 return 0;
556
557#ifdef CONFIG_STACK_GROWSUP
558 return sp >= current->sas_ss_sp &&
559 sp - current->sas_ss_sp < current->sas_ss_size;
560#else
561 return sp > current->sas_ss_sp &&
562 sp - current->sas_ss_sp <= current->sas_ss_size;
563#endif
564}
565
566static inline int sas_ss_flags(unsigned long sp)
567{
568 if (!current->sas_ss_size)
569 return SS_DISABLE;
570
571 return on_sig_stack(sp) ? SS_ONSTACK : 0;
572}
573
574static inline void sas_ss_reset(struct task_struct *p)
575{
576 p->sas_ss_sp = 0;
577 p->sas_ss_size = 0;
578 p->sas_ss_flags = SS_DISABLE;
579}
580
581static inline unsigned long sigsp(unsigned long sp, struct ksignal *ksig)
582{
583 if (unlikely((ksig->ka.sa.sa_flags & SA_ONSTACK)) && ! sas_ss_flags(sp))
584#ifdef CONFIG_STACK_GROWSUP
585 return current->sas_ss_sp;
586#else
587 return current->sas_ss_sp + current->sas_ss_size;
588#endif
589 return sp;
590}
591
592extern void __cleanup_sighand(struct sighand_struct *);
593extern void flush_itimer_signals(void);
594
595#define tasklist_empty() \
596 list_empty(&init_task.tasks)
597
598#define next_task(p) \
599 list_entry_rcu((p)->tasks.next, struct task_struct, tasks)
600
601#define for_each_process(p) \
602 for (p = &init_task ; (p = next_task(p)) != &init_task ; )
603
604extern bool current_is_single_threaded(void);
605
606
607
608
609
610#define do_each_thread(g, t) \
611 for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
612
613#define while_each_thread(g, t) \
614 while ((t = next_thread(t)) != g)
615
616#define __for_each_thread(signal, t) \
617 list_for_each_entry_rcu(t, &(signal)->thread_head, thread_node)
618
619#define for_each_thread(p, t) \
620 __for_each_thread((p)->signal, t)
621
622
623#define for_each_process_thread(p, t) \
624 for_each_process(p) for_each_thread(p, t)
625
626typedef int (*proc_visitor)(struct task_struct *p, void *data);
627void walk_process_tree(struct task_struct *top, proc_visitor, void *);
628
629static inline
630struct pid *task_pid_type(struct task_struct *task, enum pid_type type)
631{
632 struct pid *pid;
633 if (type == PIDTYPE_PID)
634 pid = task_pid(task);
635 else
636 pid = task->signal->pids[type];
637 return pid;
638}
639
640static inline struct pid *task_tgid(struct task_struct *task)
641{
642 return task->signal->pids[PIDTYPE_TGID];
643}
644
645
646
647
648
649
650static inline struct pid *task_pgrp(struct task_struct *task)
651{
652 return task->signal->pids[PIDTYPE_PGID];
653}
654
655static inline struct pid *task_session(struct task_struct *task)
656{
657 return task->signal->pids[PIDTYPE_SID];
658}
659
660static inline int get_nr_threads(struct task_struct *task)
661{
662 return task->signal->nr_threads;
663}
664
665static inline bool thread_group_leader(struct task_struct *p)
666{
667 return p->exit_signal >= 0;
668}
669
670static inline
671bool same_thread_group(struct task_struct *p1, struct task_struct *p2)
672{
673 return p1->signal == p2->signal;
674}
675
676static inline struct task_struct *next_thread(const struct task_struct *p)
677{
678 return list_entry_rcu(p->thread_group.next,
679 struct task_struct, thread_group);
680}
681
682static inline int thread_group_empty(struct task_struct *p)
683{
684 return list_empty(&p->thread_group);
685}
686
687#define delay_group_leader(p) \
688 (thread_group_leader(p) && !thread_group_empty(p))
689
690extern bool thread_group_exited(struct pid *pid);
691
692extern struct sighand_struct *__lock_task_sighand(struct task_struct *task,
693 unsigned long *flags);
694
695static inline struct sighand_struct *lock_task_sighand(struct task_struct *task,
696 unsigned long *flags)
697{
698 struct sighand_struct *ret;
699
700 ret = __lock_task_sighand(task, flags);
701 (void)__cond_lock(&task->sighand->siglock, ret);
702 return ret;
703}
704
705static inline void unlock_task_sighand(struct task_struct *task,
706 unsigned long *flags)
707{
708 spin_unlock_irqrestore(&task->sighand->siglock, *flags);
709}
710
711static inline unsigned long task_rlimit(const struct task_struct *task,
712 unsigned int limit)
713{
714 return READ_ONCE(task->signal->rlim[limit].rlim_cur);
715}
716
717static inline unsigned long task_rlimit_max(const struct task_struct *task,
718 unsigned int limit)
719{
720 return READ_ONCE(task->signal->rlim[limit].rlim_max);
721}
722
723static inline unsigned long rlimit(unsigned int limit)
724{
725 return task_rlimit(current, limit);
726}
727
728static inline unsigned long rlimit_max(unsigned int limit)
729{
730 return task_rlimit_max(current, limit);
731}
732
733#endif
734