kernel/signal.c

   1 /*
   2  *  linux/kernel/signal.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *
   6  *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
   7  *
   8  *  2003-06-02  Jim Houston - Concurrent Computer Corp.
   9  *              Changes to use preallocated sigqueue structures
  10  *              to allow signals to be sent reliably.
  11  */
  12
  13 #include <linux/slab.h>
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/sched.h>
  17 #include <linux/fs.h>
  18 #include <linux/tty.h>
  19 #include <linux/binfmts.h>
  20 #include <linux/security.h>
  21 #include <linux/syscalls.h>
  22 #include <linux/ptrace.h>
  23 #include <linux/signal.h>
  24 #include <linux/signalfd.h>
  25 #include <linux/tracehook.h>
  26 #include <linux/capability.h>
  27 #include <linux/freezer.h>
  28 #include <linux/pid_namespace.h>
  29 #include <linux/nsproxy.h>
  30 #include <trace/sched.h>
  31
  32 #include <asm/param.h>
  33 #include <asm/uaccess.h>
  34 #include <asm/unistd.h>
  35 #include <asm/siginfo.h>
  36 #include "audit.h"      /* audit_signal_info() */
  37
  38 /*
  39  * SLAB caches for signal bits.
  40  */
  41
  42 static struct kmem_cache *sigqueue_cachep;
  43
  44 DEFINE_TRACE(sched_signal_send);
  45
  46 static void __user *sig_handler(struct task_struct *t, int sig)
  47 {
  48         return t->sighand->action[sig - 1].sa.sa_handler;
  49 }
  50
  51 static int sig_handler_ignored(void __user *handler, int sig)
  52 {
  53         /* Is it explicitly or implicitly ignored? */
  54         return handler == SIG_IGN ||
  55                 (handler == SIG_DFL && sig_kernel_ignore(sig));
  56 }
  57
  58 static int sig_task_ignored(struct task_struct *t, int sig)
  59 {
  60         void __user *handler;
  61
  62         handler = sig_handler(t, sig);
  63
  64         if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
  65                         handler == SIG_DFL)
  66                 return 1;
  67
  68         return sig_handler_ignored(handler, sig);
  69 }
  70
  71 static int sig_ignored(struct task_struct *t, int sig)
  72 {
  73         /*
  74          * Blocked signals are never ignored, since the
  75          * signal handler may change by the time it is
  76          * unblocked.
  77          */
  78         if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
  79                 return 0;
  80
  81         if (!sig_task_ignored(t, sig))
  82                 return 0;
  83
  84         /*
  85          * Tracers may want to know about even ignored signals.
  86          */
  87         return !tracehook_consider_ignored_signal(t, sig);
  88 }
  89
  90 /*
  91  * Re-calculate pending state from the set of locally pending
  92  * signals, globally pending signals, and blocked signals.
  93  */
  94 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
  95 {
  96         unsigned long ready;
  97         long i;
  98
  99         switch (_NSIG_WORDS) {
 100         default:
 101                 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
 102                         ready |= signal->sig[i] &~ blocked->sig[i];
 103                 break;
 104
 105         case 4: ready  = signal->sig[3] &~ blocked->sig[3];
 106                 ready |= signal->sig[2] &~ blocked->sig[2];
 107                 ready |= signal->sig[1] &~ blocked->sig[1];
 108                 ready |= signal->sig[0] &~ blocked->sig[0];
 109                 break;
 110
 111         case 2: ready  = signal->sig[1] &~ blocked->sig[1];
 112                 ready |= signal->sig[0] &~ blocked->sig[0];
 113                 break;
 114
 115         case 1: ready  = signal->sig[0] &~ blocked->sig[0];
 116         }
 117         return ready != 0;
 118 }
 119
 120 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
 121
 122 static int recalc_sigpending_tsk(struct task_struct *t)
 123 {
 124         if (t->signal->group_stop_count > 0 ||
 125             PENDING(&t->pending, &t->blocked) ||
 126             PENDING(&t->signal->shared_pending, &t->blocked)) {
 127                 set_tsk_thread_flag(t, TIF_SIGPENDING);
 128                 return 1;
 129         }
 130         /*
 131          * We must never clear the flag in another thread, or in current
 132          * when it's possible the current syscall is returning -ERESTART*.
 133          * So we don't clear it here, and only callers who know they should do.
 134          */
 135         return 0;
 136 }
 137
 138 /*
 139  * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
 140  * This is superfluous when called on current, the wakeup is a harmless no-op.
 141  */
 142 void recalc_sigpending_and_wake(struct task_struct *t)
 143 {
 144         if (recalc_sigpending_tsk(t))
 145                 signal_wake_up(t, 0);
 146 }
 147
 148 void recalc_sigpending(void)
 149 {
 150         if (unlikely(tracehook_force_sigpending()))
 151                 set_thread_flag(TIF_SIGPENDING);
 152         else if (!recalc_sigpending_tsk(current) && !freezing(current))
 153                 clear_thread_flag(TIF_SIGPENDING);
 154
 155 }
 156
 157 /* Given the mask, find the first available signal that should be serviced. */
 158
 159 int next_signal(struct sigpending *pending, sigset_t *mask)
 160 {
 161         unsigned long i, *s, *m, x;
 162         int sig = 0;
 163
 164         s = pending->signal.sig;
 165         m = mask->sig;
 166         switch (_NSIG_WORDS) {
 167         default:
 168                 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
 169                         if ((x = *s &~ *m) != 0) {
 170                                 sig = ffz(~x) + i*_NSIG_BPW + 1;
 171                                 break;
 172                         }
 173                 break;
 174
 175         case 2: if ((x = s[0] &~ m[0]) != 0)
 176                         sig = 1;
 177                 else if ((x = s[1] &~ m[1]) != 0)
 178                         sig = _NSIG_BPW + 1;
 179                 else
 180                         break;
 181                 sig += ffz(~x);
 182                 break;
 183
 184         case 1: if ((x = *s &~ *m) != 0)
 185                         sig = ffz(~x) + 1;
 186                 break;
 187         }
 188
 189         return sig;
 190 }
 191
 192 /*
 193  * allocate a new signal queue record
 194  * - this may be called without locks if and only if t == current, otherwise an
 195  *   appopriate lock must be held to stop the target task from exiting
 196  */
 197 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
 198                                          int override_rlimit)
 199 {
 200         struct sigqueue *q = NULL;
 201         struct user_struct *user;
 202
 203         /*
 204          * We won't get problems with the target's UID changing under us
 205          * because changing it requires RCU be used, and if t != current, the
 206          * caller must be holding the RCU readlock (by way of a spinlock) and
 207          * we use RCU protection here
 208          */
 209         user = get_uid(__task_cred(t)->user);
 210         atomic_inc(&user->sigpending);
 211         if (override_rlimit ||
 212             atomic_read(&user->sigpending) <=
 213                         t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
 214                 q = kmem_cache_alloc(sigqueue_cachep, flags);
 215         if (unlikely(q == NULL)) {
 216                 atomic_dec(&user->sigpending);
 217                 free_uid(user);
 218         } else {
 219                 INIT_LIST_HEAD(&q->list);
 220                 q->flags = 0;
 221                 q->user = user;
 222         }
 223
 224         return q;
 225 }
 226
 227 static void __sigqueue_free(struct sigqueue *q)
 228 {
 229         if (q->flags & SIGQUEUE_PREALLOC)
 230                 return;
 231         atomic_dec(&q->user->sigpending);
 232         free_uid(q->user);
 233         kmem_cache_free(sigqueue_cachep, q);
 234 }
 235
 236 void flush_sigqueue(struct sigpending *queue)
 237 {
 238         struct sigqueue *q;
 239
 240         sigemptyset(&queue->signal);
 241         while (!list_empty(&queue->list)) {
 242                 q = list_entry(queue->list.next, struct sigqueue , list);
 243                 list_del_init(&q->list);
 244                 __sigqueue_free(q);
 245         }
 246 }
 247
 248 /*
 249  * Flush all pending signals for a task.
 250  */
 251 void flush_signals(struct task_struct *t)
 252 {
 253         unsigned long flags;
 254
 255         spin_lock_irqsave(&t->sighand->siglock, flags);
 256         clear_tsk_thread_flag(t, TIF_SIGPENDING);
 257         flush_sigqueue(&t->pending);
 258         flush_sigqueue(&t->signal->shared_pending);
 259         spin_unlock_irqrestore(&t->sighand->siglock, flags);
 260 }
 261
 262 static void __flush_itimer_signals(struct sigpending *pending)
 263 {
 264         sigset_t signal, retain;
 265         struct sigqueue *q, *n;
 266
 267         signal = pending->signal;
 268         sigemptyset(&retain);
 269
 270         list_for_each_entry_safe(q, n, &pending->list, list) {
 271                 int sig = q->info.si_signo;
 272
 273                 if (likely(q->info.si_code != SI_TIMER)) {
 274                         sigaddset(&retain, sig);
 275                 } else {
 276                         sigdelset(&signal, sig);
 277                         list_del_init(&q->list);
 278                         __sigqueue_free(q);
 279                 }
 280         }
 281
 282         sigorsets(&pending->signal, &signal, &retain);
 283 }
 284
 285 void flush_itimer_signals(void)
 286 {
 287         struct task_struct *tsk = current;
 288         unsigned long flags;
 289
 290         spin_lock_irqsave(&tsk->sighand->siglock, flags);
 291         __flush_itimer_signals(&tsk->pending);
 292         __flush_itimer_signals(&tsk->signal->shared_pending);
 293         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
 294 }
 295
 296 void ignore_signals(struct task_struct *t)
 297 {
 298         int i;
 299
 300         for (i = 0; i < _NSIG; ++i)
 301                 t->sighand->action[i].sa.sa_handler = SIG_IGN;
 302
 303         flush_signals(t);
 304 }
 305
 306 /*
 307  * Flush all handlers for a task.
 308  */
 309
 310 void
 311 flush_signal_handlers(struct task_struct *t, int force_default)
 312 {
 313         int i;
 314         struct k_sigaction *ka = &t->sighand->action[0];
 315         for (i = _NSIG ; i != 0 ; i--) {
 316                 if (force_default || ka->sa.sa_handler != SIG_IGN)
 317                         ka->sa.sa_handler = SIG_DFL;
 318                 ka->sa.sa_flags = 0;
 319                 sigemptyset(&ka->sa.sa_mask);
 320                 ka++;
 321         }
 322 }
 323
 324 int unhandled_signal(struct task_struct *tsk, int sig)
 325 {
 326         void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
 327         if (is_global_init(tsk))
 328                 return 1;
 329         if (handler != SIG_IGN && handler != SIG_DFL)
 330                 return 0;
 331         return !tracehook_consider_fatal_signal(tsk, sig);
 332 }
 333
 334
 335 /* Notify the system that a driver wants to block all signals for this
 336  * process, and wants to be notified if any signals at all were to be
 337  * sent/acted upon.  If the notifier routine returns non-zero, then the
 338  * signal will be acted upon after all.  If the notifier routine returns 0,
 339  * then then signal will be blocked.  Only one block per process is
 340  * allowed.  priv is a pointer to private data that the notifier routine
 341  * can use to determine if the signal should be blocked or not.  */
 342
 343 void
 344 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
 345 {
 346         unsigned long flags;
 347
 348         spin_lock_irqsave(&current->sighand->siglock, flags);
 349         current->notifier_mask = mask;
 350         current->notifier_data = priv;
 351         current->notifier = notifier;
 352         spin_unlock_irqrestore(&current->sighand->siglock, flags);
 353 }
 354
 355 /* Notify the system that blocking has ended. */
 356
 357 void
 358 unblock_all_signals(void)
 359 {
 360         unsigned long flags;
 361
 362         spin_lock_irqsave(&current->sighand->siglock, flags);
 363         current->notifier = NULL;
 364         current->notifier_data = NULL;
 365         recalc_sigpending();
 366         spin_unlock_irqrestore(&current->sighand->siglock, flags);
 367 }
 368
 369 static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
 370 {
 371         struct sigqueue *q, *first = NULL;
 372
 373         /*
 374          * Collect the siginfo appropriate to this signal.  Check if
 375          * there is another siginfo for the same signal.
 376         */
 377         list_for_each_entry(q, &list->list, list) {
 378                 if (q->info.si_signo == sig) {
 379                         if (first)
 380                                 goto still_pending;
 381                         first = q;
 382                 }
 383         }
 384
 385         sigdelset(&list->signal, sig);
 386
 387         if (first) {
 388 still_pending:
 389                 list_del_init(&first->list);
 390                 copy_siginfo(info, &first->info);
 391                 __sigqueue_free(first);
 392         } else {
 393                 /* Ok, it wasn't in the queue.  This must be
 394                    a fast-pathed signal or we must have been
 395                    out of queue space.  So zero out the info.
 396                  */
 397                 info->si_signo = sig;
 398                 info->si_errno = 0;
 399                 info->si_code = 0;
 400                 info->si_pid = 0;
 401                 info->si_uid = 0;
 402         }
 403 }
 404
 405 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
 406                         siginfo_t *info)
 407 {
 408         int sig = next_signal(pending, mask);
 409
 410         if (sig) {
 411                 if (current->notifier) {
 412                         if (sigismember(current->notifier_mask, sig)) {
 413                                 if (!(current->notifier)(current->notifier_data)) {
 414                                         clear_thread_flag(TIF_SIGPENDING);
 415                                         return 0;
 416                                 }
 417                         }
 418                 }
 419
 420                 collect_signal(sig, pending, info);
 421         }
 422
 423         return sig;
 424 }
 425
 426 /*
 427  * Dequeue a signal and return the element to the caller, which is
 428  * expected to free it.
 429  *
 430  * All callers have to hold the siglock.
 431  */
 432 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
 433 {
 434         int signr;
 435
 436         /* We only dequeue private signals from ourselves, we don't let
 437          * signalfd steal them
 438          */
 439         signr = __dequeue_signal(&tsk->pending, mask, info);
 440         if (!signr) {
 441                 signr = __dequeue_signal(&tsk->signal->shared_pending,
 442                                          mask, info);
 443                 /*
 444                  * itimer signal ?
 445                  *
 446                  * itimers are process shared and we restart periodic
 447                  * itimers in the signal delivery path to prevent DoS
 448                  * attacks in the high resolution timer case. This is
 449                  * compliant with the old way of self restarting
 450                  * itimers, as the SIGALRM is a legacy signal and only
 451                  * queued once. Changing the restart behaviour to
 452                  * restart the timer in the signal dequeue path is
 453                  * reducing the timer noise on heavy loaded !highres
 454                  * systems too.
 455                  */
 456                 if (unlikely(signr == SIGALRM)) {
 457                         struct hrtimer *tmr = &tsk->signal->real_timer;
 458
 459                         if (!hrtimer_is_queued(tmr) &&
 460                             tsk->signal->it_real_incr.tv64 != 0) {
 461                                 hrtimer_forward(tmr, tmr->base->get_time(),
 462                                                 tsk->signal->it_real_incr);
 463                                 hrtimer_restart(tmr);
 464                         }
 465                 }
 466         }
 467
 468         recalc_sigpending();
 469         if (!signr)
 470                 return 0;
 471
 472         if (unlikely(sig_kernel_stop(signr))) {
 473                 /*
 474                  * Set a marker that we have dequeued a stop signal.  Our
 475                  * caller might release the siglock and then the pending
 476                  * stop signal it is about to process is no longer in the
 477                  * pending bitmasks, but must still be cleared by a SIGCONT
 478                  * (and overruled by a SIGKILL).  So those cases clear this
 479                  * shared flag after we've set it.  Note that this flag may
 480                  * remain set after the signal we return is ignored or
 481                  * handled.  That doesn't matter because its only purpose
 482                  * is to alert stop-signal processing code when another
 483                  * processor has come along and cleared the flag.
 484                  */
 485                 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
 486         }
 487         if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
 488                 /*
 489                  * Release the siglock to ensure proper locking order
 490                  * of timer locks outside of siglocks.  Note, we leave
 491                  * irqs disabled here, since the posix-timers code is
 492                  * about to disable them again anyway.
 493                  */
 494                 spin_unlock(&tsk->sighand->siglock);
 495                 do_schedule_next_timer(info);
 496                 spin_lock(&tsk->sighand->siglock);
 497         }
 498         return signr;
 499 }
 500
 501 /*
 502  * Tell a process that it has a new active signal..
 503  *
 504  * NOTE! we rely on the previous spin_lock to
 505  * lock interrupts for us! We can only be called with
 506  * "siglock" held, and the local interrupt must
 507  * have been disabled when that got acquired!
 508  *
 509  * No need to set need_resched since signal event passing
 510  * goes through ->blocked
 511  */
 512 void signal_wake_up(struct task_struct *t, int resume)
 513 {
 514         unsigned int mask;
 515
 516         set_tsk_thread_flag(t, TIF_SIGPENDING);
 517
 518         /*
 519          * For SIGKILL, we want to wake it up in the stopped/traced/killable
 520          * case. We don't check t->state here because there is a race with it
 521          * executing another processor and just now entering stopped state.
 522          * By using wake_up_state, we ensure the process will wake up and
 523          * handle its death signal.
 524          */
 525         mask = TASK_INTERRUPTIBLE;
 526         if (resume)
 527                 mask |= TASK_WAKEKILL;
 528         if (!wake_up_state(t, mask))
 529                 kick_process(t);
 530 }
 531
 532 /*
 533  * Remove signals in mask from the pending set and queue.
 534  * Returns 1 if any signals were found.
 535  *
 536  * All callers must be holding the siglock.
 537  *
 538  * This version takes a sigset mask and looks at all signals,
 539  * not just those in the first mask word.
 540  */
 541 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
 542 {
 543         struct sigqueue *q, *n;
 544         sigset_t m;
 545
 546         sigandsets(&m, mask, &s->signal);
 547         if (sigisemptyset(&m))
 548                 return 0;
 549
 550         signandsets(&s->signal, &s->signal, mask);
 551         list_for_each_entry_safe(q, n, &s->list, list) {
 552                 if (sigismember(mask, q->info.si_signo)) {
 553                         list_del_init(&q->list);
 554                         __sigqueue_free(q);
 555                 }
 556         }
 557         return 1;
 558 }
 559 /*
 560  * Remove signals in mask from the pending set and queue.
 561  * Returns 1 if any signals were found.
 562  *
 563  * All callers must be holding the siglock.
 564  */
 565 static int rm_from_queue(unsigned long mask, struct sigpending *s)
 566 {
 567         struct sigqueue *q, *n;
 568
 569         if (!sigtestsetmask(&s->signal, mask))
 570                 return 0;
 571
 572         sigdelsetmask(&s->signal, mask);
 573         list_for_each_entry_safe(q, n, &s->list, list) {
 574                 if (q->info.si_signo < SIGRTMIN &&
 575                     (mask & sigmask(q->info.si_signo))) {
 576                         list_del_init(&q->list);
 577                         __sigqueue_free(q);
 578                 }
 579         }
 580         return 1;
 581 }
 582
 583 /*
 584  * Bad permissions for sending the signal
 585  * - the caller must hold at least the RCU read lock
 586  */
 587 static int check_kill_permission(int sig, struct siginfo *info,
 588                                  struct task_struct *t)
 589 {
 590         const struct cred *cred = current_cred(), *tcred;
 591         struct pid *sid;
 592         int error;
 593
 594         if (!valid_signal(sig))
 595                 return -EINVAL;
 596
 597         if (info != SEND_SIG_NOINFO && (is_si_special(info) || SI_FROMKERNEL(info)))
 598                 return 0;
 599
 600         error = audit_signal_info(sig, t); /* Let audit system see the signal */
 601         if (error)
 602                 return error;
 603
 604         tcred = __task_cred(t);
 605         if ((cred->euid ^ tcred->suid) &&
 606             (cred->euid ^ tcred->uid) &&
 607             (cred->uid  ^ tcred->suid) &&
 608             (cred->uid  ^ tcred->uid) &&
 609             !capable(CAP_KILL)) {
 610                 switch (sig) {
 611                 case SIGCONT:
 612                         sid = task_session(t);
 613                         /*
 614                          * We don't return the error if sid == NULL. The
 615                          * task was unhashed, the caller must notice this.
 616                          */
 617                         if (!sid || sid == task_session(current))
 618                                 break;
 619                 default:
 620                         return -EPERM;
 621                 }
 622         }
 623
 624         return security_task_kill(t, info, sig, 0);
 625 }
 626
 627 /*
 628  * Handle magic process-wide effects of stop/continue signals. Unlike
 629  * the signal actions, these happen immediately at signal-generation
 630  * time regardless of blocking, ignoring, or handling.  This does the
 631  * actual continuing for SIGCONT, but not the actual stopping for stop
 632  * signals. The process stop is done as a signal action for SIG_DFL.
 633  *
 634  * Returns true if the signal should be actually delivered, otherwise
 635  * it should be dropped.
 636  */
 637 static int prepare_signal(int sig, struct task_struct *p)
 638 {
 639         struct signal_struct *signal = p->signal;
 640         struct task_struct *t;
 641
 642         if (unlikely(signal->flags & SIGNAL_GROUP_EXIT)) {
 643                 /*
 644                  * The process is in the middle of dying, nothing to do.
 645                  */
 646         } else if (sig_kernel_stop(sig)) {
 647                 /*
 648                  * This is a stop signal.  Remove SIGCONT from all queues.
 649                  */
 650                 rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
 651                 t = p;
 652                 do {
 653                         rm_from_queue(sigmask(SIGCONT), &t->pending);
 654                 } while_each_thread(p, t);
 655         } else if (sig == SIGCONT) {
 656                 unsigned int why;
 657                 /*
 658                  * Remove all stop signals from all queues,
 659                  * and wake all threads.
 660                  */
 661                 rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
 662                 t = p;
 663                 do {
 664                         unsigned int state;
 665                         rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
 666                         /*
 667                          * If there is a handler for SIGCONT, we must make
 668                          * sure that no thread returns to user mode before
 669                          * we post the signal, in case it was the only
 670                          * thread eligible to run the signal handler--then
 671                          * it must not do anything between resuming and
 672                          * running the handler.  With the TIF_SIGPENDING
 673                          * flag set, the thread will pause and acquire the
 674                          * siglock that we hold now and until we've queued
 675                          * the pending signal.
 676                          *
 677                          * Wake up the stopped thread _after_ setting
 678                          * TIF_SIGPENDING
 679                          */
 680                         state = __TASK_STOPPED;
 681                         if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
 682                                 set_tsk_thread_flag(t, TIF_SIGPENDING);
 683                                 state |= TASK_INTERRUPTIBLE;
 684                         }
 685                         wake_up_state(t, state);
 686                 } while_each_thread(p, t);
 687
 688                 /*
 689                  * Notify the parent with CLD_CONTINUED if we were stopped.
 690                  *
 691                  * If we were in the middle of a group stop, we pretend it
 692                  * was already finished, and then continued. Since SIGCHLD
 693                  * doesn't queue we report only CLD_STOPPED, as if the next
 694                  * CLD_CONTINUED was dropped.
 695                  */
 696                 why = 0;
 697                 if (signal->flags & SIGNAL_STOP_STOPPED)
 698                         why |= SIGNAL_CLD_CONTINUED;
 699                 else if (signal->group_stop_count)
 700                         why |= SIGNAL_CLD_STOPPED;
 701
 702                 if (why) {
 703                         /*
 704                          * The first thread which returns from finish_stop()
 705                          * will take ->siglock, notice SIGNAL_CLD_MASK, and
 706                          * notify its parent. See get_signal_to_deliver().
 707                          */
 708                         signal->flags = why | SIGNAL_STOP_CONTINUED;
 709                         signal->group_stop_count = 0;
 710                         signal->group_exit_code = 0;
 711                 } else {
 712                         /*
 713                          * We are not stopped, but there could be a stop
 714                          * signal in the middle of being processed after
 715                          * being removed from the queue.  Clear that too.
 716                          */
 717                         signal->flags &= ~SIGNAL_STOP_DEQUEUED;
 718                 }
 719         }
 720
 721         return !sig_ignored(p, sig);
 722 }
 723
 724 /*
 725  * Test if P wants to take SIG.  After we've checked all threads with this,
 726  * it's equivalent to finding no threads not blocking SIG.  Any threads not
 727  * blocking SIG were ruled out because they are not running and already
 728  * have pending signals.  Such threads will dequeue from the shared queue
 729  * as soon as they're available, so putting the signal on the shared queue
 730  * will be equivalent to sending it to one such thread.
 731  */
 732 static inline int wants_signal(int sig, struct task_struct *p)
 733 {
 734         if (sigismember(&p->blocked, sig))
 735                 return 0;
 736         if (p->flags & PF_EXITING)
 737                 return 0;
 738         if (sig == SIGKILL)
 739                 return 1;
 740         if (task_is_stopped_or_traced(p))
 741                 return 0;
 742         return task_curr(p) || !signal_pending(p);
 743 }
 744
 745 static void complete_signal(int sig, struct task_struct *p, int group)
 746 {
 747         struct signal_struct *signal = p->signal;
 748         struct task_struct *t;
 749
 750         /*
 751          * Now find a thread we can wake up to take the signal off the queue.
 752          *
 753          * If the main thread wants the signal, it gets first crack.
 754          * Probably the least surprising to the average bear.
 755          */
 756         if (wants_signal(sig, p))
 757                 t = p;
 758         else if (!group || thread_group_empty(p))
 759                 /*
 760                  * There is just one thread and it does not need to be woken.
 761                  * It will dequeue unblocked signals before it runs again.
 762                  */
 763                 return;
 764         else {
 765                 /*
 766                  * Otherwise try to find a suitable thread.
 767                  */
 768                 t = signal->curr_target;
 769                 while (!wants_signal(sig, t)) {
 770                         t = next_thread(t);
 771                         if (t == signal->curr_target)
 772                                 /*
 773                                  * No thread needs to be woken.
 774                                  * Any eligible threads will see
 775                                  * the signal in the queue soon.
 776                                  */
 777                                 return;
 778                 }
 779                 signal->curr_target = t;
 780         }
 781
 782         /*
 783          * Found a killable thread.  If the signal will be fatal,
 784          * then start taking the whole group down immediately.
 785          */
 786         if (sig_fatal(p, sig) &&
 787             !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
 788             !sigismember(&t->real_blocked, sig) &&
 789             (sig == SIGKILL ||
 790              !tracehook_consider_fatal_signal(t, sig))) {
 791                 /*
 792                  * This signal will be fatal to the whole group.
 793                  */
 794                 if (!sig_kernel_coredump(sig)) {
 795                         /*
 796                          * Start a group exit and wake everybody up.
 797                          * This way we don't have other threads
 798                          * running and doing things after a slower
 799                          * thread has the fatal signal pending.
 800                          */
 801                         signal->flags = SIGNAL_GROUP_EXIT;
 802                         signal->group_exit_code = sig;
 803                         signal->group_stop_count = 0;
 804                         t = p;
 805                         do {
 806                                 sigaddset(&t->pending.signal, SIGKILL);
 807                                 signal_wake_up(t, 1);
 808                         } while_each_thread(p, t);
 809                         return;
 810                 }
 811         }
 812
 813         /*
 814          * The signal is already in the shared-pending queue.
 815          * Tell the chosen thread to wake up and dequeue it.
 816          */
 817         signal_wake_up(t, sig == SIGKILL);
 818         return;
 819 }
 820
 821 static inline int legacy_queue(struct sigpending *signals, int sig)
 822 {
 823         return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
 824 }
 825
 826 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
 827                         int group)
 828 {
 829         struct sigpending *pending;
 830         struct sigqueue *q;
 831
 832         trace_sched_signal_send(sig, t);
 833
 834         assert_spin_locked(&t->sighand->siglock);
 835         if (!prepare_signal(sig, t))
 836                 return 0;
 837
 838         pending = group ? &t->signal->shared_pending : &t->pending;
 839         /*
 840          * Short-circuit ignored signals and support queuing
 841          * exactly one non-rt signal, so that we can get more
 842          * detailed information about the cause of the signal.
 843          */
 844         if (legacy_queue(pending, sig))
 845                 return 0;
 846         /*
 847          * fast-pathed signals for kernel-internal things like SIGSTOP
 848          * or SIGKILL.
 849          */
 850         if (info == SEND_SIG_FORCED)
 851                 goto out_set;
 852
 853         /* Real-time signals must be queued if sent by sigqueue, or
 854            some other real-time mechanism.  It is implementation
 855            defined whether kill() does so.  We attempt to do so, on
 856            the principle of least surprise, but since kill is not
 857            allowed to fail with EAGAIN when low on memory we just
 858            make sure at least one signal gets delivered and don't
 859            pass on the info struct.  */
 860
 861         q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
 862                                              (is_si_special(info) ||
 863                                               info->si_code >= 0)));
 864         if (q) {
 865                 list_add_tail(&q->list, &pending->list);
 866                 switch ((unsigned long) info) {
 867                 case (unsigned long) SEND_SIG_NOINFO:
 868                         q->info.si_signo = sig;
 869                         q->info.si_errno = 0;
 870                         q->info.si_code = SI_USER;
 871                         q->info.si_pid = task_tgid_nr_ns(current,
 872                                                         task_active_pid_ns(t));
 873                         q->info.si_uid = current_uid();
 874                         break;
 875                 case (unsigned long) SEND_SIG_PRIV:
 876                         q->info.si_signo = sig;
 877                         q->info.si_errno = 0;
 878                         q->info.si_code = SI_KERNEL;
 879                         q->info.si_pid = 0;
 880                         q->info.si_uid = 0;
 881                         break;
 882                 default:
 883                         copy_siginfo(&q->info, info);
 884                         break;
 885                 }
 886         } else if (!is_si_special(info)) {
 887                 if (sig >= SIGRTMIN && info->si_code != SI_USER)
 888                 /*
 889                  * Queue overflow, abort.  We may abort if the signal was rt
 890                  * and sent by user using something other than kill().
 891                  */
 892                         return -EAGAIN;
 893         }
 894
 895 out_set:
 896         signalfd_notify(t, sig);
 897         sigaddset(&pending->signal, sig);
 898         complete_signal(sig, t, group);
 899         return 0;
 900 }
 901
 902 int print_fatal_signals;
 903
 904 static void print_fatal_signal(struct pt_regs *regs, int signr)
 905 {
 906         printk("%s/%d: potentially unexpected fatal signal %d.\n",
 907                 current->comm, task_pid_nr(current), signr);
 908
 909 #if defined(__i386__) && !defined(__arch_um__)
 910         printk("code at %08lx: ", regs->ip);
 911         {
 912                 int i;
 913                 for (i = 0; i < 16; i++) {
 914                         unsigned char insn;
 915
 916                         __get_user(insn, (unsigned char *)(regs->ip + i));
 917                         printk("%02x ", insn);
 918                 }
 919         }
 920 #endif
 921         printk("\n");
 922         preempt_disable();
 923         show_regs(regs);
 924         preempt_enable();
 925 }
 926
 927 static int __init setup_print_fatal_signals(char *str)
 928 {
 929         get_option (&str, &print_fatal_signals);
 930
 931         return 1;
 932 }
 933
 934 __setup("print-fatal-signals=", setup_print_fatal_signals);
 935
 936 int
 937 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
 938 {
 939         return send_signal(sig, info, p, 1);
 940 }
 941
 942 static int
 943 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
 944 {
 945         return send_signal(sig, info, t, 0);
 946 }
 947
 948 /*
 949  * Force a signal that the process can't ignore: if necessary
 950  * we unblock the signal and change any SIG_IGN to SIG_DFL.
 951  *
 952  * Note: If we unblock the signal, we always reset it to SIG_DFL,
 953  * since we do not want to have a signal handler that was blocked
 954  * be invoked when user space had explicitly blocked it.
 955  *
 956  * We don't want to have recursive SIGSEGV's etc, for example,
 957  * that is why we also clear SIGNAL_UNKILLABLE.
 958  */
 959 int
 960 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
 961 {
 962         unsigned long int flags;
 963         int ret, blocked, ignored;
 964         struct k_sigaction *action;
 965
 966         spin_lock_irqsave(&t->sighand->siglock, flags);
 967         action = &t->sighand->action[sig-1];
 968         ignored = action->sa.sa_handler == SIG_IGN;
 969         blocked = sigismember(&t->blocked, sig);
 970         if (blocked || ignored) {
 971                 action->sa.sa_handler = SIG_DFL;
 972                 if (blocked) {
 973                         sigdelset(&t->blocked, sig);
 974                         recalc_sigpending_and_wake(t);
 975                 }
 976         }
 977         if (action->sa.sa_handler == SIG_DFL)
 978                 t->signal->flags &= ~SIGNAL_UNKILLABLE;
 979         ret = specific_send_sig_info(sig, info, t);
 980         spin_unlock_irqrestore(&t->sighand->siglock, flags);
 981
 982         return ret;
 983 }
 984
 985 void
 986 force_sig_specific(int sig, struct task_struct *t)
 987 {
 988         force_sig_info(sig, SEND_SIG_FORCED, t);
 989 }
 990
 991 /*
 992  * Nuke all other threads in the group.
 993  */
 994 void zap_other_threads(struct task_struct *p)
 995 {
 996         struct task_struct *t;
 997
 998         p->signal->group_stop_count = 0;
 999
1000         for (t = next_thread(p); t != p; t = next_thread(t)) {
1001                 /*
1002                  * Don't bother with already dead threads
1003                  */
1004                 if (t->exit_state)
1005                         continue;
1006
1007                 /* SIGKILL will be handled before any pending SIGSTOP */
1008                 sigaddset(&t->pending.signal, SIGKILL);
1009                 signal_wake_up(t, 1);
1010         }
1011 }
1012
1013 int __fatal_signal_pending(struct task_struct *tsk)
1014 {
1015         return sigismember(&tsk->pending.signal, SIGKILL);
1016 }
1017 EXPORT_SYMBOL(__fatal_signal_pending);
1018
1019 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1020 {
1021         struct sighand_struct *sighand;
1022
1023         rcu_read_lock();
1024         for (;;) {
1025                 sighand = rcu_dereference(tsk->sighand);
1026                 if (unlikely(sighand == NULL))
1027                         break;
1028
1029                 spin_lock_irqsave(&sighand->siglock, *flags);
1030                 if (likely(sighand == tsk->sighand))
1031                         break;
1032                 spin_unlock_irqrestore(&sighand->siglock, *flags);
1033         }
1034         rcu_read_unlock();
1035
1036         return sighand;
1037 }
1038
1039 /*
1040  * send signal info to all the members of a group
1041  * - the caller must hold the RCU read lock at least
1042  */
1043 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1044 {
1045         unsigned long flags;
1046         int ret;
1047
1048         ret = check_kill_permission(sig, info, p);
1049
1050         if (!ret && sig) {
1051                 ret = -ESRCH;
1052                 if (lock_task_sighand(p, &flags)) {
1053                         ret = __group_send_sig_info(sig, info, p);
1054                         unlock_task_sighand(p, &flags);
1055                 }
1056         }
1057
1058         return ret;
1059 }
1060
1061 /*
1062  * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1063  * control characters do (^C, ^Z etc)
1064  * - the caller must hold at least a readlock on tasklist_lock
1065  */
1066 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1067 {
1068         struct task_struct *p = NULL;
1069         int retval, success;
1070
1071         success = 0;
1072         retval = -ESRCH;
1073         do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1074                 int err = group_send_sig_info(sig, info, p);
1075                 success |= !err;
1076                 retval = err;
1077         } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1078         return success ? 0 : retval;
1079 }
1080
1081 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1082 {
1083         int error = -ESRCH;
1084         struct task_struct *p;
1085
1086         rcu_read_lock();
1087 retry:
1088         p = pid_task(pid, PIDTYPE_PID);
1089         if (p) {
1090                 error = group_send_sig_info(sig, info, p);
1091                 if (unlikely(error == -ESRCH))
1092                         /*
1093                          * The task was unhashed in between, try again.
1094                          * If it is dead, pid_task() will return NULL,
1095                          * if we race with de_thread() it will find the
1096                          * new leader.
1097                          */
1098                         goto retry;
1099         }
1100         rcu_read_unlock();
1101
1102         return error;
1103 }
1104
1105 int
1106 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1107 {
1108         int error;
1109         rcu_read_lock();
1110         error = kill_pid_info(sig, info, find_vpid(pid));
1111         rcu_read_unlock();
1112         return error;
1113 }
1114
1115 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1116 int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
1117                       uid_t uid, uid_t euid, u32 secid)
1118 {
1119         int ret = -EINVAL;
1120         struct task_struct *p;
1121         const struct cred *pcred;
1122
1123         if (!valid_signal(sig))
1124                 return ret;
1125
1126         read_lock(&tasklist_lock);
1127         p = pid_task(pid, PIDTYPE_PID);
1128         if (!p) {
1129                 ret = -ESRCH;
1130                 goto out_unlock;
1131         }
1132         pcred = __task_cred(p);
1133         if ((info == SEND_SIG_NOINFO ||
1134              (!is_si_special(info) && SI_FROMUSER(info))) &&
1135             euid != pcred->suid && euid != pcred->uid &&
1136             uid  != pcred->suid && uid  != pcred->uid) {
1137                 ret = -EPERM;
1138                 goto out_unlock;
1139         }
1140         ret = security_task_kill(p, info, sig, secid);
1141         if (ret)
1142                 goto out_unlock;
1143         if (sig && p->sighand) {
1144                 unsigned long flags;
1145                 spin_lock_irqsave(&p->sighand->siglock, flags);
1146                 ret = __group_send_sig_info(sig, info, p);
1147                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1148         }
1149 out_unlock:
1150         read_unlock(&tasklist_lock);
1151         return ret;
1152 }
1153 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
1154
1155 /*
1156  * kill_something_info() interprets pid in interesting ways just like kill(2).
1157  *
1158  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1159  * is probably wrong.  Should make it like BSD or SYSV.
1160  */
1161
1162 static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
1163 {
1164         int ret;
1165
1166         if (pid > 0) {
1167                 rcu_read_lock();
1168                 ret = kill_pid_info(sig, info, find_vpid(pid));
1169                 rcu_read_unlock();
1170                 return ret;
1171         }
1172
1173         read_lock(&tasklist_lock);
1174         if (pid != -1) {
1175                 ret = __kill_pgrp_info(sig, info,
1176                                 pid ? find_vpid(-pid) : task_pgrp(current));
1177         } else {
1178                 int retval = 0, count = 0;
1179                 struct task_struct * p;
1180
1181                 for_each_process(p) {
1182                         if (task_pid_vnr(p) > 1 &&
1183                                         !same_thread_group(p, current)) {
1184                                 int err = group_send_sig_info(sig, info, p);
1185                                 ++count;
1186                                 if (err != -EPERM)
1187                                         retval = err;
1188                         }
1189                 }
1190                 ret = count ? retval : -ESRCH;
1191         }
1192         read_unlock(&tasklist_lock);
1193
1194         return ret;
1195 }
1196
1197 /*
1198  * These are for backward compatibility with the rest of the kernel source.
1199  */
1200
1201 /*
1202  * The caller must ensure the task can't exit.
1203  */
1204 int
1205 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1206 {
1207         int ret;
1208         unsigned long flags;
1209
1210         /*
1211          * Make sure legacy kernel users don't send in bad values
1212          * (normal paths check this in check_kill_permission).
1213          */
1214         if (!valid_signal(sig))
1215                 return -EINVAL;
1216
1217         spin_lock_irqsave(&p->sighand->siglock, flags);
1218         ret = specific_send_sig_info(sig, info, p);
1219         spin_unlock_irqrestore(&p->sighand->siglock, flags);
1220         return ret;
1221 }
1222
1223 #define __si_special(priv) \
1224         ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1225
1226 int
1227 send_sig(int sig, struct task_struct *p, int priv)
1228 {
1229         return send_sig_info(sig, __si_special(priv), p);
1230 }
1231
1232 void
1233 force_sig(int sig, struct task_struct *p)
1234 {
1235         force_sig_info(sig, SEND_SIG_PRIV, p);
1236 }
1237
1238 /*
1239  * When things go south during signal handling, we
1240  * will force a SIGSEGV. And if the signal that caused
1241  * the problem was already a SIGSEGV, we'll want to
1242  * make sure we don't even try to deliver the signal..
1243  */
1244 int
1245 force_sigsegv(int sig, struct task_struct *p)
1246 {
1247         if (sig == SIGSEGV) {
1248                 unsigned long flags;
1249                 spin_lock_irqsave(&p->sighand->siglock, flags);
1250                 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1251                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1252         }
1253         force_sig(SIGSEGV, p);
1254         return 0;
1255 }
1256
1257 int kill_pgrp(struct pid *pid, int sig, int priv)
1258 {
1259         int ret;
1260
1261         read_lock(&tasklist_lock);
1262         ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1263         read_unlock(&tasklist_lock);
1264
1265         return ret;
1266 }
1267 EXPORT_SYMBOL(kill_pgrp);
1268
1269 int kill_pid(struct pid *pid, int sig, int priv)
1270 {
1271         return kill_pid_info(sig, __si_special(priv), pid);
1272 }
1273 EXPORT_SYMBOL(kill_pid);
1274
1275 /*
1276  * These functions support sending signals using preallocated sigqueue
1277  * structures.  This is needed "because realtime applications cannot
1278  * afford to lose notifications of asynchronous events, like timer
1279  * expirations or I/O completions".  In the case of Posix Timers
1280  * we allocate the sigqueue structure from the timer_create.  If this
1281  * allocation fails we are able to report the failure to the application
1282  * with an EAGAIN error.
1283  */
1284
1285 struct sigqueue *sigqueue_alloc(void)
1286 {
1287         struct sigqueue *q;
1288
1289         if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1290                 q->flags |= SIGQUEUE_PREALLOC;
1291         return(q);
1292 }
1293
1294 void sigqueue_free(struct sigqueue *q)
1295 {
1296         unsigned long flags;
1297         spinlock_t *lock = &current->sighand->siglock;
1298
1299         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1300         /*
1301          * We must hold ->siglock while testing q->list
1302          * to serialize with collect_signal() or with
1303          * __exit_signal()->flush_sigqueue().
1304          */
1305         spin_lock_irqsave(lock, flags);
1306         q->flags &= ~SIGQUEUE_PREALLOC;
1307         /*
1308          * If it is queued it will be freed when dequeued,
1309          * like the "regular" sigqueue.
1310          */
1311         if (!list_empty(&q->list))
1312                 q = NULL;
1313         spin_unlock_irqrestore(lock, flags);
1314
1315         if (q)
1316                 __sigqueue_free(q);
1317 }
1318
1319 int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1320 {
1321         int sig = q->info.si_signo;
1322         struct sigpending *pending;
1323         unsigned long flags;
1324         int ret;
1325
1326         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1327
1328         ret = -1;
1329         if (!likely(lock_task_sighand(t, &flags)))
1330                 goto ret;
1331
1332         ret = 1; /* the signal is ignored */
1333         if (!prepare_signal(sig, t))
1334                 goto out;
1335
1336         ret = 0;
1337         if (unlikely(!list_empty(&q->list))) {
1338                 /*
1339                  * If an SI_TIMER entry is already queue just increment
1340                  * the overrun count.
1341                  */
1342                 BUG_ON(q->info.si_code != SI_TIMER);
1343                 q->info.si_overrun++;
1344                 goto out;
1345         }
1346         q->info.si_overrun = 0;
1347
1348         signalfd_notify(t, sig);
1349         pending = group ? &t->signal->shared_pending : &t->pending;
1350         list_add_tail(&q->list, &pending->list);
1351         sigaddset(&pending->signal, sig);
1352         complete_signal(sig, t, group);
1353 out:
1354         unlock_task_sighand(t, &flags);
1355 ret:
1356         return ret;
1357 }
1358
1359 /*
1360  * Wake up any threads in the parent blocked in wait* syscalls.
1361  */
1362 static inline void __wake_up_parent(struct task_struct *p,
1363                                     struct task_struct *parent)
1364 {
1365         wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1366 }
1367
1368 /*
1369  * Let a parent know about the death of a child.
1370  * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1371  *
1372  * Returns -1 if our parent ignored us and so we've switched to
1373  * self-reaping, or else @sig.
1374  */
1375 int do_notify_parent(struct task_struct *tsk, int sig)
1376 {
1377         struct siginfo info;
1378         unsigned long flags;
1379         struct sighand_struct *psig;
1380         int ret = sig;
1381
1382         BUG_ON(sig == -1);
1383
1384         /* do_notify_parent_cldstop should have been called instead.  */
1385         BUG_ON(task_is_stopped_or_traced(tsk));
1386
1387         BUG_ON(!tsk->ptrace &&
1388                (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1389
1390         info.si_signo = sig;
1391         info.si_errno = 0;
1392         /*
1393          * we are under tasklist_lock here so our parent is tied to
1394          * us and cannot exit and release its namespace.
1395          *
1396          * the only it can is to switch its nsproxy with sys_unshare,
1397          * bu uncharing pid namespaces is not allowed, so we'll always
1398          * see relevant namespace
1399          *
1400          * write_lock() currently calls preempt_disable() which is the
1401          * same as rcu_read_lock(), but according to Oleg, this is not
1402          * correct to rely on this
1403          */
1404         rcu_read_lock();
1405         info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1406         info.si_uid = __task_cred(tsk)->uid;
1407         rcu_read_unlock();
1408
1409         info.si_utime = cputime_to_clock_t(cputime_add(tsk->utime,
1410                                 tsk->signal->utime));
1411         info.si_stime = cputime_to_clock_t(cputime_add(tsk->stime,
1412                                 tsk->signal->stime));
1413
1414         info.si_status = tsk->exit_code & 0x7f;
1415         if (tsk->exit_code & 0x80)
1416                 info.si_code = CLD_DUMPED;
1417         else if (tsk->exit_code & 0x7f)
1418                 info.si_code = CLD_KILLED;
1419         else {
1420                 info.si_code = CLD_EXITED;
1421                 info.si_status = tsk->exit_code >> 8;
1422         }
1423
1424         psig = tsk->parent->sighand;
1425         spin_lock_irqsave(&psig->siglock, flags);
1426         if (!tsk->ptrace && sig == SIGCHLD &&
1427             (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1428              (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1429                 /*
1430                  * We are exiting and our parent doesn't care.  POSIX.1
1431                  * defines special semantics for setting SIGCHLD to SIG_IGN
1432                  * or setting the SA_NOCLDWAIT flag: we should be reaped
1433                  * automatically and not left for our parent's wait4 call.
1434                  * Rather than having the parent do it as a magic kind of
1435                  * signal handler, we just set this to tell do_exit that we
1436                  * can be cleaned up without becoming a zombie.  Note that
1437                  * we still call __wake_up_parent in this case, because a
1438                  * blocked sys_wait4 might now return -ECHILD.
1439                  *
1440                  * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1441                  * is implementation-defined: we do (if you don't want
1442                  * it, just use SIG_IGN instead).
1443                  */
1444                 ret = tsk->exit_signal = -1;
1445                 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1446                         sig = -1;
1447         }
1448         if (valid_signal(sig) && sig > 0)
1449                 __group_send_sig_info(sig, &info, tsk->parent);
1450         __wake_up_parent(tsk, tsk->parent);
1451         spin_unlock_irqrestore(&psig->siglock, flags);
1452
1453         return ret;
1454 }
1455
1456 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1457 {
1458         struct siginfo info;
1459         unsigned long flags;
1460         struct task_struct *parent;
1461         struct sighand_struct *sighand;
1462
1463         if (tsk->ptrace & PT_PTRACED)
1464                 parent = tsk->parent;
1465         else {
1466                 tsk = tsk->group_leader;
1467                 parent = tsk->real_parent;
1468         }
1469
1470         info.si_signo = SIGCHLD;
1471         info.si_errno = 0;
1472         /*
1473          * see comment in do_notify_parent() abot the following 3 lines
1474          */
1475         rcu_read_lock();
1476         info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1477         info.si_uid = __task_cred(tsk)->uid;
1478         rcu_read_unlock();
1479
1480         info.si_utime = cputime_to_clock_t(tsk->utime);
1481         info.si_stime = cputime_to_clock_t(tsk->stime);
1482
1483         info.si_code = why;
1484         switch (why) {
1485         case CLD_CONTINUED:
1486                 info.si_status = SIGCONT;
1487                 break;
1488         case CLD_STOPPED:
1489                 info.si_status = tsk->signal->group_exit_code & 0x7f;
1490                 break;
1491         case CLD_TRAPPED:
1492                 info.si_status = tsk->exit_code & 0x7f;
1493                 break;
1494         default:
1495                 BUG();
1496         }
1497
1498         sighand = parent->sighand;
1499         spin_lock_irqsave(&sighand->siglock, flags);
1500         if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1501             !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1502                 __group_send_sig_info(SIGCHLD, &info, parent);
1503         /*
1504          * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1505          */
1506         __wake_up_parent(tsk, parent);
1507         spin_unlock_irqrestore(&sighand->siglock, flags);
1508 }
1509
1510 static inline int may_ptrace_stop(void)
1511 {
1512         if (!likely(current->ptrace & PT_PTRACED))
1513                 return 0;
1514         /*
1515          * Are we in the middle of do_coredump?
1516          * If so and our tracer is also part of the coredump stopping
1517          * is a deadlock situation, and pointless because our tracer
1518          * is dead so don't allow us to stop.
1519          * If SIGKILL was already sent before the caller unlocked
1520          * ->siglock we must see ->core_state != NULL. Otherwise it
1521          * is safe to enter schedule().
1522          */
1523         if (unlikely(current->mm->core_state) &&
1524             unlikely(current->mm == current->parent->mm))
1525                 return 0;
1526
1527         return 1;
1528 }
1529
1530 /*
1531  * Return nonzero if there is a SIGKILL that should be waking us up.
1532  * Called with the siglock held.
1533  */
1534 static int sigkill_pending(struct task_struct *tsk)
1535 {
1536         return  sigismember(&tsk->pending.signal, SIGKILL) ||
1537                 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
1538 }
1539
1540 /*
1541  * This must be called with current->sighand->siglock held.
1542  *
1543  * This should be the path for all ptrace stops.
1544  * We always set current->last_siginfo while stopped here.
1545  * That makes it a way to test a stopped process for
1546  * being ptrace-stopped vs being job-control-stopped.
1547  *
1548  * If we actually decide not to stop at all because the tracer
1549  * is gone, we keep current->exit_code unless clear_code.
1550  */
1551 static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
1552 {
1553         if (arch_ptrace_stop_needed(exit_code, info)) {
1554                 /*
1555                  * The arch code has something special to do before a
1556                  * ptrace stop.  This is allowed to block, e.g. for faults
1557                  * on user stack pages.  We can't keep the siglock while
1558                  * calling arch_ptrace_stop, so we must release it now.
1559                  * To preserve proper semantics, we must do this before
1560                  * any signal bookkeeping like checking group_stop_count.
1561                  * Meanwhile, a SIGKILL could come in before we retake the
1562                  * siglock.  That must prevent us from sleeping in TASK_TRACED.
1563                  * So after regaining the lock, we must check for SIGKILL.
1564                  */
1565                 spin_unlock_irq(&current->sighand->siglock);
1566                 arch_ptrace_stop(exit_code, info);
1567                 spin_lock_irq(&current->sighand->siglock);
1568                 if (sigkill_pending(current))
1569                         return;
1570         }
1571
1572         /*
1573          * If there is a group stop in progress,
1574          * we must participate in the bookkeeping.
1575          */
1576         if (current->signal->group_stop_count > 0)
1577                 --current->signal->group_stop_count;
1578
1579         current->last_siginfo = info;
1580         current->exit_code = exit_code;
1581
1582         /* Let the debugger run.  */
1583         __set_current_state(TASK_TRACED);
1584         spin_unlock_irq(&current->sighand->siglock);
1585         read_lock(&tasklist_lock);
1586         if (may_ptrace_stop()) {
1587                 do_notify_parent_cldstop(current, CLD_TRAPPED);
1588                 /*
1589                  * Don't want to allow preemption here, because
1590                  * sys_ptrace() needs this task to be inactive.
1591                  *
1592                  * XXX: implement read_unlock_no_resched().
1593                  */
1594                 preempt_disable();
1595                 read_unlock(&tasklist_lock);
1596                 preempt_enable_no_resched();
1597                 schedule();
1598         } else {
1599                 /*
1600                  * By the time we got the lock, our tracer went away.
1601                  * Don't drop the lock yet, another tracer may come.
1602                  */
1603                 __set_current_state(TASK_RUNNING);
1604                 if (clear_code)
1605                         current->exit_code = 0;
1606                 read_unlock(&tasklist_lock);
1607         }
1608
1609         /*
1610          * While in TASK_TRACED, we were considered "frozen enough".
1611          * Now that we woke up, it's crucial if we're supposed to be
1612          * frozen that we freeze now before running anything substantial.
1613          */
1614         try_to_freeze();
1615
1616         /*
1617          * We are back.  Now reacquire the siglock before touching
1618          * last_siginfo, so that we are sure to have synchronized with
1619          * any signal-sending on another CPU that wants to examine it.
1620          */
1621         spin_lock_irq(&current->sighand->siglock);
1622         current->last_siginfo = NULL;
1623
1624         /*
1625          * Queued signals ignored us while we were stopped for tracing.
1626          * So check for any that we should take before resuming user mode.
1627          * This sets TIF_SIGPENDING, but never clears it.
1628          */
1629         recalc_sigpending_tsk(current);
1630 }
1631
1632 void ptrace_notify(int exit_code)
1633 {
1634         siginfo_t info;
1635
1636         BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1637
1638         memset(&info, 0, sizeof info);
1639         info.si_signo = SIGTRAP;
1640         info.si_code = exit_code;
1641         info.si_pid = task_pid_vnr(current);
1642         info.si_uid = current_uid();
1643
1644         /* Let the debugger run.  */
1645         spin_lock_irq(&current->sighand->siglock);
1646         ptrace_stop(exit_code, 1, &info);
1647         spin_unlock_irq(&current->sighand->siglock);
1648 }
1649
1650 static void
1651 finish_stop(int stop_count)
1652 {
1653         /*
1654          * If there are no other threads in the group, or if there is
1655          * a group stop in progress and we are the last to stop,
1656          * report to the parent.  When ptraced, every thread reports itself.
1657          */
1658         if (tracehook_notify_jctl(stop_count == 0, CLD_STOPPED)) {
1659                 read_lock(&tasklist_lock);
1660                 do_notify_parent_cldstop(current, CLD_STOPPED);
1661                 read_unlock(&tasklist_lock);
1662         }
1663
1664         do {
1665                 schedule();
1666         } while (try_to_freeze());
1667         /*
1668          * Now we don't run again until continued.
1669          */
1670         current->exit_code = 0;
1671 }
1672
1673 /*
1674  * This performs the stopping for SIGSTOP and other stop signals.
1675  * We have to stop all threads in the thread group.
1676  * Returns nonzero if we've actually stopped and released the siglock.
1677  * Returns zero if we didn't stop and still hold the siglock.
1678  */
1679 static int do_signal_stop(int signr)
1680 {
1681         struct signal_struct *sig = current->signal;
1682         int stop_count;
1683
1684         if (sig->group_stop_count > 0) {
1685                 /*
1686                  * There is a group stop in progress.  We don't need to
1687                  * start another one.
1688                  */
1689                 stop_count = --sig->group_stop_count;
1690         } else {
1691                 struct task_struct *t;
1692
1693                 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
1694                     unlikely(signal_group_exit(sig)))
1695                         return 0;
1696                 /*
1697                  * There is no group stop already in progress.
1698                  * We must initiate one now.
1699                  */
1700                 sig->group_exit_code = signr;
1701
1702                 stop_count = 0;
1703                 for (t = next_thread(current); t != current; t = next_thread(t))
1704                         /*
1705                          * Setting state to TASK_STOPPED for a group
1706                          * stop is always done with the siglock held,
1707                          * so this check has no races.
1708                          */
1709                         if (!(t->flags & PF_EXITING) &&
1710                             !task_is_stopped_or_traced(t)) {
1711                                 stop_count++;
1712                                 signal_wake_up(t, 0);
1713                         }
1714                 sig->group_stop_count = stop_count;
1715         }
1716
1717         if (stop_count == 0)
1718                 sig->flags = SIGNAL_STOP_STOPPED;
1719         current->exit_code = sig->group_exit_code;
1720         __set_current_state(TASK_STOPPED);
1721
1722         spin_unlock_irq(&current->sighand->siglock);
1723         finish_stop(stop_count);
1724         return 1;
1725 }
1726
1727 static int ptrace_signal(int signr, siginfo_t *info,
1728                          struct pt_regs *regs, void *cookie)
1729 {
1730         if (!(current->ptrace & PT_PTRACED))
1731                 return signr;
1732
1733         ptrace_signal_deliver(regs, cookie);
1734
1735         /* Let the debugger run.  */
1736         ptrace_stop(signr, 0, info);
1737
1738         /* We're back.  Did the debugger cancel the sig?  */
1739         signr = current->exit_code;
1740         if (signr == 0)
1741                 return signr;
1742
1743         current->exit_code = 0;
1744
1745         /* Update the siginfo structure if the signal has
1746            changed.  If the debugger wanted something
1747            specific in the siginfo structure then it should
1748            have updated *info via PTRACE_SETSIGINFO.  */
1749         if (signr != info->si_signo) {
1750                 info->si_signo = signr;
1751                 info->si_errno = 0;
1752                 info->si_code = SI_USER;
1753                 info->si_pid = task_pid_vnr(current->parent);
1754                 info->si_uid = task_uid(current->parent);
1755         }
1756
1757         /* If the (new) signal is now blocked, requeue it.  */
1758         if (sigismember(&current->blocked, signr)) {
1759                 specific_send_sig_info(signr, info, current);
1760                 signr = 0;
1761         }
1762
1763         return signr;
1764 }
1765
1766 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1767                           struct pt_regs *regs, void *cookie)
1768 {
1769         struct sighand_struct *sighand = current->sighand;
1770         struct signal_struct *signal = current->signal;
1771         int signr;
1772
1773 relock:
1774         /*
1775          * We'll jump back here after any time we were stopped in TASK_STOPPED.
1776          * While in TASK_STOPPED, we were considered "frozen enough".
1777          * Now that we woke up, it's crucial if we're supposed to be
1778          * frozen that we freeze now before running anything substantial.
1779          */
1780         try_to_freeze();
1781
1782         spin_lock_irq(&sighand->siglock);
1783         /*
1784          * Every stopped thread goes here after wakeup. Check to see if
1785          * we should notify the parent, prepare_signal(SIGCONT) encodes
1786          * the CLD_ si_code into SIGNAL_CLD_MASK bits.
1787          */
1788         if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
1789                 int why = (signal->flags & SIGNAL_STOP_CONTINUED)
1790                                 ? CLD_CONTINUED : CLD_STOPPED;
1791                 signal->flags &= ~SIGNAL_CLD_MASK;
1792                 spin_unlock_irq(&sighand->siglock);
1793
1794                 if (unlikely(!tracehook_notify_jctl(1, why)))
1795                         goto relock;
1796
1797                 read_lock(&tasklist_lock);
1798                 do_notify_parent_cldstop(current->group_leader, why);
1799                 read_unlock(&tasklist_lock);
1800                 goto relock;
1801         }
1802
1803         for (;;) {
1804                 struct k_sigaction *ka;
1805
1806                 if (unlikely(signal->group_stop_count > 0) &&
1807                     do_signal_stop(0))
1808                         goto relock;
1809
1810                 /*
1811                  * Tracing can induce an artifical signal and choose sigaction.
1812                  * The return value in @signr determines the default action,
1813                  * but @info->si_signo is the signal number we will report.
1814                  */
1815                 signr = tracehook_get_signal(current, regs, info, return_ka);
1816                 if (unlikely(signr < 0))
1817                         goto relock;
1818                 if (unlikely(signr != 0))
1819                         ka = return_ka;
1820                 else {
1821                         signr = dequeue_signal(current, &current->blocked,
1822                                                info);
1823
1824                         if (!signr)
1825                                 break; /* will return 0 */
1826
1827                         if (signr != SIGKILL) {
1828                                 signr = ptrace_signal(signr, info,
1829                                                       regs, cookie);
1830                                 if (!signr)
1831                                         continue;
1832                         }
1833
1834                         ka = &sighand->action[signr-1];
1835                 }
1836
1837                 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
1838                         continue;
1839                 if (ka->sa.sa_handler != SIG_DFL) {
1840                         /* Run the handler.  */
1841                         *return_ka = *ka;
1842
1843                         if (ka->sa.sa_flags & SA_ONESHOT)
1844                                 ka->sa.sa_handler = SIG_DFL;
1845
1846                         break; /* will return non-zero "signr" value */
1847                 }
1848
1849                 /*
1850                  * Now we are doing the default action for this signal.
1851                  */
1852                 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1853                         continue;
1854
1855                 /*
1856                  * Global init gets no signals it doesn't want.
1857                  */
1858                 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
1859                     !signal_group_exit(signal))
1860                         continue;
1861
1862                 if (sig_kernel_stop(signr)) {
1863                         /*
1864                          * The default action is to stop all threads in
1865                          * the thread group.  The job control signals
1866                          * do nothing in an orphaned pgrp, but SIGSTOP
1867                          * always works.  Note that siglock needs to be
1868                          * dropped during the call to is_orphaned_pgrp()
1869                          * because of lock ordering with tasklist_lock.
1870                          * This allows an intervening SIGCONT to be posted.
1871                          * We need to check for that and bail out if necessary.
1872                          */
1873                         if (signr != SIGSTOP) {
1874                                 spin_unlock_irq(&sighand->siglock);
1875
1876                                 /* signals can be posted during this window */
1877
1878                                 if (is_current_pgrp_orphaned())
1879                                         goto relock;
1880
1881                                 spin_lock_irq(&sighand->siglock);
1882                         }
1883
1884                         if (likely(do_signal_stop(info->si_signo))) {
1885                                 /* It released the siglock.  */
1886                                 goto relock;
1887                         }
1888
1889                         /*
1890                          * We didn't actually stop, due to a race
1891                          * with SIGCONT or something like that.
1892                          */
1893                         continue;
1894                 }
1895
1896                 spin_unlock_irq(&sighand->siglock);
1897
1898                 /*
1899                  * Anything else is fatal, maybe with a core dump.
1900                  */
1901                 current->flags |= PF_SIGNALED;
1902
1903                 if (sig_kernel_coredump(signr)) {
1904                         if (print_fatal_signals)
1905                                 print_fatal_signal(regs, info->si_signo);
1906                         /*
1907                          * If it was able to dump core, this kills all
1908                          * other threads in the group and synchronizes with
1909                          * their demise.  If we lost the race with another
1910                          * thread getting here, it set group_exit_code
1911                          * first and our do_group_exit call below will use
1912                          * that value and ignore the one we pass it.
1913                          */
1914                         do_coredump(info->si_signo, info->si_signo, regs);
1915                 }
1916
1917                 /*
1918                  * Death signals, no core dump.
1919                  */
1920                 do_group_exit(info->si_signo);
1921                 /* NOTREACHED */
1922         }
1923         spin_unlock_irq(&sighand->siglock);
1924         return signr;
1925 }
1926
1927 void exit_signals(struct task_struct *tsk)
1928 {
1929         int group_stop = 0;
1930         struct task_struct *t;
1931
1932         if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
1933                 tsk->flags |= PF_EXITING;
1934                 return;
1935         }
1936
1937         spin_lock_irq(&tsk->sighand->siglock);
1938         /*
1939          * From now this task is not visible for group-wide signals,
1940          * see wants_signal(), do_signal_stop().
1941          */
1942         tsk->flags |= PF_EXITING;
1943         if (!signal_pending(tsk))
1944                 goto out;
1945
1946         /* It could be that __group_complete_signal() choose us to
1947          * notify about group-wide signal. Another thread should be
1948          * woken now to take the signal since we will not.
1949          */
1950         for (t = tsk; (t = next_thread(t)) != tsk; )
1951                 if (!signal_pending(t) && !(t->flags & PF_EXITING))
1952                         recalc_sigpending_and_wake(t);
1953
1954         if (unlikely(tsk->signal->group_stop_count) &&
1955                         !--tsk->signal->group_stop_count) {
1956                 tsk->signal->flags = SIGNAL_STOP_STOPPED;
1957                 group_stop = 1;
1958         }
1959 out:
1960         spin_unlock_irq(&tsk->sighand->siglock);
1961
1962         if (unlikely(group_stop) && tracehook_notify_jctl(1, CLD_STOPPED)) {
1963                 read_lock(&tasklist_lock);
1964                 do_notify_parent_cldstop(tsk, CLD_STOPPED);
1965                 read_unlock(&tasklist_lock);
1966         }
1967 }
1968
1969 EXPORT_SYMBOL(recalc_sigpending);
1970 EXPORT_SYMBOL_GPL(dequeue_signal);
1971 EXPORT_SYMBOL(flush_signals);
1972 EXPORT_SYMBOL(force_sig);
1973 EXPORT_SYMBOL(send_sig);
1974 EXPORT_SYMBOL(send_sig_info);
1975 EXPORT_SYMBOL(sigprocmask);
1976 EXPORT_SYMBOL(block_all_signals);
1977 EXPORT_SYMBOL(unblock_all_signals);
1978
1979
1980 /*
1981  * System call entry points.
1982  */
1983
1984 SYSCALL_DEFINE0(restart_syscall)
1985 {
1986         struct restart_block *restart = &current_thread_info()->restart_block;
1987         return restart->fn(restart);
1988 }
1989
1990 long do_no_restart_syscall(struct restart_block *param)
1991 {
1992         return -EINTR;
1993 }
1994
1995 /*
1996  * We don't need to get the kernel lock - this is all local to this
1997  * particular thread.. (and that's good, because this is _heavily_
1998  * used by various programs)
1999  */
2000
2001 /*
2002  * This is also useful for kernel threads that want to temporarily
2003  * (or permanently) block certain signals.
2004  *
2005  * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2006  * interface happily blocks "unblockable" signals like SIGKILL
2007  * and friends.
2008  */
2009 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2010 {
2011         int error;
2012
2013         spin_lock_irq(&current->sighand->siglock);
2014         if (oldset)
2015                 *oldset = current->blocked;
2016
2017         error = 0;
2018         switch (how) {
2019         case SIG_BLOCK:
2020                 sigorsets(&current->blocked, &current->blocked, set);
2021                 break;
2022         case SIG_UNBLOCK:
2023                 signandsets(&current->blocked, &current->blocked, set);
2024                 break;
2025         case SIG_SETMASK:
2026                 current->blocked = *set;
2027                 break;
2028         default:
2029                 error = -EINVAL;
2030         }
2031         recalc_sigpending();
2032         spin_unlock_irq(&current->sighand->siglock);
2033
2034         return error;
2035 }
2036
2037 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, set,
2038                 sigset_t __user *, oset, size_t, sigsetsize)
2039 {
2040         int error = -EINVAL;
2041         sigset_t old_set, new_set;
2042
2043         /* XXX: Don't preclude handling different sized sigset_t's.  */
2044         if (sigsetsize != sizeof(sigset_t))
2045                 goto out;
2046
2047         if (set) {
2048                 error = -EFAULT;
2049                 if (copy_from_user(&new_set, set, sizeof(*set)))
2050                         goto out;
2051                 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2052
2053                 error = sigprocmask(how, &new_set, &old_set);
2054                 if (error)
2055                         goto out;
2056                 if (oset)
2057                         goto set_old;
2058         } else if (oset) {
2059                 spin_lock_irq(&current->sighand->siglock);
2060                 old_set = current->blocked;
2061                 spin_unlock_irq(&current->sighand->siglock);
2062
2063         set_old:
2064                 error = -EFAULT;
2065                 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2066                         goto out;
2067         }
2068         error = 0;
2069 out:
2070         return error;
2071 }
2072
2073 long do_sigpending(void __user *set, unsigned long sigsetsize)
2074 {
2075         long error = -EINVAL;
2076         sigset_t pending;
2077
2078         if (sigsetsize > sizeof(sigset_t))
2079                 goto out;
2080
2081         spin_lock_irq(&current->sighand->siglock);
2082         sigorsets(&pending, &current->pending.signal,
2083                   &current->signal->shared_pending.signal);
2084         spin_unlock_irq(&current->sighand->siglock);
2085
2086         /* Outside the lock because only this thread touches it.  */
2087         sigandsets(&pending, &current->blocked, &pending);
2088
2089         error = -EFAULT;
2090         if (!copy_to_user(set, &pending, sigsetsize))
2091                 error = 0;
2092
2093 out:
2094         return error;
2095 }
2096
2097 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, set, size_t, sigsetsize)
2098 {
2099         return do_sigpending(set, sigsetsize);
2100 }
2101
2102 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2103
2104 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2105 {
2106         int err;
2107
2108         if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2109                 return -EFAULT;
2110         if (from->si_code < 0)
2111                 return __copy_to_user(to, from, sizeof(siginfo_t))
2112                         ? -EFAULT : 0;
2113         /*
2114          * If you change siginfo_t structure, please be sure
2115          * this code is fixed accordingly.
2116          * Please remember to update the signalfd_copyinfo() function
2117          * inside fs/signalfd.c too, in case siginfo_t changes.
2118          * It should never copy any pad contained in the structure
2119          * to avoid security leaks, but must copy the generic
2120          * 3 ints plus the relevant union member.
2121          */
2122         err = __put_user(from->si_signo, &to->si_signo);
2123         err |= __put_user(from->si_errno, &to->si_errno);
2124         err |= __put_user((short)from->si_code, &to->si_code);
2125         switch (from->si_code & __SI_MASK) {
2126         case __SI_KILL:
2127                 err |= __put_user(from->si_pid, &to->si_pid);
2128                 err |= __put_user(from->si_uid, &to->si_uid);
2129                 break;
2130         case __SI_TIMER:
2131                  err |= __put_user(from->si_tid, &to->si_tid);
2132                  err |= __put_user(from->si_overrun, &to->si_overrun);
2133                  err |= __put_user(from->si_ptr, &to->si_ptr);
2134                 break;
2135         case __SI_POLL:
2136                 err |= __put_user(from->si_band, &to->si_band);
2137                 err |= __put_user(from->si_fd, &to->si_fd);
2138                 break;
2139         case __SI_FAULT:
2140                 err |= __put_user(from->si_addr, &to->si_addr);
2141 #ifdef __ARCH_SI_TRAPNO
2142                 err |= __put_user(from->si_trapno, &to->si_trapno);
2143 #endif
2144                 break;
2145         case __SI_CHLD:
2146                 err |= __put_user(from->si_pid, &to->si_pid);
2147                 err |= __put_user(from->si_uid, &to->si_uid);
2148                 err |= __put_user(from->si_status, &to->si_status);
2149                 err |= __put_user(from->si_utime, &to->si_utime);
2150                 err |= __put_user(from->si_stime, &to->si_stime);
2151                 break;
2152         case __SI_RT: /* This is not generated by the kernel as of now. */
2153         case __SI_MESGQ: /* But this is */
2154                 err |= __put_user(from->si_pid, &to->si_pid);
2155                 err |= __put_user(from->si_uid, &to->si_uid);
2156                 err |= __put_user(from->si_ptr, &to->si_ptr);
2157                 break;
2158         default: /* this is just in case for now ... */
2159                 err |= __put_user(from->si_pid, &to->si_pid);
2160                 err |= __put_user(from->si_uid, &to->si_uid);
2161                 break;
2162         }
2163         return err;
2164 }
2165
2166 #endif
2167
2168 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2169                 siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2170                 size_t, sigsetsize)
2171 {
2172         int ret, sig;
2173         sigset_t these;
2174         struct timespec ts;
2175         siginfo_t info;
2176         long timeout = 0;
2177
2178         /* XXX: Don't preclude handling different sized sigset_t's.  */
2179         if (sigsetsize != sizeof(sigset_t))
2180                 return -EINVAL;
2181
2182         if (copy_from_user(&these, uthese, sizeof(these)))
2183                 return -EFAULT;
2184
2185         /*
2186          * Invert the set of allowed signals to get those we
2187          * want to block.
2188          */
2189         sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2190         signotset(&these);
2191
2192         if (uts) {
2193                 if (copy_from_user(&ts, uts, sizeof(ts)))
2194                         return -EFAULT;
2195                 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2196                     || ts.tv_sec < 0)
2197                         return -EINVAL;
2198         }
2199
2200         spin_lock_irq(&current->sighand->siglock);
2201         sig = dequeue_signal(current, &these, &info);
2202         if (!sig) {
2203                 timeout = MAX_SCHEDULE_TIMEOUT;
2204                 if (uts)
2205                         timeout = (timespec_to_jiffies(&ts)
2206                                    + (ts.tv_sec || ts.tv_nsec));
2207
2208                 if (timeout) {
2209                         /* None ready -- temporarily unblock those we're
2210                          * interested while we are sleeping in so that we'll
2211                          * be awakened when they arrive.  */
2212                         current->real_blocked = current->blocked;
2213                         sigandsets(&current->blocked, &current->blocked, &these);
2214                         recalc_sigpending();
2215                         spin_unlock_irq(&current->sighand->siglock);
2216
2217                         timeout = schedule_timeout_interruptible(timeout);
2218
2219                         spin_lock_irq(&current->sighand->siglock);
2220                         sig = dequeue_signal(current, &these, &info);
2221                         current->blocked = current->real_blocked;
2222                         siginitset(&current->real_blocked, 0);
2223                         recalc_sigpending();
2224                 }
2225         }
2226         spin_unlock_irq(&current->sighand->siglock);
2227
2228         if (sig) {
2229                 ret = sig;
2230                 if (uinfo) {
2231                         if (copy_siginfo_to_user(uinfo, &info))
2232                                 ret = -EFAULT;
2233                 }
2234         } else {
2235                 ret = -EAGAIN;
2236                 if (timeout)
2237                         ret = -EINTR;
2238         }
2239
2240         return ret;
2241 }
2242
2243 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
2244 {
2245         struct siginfo info;
2246
2247         info.si_signo = sig;
2248         info.si_errno = 0;
2249         info.si_code = SI_USER;
2250         info.si_pid = task_tgid_vnr(current);
2251         info.si_uid = current_uid();
2252
2253         return kill_something_info(sig, &info, pid);
2254 }
2255
2256 static int do_tkill(pid_t tgid, pid_t pid, int sig)
2257 {
2258         int error;
2259         struct siginfo info;
2260         struct task_struct *p;
2261         unsigned long flags;
2262
2263         error = -ESRCH;
2264         info.si_signo = sig;
2265         info.si_errno = 0;
2266         info.si_code = SI_TKILL;
2267         info.si_pid = task_tgid_vnr(current);
2268         info.si_uid = current_uid();
2269
2270         rcu_read_lock();
2271         p = find_task_by_vpid(pid);
2272         if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2273                 error = check_kill_permission(sig, &info, p);
2274                 /*
2275                  * The null signal is a permissions and process existence
2276                  * probe.  No signal is actually delivered.
2277                  *
2278                  * If lock_task_sighand() fails we pretend the task dies
2279                  * after receiving the signal. The window is tiny, and the
2280                  * signal is private anyway.
2281                  */
2282                 if (!error && sig && lock_task_sighand(p, &flags)) {
2283                         error = specific_send_sig_info(sig, &info, p);
2284                         unlock_task_sighand(p, &flags);
2285                 }
2286         }
2287         rcu_read_unlock();
2288
2289         return error;
2290 }
2291
2292 /**
2293  *  sys_tgkill - send signal to one specific thread
2294  *  @tgid: the thread group ID of the thread
2295  *  @pid: the PID of the thread
2296  *  @sig: signal to be sent
2297  *
2298  *  This syscall also checks the @tgid and returns -ESRCH even if the PID
2299  *  exists but it's not belonging to the target process anymore. This
2300  *  method solves the problem of threads exiting and PIDs getting reused.
2301  */
2302 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
2303 {
2304         /* This is only valid for single tasks */
2305         if (pid <= 0 || tgid <= 0)
2306                 return -EINVAL;
2307
2308         return do_tkill(tgid, pid, sig);
2309 }
2310
2311 /*
2312  *  Send a signal to only one task, even if it's a CLONE_THREAD task.
2313  */
2314 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
2315 {
2316         /* This is only valid for single tasks */
2317         if (pid <= 0)
2318                 return -EINVAL;
2319
2320         return do_tkill(0, pid, sig);
2321 }
2322
2323 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
2324                 siginfo_t __user *, uinfo)
2325 {
2326         siginfo_t info;
2327
2328         if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2329                 return -EFAULT;
2330
2331         /* Not even root can pretend to send signals from the kernel.
2332            Nor can they impersonate a kill(), which adds source info.  */
2333         if (info.si_code >= 0)
2334                 return -EPERM;
2335         info.si_signo = sig;
2336
2337         /* POSIX.1b doesn't mention process groups.  */
2338         return kill_proc_info(sig, &info, pid);
2339 }
2340
2341 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2342 {
2343         struct task_struct *t = current;
2344         struct k_sigaction *k;
2345         sigset_t mask;
2346
2347         if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2348                 return -EINVAL;
2349
2350         k = &t->sighand->action[sig-1];
2351
2352         spin_lock_irq(&current->sighand->siglock);
2353         if (oact)
2354                 *oact = *k;
2355
2356         if (act) {
2357                 sigdelsetmask(&act->sa.sa_mask,
2358                               sigmask(SIGKILL) | sigmask(SIGSTOP));
2359                 *k = *act;
2360                 /*
2361                  * POSIX 3.3.1.3:
2362                  *  "Setting a signal action to SIG_IGN for a signal that is
2363                  *   pending shall cause the pending signal to be discarded,
2364                  *   whether or not it is blocked."
2365                  *
2366                  *  "Setting a signal action to SIG_DFL for a signal that is
2367                  *   pending and whose default action is to ignore the signal
2368                  *   (for example, SIGCHLD), shall cause the pending signal to
2369                  *   be discarded, whether or not it is blocked"
2370                  */
2371                 if (sig_handler_ignored(sig_handler(t, sig), sig)) {
2372                         sigemptyset(&mask);
2373                         sigaddset(&mask, sig);
2374                         rm_from_queue_full(&mask, &t->signal->shared_pending);
2375                         do {
2376                                 rm_from_queue_full(&mask, &t->pending);
2377                                 t = next_thread(t);
2378                         } while (t != current);
2379                 }
2380         }
2381
2382         spin_unlock_irq(&current->sighand->siglock);
2383         return 0;
2384 }
2385
2386 int
2387 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2388 {
2389         stack_t oss;
2390         int error;
2391
2392         if (uoss) {
2393                 oss.ss_sp = (void __user *) current->sas_ss_sp;
2394                 oss.ss_size = current->sas_ss_size;
2395                 oss.ss_flags = sas_ss_flags(sp);
2396         }
2397
2398         if (uss) {
2399                 void __user *ss_sp;
2400                 size_t ss_size;
2401                 int ss_flags;
2402
2403                 error = -EFAULT;
2404                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2405                     || __get_user(ss_sp, &uss->ss_sp)
2406                     || __get_user(ss_flags, &uss->ss_flags)
2407                     || __get_user(ss_size, &uss->ss_size))
2408                         goto out;
2409
2410                 error = -EPERM;
2411                 if (on_sig_stack(sp))
2412                         goto out;
2413
2414                 error = -EINVAL;
2415                 /*
2416                  *
2417                  * Note - this code used to test ss_flags incorrectly
2418                  *        old code may have been written using ss_flags==0
2419                  *        to mean ss_flags==SS_ONSTACK (as this was the only
2420                  *        way that worked) - this fix preserves that older
2421                  *        mechanism
2422                  */
2423                 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2424                         goto out;
2425
2426                 if (ss_flags == SS_DISABLE) {
2427                         ss_size = 0;
2428                         ss_sp = NULL;
2429                 } else {
2430                         error = -ENOMEM;
2431                         if (ss_size < MINSIGSTKSZ)
2432                                 goto out;
2433                 }
2434
2435                 current->sas_ss_sp = (unsigned long) ss_sp;
2436                 current->sas_ss_size = ss_size;
2437         }
2438
2439         if (uoss) {
2440                 error = -EFAULT;
2441                 if (copy_to_user(uoss, &oss, sizeof(oss)))
2442                         goto out;
2443         }
2444
2445         error = 0;
2446 out:
2447         return error;
2448 }
2449
2450 #ifdef __ARCH_WANT_SYS_SIGPENDING
2451
2452 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
2453 {
2454         return do_sigpending(set, sizeof(*set));
2455 }
2456
2457 #endif
2458
2459 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2460 /* Some platforms have their own version with special arguments others
2461    support only sys_rt_sigprocmask.  */
2462
2463 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, set,
2464                 old_sigset_t __user *, oset)
2465 {
2466         int error;
2467         old_sigset_t old_set, new_set;
2468
2469         if (set) {
2470                 error = -EFAULT;
2471                 if (copy_from_user(&new_set, set, sizeof(*set)))
2472                         goto out;
2473                 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2474
2475                 spin_lock_irq(&current->sighand->siglock);
2476                 old_set = current->blocked.sig[0];
2477
2478                 error = 0;
2479                 switch (how) {
2480                 default:
2481                         error = -EINVAL;
2482                         break;
2483                 case SIG_BLOCK:
2484                         sigaddsetmask(&current->blocked, new_set);
2485                         break;
2486                 case SIG_UNBLOCK:
2487                         sigdelsetmask(&current->blocked, new_set);
2488                         break;
2489                 case SIG_SETMASK:
2490                         current->blocked.sig[0] = new_set;
2491                         break;
2492                 }
2493
2494                 recalc_sigpending();
2495                 spin_unlock_irq(&current->sighand->siglock);
2496                 if (error)
2497                         goto out;
2498                 if (oset)
2499                         goto set_old;
2500         } else if (oset) {
2501                 old_set = current->blocked.sig[0];
2502         set_old:
2503                 error = -EFAULT;
2504                 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2505                         goto out;
2506         }
2507         error = 0;
2508 out:
2509         return error;
2510 }
2511 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2512
2513 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2514 SYSCALL_DEFINE4(rt_sigaction, int, sig,
2515                 const struct sigaction __user *, act,
2516                 struct sigaction __user *, oact,
2517                 size_t, sigsetsize)
2518 {
2519         struct k_sigaction new_sa, old_sa;
2520         int ret = -EINVAL;
2521
2522         /* XXX: Don't preclude handling different sized sigset_t's.  */
2523         if (sigsetsize != sizeof(sigset_t))
2524                 goto out;
2525
2526         if (act) {
2527                 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2528                         return -EFAULT;
2529         }
2530
2531         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2532
2533         if (!ret && oact) {
2534                 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2535                         return -EFAULT;
2536         }
2537 out:
2538         return ret;
2539 }
2540 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2541
2542 #ifdef __ARCH_WANT_SYS_SGETMASK
2543
2544 /*
2545  * For backwards compatibility.  Functionality superseded by sigprocmask.
2546  */
2547 SYSCALL_DEFINE0(sgetmask)
2548 {
2549         /* SMP safe */
2550         return current->blocked.sig[0];
2551 }
2552
2553 SYSCALL_DEFINE1(ssetmask, int, newmask)
2554 {
2555         int old;
2556
2557         spin_lock_irq(&current->sighand->siglock);
2558         old = current->blocked.sig[0];
2559
2560         siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2561                                                   sigmask(SIGSTOP)));
2562         recalc_sigpending();
2563         spin_unlock_irq(&current->sighand->siglock);
2564
2565         return old;
2566 }
2567 #endif /* __ARCH_WANT_SGETMASK */
2568
2569 #ifdef __ARCH_WANT_SYS_SIGNAL
2570 /*
2571  * For backwards compatibility.  Functionality superseded by sigaction.
2572  */
2573 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
2574 {
2575         struct k_sigaction new_sa, old_sa;
2576         int ret;
2577
2578         new_sa.sa.sa_handler = handler;
2579         new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2580         sigemptyset(&new_sa.sa.sa_mask);
2581
2582         ret = do_sigaction(sig, &new_sa, &old_sa);
2583
2584         return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2585 }
2586 #endif /* __ARCH_WANT_SYS_SIGNAL */
2587
2588 #ifdef __ARCH_WANT_SYS_PAUSE
2589
2590 SYSCALL_DEFINE0(pause)
2591 {
2592         current->state = TASK_INTERRUPTIBLE;
2593         schedule();
2594         return -ERESTARTNOHAND;
2595 }
2596
2597 #endif
2598
2599 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2600 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
2601 {
2602         sigset_t newset;
2603
2604         /* XXX: Don't preclude handling different sized sigset_t's.  */
2605         if (sigsetsize != sizeof(sigset_t))
2606                 return -EINVAL;
2607
2608         if (copy_from_user(&newset, unewset, sizeof(newset)))
2609                 return -EFAULT;
2610         sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2611
2612         spin_lock_irq(&current->sighand->siglock);
2613         current->saved_sigmask = current->blocked;
2614         current->blocked = newset;
2615         recalc_sigpending();
2616         spin_unlock_irq(&current->sighand->siglock);
2617
2618         current->state = TASK_INTERRUPTIBLE;
2619         schedule();
2620         set_restore_sigmask();
2621         return -ERESTARTNOHAND;
2622 }
2623 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2624
2625 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2626 {
2627         return NULL;
2628 }
2629
2630 void __init signals_init(void)
2631 {
2632         sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
2633 }