[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Xen-devel] [PATCH 5/7] xen: add block device backend driver.



This patch adds a block device backend driver to qemu.  It is a pure
userspace implemention using the gntdev interface.  It uses "qdisk" as
backend name in xenstore so it doesn't interfere with the other existing
backends (blkback aka "vbd" and tapdisk aka "tap").

Signed-off-by: Gerd Hoffmann <kraxel@xxxxxxxxxx>
---
 Makefile.target  |    2 +-
 hw/xen-backend.h |    2 +
 hw/xen-blkif.h   |  103 ++++++++
 hw/xen-disk.c    |  681 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 hw/xen-machine.c |    1 +
 sysemu.h         |    2 +-
 vl.c             |    4 +
 7 files changed, 793 insertions(+), 2 deletions(-)
 create mode 100644 hw/xen-blkif.h
 create mode 100644 hw/xen-disk.c

diff --git a/Makefile.target b/Makefile.target
index 66d41ee..2d599d2 100644
--- a/Makefile.target
+++ b/Makefile.target
@@ -517,7 +517,7 @@ endif
 
 # xen backend driver support
 XEN_OBJS := xen-machine.o xen-backend.o
-XEN_OBJS += xen-console.o xen-framebuffer.o
+XEN_OBJS += xen-console.o xen-framebuffer.o xen-disk.o
 ifeq ($(CONFIG_XEN), yes)
   OBJS += $(XEN_OBJS)
   LIBS += $(XEN_LIBS)
diff --git a/hw/xen-backend.h b/hw/xen-backend.h
index 3facf90..941b0a6 100644
--- a/hw/xen-backend.h
+++ b/hw/xen-backend.h
@@ -10,6 +10,7 @@
 
 #include "hw.h"
 #include "xen.h"
+#include "sysemu.h"
 
 /*
  * tweaks needed to build with different xen versions
@@ -118,6 +119,7 @@ void xen_be_printf(struct xendev *xendev, int msg_level, 
const char *fmt, ...)
 struct devops xen_console_ops;      /* xen_console.c     */
 struct devops xen_kbdmouse_ops;     /* xen_framebuffer.c */
 struct devops xen_framebuffer_ops;  /* xen_framebuffer.c */
+struct devops xen_blkdev_ops;       /* xen_disk.c        */
 
 void xen_set_display(int domid, DisplayState *ds);
 
diff --git a/hw/xen-blkif.h b/hw/xen-blkif.h
new file mode 100644
index 0000000..254a5fd
--- /dev/null
+++ b/hw/xen-blkif.h
@@ -0,0 +1,103 @@
+#ifndef __XEN_BLKIF_H__
+#define __XEN_BLKIF_H__
+
+#include <xen/io/ring.h>
+#include <xen/io/blkif.h>
+#include <xen/io/protocols.h>
+
+/* Not a real protocol.  Used to generate ring structs which contain
+ * the elements common to all protocols only.  This way we get a
+ * compiler-checkable way to use common struct elements, so we can
+ * avoid using switch(protocol) in a number of places.  */
+struct blkif_common_request {
+       char dummy;
+};
+struct blkif_common_response {
+       char dummy;
+};
+
+/* i386 protocol version */
+#pragma pack(push, 4)
+struct blkif_x86_32_request {
+       uint8_t        operation;    /* BLKIF_OP_???                         */
+       uint8_t        nr_segments;  /* number of segments                   */
+       blkif_vdev_t   handle;       /* only for read/write requests         */
+       uint64_t       id;           /* private guest value, echoed in resp  */
+       blkif_sector_t sector_number;/* start sector idx on disk (r/w only)  */
+       struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
+};
+struct blkif_x86_32_response {
+       uint64_t        id;              /* copied from request */
+       uint8_t         operation;       /* copied from request */
+       int16_t         status;          /* BLKIF_RSP_???       */
+};
+typedef struct blkif_x86_32_request blkif_x86_32_request_t;
+typedef struct blkif_x86_32_response blkif_x86_32_response_t;
+#pragma pack(pop)
+
+/* x86_64 protocol version */
+struct blkif_x86_64_request {
+       uint8_t        operation;    /* BLKIF_OP_???                         */
+       uint8_t        nr_segments;  /* number of segments                   */
+       blkif_vdev_t   handle;       /* only for read/write requests         */
+       uint64_t       __attribute__((__aligned__(8))) id;
+       blkif_sector_t sector_number;/* start sector idx on disk (r/w only)  */
+       struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
+};
+struct blkif_x86_64_response {
+       uint64_t       __attribute__((__aligned__(8))) id;
+       uint8_t         operation;       /* copied from request */
+       int16_t         status;          /* BLKIF_RSP_???       */
+};
+typedef struct blkif_x86_64_request blkif_x86_64_request_t;
+typedef struct blkif_x86_64_response blkif_x86_64_response_t;
+
+DEFINE_RING_TYPES(blkif_common, struct blkif_common_request, struct 
blkif_common_response);
+DEFINE_RING_TYPES(blkif_x86_32, struct blkif_x86_32_request, struct 
blkif_x86_32_response);
+DEFINE_RING_TYPES(blkif_x86_64, struct blkif_x86_64_request, struct 
blkif_x86_64_response);
+
+union blkif_back_rings {
+       blkif_back_ring_t        native;
+       blkif_common_back_ring_t common;
+       blkif_x86_32_back_ring_t x86_32;
+       blkif_x86_64_back_ring_t x86_64;
+};
+typedef union blkif_back_rings blkif_back_rings_t;
+
+enum blkif_protocol {
+       BLKIF_PROTOCOL_NATIVE = 1,
+       BLKIF_PROTOCOL_X86_32 = 2,
+       BLKIF_PROTOCOL_X86_64 = 3,
+};
+
+static void inline blkif_get_x86_32_req(blkif_request_t *dst, 
blkif_x86_32_request_t *src)
+{
+       int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST;
+
+       dst->operation = src->operation;
+       dst->nr_segments = src->nr_segments;
+       dst->handle = src->handle;
+       dst->id = src->id;
+       dst->sector_number = src->sector_number;
+       if (n > src->nr_segments)
+               n = src->nr_segments;
+       for (i = 0; i < n; i++)
+               dst->seg[i] = src->seg[i];
+}
+
+static void inline blkif_get_x86_64_req(blkif_request_t *dst, 
blkif_x86_64_request_t *src)
+{
+       int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST;
+
+       dst->operation = src->operation;
+       dst->nr_segments = src->nr_segments;
+       dst->handle = src->handle;
+       dst->id = src->id;
+       dst->sector_number = src->sector_number;
+       if (n > src->nr_segments)
+               n = src->nr_segments;
+       for (i = 0; i < n; i++)
+               dst->seg[i] = src->seg[i];
+}
+
+#endif /* __XEN_BLKIF_H__ */
diff --git a/hw/xen-disk.c b/hw/xen-disk.c
new file mode 100644
index 0000000..6947363
--- /dev/null
+++ b/hw/xen-disk.c
@@ -0,0 +1,681 @@
+/*
+ *  xen paravirt block device backend
+ *
+ *  FIXME: the code is designed to handle multiple outstanding
+ *  requests (using aio or using threads), which isn't used right
+ *  now due to limitations of the qemu block driver interface.
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; under version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+#include <signal.h>
+#include <inttypes.h>
+#include <time.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <pthread.h>
+#include <sys/utsname.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/uio.h>
+
+#include <xs.h>
+#include <xenctrl.h>
+#include <xen/io/xenbus.h>
+
+#include "list.h"
+
+#include "hw.h"
+#include "block_int.h"
+#include "qemu-char.h"
+#include "xen-blkif.h"
+#include "xen-backend.h"
+
+/* ------------------------------------------------------------- */
+
+#define BLOCK_SIZE  512
+#define IOCB_COUNT  (BLKIF_MAX_SEGMENTS_PER_REQUEST + 2)
+
+struct ioreq {
+    blkif_request_t     req;
+    int16_t             status;
+
+    /* parsed request */
+    off_t               start, end;
+    struct iovec        vec[BLKIF_MAX_SEGMENTS_PER_REQUEST];
+    int                 vecs;
+    int                 presync;
+    int                 postsync;
+
+    /* grant mapping */
+    uint32_t            domids[BLKIF_MAX_SEGMENTS_PER_REQUEST];
+    uint32_t            refs[BLKIF_MAX_SEGMENTS_PER_REQUEST];
+    int                 prot;
+    void                *page[BLKIF_MAX_SEGMENTS_PER_REQUEST];
+    void                *pages;
+
+    struct blkdev       *blkdev;
+    struct list_head    list;
+};
+
+struct blkdev {
+    struct xendev       xendev;  /* must be first */
+    char                *params;
+    char                *mode;
+    char                *type;
+    char                *dev;
+    char                *fileproto;
+    char                *filename;
+    int                 ring_ref;
+    void                *sring;
+    int                 file;
+    int64_t             file_blk;
+    int64_t             file_size;
+    int                 protocol;
+    blkif_back_rings_t  rings;
+    int                 more_work;
+    int                 cnt_map;
+
+    /* request lists */
+    struct list_head    inflight;
+    struct list_head    finished;
+    struct list_head    freelist;
+    int                 requests;
+
+    /* qemu block driver */
+    BlockDriverState    *bs;
+};
+
+static int syncwrite    = 0;
+static int batch_maps   = 0;
+static int max_requests = 32;
+
+/* ------------------------------------------------------------- */
+
+static struct ioreq *ioreq_start(struct blkdev *blkdev)
+{
+    struct ioreq *ioreq = NULL;
+
+    if (list_empty(&blkdev->freelist)) {
+       if (blkdev->requests >= max_requests)
+           goto out;
+       /* allocate new struct */
+       ioreq = malloc(sizeof(*ioreq));
+       if (NULL == ioreq)
+           goto out;
+       memset(ioreq, 0, sizeof(*ioreq));
+       ioreq->blkdev = blkdev;
+       blkdev->requests++;
+    } else {
+       /* get one from freelist */
+       ioreq = list_entry(blkdev->freelist.next, struct ioreq, list);
+       list_del(&ioreq->list);
+    }
+    list_add_tail(&ioreq->list, &blkdev->inflight);
+
+out:
+    return ioreq;
+}
+
+static void ioreq_finish(struct ioreq *ioreq)
+{
+    struct blkdev *blkdev = ioreq->blkdev;
+
+    list_del(&ioreq->list);
+    list_add_tail(&ioreq->list, &blkdev->finished);
+}
+
+static void ioreq_release(struct ioreq *ioreq)
+{
+    struct blkdev *blkdev = ioreq->blkdev;
+
+    list_del(&ioreq->list);
+    memset(ioreq, 0, sizeof(*ioreq));
+    ioreq->blkdev = blkdev;
+    list_add_tail(&ioreq->list, &blkdev->freelist);
+}
+
+/*
+ * translate request into iovec + start offset + end offset
+ * do sanity checks along the way
+ */
+static int ioreq_parse(struct ioreq *ioreq)
+{
+    struct blkdev *blkdev = ioreq->blkdev;
+    uintptr_t mem;
+    size_t len;
+    int i;
+
+    xen_be_printf(&blkdev->xendev, 3,
+                 "op %d, nr %d, handle %d, id %" PRId64 ", sector %" PRId64 
"\n",
+                 ioreq->req.operation, ioreq->req.nr_segments,
+                 ioreq->req.handle, ioreq->req.id, ioreq->req.sector_number);
+    switch (ioreq->req.operation) {
+    case BLKIF_OP_READ:
+       ioreq->prot = PROT_WRITE; /* to memory */
+       if (BLKIF_OP_READ != ioreq->req.operation && blkdev->mode[0] != 'w') {
+           xen_be_printf(&blkdev->xendev, 0, "error: write req for ro 
device\n");
+           goto err;
+       }
+       break;
+    case BLKIF_OP_WRITE_BARRIER:
+       if (!syncwrite)
+           ioreq->presync = ioreq->postsync = 1;
+       /* fall through */
+    case BLKIF_OP_WRITE:
+       ioreq->prot = PROT_READ; /* from memory */
+       if (syncwrite)
+           ioreq->postsync = 1;
+       break;
+    default:
+       xen_be_printf(&blkdev->xendev, 0, "error: unknown operation (%d)\n",
+                     ioreq->req.operation);
+       goto err;
+    };
+
+    ioreq->start = ioreq->end = ioreq->req.sector_number * blkdev->file_blk;
+    for (i = 0; i < ioreq->req.nr_segments; i++) {
+       if (i == BLKIF_MAX_SEGMENTS_PER_REQUEST) {
+           xen_be_printf(&blkdev->xendev, 0, "error: nr_segments too big\n");
+           goto err;
+       }
+       if (ioreq->req.seg[i].first_sect > ioreq->req.seg[i].last_sect) {
+           xen_be_printf(&blkdev->xendev, 0, "error: first > last sector\n");
+           goto err;
+       }
+       if (ioreq->req.seg[i].last_sect * BLOCK_SIZE >= XC_PAGE_SIZE) {
+           xen_be_printf(&blkdev->xendev, 0, "error: page crossing\n");
+           goto err;
+       }
+       len = (ioreq->req.seg[i].last_sect - ioreq->req.seg[i].first_sect + 1) 
* blkdev->file_blk;
+
+       ioreq->domids[i] = blkdev->xendev.dom;
+       ioreq->refs[i]   = ioreq->req.seg[i].gref;
+       mem = ioreq->req.seg[i].first_sect * blkdev->file_blk;
+
+       ioreq->vec[i].iov_base = (void*)mem;
+       ioreq->vec[i].iov_len  = len;
+       ioreq->end += len;
+    }
+    if (ioreq->end > blkdev->file_size) {
+       xen_be_printf(&blkdev->xendev, 0, "error: access beyond end of file\n");
+       goto err;
+    }
+    ioreq->vecs = i;
+    return 0;
+
+err:
+    ioreq->status = BLKIF_RSP_ERROR;
+    return -1;
+}
+
+static void ioreq_unmap(struct ioreq *ioreq)
+{
+    int gnt = ioreq->blkdev->xendev.gnttabdev;
+    int i;
+
+    if (batch_maps) {
+       if (!ioreq->pages)
+           return;
+       if (0 != xc_gnttab_munmap(gnt, ioreq->pages, ioreq->vecs))
+           xen_be_printf(&ioreq->blkdev->xendev, 0, "xc_gnttab_munmap failed: 
%s\n",
+                         strerror(errno));
+       ioreq->blkdev->cnt_map -= ioreq->vecs;
+       ioreq->pages = NULL;
+    } else {
+       for (i = 0; i < ioreq->vecs; i++) {
+           if (!ioreq->page[i])
+               continue;
+           if (0 != xc_gnttab_munmap(gnt, ioreq->page[i], 1))
+               xen_be_printf(&ioreq->blkdev->xendev, 0, "xc_gnttab_munmap 
failed: %s\n",
+                             strerror(errno));
+           ioreq->blkdev->cnt_map--;
+           ioreq->page[i] = NULL;
+       }
+    }
+}
+
+static int ioreq_map(struct ioreq *ioreq)
+{
+    int gnt = ioreq->blkdev->xendev.gnttabdev;
+    int i;
+
+    if (batch_maps) {
+       ioreq->pages = xc_gnttab_map_grant_refs
+           (gnt, ioreq->vecs, ioreq->domids, ioreq->refs, ioreq->prot);
+       if (NULL == ioreq->pages) {
+           xen_be_printf(&ioreq->blkdev->xendev, 0,
+                         "can't map %d grant refs (%s, %d maps)\n",
+                         ioreq->vecs, strerror(errno), ioreq->blkdev->cnt_map);
+           return -1;
+       }
+       for (i = 0; i < ioreq->vecs; i++)
+           ioreq->vec[i].iov_base = ioreq->pages + i * XC_PAGE_SIZE +
+               (uintptr_t)ioreq->vec[i].iov_base;
+       ioreq->blkdev->cnt_map += ioreq->vecs;
+    } else  {
+       for (i = 0; i < ioreq->vecs; i++) {
+           ioreq->page[i] = xc_gnttab_map_grant_ref
+               (gnt, ioreq->domids[i], ioreq->refs[i], ioreq->prot);
+           if (NULL == ioreq->page[i]) {
+               xen_be_printf(&ioreq->blkdev->xendev, 0,
+                             "can't map grant ref %d (%s, %d maps)\n",
+                             ioreq->refs[i], strerror(errno), 
ioreq->blkdev->cnt_map);
+               ioreq_unmap(ioreq);
+               return -1;
+           }
+           ioreq->vec[i].iov_base = ioreq->page[i] + 
(uintptr_t)ioreq->vec[i].iov_base;
+           ioreq->blkdev->cnt_map++;
+       }
+    }
+    return 0;
+}
+
+static int ioreq_runio_qemu(struct ioreq *ioreq)
+{
+    struct blkdev *blkdev = ioreq->blkdev;
+    int i, rc, len = 0;
+    off_t pos;
+
+    if (-1 == ioreq_map(ioreq))
+       goto err;
+    if (ioreq->presync)
+       bdrv_flush(blkdev->bs);
+
+    switch (ioreq->req.operation) {
+    case BLKIF_OP_READ:
+       pos = ioreq->start;
+       for (i = 0; i < ioreq->vecs; i++) {
+           rc = bdrv_read(blkdev->bs, pos / BLOCK_SIZE,
+                          ioreq->vec[i].iov_base,
+                          ioreq->vec[i].iov_len / BLOCK_SIZE);
+           if (rc != 0) {
+               xen_be_printf(&blkdev->xendev, 0, "rd I/O error (%p, len 
%zd)\n",
+                             ioreq->vec[i].iov_base,
+                             ioreq->vec[i].iov_len);
+               goto err;
+           }
+           len += ioreq->vec[i].iov_len;
+           pos += ioreq->vec[i].iov_len;
+       }
+       break;
+    case BLKIF_OP_WRITE:
+    case BLKIF_OP_WRITE_BARRIER:
+       pos = ioreq->start;
+       for (i = 0; i < ioreq->vecs; i++) {
+           rc = bdrv_write(blkdev->bs, pos / BLOCK_SIZE,
+                           ioreq->vec[i].iov_base,
+                           ioreq->vec[i].iov_len / BLOCK_SIZE);
+           if (rc != 0) {
+               xen_be_printf(&blkdev->xendev, 0, "wr I/O error (%p, len 
%zd)\n",
+                             ioreq->vec[i].iov_base,
+                             ioreq->vec[i].iov_len);
+               goto err;
+           }
+           len += ioreq->vec[i].iov_len;
+           pos += ioreq->vec[i].iov_len;
+       }
+       break;
+    default:
+       /* unknown operation (shouldn't happen -- parse catches this) */
+       goto err;
+    }
+
+    if (ioreq->postsync)
+       bdrv_flush(blkdev->bs);
+    ioreq->status = BLKIF_RSP_OKAY;
+
+    ioreq_unmap(ioreq);
+    return 0;
+
+err:
+    ioreq->status = BLKIF_RSP_ERROR;
+    return -1;
+}
+
+static int blk_send_response_one(struct ioreq *ioreq)
+{
+    struct blkdev     *blkdev = ioreq->blkdev;
+    int               send_notify   = 0;
+    int               have_requests = 0;
+    blkif_response_t  resp;
+    void              *dst;
+
+    resp.id        = ioreq->req.id;
+    resp.operation = ioreq->req.operation;
+    resp.status    = ioreq->status;
+
+    /* Place on the response ring for the relevant domain. */
+    switch (blkdev->protocol) {
+    case BLKIF_PROTOCOL_NATIVE:
+       dst = RING_GET_RESPONSE(&blkdev->rings.native, 
blkdev->rings.native.rsp_prod_pvt);
+       break;
+    case BLKIF_PROTOCOL_X86_32:
+       dst = RING_GET_RESPONSE(&blkdev->rings.x86_32, 
blkdev->rings.x86_32.rsp_prod_pvt);
+       break;
+    case BLKIF_PROTOCOL_X86_64:
+       dst = RING_GET_RESPONSE(&blkdev->rings.x86_64, 
blkdev->rings.x86_64.rsp_prod_pvt);
+       break;
+    default:
+       dst = NULL;
+    }
+    memcpy(dst, &resp, sizeof(resp));
+    blkdev->rings.common.rsp_prod_pvt++;
+
+    RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&blkdev->rings.common, send_notify);
+    if (blkdev->rings.common.rsp_prod_pvt == blkdev->rings.common.req_cons) {
+       /*
+        * Tail check for pending requests. Allows frontend to avoid
+        * notifications if requests are already in flight (lower
+        * overheads and promotes batching).
+        */
+       RING_FINAL_CHECK_FOR_REQUESTS(&blkdev->rings.common, have_requests);
+    } else if (RING_HAS_UNCONSUMED_REQUESTS(&blkdev->rings.common)) {
+       have_requests = 1;
+    }
+
+    if (have_requests)
+       blkdev->more_work++;
+    return send_notify;
+}
+
+/* walk finished list, send outstanding responses, free requests */
+static void blk_send_response_all(struct blkdev *blkdev)
+{
+    struct list_head *item, *safe;
+    struct ioreq *ioreq;
+    int send_notify = 0;
+
+    list_for_each_safe(item, safe, &blkdev->finished) {
+       ioreq = list_entry(item, struct ioreq, list);
+       send_notify += blk_send_response_one(ioreq);
+       ioreq_release(ioreq);
+    }
+    if (send_notify)
+       xen_be_send_notify(&blkdev->xendev);
+}
+
+static int blk_get_request(struct blkdev *blkdev, struct ioreq *ioreq, 
RING_IDX rc)
+{
+    switch (blkdev->protocol) {
+    case BLKIF_PROTOCOL_NATIVE:
+       memcpy(&ioreq->req, RING_GET_REQUEST(&blkdev->rings.native, rc),
+              sizeof(ioreq->req));
+       break;
+    case BLKIF_PROTOCOL_X86_32:
+       blkif_get_x86_32_req(&ioreq->req, 
RING_GET_REQUEST(&blkdev->rings.x86_32, rc));
+       break;
+    case BLKIF_PROTOCOL_X86_64:
+       blkif_get_x86_64_req(&ioreq->req, 
RING_GET_REQUEST(&blkdev->rings.x86_64, rc));
+       break;
+    }
+    return 0;
+}
+
+static void blk_handle_requests(struct blkdev *blkdev)
+{
+    RING_IDX rc, rp;
+    struct ioreq *ioreq;
+
+    do {
+       blkdev->more_work = 0;
+
+       rc = blkdev->rings.common.req_cons;
+       rp = blkdev->rings.common.sring->req_prod;
+       xen_rmb(); /* Ensure we see queued requests up to 'rp'. */
+
+       /* Limit #of requests we queue up for I/O so we ack requests
+        * faster if busy.  Improves backend/frontend parallelism and
+        * reduces evchn signaling. */
+       if (rp > rc + (max_requests >> 2)) {
+           rp = rc + (max_requests >> 2);
+           blkdev->more_work++;
+       }
+
+       while ((rc != rp)) {
+           /* pull request from ring */
+           if (RING_REQUEST_CONS_OVERFLOW(&blkdev->rings.common, rc))
+               break;
+           ioreq = ioreq_start(blkdev);
+           if (NULL == ioreq) {
+               blkdev->more_work++;
+               break;
+           }
+           blk_get_request(blkdev, ioreq, rc);
+           blkdev->rings.common.req_cons = ++rc;
+
+           /* parse them */
+           if (0 != ioreq_parse(ioreq)) {
+               if (blk_send_response_one(ioreq))
+                   xen_be_send_notify(&blkdev->xendev);
+               ioreq_release(ioreq);
+               continue;
+           }
+
+           /* run i/o in qemu mode */
+           ioreq_runio_qemu(ioreq);
+           ioreq_finish(ioreq);
+       }
+       blk_send_response_all(blkdev);
+
+    } while (blkdev->more_work);
+}
+
+/* ------------------------------------------------------------- */
+
+static void blk_alloc(struct xendev *xendev)
+{
+    struct blkdev *blkdev = container_of(xendev, struct blkdev, xendev);
+
+    INIT_LIST_HEAD(&blkdev->inflight);
+    INIT_LIST_HEAD(&blkdev->finished);
+    INIT_LIST_HEAD(&blkdev->freelist);
+}
+
+static int blk_init(struct xendev *xendev)
+{
+    struct blkdev *blkdev = container_of(xendev, struct blkdev, xendev);
+    int mode, qflags, have_barriers, index, info = 0;
+    char *h;
+
+    /* read xenstore entries */
+    if (NULL == blkdev->params) {
+       blkdev->params = xenstore_read_be_str(&blkdev->xendev, "params");
+       if (NULL != (h = strchr(blkdev->params, ':'))) {
+           blkdev->fileproto = blkdev->params;
+           blkdev->filename  = h+1;
+           *h = 0;
+       } else {
+           blkdev->fileproto = "<unset>";
+           blkdev->filename  = blkdev->params;
+       }
+    }
+    if (NULL == blkdev->mode)
+       blkdev->mode = xenstore_read_be_str(&blkdev->xendev, "mode");
+    if (NULL == blkdev->type)
+       blkdev->type = xenstore_read_be_str(&blkdev->xendev, "type");
+    if (NULL == blkdev->dev)
+       blkdev->dev  = xenstore_read_be_str(&blkdev->xendev, "dev");
+
+    /* do we have all we need? */
+    if (NULL == blkdev->params ||
+       NULL == blkdev->mode   ||
+       NULL == blkdev->type   ||
+       NULL == blkdev->dev)
+       return -1;
+
+    /* read-only ? */
+    if (0 == strcmp(blkdev->mode, "w")) {
+       mode   = O_RDWR;
+       qflags = BDRV_O_RDWR;
+    } else {
+       mode   = O_RDONLY;
+       qflags = BDRV_O_RDONLY;
+       info  |= VDISK_READONLY | VDISK_REMOVABLE | VDISK_CDROM;
+    }
+
+    /* init qemu block driver */
+    index = (blkdev->xendev.dev - 202 * 256) / 16;
+    index = drive_get_index(IF_XEN, 0, index);
+    if (-1 == index) {
+       blkdev->bs = bdrv_new(blkdev->dev);
+       if (blkdev->bs) {
+           if (0 != bdrv_open2(blkdev->bs, blkdev->filename, qflags,
+                               bdrv_find_format(blkdev->fileproto))) {
+               bdrv_delete(blkdev->bs);
+               blkdev->bs = NULL;
+           }
+       }
+       if (!blkdev->bs)
+           return -1;
+    } else {
+       blkdev->bs = drives_table[index].bdrv;
+    }
+    blkdev->file_blk  = BLOCK_SIZE;
+    blkdev->file_size = bdrv_getlength(blkdev->bs);
+    if (blkdev->file_size < 0)
+       blkdev->file_size = 0;
+    have_barriers = blkdev->bs->drv && blkdev->bs->drv->bdrv_flush ? 1 : 0;
+
+    xen_be_printf(xendev, 1, "type \"%s\", fileproto \"%s\", filename \"%s\","
+                 " size %" PRId64 " (%" PRId64 " MB)\n",
+                 blkdev->type, blkdev->fileproto, blkdev->filename,
+                 blkdev->file_size, blkdev->file_size >> 20);
+
+    /* fill info */
+    xenstore_write_be_int(&blkdev->xendev, "feature-barrier", have_barriers);
+    xenstore_write_be_int(&blkdev->xendev, "info",            info);
+    xenstore_write_be_int(&blkdev->xendev, "sector-size",     
blkdev->file_blk);
+    xenstore_write_be_int(&blkdev->xendev, "sectors",
+                         blkdev->file_size / blkdev->file_blk);
+    return 0;
+}
+
+static int blk_connect(struct xendev *xendev)
+{
+    struct blkdev *blkdev = container_of(xendev, struct blkdev, xendev);
+
+    if (-1 == xenstore_read_fe_int(&blkdev->xendev, "ring-ref", 
&blkdev->ring_ref))
+       return -1;
+    if (-1 == xenstore_read_fe_int(&blkdev->xendev, "event-channel",
+                                  &blkdev->xendev.remote_port))
+       return -1;
+
+    blkdev->protocol = BLKIF_PROTOCOL_NATIVE;
+    if (0 == strcmp(blkdev->xendev.protocol, XEN_IO_PROTO_ABI_X86_32))
+       blkdev->protocol = BLKIF_PROTOCOL_X86_32;
+    if (0 == strcmp(blkdev->xendev.protocol, XEN_IO_PROTO_ABI_X86_64))
+       blkdev->protocol = BLKIF_PROTOCOL_X86_64;
+
+    blkdev->sring = xc_gnttab_map_grant_ref(blkdev->xendev.gnttabdev,
+                                           blkdev->xendev.dom,
+                                           blkdev->ring_ref,
+                                           PROT_READ | PROT_WRITE);
+    if (!blkdev->sring)
+       return -1;
+    blkdev->cnt_map++;
+
+    switch (blkdev->protocol) {
+    case BLKIF_PROTOCOL_NATIVE:
+    {
+       blkif_sring_t *sring_native = blkdev->sring;
+       BACK_RING_INIT(&blkdev->rings.native, sring_native, XC_PAGE_SIZE);
+       break;
+    }
+    case BLKIF_PROTOCOL_X86_32:
+    {
+       blkif_x86_32_sring_t *sring_x86_32 = blkdev->sring;
+       BACK_RING_INIT(&blkdev->rings.x86_32, sring_x86_32, XC_PAGE_SIZE);
+       break;
+    }
+    case BLKIF_PROTOCOL_X86_64:
+    {
+       blkif_x86_64_sring_t *sring_x86_64 = blkdev->sring;
+       BACK_RING_INIT(&blkdev->rings.x86_64, sring_x86_64, XC_PAGE_SIZE);
+       break;
+    }
+    }
+
+    xen_be_bind_evtchn(&blkdev->xendev);
+
+    xen_be_printf(&blkdev->xendev, 1, "ok: proto %s, ring-ref %d, "
+                 "remote port %d, local port %d\n",
+                 blkdev->xendev.protocol, blkdev->ring_ref,
+                 blkdev->xendev.remote_port, blkdev->xendev.local_port);
+    return 0;
+}
+
+static void blk_disconnect(struct xendev *xendev)
+{
+    struct blkdev *blkdev = container_of(xendev, struct blkdev, xendev);
+
+    if (-1 != blkdev->file) {
+       close(blkdev->file);
+       blkdev->file = -1;
+    }
+    if (blkdev->bs) {
+       bdrv_close(blkdev->bs);
+       bdrv_delete(blkdev->bs);
+       blkdev->bs = NULL;
+    }
+    xen_be_unbind_evtchn(&blkdev->xendev);
+
+    if (blkdev->sring) {
+       xc_gnttab_munmap(blkdev->xendev.gnttabdev, blkdev->sring, 1);
+       blkdev->cnt_map--;
+       blkdev->sring = NULL;
+    }
+}
+
+static int blk_free(struct xendev *xendev)
+{
+    struct blkdev *blkdev = container_of(xendev, struct blkdev, xendev);
+    struct list_head *item, *safe;
+    struct ioreq *ioreq;
+
+    list_for_each_safe(item, safe, &blkdev->freelist) {
+       ioreq = list_entry(item, struct ioreq, list);
+       list_del(&ioreq->list);
+       free(ioreq);
+    }
+
+    free(blkdev->params);
+    free(blkdev->mode);
+    return 0;
+}
+
+static void blk_event(struct xendev *xendev)
+{
+    struct blkdev *blkdev = container_of(xendev, struct blkdev, xendev);
+    blk_handle_requests(blkdev);
+}
+
+struct devops xen_blkdev_ops = {
+    .size       = sizeof(struct blkdev),
+    .flags      = DEVOPS_FLAG_NEED_GNTDEV,
+    .alloc      = blk_alloc,
+    .init       = blk_init,
+    .connect    = blk_connect,
+    .disconnect = blk_disconnect,
+    .event      = blk_event,
+    .free       = blk_free,
+};
diff --git a/hw/xen-machine.c b/hw/xen-machine.c
index c03cb53..1b647a2 100644
--- a/hw/xen-machine.c
+++ b/hw/xen-machine.c
@@ -61,6 +61,7 @@ static void xenpv_init(ram_addr_t ram_size, int vga_ram_size,
     xen_be_register("console", &xen_console_ops);
     xen_be_register("vkbd", &xen_kbdmouse_ops);
     xen_be_register("vfb", &xen_framebuffer_ops);
+    xen_be_register("qdisk", &xen_blkdev_ops);
 
     /* setup framebuffer */
     xen_set_display(xen_domid, ds);
diff --git a/sysemu.h b/sysemu.h
index b12fae0..49e75b1 100644
--- a/sysemu.h
+++ b/sysemu.h
@@ -113,7 +113,7 @@ extern unsigned int nb_prom_envs;
 #endif
 
 typedef enum {
-    IF_IDE, IF_SCSI, IF_FLOPPY, IF_PFLASH, IF_MTD, IF_SD
+    IF_IDE, IF_SCSI, IF_FLOPPY, IF_PFLASH, IF_MTD, IF_SD, IF_XEN
 } BlockInterfaceType;
 
 typedef struct DriveInfo {
diff --git a/vl.c b/vl.c
index 8aef3bd..7187545 100644
--- a/vl.c
+++ b/vl.c
@@ -5478,6 +5478,9 @@ static int drive_init(struct drive_opt *arg, int snapshot,
        } else if (!strcmp(buf, "sd")) {
            type = IF_SD;
             max_devs = 0;
+       } else if (!strcmp(buf, "xen")) {
+           type = IF_XEN;
+            max_devs = 0;
        } else {
             fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, 
buf);
             return -1;
@@ -5663,6 +5666,7 @@ static int drive_init(struct drive_opt *arg, int snapshot,
     switch(type) {
     case IF_IDE:
     case IF_SCSI:
+    case IF_XEN:
         switch(media) {
        case MEDIA_DISK:
             if (cyls != 0) {
-- 
1.5.4.1


_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel


 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.