Actual source code: errtrace.c

  1: #define PETSC_DESIRE_FEATURE_TEST_MACROS /* for fileno() */
  2: #include <petscsys.h>
  3: #include <petsc/private/petscimpl.h>
  4: #include <petscconfiginfo.h>
  5: #if defined(PETSC_HAVE_UNISTD_H)
  6:   #include <unistd.h>
  7: #endif
  8: #include "err.h"
  9: #include <petsc/private/logimpl.h>

 11: /*@C
 12:   PetscIgnoreErrorHandler - Deprecated, use `PetscReturnErrorHandler()`. Ignores the error, allows program to continue as if error did not occur

 14:   Not Collective

 16:   Input Parameters:
 17: + comm - communicator over which error occurred
 18: . line - the line number of the error (indicated by __LINE__)
 19: . fun  - the function name
 20: . file - the file in which the error was detected (indicated by __FILE__)
 21: . mess - an error text string, usually just printed to the screen
 22: . n    - the generic error number
 23: . p    - specific error number
 24: - ctx  - error handler context

 26:   Level: developer

 28:   Note:
 29:   Users do not directly call this routine

 31: .seealso: `PetscReturnErrorHandler()`
 32:  @*/
 33: PetscErrorCode PetscIgnoreErrorHandler(MPI_Comm comm, int line, const char *fun, const char *file, PetscErrorCode n, PetscErrorType p, const char *mess, void *ctx)
 34: {
 35:   (void)comm;
 36:   (void)line;
 37:   (void)fun;
 38:   (void)file;
 39:   (void)p;
 40:   (void)mess;
 41:   (void)ctx;
 42:   return n;
 43: }

 45: /* ---------------------------------------------------------------------------------------*/

 47: static char      arch[128], hostname[128], username[128], pname[PETSC_MAX_PATH_LEN], date[128];
 48: static PetscBool PetscErrorPrintfInitializeCalled = PETSC_FALSE;
 49: static char      version[256];

 51: /*
 52:    Initializes arch, hostname, username, date so that system calls do NOT need
 53:    to be made during the error handler.
 54: */
 55: PetscErrorCode PetscErrorPrintfInitialize(void)
 56: {
 57:   PetscBool use_stdout = PETSC_FALSE, use_none = PETSC_FALSE;

 59:   PetscFunctionBegin;
 60:   PetscCall(PetscGetArchType(arch, sizeof(arch)));
 61:   PetscCall(PetscGetHostName(hostname, sizeof(hostname)));
 62:   PetscCall(PetscGetUserName(username, sizeof(username)));
 63:   PetscCall(PetscGetProgramName(pname, sizeof(pname)));
 64:   PetscCall(PetscGetDate(date, sizeof(date)));
 65:   PetscCall(PetscGetVersion(version, sizeof(version)));

 67:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-error_output_stdout", &use_stdout, NULL));
 68:   if (use_stdout) PETSC_STDERR = PETSC_STDOUT;
 69:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-error_output_none", &use_none, NULL));
 70:   if (use_none) PetscErrorPrintf = PetscErrorPrintfNone;
 71:   PetscErrorPrintfInitializeCalled = PETSC_TRUE;
 72:   PetscFunctionReturn(PETSC_SUCCESS);
 73: }

 75: PetscErrorCode PetscErrorPrintfNone(const char format[], ...)
 76: {
 77:   return PETSC_SUCCESS;
 78: }

 80: PetscErrorCode PetscErrorPrintfDefault(const char format[], ...)
 81: {
 82:   va_list          Argp;
 83:   static PetscBool PetscErrorPrintfCalled = PETSC_FALSE;
 84:   PetscErrorCode   ierr;

 86:   /*
 87:       This function does not call PetscFunctionBegin and PetscFunctionReturn() because
 88:     it may be called by PetscStackView().

 90:       This function does not do error checking because it is called by the error handlers.
 91:   */

 93:   if (!PetscErrorPrintfCalled) {
 94:     PetscErrorPrintfCalled = PETSC_TRUE;

 96:     /*
 97:         On the SGI machines and Cray T3E, if errors are generated  "simultaneously" by
 98:       different processors, the messages are printed all jumbled up; to try to
 99:       prevent this we have each processor wait based on their rank
100:     */
101: #if defined(PETSC_CAN_SLEEP_AFTER_ERROR)
102:     {
103:       PetscMPIInt rank = PetscGlobalRank > 8 ? 8 : PetscGlobalRank;
104:       ierr             = PetscSleep((PetscReal)rank);
105:       (void)ierr;
106:     }
107: #endif
108:   }

110:   ierr = PetscFPrintf(PETSC_COMM_SELF, PETSC_STDERR, "[%d]PETSC ERROR: ", PetscGlobalRank);
111:   va_start(Argp, format);
112:   ierr = (*PetscVFPrintf)(PETSC_STDERR, format, Argp);
113:   (void)ierr;
114:   va_end(Argp);
115:   return PETSC_SUCCESS;
116: }

118: /*
119:    On some systems when the stderr is nested through several levels of shell script
120:    before being passed to a file the isatty() falsely returns true resulting in
121:    the screen highlight variables being passed through the test harness. Therefore
122:    simply do not highlight when the PETSC_STDERR is PETSC_STDOUT.
123: */
124: static void PetscErrorPrintfHilight(void)
125: {
126: #if defined(PETSC_HAVE_UNISTD_H) && defined(PETSC_USE_ISATTY)
127:   if (PetscErrorPrintf == PetscErrorPrintfDefault && PETSC_STDERR != PETSC_STDOUT) {
128:     if (isatty(fileno(PETSC_STDERR))) fprintf(PETSC_STDERR, "\033[1;31m");
129:   }
130: #endif
131: }

133: static void PetscErrorPrintfNormal(void)
134: {
135: #if defined(PETSC_HAVE_UNISTD_H) && defined(PETSC_USE_ISATTY)
136:   if (PetscErrorPrintf == PetscErrorPrintfDefault && PETSC_STDERR != PETSC_STDOUT) {
137:     if (isatty(fileno(PETSC_STDERR))) fprintf(PETSC_STDERR, "\033[0;39m\033[0;49m");
138:   }
139: #endif
140: }

142: PETSC_EXTERN PetscErrorCode PetscOptionsViewError(void);

144: static PETSC_TLS PetscBool petsc_traceback_error_silent = PETSC_FALSE;

146: /*@C

148:   PetscTraceBackErrorHandler - Default error handler routine that generates
149:   a traceback on error detection.

151:   Not Collective

153:   Input Parameters:
154: + comm - communicator over which error occurred
155: . line - the line number of the error (usually indicated by `__LINE__` in the calling routine)
156: . fun  - the function name
157: . file - the file in which the error was detected (usually indicated by `__FILE__` in the calling routine)
158: . mess - an error text string, usually just printed to the screen
159: . n    - the generic error number
160: . p    - `PETSC_ERROR_INITIAL` if this is the first call the error handler, otherwise `PETSC_ERROR_REPEAT`
161: - ctx  - error handler context

163:   Options Database Keys:
164: + -error_output_stdout - output the error messages to `stdout` instead of the default `stderr`
165: - -error_output_none   - do not output the error messages

167:   Notes:
168:   Users do not directly call this routine

170:   Use `PetscPushErrorHandler()` to set the desired error handler.

172:   Level: developer

174: .seealso: `PetscError()`, `PetscPushErrorHandler()`, `PetscPopErrorHandler()`, `PetscAttachDebuggerErrorHandler()`,
175:           `PetscAbortErrorHandler()`, `PetscMPIAbortErrorHandler()`, `PetscReturnErrorHandler()`, `PetscEmacsClientErrorHandler()`,
176:            `PETSC_ERROR_INITIAL`, `PETSC_ERROR_REPEAT`, `PetscErrorCode`, `PetscErrorType`
177:  @*/
178: PetscErrorCode PetscTraceBackErrorHandler(MPI_Comm comm, int line, const char *fun, const char *file, PetscErrorCode n, PetscErrorType p, const char *mess, void *ctx)
179: {
180:   PetscErrorCode ierr;
181:   PetscMPIInt    rank = 0;

183:   (void)ctx;
184:   if (comm != PETSC_COMM_SELF) MPI_Comm_rank(comm, &rank);

186:   // reinitialize the error handler when a new initializing error is detected
187:   if (p != PETSC_ERROR_REPEAT) {
188:     petsc_traceback_error_silent = PETSC_FALSE;
189:     if (PetscCIEnabledPortableErrorOutput) {
190:       PetscMPIInt size = 1;

192:       if (comm != MPI_COMM_NULL) MPI_Comm_size(comm, &size);
193:       petscabortmpifinalize = (size == PetscGlobalSize) ? PETSC_TRUE : PETSC_FALSE;
194:     }
195:   }

197:   if (rank == 0 && (!PetscCIEnabledPortableErrorOutput || PetscGlobalRank == 0) && (p != PETSC_ERROR_REPEAT || !petsc_traceback_error_silent)) {
198:     static int cnt = 1;

200:     if (p == PETSC_ERROR_INITIAL) {
201:       PetscErrorPrintfHilight();
202:       ierr = (*PetscErrorPrintf)("--------------------- Error Message --------------------------------------------------------------\n");
203:       PetscErrorPrintfNormal();
204:       if (cnt > 1) {
205:         ierr = (*PetscErrorPrintf)("  It appears a new error in the code was triggered after a previous error, possibly because:\n");
206:         ierr = (*PetscErrorPrintf)("  -  The first error was not properly handled via (for example) the use of\n");
207:         ierr = (*PetscErrorPrintf)("     PetscCall(TheFunctionThatErrors()); or\n");
208:         ierr = (*PetscErrorPrintf)("  -  The second error was triggered while handling the first error.\n");
209:         ierr = (*PetscErrorPrintf)("  Above is the traceback for the previous unhandled error, below the traceback for the next error\n");
210:         ierr = (*PetscErrorPrintf)("  ALL ERRORS in the PETSc libraries are fatal, you should add the appropriate error checking to the code\n");
211:         cnt  = 1;
212:       }
213:     }
214:     if (cnt == 1) {
215:       if (n == PETSC_ERR_MEM || n == PETSC_ERR_MEM_LEAK) ierr = PetscErrorMemoryMessage(n);
216:       else {
217:         const char *text;
218:         ierr = PetscErrorMessage(n, &text, NULL);
219:         if (text) ierr = (*PetscErrorPrintf)("%s\n", text);
220:       }
221:       if (mess) ierr = (*PetscErrorPrintf)("%s\n", mess);
222:       ierr = PetscOptionsLeftError();
223:       ierr = (*PetscErrorPrintf)("See https://petsc.org/release/faq/ for trouble shooting.\n");
224:       if (!PetscCIEnabledPortableErrorOutput) {
225:         ierr = (*PetscErrorPrintf)("%s\n", version);
226:         if (PetscErrorPrintfInitializeCalled) ierr = (*PetscErrorPrintf)("%s on a %s named %s by %s %s\n", pname, arch, hostname, username, date);
227:         ierr = (*PetscErrorPrintf)("Configure options %s\n", petscconfigureoptions);
228:       }
229:     }
230:     /* print line of stack trace */
231:     if (fun) ierr = (*PetscErrorPrintf)("#%d %s() at %s:%d\n", cnt++, fun, PetscCIFilename(file), PetscCILinenumber(line));
232:     else if (file) ierr = (*PetscErrorPrintf)("#%d %s:%d\n", cnt++, PetscCIFilename(file), PetscCILinenumber(line));
233:     if (fun) {
234:       PetscBool ismain = PETSC_FALSE;

236:       ierr = PetscStrncmp(fun, "main", 4, &ismain);
237:       if (ismain) {
238:         if ((n <= PETSC_ERR_MIN_VALUE) || (n >= PETSC_ERR_MAX_VALUE)) ierr = (*PetscErrorPrintf)("Reached the main program with an out-of-range error code %d. This should never happen\n", n);
239:         ierr = PetscOptionsViewError();
240:         PetscErrorPrintfHilight();
241:         ierr = (*PetscErrorPrintf)("----------------End of Error Message -------send entire error message to petsc-maint@mcs.anl.gov----------\n");
242:         PetscErrorPrintfNormal();
243:       }
244:     }
245:   } else {
246:     // silence this process's stacktrace if it is not the root of an originating error
247:     if (p != PETSC_ERROR_REPEAT && rank) petsc_traceback_error_silent = PETSC_TRUE;
248:     if (fun) {
249:       PetscBool ismain = PETSC_FALSE;

251:       ierr = PetscStrncmp(fun, "main", 4, &ismain);
252:       if (ismain && petsc_traceback_error_silent) {
253:         /* This results from PetscError() being called in main: PETSCABORT()
254:            will be called after the error handler.  But this thread is not the
255:            root rank of the communicator that initialized the error.  So sleep
256:            to allow the root thread to finish its printing.

258:            (Unless this is running CI, in which case do not sleep because
259:            we expect all processes to call MPI_Finalize() and make a clean
260:            exit.) */
261:         if (!PetscCIEnabledPortableErrorOutput) ierr = PetscSleep(10.0);
262:       }
263:     }
264:   }
265:   (void)ierr;
266:   return n;
267: }