tests: put `static` keyword at beginning of variable declaration
[lttng-tools.git] / tests / regression / kernel / select_poll_epoll.c
1 #include <stdio.h>
2 #include <poll.h>
3 #include <signal.h>
4 #include <unistd.h>
5 #include <sys/syscall.h>
6 #include <sys/types.h>
7 #include <sys/stat.h>
8 #include <fcntl.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <stddef.h>
12 #include <sys/select.h>
13 #include <sys/epoll.h>
14 #include <popt.h>
15 #include <sys/time.h>
16 #include <sys/resource.h>
17 #include <limits.h>
18 #include <pthread.h>
19 #include <sys/mman.h>
20 #include <common/compat/time.h>
21
22 #define BUF_SIZE 256
23 #define NB_FD 1
24 #define MAX_FDS 2047
25 #define NR_ITER 1000 /* for stress-tests */
26
27 #define MIN_NR_FDS 5 /* the minimum number of open FDs required for the test to run */
28 #define BIG_SELECT_FD 1022
29
30 #define MSEC_PER_USEC 1000
31 #define MSEC_PER_NSEC (MSEC_PER_USEC * 1000)
32
33 static int timeout; /* seconds, -1 to disable */
34 static volatile int stop_thread;
35 static int wait_fd;
36
37 struct ppoll_thread_data {
38 struct pollfd *ufds;
39 int value;
40 };
41
42 void test_select_big(void)
43 {
44 fd_set rfds, wfds, exfds;
45 struct timeval tv;
46 int ret;
47 int fd2;
48 char buf[BUF_SIZE];
49
50 FD_ZERO(&rfds);
51 FD_ZERO(&wfds);
52 FD_ZERO(&exfds);
53
54 fd2 = dup2(wait_fd, BIG_SELECT_FD);
55 if (fd2 < 0) {
56 perror("dup2");
57 goto end;
58 }
59 FD_SET(fd2, &rfds);
60
61 tv.tv_sec = 0;
62 tv.tv_usec = timeout * MSEC_PER_USEC;
63
64 if (timeout > 0) {
65 ret = select(fd2 + 1, &rfds, &wfds, &exfds, &tv);
66 } else {
67 ret = select(fd2 + 1, &rfds, &wfds, &exfds, NULL);
68 }
69
70 if (ret == -1) {
71 perror("select()");
72 } else if (ret) {
73 printf("# [select] data available\n");
74 ret = read(wait_fd, buf, BUF_SIZE);
75 if (ret < 0) {
76 perror("[select] read");
77 }
78 } else {
79 printf("# [select] timeout\n");
80 }
81
82 ret = close(BIG_SELECT_FD);
83 if (ret) {
84 perror("close");
85 }
86
87 end:
88 return;
89 }
90
91 void test_pselect(void)
92 {
93 fd_set rfds;
94 struct timespec tv;
95 int ret;
96 char buf[BUF_SIZE];
97
98 FD_ZERO(&rfds);
99 FD_SET(wait_fd, &rfds);
100
101 tv.tv_sec = 0;
102 tv.tv_nsec = timeout * MSEC_PER_NSEC;
103
104 if (timeout > 0) {
105 ret = pselect(1, &rfds, NULL, NULL, &tv, NULL);
106 } else {
107 ret = pselect(1, &rfds, NULL, NULL, NULL, NULL);
108 }
109
110 if (ret == -1) {
111 perror("pselect()");
112 } else if (ret) {
113 printf("# [pselect] data available\n");
114 ret = read(wait_fd, buf, BUF_SIZE);
115 if (ret < 0) {
116 perror("[pselect] read");
117 }
118 } else {
119 printf("# [pselect] timeout\n");
120 }
121
122 }
123
124 void test_select(void)
125 {
126 fd_set rfds;
127 struct timeval tv;
128 int ret;
129 char buf[BUF_SIZE];
130
131 FD_ZERO(&rfds);
132 FD_SET(wait_fd, &rfds);
133
134 tv.tv_sec = 0;
135 tv.tv_usec = timeout * MSEC_PER_USEC;
136
137 if (timeout > 0) {
138 ret = select(1, &rfds, NULL, NULL, &tv);
139 } else {
140 ret = select(1, &rfds, NULL, NULL, NULL);
141 }
142
143 if (ret == -1) {
144 perror("select()");
145 } else if (ret) {
146 printf("# [select] data available\n");
147 ret = read(wait_fd, buf, BUF_SIZE);
148 if (ret < 0) {
149 perror("[select] read");
150 }
151 } else {
152 printf("# [select] timeout\n");
153 }
154
155 }
156
157 void test_poll(void)
158 {
159 struct pollfd ufds[NB_FD];
160 char buf[BUF_SIZE];
161 int ret;
162
163 ufds[0].fd = wait_fd;
164 ufds[0].events = POLLIN|POLLPRI;
165
166 ret = poll(ufds, 1, timeout);
167
168 if (ret < 0) {
169 perror("poll");
170 } else if (ret > 0) {
171 printf("# [poll] data available\n");
172 ret = read(wait_fd, buf, BUF_SIZE);
173 if (ret < 0) {
174 perror("[poll] read");
175 }
176 } else {
177 printf("# [poll] timeout\n");
178 }
179 }
180
181 void test_ppoll(void)
182 {
183 struct pollfd ufds[NB_FD];
184 char buf[BUF_SIZE];
185 int ret;
186 struct timespec ts;
187
188 ufds[0].fd = wait_fd;
189 ufds[0].events = POLLIN|POLLPRI;
190
191 if (timeout > 0) {
192 ts.tv_sec = 0;
193 ts.tv_nsec = timeout * MSEC_PER_NSEC;
194 ret = ppoll(ufds, 1, &ts, NULL);
195 } else {
196 ret = ppoll(ufds, 1, NULL, NULL);
197 }
198
199
200 if (ret < 0) {
201 perror("ppoll");
202 } else if (ret > 0) {
203 printf("# [ppoll] data available\n");
204 ret = read(wait_fd, buf, BUF_SIZE);
205 if (ret < 0) {
206 perror("[ppoll] read");
207 }
208 } else {
209 printf("# [ppoll] timeout\n");
210 }
211 }
212
213 void test_ppoll_big(void)
214 {
215 struct pollfd ufds[MAX_FDS];
216 char buf[BUF_SIZE];
217 int ret, i, fds[MAX_FDS];
218
219 for (i = 0; i < MAX_FDS; i++) {
220 fds[i] = dup(wait_fd);
221 if (fds[i] < 0) {
222 perror("dup");
223 }
224 ufds[i].fd = fds[i];
225 ufds[i].events = POLLIN|POLLPRI;
226 }
227
228 ret = ppoll(ufds, MAX_FDS, NULL, NULL);
229
230 if (ret < 0) {
231 perror("ppoll");
232 } else if (ret > 0) {
233 printf("# [ppoll] data available\n");
234 ret = read(wait_fd, buf, BUF_SIZE);
235 if (ret < 0) {
236 perror("[ppoll] read");
237 }
238 } else {
239 printf("# [ppoll] timeout\n");
240 }
241
242 for (i = 0; i < MAX_FDS; i++) {
243 ret = close(fds[i]);
244 if (ret != 0) {
245 perror("close");
246 }
247 }
248
249 return;
250 }
251
252 void test_epoll(void)
253 {
254 int ret, epollfd;
255 char buf[BUF_SIZE];
256 struct epoll_event epoll_event;
257
258 epollfd = epoll_create(NB_FD);
259 if (epollfd < 0) {
260 perror("[epoll] create");
261 goto end;
262 }
263
264 epoll_event.events = EPOLLIN | EPOLLPRI | EPOLLET;
265 epoll_event.data.fd = wait_fd;
266 ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, wait_fd, &epoll_event);
267 if (ret < 0) {
268 perror("[epoll] add");
269 goto end;
270 }
271
272 if (timeout > 0) {
273 ret = epoll_wait(epollfd, &epoll_event, 1, timeout);
274 } else {
275 ret = epoll_wait(epollfd, &epoll_event, 1, -1);
276 }
277
278 if (ret == 1) {
279 printf("# [epoll] data available\n");
280 ret = read(wait_fd, buf, BUF_SIZE);
281 if (ret < 0) {
282 perror("[epoll] read");
283 }
284 } else if (ret == 0) {
285 printf("# [epoll] timeout\n");
286 } else {
287 perror("epoll_wait");
288 }
289
290 end:
291 return;
292 }
293
294 void test_pepoll(void)
295 {
296 int ret, epollfd;
297 char buf[BUF_SIZE];
298 struct epoll_event epoll_event;
299
300 epollfd = epoll_create(NB_FD);
301 if (epollfd < 0) {
302 perror("[eppoll] create");
303 goto end;
304 }
305
306 epoll_event.events = EPOLLIN | EPOLLPRI | EPOLLET;
307 epoll_event.data.fd = wait_fd;
308 ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, wait_fd, &epoll_event);
309 if (ret < 0) {
310 perror("[eppoll] add");
311 goto end;
312 }
313
314 if (timeout > 0) {
315 ret = epoll_pwait(epollfd, &epoll_event, 1, timeout, NULL);
316 } else {
317 ret = epoll_pwait(epollfd, &epoll_event, 1, -1, NULL);
318 }
319
320 if (ret == 1) {
321 printf("# [eppoll] data available\n");
322 ret = read(wait_fd, buf, BUF_SIZE);
323 if (ret < 0) {
324 perror("[eppoll] read");
325 }
326 } else if (ret == 0) {
327 printf("# [eppoll] timeout\n");
328 } else {
329 perror("epoll_pwait");
330 }
331
332 end:
333 return;
334 }
335
336 void run_working_cases(void)
337 {
338 int ret;
339 int pipe_fds[2];
340
341 if (timeout > 0) {
342 /*
343 * We need an input pipe for some cases and stdin might
344 * have random data, so we create a dummy pipe for this
345 * test to make sure we are running under clean conditions.
346 */
347 ret = pipe(pipe_fds);
348 if (ret != 0) {
349 perror("pipe");
350 goto end;
351 }
352 wait_fd = pipe_fds[0];
353 }
354 test_select();
355 test_pselect();
356 test_select_big();
357 test_poll();
358 test_ppoll();
359 test_epoll();
360 test_pepoll();
361
362 if (timeout > 0) {
363 ret = close(pipe_fds[0]);
364 if (ret) {
365 perror("close");
366 }
367 ret = close(pipe_fds[1]);
368 if (ret) {
369 perror("close");
370 }
371 }
372
373 end:
374 return;
375 }
376
377 /*
378 * Ask for 100 FDs in a buffer for allocated for only 1 FD, should
379 * segfault (eventually with a "*** stack smashing detected ***" message).
380 * The event should contain an array of 100 FDs filled with garbage.
381 */
382 void ppoll_fds_buffer_overflow(void)
383 {
384 struct pollfd ufds[NB_FD];
385 char buf[BUF_SIZE];
386 int ret;
387
388 ufds[0].fd = wait_fd;
389 ufds[0].events = POLLIN|POLLPRI;
390
391 ret = syscall(SYS_ppoll, ufds, 100, NULL, NULL);
392
393 if (ret < 0) {
394 perror("ppoll");
395 } else if (ret > 0) {
396 printf("# [ppoll] data available\n");
397 ret = read(wait_fd, buf, BUF_SIZE);
398 if (ret < 0) {
399 perror("[ppoll] read");
400 }
401 } else {
402 printf("# [ppoll] timeout\n");
403 }
404
405 return;
406 }
407
408 /*
409 * Ask for ULONG_MAX FDs in a buffer for allocated for only 1 FD, should
410 * cleanly fail with a "Invalid argument".
411 * The event should contain an empty array of FDs and overflow = 1.
412 */
413 void ppoll_fds_ulong_max(void)
414 {
415 struct pollfd ufds[NB_FD];
416 char buf[BUF_SIZE];
417 int ret;
418
419 ufds[0].fd = wait_fd;
420 ufds[0].events = POLLIN|POLLPRI;
421
422 ret = syscall(SYS_ppoll, ufds, ULONG_MAX, NULL, NULL);
423
424 if (ret < 0) {
425 perror("# ppoll");
426 } else if (ret > 0) {
427 printf("# [ppoll] data available\n");
428 ret = read(wait_fd, buf, BUF_SIZE);
429 if (ret < 0) {
430 perror("[ppoll] read");
431 }
432 } else {
433 printf("# [ppoll] timeout\n");
434 }
435
436 return;
437 }
438
439 /*
440 * Pass an invalid file descriptor to pselect6(). The syscall should return
441 * -EBADF. The recorded event should contain a "ret = -EBADF (-9)".
442 */
443 void pselect_invalid_fd(void)
444 {
445 fd_set rfds;
446 int ret;
447 int fd;
448 char buf[BUF_SIZE];
449
450 /*
451 * Open a file, close it and use the closed FD in the pselect6 call.
452 */
453
454 fd = open("/dev/null", O_RDONLY);
455 if (fd == -1) {
456 perror("open");
457 goto error;
458 }
459
460 ret = close(fd);
461 if (ret == -1) {
462 perror("close");
463 goto error;
464 }
465
466 FD_ZERO(&rfds);
467 FD_SET(fd, &rfds);
468
469 ret = syscall(SYS_pselect6, fd + 1, &rfds, NULL, NULL, NULL, NULL);
470 if (ret == -1) {
471 perror("# pselect()");
472 } else if (ret) {
473 printf("# [pselect] data available\n");
474 ret = read(wait_fd, buf, BUF_SIZE);
475 if (ret < 0) {
476 perror("[pselect] read");
477 }
478 } else {
479 printf("# [pselect] timeout\n");
480 }
481 error:
482 return;
483 }
484
485 /*
486 * Invalid pointer as writefds, should output a ppoll event
487 * with 0 FDs.
488 */
489 void pselect_invalid_pointer(void)
490 {
491 fd_set rfds;
492 int ret;
493 char buf[BUF_SIZE];
494 void *invalid = (void *) 0x42;
495
496 FD_ZERO(&rfds);
497 FD_SET(wait_fd, &rfds);
498
499 ret = syscall(SYS_pselect6, 1, &rfds, (fd_set *) invalid, NULL, NULL,
500 NULL);
501
502 if (ret == -1) {
503 perror("# pselect()");
504 } else if (ret) {
505 printf("# [pselect] data available\n");
506 ret = read(wait_fd, buf, BUF_SIZE);
507 if (ret < 0) {
508 perror("[pselect] read");
509 }
510 } else {
511 printf("# [pselect] timeout\n");
512 }
513
514 }
515
516 /*
517 * Pass an invalid pointer to epoll_pwait, should fail with
518 * "Bad address", the event returns 0 FDs.
519 */
520 void epoll_pwait_invalid_pointer(void)
521 {
522 int ret, epollfd;
523 char buf[BUF_SIZE];
524 struct epoll_event epoll_event;
525 void *invalid = (void *) 0x42;
526
527 epollfd = epoll_create(NB_FD);
528 if (epollfd < 0) {
529 perror("[eppoll] create");
530 goto end;
531 }
532
533 epoll_event.events = EPOLLIN | EPOLLPRI | EPOLLET;
534 epoll_event.data.fd = wait_fd;
535 ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, wait_fd, &epoll_event);
536 if (ret < 0) {
537 perror("[eppoll] add");
538 goto end;
539 }
540
541 ret = syscall(SYS_epoll_pwait, epollfd,
542 (struct epoll_event *) invalid, 1, -1, NULL);
543
544 if (ret == 1) {
545 printf("# [eppoll] data available\n");
546 ret = read(wait_fd, buf, BUF_SIZE);
547 if (ret < 0) {
548 perror("[eppoll] read");
549 }
550 } else if (ret == 0) {
551 printf("# [eppoll] timeout\n");
552 } else {
553 perror("# epoll_pwait");
554 }
555
556 end:
557 return;
558 }
559
560 /*
561 * Set maxevents to INT_MAX, should output "Invalid argument"
562 * The event should return an empty array.
563 */
564 void epoll_pwait_int_max(void)
565 {
566 int ret, epollfd;
567 char buf[BUF_SIZE];
568 struct epoll_event epoll_event;
569
570 epollfd = epoll_create(NB_FD);
571 if (epollfd < 0) {
572 perror("[eppoll] create");
573 goto end;
574 }
575
576 epoll_event.events = EPOLLIN | EPOLLPRI | EPOLLET;
577 epoll_event.data.fd = wait_fd;
578 ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, wait_fd, &epoll_event);
579 if (ret < 0) {
580 perror("[eppoll] add");
581 goto end;
582 }
583
584 ret = syscall(SYS_epoll_pwait, epollfd, &epoll_event, INT_MAX, -1,
585 NULL);
586
587 if (ret == 1) {
588 printf("# [eppoll] data available\n");
589 ret = read(wait_fd, buf, BUF_SIZE);
590 if (ret < 0) {
591 perror("[eppoll] read");
592 }
593 } else if (ret == 0) {
594 printf("# [eppoll] timeout\n");
595 } else {
596 perror("# epoll_pwait");
597 }
598
599 end:
600 return;
601 }
602
603 void *ppoll_writer(void *arg)
604 {
605 struct ppoll_thread_data *data = (struct ppoll_thread_data *) arg;
606
607 while (!stop_thread) {
608 memset(data->ufds, data->value,
609 MAX_FDS * sizeof(struct pollfd));
610 usleep(100);
611 }
612
613 return NULL;
614 }
615
616 void do_ppoll(int *fds, struct pollfd *ufds)
617 {
618 int i, ret;
619 struct timespec ts;
620 char buf[BUF_SIZE];
621
622 ts.tv_sec = 0;
623 ts.tv_nsec = 1 * MSEC_PER_NSEC;
624
625 for (i = 0; i < MAX_FDS; i++) {
626 ufds[i].fd = fds[i];
627 ufds[i].events = POLLIN|POLLPRI;
628 }
629
630 ret = ppoll(ufds, MAX_FDS, &ts, NULL);
631
632 if (ret < 0) {
633 perror("ppoll");
634 } else if (ret > 0) {
635 printf("# [ppoll] data available\n");
636 ret = read(wait_fd, buf, BUF_SIZE);
637 if (ret < 0) {
638 perror("[ppoll] read");
639 }
640 } else {
641 printf("# [ppoll] timeout\n");
642 }
643 }
644
645 void stress_ppoll(int *fds, int value)
646 {
647 pthread_t writer;
648 int iter, ret;
649 struct ppoll_thread_data thread_data;
650 struct pollfd ufds[MAX_FDS];
651
652 thread_data.ufds = ufds;
653 thread_data.value = value;
654
655 stop_thread = 0;
656 ret = pthread_create(&writer, NULL, &ppoll_writer, (void *) &thread_data);
657 if (ret != 0) {
658 fprintf(stderr, "[error] pthread_create\n");
659 goto end;
660 }
661 for (iter = 0; iter < NR_ITER; iter++) {
662 do_ppoll(fds, ufds);
663 }
664 stop_thread = 1;
665 ret = pthread_join(writer, NULL);
666 if (ret) {
667 fprintf(stderr, "[error] pthread_join\n");
668 goto end;
669 }
670 end:
671 return;
672 }
673
674 /*
675 * 3 rounds of NR_ITER iterations with concurrent updates of the pollfd
676 * structure:
677 * - memset to 0
678 * - memset to 1
679 * - memset to INT_MAX
680 * Waits for input, but also set a timeout in case the input FD is overwritten
681 * before entering in the syscall. We use MAX_FDS FDs (dup of stdin), so the
682 * resulting trace is big (20MB).
683 *
684 * ppoll should work as expected and the trace should be readable at the end.
685 */
686 void ppoll_concurrent_write(void)
687 {
688 int i, ret, fds[MAX_FDS];
689
690 for (i = 0; i < MAX_FDS; i++) {
691 fds[i] = dup(wait_fd);
692 if (fds[i] < 0) {
693 perror("dup");
694 }
695 }
696
697 stress_ppoll(fds, 0);
698 stress_ppoll(fds, 1);
699 stress_ppoll(fds, INT_MAX);
700
701 for (i = 0; i < MAX_FDS; i++) {
702 ret = close(fds[i]);
703 if (ret != 0) {
704 perror("close");
705 }
706 }
707
708 return;
709 }
710
711 void *epoll_pwait_writer(void *addr)
712 {
713 srand(time(NULL));
714
715 while (!stop_thread) {
716 usleep(rand() % 30);
717 munmap(addr, MAX_FDS * sizeof(struct epoll_event));
718 }
719
720 return NULL;
721 }
722
723 /*
724 * epoll_pwait on MAX_FDS fds while a concurrent thread munmaps the
725 * buffer allocated for the returned data. This should randomly segfault.
726 * The trace should be readable and no kernel OOPS should occur.
727 */
728 void epoll_pwait_concurrent_munmap(void)
729 {
730 int ret, epollfd, i, fds[MAX_FDS];
731 char buf[BUF_SIZE];
732 struct epoll_event *epoll_event;
733 pthread_t writer;
734
735 for (i = 0; i < MAX_FDS; i++) {
736 fds[i] = -1;
737 }
738 epollfd = epoll_create(MAX_FDS);
739 if (epollfd < 0) {
740 perror("[eppoll] create");
741 goto end;
742 }
743
744 epoll_event = mmap(NULL, MAX_FDS * sizeof(struct epoll_event),
745 PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
746 -1, 0);
747 if (epoll_event == MAP_FAILED) {
748 perror("mmap");
749 goto end;
750 }
751
752 for (i = 0; i < MAX_FDS; i++) {
753 fds[i] = dup(wait_fd);
754 if (fds[i] < 0) {
755 perror("dup");
756 }
757 epoll_event[i].events = EPOLLIN | EPOLLPRI | EPOLLET;
758 epoll_event[i].data.fd = fds[i];
759 ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, fds[i], epoll_event);
760 if (ret < 0) {
761 perror("[eppoll] add");
762 goto end_unmap;
763 }
764 }
765 stop_thread = 0;
766 ret = pthread_create(&writer, NULL, &epoll_pwait_writer,
767 (void *) epoll_event);
768 if (ret != 0) {
769 fprintf(stderr, "[error] pthread_create\n");
770 goto end_unmap;
771 }
772
773 ret = epoll_pwait(epollfd, epoll_event, 1, 1, NULL);
774
775 if (ret == 1) {
776 printf("# [eppoll] data available\n");
777 ret = read(wait_fd, buf, BUF_SIZE);
778 if (ret < 0) {
779 perror("[eppoll] read");
780 }
781 } else if (ret == 0) {
782 printf("# [eppoll] timeout\n");
783 } else {
784 perror("# epoll_pwait");
785 }
786
787 stop_thread = 1;
788 ret = pthread_join(writer, NULL);
789 if (ret) {
790 fprintf(stderr, "[error] pthread_join\n");
791 goto end_unmap;
792 }
793 end_unmap:
794 for (i = 0; i < MAX_FDS; i++) {
795 ret = close(fds[i]);
796 if (ret != 0) {
797 perror("close");
798 }
799 }
800
801 ret = munmap(epoll_event, MAX_FDS * sizeof(struct epoll_event));
802 if (ret != 0) {
803 perror("munmap");
804 }
805
806 end:
807 return;
808 }
809
810 void usage(poptContext optCon, int exitcode, char *error, char *addl)
811 {
812 poptPrintUsage(optCon, stderr, 0);
813 if (error) {
814 fprintf(stderr, "%s: %s\n", error, addl);
815 }
816 exit(exitcode);
817 }
818
819 void print_list(void)
820 {
821 fprintf(stderr, "Test list (-t X):\n");
822 fprintf(stderr, "\t1: Working cases for select, pselect6, poll, ppoll "
823 "and epoll, waiting for input\n");
824 fprintf(stderr, "\t2: Timeout cases (1ms) for select, pselect6, poll, "
825 "ppoll and epoll\n");
826 fprintf(stderr, "\t3: pselect with an invalid fd\n");
827 fprintf(stderr, "\t4: ppoll with %d FDs\n", MAX_FDS);
828 fprintf(stderr, "\t5: ppoll buffer overflow, should segfault, waits "
829 "for input\n");
830 fprintf(stderr, "\t6: pselect with an invalid pointer, waits for "
831 "input\n");
832 fprintf(stderr, "\t7: ppoll with ulong_max fds, waits for input\n");
833 fprintf(stderr, "\t8: epoll_pwait with an invalid pointer, waits for "
834 "input\n");
835 fprintf(stderr, "\t9: epoll_pwait with maxevents set to INT_MAX, "
836 "waits for input\n");
837 fprintf(stderr, "\t10: ppoll with concurrent updates of the structure "
838 "from user-space, stress test (3000 iterations), "
839 "waits for input + timeout 1ms\n");
840 fprintf(stderr, "\t11: epoll_pwait with concurrent munmap of the buffer "
841 "from user-space, should randomly segfault, run "
842 "multiple times, waits for input + timeout 1ms\n");
843 }
844
845 int main(int argc, const char **argv)
846 {
847 int c, ret, test = -1;
848 poptContext optCon;
849 struct rlimit open_lim;
850
851 struct poptOption optionsTable[] = {
852 { "test", 't', POPT_ARG_INT, &test, 0,
853 "Test to run", NULL },
854 { "list", 'l', 0, 0, 'l',
855 "List of tests (-t X)", NULL },
856 POPT_AUTOHELP
857 { NULL, 0, 0, NULL, 0 }
858 };
859
860 optCon = poptGetContext(NULL, argc, argv, optionsTable, 0);
861
862 if (argc < 2) {
863 poptPrintUsage(optCon, stderr, 0);
864 ret = -1;
865 goto end;
866 }
867
868 ret = 0;
869
870 while ((c = poptGetNextOpt(optCon)) >= 0) {
871 switch(c) {
872 case 'l':
873 print_list();
874 goto end;
875 }
876 }
877
878 open_lim.rlim_cur = MAX_FDS + MIN_NR_FDS;
879 open_lim.rlim_max = MAX_FDS + MIN_NR_FDS;
880
881 ret = setrlimit(RLIMIT_NOFILE, &open_lim);
882 if (ret < 0) {
883 perror("setrlimit");
884 goto end;
885 }
886
887 /*
888 * Some tests might segfault, but we need the getpid() to be output
889 * for the validation, disabling the buffering on stdout works.
890 */
891 setbuf(stdout, NULL);
892 printf("%d\n", getpid());
893
894 wait_fd = STDIN_FILENO;
895
896 switch(test) {
897 case 1:
898 timeout = -1;
899 run_working_cases();
900 break;
901 case 2:
902 timeout = 1;
903 run_working_cases();
904 break;
905 case 3:
906 pselect_invalid_fd();
907 break;
908 case 4:
909 test_ppoll_big();
910 break;
911 case 5:
912 ppoll_fds_buffer_overflow();
913 break;
914 case 6:
915 pselect_invalid_pointer();
916 break;
917 case 7:
918 ppoll_fds_ulong_max();
919 break;
920 case 8:
921 epoll_pwait_invalid_pointer();
922 break;
923 case 9:
924 epoll_pwait_int_max();
925 break;
926 case 10:
927 ppoll_concurrent_write();
928 break;
929 case 11:
930 epoll_pwait_concurrent_munmap();
931 break;
932 default:
933 poptPrintUsage(optCon, stderr, 0);
934 ret = -1;
935 break;
936 }
937
938 end:
939 poptFreeContext(optCon);
940 return ret;
941 }
This page took 0.086139 seconds and 5 git commands to generate.