FreeBSD 7.0 manual page repository

FreeBSD is a free computer operating system based on BSD UNIX originally. Many IT companies, like DeployIS is using it to provide an up-to-date, stable operating system.

signal, SIGADDSET, SIGDELSET, SETEMPTYSET, SIGFILLSET, SIGISMEMBER,

 

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 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 sig‐
      nals 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 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 td->td_proc.  If there are no signals pending, zero is
      returned.
 
      The execsigs() function resets the signal set and signal stack of a pro‐
      cess in preparation for an execve(2).  The lock for p must be held before
      execsigs() is called.
 
      The issignal() function determines if there are any pending signals for
      process td->td_proc that should be caught, or cause this process to ter‐
      minate or interrupt its current system call.  If process 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 reac‐
      quired.  The sigacts structure td->td_proc->p_sigacts must be locked
      before calling issignal() and may be released and reacquired during the
      call.  The process lock for td->td_proc must be acquired before calling
      issignal() and may be released and reacquired during the call.  The lock
      for the parent of 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 p.  why is logged as the rea‐
      son 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 ter‐
      minal.  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.  The lock 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 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 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.
 
      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 process 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 td->td_proc.  If the process is not being traced and the signal
      can be delivered immediately, trapsignal() will deliver it directly; oth‐
      erwise, 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 td->td_proc.  The lock for the p_sigacts field of td->td_proc is
      acquired and released.
      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.
      gsignal(9), pgsignal(9), psignal(9)
 

AUTHORS

      This manual page was written by Chad David 〈davidc@FreeBSD.org〉.
 

Sections

Based on BSD UNIX
FreeBSD is an advanced operating system for x86 compatible (including Pentium and Athlon), amd64 compatible (including Opteron, Athlon64, and EM64T), UltraSPARC, IA-64, PC-98 and ARM architectures. It is derived from BSD, the version of UNIX developed at the University of California, Berkeley. It is developed and maintained by a large team of individuals. Additional platforms are in various stages of development.