1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/kernel/signal.c 4 * 5 * Copyright (C) 1991, 1992 Linus Torvalds 6 * 7 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson 8 * 9 * 2003-06-02 Jim Houston - Concurrent Computer Corp. 10 * Changes to use preallocated sigqueue structures 11 * to allow signals to be sent reliably. 12 */ 13 14 #include <linux/slab.h> 15 #include <linux/export.h> 16 #include <linux/init.h> 17 #include <linux/sched/mm.h> 18 #include <linux/sched/user.h> 19 #include <linux/sched/debug.h> 20 #include <linux/sched/task.h> 21 #include <linux/sched/task_stack.h> 22 #include <linux/sched/cputime.h> 23 #include <linux/file.h> 24 #include <linux/fs.h> 25 #include <linux/proc_fs.h> 26 #include <linux/tty.h> 27 #include <linux/binfmts.h> 28 #include <linux/coredump.h> 29 #include <linux/security.h> 30 #include <linux/syscalls.h> 31 #include <linux/ptrace.h> 32 #include <linux/signal.h> 33 #include <linux/signalfd.h> 34 #include <linux/ratelimit.h> 35 #include <linux/task_work.h> 36 #include <linux/capability.h> 37 #include <linux/freezer.h> 38 #include <linux/pid_namespace.h> 39 #include <linux/nsproxy.h> 40 #include <linux/user_namespace.h> 41 #include <linux/uprobes.h> 42 #include <linux/compat.h> 43 #include <linux/cn_proc.h> 44 #include <linux/compiler.h> 45 #include <linux/posix-timers.h> 46 #include <linux/cgroup.h> 47 #include <linux/audit.h> 48 49 #define CREATE_TRACE_POINTS 50 #include <trace/events/signal.h> 51 52 #include <asm/param.h> 53 #include <linux/uaccess.h> 54 #include <asm/unistd.h> 55 #include <asm/siginfo.h> 56 #include <asm/cacheflush.h> 57 #include <asm/syscall.h> /* for syscall_get_* */ 58 59 /* 60 * SLAB caches for signal bits. 61 */ 62 63 static struct kmem_cache *sigqueue_cachep; 64 65 int print_fatal_signals __read_mostly; 66 67 static void __user *sig_handler(struct task_struct *t, int sig) 68 { 69 return t->sighand->action[sig - 1].sa.sa_handler; 70 } 71 72 static inline bool sig_handler_ignored(void __user *handler, int sig) 73 { 74 /* Is it explicitly or implicitly ignored? */ 75 return handler == SIG_IGN || 76 (handler == SIG_DFL && sig_kernel_ignore(sig)); 77 } 78 79 static bool sig_task_ignored(struct task_struct *t, int sig, bool force) 80 { 81 void __user *handler; 82 83 handler = sig_handler(t, sig); 84 85 /* SIGKILL and SIGSTOP may not be sent to the global init */ 86 if (unlikely(is_global_init(t) && sig_kernel_only(sig))) 87 return true; 88 89 if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) && 90 handler == SIG_DFL && !(force && sig_kernel_only(sig))) 91 return true; 92 93 /* Only allow kernel generated signals to this kthread */ 94 if (unlikely((t->flags & PF_KTHREAD) && 95 (handler == SIG_KTHREAD_KERNEL) && !force)) 96 return true; 97 98 return sig_handler_ignored(handler, sig); 99 } 100 101 static bool sig_ignored(struct task_struct *t, int sig, bool force) 102 { 103 /* 104 * Blocked signals are never ignored, since the 105 * signal handler may change by the time it is 106 * unblocked. 107 */ 108 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig)) 109 return false; 110 111 /* 112 * Tracers may want to know about even ignored signal unless it 113 * is SIGKILL which can't be reported anyway but can be ignored 114 * by SIGNAL_UNKILLABLE task. 115 */ 116 if (t->ptrace && sig != SIGKILL) 117 return false; 118 119 return sig_task_ignored(t, sig, force); 120 } 121 122 /* 123 * Re-calculate pending state from the set of locally pending 124 * signals, globally pending signals, and blocked signals. 125 */ 126 static inline bool has_pending_signals(sigset_t *signal, sigset_t *blocked) 127 { 128 unsigned long ready; 129 long i; 130 131 switch (_NSIG_WORDS) { 132 default: 133 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;) 134 ready |= signal->sig[i] &~ blocked->sig[i]; 135 break; 136 137 case 4: ready = signal->sig[3] &~ blocked->sig[3]; 138 ready |= signal->sig[2] &~ blocked->sig[2]; 139 ready |= signal->sig[1] &~ blocked->sig[1]; 140 ready |= signal->sig[0] &~ blocked->sig[0]; 141 break; 142 143 case 2: ready = signal->sig[1] &~ blocked->sig[1]; 144 ready |= signal->sig[0] &~ blocked->sig[0]; 145 break; 146 147 case 1: ready = signal->sig[0] &~ blocked->sig[0]; 148 } 149 return ready != 0; 150 } 151 152 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b)) 153 154 static bool recalc_sigpending_tsk(struct task_struct *t) 155 { 156 if ((t->jobctl & (JOBCTL_PENDING_MASK | JOBCTL_TRAP_FREEZE)) || 157 PENDING(&t->pending, &t->blocked) || 158 PENDING(&t->signal->shared_pending, &t->blocked) || 159 cgroup_task_frozen(t)) { 160 set_tsk_thread_flag(t, TIF_SIGPENDING); 161 return true; 162 } 163 164 /* 165 * We must never clear the flag in another thread, or in current 166 * when it's possible the current syscall is returning -ERESTART*. 167 * So we don't clear it here, and only callers who know they should do. 168 */ 169 return false; 170 } 171 172 /* 173 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up. 174 * This is superfluous when called on current, the wakeup is a harmless no-op. 175 */ 176 void recalc_sigpending_and_wake(struct task_struct *t) 177 { 178 if (recalc_sigpending_tsk(t)) 179 signal_wake_up(t, 0); 180 } 181 182 void recalc_sigpending(void) 183 { 184 if (!recalc_sigpending_tsk(current) && !freezing(current)) 185 clear_thread_flag(TIF_SIGPENDING); 186 187 } 188 EXPORT_SYMBOL(recalc_sigpending); 189 190 void calculate_sigpending(void) 191 { 192 /* Have any signals or users of TIF_SIGPENDING been delayed 193 * until after fork? 194 */ 195 spin_lock_irq(¤t->sighand->siglock); 196 set_tsk_thread_flag(current, TIF_SIGPENDING); 197 recalc_sigpending(); 198 spin_unlock_irq(¤t->sighand->siglock); 199 } 200 201 /* Given the mask, find the first available signal that should be serviced. */ 202 203 #define SYNCHRONOUS_MASK \ 204 (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \ 205 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS)) 206 207 int next_signal(struct sigpending *pending, sigset_t *mask) 208 { 209 unsigned long i, *s, *m, x; 210 int sig = 0; 211 212 s = pending->signal.sig; 213 m = mask->sig; 214 215 /* 216 * Handle the first word specially: it contains the 217 * synchronous signals that need to be dequeued first. 218 */ 219 x = *s &~ *m; 220 if (x) { 221 if (x & SYNCHRONOUS_MASK) 222 x &= SYNCHRONOUS_MASK; 223 sig = ffz(~x) + 1; 224 return sig; 225 } 226 227 switch (_NSIG_WORDS) { 228 default: 229 for (i = 1; i < _NSIG_WORDS; ++i) { 230 x = *++s &~ *++m; 231 if (!x) 232 continue; 233 sig = ffz(~x) + i*_NSIG_BPW + 1; 234 break; 235 } 236 break; 237 238 case 2: 239 x = s[1] &~ m[1]; 240 if (!x) 241 break; 242 sig = ffz(~x) + _NSIG_BPW + 1; 243 break; 244 245 case 1: 246 /* Nothing to do */ 247 break; 248 } 249 250 return sig; 251 } 252 253 static inline void print_dropped_signal(int sig) 254 { 255 static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10); 256 257 if (!print_fatal_signals) 258 return; 259 260 if (!__ratelimit(&ratelimit_state)) 261 return; 262 263 pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n", 264 current->comm, current->pid, sig); 265 } 266 267 /** 268 * task_set_jobctl_pending - set jobctl pending bits 269 * @task: target task 270 * @mask: pending bits to set 271 * 272 * Clear @mask from @task->jobctl. @mask must be subset of 273 * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK | 274 * %JOBCTL_TRAPPING. If stop signo is being set, the existing signo is 275 * cleared. If @task is already being killed or exiting, this function 276 * becomes noop. 277 * 278 * CONTEXT: 279 * Must be called with @task->sighand->siglock held. 280 * 281 * RETURNS: 282 * %true if @mask is set, %false if made noop because @task was dying. 283 */ 284 bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask) 285 { 286 BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME | 287 JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING)); 288 BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK)); 289 290 if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING))) 291 return false; 292 293 if (mask & JOBCTL_STOP_SIGMASK) 294 task->jobctl &= ~JOBCTL_STOP_SIGMASK; 295 296 task->jobctl |= mask; 297 return true; 298 } 299 300 /** 301 * task_clear_jobctl_trapping - clear jobctl trapping bit 302 * @task: target task 303 * 304 * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED. 305 * Clear it and wake up the ptracer. Note that we don't need any further 306 * locking. @task->siglock guarantees that @task->parent points to the 307 * ptracer. 308 * 309 * CONTEXT: 310 * Must be called with @task->sighand->siglock held. 311 */ 312 void task_clear_jobctl_trapping(struct task_struct *task) 313 { 314 if (unlikely(task->jobctl & JOBCTL_TRAPPING)) { 315 task->jobctl &= ~JOBCTL_TRAPPING; 316 smp_mb(); /* advised by wake_up_bit() */ 317 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT); 318 } 319 } 320 321 /** 322 * task_clear_jobctl_pending - clear jobctl pending bits 323 * @task: target task 324 * @mask: pending bits to clear 325 * 326 * Clear @mask from @task->jobctl. @mask must be subset of 327 * %JOBCTL_PENDING_MASK. If %JOBCTL_STOP_PENDING is being cleared, other 328 * STOP bits are cleared together. 329 * 330 * If clearing of @mask leaves no stop or trap pending, this function calls 331 * task_clear_jobctl_trapping(). 332 * 333 * CONTEXT: 334 * Must be called with @task->sighand->siglock held. 335 */ 336 void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask) 337 { 338 BUG_ON(mask & ~JOBCTL_PENDING_MASK); 339 340 if (mask & JOBCTL_STOP_PENDING) 341 mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED; 342 343 task->jobctl &= ~mask; 344 345 if (!(task->jobctl & JOBCTL_PENDING_MASK)) 346 task_clear_jobctl_trapping(task); 347 } 348 349 /** 350 * task_participate_group_stop - participate in a group stop 351 * @task: task participating in a group stop 352 * 353 * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop. 354 * Group stop states are cleared and the group stop count is consumed if 355 * %JOBCTL_STOP_CONSUME was set. If the consumption completes the group 356 * stop, the appropriate `SIGNAL_*` flags are set. 357 * 358 * CONTEXT: 359 * Must be called with @task->sighand->siglock held. 360 * 361 * RETURNS: 362 * %true if group stop completion should be notified to the parent, %false 363 * otherwise. 364 */ 365 static bool task_participate_group_stop(struct task_struct *task) 366 { 367 struct signal_struct *sig = task->signal; 368 bool consume = task->jobctl & JOBCTL_STOP_CONSUME; 369 370 WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING)); 371 372 task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING); 373 374 if (!consume) 375 return false; 376 377 if (!WARN_ON_ONCE(sig->group_stop_count == 0)) 378 sig->group_stop_count--; 379 380 /* 381 * Tell the caller to notify completion iff we are entering into a 382 * fresh group stop. Read comment in do_signal_stop() for details. 383 */ 384 if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) { 385 signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED); 386 return true; 387 } 388 return false; 389 } 390 391 void task_join_group_stop(struct task_struct *task) 392 { 393 unsigned long mask = current->jobctl & JOBCTL_STOP_SIGMASK; 394 struct signal_struct *sig = current->signal; 395 396 if (sig->group_stop_count) { 397 sig->group_stop_count++; 398 mask |= JOBCTL_STOP_CONSUME; 399 } else if (!(sig->flags & SIGNAL_STOP_STOPPED)) 400 return; 401 402 /* Have the new thread join an on-going signal group stop */ 403 task_set_jobctl_pending(task, mask | JOBCTL_STOP_PENDING); 404 } 405 406 /* 407 * allocate a new signal queue record 408 * - this may be called without locks if and only if t == current, otherwise an 409 * appropriate lock must be held to stop the target task from exiting 410 */ 411 static struct sigqueue * 412 __sigqueue_alloc(int sig, struct task_struct *t, gfp_t gfp_flags, 413 int override_rlimit, const unsigned int sigqueue_flags) 414 { 415 struct sigqueue *q = NULL; 416 struct ucounts *ucounts = NULL; 417 long sigpending; 418 419 /* 420 * Protect access to @t credentials. This can go away when all 421 * callers hold rcu read lock. 422 * 423 * NOTE! A pending signal will hold on to the user refcount, 424 * and we get/put the refcount only when the sigpending count 425 * changes from/to zero. 426 */ 427 rcu_read_lock(); 428 ucounts = task_ucounts(t); 429 sigpending = inc_rlimit_get_ucounts(ucounts, UCOUNT_RLIMIT_SIGPENDING); 430 rcu_read_unlock(); 431 if (!sigpending) 432 return NULL; 433 434 if (override_rlimit || likely(sigpending <= task_rlimit(t, RLIMIT_SIGPENDING))) { 435 q = kmem_cache_alloc(sigqueue_cachep, gfp_flags); 436 } else { 437 print_dropped_signal(sig); 438 } 439 440 if (unlikely(q == NULL)) { 441 dec_rlimit_put_ucounts(ucounts, UCOUNT_RLIMIT_SIGPENDING); 442 } else { 443 INIT_LIST_HEAD(&q->list); 444 q->flags = sigqueue_flags; 445 q->ucounts = ucounts; 446 } 447 return q; 448 } 449 450 static void __sigqueue_free(struct sigqueue *q) 451 { 452 if (q->flags & SIGQUEUE_PREALLOC) 453 return; 454 if (q->ucounts) { 455 dec_rlimit_put_ucounts(q->ucounts, UCOUNT_RLIMIT_SIGPENDING); 456 q->ucounts = NULL; 457 } 458 kmem_cache_free(sigqueue_cachep, q); 459 } 460 461 void flush_sigqueue(struct sigpending *queue) 462 { 463 struct sigqueue *q; 464 465 sigemptyset(&queue->signal); 466 while (!list_empty(&queue->list)) { 467 q = list_entry(queue->list.next, struct sigqueue , list); 468 list_del_init(&q->list); 469 __sigqueue_free(q); 470 } 471 } 472 473 /* 474 * Flush all pending signals for this kthread. 475 */ 476 void flush_signals(struct task_struct *t) 477 { 478 unsigned long flags; 479 480 spin_lock_irqsave(&t->sighand->siglock, flags); 481 clear_tsk_thread_flag(t, TIF_SIGPENDING); 482 flush_sigqueue(&t->pending); 483 flush_sigqueue(&t->signal->shared_pending); 484 spin_unlock_irqrestore(&t->sighand->siglock, flags); 485 } 486 EXPORT_SYMBOL(flush_signals); 487 488 #ifdef CONFIG_POSIX_TIMERS 489 static void __flush_itimer_signals(struct sigpending *pending) 490 { 491 sigset_t signal, retain; 492 struct sigqueue *q, *n; 493 494 signal = pending->signal; 495 sigemptyset(&retain); 496 497 list_for_each_entry_safe(q, n, &pending->list, list) { 498 int sig = q->info.si_signo; 499 500 if (likely(q->info.si_code != SI_TIMER)) { 501 sigaddset(&retain, sig); 502 } else { 503 sigdelset(&signal, sig); 504 list_del_init(&q->list); 505 __sigqueue_free(q); 506 } 507 } 508 509 sigorsets(&pending->signal, &signal, &retain); 510 } 511 512 void flush_itimer_signals(void) 513 { 514 struct task_struct *tsk = current; 515 unsigned long flags; 516 517 spin_lock_irqsave(&tsk->sighand->siglock, flags); 518 __flush_itimer_signals(&tsk->pending); 519 __flush_itimer_signals(&tsk->signal->shared_pending); 520 spin_unlock_irqrestore(&tsk->sighand->siglock, flags); 521 } 522 #endif 523 524 void ignore_signals(struct task_struct *t) 525 { 526 int i; 527 528 for (i = 0; i < _NSIG; ++i) 529 t->sighand->action[i].sa.sa_handler = SIG_IGN; 530 531 flush_signals(t); 532 } 533 534 /* 535 * Flush all handlers for a task. 536 */ 537 538 void 539 flush_signal_handlers(struct task_struct *t, int force_default) 540 { 541 int i; 542 struct k_sigaction *ka = &t->sighand->action[0]; 543 for (i = _NSIG ; i != 0 ; i--) { 544 if (force_default || ka->sa.sa_handler != SIG_IGN) 545 ka->sa.sa_handler = SIG_DFL; 546 ka->sa.sa_flags = 0; 547 #ifdef __ARCH_HAS_SA_RESTORER 548 ka->sa.sa_restorer = NULL; 549 #endif 550 sigemptyset(&ka->sa.sa_mask); 551 ka++; 552 } 553 } 554 555 bool unhandled_signal(struct task_struct *tsk, int sig) 556 { 557 void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler; 558 if (is_global_init(tsk)) 559 return true; 560 561 if (handler != SIG_IGN && handler != SIG_DFL) 562 return false; 563 564 /* if ptraced, let the tracer determine */ 565 return !tsk->ptrace; 566 } 567 568 static void collect_signal(int sig, struct sigpending *list, kernel_siginfo_t *info, 569 bool *resched_timer) 570 { 571 struct sigqueue *q, *first = NULL; 572 573 /* 574 * Collect the siginfo appropriate to this signal. Check if 575 * there is another siginfo for the same signal. 576 */ 577 list_for_each_entry(q, &list->list, list) { 578 if (q->info.si_signo == sig) { 579 if (first) 580 goto still_pending; 581 first = q; 582 } 583 } 584 585 sigdelset(&list->signal, sig); 586 587 if (first) { 588 still_pending: 589 list_del_init(&first->list); 590 copy_siginfo(info, &first->info); 591 592 *resched_timer = 593 (first->flags & SIGQUEUE_PREALLOC) && 594 (info->si_code == SI_TIMER) && 595 (info->si_sys_private); 596 597 __sigqueue_free(first); 598 } else { 599 /* 600 * Ok, it wasn't in the queue. This must be 601 * a fast-pathed signal or we must have been 602 * out of queue space. So zero out the info. 603 */ 604 clear_siginfo(info); 605 info->si_signo = sig; 606 info->si_errno = 0; 607 info->si_code = SI_USER; 608 info->si_pid = 0; 609 info->si_uid = 0; 610 } 611 } 612 613 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask, 614 kernel_siginfo_t *info, bool *resched_timer) 615 { 616 int sig = next_signal(pending, mask); 617 618 if (sig) 619 collect_signal(sig, pending, info, resched_timer); 620 return sig; 621 } 622 623 /* 624 * Dequeue a signal and return the element to the caller, which is 625 * expected to free it. 626 * 627 * All callers have to hold the siglock. 628 */ 629 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, 630 kernel_siginfo_t *info, enum pid_type *type) 631 { 632 bool resched_timer = false; 633 int signr; 634 635 /* We only dequeue private signals from ourselves, we don't let 636 * signalfd steal them 637 */ 638 *type = PIDTYPE_PID; 639 signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer); 640 if (!signr) { 641 *type = PIDTYPE_TGID; 642 signr = __dequeue_signal(&tsk->signal->shared_pending, 643 mask, info, &resched_timer); 644 #ifdef CONFIG_POSIX_TIMERS 645 /* 646 * itimer signal ? 647 * 648 * itimers are process shared and we restart periodic 649 * itimers in the signal delivery path to prevent DoS 650 * attacks in the high resolution timer case. This is 651 * compliant with the old way of self-restarting 652 * itimers, as the SIGALRM is a legacy signal and only 653 * queued once. Changing the restart behaviour to 654 * restart the timer in the signal dequeue path is 655 * reducing the timer noise on heavy loaded !highres 656 * systems too. 657 */ 658 if (unlikely(signr == SIGALRM)) { 659 struct hrtimer *tmr = &tsk->signal->real_timer; 660 661 if (!hrtimer_is_queued(tmr) && 662 tsk->signal->it_real_incr != 0) { 663 hrtimer_forward(tmr, tmr->base->get_time(), 664 tsk->signal->it_real_incr); 665 hrtimer_restart(tmr); 666 } 667 } 668 #endif 669 } 670 671 recalc_sigpending(); 672 if (!signr) 673 return 0; 674 675 if (unlikely(sig_kernel_stop(signr))) { 676 /* 677 * Set a marker that we have dequeued a stop signal. Our 678 * caller might release the siglock and then the pending 679 * stop signal it is about to process is no longer in the 680 * pending bitmasks, but must still be cleared by a SIGCONT 681 * (and overruled by a SIGKILL). So those cases clear this 682 * shared flag after we've set it. Note that this flag may 683 * remain set after the signal we return is ignored or 684 * handled. That doesn't matter because its only purpose 685 * is to alert stop-signal processing code when another 686 * processor has come along and cleared the flag. 687 */ 688 current->jobctl |= JOBCTL_STOP_DEQUEUED; 689 } 690 #ifdef CONFIG_POSIX_TIMERS 691 if (resched_timer) { 692 /* 693 * Release the siglock to ensure proper locking order 694 * of timer locks outside of siglocks. Note, we leave 695 * irqs disabled here, since the posix-timers code is 696 * about to disable them again anyway. 697 */ 698 spin_unlock(&tsk->sighand->siglock); 699 posixtimer_rearm(info); 700 spin_lock(&tsk->sighand->siglock); 701 702 /* Don't expose the si_sys_private value to userspace */ 703 info->si_sys_private = 0; 704 } 705 #endif 706 return signr; 707 } 708 EXPORT_SYMBOL_GPL(dequeue_signal); 709 710 static int dequeue_synchronous_signal(kernel_siginfo_t *info) 711 { 712 struct task_struct *tsk = current; 713 struct sigpending *pending = &tsk->pending; 714 struct sigqueue *q, *sync = NULL; 715 716 /* 717 * Might a synchronous signal be in the queue? 718 */ 719 if (!((pending->signal.sig[0] & ~tsk->blocked.sig[0]) & SYNCHRONOUS_MASK)) 720 return 0; 721 722 /* 723 * Return the first synchronous signal in the queue. 724 */ 725 list_for_each_entry(q, &pending->list, list) { 726 /* Synchronous signals have a positive si_code */ 727 if ((q->info.si_code > SI_USER) && 728 (sigmask(q->info.si_signo) & SYNCHRONOUS_MASK)) { 729 sync = q; 730 goto next; 731 } 732 } 733 return 0; 734 next: 735 /* 736 * Check if there is another siginfo for the same signal. 737 */ 738 list_for_each_entry_continue(q, &pending->list, list) { 739 if (q->info.si_signo == sync->info.si_signo) 740 goto still_pending; 741 } 742 743 sigdelset(&pending->signal, sync->info.si_signo); 744 recalc_sigpending(); 745 still_pending: 746 list_del_init(&sync->list); 747 copy_siginfo(info, &sync->info); 748 __sigqueue_free(sync); 749 return info->si_signo; 750 } 751 752 /* 753 * Tell a process that it has a new active signal.. 754 * 755 * NOTE! we rely on the previous spin_lock to 756 * lock interrupts for us! We can only be called with 757 * "siglock" held, and the local interrupt must 758 * have been disabled when that got acquired! 759 * 760 * No need to set need_resched since signal event passing 761 * goes through ->blocked 762 */ 763 void signal_wake_up_state(struct task_struct *t, unsigned int state) 764 { 765 set_tsk_thread_flag(t, TIF_SIGPENDING); 766 /* 767 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable 768 * case. We don't check t->state here because there is a race with it 769 * executing another processor and just now entering stopped state. 770 * By using wake_up_state, we ensure the process will wake up and 771 * handle its death signal. 772 */ 773 if (!wake_up_state(t, state | TASK_INTERRUPTIBLE)) 774 kick_process(t); 775 } 776 777 /* 778 * Remove signals in mask from the pending set and queue. 779 * Returns 1 if any signals were found. 780 * 781 * All callers must be holding the siglock. 782 */ 783 static void flush_sigqueue_mask(sigset_t *mask, struct sigpending *s) 784 { 785 struct sigqueue *q, *n; 786 sigset_t m; 787 788 sigandsets(&m, mask, &s->signal); 789 if (sigisemptyset(&m)) 790 return; 791 792 sigandnsets(&s->signal, &s->signal, mask); 793 list_for_each_entry_safe(q, n, &s->list, list) { 794 if (sigismember(mask, q->info.si_signo)) { 795 list_del_init(&q->list); 796 __sigqueue_free(q); 797 } 798 } 799 } 800 801 static inline int is_si_special(const struct kernel_siginfo *info) 802 { 803 return info <= SEND_SIG_PRIV; 804 } 805 806 static inline bool si_fromuser(const struct kernel_siginfo *info) 807 { 808 return info == SEND_SIG_NOINFO || 809 (!is_si_special(info) && SI_FROMUSER(info)); 810 } 811 812 /* 813 * called with RCU read lock from check_kill_permission() 814 */ 815 static bool kill_ok_by_cred(struct task_struct *t) 816 { 817 const struct cred *cred = current_cred(); 818 const struct cred *tcred = __task_cred(t); 819 820 return uid_eq(cred->euid, tcred->suid) || 821 uid_eq(cred->euid, tcred->uid) || 822 uid_eq(cred->uid, tcred->suid) || 823 uid_eq(cred->uid, tcred->uid) || 824 ns_capable(tcred->user_ns, CAP_KILL); 825 } 826 827 /* 828 * Bad permissions for sending the signal 829 * - the caller must hold the RCU read lock 830 */ 831 static int check_kill_permission(int sig, struct kernel_siginfo *info, 832 struct task_struct *t) 833 { 834 struct pid *sid; 835 int error; 836 837 if (!valid_signal(sig)) 838 return -EINVAL; 839 840 if (!si_fromuser(info)) 841 return 0; 842 843 error = audit_signal_info(sig, t); /* Let audit system see the signal */ 844 if (error) 845 return error; 846 847 if (!same_thread_group(current, t) && 848 !kill_ok_by_cred(t)) { 849 switch (sig) { 850 case SIGCONT: 851 sid = task_session(t); 852 /* 853 * We don't return the error if sid == NULL. The 854 * task was unhashed, the caller must notice this. 855 */ 856 if (!sid || sid == task_session(current)) 857 break; 858 fallthrough; 859 default: 860 return -EPERM; 861 } 862 } 863 864 return security_task_kill(t, info, sig, NULL); 865 } 866 867 /** 868 * ptrace_trap_notify - schedule trap to notify ptracer 869 * @t: tracee wanting to notify tracer 870 * 871 * This function schedules sticky ptrace trap which is cleared on the next 872 * TRAP_STOP to notify ptracer of an event. @t must have been seized by 873 * ptracer. 874 * 875 * If @t is running, STOP trap will be taken. If trapped for STOP and 876 * ptracer is listening for events, tracee is woken up so that it can 877 * re-trap for the new event. If trapped otherwise, STOP trap will be 878 * eventually taken without returning to userland after the existing traps 879 * are finished by PTRACE_CONT. 880 * 881 * CONTEXT: 882 * Must be called with @task->sighand->siglock held. 883 */ 884 static void ptrace_trap_notify(struct task_struct *t) 885 { 886 WARN_ON_ONCE(!(t->ptrace & PT_SEIZED)); 887 assert_spin_locked(&t->sighand->siglock); 888 889 task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY); 890 ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING); 891 } 892 893 /* 894 * Handle magic process-wide effects of stop/continue signals. Unlike 895 * the signal actions, these happen immediately at signal-generation 896 * time regardless of blocking, ignoring, or handling. This does the 897 * actual continuing for SIGCONT, but not the actual stopping for stop 898 * signals. The process stop is done as a signal action for SIG_DFL. 899 * 900 * Returns true if the signal should be actually delivered, otherwise 901 * it should be dropped. 902 */ 903 static bool prepare_signal(int sig, struct task_struct *p, bool force) 904 { 905 struct signal_struct *signal = p->signal; 906 struct task_struct *t; 907 sigset_t flush; 908 909 if (signal->flags & SIGNAL_GROUP_EXIT) { 910 if (signal->core_state) 911 return sig == SIGKILL; 912 /* 913 * The process is in the middle of dying, nothing to do. 914 */ 915 } else if (sig_kernel_stop(sig)) { 916 /* 917 * This is a stop signal. Remove SIGCONT from all queues. 918 */ 919 siginitset(&flush, sigmask(SIGCONT)); 920 flush_sigqueue_mask(&flush, &signal->shared_pending); 921 for_each_thread(p, t) 922 flush_sigqueue_mask(&flush, &t->pending); 923 } else if (sig == SIGCONT) { 924 unsigned int why; 925 /* 926 * Remove all stop signals from all queues, wake all threads. 927 */ 928 siginitset(&flush, SIG_KERNEL_STOP_MASK); 929 flush_sigqueue_mask(&flush, &signal->shared_pending); 930 for_each_thread(p, t) { 931 flush_sigqueue_mask(&flush, &t->pending); 932 task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING); 933 if (likely(!(t->ptrace & PT_SEIZED))) 934 wake_up_state(t, __TASK_STOPPED); 935 else 936 ptrace_trap_notify(t); 937 } 938 939 /* 940 * Notify the parent with CLD_CONTINUED if we were stopped. 941 * 942 * If we were in the middle of a group stop, we pretend it 943 * was already finished, and then continued. Since SIGCHLD 944 * doesn't queue we report only CLD_STOPPED, as if the next 945 * CLD_CONTINUED was dropped. 946 */ 947 why = 0; 948 if (signal->flags & SIGNAL_STOP_STOPPED) 949 why |= SIGNAL_CLD_CONTINUED; 950 else if (signal->group_stop_count) 951 why |= SIGNAL_CLD_STOPPED; 952 953 if (why) { 954 /* 955 * The first thread which returns from do_signal_stop() 956 * will take ->siglock, notice SIGNAL_CLD_MASK, and 957 * notify its parent. See get_signal(). 958 */ 959 signal_set_stop_flags(signal, why | SIGNAL_STOP_CONTINUED); 960 signal->group_stop_count = 0; 961 signal->group_exit_code = 0; 962 } 963 } 964 965 return !sig_ignored(p, sig, force); 966 } 967 968 /* 969 * Test if P wants to take SIG. After we've checked all threads with this, 970 * it's equivalent to finding no threads not blocking SIG. Any threads not 971 * blocking SIG were ruled out because they are not running and already 972 * have pending signals. Such threads will dequeue from the shared queue 973 * as soon as they're available, so putting the signal on the shared queue 974 * will be equivalent to sending it to one such thread. 975 */ 976 static inline bool wants_signal(int sig, struct task_struct *p) 977 { 978 if (sigismember(&p->blocked, sig)) 979 return false; 980 981 if (p->flags & PF_EXITING) 982 return false; 983 984 if (sig == SIGKILL) 985 return true; 986 987 if (task_is_stopped_or_traced(p)) 988 return false; 989 990 return task_curr(p) || !task_sigpending(p); 991 } 992 993 static void complete_signal(int sig, struct task_struct *p, enum pid_type type) 994 { 995 struct signal_struct *signal = p->signal; 996 struct task_struct *t; 997 998 /* 999 * Now find a thread we can wake up to take the signal off the queue. 1000 * 1001 * If the main thread wants the signal, it gets first crack. 1002 * Probably the least surprising to the average bear. 1003 */ 1004 if (wants_signal(sig, p)) 1005 t = p; 1006 else if ((type == PIDTYPE_PID) || thread_group_empty(p)) 1007 /* 1008 * There is just one thread and it does not need to be woken. 1009 * It will dequeue unblocked signals before it runs again. 1010 */ 1011 return; 1012 else { 1013 /* 1014 * Otherwise try to find a suitable thread. 1015 */ 1016 t = signal->curr_target; 1017 while (!wants_signal(sig, t)) { 1018 t = next_thread(t); 1019 if (t == signal->curr_target) 1020 /* 1021 * No thread needs to be woken. 1022 * Any eligible threads will see 1023 * the signal in the queue soon. 1024 */ 1025 return; 1026 } 1027 signal->curr_target = t; 1028 } 1029 1030 /* 1031 * Found a killable thread. If the signal will be fatal, 1032 * then start taking the whole group down immediately. 1033 */ 1034 if (sig_fatal(p, sig) && 1035 (signal->core_state || !(signal->flags & SIGNAL_GROUP_EXIT)) && 1036 !sigismember(&t->real_blocked, sig) && 1037 (sig == SIGKILL || !p->ptrace)) { 1038 /* 1039 * This signal will be fatal to the whole group. 1040 */ 1041 if (!sig_kernel_coredump(sig)) { 1042 /* 1043 * Start a group exit and wake everybody up. 1044 * This way we don't have other threads 1045 * running and doing things after a slower 1046 * thread has the fatal signal pending. 1047 */ 1048 signal->flags = SIGNAL_GROUP_EXIT; 1049 signal->group_exit_code = sig; 1050 signal->group_stop_count = 0; 1051 t = p; 1052 do { 1053 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK); 1054 sigaddset(&t->pending.signal, SIGKILL); 1055 signal_wake_up(t, 1); 1056 } while_each_thread(p, t); 1057 return; 1058 } 1059 } 1060 1061 /* 1062 * The signal is already in the shared-pending queue. 1063 * Tell the chosen thread to wake up and dequeue it. 1064 */ 1065 signal_wake_up(t, sig == SIGKILL); 1066 return; 1067 } 1068 1069 static inline bool legacy_queue(struct sigpending *signals, int sig) 1070 { 1071 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig); 1072 } 1073 1074 static int __send_signal(int sig, struct kernel_siginfo *info, struct task_struct *t, 1075 enum pid_type type, bool force) 1076 { 1077 struct sigpending *pending; 1078 struct sigqueue *q; 1079 int override_rlimit; 1080 int ret = 0, result; 1081 1082 assert_spin_locked(&t->sighand->siglock); 1083 1084 result = TRACE_SIGNAL_IGNORED; 1085 if (!prepare_signal(sig, t, force)) 1086 goto ret; 1087 1088 pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending; 1089 /* 1090 * Short-circuit ignored signals and support queuing 1091 * exactly one non-rt signal, so that we can get more 1092 * detailed information about the cause of the signal. 1093 */ 1094 result = TRACE_SIGNAL_ALREADY_PENDING; 1095 if (legacy_queue(pending, sig)) 1096 goto ret; 1097 1098 result = TRACE_SIGNAL_DELIVERED; 1099 /* 1100 * Skip useless siginfo allocation for SIGKILL and kernel threads. 1101 */ 1102 if ((sig == SIGKILL) || (t->flags & PF_KTHREAD)) 1103 goto out_set; 1104 1105 /* 1106 * Real-time signals must be queued if sent by sigqueue, or 1107 * some other real-time mechanism. It is implementation 1108 * defined whether kill() does so. We attempt to do so, on 1109 * the principle of least surprise, but since kill is not 1110 * allowed to fail with EAGAIN when low on memory we just 1111 * make sure at least one signal gets delivered and don't 1112 * pass on the info struct. 1113 */ 1114 if (sig < SIGRTMIN) 1115 override_rlimit = (is_si_special(info) || info->si_code >= 0); 1116 else 1117 override_rlimit = 0; 1118 1119 q = __sigqueue_alloc(sig, t, GFP_ATOMIC, override_rlimit, 0); 1120 1121 if (q) { 1122 list_add_tail(&q->list, &pending->list); 1123 switch ((unsigned long) info) { 1124 case (unsigned long) SEND_SIG_NOINFO: 1125 clear_siginfo(&q->info); 1126 q->info.si_signo = sig; 1127 q->info.si_errno = 0; 1128 q->info.si_code = SI_USER; 1129 q->info.si_pid = task_tgid_nr_ns(current, 1130 task_active_pid_ns(t)); 1131 rcu_read_lock(); 1132 q->info.si_uid = 1133 from_kuid_munged(task_cred_xxx(t, user_ns), 1134 current_uid()); 1135 rcu_read_unlock(); 1136 break; 1137 case (unsigned long) SEND_SIG_PRIV: 1138 clear_siginfo(&q->info); 1139 q->info.si_signo = sig; 1140 q->info.si_errno = 0; 1141 q->info.si_code = SI_KERNEL; 1142 q->info.si_pid = 0; 1143 q->info.si_uid = 0; 1144 break; 1145 default: 1146 copy_siginfo(&q->info, info); 1147 break; 1148 } 1149 } else if (!is_si_special(info) && 1150 sig >= SIGRTMIN && info->si_code != SI_USER) { 1151 /* 1152 * Queue overflow, abort. We may abort if the 1153 * signal was rt and sent by user using something 1154 * other than kill(). 1155 */ 1156 result = TRACE_SIGNAL_OVERFLOW_FAIL; 1157 ret = -EAGAIN; 1158 goto ret; 1159 } else { 1160 /* 1161 * This is a silent loss of information. We still 1162 * send the signal, but the *info bits are lost. 1163 */ 1164 result = TRACE_SIGNAL_LOSE_INFO; 1165 } 1166 1167 out_set: 1168 signalfd_notify(t, sig); 1169 sigaddset(&pending->signal, sig); 1170 1171 /* Let multiprocess signals appear after on-going forks */ 1172 if (type > PIDTYPE_TGID) { 1173 struct multiprocess_signals *delayed; 1174 hlist_for_each_entry(delayed, &t->signal->multiprocess, node) { 1175 sigset_t *signal = &delayed->signal; 1176 /* Can't queue both a stop and a continue signal */ 1177 if (sig == SIGCONT) 1178 sigdelsetmask(signal, SIG_KERNEL_STOP_MASK); 1179 else if (sig_kernel_stop(sig)) 1180 sigdelset(signal, SIGCONT); 1181 sigaddset(signal, sig); 1182 } 1183 } 1184 1185 complete_signal(sig, t, type); 1186 ret: 1187 trace_signal_generate(sig, info, t, type != PIDTYPE_PID, result); 1188 return ret; 1189 } 1190 1191 static inline bool has_si_pid_and_uid(struct kernel_siginfo *info) 1192 { 1193 bool ret = false; 1194 switch (siginfo_layout(info->si_signo, info->si_code)) { 1195 case SIL_KILL: 1196 case SIL_CHLD: 1197 case SIL_RT: 1198 ret = true; 1199 break; 1200 case SIL_TIMER: 1201 case SIL_POLL: 1202 case SIL_FAULT: 1203 case SIL_FAULT_TRAPNO: 1204 case SIL_FAULT_MCEERR: 1205 case SIL_FAULT_BNDERR: 1206 case SIL_FAULT_PKUERR: 1207 case SIL_FAULT_PERF_EVENT: 1208 case SIL_SYS: 1209 ret = false; 1210 break; 1211 } 1212 return ret; 1213 } 1214 1215 static int send_signal(int sig, struct kernel_siginfo *info, struct task_struct *t, 1216 enum pid_type type) 1217 { 1218 /* Should SIGKILL or SIGSTOP be received by a pid namespace init? */ 1219 bool force = false; 1220 1221 if (info == SEND_SIG_NOINFO) { 1222 /* Force if sent from an ancestor pid namespace */ 1223 force = !task_pid_nr_ns(current, task_active_pid_ns(t)); 1224 } else if (info == SEND_SIG_PRIV) { 1225 /* Don't ignore kernel generated signals */ 1226 force = true; 1227 } else if (has_si_pid_and_uid(info)) { 1228 /* SIGKILL and SIGSTOP is special or has ids */ 1229 struct user_namespace *t_user_ns; 1230 1231 rcu_read_lock(); 1232 t_user_ns = task_cred_xxx(t, user_ns); 1233 if (current_user_ns() != t_user_ns) { 1234 kuid_t uid = make_kuid(current_user_ns(), info->si_uid); 1235 info->si_uid = from_kuid_munged(t_user_ns, uid); 1236 } 1237 rcu_read_unlock(); 1238 1239 /* A kernel generated signal? */ 1240 force = (info->si_code == SI_KERNEL); 1241 1242 /* From an ancestor pid namespace? */ 1243 if (!task_pid_nr_ns(current, task_active_pid_ns(t))) { 1244 info->si_pid = 0; 1245 force = true; 1246 } 1247 } 1248 return __send_signal(sig, info, t, type, force); 1249 } 1250 1251 static void print_fatal_signal(int signr) 1252 { 1253 struct pt_regs *regs = signal_pt_regs(); 1254 pr_info("potentially unexpected fatal signal %d.\n", signr); 1255 1256 #if defined(__i386__) && !defined(__arch_um__) 1257 pr_info("code at %08lx: ", regs->ip); 1258 { 1259 int i; 1260 for (i = 0; i < 16; i++) { 1261 unsigned char insn; 1262 1263 if (get_user(insn, (unsigned char *)(regs->ip + i))) 1264 break; 1265 pr_cont("%02x ", insn); 1266 } 1267 } 1268 pr_cont("\n"); 1269 #endif 1270 preempt_disable(); 1271 show_regs(regs); 1272 preempt_enable(); 1273 } 1274 1275 static int __init setup_print_fatal_signals(char *str) 1276 { 1277 get_option (&str, &print_fatal_signals); 1278 1279 return 1; 1280 } 1281 1282 __setup("print-fatal-signals=", setup_print_fatal_signals); 1283 1284 int 1285 __group_send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p) 1286 { 1287 return send_signal(sig, info, p, PIDTYPE_TGID); 1288 } 1289 1290 int do_send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p, 1291 enum pid_type type) 1292 { 1293 unsigned long flags; 1294 int ret = -ESRCH; 1295 1296 if (lock_task_sighand(p, &flags)) { 1297 ret = send_signal(sig, info, p, type); 1298 unlock_task_sighand(p, &flags); 1299 } 1300 1301 return ret; 1302 } 1303 1304 enum sig_handler { 1305 HANDLER_CURRENT, /* If reachable use the current handler */ 1306 HANDLER_SIG_DFL, /* Always use SIG_DFL handler semantics */ 1307 HANDLER_EXIT, /* Only visible as the process exit code */ 1308 }; 1309 1310 /* 1311 * Force a signal that the process can't ignore: if necessary 1312 * we unblock the signal and change any SIG_IGN to SIG_DFL. 1313 * 1314 * Note: If we unblock the signal, we always reset it to SIG_DFL, 1315 * since we do not want to have a signal handler that was blocked 1316 * be invoked when user space had explicitly blocked it. 1317 * 1318 * We don't want to have recursive SIGSEGV's etc, for example, 1319 * that is why we also clear SIGNAL_UNKILLABLE. 1320 */ 1321 static int 1322 force_sig_info_to_task(struct kernel_siginfo *info, struct task_struct *t, 1323 enum sig_handler handler) 1324 { 1325 unsigned long int flags; 1326 int ret, blocked, ignored; 1327 struct k_sigaction *action; 1328 int sig = info->si_signo; 1329 1330 spin_lock_irqsave(&t->sighand->siglock, flags); 1331 action = &t->sighand->action[sig-1]; 1332 ignored = action->sa.sa_handler == SIG_IGN; 1333 blocked = sigismember(&t->blocked, sig); 1334 if (blocked || ignored || (handler != HANDLER_CURRENT)) { 1335 action->sa.sa_handler = SIG_DFL; 1336 if (handler == HANDLER_EXIT) 1337 action->sa.sa_flags |= SA_IMMUTABLE; 1338 if (blocked) { 1339 sigdelset(&t->blocked, sig); 1340 recalc_sigpending_and_wake(t); 1341 } 1342 } 1343 /* 1344 * Don't clear SIGNAL_UNKILLABLE for traced tasks, users won't expect 1345 * debugging to leave init killable. 1346 */ 1347 if (action->sa.sa_handler == SIG_DFL && !t->ptrace) 1348 t->signal->flags &= ~SIGNAL_UNKILLABLE; 1349 ret = send_signal(sig, info, t, PIDTYPE_PID); 1350 spin_unlock_irqrestore(&t->sighand->siglock, flags); 1351 1352 return ret; 1353 } 1354 1355 int force_sig_info(struct kernel_siginfo *info) 1356 { 1357 return force_sig_info_to_task(info, current, HANDLER_CURRENT); 1358 } 1359 1360 /* 1361 * Nuke all other threads in the group. 1362 */ 1363 int zap_other_threads(struct task_struct *p) 1364 { 1365 struct task_struct *t = p; 1366 int count = 0; 1367 1368 p->signal->group_stop_count = 0; 1369 1370 while_each_thread(p, t) { 1371 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK); 1372 count++; 1373 1374 /* Don't bother with already dead threads */ 1375 if (t->exit_state) 1376 continue; 1377 sigaddset(&t->pending.signal, SIGKILL); 1378 signal_wake_up(t, 1); 1379 } 1380 1381 return count; 1382 } 1383 1384 struct sighand_struct *__lock_task_sighand(struct task_struct *tsk, 1385 unsigned long *flags) 1386 { 1387 struct sighand_struct *sighand; 1388 1389 rcu_read_lock(); 1390 for (;;) { 1391 sighand = rcu_dereference(tsk->sighand); 1392 if (unlikely(sighand == NULL)) 1393 break; 1394 1395 /* 1396 * This sighand can be already freed and even reused, but 1397 * we rely on SLAB_TYPESAFE_BY_RCU and sighand_ctor() which 1398 * initializes ->siglock: this slab can't go away, it has 1399 * the same object type, ->siglock can't be reinitialized. 1400 * 1401 * We need to ensure that tsk->sighand is still the same 1402 * after we take the lock, we can race with de_thread() or 1403 * __exit_signal(). In the latter case the next iteration 1404 * must see ->sighand == NULL. 1405 */ 1406 spin_lock_irqsave(&sighand->siglock, *flags); 1407 if (likely(sighand == rcu_access_pointer(tsk->sighand))) 1408 break; 1409 spin_unlock_irqrestore(&sighand->siglock, *flags); 1410 } 1411 rcu_read_unlock(); 1412 1413 return sighand; 1414 } 1415 1416 #ifdef CONFIG_LOCKDEP 1417 void lockdep_assert_task_sighand_held(struct task_struct *task) 1418 { 1419 struct sighand_struct *sighand; 1420 1421 rcu_read_lock(); 1422 sighand = rcu_dereference(task->sighand); 1423 if (sighand) 1424 lockdep_assert_held(&sighand->siglock); 1425 else 1426 WARN_ON_ONCE(1); 1427 rcu_read_unlock(); 1428 } 1429 #endif 1430 1431 /* 1432 * send signal info to all the members of a group 1433 */ 1434 int group_send_sig_info(int sig, struct kernel_siginfo *info, 1435 struct task_struct *p, enum pid_type type) 1436 { 1437 int ret; 1438 1439 rcu_read_lock(); 1440 ret = check_kill_permission(sig, info, p); 1441 rcu_read_unlock(); 1442 1443 if (!ret && sig) 1444 ret = do_send_sig_info(sig, info, p, type); 1445 1446 return ret; 1447 } 1448 1449 /* 1450 * __kill_pgrp_info() sends a signal to a process group: this is what the tty 1451 * control characters do (^C, ^Z etc) 1452 * - the caller must hold at least a readlock on tasklist_lock 1453 */ 1454 int __kill_pgrp_info(int sig, struct kernel_siginfo *info, struct pid *pgrp) 1455 { 1456 struct task_struct *p = NULL; 1457 int retval, success; 1458 1459 success = 0; 1460 retval = -ESRCH; 1461 do_each_pid_task(pgrp, PIDTYPE_PGID, p) { 1462 int err = group_send_sig_info(sig, info, p, PIDTYPE_PGID); 1463 success |= !err; 1464 retval = err; 1465 } while_each_pid_task(pgrp, PIDTYPE_PGID, p); 1466 return success ? 0 : retval; 1467 } 1468 1469 int kill_pid_info(int sig, struct kernel_siginfo *info, struct pid *pid) 1470 { 1471 int error = -ESRCH; 1472 struct task_struct *p; 1473 1474 for (;;) { 1475 rcu_read_lock(); 1476 p = pid_task(pid, PIDTYPE_PID); 1477 if (p) 1478 error = group_send_sig_info(sig, info, p, PIDTYPE_TGID); 1479 rcu_read_unlock(); 1480 if (likely(!p || error != -ESRCH)) 1481 return error; 1482 1483 /* 1484 * The task was unhashed in between, try again. If it 1485 * is dead, pid_task() will return NULL, if we race with 1486 * de_thread() it will find the new leader. 1487 */ 1488 } 1489 } 1490 1491 static int kill_proc_info(int sig, struct kernel_siginfo *info, pid_t pid) 1492 { 1493 int error; 1494 rcu_read_lock(); 1495 error = kill_pid_info(sig, info, find_vpid(pid)); 1496 rcu_read_unlock(); 1497 return error; 1498 } 1499 1500 static inline bool kill_as_cred_perm(const struct cred *cred, 1501 struct task_struct *target) 1502 { 1503 const struct cred *pcred = __task_cred(target); 1504 1505 return uid_eq(cred->euid, pcred->suid) || 1506 uid_eq(cred->euid, pcred->uid) || 1507 uid_eq(cred->uid, pcred->suid) || 1508 uid_eq(cred->uid, pcred->uid); 1509 } 1510 1511 /* 1512 * The usb asyncio usage of siginfo is wrong. The glibc support 1513 * for asyncio which uses SI_ASYNCIO assumes the layout is SIL_RT. 1514 * AKA after the generic fields: 1515 * kernel_pid_t si_pid; 1516 * kernel_uid32_t si_uid; 1517 * sigval_t si_value; 1518 * 1519 * Unfortunately when usb generates SI_ASYNCIO it assumes the layout 1520 * after the generic fields is: 1521 * void __user *si_addr; 1522 * 1523 * This is a practical problem when there is a 64bit big endian kernel 1524 * and a 32bit userspace. As the 32bit address will encoded in the low 1525 * 32bits of the pointer. Those low 32bits will be stored at higher 1526 * address than appear in a 32 bit pointer. So userspace will not 1527 * see the address it was expecting for it's completions. 1528 * 1529 * There is nothing in the encoding that can allow 1530 * copy_siginfo_to_user32 to detect this confusion of formats, so 1531 * handle this by requiring the caller of kill_pid_usb_asyncio to 1532 * notice when this situration takes place and to store the 32bit 1533 * pointer in sival_int, instead of sival_addr of the sigval_t addr 1534 * parameter. 1535 */ 1536 int kill_pid_usb_asyncio(int sig, int errno, sigval_t addr, 1537 struct pid *pid, const struct cred *cred) 1538 { 1539 struct kernel_siginfo info; 1540 struct task_struct *p; 1541 unsigned long flags; 1542 int ret = -EINVAL; 1543 1544 if (!valid_signal(sig)) 1545 return ret; 1546 1547 clear_siginfo(&info); 1548 info.si_signo = sig; 1549 info.si_errno = errno; 1550 info.si_code = SI_ASYNCIO; 1551 *((sigval_t *)&info.si_pid) = addr; 1552 1553 rcu_read_lock(); 1554 p = pid_task(pid, PIDTYPE_PID); 1555 if (!p) { 1556 ret = -ESRCH; 1557 goto out_unlock; 1558 } 1559 if (!kill_as_cred_perm(cred, p)) { 1560 ret = -EPERM; 1561 goto out_unlock; 1562 } 1563 ret = security_task_kill(p, &info, sig, cred); 1564 if (ret) 1565 goto out_unlock; 1566 1567 if (sig) { 1568 if (lock_task_sighand(p, &flags)) { 1569 ret = __send_signal(sig, &info, p, PIDTYPE_TGID, false); 1570 unlock_task_sighand(p, &flags); 1571 } else 1572 ret = -ESRCH; 1573 } 1574 out_unlock: 1575 rcu_read_unlock(); 1576 return ret; 1577 } 1578 EXPORT_SYMBOL_GPL(kill_pid_usb_asyncio); 1579 1580 /* 1581 * kill_something_info() interprets pid in interesting ways just like kill(2). 1582 * 1583 * POSIX specifies that kill(-1,sig) is unspecified, but what we have 1584 * is probably wrong. Should make it like BSD or SYSV. 1585 */ 1586 1587 static int kill_something_info(int sig, struct kernel_siginfo *info, pid_t pid) 1588 { 1589 int ret; 1590 1591 if (pid > 0) 1592 return kill_proc_info(sig, info, pid); 1593 1594 /* -INT_MIN is undefined. Exclude this case to avoid a UBSAN warning */ 1595 if (pid == INT_MIN) 1596 return -ESRCH; 1597 1598 read_lock(&tasklist_lock); 1599 if (pid != -1) { 1600 ret = __kill_pgrp_info(sig, info, 1601 pid ? find_vpid(-pid) : task_pgrp(current)); 1602 } else { 1603 int retval = 0, count = 0; 1604 struct task_struct * p; 1605 1606 for_each_process(p) { 1607 if (task_pid_vnr(p) > 1 && 1608 !same_thread_group(p, current)) { 1609 int err = group_send_sig_info(sig, info, p, 1610 PIDTYPE_MAX); 1611 ++count; 1612 if (err != -EPERM) 1613 retval = err; 1614 } 1615 } 1616 ret = count ? retval : -ESRCH; 1617 } 1618 read_unlock(&tasklist_lock); 1619 1620 return ret; 1621 } 1622 1623 /* 1624 * These are for backward compatibility with the rest of the kernel source. 1625 */ 1626 1627 int send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p) 1628 { 1629 /* 1630 * Make sure legacy kernel users don't send in bad values 1631 * (normal paths check this in check_kill_permission). 1632 */ 1633 if (!valid_signal(sig)) 1634 return -EINVAL; 1635 1636 return do_send_sig_info(sig, info, p, PIDTYPE_PID); 1637 } 1638 EXPORT_SYMBOL(send_sig_info); 1639 1640 #define __si_special(priv) \ 1641 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO) 1642 1643 int 1644 send_sig(int sig, struct task_struct *p, int priv) 1645 { 1646 return send_sig_info(sig, __si_special(priv), p); 1647 } 1648 EXPORT_SYMBOL(send_sig); 1649 1650 void force_sig(int sig) 1651 { 1652 struct kernel_siginfo info; 1653 1654 clear_siginfo(&info); 1655 info.si_signo = sig; 1656 info.si_errno = 0; 1657 info.si_code = SI_KERNEL; 1658 info.si_pid = 0; 1659 info.si_uid = 0; 1660 force_sig_info(&info); 1661 } 1662 EXPORT_SYMBOL(force_sig); 1663 1664 void force_fatal_sig(int sig) 1665 { 1666 struct kernel_siginfo info; 1667 1668 clear_siginfo(&info); 1669 info.si_signo = sig; 1670 info.si_errno = 0; 1671 info.si_code = SI_KERNEL; 1672 info.si_pid = 0; 1673 info.si_uid = 0; 1674 force_sig_info_to_task(&info, current, HANDLER_SIG_DFL); 1675 } 1676 1677 void force_exit_sig(int sig) 1678 { 1679 struct kernel_siginfo info; 1680 1681 clear_siginfo(&info); 1682 info.si_signo = sig; 1683 info.si_errno = 0; 1684 info.si_code = SI_KERNEL; 1685 info.si_pid = 0; 1686 info.si_uid = 0; 1687 force_sig_info_to_task(&info, current, HANDLER_EXIT); 1688 } 1689 1690 /* 1691 * When things go south during signal handling, we 1692 * will force a SIGSEGV. And if the signal that caused 1693 * the problem was already a SIGSEGV, we'll want to 1694 * make sure we don't even try to deliver the signal.. 1695 */ 1696 void force_sigsegv(int sig) 1697 { 1698 if (sig == SIGSEGV) 1699 force_fatal_sig(SIGSEGV); 1700 else 1701 force_sig(SIGSEGV); 1702 } 1703 1704 int force_sig_fault_to_task(int sig, int code, void __user *addr 1705 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr) 1706 , struct task_struct *t) 1707 { 1708 struct kernel_siginfo info; 1709 1710 clear_siginfo(&info); 1711 info.si_signo = sig; 1712 info.si_errno = 0; 1713 info.si_code = code; 1714 info.si_addr = addr; 1715 #ifdef __ia64__ 1716 info.si_imm = imm; 1717 info.si_flags = flags; 1718 info.si_isr = isr; 1719 #endif 1720 return force_sig_info_to_task(&info, t, HANDLER_CURRENT); 1721 } 1722 1723 int force_sig_fault(int sig, int code, void __user *addr 1724 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)) 1725 { 1726 return force_sig_fault_to_task(sig, code, addr 1727 ___ARCH_SI_IA64(imm, flags, isr), current); 1728 } 1729 1730 int send_sig_fault(int sig, int code, void __user *addr 1731 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr) 1732 , struct task_struct *t) 1733 { 1734 struct kernel_siginfo info; 1735 1736 clear_siginfo(&info); 1737 info.si_signo = sig; 1738 info.si_errno = 0; 1739 info.si_code = code; 1740 info.si_addr = addr; 1741 #ifdef __ia64__ 1742 info.si_imm = imm; 1743 info.si_flags = flags; 1744 info.si_isr = isr; 1745 #endif 1746 return send_sig_info(info.si_signo, &info, t); 1747 } 1748 1749 int force_sig_mceerr(int code, void __user *addr, short lsb) 1750 { 1751 struct kernel_siginfo info; 1752 1753 WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR)); 1754 clear_siginfo(&info); 1755 info.si_signo = SIGBUS; 1756 info.si_errno = 0; 1757 info.si_code = code; 1758 info.si_addr = addr; 1759 info.si_addr_lsb = lsb; 1760 return force_sig_info(&info); 1761 } 1762 1763 int send_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct *t) 1764 { 1765 struct kernel_siginfo info; 1766 1767 WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR)); 1768 clear_siginfo(&info); 1769 info.si_signo = SIGBUS; 1770 info.si_errno = 0; 1771 info.si_code = code; 1772 info.si_addr = addr; 1773 info.si_addr_lsb = lsb; 1774 return send_sig_info(info.si_signo, &info, t); 1775 } 1776 EXPORT_SYMBOL(send_sig_mceerr); 1777 1778 int force_sig_bnderr(void __user *addr, void __user *lower, void __user *upper) 1779 { 1780 struct kernel_siginfo info; 1781 1782 clear_siginfo(&info); 1783 info.si_signo = SIGSEGV; 1784 info.si_errno = 0; 1785 info.si_code = SEGV_BNDERR; 1786 info.si_addr = addr; 1787 info.si_lower = lower; 1788 info.si_upper = upper; 1789 return force_sig_info(&info); 1790 } 1791 1792 #ifdef SEGV_PKUERR 1793 int force_sig_pkuerr(void __user *addr, u32 pkey) 1794 { 1795 struct kernel_siginfo info; 1796 1797 clear_siginfo(&info); 1798 info.si_signo = SIGSEGV; 1799 info.si_errno = 0; 1800 info.si_code = SEGV_PKUERR; 1801 info.si_addr = addr; 1802 info.si_pkey = pkey; 1803 return force_sig_info(&info); 1804 } 1805 #endif 1806 1807 int force_sig_perf(void __user *addr, u32 type, u64 sig_data) 1808 { 1809 struct kernel_siginfo info; 1810 1811 clear_siginfo(&info); 1812 info.si_signo = SIGTRAP; 1813 info.si_errno = 0; 1814 info.si_code = TRAP_PERF; 1815 info.si_addr = addr; 1816 info.si_perf_data = sig_data; 1817 info.si_perf_type = type; 1818 1819 return force_sig_info(&info); 1820 } 1821 1822 /** 1823 * force_sig_seccomp - signals the task to allow in-process syscall emulation 1824 * @syscall: syscall number to send to userland 1825 * @reason: filter-supplied reason code to send to userland (via si_errno) 1826 * @force_coredump: true to trigger a coredump 1827 * 1828 * Forces a SIGSYS with a code of SYS_SECCOMP and related sigsys info. 1829 */ 1830 int force_sig_seccomp(int syscall, int reason, bool force_coredump) 1831 { 1832 struct kernel_siginfo info; 1833 1834 clear_siginfo(&info); 1835 info.si_signo = SIGSYS; 1836 info.si_code = SYS_SECCOMP; 1837 info.si_call_addr = (void __user *)KSTK_EIP(current); 1838 info.si_errno = reason; 1839 info.si_arch = syscall_get_arch(current); 1840 info.si_syscall = syscall; 1841 return force_sig_info_to_task(&info, current, 1842 force_coredump ? HANDLER_EXIT : HANDLER_CURRENT); 1843 } 1844 1845 /* For the crazy architectures that include trap information in 1846 * the errno field, instead of an actual errno value. 1847 */ 1848 int force_sig_ptrace_errno_trap(int errno, void __user *addr) 1849 { 1850 struct kernel_siginfo info; 1851 1852 clear_siginfo(&info); 1853 info.si_signo = SIGTRAP; 1854 info.si_errno = errno; 1855 info.si_code = TRAP_HWBKPT; 1856 info.si_addr = addr; 1857 return force_sig_info(&info); 1858 } 1859 1860 /* For the rare architectures that include trap information using 1861 * si_trapno. 1862 */ 1863 int force_sig_fault_trapno(int sig, int code, void __user *addr, int trapno) 1864 { 1865 struct kernel_siginfo info; 1866 1867 clear_siginfo(&info); 1868 info.si_signo = sig; 1869 info.si_errno = 0; 1870 info.si_code = code; 1871 info.si_addr = addr; 1872 info.si_trapno = trapno; 1873 return force_sig_info(&info); 1874 } 1875 1876 /* For the rare architectures that include trap information using 1877 * si_trapno. 1878 */ 1879 int send_sig_fault_trapno(int sig, int code, void __user *addr, int trapno, 1880 struct task_struct *t) 1881 { 1882 struct kernel_siginfo info; 1883 1884 clear_siginfo(&info); 1885 info.si_signo = sig; 1886 info.si_errno = 0; 1887 info.si_code = code; 1888 info.si_addr = addr; 1889 info.si_trapno = trapno; 1890 return send_sig_info(info.si_signo, &info, t); 1891 } 1892 1893 int kill_pgrp(struct pid *pid, int sig, int priv) 1894 { 1895 int ret; 1896 1897 read_lock(&tasklist_lock); 1898 ret = __kill_pgrp_info(sig, __si_special(priv), pid); 1899 read_unlock(&tasklist_lock); 1900 1901 return ret; 1902 } 1903 EXPORT_SYMBOL(kill_pgrp); 1904 1905 int kill_pid(struct pid *pid, int sig, int priv) 1906 { 1907 return kill_pid_info(sig, __si_special(priv), pid); 1908 } 1909 EXPORT_SYMBOL(kill_pid); 1910 1911 /* 1912 * These functions support sending signals using preallocated sigqueue 1913 * structures. This is needed "because realtime applications cannot 1914 * afford to lose notifications of asynchronous events, like timer 1915 * expirations or I/O completions". In the case of POSIX Timers 1916 * we allocate the sigqueue structure from the timer_create. If this 1917 * allocation fails we are able to report the failure to the application 1918 * with an EAGAIN error. 1919 */ 1920 struct sigqueue *sigqueue_alloc(void) 1921 { 1922 return __sigqueue_alloc(-1, current, GFP_KERNEL, 0, SIGQUEUE_PREALLOC); 1923 } 1924 1925 void sigqueue_free(struct sigqueue *q) 1926 { 1927 unsigned long flags; 1928 spinlock_t *lock = ¤t->sighand->siglock; 1929 1930 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC)); 1931 /* 1932 * We must hold ->siglock while testing q->list 1933 * to serialize with collect_signal() or with 1934 * __exit_signal()->flush_sigqueue(). 1935 */ 1936 spin_lock_irqsave(lock, flags); 1937 q->flags &= ~SIGQUEUE_PREALLOC; 1938 /* 1939 * If it is queued it will be freed when dequeued, 1940 * like the "regular" sigqueue. 1941 */ 1942 if (!list_empty(&q->list)) 1943 q = NULL; 1944 spin_unlock_irqrestore(lock, flags); 1945 1946 if (q) 1947 __sigqueue_free(q); 1948 } 1949 1950 int send_sigqueue(struct sigqueue *q, struct pid *pid, enum pid_type type) 1951 { 1952 int sig = q->info.si_signo; 1953 struct sigpending *pending; 1954 struct task_struct *t; 1955 unsigned long flags; 1956 int ret, result; 1957 1958 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC)); 1959 1960 ret = -1; 1961 rcu_read_lock(); 1962 t = pid_task(pid, type); 1963 if (!t || !likely(lock_task_sighand(t, &flags))) 1964 goto ret; 1965 1966 ret = 1; /* the signal is ignored */ 1967 result = TRACE_SIGNAL_IGNORED; 1968 if (!prepare_signal(sig, t, false)) 1969 goto out; 1970 1971 ret = 0; 1972 if (unlikely(!list_empty(&q->list))) { 1973 /* 1974 * If an SI_TIMER entry is already queue just increment 1975 * the overrun count. 1976 */ 1977 BUG_ON(q->info.si_code != SI_TIMER); 1978 q->info.si_overrun++; 1979 result = TRACE_SIGNAL_ALREADY_PENDING; 1980 goto out; 1981 } 1982 q->info.si_overrun = 0; 1983 1984 signalfd_notify(t, sig); 1985 pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending; 1986 list_add_tail(&q->list, &pending->list); 1987 sigaddset(&pending->signal, sig); 1988 complete_signal(sig, t, type); 1989 result = TRACE_SIGNAL_DELIVERED; 1990 out: 1991 trace_signal_generate(sig, &q->info, t, type != PIDTYPE_PID, result); 1992 unlock_task_sighand(t, &flags); 1993 ret: 1994 rcu_read_unlock(); 1995 return ret; 1996 } 1997 1998 static void do_notify_pidfd(struct task_struct *task) 1999 { 2000 struct pid *pid; 2001 2002 WARN_ON(task->exit_state == 0); 2003 pid = task_pid(task); 2004 wake_up_all(&pid->wait_pidfd); 2005 } 2006 2007 /* 2008 * Let a parent know about the death of a child. 2009 * For a stopped/continued status change, use do_notify_parent_cldstop instead. 2010 * 2011 * Returns true if our parent ignored us and so we've switched to 2012 * self-reaping. 2013 */ 2014 bool do_notify_parent(struct task_struct *tsk, int sig) 2015 { 2016 struct kernel_siginfo info; 2017 unsigned long flags; 2018 struct sighand_struct *psig; 2019 bool autoreap = false; 2020 u64 utime, stime; 2021 2022 BUG_ON(sig == -1); 2023 2024 /* do_notify_parent_cldstop should have been called instead. */ 2025 BUG_ON(task_is_stopped_or_traced(tsk)); 2026 2027 BUG_ON(!tsk->ptrace && 2028 (tsk->group_leader != tsk || !thread_group_empty(tsk))); 2029 2030 /* Wake up all pidfd waiters */ 2031 do_notify_pidfd(tsk); 2032 2033 if (sig != SIGCHLD) { 2034 /* 2035 * This is only possible if parent == real_parent. 2036 * Check if it has changed security domain. 2037 */ 2038 if (tsk->parent_exec_id != READ_ONCE(tsk->parent->self_exec_id)) 2039 sig = SIGCHLD; 2040 } 2041 2042 clear_siginfo(&info); 2043 info.si_signo = sig; 2044 info.si_errno = 0; 2045 /* 2046 * We are under tasklist_lock here so our parent is tied to 2047 * us and cannot change. 2048 * 2049 * task_active_pid_ns will always return the same pid namespace 2050 * until a task passes through release_task. 2051 * 2052 * write_lock() currently calls preempt_disable() which is the 2053 * same as rcu_read_lock(), but according to Oleg, this is not 2054 * correct to rely on this 2055 */ 2056 rcu_read_lock(); 2057 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent)); 2058 info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns), 2059 task_uid(tsk)); 2060 rcu_read_unlock(); 2061 2062 task_cputime(tsk, &utime, &stime); 2063 info.si_utime = nsec_to_clock_t(utime + tsk->signal->utime); 2064 info.si_stime = nsec_to_clock_t(stime + tsk->signal->stime); 2065 2066 info.si_status = tsk->exit_code & 0x7f; 2067 if (tsk->exit_code & 0x80) 2068 info.si_code = CLD_DUMPED; 2069 else if (tsk->exit_code & 0x7f) 2070 info.si_code = CLD_KILLED; 2071 else { 2072 info.si_code = CLD_EXITED; 2073 info.si_status = tsk->exit_code >> 8; 2074 } 2075 2076 psig = tsk->parent->sighand; 2077 spin_lock_irqsave(&psig->siglock, flags); 2078 if (!tsk->ptrace && sig == SIGCHLD && 2079 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN || 2080 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) { 2081 /* 2082 * We are exiting and our parent doesn't care. POSIX.1 2083 * defines special semantics for setting SIGCHLD to SIG_IGN 2084 * or setting the SA_NOCLDWAIT flag: we should be reaped 2085 * automatically and not left for our parent's wait4 call. 2086 * Rather than having the parent do it as a magic kind of 2087 * signal handler, we just set this to tell do_exit that we 2088 * can be cleaned up without becoming a zombie. Note that 2089 * we still call __wake_up_parent in this case, because a 2090 * blocked sys_wait4 might now return -ECHILD. 2091 * 2092 * Whether we send SIGCHLD or not for SA_NOCLDWAIT 2093 * is implementation-defined: we do (if you don't want 2094 * it, just use SIG_IGN instead). 2095 */ 2096 autoreap = true; 2097 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) 2098 sig = 0; 2099 } 2100 /* 2101 * Send with __send_signal as si_pid and si_uid are in the 2102 * parent's namespaces. 2103 */ 2104 if (valid_signal(sig) && sig) 2105 __send_signal(sig, &info, tsk->parent, PIDTYPE_TGID, false); 2106 __wake_up_parent(tsk, tsk->parent); 2107 spin_unlock_irqrestore(&psig->siglock, flags); 2108 2109 return autoreap; 2110 } 2111 2112 /** 2113 * do_notify_parent_cldstop - notify parent of stopped/continued state change 2114 * @tsk: task reporting the state change 2115 * @for_ptracer: the notification is for ptracer 2116 * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report 2117 * 2118 * Notify @tsk's parent that the stopped/continued state has changed. If 2119 * @for_ptracer is %false, @tsk's group leader notifies to its real parent. 2120 * If %true, @tsk reports to @tsk->parent which should be the ptracer. 2121 * 2122 * CONTEXT: 2123 * Must be called with tasklist_lock at least read locked. 2124 */ 2125 static void do_notify_parent_cldstop(struct task_struct *tsk, 2126 bool for_ptracer, int why) 2127 { 2128 struct kernel_siginfo info; 2129 unsigned long flags; 2130 struct task_struct *parent; 2131 struct sighand_struct *sighand; 2132 u64 utime, stime; 2133 2134 if (for_ptracer) { 2135 parent = tsk->parent; 2136 } else { 2137 tsk = tsk->group_leader; 2138 parent = tsk->real_parent; 2139 } 2140 2141 clear_siginfo(&info); 2142 info.si_signo = SIGCHLD; 2143 info.si_errno = 0; 2144 /* 2145 * see comment in do_notify_parent() about the following 4 lines 2146 */ 2147 rcu_read_lock(); 2148 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent)); 2149 info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk)); 2150 rcu_read_unlock(); 2151 2152 task_cputime(tsk, &utime, &stime); 2153 info.si_utime = nsec_to_clock_t(utime); 2154 info.si_stime = nsec_to_clock_t(stime); 2155 2156 info.si_code = why; 2157 switch (why) { 2158 case CLD_CONTINUED: 2159 info.si_status = SIGCONT; 2160 break; 2161 case CLD_STOPPED: 2162 info.si_status = tsk->signal->group_exit_code & 0x7f; 2163 break; 2164 case CLD_TRAPPED: 2165 info.si_status = tsk->exit_code & 0x7f; 2166 break; 2167 default: 2168 BUG(); 2169 } 2170 2171 sighand = parent->sighand; 2172 spin_lock_irqsave(&sighand->siglock, flags); 2173 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN && 2174 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP)) 2175 __group_send_sig_info(SIGCHLD, &info, parent); 2176 /* 2177 * Even if SIGCHLD is not generated, we must wake up wait4 calls. 2178 */ 2179 __wake_up_parent(tsk, parent); 2180 spin_unlock_irqrestore(&sighand->siglock, flags); 2181 } 2182 2183 /* 2184 * This must be called with current->sighand->siglock held. 2185 * 2186 * This should be the path for all ptrace stops. 2187 * We always set current->last_siginfo while stopped here. 2188 * That makes it a way to test a stopped process for 2189 * being ptrace-stopped vs being job-control-stopped. 2190 * 2191 * If we actually decide not to stop at all because the tracer 2192 * is gone, we keep current->exit_code unless clear_code. 2193 */ 2194 static void ptrace_stop(int exit_code, int why, int clear_code, kernel_siginfo_t *info) 2195 __releases(¤t->sighand->siglock) 2196 __acquires(¤t->sighand->siglock) 2197 { 2198 bool gstop_done = false; 2199 2200 if (arch_ptrace_stop_needed()) { 2201 /* 2202 * The arch code has something special to do before a 2203 * ptrace stop. This is allowed to block, e.g. for faults 2204 * on user stack pages. We can't keep the siglock while 2205 * calling arch_ptrace_stop, so we must release it now. 2206 * To preserve proper semantics, we must do this before 2207 * any signal bookkeeping like checking group_stop_count. 2208 */ 2209 spin_unlock_irq(¤t->sighand->siglock); 2210 arch_ptrace_stop(); 2211 spin_lock_irq(¤t->sighand->siglock); 2212 } 2213 2214 /* 2215 * schedule() will not sleep if there is a pending signal that 2216 * can awaken the task. 2217 */ 2218 set_special_state(TASK_TRACED); 2219 2220 /* 2221 * We're committing to trapping. TRACED should be visible before 2222 * TRAPPING is cleared; otherwise, the tracer might fail do_wait(). 2223 * Also, transition to TRACED and updates to ->jobctl should be 2224 * atomic with respect to siglock and should be done after the arch 2225 * hook as siglock is released and regrabbed across it. 2226 * 2227 * TRACER TRACEE 2228 * 2229 * ptrace_attach() 2230 * [L] wait_on_bit(JOBCTL_TRAPPING) [S] set_special_state(TRACED) 2231 * do_wait() 2232 * set_current_state() smp_wmb(); 2233 * ptrace_do_wait() 2234 * wait_task_stopped() 2235 * task_stopped_code() 2236 * [L] task_is_traced() [S] task_clear_jobctl_trapping(); 2237 */ 2238 smp_wmb(); 2239 2240 current->last_siginfo = info; 2241 current->exit_code = exit_code; 2242 2243 /* 2244 * If @why is CLD_STOPPED, we're trapping to participate in a group 2245 * stop. Do the bookkeeping. Note that if SIGCONT was delievered 2246 * across siglock relocks since INTERRUPT was scheduled, PENDING 2247 * could be clear now. We act as if SIGCONT is received after 2248 * TASK_TRACED is entered - ignore it. 2249 */ 2250 if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING)) 2251 gstop_done = task_participate_group_stop(current); 2252 2253 /* any trap clears pending STOP trap, STOP trap clears NOTIFY */ 2254 task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP); 2255 if (info && info->si_code >> 8 == PTRACE_EVENT_STOP) 2256 task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY); 2257 2258 /* entering a trap, clear TRAPPING */ 2259 task_clear_jobctl_trapping(current); 2260 2261 spin_unlock_irq(¤t->sighand->siglock); 2262 read_lock(&tasklist_lock); 2263 if (likely(current->ptrace)) { 2264 /* 2265 * Notify parents of the stop. 2266 * 2267 * While ptraced, there are two parents - the ptracer and 2268 * the real_parent of the group_leader. The ptracer should 2269 * know about every stop while the real parent is only 2270 * interested in the completion of group stop. The states 2271 * for the two don't interact with each other. Notify 2272 * separately unless they're gonna be duplicates. 2273 */ 2274 do_notify_parent_cldstop(current, true, why); 2275 if (gstop_done && ptrace_reparented(current)) 2276 do_notify_parent_cldstop(current, false, why); 2277 2278 /* 2279 * Don't want to allow preemption here, because 2280 * sys_ptrace() needs this task to be inactive. 2281 * 2282 * XXX: implement read_unlock_no_resched(). 2283 */ 2284 preempt_disable(); 2285 read_unlock(&tasklist_lock); 2286 cgroup_enter_frozen(); 2287 preempt_enable_no_resched(); 2288 freezable_schedule(); 2289 cgroup_leave_frozen(true); 2290 } else { 2291 /* 2292 * By the time we got the lock, our tracer went away. 2293 * Don't drop the lock yet, another tracer may come. 2294 * 2295 * If @gstop_done, the ptracer went away between group stop 2296 * completion and here. During detach, it would have set 2297 * JOBCTL_STOP_PENDING on us and we'll re-enter 2298 * TASK_STOPPED in do_signal_stop() on return, so notifying 2299 * the real parent of the group stop completion is enough. 2300 */ 2301 if (gstop_done) 2302 do_notify_parent_cldstop(current, false, why); 2303 2304 /* tasklist protects us from ptrace_freeze_traced() */ 2305 __set_current_state(TASK_RUNNING); 2306 if (clear_code) 2307 current->exit_code = 0; 2308 read_unlock(&tasklist_lock); 2309 } 2310 2311 /* 2312 * We are back. Now reacquire the siglock before touching 2313 * last_siginfo, so that we are sure to have synchronized with 2314 * any signal-sending on another CPU that wants to examine it. 2315 */ 2316 spin_lock_irq(¤t->sighand->siglock); 2317 current->last_siginfo = NULL; 2318 2319 /* LISTENING can be set only during STOP traps, clear it */ 2320 current->jobctl &= ~JOBCTL_LISTENING; 2321 2322 /* 2323 * Queued signals ignored us while we were stopped for tracing. 2324 * So check for any that we should take before resuming user mode. 2325 * This sets TIF_SIGPENDING, but never clears it. 2326 */ 2327 recalc_sigpending_tsk(current); 2328 } 2329 2330 static void ptrace_do_notify(int signr, int exit_code, int why) 2331 { 2332 kernel_siginfo_t info; 2333 2334 clear_siginfo(&info); 2335 info.si_signo = signr; 2336 info.si_code = exit_code; 2337 info.si_pid = task_pid_vnr(current); 2338 info.si_uid = from_kuid_munged(current_user_ns(), current_uid()); 2339 2340 /* Let the debugger run. */ 2341 ptrace_stop(exit_code, why, 1, &info); 2342 } 2343 2344 void ptrace_notify(int exit_code) 2345 { 2346 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP); 2347 if (unlikely(task_work_pending(current))) 2348 task_work_run(); 2349 2350 spin_lock_irq(¤t->sighand->siglock); 2351 ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED); 2352 spin_unlock_irq(¤t->sighand->siglock); 2353 } 2354 2355 /** 2356 * do_signal_stop - handle group stop for SIGSTOP and other stop signals 2357 * @signr: signr causing group stop if initiating 2358 * 2359 * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr 2360 * and participate in it. If already set, participate in the existing 2361 * group stop. If participated in a group stop (and thus slept), %true is 2362 * returned with siglock released. 2363 * 2364 * If ptraced, this function doesn't handle stop itself. Instead, 2365 * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock 2366 * untouched. The caller must ensure that INTERRUPT trap handling takes 2367 * places afterwards. 2368 * 2369 * CONTEXT: 2370 * Must be called with @current->sighand->siglock held, which is released 2371 * on %true return. 2372 * 2373 * RETURNS: 2374 * %false if group stop is already cancelled or ptrace trap is scheduled. 2375 * %true if participated in group stop. 2376 */ 2377 static bool do_signal_stop(int signr) 2378 __releases(¤t->sighand->siglock) 2379 { 2380 struct signal_struct *sig = current->signal; 2381 2382 if (!(current->jobctl & JOBCTL_STOP_PENDING)) { 2383 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME; 2384 struct task_struct *t; 2385 2386 /* signr will be recorded in task->jobctl for retries */ 2387 WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK); 2388 2389 if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) || 2390 unlikely(sig->flags & SIGNAL_GROUP_EXIT) || 2391 unlikely(sig->group_exec_task)) 2392 return false; 2393 /* 2394 * There is no group stop already in progress. We must 2395 * initiate one now. 2396 * 2397 * While ptraced, a task may be resumed while group stop is 2398 * still in effect and then receive a stop signal and 2399 * initiate another group stop. This deviates from the 2400 * usual behavior as two consecutive stop signals can't 2401 * cause two group stops when !ptraced. That is why we 2402 * also check !task_is_stopped(t) below. 2403 * 2404 * The condition can be distinguished by testing whether 2405 * SIGNAL_STOP_STOPPED is already set. Don't generate 2406 * group_exit_code in such case. 2407 * 2408 * This is not necessary for SIGNAL_STOP_CONTINUED because 2409 * an intervening stop signal is required to cause two 2410 * continued events regardless of ptrace. 2411 */ 2412 if (!(sig->flags & SIGNAL_STOP_STOPPED)) 2413 sig->group_exit_code = signr; 2414 2415 sig->group_stop_count = 0; 2416 2417 if (task_set_jobctl_pending(current, signr | gstop)) 2418 sig->group_stop_count++; 2419 2420 t = current; 2421 while_each_thread(current, t) { 2422 /* 2423 * Setting state to TASK_STOPPED for a group 2424 * stop is always done with the siglock held, 2425 * so this check has no races. 2426 */ 2427 if (!task_is_stopped(t) && 2428 task_set_jobctl_pending(t, signr | gstop)) { 2429 sig->group_stop_count++; 2430 if (likely(!(t->ptrace & PT_SEIZED))) 2431 signal_wake_up(t, 0); 2432 else 2433 ptrace_trap_notify(t); 2434 } 2435 } 2436 } 2437 2438 if (likely(!current->ptrace)) { 2439 int notify = 0; 2440 2441 /* 2442 * If there are no other threads in the group, or if there 2443 * is a group stop in progress and we are the last to stop, 2444 * report to the parent. 2445 */ 2446 if (task_participate_group_stop(current)) 2447 notify = CLD_STOPPED; 2448 2449 set_special_state(TASK_STOPPED); 2450 spin_unlock_irq(¤t->sighand->siglock); 2451 2452 /* 2453 * Notify the parent of the group stop completion. Because 2454 * we're not holding either the siglock or tasklist_lock 2455 * here, ptracer may attach inbetween; however, this is for 2456 * group stop and should always be delivered to the real 2457 * parent of the group leader. The new ptracer will get 2458 * its notification when this task transitions into 2459 * TASK_TRACED. 2460 */ 2461 if (notify) { 2462 read_lock(&tasklist_lock); 2463 do_notify_parent_cldstop(current, false, notify); 2464 read_unlock(&tasklist_lock); 2465 } 2466 2467 /* Now we don't run again until woken by SIGCONT or SIGKILL */ 2468 cgroup_enter_frozen(); 2469 freezable_schedule(); 2470 return true; 2471 } else { 2472 /* 2473 * While ptraced, group stop is handled by STOP trap. 2474 * Schedule it and let the caller deal with it. 2475 */ 2476 task_set_jobctl_pending(current, JOBCTL_TRAP_STOP); 2477 return false; 2478 } 2479 } 2480 2481 /** 2482 * do_jobctl_trap - take care of ptrace jobctl traps 2483 * 2484 * When PT_SEIZED, it's used for both group stop and explicit 2485 * SEIZE/INTERRUPT traps. Both generate PTRACE_EVENT_STOP trap with 2486 * accompanying siginfo. If stopped, lower eight bits of exit_code contain 2487 * the stop signal; otherwise, %SIGTRAP. 2488 * 2489 * When !PT_SEIZED, it's used only for group stop trap with stop signal 2490 * number as exit_code and no siginfo. 2491 * 2492 * CONTEXT: 2493 * Must be called with @current->sighand->siglock held, which may be 2494 * released and re-acquired before returning with intervening sleep. 2495 */ 2496 static void do_jobctl_trap(void) 2497 { 2498 struct signal_struct *signal = current->signal; 2499 int signr = current->jobctl & JOBCTL_STOP_SIGMASK; 2500 2501 if (current->ptrace & PT_SEIZED) { 2502 if (!signal->group_stop_count && 2503 !(signal->flags & SIGNAL_STOP_STOPPED)) 2504 signr = SIGTRAP; 2505 WARN_ON_ONCE(!signr); 2506 ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8), 2507 CLD_STOPPED); 2508 } else { 2509 WARN_ON_ONCE(!signr); 2510 ptrace_stop(signr, CLD_STOPPED, 0, NULL); 2511 current->exit_code = 0; 2512 } 2513 } 2514 2515 /** 2516 * do_freezer_trap - handle the freezer jobctl trap 2517 * 2518 * Puts the task into frozen state, if only the task is not about to quit. 2519 * In this case it drops JOBCTL_TRAP_FREEZE. 2520 * 2521 * CONTEXT: 2522 * Must be called with @current->sighand->siglock held, 2523 * which is always released before returning. 2524 */ 2525 static void do_freezer_trap(void) 2526 __releases(¤t->sighand->siglock) 2527 { 2528 /* 2529 * If there are other trap bits pending except JOBCTL_TRAP_FREEZE, 2530 * let's make another loop to give it a chance to be handled. 2531 * In any case, we'll return back. 2532 */ 2533 if ((current->jobctl & (JOBCTL_PENDING_MASK | JOBCTL_TRAP_FREEZE)) != 2534 JOBCTL_TRAP_FREEZE) { 2535 spin_unlock_irq(¤t->sighand->siglock); 2536 return; 2537 } 2538 2539 /* 2540 * Now we're sure that there is no pending fatal signal and no 2541 * pending traps. Clear TIF_SIGPENDING to not get out of schedule() 2542 * immediately (if there is a non-fatal signal pending), and 2543 * put the task into sleep. 2544 */ 2545 __set_current_state(TASK_INTERRUPTIBLE); 2546 clear_thread_flag(TIF_SIGPENDING); 2547 spin_unlock_irq(¤t->sighand->siglock); 2548 cgroup_enter_frozen(); 2549 freezable_schedule(); 2550 } 2551 2552 static int ptrace_signal(int signr, kernel_siginfo_t *info, enum pid_type type) 2553 { 2554 /* 2555 * We do not check sig_kernel_stop(signr) but set this marker 2556 * unconditionally because we do not know whether debugger will 2557 * change signr. This flag has no meaning unless we are going 2558 * to stop after return from ptrace_stop(). In this case it will 2559 * be checked in do_signal_stop(), we should only stop if it was 2560 * not cleared by SIGCONT while we were sleeping. See also the 2561 * comment in dequeue_signal(). 2562 */ 2563 current->jobctl |= JOBCTL_STOP_DEQUEUED; 2564 ptrace_stop(signr, CLD_TRAPPED, 0, info); 2565 2566 /* We're back. Did the debugger cancel the sig? */ 2567 signr = current->exit_code; 2568 if (signr == 0) 2569 return signr; 2570 2571 current->exit_code = 0; 2572 2573 /* 2574 * Update the siginfo structure if the signal has 2575 * changed. If the debugger wanted something 2576 * specific in the siginfo structure then it should 2577 * have updated *info via PTRACE_SETSIGINFO. 2578 */ 2579 if (signr != info->si_signo) { 2580 clear_siginfo(info); 2581 info->si_signo = signr; 2582 info->si_errno = 0; 2583 info->si_code = SI_USER; 2584 rcu_read_lock(); 2585 info->si_pid = task_pid_vnr(current->parent); 2586 info->si_uid = from_kuid_munged(current_user_ns(), 2587 task_uid(current->parent)); 2588 rcu_read_unlock(); 2589 } 2590 2591 /* If the (new) signal is now blocked, requeue it. */ 2592 if (sigismember(¤t->blocked, signr) || 2593 fatal_signal_pending(current)) { 2594 send_signal(signr, info, current, type); 2595 signr = 0; 2596 } 2597 2598 return signr; 2599 } 2600 2601 static void hide_si_addr_tag_bits(struct ksignal *ksig) 2602 { 2603 switch (siginfo_layout(ksig->sig, ksig->info.si_code)) { 2604 case SIL_FAULT: 2605 case SIL_FAULT_TRAPNO: 2606 case SIL_FAULT_MCEERR: 2607 case SIL_FAULT_BNDERR: 2608 case SIL_FAULT_PKUERR: 2609 case SIL_FAULT_PERF_EVENT: 2610 ksig->info.si_addr = arch_untagged_si_addr( 2611 ksig->info.si_addr, ksig->sig, ksig->info.si_code); 2612 break; 2613 case SIL_KILL: 2614 case SIL_TIMER: 2615 case SIL_POLL: 2616 case SIL_CHLD: 2617 case SIL_RT: 2618 case SIL_SYS: 2619 break; 2620 } 2621 } 2622 2623 bool get_signal(struct ksignal *ksig) 2624 { 2625 struct sighand_struct *sighand = current->sighand; 2626 struct signal_struct *signal = current->signal; 2627 int signr; 2628 2629 clear_notify_signal(); 2630 if (unlikely(task_work_pending(current))) 2631 task_work_run(); 2632 2633 if (!task_sigpending(current)) 2634 return false; 2635 2636 if (unlikely(uprobe_deny_signal())) 2637 return false; 2638 2639 /* 2640 * Do this once, we can't return to user-mode if freezing() == T. 2641 * do_signal_stop() and ptrace_stop() do freezable_schedule() and 2642 * thus do not need another check after return. 2643 */ 2644 try_to_freeze(); 2645 2646 relock: 2647 spin_lock_irq(&sighand->siglock); 2648 2649 /* 2650 * Every stopped thread goes here after wakeup. Check to see if 2651 * we should notify the parent, prepare_signal(SIGCONT) encodes 2652 * the CLD_ si_code into SIGNAL_CLD_MASK bits. 2653 */ 2654 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) { 2655 int why; 2656 2657 if (signal->flags & SIGNAL_CLD_CONTINUED) 2658 why = CLD_CONTINUED; 2659 else 2660 why = CLD_STOPPED; 2661 2662 signal->flags &= ~SIGNAL_CLD_MASK; 2663 2664 spin_unlock_irq(&sighand->siglock); 2665 2666 /* 2667 * Notify the parent that we're continuing. This event is 2668 * always per-process and doesn't make whole lot of sense 2669 * for ptracers, who shouldn't consume the state via 2670 * wait(2) either, but, for backward compatibility, notify 2671 * the ptracer of the group leader too unless it's gonna be 2672 * a duplicate. 2673 */ 2674 read_lock(&tasklist_lock); 2675 do_notify_parent_cldstop(current, false, why); 2676 2677 if (ptrace_reparented(current->group_leader)) 2678 do_notify_parent_cldstop(current->group_leader, 2679 true, why); 2680 read_unlock(&tasklist_lock); 2681 2682 goto relock; 2683 } 2684 2685 for (;;) { 2686 struct k_sigaction *ka; 2687 enum pid_type type; 2688 2689 /* Has this task already been marked for death? */ 2690 if ((signal->flags & SIGNAL_GROUP_EXIT) || 2691 signal->group_exec_task) { 2692 ksig->info.si_signo = signr = SIGKILL; 2693 sigdelset(¤t->pending.signal, SIGKILL); 2694 trace_signal_deliver(SIGKILL, SEND_SIG_NOINFO, 2695 &sighand->action[SIGKILL - 1]); 2696 recalc_sigpending(); 2697 goto fatal; 2698 } 2699 2700 if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) && 2701 do_signal_stop(0)) 2702 goto relock; 2703 2704 if (unlikely(current->jobctl & 2705 (JOBCTL_TRAP_MASK | JOBCTL_TRAP_FREEZE))) { 2706 if (current->jobctl & JOBCTL_TRAP_MASK) { 2707 do_jobctl_trap(); 2708 spin_unlock_irq(&sighand->siglock); 2709 } else if (current->jobctl & JOBCTL_TRAP_FREEZE) 2710 do_freezer_trap(); 2711 2712 goto relock; 2713 } 2714 2715 /* 2716 * If the task is leaving the frozen state, let's update 2717 * cgroup counters and reset the frozen bit. 2718 */ 2719 if (unlikely(cgroup_task_frozen(current))) { 2720 spin_unlock_irq(&sighand->siglock); 2721 cgroup_leave_frozen(false); 2722 goto relock; 2723 } 2724 2725 /* 2726 * Signals generated by the execution of an instruction 2727 * need to be delivered before any other pending signals 2728 * so that the instruction pointer in the signal stack 2729 * frame points to the faulting instruction. 2730 */ 2731 type = PIDTYPE_PID; 2732 signr = dequeue_synchronous_signal(&ksig->info); 2733 if (!signr) 2734 signr = dequeue_signal(current, ¤t->blocked, 2735 &ksig->info, &type); 2736 2737 if (!signr) 2738 break; /* will return 0 */ 2739 2740 if (unlikely(current->ptrace) && (signr != SIGKILL) && 2741 !(sighand->action[signr -1].sa.sa_flags & SA_IMMUTABLE)) { 2742 signr = ptrace_signal(signr, &ksig->info, type); 2743 if (!signr) 2744 continue; 2745 } 2746 2747 ka = &sighand->action[signr-1]; 2748 2749 /* Trace actually delivered signals. */ 2750 trace_signal_deliver(signr, &ksig->info, ka); 2751 2752 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */ 2753 continue; 2754 if (ka->sa.sa_handler != SIG_DFL) { 2755 /* Run the handler. */ 2756 ksig->ka = *ka; 2757 2758 if (ka->sa.sa_flags & SA_ONESHOT) 2759 ka->sa.sa_handler = SIG_DFL; 2760 2761 break; /* will return non-zero "signr" value */ 2762 } 2763 2764 /* 2765 * Now we are doing the default action for this signal. 2766 */ 2767 if (sig_kernel_ignore(signr)) /* Default is nothing. */ 2768 continue; 2769 2770 /* 2771 * Global init gets no signals it doesn't want. 2772 * Container-init gets no signals it doesn't want from same 2773 * container. 2774 * 2775 * Note that if global/container-init sees a sig_kernel_only() 2776 * signal here, the signal must have been generated internally 2777 * or must have come from an ancestor namespace. In either 2778 * case, the signal cannot be dropped. 2779 */ 2780 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) && 2781 !sig_kernel_only(signr)) 2782 continue; 2783 2784 if (sig_kernel_stop(signr)) { 2785 /* 2786 * The default action is to stop all threads in 2787 * the thread group. The job control signals 2788 * do nothing in an orphaned pgrp, but SIGSTOP 2789 * always works. Note that siglock needs to be 2790 * dropped during the call to is_orphaned_pgrp() 2791 * because of lock ordering with tasklist_lock. 2792 * This allows an intervening SIGCONT to be posted. 2793 * We need to check for that and bail out if necessary. 2794 */ 2795 if (signr != SIGSTOP) { 2796 spin_unlock_irq(&sighand->siglock); 2797 2798 /* signals can be posted during this window */ 2799 2800 if (is_current_pgrp_orphaned()) 2801 goto relock; 2802 2803 spin_lock_irq(&sighand->siglock); 2804 } 2805 2806 if (likely(do_signal_stop(ksig->info.si_signo))) { 2807 /* It released the siglock. */ 2808 goto relock; 2809 } 2810 2811 /* 2812 * We didn't actually stop, due to a race 2813 * with SIGCONT or something like that. 2814 */ 2815 continue; 2816 } 2817 2818 fatal: 2819 spin_unlock_irq(&sighand->siglock); 2820 if (unlikely(cgroup_task_frozen(current))) 2821 cgroup_leave_frozen(true); 2822 2823 /* 2824 * Anything else is fatal, maybe with a core dump. 2825 */ 2826 current->flags |= PF_SIGNALED; 2827 2828 if (sig_kernel_coredump(signr)) { 2829 if (print_fatal_signals) 2830 print_fatal_signal(ksig->info.si_signo); 2831 proc_coredump_connector(current); 2832 /* 2833 * If it was able to dump core, this kills all 2834 * other threads in the group and synchronizes with 2835 * their demise. If we lost the race with another 2836 * thread getting here, it set group_exit_code 2837 * first and our do_group_exit call below will use 2838 * that value and ignore the one we pass it. 2839 */ 2840 do_coredump(&ksig->info); 2841 } 2842 2843 /* 2844 * PF_IO_WORKER threads will catch and exit on fatal signals 2845 * themselves. They have cleanup that must be performed, so 2846 * we cannot call do_exit() on their behalf. 2847 */ 2848 if (current->flags & PF_IO_WORKER) 2849 goto out; 2850 2851 /* 2852 * Death signals, no core dump. 2853 */ 2854 do_group_exit(ksig->info.si_signo); 2855 /* NOTREACHED */ 2856 } 2857 spin_unlock_irq(&sighand->siglock); 2858 out: 2859 ksig->sig = signr; 2860 2861 if (!(ksig->ka.sa.sa_flags & SA_EXPOSE_TAGBITS)) 2862 hide_si_addr_tag_bits(ksig); 2863 2864 return ksig->sig > 0; 2865 } 2866 2867 /** 2868 * signal_delivered - called after signal delivery to update blocked signals 2869 * @ksig: kernel signal struct 2870 * @stepping: nonzero if debugger single-step or block-step in use 2871 * 2872 * This function should be called when a signal has successfully been 2873 * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask 2874 * is always blocked), and the signal itself is blocked unless %SA_NODEFER 2875 * is set in @ksig->ka.sa.sa_flags. Tracing is notified. 2876 */ 2877 static void signal_delivered(struct ksignal *ksig, int stepping) 2878 { 2879 sigset_t blocked; 2880 2881 /* A signal was successfully delivered, and the 2882 saved sigmask was stored on the signal frame, 2883 and will be restored by sigreturn. So we can 2884 simply clear the restore sigmask flag. */ 2885 clear_restore_sigmask(); 2886 2887 sigorsets(&blocked, ¤t->blocked, &ksig->ka.sa.sa_mask); 2888 if (!(ksig->ka.sa.sa_flags & SA_NODEFER)) 2889 sigaddset(&blocked, ksig->sig); 2890 set_current_blocked(&blocked); 2891 if (current->sas_ss_flags & SS_AUTODISARM) 2892 sas_ss_reset(current); 2893 if (stepping) 2894 ptrace_notify(SIGTRAP); 2895 } 2896 2897 void signal_setup_done(int failed, struct ksignal *ksig, int stepping) 2898 { 2899 if (failed) 2900 force_sigsegv(ksig->sig); 2901 else 2902 signal_delivered(ksig, stepping); 2903 } 2904 2905 /* 2906 * It could be that complete_signal() picked us to notify about the 2907 * group-wide signal. Other threads should be notified now to take 2908 * the shared signals in @which since we will not. 2909 */ 2910 static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which) 2911 { 2912 sigset_t retarget; 2913 struct task_struct *t; 2914 2915 sigandsets(&retarget, &tsk->signal->shared_pending.signal, which); 2916 if (sigisemptyset(&retarget)) 2917 return; 2918 2919 t = tsk; 2920 while_each_thread(tsk, t) { 2921 if (t->flags & PF_EXITING) 2922 continue; 2923 2924 if (!has_pending_signals(&retarget, &t->blocked)) 2925 continue; 2926 /* Remove the signals this thread can handle. */ 2927 sigandsets(&retarget, &retarget, &t->blocked); 2928 2929 if (!task_sigpending(t)) 2930 signal_wake_up(t, 0); 2931 2932 if (sigisemptyset(&retarget)) 2933 break; 2934 } 2935 } 2936 2937 void exit_signals(struct task_struct *tsk) 2938 { 2939 int group_stop = 0; 2940 sigset_t unblocked; 2941 2942 /* 2943 * @tsk is about to have PF_EXITING set - lock out users which 2944 * expect stable threadgroup. 2945 */ 2946 cgroup_threadgroup_change_begin(tsk); 2947 2948 if (thread_group_empty(tsk) || (tsk->signal->flags & SIGNAL_GROUP_EXIT)) { 2949 tsk->flags |= PF_EXITING; 2950 cgroup_threadgroup_change_end(tsk); 2951 return; 2952 } 2953 2954 spin_lock_irq(&tsk->sighand->siglock); 2955 /* 2956 * From now this task is not visible for group-wide signals, 2957 * see wants_signal(), do_signal_stop(). 2958 */ 2959 tsk->flags |= PF_EXITING; 2960 2961 cgroup_threadgroup_change_end(tsk); 2962 2963 if (!task_sigpending(tsk)) 2964 goto out; 2965 2966 unblocked = tsk->blocked; 2967 signotset(&unblocked); 2968 retarget_shared_pending(tsk, &unblocked); 2969 2970 if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) && 2971 task_participate_group_stop(tsk)) 2972 group_stop = CLD_STOPPED; 2973 out: 2974 spin_unlock_irq(&tsk->sighand->siglock); 2975 2976 /* 2977 * If group stop has completed, deliver the notification. This 2978 * should always go to the real parent of the group leader. 2979 */ 2980 if (unlikely(group_stop)) { 2981 read_lock(&tasklist_lock); 2982 do_notify_parent_cldstop(tsk, false, group_stop); 2983 read_unlock(&tasklist_lock); 2984 } 2985 } 2986 2987 /* 2988 * System call entry points. 2989 */ 2990 2991 /** 2992 * sys_restart_syscall - restart a system call 2993 */ 2994 SYSCALL_DEFINE0(restart_syscall) 2995 { 2996 struct restart_block *restart = ¤t->restart_block; 2997 return restart->fn(restart); 2998 } 2999 3000 long do_no_restart_syscall(struct restart_block *param) 3001 { 3002 return -EINTR; 3003 } 3004 3005 static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset) 3006 { 3007 if (task_sigpending(tsk) && !thread_group_empty(tsk)) { 3008 sigset_t newblocked; 3009 /* A set of now blocked but previously unblocked signals. */ 3010 sigandnsets(&newblocked, newset, ¤t->blocked); 3011 retarget_shared_pending(tsk, &newblocked); 3012 } 3013 tsk->blocked = *newset; 3014 recalc_sigpending(); 3015 } 3016 3017 /** 3018 * set_current_blocked - change current->blocked mask 3019 * @newset: new mask 3020 * 3021 * It is wrong to change ->blocked directly, this helper should be used 3022 * to ensure the process can't miss a shared signal we are going to block. 3023 */ 3024 void set_current_blocked(sigset_t *newset) 3025 { 3026 sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP)); 3027 __set_current_blocked(newset); 3028 } 3029 3030 void __set_current_blocked(const sigset_t *newset) 3031 { 3032 struct task_struct *tsk = current; 3033 3034 /* 3035 * In case the signal mask hasn't changed, there is nothing we need 3036 * to do. The current->blocked shouldn't be modified by other task. 3037 */ 3038 if (sigequalsets(&tsk->blocked, newset)) 3039 return; 3040 3041 spin_lock_irq(&tsk->sighand->siglock); 3042 __set_task_blocked(tsk, newset); 3043 spin_unlock_irq(&tsk->sighand->siglock); 3044 } 3045 3046 /* 3047 * This is also useful for kernel threads that want to temporarily 3048 * (or permanently) block certain signals. 3049 * 3050 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel 3051 * interface happily blocks "unblockable" signals like SIGKILL 3052 * and friends. 3053 */ 3054 int sigprocmask(int how, sigset_t *set, sigset_t *oldset) 3055 { 3056 struct task_struct *tsk = current; 3057 sigset_t newset; 3058 3059 /* Lockless, only current can change ->blocked, never from irq */ 3060 if (oldset) 3061 *oldset = tsk->blocked; 3062 3063 switch (how) { 3064 case SIG_BLOCK: 3065 sigorsets(&newset, &tsk->blocked, set); 3066 break; 3067 case SIG_UNBLOCK: 3068 sigandnsets(&newset, &tsk->blocked, set); 3069 break; 3070 case SIG_SETMASK: 3071 newset = *set; 3072 break; 3073 default: 3074 return -EINVAL; 3075 } 3076 3077 __set_current_blocked(&newset); 3078 return 0; 3079 } 3080 EXPORT_SYMBOL(sigprocmask); 3081 3082 /* 3083 * The api helps set app-provided sigmasks. 3084 * 3085 * This is useful for syscalls such as ppoll, pselect, io_pgetevents and 3086 * epoll_pwait where a new sigmask is passed from userland for the syscalls. 3087 * 3088 * Note that it does set_restore_sigmask() in advance, so it must be always 3089 * paired with restore_saved_sigmask_unless() before return from syscall. 3090 */ 3091 int set_user_sigmask(const sigset_t __user *umask, size_t sigsetsize) 3092 { 3093 sigset_t kmask; 3094 3095 if (!umask) 3096 return 0; 3097 if (sigsetsize != sizeof(sigset_t)) 3098 return -EINVAL; 3099 if (copy_from_user(&kmask, umask, sizeof(sigset_t))) 3100 return -EFAULT; 3101 3102 set_restore_sigmask(); 3103 current->saved_sigmask = current->blocked; 3104 set_current_blocked(&kmask); 3105 3106 return 0; 3107 } 3108 3109 #ifdef CONFIG_COMPAT 3110 int set_compat_user_sigmask(const compat_sigset_t __user *umask, 3111 size_t sigsetsize) 3112 { 3113 sigset_t kmask; 3114 3115 if (!umask) 3116 return 0; 3117 if (sigsetsize != sizeof(compat_sigset_t)) 3118 return -EINVAL; 3119 if (get_compat_sigset(&kmask, umask)) 3120 return -EFAULT; 3121 3122 set_restore_sigmask(); 3123 current->saved_sigmask = current->blocked; 3124 set_current_blocked(&kmask); 3125 3126 return 0; 3127 } 3128 #endif 3129 3130 /** 3131 * sys_rt_sigprocmask - change the list of currently blocked signals 3132 * @how: whether to add, remove, or set signals 3133 * @nset: stores pending signals 3134 * @oset: previous value of signal mask if non-null 3135 * @sigsetsize: size of sigset_t type 3136 */ 3137 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset, 3138 sigset_t __user *, oset, size_t, sigsetsize) 3139 { 3140 sigset_t old_set, new_set; 3141 int error; 3142 3143 /* XXX: Don't preclude handling different sized sigset_t's. */ 3144 if (sigsetsize != sizeof(sigset_t)) 3145 return -EINVAL; 3146 3147 old_set = current->blocked; 3148 3149 if (nset) { 3150 if (copy_from_user(&new_set, nset, sizeof(sigset_t))) 3151 return -EFAULT; 3152 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP)); 3153 3154 error = sigprocmask(how, &new_set, NULL); 3155 if (error) 3156 return error; 3157 } 3158 3159 if (oset) { 3160 if (copy_to_user(oset, &old_set, sizeof(sigset_t))) 3161 return -EFAULT; 3162 } 3163 3164 return 0; 3165 } 3166 3167 #ifdef CONFIG_COMPAT 3168 COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset, 3169 compat_sigset_t __user *, oset, compat_size_t, sigsetsize) 3170 { 3171 sigset_t old_set = current->blocked; 3172 3173 /* XXX: Don't preclude handling different sized sigset_t's. */ 3174 if (sigsetsize != sizeof(sigset_t)) 3175 return -EINVAL; 3176 3177 if (nset) { 3178 sigset_t new_set; 3179 int error; 3180 if (get_compat_sigset(&new_set, nset)) 3181 return -EFAULT; 3182 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP)); 3183 3184 error = sigprocmask(how, &new_set, NULL); 3185 if (error) 3186 return error; 3187 } 3188 return oset ? put_compat_sigset(oset, &old_set, sizeof(*oset)) : 0; 3189 } 3190 #endif 3191 3192 static void do_sigpending(sigset_t *set) 3193 { 3194 spin_lock_irq(¤t->sighand->siglock); 3195 sigorsets(set, ¤t->pending.signal, 3196 ¤t->signal->shared_pending.signal); 3197 spin_unlock_irq(¤t->sighand->siglock); 3198 3199 /* Outside the lock because only this thread touches it. */ 3200 sigandsets(set, ¤t->blocked, set); 3201 } 3202 3203 /** 3204 * sys_rt_sigpending - examine a pending signal that has been raised 3205 * while blocked 3206 * @uset: stores pending signals 3207 * @sigsetsize: size of sigset_t type or larger 3208 */ 3209 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize) 3210 { 3211 sigset_t set; 3212 3213 if (sigsetsize > sizeof(*uset)) 3214 return -EINVAL; 3215 3216 do_sigpending(&set); 3217 3218 if (copy_to_user(uset, &set, sigsetsize)) 3219 return -EFAULT; 3220 3221 return 0; 3222 } 3223 3224 #ifdef CONFIG_COMPAT 3225 COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset, 3226 compat_size_t, sigsetsize) 3227 { 3228 sigset_t set; 3229 3230 if (sigsetsize > sizeof(*uset)) 3231 return -EINVAL; 3232 3233 do_sigpending(&set); 3234 3235 return put_compat_sigset(uset, &set, sigsetsize); 3236 } 3237 #endif 3238 3239 static const struct { 3240 unsigned char limit, layout; 3241 } sig_sicodes[] = { 3242 [SIGILL] = { NSIGILL, SIL_FAULT }, 3243 [SIGFPE] = { NSIGFPE, SIL_FAULT }, 3244 [SIGSEGV] = { NSIGSEGV, SIL_FAULT }, 3245 [SIGBUS] = { NSIGBUS, SIL_FAULT }, 3246 [SIGTRAP] = { NSIGTRAP, SIL_FAULT }, 3247 #if defined(SIGEMT) 3248 [SIGEMT] = { NSIGEMT, SIL_FAULT }, 3249 #endif 3250 [SIGCHLD] = { NSIGCHLD, SIL_CHLD }, 3251 [SIGPOLL] = { NSIGPOLL, SIL_POLL }, 3252 [SIGSYS] = { NSIGSYS, SIL_SYS }, 3253 }; 3254 3255 static bool known_siginfo_layout(unsigned sig, int si_code) 3256 { 3257 if (si_code == SI_KERNEL) 3258 return true; 3259 else if ((si_code > SI_USER)) { 3260 if (sig_specific_sicodes(sig)) { 3261 if (si_code <= sig_sicodes[sig].limit) 3262 return true; 3263 } 3264 else if (si_code <= NSIGPOLL) 3265 return true; 3266 } 3267 else if (si_code >= SI_DETHREAD) 3268 return true; 3269 else if (si_code == SI_ASYNCNL) 3270 return true; 3271 return false; 3272 } 3273 3274 enum siginfo_layout siginfo_layout(unsigned sig, int si_code) 3275 { 3276 enum siginfo_layout layout = SIL_KILL; 3277 if ((si_code > SI_USER) && (si_code < SI_KERNEL)) { 3278 if ((sig < ARRAY_SIZE(sig_sicodes)) && 3279 (si_code <= sig_sicodes[sig].limit)) { 3280 layout = sig_sicodes[sig].layout; 3281 /* Handle the exceptions */ 3282 if ((sig == SIGBUS) && 3283 (si_code >= BUS_MCEERR_AR) && (si_code <= BUS_MCEERR_AO)) 3284 layout = SIL_FAULT_MCEERR; 3285 else if ((sig == SIGSEGV) && (si_code == SEGV_BNDERR)) 3286 layout = SIL_FAULT_BNDERR; 3287 #ifdef SEGV_PKUERR 3288 else if ((sig == SIGSEGV) && (si_code == SEGV_PKUERR)) 3289 layout = SIL_FAULT_PKUERR; 3290 #endif 3291 else if ((sig == SIGTRAP) && (si_code == TRAP_PERF)) 3292 layout = SIL_FAULT_PERF_EVENT; 3293 else if (IS_ENABLED(CONFIG_SPARC) && 3294 (sig == SIGILL) && (si_code == ILL_ILLTRP)) 3295 layout = SIL_FAULT_TRAPNO; 3296 else if (IS_ENABLED(CONFIG_ALPHA) && 3297 ((sig == SIGFPE) || 3298 ((sig == SIGTRAP) && (si_code == TRAP_UNK)))) 3299 layout = SIL_FAULT_TRAPNO; 3300 } 3301 else if (si_code <= NSIGPOLL) 3302 layout = SIL_POLL; 3303 } else { 3304 if (si_code == SI_TIMER) 3305 layout = SIL_TIMER; 3306 else if (si_code == SI_SIGIO) 3307 layout = SIL_POLL; 3308 else if (si_code < 0) 3309 layout = SIL_RT; 3310 } 3311 return layout; 3312 } 3313 3314 static inline char __user *si_expansion(const siginfo_t __user *info) 3315 { 3316 return ((char __user *)info) + sizeof(struct kernel_siginfo); 3317 } 3318 3319 int copy_siginfo_to_user(siginfo_t __user *to, const kernel_siginfo_t *from) 3320 { 3321 char __user *expansion = si_expansion(to); 3322 if (copy_to_user(to, from , sizeof(struct kernel_siginfo))) 3323 return -EFAULT; 3324 if (clear_user(expansion, SI_EXPANSION_SIZE)) 3325 return -EFAULT; 3326 return 0; 3327 } 3328 3329 static int post_copy_siginfo_from_user(kernel_siginfo_t *info, 3330 const siginfo_t __user *from) 3331 { 3332 if (unlikely(!known_siginfo_layout(info->si_signo, info->si_code))) { 3333 char __user *expansion = si_expansion(from); 3334 char buf[SI_EXPANSION_SIZE]; 3335 int i; 3336 /* 3337 * An unknown si_code might need more than 3338 * sizeof(struct kernel_siginfo) bytes. Verify all of the 3339 * extra bytes are 0. This guarantees copy_siginfo_to_user 3340 * will return this data to userspace exactly. 3341 */ 3342 if (copy_from_user(&buf, expansion, SI_EXPANSION_SIZE)) 3343 return -EFAULT; 3344 for (i = 0; i < SI_EXPANSION_SIZE; i++) { 3345 if (buf[i] != 0) 3346 return -E2BIG; 3347 } 3348 } 3349 return 0; 3350 } 3351 3352 static int __copy_siginfo_from_user(int signo, kernel_siginfo_t *to, 3353 const siginfo_t __user *from) 3354 { 3355 if (copy_from_user(to, from, sizeof(struct kernel_siginfo))) 3356 return -EFAULT; 3357 to->si_signo = signo; 3358 return post_copy_siginfo_from_user(to, from); 3359 } 3360 3361 int copy_siginfo_from_user(kernel_siginfo_t *to, const siginfo_t __user *from) 3362 { 3363 if (copy_from_user(to, from, sizeof(struct kernel_siginfo))) 3364 return -EFAULT; 3365 return post_copy_siginfo_from_user(to, from); 3366 } 3367 3368 #ifdef CONFIG_COMPAT 3369 /** 3370 * copy_siginfo_to_external32 - copy a kernel siginfo into a compat user siginfo 3371 * @to: compat siginfo destination 3372 * @from: kernel siginfo source 3373 * 3374 * Note: This function does not work properly for the SIGCHLD on x32, but 3375 * fortunately it doesn't have to. The only valid callers for this function are 3376 * copy_siginfo_to_user32, which is overriden for x32 and the coredump code. 3377 * The latter does not care because SIGCHLD will never cause a coredump. 3378 */ 3379 void copy_siginfo_to_external32(struct compat_siginfo *to, 3380 const struct kernel_siginfo *from) 3381 { 3382 memset(to, 0, sizeof(*to)); 3383 3384 to->si_signo = from->si_signo; 3385 to->si_errno = from->si_errno; 3386 to->si_code = from->si_code; 3387 switch(siginfo_layout(from->si_signo, from->si_code)) { 3388 case SIL_KILL: 3389 to->si_pid = from->si_pid; 3390 to->si_uid = from->si_uid; 3391 break; 3392 case SIL_TIMER: 3393 to->si_tid = from->si_tid; 3394 to->si_overrun = from->si_overrun; 3395 to->si_int = from->si_int; 3396 break; 3397 case SIL_POLL: 3398 to->si_band = from->si_band; 3399 to->si_fd = from->si_fd; 3400 break; 3401 case SIL_FAULT: 3402 to->si_addr = ptr_to_compat(from->si_addr); 3403 break; 3404 case SIL_FAULT_TRAPNO: 3405 to->si_addr = ptr_to_compat(from->si_addr); 3406 to->si_trapno = from->si_trapno; 3407 break; 3408 case SIL_FAULT_MCEERR: 3409 to->si_addr = ptr_to_compat(from->si_addr); 3410 to->si_addr_lsb = from->si_addr_lsb; 3411 break; 3412 case SIL_FAULT_BNDERR: 3413 to->si_addr = ptr_to_compat(from->si_addr); 3414 to->si_lower = ptr_to_compat(from->si_lower); 3415 to->si_upper = ptr_to_compat(from->si_upper); 3416 break; 3417 case SIL_FAULT_PKUERR: 3418 to->si_addr = ptr_to_compat(from->si_addr); 3419 to->si_pkey = from->si_pkey; 3420 break; 3421 case SIL_FAULT_PERF_EVENT: 3422 to->si_addr = ptr_to_compat(from->si_addr); 3423 to->si_perf_data = from->si_perf_data; 3424 to->si_perf_type = from->si_perf_type; 3425 break; 3426 case SIL_CHLD: 3427 to->si_pid = from->si_pid; 3428 to->si_uid = from->si_uid; 3429 to->si_status = from->si_status; 3430 to->si_utime = from->si_utime; 3431 to->si_stime = from->si_stime; 3432 break; 3433 case SIL_RT: 3434 to->si_pid = from->si_pid; 3435 to->si_uid = from->si_uid; 3436 to->si_int = from->si_int; 3437 break; 3438 case SIL_SYS: 3439 to->si_call_addr = ptr_to_compat(from->si_call_addr); 3440 to->si_syscall = from->si_syscall; 3441 to->si_arch = from->si_arch; 3442 break; 3443 } 3444 } 3445 3446 int __copy_siginfo_to_user32(struct compat_siginfo __user *to, 3447 const struct kernel_siginfo *from) 3448 { 3449 struct compat_siginfo new; 3450 3451 copy_siginfo_to_external32(&new, from); 3452 if (copy_to_user(to, &new, sizeof(struct compat_siginfo))) 3453 return -EFAULT; 3454 return 0; 3455 } 3456 3457 static int post_copy_siginfo_from_user32(kernel_siginfo_t *to, 3458 const struct compat_siginfo *from) 3459 { 3460 clear_siginfo(to); 3461 to->si_signo = from->si_signo; 3462 to->si_errno = from->si_errno; 3463 to->si_code = from->si_code; 3464 switch(siginfo_layout(from->si_signo, from->si_code)) { 3465 case SIL_KILL: 3466 to->si_pid = from->si_pid; 3467 to->si_uid = from->si_uid; 3468 break; 3469 case SIL_TIMER: 3470 to->si_tid = from->si_tid; 3471 to->si_overrun = from->si_overrun; 3472 to->si_int = from->si_int; 3473 break; 3474 case SIL_POLL: 3475 to->si_band = from->si_band; 3476 to->si_fd = from->si_fd; 3477 break; 3478 case SIL_FAULT: 3479 to->si_addr = compat_ptr(from->si_addr); 3480 break; 3481 case SIL_FAULT_TRAPNO: 3482 to->si_addr = compat_ptr(from->si_addr); 3483 to->si_trapno = from->si_trapno; 3484 break; 3485 case SIL_FAULT_MCEERR: 3486 to->si_addr = compat_ptr(from->si_addr); 3487 to->si_addr_lsb = from->si_addr_lsb; 3488 break; 3489 case SIL_FAULT_BNDERR: 3490 to->si_addr = compat_ptr(from->si_addr); 3491 to->si_lower = compat_ptr(from->si_lower); 3492 to->si_upper = compat_ptr(from->si_upper); 3493 break; 3494 case SIL_FAULT_PKUERR: 3495 to->si_addr = compat_ptr(from->si_addr); 3496 to->si_pkey = from->si_pkey; 3497 break; 3498 case SIL_FAULT_PERF_EVENT: 3499 to->si_addr = compat_ptr(from->si_addr); 3500 to->si_perf_data = from->si_perf_data; 3501 to->si_perf_type = from->si_perf_type; 3502 break; 3503 case SIL_CHLD: 3504 to->si_pid = from->si_pid; 3505 to->si_uid = from->si_uid; 3506 to->si_status = from->si_status; 3507 #ifdef CONFIG_X86_X32_ABI 3508 if (in_x32_syscall()) { 3509 to->si_utime = from->_sifields._sigchld_x32._utime; 3510 to->si_stime = from->_sifields._sigchld_x32._stime; 3511 } else 3512 #endif 3513 { 3514 to->si_utime = from->si_utime; 3515 to->si_stime = from->si_stime; 3516 } 3517 break; 3518 case SIL_RT: 3519 to->si_pid = from->si_pid; 3520 to->si_uid = from->si_uid; 3521 to->si_int = from->si_int; 3522 break; 3523 case SIL_SYS: 3524 to->si_call_addr = compat_ptr(from->si_call_addr); 3525 to->si_syscall = from->si_syscall; 3526 to->si_arch = from->si_arch; 3527 break; 3528 } 3529 return 0; 3530 } 3531 3532 static int __copy_siginfo_from_user32(int signo, struct kernel_siginfo *to, 3533 const struct compat_siginfo __user *ufrom) 3534 { 3535 struct compat_siginfo from; 3536 3537 if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo))) 3538 return -EFAULT; 3539 3540 from.si_signo = signo; 3541 return post_copy_siginfo_from_user32(to, &from); 3542 } 3543 3544 int copy_siginfo_from_user32(struct kernel_siginfo *to, 3545 const struct compat_siginfo __user *ufrom) 3546 { 3547 struct compat_siginfo from; 3548 3549 if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo))) 3550 return -EFAULT; 3551 3552 return post_copy_siginfo_from_user32(to, &from); 3553 } 3554 #endif /* CONFIG_COMPAT */ 3555 3556 /** 3557 * do_sigtimedwait - wait for queued signals specified in @which 3558 * @which: queued signals to wait for 3559 * @info: if non-null, the signal's siginfo is returned here 3560 * @ts: upper bound on process time suspension 3561 */ 3562 static int do_sigtimedwait(const sigset_t *which, kernel_siginfo_t *info, 3563 const struct timespec64 *ts) 3564 { 3565 ktime_t *to = NULL, timeout = KTIME_MAX; 3566 struct task_struct *tsk = current; 3567 sigset_t mask = *which; 3568 enum pid_type type; 3569 int sig, ret = 0; 3570 3571 if (ts) { 3572 if (!timespec64_valid(ts)) 3573 return -EINVAL; 3574 timeout = timespec64_to_ktime(*ts); 3575 to = &timeout; 3576 } 3577 3578 /* 3579 * Invert the set of allowed signals to get those we want to block. 3580 */ 3581 sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP)); 3582 signotset(&mask); 3583 3584 spin_lock_irq(&tsk->sighand->siglock); 3585 sig = dequeue_signal(tsk, &mask, info, &type); 3586 if (!sig && timeout) { 3587 /* 3588 * None ready, temporarily unblock those we're interested 3589 * while we are sleeping in so that we'll be awakened when 3590 * they arrive. Unblocking is always fine, we can avoid 3591 * set_current_blocked(). 3592 */ 3593 tsk->real_blocked = tsk->blocked; 3594 sigandsets(&tsk->blocked, &tsk->blocked, &mask); 3595 recalc_sigpending(); 3596 spin_unlock_irq(&tsk->sighand->siglock); 3597 3598 __set_current_state(TASK_INTERRUPTIBLE); 3599 ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns, 3600 HRTIMER_MODE_REL); 3601 spin_lock_irq(&tsk->sighand->siglock); 3602 __set_task_blocked(tsk, &tsk->real_blocked); 3603 sigemptyset(&tsk->real_blocked); 3604 sig = dequeue_signal(tsk, &mask, info, &type); 3605 } 3606 spin_unlock_irq(&tsk->sighand->siglock); 3607 3608 if (sig) 3609 return sig; 3610 return ret ? -EINTR : -EAGAIN; 3611 } 3612 3613 /** 3614 * sys_rt_sigtimedwait - synchronously wait for queued signals specified 3615 * in @uthese 3616 * @uthese: queued signals to wait for 3617 * @uinfo: if non-null, the signal's siginfo is returned here 3618 * @uts: upper bound on process time suspension 3619 * @sigsetsize: size of sigset_t type 3620 */ 3621 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese, 3622 siginfo_t __user *, uinfo, 3623 const struct __kernel_timespec __user *, uts, 3624 size_t, sigsetsize) 3625 { 3626 sigset_t these; 3627 struct timespec64 ts; 3628 kernel_siginfo_t info; 3629 int ret; 3630 3631 /* XXX: Don't preclude handling different sized sigset_t's. */ 3632 if (sigsetsize != sizeof(sigset_t)) 3633 return -EINVAL; 3634 3635 if (copy_from_user(&these, uthese, sizeof(these))) 3636 return -EFAULT; 3637 3638 if (uts) { 3639 if (get_timespec64(&ts, uts)) 3640 return -EFAULT; 3641 } 3642 3643 ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL); 3644 3645 if (ret > 0 && uinfo) { 3646 if (copy_siginfo_to_user(uinfo, &info)) 3647 ret = -EFAULT; 3648 } 3649 3650 return ret; 3651 } 3652 3653 #ifdef CONFIG_COMPAT_32BIT_TIME 3654 SYSCALL_DEFINE4(rt_sigtimedwait_time32, const sigset_t __user *, uthese, 3655 siginfo_t __user *, uinfo, 3656 const struct old_timespec32 __user *, uts, 3657 size_t, sigsetsize) 3658 { 3659 sigset_t these; 3660 struct timespec64 ts; 3661 kernel_siginfo_t info; 3662 int ret; 3663 3664 if (sigsetsize != sizeof(sigset_t)) 3665 return -EINVAL; 3666 3667 if (copy_from_user(&these, uthese, sizeof(these))) 3668 return -EFAULT; 3669 3670 if (uts) { 3671 if (get_old_timespec32(&ts, uts)) 3672 return -EFAULT; 3673 } 3674 3675 ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL); 3676 3677 if (ret > 0 && uinfo) { 3678 if (copy_siginfo_to_user(uinfo, &info)) 3679 ret = -EFAULT; 3680 } 3681 3682 return ret; 3683 } 3684 #endif 3685 3686 #ifdef CONFIG_COMPAT 3687 COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time64, compat_sigset_t __user *, uthese, 3688 struct compat_siginfo __user *, uinfo, 3689 struct __kernel_timespec __user *, uts, compat_size_t, sigsetsize) 3690 { 3691 sigset_t s; 3692 struct timespec64 t; 3693 kernel_siginfo_t info; 3694 long ret; 3695 3696 if (sigsetsize != sizeof(sigset_t)) 3697 return -EINVAL; 3698 3699 if (get_compat_sigset(&s, uthese)) 3700 return -EFAULT; 3701 3702 if (uts) { 3703 if (get_timespec64(&t, uts)) 3704 return -EFAULT; 3705 } 3706 3707 ret = do_sigtimedwait(&s, &info, uts ? &t : NULL); 3708 3709 if (ret > 0 && uinfo) { 3710 if (copy_siginfo_to_user32(uinfo, &info)) 3711 ret = -EFAULT; 3712 } 3713 3714 return ret; 3715 } 3716 3717 #ifdef CONFIG_COMPAT_32BIT_TIME 3718 COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time32, compat_sigset_t __user *, uthese, 3719 struct compat_siginfo __user *, uinfo, 3720 struct old_timespec32 __user *, uts, compat_size_t, sigsetsize) 3721 { 3722 sigset_t s; 3723 struct timespec64 t; 3724 kernel_siginfo_t info; 3725 long ret; 3726 3727 if (sigsetsize != sizeof(sigset_t)) 3728 return -EINVAL; 3729 3730 if (get_compat_sigset(&s, uthese)) 3731 return -EFAULT; 3732 3733 if (uts) { 3734 if (get_old_timespec32(&t, uts)) 3735 return -EFAULT; 3736 } 3737 3738 ret = do_sigtimedwait(&s, &info, uts ? &t : NULL); 3739 3740 if (ret > 0 && uinfo) { 3741 if (copy_siginfo_to_user32(uinfo, &info)) 3742 ret = -EFAULT; 3743 } 3744 3745 return ret; 3746 } 3747 #endif 3748 #endif 3749 3750 static inline void prepare_kill_siginfo(int sig, struct kernel_siginfo *info) 3751 { 3752 clear_siginfo(info); 3753 info->si_signo = sig; 3754 info->si_errno = 0; 3755 info->si_code = SI_USER; 3756 info->si_pid = task_tgid_vnr(current); 3757 info->si_uid = from_kuid_munged(current_user_ns(), current_uid()); 3758 } 3759 3760 /** 3761 * sys_kill - send a signal to a process 3762 * @pid: the PID of the process 3763 * @sig: signal to be sent 3764 */ 3765 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig) 3766 { 3767 struct kernel_siginfo info; 3768 3769 prepare_kill_siginfo(sig, &info); 3770 3771 return kill_something_info(sig, &info, pid); 3772 } 3773 3774 /* 3775 * Verify that the signaler and signalee either are in the same pid namespace 3776 * or that the signaler's pid namespace is an ancestor of the signalee's pid 3777 * namespace. 3778 */ 3779 static bool access_pidfd_pidns(struct pid *pid) 3780 { 3781 struct pid_namespace *active = task_active_pid_ns(current); 3782 struct pid_namespace *p = ns_of_pid(pid); 3783 3784 for (;;) { 3785 if (!p) 3786 return false; 3787 if (p == active) 3788 break; 3789 p = p->parent; 3790 } 3791 3792 return true; 3793 } 3794 3795 static int copy_siginfo_from_user_any(kernel_siginfo_t *kinfo, 3796 siginfo_t __user *info) 3797 { 3798 #ifdef CONFIG_COMPAT 3799 /* 3800 * Avoid hooking up compat syscalls and instead handle necessary 3801 * conversions here. Note, this is a stop-gap measure and should not be 3802 * considered a generic solution. 3803 */ 3804 if (in_compat_syscall()) 3805 return copy_siginfo_from_user32( 3806 kinfo, (struct compat_siginfo __user *)info); 3807 #endif 3808 return copy_siginfo_from_user(kinfo, info); 3809 } 3810 3811 static struct pid *pidfd_to_pid(const struct file *file) 3812 { 3813 struct pid *pid; 3814 3815 pid = pidfd_pid(file); 3816 if (!IS_ERR(pid)) 3817 return pid; 3818 3819 return tgid_pidfd_to_pid(file); 3820 } 3821 3822 /** 3823 * sys_pidfd_send_signal - Signal a process through a pidfd 3824 * @pidfd: file descriptor of the process 3825 * @sig: signal to send 3826 * @info: signal info 3827 * @flags: future flags 3828 * 3829 * The syscall currently only signals via PIDTYPE_PID which covers 3830 * kill(<positive-pid>, <signal>. It does not signal threads or process 3831 * groups. 3832 * In order to extend the syscall to threads and process groups the @flags 3833 * argument should be used. In essence, the @flags argument will determine 3834 * what is signaled and not the file descriptor itself. Put in other words, 3835 * grouping is a property of the flags argument not a property of the file 3836 * descriptor. 3837 * 3838 * Return: 0 on success, negative errno on failure 3839 */ 3840 SYSCALL_DEFINE4(pidfd_send_signal, int, pidfd, int, sig, 3841 siginfo_t __user *, info, unsigned int, flags) 3842 { 3843 int ret; 3844 struct fd f; 3845 struct pid *pid; 3846 kernel_siginfo_t kinfo; 3847 3848 /* Enforce flags be set to 0 until we add an extension. */ 3849 if (flags) 3850 return -EINVAL; 3851 3852 f = fdget(pidfd); 3853 if (!f.file) 3854 return -EBADF; 3855 3856 /* Is this a pidfd? */ 3857 pid = pidfd_to_pid(f.file); 3858 if (IS_ERR(pid)) { 3859 ret = PTR_ERR(pid); 3860 goto err; 3861 } 3862 3863 ret = -EINVAL; 3864 if (!access_pidfd_pidns(pid)) 3865 goto err; 3866 3867 if (info) { 3868 ret = copy_siginfo_from_user_any(&kinfo, info); 3869 if (unlikely(ret)) 3870 goto err; 3871 3872 ret = -EINVAL; 3873 if (unlikely(sig != kinfo.si_signo)) 3874 goto err; 3875 3876 /* Only allow sending arbitrary signals to yourself. */ 3877 ret = -EPERM; 3878 if ((task_pid(current) != pid) && 3879 (kinfo.si_code >= 0 || kinfo.si_code == SI_TKILL)) 3880 goto err; 3881 } else { 3882 prepare_kill_siginfo(sig, &kinfo); 3883 } 3884 3885 ret = kill_pid_info(sig, &kinfo, pid); 3886 3887 err: 3888 fdput(f); 3889 return ret; 3890 } 3891 3892 static int 3893 do_send_specific(pid_t tgid, pid_t pid, int sig, struct kernel_siginfo *info) 3894 { 3895 struct task_struct *p; 3896 int error = -ESRCH; 3897 3898 rcu_read_lock(); 3899 p = find_task_by_vpid(pid); 3900 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) { 3901 error = check_kill_permission(sig, info, p); 3902 /* 3903 * The null signal is a permissions and process existence 3904 * probe. No signal is actually delivered. 3905 */ 3906 if (!error && sig) { 3907 error = do_send_sig_info(sig, info, p, PIDTYPE_PID); 3908 /* 3909 * If lock_task_sighand() failed we pretend the task 3910 * dies after receiving the signal. The window is tiny, 3911 * and the signal is private anyway. 3912 */ 3913 if (unlikely(error == -ESRCH)) 3914 error = 0; 3915 } 3916 } 3917 rcu_read_unlock(); 3918 3919 return error; 3920 } 3921 3922 static int do_tkill(pid_t tgid, pid_t pid, int sig) 3923 { 3924 struct kernel_siginfo info; 3925 3926 clear_siginfo(&info); 3927 info.si_signo = sig; 3928 info.si_errno = 0; 3929 info.si_code = SI_TKILL; 3930 info.si_pid = task_tgid_vnr(current); 3931 info.si_uid = from_kuid_munged(current_user_ns(), current_uid()); 3932 3933 return do_send_specific(tgid, pid, sig, &info); 3934 } 3935 3936 /** 3937 * sys_tgkill - send signal to one specific thread 3938 * @tgid: the thread group ID of the thread 3939 * @pid: the PID of the thread 3940 * @sig: signal to be sent 3941 * 3942 * This syscall also checks the @tgid and returns -ESRCH even if the PID 3943 * exists but it's not belonging to the target process anymore. This 3944 * method solves the problem of threads exiting and PIDs getting reused. 3945 */ 3946 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig) 3947 { 3948 /* This is only valid for single tasks */ 3949 if (pid <= 0 || tgid <= 0) 3950 return -EINVAL; 3951 3952 return do_tkill(tgid, pid, sig); 3953 } 3954 3955 /** 3956 * sys_tkill - send signal to one specific task 3957 * @pid: the PID of the task 3958 * @sig: signal to be sent 3959 * 3960 * Send a signal to only one task, even if it's a CLONE_THREAD task. 3961 */ 3962 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig) 3963 { 3964 /* This is only valid for single tasks */ 3965 if (pid <= 0) 3966 return -EINVAL; 3967 3968 return do_tkill(0, pid, sig); 3969 } 3970 3971 static int do_rt_sigqueueinfo(pid_t pid, int sig, kernel_siginfo_t *info) 3972 { 3973 /* Not even root can pretend to send signals from the kernel. 3974 * Nor can they impersonate a kill()/tgkill(), which adds source info. 3975 */ 3976 if ((info->si_code >= 0 || info->si_code == SI_TKILL) && 3977 (task_pid_vnr(current) != pid)) 3978 return -EPERM; 3979 3980 /* POSIX.1b doesn't mention process groups. */ 3981 return kill_proc_info(sig, info, pid); 3982 } 3983 3984 /** 3985 * sys_rt_sigqueueinfo - send signal information to a signal 3986 * @pid: the PID of the thread 3987 * @sig: signal to be sent 3988 * @uinfo: signal info to be sent 3989 */ 3990 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig, 3991 siginfo_t __user *, uinfo) 3992 { 3993 kernel_siginfo_t info; 3994 int ret = __copy_siginfo_from_user(sig, &info, uinfo); 3995 if (unlikely(ret)) 3996 return ret; 3997 return do_rt_sigqueueinfo(pid, sig, &info); 3998 } 3999 4000 #ifdef CONFIG_COMPAT 4001 COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo, 4002 compat_pid_t, pid, 4003 int, sig, 4004 struct compat_siginfo __user *, uinfo) 4005 { 4006 kernel_siginfo_t info; 4007 int ret = __copy_siginfo_from_user32(sig, &info, uinfo); 4008 if (unlikely(ret)) 4009 return ret; 4010 return do_rt_sigqueueinfo(pid, sig, &info); 4011 } 4012 #endif 4013 4014 static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, kernel_siginfo_t *info) 4015 { 4016 /* This is only valid for single tasks */ 4017 if (pid <= 0 || tgid <= 0) 4018 return -EINVAL; 4019 4020 /* Not even root can pretend to send signals from the kernel. 4021 * Nor can they impersonate a kill()/tgkill(), which adds source info. 4022 */ 4023 if ((info->si_code >= 0 || info->si_code == SI_TKILL) && 4024 (task_pid_vnr(current) != pid)) 4025 return -EPERM; 4026 4027 return do_send_specific(tgid, pid, sig, info); 4028 } 4029 4030 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig, 4031 siginfo_t __user *, uinfo) 4032 { 4033 kernel_siginfo_t info; 4034 int ret = __copy_siginfo_from_user(sig, &info, uinfo); 4035 if (unlikely(ret)) 4036 return ret; 4037 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info); 4038 } 4039 4040 #ifdef CONFIG_COMPAT 4041 COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo, 4042 compat_pid_t, tgid, 4043 compat_pid_t, pid, 4044 int, sig, 4045 struct compat_siginfo __user *, uinfo) 4046 { 4047 kernel_siginfo_t info; 4048 int ret = __copy_siginfo_from_user32(sig, &info, uinfo); 4049 if (unlikely(ret)) 4050 return ret; 4051 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info); 4052 } 4053 #endif 4054 4055 /* 4056 * For kthreads only, must not be used if cloned with CLONE_SIGHAND 4057 */ 4058 void kernel_sigaction(int sig, __sighandler_t action) 4059 { 4060 spin_lock_irq(¤t->sighand->siglock); 4061 current->sighand->action[sig - 1].sa.sa_handler = action; 4062 if (action == SIG_IGN) { 4063 sigset_t mask; 4064 4065 sigemptyset(&mask); 4066 sigaddset(&mask, sig); 4067 4068 flush_sigqueue_mask(&mask, ¤t->signal->shared_pending); 4069 flush_sigqueue_mask(&mask, ¤t->pending); 4070 recalc_sigpending(); 4071 } 4072 spin_unlock_irq(¤t->sighand->siglock); 4073 } 4074 EXPORT_SYMBOL(kernel_sigaction); 4075 4076 void __weak sigaction_compat_abi(struct k_sigaction *act, 4077 struct k_sigaction *oact) 4078 { 4079 } 4080 4081 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact) 4082 { 4083 struct task_struct *p = current, *t; 4084 struct k_sigaction *k; 4085 sigset_t mask; 4086 4087 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig))) 4088 return -EINVAL; 4089 4090 k = &p->sighand->action[sig-1]; 4091 4092 spin_lock_irq(&p->sighand->siglock); 4093 if (k->sa.sa_flags & SA_IMMUTABLE) { 4094 spin_unlock_irq(&p->sighand->siglock); 4095 return -EINVAL; 4096 } 4097 if (oact) 4098 *oact = *k; 4099 4100 /* 4101 * Make sure that we never accidentally claim to support SA_UNSUPPORTED, 4102 * e.g. by having an architecture use the bit in their uapi. 4103 */ 4104 BUILD_BUG_ON(UAPI_SA_FLAGS & SA_UNSUPPORTED); 4105 4106 /* 4107 * Clear unknown flag bits in order to allow userspace to detect missing 4108 * support for flag bits and to allow the kernel to use non-uapi bits 4109 * internally. 4110 */ 4111 if (act) 4112 act->sa.sa_flags &= UAPI_SA_FLAGS; 4113 if (oact) 4114 oact->sa.sa_flags &= UAPI_SA_FLAGS; 4115 4116 sigaction_compat_abi(act, oact); 4117 4118 if (act) { 4119 sigdelsetmask(&act->sa.sa_mask, 4120 sigmask(SIGKILL) | sigmask(SIGSTOP)); 4121 *k = *act; 4122 /* 4123 * POSIX 3.3.1.3: 4124 * "Setting a signal action to SIG_IGN for a signal that is 4125 * pending shall cause the pending signal to be discarded, 4126 * whether or not it is blocked." 4127 * 4128 * "Setting a signal action to SIG_DFL for a signal that is 4129 * pending and whose default action is to ignore the signal 4130 * (for example, SIGCHLD), shall cause the pending signal to 4131 * be discarded, whether or not it is blocked" 4132 */ 4133 if (sig_handler_ignored(sig_handler(p, sig), sig)) { 4134 sigemptyset(&mask); 4135 sigaddset(&mask, sig); 4136 flush_sigqueue_mask(&mask, &p->signal->shared_pending); 4137 for_each_thread(p, t) 4138 flush_sigqueue_mask(&mask, &t->pending); 4139 } 4140 } 4141 4142 spin_unlock_irq(&p->sighand->siglock); 4143 return 0; 4144 } 4145 4146 #ifdef CONFIG_DYNAMIC_SIGFRAME 4147 static inline void sigaltstack_lock(void) 4148 __acquires(¤t->sighand->siglock) 4149 { 4150 spin_lock_irq(¤t->sighand->siglock); 4151 } 4152 4153 static inline void sigaltstack_unlock(void) 4154 __releases(¤t->sighand->siglock) 4155 { 4156 spin_unlock_irq(¤t->sighand->siglock); 4157 } 4158 #else 4159 static inline void sigaltstack_lock(void) { } 4160 static inline void sigaltstack_unlock(void) { } 4161 #endif 4162 4163 static int 4164 do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp, 4165 size_t min_ss_size) 4166 { 4167 struct task_struct *t = current; 4168 int ret = 0; 4169 4170 if (oss) { 4171 memset(oss, 0, sizeof(stack_t)); 4172 oss->ss_sp = (void __user *) t->sas_ss_sp; 4173 oss->ss_size = t->sas_ss_size; 4174 oss->ss_flags = sas_ss_flags(sp) | 4175 (current->sas_ss_flags & SS_FLAG_BITS); 4176 } 4177 4178 if (ss) { 4179 void __user *ss_sp = ss->ss_sp; 4180 size_t ss_size = ss->ss_size; 4181 unsigned ss_flags = ss->ss_flags; 4182 int ss_mode; 4183 4184 if (unlikely(on_sig_stack(sp))) 4185 return -EPERM; 4186 4187 ss_mode = ss_flags & ~SS_FLAG_BITS; 4188 if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK && 4189 ss_mode != 0)) 4190 return -EINVAL; 4191 4192 /* 4193 * Return before taking any locks if no actual 4194 * sigaltstack changes were requested. 4195 */ 4196 if (t->sas_ss_sp == (unsigned long)ss_sp && 4197 t->sas_ss_size == ss_size && 4198 t->sas_ss_flags == ss_flags) 4199 return 0; 4200 4201 sigaltstack_lock(); 4202 if (ss_mode == SS_DISABLE) { 4203 ss_size = 0; 4204 ss_sp = NULL; 4205 } else { 4206 if (unlikely(ss_size < min_ss_size)) 4207 ret = -ENOMEM; 4208 if (!sigaltstack_size_valid(ss_size)) 4209 ret = -ENOMEM; 4210 } 4211 if (!ret) { 4212 t->sas_ss_sp = (unsigned long) ss_sp; 4213 t->sas_ss_size = ss_size; 4214 t->sas_ss_flags = ss_flags; 4215 } 4216 sigaltstack_unlock(); 4217 } 4218 return ret; 4219 } 4220 4221 SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss) 4222 { 4223 stack_t new, old; 4224 int err; 4225 if (uss && copy_from_user(&new, uss, sizeof(stack_t))) 4226 return -EFAULT; 4227 err = do_sigaltstack(uss ? &new : NULL, uoss ? &old : NULL, 4228 current_user_stack_pointer(), 4229 MINSIGSTKSZ); 4230 if (!err && uoss && copy_to_user(uoss, &old, sizeof(stack_t))) 4231 err = -EFAULT; 4232 return err; 4233 } 4234 4235 int restore_altstack(const stack_t __user *uss) 4236 { 4237 stack_t new; 4238 if (copy_from_user(&new, uss, sizeof(stack_t))) 4239 return -EFAULT; 4240 (void)do_sigaltstack(&new, NULL, current_user_stack_pointer(), 4241 MINSIGSTKSZ); 4242 /* squash all but EFAULT for now */ 4243 return 0; 4244 } 4245 4246 int __save_altstack(stack_t __user *uss, unsigned long sp) 4247 { 4248 struct task_struct *t = current; 4249 int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) | 4250 __put_user(t->sas_ss_flags, &uss->ss_flags) | 4251 __put_user(t->sas_ss_size, &uss->ss_size); 4252 return err; 4253 } 4254 4255 #ifdef CONFIG_COMPAT 4256 static int do_compat_sigaltstack(const compat_stack_t __user *uss_ptr, 4257 compat_stack_t __user *uoss_ptr) 4258 { 4259 stack_t uss, uoss; 4260 int ret; 4261 4262 if (uss_ptr) { 4263 compat_stack_t uss32; 4264 if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t))) 4265 return -EFAULT; 4266 uss.ss_sp = compat_ptr(uss32.ss_sp); 4267 uss.ss_flags = uss32.ss_flags; 4268 uss.ss_size = uss32.ss_size; 4269 } 4270 ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, 4271 compat_user_stack_pointer(), 4272 COMPAT_MINSIGSTKSZ); 4273 if (ret >= 0 && uoss_ptr) { 4274 compat_stack_t old; 4275 memset(&old, 0, sizeof(old)); 4276 old.ss_sp = ptr_to_compat(uoss.ss_sp); 4277 old.ss_flags = uoss.ss_flags; 4278 old.ss_size = uoss.ss_size; 4279 if (copy_to_user(uoss_ptr, &old, sizeof(compat_stack_t))) 4280 ret = -EFAULT; 4281 } 4282 return ret; 4283 } 4284 4285 COMPAT_SYSCALL_DEFINE2(sigaltstack, 4286 const compat_stack_t __user *, uss_ptr, 4287 compat_stack_t __user *, uoss_ptr) 4288 { 4289 return do_compat_sigaltstack(uss_ptr, uoss_ptr); 4290 } 4291 4292 int compat_restore_altstack(const compat_stack_t __user *uss) 4293 { 4294 int err = do_compat_sigaltstack(uss, NULL); 4295 /* squash all but -EFAULT for now */ 4296 return err == -EFAULT ? err : 0; 4297 } 4298 4299 int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp) 4300 { 4301 int err; 4302 struct task_struct *t = current; 4303 err = __put_user(ptr_to_compat((void __user *)t->sas_ss_sp), 4304 &uss->ss_sp) | 4305 __put_user(t->sas_ss_flags, &uss->ss_flags) | 4306 __put_user(t->sas_ss_size, &uss->ss_size); 4307 return err; 4308 } 4309 #endif 4310 4311 #ifdef __ARCH_WANT_SYS_SIGPENDING 4312 4313 /** 4314 * sys_sigpending - examine pending signals 4315 * @uset: where mask of pending signal is returned 4316 */ 4317 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, uset) 4318 { 4319 sigset_t set; 4320 4321 if (sizeof(old_sigset_t) > sizeof(*uset)) 4322 return -EINVAL; 4323 4324 do_sigpending(&set); 4325 4326 if (copy_to_user(uset, &set, sizeof(old_sigset_t))) 4327 return -EFAULT; 4328 4329 return 0; 4330 } 4331 4332 #ifdef CONFIG_COMPAT 4333 COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set32) 4334 { 4335 sigset_t set; 4336 4337 do_sigpending(&set); 4338 4339 return put_user(set.sig[0], set32); 4340 } 4341 #endif 4342 4343 #endif 4344 4345 #ifdef __ARCH_WANT_SYS_SIGPROCMASK 4346 /** 4347 * sys_sigprocmask - examine and change blocked signals 4348 * @how: whether to add, remove, or set signals 4349 * @nset: signals to add or remove (if non-null) 4350 * @oset: previous value of signal mask if non-null 4351 * 4352 * Some platforms have their own version with special arguments; 4353 * others support only sys_rt_sigprocmask. 4354 */ 4355 4356 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset, 4357 old_sigset_t __user *, oset) 4358 { 4359 old_sigset_t old_set, new_set; 4360 sigset_t new_blocked; 4361 4362 old_set = current->blocked.sig[0]; 4363 4364 if (nset) { 4365 if (copy_from_user(&new_set, nset, sizeof(*nset))) 4366 return -EFAULT; 4367 4368 new_blocked = current->blocked; 4369 4370 switch (how) { 4371 case SIG_BLOCK: 4372 sigaddsetmask(&new_blocked, new_set); 4373 break; 4374 case SIG_UNBLOCK: 4375 sigdelsetmask(&new_blocked, new_set); 4376 break; 4377 case SIG_SETMASK: 4378 new_blocked.sig[0] = new_set; 4379 break; 4380 default: 4381 return -EINVAL; 4382 } 4383 4384 set_current_blocked(&new_blocked); 4385 } 4386 4387 if (oset) { 4388 if (copy_to_user(oset, &old_set, sizeof(*oset))) 4389 return -EFAULT; 4390 } 4391 4392 return 0; 4393 } 4394 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */ 4395 4396 #ifndef CONFIG_ODD_RT_SIGACTION 4397 /** 4398 * sys_rt_sigaction - alter an action taken by a process 4399 * @sig: signal to be sent 4400 * @act: new sigaction 4401 * @oact: used to save the previous sigaction 4402 * @sigsetsize: size of sigset_t type 4403 */ 4404 SYSCALL_DEFINE4(rt_sigaction, int, sig, 4405 const struct sigaction __user *, act, 4406 struct sigaction __user *, oact, 4407 size_t, sigsetsize) 4408 { 4409 struct k_sigaction new_sa, old_sa; 4410 int ret; 4411 4412 /* XXX: Don't preclude handling different sized sigset_t's. */ 4413 if (sigsetsize != sizeof(sigset_t)) 4414 return -EINVAL; 4415 4416 if (act && copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa))) 4417 return -EFAULT; 4418 4419 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL); 4420 if (ret) 4421 return ret; 4422 4423 if (oact && copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa))) 4424 return -EFAULT; 4425 4426 return 0; 4427 } 4428 #ifdef CONFIG_COMPAT 4429 COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig, 4430 const struct compat_sigaction __user *, act, 4431 struct compat_sigaction __user *, oact, 4432 compat_size_t, sigsetsize) 4433 { 4434 struct k_sigaction new_ka, old_ka; 4435 #ifdef __ARCH_HAS_SA_RESTORER 4436 compat_uptr_t restorer; 4437 #endif 4438 int ret; 4439 4440 /* XXX: Don't preclude handling different sized sigset_t's. */ 4441 if (sigsetsize != sizeof(compat_sigset_t)) 4442 return -EINVAL; 4443 4444 if (act) { 4445 compat_uptr_t handler; 4446 ret = get_user(handler, &act->sa_handler); 4447 new_ka.sa.sa_handler = compat_ptr(handler); 4448 #ifdef __ARCH_HAS_SA_RESTORER 4449 ret |= get_user(restorer, &act->sa_restorer); 4450 new_ka.sa.sa_restorer = compat_ptr(restorer); 4451 #endif 4452 ret |= get_compat_sigset(&new_ka.sa.sa_mask, &act->sa_mask); 4453 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags); 4454 if (ret) 4455 return -EFAULT; 4456 } 4457 4458 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 4459 if (!ret && oact) { 4460 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), 4461 &oact->sa_handler); 4462 ret |= put_compat_sigset(&oact->sa_mask, &old_ka.sa.sa_mask, 4463 sizeof(oact->sa_mask)); 4464 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags); 4465 #ifdef __ARCH_HAS_SA_RESTORER 4466 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer), 4467 &oact->sa_restorer); 4468 #endif 4469 } 4470 return ret; 4471 } 4472 #endif 4473 #endif /* !CONFIG_ODD_RT_SIGACTION */ 4474 4475 #ifdef CONFIG_OLD_SIGACTION 4476 SYSCALL_DEFINE3(sigaction, int, sig, 4477 const struct old_sigaction __user *, act, 4478 struct old_sigaction __user *, oact) 4479 { 4480 struct k_sigaction new_ka, old_ka; 4481 int ret; 4482 4483 if (act) { 4484 old_sigset_t mask; 4485 if (!access_ok(act, sizeof(*act)) || 4486 __get_user(new_ka.sa.sa_handler, &act->sa_handler) || 4487 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) || 4488 __get_user(new_ka.sa.sa_flags, &act->sa_flags) || 4489 __get_user(mask, &act->sa_mask)) 4490 return -EFAULT; 4491 #ifdef __ARCH_HAS_KA_RESTORER 4492 new_ka.ka_restorer = NULL; 4493 #endif 4494 siginitset(&new_ka.sa.sa_mask, mask); 4495 } 4496 4497 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 4498 4499 if (!ret && oact) { 4500 if (!access_ok(oact, sizeof(*oact)) || 4501 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) || 4502 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) || 4503 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || 4504 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) 4505 return -EFAULT; 4506 } 4507 4508 return ret; 4509 } 4510 #endif 4511 #ifdef CONFIG_COMPAT_OLD_SIGACTION 4512 COMPAT_SYSCALL_DEFINE3(sigaction, int, sig, 4513 const struct compat_old_sigaction __user *, act, 4514 struct compat_old_sigaction __user *, oact) 4515 { 4516 struct k_sigaction new_ka, old_ka; 4517 int ret; 4518 compat_old_sigset_t mask; 4519 compat_uptr_t handler, restorer; 4520 4521 if (act) { 4522 if (!access_ok(act, sizeof(*act)) || 4523 __get_user(handler, &act->sa_handler) || 4524 __get_user(restorer, &act->sa_restorer) || 4525 __get_user(new_ka.sa.sa_flags, &act->sa_flags) || 4526 __get_user(mask, &act->sa_mask)) 4527 return -EFAULT; 4528 4529 #ifdef __ARCH_HAS_KA_RESTORER 4530 new_ka.ka_restorer = NULL; 4531 #endif 4532 new_ka.sa.sa_handler = compat_ptr(handler); 4533 new_ka.sa.sa_restorer = compat_ptr(restorer); 4534 siginitset(&new_ka.sa.sa_mask, mask); 4535 } 4536 4537 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 4538 4539 if (!ret && oact) { 4540 if (!access_ok(oact, sizeof(*oact)) || 4541 __put_user(ptr_to_compat(old_ka.sa.sa_handler), 4542 &oact->sa_handler) || 4543 __put_user(ptr_to_compat(old_ka.sa.sa_restorer), 4544 &oact->sa_restorer) || 4545 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || 4546 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) 4547 return -EFAULT; 4548 } 4549 return ret; 4550 } 4551 #endif 4552 4553 #ifdef CONFIG_SGETMASK_SYSCALL 4554 4555 /* 4556 * For backwards compatibility. Functionality superseded by sigprocmask. 4557 */ 4558 SYSCALL_DEFINE0(sgetmask) 4559 { 4560 /* SMP safe */ 4561 return current->blocked.sig[0]; 4562 } 4563 4564 SYSCALL_DEFINE1(ssetmask, int, newmask) 4565 { 4566 int old = current->blocked.sig[0]; 4567 sigset_t newset; 4568 4569 siginitset(&newset, newmask); 4570 set_current_blocked(&newset); 4571 4572 return old; 4573 } 4574 #endif /* CONFIG_SGETMASK_SYSCALL */ 4575 4576 #ifdef __ARCH_WANT_SYS_SIGNAL 4577 /* 4578 * For backwards compatibility. Functionality superseded by sigaction. 4579 */ 4580 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler) 4581 { 4582 struct k_sigaction new_sa, old_sa; 4583 int ret; 4584 4585 new_sa.sa.sa_handler = handler; 4586 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK; 4587 sigemptyset(&new_sa.sa.sa_mask); 4588 4589 ret = do_sigaction(sig, &new_sa, &old_sa); 4590 4591 return ret ? ret : (unsigned long)old_sa.sa.sa_handler; 4592 } 4593 #endif /* __ARCH_WANT_SYS_SIGNAL */ 4594 4595 #ifdef __ARCH_WANT_SYS_PAUSE 4596 4597 SYSCALL_DEFINE0(pause) 4598 { 4599 while (!signal_pending(current)) { 4600 __set_current_state(TASK_INTERRUPTIBLE); 4601 schedule(); 4602 } 4603 return -ERESTARTNOHAND; 4604 } 4605 4606 #endif 4607 4608 static int sigsuspend(sigset_t *set) 4609 { 4610 current->saved_sigmask = current->blocked; 4611 set_current_blocked(set); 4612 4613 while (!signal_pending(current)) { 4614 __set_current_state(TASK_INTERRUPTIBLE); 4615 schedule(); 4616 } 4617 set_restore_sigmask(); 4618 return -ERESTARTNOHAND; 4619 } 4620 4621 /** 4622 * sys_rt_sigsuspend - replace the signal mask for a value with the 4623 * @unewset value until a signal is received 4624 * @unewset: new signal mask value 4625 * @sigsetsize: size of sigset_t type 4626 */ 4627 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize) 4628 { 4629 sigset_t newset; 4630 4631 /* XXX: Don't preclude handling different sized sigset_t's. */ 4632 if (sigsetsize != sizeof(sigset_t)) 4633 return -EINVAL; 4634 4635 if (copy_from_user(&newset, unewset, sizeof(newset))) 4636 return -EFAULT; 4637 return sigsuspend(&newset); 4638 } 4639 4640 #ifdef CONFIG_COMPAT 4641 COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize) 4642 { 4643 sigset_t newset; 4644 4645 /* XXX: Don't preclude handling different sized sigset_t's. */ 4646 if (sigsetsize != sizeof(sigset_t)) 4647 return -EINVAL; 4648 4649 if (get_compat_sigset(&newset, unewset)) 4650 return -EFAULT; 4651 return sigsuspend(&newset); 4652 } 4653 #endif 4654 4655 #ifdef CONFIG_OLD_SIGSUSPEND 4656 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask) 4657 { 4658 sigset_t blocked; 4659 siginitset(&blocked, mask); 4660 return sigsuspend(&blocked); 4661 } 4662 #endif 4663 #ifdef CONFIG_OLD_SIGSUSPEND3 4664 SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask) 4665 { 4666 sigset_t blocked; 4667 siginitset(&blocked, mask); 4668 return sigsuspend(&blocked); 4669 } 4670 #endif 4671 4672 __weak const char *arch_vma_name(struct vm_area_struct *vma) 4673 { 4674 return NULL; 4675 } 4676 4677 static inline void siginfo_buildtime_checks(void) 4678 { 4679 BUILD_BUG_ON(sizeof(struct siginfo) != SI_MAX_SIZE); 4680 4681 /* Verify the offsets in the two siginfos match */ 4682 #define CHECK_OFFSET(field) \ 4683 BUILD_BUG_ON(offsetof(siginfo_t, field) != offsetof(kernel_siginfo_t, field)) 4684 4685 /* kill */ 4686 CHECK_OFFSET(si_pid); 4687 CHECK_OFFSET(si_uid); 4688 4689 /* timer */ 4690 CHECK_OFFSET(si_tid); 4691 CHECK_OFFSET(si_overrun); 4692 CHECK_OFFSET(si_value); 4693 4694 /* rt */ 4695 CHECK_OFFSET(si_pid); 4696 CHECK_OFFSET(si_uid); 4697 CHECK_OFFSET(si_value); 4698 4699 /* sigchld */ 4700 CHECK_OFFSET(si_pid); 4701 CHECK_OFFSET(si_uid); 4702 CHECK_OFFSET(si_status); 4703 CHECK_OFFSET(si_utime); 4704 CHECK_OFFSET(si_stime); 4705 4706 /* sigfault */ 4707 CHECK_OFFSET(si_addr); 4708 CHECK_OFFSET(si_trapno); 4709 CHECK_OFFSET(si_addr_lsb); 4710 CHECK_OFFSET(si_lower); 4711 CHECK_OFFSET(si_upper); 4712 CHECK_OFFSET(si_pkey); 4713 CHECK_OFFSET(si_perf_data); 4714 CHECK_OFFSET(si_perf_type); 4715 4716 /* sigpoll */ 4717 CHECK_OFFSET(si_band); 4718 CHECK_OFFSET(si_fd); 4719 4720 /* sigsys */ 4721 CHECK_OFFSET(si_call_addr); 4722 CHECK_OFFSET(si_syscall); 4723 CHECK_OFFSET(si_arch); 4724 #undef CHECK_OFFSET 4725 4726 /* usb asyncio */ 4727 BUILD_BUG_ON(offsetof(struct siginfo, si_pid) != 4728 offsetof(struct siginfo, si_addr)); 4729 if (sizeof(int) == sizeof(void __user *)) { 4730 BUILD_BUG_ON(sizeof_field(struct siginfo, si_pid) != 4731 sizeof(void __user *)); 4732 } else { 4733 BUILD_BUG_ON((sizeof_field(struct siginfo, si_pid) + 4734 sizeof_field(struct siginfo, si_uid)) != 4735 sizeof(void __user *)); 4736 BUILD_BUG_ON(offsetofend(struct siginfo, si_pid) != 4737 offsetof(struct siginfo, si_uid)); 4738 } 4739 #ifdef CONFIG_COMPAT 4740 BUILD_BUG_ON(offsetof(struct compat_siginfo, si_pid) != 4741 offsetof(struct compat_siginfo, si_addr)); 4742 BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) != 4743 sizeof(compat_uptr_t)); 4744 BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) != 4745 sizeof_field(struct siginfo, si_pid)); 4746 #endif 4747 } 4748 4749 void __init signals_init(void) 4750 { 4751 siginfo_buildtime_checks(); 4752 4753 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC | SLAB_ACCOUNT); 4754 } 4755 4756 #ifdef CONFIG_KGDB_KDB 4757 #include <linux/kdb.h> 4758 /* 4759 * kdb_send_sig - Allows kdb to send signals without exposing 4760 * signal internals. This function checks if the required locks are 4761 * available before calling the main signal code, to avoid kdb 4762 * deadlocks. 4763 */ 4764 void kdb_send_sig(struct task_struct *t, int sig) 4765 { 4766 static struct task_struct *kdb_prev_t; 4767 int new_t, ret; 4768 if (!spin_trylock(&t->sighand->siglock)) { 4769 kdb_printf("Can't do kill command now.\n" 4770 "The sigmask lock is held somewhere else in " 4771 "kernel, try again later\n"); 4772 return; 4773 } 4774 new_t = kdb_prev_t != t; 4775 kdb_prev_t = t; 4776 if (!task_is_running(t) && new_t) { 4777 spin_unlock(&t->sighand->siglock); 4778 kdb_printf("Process is not RUNNING, sending a signal from " 4779 "kdb risks deadlock\n" 4780 "on the run queue locks. " 4781 "The signal has _not_ been sent.\n" 4782 "Reissue the kill command if you want to risk " 4783 "the deadlock.\n"); 4784 return; 4785 } 4786 ret = send_signal(sig, SEND_SIG_PRIV, t, PIDTYPE_PID); 4787 spin_unlock(&t->sighand->siglock); 4788 if (ret) 4789 kdb_printf("Fail to deliver Signal %d to process %d.\n", 4790 sig, t->pid); 4791 else 4792 kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid); 4793 } 4794 #endif /* CONFIG_KGDB_KDB */ 4795