AIO(7) Miscellaneous Information Manual AIO(7) aio - / POSIX / (AIO) POSIX / ( ). / : . POSIX AIO : aio_read(3) . read(2). aio_write(3) . write(2). aio_fsync(3) / . fsync(2) fdatasync(2). aio_error(3) / . aio_return(3) / . aio_suspend(3) / . aio_cancel(3) / . lio_listio(3) / . aiocb (" / ") /. . : #include struct aiocb { /* The order of these fields is implementation-dependent */ int aio_fildes; /* File descriptor */ off_t aio_offset; /* File offset */ volatile void *aio_buf; /* Location of buffer */ size_t aio_nbytes; /* Length of transfer */ int aio_reqprio; /* Request priority */ struct sigevent aio_sigevent; /* Notification method */ int aio_lio_opcode; /* Operation to be performed; lio_listio() only */ /* Various implementation-internal fields not shown */ }; /* Operation codes for 'aio_lio_opcode': */ enum { LIO_READ, LIO_WRITE, LIO_NOP }; : aio_fildes /. aio_offset /. aio_buf . aio_nbytes aio_buf. aio_reqprio / ( pthread_setschedparam(3)). 0 sysconf(_SC_AIO_PRIO_DELTA_MAX). . aio_sigevent / . aio_sigevent.sigev_notify SIGEV_NONE SIGEV_SIGNAL SIGEV_THREAD. sigevent(3type) . aio_lio_opcode lio_listio(3). GNU C POSIX AIO: aio_init(3) glibc POSIX AIO. EINVAL aio_reqprio aiocb 0 sysconf(_SC_AIO_PRIO_DELTA_MAX). POSIX.1-2008. POSIX.1-2001. glibc 2.1. ( memset(3)). aio_buf /. /. aiocb . Linux POSIX AIO glibc. / . / ( io_submit(2) io_setup(2) io_cancel(2) io_destroy(2) io_getevents(2)) POSIX AIO . aio_read(3). / aio_error(3). / . / aio_return(3). SIGQUIT ( control-\) aio_cancel(3). . "abc" "x". $ ./a.out /dev/stdin /dev/stdin; opened /dev/stdin on descriptor 3 opened /dev/stdin on descriptor 4 aio_error(): for request 0 (descriptor 3): In progress for request 1 (descriptor 4): In progress abc I/O completion signal received aio_error(): for request 0 (descriptor 3): I/O succeeded for request 1 (descriptor 4): In progress aio_error(): for request 1 (descriptor 4): In progress x I/O completion signal received aio_error(): for request 1 (descriptor 4): I/O succeeded All I/O requests completed aio_return(): for request 0 (descriptor 3): 4 for request 1 (descriptor 4): 2 #include #include #include #include #include #include #include #include #define BUF_SIZE 20 /* Size of buffers for read operations */ 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) { if (si->si_code == SI_ASYNCIO) { 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 sigaction sa; int s; 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 ...\n", argv[0]); exit(EXIT_FAILURE); } numReqs = argc - 1; /* Allocate our arrays. */ struct ioRequest *ioList = calloc(numReqs, sizeof(*ioList)); if (ioList == NULL) err(EXIT_FAILURE, "calloc"); struct aiocb *aiocbList = calloc(numReqs, sizeof(*aiocbList)); if (aiocbList == NULL) err(EXIT_FAILURE, "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) err(EXIT_FAILURE, "sigaction"); sa.sa_flags = SA_RESTART | SA_SIGINFO; sa.sa_sigaction = aioSigHandler; if (sigaction(IO_SIGNAL, &sa, NULL) == -1) err(EXIT_FAILURE, "sigaction"); /* Open each file specified on the command line, and queue a read request on the resulting file descriptor. */ for (size_t 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) err(EXIT_FAILURE, "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) err(EXIT_FAILURE, "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) err(EXIT_FAILURE, "aio_read"); } openReqs = numReqs; /* Loop, monitoring status of I/O requests. */ while (openReqs > 0) { 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 cancelation requests. */ printf("got SIGQUIT; canceling I/O requests: \n"); for (size_t j = 0; j < numReqs; j++) { if (ioList[j].status == EINPROGRESS) { printf(" Request %zu 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 perror("aio_cancel"); } } gotSIGQUIT = 0; } /* Check the status of each I/O request that is still in progress. */ printf("aio_error():\n"); for (size_t j = 0; j < numReqs; j++) { if (ioList[j].status == EINPROGRESS) { printf(" for request %zu (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: perror("aio_error"); break; } if (ioList[j].status != EINPROGRESS) openReqs--; } } } printf("All I/O requests completed\n"); /* Check status return of all I/O requests. */ printf("aio_return():\n"); for (size_t j = 0; j < numReqs; j++) { ssize_t s; s = aio_return(ioList[j].aiocbp); printf(" for request %zu (descriptor %d): %zd\n", j, ioList[j].aiocbp->aio_fildes, s); } exit(EXIT_SUCCESS); } io_cancel(2), io_destroy(2), io_getevents(2), io_setup(2), io_submit(2), aio_cancel(3), aio_error(3), aio_init(3), aio_read(3), aio_return(3), aio_write(3), lio_listio(3) " / 2.5" 2003 3 . . : . 6.18 8 2026 AIO(7)