lio_test.c

/*-
 * Copyright (c) 2017 Spectra Logic Corp
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#define _WANT_ALL_LIO_OPCODES

#include <sys/param.h>
#include <sys/event.h>
#include <sys/uio.h>

#include <aio.h>
#include <fcntl.h>
#include <semaphore.h>
#include <stdlib.h>

#include <atf-c.h>

#include "local.h"

static sem_t completions; 


static void
handler(int sig __unused)
{
	ATF_REQUIRE_EQ(0, sem_post(&completions));
}

static void
thr_handler(union sigval sv __unused)
{
	ATF_REQUIRE_EQ(0, sem_post(&completions));
}

/* 
 * If lio_listio is unable to enqueue any requests at all, it should return
 * EAGAIN.
 */
ATF_TC_WITHOUT_HEAD(lio_listio_eagain_kevent);
ATF_TC_BODY(lio_listio_eagain_kevent, tc)
{
	int fd, i, j, kq, max_queue_per_proc, ios_per_call;
	size_t max_queue_per_proc_size;
	struct aiocb *aiocbs[2];
	struct aiocb **list[2];
	struct sigevent sev[2];
	char *buffer;
	const char *path="tempfile";
	void *udata[2];

	ATF_REQUIRE_UNSAFE_AIO();

	max_queue_per_proc_size = sizeof(max_queue_per_proc);
	ATF_REQUIRE_EQ(sysctlbyname("vfs.aio.max_aio_queue_per_proc",
	    &max_queue_per_proc, &max_queue_per_proc_size, NULL, 0), 0);
	ios_per_call = max_queue_per_proc;

	fd = open(path, O_RDWR|O_CREAT, 0666);
	ATF_REQUIRE(fd >= 0);

	kq = kqueue();
	ATF_REQUIRE(kq > 0);

	buffer = calloc(1, 4096);
	ATF_REQUIRE(buffer != NULL);

	/*
	 * Call lio_listio twice, each with the maximum number of operations.
	 * The first call should succeed and the second should fail.
	 */
	for (i = 0; i < 2; i++) {
		aiocbs[i] = calloc(ios_per_call, sizeof(struct aiocb));
		ATF_REQUIRE(aiocbs[i] != NULL);
		list[i] = calloc(ios_per_call, sizeof(struct aiocb*));
		ATF_REQUIRE(list[i] != NULL);
		udata[i] = (void*)((caddr_t)0xdead0000 + i);
		sev[i].sigev_notify = SIGEV_KEVENT;
		sev[i].sigev_notify_kqueue = kq;
		sev[i].sigev_value.sival_ptr = udata[i];
		for (j = 0; j < ios_per_call; j++) {
			aiocbs[i][j].aio_fildes = fd;
			aiocbs[i][j].aio_offset = (i * ios_per_call + j) * 4096;
			aiocbs[i][j].aio_buf = buffer;
			aiocbs[i][j].aio_nbytes = 4096;
			aiocbs[i][j].aio_lio_opcode = LIO_WRITE;
			list[i][j] = &aiocbs[i][j];
		}
	}

	ATF_REQUIRE_EQ(0, lio_listio(LIO_NOWAIT, list[0], ios_per_call, &sev[0]));
	ATF_REQUIRE_EQ(-1, lio_listio(LIO_NOWAIT, list[1], ios_per_call, &sev[1]));
	/*
	 * The second lio_listio call should fail with EAGAIN.  Bad timing may
	 * mean that some requests did get enqueued, but the result should
	 * still be EAGAIN.
	 */
	ATF_REQUIRE_EQ(errno, EAGAIN);
}


/* With LIO_WAIT, an empty lio_listio should return immediately */
ATF_TC_WITHOUT_HEAD(lio_listio_empty_wait);
ATF_TC_BODY(lio_listio_empty_wait, tc)
{
	struct aiocb *list = NULL;

	ATF_REQUIRE_EQ(0, lio_listio(LIO_WAIT, &list, 0, NULL));
}

/* With LIO_NOWAIT, an empty lio_listio should return immediately */
ATF_TC_WITHOUT_HEAD(lio_listio_empty_nowait);
ATF_TC_BODY(lio_listio_empty_nowait, tc)
{
	struct aiocb *list = NULL;

	ATF_REQUIRE_EQ(0, lio_listio(LIO_NOWAIT, &list, 0, NULL));
}

/*
 * With LIO_NOWAIT, an empty lio_listio should send completion notification
 * immediately
 */
ATF_TC_WITHOUT_HEAD(lio_listio_empty_nowait_kevent);
ATF_TC_BODY(lio_listio_empty_nowait_kevent, tc)
{
	struct aiocb *list = NULL;
	struct sigevent sev;
	struct kevent kq_returned;
	int kq, result;
	void *udata = (void*)0xdeadbeefdeadbeef;

	atf_tc_expect_timeout("Bug 251515 - lio_listio(2) never sends"
			" kevent if nent==0");
	kq = kqueue();
	ATF_REQUIRE(kq > 0);
	sev.sigev_notify = SIGEV_KEVENT;
	sev.sigev_notify_kqueue = kq;
	sev.sigev_value.sival_ptr = udata;
	ATF_REQUIRE_EQ(0, lio_listio(LIO_NOWAIT, &list, 0, &sev));
	result = kevent(kq, NULL, 0, &kq_returned, 1, NULL);
	ATF_REQUIRE_MSG(result == 1, "Never got completion notification");
	ATF_REQUIRE_EQ((uintptr_t)list, kq_returned.ident);
	ATF_REQUIRE_EQ(EVFILT_LIO, kq_returned.filter);
	ATF_REQUIRE_EQ(udata, kq_returned.udata);
}

/*
 * With LIO_NOWAIT, an empty lio_listio should send completion notification
 * immediately
 */
ATF_TC_WITHOUT_HEAD(lio_listio_empty_nowait_signal);
ATF_TC_BODY(lio_listio_empty_nowait_signal, tc)
{
	struct aiocb *list = NULL;
	struct sigevent sev;

	ATF_REQUIRE_EQ(0, sem_init(&completions, false, 0));
	sev.sigev_notify = SIGEV_SIGNAL;
	sev.sigev_signo = SIGUSR1;
	ATF_REQUIRE(SIG_ERR != signal(SIGUSR1, handler));
	ATF_REQUIRE_EQ(0, lio_listio(LIO_NOWAIT, &list, 0, &sev));
	ATF_REQUIRE_EQ(0, sem_wait(&completions));
	ATF_REQUIRE_EQ(0, sem_destroy(&completions));
}

/*
 * With LIO_NOWAIT, an empty lio_listio should send completion notification
 * immediately
 */
ATF_TC_WITHOUT_HEAD(lio_listio_empty_nowait_thread);
ATF_TC_BODY(lio_listio_empty_nowait_thread, tc)
{
	struct aiocb *list = NULL;
	struct sigevent sev;

	ATF_REQUIRE_EQ(0, sem_init(&completions, false, 0));
	bzero(&sev, sizeof(sev));
	sev.sigev_notify = SIGEV_THREAD;
	sev.sigev_notify_function = thr_handler;
	sev.sigev_notify_attributes = NULL;
	ATF_REQUIRE_MSG(0 == lio_listio(LIO_NOWAIT, &list, 0, &sev),
	    "lio_listio: %s", strerror(errno));
	ATF_REQUIRE_EQ(0, sem_wait(&completions));
	ATF_REQUIRE_EQ(0, sem_destroy(&completions));
}

/*
 * A simple check that the allowed operations work.
 */
ATF_TC_WITHOUT_HEAD(lio_listio_opcodes);
ATF_TC_BODY(lio_listio_opcodes, tc)
{
	struct aiocb write_cb, read_cb, writev_cb, readv_cb;
	struct aiocb *list[] = {&write_cb, &read_cb, &writev_cb, &readv_cb};
	struct iovec writev_iov[2];
	struct iovec readv_iov[2];
	char buffer[6];
	int fd;

	fd = open("testfile", O_CREAT | O_RDWR, 0666);
	ATF_REQUIRE_MSG(fd >= 0, "open: %s", strerror(errno));

	/* We start with numbers in a file and letters in memory... */
	ATF_CHECK_EQ(6, write(fd, "123456", 6));
	memcpy(buffer, "abcdef", 6);

	/* a -> 1 */
	bzero(&write_cb, sizeof(write_cb));
	write_cb.aio_sigevent.sigev_notify = SIGEV_NONE;
	write_cb.aio_fildes = fd;
	write_cb.aio_lio_opcode = LIO_WRITE;
	write_cb.aio_buf = &buffer[0];
	write_cb.aio_nbytes = 1;
	write_cb.aio_offset = 0;

	/* b <- 2 */
	bzero(&read_cb, sizeof(read_cb));
	read_cb.aio_sigevent.sigev_notify = SIGEV_NONE;
	read_cb.aio_fildes = fd;
	read_cb.aio_lio_opcode = LIO_READ;
	read_cb.aio_buf = &buffer[1];
	read_cb.aio_nbytes = 1;
	read_cb.aio_offset = 1;

	/* d -> 3, c -> 4 */
	writev_iov[0].iov_base = &buffer[3];
	writev_iov[0].iov_len = 1;
	writev_iov[1].iov_base = &buffer[2];
	writev_iov[1].iov_len = 1;
	bzero(&writev_cb, sizeof(writev_cb));
	writev_cb.aio_sigevent.sigev_notify = SIGEV_NONE;
	writev_cb.aio_fildes = fd;
	writev_cb.aio_lio_opcode = LIO_WRITEV;
	writev_cb.aio_iov = &writev_iov;
	writev_cb.aio_iovcnt = 2;
	writev_cb.aio_offset = 2;

	/* f <- 5, e <- 6 */
	readv_iov[0].iov_base = &buffer[5];
	readv_iov[0].iov_len = 1;
	readv_iov[1].iov_base = &buffer[4];
	readv_iov[1].iov_len = 1;
	bzero(&readv_cb, sizeof(readv_cb));
	readv_cb.aio_sigevent.sigev_notify = SIGEV_NONE;
	readv_cb.aio_fildes = fd;
	readv_cb.aio_lio_opcode = LIO_READV;
	readv_cb.aio_iov = &readv_iov;
	readv_cb.aio_iovcnt = 2;
	readv_cb.aio_offset = 4;

	ATF_CHECK_EQ(0, lio_listio(LIO_WAIT, list, nitems(list), NULL));
	ATF_CHECK_EQ(0, aio_error(&write_cb));
	ATF_CHECK_EQ(1, aio_return(&write_cb));
	ATF_CHECK_EQ(0, aio_error(&read_cb));
	ATF_CHECK_EQ(1, aio_return(&read_cb));
	ATF_CHECK_EQ(0, aio_error(&writev_cb));
	ATF_CHECK_EQ(2, aio_return(&writev_cb));
	ATF_CHECK_EQ(0, aio_error(&readv_cb));
	ATF_CHECK_EQ(2, aio_return(&readv_cb));

	ATF_CHECK_EQ(0, memcmp(buffer, "a2cd65", 6));
	ATF_CHECK_EQ(6, pread(fd, buffer, 6, 0));
	ATF_CHECK_EQ(0, memcmp(buffer, "a2dc56", 6));

	close(fd);
}


/*
 * Only select opcodes are allowed with lio_listio
 */
ATF_TC_WITHOUT_HEAD(lio_listio_invalid_opcode);
ATF_TC_BODY(lio_listio_invalid_opcode, tc)
{
	struct aiocb sync_cb, mlock_cb;
	struct aiocb *list[] = {&sync_cb, &mlock_cb};
	int fd;

	fd = open("testfile", O_CREAT | O_RDWR, 0666);
	ATF_REQUIRE_MSG(fd >= 0, "open: %s", strerror(errno));

	bzero(&sync_cb, sizeof(sync_cb));
	sync_cb.aio_fildes = fd;
	sync_cb.aio_lio_opcode = LIO_SYNC;

	bzero(&mlock_cb, sizeof(mlock_cb));
	mlock_cb.aio_lio_opcode = LIO_MLOCK;

	ATF_CHECK_ERRNO(EIO, lio_listio(LIO_WAIT, list, nitems(list), NULL));
	ATF_CHECK_EQ(EINVAL, aio_error(&sync_cb));
	ATF_CHECK_ERRNO(EINVAL, aio_return(&sync_cb) < 0);
	ATF_CHECK_EQ(EINVAL, aio_error(&mlock_cb));
	ATF_CHECK_ERRNO(EINVAL, aio_return(&mlock_cb) < 0);

	close(fd);
}


ATF_TP_ADD_TCS(tp)
{

	ATF_TP_ADD_TC(tp, lio_listio_eagain_kevent);
	ATF_TP_ADD_TC(tp, lio_listio_empty_nowait);
	ATF_TP_ADD_TC(tp, lio_listio_empty_nowait_kevent);
	ATF_TP_ADD_TC(tp, lio_listio_empty_nowait_signal);
	ATF_TP_ADD_TC(tp, lio_listio_empty_nowait_thread);
	ATF_TP_ADD_TC(tp, lio_listio_empty_wait);
	ATF_TP_ADD_TC(tp, lio_listio_opcodes);
	ATF_TP_ADD_TC(tp, lio_listio_invalid_opcode);

	return (atf_no_error());
}