Проект OpenNet: MAN SIG_STOPSIGMASK (9) Ядро (FreeBSD и Linux)

Интерактивная система просмотра системных руководств (man-ов)

SIG_STOPSIGMASK (9)

>> SIG_STOPSIGMASK (9) ( FreeBSD man: Ядро )

BSD mandoc

NAME



signal

 
SIGADDSET

 
SIGDELSET

 
SETEMPTYSET

 
SIGFILLSET

 
SIGISMEMBER

 
SIGISEMPTY

 
SIGNOTEMPTY

 
SIGSETEQ

 
SIGSETNEQ

 
SIGSETOR

 
SIGSETAND

 
SIGSETNAND

 
SIGSETCANTMASK

 
SIG_STOPSIGMASK

 
SIG_CONTSIGMASK

 
SIGPENDING

 
cursig

 
execsigs

 
issignal

 
killproc

 
pgsigio

 
postsig

 
sigexit

 
siginit

 
signotify

 
trapsignal

 - kernel signal functions

SYNOPSIS

   #include <sys/param.h>
   #include <sys/proc.h>
   #include <sys/signalvar.h>
void SIGADDSET (sigset_t set int signo);
void SIGDELSET (sigset_t set int signo);
void SIGEMPTYSET (sigset_t set);
void SIGFILLSET (sigset_t set);
int SIGISMEMBER (sigset_t set int signo);
int SIGISEMPTY (sigset_t set);
int SIGNOTEMPTY (sigset_t set);
int SIGSETEQ (sigset_t set1 sigset_t set2);
int SIGSETNEQ (sigset_t set1 sigset_t set2);
void SIGSETOR (sigset_t set1 sigset_t set2);
void SIGSETAND (sigset_t set1 sigset_t set2);
void SIGSETNAND (sigset_t set1 sigset_t set2);
void SIG_CANTMASK (sigset_t set);
void SIG_STOPSIGMASK (sigset_t set);
void SIG_CONTSIGMASK (sigset_t set);
int SIGPENDING (struct proc *p);
int cursig (struct thread *td);
void execsigs (struct proc *p);
int issignal (struct thread *td);
void killproc (struct proc *p char *why);
void pgsigio (struct sigio **sigiop int sig int checkctty);
void postsig (int sig);
void sigexit (struct thread *td int signum);
void siginit (struct proc *p);
void signotify (struct thread *td);
void trapsignal (struct thread *td int sig u_long code);

DESCRIPTION

The SIGADDSET ();
macro adds Fa signo to Fa set . No effort is made to ensure that Fa signo is a valid signal number.

The SIGDELSET ();
macro removes Fa signo from Fa set . No effort is made to ensure that Fa signo is a valid signal number.

The SIGEMPTYSET ();
macro clears all signals in Fa set .

The SIGFILLSET ();
macro sets all signals in Fa set .

The SIGISMEMBER ();
macro determines if Fa signo is set in Fa set .

The SIGISEMPTY ();
macro determines if Fa set does not have any signals set.

The SIGNOTEMPTY ();
macro determines if Fa set has any signals set.

The SIGSETEQ ();
macro determines if two signal sets are equal; that is, the same signals are set in both.

The SIGSETNEQ ();
macro determines if two signal sets differ; that is, if any signal set in one is not set in the other.

The SIGSETOR ();
macro ORs the signals set in Fa set2 into Fa set1 .

The SIGSETAND ();
macro ANDs the signals set in Fa set2 into Fa set1 .

The SIGSETNAND ();
macro NANDs the signals set in Fa set2 into Fa set1 .

The SIG_CANTMASK ();
macro clears the SIGKILL and SIGSTOP signals from Fa set . These two signals cannot be blocked or caught and SIG_CANTMASK ();
is used in code where signals are manipulated to ensure this policy is enforced.

The SIG_STOPSIGMASK ();
macro clears the SIGSTOP SIGTSTP SIGTTIN and SIGTTOU signals from Fa set . SIG_STOPSIGMASK ();
is used to clear stop signals when a process is waiting for a child to exit or exec, and when a process is continuing after having been suspended.

The SIG_CONTSIGMASK ();
macro clears the SIGCONT signal from Fa set . SIG_CONTSIGMASK ();
is called when a process is stopped.

The SIGPENDING ();
macro determines if the given process has any pending signals that are not masked. If the process has a pending signal and the process is currently being traced, SIGPENDING ();
will return true even if the signal is masked.

The cursig ();
function returns the signal number that should be delivered to process Fa td->td_proc . If there are no signals pending, zero is returned.

The execsigs ();
function resets the signal set and signal stack of a process in preparation for an execve(2). The lock for Fa p must be held before execsigs ();
is called.

The issignal ();
function determines if there are any pending signals for process Fa td->td_proc that should be caught, or cause this process to terminate or interrupt its current system call. If process Fa td->td_proc is currently being traced, ignored signals will be handled and the process is always stopped. Stop signals are handled and cleared right away by issignal ();
unless the process is a member of an orphaned process group and the stop signal originated from a TTY. The sched_lock lock may be acquired and released, and if Giant is held, it may be released and reacquired. The Vt sigacts structure Fa td->td_proc->p_sigacts must be locked before calling issignal ();
and may be released and reacquired during the call. The process lock for Fa td->td_proc must be acquired before calling issignal ();
and may be released and reacquired during the call. The lock for the parent of Fa td->td_proc may also be acquired and released. Default signal actions are not taken for system processes and init.

The killproc ();
function delivers SIGKILL to Fa p . Fa why is logged as the reason why the process was killed.

The pgsigio ();
function sends the signal Fa sig to the process or process group Fa sigiop->sio_pgid . If Fa checkctty is non-zero, the signal is only delivered to processes in the process group that have a controlling terminal. If Fa sigiop->sio_pgid is for a process (> 0), the lock for Fa sigiop->sio_proc is acquired and released. If Fa sigiop->sio_pgid is for a process group (< 0), the process group lock for Fa sigiop->sio_pgrp is acquired and released. The lock sigio_lock is acquired and released.

The postsig ();
function handles the actual delivery of the signal Fa sig . postsig ();
is called from ast ();
after the kernel has been notified that a signal should be delivered (via a call to signotify (,);
which causes the flag PS_NEEDSIGCHK to be set). The lock for process that owns curthread must be held before postsig ();
is called, and the current process cannot be 0. The lock for the p_sigacts field of the current process must be held before postsig ();
is called, and may be released and reacquired.

The sigexit ();
function causes the process that owns Fa td to exit with a return value of signal number Fa sig . If required, the process will dump core. The lock for the process that owns Fa td must be held before sigexit ();
is called.

The siginit ();
function is called during system initialization to cause every signal with a default property of SA_IGNORE (except SIGCONT to be ignored by Fa p . The process lock for Fa p is acquired and released by siginit (.);
The only process that siginit ();
is ever called for is proc0

The signotify ();
function flags that there are unmasked signals pending that ast ();
should handle. The lock for process Fa td->td_proc must be held before signotify ();
is called, and sched_lock is acquired and released.

The trapsignal ();
function sends a signal that is the result of a trap to process Fa td->td_proc . If the process is not being traced and the signal can be delivered immediately, trapsignal ();
will deliver it directly; otherwise, trapsignal ();
will call psignal(9) to cause the signal to be delivered. The sched_lock lock is acquired and released, as is the lock for Fa td->td_proc . The lock for the p_sigacts field of Fa td->td_proc is acquired and released.

RETURN VALUES

The SIGISMEMBER (,);
SIGISEMPTY (,);
SIGNOTEMPTY (,);
SIGSETEQ (,);
SIGSETNEQ (,);
and SIGPENDING ();
macros all return non-zero (true) if the condition they are checking is found to be true; otherwise, zero (false) is returned.

The cursig ();
function returns either a valid signal number or zero.

issignal ();
returns either a valid signal number or zero.