winsup/cygwin/local_includes/sigproc.h

   1 /* sigproc.h
   2
   3 This file is part of Cygwin.
   4
   5 This software is a copyrighted work licensed under the terms of the
   6 Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
   7 details. */
   8
   9 #pragma once
  10 #include <signal.h>
  11 #include "sync.h"
  12
  13 #ifdef _NSIG
  14 enum
  15 {
  16   __SIGFLUSH        = -(_NSIG + 1),
  17   __SIGSTRACE       = -(_NSIG + 2),
  18   __SIGCOMMUNE      = -(_NSIG + 3),
  19   __SIGPENDING      = -(_NSIG + 4),
  20   __SIGDELETE       = -(_NSIG + 5),     /* Not currently used */
  21   __SIGFLUSHFAST    = -(_NSIG + 6),
  22   __SIGHOLD         = -(_NSIG + 7),
  23   __SIGNOHOLD       = -(_NSIG + 8),
  24   __SIGSETPGRP      = -(_NSIG + 9),
  25   __SIGTHREADEXIT   = -(_NSIG + 10),
  26   __SIGPENDINGALL   = -(_NSIG + 11),
  27 };
  28 #endif
  29
  30 #define SIG_BAD_MASK (1 << (SIGKILL - 1))
  31
  32 enum procstuff
  33 {
  34   PROC_ADD_CHILD          = 1,  // set up a new child
  35   PROC_ATTACH_CHILD       = 2,  // attach child or reattach after exec
  36   PROC_EXEC_CLEANUP       = 3,  // cleanup waiting children after exec
  37   PROC_CLEARWAIT          = 4,  // clear all waits - signal arrived
  38   PROC_WAIT               = 5,  // setup for wait() for subproc
  39   PROC_EXECING            = 6,  // used to get a lock when execing
  40   PROC_NOTHING            = 7   // nothing, really
  41 };
  42
  43 struct sigpacket
  44 {
  45   siginfo_t si;
  46   pid_t pid;
  47   class _cygtls *sigtls;
  48   sigset_t *mask;
  49   union
  50   {
  51     HANDLE wakeup;
  52     HANDLE thread_handle;
  53     struct sigpacket *next;
  54   };
  55   int process ();
  56   int setup_handler (void *, struct sigaction&, _cygtls *);
  57 };
  58
  59 void sig_dispatch_pending (bool fast = false);
  60 void set_signal_mask (sigset_t&, sigset_t);
  61 int handle_sigprocmask (int sig, const sigset_t *set,
  62                                   sigset_t *oldset, sigset_t& opmask);
  63
  64 void sig_clear (int);
  65 void sig_set_pending (int);
  66 int handle_sigsuspend (sigset_t);
  67
  68 int proc_subproc (DWORD, uintptr_t);
  69
  70 class _pinfo;
  71 void proc_terminate ();
  72 void sigproc_init ();
  73 bool pid_exists (pid_t);
  74 sigset_t sig_send (_pinfo *, siginfo_t&, class _cygtls * = NULL);
  75 sigset_t sig_send (_pinfo *, int, class _cygtls * = NULL);
  76 void signal_fixup_after_exec ();
  77 void sigalloc ();
  78
  79 int kill_pgrp (pid_t, siginfo_t&);
  80 void exit_thread (DWORD) __attribute__ ((noreturn));
  81 void setup_signal_exit (int);
  82 int sigwait_common (const sigset_t *, siginfo_t *, PLARGE_INTEGER);
  83
  84 class no_thread_exit_protect
  85 {
  86   static bool flag;
  87   bool modify;
  88 public:
  89   no_thread_exit_protect (int) {flag = true; modify = true;}
  90   ~no_thread_exit_protect ()
  91   {
  92     if (modify)
  93       flag = false;
  94   }
  95   no_thread_exit_protect () {modify = false;}
  96   operator int () {return flag;}
  97 };
  98
  99
 100 extern "C" void sigdelayed ();
 101
 102 extern char myself_nowait_dummy[];
 103
 104 extern struct sigaction *global_sigs;
 105
 106 class lock_signals
 107 {
 108   bool worked;
 109 public:
 110   lock_signals ()
 111   {
 112     worked = (bool) sig_send (NULL, __SIGHOLD) == 0;
 113   }
 114   operator int () const
 115   {
 116     return worked;
 117   }
 118   void dont_bother ()
 119   {
 120     worked = false;
 121   }
 122   ~lock_signals ()
 123   {
 124     if (worked)
 125       sig_send (NULL, __SIGNOHOLD);
 126   }
 127 };
 128
 129 class lock_pthread
 130 {
 131   bool bother;
 132 public:
 133   lock_pthread (): bother (1)
 134   {
 135     pthread::atforkprepare ();
 136   }
 137   void dont_bother ()
 138   {
 139     bother = false;
 140   }
 141   ~lock_pthread ()
 142   {
 143     if (bother)
 144       pthread::atforkparent ();
 145   }
 146 };
 147
 148 class hold_everything
 149 {
 150   bool& ischild;
 151   /* Note the order of the locks below.  It is important,
 152      to avoid races, that the lock order be preserved.
 153
 154      pthread is first because it serves as a master lock
 155      against other forks being attempted while this one is active.
 156
 157      signals is next to stop signal processing for the duration
 158      of the fork.
 159
 160      process is last.  If it is put before signals, then a deadlock
 161      could be introduced if the process attempts to exit due to a signal. */
 162   lock_pthread pthread;
 163   lock_signals signals;
 164   lock_process process;
 165
 166 public:
 167   hold_everything (bool& x): ischild (x) {}
 168   operator int () const {return signals;}
 169
 170   ~hold_everything()
 171   {
 172     if (ischild)
 173       {
 174         pthread.dont_bother ();
 175         process.dont_bother ();
 176         signals.dont_bother ();
 177       }
 178   }
 179
 180 };
 181
 182 #define myself_nowait ((_pinfo *) myself_nowait_dummy)