dma-helpers.c

   1 /*
   2  * DMA helper functions
   3  *
   4  * Copyright (c) 2009 Red Hat
   5  *
   6  * This work is licensed under the terms of the GNU General Public License
   7  * (GNU GPL), version 2 or later.
   8  */
   9
  10 #include "dma.h"
  11 #include "block_int.h"
  12 #include "trace.h"
  13
  14 void qemu_sglist_init(QEMUSGList *qsg, int alloc_hint)
  15 {
  16     qsg->sg = g_malloc(alloc_hint * sizeof(ScatterGatherEntry));
  17     qsg->nsg = 0;
  18     qsg->nalloc = alloc_hint;
  19     qsg->size = 0;
  20 }
  21
  22 void qemu_sglist_add(QEMUSGList *qsg, dma_addr_t base, dma_addr_t len)
  23 {
  24     if (qsg->nsg == qsg->nalloc) {
  25         qsg->nalloc = 2 * qsg->nalloc + 1;
  26         qsg->sg = g_realloc(qsg->sg, qsg->nalloc * sizeof(ScatterGatherEntry));
  27     }
  28     qsg->sg[qsg->nsg].base = base;
  29     qsg->sg[qsg->nsg].len = len;
  30     qsg->size += len;
  31     ++qsg->nsg;
  32 }
  33
  34 void qemu_sglist_destroy(QEMUSGList *qsg)
  35 {
  36     g_free(qsg->sg);
  37 }
  38
  39 typedef struct {
  40     BlockDriverAIOCB common;
  41     BlockDriverState *bs;
  42     BlockDriverAIOCB *acb;
  43     QEMUSGList *sg;
  44     uint64_t sector_num;
  45     bool to_dev;
  46     bool in_cancel;
  47     int sg_cur_index;
  48     dma_addr_t sg_cur_byte;
  49     QEMUIOVector iov;
  50     QEMUBH *bh;
  51     DMAIOFunc *io_func;
  52 } DMAAIOCB;
  53
  54 static void dma_bdrv_cb(void *opaque, int ret);
  55
  56 static void reschedule_dma(void *opaque)
  57 {
  58     DMAAIOCB *dbs = (DMAAIOCB *)opaque;
  59
  60     qemu_bh_delete(dbs->bh);
  61     dbs->bh = NULL;
  62     dma_bdrv_cb(dbs, 0);
  63 }
  64
  65 static void continue_after_map_failure(void *opaque)
  66 {
  67     DMAAIOCB *dbs = (DMAAIOCB *)opaque;
  68
  69     dbs->bh = qemu_bh_new(reschedule_dma, dbs);
  70     qemu_bh_schedule(dbs->bh);
  71 }
  72
  73 static void dma_bdrv_unmap(DMAAIOCB *dbs)
  74 {
  75     int i;
  76
  77     for (i = 0; i < dbs->iov.niov; ++i) {
  78         cpu_physical_memory_unmap(dbs->iov.iov[i].iov_base,
  79                                   dbs->iov.iov[i].iov_len, !dbs->to_dev,
  80                                   dbs->iov.iov[i].iov_len);
  81     }
  82     qemu_iovec_reset(&dbs->iov);
  83 }
  84
  85 static void dma_complete(DMAAIOCB *dbs, int ret)
  86 {
  87     trace_dma_complete(dbs, ret, dbs->common.cb);
  88
  89     dma_bdrv_unmap(dbs);
  90     if (dbs->common.cb) {
  91         dbs->common.cb(dbs->common.opaque, ret);
  92     }
  93     qemu_iovec_destroy(&dbs->iov);
  94     if (dbs->bh) {
  95         qemu_bh_delete(dbs->bh);
  96         dbs->bh = NULL;
  97     }
  98     if (!dbs->in_cancel) {
  99         /* Requests may complete while dma_aio_cancel is in progress.  In
 100          * this case, the AIOCB should not be released because it is still
 101          * referenced by dma_aio_cancel.  */
 102         qemu_aio_release(dbs);
 103     }
 104 }
 105
 106 static void dma_bdrv_cb(void *opaque, int ret)
 107 {
 108     DMAAIOCB *dbs = (DMAAIOCB *)opaque;
 109     target_phys_addr_t cur_addr, cur_len;
 110     void *mem;
 111
 112     trace_dma_bdrv_cb(dbs, ret);
 113
 114     dbs->acb = NULL;
 115     dbs->sector_num += dbs->iov.size / 512;
 116     dma_bdrv_unmap(dbs);
 117
 118     if (dbs->sg_cur_index == dbs->sg->nsg || ret < 0) {
 119         dma_complete(dbs, ret);
 120         return;
 121     }
 122
 123     while (dbs->sg_cur_index < dbs->sg->nsg) {
 124         cur_addr = dbs->sg->sg[dbs->sg_cur_index].base + dbs->sg_cur_byte;
 125         cur_len = dbs->sg->sg[dbs->sg_cur_index].len - dbs->sg_cur_byte;
 126         mem = cpu_physical_memory_map(cur_addr, &cur_len, !dbs->to_dev);
 127         if (!mem)
 128             break;
 129         qemu_iovec_add(&dbs->iov, mem, cur_len);
 130         dbs->sg_cur_byte += cur_len;
 131         if (dbs->sg_cur_byte == dbs->sg->sg[dbs->sg_cur_index].len) {
 132             dbs->sg_cur_byte = 0;
 133             ++dbs->sg_cur_index;
 134         }
 135     }
 136
 137     if (dbs->iov.size == 0) {
 138         trace_dma_map_wait(dbs);
 139         cpu_register_map_client(dbs, continue_after_map_failure);
 140         return;
 141     }
 142
 143     dbs->acb = dbs->io_func(dbs->bs, dbs->sector_num, &dbs->iov,
 144                             dbs->iov.size / 512, dma_bdrv_cb, dbs);
 145     if (!dbs->acb) {
 146         dma_complete(dbs, -EIO);
 147     }
 148 }
 149
 150 static void dma_aio_cancel(BlockDriverAIOCB *acb)
 151 {
 152     DMAAIOCB *dbs = container_of(acb, DMAAIOCB, common);
 153
 154     trace_dma_aio_cancel(dbs);
 155
 156     if (dbs->acb) {
 157         BlockDriverAIOCB *acb = dbs->acb;
 158         dbs->acb = NULL;
 159         dbs->in_cancel = true;
 160         bdrv_aio_cancel(acb);
 161         dbs->in_cancel = false;
 162     }
 163     dbs->common.cb = NULL;
 164     dma_complete(dbs, 0);
 165 }
 166
 167 static AIOPool dma_aio_pool = {
 168     .aiocb_size         = sizeof(DMAAIOCB),
 169     .cancel             = dma_aio_cancel,
 170 };
 171
 172 BlockDriverAIOCB *dma_bdrv_io(
 173     BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num,
 174     DMAIOFunc *io_func, BlockDriverCompletionFunc *cb,
 175     void *opaque, bool to_dev)
 176 {
 177     DMAAIOCB *dbs = qemu_aio_get(&dma_aio_pool, bs, cb, opaque);
 178
 179     trace_dma_bdrv_io(dbs, bs, sector_num, to_dev);
 180
 181     dbs->acb = NULL;
 182     dbs->bs = bs;
 183     dbs->sg = sg;
 184     dbs->sector_num = sector_num;
 185     dbs->sg_cur_index = 0;
 186     dbs->sg_cur_byte = 0;
 187     dbs->to_dev = to_dev;
 188     dbs->io_func = io_func;
 189     dbs->bh = NULL;
 190     qemu_iovec_init(&dbs->iov, sg->nsg);
 191     dma_bdrv_cb(dbs, 0);
 192     return &dbs->common;
 193 }
 194
 195
 196 BlockDriverAIOCB *dma_bdrv_read(BlockDriverState *bs,
 197                                 QEMUSGList *sg, uint64_t sector,
 198                                 void (*cb)(void *opaque, int ret), void *opaque)
 199 {
 200     return dma_bdrv_io(bs, sg, sector, bdrv_aio_readv, cb, opaque, false);
 201 }
 202
 203 BlockDriverAIOCB *dma_bdrv_write(BlockDriverState *bs,
 204                                  QEMUSGList *sg, uint64_t sector,
 205                                  void (*cb)(void *opaque, int ret), void *opaque)
 206 {
 207     return dma_bdrv_io(bs, sg, sector, bdrv_aio_writev, cb, opaque, true);
 208 }