1 /* $NetBSD: t_eventfd.c,v 1.3 2022/02/20 15:21:14 thorpej Exp $ */
2
3 /*-
4 * Copyright (c) 2020 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __COPYRIGHT("@(#) Copyright (c) 2020\
31 The NetBSD Foundation, inc. All rights reserved.");
32 __RCSID("$NetBSD: t_eventfd.c,v 1.3 2022/02/20 15:21:14 thorpej Exp $");
33
34 #include <sys/types.h>
35 #include <sys/event.h>
36 #include <sys/eventfd.h>
37 #include <sys/ioctl.h>
38 #include <sys/select.h>
39 #include <sys/stat.h>
40 #include <sys/syscall.h>
41 #include <errno.h>
42 #include <poll.h>
43 #include <pthread.h>
44 #include <stdlib.h>
45 #include <stdio.h>
46 #include <time.h>
47 #include <unistd.h>
48
49 #include <atf-c.h>
50
51 struct helper_context {
52 int efd;
53
54 pthread_mutex_t mutex;
55 pthread_cond_t cond;
56 pthread_barrier_t barrier;
57 int state;
58 };
59
60 static void
init_helper_context(struct helper_context * const ctx)61 init_helper_context(struct helper_context * const ctx)
62 {
63 pthread_condattr_t condattr;
64
65 memset(ctx, 0, sizeof(*ctx));
66
67 ATF_REQUIRE(pthread_mutex_init(&ctx->mutex, NULL) == 0);
68
69 ATF_REQUIRE(pthread_condattr_init(&condattr) == 0);
70 ATF_REQUIRE(pthread_condattr_setclock(&condattr, CLOCK_MONOTONIC) == 0);
71 ATF_REQUIRE(pthread_cond_init(&ctx->cond, &condattr) == 0);
72 ATF_REQUIRE(pthread_condattr_destroy(&condattr) == 0);
73
74 ATF_REQUIRE(pthread_barrier_init(&ctx->barrier, NULL, 2) == 0);
75 }
76
77 static void
set_state(struct helper_context * const ctx,int const new)78 set_state(struct helper_context * const ctx, int const new)
79 {
80 pthread_mutex_lock(&ctx->mutex);
81 ctx->state = new;
82 pthread_cond_signal(&ctx->cond);
83 pthread_mutex_unlock(&ctx->mutex);
84 }
85
86 static int
get_state(struct helper_context * const ctx)87 get_state(struct helper_context * const ctx)
88 {
89 int rv;
90
91 pthread_mutex_lock(&ctx->mutex);
92 rv = ctx->state;
93 pthread_mutex_unlock(&ctx->mutex);
94
95 return rv;
96 }
97
98 static bool
wait_state(struct helper_context * const ctx,int const val)99 wait_state(struct helper_context * const ctx, int const val)
100 {
101 struct timespec deadline;
102 int error;
103 bool rv;
104
105 pthread_mutex_lock(&ctx->mutex);
106
107 ATF_REQUIRE(clock_gettime(CLOCK_MONOTONIC, &deadline) == 0);
108 deadline.tv_sec += 5;
109
110 while (ctx->state != val) {
111 error = pthread_cond_timedwait(&ctx->cond, &ctx->mutex,
112 &deadline);
113 if (error) {
114 break;
115 }
116 }
117 rv = ctx->state == val;
118
119 pthread_mutex_unlock(&ctx->mutex);
120
121 return rv;
122 }
123
124 static bool
wait_barrier(struct helper_context * const ctx)125 wait_barrier(struct helper_context * const ctx)
126 {
127 int rv = pthread_barrier_wait(&ctx->barrier);
128
129 return rv == 0 || rv == PTHREAD_BARRIER_SERIAL_THREAD;
130 }
131
132 /*****************************************************************************/
133
134 static void *
eventfd_normal_helper(void * const v)135 eventfd_normal_helper(void * const v)
136 {
137 struct helper_context * const ctx = v;
138 eventfd_t efd_value;
139
140 ATF_REQUIRE(wait_barrier(ctx));
141
142 /* Read the value. This will reset it to zero. */
143 ATF_REQUIRE(get_state(ctx) == 666);
144 ATF_REQUIRE(eventfd_read(ctx->efd, &efd_value) == 0);
145
146 /* Assert the value. */
147 ATF_REQUIRE(efd_value == 0xcafebabe);
148
149 set_state(ctx, 0);
150
151 /* Wait for the main thread to prep the next test. */
152 ATF_REQUIRE(wait_barrier(ctx));
153
154 /* Read the value. */
155 ATF_REQUIRE(eventfd_read(ctx->efd, &efd_value) == 0);
156
157 /* Assert the value. */
158 ATF_REQUIRE(efd_value == 0xbeefcafe);
159
160 ATF_REQUIRE(wait_barrier(ctx));
161
162 return NULL;
163 }
164
165 ATF_TC(eventfd_normal);
ATF_TC_HEAD(eventfd_normal,tc)166 ATF_TC_HEAD(eventfd_normal, tc)
167 {
168 atf_tc_set_md_var(tc, "descr",
169 "validates basic normal eventfd operation");
170 }
ATF_TC_BODY(eventfd_normal,tc)171 ATF_TC_BODY(eventfd_normal, tc)
172 {
173 struct helper_context ctx;
174 pthread_t helper;
175 void *join_val;
176
177 init_helper_context(&ctx);
178
179 ATF_REQUIRE((ctx.efd = eventfd(0, 0)) >= 0);
180
181 ATF_REQUIRE(pthread_create(&helper, NULL,
182 eventfd_normal_helper, &ctx) == 0);
183
184 /*
185 * Wait for the helper to block in read(). Give it some time
186 * so that if the read fails or returns immediately, we'll
187 * notice.
188 */
189 set_state(&ctx, 666);
190 ATF_REQUIRE(wait_barrier(&ctx));
191 sleep(2);
192 ATF_REQUIRE(get_state(&ctx) == 666);
193
194 /* Write a distinct value; helper will assert it. */
195 ATF_REQUIRE(eventfd_write(ctx.efd, 0xcafebabe) == 0);
196
197 /* Wait for helper to read the value. */
198 ATF_REQUIRE(wait_state(&ctx, 0));
199
200 /* Helper is now blocked in a barrier. */
201
202 /* Test additive property of the efd value. */
203 ATF_REQUIRE(eventfd_write(ctx.efd, 0x0000cafe) == 0);
204 ATF_REQUIRE(eventfd_write(ctx.efd, 0xbeef0000) == 0);
205
206 /* Satisfy the barrier; helper will read value and assert 0xbeefcafe. */
207 ATF_REQUIRE(wait_barrier(&ctx));
208
209 /* And wait for it to finish. */
210 ATF_REQUIRE(wait_barrier(&ctx));
211
212 /* Reap the helper. */
213 ATF_REQUIRE(pthread_join(helper, &join_val) == 0);
214
215 (void) close(ctx.efd);
216 }
217
218 /*****************************************************************************/
219
220 ATF_TC(eventfd_semaphore);
ATF_TC_HEAD(eventfd_semaphore,tc)221 ATF_TC_HEAD(eventfd_semaphore, tc)
222 {
223 atf_tc_set_md_var(tc, "descr",
224 "validates semaphore and non-blocking eventfd operation");
225 }
ATF_TC_BODY(eventfd_semaphore,tc)226 ATF_TC_BODY(eventfd_semaphore, tc)
227 {
228 eventfd_t efd_value;
229 int efd;
230
231 ATF_REQUIRE((efd = eventfd(3, EFD_SEMAPHORE | EFD_NONBLOCK)) >= 0);
232
233 /* 3 reads should succeed without blocking. */
234 ATF_REQUIRE(eventfd_read(efd, &efd_value) == 0);
235 ATF_REQUIRE(efd_value == 1);
236
237 ATF_REQUIRE(eventfd_read(efd, &efd_value) == 0);
238 ATF_REQUIRE(efd_value == 1);
239
240 ATF_REQUIRE(eventfd_read(efd, &efd_value) == 0);
241 ATF_REQUIRE(efd_value == 1);
242
243 /* This one should block. */
244 ATF_REQUIRE_ERRNO(EAGAIN,
245 eventfd_read(efd, &efd_value) == -1);
246
247 /* Add 1 to the semaphore. */
248 ATF_REQUIRE(eventfd_write(efd, 1) == 0);
249
250 /* One more read allowed. */
251 ATF_REQUIRE(eventfd_read(efd, &efd_value) == 0);
252 ATF_REQUIRE(efd_value == 1);
253
254 /* And this one again should block. */
255 ATF_REQUIRE_ERRNO(EAGAIN,
256 eventfd_read(efd, &efd_value) == -1);
257
258 (void) close(efd);
259 }
260
261 /*****************************************************************************/
262
263 ATF_TC(eventfd_select_poll_kevent_immed);
ATF_TC_HEAD(eventfd_select_poll_kevent_immed,tc)264 ATF_TC_HEAD(eventfd_select_poll_kevent_immed, tc)
265 {
266 atf_tc_set_md_var(tc, "descr",
267 "validates select/poll/kevent behavior - immediate return");
268 }
ATF_TC_BODY(eventfd_select_poll_kevent_immed,tc)269 ATF_TC_BODY(eventfd_select_poll_kevent_immed, tc)
270 {
271 const struct timespec ts = { .tv_sec = 0, .tv_nsec = 0 };
272 struct timeval tv;
273 struct pollfd fds[1];
274 fd_set readfds, writefds, exceptfds;
275 int efd;
276 int kq;
277 struct kevent kev[2];
278
279 ATF_REQUIRE((efd = eventfd(0, EFD_NONBLOCK)) >= 0);
280
281 ATF_REQUIRE((kq = kqueue()) >= 0);
282 EV_SET(&kev[0], efd, EVFILT_READ, EV_ADD, 0, 0, NULL);
283 EV_SET(&kev[1], efd, EVFILT_WRITE, EV_ADD, 0, 0, NULL);
284 ATF_REQUIRE(kevent(kq, kev, 2, NULL, 0, &ts) == 0);
285
286 /*
287 * efd should be writable but not readable. Pass all of the
288 * event bits; we should only get back POLLOUT | POLLWRNORM.
289 */
290 fds[0].fd = efd;
291 fds[0].events = POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI |
292 POLLOUT | POLLWRNORM | POLLWRBAND | POLLHUP;
293 fds[0].revents = 0;
294 ATF_REQUIRE(poll(fds, 1, 0) == 1);
295 ATF_REQUIRE(fds[0].revents == (POLLOUT | POLLWRNORM));
296
297 /*
298 * As above; efd should only be set in writefds upon return
299 * from the select() call.
300 */
301 FD_ZERO(&readfds);
302 FD_ZERO(&writefds);
303 FD_ZERO(&exceptfds);
304 tv.tv_sec = 0;
305 tv.tv_usec = 0;
306 FD_SET(efd, &readfds);
307 FD_SET(efd, &writefds);
308 FD_SET(efd, &exceptfds);
309 ATF_REQUIRE(select(efd + 1, &readfds, &writefds, &exceptfds, &tv) == 1);
310 ATF_REQUIRE(!FD_ISSET(efd, &readfds));
311 ATF_REQUIRE(FD_ISSET(efd, &writefds));
312 ATF_REQUIRE(!FD_ISSET(efd, &exceptfds));
313
314 /*
315 * Check that we get an EVFILT_WRITE event (and only that event)
316 * on efd.
317 */
318 memset(kev, 0, sizeof(kev));
319 ATF_REQUIRE(kevent(kq, NULL, 0, kev, 2, &ts) == 1);
320 ATF_REQUIRE(kev[0].ident == (uintptr_t)efd);
321 ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);
322 ATF_REQUIRE((kev[0].flags & (EV_EOF | EV_ERROR)) == 0);
323 ATF_REQUIRE(kev[0].data == 0);
324
325 /*
326 * Write the maximum value into the eventfd. This should result
327 * in the eventfd becoming readable but NOT writable.
328 */
329 ATF_REQUIRE(eventfd_write(efd, UINT64_MAX - 1) == 0);
330
331 fds[0].fd = efd;
332 fds[0].events = POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI |
333 POLLOUT | POLLWRNORM | POLLWRBAND | POLLHUP;
334 fds[0].revents = 0;
335 ATF_REQUIRE(poll(fds, 1, 0) == 1);
336 ATF_REQUIRE(fds[0].revents == (POLLIN | POLLRDNORM));
337
338 FD_ZERO(&readfds);
339 FD_ZERO(&writefds);
340 FD_ZERO(&exceptfds);
341 tv.tv_sec = 0;
342 tv.tv_usec = 0;
343 FD_SET(efd, &readfds);
344 FD_SET(efd, &writefds);
345 FD_SET(efd, &exceptfds);
346 ATF_REQUIRE(select(efd + 1, &readfds, &writefds, &exceptfds, &tv) == 1);
347 ATF_REQUIRE(FD_ISSET(efd, &readfds));
348 ATF_REQUIRE(!FD_ISSET(efd, &writefds));
349 ATF_REQUIRE(!FD_ISSET(efd, &exceptfds));
350
351 /*
352 * Check that we get an EVFILT_READ event (and only that event)
353 * on efd.
354 */
355 memset(kev, 0, sizeof(kev));
356 ATF_REQUIRE(kevent(kq, NULL, 0, kev, 2, &ts) == 1);
357 ATF_REQUIRE(kev[0].ident == (uintptr_t)efd);
358 ATF_REQUIRE(kev[0].filter == EVFILT_READ);
359 ATF_REQUIRE((kev[0].flags & (EV_EOF | EV_ERROR)) == 0);
360 ATF_REQUIRE(kev[0].data == (int64_t)(UINT64_MAX - 1));
361
362 (void) close(kq);
363 (void) close(efd);
364 }
365
366 /*****************************************************************************/
367
368 static void *
eventfd_select_poll_kevent_block_helper(void * const v)369 eventfd_select_poll_kevent_block_helper(void * const v)
370 {
371 struct helper_context * const ctx = v;
372 struct pollfd fds[1];
373 fd_set selfds;
374 eventfd_t efd_value;
375 int kq;
376 struct kevent kev[1];
377
378 fds[0].fd = ctx->efd;
379 fds[0].events = POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI;
380 fds[0].revents = 0;
381
382 ATF_REQUIRE_ERRNO(EAGAIN,
383 eventfd_read(ctx->efd, &efd_value) == -1);
384
385 ATF_REQUIRE(wait_barrier(ctx));
386
387 ATF_REQUIRE(get_state(ctx) == 666);
388 ATF_REQUIRE(poll(fds, 1, INFTIM) == 1);
389 ATF_REQUIRE(fds[0].revents == (POLLIN | POLLRDNORM));
390 set_state(ctx, 0);
391
392 ATF_REQUIRE(wait_barrier(ctx));
393
394 /*
395 * The maximum value was written to the eventfd, so we
396 * should block waiting for writability.
397 */
398 fds[0].fd = ctx->efd;
399 fds[0].events = POLLOUT | POLLWRNORM;
400 fds[0].revents = 0;
401
402 ATF_REQUIRE_ERRNO(EAGAIN,
403 eventfd_write(ctx->efd, UINT64_MAX - 1) == -1);
404
405 ATF_REQUIRE(wait_barrier(ctx));
406
407 ATF_REQUIRE(get_state(ctx) == 666);
408 ATF_REQUIRE(poll(fds, 1, INFTIM) == 1);
409 ATF_REQUIRE(fds[0].revents == (POLLOUT | POLLWRNORM));
410 set_state(ctx, 0);
411
412 ATF_REQUIRE(wait_barrier(ctx));
413
414 /*
415 * Now, the same dance again, with select().
416 */
417
418 FD_ZERO(&selfds);
419 FD_SET(ctx->efd, &selfds);
420
421 ATF_REQUIRE_ERRNO(EAGAIN,
422 eventfd_read(ctx->efd, &efd_value) == -1);
423
424 ATF_REQUIRE(wait_barrier(ctx));
425
426 ATF_REQUIRE(get_state(ctx) == 666);
427 ATF_REQUIRE(select(ctx->efd + 1, &selfds, NULL, NULL, NULL) == 1);
428 ATF_REQUIRE(FD_ISSET(ctx->efd, &selfds));
429 set_state(ctx, 0);
430
431 ATF_REQUIRE(wait_barrier(ctx));
432
433 FD_ZERO(&selfds);
434 FD_SET(ctx->efd, &selfds);
435
436 ATF_REQUIRE_ERRNO(EAGAIN,
437 eventfd_write(ctx->efd, UINT64_MAX - 1) == -1);
438
439 ATF_REQUIRE(wait_barrier(ctx));
440
441 ATF_REQUIRE(get_state(ctx) == 666);
442 ATF_REQUIRE(select(ctx->efd + 1, NULL, &selfds, NULL, NULL) == 1);
443 ATF_REQUIRE(FD_ISSET(ctx->efd, &selfds));
444 set_state(ctx, 0);
445
446 ATF_REQUIRE(wait_barrier(ctx));
447
448 /*
449 * Now, the same dance again, with kevent().
450 */
451 ATF_REQUIRE((kq = kqueue()) >= 0);
452
453 EV_SET(&kev[0], ctx->efd, EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, NULL);
454 ATF_REQUIRE(kevent(kq, kev, 1, NULL, 0, NULL) == 0);
455
456 ATF_REQUIRE_ERRNO(EAGAIN,
457 eventfd_read(ctx->efd, &efd_value) == -1);
458
459 ATF_REQUIRE(wait_barrier(ctx));
460
461 ATF_REQUIRE(get_state(ctx) == 666);
462 ATF_REQUIRE(kevent(kq, NULL, 0, kev, 1, NULL) == 1);
463 ATF_REQUIRE(kev[0].ident == (uintptr_t)ctx->efd);
464 ATF_REQUIRE(kev[0].filter == EVFILT_READ);
465 ATF_REQUIRE((kev[0].flags & (EV_EOF | EV_ERROR)) == 0);
466 ATF_REQUIRE(kev[0].data == (int64_t)(UINT64_MAX - 1));
467 set_state(ctx, 0);
468
469 ATF_REQUIRE(wait_barrier(ctx));
470
471 EV_SET(&kev[0], ctx->efd, EVFILT_WRITE, EV_ADD | EV_ONESHOT, 0, 0,
472 NULL);
473 ATF_REQUIRE(kevent(kq, kev, 1, NULL, 0, NULL) == 0);
474
475 ATF_REQUIRE_ERRNO(EAGAIN,
476 eventfd_write(ctx->efd, UINT64_MAX - 1) == -1);
477
478 ATF_REQUIRE(wait_barrier(ctx));
479
480 ATF_REQUIRE(get_state(ctx) == 666);
481 ATF_REQUIRE(kevent(kq, NULL, 0, kev, 1, NULL) == 1);
482 ATF_REQUIRE(kev[0].ident == (uintptr_t)ctx->efd);
483 ATF_REQUIRE(kev[0].filter == EVFILT_WRITE);
484 ATF_REQUIRE((kev[0].flags & (EV_EOF | EV_ERROR)) == 0);
485 ATF_REQUIRE(kev[0].data == 0);
486 set_state(ctx, 0);
487
488 ATF_REQUIRE(wait_barrier(ctx));
489
490 (void) close(kq);
491
492 return NULL;
493 }
494
495 ATF_TC(eventfd_select_poll_kevent_block);
ATF_TC_HEAD(eventfd_select_poll_kevent_block,tc)496 ATF_TC_HEAD(eventfd_select_poll_kevent_block, tc)
497 {
498 atf_tc_set_md_var(tc, "descr",
499 "validates select/poll/kevent behavior - return after blocking");
500 }
ATF_TC_BODY(eventfd_select_poll_kevent_block,tc)501 ATF_TC_BODY(eventfd_select_poll_kevent_block, tc)
502 {
503 struct helper_context ctx;
504 pthread_t helper;
505 eventfd_t efd_value;
506 void *join_val;
507
508 init_helper_context(&ctx);
509
510 ATF_REQUIRE((ctx.efd = eventfd(0, EFD_NONBLOCK)) >= 0);
511
512 ATF_REQUIRE(pthread_create(&helper, NULL,
513 eventfd_select_poll_kevent_block_helper,
514 &ctx) == 0);
515
516 /*
517 * Wait for the helper to block in poll(). Give it some time
518 * so that if the poll returns immediately, we'll notice.
519 */
520 set_state(&ctx, 666);
521 ATF_REQUIRE(wait_barrier(&ctx));
522 sleep(2);
523 ATF_REQUIRE(get_state(&ctx) == 666);
524
525 /*
526 * Write the max value to the eventfd so that it becomes readable
527 * and unblocks the helper waiting in poll().
528 */
529 ATF_REQUIRE(eventfd_write(ctx.efd, UINT64_MAX - 1) == 0);
530
531 /*
532 * Ensure the helper woke from the poll() call.
533 */
534 ATF_REQUIRE(wait_barrier(&ctx));
535 ATF_REQUIRE(get_state(&ctx) == 0);
536
537 /*
538 * Wait for the helper to block in poll(), this time waiting
539 * for writability.
540 */
541 set_state(&ctx, 666);
542 ATF_REQUIRE(wait_barrier(&ctx));
543 sleep(2);
544 ATF_REQUIRE(get_state(&ctx) == 666);
545
546 /*
547 * Now read the value, which will reset the eventfd to 0 and
548 * unblock the poll() call.
549 */
550 ATF_REQUIRE(eventfd_read(ctx.efd, &efd_value) == 0);
551 ATF_REQUIRE(efd_value == UINT64_MAX - 1);
552
553 /*
554 * Ensure that the helper woke from the poll() call.
555 */
556 ATF_REQUIRE(wait_barrier(&ctx));
557 ATF_REQUIRE(get_state(&ctx) == 0);
558
559 /*
560 * Wait for the helper to block in select(), waiting for readability.
561 */
562 set_state(&ctx, 666);
563 ATF_REQUIRE(wait_barrier(&ctx));
564 sleep(2);
565 ATF_REQUIRE(get_state(&ctx) == 666);
566
567 /*
568 * Write the max value to the eventfd so that it becomes readable
569 * and unblocks the helper waiting in select().
570 */
571 efd_value = UINT64_MAX - 1;
572 ATF_REQUIRE(eventfd_write(ctx.efd, UINT64_MAX - 1) == 0);
573
574 /*
575 * Ensure the helper woke from the select() call.
576 */
577 ATF_REQUIRE(wait_barrier(&ctx));
578 ATF_REQUIRE(get_state(&ctx) == 0);
579
580 /*
581 * Wait for the helper to block in select(), this time waiting
582 * for writability.
583 */
584 set_state(&ctx, 666);
585 ATF_REQUIRE(wait_barrier(&ctx));
586 sleep(2);
587 ATF_REQUIRE(get_state(&ctx) == 666);
588
589 /*
590 * Now read the value, which will reset the eventfd to 0 and
591 * unblock the select() call.
592 */
593 ATF_REQUIRE(eventfd_read(ctx.efd, &efd_value) == 0);
594 ATF_REQUIRE(efd_value == UINT64_MAX - 1);
595
596 /*
597 * Ensure that the helper woke from the select() call.
598 */
599 ATF_REQUIRE(wait_barrier(&ctx));
600 ATF_REQUIRE(get_state(&ctx) == 0);
601
602 /*
603 * Wait for the helper to block in kevent(), waiting for readability.
604 */
605 set_state(&ctx, 666);
606 ATF_REQUIRE(wait_barrier(&ctx));
607 sleep(2);
608 ATF_REQUIRE(get_state(&ctx) == 666);
609
610 /*
611 * Write the max value to the eventfd so that it becomes readable
612 * and unblocks the helper waiting in kevent().
613 */
614 efd_value = UINT64_MAX - 1;
615 ATF_REQUIRE(eventfd_write(ctx.efd, UINT64_MAX - 1) == 0);
616
617 /*
618 * Ensure the helper woke from the kevent() call.
619 */
620 ATF_REQUIRE(wait_barrier(&ctx));
621 ATF_REQUIRE(get_state(&ctx) == 0);
622
623 /*
624 * Wait for the helper to block in kevent(), this time waiting
625 * for writability.
626 */
627 set_state(&ctx, 666);
628 ATF_REQUIRE(wait_barrier(&ctx));
629 sleep(2);
630 ATF_REQUIRE(get_state(&ctx) == 666);
631
632 /*
633 * Now read the value, which will reset the eventfd to 0 and
634 * unblock the select() call.
635 */
636 ATF_REQUIRE(eventfd_read(ctx.efd, &efd_value) == 0);
637 ATF_REQUIRE(efd_value == UINT64_MAX - 1);
638
639 /*
640 * Ensure that the helper woke from the kevent() call.
641 */
642 ATF_REQUIRE(wait_barrier(&ctx));
643 ATF_REQUIRE(get_state(&ctx) == 0);
644
645 /* Reap the helper. */
646 ATF_REQUIRE(pthread_join(helper, &join_val) == 0);
647
648 (void) close(ctx.efd);
649 }
650
651 /*****************************************************************************/
652
653 static void *
eventfd_restart_helper(void * const v)654 eventfd_restart_helper(void * const v)
655 {
656 struct helper_context * const ctx = v;
657 eventfd_t efd_value;
658
659 /*
660 * Issue a single read to ensure that the descriptor is valid.
661 * Thius will not block because it was created with an initial
662 * count of 1.
663 */
664 ATF_REQUIRE(eventfd_read(ctx->efd, &efd_value) == 0);
665 ATF_REQUIRE(efd_value == 1);
666
667 ATF_REQUIRE(wait_barrier(ctx));
668
669 /*
670 * Block in read. The main thread will close the descriptor,
671 * which should unblock us and result in EBADF.
672 */
673 ATF_REQUIRE(get_state(ctx) == 666);
674 ATF_REQUIRE_ERRNO(EBADF, eventfd_read(ctx->efd, &efd_value) == -1);
675 set_state(ctx, 0);
676
677 ATF_REQUIRE(wait_barrier(ctx));
678
679 return NULL;
680 }
681
682 ATF_TC(eventfd_restart);
ATF_TC_HEAD(eventfd_restart,tc)683 ATF_TC_HEAD(eventfd_restart, tc)
684 {
685 atf_tc_set_md_var(tc, "descr",
686 "exercises the 'restart' fileop code path");
687 }
ATF_TC_BODY(eventfd_restart,tc)688 ATF_TC_BODY(eventfd_restart, tc)
689 {
690 struct helper_context ctx;
691 pthread_t helper;
692 void *join_val;
693
694 init_helper_context(&ctx);
695
696 ATF_REQUIRE((ctx.efd = eventfd(1, 0)) >= 0);
697
698 ATF_REQUIRE(pthread_create(&helper, NULL,
699 eventfd_restart_helper, &ctx) == 0);
700
701 /*
702 * Wait for the helper to block in read(). Give it some time
703 * so that if the poll returns immediately, we'll notice.
704 */
705 set_state(&ctx, 666);
706 ATF_REQUIRE(wait_barrier(&ctx));
707 sleep(2);
708 ATF_REQUIRE(get_state(&ctx) == 666);
709
710 /*
711 * Close the descriptor. This should unblock the reader,
712 * and cause it to receive EBADF.
713 */
714 ATF_REQUIRE(close(ctx.efd) == 0);
715
716 /*
717 * Ensure that the helper woke from the read() call.
718 */
719 ATF_REQUIRE(wait_barrier(&ctx));
720 ATF_REQUIRE(get_state(&ctx) == 0);
721
722 /* Reap the helper. */
723 ATF_REQUIRE(pthread_join(helper, &join_val) == 0);
724 }
725
726 /*****************************************************************************/
727
728 ATF_TC(eventfd_badflags);
ATF_TC_HEAD(eventfd_badflags,tc)729 ATF_TC_HEAD(eventfd_badflags, tc)
730 {
731 atf_tc_set_md_var(tc, "descr",
732 "validates behavior when eventfd() called with bad flags");
733 }
ATF_TC_BODY(eventfd_badflags,tc)734 ATF_TC_BODY(eventfd_badflags, tc)
735 {
736 ATF_REQUIRE_ERRNO(EINVAL,
737 eventfd(0, ~(EFD_SEMAPHORE | EFD_CLOEXEC | EFD_NONBLOCK)) == -1);
738 }
739
740 /*****************************************************************************/
741
742 ATF_TC(eventfd_bufsize);
ATF_TC_HEAD(eventfd_bufsize,tc)743 ATF_TC_HEAD(eventfd_bufsize, tc)
744 {
745 atf_tc_set_md_var(tc, "descr",
746 "validates expected buffer size behavior");
747 }
ATF_TC_BODY(eventfd_bufsize,tc)748 ATF_TC_BODY(eventfd_bufsize, tc)
749 {
750 eventfd_t efd_value[2];
751 int efd;
752
753 ATF_REQUIRE((efd = eventfd(1, EFD_NONBLOCK)) >= 0);
754
755 ATF_REQUIRE_ERRNO(EINVAL,
756 read(efd, efd_value, sizeof(efd_value[0]) - 1) == -1);
757
758 efd_value[0] = 0xdeadbeef;
759 efd_value[1] = 0xdeadbeef;
760 ATF_REQUIRE(read(efd, efd_value, sizeof(efd_value)) ==
761 sizeof(efd_value[0]));
762 ATF_REQUIRE(efd_value[0] == 1);
763 ATF_REQUIRE(efd_value[1] == 0xdeadbeef);
764
765 ATF_REQUIRE_ERRNO(EINVAL,
766 write(efd, efd_value, sizeof(efd_value[0]) - 1) == -1);
767 ATF_REQUIRE(write(efd, efd_value, sizeof(efd_value)) ==
768 sizeof(efd_value[0]));
769
770 ATF_REQUIRE(read(efd, efd_value, sizeof(efd_value)) ==
771 sizeof(efd_value[0]));
772 ATF_REQUIRE(efd_value[0] == 1);
773 ATF_REQUIRE(efd_value[1] == 0xdeadbeef);
774
775 (void) close(efd);
776 }
777
778 /*****************************************************************************/
779
780 ATF_TC(eventfd_fcntl);
ATF_TC_HEAD(eventfd_fcntl,tc)781 ATF_TC_HEAD(eventfd_fcntl, tc)
782 {
783 atf_tc_set_md_var(tc, "descr",
784 "validates fcntl behavior");
785 }
ATF_TC_BODY(eventfd_fcntl,tc)786 ATF_TC_BODY(eventfd_fcntl, tc)
787 {
788 int efd;
789 int val;
790
791 ATF_REQUIRE((efd = eventfd(1, 0)) >= 0);
792 ATF_REQUIRE((fcntl(efd, F_GETFL) & O_NONBLOCK) == 0);
793 ATF_REQUIRE(fcntl(efd, F_SETFL, O_NONBLOCK) == 0);
794 ATF_REQUIRE((fcntl(efd, F_GETFL) & O_NONBLOCK) != 0);
795 ATF_REQUIRE((fcntl(efd, F_GETFD) & FD_CLOEXEC) == 0);
796
797 ATF_REQUIRE(ioctl(efd, FIONREAD, &val) == 0);
798 ATF_REQUIRE(val == sizeof(eventfd_t));
799
800 ATF_REQUIRE(ioctl(efd, FIONWRITE, &val) == 0);
801 ATF_REQUIRE(val == 0);
802
803 ATF_REQUIRE_ERRNO(ENOTTY, ioctl(efd, FIONSPACE, &val) == -1);
804 (void)close(efd);
805
806 ATF_REQUIRE((efd = eventfd(1, EFD_NONBLOCK | EFD_CLOEXEC)) >= 0);
807 ATF_REQUIRE((fcntl(efd, F_GETFL) & ~O_ACCMODE) == O_NONBLOCK);
808 ATF_REQUIRE((fcntl(efd, F_GETFD) & FD_CLOEXEC) != 0);
809 ATF_REQUIRE(fcntl(efd, F_SETFD, 0) == 0);
810 ATF_REQUIRE((fcntl(efd, F_GETFD) & FD_CLOEXEC) == 0);
811 ATF_REQUIRE(fcntl(efd, F_SETFD, FD_CLOEXEC) == 0);
812 ATF_REQUIRE((fcntl(efd, F_GETFD) & FD_CLOEXEC) != 0);
813 (void)close(efd);
814 }
815
816 /*****************************************************************************/
817
ATF_TP_ADD_TCS(tp)818 ATF_TP_ADD_TCS(tp)
819 {
820 ATF_TP_ADD_TC(tp, eventfd_normal);
821 ATF_TP_ADD_TC(tp, eventfd_semaphore);
822 ATF_TP_ADD_TC(tp, eventfd_badflags);
823 ATF_TP_ADD_TC(tp, eventfd_bufsize);
824 ATF_TP_ADD_TC(tp, eventfd_select_poll_kevent_immed);
825 ATF_TP_ADD_TC(tp, eventfd_select_poll_kevent_block);
826 ATF_TP_ADD_TC(tp, eventfd_restart);
827 ATF_TP_ADD_TC(tp, eventfd_fcntl);
828
829 return atf_no_error();
830 }
831