xen-blkback-porting

diff --git a/drivers/xen/blkback/blkback.c b/drivers/xen/blkback/blkback.c
index 5b8d50e..43fd070 100644 (file)
--- a/drivers/xen/blkback/blkback.c
+++ b/drivers/xen/blkback/blkback.c
@@ -39,8 +39,12 @@
 #include <linux/kthread.h>
 #include <linux/list.h>
 #include <linux/delay.h>
+#include <linux/freezer.h>
 #include <xen/balloon.h>
-#include <asm/hypervisor.h>
+#include <xen/events.h>
+#include <xen/page.h>
+#include <asm/xen/hypervisor.h>
+#include <asm/xen/hypercall.h>
 #include "common.h"
 
 /*
@@ -106,7 +110,7 @@ static inline unsigned long vaddr(pending_req_t *req, int seg)
 
 static int do_block_io_op(blkif_t *blkif);
 static void dispatch_rw_block_io(blkif_t *blkif,
-                                blkif_request_t *req,
+                                struct blkif_request *req,
                                 pending_req_t *pending_req);
 static void make_response(blkif_t *blkif, u64 id,
                          unsigned short op, int st);
@@ -153,7 +157,7 @@ static void unplug_queue(blkif_t *blkif)
 
 static void plug_queue(blkif_t *blkif, struct block_device *bdev)
 {
-       request_queue_t *q = bdev_get_queue(bdev);
+       struct request_queue *q = bdev_get_queue(bdev);
 
        if (q == blkif->plug)
                return;
@@ -268,13 +272,10 @@ static void __end_block_io_op(pending_req_t *pending_req, int error)
        }
 }
 
-static int end_block_io_op(struct bio *bio, unsigned int done, int error)
+static void end_block_io_op(struct bio *bio, int error)
 {
-       if (bio->bi_size != 0)
-               return 1;
        __end_block_io_op(bio->bi_private, error);
        bio_put(bio);
-       return error;
 }
 
 
@@ -288,7 +289,7 @@ static void blkif_notify_work(blkif_t *blkif)
        wake_up(&blkif->wq);
 }
 
-irqreturn_t blkif_be_int(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t blkif_be_int(int irq, void *dev_id)
 {
        blkif_notify_work(dev_id);
        return IRQ_HANDLED;
@@ -302,8 +303,8 @@ irqreturn_t blkif_be_int(int irq, void *dev_id, struct pt_regs *regs)
 
 static int do_block_io_op(blkif_t *blkif)
 {
-       blkif_back_rings_t *blk_rings = &blkif->blk_rings;
-       blkif_request_t req;
+       union blkif_back_rings *blk_rings = &blkif->blk_rings;
+       struct blkif_request req;
        pending_req_t *pending_req;
        RING_IDX rc, rp;
        int more_to_do = 0;
@@ -379,7 +380,7 @@ static int do_block_io_op(blkif_t *blkif)
 }
 
 static void dispatch_rw_block_io(blkif_t *blkif,
-                                blkif_request_t *req,
+                                struct blkif_request *req,
                                 pending_req_t *pending_req)
 {
        extern void ll_rw_block(int rw, int nr, struct buffer_head * bhs[]);
@@ -560,9 +561,9 @@ static void dispatch_rw_block_io(blkif_t *blkif,
 static void make_response(blkif_t *blkif, u64 id,
                          unsigned short op, int st)
 {
-       blkif_response_t  resp;
+       struct blkif_response  resp;
        unsigned long     flags;
-       blkif_back_rings_t *blk_rings = &blkif->blk_rings;
+       union blkif_back_rings *blk_rings = &blkif->blk_rings;
        int more_to_do = 0;
        int notify;
 
@@ -614,7 +615,8 @@ static int __init blkif_init(void)
 {
        int i, mmap_pages;
 
-       if (!is_running_on_xen())
+       printk(KERN_CRIT "***blkif_init\n");
+       if (!xen_pv_domain())
                return -ENODEV;
 
        mmap_pages = blkif_reqs * BLKIF_MAX_SEGMENTS_PER_REQUEST;

diff --git a/drivers/xen/blkback/common.h b/drivers/xen/blkback/common.h
index 422e935..1c422b0 100644 (file)
--- a/drivers/xen/blkback/common.h
+++ b/drivers/xen/blkback/common.h
@@ -40,8 +40,7 @@
 #include <xen/evtchn.h>
 #include <asm/hypervisor.h>
 #include <xen/blkif.h>
-#include <xen/gnttab.h>
-#include <xen/driver_util.h>
+#include <xen/grant_table.h>
 #include <xen/xenbus.h>
 
 #define DPRINTK(_f, _a...)                     \
@@ -66,7 +65,7 @@ typedef struct blkif_st {
        unsigned int      irq;
        /* Comms information. */
        enum blkif_protocol blk_protocol;
-       blkif_back_rings_t blk_rings;
+       union blkif_back_rings blk_rings;
        struct vm_struct *blk_ring_area;
        /* The VBD attached to this interface. */
        struct vbd        vbd;
@@ -79,7 +78,7 @@ typedef struct blkif_st {
        wait_queue_head_t   wq;
        struct task_struct  *xenblkd;
        unsigned int        waiting_reqs;
-       request_queue_t     *plug;
+       struct request_queue     *plug;
 
        /* statistics */
        unsigned long       st_print;
@@ -130,7 +129,7 @@ void blkif_interface_init(void);
 
 void blkif_xenbus_init(void);
 
-irqreturn_t blkif_be_int(int irq, void *dev_id, struct pt_regs *regs);
+irqreturn_t blkif_be_int(int irq, void *dev_id);
 int blkif_schedule(void *arg);
 
 int blkback_barrier(struct xenbus_transaction xbt,

diff --git a/drivers/xen/blkback/interface.c b/drivers/xen/blkback/interface.c
index 81821bd..c6c3e14 100644 (file)
--- a/drivers/xen/blkback/interface.c
+++ b/drivers/xen/blkback/interface.c
@@ -31,10 +31,11 @@
  */
 
 #include "common.h"
-#include <xen/evtchn.h>
+#include <xen/events.h>
+#include <xen/grant_table.h>
 #include <linux/kthread.h>
 
-static kmem_cache_t *blkif_cachep;
+static struct kmem_cache *blkif_cachep;
 
 blkif_t *blkif_alloc(domid_t domid)
 {
@@ -107,22 +108,22 @@ int blkif_map(blkif_t *blkif, unsigned long shared_page, unsigned int evtchn)
        switch (blkif->blk_protocol) {
        case BLKIF_PROTOCOL_NATIVE:
        {
-               blkif_sring_t *sring;
-               sring = (blkif_sring_t *)blkif->blk_ring_area->addr;
+               struct blkif_sring *sring;
+               sring = (struct blkif_sring *)blkif->blk_ring_area->addr;
                BACK_RING_INIT(&blkif->blk_rings.native, sring, PAGE_SIZE);
                break;
        }
        case BLKIF_PROTOCOL_X86_32:
        {
-               blkif_x86_32_sring_t *sring_x86_32;
-               sring_x86_32 = (blkif_x86_32_sring_t *)blkif->blk_ring_area->addr;
+               struct blkif_x86_32_sring *sring_x86_32;
+               sring_x86_32 = (struct blkif_x86_32_sring *)blkif->blk_ring_area->addr;
                BACK_RING_INIT(&blkif->blk_rings.x86_32, sring_x86_32, PAGE_SIZE);
                break;
        }
        case BLKIF_PROTOCOL_X86_64:
        {
-               blkif_x86_64_sring_t *sring_x86_64;
-               sring_x86_64 = (blkif_x86_64_sring_t *)blkif->blk_ring_area->addr;
+               struct blkif_x86_64_sring *sring_x86_64;
+               sring_x86_64 = (struct blkif_x86_64_sring *)blkif->blk_ring_area->addr;
                BACK_RING_INIT(&blkif->blk_rings.x86_64, sring_x86_64, PAGE_SIZE);
                break;
        }
@@ -177,5 +178,5 @@ void blkif_free(blkif_t *blkif)
 void __init blkif_interface_init(void)
 {
        blkif_cachep = kmem_cache_create("blkif_cache", sizeof(blkif_t),
-                                        0, 0, NULL, NULL);
+                                        0, 0, NULL);
 }

diff --git a/drivers/xen/blkback/vbd.c b/drivers/xen/blkback/vbd.c
index 1fb31d0..7e9a1cd 100644 (file)
--- a/drivers/xen/blkback/vbd.c
+++ b/drivers/xen/blkback/vbd.c
@@ -33,7 +33,7 @@
 #include "common.h"
 
 #define vbd_sz(_v)   ((_v)->bdev->bd_part ?                            \
-       (_v)->bdev->bd_part->nr_sects : (_v)->bdev->bd_disk->capacity)
+                     (_v)->bdev->bd_part->nr_sects : get_capacity((_v)->bdev->bd_disk))
 
 unsigned long long vbd_size(struct vbd *vbd)
 {
@@ -94,7 +94,7 @@ int vbd_create(blkif_t *blkif, blkif_vdev_t handle, unsigned major,
 void vbd_free(struct vbd *vbd)
 {
        if (vbd->bdev)
-               blkdev_put(vbd->bdev);
+               blkdev_put(vbd->bdev, vbd->readonly ? FMODE_READ : FMODE_WRITE);
        vbd->bdev = NULL;
 }
 

diff --git a/drivers/xen/blkback/xenbus.c b/drivers/xen/blkback/xenbus.c
index 80d9aa6..650f4b3 100644 (file)
--- a/drivers/xen/blkback/xenbus.c
+++ b/drivers/xen/blkback/xenbus.c
@@ -238,8 +238,8 @@ static int blkback_probe(struct xenbus_device *dev,
        /* setup back pointer */
        be->blkif->be = be;
 
-       err = xenbus_watch_path2(dev, dev->nodename, "physical-device",
-                                &be->backend_watch, backend_changed);
+       err = xenbus_watch_pathfmt(dev, &be->backend_watch, backend_changed,
+                                  "%s/%s", dev->nodename, "physical-device");
        if (err)
                goto fail;
 
@@ -537,5 +537,6 @@ static struct xenbus_driver blkback = {
 
 void blkif_xenbus_init(void)
 {
-       xenbus_register_backend(&blkback);
+       /* XXX must_check */
+       (void)xenbus_register_backend(&blkback);
 }

diff --git a/include/xen/blkif.h b/include/xen/blkif.h
index 3d56b75..d274280 100644 (file)
--- a/include/xen/blkif.h
+++ b/include/xen/blkif.h
@@ -77,12 +77,11 @@ DEFINE_RING_TYPES(blkif_x86_32, struct blkif_x86_32_request, struct blkif_x86_32
 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;
+       struct blkif_back_ring        native;
+       struct blkif_common_back_ring common;
+       struct blkif_x86_32_back_ring x86_32;
+       struct blkif_x86_64_back_ring x86_64;
 };
-typedef union blkif_back_rings blkif_back_rings_t;
 
 enum blkif_protocol {
        BLKIF_PROTOCOL_NATIVE = 1,
@@ -90,7 +89,7 @@ enum blkif_protocol {
        BLKIF_PROTOCOL_X86_64 = 3,
 };
 
-static void inline blkif_get_x86_32_req(blkif_request_t *dst, blkif_x86_32_request_t *src)
+static void inline blkif_get_x86_32_req(struct blkif_request *dst, struct blkif_x86_32_request *src)
 {
        int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST;
        dst->operation = src->operation;
@@ -105,7 +104,7 @@ static void inline blkif_get_x86_32_req(blkif_request_t *dst, blkif_x86_32_reque
                dst->seg[i] = src->seg[i];
 }
 
-static void inline blkif_get_x86_64_req(blkif_request_t *dst, blkif_x86_64_request_t *src)
+static void inline blkif_get_x86_64_req(struct blkif_request *dst, struct blkif_x86_64_request *src)
 {
        int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST;
        dst->operation = src->operation;