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  * SPDX-License-Identifier: BSD-3-Clause
    3  *
    4  * Copyright (c) 1991, 1993
    5  *      The Regents of the University of California.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. Neither the name of the University nor the names of its contributors
   16  *    may be used to endorse or promote products derived from this software
   17  *    without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29  * SUCH DAMAGE.
   30  *
   31  *      @(#)signalvar.h 8.6 (Berkeley) 2/19/95
   32  * $FreeBSD$
   33  */
   34 
   35 #ifndef _SYS_SIGNALVAR_H_
   36 #define _SYS_SIGNALVAR_H_
   37 
   38 #include <sys/queue.h>
   39 #include <sys/_lock.h>
   40 #include <sys/_mutex.h>
   41 #include <sys/signal.h>
   42 
   43 /*
   44  * Kernel signal definitions and data structures.
   45  */
   46 
   47 /*
   48  * Logical process signal actions and state, needed only within the process
   49  * The mapping between sigacts and proc structures is 1:1 except for rfork()
   50  * processes masquerading as threads which use one structure for the whole
   51  * group.  All members are locked by the included mutex.  The reference count
   52  * and mutex must be last for the bcopy in sigacts_copy() to work.
   53  */
   54 struct sigacts {
   55         sig_t   ps_sigact[_SIG_MAXSIG]; /* Disposition of signals. */
   56         sigset_t ps_catchmask[_SIG_MAXSIG];     /* Signals to be blocked. */
   57         sigset_t ps_sigonstack;         /* Signals to take on sigstack. */
   58         sigset_t ps_sigintr;            /* Signals that interrupt syscalls. */
   59         sigset_t ps_sigreset;           /* Signals that reset when caught. */
   60         sigset_t ps_signodefer;         /* Signals not masked while handled. */
   61         sigset_t ps_siginfo;            /* Signals that want SA_SIGINFO args. */
   62         sigset_t ps_sigignore;          /* Signals being ignored. */
   63         sigset_t ps_sigcatch;           /* Signals being caught by user. */
   64         sigset_t ps_freebsd4;           /* Signals using freebsd4 ucontext. */
   65         sigset_t ps_osigset;            /* Signals using <= 3.x osigset_t. */
   66         sigset_t ps_usertramp;          /* SunOS compat; libc sigtramp. XXX */
   67         int     ps_flag;
   68         u_int   ps_refcnt;
   69         struct mtx ps_mtx;
   70 };
   71 
   72 #define PS_NOCLDWAIT    0x0001  /* No zombies if child dies */
   73 #define PS_NOCLDSTOP    0x0002  /* No SIGCHLD when children stop. */
   74 #define PS_CLDSIGIGN    0x0004  /* The SIGCHLD handler is SIG_IGN. */
   75 
   76 #ifdef _KERNEL
   77 
   78 #ifdef COMPAT_43
   79 typedef struct {
   80         struct osigcontext si_sc;
   81         int             si_signo;
   82         int             si_code;
   83         union sigval    si_value;
   84 } osiginfo_t;
   85 
   86 struct osigaction {
   87         union {
   88                 void    (*__sa_handler)(int);
   89                 void    (*__sa_sigaction)(int, osiginfo_t *, void *);
   90         } __sigaction_u;                /* signal handler */
   91         osigset_t       sa_mask;        /* signal mask to apply */
   92         int             sa_flags;       /* see signal options below */
   93 };
   94 
   95 typedef void __osiginfohandler_t(int, osiginfo_t *, void *);
   96 #endif /* COMPAT_43 */
   97 
   98 /* additional signal action values, used only temporarily/internally */
   99 #define SIG_CATCH       ((__sighandler_t *)2)
  100 /* #define SIG_HOLD        ((__sighandler_t *)3) See signal.h */
  101 
  102 /*
  103  * get signal action for process and signal; currently only for current process
  104  */
  105 #define SIGACTION(p, sig)       (p->p_sigacts->ps_sigact[_SIG_IDX(sig)])
  106 
  107 #endif /* _KERNEL */
  108 
  109 /*
  110  * sigset_t manipulation macros.
  111  */
  112 #define SIGADDSET(set, signo)                                           \
  113         ((set).__bits[_SIG_WORD(signo)] |= _SIG_BIT(signo))
  114 
  115 #define SIGDELSET(set, signo)                                           \
  116         ((set).__bits[_SIG_WORD(signo)] &= ~_SIG_BIT(signo))
  117 
  118 #define SIGEMPTYSET(set)                                                \
  119         do {                                                            \
  120                 int __i;                                                \
  121                 for (__i = 0; __i < _SIG_WORDS; __i++)                  \
  122                         (set).__bits[__i] = 0;                          \
  123         } while (0)
  124 
  125 #define SIGFILLSET(set)                                                 \
  126         do {                                                            \
  127                 int __i;                                                \
  128                 for (__i = 0; __i < _SIG_WORDS; __i++)                  \
  129                         (set).__bits[__i] = ~0U;                        \
  130         } while (0)
  131 
  132 #define SIGISMEMBER(set, signo)                                         \
  133         ((set).__bits[_SIG_WORD(signo)] & _SIG_BIT(signo))
  134 
  135 #define SIGISEMPTY(set)         (__sigisempty(&(set)))
  136 #define SIGNOTEMPTY(set)        (!__sigisempty(&(set)))
  137 
  138 #define SIGSETEQ(set1, set2)    (__sigseteq(&(set1), &(set2)))
  139 #define SIGSETNEQ(set1, set2)   (!__sigseteq(&(set1), &(set2)))
  140 
  141 #define SIGSETOR(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 SIGSETAND(set1, set2)                                           \
  149         do {                                                            \
  150                 int __i;                                                \
  151                 for (__i = 0; __i < _SIG_WORDS; __i++)                  \
  152                         (set1).__bits[__i] &= (set2).__bits[__i];       \
  153         } while (0)
  154 
  155 #define SIGSETNAND(set1, set2)                                          \
  156         do {                                                            \
  157                 int __i;                                                \
  158                 for (__i = 0; __i < _SIG_WORDS; __i++)                  \
  159                         (set1).__bits[__i] &= ~(set2).__bits[__i];      \
  160         } while (0)
  161 
  162 #define SIGSETLO(set1, set2)    ((set1).__bits[0] = (set2).__bits[0])
  163 #define SIGSETOLD(set, oset)    ((set).__bits[0] = (oset))
  164 
  165 #define SIG_CANTMASK(set)                                               \
  166         SIGDELSET(set, SIGKILL), SIGDELSET(set, SIGSTOP)
  167 
  168 #define SIG_STOPSIGMASK(set)                                            \
  169         SIGDELSET(set, SIGSTOP), SIGDELSET(set, SIGTSTP),               \
  170         SIGDELSET(set, SIGTTIN), SIGDELSET(set, SIGTTOU)
  171 
  172 #define SIG_CONTSIGMASK(set)                                            \
  173         SIGDELSET(set, SIGCONT)
  174 
  175 #define sigcantmask     (sigmask(SIGKILL) | sigmask(SIGSTOP))
  176 
  177 #define SIG2OSIG(sig, osig)     (osig = (sig).__bits[0])
  178 #define OSIG2SIG(osig, sig)     SIGEMPTYSET(sig); (sig).__bits[0] = osig
  179 
  180 static __inline int
  181 __sigisempty(sigset_t *set)
  182 {
  183         int i;
  184 
  185         for (i = 0; i < _SIG_WORDS; i++) {
  186                 if (set->__bits[i])
  187                         return (0);
  188         }
  189         return (1);
  190 }
  191 
  192 static __inline int
  193 __sigseteq(sigset_t *set1, sigset_t *set2)
  194 {
  195         int i;
  196 
  197         for (i = 0; i < _SIG_WORDS; i++) {
  198                 if (set1->__bits[i] != set2->__bits[i])
  199                         return (0);
  200         }
  201         return (1);
  202 }
  203 
  204 #ifdef COMPAT_FREEBSD6
  205 struct osigevent {
  206         int     sigev_notify;           /* Notification type */
  207         union {
  208                 int     __sigev_signo;  /* Signal number */
  209                 int     __sigev_notify_kqueue;
  210         } __sigev_u;
  211         union sigval sigev_value;       /* Signal value */
  212 };
  213 #endif
  214 
  215 typedef struct ksiginfo {
  216         TAILQ_ENTRY(ksiginfo)   ksi_link;
  217         siginfo_t               ksi_info;
  218         int                     ksi_flags;
  219         struct sigqueue         *ksi_sigq;
  220 } ksiginfo_t;
  221 
  222 #define ksi_signo       ksi_info.si_signo
  223 #define ksi_errno       ksi_info.si_errno
  224 #define ksi_code        ksi_info.si_code
  225 #define ksi_pid         ksi_info.si_pid
  226 #define ksi_uid         ksi_info.si_uid
  227 #define ksi_status      ksi_info.si_status
  228 #define ksi_addr        ksi_info.si_addr
  229 #define ksi_value       ksi_info.si_value
  230 #define ksi_band        ksi_info.si_band
  231 #define ksi_trapno      ksi_info.si_trapno
  232 #define ksi_overrun     ksi_info.si_overrun
  233 #define ksi_timerid     ksi_info.si_timerid
  234 #define ksi_mqd         ksi_info.si_mqd
  235 
  236 /* bits for ksi_flags */
  237 #define KSI_TRAP        0x01    /* Generated by trap. */
  238 #define KSI_EXT         0x02    /* Externally managed ksi. */
  239 #define KSI_INS         0x04    /* Directly insert ksi, not the copy */
  240 #define KSI_SIGQ        0x08    /* Generated by sigqueue, might ret EAGAIN. */
  241 #define KSI_HEAD        0x10    /* Insert into head, not tail. */
  242 #define KSI_PTRACE      0x20    /* Generated by ptrace. */
  243 #define KSI_COPYMASK    (KSI_TRAP | KSI_SIGQ | KSI_PTRACE)
  244 
  245 #define KSI_ONQ(ksi)    ((ksi)->ksi_sigq != NULL)
  246 
  247 typedef struct sigqueue {
  248         sigset_t        sq_signals;     /* All pending signals. */
  249         sigset_t        sq_kill;        /* Legacy depth 1 queue. */
  250         sigset_t        sq_ptrace;      /* Depth 1 queue for ptrace(2). */
  251         TAILQ_HEAD(, ksiginfo)  sq_list;/* Queued signal info. */
  252         struct proc     *sq_proc;
  253         int             sq_flags;
  254 } sigqueue_t;
  255 
  256 /* Flags for ksi_flags */
  257 #define SQ_INIT 0x01
  258 
  259 /*
  260  * Fast_sigblock
  261  */
  262 #define SIGFASTBLOCK_SETPTR     1
  263 #define SIGFASTBLOCK_UNBLOCK    2
  264 #define SIGFASTBLOCK_UNSETPTR   3
  265 
  266 #define SIGFASTBLOCK_PEND       0x1
  267 #define SIGFASTBLOCK_FLAGS      0xf
  268 #define SIGFASTBLOCK_INC        0x10
  269 
  270 #ifndef _KERNEL
  271 int __sys_sigfastblock(int cmd, void *ptr);
  272 #endif
  273 
  274 #ifdef _KERNEL
  275 extern bool sigfastblock_fetch_always;
  276 
  277 /* Return nonzero if process p has an unmasked pending signal. */
  278 #define SIGPENDING(td)                                                  \
  279         ((!SIGISEMPTY((td)->td_siglist) &&                              \
  280             !sigsetmasked(&(td)->td_siglist, &(td)->td_sigmask)) ||     \
  281          (!SIGISEMPTY((td)->td_proc->p_siglist) &&                      \
  282             !sigsetmasked(&(td)->td_proc->p_siglist, &(td)->td_sigmask)))
  283 /*
  284  * Return the value of the pseudo-expression ((*set & ~*mask) == 0).  This
  285  * is an optimized version of SIGISEMPTY() on a temporary variable
  286  * containing SIGSETNAND(*set, *mask).
  287  */
  288 static __inline bool
  289 sigsetmasked(sigset_t *set, sigset_t *mask)
  290 {
  291         int i;
  292 
  293         for (i = 0; i < _SIG_WORDS; i++) {
  294                 if (set->__bits[i] & ~mask->__bits[i])
  295                         return (false);
  296         }
  297         return (true);
  298 }
  299 
  300 #define ksiginfo_init(ksi)                      \
  301 do {                                            \
  302         bzero(ksi, sizeof(ksiginfo_t));         \
  303 } while (0)
  304 
  305 #define ksiginfo_init_trap(ksi)                 \
  306 do {                                            \
  307         ksiginfo_t *kp = ksi;                   \
  308         bzero(kp, sizeof(ksiginfo_t));          \
  309         kp->ksi_flags |= KSI_TRAP;              \
  310 } while (0)
  311 
  312 static __inline void
  313 ksiginfo_copy(ksiginfo_t *src, ksiginfo_t *dst)
  314 {
  315         (dst)->ksi_info = src->ksi_info;
  316         (dst)->ksi_flags = (src->ksi_flags & KSI_COPYMASK);
  317 }
  318 
  319 static __inline void
  320 ksiginfo_set_sigev(ksiginfo_t *dst, struct sigevent *sigev)
  321 {
  322         dst->ksi_signo = sigev->sigev_signo;
  323         dst->ksi_value = sigev->sigev_value;
  324 }
  325 
  326 struct pgrp;
  327 struct proc;
  328 struct sigio;
  329 struct thread;
  330 
  331 /*
  332  * Lock the pointers for a sigio object in the underlying objects of
  333  * a file descriptor.
  334  */
  335 #define SIGIO_LOCK()    mtx_lock(&sigio_lock)
  336 #define SIGIO_TRYLOCK() mtx_trylock(&sigio_lock)
  337 #define SIGIO_UNLOCK()  mtx_unlock(&sigio_lock)
  338 #define SIGIO_LOCKED()  mtx_owned(&sigio_lock)
  339 #define SIGIO_ASSERT_LOCKED() mtx_assert(&sigio_lock, MA_OWNED)
  340 
  341 extern struct mtx       sigio_lock;
  342 
  343 /* Flags for kern_sigprocmask(). */
  344 #define SIGPROCMASK_OLD         0x0001
  345 #define SIGPROCMASK_PROC_LOCKED 0x0002
  346 #define SIGPROCMASK_PS_LOCKED   0x0004
  347 #define SIGPROCMASK_FASTBLK     0x0008
  348 
  349 /*
  350  * Modes for sigdeferstop().  Manages behaviour of
  351  * thread_suspend_check() in the region delimited by
  352  * sigdeferstop()/sigallowstop().  Must be restored to
  353  * SIGDEFERSTOP_OFF before returning to userspace.
  354  */
  355 #define SIGDEFERSTOP_NOP        0 /* continue doing whatever is done now */
  356 #define SIGDEFERSTOP_OFF        1 /* stop ignoring STOPs */
  357 #define SIGDEFERSTOP_SILENT     2 /* silently ignore STOPs */
  358 #define SIGDEFERSTOP_EINTR      3 /* ignore STOPs, return EINTR */
  359 #define SIGDEFERSTOP_ERESTART   4 /* ignore STOPs, return ERESTART */
  360 
  361 #define SIGDEFERSTOP_VAL_NCHG   (-1) /* placeholder indicating no state change */
  362 int     sigdeferstop_impl(int mode);
  363 void    sigallowstop_impl(int prev);
  364 
  365 static inline int
  366 sigdeferstop(int mode)
  367 {
  368 
  369         if (__predict_false(mode == SIGDEFERSTOP_NOP))
  370                 return (SIGDEFERSTOP_VAL_NCHG);
  371         return (sigdeferstop_impl(mode));
  372 }
  373 
  374 static inline void
  375 sigallowstop(int prev)
  376 {
  377 
  378         if (__predict_true(prev == SIGDEFERSTOP_VAL_NCHG))
  379                 return;
  380         sigallowstop_impl(prev);
  381 }
  382 
  383 int     cursig(struct thread *td);
  384 void    execsigs(struct proc *p);
  385 void    gsignal(int pgid, int sig, ksiginfo_t *ksi);
  386 void    killproc(struct proc *p, const char *why);
  387 ksiginfo_t *ksiginfo_alloc(int mwait);
  388 void    ksiginfo_free(ksiginfo_t *ksi);
  389 int     pksignal(struct proc *p, int sig, ksiginfo_t *ksi);
  390 void    pgsigio(struct sigio **sigiop, int sig, int checkctty);
  391 void    pgsignal(struct pgrp *pgrp, int sig, int checkctty, ksiginfo_t *ksi);
  392 int     postsig(int sig);
  393 void    kern_psignal(struct proc *p, int sig);
  394 int     ptracestop(struct thread *td, int sig, ksiginfo_t *si);
  395 void    sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *retmask);
  396 struct sigacts *sigacts_alloc(void);
  397 void    sigacts_copy(struct sigacts *dest, struct sigacts *src);
  398 void    sigacts_free(struct sigacts *ps);
  399 struct sigacts *sigacts_hold(struct sigacts *ps);
  400 int     sigacts_shared(struct sigacts *ps);
  401 int     sig_ast_checksusp(struct thread *td);
  402 int     sig_ast_needsigchk(struct thread *td);
  403 void    sig_drop_caught(struct proc *p);
  404 void    sigexit(struct thread *td, int sig) __dead2;
  405 int     sigev_findtd(struct proc *p, struct sigevent *sigev, struct thread **);
  406 void    sigfastblock_clear(struct thread *td);
  407 void    sigfastblock_fetch(struct thread *td);
  408 int     sig_intr(void);
  409 void    siginit(struct proc *p);
  410 void    signotify(struct thread *td);
  411 void    sigqueue_delete(struct sigqueue *queue, int sig);
  412 void    sigqueue_delete_proc(struct proc *p, int sig);
  413 void    sigqueue_flush(struct sigqueue *queue);
  414 void    sigqueue_init(struct sigqueue *queue, struct proc *p);
  415 void    sigqueue_take(ksiginfo_t *ksi);
  416 void    tdksignal(struct thread *td, int sig, ksiginfo_t *ksi);
  417 int     tdsendsignal(struct proc *p, struct thread *td, int sig,
  418            ksiginfo_t *ksi);
  419 void    tdsigcleanup(struct thread *td);
  420 void    tdsignal(struct thread *td, int sig);
  421 void    trapsignal(struct thread *td, ksiginfo_t *ksi);
  422 
  423 #endif /* _KERNEL */
  424 
  425 #endif /* !_SYS_SIGNALVAR_H_ */
Cache object: 56d59a47defb504100d58e88282fe8e9
[ 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
