Diff for /qemu/dma-helpers.c between versions 1.1.1.5 and 1.1.1.6

version 1.1.1.5, 2018/04/24 18:56:40 version 1.1.1.6, 2018/04/24 19:17:48
Line 12 Line 12
   
 void qemu_sglist_init(QEMUSGList *qsg, int alloc_hint)  void qemu_sglist_init(QEMUSGList *qsg, int alloc_hint)
 {  {
     qsg->sg = qemu_malloc(alloc_hint * sizeof(ScatterGatherEntry));      qsg->sg = g_malloc(alloc_hint * sizeof(ScatterGatherEntry));
     qsg->nsg = 0;      qsg->nsg = 0;
     qsg->nalloc = alloc_hint;      qsg->nalloc = alloc_hint;
     qsg->size = 0;      qsg->size = 0;
 }  }
   
 void qemu_sglist_add(QEMUSGList *qsg, target_phys_addr_t base,  void qemu_sglist_add(QEMUSGList *qsg, dma_addr_t base, dma_addr_t len)
                      target_phys_addr_t len)  
 {  {
     if (qsg->nsg == qsg->nalloc) {      if (qsg->nsg == qsg->nalloc) {
         qsg->nalloc = 2 * qsg->nalloc + 1;          qsg->nalloc = 2 * qsg->nalloc + 1;
         qsg->sg = qemu_realloc(qsg->sg, qsg->nalloc * sizeof(ScatterGatherEntry));          qsg->sg = g_realloc(qsg->sg, qsg->nalloc * sizeof(ScatterGatherEntry));
     }      }
     qsg->sg[qsg->nsg].base = base;      qsg->sg[qsg->nsg].base = base;
     qsg->sg[qsg->nsg].len = len;      qsg->sg[qsg->nsg].len = len;
Line 33  void qemu_sglist_add(QEMUSGList *qsg, ta Line 32  void qemu_sglist_add(QEMUSGList *qsg, ta
   
 void qemu_sglist_destroy(QEMUSGList *qsg)  void qemu_sglist_destroy(QEMUSGList *qsg)
 {  {
     qemu_free(qsg->sg);      g_free(qsg->sg);
 }  }
   
 typedef struct {  typedef struct {
Line 42  typedef struct { Line 41  typedef struct {
     BlockDriverAIOCB *acb;      BlockDriverAIOCB *acb;
     QEMUSGList *sg;      QEMUSGList *sg;
     uint64_t sector_num;      uint64_t sector_num;
     int is_write;      bool to_dev;
       bool in_cancel;
     int sg_cur_index;      int sg_cur_index;
     target_phys_addr_t sg_cur_byte;      dma_addr_t sg_cur_byte;
     QEMUIOVector iov;      QEMUIOVector iov;
     QEMUBH *bh;      QEMUBH *bh;
     DMAIOFunc *io_func;      DMAIOFunc *io_func;
Line 58  static void reschedule_dma(void *opaque) Line 58  static void reschedule_dma(void *opaque)
   
     qemu_bh_delete(dbs->bh);      qemu_bh_delete(dbs->bh);
     dbs->bh = NULL;      dbs->bh = NULL;
     dma_bdrv_cb(opaque, 0);      dma_bdrv_cb(dbs, 0);
 }  }
   
 static void continue_after_map_failure(void *opaque)  static void continue_after_map_failure(void *opaque)
Line 75  static void dma_bdrv_unmap(DMAAIOCB *dbs Line 75  static void dma_bdrv_unmap(DMAAIOCB *dbs
   
     for (i = 0; i < dbs->iov.niov; ++i) {      for (i = 0; i < dbs->iov.niov; ++i) {
         cpu_physical_memory_unmap(dbs->iov.iov[i].iov_base,          cpu_physical_memory_unmap(dbs->iov.iov[i].iov_base,
                                   dbs->iov.iov[i].iov_len, !dbs->is_write,                                    dbs->iov.iov[i].iov_len, !dbs->to_dev,
                                   dbs->iov.iov[i].iov_len);                                    dbs->iov.iov[i].iov_len);
     }      }
       qemu_iovec_reset(&dbs->iov);
   }
   
   static void dma_complete(DMAAIOCB *dbs, int ret)
   {
       dma_bdrv_unmap(dbs);
       if (dbs->common.cb) {
           dbs->common.cb(dbs->common.opaque, ret);
       }
       qemu_iovec_destroy(&dbs->iov);
       if (dbs->bh) {
           qemu_bh_delete(dbs->bh);
           dbs->bh = NULL;
       }
       if (!dbs->in_cancel) {
           /* Requests may complete while dma_aio_cancel is in progress.  In
            * this case, the AIOCB should not be released because it is still
            * referenced by dma_aio_cancel.  */
           qemu_aio_release(dbs);
       }
 }  }
   
 static void dma_bdrv_cb(void *opaque, int ret)  static void dma_bdrv_cb(void *opaque, int ret)
Line 89  static void dma_bdrv_cb(void *opaque, in Line 109  static void dma_bdrv_cb(void *opaque, in
     dbs->acb = NULL;      dbs->acb = NULL;
     dbs->sector_num += dbs->iov.size / 512;      dbs->sector_num += dbs->iov.size / 512;
     dma_bdrv_unmap(dbs);      dma_bdrv_unmap(dbs);
     qemu_iovec_reset(&dbs->iov);  
   
     if (dbs->sg_cur_index == dbs->sg->nsg || ret < 0) {      if (dbs->sg_cur_index == dbs->sg->nsg || ret < 0) {
         dbs->common.cb(dbs->common.opaque, ret);          dma_complete(dbs, ret);
         qemu_iovec_destroy(&dbs->iov);  
         qemu_aio_release(dbs);  
         return;          return;
     }      }
   
     while (dbs->sg_cur_index < dbs->sg->nsg) {      while (dbs->sg_cur_index < dbs->sg->nsg) {
         cur_addr = dbs->sg->sg[dbs->sg_cur_index].base + dbs->sg_cur_byte;          cur_addr = dbs->sg->sg[dbs->sg_cur_index].base + dbs->sg_cur_byte;
         cur_len = dbs->sg->sg[dbs->sg_cur_index].len - dbs->sg_cur_byte;          cur_len = dbs->sg->sg[dbs->sg_cur_index].len - dbs->sg_cur_byte;
         mem = cpu_physical_memory_map(cur_addr, &cur_len, !dbs->is_write);          mem = cpu_physical_memory_map(cur_addr, &cur_len, !dbs->to_dev);
         if (!mem)          if (!mem)
             break;              break;
         qemu_iovec_add(&dbs->iov, mem, cur_len);          qemu_iovec_add(&dbs->iov, mem, cur_len);
Line 120  static void dma_bdrv_cb(void *opaque, in Line 137  static void dma_bdrv_cb(void *opaque, in
     dbs->acb = dbs->io_func(dbs->bs, dbs->sector_num, &dbs->iov,      dbs->acb = dbs->io_func(dbs->bs, dbs->sector_num, &dbs->iov,
                             dbs->iov.size / 512, dma_bdrv_cb, dbs);                              dbs->iov.size / 512, dma_bdrv_cb, dbs);
     if (!dbs->acb) {      if (!dbs->acb) {
         dma_bdrv_unmap(dbs);          dma_complete(dbs, -EIO);
         qemu_iovec_destroy(&dbs->iov);  
         return;  
     }      }
 }  }
   
Line 131  static void dma_aio_cancel(BlockDriverAI Line 146  static void dma_aio_cancel(BlockDriverAI
     DMAAIOCB *dbs = container_of(acb, DMAAIOCB, common);      DMAAIOCB *dbs = container_of(acb, DMAAIOCB, common);
   
     if (dbs->acb) {      if (dbs->acb) {
         bdrv_aio_cancel(dbs->acb);          BlockDriverAIOCB *acb = dbs->acb;
           dbs->acb = NULL;
           dbs->in_cancel = true;
           bdrv_aio_cancel(acb);
           dbs->in_cancel = false;
     }      }
       dbs->common.cb = NULL;
       dma_complete(dbs, 0);
 }  }
   
 static AIOPool dma_aio_pool = {  static AIOPool dma_aio_pool = {
Line 143  static AIOPool dma_aio_pool = { Line 164  static AIOPool dma_aio_pool = {
 BlockDriverAIOCB *dma_bdrv_io(  BlockDriverAIOCB *dma_bdrv_io(
     BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num,      BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num,
     DMAIOFunc *io_func, BlockDriverCompletionFunc *cb,      DMAIOFunc *io_func, BlockDriverCompletionFunc *cb,
     void *opaque, int is_write)      void *opaque, bool to_dev)
 {  {
     DMAAIOCB *dbs = qemu_aio_get(&dma_aio_pool, bs, cb, opaque);      DMAAIOCB *dbs = qemu_aio_get(&dma_aio_pool, bs, cb, opaque);
   
Line 153  BlockDriverAIOCB *dma_bdrv_io( Line 174  BlockDriverAIOCB *dma_bdrv_io(
     dbs->sector_num = sector_num;      dbs->sector_num = sector_num;
     dbs->sg_cur_index = 0;      dbs->sg_cur_index = 0;
     dbs->sg_cur_byte = 0;      dbs->sg_cur_byte = 0;
     dbs->is_write = is_write;      dbs->to_dev = to_dev;
     dbs->io_func = io_func;      dbs->io_func = io_func;
     dbs->bh = NULL;      dbs->bh = NULL;
     qemu_iovec_init(&dbs->iov, sg->nsg);      qemu_iovec_init(&dbs->iov, sg->nsg);
     dma_bdrv_cb(dbs, 0);      dma_bdrv_cb(dbs, 0);
     if (!dbs->acb) {  
         qemu_aio_release(dbs);  
         return NULL;  
     }  
     return &dbs->common;      return &dbs->common;
 }  }
   
Line 170  BlockDriverAIOCB *dma_bdrv_read(BlockDri Line 187  BlockDriverAIOCB *dma_bdrv_read(BlockDri
                                 QEMUSGList *sg, uint64_t sector,                                  QEMUSGList *sg, uint64_t sector,
                                 void (*cb)(void *opaque, int ret), void *opaque)                                  void (*cb)(void *opaque, int ret), void *opaque)
 {  {
     return dma_bdrv_io(bs, sg, sector, bdrv_aio_readv, cb, opaque, 0);      return dma_bdrv_io(bs, sg, sector, bdrv_aio_readv, cb, opaque, false);
 }  }
   
 BlockDriverAIOCB *dma_bdrv_write(BlockDriverState *bs,  BlockDriverAIOCB *dma_bdrv_write(BlockDriverState *bs,
                                  QEMUSGList *sg, uint64_t sector,                                   QEMUSGList *sg, uint64_t sector,
                                  void (*cb)(void *opaque, int ret), void *opaque)                                   void (*cb)(void *opaque, int ret), void *opaque)
 {  {
     return dma_bdrv_io(bs, sg, sector, bdrv_aio_writev, cb, opaque, 1);      return dma_bdrv_io(bs, sg, sector, bdrv_aio_writev, cb, opaque, true);
 }  }

Removed from v.1.1.1.5  
changed lines
  Added in v.1.1.1.6


unix.superglobalmegacorp.com