diff options
Diffstat (limited to 'debug')
| -rw-r--r-- | debug/Makefile | 14 | ||||
| -rw-r--r-- | debug/tst-backtrace2.c | 111 | ||||
| -rw-r--r-- | debug/tst-backtrace3.c | 95 | ||||
| -rw-r--r-- | debug/tst-backtrace4.c | 134 | ||||
| -rw-r--r-- | debug/tst-backtrace5.c | 148 |
5 files changed, 501 insertions, 1 deletions
diff --git a/debug/Makefile b/debug/Makefile index 40446d4af5..55017d327c 100644 --- a/debug/Makefile +++ b/debug/Makefile @@ -121,10 +121,22 @@ LDLIBS-tst-lfschk4 = -lstdc++ LDLIBS-tst-lfschk5 = -lstdc++ LDLIBS-tst-lfschk6 = -lstdc++ +# backtrace_symbols only works if we link with -rdynamic. backtrace +# requires unwind tables on most architectures. +CFLAGS-tst-backtrace2.c += -funwind-tables +CFLAGS-tst-backtrace3.c += -funwind-tables +CFLAGS-tst-backtrace4.c += -funwind-tables +CFLAGS-tst-backtrace5.c += -funwind-tables +LDFLAGS-tst-backtrace2 = -rdynamic +LDFLAGS-tst-backtrace3 = -rdynamic +LDFLAGS-tst-backtrace4 = -rdynamic +LDFLAGS-tst-backtrace5 = -rdynamic + tests = backtrace-tst tst-longjmp_chk tst-chk1 tst-chk2 tst-chk3 \ tst-lfschk1 tst-lfschk2 tst-lfschk3 test-strcpy_chk test-stpcpy_chk \ tst-chk4 tst-chk5 tst-chk6 tst-lfschk4 tst-lfschk5 tst-lfschk6 \ - tst-longjmp_chk2 + tst-longjmp_chk2 tst-backtrace2 tst-backtrace3 tst-backtrace4 \ + tst-backtrace5 tests-ifunc := $(stpcpy_chk strcpy_chk:%=test-%-ifunc) tests += $(tests-ifunc) diff --git a/debug/tst-backtrace2.c b/debug/tst-backtrace2.c new file mode 100644 index 0000000000..e1d4572c35 --- /dev/null +++ b/debug/tst-backtrace2.c @@ -0,0 +1,111 @@ +/* Test backtrace and backtrace_symbols. + Copyright (C) 2009-2013 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + 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 <execinfo.h> +#include <search.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +static int do_test (void); +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" + +/* Set to a non-zero value if the test fails. */ +int ret; + +/* Accesses to X are used to prevent optimization. */ +volatile int x; + +/* Called if the test fails. */ +#define FAIL() \ + do { printf ("Failure on line %d\n", __LINE__); ret = 1; } while (0) + +/* The backtrace should include at least f1, f2, f3, and do_test. */ +#define NUM_FUNCTIONS 4 + +/* Use this attribute to prevent inlining, so that all expected frames + are present. */ +#define NO_INLINE __attribute__ ((noinline)) + +NO_INLINE void +fn1 (void) +{ + void *addresses[NUM_FUNCTIONS]; + char **symbols; + int n; + int i; + + /* Get the backtrace addresses. */ + n = backtrace (addresses, sizeof (addresses) / sizeof (addresses[0])); + printf ("Obtained backtrace with %d functions\n", n); + /* Check that there are at least four functions. */ + if (n < NUM_FUNCTIONS) + { + FAIL (); + return; + } + /* Convert them to symbols. */ + symbols = backtrace_symbols (addresses, n); + /* Check that symbols were obtained. */ + if (symbols == NULL) + { + FAIL (); + return; + } + for (i = 0; i < n; ++i) + printf ("Function %d: %s\n", i, symbols[i]); + /* Check that the function names obtained are accurate. */ + if (strstr (symbols[0], "fn1") == NULL) + { + FAIL (); + return; + } + /* Symbol names are not available for static functions, so we do not + check f2. */ + if (strstr (symbols[2], "fn3") == NULL) + { + FAIL (); + return; + } + /* Symbol names are not available for static functions, so we do not + check do_test. */ +} + +NO_INLINE static int +fn2 (void) +{ + fn1 (); + /* Prevent tail calls. */ + return x; +} + +NO_INLINE int +fn3 (void) +{ + fn2(); + /* Prevent tail calls. */ + return x; +} + +NO_INLINE static int +do_test (void) +{ + fn3 (); + return ret; +} diff --git a/debug/tst-backtrace3.c b/debug/tst-backtrace3.c new file mode 100644 index 0000000000..4d3309b3a0 --- /dev/null +++ b/debug/tst-backtrace3.c @@ -0,0 +1,95 @@ +/* Test backtrace and backtrace_symbols for recursive calls. + Copyright (C) 2010-2013 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + 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 <execinfo.h> +#include <search.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +static int do_test (void); +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" + +/* Set to a non-zero value if the test fails. */ +int ret; + +/* Accesses to X are used to prevent optimization. */ +volatile int x; + +/* Called if the test fails. */ +#define FAIL() \ + do { printf ("Failure on line %d\n", __LINE__); ret = 1; } while (0) + +/* The backtrace should include at least 3 * fn, and do_test. */ +#define NUM_FUNCTIONS 4 + +/* Use this attribute to prevent inlining, so that all expected frames + are present. */ +#define NO_INLINE __attribute__ ((noinline)) + +NO_INLINE int +fn (int c) +{ + void *addresses[NUM_FUNCTIONS]; + char **symbols; + int n; + int i; + + if (c > 0) + { + fn (c - 1); + return x; + } + /* Get the backtrace addresses. */ + n = backtrace (addresses, sizeof (addresses) / sizeof (addresses[0])); + printf ("Obtained backtrace with %d functions\n", n); + /* Check that there are at least four functions. */ + if (n < NUM_FUNCTIONS) + { + FAIL (); + return 1; + } + /* Convert them to symbols. */ + symbols = backtrace_symbols (addresses, n); + /* Check that symbols were obtained. */ + if (symbols == NULL) + { + FAIL (); + return 1; + } + for (i = 0; i < n; ++i) + printf ("Function %d: %s\n", i, symbols[i]); + /* Check that the function names obtained are accurate. */ + for (i = 0; i < n - 1; ++i) + if (strstr (symbols[i], "fn") == NULL) + { + FAIL (); + return 1; + } + /* Symbol names are not available for static functions, so we do not + check do_test. */ + return x; +} + +NO_INLINE static int +do_test (void) +{ + fn (2); + return ret; +} diff --git a/debug/tst-backtrace4.c b/debug/tst-backtrace4.c new file mode 100644 index 0000000000..41a3f51349 --- /dev/null +++ b/debug/tst-backtrace4.c @@ -0,0 +1,134 @@ +/* Test backtrace and backtrace_symbols for signal frames. + Copyright (C) 2011-2013 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + 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 <execinfo.h> +#include <search.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <signal.h> +#include <unistd.h> + +static int do_test (void); +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" + +/* Set to a non-zero value if the test fails. */ +volatile int ret; + +/* Accesses to X are used to prevent optimization. */ +volatile int x; + +/* Called if the test fails. */ +#define FAIL() \ + do { printf ("Failure on line %d\n", __LINE__); ret = 1; } while (0) + +/* The backtrace should include at least handle_signal, a signal + trampoline, 3 * fn, and do_test. */ +#define NUM_FUNCTIONS 6 + +/* Use this attribute to prevent inlining, so that all expected frames + are present. */ +#define NO_INLINE __attribute__ ((noinline)) + +volatile int sig_handled = 0; + +void +handle_signal (int signum) +{ + void *addresses[NUM_FUNCTIONS]; + char **symbols; + int n; + int i; + + sig_handled = 1; + + /* Get the backtrace addresses. */ + n = backtrace (addresses, sizeof (addresses) / sizeof (addresses[0])); + printf ("Obtained backtrace with %d functions\n", n); + /* Check that there are at least six functions. */ + if (n < NUM_FUNCTIONS) + { + FAIL (); + return; + } + /* Convert them to symbols. */ + symbols = backtrace_symbols (addresses, n); + /* Check that symbols were obtained. */ + if (symbols == NULL) + { + FAIL (); + return; + } + for (i = 0; i < n; ++i) + printf ("Function %d: %s\n", i, symbols[i]); + /* Check that the function names obtained are accurate. */ + if (strstr (symbols[0], "handle_signal") == NULL) + { + FAIL (); + return; + } + /* Do not check name for signal trampoline. */ + for (i = 2; i < n - 1; i++) + if (strstr (symbols[i], "fn") == NULL) + { + FAIL (); + return; + } + /* Symbol names are not available for static functions, so we do not + check do_test. */ +} + +NO_INLINE int +fn (int c) +{ + pid_t parent_pid, child_pid; + + if (c > 0) + { + fn (c - 1); + return x; + } + + signal (SIGUSR1, handle_signal); + parent_pid = getpid (); + + child_pid = fork (); + if (child_pid == (pid_t) -1) + abort (); + else if (child_pid == 0) + { + sleep (1); + kill (parent_pid, SIGUSR1); + _exit (0); + } + + /* In the parent. */ + while (sig_handled == 0) + ; + + return 0; +} + +NO_INLINE static int +do_test (void) +{ + fn (2); + return ret; +} diff --git a/debug/tst-backtrace5.c b/debug/tst-backtrace5.c new file mode 100644 index 0000000000..eb16c23ce5 --- /dev/null +++ b/debug/tst-backtrace5.c @@ -0,0 +1,148 @@ +/* Test backtrace and backtrace_symbols for signal frames, where a + system call was interrupted by a signal. + Copyright (C) 2011-2013 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + 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 <execinfo.h> +#include <search.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <signal.h> +#include <unistd.h> + +static int do_test (void); +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" + +/* Set to a non-zero value if the test fails. */ +volatile int ret; + +/* Accesses to X are used to prevent optimization. */ +volatile int x; + +/* Called if the test fails. */ +#define FAIL() \ + do { printf ("Failure on line %d\n", __LINE__); ret = 1; } while (0) + +/* The backtrace should include at least handle_signal, a signal + trampoline, read, 3 * fn, and do_test. */ +#define NUM_FUNCTIONS 7 + +/* Use this attribute to prevent inlining, so that all expected frames + are present. */ +#define NO_INLINE __attribute__ ((noinline)) + +void +handle_signal (int signum) +{ + void *addresses[NUM_FUNCTIONS]; + char **symbols; + int n; + int i; + + /* Get the backtrace addresses. */ + n = backtrace (addresses, sizeof (addresses) / sizeof (addresses[0])); + printf ("Obtained backtrace with %d functions\n", n); + /* Check that there are at least seven functions. */ + if (n < NUM_FUNCTIONS) + { + FAIL (); + return; + } + /* Convert them to symbols. */ + symbols = backtrace_symbols (addresses, n); + /* Check that symbols were obtained. */ + if (symbols == NULL) + { + FAIL (); + return; + } + for (i = 0; i < n; ++i) + printf ("Function %d: %s\n", i, symbols[i]); + /* Check that the function names obtained are accurate. */ + if (strstr (symbols[0], "handle_signal") == NULL) + { + FAIL (); + return; + } + /* Do not check name for signal trampoline. */ + i = 2; + if (strstr (symbols[i++], "read") == NULL) + { + /* Perhaps symbols[2] is __kernel_vsyscall? */ + if (strstr (symbols[i++], "read") == NULL) + { + FAIL (); + return; + } + } + for (; i < n - 1; i++) + if (strstr (symbols[i], "fn") == NULL) + { + FAIL (); + return; + } + /* Symbol names are not available for static functions, so we do not + check do_test. */ +} + +NO_INLINE int +fn (int c) +{ + pid_t parent_pid, child_pid; + int pipefd[2]; + char r[1]; + struct sigaction act; + + if (c > 0) + { + fn (c - 1); + return x; + } + + memset (&act, 0, sizeof (act)); + act.sa_handler = handle_signal; + sigemptyset (&act.sa_mask); + sigaction (SIGUSR1, &act, NULL); + parent_pid = getpid (); + if (pipe (pipefd) == -1) + abort (); + + child_pid = fork (); + if (child_pid == (pid_t) -1) + abort (); + else if (child_pid == 0) + { + sleep (1); + kill (parent_pid, SIGUSR1); + _exit (0); + } + + /* In the parent. */ + read (pipefd[0], r, 1); + + return 0; +} + +NO_INLINE static int +do_test (void) +{ + fn (2); + return ret; +} |