[patch] Use executable_for_core in dwfl_build_id_find_elf
by Jan Kratochvil
Hi Mark,
I believe if executable_for_core is set it means the Dwfl is really for a core
file and the executable has been explicitly set by the user. Therefore it
should override/precede any searches.
I was experimenting also with replacing [exe]/[pie] by executable_for_core but
I do not see any end-user visible benefit from it and it is also an unrelated
patch.
OK for check-in?
Thanks,
Jan
10 years, 3 months
pkg-config
by Masatake YAMATO
Do you have a plan to provide *.pc files for libraries of
elfutils?
With the files using the libraries from an application becomes
easier.
Masatake YAMATO
10 years, 3 months
[PATCH v2] stack: show binary and source file names where a function is defined
by Masatake YAMATO
This patch adds the module and source file information to the
each stack trace line. `-m' is for module file information
and `-s' is for source file information. `-v' is for both and more.
This is based on private discussion with Jan Kratochvil
<jan.kratochvil(a)redhat.com>.
In v2 patch, `-s' and `-m' options are introduced instead
of using `-v' repeatedly as suggested by Mark Wielaard <mjw(a)redhat.com>.
Signed-off-by: Masatake YAMATO <yamato(a)redhat.com>
---
src/ChangeLog | 8 ++++++++
src/stack.c | 40 ++++++++++++++++++++++++++++++++++++----
2 files changed, 44 insertions(+), 4 deletions(-)
diff --git a/src/ChangeLog b/src/ChangeLog
index f899858..454d6dd 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,11 @@
+2013-12-16 Masatake YAMATO <yamato(a)redhat.com>
+
+ * stack.c (show_module, show_source): New variables.
+ (parse_opt): set show_module if -m option is given.
+ set show_source if -s option is given.
+ (main): Added `-m', `-s', and `-v' to the help message.
+ (frame_callback): Print module and source file information.
+
2013-11-25 Petr Machata <pmachata(a)redhat.com>
* elflint.c (valid_e_machine): Add EM_AARCH64.
diff --git a/src/stack.c b/src/stack.c
index f428ed0..ed684c6 100644
--- a/src/stack.c
+++ b/src/stack.c
@@ -37,6 +37,8 @@ ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;
ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;
static bool verbose = false;
+static bool show_module = false;
+static bool show_source = false;
static int
frame_callback (Dwfl_Frame *state, void *arg)
@@ -78,7 +80,26 @@ frame_callback (Dwfl_Frame *state, void *arg)
printf ("#%-2u 0x%0*" PRIx64, (*framenop)++, width, (uint64_t) pc);
if (verbose)
printf ("%4s", ! isactivation ? "- 1" : "");
- printf (" %s\n", symname);
+ printf (" %s", symname);
+ if (show_module)
+ {
+ const char* fname;
+
+ fname = dwfl_module_info(mod, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+ printf (" - %s", fname? fname: "?");
+ }
+ if (show_source)
+ {
+ Dwfl_Line * lineobj;
+ int line, col;
+ const char* sname;
+
+ lineobj = dwfl_module_getsrc(mod, pc_adjusted);
+ line = col = -1;
+ sname = lineobj? (dwfl_lineinfo(lineobj, NULL, &line, &col, NULL, NULL)?: "?"): "?";
+ printf(" (%s:%d:%d)", sname, line, col);
+ }
+ printf ("\n");
return DWARF_CB_OK;
}
@@ -117,8 +138,16 @@ parse_opt (int key, char *arg __attribute__ ((unused)),
state->child_inputs[0] = state->input;
break;
+ case 'm':
+ show_module = true;
+ break;
+
+ case 's':
+ show_source = true;
+ break;
+
case 'v':
- verbose = true;
+ verbose = show_source = show_module = true;
break;
default:
@@ -140,7 +169,10 @@ main (int argc, char **argv)
const struct argp_option options[] =
{
- { "verbose", 'v', NULL, 0, N_("Additionally show frames activation"), 0 },
+ { "module", 'm', NULL, 0, N_("Additionally show module file information"), 0 },
+ { "source", 's', NULL, 0, N_("Additionally show source file information"), 0 },
+ { "verbose", 'v', NULL, 0, N_("Additionally show frames activation "
+ "including module and source file information"), 0 },
{ NULL, 0, NULL, 0, NULL, 0 }
};
@@ -165,7 +197,7 @@ Only real user processes are supported, no kernel or process maps."),
argp_parse (&argp, argc, argv, 0, &remaining, &dwfl);
assert (dwfl != NULL);
if (remaining != argc)
- error (2, 0, "eu-stack [--debuginfo-path=<path>] {-p <process id>|"
+ error (2, 0, "eu-stack [-m] [-s] [-v] [--debuginfo-path=<path>] {-p <process id>|"
"--core=<file> [--executable=<file>]|--help}");
/* dwfl_linux_proc_report has been already called from dwfl_standard_argp's
--
1.8.3.1
10 years, 3 months
[obv] Fix forgotten call of ebl_dwarf_to_regno
by Jan Kratochvil
Hi Mark,
it has been posted in
[patch 4/4] unwinder: s390 and s390x
with your comment
OK. Shouldn't this have been part of the previous (ppc) patch?
Checked in.
Thanks,
Jan
10 years, 3 months
[PATCH] Introduce tids cache for dwfl_getthreads
by Masatake YAMATO
dwfl_getthreads can be called once for the same Dwfl object. In
dwfl_getthreads, directory entries under /proc/$pid/tasks are
traversed and the directory descriptor points the end of
/proc/$pid/tasks. Even if dwfl_getthreads called again, no
more directory entry can be read from the descriptor.
(1)rewinding the directory or (2) caching the threads at the initial
traversing can permit calling dwfl_getthreads repeatedly.
This patch implements (2). (2) is faster than (1) because
(2) can avoid overheads of readdir.
Following patch for stack.c is used for testing.
This patch makes stack command calling dwfl_getthreads twice.
diff --git a/src/stack.c b/src/stack.c
index f428ed0..3b7a319 100644
--- a/src/stack.c
+++ b/src/stack.c
@@ -183,6 +183,16 @@ Only real user processes are supported, no kernel or process maps."),
default:
abort ();
}
+ switch (dwfl_getthreads (dwfl, thread_callback, NULL))
+ {
+ case DWARF_CB_OK:
+ break;
+ case -1:
+ error (0, 0, "dwfl_getthreads: %s", dwfl_errmsg (-1));
+ break;
+ default:
+ abort ();
+ }
dwfl_end (dwfl);
return 0;
Signed-off-by: Masatake YAMATO <yamato(a)redhat.com>
---
libdwfl/ChangeLog | 13 ++++++++
libdwfl/linux-pid-attach.c | 80 ++++++++++++++++++++++++++++++++++++++++++++--
2 files changed, 90 insertions(+), 3 deletions(-)
diff --git a/libdwfl/ChangeLog b/libdwfl/ChangeLog
index ff38108..1b134e1 100644
--- a/libdwfl/ChangeLog
+++ b/libdwfl/ChangeLog
@@ -1,3 +1,16 @@
+2013-12-16 Masatake YAMATO <yamato(a)redhat.com>
+
+ Introduce tids cache.
+ * linux-pid-attach.c (tids_vector): New struct type.
+ (pid_arg::vec): New field.
+ (pid_next_thread_in_vec): New function.
+ (pid_next_thread_in_dir): New function.
+ (pid_next_thread): Use above two functions.
+ (pid_detach): free pid_arg::vec field. closedir only
+ dir pid_arg::vec is not NULL.
+ (__libdwfl_attach_state_for_pid): Initialize pid_arg::vec
+ related field.
+
2013-12-15 Jan Kratochvil <jan.kratochvil(a)redhat.com>
unwinder: ppc and ppc64
diff --git a/libdwfl/linux-pid-attach.c b/libdwfl/linux-pid-attach.c
index 45a0732..fadcedb 100644
--- a/libdwfl/linux-pid-attach.c
+++ b/libdwfl/linux-pid-attach.c
@@ -37,9 +37,20 @@
# define MAX(a, b) ((a) > (b) ? (a) : (b))
#endif
+struct tids_vector
+{
+ int n_used;
+ int n_allocated;
+ int pos; /* Used when reading tids cache */
+ pid_t *tids;
+};
+
struct pid_arg
{
+ /* vec acts as cache for the result of dir reading.
+ dir can be NULL after all dirents are stored to vec. */
DIR *dir;
+ struct tids_vector vec;
/* It is 0 if not used. */
pid_t tid_attached;
/* Valid only if TID_ATTACHED is not zero. */
@@ -159,8 +170,8 @@ pid_memory_read (Dwfl *dwfl, Dwarf_Addr addr, Dwarf_Word *result, void *arg)
}
static pid_t
-pid_next_thread (Dwfl *dwfl __attribute__ ((unused)), void *dwfl_arg,
- void **thread_argp)
+pid_next_thread_in_dir (Dwfl *dwfl __attribute__ ((unused)), void *dwfl_arg,
+ void **thread_argp)
{
struct pid_arg *pid_arg = dwfl_arg;
struct dirent *dirent;
@@ -175,6 +186,10 @@ pid_next_thread (Dwfl *dwfl __attribute__ ((unused)), void *dwfl_arg,
__libdwfl_seterrno (DWFL_E_ERRNO);
return -1;
}
+ /* All dirents are read.
+ These are now in pid_arg->vec. */
+ closedir (pid_arg->dir);
+ pid_arg->dir = NULL;
return 0;
}
}
@@ -194,10 +209,58 @@ pid_next_thread (Dwfl *dwfl __attribute__ ((unused)), void *dwfl_arg,
__libdwfl_seterrno (DWFL_E_PARSE_PROC);
return -1;
}
+ if (pid_arg->vec.n_used == pid_arg->vec.n_allocated)
+ {
+ pid_t *tmp;
+
+ pid_arg->vec.n_allocated *= 2;
+ tmp = realloc(pid_arg->vec.tids, sizeof(pid_t) * pid_arg->vec.n_allocated);
+ if (tmp)
+ pid_arg->vec.tids = tmp;
+ else
+ {
+ __libdwfl_seterrno (DWFL_E_NOMEM);
+ return -1;
+ }
+ }
+ pid_arg->vec.tids[pid_arg->vec.n_used++] = tid;
+
*thread_argp = dwfl_arg;
return tid;
}
+static pid_t
+pid_next_thread_in_vec (Dwfl *dwfl __attribute__ ((unused)), void *dwfl_arg,
+ void **thread_argp)
+{
+ struct pid_arg *pid_arg = dwfl_arg;
+ pid_t r;
+
+ if (pid_arg->vec.pos < pid_arg->vec.n_used)
+ {
+ r = pid_arg->vec.tids[pid_arg->vec.pos++];
+ *thread_argp = dwfl_arg;
+ }
+ else
+ {
+ /* Reached the end of array. Reset the position. */
+ r = 0;
+ pid_arg->vec.pos = 0;
+ }
+
+ return r;
+}
+
+static pid_t
+pid_next_thread (Dwfl *dwfl __attribute__ ((unused)), void *dwfl_arg,
+ void **thread_argp)
+{
+ struct pid_arg *pid_arg = dwfl_arg;
+ if (pid_arg->dir)
+ return pid_next_thread_in_dir(dwfl, dwfl_arg, thread_argp);
+ else
+ return pid_next_thread_in_vec(dwfl, dwfl_arg, thread_argp);
+}
/* Implement the ebl_set_initial_registers_tid setfunc callback. */
static bool
@@ -235,7 +298,9 @@ static void
pid_detach (Dwfl *dwfl __attribute__ ((unused)), void *dwfl_arg)
{
struct pid_arg *pid_arg = dwfl_arg;
- closedir (pid_arg->dir);
+ if (pid_arg->dir)
+ closedir (pid_arg->dir);
+ free(pid_arg->vec.tids);
free (pid_arg);
}
@@ -279,16 +344,25 @@ __libdwfl_attach_state_for_pid (Dwfl *dwfl, pid_t pid)
struct pid_arg *pid_arg = malloc (sizeof *pid_arg);
if (pid_arg == NULL)
{
+ error:
closedir (dir);
__libdwfl_seterrno (DWFL_E_NOMEM);
return false;
}
pid_arg->dir = dir;
+ pid_arg->vec.n_used = 0;
+#define INITIAL_VEC_ALLOCATION 2
+ pid_arg->vec.n_allocated = INITIAL_VEC_ALLOCATION;
+ pid_arg->vec.pos = 0;
+ pid_arg->vec.tids = malloc(sizeof(pid_t) * INITIAL_VEC_ALLOCATION);
+ if (pid_arg->vec.tids == NULL)
+ goto error;
pid_arg->tid_attached = 0;
if (! INTUSE(dwfl_attach_state) (dwfl, NULL, pid, &pid_thread_callbacks,
pid_arg))
{
closedir (dir);
+ free(pid_arg->vec.tids);
free (pid_arg);
return false;
}
--
1.8.3.1
10 years, 3 months
[PATCH] stack: show binary and source file names where a function is defined
by Masatake YAMATO
This patch added the binary file name where the function is
defined when -v option is given, and the source file name
where the function is defined when -v -v options are given.
This is based on private discussion with Jan Kratochvil
<jan.kratochvil(a)redhat.com>.
Signed-off-by: Masatake YAMATO <yamato(a)redhat.com>
---
src/ChangeLog | 9 +++++++++
src/stack.c | 26 ++++++++++++++++++++++----
2 files changed, 31 insertions(+), 4 deletions(-)
diff --git a/src/ChangeLog b/src/ChangeLog
index f899858..3bf2426 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,12 @@
+2013-12-16 Masatake YAMATO <yamato(a)redhat.com>
+
+ * stack.c (verbose): Change the type to int.
+ (parse_opt): Increment verbose for each time when
+ '-v' is found.
+ (main): Added '-v' to the help message.
+ (frame_callback): Print binary and source file name
+ if verbose > 0.
+
2013-11-25 Petr Machata <pmachata(a)redhat.com>
* elflint.c (valid_e_machine): Add EM_AARCH64.
diff --git a/src/stack.c b/src/stack.c
index f428ed0..edb479f 100644
--- a/src/stack.c
+++ b/src/stack.c
@@ -36,7 +36,7 @@ ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;
/* Bug report address. */
ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;
-static bool verbose = false;
+static int verbose = 0;
static int
frame_callback (Dwfl_Frame *state, void *arg)
@@ -78,7 +78,25 @@ frame_callback (Dwfl_Frame *state, void *arg)
printf ("#%-2u 0x%0*" PRIx64, (*framenop)++, width, (uint64_t) pc);
if (verbose)
printf ("%4s", ! isactivation ? "- 1" : "");
- printf (" %s\n", symname);
+ printf (" %s", symname);
+ if (verbose > 0)
+ {
+ const char* fname;
+ Dwfl_Line * lineobj;
+ int line, col;
+ const char* sname;
+
+ fname = dwfl_module_info(mod, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+ printf (" - %s", fname? fname: "?");
+ if (verbose > 1)
+ {
+ lineobj = dwfl_module_getsrc(mod, pc_adjusted);
+ line = col = -1;
+ sname = lineobj? (dwfl_lineinfo(lineobj, NULL, &line, &col, NULL, NULL)?: "?"): "?";
+ printf(" (%s:%d:%d)", sname, line, col);
+ }
+ }
+ printf ("\n");
return DWARF_CB_OK;
}
@@ -118,7 +136,7 @@ parse_opt (int key, char *arg __attribute__ ((unused)),
break;
case 'v':
- verbose = true;
+ verbose++;
break;
default:
@@ -165,7 +183,7 @@ Only real user processes are supported, no kernel or process maps."),
argp_parse (&argp, argc, argv, 0, &remaining, &dwfl);
assert (dwfl != NULL);
if (remaining != argc)
- error (2, 0, "eu-stack [--debuginfo-path=<path>] {-p <process id>|"
+ error (2, 0, "eu-stack [-v [-v]] [--debuginfo-path=<path>] {-p <process id>|"
"--core=<file> [--executable=<file>]|--help}");
/* dwfl_linux_proc_report has been already called from dwfl_standard_argp's
--
1.8.3.1
10 years, 3 months
memory leak(?) in stack command
by Masatake YAMATO
Hi,
I've tried stack command under valgrind.
valgrind reports some memory leaks. Is it expected behavior or known issue?
$ LD_LIBRARY_PATH=/usr/local/lib valgrind --leak-check=full stack -p 2234
==17863== Memcheck, a memory error detector
==17863== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.
==17863== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
==17863== Command: stack -p 2234
==17863==
TID 2234:
#0 0x0000003aa8ee7600 __read
#1 0x00007fcad2c0a287 getbyte
#2 0x00007fcad2c09556 getkeymapcmd
#3 0x00007fcad2c09768 getkeycmd
#4 0x00007fcad2c0b2f7 zlecore
#5 0x00007fcad2c0beed zleread
#6 0x000000000043f44f zleentry
#7 0x00000000004403f6 ingetc
#8 0x0000000000439c76 ihgetc
#9 0x000000000044a13c zshlex
#10 0x0000000000466b47 parse_event
#11 0x000000000043cc29 loop
#12 0x000000000043fe26 zsh_main
#13 0x0000003aa8e21b45 __libc_start_main
#14 0x000000000040ecd1 _start
==17863==
==17863== HEAP SUMMARY:
==17863== in use at exit: 6,144 bytes in 61 blocks
==17863== total heap usage: 452 allocs, 391 frees, 17,063,018 bytes allocated
==17863==
==17863== 816 (224 direct, 592 indirect) bytes in 1 blocks are definitely lost in loss record 14 of 15
==17863== at 0x4A06409: malloc (in /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so)
==17863== by 0x4E3C41D: duplicate_frame_state (cfi.c:50)
==17863== by 0x4E3DBBF: __libdw_frame_at_address (cfi.c:478)
==17863== by 0x4E3E23C: dwarf_cfi_addrframe (dwarf_cfi_addrframe.c:49)
==17863== by 0x4E50EC7: handle_cfi (frame_unwind.c:502)
==17863== by 0x4E51197: __libdwfl_frame_unwind (frame_unwind.c:605)
==17863== by 0x4E4FE17: dwfl_thread_getframes (dwfl_frame.c:325)
==17863== by 0x401305: thread_callback (stack.c:90)
==17863== by 0x4E4FBDA: dwfl_getthreads (dwfl_frame.c:264)
==17863== by 0x400F74: main (stack.c:176)
==17863==
==17863== 5,296 (3,136 direct, 2,160 indirect) bytes in 14 blocks are definitely lost in loss record 15 of 15
==17863== at 0x4A06409: malloc (in /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so)
==17863== by 0x4E3C41D: duplicate_frame_state (cfi.c:50)
==17863== by 0x4E3DBBF: __libdw_frame_at_address (cfi.c:478)
==17863== by 0x4E3E23C: dwarf_cfi_addrframe (dwarf_cfi_addrframe.c:49)
==17863== by 0x4E50EC7: handle_cfi (frame_unwind.c:502)
==17863== by 0x4E51197: __libdwfl_frame_unwind (frame_unwind.c:605)
==17863== by 0x4E51261: dwfl_frame_pc (dwfl_frame_pc.c:53)
==17863== by 0x40116C: frame_callback (stack.c:47)
==17863== by 0x4E4FE40: dwfl_thread_getframes (dwfl_frame.c:317)
==17863== by 0x401305: thread_callback (stack.c:90)
==17863== by 0x4E4FBDA: dwfl_getthreads (dwfl_frame.c:264)
==17863== by 0x400F74: main (stack.c:176)
==17863==
==17863== LEAK SUMMARY:
==17863== definitely lost: 3,360 bytes in 15 blocks
==17863== indirectly lost: 2,752 bytes in 45 blocks
==17863== possibly lost: 0 bytes in 0 blocks
==17863== still reachable: 32 bytes in 1 blocks
==17863== suppressed: 0 bytes in 0 blocks
==17863== Reachable blocks (those to which a pointer was found) are not shown.
==17863== To see them, rerun with: --leak-check=full --show-reachable=yes
==17863==
==17863== For counts of detected and suppressed errors, rerun with: -v
==17863== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 2 from 2)
Masatake YAMATO
10 years, 3 months
[COMMITTED] tests: Disable valgrind for core dumping and for self-introspecting tests.
by Mark Wielaard
The only tests that fork and exec are those that will then try to ptrace
attach the child for unwind testing. That won't work when the child is
also running under valgrind. So remove --trace-children=yes. Also disable
valgrind while dumping a core or for tests that try to inspect their own
state. They will get confused otherwise finding pieces of valgrind in
their maps.
Note we still seem to hit the following valgrind bug because the way we
map and unmap some shared libraries gets valgrind confused:
https://bugs.kde.org/show_bug.cgi?id=327427
Signed-off-by: Mark Wielaard <mjw(a)redhat.com>
---
tests/ChangeLog | 8 ++++++++
tests/Makefile.am | 2 +-
tests/backtrace-subr.sh | 11 +++++++++++
tests/run-backtrace-data.sh | 4 ++++
tests/run-backtrace-dwarf.sh | 6 ++++++
5 files changed, 30 insertions(+), 1 deletions(-)
diff --git a/tests/ChangeLog b/tests/ChangeLog
index 31638d3..44f4ef6 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
@@ -1,3 +1,11 @@
+2013-12-10 Mark Wielaard <mjw(a)redhat.com>
+
+ * Makefile.am (valgrind_cmd): Remove --trace-children=yes.
+ * backtrace-subr.sh (check_native_core): Disable valgrind while
+ dumping core.
+ * run-backtrace-data.sh: Disable valgrind.
+ * run-backtrace-dwarf.sh: Likewise.
+
2013-12-09 Mark Wielaard <mjw(a)redhat.com>
* varlocs.c (print_expr): Update comment to explain empty location
diff --git a/tests/Makefile.am b/tests/Makefile.am
index fbcc752..006b232 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -248,7 +248,7 @@ EXTRA_DIST = run-arextract.sh run-arsymtest.sh \
backtrace.x86_64.core.bz2 backtrace.x86_64.exec.bz2
if USE_VALGRIND
-valgrind_cmd='valgrind -q --trace-children=yes --error-exitcode=1 --run-libc-freeres=no'
+valgrind_cmd='valgrind -q --error-exitcode=1 --run-libc-freeres=no'
endif
diff --git a/tests/backtrace-subr.sh b/tests/backtrace-subr.sh
index 39d40b3..580a1ce 100644
--- a/tests/backtrace-subr.sh
+++ b/tests/backtrace-subr.sh
@@ -104,7 +104,18 @@ check_native()
check_native_core()
{
child=$1
+
+ # Disable valgrind while dumping core.
+ SAVED_VALGRIND_CMD="$VALGRIND_CMD"
+ unset VALGRIND_CMD
+
core="core.`ulimit -c unlimited; set +ex; testrun ${abs_builddir}/$child --gencore; true`"
+
+ if [ "x$SAVED_VALGRIND_CMD" != "x" ]; then
+ VALGRIND_CMD="$SAVED_VALGRIND_CMD"
+ export VALGRIND_CMD
+ fi
+
# Do not abort on non-zero exit code due to some warnings of ./backtrace
# - see function check_err.
tempfiles $core{,.{bt,err}}
diff --git a/tests/run-backtrace-data.sh b/tests/run-backtrace-data.sh
index 30127c3..34a4f01 100755
--- a/tests/run-backtrace-data.sh
+++ b/tests/run-backtrace-data.sh
@@ -17,6 +17,10 @@
. $srcdir/backtrace-subr.sh
+# This test really cannot be run under valgrind, it tries to introspect
+# its own maps and registers and will find valgrinds instead.
+unset VALGRIND_CMD
+
tempfiles data.{bt,err}
(set +ex; testrun ${abs_builddir}/backtrace-data 1>data.bt 2>data.err; true)
cat data.{bt,err}
diff --git a/tests/run-backtrace-dwarf.sh b/tests/run-backtrace-dwarf.sh
index 2f4ba0f..a133b32 100755
--- a/tests/run-backtrace-dwarf.sh
+++ b/tests/run-backtrace-dwarf.sh
@@ -17,6 +17,12 @@
. $srcdir/backtrace-subr.sh
+# This test really cannot be run under valgrind, it tries to introspect
+# itself through ptrace and will find bits and pieces of valgrind.
+# On top of that valgrind also tries to read all the unwind info and
+# will warn and complain about various opcodes it doesn't understand...
+unset VALGRIND_CMD
+
tempfiles dwarf.{bt,err}
(set +ex; testrun ${abs_builddir}/backtrace-dwarf 1>dwarf.bt 2>dwarf.err; true)
cat dwarf.{bt,err}
--
1.7.1
10 years, 3 months