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

TOMOYO Linux Cross Reference
Linux/kernel/signal.c

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

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