// 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