]>
Commit | Line | Data |
---|---|---|
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 "trace.h" | |
12 | ||
13 | void qemu_sglist_init(QEMUSGList *qsg, int alloc_hint) | |
14 | { | |
15 | qsg->sg = g_malloc(alloc_hint * sizeof(ScatterGatherEntry)); | |
16 | qsg->nsg = 0; | |
17 | qsg->nalloc = alloc_hint; | |
18 | qsg->size = 0; | |
19 | } | |
20 | ||
21 | void qemu_sglist_add(QEMUSGList *qsg, dma_addr_t base, dma_addr_t len) | |
22 | { | |
23 | if (qsg->nsg == qsg->nalloc) { | |
24 | qsg->nalloc = 2 * qsg->nalloc + 1; | |
25 | qsg->sg = g_realloc(qsg->sg, qsg->nalloc * sizeof(ScatterGatherEntry)); | |
26 | } | |
27 | qsg->sg[qsg->nsg].base = base; | |
28 | qsg->sg[qsg->nsg].len = len; | |
29 | qsg->size += len; | |
30 | ++qsg->nsg; | |
31 | } | |
32 | ||
33 | void qemu_sglist_destroy(QEMUSGList *qsg) | |
34 | { | |
35 | g_free(qsg->sg); | |
36 | } | |
37 | ||
38 | typedef struct { | |
39 | BlockDriverAIOCB common; | |
40 | BlockDriverState *bs; | |
41 | BlockDriverAIOCB *acb; | |
42 | QEMUSGList *sg; | |
43 | uint64_t sector_num; | |
44 | DMADirection dir; | |
45 | bool in_cancel; | |
46 | int sg_cur_index; | |
47 | dma_addr_t sg_cur_byte; | |
48 | QEMUIOVector iov; | |
49 | QEMUBH *bh; | |
50 | DMAIOFunc *io_func; | |
51 | } DMAAIOCB; | |
52 | ||
53 | static void dma_bdrv_cb(void *opaque, int ret); | |
54 | ||
55 | static void reschedule_dma(void *opaque) | |
56 | { | |
57 | DMAAIOCB *dbs = (DMAAIOCB *)opaque; | |
58 | ||
59 | qemu_bh_delete(dbs->bh); | |
60 | dbs->bh = NULL; | |
61 | dma_bdrv_cb(dbs, 0); | |
62 | } | |
63 | ||
64 | static void continue_after_map_failure(void *opaque) | |
65 | { | |
66 | DMAAIOCB *dbs = (DMAAIOCB *)opaque; | |
67 | ||
68 | dbs->bh = qemu_bh_new(reschedule_dma, dbs); | |
69 | qemu_bh_schedule(dbs->bh); | |
70 | } | |
71 | ||
72 | static void dma_bdrv_unmap(DMAAIOCB *dbs) | |
73 | { | |
74 | int i; | |
75 | ||
76 | for (i = 0; i < dbs->iov.niov; ++i) { | |
77 | cpu_physical_memory_unmap(dbs->iov.iov[i].iov_base, | |
78 | dbs->iov.iov[i].iov_len, | |
79 | dbs->dir != DMA_DIRECTION_TO_DEVICE, | |
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, | |
127 | dbs->dir != DMA_DIRECTION_TO_DEVICE); | |
128 | if (!mem) | |
129 | break; | |
130 | qemu_iovec_add(&dbs->iov, mem, cur_len); | |
131 | dbs->sg_cur_byte += cur_len; | |
132 | if (dbs->sg_cur_byte == dbs->sg->sg[dbs->sg_cur_index].len) { | |
133 | dbs->sg_cur_byte = 0; | |
134 | ++dbs->sg_cur_index; | |
135 | } | |
136 | } | |
137 | ||
138 | if (dbs->iov.size == 0) { | |
139 | trace_dma_map_wait(dbs); | |
140 | cpu_register_map_client(dbs, continue_after_map_failure); | |
141 | return; | |
142 | } | |
143 | ||
144 | dbs->acb = dbs->io_func(dbs->bs, dbs->sector_num, &dbs->iov, | |
145 | dbs->iov.size / 512, dma_bdrv_cb, dbs); | |
146 | assert(dbs->acb); | |
147 | } | |
148 | ||
149 | static void dma_aio_cancel(BlockDriverAIOCB *acb) | |
150 | { | |
151 | DMAAIOCB *dbs = container_of(acb, DMAAIOCB, common); | |
152 | ||
153 | trace_dma_aio_cancel(dbs); | |
154 | ||
155 | if (dbs->acb) { | |
156 | BlockDriverAIOCB *acb = dbs->acb; | |
157 | dbs->acb = NULL; | |
158 | dbs->in_cancel = true; | |
159 | bdrv_aio_cancel(acb); | |
160 | dbs->in_cancel = false; | |
161 | } | |
162 | dbs->common.cb = NULL; | |
163 | dma_complete(dbs, 0); | |
164 | } | |
165 | ||
166 | static AIOPool dma_aio_pool = { | |
167 | .aiocb_size = sizeof(DMAAIOCB), | |
168 | .cancel = dma_aio_cancel, | |
169 | }; | |
170 | ||
171 | BlockDriverAIOCB *dma_bdrv_io( | |
172 | BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num, | |
173 | DMAIOFunc *io_func, BlockDriverCompletionFunc *cb, | |
174 | void *opaque, DMADirection dir) | |
175 | { | |
176 | DMAAIOCB *dbs = qemu_aio_get(&dma_aio_pool, bs, cb, opaque); | |
177 | ||
178 | trace_dma_bdrv_io(dbs, bs, sector_num, (dir == DMA_DIRECTION_TO_DEVICE)); | |
179 | ||
180 | dbs->acb = NULL; | |
181 | dbs->bs = bs; | |
182 | dbs->sg = sg; | |
183 | dbs->sector_num = sector_num; | |
184 | dbs->sg_cur_index = 0; | |
185 | dbs->sg_cur_byte = 0; | |
186 | dbs->dir = dir; | |
187 | dbs->io_func = io_func; | |
188 | dbs->bh = NULL; | |
189 | qemu_iovec_init(&dbs->iov, sg->nsg); | |
190 | dma_bdrv_cb(dbs, 0); | |
191 | return &dbs->common; | |
192 | } | |
193 | ||
194 | ||
195 | BlockDriverAIOCB *dma_bdrv_read(BlockDriverState *bs, | |
196 | QEMUSGList *sg, uint64_t sector, | |
197 | void (*cb)(void *opaque, int ret), void *opaque) | |
198 | { | |
199 | return dma_bdrv_io(bs, sg, sector, bdrv_aio_readv, cb, opaque, | |
200 | DMA_DIRECTION_FROM_DEVICE); | |
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, | |
208 | DMA_DIRECTION_TO_DEVICE); | |
209 | } | |
210 | ||
211 | ||
212 | static uint64_t dma_buf_rw(uint8_t *ptr, int32_t len, QEMUSGList *sg, bool to_dev) | |
213 | { | |
214 | uint64_t resid; | |
215 | int sg_cur_index; | |
216 | ||
217 | resid = sg->size; | |
218 | sg_cur_index = 0; | |
219 | len = MIN(len, resid); | |
220 | while (len > 0) { | |
221 | ScatterGatherEntry entry = sg->sg[sg_cur_index++]; | |
222 | int32_t xfer = MIN(len, entry.len); | |
223 | cpu_physical_memory_rw(entry.base, ptr, xfer, !to_dev); | |
224 | ptr += xfer; | |
225 | len -= xfer; | |
226 | resid -= xfer; | |
227 | } | |
228 | ||
229 | return resid; | |
230 | } | |
231 | ||
232 | uint64_t dma_buf_read(uint8_t *ptr, int32_t len, QEMUSGList *sg) | |
233 | { | |
234 | return dma_buf_rw(ptr, len, sg, 0); | |
235 | } | |
236 | ||
237 | uint64_t dma_buf_write(uint8_t *ptr, int32_t len, QEMUSGList *sg) | |
238 | { | |
239 | return dma_buf_rw(ptr, len, sg, 1); | |
240 | } | |
241 | ||
242 | void dma_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, | |
243 | QEMUSGList *sg, enum BlockAcctType type) | |
244 | { | |
245 | bdrv_acct_start(bs, cookie, sg->size, type); | |
246 | } |