From cfde3cb1fdda81a5156df2f39201518d815c2710 Mon Sep 17 00:00:00 2001
From: "Frank Ch. Eigler" <fche@elastic.org>
Date: Wed, 8 Apr 2009 12:29:29 -0400
Subject: tweak nettop.stp demo to sort by accumulated counts despite merging

---
 testsuite/systemtap.examples/network/nettop.stp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/testsuite/systemtap.examples/network/nettop.stp b/testsuite/systemtap.examples/network/nettop.stp
index b84e4882..e96548f1 100755
--- a/testsuite/systemtap.examples/network/nettop.stp
+++ b/testsuite/systemtap.examples/network/nettop.stp
@@ -19,11 +19,11 @@ function print_activity()
          "PID", "UID", "DEV", "XMIT_PK", "RECV_PK",
          "XMIT_KB", "RECV_KB", "COMMAND")
 
-  foreach ([pid, dev, exec, uid] in ifrecv-) {
-	  ifmerged[pid, dev, exec, uid] = 1;
+  foreach ([pid, dev, exec, uid] in ifrecv) {
+	  ifmerged[pid, dev, exec, uid] += @count(ifrecv[pid,dev,exec,uid]);
   }
-  foreach ([pid, dev, exec, uid] in ifxmit-) {
-	  ifmerged[pid, dev, exec, uid] = 1;
+  foreach ([pid, dev, exec, uid] in ifxmit) {
+	  ifmerged[pid, dev, exec, uid] += @count(ifxmit[pid,dev,exec,uid]);
   }
   foreach ([pid, dev, exec, uid] in ifmerged-) {
     n_xmit = @count(ifxmit[pid, dev, exec, uid])
-- 
cgit 


From 0b113a7a70d617c5e67807c9a897b196db4b3b7a Mon Sep 17 00:00:00 2001
From: Stan Cox <scox@redhat.com>
Date: Wed, 8 Apr 2009 12:36:37 -0400
Subject: Do not do a partial name comparison for .label.

* tapsets.cxx (dwflpp::iterate_over_cu_labels): Compare with strcmp not strncmp.
---
 tapsets.cxx                         |  2 +-
 testsuite/systemtap.base/labels.exp | 15 ++++++++-------
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/tapsets.cxx b/tapsets.cxx
index 04402a27..b12d7711 100644
--- a/tapsets.cxx
+++ b/tapsets.cxx
@@ -1369,7 +1369,7 @@ struct dwflpp
 	    function_name = name;
 	  }
 	else if (tag == DW_TAG_label && name != 0
-		 && ((strncmp(name, sym, strlen(sym)) == 0)
+		 && ((strcmp(name, sym) == 0)
 		     || (name_has_wildcard (sym)
 			 && function_name_matches_pattern (name, sym))))
 	  {
diff --git a/testsuite/systemtap.base/labels.exp b/testsuite/systemtap.base/labels.exp
index 2f79a502..f389f08c 100644
--- a/testsuite/systemtap.base/labels.exp
+++ b/testsuite/systemtap.base/labels.exp
@@ -18,7 +18,7 @@ main ()
   char *c;
 init_an_int:
   a = 2;
-init_another_int:
+init_an_int_again:
   b = 3;
   c = \"abc\";
 ptr_inited:
@@ -32,6 +32,7 @@ set fp [open $label_stppath "w"]
 puts $fp "
 probe process(\"labels.x\").function(\"main*@labels.c\").label(\"init_*\") {printf (\"VARS %s\\n\",\$\$vars)}
 probe process(\"labels.x\").function(\"main*@labels.c\").label(\"ptr_inited\") {printf (\"VARS %s\\n\",\$\$vars)}
+probe process(\"labels.x\").function(\"main*@labels.c\").label(\"init_an_int\") {printf (\"init_an_int\\n\")}
 "
 close $fp
 
@@ -55,12 +56,12 @@ spawn stap -c $label_exepath $label_stppath
 wait
 expect {
     -timeout 180
-    -re {VARS a=0x0 b=0x0.*VARS a=0x2 b=0x0.*VARS a=0x2 b=0x3 c=0x[a-f01-9]} { incr ok; exp_continue }
+    -re {VARS a=0x0 b=0x0.*init_an_int.*VARS a=0x2 b=0x0.*VARS a=0x2 b=0x3 c=0x[a-f01-9]} { incr ok; exp_continue }
     timeout { fail "$test (timeout)" }
     eof { }
 }
 
-if {$ok == 1} { pass "$test exe .label" } { fail "$test exe .label" }
+if {$ok == 1} { pass "$test exe .label" } { fail "$test exe .label $ok" }
 
 # address of label in an executable
 
@@ -68,7 +69,7 @@ set label_shpath "[pwd]/label.sh"
 set fp [open $label_shpath "w"]
 puts $fp "
 readelf --debug-dump $label_exepath | awk \"
-/init_another_int/ {have_label=1} 
+/init_an_int_again/ {have_label=1} 
 /DW_AT_low_pc/ {if (have_label) {print \$3;exit;}}
 \"
 "
@@ -103,7 +104,7 @@ if { $res != "" } {
 
 # label in a shared object
 
-spawn stap -p2 -l "process\(\"$label_sopath\"\).function\(\"\*\"\).label\(\"init_another_int\"\)"
+spawn stap -p2 -l "process\(\"$label_sopath\"\).function\(\"\*\"\).label\(\"init_an_int_again\"\)"
 expect {
     -timeout 180
     -re {process.*function} { incr ok; exp_continue }
@@ -111,7 +112,7 @@ expect {
     eof { }
 }
 
-if {$ok == 1} { pass "$test so .label" } { fail "$test so .label" }
+if {$ok == 1} { pass "$test so .label" } { fail "$test so .label $ok" }
 
 # address of label in a shared object
 
@@ -119,7 +120,7 @@ set label_shpath "[pwd]/label.sh"
 set fp [open $label_shpath "w"]
 puts $fp "
 readelf --debug-dump $label_sopath | awk \"
-/init_another_int/ {have_label=1} 
+/init_an_int_again/ {have_label=1} 
 /DW_AT_low_pc/ {if (have_label) {print \$3;exit;}}
 \"
 "
-- 
cgit 


From 55c0f2bfefb04915622dd3688bba59da1addaec8 Mon Sep 17 00:00:00 2001
From: David Smith <dsmith@redhat.com>
Date: Wed, 8 Apr 2009 12:41:55 -0500
Subject: Only includes task_finder.c when needed. 2009-04-08  David Smith 
 <dsmith@redhat.com>

        * tapsets.cxx (itrace_derived_probe_group::emit_module_decls):
        Added inclusion of task_finder.c back.  Unconditionally including
        it when not needed causes all systemtap scripts to fail on kernels
        with no utrace support.
        (utrace_derived_probe_group::emit_module_decls): Ditto.
        (uprobe_derived_probe_group::emit_module_decls): Ditto.
        * runtime/runtime.h: Removed unconditional inclusion of
        task_finder.c.
---
 runtime/runtime.h |  2 --
 tapsets.cxx       | 22 ++++++++++++++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/runtime/runtime.h b/runtime/runtime.h
index 0a656b78..70fe4dce 100644
--- a/runtime/runtime.h
+++ b/runtime/runtime.h
@@ -89,8 +89,6 @@ static struct
 #include "regs.c"
 #include "regs-ia64.c"
 
-#include "task_finder.c"
-
 #include "sym.c"
 #ifdef STP_PERFMON
 #include "perf.c"
diff --git a/tapsets.cxx b/tapsets.cxx
index 04402a27..a7bda5f5 100644
--- a/tapsets.cxx
+++ b/tapsets.cxx
@@ -6474,6 +6474,14 @@ itrace_derived_probe_group::emit_module_decls (systemtap_session& s)
 
   s.op->newline();
   s.op->newline() << "/* ---- itrace probes ---- */";
+
+  // Note that we can potentially include task_finder.c multiple times
+  // in the generated code.  That is OK, since task_finder.c has guard
+  // macros to prevent defining things multiple times.  If we include
+  // task_finder.c unconditionally, stap can't be used on systems
+  // without utrace.
+  s.op->newline() << "#include \"task_finder.c\"";
+
   s.op->newline() << "struct stap_itrace_probe {";
   s.op->indent(1);
   s.op->newline() << "struct stap_task_finder_target tgt;";
@@ -7058,6 +7066,13 @@ utrace_derived_probe_group::emit_module_decls (systemtap_session& s)
   s.op->newline();
   s.op->newline() << "/* ---- utrace probes ---- */";
 
+  // Note that we can potentially include task_finder.c multiple times
+  // in the generated code.  That is OK, since task_finder.c has guard
+  // macros to prevent defining things multiple times.  If we include
+  // task_finder.c unconditionally, stap can't be used on systems
+  // without utrace.
+  s.op->newline() << "#include \"task_finder.c\"";
+
   s.op->newline() << "enum utrace_derived_probe_flags {";
   s.op->indent(1);
   s.op->newline() << "UDPF_NONE,";
@@ -7566,6 +7581,13 @@ uprobe_derived_probe_group::emit_module_decls (systemtap_session& s)
   s.op->newline() << "#include \"uprobes/uprobes.h\"";
   s.op->newline() << "#endif";
 
+  // Note that we can potentially include task_finder.c multiple times
+  // in the generated code.  That is OK, since task_finder.c has guard
+  // macros to prevent defining things multiple times.  If we include
+  // task_finder.c unconditionally, stap can't be used on systems
+  // without utrace.
+  s.op->newline() << "#include \"task_finder.c\"";
+
   s.op->newline() << "#ifndef MULTIPLE_UPROBES";
   s.op->newline() << "#define MULTIPLE_UPROBES 256"; // maximum possible armed uprobes per process() probe point
 						     // or apprx. max number of processes mapping a shared library
-- 
cgit 


From 117bcbe45ff448c0913007d31cfa2be78caeb4ba Mon Sep 17 00:00:00 2001
From: David Smith <dsmith@redhat.com>
Date: Wed, 8 Apr 2009 13:14:24 -0500
Subject: Added '#ifdef STP_NEED_VMA_TRACKER' around code that needs it.
 2009-04-08  David Smith  <dsmith@redhat.com>

        * runtime/sym.c: Added '#ifdef STP_NEED_VMA_TRACKER' around code
        that needs it.
---
 runtime/sym.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/runtime/sym.c b/runtime/sym.c
index 835e1b46..7b918428 100644
--- a/runtime/sym.c
+++ b/runtime/sym.c
@@ -30,6 +30,7 @@ static void _stp_sym_init(void)
 	}
 }
 
+#ifdef STP_NEED_VMA_TRACKER
 /* Callback that needs to be registered (in tapsets.cxx for
    emit_module_init) for every user task path or pid for which we
    might need symbols or unwind info. */
@@ -76,6 +77,7 @@ static int _stp_tf_munmap_cb(struct stap_task_finder_target *tgt,
 	stap_remove_vma_map_info(tsk->group_leader, addr, addr + length, 0);
 	return 0;
 }
+#endif
 
 /* XXX: this needs to be address-space-specific. */
 static unsigned long _stp_module_relocate(const char *module, const char *section, unsigned long offset)
@@ -128,7 +130,6 @@ static unsigned long _stp_module_relocate(const char *module, const char *sectio
 	return 0;
 }
 
-
 /* Return module owner and, if sec != NULL, fills in closest section
    of the address if found, return NULL otherwise.
    XXX: needs to be address-space-specific. */
-- 
cgit 


From 0af51b594e033a9d7148be6428f7365f2fcd1663 Mon Sep 17 00:00:00 2001
From: David Smith <dsmith@redhat.com>
Date: Wed, 8 Apr 2009 15:31:49 -0500
Subject: Better error handling in 'setup_server'. 2009-04-08  David Smith 
 <dsmith@redhat.com>

        * lib/systemtap.exp (setup_server): Better error handling.
---
 testsuite/lib/systemtap.exp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/testsuite/lib/systemtap.exp b/testsuite/lib/systemtap.exp
index 5311be7b..98108fa5 100644
--- a/testsuite/lib/systemtap.exp
+++ b/testsuite/lib/systemtap.exp
@@ -85,7 +85,7 @@ proc setup_server {} {
 
     # Make sure that the necessary resources are available to run the client/server.
     if {[installtest_p]} then {
-	if {[exec /usr/bin/which stap-client-connect] == ""} then {
+	if {[catch {exec /usr/bin/which stap-client-connect} dummy]} then {
 	    print "Unable to start a server: stap-client-connect is not found in PATH"
 	    return 0
 	}
@@ -93,7 +93,7 @@ proc setup_server {} {
 	print "Unable to start a server: [exec pwd]/../stap-client-connect is not found"
 	return 0
     }
-    if {[exec /usr/bin/which avahi-publish-service] == ""} then {
+    if {[catch {exec /usr/bin/which avahi-publish-service} dummy]} then {
 	print "Unable to start a server: avahi-publish-service is not found in PATH"
 	return 0
     }
-- 
cgit 


From e87251e16921a2d52a35212278e45f0c0af1cc5d Mon Sep 17 00:00:00 2001
From: Stan Cox <scox@redhat.com>
Date: Wed, 8 Apr 2009 17:19:04 -0400
Subject: Consider function when handling .label

* tapsets.cxx(dwflpp::iterate_over_cu_labels): New parameter function.
Do wildcard match for function.
* testsuite/systemtap.base/labels.exp: Test .label function handling.
---
 tapsets.cxx                         | 37 ++++++++++++++++++++++++-------------
 testsuite/systemtap.base/labels.exp | 13 ++++++++++---
 2 files changed, 34 insertions(+), 16 deletions(-)

diff --git a/tapsets.cxx b/tapsets.cxx
index 694490d8..32cd8494 100644
--- a/tapsets.cxx
+++ b/tapsets.cxx
@@ -1339,7 +1339,8 @@ struct dwflpp
   }
 
   void
-  iterate_over_cu_labels (string label_val, Dwarf_Die *cu, void *data,
+  iterate_over_cu_labels (string label_val, string function, Dwarf_Die *cu,
+			  void *data,
 			  void (* callback)(const string &,
 					    const char *,
 					    int,
@@ -1364,14 +1365,30 @@ struct dwflpp
 	Dwarf_Attribute *attr = dwarf_attr (&die, DW_AT_name, &attr_mem);
 	int tag = dwarf_tag(&die);
 	const char *name = dwarf_formstring (attr);
-	if (tag == DW_TAG_subprogram && name != 0)
+	if (name == 0)
+	  continue;
+	switch (tag)
 	  {
+	  case DW_TAG_label:
+	    break;
+	  case DW_TAG_subprogram:
 	    function_name = name;
+	  default:
+	    if (dwarf_haschildren (&die))
+	      iterate_over_cu_labels (label_val, function, &die, q, callback);
+	    continue;
 	  }
-	else if (tag == DW_TAG_label && name != 0
-		 && ((strcmp(name, sym) == 0)
-		     || (name_has_wildcard (sym)
-			 && function_name_matches_pattern (name, sym))))
+	
+	if (strcmp(function_name.c_str(), function.c_str()) == 0
+	    || (name_has_wildcard(function)
+		&& function_name_matches_pattern (function_name, function)))
+	  {
+	  }
+	else
+	  continue;
+	if (strcmp(name, sym) == 0
+	    || (name_has_wildcard(sym) 
+		&& function_name_matches_pattern (name, sym)))
 	  {
 	    const char *file = dwarf_decl_file (&die);
 	    // Get the line number for this label
@@ -1406,16 +1423,10 @@ struct dwflpp
 	      callback(function_name.c_str(), file,
 		       (int)dline, &scopes[1], stmt_addr, q);
 	  }
-	if (dwarf_haschildren (&die) && tag != DW_TAG_structure_type
-	    && tag != DW_TAG_union_type)
-	  {
-	    iterate_over_cu_labels (label_val, &die, q, callback);
-	  }
       }
     while (dwarf_siblingof (&die, &die) == 0);
   }
 
-
   void collect_srcfiles_matching (string const & pattern,
 				  set<char const *> & filtered_srcfiles)
   {
@@ -4110,7 +4121,7 @@ query_cu (Dwarf_Die * cudie, void * arg)
 	    {
 	      // If we have a pattern string with target *label*, we
 	      // have to look at labels in all the matched srcfiles.
-	      q->dw.iterate_over_cu_labels (q->label_val, q->dw.cu, q, query_statement);
+	      q->dw.iterate_over_cu_labels (q->label_val, q->function, q->dw.cu, q, query_statement);
 	    }
 	  else
 	    {
diff --git a/testsuite/systemtap.base/labels.exp b/testsuite/systemtap.base/labels.exp
index f389f08c..268bb320 100644
--- a/testsuite/systemtap.base/labels.exp
+++ b/testsuite/systemtap.base/labels.exp
@@ -10,9 +10,16 @@ set label_flags "additional_flags=-g"
 set fp [open $label_srcpath "w"]
 puts $fp "
 int
+foo ()
+{
+init_an_int:
+  return 1;
+}
+int
 main ()
 {
   sleep(5);
+  foo();
   int a = 0;
   int b = 0;
   char *c;
@@ -30,9 +37,9 @@ close $fp
 set label_stppath "[pwd]/labels.stp"
 set fp [open $label_stppath "w"]
 puts $fp "
-probe process(\"labels.x\").function(\"main*@labels.c\").label(\"init_*\") {printf (\"VARS %s\\n\",\$\$vars)}
-probe process(\"labels.x\").function(\"main*@labels.c\").label(\"ptr_inited\") {printf (\"VARS %s\\n\",\$\$vars)}
-probe process(\"labels.x\").function(\"main*@labels.c\").label(\"init_an_int\") {printf (\"init_an_int\\n\")}
+probe process(\"labels.x\").function(\"main@labels.c\").label(\"init_*\") {printf (\"VARS %s\\n\",\$\$vars)}
+probe process(\"labels.x\").function(\"main@labels.c\").label(\"ptr_inited\") {printf (\"VARS %s\\n\",\$\$vars)}
+probe process(\"labels.x\").function(\"main@labels.c\").label(\"init_an_int\") {printf (\"init_an_int\\n\")}
 "
 close $fp
 
-- 
cgit 


From 30450585dd7d50224abef863ed8bae0950740fdb Mon Sep 17 00:00:00 2001
From: Mark Wielaard <mjw@redhat.com>
Date: Wed, 8 Apr 2009 18:11:34 +0200
Subject: Add main executable symbol uprobe to uprobes_lib.exp test.

There was nothing wrong with the probe itself, but because the body
was empty the compiler optimised away the actual call...

* testsuite/systemtap.base/uprobes_lib.exp: Activate main exe probe, expect
  more output.
* testsuite/systemtap.base/uprobes_lib.stp: Also probe main and main_lib.
* testsuite/systemtap.base/uprobes_exe.c: Put some code in main_func.
* testsuite/systemtap.base/uprobes_lib.c: Likewise for lib_func.
---
 testsuite/systemtap.base/uprobes_exe.c   |  8 +++++---
 testsuite/systemtap.base/uprobes_lib.c   |  3 ++-
 testsuite/systemtap.base/uprobes_lib.exp | 13 ++++++++-----
 testsuite/systemtap.base/uprobes_lib.stp | 10 ++++++++--
 4 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/testsuite/systemtap.base/uprobes_exe.c b/testsuite/systemtap.base/uprobes_exe.c
index 447434c6..b4811335 100644
--- a/testsuite/systemtap.base/uprobes_exe.c
+++ b/testsuite/systemtap.base/uprobes_exe.c
@@ -15,13 +15,15 @@ int lib_main (void);
 void
 main_func (int foo)
 {
-  ; // nothing here...
+  if (foo > 1)
+    main_func (foo - 1);
+  else
+    lib_main();
 }
 
 int
 main (int argc, char *argv[], char *envp[])
 {
-  main_func(1);
-  lib_main();
+  main_func (3);
   return 0;
 }
diff --git a/testsuite/systemtap.base/uprobes_lib.c b/testsuite/systemtap.base/uprobes_lib.c
index c9d70625..25297b6b 100644
--- a/testsuite/systemtap.base/uprobes_lib.c
+++ b/testsuite/systemtap.base/uprobes_lib.c
@@ -10,7 +10,8 @@
 void
 lib_func (int bar)
 {
-  ; // nothing here...
+  if (bar > 1)
+    lib_func (bar - 1);
 }
 
 void
diff --git a/testsuite/systemtap.base/uprobes_lib.exp b/testsuite/systemtap.base/uprobes_lib.exp
index 63ef957a..313c01b6 100644
--- a/testsuite/systemtap.base/uprobes_lib.exp
+++ b/testsuite/systemtap.base/uprobes_lib.exp
@@ -29,11 +29,14 @@ if { $res != "" } {
     pass "$test compile $testsrc"
 }
 
-# XXX main_func needs another/extra test. Disabled for now.
-# Enable (and in uprobes_lib.stp) after PR9940 is fixed.
-# set ::result_string {main_func
-# lib_func}
-set ::result_string {lib_func}
+set ::result_string {main
+main_func
+main_func
+main_func
+lib_main
+lib_func
+lib_func
+lib_func}
 
 # Only run on make installcheck
 if {! [installtest_p]} { untested "$test"; return }
diff --git a/testsuite/systemtap.base/uprobes_lib.stp b/testsuite/systemtap.base/uprobes_lib.stp
index bc6cc249..459351a4 100644
--- a/testsuite/systemtap.base/uprobes_lib.stp
+++ b/testsuite/systemtap.base/uprobes_lib.stp
@@ -1,8 +1,14 @@
-/* - Not activated probe... Seems always skipped?
+probe process("uprobes_exe").function("main") {
+  printf("main\n");
+}
+
 probe process("uprobes_exe").function("main_func") {
   printf("main_func\n");
 }
-*/
+
+probe process("libuprobes_lib.so").function("lib_main") {
+  printf("lib_main\n");
+}
 
 probe process("libuprobes_lib.so").function("lib_func") {
   printf("lib_func\n");
-- 
cgit 


From 9b11ea1ccc742f6a594be6a9777e618bdcbfebed Mon Sep 17 00:00:00 2001
From: Mark Wielaard <mjw@redhat.com>
Date: Wed, 8 Apr 2009 19:27:42 +0200
Subject: Fix DEBUG_TASK_FINDER_VMA compilation.

* runtime/sym.c (_stp_tf_mmap_cb): We get passed vm_flags, not flags.
---
 runtime/sym.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/sym.c b/runtime/sym.c
index 7b918428..8de01bc8 100644
--- a/runtime/sym.c
+++ b/runtime/sym.c
@@ -48,7 +48,7 @@ static int _stp_tf_mmap_cb(struct stap_task_finder_target *tgt,
 #ifdef DEBUG_TASK_FINDER_VMA
 	_stp_dbug(__FUNCTION__, __LINE__,
 		  "mmap_cb: tsk %d:%d path %s, addr 0x%08lx, length 0x%08lx, offset 0x%lx, flags 0x%lx\n",
-		  tsk->pid, tsk->tgid, path, addr, length, offset, flags);
+		  tsk->pid, tsk->tgid, path, addr, length, offset, vm_flags);
 #endif
 	if (path != NULL) {
 		for (i = 0; i < _stp_num_modules; i++) {
-- 
cgit 


From 8c39e6ee099a479b3f8e25bad1272085369970a9 Mon Sep 17 00:00:00 2001
From: Mark Wielaard <mjw@redhat.com>
Date: Wed, 8 Apr 2009 23:35:21 +0200
Subject: Make sure code using the vma tracker compiles again.

* runtime/runtime.h: Include task_finder.c.
* runtime/sym.c: Always define task_finder callbacks for usage in tapsets.
* runtime/task_finder.c: Define dummy stap_task_finder_target when
  ! defined(CONFIG_UTRACE).
* tapsets.cxx: Never include task_finder.c directly.
---
 runtime/runtime.h     |  2 ++
 runtime/sym.c         |  2 --
 runtime/task_finder.c |  7 ++++---
 tapsets.cxx           | 21 ---------------------
 4 files changed, 6 insertions(+), 26 deletions(-)

diff --git a/runtime/runtime.h b/runtime/runtime.h
index 70fe4dce..0a656b78 100644
--- a/runtime/runtime.h
+++ b/runtime/runtime.h
@@ -89,6 +89,8 @@ static struct
 #include "regs.c"
 #include "regs-ia64.c"
 
+#include "task_finder.c"
+
 #include "sym.c"
 #ifdef STP_PERFMON
 #include "perf.c"
diff --git a/runtime/sym.c b/runtime/sym.c
index 8de01bc8..a2cdd0ff 100644
--- a/runtime/sym.c
+++ b/runtime/sym.c
@@ -30,7 +30,6 @@ static void _stp_sym_init(void)
 	}
 }
 
-#ifdef STP_NEED_VMA_TRACKER
 /* Callback that needs to be registered (in tapsets.cxx for
    emit_module_init) for every user task path or pid for which we
    might need symbols or unwind info. */
@@ -77,7 +76,6 @@ static int _stp_tf_munmap_cb(struct stap_task_finder_target *tgt,
 	stap_remove_vma_map_info(tsk->group_leader, addr, addr + length, 0);
 	return 0;
 }
-#endif
 
 /* XXX: this needs to be address-space-specific. */
 static unsigned long _stp_module_relocate(const char *module, const char *section, unsigned long offset)
diff --git a/runtime/task_finder.c b/runtime/task_finder.c
index 69b6246b..55a896ee 100644
--- a/runtime/task_finder.c
+++ b/runtime/task_finder.c
@@ -2,8 +2,9 @@
 #define TASK_FINDER_C
 
 #if ! defined(CONFIG_UTRACE)
-#error "Need CONFIG_UTRACE!"
-#endif
+/* Dummy definitions for use in sym.c */
+struct stap_task_finder_target { };
+#else
 
 #include <linux/utrace.h>
 
@@ -1324,5 +1325,5 @@ stap_stop_task_finder(void)
 	debug_task_finder_report();
 }
 
-
+#endif /* defined(CONFIG_UTRACE) */
 #endif /* TASK_FINDER_C */
diff --git a/tapsets.cxx b/tapsets.cxx
index 32cd8494..2316a777 100644
--- a/tapsets.cxx
+++ b/tapsets.cxx
@@ -6486,13 +6486,6 @@ itrace_derived_probe_group::emit_module_decls (systemtap_session& s)
   s.op->newline();
   s.op->newline() << "/* ---- itrace probes ---- */";
 
-  // Note that we can potentially include task_finder.c multiple times
-  // in the generated code.  That is OK, since task_finder.c has guard
-  // macros to prevent defining things multiple times.  If we include
-  // task_finder.c unconditionally, stap can't be used on systems
-  // without utrace.
-  s.op->newline() << "#include \"task_finder.c\"";
-
   s.op->newline() << "struct stap_itrace_probe {";
   s.op->indent(1);
   s.op->newline() << "struct stap_task_finder_target tgt;";
@@ -7077,13 +7070,6 @@ utrace_derived_probe_group::emit_module_decls (systemtap_session& s)
   s.op->newline();
   s.op->newline() << "/* ---- utrace probes ---- */";
 
-  // Note that we can potentially include task_finder.c multiple times
-  // in the generated code.  That is OK, since task_finder.c has guard
-  // macros to prevent defining things multiple times.  If we include
-  // task_finder.c unconditionally, stap can't be used on systems
-  // without utrace.
-  s.op->newline() << "#include \"task_finder.c\"";
-
   s.op->newline() << "enum utrace_derived_probe_flags {";
   s.op->indent(1);
   s.op->newline() << "UDPF_NONE,";
@@ -7592,13 +7578,6 @@ uprobe_derived_probe_group::emit_module_decls (systemtap_session& s)
   s.op->newline() << "#include \"uprobes/uprobes.h\"";
   s.op->newline() << "#endif";
 
-  // Note that we can potentially include task_finder.c multiple times
-  // in the generated code.  That is OK, since task_finder.c has guard
-  // macros to prevent defining things multiple times.  If we include
-  // task_finder.c unconditionally, stap can't be used on systems
-  // without utrace.
-  s.op->newline() << "#include \"task_finder.c\"";
-
   s.op->newline() << "#ifndef MULTIPLE_UPROBES";
   s.op->newline() << "#define MULTIPLE_UPROBES 256"; // maximum possible armed uprobes per process() probe point
 						     // or apprx. max number of processes mapping a shared library
-- 
cgit 


From 86872ea4cdc4ce7b4546975125fc7be7c7a6e0ec Mon Sep 17 00:00:00 2001
From: Mark Wielaard <mjw@redhat.com>
Date: Thu, 9 Apr 2009 14:22:03 +0200
Subject: Make new stap_task_finder_targets chain on correct list.

* runtime/task_finder.c (stap_register_task_finder_target): Also check both
  pathlen are zero.
---
 runtime/task_finder.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/task_finder.c b/runtime/task_finder.c
index 55a896ee..433a042a 100644
--- a/runtime/task_finder.c
+++ b/runtime/task_finder.c
@@ -179,7 +179,7 @@ stap_register_task_finder_target(struct stap_task_finder_target *new_tgt)
 			 && strcmp(tgt->pathname, new_tgt->pathname) == 0)
 			/* pid-based target (a specific pid or all
 			 * pids) */
-			|| (new_tgt->pathlen == 0
+			|| (new_tgt->pathlen == 0 && tgt->pathlen == 0
 			    && tgt->pid == new_tgt->pid))) {
 			found_node = 1;
 			break;
-- 
cgit 


From 18ac9f367a2e63335dfbdc8f5e8a97de4e40dbe4 Mon Sep 17 00:00:00 2001
From: Mark Wielaard <mjw@redhat.com>
Date: Thu, 9 Apr 2009 14:26:07 +0200
Subject: Add tests for probefunc(), usymname(), uaddr() versus shared
 libraries.

* testsuite/systemtap.base/uprobes_uname.exp: New file.
* testsuite/systemtap.base/uprobes_uname.stp: Likewise.
---
 testsuite/systemtap.base/uprobes_uname.exp | 46 ++++++++++++++++++++++++++++++
 testsuite/systemtap.base/uprobes_uname.stp |  7 +++++
 2 files changed, 53 insertions(+)
 create mode 100644 testsuite/systemtap.base/uprobes_uname.exp
 create mode 100644 testsuite/systemtap.base/uprobes_uname.stp

diff --git a/testsuite/systemtap.base/uprobes_uname.exp b/testsuite/systemtap.base/uprobes_uname.exp
new file mode 100644
index 00000000..65e1ff70
--- /dev/null
+++ b/testsuite/systemtap.base/uprobes_uname.exp
@@ -0,0 +1,46 @@
+set test "uprobes_uname"
+set testpath "$srcdir/$subdir"
+set testsrc  "$testpath/uprobes_exe.c"
+set testsrclib  "$testpath/uprobes_lib.c"
+set testexe  "./uprobes_exe"
+set testlibname  "uprobes_lib"
+set testlibdir "."
+set testso  "$testlibdir/lib${testlibname}.so"
+set testflags "additional_flags=-g additional_flags=-O"
+set testlibflags "$testflags additional_flags=-fPIC additional_flags=-shared"
+set maintestflags "$testflags additional_flags=-L$testlibdir additional_flags=-l$testlibname additional_flags=-Wl,-rpath,$testlibdir"
+
+# Compile our test program and library.
+set res [target_compile $testsrclib $testso executable $testlibflags]
+if { $res != "" } {
+    verbose "target_compile for $testso failed: $res" 2
+    fail "$test compile $testsrclib"
+    return
+} else {
+    pass "$test compile $testsrclib"
+}
+
+set res [target_compile $testsrc $testexe executable $maintestflags]
+if { $res != "" } {
+    verbose "target_compile failed: $res" 2
+    fail "$test compile $testsrc"
+    return
+} else {
+    pass "$test compile $testsrc"
+}
+
+set ::result_string {exe: main=main
+exe: main_func=main_func
+exe: main_func=main_func
+exe: main_func=main_func
+lib: lib_main=lib_main
+lib: lib_func=lib_func
+lib: lib_func=lib_func
+lib: lib_func=lib_func}
+
+# Only run on make installcheck
+if {! [installtest_p]} { untested "$test"; return }
+if {! [utrace_p]} { untested $test; return }
+stap_run2 $srcdir/$subdir/$test.stp -c $testexe
+
+#exec rm -f $testexe $testso
diff --git a/testsuite/systemtap.base/uprobes_uname.stp b/testsuite/systemtap.base/uprobes_uname.stp
new file mode 100644
index 00000000..a44d78d3
--- /dev/null
+++ b/testsuite/systemtap.base/uprobes_uname.stp
@@ -0,0 +1,7 @@
+probe process("uprobes_exe").function("*") {
+  printf("exe: %s=%s\n",probefunc(), usymname(uaddr()));
+}
+
+probe process("libuprobes_lib.so").function("*") {
+  printf("lib: %s=%s\n",probefunc(), usymname(uaddr()));
+}
-- 
cgit 


From 52356a26e1825acbd9146337ffdbed9b0e173f2b Mon Sep 17 00:00:00 2001
From: Mark Wielaard <mjw@redhat.com>
Date: Thu, 9 Apr 2009 18:20:32 +0200
Subject: Make simple probes work even without KPROBES in the kernel.

Without KPROBES very little works atm. But stack.c file is unconditionally
imported, while these two functions are only used through context-unwind.stp.
This at least lets us do simple sanity checks on "plain" kernels.

* runtime/stack.c (_stp_stack_print, _stp_stack_snprint):
  Wrap in #if defined (CONFIG_KPROBES).
---
 runtime/stack.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/runtime/stack.c b/runtime/stack.c
index f6b1cd08..68fb9b1f 100644
--- a/runtime/stack.c
+++ b/runtime/stack.c
@@ -97,6 +97,12 @@ static void _stp_stack_print_fallback(unsigned long stack, int verbose, int leve
                    &print_data);
 }
 #endif
+
+// Without KPROBES very little works atm.
+// But this file is unconditionally imported, while these two functions are only
+// used through context-unwind.stp.
+#if defined (CONFIG_KPROBES)
+
 /** Prints the stack backtrace
  * @param regs A pointer to the struct pt_regs.
  */
@@ -141,6 +147,8 @@ static void _stp_stack_snprint(char *str, int size, struct pt_regs *regs, int ve
 	pb->len = 0;
 }
 
+#endif /* CONFIG_KPROBES */
+
 /** Prints the user stack backtrace
  * @param str string
  * @returns Same string as was input with trace info appended,
-- 
cgit 


From d5cd287f7860df8752f93de93fcd1cc68884d56b Mon Sep 17 00:00:00 2001
From: David Smith <dsmith@redhat.com>
Date: Thu, 9 Apr 2009 12:06:05 -0500
Subject: Uses <asm/syscall.h> when available. 2009-04-09  David Smith 
 <dsmith@redhat.com>

        * buildrun.cxx (compile_pass): Compile autoconf test for
        <asm/syscall.h>.
        * runtime/autoconf-asm-syscall.c: New "autoconf" test the presence
        of <asm/syscall.h>.
        * runtime/syscall.h: If <asm/syscall.h> exists, use it.
        Otherwise, use our private copy of the functions for each
        architecture.
        (syscall_get_nr): Renamed from __stp_user_syscall_nr().
        (syscall_get_return_value): Renamed from
        __stp_user_syscall_return_value().
        (syscall_get_arguments): Renamed from __stp_user_syscall_arg().
        * runtime/task_finder.c
        (__stp_utrace_task_finder_target_syscall_exit): Uses new syscall.h
        functions.
        * tapset/utrace.stp: Ditto.
---
 buildrun.cxx                   |   2 +
 runtime/autoconf-asm-syscall.c |   2 +
 runtime/syscall.h              | 298 ++++++++++++++++++++++++++---------------
 runtime/task_finder.c          |  56 ++------
 tapset/utrace.stp              |   8 +-
 5 files changed, 214 insertions(+), 152 deletions(-)
 create mode 100644 runtime/autoconf-asm-syscall.c

diff --git a/buildrun.cxx b/buildrun.cxx
index bcd4c1fe..82ac9d4e 100644
--- a/buildrun.cxx
+++ b/buildrun.cxx
@@ -165,6 +165,8 @@ compile_pass (systemtap_session& s)
 #endif
   output_autoconf(s, o, "autoconf-save-stack-trace.c",
                   "STAPCONF_KERNEL_STACKTRACE", NULL);
+  output_autoconf(s, o, "autoconf-asm-syscall.c",
+		  "STAPCONF_ASM_SYSCALL_H", NULL);
 
   o << module_cflags << " += -include $(STAPCONF_HEADER)" << endl;
 
diff --git a/runtime/autoconf-asm-syscall.c b/runtime/autoconf-asm-syscall.c
new file mode 100644
index 00000000..bf7a273f
--- /dev/null
+++ b/runtime/autoconf-asm-syscall.c
@@ -0,0 +1,2 @@
+#include <asm/syscall.h>
+
diff --git a/runtime/syscall.h b/runtime/syscall.h
index ae451070..6d22ba83 100644
--- a/runtime/syscall.h
+++ b/runtime/syscall.h
@@ -1,5 +1,6 @@
-/* syscall defines and inlines
- * Copyright (C) 2008 Red Hat Inc.
+/*
+ * syscall defines and inlines
+ * Copyright (C) 2008-2009 Red Hat Inc.
  *
  * This file is part of systemtap, and is free software.  You can
  * redistribute it and/or modify it under the terms of the GNU General
@@ -89,9 +90,17 @@
 #error "Unimplemented architecture"
 #endif
 
+#ifdef STAPCONF_ASM_SYSCALL_H
+
+/* If the system has asm/syscall.h, use defines from it. */
+#include <asm/syscall.h>
+
+#else  /* !STAPCONF_ASM_SYSCALL_H */
+
+/* If the system doesn't have asm/syscall.h, use our defines. */
 #if defined(__i386__) || defined(__x86_64__)
-static inline unsigned long
-__stp_user_syscall_nr(struct pt_regs *regs)
+static inline long
+syscall_get_nr(struct task_struct *task, struct pt_regs *regs)
 {
 #if defined(STAPCONF_X86_UNIREGS)
 	return regs->orig_ax;
@@ -104,37 +113,37 @@ __stp_user_syscall_nr(struct pt_regs *regs)
 #endif
 
 #if defined(__powerpc__)
-static inline unsigned long
-__stp_user_syscall_nr(struct pt_regs *regs)
+static inline long
+syscall_get_nr(struct task_struct *task, struct pt_regs *regs)
 {
 	return regs->gpr[0];
 }
 #endif
 
 #if defined(__ia64__)
-static inline unsigned long
-__stp_user_syscall_nr(struct pt_regs *regs)
+static inline long
+syscall_get_nr(struct task_struct *task, struct pt_regs *regs)
 {
         return regs->r15;
 }
 #endif
 
 #if defined(__s390__) || defined(__s390x__)
-static inline unsigned long
-__stp_user_syscall_nr(struct pt_regs *regs)
+static inline long
+syscall_get_nr(struct task_struct *task, struct pt_regs *regs)
 {
-	    // might need to be 'orig_gpr2'
+	// might need to be 'orig_gpr2'
 	return regs->gprs[2];
 }
 #endif
 
 #if defined(__i386__) || defined(__x86_64__)
-static inline long *
-__stp_user_syscall_return_value(struct task_struct *task, struct pt_regs *regs)
+static inline long
+syscall_get_return_value(struct task_struct *task, struct pt_regs *regs)
 {
 #ifdef CONFIG_IA32_EMULATION
 // This code works, but isn't what we need.  Since
-// __stp_user_syscall_arg() doesn't sign-extend, a value passed in as
+// syscall_get_syscall_arg() doesn't sign-extend, a value passed in as
 // an argument and then returned won't compare correctly anymore.  So,
 // for now, disable this code.
 # if 0
@@ -145,158 +154,233 @@ __stp_user_syscall_return_value(struct task_struct *task, struct pt_regs *regs)
 # endif
 #endif
 #if defined(STAPCONF_X86_UNIREGS)
-	return &regs->ax;
+	return regs->ax;
 #elif defined(__x86_64__)
-	return &regs->rax;
+	return regs->rax;
 #elif defined (__i386__)
-	return &regs->eax;
+	return regs->eax;
 #endif
 }
 #endif
 
 #if defined(__powerpc__)
-static inline long *
-__stp_user_syscall_return_value(struct task_struct *task, struct pt_regs *regs)
+static inline long
+syscall_get_return_value(struct task_struct *task, struct pt_regs *regs)
 {
-	return &regs->gpr[3];
+	return regs->gpr[3];
 } 
 #endif
 
 #if defined(__ia64__)
-static inline long *
-__stp_user_syscall_return_value(struct task_struct *task, struct pt_regs *regs)
+static inline long
+syscall_get_return_value(struct task_struct *task, struct pt_regs *regs)
 {
-	return &regs->r8;
+	return regs->r8;
 }
 #endif
 
 #if defined(__s390__) || defined(__s390x__)
-static inline long *
-__stp_user_syscall_return_value(struct task_struct *task, struct pt_regs *regs)
+static inline long
+syscall_get_return_value(struct task_struct *task, struct pt_regs *regs)
 {
-	return &regs->gprs[2];
+	return regs->gprs[2];
 }
 #endif
 
 #if defined(__i386__) || defined(__x86_64__)
-static inline long *
-__stp_user_syscall_arg(struct task_struct *task, struct pt_regs *regs,
-		       unsigned int n)
+static inline void
+syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
+		      unsigned int i, unsigned int n, unsigned long *args)
 {
-#if defined(__i386__)
-	if (n > 5) {
-		_stp_error("syscall arg > 5");
-		return NULL;
+	if (i + n > 6) {
+		_stp_error("invalid syscall arg request");
+		return;
 	}
+#if defined(__i386__)
 #if defined(STAPCONF_X86_UNIREGS)
-	return &regs->bx + n;
+	memcpy(args, &regs->bx + i, n * sizeof(args[0]));
 #else
-	return &regs->ebx + n;
+	memcpy(args, &regs->ebx + i, n * sizeof(args[0]));
 #endif
 #elif defined(__x86_64__)
 #ifdef CONFIG_IA32_EMULATION
-	if (test_tsk_thread_flag(task, TIF_IA32))
-		switch (n) {
+	if (test_tsk_thread_flag(task, TIF_IA32)) {
+		switch (i) {
 #if defined(STAPCONF_X86_UNIREGS)
-		case 0: return &regs->bx;
-		case 1: return &regs->cx;
-		case 2: return &regs->dx;
-		case 3: return &regs->si;
-		case 4: return &regs->di;
-		case 5: return &regs->bp;
+		case 0:
+			if (!n--) break;
+			*args++ = regs->bx;
+		case 1:
+			if (!n--) break;
+			*args++ = regs->cx;
+		case 2:
+			if (!n--) break;
+			*args++ = regs->dx;
+		case 3:
+			if (!n--) break;
+			*args++ = regs->si;
+		case 4:
+			if (!n--) break;
+			*args++ = regs->di;
+		case 5:
+			if (!n--) break;
+			*args++ = regs->bp;
 #else
-		case 0: return &regs->rbx;
-		case 1: return &regs->rcx;
-		case 2: return &regs->rdx;
-		case 3: return &regs->rsi;
-		case 4: return &regs->rdi;
-		case 5: return &regs->rbp;
+		case 0:
+			if (!n--) break;
+			*args++ = regs->rbx;
+		case 1:
+			if (!n--) break;
+			*args++ = regs->rcx;
+		case 2:
+			if (!n--) break;
+			*args++ = regs->rdx;
+		case 3:
+			if (!n--) break;
+			*args++ = regs->rsi;
+		case 4:
+			if (!n--) break;
+			*args++ = regs->rdi;
+		case 5:
+			if (!n--) break;
+			*args++ = regs->rbp;
 #endif
-		default: 
-			_stp_error("syscall arg > 5");
-			return NULL;
 		}
+		return;
+	}
 #endif /* CONFIG_IA32_EMULATION */
-	switch (n) {
+	switch (i) {
 #if defined(STAPCONF_X86_UNIREGS)
-	case 0: return &regs->di;
-	case 1: return &regs->si;
-	case 2: return &regs->dx;
-	case 3: return &regs->r10;
-	case 4: return &regs->r8;
-	case 5: return &regs->r9;
+	case 0:
+		if (!n--) break;
+		*args++ = regs->di;
+	case 1:
+		if (!n--) break;
+		*args++ = regs->si;
+	case 2:
+		if (!n--) break;
+		*args++ = regs->dx;
+	case 3:
+		if (!n--) break;
+		*args++ = regs->r10;
+	case 4:
+		if (!n--) break;
+		*args++ = regs->r8;
+	case 5:
+		if (!n--) break;
+		*args++ = regs->r9;
 #else
-	case 0: return &regs->rdi;
-	case 1: return &regs->rsi;
-	case 2: return &regs->rdx;
-	case 3: return &regs->r10;
-	case 4: return &regs->r8;
-	case 5: return &regs->r9;
+	case 0:
+		if (!n--) break;
+		*args++ = regs->rdi;
+	case 1:
+		if (!n--) break;
+		*args++ = regs->rsi;
+	case 2:
+		if (!n--) break;
+		*args++ = regs->rdx;
+	case 3:
+		if (!n--) break;
+		*args++ = regs->r10;
+	case 4:
+		if (!n--) break;
+		*args++ = regs->r8;
+	case 5:
+		if (!n--) break;
+		*args++ = regs->r9;
 #endif
-	default: 
-		_stp_error("syscall arg > 5");
-		return NULL;
 	}
 #endif /* CONFIG_X86_32 */
+	return;
 }
 #endif
 
 #if defined(__powerpc__)
-static inline long *
-__stp_user_syscall_arg(struct task_struct *task, struct pt_regs *regs,
-		       unsigned int n)
+static inline void
+syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
+		      unsigned int i, unsigned int n, unsigned long *args)
 {
-	switch (n) {
-	case 0: return &regs->gpr[3];
-	case 1: return &regs->gpr[4];
-	case 2: return &regs->gpr[5];
-	case 3: return &regs->gpr[6];
-	case 4: return &regs->gpr[7];
-	case 5: return &regs->gpr[8];
-	default:
-		_stp_error("syscall arg > 5");
-		return NULL;
+	if (i + n > 6) {
+		_stp_error("invalid syscall arg request");
+		return;
 	}
+	memcpy(args, &regs->gpr[3 + i], n * sizeof(args[0]));
 }
 #endif
 
 #if defined(__ia64__)
-#define __stp_user_syscall_arg(task, regs, n) \
-	____stp_user_syscall_arg(task, regs, n, &c->unwaddr)
+#define syscall_get_arguments(task, regs, i, n, args)		\
+	__ia64_syscall_get_arguments(task, regs, i, n, args, &c->unwaddr)
 
-static inline long *
-____stp_user_syscall_arg(struct task_struct *task, struct pt_regs *regs,
-			 unsigned int n, unsigned long **cache)
+static inline void
+__ia64_syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
+			     unsigned int i, unsigned int n,
+			     unsigned long *args, unsigned long **cache)
 {
-	if (n > 5) {
-		_stp_error("syscall arg > 5");
-		return NULL;
+	if (i + n > 6) {
+		_stp_error("invalid syscall arg request");
+		return;
+	}
+	switch (i) {
+	case 0:
+		if (!n--) break;
+		*args++ = *__ia64_fetch_register(i + 32, regs, cache);
+	case 1:
+		if (!n--) break;
+		*args++ = *__ia64_fetch_register(i + 33, regs, cache);
+	case 2:
+		if (!n--) break;
+		*args++ = *__ia64_fetch_register(i + 34, regs, cache);
+	case 3:
+		if (!n--) break;
+		*args++ = *__ia64_fetch_register(i + 35, regs, cache);
+	case 4:
+		if (!n--) break;
+		*args++ = *__ia64_fetch_register(i + 36, regs, cache);
+	case 5:
+		if (!n--) break;
+		*args++ = *__ia64_fetch_register(i + 37, regs, cache);
 	}
-	return __ia64_fetch_register(n + 32, regs, cache);
 }
 #endif
 
 #if defined(__s390__) || defined(__s390x__)
-static inline long *
-__stp_user_syscall_arg(struct task_struct *task, struct pt_regs *regs,
-		       unsigned int n)
+static inline void
+syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
+		      unsigned int i, unsigned int n, unsigned long *args)
 {
-	/* If we were returning a value, we could check for TIF_31BIT
-	 * here and cast the value with '(u32)' to make sure it got
-	 * down to 32bits.  But, since we're returning an address,
-	 * there isn't much we can do. */
-	switch (n) {
-	case 0: return &regs->orig_gpr2;
-	case 1: return &regs->gprs[3];
-	case 2: return &regs->gprs[4];
-	case 3: return &regs->gprs[5];
-	case 4: return &regs->gprs[6];
-	case 5: return &regs->args[0];
-	default:
-		_stp_error("syscall arg > 5");
-		return NULL;
+	unsigned long mask = -1UL;
+
+	if (i + n > 6) {
+		_stp_error("invalid syscall arg request");
+		return;
+	}
+#ifdef CONFIG_COMPAT
+	if (test_tsk_thread_flag(task, TIF_31BIT))
+		mask = 0xffffffff;
+#endif
+	switch (i) {
+	case 0:
+		if (!n--) break;
+		*args++ = regs->orig_gpr2 & mask;
+	case 1:
+		if (!n--) break;
+		*args++ = regs->gprs[3] & mask;
+	case 2:
+		if (!n--) break;
+		*args++ = regs->gprs[4] & mask;
+	case 3:
+		if (!n--) break;
+		*args++ = regs->gprs[5] & mask;
+	case 4:
+		if (!n--) break;
+		*args++ = regs->gprs[6] & mask;
+	case 5:
+		if (!n--) break;
+		*args++ = regs->args[0] & mask;
 	}
 }
 #endif
 
+#endif /* !STAPCONF_ASM_SYSCALL_H */
 #endif /* _SYSCALL_H_ */
diff --git a/runtime/task_finder.c b/runtime/task_finder.c
index 433a042a..fa6c296e 100644
--- a/runtime/task_finder.c
+++ b/runtime/task_finder.c
@@ -1065,11 +1065,9 @@ __stp_utrace_task_finder_target_syscall_exit(enum utrace_resume_action action,
 #endif
 {
 	struct stap_task_finder_target *tgt = engine->data;
-	unsigned long syscall_no;
-	unsigned long *rv_addr, rv;
-	unsigned long *arg_addr, arg0;
-	unsigned long arg1 = 0;
-	unsigned long arg2 = 0;
+	long syscall_no;
+	unsigned long rv;
+	unsigned long args[3];
 	int rc;
 	struct mm_struct *mm;
 	struct vm_area_struct *vma;
@@ -1088,7 +1086,7 @@ __stp_utrace_task_finder_target_syscall_exit(enum utrace_resume_action action,
 	// See if syscall is one we're interested in.
 	//
 	// FIXME: do we need to handle mremap()?
-	syscall_no = __stp_user_syscall_nr(regs);
+	syscall_no = syscall_get_nr(tsk, regs);
 	if (syscall_no != MMAP_SYSCALL_NO(tsk)
 	    && syscall_no != MMAP2_SYSCALL_NO(tsk)
 	    && syscall_no != MPROTECT_SYSCALL_NO(tsk)
@@ -1106,21 +1104,11 @@ __stp_utrace_task_finder_target_syscall_exit(enum utrace_resume_action action,
 		return UTRACE_RESUME;
 
 	// Get return value
-	rv_addr = __stp_user_syscall_return_value(tsk, regs);
-	if ((rc = __stp_get_user(rv, rv_addr)) != 0) {
-		_stp_error("couldn't read syscall return value for pid %d: %d",
-			   tsk->pid, rc);
-		return UTRACE_RESUME;
-	}
+	rv = syscall_get_return_value(tsk, regs);
 
 	// We need the first syscall argument to see what address we
 	// were operating on.
-	arg_addr = __stp_user_syscall_arg(tsk, regs, 0);
-	if ((rc = __stp_get_user(arg0, arg_addr)) != 0) {
-		_stp_error("couldn't read syscall arg 0 for pid %d: %d",
-			   tsk->pid, rc);
-		return UTRACE_RESUME;
-	}
+	syscall_get_arguments(tsk, regs, 0, 1, args);
 
 #ifdef DEBUG_TASK_FINDER_VMA
 	_stp_dbug(__FUNCTION__, __LINE__,
@@ -1131,20 +1119,15 @@ __stp_utrace_task_finder_target_syscall_exit(enum utrace_resume_action action,
 		      : ((syscall_no == MPROTECT_SYSCALL_NO(tsk)) ? "mprotect"
 			 : ((syscall_no == MUNMAP_SYSCALL_NO(tsk)) ? "munmap"
 			    : "UNKNOWN")))),
-		  arg0, rv);
+		  args[0], rv);
 #endif
 	__stp_tf_handler_start();
 
 	if (syscall_no == MUNMAP_SYSCALL_NO(tsk)) {
 		// We need the 2nd syscall argument for the length.
-		arg_addr = __stp_user_syscall_arg(tsk, regs, 1);
-		if ((rc = __stp_get_user(arg1, arg_addr)) != 0) {
-			_stp_error("couldn't read syscall arg 1 for pid %d: %d",
-				   tsk->pid, rc);
-			goto syscall_exit_done;
-		}
+		syscall_get_arguments(tsk, regs, 1, 1, &args[1]);
 		// Call the callbacks
-		__stp_call_munmap_callbacks(tgt, tsk, arg0, arg1);
+		__stp_call_munmap_callbacks(tgt, tsk, args[0], args[1]);
 	}
 	else if (syscall_no == MMAP_SYSCALL_NO(tsk)
 		 || syscall_no == MMAP2_SYSCALL_NO(tsk)) {
@@ -1165,24 +1148,13 @@ __stp_utrace_task_finder_target_syscall_exit(enum utrace_resume_action action,
 		}
 	}
 	else {
-		// We need the 2nd syscall argument for the length.
-		arg_addr = __stp_user_syscall_arg(tsk, regs, 1);
-		if ((rc = __stp_get_user(arg1, arg_addr)) != 0) {
-			_stp_error("couldn't read syscall arg 1 for pid %d: %d",
-				   tsk->pid, rc);
-			goto syscall_exit_done;
-		}
-
-		// We need the 3nd syscall argument for the protection.
-		arg_addr = __stp_user_syscall_arg(tsk, regs, 2);
-		if ((rc = __stp_get_user(arg2, arg_addr)) != 0) {
-			_stp_error("couldn't read syscall arg 2 for pid %d: %d",
-				   tsk->pid, rc);
-			goto syscall_exit_done;
-		}
+		// We need the 2nd syscall argument for the length and
+		// the 3rd argument for the protection.
+		syscall_get_arguments(tsk, regs, 1, 2, &args[1]);
 
 		// Call the callbacks
-		__stp_call_mprotect_callbacks(tgt, tsk, arg0, arg1, arg2);
+		__stp_call_mprotect_callbacks(tgt, tsk, args[0], args[1],
+					      args[2]);
 	}
 
 syscall_exit_done:
diff --git a/tapset/utrace.stp b/tapset/utrace.stp
index 34cb32c5..00f427e6 100644
--- a/tapset/utrace.stp
+++ b/tapset/utrace.stp
@@ -6,13 +6,15 @@
 %}
 
 function _utrace_syscall_nr:long () %{
-   THIS->__retvalue = __stp_user_syscall_nr(CONTEXT->regs); /* pure */
+   THIS->__retvalue = syscall_get_nr(current, CONTEXT->regs); /* pure */
 %}
 
 function _utrace_syscall_arg:long (n:long) %{
-   THIS->__retvalue = *__stp_user_syscall_arg(current, CONTEXT->regs, (int)THIS->n); /* pure */
+   unsigned long arg = 0; /* pure */
+   syscall_get_arguments(current, CONTEXT->regs, (int)THIS->n, 1, &arg);
+   THIS->__retvalue = arg;
 %}
 
 function _utrace_syscall_return:long () %{
-   THIS->__retvalue = *__stp_user_syscall_return_value(current, CONTEXT->regs); /* pure */
+   THIS->__retvalue = syscall_get_return_value(current, CONTEXT->regs); /* pure */
 %}
-- 
cgit 


From d6377d4452bb469ea97dc6747cd02cfb1df4af27 Mon Sep 17 00:00:00 2001
From: Mark Wielaard <mjw@redhat.com>
Date: Thu, 9 Apr 2009 23:18:46 +0200
Subject: Cleanup symbol table sanity checking.

* translate.cxx (dump_unwindsyms): Get and check against module end, only
  check STT_FUNC && SHN_ABS for kernel, check shndxp for non-allocated
  section.
---
 translate.cxx | 45 +++++++++++++++++++++++++++++----------------
 1 file changed, 29 insertions(+), 16 deletions(-)

diff --git a/translate.cxx b/translate.cxx
index 3442703d..a22e9a5b 100644
--- a/translate.cxx
+++ b/translate.cxx
@@ -4486,7 +4486,7 @@ dump_unwindsyms (Dwfl_Module *m,
   // In the future, we'll also care about data symbols.
 
   int syments = dwfl_module_getsymtab(m);
-  assert(syments);
+  dwfl_assert ("Getting symbol table for " + modname, syments >= 0);
 
   //extract build-id from debuginfo file
   int build_id_len = 0;
@@ -4532,6 +4532,10 @@ dump_unwindsyms (Dwfl_Module *m,
       }
   }
 
+  // Use end as sanity check when resolving symbol addresses.
+  Dwarf_Addr end;
+  dwfl_module_info (m, NULL, NULL, &end, NULL, NULL, NULL, NULL);
+
   // Look up the relocation basis for symbols
   int n = dwfl_module_relocations (m);
 
@@ -4546,10 +4550,11 @@ dump_unwindsyms (Dwfl_Module *m,
 
   Dwarf_Addr extra_offset = 0;
 
-  for (int i = 1 /* XXX: why not 0? */ ; i < syments; ++i)
+  for (int i = 0; i < syments; ++i)
     {
       GElf_Sym sym;
-      const char *name = dwfl_module_getsym(m, i, &sym, NULL);
+      GElf_Word shndxp;
+      const char *name = dwfl_module_getsym(m, i, &sym, &shndxp);
       if (name)
         {
           // NB: Yey, we found the kernel's _stext value.
@@ -4572,17 +4577,15 @@ dump_unwindsyms (Dwfl_Module *m,
                 clog << "Found kernel _stext extra offset 0x" << hex << extra_offset << dec << endl;
             }
 
-          // We only need the function symbols to identify kernel-mode
-          // PC's, so we omit undefined or "fake" absolute addresses.
-          // These fake absolute addresses occur in some older i386
-          // kernels to indicate they are vDSO symbols, not real
-          // functions in the kernel. We also omit symbols that have
-          // suspicious addresses (before base).
+	  // We are only interested in "real" symbols.
+	  // We omit symbols that have suspicious addresses (before base,
+	  // or after end).
           if ((GELF_ST_TYPE (sym.st_info) == STT_FUNC ||
                GELF_ST_TYPE (sym.st_info) == STT_OBJECT) // PR10000: also need .data
-               && !(sym.st_shndx == SHN_UNDEF
-		    || sym.st_shndx == SHN_ABS
-		    || sym.st_value < base))
+               && !(sym.st_shndx == SHN_UNDEF	// Value undefined,
+		    || shndxp == (GElf_Word) -1	// in a non-allocated section,
+		    || sym.st_value >= end	// beyond current module,
+		    || sym.st_value < base))	// before first section.
             {
               Dwarf_Addr sym_addr = sym.st_value;
               const char *secname = NULL;
@@ -4607,6 +4610,16 @@ dump_unwindsyms (Dwfl_Module *m,
                 {
                   // This is a symbol within a (possibly relocatable)
                   // kernel image.
+                  
+		  // We only need the function symbols to identify kernel-mode
+		  // PC's, so we omit undefined or "fake" absolute addresses.
+		  // These fake absolute addresses occur in some older i386
+		  // kernels to indicate they are vDSO symbols, not real
+		  // functions in the kernel. We also omit symbols that have
+                  if (GELF_ST_TYPE (sym.st_info) == STT_FUNC
+		      && sym.st_shndx == SHN_ABS)
+		    continue;
+
                   secname = "_stext";
                   // NB: don't subtract session.sym_stext, which could be inconveniently NULL.
                   // Instead, sym_addr will get compensated later via extra_offset.
@@ -4666,10 +4679,10 @@ dump_unwindsyms (Dwfl_Module *m,
       // There would be only a small benefit to warning.  A user
       // likely can't do anything about this; backtraces for the
       // affected module would just get all icky heuristicy.
-#if 0
-      c->session.print_warning ("No unwind data for " + modname
-				+ ", " + dwfl_errmsg (-1));
-#endif
+      // So only report in verbose mode.
+      if (c->session.verbose > 2)
+	c->session.print_warning ("No unwind data for " + modname
+				  + ", " + dwfl_errmsg (-1));
     }
 
   for (unsigned secidx = 0; secidx < seclist.size(); secidx++)
-- 
cgit 


From 412e8ec0dadbc0010c865f9a285a748b8d08c053 Mon Sep 17 00:00:00 2001
From: Wenji Huang <wenji.huang@oracle.com>
Date: Thu, 9 Apr 2009 23:48:39 -0400
Subject: Make stmt_rel.exp have good compatibility

---
 testsuite/systemtap.base/stmt_rel.exp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/testsuite/systemtap.base/stmt_rel.exp b/testsuite/systemtap.base/stmt_rel.exp
index ec12e484..619c91a5 100644
--- a/testsuite/systemtap.base/stmt_rel.exp
+++ b/testsuite/systemtap.base/stmt_rel.exp
@@ -33,7 +33,9 @@ expect {
     eof { }
 }
 
-if { $ok == 3 } {
+# bio_init drifts a bit in different kernels. 
+# maybe 3, 4 or 15 lines in it.
+if { $ok >= 3 } {
     pass "$test wildcard"
 } else {
     fail "$test wildcard ($ok)"
-- 
cgit 


From f5f4f6b9712d3a93e42d5c2f81d21bf229d65ab6 Mon Sep 17 00:00:00 2001
From: Eugeniy Meshcheryakov <eugen@debian.org>
Date: Mon, 13 Apr 2009 21:05:25 +0200
Subject: add a space

---
 dtrace | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dtrace b/dtrace
index fd7b4b99..ca95b678 100755
--- a/dtrace
+++ b/dtrace
@@ -94,7 +94,7 @@ class provider:
 ########################################################################
 
 def usage ():
-    print "Usage " + sys.argv[0] + "[-h | -G] -s File.d -o File {Files}"
+    print "Usage " + sys.argv[0] + " [-h | -G] -s File.d -o File {Files}"
     sys.exit(1)
 
 def open_file (arg):
-- 
cgit 


From 8ca27b7dc58bf14e86cd40ae6246962fa580966d Mon Sep 17 00:00:00 2001
From: Stan Cox <scox@redhat.com>
Date: Mon, 13 Apr 2009 17:51:58 -0400
Subject: Improve -l output for .label

* tapsets.cxx (iterate_over_cu_labels): Treat -l specially so the
output of a .label can be improved.
* labels.stp: Test -l
---
 tapsets.cxx                         | 21 +++++++++++++++------
 testsuite/systemtap.base/labels.exp | 15 +++++++++++++++
 2 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/tapsets.cxx b/tapsets.cxx
index 2316a777..774821c7 100644
--- a/tapsets.cxx
+++ b/tapsets.cxx
@@ -1339,8 +1339,12 @@ struct dwflpp
   }
 
   void
-  iterate_over_cu_labels (string label_val, string function, Dwarf_Die *cu,
-			  void *data,
+  iterate_over_cu_labels (string label_val,
+			  string function,
+			  Dwarf_Die *cu,
+			  vector<derived_probe *>  & results, 
+			  probe_point *base_loc,
+			  void *data, 
 			  void (* callback)(const string &,
 					    const char *,
 					    int,
@@ -1375,7 +1379,7 @@ struct dwflpp
 	    function_name = name;
 	  default:
 	    if (dwarf_haschildren (&die))
-	      iterate_over_cu_labels (label_val, function, &die, q, callback);
+	      iterate_over_cu_labels (label_val, function, &die, results, base_loc, q, callback);
 	    continue;
 	  }
 	
@@ -1420,8 +1424,13 @@ struct dwflpp
 	    int nscopes = 0;
 	    nscopes = dwarf_getscopes_die (&die, &scopes);
 	    if (nscopes > 1)
-	      callback(function_name.c_str(), file,
-		       (int)dline, &scopes[1], stmt_addr, q);
+	      {
+		callback(function_name.c_str(), file,
+			 (int)dline, &scopes[1], stmt_addr, q);
+		if (sess.listing_mode)
+		  results.back()->locations[0]->components.push_back
+		    (new probe_point::component(TOK_LABEL, new literal_string (name)));
+	      }
 	  }
       }
     while (dwarf_siblingof (&die, &die) == 0);
@@ -4121,7 +4130,7 @@ query_cu (Dwarf_Die * cudie, void * arg)
 	    {
 	      // If we have a pattern string with target *label*, we
 	      // have to look at labels in all the matched srcfiles.
-	      q->dw.iterate_over_cu_labels (q->label_val, q->function, q->dw.cu, q, query_statement);
+	      q->dw.iterate_over_cu_labels (q->label_val, q->function, q->dw.cu, q->results, q->base_loc, q, query_statement);
 	    }
 	  else
 	    {
diff --git a/testsuite/systemtap.base/labels.exp b/testsuite/systemtap.base/labels.exp
index 268bb320..88ed4619 100644
--- a/testsuite/systemtap.base/labels.exp
+++ b/testsuite/systemtap.base/labels.exp
@@ -55,8 +55,23 @@ if { $res != "" } {
     pass "compiling labels.c -g"
 }
 
+# list of labels
+
+spawn stap -l "process(\"$label_exepath\").function(\"*\").label(\"*\")"
+
+wait
+expect {
+    -timeout 180
+    -re {process.*function.*labels.c:5...label..init_an_int.*process.*function.*labels.c:16...label..init_an_int.*process.*function.*labels.c:18...label..init_an_int_again} { incr ok; exp_continue }
+    timeout { fail "$test (timeout)" }
+    eof { }
+}
+
+if {$ok == 1} { pass "$test -l .label" } { fail "$test -l .label $ok" }
+
 # label in an executable
 
+set ok 0
 verbose -log "spawn stap -c $label_exepath $label_stppath"
 spawn stap -c $label_exepath $label_stppath
 
-- 
cgit 


From 675e4d2a0635f822e8258c3f219c6dda685c67cf Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Mon, 13 Apr 2009 14:46:54 -0700
Subject: PR10049: Restore better errors for $return

In commit c4ce66a1 I shifted some of the variable accesses around, and
that caused the error messages for $return variables to lose context.

The root problem in this case was that dwarf_attr didn't find the type
attribute, and that failure wasn't immediately caught.  Now that result
is checked so we can provide a proper error message.

While I'm at it, changing that lookup to dwarf_attr_integrate is enough
to make the $return value usable again, at least for the reported test
case.
---
 tapsets.cxx | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/tapsets.cxx b/tapsets.cxx
index 774821c7..094ae358 100644
--- a/tapsets.cxx
+++ b/tapsets.cxx
@@ -2434,13 +2434,12 @@ struct dwflpp
 
     /* Translate the ->bar->baz[NN] parts. */
 
-    Dwarf_Die die_mem, *die = NULL;
-    die = dwarf_formref_die (&attr_mem, &die_mem);
+    Dwarf_Die die_mem, *die = dwarf_formref_die (&attr_mem, &die_mem);
     die = translate_components (&pool, &tail, pc, e,
 				die, &die_mem, &attr_mem);
     if(!die)
 	{ 
-	  die = dwarf_formref_die (&attr_mem, &vardie);
+	  die = dwarf_formref_die (&attr_mem, &die_mem);
           stringstream alternatives;
           if (die != NULL)
 	    print_members(die,alternatives); 
@@ -2516,17 +2515,19 @@ struct dwflpp
     /* Translate the ->bar->baz[NN] parts. */
 
     Dwarf_Attribute attr_mem;
-    Dwarf_Attribute *attr = dwarf_attr (scope_die, DW_AT_type, &attr_mem);
-
-    Dwarf_Die vardie_mem;
-    Dwarf_Die *vardie = dwarf_formref_die (attr, &vardie_mem);
+    if (dwarf_attr_integrate (scope_die, DW_AT_type, &attr_mem) == NULL)
+      throw semantic_error("failed to retrieve return value type attribute for "
+                           + string(dwarf_diename(scope_die) ?: "<unknown>")
+                           + "(" + string(dwarf_diename(cu) ?: "<unknown>")
+                           + ")",
+                           e->tok);
 
-    Dwarf_Die die_mem, *die = NULL;
+    Dwarf_Die die_mem, *die = dwarf_formref_die (&attr_mem, &die_mem);
     die = translate_components (&pool, &tail, pc, e,
-				vardie, &die_mem, &attr_mem);
+				die, &die_mem, &attr_mem);
     if(!die)
 	{ 
-	  die = dwarf_formref_die (&attr_mem, vardie);
+	  die = dwarf_formref_die (&attr_mem, &die_mem);
           stringstream alternatives;
           if (die != NULL)
 	    print_members(die,alternatives); 
-- 
cgit 


From b9c2e81cc7a62336ec1daf374cb3411add772ab4 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Mon, 13 Apr 2009 19:50:23 -0700
Subject: PR10067: fix bitfield access

	* tapsets.cxx (dwflpp::translate_components): Eliminate the extra
	die-dereference at the end of the loop (a regression from @casts).
	* runtime/loc2c-runtime.h (store_bitfield): Use the target as the
	representative type, since the base is always int64_t.  Also be a
	bit more aggressive with masking and parentheses.
	* testsuite/systemtap.base/bitfield.*: New test for R/W bitfields.
---
 runtime/loc2c-runtime.h               | 11 +++++----
 tapsets.cxx                           |  7 ++++--
 testsuite/systemtap.base/bitfield.exp |  3 +++
 testsuite/systemtap.base/bitfield.stp | 46 +++++++++++++++++++++++++++++++++++
 4 files changed, 60 insertions(+), 7 deletions(-)
 create mode 100644 testsuite/systemtap.base/bitfield.exp
 create mode 100644 testsuite/systemtap.base/bitfield.stp

diff --git a/runtime/loc2c-runtime.h b/runtime/loc2c-runtime.h
index eaf47cad..620e1615 100644
--- a/runtime/loc2c-runtime.h
+++ b/runtime/loc2c-runtime.h
@@ -29,11 +29,12 @@
 	    & (((__typeof (base)) 1 << (nbits)) - 1))
 
 #define store_bitfield(target, base, higherbits, nbits)			      \
-  target = (target							      \
-	    &~ ((((__typeof (base)) 1 << (nbits)) - 1)			      \
-		<< (sizeof (base) * 8 - (higherbits) - (nbits)))	      \
-	    | ((__typeof (base)) (base)					      \
-	       << (sizeof (base) * 8 - (higherbits) - (nbits))))
+  target = ((target							      \
+	     &~ ((((__typeof (target)) 1 << (nbits)) - 1)		      \
+		 << (sizeof (target) * 8 - (higherbits) - (nbits))))	      \
+	    | ((((__typeof (target)) (base))				      \
+		& (((__typeof (target)) 1 << (nbits)) - 1))		      \
+	       << (sizeof (target) * 8 - (higherbits) - (nbits))))
 
 
 /* Given a DWARF register number, fetch its intptr_t (long) value from the
diff --git a/tapsets.cxx b/tapsets.cxx
index 094ae358..c63151e1 100644
--- a/tapsets.cxx
+++ b/tapsets.cxx
@@ -2006,7 +2006,7 @@ struct dwflpp
 		       Dwarf_Die *die_mem,
 		       Dwarf_Attribute *attr_mem)
   {
-    Dwarf_Die *die = die_mem;
+    Dwarf_Die *die = NULL;
     Dwarf_Die struct_die;
     Dwarf_Attribute temp_attr;
 
@@ -2015,6 +2015,9 @@ struct dwflpp
     if (vardie)
       *die_mem = *vardie;
 
+    if (e->components.empty())
+      return die_mem;
+
     static unsigned int func_call_level ;
     static unsigned int dwarf_error_flag ; // indicates current error is dwarf error
     static unsigned int dwarf_error_count ; // keeps track of no of dwarf errors
@@ -2031,6 +2034,7 @@ struct dwflpp
         obstack_printf (pool, "c->last_stmt = %s;", lex_cast_qstring(piece).c_str());
 #endif
 
+	die = die ? dwarf_formref_die (attr_mem, die_mem) : die_mem;
 	const int typetag = dwarf_tag (die);
 	switch (typetag)
 	  {
@@ -2188,7 +2192,6 @@ struct dwflpp
 	/* Now iterate on the type in DIE's attribute.  */
 	if (dwarf_attr_integrate (die, DW_AT_type, attr_mem) == NULL)
 	  throw semantic_error ("cannot get type of field: " + string(dwarf_errmsg (-1)), e->tok);
-	die = dwarf_formref_die (attr_mem, die_mem);
       }
     return die;
   }
diff --git a/testsuite/systemtap.base/bitfield.exp b/testsuite/systemtap.base/bitfield.exp
new file mode 100644
index 00000000..16451369
--- /dev/null
+++ b/testsuite/systemtap.base/bitfield.exp
@@ -0,0 +1,3 @@
+# test that bitfield r/w works correctly
+set test "bitfield"
+stap_run $srcdir/$subdir/$test.stp no_load $all_pass_string -g
diff --git a/testsuite/systemtap.base/bitfield.stp b/testsuite/systemtap.base/bitfield.stp
new file mode 100644
index 00000000..c2ff4929
--- /dev/null
+++ b/testsuite/systemtap.base/bitfield.stp
@@ -0,0 +1,46 @@
+%{
+#include <linux/tcp.h>
+static struct tcphdr foo = {0};
+%}
+
+function get_ptr:long() %{ THIS->__retvalue = (long)&foo; /* pure */ %}
+function get_ack:long() %{ THIS->__retvalue = foo.ack; /* pure */ %}
+function get_urg:long() %{ THIS->__retvalue = foo.urg; /* pure */ %}
+
+function check:long(ack:long, urg:long) {
+  ptr = get_ptr()
+
+  /* set the bits with cast */
+  @cast(ptr, "tcphdr")->ack = ack
+  @cast(ptr, "tcphdr")->urg = urg
+
+  /* check that reading with embedded-C is ok */
+  real_ack = get_ack()
+  real_urg = get_urg()
+  errors = (ack != real_ack) + (urg != real_urg)
+
+  /* check that reading with a cast is ok */
+  cast_ack = @cast(ptr, "tcphdr")->ack
+  cast_urg = @cast(ptr, "tcphdr")->urg
+  errors += (ack != cast_ack) + (urg != cast_urg)
+
+  if (errors)
+    printf("bitfield had %d errors; expect(%d%d), real(%d%d), cast(%d%d)\n",
+           errors, ack, urg, real_ack, real_urg, cast_ack, cast_urg)
+
+  return errors
+}
+
+probe begin {
+  println("systemtap starting probe")
+
+  errors = check(0, 0)
+  errors += check(0, 1)
+  errors += check(1, 0)
+  errors += check(1, 1)
+
+  println("systemtap ending probe")
+  if (errors == 0)
+    println("systemtap test success")
+  exit()
+}
-- 
cgit