// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (c) International Business Machines Corp., 2003 * Copyright (c) Linux Test Project, 2004-2019 * * AUTHORS * Kai Zhao (ltcd3@cn.ibm.com) */ #include "config.h" #include "tst_test.h" #ifdef HAVE_LIBAIO #include <errno.h> #include <stdlib.h> #include <libaio.h> #define AIO_MAXIO 32 #define AIO_BLKSIZE (64*1024) static int wait_count = 0; #define DESC_FLAGS_OPR(x, y) .desc = (x == IO_CMD_PWRITE ? "WRITE: " #y: "READ : " #y), \ .flags = y, .operation = x struct testcase { const char *desc; int flags; int operation; } testcases[] = { { DESC_FLAGS_OPR(IO_CMD_PWRITE, O_WRONLY | O_TRUNC | O_DIRECT | O_LARGEFILE | O_CREAT), }, { DESC_FLAGS_OPR(IO_CMD_PREAD, O_RDONLY | O_DIRECT | O_LARGEFILE), }, { DESC_FLAGS_OPR(IO_CMD_PWRITE, O_RDWR | O_TRUNC), }, { DESC_FLAGS_OPR(IO_CMD_PREAD, O_RDWR), }, { DESC_FLAGS_OPR(IO_CMD_PWRITE, O_WRONLY | O_TRUNC), }, { DESC_FLAGS_OPR(IO_CMD_PREAD, O_RDONLY), }, }; /* * Fatal error handler */ static void io_error(const char *func, int rc) { if (rc == -ENOSYS) tst_brk(TCONF, "AIO not in this kernel\n"); else if (rc < 0) tst_brk(TFAIL, "%s: %s\n", func, strerror(-rc)); else tst_brk(TFAIL, "%s: error %d\n", func, rc); } /* * write work done */ static void work_done(io_context_t ctx, struct iocb *iocb, long res, long res2) { (void) ctx; // silence compiler warning (-Wunused) if (res2 != 0) io_error("aio write", res2); if (res != (long)iocb->u.c.nbytes) tst_brk(TFAIL, "write missed bytes expect %lu got %ld\n", iocb->u.c.nbytes, res); wait_count--; } /* * io_wait_run() - wait for an io_event and then call the callback. */ static int io_wait_run(io_context_t ctx, struct timespec *to) { struct io_event events[AIO_MAXIO]; struct io_event *ep; int ret, n; /* * get up to aio_maxio events at a time. */ ret = n = io_getevents(ctx, 1, AIO_MAXIO, events, to); /* * Call the callback functions for each event. */ for (ep = events; n-- > 0; ep++) { io_callback_t cb = (io_callback_t) ep->data; struct iocb *iocb = ep->obj; cb(ctx, iocb, ep->res, ep->res2); } return ret; } static int io_tio(char *pathname, int flag, int operation) { int res, fd = 0, i = 0; void *bufptr = NULL; off_t offset = 0; struct timespec timeout; struct stat fi_stat; size_t alignment; io_context_t myctx; struct iocb iocb_array[AIO_MAXIO]; struct iocb *iocbps[AIO_MAXIO]; fd = SAFE_OPEN(pathname, flag, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); /* determine the alignment from the blksize of the underlying device */ SAFE_FSTAT(fd, &fi_stat); alignment = fi_stat.st_blksize; res = io_queue_init(AIO_MAXIO, &myctx); for (i = 0; i < AIO_MAXIO; i++) { switch (operation) { case IO_CMD_PWRITE: if (posix_memalign(&bufptr, alignment, AIO_BLKSIZE)) { tst_brk(TBROK | TERRNO, "posix_memalign failed"); return -1; } memset(bufptr, 0, AIO_BLKSIZE); io_prep_pwrite(&iocb_array[i], fd, bufptr, AIO_BLKSIZE, offset); io_set_callback(&iocb_array[i], work_done); iocbps[i] = &iocb_array[i]; offset += AIO_BLKSIZE; break; case IO_CMD_PREAD: if (posix_memalign(&bufptr, alignment, AIO_BLKSIZE)) { tst_brk(TBROK | TERRNO, "posix_memalign failed"); return -1; } memset(bufptr, 0, AIO_BLKSIZE); io_prep_pread(&iocb_array[i], fd, bufptr, AIO_BLKSIZE, offset); io_set_callback(&iocb_array[i], work_done); iocbps[i] = &iocb_array[i]; offset += AIO_BLKSIZE; break; default: tst_res(TFAIL, "Command failed; opcode returned: %d\n", operation); return -1; break; } } do { res = io_submit(myctx, AIO_MAXIO, iocbps); } while (res == -EAGAIN); if (res < 0) io_error("io_submit tio", res); /* * We have submitted all the i/o requests. Wait for them to complete and * call the callbacks. */ wait_count = AIO_MAXIO; timeout.tv_sec = 30; timeout.tv_nsec = 0; switch (operation) { case IO_CMD_PREAD: case IO_CMD_PWRITE: { while (wait_count) { res = io_wait_run(myctx, &timeout); if (res < 0) io_error("io_wait_run", res); } } break; } SAFE_CLOSE(fd); for (i = 0; i < AIO_MAXIO; i++) if (iocb_array[i].u.c.buf != NULL) free(iocb_array[i].u.c.buf); io_queue_release(myctx); return 0; } static void test_io(unsigned int n) { int status; struct testcase *tc = testcases + n; status = io_tio("file", tc->flags, tc->operation); if (status) tst_res(TFAIL, "%s, status = %d", tc->desc, status); else tst_res(TPASS, "%s", tc->desc); } static struct tst_test test = { .needs_tmpdir = 1, .test = test_io, .tcnt = ARRAY_SIZE(testcases), }; #else TST_TEST_TCONF("test requires libaio and its development packages"); #endif