sysdeps/generic/abort.c

   1 /* Copyright (C) 1991, 93, 95, 96, 97, 98 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 Library General Public License as
   6    published by the Free Software Foundation; either version 2 of the
   7    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    Library General Public License for more details.
  13
  14    You should have received a copy of the GNU Library General Public
  15    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  16    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17    Boston, MA 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/iolibio.h>
  36 # define fflush(s) _IO_fflush (s)
  37 #endif
  38
  39 /* We must avoid to run in circles.  Therefore we remember how far we
  40    already got.  */
  41 static int stage;
  42
  43 /* We should be prepared for multiple threads trying to run abort.  */
  44 __libc_lock_define_initialized_recursive (static, lock);
  45
  46
  47 /* Cause an abnormal program termination with core-dump.  */
  48 void
  49 abort (void)
  50 {
  51   struct sigaction act;
  52   sigset_t sigs;
  53
  54   /* First acquire the lock.  */
  55   __libc_lock_lock_recursive (lock);
  56
  57   /* Now it's for sure we are alone.  But recursive calls are possible.  */
  58
  59   /* Unlock SIGABRT.  */
  60   if (stage == 0)
  61     {
  62       ++stage;
  63       if (__sigemptyset (&sigs) == 0 &&
  64           __sigaddset (&sigs, SIGABRT) == 0)
  65         __sigprocmask (SIG_UNBLOCK, &sigs, (sigset_t *) NULL);
  66     }
  67
  68   /* Flush all streams.  We cannot close them now because the user
  69      might have registered a handler for SIGABRT.  */
  70   if (stage == 1)
  71     {
  72       ++stage;
  73       fflush (NULL);
  74     }
  75
  76   /* Send signal which possibly calls a user handler.  */
  77   if (stage == 2)
  78     {
  79       /* This stage is special: we must allow repeated calls of
  80          `abort' when a user defined handler for SIGABRT is installed.
  81          This is risky since the `raise' implementation might also
  82          fail but I don't see another possibility.  */
  83       int save_stage = stage;
  84
  85       stage = 0;
  86       __libc_lock_unlock_recursive (lock);
  87
  88       raise (SIGABRT);
  89
  90       __libc_lock_lock_recursive (lock);
  91       stage = save_stage + 1;
  92     }
  93
  94   /* There was a handler installed.  Now remove it.  */
  95   if (stage == 3)
  96     {
  97       ++stage;
  98       memset (&act, '\0', sizeof (struct sigaction));
  99       act.sa_handler = SIG_DFL;
 100       __sigfillset (&act.sa_mask);
 101       act.sa_flags = 0;
 102       __sigaction (SIGABRT, &act, NULL);
 103     }
 104
 105   /* Now close the streams which also flushes the output the user
 106      defined handler might has produced.  */
 107   if (stage == 4)
 108     {
 109       ++stage;
 110       __fcloseall ();
 111     }
 112
 113   /* Try again.  */
 114   if (stage == 5)
 115     {
 116       ++stage;
 117       raise (SIGABRT);
 118     }
 119
 120   /* Now try to abort using the system specific command.  */
 121   if (stage == 6)
 122     {
 123       ++stage;
 124       ABORT_INSTRUCTION;
 125     }
 126
 127   /* If we can't signal ourselves and the abort instruction failed, exit.  */
 128   if (stage == 7)
 129     {
 130       ++stage;
 131       _exit (127);
 132     }
 133
 134   /* If even this fails try to use the provided instruction to crash
 135      or otherwise make sure we never return.  */
 136   while (1)
 137     /* Try for ever and ever.  */
 138     ABORT_INSTRUCTION;
 139 }