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_too_big_in"] = 0
454 self
.expect
["select_too_big_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 # make sure an invalid value still produces a valid event
470 if n
== 2048 and overflow
== 0 and _readfds_length
== 0:
471 self
.expect
["select_too_big_in"] = 1
473 def select_exit(self
, event
):
474 timestamp
= event
.timestamp
475 cpu_id
= event
["cpu_id"]
477 overflow
= event
["overflow"]
479 _readfds_length
= event
["_readfds_length"]
480 readfds
= event
["readfds"]
481 _writefds_length
= event
["_writefds_length"]
482 writefds
= event
["writefds"]
483 _exceptfds_length
= event
["_exceptfds_length"]
484 exceptfds
= event
["exceptfds"]
486 # make sure an invalid value still produces a valid event
487 if ret
== -9 and overflow
== 0 and _readfds_length
== 0:
488 self
.expect
["select_too_big_out"] = 1
491 class Test4(TraceParser
):
492 def __init__(self
, trace
, pid
):
493 super().__init
__(trace
, pid
)
494 self
.expect
["big_poll_in"] = 0
495 self
.expect
["big_poll_out"] = 0
497 def poll_entry(self
, event
):
498 timestamp
= event
.timestamp
499 cpu_id
= event
["cpu_id"]
501 fds_length
= event
["fds_length"]
502 overflow
= event
["overflow"]
505 # test of big list of FDs and the behaviour of the overflow
506 if nfds
== 2047 and fds_length
== 512 and overflow
== 1 and \
507 fds
[0]["raw_events"] == 0x3 \
508 and fds
[0]["events"]["POLLIN"] == 1 and \
509 fds
[0]["events"]["padding"] == 0 and \
510 fds
[511]["events"]["POLLIN"] == 1 and \
511 fds
[511]["events"]["POLLPRI"] == 1:
512 self
.expect
["big_poll_in"] = 1
514 def poll_exit(self
, event
):
515 timestamp
= event
.timestamp
516 cpu_id
= event
["cpu_id"]
519 fds_length
= event
["fds_length"]
520 overflow
= event
["overflow"]
523 # test of big list of FDs and the behaviour of the overflow
524 if ret
== 2047 and nfds
== 2047 and fds_length
== 512 and \
525 overflow
== 1 and fds
[0]["events"]["POLLIN"] == 1 and \
526 fds
[511]["events"]["POLLIN"] == 1:
527 self
.expect
["big_poll_out"] = 1
530 class Test5(TraceParser
):
531 def __init__(self
, trace
, pid
):
532 super().__init
__(trace
, pid
)
533 self
.expect
["poll_overflow_in"] = 0
534 self
.expect
["poll_overflow_out"] = 0
536 def poll_entry(self
, event
):
537 timestamp
= event
.timestamp
538 cpu_id
= event
["cpu_id"]
540 fds_length
= event
["fds_length"]
541 overflow
= event
["overflow"]
544 # test that event in valid even though the target buffer is too small
545 # and the program segfaults
546 if nfds
== 100 and fds_length
== 100 and overflow
== 0 and \
547 fds
[0]["events"]["POLLIN"] == 1:
548 self
.expect
["poll_overflow_in"] = 1
550 def poll_exit(self
, event
):
551 timestamp
= event
.timestamp
552 cpu_id
= event
["cpu_id"]
555 fds_length
= event
["fds_length"]
556 overflow
= event
["overflow"]
559 # test that event in valid even though the target buffer is too small
560 # and the program segfaults
561 if nfds
== 100 and overflow
== 0:
562 self
.expect
["poll_overflow_out"] = 1
565 class Test6(TraceParser
):
566 def __init__(self
, trace
, pid
):
567 super().__init
__(trace
, pid
)
568 self
.expect
["pselect_invalid_in"] = 0
569 self
.expect
["pselect_invalid_out"] = 0
571 def select_entry(self
, event
):
572 timestamp
= event
.timestamp
573 cpu_id
= event
["cpu_id"]
575 overflow
= event
["overflow"]
577 _readfds_length
= event
["_readfds_length"]
578 readfds
= event
["readfds"]
579 _writefds_length
= event
["_writefds_length"]
580 writefds
= event
["writefds"]
581 _exceptfds_length
= event
["_exceptfds_length"]
582 exceptfds
= event
["exceptfds"]
584 # test that event in valid even though the target buffer pointer is
585 # invalid and the program segfaults
586 if n
== 1 and overflow
== 0 and _readfds_length
== 0:
587 self
.expect
["pselect_invalid_in"] = 1
589 def select_exit(self
, event
):
590 timestamp
= event
.timestamp
591 cpu_id
= event
["cpu_id"]
593 overflow
= event
["overflow"]
595 _readfds_length
= event
["_readfds_length"]
596 readfds
= event
["readfds"]
597 _writefds_length
= event
["_writefds_length"]
598 writefds
= event
["writefds"]
599 _exceptfds_length
= event
["_exceptfds_length"]
600 exceptfds
= event
["exceptfds"]
602 # test that event in valid even though the target buffer pointer is
603 # invalid and the program segfaults
604 if ret
== -14 and overflow
== 0 and _readfds_length
== 0:
605 self
.expect
["pselect_invalid_out"] = 1
608 class Test7(TraceParser
):
609 def __init__(self
, trace
, pid
):
610 super().__init
__(trace
, pid
)
611 self
.expect
["poll_max_in"] = 0
612 self
.expect
["poll_max_out"] = 0
614 def poll_entry(self
, event
):
615 timestamp
= event
.timestamp
616 cpu_id
= event
["cpu_id"]
618 fds_length
= event
["fds_length"]
619 overflow
= event
["overflow"]
622 # check the proper working of INT_MAX maxevent value
623 if nfds
== 4294967295 and overflow
== 1:
624 self
.expect
["poll_max_in"] = 1
626 def poll_exit(self
, event
):
627 timestamp
= event
.timestamp
628 cpu_id
= event
["cpu_id"]
631 fds_length
= event
["fds_length"]
632 overflow
= event
["overflow"]
635 # check the proper working of UINT_MAX maxevent value
636 if ret
== -22 and nfds
== 4294967295 and overflow
== 0:
637 self
.expect
["poll_max_out"] = 1
640 class Test8(TraceParser
):
641 def __init__(self
, trace
, pid
):
642 super().__init
__(trace
, pid
)
643 self
.expect
["epoll_wait_invalid_in"] = 0
644 self
.expect
["epoll_wait_invalid_out"] = 0
646 def epoll_wait_entry(self
, event
):
647 timestamp
= event
.timestamp
648 cpu_id
= event
["cpu_id"]
650 maxevents
= event
["maxevents"]
651 timeout
= event
["timeout"]
653 # test that event in valid even though the target buffer pointer is
654 # invalid and the program segfaults
655 if epfd
== 3 and maxevents
== 1 and timeout
== -1:
656 self
.expect
["epoll_wait_invalid_in"] = 1
658 def epoll_wait_exit(self
, event
):
659 timestamp
= event
.timestamp
660 cpu_id
= event
["cpu_id"]
662 fds_length
= event
["fds_length"]
663 overflow
= event
["overflow"]
666 # test that event in valid even though the target buffer pointer is
667 # invalid and the program segfaults
668 if ret
== -14 and fds_length
== 0 and overflow
== 0:
669 self
.expect
["epoll_wait_invalid_out"] = 1
672 class Test9(TraceParser
):
673 def __init__(self
, trace
, pid
):
674 super().__init
__(trace
, pid
)
675 self
.expect
["epoll_wait_max_in"] = 0
676 self
.expect
["epoll_wait_max_out"] = 0
678 def epoll_wait_entry(self
, event
):
679 timestamp
= event
.timestamp
680 cpu_id
= event
["cpu_id"]
682 maxevents
= event
["maxevents"]
683 timeout
= event
["timeout"]
685 # check the proper working of INT_MAX maxevent value
686 if epfd
== 3 and maxevents
== 2147483647 and timeout
== -1:
687 self
.expect
["epoll_wait_max_in"] = 1
689 def epoll_wait_exit(self
, event
):
690 timestamp
= event
.timestamp
691 cpu_id
= event
["cpu_id"]
693 fds_length
= event
["fds_length"]
694 overflow
= event
["overflow"]
697 # check the proper working of INT_MAX maxevent value
698 if ret
== -22 and fds_length
== 0 and overflow
== 0:
699 self
.expect
["epoll_wait_max_out"] = 1
702 if __name__
== "__main__":
703 parser
= argparse
.ArgumentParser(description
='Trace parser')
704 parser
.add_argument('path', metavar
="<path/to/trace>", help='Trace path')
705 parser
.add_argument('-t', '--test', type=int, help='Test to validate')
706 parser
.add_argument('-p', '--pid', type=int, help='PID of the app')
707 args
= parser
.parse_args()
710 print("Need to pass a test to validate (-t)")
714 print("Need to pass the PID to check (-p)")
717 traces
= TraceCollection()
718 handle
= traces
.add_traces_recursive(args
.path
, "ctf")
725 t
= Test1(traces
, args
.pid
)
727 t
= Test2(traces
, args
.pid
)
729 t
= Test3(traces
, args
.pid
)
731 t
= Test4(traces
, args
.pid
)
733 t
= Test5(traces
, args
.pid
)
735 t
= Test6(traces
, args
.pid
)
737 t
= Test7(traces
, args
.pid
)
739 t
= Test8(traces
, args
.pid
)
741 t
= Test9(traces
, args
.pid
)
742 elif args
.test
== 10:
743 # stress test, nothing reliable to check
745 elif args
.test
== 11:
746 # stress test, nothing reliable to check
749 print("Invalid test case")
755 for h
in handle
.values():
756 traces
.remove_trace(h
)
This page took 0.049236 seconds and 6 git commands to generate.