tests/sys/aio/lio_test.c

   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  * $FreeBSD$
  27  */
  28
  29 #define _WANT_ALL_LIO_OPCODES
  30
  31 #include <sys/param.h>
  32 #include <sys/event.h>
  33 #include <sys/uio.h>
  34
  35 #include <aio.h>
  36 #include <fcntl.h>
  37 #include <semaphore.h>
  38 #include <stdlib.h>
  39
  40 #include <atf-c.h>
  41
  42 #include "local.h"
  43 #include "freebsd_test_suite/macros.h"
  44
  45 static sem_t completions;
  46
  47
  48 static void
  49 handler(int sig __unused)
  50 {
  51         ATF_REQUIRE_EQ(0, sem_post(&completions));
  52 }
  53
  54 static void
  55 thr_handler(union sigval sv __unused)
  56 {
  57         ATF_REQUIRE_EQ(0, sem_post(&completions));
  58 }
  59
  60 /*
  61  * If lio_listio is unable to enqueue any requests at all, it should return
  62  * EAGAIN.
  63  */
  64 ATF_TC_WITHOUT_HEAD(lio_listio_eagain_kevent);
  65 ATF_TC_BODY(lio_listio_eagain_kevent, tc)
  66 {
  67         int fd, i, j, kq, max_queue_per_proc, ios_per_call;
  68         size_t max_queue_per_proc_size;
  69         struct aiocb *aiocbs[2];
  70         struct aiocb **list[2];
  71         struct sigevent sev[2];
  72         char *buffer;
  73         const char *path="tempfile";
  74         void *udata[2];
  75
  76         ATF_REQUIRE_KERNEL_MODULE("aio");
  77         ATF_REQUIRE_UNSAFE_AIO();
  78
  79         max_queue_per_proc_size = sizeof(max_queue_per_proc);
  80         ATF_REQUIRE_EQ(sysctlbyname("vfs.aio.max_aio_queue_per_proc",
  81             &max_queue_per_proc, &max_queue_per_proc_size, NULL, 0), 0);
  82         ios_per_call = max_queue_per_proc;
  83
  84         fd = open(path, O_RDWR|O_CREAT, 0666);
  85         ATF_REQUIRE(fd >= 0);
  86
  87         kq = kqueue();
  88         ATF_REQUIRE(kq > 0);
  89
  90         buffer = calloc(1, 4096);
  91         ATF_REQUIRE(buffer != NULL);
  92
  93         /*
  94          * Call lio_listio twice, each with the maximum number of operations.
  95          * The first call should succeed and the second should fail.
  96          */
  97         for (i = 0; i < 2; i++) {
  98                 aiocbs[i] = calloc(ios_per_call, sizeof(struct aiocb));
  99                 ATF_REQUIRE(aiocbs[i] != NULL);
 100                 list[i] = calloc(ios_per_call, sizeof(struct aiocb*));
 101                 ATF_REQUIRE(list[i] != NULL);
 102                 udata[i] = (void*)((caddr_t)0xdead0000 + i);
 103                 sev[i].sigev_notify = SIGEV_KEVENT;
 104                 sev[i].sigev_notify_kqueue = kq;
 105                 sev[i].sigev_value.sival_ptr = udata[i];
 106                 for (j = 0; j < ios_per_call; j++) {
 107                         aiocbs[i][j].aio_fildes = fd;
 108                         aiocbs[i][j].aio_offset = (i * ios_per_call + j) * 4096;
 109                         aiocbs[i][j].aio_buf = buffer;
 110                         aiocbs[i][j].aio_nbytes = 4096;
 111                         aiocbs[i][j].aio_lio_opcode = LIO_WRITE;
 112                         list[i][j] = &aiocbs[i][j];
 113                 }
 114         }
 115
 116         ATF_REQUIRE_EQ(0, lio_listio(LIO_NOWAIT, list[0], ios_per_call, &sev[0]));
 117         ATF_REQUIRE_EQ(-1, lio_listio(LIO_NOWAIT, list[1], ios_per_call, &sev[1]));
 118         /*
 119          * The second lio_listio call should fail with EAGAIN.  Bad timing may
 120          * mean that some requests did get enqueued, but the result should
 121          * still be EAGAIN.
 122          */
 123         ATF_REQUIRE_EQ(errno, EAGAIN);
 124 }
 125
 126
 127 /* With LIO_WAIT, an empty lio_listio should return immediately */
 128 ATF_TC_WITHOUT_HEAD(lio_listio_empty_wait);
 129 ATF_TC_BODY(lio_listio_empty_wait, tc)
 130 {
 131         struct aiocb *list = NULL;
 132
 133         ATF_REQUIRE_EQ(0, lio_listio(LIO_WAIT, &list, 0, NULL));
 134 }
 135
 136 /* With LIO_NOWAIT, an empty lio_listio should return immediately */
 137 ATF_TC_WITHOUT_HEAD(lio_listio_empty_nowait);
 138 ATF_TC_BODY(lio_listio_empty_nowait, tc)
 139 {
 140         struct aiocb *list = NULL;
 141
 142         ATF_REQUIRE_EQ(0, lio_listio(LIO_NOWAIT, &list, 0, NULL));
 143 }
 144
 145 /*
 146  * With LIO_NOWAIT, an empty lio_listio should send completion notification
 147  * immediately
 148  */
 149 ATF_TC_WITHOUT_HEAD(lio_listio_empty_nowait_kevent);
 150 ATF_TC_BODY(lio_listio_empty_nowait_kevent, tc)
 151 {
 152         struct aiocb *list = NULL;
 153         struct sigevent sev;
 154         struct kevent kq_returned;
 155         int kq, result;
 156         void *udata = (void*)0xdeadbeefdeadbeef;
 157
 158         atf_tc_expect_timeout("Bug 251515 - lio_listio(2) never sends"
 159                         " kevent if nent==0");
 160         kq = kqueue();
 161         ATF_REQUIRE(kq > 0);
 162         sev.sigev_notify = SIGEV_KEVENT;
 163         sev.sigev_notify_kqueue = kq;
 164         sev.sigev_value.sival_ptr = udata;
 165         ATF_REQUIRE_EQ(0, lio_listio(LIO_NOWAIT, &list, 0, &sev));
 166         result = kevent(kq, NULL, 0, &kq_returned, 1, NULL);
 167         ATF_REQUIRE_MSG(result == 1, "Never got completion notification");
 168         ATF_REQUIRE_EQ((uintptr_t)list, kq_returned.ident);
 169         ATF_REQUIRE_EQ(EVFILT_LIO, kq_returned.filter);
 170         ATF_REQUIRE_EQ(udata, kq_returned.udata);
 171 }
 172
 173 /*
 174  * With LIO_NOWAIT, an empty lio_listio should send completion notification
 175  * immediately
 176  */
 177 ATF_TC_WITHOUT_HEAD(lio_listio_empty_nowait_signal);
 178 ATF_TC_BODY(lio_listio_empty_nowait_signal, tc)
 179 {
 180         struct aiocb *list = NULL;
 181         struct sigevent sev;
 182
 183         ATF_REQUIRE_EQ(0, sem_init(&completions, false, 0));
 184         sev.sigev_notify = SIGEV_SIGNAL;
 185         sev.sigev_signo = SIGUSR1;
 186         ATF_REQUIRE(SIG_ERR != signal(SIGUSR1, handler));
 187         ATF_REQUIRE_EQ(0, lio_listio(LIO_NOWAIT, &list, 0, &sev));
 188         ATF_REQUIRE_EQ(0, sem_wait(&completions));
 189         ATF_REQUIRE_EQ(0, sem_destroy(&completions));
 190 }
 191
 192 /*
 193  * With LIO_NOWAIT, an empty lio_listio should send completion notification
 194  * immediately
 195  */
 196 ATF_TC_WITHOUT_HEAD(lio_listio_empty_nowait_thread);
 197 ATF_TC_BODY(lio_listio_empty_nowait_thread, tc)
 198 {
 199         struct aiocb *list = NULL;
 200         struct sigevent sev;
 201
 202         ATF_REQUIRE_EQ(0, sem_init(&completions, false, 0));
 203         bzero(&sev, sizeof(sev));
 204         sev.sigev_notify = SIGEV_THREAD;
 205         sev.sigev_notify_function = thr_handler;
 206         sev.sigev_notify_attributes = NULL;
 207         ATF_REQUIRE_MSG(0 == lio_listio(LIO_NOWAIT, &list, 0, &sev),
 208             "lio_listio: %s", strerror(errno));
 209         ATF_REQUIRE_EQ(0, sem_wait(&completions));
 210         ATF_REQUIRE_EQ(0, sem_destroy(&completions));
 211 }
 212
 213 /*
 214  * Only select opcodes are allowed with lio_listio
 215  */
 216 ATF_TC_WITHOUT_HEAD(lio_listio_invalid_opcode);
 217 ATF_TC_BODY(lio_listio_invalid_opcode, tc)
 218 {
 219         struct aiocb sync_cb, mlock_cb, writev_cb, readv_cb;
 220         struct aiocb *list[] = {&sync_cb, &mlock_cb, &writev_cb, &readv_cb};
 221         struct iovec iov;
 222         int fd;
 223
 224         fd = open("testfile", O_CREAT | O_RDWR);
 225         ATF_REQUIRE_MSG(fd >= 0, "open: %s", strerror(errno));
 226
 227         bzero(&sync_cb, sizeof(sync_cb));
 228         sync_cb.aio_fildes = fd;
 229         sync_cb.aio_lio_opcode = LIO_SYNC;
 230
 231         bzero(&mlock_cb, sizeof(mlock_cb));
 232         mlock_cb.aio_lio_opcode = LIO_MLOCK;
 233
 234         iov.iov_base = NULL;
 235         iov.iov_len = 0;
 236
 237         bzero(&readv_cb, sizeof(readv_cb));
 238         readv_cb.aio_fildes = fd;
 239         readv_cb.aio_lio_opcode = LIO_READV;
 240         readv_cb.aio_iov = &iov;
 241         readv_cb.aio_iovcnt = 1;
 242
 243         bzero(&writev_cb, sizeof(writev_cb));
 244         writev_cb.aio_fildes = fd;
 245         writev_cb.aio_lio_opcode = LIO_WRITEV;
 246         writev_cb.aio_iov = &iov;
 247         writev_cb.aio_iovcnt = 1;
 248
 249         ATF_CHECK_ERRNO(EIO, lio_listio(LIO_WAIT, list, nitems(list), NULL));
 250         ATF_CHECK_EQ(EINVAL, aio_error(&sync_cb));
 251         ATF_CHECK_ERRNO(EINVAL, aio_return(&sync_cb) < 0);
 252         ATF_CHECK_EQ(EINVAL, aio_error(&mlock_cb));
 253         ATF_CHECK_ERRNO(EINVAL, aio_return(&mlock_cb) < 0);
 254         ATF_CHECK_EQ(EINVAL, aio_error(&readv_cb));
 255         ATF_CHECK_ERRNO(EINVAL, aio_return(&readv_cb) < 0);
 256         ATF_CHECK_EQ(EINVAL, aio_error(&writev_cb));
 257         ATF_CHECK_ERRNO(EINVAL, aio_return(&writev_cb) < 0);
 258 }
 259
 260
 261 ATF_TP_ADD_TCS(tp)
 262 {
 263
 264         ATF_TP_ADD_TC(tp, lio_listio_eagain_kevent);
 265         ATF_TP_ADD_TC(tp, lio_listio_empty_nowait);
 266         ATF_TP_ADD_TC(tp, lio_listio_empty_nowait_kevent);
 267         ATF_TP_ADD_TC(tp, lio_listio_empty_nowait_signal);
 268         ATF_TP_ADD_TC(tp, lio_listio_empty_nowait_thread);
 269         ATF_TP_ADD_TC(tp, lio_listio_empty_wait);
 270         ATF_TP_ADD_TC(tp, lio_listio_invalid_opcode);
 271
 272         return (atf_no_error());
 273 }