Merge branch 'for-2.6.37/core' of git://git.kernel.dk/linux-2.6-block
[linux-2.6.git] / block / genhd.c
index ee4b135..8313834 100644 (file)
@@ -10,6 +10,7 @@
 #include <linux/blkdev.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
+#include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/kmod.h>
@@ -52,14 +53,21 @@ static struct device_type disk_type;
  */
 struct hd_struct *disk_get_part(struct gendisk *disk, int partno)
 {
-       struct hd_struct *part;
+       struct hd_struct *part = NULL;
+       struct disk_part_tbl *ptbl;
 
-       if (unlikely(partno < 1 || partno > disk_max_parts(disk)))
+       if (unlikely(partno < 0))
                return NULL;
+
        rcu_read_lock();
-       part = rcu_dereference(disk->__part[partno - 1]);
-       if (part)
-               get_device(&part->dev);
+
+       ptbl = rcu_dereference(disk->part_tbl);
+       if (likely(partno < ptbl->len)) {
+               part = rcu_dereference(ptbl->part[partno]);
+               if (part)
+                       get_device(part_to_dev(part));
+       }
+
        rcu_read_unlock();
 
        return part;
@@ -80,15 +88,24 @@ EXPORT_SYMBOL_GPL(disk_get_part);
 void disk_part_iter_init(struct disk_part_iter *piter, struct gendisk *disk,
                          unsigned int flags)
 {
+       struct disk_part_tbl *ptbl;
+
+       rcu_read_lock();
+       ptbl = rcu_dereference(disk->part_tbl);
+
        piter->disk = disk;
        piter->part = NULL;
 
        if (flags & DISK_PITER_REVERSE)
-               piter->idx = disk_max_parts(piter->disk) - 1;
-       else
+               piter->idx = ptbl->len - 1;
+       else if (flags & (DISK_PITER_INCL_PART0 | DISK_PITER_INCL_EMPTY_PART0))
                piter->idx = 0;
+       else
+               piter->idx = 1;
 
        piter->flags = flags;
+
+       rcu_read_unlock();
 }
 EXPORT_SYMBOL_GPL(disk_part_iter_init);
 
@@ -103,34 +120,44 @@ EXPORT_SYMBOL_GPL(disk_part_iter_init);
  */
 struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter)
 {
+       struct disk_part_tbl *ptbl;
        int inc, end;
 
        /* put the last partition */
        disk_put_part(piter->part);
        piter->part = NULL;
 
+       /* get part_tbl */
        rcu_read_lock();
+       ptbl = rcu_dereference(piter->disk->part_tbl);
 
        /* determine iteration parameters */
        if (piter->flags & DISK_PITER_REVERSE) {
                inc = -1;
-               end = -1;
+               if (piter->flags & (DISK_PITER_INCL_PART0 |
+                                   DISK_PITER_INCL_EMPTY_PART0))
+                       end = -1;
+               else
+                       end = 0;
        } else {
                inc = 1;
-               end = disk_max_parts(piter->disk);
+               end = ptbl->len;
        }
 
        /* iterate to the next partition */
        for (; piter->idx != end; piter->idx += inc) {
                struct hd_struct *part;
 
-               part = rcu_dereference(piter->disk->__part[piter->idx]);
+               part = rcu_dereference(ptbl->part[piter->idx]);
                if (!part)
                        continue;
-               if (!(piter->flags & DISK_PITER_INCL_EMPTY) && !part->nr_sects)
+               if (!part->nr_sects &&
+                   !(piter->flags & DISK_PITER_INCL_EMPTY) &&
+                   !(piter->flags & DISK_PITER_INCL_EMPTY_PART0 &&
+                     piter->idx == 0))
                        continue;
 
-               get_device(&part->dev);
+               get_device(part_to_dev(part));
                piter->part = part;
                piter->idx += inc;
                break;
@@ -158,6 +185,12 @@ void disk_part_iter_exit(struct disk_part_iter *piter)
 }
 EXPORT_SYMBOL_GPL(disk_part_iter_exit);
 
+static inline int sector_in_part(struct hd_struct *part, sector_t sector)
+{
+       return part->start_sect <= sector &&
+               sector < part->start_sect + part->nr_sects;
+}
+
 /**
  * disk_map_sector_rcu - map sector to partition
  * @disk: gendisk of interest
@@ -171,20 +204,29 @@ EXPORT_SYMBOL_GPL(disk_part_iter_exit);
  * while preemption is disabled.
  *
  * RETURNS:
- * Found partition on success, NULL if there's no matching partition.
+ * Found partition on success, part0 is returned if no partition matches
  */
 struct hd_struct *disk_map_sector_rcu(struct gendisk *disk, sector_t sector)
 {
+       struct disk_part_tbl *ptbl;
+       struct hd_struct *part;
        int i;
 
-       for (i = 0; i < disk_max_parts(disk); i++) {
-               struct hd_struct *part = rcu_dereference(disk->__part[i]);
+       ptbl = rcu_dereference(disk->part_tbl);
 
-               if (part && part->start_sect <= sector &&
-                   sector < part->start_sect + part->nr_sects)
+       part = rcu_dereference(ptbl->last_lookup);
+       if (part && sector_in_part(part, sector))
+               return part;
+
+       for (i = 1; i < ptbl->len; i++) {
+               part = rcu_dereference(ptbl->part[i]);
+
+               if (part && sector_in_part(part, sector)) {
+                       rcu_assign_pointer(ptbl->last_lookup, part);
                        return part;
+               }
        }
-       return NULL;
+       return &disk->part0;
 }
 EXPORT_SYMBOL_GPL(disk_map_sector_rcu);
 
@@ -218,6 +260,22 @@ void blkdev_show(struct seq_file *seqf, off_t offset)
 }
 #endif /* CONFIG_PROC_FS */
 
+/**
+ * register_blkdev - register a new block device
+ *
+ * @major: the requested major device number [1..255]. If @major=0, try to
+ *         allocate any unused major number.
+ * @name: the name of the new block device as a zero terminated string
+ *
+ * The @name must be unique within the system.
+ *
+ * The return value depends on the @major input parameter.
+ *  - if a major device number was requested in range [1..255] then the
+ *    function returns zero on success, or a negative error code
+ *  - if any unused major number was requested with @major=0 parameter
+ *    then the return value is the allocated major number in range
+ *    [1..255] or a negative error code otherwise
+ */
 int register_blkdev(unsigned int major, const char *name)
 {
        struct blk_major_name **n, *p;
@@ -299,9 +357,40 @@ EXPORT_SYMBOL(unregister_blkdev);
 static struct kobj_map *bdev_map;
 
 /**
+ * blk_mangle_minor - scatter minor numbers apart
+ * @minor: minor number to mangle
+ *
+ * Scatter consecutively allocated @minor number apart if MANGLE_DEVT
+ * is enabled.  Mangling twice gives the original value.
+ *
+ * RETURNS:
+ * Mangled value.
+ *
+ * CONTEXT:
+ * Don't care.
+ */
+static int blk_mangle_minor(int minor)
+{
+#ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
+       int i;
+
+       for (i = 0; i < MINORBITS / 2; i++) {
+               int low = minor & (1 << i);
+               int high = minor & (1 << (MINORBITS - 1 - i));
+               int distance = MINORBITS - 1 - 2 * i;
+
+               minor ^= low | high;    /* clear both bits */
+               low <<= distance;       /* swap the positions */
+               high >>= distance;
+               minor |= low | high;    /* and set */
+       }
+#endif
+       return minor;
+}
+
+/**
  * blk_alloc_devt - allocate a dev_t for a partition
  * @part: partition to allocate dev_t for
- * @gfp_mask: memory allocation flag
  * @devt: out parameter for resulting dev_t
  *
  * Allocate a dev_t for block device.
@@ -339,7 +428,7 @@ int blk_alloc_devt(struct hd_struct *part, dev_t *devt)
                return -EBUSY;
        }
 
-       *devt = MKDEV(BLOCK_EXT_MAJOR, idx);
+       *devt = MKDEV(BLOCK_EXT_MAJOR, blk_mangle_minor(idx));
        return 0;
 }
 
@@ -361,7 +450,7 @@ void blk_free_devt(dev_t devt)
 
        if (MAJOR(devt) == BLOCK_EXT_MAJOR) {
                mutex_lock(&ext_devt_mutex);
-               idr_remove(&ext_devt_idr, MINOR(devt));
+               idr_remove(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
                mutex_unlock(&ext_devt_mutex);
        }
 }
@@ -403,7 +492,7 @@ static struct kobject *exact_match(dev_t devt, int *partno, void *data)
 {
        struct gendisk *p = data;
 
-       return &p->dev.kobj;
+       return &disk_to_dev(p)->kobj;
 }
 
 static int exact_lock(dev_t devt, void *data)
@@ -421,22 +510,48 @@ static int exact_lock(dev_t devt, void *data)
  *
  * This function registers the partitioning information in @disk
  * with the kernel.
+ *
+ * FIXME: error handling
  */
 void add_disk(struct gendisk *disk)
 {
        struct backing_dev_info *bdi;
+       dev_t devt;
        int retval;
 
+       /* minors == 0 indicates to use ext devt from part0 and should
+        * be accompanied with EXT_DEVT flag.  Make sure all
+        * parameters make sense.
+        */
+       WARN_ON(disk->minors && !(disk->major || disk->first_minor));
+       WARN_ON(!disk->minors && !(disk->flags & GENHD_FL_EXT_DEVT));
+
        disk->flags |= GENHD_FL_UP;
-       disk->dev.devt = MKDEV(disk->major, disk->first_minor);
+
+       retval = blk_alloc_devt(&disk->part0, &devt);
+       if (retval) {
+               WARN_ON(1);
+               return;
+       }
+       disk_to_dev(disk)->devt = devt;
+
+       /* ->major and ->first_minor aren't supposed to be
+        * dereferenced from here on, but set them just in case.
+        */
+       disk->major = MAJOR(devt);
+       disk->first_minor = MINOR(devt);
+
+       /* Register BDI before referencing it from bdev */ 
+       bdi = &disk->queue->backing_dev_info;
+       bdi_register_dev(bdi, disk_devt(disk));
+
        blk_register_region(disk_devt(disk), disk->minors, NULL,
                            exact_match, exact_lock, disk);
        register_disk(disk);
        blk_register_queue(disk);
 
-       bdi = &disk->queue->backing_dev_info;
-       bdi_register_dev(bdi, disk_devt(disk));
-       retval = sysfs_create_link(&disk->dev.kobj, &bdi->dev->kobj, "bdi");
+       retval = sysfs_create_link(&disk_to_dev(disk)->kobj, &bdi->dev->kobj,
+                                  "bdi");
        WARN_ON(retval);
 }
 
@@ -445,7 +560,7 @@ EXPORT_SYMBOL(del_gendisk); /* in partitions/check.c */
 
 void unlink_gendisk(struct gendisk *disk)
 {
-       sysfs_remove_link(&disk->dev.kobj, "bdi");
+       sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
        bdi_unregister(&disk->queue->backing_dev_info);
        blk_unregister_queue(disk);
        blk_unregister_region(disk_devt(disk), disk->minors);
@@ -454,7 +569,7 @@ void unlink_gendisk(struct gendisk *disk)
 /**
  * get_gendisk - get partitioning information for a given device
  * @devt: device to get partitioning information for
- * @part: returned partition index
+ * @partno: returned partition index
  *
  * This function gets the structure containing partitioning
  * information for the given device @devt.
@@ -473,7 +588,7 @@ struct gendisk *get_gendisk(dev_t devt, int *partno)
                struct hd_struct *part;
 
                mutex_lock(&ext_devt_mutex);
-               part = idr_find(&ext_devt_idr, MINOR(devt));
+               part = idr_find(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
                if (part && get_disk(part_to_disk(part))) {
                        *partno = part->partno;
                        disk = part_to_disk(part);
@@ -483,6 +598,7 @@ struct gendisk *get_gendisk(dev_t devt, int *partno)
 
        return disk;
 }
+EXPORT_SYMBOL(get_gendisk);
 
 /**
  * bdget_disk - do bdget() by gendisk and partition number
@@ -497,24 +613,17 @@ struct gendisk *get_gendisk(dev_t devt, int *partno)
  * RETURNS:
  * Resulting block_device on success, NULL on failure.
  */
-extern struct block_device *bdget_disk(struct gendisk *disk, int partno)
+struct block_device *bdget_disk(struct gendisk *disk, int partno)
 {
-       dev_t devt = MKDEV(0, 0);
-
-       if (partno == 0)
-               devt = disk_devt(disk);
-       else {
-               struct hd_struct *part;
+       struct hd_struct *part;
+       struct block_device *bdev = NULL;
 
-               part = disk_get_part(disk, partno);
-               if (part && part->nr_sects)
-                       devt = part_devt(part);
-               disk_put_part(part);
-       }
+       part = disk_get_part(disk, partno);
+       if (part)
+               bdev = bdget(part_devt(part));
+       disk_put_part(part);
 
-       if (likely(devt != MKDEV(0, 0)))
-               return bdget(devt);
-       return NULL;
+       return bdev;
 }
 EXPORT_SYMBOL(bdget_disk);
 
@@ -535,6 +644,7 @@ void __init printk_all_partitions(void)
                struct hd_struct *part;
                char name_buf[BDEVNAME_SIZE];
                char devt_buf[BDEVT_SIZE];
+               u8 uuid[PARTITION_META_INFO_UUIDLTH * 2 + 1];
 
                /*
                 * Don't show empty devices or things that have been
@@ -549,24 +659,28 @@ void __init printk_all_partitions(void)
                 * numbers in hex - the same format as the root=
                 * option takes.
                 */
-               printk("%s %10llu %s",
-                      bdevt_str(disk_devt(disk), devt_buf),
-                      (unsigned long long)get_capacity(disk) >> 1,
-                      disk_name(disk, 0, name_buf));
-               if (disk->driverfs_dev != NULL &&
-                   disk->driverfs_dev->driver != NULL)
-                       printk(" driver: %s\n",
-                              disk->driverfs_dev->driver->name);
-               else
-                       printk(" (driver?)\n");
+               disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
+               while ((part = disk_part_iter_next(&piter))) {
+                       bool is_part0 = part == &disk->part0;
 
-               /* now show the partitions */
-               disk_part_iter_init(&piter, disk, 0);
-               while ((part = disk_part_iter_next(&piter)))
-                       printk("  %s %10llu %s\n",
+                       uuid[0] = 0;
+                       if (part->info)
+                               part_unpack_uuid(part->info->uuid, uuid);
+
+                       printk("%s%s %10llu %s %s", is_part0 ? "" : "  ",
                               bdevt_str(part_devt(part), devt_buf),
                               (unsigned long long)part->nr_sects >> 1,
-                              disk_name(disk, part->partno, name_buf));
+                              disk_name(disk, part->partno, name_buf), uuid);
+                       if (is_part0) {
+                               if (disk->driverfs_dev != NULL &&
+                                   disk->driverfs_dev->driver != NULL)
+                                       printk(" driver: %s\n",
+                                             disk->driverfs_dev->driver->name);
+                               else
+                                       printk(" (driver?)\n");
+                       } else
+                               printk("\n");
+               }
                disk_part_iter_exit(&piter);
        }
        class_dev_iter_exit(&iter);
@@ -580,7 +694,7 @@ static void *disk_seqf_start(struct seq_file *seqf, loff_t *pos)
        struct class_dev_iter *iter;
        struct device *dev;
 
-       iter = kmalloc(GFP_KERNEL, sizeof(*iter));
+       iter = kmalloc(sizeof(*iter), GFP_KERNEL);
        if (!iter)
                return ERR_PTR(-ENOMEM);
 
@@ -623,7 +737,7 @@ static void *show_partition_start(struct seq_file *seqf, loff_t *pos)
        static void *p;
 
        p = disk_seqf_start(seqf, pos);
-       if (!IS_ERR(p) && p)
+       if (!IS_ERR(p) && p && !*pos)
                seq_puts(seqf, "major minor  #blocks  name\n\n");
        return p;
 }
@@ -636,19 +750,14 @@ static int show_partition(struct seq_file *seqf, void *v)
        char buf[BDEVNAME_SIZE];
 
        /* Don't show non-partitionable removeable devices or empty devices */
-       if (!get_capacity(sgp) || (!disk_max_parts(sgp) &&
+       if (!get_capacity(sgp) || (!disk_partitionable(sgp) &&
                                   (sgp->flags & GENHD_FL_REMOVABLE)))
                return 0;
        if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
                return 0;
 
        /* show the full disk and all non-0 size partitions of it */
-       seq_printf(seqf, "%4d  %7d %10llu %s\n",
-               MAJOR(disk_devt(sgp)), MINOR(disk_devt(sgp)),
-               (unsigned long long)get_capacity(sgp) >> 1,
-               disk_name(sgp, 0, buf));
-
-       disk_part_iter_init(&piter, sgp, 0);
+       disk_part_iter_init(&piter, sgp, DISK_PITER_INCL_PART0);
        while ((part = disk_part_iter_next(&piter)))
                seq_printf(seqf, "%4d  %7d %10llu %s\n",
                           MAJOR(part_devt(part)), MINOR(part_devt(part)),
@@ -659,12 +768,24 @@ static int show_partition(struct seq_file *seqf, void *v)
        return 0;
 }
 
-const struct seq_operations partitions_op = {
+static const struct seq_operations partitions_op = {
        .start  = show_partition_start,
        .next   = disk_seqf_next,
        .stop   = disk_seqf_stop,
        .show   = show_partition
 };
+
+static int partitions_open(struct inode *inode, struct file *file)
+{
+       return seq_open(file, &partitions_op);
+}
+
+static const struct file_operations proc_partitions_operations = {
+       .open           = partitions_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = seq_release,
+};
 #endif
 
 
@@ -687,6 +808,8 @@ static int __init genhd_device_init(void)
        bdev_map = kobj_map_init(base_probe, &block_class_lock);
        blk_dev_init();
 
+       register_blkdev(BLOCK_EXT_MAJOR, "blkext");
+
 #ifndef CONFIG_SYSFS_DEPRECATED
        /* create top-level block dir */
        block_depr = kobject_create_and_add("block", NULL);
@@ -709,7 +832,7 @@ static ssize_t disk_ext_range_show(struct device *dev,
 {
        struct gendisk *disk = dev_to_disk(dev);
 
-       return sprintf(buf, "%d\n", disk_max_parts(disk) + 1);
+       return sprintf(buf, "%d\n", disk_max_parts(disk));
 }
 
 static ssize_t disk_removable_show(struct device *dev,
@@ -726,15 +849,7 @@ static ssize_t disk_ro_show(struct device *dev,
 {
        struct gendisk *disk = dev_to_disk(dev);
 
-       return sprintf(buf, "%d\n", disk->policy ? 1 : 0);
-}
-
-static ssize_t disk_size_show(struct device *dev,
-                             struct device_attribute *attr, char *buf)
-{
-       struct gendisk *disk = dev_to_disk(dev);
-
-       return sprintf(buf, "%llu\n", (unsigned long long)get_capacity(disk));
+       return sprintf(buf, "%d\n", get_disk_ro(disk) ? 1 : 0);
 }
 
 static ssize_t disk_capability_show(struct device *dev,
@@ -745,71 +860,43 @@ static ssize_t disk_capability_show(struct device *dev,
        return sprintf(buf, "%x\n", disk->flags);
 }
 
-static ssize_t disk_stat_show(struct device *dev,
-                             struct device_attribute *attr, char *buf)
+static ssize_t disk_alignment_offset_show(struct device *dev,
+                                         struct device_attribute *attr,
+                                         char *buf)
 {
        struct gendisk *disk = dev_to_disk(dev);
-       int cpu;
 
-       cpu = disk_stat_lock();
-       disk_round_stats(cpu, disk);
-       disk_stat_unlock();
-       return sprintf(buf,
-               "%8lu %8lu %8llu %8u "
-               "%8lu %8lu %8llu %8u "
-               "%8u %8u %8u"
-               "\n",
-               disk_stat_read(disk, ios[READ]),
-               disk_stat_read(disk, merges[READ]),
-               (unsigned long long)disk_stat_read(disk, sectors[READ]),
-               jiffies_to_msecs(disk_stat_read(disk, ticks[READ])),
-               disk_stat_read(disk, ios[WRITE]),
-               disk_stat_read(disk, merges[WRITE]),
-               (unsigned long long)disk_stat_read(disk, sectors[WRITE]),
-               jiffies_to_msecs(disk_stat_read(disk, ticks[WRITE])),
-               disk->in_flight,
-               jiffies_to_msecs(disk_stat_read(disk, io_ticks)),
-               jiffies_to_msecs(disk_stat_read(disk, time_in_queue)));
+       return sprintf(buf, "%d\n", queue_alignment_offset(disk->queue));
 }
 
-#ifdef CONFIG_FAIL_MAKE_REQUEST
-static ssize_t disk_fail_show(struct device *dev,
-                             struct device_attribute *attr, char *buf)
+static ssize_t disk_discard_alignment_show(struct device *dev,
+                                          struct device_attribute *attr,
+                                          char *buf)
 {
        struct gendisk *disk = dev_to_disk(dev);
 
-       return sprintf(buf, "%d\n", disk->flags & GENHD_FL_FAIL ? 1 : 0);
+       return sprintf(buf, "%d\n", queue_discard_alignment(disk->queue));
 }
 
-static ssize_t disk_fail_store(struct device *dev,
-                              struct device_attribute *attr,
-                              const char *buf, size_t count)
-{
-       struct gendisk *disk = dev_to_disk(dev);
-       int i;
-
-       if (count > 0 && sscanf(buf, "%d", &i) > 0) {
-               if (i == 0)
-                       disk->flags &= ~GENHD_FL_FAIL;
-               else
-                       disk->flags |= GENHD_FL_FAIL;
-       }
-
-       return count;
-}
-
-#endif
-
 static DEVICE_ATTR(range, S_IRUGO, disk_range_show, NULL);
 static DEVICE_ATTR(ext_range, S_IRUGO, disk_ext_range_show, NULL);
 static DEVICE_ATTR(removable, S_IRUGO, disk_removable_show, NULL);
 static DEVICE_ATTR(ro, S_IRUGO, disk_ro_show, NULL);
-static DEVICE_ATTR(size, S_IRUGO, disk_size_show, NULL);
+static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
+static DEVICE_ATTR(alignment_offset, S_IRUGO, disk_alignment_offset_show, NULL);
+static DEVICE_ATTR(discard_alignment, S_IRUGO, disk_discard_alignment_show,
+                  NULL);
 static DEVICE_ATTR(capability, S_IRUGO, disk_capability_show, NULL);
-static DEVICE_ATTR(stat, S_IRUGO, disk_stat_show, NULL);
+static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
+static DEVICE_ATTR(inflight, S_IRUGO, part_inflight_show, NULL);
 #ifdef CONFIG_FAIL_MAKE_REQUEST
 static struct device_attribute dev_attr_fail =
-       __ATTR(make-it-fail, S_IRUGO|S_IWUSR, disk_fail_show, disk_fail_store);
+       __ATTR(make-it-fail, S_IRUGO|S_IWUSR, part_fail_show, part_fail_store);
+#endif
+#ifdef CONFIG_FAIL_IO_TIMEOUT
+static struct device_attribute dev_attr_fail_timeout =
+       __ATTR(io-timeout-fail,  S_IRUGO|S_IWUSR, part_timeout_show,
+               part_timeout_store);
 #endif
 
 static struct attribute *disk_attrs[] = {
@@ -818,11 +905,17 @@ static struct attribute *disk_attrs[] = {
        &dev_attr_removable.attr,
        &dev_attr_ro.attr,
        &dev_attr_size.attr,
+       &dev_attr_alignment_offset.attr,
+       &dev_attr_discard_alignment.attr,
        &dev_attr_capability.attr,
        &dev_attr_stat.attr,
+       &dev_attr_inflight.attr,
 #ifdef CONFIG_FAIL_MAKE_REQUEST
        &dev_attr_fail.attr,
 #endif
+#ifdef CONFIG_FAIL_IO_TIMEOUT
+       &dev_attr_fail_timeout.attr,
+#endif
        NULL
 };
 
@@ -830,28 +923,129 @@ static struct attribute_group disk_attr_group = {
        .attrs = disk_attrs,
 };
 
-static struct attribute_group *disk_attr_groups[] = {
+static const struct attribute_group *disk_attr_groups[] = {
        &disk_attr_group,
        NULL
 };
 
+static void disk_free_ptbl_rcu_cb(struct rcu_head *head)
+{
+       struct disk_part_tbl *ptbl =
+               container_of(head, struct disk_part_tbl, rcu_head);
+       struct gendisk *disk = ptbl->disk;
+       struct request_queue *q = disk->queue;
+       unsigned long flags;
+
+       kfree(ptbl);
+
+       spin_lock_irqsave(q->queue_lock, flags);
+       elv_quiesce_end(q);
+       spin_unlock_irqrestore(q->queue_lock, flags);
+}
+
+/**
+ * disk_replace_part_tbl - replace disk->part_tbl in RCU-safe way
+ * @disk: disk to replace part_tbl for
+ * @new_ptbl: new part_tbl to install
+ *
+ * Replace disk->part_tbl with @new_ptbl in RCU-safe way.  The
+ * original ptbl is freed using RCU callback.
+ *
+ * LOCKING:
+ * Matching bd_mutx locked.
+ */
+static void disk_replace_part_tbl(struct gendisk *disk,
+                                 struct disk_part_tbl *new_ptbl)
+{
+       struct disk_part_tbl *old_ptbl = disk->part_tbl;
+       struct request_queue *q = disk->queue;
+
+       rcu_assign_pointer(disk->part_tbl, new_ptbl);
+
+       if (old_ptbl) {
+               rcu_assign_pointer(old_ptbl->last_lookup, NULL);
+
+               spin_lock_irq(q->queue_lock);
+               elv_quiesce_start(q);
+               spin_unlock_irq(q->queue_lock);
+
+               call_rcu(&old_ptbl->rcu_head, disk_free_ptbl_rcu_cb);
+       }
+}
+
+/**
+ * disk_expand_part_tbl - expand disk->part_tbl
+ * @disk: disk to expand part_tbl for
+ * @partno: expand such that this partno can fit in
+ *
+ * Expand disk->part_tbl such that @partno can fit in.  disk->part_tbl
+ * uses RCU to allow unlocked dereferencing for stats and other stuff.
+ *
+ * LOCKING:
+ * Matching bd_mutex locked, might sleep.
+ *
+ * RETURNS:
+ * 0 on success, -errno on failure.
+ */
+int disk_expand_part_tbl(struct gendisk *disk, int partno)
+{
+       struct disk_part_tbl *old_ptbl = disk->part_tbl;
+       struct disk_part_tbl *new_ptbl;
+       int len = old_ptbl ? old_ptbl->len : 0;
+       int target = partno + 1;
+       size_t size;
+       int i;
+
+       /* disk_max_parts() is zero during initialization, ignore if so */
+       if (disk_max_parts(disk) && target > disk_max_parts(disk))
+               return -EINVAL;
+
+       if (target <= len)
+               return 0;
+
+       size = sizeof(*new_ptbl) + target * sizeof(new_ptbl->part[0]);
+       new_ptbl = kzalloc_node(size, GFP_KERNEL, disk->node_id);
+       if (!new_ptbl)
+               return -ENOMEM;
+
+       new_ptbl->len = target;
+       new_ptbl->disk = disk;
+
+       for (i = 0; i < len; i++)
+               rcu_assign_pointer(new_ptbl->part[i], old_ptbl->part[i]);
+
+       disk_replace_part_tbl(disk, new_ptbl);
+       return 0;
+}
+
 static void disk_release(struct device *dev)
 {
        struct gendisk *disk = dev_to_disk(dev);
 
        kfree(disk->random);
-       kfree(disk->__part);
-       free_disk_stats(disk);
+       disk_replace_part_tbl(disk, NULL);
+       free_part_stats(&disk->part0);
+       free_part_info(&disk->part0);
        kfree(disk);
 }
 struct class block_class = {
        .name           = "block",
 };
 
+static char *block_devnode(struct device *dev, mode_t *mode)
+{
+       struct gendisk *disk = dev_to_disk(dev);
+
+       if (disk->devnode)
+               return disk->devnode(disk, mode);
+       return NULL;
+}
+
 static struct device_type disk_type = {
        .name           = "disk",
        .groups         = disk_attr_groups,
        .release        = disk_release,
+       .devnode        = block_devnode,
 };
 
 #ifdef CONFIG_PROC_FS
@@ -871,35 +1065,18 @@ static int diskstats_show(struct seq_file *seqf, void *v)
        int cpu;
 
        /*
-       if (&gp->dev.kobj.entry == block_class.devices.next)
+       if (&disk_to_dev(gp)->kobj.entry == block_class.devices.next)
                seq_puts(seqf,  "major minor name"
                                "     rio rmerge rsect ruse wio wmerge "
                                "wsect wuse running use aveq"
                                "\n\n");
        */
  
-       cpu = disk_stat_lock();
-       disk_round_stats(cpu, gp);
-       disk_stat_unlock();
-       seq_printf(seqf, "%4d %7d %s %lu %lu %llu %u %lu %lu %llu %u %u %u %u\n",
-               MAJOR(disk_devt(gp)), MINOR(disk_devt(gp)),
-               disk_name(gp, 0, buf),
-               disk_stat_read(gp, ios[0]), disk_stat_read(gp, merges[0]),
-               (unsigned long long)disk_stat_read(gp, sectors[0]),
-               jiffies_to_msecs(disk_stat_read(gp, ticks[0])),
-               disk_stat_read(gp, ios[1]), disk_stat_read(gp, merges[1]),
-               (unsigned long long)disk_stat_read(gp, sectors[1]),
-               jiffies_to_msecs(disk_stat_read(gp, ticks[1])),
-               gp->in_flight,
-               jiffies_to_msecs(disk_stat_read(gp, io_ticks)),
-               jiffies_to_msecs(disk_stat_read(gp, time_in_queue)));
-
-       /* now show all non-0 size partitions of it */
-       disk_part_iter_init(&piter, gp, 0);
+       disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0);
        while ((hd = disk_part_iter_next(&piter))) {
-               cpu = disk_stat_lock();
+               cpu = part_stat_lock();
                part_round_stats(cpu, hd);
-               disk_stat_unlock();
+               part_stat_unlock();
                seq_printf(seqf, "%4d %7d %s %lu %lu %llu "
                           "%u %lu %lu %llu %u %u %u %u\n",
                           MAJOR(part_devt(hd)), MINOR(part_devt(hd)),
@@ -912,7 +1089,7 @@ static int diskstats_show(struct seq_file *seqf, void *v)
                           part_stat_read(hd, merges[1]),
                           (unsigned long long)part_stat_read(hd, sectors[1]),
                           jiffies_to_msecs(part_stat_read(hd, ticks[1])),
-                          hd->in_flight,
+                          part_in_flight(hd),
                           jiffies_to_msecs(part_stat_read(hd, io_ticks)),
                           jiffies_to_msecs(part_stat_read(hd, time_in_queue))
                        );
@@ -922,12 +1099,32 @@ static int diskstats_show(struct seq_file *seqf, void *v)
        return 0;
 }
 
-const struct seq_operations diskstats_op = {
+static const struct seq_operations diskstats_op = {
        .start  = disk_seqf_start,
        .next   = disk_seqf_next,
        .stop   = disk_seqf_stop,
        .show   = diskstats_show
 };
+
+static int diskstats_open(struct inode *inode, struct file *file)
+{
+       return seq_open(file, &diskstats_op);
+}
+
+static const struct file_operations proc_diskstats_operations = {
+       .open           = diskstats_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = seq_release,
+};
+
+static int __init proc_genhd_init(void)
+{
+       proc_create("diskstats", 0, NULL, &proc_diskstats_operations);
+       proc_create("partitions", 0, NULL, &proc_partitions_operations);
+       return 0;
+}
+module_init(proc_genhd_init);
 #endif /* CONFIG_PROC_FS */
 
 static void media_change_notify_thread(struct work_struct *work)
@@ -940,7 +1137,7 @@ static void media_change_notify_thread(struct work_struct *work)
         * set enviroment vars to indicate which event this is for
         * so that user space will know to go check the media status.
         */
-       kobject_uevent_env(&gd->dev.kobj, KOBJ_CHANGE, envp);
+       kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp);
        put_device(gd->driverfs_dev);
 }
 
@@ -962,27 +1159,26 @@ dev_t blk_lookup_devt(const char *name, int partno)
        class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
        while ((dev = class_dev_iter_next(&iter))) {
                struct gendisk *disk = dev_to_disk(dev);
+               struct hd_struct *part;
 
-               if (strcmp(dev->bus_id, name))
-                       continue;
-               if (partno < 0 || partno > disk_max_parts(disk))
+               if (strcmp(dev_name(dev), name))
                        continue;
 
-               if (partno == 0)
-                       devt = disk_devt(disk);
-               else {
-                       struct hd_struct *part;
-
-                       part = disk_get_part(disk, partno);
-                       if (!part || !part->nr_sects) {
-                               disk_put_part(part);
-                               continue;
-                       }
-
+               if (partno < disk->minors) {
+                       /* We need to return the right devno, even
+                        * if the partition doesn't exist yet.
+                        */
+                       devt = MKDEV(MAJOR(dev->devt),
+                                    MINOR(dev->devt) + partno);
+                       break;
+               }
+               part = disk_get_part(disk, partno);
+               if (part) {
                        devt = part_devt(part);
                        disk_put_part(part);
+                       break;
                }
-               break;
+               disk_put_part(part);
        }
        class_dev_iter_exit(&iter);
        return devt;
@@ -993,56 +1189,38 @@ struct gendisk *alloc_disk(int minors)
 {
        return alloc_disk_node(minors, -1);
 }
+EXPORT_SYMBOL(alloc_disk);
 
 struct gendisk *alloc_disk_node(int minors, int node_id)
 {
-       return alloc_disk_ext_node(minors, 0, node_id);
-}
-
-struct gendisk *alloc_disk_ext(int minors, int ext_minors)
-{
-       return alloc_disk_ext_node(minors, ext_minors, -1);
-}
-
-struct gendisk *alloc_disk_ext_node(int minors, int ext_minors, int node_id)
-{
        struct gendisk *disk;
 
        disk = kmalloc_node(sizeof(struct gendisk),
                                GFP_KERNEL | __GFP_ZERO, node_id);
        if (disk) {
-               int tot_minors = minors + ext_minors;
-
-               if (!init_disk_stats(disk)) {
+               if (!init_part_stats(&disk->part0)) {
                        kfree(disk);
                        return NULL;
                }
-               if (tot_minors > 1) {
-                       int size = (tot_minors - 1) * sizeof(struct hd_struct *);
-                       disk->__part = kmalloc_node(size,
-                               GFP_KERNEL | __GFP_ZERO, node_id);
-                       if (!disk->__part) {
-                               free_disk_stats(disk);
-                               kfree(disk);
-                               return NULL;
-                       }
+               disk->node_id = node_id;
+               if (disk_expand_part_tbl(disk, 0)) {
+                       free_part_stats(&disk->part0);
+                       kfree(disk);
+                       return NULL;
                }
+               disk->part_tbl->part[0] = &disk->part0;
+
                disk->minors = minors;
-               disk->ext_minors = ext_minors;
                rand_initialize_disk(disk);
-               disk->dev.class = &block_class;
-               disk->dev.type = &disk_type;
-               device_initialize(&disk->dev);
+               disk_to_dev(disk)->class = &block_class;
+               disk_to_dev(disk)->type = &disk_type;
+               device_initialize(disk_to_dev(disk));
                INIT_WORK(&disk->async_notify,
                        media_change_notify_thread);
        }
        return disk;
 }
-
-EXPORT_SYMBOL(alloc_disk);
 EXPORT_SYMBOL(alloc_disk_node);
-EXPORT_SYMBOL(alloc_disk_ext);
-EXPORT_SYMBOL(alloc_disk_ext_node);
 
 struct kobject *get_disk(struct gendisk *disk)
 {
@@ -1054,7 +1232,7 @@ struct kobject *get_disk(struct gendisk *disk)
        owner = disk->fops->owner;
        if (owner && !try_module_get(owner))
                return NULL;
-       kobj = kobject_get(&disk->dev.kobj);
+       kobj = kobject_get(&disk_to_dev(disk)->kobj);
        if (kobj == NULL) {
                module_put(owner);
                return NULL;
@@ -1068,17 +1246,24 @@ EXPORT_SYMBOL(get_disk);
 void put_disk(struct gendisk *disk)
 {
        if (disk)
-               kobject_put(&disk->dev.kobj);
+               kobject_put(&disk_to_dev(disk)->kobj);
 }
 
 EXPORT_SYMBOL(put_disk);
 
+static void set_disk_ro_uevent(struct gendisk *gd, int ro)
+{
+       char event[] = "DISK_RO=1";
+       char *envp[] = { event, NULL };
+
+       if (!ro)
+               event[8] = '0';
+       kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp);
+}
+
 void set_device_ro(struct block_device *bdev, int flag)
 {
-       if (bdev->bd_contains != bdev)
-               bdev->bd_part->policy = flag;
-       else
-               bdev->bd_disk->policy = flag;
+       bdev->bd_part->policy = flag;
 }
 
 EXPORT_SYMBOL(set_device_ro);
@@ -1088,7 +1273,11 @@ void set_disk_ro(struct gendisk *disk, int flag)
        struct disk_part_iter piter;
        struct hd_struct *part;
 
-       disk->policy = flag;
+       if (disk->part0.policy != flag) {
+               set_disk_ro_uevent(disk, flag);
+               disk->part0.policy = flag;
+       }
+
        disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY);
        while ((part = disk_part_iter_next(&piter)))
                part->policy = flag;
@@ -1101,10 +1290,7 @@ int bdev_read_only(struct block_device *bdev)
 {
        if (!bdev)
                return 0;
-       else if (bdev->bd_contains != bdev)
-               return bdev->bd_part->policy;
-       else
-               return bdev->bd_disk->policy;
+       return bdev->bd_part->policy;
 }
 
 EXPORT_SYMBOL(bdev_read_only);