root/kernel/signal.c

/* [previous][next][first][last][top][bottom][index][help] [+1 kernel/signal.c] */

DEFINITIONS

This source file includes following definitions.
  1. sig_handler
  2. sig_handler_ignored
  3. sig_task_ignored
  4. sig_ignored
  5. has_pending_signals
  6. recalc_sigpending_tsk
  7. recalc_sigpending_and_wake
  8. recalc_sigpending
  9. next_signal
  10. print_dropped_signal
  11. task_set_jobctl_pending
  12. task_clear_jobctl_trapping
  13. task_clear_jobctl_pending
  14. task_participate_group_stop
  15. __sigqueue_alloc
  16. __sigqueue_free
  17. flush_sigqueue
  18. flush_signals
  19. __flush_itimer_signals
  20. flush_itimer_signals
  21. ignore_signals
  22. flush_signal_handlers
  23. unhandled_signal
  24. collect_signal
  25. __dequeue_signal
  26. dequeue_signal
  27. signal_wake_up_state
  28. flush_sigqueue_mask
  29. is_si_special
  30. si_fromuser
  31. kill_ok_by_cred
  32. check_kill_permission
  33. ptrace_trap_notify
  34. prepare_signal
  35. wants_signal
  36. complete_signal
  37. legacy_queue
  38. userns_fixup_signal_uid
  39. userns_fixup_signal_uid
  40. __send_signal
  41. send_signal
  42. print_fatal_signal
  43. setup_print_fatal_signals
  44. __group_send_sig_info
  45. specific_send_sig_info
  46. do_send_sig_info
  47. force_sig_info
  48. zap_other_threads
  49. __lock_task_sighand
  50. group_send_sig_info
  51. __kill_pgrp_info
  52. kill_pid_info
  53. kill_proc_info
  54. kill_as_cred_perm
  55. kill_pid_info_as_cred
  56. kill_something_info
  57. send_sig_info
  58. send_sig
  59. force_sig
  60. force_sigsegv
  61. kill_pgrp
  62. kill_pid
  63. sigqueue_alloc
  64. sigqueue_free
  65. send_sigqueue
  66. do_notify_parent
  67. do_notify_parent_cldstop
  68. may_ptrace_stop
  69. sigkill_pending
  70. ptrace_stop
  71. ptrace_do_notify
  72. ptrace_notify
  73. do_signal_stop
  74. do_jobctl_trap
  75. ptrace_signal
  76. get_signal
  77. signal_delivered
  78. signal_setup_done
  79. retarget_shared_pending
  80. exit_signals
  81. SYSCALL_DEFINE0
  82. do_no_restart_syscall
  83. __set_task_blocked
  84. set_current_blocked
  85. __set_current_blocked
  86. sigprocmask
  87. SYSCALL_DEFINE4
  88. COMPAT_SYSCALL_DEFINE4
  89. do_sigpending
  90. SYSCALL_DEFINE2
  91. COMPAT_SYSCALL_DEFINE2
  92. copy_siginfo_to_user
  93. do_sigtimedwait
  94. SYSCALL_DEFINE4
  95. SYSCALL_DEFINE2
  96. do_send_specific
  97. do_tkill
  98. SYSCALL_DEFINE3
  99. SYSCALL_DEFINE2
  100. do_rt_sigqueueinfo
  101. SYSCALL_DEFINE3
  102. COMPAT_SYSCALL_DEFINE3
  103. do_rt_tgsigqueueinfo
  104. SYSCALL_DEFINE4
  105. COMPAT_SYSCALL_DEFINE4
  106. kernel_sigaction
  107. do_sigaction
  108. do_sigaltstack
  109. SYSCALL_DEFINE2
  110. restore_altstack
  111. __save_altstack
  112. COMPAT_SYSCALL_DEFINE2
  113. compat_restore_altstack
  114. __compat_save_altstack
  115. SYSCALL_DEFINE1
  116. SYSCALL_DEFINE3
  117. SYSCALL_DEFINE4
  118. COMPAT_SYSCALL_DEFINE4
  119. SYSCALL_DEFINE3
  120. COMPAT_SYSCALL_DEFINE3
  121. SYSCALL_DEFINE0
  122. SYSCALL_DEFINE1
  123. SYSCALL_DEFINE2
  124. SYSCALL_DEFINE0
  125. sigsuspend
  126. SYSCALL_DEFINE2
  127. COMPAT_SYSCALL_DEFINE2
  128. SYSCALL_DEFINE1
  129. SYSCALL_DEFINE3
  130. arch_vma_name
  131. signals_init
  132. kdb_send_sig_info

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

/* [previous][next][first][last][top][bottom][index][help] [+3623 kernel/signal.c] */