]>
Commit | Line | Data |
---|---|---|
62d23efa AL |
1 | /* |
2 | * xen paravirt block device backend | |
3 | * | |
4 | * (c) Gerd Hoffmann <kraxel@redhat.com> | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; under version 2 of the License. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License along | |
8167ee88 | 16 | * with this program; if not, see <http://www.gnu.org/licenses/>. |
62d23efa AL |
17 | */ |
18 | ||
19 | #include <stdio.h> | |
20 | #include <stdlib.h> | |
21 | #include <stdarg.h> | |
22 | #include <string.h> | |
23 | #include <unistd.h> | |
24 | #include <signal.h> | |
25 | #include <inttypes.h> | |
26 | #include <time.h> | |
27 | #include <fcntl.h> | |
28 | #include <errno.h> | |
29 | #include <sys/ioctl.h> | |
30 | #include <sys/types.h> | |
31 | #include <sys/stat.h> | |
32 | #include <sys/mman.h> | |
33 | #include <sys/uio.h> | |
34 | ||
35 | #include <xs.h> | |
36 | #include <xenctrl.h> | |
37 | #include <xen/io/xenbus.h> | |
38 | ||
39 | #include "hw.h" | |
40 | #include "block_int.h" | |
41 | #include "qemu-char.h" | |
42 | #include "xen_blkif.h" | |
43 | #include "xen_backend.h" | |
2446333c | 44 | #include "blockdev.h" |
62d23efa AL |
45 | |
46 | /* ------------------------------------------------------------- */ | |
47 | ||
48 | static int syncwrite = 0; | |
49 | static int batch_maps = 0; | |
50 | ||
51 | static int max_requests = 32; | |
52 | static int use_aio = 1; | |
53 | ||
54 | /* ------------------------------------------------------------- */ | |
55 | ||
56 | #define BLOCK_SIZE 512 | |
57 | #define IOCB_COUNT (BLKIF_MAX_SEGMENTS_PER_REQUEST + 2) | |
58 | ||
59 | struct ioreq { | |
60 | blkif_request_t req; | |
61 | int16_t status; | |
62 | ||
63 | /* parsed request */ | |
64 | off_t start; | |
65 | QEMUIOVector v; | |
66 | int presync; | |
67 | int postsync; | |
68 | ||
69 | /* grant mapping */ | |
70 | uint32_t domids[BLKIF_MAX_SEGMENTS_PER_REQUEST]; | |
71 | uint32_t refs[BLKIF_MAX_SEGMENTS_PER_REQUEST]; | |
72 | int prot; | |
73 | void *page[BLKIF_MAX_SEGMENTS_PER_REQUEST]; | |
74 | void *pages; | |
75 | ||
76 | /* aio status */ | |
77 | int aio_inflight; | |
78 | int aio_errors; | |
79 | ||
80 | struct XenBlkDev *blkdev; | |
72cf2d4f | 81 | QLIST_ENTRY(ioreq) list; |
62d23efa AL |
82 | }; |
83 | ||
84 | struct XenBlkDev { | |
85 | struct XenDevice xendev; /* must be first */ | |
86 | char *params; | |
87 | char *mode; | |
88 | char *type; | |
89 | char *dev; | |
90 | char *devtype; | |
91 | const char *fileproto; | |
92 | const char *filename; | |
93 | int ring_ref; | |
94 | void *sring; | |
95 | int64_t file_blk; | |
96 | int64_t file_size; | |
97 | int protocol; | |
98 | blkif_back_rings_t rings; | |
99 | int more_work; | |
100 | int cnt_map; | |
101 | ||
102 | /* request lists */ | |
72cf2d4f BS |
103 | QLIST_HEAD(inflight_head, ioreq) inflight; |
104 | QLIST_HEAD(finished_head, ioreq) finished; | |
105 | QLIST_HEAD(freelist_head, ioreq) freelist; | |
62d23efa AL |
106 | int requests_total; |
107 | int requests_inflight; | |
108 | int requests_finished; | |
109 | ||
110 | /* qemu block driver */ | |
751c6a17 | 111 | DriveInfo *dinfo; |
62d23efa AL |
112 | BlockDriverState *bs; |
113 | QEMUBH *bh; | |
114 | }; | |
115 | ||
116 | /* ------------------------------------------------------------- */ | |
117 | ||
118 | static struct ioreq *ioreq_start(struct XenBlkDev *blkdev) | |
119 | { | |
120 | struct ioreq *ioreq = NULL; | |
121 | ||
72cf2d4f | 122 | if (QLIST_EMPTY(&blkdev->freelist)) { |
62d23efa AL |
123 | if (blkdev->requests_total >= max_requests) |
124 | goto out; | |
125 | /* allocate new struct */ | |
126 | ioreq = qemu_mallocz(sizeof(*ioreq)); | |
127 | ioreq->blkdev = blkdev; | |
128 | blkdev->requests_total++; | |
129 | qemu_iovec_init(&ioreq->v, BLKIF_MAX_SEGMENTS_PER_REQUEST); | |
130 | } else { | |
131 | /* get one from freelist */ | |
72cf2d4f BS |
132 | ioreq = QLIST_FIRST(&blkdev->freelist); |
133 | QLIST_REMOVE(ioreq, list); | |
62d23efa AL |
134 | qemu_iovec_reset(&ioreq->v); |
135 | } | |
72cf2d4f | 136 | QLIST_INSERT_HEAD(&blkdev->inflight, ioreq, list); |
62d23efa AL |
137 | blkdev->requests_inflight++; |
138 | ||
139 | out: | |
140 | return ioreq; | |
141 | } | |
142 | ||
143 | static void ioreq_finish(struct ioreq *ioreq) | |
144 | { | |
145 | struct XenBlkDev *blkdev = ioreq->blkdev; | |
146 | ||
72cf2d4f BS |
147 | QLIST_REMOVE(ioreq, list); |
148 | QLIST_INSERT_HEAD(&blkdev->finished, ioreq, list); | |
62d23efa AL |
149 | blkdev->requests_inflight--; |
150 | blkdev->requests_finished++; | |
151 | } | |
152 | ||
153 | static void ioreq_release(struct ioreq *ioreq) | |
154 | { | |
155 | struct XenBlkDev *blkdev = ioreq->blkdev; | |
156 | ||
72cf2d4f | 157 | QLIST_REMOVE(ioreq, list); |
62d23efa AL |
158 | memset(ioreq, 0, sizeof(*ioreq)); |
159 | ioreq->blkdev = blkdev; | |
72cf2d4f | 160 | QLIST_INSERT_HEAD(&blkdev->freelist, ioreq, list); |
62d23efa AL |
161 | blkdev->requests_finished--; |
162 | } | |
163 | ||
164 | /* | |
165 | * translate request into iovec + start offset | |
166 | * do sanity checks along the way | |
167 | */ | |
168 | static int ioreq_parse(struct ioreq *ioreq) | |
169 | { | |
170 | struct XenBlkDev *blkdev = ioreq->blkdev; | |
171 | uintptr_t mem; | |
172 | size_t len; | |
173 | int i; | |
174 | ||
175 | xen_be_printf(&blkdev->xendev, 3, | |
176 | "op %d, nr %d, handle %d, id %" PRId64 ", sector %" PRId64 "\n", | |
177 | ioreq->req.operation, ioreq->req.nr_segments, | |
178 | ioreq->req.handle, ioreq->req.id, ioreq->req.sector_number); | |
179 | switch (ioreq->req.operation) { | |
180 | case BLKIF_OP_READ: | |
181 | ioreq->prot = PROT_WRITE; /* to memory */ | |
62d23efa AL |
182 | break; |
183 | case BLKIF_OP_WRITE_BARRIER: | |
5cbdebe3 SS |
184 | if (!ioreq->req.nr_segments) { |
185 | ioreq->presync = 1; | |
186 | return 0; | |
187 | } | |
62d23efa AL |
188 | if (!syncwrite) |
189 | ioreq->presync = ioreq->postsync = 1; | |
190 | /* fall through */ | |
191 | case BLKIF_OP_WRITE: | |
192 | ioreq->prot = PROT_READ; /* from memory */ | |
193 | if (syncwrite) | |
194 | ioreq->postsync = 1; | |
195 | break; | |
196 | default: | |
197 | xen_be_printf(&blkdev->xendev, 0, "error: unknown operation (%d)\n", | |
198 | ioreq->req.operation); | |
199 | goto err; | |
200 | }; | |
201 | ||
908c7b9f GH |
202 | if (ioreq->req.operation != BLKIF_OP_READ && blkdev->mode[0] != 'w') { |
203 | xen_be_printf(&blkdev->xendev, 0, "error: write req for ro device\n"); | |
204 | goto err; | |
205 | } | |
206 | ||
62d23efa AL |
207 | ioreq->start = ioreq->req.sector_number * blkdev->file_blk; |
208 | for (i = 0; i < ioreq->req.nr_segments; i++) { | |
209 | if (i == BLKIF_MAX_SEGMENTS_PER_REQUEST) { | |
210 | xen_be_printf(&blkdev->xendev, 0, "error: nr_segments too big\n"); | |
211 | goto err; | |
212 | } | |
213 | if (ioreq->req.seg[i].first_sect > ioreq->req.seg[i].last_sect) { | |
214 | xen_be_printf(&blkdev->xendev, 0, "error: first > last sector\n"); | |
215 | goto err; | |
216 | } | |
217 | if (ioreq->req.seg[i].last_sect * BLOCK_SIZE >= XC_PAGE_SIZE) { | |
218 | xen_be_printf(&blkdev->xendev, 0, "error: page crossing\n"); | |
219 | goto err; | |
220 | } | |
221 | ||
222 | ioreq->domids[i] = blkdev->xendev.dom; | |
223 | ioreq->refs[i] = ioreq->req.seg[i].gref; | |
224 | ||
225 | mem = ioreq->req.seg[i].first_sect * blkdev->file_blk; | |
226 | len = (ioreq->req.seg[i].last_sect - ioreq->req.seg[i].first_sect + 1) * blkdev->file_blk; | |
227 | qemu_iovec_add(&ioreq->v, (void*)mem, len); | |
228 | } | |
229 | if (ioreq->start + ioreq->v.size > blkdev->file_size) { | |
230 | xen_be_printf(&blkdev->xendev, 0, "error: access beyond end of file\n"); | |
231 | goto err; | |
232 | } | |
233 | return 0; | |
234 | ||
235 | err: | |
236 | ioreq->status = BLKIF_RSP_ERROR; | |
237 | return -1; | |
238 | } | |
239 | ||
240 | static void ioreq_unmap(struct ioreq *ioreq) | |
241 | { | |
242 | int gnt = ioreq->blkdev->xendev.gnttabdev; | |
243 | int i; | |
244 | ||
245 | if (ioreq->v.niov == 0) | |
246 | return; | |
247 | if (batch_maps) { | |
248 | if (!ioreq->pages) | |
249 | return; | |
250 | if (xc_gnttab_munmap(gnt, ioreq->pages, ioreq->v.niov) != 0) | |
251 | xen_be_printf(&ioreq->blkdev->xendev, 0, "xc_gnttab_munmap failed: %s\n", | |
252 | strerror(errno)); | |
253 | ioreq->blkdev->cnt_map -= ioreq->v.niov; | |
254 | ioreq->pages = NULL; | |
255 | } else { | |
256 | for (i = 0; i < ioreq->v.niov; i++) { | |
257 | if (!ioreq->page[i]) | |
258 | continue; | |
259 | if (xc_gnttab_munmap(gnt, ioreq->page[i], 1) != 0) | |
260 | xen_be_printf(&ioreq->blkdev->xendev, 0, "xc_gnttab_munmap failed: %s\n", | |
261 | strerror(errno)); | |
262 | ioreq->blkdev->cnt_map--; | |
263 | ioreq->page[i] = NULL; | |
264 | } | |
265 | } | |
266 | } | |
267 | ||
268 | static int ioreq_map(struct ioreq *ioreq) | |
269 | { | |
270 | int gnt = ioreq->blkdev->xendev.gnttabdev; | |
271 | int i; | |
272 | ||
273 | if (ioreq->v.niov == 0) | |
274 | return 0; | |
275 | if (batch_maps) { | |
276 | ioreq->pages = xc_gnttab_map_grant_refs | |
277 | (gnt, ioreq->v.niov, ioreq->domids, ioreq->refs, ioreq->prot); | |
278 | if (ioreq->pages == NULL) { | |
279 | xen_be_printf(&ioreq->blkdev->xendev, 0, | |
280 | "can't map %d grant refs (%s, %d maps)\n", | |
281 | ioreq->v.niov, strerror(errno), ioreq->blkdev->cnt_map); | |
282 | return -1; | |
283 | } | |
284 | for (i = 0; i < ioreq->v.niov; i++) | |
285 | ioreq->v.iov[i].iov_base = ioreq->pages + i * XC_PAGE_SIZE + | |
286 | (uintptr_t)ioreq->v.iov[i].iov_base; | |
287 | ioreq->blkdev->cnt_map += ioreq->v.niov; | |
288 | } else { | |
289 | for (i = 0; i < ioreq->v.niov; i++) { | |
290 | ioreq->page[i] = xc_gnttab_map_grant_ref | |
291 | (gnt, ioreq->domids[i], ioreq->refs[i], ioreq->prot); | |
292 | if (ioreq->page[i] == NULL) { | |
293 | xen_be_printf(&ioreq->blkdev->xendev, 0, | |
294 | "can't map grant ref %d (%s, %d maps)\n", | |
295 | ioreq->refs[i], strerror(errno), ioreq->blkdev->cnt_map); | |
296 | ioreq_unmap(ioreq); | |
297 | return -1; | |
298 | } | |
299 | ioreq->v.iov[i].iov_base = ioreq->page[i] + (uintptr_t)ioreq->v.iov[i].iov_base; | |
300 | ioreq->blkdev->cnt_map++; | |
301 | } | |
302 | } | |
303 | return 0; | |
304 | } | |
305 | ||
306 | static int ioreq_runio_qemu_sync(struct ioreq *ioreq) | |
307 | { | |
308 | struct XenBlkDev *blkdev = ioreq->blkdev; | |
309 | int i, rc, len = 0; | |
310 | off_t pos; | |
311 | ||
5cbdebe3 | 312 | if (ioreq->req.nr_segments && ioreq_map(ioreq) == -1) |
62d23efa AL |
313 | goto err; |
314 | if (ioreq->presync) | |
315 | bdrv_flush(blkdev->bs); | |
316 | ||
317 | switch (ioreq->req.operation) { | |
318 | case BLKIF_OP_READ: | |
319 | pos = ioreq->start; | |
320 | for (i = 0; i < ioreq->v.niov; i++) { | |
321 | rc = bdrv_read(blkdev->bs, pos / BLOCK_SIZE, | |
322 | ioreq->v.iov[i].iov_base, | |
323 | ioreq->v.iov[i].iov_len / BLOCK_SIZE); | |
324 | if (rc != 0) { | |
325 | xen_be_printf(&blkdev->xendev, 0, "rd I/O error (%p, len %zd)\n", | |
326 | ioreq->v.iov[i].iov_base, | |
327 | ioreq->v.iov[i].iov_len); | |
328 | goto err; | |
329 | } | |
330 | len += ioreq->v.iov[i].iov_len; | |
331 | pos += ioreq->v.iov[i].iov_len; | |
332 | } | |
333 | break; | |
334 | case BLKIF_OP_WRITE: | |
335 | case BLKIF_OP_WRITE_BARRIER: | |
5cbdebe3 SS |
336 | if (!ioreq->req.nr_segments) |
337 | break; | |
62d23efa AL |
338 | pos = ioreq->start; |
339 | for (i = 0; i < ioreq->v.niov; i++) { | |
340 | rc = bdrv_write(blkdev->bs, pos / BLOCK_SIZE, | |
341 | ioreq->v.iov[i].iov_base, | |
342 | ioreq->v.iov[i].iov_len / BLOCK_SIZE); | |
343 | if (rc != 0) { | |
344 | xen_be_printf(&blkdev->xendev, 0, "wr I/O error (%p, len %zd)\n", | |
345 | ioreq->v.iov[i].iov_base, | |
346 | ioreq->v.iov[i].iov_len); | |
347 | goto err; | |
348 | } | |
349 | len += ioreq->v.iov[i].iov_len; | |
350 | pos += ioreq->v.iov[i].iov_len; | |
351 | } | |
352 | break; | |
353 | default: | |
354 | /* unknown operation (shouldn't happen -- parse catches this) */ | |
355 | goto err; | |
356 | } | |
357 | ||
358 | if (ioreq->postsync) | |
359 | bdrv_flush(blkdev->bs); | |
360 | ioreq->status = BLKIF_RSP_OKAY; | |
361 | ||
362 | ioreq_unmap(ioreq); | |
363 | ioreq_finish(ioreq); | |
364 | return 0; | |
365 | ||
366 | err: | |
367 | ioreq->status = BLKIF_RSP_ERROR; | |
368 | return -1; | |
369 | } | |
370 | ||
371 | static void qemu_aio_complete(void *opaque, int ret) | |
372 | { | |
373 | struct ioreq *ioreq = opaque; | |
374 | ||
375 | if (ret != 0) { | |
376 | xen_be_printf(&ioreq->blkdev->xendev, 0, "%s I/O error\n", | |
377 | ioreq->req.operation == BLKIF_OP_READ ? "read" : "write"); | |
378 | ioreq->aio_errors++; | |
379 | } | |
380 | ||
381 | ioreq->aio_inflight--; | |
382 | if (ioreq->aio_inflight > 0) | |
383 | return; | |
384 | ||
385 | ioreq->status = ioreq->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY; | |
386 | ioreq_unmap(ioreq); | |
387 | ioreq_finish(ioreq); | |
388 | qemu_bh_schedule(ioreq->blkdev->bh); | |
389 | } | |
390 | ||
391 | static int ioreq_runio_qemu_aio(struct ioreq *ioreq) | |
392 | { | |
393 | struct XenBlkDev *blkdev = ioreq->blkdev; | |
394 | ||
5cbdebe3 | 395 | if (ioreq->req.nr_segments && ioreq_map(ioreq) == -1) |
62d23efa AL |
396 | goto err; |
397 | ||
398 | ioreq->aio_inflight++; | |
399 | if (ioreq->presync) | |
400 | bdrv_flush(blkdev->bs); /* FIXME: aio_flush() ??? */ | |
401 | ||
402 | switch (ioreq->req.operation) { | |
403 | case BLKIF_OP_READ: | |
404 | ioreq->aio_inflight++; | |
405 | bdrv_aio_readv(blkdev->bs, ioreq->start / BLOCK_SIZE, | |
406 | &ioreq->v, ioreq->v.size / BLOCK_SIZE, | |
407 | qemu_aio_complete, ioreq); | |
408 | break; | |
409 | case BLKIF_OP_WRITE: | |
410 | case BLKIF_OP_WRITE_BARRIER: | |
411 | ioreq->aio_inflight++; | |
5cbdebe3 SS |
412 | if (!ioreq->req.nr_segments) |
413 | break; | |
62d23efa AL |
414 | bdrv_aio_writev(blkdev->bs, ioreq->start / BLOCK_SIZE, |
415 | &ioreq->v, ioreq->v.size / BLOCK_SIZE, | |
416 | qemu_aio_complete, ioreq); | |
417 | break; | |
418 | default: | |
419 | /* unknown operation (shouldn't happen -- parse catches this) */ | |
420 | goto err; | |
421 | } | |
422 | ||
423 | if (ioreq->postsync) | |
424 | bdrv_flush(blkdev->bs); /* FIXME: aio_flush() ??? */ | |
425 | qemu_aio_complete(ioreq, 0); | |
426 | ||
427 | return 0; | |
428 | ||
429 | err: | |
430 | ioreq->status = BLKIF_RSP_ERROR; | |
431 | return -1; | |
432 | } | |
433 | ||
434 | static int blk_send_response_one(struct ioreq *ioreq) | |
435 | { | |
436 | struct XenBlkDev *blkdev = ioreq->blkdev; | |
437 | int send_notify = 0; | |
438 | int have_requests = 0; | |
439 | blkif_response_t resp; | |
440 | void *dst; | |
441 | ||
442 | resp.id = ioreq->req.id; | |
443 | resp.operation = ioreq->req.operation; | |
444 | resp.status = ioreq->status; | |
445 | ||
446 | /* Place on the response ring for the relevant domain. */ | |
447 | switch (blkdev->protocol) { | |
448 | case BLKIF_PROTOCOL_NATIVE: | |
449 | dst = RING_GET_RESPONSE(&blkdev->rings.native, blkdev->rings.native.rsp_prod_pvt); | |
450 | break; | |
451 | case BLKIF_PROTOCOL_X86_32: | |
6fcfeff9 BS |
452 | dst = RING_GET_RESPONSE(&blkdev->rings.x86_32_part, |
453 | blkdev->rings.x86_32_part.rsp_prod_pvt); | |
62d23efa AL |
454 | break; |
455 | case BLKIF_PROTOCOL_X86_64: | |
6fcfeff9 BS |
456 | dst = RING_GET_RESPONSE(&blkdev->rings.x86_64_part, |
457 | blkdev->rings.x86_64_part.rsp_prod_pvt); | |
62d23efa AL |
458 | break; |
459 | default: | |
460 | dst = NULL; | |
461 | } | |
462 | memcpy(dst, &resp, sizeof(resp)); | |
463 | blkdev->rings.common.rsp_prod_pvt++; | |
464 | ||
465 | RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&blkdev->rings.common, send_notify); | |
466 | if (blkdev->rings.common.rsp_prod_pvt == blkdev->rings.common.req_cons) { | |
467 | /* | |
468 | * Tail check for pending requests. Allows frontend to avoid | |
469 | * notifications if requests are already in flight (lower | |
470 | * overheads and promotes batching). | |
471 | */ | |
472 | RING_FINAL_CHECK_FOR_REQUESTS(&blkdev->rings.common, have_requests); | |
473 | } else if (RING_HAS_UNCONSUMED_REQUESTS(&blkdev->rings.common)) { | |
474 | have_requests = 1; | |
475 | } | |
476 | ||
477 | if (have_requests) | |
478 | blkdev->more_work++; | |
479 | return send_notify; | |
480 | } | |
481 | ||
482 | /* walk finished list, send outstanding responses, free requests */ | |
483 | static void blk_send_response_all(struct XenBlkDev *blkdev) | |
484 | { | |
485 | struct ioreq *ioreq; | |
486 | int send_notify = 0; | |
487 | ||
72cf2d4f BS |
488 | while (!QLIST_EMPTY(&blkdev->finished)) { |
489 | ioreq = QLIST_FIRST(&blkdev->finished); | |
62d23efa AL |
490 | send_notify += blk_send_response_one(ioreq); |
491 | ioreq_release(ioreq); | |
492 | } | |
493 | if (send_notify) | |
494 | xen_be_send_notify(&blkdev->xendev); | |
495 | } | |
496 | ||
497 | static int blk_get_request(struct XenBlkDev *blkdev, struct ioreq *ioreq, RING_IDX rc) | |
498 | { | |
499 | switch (blkdev->protocol) { | |
500 | case BLKIF_PROTOCOL_NATIVE: | |
501 | memcpy(&ioreq->req, RING_GET_REQUEST(&blkdev->rings.native, rc), | |
502 | sizeof(ioreq->req)); | |
503 | break; | |
504 | case BLKIF_PROTOCOL_X86_32: | |
6fcfeff9 BS |
505 | blkif_get_x86_32_req(&ioreq->req, |
506 | RING_GET_REQUEST(&blkdev->rings.x86_32_part, rc)); | |
62d23efa AL |
507 | break; |
508 | case BLKIF_PROTOCOL_X86_64: | |
6fcfeff9 BS |
509 | blkif_get_x86_64_req(&ioreq->req, |
510 | RING_GET_REQUEST(&blkdev->rings.x86_64_part, rc)); | |
62d23efa AL |
511 | break; |
512 | } | |
513 | return 0; | |
514 | } | |
515 | ||
516 | static void blk_handle_requests(struct XenBlkDev *blkdev) | |
517 | { | |
518 | RING_IDX rc, rp; | |
519 | struct ioreq *ioreq; | |
520 | ||
521 | blkdev->more_work = 0; | |
522 | ||
523 | rc = blkdev->rings.common.req_cons; | |
524 | rp = blkdev->rings.common.sring->req_prod; | |
525 | xen_rmb(); /* Ensure we see queued requests up to 'rp'. */ | |
526 | ||
527 | if (use_aio) | |
528 | blk_send_response_all(blkdev); | |
fc1f79f7 | 529 | while (rc != rp) { |
62d23efa AL |
530 | /* pull request from ring */ |
531 | if (RING_REQUEST_CONS_OVERFLOW(&blkdev->rings.common, rc)) | |
532 | break; | |
533 | ioreq = ioreq_start(blkdev); | |
534 | if (ioreq == NULL) { | |
535 | blkdev->more_work++; | |
536 | break; | |
537 | } | |
538 | blk_get_request(blkdev, ioreq, rc); | |
539 | blkdev->rings.common.req_cons = ++rc; | |
540 | ||
541 | /* parse them */ | |
542 | if (ioreq_parse(ioreq) != 0) { | |
543 | if (blk_send_response_one(ioreq)) | |
544 | xen_be_send_notify(&blkdev->xendev); | |
545 | ioreq_release(ioreq); | |
546 | continue; | |
547 | } | |
548 | ||
549 | if (use_aio) { | |
550 | /* run i/o in aio mode */ | |
551 | ioreq_runio_qemu_aio(ioreq); | |
552 | } else { | |
553 | /* run i/o in sync mode */ | |
554 | ioreq_runio_qemu_sync(ioreq); | |
555 | } | |
556 | } | |
557 | if (!use_aio) | |
558 | blk_send_response_all(blkdev); | |
559 | ||
560 | if (blkdev->more_work && blkdev->requests_inflight < max_requests) | |
561 | qemu_bh_schedule(blkdev->bh); | |
562 | } | |
563 | ||
564 | /* ------------------------------------------------------------- */ | |
565 | ||
566 | static void blk_bh(void *opaque) | |
567 | { | |
568 | struct XenBlkDev *blkdev = opaque; | |
569 | blk_handle_requests(blkdev); | |
570 | } | |
571 | ||
572 | static void blk_alloc(struct XenDevice *xendev) | |
573 | { | |
574 | struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); | |
575 | ||
72cf2d4f BS |
576 | QLIST_INIT(&blkdev->inflight); |
577 | QLIST_INIT(&blkdev->finished); | |
578 | QLIST_INIT(&blkdev->freelist); | |
62d23efa AL |
579 | blkdev->bh = qemu_bh_new(blk_bh, blkdev); |
580 | if (xen_mode != XEN_EMULATE) | |
581 | batch_maps = 1; | |
582 | } | |
583 | ||
584 | static int blk_init(struct XenDevice *xendev) | |
585 | { | |
586 | struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); | |
9678d950 | 587 | int index, qflags, have_barriers, info = 0; |
62d23efa AL |
588 | char *h; |
589 | ||
590 | /* read xenstore entries */ | |
591 | if (blkdev->params == NULL) { | |
592 | blkdev->params = xenstore_read_be_str(&blkdev->xendev, "params"); | |
593 | h = strchr(blkdev->params, ':'); | |
594 | if (h != NULL) { | |
595 | blkdev->fileproto = blkdev->params; | |
596 | blkdev->filename = h+1; | |
597 | *h = 0; | |
598 | } else { | |
599 | blkdev->fileproto = "<unset>"; | |
600 | blkdev->filename = blkdev->params; | |
601 | } | |
602 | } | |
603 | if (blkdev->mode == NULL) | |
604 | blkdev->mode = xenstore_read_be_str(&blkdev->xendev, "mode"); | |
605 | if (blkdev->type == NULL) | |
606 | blkdev->type = xenstore_read_be_str(&blkdev->xendev, "type"); | |
607 | if (blkdev->dev == NULL) | |
608 | blkdev->dev = xenstore_read_be_str(&blkdev->xendev, "dev"); | |
609 | if (blkdev->devtype == NULL) | |
610 | blkdev->devtype = xenstore_read_be_str(&blkdev->xendev, "device-type"); | |
611 | ||
612 | /* do we have all we need? */ | |
613 | if (blkdev->params == NULL || | |
614 | blkdev->mode == NULL || | |
615 | blkdev->type == NULL || | |
616 | blkdev->dev == NULL) | |
617 | return -1; | |
618 | ||
619 | /* read-only ? */ | |
620 | if (strcmp(blkdev->mode, "w") == 0) { | |
62d23efa AL |
621 | qflags = BDRV_O_RDWR; |
622 | } else { | |
f5edb014 | 623 | qflags = 0; |
62d23efa AL |
624 | info |= VDISK_READONLY; |
625 | } | |
626 | ||
627 | /* cdrom ? */ | |
628 | if (blkdev->devtype && !strcmp(blkdev->devtype, "cdrom")) | |
629 | info |= VDISK_CDROM; | |
630 | ||
631 | /* init qemu block driver */ | |
751c6a17 GH |
632 | index = (blkdev->xendev.dev - 202 * 256) / 16; |
633 | blkdev->dinfo = drive_get(IF_XEN, 0, index); | |
634 | if (!blkdev->dinfo) { | |
62d23efa AL |
635 | /* setup via xenbus -> create new block driver instance */ |
636 | xen_be_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n"); | |
ad717139 KW |
637 | blkdev->bs = bdrv_new(blkdev->dev); |
638 | if (bdrv_open(blkdev->bs, blkdev->filename, qflags, | |
639 | bdrv_find_whitelisted_format(blkdev->fileproto)) != 0) { | |
640 | bdrv_delete(blkdev->bs); | |
641 | return -1; | |
642 | } | |
62d23efa AL |
643 | } else { |
644 | /* setup via qemu cmdline -> already setup for us */ | |
645 | xen_be_printf(&blkdev->xendev, 2, "get configured bdrv (cmdline setup)\n"); | |
751c6a17 | 646 | blkdev->bs = blkdev->dinfo->bdrv; |
62d23efa AL |
647 | } |
648 | blkdev->file_blk = BLOCK_SIZE; | |
649 | blkdev->file_size = bdrv_getlength(blkdev->bs); | |
650 | if (blkdev->file_size < 0) { | |
651 | xen_be_printf(&blkdev->xendev, 1, "bdrv_getlength: %d (%s) | drv %s\n", | |
652 | (int)blkdev->file_size, strerror(-blkdev->file_size), | |
653 | blkdev->bs->drv ? blkdev->bs->drv->format_name : "-"); | |
654 | blkdev->file_size = 0; | |
655 | } | |
656 | have_barriers = blkdev->bs->drv && blkdev->bs->drv->bdrv_flush ? 1 : 0; | |
657 | ||
658 | xen_be_printf(xendev, 1, "type \"%s\", fileproto \"%s\", filename \"%s\"," | |
659 | " size %" PRId64 " (%" PRId64 " MB)\n", | |
660 | blkdev->type, blkdev->fileproto, blkdev->filename, | |
661 | blkdev->file_size, blkdev->file_size >> 20); | |
662 | ||
663 | /* fill info */ | |
664 | xenstore_write_be_int(&blkdev->xendev, "feature-barrier", have_barriers); | |
665 | xenstore_write_be_int(&blkdev->xendev, "info", info); | |
666 | xenstore_write_be_int(&blkdev->xendev, "sector-size", blkdev->file_blk); | |
667 | xenstore_write_be_int(&blkdev->xendev, "sectors", | |
668 | blkdev->file_size / blkdev->file_blk); | |
669 | return 0; | |
670 | } | |
671 | ||
672 | static int blk_connect(struct XenDevice *xendev) | |
673 | { | |
674 | struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); | |
675 | ||
676 | if (xenstore_read_fe_int(&blkdev->xendev, "ring-ref", &blkdev->ring_ref) == -1) | |
677 | return -1; | |
678 | if (xenstore_read_fe_int(&blkdev->xendev, "event-channel", | |
679 | &blkdev->xendev.remote_port) == -1) | |
680 | return -1; | |
681 | ||
682 | blkdev->protocol = BLKIF_PROTOCOL_NATIVE; | |
683 | if (blkdev->xendev.protocol) { | |
684 | if (strcmp(blkdev->xendev.protocol, XEN_IO_PROTO_ABI_X86_32) == 0) | |
685 | blkdev->protocol = BLKIF_PROTOCOL_X86_32; | |
686 | if (strcmp(blkdev->xendev.protocol, XEN_IO_PROTO_ABI_X86_64) == 0) | |
687 | blkdev->protocol = BLKIF_PROTOCOL_X86_64; | |
688 | } | |
689 | ||
690 | blkdev->sring = xc_gnttab_map_grant_ref(blkdev->xendev.gnttabdev, | |
691 | blkdev->xendev.dom, | |
692 | blkdev->ring_ref, | |
693 | PROT_READ | PROT_WRITE); | |
694 | if (!blkdev->sring) | |
695 | return -1; | |
696 | blkdev->cnt_map++; | |
697 | ||
698 | switch (blkdev->protocol) { | |
699 | case BLKIF_PROTOCOL_NATIVE: | |
700 | { | |
701 | blkif_sring_t *sring_native = blkdev->sring; | |
702 | BACK_RING_INIT(&blkdev->rings.native, sring_native, XC_PAGE_SIZE); | |
703 | break; | |
704 | } | |
705 | case BLKIF_PROTOCOL_X86_32: | |
706 | { | |
707 | blkif_x86_32_sring_t *sring_x86_32 = blkdev->sring; | |
6fcfeff9 BS |
708 | |
709 | BACK_RING_INIT(&blkdev->rings.x86_32_part, sring_x86_32, XC_PAGE_SIZE); | |
62d23efa AL |
710 | break; |
711 | } | |
712 | case BLKIF_PROTOCOL_X86_64: | |
713 | { | |
714 | blkif_x86_64_sring_t *sring_x86_64 = blkdev->sring; | |
6fcfeff9 BS |
715 | |
716 | BACK_RING_INIT(&blkdev->rings.x86_64_part, sring_x86_64, XC_PAGE_SIZE); | |
62d23efa AL |
717 | break; |
718 | } | |
719 | } | |
720 | ||
721 | xen_be_bind_evtchn(&blkdev->xendev); | |
722 | ||
723 | xen_be_printf(&blkdev->xendev, 1, "ok: proto %s, ring-ref %d, " | |
724 | "remote port %d, local port %d\n", | |
725 | blkdev->xendev.protocol, blkdev->ring_ref, | |
726 | blkdev->xendev.remote_port, blkdev->xendev.local_port); | |
727 | return 0; | |
728 | } | |
729 | ||
730 | static void blk_disconnect(struct XenDevice *xendev) | |
731 | { | |
732 | struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); | |
733 | ||
734 | if (blkdev->bs) { | |
751c6a17 | 735 | if (!blkdev->dinfo) { |
62d23efa AL |
736 | /* close/delete only if we created it ourself */ |
737 | bdrv_close(blkdev->bs); | |
738 | bdrv_delete(blkdev->bs); | |
739 | } | |
740 | blkdev->bs = NULL; | |
741 | } | |
742 | xen_be_unbind_evtchn(&blkdev->xendev); | |
743 | ||
744 | if (blkdev->sring) { | |
745 | xc_gnttab_munmap(blkdev->xendev.gnttabdev, blkdev->sring, 1); | |
746 | blkdev->cnt_map--; | |
747 | blkdev->sring = NULL; | |
748 | } | |
749 | } | |
750 | ||
751 | static int blk_free(struct XenDevice *xendev) | |
752 | { | |
753 | struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); | |
754 | struct ioreq *ioreq; | |
755 | ||
72cf2d4f BS |
756 | while (!QLIST_EMPTY(&blkdev->freelist)) { |
757 | ioreq = QLIST_FIRST(&blkdev->freelist); | |
758 | QLIST_REMOVE(ioreq, list); | |
62d23efa AL |
759 | qemu_iovec_destroy(&ioreq->v); |
760 | qemu_free(ioreq); | |
761 | } | |
762 | ||
763 | qemu_free(blkdev->params); | |
764 | qemu_free(blkdev->mode); | |
765 | qemu_free(blkdev->type); | |
766 | qemu_free(blkdev->dev); | |
767 | qemu_free(blkdev->devtype); | |
768 | qemu_bh_delete(blkdev->bh); | |
769 | return 0; | |
770 | } | |
771 | ||
772 | static void blk_event(struct XenDevice *xendev) | |
773 | { | |
774 | struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); | |
775 | ||
776 | qemu_bh_schedule(blkdev->bh); | |
777 | } | |
778 | ||
779 | struct XenDevOps xen_blkdev_ops = { | |
780 | .size = sizeof(struct XenBlkDev), | |
781 | .flags = DEVOPS_FLAG_NEED_GNTDEV, | |
782 | .alloc = blk_alloc, | |
783 | .init = blk_init, | |
784 | .connect = blk_connect, | |
785 | .disconnect = blk_disconnect, | |
786 | .event = blk_event, | |
787 | .free = blk_free, | |
788 | }; |