mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-27 07:20:11 +00:00
7553131847
glibc defines the stack_t type with the tag struct sigaltstack. This is not permitted by POSIX; sigaltstack is only reserved with file scope in the namespace of ordinary identifiers, not the tag namespace, and in the case where stack_t is obtained from ucontext.h rather than signal.h, it's not reserved with file scope at all. This patch removes the tag accordingly and updates uses in glibc of struct sigaltstack. This is similar to the removal of the "struct siginfo" tag a few years ago: C++ name mangling changes are an unavoidable consequence. A NEWS item is added to note the changed mangling. There is inevitably some risk of breaking builds of anything that relies on the struct sigaltstack name (though the first few hits I looked at from codesearch.debian.net generally seemed to involve code that could use the stack_t name conditionally, so depending on how they determine the conditionals they may work with glibc not defining the struct tag anyway). Tested for x86_64 and x86, and with build-many-glibcs.py. [BZ #21517] * bits/types/stack_t.h (stack_t): Remove struct tag. * sysdeps/unix/sysv/linux/bits/types/stack_t.h (stack_t): Likewise. * sysdeps/unix/sysv/linux/mips/bits/types/stack_t.h (stack_t): Likewise. * debug/segfault.c (install_handler): Use stack_t instead of struct sigaltstack. * hurd/hurd/signal.h (struct hurd_sigstate): Likewise. * hurd/trampoline.c (_hurd_setup_sighandler): Likewise. * include/signal.h (__sigaltstack): Likwise. * signal/sigaltstack.c (__sigaltstack): Likewise. * signal/signal.h (sigaltstack): Likewise. * sysdeps/mach/hurd/i386/signal-defines.sym (SIGALTSTACK__SS_SP__OFFSET): Likewise. (SIGALTSTACK__SS_SIZE__OFFSET): Likewise. (SIGALTSTACK__SS_FLAGS__OFFSET): Likewise. * sysdeps/mach/hurd/sigaltstack.c (__sigaltstack): Likewise. * sysdeps/mach/hurd/sigstack.c (sigstack): Likewise. * sysdeps/unix/sysv/linux/alpha/sys/procfs.h (struct elf_prstatus): Likewise. * sysdeps/unix/sysv/linux/hppa/____longjmp_chk.c (CHECK_SP): Likewise. * sysdeps/unix/sysv/linux/ia64/sys/procfs.h (struct elf_prstatus): Likewise. * sysdeps/unix/sysv/linux/m68k/____longjmp_chk.c (CHECK_SP): Likewise. * sysdeps/unix/sysv/linux/powerpc/sys/procfs.h (struct elf_prstatus): Likewise. * sysdeps/unix/sysv/linux/sh/sys/procfs.h (struct elf_prstatus): Likewise. * sysdeps/unix/sysv/linux/sys/procfs.h (struct elf_prstatus): Likewise.
211 lines
5.6 KiB
C
211 lines
5.6 KiB
C
/* Catch segmentation faults and print backtrace.
|
|
Copyright (C) 1998-2017 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with the GNU C Library; if not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include <alloca.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <execinfo.h>
|
|
#include <fcntl.h>
|
|
#include <signal.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <_itoa.h>
|
|
#include <ldsodefs.h>
|
|
|
|
/* This file defines macros to access the content of the sigcontext element
|
|
passed up by the signal handler. */
|
|
#include <sigcontextinfo.h>
|
|
|
|
/* Get code to possibly dump the content of all registers. */
|
|
#include <register-dump.h>
|
|
|
|
/* We'll use this a lot. */
|
|
#define WRITE_STRING(s) write (fd, s, strlen (s))
|
|
|
|
/* Name of the output file. */
|
|
static const char *fname;
|
|
|
|
|
|
/* We better should not use `strerror' since it can call far too many
|
|
other functions which might fail. Do it here ourselves. */
|
|
static void
|
|
write_strsignal (int fd, int signal)
|
|
{
|
|
if (signal < 0 || signal >= _NSIG || _sys_siglist[signal] == NULL)
|
|
{
|
|
char buf[30];
|
|
char *ptr = _itoa_word (signal, &buf[sizeof (buf)], 10, 0);
|
|
WRITE_STRING ("signal ");
|
|
write (fd, buf, &buf[sizeof (buf)] - ptr);
|
|
}
|
|
else
|
|
WRITE_STRING (_sys_siglist[signal]);
|
|
}
|
|
|
|
|
|
/* This function is called when a segmentation fault is caught. The system
|
|
is in an unstable state now. This means especially that malloc() might
|
|
not work anymore. */
|
|
static void
|
|
catch_segfault (int signal, SIGCONTEXT ctx)
|
|
{
|
|
int fd, cnt, i;
|
|
void **arr;
|
|
struct sigaction sa;
|
|
uintptr_t pc;
|
|
|
|
/* This is the name of the file we are writing to. If none is given
|
|
or we cannot write to this file write to stderr. */
|
|
fd = 2;
|
|
if (fname != NULL)
|
|
{
|
|
fd = open (fname, O_TRUNC | O_WRONLY | O_CREAT, 0666);
|
|
if (fd == -1)
|
|
fd = 2;
|
|
}
|
|
|
|
WRITE_STRING ("*** ");
|
|
write_strsignal (fd, signal);
|
|
WRITE_STRING ("\n");
|
|
|
|
#ifdef REGISTER_DUMP
|
|
REGISTER_DUMP;
|
|
#endif
|
|
|
|
WRITE_STRING ("\nBacktrace:\n");
|
|
|
|
/* Get the backtrace. */
|
|
arr = alloca (256 * sizeof (void *));
|
|
cnt = backtrace (arr, 256);
|
|
|
|
/* Now try to locate the PC from signal context in the backtrace.
|
|
Normally it will be found at arr[2], but it might appear later
|
|
if there were some signal handler wrappers. Allow a few bytes
|
|
difference to cope with as many arches as possible. */
|
|
pc = (uintptr_t) GET_PC (ctx);
|
|
for (i = 0; i < cnt; ++i)
|
|
if ((uintptr_t) arr[i] >= pc - 16 && (uintptr_t) arr[i] <= pc + 16)
|
|
break;
|
|
|
|
/* If we haven't found it, better dump full backtrace even including
|
|
the signal handler frames instead of not dumping anything. */
|
|
if (i == cnt)
|
|
i = 0;
|
|
|
|
/* Now generate nicely formatted output. */
|
|
__backtrace_symbols_fd (arr + i, cnt - i, fd);
|
|
|
|
#ifdef HAVE_PROC_SELF
|
|
/* Now the link map. */
|
|
int mapfd = open ("/proc/self/maps", O_RDONLY);
|
|
if (mapfd != -1)
|
|
{
|
|
write (fd, "\nMemory map:\n\n", 14);
|
|
|
|
char buf[256];
|
|
ssize_t n;
|
|
|
|
while ((n = TEMP_FAILURE_RETRY (read (mapfd, buf, sizeof (buf)))) > 0)
|
|
TEMP_FAILURE_RETRY (write (fd, buf, n));
|
|
|
|
close (mapfd);
|
|
}
|
|
#endif
|
|
|
|
/* Pass on the signal (so that a core file is produced). */
|
|
sa.sa_handler = SIG_DFL;
|
|
sigemptyset (&sa.sa_mask);
|
|
sa.sa_flags = 0;
|
|
sigaction (signal, &sa, NULL);
|
|
raise (signal);
|
|
}
|
|
|
|
|
|
static void
|
|
__attribute__ ((constructor))
|
|
install_handler (void)
|
|
{
|
|
struct sigaction sa;
|
|
const char *sigs = getenv ("SEGFAULT_SIGNALS");
|
|
const char *name;
|
|
|
|
sa.sa_handler = (void *) catch_segfault;
|
|
sigemptyset (&sa.sa_mask);
|
|
sa.sa_flags = SA_RESTART;
|
|
|
|
/* Maybe we are expected to use an alternative stack. */
|
|
if (getenv ("SEGFAULT_USE_ALTSTACK") != 0)
|
|
{
|
|
void *stack_mem = malloc (2 * SIGSTKSZ);
|
|
stack_t ss;
|
|
|
|
if (stack_mem != NULL)
|
|
{
|
|
ss.ss_sp = stack_mem;
|
|
ss.ss_flags = 0;
|
|
ss.ss_size = 2 * SIGSTKSZ;
|
|
|
|
if (sigaltstack (&ss, NULL) == 0)
|
|
sa.sa_flags |= SA_ONSTACK;
|
|
}
|
|
}
|
|
|
|
if (sigs == NULL)
|
|
sigaction (SIGSEGV, &sa, NULL);
|
|
else if (sigs[0] == '\0')
|
|
/* Do not do anything. */
|
|
return;
|
|
else
|
|
{
|
|
const char *where;
|
|
int all = __strcasecmp (sigs, "all") == 0;
|
|
|
|
#define INSTALL_FOR_SIG(sig, name) \
|
|
where = __strcasestr (sigs, name); \
|
|
if (all || (where != NULL \
|
|
&& (where == sigs || !isalnum (where[-1])) \
|
|
&& !isalnum (where[sizeof (name) - 1]))) \
|
|
sigaction (sig, &sa, NULL);
|
|
|
|
INSTALL_FOR_SIG (SIGSEGV, "segv");
|
|
INSTALL_FOR_SIG (SIGILL, "ill");
|
|
#ifdef SIGBUS
|
|
INSTALL_FOR_SIG (SIGBUS, "bus");
|
|
#endif
|
|
#ifdef SIGSTKFLT
|
|
INSTALL_FOR_SIG (SIGSTKFLT, "stkflt");
|
|
#endif
|
|
INSTALL_FOR_SIG (SIGABRT, "abrt");
|
|
INSTALL_FOR_SIG (SIGFPE, "fpe");
|
|
}
|
|
|
|
/* Preserve the output file name if there is any given. */
|
|
name = getenv ("SEGFAULT_OUTPUT_NAME");
|
|
if (name != NULL && name[0] != '\0')
|
|
{
|
|
int ret = access (name, R_OK | W_OK);
|
|
|
|
if (ret == 0 || (ret == -1 && errno == ENOENT))
|
|
fname = __strdup (name);
|
|
}
|
|
}
|