Date: 2015-10-02T21:59:38+00:00

Actual source code: signal.c
petsc-3.6.2 2015-10-02
Report Typos and Errors

      2: /*
      3:       Routines to handle signals the program will receive.
      4:     Usually this will call the error handlers.
      5: */
      6: #include <petsc/private/petscimpl.h>             /*I   "petscsys.h"   I*/
      7: #include <signal.h>

      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       = 0;
     18: static PetscBool SignalSet = PETSC_FALSE;

     22: /*
     23:     PetscSignalHandler_Private - This is the signal handler called by the system. This calls
     24:              any signal handler set by PETSc or the application code.

     26:    Input Parameters: (depends on system)
     27: .    sig - integer code indicating the type of signal
     28: .    code - ??
     29: .    sigcontext - ??
     30: .    addr - ??

     32:     Note: this is declared extern "C" because it is passed to the system routine signal()
     33:           which is an extern "C" routine. The Solaris 2.7 OS compilers require that this be
     34:           extern "C".

     36: */
     37: #if defined(PETSC_HAVE_4ARG_SIGNAL_HANDLER)
     38: static void PetscSignalHandler_Private(int sig,int code,struct sigcontext * scp,char *addr)
     39: #else
     40: static void PetscSignalHandler_Private(int sig)
     41: #endif
     42: {

     46:   if (!sh || !sh->handler) PetscSignalHandlerDefault(sig,(void*)0);
     47:   else {
     48:     if (sh->classid != SIGNAL_CLASSID) SETERRABORT(PETSC_COMM_WORLD,PETSC_ERR_COR,"Signal object has been corrupted");
     49:     (*sh->handler)(sig,sh->ctx);
     50:   }
     51:   if (ierr) MPI_Abort(PETSC_COMM_WORLD,0);
     52: }

     56: /*@
     57:    PetscSignalHandlerDefault - Default signal handler.

     59:    Not Collective

     61:    Level: advanced

     63:    Input Parameters:
     64: +  sig - signal value
     65: -  ptr - unused pointer

     67:    Concepts: signal handler^default

     69: @*/
     70: PetscErrorCode  PetscSignalHandlerDefault(int sig,void *ptr)
     71: {
     73:   const char     *SIGNAME[64];

     76:   SIGNAME[0]       = "Unknown signal";
     77: #if !defined(PETSC_MISSING_SIGABRT)
     78:   SIGNAME[SIGABRT] = "Abort";
     79: #endif
     80: #if !defined(PETSC_MISSING_SIGALRM)
     81:   SIGNAME[SIGALRM] = "Alarm";
     82: #endif
     83: #if !defined(PETSC_MISSING_SIGBUS)
     84:   SIGNAME[SIGBUS]  = "BUS: Bus Error, possibly illegal memory access";
     85: #endif
     86: #if !defined(PETSC_MISSING_SIGCHLD)
     87:   SIGNAME[SIGCHLD] = "CHLD";
     88: #endif
     89: #if !defined(PETSC_MISSING_SIGCONT)
     90:   SIGNAME[SIGCONT] = "CONT";
     91: #endif
     92: #if !defined(PETSC_MISSING_SIGFPE)
     93:   SIGNAME[SIGFPE]  = "FPE: Floating Point Exception,probably divide by zero";
     94: #endif
     95: #if !defined(PETSC_MISSING_SIGHUP)
     96:   SIGNAME[SIGHUP]  = "Hang up: Some other process (or the batch system) has told this process to end";
     97: #endif
     98: #if !defined(PETSC_MISSING_SIGILL)
     99:   SIGNAME[SIGILL]  = "Illegal instruction: Likely due to memory corruption";
    100: #endif
    101: #if !defined(PETSC_MISSING_SIGINT)
    102:   SIGNAME[SIGINT]  = "Interrupt";
    103: #endif
    104: #if !defined(PETSC_MISSING_SIGKILL)
    105:   SIGNAME[SIGKILL] = "Kill: Some other process (or the batch system) has told this process to end";
    106: #endif
    107: #if !defined(PETSC_MISSING_SIGPIPE)
    108:   SIGNAME[SIGPIPE] = "Broken Pipe: Likely while reading or writing to a socket";
    109: #endif
    110: #if !defined(PETSC_MISSING_SIGQUIT)
    111:   SIGNAME[SIGQUIT] = "Quit: Some other process (or the batch system) has told this process to end";
    112: #endif
    113: #if !defined(PETSC_MISSING_SIGSEGV)
    114:   SIGNAME[SIGSEGV] = "SEGV: Segmentation Violation, probably memory access out of range";
    115: #endif
    116: #if !defined(PETSC_MISSING_SIGSYS)
    117:   SIGNAME[SIGSYS]  = "SYS";
    118: #endif
    119: #if !defined(PETSC_MISSING_SIGTERM)
    120:   SIGNAME[SIGTERM] = "Terminate: Some process (or the batch system) has told this process to end";
    121: #endif
    122: #if !defined(PETSC_MISSING_SIGTRAP)
    123:   SIGNAME[SIGTRAP] = "TRAP";
    124: #endif
    125: #if !defined(PETSC_MISSING_SIGTSTP)
    126:   SIGNAME[SIGTSTP] = "TSTP";
    127: #endif
    128: #if !defined(PETSC_MISSING_SIGURG)
    129:   SIGNAME[SIGURG]  = "URG";
    130: #endif
    131: #if !defined(PETSC_MISSING_SIGUSR1)
    132:   SIGNAME[SIGUSR1] = "User 1";
    133: #endif
    134: #if !defined(PETSC_MISSING_SIGUSR2)
    135:   SIGNAME[SIGUSR2] = "User 2";
    136: #endif

    138:   signal(sig,SIG_DFL);
    139:   (*PetscErrorPrintf)("------------------------------------------------------------------------\n");
    140:   if (sig >= 0 && sig <= 20) (*PetscErrorPrintf)("Caught signal number %d %s\n",sig,SIGNAME[sig]);
    141:   else (*PetscErrorPrintf)("Caught signal\n");

    143:   (*PetscErrorPrintf)("Try option -start_in_debugger or -on_error_attach_debugger\n");
    144:   (*PetscErrorPrintf)("or see http://www.mcs.anl.gov/petsc/documentation/faq.html#valgrind\n");
    145:   (*PetscErrorPrintf)("or try http://valgrind.org on GNU/linux and Apple Mac OS X to find memory corruption errors\n");
    146: #if defined(PETSC_USE_DEBUG)
    147:   if (!PetscStackActive()) (*PetscErrorPrintf)("  or try option -log_stack\n");
    148:   else {
    149:     PetscStackPop;  /* remove stack frames for error handlers */
    150:     PetscStackPop;
    151:     (*PetscErrorPrintf)("likely location of problem given in stack below\n");
    152:     (*PetscErrorPrintf)("---------------------  Stack Frames ------------------------------------\n");
    153:     PetscStackView(PETSC_STDOUT);
    154:   }
    155: #endif
    156: #if !defined(PETSC_USE_DEBUG)
    157:   (*PetscErrorPrintf)("configure using --with-debugging=yes, recompile, link, and run \n");
    158:   (*PetscErrorPrintf)("to get more information on the crash.\n");
    159: #endif
    160:    PetscError(PETSC_COMM_SELF,0,"User provided function"," unknown file",PETSC_ERR_SIG,PETSC_ERROR_INITIAL,NULL);
    161:   MPI_Abort(PETSC_COMM_WORLD,(int)ierr);
    162:   return(0);
    163: }

    165: #if !defined(PETSC_SIGNAL_CAST)
    166: #define PETSC_SIGNAL_CAST
    167: #endif

    171: /*@C
    172:    PetscPushSignalHandler - Catches the usual fatal errors and
    173:    calls a user-provided routine.

    175:    Not Collective

    177:     Input Parameter:
    178: +  routine - routine to call when a signal is received
    179: -  ctx - optional context needed by the routine

    181:   Level: developer

    183:    Concepts: signal handler^setting

    185: .seealso: PetscPopSignalHandler(), PetscSignalHandlerDefault(), PetscPushErrorHandler()

    187: @*/
    188: PetscErrorCode  PetscPushSignalHandler(PetscErrorCode (*routine)(int,void*),void *ctx)
    189: {
    190:   struct  SH     *newsh;

    194:   if (!SIGNAL_CLASSID) {
    195:     /* PetscClassIdRegister("Signal",&SIGNAL_CLASSID); */
    196:     SIGNAL_CLASSID = 19;
    197:   }
    198:   if (!SignalSet && routine) {
    199:     /* Do not catch ABRT, CHLD, KILL */
    200: #if !defined(PETSC_MISSING_SIGALRM)
    201:     /* signal(SIGALRM, PETSC_SIGNAL_CAST PetscSignalHandler_Private); */
    202: #endif
    203: #if !defined(PETSC_MISSING_SIGBUS)
    204:     signal(SIGBUS, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
    205: #endif
    206: #if !defined(PETSC_MISSING_SIGCONT)
    207:     /*signal(SIGCONT, PETSC_SIGNAL_CAST PetscSignalHandler_Private);*/
    208: #endif
    209: #if !defined(PETSC_MISSING_SIGFPE)
    210:     signal(SIGFPE,  PETSC_SIGNAL_CAST PetscSignalHandler_Private);
    211: #endif
    212: #if !defined(PETSC_MISSING_SIGHUP)
    213:     signal(SIGHUP, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
    214: #endif
    215: #if !defined(PETSC_MISSING_SIGILL)
    216:     signal(SIGILL,  PETSC_SIGNAL_CAST PetscSignalHandler_Private);
    217: #endif
    218: #if !defined(PETSC_MISSING_SIGINT)
    219:     /* signal(SIGINT, PETSC_SIGNAL_CAST PetscSignalHandler_Private); */
    220: #endif
    221: #if !defined(PETSC_MISSING_SIGPIPE)
    222:     signal(SIGPIPE, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
    223: #endif
    224: #if !defined(PETSC_MISSING_SIGQUIT)
    225:     signal(SIGQUIT, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
    226: #endif
    227: #if !defined(PETSC_MISSING_SIGSEGV)
    228:     signal(SIGSEGV, PETSC_SIGNAL_CAST PetscSignalHandler_Private);
    229: #endif
    230: #if !defined(PETSC_MISSING_SIGSYS)
    231:     signal(SIGSYS,  PETSC_SIGNAL_CAST PetscSignalHandler_Private);
    232: #endif
    233: #if !defined(PETSC_MISSING_SIGTERM)
    234:     signal(SIGTERM,  PETSC_SIGNAL_CAST PetscSignalHandler_Private);
    235: #endif
    236: #if !defined(PETSC_MISSING_SIGTRAP)
    237:     signal(SIGTRAP,  PETSC_SIGNAL_CAST PetscSignalHandler_Private);
    238: #endif
    239: #if !defined(PETSC_MISSING_SIGTSTP)
    240:     /* signal(SIGTSTP,  PETSC_SIGNAL_CAST PetscSignalHandler_Private); */
    241: #endif
    242: #if !defined(PETSC_MISSING_SIGURG)
    243:     signal(SIGURG,  PETSC_SIGNAL_CAST PetscSignalHandler_Private);
    244: #endif
    245: #if !defined(PETSC_MISSING_SIGUSR1)
    246:     /*    signal(SIGUSR1, PETSC_SIGNAL_CAST PetscSignalHandler_Private); */
    247: #endif
    248: #if !defined(PETSC_MISSING_SIGUSR2)
    249:     /* signal(SIGUSR2, PETSC_SIGNAL_CAST PetscSignalHandler_Private); */
    250: #endif
    251:     SignalSet = PETSC_TRUE;
    252:   }
    253:   if (!routine) {
    254: #if !defined(PETSC_MISSING_SIGALRM)
    255:     /* signal(SIGALRM, 0); */
    256: #endif
    257: #if !defined(PETSC_MISSING_SIGBUS)
    258:     signal(SIGBUS,  0);
    259: #endif
    260: #if !defined(PETSC_MISSING_SIGCONT)
    261:     /* signal(SIGCONT, 0); */
    262: #endif
    263: #if !defined(PETSC_MISSING_SIGFPE)
    264:     signal(SIGFPE,  0);
    265: #endif
    266: #if !defined(PETSC_MISSING_SIGHUP)
    267:     signal(SIGHUP,  0);
    268: #endif
    269: #if !defined(PETSC_MISSING_SIGILL)
    270:     signal(SIGILL,  0);
    271: #endif
    272: #if !defined(PETSC_MISSING_SIGINT)
    273:     /* signal(SIGINT,  0); */
    274: #endif
    275: #if !defined(PETSC_MISSING_SIGPIPE)
    276:     signal(SIGPIPE, 0);
    277: #endif
    278: #if !defined(PETSC_MISSING_SIGQUIT)
    279:     signal(SIGQUIT, 0);
    280: #endif
    281: #if !defined(PETSC_MISSING_SIGSEGV)
    282:     signal(SIGSEGV, 0);
    283: #endif
    284: #if !defined(PETSC_MISSING_SIGSYS)
    285:     signal(SIGSYS,  0);
    286: #endif
    287: #if !defined(PETSC_MISSING_SIGTERM)
    288:     signal(SIGTERM, 0);
    289: #endif
    290: #if !defined(PETSC_MISSING_SIGTRAP)
    291:     signal(SIGTRAP, 0);
    292: #endif
    293: #if !defined(PETSC_MISSING_SIGTSTP)
    294:     /* signal(SIGTSTP, 0); */
    295: #endif
    296: #if !defined(PETSC_MISSING_SIGURG)
    297:     signal(SIGURG,  0);
    298: #endif
    299: #if !defined(PETSC_MISSING_SIGUSR1)
    300:     /*    signal(SIGUSR1, 0); */
    301: #endif
    302: #if !defined(PETSC_MISSING_SIGUSR2)
    303:     /* signal(SIGUSR2, 0); */
    304: #endif
    305:     SignalSet = PETSC_FALSE;
    306:   }
    307:   PetscNew(&newsh);
    308:   if (sh) {
    309:     if (sh->classid != SIGNAL_CLASSID) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_COR,"Signal object has been corrupted");
    310:     newsh->previous = sh;
    311:   }  else newsh->previous = 0;
    312:   newsh->handler = routine;
    313:   newsh->ctx     = ctx;
    314:   newsh->classid = SIGNAL_CLASSID;
    315:   sh             = newsh;
    316:   return(0);
    317: }

    321: /*@
    322:    PetscPopSignalHandler - Removes the most last signal handler that was pushed.
    323:        If no signal handlers are left on the stack it will remove the PETSc signal handler.
    324:        (That is PETSc will no longer catch signals).

    326:    Not Collective

    328:   Level: developer

    330:    Concepts: signal handler^setting

    332: .seealso: PetscPushSignalHandler()

    334: @*/
    335: PetscErrorCode  PetscPopSignalHandler(void)
    336: {
    337:   struct SH *tmp;

    340:   if (!sh) return(0);
    341:   if (sh->classid != SIGNAL_CLASSID) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_COR,"Signal object has been corrupted");

    343:   tmp = sh;
    344:   sh  = sh->previous;
    345:   PetscFreeVoid(tmp);
    346:   if (!sh || !sh->handler) {
    347: #if !defined(PETSC_MISSING_SIGALRM)
    348:     /* signal(SIGALRM, 0); */
    349: #endif
    350: #if !defined(PETSC_MISSING_SIGBUS)
    351:     signal(SIGBUS,  0);
    352: #endif
    353: #if !defined(PETSC_MISSING_SIGCONT)
    354:     /* signal(SIGCONT, 0); */
    355: #endif
    356: #if !defined(PETSC_MISSING_SIGFPE)
    357:     signal(SIGFPE,  0);
    358: #endif
    359: #if !defined(PETSC_MISSING_SIGHUP)
    360:     signal(SIGHUP,  0);
    361: #endif
    362: #if !defined(PETSC_MISSING_SIGILL)
    363:     signal(SIGILL,  0);
    364: #endif
    365: #if !defined(PETSC_MISSING_SIGINT)
    366:     /* signal(SIGINT,  0); */
    367: #endif
    368: #if !defined(PETSC_MISSING_SIGPIPE)
    369:     signal(SIGPIPE, 0);
    370: #endif
    371: #if !defined(PETSC_MISSING_SIGQUIT)
    372:     signal(SIGQUIT, 0);
    373: #endif
    374: #if !defined(PETSC_MISSING_SIGSEGV)
    375:     signal(SIGSEGV, 0);
    376: #endif
    377: #if !defined(PETSC_MISSING_SIGSYS)
    378:     signal(SIGSYS,  0);
    379: #endif
    380: #if !defined(PETSC_MISSING_SIGTERM)
    381:     signal(SIGTERM, 0);
    382: #endif
    383: #if !defined(PETSC_MISSING_SIGTRAP)
    384:     signal(SIGTRAP, 0);
    385: #endif
    386: #if !defined(PETSC_MISSING_SIGTSTP)
    387:     /* signal(SIGTSTP, 0); */
    388: #endif
    389: #if !defined(PETSC_MISSING_SIGURG)
    390:     signal(SIGURG,  0);
    391: #endif
    392: #if !defined(PETSC_MISSING_SIGUSR1)
    393:     /*    signal(SIGUSR1, 0); */
    394: #endif
    395: #if !defined(PETSC_MISSING_SIGUSR2)
    396:     /* signal(SIGUSR2, 0); */
    397: #endif
    398:     SignalSet = PETSC_FALSE;
    399:   } else {
    400:     SignalSet = PETSC_TRUE;
    401:   }
    402:   return(0);
    403: }

    406: #if defined(PETSC_HAVE_SETJMP_H) && defined(PETSC_HAVE_SIGINFO_T)
    407: #include <setjmp.h>
    408: PETSC_VISIBILITY_INTERNAL jmp_buf PetscSegvJumpBuf;
    409: /*
    410:     This routine is called if a segmentation violation, i.e. inaccessible memory access

    413:     It simply unrolls the UNIX signal and returns to the location where setjump(PetscSeqvJumpBuf) is declared.
    414: */
    415: PETSC_INTERN void PetscSegv_sigaction(int signal, siginfo_t *si, void *arg)
    416: {
    417:   longjmp(PetscSegvJumpBuf,1);
    418:   return;
    419: }
    420: #endif