2 Unix SMB/CIFS implementation.
4 testing of the events subsystem
6 Copyright (C) Stefan Metzmacher 2006-2009
7 Copyright (C) Jeremy Allison 2013
9 ** NOTE! The following LGPL license applies to the tevent
10 ** library. This does NOT imply that all of Samba is released
13 This library is free software; you can redistribute it and/or
14 modify it under the terms of the GNU Lesser General Public
15 License as published by the Free Software Foundation; either
16 version 3 of the License, or (at your option) any later version.
18 This library is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 Lesser General Public License for more details.
23 You should have received a copy of the GNU Lesser General Public
24 License along with this library; if not, see <http://www.gnu.org/licenses/>.
28 #include "lib/tevent/tevent.h"
29 #include "system/filesys.h"
30 #include "system/select.h"
31 #include "system/network.h"
32 #include "torture/torture.h"
33 #include "torture/local/proto.h"
41 static void fde_handler_read(struct tevent_context *ev_ctx, struct tevent_fd *f,
42 uint16_t flags, void *private_data)
44 int *fd = (int *)private_data;
47 kill(getpid(), SIGUSR1);
49 kill(getpid(), SIGALRM);
55 static void fde_handler_write(struct tevent_context *ev_ctx, struct tevent_fd *f,
56 uint16_t flags, void *private_data)
58 int *fd = (int *)private_data;
64 /* This will only fire if the fd's returned from pipe() are bi-directional. */
65 static void fde_handler_read_1(struct tevent_context *ev_ctx, struct tevent_fd *f,
66 uint16_t flags, void *private_data)
68 int *fd = (int *)private_data;
71 kill(getpid(), SIGUSR1);
73 kill(getpid(), SIGALRM);
79 /* This will only fire if the fd's returned from pipe() are bi-directional. */
80 static void fde_handler_write_1(struct tevent_context *ev_ctx, struct tevent_fd *f,
81 uint16_t flags, void *private_data)
83 int *fd = (int *)private_data;
88 static void finished_handler(struct tevent_context *ev_ctx, struct tevent_timer *te,
89 struct timeval tval, void *private_data)
91 int *finished = (int *)private_data;
95 static void count_handler(struct tevent_context *ev_ctx, struct tevent_signal *te,
96 int signum, int count, void *info, void *private_data)
98 int *countp = (int *)private_data;
102 static bool test_event_context(struct torture_context *test,
103 const void *test_data)
105 struct tevent_context *ev_ctx;
106 int fd[2] = { -1, -1 };
107 const char *backend = (const char *)test_data;
108 int alarm_count=0, info_count=0;
109 struct tevent_fd *fde_read;
110 struct tevent_fd *fde_read_1;
111 struct tevent_fd *fde_write;
112 struct tevent_fd *fde_write_1;
114 struct tevent_signal *se1 = NULL;
117 struct tevent_signal *se2 = NULL;
120 struct tevent_signal *se3 = NULL;
125 ev_ctx = tevent_context_init_byname(test, backend);
126 if (ev_ctx == NULL) {
127 torture_comment(test, "event backend '%s' not supported\n", backend);
131 torture_comment(test, "backend '%s' - %s\n",
132 backend, __FUNCTION__);
140 fde_read = tevent_add_fd(ev_ctx, ev_ctx, fd[0], TEVENT_FD_READ,
141 fde_handler_read, fd);
142 fde_write_1 = tevent_add_fd(ev_ctx, ev_ctx, fd[0], TEVENT_FD_WRITE,
143 fde_handler_write_1, fd);
145 fde_write = tevent_add_fd(ev_ctx, ev_ctx, fd[1], TEVENT_FD_WRITE,
146 fde_handler_write, fd);
147 fde_read_1 = tevent_add_fd(ev_ctx, ev_ctx, fd[1], TEVENT_FD_READ,
148 fde_handler_read_1, fd);
150 tevent_fd_set_auto_close(fde_read);
151 tevent_fd_set_auto_close(fde_write);
153 tevent_add_timer(ev_ctx, ev_ctx, timeval_current_ofs(2,0),
154 finished_handler, &finished);
157 se1 = tevent_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESTART, count_handler, &alarm_count);
158 torture_assert(test, se1 != NULL, "failed to setup se1");
161 se2 = tevent_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESETHAND, count_handler, &alarm_count);
162 torture_assert(test, se2 != NULL, "failed to setup se2");
165 se3 = tevent_add_signal(ev_ctx, ev_ctx, SIGUSR1, SA_SIGINFO, count_handler, &info_count);
166 torture_assert(test, se3 != NULL, "failed to setup se3");
169 t = timeval_current();
172 if (tevent_loop_once(ev_ctx) == -1) {
174 torture_fail(test, talloc_asprintf(test, "Failed event loop %s\n", strerror(errno)));
178 talloc_free(fde_read);
179 talloc_free(fde_write);
180 talloc_free(fde_read_1);
181 talloc_free(fde_write_1);
183 while (alarm_count < fde_count+1) {
184 if (tevent_loop_once(ev_ctx) == -1) {
189 torture_comment(test, "Got %.2f pipe events/sec\n", fde_count/timeval_elapsed(&t));
195 torture_assert_int_equal(test, alarm_count, 1+fde_count, "alarm count mismatch");
199 * we do not call talloc_free(se2)
200 * because it is already gone,
201 * after triggering the event handler.
207 torture_assert_int_equal(test, info_count, fde_count, "info count mismatch");
215 struct test_event_fd1_state {
216 struct torture_context *tctx;
218 struct tevent_context *ev;
220 struct tevent_timer *te;
221 struct tevent_fd *fde0;
222 struct tevent_fd *fde1;
232 static void test_event_fd1_fde_handler(struct tevent_context *ev_ctx,
233 struct tevent_fd *fde,
237 struct test_event_fd1_state *state =
238 (struct test_event_fd1_state *)private_data;
240 if (state->drain_done) {
241 state->finished = true;
242 state->error = __location__;
250 if (!(flags & TEVENT_FD_READ)) {
251 state->finished = true;
252 state->error = __location__;
256 ret = read(state->sock[0], &c, 1);
264 tevent_fd_set_flags(fde, 0);
265 state->drain_done = true;
269 if (!state->got_write) {
272 if (flags != TEVENT_FD_WRITE) {
273 state->finished = true;
274 state->error = __location__;
277 state->got_write = true;
280 * we write to the other socket...
282 write(state->sock[1], &c, 1);
283 TEVENT_FD_NOT_WRITEABLE(fde);
284 TEVENT_FD_READABLE(fde);
288 if (!state->got_read) {
289 if (flags != TEVENT_FD_READ) {
290 state->finished = true;
291 state->error = __location__;
294 state->got_read = true;
296 TEVENT_FD_NOT_READABLE(fde);
300 state->finished = true;
301 state->error = __location__;
305 static void test_event_fd1_finished(struct tevent_context *ev_ctx,
306 struct tevent_timer *te,
310 struct test_event_fd1_state *state =
311 (struct test_event_fd1_state *)private_data;
313 if (state->drain_done) {
314 state->finished = true;
318 if (!state->got_write) {
319 state->finished = true;
320 state->error = __location__;
324 if (!state->got_read) {
325 state->finished = true;
326 state->error = __location__;
331 if (state->loop_count > 3) {
332 state->finished = true;
333 state->error = __location__;
337 state->got_write = false;
338 state->got_read = false;
340 tevent_fd_set_flags(state->fde0, TEVENT_FD_WRITE);
342 if (state->loop_count > 2) {
344 TALLOC_FREE(state->fde1);
345 TEVENT_FD_READABLE(state->fde0);
348 state->te = tevent_add_timer(state->ev, state->ev,
349 timeval_current_ofs(0,2000),
350 test_event_fd1_finished, state);
353 static bool test_event_fd1(struct torture_context *tctx,
354 const void *test_data)
356 struct test_event_fd1_state state;
360 state.backend = (const char *)test_data;
362 state.ev = tevent_context_init_byname(tctx, state.backend);
363 if (state.ev == NULL) {
364 torture_skip(tctx, talloc_asprintf(tctx,
365 "event backend '%s' not supported\n",
370 tevent_set_debug_stderr(state.ev);
371 torture_comment(tctx, "backend '%s' - %s\n",
372 state.backend, __FUNCTION__);
375 * This tests the following:
377 * It monitors the state of state.sock[0]
378 * with tevent_fd, but we never read/write on state.sock[0]
379 * while state.sock[1] * is only used to write a few bytes.
382 * - we wait only for TEVENT_FD_WRITE on state.sock[0]
383 * - we write 1 byte to state.sock[1]
384 * - we wait only for TEVENT_FD_READ on state.sock[0]
385 * - we disable events on state.sock[0]
386 * - the timer event restarts the loop
387 * Then we close state.sock[1]
389 * - we wait for TEVENT_FD_READ/WRITE on state.sock[0]
390 * - we try to read 1 byte
391 * - if the read gets an error of returns 0
392 * we disable the event handler
393 * - the timer finishes the test
397 socketpair(AF_UNIX, SOCK_STREAM, 0, state.sock);
399 state.te = tevent_add_timer(state.ev, state.ev,
400 timeval_current_ofs(0,1000),
401 test_event_fd1_finished, &state);
402 state.fde0 = tevent_add_fd(state.ev, state.ev,
403 state.sock[0], TEVENT_FD_WRITE,
404 test_event_fd1_fde_handler, &state);
405 /* state.fde1 is only used to auto close */
406 state.fde1 = tevent_add_fd(state.ev, state.ev,
408 test_event_fd1_fde_handler, &state);
410 tevent_fd_set_auto_close(state.fde0);
411 tevent_fd_set_auto_close(state.fde1);
413 while (!state.finished) {
415 if (tevent_loop_once(state.ev) == -1) {
416 talloc_free(state.ev);
417 torture_fail(tctx, talloc_asprintf(tctx,
418 "Failed event loop %s\n",
423 talloc_free(state.ev);
425 torture_assert(tctx, state.error == NULL, talloc_asprintf(tctx,
431 struct test_event_fd2_state {
432 struct torture_context *tctx;
434 struct tevent_context *ev;
435 struct tevent_timer *te;
436 struct test_event_fd2_sock {
437 struct test_event_fd2_state *state;
439 struct tevent_fd *fde;
448 static void test_event_fd2_sock_handler(struct tevent_context *ev_ctx,
449 struct tevent_fd *fde,
453 struct test_event_fd2_sock *cur_sock =
454 (struct test_event_fd2_sock *)private_data;
455 struct test_event_fd2_state *state = cur_sock->state;
456 struct test_event_fd2_sock *oth_sock = NULL;
460 if (cur_sock == &state->sock0) {
461 oth_sock = &state->sock1;
463 oth_sock = &state->sock0;
466 if (oth_sock->num_written == 1) {
467 if (flags != (TEVENT_FD_READ | TEVENT_FD_WRITE)) {
468 state->finished = true;
469 state->error = __location__;
474 if (cur_sock->num_read == oth_sock->num_written) {
475 state->finished = true;
476 state->error = __location__;
480 if (!(flags & TEVENT_FD_READ)) {
481 state->finished = true;
482 state->error = __location__;
486 if (oth_sock->num_read >= PIPE_BUF) {
488 * On Linux we become writable once we've read
489 * one byte. On Solaris we only become writable
490 * again once we've read 4096 bytes. PIPE_BUF
491 * is probably a safe bet to test against.
493 * There should be room to write a byte again
495 if (!(flags & TEVENT_FD_WRITE)) {
496 state->finished = true;
497 state->error = __location__;
502 if ((flags & TEVENT_FD_WRITE) && !cur_sock->got_full) {
503 v = (uint8_t)cur_sock->num_written;
504 ret = write(cur_sock->fd, &v, 1);
506 state->finished = true;
507 state->error = __location__;
510 cur_sock->num_written++;
511 if (cur_sock->num_written > 0x80000000) {
512 state->finished = true;
513 state->error = __location__;
519 if (!cur_sock->got_full) {
520 cur_sock->got_full = true;
522 if (!oth_sock->got_full) {
525 * lets wait for oth_sock
528 tevent_fd_set_flags(cur_sock->fde, 0);
533 * oth_sock waited for cur_sock,
536 tevent_fd_set_flags(oth_sock->fde,
537 TEVENT_FD_READ|TEVENT_FD_WRITE);
540 ret = read(cur_sock->fd, &v, 1);
542 state->finished = true;
543 state->error = __location__;
546 c = (uint8_t)cur_sock->num_read;
548 state->finished = true;
549 state->error = __location__;
552 cur_sock->num_read++;
554 if (cur_sock->num_read < oth_sock->num_written) {
555 /* there is more to read */
559 * we read everything, we need to remove TEVENT_FD_WRITE
562 TEVENT_FD_NOT_WRITEABLE(cur_sock->fde);
564 if (oth_sock->num_read == cur_sock->num_written) {
566 * both directions are finished
568 state->finished = true;
574 static void test_event_fd2_finished(struct tevent_context *ev_ctx,
575 struct tevent_timer *te,
579 struct test_event_fd2_state *state =
580 (struct test_event_fd2_state *)private_data;
583 * this should never be triggered
585 state->finished = true;
586 state->error = __location__;
589 static bool test_event_fd2(struct torture_context *tctx,
590 const void *test_data)
592 struct test_event_fd2_state state;
598 state.backend = (const char *)test_data;
600 state.ev = tevent_context_init_byname(tctx, state.backend);
601 if (state.ev == NULL) {
602 torture_skip(tctx, talloc_asprintf(tctx,
603 "event backend '%s' not supported\n",
608 tevent_set_debug_stderr(state.ev);
609 torture_comment(tctx, "backend '%s' - %s\n",
610 state.backend, __FUNCTION__);
613 * This tests the following
615 * - We write 1 byte to each socket
616 * - We wait for TEVENT_FD_READ/WRITE on both sockets
617 * - When we get TEVENT_FD_WRITE we write 1 byte
618 * until both socket buffers are full, which
619 * means both sockets only get TEVENT_FD_READ.
620 * - Then we read 1 byte until we have consumed
621 * all bytes the other end has written.
625 socketpair(AF_UNIX, SOCK_STREAM, 0, sock);
628 * the timer should never expire
630 state.te = tevent_add_timer(state.ev, state.ev,
631 timeval_current_ofs(600, 0),
632 test_event_fd2_finished, &state);
633 state.sock0.state = &state;
634 state.sock0.fd = sock[0];
635 state.sock0.fde = tevent_add_fd(state.ev, state.ev,
637 TEVENT_FD_READ | TEVENT_FD_WRITE,
638 test_event_fd2_sock_handler,
640 state.sock1.state = &state;
641 state.sock1.fd = sock[1];
642 state.sock1.fde = tevent_add_fd(state.ev, state.ev,
644 TEVENT_FD_READ | TEVENT_FD_WRITE,
645 test_event_fd2_sock_handler,
648 tevent_fd_set_auto_close(state.sock0.fde);
649 tevent_fd_set_auto_close(state.sock1.fde);
651 write(state.sock0.fd, &c, 1);
652 state.sock0.num_written++;
653 write(state.sock1.fd, &c, 1);
654 state.sock1.num_written++;
656 while (!state.finished) {
658 if (tevent_loop_once(state.ev) == -1) {
659 talloc_free(state.ev);
660 torture_fail(tctx, talloc_asprintf(tctx,
661 "Failed event loop %s\n",
666 talloc_free(state.ev);
668 torture_assert(tctx, state.error == NULL, talloc_asprintf(tctx,
676 static pthread_mutex_t threaded_mutex = PTHREAD_MUTEX_INITIALIZER;
677 static bool do_shutdown = false;
679 static void test_event_threaded_lock(void)
682 ret = pthread_mutex_lock(&threaded_mutex);
686 static void test_event_threaded_unlock(void)
689 ret = pthread_mutex_unlock(&threaded_mutex);
693 static void test_event_threaded_trace(enum tevent_trace_point point,
697 case TEVENT_TRACE_BEFORE_WAIT:
698 test_event_threaded_unlock();
700 case TEVENT_TRACE_AFTER_WAIT:
701 test_event_threaded_lock();
703 case TEVENT_TRACE_BEFORE_LOOP_ONCE:
704 case TEVENT_TRACE_AFTER_LOOP_ONCE:
709 static void test_event_threaded_timer(struct tevent_context *ev,
710 struct tevent_timer *te,
711 struct timeval current_time,
717 static void *test_event_poll_thread(void *private_data)
719 struct tevent_context *ev = (struct tevent_context *)private_data;
721 test_event_threaded_lock();
725 ret = tevent_loop_once(ev);
728 test_event_threaded_unlock();
735 static void test_event_threaded_read_handler(struct tevent_context *ev,
736 struct tevent_fd *fde,
740 int *pfd = (int *)private_data;
744 if ((flags & TEVENT_FD_READ) == 0) {
749 nread = read(*pfd, &c, 1);
750 } while ((nread == -1) && (errno == EINTR));
755 static bool test_event_context_threaded(struct torture_context *test,
756 const void *test_data)
758 struct tevent_context *ev;
759 struct tevent_timer *te;
760 struct tevent_fd *fde;
761 pthread_t poll_thread;
766 ev = tevent_context_init_byname(test, "poll_mt");
767 torture_assert(test, ev != NULL, "poll_mt not supported");
769 tevent_set_trace_callback(ev, test_event_threaded_trace, NULL);
771 te = tevent_add_timer(ev, ev, timeval_current_ofs(5, 0),
772 test_event_threaded_timer, NULL);
773 torture_assert(test, te != NULL, "Could not add timer");
775 ret = pthread_create(&poll_thread, NULL, test_event_poll_thread, ev);
776 torture_assert(test, ret == 0, "Could not create poll thread");
779 torture_assert(test, ret == 0, "Could not create pipe");
783 test_event_threaded_lock();
785 fde = tevent_add_fd(ev, ev, fds[0], TEVENT_FD_READ,
786 test_event_threaded_read_handler, &fds[0]);
787 torture_assert(test, fde != NULL, "Could not add fd event");
789 test_event_threaded_unlock();
793 write(fds[1], &c, 1);
797 test_event_threaded_lock();
799 test_event_threaded_unlock();
801 write(fds[1], &c, 1);
803 ret = pthread_join(poll_thread, NULL);
804 torture_assert(test, ret == 0, "pthread_join failed");
811 struct torture_suite *torture_local_event(TALLOC_CTX *mem_ctx)
813 struct torture_suite *suite = torture_suite_create(mem_ctx, "event");
814 const char **list = tevent_backend_list(suite);
817 for (i=0;list && list[i];i++) {
818 struct torture_suite *backend_suite;
820 backend_suite = torture_suite_create(mem_ctx, list[i]);
822 torture_suite_add_simple_tcase_const(backend_suite,
825 (const void *)list[i]);
826 torture_suite_add_simple_tcase_const(backend_suite,
829 (const void *)list[i]);
830 torture_suite_add_simple_tcase_const(backend_suite,
833 (const void *)list[i]);
835 torture_suite_add_suite(suite, backend_suite);
839 torture_suite_add_simple_tcase_const(suite, "threaded_poll_mt",
840 test_event_context_threaded,