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