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, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
30 #include <sys/ioctl.h>
31 #include <sys/types.h>
38 #include <xen/io/xenbus.h>
41 #include "block_int.h"
42 #include "qemu-char.h"
43 #include "xen_blkif.h"
44 #include "xen_backend.h"
46 /* ------------------------------------------------------------- */
48 static int syncwrite
= 0;
49 static int batch_maps
= 0;
51 static int max_requests
= 32;
52 static int use_aio
= 1;
54 /* ------------------------------------------------------------- */
56 #define BLOCK_SIZE 512
57 #define IOCB_COUNT (BLKIF_MAX_SEGMENTS_PER_REQUEST + 2)
70 uint32_t domids
[BLKIF_MAX_SEGMENTS_PER_REQUEST
];
71 uint32_t refs
[BLKIF_MAX_SEGMENTS_PER_REQUEST
];
73 void *page
[BLKIF_MAX_SEGMENTS_PER_REQUEST
];
80 struct XenBlkDev
*blkdev
;
81 LIST_ENTRY(ioreq
) list
;
85 struct XenDevice xendev
; /* must be first */
91 const char *fileproto
;
98 blkif_back_rings_t rings
;
103 LIST_HEAD(inflight_head
, ioreq
) inflight
;
104 LIST_HEAD(finished_head
, ioreq
) finished
;
105 LIST_HEAD(freelist_head
, ioreq
) freelist
;
107 int requests_inflight
;
108 int requests_finished
;
110 /* qemu block driver */
112 BlockDriverState
*bs
;
116 /* ------------------------------------------------------------- */
118 static struct ioreq
*ioreq_start(struct XenBlkDev
*blkdev
)
120 struct ioreq
*ioreq
= NULL
;
122 if (LIST_EMPTY(&blkdev
->freelist
)) {
123 if (blkdev
->requests_total
>= max_requests
)
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
);
131 /* get one from freelist */
132 ioreq
= LIST_FIRST(&blkdev
->freelist
);
133 LIST_REMOVE(ioreq
, list
);
134 qemu_iovec_reset(&ioreq
->v
);
136 LIST_INSERT_HEAD(&blkdev
->inflight
, ioreq
, list
);
137 blkdev
->requests_inflight
++;
143 static void ioreq_finish(struct ioreq
*ioreq
)
145 struct XenBlkDev
*blkdev
= ioreq
->blkdev
;
147 LIST_REMOVE(ioreq
, list
);
148 LIST_INSERT_HEAD(&blkdev
->finished
, ioreq
, list
);
149 blkdev
->requests_inflight
--;
150 blkdev
->requests_finished
++;
153 static void ioreq_release(struct ioreq
*ioreq
)
155 struct XenBlkDev
*blkdev
= ioreq
->blkdev
;
157 LIST_REMOVE(ioreq
, list
);
158 memset(ioreq
, 0, sizeof(*ioreq
));
159 ioreq
->blkdev
= blkdev
;
160 LIST_INSERT_HEAD(&blkdev
->freelist
, ioreq
, list
);
161 blkdev
->requests_finished
--;
165 * translate request into iovec + start offset
166 * do sanity checks along the way
168 static int ioreq_parse(struct ioreq
*ioreq
)
170 struct XenBlkDev
*blkdev
= ioreq
->blkdev
;
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
) {
181 ioreq
->prot
= PROT_WRITE
; /* to memory */
182 if (BLKIF_OP_READ
!= ioreq
->req
.operation
&& blkdev
->mode
[0] != 'w') {
183 xen_be_printf(&blkdev
->xendev
, 0, "error: write req for ro device\n");
187 case BLKIF_OP_WRITE_BARRIER
:
189 ioreq
->presync
= ioreq
->postsync
= 1;
192 ioreq
->prot
= PROT_READ
; /* from memory */
197 xen_be_printf(&blkdev
->xendev
, 0, "error: unknown operation (%d)\n",
198 ioreq
->req
.operation
);
202 ioreq
->start
= ioreq
->req
.sector_number
* blkdev
->file_blk
;
203 for (i
= 0; i
< ioreq
->req
.nr_segments
; i
++) {
204 if (i
== BLKIF_MAX_SEGMENTS_PER_REQUEST
) {
205 xen_be_printf(&blkdev
->xendev
, 0, "error: nr_segments too big\n");
208 if (ioreq
->req
.seg
[i
].first_sect
> ioreq
->req
.seg
[i
].last_sect
) {
209 xen_be_printf(&blkdev
->xendev
, 0, "error: first > last sector\n");
212 if (ioreq
->req
.seg
[i
].last_sect
* BLOCK_SIZE
>= XC_PAGE_SIZE
) {
213 xen_be_printf(&blkdev
->xendev
, 0, "error: page crossing\n");
217 ioreq
->domids
[i
] = blkdev
->xendev
.dom
;
218 ioreq
->refs
[i
] = ioreq
->req
.seg
[i
].gref
;
220 mem
= ioreq
->req
.seg
[i
].first_sect
* blkdev
->file_blk
;
221 len
= (ioreq
->req
.seg
[i
].last_sect
- ioreq
->req
.seg
[i
].first_sect
+ 1) * blkdev
->file_blk
;
222 qemu_iovec_add(&ioreq
->v
, (void*)mem
, len
);
224 if (ioreq
->start
+ ioreq
->v
.size
> blkdev
->file_size
) {
225 xen_be_printf(&blkdev
->xendev
, 0, "error: access beyond end of file\n");
231 ioreq
->status
= BLKIF_RSP_ERROR
;
235 static void ioreq_unmap(struct ioreq
*ioreq
)
237 int gnt
= ioreq
->blkdev
->xendev
.gnttabdev
;
240 if (ioreq
->v
.niov
== 0)
245 if (xc_gnttab_munmap(gnt
, ioreq
->pages
, ioreq
->v
.niov
) != 0)
246 xen_be_printf(&ioreq
->blkdev
->xendev
, 0, "xc_gnttab_munmap failed: %s\n",
248 ioreq
->blkdev
->cnt_map
-= ioreq
->v
.niov
;
251 for (i
= 0; i
< ioreq
->v
.niov
; i
++) {
254 if (xc_gnttab_munmap(gnt
, ioreq
->page
[i
], 1) != 0)
255 xen_be_printf(&ioreq
->blkdev
->xendev
, 0, "xc_gnttab_munmap failed: %s\n",
257 ioreq
->blkdev
->cnt_map
--;
258 ioreq
->page
[i
] = NULL
;
263 static int ioreq_map(struct ioreq
*ioreq
)
265 int gnt
= ioreq
->blkdev
->xendev
.gnttabdev
;
268 if (ioreq
->v
.niov
== 0)
271 ioreq
->pages
= xc_gnttab_map_grant_refs
272 (gnt
, ioreq
->v
.niov
, ioreq
->domids
, ioreq
->refs
, ioreq
->prot
);
273 if (ioreq
->pages
== NULL
) {
274 xen_be_printf(&ioreq
->blkdev
->xendev
, 0,
275 "can't map %d grant refs (%s, %d maps)\n",
276 ioreq
->v
.niov
, strerror(errno
), ioreq
->blkdev
->cnt_map
);
279 for (i
= 0; i
< ioreq
->v
.niov
; i
++)
280 ioreq
->v
.iov
[i
].iov_base
= ioreq
->pages
+ i
* XC_PAGE_SIZE
+
281 (uintptr_t)ioreq
->v
.iov
[i
].iov_base
;
282 ioreq
->blkdev
->cnt_map
+= ioreq
->v
.niov
;
284 for (i
= 0; i
< ioreq
->v
.niov
; i
++) {
285 ioreq
->page
[i
] = xc_gnttab_map_grant_ref
286 (gnt
, ioreq
->domids
[i
], ioreq
->refs
[i
], ioreq
->prot
);
287 if (ioreq
->page
[i
] == NULL
) {
288 xen_be_printf(&ioreq
->blkdev
->xendev
, 0,
289 "can't map grant ref %d (%s, %d maps)\n",
290 ioreq
->refs
[i
], strerror(errno
), ioreq
->blkdev
->cnt_map
);
294 ioreq
->v
.iov
[i
].iov_base
= ioreq
->page
[i
] + (uintptr_t)ioreq
->v
.iov
[i
].iov_base
;
295 ioreq
->blkdev
->cnt_map
++;
301 static int ioreq_runio_qemu_sync(struct ioreq
*ioreq
)
303 struct XenBlkDev
*blkdev
= ioreq
->blkdev
;
307 if (ioreq_map(ioreq
) == -1)
310 bdrv_flush(blkdev
->bs
);
312 switch (ioreq
->req
.operation
) {
315 for (i
= 0; i
< ioreq
->v
.niov
; i
++) {
316 rc
= bdrv_read(blkdev
->bs
, pos
/ BLOCK_SIZE
,
317 ioreq
->v
.iov
[i
].iov_base
,
318 ioreq
->v
.iov
[i
].iov_len
/ BLOCK_SIZE
);
320 xen_be_printf(&blkdev
->xendev
, 0, "rd I/O error (%p, len %zd)\n",
321 ioreq
->v
.iov
[i
].iov_base
,
322 ioreq
->v
.iov
[i
].iov_len
);
325 len
+= ioreq
->v
.iov
[i
].iov_len
;
326 pos
+= ioreq
->v
.iov
[i
].iov_len
;
330 case BLKIF_OP_WRITE_BARRIER
:
332 for (i
= 0; i
< ioreq
->v
.niov
; i
++) {
333 rc
= bdrv_write(blkdev
->bs
, pos
/ BLOCK_SIZE
,
334 ioreq
->v
.iov
[i
].iov_base
,
335 ioreq
->v
.iov
[i
].iov_len
/ BLOCK_SIZE
);
337 xen_be_printf(&blkdev
->xendev
, 0, "wr I/O error (%p, len %zd)\n",
338 ioreq
->v
.iov
[i
].iov_base
,
339 ioreq
->v
.iov
[i
].iov_len
);
342 len
+= ioreq
->v
.iov
[i
].iov_len
;
343 pos
+= ioreq
->v
.iov
[i
].iov_len
;
347 /* unknown operation (shouldn't happen -- parse catches this) */
352 bdrv_flush(blkdev
->bs
);
353 ioreq
->status
= BLKIF_RSP_OKAY
;
360 ioreq
->status
= BLKIF_RSP_ERROR
;
364 static void qemu_aio_complete(void *opaque
, int ret
)
366 struct ioreq
*ioreq
= opaque
;
369 xen_be_printf(&ioreq
->blkdev
->xendev
, 0, "%s I/O error\n",
370 ioreq
->req
.operation
== BLKIF_OP_READ
? "read" : "write");
374 ioreq
->aio_inflight
--;
375 if (ioreq
->aio_inflight
> 0)
378 ioreq
->status
= ioreq
->aio_errors
? BLKIF_RSP_ERROR
: BLKIF_RSP_OKAY
;
381 qemu_bh_schedule(ioreq
->blkdev
->bh
);
384 static int ioreq_runio_qemu_aio(struct ioreq
*ioreq
)
386 struct XenBlkDev
*blkdev
= ioreq
->blkdev
;
388 if (ioreq_map(ioreq
) == -1)
391 ioreq
->aio_inflight
++;
393 bdrv_flush(blkdev
->bs
); /* FIXME: aio_flush() ??? */
395 switch (ioreq
->req
.operation
) {
397 ioreq
->aio_inflight
++;
398 bdrv_aio_readv(blkdev
->bs
, ioreq
->start
/ BLOCK_SIZE
,
399 &ioreq
->v
, ioreq
->v
.size
/ BLOCK_SIZE
,
400 qemu_aio_complete
, ioreq
);
403 case BLKIF_OP_WRITE_BARRIER
:
404 ioreq
->aio_inflight
++;
405 bdrv_aio_writev(blkdev
->bs
, ioreq
->start
/ BLOCK_SIZE
,
406 &ioreq
->v
, ioreq
->v
.size
/ BLOCK_SIZE
,
407 qemu_aio_complete
, ioreq
);
410 /* unknown operation (shouldn't happen -- parse catches this) */
415 bdrv_flush(blkdev
->bs
); /* FIXME: aio_flush() ??? */
416 qemu_aio_complete(ioreq
, 0);
421 ioreq
->status
= BLKIF_RSP_ERROR
;
425 static int blk_send_response_one(struct ioreq
*ioreq
)
427 struct XenBlkDev
*blkdev
= ioreq
->blkdev
;
429 int have_requests
= 0;
430 blkif_response_t resp
;
433 resp
.id
= ioreq
->req
.id
;
434 resp
.operation
= ioreq
->req
.operation
;
435 resp
.status
= ioreq
->status
;
437 /* Place on the response ring for the relevant domain. */
438 switch (blkdev
->protocol
) {
439 case BLKIF_PROTOCOL_NATIVE
:
440 dst
= RING_GET_RESPONSE(&blkdev
->rings
.native
, blkdev
->rings
.native
.rsp_prod_pvt
);
442 case BLKIF_PROTOCOL_X86_32
:
443 dst
= RING_GET_RESPONSE(&blkdev
->rings
.x86_32
, blkdev
->rings
.x86_32
.rsp_prod_pvt
);
445 case BLKIF_PROTOCOL_X86_64
:
446 dst
= RING_GET_RESPONSE(&blkdev
->rings
.x86_64
, blkdev
->rings
.x86_64
.rsp_prod_pvt
);
451 memcpy(dst
, &resp
, sizeof(resp
));
452 blkdev
->rings
.common
.rsp_prod_pvt
++;
454 RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&blkdev
->rings
.common
, send_notify
);
455 if (blkdev
->rings
.common
.rsp_prod_pvt
== blkdev
->rings
.common
.req_cons
) {
457 * Tail check for pending requests. Allows frontend to avoid
458 * notifications if requests are already in flight (lower
459 * overheads and promotes batching).
461 RING_FINAL_CHECK_FOR_REQUESTS(&blkdev
->rings
.common
, have_requests
);
462 } else if (RING_HAS_UNCONSUMED_REQUESTS(&blkdev
->rings
.common
)) {
471 /* walk finished list, send outstanding responses, free requests */
472 static void blk_send_response_all(struct XenBlkDev
*blkdev
)
477 while (!LIST_EMPTY(&blkdev
->finished
)) {
478 ioreq
= LIST_FIRST(&blkdev
->finished
);
479 send_notify
+= blk_send_response_one(ioreq
);
480 ioreq_release(ioreq
);
483 xen_be_send_notify(&blkdev
->xendev
);
486 static int blk_get_request(struct XenBlkDev
*blkdev
, struct ioreq
*ioreq
, RING_IDX rc
)
488 switch (blkdev
->protocol
) {
489 case BLKIF_PROTOCOL_NATIVE
:
490 memcpy(&ioreq
->req
, RING_GET_REQUEST(&blkdev
->rings
.native
, rc
),
493 case BLKIF_PROTOCOL_X86_32
:
494 blkif_get_x86_32_req(&ioreq
->req
, RING_GET_REQUEST(&blkdev
->rings
.x86_32
, rc
));
496 case BLKIF_PROTOCOL_X86_64
:
497 blkif_get_x86_64_req(&ioreq
->req
, RING_GET_REQUEST(&blkdev
->rings
.x86_64
, rc
));
503 static void blk_handle_requests(struct XenBlkDev
*blkdev
)
508 blkdev
->more_work
= 0;
510 rc
= blkdev
->rings
.common
.req_cons
;
511 rp
= blkdev
->rings
.common
.sring
->req_prod
;
512 xen_rmb(); /* Ensure we see queued requests up to 'rp'. */
515 blk_send_response_all(blkdev
);
517 /* pull request from ring */
518 if (RING_REQUEST_CONS_OVERFLOW(&blkdev
->rings
.common
, rc
))
520 ioreq
= ioreq_start(blkdev
);
525 blk_get_request(blkdev
, ioreq
, rc
);
526 blkdev
->rings
.common
.req_cons
= ++rc
;
529 if (ioreq_parse(ioreq
) != 0) {
530 if (blk_send_response_one(ioreq
))
531 xen_be_send_notify(&blkdev
->xendev
);
532 ioreq_release(ioreq
);
537 /* run i/o in aio mode */
538 ioreq_runio_qemu_aio(ioreq
);
540 /* run i/o in sync mode */
541 ioreq_runio_qemu_sync(ioreq
);
545 blk_send_response_all(blkdev
);
547 if (blkdev
->more_work
&& blkdev
->requests_inflight
< max_requests
)
548 qemu_bh_schedule(blkdev
->bh
);
551 /* ------------------------------------------------------------- */
553 static void blk_bh(void *opaque
)
555 struct XenBlkDev
*blkdev
= opaque
;
556 blk_handle_requests(blkdev
);
559 static void blk_alloc(struct XenDevice
*xendev
)
561 struct XenBlkDev
*blkdev
= container_of(xendev
, struct XenBlkDev
, xendev
);
563 LIST_INIT(&blkdev
->inflight
);
564 LIST_INIT(&blkdev
->finished
);
565 LIST_INIT(&blkdev
->freelist
);
566 blkdev
->bh
= qemu_bh_new(blk_bh
, blkdev
);
567 if (xen_mode
!= XEN_EMULATE
)
571 static int blk_init(struct XenDevice
*xendev
)
573 struct XenBlkDev
*blkdev
= container_of(xendev
, struct XenBlkDev
, xendev
);
574 int mode
, qflags
, have_barriers
, info
= 0;
577 /* read xenstore entries */
578 if (blkdev
->params
== NULL
) {
579 blkdev
->params
= xenstore_read_be_str(&blkdev
->xendev
, "params");
580 h
= strchr(blkdev
->params
, ':');
582 blkdev
->fileproto
= blkdev
->params
;
583 blkdev
->filename
= h
+1;
586 blkdev
->fileproto
= "<unset>";
587 blkdev
->filename
= blkdev
->params
;
590 if (blkdev
->mode
== NULL
)
591 blkdev
->mode
= xenstore_read_be_str(&blkdev
->xendev
, "mode");
592 if (blkdev
->type
== NULL
)
593 blkdev
->type
= xenstore_read_be_str(&blkdev
->xendev
, "type");
594 if (blkdev
->dev
== NULL
)
595 blkdev
->dev
= xenstore_read_be_str(&blkdev
->xendev
, "dev");
596 if (blkdev
->devtype
== NULL
)
597 blkdev
->devtype
= xenstore_read_be_str(&blkdev
->xendev
, "device-type");
599 /* do we have all we need? */
600 if (blkdev
->params
== NULL
||
601 blkdev
->mode
== NULL
||
602 blkdev
->type
== NULL
||
607 if (strcmp(blkdev
->mode
, "w") == 0) {
609 qflags
= BDRV_O_RDWR
;
612 qflags
= BDRV_O_RDONLY
;
613 info
|= VDISK_READONLY
;
617 if (blkdev
->devtype
&& !strcmp(blkdev
->devtype
, "cdrom"))
620 /* init qemu block driver */
621 blkdev
->index
= (blkdev
->xendev
.dev
- 202 * 256) / 16;
622 blkdev
->index
= drive_get_index(IF_XEN
, 0, blkdev
->index
);
623 if (blkdev
->index
== -1) {
624 /* setup via xenbus -> create new block driver instance */
625 xen_be_printf(&blkdev
->xendev
, 2, "create new bdrv (xenbus setup)\n");
626 blkdev
->bs
= bdrv_new(blkdev
->dev
);
628 if (bdrv_open2(blkdev
->bs
, blkdev
->filename
, qflags
,
629 bdrv_find_format(blkdev
->fileproto
)) != 0) {
630 bdrv_delete(blkdev
->bs
);
637 /* setup via qemu cmdline -> already setup for us */
638 xen_be_printf(&blkdev
->xendev
, 2, "get configured bdrv (cmdline setup)\n");
639 blkdev
->bs
= drives_table
[blkdev
->index
].bdrv
;
641 blkdev
->file_blk
= BLOCK_SIZE
;
642 blkdev
->file_size
= bdrv_getlength(blkdev
->bs
);
643 if (blkdev
->file_size
< 0) {
644 xen_be_printf(&blkdev
->xendev
, 1, "bdrv_getlength: %d (%s) | drv %s\n",
645 (int)blkdev
->file_size
, strerror(-blkdev
->file_size
),
646 blkdev
->bs
->drv
? blkdev
->bs
->drv
->format_name
: "-");
647 blkdev
->file_size
= 0;
649 have_barriers
= blkdev
->bs
->drv
&& blkdev
->bs
->drv
->bdrv_flush
? 1 : 0;
651 xen_be_printf(xendev
, 1, "type \"%s\", fileproto \"%s\", filename \"%s\","
652 " size %" PRId64
" (%" PRId64
" MB)\n",
653 blkdev
->type
, blkdev
->fileproto
, blkdev
->filename
,
654 blkdev
->file_size
, blkdev
->file_size
>> 20);
657 xenstore_write_be_int(&blkdev
->xendev
, "feature-barrier", have_barriers
);
658 xenstore_write_be_int(&blkdev
->xendev
, "info", info
);
659 xenstore_write_be_int(&blkdev
->xendev
, "sector-size", blkdev
->file_blk
);
660 xenstore_write_be_int(&blkdev
->xendev
, "sectors",
661 blkdev
->file_size
/ blkdev
->file_blk
);
665 static int blk_connect(struct XenDevice
*xendev
)
667 struct XenBlkDev
*blkdev
= container_of(xendev
, struct XenBlkDev
, xendev
);
669 if (xenstore_read_fe_int(&blkdev
->xendev
, "ring-ref", &blkdev
->ring_ref
) == -1)
671 if (xenstore_read_fe_int(&blkdev
->xendev
, "event-channel",
672 &blkdev
->xendev
.remote_port
) == -1)
675 blkdev
->protocol
= BLKIF_PROTOCOL_NATIVE
;
676 if (blkdev
->xendev
.protocol
) {
677 if (strcmp(blkdev
->xendev
.protocol
, XEN_IO_PROTO_ABI_X86_32
) == 0)
678 blkdev
->protocol
= BLKIF_PROTOCOL_X86_32
;
679 if (strcmp(blkdev
->xendev
.protocol
, XEN_IO_PROTO_ABI_X86_64
) == 0)
680 blkdev
->protocol
= BLKIF_PROTOCOL_X86_64
;
683 blkdev
->sring
= xc_gnttab_map_grant_ref(blkdev
->xendev
.gnttabdev
,
686 PROT_READ
| PROT_WRITE
);
691 switch (blkdev
->protocol
) {
692 case BLKIF_PROTOCOL_NATIVE
:
694 blkif_sring_t
*sring_native
= blkdev
->sring
;
695 BACK_RING_INIT(&blkdev
->rings
.native
, sring_native
, XC_PAGE_SIZE
);
698 case BLKIF_PROTOCOL_X86_32
:
700 blkif_x86_32_sring_t
*sring_x86_32
= blkdev
->sring
;
701 BACK_RING_INIT(&blkdev
->rings
.x86_32
, sring_x86_32
, XC_PAGE_SIZE
);
704 case BLKIF_PROTOCOL_X86_64
:
706 blkif_x86_64_sring_t
*sring_x86_64
= blkdev
->sring
;
707 BACK_RING_INIT(&blkdev
->rings
.x86_64
, sring_x86_64
, XC_PAGE_SIZE
);
712 xen_be_bind_evtchn(&blkdev
->xendev
);
714 xen_be_printf(&blkdev
->xendev
, 1, "ok: proto %s, ring-ref %d, "
715 "remote port %d, local port %d\n",
716 blkdev
->xendev
.protocol
, blkdev
->ring_ref
,
717 blkdev
->xendev
.remote_port
, blkdev
->xendev
.local_port
);
721 static void blk_disconnect(struct XenDevice
*xendev
)
723 struct XenBlkDev
*blkdev
= container_of(xendev
, struct XenBlkDev
, xendev
);
726 if (blkdev
->index
== -1) {
727 /* close/delete only if we created it ourself */
728 bdrv_close(blkdev
->bs
);
729 bdrv_delete(blkdev
->bs
);
733 xen_be_unbind_evtchn(&blkdev
->xendev
);
736 xc_gnttab_munmap(blkdev
->xendev
.gnttabdev
, blkdev
->sring
, 1);
738 blkdev
->sring
= NULL
;
742 static int blk_free(struct XenDevice
*xendev
)
744 struct XenBlkDev
*blkdev
= container_of(xendev
, struct XenBlkDev
, xendev
);
747 while (!LIST_EMPTY(&blkdev
->freelist
)) {
748 ioreq
= LIST_FIRST(&blkdev
->freelist
);
749 LIST_REMOVE(ioreq
, list
);
750 qemu_iovec_destroy(&ioreq
->v
);
754 qemu_free(blkdev
->params
);
755 qemu_free(blkdev
->mode
);
756 qemu_free(blkdev
->type
);
757 qemu_free(blkdev
->dev
);
758 qemu_free(blkdev
->devtype
);
759 qemu_bh_delete(blkdev
->bh
);
763 static void blk_event(struct XenDevice
*xendev
)
765 struct XenBlkDev
*blkdev
= container_of(xendev
, struct XenBlkDev
, xendev
);
767 qemu_bh_schedule(blkdev
->bh
);
770 struct XenDevOps xen_blkdev_ops
= {
771 .size
= sizeof(struct XenBlkDev
),
772 .flags
= DEVOPS_FLAG_NEED_GNTDEV
,
775 .connect
= blk_connect
,
776 .disconnect
= blk_disconnect
,