Diff for /qemu/block.c between versions 1.1.1.9 and 1.1.1.12

version 1.1.1.9, 2018/04/24 17:01:52 version 1.1.1.12, 2018/04/24 17:16:37
Line 41 Line 41
 #define SECTOR_BITS 9  #define SECTOR_BITS 9
 #define SECTOR_SIZE (1 << SECTOR_BITS)  #define SECTOR_SIZE (1 << SECTOR_BITS)
   
   static AIOPool vectored_aio_pool;
   
 typedef struct BlockDriverAIOCBSync {  typedef struct BlockDriverAIOCBSync {
     BlockDriverAIOCB common;      BlockDriverAIOCB common;
     QEMUBH *bh;      QEMUBH *bh;
Line 141  static void bdrv_register(BlockDriver *b Line 143  static void bdrv_register(BlockDriver *b
         bdrv->bdrv_read = bdrv_read_em;          bdrv->bdrv_read = bdrv_read_em;
         bdrv->bdrv_write = bdrv_write_em;          bdrv->bdrv_write = bdrv_write_em;
     }      }
       aio_pool_init(&bdrv->aio_pool, bdrv->aiocb_size, bdrv->bdrv_aio_cancel);
     bdrv->next = first_drv;      bdrv->next = first_drv;
     first_drv = bdrv;      first_drv = bdrv;
 }  }
Line 530  static int bdrv_check_byte_request(Block Line 533  static int bdrv_check_byte_request(Block
   
     len = bdrv_getlength(bs);      len = bdrv_getlength(bs);
   
     if ((offset + size) > len)      if (offset < 0)
           return -EIO;
   
       if ((offset > len) || (len - offset < size))
         return -EIO;          return -EIO;
   
     return 0;      return 0;
Line 1167  int bdrv_write_compressed(BlockDriverSta Line 1173  int bdrv_write_compressed(BlockDriverSta
         return -ENOMEDIUM;          return -ENOMEDIUM;
     if (!drv->bdrv_write_compressed)      if (!drv->bdrv_write_compressed)
         return -ENOTSUP;          return -ENOTSUP;
       if (bdrv_check_request(bs, sector_num, nb_sectors))
           return -EIO;
     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);      return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
 }  }
   
Line 1324  char *bdrv_snapshot_dump(char *buf, int  Line 1332  char *bdrv_snapshot_dump(char *buf, int 
 /**************************************************************/  /**************************************************************/
 /* async I/Os */  /* async I/Os */
   
 typedef struct VectorTranslationState {  typedef struct VectorTranslationAIOCB {
       BlockDriverAIOCB common;
     QEMUIOVector *iov;      QEMUIOVector *iov;
     uint8_t *bounce;      uint8_t *bounce;
     int is_write;      int is_write;
     BlockDriverAIOCB *aiocb;      BlockDriverAIOCB *aiocb;
     BlockDriverAIOCB *this_aiocb;  } VectorTranslationAIOCB;
 } VectorTranslationState;  
   static void bdrv_aio_cancel_vector(BlockDriverAIOCB *_acb)
   {
       VectorTranslationAIOCB *acb
           = container_of(_acb, VectorTranslationAIOCB, common);
   
       bdrv_aio_cancel(acb->aiocb);
   }
   
 static void bdrv_aio_rw_vector_cb(void *opaque, int ret)  static void bdrv_aio_rw_vector_cb(void *opaque, int ret)
 {  {
     VectorTranslationState *s = opaque;      VectorTranslationAIOCB *s = (VectorTranslationAIOCB *)opaque;
   
     if (!s->is_write) {      if (!s->is_write) {
         qemu_iovec_from_buffer(s->iov, s->bounce, s->iov->size);          qemu_iovec_from_buffer(s->iov, s->bounce, s->iov->size);
     }      }
     qemu_vfree(s->bounce);      qemu_vfree(s->bounce);
     s->this_aiocb->cb(s->this_aiocb->opaque, ret);      s->common.cb(s->common.opaque, ret);
     qemu_aio_release(s->this_aiocb);      qemu_aio_release(s);
 }  }
   
 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,  static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
Line 1353  static BlockDriverAIOCB *bdrv_aio_rw_vec Line 1369  static BlockDriverAIOCB *bdrv_aio_rw_vec
                                             int is_write)                                              int is_write)
   
 {  {
     VectorTranslationState *s = qemu_mallocz(sizeof(*s));      VectorTranslationAIOCB *s = qemu_aio_get_pool(&vectored_aio_pool, bs,
     BlockDriverAIOCB *aiocb = qemu_aio_get(bs, cb, opaque);                                                    cb, opaque);
   
     s->this_aiocb = aiocb;  
     s->iov = iov;      s->iov = iov;
     s->bounce = qemu_memalign(512, nb_sectors * 512);      s->bounce = qemu_memalign(512, nb_sectors * 512);
     s->is_write = is_write;      s->is_write = is_write;
Line 1368  static BlockDriverAIOCB *bdrv_aio_rw_vec Line 1383  static BlockDriverAIOCB *bdrv_aio_rw_vec
         s->aiocb = bdrv_aio_read(bs, sector_num, s->bounce, nb_sectors,          s->aiocb = bdrv_aio_read(bs, sector_num, s->bounce, nb_sectors,
                                  bdrv_aio_rw_vector_cb, s);                                   bdrv_aio_rw_vector_cb, s);
     }      }
     return aiocb;      if (!s->aiocb) {
           qemu_vfree(s->bounce);
           qemu_aio_release(s);
           return NULL;
       }
       return &s->common;
 }  }
   
 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,  BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
Line 1443  BlockDriverAIOCB *bdrv_aio_write(BlockDr Line 1463  BlockDriverAIOCB *bdrv_aio_write(BlockDr
   
 void bdrv_aio_cancel(BlockDriverAIOCB *acb)  void bdrv_aio_cancel(BlockDriverAIOCB *acb)
 {  {
     BlockDriver *drv = acb->bs->drv;      acb->pool->cancel(acb);
   
     if (acb->cb == bdrv_aio_rw_vector_cb) {  
         VectorTranslationState *s = acb->opaque;  
         acb = s->aiocb;  
     }  
   
     drv->bdrv_aio_cancel(acb);  
 }  }
   
   
Line 1551  static int bdrv_write_em(BlockDriverStat Line 1564  static int bdrv_write_em(BlockDriverStat
   
 void bdrv_init(void)  void bdrv_init(void)
 {  {
       aio_pool_init(&vectored_aio_pool, sizeof(VectorTranslationAIOCB),
                     bdrv_aio_cancel_vector);
   
     bdrv_register(&bdrv_raw);      bdrv_register(&bdrv_raw);
     bdrv_register(&bdrv_host_device);      bdrv_register(&bdrv_host_device);
 #ifndef _WIN32  #ifndef _WIN32
Line 1568  void bdrv_init(void) Line 1584  void bdrv_init(void)
     bdrv_register(&bdrv_nbd);      bdrv_register(&bdrv_nbd);
 }  }
   
 void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,  void aio_pool_init(AIOPool *pool, int aiocb_size,
                    void *opaque)                     void (*cancel)(BlockDriverAIOCB *acb))
   {
       pool->aiocb_size = aiocb_size;
       pool->cancel = cancel;
       pool->free_aiocb = NULL;
   }
   
   void *qemu_aio_get_pool(AIOPool *pool, BlockDriverState *bs,
                           BlockDriverCompletionFunc *cb, void *opaque)
 {  {
     BlockDriver *drv;  
     BlockDriverAIOCB *acb;      BlockDriverAIOCB *acb;
   
     drv = bs->drv;      if (pool->free_aiocb) {
     if (drv->free_aiocb) {          acb = pool->free_aiocb;
         acb = drv->free_aiocb;          pool->free_aiocb = acb->next;
         drv->free_aiocb = acb->next;  
     } else {      } else {
         acb = qemu_mallocz(drv->aiocb_size);          acb = qemu_mallocz(pool->aiocb_size);
           acb->pool = pool;
     }      }
     acb->bs = bs;      acb->bs = bs;
     acb->cb = cb;      acb->cb = cb;
Line 1587  void *qemu_aio_get(BlockDriverState *bs, Line 1610  void *qemu_aio_get(BlockDriverState *bs,
     return acb;      return acb;
 }  }
   
   void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,
                      void *opaque)
   {
       return qemu_aio_get_pool(&bs->drv->aio_pool, bs, cb, opaque);
   }
   
 void qemu_aio_release(void *p)  void qemu_aio_release(void *p)
 {  {
     BlockDriverAIOCB *acb = p;      BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
     BlockDriver *drv = acb->bs->drv;      AIOPool *pool = acb->pool;
     acb->next = drv->free_aiocb;      acb->next = pool->free_aiocb;
     drv->free_aiocb = acb;      pool->free_aiocb = acb;
 }  }
   
 /**************************************************************/  /**************************************************************/

Removed from v.1.1.1.9  
changed lines
  Added in v.1.1.1.12


unix.superglobalmegacorp.com