tests/regression/kernel/validate_select_poll_epoll.py

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