stdlib/abort.c

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