8 files changed, 87 insertions, 49 deletions

diff --git a/drivers/block/drbd/drbd_req.c b/drivers/block/drbd/drbd_req.c
index f58a4a4b4dfb..2b8303ad63c9 100644
--- a/drivers/block/drbd/drbd_req.c
+++ b/drivers/block/drbd/drbd_req.c
@@ -168,7 +168,7 @@ static void wake_all_senders(struct drbd_tconn *tconn) {
 }
 
 /* must hold resource->req_lock */
-static void start_new_tl_epoch(struct drbd_tconn *tconn)
+void start_new_tl_epoch(struct drbd_tconn *tconn)
 {
         /* no point closing an epoch, if it is empty, anyways. */
         if (tconn->current_tle_writes == 0)
diff --git a/drivers/block/drbd/drbd_req.h b/drivers/block/drbd/drbd_req.h
index 016de6b8bb57..c08d22964d06 100644
--- a/drivers/block/drbd/drbd_req.h
+++ b/drivers/block/drbd/drbd_req.h
@@ -267,6 +267,7 @@ struct bio_and_error {
         int error;
 };
 
+extern void start_new_tl_epoch(struct drbd_tconn *tconn);
 extern void drbd_req_destroy(struct kref *kref);
 extern void _req_may_be_done(struct drbd_request *req,
                 struct bio_and_error *m);
diff --git a/drivers/block/drbd/drbd_state.c b/drivers/block/drbd/drbd_state.c
index 53bf6182bac4..0fe220cfb9e9 100644
--- a/drivers/block/drbd/drbd_state.c
+++ b/drivers/block/drbd/drbd_state.c
@@ -931,6 +931,7 @@ __drbd_set_state(struct drbd_conf *mdev, union drbd_state ns,
         enum drbd_state_rv rv = SS_SUCCESS;
         enum sanitize_state_warnings ssw;
         struct after_state_chg_work *ascw;
+        bool did_remote, should_do_remote;
 
         os = drbd_read_state(mdev);
 
@@ -981,11 +982,17 @@ __drbd_set_state(struct drbd_conf *mdev, union drbd_state ns,
             (os.disk != D_DISKLESS && ns.disk == D_DISKLESS))
                 atomic_inc(&mdev->local_cnt);
 
+        did_remote = drbd_should_do_remote(mdev->state);
         mdev->state.i = ns.i;
+        should_do_remote = drbd_should_do_remote(mdev->state);
         mdev->tconn->susp = ns.susp;
         mdev->tconn->susp_nod = ns.susp_nod;
         mdev->tconn->susp_fen = ns.susp_fen;
 
+        /* put replicated vs not-replicated requests in seperate epochs */
+        if (did_remote != should_do_remote)
+                start_new_tl_epoch(mdev->tconn);
+
         if (os.disk == D_ATTACHING && ns.disk >= D_NEGOTIATING)
                 drbd_print_uuids(mdev, "attached to UUIDs");
 
diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
index 9790666f90f2..11cc9522cdd4 100644
--- a/drivers/block/mtip32xx/mtip32xx.c
+++ b/drivers/block/mtip32xx/mtip32xx.c
@@ -629,12 +629,13 @@ static void mtip_timeout_function(unsigned long int data)
                 }
         }
 
-        if (cmdto_cnt && !test_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags)) {
+        if (cmdto_cnt) {
                 print_tags(port->dd, "timed out", tagaccum, cmdto_cnt);
-
-                mtip_restart_port(port);
+                if (!test_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags)) {
+                        mtip_restart_port(port);
+                        wake_up_interruptible(&port->svc_wait);
+                }
                 clear_bit(MTIP_PF_EH_ACTIVE_BIT, &port->flags);
-                wake_up_interruptible(&port->svc_wait);
         }
 
         if (port->ic_pause_timer) {
@@ -4017,7 +4018,12 @@ static int mtip_block_remove(struct driver_data *dd)
          * Delete our gendisk structure. This also removes the device
          * from /dev
          */
-        del_gendisk(dd->disk);
+        if (dd->disk) {
+                if (dd->disk->queue)
+                        del_gendisk(dd->disk);
+                else
+                        put_disk(dd->disk);
+        }
 
         spin_lock(&rssd_index_lock);
         ida_remove(&rssd_index_ida, dd->index);
@@ -4051,7 +4057,13 @@ static int mtip_block_shutdown(struct driver_data *dd)
                 "Shutting down %s ...\n", dd->disk->disk_name);
 
         /* Delete our gendisk structure, and cleanup the blk queue. */
-        del_gendisk(dd->disk);
+        if (dd->disk) {
+                if (dd->disk->queue)
+                        del_gendisk(dd->disk);
+                else
+                        put_disk(dd->disk);
+        }
+
 
         spin_lock(&rssd_index_lock);
         ida_remove(&rssd_index_ida, dd->index);
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 9d8409c02082..8ad21a25bc0d 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -889,6 +889,7 @@ static void virtblk_remove(struct virtio_device *vdev)
 {
         struct virtio_blk *vblk = vdev->priv;
         int index = vblk->index;
+        int refc;
 
         /* Prevent config work handler from accessing the device. */
         mutex_lock(&vblk->config_lock);
@@ -903,11 +904,15 @@ static void virtblk_remove(struct virtio_device *vdev)
 
         flush_work(&vblk->config_work);
 
+        refc = atomic_read(&disk_to_dev(vblk->disk)->kobj.kref.refcount);
         put_disk(vblk->disk);
         mempool_destroy(vblk->pool);
         vdev->config->del_vqs(vdev);
         kfree(vblk);
-        ida_simple_remove(&vd_index_ida, index);
+
+        /* Only free device id if we don't have any users */
+        if (refc == 1)
+                ida_simple_remove(&vd_index_ida, index);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/block/xen-blkback/blkback.c b/drivers/block/xen-blkback/blkback.c
index 74374fb762aa..de1f319f7bd7 100644
--- a/drivers/block/xen-blkback/blkback.c
+++ b/drivers/block/xen-blkback/blkback.c
@@ -46,6 +46,7 @@
 #include <xen/xen.h>
 #include <asm/xen/hypervisor.h>
 #include <asm/xen/hypercall.h>
+#include <xen/balloon.h>
 #include "common.h"
 
 /*
@@ -161,10 +162,12 @@ static int dispatch_rw_block_io(struct xen_blkif *blkif,
 static void make_response(struct xen_blkif *blkif, u64 id,
                           unsigned short op, int st);
 
-#define foreach_grant(pos, rbtree, node) \
-        for ((pos) = container_of(rb_first((rbtree)), typeof(*(pos)), node); \
+#define foreach_grant_safe(pos, n, rbtree, node) \
+        for ((pos) = container_of(rb_first((rbtree)), typeof(*(pos)), node), \
+             (n) = rb_next(&(pos)->node); \
              &(pos)->node != NULL; \
-             (pos) = container_of(rb_next(&(pos)->node), typeof(*(pos)), node))
+             (pos) = container_of(n, typeof(*(pos)), node), \
+             (n) = (&(pos)->node != NULL) ? rb_next(&(pos)->node) : NULL)
 
 
 static void add_persistent_gnt(struct rb_root *root,
@@ -217,10 +220,11 @@ static void free_persistent_gnts(struct rb_root *root, unsigned int num)
         struct gnttab_unmap_grant_ref unmap[BLKIF_MAX_SEGMENTS_PER_REQUEST];
         struct page *pages[BLKIF_MAX_SEGMENTS_PER_REQUEST];
         struct persistent_gnt *persistent_gnt;
+        struct rb_node *n;
         int ret = 0;
         int segs_to_unmap = 0;
 
-        foreach_grant(persistent_gnt, root, node) {
+        foreach_grant_safe(persistent_gnt, n, root, node) {
                 BUG_ON(persistent_gnt->handle ==
                         BLKBACK_INVALID_HANDLE);
                 gnttab_set_unmap_op(&unmap[segs_to_unmap],
@@ -230,17 +234,19 @@ static void free_persistent_gnts(struct rb_root *root, unsigned int num)
                         persistent_gnt->handle);
 
                 pages[segs_to_unmap] = persistent_gnt->page;
-                rb_erase(&persistent_gnt->node, root);
-                kfree(persistent_gnt);
-                num--;
 
                 if (++segs_to_unmap == BLKIF_MAX_SEGMENTS_PER_REQUEST ||
                         !rb_next(&persistent_gnt->node)) {
                         ret = gnttab_unmap_refs(unmap, NULL, pages,
                                 segs_to_unmap);
                         BUG_ON(ret);
+                        free_xenballooned_pages(segs_to_unmap, pages);
                         segs_to_unmap = 0;
                 }
+
+                rb_erase(&persistent_gnt->node, root);
+                kfree(persistent_gnt);
+                num--;
         }
         BUG_ON(num != 0);
 }
@@ -523,8 +529,8 @@ static int xen_blkbk_map(struct blkif_request *req,
                                 GFP_KERNEL);
                         if (!persistent_gnt)
                                 return -ENOMEM;
-                        persistent_gnt->page = alloc_page(GFP_KERNEL);
-                        if (!persistent_gnt->page) {
+                        if (alloc_xenballooned_pages(1, &persistent_gnt->page,
+                            false)) {
                                 kfree(persistent_gnt);
                                 return -ENOMEM;
                         }
@@ -875,7 +881,6 @@ static int dispatch_rw_block_io(struct xen_blkif *blkif,
                 goto fail_response;
         }
 
-        preq.dev           = req->u.rw.handle;
         preq.sector_number = req->u.rw.sector_number;
         preq.nr_sects      = 0;
 
diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback/xenbus.c
index 63980722db41..5e237f630c47 100644
--- a/drivers/block/xen-blkback/xenbus.c
+++ b/drivers/block/xen-blkback/xenbus.c
@@ -367,6 +367,7 @@ static int xen_blkbk_remove(struct xenbus_device *dev)
                 be->blkif = NULL;
         }
 
+        kfree(be->mode);
         kfree(be);
         dev_set_drvdata(&dev->dev, NULL);
         return 0;
@@ -502,6 +503,7 @@ static void backend_changed(struct xenbus_watch *watch,
                 = container_of(watch, struct backend_info, backend_watch);
         struct xenbus_device *dev = be->dev;
         int cdrom = 0;
+        unsigned long handle;
         char *device_type;
 
         DPRINTK("");
@@ -521,10 +523,10 @@ static void backend_changed(struct xenbus_watch *watch,
                 return;
         }
 
-        if ((be->major || be->minor) &&
-            ((be->major != major) || (be->minor != minor))) {
-                pr_warn(DRV_PFX "changing physical device (from %x:%x to %x:%x) not supported.\n",
-                        be->major, be->minor, major, minor);
+        if (be->major | be->minor) {
+                if (be->major != major || be->minor != minor)
+                        pr_warn(DRV_PFX "changing physical device (from %x:%x to %x:%x) not supported.\n",
+                                be->major, be->minor, major, minor);
                 return;
         }
 
@@ -542,36 +544,33 @@ static void backend_changed(struct xenbus_watch *watch,
                 kfree(device_type);
         }
 
-        if (be->major == 0 && be->minor == 0) {
-                /* Front end dir is a number, which is used as the handle. */
-
-                char *p = strrchr(dev->otherend, '/') + 1;
-                long handle;
-                err = strict_strtoul(p, 0, &handle);
-                if (err)
-                        return;
+        /* Front end dir is a number, which is used as the handle. */
+        err = strict_strtoul(strrchr(dev->otherend, '/') + 1, 0, &handle);
+        if (err)
+                return;
 
-                be->major = major;
-                be->minor = minor;
+        be->major = major;
+        be->minor = minor;
 
-                err = xen_vbd_create(be->blkif, handle, major, minor,
-                                 (NULL == strchr(be->mode, 'w')), cdrom);
-                if (err) {
-                        be->major = 0;
-                        be->minor = 0;
-                        xenbus_dev_fatal(dev, err, "creating vbd structure");
-                        return;
-                }
+        err = xen_vbd_create(be->blkif, handle, major, minor,
+                             !strchr(be->mode, 'w'), cdrom);
 
+        if (err)
+                xenbus_dev_fatal(dev, err, "creating vbd structure");
+        else {
                 err = xenvbd_sysfs_addif(dev);
                 if (err) {
                         xen_vbd_free(&be->blkif->vbd);
-                        be->major = 0;
-                        be->minor = 0;
                         xenbus_dev_fatal(dev, err, "creating sysfs entries");
-                        return;
                 }
+        }
 
+        if (err) {
+                kfree(be->mode);
+                be->mode = NULL;
+                be->major = 0;
+                be->minor = 0;
+        } else {
                 /* We're potentially connected now */
                 xen_update_blkif_status(be->blkif);
         }
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 96e9b00db081..c3dae2e0f290 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -791,7 +791,8 @@ static void blkif_restart_queue(struct work_struct *work)
 static void blkif_free(struct blkfront_info *info, int suspend)
 {
         struct llist_node *all_gnts;
-        struct grant *persistent_gnt;
+        struct grant *persistent_gnt, *tmp;
+        struct llist_node *n;
 
         /* Prevent new requests being issued until we fix things up. */
         spin_lock_irq(&info->io_lock);
@@ -804,10 +805,17 @@ static void blkif_free(struct blkfront_info *info, int suspend)
         /* Remove all persistent grants */
         if (info->persistent_gnts_c) {
                 all_gnts = llist_del_all(&info->persistent_gnts);
-                llist_for_each_entry(persistent_gnt, all_gnts, node) {
+                persistent_gnt = llist_entry(all_gnts, typeof(*(persistent_gnt)), node);
+                while (persistent_gnt) {
                         gnttab_end_foreign_access(persistent_gnt->gref, 0, 0UL);
                         __free_page(pfn_to_page(persistent_gnt->pfn));
-                        kfree(persistent_gnt);
+                        tmp = persistent_gnt;
+                        n = persistent_gnt->node.next;
+                        if (n)
+                                persistent_gnt = llist_entry(n, typeof(*(persistent_gnt)), node);
+                        else
+                                persistent_gnt = NULL;
+                        kfree(tmp);
                 }
                 info->persistent_gnts_c = 0;
         }
@@ -835,7 +843,7 @@ static void blkif_free(struct blkfront_info *info, int suspend)
 static void blkif_completion(struct blk_shadow *s, struct blkfront_info *info,
                              struct blkif_response *bret)
 {
-        int i;
+        int i = 0;
         struct bio_vec *bvec;
         struct req_iterator iter;
         unsigned long flags;
@@ -852,7 +860,8 @@ static void blkif_completion(struct blk_shadow *s, struct blkfront_info *info,
                  */
                 rq_for_each_segment(bvec, s->request, iter) {
                         BUG_ON((bvec->bv_offset + bvec->bv_len) > PAGE_SIZE);
-                        i = offset >> PAGE_SHIFT;
+                        if (bvec->bv_offset < offset)
+                                i++;
                         BUG_ON(i >= s->req.u.rw.nr_segments);
                         shared_data = kmap_atomic(
                                 pfn_to_page(s->grants_used[i]->pfn));
@@ -861,7 +870,7 @@ static void blkif_completion(struct blk_shadow *s, struct blkfront_info *info,
                                 bvec->bv_len);
                         bvec_kunmap_irq(bvec_data, &flags);
                         kunmap_atomic(shared_data);
-                        offset += bvec->bv_len;
+                        offset = bvec->bv_offset + bvec->bv_len;
                 }
         }
         /* Add the persistent grant into the list of free grants */