signalvar.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*
    2  * Copyright (c) 1991, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. All advertising materials mentioning features or use of this software
   14  *    must display the following acknowledgement:
   15  *      This product includes software developed by the University of
   16  *      California, Berkeley and its contributors.
   17  * 4. Neither the name of the University nor the names of its contributors
   18  *    may be used to endorse or promote products derived from this software
   19  *    without specific prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   31  * SUCH DAMAGE.
   32  *
   33  *      @(#)signalvar.h 8.6 (Berkeley) 2/19/95
   34  * $FreeBSD$
   35  */
   36 
   37 #ifndef _SYS_SIGNALVAR_H_               /* tmp for user.h */
   38 #define _SYS_SIGNALVAR_H_
   39 
   40 #include <sys/signal.h>
   41 #include <sys/proc.h>
   42 #include <machine/smp.h>
   43 
   44 /*
   45  * Kernel signal definitions and data structures,
   46  * not exported to user programs.
   47  */
   48 
   49 /*
   50  * Process signal actions and state, needed only within the process
   51  * (not necessarily resident).
   52  */
   53 struct  sigacts {
   54         sig_t   ps_sigact[_SIG_MAXSIG]; /* disposition of signals */
   55         sigset_t ps_catchmask[_SIG_MAXSIG];     /* signals to be blocked */
   56         sigset_t ps_sigonstack;         /* signals to take on sigstack */
   57         sigset_t ps_sigintr;            /* signals that interrupt syscalls */
   58         sigset_t ps_sigreset;           /* signals that reset when caught */
   59         sigset_t ps_signodefer;         /* signals not masked while handled */
   60         sigset_t ps_siginfo;            /* signals that want SA_SIGINFO args */
   61         sigset_t ps_osigset;            /* signals that use osigset_t */
   62         sigset_t ps_usertramp;          /* SunOS compat; libc sigtramp XXX */
   63 };
   64 
   65 /*
   66  * Compatibility.
   67  */
   68 typedef struct {
   69         struct osigcontext si_sc;
   70         int             si_signo;
   71         int             si_code;
   72         union sigval    si_value;
   73 } osiginfo_t;
   74 
   75 struct  osigaction {
   76         union {
   77                 void    (*__sa_handler) __P((int));
   78                 void    (*__sa_sigaction) __P((int, osiginfo_t *, void *));
   79         } __sigaction_u;                /* signal handler */
   80         osigset_t       sa_mask;        /* signal mask to apply */
   81         int             sa_flags;       /* see signal options below */
   82 };
   83 
   84 typedef void __osiginfohandler_t __P((int, osiginfo_t *, void *));
   85 
   86 /* additional signal action values, used only temporarily/internally */
   87 #define SIG_CATCH       ((__sighandler_t *)2)
   88 #define SIG_HOLD        ((__sighandler_t *)3)
   89 
   90 /*
   91  * get signal action for process and signal; currently only for current process
   92  */
   93 #define SIGACTION(p, sig)       (p->p_sigacts->ps_sigact[_SIG_IDX(sig)])
   94 
   95 /*
   96  * sigset_t manipulation macros
   97  */
   98 #define SIGADDSET(set, signo)                                           \
   99         (set).__bits[_SIG_WORD(signo)] |= _SIG_BIT(signo)
  100 
  101 #define SIGDELSET(set, signo)                                           \
  102         (set).__bits[_SIG_WORD(signo)] &= ~_SIG_BIT(signo)
  103 
  104 #define SIGEMPTYSET(set)                                                \
  105         do {                                                            \
  106                 int __i;                                                \
  107                 for (__i = 0; __i < _SIG_WORDS; __i++)                  \
  108                         (set).__bits[__i] = 0;                          \
  109         } while (0)
  110 
  111 #define SIGFILLSET(set)                                                 \
  112         do {                                                            \
  113                 int __i;                                                \
  114                 for (__i = 0; __i < _SIG_WORDS; __i++)                  \
  115                         (set).__bits[__i] = ~(unsigned int)0;           \
  116         } while (0)
  117 
  118 #define SIGISMEMBER(set, signo)                                         \
  119         ((set).__bits[_SIG_WORD(signo)] & _SIG_BIT(signo))
  120 
  121 #define SIGISEMPTY(set)         __sigisempty(&(set))
  122 #define SIGNOTEMPTY(set)        (!__sigisempty(&(set)))
  123 
  124 #define SIGSETEQ(set1, set2)    __sigseteq(&(set1), &(set2))
  125 #define SIGSETNEQ(set1, set2)   (!__sigseteq(&(set1), &(set2)))
  126 
  127 #define SIGSETOR(set1, set2)                                            \
  128         do {                                                            \
  129                 int __i;                                                \
  130                 for (__i = 0; __i < _SIG_WORDS; __i++)                  \
  131                         (set1).__bits[__i] |= (set2).__bits[__i];       \
  132         } while (0)
  133 
  134 #define SIGSETAND(set1, set2)                                           \
  135         do {                                                            \
  136                 int __i;                                                \
  137                 for (__i = 0; __i < _SIG_WORDS; __i++)                  \
  138                         (set1).__bits[__i] &= (set2).__bits[__i];       \
  139         } while (0)
  140 
  141 #define SIGSETNAND(set1, set2)                                          \
  142         do {                                                            \
  143                 int __i;                                                \
  144                 for (__i = 0; __i < _SIG_WORDS; __i++)                  \
  145                         (set1).__bits[__i] &= ~(set2).__bits[__i];      \
  146         } while (0)
  147 
  148 #define SIGSETLO(set1, set2)    ((set1).__bits[0] = (set2).__bits[0])
  149 #define SIGSETOLD(set, oset)    ((set).__bits[0] = (oset))
  150 
  151 #define SIG_CANTMASK(set)                                               \
  152         SIGDELSET(set, SIGKILL), SIGDELSET(set, SIGSTOP)
  153 
  154 #define SIG_STOPSIGMASK(set)                                            \
  155         SIGDELSET(set, SIGSTOP), SIGDELSET(set, SIGTSTP),               \
  156         SIGDELSET(set, SIGTTIN), SIGDELSET(set, SIGTTOU)
  157 
  158 #define SIG_CONTSIGMASK(set)                                            \
  159         SIGDELSET(set, SIGCONT)
  160 
  161 #define sigcantmask     (sigmask(SIGKILL) | sigmask(SIGSTOP))
  162 
  163 #define SIG2OSIG(sig, osig)     osig = (sig).__bits[0]
  164 #define OSIG2SIG(osig, sig)     SIGEMPTYSET(sig); (sig).__bits[0] = osig
  165 
  166 static __inline int
  167 __sigisempty(sigset_t *set)
  168 {
  169         int i;
  170 
  171         for (i = 0; i < _SIG_WORDS; i++) {
  172                 if (set->__bits[i])
  173                         return (0);
  174         }
  175         return (1);
  176 }
  177 
  178 static __inline int
  179 __sigseteq(sigset_t *set1, sigset_t *set2)
  180 {
  181         int i;
  182 
  183         for (i = 0; i < _SIG_WORDS; i++) {
  184                 if (set1->__bits[i] != set2->__bits[i])
  185                         return (0);
  186         }
  187         return (1);
  188 }
  189 
  190 #ifdef _KERNEL
  191 
  192 struct pgrp;
  193 struct proc;
  194 struct sigio;
  195 
  196 extern int sugid_coredump;      /* Sysctl variable kern.sugid_coredump */
  197 
  198 /*
  199  * Machine-independent functions:
  200  */
  201 void    check_sigacts __P((void));
  202 void    execsigs __P((struct proc *p));
  203 void    gsignal __P((int pgid, int sig));
  204 int     issignal __P((struct proc *p));
  205 void    killproc __P((struct proc *p, char *why));
  206 void    pgsigio __P((struct sigio *, int signum, int checkctty));
  207 void    pgsignal __P((struct pgrp *pgrp, int sig, int checkctty));
  208 void    postsig __P((int sig));
  209 void    psignal __P((struct proc *p, int sig));
  210 void    sigexit __P((struct proc *p, int signum));
  211 void    siginit __P((struct proc *p));
  212 void    trapsignal __P((struct proc *p, int sig, u_long code));
  213 
  214 /*
  215  * Machine-dependent functions:
  216  */
  217 void    sendsig __P((sig_t action, int sig, sigset_t *retmask, u_long code));
  218 
  219 /*
  220  * Inline functions:
  221  */
  222 #define CURSIG(p)       __cursig(p)
  223 
  224 /*
  225  * Determine signal that should be delivered to process p, the current
  226  * process, 0 if none.  If there is a pending stop signal with default
  227  * action, the process stops in issignal().
  228  *
  229  * MP SAFE
  230  */
  231 static __inline int __cursig(struct proc *p)
  232 {
  233         sigset_t tmpset;
  234         int r;
  235 
  236         tmpset = p->p_siglist;
  237         SIGSETNAND(tmpset, p->p_sigmask);
  238         if (SIGISEMPTY(p->p_siglist) ||
  239              (!(p->p_flag & P_TRACED) && SIGISEMPTY(tmpset))) {
  240                 return(0);
  241         }
  242         get_mplock();
  243         r = issignal(p);
  244         rel_mplock();
  245         return(r);
  246 }
  247 
  248 #endif  /* _KERNEL */
  249 
  250 #endif  /* !_SYS_SIGNALVAR_H_ */
Cache object: 1977ec20593e1fc0194724637ce77f8d
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/sys/signalvar.h

FreeBSD/Linux Kernel Cross Reference
sys/sys/signalvar.h
