Man Linux: Main Page and Category List


       io - Asynchronous IO


       #include <errno.h>

       #include <libaio.h>


       The  libaio  library  defines  a  new  set  of I/O operations which can
       significantly reduce the time an application  spends  waiting  at  I/O.
       The  new  functions  allow  a  program  to  initiate  one  or  more I/O
       operations and then  immediately  resume  normal  work  while  the  I/O
       operations are executed in parallel.

       These  functions  are part of the library with realtime functions named
       libaio.   They  are  not  actually  part  of  the  libc  binary.    The
       implementation  of  these  functions  can  be done using support in the

       All IO operations operate on files which were opened previously.  There
       might  be  arbitrarily  many  operations  running  for  one  file.  The
       asynchronous I/O operations are controlled using a data structure named
       struct iocb It is defined in libaio.h as follows.

       typedef struct io_context *io_context_t;

       typedef enum io_iocb_cmd {
               IO_CMD_PREAD = 0,
               IO_CMD_PWRITE = 1,

               IO_CMD_FSYNC = 2,
               IO_CMD_FDSYNC = 3,

               IO_CMD_POLL = 5,
               IO_CMD_NOOP = 6,
       } io_iocb_cmd_t;

       struct io_iocb_common {
               void            *buf;
               unsigned        __pad1;
               long            nbytes;
               unsigned        __pad2;
               long long       offset;
               long long       __pad3, __pad4;
       };      /* result code is the amount read or -’ve errno */

       struct iocb {
               void            *data;
               unsigned        key;
               short           aio_lio_opcode;
               short           aio_reqprio;
               int             aio_fildes;
               union {
                       struct io_iocb_common           c;
                       struct io_iocb_vector           v;
                       struct io_iocb_poll             poll;
                       struct io_iocb_sockaddr saddr;
               } u;

       int aio_fildes
              This  element  specifies  the file descriptor to be used for the
              operation.   It  must  be  a  legal  descriptor,  otherwise  the
              operation will fail.

              The  device  on  which  the  file  is opened must allow the seek
              operation.  I.e., it is not  possible  to  use  any  of  the  IO
              operations  on  devices  like  terminals  where an lseek(2) call
              would lead to an error.

       long u.c.offset
              This element specifies the offset  in  the  file  at  which  the
              operation  (input or output) is performed.  Since the operations
              are carried out in arbitrary order and more than  one  operation
              for  one  file  descriptor  can  be started, one cannot expect a
              current read/write position of the file descriptor.

       void *buf
              This is a pointer to the buffer with the data to be  written  or
              the place where the read data is stored.

       long u.c.nbytes
              This  element  specifies  the length of the buffer pointed to by

       int aio_reqprio
              Is not currently used.

              Start  a  read  operation.   Read  from  the  file  at  position
              u.c.offset  and  store  the  next u.c.nbytes bytes in the buffer
              pointed to by buf.

              Start a write operation.  Write u.c.nbytes bytes starting at buf
              into the file starting at position u.c.offset.

              Do  nothing  for  this  control  block.   This  value  is useful
              sometimes when an array of struct iocb  values  contains  holes,
              i.e.,  some of the values must not be handled although the whole
              array is presented to the io_submit function.


              This is experimental.


        * Simplistic version of copy command using async i/o
        * From:  Stephen Hemminger <>
        * Copy file by using a async I/O state machine.
        * 1. Start read request
        * 2. When read completes turn it into a write request
        * 3. When write completes decrement counter and free resources
        * Usage: aiocp file(s) desination

       #include <unistd.h>
       #include <stdio.h>
       #include <sys/types.h>
       #include <sys/stat.h>
       #include <sys/param.h>
       #include <fcntl.h>
       #include <errno.h>

       #include <libaio.h>

       #define AIO_BLKSIZE (64*1024)
       #define AIO_MAXIO   32

       static int busy = 0;          // # of I/O’s in flight
       static int tocopy = 0;        // # of blocks left to copy
       static int dstfd = -1;        // destination file descriptor
       static const char *dstname = NULL;
       static const char *srcname = NULL;

       /* Fatal error handler */
       static void io_error(const char *func, int rc)
           if (rc == -ENOSYS)
            fprintf(stderr, "AIO not in this kernel0);
           else if (rc < 0 && -rc < sys_nerr)
            fprintf(stderr, "%s: %s0, func, sys_errlist[-rc]);
            fprintf(stderr, "%s: error %d0, func, rc);

           if (dstfd > 0)
           if (dstname)

        * Write complete callback.
        * Adjust counts and free resources
       static void wr_done(io_context_t ctx, struct iocb *iocb, long res, long res2)
           if (res2 != 0) {
            io_error("aio write", res2);
           if (res != iocb->u.c.nbytes) {
            fprintf(stderr, "write missed bytes expect %d got %d0, iocb->u.c.nbytes, res2);

           memset(iocb, 0xff, sizeof(iocb));   // paranoia
           write(2, "w", 1);

        * Read complete callback.
        * Change read iocb into a write iocb and start it.
       static void rd_done(io_context_t ctx, struct iocb *iocb, long res, long res2)
           /* library needs accessors to look at iocb? */
           int iosize = iocb->u.c.nbytes;
           char *buf = iocb->u.c.buf;
           off_t offset = iocb->u.c.offset;

           if (res2 != 0)
            io_error("aio read", res2);
           if (res != iosize) {
            fprintf(stderr, "read missing bytes expect %d got %d0, iocb->u.c.nbytes, res);

           /* turn read into write */
           io_prep_pwrite(iocb, dstfd, buf, iosize, offset);
           io_set_callback(iocb, wr_done);
           if (1 != (res = io_submit(ctx, 1, &iocb)))
            io_error("io_submit write", res);
           write(2, "r", 1);

       int main(int argc, char *const *argv)
           int srcfd;
           struct stat st;
           off_t length = 0, offset = 0;
           io_context_t myctx;

           if (argc != 3 || argv[1][0] == ’-’) {
            fprintf(stderr, "Usage: aiocp SOURCE DEST");
           if ((srcfd = open(srcname = argv[1], O_RDONLY)) < 0) {
           if (fstat(srcfd, &st) < 0) {
           length = st.st_size;

           if ((dstfd = open(dstname = argv[2], O_WRONLY | O_CREAT, 0666)) < 0) {

           /* initialize state machine */
           memset(&myctx, 0, sizeof(myctx));
           io_queue_init(AIO_MAXIO, &myctx);
           tocopy = howmany(length, AIO_BLKSIZE);

           while (tocopy > 0) {
            int i, rc;
            /* Submit as many reads as once as possible upto AIO_MAXIO */
            int n = MIN(MIN(AIO_MAXIO - busy, AIO_MAXIO / 2),
                     howmany(length - offset, AIO_BLKSIZE));
            if (n > 0) {
                struct iocb *ioq[n];

                for (i = 0; i < n; i++) {
                 struct iocb *io = (struct iocb *) malloc(sizeof(struct iocb));
                 int iosize = MIN(length - offset, AIO_BLKSIZE);
                 char *buf = (char *) malloc(iosize);

                 if (NULL == buf || NULL == io) {
                     fprintf(stderr, "out of memory0);

                 io_prep_pread(io, srcfd, buf, iosize, offset);
                 io_set_callback(io, rd_done);
                 ioq[i] = io;
                 offset += iosize;

                rc = io_submit(myctx, n, ioq);
                if (rc < 0)
                 io_error("io_submit", rc);

                busy += n;

            // Handle IO’s that have completed
            rc = io_queue_run(myctx);
            if (rc < 0)
                io_error("io_queue_run", rc);

            // if we have maximum number of i/o’s in flight
            // then wait for one to complete
            if (busy == AIO_MAXIO) {
                rc = io_queue_wait(myctx, NULL);
                if (rc < 0)
                 io_error("io_queue_wait", rc);



        * Results look like:
        * [alanm@toolbox ~/MOT3]$ ../taio kernel-source-2.4.8-0.4g.ppc.rpm abc
        * rrrrrrrrrrrrrrrwwwrwrrwwrrwrwwrrwrwrwwrrwrwrrrrwwrwwwrrwrrrwwwwwwwwwwwwwwwww
        * rrrrrrrrrrrrrrwwwrrwrwrwrwrrwwwwwwwwwwwwwwrrrrrrrrrrrrrrrrrrwwwwrwrwwrwrwrwr
        * wrrrrrrrwwwwwwwwwwwwwrrrwrrrwrrwrwwwwwwwwwwrrrrwwrwrrrrrrrrrrrwwwwwwwwwwwrww
        * wwwrrrrrrrrwwrrrwwrwrwrwwwrrrrrrrwwwrrwwwrrwrwwwwwwwwrrrrrrrwwwrrrrrrrwwwwww
        * wwwwwwwrwrrrrrrrrwrrwrrwrrwrwrrrwrrrwrrrwrwwwwwwwwwwwwwwwwwwrrrwwwrrrrrrrrrr
        * rrwrrrrrrwrrwwwwwwwwwwwwwwwwrwwwrrwrwwrrrrrrrrrrrrrrrrrrrwwwwwwwwwwwwwwwwwww
        * rrrrrwrrwrwrwrrwrrrwwwwwwwwrrrrwrrrwrwwrwrrrwrrwrrrrwwwwwwwrwrwwwwrwwrrrwrrr
        * rrrwwwwwwwrrrrwwrrrrrrrrrrrrwrwrrrrwwwwwwwwwwwwwwrwrrrrwwwwrwrrrrwrwwwrrrwww
        * rwwrrrrrrrwrrrrrrrrrrrrwwwwrrrwwwrwrrwwwwwwwwwwwwwwwwwwwwwrrrrrrrwwwwwwwrw


       io_cancel(3),    io_fsync(3),    io_getevents(3),     io_prep_fsync(3),
       io_prep_pread(3),          io_prep_pwrite(3),         io_queue_init(3),
       io_queue_release(3),         io_queue_run(3),         io_queue_wait(3),
       io_set_callback(3), io_submit(3), errno(3).