1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
# cache.exp
# flag values
proc F_UNCACHED {} {return 0x1}; # compilation should be uncached
proc F_CACHED {} {return 0x2}; # compilation should be cached
proc F_NO_COMPILE {} {return 0x4}; # script doesn't compile
proc F_COMPILE {} {return 0x8}; # script compiles
# mask values to get either the cache vale or the compile value
proc F_CACHE_MASK {} {return [expr [F_UNCACHED] | [F_CACHED]]}
proc F_COMPILE_MASK {} {return [expr [F_NO_COMPILE] | [F_COMPILE]]}
# convenience combination of flags
proc F_CACHED_COMPILE {} {return [expr [F_CACHED] | [F_COMPILE]]}
proc F_UNCACHED_COMPILE {} {return [expr [F_UNCACHED] | [F_COMPILE]]}
proc F_UNCACHED_NO_COMPILE {} {return [expr [F_UNCACHED] | [F_NO_COMPILE]]}
# cache_compile TEST_NAME flags script args
# - TEST_NAME is the name of the current test
# - flags indicates the expected outcome of this test
# - script is the script to compile
# Additional arguments are passed to stap as-is.
proc cache_compile { TEST_NAME flags script args } {
set cmd [concat {stap -v -p4 -e} $script $args]
eval spawn $cmd
set cached 0
set compile_errors 0
expect {
-timeout 180
-re {^Pass\ [1234]:[^\r]*\ in\ [^\r]*\ ms\.\r\n} {exp_continue}
-re {^Pass\ [34]: using cached [^\r\n]+\r\n} {incr cached 1; exp_continue}
-re "^WARNING" {exp_continue}
# pass-4 output
-re {^/[^\r\n]+\.ko\r\n} {exp_continue}
-re "compilation failed" {incr compile_errors 1; exp_continue}
-re "semantic error:" {incr compile_errors 1; exp_continue}
timeout { fail "$TEST_NAME (timeout)" }
}
catch close
wait
# If we've got compile errors and the script was supposed to
# compile, fail.
if {$compile_errors > 0
&& [expr $flags & [F_COMPILE_MASK]] == [F_COMPILE]} {
fail "$TEST_NAME compilation failed"
return
}
# If we were supposed to use a cached module...
if {[expr $flags & [F_CACHE_MASK]] == [F_CACHED]} {
if {$cached == 2} {
pass "$TEST_NAME was cached"
} else {
fail "$TEST_NAME wasn't cached"
}
# If we weren't supposed to use a cached module...
} else {
if {$cached > 0} {
fail "$TEST_NAME was cached"
} else {
pass "$TEST_NAME wasn't cached"
}
}
}
# Since we need a clean cache directory, we'll use a temporary
# systemtap directory and cache (add user name so make check and
# sudo make installcheck don't clobber each others)
set local_systemtap_dir [exec pwd]/.cache_test-[exec whoami]
exec /bin/rm -rf $local_systemtap_dir
if [info exists env(SYSTEMTAP_DIR)] {
set old_systemtap_dir $env(SYSTEMTAP_DIR)
}
set env(SYSTEMTAP_DIR) $local_systemtap_dir
# Set up the scripts we'll use.
set basic_script1 "\"probe begin { println(1) }\""
set basic_script2 "\"probe begin, end { println(2) }\""
set error_script "\"probe XbeginX { }\""
# Check basic functionality. The 1st compilation of a script won't
# be cached, the 2nd should be cached.
cache_compile BASIC1 [F_UNCACHED_COMPILE] $basic_script1
cache_compile BASIC2 [F_CACHED_COMPILE] $basic_script1
# Adding in a macro definition should change the hash
cache_compile OPTION1 [F_UNCACHED_COMPILE] $basic_script1 -DFOO=1
cache_compile OPTION2 [F_CACHED_COMPILE] $basic_script1 -DFOO=1
# Using '-b' (bulk/relayfs mode) should change the hash
cache_compile BULK1 [F_UNCACHED_COMPILE] $basic_script1 -b
cache_compile BULK2 [F_CACHED_COMPILE] $basic_script1 -b
# Using '-t' (benchmark timing) should change the hash
cache_compile TIMING1 [F_UNCACHED_COMPILE] $basic_script1 -t
cache_compile TIMING2 [F_CACHED_COMPILE] $basic_script1 -t
# Changing the runtime directory should change the hash
set new_runtime [exec pwd]/.cache_test_runtime
exec /bin/rm -f $new_runtime
exec /bin/ln -s $env(SYSTEMTAP_RUNTIME) $new_runtime
cache_compile RUNTIME1 [F_UNCACHED_COMPILE] $basic_script1 -R $new_runtime
cache_compile RUNTIME2 [F_CACHED_COMPILE] $basic_script1 -R $new_runtime
exec /bin/rm -f $new_runtime
# Disable the cache with SYSTEMTAP_DIR
set env(SYSTEMTAP_DIR) /dev/null
cache_compile DISABLED1 [F_UNCACHED_COMPILE] $basic_script1
cache_compile DISABLED2 [F_UNCACHED_COMPILE] $basic_script1
set env(SYSTEMTAP_DIR) $local_systemtap_dir
eval [list exec /bin/rm -f] [glob "stap_*.ko"]
# Disable the cache with '-m'
cache_compile MODNAM1 [F_UNCACHED_COMPILE] $basic_script1 -m modnam
exec /bin/rm -f modnam.ko
cache_compile MODNAM2 [F_UNCACHED_COMPILE] $basic_script1 -m modnam
exec /bin/rm -f modnam.ko
# Make sure scripts that don't actually compile don't get cached
cache_compile ERROR1 [F_UNCACHED_NO_COMPILE] $error_script
cache_compile ERROR2 [F_UNCACHED_NO_COMPILE] $error_script
# Make sure basic stuff still works.
cache_compile BASIC3 [F_UNCACHED_COMPILE] $basic_script2
cache_compile BASIC4 [F_CACHED_COMPILE] $basic_script2
# Cleanup.
exec /bin/rm -rf $local_systemtap_dir
if [info exists old_systemtap_dir] {
set env(SYSTEMTAP_DIR) $old_systemtap_dir
} else {
unset env(SYSTEMTAP_DIR)
}
|
