Merge branch 'for-3.3/drivers' of git://git.kernel.dk/linux-block

* 'for-3.3/drivers' of git://git.kernel.dk/linux-block:
  mtip32xx: do rebuild monitoring asynchronously
  xen-blkfront: Use kcalloc instead of kzalloc to allocate array
  mtip32xx: uninitialized variable in mtip_quiesce_io()
  mtip32xx: updates based on feedback
  xen-blkback: convert hole punching to discard request on loop devices
  xen/blkback: Move processing of BLKIF_OP_DISCARD from dispatch_rw_block_io
  xen/blk[front|back]: Enhance discard support with secure erasing support.
  xen/blk[front|back]: Squash blkif_request_rw and blkif_request_discard together
  mtip32xx: update to new ->make_request() API
  mtip32xx: add module.h include to avoid conflict with moduleh tree
  mtip32xx: mark a few more items static
  mtip32xx: ensure that all local functions are static
  mtip32xx: cleanup compat ioctl handling
  mtip32xx: fix warnings/errors on 32-bit compiles
  block: Add driver for Micron RealSSD pcie flash cards

3 files changed, 86 insertions, 77 deletions

diff --git a/drivers/block/xen-blkback/blkback.c b/drivers/block/xen-blkback/blkback.c
index 15ec4db194d1..0088bf60f368 100644
--- a/drivers/block/xen-blkback/blkback.c
+++ b/drivers/block/xen-blkback/blkback.c
@@ -39,9 +39,6 @@
 #include <linux/list.h>
 #include <linux/delay.h>
 #include <linux/freezer.h>
-#include <linux/loop.h>
-#include <linux/falloc.h>
-#include <linux/fs.h>
 
 #include <xen/events.h>
 #include <xen/page.h>
@@ -362,7 +359,7 @@ static int xen_blkbk_map(struct blkif_request *req,
 {
         struct gnttab_map_grant_ref map[BLKIF_MAX_SEGMENTS_PER_REQUEST];
         int i;
-        int nseg = req->nr_segments;
+        int nseg = req->u.rw.nr_segments;
         int ret = 0;
 
         /*
@@ -416,30 +413,25 @@ static int xen_blkbk_map(struct blkif_request *req,
         return ret;
 }
 
-static void xen_blk_discard(struct xen_blkif *blkif, struct blkif_request *req)
+static int dispatch_discard_io(struct xen_blkif *blkif,
+                                struct blkif_request *req)
 {
         int err = 0;
         int status = BLKIF_RSP_OKAY;
         struct block_device *bdev = blkif->vbd.bdev;
 
-        if (blkif->blk_backend_type == BLKIF_BACKEND_PHY)
-                /* just forward the discard request */
+        blkif->st_ds_req++;
+
+        xen_blkif_get(blkif);
+        if (blkif->blk_backend_type == BLKIF_BACKEND_PHY ||
+            blkif->blk_backend_type == BLKIF_BACKEND_FILE) {
+                unsigned long secure = (blkif->vbd.discard_secure &&
+                        (req->u.discard.flag & BLKIF_DISCARD_SECURE)) ?
+                        BLKDEV_DISCARD_SECURE : 0;
                 err = blkdev_issue_discard(bdev,
                                 req->u.discard.sector_number,
                                 req->u.discard.nr_sectors,
-                                GFP_KERNEL, 0);
-        else if (blkif->blk_backend_type == BLKIF_BACKEND_FILE) {
-                /* punch a hole in the backing file */
-                struct loop_device *lo = bdev->bd_disk->private_data;
-                struct file *file = lo->lo_backing_file;
-
-                if (file->f_op->fallocate)
-                        err = file->f_op->fallocate(file,
-                                FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE,
-                                req->u.discard.sector_number << 9,
-                                req->u.discard.nr_sectors << 9);
-                else
-                        err = -EOPNOTSUPP;
+                                GFP_KERNEL, secure);
         } else
                 err = -EOPNOTSUPP;
 
@@ -449,7 +441,9 @@ static void xen_blk_discard(struct xen_blkif *blkif, struct blkif_request *req)
         } else if (err)
                 status = BLKIF_RSP_ERROR;
 
-        make_response(blkif, req->id, req->operation, status);
+        make_response(blkif, req->u.discard.id, req->operation, status);
+        xen_blkif_put(blkif);
+        return err;
 }
 
 static void xen_blk_drain_io(struct xen_blkif *blkif)
@@ -573,8 +567,11 @@ __do_block_io_op(struct xen_blkif *blkif)
 
                 /* Apply all sanity checks to /private copy/ of request. */
                 barrier();
-
-                if (dispatch_rw_block_io(blkif, &req, pending_req))
+                if (unlikely(req.operation == BLKIF_OP_DISCARD)) {
+                        free_req(pending_req);
+                        if (dispatch_discard_io(blkif, &req))
+                                break;
+                } else if (dispatch_rw_block_io(blkif, &req, pending_req))
                         break;
 
                 /* Yield point for this unbounded loop. */
@@ -633,10 +630,6 @@ static int dispatch_rw_block_io(struct xen_blkif *blkif,
                 blkif->st_f_req++;
                 operation = WRITE_FLUSH;
                 break;
-        case BLKIF_OP_DISCARD:
-                blkif->st_ds_req++;
-                operation = REQ_DISCARD;
-                break;
         default:
                 operation = 0; /* make gcc happy */
                 goto fail_response;
@@ -644,9 +637,9 @@ static int dispatch_rw_block_io(struct xen_blkif *blkif,
         }
 
         /* Check that the number of segments is sane. */
-        nseg = req->nr_segments;
-        if (unlikely(nseg == 0 && operation != WRITE_FLUSH &&
-                                operation != REQ_DISCARD) ||
+        nseg = req->u.rw.nr_segments;
+
+        if (unlikely(nseg == 0 && operation != WRITE_FLUSH) ||
             unlikely(nseg > BLKIF_MAX_SEGMENTS_PER_REQUEST)) {
                 pr_debug(DRV_PFX "Bad number of segments in request (%d)\n",
                          nseg);
@@ -654,12 +647,12 @@ static int dispatch_rw_block_io(struct xen_blkif *blkif,
                 goto fail_response;
         }
 
-        preq.dev           = req->handle;
+        preq.dev           = req->u.rw.handle;
         preq.sector_number = req->u.rw.sector_number;
         preq.nr_sects      = 0;
 
         pending_req->blkif     = blkif;
-        pending_req->id        = req->id;
+        pending_req->id        = req->u.rw.id;
         pending_req->operation = req->operation;
         pending_req->status    = BLKIF_RSP_OKAY;
         pending_req->nr_pages  = nseg;
@@ -707,7 +700,7 @@ static int dispatch_rw_block_io(struct xen_blkif *blkif,
          * the hypercall to unmap the grants - that is all done in
          * xen_blkbk_unmap.
          */
-        if (operation != REQ_DISCARD && xen_blkbk_map(req, pending_req, seg))
+        if (xen_blkbk_map(req, pending_req, seg))
                 goto fail_flush;
 
         /*
@@ -739,23 +732,16 @@ static int dispatch_rw_block_io(struct xen_blkif *blkif,
 
         /* This will be hit if the operation was a flush or discard. */
         if (!bio) {
-                BUG_ON(operation != WRITE_FLUSH && operation != REQ_DISCARD);
+                BUG_ON(operation != WRITE_FLUSH);
 
-                if (operation == WRITE_FLUSH) {
-                        bio = bio_alloc(GFP_KERNEL, 0);
-                        if (unlikely(bio == NULL))
-                                goto fail_put_bio;
+                bio = bio_alloc(GFP_KERNEL, 0);
+                if (unlikely(bio == NULL))
+                        goto fail_put_bio;
 
-                        biolist[nbio++] = bio;
-                        bio->bi_bdev    = preq.bdev;
-                        bio->bi_private = pending_req;
-                        bio->bi_end_io  = end_block_io_op;
-                } else if (operation == REQ_DISCARD) {
-                        xen_blk_discard(blkif, req);
-                        xen_blkif_put(blkif);
-                        free_req(pending_req);
-                        return 0;
-                }
+                biolist[nbio++] = bio;
+                bio->bi_bdev    = preq.bdev;
+                bio->bi_private = pending_req;
+                bio->bi_end_io  = end_block_io_op;
         }
 
         /*
@@ -784,7 +770,7 @@ static int dispatch_rw_block_io(struct xen_blkif *blkif,
         xen_blkbk_unmap(pending_req);
  fail_response:
         /* Haven't submitted any bio's yet. */
-        make_response(blkif, req->id, req->operation, BLKIF_RSP_ERROR);
+        make_response(blkif, req->u.rw.id, req->operation, BLKIF_RSP_ERROR);
         free_req(pending_req);
         msleep(1); /* back off a bit */
         return -EIO;
diff --git a/drivers/block/xen-blkback/common.h b/drivers/block/xen-blkback/common.h
index dfb1b3a43a5d..d0ee7edc9be8 100644
--- a/drivers/block/xen-blkback/common.h
+++ b/drivers/block/xen-blkback/common.h
@@ -60,58 +60,66 @@ struct blkif_common_response {
         char dummy;
 };
 
-/* i386 protocol version */
-#pragma pack(push, 4)
-
 struct blkif_x86_32_request_rw {
+        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];
-};
+} __attribute__((__packed__));
 
 struct blkif_x86_32_request_discard {
+        uint8_t        flag;         /* BLKIF_DISCARD_SECURE or zero         */
+        blkif_vdev_t   _pad1;        /* was "handle" 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)  */
-        uint64_t nr_sectors;
-};
+        uint64_t       nr_sectors;
+} __attribute__((__packed__));
 
 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  */
         union {
                 struct blkif_x86_32_request_rw rw;
                 struct blkif_x86_32_request_discard discard;
         } u;
-};
+} __attribute__((__packed__));
+
+/* i386 protocol version */
+#pragma pack(push, 4)
 struct blkif_x86_32_response {
         uint64_t        id;              /* copied from request */
         uint8_t         operation;       /* copied from request */
         int16_t         status;          /* BLKIF_RSP_???       */
 };
 #pragma pack(pop)
-
 /* x86_64 protocol version */
 
 struct blkif_x86_64_request_rw {
+        uint8_t        nr_segments;  /* number of segments                   */
+        blkif_vdev_t   handle;       /* only for read/write requests         */
+        uint32_t       _pad1;        /* offsetof(blkif_reqest..,u.rw.id)==8  */
+        uint64_t       id;
         blkif_sector_t sector_number;/* start sector idx on disk (r/w only)  */
         struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
-};
+} __attribute__((__packed__));
 
 struct blkif_x86_64_request_discard {
+        uint8_t        flag;         /* BLKIF_DISCARD_SECURE or zero         */
+        blkif_vdev_t   _pad1;        /* was "handle" for read/write requests */
+        uint32_t       _pad2;        /* offsetof(blkif_..,u.discard.id)==8   */
+        uint64_t       id;
         blkif_sector_t sector_number;/* start sector idx on disk (r/w only)  */
-        uint64_t nr_sectors;
-};
+        uint64_t       nr_sectors;
+} __attribute__((__packed__));
 
 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;
         union {
                 struct blkif_x86_64_request_rw rw;
                 struct blkif_x86_64_request_discard discard;
         } u;
-};
+} __attribute__((__packed__));
+
 struct blkif_x86_64_response {
         uint64_t       __attribute__((__aligned__(8))) id;
         uint8_t         operation;       /* copied from request */
@@ -156,6 +164,7 @@ struct xen_vbd {
         /* Cached size parameter. */
         sector_t                size;
         bool                    flush_support;
+        bool                    discard_secure;
 };
 
 struct backend_info;
@@ -237,22 +246,23 @@ static inline void blkif_get_x86_32_req(struct blkif_request *dst,
 {
         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;
         switch (src->operation) {
         case BLKIF_OP_READ:
         case BLKIF_OP_WRITE:
         case BLKIF_OP_WRITE_BARRIER:
         case BLKIF_OP_FLUSH_DISKCACHE:
+                dst->u.rw.nr_segments = src->u.rw.nr_segments;
+                dst->u.rw.handle = src->u.rw.handle;
+                dst->u.rw.id = src->u.rw.id;
                 dst->u.rw.sector_number = src->u.rw.sector_number;
                 barrier();
-                if (n > dst->nr_segments)
-                        n = dst->nr_segments;
+                if (n > dst->u.rw.nr_segments)
+                        n = dst->u.rw.nr_segments;
                 for (i = 0; i < n; i++)
                         dst->u.rw.seg[i] = src->u.rw.seg[i];
                 break;
         case BLKIF_OP_DISCARD:
+                dst->u.discard.flag = src->u.discard.flag;
                 dst->u.discard.sector_number = src->u.discard.sector_number;
                 dst->u.discard.nr_sectors = src->u.discard.nr_sectors;
                 break;
@@ -266,22 +276,23 @@ static inline void blkif_get_x86_64_req(struct blkif_request *dst,
 {
         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;
         switch (src->operation) {
         case BLKIF_OP_READ:
         case BLKIF_OP_WRITE:
         case BLKIF_OP_WRITE_BARRIER:
         case BLKIF_OP_FLUSH_DISKCACHE:
+                dst->u.rw.nr_segments = src->u.rw.nr_segments;
+                dst->u.rw.handle = src->u.rw.handle;
+                dst->u.rw.id = src->u.rw.id;
                 dst->u.rw.sector_number = src->u.rw.sector_number;
                 barrier();
-                if (n > dst->nr_segments)
-                        n = dst->nr_segments;
+                if (n > dst->u.rw.nr_segments)
+                        n = dst->u.rw.nr_segments;
                 for (i = 0; i < n; i++)
                         dst->u.rw.seg[i] = src->u.rw.seg[i];
                 break;
         case BLKIF_OP_DISCARD:
+                dst->u.discard.flag = src->u.discard.flag;
                 dst->u.discard.sector_number = src->u.discard.sector_number;
                 dst->u.discard.nr_sectors = src->u.discard.nr_sectors;
                 break;
diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback/xenbus.c
index 37c794d31264..24a2fb57e5d0 100644
--- a/drivers/block/xen-blkback/xenbus.c
+++ b/drivers/block/xen-blkback/xenbus.c
@@ -338,6 +338,9 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle,
         if (q && q->flush_flags)
                 vbd->flush_support = true;
 
+        if (q && blk_queue_secdiscard(q))
+                vbd->discard_secure = true;
+
         DPRINTK("Successful creation of handle=%04x (dom=%u)\n",
                 handle, blkif->domid);
         return 0;
@@ -420,6 +423,15 @@ int xen_blkbk_discard(struct xenbus_transaction xbt, struct backend_info *be)
                                 state = 1;
                                 blkif->blk_backend_type = BLKIF_BACKEND_PHY;
                         }
+                        /* Optional. */
+                        err = xenbus_printf(xbt, dev->nodename,
+                                "discard-secure", "%d",
+                                blkif->vbd.discard_secure);
+                        if (err) {
+                                xenbus_dev_fatal(dev, err,
+                                        "writting discard-secure");
+                                goto kfree;
+                        }
                 }
         } else {
                 err = PTR_ERR(type);