example.c

//XXX lines marked XXX are additions to what's on the Linux aio(7) man page
#include <fcntl.h> //XXX
#include <string.h> //XXX
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <aio.h>
#include <signal.h>

#define BUF_SIZE 20     /* Size of buffers for read operations */

#define errExit(msg) do { perror(msg); exit(EXIT_FAILURE); } while (0)

#define errMsg(msg)  do { perror(msg); } while (0)

struct ioRequest {      /* Application-defined structure for tracking
				  I/O requests */
    int             reqNum;
    int             status;
    struct aiocb   *aiocbp;
};

static volatile sig_atomic_t gotSIGQUIT = 0;
			       /* On delivery of SIGQUIT, we attempt to
				  cancel all outstanding I/O requests */

static void	       /* Handler for SIGQUIT */
quitHandler(int sig)
{
    gotSIGQUIT = 1;
}

#define IO_SIGNAL SIGUSR1   /* Signal used to notify I/O completion */

static void		   /* Handler for I/O completion signal */
aioSigHandler(int sig, siginfo_t *si, void *ucontext)
{
    write(STDOUT_FILENO, "I/O completion signal received\n", 31);

    /* The corresponding ioRequest structure would be available as
       struct ioRequest *ioReq = si->si_value.sival_ptr;
       and the file descriptor would then be available via
       ioReq->aiocbp->aio_fildes */
}

int
main(int argc, char *argv[])
{
    struct ioRequest *ioList;
    struct aiocb *aiocbList;
    struct sigaction sa;
    int s, j;
    int numReqs;        /* Total number of queued I/O requests */
    int openReqs;       /* Number of I/O requests still in progress */

    if (argc < 2) {
	fprintf(stderr, "Usage: %s <pathname> <pathname>...\n", argv[0]);
	exit(EXIT_FAILURE);
    }

    numReqs = argc - 1;

    /* Allocate our arrays */

    ioList = calloc(numReqs, sizeof(struct ioRequest));
    if (ioList == NULL)
	errExit("calloc");

    aiocbList = calloc(numReqs, sizeof(struct aiocb));
    if (aiocbList == NULL)
	errExit("calloc");

    /* Establish handlers for SIGQUIT and the I/O completion signal */

    sa.sa_flags = SA_RESTART;
    sigemptyset(&sa.sa_mask);

    sa.sa_handler = quitHandler;
    if (sigaction(SIGQUIT, &sa, NULL) == -1)
	errExit("sigaction");

    sa.sa_flags = SA_RESTART | SA_SIGINFO;
    sa.sa_sigaction = aioSigHandler;
    if (sigaction(IO_SIGNAL, &sa, NULL) == -1)
	errExit("sigaction");

    /* Open each file specified on the command line, and queue
       a read request on the resulting file descriptor */

    printf("\naio_read() phase:\n"); //XXX
    for (j = 0; j < numReqs; j++) {
	ioList[j].reqNum = j;
	ioList[j].status = EINPROGRESS;
	ioList[j].aiocbp = &aiocbList[j];

	ioList[j].aiocbp->aio_fildes = open(argv[j + 1], O_RDONLY);
	if (ioList[j].aiocbp->aio_fildes == -1)
	    errExit("open");
	printf("opened %s on descriptor %d\n", argv[j + 1],
	       ioList[j].aiocbp->aio_fildes);

	ioList[j].aiocbp->aio_buf = malloc(BUF_SIZE);
	if (ioList[j].aiocbp->aio_buf == NULL)
	    errExit("malloc");

	ioList[j].aiocbp->aio_nbytes = BUF_SIZE;
	ioList[j].aiocbp->aio_reqprio = 0;
	ioList[j].aiocbp->aio_offset = 0;
	ioList[j].aiocbp->aio_sigevent.sigev_notify = SIGEV_SIGNAL;
	ioList[j].aiocbp->aio_sigevent.sigev_signo = IO_SIGNAL;
	ioList[j].aiocbp->aio_sigevent.sigev_value.sival_ptr = &ioList[j];

	s = aio_read(ioList[j].aiocbp);
	if (s == -1)
	    errExit("aio_read");
    }

    openReqs = numReqs;

    /* Loop, monitoring status of I/O requests */

    while (openReqs > 0) {
	printf("sleeping for 3 seconds...\n"); //XXX
	sleep(3);       /* Delay between each monitoring step */

	if (gotSIGQUIT) {

	    /* On receipt of SIGQUIT, attempt to cancel each of the
	       outstanding I/O requests, and display status returned
	       from the cancellation requests */

	    printf("got SIGQUIT; canceling I/O requests: \n");

	    for (j = 0; j < numReqs; j++) {
		if (ioList[j].status == EINPROGRESS) {
		    printf("    Request %d on descriptor %d:", j,
			   ioList[j].aiocbp->aio_fildes);
		    s = aio_cancel(ioList[j].aiocbp->aio_fildes,
				   ioList[j].aiocbp);
		    if (s == AIO_CANCELED)
			printf("I/O canceled\n");
		    else if (s == AIO_NOTCANCELED)
			printf("I/O not canceled\n");
		    else if (s == AIO_ALLDONE)
			printf("I/O all done\n");
		    else
			printf("aio_cancel returns %d\n", s);
		}
	}

	gotSIGQUIT = 0;
	}

	/* Check the status of each I/O request that is still in progress */

	printf("\naio_error() phase:\n"); //XXX
	for (j = 0; j < numReqs; j++) {
	    if (ioList[j].status == EINPROGRESS) {
		printf("    for request %d (descriptor %d): ",
		       j, ioList[j].aiocbp->aio_fildes);
		ioList[j].status = aio_error(ioList[j].aiocbp);

		switch (ioList[j].status) {
		case 0:
		    printf("I/O succeeded\n");
		    break;

		case EINPROGRESS:
		    printf("In progress\n");
		    break;

		case ECANCELED:
		    printf("Canceled\n");
		    break;

		default:
		    printf("%s\n", strerror(ioList[j].status));
		    break;
		}

	    if (ioList[j].status != EINPROGRESS)
		openReqs--;
	    }
	}
    }

    printf("All I/O requests completed\n");

    /* Check status return of all I/O requests */

    printf("\naio_return() phase:\n"); //XXX
    for (j = 0; j < numReqs; j++) {
	ssize_t s;

	s = aio_return(ioList[j].aiocbp);
	printf("    for request %d (descriptor %d): %ld\n",
	       j, ioList[j].aiocbp->aio_fildes, (long) s);
    }

    exit(EXIT_SUCCESS);
}