kernel/signal.c

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