?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
xen: duplicate xen_disk.c as basis of dataplane/xen-block.c
[qemu.git] / hw / block / dataplane / xen-block.c
blob9fae50534e6e49cc744900c7e0ee4bd23b3ab1e4
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
16 * with this program; if not, see <http://www.gnu.org/licenses/>.
17 *
18 * Contributions after 2012-01-13 are licensed under the terms of the
19 * GNU GPL, version 2 or (at your option) any later version.
20 */
21
22 #include "qemu/osdep.h"
23 #include "qemu/units.h"
24 #include <sys/ioctl.h>
25 #include <sys/uio.h>
26
27 #include "hw/hw.h"
28 #include "hw/xen/xen_backend.h"
29 #include "xen_blkif.h"
30 #include "sysemu/blockdev.h"
31 #include "sysemu/iothread.h"
32 #include "sysemu/block-backend.h"
33 #include "qapi/error.h"
34 #include "qapi/qmp/qdict.h"
35 #include "qapi/qmp/qstring.h"
36 #include "trace.h"
37
38 /* ------------------------------------------------------------- */
39
40 #define BLOCK_SIZE 512
41 #define IOCB_COUNT (BLKIF_MAX_SEGMENTS_PER_REQUEST + 2)
42
43 struct ioreq {
44 blkif_request_t req;
45 int16_t status;
46
47 /* parsed request */
48 off_t start;
49 QEMUIOVector v;
50 void *buf;
51 size_t size;
52 int presync;
53
54 /* aio status */
55 int aio_inflight;
56 int aio_errors;
57
58 struct XenBlkDev *blkdev;
59 QLIST_ENTRY(ioreq) list;
60 BlockAcctCookie acct;
61 };
62
63 #define MAX_RING_PAGE_ORDER 4
64
65 struct XenBlkDev {
66 struct XenLegacyDevice xendev; /* must be first */
67 char *params;
68 char *mode;
69 char *type;
70 char *dev;
71 char *devtype;
72 bool directiosafe;
73 const char *fileproto;
74 const char *filename;
75 unsigned int ring_ref[1 << MAX_RING_PAGE_ORDER];
76 unsigned int nr_ring_ref;
77 void *sring;
78 int64_t file_blk;
79 int64_t file_size;
80 int protocol;
81 blkif_back_rings_t rings;
82 int more_work;
83
84 /* request lists */
85 QLIST_HEAD(inflight_head, ioreq) inflight;
86 QLIST_HEAD(finished_head, ioreq) finished;
87 QLIST_HEAD(freelist_head, ioreq) freelist;
88 int requests_total;
89 int requests_inflight;
90 int requests_finished;
91 unsigned int max_requests;
92
93 gboolean feature_discard;
94
95 /* qemu block driver */
96 DriveInfo *dinfo;
97 BlockBackend *blk;
98 QEMUBH *bh;
99
100 IOThread *iothread;
101 AioContext *ctx;
102 };
103
104 /* ------------------------------------------------------------- */
105
106 static void ioreq_reset(struct ioreq *ioreq)
107 {
108 memset(&ioreq->req, 0, sizeof(ioreq->req));
109 ioreq->status = 0;
110 ioreq->start = 0;
111 ioreq->buf = NULL;
112 ioreq->size = 0;
113 ioreq->presync = 0;
114
115 ioreq->aio_inflight = 0;
116 ioreq->aio_errors = 0;
117
118 ioreq->blkdev = NULL;
119 memset(&ioreq->list, 0, sizeof(ioreq->list));
120 memset(&ioreq->acct, 0, sizeof(ioreq->acct));
121
122 qemu_iovec_reset(&ioreq->v);
123 }
124
125 static struct ioreq *ioreq_start(struct XenBlkDev *blkdev)
126 {
127 struct ioreq *ioreq = NULL;
128
129 if (QLIST_EMPTY(&blkdev->freelist)) {
130 if (blkdev->requests_total >= blkdev->max_requests) {
131 goto out;
132 }
133 /* allocate new struct */
134 ioreq = g_malloc0(sizeof(*ioreq));
135 ioreq->blkdev = blkdev;
136 blkdev->requests_total++;
137 qemu_iovec_init(&ioreq->v, 1);
138 } else {
139 /* get one from freelist */
140 ioreq = QLIST_FIRST(&blkdev->freelist);
141 QLIST_REMOVE(ioreq, list);
142 }
143 QLIST_INSERT_HEAD(&blkdev->inflight, ioreq, list);
144 blkdev->requests_inflight++;
145
146 out:
147 return ioreq;
148 }
149
150 static void ioreq_finish(struct ioreq *ioreq)
151 {
152 struct XenBlkDev *blkdev = ioreq->blkdev;
153
154 QLIST_REMOVE(ioreq, list);
155 QLIST_INSERT_HEAD(&blkdev->finished, ioreq, list);
156 blkdev->requests_inflight--;
157 blkdev->requests_finished++;
158 }
159
160 static void ioreq_release(struct ioreq *ioreq, bool finish)
161 {
162 struct XenBlkDev *blkdev = ioreq->blkdev;
163
164 QLIST_REMOVE(ioreq, list);
165 ioreq_reset(ioreq);
166 ioreq->blkdev = blkdev;
167 QLIST_INSERT_HEAD(&blkdev->freelist, ioreq, list);
168 if (finish) {
169 blkdev->requests_finished--;
170 } else {
171 blkdev->requests_inflight--;
172 }
173 }
174
175 /*
176 * translate request into iovec + start offset
177 * do sanity checks along the way
178 */
179 static int ioreq_parse(struct ioreq *ioreq)
180 {
181 struct XenBlkDev *blkdev = ioreq->blkdev;
182 struct XenLegacyDevice *xendev = &blkdev->xendev;
183 size_t len;
184 int i;
185
186 xen_pv_printf(
187 xendev, 3,
188 "op %d, nr %d, handle %d, id %" PRId64 ", sector %" PRId64 "\n",
189 ioreq->req.operation, ioreq->req.nr_segments,
190 ioreq->req.handle, ioreq->req.id, ioreq->req.sector_number);
191 switch (ioreq->req.operation) {
192 case BLKIF_OP_READ:
193 break;
194 case BLKIF_OP_FLUSH_DISKCACHE:
195 ioreq->presync = 1;
196 if (!ioreq->req.nr_segments) {
197 return 0;
198 }
199 /* fall through */
200 case BLKIF_OP_WRITE:
201 break;
202 case BLKIF_OP_DISCARD:
203 return 0;
204 default:
205 xen_pv_printf(xendev, 0, "error: unknown operation (%d)\n",
206 ioreq->req.operation);
207 goto err;
208 };
209
210 if (ioreq->req.operation != BLKIF_OP_READ && blkdev->mode[0] != 'w') {
211 xen_pv_printf(xendev, 0, "error: write req for ro device\n");
212 goto err;
213 }
214
215 ioreq->start = ioreq->req.sector_number * blkdev->file_blk;
216 for (i = 0; i < ioreq->req.nr_segments; i++) {
217 if (i == BLKIF_MAX_SEGMENTS_PER_REQUEST) {
218 xen_pv_printf(xendev, 0, "error: nr_segments too big\n");
219 goto err;
220 }
221 if (ioreq->req.seg[i].first_sect > ioreq->req.seg[i].last_sect) {
222 xen_pv_printf(xendev, 0, "error: first > last sector\n");
223 goto err;
224 }
225 if (ioreq->req.seg[i].last_sect * BLOCK_SIZE >= XC_PAGE_SIZE) {
226 xen_pv_printf(xendev, 0, "error: page crossing\n");
227 goto err;
228 }
229
230 len = (ioreq->req.seg[i].last_sect -
231 ioreq->req.seg[i].first_sect + 1) * blkdev->file_blk;
232 ioreq->size += len;
233 }
234 if (ioreq->start + ioreq->size > blkdev->file_size) {
235 xen_pv_printf(xendev, 0, "error: access beyond end of file\n");
236 goto err;
237 }
238 return 0;
239
240 err:
241 ioreq->status = BLKIF_RSP_ERROR;
242 return -1;
243 }
244
245 static int ioreq_grant_copy(struct ioreq *ioreq)
246 {
247 struct XenBlkDev *blkdev = ioreq->blkdev;
248 struct XenLegacyDevice *xendev = &blkdev->xendev;
249 XenGrantCopySegment segs[BLKIF_MAX_SEGMENTS_PER_REQUEST];
250 int i, count, rc;
251 int64_t file_blk = blkdev->file_blk;
252 bool to_domain = (ioreq->req.operation == BLKIF_OP_READ);
253 void *virt = ioreq->buf;
254
255 if (ioreq->req.nr_segments == 0) {
256 return 0;
257 }
258
259 count = ioreq->req.nr_segments;
260
261 for (i = 0; i < count; i++) {
262 if (to_domain) {
263 segs[i].dest.foreign.ref = ioreq->req.seg[i].gref;
264 segs[i].dest.foreign.offset = ioreq->req.seg[i].first_sect *
265 file_blk;
266 segs[i].source.virt = virt;
267 } else {
268 segs[i].source.foreign.ref = ioreq->req.seg[i].gref;
269 segs[i].source.foreign.offset = ioreq->req.seg[i].first_sect *
270 file_blk;
271 segs[i].dest.virt = virt;
272 }
273 segs[i].len = (ioreq->req.seg[i].last_sect
274 - ioreq->req.seg[i].first_sect + 1) * file_blk;
275 virt += segs[i].len;
276 }
277
278 rc = xen_be_copy_grant_refs(xendev, to_domain, segs, count);
279
280 if (rc) {
281 xen_pv_printf(xendev, 0,
282 "failed to copy data %d\n", rc);
283 ioreq->aio_errors++;
284 return -1;
285 }
286
287 return rc;
288 }
289
290 static int ioreq_runio_qemu_aio(struct ioreq *ioreq);
291
292 static void qemu_aio_complete(void *opaque, int ret)
293 {
294 struct ioreq *ioreq = opaque;
295 struct XenBlkDev *blkdev = ioreq->blkdev;
296 struct XenLegacyDevice *xendev = &blkdev->xendev;
297
298 aio_context_acquire(blkdev->ctx);
299
300 if (ret != 0) {
301 xen_pv_printf(xendev, 0, "%s I/O error\n",
302 ioreq->req.operation == BLKIF_OP_READ ? "read" : "write");
303 ioreq->aio_errors++;
304 }
305
306 ioreq->aio_inflight--;
307 if (ioreq->presync) {
308 ioreq->presync = 0;
309 ioreq_runio_qemu_aio(ioreq);
310 goto done;
311 }
312 if (ioreq->aio_inflight > 0) {
313 goto done;
314 }
315
316 switch (ioreq->req.operation) {
317 case BLKIF_OP_READ:
318 /* in case of failure ioreq->aio_errors is increased */
319 if (ret == 0) {
320 ioreq_grant_copy(ioreq);
321 }
322 qemu_vfree(ioreq->buf);
323 break;
324 case BLKIF_OP_WRITE:
325 case BLKIF_OP_FLUSH_DISKCACHE:
326 if (!ioreq->req.nr_segments) {
327 break;
328 }
329 qemu_vfree(ioreq->buf);
330 break;
331 default:
332 break;
333 }
334
335 ioreq->status = ioreq->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY;
336 ioreq_finish(ioreq);
337
338 switch (ioreq->req.operation) {
339 case BLKIF_OP_WRITE:
340 case BLKIF_OP_FLUSH_DISKCACHE:
341 if (!ioreq->req.nr_segments) {
342 break;
343 }
344 case BLKIF_OP_READ:
345 if (ioreq->status == BLKIF_RSP_OKAY) {
346 block_acct_done(blk_get_stats(blkdev->blk), &ioreq->acct);
347 } else {
348 block_acct_failed(blk_get_stats(blkdev->blk), &ioreq->acct);
349 }
350 break;
351 case BLKIF_OP_DISCARD:
352 default:
353 break;
354 }
355 qemu_bh_schedule(blkdev->bh);
356
357 done:
358 aio_context_release(blkdev->ctx);
359 }
360
361 static bool blk_split_discard(struct ioreq *ioreq, blkif_sector_t sector_number,
362 uint64_t nr_sectors)
363 {
364 struct XenBlkDev *blkdev = ioreq->blkdev;
365 int64_t byte_offset;
366 int byte_chunk;
367 uint64_t byte_remaining, limit;
368 uint64_t sec_start = sector_number;
369 uint64_t sec_count = nr_sectors;
370
371 /* Wrap around, or overflowing byte limit? */
372 if (sec_start + sec_count < sec_count ||
373 sec_start + sec_count > INT64_MAX >> BDRV_SECTOR_BITS) {
374 return false;
375 }
376
377 limit = BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS;
378 byte_offset = sec_start << BDRV_SECTOR_BITS;
379 byte_remaining = sec_count << BDRV_SECTOR_BITS;
380
381 do {
382 byte_chunk = byte_remaining > limit ? limit : byte_remaining;
383 ioreq->aio_inflight++;
384 blk_aio_pdiscard(blkdev->blk, byte_offset, byte_chunk,
385 qemu_aio_complete, ioreq);
386 byte_remaining -= byte_chunk;
387 byte_offset += byte_chunk;
388 } while (byte_remaining > 0);
389
390 return true;
391 }
392
393 static int ioreq_runio_qemu_aio(struct ioreq *ioreq)
394 {
395 struct XenBlkDev *blkdev = ioreq->blkdev;
396
397 ioreq->buf = qemu_memalign(XC_PAGE_SIZE, ioreq->size);
398 if (ioreq->req.nr_segments &&
399 (ioreq->req.operation == BLKIF_OP_WRITE ||
400 ioreq->req.operation == BLKIF_OP_FLUSH_DISKCACHE) &&
401 ioreq_grant_copy(ioreq)) {
402 qemu_vfree(ioreq->buf);
403 goto err;
404 }
405
406 ioreq->aio_inflight++;
407 if (ioreq->presync) {
408 blk_aio_flush(ioreq->blkdev->blk, qemu_aio_complete, ioreq);
409 return 0;
410 }
411
412 switch (ioreq->req.operation) {
413 case BLKIF_OP_READ:
414 qemu_iovec_add(&ioreq->v, ioreq->buf, ioreq->size);
415 block_acct_start(blk_get_stats(blkdev->blk), &ioreq->acct,
416 ioreq->v.size, BLOCK_ACCT_READ);
417 ioreq->aio_inflight++;
418 blk_aio_preadv(blkdev->blk, ioreq->start, &ioreq->v, 0,
419 qemu_aio_complete, ioreq);
420 break;
421 case BLKIF_OP_WRITE:
422 case BLKIF_OP_FLUSH_DISKCACHE:
423 if (!ioreq->req.nr_segments) {
424 break;
425 }
426
427 qemu_iovec_add(&ioreq->v, ioreq->buf, ioreq->size);
428 block_acct_start(blk_get_stats(blkdev->blk), &ioreq->acct,
429 ioreq->v.size,
430 ioreq->req.operation == BLKIF_OP_WRITE ?
431 BLOCK_ACCT_WRITE : BLOCK_ACCT_FLUSH);
432 ioreq->aio_inflight++;
433 blk_aio_pwritev(blkdev->blk, ioreq->start, &ioreq->v, 0,
434 qemu_aio_complete, ioreq);
435 break;
436 case BLKIF_OP_DISCARD:
437 {
438 struct blkif_request_discard *req = (void *)&ioreq->req;
439 if (!blk_split_discard(ioreq, req->sector_number, req->nr_sectors)) {
440 goto err;
441 }
442 break;
443 }
444 default:
445 /* unknown operation (shouldn't happen -- parse catches this) */
446 goto err;
447 }
448
449 qemu_aio_complete(ioreq, 0);
450
451 return 0;
452
453 err:
454 ioreq_finish(ioreq);
455 ioreq->status = BLKIF_RSP_ERROR;
456 return -1;
457 }
458
459 static int blk_send_response_one(struct ioreq *ioreq)
460 {
461 struct XenBlkDev *blkdev = ioreq->blkdev;
462 int send_notify = 0;
463 int have_requests = 0;
464 blkif_response_t *resp;
465
466 /* Place on the response ring for the relevant domain. */
467 switch (blkdev->protocol) {
468 case BLKIF_PROTOCOL_NATIVE:
469 resp = (blkif_response_t *)RING_GET_RESPONSE(
470 &blkdev->rings.native,
471 blkdev->rings.native.rsp_prod_pvt);
472 break;
473 case BLKIF_PROTOCOL_X86_32:
474 resp = (blkif_response_t *)RING_GET_RESPONSE(
475 &blkdev->rings.x86_32_part,
476 blkdev->rings.x86_32_part.rsp_prod_pvt);
477 break;
478 case BLKIF_PROTOCOL_X86_64:
479 resp = (blkif_response_t *)RING_GET_RESPONSE(
480 &blkdev->rings.x86_64_part,
481 blkdev->rings.x86_64_part.rsp_prod_pvt);
482 break;
483 default:
484 return 0;
485 }
486
487 resp->id = ioreq->req.id;
488 resp->operation = ioreq->req.operation;
489 resp->status = ioreq->status;
490
491 blkdev->rings.common.rsp_prod_pvt++;
492
493 RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&blkdev->rings.common, send_notify);
494 if (blkdev->rings.common.rsp_prod_pvt == blkdev->rings.common.req_cons) {
495 /*
496 * Tail check for pending requests. Allows frontend to avoid
497 * notifications if requests are already in flight (lower
498 * overheads and promotes batching).
499 */
500 RING_FINAL_CHECK_FOR_REQUESTS(&blkdev->rings.common, have_requests);
501 } else if (RING_HAS_UNCONSUMED_REQUESTS(&blkdev->rings.common)) {
502 have_requests = 1;
503 }
504
505 if (have_requests) {
506 blkdev->more_work++;
507 }
508 return send_notify;
509 }
510
511 /* walk finished list, send outstanding responses, free requests */
512 static void blk_send_response_all(struct XenBlkDev *blkdev)
513 {
514 struct ioreq *ioreq;
515 int send_notify = 0;
516
517 while (!QLIST_EMPTY(&blkdev->finished)) {
518 ioreq = QLIST_FIRST(&blkdev->finished);
519 send_notify += blk_send_response_one(ioreq);
520 ioreq_release(ioreq, true);
521 }
522 if (send_notify) {
523 xen_pv_send_notify(&blkdev->xendev);
524 }
525 }
526
527 static int blk_get_request(struct XenBlkDev *blkdev, struct ioreq *ioreq,
528 RING_IDX rc)
529 {
530 switch (blkdev->protocol) {
531 case BLKIF_PROTOCOL_NATIVE:
532 memcpy(&ioreq->req, RING_GET_REQUEST(&blkdev->rings.native, rc),
533 sizeof(ioreq->req));
534 break;
535 case BLKIF_PROTOCOL_X86_32:
536 blkif_get_x86_32_req(&ioreq->req,
537 RING_GET_REQUEST(&blkdev->rings.x86_32_part, rc));
538 break;
539 case BLKIF_PROTOCOL_X86_64:
540 blkif_get_x86_64_req(&ioreq->req,
541 RING_GET_REQUEST(&blkdev->rings.x86_64_part, rc));
542 break;
543 }
544 /* Prevent the compiler from accessing the on-ring fields instead. */
545 barrier();
546 return 0;
547 }
548
549 static void blk_handle_requests(struct XenBlkDev *blkdev)
550 {
551 RING_IDX rc, rp;
552 struct ioreq *ioreq;
553
554 blkdev->more_work = 0;
555
556 rc = blkdev->rings.common.req_cons;
557 rp = blkdev->rings.common.sring->req_prod;
558 xen_rmb(); /* Ensure we see queued requests up to 'rp'. */
559
560 blk_send_response_all(blkdev);
561 while (rc != rp) {
562 /* pull request from ring */
563 if (RING_REQUEST_CONS_OVERFLOW(&blkdev->rings.common, rc)) {
564 break;
565 }
566 ioreq = ioreq_start(blkdev);
567 if (ioreq == NULL) {
568 blkdev->more_work++;
569 break;
570 }
571 blk_get_request(blkdev, ioreq, rc);
572 blkdev->rings.common.req_cons = ++rc;
573
574 /* parse them */
575 if (ioreq_parse(ioreq) != 0) {
576
577 switch (ioreq->req.operation) {
578 case BLKIF_OP_READ:
579 block_acct_invalid(blk_get_stats(blkdev->blk),
580 BLOCK_ACCT_READ);
581 break;
582 case BLKIF_OP_WRITE:
583 block_acct_invalid(blk_get_stats(blkdev->blk),
584 BLOCK_ACCT_WRITE);
585 break;
586 case BLKIF_OP_FLUSH_DISKCACHE:
587 block_acct_invalid(blk_get_stats(blkdev->blk),
588 BLOCK_ACCT_FLUSH);
589 default:
590 break;
591 };
592
593 if (blk_send_response_one(ioreq)) {
594 xen_pv_send_notify(&blkdev->xendev);
595 }
596 ioreq_release(ioreq, false);
597 continue;
598 }
599
600 ioreq_runio_qemu_aio(ioreq);
601 }
602
603 if (blkdev->more_work && blkdev->requests_inflight < blkdev->max_requests) {
604 qemu_bh_schedule(blkdev->bh);
605 }
606 }
607
608 /* ------------------------------------------------------------- */
609
610 static void blk_bh(void *opaque)
611 {
612 struct XenBlkDev *blkdev = opaque;
613
614 aio_context_acquire(blkdev->ctx);
615 blk_handle_requests(blkdev);
616 aio_context_release(blkdev->ctx);
617 }
618
619 static void blk_alloc(struct XenLegacyDevice *xendev)
620 {
621 struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
622 Error *err = NULL;
623
624 trace_xen_disk_alloc(xendev->name);
625
626 QLIST_INIT(&blkdev->inflight);
627 QLIST_INIT(&blkdev->finished);
628 QLIST_INIT(&blkdev->freelist);
629
630 blkdev->iothread = iothread_create(xendev->name, &err);
631 assert(!err);
632
633 blkdev->ctx = iothread_get_aio_context(blkdev->iothread);
634 blkdev->bh = aio_bh_new(blkdev->ctx, blk_bh, blkdev);
635 }
636
637 static void blk_parse_discard(struct XenBlkDev *blkdev)
638 {
639 struct XenLegacyDevice *xendev = &blkdev->xendev;
640 int enable;
641
642 blkdev->feature_discard = true;
643
644 if (xenstore_read_be_int(xendev, "discard-enable", &enable) == 0) {
645 blkdev->feature_discard = !!enable;
646 }
647
648 if (blkdev->feature_discard) {
649 xenstore_write_be_int(xendev, "feature-discard", 1);
650 }
651 }
652
653 static int blk_init(struct XenLegacyDevice *xendev)
654 {
655 struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
656 int info = 0;
657 char *directiosafe = NULL;
658
659 trace_xen_disk_init(xendev->name);
660
661 /* read xenstore entries */
662 if (blkdev->params == NULL) {
663 char *h = NULL;
664 blkdev->params = xenstore_read_be_str(xendev, "params");
665 if (blkdev->params != NULL) {
666 h = strchr(blkdev->params, ':');
667 }
668 if (h != NULL) {
669 blkdev->fileproto = blkdev->params;
670 blkdev->filename = h + 1;
671 *h = 0;
672 } else {
673 blkdev->fileproto = "<unset>";
674 blkdev->filename = blkdev->params;
675 }
676 }
677 if (!strcmp("aio", blkdev->fileproto)) {
678 blkdev->fileproto = "raw";
679 }
680 if (!strcmp("vhd", blkdev->fileproto)) {
681 blkdev->fileproto = "vpc";
682 }
683 if (blkdev->mode == NULL) {
684 blkdev->mode = xenstore_read_be_str(xendev, "mode");
685 }
686 if (blkdev->type == NULL) {
687 blkdev->type = xenstore_read_be_str(xendev, "type");
688 }
689 if (blkdev->dev == NULL) {
690 blkdev->dev = xenstore_read_be_str(xendev, "dev");
691 }
692 if (blkdev->devtype == NULL) {
693 blkdev->devtype = xenstore_read_be_str(xendev, "device-type");
694 }
695 directiosafe = xenstore_read_be_str(xendev, "direct-io-safe");
696 blkdev->directiosafe = (directiosafe && atoi(directiosafe));
697
698 /* do we have all we need? */
699 if (blkdev->params == NULL ||
700 blkdev->mode == NULL ||
701 blkdev->type == NULL ||
702 blkdev->dev == NULL) {
703 goto out_error;
704 }
705
706 /* read-only ? */
707 if (strcmp(blkdev->mode, "w")) {
708 info |= VDISK_READONLY;
709 }
710
711 /* cdrom ? */
712 if (blkdev->devtype && !strcmp(blkdev->devtype, "cdrom")) {
713 info |= VDISK_CDROM;
714 }
715
716 blkdev->file_blk = BLOCK_SIZE;
717
718 /* fill info
719 * blk_connect supplies sector-size and sectors
720 */
721 xenstore_write_be_int(xendev, "feature-flush-cache", 1);
722 xenstore_write_be_int(xendev, "info", info);
723
724 xenstore_write_be_int(xendev, "max-ring-page-order",
725 MAX_RING_PAGE_ORDER);
726
727 blk_parse_discard(blkdev);
728
729 g_free(directiosafe);
730 return 0;
731
732 out_error:
733 g_free(blkdev->params);
734 blkdev->params = NULL;
735 g_free(blkdev->mode);
736 blkdev->mode = NULL;
737 g_free(blkdev->type);
738 blkdev->type = NULL;
739 g_free(blkdev->dev);
740 blkdev->dev = NULL;
741 g_free(blkdev->devtype);
742 blkdev->devtype = NULL;
743 g_free(directiosafe);
744 blkdev->directiosafe = false;
745 return -1;
746 }
747
748 static int blk_connect(struct XenLegacyDevice *xendev)
749 {
750 struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
751 int index, qflags;
752 bool readonly = true;
753 bool writethrough = true;
754 int order, ring_ref;
755 unsigned int ring_size, max_grants;
756 unsigned int i;
757
758 trace_xen_disk_connect(xendev->name);
759
760 /* read-only ? */
761 if (blkdev->directiosafe) {
762 qflags = BDRV_O_NOCACHE | BDRV_O_NATIVE_AIO;
763 } else {
764 qflags = 0;
765 writethrough = false;
766 }
767 if (strcmp(blkdev->mode, "w") == 0) {
768 qflags |= BDRV_O_RDWR;
769 readonly = false;
770 }
771 if (blkdev->feature_discard) {
772 qflags |= BDRV_O_UNMAP;
773 }
774
775 /* init qemu block driver */
776 index = (xendev->dev - 202 * 256) / 16;
777 blkdev->dinfo = drive_get(IF_XEN, 0, index);
778 if (!blkdev->dinfo) {
779 Error *local_err = NULL;
780 QDict *options = NULL;
781
782 if (strcmp(blkdev->fileproto, "<unset>")) {
783 options = qdict_new();
784 qdict_put_str(options, "driver", blkdev->fileproto);
785 }
786
787 /* setup via xenbus -> create new block driver instance */
788 xen_pv_printf(xendev, 2, "create new bdrv (xenbus setup)\n");
789 blkdev->blk = blk_new_open(blkdev->filename, NULL, options,
790 qflags, &local_err);
791 if (!blkdev->blk) {
792 xen_pv_printf(xendev, 0, "error: %s\n",
793 error_get_pretty(local_err));
794 error_free(local_err);
795 return -1;
796 }
797 blk_set_enable_write_cache(blkdev->blk, !writethrough);
798 } else {
799 /* setup via qemu cmdline -> already setup for us */
800 xen_pv_printf(xendev, 2,
801 "get configured bdrv (cmdline setup)\n");
802 blkdev->blk = blk_by_legacy_dinfo(blkdev->dinfo);
803 if (blk_is_read_only(blkdev->blk) && !readonly) {
804 xen_pv_printf(xendev, 0, "Unexpected read-only drive");
805 blkdev->blk = NULL;
806 return -1;
807 }
808 /* blkdev->blk is not create by us, we get a reference
809 * so we can blk_unref() unconditionally */
810 blk_ref(blkdev->blk);
811 }
812 blk_attach_dev_legacy(blkdev->blk, blkdev);
813 blkdev->file_size = blk_getlength(blkdev->blk);
814 if (blkdev->file_size < 0) {
815 BlockDriverState *bs = blk_bs(blkdev->blk);
816 const char *drv_name = bs ? bdrv_get_format_name(bs) : NULL;
817 xen_pv_printf(xendev, 1, "blk_getlength: %d (%s) | drv %s\n",
818 (int)blkdev->file_size, strerror(-blkdev->file_size),
819 drv_name ?: "-");
820 blkdev->file_size = 0;
821 }
822
823 xen_pv_printf(xendev, 1, "type \"%s\", fileproto \"%s\", filename \"%s\","
824 " size %" PRId64 " (%" PRId64 " MB)\n",
825 blkdev->type, blkdev->fileproto, blkdev->filename,
826 blkdev->file_size, blkdev->file_size / MiB);
827
828 /* Fill in number of sector size and number of sectors */
829 xenstore_write_be_int(xendev, "sector-size", blkdev->file_blk);
830 xenstore_write_be_int64(xendev, "sectors",
831 blkdev->file_size / blkdev->file_blk);
832
833 if (xenstore_read_fe_int(xendev, "ring-page-order",
834 &order) == -1) {
835 blkdev->nr_ring_ref = 1;
836
837 if (xenstore_read_fe_int(xendev, "ring-ref",
838 &ring_ref) == -1) {
839 return -1;
840 }
841 blkdev->ring_ref[0] = ring_ref;
842
843 } else if (order >= 0 && order <= MAX_RING_PAGE_ORDER) {
844 blkdev->nr_ring_ref = 1 << order;
845
846 for (i = 0; i < blkdev->nr_ring_ref; i++) {
847 char *key;
848
849 key = g_strdup_printf("ring-ref%u", i);
850 if (!key) {
851 return -1;
852 }
853
854 if (xenstore_read_fe_int(xendev, key,
855 &ring_ref) == -1) {
856 g_free(key);
857 return -1;
858 }
859 blkdev->ring_ref[i] = ring_ref;
860
861 g_free(key);
862 }
863 } else {
864 xen_pv_printf(xendev, 0, "invalid ring-page-order: %d\n",
865 order);
866 return -1;
867 }
868
869 if (xenstore_read_fe_int(xendev, "event-channel",
870 &xendev->remote_port) == -1) {
871 return -1;
872 }
873
874 if (!xendev->protocol) {
875 blkdev->protocol = BLKIF_PROTOCOL_NATIVE;
876 } else if (strcmp(xendev->protocol, XEN_IO_PROTO_ABI_NATIVE) == 0) {
877 blkdev->protocol = BLKIF_PROTOCOL_NATIVE;
878 } else if (strcmp(xendev->protocol, XEN_IO_PROTO_ABI_X86_32) == 0) {
879 blkdev->protocol = BLKIF_PROTOCOL_X86_32;
880 } else if (strcmp(xendev->protocol, XEN_IO_PROTO_ABI_X86_64) == 0) {
881 blkdev->protocol = BLKIF_PROTOCOL_X86_64;
882 } else {
883 blkdev->protocol = BLKIF_PROTOCOL_NATIVE;
884 }
885
886 ring_size = XC_PAGE_SIZE * blkdev->nr_ring_ref;
887 switch (blkdev->protocol) {
888 case BLKIF_PROTOCOL_NATIVE:
889 {
890 blkdev->max_requests = __CONST_RING_SIZE(blkif, ring_size);
891 break;
892 }
893 case BLKIF_PROTOCOL_X86_32:
894 {
895 blkdev->max_requests = __CONST_RING_SIZE(blkif_x86_32, ring_size);
896 break;
897 }
898 case BLKIF_PROTOCOL_X86_64:
899 {
900 blkdev->max_requests = __CONST_RING_SIZE(blkif_x86_64, ring_size);
901 break;
902 }
903 default:
904 return -1;
905 }
906
907 /* Add on the number needed for the ring pages */
908 max_grants = blkdev->nr_ring_ref;
909
910 xen_be_set_max_grant_refs(xendev, max_grants);
911 blkdev->sring = xen_be_map_grant_refs(xendev, blkdev->ring_ref,
912 blkdev->nr_ring_ref,
913 PROT_READ | PROT_WRITE);
914 if (!blkdev->sring) {
915 return -1;
916 }
917
918 switch (blkdev->protocol) {
919 case BLKIF_PROTOCOL_NATIVE:
920 {
921 blkif_sring_t *sring_native = blkdev->sring;
922 BACK_RING_INIT(&blkdev->rings.native, sring_native, ring_size);
923 break;
924 }
925 case BLKIF_PROTOCOL_X86_32:
926 {
927 blkif_x86_32_sring_t *sring_x86_32 = blkdev->sring;
928
929 BACK_RING_INIT(&blkdev->rings.x86_32_part, sring_x86_32, ring_size);
930 break;
931 }
932 case BLKIF_PROTOCOL_X86_64:
933 {
934 blkif_x86_64_sring_t *sring_x86_64 = blkdev->sring;
935
936 BACK_RING_INIT(&blkdev->rings.x86_64_part, sring_x86_64, ring_size);
937 break;
938 }
939 }
940
941 blk_set_aio_context(blkdev->blk, blkdev->ctx);
942
943 xen_be_bind_evtchn(xendev);
944
945 xen_pv_printf(xendev, 1, "ok: proto %s, nr-ring-ref %u, "
946 "remote port %d, local port %d\n",
947 xendev->protocol, blkdev->nr_ring_ref,
948 xendev->remote_port, xendev->local_port);
949 return 0;
950 }
951
952 static void blk_disconnect(struct XenLegacyDevice *xendev)
953 {
954 struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
955
956 trace_xen_disk_disconnect(xendev->name);
957
958 aio_context_acquire(blkdev->ctx);
959
960 if (blkdev->blk) {
961 blk_set_aio_context(blkdev->blk, qemu_get_aio_context());
962 blk_detach_dev(blkdev->blk, blkdev);
963 blk_unref(blkdev->blk);
964 blkdev->blk = NULL;
965 }
966 xen_pv_unbind_evtchn(xendev);
967
968 aio_context_release(blkdev->ctx);
969
970 if (blkdev->sring) {
971 xen_be_unmap_grant_refs(xendev, blkdev->sring,
972 blkdev->nr_ring_ref);
973 blkdev->sring = NULL;
974 }
975 }
976
977 static int blk_free(struct XenLegacyDevice *xendev)
978 {
979 struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
980 struct ioreq *ioreq;
981
982 trace_xen_disk_free(xendev->name);
983
984 blk_disconnect(xendev);
985
986 while (!QLIST_EMPTY(&blkdev->freelist)) {
987 ioreq = QLIST_FIRST(&blkdev->freelist);
988 QLIST_REMOVE(ioreq, list);
989 qemu_iovec_destroy(&ioreq->v);
990 g_free(ioreq);
991 }
992
993 g_free(blkdev->params);
994 g_free(blkdev->mode);
995 g_free(blkdev->type);
996 g_free(blkdev->dev);
997 g_free(blkdev->devtype);
998 qemu_bh_delete(blkdev->bh);
999 iothread_destroy(blkdev->iothread);
1000 return 0;
1001 }
1002
1003 static void blk_event(struct XenLegacyDevice *xendev)
1004 {
1005 struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
1006
1007 qemu_bh_schedule(blkdev->bh);
1008 }
1009
1010 struct XenDevOps xen_blkdev_ops = {
1011 .flags = DEVOPS_FLAG_NEED_GNTDEV,
1012 .size = sizeof(struct XenBlkDev),
1013 .alloc = blk_alloc,
1014 .init = blk_init,
1015 .initialise = blk_connect,
1016 .disconnect = blk_disconnect,
1017 .event = blk_event,
1018 .free = blk_free,
1019 };
QEmu