1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet at
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright 2018 Joyent, Inc.
14 */
15
16 /*
17 * Test: read.pause
18 * Assertion: mevent_disable() can be used to pause reads.
19 *
20 * Strategy: 1. Create a pipe
21 * 2. Call mevent_add() to be notified of writes to the pipe. The
22 * callback will signal a cv.
23 * 3. In a loop, write to the pipe then wait on the cv.
24 */
25
26 #include <errno.h>
27 #include <fcntl.h>
28 #include <pthread.h>
29 #include <signal.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <strings.h>
33 #include <unistd.h>
34
35 #include <sys/types.h>
36 #include <sys/stat.h>
37
38 #include "testlib.h"
39 #include "mevent.h"
40
41 static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
42 static pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
43
44 static char cookie[] = "Chocolate chip with fudge stripes";
45
46 /*
47 * After this many bytes are sent, writes will get batched up, progress will be
48 * made on the write side via an interval timer
49 */
50 const int pauseat = 8;
51
52 static void
munch(int fd,enum ev_type ev,void * arg)53 munch(int fd, enum ev_type ev, void *arg)
54 {
55 static int i = 0;
56 char buf[sizeof (cookie)] = { 0 };
57 ssize_t nbytes;
58 ssize_t expected;
59
60 ASSERT_INT_EQ(("bad event"), ev, EVF_READ);
61 ASSERT_PTR_EQ(("bad cookie"), arg, cookie);
62
63 /*
64 * For the first while, expect data to come a byte at a time. After the
65 * pause, we should get a burst with the rest of the data.
66 */
67 if (i > pauseat) {
68 expected = strlen(cookie) - pauseat - 1;
69 } else {
70 expected = 1;
71 }
72
73 if ((nbytes = read(fd, buf, sizeof (buf))) < 0) {
74 FAIL_ERRNO("bad read");
75 }
76 VERBOSE(("read %ld bytes '%s'", nbytes, buf));
77
78 ASSERT_INT64_EQ(("wanted a byte of cookie"), nbytes, expected);
79
80 if (expected == 1) {
81 ASSERT_CHAR_EQ(("bad byte %d of cookie", i), buf[0], cookie[i]);
82 } else {
83 ASSERT_STR_EQ(("bad last half of cookie"), buf, &cookie[i]);
84 }
85
86 pthread_mutex_lock(&mtx);
87 pthread_cond_signal(&cv);
88 VERBOSE(("wakeup"));
89 pthread_mutex_unlock(&mtx);
90
91 i++;
92 }
93
94 static void
tick(int ms,enum ev_type ev,void * arg)95 tick(int ms, enum ev_type ev, void *arg)
96 {
97 pthread_mutex_lock(&mtx);
98 pthread_cond_signal(&cv);
99 VERBOSE(("wakeup"));
100 pthread_mutex_unlock(&mtx);
101 }
102
103 int
main(int argc,const char * argv[])104 main(int argc, const char *argv[])
105 {
106 int pipefds[2];
107 struct mevent *evp, *timer;
108 ssize_t written;
109
110 start_test(argv[0], 5);
111 start_event_thread();
112
113 if (pipe(pipefds) != 0) {
114 FAIL_ERRNO("pipe");
115 }
116 if (fcntl(pipefds[0], F_SETFL, O_NONBLOCK) != 0) {
117 FAIL_ERRNO("set pipe nonblocking");
118 }
119
120 evp = mevent_add(pipefds[0], EVF_READ, munch, cookie);
121 ASSERT_PTR_NEQ(("mevent_add pipefd"), evp, NULL);
122
123 for (int i = 0; cookie[i] != 0; i++) {
124 pthread_mutex_lock(&mtx);
125 written = write(pipefds[1], cookie + i, 1);
126 if (written < 0) {
127 FAIL_ERRNO("bad write");
128 }
129 ASSERT_INT64_EQ(("write byte %d of cookie", i), written, 1);
130
131 /* Wait for it to be read */
132 pthread_cond_wait(&cv, &mtx);
133 pthread_mutex_unlock(&mtx);
134
135 if (i == pauseat) {
136 timer = mevent_add(10, EVF_TIMER, tick,
137 &cookie[pauseat]);
138 ASSERT_PTR_NEQ(("mevent_add timer"), timer, NULL);
139 VERBOSE(("disable munch"));
140 mevent_disable(evp);
141 }
142 }
143
144 pthread_mutex_lock(&mtx);
145
146 mevent_enable(evp);
147
148 pthread_cond_wait(&cv, &mtx);
149 pthread_mutex_unlock(&mtx);
150
151 PASS();
152 }
153