LCOV - code coverage report
Current view: top level - lkbce/include/linux - signal.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2 2 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : #ifndef _LINUX_SIGNAL_H
       2             : #define _LINUX_SIGNAL_H
       3             : 
       4             : #include <asm/signal.h>
       5             : #include <asm/siginfo.h>
       6             : 
       7             : #ifdef __KERNEL__
       8             : #include <linux/list.h>
       9             : 
      10             : /*
      11             :  * Real Time signals may be queued.
      12             :  */
      13             : 
      14             : struct sigqueue {
      15             :         struct list_head list;
      16             :         int flags;
      17             :         siginfo_t info;
      18             :         struct user_struct *user;
      19             : };
      20           1 : 
      21             : /* flags values. */
      22             : #define SIGQUEUE_PREALLOC       1
      23             : 
      24             : struct sigpending {
      25             :         struct list_head list;
      26             :         sigset_t signal;
      27             : };
      28             : 
      29             : /*
      30             :  * Define some primitives to manipulate sigset_t.
      31             :  */
      32             : 
      33             : #ifndef __HAVE_ARCH_SIG_BITOPS
      34             : #include <linux/bitops.h>
      35             : 
      36             : /* We don't use <linux/bitops.h> for these because there is no need to
      37             :    be atomic.  */
      38             : static inline void sigaddset(sigset_t *set, int _sig)
      39             : {
      40             :         unsigned long sig = _sig - 1;
      41             :         if (_NSIG_WORDS == 1)
      42             :                 set->sig[0] |= 1UL << sig;
      43             :         else
      44             :                 set->sig[sig / _NSIG_BPW] |= 1UL << (sig % _NSIG_BPW);
      45             : }
      46             : 
      47             : static inline void sigdelset(sigset_t *set, int _sig)
      48             : {
      49             :         unsigned long sig = _sig - 1;
      50             :         if (_NSIG_WORDS == 1)
      51             :                 set->sig[0] &= ~(1UL << sig);
      52             :         else
      53             :                 set->sig[sig / _NSIG_BPW] &= ~(1UL << (sig % _NSIG_BPW));
      54             : }
      55             : 
      56             : static inline int sigismember(sigset_t *set, int _sig)
      57             : {
      58             :         unsigned long sig = _sig - 1;
      59             :         if (_NSIG_WORDS == 1)
      60             :                 return 1 & (set->sig[0] >> sig);
      61             :         else
      62             :                 return 1 & (set->sig[sig / _NSIG_BPW] >> (sig % _NSIG_BPW));
      63             : }
      64             : 
      65             : static inline int sigfindinword(unsigned long word)
      66             : {
      67             :         return ffz(~word);
      68             : }
      69             : 
      70             : #endif /* __HAVE_ARCH_SIG_BITOPS */
      71             : 
      72             : static inline int sigisemptyset(sigset_t *set)
      73             : {
      74             :         extern void _NSIG_WORDS_is_unsupported_size(void);
      75             :         switch (_NSIG_WORDS) {
      76             :         case 4:
      77             :                 return (set->sig[3] | set->sig[2] |
      78             :                         set->sig[1] | set->sig[0]) == 0;
      79             :         case 2:
      80             :                 return (set->sig[1] | set->sig[0]) == 0;
      81             :         case 1:
      82             :                 return set->sig[0] == 0;
      83             :         default:
      84             :                 _NSIG_WORDS_is_unsupported_size();
      85             :                 return 0;
      86             :         }
      87             : }
      88             : 
      89             : #define sigmask(sig)    (1UL << ((sig) - 1))
      90             : 
      91             : #ifndef __HAVE_ARCH_SIG_SETOPS
      92             : #include <linux/string.h>
      93             : 
      94             : #define _SIG_SET_BINOP(name, op)                                        \
      95             : static inline void name(sigset_t *r, const sigset_t *a, const sigset_t *b) \
      96             : {                                                                       \
      97             :         extern void _NSIG_WORDS_is_unsupported_size(void);              \
      98             :         unsigned long a0, a1, a2, a3, b0, b1, b2, b3;                   \
      99             :                                                                         \
     100             :         switch (_NSIG_WORDS) {                                          \
     101             :             case 4:                                                     \
     102             :                 a3 = a->sig[3]; a2 = a->sig[2];                           \
     103             :                 b3 = b->sig[3]; b2 = b->sig[2];                           \
     104             :                 r->sig[3] = op(a3, b3);                                      \
     105             :                 r->sig[2] = op(a2, b2);                                      \
     106             :             case 2:                                                     \
     107             :                 a1 = a->sig[1]; b1 = b->sig[1];                           \
     108             :                 r->sig[1] = op(a1, b1);                                      \
     109             :             case 1:                                                     \
     110             :                 a0 = a->sig[0]; b0 = b->sig[0];                           \
     111             :                 r->sig[0] = op(a0, b0);                                      \
     112             :                 break;                                                  \
     113             :             default:                                                    \
     114             :                 _NSIG_WORDS_is_unsupported_size();                      \
     115             :         }                                                               \
     116             : }
     117             : 
     118             : #define _sig_or(x,y)    ((x) | (y))
     119             : _SIG_SET_BINOP(sigorsets, _sig_or)
     120             : 
     121             : #define _sig_and(x,y)   ((x) & (y))
     122             : _SIG_SET_BINOP(sigandsets, _sig_and)
     123             : 
     124             : #define _sig_nand(x,y)  ((x) & ~(y))
     125             : _SIG_SET_BINOP(signandsets, _sig_nand)
     126             : 
     127             : #undef _SIG_SET_BINOP
     128             : #undef _sig_or
     129             : #undef _sig_and
     130             : #undef _sig_nand
     131             : 
     132             : #define _SIG_SET_OP(name, op)                                           \
     133             : static inline void name(sigset_t *set)                                  \
     134             : {                                                                       \
     135             :         extern void _NSIG_WORDS_is_unsupported_size(void);              \
     136             :                                                                         \
     137             :         switch (_NSIG_WORDS) {                                          \
     138             :             case 4: set->sig[3] = op(set->sig[3]);                        \
     139             :                     set->sig[2] = op(set->sig[2]);                        \
     140             :             case 2: set->sig[1] = op(set->sig[1]);                        \
     141             :             case 1: set->sig[0] = op(set->sig[0]);                        \
     142             :                     break;                                              \
     143             :             default:                                                    \
     144             :                 _NSIG_WORDS_is_unsupported_size();                      \
     145             :         }                                                               \
     146             : }
     147             : 
     148             : #define _sig_not(x)     (~(x))
     149             : _SIG_SET_OP(signotset, _sig_not)
     150             : 
     151             : #undef _SIG_SET_OP
     152             : #undef _sig_not
     153             : 
     154             : static inline void sigemptyset(sigset_t *set)
     155             : {
     156             :         switch (_NSIG_WORDS) {
     157             :         default:
     158             :                 memset(set, 0, sizeof(sigset_t));
     159             :                 break;
     160             :         case 2: set->sig[1] = 0;
     161             :         case 1: set->sig[0] = 0;
     162             :                 break;
     163             :         }
     164             : }
     165             : 
     166             : static inline void sigfillset(sigset_t *set)
     167             : {
     168             :         switch (_NSIG_WORDS) {
     169             :         default:
     170             :                 memset(set, -1, sizeof(sigset_t));
     171             :                 break;
     172             :         case 2: set->sig[1] = -1;
     173             :         case 1: set->sig[0] = -1;
     174             :                 break;
     175             :         }
     176             : }
     177             : 
     178             : /* Some extensions for manipulating the low 32 signals in particular.  */
     179             : 
     180             : static inline void sigaddsetmask(sigset_t *set, unsigned long mask)
     181             : {
     182             :         set->sig[0] |= mask;
     183             : }
     184             : 
     185             : static inline void sigdelsetmask(sigset_t *set, unsigned long mask)
     186             : {
     187             :         set->sig[0] &= ~mask;
     188             : }
     189             : 
     190             : static inline int sigtestsetmask(sigset_t *set, unsigned long mask)
     191             : {
     192             :         return (set->sig[0] & mask) != 0;
     193             : }
     194             : 
     195             : static inline void siginitset(sigset_t *set, unsigned long mask)
     196             : {
     197             :         set->sig[0] = mask;
     198             :         switch (_NSIG_WORDS) {
     199             :         default:
     200             :                 memset(&set->sig[1], 0, sizeof(long)*(_NSIG_WORDS-1));
     201             :                 break;
     202             :         case 2: set->sig[1] = 0;
     203             :         case 1: ;
     204             :         }
     205             : }
     206             : 
     207             : static inline void siginitsetinv(sigset_t *set, unsigned long mask)
     208             : {
     209             :         set->sig[0] = ~mask;
     210             :         switch (_NSIG_WORDS) {
     211             :         default:
     212             :                 memset(&set->sig[1], -1, sizeof(long)*(_NSIG_WORDS-1));
     213             :                 break;
     214             :         case 2: set->sig[1] = -1;
     215             :         case 1: ;
     216             :         }
     217             : }
     218             : 
     219             : #endif /* __HAVE_ARCH_SIG_SETOPS */
     220             : 
     221             : static inline void init_sigpending(struct sigpending *sig)
     222             : {
     223             :         sigemptyset(&sig->signal);
     224             :         INIT_LIST_HEAD(&sig->list);
     225             : }
     226             : 
     227             : extern void flush_sigqueue(struct sigpending *queue);
     228             : 
     229             : /* Test if 'sig' is valid signal. Use this instead of testing _NSIG directly */
     230             : static inline int valid_signal(unsigned long sig)
     231             : {
     232             :         return sig <= _NSIG ? 1 : 0;
     233             : }
     234             : 
     235             : extern int next_signal(struct sigpending *pending, sigset_t *mask);
     236             : extern int do_send_sig_info(int sig, struct siginfo *info,
     237             :                                 struct task_struct *p, bool group);
     238             : extern int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p);
     239             : extern int __group_send_sig_info(int, struct siginfo *, struct task_struct *);
     240             : extern long do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig,
     241             :                                  siginfo_t *info);
     242             : extern long do_sigpending(void __user *, unsigned long);
     243             : extern int sigprocmask(int, sigset_t *, sigset_t *);
     244             : extern int show_unhandled_signals;
     245             : 
     246             : struct pt_regs;
     247             : extern int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka, struct pt_regs *regs, void *cookie);
     248             : extern void exit_signals(struct task_struct *tsk);
     249             : 
     250             : extern struct kmem_cache *sighand_cachep;
     251             : 
     252             : int unhandled_signal(struct task_struct *tsk, int sig);
     253             : 
     254             : /*
     255             :  * In POSIX a signal is sent either to a specific thread (Linux task)
     256             :  * or to the process as a whole (Linux thread group).  How the signal
     257             :  * is sent determines whether it's to one thread or the whole group,
     258             :  * which determines which signal mask(s) are involved in blocking it
     259             :  * from being delivered until later.  When the signal is delivered,
     260             :  * either it's caught or ignored by a user handler or it has a default
     261             :  * effect that applies to the whole thread group (POSIX process).
     262             :  *
     263             :  * The possible effects an unblocked signal set to SIG_DFL can have are:
     264             :  *   ignore     - Nothing Happens
     265             :  *   terminate  - kill the process, i.e. all threads in the group,
     266             :  *                similar to exit_group.  The group leader (only) reports
     267             :  *                WIFSIGNALED status to its parent.
     268             :  *   coredump   - write a core dump file describing all threads using
     269             :  *                the same mm and then kill all those threads
     270             :  *   stop       - stop all the threads in the group, i.e. TASK_STOPPED state
     271             :  *
     272             :  * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
     273             :  * Other signals when not blocked and set to SIG_DFL behaves as follows.
     274             :  * The job control signals also have other special effects.
     275             :  *
     276             :  *      +--------------------+------------------+
     277             :  *      |  POSIX signal      |  default action  |
     278             :  *      +--------------------+------------------+
     279             :  *      |  SIGHUP            |  terminate       |
     280             :  *      |  SIGINT            |  terminate       |
     281             :  *      |  SIGQUIT           |  coredump        |
     282             :  *      |  SIGILL            |  coredump        |
     283             :  *      |  SIGTRAP           |  coredump        |
     284             :  *      |  SIGABRT/SIGIOT    |  coredump        |
     285             :  *      |  SIGBUS            |  coredump        |
     286             :  *      |  SIGFPE            |  coredump        |
     287             :  *      |  SIGKILL           |  terminate(+)    |
     288             :  *      |  SIGUSR1           |  terminate       |
     289             :  *      |  SIGSEGV           |  coredump        |
     290             :  *      |  SIGUSR2           |  terminate       |
     291             :  *      |  SIGPIPE           |  terminate       |
     292             :  *      |  SIGALRM           |  terminate       |
     293             :  *      |  SIGTERM           |  terminate       |
     294             :  *      |  SIGCHLD           |  ignore          |
     295             :  *      |  SIGCONT           |  ignore(*)       |
     296             :  *      |  SIGSTOP           |  stop(*)(+)      |
     297             :  *      |  SIGTSTP           |  stop(*)         |
     298             :  *      |  SIGTTIN           |  stop(*)         |
     299             :  *      |  SIGTTOU           |  stop(*)         |
     300             :  *      |  SIGURG            |  ignore          |
     301             :  *      |  SIGXCPU           |  coredump        |
     302             :  *      |  SIGXFSZ           |  coredump        |
     303             :  *      |  SIGVTALRM         |  terminate       |
     304             :  *      |  SIGPROF           |  terminate       |
     305             :  *      |  SIGPOLL/SIGIO     |  terminate       |
     306             :  *      |  SIGSYS/SIGUNUSED  |  coredump        |
     307             :  *      |  SIGSTKFLT         |  terminate       |
     308             :  *      |  SIGWINCH          |  ignore          |
     309             :  *      |  SIGPWR            |  terminate       |
     310             :  *      |  SIGRTMIN-SIGRTMAX |  terminate       |
     311             :  *      +--------------------+------------------+
     312             :  *      |  non-POSIX signal  |  default action  |
     313             :  *      +--------------------+------------------+
     314             :  *      |  SIGEMT            |  coredump        |
     315             :  *      +--------------------+------------------+
     316             :  *
     317             :  * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
     318             :  * (*) Special job control effects:
     319             :  * When SIGCONT is sent, it resumes the process (all threads in the group)
     320             :  * from TASK_STOPPED state and also clears any pending/queued stop signals
     321             :  * (any of those marked with "stop(*)").  This happens regardless of blocking,
     322             :  * catching, or ignoring SIGCONT.  When any stop signal is sent, it clears
     323             :  * any pending/queued SIGCONT signals; this happens regardless of blocking,
     324             :  * catching, or ignored the stop signal, though (except for SIGSTOP) the
     325             :  * default action of stopping the process may happen later or never.
     326             :  */
     327             : 
     328             : #ifdef SIGEMT
     329             : #define SIGEMT_MASK     rt_sigmask(SIGEMT)
     330             : #else
     331             : #define SIGEMT_MASK     0
     332             : #endif
     333             : 
     334             : #if SIGRTMIN > BITS_PER_LONG
     335             : #define rt_sigmask(sig) (1ULL << ((sig)-1))
     336             : #else
     337             : #define rt_sigmask(sig) sigmask(sig)
     338             : #endif
     339             : #define siginmask(sig, mask) (rt_sigmask(sig) & (mask))
     340             : 
     341             : #define SIG_KERNEL_ONLY_MASK (\
     342             :         rt_sigmask(SIGKILL)   |  rt_sigmask(SIGSTOP))
     343             : 
     344             : #define SIG_KERNEL_STOP_MASK (\
     345             :         rt_sigmask(SIGSTOP)   |  rt_sigmask(SIGTSTP)   | \
     346             :         rt_sigmask(SIGTTIN)   |  rt_sigmask(SIGTTOU)   )
     347             : 
     348             : #define SIG_KERNEL_COREDUMP_MASK (\
     349             :         rt_sigmask(SIGQUIT)   |  rt_sigmask(SIGILL)    | \
     350             :         rt_sigmask(SIGTRAP)   |  rt_sigmask(SIGABRT)   | \
     351             :         rt_sigmask(SIGFPE)    |  rt_sigmask(SIGSEGV)   | \
     352             :         rt_sigmask(SIGBUS)    |  rt_sigmask(SIGSYS)    | \
     353             :         rt_sigmask(SIGXCPU)   |  rt_sigmask(SIGXFSZ)   | \
     354             :         SIGEMT_MASK                                    )
     355             : 
     356             : #define SIG_KERNEL_IGNORE_MASK (\
     357             :         rt_sigmask(SIGCONT)   |  rt_sigmask(SIGCHLD)   | \
     358             :         rt_sigmask(SIGWINCH)  |  rt_sigmask(SIGURG)    )
     359             : 
     360             : #define sig_kernel_only(sig) \
     361             :         (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_ONLY_MASK))
     362             : #define sig_kernel_coredump(sig) \
     363             :         (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_COREDUMP_MASK))
     364             : #define sig_kernel_ignore(sig) \
     365             :         (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_IGNORE_MASK))
     366             : #define sig_kernel_stop(sig) \
     367             :         (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_STOP_MASK))
     368             : 
     369             : #define sig_user_defined(t, signr) \
     370             :         (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) &&    \
     371             :          ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
     372             : 
     373             : #define sig_fatal(t, signr) \
     374             :         (!siginmask(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
     375             :          (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
     376             : 
     377             : void signals_init(void);
     378           1 : 
     379             : #endif /* __KERNEL__ */
     380             : 
     381             : #endif /* _LINUX_SIGNAL_H */

Generated by: LCOV version 1.10