src/aio-dio-regress/aio-dio-subblock-eof-read.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2005 Jeff Moyer
 */

/*
 *  Test AIO read of last block of DIO file
 *
 *  Code taken from an example posted to linux-aio at kvack.org
 *  http://marc.info/?l=linux-aio&m=112263621431161&w=2
 *  Original Author: Drangon Zhou
 *  Munged & rewritten by Jeff Moyer.
 *
 *  Description:  This source code implements a test to ensure that an AIO
 *  read of the last block in a file opened with O_DIRECT returns the proper
 *  amount of data.  In the past, there was a bug that resulted in a return
 *  value of the requested block size, when in fact there was only a fraction
 *  of that data available.  Thus, if the last data block contained 300 bytes
 *  worth of data, and the user issued a 4k read, we want to ensure that
 *  the return value is 300, not 4k.
 */
#include <stdio.h>
#include <stdlib.h>
#include <libaio.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

/* Create a file of a size that is not a multiple of block size */
#define FILE_SIZE	300

#define fail(fmt , args...) 	\
do {				\
	printf(fmt , ##args);	\
	exit(1);		\
} while (0)

static unsigned char buffer[4096] __attribute((aligned (4096)));

int
main(int argc, char **argv)
{
	int ret;
	int fd;
	const char *filename;
	struct iocb myiocb;
	struct iocb *cb = &myiocb;
	io_context_t ioctx;
	struct io_event ie;
    
	if (argc != 2)
		fail("only arg should be file name");

	filename = argv[1];
	fd = open(filename, O_CREAT|O_RDWR|O_DIRECT, 0600);
	if (fd < 0)
		fail("open returned error %d\n", errno);

	ret = ftruncate(fd, FILE_SIZE);
	if (ret < 0)
		fail("truncate returned error %d\n", errno);

	/* <1> use normal disk read, this should be ok */
	ret = read(fd, buffer, 4096);
	if (ret != FILE_SIZE)
		fail("buffered read returned %d, should be %d\n", ret, FILE_SIZE);

	/* <2> use AIO disk read, it sees error. */
	memset(&myiocb, 0, sizeof(myiocb));
	cb->data = 0;
	cb->key = 0;
	cb->aio_lio_opcode = IO_CMD_PREAD;
	cb->aio_reqprio = 0; 
	cb->aio_fildes = fd; 
	cb->u.c.buf = buffer;
	cb->u.c.nbytes = 4096;
	cb->u.c.offset = 0;
    
	ret = io_queue_init(1, &ioctx);
	if (ret != 0)
		fail("io_queue_init returned error %d\n", ret);

	ret = io_submit(ioctx, 1, &cb);
	if (ret != 1)
		fail("io_submit returned error %d\n", ret);

	ret = io_getevents(ioctx, 1, 1, &ie, NULL);
	if (ret != 1)
		fail("io_getevents returned %d\n", ret);

	/*
	 *  If all goes well, we should see FILE_SIZE bytes read.  If things
	 *  are broken, we may very well see a result of 4k.
	 */
	if (ie.res != FILE_SIZE)
		fail("AIO read of last block in file returned %ld bytes, "
		     "expected %d\n", ie.res, FILE_SIZE);

	printf("AIO read of last block in file succeeded.\n");
	return 0;
}