~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/signal.c

Version: ~ [ linux-5.15-rc5 ] ~ [ linux-5.14.11 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.72 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.152 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.210 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.250 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.286 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.288 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-only
  2 /*
  3  *  linux/kernel/signal.c
  4  *
  5  *  Copyright (C) 1991, 1992  Linus Torvalds
  6  *
  7  *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
  8  *
  9  *  2003-06-02  Jim Houston - Concurrent Computer Corp.
 10  *              Changes to use preallocated sigqueue structures
 11  *              to allow signals to be sent reliably.
 12  */
 13 
 14 #include <linux/slab.h>
 15 #include <linux/export.h>
 16 #include <linux/init.h>
 17 #include <linux/sched/mm.h>
 18 #include <linux/sched/user.h>
 19 #include <linux/sched/debug.h>
 20 #include <linux/sched/task.h>
 21 #include <linux/sched/task_stack.h>
 22 #include <linux/sched/cputime.h>
 23 #include <linux/file.h>
 24 #include <linux/fs.h>
 25 #include <linux/proc_fs.h>
 26 #include <linux/tty.h>
 27 #include <linux/binfmts.h>
 28 #include <linux/coredump.h>
 29 #include <linux/security.h>
 30 #include <linux/syscalls.h>
 31 #include <linux/ptrace.h>
 32 #include <linux/signal.h>
 33 #include <linux/signalfd.h>
 34 #include <linux/ratelimit.h>
 35 #include <linux/tracehook.h>
 36 #include <linux/capability.h>
 37 #include <linux/freezer.h>
 38 #include <linux/pid_namespace.h>
 39 #include <linux/nsproxy.h>
 40 #include <linux/user_namespace.h>
 41 #include <linux/uprobes.h>
 42 #include <linux/compat.h>
 43 #include <linux/cn_proc.h>
 44 #include <linux/compiler.h>
 45 #include <linux/posix-timers.h>
 46 #include <linux/livepatch.h>
 47 #include <linux/cgroup.h>
 48 #include <linux/audit.h>
 49 
 50 #define CREATE_TRACE_POINTS
 51 #include <trace/events/signal.h>
 52 
 53 #include <asm/param.h>
 54 #include <linux/uaccess.h>
 55 #include <asm/unistd.h>
 56 #include <asm/siginfo.h>
 57 #include <asm/cacheflush.h>
 58 
 59 /*
 60  * SLAB caches for signal bits.
 61  */
 62 
 63 static struct kmem_cache *sigqueue_cachep;
 64 
 65 int print_fatal_signals __read_mostly;
 66 
 67 static void __user *sig_handler(struct task_struct *t, int sig)
 68 {
 69         return t->sighand->action[sig - 1].sa.sa_handler;
 70 }
 71 
 72 static inline bool sig_handler_ignored(void __user *handler, int sig)
 73 {
 74         /* Is it explicitly or implicitly ignored? */
 75         return handler == SIG_IGN ||
 76                (handler == SIG_DFL && sig_kernel_ignore(sig));
 77 }
 78 
 79 static bool sig_task_ignored(struct task_struct *t, int sig, bool force)
 80 {
 81         void __user *handler;
 82 
 83         handler = sig_handler(t, sig);
 84 
 85         /* SIGKILL and SIGSTOP may not be sent to the global init */
 86         if (unlikely(is_global_init(t) && sig_kernel_only(sig)))
 87                 return true;
 88 
 89         if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
 90             handler == SIG_DFL && !(force && sig_kernel_only(sig)))
 91                 return true;
 92 
 93         /* Only allow kernel generated signals to this kthread */
 94         if (unlikely((t->flags & PF_KTHREAD) &&
 95                      (handler == SIG_KTHREAD_KERNEL) && !force))
 96                 return true;
 97 
 98         return sig_handler_ignored(handler, sig);
 99 }
100 
101 static bool sig_ignored(struct task_struct *t, int sig, bool force)
102 {
103         /*
104          * Blocked signals are never ignored, since the
105          * signal handler may change by the time it is
106          * unblocked.
107          */
108         if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
109                 return false;
110 
111         /*
112          * Tracers may want to know about even ignored signal unless it
113          * is SIGKILL which can't be reported anyway but can be ignored
114          * by SIGNAL_UNKILLABLE task.
115          */
116         if (t->ptrace && sig != SIGKILL)
117                 return false;
118 
119         return sig_task_ignored(t, sig, force);
120 }
121 
122 /*
123  * Re-calculate pending state from the set of locally pending
124  * signals, globally pending signals, and blocked signals.
125  */
126 static inline bool has_pending_signals(sigset_t *signal, sigset_t *blocked)
127 {
128         unsigned long ready;
129         long i;
130 
131         switch (_NSIG_WORDS) {
132         default:
133                 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
134                         ready |= signal->sig[i] &~ blocked->sig[i];
135                 break;
136 
137         case 4: ready  = signal->sig[3] &~ blocked->sig[3];
138                 ready |= signal->sig[2] &~ blocked->sig[2];
139                 ready |= signal->sig[1] &~ blocked->sig[1];
140                 ready |= signal->sig[0] &~ blocked->sig[0];
141                 break;
142 
143         case 2: ready  = signal->sig[1] &~ blocked->sig[1];
144                 ready |= signal->sig[0] &~ blocked->sig[0];
145                 break;
146 
147         case 1: ready  = signal->sig[0] &~ blocked->sig[0];
148         }
149         return ready != 0;
150 }
151 
152 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
153 
154 static bool recalc_sigpending_tsk(struct task_struct *t)
155 {
156         if ((t->jobctl & (JOBCTL_PENDING_MASK | JOBCTL_TRAP_FREEZE)) ||
157             PENDING(&t->pending, &t->blocked) ||
158             PENDING(&t->signal->shared_pending, &t->blocked) ||
159             cgroup_task_frozen(t)) {
160                 set_tsk_thread_flag(t, TIF_SIGPENDING);
161                 return true;
162         }
163 
164         /*
165          * We must never clear the flag in another thread, or in current
166          * when it's possible the current syscall is returning -ERESTART*.
167          * So we don't clear it here, and only callers who know they should do.
168          */
169         return false;
170 }
171 
172 /*
173  * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
174  * This is superfluous when called on current, the wakeup is a harmless no-op.
175  */
176 void recalc_sigpending_and_wake(struct task_struct *t)
177 {
178         if (recalc_sigpending_tsk(t))
179                 signal_wake_up(t, 0);
180 }
181 
182 void recalc_sigpending(void)
183 {
184         if (!recalc_sigpending_tsk(current) && !freezing(current) &&
185             !klp_patch_pending(current))
186                 clear_thread_flag(TIF_SIGPENDING);
187 
188 }
189 EXPORT_SYMBOL(recalc_sigpending);
190 
191 void calculate_sigpending(void)
192 {
193         /* Have any signals or users of TIF_SIGPENDING been delayed
194          * until after fork?
195          */
196         spin_lock_irq(&current->sighand->siglock);
197         set_tsk_thread_flag(current, TIF_SIGPENDING);
198         recalc_sigpending();
199         spin_unlock_irq(&current->sighand->siglock);
200 }
201 
202 /* Given the mask, find the first available signal that should be serviced. */
203 
204 #define SYNCHRONOUS_MASK \
205         (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
206          sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
207 
208 int next_signal(struct sigpending *pending, sigset_t *mask)
209 {
210         unsigned long i, *s, *m, x;
211         int sig = 0;
212 
213         s = pending->signal.sig;
214         m = mask->sig;
215 
216         /*
217          * Handle the first word specially: it contains the
218          * synchronous signals that need to be dequeued first.
219          */
220         x = *s &~ *m;
221         if (x) {
222                 if (x & SYNCHRONOUS_MASK)
223                         x &= SYNCHRONOUS_MASK;
224                 sig = ffz(~x) + 1;
225                 return sig;
226         }
227 
228         switch (_NSIG_WORDS) {
229         default:
230                 for (i = 1; i < _NSIG_WORDS; ++i) {
231                         x = *++s &~ *++m;
232                         if (!x)
233                                 continue;
234                         sig = ffz(~x) + i*_NSIG_BPW + 1;
235                         break;
236                 }
237                 break;
238 
239         case 2:
240                 x = s[1] &~ m[1];
241                 if (!x)
242                         break;
243                 sig = ffz(~x) + _NSIG_BPW + 1;
244                 break;
245 
246         case 1:
247                 /* Nothing to do */
248                 break;
249         }
250 
251         return sig;
252 }
253 
254 static inline void print_dropped_signal(int sig)
255 {
256         static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
257 
258         if (!print_fatal_signals)
259                 return;
260 
261         if (!__ratelimit(&ratelimit_state))
262                 return;
263 
264         pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
265                                 current->comm, current->pid, sig);
266 }
267 
268 /**
269  * task_set_jobctl_pending - set jobctl pending bits
270  * @task: target task
271  * @mask: pending bits to set
272  *
273  * Clear @mask from @task->jobctl.  @mask must be subset of
274  * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
275  * %JOBCTL_TRAPPING.  If stop signo is being set, the existing signo is
276  * cleared.  If @task is already being killed or exiting, this function
277  * becomes noop.
278  *
279  * CONTEXT:
280  * Must be called with @task->sighand->siglock held.
281  *
282  * RETURNS:
283  * %true if @mask is set, %false if made noop because @task was dying.
284  */
285 bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
286 {
287         BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
288                         JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
289         BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
290 
291         if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
292                 return false;
293 
294         if (mask & JOBCTL_STOP_SIGMASK)
295                 task->jobctl &= ~JOBCTL_STOP_SIGMASK;
296 
297         task->jobctl |= mask;
298         return true;
299 }
300 
301 /**
302  * task_clear_jobctl_trapping - clear jobctl trapping bit
303  * @task: target task
304  *
305  * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
306  * Clear it and wake up the ptracer.  Note that we don't need any further
307  * locking.  @task->siglock guarantees that @task->parent points to the
308  * ptracer.
309  *
310  * CONTEXT:
311  * Must be called with @task->sighand->siglock held.
312  */
313 void task_clear_jobctl_trapping(struct task_struct *task)
314 {
315         if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
316                 task->jobctl &= ~JOBCTL_TRAPPING;
317                 smp_mb();       /* advised by wake_up_bit() */
318                 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
319         }
320 }
321 
322 /**
323  * task_clear_jobctl_pending - clear jobctl pending bits
324  * @task: target task
325  * @mask: pending bits to clear
326  *
327  * Clear @mask from @task->jobctl.  @mask must be subset of
328  * %JOBCTL_PENDING_MASK.  If %JOBCTL_STOP_PENDING is being cleared, other
329  * STOP bits are cleared together.
330  *
331  * If clearing of @mask leaves no stop or trap pending, this function calls
332  * task_clear_jobctl_trapping().
333  *
334  * CONTEXT:
335  * Must be called with @task->sighand->siglock held.
336  */
337 void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
338 {
339         BUG_ON(mask & ~JOBCTL_PENDING_MASK);
340 
341         if (mask & JOBCTL_STOP_PENDING)
342                 mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
343 
344         task->jobctl &= ~mask;
345 
346         if (!(task->jobctl & JOBCTL_PENDING_MASK))
347                 task_clear_jobctl_trapping(task);
348 }
349 
350 /**
351  * task_participate_group_stop - participate in a group stop
352  * @task: task participating in a group stop
353  *
354  * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
355  * Group stop states are cleared and the group stop count is consumed if
356  * %JOBCTL_STOP_CONSUME was set.  If the consumption completes the group
357  * stop, the appropriate `SIGNAL_*` flags are set.
358  *
359  * CONTEXT:
360  * Must be called with @task->sighand->siglock held.
361  *
362  * RETURNS:
363  * %true if group stop completion should be notified to the parent, %false
364  * otherwise.
365  */
366 static bool task_participate_group_stop(struct task_struct *task)
367 {
368         struct signal_struct *sig = task->signal;
369         bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
370 
371         WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
372 
373         task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
374 
375         if (!consume)
376                 return false;
377 
378         if (!WARN_ON_ONCE(sig->group_stop_count == 0))
379                 sig->group_stop_count--;
380 
381         /*
382          * Tell the caller to notify completion iff we are entering into a
383          * fresh group stop.  Read comment in do_signal_stop() for details.
384          */
385         if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
386                 signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED);
387                 return true;
388         }
389         return false;
390 }
391 
392 void task_join_group_stop(struct task_struct *task)
393 {
394         /* Have the new thread join an on-going signal group stop */
395         unsigned long jobctl = current->jobctl;
396         if (jobctl & JOBCTL_STOP_PENDING) {
397                 struct signal_struct *sig = current->signal;
398                 unsigned long signr = jobctl & JOBCTL_STOP_SIGMASK;
399                 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
400                 if (task_set_jobctl_pending(task, signr | gstop)) {
401                         sig->group_stop_count++;
402                 }
403         }
404 }
405 
406 /*
407  * allocate a new signal queue record
408  * - this may be called without locks if and only if t == current, otherwise an
409  *   appropriate lock must be held to stop the target task from exiting
410  */
411 static struct sigqueue *
412 __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
413 {
414         struct sigqueue *q = NULL;
415         struct user_struct *user;
416         int sigpending;
417 
418         /*
419          * Protect access to @t credentials. This can go away when all
420          * callers hold rcu read lock.
421          *
422          * NOTE! A pending signal will hold on to the user refcount,
423          * and we get/put the refcount only when the sigpending count
424          * changes from/to zero.
425          */
426         rcu_read_lock();
427         user = __task_cred(t)->user;
428         sigpending = atomic_inc_return(&user->sigpending);
429         if (sigpending == 1)
430                 get_uid(user);
431         rcu_read_unlock();
432 
433         if (override_rlimit || likely(sigpending <= task_rlimit(t, RLIMIT_SIGPENDING))) {
434                 q = kmem_cache_alloc(sigqueue_cachep, flags);
435         } else {
436                 print_dropped_signal(sig);
437         }
438 
439         if (unlikely(q == NULL)) {
440                 if (atomic_dec_and_test(&user->sigpending))
441                         free_uid(user);
442         } else {
443                 INIT_LIST_HEAD(&q->list);
444                 q->flags = 0;
445                 q->user = user;
446         }
447 
448         return q;
449 }
450 
451 static void __sigqueue_free(struct sigqueue *q)
452 {
453         if (q->flags & SIGQUEUE_PREALLOC)
454                 return;
455         if (atomic_dec_and_test(&q->user->sigpending))
456                 free_uid(q->user);
457         kmem_cache_free(sigqueue_cachep, q);
458 }
459 
460 void flush_sigqueue(struct sigpending *queue)
461 {
462         struct sigqueue *q;
463 
464         sigemptyset(&queue->signal);
465         while (!list_empty(&queue->list)) {
466                 q = list_entry(queue->list.next, struct sigqueue , list);
467                 list_del_init(&q->list);
468                 __sigqueue_free(q);
469         }
470 }
471 
472 /*
473  * Flush all pending signals for this kthread.
474  */
475 void flush_signals(struct task_struct *t)
476 {
477         unsigned long flags;
478 
479         spin_lock_irqsave(&t->sighand->siglock, flags);
480         clear_tsk_thread_flag(t, TIF_SIGPENDING);
481         flush_sigqueue(&t->pending);
482         flush_sigqueue(&t->signal->shared_pending);
483         spin_unlock_irqrestore(&t->sighand->siglock, flags);
484 }
485 EXPORT_SYMBOL(flush_signals);
486 
487 #ifdef CONFIG_POSIX_TIMERS
488 static void __flush_itimer_signals(struct sigpending *pending)
489 {
490         sigset_t signal, retain;
491         struct sigqueue *q, *n;
492 
493         signal = pending->signal;
494         sigemptyset(&retain);
495 
496         list_for_each_entry_safe(q, n, &pending->list, list) {
497                 int sig = q->info.si_signo;
498 
499                 if (likely(q->info.si_code != SI_TIMER)) {
500                         sigaddset(&retain, sig);
501                 } else {
502                         sigdelset(&signal, sig);
503                         list_del_init(&q->list);
504                         __sigqueue_free(q);
505                 }
506         }
507 
508         sigorsets(&pending->signal, &signal, &retain);
509 }
510 
511 void flush_itimer_signals(void)
512 {
513         struct task_struct *tsk = current;
514         unsigned long flags;
515 
516         spin_lock_irqsave(&tsk->sighand->siglock, flags);
517         __flush_itimer_signals(&tsk->pending);
518         __flush_itimer_signals(&tsk->signal->shared_pending);
519         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
520 }
521 #endif
522 
523 void ignore_signals(struct task_struct *t)
524 {
525         int i;
526 
527         for (i = 0; i < _NSIG; ++i)
528                 t->sighand->action[i].sa.sa_handler = SIG_IGN;
529 
530         flush_signals(t);
531 }
532 
533 /*
534  * Flush all handlers for a task.
535  */
536 
537 void
538 flush_signal_handlers(struct task_struct *t, int force_default)
539 {
540         int i;
541         struct k_sigaction *ka = &t->sighand->action[0];
542         for (i = _NSIG ; i != 0 ; i--) {
543                 if (force_default || ka->sa.sa_handler != SIG_IGN)
544                         ka->sa.sa_handler = SIG_DFL;
545                 ka->sa.sa_flags = 0;
546 #ifdef __ARCH_HAS_SA_RESTORER
547                 ka->sa.sa_restorer = NULL;
548 #endif
549                 sigemptyset(&ka->sa.sa_mask);
550                 ka++;
551         }
552 }
553 
554 bool unhandled_signal(struct task_struct *tsk, int sig)
555 {
556         void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
557         if (is_global_init(tsk))
558                 return true;
559 
560         if (handler != SIG_IGN && handler != SIG_DFL)
561                 return false;
562 
563         /* if ptraced, let the tracer determine */
564         return !tsk->ptrace;
565 }
566 
567 static void collect_signal(int sig, struct sigpending *list, kernel_siginfo_t *info,
568                            bool *resched_timer)
569 {
570         struct sigqueue *q, *first = NULL;
571 
572         /*
573          * Collect the siginfo appropriate to this signal.  Check if
574          * there is another siginfo for the same signal.
575         */
576         list_for_each_entry(q, &list->list, list) {
577                 if (q->info.si_signo == sig) {
578                         if (first)
579                                 goto still_pending;
580                         first = q;
581                 }
582         }
583 
584         sigdelset(&list->signal, sig);
585 
586         if (first) {
587 still_pending:
588                 list_del_init(&first->list);
589                 copy_siginfo(info, &first->info);
590 
591                 *resched_timer =
592                         (first->flags & SIGQUEUE_PREALLOC) &&
593                         (info->si_code == SI_TIMER) &&
594                         (info->si_sys_private);
595 
596                 __sigqueue_free(first);
597         } else {
598                 /*
599                  * Ok, it wasn't in the queue.  This must be
600                  * a fast-pathed signal or we must have been
601                  * out of queue space.  So zero out the info.
602                  */
603                 clear_siginfo(info);
604                 info->si_signo = sig;
605                 info->si_errno = 0;
606                 info->si_code = SI_USER;
607                 info->si_pid = 0;
608                 info->si_uid = 0;
609         }
610 }
611 
612 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
613                         kernel_siginfo_t *info, bool *resched_timer)
614 {
615         int sig = next_signal(pending, mask);
616 
617         if (sig)
618                 collect_signal(sig, pending, info, resched_timer);
619         return sig;
620 }
621 
622 /*
623  * Dequeue a signal and return the element to the caller, which is
624  * expected to free it.
625  *
626  * All callers have to hold the siglock.
627  */
628 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, kernel_siginfo_t *info)
629 {
630         bool resched_timer = false;
631         int signr;
632 
633         /* We only dequeue private signals from ourselves, we don't let
634          * signalfd steal them
635          */
636         signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer);
637         if (!signr) {
638                 signr = __dequeue_signal(&tsk->signal->shared_pending,
639                                          mask, info, &resched_timer);
640 #ifdef CONFIG_POSIX_TIMERS
641                 /*
642                  * itimer signal ?
643                  *
644                  * itimers are process shared and we restart periodic
645                  * itimers in the signal delivery path to prevent DoS
646                  * attacks in the high resolution timer case. This is
647                  * compliant with the old way of self-restarting
648                  * itimers, as the SIGALRM is a legacy signal and only
649                  * queued once. Changing the restart behaviour to
650                  * restart the timer in the signal dequeue path is
651                  * reducing the timer noise on heavy loaded !highres
652                  * systems too.
653                  */
654                 if (unlikely(signr == SIGALRM)) {
655                         struct hrtimer *tmr = &tsk->signal->real_timer;
656 
657                         if (!hrtimer_is_queued(tmr) &&
658                             tsk->signal->it_real_incr != 0) {
659                                 hrtimer_forward(tmr, tmr->base->get_time(),
660                                                 tsk->signal->it_real_incr);
661                                 hrtimer_restart(tmr);
662                         }
663                 }
664 #endif
665         }
666 
667         recalc_sigpending();
668         if (!signr)
669                 return 0;
670 
671         if (unlikely(sig_kernel_stop(signr))) {
672                 /*
673                  * Set a marker that we have dequeued a stop signal.  Our
674                  * caller might release the siglock and then the pending
675                  * stop signal it is about to process is no longer in the
676                  * pending bitmasks, but must still be cleared by a SIGCONT
677                  * (and overruled by a SIGKILL).  So those cases clear this
678                  * shared flag after we've set it.  Note that this flag may
679                  * remain set after the signal we return is ignored or
680                  * handled.  That doesn't matter because its only purpose
681                  * is to alert stop-signal processing code when another
682                  * processor has come along and cleared the flag.
683                  */
684                 current->jobctl |= JOBCTL_STOP_DEQUEUED;
685         }
686 #ifdef CONFIG_POSIX_TIMERS
687         if (resched_timer) {
688                 /*
689                  * Release the siglock to ensure proper locking order
690                  * of timer locks outside of siglocks.  Note, we leave
691                  * irqs disabled here, since the posix-timers code is
692                  * about to disable them again anyway.
693                  */
694                 spin_unlock(&tsk->sighand->siglock);
695                 posixtimer_rearm(info);
696                 spin_lock(&tsk->sighand->siglock);
697 
698                 /* Don't expose the si_sys_private value to userspace */
699                 info->si_sys_private = 0;
700         }
701 #endif
702         return signr;
703 }
704 EXPORT_SYMBOL_GPL(dequeue_signal);
705 
706 static int dequeue_synchronous_signal(kernel_siginfo_t *info)
707 {
708         struct task_struct *tsk = current;
709         struct sigpending *pending = &tsk->pending;
710         struct sigqueue *q, *sync = NULL;
711 
712         /*
713          * Might a synchronous signal be in the queue?
714          */
715         if (!((pending->signal.sig[0] & ~tsk->blocked.sig[0]) & SYNCHRONOUS_MASK))
716                 return 0;
717 
718         /*
719          * Return the first synchronous signal in the queue.
720          */
721         list_for_each_entry(q, &pending->list, list) {
722                 /* Synchronous signals have a postive si_code */
723                 if ((q->info.si_code > SI_USER) &&
724                     (sigmask(q->info.si_signo) & SYNCHRONOUS_MASK)) {
725                         sync = q;
726                         goto next;
727                 }
728         }
729         return 0;
730 next:
731         /*
732          * Check if there is another siginfo for the same signal.
733          */
734         list_for_each_entry_continue(q, &pending->list, list) {
735                 if (q->info.si_signo == sync->info.si_signo)
736                         goto still_pending;
737         }
738 
739         sigdelset(&pending->signal, sync->info.si_signo);
740         recalc_sigpending();
741 still_pending:
742         list_del_init(&sync->list);
743         copy_siginfo(info, &sync->info);
744         __sigqueue_free(sync);
745         return info->si_signo;
746 }
747 
748 /*
749  * Tell a process that it has a new active signal..
750  *
751  * NOTE! we rely on the previous spin_lock to
752  * lock interrupts for us! We can only be called with
753  * "siglock" held, and the local interrupt must
754  * have been disabled when that got acquired!
755  *
756  * No need to set need_resched since signal event passing
757  * goes through ->blocked
758  */
759 void signal_wake_up_state(struct task_struct *t, unsigned int state)
760 {
761         set_tsk_thread_flag(t, TIF_SIGPENDING);
762         /*
763          * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
764          * case. We don't check t->state here because there is a race with it
765          * executing another processor and just now entering stopped state.
766          * By using wake_up_state, we ensure the process will wake up and
767          * handle its death signal.
768          */
769         if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
770                 kick_process(t);
771 }
772 
773 /*
774  * Remove signals in mask from the pending set and queue.
775  * Returns 1 if any signals were found.
776  *
777  * All callers must be holding the siglock.
778  */
779 static void flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
780 {
781         struct sigqueue *q, *n;
782         sigset_t m;
783 
784         sigandsets(&m, mask, &s->signal);
785         if (sigisemptyset(&m))
786                 return;
787 
788         sigandnsets(&s->signal, &s->signal, mask);
789         list_for_each_entry_safe(q, n, &s->list, list) {
790                 if (sigismember(mask, q->info.si_signo)) {
791                         list_del_init(&q->list);
792                         __sigqueue_free(q);
793                 }
794         }
795 }
796 
797 static inline int is_si_special(const struct kernel_siginfo *info)
798 {
799         return info <= SEND_SIG_PRIV;
800 }
801 
802 static inline bool si_fromuser(const struct kernel_siginfo *info)
803 {
804         return info == SEND_SIG_NOINFO ||
805                 (!is_si_special(info) && SI_FROMUSER(info));
806 }
807 
808 /*
809  * called with RCU read lock from check_kill_permission()
810  */
811 static bool kill_ok_by_cred(struct task_struct *t)
812 {
813         const struct cred *cred = current_cred();
814         const struct cred *tcred = __task_cred(t);
815 
816         return uid_eq(cred->euid, tcred->suid) ||
817                uid_eq(cred->euid, tcred->uid) ||
818                uid_eq(cred->uid, tcred->suid) ||
819                uid_eq(cred->uid, tcred->uid) ||
820                ns_capable(tcred->user_ns, CAP_KILL);
821 }
822 
823 /*
824  * Bad permissions for sending the signal
825  * - the caller must hold the RCU read lock
826  */
827 static int check_kill_permission(int sig, struct kernel_siginfo *info,
828                                  struct task_struct *t)
829 {
830         struct pid *sid;
831         int error;
832 
833         if (!valid_signal(sig))
834                 return -EINVAL;
835 
836         if (!si_fromuser(info))
837                 return 0;
838 
839         error = audit_signal_info(sig, t); /* Let audit system see the signal */
840         if (error)
841                 return error;
842 
843         if (!same_thread_group(current, t) &&
844             !kill_ok_by_cred(t)) {
845                 switch (sig) {
846                 case SIGCONT:
847                         sid = task_session(t);
848                         /*
849                          * We don't return the error if sid == NULL. The
850                          * task was unhashed, the caller must notice this.
851                          */
852                         if (!sid || sid == task_session(current))
853                                 break;
854                         /* fall through */
855                 default:
856                         return -EPERM;
857                 }
858         }
859 
860         return security_task_kill(t, info, sig, NULL);
861 }
862 
863 /**
864  * ptrace_trap_notify - schedule trap to notify ptracer
865  * @t: tracee wanting to notify tracer
866  *
867  * This function schedules sticky ptrace trap which is cleared on the next
868  * TRAP_STOP to notify ptracer of an event.  @t must have been seized by
869  * ptracer.
870  *
871  * If @t is running, STOP trap will be taken.  If trapped for STOP and
872  * ptracer is listening for events, tracee is woken up so that it can
873  * re-trap for the new event.  If trapped otherwise, STOP trap will be
874  * eventually taken without returning to userland after the existing traps
875  * are finished by PTRACE_CONT.
876  *
877  * CONTEXT:
878  * Must be called with @task->sighand->siglock held.
879  */
880 static void ptrace_trap_notify(struct task_struct *t)
881 {
882         WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
883         assert_spin_locked(&t->sighand->siglock);
884 
885         task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
886         ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
887 }
888 
889 /*
890  * Handle magic process-wide effects of stop/continue signals. Unlike
891  * the signal actions, these happen immediately at signal-generation
892  * time regardless of blocking, ignoring, or handling.  This does the
893  * actual continuing for SIGCONT, but not the actual stopping for stop
894  * signals. The process stop is done as a signal action for SIG_DFL.
895  *
896  * Returns true if the signal should be actually delivered, otherwise
897  * it should be dropped.
898  */
899 static bool prepare_signal(int sig, struct task_struct *p, bool force)
900 {
901         struct signal_struct *signal = p->signal;
902         struct task_struct *t;
903         sigset_t flush;
904 
905         if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
906                 if (!(signal->flags & SIGNAL_GROUP_EXIT))
907                         return sig == SIGKILL;
908                 /*
909                  * The process is in the middle of dying, nothing to do.
910                  */
911         } else if (sig_kernel_stop(sig)) {
912                 /*
913                  * This is a stop signal.  Remove SIGCONT from all queues.
914                  */
915                 siginitset(&flush, sigmask(SIGCONT));
916                 flush_sigqueue_mask(&flush, &signal->shared_pending);
917                 for_each_thread(p, t)
918                         flush_sigqueue_mask(&flush, &t->pending);
919         } else if (sig == SIGCONT) {
920                 unsigned int why;
921                 /*
922                  * Remove all stop signals from all queues, wake all threads.
923                  */
924                 siginitset(&flush, SIG_KERNEL_STOP_MASK);
925                 flush_sigqueue_mask(&flush, &signal->shared_pending);
926                 for_each_thread(p, t) {
927                         flush_sigqueue_mask(&flush, &t->pending);
928                         task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
929                         if (likely(!(t->ptrace & PT_SEIZED)))
930                                 wake_up_state(t, __TASK_STOPPED);
931                         else
932                                 ptrace_trap_notify(t);
933                 }
934 
935                 /*
936                  * Notify the parent with CLD_CONTINUED if we were stopped.
937                  *
938                  * If we were in the middle of a group stop, we pretend it
939                  * was already finished, and then continued. Since SIGCHLD
940                  * doesn't queue we report only CLD_STOPPED, as if the next
941                  * CLD_CONTINUED was dropped.
942                  */
943                 why = 0;
944                 if (signal->flags & SIGNAL_STOP_STOPPED)
945                         why |= SIGNAL_CLD_CONTINUED;
946                 else if (signal->group_stop_count)
947                         why |= SIGNAL_CLD_STOPPED;
948 
949                 if (why) {
950                         /*
951                          * The first thread which returns from do_signal_stop()
952                          * will take ->siglock, notice SIGNAL_CLD_MASK, and
953                          * notify its parent. See get_signal().
954                          */
955                         signal_set_stop_flags(signal, why | SIGNAL_STOP_CONTINUED);
956                         signal->group_stop_count = 0;
957                         signal->group_exit_code = 0;
958                 }
959         }
960 
961         return !sig_ignored(p, sig, force);
962 }
963 
964 /*
965  * Test if P wants to take SIG.  After we've checked all threads with this,
966  * it's equivalent to finding no threads not blocking SIG.  Any threads not
967  * blocking SIG were ruled out because they are not running and already
968  * have pending signals.  Such threads will dequeue from the shared queue
969  * as soon as they're available, so putting the signal on the shared queue
970  * will be equivalent to sending it to one such thread.
971  */
972 static inline bool wants_signal(int sig, struct task_struct *p)
973 {
974         if (sigismember(&p->blocked, sig))
975                 return false;
976 
977         if (p->flags & PF_EXITING)
978                 return false;
979 
980         if (sig == SIGKILL)
981                 return true;
982 
983         if (task_is_stopped_or_traced(p))
984                 return false;
985 
986         return task_curr(p) || !signal_pending(p);
987 }
988 
989 static void complete_signal(int sig, struct task_struct *p, enum pid_type type)
990 {
991         struct signal_struct *signal = p->signal;
992         struct task_struct *t;
993 
994         /*
995          * Now find a thread we can wake up to take the signal off the queue.
996          *
997          * If the main thread wants the signal, it gets first crack.
998          * Probably the least surprising to the average bear.
999          */
1000         if (wants_signal(sig, p))
1001                 t = p;
1002         else if ((type == PIDTYPE_PID) || thread_group_empty(p))
1003                 /*
1004                  * There is just one thread and it does not need to be woken.
1005                  * It will dequeue unblocked signals before it runs again.
1006                  */
1007                 return;
1008         else {
1009                 /*
1010                  * Otherwise try to find a suitable thread.
1011                  */
1012                 t = signal->curr_target;
1013                 while (!wants_signal(sig, t)) {
1014                         t = next_thread(t);
1015                         if (t == signal->curr_target)
1016                                 /*
1017                                  * No thread needs to be woken.
1018                                  * Any eligible threads will see
1019                                  * the signal in the queue soon.
1020                                  */
1021                                 return;
1022                 }
1023                 signal->curr_target = t;
1024         }
1025 
1026         /*
1027          * Found a killable thread.  If the signal will be fatal,
1028          * then start taking the whole group down immediately.
1029          */
1030         if (sig_fatal(p, sig) &&
1031             !(signal->flags & SIGNAL_GROUP_EXIT) &&
1032             !sigismember(&t->real_blocked, sig) &&
1033             (sig == SIGKILL || !p->ptrace)) {
1034                 /*
1035                  * This signal will be fatal to the whole group.
1036                  */
1037                 if (!sig_kernel_coredump(sig)) {
1038                         /*
1039                          * Start a group exit and wake everybody up.
1040                          * This way we don't have other threads
1041                          * running and doing things after a slower
1042                          * thread has the fatal signal pending.
1043                          */
1044                         signal->flags = SIGNAL_GROUP_EXIT;
1045                         signal->group_exit_code = sig;
1046                         signal->group_stop_count = 0;
1047                         t = p;
1048                         do {
1049                                 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1050                                 sigaddset(&t->pending.signal, SIGKILL);
1051                                 signal_wake_up(t, 1);
1052                         } while_each_thread(p, t);
1053                         return;
1054                 }
1055         }
1056 
1057         /*
1058          * The signal is already in the shared-pending queue.
1059          * Tell the chosen thread to wake up and dequeue it.
1060          */
1061         signal_wake_up(t, sig == SIGKILL);
1062         return;
1063 }
1064 
1065 static inline bool legacy_queue(struct sigpending *signals, int sig)
1066 {
1067         return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
1068 }
1069 
1070 static int __send_signal(int sig, struct kernel_siginfo *info, struct task_struct *t,
1071                         enum pid_type type, bool force)
1072 {
1073         struct sigpending *pending;
1074         struct sigqueue *q;
1075         int override_rlimit;
1076         int ret = 0, result;
1077 
1078         assert_spin_locked(&t->sighand->siglock);
1079 
1080         result = TRACE_SIGNAL_IGNORED;
1081         if (!prepare_signal(sig, t, force))
1082                 goto ret;
1083 
1084         pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending;
1085         /*
1086          * Short-circuit ignored signals and support queuing
1087          * exactly one non-rt signal, so that we can get more
1088          * detailed information about the cause of the signal.
1089          */
1090         result = TRACE_SIGNAL_ALREADY_PENDING;
1091         if (legacy_queue(pending, sig))
1092                 goto ret;
1093 
1094         result = TRACE_SIGNAL_DELIVERED;
1095         /*
1096          * Skip useless siginfo allocation for SIGKILL and kernel threads.
1097          */
1098         if ((sig == SIGKILL) || (t->flags & PF_KTHREAD))
1099                 goto out_set;
1100 
1101         /*
1102          * Real-time signals must be queued if sent by sigqueue, or
1103          * some other real-time mechanism.  It is implementation
1104          * defined whether kill() does so.  We attempt to do so, on
1105          * the principle of least surprise, but since kill is not
1106          * allowed to fail with EAGAIN when low on memory we just
1107          * make sure at least one signal gets delivered and don't
1108          * pass on the info struct.
1109          */
1110         if (sig < SIGRTMIN)
1111                 override_rlimit = (is_si_special(info) || info->si_code >= 0);
1112         else
1113                 override_rlimit = 0;
1114 
1115         q = __sigqueue_alloc(sig, t, GFP_ATOMIC, override_rlimit);
1116         if (q) {
1117                 list_add_tail(&q->list, &pending->list);
1118                 switch ((unsigned long) info) {
1119                 case (unsigned long) SEND_SIG_NOINFO:
1120                         clear_siginfo(&q->info);
1121                         q->info.si_signo = sig;
1122                         q->info.si_errno = 0;
1123                         q->info.si_code = SI_USER;
1124                         q->info.si_pid = task_tgid_nr_ns(current,
1125                                                         task_active_pid_ns(t));
1126                         rcu_read_lock();
1127                         q->info.si_uid =
1128                                 from_kuid_munged(task_cred_xxx(t, user_ns),
1129                                                  current_uid());
1130                         rcu_read_unlock();
1131                         break;
1132                 case (unsigned long) SEND_SIG_PRIV:
1133                         clear_siginfo(&q->info);
1134                         q->info.si_signo = sig;
1135                         q->info.si_errno = 0;
1136                         q->info.si_code = SI_KERNEL;
1137                         q->info.si_pid = 0;
1138                         q->info.si_uid = 0;
1139                         break;
1140                 default:
1141                         copy_siginfo(&q->info, info);
1142                         break;
1143                 }
1144         } else if (!is_si_special(info) &&
1145                    sig >= SIGRTMIN && info->si_code != SI_USER) {
1146                 /*
1147                  * Queue overflow, abort.  We may abort if the
1148                  * signal was rt and sent by user using something
1149                  * other than kill().
1150                  */
1151                 result = TRACE_SIGNAL_OVERFLOW_FAIL;
1152                 ret = -EAGAIN;
1153                 goto ret;
1154         } else {
1155                 /*
1156                  * This is a silent loss of information.  We still
1157                  * send the signal, but the *info bits are lost.
1158                  */
1159                 result = TRACE_SIGNAL_LOSE_INFO;
1160         }
1161 
1162 out_set:
1163         signalfd_notify(t, sig);
1164         sigaddset(&pending->signal, sig);
1165 
1166         /* Let multiprocess signals appear after on-going forks */
1167         if (type > PIDTYPE_TGID) {
1168                 struct multiprocess_signals *delayed;
1169                 hlist_for_each_entry(delayed, &t->signal->multiprocess, node) {
1170                         sigset_t *signal = &delayed->signal;
1171                         /* Can't queue both a stop and a continue signal */
1172                         if (sig == SIGCONT)
1173                                 sigdelsetmask(signal, SIG_KERNEL_STOP_MASK);
1174                         else if (sig_kernel_stop(sig))
1175                                 sigdelset(signal, SIGCONT);
1176                         sigaddset(signal, sig);
1177                 }
1178         }
1179 
1180         complete_signal(sig, t, type);
1181 ret:
1182         trace_signal_generate(sig, info, t, type != PIDTYPE_PID, result);
1183         return ret;
1184 }
1185 
1186 static inline bool has_si_pid_and_uid(struct kernel_siginfo *info)
1187 {
1188         bool ret = false;
1189         switch (siginfo_layout(info->si_signo, info->si_code)) {
1190         case SIL_KILL:
1191         case SIL_CHLD:
1192         case SIL_RT:
1193                 ret = true;
1194                 break;
1195         case SIL_TIMER:
1196         case SIL_POLL:
1197         case SIL_FAULT:
1198         case SIL_FAULT_MCEERR:
1199         case SIL_FAULT_BNDERR:
1200         case SIL_FAULT_PKUERR:
1201         case SIL_SYS:
1202                 ret = false;
1203                 break;
1204         }
1205         return ret;
1206 }
1207 
1208 static int send_signal(int sig, struct kernel_siginfo *info, struct task_struct *t,
1209                         enum pid_type type)
1210 {
1211         /* Should SIGKILL or SIGSTOP be received by a pid namespace init? */
1212         bool force = false;
1213 
1214         if (info == SEND_SIG_NOINFO) {
1215                 /* Force if sent from an ancestor pid namespace */
1216                 force = !task_pid_nr_ns(current, task_active_pid_ns(t));
1217         } else if (info == SEND_SIG_PRIV) {
1218                 /* Don't ignore kernel generated signals */
1219                 force = true;
1220         } else if (has_si_pid_and_uid(info)) {
1221                 /* SIGKILL and SIGSTOP is special or has ids */
1222                 struct user_namespace *t_user_ns;
1223 
1224                 rcu_read_lock();
1225                 t_user_ns = task_cred_xxx(t, user_ns);
1226                 if (current_user_ns() != t_user_ns) {
1227                         kuid_t uid = make_kuid(current_user_ns(), info->si_uid);
1228                         info->si_uid = from_kuid_munged(t_user_ns, uid);
1229                 }
1230                 rcu_read_unlock();
1231 
1232                 /* A kernel generated signal? */
1233                 force = (info->si_code == SI_KERNEL);
1234 
1235                 /* From an ancestor pid namespace? */
1236                 if (!task_pid_nr_ns(current, task_active_pid_ns(t))) {
1237                         info->si_pid = 0;
1238                         force = true;
1239                 }
1240         }
1241         return __send_signal(sig, info, t, type, force);
1242 }
1243 
1244 static void print_fatal_signal(int signr)
1245 {
1246         struct pt_regs *regs = signal_pt_regs();
1247         pr_info("potentially unexpected fatal signal %d.\n", signr);
1248 
1249 #if defined(__i386__) && !defined(__arch_um__)
1250         pr_info("code at %08lx: ", regs->ip);
1251         {
1252                 int i;
1253                 for (i = 0; i < 16; i++) {
1254                         unsigned char insn;
1255 
1256                         if (get_user(insn, (unsigned char *)(regs->ip + i)))
1257                                 break;
1258                         pr_cont("%02x ", insn);
1259                 }
1260         }
1261         pr_cont("\n");
1262 #endif
1263         preempt_disable();
1264         show_regs(regs);
1265         preempt_enable();
1266 }
1267 
1268 static int __init setup_print_fatal_signals(char *str)
1269 {
1270         get_option (&str, &print_fatal_signals);
1271 
1272         return 1;
1273 }
1274 
1275 __setup("print-fatal-signals=", setup_print_fatal_signals);
1276 
1277 int
1278 __group_send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p)
1279 {
1280         return send_signal(sig, info, p, PIDTYPE_TGID);
1281 }
1282 
1283 int do_send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p,
1284                         enum pid_type type)
1285 {
1286         unsigned long flags;
1287         int ret = -ESRCH;
1288 
1289         if (lock_task_sighand(p, &flags)) {
1290                 ret = send_signal(sig, info, p, type);
1291                 unlock_task_sighand(p, &flags);
1292         }
1293 
1294         return ret;
1295 }
1296 
1297 /*
1298  * Force a signal that the process can't ignore: if necessary
1299  * we unblock the signal and change any SIG_IGN to SIG_DFL.
1300  *
1301  * Note: If we unblock the signal, we always reset it to SIG_DFL,
1302  * since we do not want to have a signal handler that was blocked
1303  * be invoked when user space had explicitly blocked it.
1304  *
1305  * We don't want to have recursive SIGSEGV's etc, for example,
1306  * that is why we also clear SIGNAL_UNKILLABLE.
1307  */
1308 static int
1309 force_sig_info_to_task(struct kernel_siginfo *info, struct task_struct *t)
1310 {
1311         unsigned long int flags;
1312         int ret, blocked, ignored;
1313         struct k_sigaction *action;
1314         int sig = info->si_signo;
1315 
1316         spin_lock_irqsave(&t->sighand->siglock, flags);
1317         action = &t->sighand->action[sig-1];
1318         ignored = action->sa.sa_handler == SIG_IGN;
1319         blocked = sigismember(&t->blocked, sig);
1320         if (blocked || ignored) {
1321                 action->sa.sa_handler = SIG_DFL;
1322                 if (blocked) {
1323                         sigdelset(&t->blocked, sig);
1324                         recalc_sigpending_and_wake(t);
1325                 }
1326         }
1327         /*
1328          * Don't clear SIGNAL_UNKILLABLE for traced tasks, users won't expect
1329          * debugging to leave init killable.
1330          */
1331         if (action->sa.sa_handler == SIG_DFL && !t->ptrace)
1332                 t->signal->flags &= ~SIGNAL_UNKILLABLE;
1333         ret = send_signal(sig, info, t, PIDTYPE_PID);
1334         spin_unlock_irqrestore(&t->sighand->siglock, flags);
1335 
1336         return ret;
1337 }
1338 
1339 int force_sig_info(struct kernel_siginfo *info)
1340 {
1341         return force_sig_info_to_task(info, current);
1342 }
1343 
1344 /*
1345  * Nuke all other threads in the group.
1346  */
1347 int zap_other_threads(struct task_struct *p)
1348 {
1349         struct task_struct *t = p;
1350         int count = 0;
1351 
1352         p->signal->group_stop_count = 0;
1353 
1354         while_each_thread(p, t) {
1355                 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1356                 count++;
1357 
1358                 /* Don't bother with already dead threads */
1359                 if (t->exit_state)
1360                         continue;
1361                 sigaddset(&t->pending.signal, SIGKILL);
1362                 signal_wake_up(t, 1);
1363         }
1364 
1365         return count;
1366 }
1367 
1368 struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1369                                            unsigned long *flags)
1370 {
1371         struct sighand_struct *sighand;
1372 
1373         rcu_read_lock();
1374         for (;;) {
1375                 sighand = rcu_dereference(tsk->sighand);
1376                 if (unlikely(sighand == NULL))
1377                         break;
1378 
1379                 /*
1380                  * This sighand can be already freed and even reused, but
1381                  * we rely on SLAB_TYPESAFE_BY_RCU and sighand_ctor() which
1382                  * initializes ->siglock: this slab can't go away, it has
1383                  * the same object type, ->siglock can't be reinitialized.
1384                  *
1385                  * We need to ensure that tsk->sighand is still the same
1386                  * after we take the lock, we can race with de_thread() or
1387                  * __exit_signal(). In the latter case the next iteration
1388                  * must see ->sighand == NULL.
1389                  */
1390                 spin_lock_irqsave(&sighand->siglock, *flags);
1391                 if (likely(sighand == rcu_access_pointer(tsk->sighand)))
1392                         break;
1393                 spin_unlock_irqrestore(&sighand->siglock, *flags);
1394         }
1395         rcu_read_unlock();
1396 
1397         return sighand;
1398 }
1399 
1400 /*
1401  * send signal info to all the members of a group
1402  */
1403 int group_send_sig_info(int sig, struct kernel_siginfo *info,
1404                         struct task_struct *p, enum pid_type type)
1405 {
1406         int ret;
1407 
1408         rcu_read_lock();
1409         ret = check_kill_permission(sig, info, p);
1410         rcu_read_unlock();
1411 
1412         if (!ret && sig)
1413                 ret = do_send_sig_info(sig, info, p, type);
1414 
1415         return ret;
1416 }
1417 
1418 /*
1419  * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1420  * control characters do (^C, ^Z etc)
1421  * - the caller must hold at least a readlock on tasklist_lock
1422  */
1423 int __kill_pgrp_info(int sig, struct kernel_siginfo *info, struct pid *pgrp)
1424 {
1425         struct task_struct *p = NULL;
1426         int retval, success;
1427 
1428         success = 0;
1429         retval = -ESRCH;
1430         do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1431                 int err = group_send_sig_info(sig, info, p, PIDTYPE_PGID);
1432                 success |= !err;
1433                 retval = err;
1434         } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1435         return success ? 0 : retval;
1436 }
1437 
1438 int kill_pid_info(int sig, struct kernel_siginfo *info, struct pid *pid)
1439 {
1440         int error = -ESRCH;
1441         struct task_struct *p;
1442 
1443         for (;;) {
1444                 rcu_read_lock();
1445                 p = pid_task(pid, PIDTYPE_PID);
1446                 if (p)
1447                         error = group_send_sig_info(sig, info, p, PIDTYPE_TGID);
1448                 rcu_read_unlock();
1449                 if (likely(!p || error != -ESRCH))
1450                         return error;
1451 
1452                 /*
1453                  * The task was unhashed in between, try again.  If it
1454                  * is dead, pid_task() will return NULL, if we race with
1455                  * de_thread() it will find the new leader.
1456                  */
1457         }
1458 }
1459 
1460 static int kill_proc_info(int sig, struct kernel_siginfo *info, pid_t pid)
1461 {
1462         int error;
1463         rcu_read_lock();
1464         error = kill_pid_info(sig, info, find_vpid(pid));
1465         rcu_read_unlock();
1466         return error;
1467 }
1468 
1469 static inline bool kill_as_cred_perm(const struct cred *cred,
1470                                      struct task_struct *target)
1471 {
1472         const struct cred *pcred = __task_cred(target);
1473 
1474         return uid_eq(cred->euid, pcred->suid) ||
1475                uid_eq(cred->euid, pcred->uid) ||
1476                uid_eq(cred->uid, pcred->suid) ||
1477                uid_eq(cred->uid, pcred->uid);
1478 }
1479 
1480 /*
1481  * The usb asyncio usage of siginfo is wrong.  The glibc support
1482  * for asyncio which uses SI_ASYNCIO assumes the layout is SIL_RT.
1483  * AKA after the generic fields:
1484  *      kernel_pid_t    si_pid;
1485  *      kernel_uid32_t  si_uid;
1486  *      sigval_t        si_value;
1487  *
1488  * Unfortunately when usb generates SI_ASYNCIO it assumes the layout
1489  * after the generic fields is:
1490  *      void __user     *si_addr;
1491  *
1492  * This is a practical problem when there is a 64bit big endian kernel
1493  * and a 32bit userspace.  As the 32bit address will encoded in the low
1494  * 32bits of the pointer.  Those low 32bits will be stored at higher
1495  * address than appear in a 32 bit pointer.  So userspace will not
1496  * see the address it was expecting for it's completions.
1497  *
1498  * There is nothing in the encoding that can allow
1499  * copy_siginfo_to_user32 to detect this confusion of formats, so
1500  * handle this by requiring the caller of kill_pid_usb_asyncio to
1501  * notice when this situration takes place and to store the 32bit
1502  * pointer in sival_int, instead of sival_addr of the sigval_t addr
1503  * parameter.
1504  */
1505 int kill_pid_usb_asyncio(int sig, int errno, sigval_t addr,
1506                          struct pid *pid, const struct cred *cred)
1507 {
1508         struct kernel_siginfo info;
1509         struct task_struct *p;
1510         unsigned long flags;
1511         int ret = -EINVAL;
1512 
1513         if (!valid_signal(sig))
1514                 return ret;
1515 
1516         clear_siginfo(&info);
1517         info.si_signo = sig;
1518         info.si_errno = errno;
1519         info.si_code = SI_ASYNCIO;
1520         *((sigval_t *)&info.si_pid) = addr;
1521 
1522         rcu_read_lock();
1523         p = pid_task(pid, PIDTYPE_PID);
1524         if (!p) {
1525                 ret = -ESRCH;
1526                 goto out_unlock;
1527         }
1528         if (!kill_as_cred_perm(cred, p)) {
1529                 ret = -EPERM;
1530                 goto out_unlock;
1531         }
1532         ret = security_task_kill(p, &info, sig, cred);
1533         if (ret)
1534                 goto out_unlock;
1535 
1536         if (sig) {
1537                 if (lock_task_sighand(p, &flags)) {
1538                         ret = __send_signal(sig, &info, p, PIDTYPE_TGID, false);
1539                         unlock_task_sighand(p, &flags);
1540                 } else
1541                         ret = -ESRCH;
1542         }
1543 out_unlock:
1544         rcu_read_unlock();
1545         return ret;
1546 }
1547 EXPORT_SYMBOL_GPL(kill_pid_usb_asyncio);
1548 
1549 /*
1550  * kill_something_info() interprets pid in interesting ways just like kill(2).
1551  *
1552  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1553  * is probably wrong.  Should make it like BSD or SYSV.
1554  */
1555 
1556 static int kill_something_info(int sig, struct kernel_siginfo *info, pid_t pid)
1557 {
1558         int ret;
1559 
1560         if (pid > 0) {
1561                 rcu_read_lock();
1562                 ret = kill_pid_info(sig, info, find_vpid(pid));
1563                 rcu_read_unlock();
1564                 return ret;
1565         }
1566 
1567         /* -INT_MIN is undefined.  Exclude this case to avoid a UBSAN warning */
1568         if (pid == INT_MIN)
1569                 return -ESRCH;
1570 
1571         read_lock(&tasklist_lock);
1572         if (pid != -1) {
1573                 ret = __kill_pgrp_info(sig, info,
1574                                 pid ? find_vpid(-pid) : task_pgrp(current));
1575         } else {
1576                 int retval = 0, count = 0;
1577                 struct task_struct * p;
1578 
1579                 for_each_process(p) {
1580                         if (task_pid_vnr(p) > 1 &&
1581                                         !same_thread_group(p, current)) {
1582                                 int err = group_send_sig_info(sig, info, p,
1583                                                               PIDTYPE_MAX);
1584                                 ++count;
1585                                 if (err != -EPERM)
1586                                         retval = err;
1587                         }
1588                 }
1589                 ret = count ? retval : -ESRCH;
1590         }
1591         read_unlock(&tasklist_lock);
1592 
1593         return ret;
1594 }
1595 
1596 /*
1597  * These are for backward compatibility with the rest of the kernel source.
1598  */
1599 
1600 int send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p)
1601 {
1602         /*
1603          * Make sure legacy kernel users don't send in bad values
1604          * (normal paths check this in check_kill_permission).
1605          */
1606         if (!valid_signal(sig))
1607                 return -EINVAL;
1608 
1609         return do_send_sig_info(sig, info, p, PIDTYPE_PID);
1610 }
1611 EXPORT_SYMBOL(send_sig_info);
1612 
1613 #define __si_special(priv) \
1614         ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1615 
1616 int
1617 send_sig(int sig, struct task_struct *p, int priv)
1618 {
1619         return send_sig_info(sig, __si_special(priv), p);
1620 }
1621 EXPORT_SYMBOL(send_sig);
1622 
1623 void force_sig(int sig)
1624 {
1625         struct kernel_siginfo info;
1626 
1627         clear_siginfo(&info);
1628         info.si_signo = sig;
1629         info.si_errno = 0;
1630         info.si_code = SI_KERNEL;
1631         info.si_pid = 0;
1632         info.si_uid = 0;
1633         force_sig_info(&info);
1634 }
1635 EXPORT_SYMBOL(force_sig);
1636 
1637 /*
1638  * When things go south during signal handling, we
1639  * will force a SIGSEGV. And if the signal that caused
1640  * the problem was already a SIGSEGV, we'll want to
1641  * make sure we don't even try to deliver the signal..
1642  */
1643 void force_sigsegv(int sig)
1644 {
1645         struct task_struct *p = current;
1646 
1647         if (sig == SIGSEGV) {
1648                 unsigned long flags;
1649                 spin_lock_irqsave(&p->sighand->siglock, flags);
1650                 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1651                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1652         }
1653         force_sig(SIGSEGV);
1654 }
1655 
1656 int force_sig_fault_to_task(int sig, int code, void __user *addr
1657         ___ARCH_SI_TRAPNO(int trapno)
1658         ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
1659         , struct task_struct *t)
1660 {
1661         struct kernel_siginfo info;
1662 
1663         clear_siginfo(&info);
1664         info.si_signo = sig;
1665         info.si_errno = 0;
1666         info.si_code  = code;
1667         info.si_addr  = addr;
1668 #ifdef __ARCH_SI_TRAPNO
1669         info.si_trapno = trapno;
1670 #endif
1671 #ifdef __ia64__
1672         info.si_imm = imm;
1673         info.si_flags = flags;
1674         info.si_isr = isr;
1675 #endif
1676         return force_sig_info_to_task(&info, t);
1677 }
1678 
1679 int force_sig_fault(int sig, int code, void __user *addr
1680         ___ARCH_SI_TRAPNO(int trapno)
1681         ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr))
1682 {
1683         return force_sig_fault_to_task(sig, code, addr
1684                                        ___ARCH_SI_TRAPNO(trapno)
1685                                        ___ARCH_SI_IA64(imm, flags, isr), current);
1686 }
1687 
1688 int send_sig_fault(int sig, int code, void __user *addr
1689         ___ARCH_SI_TRAPNO(int trapno)
1690         ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
1691         , struct task_struct *t)
1692 {
1693         struct kernel_siginfo info;
1694 
1695         clear_siginfo(&info);
1696         info.si_signo = sig;
1697         info.si_errno = 0;
1698         info.si_code  = code;
1699         info.si_addr  = addr;
1700 #ifdef __ARCH_SI_TRAPNO
1701         info.si_trapno = trapno;
1702 #endif
1703 #ifdef __ia64__
1704         info.si_imm = imm;
1705         info.si_flags = flags;
1706         info.si_isr = isr;
1707 #endif
1708         return send_sig_info(info.si_signo, &info, t);
1709 }
1710 
1711 int force_sig_mceerr(int code, void __user *addr, short lsb)
1712 {
1713         struct kernel_siginfo info;
1714 
1715         WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
1716         clear_siginfo(&info);
1717         info.si_signo = SIGBUS;
1718         info.si_errno = 0;
1719         info.si_code = code;
1720         info.si_addr = addr;
1721         info.si_addr_lsb = lsb;
1722         return force_sig_info(&info);
1723 }
1724 
1725 int send_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct *t)
1726 {
1727         struct kernel_siginfo info;
1728 
1729         WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
1730         clear_siginfo(&info);
1731         info.si_signo = SIGBUS;
1732         info.si_errno = 0;
1733         info.si_code = code;
1734         info.si_addr = addr;
1735         info.si_addr_lsb = lsb;
1736         return send_sig_info(info.si_signo, &info, t);
1737 }
1738 EXPORT_SYMBOL(send_sig_mceerr);
1739 
1740 int force_sig_bnderr(void __user *addr, void __user *lower, void __user *upper)
1741 {
1742         struct kernel_siginfo info;
1743 
1744         clear_siginfo(&info);
1745         info.si_signo = SIGSEGV;
1746         info.si_errno = 0;
1747         info.si_code  = SEGV_BNDERR;
1748         info.si_addr  = addr;
1749         info.si_lower = lower;
1750         info.si_upper = upper;
1751         return force_sig_info(&info);
1752 }
1753 
1754 #ifdef SEGV_PKUERR
1755 int force_sig_pkuerr(void __user *addr, u32 pkey)
1756 {
1757         struct kernel_siginfo info;
1758 
1759         clear_siginfo(&info);
1760         info.si_signo = SIGSEGV;
1761         info.si_errno = 0;
1762         info.si_code  = SEGV_PKUERR;
1763         info.si_addr  = addr;
1764         info.si_pkey  = pkey;
1765         return force_sig_info(&info);
1766 }
1767 #endif
1768 
1769 /* For the crazy architectures that include trap information in
1770  * the errno field, instead of an actual errno value.
1771  */
1772 int force_sig_ptrace_errno_trap(int errno, void __user *addr)
1773 {
1774         struct kernel_siginfo info;
1775 
1776         clear_siginfo(&info);
1777         info.si_signo = SIGTRAP;
1778         info.si_errno = errno;
1779         info.si_code  = TRAP_HWBKPT;
1780         info.si_addr  = addr;
1781         return force_sig_info(&info);
1782 }
1783 
1784 int kill_pgrp(struct pid *pid, int sig, int priv)
1785 {
1786         int ret;
1787 
1788         read_lock(&tasklist_lock);
1789         ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1790         read_unlock(&tasklist_lock);
1791 
1792         return ret;
1793 }
1794 EXPORT_SYMBOL(kill_pgrp);
1795 
1796 int kill_pid(struct pid *pid, int sig, int priv)
1797 {
1798         return kill_pid_info(sig, __si_special(priv), pid);
1799 }
1800 EXPORT_SYMBOL(kill_pid);
1801 
1802 /*
1803  * These functions support sending signals using preallocated sigqueue
1804  * structures.  This is needed "because realtime applications cannot
1805  * afford to lose notifications of asynchronous events, like timer
1806  * expirations or I/O completions".  In the case of POSIX Timers
1807  * we allocate the sigqueue structure from the timer_create.  If this
1808  * allocation fails we are able to report the failure to the application
1809  * with an EAGAIN error.
1810  */
1811 struct sigqueue *sigqueue_alloc(void)
1812 {
1813         struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
1814 
1815         if (q)
1816                 q->flags |= SIGQUEUE_PREALLOC;
1817 
1818         return q;
1819 }
1820 
1821 void sigqueue_free(struct sigqueue *q)
1822 {
1823         unsigned long flags;
1824         spinlock_t *lock = &current->sighand->siglock;
1825 
1826         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1827         /*
1828          * We must hold ->siglock while testing q->list
1829          * to serialize with collect_signal() or with
1830          * __exit_signal()->flush_sigqueue().
1831          */
1832         spin_lock_irqsave(lock, flags);
1833         q->flags &= ~SIGQUEUE_PREALLOC;
1834         /*
1835          * If it is queued it will be freed when dequeued,
1836          * like the "regular" sigqueue.
1837          */
1838         if (!list_empty(&q->list))
1839                 q = NULL;
1840         spin_unlock_irqrestore(lock, flags);
1841 
1842         if (q)
1843                 __sigqueue_free(q);
1844 }
1845 
1846 int send_sigqueue(struct sigqueue *q, struct pid *pid, enum pid_type type)
1847 {
1848         int sig = q->info.si_signo;
1849         struct sigpending *pending;
1850         struct task_struct *t;
1851         unsigned long flags;
1852         int ret, result;
1853 
1854         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1855 
1856         ret = -1;
1857         rcu_read_lock();
1858         t = pid_task(pid, type);
1859         if (!t || !likely(lock_task_sighand(t, &flags)))
1860                 goto ret;
1861 
1862         ret = 1; /* the signal is ignored */
1863         result = TRACE_SIGNAL_IGNORED;
1864         if (!prepare_signal(sig, t, false))
1865                 goto out;
1866 
1867         ret = 0;
1868         if (unlikely(!list_empty(&q->list))) {
1869                 /*
1870                  * If an SI_TIMER entry is already queue just increment
1871                  * the overrun count.
1872                  */
1873                 BUG_ON(q->info.si_code != SI_TIMER);
1874                 q->info.si_overrun++;
1875                 result = TRACE_SIGNAL_ALREADY_PENDING;
1876                 goto out;
1877         }
1878         q->info.si_overrun = 0;
1879 
1880         signalfd_notify(t, sig);
1881         pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending;
1882         list_add_tail(&q->list, &pending->list);
1883         sigaddset(&pending->signal, sig);
1884         complete_signal(sig, t, type);
1885         result = TRACE_SIGNAL_DELIVERED;
1886 out:
1887         trace_signal_generate(sig, &q->info, t, type != PIDTYPE_PID, result);
1888         unlock_task_sighand(t, &flags);
1889 ret:
1890         rcu_read_unlock();
1891         return ret;
1892 }
1893 
1894 static void do_notify_pidfd(struct task_struct *task)
1895 {
1896         struct pid *pid;
1897 
1898         WARN_ON(task->exit_state == 0);
1899         pid = task_pid(task);
1900         wake_up_all(&pid->wait_pidfd);
1901 }
1902 
1903 /*
1904  * Let a parent know about the death of a child.
1905  * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1906  *
1907  * Returns true if our parent ignored us and so we've switched to
1908  * self-reaping.
1909  */
1910 bool do_notify_parent(struct task_struct *tsk, int sig)
1911 {
1912         struct kernel_siginfo info;
1913         unsigned long flags;
1914         struct sighand_struct *psig;
1915         bool autoreap = false;
1916         u64 utime, stime;
1917 
1918         BUG_ON(sig == -1);
1919 
1920         /* do_notify_parent_cldstop should have been called instead.  */
1921         BUG_ON(task_is_stopped_or_traced(tsk));
1922 
1923         BUG_ON(!tsk->ptrace &&
1924                (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1925 
1926         /* Wake up all pidfd waiters */
1927         do_notify_pidfd(tsk);
1928 
1929         if (sig != SIGCHLD) {
1930                 /*
1931                  * This is only possible if parent == real_parent.
1932                  * Check if it has changed security domain.
1933                  */
1934                 if (tsk->parent_exec_id != READ_ONCE(tsk->parent->self_exec_id))
1935                         sig = SIGCHLD;
1936         }
1937 
1938         clear_siginfo(&info);
1939         info.si_signo = sig;
1940         info.si_errno = 0;
1941         /*
1942          * We are under tasklist_lock here so our parent is tied to
1943          * us and cannot change.
1944          *
1945          * task_active_pid_ns will always return the same pid namespace
1946          * until a task passes through release_task.
1947          *
1948          * write_lock() currently calls preempt_disable() which is the
1949          * same as rcu_read_lock(), but according to Oleg, this is not
1950          * correct to rely on this
1951          */
1952         rcu_read_lock();
1953         info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1954         info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
1955                                        task_uid(tsk));
1956         rcu_read_unlock();
1957 
1958         task_cputime(tsk, &utime, &stime);
1959         info.si_utime = nsec_to_clock_t(utime + tsk->signal->utime);
1960         info.si_stime = nsec_to_clock_t(stime + tsk->signal->stime);
1961 
1962         info.si_status = tsk->exit_code & 0x7f;
1963         if (tsk->exit_code & 0x80)
1964                 info.si_code = CLD_DUMPED;
1965         else if (tsk->exit_code & 0x7f)
1966                 info.si_code = CLD_KILLED;
1967         else {
1968                 info.si_code = CLD_EXITED;
1969                 info.si_status = tsk->exit_code >> 8;
1970         }
1971 
1972         psig = tsk->parent->sighand;
1973         spin_lock_irqsave(&psig->siglock, flags);
1974         if (!tsk->ptrace && sig == SIGCHLD &&
1975             (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1976              (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1977                 /*
1978                  * We are exiting and our parent doesn't care.  POSIX.1
1979                  * defines special semantics for setting SIGCHLD to SIG_IGN
1980                  * or setting the SA_NOCLDWAIT flag: we should be reaped
1981                  * automatically and not left for our parent's wait4 call.
1982                  * Rather than having the parent do it as a magic kind of
1983                  * signal handler, we just set this to tell do_exit that we
1984                  * can be cleaned up without becoming a zombie.  Note that
1985                  * we still call __wake_up_parent in this case, because a
1986                  * blocked sys_wait4 might now return -ECHILD.
1987                  *
1988                  * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1989                  * is implementation-defined: we do (if you don't want
1990                  * it, just use SIG_IGN instead).
1991                  */
1992                 autoreap = true;
1993                 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1994                         sig = 0;
1995         }
1996         /*
1997          * Send with __send_signal as si_pid and si_uid are in the
1998          * parent's namespaces.
1999          */
2000         if (valid_signal(sig) && sig)
2001                 __send_signal(sig, &info, tsk->parent, PIDTYPE_TGID, false);
2002         __wake_up_parent(tsk, tsk->parent);
2003         spin_unlock_irqrestore(&psig->siglock, flags);
2004 
2005         return autoreap;
2006 }
2007 
2008 /**
2009  * do_notify_parent_cldstop - notify parent of stopped/continued state change
2010  * @tsk: task reporting the state change
2011  * @for_ptracer: the notification is for ptracer
2012  * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
2013  *
2014  * Notify @tsk's parent that the stopped/continued state has changed.  If
2015  * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
2016  * If %true, @tsk reports to @tsk->parent which should be the ptracer.
2017  *
2018  * CONTEXT:
2019  * Must be called with tasklist_lock at least read locked.
2020  */
2021 static void do_notify_parent_cldstop(struct task_struct *tsk,
2022                                      bool for_ptracer, int why)
2023 {
2024         struct kernel_siginfo info;
2025         unsigned long flags;
2026         struct task_struct *parent;
2027         struct sighand_struct *sighand;
2028         u64 utime, stime;
2029 
2030         if (for_ptracer) {
2031                 parent = tsk->parent;
2032         } else {
2033                 tsk = tsk->group_leader;
2034                 parent = tsk->real_parent;
2035         }
2036 
2037         clear_siginfo(&info);
2038         info.si_signo = SIGCHLD;
2039         info.si_errno = 0;
2040         /*
2041          * see comment in do_notify_parent() about the following 4 lines
2042          */
2043         rcu_read_lock();
2044         info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
2045         info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
2046         rcu_read_unlock();
2047 
2048         task_cputime(tsk, &utime, &stime);
2049         info.si_utime = nsec_to_clock_t(utime);
2050         info.si_stime = nsec_to_clock_t(stime);
2051 
2052         info.si_code = why;
2053         switch (why) {
2054         case CLD_CONTINUED:
2055                 info.si_status = SIGCONT;
2056                 break;
2057         case CLD_STOPPED:
2058                 info.si_status = tsk->signal->group_exit_code & 0x7f;
2059                 break;
2060         case CLD_TRAPPED:
2061                 info.si_status = tsk->exit_code & 0x7f;
2062                 break;
2063         default:
2064                 BUG();
2065         }
2066 
2067         sighand = parent->sighand;
2068         spin_lock_irqsave(&sighand->siglock, flags);
2069         if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
2070             !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
2071                 __group_send_sig_info(SIGCHLD, &info, parent);
2072         /*
2073          * Even if SIGCHLD is not generated, we must wake up wait4 calls.
2074          */
2075         __wake_up_parent(tsk, parent);
2076         spin_unlock_irqrestore(&sighand->siglock, flags);
2077 }
2078 
2079 static inline bool may_ptrace_stop(void)
2080 {
2081         if (!likely(current->ptrace))
2082                 return false;
2083         /*
2084          * Are we in the middle of do_coredump?
2085          * If so and our tracer is also part of the coredump stopping
2086          * is a deadlock situation, and pointless because our tracer
2087          * is dead so don't allow us to stop.
2088          * If SIGKILL was already sent before the caller unlocked
2089          * ->siglock we must see ->core_state != NULL. Otherwise it
2090          * is safe to enter schedule().
2091          *
2092          * This is almost outdated, a task with the pending SIGKILL can't
2093          * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported
2094          * after SIGKILL was already dequeued.
2095          */
2096         if (unlikely(current->mm->core_state) &&
2097             unlikely(current->mm == current->parent->mm))
2098                 return false;
2099 
2100         return true;
2101 }
2102 
2103 /*
2104  * Return non-zero if there is a SIGKILL that should be waking us up.
2105  * Called with the siglock held.
2106  */
2107 static bool sigkill_pending(struct task_struct *tsk)
2108 {
2109         return sigismember(&tsk->pending.signal, SIGKILL) ||
2110                sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
2111 }
2112 
2113 /*
2114  * This must be called with current->sighand->siglock held.
2115  *
2116  * This should be the path for all ptrace stops.
2117  * We always set current->last_siginfo while stopped here.
2118  * That makes it a way to test a stopped process for
2119  * being ptrace-stopped vs being job-control-stopped.
2120  *
2121  * If we actually decide not to stop at all because the tracer
2122  * is gone, we keep current->exit_code unless clear_code.
2123  */
2124 static void ptrace_stop(int exit_code, int why, int clear_code, kernel_siginfo_t *info)
2125         __releases(&current->sighand->siglock)
2126         __acquires(&current->sighand->siglock)
2127 {
2128         bool gstop_done = false;
2129 
2130         if (arch_ptrace_stop_needed(exit_code, info)) {
2131                 /*
2132                  * The arch code has something special to do before a
2133                  * ptrace stop.  This is allowed to block, e.g. for faults
2134                  * on user stack pages.  We can't keep the siglock while
2135                  * calling arch_ptrace_stop, so we must release it now.
2136                  * To preserve proper semantics, we must do this before
2137                  * any signal bookkeeping like checking group_stop_count.
2138                  * Meanwhile, a SIGKILL could come in before we retake the
2139                  * siglock.  That must prevent us from sleeping in TASK_TRACED.
2140                  * So after regaining the lock, we must check for SIGKILL.
2141                  */
2142                 spin_unlock_irq(&current->sighand->siglock);
2143                 arch_ptrace_stop(exit_code, info);
2144                 spin_lock_irq(&current->sighand->siglock);
2145                 if (sigkill_pending(current))
2146                         return;
2147         }
2148 
2149         set_special_state(TASK_TRACED);
2150 
2151         /*
2152          * We're committing to trapping.  TRACED should be visible before
2153          * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
2154          * Also, transition to TRACED and updates to ->jobctl should be
2155          * atomic with respect to siglock and should be done after the arch
2156          * hook as siglock is released and regrabbed across it.
2157          *
2158          *     TRACER                               TRACEE
2159          *
2160          *     ptrace_attach()
2161          * [L]   wait_on_bit(JOBCTL_TRAPPING)   [S] set_special_state(TRACED)
2162          *     do_wait()
2163          *       set_current_state()                smp_wmb();
2164          *       ptrace_do_wait()
2165          *         wait_task_stopped()
2166          *           task_stopped_code()
2167          * [L]         task_is_traced()         [S] task_clear_jobctl_trapping();
2168          */
2169         smp_wmb();
2170 
2171         current->last_siginfo = info;
2172         current->exit_code = exit_code;
2173 
2174         /*
2175          * If @why is CLD_STOPPED, we're trapping to participate in a group
2176          * stop.  Do the bookkeeping.  Note that if SIGCONT was delievered
2177          * across siglock relocks since INTERRUPT was scheduled, PENDING
2178          * could be clear now.  We act as if SIGCONT is received after
2179          * TASK_TRACED is entered - ignore it.
2180          */
2181         if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
2182                 gstop_done = task_participate_group_stop(current);
2183 
2184         /* any trap clears pending STOP trap, STOP trap clears NOTIFY */
2185         task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
2186         if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
2187                 task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
2188 
2189         /* entering a trap, clear TRAPPING */
2190         task_clear_jobctl_trapping(current);
2191 
2192         spin_unlock_irq(&current->sighand->siglock);
2193         read_lock(&tasklist_lock);
2194         if (may_ptrace_stop()) {
2195                 /*
2196                  * Notify parents of the stop.
2197                  *
2198                  * While ptraced, there are two parents - the ptracer and
2199                  * the real_parent of the group_leader.  The ptracer should
2200                  * know about every stop while the real parent is only
2201                  * interested in the completion of group stop.  The states
2202                  * for the two don't interact with each other.  Notify
2203                  * separately unless they're gonna be duplicates.
2204                  */
2205                 do_notify_parent_cldstop(current, true, why);
2206                 if (gstop_done && ptrace_reparented(current))
2207                         do_notify_parent_cldstop(current, false, why);
2208 
2209                 /*
2210                  * Don't want to allow preemption here, because
2211                  * sys_ptrace() needs this task to be inactive.
2212                  *
2213                  * XXX: implement read_unlock_no_resched().
2214                  */
2215                 preempt_disable();
2216                 read_unlock(&tasklist_lock);
2217                 cgroup_enter_frozen();
2218                 preempt_enable_no_resched();
2219                 freezable_schedule();
2220                 cgroup_leave_frozen(true);
2221         } else {
2222                 /*
2223                  * By the time we got the lock, our tracer went away.
2224                  * Don't drop the lock yet, another tracer may come.
2225                  *
2226                  * If @gstop_done, the ptracer went away between group stop
2227                  * completion and here.  During detach, it would have set
2228                  * JOBCTL_STOP_PENDING on us and we'll re-enter
2229                  * TASK_STOPPED in do_signal_stop() on return, so notifying
2230                  * the real parent of the group stop completion is enough.
2231                  */
2232                 if (gstop_done)
2233                         do_notify_parent_cldstop(current, false, why);
2234 
2235                 /* tasklist protects us from ptrace_freeze_traced() */
2236                 __set_current_state(TASK_RUNNING);
2237                 if (clear_code)
2238                         current->exit_code = 0;
2239                 read_unlock(&tasklist_lock);
2240         }
2241 
2242         /*
2243          * We are back.  Now reacquire the siglock before touching
2244          * last_siginfo, so that we are sure to have synchronized with
2245          * any signal-sending on another CPU that wants to examine it.
2246          */
2247         spin_lock_irq(&current->sighand->siglock);
2248         current->last_siginfo = NULL;
2249 
2250         /* LISTENING can be set only during STOP traps, clear it */
2251         current->jobctl &= ~JOBCTL_LISTENING;
2252 
2253         /*
2254          * Queued signals ignored us while we were stopped for tracing.
2255          * So check for any that we should take before resuming user mode.
2256          * This sets TIF_SIGPENDING, but never clears it.
2257          */
2258         recalc_sigpending_tsk(current);
2259 }
2260 
2261 static void ptrace_do_notify(int signr, int exit_code, int why)
2262 {
2263         kernel_siginfo_t info;
2264 
2265         clear_siginfo(&info);
2266         info.si_signo = signr;
2267         info.si_code = exit_code;
2268         info.si_pid = task_pid_vnr(current);
2269         info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2270 
2271         /* Let the debugger run.  */
2272         ptrace_stop(exit_code, why, 1, &info);
2273 }
2274 
2275 void ptrace_notify(int exit_code)
2276 {
2277         BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
2278         if (unlikely(current->task_works))
2279                 task_work_run();
2280 
2281         spin_lock_irq(&current->sighand->siglock);
2282         ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
2283         spin_unlock_irq(&current->sighand->siglock);
2284 }
2285 
2286 /**
2287  * do_signal_stop - handle group stop for SIGSTOP and other stop signals
2288  * @signr: signr causing group stop if initiating
2289  *
2290  * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
2291  * and participate in it.  If already set, participate in the existing
2292  * group stop.  If participated in a group stop (and thus slept), %true is
2293  * returned with siglock released.
2294  *
2295  * If ptraced, this function doesn't handle stop itself.  Instead,
2296  * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
2297  * untouched.  The caller must ensure that INTERRUPT trap handling takes
2298  * places afterwards.
2299  *
2300  * CONTEXT:
2301  * Must be called with @current->sighand->siglock held, which is released
2302  * on %true return.
2303  *
2304  * RETURNS:
2305  * %false if group stop is already cancelled or ptrace trap is scheduled.
2306  * %true if participated in group stop.
2307  */
2308 static bool do_signal_stop(int signr)
2309         __releases(&current->sighand->siglock)
2310 {
2311         struct signal_struct *sig = current->signal;
2312 
2313         if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
2314                 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
2315                 struct task_struct *t;
2316 
2317                 /* signr will be recorded in task->jobctl for retries */
2318                 WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
2319 
2320                 if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
2321                     unlikely(signal_group_exit(sig)))
2322                         return false;
2323                 /*
2324                  * There is no group stop already in progress.  We must
2325                  * initiate one now.
2326                  *
2327                  * While ptraced, a task may be resumed while group stop is
2328                  * still in effect and then receive a stop signal and
2329                  * initiate another group stop.  This deviates from the
2330                  * usual behavior as two consecutive stop signals can't
2331                  * cause two group stops when !ptraced.  That is why we
2332                  * also check !task_is_stopped(t) below.
2333                  *
2334                  * The condition can be distinguished by testing whether
2335                  * SIGNAL_STOP_STOPPED is already set.  Don't generate
2336                  * group_exit_code in such case.
2337                  *
2338                  * This is not necessary for SIGNAL_STOP_CONTINUED because
2339                  * an intervening stop signal is required to cause two
2340                  * continued events regardless of ptrace.
2341                  */
2342                 if (!(sig->flags & SIGNAL_STOP_STOPPED))
2343                         sig->group_exit_code = signr;
2344 
2345                 sig->group_stop_count = 0;
2346 
2347                 if (task_set_jobctl_pending(current, signr | gstop))
2348                         sig->group_stop_count++;
2349 
2350                 t = current;
2351                 while_each_thread(current, t) {
2352                         /*
2353                          * Setting state to TASK_STOPPED for a group
2354                          * stop is always done with the siglock held,
2355                          * so this check has no races.
2356                          */
2357                         if (!task_is_stopped(t) &&
2358                             task_set_jobctl_pending(t, signr | gstop)) {
2359                                 sig->group_stop_count++;
2360                                 if (likely(!(t->ptrace & PT_SEIZED)))
2361                                         signal_wake_up(t, 0);
2362                                 else
2363                                         ptrace_trap_notify(t);
2364                         }
2365                 }
2366         }
2367 
2368         if (likely(!current->ptrace)) {
2369                 int notify = 0;
2370 
2371                 /*
2372                  * If there are no other threads in the group, or if there
2373                  * is a group stop in progress and we are the last to stop,
2374                  * report to the parent.
2375                  */
2376                 if (task_participate_group_stop(current))
2377                         notify = CLD_STOPPED;
2378 
2379                 set_special_state(TASK_STOPPED);
2380                 spin_unlock_irq(&current->sighand->siglock);
2381 
2382                 /*
2383                  * Notify the parent of the group stop completion.  Because
2384                  * we're not holding either the siglock or tasklist_lock
2385                  * here, ptracer may attach inbetween; however, this is for
2386                  * group stop and should always be delivered to the real
2387                  * parent of the group leader.  The new ptracer will get
2388                  * its notification when this task transitions into
2389                  * TASK_TRACED.
2390                  */
2391                 if (notify) {
2392                         read_lock(&tasklist_lock);
2393                         do_notify_parent_cldstop(current, false, notify);
2394                         read_unlock(&tasklist_lock);
2395                 }
2396 
2397                 /* Now we don't run again until woken by SIGCONT or SIGKILL */
2398                 cgroup_enter_frozen();
2399                 freezable_schedule();
2400                 return true;
2401         } else {
2402                 /*
2403                  * While ptraced, group stop is handled by STOP trap.
2404                  * Schedule it and let the caller deal with it.
2405                  */
2406                 task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
2407                 return false;
2408         }
2409 }
2410 
2411 /**
2412  * do_jobctl_trap - take care of ptrace jobctl traps
2413  *
2414  * When PT_SEIZED, it's used for both group stop and explicit
2415  * SEIZE/INTERRUPT traps.  Both generate PTRACE_EVENT_STOP trap with
2416  * accompanying siginfo.  If stopped, lower eight bits of exit_code contain
2417  * the stop signal; otherwise, %SIGTRAP.
2418  *
2419  * When !PT_SEIZED, it's used only for group stop trap with stop signal
2420  * number as exit_code and no siginfo.
2421  *
2422  * CONTEXT:
2423  * Must be called with @current->sighand->siglock held, which may be
2424  * released and re-acquired before returning with intervening sleep.
2425  */
2426 static void do_jobctl_trap(void)
2427 {
2428         struct signal_struct *signal = current->signal;
2429         int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2430 
2431         if (current->ptrace & PT_SEIZED) {
2432                 if (!signal->group_stop_count &&
2433                     !(signal->flags & SIGNAL_STOP_STOPPED))
2434                         signr = SIGTRAP;
2435                 WARN_ON_ONCE(!signr);
2436                 ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
2437                                  CLD_STOPPED);
2438         } else {
2439                 WARN_ON_ONCE(!signr);
2440                 ptrace_stop(signr, CLD_STOPPED, 0, NULL);
2441                 current->exit_code = 0;
2442         }
2443 }
2444 
2445 /**
2446  * do_freezer_trap - handle the freezer jobctl trap
2447  *
2448  * Puts the task into frozen state, if only the task is not about to quit.
2449  * In this case it drops JOBCTL_TRAP_FREEZE.
2450  *
2451  * CONTEXT:
2452  * Must be called with @current->sighand->siglock held,
2453  * which is always released before returning.
2454  */
2455 static void do_freezer_trap(void)
2456         __releases(&current->sighand->siglock)
2457 {
2458         /*
2459          * If there are other trap bits pending except JOBCTL_TRAP_FREEZE,
2460          * let's make another loop to give it a chance to be handled.
2461          * In any case, we'll return back.
2462          */
2463         if ((current->jobctl & (JOBCTL_PENDING_MASK | JOBCTL_TRAP_FREEZE)) !=
2464              JOBCTL_TRAP_FREEZE) {
2465                 spin_unlock_irq(&current->sighand->siglock);
2466                 return;
2467         }
2468 
2469         /*
2470          * Now we're sure that there is no pending fatal signal and no
2471          * pending traps. Clear TIF_SIGPENDING to not get out of schedule()
2472          * immediately (if there is a non-fatal signal pending), and
2473          * put the task into sleep.
2474          */
2475         __set_current_state(TASK_INTERRUPTIBLE);
2476         clear_thread_flag(TIF_SIGPENDING);
2477         spin_unlock_irq(&current->sighand->siglock);
2478         cgroup_enter_frozen();
2479         freezable_schedule();
2480 }
2481 
2482 static int ptrace_signal(int signr, kernel_siginfo_t *info)
2483 {
2484         /*
2485          * We do not check sig_kernel_stop(signr) but set this marker
2486          * unconditionally because we do not know whether debugger will
2487          * change signr. This flag has no meaning unless we are going
2488          * to stop after return from ptrace_stop(). In this case it will
2489          * be checked in do_signal_stop(), we should only stop if it was
2490          * not cleared by SIGCONT while we were sleeping. See also the
2491          * comment in dequeue_signal().
2492          */
2493         current->jobctl |= JOBCTL_STOP_DEQUEUED;
2494         ptrace_stop(signr, CLD_TRAPPED, 0, info);
2495 
2496         /* We're back.  Did the debugger cancel the sig?  */
2497         signr = current->exit_code;
2498         if (signr == 0)
2499                 return signr;
2500 
2501         current->exit_code = 0;
2502 
2503         /*
2504          * Update the siginfo structure if the signal has
2505          * changed.  If the debugger wanted something
2506          * specific in the siginfo structure then it should
2507          * have updated *info via PTRACE_SETSIGINFO.
2508          */
2509         if (signr != info->si_signo) {
2510                 clear_siginfo(info);
2511                 info->si_signo = signr;
2512                 info->si_errno = 0;
2513                 info->si_code = SI_USER;
2514                 rcu_read_lock();
2515                 info->si_pid = task_pid_vnr(current->parent);
2516                 info->si_uid = from_kuid_munged(current_user_ns(),
2517                                                 task_uid(current->parent));
2518                 rcu_read_unlock();
2519         }
2520 
2521         /* If the (new) signal is now blocked, requeue it.  */
2522         if (sigismember(&current->blocked, signr)) {
2523                 send_signal(signr, info, current, PIDTYPE_PID);
2524                 signr = 0;
2525         }
2526 
2527         return signr;
2528 }
2529 
2530 bool get_signal(struct ksignal *ksig)
2531 {
2532         struct sighand_struct *sighand = current->sighand;
2533         struct signal_struct *signal = current->signal;
2534         int signr;
2535 
2536         if (unlikely(current->task_works))
2537                 task_work_run();
2538 
2539         if (unlikely(uprobe_deny_signal()))
2540                 return false;
2541 
2542         /*
2543          * Do this once, we can't return to user-mode if freezing() == T.
2544          * do_signal_stop() and ptrace_stop() do freezable_schedule() and
2545          * thus do not need another check after return.
2546          */
2547         try_to_freeze();
2548 
2549 relock:
2550         spin_lock_irq(&sighand->siglock);
2551         /*
2552          * Every stopped thread goes here after wakeup. Check to see if
2553          * we should notify the parent, prepare_signal(SIGCONT) encodes
2554          * the CLD_ si_code into SIGNAL_CLD_MASK bits.
2555          */
2556         if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2557                 int why;
2558 
2559                 if (signal->flags & SIGNAL_CLD_CONTINUED)
2560                         why = CLD_CONTINUED;
2561                 else
2562                         why = CLD_STOPPED;
2563 
2564                 signal->flags &= ~SIGNAL_CLD_MASK;
2565 
2566                 spin_unlock_irq(&sighand->siglock);
2567 
2568                 /*
2569                  * Notify the parent that we're continuing.  This event is
2570                  * always per-process and doesn't make whole lot of sense
2571                  * for ptracers, who shouldn't consume the state via
2572                  * wait(2) either, but, for backward compatibility, notify
2573                  * the ptracer of the group leader too unless it's gonna be
2574                  * a duplicate.
2575                  */
2576                 read_lock(&tasklist_lock);
2577                 do_notify_parent_cldstop(current, false, why);
2578 
2579                 if (ptrace_reparented(current->group_leader))
2580                         do_notify_parent_cldstop(current->group_leader,
2581                                                 true, why);
2582                 read_unlock(&tasklist_lock);
2583 
2584                 goto relock;
2585         }
2586 
2587         /* Has this task already been marked for death? */
2588         if (signal_group_exit(signal)) {
2589                 ksig->info.si_signo = signr = SIGKILL;
2590                 sigdelset(&current->pending.signal, SIGKILL);
2591                 trace_signal_deliver(SIGKILL, SEND_SIG_NOINFO,
2592                                 &sighand->action[SIGKILL - 1]);
2593                 recalc_sigpending();
2594                 goto fatal;
2595         }
2596 
2597         for (;;) {
2598                 struct k_sigaction *ka;
2599 
2600                 if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
2601                     do_signal_stop(0))
2602                         goto relock;
2603 
2604                 if (unlikely(current->jobctl &
2605                              (JOBCTL_TRAP_MASK | JOBCTL_TRAP_FREEZE))) {
2606                         if (current->jobctl & JOBCTL_TRAP_MASK) {
2607                                 do_jobctl_trap();
2608                                 spin_unlock_irq(&sighand->siglock);
2609                         } else if (current->jobctl & JOBCTL_TRAP_FREEZE)
2610                                 do_freezer_trap();
2611 
2612                         goto relock;
2613                 }
2614 
2615                 /*
2616                  * If the task is leaving the frozen state, let's update
2617                  * cgroup counters and reset the frozen bit.
2618                  */
2619                 if (unlikely(cgroup_task_frozen(current))) {
2620                         spin_unlock_irq(&sighand->siglock);
2621                         cgroup_leave_frozen(false);
2622                         goto relock;
2623                 }
2624 
2625                 /*
2626                  * Signals generated by the execution of an instruction
2627                  * need to be delivered before any other pending signals
2628                  * so that the instruction pointer in the signal stack
2629                  * frame points to the faulting instruction.
2630                  */
2631                 signr = dequeue_synchronous_signal(&ksig->info);
2632                 if (!signr)
2633                         signr = dequeue_signal(current, &current->blocked, &ksig->info);
2634 
2635                 if (!signr)
2636                         break; /* will return 0 */
2637 
2638                 if (unlikely(current->ptrace) && signr != SIGKILL) {
2639                         signr = ptrace_signal(signr, &ksig->info);
2640                         if (!signr)
2641                                 continue;
2642                 }
2643 
2644                 ka = &sighand->action[signr-1];
2645 
2646                 /* Trace actually delivered signals. */
2647                 trace_signal_deliver(signr, &ksig->info, ka);
2648 
2649                 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
2650                         continue;
2651                 if (ka->sa.sa_handler != SIG_DFL) {
2652                         /* Run the handler.  */
2653                         ksig->ka = *ka;
2654 
2655                         if (ka->sa.sa_flags & SA_ONESHOT)
2656                                 ka->sa.sa_handler = SIG_DFL;
2657 
2658                         break; /* will return non-zero "signr" value */
2659                 }
2660 
2661                 /*
2662                  * Now we are doing the default action for this signal.
2663                  */
2664                 if (sig_kernel_ignore(signr)) /* Default is nothing. */
2665                         continue;
2666 
2667                 /*
2668                  * Global init gets no signals it doesn't want.
2669                  * Container-init gets no signals it doesn't want from same
2670                  * container.
2671                  *
2672                  * Note that if global/container-init sees a sig_kernel_only()
2673                  * signal here, the signal must have been generated internally
2674                  * or must have come from an ancestor namespace. In either
2675                  * case, the signal cannot be dropped.
2676                  */
2677                 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2678                                 !sig_kernel_only(signr))
2679                         continue;
2680 
2681                 if (sig_kernel_stop(signr)) {
2682                         /*
2683                          * The default action is to stop all threads in
2684                          * the thread group.  The job control signals
2685                          * do nothing in an orphaned pgrp, but SIGSTOP
2686                          * always works.  Note that siglock needs to be
2687                          * dropped during the call to is_orphaned_pgrp()
2688                          * because of lock ordering with tasklist_lock.
2689                          * This allows an intervening SIGCONT to be posted.
2690                          * We need to check for that and bail out if necessary.
2691                          */
2692                         if (signr != SIGSTOP) {
2693                                 spin_unlock_irq(&sighand->siglock);
2694 
2695                                 /* signals can be posted during this window */
2696 
2697                                 if (is_current_pgrp_orphaned())
2698                                         goto relock;
2699 
2700                                 spin_lock_irq(&sighand->siglock);
2701                         }
2702 
2703                         if (likely(do_signal_stop(ksig->info.si_signo))) {
2704                                 /* It released the siglock.  */
2705                                 goto relock;
2706                         }
2707 
2708                         /*
2709                          * We didn't actually stop, due to a race
2710                          * with SIGCONT or something like that.
2711                          */
2712                         continue;
2713                 }
2714 
2715         fatal:
2716                 spin_unlock_irq(&sighand->siglock);
2717                 if (unlikely(cgroup_task_frozen(current)))
2718                         cgroup_leave_frozen(true);
2719 
2720                 /*
2721                  * Anything else is fatal, maybe with a core dump.
2722                  */
2723                 current->flags |= PF_SIGNALED;
2724 
2725                 if (sig_kernel_coredump(signr)) {
2726                         if (print_fatal_signals)
2727                                 print_fatal_signal(ksig->info.si_signo);
2728                         proc_coredump_connector(current);
2729                         /*
2730                          * If it was able to dump core, this kills all
2731                          * other threads in the group and synchronizes with
2732                          * their demise.  If we lost the race with another
2733                          * thread getting here, it set group_exit_code
2734                          * first and our do_group_exit call below will use
2735                          * that value and ignore the one we pass it.
2736                          */
2737                         do_coredump(&ksig->info);
2738                 }
2739 
2740                 /*
2741                  * Death signals, no core dump.
2742                  */
2743                 do_group_exit(ksig->info.si_signo);
2744                 /* NOTREACHED */
2745         }
2746         spin_unlock_irq(&sighand->siglock);
2747 
2748         ksig->sig = signr;
2749         return ksig->sig > 0;
2750 }
2751 
2752 /**
2753  * signal_delivered - 
2754  * @ksig:               kernel signal struct
2755  * @stepping:           nonzero if debugger single-step or block-step in use
2756  *
2757  * This function should be called when a signal has successfully been
2758  * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
2759  * is always blocked, and the signal itself is blocked unless %SA_NODEFER
2760  * is set in @ksig->ka.sa.sa_flags.  Tracing is notified.
2761  */
2762 static void signal_delivered(struct ksignal *ksig, int stepping)
2763 {
2764         sigset_t blocked;
2765 
2766         /* A signal was successfully delivered, and the
2767            saved sigmask was stored on the signal frame,
2768            and will be restored by sigreturn.  So we can
2769            simply clear the restore sigmask flag.  */
2770         clear_restore_sigmask();
2771 
2772         sigorsets(&blocked, &current->blocked, &ksig->ka.sa.sa_mask);
2773         if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
2774                 sigaddset(&blocked, ksig->sig);
2775         set_current_blocked(&blocked);
2776         tracehook_signal_handler(stepping);
2777 }
2778 
2779 void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2780 {
2781         if (failed)
2782                 force_sigsegv(ksig->sig);
2783         else
2784                 signal_delivered(ksig, stepping);
2785 }
2786 
2787 /*
2788  * It could be that complete_signal() picked us to notify about the
2789  * group-wide signal. Other threads should be notified now to take
2790  * the shared signals in @which since we will not.
2791  */
2792 static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2793 {
2794         sigset_t retarget;
2795         struct task_struct *t;
2796 
2797         sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
2798         if (sigisemptyset(&retarget))
2799                 return;
2800 
2801         t = tsk;
2802         while_each_thread(tsk, t) {
2803                 if (t->flags & PF_EXITING)
2804                         continue;
2805 
2806                 if (!has_pending_signals(&retarget, &t->blocked))
2807                         continue;
2808                 /* Remove the signals this thread can handle. */
2809                 sigandsets(&retarget, &retarget, &t->blocked);
2810 
2811                 if (!signal_pending(t))
2812                         signal_wake_up(t, 0);
2813 
2814                 if (sigisemptyset(&retarget))
2815                         break;
2816         }
2817 }
2818 
2819 void exit_signals(struct task_struct *tsk)
2820 {
2821         int group_stop = 0;
2822         sigset_t unblocked;
2823 
2824         /*
2825          * @tsk is about to have PF_EXITING set - lock out users which
2826          * expect stable threadgroup.
2827          */
2828         cgroup_threadgroup_change_begin(tsk);
2829 
2830         if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2831                 tsk->flags |= PF_EXITING;
2832                 cgroup_threadgroup_change_end(tsk);
2833                 return;
2834         }
2835 
2836         spin_lock_irq(&tsk->sighand->siglock);
2837         /*
2838          * From now this task is not visible for group-wide signals,
2839          * see wants_signal(), do_signal_stop().
2840          */
2841         tsk->flags |= PF_EXITING;
2842 
2843         cgroup_threadgroup_change_end(tsk);
2844 
2845         if (!signal_pending(tsk))
2846                 goto out;
2847 
2848         unblocked = tsk->blocked;
2849         signotset(&unblocked);
2850         retarget_shared_pending(tsk, &unblocked);
2851 
2852         if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2853             task_participate_group_stop(tsk))
2854                 group_stop = CLD_STOPPED;
2855 out:
2856         spin_unlock_irq(&tsk->sighand->siglock);
2857 
2858         /*
2859          * If group stop has completed, deliver the notification.  This
2860          * should always go to the real parent of the group leader.
2861          */
2862         if (unlikely(group_stop)) {
2863                 read_lock(&tasklist_lock);
2864                 do_notify_parent_cldstop(tsk, false, group_stop);
2865                 read_unlock(&tasklist_lock);
2866         }
2867 }
2868 
2869 /*
2870  * System call entry points.
2871  */
2872 
2873 /**
2874  *  sys_restart_syscall - restart a system call
2875  */
2876 SYSCALL_DEFINE0(restart_syscall)
2877 {
2878         struct restart_block *restart = &current->restart_block;
2879         return restart->fn(restart);
2880 }
2881 
2882 long do_no_restart_syscall(struct restart_block *param)
2883 {
2884         return -EINTR;
2885 }
2886 
2887 static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
2888 {
2889         if (signal_pending(tsk) && !thread_group_empty(tsk)) {
2890                 sigset_t newblocked;
2891                 /* A set of now blocked but previously unblocked signals. */
2892                 sigandnsets(&newblocked, newset, &current->blocked);
2893                 retarget_shared_pending(tsk, &newblocked);
2894         }
2895         tsk->blocked = *newset;
2896         recalc_sigpending();
2897 }
2898 
2899 /**
2900  * set_current_blocked - change current->blocked mask
2901  * @newset: new mask
2902  *
2903  * It is wrong to change ->blocked directly, this helper should be used
2904  * to ensure the process can't miss a shared signal we are going to block.
2905  */
2906 void set_current_blocked(sigset_t *newset)
2907 {
2908         sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2909         __set_current_blocked(newset);
2910 }
2911 
2912 void __set_current_blocked(const sigset_t *newset)
2913 {
2914         struct task_struct *tsk = current;
2915 
2916         /*
2917          * In case the signal mask hasn't changed, there is nothing we need
2918          * to do. The current->blocked shouldn't be modified by other task.
2919          */
2920         if (sigequalsets(&tsk->blocked, newset))
2921                 return;
2922 
2923         spin_lock_irq(&tsk->sighand->siglock);
2924         __set_task_blocked(tsk, newset);
2925         spin_unlock_irq(&tsk->sighand->siglock);
2926 }
2927 
2928 /*
2929  * This is also useful for kernel threads that want to temporarily
2930  * (or permanently) block certain signals.
2931  *
2932  * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2933  * interface happily blocks "unblockable" signals like SIGKILL
2934  * and friends.
2935  */
2936 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2937 {
2938         struct task_struct *tsk = current;
2939         sigset_t newset;
2940 
2941         /* Lockless, only current can change ->blocked, never from irq */
2942         if (oldset)
2943                 *oldset = tsk->blocked;
2944 
2945         switch (how) {
2946         case SIG_BLOCK:
2947                 sigorsets(&newset, &tsk->blocked, set);
2948                 break;
2949         case SIG_UNBLOCK:
2950                 sigandnsets(&newset, &tsk->blocked, set);
2951                 break;
2952         case SIG_SETMASK:
2953                 newset = *set;
2954                 break;
2955         default:
2956                 return -EINVAL;
2957         }
2958 
2959         __set_current_blocked(&newset);
2960         return 0;
2961 }
2962 EXPORT_SYMBOL(sigprocmask);
2963 
2964 /*
2965  * The api helps set app-provided sigmasks.
2966  *
2967  * This is useful for syscalls such as ppoll, pselect, io_pgetevents and
2968  * epoll_pwait where a new sigmask is passed from userland for the syscalls.
2969  *
2970  * Note that it does set_restore_sigmask() in advance, so it must be always
2971  * paired with restore_saved_sigmask_unless() before return from syscall.
2972  */
2973 int set_user_sigmask(const sigset_t __user *umask, size_t sigsetsize)
2974 {
2975         sigset_t kmask;
2976 
2977         if (!umask)
2978                 return 0;
2979         if (sigsetsize != sizeof(sigset_t))
2980                 return -EINVAL;
2981         if (copy_from_user(&kmask, umask, sizeof(sigset_t)))
2982                 return -EFAULT;
2983 
2984         set_restore_sigmask();
2985         current->saved_sigmask = current->blocked;
2986         set_current_blocked(&kmask);
2987 
2988         return 0;
2989 }
2990 
2991 #ifdef CONFIG_COMPAT
2992 int set_compat_user_sigmask(const compat_sigset_t __user *umask,
2993                             size_t sigsetsize)
2994 {
2995         sigset_t kmask;
2996 
2997         if (!umask)
2998                 return 0;
2999         if (sigsetsize != sizeof(compat_sigset_t))
3000                 return -EINVAL;
3001         if (get_compat_sigset(&kmask, umask))
3002                 return -EFAULT;
3003 
3004         set_restore_sigmask();
3005         current->saved_sigmask = current->blocked;
3006         set_current_blocked(&kmask);
3007 
3008         return 0;
3009 }
3010 #endif
3011 
3012 /**
3013  *  sys_rt_sigprocmask - change the list of currently blocked signals
3014  *  @how: whether to add, remove, or set signals
3015  *  @nset: stores pending signals
3016  *  @oset: previous value of signal mask if non-null
3017  *  @sigsetsize: size of sigset_t type
3018  */
3019 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
3020                 sigset_t __user *, oset, size_t, sigsetsize)
3021 {
3022         sigset_t old_set, new_set;
3023         int error;
3024 
3025         /* XXX: Don't preclude handling different sized sigset_t's.  */
3026         if (sigsetsize != sizeof(sigset_t))
3027                 return -EINVAL;
3028 
3029         old_set = current->blocked;
3030 
3031         if (nset) {
3032                 if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
3033                         return -EFAULT;
3034                 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
3035 
3036                 error = sigprocmask(how, &new_set, NULL);
3037                 if (error)
3038                         return error;
3039         }
3040 
3041         if (oset) {
3042                 if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
3043                         return -EFAULT;
3044         }
3045 
3046         return 0;
3047 }
3048 
3049 #ifdef CONFIG_COMPAT
3050 COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
3051                 compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
3052 {
3053         sigset_t old_set = current->blocked;
3054 
3055         /* XXX: Don't preclude handling different sized sigset_t's.  */
3056         if (sigsetsize != sizeof(sigset_t))
3057                 return -EINVAL;
3058 
3059         if (nset) {
3060                 sigset_t new_set;
3061                 int error;
3062                 if (get_compat_sigset(&new_set, nset))
3063                         return -EFAULT;
3064                 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
3065 
3066                 error = sigprocmask(how, &new_set, NULL);
3067                 if (error)
3068                         return error;
3069         }
3070         return oset ? put_compat_sigset(oset, &old_set, sizeof(*oset)) : 0;
3071 }
3072 #endif
3073 
3074 static void do_sigpending(sigset_t *set)
3075 {
3076         spin_lock_irq(&current->sighand->siglock);
3077         sigorsets(set, &current->pending.signal,
3078                   &current->signal->shared_pending.signal);
3079         spin_unlock_irq(&current->sighand->siglock);
3080 
3081         /* Outside the lock because only this thread touches it.  */
3082         sigandsets(set, &current->blocked, set);
3083 }
3084 
3085 /**
3086  *  sys_rt_sigpending - examine a pending signal that has been raised
3087  *                      while blocked
3088  *  @uset: stores pending signals
3089  *  @sigsetsize: size of sigset_t type or larger
3090  */
3091 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
3092 {
3093         sigset_t set;
3094 
3095         if (sigsetsize > sizeof(*uset))
3096                 return -EINVAL;
3097 
3098         do_sigpending(&set);
3099 
3100         if (copy_to_user(uset, &set, sigsetsize))
3101                 return -EFAULT;
3102 
3103         return 0;
3104 }
3105 
3106 #ifdef CONFIG_COMPAT
3107 COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
3108                 compat_size_t, sigsetsize)
3109 {
3110         sigset_t set;
3111 
3112         if (sigsetsize > sizeof(*uset))
3113                 return -EINVAL;
3114 
3115         do_sigpending(&set);
3116 
3117         return put_compat_sigset(uset, &set, sigsetsize);
3118 }
3119 #endif
3120 
3121 static const struct {
3122         unsigned char limit, layout;
3123 } sig_sicodes[] = {
3124         [SIGILL]  = { NSIGILL,  SIL_FAULT },
3125         [SIGFPE]  = { NSIGFPE,  SIL_FAULT },
3126         [SIGSEGV] = { NSIGSEGV, SIL_FAULT },
3127         [SIGBUS]  = { NSIGBUS,  SIL_FAULT },
3128         [SIGTRAP] = { NSIGTRAP, SIL_FAULT },
3129 #if defined(SIGEMT)
3130         [SIGEMT]  = { NSIGEMT,  SIL_FAULT },
3131 #endif
3132         [SIGCHLD] = { NSIGCHLD, SIL_CHLD },
3133         [SIGPOLL] = { NSIGPOLL, SIL_POLL },
3134         [SIGSYS]  = { NSIGSYS,  SIL_SYS },
3135 };
3136 
3137 static bool known_siginfo_layout(unsigned sig, int si_code)
3138 {
3139         if (si_code == SI_KERNEL)
3140                 return true;
3141         else if ((si_code > SI_USER)) {
3142                 if (sig_specific_sicodes(sig)) {
3143                         if (si_code <= sig_sicodes[sig].limit)
3144                                 return true;
3145                 }
3146                 else if (si_code <= NSIGPOLL)
3147                         return true;
3148         }
3149         else if (si_code >= SI_DETHREAD)
3150                 return true;
3151         else if (si_code == SI_ASYNCNL)
3152                 return true;
3153         return false;
3154 }
3155 
3156 enum siginfo_layout siginfo_layout(unsigned sig, int si_code)
3157 {
3158         enum siginfo_layout layout = SIL_KILL;
3159         if ((si_code > SI_USER) && (si_code < SI_KERNEL)) {
3160                 if ((sig < ARRAY_SIZE(sig_sicodes)) &&
3161                     (si_code <= sig_sicodes[sig].limit)) {
3162                         layout = sig_sicodes[sig].layout;
3163                         /* Handle the exceptions */
3164                         if ((sig == SIGBUS) &&
3165                             (si_code >= BUS_MCEERR_AR) && (si_code <= BUS_MCEERR_AO))
3166                                 layout = SIL_FAULT_MCEERR;
3167                         else if ((sig == SIGSEGV) && (si_code == SEGV_BNDERR))
3168                                 layout = SIL_FAULT_BNDERR;
3169 #ifdef SEGV_PKUERR
3170                         else if ((sig == SIGSEGV) && (si_code == SEGV_PKUERR))
3171                                 layout = SIL_FAULT_PKUERR;
3172 #endif
3173                 }
3174                 else if (si_code <= NSIGPOLL)
3175                         layout = SIL_POLL;
3176         } else {
3177                 if (si_code == SI_TIMER)
3178                         layout = SIL_TIMER;
3179                 else if (si_code == SI_SIGIO)
3180                         layout = SIL_POLL;
3181                 else if (si_code < 0)
3182                         layout = SIL_RT;
3183         }
3184         return layout;
3185 }
3186 
3187 static inline char __user *si_expansion(const siginfo_t __user *info)
3188 {
3189         return ((char __user *)info) + sizeof(struct kernel_siginfo);
3190 }
3191 
3192 int copy_siginfo_to_user(siginfo_t __user *to, const kernel_siginfo_t *from)
3193 {
3194         char __user *expansion = si_expansion(to);
3195         if (copy_to_user(to, from , sizeof(struct kernel_siginfo)))
3196                 return -EFAULT;
3197         if (clear_user(expansion, SI_EXPANSION_SIZE))
3198                 return -EFAULT;
3199         return 0;
3200 }
3201 
3202 static int post_copy_siginfo_from_user(kernel_siginfo_t *info,
3203                                        const siginfo_t __user *from)
3204 {
3205         if (unlikely(!known_siginfo_layout(info->si_signo, info->si_code))) {
3206                 char __user *expansion = si_expansion(from);
3207                 char buf[SI_EXPANSION_SIZE];
3208                 int i;
3209                 /*
3210                  * An unknown si_code might need more than
3211                  * sizeof(struct kernel_siginfo) bytes.  Verify all of the
3212                  * extra bytes are 0.  This guarantees copy_siginfo_to_user
3213                  * will return this data to userspace exactly.
3214                  */
3215                 if (copy_from_user(&buf, expansion, SI_EXPANSION_SIZE))
3216                         return -EFAULT;
3217                 for (i = 0; i < SI_EXPANSION_SIZE; i++) {
3218                         if (buf[i] != 0)
3219                                 return -E2BIG;
3220                 }
3221         }
3222         return 0;
3223 }
3224 
3225 static int __copy_siginfo_from_user(int signo, kernel_siginfo_t *to,
3226                                     const siginfo_t __user *from)
3227 {
3228         if (copy_from_user(to, from, sizeof(struct kernel_siginfo)))
3229                 return -EFAULT;
3230         to->si_signo = signo;
3231         return post_copy_siginfo_from_user(to, from);
3232 }
3233 
3234 int copy_siginfo_from_user(kernel_siginfo_t *to, const siginfo_t __user *from)
3235 {
3236         if (copy_from_user(to, from, sizeof(struct kernel_siginfo)))
3237                 return -EFAULT;
3238         return post_copy_siginfo_from_user(to, from);
3239 }
3240 
3241 #ifdef CONFIG_COMPAT
3242 int copy_siginfo_to_user32(struct compat_siginfo __user *to,
3243                            const struct kernel_siginfo *from)
3244 #if defined(CONFIG_X86_X32_ABI) || defined(CONFIG_IA32_EMULATION)
3245 {
3246         return __copy_siginfo_to_user32(to, from, in_x32_syscall());
3247 }
3248 int __copy_siginfo_to_user32(struct compat_siginfo __user *to,
3249                              const struct kernel_siginfo *from, bool x32_ABI)
3250 #endif
3251 {
3252         struct compat_siginfo new;
3253         memset(&new, 0, sizeof(new));
3254 
3255         new.si_signo = from->si_signo;
3256         new.si_errno = from->si_errno;
3257         new.si_code  = from->si_code;
3258         switch(siginfo_layout(from->si_signo, from->si_code)) {
3259         case SIL_KILL:
3260                 new.si_pid = from->si_pid;
3261                 new.si_uid = from->si_uid;
3262                 break;
3263         case SIL_TIMER:
3264                 new.si_tid     = from->si_tid;
3265                 new.si_overrun = from->si_overrun;
3266                 new.si_int     = from->si_int;
3267                 break;
3268         case SIL_POLL:
3269                 new.si_band = from->si_band;
3270                 new.si_fd   = from->si_fd;
3271                 break;
3272         case SIL_FAULT:
3273                 new.si_addr = ptr_to_compat(from->si_addr);
3274 #ifdef __ARCH_SI_TRAPNO
3275                 new.si_trapno = from->si_trapno;
3276 #endif
3277                 break;
3278         case SIL_FAULT_MCEERR:
3279                 new.si_addr = ptr_to_compat(from->si_addr);
3280 #ifdef __ARCH_SI_TRAPNO
3281                 new.si_trapno = from->si_trapno;
3282 #endif
3283                 new.si_addr_lsb = from->si_addr_lsb;
3284                 break;
3285         case SIL_FAULT_BNDERR:
3286                 new.si_addr = ptr_to_compat(from->si_addr);
3287 #ifdef __ARCH_SI_TRAPNO
3288                 new.si_trapno = from->si_trapno;
3289 #endif
3290                 new.si_lower = ptr_to_compat(from->si_lower);
3291                 new.si_upper = ptr_to_compat(from->si_upper);
3292                 break;
3293         case SIL_FAULT_PKUERR:
3294                 new.si_addr = ptr_to_compat(from->si_addr);
3295 #ifdef __ARCH_SI_TRAPNO
3296                 new.si_trapno = from->si_trapno;
3297 #endif
3298                 new.si_pkey = from->si_pkey;
3299                 break;
3300         case SIL_CHLD:
3301                 new.si_pid    = from->si_pid;
3302                 new.si_uid    = from->si_uid;
3303                 new.si_status = from->si_status;
3304 #ifdef CONFIG_X86_X32_ABI
3305                 if (x32_ABI) {
3306                         new._sifields._sigchld_x32._utime = from->si_utime;
3307                         new._sifields._sigchld_x32._stime = from->si_stime;
3308                 } else
3309 #endif
3310                 {
3311                         new.si_utime = from->si_utime;
3312                         new.si_stime = from->si_stime;
3313                 }
3314                 break;
3315         case SIL_RT:
3316                 new.si_pid = from->si_pid;
3317                 new.si_uid = from->si_uid;
3318                 new.si_int = from->si_int;
3319                 break;
3320         case SIL_SYS:
3321                 new.si_call_addr = ptr_to_compat(from->si_call_addr);
3322                 new.si_syscall   = from->si_syscall;
3323                 new.si_arch      = from->si_arch;
3324                 break;
3325         }
3326 
3327         if (copy_to_user(to, &new, sizeof(struct compat_siginfo)))
3328                 return -EFAULT;
3329 
3330         return 0;
3331 }
3332 
3333 static int post_copy_siginfo_from_user32(kernel_siginfo_t *to,
3334                                          const struct compat_siginfo *from)
3335 {
3336         clear_siginfo(to);
3337         to->si_signo = from->si_signo;
3338         to->si_errno = from->si_errno;
3339         to->si_code  = from->si_code;
3340         switch(siginfo_layout(from->si_signo, from->si_code)) {
3341         case SIL_KILL:
3342                 to->si_pid = from->si_pid;
3343                 to->si_uid = from->si_uid;
3344                 break;
3345         case SIL_TIMER:
3346                 to->si_tid     = from->si_tid;
3347                 to->si_overrun = from->si_overrun;
3348                 to->si_int     = from->si_int;
3349                 break;
3350         case SIL_POLL:
3351                 to->si_band = from->si_band;
3352                 to->si_fd   = from->si_fd;
3353                 break;
3354         case SIL_FAULT:
3355                 to->si_addr = compat_ptr(from->si_addr);
3356 #ifdef __ARCH_SI_TRAPNO
3357                 to->si_trapno = from->si_trapno;
3358 #endif
3359                 break;
3360         case SIL_FAULT_MCEERR:
3361                 to->si_addr = compat_ptr(from->si_addr);
3362 #ifdef __ARCH_SI_TRAPNO
3363                 to->si_trapno = from->si_trapno;
3364 #endif
3365                 to->si_addr_lsb = from->si_addr_lsb;
3366                 break;
3367         case SIL_FAULT_BNDERR:
3368                 to->si_addr = compat_ptr(from->si_addr);
3369 #ifdef __ARCH_SI_TRAPNO
3370                 to->si_trapno = from->si_trapno;
3371 #endif
3372                 to->si_lower = compat_ptr(from->si_lower);
3373                 to->si_upper = compat_ptr(from->si_upper);
3374                 break;
3375         case SIL_FAULT_PKUERR:
3376                 to->si_addr = compat_ptr(from->si_addr);
3377 #ifdef __ARCH_SI_TRAPNO
3378                 to->si_trapno = from->si_trapno;
3379 #endif
3380                 to->si_pkey = from->si_pkey;
3381                 break;
3382         case SIL_CHLD:
3383                 to->si_pid    = from->si_pid;
3384                 to->si_uid    = from->si_uid;
3385                 to->si_status = from->si_status;
3386 #ifdef CONFIG_X86_X32_ABI
3387                 if (in_x32_syscall()) {
3388                         to->si_utime = from->_sifields._sigchld_x32._utime;
3389                         to->si_stime = from->_sifields._sigchld_x32._stime;
3390                 } else
3391 #endif
3392                 {
3393                         to->si_utime = from->si_utime;
3394                         to->si_stime = from->si_stime;
3395                 }
3396                 break;
3397         case SIL_RT:
3398                 to->si_pid = from->si_pid;
3399                 to->si_uid = from->si_uid;
3400                 to->si_int = from->si_int;
3401                 break;
3402         case SIL_SYS:
3403                 to->si_call_addr = compat_ptr(from->si_call_addr);
3404                 to->si_syscall   = from->si_syscall;
3405                 to->si_arch      = from->si_arch;
3406                 break;
3407         }
3408         return 0;
3409 }
3410 
3411 static int __copy_siginfo_from_user32(int signo, struct kernel_siginfo *to,
3412                                       const struct compat_siginfo __user *ufrom)
3413 {
3414         struct compat_siginfo from;
3415 
3416         if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
3417                 return -EFAULT;
3418 
3419         from.si_signo = signo;
3420         return post_copy_siginfo_from_user32(to, &from);
3421 }
3422 
3423 int copy_siginfo_from_user32(struct kernel_siginfo *to,
3424                              const struct compat_siginfo __user *ufrom)
3425 {
3426         struct compat_siginfo from;
3427 
3428         if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
3429                 return -EFAULT;
3430 
3431         return post_copy_siginfo_from_user32(to, &from);
3432 }
3433 #endif /* CONFIG_COMPAT */
3434 
3435 /**
3436  *  do_sigtimedwait - wait for queued signals specified in @which
3437  *  @which: queued signals to wait for
3438  *  @info: if non-null, the signal's siginfo is returned here
3439  *  @ts: upper bound on process time suspension
3440  */
3441 static int do_sigtimedwait(const sigset_t *which, kernel_siginfo_t *info,
3442                     const struct timespec64 *ts)
3443 {
3444         ktime_t *to = NULL, timeout = KTIME_MAX;
3445         struct task_struct *tsk = current;
3446         sigset_t mask = *which;
3447         int sig, ret = 0;
3448 
3449         if (ts) {
3450                 if (!timespec64_valid(ts))
3451                         return -EINVAL;
3452                 timeout = timespec64_to_ktime(*ts);
3453                 to = &timeout;
3454         }
3455 
3456         /*
3457          * Invert the set of allowed signals to get those we want to block.
3458          */
3459         sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
3460         signotset(&mask);
3461 
3462         spin_lock_irq(&tsk->sighand->siglock);
3463         sig = dequeue_signal(tsk, &mask, info);
3464         if (!sig && timeout) {
3465                 /*
3466                  * None ready, temporarily unblock those we're interested
3467                  * while we are sleeping in so that we'll be awakened when
3468                  * they arrive. Unblocking is always fine, we can avoid
3469                  * set_current_blocked().
3470                  */
3471                 tsk->real_blocked = tsk->blocked;
3472                 sigandsets(&tsk->blocked, &tsk->blocked, &mask);
3473                 recalc_sigpending();
3474                 spin_unlock_irq(&tsk->sighand->siglock);
3475 
3476                 __set_current_state(TASK_INTERRUPTIBLE);
3477                 ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns,
3478                                                          HRTIMER_MODE_REL);
3479                 spin_lock_irq(&tsk->sighand->siglock);
3480                 __set_task_blocked(tsk, &tsk->real_blocked);
3481                 sigemptyset(&tsk->real_blocked);
3482                 sig = dequeue_signal(tsk, &mask, info);
3483         }
3484         spin_unlock_irq(&tsk->sighand->siglock);
3485 
3486         if (sig)
3487                 return sig;
3488         return ret ? -EINTR : -EAGAIN;
3489 }
3490 
3491 /**
3492  *  sys_rt_sigtimedwait - synchronously wait for queued signals specified
3493  *                      in @uthese
3494  *  @uthese: queued signals to wait for
3495  *  @uinfo: if non-null, the signal's siginfo is returned here
3496  *  @uts: upper bound on process time suspension
3497  *  @sigsetsize: size of sigset_t type
3498  */
3499 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
3500                 siginfo_t __user *, uinfo,
3501                 const struct __kernel_timespec __user *, uts,
3502                 size_t, sigsetsize)
3503 {
3504         sigset_t these;
3505         struct timespec64 ts;
3506         kernel_siginfo_t info;
3507         int ret;
3508 
3509         /* XXX: Don't preclude handling different sized sigset_t's.  */
3510         if (sigsetsize != sizeof(sigset_t))
3511                 return -EINVAL;
3512 
3513         if (copy_from_user(&these, uthese, sizeof(these)))
3514                 return -EFAULT;
3515 
3516         if (uts) {
3517                 if (get_timespec64(&ts, uts))
3518                         return -EFAULT;
3519         }
3520 
3521         ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
3522 
3523         if (ret > 0 && uinfo) {
3524                 if (copy_siginfo_to_user(uinfo, &info))
3525                         ret = -EFAULT;
3526         }
3527 
3528         return ret;
3529 }
3530 
3531 #ifdef CONFIG_COMPAT_32BIT_TIME
3532 SYSCALL_DEFINE4(rt_sigtimedwait_time32, const sigset_t __user *, uthese,
3533                 siginfo_t __user *, uinfo,
3534                 const struct old_timespec32 __user *, uts,
3535                 size_t, sigsetsize)
3536 {
3537         sigset_t these;
3538         struct timespec64 ts;
3539         kernel_siginfo_t info;
3540         int ret;
3541 
3542         if (sigsetsize != sizeof(sigset_t))
3543                 return -EINVAL;
3544 
3545         if (copy_from_user(&these, uthese, sizeof(these)))
3546                 return -EFAULT;
3547 
3548         if (uts) {
3549                 if (get_old_timespec32(&ts, uts))
3550                         return -EFAULT;
3551         }
3552 
3553         ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
3554 
3555         if (ret > 0 && uinfo) {
3556                 if (copy_siginfo_to_user(uinfo, &info))
3557                         ret = -EFAULT;
3558         }
3559 
3560         return ret;
3561 }
3562 #endif
3563 
3564 #ifdef CONFIG_COMPAT
3565 COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time64, compat_sigset_t __user *, uthese,
3566                 struct compat_siginfo __user *, uinfo,
3567                 struct __kernel_timespec __user *, uts, compat_size_t, sigsetsize)
3568 {
3569         sigset_t s;
3570         struct timespec64 t;
3571         kernel_siginfo_t info;
3572         long ret;
3573 
3574         if (sigsetsize != sizeof(sigset_t))
3575                 return -EINVAL;
3576 
3577         if (get_compat_sigset(&s, uthese))
3578                 return -EFAULT;
3579 
3580         if (uts) {
3581                 if (get_timespec64(&t, uts))
3582                         return -EFAULT;
3583         }
3584 
3585         ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
3586 
3587         if (ret > 0 && uinfo) {
3588                 if (copy_siginfo_to_user32(uinfo, &info))
3589                         ret = -EFAULT;
3590         }
3591 
3592         return ret;
3593 }
3594 
3595 #ifdef CONFIG_COMPAT_32BIT_TIME
3596 COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time32, compat_sigset_t __user *, uthese,
3597                 struct compat_siginfo __user *, uinfo,
3598                 struct old_timespec32 __user *, uts, compat_size_t, sigsetsize)
3599 {
3600         sigset_t s;
3601         struct timespec64 t;
3602         kernel_siginfo_t info;
3603         long ret;
3604 
3605         if (sigsetsize != sizeof(sigset_t))
3606                 return -EINVAL;
3607 
3608         if (get_compat_sigset(&s, uthese))
3609                 return -EFAULT;
3610 
3611         if (uts) {
3612                 if (get_old_timespec32(&t, uts))
3613                         return -EFAULT;
3614         }
3615 
3616         ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
3617 
3618         if (ret > 0 && uinfo) {
3619                 if (copy_siginfo_to_user32(uinfo, &info))
3620                         ret = -EFAULT;
3621         }
3622 
3623         return ret;
3624 }
3625 #endif
3626 #endif
3627 
3628 static inline void prepare_kill_siginfo(int sig, struct kernel_siginfo *info)
3629 {
3630         clear_siginfo(info);
3631         info->si_signo = sig;
3632         info->si_errno = 0;
3633         info->si_code = SI_USER;
3634         info->si_pid = task_tgid_vnr(current);
3635         info->si_uid = from_kuid_munged(current_user_ns(), current_uid());
3636 }
3637 
3638 /**
3639  *  sys_kill - send a signal to a process
3640  *  @pid: the PID of the process
3641  *  @sig: signal to be sent
3642  */
3643 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
3644 {
3645         struct kernel_siginfo info;
3646         if (ccs_kill_permission(pid, sig))
3647                 return -EPERM;
3648 
3649         prepare_kill_siginfo(sig, &info);
3650 
3651         return kill_something_info(sig, &info, pid);
3652 }
3653 
3654 /*
3655  * Verify that the signaler and signalee either are in the same pid namespace
3656  * or that the signaler's pid namespace is an ancestor of the signalee's pid
3657  * namespace.
3658  */
3659 static bool access_pidfd_pidns(struct pid *pid)
3660 {
3661         struct pid_namespace *active = task_active_pid_ns(current);
3662         struct pid_namespace *p = ns_of_pid(pid);
3663 
3664         for (;;) {
3665                 if (!p)
3666                         return false;
3667                 if (p == active)
3668                         break;
3669                 p = p->parent;
3670         }
3671 
3672         return true;
3673 }
3674 
3675 static int copy_siginfo_from_user_any(kernel_siginfo_t *kinfo, siginfo_t *info)
3676 {
3677 #ifdef CONFIG_COMPAT
3678         /*
3679          * Avoid hooking up compat syscalls and instead handle necessary
3680          * conversions here. Note, this is a stop-gap measure and should not be
3681          * considered a generic solution.
3682          */
3683         if (in_compat_syscall())
3684                 return copy_siginfo_from_user32(
3685                         kinfo, (struct compat_siginfo __user *)info);
3686 #endif
3687         return copy_siginfo_from_user(kinfo, info);
3688 }
3689 
3690 static struct pid *pidfd_to_pid(const struct file *file)
3691 {
3692         struct pid *pid;
3693 
3694         pid = pidfd_pid(file);
3695         if (!IS_ERR(pid))
3696                 return pid;
3697 
3698         return tgid_pidfd_to_pid(file);
3699 }
3700 
3701 /**
3702  * sys_pidfd_send_signal - Signal a process through a pidfd
3703  * @pidfd:  file descriptor of the process
3704  * @sig:    signal to send
3705  * @info:   signal info
3706  * @flags:  future flags
3707  *
3708  * The syscall currently only signals via PIDTYPE_PID which covers
3709  * kill(<positive-pid>, <signal>. It does not signal threads or process
3710  * groups.
3711  * In order to extend the syscall to threads and process groups the @flags
3712  * argument should be used. In essence, the @flags argument will determine
3713  * what is signaled and not the file descriptor itself. Put in other words,
3714  * grouping is a property of the flags argument not a property of the file
3715  * descriptor.
3716  *
3717  * Return: 0 on success, negative errno on failure
3718  */
3719 SYSCALL_DEFINE4(pidfd_send_signal, int, pidfd, int, sig,
3720                 siginfo_t __user *, info, unsigned int, flags)
3721 {
3722         int ret;
3723         struct fd f;
3724         struct pid *pid;
3725         kernel_siginfo_t kinfo;
3726 
3727         /* Enforce flags be set to 0 until we add an extension. */
3728         if (flags)
3729                 return -EINVAL;
3730 
3731         f = fdget(pidfd);
3732         if (!f.file)
3733                 return -EBADF;
3734 
3735         /* Is this a pidfd? */
3736         pid = pidfd_to_pid(f.file);
3737         if (IS_ERR(pid)) {
3738                 ret = PTR_ERR(pid);
3739                 goto err;
3740         }
3741 
3742         ret = -EINVAL;
3743         if (!access_pidfd_pidns(pid))
3744                 goto err;
3745 
3746         {
3747                 struct task_struct *task;
3748                 int id = 0;
3749 
3750                 rcu_read_lock();
3751                 task = pid_task(pid, PIDTYPE_PID);
3752                 if (task)
3753                         id = task_pid_vnr(task);
3754                 rcu_read_unlock();
3755                 if (task && ccs_kill_permission(id, sig)) {
3756                         ret = -EPERM;
3757                         goto err;
3758                 }
3759         }
3760 
3761         if (info) {
3762                 ret = copy_siginfo_from_user_any(&kinfo, info);
3763                 if (unlikely(ret))
3764                         goto err;
3765 
3766                 ret = -EINVAL;
3767                 if (unlikely(sig != kinfo.si_signo))
3768                         goto err;
3769 
3770                 /* Only allow sending arbitrary signals to yourself. */
3771                 ret = -EPERM;
3772                 if ((task_pid(current) != pid) &&
3773                     (kinfo.si_code >= 0 || kinfo.si_code == SI_TKILL))
3774                         goto err;
3775         } else {
3776                 prepare_kill_siginfo(sig, &kinfo);
3777         }
3778 
3779         ret = kill_pid_info(sig, &kinfo, pid);
3780 
3781 err:
3782         fdput(f);
3783         return ret;
3784 }
3785 
3786 static int
3787 do_send_specific(pid_t tgid, pid_t pid, int sig, struct kernel_siginfo *info)
3788 {
3789         struct task_struct *p;
3790         int error = -ESRCH;
3791 
3792         rcu_read_lock();
3793         p = find_task_by_vpid(pid);
3794         if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
3795                 error = check_kill_permission(sig, info, p);
3796                 /*
3797                  * The null signal is a permissions and process existence
3798                  * probe.  No signal is actually delivered.
3799                  */
3800                 if (!error && sig) {
3801                         error = do_send_sig_info(sig, info, p, PIDTYPE_PID);
3802                         /*
3803                          * If lock_task_sighand() failed we pretend the task
3804                          * dies after receiving the signal. The window is tiny,
3805                          * and the signal is private anyway.
3806                          */
3807                         if (unlikely(error == -ESRCH))
3808                                 error = 0;
3809                 }
3810         }
3811         rcu_read_unlock();
3812 
3813         return error;
3814 }
3815 
3816 static int do_tkill(pid_t tgid, pid_t pid, int sig)
3817 {
3818         struct kernel_siginfo info;
3819 
3820         clear_siginfo(&info);
3821         info.si_signo = sig;
3822         info.si_errno = 0;
3823         info.si_code = SI_TKILL;
3824         info.si_pid = task_tgid_vnr(current);
3825         info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
3826 
3827         return do_send_specific(tgid, pid, sig, &info);
3828 }
3829 
3830 /**
3831  *  sys_tgkill - send signal to one specific thread
3832  *  @tgid: the thread group ID of the thread
3833  *  @pid: the PID of the thread
3834  *  @sig: signal to be sent
3835  *
3836  *  This syscall also checks the @tgid and returns -ESRCH even if the PID
3837  *  exists but it's not belonging to the target process anymore. This
3838  *  method solves the problem of threads exiting and PIDs getting reused.
3839  */
3840 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
3841 {
3842         /* This is only valid for single tasks */
3843         if (pid <= 0 || tgid <= 0)
3844                 return -EINVAL;
3845         if (ccs_tgkill_permission(tgid, pid, sig))
3846                 return -EPERM;
3847 
3848         return do_tkill(tgid, pid, sig);
3849 }
3850 
3851 /**
3852  *  sys_tkill - send signal to one specific task
3853  *  @pid: the PID of the task
3854  *  @sig: signal to be sent
3855  *
3856  *  Send a signal to only one task, even if it's a CLONE_THREAD task.
3857  */
3858 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
3859 {
3860         /* This is only valid for single tasks */
3861         if (pid <= 0)
3862                 return -EINVAL;
3863         if (ccs_tkill_permission(pid, sig))
3864                 return -EPERM;
3865 
3866         return do_tkill(0, pid, sig);
3867 }
3868 
3869 static int do_rt_sigqueueinfo(pid_t pid, int sig, kernel_siginfo_t *info)
3870 {
3871         /* Not even root can pretend to send signals from the kernel.
3872          * Nor can they impersonate a kill()/tgkill(), which adds source info.
3873          */
3874         if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3875             (task_pid_vnr(current) != pid))
3876                 return -EPERM;
3877         if (ccs_sigqueue_permission(pid, sig))
3878                 return -EPERM;
3879 
3880         /* POSIX.1b doesn't mention process groups.  */
3881         return kill_proc_info(sig, info, pid);
3882 }
3883 
3884 /**
3885  *  sys_rt_sigqueueinfo - send signal information to a signal
3886  *  @pid: the PID of the thread
3887  *  @sig: signal to be sent
3888  *  @uinfo: signal info to be sent
3889  */
3890 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
3891                 siginfo_t __user *, uinfo)
3892 {
3893         kernel_siginfo_t info;
3894         int ret = __copy_siginfo_from_user(sig, &info, uinfo);
3895         if (unlikely(ret))
3896                 return ret;
3897         return do_rt_sigqueueinfo(pid, sig, &info);
3898 }
3899 
3900 #ifdef CONFIG_COMPAT
3901 COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
3902                         compat_pid_t, pid,
3903                         int, sig,
3904                         struct compat_siginfo __user *, uinfo)
3905 {
3906         kernel_siginfo_t info;
3907         int ret = __copy_siginfo_from_user32(sig, &info, uinfo);
3908         if (unlikely(ret))
3909                 return ret;
3910         return do_rt_sigqueueinfo(pid, sig, &info);
3911 }
3912 #endif
3913 
3914 static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, kernel_siginfo_t *info)
3915 {
3916         /* This is only valid for single tasks */
3917         if (pid <= 0 || tgid <= 0)
3918                 return -EINVAL;
3919 
3920         /* Not even root can pretend to send signals from the kernel.
3921          * Nor can they impersonate a kill()/tgkill(), which adds source info.
3922          */
3923         if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3924             (task_pid_vnr(current) != pid))
3925                 return -EPERM;
3926         if (ccs_tgsigqueue_permission(tgid, pid, sig))
3927                 return -EPERM;
3928 
3929         return do_send_specific(tgid, pid, sig, info);
3930 }
3931 
3932 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
3933                 siginfo_t __user *, uinfo)
3934 {
3935         kernel_siginfo_t info;
3936         int ret = __copy_siginfo_from_user(sig, &info, uinfo);
3937         if (unlikely(ret))
3938                 return ret;
3939         return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3940 }
3941 
3942 #ifdef CONFIG_COMPAT
3943 COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
3944                         compat_pid_t, tgid,
3945                         compat_pid_t, pid,
3946                         int, sig,
3947                         struct compat_siginfo __user *, uinfo)
3948 {
3949         kernel_siginfo_t info;
3950         int ret = __copy_siginfo_from_user32(sig, &info, uinfo);
3951         if (unlikely(ret))
3952                 return ret;
3953         return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3954 }
3955 #endif
3956 
3957 /*
3958  * For kthreads only, must not be used if cloned with CLONE_SIGHAND
3959  */
3960 void kernel_sigaction(int sig, __sighandler_t action)
3961 {
3962         spin_lock_irq(&current->sighand->siglock);
3963         current->sighand->action[sig - 1].sa.sa_handler = action;
3964         if (action == SIG_IGN) {
3965                 sigset_t mask;
3966 
3967                 sigemptyset(&mask);
3968                 sigaddset(&mask, sig);
3969 
3970                 flush_sigqueue_mask(&mask, &current->signal->shared_pending);
3971                 flush_sigqueue_mask(&mask, &current->pending);
3972                 recalc_sigpending();
3973         }
3974         spin_unlock_irq(&current->sighand->siglock);
3975 }
3976 EXPORT_SYMBOL(kernel_sigaction);
3977 
3978 void __weak sigaction_compat_abi(struct k_sigaction *act,
3979                 struct k_sigaction *oact)
3980 {
3981 }
3982 
3983 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
3984 {
3985         struct task_struct *p = current, *t;
3986         struct k_sigaction *k;
3987         sigset_t mask;
3988 
3989         if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
3990                 return -EINVAL;
3991 
3992         k = &p->sighand->action[sig-1];
3993 
3994         spin_lock_irq(&p->sighand->siglock);
3995         if (oact)
3996                 *oact = *k;
3997 
3998         sigaction_compat_abi(act, oact);
3999 
4000         if (act) {
4001                 sigdelsetmask(&act->sa.sa_mask,
4002                               sigmask(SIGKILL) | sigmask(SIGSTOP));
4003                 *k = *act;
4004                 /*
4005                  * POSIX 3.3.1.3:
4006                  *  "Setting a signal action to SIG_IGN for a signal that is
4007                  *   pending shall cause the pending signal to be discarded,
4008                  *   whether or not it is blocked."
4009                  *
4010                  *  "Setting a signal action to SIG_DFL for a signal that is
4011                  *   pending and whose default action is to ignore the signal
4012                  *   (for example, SIGCHLD), shall cause the pending signal to
4013                  *   be discarded, whether or not it is blocked"
4014                  */
4015                 if (sig_handler_ignored(sig_handler(p, sig), sig)) {
4016                         sigemptyset(&mask);
4017                         sigaddset(&mask, sig);
4018                         flush_sigqueue_mask(&mask, &p->signal->shared_pending);
4019                         for_each_thread(p, t)
4020                                 flush_sigqueue_mask(&mask, &t->pending);
4021                 }
4022         }
4023 
4024         spin_unlock_irq(&p->sighand->siglock);
4025         return 0;
4026 }
4027 
4028 static int
4029 do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp,
4030                 size_t min_ss_size)
4031 {
4032         struct task_struct *t = current;
4033 
4034         if (oss) {
4035                 memset(oss, 0, sizeof(stack_t));
4036                 oss->ss_sp = (void __user *) t->sas_ss_sp;
4037                 oss->ss_size = t->sas_ss_size;
4038                 oss->ss_flags = sas_ss_flags(sp) |
4039                         (current->sas_ss_flags & SS_FLAG_BITS);
4040         }
4041 
4042         if (ss) {
4043                 void __user *ss_sp = ss->ss_sp;
4044                 size_t ss_size = ss->ss_size;
4045                 unsigned ss_flags = ss->ss_flags;
4046                 int ss_mode;
4047 
4048                 if (unlikely(on_sig_stack(sp)))
4049                         return -EPERM;
4050 
4051                 ss_mode = ss_flags & ~SS_FLAG_BITS;
4052                 if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
4053                                 ss_mode != 0))
4054                         return -EINVAL;
4055 
4056                 if (ss_mode == SS_DISABLE) {
4057                         ss_size = 0;
4058                         ss_sp = NULL;
4059                 } else {
4060                         if (unlikely(ss_size < min_ss_size))
4061                                 return -ENOMEM;
4062                 }
4063 
4064                 t->sas_ss_sp = (unsigned long) ss_sp;
4065                 t->sas_ss_size = ss_size;
4066                 t->sas_ss_flags = ss_flags;
4067         }
4068         return 0;
4069 }
4070 
4071 SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
4072 {
4073         stack_t new, old;
4074         int err;
4075         if (uss && copy_from_user(&new, uss, sizeof(stack_t)))
4076                 return -EFAULT;
4077         err = do_sigaltstack(uss ? &new : NULL, uoss ? &old : NULL,
4078                               current_user_stack_pointer(),
4079                               MINSIGSTKSZ);
4080         if (!err && uoss && copy_to_user(uoss, &old, sizeof(stack_t)))
4081                 err = -EFAULT;
4082         return err;
4083 }
4084 
4085 int restore_altstack(const stack_t __user *uss)
4086 {
4087         stack_t new;
4088         if (copy_from_user(&new, uss, sizeof(stack_t)))
4089                 return -EFAULT;
4090         (void)do_sigaltstack(&new, NULL, current_user_stack_pointer(),
4091                              MINSIGSTKSZ);
4092         /* squash all but EFAULT for now */
4093         return 0;
4094 }
4095 
4096 int __save_altstack(stack_t __user *uss, unsigned long sp)
4097 {
4098         struct task_struct *t = current;
4099         int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
4100                 __put_user(t->sas_ss_flags, &uss->ss_flags) |
4101                 __put_user(t->sas_ss_size, &uss->ss_size);
4102         if (err)
4103                 return err;
4104         if (t->sas_ss_flags & SS_AUTODISARM)
4105                 sas_ss_reset(t);
4106         return 0;
4107 }
4108 
4109 #ifdef CONFIG_COMPAT
4110 static int do_compat_sigaltstack(const compat_stack_t __user *uss_ptr,
4111                                  compat_stack_t __user *uoss_ptr)
4112 {
4113         stack_t uss, uoss;
4114         int ret;
4115 
4116         if (uss_ptr) {
4117                 compat_stack_t uss32;
4118                 if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
4119                         return -EFAULT;
4120                 uss.ss_sp = compat_ptr(uss32.ss_sp);
4121                 uss.ss_flags = uss32.ss_flags;
4122                 uss.ss_size = uss32.ss_size;
4123         }
4124         ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss,
4125                              compat_user_stack_pointer(),
4126                              COMPAT_MINSIGSTKSZ);
4127         if (ret >= 0 && uoss_ptr)  {
4128                 compat_stack_t old;
4129                 memset(&old, 0, sizeof(old));
4130                 old.ss_sp = ptr_to_compat(uoss.ss_sp);
4131                 old.ss_flags = uoss.ss_flags;
4132                 old.ss_size = uoss.ss_size;
4133                 if (copy_to_user(uoss_ptr, &old, sizeof(compat_stack_t)))
4134                         ret = -EFAULT;
4135         }
4136         return ret;
4137 }
4138 
4139 COMPAT_SYSCALL_DEFINE2(sigaltstack,
4140                         const compat_stack_t __user *, uss_ptr,
4141                         compat_stack_t __user *, uoss_ptr)
4142 {
4143         return do_compat_sigaltstack(uss_ptr, uoss_ptr);
4144 }
4145 
4146 int compat_restore_altstack(const compat_stack_t __user *uss)
4147 {
4148         int err = do_compat_sigaltstack(uss, NULL);
4149         /* squash all but -EFAULT for now */
4150         return err == -EFAULT ? err : 0;
4151 }
4152 
4153 int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
4154 {
4155         int err;
4156         struct task_struct *t = current;
4157         err = __put_user(ptr_to_compat((void __user *)t->sas_ss_sp),
4158                          &uss->ss_sp) |
4159                 __put_user(t->sas_ss_flags, &uss->ss_flags) |
4160                 __put_user(t->sas_ss_size, &uss->ss_size);
4161         if (err)
4162                 return err;
4163         if (t->sas_ss_flags & SS_AUTODISARM)
4164                 sas_ss_reset(t);
4165         return 0;
4166 }
4167 #endif
4168 
4169 #ifdef __ARCH_WANT_SYS_SIGPENDING
4170 
4171 /**
4172  *  sys_sigpending - examine pending signals
4173  *  @uset: where mask of pending signal is returned
4174  */
4175 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, uset)
4176 {
4177         sigset_t set;
4178 
4179         if (sizeof(old_sigset_t) > sizeof(*uset))
4180                 return -EINVAL;
4181 
4182         do_sigpending(&set);
4183 
4184         if (copy_to_user(uset, &set, sizeof(old_sigset_t)))
4185                 return -EFAULT;
4186 
4187         return 0;
4188 }
4189 
4190 #ifdef CONFIG_COMPAT
4191 COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set32)
4192 {
4193         sigset_t set;
4194 
4195         do_sigpending(&set);
4196 
4197         return put_user(set.sig[0], set32);
4198 }
4199 #endif
4200 
4201 #endif
4202 
4203 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
4204 /**
4205  *  sys_sigprocmask - examine and change blocked signals
4206  *  @how: whether to add, remove, or set signals
4207  *  @nset: signals to add or remove (if non-null)
4208  *  @oset: previous value of signal mask if non-null
4209  *
4210  * Some platforms have their own version with special arguments;
4211  * others support only sys_rt_sigprocmask.
4212  */
4213 
4214 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
4215                 old_sigset_t __user *, oset)
4216 {
4217         old_sigset_t old_set, new_set;
4218         sigset_t new_blocked;
4219 
4220         old_set = current->blocked.sig[0];
4221 
4222         if (nset) {
4223                 if (copy_from_user(&new_set, nset, sizeof(*nset)))
4224                         return -EFAULT;
4225 
4226                 new_blocked = current->blocked;
4227 
4228                 switch (how) {
4229                 case SIG_BLOCK:
4230                         sigaddsetmask(&new_blocked, new_set);
4231                         break;
4232                 case SIG_UNBLOCK:
4233                         sigdelsetmask(&new_blocked, new_set);
4234                         break;
4235                 case SIG_SETMASK:
4236                         new_blocked.sig[0] = new_set;
4237                         break;
4238                 default:
4239                         return -EINVAL;
4240                 }
4241 
4242                 set_current_blocked(&new_blocked);
4243         }
4244 
4245         if (oset) {
4246                 if (copy_to_user(oset, &old_set, sizeof(*oset)))
4247                         return -EFAULT;
4248         }
4249 
4250         return 0;
4251 }
4252 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
4253 
4254 #ifndef CONFIG_ODD_RT_SIGACTION
4255 /**
4256  *  sys_rt_sigaction - alter an action taken by a process
4257  *  @sig: signal to be sent
4258  *  @act: new sigaction
4259  *  @oact: used to save the previous sigaction
4260  *  @sigsetsize: size of sigset_t type
4261  */
4262 SYSCALL_DEFINE4(rt_sigaction, int, sig,
4263                 const struct sigaction __user *, act,
4264                 struct sigaction __user *, oact,
4265                 size_t, sigsetsize)
4266 {
4267         struct k_sigaction new_sa, old_sa;
4268         int ret;
4269 
4270         /* XXX: Don't preclude handling different sized sigset_t's.  */
4271         if (sigsetsize != sizeof(sigset_t))
4272                 return -EINVAL;
4273 
4274         if (act && copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
4275                 return -EFAULT;
4276 
4277         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
4278         if (ret)
4279                 return ret;
4280 
4281         if (oact && copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
4282                 return -EFAULT;
4283 
4284         return 0;
4285 }
4286 #ifdef CONFIG_COMPAT
4287 COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
4288                 const struct compat_sigaction __user *, act,
4289                 struct compat_sigaction __user *, oact,
4290                 compat_size_t, sigsetsize)
4291 {
4292         struct k_sigaction new_ka, old_ka;
4293 #ifdef __ARCH_HAS_SA_RESTORER
4294         compat_uptr_t restorer;
4295 #endif
4296         int ret;
4297 
4298         /* XXX: Don't preclude handling different sized sigset_t's.  */
4299         if (sigsetsize != sizeof(compat_sigset_t))
4300                 return -EINVAL;
4301 
4302         if (act) {
4303                 compat_uptr_t handler;
4304                 ret = get_user(handler, &act->sa_handler);
4305                 new_ka.sa.sa_handler = compat_ptr(handler);
4306 #ifdef __ARCH_HAS_SA_RESTORER
4307                 ret |= get_user(restorer, &act->sa_restorer);
4308                 new_ka.sa.sa_restorer = compat_ptr(restorer);
4309 #endif
4310                 ret |= get_compat_sigset(&new_ka.sa.sa_mask, &act->sa_mask);
4311                 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
4312                 if (ret)
4313                         return -EFAULT;
4314         }
4315 
4316         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
4317         if (!ret && oact) {
4318                 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), 
4319                                &oact->sa_handler);
4320                 ret |= put_compat_sigset(&oact->sa_mask, &old_ka.sa.sa_mask,
4321                                          sizeof(oact->sa_mask));
4322                 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
4323 #ifdef __ARCH_HAS_SA_RESTORER
4324                 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
4325                                 &oact->sa_restorer);
4326 #endif
4327         }
4328         return ret;
4329 }
4330 #endif
4331 #endif /* !CONFIG_ODD_RT_SIGACTION */
4332 
4333 #ifdef CONFIG_OLD_SIGACTION
4334 SYSCALL_DEFINE3(sigaction, int, sig,
4335                 const struct old_sigaction __user *, act,
4336                 struct old_sigaction __user *, oact)
4337 {
4338         struct k_sigaction new_ka, old_ka;
4339         int ret;
4340 
4341         if (act) {
4342                 old_sigset_t mask;
4343                 if (!access_ok(act, sizeof(*act)) ||
4344                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
4345                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
4346                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
4347                     __get_user(mask, &act->sa_mask))
4348                         return -EFAULT;
4349 #ifdef __ARCH_HAS_KA_RESTORER
4350                 new_ka.ka_restorer = NULL;
4351 #endif
4352                 siginitset(&new_ka.sa.sa_mask, mask);
4353         }
4354 
4355         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
4356 
4357         if (!ret && oact) {
4358                 if (!access_ok(oact, sizeof(*oact)) ||
4359                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
4360                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
4361                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
4362                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
4363                         return -EFAULT;
4364         }
4365 
4366         return ret;
4367 }
4368 #endif
4369 #ifdef CONFIG_COMPAT_OLD_SIGACTION
4370 COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
4371                 const struct compat_old_sigaction __user *, act,
4372                 struct compat_old_sigaction __user *, oact)
4373 {
4374         struct k_sigaction new_ka, old_ka;
4375         int ret;
4376         compat_old_sigset_t mask;
4377         compat_uptr_t handler, restorer;
4378 
4379         if (act) {
4380                 if (!access_ok(act, sizeof(*act)) ||
4381                     __get_user(handler, &act->sa_handler) ||
4382                     __get_user(restorer, &act->sa_restorer) ||
4383                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
4384                     __get_user(mask, &act->sa_mask))
4385                         return -EFAULT;
4386 
4387 #ifdef __ARCH_HAS_KA_RESTORER
4388                 new_ka.ka_restorer = NULL;
4389 #endif
4390                 new_ka.sa.sa_handler = compat_ptr(handler);
4391                 new_ka.sa.sa_restorer = compat_ptr(restorer);
4392                 siginitset(&new_ka.sa.sa_mask, mask);
4393         }
4394 
4395         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
4396 
4397         if (!ret && oact) {
4398                 if (!access_ok(oact, sizeof(*oact)) ||
4399                     __put_user(ptr_to_compat(old_ka.sa.sa_handler),
4400                                &oact->sa_handler) ||
4401                     __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
4402                                &oact->sa_restorer) ||
4403                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
4404                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
4405                         return -EFAULT;
4406         }
4407         return ret;
4408 }
4409 #endif
4410 
4411 #ifdef CONFIG_SGETMASK_SYSCALL
4412 
4413 /*
4414  * For backwards compatibility.  Functionality superseded by sigprocmask.
4415  */
4416 SYSCALL_DEFINE0(sgetmask)
4417 {
4418         /* SMP safe */
4419         return current->blocked.sig[0];
4420 }
4421 
4422 SYSCALL_DEFINE1(ssetmask, int, newmask)
4423 {
4424         int old = current->blocked.sig[0];
4425         sigset_t newset;
4426 
4427         siginitset(&newset, newmask);
4428         set_current_blocked(&newset);
4429 
4430         return old;
4431 }
4432 #endif /* CONFIG_SGETMASK_SYSCALL */
4433 
4434 #ifdef __ARCH_WANT_SYS_SIGNAL
4435 /*
4436  * For backwards compatibility.  Functionality superseded by sigaction.
4437  */
4438 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
4439 {
4440         struct k_sigaction new_sa, old_sa;
4441         int ret;
4442 
4443         new_sa.sa.sa_handler = handler;
4444         new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
4445         sigemptyset(&new_sa.sa.sa_mask);
4446 
4447         ret = do_sigaction(sig, &new_sa, &old_sa);
4448 
4449         return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
4450 }
4451 #endif /* __ARCH_WANT_SYS_SIGNAL */
4452 
4453 #ifdef __ARCH_WANT_SYS_PAUSE
4454 
4455 SYSCALL_DEFINE0(pause)
4456 {
4457         while (!signal_pending(current)) {
4458                 __set_current_state(TASK_INTERRUPTIBLE);
4459                 schedule();
4460         }
4461         return -ERESTARTNOHAND;
4462 }
4463 
4464 #endif
4465 
4466 static int sigsuspend(sigset_t *set)
4467 {
4468         current->saved_sigmask = current->blocked;
4469         set_current_blocked(set);
4470 
4471         while (!signal_pending(current)) {
4472                 __set_current_state(TASK_INTERRUPTIBLE);
4473                 schedule();
4474         }
4475         set_restore_sigmask();
4476         return -ERESTARTNOHAND;
4477 }
4478 
4479 /**
4480  *  sys_rt_sigsuspend - replace the signal mask for a value with the
4481  *      @unewset value until a signal is received
4482  *  @unewset: new signal mask value
4483  *  @sigsetsize: size of sigset_t type
4484  */
4485 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
4486 {
4487         sigset_t newset;
4488 
4489         /* XXX: Don't preclude handling different sized sigset_t's.  */
4490         if (sigsetsize != sizeof(sigset_t))
4491                 return -EINVAL;
4492 
4493         if (copy_from_user(&newset, unewset, sizeof(newset)))
4494                 return -EFAULT;
4495         return sigsuspend(&newset);
4496 }
4497  
4498 #ifdef CONFIG_COMPAT
4499 COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
4500 {
4501         sigset_t newset;
4502 
4503         /* XXX: Don't preclude handling different sized sigset_t's.  */
4504         if (sigsetsize != sizeof(sigset_t))
4505                 return -EINVAL;
4506 
4507         if (get_compat_sigset(&newset, unewset))
4508                 return -EFAULT;
4509         return sigsuspend(&newset);
4510 }
4511 #endif
4512 
4513 #ifdef CONFIG_OLD_SIGSUSPEND
4514 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
4515 {
4516         sigset_t blocked;
4517         siginitset(&blocked, mask);
4518         return sigsuspend(&blocked);
4519 }
4520 #endif
4521 #ifdef CONFIG_OLD_SIGSUSPEND3
4522 SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
4523 {
4524         sigset_t blocked;
4525         siginitset(&blocked, mask);
4526         return sigsuspend(&blocked);
4527 }
4528 #endif
4529 
4530 __weak const char *arch_vma_name(struct vm_area_struct *vma)
4531 {
4532         return NULL;
4533 }
4534 
4535 static inline void siginfo_buildtime_checks(void)
4536 {
4537         BUILD_BUG_ON(sizeof(struct siginfo) != SI_MAX_SIZE);
4538 
4539         /* Verify the offsets in the two siginfos match */
4540 #define CHECK_OFFSET(field) \
4541         BUILD_BUG_ON(offsetof(siginfo_t, field) != offsetof(kernel_siginfo_t, field))
4542 
4543         /* kill */
4544         CHECK_OFFSET(si_pid);
4545         CHECK_OFFSET(si_uid);
4546 
4547         /* timer */
4548         CHECK_OFFSET(si_tid);
4549         CHECK_OFFSET(si_overrun);
4550         CHECK_OFFSET(si_value);
4551 
4552         /* rt */
4553         CHECK_OFFSET(si_pid);
4554         CHECK_OFFSET(si_uid);
4555         CHECK_OFFSET(si_value);
4556 
4557         /* sigchld */
4558         CHECK_OFFSET(si_pid);
4559         CHECK_OFFSET(si_uid);
4560         CHECK_OFFSET(si_status);
4561         CHECK_OFFSET(si_utime);
4562         CHECK_OFFSET(si_stime);
4563 
4564         /* sigfault */
4565         CHECK_OFFSET(si_addr);
4566         CHECK_OFFSET(si_addr_lsb);
4567         CHECK_OFFSET(si_lower);
4568         CHECK_OFFSET(si_upper);
4569         CHECK_OFFSET(si_pkey);
4570 
4571         /* sigpoll */
4572         CHECK_OFFSET(si_band);
4573         CHECK_OFFSET(si_fd);
4574 
4575         /* sigsys */
4576         CHECK_OFFSET(si_call_addr);
4577         CHECK_OFFSET(si_syscall);
4578         CHECK_OFFSET(si_arch);
4579 #undef CHECK_OFFSET
4580 
4581         /* usb asyncio */
4582         BUILD_BUG_ON(offsetof(struct siginfo, si_pid) !=
4583                      offsetof(struct siginfo, si_addr));
4584         if (sizeof(int) == sizeof(void __user *)) {
4585                 BUILD_BUG_ON(sizeof_field(struct siginfo, si_pid) !=
4586                              sizeof(void __user *));
4587         } else {
4588                 BUILD_BUG_ON((sizeof_field(struct siginfo, si_pid) +
4589                               sizeof_field(struct siginfo, si_uid)) !=
4590                              sizeof(void __user *));
4591                 BUILD_BUG_ON(offsetofend(struct siginfo, si_pid) !=
4592                              offsetof(struct siginfo, si_uid));
4593         }
4594 #ifdef CONFIG_COMPAT
4595         BUILD_BUG_ON(offsetof(struct compat_siginfo, si_pid) !=
4596                      offsetof(struct compat_siginfo, si_addr));
4597         BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) !=
4598                      sizeof(compat_uptr_t));
4599         BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) !=
4600                      sizeof_field(struct siginfo, si_pid));
4601 #endif
4602 }
4603 
4604 void __init signals_init(void)
4605 {
4606         siginfo_buildtime_checks();
4607 
4608         sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
4609 }
4610 
4611 #ifdef CONFIG_KGDB_KDB
4612 #include <linux/kdb.h>
4613 /*
4614  * kdb_send_sig - Allows kdb to send signals without exposing
4615  * signal internals.  This function checks if the required locks are
4616  * available before calling the main signal code, to avoid kdb
4617  * deadlocks.
4618  */
4619 void kdb_send_sig(struct task_struct *t, int sig)
4620 {
4621         static struct task_struct *kdb_prev_t;
4622         int new_t, ret;
4623         if (!spin_trylock(&t->sighand->siglock)) {
4624                 kdb_printf("Can't do kill command now.\n"
4625                            "The sigmask lock is held somewhere else in "
4626                            "kernel, try again later\n");
4627                 return;
4628         }
4629         new_t = kdb_prev_t != t;
4630         kdb_prev_t = t;
4631         if (t->state != TASK_RUNNING && new_t) {
4632                 spin_unlock(&t->sighand->siglock);
4633                 kdb_printf("Process is not RUNNING, sending a signal from "
4634                            "kdb risks deadlock\n"
4635                            "on the run queue locks. "
4636                            "The signal has _not_ been sent.\n"
4637                            "Reissue the kill command if you want to risk "
4638                            "the deadlock.\n");
4639                 return;
4640         }
4641         ret = send_signal(sig, SEND_SIG_PRIV, t, PIDTYPE_PID);
4642         spin_unlock(&t->sighand->siglock);
4643         if (ret)
4644                 kdb_printf("Fail to deliver Signal %d to process %d.\n",
4645                            sig, t->pid);
4646         else
4647                 kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
4648 }
4649 #endif  /* CONFIG_KGDB_KDB */
4650 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp