This manual page is part of the POSIX Programmer's Manual. The Linux implementation of this interface

       Normally,  at  the  beginning of a critical code section, a specified set of signals is blocked using the
       sigprocmask() function. When the thread has completed the critical section and  needs  to  wait  for  the
       previously  blocked  signal(s),  it pauses by calling sigsuspend() with the mask that was returned by the
       sigprocmask() call.

       Portions of this text are reprinted and reproduced in electronic form from IEEE Std 1003.1-2017, Standard
       for  Information  Technology  --  Portable  Operating  System  Interface  (POSIX),  The  Open  Group Base
       Specifications Issue 7, 2018 Edition, Copyright (C) 2018 by the Institute of Electrical  and  Electronics
       Engineers, Inc and The Open Group.  In the event of any discrepancy between this version and the original
       IEEE  and The Open Group Standard, the original IEEE and The Open Group Standard is the referee document.
       The original Standard can be obtained online at http://www.opengroup.org/unix/online.html .

       Any typographical or formatting errors that appear in this page are most likely to have  been  introduced
       during   the   conversion  of  the  source  files  to  man  page  format.  To  report  such  errors,  see
       https://www.kernel.org/doc/man-pages/reporting_bugs.html .

IEEE/The Open Group                                   2017                                    SIGSUSPEND(3POSIX)

       The  sigsuspend()  function  shall  replace the current signal mask of the calling thread with the set of
       signals pointed to by sigmask and then suspend the thread until delivery of  a  signal  whose  action  is
       either  to execute a signal-catching function or to terminate the process. This shall not cause any other
       signals that may have been pending on the process to become pending on the thread.

       If the action is to terminate the process then sigsuspend() shall never  return.  If  the  action  is  to
       execute  a  signal-catching  function,  then sigsuspend() shall return after the signal-catching function
       returns, with the signal mask restored to the set that existed prior to the sigsuspend() call.

       It is not possible to block signals that cannot be ignored.  This  is  enforced  by  the  system  without
       causing an error to be indicated.

       The sigsuspend() function shall fail if:

       EINTR  A signal is caught by the calling  process  and  control  is  returned  from  the  signal-catching
              function.

       Thefollowingsectionsareinformative.

       None.

       None.

       sigsuspend — wait for a signal

       This  manual  page  is part of the POSIX Programmer's Manual.  The Linux implementation of this interface
       may differ (consult the corresponding Linux manual page for details of Linux behavior), or the  interface
       may not be implemented on Linux.

       Code which wants to avoid the ambiguity of the signal mask for thread cancellation handlers  can  install
       an additional cancellation handler which resets the signal mask to the expected value.

           void cleanup(void *arg)
           {
               sigset_t *ss = (sigset_t *) arg;
               pthread_sigmask(SIG_SETMASK, ss, NULL);
           }

           int call_sigsuspend(const sigset_t *mask)
           {
               sigset_t oldmask;
               int result;
               pthread_sigmask(SIG_SETMASK, NULL, &oldmask);
               pthread_cleanup_push(cleanup, &oldmask);
               result = sigsuspend(sigmask);
               pthread_cleanup_pop(0);
               return result;
           }

       Since  sigsuspend()  suspends  thread  execution  indefinitely,  there is no successful completion return
       value. If a return occurs, -1 shall be returned and errno set to indicate the error.

Section2.4, SignalConcepts, pause(), sigaction(), sigaddset(), sigdelset(), sigemptyset(), sigfillset()

       The Base Definitions volume of POSIX.1‐2017, <signal.h>

       #include <signal.h>

       int sigsuspend(const sigset_t *sigmask);