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