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