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