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

TOMOYO Linux Cross Reference
Linux/kernel/signal.c

Version: ~ [ linux-5.19-rc3 ] ~ [ linux-5.18.5 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.48 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.123 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.199 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.248 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.284 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.319 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ 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.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  linux/kernel/signal.c
  3  *
  4  *  Copyright (C) 1991, 1992  Linus Torvalds
  5  *
  6  *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
  7  *
  8  *  2003-06-02  Jim Houston - Concurrent Computer Corp.
  9  *              Changes to use preallocated sigqueue structures
 10  *              to allow signals to be sent reliably.
 11  */
 12 
 13 #include <linux/slab.h>
 14 #include <linux/export.h>
 15 #include <linux/init.h>
 16 #include <linux/sched.h>
 17 #include <linux/fs.h>
 18 #include <linux/tty.h>
 19 #include <linux/binfmts.h>
 20 #include <linux/coredump.h>
 21 #include <linux/security.h>
 22 #include <linux/syscalls.h>
 23 #include <linux/ptrace.h>
 24 #include <linux/signal.h>
 25 #include <linux/signalfd.h>
 26 #include <linux/ratelimit.h>
 27 #include <linux/tracehook.h>
 28 #include <linux/capability.h>
 29 #include <linux/freezer.h>
 30 #include <linux/pid_namespace.h>
 31 #include <linux/nsproxy.h>
 32 #include <linux/user_namespace.h>
 33 #include <linux/uprobes.h>
 34 #include <linux/compat.h>
 35 #include <linux/cn_proc.h>
 36 #include <linux/compiler.h>
 37 
 38 #define CREATE_TRACE_POINTS
 39 #include <trace/events/signal.h>
 40 
 41 #include <asm/param.h>
 42 #include <asm/uaccess.h>
 43 #include <asm/unistd.h>
 44 #include <asm/siginfo.h>
 45 #include <asm/cacheflush.h>
 46 #include "audit.h"      /* audit_signal_info() */
 47 
 48 /*
 49  * SLAB caches for signal bits.
 50  */
 51 
 52 static struct kmem_cache *sigqueue_cachep;
 53 
 54 int print_fatal_signals __read_mostly;
 55 
 56 static void __user *sig_handler(struct task_struct *t, int sig)
 57 {
 58         return t->sighand->action[sig - 1].sa.sa_handler;
 59 }
 60 
 61 static int sig_handler_ignored(void __user *handler, int sig)
 62 {
 63         /* Is it explicitly or implicitly ignored? */
 64         return handler == SIG_IGN ||
 65                 (handler == SIG_DFL && sig_kernel_ignore(sig));
 66 }
 67 
 68 static int sig_task_ignored(struct task_struct *t, int sig, bool force)
 69 {
 70         void __user *handler;
 71 
 72         handler = sig_handler(t, sig);
 73 
 74         if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
 75                         handler == SIG_DFL && !force)
 76                 return 1;
 77 
 78         return sig_handler_ignored(handler, sig);
 79 }
 80 
 81 static int sig_ignored(struct task_struct *t, int sig, bool force)
 82 {
 83         /*
 84          * Blocked signals are never ignored, since the
 85          * signal handler may change by the time it is
 86          * unblocked.
 87          */
 88         if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
 89                 return 0;
 90 
 91         if (!sig_task_ignored(t, sig, force))
 92                 return 0;
 93 
 94         /*
 95          * Tracers may want to know about even ignored signals.
 96          */
 97         return !t->ptrace;
 98 }
 99 
100 /*
101  * Re-calculate pending state from the set of locally pending
102  * signals, globally pending signals, and blocked signals.
103  */
104 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
105 {
106         unsigned long ready;
107         long i;
108 
109         switch (_NSIG_WORDS) {
110         default:
111                 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
112                         ready |= signal->sig[i] &~ blocked->sig[i];
113                 break;
114 
115         case 4: ready  = signal->sig[3] &~ blocked->sig[3];
116                 ready |= signal->sig[2] &~ blocked->sig[2];
117                 ready |= signal->sig[1] &~ blocked->sig[1];
118                 ready |= signal->sig[0] &~ blocked->sig[0];
119                 break;
120 
121         case 2: ready  = signal->sig[1] &~ blocked->sig[1];
122                 ready |= signal->sig[0] &~ blocked->sig[0];
123                 break;
124 
125         case 1: ready  = signal->sig[0] &~ blocked->sig[0];
126         }
127         return ready != 0;
128 }
129 
130 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
131 
132 static int recalc_sigpending_tsk(struct task_struct *t)
133 {
134         if ((t->jobctl & JOBCTL_PENDING_MASK) ||
135             PENDING(&t->pending, &t->blocked) ||
136             PENDING(&t->signal->shared_pending, &t->blocked)) {
137                 set_tsk_thread_flag(t, TIF_SIGPENDING);
138                 return 1;
139         }
140         /*
141          * We must never clear the flag in another thread, or in current
142          * when it's possible the current syscall is returning -ERESTART*.
143          * So we don't clear it here, and only callers who know they should do.
144          */
145         return 0;
146 }
147 
148 /*
149  * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
150  * This is superfluous when called on current, the wakeup is a harmless no-op.
151  */
152 void recalc_sigpending_and_wake(struct task_struct *t)
153 {
154         if (recalc_sigpending_tsk(t))
155                 signal_wake_up(t, 0);
156 }
157 
158 void recalc_sigpending(void)
159 {
160         if (!recalc_sigpending_tsk(current) && !freezing(current))
161                 clear_thread_flag(TIF_SIGPENDING);
162 
163 }
164 
165 /* Given the mask, find the first available signal that should be serviced. */
166 
167 #define SYNCHRONOUS_MASK \
168         (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
169          sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
170 
171 int next_signal(struct sigpending *pending, sigset_t *mask)
172 {
173         unsigned long i, *s, *m, x;
174         int sig = 0;
175 
176         s = pending->signal.sig;
177         m = mask->sig;
178 
179         /*
180          * Handle the first word specially: it contains the
181          * synchronous signals that need to be dequeued first.
182          */
183         x = *s &~ *m;
184         if (x) {
185                 if (x & SYNCHRONOUS_MASK)
186                         x &= SYNCHRONOUS_MASK;
187                 sig = ffz(~x) + 1;
188                 return sig;
189         }
190 
191         switch (_NSIG_WORDS) {
192         default:
193                 for (i = 1; i < _NSIG_WORDS; ++i) {
194                         x = *++s &~ *++m;
195                         if (!x)
196                                 continue;
197                         sig = ffz(~x) + i*_NSIG_BPW + 1;
198                         break;
199                 }
200                 break;
201 
202         case 2:
203                 x = s[1] &~ m[1];
204                 if (!x)
205                         break;
206                 sig = ffz(~x) + _NSIG_BPW + 1;
207                 break;
208 
209         case 1:
210                 /* Nothing to do */
211                 break;
212         }
213 
214         return sig;
215 }
216 
217 static inline void print_dropped_signal(int sig)
218 {
219         static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
220 
221         if (!print_fatal_signals)
222                 return;
223 
224         if (!__ratelimit(&ratelimit_state))
225                 return;
226 
227         pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
228                                 current->comm, current->pid, sig);
229 }
230 
231 /**
232  * task_set_jobctl_pending - set jobctl pending bits
233  * @task: target task
234  * @mask: pending bits to set
235  *
236  * Clear @mask from @task->jobctl.  @mask must be subset of
237  * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
238  * %JOBCTL_TRAPPING.  If stop signo is being set, the existing signo is
239  * cleared.  If @task is already being killed or exiting, this function
240  * becomes noop.
241  *
242  * CONTEXT:
243  * Must be called with @task->sighand->siglock held.
244  *
245  * RETURNS:
246  * %true if @mask is set, %false if made noop because @task was dying.
247  */
248 bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
249 {
250         BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
251                         JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
252         BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
253 
254         if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
255                 return false;
256 
257         if (mask & JOBCTL_STOP_SIGMASK)
258                 task->jobctl &= ~JOBCTL_STOP_SIGMASK;
259 
260         task->jobctl |= mask;
261         return true;
262 }
263 
264 /**
265  * task_clear_jobctl_trapping - clear jobctl trapping bit
266  * @task: target task
267  *
268  * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
269  * Clear it and wake up the ptracer.  Note that we don't need any further
270  * locking.  @task->siglock guarantees that @task->parent points to the
271  * ptracer.
272  *
273  * CONTEXT:
274  * Must be called with @task->sighand->siglock held.
275  */
276 void task_clear_jobctl_trapping(struct task_struct *task)
277 {
278         if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
279                 task->jobctl &= ~JOBCTL_TRAPPING;
280                 smp_mb();       /* advised by wake_up_bit() */
281                 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
282         }
283 }
284 
285 /**
286  * task_clear_jobctl_pending - clear jobctl pending bits
287  * @task: target task
288  * @mask: pending bits to clear
289  *
290  * Clear @mask from @task->jobctl.  @mask must be subset of
291  * %JOBCTL_PENDING_MASK.  If %JOBCTL_STOP_PENDING is being cleared, other
292  * STOP bits are cleared together.
293  *
294  * If clearing of @mask leaves no stop or trap pending, this function calls
295  * task_clear_jobctl_trapping().
296  *
297  * CONTEXT:
298  * Must be called with @task->sighand->siglock held.
299  */
300 void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
301 {
302         BUG_ON(mask & ~JOBCTL_PENDING_MASK);
303 
304         if (mask & JOBCTL_STOP_PENDING)
305                 mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
306 
307         task->jobctl &= ~mask;
308 
309         if (!(task->jobctl & JOBCTL_PENDING_MASK))
310                 task_clear_jobctl_trapping(task);
311 }
312 
313 /**
314  * task_participate_group_stop - participate in a group stop
315  * @task: task participating in a group stop
316  *
317  * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
318  * Group stop states are cleared and the group stop count is consumed if
319  * %JOBCTL_STOP_CONSUME was set.  If the consumption completes the group
320  * stop, the appropriate %SIGNAL_* flags are set.
321  *
322  * CONTEXT:
323  * Must be called with @task->sighand->siglock held.
324  *
325  * RETURNS:
326  * %true if group stop completion should be notified to the parent, %false
327  * otherwise.
328  */
329 static bool task_participate_group_stop(struct task_struct *task)
330 {
331         struct signal_struct *sig = task->signal;
332         bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
333 
334         WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
335 
336         task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
337 
338         if (!consume)
339                 return false;
340 
341         if (!WARN_ON_ONCE(sig->group_stop_count == 0))
342                 sig->group_stop_count--;
343 
344         /*
345          * Tell the caller to notify completion iff we are entering into a
346          * fresh group stop.  Read comment in do_signal_stop() for details.
347          */
348         if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
349                 sig->flags = SIGNAL_STOP_STOPPED;
350                 return true;
351         }
352         return false;
353 }
354 
355 /*
356  * allocate a new signal queue record
357  * - this may be called without locks if and only if t == current, otherwise an
358  *   appropriate lock must be held to stop the target task from exiting
359  */
360 static struct sigqueue *
361 __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
362 {
363         struct sigqueue *q = NULL;
364         struct user_struct *user;
365 
366         /*
367          * Protect access to @t credentials. This can go away when all
368          * callers hold rcu read lock.
369          */
370         rcu_read_lock();
371         user = get_uid(__task_cred(t)->user);
372         atomic_inc(&user->sigpending);
373         rcu_read_unlock();
374 
375         if (override_rlimit ||
376             atomic_read(&user->sigpending) <=
377                         task_rlimit(t, RLIMIT_SIGPENDING)) {
378                 q = kmem_cache_alloc(sigqueue_cachep, flags);
379         } else {
380                 print_dropped_signal(sig);
381         }
382 
383         if (unlikely(q == NULL)) {
384                 atomic_dec(&user->sigpending);
385                 free_uid(user);
386         } else {
387                 INIT_LIST_HEAD(&q->list);
388                 q->flags = 0;
389                 q->user = user;
390         }
391 
392         return q;
393 }
394 
395 static void __sigqueue_free(struct sigqueue *q)
396 {
397         if (q->flags & SIGQUEUE_PREALLOC)
398                 return;
399         atomic_dec(&q->user->sigpending);
400         free_uid(q->user);
401         kmem_cache_free(sigqueue_cachep, q);
402 }
403 
404 void flush_sigqueue(struct sigpending *queue)
405 {
406         struct sigqueue *q;
407 
408         sigemptyset(&queue->signal);
409         while (!list_empty(&queue->list)) {
410                 q = list_entry(queue->list.next, struct sigqueue , list);
411                 list_del_init(&q->list);
412                 __sigqueue_free(q);
413         }
414 }
415 
416 /*
417  * Flush all pending signals for this kthread.
418  */
419 void flush_signals(struct task_struct *t)
420 {
421         unsigned long flags;
422 
423         spin_lock_irqsave(&t->sighand->siglock, flags);
424         clear_tsk_thread_flag(t, TIF_SIGPENDING);
425         flush_sigqueue(&t->pending);
426         flush_sigqueue(&t->signal->shared_pending);
427         spin_unlock_irqrestore(&t->sighand->siglock, flags);
428 }
429 
430 static void __flush_itimer_signals(struct sigpending *pending)
431 {
432         sigset_t signal, retain;
433         struct sigqueue *q, *n;
434 
435         signal = pending->signal;
436         sigemptyset(&retain);
437 
438         list_for_each_entry_safe(q, n, &pending->list, list) {
439                 int sig = q->info.si_signo;
440 
441                 if (likely(q->info.si_code != SI_TIMER)) {
442                         sigaddset(&retain, sig);
443                 } else {
444                         sigdelset(&signal, sig);
445                         list_del_init(&q->list);
446                         __sigqueue_free(q);
447                 }
448         }
449 
450         sigorsets(&pending->signal, &signal, &retain);
451 }
452 
453 void flush_itimer_signals(void)
454 {
455         struct task_struct *tsk = current;
456         unsigned long flags;
457 
458         spin_lock_irqsave(&tsk->sighand->siglock, flags);
459         __flush_itimer_signals(&tsk->pending);
460         __flush_itimer_signals(&tsk->signal->shared_pending);
461         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
462 }
463 
464 void ignore_signals(struct task_struct *t)
465 {
466         int i;
467 
468         for (i = 0; i < _NSIG; ++i)
469                 t->sighand->action[i].sa.sa_handler = SIG_IGN;
470 
471         flush_signals(t);
472 }
473 
474 /*
475  * Flush all handlers for a task.
476  */
477 
478 void
479 flush_signal_handlers(struct task_struct *t, int force_default)
480 {
481         int i;
482         struct k_sigaction *ka = &t->sighand->action[0];
483         for (i = _NSIG ; i != 0 ; i--) {
484                 if (force_default || ka->sa.sa_handler != SIG_IGN)
485                         ka->sa.sa_handler = SIG_DFL;
486                 ka->sa.sa_flags = 0;
487 #ifdef __ARCH_HAS_SA_RESTORER
488                 ka->sa.sa_restorer = NULL;
489 #endif
490                 sigemptyset(&ka->sa.sa_mask);
491                 ka++;
492         }
493 }
494 
495 int unhandled_signal(struct task_struct *tsk, int sig)
496 {
497         void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
498         if (is_global_init(tsk))
499                 return 1;
500         if (handler != SIG_IGN && handler != SIG_DFL)
501                 return 0;
502         /* if ptraced, let the tracer determine */
503         return !tsk->ptrace;
504 }
505 
506 static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
507 {
508         struct sigqueue *q, *first = NULL;
509 
510         /*
511          * Collect the siginfo appropriate to this signal.  Check if
512          * there is another siginfo for the same signal.
513         */
514         list_for_each_entry(q, &list->list, list) {
515                 if (q->info.si_signo == sig) {
516                         if (first)
517                                 goto still_pending;
518                         first = q;
519                 }
520         }
521 
522         sigdelset(&list->signal, sig);
523 
524         if (first) {
525 still_pending:
526                 list_del_init(&first->list);
527                 copy_siginfo(info, &first->info);
528                 __sigqueue_free(first);
529         } else {
530                 /*
531                  * Ok, it wasn't in the queue.  This must be
532                  * a fast-pathed signal or we must have been
533                  * out of queue space.  So zero out the info.
534                  */
535                 info->si_signo = sig;
536                 info->si_errno = 0;
537                 info->si_code = SI_USER;
538                 info->si_pid = 0;
539                 info->si_uid = 0;
540         }
541 }
542 
543 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
544                         siginfo_t *info)
545 {
546         int sig = next_signal(pending, mask);
547 
548         if (sig)
549                 collect_signal(sig, pending, info);
550         return sig;
551 }
552 
553 /*
554  * Dequeue a signal and return the element to the caller, which is
555  * expected to free it.
556  *
557  * All callers have to hold the siglock.
558  */
559 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
560 {
561         int signr;
562 
563         /* We only dequeue private signals from ourselves, we don't let
564          * signalfd steal them
565          */
566         signr = __dequeue_signal(&tsk->pending, mask, info);
567         if (!signr) {
568                 signr = __dequeue_signal(&tsk->signal->shared_pending,
569                                          mask, info);
570                 /*
571                  * itimer signal ?
572                  *
573                  * itimers are process shared and we restart periodic
574                  * itimers in the signal delivery path to prevent DoS
575                  * attacks in the high resolution timer case. This is
576                  * compliant with the old way of self-restarting
577                  * itimers, as the SIGALRM is a legacy signal and only
578                  * queued once. Changing the restart behaviour to
579                  * restart the timer in the signal dequeue path is
580                  * reducing the timer noise on heavy loaded !highres
581                  * systems too.
582                  */
583                 if (unlikely(signr == SIGALRM)) {
584                         struct hrtimer *tmr = &tsk->signal->real_timer;
585 
586                         if (!hrtimer_is_queued(tmr) &&
587                             tsk->signal->it_real_incr.tv64 != 0) {
588                                 hrtimer_forward(tmr, tmr->base->get_time(),
589                                                 tsk->signal->it_real_incr);
590                                 hrtimer_restart(tmr);
591                         }
592                 }
593         }
594 
595         recalc_sigpending();
596         if (!signr)
597                 return 0;
598 
599         if (unlikely(sig_kernel_stop(signr))) {
600                 /*
601                  * Set a marker that we have dequeued a stop signal.  Our
602                  * caller might release the siglock and then the pending
603                  * stop signal it is about to process is no longer in the
604                  * pending bitmasks, but must still be cleared by a SIGCONT
605                  * (and overruled by a SIGKILL).  So those cases clear this
606                  * shared flag after we've set it.  Note that this flag may
607                  * remain set after the signal we return is ignored or
608                  * handled.  That doesn't matter because its only purpose
609                  * is to alert stop-signal processing code when another
610                  * processor has come along and cleared the flag.
611                  */
612                 current->jobctl |= JOBCTL_STOP_DEQUEUED;
613         }
614         if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
615                 /*
616                  * Release the siglock to ensure proper locking order
617                  * of timer locks outside of siglocks.  Note, we leave
618                  * irqs disabled here, since the posix-timers code is
619                  * about to disable them again anyway.
620                  */
621                 spin_unlock(&tsk->sighand->siglock);
622                 do_schedule_next_timer(info);
623                 spin_lock(&tsk->sighand->siglock);
624         }
625         return signr;
626 }
627 
628 /*
629  * Tell a process that it has a new active signal..
630  *
631  * NOTE! we rely on the previous spin_lock to
632  * lock interrupts for us! We can only be called with
633  * "siglock" held, and the local interrupt must
634  * have been disabled when that got acquired!
635  *
636  * No need to set need_resched since signal event passing
637  * goes through ->blocked
638  */
639 void signal_wake_up_state(struct task_struct *t, unsigned int state)
640 {
641         set_tsk_thread_flag(t, TIF_SIGPENDING);
642         /*
643          * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
644          * case. We don't check t->state here because there is a race with it
645          * executing another processor and just now entering stopped state.
646          * By using wake_up_state, we ensure the process will wake up and
647          * handle its death signal.
648          */
649         if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
650                 kick_process(t);
651 }
652 
653 /*
654  * Remove signals in mask from the pending set and queue.
655  * Returns 1 if any signals were found.
656  *
657  * All callers must be holding the siglock.
658  */
659 static int flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
660 {
661         struct sigqueue *q, *n;
662         sigset_t m;
663 
664         sigandsets(&m, mask, &s->signal);
665         if (sigisemptyset(&m))
666                 return 0;
667 
668         sigandnsets(&s->signal, &s->signal, mask);
669         list_for_each_entry_safe(q, n, &s->list, list) {
670                 if (sigismember(mask, q->info.si_signo)) {
671                         list_del_init(&q->list);
672                         __sigqueue_free(q);
673                 }
674         }
675         return 1;
676 }
677 
678 static inline int is_si_special(const struct siginfo *info)
679 {
680         return info <= SEND_SIG_FORCED;
681 }
682 
683 static inline bool si_fromuser(const struct siginfo *info)
684 {
685         return info == SEND_SIG_NOINFO ||
686                 (!is_si_special(info) && SI_FROMUSER(info));
687 }
688 
689 /*
690  * called with RCU read lock from check_kill_permission()
691  */
692 static int kill_ok_by_cred(struct task_struct *t)
693 {
694         const struct cred *cred = current_cred();
695         const struct cred *tcred = __task_cred(t);
696 
697         if (uid_eq(cred->euid, tcred->suid) ||
698             uid_eq(cred->euid, tcred->uid)  ||
699             uid_eq(cred->uid,  tcred->suid) ||
700             uid_eq(cred->uid,  tcred->uid))
701                 return 1;
702 
703         if (ns_capable(tcred->user_ns, CAP_KILL))
704                 return 1;
705 
706         return 0;
707 }
708 
709 /*
710  * Bad permissions for sending the signal
711  * - the caller must hold the RCU read lock
712  */
713 static int check_kill_permission(int sig, struct siginfo *info,
714                                  struct task_struct *t)
715 {
716         struct pid *sid;
717         int error;
718 
719         if (!valid_signal(sig))
720                 return -EINVAL;
721 
722         if (!si_fromuser(info))
723                 return 0;
724 
725         error = audit_signal_info(sig, t); /* Let audit system see the signal */
726         if (error)
727                 return error;
728 
729         if (!same_thread_group(current, t) &&
730             !kill_ok_by_cred(t)) {
731                 switch (sig) {
732                 case SIGCONT:
733                         sid = task_session(t);
734                         /*
735                          * We don't return the error if sid == NULL. The
736                          * task was unhashed, the caller must notice this.
737                          */
738                         if (!sid || sid == task_session(current))
739                                 break;
740                 default:
741                         return -EPERM;
742                 }
743         }
744 
745         return security_task_kill(t, info, sig, 0);
746 }
747 
748 /**
749  * ptrace_trap_notify - schedule trap to notify ptracer
750  * @t: tracee wanting to notify tracer
751  *
752  * This function schedules sticky ptrace trap which is cleared on the next
753  * TRAP_STOP to notify ptracer of an event.  @t must have been seized by
754  * ptracer.
755  *
756  * If @t is running, STOP trap will be taken.  If trapped for STOP and
757  * ptracer is listening for events, tracee is woken up so that it can
758  * re-trap for the new event.  If trapped otherwise, STOP trap will be
759  * eventually taken without returning to userland after the existing traps
760  * are finished by PTRACE_CONT.
761  *
762  * CONTEXT:
763  * Must be called with @task->sighand->siglock held.
764  */
765 static void ptrace_trap_notify(struct task_struct *t)
766 {
767         WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
768         assert_spin_locked(&t->sighand->siglock);
769 
770         task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
771         ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
772 }
773 
774 /*
775  * Handle magic process-wide effects of stop/continue signals. Unlike
776  * the signal actions, these happen immediately at signal-generation
777  * time regardless of blocking, ignoring, or handling.  This does the
778  * actual continuing for SIGCONT, but not the actual stopping for stop
779  * signals. The process stop is done as a signal action for SIG_DFL.
780  *
781  * Returns true if the signal should be actually delivered, otherwise
782  * it should be dropped.
783  */
784 static bool prepare_signal(int sig, struct task_struct *p, bool force)
785 {
786         struct signal_struct *signal = p->signal;
787         struct task_struct *t;
788         sigset_t flush;
789 
790         if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
791                 if (!(signal->flags & SIGNAL_GROUP_EXIT))
792                         return sig == SIGKILL;
793                 /*
794                  * The process is in the middle of dying, nothing to do.
795                  */
796         } else if (sig_kernel_stop(sig)) {
797                 /*
798                  * This is a stop signal.  Remove SIGCONT from all queues.
799                  */
800                 siginitset(&flush, sigmask(SIGCONT));
801                 flush_sigqueue_mask(&flush, &signal->shared_pending);
802                 for_each_thread(p, t)
803                         flush_sigqueue_mask(&flush, &t->pending);
804         } else if (sig == SIGCONT) {
805                 unsigned int why;
806                 /*
807                  * Remove all stop signals from all queues, wake all threads.
808                  */
809                 siginitset(&flush, SIG_KERNEL_STOP_MASK);
810                 flush_sigqueue_mask(&flush, &signal->shared_pending);
811                 for_each_thread(p, t) {
812                         flush_sigqueue_mask(&flush, &t->pending);
813                         task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
814                         if (likely(!(t->ptrace & PT_SEIZED)))
815                                 wake_up_state(t, __TASK_STOPPED);
816                         else
817                                 ptrace_trap_notify(t);
818                 }
819 
820                 /*
821                  * Notify the parent with CLD_CONTINUED if we were stopped.
822                  *
823                  * If we were in the middle of a group stop, we pretend it
824                  * was already finished, and then continued. Since SIGCHLD
825                  * doesn't queue we report only CLD_STOPPED, as if the next
826                  * CLD_CONTINUED was dropped.
827                  */
828                 why = 0;
829                 if (signal->flags & SIGNAL_STOP_STOPPED)
830                         why |= SIGNAL_CLD_CONTINUED;
831                 else if (signal->group_stop_count)
832                         why |= SIGNAL_CLD_STOPPED;
833 
834                 if (why) {
835                         /*
836                          * The first thread which returns from do_signal_stop()
837                          * will take ->siglock, notice SIGNAL_CLD_MASK, and
838                          * notify its parent. See get_signal_to_deliver().
839                          */
840                         signal->flags = why | SIGNAL_STOP_CONTINUED;
841                         signal->group_stop_count = 0;
842                         signal->group_exit_code = 0;
843                 }
844         }
845 
846         return !sig_ignored(p, sig, force);
847 }
848 
849 /*
850  * Test if P wants to take SIG.  After we've checked all threads with this,
851  * it's equivalent to finding no threads not blocking SIG.  Any threads not
852  * blocking SIG were ruled out because they are not running and already
853  * have pending signals.  Such threads will dequeue from the shared queue
854  * as soon as they're available, so putting the signal on the shared queue
855  * will be equivalent to sending it to one such thread.
856  */
857 static inline int wants_signal(int sig, struct task_struct *p)
858 {
859         if (sigismember(&p->blocked, sig))
860                 return 0;
861         if (p->flags & PF_EXITING)
862                 return 0;
863         if (sig == SIGKILL)
864                 return 1;
865         if (task_is_stopped_or_traced(p))
866                 return 0;
867         return task_curr(p) || !signal_pending(p);
868 }
869 
870 static void complete_signal(int sig, struct task_struct *p, int group)
871 {
872         struct signal_struct *signal = p->signal;
873         struct task_struct *t;
874 
875         /*
876          * Now find a thread we can wake up to take the signal off the queue.
877          *
878          * If the main thread wants the signal, it gets first crack.
879          * Probably the least surprising to the average bear.
880          */
881         if (wants_signal(sig, p))
882                 t = p;
883         else if (!group || thread_group_empty(p))
884                 /*
885                  * There is just one thread and it does not need to be woken.
886                  * It will dequeue unblocked signals before it runs again.
887                  */
888                 return;
889         else {
890                 /*
891                  * Otherwise try to find a suitable thread.
892                  */
893                 t = signal->curr_target;
894                 while (!wants_signal(sig, t)) {
895                         t = next_thread(t);
896                         if (t == signal->curr_target)
897                                 /*
898                                  * No thread needs to be woken.
899                                  * Any eligible threads will see
900                                  * the signal in the queue soon.
901                                  */
902                                 return;
903                 }
904                 signal->curr_target = t;
905         }
906 
907         /*
908          * Found a killable thread.  If the signal will be fatal,
909          * then start taking the whole group down immediately.
910          */
911         if (sig_fatal(p, sig) &&
912             !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
913             !sigismember(&t->real_blocked, sig) &&
914             (sig == SIGKILL || !t->ptrace)) {
915                 /*
916                  * This signal will be fatal to the whole group.
917                  */
918                 if (!sig_kernel_coredump(sig)) {
919                         /*
920                          * Start a group exit and wake everybody up.
921                          * This way we don't have other threads
922                          * running and doing things after a slower
923                          * thread has the fatal signal pending.
924                          */
925                         signal->flags = SIGNAL_GROUP_EXIT;
926                         signal->group_exit_code = sig;
927                         signal->group_stop_count = 0;
928                         t = p;
929                         do {
930                                 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
931                                 sigaddset(&t->pending.signal, SIGKILL);
932                                 signal_wake_up(t, 1);
933                         } while_each_thread(p, t);
934                         return;
935                 }
936         }
937 
938         /*
939          * The signal is already in the shared-pending queue.
940          * Tell the chosen thread to wake up and dequeue it.
941          */
942         signal_wake_up(t, sig == SIGKILL);
943         return;
944 }
945 
946 static inline int legacy_queue(struct sigpending *signals, int sig)
947 {
948         return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
949 }
950 
951 #ifdef CONFIG_USER_NS
952 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
953 {
954         if (current_user_ns() == task_cred_xxx(t, user_ns))
955                 return;
956 
957         if (SI_FROMKERNEL(info))
958                 return;
959 
960         rcu_read_lock();
961         info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
962                                         make_kuid(current_user_ns(), info->si_uid));
963         rcu_read_unlock();
964 }
965 #else
966 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
967 {
968         return;
969 }
970 #endif
971 
972 static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
973                         int group, int from_ancestor_ns)
974 {
975         struct sigpending *pending;
976         struct sigqueue *q;
977         int override_rlimit;
978         int ret = 0, result;
979 
980         assert_spin_locked(&t->sighand->siglock);
981 
982         result = TRACE_SIGNAL_IGNORED;
983         if (!prepare_signal(sig, t,
984                         from_ancestor_ns || (info == SEND_SIG_FORCED)))
985                 goto ret;
986 
987         pending = group ? &t->signal->shared_pending : &t->pending;
988         /*
989          * Short-circuit ignored signals and support queuing
990          * exactly one non-rt signal, so that we can get more
991          * detailed information about the cause of the signal.
992          */
993         result = TRACE_SIGNAL_ALREADY_PENDING;
994         if (legacy_queue(pending, sig))
995                 goto ret;
996 
997         result = TRACE_SIGNAL_DELIVERED;
998         /*
999          * fast-pathed signals for kernel-internal things like SIGSTOP
1000          * or SIGKILL.
1001          */
1002         if (info == SEND_SIG_FORCED)
1003                 goto out_set;
1004 
1005         /*
1006          * Real-time signals must be queued if sent by sigqueue, or
1007          * some other real-time mechanism.  It is implementation
1008          * defined whether kill() does so.  We attempt to do so, on
1009          * the principle of least surprise, but since kill is not
1010          * allowed to fail with EAGAIN when low on memory we just
1011          * make sure at least one signal gets delivered and don't
1012          * pass on the info struct.
1013          */
1014         if (sig < SIGRTMIN)
1015                 override_rlimit = (is_si_special(info) || info->si_code >= 0);
1016         else
1017                 override_rlimit = 0;
1018 
1019         q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
1020                 override_rlimit);
1021         if (q) {
1022                 list_add_tail(&q->list, &pending->list);
1023                 switch ((unsigned long) info) {
1024                 case (unsigned long) SEND_SIG_NOINFO:
1025                         q->info.si_signo = sig;
1026                         q->info.si_errno = 0;
1027                         q->info.si_code = SI_USER;
1028                         q->info.si_pid = task_tgid_nr_ns(current,
1029                                                         task_active_pid_ns(t));
1030                         q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1031                         break;
1032                 case (unsigned long) SEND_SIG_PRIV:
1033                         q->info.si_signo = sig;
1034                         q->info.si_errno = 0;
1035                         q->info.si_code = SI_KERNEL;
1036                         q->info.si_pid = 0;
1037                         q->info.si_uid = 0;
1038                         break;
1039                 default:
1040                         copy_siginfo(&q->info, info);
1041                         if (from_ancestor_ns)
1042                                 q->info.si_pid = 0;
1043                         break;
1044                 }
1045 
1046                 userns_fixup_signal_uid(&q->info, t);
1047 
1048         } else if (!is_si_special(info)) {
1049                 if (sig >= SIGRTMIN && info->si_code != SI_USER) {
1050                         /*
1051                          * Queue overflow, abort.  We may abort if the
1052                          * signal was rt and sent by user using something
1053                          * other than kill().
1054                          */
1055                         result = TRACE_SIGNAL_OVERFLOW_FAIL;
1056                         ret = -EAGAIN;
1057                         goto ret;
1058                 } else {
1059                         /*
1060                          * This is a silent loss of information.  We still
1061                          * send the signal, but the *info bits are lost.
1062                          */
1063                         result = TRACE_SIGNAL_LOSE_INFO;
1064                 }
1065         }
1066 
1067 out_set:
1068         signalfd_notify(t, sig);
1069         sigaddset(&pending->signal, sig);
1070         complete_signal(sig, t, group);
1071 ret:
1072         trace_signal_generate(sig, info, t, group, result);
1073         return ret;
1074 }
1075 
1076 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
1077                         int group)
1078 {
1079         int from_ancestor_ns = 0;
1080 
1081 #ifdef CONFIG_PID_NS
1082         from_ancestor_ns = si_fromuser(info) &&
1083                            !task_pid_nr_ns(current, task_active_pid_ns(t));
1084 #endif
1085 
1086         return __send_signal(sig, info, t, group, from_ancestor_ns);
1087 }
1088 
1089 static void print_fatal_signal(int signr)
1090 {
1091         struct pt_regs *regs = signal_pt_regs();
1092         pr_info("potentially unexpected fatal signal %d.\n", signr);
1093 
1094 #if defined(__i386__) && !defined(__arch_um__)
1095         pr_info("code at %08lx: ", regs->ip);
1096         {
1097                 int i;
1098                 for (i = 0; i < 16; i++) {
1099                         unsigned char insn;
1100 
1101                         if (get_user(insn, (unsigned char *)(regs->ip + i)))
1102                                 break;
1103                         pr_cont("%02x ", insn);
1104                 }
1105         }
1106         pr_cont("\n");
1107 #endif
1108         preempt_disable();
1109         show_regs(regs);
1110         preempt_enable();
1111 }
1112 
1113 static int __init setup_print_fatal_signals(char *str)
1114 {
1115         get_option (&str, &print_fatal_signals);
1116 
1117         return 1;
1118 }
1119 
1120 __setup("print-fatal-signals=", setup_print_fatal_signals);
1121 
1122 int
1123 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1124 {
1125         return send_signal(sig, info, p, 1);
1126 }
1127 
1128 static int
1129 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1130 {
1131         return send_signal(sig, info, t, 0);
1132 }
1133 
1134 int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
1135                         bool group)
1136 {
1137         unsigned long flags;
1138         int ret = -ESRCH;
1139 
1140         if (lock_task_sighand(p, &flags)) {
1141                 ret = send_signal(sig, info, p, group);
1142                 unlock_task_sighand(p, &flags);
1143         }
1144 
1145         return ret;
1146 }
1147 
1148 /*
1149  * Force a signal that the process can't ignore: if necessary
1150  * we unblock the signal and change any SIG_IGN to SIG_DFL.
1151  *
1152  * Note: If we unblock the signal, we always reset it to SIG_DFL,
1153  * since we do not want to have a signal handler that was blocked
1154  * be invoked when user space had explicitly blocked it.
1155  *
1156  * We don't want to have recursive SIGSEGV's etc, for example,
1157  * that is why we also clear SIGNAL_UNKILLABLE.
1158  */
1159 int
1160 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1161 {
1162         unsigned long int flags;
1163         int ret, blocked, ignored;
1164         struct k_sigaction *action;
1165 
1166         spin_lock_irqsave(&t->sighand->siglock, flags);
1167         action = &t->sighand->action[sig-1];
1168         ignored = action->sa.sa_handler == SIG_IGN;
1169         blocked = sigismember(&t->blocked, sig);
1170         if (blocked || ignored) {
1171                 action->sa.sa_handler = SIG_DFL;
1172                 if (blocked) {
1173                         sigdelset(&t->blocked, sig);
1174                         recalc_sigpending_and_wake(t);
1175                 }
1176         }
1177         if (action->sa.sa_handler == SIG_DFL)
1178                 t->signal->flags &= ~SIGNAL_UNKILLABLE;
1179         ret = specific_send_sig_info(sig, info, t);
1180         spin_unlock_irqrestore(&t->sighand->siglock, flags);
1181 
1182         return ret;
1183 }
1184 
1185 /*
1186  * Nuke all other threads in the group.
1187  */
1188 int zap_other_threads(struct task_struct *p)
1189 {
1190         struct task_struct *t = p;
1191         int count = 0;
1192 
1193         p->signal->group_stop_count = 0;
1194 
1195         while_each_thread(p, t) {
1196                 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1197                 count++;
1198 
1199                 /* Don't bother with already dead threads */
1200                 if (t->exit_state)
1201                         continue;
1202                 sigaddset(&t->pending.signal, SIGKILL);
1203                 signal_wake_up(t, 1);
1204         }
1205 
1206         return count;
1207 }
1208 
1209 struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1210                                            unsigned long *flags)
1211 {
1212         struct sighand_struct *sighand;
1213 
1214         for (;;) {
1215                 /*
1216                  * Disable interrupts early to avoid deadlocks.
1217                  * See rcu_read_unlock() comment header for details.
1218                  */
1219                 local_irq_save(*flags);
1220                 rcu_read_lock();
1221                 sighand = rcu_dereference(tsk->sighand);
1222                 if (unlikely(sighand == NULL)) {
1223                         rcu_read_unlock();
1224                         local_irq_restore(*flags);
1225                         break;
1226                 }
1227                 /*
1228                  * This sighand can be already freed and even reused, but
1229                  * we rely on SLAB_DESTROY_BY_RCU and sighand_ctor() which
1230                  * initializes ->siglock: this slab can't go away, it has
1231                  * the same object type, ->siglock can't be reinitialized.
1232                  *
1233                  * We need to ensure that tsk->sighand is still the same
1234                  * after we take the lock, we can race with de_thread() or
1235                  * __exit_signal(). In the latter case the next iteration
1236                  * must see ->sighand == NULL.
1237                  */
1238                 spin_lock(&sighand->siglock);
1239                 if (likely(sighand == tsk->sighand)) {
1240                         rcu_read_unlock();
1241                         break;
1242                 }
1243                 spin_unlock(&sighand->siglock);
1244                 rcu_read_unlock();
1245                 local_irq_restore(*flags);
1246         }
1247 
1248         return sighand;
1249 }
1250 
1251 /*
1252  * send signal info to all the members of a group
1253  */
1254 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1255 {
1256         int ret;
1257 
1258         rcu_read_lock();
1259         ret = check_kill_permission(sig, info, p);
1260         rcu_read_unlock();
1261 
1262         if (!ret && sig)
1263                 ret = do_send_sig_info(sig, info, p, true);
1264 
1265         return ret;
1266 }
1267 
1268 /*
1269  * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1270  * control characters do (^C, ^Z etc)
1271  * - the caller must hold at least a readlock on tasklist_lock
1272  */
1273 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1274 {
1275         struct task_struct *p = NULL;
1276         int retval, success;
1277 
1278         success = 0;
1279         retval = -ESRCH;
1280         do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1281                 int err = group_send_sig_info(sig, info, p);
1282                 success |= !err;
1283                 retval = err;
1284         } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1285         return success ? 0 : retval;
1286 }
1287 
1288 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1289 {
1290         int error = -ESRCH;
1291         struct task_struct *p;
1292 
1293         for (;;) {
1294                 rcu_read_lock();
1295                 p = pid_task(pid, PIDTYPE_PID);
1296                 if (p)
1297                         error = group_send_sig_info(sig, info, p);
1298                 rcu_read_unlock();
1299                 if (likely(!p || error != -ESRCH))
1300                         return error;
1301 
1302                 /*
1303                  * The task was unhashed in between, try again.  If it
1304                  * is dead, pid_task() will return NULL, if we race with
1305                  * de_thread() it will find the new leader.
1306                  */
1307         }
1308 }
1309 
1310 int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1311 {
1312         int error;
1313         rcu_read_lock();
1314         error = kill_pid_info(sig, info, find_vpid(pid));
1315         rcu_read_unlock();
1316         return error;
1317 }
1318 
1319 static int kill_as_cred_perm(const struct cred *cred,
1320                              struct task_struct *target)
1321 {
1322         const struct cred *pcred = __task_cred(target);
1323         if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) &&
1324             !uid_eq(cred->uid,  pcred->suid) && !uid_eq(cred->uid,  pcred->uid))
1325                 return 0;
1326         return 1;
1327 }
1328 
1329 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1330 int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
1331                          const struct cred *cred, u32 secid)
1332 {
1333         int ret = -EINVAL;
1334         struct task_struct *p;
1335         unsigned long flags;
1336 
1337         if (!valid_signal(sig))
1338                 return ret;
1339 
1340         rcu_read_lock();
1341         p = pid_task(pid, PIDTYPE_PID);
1342         if (!p) {
1343                 ret = -ESRCH;
1344                 goto out_unlock;
1345         }
1346         if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
1347                 ret = -EPERM;
1348                 goto out_unlock;
1349         }
1350         ret = security_task_kill(p, info, sig, secid);
1351         if (ret)
1352                 goto out_unlock;
1353 
1354         if (sig) {
1355                 if (lock_task_sighand(p, &flags)) {
1356                         ret = __send_signal(sig, info, p, 1, 0);
1357                         unlock_task_sighand(p, &flags);
1358                 } else
1359                         ret = -ESRCH;
1360         }
1361 out_unlock:
1362         rcu_read_unlock();
1363         return ret;
1364 }
1365 EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
1366 
1367 /*
1368  * kill_something_info() interprets pid in interesting ways just like kill(2).
1369  *
1370  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1371  * is probably wrong.  Should make it like BSD or SYSV.
1372  */
1373 
1374 static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
1375 {
1376         int ret;
1377 
1378         if (pid > 0) {
1379                 rcu_read_lock();
1380                 ret = kill_pid_info(sig, info, find_vpid(pid));
1381                 rcu_read_unlock();
1382                 return ret;
1383         }
1384 
1385         read_lock(&tasklist_lock);
1386         if (pid != -1) {
1387                 ret = __kill_pgrp_info(sig, info,
1388                                 pid ? find_vpid(-pid) : task_pgrp(current));
1389         } else {
1390                 int retval = 0, count = 0;
1391                 struct task_struct * p;
1392 
1393                 for_each_process(p) {
1394                         if (task_pid_vnr(p) > 1 &&
1395                                         !same_thread_group(p, current)) {
1396                                 int err = group_send_sig_info(sig, info, p);
1397                                 ++count;
1398                                 if (err != -EPERM)
1399                                         retval = err;
1400                         }
1401                 }
1402                 ret = count ? retval : -ESRCH;
1403         }
1404         read_unlock(&tasklist_lock);
1405 
1406         return ret;
1407 }
1408 
1409 /*
1410  * These are for backward compatibility with the rest of the kernel source.
1411  */
1412 
1413 int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1414 {
1415         /*
1416          * Make sure legacy kernel users don't send in bad values
1417          * (normal paths check this in check_kill_permission).
1418          */
1419         if (!valid_signal(sig))
1420                 return -EINVAL;
1421 
1422         return do_send_sig_info(sig, info, p, false);
1423 }
1424 
1425 #define __si_special(priv) \
1426         ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1427 
1428 int
1429 send_sig(int sig, struct task_struct *p, int priv)
1430 {
1431         return send_sig_info(sig, __si_special(priv), p);
1432 }
1433 
1434 void
1435 force_sig(int sig, struct task_struct *p)
1436 {
1437         force_sig_info(sig, SEND_SIG_PRIV, p);
1438 }
1439 
1440 /*
1441  * When things go south during signal handling, we
1442  * will force a SIGSEGV. And if the signal that caused
1443  * the problem was already a SIGSEGV, we'll want to
1444  * make sure we don't even try to deliver the signal..
1445  */
1446 int
1447 force_sigsegv(int sig, struct task_struct *p)
1448 {
1449         if (sig == SIGSEGV) {
1450                 unsigned long flags;
1451                 spin_lock_irqsave(&p->sighand->siglock, flags);
1452                 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1453                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1454         }
1455         force_sig(SIGSEGV, p);
1456         return 0;
1457 }
1458 
1459 int kill_pgrp(struct pid *pid, int sig, int priv)
1460 {
1461         int ret;
1462 
1463         read_lock(&tasklist_lock);
1464         ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1465         read_unlock(&tasklist_lock);
1466 
1467         return ret;
1468 }
1469 EXPORT_SYMBOL(kill_pgrp);
1470 
1471 int kill_pid(struct pid *pid, int sig, int priv)
1472 {
1473         return kill_pid_info(sig, __si_special(priv), pid);
1474 }
1475 EXPORT_SYMBOL(kill_pid);
1476 
1477 /*
1478  * These functions support sending signals using preallocated sigqueue
1479  * structures.  This is needed "because realtime applications cannot
1480  * afford to lose notifications of asynchronous events, like timer
1481  * expirations or I/O completions".  In the case of POSIX Timers
1482  * we allocate the sigqueue structure from the timer_create.  If this
1483  * allocation fails we are able to report the failure to the application
1484  * with an EAGAIN error.
1485  */
1486 struct sigqueue *sigqueue_alloc(void)
1487 {
1488         struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
1489 
1490         if (q)
1491                 q->flags |= SIGQUEUE_PREALLOC;
1492 
1493         return q;
1494 }
1495 
1496 void sigqueue_free(struct sigqueue *q)
1497 {
1498         unsigned long flags;
1499         spinlock_t *lock = &current->sighand->siglock;
1500 
1501         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1502         /*
1503          * We must hold ->siglock while testing q->list
1504          * to serialize with collect_signal() or with
1505          * __exit_signal()->flush_sigqueue().
1506          */
1507         spin_lock_irqsave(lock, flags);
1508         q->flags &= ~SIGQUEUE_PREALLOC;
1509         /*
1510          * If it is queued it will be freed when dequeued,
1511          * like the "regular" sigqueue.
1512          */
1513         if (!list_empty(&q->list))
1514                 q = NULL;
1515         spin_unlock_irqrestore(lock, flags);
1516 
1517         if (q)
1518                 __sigqueue_free(q);
1519 }
1520 
1521 int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1522 {
1523         int sig = q->info.si_signo;
1524         struct sigpending *pending;
1525         unsigned long flags;
1526         int ret, result;
1527 
1528         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1529 
1530         ret = -1;
1531         if (!likely(lock_task_sighand(t, &flags)))
1532                 goto ret;
1533 
1534         ret = 1; /* the signal is ignored */
1535         result = TRACE_SIGNAL_IGNORED;
1536         if (!prepare_signal(sig, t, false))
1537                 goto out;
1538 
1539         ret = 0;
1540         if (unlikely(!list_empty(&q->list))) {
1541                 /*
1542                  * If an SI_TIMER entry is already queue just increment
1543                  * the overrun count.
1544                  */
1545                 BUG_ON(q->info.si_code != SI_TIMER);
1546                 q->info.si_overrun++;
1547                 result = TRACE_SIGNAL_ALREADY_PENDING;
1548                 goto out;
1549         }
1550         q->info.si_overrun = 0;
1551 
1552         signalfd_notify(t, sig);
1553         pending = group ? &t->signal->shared_pending : &t->pending;
1554         list_add_tail(&q->list, &pending->list);
1555         sigaddset(&pending->signal, sig);
1556         complete_signal(sig, t, group);
1557         result = TRACE_SIGNAL_DELIVERED;
1558 out:
1559         trace_signal_generate(sig, &q->info, t, group, result);
1560         unlock_task_sighand(t, &flags);
1561 ret:
1562         return ret;
1563 }
1564 
1565 /*
1566  * Let a parent know about the death of a child.
1567  * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1568  *
1569  * Returns true if our parent ignored us and so we've switched to
1570  * self-reaping.
1571  */
1572 bool do_notify_parent(struct task_struct *tsk, int sig)
1573 {
1574         struct siginfo info;
1575         unsigned long flags;
1576         struct sighand_struct *psig;
1577         bool autoreap = false;
1578         cputime_t utime, stime;
1579 
1580         BUG_ON(sig == -1);
1581 
1582         /* do_notify_parent_cldstop should have been called instead.  */
1583         BUG_ON(task_is_stopped_or_traced(tsk));
1584 
1585         BUG_ON(!tsk->ptrace &&
1586                (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1587 
1588         if (sig != SIGCHLD) {
1589                 /*
1590                  * This is only possible if parent == real_parent.
1591                  * Check if it has changed security domain.
1592                  */
1593                 if (tsk->parent_exec_id != tsk->parent->self_exec_id)
1594                         sig = SIGCHLD;
1595         }
1596 
1597         info.si_signo = sig;
1598         info.si_errno = 0;
1599         /*
1600          * We are under tasklist_lock here so our parent is tied to
1601          * us and cannot change.
1602          *
1603          * task_active_pid_ns will always return the same pid namespace
1604          * until a task passes through release_task.
1605          *
1606          * write_lock() currently calls preempt_disable() which is the
1607          * same as rcu_read_lock(), but according to Oleg, this is not
1608          * correct to rely on this
1609          */
1610         rcu_read_lock();
1611         info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1612         info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
1613                                        task_uid(tsk));
1614         rcu_read_unlock();
1615 
1616         task_cputime(tsk, &utime, &stime);
1617         info.si_utime = cputime_to_clock_t(utime + tsk->signal->utime);
1618         info.si_stime = cputime_to_clock_t(stime + tsk->signal->stime);
1619 
1620         info.si_status = tsk->exit_code & 0x7f;
1621         if (tsk->exit_code & 0x80)
1622                 info.si_code = CLD_DUMPED;
1623         else if (tsk->exit_code & 0x7f)
1624                 info.si_code = CLD_KILLED;
1625         else {
1626                 info.si_code = CLD_EXITED;
1627                 info.si_status = tsk->exit_code >> 8;
1628         }
1629 
1630         psig = tsk->parent->sighand;
1631         spin_lock_irqsave(&psig->siglock, flags);
1632         if (!tsk->ptrace && sig == SIGCHLD &&
1633             (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1634              (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1635                 /*
1636                  * We are exiting and our parent doesn't care.  POSIX.1
1637                  * defines special semantics for setting SIGCHLD to SIG_IGN
1638                  * or setting the SA_NOCLDWAIT flag: we should be reaped
1639                  * automatically and not left for our parent's wait4 call.
1640                  * Rather than having the parent do it as a magic kind of
1641                  * signal handler, we just set this to tell do_exit that we
1642                  * can be cleaned up without becoming a zombie.  Note that
1643                  * we still call __wake_up_parent in this case, because a
1644                  * blocked sys_wait4 might now return -ECHILD.
1645                  *
1646                  * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1647                  * is implementation-defined: we do (if you don't want
1648                  * it, just use SIG_IGN instead).
1649                  */
1650                 autoreap = true;
1651                 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1652                         sig = 0;
1653         }
1654         if (valid_signal(sig) && sig)
1655                 __group_send_sig_info(sig, &info, tsk->parent);
1656         __wake_up_parent(tsk, tsk->parent);
1657         spin_unlock_irqrestore(&psig->siglock, flags);
1658 
1659         return autoreap;
1660 }
1661 
1662 /**
1663  * do_notify_parent_cldstop - notify parent of stopped/continued state change
1664  * @tsk: task reporting the state change
1665  * @for_ptracer: the notification is for ptracer
1666  * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
1667  *
1668  * Notify @tsk's parent that the stopped/continued state has changed.  If
1669  * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
1670  * If %true, @tsk reports to @tsk->parent which should be the ptracer.
1671  *
1672  * CONTEXT:
1673  * Must be called with tasklist_lock at least read locked.
1674  */
1675 static void do_notify_parent_cldstop(struct task_struct *tsk,
1676                                      bool for_ptracer, int why)
1677 {
1678         struct siginfo info;
1679         unsigned long flags;
1680         struct task_struct *parent;
1681         struct sighand_struct *sighand;
1682         cputime_t utime, stime;
1683 
1684         if (for_ptracer) {
1685                 parent = tsk->parent;
1686         } else {
1687                 tsk = tsk->group_leader;
1688                 parent = tsk->real_parent;
1689         }
1690 
1691         info.si_signo = SIGCHLD;
1692         info.si_errno = 0;
1693         /*
1694          * see comment in do_notify_parent() about the following 4 lines
1695          */
1696         rcu_read_lock();
1697         info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
1698         info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
1699         rcu_read_unlock();
1700 
1701         task_cputime(tsk, &utime, &stime);
1702         info.si_utime = cputime_to_clock_t(utime);
1703         info.si_stime = cputime_to_clock_t(stime);
1704 
1705         info.si_code = why;
1706         switch (why) {
1707         case CLD_CONTINUED:
1708                 info.si_status = SIGCONT;
1709                 break;
1710         case CLD_STOPPED:
1711                 info.si_status = tsk->signal->group_exit_code & 0x7f;
1712                 break;
1713         case CLD_TRAPPED:
1714                 info.si_status = tsk->exit_code & 0x7f;
1715                 break;
1716         default:
1717                 BUG();
1718         }
1719 
1720         sighand = parent->sighand;
1721         spin_lock_irqsave(&sighand->siglock, flags);
1722         if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1723             !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1724                 __group_send_sig_info(SIGCHLD, &info, parent);
1725         /*
1726          * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1727          */
1728         __wake_up_parent(tsk, parent);
1729         spin_unlock_irqrestore(&sighand->siglock, flags);
1730 }
1731 
1732 static inline int may_ptrace_stop(void)
1733 {
1734         if (!likely(current->ptrace))
1735                 return 0;
1736         /*
1737          * Are we in the middle of do_coredump?
1738          * If so and our tracer is also part of the coredump stopping
1739          * is a deadlock situation, and pointless because our tracer
1740          * is dead so don't allow us to stop.
1741          * If SIGKILL was already sent before the caller unlocked
1742          * ->siglock we must see ->core_state != NULL. Otherwise it
1743          * is safe to enter schedule().
1744          *
1745          * This is almost outdated, a task with the pending SIGKILL can't
1746          * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported
1747          * after SIGKILL was already dequeued.
1748          */
1749         if (unlikely(current->mm->core_state) &&
1750             unlikely(current->mm == current->parent->mm))
1751                 return 0;
1752 
1753         return 1;
1754 }
1755 
1756 /*
1757  * Return non-zero if there is a SIGKILL that should be waking us up.
1758  * Called with the siglock held.
1759  */
1760 static int sigkill_pending(struct task_struct *tsk)
1761 {
1762         return  sigismember(&tsk->pending.signal, SIGKILL) ||
1763                 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
1764 }
1765 
1766 /*
1767  * This must be called with current->sighand->siglock held.
1768  *
1769  * This should be the path for all ptrace stops.
1770  * We always set current->last_siginfo while stopped here.
1771  * That makes it a way to test a stopped process for
1772  * being ptrace-stopped vs being job-control-stopped.
1773  *
1774  * If we actually decide not to stop at all because the tracer
1775  * is gone, we keep current->exit_code unless clear_code.
1776  */
1777 static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
1778         __releases(&current->sighand->siglock)
1779         __acquires(&current->sighand->siglock)
1780 {
1781         bool gstop_done = false;
1782 
1783         if (arch_ptrace_stop_needed(exit_code, info)) {
1784                 /*
1785                  * The arch code has something special to do before a
1786                  * ptrace stop.  This is allowed to block, e.g. for faults
1787                  * on user stack pages.  We can't keep the siglock while
1788                  * calling arch_ptrace_stop, so we must release it now.
1789                  * To preserve proper semantics, we must do this before
1790                  * any signal bookkeeping like checking group_stop_count.
1791                  * Meanwhile, a SIGKILL could come in before we retake the
1792                  * siglock.  That must prevent us from sleeping in TASK_TRACED.
1793                  * So after regaining the lock, we must check for SIGKILL.
1794                  */
1795                 spin_unlock_irq(&current->sighand->siglock);
1796                 arch_ptrace_stop(exit_code, info);
1797                 spin_lock_irq(&current->sighand->siglock);
1798                 if (sigkill_pending(current))
1799                         return;
1800         }
1801 
1802         /*
1803          * We're committing to trapping.  TRACED should be visible before
1804          * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
1805          * Also, transition to TRACED and updates to ->jobctl should be
1806          * atomic with respect to siglock and should be done after the arch
1807          * hook as siglock is released and regrabbed across it.
1808          */
1809         set_current_state(TASK_TRACED);
1810 
1811         current->last_siginfo = info;
1812         current->exit_code = exit_code;
1813 
1814         /*
1815          * If @why is CLD_STOPPED, we're trapping to participate in a group
1816          * stop.  Do the bookkeeping.  Note that if SIGCONT was delievered
1817          * across siglock relocks since INTERRUPT was scheduled, PENDING
1818          * could be clear now.  We act as if SIGCONT is received after
1819          * TASK_TRACED is entered - ignore it.
1820          */
1821         if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
1822                 gstop_done = task_participate_group_stop(current);
1823 
1824         /* any trap clears pending STOP trap, STOP trap clears NOTIFY */
1825         task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
1826         if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
1827                 task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
1828 
1829         /* entering a trap, clear TRAPPING */
1830         task_clear_jobctl_trapping(current);
1831 
1832         spin_unlock_irq(&current->sighand->siglock);
1833         read_lock(&tasklist_lock);
1834         if (may_ptrace_stop()) {
1835                 /*
1836                  * Notify parents of the stop.
1837                  *
1838                  * While ptraced, there are two parents - the ptracer and
1839                  * the real_parent of the group_leader.  The ptracer should
1840                  * know about every stop while the real parent is only
1841                  * interested in the completion of group stop.  The states
1842                  * for the two don't interact with each other.  Notify
1843                  * separately unless they're gonna be duplicates.
1844                  */
1845                 do_notify_parent_cldstop(current, true, why);
1846                 if (gstop_done && ptrace_reparented(current))
1847                         do_notify_parent_cldstop(current, false, why);
1848 
1849                 /*
1850                  * Don't want to allow preemption here, because
1851                  * sys_ptrace() needs this task to be inactive.
1852                  *
1853                  * XXX: implement read_unlock_no_resched().
1854                  */
1855                 preempt_disable();
1856                 read_unlock(&tasklist_lock);
1857                 preempt_enable_no_resched();
1858                 freezable_schedule();
1859         } else {
1860                 /*
1861                  * By the time we got the lock, our tracer went away.
1862                  * Don't drop the lock yet, another tracer may come.
1863                  *
1864                  * If @gstop_done, the ptracer went away between group stop
1865                  * completion and here.  During detach, it would have set
1866                  * JOBCTL_STOP_PENDING on us and we'll re-enter
1867                  * TASK_STOPPED in do_signal_stop() on return, so notifying
1868                  * the real parent of the group stop completion is enough.
1869                  */
1870                 if (gstop_done)
1871                         do_notify_parent_cldstop(current, false, why);
1872 
1873                 /* tasklist protects us from ptrace_freeze_traced() */
1874                 __set_current_state(TASK_RUNNING);
1875                 if (clear_code)
1876                         current->exit_code = 0;
1877                 read_unlock(&tasklist_lock);
1878         }
1879 
1880         /*
1881          * We are back.  Now reacquire the siglock before touching
1882          * last_siginfo, so that we are sure to have synchronized with
1883          * any signal-sending on another CPU that wants to examine it.
1884          */
1885         spin_lock_irq(&current->sighand->siglock);
1886         current->last_siginfo = NULL;
1887 
1888         /* LISTENING can be set only during STOP traps, clear it */
1889         current->jobctl &= ~JOBCTL_LISTENING;
1890 
1891         /*
1892          * Queued signals ignored us while we were stopped for tracing.
1893          * So check for any that we should take before resuming user mode.
1894          * This sets TIF_SIGPENDING, but never clears it.
1895          */
1896         recalc_sigpending_tsk(current);
1897 }
1898 
1899 static void ptrace_do_notify(int signr, int exit_code, int why)
1900 {
1901         siginfo_t info;
1902 
1903         memset(&info, 0, sizeof info);
1904         info.si_signo = signr;
1905         info.si_code = exit_code;
1906         info.si_pid = task_pid_vnr(current);
1907         info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1908 
1909         /* Let the debugger run.  */
1910         ptrace_stop(exit_code, why, 1, &info);
1911 }
1912 
1913 void ptrace_notify(int exit_code)
1914 {
1915         BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1916         if (unlikely(current->task_works))
1917                 task_work_run();
1918 
1919         spin_lock_irq(&current->sighand->siglock);
1920         ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
1921         spin_unlock_irq(&current->sighand->siglock);
1922 }
1923 
1924 /**
1925  * do_signal_stop - handle group stop for SIGSTOP and other stop signals
1926  * @signr: signr causing group stop if initiating
1927  *
1928  * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
1929  * and participate in it.  If already set, participate in the existing
1930  * group stop.  If participated in a group stop (and thus slept), %true is
1931  * returned with siglock released.
1932  *
1933  * If ptraced, this function doesn't handle stop itself.  Instead,
1934  * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
1935  * untouched.  The caller must ensure that INTERRUPT trap handling takes
1936  * places afterwards.
1937  *
1938  * CONTEXT:
1939  * Must be called with @current->sighand->siglock held, which is released
1940  * on %true return.
1941  *
1942  * RETURNS:
1943  * %false if group stop is already cancelled or ptrace trap is scheduled.
1944  * %true if participated in group stop.
1945  */
1946 static bool do_signal_stop(int signr)
1947         __releases(&current->sighand->siglock)
1948 {
1949         struct signal_struct *sig = current->signal;
1950 
1951         if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
1952                 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
1953                 struct task_struct *t;
1954 
1955                 /* signr will be recorded in task->jobctl for retries */
1956                 WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
1957 
1958                 if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
1959                     unlikely(signal_group_exit(sig)))
1960                         return false;
1961                 /*
1962                  * There is no group stop already in progress.  We must
1963                  * initiate one now.
1964                  *
1965                  * While ptraced, a task may be resumed while group stop is
1966                  * still in effect and then receive a stop signal and
1967                  * initiate another group stop.  This deviates from the
1968                  * usual behavior as two consecutive stop signals can't
1969                  * cause two group stops when !ptraced.  That is why we
1970                  * also check !task_is_stopped(t) below.
1971                  *
1972                  * The condition can be distinguished by testing whether
1973                  * SIGNAL_STOP_STOPPED is already set.  Don't generate
1974                  * group_exit_code in such case.
1975                  *
1976                  * This is not necessary for SIGNAL_STOP_CONTINUED because
1977                  * an intervening stop signal is required to cause two
1978                  * continued events regardless of ptrace.
1979                  */
1980                 if (!(sig->flags & SIGNAL_STOP_STOPPED))
1981                         sig->group_exit_code = signr;
1982 
1983                 sig->group_stop_count = 0;
1984 
1985                 if (task_set_jobctl_pending(current, signr | gstop))
1986                         sig->group_stop_count++;
1987 
1988                 t = current;
1989                 while_each_thread(current, t) {
1990                         /*
1991                          * Setting state to TASK_STOPPED for a group
1992                          * stop is always done with the siglock held,
1993                          * so this check has no races.
1994                          */
1995                         if (!task_is_stopped(t) &&
1996                             task_set_jobctl_pending(t, signr | gstop)) {
1997                                 sig->group_stop_count++;
1998                                 if (likely(!(t->ptrace & PT_SEIZED)))
1999                                         signal_wake_up(t, 0);
2000                                 else
2001                                         ptrace_trap_notify(t);
2002                         }
2003                 }
2004         }
2005 
2006         if (likely(!current->ptrace)) {
2007                 int notify = 0;
2008 
2009                 /*
2010                  * If there are no other threads in the group, or if there
2011                  * is a group stop in progress and we are the last to stop,
2012                  * report to the parent.
2013                  */
2014                 if (task_participate_group_stop(current))
2015                         notify = CLD_STOPPED;
2016 
2017                 __set_current_state(TASK_STOPPED);
2018                 spin_unlock_irq(&current->sighand->siglock);
2019 
2020                 /*
2021                  * Notify the parent of the group stop completion.  Because
2022                  * we're not holding either the siglock or tasklist_lock
2023                  * here, ptracer may attach inbetween; however, this is for
2024                  * group stop and should always be delivered to the real
2025                  * parent of the group leader.  The new ptracer will get
2026                  * its notification when this task transitions into
2027                  * TASK_TRACED.
2028                  */
2029                 if (notify) {
2030                         read_lock(&tasklist_lock);
2031                         do_notify_parent_cldstop(current, false, notify);
2032                         read_unlock(&tasklist_lock);
2033                 }
2034 
2035                 /* Now we don't run again until woken by SIGCONT or SIGKILL */
2036                 freezable_schedule();
2037                 return true;
2038         } else {
2039                 /*
2040                  * While ptraced, group stop is handled by STOP trap.
2041                  * Schedule it and let the caller deal with it.
2042                  */
2043                 task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
2044                 return false;
2045         }
2046 }
2047 
2048 /**
2049  * do_jobctl_trap - take care of ptrace jobctl traps
2050  *
2051  * When PT_SEIZED, it's used for both group stop and explicit
2052  * SEIZE/INTERRUPT traps.  Both generate PTRACE_EVENT_STOP trap with
2053  * accompanying siginfo.  If stopped, lower eight bits of exit_code contain
2054  * the stop signal; otherwise, %SIGTRAP.
2055  *
2056  * When !PT_SEIZED, it's used only for group stop trap with stop signal
2057  * number as exit_code and no siginfo.
2058  *
2059  * CONTEXT:
2060  * Must be called with @current->sighand->siglock held, which may be
2061  * released and re-acquired before returning with intervening sleep.
2062  */
2063 static void do_jobctl_trap(void)
2064 {
2065         struct signal_struct *signal = current->signal;
2066         int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2067 
2068         if (current->ptrace & PT_SEIZED) {
2069                 if (!signal->group_stop_count &&
2070                     !(signal->flags & SIGNAL_STOP_STOPPED))
2071                         signr = SIGTRAP;
2072                 WARN_ON_ONCE(!signr);
2073                 ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
2074                                  CLD_STOPPED);
2075         } else {
2076                 WARN_ON_ONCE(!signr);
2077                 ptrace_stop(signr, CLD_STOPPED, 0, NULL);
2078                 current->exit_code = 0;
2079         }
2080 }
2081 
2082 static int ptrace_signal(int signr, siginfo_t *info)
2083 {
2084         ptrace_signal_deliver();
2085         /*
2086          * We do not check sig_kernel_stop(signr) but set this marker
2087          * unconditionally because we do not know whether debugger will
2088          * change signr. This flag has no meaning unless we are going
2089          * to stop after return from ptrace_stop(). In this case it will
2090          * be checked in do_signal_stop(), we should only stop if it was
2091          * not cleared by SIGCONT while we were sleeping. See also the
2092          * comment in dequeue_signal().
2093          */
2094         current->jobctl |= JOBCTL_STOP_DEQUEUED;
2095         ptrace_stop(signr, CLD_TRAPPED, 0, info);
2096 
2097         /* We're back.  Did the debugger cancel the sig?  */
2098         signr = current->exit_code;
2099         if (signr == 0)
2100                 return signr;
2101 
2102         current->exit_code = 0;
2103 
2104         /*
2105          * Update the siginfo structure if the signal has
2106          * changed.  If the debugger wanted something
2107          * specific in the siginfo structure then it should
2108          * have updated *info via PTRACE_SETSIGINFO.
2109          */
2110         if (signr != info->si_signo) {
2111                 info->si_signo = signr;
2112                 info->si_errno = 0;
2113                 info->si_code = SI_USER;
2114                 rcu_read_lock();
2115                 info->si_pid = task_pid_vnr(current->parent);
2116                 info->si_uid = from_kuid_munged(current_user_ns(),
2117                                                 task_uid(current->parent));
2118                 rcu_read_unlock();
2119         }
2120 
2121         /* If the (new) signal is now blocked, requeue it.  */
2122         if (sigismember(&current->blocked, signr)) {
2123                 specific_send_sig_info(signr, info, current);
2124                 signr = 0;
2125         }
2126 
2127         return signr;
2128 }
2129 
2130 int get_signal(struct ksignal *ksig)
2131 {
2132         struct sighand_struct *sighand = current->sighand;
2133         struct signal_struct *signal = current->signal;
2134         int signr;
2135 
2136         if (unlikely(current->task_works))
2137                 task_work_run();
2138 
2139         if (unlikely(uprobe_deny_signal()))
2140                 return 0;
2141 
2142         /*
2143          * Do this once, we can't return to user-mode if freezing() == T.
2144          * do_signal_stop() and ptrace_stop() do freezable_schedule() and
2145          * thus do not need another check after return.
2146          */
2147         try_to_freeze();
2148 
2149 relock:
2150         spin_lock_irq(&sighand->siglock);
2151         /*
2152          * Every stopped thread goes here after wakeup. Check to see if
2153          * we should notify the parent, prepare_signal(SIGCONT) encodes
2154          * the CLD_ si_code into SIGNAL_CLD_MASK bits.
2155          */
2156         if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2157                 int why;
2158 
2159                 if (signal->flags & SIGNAL_CLD_CONTINUED)
2160                         why = CLD_CONTINUED;
2161                 else
2162                         why = CLD_STOPPED;
2163 
2164                 signal->flags &= ~SIGNAL_CLD_MASK;
2165 
2166                 spin_unlock_irq(&sighand->siglock);
2167 
2168                 /*
2169                  * Notify the parent that we're continuing.  This event is
2170                  * always per-process and doesn't make whole lot of sense
2171                  * for ptracers, who shouldn't consume the state via
2172                  * wait(2) either, but, for backward compatibility, notify
2173                  * the ptracer of the group leader too unless it's gonna be
2174                  * a duplicate.
2175                  */
2176                 read_lock(&tasklist_lock);
2177                 do_notify_parent_cldstop(current, false, why);
2178 
2179                 if (ptrace_reparented(current->group_leader))
2180                         do_notify_parent_cldstop(current->group_leader,
2181                                                 true, why);
2182                 read_unlock(&tasklist_lock);
2183 
2184                 goto relock;
2185         }
2186 
2187         for (;;) {
2188                 struct k_sigaction *ka;
2189 
2190                 if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
2191                     do_signal_stop(0))
2192                         goto relock;
2193 
2194                 if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
2195                         do_jobctl_trap();
2196                         spin_unlock_irq(&sighand->siglock);
2197                         goto relock;
2198                 }
2199 
2200                 signr = dequeue_signal(current, &current->blocked, &ksig->info);
2201 
2202                 if (!signr)
2203                         break; /* will return 0 */
2204 
2205                 if (unlikely(current->ptrace) && signr != SIGKILL) {
2206                         signr = ptrace_signal(signr, &ksig->info);
2207                         if (!signr)
2208                                 continue;
2209                 }
2210 
2211                 ka = &sighand->action[signr-1];
2212 
2213                 /* Trace actually delivered signals. */
2214                 trace_signal_deliver(signr, &ksig->info, ka);
2215 
2216                 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
2217                         continue;
2218                 if (ka->sa.sa_handler != SIG_DFL) {
2219                         /* Run the handler.  */
2220                         ksig->ka = *ka;
2221 
2222                         if (ka->sa.sa_flags & SA_ONESHOT)
2223                                 ka->sa.sa_handler = SIG_DFL;
2224 
2225                         break; /* will return non-zero "signr" value */
2226                 }
2227 
2228                 /*
2229                  * Now we are doing the default action for this signal.
2230                  */
2231                 if (sig_kernel_ignore(signr)) /* Default is nothing. */
2232                         continue;
2233 
2234                 /*
2235                  * Global init gets no signals it doesn't want.
2236                  * Container-init gets no signals it doesn't want from same
2237                  * container.
2238                  *
2239                  * Note that if global/container-init sees a sig_kernel_only()
2240                  * signal here, the signal must have been generated internally
2241                  * or must have come from an ancestor namespace. In either
2242                  * case, the signal cannot be dropped.
2243                  */
2244                 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2245                                 !sig_kernel_only(signr))
2246                         continue;
2247 
2248                 if (sig_kernel_stop(signr)) {
2249                         /*
2250                          * The default action is to stop all threads in
2251                          * the thread group.  The job control signals
2252                          * do nothing in an orphaned pgrp, but SIGSTOP
2253                          * always works.  Note that siglock needs to be
2254                          * dropped during the call to is_orphaned_pgrp()
2255                          * because of lock ordering with tasklist_lock.
2256                          * This allows an intervening SIGCONT to be posted.
2257                          * We need to check for that and bail out if necessary.
2258                          */
2259                         if (signr != SIGSTOP) {
2260                                 spin_unlock_irq(&sighand->siglock);
2261 
2262                                 /* signals can be posted during this window */
2263 
2264                                 if (is_current_pgrp_orphaned())
2265                                         goto relock;
2266 
2267                                 spin_lock_irq(&sighand->siglock);
2268                         }
2269 
2270                         if (likely(do_signal_stop(ksig->info.si_signo))) {
2271                                 /* It released the siglock.  */
2272                                 goto relock;
2273                         }
2274 
2275                         /*
2276                          * We didn't actually stop, due to a race
2277                          * with SIGCONT or something like that.
2278                          */
2279                         continue;
2280                 }
2281 
2282                 spin_unlock_irq(&sighand->siglock);
2283 
2284                 /*
2285                  * Anything else is fatal, maybe with a core dump.
2286                  */
2287                 current->flags |= PF_SIGNALED;
2288 
2289                 if (sig_kernel_coredump(signr)) {
2290                         if (print_fatal_signals)
2291                                 print_fatal_signal(ksig->info.si_signo);
2292                         proc_coredump_connector(current);
2293                         /*
2294                          * If it was able to dump core, this kills all
2295                          * other threads in the group and synchronizes with
2296                          * their demise.  If we lost the race with another
2297                          * thread getting here, it set group_exit_code
2298                          * first and our do_group_exit call below will use
2299                          * that value and ignore the one we pass it.
2300                          */
2301                         do_coredump(&ksig->info);
2302                 }
2303 
2304                 /*
2305                  * Death signals, no core dump.
2306                  */
2307                 do_group_exit(ksig->info.si_signo);
2308                 /* NOTREACHED */
2309         }
2310         spin_unlock_irq(&sighand->siglock);
2311 
2312         ksig->sig = signr;
2313         return ksig->sig > 0;
2314 }
2315 
2316 /**
2317  * signal_delivered - 
2318  * @ksig:               kernel signal struct
2319  * @stepping:           nonzero if debugger single-step or block-step in use
2320  *
2321  * This function should be called when a signal has successfully been
2322  * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
2323  * is always blocked, and the signal itself is blocked unless %SA_NODEFER
2324  * is set in @ksig->ka.sa.sa_flags.  Tracing is notified.
2325  */
2326 static void signal_delivered(struct ksignal *ksig, int stepping)
2327 {
2328         sigset_t blocked;
2329 
2330         /* A signal was successfully delivered, and the
2331            saved sigmask was stored on the signal frame,
2332            and will be restored by sigreturn.  So we can
2333            simply clear the restore sigmask flag.  */
2334         clear_restore_sigmask();
2335 
2336         sigorsets(&blocked, &current->blocked, &ksig->ka.sa.sa_mask);
2337         if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
2338                 sigaddset(&blocked, ksig->sig);
2339         set_current_blocked(&blocked);
2340         tracehook_signal_handler(stepping);
2341 }
2342 
2343 void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2344 {
2345         if (failed)
2346                 force_sigsegv(ksig->sig, current);
2347         else
2348                 signal_delivered(ksig, stepping);
2349 }
2350 
2351 /*
2352  * It could be that complete_signal() picked us to notify about the
2353  * group-wide signal. Other threads should be notified now to take
2354  * the shared signals in @which since we will not.
2355  */
2356 static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2357 {
2358         sigset_t retarget;
2359         struct task_struct *t;
2360 
2361         sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
2362         if (sigisemptyset(&retarget))
2363                 return;
2364 
2365         t = tsk;
2366         while_each_thread(tsk, t) {
2367                 if (t->flags & PF_EXITING)
2368                         continue;
2369 
2370                 if (!has_pending_signals(&retarget, &t->blocked))
2371                         continue;
2372                 /* Remove the signals this thread can handle. */
2373                 sigandsets(&retarget, &retarget, &t->blocked);
2374 
2375                 if (!signal_pending(t))
2376                         signal_wake_up(t, 0);
2377 
2378                 if (sigisemptyset(&retarget))
2379                         break;
2380         }
2381 }
2382 
2383 void exit_signals(struct task_struct *tsk)
2384 {
2385         int group_stop = 0;
2386         sigset_t unblocked;
2387 
2388         /*
2389          * @tsk is about to have PF_EXITING set - lock out users which
2390          * expect stable threadgroup.
2391          */
2392         threadgroup_change_begin(tsk);
2393 
2394         if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2395                 tsk->flags |= PF_EXITING;
2396                 threadgroup_change_end(tsk);
2397                 return;
2398         }
2399 
2400         spin_lock_irq(&tsk->sighand->siglock);
2401         /*
2402          * From now this task is not visible for group-wide signals,
2403          * see wants_signal(), do_signal_stop().
2404          */
2405         tsk->flags |= PF_EXITING;
2406 
2407         threadgroup_change_end(tsk);
2408 
2409         if (!signal_pending(tsk))
2410                 goto out;
2411 
2412         unblocked = tsk->blocked;
2413         signotset(&unblocked);
2414         retarget_shared_pending(tsk, &unblocked);
2415 
2416         if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2417             task_participate_group_stop(tsk))
2418                 group_stop = CLD_STOPPED;
2419 out:
2420         spin_unlock_irq(&tsk->sighand->siglock);
2421 
2422         /*
2423          * If group stop has completed, deliver the notification.  This
2424          * should always go to the real parent of the group leader.
2425          */
2426         if (unlikely(group_stop)) {
2427                 read_lock(&tasklist_lock);
2428                 do_notify_parent_cldstop(tsk, false, group_stop);
2429                 read_unlock(&tasklist_lock);
2430         }
2431 }
2432 
2433 EXPORT_SYMBOL(recalc_sigpending);
2434 EXPORT_SYMBOL_GPL(dequeue_signal);
2435 EXPORT_SYMBOL(flush_signals);
2436 EXPORT_SYMBOL(force_sig);
2437 EXPORT_SYMBOL(send_sig);
2438 EXPORT_SYMBOL(send_sig_info);
2439 EXPORT_SYMBOL(sigprocmask);
2440 
2441 /*
2442  * System call entry points.
2443  */
2444 
2445 /**
2446  *  sys_restart_syscall - restart a system call
2447  */
2448 SYSCALL_DEFINE0(restart_syscall)
2449 {
2450         struct restart_block *restart = &current->restart_block;
2451         return restart->fn(restart);
2452 }
2453 
2454 long do_no_restart_syscall(struct restart_block *param)
2455 {
2456         return -EINTR;
2457 }
2458 
2459 static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
2460 {
2461         if (signal_pending(tsk) && !thread_group_empty(tsk)) {
2462                 sigset_t newblocked;
2463                 /* A set of now blocked but previously unblocked signals. */
2464                 sigandnsets(&newblocked, newset, &current->blocked);
2465                 retarget_shared_pending(tsk, &newblocked);
2466         }
2467         tsk->blocked = *newset;
2468         recalc_sigpending();
2469 }
2470 
2471 /**
2472  * set_current_blocked - change current->blocked mask
2473  * @newset: new mask
2474  *
2475  * It is wrong to change ->blocked directly, this helper should be used
2476  * to ensure the process can't miss a shared signal we are going to block.
2477  */
2478 void set_current_blocked(sigset_t *newset)
2479 {
2480         sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2481         __set_current_blocked(newset);
2482 }
2483 
2484 void __set_current_blocked(const sigset_t *newset)
2485 {
2486         struct task_struct *tsk = current;
2487 
2488         spin_lock_irq(&tsk->sighand->siglock);
2489         __set_task_blocked(tsk, newset);
2490         spin_unlock_irq(&tsk->sighand->siglock);
2491 }
2492 
2493 /*
2494  * This is also useful for kernel threads that want to temporarily
2495  * (or permanently) block certain signals.
2496  *
2497  * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2498  * interface happily blocks "unblockable" signals like SIGKILL
2499  * and friends.
2500  */
2501 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2502 {
2503         struct task_struct *tsk = current;
2504         sigset_t newset;
2505 
2506         /* Lockless, only current can change ->blocked, never from irq */
2507         if (oldset)
2508                 *oldset = tsk->blocked;
2509 
2510         switch (how) {
2511         case SIG_BLOCK:
2512                 sigorsets(&newset, &tsk->blocked, set);
2513                 break;
2514         case SIG_UNBLOCK:
2515                 sigandnsets(&newset, &tsk->blocked, set);
2516                 break;
2517         case SIG_SETMASK:
2518                 newset = *set;
2519                 break;
2520         default:
2521                 return -EINVAL;
2522         }
2523 
2524         __set_current_blocked(&newset);
2525         return 0;
2526 }
2527 
2528 /**
2529  *  sys_rt_sigprocmask - change the list of currently blocked signals
2530  *  @how: whether to add, remove, or set signals
2531  *  @nset: stores pending signals
2532  *  @oset: previous value of signal mask if non-null
2533  *  @sigsetsize: size of sigset_t type
2534  */
2535 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
2536                 sigset_t __user *, oset, size_t, sigsetsize)
2537 {
2538         sigset_t old_set, new_set;
2539         int error;
2540 
2541         /* XXX: Don't preclude handling different sized sigset_t's.  */
2542         if (sigsetsize != sizeof(sigset_t))
2543                 return -EINVAL;
2544 
2545         old_set = current->blocked;
2546 
2547         if (nset) {
2548                 if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
2549                         return -EFAULT;
2550                 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2551 
2552                 error = sigprocmask(how, &new_set, NULL);
2553                 if (error)
2554                         return error;
2555         }
2556 
2557         if (oset) {
2558                 if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
2559                         return -EFAULT;
2560         }
2561 
2562         return 0;
2563 }
2564 
2565 #ifdef CONFIG_COMPAT
2566 COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
2567                 compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
2568 {
2569 #ifdef __BIG_ENDIAN
2570         sigset_t old_set = current->blocked;
2571 
2572         /* XXX: Don't preclude handling different sized sigset_t's.  */
2573         if (sigsetsize != sizeof(sigset_t))
2574                 return -EINVAL;
2575 
2576         if (nset) {
2577                 compat_sigset_t new32;
2578                 sigset_t new_set;
2579                 int error;
2580                 if (copy_from_user(&new32, nset, sizeof(compat_sigset_t)))
2581                         return -EFAULT;
2582 
2583                 sigset_from_compat(&new_set, &new32);
2584                 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2585 
2586                 error = sigprocmask(how, &new_set, NULL);
2587                 if (error)
2588                         return error;
2589         }
2590         if (oset) {
2591                 compat_sigset_t old32;
2592                 sigset_to_compat(&old32, &old_set);
2593                 if (copy_to_user(oset, &old32, sizeof(compat_sigset_t)))
2594                         return -EFAULT;
2595         }
2596         return 0;
2597 #else
2598         return sys_rt_sigprocmask(how, (sigset_t __user *)nset,
2599                                   (sigset_t __user *)oset, sigsetsize);
2600 #endif
2601 }
2602 #endif
2603 
2604 static int do_sigpending(void *set, unsigned long sigsetsize)
2605 {
2606         if (sigsetsize > sizeof(sigset_t))
2607                 return -EINVAL;
2608 
2609         spin_lock_irq(&current->sighand->siglock);
2610         sigorsets(set, &current->pending.signal,
2611                   &current->signal->shared_pending.signal);
2612         spin_unlock_irq(&current->sighand->siglock);
2613 
2614         /* Outside the lock because only this thread touches it.  */
2615         sigandsets(set, &current->blocked, set);
2616         return 0;
2617 }
2618 
2619 /**
2620  *  sys_rt_sigpending - examine a pending signal that has been raised
2621  *                      while blocked
2622  *  @uset: stores pending signals
2623  *  @sigsetsize: size of sigset_t type or larger
2624  */
2625 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
2626 {
2627         sigset_t set;
2628         int err = do_sigpending(&set, sigsetsize);
2629         if (!err && copy_to_user(uset, &set, sigsetsize))
2630                 err = -EFAULT;
2631         return err;
2632 }
2633 
2634 #ifdef CONFIG_COMPAT
2635 COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
2636                 compat_size_t, sigsetsize)
2637 {
2638 #ifdef __BIG_ENDIAN
2639         sigset_t set;
2640         int err = do_sigpending(&set, sigsetsize);
2641         if (!err) {
2642                 compat_sigset_t set32;
2643                 sigset_to_compat(&set32, &set);
2644                 /* we can get here only if sigsetsize <= sizeof(set) */
2645                 if (copy_to_user(uset, &set32, sigsetsize))
2646                         err = -EFAULT;
2647         }
2648         return err;
2649 #else
2650         return sys_rt_sigpending((sigset_t __user *)uset, sigsetsize);
2651 #endif
2652 }
2653 #endif
2654 
2655 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2656 
2657 int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
2658 {
2659         int err;
2660 
2661         if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2662                 return -EFAULT;
2663         if (from->si_code < 0)
2664                 return __copy_to_user(to, from, sizeof(siginfo_t))
2665                         ? -EFAULT : 0;
2666         /*
2667          * If you change siginfo_t structure, please be sure
2668          * this code is fixed accordingly.
2669          * Please remember to update the signalfd_copyinfo() function
2670          * inside fs/signalfd.c too, in case siginfo_t changes.
2671          * It should never copy any pad contained in the structure
2672          * to avoid security leaks, but must copy the generic
2673          * 3 ints plus the relevant union member.
2674          */
2675         err = __put_user(from->si_signo, &to->si_signo);
2676         err |= __put_user(from->si_errno, &to->si_errno);
2677         err |= __put_user((short)from->si_code, &to->si_code);
2678         switch (from->si_code & __SI_MASK) {
2679         case __SI_KILL:
2680                 err |= __put_user(from->si_pid, &to->si_pid);
2681                 err |= __put_user(from->si_uid, &to->si_uid);
2682                 break;
2683         case __SI_TIMER:
2684                  err |= __put_user(from->si_tid, &to->si_tid);
2685                  err |= __put_user(from->si_overrun, &to->si_overrun);
2686                  err |= __put_user(from->si_ptr, &to->si_ptr);
2687                 break;
2688         case __SI_POLL:
2689                 err |= __put_user(from->si_band, &to->si_band);
2690                 err |= __put_user(from->si_fd, &to->si_fd);
2691                 break;
2692         case __SI_FAULT:
2693                 err |= __put_user(from->si_addr, &to->si_addr);
2694 #ifdef __ARCH_SI_TRAPNO
2695                 err |= __put_user(from->si_trapno, &to->si_trapno);
2696 #endif
2697 #ifdef BUS_MCEERR_AO
2698                 /*
2699                  * Other callers might not initialize the si_lsb field,
2700                  * so check explicitly for the right codes here.
2701                  */
2702                 if (from->si_signo == SIGBUS &&
2703                     (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO))
2704                         err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
2705 #endif
2706 #ifdef SEGV_BNDERR
2707                 if (from->si_signo == SIGSEGV && from->si_code == SEGV_BNDERR) {
2708                         err |= __put_user(from->si_lower, &to->si_lower);
2709                         err |= __put_user(from->si_upper, &to->si_upper);
2710                 }
2711 #endif
2712 #ifdef SEGV_PKUERR
2713                 if (from->si_signo == SIGSEGV && from->si_code == SEGV_PKUERR)
2714                         err |= __put_user(from->si_pkey, &to->si_pkey);
2715 #endif
2716                 break;
2717         case __SI_CHLD:
2718                 err |= __put_user(from->si_pid, &to->si_pid);
2719                 err |= __put_user(from->si_uid, &to->si_uid);
2720                 err |= __put_user(from->si_status, &to->si_status);
2721                 err |= __put_user(from->si_utime, &to->si_utime);
2722                 err |= __put_user(from->si_stime, &to->si_stime);
2723                 break;
2724         case __SI_RT: /* This is not generated by the kernel as of now. */
2725         case __SI_MESGQ: /* But this is */
2726                 err |= __put_user(from->si_pid, &to->si_pid);
2727                 err |= __put_user(from->si_uid, &to->si_uid);
2728                 err |= __put_user(from->si_ptr, &to->si_ptr);
2729                 break;
2730 #ifdef __ARCH_SIGSYS
2731         case __SI_SYS:
2732                 err |= __put_user(from->si_call_addr, &to->si_call_addr);
2733                 err |= __put_user(from->si_syscall, &to->si_syscall);
2734                 err |= __put_user(from->si_arch, &to->si_arch);
2735                 break;
2736 #endif
2737         default: /* this is just in case for now ... */
2738                 err |= __put_user(from->si_pid, &to->si_pid);
2739                 err |= __put_user(from->si_uid, &to->si_uid);
2740                 break;
2741         }
2742         return err;
2743 }
2744 
2745 #endif
2746 
2747 /**
2748  *  do_sigtimedwait - wait for queued signals specified in @which
2749  *  @which: queued signals to wait for
2750  *  @info: if non-null, the signal's siginfo is returned here
2751  *  @ts: upper bound on process time suspension
2752  */
2753 int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
2754                     const struct timespec *ts)
2755 {
2756         ktime_t *to = NULL, timeout = { .tv64 = KTIME_MAX };
2757         struct task_struct *tsk = current;
2758         sigset_t mask = *which;
2759         int sig, ret = 0;
2760 
2761         if (ts) {
2762                 if (!timespec_valid(ts))
2763                         return -EINVAL;
2764                 timeout = timespec_to_ktime(*ts);
2765                 to = &timeout;
2766         }
2767 
2768         /*
2769          * Invert the set of allowed signals to get those we want to block.
2770          */
2771         sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
2772         signotset(&mask);
2773 
2774         spin_lock_irq(&tsk->sighand->siglock);
2775         sig = dequeue_signal(tsk, &mask, info);
2776         if (!sig && timeout.tv64) {
2777                 /*
2778                  * None ready, temporarily unblock those we're interested
2779                  * while we are sleeping in so that we'll be awakened when
2780                  * they arrive. Unblocking is always fine, we can avoid
2781                  * set_current_blocked().
2782                  */
2783                 tsk->real_blocked = tsk->blocked;
2784                 sigandsets(&tsk->blocked, &tsk->blocked, &mask);
2785                 recalc_sigpending();
2786                 spin_unlock_irq(&tsk->sighand->siglock);
2787 
2788                 __set_current_state(TASK_INTERRUPTIBLE);
2789                 ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns,
2790                                                          HRTIMER_MODE_REL);
2791                 spin_lock_irq(&tsk->sighand->siglock);
2792                 __set_task_blocked(tsk, &tsk->real_blocked);
2793                 sigemptyset(&tsk->real_blocked);
2794                 sig = dequeue_signal(tsk, &mask, info);
2795         }
2796         spin_unlock_irq(&tsk->sighand->siglock);
2797 
2798         if (sig)
2799                 return sig;
2800         return ret ? -EINTR : -EAGAIN;
2801 }
2802 
2803 /**
2804  *  sys_rt_sigtimedwait - synchronously wait for queued signals specified
2805  *                      in @uthese
2806  *  @uthese: queued signals to wait for
2807  *  @uinfo: if non-null, the signal's siginfo is returned here
2808  *  @uts: upper bound on process time suspension
2809  *  @sigsetsize: size of sigset_t type
2810  */
2811 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2812                 siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2813                 size_t, sigsetsize)
2814 {
2815         sigset_t these;
2816         struct timespec ts;
2817         siginfo_t info;
2818         int ret;
2819 
2820         /* XXX: Don't preclude handling different sized sigset_t's.  */
2821         if (sigsetsize != sizeof(sigset_t))
2822                 return -EINVAL;
2823 
2824         if (copy_from_user(&these, uthese, sizeof(these)))
2825                 return -EFAULT;
2826 
2827         if (uts) {
2828                 if (copy_from_user(&ts, uts, sizeof(ts)))
2829                         return -EFAULT;
2830         }
2831 
2832         ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
2833 
2834         if (ret > 0 && uinfo) {
2835                 if (copy_siginfo_to_user(uinfo, &info))
2836                         ret = -EFAULT;
2837         }
2838 
2839         return ret;
2840 }
2841 
2842 /**
2843  *  sys_kill - send a signal to a process
2844  *  @pid: the PID of the process
2845  *  @sig: signal to be sent
2846  */
2847 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
2848 {
2849         struct siginfo info;
2850         if (ccs_kill_permission(pid, sig))
2851                 return -EPERM;
2852 
2853         info.si_signo = sig;
2854         info.si_errno = 0;
2855         info.si_code = SI_USER;
2856         info.si_pid = task_tgid_vnr(current);
2857         info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2858 
2859         return kill_something_info(sig, &info, pid);
2860 }
2861 
2862 static int
2863 do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
2864 {
2865         struct task_struct *p;
2866         int error = -ESRCH;
2867 
2868         rcu_read_lock();
2869         p = find_task_by_vpid(pid);
2870         if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2871                 error = check_kill_permission(sig, info, p);
2872                 /*
2873                  * The null signal is a permissions and process existence
2874                  * probe.  No signal is actually delivered.
2875                  */
2876                 if (!error && sig) {
2877                         error = do_send_sig_info(sig, info, p, false);
2878                         /*
2879                          * If lock_task_sighand() failed we pretend the task
2880                          * dies after receiving the signal. The window is tiny,
2881                          * and the signal is private anyway.
2882                          */
2883                         if (unlikely(error == -ESRCH))
2884                                 error = 0;
2885                 }
2886         }
2887         rcu_read_unlock();
2888 
2889         return error;
2890 }
2891 
2892 static int do_tkill(pid_t tgid, pid_t pid, int sig)
2893 {
2894         struct siginfo info = {};
2895 
2896         info.si_signo = sig;
2897         info.si_errno = 0;
2898         info.si_code = SI_TKILL;
2899         info.si_pid = task_tgid_vnr(current);
2900         info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2901 
2902         return do_send_specific(tgid, pid, sig, &info);
2903 }
2904 
2905 /**
2906  *  sys_tgkill - send signal to one specific thread
2907  *  @tgid: the thread group ID of the thread
2908  *  @pid: the PID of the thread
2909  *  @sig: signal to be sent
2910  *
2911  *  This syscall also checks the @tgid and returns -ESRCH even if the PID
2912  *  exists but it's not belonging to the target process anymore. This
2913  *  method solves the problem of threads exiting and PIDs getting reused.
2914  */
2915 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
2916 {
2917         /* This is only valid for single tasks */
2918         if (pid <= 0 || tgid <= 0)
2919                 return -EINVAL;
2920         if (ccs_tgkill_permission(tgid, pid, sig))
2921                 return -EPERM;
2922 
2923         return do_tkill(tgid, pid, sig);
2924 }
2925 
2926 /**
2927  *  sys_tkill - send signal to one specific task
2928  *  @pid: the PID of the task
2929  *  @sig: signal to be sent
2930  *
2931  *  Send a signal to only one task, even if it's a CLONE_THREAD task.
2932  */
2933 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
2934 {
2935         /* This is only valid for single tasks */
2936         if (pid <= 0)
2937                 return -EINVAL;
2938         if (ccs_tkill_permission(pid, sig))
2939                 return -EPERM;
2940 
2941         return do_tkill(0, pid, sig);
2942 }
2943 
2944 static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t *info)
2945 {
2946         /* Not even root can pretend to send signals from the kernel.
2947          * Nor can they impersonate a kill()/tgkill(), which adds source info.
2948          */
2949         if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
2950             (task_pid_vnr(current) != pid))
2951                 return -EPERM;
2952 
2953         info->si_signo = sig;
2954         if (ccs_sigqueue_permission(pid, sig))
2955                 return -EPERM;
2956 
2957         /* POSIX.1b doesn't mention process groups.  */
2958         return kill_proc_info(sig, info, pid);
2959 }
2960 
2961 /**
2962  *  sys_rt_sigqueueinfo - send signal information to a signal
2963  *  @pid: the PID of the thread
2964  *  @sig: signal to be sent
2965  *  @uinfo: signal info to be sent
2966  */
2967 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
2968                 siginfo_t __user *, uinfo)
2969 {
2970         siginfo_t info;
2971         if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2972                 return -EFAULT;
2973         return do_rt_sigqueueinfo(pid, sig, &info);
2974 }
2975 
2976 #ifdef CONFIG_COMPAT
2977 COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
2978                         compat_pid_t, pid,
2979                         int, sig,
2980                         struct compat_siginfo __user *, uinfo)
2981 {
2982         siginfo_t info = {};
2983         int ret = copy_siginfo_from_user32(&info, uinfo);
2984         if (unlikely(ret))
2985                 return ret;
2986         return do_rt_sigqueueinfo(pid, sig, &info);
2987 }
2988 #endif
2989 
2990 static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
2991 {
2992         /* This is only valid for single tasks */
2993         if (pid <= 0 || tgid <= 0)
2994                 return -EINVAL;
2995 
2996         /* Not even root can pretend to send signals from the kernel.
2997          * Nor can they impersonate a kill()/tgkill(), which adds source info.
2998          */
2999         if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3000             (task_pid_vnr(current) != pid))
3001                 return -EPERM;
3002 
3003         info->si_signo = sig;
3004         if (ccs_tgsigqueue_permission(tgid, pid, sig))
3005                 return -EPERM;
3006 
3007         return do_send_specific(tgid, pid, sig, info);
3008 }
3009 
3010 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
3011                 siginfo_t __user *, uinfo)
3012 {
3013         siginfo_t info;
3014 
3015         if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3016                 return -EFAULT;
3017 
3018         return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3019 }
3020 
3021 #ifdef CONFIG_COMPAT
3022 COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
3023                         compat_pid_t, tgid,
3024                         compat_pid_t, pid,
3025                         int, sig,
3026                         struct compat_siginfo __user *, uinfo)
3027 {
3028         siginfo_t info = {};
3029 
3030         if (copy_siginfo_from_user32(&info, uinfo))
3031                 return -EFAULT;
3032         return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3033 }
3034 #endif
3035 
3036 /*
3037  * For kthreads only, must not be used if cloned with CLONE_SIGHAND
3038  */
3039 void kernel_sigaction(int sig, __sighandler_t action)
3040 {
3041         spin_lock_irq(&current->sighand->siglock);
3042         current->sighand->action[sig - 1].sa.sa_handler = action;
3043         if (action == SIG_IGN) {
3044                 sigset_t mask;
3045 
3046                 sigemptyset(&mask);
3047                 sigaddset(&mask, sig);
3048 
3049                 flush_sigqueue_mask(&mask, &current->signal->shared_pending);
3050                 flush_sigqueue_mask(&mask, &current->pending);
3051                 recalc_sigpending();
3052         }
3053         spin_unlock_irq(&current->sighand->siglock);
3054 }
3055 EXPORT_SYMBOL(kernel_sigaction);
3056 
3057 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
3058 {
3059         struct task_struct *p = current, *t;
3060         struct k_sigaction *k;
3061         sigset_t mask;
3062 
3063         if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
3064                 return -EINVAL;
3065 
3066         k = &p->sighand->action[sig-1];
3067 
3068         spin_lock_irq(&p->sighand->siglock);
3069         if (oact)
3070                 *oact = *k;
3071 
3072         if (act) {
3073                 sigdelsetmask(&act->sa.sa_mask,
3074                               sigmask(SIGKILL) | sigmask(SIGSTOP));
3075                 *k = *act;
3076                 /*
3077                  * POSIX 3.3.1.3:
3078                  *  "Setting a signal action to SIG_IGN for a signal that is
3079                  *   pending shall cause the pending signal to be discarded,
3080                  *   whether or not it is blocked."
3081                  *
3082                  *  "Setting a signal action to SIG_DFL for a signal that is
3083                  *   pending and whose default action is to ignore the signal
3084                  *   (for example, SIGCHLD), shall cause the pending signal to
3085                  *   be discarded, whether or not it is blocked"
3086                  */
3087                 if (sig_handler_ignored(sig_handler(p, sig), sig)) {
3088                         sigemptyset(&mask);
3089                         sigaddset(&mask, sig);
3090                         flush_sigqueue_mask(&mask, &p->signal->shared_pending);
3091                         for_each_thread(p, t)
3092                                 flush_sigqueue_mask(&mask, &t->pending);
3093                 }
3094         }
3095 
3096         spin_unlock_irq(&p->sighand->siglock);
3097         return 0;
3098 }
3099 
3100 static int
3101 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
3102 {
3103         stack_t oss;
3104         int error;
3105 
3106         oss.ss_sp = (void __user *) current->sas_ss_sp;
3107         oss.ss_size = current->sas_ss_size;
3108         oss.ss_flags = sas_ss_flags(sp) |
3109                 (current->sas_ss_flags & SS_FLAG_BITS);
3110 
3111         if (uss) {
3112                 void __user *ss_sp;
3113                 size_t ss_size;
3114                 unsigned ss_flags;
3115                 int ss_mode;
3116 
3117                 error = -EFAULT;
3118                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
3119                         goto out;
3120                 error = __get_user(ss_sp, &uss->ss_sp) |
3121                         __get_user(ss_flags, &uss->ss_flags) |
3122                         __get_user(ss_size, &uss->ss_size);
3123                 if (error)
3124                         goto out;
3125 
3126                 error = -EPERM;
3127                 if (on_sig_stack(sp))
3128                         goto out;
3129 
3130                 ss_mode = ss_flags & ~SS_FLAG_BITS;
3131                 error = -EINVAL;
3132                 if (ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
3133                                 ss_mode != 0)
3134                         goto out;
3135 
3136                 if (ss_mode == SS_DISABLE) {
3137                         ss_size = 0;
3138                         ss_sp = NULL;
3139                 } else {
3140                         error = -ENOMEM;
3141                         if (ss_size < MINSIGSTKSZ)
3142                                 goto out;
3143                 }
3144 
3145                 current->sas_ss_sp = (unsigned long) ss_sp;
3146                 current->sas_ss_size = ss_size;
3147                 current->sas_ss_flags = ss_flags;
3148         }
3149 
3150         error = 0;
3151         if (uoss) {
3152                 error = -EFAULT;
3153                 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
3154                         goto out;
3155                 error = __put_user(oss.ss_sp, &uoss->ss_sp) |
3156                         __put_user(oss.ss_size, &uoss->ss_size) |
3157                         __put_user(oss.ss_flags, &uoss->ss_flags);
3158         }
3159 
3160 out:
3161         return error;
3162 }
3163 SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
3164 {
3165         return do_sigaltstack(uss, uoss, current_user_stack_pointer());
3166 }
3167 
3168 int restore_altstack(const stack_t __user *uss)
3169 {
3170         int err = do_sigaltstack(uss, NULL, current_user_stack_pointer());
3171         /* squash all but EFAULT for now */
3172         return err == -EFAULT ? err : 0;
3173 }
3174 
3175 int __save_altstack(stack_t __user *uss, unsigned long sp)
3176 {
3177         struct task_struct *t = current;
3178         int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
3179                 __put_user(t->sas_ss_flags, &uss->ss_flags) |
3180                 __put_user(t->sas_ss_size, &uss->ss_size);
3181         if (err)
3182                 return err;
3183         if (t->sas_ss_flags & SS_AUTODISARM)
3184                 sas_ss_reset(t);
3185         return 0;
3186 }
3187 
3188 #ifdef CONFIG_COMPAT
3189 COMPAT_SYSCALL_DEFINE2(sigaltstack,
3190                         const compat_stack_t __user *, uss_ptr,
3191                         compat_stack_t __user *, uoss_ptr)
3192 {
3193         stack_t uss, uoss;
3194         int ret;
3195         mm_segment_t seg;
3196 
3197         if (uss_ptr) {
3198                 compat_stack_t uss32;
3199 
3200                 memset(&uss, 0, sizeof(stack_t));
3201                 if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
3202                         return -EFAULT;
3203                 uss.ss_sp = compat_ptr(uss32.ss_sp);
3204                 uss.ss_flags = uss32.ss_flags;
3205                 uss.ss_size = uss32.ss_size;
3206         }
3207         seg = get_fs();
3208         set_fs(KERNEL_DS);
3209         ret = do_sigaltstack((stack_t __force __user *) (uss_ptr ? &uss : NULL),
3210                              (stack_t __force __user *) &uoss,
3211                              compat_user_stack_pointer());
3212         set_fs(seg);
3213         if (ret >= 0 && uoss_ptr)  {
3214                 if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(compat_stack_t)) ||
3215                     __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
3216                     __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
3217                     __put_user(uoss.ss_size, &uoss_ptr->ss_size))
3218                         ret = -EFAULT;
3219         }
3220         return ret;
3221 }
3222 
3223 int compat_restore_altstack(const compat_stack_t __user *uss)
3224 {
3225         int err = compat_sys_sigaltstack(uss, NULL);
3226         /* squash all but -EFAULT for now */
3227         return err == -EFAULT ? err : 0;
3228 }
3229 
3230 int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
3231 {
3232         struct task_struct *t = current;
3233         return  __put_user(ptr_to_compat((void __user *)t->sas_ss_sp), &uss->ss_sp) |
3234                 __put_user(sas_ss_flags(sp), &uss->ss_flags) |
3235                 __put_user(t->sas_ss_size, &uss->ss_size);
3236 }
3237 #endif
3238 
3239 #ifdef __ARCH_WANT_SYS_SIGPENDING
3240 
3241 /**
3242  *  sys_sigpending - examine pending signals
3243  *  @set: where mask of pending signal is returned
3244  */
3245 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
3246 {
3247         return sys_rt_sigpending((sigset_t __user *)set, sizeof(old_sigset_t)); 
3248 }
3249 
3250 #endif
3251 
3252 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
3253 /**
3254  *  sys_sigprocmask - examine and change blocked signals
3255  *  @how: whether to add, remove, or set signals
3256  *  @nset: signals to add or remove (if non-null)
3257  *  @oset: previous value of signal mask if non-null
3258  *
3259  * Some platforms have their own version with special arguments;
3260  * others support only sys_rt_sigprocmask.
3261  */
3262 
3263 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
3264                 old_sigset_t __user *, oset)
3265 {
3266         old_sigset_t old_set, new_set;
3267         sigset_t new_blocked;
3268 
3269         old_set = current->blocked.sig[0];
3270 
3271         if (nset) {
3272                 if (copy_from_user(&new_set, nset, sizeof(*nset)))
3273                         return -EFAULT;
3274 
3275                 new_blocked = current->blocked;
3276 
3277                 switch (how) {
3278                 case SIG_BLOCK:
3279                         sigaddsetmask(&new_blocked, new_set);
3280                         break;
3281                 case SIG_UNBLOCK:
3282                         sigdelsetmask(&new_blocked, new_set);
3283                         break;
3284                 case SIG_SETMASK:
3285                         new_blocked.sig[0] = new_set;
3286                         break;
3287                 default:
3288                         return -EINVAL;
3289                 }
3290 
3291                 set_current_blocked(&new_blocked);
3292         }
3293 
3294         if (oset) {
3295                 if (copy_to_user(oset, &old_set, sizeof(*oset)))
3296                         return -EFAULT;
3297         }
3298 
3299         return 0;
3300 }
3301 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
3302 
3303 #ifndef CONFIG_ODD_RT_SIGACTION
3304 /**
3305  *  sys_rt_sigaction - alter an action taken by a process
3306  *  @sig: signal to be sent
3307  *  @act: new sigaction
3308  *  @oact: used to save the previous sigaction
3309  *  @sigsetsize: size of sigset_t type
3310  */
3311 SYSCALL_DEFINE4(rt_sigaction, int, sig,
3312                 const struct sigaction __user *, act,
3313                 struct sigaction __user *, oact,
3314                 size_t, sigsetsize)
3315 {
3316         struct k_sigaction new_sa, old_sa;
3317         int ret = -EINVAL;
3318 
3319         /* XXX: Don't preclude handling different sized sigset_t's.  */
3320         if (sigsetsize != sizeof(sigset_t))
3321                 goto out;
3322 
3323         if (act) {
3324                 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
3325                         return -EFAULT;
3326         }
3327 
3328         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
3329 
3330         if (!ret && oact) {
3331                 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
3332                         return -EFAULT;
3333         }
3334 out:
3335         return ret;
3336 }
3337 #ifdef CONFIG_COMPAT
3338 COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
3339                 const struct compat_sigaction __user *, act,
3340                 struct compat_sigaction __user *, oact,
3341                 compat_size_t, sigsetsize)
3342 {
3343         struct k_sigaction new_ka, old_ka;
3344         compat_sigset_t mask;
3345 #ifdef __ARCH_HAS_SA_RESTORER
3346         compat_uptr_t restorer;
3347 #endif
3348         int ret;
3349 
3350         /* XXX: Don't preclude handling different sized sigset_t's.  */
3351         if (sigsetsize != sizeof(compat_sigset_t))
3352                 return -EINVAL;
3353 
3354         if (act) {
3355                 compat_uptr_t handler;
3356                 ret = get_user(handler, &act->sa_handler);
3357                 new_ka.sa.sa_handler = compat_ptr(handler);
3358 #ifdef __ARCH_HAS_SA_RESTORER
3359                 ret |= get_user(restorer, &act->sa_restorer);
3360                 new_ka.sa.sa_restorer = compat_ptr(restorer);
3361 #endif
3362                 ret |= copy_from_user(&mask, &act->sa_mask, sizeof(mask));
3363                 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
3364                 if (ret)
3365                         return -EFAULT;
3366                 sigset_from_compat(&new_ka.sa.sa_mask, &mask);
3367         }
3368 
3369         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3370         if (!ret && oact) {
3371                 sigset_to_compat(&mask, &old_ka.sa.sa_mask);
3372                 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), 
3373                                &oact->sa_handler);
3374                 ret |= copy_to_user(&oact->sa_mask, &mask, sizeof(mask));
3375                 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
3376 #ifdef __ARCH_HAS_SA_RESTORER
3377                 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3378                                 &oact->sa_restorer);
3379 #endif
3380         }
3381         return ret;
3382 }
3383 #endif
3384 #endif /* !CONFIG_ODD_RT_SIGACTION */
3385 
3386 #ifdef CONFIG_OLD_SIGACTION
3387 SYSCALL_DEFINE3(sigaction, int, sig,
3388                 const struct old_sigaction __user *, act,
3389                 struct old_sigaction __user *, oact)
3390 {
3391         struct k_sigaction new_ka, old_ka;
3392         int ret;
3393 
3394         if (act) {
3395                 old_sigset_t mask;
3396                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3397                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
3398                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
3399                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3400                     __get_user(mask, &act->sa_mask))
3401                         return -EFAULT;
3402 #ifdef __ARCH_HAS_KA_RESTORER
3403                 new_ka.ka_restorer = NULL;
3404 #endif
3405                 siginitset(&new_ka.sa.sa_mask, mask);
3406         }
3407 
3408         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3409 
3410         if (!ret && oact) {
3411                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3412                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
3413                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
3414                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3415                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3416                         return -EFAULT;
3417         }
3418 
3419         return ret;
3420 }
3421 #endif
3422 #ifdef CONFIG_COMPAT_OLD_SIGACTION
3423 COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
3424                 const struct compat_old_sigaction __user *, act,
3425                 struct compat_old_sigaction __user *, oact)
3426 {
3427         struct k_sigaction new_ka, old_ka;
3428         int ret;
3429         compat_old_sigset_t mask;
3430         compat_uptr_t handler, restorer;
3431 
3432         if (act) {
3433                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3434                     __get_user(handler, &act->sa_handler) ||
3435                     __get_user(restorer, &act->sa_restorer) ||
3436                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3437                     __get_user(mask, &act->sa_mask))
3438                         return -EFAULT;
3439 
3440 #ifdef __ARCH_HAS_KA_RESTORER
3441                 new_ka.ka_restorer = NULL;
3442 #endif
3443                 new_ka.sa.sa_handler = compat_ptr(handler);
3444                 new_ka.sa.sa_restorer = compat_ptr(restorer);
3445                 siginitset(&new_ka.sa.sa_mask, mask);
3446         }
3447 
3448         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3449 
3450         if (!ret && oact) {
3451                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3452                     __put_user(ptr_to_compat(old_ka.sa.sa_handler),
3453                                &oact->sa_handler) ||
3454                     __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3455                                &oact->sa_restorer) ||
3456                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3457                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3458                         return -EFAULT;
3459         }
3460         return ret;
3461 }
3462 #endif
3463 
3464 #ifdef CONFIG_SGETMASK_SYSCALL
3465 
3466 /*
3467  * For backwards compatibility.  Functionality superseded by sigprocmask.
3468  */
3469 SYSCALL_DEFINE0(sgetmask)
3470 {
3471         /* SMP safe */
3472         return current->blocked.sig[0];
3473 }
3474 
3475 SYSCALL_DEFINE1(ssetmask, int, newmask)
3476 {
3477         int old = current->blocked.sig[0];
3478         sigset_t newset;
3479 
3480         siginitset(&newset, newmask);
3481         set_current_blocked(&newset);
3482 
3483         return old;
3484 }
3485 #endif /* CONFIG_SGETMASK_SYSCALL */
3486 
3487 #ifdef __ARCH_WANT_SYS_SIGNAL
3488 /*
3489  * For backwards compatibility.  Functionality superseded by sigaction.
3490  */
3491 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
3492 {
3493         struct k_sigaction new_sa, old_sa;
3494         int ret;
3495 
3496         new_sa.sa.sa_handler = handler;
3497         new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
3498         sigemptyset(&new_sa.sa.sa_mask);
3499 
3500         ret = do_sigaction(sig, &new_sa, &old_sa);
3501 
3502         return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
3503 }
3504 #endif /* __ARCH_WANT_SYS_SIGNAL */
3505 
3506 #ifdef __ARCH_WANT_SYS_PAUSE
3507 
3508 SYSCALL_DEFINE0(pause)
3509 {
3510         while (!signal_pending(current)) {
3511                 __set_current_state(TASK_INTERRUPTIBLE);
3512                 schedule();
3513         }
3514         return -ERESTARTNOHAND;
3515 }
3516 
3517 #endif
3518 
3519 static int sigsuspend(sigset_t *set)
3520 {
3521         current->saved_sigmask = current->blocked;
3522         set_current_blocked(set);
3523 
3524         while (!signal_pending(current)) {
3525                 __set_current_state(TASK_INTERRUPTIBLE);
3526                 schedule();
3527         }
3528         set_restore_sigmask();
3529         return -ERESTARTNOHAND;
3530 }
3531 
3532 /**
3533  *  sys_rt_sigsuspend - replace the signal mask for a value with the
3534  *      @unewset value until a signal is received
3535  *  @unewset: new signal mask value
3536  *  @sigsetsize: size of sigset_t type
3537  */
3538 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
3539 {
3540         sigset_t newset;
3541 
3542         /* XXX: Don't preclude handling different sized sigset_t's.  */
3543         if (sigsetsize != sizeof(sigset_t))
3544                 return -EINVAL;
3545 
3546         if (copy_from_user(&newset, unewset, sizeof(newset)))
3547                 return -EFAULT;
3548         return sigsuspend(&newset);
3549 }
3550  
3551 #ifdef CONFIG_COMPAT
3552 COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
3553 {
3554 #ifdef __BIG_ENDIAN
3555         sigset_t newset;
3556         compat_sigset_t newset32;
3557 
3558         /* XXX: Don't preclude handling different sized sigset_t's.  */
3559         if (sigsetsize != sizeof(sigset_t))
3560                 return -EINVAL;
3561 
3562         if (copy_from_user(&newset32, unewset, sizeof(compat_sigset_t)))
3563                 return -EFAULT;
3564         sigset_from_compat(&newset, &newset32);
3565         return sigsuspend(&newset);
3566 #else
3567         /* on little-endian bitmaps don't care about granularity */
3568         return sys_rt_sigsuspend((sigset_t __user *)unewset, sigsetsize);
3569 #endif
3570 }
3571 #endif
3572 
3573 #ifdef CONFIG_OLD_SIGSUSPEND
3574 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
3575 {
3576         sigset_t blocked;
3577         siginitset(&blocked, mask);
3578         return sigsuspend(&blocked);
3579 }
3580 #endif
3581 #ifdef CONFIG_OLD_SIGSUSPEND3
3582 SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
3583 {
3584         sigset_t blocked;
3585         siginitset(&blocked, mask);
3586         return sigsuspend(&blocked);
3587 }
3588 #endif
3589 
3590 __weak const char *arch_vma_name(struct vm_area_struct *vma)
3591 {
3592         return NULL;
3593 }
3594 
3595 void __init signals_init(void)
3596 {
3597         /* If this check fails, the __ARCH_SI_PREAMBLE_SIZE value is wrong! */
3598         BUILD_BUG_ON(__ARCH_SI_PREAMBLE_SIZE
3599                 != offsetof(struct siginfo, _sifields._pad));
3600 
3601         sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
3602 }
3603 
3604 #ifdef CONFIG_KGDB_KDB
3605 #include <linux/kdb.h>
3606 /*
3607  * kdb_send_sig_info - Allows kdb to send signals without exposing
3608  * signal internals.  This function checks if the required locks are
3609  * available before calling the main signal code, to avoid kdb
3610  * deadlocks.
3611  */
3612 void
3613 kdb_send_sig_info(struct task_struct *t, struct siginfo *info)
3614 {
3615         static struct task_struct *kdb_prev_t;
3616         int sig, new_t;
3617         if (!spin_trylock(&t->sighand->siglock)) {
3618                 kdb_printf("Can't do kill command now.\n"
3619                            "The sigmask lock is held somewhere else in "
3620                            "kernel, try again later\n");
3621                 return;
3622         }
3623         spin_unlock(&t->sighand->siglock);
3624         new_t = kdb_prev_t != t;
3625         kdb_prev_t = t;
3626         if (t->state != TASK_RUNNING && new_t) {
3627                 kdb_printf("Process is not RUNNING, sending a signal from "
3628                            "kdb risks deadlock\n"
3629                            "on the run queue locks. "
3630                            "The signal has _not_ been sent.\n"
3631                            "Reissue the kill command if you want to risk "
3632                            "the deadlock.\n");
3633                 return;
3634         }
3635         sig = info->si_signo;
3636         if (send_sig_info(sig, info, t))
3637                 kdb_printf("Fail to deliver Signal %d to process %d.\n",
3638                            sig, t->pid);
3639         else
3640                 kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
3641 }
3642 #endif  /* CONFIG_KGDB_KDB */
3643 

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