From 1f0cfd980bc0a5e3e360f4ee46808b239bca6b55 Mon Sep 17 00:00:00 2001 From: Stan Cox Date: Tue, 16 Dec 2008 10:34:01 -0500 Subject: [PATCH] Convert .mark to .statement(0x) instead of .statement(foo.c:N) --- ChangeLog | 6 + runtime/ChangeLog | 4 + runtime/sduprobes.h | 119 +++++++++----------- tapsets.cxx | 46 ++++---- testsuite/ChangeLog | 4 + testsuite/systemtap.base/static_uprobes.exp | 74 ++++++++++-- testsuite/systemtap.base/static_uprobes.stp | 14 --- 7 files changed, 154 insertions(+), 113 deletions(-) delete mode 100644 testsuite/systemtap.base/static_uprobes.stp diff --git a/ChangeLog b/ChangeLog index 9a852834a..6eba60bb9 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +2008-12-16 Stan Cox + + * tapsets.cxx (dwarf_builder::build): Consider alignment when + fetching .probes values. Convert .mark to .statement(0x) instead + of .statement(foo.c:N) + 2008-12-11 Dave Brolley PR7087 diff --git a/runtime/ChangeLog b/runtime/ChangeLog index 3f88bae2b..7026b2762 100644 --- a/runtime/ChangeLog +++ b/runtime/ChangeLog @@ -1,3 +1,7 @@ +2008-12-16 Stan Cox + + * sduprobes.h (STAP_PROBE): Add synthetic reference to probe label. + 2008-12-09 Frank Ch. Eigler * time.c (_stp_gettimeofday_ns): Protect some more against freq=0. diff --git a/runtime/sduprobes.h b/runtime/sduprobes.h index b91dea933..efa25be7c 100644 --- a/runtime/sduprobes.h +++ b/runtime/sduprobes.h @@ -9,23 +9,23 @@ #include #if _LP64 -#define STAP_PROBE_STRUCT_ARG \ - __uint64_t probe_arg; +#define STAP_PROBE_STRUCT_ARG(arg) \ + __uint64_t arg; #else -#define STAP_PROBE_STRUCT_ARG \ - long probe_arg __attribute__ ((aligned(8))); +#define STAP_PROBE_STRUCT_ARG(arg) \ + long arg __attribute__ ((aligned(8))); #endif #define STAP_PROBE_STRUCT(probe,type,argc) \ struct _probe_ ## probe \ { \ char probe_name [strlen(#probe)+1]; \ - int probe_type; \ - STAP_PROBE_STRUCT_ARG \ + int probe_type; \ + STAP_PROBE_STRUCT_ARG (probe_arg); \ }; \ static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section (".probes"))) = {#probe,type,argc}; -#ifndef USE_STAP_DEBUGINFO_PROBE +#ifdef USE_STAP_PROBE #define STAP_PROBE(provider,probe) \ STAP_PROBE_STRUCT(probe,0,0) \ _stap_probe_0 (_probe_ ## probe.probe_name); @@ -34,108 +34,99 @@ struct _probe_ ## probe \ _probe_ ## probe: \ asm volatile ("nop"); \ STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \ - asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type))); + if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ + goto _probe_ ## probe; #endif -#ifndef USE_STAP_DEBUGINFO_PROBE +#ifdef USE_STAP_PROBE #define STAP_PROBE1(provider,probe,arg1) \ STAP_PROBE_STRUCT(probe,0,1) \ _stap_probe_1 (_probe_ ## probe.probe_name,(size_t)arg1); #else #define STAP_PROBE1(provider,probe,parm1) \ + volatile typeof(parm1) probe ## _arg1 = parm1; \ _probe_ ## probe: \ - asm volatile ("nop"); \ - volatile typeof(parm1) arg1 = parm1; \ + asm volatile ("nop" :: "r"(probe ## _arg1)); \ STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \ - asm volatile ("# %0" :: "r"(arg1)); \ - asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type))); + if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ + goto _probe_ ## probe; #endif -#ifndef USE_STAP_DEBUGINFO_PROBE +#ifdef USE_STAP_PROBE #define STAP_PROBE2(provider,probe,arg1,arg2) \ STAP_PROBE_STRUCT(probe,0,2) \ _stap_probe_2 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2); #else #define STAP_PROBE2(provider,probe,parm1,parm2) \ + volatile typeof(parm1) probe ## _arg1 = parm1; \ + volatile typeof(parm2) probe ## _arg2 = parm2; \ _probe_ ## probe: \ - asm volatile ("nop"); \ - volatile typeof(parm1) arg1 = parm1; \ - volatile typeof(parm2) arg2 = parm2; \ + asm volatile ("nop" :: "r"(probe ## _arg1), "r"(probe ## _arg2)); \ STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe)\ - asm volatile ("# %0" :: "r"(arg1)); \ - asm volatile ("# %0" :: "r"(arg2)); \ - asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type))); + if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ + goto _probe_ ## probe; #endif -#ifndef USE_STAP_DEBUGINFO_PROBE +#ifdef USE_STAP_PROBE #define STAP_PROBE3(provider,probe,arg1,arg2,arg3) \ STAP_PROBE_STRUCT(probe,0,3) \ _stap_probe_3 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3); #else #define STAP_PROBE3(provider,probe,parm1,parm2,parm3) \ + volatile typeof(parm1) probe ## _arg1 = parm1; \ + volatile typeof(parm2) probe ## _arg2 = parm2; \ + volatile typeof(parm3) probe ## _arg3 = parm3; \ _probe_ ## probe: \ - asm volatile ("nop"); \ - volatile typeof(parm1) arg1 = parm1; \ - volatile typeof(parm2) arg2 = parm2; \ - volatile typeof(parm3) arg3 = parm3; \ + asm volatile ("nop" :: "r"(probe ## _arg1), "r"(probe ## _arg2), "r"(probe ## _arg3)); \ STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \ - asm volatile ("# %0" :: "r"(arg1)); \ - asm volatile ("# %0" :: "r"(arg2)); \ - asm volatile ("# %0" :: "r"(arg3)); \ - asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type))); + if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ + goto _probe_ ## probe; #endif -#ifndef USE_STAP_DEBUGINFO_PROBE +#ifdef USE_STAP_PROBE #define STAP_PROBE4(provider,probe,arg1,arg2,arg3,arg4) \ STAP_PROBE_STRUCT(probe,0,4) \ _stap_probe_4 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4); #else -#define STAP_PROBE4(provider,probe,parm1,parm2,parm3) \ +#define STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \ + volatile typeof(parm1) probe ## _arg1 = parm1; \ + volatile typeof(parm2) probe ## _arg2 = parm2; \ + volatile typeof(parm3) probe ## _arg3 = parm3; \ + volatile typeof(parm4) probe ## _arg4 = parm4; \ _probe_ ## probe: \ - asm volatile ("nop"); \ - volatile typeof(parm1) arg1 = parm1; \ - volatile typeof(parm2) arg2 = parm2; \ - volatile typeof(parm3) arg3 = parm3; \ - volatile typeof(parm4) arg4 = parm4; \ + asm volatile ("nop" "r"(probe ## _arg1), "r"(probe ## _arg2), "r"(probe ## _arg3), "r"(probe ## _arg4)); \ STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \ - asm volatile ("# %0" :: "r"(arg1)); \ - asm volatile ("# %0" :: "r"(arg2)); \ - asm volatile ("# %0" :: "r"(arg3)); \ - asm volatile ("# %0" :: "r"(arg4)); \ - asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type))); + if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ + goto _probe_ ## probe; #endif -#ifndef USE_STAP_DEBUGINFO_PROBE +#ifdef USE_STAP_PROBE #define STAP_PROBE5(provider,probe,arg1,arg2,arg3,arg4,arg5) \ STAP_PROBE_STRUCT(probe,0,5) \ _stap_probe_5 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4,(size_t)arg5); #else #define STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \ + volatile typeof(parm1) probe ## _arg1 = parm1; \ + volatile typeof(parm2) probe ## _arg2 = parm2; \ + volatile typeof(parm3) probe ## _arg3 = parm3; \ + volatile typeof(parm4) probe ## _arg4 = parm4; \ + volatile typeof(parm5) probe ## _arg5 = parm5; \ _probe_ ## probe: \ - asm volatile ("nop"); \ - volatile typeof(parm1) arg1 = parm1; \ - volatile typeof(parm2) arg2 = parm2; \ - volatile typeof(parm3) arg3 = parm3; \ - volatile typeof(parm4) arg4 = parm4; \ - volatile typeof(parm5) arg5 = parm5; \ + asm volatile ("nop" "r"(probe ## _arg1), "r"(probe ## _arg2), "r"(probe ## _arg3), "r"(probe ## _arg4), "r"(probe ## _arg5)); \ STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \ - asm volatile ("# %0" :: "r"(arg1)); \ - asm volatile ("# %0" :: "r"(arg2)); \ - asm volatile ("# %0" :: "r"(arg3)); \ - asm volatile ("# %0" :: "r"(arg4)); \ - asm volatile ("# %0" :: "r"(arg5)); \ - asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type))); + if (__builtin_expect(_probe_ ## probe.probe_type < 0, 0)) \ + goto _probe_ ## probe; #endif -#define DTRACE_PROBE1(provider,probe,parm1,parm2,parm3,parm4,parm5) \ -STAP_PROBE1(provider,probe,parm1,parm2,parm3,parm4,parm5) -#define DTRACE_PROBE2(provider,probe,parm1,parm2,parm3,parm4,parm5) \ -STAP_PROBE2(provider,probe,parm1,parm2,parm3,parm4,parm5) -#define DTRACE_PROBE3(provider,probe,parm1,parm2,parm3,parm4,parm5) \ -STAP_PROBE3(provider,probe,parm1,parm2,parm3,parm4,parm5) -#define DTRACE_PROBE4(provider,probe,parm1,parm2,parm3,parm4,parm5) \ -STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4,parm5) -#define DTRACE_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \ -STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) +#define DTRACE_PROBE(provider,probe) \ +STAP_PROBE(provider,probe) +#define DTRACE_PROBE1(provider,probe,parm1) \ +STAP_PROBE1(provider,probe,parm1) +#define DTRACE_PROBE2(provider,probe,parm1,parm2) \ +STAP_PROBE2(provider,probe,parm1,parm2) +#define DTRACE_PROBE3(provider,probe,parm1,parm2,parm3) \ +STAP_PROBE3(provider,probe,parm1,parm2,parm3) +#define DTRACE_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \ +STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4) diff --git a/tapsets.cxx b/tapsets.cxx index 4d9a021d9..0efaf4553 100644 --- a/tapsets.cxx +++ b/tapsets.cxx @@ -3856,7 +3856,8 @@ query_cu (Dwarf_Die * cudie, void * arg) // Verify that a raw address matches the beginning of a // statement. This is a somewhat lame check that the address // is at the start of an assembly instruction. - if (q->has_statement_num) + // Avoid for now since this thwarts a probe on a statement in a macro + if (0 && q->has_statement_num) { Dwarf_Addr queryaddr = q->statement_num_val; dwarf_line_t address_line(dwarf_getsrc_die(cudie, queryaddr)); @@ -5297,14 +5298,14 @@ dwarf_builder::build(systemtap_session & sess, location->components[0]->arg = new literal_string(sess.cmd); ((literal_map_t&)parameters)[location->components[0]->functor] = location->components[0]->arg; Dwarf_Addr bias; - Elf* elf = (dwarf_getelf (dwfl_module_getdwarf (dw->module, &bias)) - ?: dwfl_module_getelf (dw->module, &bias)); + Elf* elf = dwfl_module_getelf (dw->module, &bias); size_t shstrndx; Elf_Scn *probe_scn = NULL; dwfl_assert ("getshstrndx", elf_getshstrndx (elf, &shstrndx)); __uint64_t probe_arg = 0; int probe_type = no_debuginfo; + char *probe_name; // Find the .probes section where the static probe label and arg are stored while ((probe_scn = elf_nextscn (elf, probe_scn))) { @@ -5314,23 +5315,24 @@ dwarf_builder::build(systemtap_session & sess, if (strcmp (elf_strptr (elf, shstrndx, shdr->sh_name), ".probes") != 0) continue; - Elf_Data *pdata = elf_getdata (probe_scn, NULL); + Elf_Data *pdata = elf_getdata_rawchunk (elf, shdr->sh_offset, shdr->sh_size, ELF_T_BYTE); assert (pdata != NULL); size_t probe_scn_offset = 0; while (probe_scn_offset < pdata->d_size) { - char *probe_name = (char*)pdata->d_buf + probe_scn_offset; - probe_scn_offset += strlen(probe_name); - probe_scn_offset += sizeof(int) - (probe_scn_offset % sizeof(int)); - probe_type = *(((char*)pdata->d_buf + probe_scn_offset)); + probe_name = (char*)pdata->d_buf + probe_scn_offset; + probe_scn_offset += strlen(probe_name) + 1; + if (probe_scn_offset % (sizeof(int))) + probe_scn_offset += sizeof(int) - (probe_scn_offset % sizeof(int)); + probe_type = *((int*)((char*)pdata->d_buf + probe_scn_offset)); probe_scn_offset += sizeof(int); - probe_arg = *((__uint32_t*)((char*)pdata->d_buf + probe_scn_offset)); - probe_arg <<= 32; - probe_arg |= *((__uint32_t*)((char*)pdata->d_buf + probe_scn_offset + 4)); + if (probe_scn_offset % (sizeof(__uint64_t))) + probe_scn_offset += sizeof(__uint64_t) - (probe_scn_offset % sizeof(__uint64_t)); + probe_arg = *((__uint64_t*)((char*)pdata->d_buf + probe_scn_offset)); if (strcmp (location->components[1]->arg->tok->content.c_str(), probe_name) == 0) break; - probe_scn_offset += sizeof(__uint64_t); - probe_scn_offset += sizeof(__uint64_t)*2 - (probe_scn_offset % (sizeof(__uint64_t)*2)); + if (probe_scn_offset % (sizeof(__uint64_t)*2)) + probe_scn_offset = (probe_scn_offset + sizeof(__uint64_t)*2) - (probe_scn_offset % (sizeof(__uint64_t)*2)); } } @@ -5378,7 +5380,6 @@ dwarf_builder::build(systemtap_session & sess, size_t cuhl; Dwarf_Off noff = 0; const char *probe_file = "@sduprobes.c"; - int probe_line; // Find where the probe instrumentation landing points are defined while (dwarf_nextcu (dwarf, off = noff, &noff, &cuhl, NULL, NULL, NULL) == 0) { @@ -5386,6 +5387,8 @@ dwarf_builder::build(systemtap_session & sess, Dwarf_Die *cudie = dwarf_offdie (dwarf, off + cuhl, &cudie_mem); if (cudie == NULL) continue; + if (0) + printf("2 diename=%s module_name=%s probe_type=%d probe_arg=%#Lx\n",dwarf_diename(&cudie_mem),module_name.c_str(), (int)probe_type, (long long)probe_arg); if (probe_type == no_debuginfo) { if (strncmp (dwarf_diename(&cudie_mem), "sduprobes", 9) == 0) @@ -5393,15 +5396,6 @@ dwarf_builder::build(systemtap_session & sess, break; } } - else - { - Dwarf_Line *dwarf_line = dwarf_getsrc_die (cudie, probe_arg); - if (dwarf_line == NULL) - continue; - dwarf_lineno (dwarf_line, &probe_line); - probe_file = (dwarf_diename(&cudie_mem) ?: ""); - break; - } } location->components[1]->functor = TOK_STATEMENT; if (probe_type == no_debuginfo) @@ -5414,11 +5408,9 @@ dwarf_builder::build(systemtap_session & sess, } else { - char *pline; - if (asprintf (&pline, "*@%s:%d", probe_file, probe_line + 1) < 0) - return; - location->components[1]->arg = new literal_string(pline); + location->components[1]->arg = new literal_number((int)probe_arg); } + ((literal_map_t&)parameters)[TOK_STATEMENT] = location->components[1]->arg; dw->module = 0; } diff --git a/testsuite/ChangeLog b/testsuite/ChangeLog index 8e174efc1..dc91a2158 100644 --- a/testsuite/ChangeLog +++ b/testsuite/ChangeLog @@ -1,3 +1,7 @@ +2008-12-16 Stan Cox + + * systemtap.base/static_uprobes.exp: Generate our own probes file. + 2008-12-09 Frank Ch. Eigler PR6961. diff --git a/testsuite/systemtap.base/static_uprobes.exp b/testsuite/systemtap.base/static_uprobes.exp index 78641d3f9..f3f26d8af 100644 --- a/testsuite/systemtap.base/static_uprobes.exp +++ b/testsuite/systemtap.base/static_uprobes.exp @@ -8,6 +8,7 @@ set sup_flags "additional_flags=-iquote$env(SYSTEMTAP_RUNTIME) additional_flags= set fp [open $sup_srcpath "w"] puts $fp " #include +#define USE_STAP_PROBE 1 #include \"sduprobes.h\" foo () @@ -24,12 +25,13 @@ bar (int i) baz (int i, char* s) { + STAP_PROBE1(tstlabel,label0,i); if (i == 0) i = 1000; STAP_PROBE2(tstlabel,label3,i,s); } -buz () +buz (int parm) { } @@ -39,6 +41,7 @@ main () foo(); bar(2); baz(3,\"abc\"); + buz(4); } " close $fp @@ -52,33 +55,85 @@ if { $res != "" } { pass "compiling static_uprobes.c" } +set fp [open "[pwd]/static_uprobes.stp" "w"] +puts $fp " +probe process(\"static_uprobes.x\").mark(\"label0\") +{ + printf(\"In label0 probe %#x\\n\", \$arg1) +} +probe process(\"static_uprobes.x\").mark(\"label1\") +{ + printf(\"In label1 probe\\n\") +} +probe process(\"static_uprobes.x\").mark(\"label2\") +{ + printf(\"In label2 probe %#x\\n\", \$arg1) +} +probe process(\"static_uprobes.x\").mark(\"label3\") +{ + printf(\"In label3 probe %#x %#x\\n\", \$arg1, \$arg2) +} +" +close $fp + set ok 0 -spawn stap -c $sup_exepath $srcdir/$subdir/static_uprobes.stp +verbose -log "spawn stap -c $sup_exepath [pwd]/static_uprobes.stp" +spawn stap -c $sup_exepath [pwd]/static_uprobes.stp expect { -timeout 180 -re {In label1 probe} { incr ok; exp_continue } -re {In label2 probe 0x2} { incr ok; exp_continue } + -re {In label0 probe 0x3} { incr ok; exp_continue } -re {In label3 probe 0x3 0x[0-9a-f][0-9a-f]} { incr ok; exp_continue } timeout { fail "$test (timeout)" } eof { } } +if {$ok == 4} { pass "$test" } { fail "$test ($ok)" } +set ok 0 + # Now do a debuginfo style probe of the above test set fp [open "[pwd]/static_uprobes.sh" "w"] puts $fp " ed $sup_srcpath <