*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->FreeBSD man pages -> issignal (9)              
Title
Content
Arch
Section
 

SIGNAL(9)

Contents


NAME    [Toc]    [Back]

     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    [Toc]    [Back]

     #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 proc *p);

     void
     execsigs(struct proc *p);

     int
     issignal(struct proc *p);

     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 proc *p);

     void
     trapsignal(struct proc *p, int sig, u_long code);

DESCRIPTION    [Toc]    [Back]

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

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

     The SIGEMPTYSET() macro clears all signals in set.

     The SIGFILLSET() macro sets all signals in set.

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

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

     The SIGNOTEMPTY() macro determines if 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 set2 into set1.

     The SIGSETAND() macro ands the signals set in set2 into set1.

     The SIGSETNAND() macro nands the signals set in set2 into set1.

     The SIG_CANTMASK() macro clears the SIGKILL and SIGSTOP signals from 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 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 set.
     SIG_CONTSIGMASK() is call 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 p.  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 exec(2).  The lock for p must be held
     before execsigs() is called.

     The issignal() function determines if there are any pending signals for p
     that should be caught, cause p to terminate or interrupt the current system
 call.	If p is currently being traced, ignored signals will be handled
 and p 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.  sched_lock may be
     acquired and released and if Giant is held it may be released and reacquired.
  p must be locked before issignal() is called and may be released
     and reacquired during the call; as well, p's parent's lock may be
     acquired and released.  Default signal actions are not taken for system
     processes and init.

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

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

     The postsig() function handles the actual delivery of the signal 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 sigexit() function causes the process that owns td to exit with a
     return value of signal number sig. If required, the process will dump
     core.  The lock for the process that owns td must be held before
     sigexit() is called, and Giant will be acquired if it is not already
     held.

     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 p.  The process lock for 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 p 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
     p.  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.
     Giant is acquired and released, as is the lock for p.

RETURN VALUES    [Toc]    [Back]

     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.

     CURSIG() returns either a valid signal number or zero.

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

SEE ALSO    [Toc]    [Back]

      
      
     gsignal(9), pgsignal(9), psignal(9)

AUTHORS    [Toc]    [Back]

     This man page was written by Chad David <davidc@FreeBSD.org>.


FreeBSD 5.2.1			 June 9, 2002			 FreeBSD 5.2.1
[ Back ]
 Similar pages
Name OS Title
signal Tru64 Modifies signal functions
sigaction Linux POSIX signal handling functions.
signal Tru64 Contains definitions and variables used by signal functions
signal.h Tru64 Contains definitions and variables used by signal functions
hashinit OpenBSD kernel hashtable functions
hash32_buf NetBSD kernel hash functions
lockinit NetBSD kernel lock functions
simple_lock_init NetBSD kernel lock functions
simple_lock_unlock NetBSD kernel lock functions
simple_lock_try NetBSD kernel lock functions
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service