Debian Codegraph @

doc/SystemTap_Beginners_Guide/testsuite/systemtap.base/listing_mode.exp

raw
1 set test "listing_mode"
2 set testpath "$srcdir/$subdir"
3
4 # This test verifies the output of stap -l for (hopefully) all possible probe
5 # point syntax. It's less about the exact string match of the probe point (this
6 # should be tested in the section for that probe point) and more about comparing
7 # the general form of the listed probe with what we expected regardless of the
8 # way the user inputs the data.
9
10 # There are some probe points that cannot reliably be tested, such as a few in
11 # the kernel.* family and all of the module.* probe points. However, note that
12 # the same probe builder is used for those and for the process.* probe points,
13 # which we extensively test.
14
15 # Specify a globby pattern in the LISTING_MODE_SUBTEST env var to match against
16 # pps to exclusively test. Leave undefined/blank to test all.
17 if {[info exists ::env(LISTING_MODE_SUBTEST)]} {
18 set TARGET_SUBTEST $::env(LISTING_MODE_SUBTEST)
19 } else {
20 set TARGET_SUBTEST ""
21 }
22
23 # Runs stap -l $pp and checks that every line output matches $exp. If $exp is
24 # missing, checks that lines match $pp. If $exp starts with 're:' then the rest
25 # of it is treated as a regular expression. If $nlines_exp is not -1, then
26 # exactly $nlines_exp lines are expected.
27 proc stap_list {pp {exp ""} {nlines_exp 1} {arguments ""}} {
28 global test TARGET_SUBTEST exefullpath sofullpath valid_pid
29
30 set subtest "$test ($pp $arguments)"
31 set subtest [regsub -all $exefullpath $subtest EXEFULLPATH]
32 set subtest [regsub -all $sofullpath $subtest SOFULLPATH]
33 set subtest [regsub -all $valid_pid $subtest VALIDPID]
34 set subtest [regsub -all {0x[0-9a-f]*} $subtest HEXADDR]
35
36 if {$TARGET_SUBTEST != ""} {
37 if {![string match $TARGET_SUBTEST $pp]} {
38 untested $subtest
39 return
40 }
41 }
42
43 if {$exp == ""} {
44 set exp $pp
45 }
46
47 set is_regex 0
48 if {[string match re:* $exp]} {
49 set is_regex 1
50 set exp "^[string range $exp 3 [string length $exp]]$"
51 }
52
53 verbose -log "executing: stap -l $pp $arguments"
54 catch {eval exec stap -l $pp $arguments} out
55 set n 0
56 foreach line [split $out "\n"] {
57 if {$is_regex} {
58 set r [regexp $exp $line]
59 } else {
60 set r [string equal $exp $line]
61 }
62 # Always print line & exp regardless of fail/pass
63 verbose -log "received: \"$line\""
64 verbose -log "expected: \"$exp\""
65 if {!$r} {
66 fail $subtest
67 return
68 }
69 incr n
70 }
71 if {$nlines_exp >= 0} {
72 if {$n != $nlines_exp} {
73 verbose -log "expected $nlines_exp lines, got $n"
74 fail $subtest
75 return
76 }
77 }
78 pass $subtest
79 }
80
81 # Returns the address to vfs_read using stap. NB: we can't use kallsyms because
82 # the addresses might show up as all 0s for non-root.
83 proc get_kernel_function_number {} {
84 if {[catch {exec stap -vvl {kernel.function("vfs_read")} 2>@1} out]} {
85 return 0
86 }
87 if {![regexp -line "^probe vfs_read@.* pc=0x(\[0-9a-f\]+)" $out dummy addr]} {
88 return 0
89 }
90 set addr [string trimleft $addr 0]
91 if {$addr == ""} {
92 return 0
93 }
94 return $addr
95 }
96
97 set kernel_addr [get_kernel_function_number]
98 if {$kernel_addr == 0} {
99 fail "$test (no kernel addr to play with)"
100 }
101
102 set sopath "lib$test.so"
103 set exepath "$test"
104 set pypath ""
105
106 proc test_cleanup {} {
107 global sopath exepath pypath
108 if {[file exists "$sopath"]} { file delete "$sopath" }
109 if {[file exists "$exepath"]} { file delete "$exepath" }
110 if {[file exists "$pypath"]} { file delete "$pypath" }
111 set sopath ""
112 set exepath ""
113 set pypath ""
114 }
115
116 # Compile the shared lib
117 set libflags [sdt_includes]
118 set libflags "$libflags additional_flags=-g"
119 set libflags "$libflags additional_flags=-O"
120 set libflags "$libflags additional_flags=-fPIC"
121 set libflags "$libflags additional_flags=-shared"
122 set libflags "$libflags additional_flags=-DLISTING_MODE_LIB"
123 set res [target_compile $testpath/$test.c $sopath executable $libflags]
124 if { $res == "" } {
125 pass "$test library compile"
126 } else {
127 fail "$test library compile: $res"
128 test_cleanup
129 }
130
131 # Compile the executable
132 set exeflags [sdt_includes]
133 set exeflags "$exeflags additional_flags=-g"
134 set exeflags "$exeflags additional_flags=-O"
135 set exeflags "$exeflags additional_flags=-l$test"
136 set exeflags "$exeflags additional_flags=-Wl,-rpath,[pwd]"
137 set exeflags "$exeflags additional_flags=-L."
138 set exeflags "$exeflags additional_flags=-DLISTING_MODE_MAIN"
139 set res [target_compile $testpath/$test.c $exepath executable $exeflags]
140 if { $res == "" } {
141 pass "$test exe compile"
142 } else {
143 fail "$test exe compile: $res"
144 test_cleanup
145 }
146 # PR6897: need a valid pid when trying to list probes in the form process(PID).*
147 spawn ./$exepath
148 set valid_pid [exp_pid -i $spawn_id]
149
150 # Copy the python test file.
151 set pypath "${test}.py"
152 # Notice we are using the tcl 'exec' command redirection of '2>@1',
153 # which is equivalent to the shell's '2>&1'.
154 if {[catch {exec cp ${testpath}/${pypath} . 2>@1} out]} {
155 verbose -log "python cp failure: $out"
156 }
157
158 proc test_cleanup2 {} {
159 global valid_pid
160 kill -INT -$valid_pid 2
161 catch { close }; catch { wait }
162 }
163
164 # Returns the address to main in compiled executable using stap
165 proc get_process_function_number {} {
166 global exepath
167
168 if {[catch {exec stap -vvl "process(\"$exepath\").function(\"main\")" 2>@1} out]} {
169 return 0
170 }
171 if {![regexp -line "^probe main@.* pc=0x(\[0-9a-f\]+)" $out dummy addr]} {
172 return 0
173 }
174 set addr [string trimleft $addr 0]
175 if {$addr == ""} {
176 return 0
177 }
178 return $addr
179 }
180
181 set process_addr [get_process_function_number]
182 if {$process_addr == 0} {
183 fail "$test (no process addr to play with)"
184 }
185
186 # Returns the address to libfoo in compiled library using stap
187 proc get_library_function_number {} {
188 global exepath sopath
189
190 if {[catch {exec stap -vvl "process(\"$exepath\").library(\"$sopath\").function(\"libfoo\")" 2>@1} out]} {
191 return 0
192 }
193 if {![regexp -line "^probe libfoo@.* pc=0x(\[0-9a-f\]+)" $out dummy addr]} {
194 return 0
195 }
196 set addr [string trimleft $addr 0]
197 if {$addr == ""} {
198 return 0
199 }
200 return $addr
201 }
202
203 set library_addr [get_library_function_number]
204 if {$library_addr == 0} {
205 fail "$test (no library addr to play with)"
206 }
207
208 set exefullpath [exec readlink -f $exepath]
209 set sofullpath [exec readlink -f $sopath]
210
211 # Runs stap_list with variations in the way the executable is specified.
212 # Varies the -c command as well as the process("path").
213 proc stap_list_cmd {pp {exp ""} {nlines_exp 1} {arguments ""}} {
214 global exepath exefullpath
215
216 # Vary -c
217 stap_list $pp $exp $nlines_exp "$arguments -c $exepath"
218 stap_list $pp $exp $nlines_exp "$arguments -c ./$exepath"
219 stap_list $pp $exp $nlines_exp "$arguments -c $exefullpath"
220
221 # Vary process(path)
222 set pp_simple [string map "process process(\"$exepath\")" $pp]
223 stap_list $pp_simple $exp $nlines_exp $arguments
224 set pp_rel [string map "process process(\"./$exepath\")" $pp]
225 stap_list $pp_rel $exp $nlines_exp $arguments
226 set pp_abs [string map "process process(\"$exefullpath\")" $pp]
227 stap_list $pp_abs $exp $nlines_exp $arguments
228 set pp_wild [string map "process process(\"*$exepath\")" $pp]
229 stap_list $pp_wild $exp $nlines_exp $arguments
230 }
231
232 # Runs stap_list_cmd with variations in the way the library is specified
233 proc stap_list_cmd_lib {pp {exp ""} {nlines_exp 1} {arguments ""}} {
234 global sopath sofullpath
235
236 set pp_simple [string map "sopath $sopath" $pp]
237 stap_list_cmd $pp_simple $exp $nlines_exp $arguments
238 set pp_rel [string map "sopath ./$sopath" $pp]
239 stap_list_cmd $pp_rel $exp $nlines_exp $arguments
240 set pp_abs [string map "sopath $sofullpath" $pp]
241 stap_list_cmd $pp_abs $exp $nlines_exp $arguments
242 set pp_wild [string map "sopath *$sopath" $pp]
243 stap_list_cmd $pp_wild $exp $nlines_exp $arguments
244 }
245
246 # Initialize the list of probe types to test, using --dump-probe-types
247 if {[catch {exec stap --dump-probe-types} out]} {
248 verbose -log "stap --dump-probe-types output: $out"
249 fail "$test (can't get probe list)"
250 return
251 }
252
253 set all_probe_types [split $out "\n"]
254
255 # Removes the given probe type from the list
256 proc testing_probe {probe_type} {
257 global test all_probe_types
258
259 # Find it
260 set idx [lsearch $all_probe_types $probe_type]
261 if {$idx < 0} {
262 fail "$test (probe type $probe_type not in list)"
263 return
264 }
265
266 # Remove from list
267 set all_probe_types [lreplace $all_probe_types $idx $idx]
268
269 # If it's a process. probe, also remove the process(string) version:
270 if {[string match process\.* $probe_type]} {
271 set probe_type [string map "process. process(string)." $probe_type]
272 testing_probe $probe_type
273 }
274 }
275
276 # Reports all probe types in the list that haven't been tested
277 proc report_untested_probes {} {
278 global test all_probe_types
279
280 foreach probe_type $all_probe_types {
281 switch $probe_type {
282
283 java(number).class(string).method(string) -
284 java(number).class(string).method(string).return -
285 java(string).class(string).method(string) -
286 java(string).class(string).method(string).return
287 {
288 if {![java_p]} {
289 setup_kfail JAVA *-*-*
290 }
291 }
292
293 python2.module(string).function(string) -
294 python2.module(string).function(string).call -
295 python2.module(string).function(string).return
296 {
297 if {![python2_p]} {
298 setup_kfail PYTHON2 *-*-*
299 }
300 }
301
302 python3.module(string).function(string) -
303 python3.module(string).function(string).call -
304 python3.module(string).function(string).return
305 {
306 if {![python3_p]} {
307 setup_kfail PYTHON3 *-*-*
308 }
309 }
310
311 kernel.data(number).length(number).rw -
312 kernel.data(number).length(number).write -
313 kernel.data(number).rw -
314 kernel.data(number).write -
315 kernel.data(string).rw -
316 kernel.data(string).write
317 {
318 if {![hwbkpt_probes_p]} {
319 setup_kfail HW_BKPT *-*-*
320 }
321 }
322
323 kernel.function(string).callee(string) -
324 kernel.function(string).callee(string).call -
325 kernel.function(string).callee(string).return -
326 kernel.function(string).callees -
327 kernel.function(string).callees(number)
328 {
329 if {![callee_probes_p]} {
330 setup_kfail CALLEE *-*-*
331 }
332 }
333
334 kernel.function(string).inline
335 {
336 # Not easy to reliably test on all kernels
337 setup_kfail KERNEL_INLINE *-*-*
338 }
339
340 kernel.function(string).label(string)
341 {
342 # Not easy to reliably test on all kernels
343 setup_kfail KERNEL_LABEL *-*-*
344 }
345
346 kernel.mark(string) -
347 kernel.mark(string).format(string)
348 {
349 # Can only be tested on older kernels
350 # XXX: detect older kernel and test there, otherwise skip
351 setup_kfail KERNEL_MARK *-*-*
352 }
353
354 kprobe.module(string).function(string) -
355 kprobe.module(string).function(string).call -
356 kprobe.module(string).function(string).return -
357 kprobe.module(string).function(string).return.maxactive(number)
358 {
359 # Not easy to reliably test on all kernels
360 setup_kfail KPROBE_MODULE *-*-*
361 }
362
363 module(string).function(number) -
364 module(string).function(number).call -
365 module(string).function(number).exported -
366 module(string).function(number).return -
367 module(string).function(number).return.maxactive(number) -
368 module(string).function(string) -
369 module(string).function(string).call -
370 module(string).function(string).callee(string) -
371 module(string).function(string).callee(string).call -
372 module(string).function(string).callee(string).return -
373 module(string).function(string).callees -
374 module(string).function(string).callees(number) -
375 module(string).function(string).exported -
376 module(string).function(string).inline -
377 module(string).function(string).label(string) -
378 module(string).function(string).return -
379 module(string).function(string).return.maxactive(number) -
380 module(string).statement(number) -
381 module(string).statement(number).nearest -
382 module(string).statement(string) -
383 module(string).statement(string).nearest
384 {
385 # Not easy to reliably test on all kernels
386 setup_kfail MODULE *-*-*
387 }
388
389 perf.type(number).config(number) -
390 perf.type(number).config(number).counter(string) -
391 perf.type(number).config(number).process -
392 perf.type(number).config(number).process(string) -
393 perf.type(number).config(number).process(string).counter(string) -
394 perf.type(number).config(number).sample(number) -
395 perf.type(number).config(number).hz(number)
396 {
397 if {![perf_probes_p]} {
398 setup_kfail PERF *-*-*
399 }
400 }
401
402 process.function(string).callee(string) -
403 process.function(string).callee(string).call -
404 process.function(string).callee(string).return -
405 process.function(string).callees -
406 process.function(string).callees(number) -
407 process(string).function(string).callee(string) -
408 process(string).function(string).callee(string).call -
409 process(string).function(string).callee(string).return -
410 process(string).function(string).callees -
411 process(string).function(string).callees(number) -
412 process(number).function(string).callee(string) -
413 process(number).function(string).callee(string).call -
414 process(number).function(string).callee(string).return -
415 process(number).function(string).callees -
416 process(number).function(string).callees(number)
417 {
418 if {![callee_probes_p]} {
419 setup_kfail CALLEE *-*-*
420 } elseif {![uprobes_p]} {
421 setup_kfail UPROBES *-*-*
422 }
423 }
424
425 process.function(string).label(string) -
426 process.library(string).function(string).label(string) -
427 process(number).function(string).label(string) -
428 process(string).function(string).label(string) -
429 process(string).library(string).function(string).label(string)
430 {
431 if {![uprobes_p]} {
432 setup_kfail UPROBES *-*-*
433 }
434 }
435
436 process.library(string).function(string).callee(string) -
437 process.library(string).function(string).callee(string).call -
438 process.library(string).function(string).callee(string).return -
439 process.library(string).function(string).callees -
440 process.library(string).function(string).callees(number) -
441 process(string).library(string).function(string).callee(string) -
442 process(string).library(string).function(string).callee(string).call -
443 process(string).library(string).function(string).callee(string).return -
444 process(string).library(string).function(string).callees -
445 process(string).library(string).function(string).callees(number)
446 {
447 if {![callee_probes_p]} {
448 setup_kfail CALLEE *-*-*
449 } elseif {![uprobes_p]} {
450 setup_kfail UPROBES *-*-*
451 }
452 }
453
454 process.library(string).plt -
455 process.library(string).plt.return -
456 process.library(string).plt(string) -
457 process.library(string).plt(string).return -
458 process(string).library(string).plt -
459 process(string).library(string).plt.return -
460 process(string).library(string).plt(string) -
461 process(string).library(string).plt(string).return -
462 process.plt -
463 process.plt.return -
464 process.plt(string) -
465 process.plt(string).return -
466 process(string).plt -
467 process(string).plt.return -
468 process(string).plt(string) -
469 process(string).plt(string).return -
470 process(number).plt -
471 process(number).plt.return -
472 process(number).plt(string) -
473 process(number).plt(string).return
474 {
475 if {![plt_probes_p]} {
476 setup_kfail PLT *-*-*
477 } elseif {![uprobes_p]} {
478 setup_kfail UPROBES *-*-*
479 }
480 }
481
482 process(number).statement(number).absolute -
483 process(number).statement(number).absolute.return
484 {
485 setup_kfail INODE_UPROBES *-*-*
486 }
487
488 timer.profile.tick
489 {
490 setup_kfail TIMER_HOOK *-*-*
491 }
492 }
493
494 fail "$test (untested probe type: $probe_type)"
495 }
496 }
497
498 ###############################################
499 # List retrieved from stap --dump-probe-types #
500 ###############################################
501
502 testing_probe {begin}
503
504 stap_list {begin}
505
506 testing_probe {begin(number)}
507
508 stap_list {begin(-1)}
509 stap_list {begin(0)}
510 stap_list {begin(1)}
511
512 testing_probe {end}
513
514 stap_list {end}
515
516 testing_probe {end(number)}
517
518 stap_list {end(-1)}
519 stap_list {end(0)}
520 stap_list {end(1)}
521
522 testing_probe {error}
523
524 stap_list {error}
525
526 testing_probe {error(number)}
527
528 stap_list {error(-1)}
529 stap_list {error(0)}
530 stap_list {error(1)}
531
532 if {[java_p]} {
533
534 testing_probe {java(number).class(string).method(string)}
535
536 stap_list {java(123).class("MyClass").method("MyMethod")}
537
538 testing_probe {java(number).class(string).method(string).return}
539
540 stap_list {java(123).class("MyClass").method("MyMethod").return}
541
542 testing_probe {java(string).class(string).method(string)}
543
544 stap_list {java("JavaProc").class("MyClass").method("MyMethod")}
545
546 testing_probe {java(string).class(string).method(string).return}
547
548 stap_list {java("JavaProc").class("MyClass").method("MyMethod").return}
549 }
550
551 if {[python2_p]} {
552
553 testing_probe {python2.module(string).function(string)}
554
555 # Function with no line number should expand with a '.call' added
556 # (and a line number).
557 stap_list {python2.module("listing_mode").function("MyFunction")} \
558 {re:python2.module\("listing_mode"\).function\("MyFunction@listing_mode.py:[0-9]+"\).call}
559
560 # Globby function.
561 stap_list {python2.module("listing_mode").function("My*")} \
562 {re:python2.module\("listing_mode"\).function\("MyFunction@listing_mode.py:[0-9]+"\).call}
563
564 # We could test filename wildcards here, but we'll skip them
565 # because they take a long time.
566 #stap_list {python2.module("listing_mode").function("MyFunction@*")} \
567 # {re:python2.module\("listing_mode"\).function\("MyFunction@listing_mode.py:[0-9]+"\).call}
568
569 # Function with a line number.
570 stap_list {python2.module("listing_mode").function("MyFunction@listing_mode.py:*")} \
571 {re:python2.module\("listing_mode"\).function\("MyFunction@[^:]+/listing_mode.py:[0-9]+"\)}
572
573 testing_probe {python2.module(string).function(string).return}
574
575 stap_list {python2.module("listing_mode").function("MyFunction").return} \
576 {re:python2.module\("listing_mode"\).function\("MyFunction@listing_mode.py:[0-9]+"\).return}
577
578 testing_probe {python2.module(string).function(string).call}
579
580 # Basic call probe
581 stap_list {python2.module("listing_mode").function("MyFunction").call} \
582 {re:python2.module\("listing_mode"\).function\("MyFunction@listing_mode.py:[0-9]+"\).call}
583
584 # Globby function.
585 stap_list {python2.module("listing_mode").function("*").call} \
586 {re:python2.module\("listing_mode"\).function\(".+@listing_mode.py:[0-9]+"\).call} -1
587 }
588
589 if {[python3_p]} {
590
591 testing_probe {python3.module(string).function(string)}
592
593 # Function with no line number should expand with a '.call' added
594 # (and a line number).
595 stap_list {python3.module("listing_mode").function("MyFunction")} \
596 {re:python3.module\("listing_mode"\).function\("MyFunction@listing_mode.py:[0-9]+"\).call}
597
598 # Globby function.
599 stap_list {python3.module("listing_mode").function("My*")} \
600 {re:python3.module\("listing_mode"\).function\("MyFunction@listing_mode.py:[0-9]+"\).call}
601
602 # We could test filename wildcards here, but we'll skip them
603 # because they take a long time.
604 #stap_list {python3.module("listing_mode").function("MyFunction@*")} \
605 # {re:python3.module\("listing_mode"\).function\("MyFunction@listing_mode.py:[0-9]+"\).call}
606
607 # Function with a line number.
608 stap_list {python3.module("listing_mode").function("MyFunction@listing_mode.py:*")} \
609 {re:python3.module\("listing_mode"\).function\("MyFunction@[^:]+/listing_mode.py:[0-9]+"\)}
610
611 testing_probe {python3.module(string).function(string).return}
612
613 stap_list {python3.module("listing_mode").function("MyFunction").return} \
614 {re:python3.module\("listing_mode"\).function\("MyFunction@listing_mode.py:[0-9]+"\).return}
615
616 testing_probe {python3.module(string).function(string).call}
617
618 # Basic call probe
619 stap_list {python3.module("listing_mode").function("MyFunction").call} \
620 {re:python3.module\("listing_mode"\).function\("MyFunction@listing_mode.py:[0-9]+"\).call}
621
622 # Globby function.
623 stap_list {python3.module("listing_mode").function("*").call} \
624 {re:python3.module\("listing_mode"\).function\(".+@listing_mode.py:[0-9]+"\).call} -1
625 }
626
627 if {[hwbkpt_probes_p]} {
628
629 testing_probe {kernel.data(number).length(number).rw}
630
631 stap_list {kernel.data(0x123).length(456).rw}
632
633 testing_probe {kernel.data(number).length(number).write}
634
635 stap_list {kernel.data(0x123).length(456).write}
636
637 testing_probe {kernel.data(number).rw}
638
639 stap_list {kernel.data(0x123).rw}
640
641 testing_probe {kernel.data(number).write}
642
643 stap_list {kernel.data(0x123).write}
644
645 testing_probe {kernel.data(string).rw}
646
647 stap_list {kernel.data("abcd").rw}
648
649 testing_probe {kernel.data(string).write}
650
651 stap_list {kernel.data("abcd").write}
652 }
653
654 if {$kernel_addr != 0} {
655
656 testing_probe {kernel.function(number)}
657
658 stap_list "kernel.function(0x$kernel_addr)"
659
660 testing_probe {kernel.function(number).call}
661
662 stap_list "kernel.function(0x$kernel_addr).call"
663
664 testing_probe {kernel.function(number).exported}
665
666 stap_list "kernel.function(0x$kernel_addr).exported"
667
668 testing_probe {kernel.function(number).return}
669
670 stap_list "kernel.function(0x$kernel_addr).return"
671
672 testing_probe {kernel.function(number).return.maxactive(number)}
673
674 stap_list "kernel.function(0x$kernel_addr).return.maxactive(0)"
675
676 stap_list "kernel.function(0x$kernel_addr).return.maxactive(1)"
677
678 stap_list "kernel.function(0x$kernel_addr).return.maxactive(100)"
679 }
680
681 testing_probe {kernel.function(string)}
682
683 # Simple function
684 stap_list {kernel.function("vfs_read")} \
685 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\)}
686
687 # Globby function
688 stap_list {kernel.function("vfs_rea\[d\]")} \
689 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\)}
690
691 # With filename wildcard
692 stap_list {kernel.function("vfs_read@*")} \
693 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\)}
694
695 testing_probe {kernel.function(string).call}
696
697 stap_list {kernel.function("vfs_read").call} \
698 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\).call}
699
700 if {[callee_probes_p]} {
701
702 testing_probe {kernel.function(string).callee(string)}
703
704 stap_list {kernel.function("vfs_read").callee("*")} \
705 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\).callee\("[^@]+@[^:]+:[0-9]+"\)} {-1}
706
707 testing_probe {kernel.function(string).callee(string).return}
708
709 stap_list {kernel.function("vfs_read").callee("*").return} \
710 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\).callee\("[^@]+@[^:]+:[0-9]+"\).return} {-1}
711
712 testing_probe {kernel.function(string).callee(string).call}
713
714 stap_list {kernel.function("vfs_read").callee("*").call} \
715 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\).callee\("[^@]+@[^:]+:[0-9]+"\).call} {-1}
716
717 testing_probe {kernel.function(string).callees}
718
719 stap_list {kernel.function("vfs_read").callees} \
720 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\).callee\("[^@]+@[^:]+:[0-9]+"\)} {-1}
721
722 testing_probe {kernel.function(string).callees(number)}
723
724 stap_list {kernel.function("vfs_read").callees(1)} \
725 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\).callee\("[^@]+@[^:]+:[0-9]+"\)} {-1}
726
727 stap_list {kernel.function("vfs_read").callees(2)} \
728 {re:kernel.function\("[^@]+@[^:]+:[0-9]+"\).callee\("[^@]+@[^:]+:[0-9]+"\)} {-1}
729 }
730
731 testing_probe {kernel.function(string).exported}
732
733 stap_list {kernel.function("vfs_read").exported} \
734 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\).exported}
735
736 testing_probe {kernel.function(string).return}
737
738 stap_list {kernel.function("vfs_read").return} \
739 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\).return}
740
741 testing_probe {kernel.function(string).return.maxactive(number)}
742
743 stap_list {kernel.function("vfs_read").return.maxactive(0)} \
744 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\).return.maxactive\(0\)}
745
746 stap_list {kernel.function("vfs_read").return.maxactive(1)} \
747 {re:kernel.function\("vfs_read@[^:]+:[0-9]+"\).return.maxactive\(1\)}
748
749 if {$kernel_addr != 0} {
750
751 testing_probe {kernel.statement(number)}
752
753 stap_list "kernel.statement(0x$kernel_addr)"
754
755 testing_probe {kernel.statement(number).nearest}
756
757 stap_list "kernel.statement(0x$kernel_addr).nearest"
758
759 testing_probe {kernel.statement(number).absolute}
760
761 stap_list "kernel.statement(0x$kernel_addr).absolute" \
762 "kernel.statement(0x$kernel_addr).absolute" {1} {-g}
763 }
764
765 testing_probe {kernel.statement(string)}
766
767 stap_list {kernel.statement("vfs_read")} \
768 {re:kernel.statement\("vfs_read@[^:]+:[0-9]+"\)}
769
770 testing_probe {kernel.statement(string).nearest}
771
772 stap_list {kernel.statement("vfs_read").nearest} \
773 {re:kernel.statement\("vfs_read@[^:]+:[0-9]+"\).nearest}
774
775 testing_probe {kernel.trace(string)}
776
777 # Check for TRACE_SYSTEM support
778 stap_list {kernel.trace("sched:sched_switch")}
779
780 stap_list {kernel.trace("sched_switch")} \
781 {kernel.trace("sched:sched_switch")}
782
783 stap_list {kernel.trace("s*")} \
784 {re:kernel.trace\("[^:]*:s[a-zA-Z0-9_]*"\)} {-1}
785
786
787 testing_probe {kprobe.function(string)}
788
789 stap_list {kprobe.function("vfs_read")}
790
791 testing_probe {kprobe.function(string).call}
792
793 stap_list {kprobe.function("vfs_read").call}
794
795 testing_probe {kprobe.function(string).return}
796
797 stap_list {kprobe.function("vfs_read").return}
798
799 testing_probe {kprobe.function(string).return.maxactive(number)}
800
801 stap_list {kprobe.function("vfs_read").return.maxactive(0)}
802 stap_list {kprobe.function("vfs_read").return.maxactive(1)}
803
804 if {$kernel_addr != 0} {
805
806 testing_probe {kprobe.statement(number).absolute}
807
808 stap_list "kprobe.statement(0x$kernel_addr).absolute" \
809 "kprobe.statement(0x$kernel_addr).absolute" {1} {-g}
810 }
811
812 testing_probe {netfilter.hook(string).pf(string)}
813
814 stap_list {netfilter.hook("NF_INET_PRE_ROUTING").pf("NFPROTO_IPV4")}
815 stap_list {netfilter.hook("STRING1").pf("STRING2")} "" {1} {-g}
816
817 testing_probe {netfilter.hook(string).pf(string).priority(string)}
818
819 stap_list {netfilter.hook("NF_INET_PRE_ROUTING").pf("NFPROTO_IPV4").priority("255")}
820 stap_list {netfilter.hook("STRING1").pf("STRING2").priority("STRING3")} "" {1} {-g}
821
822 testing_probe {netfilter.pf(string).hook(string)}
823
824 stap_list {netfilter.pf("NFPROTO_IPV4").hook("NF_INET_PRE_ROUTING")}
825 stap_list {netfilter.pf("STRING1").hook("STRING2")} "" {1} {-g}
826
827 testing_probe {netfilter.pf(string).hook(string).priority(string)}
828
829 stap_list {netfilter.pf("NFPROTO_IPV4").hook("NF_INET_PRE_ROUTING").priority("255")}
830 stap_list {netfilter.pf("STRING1").hook("STRING2").priority("STRING3")} "" {1} {-g}
831
832 testing_probe {never}
833
834 stap_list {never}
835
836 if {[perf_probes_p]} {
837
838 testing_probe {perf.type(number).config(number)}
839
840 stap_list {perf.type(1).config(1)}
841
842 testing_probe {perf.type(number).config(number).counter(string)}
843
844 stap_list {perf.type(1).config(1).counter("string")}
845
846 testing_probe {perf.type(number).config(number).process}
847
848 stap_list {perf.type(1).config(1).process} \
849 {perf.type(1).config(1).process} {1} {-c ls}
850
851 testing_probe {perf.type(number).config(number).process(string)}
852
853 stap_list {perf.type(1).config(1).process("string")}
854
855 testing_probe {perf.type(number).config(number).process(string).counter(string)}
856
857 stap_list {perf.type(1).config(1).process("string").counter("string")}
858
859 testing_probe {perf.type(number).config(number).sample(number)}
860
861 stap_list {perf.type(1).config(1).sample(1000)}
862
863 testing_probe {perf.type(number).config(number).hz(number)}
864
865 stap_list {perf.type(1).config(1).hz(1000)}
866 }
867
868 testing_probe {process.begin}
869
870 stap_list {process.begin}
871
872 testing_probe {process.end}
873
874 stap_list {process.end}
875
876 if {$exepath != ""} {
877
878 if {$process_addr != 0} {
879
880 testing_probe {process.function(number)}
881
882 stap_list_cmd "process.function(0x$process_addr)" \
883 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(0x\[a-f0-9\]+\\\)"
884
885 testing_probe {process.function(number).call}
886
887 stap_list_cmd "process.function(0x$process_addr).call" \
888 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(0x\[a-f0-9\]+\\\)\\\.call"
889
890 testing_probe {process.function(number).exported}
891
892 stap_list_cmd "process.function(0x$process_addr).exported" \
893 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(0x\[a-f0-9\]+\\\)\\\.exported"
894
895 testing_probe {process.function(number).return}
896
897 stap_list_cmd "process.function(0x$process_addr).return" \
898 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(0x\[a-f0-9\]+\\\)\\\.return"
899 }
900
901 testing_probe {process.function(string)}
902
903 stap_list_cmd "process.function(\"foo\")" \
904 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)"
905
906 testing_probe {process.function(string).call}
907
908 stap_list_cmd "process.function(\"foo\").call" \
909 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)\\\.call"
910
911 if {[uprobes_p] && [callee_probes_p]} {
912
913 testing_probe {process.function(string).callee(string)}
914
915 stap_list_cmd "process.function(\"foo\").callee(\"bar\")" \
916 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)\\\.callee\\\(\"bar@\[^:\]+:16\"\\\)"
917
918 testing_probe {process.function(string).callee(string).call}
919
920 stap_list_cmd "process.function(\"foo\").callee(\"bar\").call" \
921 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)\\\.callee\\\(\"bar@\[^:\]+:16\"\\\)\\\.call"
922
923 testing_probe {process.function(string).callee(string).return}
924
925 stap_list_cmd "process.function(\"foo\").callee(\"bar\").return" \
926 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)\\\.callee\\\(\"bar@\[^:\]+:16\"\\\)\\\.return"
927
928 testing_probe {process.function(string).callees}
929
930 stap_list_cmd "process.function(\"foo\").callees" \
931 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)\\\.callee\\\(\"bar@\[^:\]+:16\"\\\)"
932
933 testing_probe {process.function(string).callees(number)}
934
935 stap_list_cmd "process.function(\"foo\").callees(1)" \
936 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)\\\.callee\\\(\"bar@\[^:\]+:16\"\\\)"
937
938 stap_list_cmd "process.function(\"foo\").callees(2)" \
939 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"(foo|bar)@\[^:\]+:\[0-9\]+\"\\\)\\\.callee\\\(\"(bar|inln)@\[^:\]+:\[0-9\]+\"\\\)" {2}
940 }
941
942 testing_probe {process.function(string).exported}
943
944 stap_list_cmd "process.function(\"main\").exported" \
945 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"main@\[^:\]+:29\"\\\)\\\.exported"
946
947 testing_probe {process.function(string).inline}
948
949 stap_list_cmd "process.function(\"inln\").inline" \
950 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"inln@\[^:\]+:11\"\\\)\\\.inline"
951
952 if {[uprobes_p]} {
953
954 testing_probe {process.function(string).label(string)}
955
956 stap_list_cmd "process.function(\"main\").label(\"main_label\")" \
957 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"main@\[^:\]+:33\"\\\)\\\.label\\\(\"main_label\"\\\)"
958
959 stap_list_cmd "process.function(\"main\").label(\"main_labe?\")" \
960 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"main@\[^:\]+:33\"\\\)\\\.label\\\(\"main_label\"\\\)"
961
962 stap_list_cmd "process.function(\"main@$test.c:33\").label(\"main_label\")" \
963 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"main@\[^:\]+:33\"\\\)\\\.label\\\(\"main_label\"\\\)"
964
965 stap_list_cmd "process.function(\"main@$test.c:33\").label(\"main_labe?\")" \
966 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"main@\[^:\]+:33\"\\\)\\\.label\\\(\"main_label\"\\\)"
967 }
968
969 testing_probe {process.function(string).return}
970
971 stap_list_cmd "process.function(\"main\").return" \
972 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"main@\[^:\]+:29\"\\\)\\\.return"
973
974 if {$library_addr != 0} {
975
976 testing_probe {process.library(string).function(number)}
977
978 stap_list_cmd_lib "process.library(\"sopath\").function(0x$library_addr)" \
979 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(0x\[0-9a-f\]+\\\)"
980
981 testing_probe {process.library(string).function(number).call}
982
983 stap_list_cmd_lib "process.library(\"sopath\").function(0x$library_addr).call" \
984 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(0x\[0-9a-f\]+\\\)\\\.call"
985
986 testing_probe {process.library(string).function(number).exported}
987
988 stap_list_cmd_lib "process.library(\"sopath\").function(0x$library_addr).exported" \
989 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(0x\[0-9a-f\]+\\\)\\\.exported"
990
991 testing_probe {process.library(string).function(number).return}
992
993 stap_list_cmd_lib "process.library(\"sopath\").function(0x$library_addr).return" \
994 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(0x\[0-9a-f\]+\\\)\\\.return"
995 }
996
997 testing_probe {process.library(string).function(string)}
998
999 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo\")" \
1000 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:55\"\\\)"
1001
1002 testing_probe {process.library(string).function(string).call}
1003
1004 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo\").call" \
1005 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:55\"\\\)\\\.call"
1006
1007 if {[uprobes_p] && [callee_probes_p]} {
1008
1009 testing_probe {process.library(string).function(string).callee(string)}
1010
1011 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo\").callee(\"libbar\")" \
1012 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:55\"\\\)\\\.callee\\\(\"libbar@\[^:\]+:48\"\\\)"
1013
1014 testing_probe {process.library(string).function(string).callee(string).call}
1015
1016 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo\").callee(\"libbar\").call" \
1017 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:55\"\\\)\\\.callee\\\(\"libbar@\[^:\]+:48\"\\\)\\\.call"
1018
1019 testing_probe {process.library(string).function(string).callee(string).return}
1020
1021 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo\").callee(\"libbar\").return" \
1022 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:55\"\\\)\\\.callee\\\(\"libbar@\[^:\]+:48\"\\\)\\\.return"
1023
1024 testing_probe {process.library(string).function(string).callees}
1025
1026 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo\").callees" \
1027 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:55\"\\\)\\\.callee\\\(\"libbar@\[^:\]+:48\"\\\)"
1028
1029 testing_probe {process.library(string).function(string).callees(number)}
1030
1031 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo\").callees(1)" \
1032 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:55\"\\\)\\\.callee\\\(\"libbar@\[^:\]+:48\"\\\)"
1033
1034 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo\").callees(2)" \
1035 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"lib(foo|bar)@\[^:\]+:(55|48)\"\\\)\\\.callee\\\(\"(libbar|libinln)@\[^:\]+:(48|43)\"\\\)" {2}
1036 }
1037
1038 testing_probe {process.library(string).function(string).exported}
1039
1040 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo\").exported" \
1041 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:55\"\\\)\\\.exported"
1042
1043 testing_probe {process.library(string).function(string).inline}
1044
1045 stap_list_cmd_lib "process.library(\"sopath\").function(\"libinln\").inline" \
1046 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libinln@\[^:\]+:43\"\\\)\\\.inline"
1047
1048 if {[uprobes_p]} {
1049
1050 testing_probe {process.library(string).function(string).label(string)}
1051
1052 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo\").label(\"lib_label\")" \
1053 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:58\"\\\)\\\.label\\\(\"lib_label\"\\\)"
1054
1055 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo\").label(\"lib_labe?\")" \
1056 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:58\"\\\)\\\.label\\\(\"lib_label\"\\\)"
1057
1058 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo@$test.c:58\").label(\"lib_label\")" \
1059 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:58\"\\\)\\\.label\\\(\"lib_label\"\\\)"
1060
1061 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo@$test.c:58\").label(\"lib_labe?\")" \
1062 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:58\"\\\)\\\.label\\\(\"lib_label\"\\\)"
1063 }
1064
1065 testing_probe {process.library(string).function(string).return}
1066
1067 stap_list_cmd_lib "process.library(\"sopath\").function(\"libfoo\").return" \
1068 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.function\\\(\"libfoo@\[^:\]+:55\"\\\)\\\.return"
1069
1070 testing_probe {process.library(string).mark(string)}
1071
1072 stap_list_cmd_lib "process.library(\"sopath\").mark(\"mark\")" \
1073 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.mark\\\(\"mark\"\\\)"
1074
1075 if {[plt_probes_p]} {
1076
1077 testing_probe {process.library(string).plt}
1078
1079 stap_list_cmd_lib "process.library(\"sopath\").plt" \
1080 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.plt\\\(\"\[^\"\]+\"\\\)" {-1}
1081
1082 testing_probe {process.library(string).plt.return}
1083
1084 stap_list_cmd_lib "process.library(\"sopath\").plt.return" \
1085 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.plt\\\(\"\[^\"\]+\"\\\).return" {-1}
1086
1087 testing_probe {process.library(string).plt(string)}
1088
1089 stap_list_cmd_lib "process.library(\"sopath\").plt(\"libbar\")" \
1090 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.plt\\\(\"libbar\"\\\)"
1091
1092 stap_list_cmd_lib "process.library(\"sopath\").plt(\"libba?\")" \
1093 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.plt\\\(\"libbar\"\\\)"
1094
1095 stap_list_cmd_lib "process.library(\"sopath\").plt(\"\\\[lp\\\]*\")" \
1096 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.plt\\\(\"(libbar|printf)\"\\\)" {-1}
1097
1098 testing_probe {process.library(string).plt(string).return}
1099
1100 stap_list_cmd_lib "process.library(\"sopath\").plt(\"libbar\").return" \
1101 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.plt\\\(\"libbar\"\\\).return"
1102
1103 stap_list_cmd_lib "process.library(\"sopath\").plt(\"libba?\").return" \
1104 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.plt\\\(\"libbar\"\\\).return"
1105
1106 stap_list_cmd_lib "process.library(\"sopath\").plt(\"\\\[lp\\\]*\").return" \
1107 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.plt\\\(\"(libbar|printf)\"\\\).return" {-1}
1108 }
1109
1110 testing_probe {process.library(string).provider(string).mark(string)}
1111
1112 stap_list_cmd_lib "process.library(\"sopath\").provider(\"lib\").mark(\"mark\")" \
1113 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.provider\\\(\"lib\"\\\)\\\.mark\\\(\"mark\"\\\)"
1114
1115 if {$library_addr != 0} {
1116
1117 testing_probe {process.library(string).statement(number)}
1118
1119 stap_list_cmd_lib "process.library(\"sopath\").statement(0x$library_addr)" \
1120 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(0x$library_addr\\\)"
1121
1122 testing_probe {process.library(string).statement(number).nearest}
1123
1124 stap_list_cmd_lib "process.library(\"sopath\").statement(0x$library_addr).nearest" \
1125 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(0x$library_addr\\\)\\\.nearest"
1126 }
1127
1128 testing_probe {process.library(string).statement(string)}
1129
1130 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libinln\")" \
1131 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libinln@\[^:\]+:43\"\\\)"
1132
1133 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libfoo\")" \
1134 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libfoo@\[^:\]+:55\"\\\)"
1135
1136 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libfoo@$test.c\")" \
1137 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libfoo@\[^:\]+:55\"\\\)"
1138
1139 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libfoo@$test.c:57\")" \
1140 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libfoo@\[^:\]+:57\"\\\)"
1141
1142 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libfo?@$test.c:57\")" \
1143 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libfoo@\[^:\]+:57\"\\\)"
1144
1145 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libfoo@$test.c+2\")" \
1146 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libfoo@\[^:\]+:57\"\\\)"
1147
1148 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libfoo@$test.c:55-56\")" \
1149 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libfoo@\[^:\]+:\[0-9\]+\"\\\)" {-1}
1150
1151 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libfoo@$test.c:55,55-56\")" \
1152 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libfoo@\[^:\]+:\[0-9\]+\"\\\)" {-1}
1153
1154 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libfoo@$test.c:*\")" \
1155 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libfoo@\[^:\]+:\[0-9\]+\"\\\)" {-1}
1156
1157 testing_probe {process.library(string).statement(string).nearest}
1158
1159 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libfoo@$test.c:58\").nearest" \
1160 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libfoo@\[^:\]+:58\"\\\).nearest"
1161
1162 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libfoo@$test.c+3\").nearest" \
1163 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libfoo@\[^:\]+:58\"\\\).nearest"
1164
1165 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libfoo@$test.c:55,56\").nearest" \
1166 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libfoo@\[^:\]+:5\[57\]\"\\\).nearest" {2}
1167
1168 stap_list_cmd_lib "process.library(\"sopath\").statement(\"libfoo@$test.c:*\").nearest" \
1169 "re:process\\\(\"$exefullpath\"\\\)\\\.library\\\(\"\[^\"\]*$sopath\"\\\)\\\.statement\\\(\"libfoo@\[^:\]+:\[0-9\]+\"\\\).nearest" {-1}
1170
1171 testing_probe {process.mark(string)}
1172
1173 stap_list_cmd "process.mark(\"mark\")" \
1174 "re:process\\\(\"$exefullpath\"\\\)\\\.mark\\\(\"mark\"\\\)"
1175
1176 if {[plt_probes_p]} {
1177
1178 testing_probe {process.plt}
1179
1180 stap_list_cmd "process.plt" \
1181 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"\[^\"\]+\"\\\)" {-1}
1182
1183
1184 testing_probe {process.plt.return}
1185
1186 stap_list_cmd "process.plt.return" \
1187 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"\[^\"\]+\"\\\).return" {-1}
1188
1189 testing_probe {process.plt(string)}
1190
1191 stap_list_cmd "process.plt(\"libfoo\")" \
1192 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"libfoo\"\\\)"
1193
1194 stap_list_cmd "process.plt(\"libfo?\")" \
1195 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"libfoo\"\\\)"
1196
1197 testing_probe {process.plt(string).return}
1198
1199 stap_list_cmd "process.plt(\"libfoo\").return" \
1200 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"libfoo\"\\\).return"
1201
1202 stap_list_cmd "process.plt(\"libfo?\").return" \
1203 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"libfoo\"\\\).return"
1204
1205 stap_list_cmd "process.plt(\"\\\[lp\\\]*\").return" \
1206 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"(libfoo|printf)\"\\\).return" {-1}
1207 }
1208
1209 testing_probe {process.provider(string).mark(string)}
1210
1211 stap_list_cmd "process.provider(\"main\").mark(\"mark\")" \
1212 "re:process\\\(\"$exefullpath\"\\\)\\\.provider\\\(\"main\"\\\)\\\.mark\\\(\"mark\"\\\)"
1213
1214 if {$process_addr != 0} {
1215
1216 testing_probe {process.statement(number)}
1217
1218 stap_list_cmd "process.statement(0x$process_addr)" \
1219 "process(\"$exefullpath\").statement(0x$process_addr)"
1220
1221 testing_probe {process.statement(number).nearest}
1222
1223 stap_list_cmd "process.statement(0x$process_addr).nearest" \
1224 "process(\"$exefullpath\").statement(0x$process_addr).nearest"
1225 }
1226
1227 testing_probe {process.statement(string)}
1228
1229 stap_list_cmd "process.statement(\"inln\")" \
1230 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"inln@\[^:\]+:11\"\\\)"
1231
1232 stap_list_cmd "process.statement(\"foo\")" \
1233 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:23\"\\\)"
1234
1235 stap_list_cmd "process.statement(\"foo@$test.c\")" \
1236 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:23\"\\\)"
1237
1238 stap_list_cmd "process.statement(\"foo@$test.c:25\")" \
1239 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:25\"\\\)"
1240
1241 stap_list_cmd "process.statement(\"fo?@$test.c:25\")" \
1242 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:25\"\\\)"
1243
1244 stap_list_cmd "process.statement(\"foo@$test.c+2\")" \
1245 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:25\"\\\)"
1246
1247 stap_list_cmd "process.statement(\"foo@$test.c:23-25\")" \
1248 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:\[0-9\]+\"\\\)" {-1}
1249
1250 stap_list_cmd "process.statement(\"foo@$test.c:23,25-26\")" \
1251 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:\[0-9\]+\"\\\)" {-1}
1252
1253 stap_list_cmd "process.statement(\"foo@$test.c:*\")" \
1254 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:\[0-9\]+\"\\\)" {-1}
1255
1256 testing_probe {process.statement(string).nearest}
1257
1258 stap_list_cmd "process.statement(\"foo@$test.c:28\").nearest" \
1259 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:28\"\\\).nearest"
1260
1261 stap_list_cmd "process.statement(\"foo@$test.c+5\").nearest" \
1262 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:28\"\\\).nearest"
1263
1264 stap_list_cmd "process.statement(\"foo@$test.c:23,24\").nearest" \
1265 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:2\[35\]\"\\\).nearest" {2}
1266
1267 stap_list_cmd "process.statement(\"foo@$test.c:*\").nearest" \
1268 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:\[0-9\]+\"\\\).nearest" {-1}
1269 }
1270
1271 testing_probe {process.syscall}
1272
1273 stap_list {process.syscall}
1274
1275 testing_probe {process.syscall.return}
1276
1277 stap_list {process.syscall.return}
1278
1279 testing_probe {process.thread.begin}
1280
1281 stap_list {process.thread.begin}
1282
1283 testing_probe {process.thread.end}
1284
1285 stap_list {process.thread.end}
1286
1287 # All the process(number).* probes. for number, need to use a valid pid
1288 # instead of just 1, so that errors about permissions dont arise.
1289 testing_probe {process(number).begin}
1290
1291 stap_list "process($valid_pid).begin"
1292
1293 testing_probe {process(number).end}
1294
1295 stap_list "process($valid_pid).end"
1296
1297 if {$exepath != ""} {
1298
1299 if {$process_addr != 0} {
1300
1301 testing_probe {process(number).function(number)}
1302
1303 stap_list "process($valid_pid).function(0x$process_addr)" \
1304 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(0x\[a-f0-9\]+\\\)"
1305
1306 testing_probe {process(number).function(number).call}
1307
1308 stap_list "process($valid_pid).function(0x$process_addr).call" \
1309 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(0x\[a-f0-9\]+\\\)\\\.call"
1310
1311 testing_probe {process(number).function(number).exported}
1312
1313 stap_list "process($valid_pid).function(0x$process_addr).exported" \
1314 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(0x\[a-f0-9\]+\\\)\\\.exported"
1315
1316 testing_probe {process(number).function(number).return}
1317
1318 stap_list "process($valid_pid).function(0x$process_addr).return" \
1319 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(0x\[a-f0-9\]+\\\)\\\.return"
1320 }
1321
1322 testing_probe {process(number).function(string)}
1323
1324 stap_list "process($valid_pid).function(\"foo\")" \
1325 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)"
1326
1327 testing_probe {process(number).function(string).call}
1328
1329 stap_list "process($valid_pid).function(\"foo\").call" \
1330 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)\\\.call"
1331
1332 if {[uprobes_p] && [callee_probes_p]} {
1333
1334 testing_probe {process(number).function(string).callee(string)}
1335
1336 stap_list "process($valid_pid).function(\"foo\").callee(\"bar\")" \
1337 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)\\\.callee\\\(\"bar@\[^:\]+:16\"\\\)"
1338
1339 testing_probe {process(number).function(string).callee(string).call}
1340
1341 stap_list "process($valid_pid).function(\"foo\").callee(\"bar\").call" \
1342 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)\\\.callee\\\(\"bar@\[^:\]+:16\"\\\)\\\.call"
1343
1344 testing_probe {process(number).function(string).callee(string).return}
1345
1346 stap_list "process($valid_pid).function(\"foo\").callee(\"bar\").return" \
1347 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)\\\.callee\\\(\"bar@\[^:\]+:16\"\\\)\\\.return"
1348
1349 testing_probe {process(number).function(string).callees}
1350
1351 stap_list "process($valid_pid).function(\"foo\").callees" \
1352 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)\\\.callee\\\(\"bar@\[^:\]+:16\"\\\)"
1353
1354 testing_probe {process(number).function(string).callees(number)}
1355
1356 stap_list "process($valid_pid).function(\"foo\").callees(1)" \
1357 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"foo@\[^:\]+:23\"\\\)\\\.callee\\\(\"bar@\[^:\]+:16\"\\\)"
1358
1359 stap_list "process($valid_pid).function(\"foo\").callees(2)" \
1360 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"(foo|bar)@\[^:\]+:\[0-9\]+\"\\\)\\\.callee\\\(\"(bar|inln)@\[^:\]+:\[0-9\]+\"\\\)" {2}
1361 }
1362
1363 testing_probe {process(number).function(string).exported}
1364
1365 stap_list "process($valid_pid).function(\"main\").exported" \
1366 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"main@\[^:\]+:29\"\\\)\\\.exported"
1367
1368 testing_probe {process(number).function(string).inline}
1369
1370 stap_list "process($valid_pid).function(\"inln\").inline" \
1371 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"inln@\[^:\]+:11\"\\\)\\\.inline"
1372
1373 if {[uprobes_p]} {
1374
1375 testing_probe {process(number).function(string).label(string)}
1376
1377 stap_list "process($valid_pid).function(\"main\").label(\"main_label\")" \
1378 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"main@\[^:\]+:33\"\\\)\\\.label\\\(\"main_label\"\\\)"
1379
1380 stap_list "process($valid_pid).function(\"main\").label(\"main_labe?\")" \
1381 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"main@\[^:\]+:33\"\\\)\\\.label\\\(\"main_label\"\\\)"
1382
1383 stap_list "process($valid_pid).function(\"main@$test.c:33\").label(\"main_label\")" \
1384 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"main@\[^:\]+:33\"\\\)\\\.label\\\(\"main_label\"\\\)"
1385
1386 stap_list "process($valid_pid).function(\"main@$test.c:33\").label(\"main_labe?\")" \
1387 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"main@\[^:\]+:33\"\\\)\\\.label\\\(\"main_label\"\\\)"
1388 }
1389
1390 testing_probe {process(number).function(string).return}
1391
1392 stap_list "process($valid_pid).function(\"main\").return" \
1393 "re:process\\\(\"$exefullpath\"\\\)\\\.function\\\(\"main@\[^:\]+:29\"\\\)\\\.return"
1394
1395 testing_probe {process(number).mark(string)}
1396
1397 stap_list "process($valid_pid).mark(\"mark\")" \
1398 "re:process\\\(\"$exefullpath\"\\\)\\\.mark\\\(\"mark\"\\\)"
1399
1400 if {[plt_probes_p]} {
1401
1402 testing_probe {process(number).plt}
1403
1404 stap_list "process($valid_pid).plt" \
1405 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"\[^\"\]+\"\\\)" {-1}
1406
1407 testing_probe {process(number).plt.return}
1408
1409 stap_list "process($valid_pid).plt.return" \
1410 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"\[^\"\]+\"\\\).return" {-1}
1411
1412 testing_probe {process(number).plt(string)}
1413
1414 stap_list "process($valid_pid).plt(\"libfoo\")" \
1415 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"libfoo\"\\\)"
1416
1417 stap_list "process($valid_pid).plt(\"libfo?\")" \
1418 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"libfoo\"\\\)"
1419
1420 stap_list "process($valid_pid).plt(\"\\\[lp\\\]*\")" \
1421 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"(libfoo|printf)\"\\\)" {-1}
1422
1423 testing_probe {process(number).plt(string).return}
1424
1425 stap_list "process($valid_pid).plt(\"libfoo\").return" \
1426 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"libfoo\"\\\).return"
1427
1428 stap_list "process($valid_pid).plt(\"libfo?\").return" \
1429 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"libfoo\"\\\).return"
1430
1431 stap_list "process($valid_pid).plt(\"\\\[lp\\\]*\").return" \
1432 "re:process\\\(\"$exefullpath\"\\\)\\\.plt\\\(\"(libfoo|printf)\"\\\).return" {-1}
1433 }
1434
1435 testing_probe {process(number).provider(string).mark(string)}
1436
1437 stap_list "process($valid_pid).provider(\"main\").mark(\"mark\")" \
1438 "re:process\\\(\"$exefullpath\"\\\)\\\.provider\\\(\"main\"\\\)\\\.mark\\\(\"mark\"\\\)"
1439
1440 if {$process_addr != 0} {
1441
1442 testing_probe {process(number).statement(number)}
1443
1444 stap_list "process($valid_pid).statement(0x$process_addr)" \
1445 "process(\"$exefullpath\").statement(0x$process_addr)"
1446
1447 testing_probe {process(number).statement(number).nearest}
1448
1449 stap_list "process($valid_pid).statement(0x$process_addr).nearest" \
1450 "process(\"$exefullpath\").statement(0x$process_addr).nearest"
1451 }
1452
1453 testing_probe {process(number).statement(string)}
1454
1455 stap_list "process($valid_pid).statement(\"inln\")" \
1456 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"inln@\[^:\]+:11\"\\\)"
1457
1458 stap_list "process($valid_pid).statement(\"foo\")" \
1459 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:23\"\\\)"
1460
1461 stap_list "process($valid_pid).statement(\"foo@$test.c\")" \
1462 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:23\"\\\)"
1463
1464 stap_list "process($valid_pid).statement(\"foo@$test.c:25\")" \
1465 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:25\"\\\)"
1466
1467 stap_list "process($valid_pid).statement(\"fo?@$test.c:25\")" \
1468 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:25\"\\\)"
1469
1470 stap_list "process($valid_pid).statement(\"foo@$test.c+2\")" \
1471 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:25\"\\\)"
1472
1473 stap_list "process($valid_pid).statement(\"foo@$test.c:23-25\")" \
1474 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:\[0-9\]+\"\\\)" {-1}
1475
1476 stap_list "process($valid_pid).statement(\"foo@$test.c:23,25-26\")" \
1477 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:\[0-9\]+\"\\\)" {-1}
1478
1479 stap_list "process($valid_pid).statement(\"foo@$test.c:*\")" \
1480 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:\[0-9\]+\"\\\)" {-1}
1481
1482 testing_probe {process(number).statement(string).nearest}
1483
1484 stap_list "process($valid_pid).statement(\"foo@$test.c:28\").nearest" \
1485 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:28\"\\\).nearest"
1486
1487 stap_list "process($valid_pid).statement(\"foo@$test.c+5\").nearest" \
1488 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:28\"\\\).nearest"
1489
1490 stap_list "process($valid_pid).statement(\"foo@$test.c:23,24\").nearest" \
1491 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:2\[35\]\"\\\).nearest" {2}
1492
1493 stap_list "process($valid_pid).statement(\"foo@$test.c:*\").nearest" \
1494 "re:process\\\(\"$exefullpath\"\\\)\\\.statement\\\(\"foo@\[^:\]+:\[0-9\]+\"\\\).nearest" {-1}
1495 }
1496
1497 testing_probe {process(number).syscall}
1498
1499 stap_list "process($valid_pid).syscall"
1500
1501 testing_probe {process(number).syscall.return}
1502
1503 stap_list "process($valid_pid).syscall.return"
1504
1505 testing_probe {process(number).thread.begin}
1506
1507 stap_list "process($valid_pid).thread.begin"
1508
1509 testing_probe {process(number).thread.end}
1510
1511 stap_list "process($valid_pid).thread.end"
1512
1513 # All of the process(string).* are already tested through stap_list_cmd
1514
1515 #process(string).begin
1516 #process(string).end
1517 #process(string).function(number)
1518 #process(string).function(number).call
1519 #process(string).function(number).exported
1520 #process(string).function(number).return
1521 #process(string).function(string)
1522 #process(string).function(string).call
1523 #process(string).function(string).callee(string)
1524 #process(string).function(string).callees
1525 #process(string).function(string).callees(number)
1526 #process(string).function(string).exported
1527 #process(string).function(string).inline
1528 #process(string).function(string).label(string)
1529 #process(string).function(string).return
1530 #process(string).library(string).function(number)
1531 #process(string).library(string).function(number).call
1532 #process(string).library(string).function(number).exported
1533 #process(string).library(string).function(number).return
1534 #process(string).library(string).function(string)
1535 #process(string).library(string).function(string).call
1536 #process(string).library(string).function(string).callee(string)
1537 #process(string).library(string).function(string).callees
1538 #process(string).library(string).function(string).callees(number)
1539 #process(string).library(string).function(string).exported
1540 #process(string).library(string).function(string).inline
1541 #process(string).library(string).function(string).label(string)
1542 #process(string).library(string).function(string).return
1543 #process(string).library(string).mark(string)
1544 #process(string).library(string).plt
1545 #process(string).library(string).plt(string)
1546 #process(string).library(string).provider(string).mark(string)
1547 #process(string).library(string).statement(number)
1548 #process(string).library(string).statement(string)
1549 #process(string).mark(string)
1550 #process(string).plt
1551 #process(string).plt(string)
1552 #process(string).provider(string).mark(string)
1553 #process(string).statement(number)
1554 #process(string).statement(string)
1555 #process(string).syscall
1556 #process(string).syscall.return
1557 #process(string).thread.begin
1558 #process(string).thread.end
1559
1560 testing_probe {procfs.read}
1561
1562 stap_list {procfs.read}
1563
1564 testing_probe {procfs.read.maxsize(number)}
1565
1566 stap_list {procfs.read.maxsize(100)}
1567
1568 testing_probe {procfs.umask(number).read}
1569
1570 stap_list {procfs.umask(0400).read} \
1571 {procfs.umask(256).read}
1572
1573 testing_probe {procfs.umask(number).read.maxsize(number)}
1574
1575 stap_list {procfs.umask(0400).read.maxsize(100)} \
1576 {procfs.umask(256).read.maxsize(100)}
1577
1578 testing_probe {procfs.umask(number).write}
1579
1580 stap_list {procfs.umask(0400).write} \
1581 {procfs.umask(256).write}
1582
1583 testing_probe {procfs.write}
1584
1585 stap_list {procfs.write}
1586
1587 testing_probe {procfs(string).read}
1588
1589 stap_list {procfs("string").read}
1590
1591 testing_probe {procfs(string).read.maxsize(number)}
1592
1593 stap_list {procfs("string").read.maxsize(100)}
1594
1595 testing_probe {procfs(string).umask(number).read}
1596
1597 stap_list {procfs("string").umask(0400).read} \
1598 {procfs("string").umask(256).read}
1599
1600 testing_probe {procfs(string).umask(number).read.maxsize(number)}
1601
1602 stap_list {procfs("string").umask(0400).read.maxsize(100)} \
1603 {procfs("string").umask(256).read.maxsize(100)}
1604
1605 testing_probe {procfs(string).umask(number).write}
1606
1607 stap_list {procfs("string").umask(0400).write} \
1608 {procfs("string").umask(256).write}
1609
1610 testing_probe {procfs(string).write}
1611
1612 stap_list {procfs("string").write}
1613
1614 testing_probe {timer.hz(number)}
1615
1616 stap_list {timer.hz(1)}
1617
1618 testing_probe {timer.jiffies(number)}
1619
1620 stap_list {timer.jiffies(10)}
1621
1622 testing_probe {timer.jiffies(number).randomize(number)}
1623
1624 stap_list {timer.jiffies(10).randomize(2)}
1625
1626 testing_probe {timer.ms(number)}
1627
1628 stap_list {timer.ms(10)}
1629
1630 testing_probe {timer.ms(number).randomize(number)}
1631
1632 stap_list {timer.ms(10).randomize(2)}
1633
1634 testing_probe {timer.msec(number)}
1635
1636 stap_list {timer.msec(10)}
1637
1638 testing_probe {timer.msec(number).randomize(number)}
1639
1640 stap_list {timer.msec(10).randomize(2)}
1641
1642 testing_probe {timer.ns(number)}
1643
1644 stap_list {timer.ns(100000)}
1645
1646 testing_probe {timer.ns(number).randomize(number)}
1647
1648 stap_list {timer.ns(100000).randomize(2)}
1649
1650 testing_probe {timer.nsec(number)}
1651
1652 stap_list {timer.nsec(100000)}
1653
1654 testing_probe {timer.nsec(number).randomize(number)}
1655
1656 stap_list {timer.nsec(100000).randomize(2)}
1657
1658 testing_probe {timer.s(number)}
1659
1660 stap_list {timer.s(100)}
1661
1662 testing_probe {timer.s(number).randomize(number)}
1663
1664 stap_list {timer.s(100).randomize(2)}
1665
1666 testing_probe {timer.sec(number)}
1667
1668 stap_list {timer.sec(100)}
1669
1670 testing_probe {timer.sec(number).randomize(number)}
1671
1672 stap_list {timer.sec(100).randomize(2)}
1673
1674 testing_probe {timer.us(number)}
1675
1676 stap_list {timer.us(100)}
1677
1678 testing_probe {timer.us(number).randomize(number)}
1679
1680 stap_list {timer.us(100).randomize(2)}
1681
1682 testing_probe {timer.usec(number)}
1683
1684 stap_list {timer.usec(100000)}
1685
1686 testing_probe {timer.usec(number).randomize(number)}
1687
1688 stap_list {timer.usec(100000).randomize(2)}
1689
1690 test_cleanup
1691 test_cleanup2
1692 report_untested_probes