1 files changed, 85 insertions, 0 deletions

diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback/xenbus.c
index 04608a6502d7..fe5c3cd10c34 100644
--- a/drivers/block/xen-blkback/xenbus.c
+++ b/drivers/block/xen-blkback/xenbus.c
@@ -98,12 +98,17 @@ static void xen_update_blkif_status(struct xen_blkif *blkif)
                 err = PTR_ERR(blkif->xenblkd);
                 blkif->xenblkd = NULL;
                 xenbus_dev_error(blkif->be->dev, err, "start xenblkd");
+                return;
         }
 }
 
 static struct xen_blkif *xen_blkif_alloc(domid_t domid)
 {
         struct xen_blkif *blkif;
+        struct pending_req *req, *n;
+        int i, j;
+
+        BUILD_BUG_ON(MAX_INDIRECT_PAGES > BLKIF_MAX_INDIRECT_PAGES_PER_REQUEST);
 
         blkif = kmem_cache_zalloc(xen_blkif_cachep, GFP_KERNEL);
         if (!blkif)
@@ -118,8 +123,57 @@ static struct xen_blkif *xen_blkif_alloc(domid_t domid)
         blkif->st_print = jiffies;
         init_waitqueue_head(&blkif->waiting_to_free);
         blkif->persistent_gnts.rb_node = NULL;
+        spin_lock_init(&blkif->free_pages_lock);
+        INIT_LIST_HEAD(&blkif->free_pages);
+        blkif->free_pages_num = 0;
+        atomic_set(&blkif->persistent_gnt_in_use, 0);
+
+        INIT_LIST_HEAD(&blkif->pending_free);
+
+        for (i = 0; i < XEN_BLKIF_REQS; i++) {
+                req = kzalloc(sizeof(*req), GFP_KERNEL);
+                if (!req)
+                        goto fail;
+                list_add_tail(&req->free_list,
+                              &blkif->pending_free);
+                for (j = 0; j < MAX_INDIRECT_SEGMENTS; j++) {
+                        req->segments[j] = kzalloc(sizeof(*req->segments[0]),
+                                                   GFP_KERNEL);
+                        if (!req->segments[j])
+                                goto fail;
+                }
+                for (j = 0; j < MAX_INDIRECT_PAGES; j++) {
+                        req->indirect_pages[j] = kzalloc(sizeof(*req->indirect_pages[0]),
+                                                         GFP_KERNEL);
+                        if (!req->indirect_pages[j])
+                                goto fail;
+                }
+        }
+        spin_lock_init(&blkif->pending_free_lock);
+        init_waitqueue_head(&blkif->pending_free_wq);
+        init_waitqueue_head(&blkif->shutdown_wq);
 
         return blkif;
+
+fail:
+        list_for_each_entry_safe(req, n, &blkif->pending_free, free_list) {
+                list_del(&req->free_list);
+                for (j = 0; j < MAX_INDIRECT_SEGMENTS; j++) {
+                        if (!req->segments[j])
+                                break;
+                        kfree(req->segments[j]);
+                }
+                for (j = 0; j < MAX_INDIRECT_PAGES; j++) {
+                        if (!req->indirect_pages[j])
+                                break;
+                        kfree(req->indirect_pages[j]);
+                }
+                kfree(req);
+        }
+
+        kmem_cache_free(xen_blkif_cachep, blkif);
+
+        return ERR_PTR(-ENOMEM);
 }
 
 static int xen_blkif_map(struct xen_blkif *blkif, unsigned long shared_page,
@@ -178,6 +232,7 @@ static void xen_blkif_disconnect(struct xen_blkif *blkif)
 {
         if (blkif->xenblkd) {
                 kthread_stop(blkif->xenblkd);
+                wake_up(&blkif->shutdown_wq);
                 blkif->xenblkd = NULL;
         }
 
@@ -198,8 +253,28 @@ static void xen_blkif_disconnect(struct xen_blkif *blkif)
 
 static void xen_blkif_free(struct xen_blkif *blkif)
 {
+        struct pending_req *req, *n;
+        int i = 0, j;
+
         if (!atomic_dec_and_test(&blkif->refcnt))
                 BUG();
+
+        /* Check that there is no request in use */
+        list_for_each_entry_safe(req, n, &blkif->pending_free, free_list) {
+                list_del(&req->free_list);
+
+                for (j = 0; j < MAX_INDIRECT_SEGMENTS; j++)
+                        kfree(req->segments[j]);
+
+                for (j = 0; j < MAX_INDIRECT_PAGES; j++)
+                        kfree(req->indirect_pages[j]);
+
+                kfree(req);
+                i++;
+        }
+
+        WARN_ON(i != XEN_BLKIF_REQS);
+
         kmem_cache_free(xen_blkif_cachep, blkif);
 }
 
@@ -678,6 +753,11 @@ again:
                                  dev->nodename);
                 goto abort;
         }
+        err = xenbus_printf(xbt, dev->nodename, "feature-max-indirect-segments", "%u",
+                            MAX_INDIRECT_SEGMENTS);
+        if (err)
+                dev_warn(&dev->dev, "writing %s/feature-max-indirect-segments (%d)",
+                         dev->nodename, err);
 
         err = xenbus_printf(xbt, dev->nodename, "sectors", "%llu",
                             (unsigned long long)vbd_sz(&be->blkif->vbd));
@@ -704,6 +784,11 @@ again:
                                  dev->nodename);
                 goto abort;
         }
+        err = xenbus_printf(xbt, dev->nodename, "physical-sector-size", "%u",
+                            bdev_physical_block_size(be->blkif->vbd.bdev));
+        if (err)
+                xenbus_dev_error(dev, err, "writing %s/physical-sector-size",
+                                 dev->nodename);
 
         err = xenbus_transaction_end(xbt, 0);
         if (err == -EAGAIN)