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

TOMOYO Linux Cross Reference
Linux/kernel/signal.c

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

~ [ 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