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

TOMOYO Linux Cross Reference
Linux/kernel/signal.c

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

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