path: root/testsuite/systemtap.base/sdt_misc.exp

set test "sdt_misc"

# Test miscellaneous features of .mark probes

# Compile a C program to use as the user-space probing target
set sup_srcpath "[pwd]/sdt_misc.c"
set supcplus_exepath "[pwd]/sdt_misc_cplus.x"
set fp [open $sup_srcpath "w"]
puts $fp "
#include <stdlib.h>
#include \"sdt_misc_.h\"

void
bar (int i)
{
  SDT_MISC_TEST_PROBE_2(i);
  if (i == 0)
    i = 1000;
  STAP_PROBE1(static_uprobes,test_probe_2,i);
}

void
baz (int i, char* s)
{
  STAP_PROBE1(static_uprobes,test_probe_0,i);
  if (i == 0)
    i = 1000;
  SDT_MISC_TEST_PROBE_3(i,s);
}

void
buz (int parm)
{
 struct astruct
  {
    int a;
    int b;
  };
  struct astruct bstruct = {parm, parm + 1};
  if (parm == 0)
    parm = 1000;
  DTRACE_PROBE1(sdt_misc,test_probe_4,&bstruct);
}

#ifndef NO_MAIN
int
main ()
{
  bar(2);
  baz(3,(char*)\"abc\");
  buz(4);
}
#endif
"
close $fp

set sup_stppath "[pwd]/sdt_misc.stp"
set fp [open $sup_stppath "w"]
puts $fp "
%( \$# > 1 %?
probe process(@1).library(@2).mark(\"test_probe_0\") 
%:
probe process(@1).mark(\"test_probe_0\") 
%)
{ 
  printf(\"In %s probe %#x\\n\", \$\$name, \$arg1)
}
%( \$# > 1 %?
probe process(@1).library(@2).mark(\"test_probe_2\") 
%:
probe process(@1).mark(\"test_probe_2\") 
%)
{
  printf(\"In %s probe %#x\\n\", \$\$name, \$arg1)
}
%( \$# > 1 %?
probe process(@1).library(@2).mark(\"test_probe_3\") 
%:
probe process(@1).mark(\"test_probe_3\") 
%)
{ 
  printf(\"In %s probe %#x %#x\\n\", \$\$name, \$arg1, \$arg2)
}
%( \$# > 1 %?
probe process(@1).library(@2).mark(\"test_probe_4\")
%:
probe process(@1).mark(\"test_probe_4\")
%)
{ 
  printf(\"In %s dtrace probe %#x %#x\\n\", \$\$name, \$arg1->a, \$arg1->b)
}
"
close $fp

set sup_dpath "[pwd]/sdt_misc_.d" 
set sup_hpath "[pwd]/sdt_misc_.h" 
set sup_opath "[pwd]/sdt_misc_.o" 
set fp [open $sup_dpath "w"]
puts $fp "
provider sdt_misc {
        probe test_probe_0 ();
	probe test_probe_2 (int i);
	probe test_probe_3 (int i, char* x);
	probe test_probe_4 (struct astruct arg);
};
struct astruct {int a; int b;};
"
close $fp

# Test dtrace

if {[installtest_p]} { 
    set dtrace $env(SYSTEMTAP_PATH)/dtrace 
} else {
    set dtrace $srcdir/../dtrace
}
if {[catch {exec $dtrace --types -h -s $sup_dpath} res]} {
    verbose -log "unable to run $dtrace: $res"
}
if {[catch {exec $dtrace --types -G -s $sup_dpath} res]} {
    verbose -log "unable to run $dtrace: $res"
}
if {[file exists $sup_hpath] && [file exists $sup_opath]} then {
    pass "$test dtrace"
} else {
    fail "$test dtrace"
    if { $verbose == 0 } {
    catch {exec rm -f $sup_srcpath $sup_hpath $sup_stppath}
    }
    return
}

if {[installtest_p]} { 
    set sdtdir $env(SYSTEMTAP_INCLUDES)
} else {
    set sdtdir $srcdir/../includes
}

set pbtype_flags {{""} {additional_flags=-O additional_flags=-DEXPERIMENTAL_KPROBE_SDT}}
set pbtype_mssgs {{uprobe} {kprobe}}

# Iterate pbtype_flags
for {set i 0} {$i < [llength $pbtype_flags]} {incr i} {
set pbtype_flag [lindex $pbtype_flags $i]
set pbtype_mssg [lindex $pbtype_mssgs $i]
set sup_exepath "[pwd]/sdt_misc-$pbtype_mssg.x"

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=$sup_opath"
set sup_flags "$sup_flags additional_flags=-I. $pbtype_flag"
set res [target_compile $sup_srcpath $sup_exepath executable $sup_flags]
if { $res != "" } {
    verbose "target_compile failed: $res" 2
    fail "$test compiling -g $pbtype_mssg"
    if { $verbose == 0 } {
    catch {exec rm -f $sup_srcpath $sup_hpath $sup_stppath}
    }
    return
} else {
    pass "$test compiling -g $pbtype_mssg"
}

if {![installtest_p]} {untested $test; return}
if {![utrace_p]} {
    untested "$test"
    if { $verbose == 0 } {
    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"
spawn stap -c $sup_exepath $sup_stppath $sup_exepath
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 0x5} { incr ok; exp_continue }
    timeout { fail "$test (timeout)" }
    eof { }
}

wait

if {$ok == 5} { 
    pass "$test $pbtype_mssg"
} else {
    fail "$test ($ok) $pbtype_mssg"
}

# Test passing various C types to .mark probes

set sup_flags "$sup_flags $pbtype_flag 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 $pbtype_mssg"
    return
} else {
    pass "$test compiling types -g $pbtype_mssg"
}

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 {FAIL: [a-z_]+var} { regexp " .*$" $expect_out(0,string) s; 
	incr ok; set fail "$fail $s"; exp_continue }
    timeout { fail "$test (timeout)" }
    eof { }
}

wait

if { $ok != 0} {
    if { $pbtype_mssg == "uprobe" } {
	fail "$test $fail $pbtype_mssg"
    } else {
	# (needs cast)
	xfail "$test $fail $pbtype_mssg"
    }
} else {
    pass "$test types $pbtype_mssg"
}

# Test probe in shared object

set sup_srcmainpath "[pwd]/sdt_misc_.c"
set fp [open $sup_srcmainpath "w"]
puts $fp "
int
main ()
{
  bar(2);
  baz(3,(char*)\"abc\");
  buz(4);
}
"
close $fp

set sup_flags "$sup_flags additional_flags=-shared"
set sup_flags "$sup_flags additional_flags=-fPIC"
set sup_flags "$sup_flags additional_flags=-DNO_MAIN"
set sup_sopath "[pwd]/libsdt-$pbtype_mssg.so"
set sup_exepath "[pwd]/sdt_misc-$pbtype_mssg-shared.x"
set res0 [target_compile $sup_srcpath $sup_sopath executable $sup_flags ]
set sup0_flags "additional_flags=-g additional_flags=-Wl,-rpath,[pwd]"
set sup0_flags "$sup0_flags additional_flags=-L[pwd] additional_flags=-lsdt-$pbtype_mssg"
set res [target_compile $sup_srcmainpath $sup_exepath executable $sup0_flags ]
if { $res0 != "" || $res != "" } {
    verbose "target_compile failed: $res0 $res" 2
    fail "$test compiling -g -shared $pbtype_mssg"
    if { $verbose == 0 } {
    catch {exec rm -f $sup_srcpath $sup_srcmainpath}
    }
    return
} else {
    pass "$test compiling -g -shared $pbtype_mssg"
}

set ok 0
verbose -log "spawn stap -c $sup_exepath $sup_stppath $sup_exepath $sup_sopath"
if { $pbtype_mssg != "kprobe" } {
    spawn stap -c $sup_exepath $sup_stppath $sup_exepath $sup_sopath
} else {
    spawn stap -c $sup_exepath $sup_stppath $sup_sopath
}
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 0x5} { incr ok; exp_continue }
    timeout { fail "$test (timeout)" }
    eof { }
}

wait

if {$ok == 5} { 
    pass "$test shared $pbtype_mssg"
} else {
    fail "$test ($ok) shared $pbtype_mssg"
}

# 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 (timeout)" }
    eof { }
}

if { $ok == 45 } {
    pass "$test wildcard $pbtype_mssg"
} else {
    fail "$test wildcard ($ok) $pbtype_mssg"
}

if { $verbose == 0 } {
    catch {exec rm -f libsdt-$pbtype_mssg.so sdt_misc-$pbtype_mssg.x sdt_misc-$pbtype_mssg-shared.x }
}
# for {set i 0}
}

if { $verbose == 0 } {
    catch {exec rm -f sdt_misc_.c sdt_misc.c sdt_misc_.d sdt_misc_.h sdt_misc_.o sdt_misc.stp sdt_types.x}
}