headers/posix/signal.h

   1 /*
   2  * Copyright 2002-2011, Haiku, Inc. All Rights Reserved.
   3  * Distributed under the terms of the MIT License.
   4  */
   5 #ifndef _SIGNAL_H_
   6 #define _SIGNAL_H_
   7
   8
   9 #include <sys/types.h>
  10
  11
  12 typedef int     sig_atomic_t;
  13 typedef __haiku_uint64 sigset_t;
  14
  15
  16 /* macros defining the standard signal handling behavior */
  17 #define SIG_DFL         ((__sighandler_t)0)             /* "default" signal behaviour */
  18 #define SIG_IGN         ((__sighandler_t)1)             /* ignore signal */
  19 #define SIG_ERR         ((__sighandler_t)-1)    /* an error occurred during signal
  20                                                                                            processing */
  21 #define SIG_HOLD        ((__sighandler_t)3)             /* the signal was hold */
  22
  23 /* macros specifying the event notification type (sigevent::sigev_notify) */
  24 #define SIGEV_NONE              0       /* no notification */
  25 #define SIGEV_SIGNAL    1       /* notify via queued signal */
  26 #define SIGEV_THREAD    2       /* notify via function called in new thread */
  27
  28
  29 union sigval {
  30         int             sival_int;
  31         void*   sival_ptr;
  32 };
  33
  34 struct sigevent {
  35         int                             sigev_notify;   /* notification type */
  36         int                             sigev_signo;    /* signal number */
  37         union sigval    sigev_value;    /* user-defined signal value */
  38         void                    (*sigev_notify_function)(union sigval);
  39                                                                         /* notification function in case of
  40                                                                            SIGEV_THREAD */
  41         pthread_attr_t* sigev_notify_attributes;
  42                                                                         /* pthread creation attributes in case of
  43                                                                            SIGEV_THREAD */
  44 };
  45
  46 typedef struct __siginfo_t {
  47         int                             si_signo;       /* signal number */
  48         int                             si_code;        /* signal code */
  49         int                             si_errno;       /* if non zero, an error number associated with
  50                                                                    this signal */
  51         pid_t                   si_pid;         /* sending process ID */
  52         uid_t                   si_uid;         /* real user ID of sending process */
  53         void*                   si_addr;        /* address of faulting instruction */
  54         int                             si_status;      /* exit value or signal */
  55         long                    si_band;        /* band event for SIGPOLL */
  56         union sigval    si_value;       /* signal value */
  57 } siginfo_t;
  58
  59
  60 /* signal handler function types */
  61 typedef void (*__sighandler_t)(int);
  62 typedef void  (*__siginfo_handler_t)(int, siginfo_t*, void*);
  63
  64 #ifdef __USE_GNU
  65 typedef __sighandler_t  sighandler_t;
  66         /* GNU-like signal handler typedef */
  67 #endif
  68
  69
  70 /* structure used by sigaction() */
  71 struct sigaction {
  72         union {
  73                 __sighandler_t          sa_handler;
  74                 __siginfo_handler_t     sa_sigaction;
  75         };
  76         sigset_t                                sa_mask;
  77         int                                             sa_flags;
  78         void*                                   sa_userdata;    /* will be passed to the signal
  79                                                                                            handler, BeOS extension */
  80 };
  81
  82 /* values for sa_flags */
  83 #define SA_NOCLDSTOP    0x01
  84 #define SA_NOCLDWAIT    0x02
  85 #define SA_RESETHAND    0x04
  86 #define SA_NODEFER              0x08
  87 #define SA_RESTART              0x10
  88 #define SA_ONSTACK              0x20
  89 #define SA_SIGINFO              0x40
  90 #define SA_NOMASK               SA_NODEFER
  91 #define SA_STACK                SA_ONSTACK
  92 #define SA_ONESHOT              SA_RESETHAND
  93
  94 /* values for ss_flags */
  95 #define SS_ONSTACK              0x1
  96 #define SS_DISABLE              0x2
  97
  98 #define MINSIGSTKSZ             8192
  99 #define SIGSTKSZ                16384
 100
 101 /* for signals using an alternate stack */
 102 typedef struct stack_t {
 103         void*   ss_sp;
 104         size_t  ss_size;
 105         int             ss_flags;
 106 } stack_t;
 107
 108 /* for the 'how' arg of sigprocmask() */
 109 #define SIG_BLOCK               1
 110 #define SIG_UNBLOCK             2
 111 #define SIG_SETMASK             3
 112
 113 /*
 114  * The list of all defined signals:
 115  *
 116  * The numbering of signals for Haiku attempts to maintain
 117  * some consistency with UN*X conventions so that things
 118  * like "kill -9" do what you expect.
 119  */
 120 #define SIGHUP                  1       /* hangup -- tty is gone! */
 121 #define SIGINT                  2       /* interrupt */
 122 #define SIGQUIT                 3       /* `quit' special character typed in tty  */
 123 #define SIGILL                  4       /* illegal instruction */
 124 #define SIGCHLD                 5       /* child process exited */
 125 #define SIGABRT                 6       /* abort() called, dont' catch */
 126 #define SIGPIPE                 7       /* write to a pipe w/no readers */
 127 #define SIGFPE                  8       /* floating point exception */
 128 #define SIGKILL                 9       /* kill a team (not catchable) */
 129 #define SIGSTOP                 10      /* suspend a thread (not catchable) */
 130 #define SIGSEGV                 11      /* segmentation violation (read: invalid pointer) */
 131 #define SIGCONT                 12      /* continue execution if suspended */
 132 #define SIGTSTP                 13      /* `stop' special character typed in tty */
 133 #define SIGALRM                 14      /* an alarm has gone off (see alarm()) */
 134 #define SIGTERM                 15      /* termination requested */
 135 #define SIGTTIN                 16      /* read of tty from bg process */
 136 #define SIGTTOU                 17      /* write to tty from bg process */
 137 #define SIGUSR1                 18      /* app defined signal 1 */
 138 #define SIGUSR2                 19      /* app defined signal 2 */
 139 #define SIGWINCH                20      /* tty window size changed */
 140 #define SIGKILLTHR              21      /* be specific: kill just the thread, not team */
 141 #define SIGTRAP                 22      /* Trace/breakpoint trap */
 142 #define SIGPOLL                 23      /* Pollable event */
 143 #define SIGPROF                 24      /* Profiling timer expired */
 144 #define SIGSYS                  25      /* Bad system call */
 145 #define SIGURG                  26      /* High bandwidth data is available at socket */
 146 #define SIGVTALRM               27      /* Virtual timer expired */
 147 #define SIGXCPU                 28      /* CPU time limit exceeded */
 148 #define SIGXFSZ                 29      /* File size limit exceeded */
 149 #define SIGBUS                  30      /* access to undefined portion of a memory object */
 150 #define SIGRESERVED1    31      /* reserved for future use */
 151 #define SIGRESERVED2    32      /* reserved for future use */
 152
 153 #define SIGRTMIN                (__signal_get_sigrtmin())
 154                                                         /* lowest realtime signal number */
 155 #define SIGRTMAX                (__signal_get_sigrtmax())
 156                                                         /* greatest realtime signal number */
 157
 158 #define __MAX_SIGNO             64      /* greatest possible signal number, can be used (+1)
 159                                                            as size of static arrays */
 160 #define NSIG                    (__MAX_SIGNO + 1)
 161                                                         /* BSD extension, size of the sys_siglist table,
 162                                                            obsolete */
 163
 164
 165 /* Signal code values appropriate for siginfo_t::si_code: */
 166 /* any signal */
 167 #define SI_USER                 0       /* signal sent by user */
 168 #define SI_QUEUE                1       /* signal sent by sigqueue() */
 169 #define SI_TIMER                2       /* signal sent on timer_settime() timeout */
 170 #define SI_ASYNCIO              3       /* signal sent on asynchronous I/O completion */
 171 #define SI_MESGQ                4       /* signal sent on arrival of message on empty
 172                                                            message queue */
 173 /* SIGILL */
 174 #define ILL_ILLOPC              10      /* illegal opcode */
 175 #define ILL_ILLOPN              11      /* illegal operand */
 176 #define ILL_ILLADR              12      /* illegal addressing mode */
 177 #define ILL_ILLTRP              13      /* illegal trap */
 178 #define ILL_PRVOPC              14      /* privileged opcode */
 179 #define ILL_PRVREG              15      /* privileged register */
 180 #define ILL_COPROC              16      /* coprocessor error */
 181 #define ILL_BADSTK              17      /* internal stack error */
 182 /* SIGFPE */
 183 #define FPE_INTDIV              20      /* integer division by zero */
 184 #define FPE_INTOVF              21      /* integer overflow */
 185 #define FPE_FLTDIV              22      /* floating-point division by zero */
 186 #define FPE_FLTOVF              23      /* floating-point overflow */
 187 #define FPE_FLTUND              24      /* floating-point underflow */
 188 #define FPE_FLTRES              25      /* floating-point inexact result */
 189 #define FPE_FLTINV              26      /* invalid floating-point operation */
 190 #define FPE_FLTSUB              27      /* subscript out of range */
 191 /* SIGSEGV */
 192 #define SEGV_MAPERR             30      /* address not mapped to object */
 193 #define SEGV_ACCERR             31      /* invalid permissions for mapped object */
 194 /* SIGBUS */
 195 #define BUS_ADRALN              40      /* invalid address alignment */
 196 #define BUS_ADRERR              41      /* nonexistent physical address */
 197 #define BUS_OBJERR              42      /* object-specific hardware error */
 198 /* SIGTRAP */
 199 #define TRAP_BRKPT              50      /* process breakpoint */
 200 #define TRAP_TRACE              51      /* process trace trap. */
 201 /* SIGCHLD */
 202 #define CLD_EXITED              60      /* child exited */
 203 #define CLD_KILLED              61      /* child terminated abnormally without core dump */
 204 #define CLD_DUMPED              62      /* child terminated abnormally with core dump */
 205 #define CLD_TRAPPED             63      /* traced child trapped */
 206 #define CLD_STOPPED             64      /* child stopped */
 207 #define CLD_CONTINUED   65      /* stopped child continued */
 208 /* SIGPOLL */
 209 #define POLL_IN                 70      /* input available */
 210 #define POLL_OUT                71      /* output available */
 211 #define POLL_MSG                72      /* input message available */
 212 #define POLL_ERR                73      /* I/O error */
 213 #define POLL_PRI                74      /* high priority input available */
 214 #define POLL_HUP                75      /* device disconnected */
 215
 216
 217 /* the global table of text strings containing descriptions for each signal */
 218 extern const char* const sys_siglist[NSIG];
 219         /* BSD extension, obsolete, use strsignal() instead */
 220
 221
 222 #ifdef __cplusplus
 223 extern "C" {
 224 #endif
 225
 226
 227 /* signal management (actions and block masks) */
 228 __sighandler_t signal(int _signal, __sighandler_t signalHandler);
 229 int     sigaction(int _signal, const struct sigaction* action,
 230                         struct sigaction* oldAction);
 231 __sighandler_t sigset(int _signal, __sighandler_t signalHandler);
 232 int             sigignore(int _signal);
 233 int             siginterrupt(int _signal, int flag);
 234
 235 int     sigprocmask(int how, const sigset_t* set, sigset_t* oldSet);
 236 int             pthread_sigmask(int how, const sigset_t* set, sigset_t* oldSet);
 237 int             sighold(int _signal);
 238 int             sigrelse(int _signal);
 239
 240 /* sending signals */
 241 int     raise(int _signal);
 242 int     kill(pid_t pid, int _signal);
 243 int             killpg(pid_t processGroupID, int _signal);
 244 int             sigqueue(pid_t pid, int _signal, const union sigval userValue);
 245 int             pthread_kill(pthread_t thread, int _signal);
 246
 247 /* querying and waiting for signals */
 248 int     sigpending(sigset_t* set);
 249 int     sigsuspend(const sigset_t* mask);
 250 int             sigpause(int _signal);
 251 int     sigwait(const sigset_t* set, int* _signal);
 252 int             sigwaitinfo(const sigset_t* set, siginfo_t* info);
 253 int             sigtimedwait(const sigset_t* set, siginfo_t* info,
 254            const struct timespec* timeout);
 255
 256 /* setting the per-thread signal stack */
 257 int             sigaltstack(const stack_t* stack, stack_t* oldStack);
 258
 259 /* signal set (sigset_t) manipulation */
 260 int     sigemptyset(sigset_t* set);
 261 int     sigfillset(sigset_t* set);
 262 int     sigaddset(sigset_t* set, int _signal);
 263 int     sigdelset(sigset_t* set, int _signal);
 264 int     sigismember(const sigset_t* set, int _signal);
 265
 266 /* printing signal names */
 267 void    psiginfo(const siginfo_t* info, const char* message);
 268 void    psignal(int _signal, const char* message);
 269
 270 /* implementation private */
 271 int             __signal_get_sigrtmin();
 272 int             __signal_get_sigrtmax();
 273
 274
 275 #ifdef __cplusplus
 276 }
 277 #endif
 278
 279
 280 /* TODO: move this into the documentation!
 281  * ==================================================
 282  * !!! SPECIAL NOTES CONCERNING NON-POSIX EXTENSIONS:
 283  * ==================================================
 284  *
 285  * The standard Posix interface for signal handlers is not as useful
 286  * as it could be. The handler can define only one single argument
 287  * (the signal number). For example:
 288  *    void
 289  *    my_signal_handler(int sig)
 290  *    {
 291  *    . . .
 292  *    }
 293  *
 294  *    // install the handler
 295  *    signal(SIGINT, &my_signal_handler);
 296  *
 297  * The sigaction() function allows finer grained control of the signal
 298  * handling. It also allows an opportunity, via the 'sigaction' struct, to
 299  * enable additional data to be passed to the handler. For example:
 300  *    void
 301  *    my_signal_handler(int sig, char* userData, vregs* regs)
 302  *    {
 303  *    . . .
 304  *    }
 305  *
 306  *    struct sigaction sa;
 307  *    char data_buffer[32];
 308  *
 309  *    sa.sa_handler = (__sighandler_t)my_signal_handler;
 310  *    sigemptyset(&sa.sa_mask);
 311  *    sa.sa_userdata = userData;
 312  *
 313  *    // install the handler
 314  *    sigaction(SIGINT, &sa, NULL);
 315  *
 316  * The two additional arguments available to the signal handler are extensions
 317  * to the Posix standard. This feature was introduced by the BeOS and retained
 318  * by Haiku. However, to remain compatible with Posix and ANSI C, the type
 319  * of the sa_handler field is defined as '__sighandler_t'. This requires the
 320  * handler to be cast when assigned to the sa_handler field, as in the example
 321  * above.
 322  *
 323  * The 3 arguments that Haiku provides to signal handlers are as follows:
 324  * 1) The first argument is the (usual) signal number.
 325  *
 326  * 2) The second argument is whatever value is put in the sa_userdata field
 327  *    of the sigaction struct.
 328  *
 329  * 3) The third argument is a pointer to a vregs struct (defined below).
 330  *    The vregs struct contains the contents of the volatile registers at
 331  *    the time the signal was delivered to your thread. You can change the
 332  *    fields of the structure. After your signal handler completes, the OS uses
 333  *    this struct to reload the registers for your thread (privileged registers
 334  *    are not loaded of course). The vregs struct is of course terribly machine
 335  *    dependent.
 336  *    Note that in BeOS the vregs argument was passed by value, not by pointer.
 337  *    While Haiku retains binary compability with code compiled for BeOS, code
 338  *    built under Haiku must use the pointer argument.
 339  */
 340
 341 /*
 342  * the vregs struct:
 343  *
 344  * signal handlers get this as the last argument
 345  */
 346 typedef struct vregs vregs;
 347         /* BeOS extension */
 348
 349
 350 /* include architecture specific definitions */
 351 #include __HAIKU_ARCH_HEADER(signal.h)
 352
 353
 354 typedef struct vregs mcontext_t;
 355
 356 typedef struct __ucontext_t {
 357         struct __ucontext_t*    uc_link;
 358         sigset_t                                uc_sigmask;
 359         stack_t                                 uc_stack;
 360         mcontext_t                              uc_mcontext;
 361 } ucontext_t;
 362
 363
 364 #endif /* _SIGNAL_H_ */