2 * xen paravirt block device backend
4 * (c) Gerd Hoffmann <kraxel@redhat.com>
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.
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.
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/>.
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.
32 #include <sys/ioctl.h>
33 #include <sys/types.h>
40 #include <xen/io/xenbus.h>
43 #include "block_int.h"
44 #include "qemu-char.h"
45 #include "xen_blkif.h"
46 #include "xen_backend.h"
49 /* ------------------------------------------------------------- */
51 static int batch_maps
= 0;
53 static int max_requests
= 32;
55 /* ------------------------------------------------------------- */
57 #define BLOCK_SIZE 512
58 #define IOCB_COUNT (BLKIF_MAX_SEGMENTS_PER_REQUEST + 2)
72 uint32_t domids
[BLKIF_MAX_SEGMENTS_PER_REQUEST
];
73 uint32_t refs
[BLKIF_MAX_SEGMENTS_PER_REQUEST
];
75 void *page
[BLKIF_MAX_SEGMENTS_PER_REQUEST
];
82 struct XenBlkDev
*blkdev
;
83 QLIST_ENTRY(ioreq
) list
;
88 struct XenDevice xendev
; /* must be first */
94 const char *fileproto
;
101 blkif_back_rings_t rings
;
106 QLIST_HEAD(inflight_head
, ioreq
) inflight
;
107 QLIST_HEAD(finished_head
, ioreq
) finished
;
108 QLIST_HEAD(freelist_head
, ioreq
) freelist
;
110 int requests_inflight
;
111 int requests_finished
;
113 /* qemu block driver */
115 BlockDriverState
*bs
;
119 /* ------------------------------------------------------------- */
121 static struct ioreq
*ioreq_start(struct XenBlkDev
*blkdev
)
123 struct ioreq
*ioreq
= NULL
;
125 if (QLIST_EMPTY(&blkdev
->freelist
)) {
126 if (blkdev
->requests_total
>= max_requests
) {
129 /* allocate new struct */
130 ioreq
= g_malloc0(sizeof(*ioreq
));
131 ioreq
->blkdev
= blkdev
;
132 blkdev
->requests_total
++;
133 qemu_iovec_init(&ioreq
->v
, BLKIF_MAX_SEGMENTS_PER_REQUEST
);
135 /* get one from freelist */
136 ioreq
= QLIST_FIRST(&blkdev
->freelist
);
137 QLIST_REMOVE(ioreq
, list
);
138 qemu_iovec_reset(&ioreq
->v
);
140 QLIST_INSERT_HEAD(&blkdev
->inflight
, ioreq
, list
);
141 blkdev
->requests_inflight
++;
147 static void ioreq_finish(struct ioreq
*ioreq
)
149 struct XenBlkDev
*blkdev
= ioreq
->blkdev
;
151 QLIST_REMOVE(ioreq
, list
);
152 QLIST_INSERT_HEAD(&blkdev
->finished
, ioreq
, list
);
153 blkdev
->requests_inflight
--;
154 blkdev
->requests_finished
++;
157 static void ioreq_release(struct ioreq
*ioreq
, bool finish
)
159 struct XenBlkDev
*blkdev
= ioreq
->blkdev
;
161 QLIST_REMOVE(ioreq
, list
);
162 memset(ioreq
, 0, sizeof(*ioreq
));
163 ioreq
->blkdev
= blkdev
;
164 QLIST_INSERT_HEAD(&blkdev
->freelist
, ioreq
, list
);
166 blkdev
->requests_finished
--;
168 blkdev
->requests_inflight
--;
173 * translate request into iovec + start offset
174 * do sanity checks along the way
176 static int ioreq_parse(struct ioreq
*ioreq
)
178 struct XenBlkDev
*blkdev
= ioreq
->blkdev
;
183 xen_be_printf(&blkdev
->xendev
, 3,
184 "op %d, nr %d, handle %d, id %" PRId64
", sector %" PRId64
"\n",
185 ioreq
->req
.operation
, ioreq
->req
.nr_segments
,
186 ioreq
->req
.handle
, ioreq
->req
.id
, ioreq
->req
.sector_number
);
187 switch (ioreq
->req
.operation
) {
189 ioreq
->prot
= PROT_WRITE
; /* to memory */
191 case BLKIF_OP_WRITE_BARRIER
:
192 if (!ioreq
->req
.nr_segments
) {
196 ioreq
->presync
= ioreq
->postsync
= 1;
199 ioreq
->prot
= PROT_READ
; /* from memory */
202 xen_be_printf(&blkdev
->xendev
, 0, "error: unknown operation (%d)\n",
203 ioreq
->req
.operation
);
207 if (ioreq
->req
.operation
!= BLKIF_OP_READ
&& blkdev
->mode
[0] != 'w') {
208 xen_be_printf(&blkdev
->xendev
, 0, "error: write req for ro device\n");
212 ioreq
->start
= ioreq
->req
.sector_number
* blkdev
->file_blk
;
213 for (i
= 0; i
< ioreq
->req
.nr_segments
; i
++) {
214 if (i
== BLKIF_MAX_SEGMENTS_PER_REQUEST
) {
215 xen_be_printf(&blkdev
->xendev
, 0, "error: nr_segments too big\n");
218 if (ioreq
->req
.seg
[i
].first_sect
> ioreq
->req
.seg
[i
].last_sect
) {
219 xen_be_printf(&blkdev
->xendev
, 0, "error: first > last sector\n");
222 if (ioreq
->req
.seg
[i
].last_sect
* BLOCK_SIZE
>= XC_PAGE_SIZE
) {
223 xen_be_printf(&blkdev
->xendev
, 0, "error: page crossing\n");
227 ioreq
->domids
[i
] = blkdev
->xendev
.dom
;
228 ioreq
->refs
[i
] = ioreq
->req
.seg
[i
].gref
;
230 mem
= ioreq
->req
.seg
[i
].first_sect
* blkdev
->file_blk
;
231 len
= (ioreq
->req
.seg
[i
].last_sect
- ioreq
->req
.seg
[i
].first_sect
+ 1) * blkdev
->file_blk
;
232 qemu_iovec_add(&ioreq
->v
, (void*)mem
, len
);
234 if (ioreq
->start
+ ioreq
->v
.size
> blkdev
->file_size
) {
235 xen_be_printf(&blkdev
->xendev
, 0, "error: access beyond end of file\n");
241 ioreq
->status
= BLKIF_RSP_ERROR
;
245 static void ioreq_unmap(struct ioreq
*ioreq
)
247 XenGnttab gnt
= ioreq
->blkdev
->xendev
.gnttabdev
;
250 if (ioreq
->v
.niov
== 0 || ioreq
->mapped
== 0) {
257 if (xc_gnttab_munmap(gnt
, ioreq
->pages
, ioreq
->v
.niov
) != 0) {
258 xen_be_printf(&ioreq
->blkdev
->xendev
, 0, "xc_gnttab_munmap failed: %s\n",
261 ioreq
->blkdev
->cnt_map
-= ioreq
->v
.niov
;
264 for (i
= 0; i
< ioreq
->v
.niov
; i
++) {
265 if (!ioreq
->page
[i
]) {
268 if (xc_gnttab_munmap(gnt
, ioreq
->page
[i
], 1) != 0) {
269 xen_be_printf(&ioreq
->blkdev
->xendev
, 0, "xc_gnttab_munmap failed: %s\n",
272 ioreq
->blkdev
->cnt_map
--;
273 ioreq
->page
[i
] = NULL
;
279 static int ioreq_map(struct ioreq
*ioreq
)
281 XenGnttab gnt
= ioreq
->blkdev
->xendev
.gnttabdev
;
284 if (ioreq
->v
.niov
== 0 || ioreq
->mapped
== 1) {
288 ioreq
->pages
= xc_gnttab_map_grant_refs
289 (gnt
, ioreq
->v
.niov
, ioreq
->domids
, ioreq
->refs
, ioreq
->prot
);
290 if (ioreq
->pages
== NULL
) {
291 xen_be_printf(&ioreq
->blkdev
->xendev
, 0,
292 "can't map %d grant refs (%s, %d maps)\n",
293 ioreq
->v
.niov
, strerror(errno
), ioreq
->blkdev
->cnt_map
);
296 for (i
= 0; i
< ioreq
->v
.niov
; i
++) {
297 ioreq
->v
.iov
[i
].iov_base
= ioreq
->pages
+ i
* XC_PAGE_SIZE
+
298 (uintptr_t)ioreq
->v
.iov
[i
].iov_base
;
300 ioreq
->blkdev
->cnt_map
+= ioreq
->v
.niov
;
302 for (i
= 0; i
< ioreq
->v
.niov
; i
++) {
303 ioreq
->page
[i
] = xc_gnttab_map_grant_ref
304 (gnt
, ioreq
->domids
[i
], ioreq
->refs
[i
], ioreq
->prot
);
305 if (ioreq
->page
[i
] == NULL
) {
306 xen_be_printf(&ioreq
->blkdev
->xendev
, 0,
307 "can't map grant ref %d (%s, %d maps)\n",
308 ioreq
->refs
[i
], strerror(errno
), ioreq
->blkdev
->cnt_map
);
312 ioreq
->v
.iov
[i
].iov_base
= ioreq
->page
[i
] + (uintptr_t)ioreq
->v
.iov
[i
].iov_base
;
313 ioreq
->blkdev
->cnt_map
++;
320 static int ioreq_runio_qemu_aio(struct ioreq
*ioreq
);
322 static void qemu_aio_complete(void *opaque
, int ret
)
324 struct ioreq
*ioreq
= opaque
;
327 xen_be_printf(&ioreq
->blkdev
->xendev
, 0, "%s I/O error\n",
328 ioreq
->req
.operation
== BLKIF_OP_READ
? "read" : "write");
332 ioreq
->aio_inflight
--;
333 if (ioreq
->presync
) {
335 ioreq_runio_qemu_aio(ioreq
);
338 if (ioreq
->aio_inflight
> 0) {
341 if (ioreq
->postsync
) {
343 ioreq
->aio_inflight
++;
344 bdrv_aio_flush(ioreq
->blkdev
->bs
, qemu_aio_complete
, ioreq
);
348 ioreq
->status
= ioreq
->aio_errors
? BLKIF_RSP_ERROR
: BLKIF_RSP_OKAY
;
351 bdrv_acct_done(ioreq
->blkdev
->bs
, &ioreq
->acct
);
352 qemu_bh_schedule(ioreq
->blkdev
->bh
);
355 static int ioreq_runio_qemu_aio(struct ioreq
*ioreq
)
357 struct XenBlkDev
*blkdev
= ioreq
->blkdev
;
359 if (ioreq
->req
.nr_segments
&& ioreq_map(ioreq
) == -1) {
363 ioreq
->aio_inflight
++;
364 if (ioreq
->presync
) {
365 bdrv_aio_flush(ioreq
->blkdev
->bs
, qemu_aio_complete
, ioreq
);
369 switch (ioreq
->req
.operation
) {
371 bdrv_acct_start(blkdev
->bs
, &ioreq
->acct
, ioreq
->v
.size
, BDRV_ACCT_READ
);
372 ioreq
->aio_inflight
++;
373 bdrv_aio_readv(blkdev
->bs
, ioreq
->start
/ BLOCK_SIZE
,
374 &ioreq
->v
, ioreq
->v
.size
/ BLOCK_SIZE
,
375 qemu_aio_complete
, ioreq
);
378 case BLKIF_OP_WRITE_BARRIER
:
379 if (!ioreq
->req
.nr_segments
) {
383 bdrv_acct_start(blkdev
->bs
, &ioreq
->acct
, ioreq
->v
.size
, BDRV_ACCT_WRITE
);
384 ioreq
->aio_inflight
++;
385 bdrv_aio_writev(blkdev
->bs
, ioreq
->start
/ BLOCK_SIZE
,
386 &ioreq
->v
, ioreq
->v
.size
/ BLOCK_SIZE
,
387 qemu_aio_complete
, ioreq
);
390 /* unknown operation (shouldn't happen -- parse catches this) */
394 qemu_aio_complete(ioreq
, 0);
402 ioreq
->status
= BLKIF_RSP_ERROR
;
406 static int blk_send_response_one(struct ioreq
*ioreq
)
408 struct XenBlkDev
*blkdev
= ioreq
->blkdev
;
410 int have_requests
= 0;
411 blkif_response_t resp
;
414 resp
.id
= ioreq
->req
.id
;
415 resp
.operation
= ioreq
->req
.operation
;
416 resp
.status
= ioreq
->status
;
418 /* Place on the response ring for the relevant domain. */
419 switch (blkdev
->protocol
) {
420 case BLKIF_PROTOCOL_NATIVE
:
421 dst
= RING_GET_RESPONSE(&blkdev
->rings
.native
, blkdev
->rings
.native
.rsp_prod_pvt
);
423 case BLKIF_PROTOCOL_X86_32
:
424 dst
= RING_GET_RESPONSE(&blkdev
->rings
.x86_32_part
,
425 blkdev
->rings
.x86_32_part
.rsp_prod_pvt
);
427 case BLKIF_PROTOCOL_X86_64
:
428 dst
= RING_GET_RESPONSE(&blkdev
->rings
.x86_64_part
,
429 blkdev
->rings
.x86_64_part
.rsp_prod_pvt
);
434 memcpy(dst
, &resp
, sizeof(resp
));
435 blkdev
->rings
.common
.rsp_prod_pvt
++;
437 RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&blkdev
->rings
.common
, send_notify
);
438 if (blkdev
->rings
.common
.rsp_prod_pvt
== blkdev
->rings
.common
.req_cons
) {
440 * Tail check for pending requests. Allows frontend to avoid
441 * notifications if requests are already in flight (lower
442 * overheads and promotes batching).
444 RING_FINAL_CHECK_FOR_REQUESTS(&blkdev
->rings
.common
, have_requests
);
445 } else if (RING_HAS_UNCONSUMED_REQUESTS(&blkdev
->rings
.common
)) {
455 /* walk finished list, send outstanding responses, free requests */
456 static void blk_send_response_all(struct XenBlkDev
*blkdev
)
461 while (!QLIST_EMPTY(&blkdev
->finished
)) {
462 ioreq
= QLIST_FIRST(&blkdev
->finished
);
463 send_notify
+= blk_send_response_one(ioreq
);
464 ioreq_release(ioreq
, true);
467 xen_be_send_notify(&blkdev
->xendev
);
471 static int blk_get_request(struct XenBlkDev
*blkdev
, struct ioreq
*ioreq
, RING_IDX rc
)
473 switch (blkdev
->protocol
) {
474 case BLKIF_PROTOCOL_NATIVE
:
475 memcpy(&ioreq
->req
, RING_GET_REQUEST(&blkdev
->rings
.native
, rc
),
478 case BLKIF_PROTOCOL_X86_32
:
479 blkif_get_x86_32_req(&ioreq
->req
,
480 RING_GET_REQUEST(&blkdev
->rings
.x86_32_part
, rc
));
482 case BLKIF_PROTOCOL_X86_64
:
483 blkif_get_x86_64_req(&ioreq
->req
,
484 RING_GET_REQUEST(&blkdev
->rings
.x86_64_part
, rc
));
490 static void blk_handle_requests(struct XenBlkDev
*blkdev
)
495 blkdev
->more_work
= 0;
497 rc
= blkdev
->rings
.common
.req_cons
;
498 rp
= blkdev
->rings
.common
.sring
->req_prod
;
499 xen_rmb(); /* Ensure we see queued requests up to 'rp'. */
501 blk_send_response_all(blkdev
);
503 /* pull request from ring */
504 if (RING_REQUEST_CONS_OVERFLOW(&blkdev
->rings
.common
, rc
)) {
507 ioreq
= ioreq_start(blkdev
);
512 blk_get_request(blkdev
, ioreq
, rc
);
513 blkdev
->rings
.common
.req_cons
= ++rc
;
516 if (ioreq_parse(ioreq
) != 0) {
517 if (blk_send_response_one(ioreq
)) {
518 xen_be_send_notify(&blkdev
->xendev
);
520 ioreq_release(ioreq
, false);
524 ioreq_runio_qemu_aio(ioreq
);
527 if (blkdev
->more_work
&& blkdev
->requests_inflight
< max_requests
) {
528 qemu_bh_schedule(blkdev
->bh
);
532 /* ------------------------------------------------------------- */
534 static void blk_bh(void *opaque
)
536 struct XenBlkDev
*blkdev
= opaque
;
537 blk_handle_requests(blkdev
);
540 static void blk_alloc(struct XenDevice
*xendev
)
542 struct XenBlkDev
*blkdev
= container_of(xendev
, struct XenBlkDev
, xendev
);
544 QLIST_INIT(&blkdev
->inflight
);
545 QLIST_INIT(&blkdev
->finished
);
546 QLIST_INIT(&blkdev
->freelist
);
547 blkdev
->bh
= qemu_bh_new(blk_bh
, blkdev
);
548 if (xen_mode
!= XEN_EMULATE
) {
553 static int blk_init(struct XenDevice
*xendev
)
555 struct XenBlkDev
*blkdev
= container_of(xendev
, struct XenBlkDev
, xendev
);
556 int index
, qflags
, info
= 0;
558 /* read xenstore entries */
559 if (blkdev
->params
== NULL
) {
561 blkdev
->params
= xenstore_read_be_str(&blkdev
->xendev
, "params");
562 if (blkdev
->params
!= NULL
) {
563 h
= strchr(blkdev
->params
, ':');
566 blkdev
->fileproto
= blkdev
->params
;
567 blkdev
->filename
= h
+1;
570 blkdev
->fileproto
= "<unset>";
571 blkdev
->filename
= blkdev
->params
;
574 if (!strcmp("aio", blkdev
->fileproto
)) {
575 blkdev
->fileproto
= "raw";
577 if (blkdev
->mode
== NULL
) {
578 blkdev
->mode
= xenstore_read_be_str(&blkdev
->xendev
, "mode");
580 if (blkdev
->type
== NULL
) {
581 blkdev
->type
= xenstore_read_be_str(&blkdev
->xendev
, "type");
583 if (blkdev
->dev
== NULL
) {
584 blkdev
->dev
= xenstore_read_be_str(&blkdev
->xendev
, "dev");
586 if (blkdev
->devtype
== NULL
) {
587 blkdev
->devtype
= xenstore_read_be_str(&blkdev
->xendev
, "device-type");
590 /* do we have all we need? */
591 if (blkdev
->params
== NULL
||
592 blkdev
->mode
== NULL
||
593 blkdev
->type
== NULL
||
594 blkdev
->dev
== NULL
) {
599 qflags
= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
| BDRV_O_NATIVE_AIO
;
600 if (strcmp(blkdev
->mode
, "w") == 0) {
601 qflags
|= BDRV_O_RDWR
;
603 info
|= VDISK_READONLY
;
607 if (blkdev
->devtype
&& !strcmp(blkdev
->devtype
, "cdrom")) {
611 /* init qemu block driver */
612 index
= (blkdev
->xendev
.dev
- 202 * 256) / 16;
613 blkdev
->dinfo
= drive_get(IF_XEN
, 0, index
);
614 if (!blkdev
->dinfo
) {
615 /* setup via xenbus -> create new block driver instance */
616 xen_be_printf(&blkdev
->xendev
, 2, "create new bdrv (xenbus setup)\n");
617 blkdev
->bs
= bdrv_new(blkdev
->dev
);
619 if (bdrv_open(blkdev
->bs
, blkdev
->filename
, qflags
,
620 bdrv_find_whitelisted_format(blkdev
->fileproto
)) != 0) {
621 bdrv_delete(blkdev
->bs
);
629 /* setup via qemu cmdline -> already setup for us */
630 xen_be_printf(&blkdev
->xendev
, 2, "get configured bdrv (cmdline setup)\n");
631 blkdev
->bs
= blkdev
->dinfo
->bdrv
;
633 bdrv_attach_dev_nofail(blkdev
->bs
, blkdev
);
634 blkdev
->file_blk
= BLOCK_SIZE
;
635 blkdev
->file_size
= bdrv_getlength(blkdev
->bs
);
636 if (blkdev
->file_size
< 0) {
637 xen_be_printf(&blkdev
->xendev
, 1, "bdrv_getlength: %d (%s) | drv %s\n",
638 (int)blkdev
->file_size
, strerror(-blkdev
->file_size
),
639 blkdev
->bs
->drv
? blkdev
->bs
->drv
->format_name
: "-");
640 blkdev
->file_size
= 0;
643 xen_be_printf(xendev
, 1, "type \"%s\", fileproto \"%s\", filename \"%s\","
644 " size %" PRId64
" (%" PRId64
" MB)\n",
645 blkdev
->type
, blkdev
->fileproto
, blkdev
->filename
,
646 blkdev
->file_size
, blkdev
->file_size
>> 20);
649 xenstore_write_be_int(&blkdev
->xendev
, "feature-barrier", 1);
650 xenstore_write_be_int(&blkdev
->xendev
, "info", info
);
651 xenstore_write_be_int(&blkdev
->xendev
, "sector-size", blkdev
->file_blk
);
652 xenstore_write_be_int(&blkdev
->xendev
, "sectors",
653 blkdev
->file_size
/ blkdev
->file_blk
);
657 g_free(blkdev
->params
);
658 blkdev
->params
= NULL
;
659 g_free(blkdev
->mode
);
661 g_free(blkdev
->type
);
665 g_free(blkdev
->devtype
);
666 blkdev
->devtype
= NULL
;
670 static int blk_connect(struct XenDevice
*xendev
)
672 struct XenBlkDev
*blkdev
= container_of(xendev
, struct XenBlkDev
, xendev
);
674 if (xenstore_read_fe_int(&blkdev
->xendev
, "ring-ref", &blkdev
->ring_ref
) == -1) {
677 if (xenstore_read_fe_int(&blkdev
->xendev
, "event-channel",
678 &blkdev
->xendev
.remote_port
) == -1) {
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
;
687 if (strcmp(blkdev
->xendev
.protocol
, XEN_IO_PROTO_ABI_X86_64
) == 0) {
688 blkdev
->protocol
= BLKIF_PROTOCOL_X86_64
;
692 blkdev
->sring
= xc_gnttab_map_grant_ref(blkdev
->xendev
.gnttabdev
,
695 PROT_READ
| PROT_WRITE
);
696 if (!blkdev
->sring
) {
701 switch (blkdev
->protocol
) {
702 case BLKIF_PROTOCOL_NATIVE
:
704 blkif_sring_t
*sring_native
= blkdev
->sring
;
705 BACK_RING_INIT(&blkdev
->rings
.native
, sring_native
, XC_PAGE_SIZE
);
708 case BLKIF_PROTOCOL_X86_32
:
710 blkif_x86_32_sring_t
*sring_x86_32
= blkdev
->sring
;
712 BACK_RING_INIT(&blkdev
->rings
.x86_32_part
, sring_x86_32
, XC_PAGE_SIZE
);
715 case BLKIF_PROTOCOL_X86_64
:
717 blkif_x86_64_sring_t
*sring_x86_64
= blkdev
->sring
;
719 BACK_RING_INIT(&blkdev
->rings
.x86_64_part
, sring_x86_64
, XC_PAGE_SIZE
);
724 xen_be_bind_evtchn(&blkdev
->xendev
);
726 xen_be_printf(&blkdev
->xendev
, 1, "ok: proto %s, ring-ref %d, "
727 "remote port %d, local port %d\n",
728 blkdev
->xendev
.protocol
, blkdev
->ring_ref
,
729 blkdev
->xendev
.remote_port
, blkdev
->xendev
.local_port
);
733 static void blk_disconnect(struct XenDevice
*xendev
)
735 struct XenBlkDev
*blkdev
= container_of(xendev
, struct XenBlkDev
, xendev
);
738 if (!blkdev
->dinfo
) {
739 /* close/delete only if we created it ourself */
740 bdrv_close(blkdev
->bs
);
741 bdrv_detach_dev(blkdev
->bs
, blkdev
);
742 bdrv_delete(blkdev
->bs
);
746 xen_be_unbind_evtchn(&blkdev
->xendev
);
749 xc_gnttab_munmap(blkdev
->xendev
.gnttabdev
, blkdev
->sring
, 1);
751 blkdev
->sring
= NULL
;
755 static int blk_free(struct XenDevice
*xendev
)
757 struct XenBlkDev
*blkdev
= container_of(xendev
, struct XenBlkDev
, xendev
);
760 if (blkdev
->bs
|| blkdev
->sring
) {
761 blk_disconnect(xendev
);
764 while (!QLIST_EMPTY(&blkdev
->freelist
)) {
765 ioreq
= QLIST_FIRST(&blkdev
->freelist
);
766 QLIST_REMOVE(ioreq
, list
);
767 qemu_iovec_destroy(&ioreq
->v
);
771 g_free(blkdev
->params
);
772 g_free(blkdev
->mode
);
773 g_free(blkdev
->type
);
775 g_free(blkdev
->devtype
);
776 qemu_bh_delete(blkdev
->bh
);
780 static void blk_event(struct XenDevice
*xendev
)
782 struct XenBlkDev
*blkdev
= container_of(xendev
, struct XenBlkDev
, xendev
);
784 qemu_bh_schedule(blkdev
->bh
);
787 struct XenDevOps xen_blkdev_ops
= {
788 .size
= sizeof(struct XenBlkDev
),
789 .flags
= DEVOPS_FLAG_NEED_GNTDEV
,
792 .initialise
= blk_connect
,
793 .disconnect
= blk_disconnect
,