Commit | Line | Data |
---|---|---|
c778fbf3 JD |
1 | #!/usr/bin/env python3 |
2 | ||
3 | import sys | |
4 | import time | |
5 | import argparse | |
6 | ||
7 | NSEC_PER_SEC = 1000000000 | |
8 | ||
9 | try: | |
10 | from babeltrace import TraceCollection | |
11 | except ImportError: | |
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 | |
16 | ||
17 | ||
18 | class TraceParser: | |
19 | def __init__(self, trace, pid): | |
20 | self.trace = trace | |
21 | self.pid = pid | |
22 | self.expect = {} | |
23 | ||
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, | |
27 | ns % NSEC_PER_SEC) | |
28 | ||
29 | def parse(self): | |
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: | |
33 | continue | |
34 | ||
35 | method_name = "handle_%s" % event.name.replace(":", "_").replace("+", "_") | |
36 | # call the function to handle each event individually | |
37 | if hasattr(TraceParser, method_name): | |
38 | func = getattr(TraceParser, method_name) | |
39 | func(self, event) | |
40 | ||
41 | ret = 0 | |
42 | for i in self.expect.keys(): | |
43 | if self.expect[i] == 0: | |
44 | print("%s not validated" % i) | |
45 | ret = 1 | |
46 | ||
47 | return ret | |
48 | ||
49 | ### epoll_ctl | |
50 | def handle_compat_syscall_entry_epoll_ctl(self, event): | |
51 | self.epoll_ctl_entry(event) | |
52 | ||
53 | def handle_compat_syscall_exit_epoll_ctl(self, event): | |
54 | self.epoll_ctl_exit(event) | |
55 | ||
56 | def handle_syscall_entry_epoll_ctl(self, event): | |
57 | self.epoll_ctl_entry(event) | |
58 | ||
59 | def handle_syscall_exit_epoll_ctl(self, event): | |
60 | self.epoll_ctl_exit(event) | |
61 | ||
62 | def epoll_ctl_entry(self, event): | |
63 | timestamp = event.timestamp | |
64 | cpu_id = event["cpu_id"] | |
65 | epfd = event["epfd"] | |
66 | op_enum = event["op_enum"] | |
67 | fd = event["fd"] | |
68 | _event = event["event"] | |
69 | ||
70 | def epoll_ctl_exit(self, event): | |
71 | timestamp = event.timestamp | |
72 | cpu_id = event["cpu_id"] | |
73 | ret = event["ret"] | |
74 | ||
75 | ### epoll_wait + epoll_pwait | |
76 | def handle_compat_syscall_entry_epoll_wait(self, event): | |
77 | self.epoll_wait_entry(event) | |
78 | ||
79 | def handle_compat_syscall_exit_epoll_wait(self, event): | |
80 | self.epoll_wait_exit(event) | |
81 | ||
82 | def handle_syscall_entry_epoll_wait(self, event): | |
83 | self.epoll_wait_entry(event) | |
84 | ||
85 | def handle_syscall_exit_epoll_wait(self, event): | |
86 | self.epoll_wait_exit(event) | |
87 | ||
88 | def handle_compat_syscall_entry_epoll_pwait(self, event): | |
89 | self.epoll_wait_entry(event) | |
90 | ||
91 | def handle_compat_syscall_exit_epoll_pwait(self, event): | |
92 | self.epoll_wait_exit(event) | |
93 | ||
94 | def handle_syscall_entry_epoll_pwait(self, event): | |
95 | self.epoll_wait_entry(event) | |
96 | ||
97 | def handle_syscall_exit_epoll_pwait(self, event): | |
98 | self.epoll_wait_exit(event) | |
99 | ||
100 | def epoll_wait_entry(self, event): | |
101 | timestamp = event.timestamp | |
102 | cpu_id = event["cpu_id"] | |
103 | epfd = event["epfd"] | |
104 | maxevents = event["maxevents"] | |
105 | timeout = event["timeout"] | |
106 | ||
107 | def epoll_wait_exit(self, event): | |
108 | timestamp = event.timestamp | |
109 | cpu_id = event["cpu_id"] | |
110 | ret = event["ret"] | |
111 | fds_length = event["fds_length"] | |
112 | overflow = event["overflow"] | |
113 | fds = event["fds"] | |
114 | ||
115 | #### poll + ppoll | |
116 | def handle_compat_syscall_entry_poll(self, event): | |
117 | self.poll_entry(event) | |
118 | ||
119 | def handle_compat_syscall_exit_poll(self, event): | |
120 | self.poll_exit(event) | |
121 | ||
122 | def handle_syscall_entry_poll(self, event): | |
123 | self.poll_entry(event) | |
124 | ||
125 | def handle_syscall_exit_poll(self, event): | |
126 | self.poll_exit(event) | |
127 | ||
128 | def handle_compat_syscall_entry_ppoll(self, event): | |
129 | self.poll_entry(event) | |
130 | ||
131 | def handle_compat_syscall_exit_ppoll(self, event): | |
132 | self.poll_exit(event) | |
133 | ||
134 | def handle_syscall_entry_ppoll(self, event): | |
135 | self.poll_entry(event) | |
136 | ||
137 | def handle_syscall_exit_ppoll(self, event): | |
138 | self.poll_exit(event) | |
139 | ||
140 | def poll_entry(self, event): | |
141 | timestamp = event.timestamp | |
142 | cpu_id = event["cpu_id"] | |
143 | nfds = event["nfds"] | |
144 | fds_length = event["fds_length"] | |
145 | overflow = event["overflow"] | |
146 | fds = event["fds"] | |
147 | ||
148 | def poll_exit(self, event): | |
149 | timestamp = event.timestamp | |
150 | cpu_id = event["cpu_id"] | |
151 | ret = event["ret"] | |
152 | nfds = event["nfds"] | |
153 | fds_length = event["fds_length"] | |
154 | fds = event["fds"] | |
155 | ||
156 | ### epoll_create | |
157 | def handle_compat_syscall_entry_epoll_create1(self, event): | |
158 | self.epoll_create_entry(event) | |
159 | ||
160 | def handle_compat_syscall_exit_epoll_create1(self, event): | |
161 | self.epoll_create_exit(event) | |
162 | ||
163 | def handle_compat_syscall_entry_epoll_create(self, event): | |
164 | self.epoll_create_entry(event) | |
165 | ||
166 | def handle_compat_syscall_exit_epoll_create(self, event): | |
167 | self.epoll_create_exit(event) | |
168 | ||
169 | def handle_syscall_entry_epoll_create1(self, event): | |
170 | self.epoll_create_entry(event) | |
171 | ||
172 | def handle_syscall_exit_epoll_create1(self, event): | |
173 | self.epoll_create_exit(event) | |
174 | ||
175 | def handle_syscall_entry_epoll_create(self, event): | |
176 | self.epoll_create_entry(event) | |
177 | ||
178 | def handle_syscall_exit_epoll_create(self, event): | |
179 | self.epoll_create_exit(event) | |
180 | ||
181 | def handle_compat_syscall_entry_epoll_create1(self, event): | |
182 | self.epoll_create_entry(event) | |
183 | ||
184 | def handle_compat_syscall_exit_epoll_create(self, event): | |
185 | self.epoll_create_exit(event) | |
186 | ||
187 | def epoll_create_entry(self, event): | |
188 | timestamp = event.timestamp | |
189 | cpu_id = event["cpu_id"] | |
190 | flags = event["flags"] | |
191 | ||
192 | def epoll_create_exit(self, event): | |
193 | timestamp = event.timestamp | |
194 | cpu_id = event["cpu_id"] | |
195 | ret = event["ret"] | |
196 | ||
197 | ### select + pselect6 | |
198 | def handle_syscall_entry_pselect6(self, event): | |
199 | self.select_entry(event) | |
200 | ||
201 | def handle_syscall_exit_pselect6(self, event): | |
202 | self.select_exit(event) | |
203 | ||
204 | def handle_compat_syscall_entry_pselect6(self, event): | |
205 | self.select_entry(event) | |
206 | ||
207 | def handle_compat_syscall_exit_pselect6(self, event): | |
208 | self.select_exit(event) | |
209 | ||
210 | def handle_syscall_entry_select(self, event): | |
211 | self.select_entry(event) | |
212 | ||
213 | def handle_syscall_exit_select(self, event): | |
214 | self.select_exit(event) | |
215 | ||
216 | def handle_compat_syscall_entry_select(self, event): | |
217 | self.select_entry(event) | |
218 | ||
219 | def handle_compat_syscall_exit_select(self, event): | |
220 | self.select_exit(event) | |
221 | ||
222 | def select_entry(self, event): | |
223 | timestamp = event.timestamp | |
224 | cpu_id = event["cpu_id"] | |
225 | n = event["n"] | |
226 | overflow = event["overflow"] | |
227 | tvp = event["tvp"] | |
228 | _readfds_length = event["_readfds_length"] | |
229 | readfds = event["readfds"] | |
230 | _writefds_length = event["_writefds_length"] | |
231 | writefds = event["writefds"] | |
232 | _exceptfds_length = event["_exceptfds_length"] | |
233 | exceptfds = event["exceptfds"] | |
234 | ||
235 | def select_exit(self, event): | |
236 | timestamp = event.timestamp | |
237 | cpu_id = event["cpu_id"] | |
238 | ret = event["ret"] | |
239 | overflow = event["overflow"] | |
240 | tvp = event["tvp"] | |
241 | _readfds_length = event["_readfds_length"] | |
242 | readfds = event["readfds"] | |
243 | _writefds_length = event["_writefds_length"] | |
244 | writefds = event["writefds"] | |
245 | _exceptfds_length = event["_exceptfds_length"] | |
246 | exceptfds = event["exceptfds"] | |
247 | ||
248 | ||
249 | class Test1(TraceParser): | |
250 | def __init__(self, trace, pid): | |
251 | super().__init__(trace, pid) | |
252 | self.expect["select_in_fd0"] = 0 | |
253 | self.expect["select_in_fd1023"] = 0 | |
254 | self.expect["select_out_fd0"] = 0 | |
255 | self.expect["select_out_fd1023"] = 0 | |
256 | self.expect["poll_in_nfds1"] = 0 | |
257 | self.expect["poll_out_nfds1"] = 0 | |
258 | self.expect["epoll_ctl_in_add"] = 0 | |
259 | self.expect["epoll_ctl_out_ok"] = 0 | |
260 | self.expect["epoll_wait_in_ok"] = 0 | |
261 | self.expect["epoll_wait_out_fd0"] = 0 | |
262 | ||
263 | def select_entry(self, event): | |
264 | timestamp = event.timestamp | |
265 | cpu_id = event["cpu_id"] | |
266 | n = event["n"] | |
267 | overflow = event["overflow"] | |
268 | tvp = event["tvp"] | |
269 | _readfds_length = event["_readfds_length"] | |
270 | readfds = event["readfds"] | |
271 | _writefds_length = event["_writefds_length"] | |
272 | writefds = event["writefds"] | |
273 | _exceptfds_length = event["_exceptfds_length"] | |
274 | exceptfds = event["exceptfds"] | |
275 | ||
276 | if n == 1 and readfds[0] == 1: | |
277 | self.expect["select_in_fd0"] = 1 | |
278 | if n == 1023: | |
279 | if readfds[127] == 0x40 and writefds[127] == 0 and \ | |
280 | exceptfds[127] == 0 and overflow == 0: | |
281 | self.expect["select_in_fd1023"] = 1 | |
282 | ||
283 | def select_exit(self, event): | |
284 | timestamp = event.timestamp | |
285 | cpu_id = event["cpu_id"] | |
286 | ret = event["ret"] | |
287 | overflow = event["overflow"] | |
288 | tvp = event["tvp"] | |
289 | _readfds_length = event["_readfds_length"] | |
290 | readfds = event["readfds"] | |
291 | _writefds_length = event["_writefds_length"] | |
292 | writefds = event["writefds"] | |
293 | _exceptfds_length = event["_exceptfds_length"] | |
294 | exceptfds = event["exceptfds"] | |
295 | ||
296 | if ret == 1: | |
297 | if readfds[0] == 1: | |
298 | self.expect["select_out_fd0"] = 1 | |
299 | if _readfds_length == 128 and readfds[127] == 0x40 and \ | |
300 | writefds[127] == 0 and exceptfds[127] == 0 and tvp == 0: | |
301 | self.expect["select_out_fd1023"] = 1 | |
302 | ||
303 | def poll_entry(self, event): | |
304 | timestamp = event.timestamp | |
305 | cpu_id = event["cpu_id"] | |
306 | nfds = event["nfds"] | |
307 | fds_length = event["fds_length"] | |
308 | overflow = event["overflow"] | |
309 | fds = event["fds"] | |
310 | ||
311 | if nfds == 1 and fds_length == 1 and fds[0]["raw_events"] == 0x3 \ | |
312 | and fds[0]["events"]["POLLIN"] == 1 and \ | |
313 | fds[0]["events"]["padding"] == 0: | |
314 | self.expect["poll_in_nfds1"] = 1 | |
315 | ||
316 | def poll_exit(self, event): | |
317 | timestamp = event.timestamp | |
318 | cpu_id = event["cpu_id"] | |
319 | ret = event["ret"] | |
320 | nfds = event["nfds"] | |
321 | fds_length = event["fds_length"] | |
322 | fds = event["fds"] | |
323 | ||
324 | if ret == 1 and fds_length == 1 and fds[0]["raw_events"] == 0x1 \ | |
325 | and fds[0]["events"]["POLLIN"] == 1 and \ | |
326 | fds[0]["events"]["padding"] == 0: | |
327 | self.expect["poll_out_nfds1"] = 1 | |
328 | ||
329 | def epoll_ctl_entry(self, event): | |
330 | timestamp = event.timestamp | |
331 | cpu_id = event["cpu_id"] | |
332 | epfd = event["epfd"] | |
333 | op_enum = event["op_enum"] | |
334 | fd = event["fd"] | |
335 | _event = event["event"] | |
336 | ||
337 | if epfd == 3 and op_enum == "EPOLL_CTL_ADD" and fd == 0 and \ | |
338 | _event["data_union"]["fd"] == 0 and \ | |
339 | _event["events"]["EPOLLIN"] == 1 and \ | |
340 | _event["events"]["EPOLLPRI"] == 1: | |
341 | self.expect["epoll_ctl_in_add"] = 1 | |
342 | ||
343 | def epoll_ctl_exit(self, event): | |
344 | timestamp = event.timestamp | |
345 | cpu_id = event["cpu_id"] | |
346 | ret = event["ret"] | |
347 | ||
348 | if ret == 0: | |
349 | self.expect["epoll_ctl_out_ok"] = 1 | |
350 | ||
351 | def epoll_wait_entry(self, event): | |
352 | timestamp = event.timestamp | |
353 | cpu_id = event["cpu_id"] | |
354 | epfd = event["epfd"] | |
355 | maxevents = event["maxevents"] | |
356 | timeout = event["timeout"] | |
357 | ||
358 | if epfd == 3 and maxevents == 1 and timeout == -1: | |
359 | self.expect["epoll_wait_in_ok"] = 1 | |
360 | ||
361 | ||
362 | def epoll_wait_exit(self, event): | |
363 | timestamp = event.timestamp | |
364 | cpu_id = event["cpu_id"] | |
365 | ret = event["ret"] | |
366 | fds_length = event["fds_length"] | |
367 | overflow = event["overflow"] | |
368 | fds = event["fds"] | |
369 | ||
370 | if ret == 1 and fds_length == 1 and overflow == 0 and \ | |
371 | fds[0]["data_union"]["fd"] == 0 and \ | |
372 | fds[0]["events"]["EPOLLIN"] == 1: | |
373 | self.expect["epoll_wait_out_fd0"] = 1 | |
374 | ||
375 | ||
376 | class Test2(TraceParser): | |
377 | def __init__(self, trace, pid): | |
378 | super().__init__(trace, pid) | |
379 | self.expect["select_timeout_in_fd0"] = 0 | |
380 | self.expect["select_timeout_in_fd1023"] = 0 | |
381 | self.expect["select_timeout_out"] = 0 | |
382 | self.expect["poll_timeout_in"] = 0 | |
383 | self.expect["poll_timeout_out"] = 0 | |
384 | self.expect["epoll_ctl_timeout_in_add"] = 0 | |
385 | self.expect["epoll_ctl_timeout_out_ok"] = 0 | |
386 | self.expect["epoll_wait_timeout_in"] = 0 | |
387 | self.expect["epoll_wait_timeout_out"] = 0 | |
388 | ||
389 | def select_entry(self, event): | |
390 | timestamp = event.timestamp | |
391 | cpu_id = event["cpu_id"] | |
392 | n = event["n"] | |
393 | overflow = event["overflow"] | |
394 | tvp = event["tvp"] | |
395 | _readfds_length = event["_readfds_length"] | |
396 | readfds = event["readfds"] | |
397 | _writefds_length = event["_writefds_length"] | |
398 | writefds = event["writefds"] | |
399 | _exceptfds_length = event["_exceptfds_length"] | |
400 | exceptfds = event["exceptfds"] | |
401 | ||
402 | if n == 1 and tvp != 0: | |
403 | self.expect["select_timeout_in_fd0"] = 1 | |
404 | if n == 1023: | |
405 | if readfds[127] == 0x40 and writefds[127] == 0 and \ | |
406 | exceptfds[127] == 0 and tvp != 0: | |
407 | self.expect["select_timeout_in_fd1023"] = 1 | |
408 | ||
409 | def select_exit(self, event): | |
410 | timestamp = event.timestamp | |
411 | cpu_id = event["cpu_id"] | |
412 | ret = event["ret"] | |
413 | overflow = event["overflow"] | |
414 | tvp = event["tvp"] | |
415 | _readfds_length = event["_readfds_length"] | |
416 | readfds = event["readfds"] | |
417 | _writefds_length = event["_writefds_length"] | |
418 | writefds = event["writefds"] | |
419 | _exceptfds_length = event["_exceptfds_length"] | |
420 | exceptfds = event["exceptfds"] | |
421 | ||
422 | if ret == 0 and tvp != 0: | |
423 | self.expect["select_timeout_out"] = 1 | |
424 | ||
425 | def poll_entry(self, event): | |
426 | timestamp = event.timestamp | |
427 | cpu_id = event["cpu_id"] | |
428 | nfds = event["nfds"] | |
429 | fds_length = event["fds_length"] | |
430 | overflow = event["overflow"] | |
431 | fds = event["fds"] | |
432 | ||
433 | if nfds == 1 and fds_length == 1 and fds[0]["raw_events"] == 0x3 \ | |
434 | and fds[0]["events"]["POLLIN"] == 1 and \ | |
435 | fds[0]["events"]["padding"] == 0: | |
436 | self.expect["poll_timeout_in"] = 1 | |
437 | ||
438 | def poll_exit(self, event): | |
439 | timestamp = event.timestamp | |
440 | cpu_id = event["cpu_id"] | |
441 | ret = event["ret"] | |
442 | nfds = event["nfds"] | |
443 | fds_length = event["fds_length"] | |
444 | fds = event["fds"] | |
445 | ||
446 | if ret == 0 and nfds == 1 and fds_length == 0: | |
447 | self.expect["poll_timeout_out"] = 1 | |
448 | ||
449 | def epoll_ctl_entry(self, event): | |
450 | timestamp = event.timestamp | |
451 | cpu_id = event["cpu_id"] | |
452 | epfd = event["epfd"] | |
453 | op_enum = event["op_enum"] | |
454 | fd = event["fd"] | |
455 | _event = event["event"] | |
456 | ||
457 | if op_enum == "EPOLL_CTL_ADD" and \ | |
458 | _event["events"]["EPOLLIN"] == 1 and \ | |
459 | _event["events"]["EPOLLPRI"] == 1: | |
460 | self.expect["epoll_ctl_timeout_in_add"] = 1 | |
461 | ||
462 | def epoll_ctl_exit(self, event): | |
463 | timestamp = event.timestamp | |
464 | cpu_id = event["cpu_id"] | |
465 | ret = event["ret"] | |
466 | ||
467 | if ret == 0: | |
468 | self.expect["epoll_ctl_timeout_out_ok"] = 1 | |
469 | ||
470 | def epoll_wait_entry(self, event): | |
471 | timestamp = event.timestamp | |
472 | cpu_id = event["cpu_id"] | |
473 | epfd = event["epfd"] | |
474 | maxevents = event["maxevents"] | |
475 | timeout = event["timeout"] | |
476 | ||
477 | if maxevents == 1 and timeout == 1: | |
478 | self.expect["epoll_wait_timeout_in"] = 1 | |
479 | ||
480 | ||
481 | def epoll_wait_exit(self, event): | |
482 | timestamp = event.timestamp | |
483 | cpu_id = event["cpu_id"] | |
484 | ret = event["ret"] | |
485 | fds_length = event["fds_length"] | |
486 | overflow = event["overflow"] | |
487 | fds = event["fds"] | |
488 | ||
489 | if ret == 0 and fds_length == 0 and overflow == 0: | |
490 | self.expect["epoll_wait_timeout_out"] = 1 | |
491 | ||
492 | ||
493 | class Test3(TraceParser): | |
494 | def __init__(self, trace, pid): | |
495 | super().__init__(trace, pid) | |
496 | self.expect["select_too_big_in"] = 0 | |
497 | self.expect["select_too_big_out"] = 0 | |
498 | ||
499 | def select_entry(self, event): | |
500 | timestamp = event.timestamp | |
501 | cpu_id = event["cpu_id"] | |
502 | n = event["n"] | |
503 | overflow = event["overflow"] | |
504 | tvp = event["tvp"] | |
505 | _readfds_length = event["_readfds_length"] | |
506 | readfds = event["readfds"] | |
507 | _writefds_length = event["_writefds_length"] | |
508 | writefds = event["writefds"] | |
509 | _exceptfds_length = event["_exceptfds_length"] | |
510 | exceptfds = event["exceptfds"] | |
511 | ||
512 | if n == 2048 and overflow == 0 and _readfds_length == 0: | |
513 | self.expect["select_too_big_in"] = 1 | |
514 | ||
515 | def select_exit(self, event): | |
516 | timestamp = event.timestamp | |
517 | cpu_id = event["cpu_id"] | |
518 | ret = event["ret"] | |
519 | overflow = event["overflow"] | |
520 | tvp = event["tvp"] | |
521 | _readfds_length = event["_readfds_length"] | |
522 | readfds = event["readfds"] | |
523 | _writefds_length = event["_writefds_length"] | |
524 | writefds = event["writefds"] | |
525 | _exceptfds_length = event["_exceptfds_length"] | |
526 | exceptfds = event["exceptfds"] | |
527 | ||
528 | if ret == -9 and overflow == 0 and _readfds_length == 0: | |
529 | self.expect["select_too_big_out"] = 1 | |
530 | ||
531 | ||
532 | class Test4(TraceParser): | |
533 | def __init__(self, trace, pid): | |
534 | super().__init__(trace, pid) | |
535 | self.expect["big_poll_in"] = 0 | |
536 | self.expect["big_poll_out"] = 0 | |
537 | ||
538 | def poll_entry(self, event): | |
539 | timestamp = event.timestamp | |
540 | cpu_id = event["cpu_id"] | |
541 | nfds = event["nfds"] | |
542 | fds_length = event["fds_length"] | |
543 | overflow = event["overflow"] | |
544 | fds = event["fds"] | |
545 | ||
546 | if nfds == 2047 and fds_length == 512 and overflow == 1 and \ | |
547 | fds[0]["raw_events"] == 0x3 \ | |
548 | and fds[0]["events"]["POLLIN"] == 1 and \ | |
549 | fds[0]["events"]["padding"] == 0 and \ | |
550 | fds[511]["events"]["POLLIN"] == 1 and \ | |
551 | fds[511]["events"]["POLLPRI"] == 1: | |
552 | self.expect["big_poll_in"] = 1 | |
553 | ||
554 | def poll_exit(self, event): | |
555 | timestamp = event.timestamp | |
556 | cpu_id = event["cpu_id"] | |
557 | ret = event["ret"] | |
558 | nfds = event["nfds"] | |
559 | fds_length = event["fds_length"] | |
560 | overflow = event["overflow"] | |
561 | fds = event["fds"] | |
562 | ||
563 | if ret == 2047 and nfds == 2047 and fds_length == 512 and \ | |
564 | overflow == 1 and fds[0]["events"]["POLLIN"] == 1 and \ | |
565 | fds[511]["events"]["POLLIN"] == 1: | |
566 | self.expect["big_poll_out"] = 1 | |
567 | ||
568 | ||
569 | class Test5(TraceParser): | |
570 | def __init__(self, trace, pid): | |
571 | super().__init__(trace, pid) | |
572 | self.expect["poll_overflow_in"] = 0 | |
573 | self.expect["poll_overflow_out"] = 0 | |
574 | ||
575 | def poll_entry(self, event): | |
576 | timestamp = event.timestamp | |
577 | cpu_id = event["cpu_id"] | |
578 | nfds = event["nfds"] | |
579 | fds_length = event["fds_length"] | |
580 | overflow = event["overflow"] | |
581 | fds = event["fds"] | |
582 | ||
583 | if nfds == 100 and fds_length == 100 and overflow == 0 and \ | |
584 | fds[0]["events"]["POLLIN"] == 1: | |
585 | self.expect["poll_overflow_in"] = 1 | |
586 | ||
587 | def poll_exit(self, event): | |
588 | timestamp = event.timestamp | |
589 | cpu_id = event["cpu_id"] | |
590 | ret = event["ret"] | |
591 | nfds = event["nfds"] | |
592 | fds_length = event["fds_length"] | |
593 | overflow = event["overflow"] | |
594 | fds = event["fds"] | |
595 | ||
596 | if nfds == 100 and overflow == 0: | |
597 | self.expect["poll_overflow_out"] = 1 | |
598 | ||
599 | ||
600 | class Test6(TraceParser): | |
601 | def __init__(self, trace, pid): | |
602 | super().__init__(trace, pid) | |
603 | self.expect["pselect_invalid_in"] = 0 | |
604 | self.expect["pselect_invalid_out"] = 0 | |
605 | ||
606 | def select_entry(self, event): | |
607 | timestamp = event.timestamp | |
608 | cpu_id = event["cpu_id"] | |
609 | n = event["n"] | |
610 | overflow = event["overflow"] | |
611 | tvp = event["tvp"] | |
612 | _readfds_length = event["_readfds_length"] | |
613 | readfds = event["readfds"] | |
614 | _writefds_length = event["_writefds_length"] | |
615 | writefds = event["writefds"] | |
616 | _exceptfds_length = event["_exceptfds_length"] | |
617 | exceptfds = event["exceptfds"] | |
618 | ||
619 | if n == 1 and overflow == 0 and _readfds_length == 0: | |
620 | self.expect["pselect_invalid_in"] = 1 | |
621 | ||
622 | def select_exit(self, event): | |
623 | timestamp = event.timestamp | |
624 | cpu_id = event["cpu_id"] | |
625 | ret = event["ret"] | |
626 | overflow = event["overflow"] | |
627 | tvp = event["tvp"] | |
628 | _readfds_length = event["_readfds_length"] | |
629 | readfds = event["readfds"] | |
630 | _writefds_length = event["_writefds_length"] | |
631 | writefds = event["writefds"] | |
632 | _exceptfds_length = event["_exceptfds_length"] | |
633 | exceptfds = event["exceptfds"] | |
634 | ||
635 | if ret == -14 and overflow == 0 and _readfds_length == 0: | |
636 | self.expect["pselect_invalid_out"] = 1 | |
637 | ||
638 | ||
639 | class Test7(TraceParser): | |
640 | def __init__(self, trace, pid): | |
641 | super().__init__(trace, pid) | |
642 | self.expect["poll_max_in"] = 0 | |
643 | self.expect["poll_max_out"] = 0 | |
644 | ||
645 | def poll_entry(self, event): | |
646 | timestamp = event.timestamp | |
647 | cpu_id = event["cpu_id"] | |
648 | nfds = event["nfds"] | |
649 | fds_length = event["fds_length"] | |
650 | overflow = event["overflow"] | |
651 | fds = event["fds"] | |
652 | ||
653 | if nfds == 4294967295 and overflow == 1: | |
654 | self.expect["poll_max_in"] = 1 | |
655 | ||
656 | def poll_exit(self, event): | |
657 | timestamp = event.timestamp | |
658 | cpu_id = event["cpu_id"] | |
659 | ret = event["ret"] | |
660 | nfds = event["nfds"] | |
661 | fds_length = event["fds_length"] | |
662 | overflow = event["overflow"] | |
663 | fds = event["fds"] | |
664 | ||
665 | if ret == -22 and nfds == 4294967295 and overflow == 0: | |
666 | self.expect["poll_max_out"] = 1 | |
667 | ||
668 | ||
669 | class Test8(TraceParser): | |
670 | def __init__(self, trace, pid): | |
671 | super().__init__(trace, pid) | |
672 | self.expect["epoll_wait_invalid_in"] = 0 | |
673 | self.expect["epoll_wait_invalid_out"] = 0 | |
674 | ||
675 | def epoll_wait_entry(self, event): | |
676 | timestamp = event.timestamp | |
677 | cpu_id = event["cpu_id"] | |
678 | epfd = event["epfd"] | |
679 | maxevents = event["maxevents"] | |
680 | timeout = event["timeout"] | |
681 | ||
682 | if epfd == 3 and maxevents == 1 and timeout == -1: | |
683 | self.expect["epoll_wait_invalid_in"] = 1 | |
684 | ||
685 | ||
686 | def epoll_wait_exit(self, event): | |
687 | timestamp = event.timestamp | |
688 | cpu_id = event["cpu_id"] | |
689 | ret = event["ret"] | |
690 | fds_length = event["fds_length"] | |
691 | overflow = event["overflow"] | |
692 | fds = event["fds"] | |
693 | ||
694 | if ret == -14 and fds_length == 0 and overflow == 0: | |
695 | self.expect["epoll_wait_invalid_out"] = 1 | |
696 | ||
697 | ||
698 | class Test9(TraceParser): | |
699 | def __init__(self, trace, pid): | |
700 | super().__init__(trace, pid) | |
701 | self.expect["epoll_wait_max_in"] = 0 | |
702 | self.expect["epoll_wait_max_out"] = 0 | |
703 | ||
704 | def epoll_wait_entry(self, event): | |
705 | timestamp = event.timestamp | |
706 | cpu_id = event["cpu_id"] | |
707 | epfd = event["epfd"] | |
708 | maxevents = event["maxevents"] | |
709 | timeout = event["timeout"] | |
710 | ||
711 | if epfd == 3 and maxevents == 2147483647 and timeout == -1: | |
712 | self.expect["epoll_wait_max_in"] = 1 | |
713 | ||
714 | ||
715 | def epoll_wait_exit(self, event): | |
716 | timestamp = event.timestamp | |
717 | cpu_id = event["cpu_id"] | |
718 | ret = event["ret"] | |
719 | fds_length = event["fds_length"] | |
720 | overflow = event["overflow"] | |
721 | fds = event["fds"] | |
722 | ||
723 | if ret == -22 and fds_length == 0 and overflow == 0: | |
724 | self.expect["epoll_wait_max_out"] = 1 | |
725 | ||
726 | ||
727 | if __name__ == "__main__": | |
728 | parser = argparse.ArgumentParser(description='Trace parser') | |
729 | parser.add_argument('path', metavar="<path/to/trace>", help='Trace path') | |
730 | parser.add_argument('-t', '--test', type=int, help='Test to validate') | |
731 | parser.add_argument('-p', '--pid', type=int, help='PID of the app') | |
732 | args = parser.parse_args() | |
733 | ||
734 | if not args.test: | |
735 | print("Need to pass a test to validate (-t)") | |
736 | sys.exit(1) | |
737 | ||
738 | if not args.pid: | |
739 | print("Need to pass the PID to check (-p)") | |
740 | sys.exit(1) | |
741 | ||
742 | traces = TraceCollection() | |
743 | handle = traces.add_traces_recursive(args.path, "ctf") | |
744 | if handle is None: | |
745 | sys.exit(1) | |
746 | ||
747 | t = None | |
748 | ||
749 | if args.test == 1: | |
750 | t = Test1(traces, args.pid) | |
751 | elif args.test == 2: | |
752 | t = Test2(traces, args.pid) | |
753 | elif args.test == 3: | |
754 | t = Test3(traces, args.pid) | |
755 | elif args.test == 4: | |
756 | t = Test4(traces, args.pid) | |
757 | elif args.test == 5: | |
758 | t = Test5(traces, args.pid) | |
759 | elif args.test == 6: | |
760 | t = Test6(traces, args.pid) | |
761 | elif args.test == 7: | |
762 | t = Test7(traces, args.pid) | |
763 | elif args.test == 8: | |
764 | t = Test8(traces, args.pid) | |
765 | elif args.test == 9: | |
766 | t = Test9(traces, args.pid) | |
767 | elif args.test == 10: | |
768 | # stress test, nothing reliable to check | |
769 | ret = 0 | |
770 | elif args.test == 11: | |
771 | # stress test, nothing reliable to check | |
772 | ret = 0 | |
773 | else: | |
774 | print("Invalid test case") | |
775 | sys.exit(1) | |
776 | ||
777 | if t is not None: | |
778 | ret = t.parse() | |
779 | ||
780 | for h in handle.values(): | |
781 | traces.remove_trace(h) | |
782 | ||
783 | sys.exit(ret) |