Back to home page

LXR

 
 

    


0001 /*
0002  *  linux/kernel/signal.c
0003  *
0004  *  Copyright (C) 1991, 1992  Linus Torvalds
0005  *
0006  *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
0007  *
0008  *  2003-06-02  Jim Houston - Concurrent Computer Corp.
0009  *      Changes to use preallocated sigqueue structures
0010  *      to allow signals to be sent reliably.
0011  */
0012 
0013 #include <linux/slab.h>
0014 #include <linux/export.h>
0015 #include <linux/init.h>
0016 #include <linux/sched.h>
0017 #include <linux/fs.h>
0018 #include <linux/tty.h>
0019 #include <linux/binfmts.h>
0020 #include <linux/coredump.h>
0021 #include <linux/security.h>
0022 #include <linux/syscalls.h>
0023 #include <linux/ptrace.h>
0024 #include <linux/signal.h>
0025 #include <linux/signalfd.h>
0026 #include <linux/ratelimit.h>
0027 #include <linux/tracehook.h>
0028 #include <linux/capability.h>
0029 #include <linux/freezer.h>
0030 #include <linux/pid_namespace.h>
0031 #include <linux/nsproxy.h>
0032 #include <linux/user_namespace.h>
0033 #include <linux/uprobes.h>
0034 #include <linux/compat.h>
0035 #include <linux/cn_proc.h>
0036 #include <linux/compiler.h>
0037 
0038 #define CREATE_TRACE_POINTS
0039 #include <trace/events/signal.h>
0040 
0041 #include <asm/param.h>
0042 #include <linux/uaccess.h>
0043 #include <asm/unistd.h>
0044 #include <asm/siginfo.h>
0045 #include <asm/cacheflush.h>
0046 #include "audit.h"  /* audit_signal_info() */
0047 
0048 /*
0049  * SLAB caches for signal bits.
0050  */
0051 
0052 static struct kmem_cache *sigqueue_cachep;
0053 
0054 int print_fatal_signals __read_mostly;
0055 
0056 static void __user *sig_handler(struct task_struct *t, int sig)
0057 {
0058     return t->sighand->action[sig - 1].sa.sa_handler;
0059 }
0060 
0061 static int sig_handler_ignored(void __user *handler, int sig)
0062 {
0063     /* Is it explicitly or implicitly ignored? */
0064     return handler == SIG_IGN ||
0065         (handler == SIG_DFL && sig_kernel_ignore(sig));
0066 }
0067 
0068 static int sig_task_ignored(struct task_struct *t, int sig, bool force)
0069 {
0070     void __user *handler;
0071 
0072     handler = sig_handler(t, sig);
0073 
0074     if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
0075             handler == SIG_DFL && !force)
0076         return 1;
0077 
0078     return sig_handler_ignored(handler, sig);
0079 }
0080 
0081 static int sig_ignored(struct task_struct *t, int sig, bool force)
0082 {
0083     /*
0084      * Blocked signals are never ignored, since the
0085      * signal handler may change by the time it is
0086      * unblocked.
0087      */
0088     if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
0089         return 0;
0090 
0091     if (!sig_task_ignored(t, sig, force))
0092         return 0;
0093 
0094     /*
0095      * Tracers may want to know about even ignored signals.
0096      */
0097     return !t->ptrace;
0098 }
0099 
0100 /*
0101  * Re-calculate pending state from the set of locally pending
0102  * signals, globally pending signals, and blocked signals.
0103  */
0104 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
0105 {
0106     unsigned long ready;
0107     long i;
0108 
0109     switch (_NSIG_WORDS) {
0110     default:
0111         for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
0112             ready |= signal->sig[i] &~ blocked->sig[i];
0113         break;
0114 
0115     case 4: ready  = signal->sig[3] &~ blocked->sig[3];
0116         ready |= signal->sig[2] &~ blocked->sig[2];
0117         ready |= signal->sig[1] &~ blocked->sig[1];
0118         ready |= signal->sig[0] &~ blocked->sig[0];
0119         break;
0120 
0121     case 2: ready  = signal->sig[1] &~ blocked->sig[1];
0122         ready |= signal->sig[0] &~ blocked->sig[0];
0123         break;
0124 
0125     case 1: ready  = signal->sig[0] &~ blocked->sig[0];
0126     }
0127     return ready != 0;
0128 }
0129 
0130 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
0131 
0132 static int recalc_sigpending_tsk(struct task_struct *t)
0133 {
0134     if ((t->jobctl & JOBCTL_PENDING_MASK) ||
0135         PENDING(&t->pending, &t->blocked) ||
0136         PENDING(&t->signal->shared_pending, &t->blocked)) {
0137         set_tsk_thread_flag(t, TIF_SIGPENDING);
0138         return 1;
0139     }
0140     /*
0141      * We must never clear the flag in another thread, or in current
0142      * when it's possible the current syscall is returning -ERESTART*.
0143      * So we don't clear it here, and only callers who know they should do.
0144      */
0145     return 0;
0146 }
0147 
0148 /*
0149  * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
0150  * This is superfluous when called on current, the wakeup is a harmless no-op.
0151  */
0152 void recalc_sigpending_and_wake(struct task_struct *t)
0153 {
0154     if (recalc_sigpending_tsk(t))
0155         signal_wake_up(t, 0);
0156 }
0157 
0158 void recalc_sigpending(void)
0159 {
0160     if (!recalc_sigpending_tsk(current) && !freezing(current))
0161         clear_thread_flag(TIF_SIGPENDING);
0162 
0163 }
0164 
0165 /* Given the mask, find the first available signal that should be serviced. */
0166 
0167 #define SYNCHRONOUS_MASK \
0168     (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
0169      sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
0170 
0171 int next_signal(struct sigpending *pending, sigset_t *mask)
0172 {
0173     unsigned long i, *s, *m, x;
0174     int sig = 0;
0175 
0176     s = pending->signal.sig;
0177     m = mask->sig;
0178 
0179     /*
0180      * Handle the first word specially: it contains the
0181      * synchronous signals that need to be dequeued first.
0182      */
0183     x = *s &~ *m;
0184     if (x) {
0185         if (x & SYNCHRONOUS_MASK)
0186             x &= SYNCHRONOUS_MASK;
0187         sig = ffz(~x) + 1;
0188         return sig;
0189     }
0190 
0191     switch (_NSIG_WORDS) {
0192     default:
0193         for (i = 1; i < _NSIG_WORDS; ++i) {
0194             x = *++s &~ *++m;
0195             if (!x)
0196                 continue;
0197             sig = ffz(~x) + i*_NSIG_BPW + 1;
0198             break;
0199         }
0200         break;
0201 
0202     case 2:
0203         x = s[1] &~ m[1];
0204         if (!x)
0205             break;
0206         sig = ffz(~x) + _NSIG_BPW + 1;
0207         break;
0208 
0209     case 1:
0210         /* Nothing to do */
0211         break;
0212     }
0213 
0214     return sig;
0215 }
0216 
0217 static inline void print_dropped_signal(int sig)
0218 {
0219     static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
0220 
0221     if (!print_fatal_signals)
0222         return;
0223 
0224     if (!__ratelimit(&ratelimit_state))
0225         return;
0226 
0227     pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
0228                 current->comm, current->pid, sig);
0229 }
0230 
0231 /**
0232  * task_set_jobctl_pending - set jobctl pending bits
0233  * @task: target task
0234  * @mask: pending bits to set
0235  *
0236  * Clear @mask from @task->jobctl.  @mask must be subset of
0237  * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
0238  * %JOBCTL_TRAPPING.  If stop signo is being set, the existing signo is
0239  * cleared.  If @task is already being killed or exiting, this function
0240  * becomes noop.
0241  *
0242  * CONTEXT:
0243  * Must be called with @task->sighand->siglock held.
0244  *
0245  * RETURNS:
0246  * %true if @mask is set, %false if made noop because @task was dying.
0247  */
0248 bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
0249 {
0250     BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
0251             JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
0252     BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
0253 
0254     if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
0255         return false;
0256 
0257     if (mask & JOBCTL_STOP_SIGMASK)
0258         task->jobctl &= ~JOBCTL_STOP_SIGMASK;
0259 
0260     task->jobctl |= mask;
0261     return true;
0262 }
0263 
0264 /**
0265  * task_clear_jobctl_trapping - clear jobctl trapping bit
0266  * @task: target task
0267  *
0268  * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
0269  * Clear it and wake up the ptracer.  Note that we don't need any further
0270  * locking.  @task->siglock guarantees that @task->parent points to the
0271  * ptracer.
0272  *
0273  * CONTEXT:
0274  * Must be called with @task->sighand->siglock held.
0275  */
0276 void task_clear_jobctl_trapping(struct task_struct *task)
0277 {
0278     if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
0279         task->jobctl &= ~JOBCTL_TRAPPING;
0280         smp_mb();   /* advised by wake_up_bit() */
0281         wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
0282     }
0283 }
0284 
0285 /**
0286  * task_clear_jobctl_pending - clear jobctl pending bits
0287  * @task: target task
0288  * @mask: pending bits to clear
0289  *
0290  * Clear @mask from @task->jobctl.  @mask must be subset of
0291  * %JOBCTL_PENDING_MASK.  If %JOBCTL_STOP_PENDING is being cleared, other
0292  * STOP bits are cleared together.
0293  *
0294  * If clearing of @mask leaves no stop or trap pending, this function calls
0295  * task_clear_jobctl_trapping().
0296  *
0297  * CONTEXT:
0298  * Must be called with @task->sighand->siglock held.
0299  */
0300 void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
0301 {
0302     BUG_ON(mask & ~JOBCTL_PENDING_MASK);
0303 
0304     if (mask & JOBCTL_STOP_PENDING)
0305         mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
0306 
0307     task->jobctl &= ~mask;
0308 
0309     if (!(task->jobctl & JOBCTL_PENDING_MASK))
0310         task_clear_jobctl_trapping(task);
0311 }
0312 
0313 /**
0314  * task_participate_group_stop - participate in a group stop
0315  * @task: task participating in a group stop
0316  *
0317  * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
0318  * Group stop states are cleared and the group stop count is consumed if
0319  * %JOBCTL_STOP_CONSUME was set.  If the consumption completes the group
0320  * stop, the appropriate %SIGNAL_* flags are set.
0321  *
0322  * CONTEXT:
0323  * Must be called with @task->sighand->siglock held.
0324  *
0325  * RETURNS:
0326  * %true if group stop completion should be notified to the parent, %false
0327  * otherwise.
0328  */
0329 static bool task_participate_group_stop(struct task_struct *task)
0330 {
0331     struct signal_struct *sig = task->signal;
0332     bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
0333 
0334     WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
0335 
0336     task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
0337 
0338     if (!consume)
0339         return false;
0340 
0341     if (!WARN_ON_ONCE(sig->group_stop_count == 0))
0342         sig->group_stop_count--;
0343 
0344     /*
0345      * Tell the caller to notify completion iff we are entering into a
0346      * fresh group stop.  Read comment in do_signal_stop() for details.
0347      */
0348     if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
0349         signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED);
0350         return true;
0351     }
0352     return false;
0353 }
0354 
0355 /*
0356  * allocate a new signal queue record
0357  * - this may be called without locks if and only if t == current, otherwise an
0358  *   appropriate lock must be held to stop the target task from exiting
0359  */
0360 static struct sigqueue *
0361 __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
0362 {
0363     struct sigqueue *q = NULL;
0364     struct user_struct *user;
0365 
0366     /*
0367      * Protect access to @t credentials. This can go away when all
0368      * callers hold rcu read lock.
0369      */
0370     rcu_read_lock();
0371     user = get_uid(__task_cred(t)->user);
0372     atomic_inc(&user->sigpending);
0373     rcu_read_unlock();
0374 
0375     if (override_rlimit ||
0376         atomic_read(&user->sigpending) <=
0377             task_rlimit(t, RLIMIT_SIGPENDING)) {
0378         q = kmem_cache_alloc(sigqueue_cachep, flags);
0379     } else {
0380         print_dropped_signal(sig);
0381     }
0382 
0383     if (unlikely(q == NULL)) {
0384         atomic_dec(&user->sigpending);
0385         free_uid(user);
0386     } else {
0387         INIT_LIST_HEAD(&q->list);
0388         q->flags = 0;
0389         q->user = user;
0390     }
0391 
0392     return q;
0393 }
0394 
0395 static void __sigqueue_free(struct sigqueue *q)
0396 {
0397     if (q->flags & SIGQUEUE_PREALLOC)
0398         return;
0399     atomic_dec(&q->user->sigpending);
0400     free_uid(q->user);
0401     kmem_cache_free(sigqueue_cachep, q);
0402 }
0403 
0404 void flush_sigqueue(struct sigpending *queue)
0405 {
0406     struct sigqueue *q;
0407 
0408     sigemptyset(&queue->signal);
0409     while (!list_empty(&queue->list)) {
0410         q = list_entry(queue->list.next, struct sigqueue , list);
0411         list_del_init(&q->list);
0412         __sigqueue_free(q);
0413     }
0414 }
0415 
0416 /*
0417  * Flush all pending signals for this kthread.
0418  */
0419 void flush_signals(struct task_struct *t)
0420 {
0421     unsigned long flags;
0422 
0423     spin_lock_irqsave(&t->sighand->siglock, flags);
0424     clear_tsk_thread_flag(t, TIF_SIGPENDING);
0425     flush_sigqueue(&t->pending);
0426     flush_sigqueue(&t->signal->shared_pending);
0427     spin_unlock_irqrestore(&t->sighand->siglock, flags);
0428 }
0429 
0430 #ifdef CONFIG_POSIX_TIMERS
0431 static void __flush_itimer_signals(struct sigpending *pending)
0432 {
0433     sigset_t signal, retain;
0434     struct sigqueue *q, *n;
0435 
0436     signal = pending->signal;
0437     sigemptyset(&retain);
0438 
0439     list_for_each_entry_safe(q, n, &pending->list, list) {
0440         int sig = q->info.si_signo;
0441 
0442         if (likely(q->info.si_code != SI_TIMER)) {
0443             sigaddset(&retain, sig);
0444         } else {
0445             sigdelset(&signal, sig);
0446             list_del_init(&q->list);
0447             __sigqueue_free(q);
0448         }
0449     }
0450 
0451     sigorsets(&pending->signal, &signal, &retain);
0452 }
0453 
0454 void flush_itimer_signals(void)
0455 {
0456     struct task_struct *tsk = current;
0457     unsigned long flags;
0458 
0459     spin_lock_irqsave(&tsk->sighand->siglock, flags);
0460     __flush_itimer_signals(&tsk->pending);
0461     __flush_itimer_signals(&tsk->signal->shared_pending);
0462     spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
0463 }
0464 #endif
0465 
0466 void ignore_signals(struct task_struct *t)
0467 {
0468     int i;
0469 
0470     for (i = 0; i < _NSIG; ++i)
0471         t->sighand->action[i].sa.sa_handler = SIG_IGN;
0472 
0473     flush_signals(t);
0474 }
0475 
0476 /*
0477  * Flush all handlers for a task.
0478  */
0479 
0480 void
0481 flush_signal_handlers(struct task_struct *t, int force_default)
0482 {
0483     int i;
0484     struct k_sigaction *ka = &t->sighand->action[0];
0485     for (i = _NSIG ; i != 0 ; i--) {
0486         if (force_default || ka->sa.sa_handler != SIG_IGN)
0487             ka->sa.sa_handler = SIG_DFL;
0488         ka->sa.sa_flags = 0;
0489 #ifdef __ARCH_HAS_SA_RESTORER
0490         ka->sa.sa_restorer = NULL;
0491 #endif
0492         sigemptyset(&ka->sa.sa_mask);
0493         ka++;
0494     }
0495 }
0496 
0497 int unhandled_signal(struct task_struct *tsk, int sig)
0498 {
0499     void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
0500     if (is_global_init(tsk))
0501         return 1;
0502     if (handler != SIG_IGN && handler != SIG_DFL)
0503         return 0;
0504     /* if ptraced, let the tracer determine */
0505     return !tsk->ptrace;
0506 }
0507 
0508 static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
0509 {
0510     struct sigqueue *q, *first = NULL;
0511 
0512     /*
0513      * Collect the siginfo appropriate to this signal.  Check if
0514      * there is another siginfo for the same signal.
0515     */
0516     list_for_each_entry(q, &list->list, list) {
0517         if (q->info.si_signo == sig) {
0518             if (first)
0519                 goto still_pending;
0520             first = q;
0521         }
0522     }
0523 
0524     sigdelset(&list->signal, sig);
0525 
0526     if (first) {
0527 still_pending:
0528         list_del_init(&first->list);
0529         copy_siginfo(info, &first->info);
0530         __sigqueue_free(first);
0531     } else {
0532         /*
0533          * Ok, it wasn't in the queue.  This must be
0534          * a fast-pathed signal or we must have been
0535          * out of queue space.  So zero out the info.
0536          */
0537         info->si_signo = sig;
0538         info->si_errno = 0;
0539         info->si_code = SI_USER;
0540         info->si_pid = 0;
0541         info->si_uid = 0;
0542     }
0543 }
0544 
0545 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
0546             siginfo_t *info)
0547 {
0548     int sig = next_signal(pending, mask);
0549 
0550     if (sig)
0551         collect_signal(sig, pending, info);
0552     return sig;
0553 }
0554 
0555 /*
0556  * Dequeue a signal and return the element to the caller, which is
0557  * expected to free it.
0558  *
0559  * All callers have to hold the siglock.
0560  */
0561 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
0562 {
0563     int signr;
0564 
0565     /* We only dequeue private signals from ourselves, we don't let
0566      * signalfd steal them
0567      */
0568     signr = __dequeue_signal(&tsk->pending, mask, info);
0569     if (!signr) {
0570         signr = __dequeue_signal(&tsk->signal->shared_pending,
0571                      mask, info);
0572 #ifdef CONFIG_POSIX_TIMERS
0573         /*
0574          * itimer signal ?
0575          *
0576          * itimers are process shared and we restart periodic
0577          * itimers in the signal delivery path to prevent DoS
0578          * attacks in the high resolution timer case. This is
0579          * compliant with the old way of self-restarting
0580          * itimers, as the SIGALRM is a legacy signal and only
0581          * queued once. Changing the restart behaviour to
0582          * restart the timer in the signal dequeue path is
0583          * reducing the timer noise on heavy loaded !highres
0584          * systems too.
0585          */
0586         if (unlikely(signr == SIGALRM)) {
0587             struct hrtimer *tmr = &tsk->signal->real_timer;
0588 
0589             if (!hrtimer_is_queued(tmr) &&
0590                 tsk->signal->it_real_incr != 0) {
0591                 hrtimer_forward(tmr, tmr->base->get_time(),
0592                         tsk->signal->it_real_incr);
0593                 hrtimer_restart(tmr);
0594             }
0595         }
0596 #endif
0597     }
0598 
0599     recalc_sigpending();
0600     if (!signr)
0601         return 0;
0602 
0603     if (unlikely(sig_kernel_stop(signr))) {
0604         /*
0605          * Set a marker that we have dequeued a stop signal.  Our
0606          * caller might release the siglock and then the pending
0607          * stop signal it is about to process is no longer in the
0608          * pending bitmasks, but must still be cleared by a SIGCONT
0609          * (and overruled by a SIGKILL).  So those cases clear this
0610          * shared flag after we've set it.  Note that this flag may
0611          * remain set after the signal we return is ignored or
0612          * handled.  That doesn't matter because its only purpose
0613          * is to alert stop-signal processing code when another
0614          * processor has come along and cleared the flag.
0615          */
0616         current->jobctl |= JOBCTL_STOP_DEQUEUED;
0617     }
0618 #ifdef CONFIG_POSIX_TIMERS
0619     if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
0620         /*
0621          * Release the siglock to ensure proper locking order
0622          * of timer locks outside of siglocks.  Note, we leave
0623          * irqs disabled here, since the posix-timers code is
0624          * about to disable them again anyway.
0625          */
0626         spin_unlock(&tsk->sighand->siglock);
0627         do_schedule_next_timer(info);
0628         spin_lock(&tsk->sighand->siglock);
0629     }
0630 #endif
0631     return signr;
0632 }
0633 
0634 /*
0635  * Tell a process that it has a new active signal..
0636  *
0637  * NOTE! we rely on the previous spin_lock to
0638  * lock interrupts for us! We can only be called with
0639  * "siglock" held, and the local interrupt must
0640  * have been disabled when that got acquired!
0641  *
0642  * No need to set need_resched since signal event passing
0643  * goes through ->blocked
0644  */
0645 void signal_wake_up_state(struct task_struct *t, unsigned int state)
0646 {
0647     set_tsk_thread_flag(t, TIF_SIGPENDING);
0648     /*
0649      * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
0650      * case. We don't check t->state here because there is a race with it
0651      * executing another processor and just now entering stopped state.
0652      * By using wake_up_state, we ensure the process will wake up and
0653      * handle its death signal.
0654      */
0655     if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
0656         kick_process(t);
0657 }
0658 
0659 /*
0660  * Remove signals in mask from the pending set and queue.
0661  * Returns 1 if any signals were found.
0662  *
0663  * All callers must be holding the siglock.
0664  */
0665 static int flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
0666 {
0667     struct sigqueue *q, *n;
0668     sigset_t m;
0669 
0670     sigandsets(&m, mask, &s->signal);
0671     if (sigisemptyset(&m))
0672         return 0;
0673 
0674     sigandnsets(&s->signal, &s->signal, mask);
0675     list_for_each_entry_safe(q, n, &s->list, list) {
0676         if (sigismember(mask, q->info.si_signo)) {
0677             list_del_init(&q->list);
0678             __sigqueue_free(q);
0679         }
0680     }
0681     return 1;
0682 }
0683 
0684 static inline int is_si_special(const struct siginfo *info)
0685 {
0686     return info <= SEND_SIG_FORCED;
0687 }
0688 
0689 static inline bool si_fromuser(const struct siginfo *info)
0690 {
0691     return info == SEND_SIG_NOINFO ||
0692         (!is_si_special(info) && SI_FROMUSER(info));
0693 }
0694 
0695 /*
0696  * called with RCU read lock from check_kill_permission()
0697  */
0698 static int kill_ok_by_cred(struct task_struct *t)
0699 {
0700     const struct cred *cred = current_cred();
0701     const struct cred *tcred = __task_cred(t);
0702 
0703     if (uid_eq(cred->euid, tcred->suid) ||
0704         uid_eq(cred->euid, tcred->uid)  ||
0705         uid_eq(cred->uid,  tcred->suid) ||
0706         uid_eq(cred->uid,  tcred->uid))
0707         return 1;
0708 
0709     if (ns_capable(tcred->user_ns, CAP_KILL))
0710         return 1;
0711 
0712     return 0;
0713 }
0714 
0715 /*
0716  * Bad permissions for sending the signal
0717  * - the caller must hold the RCU read lock
0718  */
0719 static int check_kill_permission(int sig, struct siginfo *info,
0720                  struct task_struct *t)
0721 {
0722     struct pid *sid;
0723     int error;
0724 
0725     if (!valid_signal(sig))
0726         return -EINVAL;
0727 
0728     if (!si_fromuser(info))
0729         return 0;
0730 
0731     error = audit_signal_info(sig, t); /* Let audit system see the signal */
0732     if (error)
0733         return error;
0734 
0735     if (!same_thread_group(current, t) &&
0736         !kill_ok_by_cred(t)) {
0737         switch (sig) {
0738         case SIGCONT:
0739             sid = task_session(t);
0740             /*
0741              * We don't return the error if sid == NULL. The
0742              * task was unhashed, the caller must notice this.
0743              */
0744             if (!sid || sid == task_session(current))
0745                 break;
0746         default:
0747             return -EPERM;
0748         }
0749     }
0750 
0751     return security_task_kill(t, info, sig, 0);
0752 }
0753 
0754 /**
0755  * ptrace_trap_notify - schedule trap to notify ptracer
0756  * @t: tracee wanting to notify tracer
0757  *
0758  * This function schedules sticky ptrace trap which is cleared on the next
0759  * TRAP_STOP to notify ptracer of an event.  @t must have been seized by
0760  * ptracer.
0761  *
0762  * If @t is running, STOP trap will be taken.  If trapped for STOP and
0763  * ptracer is listening for events, tracee is woken up so that it can
0764  * re-trap for the new event.  If trapped otherwise, STOP trap will be
0765  * eventually taken without returning to userland after the existing traps
0766  * are finished by PTRACE_CONT.
0767  *
0768  * CONTEXT:
0769  * Must be called with @task->sighand->siglock held.
0770  */
0771 static void ptrace_trap_notify(struct task_struct *t)
0772 {
0773     WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
0774     assert_spin_locked(&t->sighand->siglock);
0775 
0776     task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
0777     ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
0778 }
0779 
0780 /*
0781  * Handle magic process-wide effects of stop/continue signals. Unlike
0782  * the signal actions, these happen immediately at signal-generation
0783  * time regardless of blocking, ignoring, or handling.  This does the
0784  * actual continuing for SIGCONT, but not the actual stopping for stop
0785  * signals. The process stop is done as a signal action for SIG_DFL.
0786  *
0787  * Returns true if the signal should be actually delivered, otherwise
0788  * it should be dropped.
0789  */
0790 static bool prepare_signal(int sig, struct task_struct *p, bool force)
0791 {
0792     struct signal_struct *signal = p->signal;
0793     struct task_struct *t;
0794     sigset_t flush;
0795 
0796     if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
0797         if (!(signal->flags & SIGNAL_GROUP_EXIT))
0798             return sig == SIGKILL;
0799         /*
0800          * The process is in the middle of dying, nothing to do.
0801          */
0802     } else if (sig_kernel_stop(sig)) {
0803         /*
0804          * This is a stop signal.  Remove SIGCONT from all queues.
0805          */
0806         siginitset(&flush, sigmask(SIGCONT));
0807         flush_sigqueue_mask(&flush, &signal->shared_pending);
0808         for_each_thread(p, t)
0809             flush_sigqueue_mask(&flush, &t->pending);
0810     } else if (sig == SIGCONT) {
0811         unsigned int why;
0812         /*
0813          * Remove all stop signals from all queues, wake all threads.
0814          */
0815         siginitset(&flush, SIG_KERNEL_STOP_MASK);
0816         flush_sigqueue_mask(&flush, &signal->shared_pending);
0817         for_each_thread(p, t) {
0818             flush_sigqueue_mask(&flush, &t->pending);
0819             task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
0820             if (likely(!(t->ptrace & PT_SEIZED)))
0821                 wake_up_state(t, __TASK_STOPPED);
0822             else
0823                 ptrace_trap_notify(t);
0824         }
0825 
0826         /*
0827          * Notify the parent with CLD_CONTINUED if we were stopped.
0828          *
0829          * If we were in the middle of a group stop, we pretend it
0830          * was already finished, and then continued. Since SIGCHLD
0831          * doesn't queue we report only CLD_STOPPED, as if the next
0832          * CLD_CONTINUED was dropped.
0833          */
0834         why = 0;
0835         if (signal->flags & SIGNAL_STOP_STOPPED)
0836             why |= SIGNAL_CLD_CONTINUED;
0837         else if (signal->group_stop_count)
0838             why |= SIGNAL_CLD_STOPPED;
0839 
0840         if (why) {
0841             /*
0842              * The first thread which returns from do_signal_stop()
0843              * will take ->siglock, notice SIGNAL_CLD_MASK, and
0844              * notify its parent. See get_signal_to_deliver().
0845              */
0846             signal_set_stop_flags(signal, why | SIGNAL_STOP_CONTINUED);
0847             signal->group_stop_count = 0;
0848             signal->group_exit_code = 0;
0849         }
0850     }
0851 
0852     return !sig_ignored(p, sig, force);
0853 }
0854 
0855 /*
0856  * Test if P wants to take SIG.  After we've checked all threads with this,
0857  * it's equivalent to finding no threads not blocking SIG.  Any threads not
0858  * blocking SIG were ruled out because they are not running and already
0859  * have pending signals.  Such threads will dequeue from the shared queue
0860  * as soon as they're available, so putting the signal on the shared queue
0861  * will be equivalent to sending it to one such thread.
0862  */
0863 static inline int wants_signal(int sig, struct task_struct *p)
0864 {
0865     if (sigismember(&p->blocked, sig))
0866         return 0;
0867     if (p->flags & PF_EXITING)
0868         return 0;
0869     if (sig == SIGKILL)
0870         return 1;
0871     if (task_is_stopped_or_traced(p))
0872         return 0;
0873     return task_curr(p) || !signal_pending(p);
0874 }
0875 
0876 static void complete_signal(int sig, struct task_struct *p, int group)
0877 {
0878     struct signal_struct *signal = p->signal;
0879     struct task_struct *t;
0880 
0881     /*
0882      * Now find a thread we can wake up to take the signal off the queue.
0883      *
0884      * If the main thread wants the signal, it gets first crack.
0885      * Probably the least surprising to the average bear.
0886      */
0887     if (wants_signal(sig, p))
0888         t = p;
0889     else if (!group || thread_group_empty(p))
0890         /*
0891          * There is just one thread and it does not need to be woken.
0892          * It will dequeue unblocked signals before it runs again.
0893          */
0894         return;
0895     else {
0896         /*
0897          * Otherwise try to find a suitable thread.
0898          */
0899         t = signal->curr_target;
0900         while (!wants_signal(sig, t)) {
0901             t = next_thread(t);
0902             if (t == signal->curr_target)
0903                 /*
0904                  * No thread needs to be woken.
0905                  * Any eligible threads will see
0906                  * the signal in the queue soon.
0907                  */
0908                 return;
0909         }
0910         signal->curr_target = t;
0911     }
0912 
0913     /*
0914      * Found a killable thread.  If the signal will be fatal,
0915      * then start taking the whole group down immediately.
0916      */
0917     if (sig_fatal(p, sig) &&
0918         !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
0919         !sigismember(&t->real_blocked, sig) &&
0920         (sig == SIGKILL || !t->ptrace)) {
0921         /*
0922          * This signal will be fatal to the whole group.
0923          */
0924         if (!sig_kernel_coredump(sig)) {
0925             /*
0926              * Start a group exit and wake everybody up.
0927              * This way we don't have other threads
0928              * running and doing things after a slower
0929              * thread has the fatal signal pending.
0930              */
0931             signal->flags = SIGNAL_GROUP_EXIT;
0932             signal->group_exit_code = sig;
0933             signal->group_stop_count = 0;
0934             t = p;
0935             do {
0936                 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
0937                 sigaddset(&t->pending.signal, SIGKILL);
0938                 signal_wake_up(t, 1);
0939             } while_each_thread(p, t);
0940             return;
0941         }
0942     }
0943 
0944     /*
0945      * The signal is already in the shared-pending queue.
0946      * Tell the chosen thread to wake up and dequeue it.
0947      */
0948     signal_wake_up(t, sig == SIGKILL);
0949     return;
0950 }
0951 
0952 static inline int legacy_queue(struct sigpending *signals, int sig)
0953 {
0954     return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
0955 }
0956 
0957 #ifdef CONFIG_USER_NS
0958 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
0959 {
0960     if (current_user_ns() == task_cred_xxx(t, user_ns))
0961         return;
0962 
0963     if (SI_FROMKERNEL(info))
0964         return;
0965 
0966     rcu_read_lock();
0967     info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
0968                     make_kuid(current_user_ns(), info->si_uid));
0969     rcu_read_unlock();
0970 }
0971 #else
0972 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
0973 {
0974     return;
0975 }
0976 #endif
0977 
0978 static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
0979             int group, int from_ancestor_ns)
0980 {
0981     struct sigpending *pending;
0982     struct sigqueue *q;
0983     int override_rlimit;
0984     int ret = 0, result;
0985 
0986     assert_spin_locked(&t->sighand->siglock);
0987 
0988     result = TRACE_SIGNAL_IGNORED;
0989     if (!prepare_signal(sig, t,
0990             from_ancestor_ns || (info == SEND_SIG_FORCED)))
0991         goto ret;
0992 
0993     pending = group ? &t->signal->shared_pending : &t->pending;
0994     /*
0995      * Short-circuit ignored signals and support queuing
0996      * exactly one non-rt signal, so that we can get more
0997      * detailed information about the cause of the signal.
0998      */
0999     result = TRACE_SIGNAL_ALREADY_PENDING;
1000     if (legacy_queue(pending, sig))
1001         goto ret;
1002 
1003     result = TRACE_SIGNAL_DELIVERED;
1004     /*
1005      * fast-pathed signals for kernel-internal things like SIGSTOP
1006      * or SIGKILL.
1007      */
1008     if (info == SEND_SIG_FORCED)
1009         goto out_set;
1010 
1011     /*
1012      * Real-time signals must be queued if sent by sigqueue, or
1013      * some other real-time mechanism.  It is implementation
1014      * defined whether kill() does so.  We attempt to do so, on
1015      * the principle of least surprise, but since kill is not
1016      * allowed to fail with EAGAIN when low on memory we just
1017      * make sure at least one signal gets delivered and don't
1018      * pass on the info struct.
1019      */
1020     if (sig < SIGRTMIN)
1021         override_rlimit = (is_si_special(info) || info->si_code >= 0);
1022     else
1023         override_rlimit = 0;
1024 
1025     q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
1026         override_rlimit);
1027     if (q) {
1028         list_add_tail(&q->list, &pending->list);
1029         switch ((unsigned long) info) {
1030         case (unsigned long) SEND_SIG_NOINFO:
1031             q->info.si_signo = sig;
1032             q->info.si_errno = 0;
1033             q->info.si_code = SI_USER;
1034             q->info.si_pid = task_tgid_nr_ns(current,
1035                             task_active_pid_ns(t));
1036             q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1037             break;
1038         case (unsigned long) SEND_SIG_PRIV:
1039             q->info.si_signo = sig;
1040             q->info.si_errno = 0;
1041             q->info.si_code = SI_KERNEL;
1042             q->info.si_pid = 0;
1043             q->info.si_uid = 0;
1044             break;
1045         default:
1046             copy_siginfo(&q->info, info);
1047             if (from_ancestor_ns)
1048                 q->info.si_pid = 0;
1049             break;
1050         }
1051 
1052         userns_fixup_signal_uid(&q->info, t);
1053 
1054     } else if (!is_si_special(info)) {
1055         if (sig >= SIGRTMIN && info->si_code != SI_USER) {
1056             /*
1057              * Queue overflow, abort.  We may abort if the
1058              * signal was rt and sent by user using something
1059              * other than kill().
1060              */
1061             result = TRACE_SIGNAL_OVERFLOW_FAIL;
1062             ret = -EAGAIN;
1063             goto ret;
1064         } else {
1065             /*
1066              * This is a silent loss of information.  We still
1067              * send the signal, but the *info bits are lost.
1068              */
1069             result = TRACE_SIGNAL_LOSE_INFO;
1070         }
1071     }
1072 
1073 out_set:
1074     signalfd_notify(t, sig);
1075     sigaddset(&pending->signal, sig);
1076     complete_signal(sig, t, group);
1077 ret:
1078     trace_signal_generate(sig, info, t, group, result);
1079     return ret;
1080 }
1081 
1082 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
1083             int group)
1084 {
1085     int from_ancestor_ns = 0;
1086 
1087 #ifdef CONFIG_PID_NS
1088     from_ancestor_ns = si_fromuser(info) &&
1089                !task_pid_nr_ns(current, task_active_pid_ns(t));
1090 #endif
1091 
1092     return __send_signal(sig, info, t, group, from_ancestor_ns);
1093 }
1094 
1095 static void print_fatal_signal(int signr)
1096 {
1097     struct pt_regs *regs = signal_pt_regs();
1098     pr_info("potentially unexpected fatal signal %d.\n", signr);
1099 
1100 #if defined(__i386__) && !defined(__arch_um__)
1101     pr_info("code at %08lx: ", regs->ip);
1102     {
1103         int i;
1104         for (i = 0; i < 16; i++) {
1105             unsigned char insn;
1106 
1107             if (get_user(insn, (unsigned char *)(regs->ip + i)))
1108                 break;
1109             pr_cont("%02x ", insn);
1110         }
1111     }
1112     pr_cont("\n");
1113 #endif
1114     preempt_disable();
1115     show_regs(regs);
1116     preempt_enable();
1117 }
1118 
1119 static int __init setup_print_fatal_signals(char *str)
1120 {
1121     get_option (&str, &print_fatal_signals);
1122 
1123     return 1;
1124 }
1125 
1126 __setup("print-fatal-signals=", setup_print_fatal_signals);
1127 
1128 int
1129 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1130 {
1131     return send_signal(sig, info, p, 1);
1132 }
1133 
1134 static int
1135 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1136 {
1137     return send_signal(sig, info, t, 0);
1138 }
1139 
1140 int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
1141             bool group)
1142 {
1143     unsigned long flags;
1144     int ret = -ESRCH;
1145 
1146     if (lock_task_sighand(p, &flags)) {
1147         ret = send_signal(sig, info, p, group);
1148         unlock_task_sighand(p, &flags);
1149     }
1150 
1151     return ret;
1152 }
1153 
1154 /*
1155  * Force a signal that the process can't ignore: if necessary
1156  * we unblock the signal and change any SIG_IGN to SIG_DFL.
1157  *
1158  * Note: If we unblock the signal, we always reset it to SIG_DFL,
1159  * since we do not want to have a signal handler that was blocked
1160  * be invoked when user space had explicitly blocked it.
1161  *
1162  * We don't want to have recursive SIGSEGV's etc, for example,
1163  * that is why we also clear SIGNAL_UNKILLABLE.
1164  */
1165 int
1166 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1167 {
1168     unsigned long int flags;
1169     int ret, blocked, ignored;
1170     struct k_sigaction *action;
1171 
1172     spin_lock_irqsave(&t->sighand->siglock, flags);
1173     action = &t->sighand->action[sig-1];
1174     ignored = action->sa.sa_handler == SIG_IGN;
1175     blocked = sigismember(&t->blocked, sig);
1176     if (blocked || ignored) {
1177         action->sa.sa_handler = SIG_DFL;
1178         if (blocked) {
1179             sigdelset(&t->blocked, sig);
1180             recalc_sigpending_and_wake(t);
1181         }
1182     }
1183     if (action->sa.sa_handler == SIG_DFL)
1184         t->signal->flags &= ~SIGNAL_UNKILLABLE;
1185     ret = specific_send_sig_info(sig, info, t);
1186     spin_unlock_irqrestore(&t->sighand->siglock, flags);
1187 
1188     return ret;
1189 }
1190 
1191 /*
1192  * Nuke all other threads in the group.
1193  */
1194 int zap_other_threads(struct task_struct *p)
1195 {
1196     struct task_struct *t = p;
1197     int count = 0;
1198 
1199     p->signal->group_stop_count = 0;
1200 
1201     while_each_thread(p, t) {
1202         task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1203         count++;
1204 
1205         /* Don't bother with already dead threads */
1206         if (t->exit_state)
1207             continue;
1208         sigaddset(&t->pending.signal, SIGKILL);
1209         signal_wake_up(t, 1);
1210     }
1211 
1212     return count;
1213 }
1214 
1215 struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1216                        unsigned long *flags)
1217 {
1218     struct sighand_struct *sighand;
1219 
1220     for (;;) {
1221         /*
1222          * Disable interrupts early to avoid deadlocks.
1223          * See rcu_read_unlock() comment header for details.
1224          */
1225         local_irq_save(*flags);
1226         rcu_read_lock();
1227         sighand = rcu_dereference(tsk->sighand);
1228         if (unlikely(sighand == NULL)) {
1229             rcu_read_unlock();
1230             local_irq_restore(*flags);
1231             break;
1232         }
1233         /*
1234          * This sighand can be already freed and even reused, but
1235          * we rely on SLAB_DESTROY_BY_RCU and sighand_ctor() which
1236          * initializes ->siglock: this slab can't go away, it has
1237          * the same object type, ->siglock can't be reinitialized.
1238          *
1239          * We need to ensure that tsk->sighand is still the same
1240          * after we take the lock, we can race with de_thread() or
1241          * __exit_signal(). In the latter case the next iteration
1242          * must see ->sighand == NULL.
1243          */
1244         spin_lock(&sighand->siglock);
1245         if (likely(sighand == tsk->sighand)) {
1246             rcu_read_unlock();
1247             break;
1248         }
1249         spin_unlock(&sighand->siglock);
1250         rcu_read_unlock();
1251         local_irq_restore(*flags);
1252     }
1253 
1254     return sighand;
1255 }
1256 
1257 /*
1258  * send signal info to all the members of a group
1259  */
1260 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1261 {
1262     int ret;
1263 
1264     rcu_read_lock();
1265     ret = check_kill_permission(sig, info, p);
1266     rcu_read_unlock();
1267 
1268     if (!ret && sig)
1269         ret = do_send_sig_info(sig, info, p, true);
1270 
1271     return ret;
1272 }
1273 
1274 /*
1275  * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1276  * control characters do (^C, ^Z etc)
1277  * - the caller must hold at least a readlock on tasklist_lock
1278  */
1279 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1280 {
1281     struct task_struct *p = NULL;
1282     int retval, success;
1283 
1284     success = 0;
1285     retval = -ESRCH;
1286     do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1287         int err = group_send_sig_info(sig, info, p);
1288         success |= !err;
1289         retval = err;
1290     } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1291     return success ? 0 : retval;
1292 }
1293 
1294 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1295 {
1296     int error = -ESRCH;
1297     struct task_struct *p;
1298 
1299     for (;;) {
1300         rcu_read_lock();
1301         p = pid_task(pid, PIDTYPE_PID);
1302         if (p)
1303             error = group_send_sig_info(sig, info, p);
1304         rcu_read_unlock();
1305         if (likely(!p || error != -ESRCH))
1306             return error;
1307 
1308         /*
1309          * The task was unhashed in between, try again.  If it
1310          * is dead, pid_task() will return NULL, if we race with
1311          * de_thread() it will find the new leader.
1312          */
1313     }
1314 }
1315 
1316 int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1317 {
1318     int error;
1319     rcu_read_lock();
1320     error = kill_pid_info(sig, info, find_vpid(pid));
1321     rcu_read_unlock();
1322     return error;
1323 }
1324 
1325 static int kill_as_cred_perm(const struct cred *cred,
1326                  struct task_struct *target)
1327 {
1328     const struct cred *pcred = __task_cred(target);
1329     if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) &&
1330         !uid_eq(cred->uid,  pcred->suid) && !uid_eq(cred->uid,  pcred->uid))
1331         return 0;
1332     return 1;
1333 }
1334 
1335 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1336 int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
1337              const struct cred *cred, u32 secid)
1338 {
1339     int ret = -EINVAL;
1340     struct task_struct *p;
1341     unsigned long flags;
1342 
1343     if (!valid_signal(sig))
1344         return ret;
1345 
1346     rcu_read_lock();
1347     p = pid_task(pid, PIDTYPE_PID);
1348     if (!p) {
1349         ret = -ESRCH;
1350         goto out_unlock;
1351     }
1352     if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
1353         ret = -EPERM;
1354         goto out_unlock;
1355     }
1356     ret = security_task_kill(p, info, sig, secid);
1357     if (ret)
1358         goto out_unlock;
1359 
1360     if (sig) {
1361         if (lock_task_sighand(p, &flags)) {
1362             ret = __send_signal(sig, info, p, 1, 0);
1363             unlock_task_sighand(p, &flags);
1364         } else
1365             ret = -ESRCH;
1366     }
1367 out_unlock:
1368     rcu_read_unlock();
1369     return ret;
1370 }
1371 EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
1372 
1373 /*
1374  * kill_something_info() interprets pid in interesting ways just like kill(2).
1375  *
1376  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1377  * is probably wrong.  Should make it like BSD or SYSV.
1378  */
1379 
1380 static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
1381 {
1382     int ret;
1383 
1384     if (pid > 0) {
1385         rcu_read_lock();
1386         ret = kill_pid_info(sig, info, find_vpid(pid));
1387         rcu_read_unlock();
1388         return ret;
1389     }
1390 
1391     read_lock(&tasklist_lock);
1392     if (pid != -1) {
1393         ret = __kill_pgrp_info(sig, info,
1394                 pid ? find_vpid(-pid) : task_pgrp(current));
1395     } else {
1396         int retval = 0, count = 0;
1397         struct task_struct * p;
1398 
1399         for_each_process(p) {
1400             if (task_pid_vnr(p) > 1 &&
1401                     !same_thread_group(p, current)) {
1402                 int err = group_send_sig_info(sig, info, p);
1403                 ++count;
1404                 if (err != -EPERM)
1405                     retval = err;
1406             }
1407         }
1408         ret = count ? retval : -ESRCH;
1409     }
1410     read_unlock(&tasklist_lock);
1411 
1412     return ret;
1413 }
1414 
1415 /*
1416  * These are for backward compatibility with the rest of the kernel source.
1417  */
1418 
1419 int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1420 {
1421     /*
1422      * Make sure legacy kernel users don't send in bad values
1423      * (normal paths check this in check_kill_permission).
1424      */
1425     if (!valid_signal(sig))
1426         return -EINVAL;
1427 
1428     return do_send_sig_info(sig, info, p, false);
1429 }
1430 
1431 #define __si_special(priv) \
1432     ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1433 
1434 int
1435 send_sig(int sig, struct task_struct *p, int priv)
1436 {
1437     return send_sig_info(sig, __si_special(priv), p);
1438 }
1439 
1440 void
1441 force_sig(int sig, struct task_struct *p)
1442 {
1443     force_sig_info(sig, SEND_SIG_PRIV, p);
1444 }
1445 
1446 /*
1447  * When things go south during signal handling, we
1448  * will force a SIGSEGV. And if the signal that caused
1449  * the problem was already a SIGSEGV, we'll want to
1450  * make sure we don't even try to deliver the signal..
1451  */
1452 int
1453 force_sigsegv(int sig, struct task_struct *p)
1454 {
1455     if (sig == SIGSEGV) {
1456         unsigned long flags;
1457         spin_lock_irqsave(&p->sighand->siglock, flags);
1458         p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1459         spin_unlock_irqrestore(&p->sighand->siglock, flags);
1460     }
1461     force_sig(SIGSEGV, p);
1462     return 0;
1463 }
1464 
1465 int kill_pgrp(struct pid *pid, int sig, int priv)
1466 {
1467     int ret;
1468 
1469     read_lock(&tasklist_lock);
1470     ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1471     read_unlock(&tasklist_lock);
1472 
1473     return ret;
1474 }
1475 EXPORT_SYMBOL(kill_pgrp);
1476 
1477 int kill_pid(struct pid *pid, int sig, int priv)
1478 {
1479     return kill_pid_info(sig, __si_special(priv), pid);
1480 }
1481 EXPORT_SYMBOL(kill_pid);
1482 
1483 /*
1484  * These functions support sending signals using preallocated sigqueue
1485  * structures.  This is needed "because realtime applications cannot
1486  * afford to lose notifications of asynchronous events, like timer
1487  * expirations or I/O completions".  In the case of POSIX Timers
1488  * we allocate the sigqueue structure from the timer_create.  If this
1489  * allocation fails we are able to report the failure to the application
1490  * with an EAGAIN error.
1491  */
1492 struct sigqueue *sigqueue_alloc(void)
1493 {
1494     struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
1495 
1496     if (q)
1497         q->flags |= SIGQUEUE_PREALLOC;
1498 
1499     return q;
1500 }
1501 
1502 void sigqueue_free(struct sigqueue *q)
1503 {
1504     unsigned long flags;
1505     spinlock_t *lock = &current->sighand->siglock;
1506 
1507     BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1508     /*
1509      * We must hold ->siglock while testing q->list
1510      * to serialize with collect_signal() or with
1511      * __exit_signal()->flush_sigqueue().
1512      */
1513     spin_lock_irqsave(lock, flags);
1514     q->flags &= ~SIGQUEUE_PREALLOC;
1515     /*
1516      * If it is queued it will be freed when dequeued,
1517      * like the "regular" sigqueue.
1518      */
1519     if (!list_empty(&q->list))
1520         q = NULL;
1521     spin_unlock_irqrestore(lock, flags);
1522 
1523     if (q)
1524         __sigqueue_free(q);
1525 }
1526 
1527 int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1528 {
1529     int sig = q->info.si_signo;
1530     struct sigpending *pending;
1531     unsigned long flags;
1532     int ret, result;
1533 
1534     BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1535 
1536     ret = -1;
1537     if (!likely(lock_task_sighand(t, &flags)))
1538         goto ret;
1539 
1540     ret = 1; /* the signal is ignored */
1541     result = TRACE_SIGNAL_IGNORED;
1542     if (!prepare_signal(sig, t, false))
1543         goto out;
1544 
1545     ret = 0;
1546     if (unlikely(!list_empty(&q->list))) {
1547         /*
1548          * If an SI_TIMER entry is already queue just increment
1549          * the overrun count.
1550          */
1551         BUG_ON(q->info.si_code != SI_TIMER);
1552         q->info.si_overrun++;
1553         result = TRACE_SIGNAL_ALREADY_PENDING;
1554         goto out;
1555     }
1556     q->info.si_overrun = 0;
1557 
1558     signalfd_notify(t, sig);
1559     pending = group ? &t->signal->shared_pending : &t->pending;
1560     list_add_tail(&q->list, &pending->list);
1561     sigaddset(&pending->signal, sig);
1562     complete_signal(sig, t, group);
1563     result = TRACE_SIGNAL_DELIVERED;
1564 out:
1565     trace_signal_generate(sig, &q->info, t, group, result);
1566     unlock_task_sighand(t, &flags);
1567 ret:
1568     return ret;
1569 }
1570 
1571 /*
1572  * Let a parent know about the death of a child.
1573  * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1574  *
1575  * Returns true if our parent ignored us and so we've switched to
1576  * self-reaping.
1577  */
1578 bool do_notify_parent(struct task_struct *tsk, int sig)
1579 {
1580     struct siginfo info;
1581     unsigned long flags;
1582     struct sighand_struct *psig;
1583     bool autoreap = false;
1584     cputime_t utime, stime;
1585 
1586     BUG_ON(sig == -1);
1587 
1588     /* do_notify_parent_cldstop should have been called instead.  */
1589     BUG_ON(task_is_stopped_or_traced(tsk));
1590 
1591     BUG_ON(!tsk->ptrace &&
1592            (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1593 
1594     if (sig != SIGCHLD) {
1595         /*
1596          * This is only possible if parent == real_parent.
1597          * Check if it has changed security domain.
1598          */
1599         if (tsk->parent_exec_id != tsk->parent->self_exec_id)
1600             sig = SIGCHLD;
1601     }
1602 
1603     info.si_signo = sig;
1604     info.si_errno = 0;
1605     /*
1606      * We are under tasklist_lock here so our parent is tied to
1607      * us and cannot change.
1608      *
1609      * task_active_pid_ns will always return the same pid namespace
1610      * until a task passes through release_task.
1611      *
1612      * write_lock() currently calls preempt_disable() which is the
1613      * same as rcu_read_lock(), but according to Oleg, this is not
1614      * correct to rely on this
1615      */
1616     rcu_read_lock();
1617     info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1618     info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
1619                        task_uid(tsk));
1620     rcu_read_unlock();
1621 
1622     task_cputime(tsk, &utime, &stime);
1623     info.si_utime = cputime_to_clock_t(utime + tsk->signal->utime);
1624     info.si_stime = cputime_to_clock_t(stime + tsk->signal->stime);
1625 
1626     info.si_status = tsk->exit_code & 0x7f;
1627     if (tsk->exit_code & 0x80)
1628         info.si_code = CLD_DUMPED;
1629     else if (tsk->exit_code & 0x7f)
1630         info.si_code = CLD_KILLED;
1631     else {
1632         info.si_code = CLD_EXITED;
1633         info.si_status = tsk->exit_code >> 8;
1634     }
1635 
1636     psig = tsk->parent->sighand;
1637     spin_lock_irqsave(&psig->siglock, flags);
1638     if (!tsk->ptrace && sig == SIGCHLD &&
1639         (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1640          (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1641         /*
1642          * We are exiting and our parent doesn't care.  POSIX.1
1643          * defines special semantics for setting SIGCHLD to SIG_IGN
1644          * or setting the SA_NOCLDWAIT flag: we should be reaped
1645          * automatically and not left for our parent's wait4 call.
1646          * Rather than having the parent do it as a magic kind of
1647          * signal handler, we just set this to tell do_exit that we
1648          * can be cleaned up without becoming a zombie.  Note that
1649          * we still call __wake_up_parent in this case, because a
1650          * blocked sys_wait4 might now return -ECHILD.
1651          *
1652          * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1653          * is implementation-defined: we do (if you don't want
1654          * it, just use SIG_IGN instead).
1655          */
1656         autoreap = true;
1657         if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1658             sig = 0;
1659     }
1660     if (valid_signal(sig) && sig)
1661         __group_send_sig_info(sig, &info, tsk->parent);
1662     __wake_up_parent(tsk, tsk->parent);
1663     spin_unlock_irqrestore(&psig->siglock, flags);
1664 
1665     return autoreap;
1666 }
1667 
1668 /**
1669  * do_notify_parent_cldstop - notify parent of stopped/continued state change
1670  * @tsk: task reporting the state change
1671  * @for_ptracer: the notification is for ptracer
1672  * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
1673  *
1674  * Notify @tsk's parent that the stopped/continued state has changed.  If
1675  * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
1676  * If %true, @tsk reports to @tsk->parent which should be the ptracer.
1677  *
1678  * CONTEXT:
1679  * Must be called with tasklist_lock at least read locked.
1680  */
1681 static void do_notify_parent_cldstop(struct task_struct *tsk,
1682                      bool for_ptracer, int why)
1683 {
1684     struct siginfo info;
1685     unsigned long flags;
1686     struct task_struct *parent;
1687     struct sighand_struct *sighand;
1688     cputime_t utime, stime;
1689 
1690     if (for_ptracer) {
1691         parent = tsk->parent;
1692     } else {
1693         tsk = tsk->group_leader;
1694         parent = tsk->real_parent;
1695     }
1696 
1697     info.si_signo = SIGCHLD;
1698     info.si_errno = 0;
1699     /*
1700      * see comment in do_notify_parent() about the following 4 lines
1701      */
1702     rcu_read_lock();
1703     info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
1704     info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
1705     rcu_read_unlock();
1706 
1707     task_cputime(tsk, &utime, &stime);
1708     info.si_utime = cputime_to_clock_t(utime);
1709     info.si_stime = cputime_to_clock_t(stime);
1710 
1711     info.si_code = why;
1712     switch (why) {
1713     case CLD_CONTINUED:
1714         info.si_status = SIGCONT;
1715         break;
1716     case CLD_STOPPED:
1717         info.si_status = tsk->signal->group_exit_code & 0x7f;
1718         break;
1719     case CLD_TRAPPED:
1720         info.si_status = tsk->exit_code & 0x7f;
1721         break;
1722     default:
1723         BUG();
1724     }
1725 
1726     sighand = parent->sighand;
1727     spin_lock_irqsave(&sighand->siglock, flags);
1728     if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1729         !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1730         __group_send_sig_info(SIGCHLD, &info, parent);
1731     /*
1732      * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1733      */
1734     __wake_up_parent(tsk, parent);
1735     spin_unlock_irqrestore(&sighand->siglock, flags);
1736 }
1737 
1738 static inline int may_ptrace_stop(void)
1739 {
1740     if (!likely(current->ptrace))
1741         return 0;
1742     /*
1743      * Are we in the middle of do_coredump?
1744      * If so and our tracer is also part of the coredump stopping
1745      * is a deadlock situation, and pointless because our tracer
1746      * is dead so don't allow us to stop.
1747      * If SIGKILL was already sent before the caller unlocked
1748      * ->siglock we must see ->core_state != NULL. Otherwise it
1749      * is safe to enter schedule().
1750      *
1751      * This is almost outdated, a task with the pending SIGKILL can't
1752      * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported
1753      * after SIGKILL was already dequeued.
1754      */
1755     if (unlikely(current->mm->core_state) &&
1756         unlikely(current->mm == current->parent->mm))
1757         return 0;
1758 
1759     return 1;
1760 }
1761 
1762 /*
1763  * Return non-zero if there is a SIGKILL that should be waking us up.
1764  * Called with the siglock held.
1765  */
1766 static int sigkill_pending(struct task_struct *tsk)
1767 {
1768     return  sigismember(&tsk->pending.signal, SIGKILL) ||
1769         sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
1770 }
1771 
1772 /*
1773  * This must be called with current->sighand->siglock held.
1774  *
1775  * This should be the path for all ptrace stops.
1776  * We always set current->last_siginfo while stopped here.
1777  * That makes it a way to test a stopped process for
1778  * being ptrace-stopped vs being job-control-stopped.
1779  *
1780  * If we actually decide not to stop at all because the tracer
1781  * is gone, we keep current->exit_code unless clear_code.
1782  */
1783 static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
1784     __releases(&current->sighand->siglock)
1785     __acquires(&current->sighand->siglock)
1786 {
1787     bool gstop_done = false;
1788 
1789     if (arch_ptrace_stop_needed(exit_code, info)) {
1790         /*
1791          * The arch code has something special to do before a
1792          * ptrace stop.  This is allowed to block, e.g. for faults
1793          * on user stack pages.  We can't keep the siglock while
1794          * calling arch_ptrace_stop, so we must release it now.
1795          * To preserve proper semantics, we must do this before
1796          * any signal bookkeeping like checking group_stop_count.
1797          * Meanwhile, a SIGKILL could come in before we retake the
1798          * siglock.  That must prevent us from sleeping in TASK_TRACED.
1799          * So after regaining the lock, we must check for SIGKILL.
1800          */
1801         spin_unlock_irq(&current->sighand->siglock);
1802         arch_ptrace_stop(exit_code, info);
1803         spin_lock_irq(&current->sighand->siglock);
1804         if (sigkill_pending(current))
1805             return;
1806     }
1807 
1808     /*
1809      * We're committing to trapping.  TRACED should be visible before
1810      * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
1811      * Also, transition to TRACED and updates to ->jobctl should be
1812      * atomic with respect to siglock and should be done after the arch
1813      * hook as siglock is released and regrabbed across it.
1814      */
1815     set_current_state(TASK_TRACED);
1816 
1817     current->last_siginfo = info;
1818     current->exit_code = exit_code;
1819 
1820     /*
1821      * If @why is CLD_STOPPED, we're trapping to participate in a group
1822      * stop.  Do the bookkeeping.  Note that if SIGCONT was delievered
1823      * across siglock relocks since INTERRUPT was scheduled, PENDING
1824      * could be clear now.  We act as if SIGCONT is received after
1825      * TASK_TRACED is entered - ignore it.
1826      */
1827     if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
1828         gstop_done = task_participate_group_stop(current);
1829 
1830     /* any trap clears pending STOP trap, STOP trap clears NOTIFY */
1831     task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
1832     if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
1833         task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
1834 
1835     /* entering a trap, clear TRAPPING */
1836     task_clear_jobctl_trapping(current);
1837 
1838     spin_unlock_irq(&current->sighand->siglock);
1839     read_lock(&tasklist_lock);
1840     if (may_ptrace_stop()) {
1841         /*
1842          * Notify parents of the stop.
1843          *
1844          * While ptraced, there are two parents - the ptracer and
1845          * the real_parent of the group_leader.  The ptracer should
1846          * know about every stop while the real parent is only
1847          * interested in the completion of group stop.  The states
1848          * for the two don't interact with each other.  Notify
1849          * separately unless they're gonna be duplicates.
1850          */
1851         do_notify_parent_cldstop(current, true, why);
1852         if (gstop_done && ptrace_reparented(current))
1853             do_notify_parent_cldstop(current, false, why);
1854 
1855         /*
1856          * Don't want to allow preemption here, because
1857          * sys_ptrace() needs this task to be inactive.
1858          *
1859          * XXX: implement read_unlock_no_resched().
1860          */
1861         preempt_disable();
1862         read_unlock(&tasklist_lock);
1863         preempt_enable_no_resched();
1864         freezable_schedule();
1865     } else {
1866         /*
1867          * By the time we got the lock, our tracer went away.
1868          * Don't drop the lock yet, another tracer may come.
1869          *
1870          * If @gstop_done, the ptracer went away between group stop
1871          * completion and here.  During detach, it would have set
1872          * JOBCTL_STOP_PENDING on us and we'll re-enter
1873          * TASK_STOPPED in do_signal_stop() on return, so notifying
1874          * the real parent of the group stop completion is enough.
1875          */
1876         if (gstop_done)
1877             do_notify_parent_cldstop(current, false, why);
1878 
1879         /* tasklist protects us from ptrace_freeze_traced() */
1880         __set_current_state(TASK_RUNNING);
1881         if (clear_code)
1882             current->exit_code = 0;
1883         read_unlock(&tasklist_lock);
1884     }
1885 
1886     /*
1887      * We are back.  Now reacquire the siglock before touching
1888      * last_siginfo, so that we are sure to have synchronized with
1889      * any signal-sending on another CPU that wants to examine it.
1890      */
1891     spin_lock_irq(&current->sighand->siglock);
1892     current->last_siginfo = NULL;
1893 
1894     /* LISTENING can be set only during STOP traps, clear it */
1895     current->jobctl &= ~JOBCTL_LISTENING;
1896 
1897     /*
1898      * Queued signals ignored us while we were stopped for tracing.
1899      * So check for any that we should take before resuming user mode.
1900      * This sets TIF_SIGPENDING, but never clears it.
1901      */
1902     recalc_sigpending_tsk(current);
1903 }
1904 
1905 static void ptrace_do_notify(int signr, int exit_code, int why)
1906 {
1907     siginfo_t info;
1908 
1909     memset(&info, 0, sizeof info);
1910     info.si_signo = signr;
1911     info.si_code = exit_code;
1912     info.si_pid = task_pid_vnr(current);
1913     info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1914 
1915     /* Let the debugger run.  */
1916     ptrace_stop(exit_code, why, 1, &info);
1917 }
1918 
1919 void ptrace_notify(int exit_code)
1920 {
1921     BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1922     if (unlikely(current->task_works))
1923         task_work_run();
1924 
1925     spin_lock_irq(&current->sighand->siglock);
1926     ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
1927     spin_unlock_irq(&current->sighand->siglock);
1928 }
1929 
1930 /**
1931  * do_signal_stop - handle group stop for SIGSTOP and other stop signals
1932  * @signr: signr causing group stop if initiating
1933  *
1934  * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
1935  * and participate in it.  If already set, participate in the existing
1936  * group stop.  If participated in a group stop (and thus slept), %true is
1937  * returned with siglock released.
1938  *
1939  * If ptraced, this function doesn't handle stop itself.  Instead,
1940  * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
1941  * untouched.  The caller must ensure that INTERRUPT trap handling takes
1942  * places afterwards.
1943  *
1944  * CONTEXT:
1945  * Must be called with @current->sighand->siglock held, which is released
1946  * on %true return.
1947  *
1948  * RETURNS:
1949  * %false if group stop is already cancelled or ptrace trap is scheduled.
1950  * %true if participated in group stop.
1951  */
1952 static bool do_signal_stop(int signr)
1953     __releases(&current->sighand->siglock)
1954 {
1955     struct signal_struct *sig = current->signal;
1956 
1957     if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
1958         unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
1959         struct task_struct *t;
1960 
1961         /* signr will be recorded in task->jobctl for retries */
1962         WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
1963 
1964         if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
1965             unlikely(signal_group_exit(sig)))
1966             return false;
1967         /*
1968          * There is no group stop already in progress.  We must
1969          * initiate one now.
1970          *
1971          * While ptraced, a task may be resumed while group stop is
1972          * still in effect and then receive a stop signal and
1973          * initiate another group stop.  This deviates from the
1974          * usual behavior as two consecutive stop signals can't
1975          * cause two group stops when !ptraced.  That is why we
1976          * also check !task_is_stopped(t) below.
1977          *
1978          * The condition can be distinguished by testing whether
1979          * SIGNAL_STOP_STOPPED is already set.  Don't generate
1980          * group_exit_code in such case.
1981          *
1982          * This is not necessary for SIGNAL_STOP_CONTINUED because
1983          * an intervening stop signal is required to cause two
1984          * continued events regardless of ptrace.
1985          */
1986         if (!(sig->flags & SIGNAL_STOP_STOPPED))
1987             sig->group_exit_code = signr;
1988 
1989         sig->group_stop_count = 0;
1990 
1991         if (task_set_jobctl_pending(current, signr | gstop))
1992             sig->group_stop_count++;
1993 
1994         t = current;
1995         while_each_thread(current, t) {
1996             /*
1997              * Setting state to TASK_STOPPED for a group
1998              * stop is always done with the siglock held,
1999              * so this check has no races.
2000              */
2001             if (!task_is_stopped(t) &&
2002                 task_set_jobctl_pending(t, signr | gstop)) {
2003                 sig->group_stop_count++;
2004                 if (likely(!(t->ptrace & PT_SEIZED)))
2005                     signal_wake_up(t, 0);
2006                 else
2007                     ptrace_trap_notify(t);
2008             }
2009         }
2010     }
2011 
2012     if (likely(!current->ptrace)) {
2013         int notify = 0;
2014 
2015         /*
2016          * If there are no other threads in the group, or if there
2017          * is a group stop in progress and we are the last to stop,
2018          * report to the parent.
2019          */
2020         if (task_participate_group_stop(current))
2021             notify = CLD_STOPPED;
2022 
2023         __set_current_state(TASK_STOPPED);
2024         spin_unlock_irq(&current->sighand->siglock);
2025 
2026         /*
2027          * Notify the parent of the group stop completion.  Because
2028          * we're not holding either the siglock or tasklist_lock
2029          * here, ptracer may attach inbetween; however, this is for
2030          * group stop and should always be delivered to the real
2031          * parent of the group leader.  The new ptracer will get
2032          * its notification when this task transitions into
2033          * TASK_TRACED.
2034          */
2035         if (notify) {
2036             read_lock(&tasklist_lock);
2037             do_notify_parent_cldstop(current, false, notify);
2038             read_unlock(&tasklist_lock);
2039         }
2040 
2041         /* Now we don't run again until woken by SIGCONT or SIGKILL */
2042         freezable_schedule();
2043         return true;
2044     } else {
2045         /*
2046          * While ptraced, group stop is handled by STOP trap.
2047          * Schedule it and let the caller deal with it.
2048          */
2049         task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
2050         return false;
2051     }
2052 }
2053 
2054 /**
2055  * do_jobctl_trap - take care of ptrace jobctl traps
2056  *
2057  * When PT_SEIZED, it's used for both group stop and explicit
2058  * SEIZE/INTERRUPT traps.  Both generate PTRACE_EVENT_STOP trap with
2059  * accompanying siginfo.  If stopped, lower eight bits of exit_code contain
2060  * the stop signal; otherwise, %SIGTRAP.
2061  *
2062  * When !PT_SEIZED, it's used only for group stop trap with stop signal
2063  * number as exit_code and no siginfo.
2064  *
2065  * CONTEXT:
2066  * Must be called with @current->sighand->siglock held, which may be
2067  * released and re-acquired before returning with intervening sleep.
2068  */
2069 static void do_jobctl_trap(void)
2070 {
2071     struct signal_struct *signal = current->signal;
2072     int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2073 
2074     if (current->ptrace & PT_SEIZED) {
2075         if (!signal->group_stop_count &&
2076             !(signal->flags & SIGNAL_STOP_STOPPED))
2077             signr = SIGTRAP;
2078         WARN_ON_ONCE(!signr);
2079         ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
2080                  CLD_STOPPED);
2081     } else {
2082         WARN_ON_ONCE(!signr);
2083         ptrace_stop(signr, CLD_STOPPED, 0, NULL);
2084         current->exit_code = 0;
2085     }
2086 }
2087 
2088 static int ptrace_signal(int signr, siginfo_t *info)
2089 {
2090     ptrace_signal_deliver();
2091     /*
2092      * We do not check sig_kernel_stop(signr) but set this marker
2093      * unconditionally because we do not know whether debugger will
2094      * change signr. This flag has no meaning unless we are going
2095      * to stop after return from ptrace_stop(). In this case it will
2096      * be checked in do_signal_stop(), we should only stop if it was
2097      * not cleared by SIGCONT while we were sleeping. See also the
2098      * comment in dequeue_signal().
2099      */
2100     current->jobctl |= JOBCTL_STOP_DEQUEUED;
2101     ptrace_stop(signr, CLD_TRAPPED, 0, info);
2102 
2103     /* We're back.  Did the debugger cancel the sig?  */
2104     signr = current->exit_code;
2105     if (signr == 0)
2106         return signr;
2107 
2108     current->exit_code = 0;
2109 
2110     /*
2111      * Update the siginfo structure if the signal has
2112      * changed.  If the debugger wanted something
2113      * specific in the siginfo structure then it should
2114      * have updated *info via PTRACE_SETSIGINFO.
2115      */
2116     if (signr != info->si_signo) {
2117         info->si_signo = signr;
2118         info->si_errno = 0;
2119         info->si_code = SI_USER;
2120         rcu_read_lock();
2121         info->si_pid = task_pid_vnr(current->parent);
2122         info->si_uid = from_kuid_munged(current_user_ns(),
2123                         task_uid(current->parent));
2124         rcu_read_unlock();
2125     }
2126 
2127     /* If the (new) signal is now blocked, requeue it.  */
2128     if (sigismember(&current->blocked, signr)) {
2129         specific_send_sig_info(signr, info, current);
2130         signr = 0;
2131     }
2132 
2133     return signr;
2134 }
2135 
2136 int get_signal(struct ksignal *ksig)
2137 {
2138     struct sighand_struct *sighand = current->sighand;
2139     struct signal_struct *signal = current->signal;
2140     int signr;
2141 
2142     if (unlikely(current->task_works))
2143         task_work_run();
2144 
2145     if (unlikely(uprobe_deny_signal()))
2146         return 0;
2147 
2148     /*
2149      * Do this once, we can't return to user-mode if freezing() == T.
2150      * do_signal_stop() and ptrace_stop() do freezable_schedule() and
2151      * thus do not need another check after return.
2152      */
2153     try_to_freeze();
2154 
2155 relock:
2156     spin_lock_irq(&sighand->siglock);
2157     /*
2158      * Every stopped thread goes here after wakeup. Check to see if
2159      * we should notify the parent, prepare_signal(SIGCONT) encodes
2160      * the CLD_ si_code into SIGNAL_CLD_MASK bits.
2161      */
2162     if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2163         int why;
2164 
2165         if (signal->flags & SIGNAL_CLD_CONTINUED)
2166             why = CLD_CONTINUED;
2167         else
2168             why = CLD_STOPPED;
2169 
2170         signal->flags &= ~SIGNAL_CLD_MASK;
2171 
2172         spin_unlock_irq(&sighand->siglock);
2173 
2174         /*
2175          * Notify the parent that we're continuing.  This event is
2176          * always per-process and doesn't make whole lot of sense
2177          * for ptracers, who shouldn't consume the state via
2178          * wait(2) either, but, for backward compatibility, notify
2179          * the ptracer of the group leader too unless it's gonna be
2180          * a duplicate.
2181          */
2182         read_lock(&tasklist_lock);
2183         do_notify_parent_cldstop(current, false, why);
2184 
2185         if (ptrace_reparented(current->group_leader))
2186             do_notify_parent_cldstop(current->group_leader,
2187                         true, why);
2188         read_unlock(&tasklist_lock);
2189 
2190         goto relock;
2191     }
2192 
2193     for (;;) {
2194         struct k_sigaction *ka;
2195 
2196         if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
2197             do_signal_stop(0))
2198             goto relock;
2199 
2200         if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
2201             do_jobctl_trap();
2202             spin_unlock_irq(&sighand->siglock);
2203             goto relock;
2204         }
2205 
2206         signr = dequeue_signal(current, &current->blocked, &ksig->info);
2207 
2208         if (!signr)
2209             break; /* will return 0 */
2210 
2211         if (unlikely(current->ptrace) && signr != SIGKILL) {
2212             signr = ptrace_signal(signr, &ksig->info);
2213             if (!signr)
2214                 continue;
2215         }
2216 
2217         ka = &sighand->action[signr-1];
2218 
2219         /* Trace actually delivered signals. */
2220         trace_signal_deliver(signr, &ksig->info, ka);
2221 
2222         if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
2223             continue;
2224         if (ka->sa.sa_handler != SIG_DFL) {
2225             /* Run the handler.  */
2226             ksig->ka = *ka;
2227 
2228             if (ka->sa.sa_flags & SA_ONESHOT)
2229                 ka->sa.sa_handler = SIG_DFL;
2230 
2231             break; /* will return non-zero "signr" value */
2232         }
2233 
2234         /*
2235          * Now we are doing the default action for this signal.
2236          */
2237         if (sig_kernel_ignore(signr)) /* Default is nothing. */
2238             continue;
2239 
2240         /*
2241          * Global init gets no signals it doesn't want.
2242          * Container-init gets no signals it doesn't want from same
2243          * container.
2244          *
2245          * Note that if global/container-init sees a sig_kernel_only()
2246          * signal here, the signal must have been generated internally
2247          * or must have come from an ancestor namespace. In either
2248          * case, the signal cannot be dropped.
2249          */
2250         if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2251                 !sig_kernel_only(signr))
2252             continue;
2253 
2254         if (sig_kernel_stop(signr)) {
2255             /*
2256              * The default action is to stop all threads in
2257              * the thread group.  The job control signals
2258              * do nothing in an orphaned pgrp, but SIGSTOP
2259              * always works.  Note that siglock needs to be
2260              * dropped during the call to is_orphaned_pgrp()
2261              * because of lock ordering with tasklist_lock.
2262              * This allows an intervening SIGCONT to be posted.
2263              * We need to check for that and bail out if necessary.
2264              */
2265             if (signr != SIGSTOP) {
2266                 spin_unlock_irq(&sighand->siglock);
2267 
2268                 /* signals can be posted during this window */
2269 
2270                 if (is_current_pgrp_orphaned())
2271                     goto relock;
2272 
2273                 spin_lock_irq(&sighand->siglock);
2274             }
2275 
2276             if (likely(do_signal_stop(ksig->info.si_signo))) {
2277                 /* It released the siglock.  */
2278                 goto relock;
2279             }
2280 
2281             /*
2282              * We didn't actually stop, due to a race
2283              * with SIGCONT or something like that.
2284              */
2285             continue;
2286         }
2287 
2288         spin_unlock_irq(&sighand->siglock);
2289 
2290         /*
2291          * Anything else is fatal, maybe with a core dump.
2292          */
2293         current->flags |= PF_SIGNALED;
2294 
2295         if (sig_kernel_coredump(signr)) {
2296             if (print_fatal_signals)
2297                 print_fatal_signal(ksig->info.si_signo);
2298             proc_coredump_connector(current);
2299             /*
2300              * If it was able to dump core, this kills all
2301              * other threads in the group and synchronizes with
2302              * their demise.  If we lost the race with another
2303              * thread getting here, it set group_exit_code
2304              * first and our do_group_exit call below will use
2305              * that value and ignore the one we pass it.
2306              */
2307             do_coredump(&ksig->info);
2308         }
2309 
2310         /*
2311          * Death signals, no core dump.
2312          */
2313         do_group_exit(ksig->info.si_signo);
2314         /* NOTREACHED */
2315     }
2316     spin_unlock_irq(&sighand->siglock);
2317 
2318     ksig->sig = signr;
2319     return ksig->sig > 0;
2320 }
2321 
2322 /**
2323  * signal_delivered - 
2324  * @ksig:       kernel signal struct
2325  * @stepping:       nonzero if debugger single-step or block-step in use
2326  *
2327  * This function should be called when a signal has successfully been
2328  * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
2329  * is always blocked, and the signal itself is blocked unless %SA_NODEFER
2330  * is set in @ksig->ka.sa.sa_flags.  Tracing is notified.
2331  */
2332 static void signal_delivered(struct ksignal *ksig, int stepping)
2333 {
2334     sigset_t blocked;
2335 
2336     /* A signal was successfully delivered, and the
2337        saved sigmask was stored on the signal frame,
2338        and will be restored by sigreturn.  So we can
2339        simply clear the restore sigmask flag.  */
2340     clear_restore_sigmask();
2341 
2342     sigorsets(&blocked, &current->blocked, &ksig->ka.sa.sa_mask);
2343     if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
2344         sigaddset(&blocked, ksig->sig);
2345     set_current_blocked(&blocked);
2346     tracehook_signal_handler(stepping);
2347 }
2348 
2349 void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2350 {
2351     if (failed)
2352         force_sigsegv(ksig->sig, current);
2353     else
2354         signal_delivered(ksig, stepping);
2355 }
2356 
2357 /*
2358  * It could be that complete_signal() picked us to notify about the
2359  * group-wide signal. Other threads should be notified now to take
2360  * the shared signals in @which since we will not.
2361  */
2362 static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2363 {
2364     sigset_t retarget;
2365     struct task_struct *t;
2366 
2367     sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
2368     if (sigisemptyset(&retarget))
2369         return;
2370 
2371     t = tsk;
2372     while_each_thread(tsk, t) {
2373         if (t->flags & PF_EXITING)
2374             continue;
2375 
2376         if (!has_pending_signals(&retarget, &t->blocked))
2377             continue;
2378         /* Remove the signals this thread can handle. */
2379         sigandsets(&retarget, &retarget, &t->blocked);
2380 
2381         if (!signal_pending(t))
2382             signal_wake_up(t, 0);
2383 
2384         if (sigisemptyset(&retarget))
2385             break;
2386     }
2387 }
2388 
2389 void exit_signals(struct task_struct *tsk)
2390 {
2391     int group_stop = 0;
2392     sigset_t unblocked;
2393 
2394     /*
2395      * @tsk is about to have PF_EXITING set - lock out users which
2396      * expect stable threadgroup.
2397      */
2398     threadgroup_change_begin(tsk);
2399 
2400     if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2401         tsk->flags |= PF_EXITING;
2402         threadgroup_change_end(tsk);
2403         return;
2404     }
2405 
2406     spin_lock_irq(&tsk->sighand->siglock);
2407     /*
2408      * From now this task is not visible for group-wide signals,
2409      * see wants_signal(), do_signal_stop().
2410      */
2411     tsk->flags |= PF_EXITING;
2412 
2413     threadgroup_change_end(tsk);
2414 
2415     if (!signal_pending(tsk))
2416         goto out;
2417 
2418     unblocked = tsk->blocked;
2419     signotset(&unblocked);
2420     retarget_shared_pending(tsk, &unblocked);
2421 
2422     if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2423         task_participate_group_stop(tsk))
2424         group_stop = CLD_STOPPED;
2425 out:
2426     spin_unlock_irq(&tsk->sighand->siglock);
2427 
2428     /*
2429      * If group stop has completed, deliver the notification.  This
2430      * should always go to the real parent of the group leader.
2431      */
2432     if (unlikely(group_stop)) {
2433         read_lock(&tasklist_lock);
2434         do_notify_parent_cldstop(tsk, false, group_stop);
2435         read_unlock(&tasklist_lock);
2436     }
2437 }
2438 
2439 EXPORT_SYMBOL(recalc_sigpending);
2440 EXPORT_SYMBOL_GPL(dequeue_signal);
2441 EXPORT_SYMBOL(flush_signals);
2442 EXPORT_SYMBOL(force_sig);
2443 EXPORT_SYMBOL(send_sig);
2444 EXPORT_SYMBOL(send_sig_info);
2445 EXPORT_SYMBOL(sigprocmask);
2446 
2447 /*
2448  * System call entry points.
2449  */
2450 
2451 /**
2452  *  sys_restart_syscall - restart a system call
2453  */
2454 SYSCALL_DEFINE0(restart_syscall)
2455 {
2456     struct restart_block *restart = &current->restart_block;
2457     return restart->fn(restart);
2458 }
2459 
2460 long do_no_restart_syscall(struct restart_block *param)
2461 {
2462     return -EINTR;
2463 }
2464 
2465 static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
2466 {
2467     if (signal_pending(tsk) && !thread_group_empty(tsk)) {
2468         sigset_t newblocked;
2469         /* A set of now blocked but previously unblocked signals. */
2470         sigandnsets(&newblocked, newset, &current->blocked);
2471         retarget_shared_pending(tsk, &newblocked);
2472     }
2473     tsk->blocked = *newset;
2474     recalc_sigpending();
2475 }
2476 
2477 /**
2478  * set_current_blocked - change current->blocked mask
2479  * @newset: new mask
2480  *
2481  * It is wrong to change ->blocked directly, this helper should be used
2482  * to ensure the process can't miss a shared signal we are going to block.
2483  */
2484 void set_current_blocked(sigset_t *newset)
2485 {
2486     sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2487     __set_current_blocked(newset);
2488 }
2489 
2490 void __set_current_blocked(const sigset_t *newset)
2491 {
2492     struct task_struct *tsk = current;
2493 
2494     /*
2495      * In case the signal mask hasn't changed, there is nothing we need
2496      * to do. The current->blocked shouldn't be modified by other task.
2497      */
2498     if (sigequalsets(&tsk->blocked, newset))
2499         return;
2500 
2501     spin_lock_irq(&tsk->sighand->siglock);
2502     __set_task_blocked(tsk, newset);
2503     spin_unlock_irq(&tsk->sighand->siglock);
2504 }
2505 
2506 /*
2507  * This is also useful for kernel threads that want to temporarily
2508  * (or permanently) block certain signals.
2509  *
2510  * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2511  * interface happily blocks "unblockable" signals like SIGKILL
2512  * and friends.
2513  */
2514 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2515 {
2516     struct task_struct *tsk = current;
2517     sigset_t newset;
2518 
2519     /* Lockless, only current can change ->blocked, never from irq */
2520     if (oldset)
2521         *oldset = tsk->blocked;
2522 
2523     switch (how) {
2524     case SIG_BLOCK:
2525         sigorsets(&newset, &tsk->blocked, set);
2526         break;
2527     case SIG_UNBLOCK:
2528         sigandnsets(&newset, &tsk->blocked, set);
2529         break;
2530     case SIG_SETMASK:
2531         newset = *set;
2532         break;
2533     default:
2534         return -EINVAL;
2535     }
2536 
2537     __set_current_blocked(&newset);
2538     return 0;
2539 }
2540 
2541 /**
2542  *  sys_rt_sigprocmask - change the list of currently blocked signals
2543  *  @how: whether to add, remove, or set signals
2544  *  @nset: stores pending signals
2545  *  @oset: previous value of signal mask if non-null
2546  *  @sigsetsize: size of sigset_t type
2547  */
2548 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
2549         sigset_t __user *, oset, size_t, sigsetsize)
2550 {
2551     sigset_t old_set, new_set;
2552     int error;
2553 
2554     /* XXX: Don't preclude handling different sized sigset_t's.  */
2555     if (sigsetsize != sizeof(sigset_t))
2556         return -EINVAL;
2557 
2558     old_set = current->blocked;
2559 
2560     if (nset) {
2561         if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
2562             return -EFAULT;
2563         sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2564 
2565         error = sigprocmask(how, &new_set, NULL);
2566         if (error)
2567             return error;
2568     }
2569 
2570     if (oset) {
2571         if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
2572             return -EFAULT;
2573     }
2574 
2575     return 0;
2576 }
2577 
2578 #ifdef CONFIG_COMPAT
2579 COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
2580         compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
2581 {
2582 #ifdef __BIG_ENDIAN
2583     sigset_t old_set = current->blocked;
2584 
2585     /* XXX: Don't preclude handling different sized sigset_t's.  */
2586     if (sigsetsize != sizeof(sigset_t))
2587         return -EINVAL;
2588 
2589     if (nset) {
2590         compat_sigset_t new32;
2591         sigset_t new_set;
2592         int error;
2593         if (copy_from_user(&new32, nset, sizeof(compat_sigset_t)))
2594             return -EFAULT;
2595 
2596         sigset_from_compat(&new_set, &new32);
2597         sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2598 
2599         error = sigprocmask(how, &new_set, NULL);
2600         if (error)
2601             return error;
2602     }
2603     if (oset) {
2604         compat_sigset_t old32;
2605         sigset_to_compat(&old32, &old_set);
2606         if (copy_to_user(oset, &old32, sizeof(compat_sigset_t)))
2607             return -EFAULT;
2608     }
2609     return 0;
2610 #else
2611     return sys_rt_sigprocmask(how, (sigset_t __user *)nset,
2612                   (sigset_t __user *)oset, sigsetsize);
2613 #endif
2614 }
2615 #endif
2616 
2617 static int do_sigpending(void *set, unsigned long sigsetsize)
2618 {
2619     if (sigsetsize > sizeof(sigset_t))
2620         return -EINVAL;
2621 
2622     spin_lock_irq(&current->sighand->siglock);
2623     sigorsets(set, &current->pending.signal,
2624           &current->signal->shared_pending.signal);
2625     spin_unlock_irq(&current->sighand->siglock);
2626 
2627     /* Outside the lock because only this thread touches it.  */
2628     sigandsets(set, &current->blocked, set);
2629     return 0;
2630 }
2631 
2632 /**
2633  *  sys_rt_sigpending - examine a pending signal that has been raised
2634  *          while blocked
2635  *  @uset: stores pending signals
2636  *  @sigsetsize: size of sigset_t type or larger
2637  */
2638 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
2639 {
2640     sigset_t set;
2641     int err = do_sigpending(&set, sigsetsize);
2642     if (!err && copy_to_user(uset, &set, sigsetsize))
2643         err = -EFAULT;
2644     return err;
2645 }
2646 
2647 #ifdef CONFIG_COMPAT
2648 COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
2649         compat_size_t, sigsetsize)
2650 {
2651 #ifdef __BIG_ENDIAN
2652     sigset_t set;
2653     int err = do_sigpending(&set, sigsetsize);
2654     if (!err) {
2655         compat_sigset_t set32;
2656         sigset_to_compat(&set32, &set);
2657         /* we can get here only if sigsetsize <= sizeof(set) */
2658         if (copy_to_user(uset, &set32, sigsetsize))
2659             err = -EFAULT;
2660     }
2661     return err;
2662 #else
2663     return sys_rt_sigpending((sigset_t __user *)uset, sigsetsize);
2664 #endif
2665 }
2666 #endif
2667 
2668 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2669 
2670 int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
2671 {
2672     int err;
2673 
2674     if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2675         return -EFAULT;
2676     if (from->si_code < 0)
2677         return __copy_to_user(to, from, sizeof(siginfo_t))
2678             ? -EFAULT : 0;
2679     /*
2680      * If you change siginfo_t structure, please be sure
2681      * this code is fixed accordingly.
2682      * Please remember to update the signalfd_copyinfo() function
2683      * inside fs/signalfd.c too, in case siginfo_t changes.
2684      * It should never copy any pad contained in the structure
2685      * to avoid security leaks, but must copy the generic
2686      * 3 ints plus the relevant union member.
2687      */
2688     err = __put_user(from->si_signo, &to->si_signo);
2689     err |= __put_user(from->si_errno, &to->si_errno);
2690     err |= __put_user((short)from->si_code, &to->si_code);
2691     switch (from->si_code & __SI_MASK) {
2692     case __SI_KILL:
2693         err |= __put_user(from->si_pid, &to->si_pid);
2694         err |= __put_user(from->si_uid, &to->si_uid);
2695         break;
2696     case __SI_TIMER:
2697          err |= __put_user(from->si_tid, &to->si_tid);
2698          err |= __put_user(from->si_overrun, &to->si_overrun);
2699          err |= __put_user(from->si_ptr, &to->si_ptr);
2700         break;
2701     case __SI_POLL:
2702         err |= __put_user(from->si_band, &to->si_band);
2703         err |= __put_user(from->si_fd, &to->si_fd);
2704         break;
2705     case __SI_FAULT:
2706         err |= __put_user(from->si_addr, &to->si_addr);
2707 #ifdef __ARCH_SI_TRAPNO
2708         err |= __put_user(from->si_trapno, &to->si_trapno);
2709 #endif
2710 #ifdef BUS_MCEERR_AO
2711         /*
2712          * Other callers might not initialize the si_lsb field,
2713          * so check explicitly for the right codes here.
2714          */
2715         if (from->si_signo == SIGBUS &&
2716             (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO))
2717             err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
2718 #endif
2719 #ifdef SEGV_BNDERR
2720         if (from->si_signo == SIGSEGV && from->si_code == SEGV_BNDERR) {
2721             err |= __put_user(from->si_lower, &to->si_lower);
2722             err |= __put_user(from->si_upper, &to->si_upper);
2723         }
2724 #endif
2725 #ifdef SEGV_PKUERR
2726         if (from->si_signo == SIGSEGV && from->si_code == SEGV_PKUERR)
2727             err |= __put_user(from->si_pkey, &to->si_pkey);
2728 #endif
2729         break;
2730     case __SI_CHLD:
2731         err |= __put_user(from->si_pid, &to->si_pid);
2732         err |= __put_user(from->si_uid, &to->si_uid);
2733         err |= __put_user(from->si_status, &to->si_status);
2734         err |= __put_user(from->si_utime, &to->si_utime);
2735         err |= __put_user(from->si_stime, &to->si_stime);
2736         break;
2737     case __SI_RT: /* This is not generated by the kernel as of now. */
2738     case __SI_MESGQ: /* But this is */
2739         err |= __put_user(from->si_pid, &to->si_pid);
2740         err |= __put_user(from->si_uid, &to->si_uid);
2741         err |= __put_user(from->si_ptr, &to->si_ptr);
2742         break;
2743 #ifdef __ARCH_SIGSYS
2744     case __SI_SYS:
2745         err |= __put_user(from->si_call_addr, &to->si_call_addr);
2746         err |= __put_user(from->si_syscall, &to->si_syscall);
2747         err |= __put_user(from->si_arch, &to->si_arch);
2748         break;
2749 #endif
2750     default: /* this is just in case for now ... */
2751         err |= __put_user(from->si_pid, &to->si_pid);
2752         err |= __put_user(from->si_uid, &to->si_uid);
2753         break;
2754     }
2755     return err;
2756 }
2757 
2758 #endif
2759 
2760 /**
2761  *  do_sigtimedwait - wait for queued signals specified in @which
2762  *  @which: queued signals to wait for
2763  *  @info: if non-null, the signal's siginfo is returned here
2764  *  @ts: upper bound on process time suspension
2765  */
2766 int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
2767             const struct timespec *ts)
2768 {
2769     ktime_t *to = NULL, timeout = KTIME_MAX;
2770     struct task_struct *tsk = current;
2771     sigset_t mask = *which;
2772     int sig, ret = 0;
2773 
2774     if (ts) {
2775         if (!timespec_valid(ts))
2776             return -EINVAL;
2777         timeout = timespec_to_ktime(*ts);
2778         to = &timeout;
2779     }
2780 
2781     /*
2782      * Invert the set of allowed signals to get those we want to block.
2783      */
2784     sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
2785     signotset(&mask);
2786 
2787     spin_lock_irq(&tsk->sighand->siglock);
2788     sig = dequeue_signal(tsk, &mask, info);
2789     if (!sig && timeout) {
2790         /*
2791          * None ready, temporarily unblock those we're interested
2792          * while we are sleeping in so that we'll be awakened when
2793          * they arrive. Unblocking is always fine, we can avoid
2794          * set_current_blocked().
2795          */
2796         tsk->real_blocked = tsk->blocked;
2797         sigandsets(&tsk->blocked, &tsk->blocked, &mask);
2798         recalc_sigpending();
2799         spin_unlock_irq(&tsk->sighand->siglock);
2800 
2801         __set_current_state(TASK_INTERRUPTIBLE);
2802         ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns,
2803                              HRTIMER_MODE_REL);
2804         spin_lock_irq(&tsk->sighand->siglock);
2805         __set_task_blocked(tsk, &tsk->real_blocked);
2806         sigemptyset(&tsk->real_blocked);
2807         sig = dequeue_signal(tsk, &mask, info);
2808     }
2809     spin_unlock_irq(&tsk->sighand->siglock);
2810 
2811     if (sig)
2812         return sig;
2813     return ret ? -EINTR : -EAGAIN;
2814 }
2815 
2816 /**
2817  *  sys_rt_sigtimedwait - synchronously wait for queued signals specified
2818  *          in @uthese
2819  *  @uthese: queued signals to wait for
2820  *  @uinfo: if non-null, the signal's siginfo is returned here
2821  *  @uts: upper bound on process time suspension
2822  *  @sigsetsize: size of sigset_t type
2823  */
2824 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2825         siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2826         size_t, sigsetsize)
2827 {
2828     sigset_t these;
2829     struct timespec ts;
2830     siginfo_t info;
2831     int ret;
2832 
2833     /* XXX: Don't preclude handling different sized sigset_t's.  */
2834     if (sigsetsize != sizeof(sigset_t))
2835         return -EINVAL;
2836 
2837     if (copy_from_user(&these, uthese, sizeof(these)))
2838         return -EFAULT;
2839 
2840     if (uts) {
2841         if (copy_from_user(&ts, uts, sizeof(ts)))
2842             return -EFAULT;
2843     }
2844 
2845     ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
2846 
2847     if (ret > 0 && uinfo) {
2848         if (copy_siginfo_to_user(uinfo, &info))
2849             ret = -EFAULT;
2850     }
2851 
2852     return ret;
2853 }
2854 
2855 /**
2856  *  sys_kill - send a signal to a process
2857  *  @pid: the PID of the process
2858  *  @sig: signal to be sent
2859  */
2860 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
2861 {
2862     struct siginfo info;
2863 
2864     info.si_signo = sig;
2865     info.si_errno = 0;
2866     info.si_code = SI_USER;
2867     info.si_pid = task_tgid_vnr(current);
2868     info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2869 
2870     return kill_something_info(sig, &info, pid);
2871 }
2872 
2873 static int
2874 do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
2875 {
2876     struct task_struct *p;
2877     int error = -ESRCH;
2878 
2879     rcu_read_lock();
2880     p = find_task_by_vpid(pid);
2881     if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2882         error = check_kill_permission(sig, info, p);
2883         /*
2884          * The null signal is a permissions and process existence
2885          * probe.  No signal is actually delivered.
2886          */
2887         if (!error && sig) {
2888             error = do_send_sig_info(sig, info, p, false);
2889             /*
2890              * If lock_task_sighand() failed we pretend the task
2891              * dies after receiving the signal. The window is tiny,
2892              * and the signal is private anyway.
2893              */
2894             if (unlikely(error == -ESRCH))
2895                 error = 0;
2896         }
2897     }
2898     rcu_read_unlock();
2899 
2900     return error;
2901 }
2902 
2903 static int do_tkill(pid_t tgid, pid_t pid, int sig)
2904 {
2905     struct siginfo info = {};
2906 
2907     info.si_signo = sig;
2908     info.si_errno = 0;
2909     info.si_code = SI_TKILL;
2910     info.si_pid = task_tgid_vnr(current);
2911     info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2912 
2913     return do_send_specific(tgid, pid, sig, &info);
2914 }
2915 
2916 /**
2917  *  sys_tgkill - send signal to one specific thread
2918  *  @tgid: the thread group ID of the thread
2919  *  @pid: the PID of the thread
2920  *  @sig: signal to be sent
2921  *
2922  *  This syscall also checks the @tgid and returns -ESRCH even if the PID
2923  *  exists but it's not belonging to the target process anymore. This
2924  *  method solves the problem of threads exiting and PIDs getting reused.
2925  */
2926 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
2927 {
2928     /* This is only valid for single tasks */
2929     if (pid <= 0 || tgid <= 0)
2930         return -EINVAL;
2931 
2932     return do_tkill(tgid, pid, sig);
2933 }
2934 
2935 /**
2936  *  sys_tkill - send signal to one specific task
2937  *  @pid: the PID of the task
2938  *  @sig: signal to be sent
2939  *
2940  *  Send a signal to only one task, even if it's a CLONE_THREAD task.
2941  */
2942 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
2943 {
2944     /* This is only valid for single tasks */
2945     if (pid <= 0)
2946         return -EINVAL;
2947 
2948     return do_tkill(0, pid, sig);
2949 }
2950 
2951 static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t *info)
2952 {
2953     /* Not even root can pretend to send signals from the kernel.
2954      * Nor can they impersonate a kill()/tgkill(), which adds source info.
2955      */
2956     if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
2957         (task_pid_vnr(current) != pid))
2958         return -EPERM;
2959 
2960     info->si_signo = sig;
2961 
2962     /* POSIX.1b doesn't mention process groups.  */
2963     return kill_proc_info(sig, info, pid);
2964 }
2965 
2966 /**
2967  *  sys_rt_sigqueueinfo - send signal information to a signal
2968  *  @pid: the PID of the thread
2969  *  @sig: signal to be sent
2970  *  @uinfo: signal info to be sent
2971  */
2972 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
2973         siginfo_t __user *, uinfo)
2974 {
2975     siginfo_t info;
2976     if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2977         return -EFAULT;
2978     return do_rt_sigqueueinfo(pid, sig, &info);
2979 }
2980 
2981 #ifdef CONFIG_COMPAT
2982 COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
2983             compat_pid_t, pid,
2984             int, sig,
2985             struct compat_siginfo __user *, uinfo)
2986 {
2987     siginfo_t info = {};
2988     int ret = copy_siginfo_from_user32(&info, uinfo);
2989     if (unlikely(ret))
2990         return ret;
2991     return do_rt_sigqueueinfo(pid, sig, &info);
2992 }
2993 #endif
2994 
2995 static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
2996 {
2997     /* This is only valid for single tasks */
2998     if (pid <= 0 || tgid <= 0)
2999         return -EINVAL;
3000 
3001     /* Not even root can pretend to send signals from the kernel.
3002      * Nor can they impersonate a kill()/tgkill(), which adds source info.
3003      */
3004     if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3005         (task_pid_vnr(current) != pid))
3006         return -EPERM;
3007 
3008     info->si_signo = sig;
3009 
3010     return do_send_specific(tgid, pid, sig, info);
3011 }
3012 
3013 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
3014         siginfo_t __user *, uinfo)
3015 {
3016     siginfo_t info;
3017 
3018     if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3019         return -EFAULT;
3020 
3021     return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3022 }
3023 
3024 #ifdef CONFIG_COMPAT
3025 COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
3026             compat_pid_t, tgid,
3027             compat_pid_t, pid,
3028             int, sig,
3029             struct compat_siginfo __user *, uinfo)
3030 {
3031     siginfo_t info = {};
3032 
3033     if (copy_siginfo_from_user32(&info, uinfo))
3034         return -EFAULT;
3035     return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3036 }
3037 #endif
3038 
3039 /*
3040  * For kthreads only, must not be used if cloned with CLONE_SIGHAND
3041  */
3042 void kernel_sigaction(int sig, __sighandler_t action)
3043 {
3044     spin_lock_irq(&current->sighand->siglock);
3045     current->sighand->action[sig - 1].sa.sa_handler = action;
3046     if (action == SIG_IGN) {
3047         sigset_t mask;
3048 
3049         sigemptyset(&mask);
3050         sigaddset(&mask, sig);
3051 
3052         flush_sigqueue_mask(&mask, &current->signal->shared_pending);
3053         flush_sigqueue_mask(&mask, &current->pending);
3054         recalc_sigpending();
3055     }
3056     spin_unlock_irq(&current->sighand->siglock);
3057 }
3058 EXPORT_SYMBOL(kernel_sigaction);
3059 
3060 void __weak sigaction_compat_abi(struct k_sigaction *act,
3061         struct k_sigaction *oact)
3062 {
3063 }
3064 
3065 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
3066 {
3067     struct task_struct *p = current, *t;
3068     struct k_sigaction *k;
3069     sigset_t mask;
3070 
3071     if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
3072         return -EINVAL;
3073 
3074     k = &p->sighand->action[sig-1];
3075 
3076     spin_lock_irq(&p->sighand->siglock);
3077     if (oact)
3078         *oact = *k;
3079 
3080     sigaction_compat_abi(act, oact);
3081 
3082     if (act) {
3083         sigdelsetmask(&act->sa.sa_mask,
3084                   sigmask(SIGKILL) | sigmask(SIGSTOP));
3085         *k = *act;
3086         /*
3087          * POSIX 3.3.1.3:
3088          *  "Setting a signal action to SIG_IGN for a signal that is
3089          *   pending shall cause the pending signal to be discarded,
3090          *   whether or not it is blocked."
3091          *
3092          *  "Setting a signal action to SIG_DFL for a signal that is
3093          *   pending and whose default action is to ignore the signal
3094          *   (for example, SIGCHLD), shall cause the pending signal to
3095          *   be discarded, whether or not it is blocked"
3096          */
3097         if (sig_handler_ignored(sig_handler(p, sig), sig)) {
3098             sigemptyset(&mask);
3099             sigaddset(&mask, sig);
3100             flush_sigqueue_mask(&mask, &p->signal->shared_pending);
3101             for_each_thread(p, t)
3102                 flush_sigqueue_mask(&mask, &t->pending);
3103         }
3104     }
3105 
3106     spin_unlock_irq(&p->sighand->siglock);
3107     return 0;
3108 }
3109 
3110 static int
3111 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
3112 {
3113     stack_t oss;
3114     int error;
3115 
3116     oss.ss_sp = (void __user *) current->sas_ss_sp;
3117     oss.ss_size = current->sas_ss_size;
3118     oss.ss_flags = sas_ss_flags(sp) |
3119         (current->sas_ss_flags & SS_FLAG_BITS);
3120 
3121     if (uss) {
3122         void __user *ss_sp;
3123         size_t ss_size;
3124         unsigned ss_flags;
3125         int ss_mode;
3126 
3127         error = -EFAULT;
3128         if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
3129             goto out;
3130         error = __get_user(ss_sp, &uss->ss_sp) |
3131             __get_user(ss_flags, &uss->ss_flags) |
3132             __get_user(ss_size, &uss->ss_size);
3133         if (error)
3134             goto out;
3135 
3136         error = -EPERM;
3137         if (on_sig_stack(sp))
3138             goto out;
3139 
3140         ss_mode = ss_flags & ~SS_FLAG_BITS;
3141         error = -EINVAL;
3142         if (ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
3143                 ss_mode != 0)
3144             goto out;
3145 
3146         if (ss_mode == SS_DISABLE) {
3147             ss_size = 0;
3148             ss_sp = NULL;
3149         } else {
3150             error = -ENOMEM;
3151             if (ss_size < MINSIGSTKSZ)
3152                 goto out;
3153         }
3154 
3155         current->sas_ss_sp = (unsigned long) ss_sp;
3156         current->sas_ss_size = ss_size;
3157         current->sas_ss_flags = ss_flags;
3158     }
3159 
3160     error = 0;
3161     if (uoss) {
3162         error = -EFAULT;
3163         if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
3164             goto out;
3165         error = __put_user(oss.ss_sp, &uoss->ss_sp) |
3166             __put_user(oss.ss_size, &uoss->ss_size) |
3167             __put_user(oss.ss_flags, &uoss->ss_flags);
3168     }
3169 
3170 out:
3171     return error;
3172 }
3173 SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
3174 {
3175     return do_sigaltstack(uss, uoss, current_user_stack_pointer());
3176 }
3177 
3178 int restore_altstack(const stack_t __user *uss)
3179 {
3180     int err = do_sigaltstack(uss, NULL, current_user_stack_pointer());
3181     /* squash all but EFAULT for now */
3182     return err == -EFAULT ? err : 0;
3183 }
3184 
3185 int __save_altstack(stack_t __user *uss, unsigned long sp)
3186 {
3187     struct task_struct *t = current;
3188     int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
3189         __put_user(t->sas_ss_flags, &uss->ss_flags) |
3190         __put_user(t->sas_ss_size, &uss->ss_size);
3191     if (err)
3192         return err;
3193     if (t->sas_ss_flags & SS_AUTODISARM)
3194         sas_ss_reset(t);
3195     return 0;
3196 }
3197 
3198 #ifdef CONFIG_COMPAT
3199 COMPAT_SYSCALL_DEFINE2(sigaltstack,
3200             const compat_stack_t __user *, uss_ptr,
3201             compat_stack_t __user *, uoss_ptr)
3202 {
3203     stack_t uss, uoss;
3204     int ret;
3205     mm_segment_t seg;
3206 
3207     if (uss_ptr) {
3208         compat_stack_t uss32;
3209 
3210         memset(&uss, 0, sizeof(stack_t));
3211         if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
3212             return -EFAULT;
3213         uss.ss_sp = compat_ptr(uss32.ss_sp);
3214         uss.ss_flags = uss32.ss_flags;
3215         uss.ss_size = uss32.ss_size;
3216     }
3217     seg = get_fs();
3218     set_fs(KERNEL_DS);
3219     ret = do_sigaltstack((stack_t __force __user *) (uss_ptr ? &uss : NULL),
3220                  (stack_t __force __user *) &uoss,
3221                  compat_user_stack_pointer());
3222     set_fs(seg);
3223     if (ret >= 0 && uoss_ptr)  {
3224         if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(compat_stack_t)) ||
3225             __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
3226             __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
3227             __put_user(uoss.ss_size, &uoss_ptr->ss_size))
3228             ret = -EFAULT;
3229     }
3230     return ret;
3231 }
3232 
3233 int compat_restore_altstack(const compat_stack_t __user *uss)
3234 {
3235     int err = compat_sys_sigaltstack(uss, NULL);
3236     /* squash all but -EFAULT for now */
3237     return err == -EFAULT ? err : 0;
3238 }
3239 
3240 int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
3241 {
3242     struct task_struct *t = current;
3243     return  __put_user(ptr_to_compat((void __user *)t->sas_ss_sp), &uss->ss_sp) |
3244         __put_user(sas_ss_flags(sp), &uss->ss_flags) |
3245         __put_user(t->sas_ss_size, &uss->ss_size);
3246 }
3247 #endif
3248 
3249 #ifdef __ARCH_WANT_SYS_SIGPENDING
3250 
3251 /**
3252  *  sys_sigpending - examine pending signals
3253  *  @set: where mask of pending signal is returned
3254  */
3255 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
3256 {
3257     return sys_rt_sigpending((sigset_t __user *)set, sizeof(old_sigset_t)); 
3258 }
3259 
3260 #endif
3261 
3262 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
3263 /**
3264  *  sys_sigprocmask - examine and change blocked signals
3265  *  @how: whether to add, remove, or set signals
3266  *  @nset: signals to add or remove (if non-null)
3267  *  @oset: previous value of signal mask if non-null
3268  *
3269  * Some platforms have their own version with special arguments;
3270  * others support only sys_rt_sigprocmask.
3271  */
3272 
3273 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
3274         old_sigset_t __user *, oset)
3275 {
3276     old_sigset_t old_set, new_set;
3277     sigset_t new_blocked;
3278 
3279     old_set = current->blocked.sig[0];
3280 
3281     if (nset) {
3282         if (copy_from_user(&new_set, nset, sizeof(*nset)))
3283             return -EFAULT;
3284 
3285         new_blocked = current->blocked;
3286 
3287         switch (how) {
3288         case SIG_BLOCK:
3289             sigaddsetmask(&new_blocked, new_set);
3290             break;
3291         case SIG_UNBLOCK:
3292             sigdelsetmask(&new_blocked, new_set);
3293             break;
3294         case SIG_SETMASK:
3295             new_blocked.sig[0] = new_set;
3296             break;
3297         default:
3298             return -EINVAL;
3299         }
3300 
3301         set_current_blocked(&new_blocked);
3302     }
3303 
3304     if (oset) {
3305         if (copy_to_user(oset, &old_set, sizeof(*oset)))
3306             return -EFAULT;
3307     }
3308 
3309     return 0;
3310 }
3311 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
3312 
3313 #ifndef CONFIG_ODD_RT_SIGACTION
3314 /**
3315  *  sys_rt_sigaction - alter an action taken by a process
3316  *  @sig: signal to be sent
3317  *  @act: new sigaction
3318  *  @oact: used to save the previous sigaction
3319  *  @sigsetsize: size of sigset_t type
3320  */
3321 SYSCALL_DEFINE4(rt_sigaction, int, sig,
3322         const struct sigaction __user *, act,
3323         struct sigaction __user *, oact,
3324         size_t, sigsetsize)
3325 {
3326     struct k_sigaction new_sa, old_sa;
3327     int ret = -EINVAL;
3328 
3329     /* XXX: Don't preclude handling different sized sigset_t's.  */
3330     if (sigsetsize != sizeof(sigset_t))
3331         goto out;
3332 
3333     if (act) {
3334         if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
3335             return -EFAULT;
3336     }
3337 
3338     ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
3339 
3340     if (!ret && oact) {
3341         if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
3342             return -EFAULT;
3343     }
3344 out:
3345     return ret;
3346 }
3347 #ifdef CONFIG_COMPAT
3348 COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
3349         const struct compat_sigaction __user *, act,
3350         struct compat_sigaction __user *, oact,
3351         compat_size_t, sigsetsize)
3352 {
3353     struct k_sigaction new_ka, old_ka;
3354     compat_sigset_t mask;
3355 #ifdef __ARCH_HAS_SA_RESTORER
3356     compat_uptr_t restorer;
3357 #endif
3358     int ret;
3359 
3360     /* XXX: Don't preclude handling different sized sigset_t's.  */
3361     if (sigsetsize != sizeof(compat_sigset_t))
3362         return -EINVAL;
3363 
3364     if (act) {
3365         compat_uptr_t handler;
3366         ret = get_user(handler, &act->sa_handler);
3367         new_ka.sa.sa_handler = compat_ptr(handler);
3368 #ifdef __ARCH_HAS_SA_RESTORER
3369         ret |= get_user(restorer, &act->sa_restorer);
3370         new_ka.sa.sa_restorer = compat_ptr(restorer);
3371 #endif
3372         ret |= copy_from_user(&mask, &act->sa_mask, sizeof(mask));
3373         ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
3374         if (ret)
3375             return -EFAULT;
3376         sigset_from_compat(&new_ka.sa.sa_mask, &mask);
3377     }
3378 
3379     ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3380     if (!ret && oact) {
3381         sigset_to_compat(&mask, &old_ka.sa.sa_mask);
3382         ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), 
3383                    &oact->sa_handler);
3384         ret |= copy_to_user(&oact->sa_mask, &mask, sizeof(mask));
3385         ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
3386 #ifdef __ARCH_HAS_SA_RESTORER
3387         ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3388                 &oact->sa_restorer);
3389 #endif
3390     }
3391     return ret;
3392 }
3393 #endif
3394 #endif /* !CONFIG_ODD_RT_SIGACTION */
3395 
3396 #ifdef CONFIG_OLD_SIGACTION
3397 SYSCALL_DEFINE3(sigaction, int, sig,
3398         const struct old_sigaction __user *, act,
3399             struct old_sigaction __user *, oact)
3400 {
3401     struct k_sigaction new_ka, old_ka;
3402     int ret;
3403 
3404     if (act) {
3405         old_sigset_t mask;
3406         if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3407             __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
3408             __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
3409             __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3410             __get_user(mask, &act->sa_mask))
3411             return -EFAULT;
3412 #ifdef __ARCH_HAS_KA_RESTORER
3413         new_ka.ka_restorer = NULL;
3414 #endif
3415         siginitset(&new_ka.sa.sa_mask, mask);
3416     }
3417 
3418     ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3419 
3420     if (!ret && oact) {
3421         if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3422             __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
3423             __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
3424             __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3425             __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3426             return -EFAULT;
3427     }
3428 
3429     return ret;
3430 }
3431 #endif
3432 #ifdef CONFIG_COMPAT_OLD_SIGACTION
3433 COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
3434         const struct compat_old_sigaction __user *, act,
3435             struct compat_old_sigaction __user *, oact)
3436 {
3437     struct k_sigaction new_ka, old_ka;
3438     int ret;
3439     compat_old_sigset_t mask;
3440     compat_uptr_t handler, restorer;
3441 
3442     if (act) {
3443         if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3444             __get_user(handler, &act->sa_handler) ||
3445             __get_user(restorer, &act->sa_restorer) ||
3446             __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3447             __get_user(mask, &act->sa_mask))
3448             return -EFAULT;
3449 
3450 #ifdef __ARCH_HAS_KA_RESTORER
3451         new_ka.ka_restorer = NULL;
3452 #endif
3453         new_ka.sa.sa_handler = compat_ptr(handler);
3454         new_ka.sa.sa_restorer = compat_ptr(restorer);
3455         siginitset(&new_ka.sa.sa_mask, mask);
3456     }
3457 
3458     ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3459 
3460     if (!ret && oact) {
3461         if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3462             __put_user(ptr_to_compat(old_ka.sa.sa_handler),
3463                    &oact->sa_handler) ||
3464             __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3465                    &oact->sa_restorer) ||
3466             __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3467             __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3468             return -EFAULT;
3469     }
3470     return ret;
3471 }
3472 #endif
3473 
3474 #ifdef CONFIG_SGETMASK_SYSCALL
3475 
3476 /*
3477  * For backwards compatibility.  Functionality superseded by sigprocmask.
3478  */
3479 SYSCALL_DEFINE0(sgetmask)
3480 {
3481     /* SMP safe */
3482     return current->blocked.sig[0];
3483 }
3484 
3485 SYSCALL_DEFINE1(ssetmask, int, newmask)
3486 {
3487     int old = current->blocked.sig[0];
3488     sigset_t newset;
3489 
3490     siginitset(&newset, newmask);
3491     set_current_blocked(&newset);
3492 
3493     return old;
3494 }
3495 #endif /* CONFIG_SGETMASK_SYSCALL */
3496 
3497 #ifdef __ARCH_WANT_SYS_SIGNAL
3498 /*
3499  * For backwards compatibility.  Functionality superseded by sigaction.
3500  */
3501 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
3502 {
3503     struct k_sigaction new_sa, old_sa;
3504     int ret;
3505 
3506     new_sa.sa.sa_handler = handler;
3507     new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
3508     sigemptyset(&new_sa.sa.sa_mask);
3509 
3510     ret = do_sigaction(sig, &new_sa, &old_sa);
3511 
3512     return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
3513 }
3514 #endif /* __ARCH_WANT_SYS_SIGNAL */
3515 
3516 #ifdef __ARCH_WANT_SYS_PAUSE
3517 
3518 SYSCALL_DEFINE0(pause)
3519 {
3520     while (!signal_pending(current)) {
3521         __set_current_state(TASK_INTERRUPTIBLE);
3522         schedule();
3523     }
3524     return -ERESTARTNOHAND;
3525 }
3526 
3527 #endif
3528 
3529 static int sigsuspend(sigset_t *set)
3530 {
3531     current->saved_sigmask = current->blocked;
3532     set_current_blocked(set);
3533 
3534     while (!signal_pending(current)) {
3535         __set_current_state(TASK_INTERRUPTIBLE);
3536         schedule();
3537     }
3538     set_restore_sigmask();
3539     return -ERESTARTNOHAND;
3540 }
3541 
3542 /**
3543  *  sys_rt_sigsuspend - replace the signal mask for a value with the
3544  *  @unewset value until a signal is received
3545  *  @unewset: new signal mask value
3546  *  @sigsetsize: size of sigset_t type
3547  */
3548 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
3549 {
3550     sigset_t newset;
3551 
3552     /* XXX: Don't preclude handling different sized sigset_t's.  */
3553     if (sigsetsize != sizeof(sigset_t))
3554         return -EINVAL;
3555 
3556     if (copy_from_user(&newset, unewset, sizeof(newset)))
3557         return -EFAULT;
3558     return sigsuspend(&newset);
3559 }
3560  
3561 #ifdef CONFIG_COMPAT
3562 COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
3563 {
3564 #ifdef __BIG_ENDIAN
3565     sigset_t newset;
3566     compat_sigset_t newset32;
3567 
3568     /* XXX: Don't preclude handling different sized sigset_t's.  */
3569     if (sigsetsize != sizeof(sigset_t))
3570         return -EINVAL;
3571 
3572     if (copy_from_user(&newset32, unewset, sizeof(compat_sigset_t)))
3573         return -EFAULT;
3574     sigset_from_compat(&newset, &newset32);
3575     return sigsuspend(&newset);
3576 #else
3577     /* on little-endian bitmaps don't care about granularity */
3578     return sys_rt_sigsuspend((sigset_t __user *)unewset, sigsetsize);
3579 #endif
3580 }
3581 #endif
3582 
3583 #ifdef CONFIG_OLD_SIGSUSPEND
3584 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
3585 {
3586     sigset_t blocked;
3587     siginitset(&blocked, mask);
3588     return sigsuspend(&blocked);
3589 }
3590 #endif
3591 #ifdef CONFIG_OLD_SIGSUSPEND3
3592 SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
3593 {
3594     sigset_t blocked;
3595     siginitset(&blocked, mask);
3596     return sigsuspend(&blocked);
3597 }
3598 #endif
3599 
3600 __weak const char *arch_vma_name(struct vm_area_struct *vma)
3601 {
3602     return NULL;
3603 }
3604 
3605 void __init signals_init(void)
3606 {
3607     /* If this check fails, the __ARCH_SI_PREAMBLE_SIZE value is wrong! */
3608     BUILD_BUG_ON(__ARCH_SI_PREAMBLE_SIZE
3609         != offsetof(struct siginfo, _sifields._pad));
3610 
3611     sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
3612 }
3613 
3614 #ifdef CONFIG_KGDB_KDB
3615 #include <linux/kdb.h>
3616 /*
3617  * kdb_send_sig_info - Allows kdb to send signals without exposing
3618  * signal internals.  This function checks if the required locks are
3619  * available before calling the main signal code, to avoid kdb
3620  * deadlocks.
3621  */
3622 void
3623 kdb_send_sig_info(struct task_struct *t, struct siginfo *info)
3624 {
3625     static struct task_struct *kdb_prev_t;
3626     int sig, new_t;
3627     if (!spin_trylock(&t->sighand->siglock)) {
3628         kdb_printf("Can't do kill command now.\n"
3629                "The sigmask lock is held somewhere else in "
3630                "kernel, try again later\n");
3631         return;
3632     }
3633     spin_unlock(&t->sighand->siglock);
3634     new_t = kdb_prev_t != t;
3635     kdb_prev_t = t;
3636     if (t->state != TASK_RUNNING && new_t) {
3637         kdb_printf("Process is not RUNNING, sending a signal from "
3638                "kdb risks deadlock\n"
3639                "on the run queue locks. "
3640                "The signal has _not_ been sent.\n"
3641                "Reissue the kill command if you want to risk "
3642                "the deadlock.\n");
3643         return;
3644     }
3645     sig = info->si_signo;
3646     if (send_sig_info(sig, info, t))
3647         kdb_printf("Fail to deliver Signal %d to process %d.\n",
3648                sig, t->pid);
3649     else
3650         kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
3651 }
3652 #endif  /* CONFIG_KGDB_KDB */