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 __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_pid_info(int sig, struct siginfo *info, struct pid *pid)
1041 {
1042         int error = -ESRCH;
1043         struct task_struct *p;
1044
1045         rcu_read_lock();
1046         if (unlikely(sig_needs_tasklist(sig)))
1047                 read_lock(&tasklist_lock);
1048
1049 retry:
1050         p = pid_task(pid, PIDTYPE_PID);
1051         if (p) {
1052                 error = group_send_sig_info(sig, info, p);
1053                 if (unlikely(error == -ESRCH))
1054                         /*
1055                          * The task was unhashed in between, try again.
1056                          * If it is dead, pid_task() will return NULL,
1057                          * if we race with de_thread() it will find the
1058                          * new leader.
1059                          */
1060                         goto retry;
1061         }
1062
1063         if (unlikely(sig_needs_tasklist(sig)))
1064                 read_unlock(&tasklist_lock);
1065         rcu_read_unlock();
1066         return error;
1067 }
1068
1069 int
1070 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1071 {
1072         int error;
1073         rcu_read_lock();
1074         error = kill_pid_info(sig, info, find_vpid(pid));
1075         rcu_read_unlock();
1076         return error;
1077 }
1078
1079 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1080 int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
1081                       uid_t uid, uid_t euid, u32 secid)
1082 {
1083         int ret = -EINVAL;
1084         struct task_struct *p;
1085
1086         if (!valid_signal(sig))
1087                 return ret;
1088
1089         read_lock(&tasklist_lock);
1090         p = pid_task(pid, PIDTYPE_PID);
1091         if (!p) {
1092                 ret = -ESRCH;
1093                 goto out_unlock;
1094         }
1095         if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
1096             && (euid != p->suid) && (euid != p->uid)
1097             && (uid != p->suid) && (uid != p->uid)) {
1098                 ret = -EPERM;
1099                 goto out_unlock;
1100         }
1101         ret = security_task_kill(p, info, sig, secid);
1102         if (ret)
1103                 goto out_unlock;
1104         if (sig && p->sighand) {
1105                 unsigned long flags;
1106                 spin_lock_irqsave(&p->sighand->siglock, flags);
1107                 ret = __group_send_sig_info(sig, info, p);
1108                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1109         }
1110 out_unlock:
1111         read_unlock(&tasklist_lock);
1112         return ret;
1113 }
1114 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
1115
1116 /*
1117  * kill_something_info() interprets pid in interesting ways just like kill(2).
1118  *
1119  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1120  * is probably wrong.  Should make it like BSD or SYSV.
1121  */
1122
1123 static int kill_something_info(int sig, struct siginfo *info, int pid)
1124 {
1125         int ret;
1126
1127         if (pid > 0) {
1128                 rcu_read_lock();
1129                 ret = kill_pid_info(sig, info, find_vpid(pid));
1130                 rcu_read_unlock();
1131                 return ret;
1132         }
1133
1134         read_lock(&tasklist_lock);
1135         if (pid != -1) {
1136                 ret = __kill_pgrp_info(sig, info,
1137                                 pid ? find_vpid(-pid) : task_pgrp(current));
1138         } else {
1139                 int retval = 0, count = 0;
1140                 struct task_struct * p;
1141
1142                 for_each_process(p) {
1143                         if (p->pid > 1 && !same_thread_group(p, current)) {
1144                                 int err = group_send_sig_info(sig, info, p);
1145                                 ++count;
1146                                 if (err != -EPERM)
1147                                         retval = err;
1148                         }
1149                 }
1150                 ret = count ? retval : -ESRCH;
1151         }
1152         read_unlock(&tasklist_lock);
1153
1154         return ret;
1155 }
1156
1157 /*
1158  * These are for backward compatibility with the rest of the kernel source.
1159  */
1160
1161 /*
1162  * These two are the most common entry points.  They send a signal
1163  * just to the specific thread.
1164  */
1165 int
1166 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1167 {
1168         int ret;
1169         unsigned long flags;
1170
1171         /*
1172          * Make sure legacy kernel users don't send in bad values
1173          * (normal paths check this in check_kill_permission).
1174          */
1175         if (!valid_signal(sig))
1176                 return -EINVAL;
1177
1178         /*
1179          * We need the tasklist lock even for the specific
1180          * thread case (when we don't need to follow the group
1181          * lists) in order to avoid races with "p->sighand"
1182          * going away or changing from under us.
1183          */
1184         read_lock(&tasklist_lock);
1185         spin_lock_irqsave(&p->sighand->siglock, flags);
1186         ret = specific_send_sig_info(sig, info, p);
1187         spin_unlock_irqrestore(&p->sighand->siglock, flags);
1188         read_unlock(&tasklist_lock);
1189         return ret;
1190 }
1191
1192 #define __si_special(priv) \
1193         ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1194
1195 int
1196 send_sig(int sig, struct task_struct *p, int priv)
1197 {
1198         return send_sig_info(sig, __si_special(priv), p);
1199 }
1200
1201 void
1202 force_sig(int sig, struct task_struct *p)
1203 {
1204         force_sig_info(sig, SEND_SIG_PRIV, p);
1205 }
1206
1207 /*
1208  * When things go south during signal handling, we
1209  * will force a SIGSEGV. And if the signal that caused
1210  * the problem was already a SIGSEGV, we'll want to
1211  * make sure we don't even try to deliver the signal..
1212  */
1213 int
1214 force_sigsegv(int sig, struct task_struct *p)
1215 {
1216         if (sig == SIGSEGV) {
1217                 unsigned long flags;
1218                 spin_lock_irqsave(&p->sighand->siglock, flags);
1219                 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1220                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1221         }
1222         force_sig(SIGSEGV, p);
1223         return 0;
1224 }
1225
1226 int kill_pgrp(struct pid *pid, int sig, int priv)
1227 {
1228         int ret;
1229
1230         read_lock(&tasklist_lock);
1231         ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1232         read_unlock(&tasklist_lock);
1233
1234         return ret;
1235 }
1236 EXPORT_SYMBOL(kill_pgrp);
1237
1238 int kill_pid(struct pid *pid, int sig, int priv)
1239 {
1240         return kill_pid_info(sig, __si_special(priv), pid);
1241 }
1242 EXPORT_SYMBOL(kill_pid);
1243
1244 int
1245 kill_proc(pid_t pid, int sig, int priv)
1246 {
1247         int ret;
1248
1249         rcu_read_lock();
1250         ret = kill_pid_info(sig, __si_special(priv), find_pid(pid));
1251         rcu_read_unlock();
1252         return ret;
1253 }
1254
1255 /*
1256  * These functions support sending signals using preallocated sigqueue
1257  * structures.  This is needed "because realtime applications cannot
1258  * afford to lose notifications of asynchronous events, like timer
1259  * expirations or I/O completions".  In the case of Posix Timers
1260  * we allocate the sigqueue structure from the timer_create.  If this
1261  * allocation fails we are able to report the failure to the application
1262  * with an EAGAIN error.
1263  */
1264
1265 struct sigqueue *sigqueue_alloc(void)
1266 {
1267         struct sigqueue *q;
1268
1269         if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1270                 q->flags |= SIGQUEUE_PREALLOC;
1271         return(q);
1272 }
1273
1274 void sigqueue_free(struct sigqueue *q)
1275 {
1276         unsigned long flags;
1277         spinlock_t *lock = &current->sighand->siglock;
1278
1279         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1280         /*
1281          * If the signal is still pending remove it from the
1282          * pending queue. We must hold ->siglock while testing
1283          * q->list to serialize with collect_signal().
1284          */
1285         spin_lock_irqsave(lock, flags);
1286         if (!list_empty(&q->list))
1287                 list_del_init(&q->list);
1288         spin_unlock_irqrestore(lock, flags);
1289
1290         q->flags &= ~SIGQUEUE_PREALLOC;
1291         __sigqueue_free(q);
1292 }
1293
1294 int send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1295 {
1296         unsigned long flags;
1297         int ret = 0;
1298
1299         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1300
1301         /*
1302          * The rcu based delayed sighand destroy makes it possible to
1303          * run this without tasklist lock held. The task struct itself
1304          * cannot go away as create_timer did get_task_struct().
1305          *
1306          * We return -1, when the task is marked exiting, so
1307          * posix_timer_event can redirect it to the group leader
1308          */
1309         rcu_read_lock();
1310
1311         if (!likely(lock_task_sighand(p, &flags))) {
1312                 ret = -1;
1313                 goto out_err;
1314         }
1315
1316         if (unlikely(!list_empty(&q->list))) {
1317                 /*
1318                  * If an SI_TIMER entry is already queue just increment
1319                  * the overrun count.
1320                  */
1321                 BUG_ON(q->info.si_code != SI_TIMER);
1322                 q->info.si_overrun++;
1323                 goto out;
1324         }
1325         /* Short-circuit ignored signals.  */
1326         if (sig_ignored(p, sig)) {
1327                 ret = 1;
1328                 goto out;
1329         }
1330         /*
1331          * Deliver the signal to listening signalfds. This must be called
1332          * with the sighand lock held.
1333          */
1334         signalfd_notify(p, sig);
1335
1336         list_add_tail(&q->list, &p->pending.list);
1337         sigaddset(&p->pending.signal, sig);
1338         if (!sigismember(&p->blocked, sig))
1339                 signal_wake_up(p, sig == SIGKILL);
1340
1341 out:
1342         unlock_task_sighand(p, &flags);
1343 out_err:
1344         rcu_read_unlock();
1345
1346         return ret;
1347 }
1348
1349 int
1350 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1351 {
1352         unsigned long flags;
1353         int ret = 0;
1354
1355         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1356
1357         read_lock(&tasklist_lock);
1358         /* Since it_lock is held, p->sighand cannot be NULL. */
1359         spin_lock_irqsave(&p->sighand->siglock, flags);
1360         handle_stop_signal(sig, p);
1361
1362         /* Short-circuit ignored signals.  */
1363         if (sig_ignored(p, sig)) {
1364                 ret = 1;
1365                 goto out;
1366         }
1367
1368         if (unlikely(!list_empty(&q->list))) {
1369                 /*
1370                  * If an SI_TIMER entry is already queue just increment
1371                  * the overrun count.  Other uses should not try to
1372                  * send the signal multiple times.
1373                  */
1374                 BUG_ON(q->info.si_code != SI_TIMER);
1375                 q->info.si_overrun++;
1376                 goto out;
1377         }
1378         /*
1379          * Deliver the signal to listening signalfds. This must be called
1380          * with the sighand lock held.
1381          */
1382         signalfd_notify(p, sig);
1383
1384         /*
1385          * Put this signal on the shared-pending queue.
1386          * We always use the shared queue for process-wide signals,
1387          * to avoid several races.
1388          */
1389         list_add_tail(&q->list, &p->signal->shared_pending.list);
1390         sigaddset(&p->signal->shared_pending.signal, sig);
1391
1392         __group_complete_signal(sig, p);
1393 out:
1394         spin_unlock_irqrestore(&p->sighand->siglock, flags);
1395         read_unlock(&tasklist_lock);
1396         return ret;
1397 }
1398
1399 /*
1400  * Wake up any threads in the parent blocked in wait* syscalls.
1401  */
1402 static inline void __wake_up_parent(struct task_struct *p,
1403                                     struct task_struct *parent)
1404 {
1405         wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1406 }
1407
1408 /*
1409  * Let a parent know about the death of a child.
1410  * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1411  */
1412
1413 void do_notify_parent(struct task_struct *tsk, int sig)
1414 {
1415         struct siginfo info;
1416         unsigned long flags;
1417         struct sighand_struct *psig;
1418
1419         BUG_ON(sig == -1);
1420
1421         /* do_notify_parent_cldstop should have been called instead.  */
1422         BUG_ON(task_is_stopped_or_traced(tsk));
1423
1424         BUG_ON(!tsk->ptrace &&
1425                (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1426
1427         info.si_signo = sig;
1428         info.si_errno = 0;
1429         /*
1430          * we are under tasklist_lock here so our parent is tied to
1431          * us and cannot exit and release its namespace.
1432          *
1433          * the only it can is to switch its nsproxy with sys_unshare,
1434          * bu uncharing pid namespaces is not allowed, so we'll always
1435          * see relevant namespace
1436          *
1437          * write_lock() currently calls preempt_disable() which is the
1438          * same as rcu_read_lock(), but according to Oleg, this is not
1439          * correct to rely on this
1440          */
1441         rcu_read_lock();
1442         info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1443         rcu_read_unlock();
1444
1445         info.si_uid = tsk->uid;
1446
1447         /* FIXME: find out whether or not this is supposed to be c*time. */
1448         info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1449                                                        tsk->signal->utime));
1450         info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1451                                                        tsk->signal->stime));
1452
1453         info.si_status = tsk->exit_code & 0x7f;
1454         if (tsk->exit_code & 0x80)
1455                 info.si_code = CLD_DUMPED;
1456         else if (tsk->exit_code & 0x7f)
1457                 info.si_code = CLD_KILLED;
1458         else {
1459                 info.si_code = CLD_EXITED;
1460                 info.si_status = tsk->exit_code >> 8;
1461         }
1462
1463         psig = tsk->parent->sighand;
1464         spin_lock_irqsave(&psig->siglock, flags);
1465         if (!tsk->ptrace && sig == SIGCHLD &&
1466             (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1467              (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1468                 /*
1469                  * We are exiting and our parent doesn't care.  POSIX.1
1470                  * defines special semantics for setting SIGCHLD to SIG_IGN
1471                  * or setting the SA_NOCLDWAIT flag: we should be reaped
1472                  * automatically and not left for our parent's wait4 call.
1473                  * Rather than having the parent do it as a magic kind of
1474                  * signal handler, we just set this to tell do_exit that we
1475                  * can be cleaned up without becoming a zombie.  Note that
1476                  * we still call __wake_up_parent in this case, because a
1477                  * blocked sys_wait4 might now return -ECHILD.
1478                  *
1479                  * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1480                  * is implementation-defined: we do (if you don't want
1481                  * it, just use SIG_IGN instead).
1482                  */
1483                 tsk->exit_signal = -1;
1484                 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1485                         sig = 0;
1486         }
1487         if (valid_signal(sig) && sig > 0)
1488                 __group_send_sig_info(sig, &info, tsk->parent);
1489         __wake_up_parent(tsk, tsk->parent);
1490         spin_unlock_irqrestore(&psig->siglock, flags);
1491 }
1492
1493 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1494 {
1495         struct siginfo info;
1496         unsigned long flags;
1497         struct task_struct *parent;
1498         struct sighand_struct *sighand;
1499
1500         if (tsk->ptrace & PT_PTRACED)
1501                 parent = tsk->parent;
1502         else {
1503                 tsk = tsk->group_leader;
1504                 parent = tsk->real_parent;
1505         }
1506
1507         info.si_signo = SIGCHLD;
1508         info.si_errno = 0;
1509         /*
1510          * see comment in do_notify_parent() abot the following 3 lines
1511          */
1512         rcu_read_lock();
1513         info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1514         rcu_read_unlock();
1515
1516         info.si_uid = tsk->uid;
1517
1518         /* FIXME: find out whether or not this is supposed to be c*time. */
1519         info.si_utime = cputime_to_jiffies(tsk->utime);
1520         info.si_stime = cputime_to_jiffies(tsk->stime);
1521
1522         info.si_code = why;
1523         switch (why) {
1524         case CLD_CONTINUED:
1525                 info.si_status = SIGCONT;
1526                 break;
1527         case CLD_STOPPED:
1528                 info.si_status = tsk->signal->group_exit_code & 0x7f;
1529                 break;
1530         case CLD_TRAPPED:
1531                 info.si_status = tsk->exit_code & 0x7f;
1532                 break;
1533         default:
1534                 BUG();
1535         }
1536
1537         sighand = parent->sighand;
1538         spin_lock_irqsave(&sighand->siglock, flags);
1539         if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1540             !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1541                 __group_send_sig_info(SIGCHLD, &info, parent);
1542         /*
1543          * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1544          */
1545         __wake_up_parent(tsk, parent);
1546         spin_unlock_irqrestore(&sighand->siglock, flags);
1547 }
1548
1549 static inline int may_ptrace_stop(void)
1550 {
1551         if (!likely(current->ptrace & PT_PTRACED))
1552                 return 0;
1553         /*
1554          * Are we in the middle of do_coredump?
1555          * If so and our tracer is also part of the coredump stopping
1556          * is a deadlock situation, and pointless because our tracer
1557          * is dead so don't allow us to stop.
1558          * If SIGKILL was already sent before the caller unlocked
1559          * ->siglock we must see ->core_waiters != 0. Otherwise it
1560          * is safe to enter schedule().
1561          */
1562         if (unlikely(current->mm->core_waiters) &&
1563             unlikely(current->mm == current->parent->mm))
1564                 return 0;
1565
1566         return 1;
1567 }
1568
1569 /*
1570  * Return nonzero if there is a SIGKILL that should be waking us up.
1571  * Called with the siglock held.
1572  */
1573 static int sigkill_pending(struct task_struct *tsk)
1574 {
1575         return ((sigismember(&tsk->pending.signal, SIGKILL) ||
1576                  sigismember(&tsk->signal->shared_pending.signal, SIGKILL)) &&
1577                 !unlikely(sigismember(&tsk->blocked, SIGKILL)));
1578 }
1579
1580 /*
1581  * This must be called with current->sighand->siglock held.
1582  *
1583  * This should be the path for all ptrace stops.
1584  * We always set current->last_siginfo while stopped here.
1585  * That makes it a way to test a stopped process for
1586  * being ptrace-stopped vs being job-control-stopped.
1587  *
1588  * If we actually decide not to stop at all because the tracer
1589  * is gone, we keep current->exit_code unless clear_code.
1590  */
1591 static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
1592 {
1593         int killed = 0;
1594
1595         if (arch_ptrace_stop_needed(exit_code, info)) {
1596                 /*
1597                  * The arch code has something special to do before a
1598                  * ptrace stop.  This is allowed to block, e.g. for faults
1599                  * on user stack pages.  We can't keep the siglock while
1600                  * calling arch_ptrace_stop, so we must release it now.
1601                  * To preserve proper semantics, we must do this before
1602                  * any signal bookkeeping like checking group_stop_count.
1603                  * Meanwhile, a SIGKILL could come in before we retake the
1604                  * siglock.  That must prevent us from sleeping in TASK_TRACED.
1605                  * So after regaining the lock, we must check for SIGKILL.
1606                  */
1607                 spin_unlock_irq(&current->sighand->siglock);
1608                 arch_ptrace_stop(exit_code, info);
1609                 spin_lock_irq(&current->sighand->siglock);
1610                 killed = sigkill_pending(current);
1611         }
1612
1613         /*
1614          * If there is a group stop in progress,
1615          * we must participate in the bookkeeping.
1616          */
1617         if (current->signal->group_stop_count > 0)
1618                 --current->signal->group_stop_count;
1619
1620         current->last_siginfo = info;
1621         current->exit_code = exit_code;
1622
1623         /* Let the debugger run.  */
1624         __set_current_state(TASK_TRACED);
1625         spin_unlock_irq(&current->sighand->siglock);
1626         read_lock(&tasklist_lock);
1627         if (!unlikely(killed) && may_ptrace_stop()) {
1628                 do_notify_parent_cldstop(current, CLD_TRAPPED);
1629                 read_unlock(&tasklist_lock);
1630                 schedule();
1631         } else {
1632                 /*
1633                  * By the time we got the lock, our tracer went away.
1634                  * Don't drop the lock yet, another tracer may come.
1635                  */
1636                 __set_current_state(TASK_RUNNING);
1637                 if (clear_code)
1638                         current->exit_code = 0;
1639                 read_unlock(&tasklist_lock);
1640         }
1641
1642         /*
1643          * While in TASK_TRACED, we were considered "frozen enough".
1644          * Now that we woke up, it's crucial if we're supposed to be
1645          * frozen that we freeze now before running anything substantial.
1646          */
1647         try_to_freeze();
1648
1649         /*
1650          * We are back.  Now reacquire the siglock before touching
1651          * last_siginfo, so that we are sure to have synchronized with
1652          * any signal-sending on another CPU that wants to examine it.
1653          */
1654         spin_lock_irq(&current->sighand->siglock);
1655         current->last_siginfo = NULL;
1656
1657         /*
1658          * Queued signals ignored us while we were stopped for tracing.
1659          * So check for any that we should take before resuming user mode.
1660          * This sets TIF_SIGPENDING, but never clears it.
1661          */
1662         recalc_sigpending_tsk(current);
1663 }
1664
1665 void ptrace_notify(int exit_code)
1666 {
1667         siginfo_t info;
1668
1669         BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1670
1671         memset(&info, 0, sizeof info);
1672         info.si_signo = SIGTRAP;
1673         info.si_code = exit_code;
1674         info.si_pid = task_pid_vnr(current);
1675         info.si_uid = current->uid;
1676
1677         /* Let the debugger run.  */
1678         spin_lock_irq(&current->sighand->siglock);
1679         ptrace_stop(exit_code, 1, &info);
1680         spin_unlock_irq(&current->sighand->siglock);
1681 }
1682
1683 static void
1684 finish_stop(int stop_count)
1685 {
1686         /*
1687          * If there are no other threads in the group, or if there is
1688          * a group stop in progress and we are the last to stop,
1689          * report to the parent.  When ptraced, every thread reports itself.
1690          */
1691         if (stop_count == 0 || (current->ptrace & PT_PTRACED)) {
1692                 read_lock(&tasklist_lock);
1693                 do_notify_parent_cldstop(current, CLD_STOPPED);
1694                 read_unlock(&tasklist_lock);
1695         }
1696
1697         do {
1698                 schedule();
1699         } while (try_to_freeze());
1700         /*
1701          * Now we don't run again until continued.
1702          */
1703         current->exit_code = 0;
1704 }
1705
1706 /*
1707  * This performs the stopping for SIGSTOP and other stop signals.
1708  * We have to stop all threads in the thread group.
1709  * Returns nonzero if we've actually stopped and released the siglock.
1710  * Returns zero if we didn't stop and still hold the siglock.
1711  */
1712 static int do_signal_stop(int signr)
1713 {
1714         struct signal_struct *sig = current->signal;
1715         int stop_count;
1716
1717         if (sig->group_stop_count > 0) {
1718                 /*
1719                  * There is a group stop in progress.  We don't need to
1720                  * start another one.
1721                  */
1722                 stop_count = --sig->group_stop_count;
1723         } else {
1724                 struct task_struct *t;
1725
1726                 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
1727                     unlikely(sig->group_exit_task))
1728                         return 0;
1729                 /*
1730                  * There is no group stop already in progress.
1731                  * We must initiate one now.
1732                  */
1733                 sig->group_exit_code = signr;
1734
1735                 stop_count = 0;
1736                 for (t = next_thread(current); t != current; t = next_thread(t))
1737                         /*
1738                          * Setting state to TASK_STOPPED for a group
1739                          * stop is always done with the siglock held,
1740                          * so this check has no races.
1741                          */
1742                         if (!(t->flags & PF_EXITING) &&
1743                             !task_is_stopped_or_traced(t)) {
1744                                 stop_count++;
1745                                 signal_wake_up(t, 0);
1746                         }
1747                 sig->group_stop_count = stop_count;
1748         }
1749
1750         if (stop_count == 0)
1751                 sig->flags = SIGNAL_STOP_STOPPED;
1752         current->exit_code = sig->group_exit_code;
1753         __set_current_state(TASK_STOPPED);
1754
1755         spin_unlock_irq(&current->sighand->siglock);
1756         finish_stop(stop_count);
1757         return 1;
1758 }
1759
1760 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1761                           struct pt_regs *regs, void *cookie)
1762 {
1763         sigset_t *mask = &current->blocked;
1764         int signr = 0;
1765
1766 relock:
1767         /*
1768          * We'll jump back here after any time we were stopped in TASK_STOPPED.
1769          * While in TASK_STOPPED, we were considered "frozen enough".
1770          * Now that we woke up, it's crucial if we're supposed to be
1771          * frozen that we freeze now before running anything substantial.
1772          */
1773         try_to_freeze();
1774
1775         spin_lock_irq(&current->sighand->siglock);
1776         for (;;) {
1777                 struct k_sigaction *ka;
1778
1779                 if (unlikely(current->signal->group_stop_count > 0) &&
1780                     do_signal_stop(0))
1781                         goto relock;
1782
1783                 signr = dequeue_signal(current, mask, info);
1784
1785                 if (!signr)
1786                         break; /* will return 0 */
1787
1788                 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1789                         ptrace_signal_deliver(regs, cookie);
1790
1791                         /* Let the debugger run.  */
1792                         ptrace_stop(signr, 0, info);
1793
1794                         /* We're back.  Did the debugger cancel the sig?  */
1795                         signr = current->exit_code;
1796                         if (signr == 0)
1797                                 continue;
1798
1799                         current->exit_code = 0;
1800
1801                         /* Update the siginfo structure if the signal has
1802                            changed.  If the debugger wanted something
1803                            specific in the siginfo structure then it should
1804                            have updated *info via PTRACE_SETSIGINFO.  */
1805                         if (signr != info->si_signo) {
1806                                 info->si_signo = signr;
1807                                 info->si_errno = 0;
1808                                 info->si_code = SI_USER;
1809                                 info->si_pid = task_pid_vnr(current->parent);
1810                                 info->si_uid = current->parent->uid;
1811                         }
1812
1813                         /* If the (new) signal is now blocked, requeue it.  */
1814                         if (sigismember(&current->blocked, signr)) {
1815                                 specific_send_sig_info(signr, info, current);
1816                                 continue;
1817                         }
1818                 }
1819
1820                 ka = &current->sighand->action[signr-1];
1821                 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
1822                         continue;
1823                 if (ka->sa.sa_handler != SIG_DFL) {
1824                         /* Run the handler.  */
1825                         *return_ka = *ka;
1826
1827                         if (ka->sa.sa_flags & SA_ONESHOT)
1828                                 ka->sa.sa_handler = SIG_DFL;
1829
1830                         break; /* will return non-zero "signr" value */
1831                 }
1832
1833                 /*
1834                  * Now we are doing the default action for this signal.
1835                  */
1836                 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1837                         continue;
1838
1839                 /*
1840                  * Global init gets no signals it doesn't want.
1841                  */
1842                 if (is_global_init(current))
1843                         continue;
1844
1845                 if (sig_kernel_stop(signr)) {
1846                         /*
1847                          * The default action is to stop all threads in
1848                          * the thread group.  The job control signals
1849                          * do nothing in an orphaned pgrp, but SIGSTOP
1850                          * always works.  Note that siglock needs to be
1851                          * dropped during the call to is_orphaned_pgrp()
1852                          * because of lock ordering with tasklist_lock.
1853                          * This allows an intervening SIGCONT to be posted.
1854                          * We need to check for that and bail out if necessary.
1855                          */
1856                         if (signr != SIGSTOP) {
1857                                 spin_unlock_irq(&current->sighand->siglock);
1858
1859                                 /* signals can be posted during this window */
1860
1861                                 if (is_current_pgrp_orphaned())
1862                                         goto relock;
1863
1864                                 spin_lock_irq(&current->sighand->siglock);
1865                         }
1866
1867                         if (likely(do_signal_stop(signr))) {
1868                                 /* It released the siglock.  */
1869                                 goto relock;
1870                         }
1871
1872                         /*
1873                          * We didn't actually stop, due to a race
1874                          * with SIGCONT or something like that.
1875                          */
1876                         continue;
1877                 }
1878
1879                 spin_unlock_irq(&current->sighand->siglock);
1880
1881                 /*
1882                  * Anything else is fatal, maybe with a core dump.
1883                  */
1884                 current->flags |= PF_SIGNALED;
1885                 if ((signr != SIGKILL) && print_fatal_signals)
1886                         print_fatal_signal(regs, signr);
1887                 if (sig_kernel_coredump(signr)) {
1888                         /*
1889                          * If it was able to dump core, this kills all
1890                          * other threads in the group and synchronizes with
1891                          * their demise.  If we lost the race with another
1892                          * thread getting here, it set group_exit_code
1893                          * first and our do_group_exit call below will use
1894                          * that value and ignore the one we pass it.
1895                          */
1896                         do_coredump((long)signr, signr, regs);
1897                 }
1898
1899                 /*
1900                  * Death signals, no core dump.
1901                  */
1902                 do_group_exit(signr);
1903                 /* NOTREACHED */
1904         }
1905         spin_unlock_irq(&current->sighand->siglock);
1906         return signr;
1907 }
1908
1909 void exit_signals(struct task_struct *tsk)
1910 {
1911         int group_stop = 0;
1912         struct task_struct *t;
1913
1914         if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
1915                 tsk->flags |= PF_EXITING;
1916                 return;
1917         }
1918
1919         spin_lock_irq(&tsk->sighand->siglock);
1920         /*
1921          * From now this task is not visible for group-wide signals,
1922          * see wants_signal(), do_signal_stop().
1923          */
1924         tsk->flags |= PF_EXITING;
1925         if (!signal_pending(tsk))
1926                 goto out;
1927
1928         /* It could be that __group_complete_signal() choose us to
1929          * notify about group-wide signal. Another thread should be
1930          * woken now to take the signal since we will not.
1931          */
1932         for (t = tsk; (t = next_thread(t)) != tsk; )
1933                 if (!signal_pending(t) && !(t->flags & PF_EXITING))
1934                         recalc_sigpending_and_wake(t);
1935
1936         if (unlikely(tsk->signal->group_stop_count) &&
1937                         !--tsk->signal->group_stop_count) {
1938                 tsk->signal->flags = SIGNAL_STOP_STOPPED;
1939                 group_stop = 1;
1940         }
1941 out:
1942         spin_unlock_irq(&tsk->sighand->siglock);
1943
1944         if (unlikely(group_stop)) {
1945                 read_lock(&tasklist_lock);
1946                 do_notify_parent_cldstop(tsk, CLD_STOPPED);
1947                 read_unlock(&tasklist_lock);
1948         }
1949 }
1950
1951 EXPORT_SYMBOL(recalc_sigpending);
1952 EXPORT_SYMBOL_GPL(dequeue_signal);
1953 EXPORT_SYMBOL(flush_signals);
1954 EXPORT_SYMBOL(force_sig);
1955 EXPORT_SYMBOL(kill_proc);
1956 EXPORT_SYMBOL(ptrace_notify);
1957 EXPORT_SYMBOL(send_sig);
1958 EXPORT_SYMBOL(send_sig_info);
1959 EXPORT_SYMBOL(sigprocmask);
1960 EXPORT_SYMBOL(block_all_signals);
1961 EXPORT_SYMBOL(unblock_all_signals);
1962
1963
1964 /*
1965  * System call entry points.
1966  */
1967
1968 asmlinkage long sys_restart_syscall(void)
1969 {
1970         struct restart_block *restart = &current_thread_info()->restart_block;
1971         return restart->fn(restart);
1972 }
1973
1974 long do_no_restart_syscall(struct restart_block *param)
1975 {
1976         return -EINTR;
1977 }
1978
1979 /*
1980  * We don't need to get the kernel lock - this is all local to this
1981  * particular thread.. (and that's good, because this is _heavily_
1982  * used by various programs)
1983  */
1984
1985 /*
1986  * This is also useful for kernel threads that want to temporarily
1987  * (or permanently) block certain signals.
1988  *
1989  * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1990  * interface happily blocks "unblockable" signals like SIGKILL
1991  * and friends.
1992  */
1993 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
1994 {
1995         int error;
1996
1997         spin_lock_irq(&current->sighand->siglock);
1998         if (oldset)
1999                 *oldset = current->blocked;
2000
2001         error = 0;
2002         switch (how) {
2003         case SIG_BLOCK:
2004                 sigorsets(&current->blocked, &current->blocked, set);
2005                 break;
2006         case SIG_UNBLOCK:
2007                 signandsets(&current->blocked, &current->blocked, set);
2008                 break;
2009         case SIG_SETMASK:
2010                 current->blocked = *set;
2011                 break;
2012         default:
2013                 error = -EINVAL;
2014         }
2015         recalc_sigpending();
2016         spin_unlock_irq(&current->sighand->siglock);
2017
2018         return error;
2019 }
2020
2021 asmlinkage long
2022 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
2023 {
2024         int error = -EINVAL;
2025         sigset_t old_set, new_set;
2026
2027         /* XXX: Don't preclude handling different sized sigset_t's.  */
2028         if (sigsetsize != sizeof(sigset_t))
2029                 goto out;
2030
2031         if (set) {
2032                 error = -EFAULT;
2033                 if (copy_from_user(&new_set, set, sizeof(*set)))
2034                         goto out;
2035                 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2036
2037                 error = sigprocmask(how, &new_set, &old_set);
2038                 if (error)
2039                         goto out;
2040                 if (oset)
2041                         goto set_old;
2042         } else if (oset) {
2043                 spin_lock_irq(&current->sighand->siglock);
2044                 old_set = current->blocked;
2045                 spin_unlock_irq(&current->sighand->siglock);
2046
2047         set_old:
2048                 error = -EFAULT;
2049                 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2050                         goto out;
2051         }
2052         error = 0;
2053 out:
2054         return error;
2055 }
2056
2057 long do_sigpending(void __user *set, unsigned long sigsetsize)
2058 {
2059         long error = -EINVAL;
2060         sigset_t pending;
2061
2062         if (sigsetsize > sizeof(sigset_t))
2063                 goto out;
2064
2065         spin_lock_irq(&current->sighand->siglock);
2066         sigorsets(&pending, &current->pending.signal,
2067                   &current->signal->shared_pending.signal);
2068         spin_unlock_irq(&current->sighand->siglock);
2069
2070         /* Outside the lock because only this thread touches it.  */
2071         sigandsets(&pending, &current->blocked, &pending);
2072
2073         error = -EFAULT;
2074         if (!copy_to_user(set, &pending, sigsetsize))
2075                 error = 0;
2076
2077 out:
2078         return error;
2079 }
2080
2081 asmlinkage long
2082 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2083 {
2084         return do_sigpending(set, sigsetsize);
2085 }
2086
2087 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2088
2089 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2090 {
2091         int err;
2092
2093         if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2094                 return -EFAULT;
2095         if (from->si_code < 0)
2096                 return __copy_to_user(to, from, sizeof(siginfo_t))
2097                         ? -EFAULT : 0;
2098         /*
2099          * If you change siginfo_t structure, please be sure
2100          * this code is fixed accordingly.
2101          * Please remember to update the signalfd_copyinfo() function
2102          * inside fs/signalfd.c too, in case siginfo_t changes.
2103          * It should never copy any pad contained in the structure
2104          * to avoid security leaks, but must copy the generic
2105          * 3 ints plus the relevant union member.
2106          */
2107         err = __put_user(from->si_signo, &to->si_signo);
2108         err |= __put_user(from->si_errno, &to->si_errno);
2109         err |= __put_user((short)from->si_code, &to->si_code);
2110         switch (from->si_code & __SI_MASK) {
2111         case __SI_KILL:
2112                 err |= __put_user(from->si_pid, &to->si_pid);
2113                 err |= __put_user(from->si_uid, &to->si_uid);
2114                 break;
2115         case __SI_TIMER:
2116                  err |= __put_user(from->si_tid, &to->si_tid);
2117                  err |= __put_user(from->si_overrun, &to->si_overrun);
2118                  err |= __put_user(from->si_ptr, &to->si_ptr);
2119                 break;
2120         case __SI_POLL:
2121                 err |= __put_user(from->si_band, &to->si_band);
2122                 err |= __put_user(from->si_fd, &to->si_fd);
2123                 break;
2124         case __SI_FAULT:
2125                 err |= __put_user(from->si_addr, &to->si_addr);
2126 #ifdef __ARCH_SI_TRAPNO
2127                 err |= __put_user(from->si_trapno, &to->si_trapno);
2128 #endif
2129                 break;
2130         case __SI_CHLD:
2131                 err |= __put_user(from->si_pid, &to->si_pid);
2132                 err |= __put_user(from->si_uid, &to->si_uid);
2133                 err |= __put_user(from->si_status, &to->si_status);
2134                 err |= __put_user(from->si_utime, &to->si_utime);
2135                 err |= __put_user(from->si_stime, &to->si_stime);
2136                 break;
2137         case __SI_RT: /* This is not generated by the kernel as of now. */
2138         case __SI_MESGQ: /* But this is */
2139                 err |= __put_user(from->si_pid, &to->si_pid);
2140                 err |= __put_user(from->si_uid, &to->si_uid);
2141                 err |= __put_user(from->si_ptr, &to->si_ptr);
2142                 break;
2143         default: /* this is just in case for now ... */
2144                 err |= __put_user(from->si_pid, &to->si_pid);
2145                 err |= __put_user(from->si_uid, &to->si_uid);
2146                 break;
2147         }
2148         return err;
2149 }
2150
2151 #endif
2152
2153 asmlinkage long
2154 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2155                     siginfo_t __user *uinfo,
2156                     const struct timespec __user *uts,
2157                     size_t sigsetsize)
2158 {
2159         int ret, sig;
2160         sigset_t these;
2161         struct timespec ts;
2162         siginfo_t info;
2163         long timeout = 0;
2164
2165         /* XXX: Don't preclude handling different sized sigset_t's.  */
2166         if (sigsetsize != sizeof(sigset_t))
2167                 return -EINVAL;
2168
2169         if (copy_from_user(&these, uthese, sizeof(these)))
2170                 return -EFAULT;
2171
2172         /*
2173          * Invert the set of allowed signals to get those we
2174          * want to block.
2175          */
2176         sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2177         signotset(&these);
2178
2179         if (uts) {
2180                 if (copy_from_user(&ts, uts, sizeof(ts)))
2181                         return -EFAULT;
2182                 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2183                     || ts.tv_sec < 0)
2184                         return -EINVAL;
2185         }
2186
2187         spin_lock_irq(&current->sighand->siglock);
2188         sig = dequeue_signal(current, &these, &info);
2189         if (!sig) {
2190                 timeout = MAX_SCHEDULE_TIMEOUT;
2191                 if (uts)
2192                         timeout = (timespec_to_jiffies(&ts)
2193                                    + (ts.tv_sec || ts.tv_nsec));
2194
2195                 if (timeout) {
2196                         /* None ready -- temporarily unblock those we're
2197                          * interested while we are sleeping in so that we'll
2198                          * be awakened when they arrive.  */
2199                         current->real_blocked = current->blocked;
2200                         sigandsets(&current->blocked, &current->blocked, &these);
2201                         recalc_sigpending();
2202                         spin_unlock_irq(&current->sighand->siglock);
2203
2204                         timeout = schedule_timeout_interruptible(timeout);
2205
2206                         spin_lock_irq(&current->sighand->siglock);
2207                         sig = dequeue_signal(current, &these, &info);
2208                         current->blocked = current->real_blocked;
2209                         siginitset(&current->real_blocked, 0);
2210                         recalc_sigpending();
2211                 }
2212         }
2213         spin_unlock_irq(&current->sighand->siglock);
2214
2215         if (sig) {
2216                 ret = sig;
2217                 if (uinfo) {
2218                         if (copy_siginfo_to_user(uinfo, &info))
2219                                 ret = -EFAULT;
2220                 }
2221         } else {
2222                 ret = -EAGAIN;
2223                 if (timeout)
2224                         ret = -EINTR;
2225         }
2226
2227         return ret;
2228 }
2229
2230 asmlinkage long
2231 sys_kill(int pid, int sig)
2232 {
2233         struct siginfo info;
2234
2235         info.si_signo = sig;
2236         info.si_errno = 0;
2237         info.si_code = SI_USER;
2238         info.si_pid = task_tgid_vnr(current);
2239         info.si_uid = current->uid;
2240
2241         return kill_something_info(sig, &info, pid);
2242 }
2243
2244 static int do_tkill(int tgid, int pid, int sig)
2245 {
2246         int error;
2247         struct siginfo info;
2248         struct task_struct *p;
2249
2250         error = -ESRCH;
2251         info.si_signo = sig;
2252         info.si_errno = 0;
2253         info.si_code = SI_TKILL;
2254         info.si_pid = task_tgid_vnr(current);
2255         info.si_uid = current->uid;
2256
2257         read_lock(&tasklist_lock);
2258         p = find_task_by_vpid(pid);
2259         if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2260                 error = check_kill_permission(sig, &info, p);
2261                 /*
2262                  * The null signal is a permissions and process existence
2263                  * probe.  No signal is actually delivered.
2264                  */
2265                 if (!error && sig && p->sighand) {
2266                         spin_lock_irq(&p->sighand->siglock);
2267                         handle_stop_signal(sig, p);
2268                         error = specific_send_sig_info(sig, &info, p);
2269                         spin_unlock_irq(&p->sighand->siglock);
2270                 }
2271         }
2272         read_unlock(&tasklist_lock);
2273
2274         return error;
2275 }
2276
2277 /**
2278  *  sys_tgkill - send signal to one specific thread
2279  *  @tgid: the thread group ID of the thread
2280  *  @pid: the PID of the thread
2281  *  @sig: signal to be sent
2282  *
2283  *  This syscall also checks the @tgid and returns -ESRCH even if the PID
2284  *  exists but it's not belonging to the target process anymore. This
2285  *  method solves the problem of threads exiting and PIDs getting reused.
2286  */
2287 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2288 {
2289         /* This is only valid for single tasks */
2290         if (pid <= 0 || tgid <= 0)
2291                 return -EINVAL;
2292
2293         return do_tkill(tgid, pid, sig);
2294 }
2295
2296 /*
2297  *  Send a signal to only one task, even if it's a CLONE_THREAD task.
2298  */
2299 asmlinkage long
2300 sys_tkill(int pid, int sig)
2301 {
2302         /* This is only valid for single tasks */
2303         if (pid <= 0)
2304                 return -EINVAL;
2305
2306         return do_tkill(0, pid, sig);
2307 }
2308
2309 asmlinkage long
2310 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2311 {
2312         siginfo_t info;
2313
2314         if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2315                 return -EFAULT;
2316
2317         /* Not even root can pretend to send signals from the kernel.
2318            Nor can they impersonate a kill(), which adds source info.  */
2319         if (info.si_code >= 0)
2320                 return -EPERM;
2321         info.si_signo = sig;
2322
2323         /* POSIX.1b doesn't mention process groups.  */
2324         return kill_proc_info(sig, &info, pid);
2325 }
2326
2327 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2328 {
2329         struct k_sigaction *k;
2330         sigset_t mask;
2331
2332         if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2333                 return -EINVAL;
2334
2335         k = &current->sighand->action[sig-1];
2336
2337         spin_lock_irq(&current->sighand->siglock);
2338         if (oact)
2339                 *oact = *k;
2340
2341         if (act) {
2342                 sigdelsetmask(&act->sa.sa_mask,
2343                               sigmask(SIGKILL) | sigmask(SIGSTOP));
2344                 *k = *act;
2345                 /*
2346                  * POSIX 3.3.1.3:
2347                  *  "Setting a signal action to SIG_IGN for a signal that is
2348                  *   pending shall cause the pending signal to be discarded,
2349                  *   whether or not it is blocked."
2350                  *
2351                  *  "Setting a signal action to SIG_DFL for a signal that is
2352                  *   pending and whose default action is to ignore the signal
2353                  *   (for example, SIGCHLD), shall cause the pending signal to
2354                  *   be discarded, whether or not it is blocked"
2355                  */
2356                 if (act->sa.sa_handler == SIG_IGN ||
2357                    (act->sa.sa_handler == SIG_DFL && sig_kernel_ignore(sig))) {
2358                         struct task_struct *t = current;
2359                         sigemptyset(&mask);
2360                         sigaddset(&mask, sig);
2361                         rm_from_queue_full(&mask, &t->signal->shared_pending);
2362                         do {
2363                                 rm_from_queue_full(&mask, &t->pending);
2364                                 t = next_thread(t);
2365                         } while (t != current);
2366                 }
2367         }
2368
2369         spin_unlock_irq(&current->sighand->siglock);
2370         return 0;
2371 }
2372
2373 int
2374 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2375 {
2376         stack_t oss;
2377         int error;
2378
2379         if (uoss) {
2380                 oss.ss_sp = (void __user *) current->sas_ss_sp;
2381                 oss.ss_size = current->sas_ss_size;
2382                 oss.ss_flags = sas_ss_flags(sp);
2383         }
2384
2385         if (uss) {
2386                 void __user *ss_sp;
2387                 size_t ss_size;
2388                 int ss_flags;
2389
2390                 error = -EFAULT;
2391                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2392                     || __get_user(ss_sp, &uss->ss_sp)
2393                     || __get_user(ss_flags, &uss->ss_flags)
2394                     || __get_user(ss_size, &uss->ss_size))
2395                         goto out;
2396
2397                 error = -EPERM;
2398                 if (on_sig_stack(sp))
2399                         goto out;
2400
2401                 error = -EINVAL;
2402                 /*
2403                  *
2404                  * Note - this code used to test ss_flags incorrectly
2405                  *        old code may have been written using ss_flags==0
2406                  *        to mean ss_flags==SS_ONSTACK (as this was the only
2407                  *        way that worked) - this fix preserves that older
2408                  *        mechanism
2409                  */
2410                 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2411                         goto out;
2412
2413                 if (ss_flags == SS_DISABLE) {
2414                         ss_size = 0;
2415                         ss_sp = NULL;
2416                 } else {
2417                         error = -ENOMEM;
2418                         if (ss_size < MINSIGSTKSZ)
2419                                 goto out;
2420                 }
2421
2422                 current->sas_ss_sp = (unsigned long) ss_sp;
2423                 current->sas_ss_size = ss_size;
2424         }
2425
2426         if (uoss) {
2427                 error = -EFAULT;
2428                 if (copy_to_user(uoss, &oss, sizeof(oss)))
2429                         goto out;
2430         }
2431
2432         error = 0;
2433 out:
2434         return error;
2435 }
2436
2437 #ifdef __ARCH_WANT_SYS_SIGPENDING
2438
2439 asmlinkage long
2440 sys_sigpending(old_sigset_t __user *set)
2441 {
2442         return do_sigpending(set, sizeof(*set));
2443 }
2444
2445 #endif
2446
2447 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2448 /* Some platforms have their own version with special arguments others
2449    support only sys_rt_sigprocmask.  */
2450
2451 asmlinkage long
2452 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2453 {
2454         int error;
2455         old_sigset_t old_set, new_set;
2456
2457         if (set) {
2458                 error = -EFAULT;
2459                 if (copy_from_user(&new_set, set, sizeof(*set)))
2460                         goto out;
2461                 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2462
2463                 spin_lock_irq(&current->sighand->siglock);
2464                 old_set = current->blocked.sig[0];
2465
2466                 error = 0;
2467                 switch (how) {
2468                 default:
2469                         error = -EINVAL;
2470                         break;
2471                 case SIG_BLOCK:
2472                         sigaddsetmask(&current->blocked, new_set);
2473                         break;
2474                 case SIG_UNBLOCK:
2475                         sigdelsetmask(&current->blocked, new_set);
2476                         break;
2477                 case SIG_SETMASK:
2478                         current->blocked.sig[0] = new_set;
2479                         break;
2480                 }
2481
2482                 recalc_sigpending();
2483                 spin_unlock_irq(&current->sighand->siglock);
2484                 if (error)
2485                         goto out;
2486                 if (oset)
2487                         goto set_old;
2488         } else if (oset) {
2489                 old_set = current->blocked.sig[0];
2490         set_old:
2491                 error = -EFAULT;
2492                 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2493                         goto out;
2494         }
2495         error = 0;
2496 out:
2497         return error;
2498 }
2499 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2500
2501 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2502 asmlinkage long
2503 sys_rt_sigaction(int sig,
2504                  const struct sigaction __user *act,
2505                  struct sigaction __user *oact,
2506                  size_t sigsetsize)
2507 {
2508         struct k_sigaction new_sa, old_sa;
2509         int ret = -EINVAL;
2510
2511         /* XXX: Don't preclude handling different sized sigset_t's.  */
2512         if (sigsetsize != sizeof(sigset_t))
2513                 goto out;
2514
2515         if (act) {
2516                 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2517                         return -EFAULT;
2518         }
2519
2520         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2521
2522         if (!ret && oact) {
2523                 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2524                         return -EFAULT;
2525         }
2526 out:
2527         return ret;
2528 }
2529 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2530
2531 #ifdef __ARCH_WANT_SYS_SGETMASK
2532
2533 /*
2534  * For backwards compatibility.  Functionality superseded by sigprocmask.
2535  */
2536 asmlinkage long
2537 sys_sgetmask(void)
2538 {
2539         /* SMP safe */
2540         return current->blocked.sig[0];
2541 }
2542
2543 asmlinkage long
2544 sys_ssetmask(int newmask)
2545 {
2546         int old;
2547
2548         spin_lock_irq(&current->sighand->siglock);
2549         old = current->blocked.sig[0];
2550
2551         siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2552                                                   sigmask(SIGSTOP)));
2553         recalc_sigpending();
2554         spin_unlock_irq(&current->sighand->siglock);
2555
2556         return old;
2557 }
2558 #endif /* __ARCH_WANT_SGETMASK */
2559
2560 #ifdef __ARCH_WANT_SYS_SIGNAL
2561 /*
2562  * For backwards compatibility.  Functionality superseded by sigaction.
2563  */
2564 asmlinkage unsigned long
2565 sys_signal(int sig, __sighandler_t handler)
2566 {
2567         struct k_sigaction new_sa, old_sa;
2568         int ret;
2569
2570         new_sa.sa.sa_handler = handler;
2571         new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2572         sigemptyset(&new_sa.sa.sa_mask);
2573
2574         ret = do_sigaction(sig, &new_sa, &old_sa);
2575
2576         return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2577 }
2578 #endif /* __ARCH_WANT_SYS_SIGNAL */
2579
2580 #ifdef __ARCH_WANT_SYS_PAUSE
2581
2582 asmlinkage long
2583 sys_pause(void)
2584 {
2585         current->state = TASK_INTERRUPTIBLE;
2586         schedule();
2587         return -ERESTARTNOHAND;
2588 }
2589
2590 #endif
2591
2592 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2593 asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2594 {
2595         sigset_t newset;
2596
2597         /* XXX: Don't preclude handling different sized sigset_t's.  */
2598         if (sigsetsize != sizeof(sigset_t))
2599                 return -EINVAL;
2600
2601         if (copy_from_user(&newset, unewset, sizeof(newset)))
2602                 return -EFAULT;
2603         sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2604
2605         spin_lock_irq(&current->sighand->siglock);
2606         current->saved_sigmask = current->blocked;
2607         current->blocked = newset;
2608         recalc_sigpending();
2609         spin_unlock_irq(&current->sighand->siglock);
2610
2611         current->state = TASK_INTERRUPTIBLE;
2612         schedule();
2613         set_thread_flag(TIF_RESTORE_SIGMASK);
2614         return -ERESTARTNOHAND;
2615 }
2616 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2617
2618 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2619 {
2620         return NULL;
2621 }
2622
2623 void __init signals_init(void)
2624 {
2625         sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
2626 }