diff options
Diffstat (limited to 'testsuite/systemtap.base')
53 files changed, 2170 insertions, 270 deletions
diff --git a/testsuite/systemtap.base/alternatives.exp b/testsuite/systemtap.base/alternatives.exp index deaf3bf8..f5dc4513 100644 --- a/testsuite/systemtap.base/alternatives.exp +++ b/testsuite/systemtap.base/alternatives.exp @@ -14,11 +14,11 @@ # listed, but that some alternatives are listed. set local1_script { - probe kernel.function("sys_getrlimit") { x = $z; } + probe kernel.function("vfs_write") { ret = $z; } } set struct1_script { - probe kernel.function("sys_getrlimit") { rlim_cur = $rlim->rlim_cud; } + probe kernel.function("vfs_write") { f_pos = $file->f_po; } } proc stap_run_alternatives {args} { @@ -26,10 +26,11 @@ proc stap_run_alternatives {args} { verbose -log "starting $args" eval spawn $args expect { + -timeout 60 -re {semantic error: .+ \(alternatives: [a-zA-Z_]} {incr alternatives_found; exp_continue} -re {[^\r]*\r} { verbose -log $expect_out(0,string); exp_continue } - eof { } - timeout { } + eof { verbose -log "EOF" } + timeout { verbose -log "TIMEOUT" } } set results [wait] verbose -log "wait results: $results" @@ -37,9 +38,9 @@ proc stap_run_alternatives {args} { } set test "LOCAL1" -set rc [stap_run_alternatives stap -vu -p2 -e $local1_script] -if {$rc == 1} { pass $test } else { fail "$test ($rc)" } +set rc [stap_run_alternatives stap -u -p2 -e $local1_script] +if {$rc >= 1} { pass $test } else { fail "$test ($rc)" } set test "STRUCT1" -set rc [stap_run_alternatives stap -vu -p2 -e $struct1_script] -if {$rc == 1} { pass $test } else { fail "$test ($rc)" } +set rc [stap_run_alternatives stap -u -p2 -e $struct1_script] +if {$rc >= 1} { pass $test } else { fail "$test ($rc)" } diff --git a/testsuite/systemtap.base/badkprobe.exp b/testsuite/systemtap.base/badkprobe.exp index efc06695..c0815fbe 100644 --- a/testsuite/systemtap.base/badkprobe.exp +++ b/testsuite/systemtap.base/badkprobe.exp @@ -1,14 +1,28 @@ -set script "probe kernel.statement(-1).absolute {} probe timer.s(1) { exit() }" set test "bad kprobe registration" +set script { + probe $1 {} + probe timer.s(1) { exit() } + probe end { println("cleanup ok") } +} if {! [installtest_p]} { untested $test; return } -spawn stap -g -w -e "$script" -expect { - -timeout 60 - -re "^WARNING: probe .*registration error.*" { pass $test } - eof { fail "$test (eof)" } - timeout { fail "$test (timeout)" } +set bad_kprobes { + kernel.statement(-1).absolute + kprobe.statement(-1).absolute + kprobe.function("no_such_function") + kprobe.function("no_such_function").return +} + +foreach bk $bad_kprobes { + set test "bad kprobe registration: $bk" + spawn stap -g -w -e "$script" "$bk" + expect { + -timeout 60 + -re "^WARNING: probe .*registration error.*\r\ncleanup ok" { pass $test } + eof { fail "$test (eof)" } + timeout { fail "$test (timeout)" } + } + catch {close} + catch {wait} } -catch {close} -catch {wait} 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() +} diff --git a/testsuite/systemtap.base/bz10078.c b/testsuite/systemtap.base/bz10078.c new file mode 100644 index 00000000..9075fbc7 --- /dev/null +++ b/testsuite/systemtap.base/bz10078.c @@ -0,0 +1,22 @@ +#include <stdlib.h> +#include <stdio.h> + +struct point { int x, y; }; + +struct point mkpoint2(void) +{ + struct point p = { 1, 2 }; + return p; +} + +struct point mkpoint1(void) +{ + return mkpoint2(); +} + +main() +{ + struct point p = mkpoint1(); + printf("%d,%d\n", p.x, p.y); + exit(0); +} diff --git a/testsuite/systemtap.base/bz10078.exp b/testsuite/systemtap.base/bz10078.exp new file mode 100644 index 00000000..cad3a3a8 --- /dev/null +++ b/testsuite/systemtap.base/bz10078.exp @@ -0,0 +1,35 @@ +set test bz10078 + +catch {exec gcc -g -o $test $srcdir/$subdir/$test.c} err +if {$err == "" && [file exists $test]} then { pass "$test compile" } else { fail "$test compile" } + +if {![utrace_p]} { + catch {exec rm -f $test} + untested "$test -p4" + untested "$test -p5" + return +} + +set rc [stap_run_batch $srcdir/$subdir/$test.stp] +if {$rc == 0} then { pass "$test -p4" } else { fail "$test -p4" } + +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] +spawn sudo $stapexe $srcdir/$subdir/$test.stp -c ./$test +set ok 0 +expect { + -timeout 60 + -re {mkpoint[^\r\n]* returns\r\n} { incr ok; exp_continue } + -re {1,2\r\n} { incr ok; exp_continue } + timeout { fail "$test (timeout)" } + eof { } +} +wait +if {$ok == 3} then { pass "$test -p5" } else { fail "$test -p5 ($ok)" } +exec rm -f $test diff --git a/testsuite/systemtap.base/bz10078.stp b/testsuite/systemtap.base/bz10078.stp new file mode 100755 index 00000000..0318e4e9 --- /dev/null +++ b/testsuite/systemtap.base/bz10078.stp @@ -0,0 +1,4 @@ +#! stap -p4 +probe process("./bz10078").function("mkpoint*").return { + printf("%s returns\n", probefunc()) +} diff --git a/testsuite/systemtap.base/bz5274.exp b/testsuite/systemtap.base/bz5274.exp index 92441e9e..2f76a43f 100755 --- a/testsuite/systemtap.base/bz5274.exp +++ b/testsuite/systemtap.base/bz5274.exp @@ -17,14 +17,7 @@ if {! [installtest_p]} { 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} { +if {![utrace_p]} { catch {exec rm -f $test} untested "$test -p5" return diff --git a/testsuite/systemtap.base/bz6850.exp b/testsuite/systemtap.base/bz6850.exp index b96ed95c..32ecdaf5 100644 --- a/testsuite/systemtap.base/bz6850.exp +++ b/testsuite/systemtap.base/bz6850.exp @@ -3,14 +3,7 @@ set test bz6850 catch {exec gcc -g -o bz6850 $srcdir/$subdir/bz6850.c} err if {$err == "" && [file exists bz6850]} then { pass "$test compile" } else { fail "$test compile" } -# 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} { +if {![utrace_p]} { catch {exec rm -f $test} untested "$test -p4" untested "$test -p5" diff --git a/testsuite/systemtap.base/cast.exp b/testsuite/systemtap.base/cast.exp index df3246e8..374132f0 100644 --- a/testsuite/systemtap.base/cast.exp +++ b/testsuite/systemtap.base/cast.exp @@ -1,4 +1,6 @@ set test "cast" set ::result_string {PID OK -execname OK} -stap_run2 $srcdir/$subdir/$test.stp +PID2 OK +execname OK +sa_data OK} +stap_run2 $srcdir/$subdir/$test.stp -g diff --git a/testsuite/systemtap.base/cast.stp b/testsuite/systemtap.base/cast.stp index bec0cc9b..e2505000 100644 --- a/testsuite/systemtap.base/cast.stp +++ b/testsuite/systemtap.base/cast.stp @@ -10,6 +10,13 @@ probe begin else printf("PID %d != %d\n", pid, cast_pid) + // Compare PIDs using a generated kernel module + cast_pid = @cast(curr, "task_struct", "kernel<linux/sched.h>")->tgid + if (pid == cast_pid) + println("PID2 OK") + else + printf("PID2 %d != %d\n", pid, cast_pid) + // Compare execnames name = execname() cast_name = kernel_string(@cast(curr, "task_struct")->comm) @@ -18,5 +25,23 @@ probe begin else printf("execname \"%s\" != \"%s\"\n", name, cast_name) + // Compare sa_data using a generated user module + data = 42 + cast_data = @cast(get_sockaddr(data), "sockaddr", "<sys/socket.h>")->sa_data[0] + if (data == cast_data) + println("sa_data OK") + else + printf("sa_data %d != %d\n", data, cast_data) + exit() } + +%{ +#include <linux/socket.h> +%} + +function get_sockaddr:long(data:long) %{ + static struct sockaddr sa = {0}; + sa.sa_data[0] = THIS->data; + THIS->__retvalue = (long)&sa; +%} diff --git a/testsuite/systemtap.base/flightrec1.exp b/testsuite/systemtap.base/flightrec1.exp new file mode 100644 index 00000000..c32a77f2 --- /dev/null +++ b/testsuite/systemtap.base/flightrec1.exp @@ -0,0 +1,43 @@ +set test "flightrec1" +if {![installtest_p]} { untested $test; return } + +# run stapio in background mode +spawn stap -F -o $test.out -we {probe begin {}} +# check whether stap outputs stapio pid +set pid 0 +expect { + -timeout 240 + -re {([0-9]+)\r\n} { + pass "$test (flight recorder option)" + set pid $expect_out(1,string) + exp_continue} + timeout { fail "$test (timeout)" } + eof { } +} +wait +if {$pid == 0} { + fail "$test (no pid)" + return -1 +} + +# check whether stapio is running in background +spawn ps -o cmd hc $pid +expect { + -timeout 10 + "stapio" {pass "$test (stapio in background)"} # don't contine + timeout { fail "$test (timeout)"} + eof { fail "$test (stapio was not found)" } +} +wait + +exec kill -TERM $pid + +# check output file +if {[catch {exec rm $test.out}]} { + fail "$test (no output file)" + return -1 +} else { + pass "$test (output file)" +} + + diff --git a/testsuite/systemtap.base/flightrec2.exp b/testsuite/systemtap.base/flightrec2.exp new file mode 100644 index 00000000..d4481db4 --- /dev/null +++ b/testsuite/systemtap.base/flightrec2.exp @@ -0,0 +1,68 @@ +set test "flightrec2" +if {![installtest_p]} { untested $test; return } + +# cleanup +system "rm -f flightlog.out*" + +set pid 0 +# check -S option +spawn stap -F -o flightlog.out -S 1,3 $srcdir/$subdir/$test.stp +expect { + -timeout 240 + -re {([0-9]+)\r\n} { + pass "$test (-S option)" + set pid $expect_out(1,string) + exp_continue} + timeout { fail "$test (timeout)"} + eof { } +} +wait +if {$pid == 0} { + fail "$test (no pid)" + return -1 +} + +exec sleep 4 +set scnt 0 +set cnt1 0 +# wait for log files +eval spawn stat -c %s [glob flightlog.out.*] +expect { + -timeout 100 + -re {[0-9]+} { + incr cnt1; + if {$expect_out(buffer) <= 1048576 } {incr scnt} + exp_continue} + timeout { fail "$test (logfile timeout)"} +} +wait +exec sleep 3 +set cnt2 0 +# wait for log files +eval spawn stat -c %s [glob flightlog.out.*] +expect { + -timeout 100 + -re {[0-9]+} { + incr cnt2; + if {$expect_out(buffer) <= 1048576 } {incr scnt} + exp_continue} + timeout { fail "$test (logfile timeout)"} +} +wait +# check logfile number +if {$cnt1 == 3 && $cnt2 == 3} { + pass "$test (log file numbers limitation)" +} else { + fail "$test (log file numbers ($cnt1, $cnt2))" +} +# check logfile size +if {$scnt == $cnt1 + $cnt2 } { + pass "$test (log file size limitation)" +} else { + fail "$test (log file size ($scnt != $cnt1 + $cnt2))" +} +exec kill -TERM $pid +# wait for exiting... +exec sleep 1 +system "rm -f flightlog.out*" + diff --git a/testsuite/systemtap.base/flightrec2.stp b/testsuite/systemtap.base/flightrec2.stp new file mode 100644 index 00000000..f42c9b8e --- /dev/null +++ b/testsuite/systemtap.base/flightrec2.stp @@ -0,0 +1,5 @@ +probe timer.ms(10) +{ + for (j = 0; j < 1000; j++) + printf("1234567890\n") +} diff --git a/testsuite/systemtap.base/flightrec3.exp b/testsuite/systemtap.base/flightrec3.exp new file mode 100644 index 00000000..5b9d8253 --- /dev/null +++ b/testsuite/systemtap.base/flightrec3.exp @@ -0,0 +1,79 @@ +set test "flightrec3" +if {![installtest_p]} { untested $test; return } + +# cleanup +system "rm -f flightlog.out*" + +set pid 0 +# check -S option with bulk(percpu file) mode +spawn stap -F -o flightlog.out -S 1,3 -b $srcdir/$subdir/$test.stp +expect { + -timeout 240 + -re {([0-9]+)\r\n} { + pass "$test (-S option with bulk mode)" + set pid $expect_out(1,string) + exp_continue} + timeout { fail "$test (timeout)"} + eof { } +} +wait +if {$pid == 0} { + fail "$test (no pid)" + return -1 +} + +exec sleep 4 +array set cpus {} +set scnt 0 +# wait for log files +exec kill -STOP $pid +exec sleep 1 +eval spawn stat -c \"%n %s\" [glob flightlog.out_cpu*] +expect { + -timeout 100 + -re {flightlog.out_cpu([0-9]+).[0-9]+ ([0-9]+)\r\n} { + set cpuid $expect_out(1,string) + set size $expect_out(2,string) + if {[array get cpus $cpuid] == ""} {set cpus($cpuid) 0} + incr cpus($cpuid); + if {$size <= 1048576 } {incr scnt} + exp_continue} + timeout { fail "$test (logfile timeout)"} +} +wait +exec kill -CONT $pid +exec sleep 3 +exec kill -STOP $pid +eval spawn stat -c \"%n %s\" [glob flightlog.out_cpu*] +expect { + -timeout 100 + -re {flightlog.out_cpu([0-9]+).[0-9]+ ([0-9]+)\r\n} { + set cpuid $expect_out(1,string) + set size $expect_out(2,string) + if {[array get cpus $cpuid] == ""} {set cpus($cpuid) 0} + incr cpus($cpuid); + if {$size <= 1048576 } {incr scnt} + exp_continue} + timeout { fail "$test (logfile timeout)"} +} +wait +exec kill -CONT $pid +# check logfile number +set cnt 0 +foreach e [array names cpus] { + if {$cpus($e) != 6} { + fail "$test (log file numbers cpu:$e, cnt:$cpus($e)))" + } + set cnt [expr $cnt + $cpus($e)] +} +# check logfile size +if {$scnt == $cnt} { + pass "$test (log file size limitation with bulk mode)" +} else { + fail "$test (log file size ($scnt != $cnt))" +} +exec kill -TERM $pid +# wait for exiting... +exec sleep 1 +system "rm -f flightlog.out*" + diff --git a/testsuite/systemtap.base/flightrec3.stp b/testsuite/systemtap.base/flightrec3.stp new file mode 100644 index 00000000..d660793f --- /dev/null +++ b/testsuite/systemtap.base/flightrec3.stp @@ -0,0 +1,5 @@ +probe kernel.function("update_process_times") +{ + for (j = 0; j < 100; j++) + printf("1234567890\n") +} diff --git a/testsuite/systemtap.base/itrace.exp b/testsuite/systemtap.base/itrace.exp index f19af977..5da0dfaf 100644 --- a/testsuite/systemtap.base/itrace.exp +++ b/testsuite/systemtap.base/itrace.exp @@ -1,17 +1,13 @@ # itrace test -# temporarily disabled -return - # Initialize variables -set utrace_support_found 0 set exepath "[pwd]/ls_[pid]" set itrace1_script { global instrs = 0 probe begin { printf("systemtap starting probe\n") } - probe process("%s").itrace + probe process("%s").insn { instrs += 1 if (instrs == 5) @@ -28,7 +24,7 @@ set itrace1_script_output "itraced = 5\r\n" set itrace2_script { global instrs = 0, itrace_on = 0, start_timer = 0 probe begin { start_timer = 1; printf("systemtap starting probe\n") } - probe process("%s").itrace if (itrace_on) + probe process("%s").insn if (itrace_on) { instrs += 1 if (instrs == 5) @@ -51,6 +47,26 @@ set itrace2_script { } set itrace2_script_output "itraced = 5\r\n" +set itrace3_script { + global branches = 0 + probe begin + { + printf("systemtap starting probe\n") + } + probe process("%s").insn.block + { + branches += 1 + if (branches == 5) + exit() + } + + + probe end { printf("systemtap ending probe\n") + printf("itraced block mode = %%d\n", branches) + } +} +set itrace3_script_output "itraced block mode = 5\r\n" + # Set up our own copy of /bin/ls, to make testing for a particular # executable easy. We can't use 'ln' here, since we might be creating @@ -75,14 +91,8 @@ proc run_ls_5_sec {} { } -# Try to find utrace_attach symbol in /proc/kallsyms -set path "/proc/kallsyms" -if {! [catch {exec grep -q utrace_attach $path} dummy]} { - set utrace_support_found 1 -} - set TEST_NAME "itrace1" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } elseif {![installtest_p]} { untested $TEST_NAME @@ -93,7 +103,7 @@ if {$utrace_support_found == 0} { set TEST_NAME "itrace2" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } elseif {![installtest_p]} { untested $TEST_NAME @@ -102,5 +112,16 @@ if {$utrace_support_found == 0} { stap_run $TEST_NAME run_ls_5_sec $itrace2_script_output -e $script } +set TEST_NAME "itrace3" +if {![utrace_p]} { + untested "$TEST_NAME : no kernel utrace support found" +} elseif {![installtest_p]} { + untested $TEST_NAME +} else { + send_log "ATTENTION: if arch_has_block_step is not defined for this arch, this testcase will fail\n" + set script [format $itrace3_script $exepath] + stap_run $TEST_NAME run_ls_5_sec $itrace3_script_output -e $script +} + # Cleanup exec rm -f $exepath diff --git a/testsuite/systemtap.base/kprobes.exp b/testsuite/systemtap.base/kprobes.exp new file mode 100644 index 00000000..635930f8 --- /dev/null +++ b/testsuite/systemtap.base/kprobes.exp @@ -0,0 +1,2 @@ +set test "kprobes" +stap_run $srcdir/$subdir/$test.stp no_load "probe point hit" diff --git a/testsuite/systemtap.base/kprobes.stp b/testsuite/systemtap.base/kprobes.stp new file mode 100644 index 00000000..884b321c --- /dev/null +++ b/testsuite/systemtap.base/kprobes.stp @@ -0,0 +1,25 @@ +/* + * kprobes.stp + * Probe to test the functionality of kprobe-based probes + * (Dwarfless Probing) + */ +global hit_str + +probe begin +{ + println("systemtap starting probe"); + hit_str = "" +} + +probe kprobe.function("vfs_read") +{ + hit_str = "probe point hit" + exit(); +} + +probe end +{ + println("systemtap ending probe"); + println(hit_str); + delete hit_str; +} diff --git a/testsuite/systemtap.base/labels.exp b/testsuite/systemtap.base/labels.exp index 6db81c54..79e3f483 100644 --- a/testsuite/systemtap.base/labels.exp +++ b/testsuite/systemtap.base/labels.exp @@ -1,14 +1,6 @@ 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 } +if {![utrace_p]} { untested $test; return } # Compile a C program to use as the user-space probing target set label_srcpath "[pwd]/labels.c" @@ -18,15 +10,22 @@ 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; init_an_int: a = 2; -init_another_int: +init_an_int_again: b = 3; c = \"abc\"; ptr_inited: @@ -38,8 +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_*\") {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,20 +55,66 @@ if { $res != "" } { pass "compiling labels.c -g" } +# line number error + +set ok 0 +spawn stap -l "process(\"$label_exepath\").function(\"foo@${label_srcpath}:10\").label(\"*\")" + +wait +expect { + -timeout 180 + -re {no match while resolving probe point} { incr ok; exp_continue } + timeout { fail "$test (timeout)" } + eof { } +} + +if {$ok == 1} { pass "$test :N .label" } { fail "$test :N .label $ok" } + +# line number + +set ok 0 +spawn stap -l "process(\"$label_exepath\").function(\"foo@${label_srcpath}:4\").label(\"*\")" + +wait +expect { + -timeout 180 + -re {process.*function.*labels.c:5...label..init_an_int} { incr ok; exp_continue } + timeout { fail "$test (timeout)" } + eof { } +} + +if {$ok == 1} { pass "$test :N .label" } { fail "$test :N .label $ok" } + +# list of labels + +spawn stap -l "process(\"$label_exepath\").function(\"*\").label(\"*\")" + +wait +set ok 0 +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 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 @@ -76,7 +122,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;}} \" " @@ -111,7 +157,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 } @@ -119,7 +165,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 @@ -127,7 +173,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;}} \" " diff --git a/testsuite/systemtap.base/maxactive.exp b/testsuite/systemtap.base/maxactive.exp index 7c03a1bf..79ede897 100644 --- a/testsuite/systemtap.base/maxactive.exp +++ b/testsuite/systemtap.base/maxactive.exp @@ -10,12 +10,12 @@ proc sleep_five_sec {} { return 0; } -# Script1. For 5 seconds, probe the return of "sys_select" and -# "sys_read". See if we skip any probes. +# Script1. For 5 seconds, probe the return of "vfs_read" and +# "do_select". See if we skip any probes. set script1 { global foo - probe kernel.function("sys_select").return, - kernel.function("sys_read").return { foo++ } + probe kernel.function("vfs_read").return, + kernel.function("do_select").return { foo++ } probe timer.ms(5000) { exit(); } probe begin { log("systemtap starting probe"); log("systemtap ending probe");} @@ -26,13 +26,13 @@ set script1 { stap_run "MAXACTIVE01" sleep_five_sec "" -e $script1 set skipped1 $skipped_probes -# Script2. For 5 seconds, probe the return of "sys_select" and -# "sys_read", with a limit of 1 probe active at a time. See if we +# Script2. For 5 seconds, probe the return of "vfs_read" and +# "do_select", with a limit of 1 probe active at a time. See if we # skip any probes. set script2 { global foo - probe kernel.function("sys_select").return.maxactive(1), - kernel.function("sys_read").return.maxactive(1) { foo++ } + probe kernel.function("vfs_read").return.maxactive(1), + kernel.function("do_select").return.maxactive(1) { foo++ } probe timer.ms(5000) { exit(); } probe begin { log("systemtap starting probe"); log("systemtap ending probe");} diff --git a/testsuite/systemtap.base/onoffprobe.stp b/testsuite/systemtap.base/onoffprobe.stp index f7169039..79c41a3c 100644 --- a/testsuite/systemtap.base/onoffprobe.stp +++ b/testsuite/systemtap.base/onoffprobe.stp @@ -10,13 +10,13 @@ probe begin if (switch==0) { } #dwarf probe (return) -probe kernel.function("sys_write").return if (switch == 1) { +probe kernel.function("vfs_write").return if (switch == 1) { log("function return probed") switch = 0 } #dwarf probe (entry) -probe kernel.function("sys_write") if (switch == 2) { +probe kernel.function("vfs_write").return if (switch == 2) { log("function entry probed") switch = 0 } diff --git a/testsuite/systemtap.base/optionalprobe.exp b/testsuite/systemtap.base/optionalprobe.exp new file mode 100644 index 00000000..5484003c --- /dev/null +++ b/testsuite/systemtap.base/optionalprobe.exp @@ -0,0 +1,9 @@ +set test "optionalprobe" +spawn stap -p2 -w $srcdir/$subdir/$test.stp +expect { + -timeout 60 + -re "# probes\r\n" { exp_continue } + -re "^begin" { pass $test } + eof { fail $test } + timeout { fail "$test unexpected timeout" } +} diff --git a/testsuite/systemtap.base/optionalprobe.stp b/testsuite/systemtap.base/optionalprobe.stp new file mode 100644 index 00000000..13918cee --- /dev/null +++ b/testsuite/systemtap.base/optionalprobe.stp @@ -0,0 +1,14 @@ +#! stap + +# test optional probe + +probe foo ?, + process("/do/not/exist").function("main") !, + kernel.mark("no such mark") ?, + kernel.trace("no trace") !, + process.foo ?, + kernel.statement("no statement") !, + module("no mod").function("*") ?, + kernel.function("no such func*") !, + begin { +} diff --git a/testsuite/systemtap.base/overload.exp b/testsuite/systemtap.base/overload.exp index cbcbe817..ac9ceb24 100644 --- a/testsuite/systemtap.base/overload.exp +++ b/testsuite/systemtap.base/overload.exp @@ -8,7 +8,7 @@ set script { k["foo"] = 0 } - probe kernel.function("sys_read"), kernel.function("sys_write") { + probe kernel.function("vfs_read"), kernel.function("vfs_write") { k["foo"]++ } probe end { diff --git a/testsuite/systemtap.base/sdt.exp b/testsuite/systemtap.base/sdt.exp index 74818beb..c3aed91e 100644 --- a/testsuite/systemtap.base/sdt.exp +++ b/testsuite/systemtap.base/sdt.exp @@ -10,11 +10,12 @@ set ::result_string {1 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 10} -set extra_flags {{""} {additional_flags=-std=gnu89} {additional_flags=-ansi} {additional_flags=-pedantic}} +set extra_flags {{""} {additional_flags=-std=gnu89} {additional_flags=-ansi} {additional_flags=-pedantic} {additional_flags=-ansi additional_flags=-pedantic} {additional_flags=-O2} {additional_flags="-O3"}} # Iterate extra_flags, trying each with C and C++ for {set i 0} {$i < [llength $extra_flags]} {incr i} { set extra_flag [lindex $extra_flags $i] +set testprog "sdt.c.exe.$i" # C set test_flags "additional_flags=-g" @@ -23,44 +24,47 @@ set test_flags "$test_flags additional_flags=-Wall" set test_flags "$test_flags additional_flags=-Wextra" set test_flags "$test_flags additional_flags=-Werror" -set res [target_compile $srcdir/$subdir/$test.c $test.prog executable "$test_flags $extra_flag"] +set saveidx 0 + +set res [target_compile $srcdir/$subdir/$test.c $testprog executable "$test_flags $extra_flag"] if { $res != "" } { verbose "target_compile failed: $res" 2 fail "compiling $test.c $extra_flag" - return + untested "$test $extra_flag" + continue } else { pass "compiling $test.c $extra_flag" } -if {[installtest_p]} { -# XXX: we need distinct test names for these - stap_run2 $srcdir/$subdir/$test.stp -c ./$test.prog +if {[installtest_p] && [utrace_p]} { + stap_run3 "$test $extra_flag" $srcdir/$subdir/$test.stp $testprog -c ./$testprog } else { untested "$test $extra_flag" } # C++ +set testprog "sdt.cxx.exe.$i" + set test_flags "additional_flags=-g" set test_flags "$test_flags additional_flags=-I$srcdir/../includes/sys" set test_flags "$test_flags additional_flags=-Wall" set test_flags "$test_flags additional_flags=-Werror" set test_flags "$test_flags additional_flags=-x additional_flags=c++" -set res [target_compile $srcdir/$subdir/$test.c $test.prog executable "$test_flags $extra_flag"] +set res [target_compile $srcdir/$subdir/$test.c $testprog executable "$test_flags $extra_flag"] if { $res != "" } { verbose "target_compile failed: $res" 2 fail "compiling $test.c c++ $extra_flag" - return + untested "$test $extra_flag" + continue } else { pass "compiling $test.c c++ $extra_flag" } -if {[installtest_p]} { -# XXX: we need distinct test names for these - stap_run2 $srcdir/$subdir/$test.stp -c ./$test.prog +if {[installtest_p] && [utrace_p]} { + stap_run3 "$test c++ $extra_flag" $srcdir/$subdir/$test.stp $testprog -c ./$testprog } else { untested "$test c++ $extra_flag" } } -catch {exec rm -f $test.prog} diff --git a/testsuite/systemtap.base/sdt.stp b/testsuite/systemtap.base/sdt.stp index 1f075bca..5df1fdc9 100644 --- a/testsuite/systemtap.base/sdt.stp +++ b/testsuite/systemtap.base/sdt.stp @@ -1,49 +1,49 @@ -probe process("sdt.prog").mark("mark_a") +probe process(@1).mark("mark_a") { printf("%d\n", $arg1); } -probe process("sdt.prog").mark("mark_b") +probe process(@1).mark("mark_b") { printf("%d %d\n", $arg1, $arg2); } -probe process("sdt.prog").mark("mark_c") +probe process(@1).mark("mark_c") { printf("%d %d %d\n", $arg1, $arg2, $arg3); } -probe process("sdt.prog").mark("mark_d") +probe process(@1).mark("mark_d") { printf("%d %d %d %d\n", $arg1, $arg2, $arg3, $arg4); } -probe process("sdt.prog").mark("mark_e") +probe process(@1).mark("mark_e") { printf("%d %d %d %d %d\n", $arg1, $arg2, $arg3, $arg4, $arg5); } -probe process("sdt.prog").mark("mark_f") +probe process(@1).mark("mark_f") { printf("%d %d %d %d %d %d\n", $arg1, $arg2, $arg3, $arg4, $arg5, $arg6); } -probe process("sdt.prog").mark("mark_g") +probe process(@1).mark("mark_g") { printf("%d %d %d %d %d %d %d\n", $arg1, $arg2, $arg3, $arg4, $arg5, $arg6, $arg7); } -probe process("sdt.prog").mark("mark_h") +probe process(@1).mark("mark_h") { printf("%d %d %d %d %d %d %d %d\n", $arg1, $arg2, $arg3, $arg4, $arg5, $arg6, $arg7, $arg8); } -probe process("sdt.prog").mark("mark_i") +probe process(@1).mark("mark_i") { printf("%d %d %d %d %d %d %d %d %d\n", $arg1, $arg2, $arg3, $arg4, $arg5, $arg6, $arg7, $arg8, $arg9); } -probe process("sdt.prog").mark("mark_j") +probe process(@1).mark("mark_j") { printf("%d %d %d %d %d %d %d %d %d %d\n", $arg1, $arg2, $arg3, $arg4, $arg5, $arg6, $arg7, $arg8, $arg9, $arg10); } diff --git a/testsuite/systemtap.base/sdt_types.c b/testsuite/systemtap.base/sdt_types.c new file mode 100644 index 00000000..2e04ec7e --- /dev/null +++ b/testsuite/systemtap.base/sdt_types.c @@ -0,0 +1,168 @@ +#include "sdt.h" /* Really <sys/sdt.h>, but pick current source version. */ +#include <stdint.h> +#include <values.h> + +int +main (int argc, char **argv) +{ + char char_var = '~'; + STAP_PROBE1(provider,char_var,char_var); + const char const_char_var = '!'; + STAP_PROBE1(provider,const_char_var,const_char_var); + volatile char volatile_char_var = '!'; + STAP_PROBE1(provider,volatile_char_var,volatile_char_var); + char *ptr_char_var = &char_var; + STAP_PROBE2(provider,ptr_char_var,ptr_char_var,&char_var); + const char *ptr_const_char_var = &char_var; + STAP_PROBE2(provider,ptr_const_char_var,ptr_const_char_var,&char_var); + char * const char_ptr_const_var = &char_var; + STAP_PROBE2(provider,char_ptr_const_var,char_ptr_const_var,&char_var); + volatile char *ptr_volatile_char_var = &char_var; + STAP_PROBE2(provider,ptr_volatile_char_var,ptr_volatile_char_var,&char_var); + char * volatile char_ptr_volatile_var = &char_var; + STAP_PROBE2(provider,char_ptr_volatile_var,char_ptr_volatile_var,&char_var); + short int short_int_var = 32767; + STAP_PROBE1(provider,short_int_var,short_int_var); + const short int const_short_int_var = -32767; + STAP_PROBE1(provider,const_short_int_var,const_short_int_var); + volatile short int volatile_short_int_var = -32767; + STAP_PROBE1(provider,volatile_short_int_var,volatile_short_int_var); + short int *ptr_short_int_var = &short_int_var; + STAP_PROBE2(provider,ptr_short_int_var,ptr_short_int_var,&short_int_var); + const short int *ptr_const_short_int_var = &short_int_var; + STAP_PROBE2(provider,ptr_const_short_int_var,ptr_const_short_int_var,&short_int_var); + short int * const short_int_ptr_const_var = &short_int_var; + STAP_PROBE2(provider,short_int_ptr_const_var,short_int_ptr_const_var,&short_int_var); + volatile short int *ptr_volatile_short_int_var = &short_int_var; + STAP_PROBE2(provider,ptr_volatile_short_int_var,ptr_volatile_short_int_var,&short_int_var); + short int * volatile short_int_ptr_volatile_var = &short_int_var; + STAP_PROBE2(provider,short_int_ptr_volatile_var,short_int_ptr_volatile_var,&short_int_var); + int int_var = 65536; + STAP_PROBE1(provider,int_var,int_var); + const int const_int_var = -65536; + STAP_PROBE1(provider,const_int_var,const_int_var); + volatile int volatile_int_var = -65536; + STAP_PROBE1(provider,volatile_int_var,volatile_int_var); + int *ptr_int_var = &int_var; + STAP_PROBE2(provider,ptr_int_var,ptr_int_var,&int_var); + const int *ptr_const_int_var = &int_var; + STAP_PROBE2(provider,ptr_const_int_var,ptr_const_int_var,&int_var); + int * const int_ptr_const_var = &int_var; + STAP_PROBE2(provider,int_ptr_const_var,int_ptr_const_var,&int_var); + volatile int *ptr_volatile_int_var = &int_var; + STAP_PROBE2(provider,ptr_volatile_int_var,ptr_volatile_int_var,&int_var); + int * volatile int_ptr_volatile_var = &int_var; + STAP_PROBE2(provider,int_ptr_volatile_var,int_ptr_volatile_var,&int_var); + long int long_int_var = 65536; + STAP_PROBE1(provider,long_int_var,long_int_var); + const long int const_long_int_var = -65536; + STAP_PROBE1(provider,const_long_int_var,const_long_int_var); + volatile long int volatile_long_int_var = -65536; + STAP_PROBE1(provider,volatile_long_int_var,volatile_long_int_var); + long int *ptr_long_int_var = &long_int_var; + STAP_PROBE2(provider,ptr_long_int_var,ptr_long_int_var,&long_int_var); + const long int *ptr_const_long_int_var = &long_int_var; + STAP_PROBE2(provider,ptr_const_long_int_var,ptr_const_long_int_var,&long_int_var); + long int * const long_int_ptr_const_var = &long_int_var; + STAP_PROBE2(provider,long_int_ptr_const_var,long_int_ptr_const_var,&long_int_var); + volatile long int *ptr_volatile_long_int_var = &long_int_var; + STAP_PROBE2(provider,ptr_volatile_long_int_var,ptr_volatile_long_int_var,&long_int_var); + long int * volatile long_int_ptr_volatile_var = &long_int_var; + STAP_PROBE2(provider,long_int_ptr_volatile_var,long_int_ptr_volatile_var,&long_int_var); + long long int long_long_int_var = 65536; + STAP_PROBE1(provider,long_long_int_var,long_long_int_var); + const long long int const_long_long_int_var = -65536; + STAP_PROBE1(provider,const_long_long_int_var,const_long_long_int_var); + volatile long long int volatile_long_long_int_var = -65536; + STAP_PROBE1(provider,volatile_long_long_int_var,volatile_long_long_int_var); + long long int *ptr_long_long_int_var = &long_long_int_var; + STAP_PROBE2(provider,ptr_long_long_int_var,ptr_long_long_int_var,&long_long_int_var); + const long long int *ptr_const_long_long_int_var = &long_long_int_var; + STAP_PROBE2(provider,ptr_const_long_long_int_var,ptr_const_long_long_int_var,&long_long_int_var); + long long int * const long_long_int_ptr_const_var = &long_long_int_var; + STAP_PROBE2(provider,long_long_int_ptr_const_var,long_long_int_ptr_const_var,&long_long_int_var); + volatile long long int *ptr_volatile_long_long_int_var = &long_long_int_var; + STAP_PROBE2(provider,ptr_volatile_long_long_int_var,ptr_volatile_long_long_int_var,&long_long_int_var); + long long int * volatile long_long_int_ptr_volatile_var = &long_long_int_var; + STAP_PROBE2(provider,long_long_int_ptr_volatile_var,long_long_int_ptr_volatile_var,&long_long_int_var); + + char arr_char [2] = "!~"; + STAP_PROBE1(provider,arr_char,&arr_char); + struct { + int int_var; + } arr_struct [2] = {{ + .int_var=1, + },{ + .int_var=2, + }}; + STAP_PROBE1(provider,arr_struct,&arr_struct); + struct { + unsigned int bit1_0:1; + unsigned int bit1_1:1; + char char_2; + unsigned int bit1_6:1; + unsigned int bit1_7:1; + char char_8; + unsigned int bit1_9:1; + unsigned int bit1_10:1; + } bitfields_small_var = { + .bit1_0=1, + .bit1_1=0, + .char_2='a', + .bit1_6=1, + .bit1_7=0, + .char_8='z', + .bit1_9=1, + .bit1_10=0, + }; + STAP_PROBE8(provider,bitfields_small_var, + (int)bitfields_small_var.bit1_0, + (int)bitfields_small_var.bit1_1, + bitfields_small_var.char_2, + (int)bitfields_small_var.bit1_6, + (int)bitfields_small_var.bit1_7, + bitfields_small_var.char_8, + (int)bitfields_small_var.bit1_9, + (int)bitfields_small_var.bit1_10); + struct { + unsigned char char_0; + int bit1_4:1; + unsigned int bit1_5:1; + int bit2_6:2; + unsigned int bit2_8:2; + int bit3_10:3; + unsigned int bit3_13:3; + int bit9_16:9; + unsigned int bit9_25:9; + char char_34; + } bitfields_bit_var = { + .char_0='A', + .bit1_4=-1, + .bit1_5=1, + .bit2_6=1, + .bit2_8=3, + .bit3_10=3, + .bit3_13=7, + .bit9_16=255, + .bit9_25=511, + .char_34='Z', + }; + STAP_PROBE10(provider,bitfields_bit_var,bitfields_bit_var.char_0, + (int)bitfields_bit_var.bit1_4, + (int)bitfields_bit_var.bit1_5, + (int)bitfields_bit_var.bit2_6, + (int)bitfields_bit_var.bit2_8, + (int)bitfields_bit_var.bit3_10, + (int)bitfields_bit_var.bit3_13, + (int)bitfields_bit_var.bit9_16, + (int)bitfields_bit_var.bit9_25, + bitfields_bit_var.char_34); + enum { + red = 0, + green = 1, + blue = 2 + } primary_colors_var = green; + STAP_PROBE1(provider,primary_colors_var,primary_colors_var); + return 0; +} + diff --git a/testsuite/systemtap.base/sdt_types.stp b/testsuite/systemtap.base/sdt_types.stp new file mode 100644 index 00000000..654b0d18 --- /dev/null +++ b/testsuite/systemtap.base/sdt_types.stp @@ -0,0 +1,371 @@ +probe process(@1).mark("char_var") { + if ($arg1 != 126) + printf("FAIL: char_var\n") + else + printf("PASS: char_var\n") +} + +probe process(@1).mark("const_char_var") { + if ($arg1 != 33) + printf("FAIL: const_char_var\n") + else + printf("PASS: const_char_var\n") +} + +probe process(@1).mark("volatile_char_var") { + if ($arg1 != 33) + printf("FAIL: volatile_char_var\n") + else + printf("PASS: volatile_char_var\n") +} + +probe process(@1).mark("ptr_char_var") { + if ($arg1 != $arg2) + printf("FAIL: ptr_char_var\n") + else + printf("PASS: ptr_char_var\n") +} + +probe process(@1).mark("ptr_const_char_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_const_char_var\n") + else + printf("PASS: ptr_const_char_var\n") +} + +probe process(@1).mark("char_ptr_const_var") +{ + if ($arg1 != $arg2) + printf("FAIL: char_ptr_const_var\n") + else + printf("PASS: char_ptr_const_var\n") +} + +probe process(@1).mark("ptr_volatile_char_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_volatile_char_var\n") + else + printf("PASS: ptr_volatile_char_var\n") +} + +probe process(@1).mark("char_ptr_volatile_var") +{ + if ($arg1 != $arg2) + printf("FAIL: char_ptr_volatile_var\n") + else + printf("PASS: char_ptr_volatile_var\n") +} + +probe process(@1).mark("short_int_var") +{ + if ($arg1 != 32767) + printf("FAIL: short_int_var\n") + else + printf("PASS: short_int_var\n") +} + +probe process(@1).mark("const_short_int_var") +{ + if ($arg1 != -32767) + printf("FAIL: const_short_int_var\n") + else + printf("PASS: const_short_int_var\n") +} + +probe process(@1).mark("volatile_short_int_var") +{ + if ($arg1 != -32767) + printf("FAIL: volatile_short_int_var\n") + else + printf("PASS: volatile_short_int_var\n") +} + +probe process(@1).mark("ptr_short_int_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_short_int_var\n") + else + printf("PASS: ptr_short_int_var\n") +} + +probe process(@1).mark("ptr_const_short_int_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_const_short_int_var\n") + else + printf("PASS: ptr_const_short_int_var\n") +} + +probe process(@1).mark("short_int_ptr_const_var") +{ + if ($arg1 != $arg2) + printf("FAIL: short_int_ptr_const_var\n") + else + printf("PASS: short_int_ptr_const_var\n") +} + +probe process(@1).mark("ptr_volatile_short_int_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_volatile_short_int_var\n") + else + printf("PASS: ptr_volatile_short_int_var\n") +} + +probe process(@1).mark("short_int_ptr_volatile_var") +{ + if ($arg1 != $arg2) + printf("FAIL: short_int_ptr_volatile_var\n") + else + printf("PASS: short_int_ptr_volatile_var\n") +} + +probe process(@1).mark("int_var") +{ + if ($arg1 != 65536) + printf("FAIL: int_var") + else + printf("PASS: int_var") +} + +probe process(@1).mark("const_int_var") +{ + if ($arg1 != -65536) + printf("FAIL: const_int_var\n") + else + printf("PASS: const_int_var\n") +} + +probe process(@1).mark("volatile_int_var") +{ + if ($arg1 != -65536) + printf("FAIL: volatile_int_var\n") + else + printf("PASS: volatile_int_var\n") +} + +probe process(@1).mark("ptr_int_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_const_int_var\n") + else + printf("PASS: ptr_const_int_var\n") +} + +probe process(@1).mark("ptr_const_int_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_const_int_var\n") + else + printf("PASS: ptr_const_int_var\n") +} + +probe process(@1).mark("int_ptr_const_var") +{ + if ($arg1 != $arg2) + printf("FAIL: int_ptr_const_var\n") + else + printf("PASS: int_ptr_const_var\n") +} + +probe process(@1).mark("ptr_volatile_int_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_volatile_int_var\n") + else + printf("PASS: ptr_volatile_int_var\n") +} + +probe process(@1).mark("int_ptr_volatile_var") +{ + if ($arg1 != $arg2) + printf("FAIL: int_ptr_volatile_var\n") + else + printf("PASS: int_ptr_volatile_var\n") +} + +probe process(@1).mark("long_int_var") +{ + if ($arg1 != 65536) + printf("FAIL: long_int_var\n") + else + printf("PASS: long_int_var\n") +} + +probe process(@1).mark("const_long_int_var") +{ + if ($arg1 != -65536) + printf("FAIL: const_long_int_var\n") + else + printf("PASS: const_long_int_var\n") +} + +probe process(@1).mark("volatile_long_int_var") +{ + if ($arg1 != -65536) + printf("FAIL: volatile_long_int_var\n") + else + printf("PASS: volatile_long_int_var\n") +} + +probe process(@1).mark("ptr_long_int_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_long_int_var\n") + else + printf("PASS: ptr_long_int_var\n") +} + +probe process(@1).mark("ptr_const_long_int_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_const_long_int_var\n") + else + printf("PASS: ptr_const_long_int_var\n") +} + +probe process(@1).mark("long_int_ptr_const_var") +{ + if ($arg1 != $arg2) + printf("FAIL: long_int_ptr_const_var\n") + else + printf("PASS: long_int_ptr_const_var\n") +} + +probe process(@1).mark("ptr_volatile_long_int_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_volatile_long_int_var\n") + else + printf("PASS: ptr_volatile_long_int_var\n") +} + +probe process(@1).mark("long_int_ptr_volatile_var") +{ + if ($arg1 != $arg2) + printf("FAIL: long_int_ptr_volatile_var\n") + else + printf("PASS: long_int_ptr_volatile_var\n") +} + +probe process(@1).mark("long_long_int_var") +{ + if ($arg1 != 65536) + printf("FAIL: long_long_int_var\n") + else + printf("PASS: long_long_int_var\n") +} + +probe process(@1).mark("const_long_long_int_var") +{ + if ($arg1 != -65536) + printf("FAIL: const_long_long_int_var\n") + else + printf("PASS: const_long_long_int_var\n") +} + +probe process(@1).mark("volatile_long_long_int_var") +{ + if ($arg1 != -65536) + printf("FAIL: volatile_long_long_int_var\n") + else + printf("PASS: volatile_long_long_int_var\n") +} + +probe process(@1).mark("ptr_long_long_int_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_long_long_int_var\n") + else + printf("PASS: ptr_long_long_int_var\n") +} + +probe process(@1).mark("ptr_const_long_long_int_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_const_long_long_int_var\n") + else + printf("PASS: ptr_const_long_long_int_var\n") +} + +probe process(@1).mark("long_long_int_ptr_const_var") +{ + if ($arg1 != $arg2) + printf("FAIL: long_long_int_ptr_const_var\n") + else + printf("PASS: long_long_int_ptr_const_var\n") +} + +probe process(@1).mark("ptr_volatile_long_long_int_var") +{ + if ($arg1 != $arg2) + printf("FAIL: ptr_volatile_long_long_int_var\n") + else + printf("PASS: ptr_volatile_long_long_int_var\n") +} + +probe process(@1).mark("long_long_int_ptr_volatile_var") +{ + if ($arg1 != $arg2) + printf("FAIL: long_long_int_ptr_volatile_var\n") + else + printf("PASS: long_long_int_ptr_volatile_var\n") +} + +probe process(@1).mark("arr_char") +{ + arr_char = user_string ($arg1); + if (arr_char != "!~") + printf("FAIL: arr_char_var\n") + else + printf("PASS: arr_char_var\n") +} + +probe process(@1).mark("arr_struct") +{ + arr_struct_int_var = user_int ($arg1) + if (arr_struct_int_var != 1) + printf("FAIL: arr_struct_var\n") + else + printf("PASS: arr_struct_var\n") +} + +probe process(@1).mark("bitfields_small_var") +{ + if ($arg1 != 1 || $arg2 != 0 || $arg3 != 97 || $arg4 != 1 + || $arg5 != 0 || $arg6 != 122 || $arg7 != 1 || $arg8 != 0) + printf("FAIL: bitfields_small_var\n") + +} + +probe process(@1).mark("bitfields_bit_var") +{ + if ($arg1 != 65 || $arg2 != -1 || $arg3 != 1 || $arg4 != 1 + || $arg5 != 3 || $arg6 != 3 || $arg7 != 7 || $arg8 != 255 + || $arg9 != 511 || $arg10 != 90) + printf("FAIL: bitfields_bit_var\n") + else + printf("PASS: bitfields_bit_var\n") +} + + +probe process(@1).mark("primary_colors_var") +{ + if ($arg1 != 1) + printf("FAIL: primary_colors_var\n") + else + printf("PASS: primary_colors_var\n") +} + + + + + + + + + + + diff --git a/testsuite/systemtap.base/skipped.exp b/testsuite/systemtap.base/skipped.exp index 8c491037..f3048c8a 100644 --- a/testsuite/systemtap.base/skipped.exp +++ b/testsuite/systemtap.base/skipped.exp @@ -2,8 +2,8 @@ set test "skip tracking" if {! [installtest_p]} { untested $test; return } -set cpus [exec sh -c "grep ^processor /proc/cpuinfo | wc -l"] -if {$cpus < 2} { unsupported $test; return } +set nr_cpus [exec sh -c "grep ^processor /proc/cpuinfo | wc -l"] +if {$nr_cpus < 2} { unsupported $test; return } set ok 0 spawn stap -e "probe timer.s(5) {exit()} probe timer.profile,syscall.* {f++} global f" -DMAXTRYLOCK=0 -tu @@ -18,4 +18,4 @@ expect { catch {close} catch {wait} -if {$ok >= 3} { pass "$test ($cpus $ok)" } else { fail "$test ($cpus $ok)" } +if {$ok >= 3} { pass "$test ($nr_cpus $ok)" } else { fail "$test ($nr_cpus $ok)" } diff --git a/testsuite/systemtap.base/static_uprobes.exp b/testsuite/systemtap.base/static_uprobes.exp index a4bd5e2c..1e53d5d3 100644 --- a/testsuite/systemtap.base/static_uprobes.exp +++ b/testsuite/systemtap.base/static_uprobes.exp @@ -1,5 +1,6 @@ +set test "static_uprobes" -set test "sduprobes" +# Test miscellaneous features of .mark probes # Compile a C program to use as the user-space probing target set sup_srcpath "[pwd]/static_uprobes.c" @@ -81,6 +82,9 @@ provider static_uprobes { }; " close $fp + +# Test dtrace + if {[installtest_p]} { set dtrace $env(SYSTEMTAP_PATH)/dtrace } else { @@ -89,11 +93,10 @@ if {[installtest_p]} { if {[catch {exec $dtrace -h -s $sup_dpath} res]} { verbose -log "unable to run $dtrace: $res" } -catch {exec rm -f $sup_dpath} if {[file exists $sup_hpath]} then { - pass "$test generating header" + pass "$test dtrace" } else { - fail "$test generating header" + fail "$test dtrace" catch {exec rm -f $sup_srcpath $sup_hpath $sup_stppath} return } @@ -104,7 +107,11 @@ if {[installtest_p]} { set sdtdir $srcdir/../includes } -set sup_flags "additional_flags=-I$sdtdir additional_flags=-g additional_flags=-O additional_flags=-I." +set sup_flags "additional_flags=-I$srcdir/../includes/sys" +set sup_flags "$sup_flags additional_flags=-I$sdtdir" +set sup_flags "$sup_flags additional_flags=-g" +set sup_flags "$sup_flags additional_flags=-O" +set sup_flags "$sup_flags additional_flags=-I." set res [target_compile $sup_srcpath $sup_exepath executable $sup_flags] if { $res != "" } { verbose "target_compile failed: $res" 2 @@ -115,34 +122,15 @@ if { $res != "" } { pass "$test compiling C -g" } -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} { +if {![utrace_p]} { untested "$test" catch {exec rm -f $sup_srcpath} return } +# Run stap on executable built with dtrace generated header file + set ok 0 verbose -log "spawn stap -c $sup_exepath $sup_stppath" @@ -161,28 +149,56 @@ wait if {$ok == 5} { pass "$test C" } { fail "$test C ($ok)" } -set ok 0 +# Test passing various C types to .mark probes -# 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 +set sup_flags "$sup_flags additional_flags=-O0" +set res [target_compile $srcdir/$subdir/sdt_types.c sdt_types.x executable $sup_flags] +if { $res != "" } { + verbose "target_compile failed: $res" 2 + fail "$test compiling types -g" + return +} else { + pass "$test compiling types -g" +} + +set ok 0 +set fail "types" +verbose -log "spawn stap -c ./sdt_types.x $srcdir/$subdir/sdt_types.stp ./sdt_types.x" +spawn stap -c ./sdt_types.x $srcdir/$subdir/sdt_types.stp ./sdt_types.x 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)" } + -re {FAIL: [a-z_]+var} { regexp " .*$" $expect_out(0,string) s; + incr ok; set fail "$fail $s"; exp_continue } + timeout { fail "$test C (timeout)" } eof { } } wait -if {$ok == 5} { pass "$test C++" } { fail "$test C++ ($ok)" } +if { $ok != 0 } { + fail "$test $fail" +} else { + pass "$test types" +} + +# Test .mark probe wildcard matching + +set ok 0 +spawn stap -l "process(\"./sdt_types.x\").mark(\"*\")" +expect { + -timeout 180 + -re {mark\(\"[a-z_]+\"\)} { incr ok; exp_continue } + timeout { fail "$test C (timeout)" } + eof { } +} -# catch {exec rm -f $sup_srcpath $sup_exepath $supcplus_exepath $sup_hpath $sup_stppath} +if { $ok == 45 } { + pass "$test wildcard" +} else { + fail "$test wildcard ($ok)" +} + +if { $verbose == 0 } { +catch {exec rm -f $sup_srcpath $sup_exepath $supcplus_exepath $sup_dpath $sup_hpath $sup_stppath sdt_types.x} +} -# It's not so important to clean up, and it's unhelpful if -# one needs to diagnose a test failure. diff --git a/testsuite/systemtap.base/stmt_rel.exp b/testsuite/systemtap.base/stmt_rel.exp index be51fef9..619c91a5 100644 --- a/testsuite/systemtap.base/stmt_rel.exp +++ b/testsuite/systemtap.base/stmt_rel.exp @@ -1,8 +1,42 @@ -# test integer limits. Set and print variables and print constants. - set test "stmt_rel" -set ::result_string {PASS bio_init -PASS line number -PASS wildcard} -stap_run2 $srcdir/$subdir/$test.stp +set line1 "" +spawn stap -l "kernel.statement(\"bio_init@fs/bio.c+2\")" +expect { + -timeout 180 + -re {[0-9][0-9][0-9]} { regexp "\[0-9\]\[0-9\]\[0-9\]" $expect_out(0,string) line1; } + timeout { fail "$test C (timeout)" } + eof { } +} + +set line2 "" +spawn stap -l "kernel.statement(\"bio_init@fs/bio.c+3\")" +expect { + -timeout 180 + -re {[0-9][0-9][0-9]} { regexp "\[0-9\]\[0-9\]\[0-9\]" $expect_out(0,string) line2; } + timeout { fail "$test C (timeout)" } + eof { } +} + +if { $line1 < $line2 } { + pass "$test line numbers" +} else { + fail "$test line numbers" +} + +set ok 0 +spawn stap -l "kernel.statement(\"bio_init@fs/bio.c:*\")" +expect { + -timeout 180 + -re {[0-9][0-9][0-9]} { incr ok; exp_continue } + timeout { fail "$test C (timeout)" } + eof { } +} + +# 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)" +} diff --git a/testsuite/systemtap.base/stmt_rel.stp b/testsuite/systemtap.base/stmt_rel.stp deleted file mode 100644 index cfe77317..00000000 --- a/testsuite/systemtap.base/stmt_rel.stp +++ /dev/null @@ -1,71 +0,0 @@ -global stack2pp, stack2func, stack3pp, stack3func -global wildcardpp, wild_count - -probe kernel.statement("bio_init@fs/bio.c+2") { - # stack2 = tokenize(backtrace(), " ") - stack2func = probefunc() - stack2pp = pp() -} -probe kernel.statement("bio_init@fs/bio.c+3") { - # stack3 = tokenize(backtrace(), " " ) - stack3func = probefunc() - stack3pp = pp() -} - -probe kernel.statement("bio_put@fs/bio.c:*") { - line = tokenize(pp(),":") - line = tokenize("",":") - line = substr(line,0,strlen(line)-2) - wildcardpp[strtol(line,10)]++ - - if (wild_count++ <= 10) { - next - } - - stack2pp = tokenize(stack2pp,":") - stack2pp = tokenize("",":") - stack3pp = tokenize(stack3pp,":") - stack3pp = tokenize("",":") - - stack2line = strtol (substr(stack2pp,0,strlen(stack2pp)-2), 10) - stack3line = strtol (substr(stack3pp,0,strlen(stack3pp)-2), 10) - - # Did functions for both bio_init probes match? - if (stack2func == stack3func) { - printf ("PASS %s\n", stack2func) - } - else { - printf ("FAIL %s %s\n", stack2func, stack3func) - } - - # Was line # for bio_init probe +2 < line # for bio_init probe +3? - if ((stack2line + 1) == stack3line) { - printf ("PASS line number\n") - } - else { - printf ("FAIL line number %d %d\n", stack2line, stack3line) - } - - # This test does not take optimized code into account - # Was address for bio_init probe +2 < address for bio_init probe +3? - # if (stack2 < stack3) { - # printf ("PASS address\n") - # } - # else { - # printf ("FAIL address %s %s\n", stack2, stack3) - # } - - # Did wildcard probe hit at least 4 different statements? - foreach ([i] in wildcardpp) { - statement_count += 1 - } - if (statement_count >= 4) { - printf ("PASS wildcard\n") - } - else - { - printf ("FAIL wildcard %d\n", statement_count) - } - - exit() -} diff --git a/testsuite/systemtap.base/stmtvars.exp b/testsuite/systemtap.base/stmtvars.exp index 822e0d7e..c0099f2d 100644 --- a/testsuite/systemtap.base/stmtvars.exp +++ b/testsuite/systemtap.base/stmtvars.exp @@ -3,9 +3,9 @@ set test "stmtvars" set pc 0 set vars "" -spawn stap -e "probe kernel.function(\"sys_open\") {\$foo}" -p4 -vv -u +spawn stap -e "probe kernel.function(\"do_sys_open\") {\$foo}" -p4 -vv -u expect { - -re {probe sys_open[^\r\n]*pc=(0x[^\r\n]*)\r\n} { set pc $expect_out(1,string); exp_continue } + -re {probe do_sys_open[^\r\n]*pc=(0x[^\r\n]*)\r\n} { set pc $expect_out(1,string); exp_continue } -re {alternatives: ([^\r\n]*)\): identifier [^\r\n]*\r\n} { set vars $expect_out(1,string); exp_continue } timeout { fail "$test (timeout)" } eof @@ -18,7 +18,7 @@ set pc2 0 set vars2 "" spawn stap -e "probe kernel.statement($pc) {\$foo}" -p4 -vv -u expect { - -re {probe sys_open[^\r\n]*pc=(0x[^\r\n]*)\r\n} { set pc2 $expect_out(1,string); exp_continue } + -re {probe do_sys_open[^\r\n]*pc=(0x[^\r\n]*)\r\n} { set pc2 $expect_out(1,string); exp_continue } -re {alternatives: ([^\r\n]*)\): identifier [^\r\n]*\r\n} { set vars2 $expect_out(1,string); exp_continue } timeout { fail "$test (timeout)" } eof diff --git a/testsuite/systemtap.base/strftime.exp b/testsuite/systemtap.base/strftime.exp new file mode 100644 index 00000000..ad9e471d --- /dev/null +++ b/testsuite/systemtap.base/strftime.exp @@ -0,0 +1,49 @@ +set test "strftime" +if {![installtest_p]} { untested $test; return } +# cleanup +system "rm -f %*" + +# check %S and %T +set format %%%S_%T +exec stap -o $format -we {probe begin {println("hello");exit()}} + +spawn ls -1 +set ok 0 +expect { + -re {%([0-9][0-9])_[0-9][0-9]:[0-9][0-9]:\1} {incr ok} + eof { } +} +wait + +if {$ok == 1} { + pass "$test (%S and %T)" +} else { + fail "$test (%S and %T)" +} + +# check except for %S and %T +set format %%,%C,%Y,%y,%m,%d,%e,%F,%H,%I,%j,%k,%l,%M,%R,%u,%w + +set date1 [exec date +$format] +# run stapio with strftime +exec stap -o $format -we {probe begin {println("hello");exit()}} +# check whether stap outputs stapio pid +set date2 [exec date +$format] + +spawn ls -1 +set ok 0 +expect { + $date1 {incr ok} + $date2 {incr ok} + eof { } +} +wait + +if {$ok == 1} { + pass "$test (except %S and %T)" +} else { + fail "$test (except %S and %T)" +} + +# cleanup +system "rm -f %*" diff --git a/testsuite/systemtap.base/system_func.stp b/testsuite/systemtap.base/system_func.stp index d14fb25b..6a6bb04a 100644 --- a/testsuite/systemtap.base/system_func.stp +++ b/testsuite/systemtap.base/system_func.stp @@ -4,10 +4,10 @@ global saw_echo, did_cat -probe kernel.function("sys_open") { +probe kernel.function("do_sys_open") { if (!saw_echo) { # very inefficient. Testing only. DO NOT DO THIS - msg="echo sys_open" + msg="echo do_sys_open" system(msg) saw_echo = 1 } diff --git a/testsuite/systemtap.base/tracepoints.exp b/testsuite/systemtap.base/tracepoints.exp index bea461c4..cd033908 100644 --- a/testsuite/systemtap.base/tracepoints.exp +++ b/testsuite/systemtap.base/tracepoints.exp @@ -1,3 +1,26 @@ + +set tracepoints {} +spawn stap -l {kernel.trace("*")} +expect { + -re {^kernel.trace[^\r\n]*\r\n} { + append tracepoints $expect_out(0,string) + exp_continue + } + timeout {} + eof {} +} +catch {close}; catch { wait } + +foreach tp $tracepoints { + set test "tracepoint $tp -p4" + if {[catch {exec stap -w -p4 -e "probe $tp {}"} res]} { + fail "$test $res" + } else { + pass "$test" + } +} + set test "tracepoints" +if {![installtest_p]} { untested $test; return } set ::result_string {tracepoints OK} stap_run2 $srcdir/$subdir/$test.stp diff --git a/testsuite/systemtap.base/uprobes.exp b/testsuite/systemtap.base/uprobes.exp index 89250e7b..6344cbf0 100644 --- a/testsuite/systemtap.base/uprobes.exp +++ b/testsuite/systemtap.base/uprobes.exp @@ -18,14 +18,7 @@ if [file exists $path] then { pass "$test prep" } else { fail "$test prep" } catch {exec gcc -g -o jennie jennie.c} err if {$err == "" && [file exists jennie]} then { pass "$test compile" } else { fail "$test compile" } -# 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} { +if {![utrace_p]} { untested "$test -p4"; untested "$test -p5" catch {exec rm -f jennie.c jennie} return diff --git a/testsuite/systemtap.base/uprobes_exe.c b/testsuite/systemtap.base/uprobes_exe.c new file mode 100644 index 00000000..b4811335 --- /dev/null +++ b/testsuite/systemtap.base/uprobes_exe.c @@ -0,0 +1,29 @@ +/* uprobes_lib test case + * Copyright (C) 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 + * Public License (GPL); either version 2, or (at your option) any + * later version. + */ + +#include <unistd.h> + +// function from our library +int lib_main (void); + +void +main_func (int foo) +{ + if (foo > 1) + main_func (foo - 1); + else + lib_main(); +} + +int +main (int argc, char *argv[], char *envp[]) +{ + main_func (3); + return 0; +} diff --git a/testsuite/systemtap.base/uprobes_lib.c b/testsuite/systemtap.base/uprobes_lib.c new file mode 100644 index 00000000..25297b6b --- /dev/null +++ b/testsuite/systemtap.base/uprobes_lib.c @@ -0,0 +1,21 @@ +/* uprobes_lib test case - library helper + * Copyright (C) 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 + * Public License (GPL); either version 2, or (at your option) any + * later version. + */ + +void +lib_func (int bar) +{ + if (bar > 1) + lib_func (bar - 1); +} + +void +lib_main () +{ + lib_func (3); +} diff --git a/testsuite/systemtap.base/uprobes_lib.exp b/testsuite/systemtap.base/uprobes_lib.exp new file mode 100644 index 00000000..313c01b6 --- /dev/null +++ b/testsuite/systemtap.base/uprobes_lib.exp @@ -0,0 +1,46 @@ +set test "uprobes_lib" +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 {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 } +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_lib.stp b/testsuite/systemtap.base/uprobes_lib.stp new file mode 100644 index 00000000..459351a4 --- /dev/null +++ b/testsuite/systemtap.base/uprobes_lib.stp @@ -0,0 +1,15 @@ +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"); +} 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())); +} diff --git a/testsuite/systemtap.base/uprobes_ustack.exp b/testsuite/systemtap.base/uprobes_ustack.exp new file mode 100644 index 00000000..bfc435e9 --- /dev/null +++ b/testsuite/systemtap.base/uprobes_ustack.exp @@ -0,0 +1,97 @@ +set test "uprobes_ustack" +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 } + +# Output is: +#print_ubacktrace exe 0 +# 0x080484ba : main_func+0xa/0x29 [.../uprobes_exe] +# 0x080484f6 : main+0x1d/0x37 [.../uprobes_exe] +#print_ustack exe 1 +# 0x080484ba : main_func+0xa/0x29 [.../uprobes_exe] +# 0x080484c9 : main_func+0x19/0x29 [.../uprobes_exe] +# 0x080484f6 : main+0x1d/0x37 [.../uprobes_exe] +#print_ubacktrace lib 2 +# 0x00db2422 : lib_func+0x16/0x2b [.../libuprobes_lib.so] +# 0x00db2455 : lib_main+0x1e/0x29 [.../libuprobes_lib.so] +# 0x080484d0 : main_func+0x20/0x29 [.../uprobes_exe] +# 0x080484c9 : main_func+0x19/0x29 [.../uprobes_exe] +# 0x080484c9 : main_func+0x19/0x29 [.../uprobes_exe] +# 0x080484f6 : main+0x1d/0x37 [.../uprobes_exe] +#print_ustack lib 3 +# 0x00db2422 : lib_func+0x16/0x2b [.../libuprobes_lib.so] +# 0x00db2431 : lib_func+0x25/0x2b [.../libuprobes_lib.so] +# 0x00db2455 : lib_main+0x1e/0x29 [.../libuprobes_lib.so] +# 0x080484d0 : main_func+0x20/0x29 [.../uprobes_exe] +# 0x080484c9 : main_func+0x19/0x29 [.../uprobes_exe] +# 0x080484c9 : main_func+0x19/0x29 [.../uprobes_exe] +# 0x080484f6 : main+0x1d/0x37 [.../uprobes_exe] + +set print 0 +set main 0 +set main_func 0 +set lib_main 0 +set lib_func 0 +# Needs extra space since on 64bit the last ubacktrace string is +# 7 entries * (16 hex + 2 for 0x + 1 space) = 133 chars. +# Default MAXSTRINGLEN is 128 chars. +spawn stap -DMAXSTRINGLEN=133 $srcdir/$subdir/$test.stp -c $testexe + +wait +expect { + -timeout 60 + -re {^print_[^\r\n]+\r\n} {incr print; exp_continue} + -re {^ 0x[a-f0-9]+ : main\+0x[^\r\n]+\r\n} {incr main; exp_continue} + -re {^ 0x[a-f0-9]+ : main_func\+0x[^\r\n]+\r\n} {incr main_func; exp_continue} + -re {^ 0x[a-f0-9]+ : lib_main\+0x[^\r\n]+\r\n} {incr lib_main; exp_continue} + -re {^ 0x[a-f0-9]+ : lib_func\+0x[^\r\n]+\r\n} {incr lib_func; exp_continue} + timeout { fail "$test (timeout)" } + eof { } +} + +if {$print == 4} {pass "$test print"} {fail "$test print ($print)"} +if {$main == 4} {pass "$test main"} {fail "$test main ($main)"} +if {$main_func == 9} {pass "$test main_func"} {fail "$test main_func ($main_func)"} +if {$lib_main == 2} {pass "$test lib_main"} {fail "$test lib_main ($lib_main)"} +if {$lib_func == 3} {pass "$test lib_func"} {fail "$test lib_func ($lib_func)"} + +#exec rm -f $testexe $testso diff --git a/testsuite/systemtap.base/uprobes_ustack.stp b/testsuite/systemtap.base/uprobes_ustack.stp new file mode 100644 index 00000000..6de03b42 --- /dev/null +++ b/testsuite/systemtap.base/uprobes_ustack.stp @@ -0,0 +1,35 @@ +// Prints backtrace from lib through exe twice using diffent ustack functions. + +global hits = 0; + +probe process("uprobes_exe").function("main_func") +{ + if (hits == 0) + { + log("print_ubacktrace exe 0"); + print_ubacktrace(); + hits++; + } + else if (hits == 1) + { + log("print_ustack exe 1"); + print_ustack(ubacktrace()); + hits++; + } +} + +probe process("libuprobes_lib.so").function("lib_func") +{ + if (hits == 2) + { + log("print_ubacktrace lib 2"); + print_ubacktrace(); + hits++; + } + else if (hits == 3) + { + log("print_ustack lib 3"); + print_ustack(ubacktrace()); + hits++; + } +} diff --git a/testsuite/systemtap.base/utrace_p4.exp b/testsuite/systemtap.base/utrace_p4.exp index 1467d9c8..8d323a8a 100644 --- a/testsuite/systemtap.base/utrace_p4.exp +++ b/testsuite/systemtap.base/utrace_p4.exp @@ -7,8 +7,6 @@ # utrace doesn't exist in the kernel, marks the tests as 'untested'. # Initialize variables -set utrace_support_found 0 - set begin_script {"probe process(\"/bin/ls\").begin { print(\"ls begin\") }"} set end_script {"probe process(\"/bin/ls\").end { print(\"ls end\") }"} set syscall_script {"probe process(\"/bin/ls\").syscall { printf(\"|%d\", \$syscall) }"} @@ -24,18 +22,12 @@ set pid_syscall_return_script {"probe process(123).syscall.return { printf(\"|%d set pid_thread_begin_script {"probe process(123).thread.begin { print(\"123 thread.begin\") }"} set pid_thread_end_script {"probe process(123).thread.end { print(\"123 thread.end\") }"} -# Try to find utrace_attach symbol in /proc/kallsyms -set path "/proc/kallsyms" -if {! [catch {exec grep -q utrace_attach $path} dummy]} { - set utrace_support_found 1 -} - # # Do some utrace compile tests. # set TEST_NAME "UTRACE_P4_01" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling a begin script using a path @@ -43,7 +35,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P4_01_pid" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling a begin script using a pid @@ -51,7 +43,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P4_02" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling a end script using a path @@ -59,7 +51,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P4_02_pid" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling a end script using a pid @@ -67,7 +59,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P4_03" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling a syscall script using a path @@ -75,7 +67,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P4_03_pid" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling a syscall script using a pid @@ -83,7 +75,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P4_04" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling a syscall return script using a path @@ -91,7 +83,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P4_04_pid" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling a syscall return script using a pid @@ -99,7 +91,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P4_05" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling an thread.begin script using a path @@ -107,7 +99,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P4_05_pid" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling an thread.begin script using a pid @@ -115,7 +107,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P4_06" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling an thread.end script using a path @@ -123,7 +115,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P4_06_pid" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling an thread.end script using a pid @@ -131,7 +123,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P4_07" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } else { # Try compiling an system-wide begin script diff --git a/testsuite/systemtap.base/utrace_p5.exp b/testsuite/systemtap.base/utrace_p5.exp index 33281350..3d432dc3 100644 --- a/testsuite/systemtap.base/utrace_p5.exp +++ b/testsuite/systemtap.base/utrace_p5.exp @@ -1,7 +1,6 @@ # Utrace run (pass 5) tests. # Initialize variables -set utrace_support_found 0 set exepath "[pwd]/cat_[pid]" set multi_srcpath "$srcdir/systemtap.base/utrace_p5_multi.c" set multi_exepath "[pwd]/utrace_p5_multi_[pid]" @@ -90,12 +89,6 @@ set bz6841_script { } set bz6841_script_output ".+ issues syscall \\d+ times\r\n" -# Try to find utrace_attach symbol in /proc/kallsyms -set path "/proc/kallsyms" -if {! [catch {exec grep -q utrace_attach $path} dummy]} { - set utrace_support_found 1 -} - # Set up our own copy of /bin/cat, to make testing for a particular # executable easy. We can't use 'ln' here, since we might be creating # a cross-device link. We can't use 'ln -s' here, since the kernel @@ -138,7 +131,7 @@ proc run_utrace_p5_multi {} { } set TEST_NAME "UTRACE_P5_01" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } elseif {![installtest_p]} { untested "$TEST_NAME" @@ -148,7 +141,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P5_02" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } elseif {![installtest_p]} { untested "$TEST_NAME" @@ -158,7 +151,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P5_03" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } elseif {![installtest_p]} { untested "$TEST_NAME" @@ -168,7 +161,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P5_04" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } elseif {![installtest_p]} { untested "$TEST_NAME" @@ -178,7 +171,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P5_05" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } elseif {![installtest_p]} { untested "$TEST_NAME" @@ -189,7 +182,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P5_06" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } elseif {![installtest_p]} { untested "$TEST_NAME" @@ -200,7 +193,7 @@ if {$utrace_support_found == 0} { } set TEST_NAME "UTRACE_P5_07" -if {$utrace_support_found == 0} { +if {![utrace_p]} { untested "$TEST_NAME : no kernel utrace support found" } elseif {![installtest_p]} { untested "$TEST_NAME" diff --git a/testsuite/systemtap.base/utrace_syscall_args.c b/testsuite/systemtap.base/utrace_syscall_args.c new file mode 100644 index 00000000..2d3da838 --- /dev/null +++ b/testsuite/systemtap.base/utrace_syscall_args.c @@ -0,0 +1,67 @@ +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <sys/syscall.h> /* For SYS_xxx definitions */ + +int main() +{ + int fd, ret; + struct stat fs; + void *r; + int rc; + + /* create a file with something in it */ + fd = open("foobar", O_WRONLY|O_CREAT|O_TRUNC, 0600); + lseek(fd, 1024, SEEK_SET); + write(fd, "abcdef", 6); + close(fd); + + fd = open("foobar", O_RDONLY); + + /* stat for file size */ + ret = fstat(fd, &fs); + + /* mmap file file, then unmap it. */ + r = mmap(NULL, fs.st_size, PROT_READ, MAP_SHARED, fd, 0); + if (r != MAP_FAILED) + munmap(r, fs.st_size); + close(fd); + + /* OK, try some system calls to see if we get the arguments + * correctly. */ +#if (__LONG_MAX__ > __INT_MAX__) + rc = syscall (__NR_dup, (unsigned long)-12345, + (unsigned long)0xffffffffffffffff, + (unsigned long)0xa5a5a5a5a5a5a5a5, + (unsigned long)0xf0f0f0f0f0f0f0f0, + (unsigned long)0x5a5a5a5a5a5a5a5a, + (unsigned long)0xe38e38e38e38e38e); +#else + rc = syscall (__NR_dup, (unsigned long)-12345, + (unsigned long)0xffffffff, + (unsigned long)0xa5a5a5a5, + (unsigned long)0xf0f0f0f0, + (unsigned long)0x5a5a5a5a, + (unsigned long)0xe38e38e3); +#endif +#if (__LONG_MAX__ > __INT_MAX__) + rc = syscall ((unsigned long)-1, + (unsigned long)0x1c71c71c71c71c71, + (unsigned long)0x0f0f0f0f0f0f0f0f, + (unsigned long)0xdb6db6db6db6db6d, + (unsigned long)0x2492492492492492, + (unsigned long)0xad6b5ad6b5ad6b5a, + (unsigned long)0xdef7ddef7ddef7dd); +#else + rc = syscall ((unsigned long)-1, + (unsigned long)0x1c71c71c, + (unsigned long)0x0f0f0f0f, + (unsigned long)0xdb6db6db, + (unsigned long)0x24924924, + (unsigned long)0xad6b5ad6, + (unsigned long)0xdef7ddef); +#endif + return 0; +} diff --git a/testsuite/systemtap.base/utrace_syscall_args.exp b/testsuite/systemtap.base/utrace_syscall_args.exp new file mode 100644 index 00000000..98bc457e --- /dev/null +++ b/testsuite/systemtap.base/utrace_syscall_args.exp @@ -0,0 +1,82 @@ +# Utrace system call argument tests. + +set flags "" +set srcpath "$srcdir/$subdir/utrace_syscall_args.c" +set exepath "[pwd]/utrace_syscall_args" +set stppath "$srcdir/$subdir/utrace_syscall_args.stp" + +set output_string "mmap\\(\[0-9\]+\\)\\(0x\[0-9a-f]+, 0x\[0-9a-f]+, 0x\[0-9a-f]+, 0x\[0-9a-f]+, 0x\[0-9a-f]+, 0x\[0-9a-f]+\\) = 0x\[0-9a-f]+\r\nmunmap\\(\[0-9\]+\\)\\(0x\[0-9a-f]+, 0x\[0-9a-f]+\\) = 0x\[0-9a-f]+\r\nclose\\(\[0-9\]+\\)\\(0x\[0-9a-f]+\\) = 0x\[0-9a-f]+\r\ndup\\(\[0-9\]+\\)\\(0x\[0-9a-f]+, 0x\[0-9a-f]+, 0x\[0-9a-f]+, 0x\[0-9a-f]+, 0x\[0-9a-f]+, 0x\[0-9a-f]+\\) = 0x\[0-9a-f]+\r\nbad_syscall\\(-?\[0-9\]+\\)\\(0x\[0-9a-f]+, 0x\[0-9a-f]+, 0x\[0-9a-f]+, 0x\[0-9a-f]+, 0x\[0-9a-f]+, 0x\[0-9a-f]+\\) = 0x\[0-9a-f]+\r\nsystemtap test success\r\n" + +# For first pass, force 64-bit compilation for 64-bit systems. Add +# any other 64-bit architecture you want tested below. +# +# To find tcl's platform name for your machine, run the following: +# echo "puts $::tcl_platform(machine)" | tclsh + +switch -regexp $::tcl_platform(machine) { + ^ia64$ { + set do_64_bit_pass 1 + set flags "" + } + ^(x86_64|ppc64|s390x)$ { + set do_64_bit_pass 1 + set flags "additional_flags=-m64" + } + default { + set do_64_bit_pass 0 + } +} + +if {$do_64_bit_pass} { + set testname "64_BIT_UTRACE_SYSCALL_ARGS" + if {![installtest_p]} { untested $testname; continue } + if {![utrace_p]} { untested $testname; continue } + send_log "Testing ${testname}\n" + + # Compile our test program. + set res [target_compile $srcpath $exepath executable $flags] + if { $res != "" } { + verbose "target_compile for $exepath failed: $res" 2 + fail "$testname: unable to compile $srcpath" + return + } + + # Run the test. + stap_run $testname no_load $output_string -g $stppath -c $exepath + + catch {exec rm -f $exepath foobar} +} + +# The second pass is for systems that support 32-bit executables +# (either exclusively or in addition to 64-bit executables). +set do_32_bit_pass 1 +switch -regexp $::tcl_platform(machine) { + ^(x86_64|ppc64)$ { + set flags "additional_flags=-m32" + } + ^s390x$ { + set flags "additional_flags=-m31" + } + ^ia64$ { + set do_32_bit_pass 0 + } +} + +if {$do_32_bit_pass} { + set testname "32_BIT_UTRACE_SYSCALL_ARGS" + if {![installtest_p]} { untested $testname; continue } + if {![utrace_p]} { untested $testname; continue } + send_log "Testing ${testname}\n" + + # Compile our test program + set res [target_compile $srcpath $exepath executable $flags] + if { $res != "" } { + verbose "target_compile for $exepath failed: $res" 2 + fail "$testname: unable to compile $srcpath" + return + } + + stap_run $testname no_load $output_string -g $stppath -c $exepath + + catch {exec rm -f $exepath foobar} +} diff --git a/testsuite/systemtap.base/utrace_syscall_args.stp b/testsuite/systemtap.base/utrace_syscall_args.stp new file mode 100644 index 00000000..6c9e14fc --- /dev/null +++ b/testsuite/systemtap.base/utrace_syscall_args.stp @@ -0,0 +1,406 @@ +%{ +#include "syscall.h" +%} + +function mmap_syscall_no:long () %{ + THIS->__retvalue = MMAP_SYSCALL_NO(current); /* pure */ +%} +function mmap2_syscall_no:long () %{ + THIS->__retvalue = MMAP2_SYSCALL_NO(current); /* pure */ +%} +function munmap_syscall_no:long () %{ + THIS->__retvalue = MUNMAP_SYSCALL_NO(current); /* pure */ +%} + +global syscalls_seen = 0 +global failures = 0 + +global mmap_found = 0 +global mmap_args[10] + +global munmap_found = 0 +global munmap_args[10] + +global close_found = 0 +global close_args[10] + +global dup_found = 0 +global dup_args[10] + +global bad_syscall_found = 0 +global bad_syscall_args[10] + +probe begin +{ + printf("systemtap starting probe\n") +} + +probe syscall.open { + if (filename == "foobar") { + syscalls_seen += 1 + } +} + +probe process("utrace_syscall_args").syscall { + if (syscalls_seen >= 2) { + syscalls_seen += 1 + + # We skip the fstat() syscall, which is the 1st syscall after + # the open() by not looking at 'syscalls_seen == 3'. + + if (syscalls_seen == 4 && ($syscall == mmap_syscall_no() + || $syscall == mmap2_syscall_no())) { + mmap_found = 1 + mmap_args[0] = $syscall + mmap_args[1] = $arg1 + mmap_args[2] = $arg2 + mmap_args[3] = $arg3 + mmap_args[4] = $arg4 + mmap_args[5] = $arg5 + mmap_args[6] = $arg6 + +%(arch == "s390x" %? + # s390 requires this for mmap. Verified by running: + # # strace strace utrace_syscall_args + addr = mmap_args[1] + mmap_args[1] = user_long(addr) + addr += 8 + mmap_args[2] = user_long(addr) + addr += 8 + mmap_args[3] = user_long(addr) + addr += 8 + mmap_args[4] = user_long(addr) + addr += 8 + mmap_args[5] = user_long(addr) + addr += 8 + mmap_args[6] = user_long(addr) +%) + } + else if (syscalls_seen == 5 && $syscall == munmap_syscall_no()) { + munmap_found = 1 + munmap_args[0] = $syscall + munmap_args[1] = $arg1 + munmap_args[2] = $arg2 + } + else if (syscalls_seen == 6) { + close_found = 1 + close_args[0] = $syscall + close_args[1] = $arg1 + } + else if (syscalls_seen == 7) { + dup_found = 1 + dup_args[0] = $syscall + dup_args[1] = $arg1 + dup_args[2] = $arg2 + dup_args[3] = $arg3 + dup_args[4] = $arg4 + dup_args[5] = $arg5 + dup_args[6] = $arg6 + } + else if (syscalls_seen == 8) { + bad_syscall_found = 1 + bad_syscall_args[0] = $syscall + bad_syscall_args[1] = $arg1 + bad_syscall_args[2] = $arg2 + bad_syscall_args[3] = $arg3 + bad_syscall_args[4] = $arg4 + bad_syscall_args[5] = $arg5 + bad_syscall_args[6] = $arg6 + } + } +} +probe process("utrace_syscall_args").syscall.return { + if (syscalls_seen >= 4) { + if (syscalls_seen == 4) { + mmap_args[7] = $return + mmap_args[8] = $syscall + } + else if (syscalls_seen == 5) { + munmap_args[3] = $return + munmap_args[4] = $syscall + } + else if (syscalls_seen == 6) { + close_args[2] = $return + close_args[3] = $syscall + } + else if (syscalls_seen == 7) { + dup_args[7] = $return + dup_args[8] = $syscall + } + else if (syscalls_seen == 8) { + bad_syscall_args[7] = $return + bad_syscall_args[8] = $syscall + syscalls_seen = 0 + } + } +} + +probe end +{ + printf("systemtap ending probe\n") + + # print mmap info + if (mmap_found == 0) { + printf("error: no mmap system call found\n") + failures += 1 + } + else { + printf("mmap(%d)(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x) = 0x%x\n", + mmap_args[0], mmap_args[1], mmap_args[2], mmap_args[3], + mmap_args[4], mmap_args[5], mmap_args[6], mmap_args[7]) + + # Validate arguments. We can only check certain arguments. + # It is possible that mmap's 'prot' and 'flags' arguments + # could vary per platform, so we'll ignore them. + if (mmap_args[1] != 0) { + failures += 1 + printf("mmap bad arg 1: 0x%x vs 0x0\n", mmap_args[1]) + } + if (mmap_args[2] != 0x406) { + failures += 1 + printf("mmap bad arg 2: 0x%x vs 0x406\n", mmap_args[2]) + } + if (mmap_args[6] != 0) { + failures += 1 + printf("mmap bad arg 6: 0x%x vs 0x0\n", mmap_args[6]) + } + + # Validate syscall number + if (mmap_args[0] != mmap_args[8]) { + failures += 1 + printf("mmap $syscall mismatch: %d vs. %d\n", + mmap_args[0], mmap_args[8]) + } + } + + # print munmap info + if (munmap_found == 0) { + printf("error: no munmap system call found\n") + failures += 1 + } + else if (munmap_found == 0 || mmap_found == 0) { + printf("error: no munmap/mmap system call found\n") + failures += 1 + } + else { + printf("munmap(%d)(0x%x, 0x%x) = 0x%x\n", + munmap_args[0], munmap_args[1], munmap_args[2], munmap_args[3]) + + # Validate arguments. munmap()'s first argument should be the + # same as the mmap() return value. + if (munmap_args[1] != mmap_args[7]) { + failures += 1 + printf("munmap bad arg 1: 0x%x vs 0x%x\n", munmap_args[1], + mmap_args[7]) + } + if (munmap_args[2] != mmap_args[2]) { + failures += 1 + printf("munmap bad arg 2: 0x%x vs 0x%x\n", munmap_args[2], + mmap_args[2]) + } + # Validate return value + if (munmap_args[7] != 0) { + failures += 1 + printf("munmap bad return value: 0x%x vs 0x0\n", munmap_args[7]) + } + + # Validate syscall number + if (munmap_args[0] != munmap_args[4]) { + failures += 1 + printf("munmap $syscall mismatch: %d vs. %d\n", + munmap_args[0], munmap_args[4]) + } + } + + # print close info + if (close_found == 0) { + printf("error: no close system call found\n") + failures += 1 + } + else if (close_found == 1) { + printf("close(%d)(0x%x) = 0x%x\n", + close_args[0], close_args[1], close_args[2]) + + if (mmap_args[5] != close_args[1]) { + failures += 1 + printf("close bad arg 1: 0x%x vs 0x%x\n", + close_args[0], mmap_args[5]) + } + + # Validate syscall number + if (close_args[0] != close_args[3]) { + failures += 1 + printf("close $syscall mismatch: %d vs. %d\n", + close_args[0], close_args[3]) + } + } + + # print dup info + if (dup_found == 0) { + printf("error: no dup system call found\n") + failures += 1 + } + else { + printf("dup(%d)(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x) = 0x%x\n", + dup_args[0], dup_args[1], dup_args[2], dup_args[3], + dup_args[4], dup_args[5], dup_args[6], dup_args[7]) + + # Validate arguments - handle 32-bit vs. 64-bit. + if ((dup_args[1] & 0xffffffff00000000) != 0) { + if (dup_args[1] != 0xffffffffffffcfc7) { + failures += 1 + printf("dup bad arg 1: 0x%x vs 0xffffffffffffcfc7\n", + dup_args[1]) + } + if (dup_args[2] != 0xffffffffffffffff) { + failures += 1 + printf("dup bad arg 2: 0x%x vs 0xffffffffffffffff\n", + dup_args[2]) + } + if (dup_args[3] != 0xa5a5a5a5a5a5a5a5) { + failures += 1 + printf("dup bad arg 3: 0x%x vs 0xa5a5a5a5a5a5a5a5\n", + dup_args[3]) + } + if (dup_args[4] != 0xf0f0f0f0f0f0f0f0) { + failures += 1 + printf("dup bad arg 4: 0x%x vs 0xf0f0f0f0f0f0f0f0\n", + dup_args[4]) + } + if (dup_args[5] != 0x5a5a5a5a5a5a5a5a) { + failures += 1 + printf("dup bad arg 5: 0x%x vs 0x5a5a5a5a5a5a5a5a\n", + dup_args[5]) + } + if (dup_args[6] != 0xe38e38e38e38e38e) { + failures += 1 + printf("dup bad arg 6: 0x%x vs 0xe38e38e38e38d38e\n", + dup_args[6]) + } + } + else { + if (dup_args[1] != 0xffffcfc7) { + failures += 1 + printf("dup bad arg 1: 0x%x vs 0xffffcfc7\n", dup_args[1]) + } + if (dup_args[2] != 0xffffffff) { + failures += 1 + printf("dup bad arg 2: 0x%x vs 0xffffffff\n", dup_args[2]) + } + if (dup_args[3] != 0xa5a5a5a5) { + failures += 1 + printf("dup bad arg 3: 0x%x vs 0xa5a5a5a5\n", dup_args[3]) + } + if (dup_args[4] != 0xf0f0f0f0) { + failures += 4 + printf("dup bad arg 4: 0x%x vs 0xf0f0f0f0\n", dup_args[4]) + } + if (dup_args[5] != 0x5a5a5a5a) { + failures += 1 + printf("dup bad arg 5: 0x%x vs 0x5a5a5a5a\n", dup_args[5]) + } + if (dup_args[6] != 0xe38e38e3) { + failures += 1 + printf("dup bad arg 6: 0x%x vs 0xe38e38e3\n", dup_args[6]) + } + } + + # Validate syscall number + if (dup_args[0] != dup_args[8]) { + failures += 1 + printf("dup $syscall mismatch: %d vs. %d\n", + dup_args[0], dup_args[8]) + } + } + + # print bad_syscall info + if (bad_syscall_found == 0) { + printf("error: no bad_syscall system call found\n") + failures += 1 + } + else { + printf("bad_syscall(%d)(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x) = 0x%x\n", + bad_syscall_args[0], bad_syscall_args[1], bad_syscall_args[2], bad_syscall_args[3], + bad_syscall_args[4], bad_syscall_args[5], bad_syscall_args[6], bad_syscall_args[7]) + + # Validate arguments - handle 32-bit vs. 64-bit. + if (bad_syscall_args[1] > 0xffffffff) { + if (bad_syscall_args[1] != 0x1c71c71c71c71c71) { + failures += 1 + printf("bad_syscall bad arg 1: 0x%x vs 0x1c71c71c71c71c71\n", + bad_syscall_args[1]) + } + if (bad_syscall_args[2] != 0x0f0f0f0f0f0f0f0f) { + failures += 1 + printf("bad_syscall bad arg 2: 0x%x vs 0x0f0f0f0f0f0f0f0f\n", + bad_syscall_args[2]) + } + if (bad_syscall_args[3] != 0xdb6db6db6db6db6d) { + failures += 1 + printf("bad_syscall bad arg 3: 0x%x vs 0xdb6db6db6db6db6d\n", + bad_syscall_args[3]) + } + if (bad_syscall_args[4] != 0x2492492492492492) { + failures += 1 + printf("bad_syscall bad arg 4: 0x%x vs 0x2492492492492492\n", + bad_syscall_args[4]) + } + if (bad_syscall_args[5] != 0xad6b5ad6b5ad6b5a) { + failures += 1 + printf("bad_syscall bad arg 5: 0x%x vs 0xad6b5ad6b5ad6b5a\n", + bad_syscall_args[5]) + } + if (bad_syscall_args[6] != 0xdef7ddef7ddef7dd) { + failures += 1 + printf("bad_syscall bad arg 6: 0x%x vs 0xdef7ddef7ddef7dd\n", + bad_syscall_args[6]) + } + } + else { + if (bad_syscall_args[1] != 0x1c71c71c) { + failures += 1 + printf("bad_syscall bad arg 1: 0x%x vs 0x1c71c71c\n", + bad_syscall_args[1]) + } + if (bad_syscall_args[2] != 0x0f0f0f0f) { + failures += 1 + printf("bad_syscall bad arg 2: 0x%x vs 0x0f0f0f0f\n", + bad_syscall_args[2]) + } + if (bad_syscall_args[3] != 0xdb6db6db) { + failures += 1 + printf("bad_syscall bad arg 3: 0x%x vs 0xdb6db6db\n", + bad_syscall_args[3]) + } + if (bad_syscall_args[4] != 0x24924924) { + failures += 4 + printf("bad_syscall bad arg 4: 0x%x vs 0x24924924\n", + bad_syscall_args[4]) + } + if (bad_syscall_args[5] != 0xad6b5ad6) { + failures += 1 + printf("bad_syscall bad arg 5: 0x%x vs 0xad6b5ad6\n", + bad_syscall_args[5]) + } + if (bad_syscall_args[6] != 0xdef7ddef) { + failures += 1 + printf("bad_syscall bad arg 6: 0x%x vs 0xdef7ddef\n", + bad_syscall_args[6]) + } + } + + # Validate syscall number + if (bad_syscall_args[0] != bad_syscall_args[8]) { + failures += 1 + printf("bad_syscall $syscall mismatch: %d vs. %d\n", + bad_syscall_args[0], bad_syscall_args[8]) + } + } + + if (failures == 0) { + printf("systemtap test success\n") + } + else { + printf("systemtap test failure\n") + } +} diff --git a/testsuite/systemtap.base/x86_gs.exp b/testsuite/systemtap.base/x86_gs.exp new file mode 100644 index 00000000..98ab3051 --- /dev/null +++ b/testsuite/systemtap.base/x86_gs.exp @@ -0,0 +1,12 @@ +set test "x86_gs" +if {![installtest_p]} { untested $test; return } +set arch [exec uname -m] +if {$arch!="i686"} { untested $test; return } +spawn stap $srcdir/$subdir/x86_gs.stp +expect { + -timeout 60 + -re "0\r\n" { pass $test } + -re "140\r\n" { pass $test } + eof { fail $test } + timeout { fail "$test unexpected timeout" } +} diff --git a/testsuite/systemtap.base/x86_gs.stp b/testsuite/systemtap.base/x86_gs.stp new file mode 100644 index 00000000..68b58512 --- /dev/null +++ b/testsuite/systemtap.base/x86_gs.stp @@ -0,0 +1,10 @@ +#! stap + +# test x86 gs register + +probe begin { + if (!_stp_regs_registered) + _stp_register_regs() + printf("%d\n",test_x86_gs() * 100 + _reg_offsets["gs"]) /* 0 or 140 */ + exit() +} |