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/export.h> 15 #include <linux/init.h> 16 #include <linux/sched/mm.h> 17 #include <linux/sched/user.h> 18 #include <linux/sched/debug.h> 19 #include <linux/sched/task.h> 20 #include <linux/sched/task_stack.h> 21 #include <linux/sched/cputime.h> 22 #include <linux/fs.h> 23 #include <linux/tty.h> 24 #include <linux/binfmts.h> 25 #include <linux/coredump.h> 26 #include <linux/security.h> 27 #include <linux/syscalls.h> 28 #include <linux/ptrace.h> 29 #include <linux/signal.h> 30 #include <linux/signalfd.h> 31 #include <linux/ratelimit.h> 32 #include <linux/tracehook.h> 33 #include <linux/capability.h> 34 #include <linux/freezer.h> 35 #include <linux/pid_namespace.h> 36 #include <linux/nsproxy.h> 37 #include <linux/user_namespace.h> 38 #include <linux/uprobes.h> 39 #include <linux/compat.h> 40 #include <linux/cn_proc.h> 41 #include <linux/compiler.h> 42 #include <linux/posix-timers.h> 43 44 #define CREATE_TRACE_POINTS 45 #include <trace/events/signal.h> 46 47 #include <asm/param.h> 48 #include <linux/uaccess.h> 49 #include <asm/unistd.h> 50 #include <asm/siginfo.h> 51 #include <asm/cacheflush.h> 52 #include "audit.h" /* audit_signal_info() */ 53 54 /* 55 * SLAB caches for signal bits. 56 */ 57 58 static struct kmem_cache *sigqueue_cachep; 59 60 int print_fatal_signals __read_mostly; 61 62 static void __user *sig_handler(struct task_struct *t, int sig) 63 { 64 return t->sighand->action[sig - 1].sa.sa_handler; 65 } 66 67 static int sig_handler_ignored(void __user *handler, int sig) 68 { 69 /* Is it explicitly or implicitly ignored? */ 70 return handler == SIG_IGN || 71 (handler == SIG_DFL && sig_kernel_ignore(sig)); 72 } 73 74 static int sig_task_ignored(struct task_struct *t, int sig, bool force) 75 { 76 void __user *handler; 77 78 handler = sig_handler(t, sig); 79 80 if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) && 81 handler == SIG_DFL && !force) 82 return 1; 83 84 return sig_handler_ignored(handler, sig); 85 } 86 87 static int sig_ignored(struct task_struct *t, int sig, bool force) 88 { 89 /* 90 * Blocked signals are never ignored, since the 91 * signal handler may change by the time it is 92 * unblocked. 93 */ 94 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig)) 95 return 0; 96 97 if (!sig_task_ignored(t, sig, force)) 98 return 0; 99 100 /* 101 * Tracers may want to know about even ignored signals. 102 */ 103 return !t->ptrace; 104 } 105 106 /* 107 * Re-calculate pending state from the set of locally pending 108 * signals, globally pending signals, and blocked signals. 109 */ 110 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked) 111 { 112 unsigned long ready; 113 long i; 114 115 switch (_NSIG_WORDS) { 116 default: 117 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;) 118 ready |= signal->sig[i] &~ blocked->sig[i]; 119 break; 120 121 case 4: ready = signal->sig[3] &~ blocked->sig[3]; 122 ready |= signal->sig[2] &~ blocked->sig[2]; 123 ready |= signal->sig[1] &~ blocked->sig[1]; 124 ready |= signal->sig[0] &~ blocked->sig[0]; 125 break; 126 127 case 2: ready = signal->sig[1] &~ blocked->sig[1]; 128 ready |= signal->sig[0] &~ blocked->sig[0]; 129 break; 130 131 case 1: ready = signal->sig[0] &~ blocked->sig[0]; 132 } 133 return ready != 0; 134 } 135 136 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b)) 137 138 static int recalc_sigpending_tsk(struct task_struct *t) 139 { 140 if ((t->jobctl & JOBCTL_PENDING_MASK) || 141 PENDING(&t->pending, &t->blocked) || 142 PENDING(&t->signal->shared_pending, &t->blocked)) { 143 set_tsk_thread_flag(t, TIF_SIGPENDING); 144 return 1; 145 } 146 /* 147 * We must never clear the flag in another thread, or in current 148 * when it's possible the current syscall is returning -ERESTART*. 149 * So we don't clear it here, and only callers who know they should do. 150 */ 151 return 0; 152 } 153 154 /* 155 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up. 156 * This is superfluous when called on current, the wakeup is a harmless no-op. 157 */ 158 void recalc_sigpending_and_wake(struct task_struct *t) 159 { 160 if (recalc_sigpending_tsk(t)) 161 signal_wake_up(t, 0); 162 } 163 164 void recalc_sigpending(void) 165 { 166 if (!recalc_sigpending_tsk(current) && !freezing(current)) 167 clear_thread_flag(TIF_SIGPENDING); 168 169 } 170 171 /* Given the mask, find the first available signal that should be serviced. */ 172 173 #define SYNCHRONOUS_MASK \ 174 (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \ 175 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS)) 176 177 int next_signal(struct sigpending *pending, sigset_t *mask) 178 { 179 unsigned long i, *s, *m, x; 180 int sig = 0; 181 182 s = pending->signal.sig; 183 m = mask->sig; 184 185 /* 186 * Handle the first word specially: it contains the 187 * synchronous signals that need to be dequeued first. 188 */ 189 x = *s &~ *m; 190 if (x) { 191 if (x & SYNCHRONOUS_MASK) 192 x &= SYNCHRONOUS_MASK; 193 sig = ffz(~x) + 1; 194 return sig; 195 } 196 197 switch (_NSIG_WORDS) { 198 default: 199 for (i = 1; i < _NSIG_WORDS; ++i) { 200 x = *++s &~ *++m; 201 if (!x) 202 continue; 203 sig = ffz(~x) + i*_NSIG_BPW + 1; 204 break; 205 } 206 break; 207 208 case 2: 209 x = s[1] &~ m[1]; 210 if (!x) 211 break; 212 sig = ffz(~x) + _NSIG_BPW + 1; 213 break; 214 215 case 1: 216 /* Nothing to do */ 217 break; 218 } 219 220 return sig; 221 } 222 223 static inline void print_dropped_signal(int sig) 224 { 225 static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10); 226 227 if (!print_fatal_signals) 228 return; 229 230 if (!__ratelimit(&ratelimit_state)) 231 return; 232 233 pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n", 234 current->comm, current->pid, sig); 235 } 236 237 /** 238 * task_set_jobctl_pending - set jobctl pending bits 239 * @task: target task 240 * @mask: pending bits to set 241 * 242 * Clear @mask from @task->jobctl. @mask must be subset of 243 * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK | 244 * %JOBCTL_TRAPPING. If stop signo is being set, the existing signo is 245 * cleared. If @task is already being killed or exiting, this function 246 * becomes noop. 247 * 248 * CONTEXT: 249 * Must be called with @task->sighand->siglock held. 250 * 251 * RETURNS: 252 * %true if @mask is set, %false if made noop because @task was dying. 253 */ 254 bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask) 255 { 256 BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME | 257 JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING)); 258 BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK)); 259 260 if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING))) 261 return false; 262 263 if (mask & JOBCTL_STOP_SIGMASK) 264 task->jobctl &= ~JOBCTL_STOP_SIGMASK; 265 266 task->jobctl |= mask; 267 return true; 268 } 269 270 /** 271 * task_clear_jobctl_trapping - clear jobctl trapping bit 272 * @task: target task 273 * 274 * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED. 275 * Clear it and wake up the ptracer. Note that we don't need any further 276 * locking. @task->siglock guarantees that @task->parent points to the 277 * ptracer. 278 * 279 * CONTEXT: 280 * Must be called with @task->sighand->siglock held. 281 */ 282 void task_clear_jobctl_trapping(struct task_struct *task) 283 { 284 if (unlikely(task->jobctl & JOBCTL_TRAPPING)) { 285 task->jobctl &= ~JOBCTL_TRAPPING; 286 smp_mb(); /* advised by wake_up_bit() */ 287 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT); 288 } 289 } 290 291 /** 292 * task_clear_jobctl_pending - clear jobctl pending bits 293 * @task: target task 294 * @mask: pending bits to clear 295 * 296 * Clear @mask from @task->jobctl. @mask must be subset of 297 * %JOBCTL_PENDING_MASK. If %JOBCTL_STOP_PENDING is being cleared, other 298 * STOP bits are cleared together. 299 * 300 * If clearing of @mask leaves no stop or trap pending, this function calls 301 * task_clear_jobctl_trapping(). 302 * 303 * CONTEXT: 304 * Must be called with @task->sighand->siglock held. 305 */ 306 void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask) 307 { 308 BUG_ON(mask & ~JOBCTL_PENDING_MASK); 309 310 if (mask & JOBCTL_STOP_PENDING) 311 mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED; 312 313 task->jobctl &= ~mask; 314 315 if (!(task->jobctl & JOBCTL_PENDING_MASK)) 316 task_clear_jobctl_trapping(task); 317 } 318 319 /** 320 * task_participate_group_stop - participate in a group stop 321 * @task: task participating in a group stop 322 * 323 * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop. 324 * Group stop states are cleared and the group stop count is consumed if 325 * %JOBCTL_STOP_CONSUME was set. If the consumption completes the group 326 * stop, the appropriate %SIGNAL_* flags are set. 327 * 328 * CONTEXT: 329 * Must be called with @task->sighand->siglock held. 330 * 331 * RETURNS: 332 * %true if group stop completion should be notified to the parent, %false 333 * otherwise. 334 */ 335 static bool task_participate_group_stop(struct task_struct *task) 336 { 337 struct signal_struct *sig = task->signal; 338 bool consume = task->jobctl & JOBCTL_STOP_CONSUME; 339 340 WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING)); 341 342 task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING); 343 344 if (!consume) 345 return false; 346 347 if (!WARN_ON_ONCE(sig->group_stop_count == 0)) 348 sig->group_stop_count--; 349 350 /* 351 * Tell the caller to notify completion iff we are entering into a 352 * fresh group stop. Read comment in do_signal_stop() for details. 353 */ 354 if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) { 355 signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED); 356 return true; 357 } 358 return false; 359 } 360 361 /* 362 * allocate a new signal queue record 363 * - this may be called without locks if and only if t == current, otherwise an 364 * appropriate lock must be held to stop the target task from exiting 365 */ 366 static struct sigqueue * 367 __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit) 368 { 369 struct sigqueue *q = NULL; 370 struct user_struct *user; 371 372 /* 373 * Protect access to @t credentials. This can go away when all 374 * callers hold rcu read lock. 375 */ 376 rcu_read_lock(); 377 user = get_uid(__task_cred(t)->user); 378 atomic_inc(&user->sigpending); 379 rcu_read_unlock(); 380 381 if (override_rlimit || 382 atomic_read(&user->sigpending) <= 383 task_rlimit(t, RLIMIT_SIGPENDING)) { 384 q = kmem_cache_alloc(sigqueue_cachep, flags); 385 } else { 386 print_dropped_signal(sig); 387 } 388 389 if (unlikely(q == NULL)) { 390 atomic_dec(&user->sigpending); 391 free_uid(user); 392 } else { 393 INIT_LIST_HEAD(&q->list); 394 q->flags = 0; 395 q->user = user; 396 } 397 398 return q; 399 } 400 401 static void __sigqueue_free(struct sigqueue *q) 402 { 403 if (q->flags & SIGQUEUE_PREALLOC) 404 return; 405 atomic_dec(&q->user->sigpending); 406 free_uid(q->user); 407 kmem_cache_free(sigqueue_cachep, q); 408 } 409 410 void flush_sigqueue(struct sigpending *queue) 411 { 412 struct sigqueue *q; 413 414 sigemptyset(&queue->signal); 415 while (!list_empty(&queue->list)) { 416 q = list_entry(queue->list.next, struct sigqueue , list); 417 list_del_init(&q->list); 418 __sigqueue_free(q); 419 } 420 } 421 422 /* 423 * Flush all pending signals for this kthread. 424 */ 425 void flush_signals(struct task_struct *t) 426 { 427 unsigned long flags; 428 429 spin_lock_irqsave(&t->sighand->siglock, flags); 430 clear_tsk_thread_flag(t, TIF_SIGPENDING); 431 flush_sigqueue(&t->pending); 432 flush_sigqueue(&t->signal->shared_pending); 433 spin_unlock_irqrestore(&t->sighand->siglock, flags); 434 } 435 436 #ifdef CONFIG_POSIX_TIMERS 437 static void __flush_itimer_signals(struct sigpending *pending) 438 { 439 sigset_t signal, retain; 440 struct sigqueue *q, *n; 441 442 signal = pending->signal; 443 sigemptyset(&retain); 444 445 list_for_each_entry_safe(q, n, &pending->list, list) { 446 int sig = q->info.si_signo; 447 448 if (likely(q->info.si_code != SI_TIMER)) { 449 sigaddset(&retain, sig); 450 } else { 451 sigdelset(&signal, sig); 452 list_del_init(&q->list); 453 __sigqueue_free(q); 454 } 455 } 456 457 sigorsets(&pending->signal, &signal, &retain); 458 } 459 460 void flush_itimer_signals(void) 461 { 462 struct task_struct *tsk = current; 463 unsigned long flags; 464 465 spin_lock_irqsave(&tsk->sighand->siglock, flags); 466 __flush_itimer_signals(&tsk->pending); 467 __flush_itimer_signals(&tsk->signal->shared_pending); 468 spin_unlock_irqrestore(&tsk->sighand->siglock, flags); 469 } 470 #endif 471 472 void ignore_signals(struct task_struct *t) 473 { 474 int i; 475 476 for (i = 0; i < _NSIG; ++i) 477 t->sighand->action[i].sa.sa_handler = SIG_IGN; 478 479 flush_signals(t); 480 } 481 482 /* 483 * Flush all handlers for a task. 484 */ 485 486 void 487 flush_signal_handlers(struct task_struct *t, int force_default) 488 { 489 int i; 490 struct k_sigaction *ka = &t->sighand->action[0]; 491 for (i = _NSIG ; i != 0 ; i--) { 492 if (force_default || ka->sa.sa_handler != SIG_IGN) 493 ka->sa.sa_handler = SIG_DFL; 494 ka->sa.sa_flags = 0; 495 #ifdef __ARCH_HAS_SA_RESTORER 496 ka->sa.sa_restorer = NULL; 497 #endif 498 sigemptyset(&ka->sa.sa_mask); 499 ka++; 500 } 501 } 502 503 int unhandled_signal(struct task_struct *tsk, int sig) 504 { 505 void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler; 506 if (is_global_init(tsk)) 507 return 1; 508 if (handler != SIG_IGN && handler != SIG_DFL) 509 return 0; 510 /* if ptraced, let the tracer determine */ 511 return !tsk->ptrace; 512 } 513 514 static void collect_signal(int sig, struct sigpending *list, siginfo_t *info, 515 bool *resched_timer) 516 { 517 struct sigqueue *q, *first = NULL; 518 519 /* 520 * Collect the siginfo appropriate to this signal. Check if 521 * there is another siginfo for the same signal. 522 */ 523 list_for_each_entry(q, &list->list, list) { 524 if (q->info.si_signo == sig) { 525 if (first) 526 goto still_pending; 527 first = q; 528 } 529 } 530 531 sigdelset(&list->signal, sig); 532 533 if (first) { 534 still_pending: 535 list_del_init(&first->list); 536 copy_siginfo(info, &first->info); 537 538 *resched_timer = 539 (first->flags & SIGQUEUE_PREALLOC) && 540 (info->si_code == SI_TIMER) && 541 (info->si_sys_private); 542 543 __sigqueue_free(first); 544 } else { 545 /* 546 * Ok, it wasn't in the queue. This must be 547 * a fast-pathed signal or we must have been 548 * out of queue space. So zero out the info. 549 */ 550 info->si_signo = sig; 551 info->si_errno = 0; 552 info->si_code = SI_USER; 553 info->si_pid = 0; 554 info->si_uid = 0; 555 } 556 } 557 558 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask, 559 siginfo_t *info, bool *resched_timer) 560 { 561 int sig = next_signal(pending, mask); 562 563 if (sig) 564 collect_signal(sig, pending, info, resched_timer); 565 return sig; 566 } 567 568 /* 569 * Dequeue a signal and return the element to the caller, which is 570 * expected to free it. 571 * 572 * All callers have to hold the siglock. 573 */ 574 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info) 575 { 576 bool resched_timer = false; 577 int signr; 578 579 /* We only dequeue private signals from ourselves, we don't let 580 * signalfd steal them 581 */ 582 signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer); 583 if (!signr) { 584 signr = __dequeue_signal(&tsk->signal->shared_pending, 585 mask, info, &resched_timer); 586 #ifdef CONFIG_POSIX_TIMERS 587 /* 588 * itimer signal ? 589 * 590 * itimers are process shared and we restart periodic 591 * itimers in the signal delivery path to prevent DoS 592 * attacks in the high resolution timer case. This is 593 * compliant with the old way of self-restarting 594 * itimers, as the SIGALRM is a legacy signal and only 595 * queued once. Changing the restart behaviour to 596 * restart the timer in the signal dequeue path is 597 * reducing the timer noise on heavy loaded !highres 598 * systems too. 599 */ 600 if (unlikely(signr == SIGALRM)) { 601 struct hrtimer *tmr = &tsk->signal->real_timer; 602 603 if (!hrtimer_is_queued(tmr) && 604 tsk->signal->it_real_incr != 0) { 605 hrtimer_forward(tmr, tmr->base->get_time(), 606 tsk->signal->it_real_incr); 607 hrtimer_restart(tmr); 608 } 609 } 610 #endif 611 } 612 613 recalc_sigpending(); 614 if (!signr) 615 return 0; 616 617 if (unlikely(sig_kernel_stop(signr))) { 618 /* 619 * Set a marker that we have dequeued a stop signal. Our 620 * caller might release the siglock and then the pending 621 * stop signal it is about to process is no longer in the 622 * pending bitmasks, but must still be cleared by a SIGCONT 623 * (and overruled by a SIGKILL). So those cases clear this 624 * shared flag after we've set it. Note that this flag may 625 * remain set after the signal we return is ignored or 626 * handled. That doesn't matter because its only purpose 627 * is to alert stop-signal processing code when another 628 * processor has come along and cleared the flag. 629 */ 630 current->jobctl |= JOBCTL_STOP_DEQUEUED; 631 } 632 #ifdef CONFIG_POSIX_TIMERS 633 if (resched_timer) { 634 /* 635 * Release the siglock to ensure proper locking order 636 * of timer locks outside of siglocks. Note, we leave 637 * irqs disabled here, since the posix-timers code is 638 * about to disable them again anyway. 639 */ 640 spin_unlock(&tsk->sighand->siglock); 641 posixtimer_rearm(info); 642 spin_lock(&tsk->sighand->siglock); 643 } 644 #endif 645 return signr; 646 } 647 648 /* 649 * Tell a process that it has a new active signal.. 650 * 651 * NOTE! we rely on the previous spin_lock to 652 * lock interrupts for us! We can only be called with 653 * "siglock" held, and the local interrupt must 654 * have been disabled when that got acquired! 655 * 656 * No need to set need_resched since signal event passing 657 * goes through ->blocked 658 */ 659 void signal_wake_up_state(struct task_struct *t, unsigned int state) 660 { 661 set_tsk_thread_flag(t, TIF_SIGPENDING); 662 /* 663 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable 664 * case. We don't check t->state here because there is a race with it 665 * executing another processor and just now entering stopped state. 666 * By using wake_up_state, we ensure the process will wake up and 667 * handle its death signal. 668 */ 669 if (!wake_up_state(t, state | TASK_INTERRUPTIBLE)) 670 kick_process(t); 671 } 672 673 /* 674 * Remove signals in mask from the pending set and queue. 675 * Returns 1 if any signals were found. 676 * 677 * All callers must be holding the siglock. 678 */ 679 static int flush_sigqueue_mask(sigset_t *mask, struct sigpending *s) 680 { 681 struct sigqueue *q, *n; 682 sigset_t m; 683 684 sigandsets(&m, mask, &s->signal); 685 if (sigisemptyset(&m)) 686 return 0; 687 688 sigandnsets(&s->signal, &s->signal, mask); 689 list_for_each_entry_safe(q, n, &s->list, list) { 690 if (sigismember(mask, q->info.si_signo)) { 691 list_del_init(&q->list); 692 __sigqueue_free(q); 693 } 694 } 695 return 1; 696 } 697 698 static inline int is_si_special(const struct siginfo *info) 699 { 700 return info <= SEND_SIG_FORCED; 701 } 702 703 static inline bool si_fromuser(const struct siginfo *info) 704 { 705 return info == SEND_SIG_NOINFO || 706 (!is_si_special(info) && SI_FROMUSER(info)); 707 } 708 709 /* 710 * called with RCU read lock from check_kill_permission() 711 */ 712 static int kill_ok_by_cred(struct task_struct *t) 713 { 714 const struct cred *cred = current_cred(); 715 const struct cred *tcred = __task_cred(t); 716 717 if (uid_eq(cred->euid, tcred->suid) || 718 uid_eq(cred->euid, tcred->uid) || 719 uid_eq(cred->uid, tcred->suid) || 720 uid_eq(cred->uid, tcred->uid)) 721 return 1; 722 723 if (ns_capable(tcred->user_ns, CAP_KILL)) 724 return 1; 725 726 return 0; 727 } 728 729 /* 730 * Bad permissions for sending the signal 731 * - the caller must hold the RCU read lock 732 */ 733 static int check_kill_permission(int sig, struct siginfo *info, 734 struct task_struct *t) 735 { 736 struct pid *sid; 737 int error; 738 739 if (!valid_signal(sig)) 740 return -EINVAL; 741 742 if (!si_fromuser(info)) 743 return 0; 744 745 error = audit_signal_info(sig, t); /* Let audit system see the signal */ 746 if (error) 747 return error; 748 749 if (!same_thread_group(current, t) && 750 !kill_ok_by_cred(t)) { 751 switch (sig) { 752 case SIGCONT: 753 sid = task_session(t); 754 /* 755 * We don't return the error if sid == NULL. The 756 * task was unhashed, the caller must notice this. 757 */ 758 if (!sid || sid == task_session(current)) 759 break; 760 default: 761 return -EPERM; 762 } 763 } 764 765 return security_task_kill(t, info, sig, 0); 766 } 767 768 /** 769 * ptrace_trap_notify - schedule trap to notify ptracer 770 * @t: tracee wanting to notify tracer 771 * 772 * This function schedules sticky ptrace trap which is cleared on the next 773 * TRAP_STOP to notify ptracer of an event. @t must have been seized by 774 * ptracer. 775 * 776 * If @t is running, STOP trap will be taken. If trapped for STOP and 777 * ptracer is listening for events, tracee is woken up so that it can 778 * re-trap for the new event. If trapped otherwise, STOP trap will be 779 * eventually taken without returning to userland after the existing traps 780 * are finished by PTRACE_CONT. 781 * 782 * CONTEXT: 783 * Must be called with @task->sighand->siglock held. 784 */ 785 static void ptrace_trap_notify(struct task_struct *t) 786 { 787 WARN_ON_ONCE(!(t->ptrace & PT_SEIZED)); 788 assert_spin_locked(&t->sighand->siglock); 789 790 task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY); 791 ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING); 792 } 793 794 /* 795 * Handle magic process-wide effects of stop/continue signals. Unlike 796 * the signal actions, these happen immediately at signal-generation 797 * time regardless of blocking, ignoring, or handling. This does the 798 * actual continuing for SIGCONT, but not the actual stopping for stop 799 * signals. The process stop is done as a signal action for SIG_DFL. 800 * 801 * Returns true if the signal should be actually delivered, otherwise 802 * it should be dropped. 803 */ 804 static bool prepare_signal(int sig, struct task_struct *p, bool force) 805 { 806 struct signal_struct *signal = p->signal; 807 struct task_struct *t; 808 sigset_t flush; 809 810 if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) { 811 if (!(signal->flags & SIGNAL_GROUP_EXIT)) 812 return sig == SIGKILL; 813 /* 814 * The process is in the middle of dying, nothing to do. 815 */ 816 } else if (sig_kernel_stop(sig)) { 817 /* 818 * This is a stop signal. Remove SIGCONT from all queues. 819 */ 820 siginitset(&flush, sigmask(SIGCONT)); 821 flush_sigqueue_mask(&flush, &signal->shared_pending); 822 for_each_thread(p, t) 823 flush_sigqueue_mask(&flush, &t->pending); 824 } else if (sig == SIGCONT) { 825 unsigned int why; 826 /* 827 * Remove all stop signals from all queues, wake all threads. 828 */ 829 siginitset(&flush, SIG_KERNEL_STOP_MASK); 830 flush_sigqueue_mask(&flush, &signal->shared_pending); 831 for_each_thread(p, t) { 832 flush_sigqueue_mask(&flush, &t->pending); 833 task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING); 834 if (likely(!(t->ptrace & PT_SEIZED))) 835 wake_up_state(t, __TASK_STOPPED); 836 else 837 ptrace_trap_notify(t); 838 } 839 840 /* 841 * Notify the parent with CLD_CONTINUED if we were stopped. 842 * 843 * If we were in the middle of a group stop, we pretend it 844 * was already finished, and then continued. Since SIGCHLD 845 * doesn't queue we report only CLD_STOPPED, as if the next 846 * CLD_CONTINUED was dropped. 847 */ 848 why = 0; 849 if (signal->flags & SIGNAL_STOP_STOPPED) 850 why |= SIGNAL_CLD_CONTINUED; 851 else if (signal->group_stop_count) 852 why |= SIGNAL_CLD_STOPPED; 853 854 if (why) { 855 /* 856 * The first thread which returns from do_signal_stop() 857 * will take ->siglock, notice SIGNAL_CLD_MASK, and 858 * notify its parent. See get_signal_to_deliver(). 859 */ 860 signal_set_stop_flags(signal, why | SIGNAL_STOP_CONTINUED); 861 signal->group_stop_count = 0; 862 signal->group_exit_code = 0; 863 } 864 } 865 866 return !sig_ignored(p, sig, force); 867 } 868 869 /* 870 * Test if P wants to take SIG. After we've checked all threads with this, 871 * it's equivalent to finding no threads not blocking SIG. Any threads not 872 * blocking SIG were ruled out because they are not running and already 873 * have pending signals. Such threads will dequeue from the shared queue 874 * as soon as they're available, so putting the signal on the shared queue 875 * will be equivalent to sending it to one such thread. 876 */ 877 static inline int wants_signal(int sig, struct task_struct *p) 878 { 879 if (sigismember(&p->blocked, sig)) 880 return 0; 881 if (p->flags & PF_EXITING) 882 return 0; 883 if (sig == SIGKILL) 884 return 1; 885 if (task_is_stopped_or_traced(p)) 886 return 0; 887 return task_curr(p) || !signal_pending(p); 888 } 889 890 static void complete_signal(int sig, struct task_struct *p, int group) 891 { 892 struct signal_struct *signal = p->signal; 893 struct task_struct *t; 894 895 /* 896 * Now find a thread we can wake up to take the signal off the queue. 897 * 898 * If the main thread wants the signal, it gets first crack. 899 * Probably the least surprising to the average bear. 900 */ 901 if (wants_signal(sig, p)) 902 t = p; 903 else if (!group || thread_group_empty(p)) 904 /* 905 * There is just one thread and it does not need to be woken. 906 * It will dequeue unblocked signals before it runs again. 907 */ 908 return; 909 else { 910 /* 911 * Otherwise try to find a suitable thread. 912 */ 913 t = signal->curr_target; 914 while (!wants_signal(sig, t)) { 915 t = next_thread(t); 916 if (t == signal->curr_target) 917 /* 918 * No thread needs to be woken. 919 * Any eligible threads will see 920 * the signal in the queue soon. 921 */ 922 return; 923 } 924 signal->curr_target = t; 925 } 926 927 /* 928 * Found a killable thread. If the signal will be fatal, 929 * then start taking the whole group down immediately. 930 */ 931 if (sig_fatal(p, sig) && 932 !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) && 933 !sigismember(&t->real_blocked, sig) && 934 (sig == SIGKILL || !t->ptrace)) { 935 /* 936 * This signal will be fatal to the whole group. 937 */ 938 if (!sig_kernel_coredump(sig)) { 939 /* 940 * Start a group exit and wake everybody up. 941 * This way we don't have other threads 942 * running and doing things after a slower 943 * thread has the fatal signal pending. 944 */ 945 signal->flags = SIGNAL_GROUP_EXIT; 946 signal->group_exit_code = sig; 947 signal->group_stop_count = 0; 948 t = p; 949 do { 950 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK); 951 sigaddset(&t->pending.signal, SIGKILL); 952 signal_wake_up(t, 1); 953 } while_each_thread(p, t); 954 return; 955 } 956 } 957 958 /* 959 * The signal is already in the shared-pending queue. 960 * Tell the chosen thread to wake up and dequeue it. 961 */ 962 signal_wake_up(t, sig == SIGKILL); 963 return; 964 } 965 966 static inline int legacy_queue(struct sigpending *signals, int sig) 967 { 968 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig); 969 } 970 971 #ifdef CONFIG_USER_NS 972 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t) 973 { 974 if (current_user_ns() == task_cred_xxx(t, user_ns)) 975 return; 976 977 if (SI_FROMKERNEL(info)) 978 return; 979 980 rcu_read_lock(); 981 info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns), 982 make_kuid(current_user_ns(), info->si_uid)); 983 rcu_read_unlock(); 984 } 985 #else 986 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t) 987 { 988 return; 989 } 990 #endif 991 992 static int __send_signal(int sig, struct siginfo *info, struct task_struct *t, 993 int group, int from_ancestor_ns) 994 { 995 struct sigpending *pending; 996 struct sigqueue *q; 997 int override_rlimit; 998 int ret = 0, result; 999 1000 assert_spin_locked(&t->sighand->siglock); 1001 1002 result = TRACE_SIGNAL_IGNORED; 1003 if (!prepare_signal(sig, t, 1004 from_ancestor_ns || (info == SEND_SIG_FORCED))) 1005 goto ret; 1006 1007 pending = group ? &t->signal->shared_pending : &t->pending; 1008 /* 1009 * Short-circuit ignored signals and support queuing 1010 * exactly one non-rt signal, so that we can get more 1011 * detailed information about the cause of the signal. 1012 */ 1013 result = TRACE_SIGNAL_ALREADY_PENDING; 1014 if (legacy_queue(pending, sig)) 1015 goto ret; 1016 1017 result = TRACE_SIGNAL_DELIVERED; 1018 /* 1019 * fast-pathed signals for kernel-internal things like SIGSTOP 1020 * or SIGKILL. 1021 */ 1022 if (info == SEND_SIG_FORCED) 1023 goto out_set; 1024 1025 /* 1026 * Real-time signals must be queued if sent by sigqueue, or 1027 * some other real-time mechanism. It is implementation 1028 * defined whether kill() does so. We attempt to do so, on 1029 * the principle of least surprise, but since kill is not 1030 * allowed to fail with EAGAIN when low on memory we just 1031 * make sure at least one signal gets delivered and don't 1032 * pass on the info struct. 1033 */ 1034 if (sig < SIGRTMIN) 1035 override_rlimit = (is_si_special(info) || info->si_code >= 0); 1036 else 1037 override_rlimit = 0; 1038 1039 q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE, 1040 override_rlimit); 1041 if (q) { 1042 list_add_tail(&q->list, &pending->list); 1043 switch ((unsigned long) info) { 1044 case (unsigned long) SEND_SIG_NOINFO: 1045 q->info.si_signo = sig; 1046 q->info.si_errno = 0; 1047 q->info.si_code = SI_USER; 1048 q->info.si_pid = task_tgid_nr_ns(current, 1049 task_active_pid_ns(t)); 1050 q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid()); 1051 break; 1052 case (unsigned long) SEND_SIG_PRIV: 1053 q->info.si_signo = sig; 1054 q->info.si_errno = 0; 1055 q->info.si_code = SI_KERNEL; 1056 q->info.si_pid = 0; 1057 q->info.si_uid = 0; 1058 break; 1059 default: 1060 copy_siginfo(&q->info, info); 1061 if (from_ancestor_ns) 1062 q->info.si_pid = 0; 1063 break; 1064 } 1065 1066 userns_fixup_signal_uid(&q->info, t); 1067 1068 } else if (!is_si_special(info)) { 1069 if (sig >= SIGRTMIN && info->si_code != SI_USER) { 1070 /* 1071 * Queue overflow, abort. We may abort if the 1072 * signal was rt and sent by user using something 1073 * other than kill(). 1074 */ 1075 result = TRACE_SIGNAL_OVERFLOW_FAIL; 1076 ret = -EAGAIN; 1077 goto ret; 1078 } else { 1079 /* 1080 * This is a silent loss of information. We still 1081 * send the signal, but the *info bits are lost. 1082 */ 1083 result = TRACE_SIGNAL_LOSE_INFO; 1084 } 1085 } 1086 1087 out_set: 1088 signalfd_notify(t, sig); 1089 sigaddset(&pending->signal, sig); 1090 complete_signal(sig, t, group); 1091 ret: 1092 trace_signal_generate(sig, info, t, group, result); 1093 return ret; 1094 } 1095 1096 static int send_signal(int sig, struct siginfo *info, struct task_struct *t, 1097 int group) 1098 { 1099 int from_ancestor_ns = 0; 1100 1101 #ifdef CONFIG_PID_NS 1102 from_ancestor_ns = si_fromuser(info) && 1103 !task_pid_nr_ns(current, task_active_pid_ns(t)); 1104 #endif 1105 1106 return __send_signal(sig, info, t, group, from_ancestor_ns); 1107 } 1108 1109 static void print_fatal_signal(int signr) 1110 { 1111 struct pt_regs *regs = signal_pt_regs(); 1112 pr_info("potentially unexpected fatal signal %d.\n", signr); 1113 1114 #if defined(__i386__) && !defined(__arch_um__) 1115 pr_info("code at %08lx: ", regs->ip); 1116 { 1117 int i; 1118 for (i = 0; i < 16; i++) { 1119 unsigned char insn; 1120 1121 if (get_user(insn, (unsigned char *)(regs->ip + i))) 1122 break; 1123 pr_cont("%02x ", insn); 1124 } 1125 } 1126 pr_cont("\n"); 1127 #endif 1128 preempt_disable(); 1129 show_regs(regs); 1130 preempt_enable(); 1131 } 1132 1133 static int __init setup_print_fatal_signals(char *str) 1134 { 1135 get_option (&str, &print_fatal_signals); 1136 1137 return 1; 1138 } 1139 1140 __setup("print-fatal-signals=", setup_print_fatal_signals); 1141 1142 int 1143 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p) 1144 { 1145 return send_signal(sig, info, p, 1); 1146 } 1147 1148 static int 1149 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t) 1150 { 1151 return send_signal(sig, info, t, 0); 1152 } 1153 1154 int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p, 1155 bool group) 1156 { 1157 unsigned long flags; 1158 int ret = -ESRCH; 1159 1160 if (lock_task_sighand(p, &flags)) { 1161 ret = send_signal(sig, info, p, group); 1162 unlock_task_sighand(p, &flags); 1163 } 1164 1165 return ret; 1166 } 1167 1168 /* 1169 * Force a signal that the process can't ignore: if necessary 1170 * we unblock the signal and change any SIG_IGN to SIG_DFL. 1171 * 1172 * Note: If we unblock the signal, we always reset it to SIG_DFL, 1173 * since we do not want to have a signal handler that was blocked 1174 * be invoked when user space had explicitly blocked it. 1175 * 1176 * We don't want to have recursive SIGSEGV's etc, for example, 1177 * that is why we also clear SIGNAL_UNKILLABLE. 1178 */ 1179 int 1180 force_sig_info(int sig, struct siginfo *info, struct task_struct *t) 1181 { 1182 unsigned long int flags; 1183 int ret, blocked, ignored; 1184 struct k_sigaction *action; 1185 1186 spin_lock_irqsave(&t->sighand->siglock, flags); 1187 action = &t->sighand->action[sig-1]; 1188 ignored = action->sa.sa_handler == SIG_IGN; 1189 blocked = sigismember(&t->blocked, sig); 1190 if (blocked || ignored) { 1191 action->sa.sa_handler = SIG_DFL; 1192 if (blocked) { 1193 sigdelset(&t->blocked, sig); 1194 recalc_sigpending_and_wake(t); 1195 } 1196 } 1197 /* 1198 * Don't clear SIGNAL_UNKILLABLE for traced tasks, users won't expect 1199 * debugging to leave init killable. 1200 */ 1201 if (action->sa.sa_handler == SIG_DFL && !t->ptrace) 1202 t->signal->flags &= ~SIGNAL_UNKILLABLE; 1203 ret = specific_send_sig_info(sig, info, t); 1204 spin_unlock_irqrestore(&t->sighand->siglock, flags); 1205 1206 return ret; 1207 } 1208 1209 /* 1210 * Nuke all other threads in the group. 1211 */ 1212 int zap_other_threads(struct task_struct *p) 1213 { 1214 struct task_struct *t = p; 1215 int count = 0; 1216 1217 p->signal->group_stop_count = 0; 1218 1219 while_each_thread(p, t) { 1220 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK); 1221 count++; 1222 1223 /* Don't bother with already dead threads */ 1224 if (t->exit_state) 1225 continue; 1226 sigaddset(&t->pending.signal, SIGKILL); 1227 signal_wake_up(t, 1); 1228 } 1229 1230 return count; 1231 } 1232 1233 struct sighand_struct *__lock_task_sighand(struct task_struct *tsk, 1234 unsigned long *flags) 1235 { 1236 struct sighand_struct *sighand; 1237 1238 for (;;) { 1239 /* 1240 * Disable interrupts early to avoid deadlocks. 1241 * See rcu_read_unlock() comment header for details. 1242 */ 1243 local_irq_save(*flags); 1244 rcu_read_lock(); 1245 sighand = rcu_dereference(tsk->sighand); 1246 if (unlikely(sighand == NULL)) { 1247 rcu_read_unlock(); 1248 local_irq_restore(*flags); 1249 break; 1250 } 1251 /* 1252 * This sighand can be already freed and even reused, but 1253 * we rely on SLAB_TYPESAFE_BY_RCU and sighand_ctor() which 1254 * initializes ->siglock: this slab can't go away, it has 1255 * the same object type, ->siglock can't be reinitialized. 1256 * 1257 * We need to ensure that tsk->sighand is still the same 1258 * after we take the lock, we can race with de_thread() or 1259 * __exit_signal(). In the latter case the next iteration 1260 * must see ->sighand == NULL. 1261 */ 1262 spin_lock(&sighand->siglock); 1263 if (likely(sighand == tsk->sighand)) { 1264 rcu_read_unlock(); 1265 break; 1266 } 1267 spin_unlock(&sighand->siglock); 1268 rcu_read_unlock(); 1269 local_irq_restore(*flags); 1270 } 1271 1272 return sighand; 1273 } 1274 1275 /* 1276 * send signal info to all the members of a group 1277 */ 1278 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p) 1279 { 1280 int ret; 1281 1282 rcu_read_lock(); 1283 ret = check_kill_permission(sig, info, p); 1284 rcu_read_unlock(); 1285 1286 if (!ret && sig) 1287 ret = do_send_sig_info(sig, info, p, true); 1288 1289 return ret; 1290 } 1291 1292 /* 1293 * __kill_pgrp_info() sends a signal to a process group: this is what the tty 1294 * control characters do (^C, ^Z etc) 1295 * - the caller must hold at least a readlock on tasklist_lock 1296 */ 1297 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp) 1298 { 1299 struct task_struct *p = NULL; 1300 int retval, success; 1301 1302 success = 0; 1303 retval = -ESRCH; 1304 do_each_pid_task(pgrp, PIDTYPE_PGID, p) { 1305 int err = group_send_sig_info(sig, info, p); 1306 success |= !err; 1307 retval = err; 1308 } while_each_pid_task(pgrp, PIDTYPE_PGID, p); 1309 return success ? 0 : retval; 1310 } 1311 1312 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid) 1313 { 1314 int error = -ESRCH; 1315 struct task_struct *p; 1316 1317 for (;;) { 1318 rcu_read_lock(); 1319 p = pid_task(pid, PIDTYPE_PID); 1320 if (p) 1321 error = group_send_sig_info(sig, info, p); 1322 rcu_read_unlock(); 1323 if (likely(!p || error != -ESRCH)) 1324 return error; 1325 1326 /* 1327 * The task was unhashed in between, try again. If it 1328 * is dead, pid_task() will return NULL, if we race with 1329 * de_thread() it will find the new leader. 1330 */ 1331 } 1332 } 1333 1334 static int kill_proc_info(int sig, struct siginfo *info, pid_t pid) 1335 { 1336 int error; 1337 rcu_read_lock(); 1338 error = kill_pid_info(sig, info, find_vpid(pid)); 1339 rcu_read_unlock(); 1340 return error; 1341 } 1342 1343 static int kill_as_cred_perm(const struct cred *cred, 1344 struct task_struct *target) 1345 { 1346 const struct cred *pcred = __task_cred(target); 1347 if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) && 1348 !uid_eq(cred->uid, pcred->suid) && !uid_eq(cred->uid, pcred->uid)) 1349 return 0; 1350 return 1; 1351 } 1352 1353 /* like kill_pid_info(), but doesn't use uid/euid of "current" */ 1354 int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid, 1355 const struct cred *cred, u32 secid) 1356 { 1357 int ret = -EINVAL; 1358 struct task_struct *p; 1359 unsigned long flags; 1360 1361 if (!valid_signal(sig)) 1362 return ret; 1363 1364 rcu_read_lock(); 1365 p = pid_task(pid, PIDTYPE_PID); 1366 if (!p) { 1367 ret = -ESRCH; 1368 goto out_unlock; 1369 } 1370 if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) { 1371 ret = -EPERM; 1372 goto out_unlock; 1373 } 1374 ret = security_task_kill(p, info, sig, secid); 1375 if (ret) 1376 goto out_unlock; 1377 1378 if (sig) { 1379 if (lock_task_sighand(p, &flags)) { 1380 ret = __send_signal(sig, info, p, 1, 0); 1381 unlock_task_sighand(p, &flags); 1382 } else 1383 ret = -ESRCH; 1384 } 1385 out_unlock: 1386 rcu_read_unlock(); 1387 return ret; 1388 } 1389 EXPORT_SYMBOL_GPL(kill_pid_info_as_cred); 1390 1391 /* 1392 * kill_something_info() interprets pid in interesting ways just like kill(2). 1393 * 1394 * POSIX specifies that kill(-1,sig) is unspecified, but what we have 1395 * is probably wrong. Should make it like BSD or SYSV. 1396 */ 1397 1398 static int kill_something_info(int sig, struct siginfo *info, pid_t pid) 1399 { 1400 int ret; 1401 1402 if (pid > 0) { 1403 rcu_read_lock(); 1404 ret = kill_pid_info(sig, info, find_vpid(pid)); 1405 rcu_read_unlock(); 1406 return ret; 1407 } 1408 1409 /* -INT_MIN is undefined. Exclude this case to avoid a UBSAN warning */ 1410 if (pid == INT_MIN) 1411 return -ESRCH; 1412 1413 read_lock(&tasklist_lock); 1414 if (pid != -1) { 1415 ret = __kill_pgrp_info(sig, info, 1416 pid ? find_vpid(-pid) : task_pgrp(current)); 1417 } else { 1418 int retval = 0, count = 0; 1419 struct task_struct * p; 1420 1421 for_each_process(p) { 1422 if (task_pid_vnr(p) > 1 && 1423 !same_thread_group(p, current)) { 1424 int err = group_send_sig_info(sig, info, p); 1425 ++count; 1426 if (err != -EPERM) 1427 retval = err; 1428 } 1429 } 1430 ret = count ? retval : -ESRCH; 1431 } 1432 read_unlock(&tasklist_lock); 1433 1434 return ret; 1435 } 1436 1437 /* 1438 * These are for backward compatibility with the rest of the kernel source. 1439 */ 1440 1441 int send_sig_info(int sig, struct siginfo *info, struct task_struct *p) 1442 { 1443 /* 1444 * Make sure legacy kernel users don't send in bad values 1445 * (normal paths check this in check_kill_permission). 1446 */ 1447 if (!valid_signal(sig)) 1448 return -EINVAL; 1449 1450 return do_send_sig_info(sig, info, p, false); 1451 } 1452 1453 #define __si_special(priv) \ 1454 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO) 1455 1456 int 1457 send_sig(int sig, struct task_struct *p, int priv) 1458 { 1459 return send_sig_info(sig, __si_special(priv), p); 1460 } 1461 1462 void 1463 force_sig(int sig, struct task_struct *p) 1464 { 1465 force_sig_info(sig, SEND_SIG_PRIV, p); 1466 } 1467 1468 /* 1469 * When things go south during signal handling, we 1470 * will force a SIGSEGV. And if the signal that caused 1471 * the problem was already a SIGSEGV, we'll want to 1472 * make sure we don't even try to deliver the signal.. 1473 */ 1474 int 1475 force_sigsegv(int sig, struct task_struct *p) 1476 { 1477 if (sig == SIGSEGV) { 1478 unsigned long flags; 1479 spin_lock_irqsave(&p->sighand->siglock, flags); 1480 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL; 1481 spin_unlock_irqrestore(&p->sighand->siglock, flags); 1482 } 1483 force_sig(SIGSEGV, p); 1484 return 0; 1485 } 1486 1487 int kill_pgrp(struct pid *pid, int sig, int priv) 1488 { 1489 int ret; 1490 1491 read_lock(&tasklist_lock); 1492 ret = __kill_pgrp_info(sig, __si_special(priv), pid); 1493 read_unlock(&tasklist_lock); 1494 1495 return ret; 1496 } 1497 EXPORT_SYMBOL(kill_pgrp); 1498 1499 int kill_pid(struct pid *pid, int sig, int priv) 1500 { 1501 return kill_pid_info(sig, __si_special(priv), pid); 1502 } 1503 EXPORT_SYMBOL(kill_pid); 1504 1505 /* 1506 * These functions support sending signals using preallocated sigqueue 1507 * structures. This is needed "because realtime applications cannot 1508 * afford to lose notifications of asynchronous events, like timer 1509 * expirations or I/O completions". In the case of POSIX Timers 1510 * we allocate the sigqueue structure from the timer_create. If this 1511 * allocation fails we are able to report the failure to the application 1512 * with an EAGAIN error. 1513 */ 1514 struct sigqueue *sigqueue_alloc(void) 1515 { 1516 struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0); 1517 1518 if (q) 1519 q->flags |= SIGQUEUE_PREALLOC; 1520 1521 return q; 1522 } 1523 1524 void sigqueue_free(struct sigqueue *q) 1525 { 1526 unsigned long flags; 1527 spinlock_t *lock = ¤t->sighand->siglock; 1528 1529 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC)); 1530 /* 1531 * We must hold ->siglock while testing q->list 1532 * to serialize with collect_signal() or with 1533 * __exit_signal()->flush_sigqueue(). 1534 */ 1535 spin_lock_irqsave(lock, flags); 1536 q->flags &= ~SIGQUEUE_PREALLOC; 1537 /* 1538 * If it is queued it will be freed when dequeued, 1539 * like the "regular" sigqueue. 1540 */ 1541 if (!list_empty(&q->list)) 1542 q = NULL; 1543 spin_unlock_irqrestore(lock, flags); 1544 1545 if (q) 1546 __sigqueue_free(q); 1547 } 1548 1549 int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group) 1550 { 1551 int sig = q->info.si_signo; 1552 struct sigpending *pending; 1553 unsigned long flags; 1554 int ret, result; 1555 1556 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC)); 1557 1558 ret = -1; 1559 if (!likely(lock_task_sighand(t, &flags))) 1560 goto ret; 1561 1562 ret = 1; /* the signal is ignored */ 1563 result = TRACE_SIGNAL_IGNORED; 1564 if (!prepare_signal(sig, t, false)) 1565 goto out; 1566 1567 ret = 0; 1568 if (unlikely(!list_empty(&q->list))) { 1569 /* 1570 * If an SI_TIMER entry is already queue just increment 1571 * the overrun count. 1572 */ 1573 BUG_ON(q->info.si_code != SI_TIMER); 1574 q->info.si_overrun++; 1575 result = TRACE_SIGNAL_ALREADY_PENDING; 1576 goto out; 1577 } 1578 q->info.si_overrun = 0; 1579 1580 signalfd_notify(t, sig); 1581 pending = group ? &t->signal->shared_pending : &t->pending; 1582 list_add_tail(&q->list, &pending->list); 1583 sigaddset(&pending->signal, sig); 1584 complete_signal(sig, t, group); 1585 result = TRACE_SIGNAL_DELIVERED; 1586 out: 1587 trace_signal_generate(sig, &q->info, t, group, result); 1588 unlock_task_sighand(t, &flags); 1589 ret: 1590 return ret; 1591 } 1592 1593 /* 1594 * Let a parent know about the death of a child. 1595 * For a stopped/continued status change, use do_notify_parent_cldstop instead. 1596 * 1597 * Returns true if our parent ignored us and so we've switched to 1598 * self-reaping. 1599 */ 1600 bool do_notify_parent(struct task_struct *tsk, int sig) 1601 { 1602 struct siginfo info; 1603 unsigned long flags; 1604 struct sighand_struct *psig; 1605 bool autoreap = false; 1606 u64 utime, stime; 1607 1608 BUG_ON(sig == -1); 1609 1610 /* do_notify_parent_cldstop should have been called instead. */ 1611 BUG_ON(task_is_stopped_or_traced(tsk)); 1612 1613 BUG_ON(!tsk->ptrace && 1614 (tsk->group_leader != tsk || !thread_group_empty(tsk))); 1615 1616 if (sig != SIGCHLD) { 1617 /* 1618 * This is only possible if parent == real_parent. 1619 * Check if it has changed security domain. 1620 */ 1621 if (tsk->parent_exec_id != tsk->parent->self_exec_id) 1622 sig = SIGCHLD; 1623 } 1624 1625 info.si_signo = sig; 1626 info.si_errno = 0; 1627 /* 1628 * We are under tasklist_lock here so our parent is tied to 1629 * us and cannot change. 1630 * 1631 * task_active_pid_ns will always return the same pid namespace 1632 * until a task passes through release_task. 1633 * 1634 * write_lock() currently calls preempt_disable() which is the 1635 * same as rcu_read_lock(), but according to Oleg, this is not 1636 * correct to rely on this 1637 */ 1638 rcu_read_lock(); 1639 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent)); 1640 info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns), 1641 task_uid(tsk)); 1642 rcu_read_unlock(); 1643 1644 task_cputime(tsk, &utime, &stime); 1645 info.si_utime = nsec_to_clock_t(utime + tsk->signal->utime); 1646 info.si_stime = nsec_to_clock_t(stime + tsk->signal->stime); 1647 1648 info.si_status = tsk->exit_code & 0x7f; 1649 if (tsk->exit_code & 0x80) 1650 info.si_code = CLD_DUMPED; 1651 else if (tsk->exit_code & 0x7f) 1652 info.si_code = CLD_KILLED; 1653 else { 1654 info.si_code = CLD_EXITED; 1655 info.si_status = tsk->exit_code >> 8; 1656 } 1657 1658 psig = tsk->parent->sighand; 1659 spin_lock_irqsave(&psig->siglock, flags); 1660 if (!tsk->ptrace && sig == SIGCHLD && 1661 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN || 1662 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) { 1663 /* 1664 * We are exiting and our parent doesn't care. POSIX.1 1665 * defines special semantics for setting SIGCHLD to SIG_IGN 1666 * or setting the SA_NOCLDWAIT flag: we should be reaped 1667 * automatically and not left for our parent's wait4 call. 1668 * Rather than having the parent do it as a magic kind of 1669 * signal handler, we just set this to tell do_exit that we 1670 * can be cleaned up without becoming a zombie. Note that 1671 * we still call __wake_up_parent in this case, because a 1672 * blocked sys_wait4 might now return -ECHILD. 1673 * 1674 * Whether we send SIGCHLD or not for SA_NOCLDWAIT 1675 * is implementation-defined: we do (if you don't want 1676 * it, just use SIG_IGN instead). 1677 */ 1678 autoreap = true; 1679 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) 1680 sig = 0; 1681 } 1682 if (valid_signal(sig) && sig) 1683 __group_send_sig_info(sig, &info, tsk->parent); 1684 __wake_up_parent(tsk, tsk->parent); 1685 spin_unlock_irqrestore(&psig->siglock, flags); 1686 1687 return autoreap; 1688 } 1689 1690 /** 1691 * do_notify_parent_cldstop - notify parent of stopped/continued state change 1692 * @tsk: task reporting the state change 1693 * @for_ptracer: the notification is for ptracer 1694 * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report 1695 * 1696 * Notify @tsk's parent that the stopped/continued state has changed. If 1697 * @for_ptracer is %false, @tsk's group leader notifies to its real parent. 1698 * If %true, @tsk reports to @tsk->parent which should be the ptracer. 1699 * 1700 * CONTEXT: 1701 * Must be called with tasklist_lock at least read locked. 1702 */ 1703 static void do_notify_parent_cldstop(struct task_struct *tsk, 1704 bool for_ptracer, int why) 1705 { 1706 struct siginfo info; 1707 unsigned long flags; 1708 struct task_struct *parent; 1709 struct sighand_struct *sighand; 1710 u64 utime, stime; 1711 1712 if (for_ptracer) { 1713 parent = tsk->parent; 1714 } else { 1715 tsk = tsk->group_leader; 1716 parent = tsk->real_parent; 1717 } 1718 1719 info.si_signo = SIGCHLD; 1720 info.si_errno = 0; 1721 /* 1722 * see comment in do_notify_parent() about the following 4 lines 1723 */ 1724 rcu_read_lock(); 1725 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent)); 1726 info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk)); 1727 rcu_read_unlock(); 1728 1729 task_cputime(tsk, &utime, &stime); 1730 info.si_utime = nsec_to_clock_t(utime); 1731 info.si_stime = nsec_to_clock_t(stime); 1732 1733 info.si_code = why; 1734 switch (why) { 1735 case CLD_CONTINUED: 1736 info.si_status = SIGCONT; 1737 break; 1738 case CLD_STOPPED: 1739 info.si_status = tsk->signal->group_exit_code & 0x7f; 1740 break; 1741 case CLD_TRAPPED: 1742 info.si_status = tsk->exit_code & 0x7f; 1743 break; 1744 default: 1745 BUG(); 1746 } 1747 1748 sighand = parent->sighand; 1749 spin_lock_irqsave(&sighand->siglock, flags); 1750 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN && 1751 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP)) 1752 __group_send_sig_info(SIGCHLD, &info, parent); 1753 /* 1754 * Even if SIGCHLD is not generated, we must wake up wait4 calls. 1755 */ 1756 __wake_up_parent(tsk, parent); 1757 spin_unlock_irqrestore(&sighand->siglock, flags); 1758 } 1759 1760 static inline int may_ptrace_stop(void) 1761 { 1762 if (!likely(current->ptrace)) 1763 return 0; 1764 /* 1765 * Are we in the middle of do_coredump? 1766 * If so and our tracer is also part of the coredump stopping 1767 * is a deadlock situation, and pointless because our tracer 1768 * is dead so don't allow us to stop. 1769 * If SIGKILL was already sent before the caller unlocked 1770 * ->siglock we must see ->core_state != NULL. Otherwise it 1771 * is safe to enter schedule(). 1772 * 1773 * This is almost outdated, a task with the pending SIGKILL can't 1774 * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported 1775 * after SIGKILL was already dequeued. 1776 */ 1777 if (unlikely(current->mm->core_state) && 1778 unlikely(current->mm == current->parent->mm)) 1779 return 0; 1780 1781 return 1; 1782 } 1783 1784 /* 1785 * Return non-zero if there is a SIGKILL that should be waking us up. 1786 * Called with the siglock held. 1787 */ 1788 static int sigkill_pending(struct task_struct *tsk) 1789 { 1790 return sigismember(&tsk->pending.signal, SIGKILL) || 1791 sigismember(&tsk->signal->shared_pending.signal, SIGKILL); 1792 } 1793 1794 /* 1795 * This must be called with current->sighand->siglock held. 1796 * 1797 * This should be the path for all ptrace stops. 1798 * We always set current->last_siginfo while stopped here. 1799 * That makes it a way to test a stopped process for 1800 * being ptrace-stopped vs being job-control-stopped. 1801 * 1802 * If we actually decide not to stop at all because the tracer 1803 * is gone, we keep current->exit_code unless clear_code. 1804 */ 1805 static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info) 1806 __releases(¤t->sighand->siglock) 1807 __acquires(¤t->sighand->siglock) 1808 { 1809 bool gstop_done = false; 1810 1811 if (arch_ptrace_stop_needed(exit_code, info)) { 1812 /* 1813 * The arch code has something special to do before a 1814 * ptrace stop. This is allowed to block, e.g. for faults 1815 * on user stack pages. We can't keep the siglock while 1816 * calling arch_ptrace_stop, so we must release it now. 1817 * To preserve proper semantics, we must do this before 1818 * any signal bookkeeping like checking group_stop_count. 1819 * Meanwhile, a SIGKILL could come in before we retake the 1820 * siglock. That must prevent us from sleeping in TASK_TRACED. 1821 * So after regaining the lock, we must check for SIGKILL. 1822 */ 1823 spin_unlock_irq(¤t->sighand->siglock); 1824 arch_ptrace_stop(exit_code, info); 1825 spin_lock_irq(¤t->sighand->siglock); 1826 if (sigkill_pending(current)) 1827 return; 1828 } 1829 1830 /* 1831 * We're committing to trapping. TRACED should be visible before 1832 * TRAPPING is cleared; otherwise, the tracer might fail do_wait(). 1833 * Also, transition to TRACED and updates to ->jobctl should be 1834 * atomic with respect to siglock and should be done after the arch 1835 * hook as siglock is released and regrabbed across it. 1836 */ 1837 set_current_state(TASK_TRACED); 1838 1839 current->last_siginfo = info; 1840 current->exit_code = exit_code; 1841 1842 /* 1843 * If @why is CLD_STOPPED, we're trapping to participate in a group 1844 * stop. Do the bookkeeping. Note that if SIGCONT was delievered 1845 * across siglock relocks since INTERRUPT was scheduled, PENDING 1846 * could be clear now. We act as if SIGCONT is received after 1847 * TASK_TRACED is entered - ignore it. 1848 */ 1849 if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING)) 1850 gstop_done = task_participate_group_stop(current); 1851 1852 /* any trap clears pending STOP trap, STOP trap clears NOTIFY */ 1853 task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP); 1854 if (info && info->si_code >> 8 == PTRACE_EVENT_STOP) 1855 task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY); 1856 1857 /* entering a trap, clear TRAPPING */ 1858 task_clear_jobctl_trapping(current); 1859 1860 spin_unlock_irq(¤t->sighand->siglock); 1861 read_lock(&tasklist_lock); 1862 if (may_ptrace_stop()) { 1863 /* 1864 * Notify parents of the stop. 1865 * 1866 * While ptraced, there are two parents - the ptracer and 1867 * the real_parent of the group_leader. The ptracer should 1868 * know about every stop while the real parent is only 1869 * interested in the completion of group stop. The states 1870 * for the two don't interact with each other. Notify 1871 * separately unless they're gonna be duplicates. 1872 */ 1873 do_notify_parent_cldstop(current, true, why); 1874 if (gstop_done && ptrace_reparented(current)) 1875 do_notify_parent_cldstop(current, false, why); 1876 1877 /* 1878 * Don't want to allow preemption here, because 1879 * sys_ptrace() needs this task to be inactive. 1880 * 1881 * XXX: implement read_unlock_no_resched(). 1882 */ 1883 preempt_disable(); 1884 read_unlock(&tasklist_lock); 1885 preempt_enable_no_resched(); 1886 freezable_schedule(); 1887 } else { 1888 /* 1889 * By the time we got the lock, our tracer went away. 1890 * Don't drop the lock yet, another tracer may come. 1891 * 1892 * If @gstop_done, the ptracer went away between group stop 1893 * completion and here. During detach, it would have set 1894 * JOBCTL_STOP_PENDING on us and we'll re-enter 1895 * TASK_STOPPED in do_signal_stop() on return, so notifying 1896 * the real parent of the group stop completion is enough. 1897 */ 1898 if (gstop_done) 1899 do_notify_parent_cldstop(current, false, why); 1900 1901 /* tasklist protects us from ptrace_freeze_traced() */ 1902 __set_current_state(TASK_RUNNING); 1903 if (clear_code) 1904 current->exit_code = 0; 1905 read_unlock(&tasklist_lock); 1906 } 1907 1908 /* 1909 * We are back. Now reacquire the siglock before touching 1910 * last_siginfo, so that we are sure to have synchronized with 1911 * any signal-sending on another CPU that wants to examine it. 1912 */ 1913 spin_lock_irq(¤t->sighand->siglock); 1914 current->last_siginfo = NULL; 1915 1916 /* LISTENING can be set only during STOP traps, clear it */ 1917 current->jobctl &= ~JOBCTL_LISTENING; 1918 1919 /* 1920 * Queued signals ignored us while we were stopped for tracing. 1921 * So check for any that we should take before resuming user mode. 1922 * This sets TIF_SIGPENDING, but never clears it. 1923 */ 1924 recalc_sigpending_tsk(current); 1925 } 1926 1927 static void ptrace_do_notify(int signr, int exit_code, int why) 1928 { 1929 siginfo_t info; 1930 1931 memset(&info, 0, sizeof info); 1932 info.si_signo = signr; 1933 info.si_code = exit_code; 1934 info.si_pid = task_pid_vnr(current); 1935 info.si_uid = from_kuid_munged(current_user_ns(), current_uid()); 1936 1937 /* Let the debugger run. */ 1938 ptrace_stop(exit_code, why, 1, &info); 1939 } 1940 1941 void ptrace_notify(int exit_code) 1942 { 1943 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP); 1944 if (unlikely(current->task_works)) 1945 task_work_run(); 1946 1947 spin_lock_irq(¤t->sighand->siglock); 1948 ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED); 1949 spin_unlock_irq(¤t->sighand->siglock); 1950 } 1951 1952 /** 1953 * do_signal_stop - handle group stop for SIGSTOP and other stop signals 1954 * @signr: signr causing group stop if initiating 1955 * 1956 * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr 1957 * and participate in it. If already set, participate in the existing 1958 * group stop. If participated in a group stop (and thus slept), %true is 1959 * returned with siglock released. 1960 * 1961 * If ptraced, this function doesn't handle stop itself. Instead, 1962 * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock 1963 * untouched. The caller must ensure that INTERRUPT trap handling takes 1964 * places afterwards. 1965 * 1966 * CONTEXT: 1967 * Must be called with @current->sighand->siglock held, which is released 1968 * on %true return. 1969 * 1970 * RETURNS: 1971 * %false if group stop is already cancelled or ptrace trap is scheduled. 1972 * %true if participated in group stop. 1973 */ 1974 static bool do_signal_stop(int signr) 1975 __releases(¤t->sighand->siglock) 1976 { 1977 struct signal_struct *sig = current->signal; 1978 1979 if (!(current->jobctl & JOBCTL_STOP_PENDING)) { 1980 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME; 1981 struct task_struct *t; 1982 1983 /* signr will be recorded in task->jobctl for retries */ 1984 WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK); 1985 1986 if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) || 1987 unlikely(signal_group_exit(sig))) 1988 return false; 1989 /* 1990 * There is no group stop already in progress. We must 1991 * initiate one now. 1992 * 1993 * While ptraced, a task may be resumed while group stop is 1994 * still in effect and then receive a stop signal and 1995 * initiate another group stop. This deviates from the 1996 * usual behavior as two consecutive stop signals can't 1997 * cause two group stops when !ptraced. That is why we 1998 * also check !task_is_stopped(t) below. 1999 * 2000 * The condition can be distinguished by testing whether 2001 * SIGNAL_STOP_STOPPED is already set. Don't generate 2002 * group_exit_code in such case. 2003 * 2004 * This is not necessary for SIGNAL_STOP_CONTINUED because 2005 * an intervening stop signal is required to cause two 2006 * continued events regardless of ptrace. 2007 */ 2008 if (!(sig->flags & SIGNAL_STOP_STOPPED)) 2009 sig->group_exit_code = signr; 2010 2011 sig->group_stop_count = 0; 2012 2013 if (task_set_jobctl_pending(current, signr | gstop)) 2014 sig->group_stop_count++; 2015 2016 t = current; 2017 while_each_thread(current, t) { 2018 /* 2019 * Setting state to TASK_STOPPED for a group 2020 * stop is always done with the siglock held, 2021 * so this check has no races. 2022 */ 2023 if (!task_is_stopped(t) && 2024 task_set_jobctl_pending(t, signr | gstop)) { 2025 sig->group_stop_count++; 2026 if (likely(!(t->ptrace & PT_SEIZED))) 2027 signal_wake_up(t, 0); 2028 else 2029 ptrace_trap_notify(t); 2030 } 2031 } 2032 } 2033 2034 if (likely(!current->ptrace)) { 2035 int notify = 0; 2036 2037 /* 2038 * If there are no other threads in the group, or if there 2039 * is a group stop in progress and we are the last to stop, 2040 * report to the parent. 2041 */ 2042 if (task_participate_group_stop(current)) 2043 notify = CLD_STOPPED; 2044 2045 __set_current_state(TASK_STOPPED); 2046 spin_unlock_irq(¤t->sighand->siglock); 2047 2048 /* 2049 * Notify the parent of the group stop completion. Because 2050 * we're not holding either the siglock or tasklist_lock 2051 * here, ptracer may attach inbetween; however, this is for 2052 * group stop and should always be delivered to the real 2053 * parent of the group leader. The new ptracer will get 2054 * its notification when this task transitions into 2055 * TASK_TRACED. 2056 */ 2057 if (notify) { 2058 read_lock(&tasklist_lock); 2059 do_notify_parent_cldstop(current, false, notify); 2060 read_unlock(&tasklist_lock); 2061 } 2062 2063 /* Now we don't run again until woken by SIGCONT or SIGKILL */ 2064 freezable_schedule(); 2065 return true; 2066 } else { 2067 /* 2068 * While ptraced, group stop is handled by STOP trap. 2069 * Schedule it and let the caller deal with it. 2070 */ 2071 task_set_jobctl_pending(current, JOBCTL_TRAP_STOP); 2072 return false; 2073 } 2074 } 2075 2076 /** 2077 * do_jobctl_trap - take care of ptrace jobctl traps 2078 * 2079 * When PT_SEIZED, it's used for both group stop and explicit 2080 * SEIZE/INTERRUPT traps. Both generate PTRACE_EVENT_STOP trap with 2081 * accompanying siginfo. If stopped, lower eight bits of exit_code contain 2082 * the stop signal; otherwise, %SIGTRAP. 2083 * 2084 * When !PT_SEIZED, it's used only for group stop trap with stop signal 2085 * number as exit_code and no siginfo. 2086 * 2087 * CONTEXT: 2088 * Must be called with @current->sighand->siglock held, which may be 2089 * released and re-acquired before returning with intervening sleep. 2090 */ 2091 static void do_jobctl_trap(void) 2092 { 2093 struct signal_struct *signal = current->signal; 2094 int signr = current->jobctl & JOBCTL_STOP_SIGMASK; 2095 2096 if (current->ptrace & PT_SEIZED) { 2097 if (!signal->group_stop_count && 2098 !(signal->flags & SIGNAL_STOP_STOPPED)) 2099 signr = SIGTRAP; 2100 WARN_ON_ONCE(!signr); 2101 ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8), 2102 CLD_STOPPED); 2103 } else { 2104 WARN_ON_ONCE(!signr); 2105 ptrace_stop(signr, CLD_STOPPED, 0, NULL); 2106 current->exit_code = 0; 2107 } 2108 } 2109 2110 static int ptrace_signal(int signr, siginfo_t *info) 2111 { 2112 /* 2113 * We do not check sig_kernel_stop(signr) but set this marker 2114 * unconditionally because we do not know whether debugger will 2115 * change signr. This flag has no meaning unless we are going 2116 * to stop after return from ptrace_stop(). In this case it will 2117 * be checked in do_signal_stop(), we should only stop if it was 2118 * not cleared by SIGCONT while we were sleeping. See also the 2119 * comment in dequeue_signal(). 2120 */ 2121 current->jobctl |= JOBCTL_STOP_DEQUEUED; 2122 ptrace_stop(signr, CLD_TRAPPED, 0, info); 2123 2124 /* We're back. Did the debugger cancel the sig? */ 2125 signr = current->exit_code; 2126 if (signr == 0) 2127 return signr; 2128 2129 current->exit_code = 0; 2130 2131 /* 2132 * Update the siginfo structure if the signal has 2133 * changed. If the debugger wanted something 2134 * specific in the siginfo structure then it should 2135 * have updated *info via PTRACE_SETSIGINFO. 2136 */ 2137 if (signr != info->si_signo) { 2138 info->si_signo = signr; 2139 info->si_errno = 0; 2140 info->si_code = SI_USER; 2141 rcu_read_lock(); 2142 info->si_pid = task_pid_vnr(current->parent); 2143 info->si_uid = from_kuid_munged(current_user_ns(), 2144 task_uid(current->parent)); 2145 rcu_read_unlock(); 2146 } 2147 2148 /* If the (new) signal is now blocked, requeue it. */ 2149 if (sigismember(¤t->blocked, signr)) { 2150 specific_send_sig_info(signr, info, current); 2151 signr = 0; 2152 } 2153 2154 return signr; 2155 } 2156 2157 int get_signal(struct ksignal *ksig) 2158 { 2159 struct sighand_struct *sighand = current->sighand; 2160 struct signal_struct *signal = current->signal; 2161 int signr; 2162 2163 if (unlikely(current->task_works)) 2164 task_work_run(); 2165 2166 if (unlikely(uprobe_deny_signal())) 2167 return 0; 2168 2169 /* 2170 * Do this once, we can't return to user-mode if freezing() == T. 2171 * do_signal_stop() and ptrace_stop() do freezable_schedule() and 2172 * thus do not need another check after return. 2173 */ 2174 try_to_freeze(); 2175 2176 relock: 2177 spin_lock_irq(&sighand->siglock); 2178 /* 2179 * Every stopped thread goes here after wakeup. Check to see if 2180 * we should notify the parent, prepare_signal(SIGCONT) encodes 2181 * the CLD_ si_code into SIGNAL_CLD_MASK bits. 2182 */ 2183 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) { 2184 int why; 2185 2186 if (signal->flags & SIGNAL_CLD_CONTINUED) 2187 why = CLD_CONTINUED; 2188 else 2189 why = CLD_STOPPED; 2190 2191 signal->flags &= ~SIGNAL_CLD_MASK; 2192 2193 spin_unlock_irq(&sighand->siglock); 2194 2195 /* 2196 * Notify the parent that we're continuing. This event is 2197 * always per-process and doesn't make whole lot of sense 2198 * for ptracers, who shouldn't consume the state via 2199 * wait(2) either, but, for backward compatibility, notify 2200 * the ptracer of the group leader too unless it's gonna be 2201 * a duplicate. 2202 */ 2203 read_lock(&tasklist_lock); 2204 do_notify_parent_cldstop(current, false, why); 2205 2206 if (ptrace_reparented(current->group_leader)) 2207 do_notify_parent_cldstop(current->group_leader, 2208 true, why); 2209 read_unlock(&tasklist_lock); 2210 2211 goto relock; 2212 } 2213 2214 for (;;) { 2215 struct k_sigaction *ka; 2216 2217 if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) && 2218 do_signal_stop(0)) 2219 goto relock; 2220 2221 if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) { 2222 do_jobctl_trap(); 2223 spin_unlock_irq(&sighand->siglock); 2224 goto relock; 2225 } 2226 2227 signr = dequeue_signal(current, ¤t->blocked, &ksig->info); 2228 2229 if (!signr) 2230 break; /* will return 0 */ 2231 2232 if (unlikely(current->ptrace) && signr != SIGKILL) { 2233 signr = ptrace_signal(signr, &ksig->info); 2234 if (!signr) 2235 continue; 2236 } 2237 2238 ka = &sighand->action[signr-1]; 2239 2240 /* Trace actually delivered signals. */ 2241 trace_signal_deliver(signr, &ksig->info, ka); 2242 2243 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */ 2244 continue; 2245 if (ka->sa.sa_handler != SIG_DFL) { 2246 /* Run the handler. */ 2247 ksig->ka = *ka; 2248 2249 if (ka->sa.sa_flags & SA_ONESHOT) 2250 ka->sa.sa_handler = SIG_DFL; 2251 2252 break; /* will return non-zero "signr" value */ 2253 } 2254 2255 /* 2256 * Now we are doing the default action for this signal. 2257 */ 2258 if (sig_kernel_ignore(signr)) /* Default is nothing. */ 2259 continue; 2260 2261 /* 2262 * Global init gets no signals it doesn't want. 2263 * Container-init gets no signals it doesn't want from same 2264 * container. 2265 * 2266 * Note that if global/container-init sees a sig_kernel_only() 2267 * signal here, the signal must have been generated internally 2268 * or must have come from an ancestor namespace. In either 2269 * case, the signal cannot be dropped. 2270 */ 2271 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) && 2272 !sig_kernel_only(signr)) 2273 continue; 2274 2275 if (sig_kernel_stop(signr)) { 2276 /* 2277 * The default action is to stop all threads in 2278 * the thread group. The job control signals 2279 * do nothing in an orphaned pgrp, but SIGSTOP 2280 * always works. Note that siglock needs to be 2281 * dropped during the call to is_orphaned_pgrp() 2282 * because of lock ordering with tasklist_lock. 2283 * This allows an intervening SIGCONT to be posted. 2284 * We need to check for that and bail out if necessary. 2285 */ 2286 if (signr != SIGSTOP) { 2287 spin_unlock_irq(&sighand->siglock); 2288 2289 /* signals can be posted during this window */ 2290 2291 if (is_current_pgrp_orphaned()) 2292 goto relock; 2293 2294 spin_lock_irq(&sighand->siglock); 2295 } 2296 2297 if (likely(do_signal_stop(ksig->info.si_signo))) { 2298 /* It released the siglock. */ 2299 goto relock; 2300 } 2301 2302 /* 2303 * We didn't actually stop, due to a race 2304 * with SIGCONT or something like that. 2305 */ 2306 continue; 2307 } 2308 2309 spin_unlock_irq(&sighand->siglock); 2310 2311 /* 2312 * Anything else is fatal, maybe with a core dump. 2313 */ 2314 current->flags |= PF_SIGNALED; 2315 2316 if (sig_kernel_coredump(signr)) { 2317 if (print_fatal_signals) 2318 print_fatal_signal(ksig->info.si_signo); 2319 proc_coredump_connector(current); 2320 /* 2321 * If it was able to dump core, this kills all 2322 * other threads in the group and synchronizes with 2323 * their demise. If we lost the race with another 2324 * thread getting here, it set group_exit_code 2325 * first and our do_group_exit call below will use 2326 * that value and ignore the one we pass it. 2327 */ 2328 do_coredump(&ksig->info); 2329 } 2330 2331 /* 2332 * Death signals, no core dump. 2333 */ 2334 do_group_exit(ksig->info.si_signo); 2335 /* NOTREACHED */ 2336 } 2337 spin_unlock_irq(&sighand->siglock); 2338 2339 ksig->sig = signr; 2340 return ksig->sig > 0; 2341 } 2342 2343 /** 2344 * signal_delivered - 2345 * @ksig: kernel signal struct 2346 * @stepping: nonzero if debugger single-step or block-step in use 2347 * 2348 * This function should be called when a signal has successfully been 2349 * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask 2350 * is always blocked, and the signal itself is blocked unless %SA_NODEFER 2351 * is set in @ksig->ka.sa.sa_flags. Tracing is notified. 2352 */ 2353 static void signal_delivered(struct ksignal *ksig, int stepping) 2354 { 2355 sigset_t blocked; 2356 2357 /* A signal was successfully delivered, and the 2358 saved sigmask was stored on the signal frame, 2359 and will be restored by sigreturn. So we can 2360 simply clear the restore sigmask flag. */ 2361 clear_restore_sigmask(); 2362 2363 sigorsets(&blocked, ¤t->blocked, &ksig->ka.sa.sa_mask); 2364 if (!(ksig->ka.sa.sa_flags & SA_NODEFER)) 2365 sigaddset(&blocked, ksig->sig); 2366 set_current_blocked(&blocked); 2367 tracehook_signal_handler(stepping); 2368 } 2369 2370 void signal_setup_done(int failed, struct ksignal *ksig, int stepping) 2371 { 2372 if (failed) 2373 force_sigsegv(ksig->sig, current); 2374 else 2375 signal_delivered(ksig, stepping); 2376 } 2377 2378 /* 2379 * It could be that complete_signal() picked us to notify about the 2380 * group-wide signal. Other threads should be notified now to take 2381 * the shared signals in @which since we will not. 2382 */ 2383 static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which) 2384 { 2385 sigset_t retarget; 2386 struct task_struct *t; 2387 2388 sigandsets(&retarget, &tsk->signal->shared_pending.signal, which); 2389 if (sigisemptyset(&retarget)) 2390 return; 2391 2392 t = tsk; 2393 while_each_thread(tsk, t) { 2394 if (t->flags & PF_EXITING) 2395 continue; 2396 2397 if (!has_pending_signals(&retarget, &t->blocked)) 2398 continue; 2399 /* Remove the signals this thread can handle. */ 2400 sigandsets(&retarget, &retarget, &t->blocked); 2401 2402 if (!signal_pending(t)) 2403 signal_wake_up(t, 0); 2404 2405 if (sigisemptyset(&retarget)) 2406 break; 2407 } 2408 } 2409 2410 void exit_signals(struct task_struct *tsk) 2411 { 2412 int group_stop = 0; 2413 sigset_t unblocked; 2414 2415 /* 2416 * @tsk is about to have PF_EXITING set - lock out users which 2417 * expect stable threadgroup. 2418 */ 2419 cgroup_threadgroup_change_begin(tsk); 2420 2421 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) { 2422 tsk->flags |= PF_EXITING; 2423 cgroup_threadgroup_change_end(tsk); 2424 return; 2425 } 2426 2427 spin_lock_irq(&tsk->sighand->siglock); 2428 /* 2429 * From now this task is not visible for group-wide signals, 2430 * see wants_signal(), do_signal_stop(). 2431 */ 2432 tsk->flags |= PF_EXITING; 2433 2434 cgroup_threadgroup_change_end(tsk); 2435 2436 if (!signal_pending(tsk)) 2437 goto out; 2438 2439 unblocked = tsk->blocked; 2440 signotset(&unblocked); 2441 retarget_shared_pending(tsk, &unblocked); 2442 2443 if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) && 2444 task_participate_group_stop(tsk)) 2445 group_stop = CLD_STOPPED; 2446 out: 2447 spin_unlock_irq(&tsk->sighand->siglock); 2448 2449 /* 2450 * If group stop has completed, deliver the notification. This 2451 * should always go to the real parent of the group leader. 2452 */ 2453 if (unlikely(group_stop)) { 2454 read_lock(&tasklist_lock); 2455 do_notify_parent_cldstop(tsk, false, group_stop); 2456 read_unlock(&tasklist_lock); 2457 } 2458 } 2459 2460 EXPORT_SYMBOL(recalc_sigpending); 2461 EXPORT_SYMBOL_GPL(dequeue_signal); 2462 EXPORT_SYMBOL(flush_signals); 2463 EXPORT_SYMBOL(force_sig); 2464 EXPORT_SYMBOL(send_sig); 2465 EXPORT_SYMBOL(send_sig_info); 2466 EXPORT_SYMBOL(sigprocmask); 2467 2468 /* 2469 * System call entry points. 2470 */ 2471 2472 /** 2473 * sys_restart_syscall - restart a system call 2474 */ 2475 SYSCALL_DEFINE0(restart_syscall) 2476 { 2477 struct restart_block *restart = ¤t->restart_block; 2478 return restart->fn(restart); 2479 } 2480 2481 long do_no_restart_syscall(struct restart_block *param) 2482 { 2483 return -EINTR; 2484 } 2485 2486 static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset) 2487 { 2488 if (signal_pending(tsk) && !thread_group_empty(tsk)) { 2489 sigset_t newblocked; 2490 /* A set of now blocked but previously unblocked signals. */ 2491 sigandnsets(&newblocked, newset, ¤t->blocked); 2492 retarget_shared_pending(tsk, &newblocked); 2493 } 2494 tsk->blocked = *newset; 2495 recalc_sigpending(); 2496 } 2497 2498 /** 2499 * set_current_blocked - change current->blocked mask 2500 * @newset: new mask 2501 * 2502 * It is wrong to change ->blocked directly, this helper should be used 2503 * to ensure the process can't miss a shared signal we are going to block. 2504 */ 2505 void set_current_blocked(sigset_t *newset) 2506 { 2507 sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP)); 2508 __set_current_blocked(newset); 2509 } 2510 2511 void __set_current_blocked(const sigset_t *newset) 2512 { 2513 struct task_struct *tsk = current; 2514 2515 /* 2516 * In case the signal mask hasn't changed, there is nothing we need 2517 * to do. The current->blocked shouldn't be modified by other task. 2518 */ 2519 if (sigequalsets(&tsk->blocked, newset)) 2520 return; 2521 2522 spin_lock_irq(&tsk->sighand->siglock); 2523 __set_task_blocked(tsk, newset); 2524 spin_unlock_irq(&tsk->sighand->siglock); 2525 } 2526 2527 /* 2528 * This is also useful for kernel threads that want to temporarily 2529 * (or permanently) block certain signals. 2530 * 2531 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel 2532 * interface happily blocks "unblockable" signals like SIGKILL 2533 * and friends. 2534 */ 2535 int sigprocmask(int how, sigset_t *set, sigset_t *oldset) 2536 { 2537 struct task_struct *tsk = current; 2538 sigset_t newset; 2539 2540 /* Lockless, only current can change ->blocked, never from irq */ 2541 if (oldset) 2542 *oldset = tsk->blocked; 2543 2544 switch (how) { 2545 case SIG_BLOCK: 2546 sigorsets(&newset, &tsk->blocked, set); 2547 break; 2548 case SIG_UNBLOCK: 2549 sigandnsets(&newset, &tsk->blocked, set); 2550 break; 2551 case SIG_SETMASK: 2552 newset = *set; 2553 break; 2554 default: 2555 return -EINVAL; 2556 } 2557 2558 __set_current_blocked(&newset); 2559 return 0; 2560 } 2561 2562 /** 2563 * sys_rt_sigprocmask - change the list of currently blocked signals 2564 * @how: whether to add, remove, or set signals 2565 * @nset: stores pending signals 2566 * @oset: previous value of signal mask if non-null 2567 * @sigsetsize: size of sigset_t type 2568 */ 2569 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset, 2570 sigset_t __user *, oset, size_t, sigsetsize) 2571 { 2572 sigset_t old_set, new_set; 2573 int error; 2574 2575 /* XXX: Don't preclude handling different sized sigset_t's. */ 2576 if (sigsetsize != sizeof(sigset_t)) 2577 return -EINVAL; 2578 2579 old_set = current->blocked; 2580 2581 if (nset) { 2582 if (copy_from_user(&new_set, nset, sizeof(sigset_t))) 2583 return -EFAULT; 2584 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP)); 2585 2586 error = sigprocmask(how, &new_set, NULL); 2587 if (error) 2588 return error; 2589 } 2590 2591 if (oset) { 2592 if (copy_to_user(oset, &old_set, sizeof(sigset_t))) 2593 return -EFAULT; 2594 } 2595 2596 return 0; 2597 } 2598 2599 #ifdef CONFIG_COMPAT 2600 COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset, 2601 compat_sigset_t __user *, oset, compat_size_t, sigsetsize) 2602 { 2603 #ifdef __BIG_ENDIAN 2604 sigset_t old_set = current->blocked; 2605 2606 /* XXX: Don't preclude handling different sized sigset_t's. */ 2607 if (sigsetsize != sizeof(sigset_t)) 2608 return -EINVAL; 2609 2610 if (nset) { 2611 compat_sigset_t new32; 2612 sigset_t new_set; 2613 int error; 2614 if (copy_from_user(&new32, nset, sizeof(compat_sigset_t))) 2615 return -EFAULT; 2616 2617 sigset_from_compat(&new_set, &new32); 2618 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP)); 2619 2620 error = sigprocmask(how, &new_set, NULL); 2621 if (error) 2622 return error; 2623 } 2624 if (oset) { 2625 compat_sigset_t old32; 2626 sigset_to_compat(&old32, &old_set); 2627 if (copy_to_user(oset, &old32, sizeof(compat_sigset_t))) 2628 return -EFAULT; 2629 } 2630 return 0; 2631 #else 2632 return sys_rt_sigprocmask(how, (sigset_t __user *)nset, 2633 (sigset_t __user *)oset, sigsetsize); 2634 #endif 2635 } 2636 #endif 2637 2638 static int do_sigpending(void *set, unsigned long sigsetsize) 2639 { 2640 if (sigsetsize > sizeof(sigset_t)) 2641 return -EINVAL; 2642 2643 spin_lock_irq(¤t->sighand->siglock); 2644 sigorsets(set, ¤t->pending.signal, 2645 ¤t->signal->shared_pending.signal); 2646 spin_unlock_irq(¤t->sighand->siglock); 2647 2648 /* Outside the lock because only this thread touches it. */ 2649 sigandsets(set, ¤t->blocked, set); 2650 return 0; 2651 } 2652 2653 /** 2654 * sys_rt_sigpending - examine a pending signal that has been raised 2655 * while blocked 2656 * @uset: stores pending signals 2657 * @sigsetsize: size of sigset_t type or larger 2658 */ 2659 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize) 2660 { 2661 sigset_t set; 2662 int err = do_sigpending(&set, sigsetsize); 2663 if (!err && copy_to_user(uset, &set, sigsetsize)) 2664 err = -EFAULT; 2665 return err; 2666 } 2667 2668 #ifdef CONFIG_COMPAT 2669 COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset, 2670 compat_size_t, sigsetsize) 2671 { 2672 #ifdef __BIG_ENDIAN 2673 sigset_t set; 2674 int err = do_sigpending(&set, sigsetsize); 2675 if (!err) { 2676 compat_sigset_t set32; 2677 sigset_to_compat(&set32, &set); 2678 /* we can get here only if sigsetsize <= sizeof(set) */ 2679 if (copy_to_user(uset, &set32, sigsetsize)) 2680 err = -EFAULT; 2681 } 2682 return err; 2683 #else 2684 return sys_rt_sigpending((sigset_t __user *)uset, sigsetsize); 2685 #endif 2686 } 2687 #endif 2688 2689 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER 2690 2691 int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from) 2692 { 2693 int err; 2694 2695 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t))) 2696 return -EFAULT; 2697 if (from->si_code < 0) 2698 return __copy_to_user(to, from, sizeof(siginfo_t)) 2699 ? -EFAULT : 0; 2700 /* 2701 * If you change siginfo_t structure, please be sure 2702 * this code is fixed accordingly. 2703 * Please remember to update the signalfd_copyinfo() function 2704 * inside fs/signalfd.c too, in case siginfo_t changes. 2705 * It should never copy any pad contained in the structure 2706 * to avoid security leaks, but must copy the generic 2707 * 3 ints plus the relevant union member. 2708 */ 2709 err = __put_user(from->si_signo, &to->si_signo); 2710 err |= __put_user(from->si_errno, &to->si_errno); 2711 err |= __put_user((short)from->si_code, &to->si_code); 2712 switch (from->si_code & __SI_MASK) { 2713 case __SI_KILL: 2714 err |= __put_user(from->si_pid, &to->si_pid); 2715 err |= __put_user(from->si_uid, &to->si_uid); 2716 break; 2717 case __SI_TIMER: 2718 err |= __put_user(from->si_tid, &to->si_tid); 2719 err |= __put_user(from->si_overrun, &to->si_overrun); 2720 err |= __put_user(from->si_ptr, &to->si_ptr); 2721 break; 2722 case __SI_POLL: 2723 err |= __put_user(from->si_band, &to->si_band); 2724 err |= __put_user(from->si_fd, &to->si_fd); 2725 break; 2726 case __SI_FAULT: 2727 err |= __put_user(from->si_addr, &to->si_addr); 2728 #ifdef __ARCH_SI_TRAPNO 2729 err |= __put_user(from->si_trapno, &to->si_trapno); 2730 #endif 2731 #ifdef BUS_MCEERR_AO 2732 /* 2733 * Other callers might not initialize the si_lsb field, 2734 * so check explicitly for the right codes here. 2735 */ 2736 if (from->si_signo == SIGBUS && 2737 (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO)) 2738 err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb); 2739 #endif 2740 #ifdef SEGV_BNDERR 2741 if (from->si_signo == SIGSEGV && from->si_code == SEGV_BNDERR) { 2742 err |= __put_user(from->si_lower, &to->si_lower); 2743 err |= __put_user(from->si_upper, &to->si_upper); 2744 } 2745 #endif 2746 #ifdef SEGV_PKUERR 2747 if (from->si_signo == SIGSEGV && from->si_code == SEGV_PKUERR) 2748 err |= __put_user(from->si_pkey, &to->si_pkey); 2749 #endif 2750 break; 2751 case __SI_CHLD: 2752 err |= __put_user(from->si_pid, &to->si_pid); 2753 err |= __put_user(from->si_uid, &to->si_uid); 2754 err |= __put_user(from->si_status, &to->si_status); 2755 err |= __put_user(from->si_utime, &to->si_utime); 2756 err |= __put_user(from->si_stime, &to->si_stime); 2757 break; 2758 case __SI_RT: /* This is not generated by the kernel as of now. */ 2759 case __SI_MESGQ: /* But this is */ 2760 err |= __put_user(from->si_pid, &to->si_pid); 2761 err |= __put_user(from->si_uid, &to->si_uid); 2762 err |= __put_user(from->si_ptr, &to->si_ptr); 2763 break; 2764 #ifdef __ARCH_SIGSYS 2765 case __SI_SYS: 2766 err |= __put_user(from->si_call_addr, &to->si_call_addr); 2767 err |= __put_user(from->si_syscall, &to->si_syscall); 2768 err |= __put_user(from->si_arch, &to->si_arch); 2769 break; 2770 #endif 2771 default: /* this is just in case for now ... */ 2772 err |= __put_user(from->si_pid, &to->si_pid); 2773 err |= __put_user(from->si_uid, &to->si_uid); 2774 break; 2775 } 2776 return err; 2777 } 2778 2779 #endif 2780 2781 /** 2782 * do_sigtimedwait - wait for queued signals specified in @which 2783 * @which: queued signals to wait for 2784 * @info: if non-null, the signal's siginfo is returned here 2785 * @ts: upper bound on process time suspension 2786 */ 2787 static int do_sigtimedwait(const sigset_t *which, siginfo_t *info, 2788 const struct timespec *ts) 2789 { 2790 ktime_t *to = NULL, timeout = KTIME_MAX; 2791 struct task_struct *tsk = current; 2792 sigset_t mask = *which; 2793 int sig, ret = 0; 2794 2795 if (ts) { 2796 if (!timespec_valid(ts)) 2797 return -EINVAL; 2798 timeout = timespec_to_ktime(*ts); 2799 to = &timeout; 2800 } 2801 2802 /* 2803 * Invert the set of allowed signals to get those we want to block. 2804 */ 2805 sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP)); 2806 signotset(&mask); 2807 2808 spin_lock_irq(&tsk->sighand->siglock); 2809 sig = dequeue_signal(tsk, &mask, info); 2810 if (!sig && timeout) { 2811 /* 2812 * None ready, temporarily unblock those we're interested 2813 * while we are sleeping in so that we'll be awakened when 2814 * they arrive. Unblocking is always fine, we can avoid 2815 * set_current_blocked(). 2816 */ 2817 tsk->real_blocked = tsk->blocked; 2818 sigandsets(&tsk->blocked, &tsk->blocked, &mask); 2819 recalc_sigpending(); 2820 spin_unlock_irq(&tsk->sighand->siglock); 2821 2822 __set_current_state(TASK_INTERRUPTIBLE); 2823 ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns, 2824 HRTIMER_MODE_REL); 2825 spin_lock_irq(&tsk->sighand->siglock); 2826 __set_task_blocked(tsk, &tsk->real_blocked); 2827 sigemptyset(&tsk->real_blocked); 2828 sig = dequeue_signal(tsk, &mask, info); 2829 } 2830 spin_unlock_irq(&tsk->sighand->siglock); 2831 2832 if (sig) 2833 return sig; 2834 return ret ? -EINTR : -EAGAIN; 2835 } 2836 2837 /** 2838 * sys_rt_sigtimedwait - synchronously wait for queued signals specified 2839 * in @uthese 2840 * @uthese: queued signals to wait for 2841 * @uinfo: if non-null, the signal's siginfo is returned here 2842 * @uts: upper bound on process time suspension 2843 * @sigsetsize: size of sigset_t type 2844 */ 2845 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese, 2846 siginfo_t __user *, uinfo, const struct timespec __user *, uts, 2847 size_t, sigsetsize) 2848 { 2849 sigset_t these; 2850 struct timespec ts; 2851 siginfo_t info; 2852 int ret; 2853 2854 /* XXX: Don't preclude handling different sized sigset_t's. */ 2855 if (sigsetsize != sizeof(sigset_t)) 2856 return -EINVAL; 2857 2858 if (copy_from_user(&these, uthese, sizeof(these))) 2859 return -EFAULT; 2860 2861 if (uts) { 2862 if (copy_from_user(&ts, uts, sizeof(ts))) 2863 return -EFAULT; 2864 } 2865 2866 ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL); 2867 2868 if (ret > 0 && uinfo) { 2869 if (copy_siginfo_to_user(uinfo, &info)) 2870 ret = -EFAULT; 2871 } 2872 2873 return ret; 2874 } 2875 2876 #ifdef CONFIG_COMPAT 2877 COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese, 2878 struct compat_siginfo __user *, uinfo, 2879 struct compat_timespec __user *, uts, compat_size_t, sigsetsize) 2880 { 2881 compat_sigset_t s32; 2882 sigset_t s; 2883 struct timespec t; 2884 siginfo_t info; 2885 long ret; 2886 2887 if (sigsetsize != sizeof(sigset_t)) 2888 return -EINVAL; 2889 2890 if (copy_from_user(&s32, uthese, sizeof(compat_sigset_t))) 2891 return -EFAULT; 2892 sigset_from_compat(&s, &s32); 2893 2894 if (uts) { 2895 if (compat_get_timespec(&t, uts)) 2896 return -EFAULT; 2897 } 2898 2899 ret = do_sigtimedwait(&s, &info, uts ? &t : NULL); 2900 2901 if (ret > 0 && uinfo) { 2902 if (copy_siginfo_to_user32(uinfo, &info)) 2903 ret = -EFAULT; 2904 } 2905 2906 return ret; 2907 } 2908 #endif 2909 2910 /** 2911 * sys_kill - send a signal to a process 2912 * @pid: the PID of the process 2913 * @sig: signal to be sent 2914 */ 2915 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig) 2916 { 2917 struct siginfo info; 2918 2919 info.si_signo = sig; 2920 info.si_errno = 0; 2921 info.si_code = SI_USER; 2922 info.si_pid = task_tgid_vnr(current); 2923 info.si_uid = from_kuid_munged(current_user_ns(), current_uid()); 2924 2925 return kill_something_info(sig, &info, pid); 2926 } 2927 2928 static int 2929 do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info) 2930 { 2931 struct task_struct *p; 2932 int error = -ESRCH; 2933 2934 rcu_read_lock(); 2935 p = find_task_by_vpid(pid); 2936 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) { 2937 error = check_kill_permission(sig, info, p); 2938 /* 2939 * The null signal is a permissions and process existence 2940 * probe. No signal is actually delivered. 2941 */ 2942 if (!error && sig) { 2943 error = do_send_sig_info(sig, info, p, false); 2944 /* 2945 * If lock_task_sighand() failed we pretend the task 2946 * dies after receiving the signal. The window is tiny, 2947 * and the signal is private anyway. 2948 */ 2949 if (unlikely(error == -ESRCH)) 2950 error = 0; 2951 } 2952 } 2953 rcu_read_unlock(); 2954 2955 return error; 2956 } 2957 2958 static int do_tkill(pid_t tgid, pid_t pid, int sig) 2959 { 2960 struct siginfo info = {}; 2961 2962 info.si_signo = sig; 2963 info.si_errno = 0; 2964 info.si_code = SI_TKILL; 2965 info.si_pid = task_tgid_vnr(current); 2966 info.si_uid = from_kuid_munged(current_user_ns(), current_uid()); 2967 2968 return do_send_specific(tgid, pid, sig, &info); 2969 } 2970 2971 /** 2972 * sys_tgkill - send signal to one specific thread 2973 * @tgid: the thread group ID of the thread 2974 * @pid: the PID of the thread 2975 * @sig: signal to be sent 2976 * 2977 * This syscall also checks the @tgid and returns -ESRCH even if the PID 2978 * exists but it's not belonging to the target process anymore. This 2979 * method solves the problem of threads exiting and PIDs getting reused. 2980 */ 2981 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig) 2982 { 2983 /* This is only valid for single tasks */ 2984 if (pid <= 0 || tgid <= 0) 2985 return -EINVAL; 2986 2987 return do_tkill(tgid, pid, sig); 2988 } 2989 2990 /** 2991 * sys_tkill - send signal to one specific task 2992 * @pid: the PID of the task 2993 * @sig: signal to be sent 2994 * 2995 * Send a signal to only one task, even if it's a CLONE_THREAD task. 2996 */ 2997 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig) 2998 { 2999 /* This is only valid for single tasks */ 3000 if (pid <= 0) 3001 return -EINVAL; 3002 3003 return do_tkill(0, pid, sig); 3004 } 3005 3006 static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t *info) 3007 { 3008 /* Not even root can pretend to send signals from the kernel. 3009 * Nor can they impersonate a kill()/tgkill(), which adds source info. 3010 */ 3011 if ((info->si_code >= 0 || info->si_code == SI_TKILL) && 3012 (task_pid_vnr(current) != pid)) 3013 return -EPERM; 3014 3015 info->si_signo = sig; 3016 3017 /* POSIX.1b doesn't mention process groups. */ 3018 return kill_proc_info(sig, info, pid); 3019 } 3020 3021 /** 3022 * sys_rt_sigqueueinfo - send signal information to a signal 3023 * @pid: the PID of the thread 3024 * @sig: signal to be sent 3025 * @uinfo: signal info to be sent 3026 */ 3027 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig, 3028 siginfo_t __user *, uinfo) 3029 { 3030 siginfo_t info; 3031 if (copy_from_user(&info, uinfo, sizeof(siginfo_t))) 3032 return -EFAULT; 3033 return do_rt_sigqueueinfo(pid, sig, &info); 3034 } 3035 3036 #ifdef CONFIG_COMPAT 3037 COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo, 3038 compat_pid_t, pid, 3039 int, sig, 3040 struct compat_siginfo __user *, uinfo) 3041 { 3042 siginfo_t info = {}; 3043 int ret = copy_siginfo_from_user32(&info, uinfo); 3044 if (unlikely(ret)) 3045 return ret; 3046 return do_rt_sigqueueinfo(pid, sig, &info); 3047 } 3048 #endif 3049 3050 static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info) 3051 { 3052 /* This is only valid for single tasks */ 3053 if (pid <= 0 || tgid <= 0) 3054 return -EINVAL; 3055 3056 /* Not even root can pretend to send signals from the kernel. 3057 * Nor can they impersonate a kill()/tgkill(), which adds source info. 3058 */ 3059 if ((info->si_code >= 0 || info->si_code == SI_TKILL) && 3060 (task_pid_vnr(current) != pid)) 3061 return -EPERM; 3062 3063 info->si_signo = sig; 3064 3065 return do_send_specific(tgid, pid, sig, info); 3066 } 3067 3068 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig, 3069 siginfo_t __user *, uinfo) 3070 { 3071 siginfo_t info; 3072 3073 if (copy_from_user(&info, uinfo, sizeof(siginfo_t))) 3074 return -EFAULT; 3075 3076 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info); 3077 } 3078 3079 #ifdef CONFIG_COMPAT 3080 COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo, 3081 compat_pid_t, tgid, 3082 compat_pid_t, pid, 3083 int, sig, 3084 struct compat_siginfo __user *, uinfo) 3085 { 3086 siginfo_t info = {}; 3087 3088 if (copy_siginfo_from_user32(&info, uinfo)) 3089 return -EFAULT; 3090 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info); 3091 } 3092 #endif 3093 3094 /* 3095 * For kthreads only, must not be used if cloned with CLONE_SIGHAND 3096 */ 3097 void kernel_sigaction(int sig, __sighandler_t action) 3098 { 3099 spin_lock_irq(¤t->sighand->siglock); 3100 current->sighand->action[sig - 1].sa.sa_handler = action; 3101 if (action == SIG_IGN) { 3102 sigset_t mask; 3103 3104 sigemptyset(&mask); 3105 sigaddset(&mask, sig); 3106 3107 flush_sigqueue_mask(&mask, ¤t->signal->shared_pending); 3108 flush_sigqueue_mask(&mask, ¤t->pending); 3109 recalc_sigpending(); 3110 } 3111 spin_unlock_irq(¤t->sighand->siglock); 3112 } 3113 EXPORT_SYMBOL(kernel_sigaction); 3114 3115 void __weak sigaction_compat_abi(struct k_sigaction *act, 3116 struct k_sigaction *oact) 3117 { 3118 } 3119 3120 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact) 3121 { 3122 struct task_struct *p = current, *t; 3123 struct k_sigaction *k; 3124 sigset_t mask; 3125 3126 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig))) 3127 return -EINVAL; 3128 3129 k = &p->sighand->action[sig-1]; 3130 3131 spin_lock_irq(&p->sighand->siglock); 3132 if (oact) 3133 *oact = *k; 3134 3135 sigaction_compat_abi(act, oact); 3136 3137 if (act) { 3138 sigdelsetmask(&act->sa.sa_mask, 3139 sigmask(SIGKILL) | sigmask(SIGSTOP)); 3140 *k = *act; 3141 /* 3142 * POSIX 3.3.1.3: 3143 * "Setting a signal action to SIG_IGN for a signal that is 3144 * pending shall cause the pending signal to be discarded, 3145 * whether or not it is blocked." 3146 * 3147 * "Setting a signal action to SIG_DFL for a signal that is 3148 * pending and whose default action is to ignore the signal 3149 * (for example, SIGCHLD), shall cause the pending signal to 3150 * be discarded, whether or not it is blocked" 3151 */ 3152 if (sig_handler_ignored(sig_handler(p, sig), sig)) { 3153 sigemptyset(&mask); 3154 sigaddset(&mask, sig); 3155 flush_sigqueue_mask(&mask, &p->signal->shared_pending); 3156 for_each_thread(p, t) 3157 flush_sigqueue_mask(&mask, &t->pending); 3158 } 3159 } 3160 3161 spin_unlock_irq(&p->sighand->siglock); 3162 return 0; 3163 } 3164 3165 static int 3166 do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp) 3167 { 3168 struct task_struct *t = current; 3169 3170 if (oss) { 3171 memset(oss, 0, sizeof(stack_t)); 3172 oss->ss_sp = (void __user *) t->sas_ss_sp; 3173 oss->ss_size = t->sas_ss_size; 3174 oss->ss_flags = sas_ss_flags(sp) | 3175 (current->sas_ss_flags & SS_FLAG_BITS); 3176 } 3177 3178 if (ss) { 3179 void __user *ss_sp = ss->ss_sp; 3180 size_t ss_size = ss->ss_size; 3181 unsigned ss_flags = ss->ss_flags; 3182 int ss_mode; 3183 3184 if (unlikely(on_sig_stack(sp))) 3185 return -EPERM; 3186 3187 ss_mode = ss_flags & ~SS_FLAG_BITS; 3188 if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK && 3189 ss_mode != 0)) 3190 return -EINVAL; 3191 3192 if (ss_mode == SS_DISABLE) { 3193 ss_size = 0; 3194 ss_sp = NULL; 3195 } else { 3196 if (unlikely(ss_size < MINSIGSTKSZ)) 3197 return -ENOMEM; 3198 } 3199 3200 t->sas_ss_sp = (unsigned long) ss_sp; 3201 t->sas_ss_size = ss_size; 3202 t->sas_ss_flags = ss_flags; 3203 } 3204 return 0; 3205 } 3206 3207 SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss) 3208 { 3209 stack_t new, old; 3210 int err; 3211 if (uss && copy_from_user(&new, uss, sizeof(stack_t))) 3212 return -EFAULT; 3213 err = do_sigaltstack(uss ? &new : NULL, uoss ? &old : NULL, 3214 current_user_stack_pointer()); 3215 if (!err && uoss && copy_to_user(uoss, &old, sizeof(stack_t))) 3216 err = -EFAULT; 3217 return err; 3218 } 3219 3220 int restore_altstack(const stack_t __user *uss) 3221 { 3222 stack_t new; 3223 if (copy_from_user(&new, uss, sizeof(stack_t))) 3224 return -EFAULT; 3225 (void)do_sigaltstack(&new, NULL, current_user_stack_pointer()); 3226 /* squash all but EFAULT for now */ 3227 return 0; 3228 } 3229 3230 int __save_altstack(stack_t __user *uss, unsigned long sp) 3231 { 3232 struct task_struct *t = current; 3233 int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) | 3234 __put_user(t->sas_ss_flags, &uss->ss_flags) | 3235 __put_user(t->sas_ss_size, &uss->ss_size); 3236 if (err) 3237 return err; 3238 if (t->sas_ss_flags & SS_AUTODISARM) 3239 sas_ss_reset(t); 3240 return 0; 3241 } 3242 3243 #ifdef CONFIG_COMPAT 3244 COMPAT_SYSCALL_DEFINE2(sigaltstack, 3245 const compat_stack_t __user *, uss_ptr, 3246 compat_stack_t __user *, uoss_ptr) 3247 { 3248 stack_t uss, uoss; 3249 int ret; 3250 3251 if (uss_ptr) { 3252 compat_stack_t uss32; 3253 if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t))) 3254 return -EFAULT; 3255 uss.ss_sp = compat_ptr(uss32.ss_sp); 3256 uss.ss_flags = uss32.ss_flags; 3257 uss.ss_size = uss32.ss_size; 3258 } 3259 ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, 3260 compat_user_stack_pointer()); 3261 if (ret >= 0 && uoss_ptr) { 3262 compat_stack_t old; 3263 memset(&old, 0, sizeof(old)); 3264 old.ss_sp = ptr_to_compat(uoss.ss_sp); 3265 old.ss_flags = uoss.ss_flags; 3266 old.ss_size = uoss.ss_size; 3267 if (copy_to_user(uoss_ptr, &old, sizeof(compat_stack_t))) 3268 ret = -EFAULT; 3269 } 3270 return ret; 3271 } 3272 3273 int compat_restore_altstack(const compat_stack_t __user *uss) 3274 { 3275 int err = compat_sys_sigaltstack(uss, NULL); 3276 /* squash all but -EFAULT for now */ 3277 return err == -EFAULT ? err : 0; 3278 } 3279 3280 int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp) 3281 { 3282 int err; 3283 struct task_struct *t = current; 3284 err = __put_user(ptr_to_compat((void __user *)t->sas_ss_sp), 3285 &uss->ss_sp) | 3286 __put_user(t->sas_ss_flags, &uss->ss_flags) | 3287 __put_user(t->sas_ss_size, &uss->ss_size); 3288 if (err) 3289 return err; 3290 if (t->sas_ss_flags & SS_AUTODISARM) 3291 sas_ss_reset(t); 3292 return 0; 3293 } 3294 #endif 3295 3296 #ifdef __ARCH_WANT_SYS_SIGPENDING 3297 3298 /** 3299 * sys_sigpending - examine pending signals 3300 * @set: where mask of pending signal is returned 3301 */ 3302 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set) 3303 { 3304 return sys_rt_sigpending((sigset_t __user *)set, sizeof(old_sigset_t)); 3305 } 3306 3307 #ifdef CONFIG_COMPAT 3308 COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set32) 3309 { 3310 #ifdef __BIG_ENDIAN 3311 sigset_t set; 3312 int err = do_sigpending(&set, sizeof(set.sig[0])); 3313 if (!err) 3314 err = put_user(set.sig[0], set32); 3315 return err; 3316 #else 3317 return sys_rt_sigpending((sigset_t __user *)set32, sizeof(*set32)); 3318 #endif 3319 } 3320 #endif 3321 3322 #endif 3323 3324 #ifdef __ARCH_WANT_SYS_SIGPROCMASK 3325 /** 3326 * sys_sigprocmask - examine and change blocked signals 3327 * @how: whether to add, remove, or set signals 3328 * @nset: signals to add or remove (if non-null) 3329 * @oset: previous value of signal mask if non-null 3330 * 3331 * Some platforms have their own version with special arguments; 3332 * others support only sys_rt_sigprocmask. 3333 */ 3334 3335 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset, 3336 old_sigset_t __user *, oset) 3337 { 3338 old_sigset_t old_set, new_set; 3339 sigset_t new_blocked; 3340 3341 old_set = current->blocked.sig[0]; 3342 3343 if (nset) { 3344 if (copy_from_user(&new_set, nset, sizeof(*nset))) 3345 return -EFAULT; 3346 3347 new_blocked = current->blocked; 3348 3349 switch (how) { 3350 case SIG_BLOCK: 3351 sigaddsetmask(&new_blocked, new_set); 3352 break; 3353 case SIG_UNBLOCK: 3354 sigdelsetmask(&new_blocked, new_set); 3355 break; 3356 case SIG_SETMASK: 3357 new_blocked.sig[0] = new_set; 3358 break; 3359 default: 3360 return -EINVAL; 3361 } 3362 3363 set_current_blocked(&new_blocked); 3364 } 3365 3366 if (oset) { 3367 if (copy_to_user(oset, &old_set, sizeof(*oset))) 3368 return -EFAULT; 3369 } 3370 3371 return 0; 3372 } 3373 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */ 3374 3375 #ifndef CONFIG_ODD_RT_SIGACTION 3376 /** 3377 * sys_rt_sigaction - alter an action taken by a process 3378 * @sig: signal to be sent 3379 * @act: new sigaction 3380 * @oact: used to save the previous sigaction 3381 * @sigsetsize: size of sigset_t type 3382 */ 3383 SYSCALL_DEFINE4(rt_sigaction, int, sig, 3384 const struct sigaction __user *, act, 3385 struct sigaction __user *, oact, 3386 size_t, sigsetsize) 3387 { 3388 struct k_sigaction new_sa, old_sa; 3389 int ret = -EINVAL; 3390 3391 /* XXX: Don't preclude handling different sized sigset_t's. */ 3392 if (sigsetsize != sizeof(sigset_t)) 3393 goto out; 3394 3395 if (act) { 3396 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa))) 3397 return -EFAULT; 3398 } 3399 3400 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL); 3401 3402 if (!ret && oact) { 3403 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa))) 3404 return -EFAULT; 3405 } 3406 out: 3407 return ret; 3408 } 3409 #ifdef CONFIG_COMPAT 3410 COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig, 3411 const struct compat_sigaction __user *, act, 3412 struct compat_sigaction __user *, oact, 3413 compat_size_t, sigsetsize) 3414 { 3415 struct k_sigaction new_ka, old_ka; 3416 compat_sigset_t mask; 3417 #ifdef __ARCH_HAS_SA_RESTORER 3418 compat_uptr_t restorer; 3419 #endif 3420 int ret; 3421 3422 /* XXX: Don't preclude handling different sized sigset_t's. */ 3423 if (sigsetsize != sizeof(compat_sigset_t)) 3424 return -EINVAL; 3425 3426 if (act) { 3427 compat_uptr_t handler; 3428 ret = get_user(handler, &act->sa_handler); 3429 new_ka.sa.sa_handler = compat_ptr(handler); 3430 #ifdef __ARCH_HAS_SA_RESTORER 3431 ret |= get_user(restorer, &act->sa_restorer); 3432 new_ka.sa.sa_restorer = compat_ptr(restorer); 3433 #endif 3434 ret |= copy_from_user(&mask, &act->sa_mask, sizeof(mask)); 3435 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags); 3436 if (ret) 3437 return -EFAULT; 3438 sigset_from_compat(&new_ka.sa.sa_mask, &mask); 3439 } 3440 3441 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 3442 if (!ret && oact) { 3443 sigset_to_compat(&mask, &old_ka.sa.sa_mask); 3444 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), 3445 &oact->sa_handler); 3446 ret |= copy_to_user(&oact->sa_mask, &mask, sizeof(mask)); 3447 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags); 3448 #ifdef __ARCH_HAS_SA_RESTORER 3449 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer), 3450 &oact->sa_restorer); 3451 #endif 3452 } 3453 return ret; 3454 } 3455 #endif 3456 #endif /* !CONFIG_ODD_RT_SIGACTION */ 3457 3458 #ifdef CONFIG_OLD_SIGACTION 3459 SYSCALL_DEFINE3(sigaction, int, sig, 3460 const struct old_sigaction __user *, act, 3461 struct old_sigaction __user *, oact) 3462 { 3463 struct k_sigaction new_ka, old_ka; 3464 int ret; 3465 3466 if (act) { 3467 old_sigset_t mask; 3468 if (!access_ok(VERIFY_READ, act, sizeof(*act)) || 3469 __get_user(new_ka.sa.sa_handler, &act->sa_handler) || 3470 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) || 3471 __get_user(new_ka.sa.sa_flags, &act->sa_flags) || 3472 __get_user(mask, &act->sa_mask)) 3473 return -EFAULT; 3474 #ifdef __ARCH_HAS_KA_RESTORER 3475 new_ka.ka_restorer = NULL; 3476 #endif 3477 siginitset(&new_ka.sa.sa_mask, mask); 3478 } 3479 3480 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 3481 3482 if (!ret && oact) { 3483 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 3484 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) || 3485 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) || 3486 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || 3487 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) 3488 return -EFAULT; 3489 } 3490 3491 return ret; 3492 } 3493 #endif 3494 #ifdef CONFIG_COMPAT_OLD_SIGACTION 3495 COMPAT_SYSCALL_DEFINE3(sigaction, int, sig, 3496 const struct compat_old_sigaction __user *, act, 3497 struct compat_old_sigaction __user *, oact) 3498 { 3499 struct k_sigaction new_ka, old_ka; 3500 int ret; 3501 compat_old_sigset_t mask; 3502 compat_uptr_t handler, restorer; 3503 3504 if (act) { 3505 if (!access_ok(VERIFY_READ, act, sizeof(*act)) || 3506 __get_user(handler, &act->sa_handler) || 3507 __get_user(restorer, &act->sa_restorer) || 3508 __get_user(new_ka.sa.sa_flags, &act->sa_flags) || 3509 __get_user(mask, &act->sa_mask)) 3510 return -EFAULT; 3511 3512 #ifdef __ARCH_HAS_KA_RESTORER 3513 new_ka.ka_restorer = NULL; 3514 #endif 3515 new_ka.sa.sa_handler = compat_ptr(handler); 3516 new_ka.sa.sa_restorer = compat_ptr(restorer); 3517 siginitset(&new_ka.sa.sa_mask, mask); 3518 } 3519 3520 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 3521 3522 if (!ret && oact) { 3523 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 3524 __put_user(ptr_to_compat(old_ka.sa.sa_handler), 3525 &oact->sa_handler) || 3526 __put_user(ptr_to_compat(old_ka.sa.sa_restorer), 3527 &oact->sa_restorer) || 3528 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || 3529 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) 3530 return -EFAULT; 3531 } 3532 return ret; 3533 } 3534 #endif 3535 3536 #ifdef CONFIG_SGETMASK_SYSCALL 3537 3538 /* 3539 * For backwards compatibility. Functionality superseded by sigprocmask. 3540 */ 3541 SYSCALL_DEFINE0(sgetmask) 3542 { 3543 /* SMP safe */ 3544 return current->blocked.sig[0]; 3545 } 3546 3547 SYSCALL_DEFINE1(ssetmask, int, newmask) 3548 { 3549 int old = current->blocked.sig[0]; 3550 sigset_t newset; 3551 3552 siginitset(&newset, newmask); 3553 set_current_blocked(&newset); 3554 3555 return old; 3556 } 3557 #endif /* CONFIG_SGETMASK_SYSCALL */ 3558 3559 #ifdef __ARCH_WANT_SYS_SIGNAL 3560 /* 3561 * For backwards compatibility. Functionality superseded by sigaction. 3562 */ 3563 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler) 3564 { 3565 struct k_sigaction new_sa, old_sa; 3566 int ret; 3567 3568 new_sa.sa.sa_handler = handler; 3569 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK; 3570 sigemptyset(&new_sa.sa.sa_mask); 3571 3572 ret = do_sigaction(sig, &new_sa, &old_sa); 3573 3574 return ret ? ret : (unsigned long)old_sa.sa.sa_handler; 3575 } 3576 #endif /* __ARCH_WANT_SYS_SIGNAL */ 3577 3578 #ifdef __ARCH_WANT_SYS_PAUSE 3579 3580 SYSCALL_DEFINE0(pause) 3581 { 3582 while (!signal_pending(current)) { 3583 __set_current_state(TASK_INTERRUPTIBLE); 3584 schedule(); 3585 } 3586 return -ERESTARTNOHAND; 3587 } 3588 3589 #endif 3590 3591 static int sigsuspend(sigset_t *set) 3592 { 3593 current->saved_sigmask = current->blocked; 3594 set_current_blocked(set); 3595 3596 while (!signal_pending(current)) { 3597 __set_current_state(TASK_INTERRUPTIBLE); 3598 schedule(); 3599 } 3600 set_restore_sigmask(); 3601 return -ERESTARTNOHAND; 3602 } 3603 3604 /** 3605 * sys_rt_sigsuspend - replace the signal mask for a value with the 3606 * @unewset value until a signal is received 3607 * @unewset: new signal mask value 3608 * @sigsetsize: size of sigset_t type 3609 */ 3610 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize) 3611 { 3612 sigset_t newset; 3613 3614 /* XXX: Don't preclude handling different sized sigset_t's. */ 3615 if (sigsetsize != sizeof(sigset_t)) 3616 return -EINVAL; 3617 3618 if (copy_from_user(&newset, unewset, sizeof(newset))) 3619 return -EFAULT; 3620 return sigsuspend(&newset); 3621 } 3622 3623 #ifdef CONFIG_COMPAT 3624 COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize) 3625 { 3626 #ifdef __BIG_ENDIAN 3627 sigset_t newset; 3628 compat_sigset_t newset32; 3629 3630 /* XXX: Don't preclude handling different sized sigset_t's. */ 3631 if (sigsetsize != sizeof(sigset_t)) 3632 return -EINVAL; 3633 3634 if (copy_from_user(&newset32, unewset, sizeof(compat_sigset_t))) 3635 return -EFAULT; 3636 sigset_from_compat(&newset, &newset32); 3637 return sigsuspend(&newset); 3638 #else 3639 /* on little-endian bitmaps don't care about granularity */ 3640 return sys_rt_sigsuspend((sigset_t __user *)unewset, sigsetsize); 3641 #endif 3642 } 3643 #endif 3644 3645 #ifdef CONFIG_OLD_SIGSUSPEND 3646 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask) 3647 { 3648 sigset_t blocked; 3649 siginitset(&blocked, mask); 3650 return sigsuspend(&blocked); 3651 } 3652 #endif 3653 #ifdef CONFIG_OLD_SIGSUSPEND3 3654 SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask) 3655 { 3656 sigset_t blocked; 3657 siginitset(&blocked, mask); 3658 return sigsuspend(&blocked); 3659 } 3660 #endif 3661 3662 __weak const char *arch_vma_name(struct vm_area_struct *vma) 3663 { 3664 return NULL; 3665 } 3666 3667 void __init signals_init(void) 3668 { 3669 /* If this check fails, the __ARCH_SI_PREAMBLE_SIZE value is wrong! */ 3670 BUILD_BUG_ON(__ARCH_SI_PREAMBLE_SIZE 3671 != offsetof(struct siginfo, _sifields._pad)); 3672 3673 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC); 3674 } 3675 3676 #ifdef CONFIG_KGDB_KDB 3677 #include <linux/kdb.h> 3678 /* 3679 * kdb_send_sig_info - Allows kdb to send signals without exposing 3680 * signal internals. This function checks if the required locks are 3681 * available before calling the main signal code, to avoid kdb 3682 * deadlocks. 3683 */ 3684 void 3685 kdb_send_sig_info(struct task_struct *t, struct siginfo *info) 3686 { 3687 static struct task_struct *kdb_prev_t; 3688 int sig, new_t; 3689 if (!spin_trylock(&t->sighand->siglock)) { 3690 kdb_printf("Can't do kill command now.\n" 3691 "The sigmask lock is held somewhere else in " 3692 "kernel, try again later\n"); 3693 return; 3694 } 3695 spin_unlock(&t->sighand->siglock); 3696 new_t = kdb_prev_t != t; 3697 kdb_prev_t = t; 3698 if (t->state != TASK_RUNNING && new_t) { 3699 kdb_printf("Process is not RUNNING, sending a signal from " 3700 "kdb risks deadlock\n" 3701 "on the run queue locks. " 3702 "The signal has _not_ been sent.\n" 3703 "Reissue the kill command if you want to risk " 3704 "the deadlock.\n"); 3705 return; 3706 } 3707 sig = info->si_signo; 3708 if (send_sig_info(sig, info, t)) 3709 kdb_printf("Fail to deliver Signal %d to process %d.\n", 3710 sig, t->pid); 3711 else 3712 kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid); 3713 } 3714 #endif /* CONFIG_KGDB_KDB */ 3715