7 NSEC_PER_SEC
= 1000000000
10 from babeltrace
import TraceCollection
12 # quick fix for debian-based distros
13 sys
.path
.append("/usr/local/lib/python%d.%d/site-packages" %
14 (sys
.version_info
.major
, sys
.version_info
.minor
))
15 from babeltrace
import TraceCollection
19 def __init__(self
, trace
, pid
):
24 def ns_to_hour_nsec(self
, ns
):
25 d
= time
.localtime(ns
/NSEC_PER_SEC
)
26 return "%02d:%02d:%02d.%09d" % (d
.tm_hour
, d
.tm_min
, d
.tm_sec
,
30 # iterate over all the events
31 for event
in self
.trace
.events
:
32 if self
.pid
is not None and event
["pid"] != self
.pid
:
35 method_name
= "handle_%s" % event
.name
.replace(":", "_").replace(
37 # call the function to handle each event individually
38 if hasattr(TraceParser
, method_name
):
39 func
= getattr(TraceParser
, method_name
)
43 for i
in self
.expect
.keys():
44 if self
.expect
[i
] == 0:
45 print("%s not validated" % i
)
51 def handle_compat_syscall_entry_epoll_ctl(self
, event
):
52 self
.epoll_ctl_entry(event
)
54 def handle_compat_syscall_exit_epoll_ctl(self
, event
):
55 self
.epoll_ctl_exit(event
)
57 def handle_syscall_entry_epoll_ctl(self
, event
):
58 self
.epoll_ctl_entry(event
)
60 def handle_syscall_exit_epoll_ctl(self
, event
):
61 self
.epoll_ctl_exit(event
)
63 def epoll_ctl_entry(self
, event
):
66 def epoll_ctl_exit(self
, event
):
69 # epoll_wait + epoll_pwait
70 def handle_compat_syscall_entry_epoll_wait(self
, event
):
71 self
.epoll_wait_entry(event
)
73 def handle_compat_syscall_exit_epoll_wait(self
, event
):
74 self
.epoll_wait_exit(event
)
76 def handle_syscall_entry_epoll_wait(self
, event
):
77 self
.epoll_wait_entry(event
)
79 def handle_syscall_exit_epoll_wait(self
, event
):
80 self
.epoll_wait_exit(event
)
82 def handle_compat_syscall_entry_epoll_pwait(self
, event
):
83 self
.epoll_wait_entry(event
)
85 def handle_compat_syscall_exit_epoll_pwait(self
, event
):
86 self
.epoll_wait_exit(event
)
88 def handle_syscall_entry_epoll_pwait(self
, event
):
89 self
.epoll_wait_entry(event
)
91 def handle_syscall_exit_epoll_pwait(self
, event
):
92 self
.epoll_wait_exit(event
)
94 def epoll_wait_entry(self
, event
):
97 def epoll_wait_exit(self
, event
):
101 def handle_compat_syscall_entry_poll(self
, event
):
102 self
.poll_entry(event
)
104 def handle_compat_syscall_exit_poll(self
, event
):
105 self
.poll_exit(event
)
107 def handle_syscall_entry_poll(self
, event
):
108 self
.poll_entry(event
)
110 def handle_syscall_exit_poll(self
, event
):
111 self
.poll_exit(event
)
113 def handle_compat_syscall_entry_ppoll(self
, event
):
114 self
.poll_entry(event
)
116 def handle_compat_syscall_exit_ppoll(self
, event
):
117 self
.poll_exit(event
)
119 def handle_syscall_entry_ppoll(self
, event
):
120 self
.poll_entry(event
)
122 def handle_syscall_exit_ppoll(self
, event
):
123 self
.poll_exit(event
)
125 def poll_entry(self
, event
):
128 def poll_exit(self
, event
):
132 def handle_compat_syscall_entry_epoll_create1(self
, event
):
133 self
.epoll_create_entry(event
)
135 def handle_compat_syscall_exit_epoll_create1(self
, event
):
136 self
.epoll_create_exit(event
)
138 def handle_compat_syscall_entry_epoll_create(self
, event
):
139 self
.epoll_create_entry(event
)
141 def handle_compat_syscall_exit_epoll_create(self
, event
):
142 self
.epoll_create_exit(event
)
144 def handle_syscall_entry_epoll_create1(self
, event
):
145 self
.epoll_create_entry(event
)
147 def handle_syscall_exit_epoll_create1(self
, event
):
148 self
.epoll_create_exit(event
)
150 def handle_syscall_entry_epoll_create(self
, event
):
151 self
.epoll_create_entry(event
)
153 def handle_syscall_exit_epoll_create(self
, event
):
154 self
.epoll_create_exit(event
)
156 def epoll_create_entry(self
, event
):
159 def epoll_create_exit(self
, event
):
163 def handle_syscall_entry_pselect6(self
, event
):
164 self
.select_entry(event
)
166 def handle_syscall_exit_pselect6(self
, event
):
167 self
.select_exit(event
)
169 def handle_compat_syscall_entry_pselect6(self
, event
):
170 self
.select_entry(event
)
172 def handle_compat_syscall_exit_pselect6(self
, event
):
173 self
.select_exit(event
)
175 def handle_syscall_entry_select(self
, event
):
176 self
.select_entry(event
)
178 def handle_syscall_exit_select(self
, event
):
179 self
.select_exit(event
)
181 def handle_compat_syscall_entry_select(self
, event
):
182 self
.select_entry(event
)
184 def handle_compat_syscall_exit_select(self
, event
):
185 self
.select_exit(event
)
187 def select_entry(self
, event
):
190 def select_exit(self
, event
):
194 class Test1(TraceParser
):
195 def __init__(self
, trace
, pid
):
196 super().__init
__(trace
, pid
)
197 self
.expect
["select_in_fd0"] = 0
198 self
.expect
["select_in_fd1023"] = 0
199 self
.expect
["select_out_fd0"] = 0
200 self
.expect
["select_out_fd1023"] = 0
201 self
.expect
["poll_in_nfds1"] = 0
202 self
.expect
["poll_out_nfds1"] = 0
203 self
.expect
["epoll_ctl_in_add"] = 0
204 self
.expect
["epoll_ctl_out_ok"] = 0
205 self
.expect
["epoll_wait_in_ok"] = 0
206 self
.expect
["epoll_wait_out_fd0"] = 0
208 def select_entry(self
, event
):
209 timestamp
= event
.timestamp
210 cpu_id
= event
["cpu_id"]
212 overflow
= event
["overflow"]
214 _readfds_length
= event
["_readfds_length"]
215 readfds
= event
["readfds"]
216 _writefds_length
= event
["_writefds_length"]
217 writefds
= event
["writefds"]
218 _exceptfds_length
= event
["_exceptfds_length"]
219 exceptfds
= event
["exceptfds"]
221 # check that the FD 0 is actually set in the readfds
222 if n
== 1 and readfds
[0] == 1:
223 self
.expect
["select_in_fd0"] = 1
225 # check that the FD 1023 is actually set in the readfds
226 if readfds
[127] == 0x40 and writefds
[127] == 0 and \
227 exceptfds
[127] == 0 and overflow
== 0:
228 self
.expect
["select_in_fd1023"] = 1
230 def select_exit(self
, event
):
231 timestamp
= event
.timestamp
232 cpu_id
= event
["cpu_id"]
234 overflow
= event
["overflow"]
236 _readfds_length
= event
["_readfds_length"]
237 readfds
= event
["readfds"]
238 _writefds_length
= event
["_writefds_length"]
239 writefds
= event
["writefds"]
240 _exceptfds_length
= event
["_exceptfds_length"]
241 exceptfds
= event
["exceptfds"]
244 # check that the FD 0 is actually set in the readfds
246 self
.expect
["select_out_fd0"] = 1
247 # check that the FD 1023 is actually set in the readfds
248 if _readfds_length
== 128 and readfds
[127] == 0x40 and \
249 writefds
[127] == 0 and exceptfds
[127] == 0 and tvp
== 0:
250 self
.expect
["select_out_fd1023"] = 1
252 def poll_entry(self
, event
):
253 timestamp
= event
.timestamp
254 cpu_id
= event
["cpu_id"]
256 fds_length
= event
["fds_length"]
257 overflow
= event
["overflow"]
260 # check that only one FD is set, that it has the POLLIN flag and that
261 # the raw value matches the events bit field.
262 if nfds
== 1 and fds_length
== 1 and fds
[0]["raw_events"] == 0x3 \
263 and fds
[0]["events"]["POLLIN"] == 1 and \
264 fds
[0]["events"]["padding"] == 0:
265 self
.expect
["poll_in_nfds1"] = 1
267 def poll_exit(self
, event
):
268 timestamp
= event
.timestamp
269 cpu_id
= event
["cpu_id"]
272 fds_length
= event
["fds_length"]
275 # check that only one FD is set, that it has the POLLIN flag and that
276 # the raw value matches the events bit field.
277 if ret
== 1 and fds_length
== 1 and fds
[0]["raw_events"] == 0x1 \
278 and fds
[0]["events"]["POLLIN"] == 1 and \
279 fds
[0]["events"]["padding"] == 0:
280 self
.expect
["poll_out_nfds1"] = 1
282 def epoll_ctl_entry(self
, event
):
283 timestamp
= event
.timestamp
284 cpu_id
= event
["cpu_id"]
286 op_enum
= event
["op_enum"]
288 _event
= event
["event"]
290 # check that we have FD 0 waiting for EPOLLIN|EPOLLPRI and that
292 if epfd
== 3 and op_enum
== "EPOLL_CTL_ADD" and fd
== 0 and \
293 _event
["data_union"]["fd"] == 0 and \
294 _event
["events"]["EPOLLIN"] == 1 and \
295 _event
["events"]["EPOLLPRI"] == 1:
296 self
.expect
["epoll_ctl_in_add"] = 1
298 def epoll_ctl_exit(self
, event
):
299 timestamp
= event
.timestamp
300 cpu_id
= event
["cpu_id"]
304 self
.expect
["epoll_ctl_out_ok"] = 1
306 def epoll_wait_entry(self
, event
):
307 timestamp
= event
.timestamp
308 cpu_id
= event
["cpu_id"]
310 maxevents
= event
["maxevents"]
311 timeout
= event
["timeout"]
313 if epfd
== 3 and maxevents
== 1 and timeout
== -1:
314 self
.expect
["epoll_wait_in_ok"] = 1
316 def epoll_wait_exit(self
, event
):
317 timestamp
= event
.timestamp
318 cpu_id
= event
["cpu_id"]
320 fds_length
= event
["fds_length"]
321 overflow
= event
["overflow"]
324 # check that FD 0 returned with EPOLLIN and the right data.fd
325 if ret
== 1 and fds_length
== 1 and overflow
== 0 and \
326 fds
[0]["data_union"]["fd"] == 0 and \
327 fds
[0]["events"]["EPOLLIN"] == 1:
328 self
.expect
["epoll_wait_out_fd0"] = 1
331 class Test2(TraceParser
):
332 def __init__(self
, trace
, pid
):
333 super().__init
__(trace
, pid
)
334 self
.expect
["select_timeout_in_fd0"] = 0
335 self
.expect
["select_timeout_in_fd1023"] = 0
336 self
.expect
["select_timeout_out"] = 0
337 self
.expect
["poll_timeout_in"] = 0
338 self
.expect
["poll_timeout_out"] = 0
339 self
.expect
["epoll_ctl_timeout_in_add"] = 0
340 self
.expect
["epoll_ctl_timeout_out_ok"] = 0
341 self
.expect
["epoll_wait_timeout_in"] = 0
342 self
.expect
["epoll_wait_timeout_out"] = 0
344 def select_entry(self
, event
):
345 timestamp
= event
.timestamp
346 cpu_id
= event
["cpu_id"]
348 overflow
= event
["overflow"]
350 _readfds_length
= event
["_readfds_length"]
351 readfds
= event
["readfds"]
352 _writefds_length
= event
["_writefds_length"]
353 writefds
= event
["writefds"]
354 _exceptfds_length
= event
["_exceptfds_length"]
355 exceptfds
= event
["exceptfds"]
357 if n
== 1 and tvp
!= 0:
358 self
.expect
["select_timeout_in_fd0"] = 1
360 if readfds
[127] == 0x40 and writefds
[127] == 0 and \
361 exceptfds
[127] == 0 and tvp
!= 0:
362 self
.expect
["select_timeout_in_fd1023"] = 1
364 def select_exit(self
, event
):
365 timestamp
= event
.timestamp
366 cpu_id
= event
["cpu_id"]
368 overflow
= event
["overflow"]
370 _readfds_length
= event
["_readfds_length"]
371 readfds
= event
["readfds"]
372 _writefds_length
= event
["_writefds_length"]
373 writefds
= event
["writefds"]
374 _exceptfds_length
= event
["_exceptfds_length"]
375 exceptfds
= event
["exceptfds"]
377 if ret
== 0 and tvp
!= 0:
378 self
.expect
["select_timeout_out"] = 1
380 def poll_entry(self
, event
):
381 timestamp
= event
.timestamp
382 cpu_id
= event
["cpu_id"]
384 fds_length
= event
["fds_length"]
385 overflow
= event
["overflow"]
388 # check that we wait on FD 0 for POLLIN and that the raw_events
389 # field matches the value of POLLIN
390 if nfds
== 1 and fds_length
== 1 and fds
[0]["raw_events"] == 0x3 \
391 and fds
[0]["events"]["POLLIN"] == 1 and \
392 fds
[0]["events"]["padding"] == 0:
393 self
.expect
["poll_timeout_in"] = 1
395 def poll_exit(self
, event
):
396 timestamp
= event
.timestamp
397 cpu_id
= event
["cpu_id"]
400 fds_length
= event
["fds_length"]
403 if ret
== 0 and nfds
== 1 and fds_length
== 0:
404 self
.expect
["poll_timeout_out"] = 1
406 def epoll_ctl_entry(self
, event
):
407 timestamp
= event
.timestamp
408 cpu_id
= event
["cpu_id"]
410 op_enum
= event
["op_enum"]
412 _event
= event
["event"]
414 # make sure we see a EPOLLIN|EPOLLPRI
415 if op_enum
== "EPOLL_CTL_ADD" and \
416 _event
["events"]["EPOLLIN"] == 1 and \
417 _event
["events"]["EPOLLPRI"] == 1:
418 self
.expect
["epoll_ctl_timeout_in_add"] = 1
420 def epoll_ctl_exit(self
, event
):
421 timestamp
= event
.timestamp
422 cpu_id
= event
["cpu_id"]
426 self
.expect
["epoll_ctl_timeout_out_ok"] = 1
428 def epoll_wait_entry(self
, event
):
429 timestamp
= event
.timestamp
430 cpu_id
= event
["cpu_id"]
432 maxevents
= event
["maxevents"]
433 timeout
= event
["timeout"]
435 if maxevents
== 1 and timeout
== 1:
436 self
.expect
["epoll_wait_timeout_in"] = 1
438 def epoll_wait_exit(self
, event
):
439 timestamp
= event
.timestamp
440 cpu_id
= event
["cpu_id"]
442 fds_length
= event
["fds_length"]
443 overflow
= event
["overflow"]
446 if ret
== 0 and fds_length
== 0 and overflow
== 0:
447 self
.expect
["epoll_wait_timeout_out"] = 1
450 class Test3(TraceParser
):
451 def __init__(self
, trace
, pid
):
452 super().__init
__(trace
, pid
)
453 self
.expect
["select_invalid_fd_in"] = 0
454 self
.expect
["select_invalid_fd_out"] = 0
456 def select_entry(self
, event
):
457 timestamp
= event
.timestamp
458 cpu_id
= event
["cpu_id"]
460 overflow
= event
["overflow"]
462 _readfds_length
= event
["_readfds_length"]
463 readfds
= event
["readfds"]
464 _writefds_length
= event
["_writefds_length"]
465 writefds
= event
["writefds"]
466 _exceptfds_length
= event
["_exceptfds_length"]
467 exceptfds
= event
["exceptfds"]
469 if n
> 0 and overflow
== 0:
470 self
.expect
["select_invalid_fd_in"] = 1
472 def select_exit(self
, event
):
473 timestamp
= event
.timestamp
474 cpu_id
= event
["cpu_id"]
476 overflow
= event
["overflow"]
478 _readfds_length
= event
["_readfds_length"]
479 readfds
= event
["readfds"]
480 _writefds_length
= event
["_writefds_length"]
481 writefds
= event
["writefds"]
482 _exceptfds_length
= event
["_exceptfds_length"]
483 exceptfds
= event
["exceptfds"]
485 # make sure the event has a ret field equal to -EBADF
486 if ret
== -9 and overflow
== 0 and _readfds_length
== 0:
487 self
.expect
["select_invalid_fd_out"] = 1
490 class Test4(TraceParser
):
491 def __init__(self
, trace
, pid
):
492 super().__init
__(trace
, pid
)
493 self
.expect
["big_poll_in"] = 0
494 self
.expect
["big_poll_out"] = 0
496 def poll_entry(self
, event
):
497 timestamp
= event
.timestamp
498 cpu_id
= event
["cpu_id"]
500 fds_length
= event
["fds_length"]
501 overflow
= event
["overflow"]
504 # test of big list of FDs and the behaviour of the overflow
505 if nfds
== 2047 and fds_length
== 512 and overflow
== 1 and \
506 fds
[0]["raw_events"] == 0x3 \
507 and fds
[0]["events"]["POLLIN"] == 1 and \
508 fds
[0]["events"]["padding"] == 0 and \
509 fds
[511]["events"]["POLLIN"] == 1 and \
510 fds
[511]["events"]["POLLPRI"] == 1:
511 self
.expect
["big_poll_in"] = 1
513 def poll_exit(self
, event
):
514 timestamp
= event
.timestamp
515 cpu_id
= event
["cpu_id"]
518 fds_length
= event
["fds_length"]
519 overflow
= event
["overflow"]
522 # test of big list of FDs and the behaviour of the overflow
523 if ret
== 2047 and nfds
== 2047 and fds_length
== 512 and \
524 overflow
== 1 and fds
[0]["events"]["POLLIN"] == 1 and \
525 fds
[511]["events"]["POLLIN"] == 1:
526 self
.expect
["big_poll_out"] = 1
529 class Test5(TraceParser
):
530 def __init__(self
, trace
, pid
):
531 super().__init
__(trace
, pid
)
532 self
.expect
["poll_overflow_in"] = 0
533 self
.expect
["poll_overflow_out"] = 0
535 def poll_entry(self
, event
):
536 timestamp
= event
.timestamp
537 cpu_id
= event
["cpu_id"]
539 fds_length
= event
["fds_length"]
540 overflow
= event
["overflow"]
543 # test that event in valid even though the target buffer is too small
544 # and the program segfaults
545 if nfds
== 100 and fds_length
== 100 and overflow
== 0 and \
546 fds
[0]["events"]["POLLIN"] == 1:
547 self
.expect
["poll_overflow_in"] = 1
549 def poll_exit(self
, event
):
550 timestamp
= event
.timestamp
551 cpu_id
= event
["cpu_id"]
554 fds_length
= event
["fds_length"]
555 overflow
= event
["overflow"]
558 # test that event in valid even though the target buffer is too small
559 # and the program segfaults
560 if nfds
== 100 and overflow
== 0:
561 self
.expect
["poll_overflow_out"] = 1
564 class Test6(TraceParser
):
565 def __init__(self
, trace
, pid
):
566 super().__init
__(trace
, pid
)
567 self
.expect
["pselect_invalid_in"] = 0
568 self
.expect
["pselect_invalid_out"] = 0
570 def select_entry(self
, event
):
571 timestamp
= event
.timestamp
572 cpu_id
= event
["cpu_id"]
574 overflow
= event
["overflow"]
576 _readfds_length
= event
["_readfds_length"]
577 readfds
= event
["readfds"]
578 _writefds_length
= event
["_writefds_length"]
579 writefds
= event
["writefds"]
580 _exceptfds_length
= event
["_exceptfds_length"]
581 exceptfds
= event
["exceptfds"]
583 # test that event in valid even though the target buffer pointer is
584 # invalid and the program segfaults
585 if n
== 1 and overflow
== 0 and _readfds_length
== 0:
586 self
.expect
["pselect_invalid_in"] = 1
588 def select_exit(self
, event
):
589 timestamp
= event
.timestamp
590 cpu_id
= event
["cpu_id"]
592 overflow
= event
["overflow"]
594 _readfds_length
= event
["_readfds_length"]
595 readfds
= event
["readfds"]
596 _writefds_length
= event
["_writefds_length"]
597 writefds
= event
["writefds"]
598 _exceptfds_length
= event
["_exceptfds_length"]
599 exceptfds
= event
["exceptfds"]
601 # test that event in valid even though the target buffer pointer is
602 # invalid and the program segfaults
603 if ret
== -14 and overflow
== 0 and _readfds_length
== 0:
604 self
.expect
["pselect_invalid_out"] = 1
607 class Test7(TraceParser
):
608 def __init__(self
, trace
, pid
):
609 super().__init
__(trace
, pid
)
610 self
.expect
["poll_max_in"] = 0
611 self
.expect
["poll_max_out"] = 0
613 def poll_entry(self
, event
):
614 timestamp
= event
.timestamp
615 cpu_id
= event
["cpu_id"]
617 fds_length
= event
["fds_length"]
618 overflow
= event
["overflow"]
621 # check the proper working of INT_MAX maxevent value
622 if nfds
== 4294967295 and overflow
== 1:
623 self
.expect
["poll_max_in"] = 1
625 def poll_exit(self
, event
):
626 timestamp
= event
.timestamp
627 cpu_id
= event
["cpu_id"]
630 fds_length
= event
["fds_length"]
631 overflow
= event
["overflow"]
634 # check the proper working of UINT_MAX maxevent value
635 if ret
== -22 and nfds
== 4294967295 and overflow
== 0:
636 self
.expect
["poll_max_out"] = 1
639 class Test8(TraceParser
):
640 def __init__(self
, trace
, pid
):
641 super().__init
__(trace
, pid
)
642 self
.expect
["epoll_wait_invalid_in"] = 0
643 self
.expect
["epoll_wait_invalid_out"] = 0
645 def epoll_wait_entry(self
, event
):
646 timestamp
= event
.timestamp
647 cpu_id
= event
["cpu_id"]
649 maxevents
= event
["maxevents"]
650 timeout
= event
["timeout"]
652 # test that event in valid even though the target buffer pointer is
653 # invalid and the program segfaults
654 if epfd
== 3 and maxevents
== 1 and timeout
== -1:
655 self
.expect
["epoll_wait_invalid_in"] = 1
657 def epoll_wait_exit(self
, event
):
658 timestamp
= event
.timestamp
659 cpu_id
= event
["cpu_id"]
661 fds_length
= event
["fds_length"]
662 overflow
= event
["overflow"]
665 # test that event in valid even though the target buffer pointer is
666 # invalid and the program segfaults
667 if ret
== -14 and fds_length
== 0 and overflow
== 0:
668 self
.expect
["epoll_wait_invalid_out"] = 1
671 class Test9(TraceParser
):
672 def __init__(self
, trace
, pid
):
673 super().__init
__(trace
, pid
)
674 self
.expect
["epoll_wait_max_in"] = 0
675 self
.expect
["epoll_wait_max_out"] = 0
677 def epoll_wait_entry(self
, event
):
678 timestamp
= event
.timestamp
679 cpu_id
= event
["cpu_id"]
681 maxevents
= event
["maxevents"]
682 timeout
= event
["timeout"]
684 # check the proper working of INT_MAX maxevent value
685 if epfd
== 3 and maxevents
== 2147483647 and timeout
== -1:
686 self
.expect
["epoll_wait_max_in"] = 1
688 def epoll_wait_exit(self
, event
):
689 timestamp
= event
.timestamp
690 cpu_id
= event
["cpu_id"]
692 fds_length
= event
["fds_length"]
693 overflow
= event
["overflow"]
696 # check the proper working of INT_MAX maxevent value
697 if ret
== -22 and fds_length
== 0 and overflow
== 0:
698 self
.expect
["epoll_wait_max_out"] = 1
701 if __name__
== "__main__":
702 parser
= argparse
.ArgumentParser(description
='Trace parser')
703 parser
.add_argument('path', metavar
="<path/to/trace>", help='Trace path')
704 parser
.add_argument('-t', '--test', type=int, help='Test to validate')
705 parser
.add_argument('-p', '--pid', type=int, help='PID of the app')
706 args
= parser
.parse_args()
709 print("Need to pass a test to validate (-t)")
713 print("Need to pass the PID to check (-p)")
716 traces
= TraceCollection()
717 handle
= traces
.add_traces_recursive(args
.path
, "ctf")
724 t
= Test1(traces
, args
.pid
)
726 t
= Test2(traces
, args
.pid
)
728 t
= Test3(traces
, args
.pid
)
730 t
= Test4(traces
, args
.pid
)
732 t
= Test5(traces
, args
.pid
)
734 t
= Test6(traces
, args
.pid
)
736 t
= Test7(traces
, args
.pid
)
738 t
= Test8(traces
, args
.pid
)
740 t
= Test9(traces
, args
.pid
)
741 elif args
.test
== 10:
742 # stress test, nothing reliable to check
744 elif args
.test
== 11:
745 # stress test, nothing reliable to check
748 print("Invalid test case")
754 for h
in handle
.values():
755 traces
.remove_trace(h
)
This page took 0.050086 seconds and 5 git commands to generate.