1 /*-
2 * Copyright (c) 2017 Spectra Logic Corp
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 #define _WANT_ALL_LIO_OPCODES
28
29 #include <sys/param.h>
30 #include <sys/event.h>
31 #include <sys/uio.h>
32
33 #include <aio.h>
34 #include <fcntl.h>
35 #include <semaphore.h>
36 #include <stdlib.h>
37
38 #include <atf-c.h>
39
40 #include "local.h"
41
42 static sem_t completions;
43
44
45 static void
handler(int sig __unused)46 handler(int sig __unused)
47 {
48 ATF_REQUIRE_EQ(0, sem_post(&completions));
49 }
50
51 static void
thr_handler(union sigval sv __unused)52 thr_handler(union sigval sv __unused)
53 {
54 ATF_REQUIRE_EQ(0, sem_post(&completions));
55 }
56
57 /*
58 * If lio_listio is unable to enqueue any requests at all, it should return
59 * EAGAIN.
60 */
61 ATF_TC_WITHOUT_HEAD(lio_listio_eagain_kevent);
ATF_TC_BODY(lio_listio_eagain_kevent,tc)62 ATF_TC_BODY(lio_listio_eagain_kevent, tc)
63 {
64 int fd, i, j, kq, max_queue_per_proc, ios_per_call;
65 size_t max_queue_per_proc_size;
66 struct aiocb *aiocbs[2];
67 struct aiocb **list[2];
68 struct sigevent sev[2];
69 char *buffer;
70 const char *path="tempfile";
71 void *udata[2];
72
73 ATF_REQUIRE_UNSAFE_AIO();
74
75 max_queue_per_proc_size = sizeof(max_queue_per_proc);
76 ATF_REQUIRE_EQ(sysctlbyname("vfs.aio.max_aio_queue_per_proc",
77 &max_queue_per_proc, &max_queue_per_proc_size, NULL, 0), 0);
78 ios_per_call = max_queue_per_proc;
79
80 fd = open(path, O_RDWR|O_CREAT, 0666);
81 ATF_REQUIRE(fd >= 0);
82
83 kq = kqueue();
84 ATF_REQUIRE(kq > 0);
85
86 buffer = calloc(1, 4096);
87 ATF_REQUIRE(buffer != NULL);
88
89 /*
90 * Call lio_listio twice, each with the maximum number of operations.
91 * The first call should succeed and the second should fail.
92 */
93 for (i = 0; i < 2; i++) {
94 aiocbs[i] = calloc(ios_per_call, sizeof(struct aiocb));
95 ATF_REQUIRE(aiocbs[i] != NULL);
96 list[i] = calloc(ios_per_call, sizeof(struct aiocb*));
97 ATF_REQUIRE(list[i] != NULL);
98 udata[i] = (void*)((caddr_t)0xdead0000 + i);
99 sev[i].sigev_notify = SIGEV_KEVENT;
100 sev[i].sigev_notify_kqueue = kq;
101 sev[i].sigev_value.sival_ptr = udata[i];
102 for (j = 0; j < ios_per_call; j++) {
103 aiocbs[i][j].aio_fildes = fd;
104 aiocbs[i][j].aio_offset = (i * ios_per_call + j) * 4096;
105 aiocbs[i][j].aio_buf = buffer;
106 aiocbs[i][j].aio_nbytes = 4096;
107 aiocbs[i][j].aio_lio_opcode = LIO_WRITE;
108 list[i][j] = &aiocbs[i][j];
109 }
110 }
111
112 ATF_REQUIRE_EQ(0, lio_listio(LIO_NOWAIT, list[0], ios_per_call, &sev[0]));
113 ATF_REQUIRE_EQ(-1, lio_listio(LIO_NOWAIT, list[1], ios_per_call, &sev[1]));
114 /*
115 * The second lio_listio call should fail with EAGAIN. Bad timing may
116 * mean that some requests did get enqueued, but the result should
117 * still be EAGAIN.
118 */
119 ATF_REQUIRE_EQ(errno, EAGAIN);
120 }
121
122
123 /* With LIO_WAIT, an empty lio_listio should return immediately */
124 ATF_TC_WITHOUT_HEAD(lio_listio_empty_wait);
ATF_TC_BODY(lio_listio_empty_wait,tc)125 ATF_TC_BODY(lio_listio_empty_wait, tc)
126 {
127 struct aiocb *list = NULL;
128
129 ATF_REQUIRE_EQ(0, lio_listio(LIO_WAIT, &list, 0, NULL));
130 }
131
132 /* With LIO_NOWAIT, an empty lio_listio should return immediately */
133 ATF_TC_WITHOUT_HEAD(lio_listio_empty_nowait);
ATF_TC_BODY(lio_listio_empty_nowait,tc)134 ATF_TC_BODY(lio_listio_empty_nowait, tc)
135 {
136 struct aiocb *list = NULL;
137
138 ATF_REQUIRE_EQ(0, lio_listio(LIO_NOWAIT, &list, 0, NULL));
139 }
140
141 /*
142 * With LIO_NOWAIT, an empty lio_listio should send completion notification
143 * immediately
144 */
145 ATF_TC_WITHOUT_HEAD(lio_listio_empty_nowait_kevent);
ATF_TC_BODY(lio_listio_empty_nowait_kevent,tc)146 ATF_TC_BODY(lio_listio_empty_nowait_kevent, tc)
147 {
148 struct aiocb *list = NULL;
149 struct sigevent sev;
150 struct kevent kq_returned;
151 int kq, result;
152 void *udata = (void*)0xdeadbeefdeadbeef;
153
154 atf_tc_expect_timeout("Bug 251515 - lio_listio(2) never sends"
155 " kevent if nent==0");
156 kq = kqueue();
157 ATF_REQUIRE(kq > 0);
158 sev.sigev_notify = SIGEV_KEVENT;
159 sev.sigev_notify_kqueue = kq;
160 sev.sigev_value.sival_ptr = udata;
161 ATF_REQUIRE_EQ(0, lio_listio(LIO_NOWAIT, &list, 0, &sev));
162 result = kevent(kq, NULL, 0, &kq_returned, 1, NULL);
163 ATF_REQUIRE_MSG(result == 1, "Never got completion notification");
164 ATF_REQUIRE_EQ((uintptr_t)list, kq_returned.ident);
165 ATF_REQUIRE_EQ(EVFILT_LIO, kq_returned.filter);
166 ATF_REQUIRE_EQ(udata, kq_returned.udata);
167 }
168
169 /*
170 * With LIO_NOWAIT, an empty lio_listio should send completion notification
171 * immediately
172 */
173 ATF_TC_WITHOUT_HEAD(lio_listio_empty_nowait_signal);
ATF_TC_BODY(lio_listio_empty_nowait_signal,tc)174 ATF_TC_BODY(lio_listio_empty_nowait_signal, tc)
175 {
176 struct aiocb *list = NULL;
177 struct sigevent sev;
178
179 ATF_REQUIRE_EQ(0, sem_init(&completions, false, 0));
180 sev.sigev_notify = SIGEV_SIGNAL;
181 sev.sigev_signo = SIGUSR1;
182 ATF_REQUIRE(SIG_ERR != signal(SIGUSR1, handler));
183 ATF_REQUIRE_EQ(0, lio_listio(LIO_NOWAIT, &list, 0, &sev));
184 ATF_REQUIRE_EQ(0, sem_wait(&completions));
185 ATF_REQUIRE_EQ(0, sem_destroy(&completions));
186 }
187
188 /*
189 * With LIO_NOWAIT, an empty lio_listio should send completion notification
190 * immediately
191 */
192 ATF_TC_WITHOUT_HEAD(lio_listio_empty_nowait_thread);
ATF_TC_BODY(lio_listio_empty_nowait_thread,tc)193 ATF_TC_BODY(lio_listio_empty_nowait_thread, tc)
194 {
195 struct aiocb *list = NULL;
196 struct sigevent sev;
197
198 ATF_REQUIRE_EQ(0, sem_init(&completions, false, 0));
199 bzero(&sev, sizeof(sev));
200 sev.sigev_notify = SIGEV_THREAD;
201 sev.sigev_notify_function = thr_handler;
202 sev.sigev_notify_attributes = NULL;
203 ATF_REQUIRE_MSG(0 == lio_listio(LIO_NOWAIT, &list, 0, &sev),
204 "lio_listio: %s", strerror(errno));
205 ATF_REQUIRE_EQ(0, sem_wait(&completions));
206 ATF_REQUIRE_EQ(0, sem_destroy(&completions));
207 }
208
209 /*
210 * A simple check that the allowed operations work.
211 */
212 ATF_TC_WITHOUT_HEAD(lio_listio_opcodes);
ATF_TC_BODY(lio_listio_opcodes,tc)213 ATF_TC_BODY(lio_listio_opcodes, tc)
214 {
215 struct aiocb write_cb, read_cb, writev_cb, readv_cb;
216 struct aiocb *list[] = {&write_cb, &read_cb, &writev_cb, &readv_cb};
217 struct iovec writev_iov[2];
218 struct iovec readv_iov[2];
219 char buffer[6];
220 int fd;
221
222 fd = open("testfile", O_CREAT | O_RDWR, 0666);
223 ATF_REQUIRE_MSG(fd >= 0, "open: %s", strerror(errno));
224
225 /* We start with numbers in a file and letters in memory... */
226 ATF_CHECK_EQ(6, write(fd, "123456", 6));
227 memcpy(buffer, "abcdef", 6);
228
229 /* a -> 1 */
230 bzero(&write_cb, sizeof(write_cb));
231 write_cb.aio_sigevent.sigev_notify = SIGEV_NONE;
232 write_cb.aio_fildes = fd;
233 write_cb.aio_lio_opcode = LIO_WRITE;
234 write_cb.aio_buf = &buffer[0];
235 write_cb.aio_nbytes = 1;
236 write_cb.aio_offset = 0;
237
238 /* b <- 2 */
239 bzero(&read_cb, sizeof(read_cb));
240 read_cb.aio_sigevent.sigev_notify = SIGEV_NONE;
241 read_cb.aio_fildes = fd;
242 read_cb.aio_lio_opcode = LIO_READ;
243 read_cb.aio_buf = &buffer[1];
244 read_cb.aio_nbytes = 1;
245 read_cb.aio_offset = 1;
246
247 /* d -> 3, c -> 4 */
248 writev_iov[0].iov_base = &buffer[3];
249 writev_iov[0].iov_len = 1;
250 writev_iov[1].iov_base = &buffer[2];
251 writev_iov[1].iov_len = 1;
252 bzero(&writev_cb, sizeof(writev_cb));
253 writev_cb.aio_sigevent.sigev_notify = SIGEV_NONE;
254 writev_cb.aio_fildes = fd;
255 writev_cb.aio_lio_opcode = LIO_WRITEV;
256 writev_cb.aio_iov = &writev_iov;
257 writev_cb.aio_iovcnt = 2;
258 writev_cb.aio_offset = 2;
259
260 /* f <- 5, e <- 6 */
261 readv_iov[0].iov_base = &buffer[5];
262 readv_iov[0].iov_len = 1;
263 readv_iov[1].iov_base = &buffer[4];
264 readv_iov[1].iov_len = 1;
265 bzero(&readv_cb, sizeof(readv_cb));
266 readv_cb.aio_sigevent.sigev_notify = SIGEV_NONE;
267 readv_cb.aio_fildes = fd;
268 readv_cb.aio_lio_opcode = LIO_READV;
269 readv_cb.aio_iov = &readv_iov;
270 readv_cb.aio_iovcnt = 2;
271 readv_cb.aio_offset = 4;
272
273 ATF_CHECK_EQ(0, lio_listio(LIO_WAIT, list, nitems(list), NULL));
274 ATF_CHECK_EQ(0, aio_error(&write_cb));
275 ATF_CHECK_EQ(1, aio_return(&write_cb));
276 ATF_CHECK_EQ(0, aio_error(&read_cb));
277 ATF_CHECK_EQ(1, aio_return(&read_cb));
278 ATF_CHECK_EQ(0, aio_error(&writev_cb));
279 ATF_CHECK_EQ(2, aio_return(&writev_cb));
280 ATF_CHECK_EQ(0, aio_error(&readv_cb));
281 ATF_CHECK_EQ(2, aio_return(&readv_cb));
282
283 ATF_CHECK_EQ(0, memcmp(buffer, "a2cd65", 6));
284 ATF_CHECK_EQ(6, pread(fd, buffer, 6, 0));
285 ATF_CHECK_EQ(0, memcmp(buffer, "a2dc56", 6));
286
287 close(fd);
288 }
289
290
291 /*
292 * Only select opcodes are allowed with lio_listio
293 */
294 ATF_TC_WITHOUT_HEAD(lio_listio_invalid_opcode);
ATF_TC_BODY(lio_listio_invalid_opcode,tc)295 ATF_TC_BODY(lio_listio_invalid_opcode, tc)
296 {
297 struct aiocb sync_cb, mlock_cb;
298 struct aiocb *list[] = {&sync_cb, &mlock_cb};
299 int fd;
300
301 fd = open("testfile", O_CREAT | O_RDWR, 0666);
302 ATF_REQUIRE_MSG(fd >= 0, "open: %s", strerror(errno));
303
304 bzero(&sync_cb, sizeof(sync_cb));
305 sync_cb.aio_fildes = fd;
306 sync_cb.aio_lio_opcode = LIO_SYNC;
307
308 bzero(&mlock_cb, sizeof(mlock_cb));
309 mlock_cb.aio_lio_opcode = LIO_MLOCK;
310
311 ATF_CHECK_ERRNO(EIO, lio_listio(LIO_WAIT, list, nitems(list), NULL));
312 ATF_CHECK_EQ(EINVAL, aio_error(&sync_cb));
313 ATF_CHECK_ERRNO(EINVAL, aio_return(&sync_cb) < 0);
314 ATF_CHECK_EQ(EINVAL, aio_error(&mlock_cb));
315 ATF_CHECK_ERRNO(EINVAL, aio_return(&mlock_cb) < 0);
316
317 close(fd);
318 }
319
320
ATF_TP_ADD_TCS(tp)321 ATF_TP_ADD_TCS(tp)
322 {
323
324 ATF_TP_ADD_TC(tp, lio_listio_eagain_kevent);
325 ATF_TP_ADD_TC(tp, lio_listio_empty_nowait);
326 ATF_TP_ADD_TC(tp, lio_listio_empty_nowait_kevent);
327 ATF_TP_ADD_TC(tp, lio_listio_empty_nowait_signal);
328 ATF_TP_ADD_TC(tp, lio_listio_empty_nowait_thread);
329 ATF_TP_ADD_TC(tp, lio_listio_empty_wait);
330 ATF_TP_ADD_TC(tp, lio_listio_opcodes);
331 ATF_TP_ADD_TC(tp, lio_listio_invalid_opcode);
332
333 return (atf_no_error());
334 }
335