stdlib/abort.c

   1 /* Copyright (C) 1991,1993,1995-1998,2001,2002,2009,2011
   2    Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <bits/libc-lock.h>
  21 #include <signal.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26
  27 /* Try to get a machine dependent instruction which will make the
  28    program crash.  This is used in case everything else fails.  */
  29 #include <abort-instr.h>
  30 #ifndef ABORT_INSTRUCTION
  31 /* No such instruction is available.  */
  32 # define ABORT_INSTRUCTION
  33 #endif
  34
  35 #include <libio/libioP.h>
  36 #define fflush(s) _IO_flush_all_lockp (0)
  37
  38 /* Exported variable to locate abort message in core files etc.  */
  39 struct abort_msg_s *__abort_msg __attribute__ ((nocommon));
  40 libc_hidden_def (__abort_msg)
  41
  42 /* We must avoid to run in circles.  Therefore we remember how far we
  43    already got.  */
  44 static int stage;
  45
  46 /* We should be prepared for multiple threads trying to run abort.  */
  47 __libc_lock_define_initialized_recursive (static, lock);
  48
  49
  50 /* Cause an abnormal program termination with core-dump.  */
  51 void
  52 abort (void)
  53 {
  54   struct sigaction act;
  55   sigset_t sigs;
  56
  57   /* First acquire the lock.  */
  58   __libc_lock_lock_recursive (lock);
  59
  60   /* Now it's for sure we are alone.  But recursive calls are possible.  */
  61
  62   /* Unlock SIGABRT.  */
  63   if (stage == 0)
  64     {
  65       ++stage;
  66       if (__sigemptyset (&sigs) == 0 &&
  67           __sigaddset (&sigs, SIGABRT) == 0)
  68         __sigprocmask (SIG_UNBLOCK, &sigs, (sigset_t *) NULL);
  69     }
  70
  71   /* Flush all streams.  We cannot close them now because the user
  72      might have registered a handler for SIGABRT.  */
  73   if (stage == 1)
  74     {
  75       ++stage;
  76       fflush (NULL);
  77     }
  78
  79   /* Send signal which possibly calls a user handler.  */
  80   if (stage == 2)
  81     {
  82       /* This stage is special: we must allow repeated calls of
  83          `abort' when a user defined handler for SIGABRT is installed.
  84          This is risky since the `raise' implementation might also
  85          fail but I don't see another possibility.  */
  86       int save_stage = stage;
  87
  88       stage = 0;
  89       __libc_lock_unlock_recursive (lock);
  90
  91       raise (SIGABRT);
  92
  93       __libc_lock_lock_recursive (lock);
  94       stage = save_stage + 1;
  95     }
  96
  97   /* There was a handler installed.  Now remove it.  */
  98   if (stage == 3)
  99     {
 100       ++stage;
 101       memset (&act, '\0', sizeof (struct sigaction));
 102       act.sa_handler = SIG_DFL;
 103       __sigfillset (&act.sa_mask);
 104       act.sa_flags = 0;
 105       __sigaction (SIGABRT, &act, NULL);
 106     }
 107
 108   /* Now close the streams which also flushes the output the user
 109      defined handler might has produced.  */
 110   if (stage == 4)
 111     {
 112       ++stage;
 113       __fcloseall ();
 114     }
 115
 116   /* Try again.  */
 117   if (stage == 5)
 118     {
 119       ++stage;
 120       raise (SIGABRT);
 121     }
 122
 123   /* Now try to abort using the system specific command.  */
 124   if (stage == 6)
 125     {
 126       ++stage;
 127       ABORT_INSTRUCTION;
 128     }
 129
 130   /* If we can't signal ourselves and the abort instruction failed, exit.  */
 131   if (stage == 7)
 132     {
 133       ++stage;
 134       _exit (127);
 135     }
 136
 137   /* If even this fails try to use the provided instruction to crash
 138      or otherwise make sure we never return.  */
 139   while (1)
 140     /* Try for ever and ever.  */
 141     ABORT_INSTRUCTION;
 142 }
 143 libc_hidden_def (abort)