Lines Matching refs:to
9 * Changes to use preallocated sigqueue structures
10 * to allow signals to be sent reliably.
48 * Tracers always want to know about signals..
117 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
175 * In order to avoid problems with "switch_user()", we want to make
259 /* Notify the system that a driver wants to block all signals for this
260 * process, and wants to be notified if any signals at all were to be
264 * allowed. priv is a pointer to private data that the notifier routine
265 * can use to determine if the signal should be blocked or not. */
302 * Collect the siginfo appropriate to this signal. Check if
359 * Dequeue a signal and return the element to the caller, which is
360 * expected to free it.
362 * All callers have to hold the siglock.
380 * itimers in the signal delivery path to prevent DoS
384 * queued once. Changing the restart behaviour to
406 * stop signal it is about to process is no longer in the
412 * is to alert stop-signal processing code when another
422 * Release the siglock to ensure proper locking order
425 * about to disable them again anyway.
437 * NOTE! we rely on the previous spin_lock to
442 * No need to set need_resched since signal event passing
452 * For SIGKILL, we want to wake it up in the stopped/traced case.
581 * obliged to report it to the parent: if the
588 * the SIGCHLD was pending on entry to this kill.
604 * sure that no thread returns to user mode before
606 * thread eligible to run the signal handler--then
660 * Deliver the signal to listening signalfds. This must be called
674 defined whether kill() does so. We attempt to do so, on
676 allowed to fail with EAGAIN when low on memory we just
749 * we unblock the signal and change any SIG_IGN to SIG_DFL.
751 * Note: If we unblock the signal, we always reset it to SIG_DFL,
752 * since we do not want to have a signal handler that was blocked
755 * We don't want to have recursive SIGSEGV's etc, for example.
788 * Test if P wants to take SIG. After we've checked all threads with this,
789 * it's equivalent to finding no threads not blocking SIG. Any threads not
793 * will be equivalent to sending it to one such thread.
814 * Now find a thread we can wake up to take the signal off the queue.
817 * Probably the least surprising to the average bear.
823 * There is just one thread and it does not need to be woken.
829 * Otherwise try to find a suitable thread.
840 * No thread needs to be woken.
857 * This signal will be fatal to the whole group.
904 * Tell the chosen thread to wake up and dequeue it.
929 * to avoid several races.
1005 * kill_pgrp_info() sends a signal to a process group: this is what the tty
1145 * just to the specific thread.
1162 * thread case (when we don't need to follow the group
1163 * lists) in order to avoid races with "p->sighand"
1185 * They will go to an appropriate thread in the thread group.
1206 * the problem was already a SIGSEGV, we'll want to
1207 * make sure we don't even try to deliver the signal..
1243 * afford to lose notifications of asynchronous events, like timer
1246 * allocation fails we are able to report the failure to the application
1288 * The rcu based delayed sighand destroy makes it possible to
1293 * posix_timer_event can redirect it to the group leader
1317 * Deliver the signal to listening signalfds. This must be called
1357 * the overrun count. Other uses should not try to
1365 * Deliver the signal to listening signalfds. This must be called
1373 * to avoid several races.
1440 * defines special semantics for setting SIGCHLD to SIG_IGN
1444 * signal handler, we just set this to tell do_exit that we
1529 * is dead so don't allow us to stop.
1532 * is safe to enter schedule().
1546 * That makes it a way to test a stopped process for
1549 * If we actually decide not to stop at all because the tracer is gone,
1585 * last_siginfo, so that we are sure to have synchronized with
1586 * any signal-sending on another CPU that wants to examine it.
1622 * a group stop in progress and we are the last to stop,
1623 * report to the parent. When ptraced, every thread reports itself.
1642 * We have to stop all threads in the thread group.
1656 * There is a group stop in progress. We don't need to
1672 * Setting state to TASK_STOPPED for a group
1818 * The default action is to stop all threads in
1821 * always works. Note that siglock needs to be
1822 * dropped during the call to is_orphaned_pgrp()
1824 * This allows an intervening SIGCONT to be posted.
1825 * We need to check for that and bail out if necessary.
1844 * We didn't actually stop, due to a race
1858 * If it was able to dump core, this kills all
1907 * We don't need to get the kernel lock - this is all local to this
1913 * This is also useful for kernel threads that want to temporarily
2015 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2019 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2022 return __copy_to_user(to, from, sizeof(siginfo_t))
2027 * Please remember to update the signalfd_copyinfo() function
2030 * to avoid security leaks, but must copy the generic
2033 err = __put_user(from->si_signo, &to->si_signo);
2034 err |= __put_user(from->si_errno, &to->si_errno);
2035 err |= __put_user((short)from->si_code, &to->si_code);
2038 err |= __put_user(from->si_pid, &to->si_pid);
2039 err |= __put_user(from->si_uid, &to->si_uid);
2042 err |= __put_user(from->si_tid, &to->si_tid);
2043 err |= __put_user(from->si_overrun, &to->si_overrun);
2044 err |= __put_user(from->si_ptr, &to->si_ptr);
2047 err |= __put_user(from->si_band, &to->si_band);
2048 err |= __put_user(from->si_fd, &to->si_fd);
2051 err |= __put_user(from->si_addr, &to->si_addr);
2053 err |= __put_user(from->si_trapno, &to->si_trapno);
2057 err |= __put_user(from->si_pid, &to->si_pid);
2058 err |= __put_user(from->si_uid, &to->si_uid);
2059 err |= __put_user(from->si_status, &to->si_status);
2060 err |= __put_user(from->si_utime, &to->si_utime);
2061 err |= __put_user(from->si_stime, &to->si_stime);
2065 err |= __put_user(from->si_pid, &to->si_pid);
2066 err |= __put_user(from->si_uid, &to->si_uid);
2067 err |= __put_user(from->si_ptr, &to->si_ptr);
2070 err |= __put_user(from->si_pid, &to->si_pid);
2071 err |= __put_user(from->si_uid, &to->si_uid);
2098 * Invert the set of allowed signals to get those we
2099 * want to block.
2203 * sys_tgkill - send signal to one specific thread
2206 * @sig: signal to be sent
2209 * exists but it's not belonging to the target process anymore. This
2222 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2242 /* Not even root can pretend to send signals from the kernel.
2281 * "Setting a signal action to SIG_IGN for a signal that is
2282 * pending shall cause the pending signal to be discarded,
2285 * "Setting a signal action to SIG_DFL for a signal that is
2286 * pending and whose default action is to ignore the signal
2287 * (for example, SIGCHLD), shall cause the pending signal to
2339 * Note - this code used to test ss_flags incorrectly
2341 * to mean ss_flags==SS_ONSTACK (as this was the only