patch forward-port-block-drivers.patch

diff --git a/drivers/xen/blktap/backdev.c b/drivers/xen/blktap/backdev.c
index b18ecd394cd8f5d3594f34eadd6d03582c7398b7..82bfba26d89aae994c51492956243c6a08751c3b 100644 (file)
--- a/drivers/xen/blktap/backdev.c
+++ b/drivers/xen/blktap/backdev.c
@@ -70,9 +70,8 @@ backdev_end_requests(struct tap_blkif *info)
                        umap_uaddr(&init_mm, idx_to_kaddr(mmap_idx,
                                                          pending_idx, i));
                req = (struct request *)(unsigned long)pending_req->id;
-               ret = end_that_request_first(req, 0, req->hard_nr_sectors);
+               ret = __blk_end_request(req, -EIO, blk_rq_bytes(req));
                BUG_ON(ret);
-               end_that_request_last(req, 0);
        }
 
  start_queue:
@@ -233,7 +232,7 @@ static int map_uaddr_fn(
        pte_t *pte = (pte_t *)data;
 
        DPRINTK("map_uaddr ptep %p -> %012llx/%012llx\n", ptep, pte_val(*pte),
-               pte_val_ma(*pte));
+               __pte_val(*pte));
        set_pte(ptep, *pte);
        xen_invlpg(addr);
        return 0;
@@ -264,7 +263,7 @@ static int umap_uaddr(struct mm_struct *mm, unsigned long address)
 static void
 process_backdev_request(struct tap_blkif *uinfo, struct backdev_info *info)
 {
-    request_queue_t *rq;
+    struct request_queue *rq;
     struct request *req;
     blkif_request_t blkif_req;
     blkif_request_t *target;
@@ -274,9 +273,8 @@ process_backdev_request(struct tap_blkif *uinfo, struct backdev_info *info)
     unsigned long uvaddr, kvaddr;
     pte_t pte;
     unsigned int fsect, lsect;
-    struct bio *bio;
     struct bio_vec *bvec;
-    int idx;
+    struct req_iterator iter;
     int usr_idx;
     int pending_idx;
     uint16_t mmap_idx;
@@ -349,8 +347,7 @@ process_backdev_request(struct tap_blkif *uinfo, struct backdev_info *info)
            BLKIF_OP_WRITE : BLKIF_OP_READ;
 
        blkif_req.nr_segments = 0;
-       rq_for_each_bio (bio, req) {
-           bio_for_each_segment (bvec, bio, idx) {
+       rq_for_each_segment(bvec, req, iter) {
                BUG_ON(blkif_req.nr_segments ==
                       BLKIF_MAX_SEGMENTS_PER_REQUEST);
                fsect = bvec->bv_offset >> 9;
@@ -386,7 +383,6 @@ process_backdev_request(struct tap_blkif *uinfo, struct backdev_info *info)
                    INVALID_GRANT_HANDLE;
 
                blkif_req.nr_segments++;
-           }
        }
 
        pending_req->id        = (unsigned long)req;
@@ -424,7 +420,7 @@ process_backdev_request(struct tap_blkif *uinfo, struct backdev_info *info)
 }
 
 static void
-do_backdev_request(request_queue_t *rq)
+do_backdev_request(struct request_queue *rq)
 {
        struct backdev_info *info;
        struct request *req;
@@ -448,7 +444,7 @@ backdev_finish_req(struct tap_blkif *info, int usr_idx, blkif_response_t *res,
                   struct pending_req *pending_req)
 {
        struct request *req;
-       int uptodate, ret;
+       int ret;
        int pending_idx, mmap_idx;
        int i;
 
@@ -470,14 +466,14 @@ backdev_finish_req(struct tap_blkif *info, int usr_idx, blkif_response_t *res,
        req = (struct request *)(unsigned long)pending_req->id;
        DPRINTK("req %p res status %d operation %d/%d id %lld\n", req,
                res->status, res->operation, pending_req->operation, res->id);
-       uptodate = (res->status == BLKIF_RSP_OKAY);
+       ret = res->status == BLKIF_RSP_OKAY ? 0 : -EIO;
        switch (pending_req->operation) {
 #if 0
        case BLKIF_OP_WRITE_BARRIER:
                if (unlikely(res->status == BLKIF_RSP_EOPNOTSUPP)) {
                        printk("backdev: %s: write barrier op failed\n",
                               info->gd->disk_name);
-                       uptodate = -EOPNOTSUPP;
+                       ret = -EOPNOTSUPP;
                        info->feature_barrier = 0;
                        xlvbd_barrier(info);
                }
@@ -489,10 +485,8 @@ backdev_finish_req(struct tap_blkif *info, int usr_idx, blkif_response_t *res,
                        DPRINTK("Bad return from blkdev data "
                                "request: %x\n", res->status);
 
-               ret = end_that_request_first(req, uptodate,
-                                            req->hard_nr_sectors);
+               ret = __blk_end_request(req, ret, blk_rq_bytes(req));
                BUG_ON(ret);
-               end_that_request_last(req, uptodate);
                break;
        default:
                BUG();

diff --git a/drivers/xen/blktap2/blktap.h b/drivers/xen/blktap2/blktap.h
index b1b022d56708f455840c51dd8a5e51c48d68286b..05c80f959ba47ed9132bc231b3c0dd11bb8c0bc0 100644 (file)
--- a/drivers/xen/blktap2/blktap.h
+++ b/drivers/xen/blktap2/blktap.h
@@ -125,7 +125,7 @@ struct blktap_ring {
        wait_queue_head_t              poll_wait;
 
        dev_t                          devno;
-       struct class_device           *dev;
+       struct device                 *dev;
        atomic_t                       sysfs_refcnt;
        struct mutex                   sysfs_mutex;
 };

diff --git a/drivers/xen/blktap2/device.c b/drivers/xen/blktap2/device.c
index 7c5974c369b4582b94c84031c765dda82d63f75b..06571b0588990379b6d9db2076fcdbd3a4960254 100644 (file)
--- a/drivers/xen/blktap2/device.c
+++ b/drivers/xen/blktap2/device.c
@@ -97,27 +97,6 @@ blktap_device_ioctl(struct inode *inode, struct file *filep,
                      command, (long)argument, inode->i_rdev);
 
        switch (command) {
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16)
-       case HDIO_GETGEO: {
-               struct block_device *bd = inode->i_bdev;
-               struct hd_geometry geo;
-               int ret;
-
-                if (!argument)
-                        return -EINVAL;
-
-               geo.start = get_start_sect(bd);
-               ret = blktap_device_getgeo(bd, &geo);
-               if (ret)
-                       return ret;
-
-               if (copy_to_user((struct hd_geometry __user *)argument, &geo,
-                                sizeof(geo)))
-                        return -EFAULT;
-
-                return 0;
-       }
-#endif
        case CDROMMULTISESSION:
                BTDBG("FIXME: support multisession CDs later\n");
                for (i = 0; i < sizeof(struct cdrom_multisession); i++)
@@ -150,9 +129,7 @@ static struct block_device_operations blktap_device_file_operations = {
        .open      = blktap_device_open,
        .release   = blktap_device_release,
        .ioctl     = blktap_device_ioctl,
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
        .getgeo    = blktap_device_getgeo
-#endif
 };
 
 static int
@@ -195,16 +172,16 @@ blktap_umap_uaddr(struct mm_struct *mm, unsigned long address)
 
 static void
 blktap_device_end_dequeued_request(struct blktap_device *dev,
-                                  struct request *req, int uptodate)
+                                  struct request *req, int error)
 {
+       unsigned long flags;
        int ret;
 
-       ret = end_that_request_first(req, uptodate, req->hard_nr_sectors);
-       BUG_ON(ret);
+       spin_lock_irqsave(dev->gd->queue->queue_lock, flags);
+       ret = __blk_end_request(req, error, blk_rq_bytes(req));
+       spin_unlock_irqrestore(dev->gd->queue->queue_lock, flags);
 
-       spin_lock_irq(&dev->lock);
-       end_that_request_last(req, uptodate);
-       spin_unlock_irq(&dev->lock);
+       BUG_ON(ret);
 }
 
 /*
@@ -361,7 +338,7 @@ blktap_device_fail_pending_requests(struct blktap *tap)
 
                blktap_unmap(tap, request);
                req = (struct request *)(unsigned long)request->id;
-               blktap_device_end_dequeued_request(dev, req, 0);
+               blktap_device_end_dequeued_request(dev, req, -EIO);
                blktap_request_free(tap, request);
        }
 
@@ -384,7 +361,7 @@ blktap_device_finish_request(struct blktap *tap,
                             blkif_response_t *res,
                             struct blktap_request *request)
 {
-       int uptodate;
+       int ret;
        struct request *req;
        struct blktap_device *dev;
 
@@ -393,7 +370,7 @@ blktap_device_finish_request(struct blktap *tap,
        blktap_unmap(tap, request);
 
        req = (struct request *)(unsigned long)request->id;
-       uptodate = (res->status == BLKIF_RSP_OKAY);
+       ret = res->status == BLKIF_RSP_OKAY ? 0 : -EIO;
 
        BTDBG("req %p res status %d operation %d/%d id %lld\n", req,
                res->status, res->operation, request->operation, res->id);
@@ -404,7 +381,7 @@ blktap_device_finish_request(struct blktap *tap,
                if (unlikely(res->status != BLKIF_RSP_OKAY))
                        BTERR("Bad return from device data "
                                "request: %x\n", res->status);
-               blktap_device_end_dequeued_request(dev, req, uptodate);
+               blktap_device_end_dequeued_request(dev, req, ret);
                break;
        default:
                BUG();
@@ -567,10 +544,10 @@ blktap_device_process_request(struct blktap *tap,
                              struct blktap_request *request,
                              struct request *req)
 {
-       struct bio *bio;
        struct page *page;
        struct bio_vec *bvec;
-       int idx, usr_idx, err;
+       int usr_idx, err;
+       struct req_iterator iter;
        struct blktap_ring *ring;
        struct blktap_grant_table table;
        unsigned int fsect, lsect, nr_sects;
@@ -599,8 +576,7 @@ blktap_device_process_request(struct blktap *tap,
        nr_sects = 0;
        request->nr_pages = 0;
        blkif_req.nr_segments = 0;
-       rq_for_each_bio(bio, req) {
-               bio_for_each_segment(bvec, bio, idx) {
+       rq_for_each_segment(bvec, req, iter) {
                        BUG_ON(blkif_req.nr_segments ==
                               BLKIF_MAX_SEGMENTS_PER_REQUEST);
 
@@ -649,7 +625,6 @@ blktap_device_process_request(struct blktap *tap,
 
                        blkif_req.nr_segments++;
                        request->nr_pages++;
-               }
        }
 
        if (blktap_map_foreign(tap, request, &blkif_req, &table))
@@ -777,7 +752,7 @@ static void
 blktap_device_run_queue(struct blktap *tap)
 {
        int queued, err;
-       request_queue_t *rq;
+       struct request_queue *rq;
        struct request *req;
        struct blktap_ring *ring;
        struct blktap_device *dev;
@@ -838,7 +813,7 @@ blktap_device_run_queue(struct blktap *tap)
                if (!err)
                        queued++;
                else {
-                       blktap_device_end_dequeued_request(dev, req, 0);
+                       blktap_device_end_dequeued_request(dev, req, -EIO);
                        blktap_request_free(tap, request);
                }
 
@@ -854,7 +829,7 @@ blktap_device_run_queue(struct blktap *tap)
  * dev->lock held on entry
  */
 static void
-blktap_device_do_request(request_queue_t *rq)
+blktap_device_do_request(struct request_queue *rq)
 {
        struct request *req;
        struct blktap *tap;
@@ -1076,11 +1051,7 @@ blktap_device_create(struct blktap *tap)
        if (!rq)
                goto error;
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)
        elevator_init(rq, "noop");
-#else
-       elevator_init(rq, &elevator_noop);
-#endif
 
        gd->queue     = rq;
        rq->queuedata = dev;
@@ -1127,6 +1098,5 @@ void
 blktap_device_free(void)
 {
        if (blktap_device_major)
-               if (unregister_blkdev(blktap_device_major, "tapdev"))
-                       BTERR("blktap device unregister failed\n");
+               unregister_blkdev(blktap_device_major, "tapdev");
 }

diff --git a/drivers/xen/blktap2/ring.c b/drivers/xen/blktap2/ring.c
index d6b5d42ec4ce2594f2ded1433e256ebc489ad0ed..eaa2306b6b7d61fa144c6c82c2c70411504f61db 100644 (file)
--- a/drivers/xen/blktap2/ring.c
+++ b/drivers/xen/blktap2/ring.c
@@ -66,16 +66,14 @@ blktap_read_ring(struct blktap *tap)
        return 0;
 }
 
-static struct page *
-blktap_ring_nopage(struct vm_area_struct *vma,
-                  unsigned long address, int *type)
+static int blktap_ring_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
        /*
         * if the page has not been mapped in by the driver then return
-        * NOPAGE_SIGBUS to the domain.
+        * VM_FAULT_SIGBUS to the domain.
         */
 
-       return NOPAGE_SIGBUS;
+       return VM_FAULT_SIGBUS;
 }
 
 static pte_t
@@ -205,7 +203,7 @@ blktap_ring_vm_close(struct vm_area_struct *vma)
 static struct vm_operations_struct blktap_ring_vm_operations = {
        .close    = blktap_ring_vm_close,
        .unmap    = blktap_ring_vm_unmap,
-       .nopage   = blktap_ring_nopage,
+       .fault    = blktap_ring_fault,
        .zap_pte  = blktap_ring_clear_pte,
 };
 

diff --git a/drivers/xen/blktap2/sysfs.c b/drivers/xen/blktap2/sysfs.c
index 8b56c7e50f710f0e6e84fa09b7b97ce45a3efdd1..3a396ac5b185f8495b8df9a2d2b5d5f6a66c97d4 100644 (file)
--- a/drivers/xen/blktap2/sysfs.c
+++ b/drivers/xen/blktap2/sysfs.c
@@ -36,16 +36,18 @@ blktap_sysfs_exit(struct blktap *tap)
        blktap_sysfs_put(tap);
 }
 
-static ssize_t blktap_sysfs_pause_device(struct class_device *, const char *, size_t);
+#define CLASS_DEVICE_ATTR(a,b,c,d) DEVICE_ATTR(a,b,c,d)
+
+static ssize_t blktap_sysfs_pause_device(struct device *, struct device_attribute *, const char *, size_t);
 CLASS_DEVICE_ATTR(pause, S_IWUSR, NULL, blktap_sysfs_pause_device);
-static ssize_t blktap_sysfs_resume_device(struct class_device *, const char *, size_t);
+static ssize_t blktap_sysfs_resume_device(struct device *, struct device_attribute *, const char *, size_t);
 CLASS_DEVICE_ATTR(resume, S_IWUSR, NULL, blktap_sysfs_resume_device);
 
 static ssize_t
-blktap_sysfs_set_name(struct class_device *dev, const char *buf, size_t size)
+blktap_sysfs_set_name(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
 {
        int err;
-       struct blktap *tap = (struct blktap *)dev->class_data;
+       struct blktap *tap = (struct blktap *)dev_get_drvdata(dev);
 
        blktap_sysfs_enter(tap);
 
@@ -79,10 +81,10 @@ out:
 }
 
 static ssize_t
-blktap_sysfs_get_name(struct class_device *dev, char *buf)
+blktap_sysfs_get_name(struct device *dev, struct device_attribute *attr, char *buf)
 {
        ssize_t size;
-       struct blktap *tap = (struct blktap *)dev->class_data;
+       struct blktap *tap = (struct blktap *)dev_get_drvdata(dev);
 
        blktap_sysfs_enter(tap);
 
@@ -101,11 +103,12 @@ CLASS_DEVICE_ATTR(name, S_IRUSR | S_IWUSR,
                  blktap_sysfs_get_name, blktap_sysfs_set_name);
 
 static ssize_t
-blktap_sysfs_remove_device(struct class_device *dev,
+blktap_sysfs_remove_device(struct device *dev,
+                          struct device_attribute *attr,
                           const char *buf, size_t size)
 {
        int err;
-       struct blktap *tap = (struct blktap *)dev->class_data;
+       struct blktap *tap = (struct blktap *)dev_get_drvdata(dev);
 
        if (!tap->ring.dev)
                return size;
@@ -120,11 +123,12 @@ blktap_sysfs_remove_device(struct class_device *dev,
 CLASS_DEVICE_ATTR(remove, S_IWUSR, NULL, blktap_sysfs_remove_device);
 
 static ssize_t
-blktap_sysfs_pause_device(struct class_device *dev,
+blktap_sysfs_pause_device(struct device *dev,
+                         struct device_attribute *attr,
                          const char *buf, size_t size)
 {
        int err;
-       struct blktap *tap = (struct blktap *)dev->class_data;
+       struct blktap *tap = (struct blktap *)dev_get_drvdata(dev);
 
        blktap_sysfs_enter(tap);
 
@@ -149,8 +153,8 @@ blktap_sysfs_pause_device(struct class_device *dev,
 
        err = blktap_device_pause(tap);
        if (!err) {
-               class_device_remove_file(dev, &class_device_attr_pause);
-               class_device_create_file(dev, &class_device_attr_resume);
+               device_remove_file(dev, &dev_attr_pause);
+               device_create_file(dev, &dev_attr_resume);
        }
 
 out:
@@ -160,11 +164,12 @@ out:
 }
 
 static ssize_t
-blktap_sysfs_resume_device(struct class_device *dev,
+blktap_sysfs_resume_device(struct device *dev,
+                          struct device_attribute *attr,
                           const char *buf, size_t size)
 {
        int err;
-       struct blktap *tap = (struct blktap *)dev->class_data;
+       struct blktap *tap = (struct blktap *)dev_get_drvdata(dev);
 
        blktap_sysfs_enter(tap);
 
@@ -181,8 +186,8 @@ blktap_sysfs_resume_device(struct class_device *dev,
 
        err = blktap_device_resume(tap);
        if (!err) {
-               class_device_remove_file(dev, &class_device_attr_resume);
-               class_device_create_file(dev, &class_device_attr_pause);
+               device_remove_file(dev, &dev_attr_resume);
+               device_create_file(dev, &dev_attr_pause);
        }
 
 out:
@@ -194,12 +199,12 @@ out:
 
 #ifdef ENABLE_PASSTHROUGH
 static ssize_t
-blktap_sysfs_enable_passthrough(struct class_device *dev,
+blktap_sysfs_enable_passthrough(struct device *dev,
                                const char *buf, size_t size)
 {
        int err;
        unsigned major, minor;
-       struct blktap *tap = (struct blktap *)dev->class_data;
+       struct blktap *tap = (struct blktap *)dev_get_drvdata(dev);
 
        BTINFO("passthrough request enabled\n");
 
@@ -237,11 +242,11 @@ out:
 #endif
 
 static ssize_t
-blktap_sysfs_debug_device(struct class_device *dev, char *buf)
+blktap_sysfs_debug_device(struct device *dev, struct device_attribute *attr, char *buf)
 {
        char *tmp;
        int i, ret;
-       struct blktap *tap = (struct blktap *)dev->class_data;
+       struct blktap *tap = (struct blktap *)dev_get_drvdata(dev);
 
        tmp = buf;
        blktap_sysfs_get(tap);
@@ -291,29 +296,28 @@ int
 blktap_sysfs_create(struct blktap *tap)
 {
        struct blktap_ring *ring;
-       struct class_device *dev;
+       struct device *dev;
 
        if (!class)
                return -ENODEV;
 
        ring = &tap->ring;
 
-       dev = class_device_create(class, NULL, ring->devno,
-                                 NULL, "blktap%d", tap->minor);
+       dev = device_create(class, NULL, ring->devno,
+                           NULL, "blktap%d", tap->minor);
        if (IS_ERR(dev))
                return PTR_ERR(dev);
 
        ring->dev       = dev;
-       dev->class_data = tap;
+       dev_set_drvdata(dev, tap);
 
        mutex_init(&ring->sysfs_mutex);
        atomic_set(&ring->sysfs_refcnt, 0);
-       set_bit(BLKTAP_SYSFS, &tap->dev_inuse);
 
-       class_device_create_file(dev, &class_device_attr_name);
-       class_device_create_file(dev, &class_device_attr_remove);
-       class_device_create_file(dev, &class_device_attr_pause);
-       class_device_create_file(dev, &class_device_attr_debug);
+       device_create_file(dev, &dev_attr_name);
+       device_create_file(dev, &dev_attr_remove);
+       device_create_file(dev, &dev_attr_pause);
+       device_create_file(dev, &dev_attr_debug);
 
        return 0;
 }
@@ -322,7 +326,7 @@ int
 blktap_sysfs_destroy(struct blktap *tap)
 {
        struct blktap_ring *ring;
-       struct class_device *dev;
+       struct device *dev;
 
        ring = &tap->ring;
        dev  = ring->dev;
@@ -335,12 +339,12 @@ blktap_sysfs_destroy(struct blktap *tap)
                return -EAGAIN;
 
        /* XXX: is it safe to remove the class from a sysfs attribute? */
-       class_device_remove_file(dev, &class_device_attr_name);
-       class_device_remove_file(dev, &class_device_attr_remove);
-       class_device_remove_file(dev, &class_device_attr_pause);
-       class_device_remove_file(dev, &class_device_attr_resume);
-       class_device_remove_file(dev, &class_device_attr_debug);
-       class_device_destroy(class, ring->devno);
+       device_remove_file(dev, &dev_attr_name);
+       device_remove_file(dev, &dev_attr_remove);
+       device_remove_file(dev, &dev_attr_pause);
+       device_remove_file(dev, &dev_attr_resume);
+       device_remove_file(dev, &dev_attr_debug);
+       device_destroy(class, ring->devno);
 
        clear_bit(BLKTAP_SYSFS, &tap->dev_inuse);