Merge branch 'master' into pr6866

Conflicts:
	ChangeLog: Removed
	runtime/ChangeLog: Removed
	runtime/sym.c: Merged
	runtime/task_finder.c: Merged
	tapset/ChangeLog: Removed
	testsuite/ChangeLog: Removed

21 files changed, 695 insertions, 103 deletions

diff --git a/testsuite/systemtap.base/arith.exp b/testsuite/systemtap.base/arith.exp
new file mode 100644
index 00000000..c4f72793
--- /dev/null
+++ b/testsuite/systemtap.base/arith.exp
@@ -0,0 +1,14 @@
+set test "arith"
+if {![installtest_p]} { untested $test; return }
+
+spawn stap -DMAXNESTING=5 $srcdir/$subdir/arith.stp
+set ok 0
+expect {
+    -timeout 150
+    -re {passes: [0-9]* failures: 0} { incr ok }
+    timeout { fail "$test (timeout)" }
+    eof { }
+}
+close
+wait
+if {$ok == 1} { pass "$test" } { fail "$test" }
diff --git a/testsuite/systemtap.base/arith.stp b/testsuite/systemtap.base/arith.stp
new file mode 100644
index 00000000..59016dcb
--- /dev/null
+++ b/testsuite/systemtap.base/arith.stp
@@ -0,0 +1,79 @@
+global testno, passes, failures
+
+function test (v,n1,n2) {
+  if (n1 == n2) {
+    passes ++
+    result = "pass"
+  } else {
+    failures ++
+    result = "fail"
+  }
+  println ("test " . (sprint (++testno)) . " [" . v . "]\t" . result)
+}
+
+function stest (v,n1,n2) {
+  if (n1 == n2) {
+    passes ++
+    result = "pass"
+  } else {
+    failures ++
+    result = "fail"
+  }
+  println ("test " . (sprint (++testno)) . " [" . v . "]\t" . result)
+}
+
+
+probe begin {
+  test ("+", 0, 0+0)
+  test ("+", 33339999, 33330000+9999)
+  test ("-", -1, 2-3)
+  test ("==", 1, -1==-1)
+  test ("!=", 1, -1!=1)
+  test ("== s", 1, "foobar"=="foobar")
+  test ("<= s", 1, "fooban"<="foobar")
+  test ("> s", 1, "xxx">"aaa")
+  test ("<", 1, -1<0)
+  test ("<", 1, 85723838<8273823892)
+  test ("*", 100300400500, 1003004005 * 100)
+  test ("*", -1*-500, 500)
+  test ("/", 1003004005/1000, 1003004)
+  test ("%", 1003004005%1000, 5)
+  test ("/", -1/-1, 1)
+  test ("%", -1%-1, 0)
+  test ("/", 0/-100, 0)
+  test ("%", 0%-100, 0)
+  test ("/", (-2147483647-1)/-1, 2147483648)
+  test ("%", (-2147483647-1)%-1, 0)
+  # but      (-9223372036854775807-1)/-1 may overflow
+  test ("%", (-9223372036854775807-1)%-1, 0)
+  test ("&", 0x555&0xaaa, 0)
+  test ("|", 0x555|0xaaa, 0xfff)
+  test ("^", 0x55f^0xaaf, 0xff0)
+  test ("&&", 0x555&&0xaaa, 1)
+  test ("||", 0x555||0xaaa, 1)
+  test ("<<", 0<<5, 0)
+  test ("<<", 1<<8, 0x100)
+  test ("<<", 120<<-2, 120)
+  test ("<<", 120<<0, 120)
+  test ("<<", -4096<<-3, -4096)
+  test (">>", -4096>>3, -512)
+  test (">>", -4096>>-3, -4096)
+  test (">>", 120>>-2, 120)
+  test (">>", 120>>0, 120)
+  i=1; test ("--i", --i, 0)
+  i=1; test ("++i", ++i, 2)
+  i=1; test ("i--", i--, 1)
+  i=1; test ("i++", i++, 1)
+  i=1; test ("+=", i+=4, 5) test ("after +=", i, 5)
+  i=5; test ("/=", i/=2, 2) test ("after /=", i, 2)
+  a="1" b="2"; stest (".=", a .= b, "12") stest ("after .=", a, "12")
+}
+
+
+probe timer.jiffies(1) { # some time after all the begin probes
+  exit ()
+}
+
+probe end {
+	printf ("passes: %d failures: %d\n", passes, failures)
+}
diff --git a/testsuite/systemtap.base/arith_limits.exp b/testsuite/systemtap.base/arith_limits.exp
new file mode 100644
index 00000000..93794c8e
--- /dev/null
+++ b/testsuite/systemtap.base/arith_limits.exp
@@ -0,0 +1,13 @@
+set test "arith_limits"
+if {![installtest_p]} { untested $test; return }
+
+spawn stap -DMAXNESTING=5 $srcdir/$subdir/arith_limits.stp
+set ok 0
+expect {
+    -timeout 150
+    -re {passes: [0-9]* failures: 0} { incr ok }
+    timeout { fail "$test (timeout)" }
+    eof { }
+}
+wait
+if {$ok == 1} { pass "$test" } { fail "$test" }
diff --git a/testsuite/systemtap.base/arith_limits.stp b/testsuite/systemtap.base/arith_limits.stp
new file mode 100644
index 00000000..6c620830
--- /dev/null
+++ b/testsuite/systemtap.base/arith_limits.stp
@@ -0,0 +1,80 @@
+global testno, passes, failures
+
+function test (v,n1,n2) {
+  if (n1 == n2) {
+    passes ++
+    result = "pass"
+  } else {
+    failures ++
+    result = "fail"
+  }
+  printf ("test %d [%s]\t\t%s\n", testno++, v, result)
+}
+
+# Exactly the same as test() except it will magically work for strings.
+# Wouldn't it be nice if we didn't have to do this?
+
+function teststr (v,n1,n2) {
+  if (n1 == n2) {
+    passes ++
+    result = "pass"
+  } else {
+    failures ++
+    result = "fail"
+  }
+  printf ("test %d [%s]\t\t%s\n", testno++, v, result)
+}
+
+
+
+probe begin {
+	# max/minimum signed 32-bit values.
+	# these could cause problems for 32-bit cpus when overflows
+	# occur into 64-but values
+	lmax = 0x7fffffff
+	lmin = -0x80000000
+
+	# max/minimum signed 64-bit values
+	llmax =  0x7fffffffffffffff
+	llmin = -0x7fffffffffffffff-1
+
+	# 32-bit limit tests
+	teststr ("string lmax", sprint(lmax), "2147483647")
+	teststr ("hex lmax", sprintf("0x%x", lmax), "0x7fffffff")
+	teststr ("string lmin", sprint(lmin), "-2147483648")
+	teststr ("hex lmin", sprintf("0x%x", lmin), "0xffffffff80000000")
+	test ("lmax/-1", lmax/-1, -2147483647);
+	test ("lmin/-1", lmin/-1, 2147483648);
+	test ("lmax +1", lmax+1, 2147483648);
+	test ("lmin -1", lmin-1, -2147483649);
+
+	# 64-bit limits
+	teststr ("string llmax", sprint(llmax), "9223372036854775807")
+	teststr ("hex llmax", sprintf("0x%x", llmax), "0x7fffffffffffffff")
+	teststr ("string llmin", sprint(llmin), "-9223372036854775808")
+	teststr ("hex llmin", sprintf("0x%x", llmin), "0x8000000000000000")
+	test ("llmax/-1", llmax/-1, -llmax)
+	test ("llmax*-1", llmax*-1, -llmax)
+
+	# the next three overflow and produce predictable, although
+	# wrong results
+	test ("llmin/-1", llmin/-1, llmin)
+	test ("llmin*-1", llmin*-1, llmin)
+	test ("llmax +1", llmax+1, llmin)
+	test ("llmin -1", llmin-1, llmax)
+
+	# modulo tests
+	test ("llmax%1", llmax%1, 0)
+	test ("llmin%1", llmin%1, 0)
+	test ("0%1    ", 0%1, 0)
+	test ("0%lmax", 0%lmax, 0)
+	test ("1%lmax", 1%lmax, 1)
+	test ("0%lmin", 0%lmin, 0)
+	test ("1%lmin", 1%lmin, 1)
+	
+	exit()
+}
+
+probe end {
+	printf ("passes: %d failures: %d\n", passes, failures)
+}
diff --git a/testsuite/systemtap.base/bz5274.exp b/testsuite/systemtap.base/bz5274.exp
index db0e0a46..92441e9e 100755
--- a/testsuite/systemtap.base/bz5274.exp
+++ b/testsuite/systemtap.base/bz5274.exp
@@ -8,11 +8,14 @@ if {$arch == "ppc64"} {
 	catch {exec gcc -o $test -g $srcdir/$subdir/$test.c} err
 }
 
-
 if {$err == "" && [file exists $test]} then { pass "$test compile"
 } else {fail "$test compile"}
 
-if {! [installtest_p]} { untested "$test -p5"; return }
+if {! [installtest_p]} {
+    catch {exec rm -f $test}
+    untested "$test -p5"
+    return
+}
 
 # Try to find utrace_attach symbol in /proc/kallsyms
 # copy from utrace_p5.exp
@@ -21,7 +24,11 @@ set path "/proc/kallsyms"
 if {! [catch {exec grep -q utrace_attach $path} dummy]} {
     set utrace_support_found 1
 }
-if {$utrace_support_found == 0} { untested "$test -p5"; return }
+if {$utrace_support_found == 0} {
+    catch {exec rm -f $test}
+    untested "$test -p5"
+    return
+}
 
 if {[catch {exec stap $tpath.stp -c "$srcdir/$subdir/$test.sh"} res]} {
     untested "$test longjmp to a uretprobed function"
diff --git a/testsuite/systemtap.base/bz6850.exp b/testsuite/systemtap.base/bz6850.exp
index 73fedc8a..b96ed95c 100644
--- a/testsuite/systemtap.base/bz6850.exp
+++ b/testsuite/systemtap.base/bz6850.exp
@@ -10,12 +10,21 @@ set path "/proc/kallsyms"
 if {! [catch {exec grep -q utrace_attach $path} dummy]} {
     set utrace_support_found 1
 }
-if {$utrace_support_found == 0} { untested "$test -p4"; untested "$test -p5"; return }
+if {$utrace_support_found == 0} {
+    catch {exec rm -f $test}
+    untested "$test -p4"
+    untested "$test -p5"
+    return
+}
 
 set rc [stap_run_batch $srcdir/$subdir/bz6850.stp]
 if {$rc == 0} then { pass "$test -p4" } else { fail "$test -p4" }
 
-if {! [installtest_p]} { untested "$test -p5"; return }
+if {! [installtest_p]} {
+    catch {exec rm -f $test}
+    untested "$test -p5"
+    return
+}
 
 # Pick up the stap being tested.
 set stapexe [exec /usr/bin/which stap]
diff --git a/testsuite/systemtap.base/control_limits.exp b/testsuite/systemtap.base/control_limits.exp
new file mode 100644
index 00000000..513b2c4d
--- /dev/null
+++ b/testsuite/systemtap.base/control_limits.exp
@@ -0,0 +1,46 @@
+set test "control_limits MAXNESTING"
+if {![installtest_p]} { untested $test; return }
+
+spawn stap -u -DMAXNESTING=5 $srcdir/$subdir/control_limits.stp
+set ok 0
+expect {
+    -timeout 150
+    -re {ERROR.*MAXNESTING} { incr ok; exp_continue }
+    timeout { fail "$test (timeout)" }
+    eof { }
+}
+if {$ok == 1} { pass "$test ($ok)" } { fail "$test ($ok)" }
+
+set test "control_limits MAXACTION"
+spawn stap -u -DMAXACTION_INTERRUPTIBLE=500 $srcdir/$subdir/control_limits.stp
+set ok 0
+expect {
+    -timeout 150
+    -re {ERROR.*MAXACTION} { incr ok; exp_continue }
+    timeout { fail "$test (timeout)" }
+    eof { }
+}
+if {$ok == 1} { pass "$test ($ok)" } { fail "$test ($ok)" }
+
+set test "control_limits MAXSTRINGLEN small"
+spawn stap -u -DMAXSTRINGLEN=50 $srcdir/$subdir/control_limits.stp
+set ok 0
+expect {
+    -timeout 150
+    -re {ERROR.*MAXSTRINGLEN reduced} { incr ok; exp_continue }
+    timeout { fail "$test (timeout)" }
+    eof { }
+}
+if {$ok == 1} { pass "$test ($ok)" } { fail "$test ($ok)" }
+
+set test "control_limits MAXSTRINGLEN large"
+spawn stap -u -DMAXSTRINGLEN=500 $srcdir/$subdir/control_limits.stp
+set ok 0
+expect {
+    -timeout 150
+    -re {ERROR.*MAXSTRINGLEN enlarged} { incr ok; exp_continue }
+    timeout { fail "$test (timeout)" }
+    eof { }
+}
+if {$ok == 1} { pass "$test ($ok)" } { fail "$test ($ok)" }
+
diff --git a/testsuite/systemtap.base/control_limits.stp b/testsuite/systemtap.base/control_limits.stp
new file mode 100644
index 00000000..89b0bae4
--- /dev/null
+++ b/testsuite/systemtap.base/control_limits.stp
@@ -0,0 +1,24 @@
+
+# for MAXNESTING testing
+function recurse (n) {
+  if (n > 0) recurse (n-1)
+}
+probe begin {
+  recurse (7)
+}
+
+# for MAXACTION testing
+probe begin {
+  for (i=0; i<498; i++) {}
+}
+
+# for MAXSTRINGLEN testing
+probe begin {
+  s = "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" # last 8 will be \0'd
+  if (strlen(s) < 127) error ("MAXSTRINGLEN reduced")
+  if (strlen(s) > 127) error ("MAXSTRINGLEN enlarged")
+}
+
+
+probe begin { exit () }
+
diff --git a/testsuite/systemtap.base/crash.exp b/testsuite/systemtap.base/crash.exp
new file mode 100644
index 00000000..9c3e5e05
--- /dev/null
+++ b/testsuite/systemtap.base/crash.exp
@@ -0,0 +1,45 @@
+# Simple test for staplog.so crash(8) extension
+set test "crash"
+
+if {![installtest_p]} { untested $test; return }
+if {![file exists $env(CRASH_LIBDIR)/staplog.so]} { untested "$test - no staplog.so"; return }
+
+# Load a test script
+spawn stap $srcdir/$subdir/testlog.stp -m testlog
+expect {
+    -timeout 120
+    "HelloWorld\r\n" { 
+        pass "$test - testlog.stp"
+        # Need to run crash(8) while this script is still running.
+        # Since crash(8) needs /dev/mem access, need it run as_root too.
+        # This [ eval ... \{ \} ] business is necessary because as_root
+        # evals the given list/variables in its own scope.
+        eval as_root \{ $srcdir/$subdir/crash.sh $env(CRASH_LIBDIR) \}
+    }
+    timeout { fail "$test - testlog.stp timeout" }
+    timeout { fail "$test - testlog.stp eof" }
+}
+catch { exec kill -INT -[exp_pid]; close ; wait }
+
+# The crash(8) script creates testlog/global or testlog/cpu<n>
+as_root { chmod -R a+rX testlog }
+
+set ok 0
+foreach f [glob -nocomplain testlog/*] {
+    pass "$test - crash(8) generated $f"
+    set fp [open $f]
+    set chars [read $fp]
+    close $fp
+    if [string match "HelloWorld*" $chars] {
+        incr ok
+        pass "$test - crash(8) data"
+    } else {
+        fail "$test - crash(8) data $chars"
+    }
+}
+if {$ok == 0} {
+    fail "$test - crash(8) data"
+}
+
+as_root { rm -rf testlog testlog.ko }
+
diff --git a/testsuite/systemtap.base/crash.sh b/testsuite/systemtap.base/crash.sh
new file mode 100755
index 00000000..06aa414e
--- /dev/null
+++ b/testsuite/systemtap.base/crash.sh
@@ -0,0 +1,8 @@
+#! /bin/sh
+
+crash --readnow << END
+mod -s testlog testlog.ko
+extend $1/staplog.so
+staplog testlog
+exit
+END
diff --git a/testsuite/systemtap.base/gtod.c b/testsuite/systemtap.base/gtod.c
new file mode 100644
index 00000000..abc08543
--- /dev/null
+++ b/testsuite/systemtap.base/gtod.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+int main (int argc, char *argv[])
+{
+	int i;
+	struct timeval tv[100][2];
+	int us = 0;
+	if (argc == 2) us = atoi(argv[1]);
+	for (i=0; i<100; i++) {
+		gettimeofday(&tv[i][0], NULL);
+		setsid();
+		gettimeofday(&tv[i][1], NULL);
+		if (us) usleep(us);
+	}
+	for (i=0; i<100; i++) {
+		// change last 4 chars for correctly sorting even if the
+		// time stamps are completely same.
+		printf("%8d%06d :%02d appl\n", tv[i][0].tv_sec, tv[i][0].tv_usec, i);
+		printf("%8d%06d :%02d prog\n", tv[i][1].tv_sec, tv[i][1].tv_usec, i);
+	}
+	return 0;
+}
+
diff --git a/testsuite/systemtap.base/gtod.exp b/testsuite/systemtap.base/gtod.exp
new file mode 100644
index 00000000..a8f3c9d6
--- /dev/null
+++ b/testsuite/systemtap.base/gtod.exp
@@ -0,0 +1,40 @@
+# test for checking monotonic timer (PR3916)
+set test "gtod"
+if {![installtest_p]} { untested $test; continue }
+
+set wd [pwd]
+set filename "$srcdir/$subdir/gtod.c"
+
+target_compile $filename $wd/gtod executable ""
+
+# non interval (check timer drift in short range)
+spawn $srcdir/$subdir/gtod.sh $srcdir/$subdir/gtod.stp $wd/gtod
+set ok 0
+expect {
+	-timeout 120
+	-re {^[0-9]+ \:([0-9]+) appl\r\n[0-9]+ \:\1 kern\r\n[0-9]+ \:\1 prog\r\n} { incr ok; exp_continue }
+	timeout { fail "$test (timeout)" }
+	eof { }
+}
+wait
+#10ms interval (check timer drift in middle range)
+spawn $srcdir/$subdir/gtod.sh $srcdir/$subdir/gtod.stp $wd/gtod 10000
+expect {
+	-timeout 120
+	-re {^[0-9]+ \:([0-9]+) appl\r\n[0-9]+ \:\1 kern\r\n[0-9]+ \:\1 prog\r\n} { incr ok; exp_continue }
+	timeout { fail "$test (timeout)" }
+	eof { }
+}
+wait
+#100ms interval (calm down processors and CPU freq might be changed)
+spawn $srcdir/$subdir/gtod.sh $srcdir/$subdir/gtod.stp $wd/gtod 100000
+expect {
+	-timeout 120
+	-re {^[0-9]+ \:([0-9]+) appl\r\n[0-9]+ \:\1 kern\r\n[0-9]+ \:\1 prog\r\n} { incr ok; exp_continue }
+	timeout { fail "$test (timeout)" }
+	eof { }
+}
+wait
+exec rm -f $wd/gtod
+if {$ok == 300} { pass "$test ($ok)" } { fail "$test ($ok)" }
+
diff --git a/testsuite/systemtap.base/gtod.sh b/testsuite/systemtap.base/gtod.sh
new file mode 100755
index 00000000..4d4a28c2
--- /dev/null
+++ b/testsuite/systemtap.base/gtod.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+stap $1 -c "$2 $3" | sort
+
diff --git a/testsuite/systemtap.base/gtod.stp b/testsuite/systemtap.base/gtod.stp
new file mode 100644
index 00000000..f252dc0a
--- /dev/null
+++ b/testsuite/systemtap.base/gtod.stp
@@ -0,0 +1,8 @@
+global count = 0
+
+probe syscall.setsid {
+	if (pid() == target()) {
+		printf("%014d :%02d kern\n", gettimeofday_us(), count);
+		count ++;
+	}
+}
diff --git a/testsuite/systemtap.base/labels.exp b/testsuite/systemtap.base/labels.exp
new file mode 100644
index 00000000..9c92d69c
--- /dev/null
+++ b/testsuite/systemtap.base/labels.exp
@@ -0,0 +1,70 @@
+set test "labels"
+if {![installtest_p]} {untested $test; return}
+
+# Try to find utrace_attach symbol in /proc/kallsyms
+# copy from utrace_p5.exp
+set utrace_support_found 0
+set path "/proc/kallsyms"
+if {! [catch {exec grep -q utrace_attach $path} dummy]} {
+    set utrace_support_found 1
+}
+if {$utrace_support_found == 0} { untested "$test"; return }
+
+# Compile a C program to use as the user-space probing target
+set label_srcpath "[pwd]/labels.c"
+set label_exepath "[pwd]/labels.x"
+set label_flags "additional_flags=-g"
+set fp [open $label_srcpath "w"]
+puts $fp "
+int
+main ()
+{
+  sleep(5);
+  int a = 0;
+  int b = 0;
+  char *c;
+init_an_int:
+  a = 2;
+init_another_int:
+  b = 3;
+  c = \"abc\";
+ptr_inited:
+  return 1;
+}
+"
+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)}
+"
+close $fp
+
+set ok 0
+
+set res [target_compile $label_srcpath $label_exepath executable $label_flags]
+if { $res != "" } {
+    verbose "target_compile failed: $res" 2
+    fail "compiling labels.c -g"
+    catch {exec rm -f $label_srcpath $label_stppath}
+    return
+} else {
+    pass "compiling labels.c -g"
+}
+
+verbose -log "spawn stap -c $label_exepath $label_stppath"
+spawn stap -c $label_exepath $label_stppath
+
+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 }
+    timeout { fail "$test (timeout)" }
+    eof { }
+}
+
+wait
+
+if {$ok == 1} { pass "$test" } { fail "$test ($ok)" }
+catch {exec rm -f $label_srcpath $label_stppath $label_exepath}
diff --git a/testsuite/systemtap.base/poll_map.exp b/testsuite/systemtap.base/poll_map.exp
new file mode 100644
index 00000000..5ade48e6
--- /dev/null
+++ b/testsuite/systemtap.base/poll_map.exp
@@ -0,0 +1,14 @@
+set test "poll_map"
+if {![installtest_p]} { untested $test; return }
+
+spawn stap -g $srcdir/$subdir/poll_map.stp
+set ok 0
+expect {
+    -timeout 400
+    -ex "SUCCESS" { incr ok }
+    timeout { fail "$test (timeout)" }
+    eof { }
+}
+close
+wait
+if {$ok == 1} { pass "$test ($ok)" } { fail "$test ($ok)" }
diff --git a/testsuite/systemtap.base/poll_map.stp b/testsuite/systemtap.base/poll_map.stp
new file mode 100755
index 00000000..cd39b433
--- /dev/null
+++ b/testsuite/systemtap.base/poll_map.stp
@@ -0,0 +1,33 @@
+#! stap
+
+# test that polling loops do not exit when conflicts happen
+# see PR 1379
+
+global called, num_polls
+
+probe kernel.function( "sys_*" ).call {
+	called[execname(),probefunc()]++
+}
+
+probe timer.ms(1000)
+{
+	print("\n\n")
+	num_to_do = 10
+	foreach ([n,f] in called-) {
+		printf("%s called %s\t%d times\n", n, f, called[n,f])
+		num_to_do--
+		if (num_to_do <= 0)
+			break
+	}
+	delete called
+	num_polls++
+	if (num_polls > 30)
+		exit()
+}
+
+probe end {
+	if (num_polls <= 30)
+		print ("FAIL\n")
+	else
+		print ("SUCCESS\n")
+}
diff --git a/testsuite/systemtap.base/static_uprobes.exp b/testsuite/systemtap.base/static_uprobes.exp
index eb0d1c6e..11fec9b1 100644
--- a/testsuite/systemtap.base/static_uprobes.exp
+++ b/testsuite/systemtap.base/static_uprobes.exp
@@ -1,21 +1,17 @@
+
 set test "sduprobes"
-if {![installtest_p]} {untested $test; return}
 
 # Compile a C program to use as the user-space probing target
 set sup_srcpath "[pwd]/static_uprobes.c"
 set sup_exepath "[pwd]/static_uprobes.x"
-set sup_flags "additional_flags=-iquote$env(SYSTEMTAP_RUNTIME) additional_flags=-L$env(CRASH_LIBDIR) additional_flags=-lsduprobes"
+set supcplus_exepath "[pwd]/static_uprobes_cplus.x"
 set fp [open $sup_srcpath "w"]
 puts $fp "
 #include <stdlib.h>
 #define USE_STAP_PROBE 1
 #include \"static_uprobes.h\"
 
-foo ()
-{
-  STAP_PROBE(static_uprobes,test_probe_1);
-}
-
+void
 bar (int i)
 {
   if (i == 0)
@@ -23,6 +19,7 @@ bar (int i)
   STAP_PROBE1(static_uprobes,test_probe_2,i);
 }
 
+void
 baz (int i, char* s)
 {
   STAP_PROBE1(static_uprobes,test_probe_0,i);
@@ -31,102 +28,31 @@ baz (int i, char* s)
   STATIC_UPROBES_TEST_PROBE_3(i,s);
 }
 
+void
 buz (int parm)
 {
+  if (parm == 0)
+    parm = 1000;
+  DTRACE_PROBE1(static_uprobes,test_probe_4,parm);
 }
 
+int
 main ()
 {
-  sleep(5);
-  foo();
   bar(2);
-  baz(3,\"abc\");
+  baz(3,(char*)\"abc\");
   buz(4);
 }
 "
 close $fp
 
-# set res [target_compile $sup_srcpath $sup_exepath executable $sup_flags]
-# if { $res != "" } {
-#     verbose "target_compile failed: $res" 2
-#     fail "compiling static_uprobes.c"
-#     return
-# } else {
-#     pass "compiling static_uprobes.c"
-# }
-
-set fp [open "[pwd]/static_uprobes.stp" "w"]
+set sup_stppath "[pwd]/static_uprobes.stp"
+set fp [open $sup_stppath "w"]
 puts $fp "
 probe process(\"static_uprobes.x\").mark(\"test_probe_0\") 
 { 
   printf(\"In test_probe_0 probe %#x\\n\", \$arg1)
 }
-probe process(\"static_uprobes.x\").mark(\"test_probe_1\") 
-{ 
-  printf(\"In test_probe_1 probe\\n\")
-}
-probe process(\"static_uprobes.x\").mark(\"test_probe_2\") 
-{ 
-  printf(\"In test_probe_2 probe %#x\\n\", \$arg1)
-}
-probe process(\"static_uprobes.x\").mark(\"test_probe_3\") 
-{ 
-  printf(\"In test_probe_3 probe %#x %#x\\n\", \$arg1, \$arg2)
-}
-"
-close $fp
-
-# Try to find utrace_attach symbol in /proc/kallsyms
-# copy from utrace_p5.exp
-set utrace_support_found 0
-set path "/proc/kallsyms"
-if {! [catch {exec grep -q utrace_attach $path} dummy]} {
-    set utrace_support_found 1
-}
-if {$utrace_support_found == 0} { untested "$test"; return }
-
-set ok 0
-# 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 test_probe_1 probe} { incr ok; exp_continue }
-#     -re {In test_probe_2 probe 0x2} { incr ok; exp_continue }
-#     -re {In test_probe_0 probe 0x3} { incr ok; exp_continue }
-#     -re {In test_probe_3 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 <<HERE
-/USE_STAP_PROBE/d
-/buz/+1
-a
-  DTRACE_PROBE1(static_uprobes,test_probe_4,parm);
-.
-w
-q
-"
-close $fp
-spawn sh [pwd]/static_uprobes.sh
-
-set fp [open "[pwd]/static_uprobes.stp" "w"]
-puts $fp "
-probe process(\"static_uprobes.x\").mark(\"test_probe_0\") 
-{ 
-  printf(\"In test_probe_0 probe %#x\\n\", \$arg1)
-}
-probe process(\"static_uprobes.x\").mark(\"test_probe_1\") 
-{ 
-  printf(\"In test_probe_1 probe\\n\")
-}
 probe process(\"static_uprobes.x\").mark(\"test_probe_2\") 
 {
   printf(\"In test_probe_2 probe %#x\\n\", \$arg1)
@@ -142,7 +68,9 @@ probe process(\"static_uprobes.x\").mark(\"test_probe_4\")
 "
 close $fp
 
-set fp [open "[pwd]/static_uprobes.d" "w"]
+set sup_dpath "[pwd]/static_uprobes.d" 
+set sup_hpath "[pwd]/static_uprobes.h" 
+set fp [open $sup_dpath "w"]
 puts $fp "
 provider static_uprobes {
         probe test_probe_1 ();
@@ -152,20 +80,94 @@ provider static_uprobes {
 };
 "
 close $fp
-spawn dtrace -h -s [pwd]/static_uprobes.d
+if {[installtest_p]} { 
+    set dtrace $env(SYSTEMTAP_PATH)/dtrace 
+} else {
+    set dtrace $srcdir/../dtrace
+}
+if {[catch {exec $dtrace -h -s $sup_dpath} res]} {
+    verbose -log "unable to run $dtrace: $res"
+}
+if {[file exists $sup_hpath]} then {
+    pass "$test generating header"
+} else {
+    fail "$test generating header"
+    catch {exec rm -f $sup_srcpath $sup_hpath $sup_stppath}
+    return
+}
+
+catch {exec rm -f $sup_dpath}
 
-set sup_flags "additional_flags=-iquote$env(SYSTEMTAP_RUNTIME) additional_flags=-g additional_flags=-O additional_flags=-I."
+if {[installtest_p]} { 
+    set sdtdir $env(SYSTEMTAP_INCLUDES)
+} else {
+    set sdtdir $srcdir/../includes
+}
+
+set sup_flags "additional_flags=-I$sdtdir additional_flags=-g additional_flags=-O additional_flags=-I."
 set res [target_compile $sup_srcpath $sup_exepath executable $sup_flags]
 if { $res != "" } {
     verbose "target_compile failed: $res" 2
-    fail "compiling sduprobes.c -g"
+    fail "$test compiling C -g"
+    catch {exec rm -f $sup_srcpath $sup_hpath $sup_stppath}
     return
 } else {
-    pass "compiling sduprobes.c -g"
+    pass "$test compiling C -g"
 }
 
-verbose -log "spawn stap -c $sup_exepath [pwd]/static_uprobes.stp"
-spawn stap -c $sup_exepath [pwd]/static_uprobes.stp
+spawn mv $sup_srcpath "[pwd]/static_uprobes.cc"
+set sup_srcpath "[pwd]/static_uprobes.cc"
+set sup_flags "$sup_flags c++"
+set res [target_compile $sup_srcpath $supcplus_exepath executable $sup_flags]
+if { $res != "" } {
+    verbose "target_compile failed: $res" 2
+    fail "$test compiling C++ -g"
+    catch {exec rm -f $sup_srcpath $sup_exepath $sup_hpath $sup_stppath}
+    return
+} else {
+    pass "$test compiling C++ -g"
+}
+
+if {![installtest_p]} {untested $test; return}
+
+# Try to find utrace_attach symbol in /proc/kallsyms
+# copy from utrace_p5.exp
+set utrace_support_found 0
+set path "/proc/kallsyms"
+if {! [catch {exec grep -q utrace_attach $path} dummy]} {
+    set utrace_support_found 1
+}
+if {$utrace_support_found == 0} {
+    untested "$test"
+    catch {exec rm -f $sup_srcpath}
+    return
+}
+
+set ok 0
+
+verbose -log "spawn stap -c $sup_exepath $sup_stppath"
+spawn stap -c $sup_exepath $sup_stppath
+expect {
+    -timeout 180
+    -re {In test_probe_2 probe 0x2} { incr ok; exp_continue }
+    -re {In test_probe_0 probe 0x3} { incr ok; exp_continue }
+    -re {In test_probe_3 probe 0x3 0x[0-9a-f][0-9a-f]} { incr ok; exp_continue }
+    -re {In test_probe_4 dtrace probe 0x4} { incr ok; exp_continue }
+    timeout { fail "$test C (timeout)" }
+    eof { }
+}
+
+wait
+
+if {$ok == 4} { pass "$test C" } { fail "$test C ($ok)" }
+
+set ok 0
+
+# spawn objcopy -R .probes $supcplus_exepath $sup_exepath 
+verbose -log "cp $supcplus_exepath $sup_exepath"
+spawn cp $supcplus_exepath $sup_exepath
+verbose -log "spawn stap -c $sup_exepath $sup_stppath"
+spawn stap -c $sup_exepath $sup_stppath
 expect {
     -timeout 180
     -re {In test_probe_1 probe} { incr ok; exp_continue }
@@ -173,10 +175,15 @@ expect {
     -re {In test_probe_0 probe 0x3} { incr ok; exp_continue }
     -re {In test_probe_3 probe 0x3 0x[0-9a-f][0-9a-f]} { incr ok; exp_continue }
     -re {In test_probe_4 dtrace probe 0x4} { incr ok; exp_continue }
-    timeout { fail "$test (timeout)" }
+    timeout { fail "$test C++ (timeout)" }
     eof { }
 }
 
 wait
 
-if {$ok == 5} { pass "$test" } { fail "$test ($ok)" }
+if {$ok == 4} { pass "$test C++" } { fail "$test C++ ($ok)" }
+
+# catch {exec rm -f $sup_srcpath $sup_exepath $supcplus_exepath $sup_hpath $sup_stppath}
+
+# It's not so important to clean up, and it's unhelpful if
+# one needs to diagnose a test failure.
\ No newline at end of file
diff --git a/testsuite/systemtap.base/system_func.exp b/testsuite/systemtap.base/system_func.exp
new file mode 100644
index 00000000..ec935783
--- /dev/null
+++ b/testsuite/systemtap.base/system_func.exp
@@ -0,0 +1,22 @@
+set test "system_func"
+if {![installtest_p]} { untested $test; return }
+spawn stap $srcdir/$subdir/system_func.stp
+set open 0
+set done 0
+set saw_user 0
+set user [exec whoami]
+expect {
+    -timeout 30
+    -re "($user|sys_open|DONE)\r" {
+	switch $expect_out(1,string) {
+	    sys_open {incr open}
+	    DONE     {incr done}
+	    default  {incr saw_user}
+	}
+	exp_continue
+    }
+    timeout { fail "$test (timeout)" }
+    eof { }
+}
+catch {close}; wait
+if {$open == 1 && $saw_user == 1 && $done == 1 } { pass "$test" } { fail "$test ($open,$saw_user,$done)" }
diff --git a/testsuite/systemtap.base/system_func.stp b/testsuite/systemtap.base/system_func.stp
new file mode 100644
index 00000000..d14fb25b
--- /dev/null
+++ b/testsuite/systemtap.base/system_func.stp
@@ -0,0 +1,35 @@
+#! stap
+
+# test the system() function
+
+global saw_echo, did_cat
+
+probe kernel.function("sys_open") {
+  if (!saw_echo) {
+    # very inefficient. Testing only. DO NOT DO THIS
+    msg="echo sys_open"
+    system(msg)
+    saw_echo = 1
+  }
+}
+
+probe timer.ms(100) {
+  # should fail	
+  system("cat __xyzzy123ABC__")
+  did_cat = 1
+}
+
+probe timer.ms(150) { 
+	if (saw_echo && did_cat)
+		exit() 
+}
+
+probe begin {
+  # should succeed
+  system("whoami")
+}
+
+probe end {
+  # should succeed
+  system("echo DONE")
+}
diff --git a/testsuite/systemtap.base/uprobes.exp b/testsuite/systemtap.base/uprobes.exp
index e8318586..89250e7b 100644
--- a/testsuite/systemtap.base/uprobes.exp
+++ b/testsuite/systemtap.base/uprobes.exp
@@ -25,12 +25,20 @@ set path "/proc/kallsyms"
 if {! [catch {exec grep -q utrace_attach $path} dummy]} {
     set utrace_support_found 1
 }
-if {$utrace_support_found == 0} { untested "$test -p4"; untested "$test -p5"; return }
+if {$utrace_support_found == 0} {
+    untested "$test -p4"; untested "$test -p5"
+    catch {exec rm -f jennie.c jennie}
+    return
+}
 
 set rc [stap_run_batch $srcdir/$subdir/uprobes.stp]
 if {$rc == 0} then { pass "$test -p4" } else { fail "$test -p4" }
 
-if {! [installtest_p]} { untested "$test -p5"; exec rm -f jennie.c jennie; return }
+if {! [installtest_p]} {
+    untested "$test -p5";
+    catch {exec rm -f jennie.c jennie}
+    return
+}
 
 # Pick up the stap being tested.
 set stapexe [exec /usr/bin/which stap]
@@ -46,4 +54,4 @@ expect {
 if {$ok == 10} then { pass "$test -p5" } else { fail "$test -p5 ($ok)" }
 catch {wait; close}
 
-exec rm -f jennie.c jennie
+catch {exec rm -f jennie.c jennie}