Actual source code: signal.c
1: /*
2: Routines to handle signals the program will receive.
3: Usually this will call the error handlers.
4: */
5: #include <petsc/private/petscimpl.h>
6: #include <signal.h>
7: #include <stdlib.h> /* for _Exit() */
9: static PetscClassId SIGNAL_CLASSID = 0;
11: struct SH {
12: PetscClassId classid;
13: PetscErrorCode (*handler)(int, void *);
14: void *ctx;
15: struct SH *previous;
16: };
17: static struct SH *sh = NULL;
18: static PetscBool SignalSet = PETSC_FALSE;
20: /* Called by MPI_Abort() to suppress user-registered atexit()/on_exit() functions.
21: See discussion at https://gitlab.com/petsc/petsc/-/merge_requests/2745.
22: */
23: static void MyExit(void)
24: {
25: _Exit(MPI_ERR_OTHER);
26: }
28: /*
29: PetscSignalHandler_Private - This is the signal handler called by the system. This calls
30: any signal handler set by PETSc or the application code.
32: Input Parameters: (depends on system)
33: . sig - integer code indicating the type of signal
34: . code - ??
35: . sigcontext - ??
36: . addr - ??
38: */
39: #if PetscDefined(HAVE_4ARG_SIGNAL_HANDLER)
40: static void PetscSignalHandler_Private(int sig, int code, struct sigcontext *scp, char *addr)
41: #else
42: static void PetscSignalHandler_Private(int sig)
43: #endif
44: {
45: PetscErrorCode ierr;
47: if (!sh || !sh->handler) ierr = PetscSignalHandlerDefault(sig, NULL);
48: else {
49: if (sh->classid != SIGNAL_CLASSID) SETERRABORT(PETSC_COMM_WORLD, PETSC_ERR_COR, "Signal object has been corrupted");
50: ierr = (*sh->handler)(sig, sh->ctx);
51: }
52: if (ierr) PETSCABORT(PETSC_COMM_WORLD, PETSC_ERR_COR);
53: }
55: /*@
56: PetscSignalHandlerDefault - Default signal handler.
58: Not Collective
60: Input Parameters:
61: + sig - signal value
62: - ptr - unused pointer
64: Level: advanced
66: Developer Note:
67: This does not call `PetscError()`, it handles the entire error process, including possibly printing the traceback, directly
69: .seealso: [](sec_errors), `PetscPushSignalHandler()`
70: @*/
71: PetscErrorCode PetscSignalHandlerDefault(int sig, void *ptr)
72: {
73: const char *SIGNAME[64];
75: if (sig == SIGSEGV) PetscSignalSegvCheckPointerOrMpi();
76: SIGNAME[0] = "Unknown signal";
77: #if !PetscDefined(MISSING_SIGABRT)
78: SIGNAME[SIGABRT] = "Abort";
79: #endif
80: #if !PetscDefined(MISSING_SIGALRM)
81: SIGNAME[SIGALRM] = "Alarm";
82: #endif
83: #if !PetscDefined(MISSING_SIGBUS)
84: SIGNAME[SIGBUS] = "BUS: Bus Error, possibly illegal memory access";
85: #endif
86: #if !PetscDefined(MISSING_SIGCHLD)
87: SIGNAME[SIGCHLD] = "CHLD";
88: #endif
89: #if !PetscDefined(MISSING_SIGCONT)
90: SIGNAME[SIGCONT] = "CONT";
91: #endif
92: #if !PetscDefined(MISSING_SIGFPE)
93: SIGNAME[SIGFPE] = "FPE: Floating Point Exception,probably divide by zero";
94: #endif
95: #if !PetscDefined(MISSING_SIGHUP)
96: SIGNAME[SIGHUP] = "Hang up: Some other process (or the batch system) has told this process to end";
97: #endif
98: #if !PetscDefined(MISSING_SIGILL)
99: SIGNAME[SIGILL] = "Illegal instruction: Likely due to memory corruption";
100: #endif
101: #if !PetscDefined(MISSING_SIGINT)
102: SIGNAME[SIGINT] = "Interrupt";
103: #endif
104: #if !PetscDefined(MISSING_SIGKILL)
105: SIGNAME[SIGKILL] = "Kill: Some other process (or the batch system) has told this process to end";
106: #endif
107: #if !PetscDefined(MISSING_SIGPIPE)
108: SIGNAME[SIGPIPE] = "Broken Pipe: Likely while reading or writing to a socket";
109: #endif
110: #if !PetscDefined(MISSING_SIGQUIT)
111: SIGNAME[SIGQUIT] = "Quit: Some other process (or the batch system) has told this process to end";
112: #endif
113: #if !PetscDefined(MISSING_SIGSEGV)
114: SIGNAME[SIGSEGV] = "SEGV: Segmentation Violation, probably memory access out of range";
115: #endif
116: #if !PetscDefined(MISSING_SIGSYS)
117: SIGNAME[SIGSYS] = "SYS";
118: #endif
119: #if !PetscDefined(MISSING_SIGTERM)
120: SIGNAME[SIGTERM] = "Terminate: Some process (or the batch system) has told this process to end";
121: #endif
122: #if !PetscDefined(MISSING_SIGTRAP)
123: SIGNAME[SIGTRAP] = "TRAP";
124: #endif
125: #if !PetscDefined(MISSING_SIGTSTP)
126: SIGNAME[SIGTSTP] = "TSTP";
127: #endif
128: #if !PetscDefined(MISSING_SIGURG)
129: SIGNAME[SIGURG] = "URG";
130: #endif
131: #if !PetscDefined(MISSING_SIGUSR1)
132: SIGNAME[SIGUSR1] = "User 1";
133: #endif
134: #if !PetscDefined(MISSING_SIGUSR2)
135: SIGNAME[SIGUSR2] = "User 2";
136: #endif
138: signal(sig, SIG_DFL);
139: (void)PetscSleep(PetscGlobalRank % 4); /* prevent some jumbling of error messages from different ranks */
140: (void)(*PetscErrorPrintf)("------------------------------------------------------------------------\n");
141: if (sig >= 0 && sig <= 20) (void)(*PetscErrorPrintf)("Caught signal number %d %s\n", sig, SIGNAME[sig]);
142: else (void)(*PetscErrorPrintf)("Caught signal\n");
144: (void)(*PetscErrorPrintf)("Try option -start_in_debugger or -on_error_attach_debugger\n");
145: (void)(*PetscErrorPrintf)("or see https://petsc.org/release/faq/#valgrind and https://petsc.org/release/faq/\n");
146: if (PetscDefined(HAVE_CUDA)) (void)(*PetscErrorPrintf)("or try https://docs.nvidia.com/compute-sanitizer/ComputeSanitizer/index.html on NVIDIA CUDA systems to find memory corruption errors\n");
147: if (PetscDefined(USE_DEBUG)) {
148: if (!PetscDefined(HAVE_THREADSAFETY)) {
149: (void)(*PetscErrorPrintf)("--------------------- Stack Frames ------------------------------------\n");
150: (void)PetscStackView(PETSC_STDOUT);
151: }
152: } else {
153: (void)(*PetscErrorPrintf)("configure using --with-debugging=yes, recompile, link, and run \n");
154: (void)(*PetscErrorPrintf)("to get more information on the crash.\n");
155: }
156: #if !PetscDefined(MISSING_SIGBUS)
157: if (sig == SIGSEGV || sig == SIGBUS) {
158: #else
159: if (sig == SIGSEGV) {
160: #endif
161: PetscBool debug;
163: (void)PetscMallocGetDebug(&debug, NULL, NULL);
164: if (debug) (void)PetscMallocValidate(__LINE__, PETSC_FUNCTION_NAME, __FILE__);
165: else (void)(*PetscErrorPrintf)("Run with -malloc_debug to check if memory corruption is causing the crash.\n");
166: }
167: atexit(MyExit);
168: PETSCABORT(PETSC_COMM_WORLD, PETSC_ERR_SIG);
169: return PETSC_SUCCESS;
170: }
172: #if !defined(PETSC_SIGNAL_CAST)
173: #define PETSC_SIGNAL_CAST
174: #endif
176: /*@C
177: PetscPushSignalHandler - Catches the usual fatal errors and
178: calls a user-provided routine.
180: Not Collective, No Fortran Support
182: Input Parameters:
183: + routine - routine to call when a signal is received
184: - ctx - optional context needed by the routine
186: Level: developer
188: Note:
189: There is no way to return to a signal handler that was set directly by the user with the UNIX signal handler API or by
190: the loader. That information is lost with the first call to `PetscPushSignalHandler()`
192: .seealso: [](sec_errors), `PetscPopSignalHandler()`, `PetscSignalHandlerDefault()`, `PetscPushErrorHandler()`
193: @*/
194: PetscErrorCode PetscPushSignalHandler(PetscErrorCode (*routine)(int, void *), PetscCtx ctx)
195: {
196: struct SH *newsh;
198: PetscFunctionBegin;
199: if (!SIGNAL_CLASSID) {
200: /* PetscCall(PetscClassIdRegister("Signal",&SIGNAL_CLASSID)); */
201: SIGNAL_CLASSID = 19;
202: }
203: if (!SignalSet && routine) {
204: /* Do not catch ABRT, CHLD, KILL */
205: #if !PetscDefined(MISSING_SIGALRM)
206: /* signal(SIGALRM, PETSC_SIGNAL_CAST PetscSignalHandler_Private); */
207: #endif
208: #if !PetscDefined(MISSING_SIGBUS)
209: signal(SIGBUS, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
210: #endif
211: #if !PetscDefined(MISSING_SIGCONT)
212: /*signal(SIGCONT, PETSC_SIGNAL_CAST PetscSignalHandler_Private);*/
213: #endif
214: #if !PetscDefined(MISSING_SIGFPE)
215: signal(SIGFPE, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
216: #endif
217: #if !PetscDefined(MISSING_SIGHUP) && PetscDefined(HAVE_STRUCT_SIGACTION)
218: {
219: struct sigaction action;
220: sigaction(SIGHUP, NULL, &action);
221: if (action.sa_handler == SIG_IGN) {
222: PetscCall(PetscInfo(NULL, "SIGHUP previously set to ignore, therefore not changing its signal handler\n"));
223: } else {
224: signal(SIGHUP, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
225: }
226: }
227: #endif
228: #if !PetscDefined(MISSING_SIGILL)
229: signal(SIGILL, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
230: #endif
231: #if !PetscDefined(MISSING_SIGINT)
232: /* signal(SIGINT, PETSC_SIGNAL_CAST PetscSignalHandler_Private); */
233: #endif
234: #if !PetscDefined(MISSING_SIGPIPE)
235: signal(SIGPIPE, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
236: #endif
237: #if !PetscDefined(MISSING_SIGQUIT)
238: signal(SIGQUIT, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
239: #endif
240: #if !PetscDefined(MISSING_SIGSEGV)
241: signal(SIGSEGV, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
242: #endif
243: #if !PetscDefined(MISSING_SIGSYS)
244: signal(SIGSYS, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
245: #endif
246: #if !PetscDefined(MISSING_SIGTERM)
247: #if !PetscDefined(HAVE_OPENMPI)
248: /* Open MPI may use SIGTERM to close down all its ranks; we don't want to generate many confusing PETSc error messages in that case */
249: signal(SIGTERM, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
250: #endif
251: #endif
252: #if !PetscDefined(MISSING_SIGTRAP)
253: signal(SIGTRAP, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
254: #endif
255: #if !PetscDefined(MISSING_SIGTSTP)
256: /* signal(SIGTSTP, PETSC_SIGNAL_CAST PetscSignalHandler_Private); */
257: #endif
258: #if !PetscDefined(MISSING_SIGURG)
259: signal(SIGURG, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
260: #endif
261: #if !PetscDefined(MISSING_SIGUSR1)
262: /* signal(SIGUSR1, PETSC_SIGNAL_CAST PetscSignalHandler_Private); */
263: #endif
264: #if !PetscDefined(MISSING_SIGUSR2)
265: /* signal(SIGUSR2, PETSC_SIGNAL_CAST PetscSignalHandler_Private); */
266: #endif
267: SignalSet = PETSC_TRUE;
268: }
269: if (!routine) {
270: #if !PetscDefined(MISSING_SIGALRM)
271: /* signal(SIGALRM, SIG_DFL); */
272: #endif
273: #if !PetscDefined(MISSING_SIGBUS)
274: signal(SIGBUS, SIG_DFL);
275: #endif
276: #if !PetscDefined(MISSING_SIGCONT)
277: /* signal(SIGCONT, SIG_DFL); */
278: #endif
279: #if !PetscDefined(MISSING_SIGFPE)
280: signal(SIGFPE, SIG_DFL);
281: #endif
282: #if !PetscDefined(MISSING_SIGHUP)
283: signal(SIGHUP, SIG_DFL);
284: #endif
285: #if !PetscDefined(MISSING_SIGILL)
286: signal(SIGILL, SIG_DFL);
287: #endif
288: #if !PetscDefined(MISSING_SIGINT)
289: /* signal(SIGINT, SIG_DFL); */
290: #endif
291: #if !PetscDefined(MISSING_SIGPIPE)
292: signal(SIGPIPE, SIG_DFL);
293: #endif
294: #if !PetscDefined(MISSING_SIGQUIT)
295: signal(SIGQUIT, SIG_DFL);
296: #endif
297: #if !PetscDefined(MISSING_SIGSEGV)
298: signal(SIGSEGV, SIG_DFL);
299: #endif
300: #if !PetscDefined(MISSING_SIGSYS)
301: signal(SIGSYS, SIG_DFL);
302: #endif
303: #if !PetscDefined(MISSING_SIGTERM)
304: signal(SIGTERM, SIG_DFL);
305: #endif
306: #if !PetscDefined(MISSING_SIGTRAP)
307: signal(SIGTRAP, SIG_DFL);
308: #endif
309: #if !PetscDefined(MISSING_SIGTSTP)
310: /* signal(SIGTSTP, SIG_DFL); */
311: #endif
312: #if !PetscDefined(MISSING_SIGURG)
313: signal(SIGURG, SIG_DFL);
314: #endif
315: #if !PetscDefined(MISSING_SIGUSR1)
316: /* signal(SIGUSR1, SIG_DFL); */
317: #endif
318: #if !PetscDefined(MISSING_SIGUSR2)
319: /* signal(SIGUSR2, SIG_DFL); */
320: #endif
321: SignalSet = PETSC_FALSE;
322: }
323: PetscCall(PetscNew(&newsh));
324: if (sh) {
325: PetscCheck(sh->classid == SIGNAL_CLASSID, PETSC_COMM_SELF, PETSC_ERR_COR, "Signal object has been corrupted");
326: newsh->previous = sh;
327: } else newsh->previous = NULL;
328: newsh->handler = routine;
329: newsh->ctx = ctx;
330: newsh->classid = SIGNAL_CLASSID;
331: sh = newsh;
332: PetscFunctionReturn(PETSC_SUCCESS);
333: }
335: /*@
336: PetscPopSignalHandler - Removes the last signal handler that was pushed.
337: If no signal handlers are left on the stack it will remove the PETSc signal handler.
338: (That is PETSc will no longer catch signals).
340: Not Collective
342: Level: developer
344: Note:
345: There is no way to return to a signal handler that was set directly by the user with the UNIX signal handler API or by
346: the loader. That information is lost with the first call to `PetscPushSignalHandler()`
348: .seealso: [](sec_errors), `PetscPushSignalHandler()`
349: @*/
350: PetscErrorCode PetscPopSignalHandler(void)
351: {
352: struct SH *tmp;
354: PetscFunctionBegin;
355: if (!sh) PetscFunctionReturn(PETSC_SUCCESS);
356: PetscCheck(sh->classid == SIGNAL_CLASSID, PETSC_COMM_SELF, PETSC_ERR_COR, "Signal object has been corrupted");
358: tmp = sh;
359: sh = sh->previous;
360: PetscCall(PetscFree(tmp));
361: if (!sh || !sh->handler) {
362: #if !PetscDefined(MISSING_SIGALRM)
363: /* signal(SIGALRM, SIG_DFL); */
364: #endif
365: #if !PetscDefined(MISSING_SIGBUS)
366: signal(SIGBUS, SIG_DFL);
367: #endif
368: #if !PetscDefined(MISSING_SIGCONT)
369: /* signal(SIGCONT, SIG_DFL); */
370: #endif
371: #if !PetscDefined(MISSING_SIGFPE)
372: signal(SIGFPE, SIG_DFL);
373: #endif
374: #if !PetscDefined(MISSING_SIGHUP)
375: signal(SIGHUP, SIG_DFL);
376: #endif
377: #if !PetscDefined(MISSING_SIGILL)
378: signal(SIGILL, SIG_DFL);
379: #endif
380: #if !PetscDefined(MISSING_SIGINT)
381: /* signal(SIGINT, SIG_DFL); */
382: #endif
383: #if !PetscDefined(MISSING_SIGPIPE)
384: signal(SIGPIPE, SIG_DFL);
385: #endif
386: #if !PetscDefined(MISSING_SIGQUIT)
387: signal(SIGQUIT, SIG_DFL);
388: #endif
389: #if !PetscDefined(MISSING_SIGSEGV)
390: signal(SIGSEGV, SIG_DFL);
391: #endif
392: #if !PetscDefined(MISSING_SIGSYS)
393: signal(SIGSYS, SIG_DFL);
394: #endif
395: #if !PetscDefined(MISSING_SIGTERM)
396: signal(SIGTERM, SIG_DFL);
397: #endif
398: #if !PetscDefined(MISSING_SIGTRAP)
399: signal(SIGTRAP, SIG_DFL);
400: #endif
401: #if !PetscDefined(MISSING_SIGTSTP)
402: /* signal(SIGTSTP, SIG_DFL); */
403: #endif
404: #if !PetscDefined(MISSING_SIGURG)
405: signal(SIGURG, SIG_DFL);
406: #endif
407: #if !PetscDefined(MISSING_SIGUSR1)
408: /* signal(SIGUSR1, SIG_DFL); */
409: #endif
410: #if !PetscDefined(MISSING_SIGUSR2)
411: /* signal(SIGUSR2, SIG_DFL); */
412: #endif
413: SignalSet = PETSC_FALSE;
414: } else {
415: SignalSet = PETSC_TRUE;
416: }
417: PetscFunctionReturn(PETSC_SUCCESS);
418: }