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