sys/sys/signalvar.h

   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 sigset_t fastblock_mask;
 276 extern bool sigfastblock_fetch_always;
 277
 278 /* Return nonzero if process p has an unmasked pending signal. */
 279 #define SIGPENDING(td)                                                  \
 280         ((!SIGISEMPTY((td)->td_siglist) &&                              \
 281             !sigsetmasked(&(td)->td_siglist, &(td)->td_sigmask)) ||     \
 282          (!SIGISEMPTY((td)->td_proc->p_siglist) &&                      \
 283             !sigsetmasked(&(td)->td_proc->p_siglist, &(td)->td_sigmask)))
 284 /*
 285  * Return the value of the pseudo-expression ((*set & ~*mask) == 0).  This
 286  * is an optimized version of SIGISEMPTY() on a temporary variable
 287  * containing SIGSETNAND(*set, *mask).
 288  */
 289 static __inline bool
 290 sigsetmasked(sigset_t *set, sigset_t *mask)
 291 {
 292         int i;
 293
 294         for (i = 0; i < _SIG_WORDS; i++) {
 295                 if (set->__bits[i] & ~mask->__bits[i])
 296                         return (false);
 297         }
 298         return (true);
 299 }
 300
 301 #define ksiginfo_init(ksi)                      \
 302 do {                                            \
 303         bzero(ksi, sizeof(ksiginfo_t));         \
 304 } while(0)
 305
 306 #define ksiginfo_init_trap(ksi)                 \
 307 do {                                            \
 308         ksiginfo_t *kp = ksi;                   \
 309         bzero(kp, sizeof(ksiginfo_t));          \
 310         kp->ksi_flags |= KSI_TRAP;              \
 311 } while(0)
 312
 313 static __inline void
 314 ksiginfo_copy(ksiginfo_t *src, ksiginfo_t *dst)
 315 {
 316         (dst)->ksi_info = src->ksi_info;
 317         (dst)->ksi_flags = (src->ksi_flags & KSI_COPYMASK);
 318 }
 319
 320 static __inline void
 321 ksiginfo_set_sigev(ksiginfo_t *dst, struct sigevent *sigev)
 322 {
 323         dst->ksi_signo = sigev->sigev_signo;
 324         dst->ksi_value = sigev->sigev_value;
 325 }
 326
 327 struct pgrp;
 328 struct proc;
 329 struct sigio;
 330 struct thread;
 331
 332 /*
 333  * Lock the pointers for a sigio object in the underlying objects of
 334  * a file descriptor.
 335  */
 336 #define SIGIO_LOCK()    mtx_lock(&sigio_lock)
 337 #define SIGIO_TRYLOCK() mtx_trylock(&sigio_lock)
 338 #define SIGIO_UNLOCK()  mtx_unlock(&sigio_lock)
 339 #define SIGIO_LOCKED()  mtx_owned(&sigio_lock)
 340 #define SIGIO_ASSERT_LOCKED() mtx_assert(&sigio_lock, MA_OWNED)
 341
 342 extern struct mtx       sigio_lock;
 343
 344 /* Flags for kern_sigprocmask(). */
 345 #define SIGPROCMASK_OLD         0x0001
 346 #define SIGPROCMASK_PROC_LOCKED 0x0002
 347 #define SIGPROCMASK_PS_LOCKED   0x0004
 348 #define SIGPROCMASK_FASTBLK     0x0008
 349
 350 /*
 351  * Modes for sigdeferstop().  Manages behaviour of
 352  * thread_suspend_check() in the region delimited by
 353  * sigdeferstop()/sigallowstop().  Must be restored to
 354  * SIGDEFERSTOP_OFF before returning to userspace.
 355  */
 356 #define SIGDEFERSTOP_NOP        0 /* continue doing whatever is done now */
 357 #define SIGDEFERSTOP_OFF        1 /* stop ignoring STOPs */
 358 #define SIGDEFERSTOP_SILENT     2 /* silently ignore STOPs */
 359 #define SIGDEFERSTOP_EINTR      3 /* ignore STOPs, return EINTR */
 360 #define SIGDEFERSTOP_ERESTART   4 /* ignore STOPs, return ERESTART */
 361
 362 #define SIGDEFERSTOP_VAL_NCHG   (-1) /* placeholder indicating no state change */
 363 int     sigdeferstop_impl(int mode);
 364 void    sigallowstop_impl(int prev);
 365
 366 static inline int
 367 sigdeferstop(int mode)
 368 {
 369
 370         if (__predict_false(mode == SIGDEFERSTOP_NOP))
 371                 return (SIGDEFERSTOP_VAL_NCHG);
 372         return (sigdeferstop_impl(mode));
 373 }
 374
 375 static inline void
 376 sigallowstop(int prev)
 377 {
 378
 379         if (__predict_true(prev == SIGDEFERSTOP_VAL_NCHG))
 380                 return;
 381         sigallowstop_impl(prev);
 382 }
 383
 384 int     cursig(struct thread *td);
 385 void    execsigs(struct proc *p);
 386 void    gsignal(int pgid, int sig, ksiginfo_t *ksi);
 387 void    killproc(struct proc *p, const char *why);
 388 ksiginfo_t * ksiginfo_alloc(int wait);
 389 void    ksiginfo_free(ksiginfo_t *ksi);
 390 int     pksignal(struct proc *p, int sig, ksiginfo_t *ksi);
 391 void    pgsigio(struct sigio **sigiop, int sig, int checkctty);
 392 void    pgsignal(struct pgrp *pgrp, int sig, int checkctty, ksiginfo_t *ksi);
 393 int     postsig(int sig);
 394 void    kern_psignal(struct proc *p, int sig);
 395 int     ptracestop(struct thread *td, int sig, ksiginfo_t *si);
 396 void    sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *retmask);
 397 struct sigacts *sigacts_alloc(void);
 398 void    sigacts_copy(struct sigacts *dest, struct sigacts *src);
 399 void    sigacts_free(struct sigacts *ps);
 400 struct sigacts *sigacts_hold(struct sigacts *ps);
 401 int     sigacts_shared(struct sigacts *ps);
 402 int     sig_ast_checksusp(struct thread *td);
 403 int     sig_ast_needsigchk(struct thread *td);
 404 void    sig_drop_caught(struct proc *p);
 405 void    sigexit(struct thread *td, int sig) __dead2;
 406 int     sigev_findtd(struct proc *p, struct sigevent *sigev, struct thread **);
 407 int     sig_ffs(sigset_t *set);
 408 void    sigfastblock_clear(struct thread *td);
 409 void    sigfastblock_fetch(struct thread *td);
 410 void    sigfastblock_setpend(struct thread *td, bool resched);
 411 int     sig_intr(void);
 412 void    siginit(struct proc *p);
 413 void    signotify(struct thread *td);
 414 void    sigqueue_delete(struct sigqueue *queue, int sig);
 415 void    sigqueue_delete_proc(struct proc *p, int sig);
 416 void    sigqueue_flush(struct sigqueue *queue);
 417 void    sigqueue_init(struct sigqueue *queue, struct proc *p);
 418 void    sigqueue_take(ksiginfo_t *ksi);
 419 void    tdksignal(struct thread *td, int sig, ksiginfo_t *ksi);
 420 int     tdsendsignal(struct proc *p, struct thread *td, int sig,
 421            ksiginfo_t *ksi);
 422 void    tdsigcleanup(struct thread *td);
 423 void    tdsignal(struct thread *td, int sig);
 424 void    trapsignal(struct thread *td, ksiginfo_t *ksi);
 425
 426 #endif /* _KERNEL */
 427
 428 #endif /* !_SYS_SIGNALVAR_H_ */