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

TOMOYO Linux Cross Reference
Linux/kernel/signal.c

Version: ~ [ linux-5.3 ] ~ [ linux-5.2.14 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.72 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.143 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.192 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.192 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.73 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

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