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