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

version 1.1.1.11, 2018/04/24 17:11:49 version 1.1.1.12, 2018/04/24 17:16:37
Line 1332  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)  static void bdrv_aio_cancel_vector(BlockDriverAIOCB *_acb)
 {  {
     VectorTranslationState *s = acb->opaque;      VectorTranslationAIOCB *acb
           = container_of(_acb, VectorTranslationAIOCB, common);
   
     bdrv_aio_cancel(s->aiocb);      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 1368  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_pool(&vectored_aio_pool, 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 1384  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 1560  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(BlockDriverAIOCB),      aio_pool_init(&vectored_aio_pool, sizeof(VectorTranslationAIOCB),
                   bdrv_aio_cancel_vector);                    bdrv_aio_cancel_vector);
   
     bdrv_register(&bdrv_raw);      bdrv_register(&bdrv_raw);

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


unix.superglobalmegacorp.com