kernel/signal.c

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