Diff for /qemu/posix-aio-compat.c between versions 1.1.1.7 and 1.1.1.8

version 1.1.1.7, 2018/04/24 19:17:04 version 1.1.1.8, 2018/04/24 19:34:14
Line 9 Line 9
  * This work is licensed under the terms of the GNU GPL, version 2.  See   * This work is licensed under the terms of the GNU GPL, version 2.  See
  * the COPYING file in the top-level directory.   * the COPYING file in the top-level directory.
  *   *
    * Contributions after 2012-01-13 are licensed under the terms of the
    * GNU GPL, version 2 or (at your option) any later version.
  */   */
   
 #include <sys/ioctl.h>  #include <sys/ioctl.h>
Line 128  static ssize_t handle_aiocb_ioctl(struct Line 130  static ssize_t handle_aiocb_ioctl(struct
         return -errno;          return -errno;
   
     /*      /*
      * This looks weird, but the aio code only consideres a request       * This looks weird, but the aio code only considers a request
      * successful if it has written the number full number of bytes.       * successful if it has written the full number of bytes.
      *       *
      * Now we overload aio_nbytes as aio_ioctl_cmd for the ioctl command,       * Now we overload aio_nbytes as aio_ioctl_cmd for the ioctl command,
      * so in fact we return the ioctl command here to make posix_aio_read()       * so in fact we return the ioctl command here to make posix_aio_read()
Line 466  static int qemu_paio_error(struct qemu_p Line 468  static int qemu_paio_error(struct qemu_p
     return ret;      return ret;
 }  }
   
 static int posix_aio_process_queue(void *opaque)  static void posix_aio_read(void *opaque)
 {  {
     PosixAioState *s = opaque;      PosixAioState *s = opaque;
     struct qemu_paiocb *acb, **pacb;      struct qemu_paiocb *acb, **pacb;
     int ret;      int ret;
     int result = 0;      ssize_t len;
   
       /* read all bytes from signal pipe */
       for (;;) {
           char bytes[16];
   
           len = read(s->rfd, bytes, sizeof(bytes));
           if (len == -1 && errno == EINTR)
               continue; /* try again */
           if (len == sizeof(bytes))
               continue; /* more to read */
           break;
       }
   
     for(;;) {      for(;;) {
         pacb = &s->first_aio;          pacb = &s->first_aio;
         for(;;) {          for(;;) {
             acb = *pacb;              acb = *pacb;
             if (!acb)              if (!acb)
                 return result;                  return;
   
             ret = qemu_paio_error(acb);              ret = qemu_paio_error(acb);
             if (ret == ECANCELED) {              if (ret == ECANCELED) {
                 /* remove the request */                  /* remove the request */
                 *pacb = acb->next;                  *pacb = acb->next;
                 qemu_aio_release(acb);                  qemu_aio_release(acb);
                 result = 1;  
             } else if (ret != EINPROGRESS) {              } else if (ret != EINPROGRESS) {
                 /* end of aio */                  /* end of aio */
                 if (ret == 0) {                  if (ret == 0) {
Line 505  static int posix_aio_process_queue(void  Line 518  static int posix_aio_process_queue(void 
                 /* call the callback */                  /* call the callback */
                 acb->common.cb(acb->common.opaque, ret);                  acb->common.cb(acb->common.opaque, ret);
                 qemu_aio_release(acb);                  qemu_aio_release(acb);
                 result = 1;  
                 break;                  break;
             } else {              } else {
                 pacb = &acb->next;                  pacb = &acb->next;
             }              }
         }          }
     }      }
   
     return result;  
 }  
   
 static void posix_aio_read(void *opaque)  
 {  
     PosixAioState *s = opaque;  
     ssize_t len;  
   
     /* read all bytes from signal pipe */  
     for (;;) {  
         char bytes[16];  
   
         len = read(s->rfd, bytes, sizeof(bytes));  
         if (len == -1 && errno == EINTR)  
             continue; /* try again */  
         if (len == sizeof(bytes))  
             continue; /* more to read */  
         break;  
     }  
   
     posix_aio_process_queue(s);  
 }  }
   
 static int posix_aio_flush(void *opaque)  static int posix_aio_flush(void *opaque)
Line 611  BlockDriverAIOCB *paio_submit(BlockDrive Line 601  BlockDriverAIOCB *paio_submit(BlockDrive
     struct qemu_paiocb *acb;      struct qemu_paiocb *acb;
   
     acb = qemu_aio_get(&raw_aio_pool, bs, cb, opaque);      acb = qemu_aio_get(&raw_aio_pool, bs, cb, opaque);
     if (!acb)  
         return NULL;  
     acb->aio_type = type;      acb->aio_type = type;
     acb->aio_fildes = fd;      acb->aio_fildes = fd;
   
Line 638  BlockDriverAIOCB *paio_ioctl(BlockDriver Line 626  BlockDriverAIOCB *paio_ioctl(BlockDriver
     struct qemu_paiocb *acb;      struct qemu_paiocb *acb;
   
     acb = qemu_aio_get(&raw_aio_pool, bs, cb, opaque);      acb = qemu_aio_get(&raw_aio_pool, bs, cb, opaque);
     if (!acb)  
         return NULL;  
     acb->aio_type = QEMU_AIO_IOCTL;      acb->aio_type = QEMU_AIO_IOCTL;
     acb->aio_fildes = fd;      acb->aio_fildes = fd;
     acb->aio_offset = 0;      acb->aio_offset = 0;
Line 677  int paio_init(void) Line 663  int paio_init(void)
     fcntl(s->rfd, F_SETFL, O_NONBLOCK);      fcntl(s->rfd, F_SETFL, O_NONBLOCK);
     fcntl(s->wfd, F_SETFL, O_NONBLOCK);      fcntl(s->wfd, F_SETFL, O_NONBLOCK);
   
     qemu_aio_set_fd_handler(s->rfd, posix_aio_read, NULL, posix_aio_flush,      qemu_aio_set_fd_handler(s->rfd, posix_aio_read, NULL, posix_aio_flush, s);
         posix_aio_process_queue, s);  
   
     ret = pthread_attr_init(&attr);      ret = pthread_attr_init(&attr);
     if (ret)      if (ret)

Removed from v.1.1.1.7  
changed lines
  Added in v.1.1.1.8


unix.superglobalmegacorp.com