gdbsupport/scoped_ignore_signal.h

   1 /* Support for ignoring signals.
   2
   3    Copyright (C) 2021-2023 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef SCOPED_IGNORE_SIGNAL_H
  21 #define SCOPED_IGNORE_SIGNAL_H
  22
  23 #include <signal.h>
  24
  25 /* RAII class used to ignore a signal in a scope.  If sigprocmask is
  26    supported, then the signal is only ignored by the calling thread.
  27    Otherwise, the signal disposition is set to SIG_IGN, which affects
  28    the whole process.  If ConsumePending is true, the destructor
  29    consumes a pending Sig.  SIGPIPE for example is queued on the
  30    thread even if blocked at the time the pipe is written to.  SIGTTOU
  31    OTOH is not raised at all if the thread writing to the terminal has
  32    it blocked.  Because SIGTTOU is sent to the whole process instead
  33    of to a specific thread, consuming a pending SIGTTOU in the
  34    destructor could consume a signal raised due to actions done by
  35    some other thread.  */
  36
  37 template <int Sig, bool ConsumePending>
  38 class scoped_ignore_signal
  39 {
  40 public:
  41   scoped_ignore_signal ()
  42   {
  43 #ifdef HAVE_SIGPROCMASK
  44     sigset_t set, old_state;
  45
  46     sigemptyset (&set);
  47     sigaddset (&set, Sig);
  48     sigprocmask (SIG_BLOCK, &set, &old_state);
  49     m_was_blocked = sigismember (&old_state, Sig);
  50 #else
  51     m_osig = signal (Sig, SIG_IGN);
  52 #endif
  53   }
  54
  55   ~scoped_ignore_signal ()
  56   {
  57 #ifdef HAVE_SIGPROCMASK
  58     if (!m_was_blocked)
  59       {
  60         sigset_t set;
  61
  62         sigemptyset (&set);
  63         sigaddset (&set, Sig);
  64
  65         /* If we got a pending Sig signal, consume it before
  66            unblocking.  */
  67         if (ConsumePending)
  68           {
  69 #ifdef HAVE_SIGTIMEDWAIT
  70             const timespec zero_timeout = {};
  71
  72             sigtimedwait (&set, nullptr, &zero_timeout);
  73 #else
  74             sigset_t pending;
  75
  76             sigpending (&pending);
  77             if (sigismember (&pending, Sig))
  78               {
  79                 int sig_found;
  80
  81                 sigwait (&set, &sig_found);
  82                 gdb_assert (sig_found == Sig);
  83               }
  84 #endif
  85           }
  86
  87         sigprocmask (SIG_UNBLOCK, &set, nullptr);
  88       }
  89 #else
  90     signal (Sig, m_osig);
  91 #endif
  92   }
  93
  94   DISABLE_COPY_AND_ASSIGN (scoped_ignore_signal);
  95
  96 private:
  97 #ifdef HAVE_SIGPROCMASK
  98   bool m_was_blocked;
  99 #else
 100   sighandler_t m_osig;
 101 #endif
 102 };
 103
 104 struct scoped_ignore_signal_nop
 105 {
 106   /* Note, these can't both be "= default", because otherwise the
 107      compiler warns that variables of this type are not used.  */
 108   scoped_ignore_signal_nop ()
 109   {}
 110   ~scoped_ignore_signal_nop ()
 111   {}
 112   DISABLE_COPY_AND_ASSIGN (scoped_ignore_signal_nop);
 113 };
 114
 115 #ifdef SIGPIPE
 116 using scoped_ignore_sigpipe = scoped_ignore_signal<SIGPIPE, true>;
 117 #else
 118 using scoped_ignore_sigpipe = scoped_ignore_signal_nop;
 119 #endif
 120
 121 #endif /* SCOPED_IGNORE_SIGNAL_H */