5 files changed, 84 insertions, 16 deletions

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index fdf1b79eb347..31064df1370a 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -379,7 +379,7 @@ static void cciss_map_sg_chain_block(ctlr_info_t *h, CommandList_struct *c,
 static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
         "UNKNOWN"
 };
-#define RAID_UNKNOWN (sizeof(raid_label) / sizeof(raid_label[0])-1)
+#define RAID_UNKNOWN (ARRAY_SIZE(raid_label)-1)
 
 #ifdef CONFIG_PROC_FS
 
diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c
index 20abef531c99..081522d3c742 100644
--- a/drivers/block/drbd/drbd_receiver.c
+++ b/drivers/block/drbd/drbd_receiver.c
@@ -1087,7 +1087,7 @@ static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev,
                         } else {
                                 epoch->flags = 0;
                                 atomic_set(&epoch->epoch_size, 0);
-                                /* atomic_set(&epoch->active, 0); is alrady zero */
+                                /* atomic_set(&epoch->active, 0); is already zero */
                                 if (rv == FE_STILL_LIVE)
                                         rv = FE_RECYCLED;
                         }
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 6751789fb379..0daa422aa281 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -4,7 +4,7 @@
  * Note that you can not swap over this thing, yet. Seems to work but
  * deadlocks sometimes - you can not swap over TCP in general.
  * 
- * Copyright 1997-2000, 2008 Pavel Machek <pavel@suse.cz>
+ * Copyright 1997-2000, 2008 Pavel Machek <pavel@ucw.cz>
  * Parts copyright 2001 Steven Whitehouse <steve@chygwyn.com>
  *
  * This file is released under GPLv2 or later.
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 7b0f7b624adf..2aafafca2b13 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -224,16 +224,6 @@ static int virtblk_locked_ioctl(struct block_device *bdev, fmode_t mode,
         struct gendisk *disk = bdev->bd_disk;
         struct virtio_blk *vblk = disk->private_data;
 
-        if (cmd == 0x56424944) { /* 'VBID' */
-                void __user *usr_data = (void __user *)data;
-                char id_str[VIRTIO_BLK_ID_BYTES];
-                int err;
-
-                err = virtblk_get_id(disk, id_str);
-                if (!err && copy_to_user(usr_data, id_str, VIRTIO_BLK_ID_BYTES))
-                        err = -EFAULT;
-                return err;
-        }
         /*
          * Only allow the generic SCSI ioctls if the host can support it.
          */
@@ -292,6 +282,27 @@ static int index_to_minor(int index)
         return index << PART_BITS;
 }
 
+static ssize_t virtblk_serial_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct gendisk *disk = dev_to_disk(dev);
+        int err;
+
+        /* sysfs gives us a PAGE_SIZE buffer */
+        BUILD_BUG_ON(PAGE_SIZE < VIRTIO_BLK_ID_BYTES);
+
+        buf[VIRTIO_BLK_ID_BYTES] = '\0';
+        err = virtblk_get_id(disk, buf);
+        if (!err)
+                return strlen(buf);
+
+        if (err == -EIO) /* Unsupported? Make it empty. */
+                return 0;
+
+        return err;
+}
+DEVICE_ATTR(serial, S_IRUGO, virtblk_serial_show, NULL);
+
 static int __devinit virtblk_probe(struct virtio_device *vdev)
 {
         struct virtio_blk *vblk;
@@ -377,11 +388,31 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
         vblk->disk->driverfs_dev = &vdev->dev;
         index++;
 
-        /* If barriers are supported, tell block layer that queue is ordered */
-        if (virtio_has_feature(vdev, VIRTIO_BLK_F_FLUSH))
+        if (virtio_has_feature(vdev, VIRTIO_BLK_F_FLUSH)) {
+                /*
+                 * If the FLUSH feature is supported we do have support for
+                 * flushing a volatile write cache on the host.  Use that
+                 * to implement write barrier support.
+                 */
                 blk_queue_ordered(q, QUEUE_ORDERED_DRAIN_FLUSH);
-        else if (virtio_has_feature(vdev, VIRTIO_BLK_F_BARRIER))
+        } else if (virtio_has_feature(vdev, VIRTIO_BLK_F_BARRIER)) {
+                /*
+                 * If the BARRIER feature is supported the host expects us
+                 * to order request by tags.  This implies there is not
+                 * volatile write cache on the host, and that the host
+                 * never re-orders outstanding I/O.  This feature is not
+                 * useful for real life scenarious and deprecated.
+                 */
                 blk_queue_ordered(q, QUEUE_ORDERED_TAG);
+        } else {
+                /*
+                 * If the FLUSH feature is not supported we must assume that
+                 * the host does not perform any kind of volatile write
+                 * caching. We still need to drain the queue to provider
+                 * proper barrier semantics.
+                 */
+                blk_queue_ordered(q, QUEUE_ORDERED_DRAIN);
+        }
 
         /* If disk is read-only in the host, the guest should obey */
         if (virtio_has_feature(vdev, VIRTIO_BLK_F_RO))
@@ -455,8 +486,15 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
 
 
         add_disk(vblk->disk);
+        err = device_create_file(disk_to_dev(vblk->disk), &dev_attr_serial);
+        if (err)
+                goto out_del_disk;
+
         return 0;
 
+out_del_disk:
+        del_gendisk(vblk->disk);
+        blk_cleanup_queue(vblk->disk->queue);
 out_put_disk:
         put_disk(vblk->disk);
 out_mempool:
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 67d9bfab59fa..ac1b682edecb 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -49,6 +49,7 @@
 #include <xen/grant_table.h>
 #include <xen/events.h>
 #include <xen/page.h>
+#include <xen/platform_pci.h>
 
 #include <xen/interface/grant_table.h>
 #include <xen/interface/io/blkif.h>
@@ -829,6 +830,35 @@ static int blkfront_probe(struct xenbus_device *dev,
                 }
         }
 
+        if (xen_hvm_domain()) {
+                char *type;
+                int len;
+                /* no unplug has been done: do not hook devices != xen vbds */
+                if (xen_platform_pci_unplug & XEN_UNPLUG_IGNORE) {
+                        int major;
+
+                        if (!VDEV_IS_EXTENDED(vdevice))
+                                major = BLKIF_MAJOR(vdevice);
+                        else
+                                major = XENVBD_MAJOR;
+
+                        if (major != XENVBD_MAJOR) {
+                                printk(KERN_INFO
+                                                "%s: HVM does not support vbd %d as xen block device\n",
+                                                __FUNCTION__, vdevice);
+                                return -ENODEV;
+                        }
+                }
+                /* do not create a PV cdrom device if we are an HVM guest */
+                type = xenbus_read(XBT_NIL, dev->nodename, "device-type", &len);
+                if (IS_ERR(type))
+                        return -ENODEV;
+                if (strncmp(type, "cdrom", 5) == 0) {
+                        kfree(type);
+                        return -ENODEV;
+                }
+                kfree(type);
+        }
         info = kzalloc(sizeof(*info), GFP_KERNEL);
         if (!info) {
                 xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure");