1/*[clinic input]
2preserve
3[clinic start generated code]*/
4
5PyDoc_STRVAR(signal_default_int_handler__doc__,
6"default_int_handler($module, signalnum, frame, /)\n"
7"--\n"
8"\n"
9"The default handler for SIGINT installed by Python.\n"
10"\n"
11"It raises KeyboardInterrupt.");
12
13#define SIGNAL_DEFAULT_INT_HANDLER_METHODDEF    \
14    {"default_int_handler", _PyCFunction_CAST(signal_default_int_handler), METH_FASTCALL, signal_default_int_handler__doc__},
15
16static PyObject *
17signal_default_int_handler_impl(PyObject *module, int signalnum,
18                                PyObject *frame);
19
20static PyObject *
21signal_default_int_handler(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
22{
23    PyObject *return_value = NULL;
24    int signalnum;
25    PyObject *frame;
26
27    if (!_PyArg_CheckPositional("default_int_handler", nargs, 2, 2)) {
28        goto exit;
29    }
30    signalnum = _PyLong_AsInt(args[0]);
31    if (signalnum == -1 && PyErr_Occurred()) {
32        goto exit;
33    }
34    frame = args[1];
35    return_value = signal_default_int_handler_impl(module, signalnum, frame);
36
37exit:
38    return return_value;
39}
40
41#if defined(HAVE_ALARM)
42
43PyDoc_STRVAR(signal_alarm__doc__,
44"alarm($module, seconds, /)\n"
45"--\n"
46"\n"
47"Arrange for SIGALRM to arrive after the given number of seconds.");
48
49#define SIGNAL_ALARM_METHODDEF    \
50    {"alarm", (PyCFunction)signal_alarm, METH_O, signal_alarm__doc__},
51
52static long
53signal_alarm_impl(PyObject *module, int seconds);
54
55static PyObject *
56signal_alarm(PyObject *module, PyObject *arg)
57{
58    PyObject *return_value = NULL;
59    int seconds;
60    long _return_value;
61
62    seconds = _PyLong_AsInt(arg);
63    if (seconds == -1 && PyErr_Occurred()) {
64        goto exit;
65    }
66    _return_value = signal_alarm_impl(module, seconds);
67    if ((_return_value == -1) && PyErr_Occurred()) {
68        goto exit;
69    }
70    return_value = PyLong_FromLong(_return_value);
71
72exit:
73    return return_value;
74}
75
76#endif /* defined(HAVE_ALARM) */
77
78#if defined(HAVE_PAUSE)
79
80PyDoc_STRVAR(signal_pause__doc__,
81"pause($module, /)\n"
82"--\n"
83"\n"
84"Wait until a signal arrives.");
85
86#define SIGNAL_PAUSE_METHODDEF    \
87    {"pause", (PyCFunction)signal_pause, METH_NOARGS, signal_pause__doc__},
88
89static PyObject *
90signal_pause_impl(PyObject *module);
91
92static PyObject *
93signal_pause(PyObject *module, PyObject *Py_UNUSED(ignored))
94{
95    return signal_pause_impl(module);
96}
97
98#endif /* defined(HAVE_PAUSE) */
99
100PyDoc_STRVAR(signal_raise_signal__doc__,
101"raise_signal($module, signalnum, /)\n"
102"--\n"
103"\n"
104"Send a signal to the executing process.");
105
106#define SIGNAL_RAISE_SIGNAL_METHODDEF    \
107    {"raise_signal", (PyCFunction)signal_raise_signal, METH_O, signal_raise_signal__doc__},
108
109static PyObject *
110signal_raise_signal_impl(PyObject *module, int signalnum);
111
112static PyObject *
113signal_raise_signal(PyObject *module, PyObject *arg)
114{
115    PyObject *return_value = NULL;
116    int signalnum;
117
118    signalnum = _PyLong_AsInt(arg);
119    if (signalnum == -1 && PyErr_Occurred()) {
120        goto exit;
121    }
122    return_value = signal_raise_signal_impl(module, signalnum);
123
124exit:
125    return return_value;
126}
127
128PyDoc_STRVAR(signal_signal__doc__,
129"signal($module, signalnum, handler, /)\n"
130"--\n"
131"\n"
132"Set the action for the given signal.\n"
133"\n"
134"The action can be SIG_DFL, SIG_IGN, or a callable Python object.\n"
135"The previous action is returned.  See getsignal() for possible return values.\n"
136"\n"
137"*** IMPORTANT NOTICE ***\n"
138"A signal handler function is called with two arguments:\n"
139"the first is the signal number, the second is the interrupted stack frame.");
140
141#define SIGNAL_SIGNAL_METHODDEF    \
142    {"signal", _PyCFunction_CAST(signal_signal), METH_FASTCALL, signal_signal__doc__},
143
144static PyObject *
145signal_signal_impl(PyObject *module, int signalnum, PyObject *handler);
146
147static PyObject *
148signal_signal(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
149{
150    PyObject *return_value = NULL;
151    int signalnum;
152    PyObject *handler;
153
154    if (!_PyArg_CheckPositional("signal", nargs, 2, 2)) {
155        goto exit;
156    }
157    signalnum = _PyLong_AsInt(args[0]);
158    if (signalnum == -1 && PyErr_Occurred()) {
159        goto exit;
160    }
161    handler = args[1];
162    return_value = signal_signal_impl(module, signalnum, handler);
163
164exit:
165    return return_value;
166}
167
168PyDoc_STRVAR(signal_getsignal__doc__,
169"getsignal($module, signalnum, /)\n"
170"--\n"
171"\n"
172"Return the current action for the given signal.\n"
173"\n"
174"The return value can be:\n"
175"  SIG_IGN -- if the signal is being ignored\n"
176"  SIG_DFL -- if the default action for the signal is in effect\n"
177"  None    -- if an unknown handler is in effect\n"
178"  anything else -- the callable Python object used as a handler");
179
180#define SIGNAL_GETSIGNAL_METHODDEF    \
181    {"getsignal", (PyCFunction)signal_getsignal, METH_O, signal_getsignal__doc__},
182
183static PyObject *
184signal_getsignal_impl(PyObject *module, int signalnum);
185
186static PyObject *
187signal_getsignal(PyObject *module, PyObject *arg)
188{
189    PyObject *return_value = NULL;
190    int signalnum;
191
192    signalnum = _PyLong_AsInt(arg);
193    if (signalnum == -1 && PyErr_Occurred()) {
194        goto exit;
195    }
196    return_value = signal_getsignal_impl(module, signalnum);
197
198exit:
199    return return_value;
200}
201
202PyDoc_STRVAR(signal_strsignal__doc__,
203"strsignal($module, signalnum, /)\n"
204"--\n"
205"\n"
206"Return the system description of the given signal.\n"
207"\n"
208"Returns the description of signal *signalnum*, such as \"Interrupt\"\n"
209"for :const:`SIGINT`. Returns :const:`None` if *signalnum* has no\n"
210"description. Raises :exc:`ValueError` if *signalnum* is invalid.");
211
212#define SIGNAL_STRSIGNAL_METHODDEF    \
213    {"strsignal", (PyCFunction)signal_strsignal, METH_O, signal_strsignal__doc__},
214
215static PyObject *
216signal_strsignal_impl(PyObject *module, int signalnum);
217
218static PyObject *
219signal_strsignal(PyObject *module, PyObject *arg)
220{
221    PyObject *return_value = NULL;
222    int signalnum;
223
224    signalnum = _PyLong_AsInt(arg);
225    if (signalnum == -1 && PyErr_Occurred()) {
226        goto exit;
227    }
228    return_value = signal_strsignal_impl(module, signalnum);
229
230exit:
231    return return_value;
232}
233
234#if defined(HAVE_SIGINTERRUPT)
235
236PyDoc_STRVAR(signal_siginterrupt__doc__,
237"siginterrupt($module, signalnum, flag, /)\n"
238"--\n"
239"\n"
240"Change system call restart behaviour.\n"
241"\n"
242"If flag is False, system calls will be restarted when interrupted by\n"
243"signal sig, else system calls will be interrupted.");
244
245#define SIGNAL_SIGINTERRUPT_METHODDEF    \
246    {"siginterrupt", _PyCFunction_CAST(signal_siginterrupt), METH_FASTCALL, signal_siginterrupt__doc__},
247
248static PyObject *
249signal_siginterrupt_impl(PyObject *module, int signalnum, int flag);
250
251static PyObject *
252signal_siginterrupt(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
253{
254    PyObject *return_value = NULL;
255    int signalnum;
256    int flag;
257
258    if (!_PyArg_CheckPositional("siginterrupt", nargs, 2, 2)) {
259        goto exit;
260    }
261    signalnum = _PyLong_AsInt(args[0]);
262    if (signalnum == -1 && PyErr_Occurred()) {
263        goto exit;
264    }
265    flag = _PyLong_AsInt(args[1]);
266    if (flag == -1 && PyErr_Occurred()) {
267        goto exit;
268    }
269    return_value = signal_siginterrupt_impl(module, signalnum, flag);
270
271exit:
272    return return_value;
273}
274
275#endif /* defined(HAVE_SIGINTERRUPT) */
276
277#if defined(HAVE_SETITIMER)
278
279PyDoc_STRVAR(signal_setitimer__doc__,
280"setitimer($module, which, seconds, interval=0.0, /)\n"
281"--\n"
282"\n"
283"Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL or ITIMER_PROF).\n"
284"\n"
285"The timer will fire after value seconds and after that every interval seconds.\n"
286"The itimer can be cleared by setting seconds to zero.\n"
287"\n"
288"Returns old values as a tuple: (delay, interval).");
289
290#define SIGNAL_SETITIMER_METHODDEF    \
291    {"setitimer", _PyCFunction_CAST(signal_setitimer), METH_FASTCALL, signal_setitimer__doc__},
292
293static PyObject *
294signal_setitimer_impl(PyObject *module, int which, PyObject *seconds,
295                      PyObject *interval);
296
297static PyObject *
298signal_setitimer(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
299{
300    PyObject *return_value = NULL;
301    int which;
302    PyObject *seconds;
303    PyObject *interval = NULL;
304
305    if (!_PyArg_CheckPositional("setitimer", nargs, 2, 3)) {
306        goto exit;
307    }
308    which = _PyLong_AsInt(args[0]);
309    if (which == -1 && PyErr_Occurred()) {
310        goto exit;
311    }
312    seconds = args[1];
313    if (nargs < 3) {
314        goto skip_optional;
315    }
316    interval = args[2];
317skip_optional:
318    return_value = signal_setitimer_impl(module, which, seconds, interval);
319
320exit:
321    return return_value;
322}
323
324#endif /* defined(HAVE_SETITIMER) */
325
326#if defined(HAVE_GETITIMER)
327
328PyDoc_STRVAR(signal_getitimer__doc__,
329"getitimer($module, which, /)\n"
330"--\n"
331"\n"
332"Returns current value of given itimer.");
333
334#define SIGNAL_GETITIMER_METHODDEF    \
335    {"getitimer", (PyCFunction)signal_getitimer, METH_O, signal_getitimer__doc__},
336
337static PyObject *
338signal_getitimer_impl(PyObject *module, int which);
339
340static PyObject *
341signal_getitimer(PyObject *module, PyObject *arg)
342{
343    PyObject *return_value = NULL;
344    int which;
345
346    which = _PyLong_AsInt(arg);
347    if (which == -1 && PyErr_Occurred()) {
348        goto exit;
349    }
350    return_value = signal_getitimer_impl(module, which);
351
352exit:
353    return return_value;
354}
355
356#endif /* defined(HAVE_GETITIMER) */
357
358#if defined(HAVE_SIGSET_T) && defined(PYPTHREAD_SIGMASK)
359
360PyDoc_STRVAR(signal_pthread_sigmask__doc__,
361"pthread_sigmask($module, how, mask, /)\n"
362"--\n"
363"\n"
364"Fetch and/or change the signal mask of the calling thread.");
365
366#define SIGNAL_PTHREAD_SIGMASK_METHODDEF    \
367    {"pthread_sigmask", _PyCFunction_CAST(signal_pthread_sigmask), METH_FASTCALL, signal_pthread_sigmask__doc__},
368
369static PyObject *
370signal_pthread_sigmask_impl(PyObject *module, int how, sigset_t mask);
371
372static PyObject *
373signal_pthread_sigmask(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
374{
375    PyObject *return_value = NULL;
376    int how;
377    sigset_t mask;
378
379    if (!_PyArg_CheckPositional("pthread_sigmask", nargs, 2, 2)) {
380        goto exit;
381    }
382    how = _PyLong_AsInt(args[0]);
383    if (how == -1 && PyErr_Occurred()) {
384        goto exit;
385    }
386    if (!_Py_Sigset_Converter(args[1], &mask)) {
387        goto exit;
388    }
389    return_value = signal_pthread_sigmask_impl(module, how, mask);
390
391exit:
392    return return_value;
393}
394
395#endif /* defined(HAVE_SIGSET_T) && defined(PYPTHREAD_SIGMASK) */
396
397#if defined(HAVE_SIGSET_T) && defined(HAVE_SIGPENDING)
398
399PyDoc_STRVAR(signal_sigpending__doc__,
400"sigpending($module, /)\n"
401"--\n"
402"\n"
403"Examine pending signals.\n"
404"\n"
405"Returns a set of signal numbers that are pending for delivery to\n"
406"the calling thread.");
407
408#define SIGNAL_SIGPENDING_METHODDEF    \
409    {"sigpending", (PyCFunction)signal_sigpending, METH_NOARGS, signal_sigpending__doc__},
410
411static PyObject *
412signal_sigpending_impl(PyObject *module);
413
414static PyObject *
415signal_sigpending(PyObject *module, PyObject *Py_UNUSED(ignored))
416{
417    return signal_sigpending_impl(module);
418}
419
420#endif /* defined(HAVE_SIGSET_T) && defined(HAVE_SIGPENDING) */
421
422#if defined(HAVE_SIGSET_T) && defined(HAVE_SIGWAIT)
423
424PyDoc_STRVAR(signal_sigwait__doc__,
425"sigwait($module, sigset, /)\n"
426"--\n"
427"\n"
428"Wait for a signal.\n"
429"\n"
430"Suspend execution of the calling thread until the delivery of one of the\n"
431"signals specified in the signal set sigset.  The function accepts the signal\n"
432"and returns the signal number.");
433
434#define SIGNAL_SIGWAIT_METHODDEF    \
435    {"sigwait", (PyCFunction)signal_sigwait, METH_O, signal_sigwait__doc__},
436
437static PyObject *
438signal_sigwait_impl(PyObject *module, sigset_t sigset);
439
440static PyObject *
441signal_sigwait(PyObject *module, PyObject *arg)
442{
443    PyObject *return_value = NULL;
444    sigset_t sigset;
445
446    if (!_Py_Sigset_Converter(arg, &sigset)) {
447        goto exit;
448    }
449    return_value = signal_sigwait_impl(module, sigset);
450
451exit:
452    return return_value;
453}
454
455#endif /* defined(HAVE_SIGSET_T) && defined(HAVE_SIGWAIT) */
456
457#if ((defined(HAVE_SIGFILLSET) && defined(HAVE_SIGSET_T)) || defined(MS_WINDOWS))
458
459PyDoc_STRVAR(signal_valid_signals__doc__,
460"valid_signals($module, /)\n"
461"--\n"
462"\n"
463"Return a set of valid signal numbers on this platform.\n"
464"\n"
465"The signal numbers returned by this function can be safely passed to\n"
466"functions like `pthread_sigmask`.");
467
468#define SIGNAL_VALID_SIGNALS_METHODDEF    \
469    {"valid_signals", (PyCFunction)signal_valid_signals, METH_NOARGS, signal_valid_signals__doc__},
470
471static PyObject *
472signal_valid_signals_impl(PyObject *module);
473
474static PyObject *
475signal_valid_signals(PyObject *module, PyObject *Py_UNUSED(ignored))
476{
477    return signal_valid_signals_impl(module);
478}
479
480#endif /* ((defined(HAVE_SIGFILLSET) && defined(HAVE_SIGSET_T)) || defined(MS_WINDOWS)) */
481
482#if defined(HAVE_SIGSET_T) && defined(HAVE_SIGWAITINFO)
483
484PyDoc_STRVAR(signal_sigwaitinfo__doc__,
485"sigwaitinfo($module, sigset, /)\n"
486"--\n"
487"\n"
488"Wait synchronously until one of the signals in *sigset* is delivered.\n"
489"\n"
490"Returns a struct_siginfo containing information about the signal.");
491
492#define SIGNAL_SIGWAITINFO_METHODDEF    \
493    {"sigwaitinfo", (PyCFunction)signal_sigwaitinfo, METH_O, signal_sigwaitinfo__doc__},
494
495static PyObject *
496signal_sigwaitinfo_impl(PyObject *module, sigset_t sigset);
497
498static PyObject *
499signal_sigwaitinfo(PyObject *module, PyObject *arg)
500{
501    PyObject *return_value = NULL;
502    sigset_t sigset;
503
504    if (!_Py_Sigset_Converter(arg, &sigset)) {
505        goto exit;
506    }
507    return_value = signal_sigwaitinfo_impl(module, sigset);
508
509exit:
510    return return_value;
511}
512
513#endif /* defined(HAVE_SIGSET_T) && defined(HAVE_SIGWAITINFO) */
514
515#if defined(HAVE_SIGSET_T) && defined(HAVE_SIGTIMEDWAIT)
516
517PyDoc_STRVAR(signal_sigtimedwait__doc__,
518"sigtimedwait($module, sigset, timeout, /)\n"
519"--\n"
520"\n"
521"Like sigwaitinfo(), but with a timeout.\n"
522"\n"
523"The timeout is specified in seconds, with floating point numbers allowed.");
524
525#define SIGNAL_SIGTIMEDWAIT_METHODDEF    \
526    {"sigtimedwait", _PyCFunction_CAST(signal_sigtimedwait), METH_FASTCALL, signal_sigtimedwait__doc__},
527
528static PyObject *
529signal_sigtimedwait_impl(PyObject *module, sigset_t sigset,
530                         PyObject *timeout_obj);
531
532static PyObject *
533signal_sigtimedwait(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
534{
535    PyObject *return_value = NULL;
536    sigset_t sigset;
537    PyObject *timeout_obj;
538
539    if (!_PyArg_CheckPositional("sigtimedwait", nargs, 2, 2)) {
540        goto exit;
541    }
542    if (!_Py_Sigset_Converter(args[0], &sigset)) {
543        goto exit;
544    }
545    timeout_obj = args[1];
546    return_value = signal_sigtimedwait_impl(module, sigset, timeout_obj);
547
548exit:
549    return return_value;
550}
551
552#endif /* defined(HAVE_SIGSET_T) && defined(HAVE_SIGTIMEDWAIT) */
553
554#if defined(HAVE_PTHREAD_KILL)
555
556PyDoc_STRVAR(signal_pthread_kill__doc__,
557"pthread_kill($module, thread_id, signalnum, /)\n"
558"--\n"
559"\n"
560"Send a signal to a thread.");
561
562#define SIGNAL_PTHREAD_KILL_METHODDEF    \
563    {"pthread_kill", _PyCFunction_CAST(signal_pthread_kill), METH_FASTCALL, signal_pthread_kill__doc__},
564
565static PyObject *
566signal_pthread_kill_impl(PyObject *module, unsigned long thread_id,
567                         int signalnum);
568
569static PyObject *
570signal_pthread_kill(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
571{
572    PyObject *return_value = NULL;
573    unsigned long thread_id;
574    int signalnum;
575
576    if (!_PyArg_CheckPositional("pthread_kill", nargs, 2, 2)) {
577        goto exit;
578    }
579    if (!PyLong_Check(args[0])) {
580        _PyArg_BadArgument("pthread_kill", "argument 1", "int", args[0]);
581        goto exit;
582    }
583    thread_id = PyLong_AsUnsignedLongMask(args[0]);
584    signalnum = _PyLong_AsInt(args[1]);
585    if (signalnum == -1 && PyErr_Occurred()) {
586        goto exit;
587    }
588    return_value = signal_pthread_kill_impl(module, thread_id, signalnum);
589
590exit:
591    return return_value;
592}
593
594#endif /* defined(HAVE_PTHREAD_KILL) */
595
596#if (defined(__linux__) && defined(__NR_pidfd_send_signal))
597
598PyDoc_STRVAR(signal_pidfd_send_signal__doc__,
599"pidfd_send_signal($module, pidfd, signalnum, siginfo=None, flags=0, /)\n"
600"--\n"
601"\n"
602"Send a signal to a process referred to by a pid file descriptor.");
603
604#define SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF    \
605    {"pidfd_send_signal", _PyCFunction_CAST(signal_pidfd_send_signal), METH_FASTCALL, signal_pidfd_send_signal__doc__},
606
607static PyObject *
608signal_pidfd_send_signal_impl(PyObject *module, int pidfd, int signalnum,
609                              PyObject *siginfo, int flags);
610
611static PyObject *
612signal_pidfd_send_signal(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
613{
614    PyObject *return_value = NULL;
615    int pidfd;
616    int signalnum;
617    PyObject *siginfo = Py_None;
618    int flags = 0;
619
620    if (!_PyArg_CheckPositional("pidfd_send_signal", nargs, 2, 4)) {
621        goto exit;
622    }
623    pidfd = _PyLong_AsInt(args[0]);
624    if (pidfd == -1 && PyErr_Occurred()) {
625        goto exit;
626    }
627    signalnum = _PyLong_AsInt(args[1]);
628    if (signalnum == -1 && PyErr_Occurred()) {
629        goto exit;
630    }
631    if (nargs < 3) {
632        goto skip_optional;
633    }
634    siginfo = args[2];
635    if (nargs < 4) {
636        goto skip_optional;
637    }
638    flags = _PyLong_AsInt(args[3]);
639    if (flags == -1 && PyErr_Occurred()) {
640        goto exit;
641    }
642skip_optional:
643    return_value = signal_pidfd_send_signal_impl(module, pidfd, signalnum, siginfo, flags);
644
645exit:
646    return return_value;
647}
648
649#endif /* (defined(__linux__) && defined(__NR_pidfd_send_signal)) */
650
651#ifndef SIGNAL_ALARM_METHODDEF
652    #define SIGNAL_ALARM_METHODDEF
653#endif /* !defined(SIGNAL_ALARM_METHODDEF) */
654
655#ifndef SIGNAL_PAUSE_METHODDEF
656    #define SIGNAL_PAUSE_METHODDEF
657#endif /* !defined(SIGNAL_PAUSE_METHODDEF) */
658
659#ifndef SIGNAL_SIGINTERRUPT_METHODDEF
660    #define SIGNAL_SIGINTERRUPT_METHODDEF
661#endif /* !defined(SIGNAL_SIGINTERRUPT_METHODDEF) */
662
663#ifndef SIGNAL_SETITIMER_METHODDEF
664    #define SIGNAL_SETITIMER_METHODDEF
665#endif /* !defined(SIGNAL_SETITIMER_METHODDEF) */
666
667#ifndef SIGNAL_GETITIMER_METHODDEF
668    #define SIGNAL_GETITIMER_METHODDEF
669#endif /* !defined(SIGNAL_GETITIMER_METHODDEF) */
670
671#ifndef SIGNAL_PTHREAD_SIGMASK_METHODDEF
672    #define SIGNAL_PTHREAD_SIGMASK_METHODDEF
673#endif /* !defined(SIGNAL_PTHREAD_SIGMASK_METHODDEF) */
674
675#ifndef SIGNAL_SIGPENDING_METHODDEF
676    #define SIGNAL_SIGPENDING_METHODDEF
677#endif /* !defined(SIGNAL_SIGPENDING_METHODDEF) */
678
679#ifndef SIGNAL_SIGWAIT_METHODDEF
680    #define SIGNAL_SIGWAIT_METHODDEF
681#endif /* !defined(SIGNAL_SIGWAIT_METHODDEF) */
682
683#ifndef SIGNAL_VALID_SIGNALS_METHODDEF
684    #define SIGNAL_VALID_SIGNALS_METHODDEF
685#endif /* !defined(SIGNAL_VALID_SIGNALS_METHODDEF) */
686
687#ifndef SIGNAL_SIGWAITINFO_METHODDEF
688    #define SIGNAL_SIGWAITINFO_METHODDEF
689#endif /* !defined(SIGNAL_SIGWAITINFO_METHODDEF) */
690
691#ifndef SIGNAL_SIGTIMEDWAIT_METHODDEF
692    #define SIGNAL_SIGTIMEDWAIT_METHODDEF
693#endif /* !defined(SIGNAL_SIGTIMEDWAIT_METHODDEF) */
694
695#ifndef SIGNAL_PTHREAD_KILL_METHODDEF
696    #define SIGNAL_PTHREAD_KILL_METHODDEF
697#endif /* !defined(SIGNAL_PTHREAD_KILL_METHODDEF) */
698
699#ifndef SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF
700    #define SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF
701#endif /* !defined(SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF) */
702/*[clinic end generated code: output=9b3f9f1ae2ac2b94 input=a9049054013a1b77]*/
703