LCOV - code coverage report
Current view: | top level - Modules - signalmodule.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 155 | 528 | 29.4 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 16 | 53 | 30.2 %
|  |  | Branches: | 97 | 352 | 27.6 %

               Branch data     Line data    Source code
           1                 :            :
           2                 :            : /* Signal module -- many thanks to Lance Ellinghaus */
           3                 :            :
           4                 :            : /* XXX Signals should be recorded per thread, now we have thread state. */
           5                 :            :
           6                 :            : #include "Python.h"
           7                 :            : #include "pycore_atomic.h"        // _Py_atomic_int
           8                 :            : #include "pycore_call.h"          // _PyObject_Call()
           9                 :            : #include "pycore_ceval.h"         // _PyEval_SignalReceived()
          10                 :            : #include "pycore_emscripten_signal.h"  // _Py_CHECK_EMSCRIPTEN_SIGNALS
          11                 :            : #include "pycore_fileutils.h"     // _Py_BEGIN_SUPPRESS_IPH
          12                 :            : #include "pycore_frame.h"         // _PyInterpreterFrame
          13                 :            : #include "pycore_moduleobject.h"  // _PyModule_GetState()
          14                 :            : #include "pycore_pyerrors.h"      // _PyErr_SetString()
          15                 :            : #include "pycore_pystate.h"       // _PyThreadState_GET()
          16                 :            : #include "pycore_signal.h"        // Py_NSIG
          17                 :            :
          18                 :            : #ifndef MS_WINDOWS
          19                 :            : #  include "posixmodule.h"
          20                 :            : #endif
          21                 :            : #ifdef MS_WINDOWS
          22                 :            : #  include "socketmodule.h"   /* needed for SOCKET_T */
          23                 :            : #endif
          24                 :            :
          25                 :            : #ifdef MS_WINDOWS
          26                 :            : #  ifdef HAVE_PROCESS_H
          27                 :            : #    include <process.h>
          28                 :            : #  endif
          29                 :            : #endif
          30                 :            :
          31                 :            : #ifdef HAVE_SIGNAL_H
          32                 :            : #  include <signal.h>
          33                 :            : #endif
          34                 :            : #ifdef HAVE_SYS_SYSCALL_H
          35                 :            : #  include <sys/syscall.h>
          36                 :            : #endif
          37                 :            : #ifdef HAVE_SYS_STAT_H
          38                 :            : #  include <sys/stat.h>
          39                 :            : #endif
          40                 :            : #ifdef HAVE_SYS_TIME_H
          41                 :            : #  include <sys/time.h>
          42                 :            : #endif
          43                 :            :
          44                 :            : #if defined(HAVE_PTHREAD_SIGMASK) && !defined(HAVE_BROKEN_PTHREAD_SIGMASK)
          45                 :            : #  define PYPTHREAD_SIGMASK
          46                 :            : #endif
          47                 :            :
          48                 :            : #if defined(PYPTHREAD_SIGMASK) && defined(HAVE_PTHREAD_H)
          49                 :            : #  include <pthread.h>
          50                 :            : #endif
          51                 :            :
          52                 :            : #ifndef SIG_ERR
          53                 :            : #  define SIG_ERR ((PyOS_sighandler_t)(-1))
          54                 :            : #endif
          55                 :            :
          56                 :            : #include "clinic/signalmodule.c.h"
          57                 :            :
          58                 :            : /*[clinic input]
          59                 :            : module signal
          60                 :            : [clinic start generated code]*/
          61                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=b0301a3bde5fe9d3]*/
          62                 :            :
          63                 :            : #ifdef HAVE_SETSIG_T
          64                 :            :
          65                 :            : /*[python input]
          66                 :            :
          67                 :            : class sigset_t_converter(CConverter):
          68                 :            :     type = 'sigset_t'
          69                 :            :     converter = '_Py_Sigset_Converter'
          70                 :            :
          71                 :            : [python start generated code]*/
          72                 :            : /*[python end generated code: output=da39a3ee5e6b4b0d input=b5689d14466b6823]*/
          73                 :            : #endif
          74                 :            :
          75                 :            : /*
          76                 :            :    NOTES ON THE INTERACTION BETWEEN SIGNALS AND THREADS
          77                 :            :
          78                 :            :    We want the following semantics:
          79                 :            :
          80                 :            :    - only the main thread can set a signal handler
          81                 :            :    - only the main thread runs the signal handler
          82                 :            :    - signals can be delivered to any thread
          83                 :            :    - any thread can get a signal handler
          84                 :            :
          85                 :            :    I.e. we don't support "synchronous signals" like SIGFPE (catching
          86                 :            :    this doesn't make much sense in Python anyway) nor do we support
          87                 :            :    signals as a means of inter-thread communication, since not all
          88                 :            :    thread implementations support that (at least our thread library
          89                 :            :    doesn't).
          90                 :            :
          91                 :            :    We still have the problem that in some implementations signals
          92                 :            :    generated by the keyboard (e.g. SIGINT) are delivered to all
          93                 :            :    threads (e.g. SGI), while in others (e.g. Solaris) such signals are
          94                 :            :    delivered to one random thread. On Linux, signals are delivered to
          95                 :            :    the main thread (unless the main thread is blocking the signal, for
          96                 :            :    example because it's already handling the same signal).  Since we
          97                 :            :    allow signals to be delivered to any thread, this works fine. The
          98                 :            :    only oddity is that the thread executing the Python signal handler
          99                 :            :    may not be the thread that received the signal.
         100                 :            : */
         101                 :            :
         102                 :            : #define Handlers _PyRuntime.signals.handlers
         103                 :            : #define wakeup _PyRuntime.signals.wakeup
         104                 :            : #define is_tripped _PyRuntime.signals.is_tripped
         105                 :            :
         106                 :            : // State shared by all Python interpreters
         107                 :            : typedef struct _signals_runtime_state signal_state_t;
         108                 :            : #define signal_global_state _PyRuntime.signals
         109                 :            :
         110                 :            : #if defined(HAVE_GETITIMER) || defined(HAVE_SETITIMER)
         111                 :            : #  define PYHAVE_ITIMER_ERROR
         112                 :            : #endif
         113                 :            :
         114                 :            : typedef struct {
         115                 :            :     PyObject *default_handler;  // borrowed ref (signal_global_state)
         116                 :            :     PyObject *ignore_handler;  // borrowed ref (signal_global_state)
         117                 :            : #ifdef PYHAVE_ITIMER_ERROR
         118                 :            :     PyObject *itimer_error;
         119                 :            : #endif
         120                 :            :     PyTypeObject *siginfo_type;
         121                 :            : } _signal_module_state;
         122                 :            :
         123                 :            :
         124                 :            : Py_LOCAL_INLINE(PyObject *)
         125                 :       1925 : get_handler(int i)
         126                 :            : {
         127                 :       1925 :     return (PyObject *)_Py_atomic_load(&Handlers[i].func);
         128                 :            : }
         129                 :            :
         130                 :            : Py_LOCAL_INLINE(void)
         131                 :       1924 : set_handler(int i, PyObject* func)
         132                 :            : {
         133                 :       1924 :     _Py_atomic_store(&Handlers[i].func, (uintptr_t)func);
         134                 :       1924 : }
         135                 :            :
         136                 :            :
         137                 :            : static inline _signal_module_state*
         138                 :         78 : get_signal_state(PyObject *module)
         139                 :            : {
         140                 :         78 :     void *state = _PyModule_GetState(module);
         141                 :            :     assert(state != NULL);
         142                 :         78 :     return (_signal_module_state *)state;
         143                 :            : }
         144                 :            :
         145                 :            :
         146                 :            : static inline int
         147                 :        258 : compare_handler(PyObject *func, PyObject *dfl_ign_handler)
         148                 :            : {
         149                 :            :     // See https://github.com/python/cpython/pull/102399
         150   [ +  -  -  + ]:        258 :     if (func == NULL || dfl_ign_handler == NULL) {
         151                 :          0 :         return 0;
         152                 :            :     }
         153                 :            :     assert(PyLong_CheckExact(dfl_ign_handler));
         154         [ +  + ]:        258 :     if (!PyLong_CheckExact(func)) {
         155                 :          6 :         return 0;
         156                 :            :     }
         157                 :            :     // Assume that comparison of two PyLong objects will never fail.
         158                 :        252 :     return PyObject_RichCompareBool(func, dfl_ign_handler, Py_EQ) == 1;
         159                 :            : }
         160                 :            :
         161                 :            : #ifdef HAVE_SETITIMER
         162                 :            : /* auxiliary function for setitimer */
         163                 :            : static int
         164                 :          0 : timeval_from_double(PyObject *obj, struct timeval *tv)
         165                 :            : {
         166         [ #  # ]:          0 :     if (obj == NULL) {
         167                 :          0 :         tv->tv_sec = 0;
         168                 :          0 :         tv->tv_usec = 0;
         169                 :          0 :         return 0;
         170                 :            :     }
         171                 :            :
         172                 :            :     _PyTime_t t;
         173         [ #  # ]:          0 :     if (_PyTime_FromSecondsObject(&t, obj, _PyTime_ROUND_CEILING) < 0) {
         174                 :          0 :         return -1;
         175                 :            :     }
         176                 :          0 :     return _PyTime_AsTimeval(t, tv, _PyTime_ROUND_CEILING);
         177                 :            : }
         178                 :            : #endif
         179                 :            :
         180                 :            : #if defined(HAVE_SETITIMER) || defined(HAVE_GETITIMER)
         181                 :            : /* auxiliary functions for get/setitimer */
         182                 :            : Py_LOCAL_INLINE(double)
         183                 :          0 : double_from_timeval(struct timeval *tv)
         184                 :            : {
         185                 :          0 :     return tv->tv_sec + (double)(tv->tv_usec / 1000000.0);
         186                 :            : }
         187                 :            :
         188                 :            : static PyObject *
         189                 :          0 : itimer_retval(struct itimerval *iv)
         190                 :            : {
         191                 :            :     PyObject *r, *v;
         192                 :            :
         193                 :          0 :     r = PyTuple_New(2);
         194         [ #  # ]:          0 :     if (r == NULL)
         195                 :          0 :         return NULL;
         196                 :            :
         197         [ #  # ]:          0 :     if(!(v = PyFloat_FromDouble(double_from_timeval(&iv->it_value)))) {
         198                 :          0 :         Py_DECREF(r);
         199                 :          0 :         return NULL;
         200                 :            :     }
         201                 :            :
         202                 :          0 :     PyTuple_SET_ITEM(r, 0, v);
         203                 :            :
         204         [ #  # ]:          0 :     if(!(v = PyFloat_FromDouble(double_from_timeval(&iv->it_interval)))) {
         205                 :          0 :         Py_DECREF(r);
         206                 :          0 :         return NULL;
         207                 :            :     }
         208                 :            :
         209                 :          0 :     PyTuple_SET_ITEM(r, 1, v);
         210                 :            :
         211                 :          0 :     return r;
         212                 :            : }
         213                 :            : #endif
         214                 :            :
         215                 :            : /*[clinic input]
         216                 :            : signal.default_int_handler
         217                 :            :     signalnum: int
         218                 :            :     frame: object
         219                 :            :     /
         220                 :            :
         221                 :            : The default handler for SIGINT installed by Python.
         222                 :            :
         223                 :            : It raises KeyboardInterrupt.
         224                 :            : [clinic start generated code]*/
         225                 :            :
         226                 :            : static PyObject *
         227                 :          0 : signal_default_int_handler_impl(PyObject *module, int signalnum,
         228                 :            :                                 PyObject *frame)
         229                 :            : /*[clinic end generated code: output=bb11c2eb115ace4e input=efcd4a56a207acfd]*/
         230                 :            : {
         231                 :          0 :     PyErr_SetNone(PyExc_KeyboardInterrupt);
         232                 :          0 :     return NULL;
         233                 :            : }
         234                 :            :
         235                 :            :
         236                 :            : static int
         237                 :          0 : report_wakeup_write_error(void *data)
         238                 :            : {
         239                 :          0 :     int save_errno = errno;
         240                 :          0 :     errno = (int) (intptr_t) data;
         241                 :          0 :     PyObject *exc = PyErr_GetRaisedException();
         242                 :          0 :     PyErr_SetFromErrno(PyExc_OSError);
         243                 :          0 :     _PyErr_WriteUnraisableMsg("when trying to write to the signal wakeup fd",
         244                 :            :                               NULL);
         245                 :          0 :     PyErr_SetRaisedException(exc);
         246                 :          0 :     errno = save_errno;
         247                 :          0 :     return 0;
         248                 :            : }
         249                 :            :
         250                 :            : #ifdef MS_WINDOWS
         251                 :            : static int
         252                 :            : report_wakeup_send_error(void* data)
         253                 :            : {
         254                 :            :     int send_errno = (int) (intptr_t) data;
         255                 :            :
         256                 :            :     PyObject *exc = PyErr_GetRaisedException();
         257                 :            :     /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
         258                 :            :        recognizes the error codes used by both GetLastError() and
         259                 :            :        WSAGetLastError */
         260                 :            :     PyErr_SetExcFromWindowsErr(PyExc_OSError, send_errno);
         261                 :            :     _PyErr_WriteUnraisableMsg("when trying to send to the signal wakeup fd", NULL);
         262                 :            :     PyErr_SetRaisedException(exc);
         263                 :            :     return 0;
         264                 :            : }
         265                 :            : #endif   /* MS_WINDOWS */
         266                 :            :
         267                 :            : static void
         268                 :          0 : trip_signal(int sig_num)
         269                 :            : {
         270                 :          0 :     _Py_atomic_store_relaxed(&Handlers[sig_num].tripped, 1);
         271                 :            :
         272                 :            :     /* Set is_tripped after setting .tripped, as it gets
         273                 :            :        cleared in PyErr_CheckSignals() before .tripped. */
         274                 :          0 :     _Py_atomic_store(&is_tripped, 1);
         275                 :            :
         276                 :            :     /* Signals are always handled by the main interpreter */
         277                 :          0 :     PyInterpreterState *interp = _PyInterpreterState_Main();
         278                 :            :
         279                 :            :     /* Notify ceval.c */
         280                 :          0 :     _PyEval_SignalReceived(interp);
         281                 :            :
         282                 :            :     /* And then write to the wakeup fd *after* setting all the globals and
         283                 :            :        doing the _PyEval_SignalReceived. We used to write to the wakeup fd
         284                 :            :        and then set the flag, but this allowed the following sequence of events
         285                 :            :        (especially on windows, where trip_signal may run in a new thread):
         286                 :            :
         287                 :            :        - main thread blocks on select([wakeup.fd], ...)
         288                 :            :        - signal arrives
         289                 :            :        - trip_signal writes to the wakeup fd
         290                 :            :        - the main thread wakes up
         291                 :            :        - the main thread checks the signal flags, sees that they're unset
         292                 :            :        - the main thread empties the wakeup fd
         293                 :            :        - the main thread goes back to sleep
         294                 :            :        - trip_signal sets the flags to request the Python-level signal handler
         295                 :            :          be run
         296                 :            :        - the main thread doesn't notice, because it's asleep
         297                 :            :
         298                 :            :        See bpo-30038 for more details.
         299                 :            :     */
         300                 :            :
         301                 :          0 :     int fd = wakeup.fd;
         302         [ #  # ]:          0 :     if (fd != INVALID_FD) {
         303                 :          0 :         unsigned char byte = (unsigned char)sig_num;
         304                 :            : #ifdef MS_WINDOWS
         305                 :            :         if (wakeup.use_send) {
         306                 :            :             Py_ssize_t rc = send(fd, &byte, 1, 0);
         307                 :            :
         308                 :            :             if (rc < 0) {
         309                 :            :                 int last_error = GetLastError();
         310                 :            :                 if (wakeup.warn_on_full_buffer ||
         311                 :            :                     last_error != WSAEWOULDBLOCK)
         312                 :            :                 {
         313                 :            :                     /* _PyEval_AddPendingCall() isn't signal-safe, but we
         314                 :            :                        still use it for this exceptional case. */
         315                 :            :                     _PyEval_AddPendingCall(interp,
         316                 :            :                                            report_wakeup_send_error,
         317                 :            :                                            (void *)(intptr_t) last_error);
         318                 :            :                 }
         319                 :            :             }
         320                 :            :         }
         321                 :            :         else
         322                 :            : #endif
         323                 :            :         {
         324                 :            :             /* _Py_write_noraise() retries write() if write() is interrupted by
         325                 :            :                a signal (fails with EINTR). */
         326                 :          0 :             Py_ssize_t rc = _Py_write_noraise(fd, &byte, 1);
         327                 :            :
         328         [ #  # ]:          0 :             if (rc < 0) {
         329         [ #  # ]:          0 :                 if (wakeup.warn_on_full_buffer ||
         330   [ #  #  #  # ]:          0 :                     (errno != EWOULDBLOCK && errno != EAGAIN))
         331                 :            :                 {
         332                 :            :                     /* _PyEval_AddPendingCall() isn't signal-safe, but we
         333                 :            :                        still use it for this exceptional case. */
         334                 :          0 :                     _PyEval_AddPendingCall(interp,
         335                 :            :                                            report_wakeup_write_error,
         336                 :          0 :                                            (void *)(intptr_t)errno);
         337                 :            :                 }
         338                 :            :             }
         339                 :            :         }
         340                 :            :     }
         341                 :          0 : }
         342                 :            :
         343                 :            : static void
         344                 :          0 : signal_handler(int sig_num)
         345                 :            : {
         346                 :          0 :     int save_errno = errno;
         347                 :            :
         348                 :          0 :     trip_signal(sig_num);
         349                 :            :
         350                 :            : #ifndef HAVE_SIGACTION
         351                 :            : #ifdef SIGCHLD
         352                 :            :     /* To avoid infinite recursion, this signal remains
         353                 :            :        reset until explicit re-instated.
         354                 :            :        Don't clear the 'func' field as it is our pointer
         355                 :            :        to the Python handler... */
         356                 :            :     if (sig_num != SIGCHLD)
         357                 :            : #endif
         358                 :            :     /* If the handler was not set up with sigaction, reinstall it.  See
         359                 :            :      * Python/pylifecycle.c for the implementation of PyOS_setsig which
         360                 :            :      * makes this true.  See also issue8354. */
         361                 :            :     PyOS_setsig(sig_num, signal_handler);
         362                 :            : #endif
         363                 :            :
         364                 :            :     /* Issue #10311: asynchronously executing signal handlers should not
         365                 :            :        mutate errno under the feet of unsuspecting C code. */
         366                 :          0 :     errno = save_errno;
         367                 :            :
         368                 :            : #ifdef MS_WINDOWS
         369                 :            :     if (sig_num == SIGINT) {
         370                 :            :         signal_state_t *state = &signal_global_state;
         371                 :            :         SetEvent((HANDLE)state->sigint_event);
         372                 :            :     }
         373                 :            : #endif
         374                 :          0 : }
         375                 :            :
         376                 :            :
         377                 :            : #ifdef HAVE_ALARM
         378                 :            :
         379                 :            : /*[clinic input]
         380                 :            : signal.alarm -> long
         381                 :            :
         382                 :            :     seconds: int
         383                 :            :     /
         384                 :            :
         385                 :            : Arrange for SIGALRM to arrive after the given number of seconds.
         386                 :            : [clinic start generated code]*/
         387                 :            :
         388                 :            : static long
         389                 :          0 : signal_alarm_impl(PyObject *module, int seconds)
         390                 :            : /*[clinic end generated code: output=144232290814c298 input=0d5e97e0e6f39e86]*/
         391                 :            : {
         392                 :            :     /* alarm() returns the number of seconds remaining */
         393                 :          0 :     return (long)alarm(seconds);
         394                 :            : }
         395                 :            :
         396                 :            : #endif
         397                 :            :
         398                 :            : #ifdef HAVE_PAUSE
         399                 :            :
         400                 :            : /*[clinic input]
         401                 :            : signal.pause
         402                 :            :
         403                 :            : Wait until a signal arrives.
         404                 :            : [clinic start generated code]*/
         405                 :            :
         406                 :            : static PyObject *
         407                 :          0 : signal_pause_impl(PyObject *module)
         408                 :            : /*[clinic end generated code: output=391656788b3c3929 input=f03de0f875752062]*/
         409                 :            : {
         410                 :          0 :     Py_BEGIN_ALLOW_THREADS
         411                 :          0 :     (void)pause();
         412                 :          0 :     Py_END_ALLOW_THREADS
         413                 :            :     /* make sure that any exceptions that got raised are propagated
         414                 :            :      * back into Python
         415                 :            :      */
         416         [ #  # ]:          0 :     if (PyErr_CheckSignals())
         417                 :          0 :         return NULL;
         418                 :            :
         419                 :          0 :     Py_RETURN_NONE;
         420                 :            : }
         421                 :            :
         422                 :            : #endif
         423                 :            :
         424                 :            : /*[clinic input]
         425                 :            : signal.raise_signal
         426                 :            :
         427                 :            :     signalnum: int
         428                 :            :     /
         429                 :            :
         430                 :            : Send a signal to the executing process.
         431                 :            : [clinic start generated code]*/
         432                 :            :
         433                 :            : static PyObject *
         434                 :          0 : signal_raise_signal_impl(PyObject *module, int signalnum)
         435                 :            : /*[clinic end generated code: output=e2b014220aa6111d input=e90c0f9a42358de6]*/
         436                 :            : {
         437                 :            :     int err;
         438                 :          0 :     Py_BEGIN_ALLOW_THREADS
         439                 :            :     _Py_BEGIN_SUPPRESS_IPH
         440                 :          0 :     err = raise(signalnum);
         441                 :            :     _Py_END_SUPPRESS_IPH
         442                 :          0 :     Py_END_ALLOW_THREADS
         443                 :            :
         444         [ #  # ]:          0 :     if (err) {
         445                 :          0 :         return PyErr_SetFromErrno(PyExc_OSError);
         446                 :            :     }
         447                 :            :
         448                 :            :     // If the current thread can handle signals, handle immediately
         449                 :            :     // the raised signal.
         450         [ #  # ]:          0 :     if (PyErr_CheckSignals()) {
         451                 :          0 :         return NULL;
         452                 :            :     }
         453                 :            :
         454                 :          0 :     Py_RETURN_NONE;
         455                 :            : }
         456                 :            :
         457                 :            : /*[clinic input]
         458                 :            : signal.signal
         459                 :            :
         460                 :            :     signalnum: int
         461                 :            :     handler:   object
         462                 :            :     /
         463                 :            :
         464                 :            : Set the action for the given signal.
         465                 :            :
         466                 :            : The action can be SIG_DFL, SIG_IGN, or a callable Python object.
         467                 :            : The previous action is returned.  See getsignal() for possible return values.
         468                 :            :
         469                 :            : *** IMPORTANT NOTICE ***
         470                 :            : A signal handler function is called with two arguments:
         471                 :            : the first is the signal number, the second is the interrupted stack frame.
         472                 :            : [clinic start generated code]*/
         473                 :            :
         474                 :            : static PyObject *
         475                 :          0 : signal_signal_impl(PyObject *module, int signalnum, PyObject *handler)
         476                 :            : /*[clinic end generated code: output=b44cfda43780f3a1 input=deee84af5fa0432c]*/
         477                 :            : {
         478                 :          0 :     _signal_module_state *modstate = get_signal_state(module);
         479                 :            :     PyObject *old_handler;
         480                 :            :     void (*func)(int);
         481                 :            : #ifdef MS_WINDOWS
         482                 :            :     /* Validate that signalnum is one of the allowable signals */
         483                 :            :     switch (signalnum) {
         484                 :            :         case SIGABRT: break;
         485                 :            : #ifdef SIGBREAK
         486                 :            :         /* Issue #10003: SIGBREAK is not documented as permitted, but works
         487                 :            :            and corresponds to CTRL_BREAK_EVENT. */
         488                 :            :         case SIGBREAK: break;
         489                 :            : #endif
         490                 :            :         case SIGFPE: break;
         491                 :            :         case SIGILL: break;
         492                 :            :         case SIGINT: break;
         493                 :            :         case SIGSEGV: break;
         494                 :            :         case SIGTERM: break;
         495                 :            :         default:
         496                 :            :             PyErr_SetString(PyExc_ValueError, "invalid signal value");
         497                 :            :             return NULL;
         498                 :            :     }
         499                 :            : #endif
         500                 :            :
         501                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
         502         [ #  # ]:          0 :     if (!_Py_ThreadCanHandleSignals(tstate->interp)) {
         503                 :          0 :         _PyErr_SetString(tstate, PyExc_ValueError,
         504                 :            :                          "signal only works in main thread "
         505                 :            :                          "of the main interpreter");
         506                 :          0 :         return NULL;
         507                 :            :     }
         508   [ #  #  #  # ]:          0 :     if (signalnum < 1 || signalnum >= Py_NSIG) {
         509                 :          0 :         _PyErr_SetString(tstate, PyExc_ValueError,
         510                 :            :                          "signal number out of range");
         511                 :          0 :         return NULL;
         512                 :            :     }
         513         [ #  # ]:          0 :     if (PyCallable_Check(handler)) {
         514                 :          0 :         func = signal_handler;
         515         [ #  # ]:          0 :     } else if (compare_handler(handler, modstate->ignore_handler)) {
         516                 :          0 :         func = SIG_IGN;
         517         [ #  # ]:          0 :     } else if (compare_handler(handler, modstate->default_handler)) {
         518                 :          0 :         func = SIG_DFL;
         519                 :            :     } else {
         520                 :          0 :         _PyErr_SetString(tstate, PyExc_TypeError,
         521                 :            :                          "signal handler must be signal.SIG_IGN, "
         522                 :            :                          "signal.SIG_DFL, or a callable object");
         523                 :          0 :         return NULL;
         524                 :            :     }
         525                 :            :
         526                 :            :     /* Check for pending signals before changing signal handler */
         527         [ #  # ]:          0 :     if (_PyErr_CheckSignalsTstate(tstate)) {
         528                 :          0 :         return NULL;
         529                 :            :     }
         530         [ #  # ]:          0 :     if (PyOS_setsig(signalnum, func) == SIG_ERR) {
         531                 :          0 :         PyErr_SetFromErrno(PyExc_OSError);
         532                 :          0 :         return NULL;
         533                 :            :     }
         534                 :            :
         535                 :          0 :     old_handler = get_handler(signalnum);
         536                 :          0 :     set_handler(signalnum, Py_NewRef(handler));
         537                 :            :
         538         [ #  # ]:          0 :     if (old_handler != NULL) {
         539                 :          0 :         return old_handler;
         540                 :            :     }
         541                 :            :     else {
         542                 :          0 :         Py_RETURN_NONE;
         543                 :            :     }
         544                 :            : }
         545                 :            :
         546                 :            :
         547                 :            : /*[clinic input]
         548                 :            : signal.getsignal
         549                 :            :
         550                 :            :     signalnum: int
         551                 :            :     /
         552                 :            :
         553                 :            : Return the current action for the given signal.
         554                 :            :
         555                 :            : The return value can be:
         556                 :            :   SIG_IGN -- if the signal is being ignored
         557                 :            :   SIG_DFL -- if the default action for the signal is in effect
         558                 :            :   None    -- if an unknown handler is in effect
         559                 :            :   anything else -- the callable Python object used as a handler
         560                 :            : [clinic start generated code]*/
         561                 :            :
         562                 :            : static PyObject *
         563                 :          0 : signal_getsignal_impl(PyObject *module, int signalnum)
         564                 :            : /*[clinic end generated code: output=35b3e0e796fd555e input=ac23a00f19dfa509]*/
         565                 :            : {
         566                 :            :     PyObject *old_handler;
         567   [ #  #  #  # ]:          0 :     if (signalnum < 1 || signalnum >= Py_NSIG) {
         568                 :          0 :         PyErr_SetString(PyExc_ValueError,
         569                 :            :                         "signal number out of range");
         570                 :          0 :         return NULL;
         571                 :            :     }
         572                 :          0 :     old_handler = get_handler(signalnum);
         573         [ #  # ]:          0 :     if (old_handler != NULL) {
         574                 :          0 :         return Py_NewRef(old_handler);
         575                 :            :     }
         576                 :            :     else {
         577                 :          0 :         Py_RETURN_NONE;
         578                 :            :     }
         579                 :            : }
         580                 :            :
         581                 :            :
         582                 :            : /*[clinic input]
         583                 :            : signal.strsignal
         584                 :            :
         585                 :            :     signalnum: int
         586                 :            :     /
         587                 :            :
         588                 :            : Return the system description of the given signal.
         589                 :            :
         590                 :            : Returns the description of signal *signalnum*, such as "Interrupt"
         591                 :            : for :const:`SIGINT`. Returns :const:`None` if *signalnum* has no
         592                 :            : description. Raises :exc:`ValueError` if *signalnum* is invalid.
         593                 :            : [clinic start generated code]*/
         594                 :            :
         595                 :            : static PyObject *
         596                 :          0 : signal_strsignal_impl(PyObject *module, int signalnum)
         597                 :            : /*[clinic end generated code: output=44e12e1e3b666261 input=238b335847778bc0]*/
         598                 :            : {
         599                 :            :     const char *res;
         600                 :            :
         601   [ #  #  #  # ]:          0 :     if (signalnum < 1 || signalnum >= Py_NSIG) {
         602                 :          0 :         PyErr_SetString(PyExc_ValueError,
         603                 :            :                 "signal number out of range");
         604                 :          0 :         return NULL;
         605                 :            :     }
         606                 :            :
         607                 :            : #ifndef HAVE_STRSIGNAL
         608                 :            :     switch (signalnum) {
         609                 :            :         /* Though being a UNIX, HP-UX does not provide strsignal(3). */
         610                 :            : #ifndef MS_WINDOWS
         611                 :            :         case SIGHUP:
         612                 :            :             res = "Hangup";
         613                 :            :             break;
         614                 :            :         case SIGALRM:
         615                 :            :             res = "Alarm clock";
         616                 :            :             break;
         617                 :            :         case SIGPIPE:
         618                 :            :             res = "Broken pipe";
         619                 :            :             break;
         620                 :            :         case SIGQUIT:
         621                 :            :             res = "Quit";
         622                 :            :             break;
         623                 :            :         case SIGCHLD:
         624                 :            :             res = "Child exited";
         625                 :            :             break;
         626                 :            : #endif
         627                 :            :         /* Custom redefinition of POSIX signals allowed on Windows. */
         628                 :            :         case SIGINT:
         629                 :            :             res = "Interrupt";
         630                 :            :             break;
         631                 :            :         case SIGILL:
         632                 :            :             res = "Illegal instruction";
         633                 :            :             break;
         634                 :            :         case SIGABRT:
         635                 :            :             res = "Aborted";
         636                 :            :             break;
         637                 :            :         case SIGFPE:
         638                 :            :             res = "Floating point exception";
         639                 :            :             break;
         640                 :            :         case SIGSEGV:
         641                 :            :             res = "Segmentation fault";
         642                 :            :             break;
         643                 :            :         case SIGTERM:
         644                 :            :             res = "Terminated";
         645                 :            :             break;
         646                 :            :         default:
         647                 :            :             Py_RETURN_NONE;
         648                 :            :     }
         649                 :            : #else
         650                 :          0 :     errno = 0;
         651                 :          0 :     res = strsignal(signalnum);
         652                 :            :
         653   [ #  #  #  #  :          0 :     if (errno || res == NULL || strstr(res, "Unknown signal") != NULL)
                       #  # ]
         654                 :          0 :         Py_RETURN_NONE;
         655                 :            : #endif
         656                 :            :
         657                 :          0 :     return Py_BuildValue("s", res);
         658                 :            : }
         659                 :            :
         660                 :            : #ifdef HAVE_SIGINTERRUPT
         661                 :            :
         662                 :            : /*[clinic input]
         663                 :            : signal.siginterrupt
         664                 :            :
         665                 :            :     signalnum: int
         666                 :            :     flag:      int
         667                 :            :     /
         668                 :            :
         669                 :            : Change system call restart behaviour.
         670                 :            :
         671                 :            : If flag is False, system calls will be restarted when interrupted by
         672                 :            : signal sig, else system calls will be interrupted.
         673                 :            : [clinic start generated code]*/
         674                 :            :
         675                 :            : static PyObject *
         676                 :          0 : signal_siginterrupt_impl(PyObject *module, int signalnum, int flag)
         677                 :            : /*[clinic end generated code: output=063816243d85dd19 input=4160acacca3e2099]*/
         678                 :            : {
         679   [ #  #  #  # ]:          0 :     if (signalnum < 1 || signalnum >= Py_NSIG) {
         680                 :          0 :         PyErr_SetString(PyExc_ValueError,
         681                 :            :                         "signal number out of range");
         682                 :          0 :         return NULL;
         683                 :            :     }
         684                 :            : #ifdef HAVE_SIGACTION
         685                 :            :     struct sigaction act;
         686                 :          0 :     (void) sigaction(signalnum, NULL, &act);
         687         [ #  # ]:          0 :     if (flag) {
         688                 :          0 :         act.sa_flags &= ~SA_RESTART;
         689                 :            :     }
         690                 :            :     else {
         691                 :          0 :         act.sa_flags |= SA_RESTART;
         692                 :            :     }
         693         [ #  # ]:          0 :     if (sigaction(signalnum, &act, NULL) < 0) {
         694                 :            : #else
         695                 :            :     if (siginterrupt(signalnum, flag) < 0) {
         696                 :            : #endif
         697                 :          0 :         PyErr_SetFromErrno(PyExc_OSError);
         698                 :          0 :         return NULL;
         699                 :            :     }
         700                 :          0 :     Py_RETURN_NONE;
         701                 :            : }
         702                 :            :
         703                 :            : #endif
         704                 :            :
         705                 :            :
         706                 :            : static PyObject*
         707                 :          0 : signal_set_wakeup_fd(PyObject *self, PyObject *args, PyObject *kwds)
         708                 :            : {
         709                 :            :     struct _Py_stat_struct status;
         710                 :            :     static char *kwlist[] = {
         711                 :            :         "", "warn_on_full_buffer", NULL,
         712                 :            :     };
         713                 :          0 :     int warn_on_full_buffer = 1;
         714                 :            : #ifdef MS_WINDOWS
         715                 :            :     PyObject *fdobj;
         716                 :            :     SOCKET_T sockfd, old_sockfd;
         717                 :            :     int res;
         718                 :            :     int res_size = sizeof res;
         719                 :            :     PyObject *mod;
         720                 :            :     int is_socket;
         721                 :            :
         722                 :            :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|$p:set_wakeup_fd", kwlist,
         723                 :            :                                      &fdobj, &warn_on_full_buffer))
         724                 :            :         return NULL;
         725                 :            :
         726                 :            :     sockfd = PyLong_AsSocket_t(fdobj);
         727                 :            :     if (sockfd == (SOCKET_T)(-1) && PyErr_Occurred())
         728                 :            :         return NULL;
         729                 :            : #else
         730                 :            :     int fd;
         731                 :            :
         732         [ #  # ]:          0 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i|$p:set_wakeup_fd", kwlist,
         733                 :            :                                      &fd, &warn_on_full_buffer))
         734                 :          0 :         return NULL;
         735                 :            : #endif
         736                 :            :
         737                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
         738         [ #  # ]:          0 :     if (!_Py_ThreadCanHandleSignals(tstate->interp)) {
         739                 :          0 :         _PyErr_SetString(tstate, PyExc_ValueError,
         740                 :            :                          "set_wakeup_fd only works in main thread "
         741                 :            :                          "of the main interpreter");
         742                 :          0 :         return NULL;
         743                 :            :     }
         744                 :            :
         745                 :            : #ifdef MS_WINDOWS
         746                 :            :     is_socket = 0;
         747                 :            :     if (sockfd != INVALID_FD) {
         748                 :            :         /* Import the _socket module to call WSAStartup() */
         749                 :            :         mod = PyImport_ImportModule("_socket");
         750                 :            :         if (mod == NULL)
         751                 :            :             return NULL;
         752                 :            :         Py_DECREF(mod);
         753                 :            :
         754                 :            :         /* test the socket */
         755                 :            :         if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR,
         756                 :            :                        (char *)&res, &res_size) != 0) {
         757                 :            :             int fd, err;
         758                 :            :
         759                 :            :             err = WSAGetLastError();
         760                 :            :             if (err != WSAENOTSOCK) {
         761                 :            :                 PyErr_SetExcFromWindowsErr(PyExc_OSError, err);
         762                 :            :                 return NULL;
         763                 :            :             }
         764                 :            :
         765                 :            :             fd = (int)sockfd;
         766                 :            :             if ((SOCKET_T)fd != sockfd) {
         767                 :            :                 _PyErr_SetString(tstate, PyExc_ValueError, "invalid fd");
         768                 :            :                 return NULL;
         769                 :            :             }
         770                 :            :
         771                 :            :             if (_Py_fstat(fd, &status) != 0) {
         772                 :            :                 return NULL;
         773                 :            :             }
         774                 :            :
         775                 :            :             /* on Windows, a file cannot be set to non-blocking mode */
         776                 :            :         }
         777                 :            :         else {
         778                 :            :             is_socket = 1;
         779                 :            :
         780                 :            :             /* Windows does not provide a function to test if a socket
         781                 :            :                is in non-blocking mode */
         782                 :            :         }
         783                 :            :     }
         784                 :            :
         785                 :            :     old_sockfd = wakeup.fd;
         786                 :            :     wakeup.fd = Py_SAFE_DOWNCAST(sockfd, SOCKET_T, int);
         787                 :            :     wakeup.warn_on_full_buffer = warn_on_full_buffer;
         788                 :            :     wakeup.use_send = is_socket;
         789                 :            :
         790                 :            :     if (old_sockfd != INVALID_FD)
         791                 :            :         return PyLong_FromSocket_t(old_sockfd);
         792                 :            :     else
         793                 :            :         return PyLong_FromLong(-1);
         794                 :            : #else
         795         [ #  # ]:          0 :     if (fd != -1) {
         796                 :            :         int blocking;
         797                 :            :
         798         [ #  # ]:          0 :         if (_Py_fstat(fd, &status) != 0)
         799                 :          0 :             return NULL;
         800                 :            :
         801                 :          0 :         blocking = _Py_get_blocking(fd);
         802         [ #  # ]:          0 :         if (blocking < 0)
         803                 :          0 :             return NULL;
         804         [ #  # ]:          0 :         if (blocking) {
         805                 :          0 :             _PyErr_Format(tstate, PyExc_ValueError,
         806                 :            :                           "the fd %i must be in non-blocking mode",
         807                 :            :                           fd);
         808                 :          0 :             return NULL;
         809                 :            :         }
         810                 :            :     }
         811                 :            :
         812                 :          0 :     int old_fd = wakeup.fd;
         813                 :          0 :     wakeup.fd = fd;
         814                 :          0 :     wakeup.warn_on_full_buffer = warn_on_full_buffer;
         815                 :            :
         816                 :          0 :     return PyLong_FromLong(old_fd);
         817                 :            : #endif
         818                 :            : }
         819                 :            :
         820                 :            : PyDoc_STRVAR(set_wakeup_fd_doc,
         821                 :            : "set_wakeup_fd(fd, *, warn_on_full_buffer=True) -> fd\n\
         822                 :            : \n\
         823                 :            : Sets the fd to be written to (with the signal number) when a signal\n\
         824                 :            : comes in.  A library can use this to wakeup select or poll.\n\
         825                 :            : The previous fd or -1 is returned.\n\
         826                 :            : \n\
         827                 :            : The fd must be non-blocking.");
         828                 :            :
         829                 :            : /* C API for the same, without all the error checking */
         830                 :            : int
         831                 :          0 : PySignal_SetWakeupFd(int fd)
         832                 :            : {
         833         [ #  # ]:          0 :     if (fd < 0) {
         834                 :          0 :         fd = -1;
         835                 :            :     }
         836                 :            :
         837                 :          0 :     int old_fd = wakeup.fd;
         838                 :          0 :     wakeup.fd = fd;
         839                 :          0 :     wakeup.warn_on_full_buffer = 1;
         840                 :          0 :     return old_fd;
         841                 :            : }
         842                 :            :
         843                 :            :
         844                 :            : #ifdef HAVE_SETITIMER
         845                 :            : /*[clinic input]
         846                 :            : signal.setitimer
         847                 :            :
         848                 :            :     which:    int
         849                 :            :     seconds:  object
         850                 :            :     interval: object(c_default="NULL") = 0.0
         851                 :            :     /
         852                 :            :
         853                 :            : Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL or ITIMER_PROF).
         854                 :            :
         855                 :            : The timer will fire after value seconds and after that every interval seconds.
         856                 :            : The itimer can be cleared by setting seconds to zero.
         857                 :            :
         858                 :            : Returns old values as a tuple: (delay, interval).
         859                 :            : [clinic start generated code]*/
         860                 :            :
         861                 :            : static PyObject *
         862                 :          0 : signal_setitimer_impl(PyObject *module, int which, PyObject *seconds,
         863                 :            :                       PyObject *interval)
         864                 :            : /*[clinic end generated code: output=65f9dcbddc35527b input=de43daf194e6f66f]*/
         865                 :            : {
         866                 :          0 :     _signal_module_state *modstate = get_signal_state(module);
         867                 :            :
         868                 :            :     struct itimerval new;
         869         [ #  # ]:          0 :     if (timeval_from_double(seconds, &new.it_value) < 0) {
         870                 :          0 :         return NULL;
         871                 :            :     }
         872         [ #  # ]:          0 :     if (timeval_from_double(interval, &new.it_interval) < 0) {
         873                 :          0 :         return NULL;
         874                 :            :     }
         875                 :            :
         876                 :            :     /* Let OS check "which" value */
         877                 :            :     struct itimerval old;
         878         [ #  # ]:          0 :     if (setitimer(which, &new, &old) != 0) {
         879                 :          0 :         PyErr_SetFromErrno(modstate->itimer_error);
         880                 :          0 :         return NULL;
         881                 :            :     }
         882                 :            :
         883                 :          0 :     return itimer_retval(&old);
         884                 :            : }
         885                 :            : #endif  // HAVE_SETITIMER
         886                 :            :
         887                 :            :
         888                 :            : #ifdef HAVE_GETITIMER
         889                 :            : /*[clinic input]
         890                 :            : signal.getitimer
         891                 :            :
         892                 :            :     which:    int
         893                 :            :     /
         894                 :            :
         895                 :            : Returns current value of given itimer.
         896                 :            : [clinic start generated code]*/
         897                 :            :
         898                 :            : static PyObject *
         899                 :          0 : signal_getitimer_impl(PyObject *module, int which)
         900                 :            : /*[clinic end generated code: output=9e053175d517db40 input=f7d21d38f3490627]*/
         901                 :            : {
         902                 :          0 :     _signal_module_state *modstate = get_signal_state(module);
         903                 :            :
         904                 :            :     struct itimerval old;
         905         [ #  # ]:          0 :     if (getitimer(which, &old) != 0) {
         906                 :          0 :         PyErr_SetFromErrno(modstate->itimer_error);
         907                 :          0 :         return NULL;
         908                 :            :     }
         909                 :            :
         910                 :          0 :     return itimer_retval(&old);
         911                 :            : }
         912                 :            : #endif // HAVE_GETITIMER
         913                 :            :
         914                 :            :
         915                 :            : #ifdef HAVE_SIGSET_T
         916                 :            : #if defined(PYPTHREAD_SIGMASK) || defined(HAVE_SIGPENDING)
         917                 :            : static PyObject*
         918                 :          0 : sigset_to_set(sigset_t mask)
         919                 :            : {
         920                 :            :     PyObject *signum, *result;
         921                 :            :     int sig;
         922                 :            :
         923                 :          0 :     result = PySet_New(0);
         924         [ #  # ]:          0 :     if (result == NULL)
         925                 :          0 :         return NULL;
         926                 :            :
         927         [ #  # ]:          0 :     for (sig = 1; sig < Py_NSIG; sig++) {
         928         [ #  # ]:          0 :         if (sigismember(&mask, sig) != 1)
         929                 :          0 :             continue;
         930                 :            :
         931                 :            :         /* Handle the case where it is a member by adding the signal to
         932                 :            :            the result list.  Ignore the other cases because they mean the
         933                 :            :            signal isn't a member of the mask or the signal was invalid,
         934                 :            :            and an invalid signal must have been our fault in constructing
         935                 :            :            the loop boundaries. */
         936                 :          0 :         signum = PyLong_FromLong(sig);
         937         [ #  # ]:          0 :         if (signum == NULL) {
         938                 :          0 :             Py_DECREF(result);
         939                 :          0 :             return NULL;
         940                 :            :         }
         941         [ #  # ]:          0 :         if (PySet_Add(result, signum) == -1) {
         942                 :          0 :             Py_DECREF(signum);
         943                 :          0 :             Py_DECREF(result);
         944                 :          0 :             return NULL;
         945                 :            :         }
         946                 :          0 :         Py_DECREF(signum);
         947                 :            :     }
         948                 :          0 :     return result;
         949                 :            : }
         950                 :            : #endif
         951                 :            :
         952                 :            : #ifdef PYPTHREAD_SIGMASK
         953                 :            :
         954                 :            : /*[clinic input]
         955                 :            : signal.pthread_sigmask
         956                 :            :
         957                 :            :     how:  int
         958                 :            :     mask: sigset_t
         959                 :            :     /
         960                 :            :
         961                 :            : Fetch and/or change the signal mask of the calling thread.
         962                 :            : [clinic start generated code]*/
         963                 :            :
         964                 :            : static PyObject *
         965                 :          0 : signal_pthread_sigmask_impl(PyObject *module, int how, sigset_t mask)
         966                 :            : /*[clinic end generated code: output=0562c0fb192981a8 input=85bcebda442fa77f]*/
         967                 :            : {
         968                 :            :     sigset_t previous;
         969                 :            :     int err;
         970                 :            :
         971                 :          0 :     err = pthread_sigmask(how, &mask, &previous);
         972         [ #  # ]:          0 :     if (err != 0) {
         973                 :          0 :         errno = err;
         974                 :          0 :         PyErr_SetFromErrno(PyExc_OSError);
         975                 :          0 :         return NULL;
         976                 :            :     }
         977                 :            :
         978                 :            :     /* if signals was unblocked, signal handlers have been called */
         979         [ #  # ]:          0 :     if (PyErr_CheckSignals())
         980                 :          0 :         return NULL;
         981                 :            :
         982                 :          0 :     return sigset_to_set(previous);
         983                 :            : }
         984                 :            :
         985                 :            : #endif   /* #ifdef PYPTHREAD_SIGMASK */
         986                 :            :
         987                 :            :
         988                 :            : #ifdef HAVE_SIGPENDING
         989                 :            :
         990                 :            : /*[clinic input]
         991                 :            : signal.sigpending
         992                 :            :
         993                 :            : Examine pending signals.
         994                 :            :
         995                 :            : Returns a set of signal numbers that are pending for delivery to
         996                 :            : the calling thread.
         997                 :            : [clinic start generated code]*/
         998                 :            :
         999                 :            : static PyObject *
        1000                 :          0 : signal_sigpending_impl(PyObject *module)
        1001                 :            : /*[clinic end generated code: output=53375ffe89325022 input=e0036c016f874e29]*/
        1002                 :            : {
        1003                 :            :     int err;
        1004                 :            :     sigset_t mask;
        1005                 :          0 :     err = sigpending(&mask);
        1006         [ #  # ]:          0 :     if (err)
        1007                 :          0 :         return PyErr_SetFromErrno(PyExc_OSError);
        1008                 :          0 :     return sigset_to_set(mask);
        1009                 :            : }
        1010                 :            :
        1011                 :            : #endif   /* #ifdef HAVE_SIGPENDING */
        1012                 :            :
        1013                 :            :
        1014                 :            : #ifdef HAVE_SIGWAIT
        1015                 :            :
        1016                 :            : /*[clinic input]
        1017                 :            : signal.sigwait
        1018                 :            :
        1019                 :            :     sigset: sigset_t
        1020                 :            :     /
        1021                 :            :
        1022                 :            : Wait for a signal.
        1023                 :            :
        1024                 :            : Suspend execution of the calling thread until the delivery of one of the
        1025                 :            : signals specified in the signal set sigset.  The function accepts the signal
        1026                 :            : and returns the signal number.
        1027                 :            : [clinic start generated code]*/
        1028                 :            :
        1029                 :            : static PyObject *
        1030                 :          0 : signal_sigwait_impl(PyObject *module, sigset_t sigset)
        1031                 :            : /*[clinic end generated code: output=f43770699d682f96 input=a6fbd47b1086d119]*/
        1032                 :            : {
        1033                 :            :     int err, signum;
        1034                 :            :
        1035                 :          0 :     Py_BEGIN_ALLOW_THREADS
        1036                 :          0 :     err = sigwait(&sigset, &signum);
        1037                 :          0 :     Py_END_ALLOW_THREADS
        1038         [ #  # ]:          0 :     if (err) {
        1039                 :          0 :         errno = err;
        1040                 :          0 :         return PyErr_SetFromErrno(PyExc_OSError);
        1041                 :            :     }
        1042                 :            :
        1043                 :          0 :     return PyLong_FromLong(signum);
        1044                 :            : }
        1045                 :            :
        1046                 :            : #endif   /* #ifdef HAVE_SIGWAIT */
        1047                 :            : #endif   /* #ifdef HAVE_SIGSET_T */
        1048                 :            :
        1049                 :            : #if (defined(HAVE_SIGFILLSET) && defined(HAVE_SIGSET_T)) || defined(MS_WINDOWS)
        1050                 :            :
        1051                 :            : /*[clinic input]
        1052                 :            : signal.valid_signals
        1053                 :            :
        1054                 :            : Return a set of valid signal numbers on this platform.
        1055                 :            :
        1056                 :            : The signal numbers returned by this function can be safely passed to
        1057                 :            : functions like `pthread_sigmask`.
        1058                 :            : [clinic start generated code]*/
        1059                 :            :
        1060                 :            : static PyObject *
        1061                 :          0 : signal_valid_signals_impl(PyObject *module)
        1062                 :            : /*[clinic end generated code: output=1609cffbcfcf1314 input=86a3717ff25288f2]*/
        1063                 :            : {
        1064                 :            : #ifdef MS_WINDOWS
        1065                 :            : #ifdef SIGBREAK
        1066                 :            :     PyObject *tup = Py_BuildValue("(iiiiiii)", SIGABRT, SIGBREAK, SIGFPE,
        1067                 :            :                                   SIGILL, SIGINT, SIGSEGV, SIGTERM);
        1068                 :            : #else
        1069                 :            :     PyObject *tup = Py_BuildValue("(iiiiii)", SIGABRT, SIGFPE, SIGILL,
        1070                 :            :                                   SIGINT, SIGSEGV, SIGTERM);
        1071                 :            : #endif
        1072                 :            :     if (tup == NULL) {
        1073                 :            :         return NULL;
        1074                 :            :     }
        1075                 :            :     PyObject *set = PySet_New(tup);
        1076                 :            :     Py_DECREF(tup);
        1077                 :            :     return set;
        1078                 :            : #else
        1079                 :            :     sigset_t mask;
        1080   [ #  #  #  # ]:          0 :     if (sigemptyset(&mask) || sigfillset(&mask)) {
        1081                 :          0 :         return PyErr_SetFromErrno(PyExc_OSError);
        1082                 :            :     }
        1083                 :          0 :     return sigset_to_set(mask);
        1084                 :            : #endif
        1085                 :            : }
        1086                 :            :
        1087                 :            : #endif   /* #if (defined(HAVE_SIGFILLSET) && defined(HAVE_SIGSET_T)) || defined(MS_WINDOWS) */
        1088                 :            :
        1089                 :            :
        1090                 :            :
        1091                 :            : #if defined(HAVE_SIGWAITINFO) || defined(HAVE_SIGTIMEDWAIT)
        1092                 :            : static PyStructSequence_Field struct_siginfo_fields[] = {
        1093                 :            :     {"si_signo",        "signal number"},
        1094                 :            :     {"si_code",         "signal code"},
        1095                 :            :     {"si_errno",        "errno associated with this signal"},
        1096                 :            :     {"si_pid",          "sending process ID"},
        1097                 :            :     {"si_uid",          "real user ID of sending process"},
        1098                 :            :     {"si_status",       "exit value or signal"},
        1099                 :            :     {"si_band",         "band event for SIGPOLL"},
        1100                 :            :     {0}
        1101                 :            : };
        1102                 :            :
        1103                 :            : PyDoc_STRVAR(struct_siginfo__doc__,
        1104                 :            : "struct_siginfo: Result from sigwaitinfo or sigtimedwait.\n\n\
        1105                 :            : This object may be accessed either as a tuple of\n\
        1106                 :            : (si_signo, si_code, si_errno, si_pid, si_uid, si_status, si_band),\n\
        1107                 :            : or via the attributes si_signo, si_code, and so on.");
        1108                 :            :
        1109                 :            : static PyStructSequence_Desc struct_siginfo_desc = {
        1110                 :            :     "signal.struct_siginfo",           /* name */
        1111                 :            :     struct_siginfo__doc__,       /* doc */
        1112                 :            :     struct_siginfo_fields,       /* fields */
        1113                 :            :     7          /* n_in_sequence */
        1114                 :            : };
        1115                 :            :
        1116                 :            :
        1117                 :            : static PyObject *
        1118                 :          0 : fill_siginfo(_signal_module_state *state, siginfo_t *si)
        1119                 :            : {
        1120                 :          0 :     PyObject *result = PyStructSequence_New(state->siginfo_type);
        1121         [ #  # ]:          0 :     if (!result)
        1122                 :          0 :         return NULL;
        1123                 :            :
        1124                 :          0 :     PyStructSequence_SET_ITEM(result, 0, PyLong_FromLong((long)(si->si_signo)));
        1125                 :          0 :     PyStructSequence_SET_ITEM(result, 1, PyLong_FromLong((long)(si->si_code)));
        1126                 :            : #ifdef __VXWORKS__
        1127                 :            :     PyStructSequence_SET_ITEM(result, 2, PyLong_FromLong(0L));
        1128                 :            :     PyStructSequence_SET_ITEM(result, 3, PyLong_FromLong(0L));
        1129                 :            :     PyStructSequence_SET_ITEM(result, 4, PyLong_FromLong(0L));
        1130                 :            :     PyStructSequence_SET_ITEM(result, 5, PyLong_FromLong(0L));
        1131                 :            : #else
        1132                 :          0 :     PyStructSequence_SET_ITEM(result, 2, PyLong_FromLong((long)(si->si_errno)));
        1133                 :          0 :     PyStructSequence_SET_ITEM(result, 3, PyLong_FromPid(si->si_pid));
        1134                 :          0 :     PyStructSequence_SET_ITEM(result, 4, _PyLong_FromUid(si->si_uid));
        1135                 :          0 :     PyStructSequence_SET_ITEM(result, 5,
        1136                 :            :                                 PyLong_FromLong((long)(si->si_status)));
        1137                 :            : #endif
        1138                 :            : #ifdef HAVE_SIGINFO_T_SI_BAND
        1139                 :          0 :     PyStructSequence_SET_ITEM(result, 6, PyLong_FromLong(si->si_band));
        1140                 :            : #else
        1141                 :            :     PyStructSequence_SET_ITEM(result, 6, PyLong_FromLong(0L));
        1142                 :            : #endif
        1143         [ #  # ]:          0 :     if (PyErr_Occurred()) {
        1144                 :          0 :         Py_DECREF(result);
        1145                 :          0 :         return NULL;
        1146                 :            :     }
        1147                 :            :
        1148                 :          0 :     return result;
        1149                 :            : }
        1150                 :            : #endif
        1151                 :            :
        1152                 :            : #ifdef HAVE_SIGSET_T
        1153                 :            : #ifdef HAVE_SIGWAITINFO
        1154                 :            :
        1155                 :            : /*[clinic input]
        1156                 :            : signal.sigwaitinfo
        1157                 :            :
        1158                 :            :     sigset: sigset_t
        1159                 :            :     /
        1160                 :            :
        1161                 :            : Wait synchronously until one of the signals in *sigset* is delivered.
        1162                 :            :
        1163                 :            : Returns a struct_siginfo containing information about the signal.
        1164                 :            : [clinic start generated code]*/
        1165                 :            :
        1166                 :            : static PyObject *
        1167                 :          0 : signal_sigwaitinfo_impl(PyObject *module, sigset_t sigset)
        1168                 :            : /*[clinic end generated code: output=1eb2f1fa236fdbca input=3d1a7e1f27fc664c]*/
        1169                 :            : {
        1170                 :            :     siginfo_t si;
        1171                 :            :     int err;
        1172                 :          0 :     int async_err = 0;
        1173                 :            :
        1174                 :            :     do {
        1175                 :          0 :         Py_BEGIN_ALLOW_THREADS
        1176                 :          0 :         err = sigwaitinfo(&sigset, &si);
        1177                 :          0 :         Py_END_ALLOW_THREADS
        1178                 :            :     } while (err == -1
        1179   [ #  #  #  #  :          0 :              && errno == EINTR && !(async_err = PyErr_CheckSignals()));
                       #  # ]
        1180         [ #  # ]:          0 :     if (err == -1)
        1181         [ #  # ]:          0 :         return (!async_err) ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
        1182                 :            :
        1183                 :          0 :     _signal_module_state *state = get_signal_state(module);
        1184                 :          0 :     return fill_siginfo(state, &si);
        1185                 :            : }
        1186                 :            :
        1187                 :            : #endif   /* #ifdef HAVE_SIGWAITINFO */
        1188                 :            :
        1189                 :            : #ifdef HAVE_SIGTIMEDWAIT
        1190                 :            :
        1191                 :            : /*[clinic input]
        1192                 :            : signal.sigtimedwait
        1193                 :            :
        1194                 :            :     sigset: sigset_t
        1195                 :            :     timeout as timeout_obj: object
        1196                 :            :     /
        1197                 :            :
        1198                 :            : Like sigwaitinfo(), but with a timeout.
        1199                 :            :
        1200                 :            : The timeout is specified in seconds, with floating point numbers allowed.
        1201                 :            : [clinic start generated code]*/
        1202                 :            :
        1203                 :            : static PyObject *
        1204                 :          0 : signal_sigtimedwait_impl(PyObject *module, sigset_t sigset,
        1205                 :            :                          PyObject *timeout_obj)
        1206                 :            : /*[clinic end generated code: output=59c8971e8ae18a64 input=87fd39237cf0b7ba]*/
        1207                 :            : {
        1208                 :            :     _PyTime_t timeout;
        1209         [ #  # ]:          0 :     if (_PyTime_FromSecondsObject(&timeout,
        1210                 :            :                                   timeout_obj, _PyTime_ROUND_CEILING) < 0)
        1211                 :          0 :         return NULL;
        1212                 :            :
        1213         [ #  # ]:          0 :     if (timeout < 0) {
        1214                 :          0 :         PyErr_SetString(PyExc_ValueError, "timeout must be non-negative");
        1215                 :          0 :         return NULL;
        1216                 :            :     }
        1217                 :            :
        1218                 :          0 :     _PyTime_t deadline = _PyDeadline_Init(timeout);
        1219                 :            :     siginfo_t si;
        1220                 :            :
        1221                 :          0 :     do {
        1222                 :            :         struct timespec ts;
        1223         [ #  # ]:          0 :         if (_PyTime_AsTimespec(timeout, &ts) < 0) {
        1224                 :          0 :             return NULL;
        1225                 :            :         }
        1226                 :            :
        1227                 :            :         int res;
        1228                 :          0 :         Py_BEGIN_ALLOW_THREADS
        1229                 :          0 :         res = sigtimedwait(&sigset, &si, &ts);
        1230                 :          0 :         Py_END_ALLOW_THREADS
        1231                 :            :
        1232         [ #  # ]:          0 :         if (res != -1)
        1233                 :          0 :             break;
        1234                 :            :
        1235         [ #  # ]:          0 :         if (errno != EINTR) {
        1236         [ #  # ]:          0 :             if (errno == EAGAIN)
        1237                 :          0 :                 Py_RETURN_NONE;
        1238                 :            :             else
        1239                 :          0 :                 return PyErr_SetFromErrno(PyExc_OSError);
        1240                 :            :         }
        1241                 :            :
        1242                 :            :         /* sigtimedwait() was interrupted by a signal (EINTR) */
        1243         [ #  # ]:          0 :         if (PyErr_CheckSignals())
        1244                 :          0 :             return NULL;
        1245                 :            :
        1246                 :          0 :         timeout = _PyDeadline_Get(deadline);
        1247         [ #  # ]:          0 :         if (timeout < 0) {
        1248                 :          0 :             break;
        1249                 :            :         }
        1250                 :            :     } while (1);
        1251                 :            :
        1252                 :          0 :     _signal_module_state *state = get_signal_state(module);
        1253                 :          0 :     return fill_siginfo(state, &si);
        1254                 :            : }
        1255                 :            :
        1256                 :            : #endif   /* #ifdef HAVE_SIGTIMEDWAIT */
        1257                 :            : #endif   /* #ifdef HAVE_SIGSET_T */
        1258                 :            :
        1259                 :            :
        1260                 :            : #if defined(HAVE_PTHREAD_KILL)
        1261                 :            :
        1262                 :            : /*[clinic input]
        1263                 :            : signal.pthread_kill
        1264                 :            :
        1265                 :            :     thread_id:  unsigned_long(bitwise=True)
        1266                 :            :     signalnum:  int
        1267                 :            :     /
        1268                 :            :
        1269                 :            : Send a signal to a thread.
        1270                 :            : [clinic start generated code]*/
        1271                 :            :
        1272                 :            : static PyObject *
        1273                 :          0 : signal_pthread_kill_impl(PyObject *module, unsigned long thread_id,
        1274                 :            :                          int signalnum)
        1275                 :            : /*[clinic end generated code: output=7629919b791bc27f input=1d901f2c7bb544ff]*/
        1276                 :            : {
        1277                 :            :     int err;
        1278                 :            :
        1279         [ #  # ]:          0 :     if (PySys_Audit("signal.pthread_kill", "ki", thread_id, signalnum) < 0) {
        1280                 :          0 :         return NULL;
        1281                 :            :     }
        1282                 :            :
        1283                 :          0 :     err = pthread_kill((pthread_t)thread_id, signalnum);
        1284         [ #  # ]:          0 :     if (err != 0) {
        1285                 :          0 :         errno = err;
        1286                 :          0 :         PyErr_SetFromErrno(PyExc_OSError);
        1287                 :          0 :         return NULL;
        1288                 :            :     }
        1289                 :            :
        1290                 :            :     /* the signal may have been send to the current thread */
        1291         [ #  # ]:          0 :     if (PyErr_CheckSignals())
        1292                 :          0 :         return NULL;
        1293                 :            :
        1294                 :          0 :     Py_RETURN_NONE;
        1295                 :            : }
        1296                 :            :
        1297                 :            : #endif   /* #if defined(HAVE_PTHREAD_KILL) */
        1298                 :            :
        1299                 :            :
        1300                 :            : #if defined(__linux__) && defined(__NR_pidfd_send_signal)
        1301                 :            : /*[clinic input]
        1302                 :            : signal.pidfd_send_signal
        1303                 :            :
        1304                 :            :     pidfd: int
        1305                 :            :     signalnum: int
        1306                 :            :     siginfo: object = None
        1307                 :            :     flags: int = 0
        1308                 :            :     /
        1309                 :            :
        1310                 :            : Send a signal to a process referred to by a pid file descriptor.
        1311                 :            : [clinic start generated code]*/
        1312                 :            :
        1313                 :            : static PyObject *
        1314                 :          0 : signal_pidfd_send_signal_impl(PyObject *module, int pidfd, int signalnum,
        1315                 :            :                               PyObject *siginfo, int flags)
        1316                 :            : /*[clinic end generated code: output=2d59f04a75d9cbdf input=2a6543a1f4ac2000]*/
        1317                 :            :
        1318                 :            : {
        1319         [ #  # ]:          0 :     if (siginfo != Py_None) {
        1320                 :          0 :         PyErr_SetString(PyExc_TypeError, "siginfo must be None");
        1321                 :          0 :         return NULL;
        1322                 :            :     }
        1323         [ #  # ]:          0 :     if (syscall(__NR_pidfd_send_signal, pidfd, signalnum, NULL, flags) < 0) {
        1324                 :          0 :         PyErr_SetFromErrno(PyExc_OSError);
        1325                 :          0 :         return NULL;
        1326                 :            :     }
        1327                 :          0 :     Py_RETURN_NONE;
        1328                 :            : }
        1329                 :            : #endif
        1330                 :            :
        1331                 :            :
        1332                 :            :
        1333                 :            : /* List of functions defined in the module -- some of the methoddefs are
        1334                 :            :    defined to nothing if the corresponding C function is not available. */
        1335                 :            : static PyMethodDef signal_methods[] = {
        1336                 :            :     SIGNAL_DEFAULT_INT_HANDLER_METHODDEF
        1337                 :            :     SIGNAL_ALARM_METHODDEF
        1338                 :            :     SIGNAL_SETITIMER_METHODDEF
        1339                 :            :     SIGNAL_GETITIMER_METHODDEF
        1340                 :            :     SIGNAL_SIGNAL_METHODDEF
        1341                 :            :     SIGNAL_RAISE_SIGNAL_METHODDEF
        1342                 :            :     SIGNAL_STRSIGNAL_METHODDEF
        1343                 :            :     SIGNAL_GETSIGNAL_METHODDEF
        1344                 :            :     {"set_wakeup_fd", _PyCFunction_CAST(signal_set_wakeup_fd), METH_VARARGS | METH_KEYWORDS, set_wakeup_fd_doc},
        1345                 :            :     SIGNAL_SIGINTERRUPT_METHODDEF
        1346                 :            :     SIGNAL_PAUSE_METHODDEF
        1347                 :            :     SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF
        1348                 :            :     SIGNAL_PTHREAD_KILL_METHODDEF
        1349                 :            :     SIGNAL_PTHREAD_SIGMASK_METHODDEF
        1350                 :            :     SIGNAL_SIGPENDING_METHODDEF
        1351                 :            :     SIGNAL_SIGWAIT_METHODDEF
        1352                 :            :     SIGNAL_SIGWAITINFO_METHODDEF
        1353                 :            :     SIGNAL_SIGTIMEDWAIT_METHODDEF
        1354                 :            : #if defined(HAVE_SIGFILLSET) || defined(MS_WINDOWS)
        1355                 :            :     SIGNAL_VALID_SIGNALS_METHODDEF
        1356                 :            : #endif
        1357                 :            :     {NULL, NULL}           /* sentinel */
        1358                 :            : };
        1359                 :            :
        1360                 :            :
        1361                 :            : PyDoc_STRVAR(module_doc,
        1362                 :            : "This module provides mechanisms to use signal handlers in Python.\n\
        1363                 :            : \n\
        1364                 :            : Functions:\n\
        1365                 :            : \n\
        1366                 :            : alarm() -- cause SIGALRM after a specified time [Unix only]\n\
        1367                 :            : setitimer() -- cause a signal (described below) after a specified\n\
        1368                 :            :                float time and the timer may restart then [Unix only]\n\
        1369                 :            : getitimer() -- get current value of timer [Unix only]\n\
        1370                 :            : signal() -- set the action for a given signal\n\
        1371                 :            : getsignal() -- get the signal action for a given signal\n\
        1372                 :            : pause() -- wait until a signal arrives [Unix only]\n\
        1373                 :            : default_int_handler() -- default SIGINT handler\n\
        1374                 :            : \n\
        1375                 :            : signal constants:\n\
        1376                 :            : SIG_DFL -- used to refer to the system default handler\n\
        1377                 :            : SIG_IGN -- used to ignore the signal\n\
        1378                 :            : NSIG -- number of defined signals\n\
        1379                 :            : SIGINT, SIGTERM, etc. -- signal numbers\n\
        1380                 :            : \n\
        1381                 :            : itimer constants:\n\
        1382                 :            : ITIMER_REAL -- decrements in real time, and delivers SIGALRM upon\n\
        1383                 :            :                expiration\n\
        1384                 :            : ITIMER_VIRTUAL -- decrements only when the process is executing,\n\
        1385                 :            :                and delivers SIGVTALRM upon expiration\n\
        1386                 :            : ITIMER_PROF -- decrements both when the process is executing and\n\
        1387                 :            :                when the system is executing on behalf of the process.\n\
        1388                 :            :                Coupled with ITIMER_VIRTUAL, this timer is usually\n\
        1389                 :            :                used to profile the time spent by the application\n\
        1390                 :            :                in user and kernel space. SIGPROF is delivered upon\n\
        1391                 :            :                expiration.\n\
        1392                 :            : \n\n\
        1393                 :            : *** IMPORTANT NOTICE ***\n\
        1394                 :            : A signal handler function is called with two arguments:\n\
        1395                 :            : the first is the signal number, the second is the interrupted stack frame.");
        1396                 :            :
        1397                 :            :
        1398                 :            :
        1399                 :            : static int
        1400                 :          5 : signal_add_constants(PyObject *module)
        1401                 :            : {
        1402         [ -  + ]:          5 :     if (PyModule_AddIntConstant(module, "NSIG", Py_NSIG) < 0) {
        1403                 :          0 :         return -1;
        1404                 :            :     }
        1405                 :            :
        1406                 :            : #define ADD_INT_MACRO(macro) \
        1407                 :            :     if (PyModule_AddIntConstant(module, #macro, macro) < 0) { \
        1408                 :            :         return -1; \
        1409                 :            :     }
        1410                 :            :
        1411                 :            :     // SIG_xxx pthread_sigmask() constants
        1412                 :            : #ifdef SIG_BLOCK
        1413         [ -  + ]:          5 :     ADD_INT_MACRO(SIG_BLOCK);
        1414                 :            : #endif
        1415                 :            : #ifdef SIG_UNBLOCK
        1416         [ -  + ]:          5 :     ADD_INT_MACRO(SIG_UNBLOCK);
        1417                 :            : #endif
        1418                 :            : #ifdef SIG_SETMASK
        1419         [ -  + ]:          5 :     ADD_INT_MACRO(SIG_SETMASK);
        1420                 :            : #endif
        1421                 :            :
        1422                 :            :     // SIGxxx signal number constants
        1423                 :            : #ifdef SIGHUP
        1424         [ -  + ]:          5 :     ADD_INT_MACRO(SIGHUP);
        1425                 :            : #endif
        1426                 :            : #ifdef SIGINT
        1427         [ -  + ]:          5 :     ADD_INT_MACRO(SIGINT);
        1428                 :            : #endif
        1429                 :            : #ifdef SIGBREAK
        1430                 :            :     ADD_INT_MACRO(SIGBREAK);
        1431                 :            : #endif
        1432                 :            : #ifdef SIGQUIT
        1433         [ -  + ]:          5 :     ADD_INT_MACRO(SIGQUIT);
        1434                 :            : #endif
        1435                 :            : #ifdef SIGILL
        1436         [ -  + ]:          5 :     ADD_INT_MACRO(SIGILL);
        1437                 :            : #endif
        1438                 :            : #ifdef SIGTRAP
        1439         [ -  + ]:          5 :     ADD_INT_MACRO(SIGTRAP);
        1440                 :            : #endif
        1441                 :            : #ifdef SIGIOT
        1442         [ -  + ]:          5 :     ADD_INT_MACRO(SIGIOT);
        1443                 :            : #endif
        1444                 :            : #ifdef SIGABRT
        1445         [ -  + ]:          5 :     ADD_INT_MACRO(SIGABRT);
        1446                 :            : #endif
        1447                 :            : #ifdef SIGEMT
        1448                 :            :     ADD_INT_MACRO(SIGEMT);
        1449                 :            : #endif
        1450                 :            : #ifdef SIGFPE
        1451         [ -  + ]:          5 :     ADD_INT_MACRO(SIGFPE);
        1452                 :            : #endif
        1453                 :            : #ifdef SIGKILL
        1454         [ -  + ]:          5 :     ADD_INT_MACRO(SIGKILL);
        1455                 :            : #endif
        1456                 :            : #ifdef SIGBUS
        1457         [ -  + ]:          5 :     ADD_INT_MACRO(SIGBUS);
        1458                 :            : #endif
        1459                 :            : #ifdef SIGSEGV
        1460         [ -  + ]:          5 :     ADD_INT_MACRO(SIGSEGV);
        1461                 :            : #endif
        1462                 :            : #ifdef SIGSYS
        1463         [ -  + ]:          5 :     ADD_INT_MACRO(SIGSYS);
        1464                 :            : #endif
        1465                 :            : #ifdef SIGPIPE
        1466         [ -  + ]:          5 :     ADD_INT_MACRO(SIGPIPE);
        1467                 :            : #endif
        1468                 :            : #ifdef SIGALRM
        1469         [ -  + ]:          5 :     ADD_INT_MACRO(SIGALRM);
        1470                 :            : #endif
        1471                 :            : #ifdef SIGTERM
        1472         [ -  + ]:          5 :     ADD_INT_MACRO(SIGTERM);
        1473                 :            : #endif
        1474                 :            : #ifdef SIGUSR1
        1475         [ -  + ]:          5 :     ADD_INT_MACRO(SIGUSR1);
        1476                 :            : #endif
        1477                 :            : #ifdef SIGUSR2
        1478         [ -  + ]:          5 :     ADD_INT_MACRO(SIGUSR2);
        1479                 :            : #endif
        1480                 :            : #ifdef SIGCLD
        1481         [ -  + ]:          5 :     ADD_INT_MACRO(SIGCLD);
        1482                 :            : #endif
        1483                 :            : #ifdef SIGCHLD
        1484         [ -  + ]:          5 :     ADD_INT_MACRO(SIGCHLD);
        1485                 :            : #endif
        1486                 :            : #ifdef SIGPWR
        1487         [ -  + ]:          5 :     ADD_INT_MACRO(SIGPWR);
        1488                 :            : #endif
        1489                 :            : #ifdef SIGIO
        1490         [ -  + ]:          5 :     ADD_INT_MACRO(SIGIO);
        1491                 :            : #endif
        1492                 :            : #ifdef SIGURG
        1493         [ -  + ]:          5 :     ADD_INT_MACRO(SIGURG);
        1494                 :            : #endif
        1495                 :            : #ifdef SIGWINCH
        1496         [ -  + ]:          5 :     ADD_INT_MACRO(SIGWINCH);
        1497                 :            : #endif
        1498                 :            : #ifdef SIGPOLL
        1499         [ -  + ]:          5 :     ADD_INT_MACRO(SIGPOLL);
        1500                 :            : #endif
        1501                 :            : #ifdef SIGSTOP
        1502         [ -  + ]:          5 :     ADD_INT_MACRO(SIGSTOP);
        1503                 :            : #endif
        1504                 :            : #ifdef SIGTSTP
        1505         [ -  + ]:          5 :     ADD_INT_MACRO(SIGTSTP);
        1506                 :            : #endif
        1507                 :            : #ifdef SIGCONT
        1508         [ -  + ]:          5 :     ADD_INT_MACRO(SIGCONT);
        1509                 :            : #endif
        1510                 :            : #ifdef SIGTTIN
        1511         [ -  + ]:          5 :     ADD_INT_MACRO(SIGTTIN);
        1512                 :            : #endif
        1513                 :            : #ifdef SIGTTOU
        1514         [ -  + ]:          5 :     ADD_INT_MACRO(SIGTTOU);
        1515                 :            : #endif
        1516                 :            : #ifdef SIGVTALRM
        1517         [ -  + ]:          5 :     ADD_INT_MACRO(SIGVTALRM);
        1518                 :            : #endif
        1519                 :            : #ifdef SIGPROF
        1520         [ -  + ]:          5 :     ADD_INT_MACRO(SIGPROF);
        1521                 :            : #endif
        1522                 :            : #ifdef SIGXCPU
        1523         [ -  + ]:          5 :     ADD_INT_MACRO(SIGXCPU);
        1524                 :            : #endif
        1525                 :            : #ifdef SIGXFSZ
        1526         [ -  + ]:          5 :     ADD_INT_MACRO(SIGXFSZ);
        1527                 :            : #endif
        1528                 :            : #ifdef SIGRTMIN
        1529         [ -  + ]:          5 :     ADD_INT_MACRO(SIGRTMIN);
        1530                 :            : #endif
        1531                 :            : #ifdef SIGRTMAX
        1532         [ -  + ]:          5 :     ADD_INT_MACRO(SIGRTMAX);
        1533                 :            : #endif
        1534                 :            : #ifdef SIGINFO
        1535                 :            :     ADD_INT_MACRO(SIGINFO);
        1536                 :            : #endif
        1537                 :            : #ifdef SIGSTKFLT
        1538         [ -  + ]:          5 :     ADD_INT_MACRO(SIGSTKFLT);
        1539                 :            : #endif
        1540                 :            :
        1541                 :            :     // ITIMER_xxx constants
        1542                 :            : #ifdef ITIMER_REAL
        1543         [ -  + ]:          5 :     ADD_INT_MACRO(ITIMER_REAL);
        1544                 :            : #endif
        1545                 :            : #ifdef ITIMER_VIRTUAL
        1546         [ -  + ]:          5 :     ADD_INT_MACRO(ITIMER_VIRTUAL);
        1547                 :            : #endif
        1548                 :            : #ifdef ITIMER_PROF
        1549         [ -  + ]:          5 :     ADD_INT_MACRO(ITIMER_PROF);
        1550                 :            : #endif
        1551                 :            :
        1552                 :            :     // CTRL_xxx Windows signals
        1553                 :            : #ifdef CTRL_C_EVENT
        1554                 :            :     ADD_INT_MACRO(CTRL_C_EVENT);
        1555                 :            : #endif
        1556                 :            : #ifdef CTRL_BREAK_EVENT
        1557                 :            :     ADD_INT_MACRO(CTRL_BREAK_EVENT);
        1558                 :            : #endif
        1559                 :            :
        1560                 :          5 :     return 0;
        1561                 :            :
        1562                 :            : #undef ADD_INT_MACRO
        1563                 :            : }
        1564                 :            :
        1565                 :            :
        1566                 :            : static int
        1567                 :          5 : signal_get_set_handlers(signal_state_t *state, PyObject *mod_dict)
        1568                 :            : {
        1569                 :            :     // Get signal handlers
        1570         [ +  + ]:        325 :     for (int signum = 1; signum < Py_NSIG; signum++) {
        1571                 :        320 :         void (*c_handler)(int) = PyOS_getsig(signum);
        1572                 :            :         PyObject *func;
        1573         [ +  + ]:        320 :         if (c_handler == SIG_DFL) {
        1574                 :        299 :             func = state->default_handler;
        1575                 :            :         }
        1576         [ +  + ]:         21 :         else if (c_handler == SIG_IGN) {
        1577                 :         10 :             func = state->ignore_handler;
        1578                 :            :         }
        1579                 :            :         else {
        1580                 :         11 :             func = Py_None; // None of our business
        1581                 :            :         }
        1582                 :            :         // If signal_module_exec() is called more than one, we must
        1583                 :            :         // clear the strong reference to the previous function.
        1584                 :        320 :         PyObject* old_func = get_handler(signum);
        1585                 :        320 :         set_handler(signum, Py_NewRef(func));
        1586                 :        320 :         Py_XDECREF(old_func);
        1587                 :            :     }
        1588                 :            :
        1589                 :            :     // Install Python SIGINT handler which raises KeyboardInterrupt
        1590                 :          5 :     PyObject* sigint_func = get_handler(SIGINT);
        1591         [ +  + ]:          5 :     if (sigint_func == state->default_handler) {
        1592                 :          4 :         PyObject *int_handler = PyMapping_GetItemString(mod_dict,
        1593                 :            :                                                         "default_int_handler");
        1594         [ -  + ]:          4 :         if (!int_handler) {
        1595                 :          0 :             return -1;
        1596                 :            :         }
        1597                 :            :
        1598                 :          4 :         set_handler(SIGINT, int_handler);
        1599                 :          4 :         Py_DECREF(sigint_func);
        1600                 :          4 :         PyOS_setsig(SIGINT, signal_handler);
        1601                 :            :     }
        1602                 :          5 :     return 0;
        1603                 :            : }
        1604                 :            :
        1605                 :            :
        1606                 :            : static int
        1607                 :          5 : signal_module_exec(PyObject *m)
        1608                 :            : {
        1609                 :            :     assert(!PyErr_Occurred());
        1610                 :            :
        1611                 :          5 :     signal_state_t *state = &signal_global_state;
        1612                 :          5 :     _signal_module_state *modstate = get_signal_state(m);
        1613                 :            :
        1614                 :            :     // XXX For proper isolation, these values must be guaranteed
        1615                 :            :     // to be effectively const (e.g. immortal).
        1616                 :          5 :     modstate->default_handler = state->default_handler;  // borrowed ref
        1617                 :          5 :     modstate->ignore_handler = state->ignore_handler;  // borrowed ref
        1618                 :            :
        1619                 :            : #ifdef PYHAVE_ITIMER_ERROR
        1620                 :          5 :     modstate->itimer_error = PyErr_NewException("signal.itimer_error",
        1621                 :            :                                                 PyExc_OSError, NULL);
        1622         [ -  + ]:          5 :     if (modstate->itimer_error == NULL) {
        1623                 :          0 :         return -1;
        1624                 :            :     }
        1625                 :            : #endif
        1626                 :            :
        1627         [ -  + ]:          5 :     if (signal_add_constants(m) < 0) {
        1628                 :          0 :         return -1;
        1629                 :            :     }
        1630                 :            :
        1631                 :            :     /* Add some symbolic constants to the module */
        1632                 :          5 :     PyObject *d = PyModule_GetDict(m);
        1633         [ -  + ]:          5 :     if (PyDict_SetItemString(d, "SIG_DFL", state->default_handler) < 0) {
        1634                 :          0 :         return -1;
        1635                 :            :     }
        1636         [ -  + ]:          5 :     if (PyDict_SetItemString(d, "SIG_IGN", state->ignore_handler) < 0) {
        1637                 :          0 :         return -1;
        1638                 :            :     }
        1639                 :            : #ifdef PYHAVE_ITIMER_ERROR
        1640         [ -  + ]:          5 :     if (PyDict_SetItemString(d, "ItimerError", modstate->itimer_error) < 0) {
        1641                 :          0 :         return -1;
        1642                 :            :     }
        1643                 :            : #endif
        1644                 :            :
        1645                 :            : #if defined(HAVE_SIGWAITINFO) || defined(HAVE_SIGTIMEDWAIT)
        1646                 :          5 :     modstate->siginfo_type = PyStructSequence_NewType(&struct_siginfo_desc);
        1647         [ -  + ]:          5 :     if (modstate->siginfo_type == NULL) {
        1648                 :          0 :         return -1;
        1649                 :            :     }
        1650                 :            : #endif
        1651                 :            : #if defined(HAVE_SIGWAITINFO) || defined(HAVE_SIGTIMEDWAIT)
        1652         [ -  + ]:          5 :     if (PyModule_AddType(m, modstate->siginfo_type) < 0) {
        1653                 :          0 :         return -1;
        1654                 :            :     }
        1655                 :            : #endif
        1656                 :            :
        1657                 :          5 :     PyThreadState *tstate = _PyThreadState_GET();
        1658         [ +  - ]:          5 :     if (_Py_IsMainInterpreter(tstate->interp)) {
        1659         [ -  + ]:          5 :         if (signal_get_set_handlers(state, d) < 0) {
        1660                 :          0 :             return -1;
        1661                 :            :         }
        1662                 :            :     }
        1663                 :            :
        1664                 :            :     assert(!PyErr_Occurred());
        1665                 :          5 :     return 0;
        1666                 :            : }
        1667                 :            :
        1668                 :            :
        1669                 :            : #ifdef PYHAVE_ITIMER_ERROR
        1670                 :            : static int
        1671                 :         64 : _signal_module_traverse(PyObject *module, visitproc visit, void *arg)
        1672                 :            : {
        1673                 :         64 :     _signal_module_state *state = get_signal_state(module);
        1674   [ +  -  -  + ]:         64 :     Py_VISIT(state->itimer_error);
        1675   [ +  -  -  + ]:         64 :     Py_VISIT(state->siginfo_type);
        1676                 :         64 :     return 0;
        1677                 :            : }
        1678                 :            :
        1679                 :            : static int
        1680                 :          9 : _signal_module_clear(PyObject *module)
        1681                 :            : {
        1682                 :          9 :     _signal_module_state *state = get_signal_state(module);
        1683         [ +  + ]:          9 :     Py_CLEAR(state->itimer_error);
        1684         [ +  + ]:          9 :     Py_CLEAR(state->siginfo_type);
        1685                 :          9 :     return 0;
        1686                 :            : }
        1687                 :            :
        1688                 :            : static void
        1689                 :          5 : _signal_module_free(void *module)
        1690                 :            : {
        1691                 :          5 :     _signal_module_clear((PyObject *)module);
        1692                 :          5 : }
        1693                 :            : #endif  // PYHAVE_ITIMER_ERROR
        1694                 :            :
        1695                 :            :
        1696                 :            : static PyModuleDef_Slot signal_slots[] = {
        1697                 :            :     {Py_mod_exec, signal_module_exec},
        1698                 :            :     {0, NULL}
        1699                 :            : };
        1700                 :            :
        1701                 :            : static struct PyModuleDef signal_module = {
        1702                 :            :     PyModuleDef_HEAD_INIT,
        1703                 :            :     "_signal",
        1704                 :            :     .m_doc = module_doc,
        1705                 :            :     .m_size = sizeof(_signal_module_state),
        1706                 :            :     .m_methods = signal_methods,
        1707                 :            :     .m_slots = signal_slots,
        1708                 :            : #ifdef PYHAVE_ITIMER_ERROR
        1709                 :            :     .m_traverse = _signal_module_traverse,
        1710                 :            :     .m_clear = _signal_module_clear,
        1711                 :            :     .m_free = _signal_module_free,
        1712                 :            : #endif
        1713                 :            : };
        1714                 :            :
        1715                 :            :
        1716                 :            : PyMODINIT_FUNC
        1717                 :          5 : PyInit__signal(void)
        1718                 :            : {
        1719                 :          5 :     return PyModuleDef_Init(&signal_module);
        1720                 :            : }
        1721                 :            :
        1722                 :            :
        1723                 :            : void
        1724                 :         25 : _PySignal_Fini(void)
        1725                 :            : {
        1726                 :         25 :     signal_state_t *state = &signal_global_state;
        1727                 :            :
        1728                 :            :     // Restore default signals and clear handlers
        1729         [ +  + ]:       1625 :     for (int signum = 1; signum < Py_NSIG; signum++) {
        1730                 :       1600 :         PyObject *func = get_handler(signum);
        1731                 :       1600 :         _Py_atomic_store_relaxed(&Handlers[signum].tripped, 0);
        1732                 :       1600 :         set_handler(signum, NULL);
        1733         [ +  + ]:       1600 :         if (func != NULL
        1734         [ +  + ]:        256 :             && func != Py_None
        1735         [ +  + ]:        247 :             && !compare_handler(func, state->default_handler)
        1736         [ +  + ]:         11 :             && !compare_handler(func, state->ignore_handler))
        1737                 :            :         {
        1738                 :          3 :             PyOS_setsig(signum, SIG_DFL);
        1739                 :            :         }
        1740                 :       1600 :         Py_XDECREF(func);
        1741                 :            :     }
        1742                 :            :
        1743                 :            : #ifdef MS_WINDOWS
        1744                 :            :     if (state->sigint_event != NULL) {
        1745                 :            :         CloseHandle((HANDLE)state->sigint_event);
        1746                 :            :         state->sigint_event = NULL;
        1747                 :            :     }
        1748                 :            : #endif
        1749                 :            :
        1750         [ +  - ]:         25 :     Py_CLEAR(state->default_handler);
        1751         [ +  - ]:         25 :     Py_CLEAR(state->ignore_handler);
        1752                 :         25 : }
        1753                 :            :
        1754                 :            :
        1755                 :            : /* Declared in pyerrors.h */
        1756                 :            : int
        1757                 :    4802624 : PyErr_CheckSignals(void)
        1758                 :            : {
        1759                 :    4802624 :     PyThreadState *tstate = _PyThreadState_GET();
        1760                 :            :
        1761                 :            :     /* Opportunistically check if the GC is scheduled to run and run it
        1762                 :            :        if we have a request. This is done here because native code needs
        1763                 :            :        to call this API if is going to run for some time without executing
        1764                 :            :        Python code to ensure signals are handled. Checking for the GC here
        1765                 :            :        allows long running native code to clean cycles created using the C-API
        1766                 :            :        even if it doesn't run the evaluation loop */
        1767                 :    4802624 :     struct _ceval_state *interp_ceval_state = &tstate->interp->ceval;
        1768         [ +  + ]:    4802624 :     if (_Py_atomic_load_relaxed(&interp_ceval_state->gc_scheduled)) {
        1769                 :          2 :         _Py_atomic_store_relaxed(&interp_ceval_state->gc_scheduled, 0);
        1770                 :          2 :         _Py_RunGC(tstate);
        1771                 :            :     }
        1772                 :            :
        1773         [ -  + ]:    4802624 :     if (!_Py_ThreadCanHandleSignals(tstate->interp)) {
        1774                 :          0 :         return 0;
        1775                 :            :     }
        1776                 :            :
        1777                 :    4802624 :     return _PyErr_CheckSignalsTstate(tstate);
        1778                 :            : }
        1779                 :            :
        1780                 :            :
        1781                 :            : /* Declared in cpython/pyerrors.h */
        1782                 :            : int
        1783                 :    4802646 : _PyErr_CheckSignalsTstate(PyThreadState *tstate)
        1784                 :            : {
        1785                 :            :     _Py_CHECK_EMSCRIPTEN_SIGNALS();
        1786         [ +  - ]:    4802646 :     if (!_Py_atomic_load(&is_tripped)) {
        1787                 :    4802646 :         return 0;
        1788                 :            :     }
        1789                 :            :
        1790                 :            :     /*
        1791                 :            :      * The is_tripped variable is meant to speed up the calls to
        1792                 :            :      * PyErr_CheckSignals (both directly or via pending calls) when no
        1793                 :            :      * signal has arrived. This variable is set to 1 when a signal arrives
        1794                 :            :      * and it is set to 0 here, when we know some signals arrived. This way
        1795                 :            :      * we can run the registered handlers with no signals blocked.
        1796                 :            :      *
        1797                 :            :      * NOTE: with this approach we can have a situation where is_tripped is
        1798                 :            :      *       1 but we have no more signals to handle (Handlers[i].tripped
        1799                 :            :      *       is 0 for every signal i). This won't do us any harm (except
        1800                 :            :      *       we're gonna spent some cycles for nothing). This happens when
        1801                 :            :      *       we receive a signal i after we zero is_tripped and before we
        1802                 :            :      *       check Handlers[i].tripped.
        1803                 :            :      */
        1804                 :          0 :     _Py_atomic_store(&is_tripped, 0);
        1805                 :            :
        1806                 :          0 :     _PyInterpreterFrame *frame = _PyThreadState_GetFrame(tstate);
        1807                 :          0 :     signal_state_t *state = &signal_global_state;
        1808         [ #  # ]:          0 :     for (int i = 1; i < Py_NSIG; i++) {
        1809         [ #  # ]:          0 :         if (!_Py_atomic_load_relaxed(&Handlers[i].tripped)) {
        1810                 :          0 :             continue;
        1811                 :            :         }
        1812                 :          0 :         _Py_atomic_store_relaxed(&Handlers[i].tripped, 0);
        1813                 :            :
        1814                 :            :         /* Signal handlers can be modified while a signal is received,
        1815                 :            :          * and therefore the fact that trip_signal() or PyErr_SetInterrupt()
        1816                 :            :          * was called doesn't guarantee that there is still a Python
        1817                 :            :          * signal handler for it by the time PyErr_CheckSignals() is called
        1818                 :            :          * (see bpo-43406).
        1819                 :            :          */
        1820                 :          0 :         PyObject *func = get_handler(i);
        1821   [ #  #  #  #  :          0 :         if (func == NULL || func == Py_None ||
                       #  # ]
        1822         [ #  # ]:          0 :             compare_handler(func, state->ignore_handler) ||
        1823                 :          0 :             compare_handler(func, state->default_handler)) {
        1824                 :            :             /* No Python signal handler due to aforementioned race condition.
        1825                 :            :              * We can't call raise() as it would break the assumption
        1826                 :            :              * that PyErr_SetInterrupt() only *simulates* an incoming
        1827                 :            :              * signal (i.e. it will never kill the process).
        1828                 :            :              * We also don't want to interrupt user code with a cryptic
        1829                 :            :              * asynchronous exception, so instead just write out an
        1830                 :            :              * unraisable error.
        1831                 :            :              */
        1832                 :          0 :             PyErr_Format(PyExc_OSError,
        1833                 :            :                          "Signal %i ignored due to race condition",
        1834                 :            :                          i);
        1835                 :          0 :             PyErr_WriteUnraisable(Py_None);
        1836                 :          0 :             continue;
        1837                 :            :         }
        1838                 :          0 :         PyObject *arglist = NULL;
        1839         [ #  # ]:          0 :         if (frame == NULL) {
        1840                 :          0 :             arglist = Py_BuildValue("(iO)", i, Py_None);
        1841                 :            :         }
        1842                 :            :         else {
        1843                 :          0 :             PyFrameObject *f = _PyFrame_GetFrameObject(frame);
        1844         [ #  # ]:          0 :             if (f != NULL) {
        1845                 :          0 :                 arglist = Py_BuildValue("(iO)", i, f);
        1846                 :            :             }
        1847                 :            :         }
        1848                 :            :         PyObject *result;
        1849         [ #  # ]:          0 :         if (arglist) {
        1850                 :          0 :             result = _PyObject_Call(tstate, func, arglist, NULL);
        1851                 :          0 :             Py_DECREF(arglist);
        1852                 :            :         }
        1853                 :            :         else {
        1854                 :          0 :             result = NULL;
        1855                 :            :         }
        1856         [ #  # ]:          0 :         if (!result) {
        1857                 :            :             /* On error, re-schedule a call to _PyErr_CheckSignalsTstate() */
        1858                 :          0 :             _Py_atomic_store(&is_tripped, 1);
        1859                 :          0 :             return -1;
        1860                 :            :         }
        1861                 :            :
        1862                 :          0 :         Py_DECREF(result);
        1863                 :            :     }
        1864                 :            :
        1865                 :          0 :     return 0;
        1866                 :            : }
        1867                 :            :
        1868                 :            :
        1869                 :            :
        1870                 :            : int
        1871                 :          0 : _PyErr_CheckSignals(void)
        1872                 :            : {
        1873                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
        1874                 :          0 :     return _PyErr_CheckSignalsTstate(tstate);
        1875                 :            : }
        1876                 :            :
        1877                 :            :
        1878                 :            : /* Simulate the effect of a signal arriving. The next time PyErr_CheckSignals
        1879                 :            :    is called,  the corresponding Python signal handler will be raised.
        1880                 :            :
        1881                 :            :    Missing signal handler for the given signal number is silently ignored. */
        1882                 :            : int
        1883                 :          0 : PyErr_SetInterruptEx(int signum)
        1884                 :            : {
        1885   [ #  #  #  # ]:          0 :     if (signum < 1 || signum >= Py_NSIG) {
        1886                 :          0 :         return -1;
        1887                 :            :     }
        1888                 :            :
        1889                 :          0 :     signal_state_t *state = &signal_global_state;
        1890                 :          0 :     PyObject *func = get_handler(signum);
        1891         [ #  # ]:          0 :     if (!compare_handler(func, state->ignore_handler)
        1892         [ #  # ]:          0 :             && !compare_handler(func, state->default_handler)) {
        1893                 :          0 :         trip_signal(signum);
        1894                 :            :     }
        1895                 :          0 :     return 0;
        1896                 :            : }
        1897                 :            :
        1898                 :            : void
        1899                 :          0 : PyErr_SetInterrupt(void)
        1900                 :            : {
        1901                 :          0 :     (void) PyErr_SetInterruptEx(SIGINT);
        1902                 :          0 : }
        1903                 :            :
        1904                 :            : static int
        1905                 :          4 : signal_install_handlers(void)
        1906                 :            : {
        1907                 :            : #ifdef SIGPIPE
        1908                 :          4 :     PyOS_setsig(SIGPIPE, SIG_IGN);
        1909                 :            : #endif
        1910                 :            : #ifdef SIGXFZ
        1911                 :            :     PyOS_setsig(SIGXFZ, SIG_IGN);
        1912                 :            : #endif
        1913                 :            : #ifdef SIGXFSZ
        1914                 :          4 :     PyOS_setsig(SIGXFSZ, SIG_IGN);
        1915                 :            : #endif
        1916                 :            :
        1917                 :            :     // Import _signal to install the Python SIGINT handler
        1918                 :          4 :     PyObject *module = PyImport_ImportModule("_signal");
        1919         [ -  + ]:          4 :     if (!module) {
        1920                 :          0 :         return -1;
        1921                 :            :     }
        1922                 :          4 :     Py_DECREF(module);
        1923                 :            :
        1924                 :          4 :     return 0;
        1925                 :            : }
        1926                 :            :
        1927                 :            :
        1928                 :            : /* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL.
        1929                 :            :  *
        1930                 :            :  * All of the code in this function must only use async-signal-safe functions,
        1931                 :            :  * listed at `man 7 signal` or
        1932                 :            :  * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html.
        1933                 :            :  *
        1934                 :            :  * If this function is updated, update also _posix_spawn() of subprocess.py.
        1935                 :            :  */
        1936                 :            : void
        1937                 :          0 : _Py_RestoreSignals(void)
        1938                 :            : {
        1939                 :            : #ifdef SIGPIPE
        1940                 :          0 :     PyOS_setsig(SIGPIPE, SIG_DFL);
        1941                 :            : #endif
        1942                 :            : #ifdef SIGXFZ
        1943                 :            :     PyOS_setsig(SIGXFZ, SIG_DFL);
        1944                 :            : #endif
        1945                 :            : #ifdef SIGXFSZ
        1946                 :          0 :     PyOS_setsig(SIGXFSZ, SIG_DFL);
        1947                 :            : #endif
        1948                 :          0 : }
        1949                 :            :
        1950                 :            :
        1951                 :            : int
        1952                 :         25 : _PySignal_Init(int install_signal_handlers)
        1953                 :            : {
        1954                 :         25 :     signal_state_t *state = &signal_global_state;
        1955                 :            :
        1956                 :         25 :     state->default_handler = PyLong_FromVoidPtr((void *)SIG_DFL);
        1957         [ -  + ]:         25 :     if (state->default_handler == NULL) {
        1958                 :          0 :         return -1;
        1959                 :            :     }
        1960                 :            :
        1961                 :         25 :     state->ignore_handler = PyLong_FromVoidPtr((void *)SIG_IGN);
        1962         [ -  + ]:         25 :     if (state->ignore_handler == NULL) {
        1963                 :          0 :         return -1;
        1964                 :            :     }
        1965                 :            :
        1966                 :            : #ifdef MS_WINDOWS
        1967                 :            :     /* Create manual-reset event, initially unset */
        1968                 :            :     state->sigint_event = (void *)CreateEvent(NULL, TRUE, FALSE, FALSE);
        1969                 :            :     if (state->sigint_event == NULL) {
        1970                 :            :         PyErr_SetFromWindowsErr(0);
        1971                 :            :         return -1;
        1972                 :            :     }
        1973                 :            : #endif
        1974                 :            :
        1975         [ +  + ]:       1625 :     for (int signum = 1; signum < Py_NSIG; signum++) {
        1976                 :       1600 :         _Py_atomic_store_relaxed(&Handlers[signum].tripped, 0);
        1977                 :            :     }
        1978                 :            :
        1979         [ +  + ]:         25 :     if (install_signal_handlers) {
        1980         [ -  + ]:          4 :         if (signal_install_handlers() < 0) {
        1981                 :          0 :             return -1;
        1982                 :            :         }
        1983                 :            :     }
        1984                 :            :
        1985                 :         25 :     return 0;
        1986                 :            : }
        1987                 :            :
        1988                 :            :
        1989                 :            : // The caller doesn't have to hold the GIL
        1990                 :            : int
        1991                 :          0 : _PyOS_InterruptOccurred(PyThreadState *tstate)
        1992                 :            : {
        1993                 :          0 :     _Py_EnsureTstateNotNULL(tstate);
        1994         [ #  # ]:          0 :     if (!_Py_ThreadCanHandleSignals(tstate->interp)) {
        1995                 :          0 :         return 0;
        1996                 :            :     }
        1997                 :            :
        1998         [ #  # ]:          0 :     if (!_Py_atomic_load_relaxed(&Handlers[SIGINT].tripped)) {
        1999                 :          0 :         return 0;
        2000                 :            :     }
        2001                 :            :
        2002                 :          0 :     _Py_atomic_store_relaxed(&Handlers[SIGINT].tripped, 0);
        2003                 :          0 :     return 1;
        2004                 :            : }
        2005                 :            :
        2006                 :            :
        2007                 :            : // The caller must to hold the GIL
        2008                 :            : int
        2009                 :          0 : PyOS_InterruptOccurred(void)
        2010                 :            : {
        2011                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
        2012                 :          0 :     return _PyOS_InterruptOccurred(tstate);
        2013                 :            : }
        2014                 :            :
        2015                 :            :
        2016                 :            : #ifdef HAVE_FORK
        2017                 :            : static void
        2018                 :          0 : _clear_pending_signals(void)
        2019                 :            : {
        2020         [ #  # ]:          0 :     if (!_Py_atomic_load(&is_tripped)) {
        2021                 :          0 :         return;
        2022                 :            :     }
        2023                 :            :
        2024                 :          0 :     _Py_atomic_store(&is_tripped, 0);
        2025         [ #  # ]:          0 :     for (int i = 1; i < Py_NSIG; ++i) {
        2026                 :          0 :         _Py_atomic_store_relaxed(&Handlers[i].tripped, 0);
        2027                 :            :     }
        2028                 :            : }
        2029                 :            :
        2030                 :            : void
        2031                 :          0 : _PySignal_AfterFork(void)
        2032                 :            : {
        2033                 :            :     /* Clear the signal flags after forking so that they aren't handled
        2034                 :            :      * in both processes if they came in just before the fork() but before
        2035                 :            :      * the interpreter had an opportunity to call the handlers.  issue9535. */
        2036                 :          0 :     _clear_pending_signals();
        2037                 :          0 : }
        2038                 :            : #endif   /* HAVE_FORK */
        2039                 :            :
        2040                 :            :
        2041                 :            : int
        2042                 :          0 : _PyOS_IsMainThread(void)
        2043                 :            : {
        2044                 :          0 :     PyInterpreterState *interp = _PyInterpreterState_GET();
        2045                 :          0 :     return _Py_ThreadCanHandleSignals(interp);
        2046                 :            : }
        2047                 :            :
        2048                 :            : #ifdef MS_WINDOWS
        2049                 :            : /* Returns a manual-reset event which gets tripped whenever
        2050                 :            :    SIGINT is received.
        2051                 :            :
        2052                 :            :    Python.h does not include windows.h so we do cannot use HANDLE
        2053                 :            :    as the return type of this function.  We use void* instead. */
        2054                 :            : void *_PyOS_SigintEvent(void)
        2055                 :            : {
        2056                 :            :     signal_state_t *state = &signal_global_state;
        2057                 :            :     return state->sigint_event;
        2058                 :            : }
        2059                 :            : #endif

Generated by: LCOV version 1.14