block: fix disk->part[] dereferencing race

disk->part[] is protected by its matching bdev's lock.  However,
non-critical accesses like collecting stats and printing out sysfs and
proc information used to be performed without any locking.  As
partitions can come and go dynamically, partitions can go away
underneath those non-critical accesses.  As some of those accesses are
writes, this theoretically can lead to silent corruption.

This patch fixes the race by using RCU for the partition array and dev
reference counter to hold partitions.

* Rename disk->part[] to disk->__part[] to make sure no one outside
  genhd layer proper accesses it directly.

* Use RCU for disk->__part[] dereferencing.

* Implement disk_{get|put}_part() which can be used to get and put
  partitions from gendisk respectively.

* Iterators are implemented to help iterate through all partitions
  safely.

* Functions which require RCU readlock are marked with _rcu suffix.

* Use disk_put_part() in __blkdev_put() instead of directly putting
  the contained kobject.

Signed-off-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

2 files changed, 53 insertions, 32 deletions

diff --git a/fs/block_dev.c b/fs/block_dev.c
index 72e0a2887cb7..2f2873b9a041 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -929,6 +929,7 @@ static int do_open(struct block_device *bdev, struct file *file, int for_part)
 {
         struct module *owner = NULL;
         struct gendisk *disk;
+        struct hd_struct *part = NULL;
         int ret;
         int partno;
         int perm = 0;
@@ -978,7 +979,6 @@ static int do_open(struct block_device *bdev, struct file *file, int for_part)
                         if (bdev->bd_invalidated)
                                 rescan_partitions(disk, bdev);
                 } else {
-                        struct hd_struct *p;
                         struct block_device *whole;
                         whole = bdget_disk(disk, 0);
                         ret = -ENOMEM;
@@ -989,16 +989,16 @@ static int do_open(struct block_device *bdev, struct file *file, int for_part)
                         if (ret)
                                 goto out_first;
                         bdev->bd_contains = whole;
-                        p = disk->part[partno - 1];
+                        part = disk_get_part(disk, partno);
                         bdev->bd_inode->i_data.backing_dev_info =
                            whole->bd_inode->i_data.backing_dev_info;
-                        if (!(disk->flags & GENHD_FL_UP) || !p || !p->nr_sects) {
+                        if (!(disk->flags & GENHD_FL_UP) ||
+                            !part || !part->nr_sects) {
                                 ret = -ENXIO;
                                 goto out_first;
                         }
-                        kobject_get(&p->dev.kobj);
-                        bdev->bd_part = p;
-                        bd_set_size(bdev, (loff_t) p->nr_sects << 9);
+                        bdev->bd_part = part;
+                        bd_set_size(bdev, (loff_t)part->nr_sects << 9);
                 }
         } else {
                 put_disk(disk);
@@ -1027,6 +1027,7 @@ out_first:
                 __blkdev_put(bdev->bd_contains, 1);
         bdev->bd_contains = NULL;
         put_disk(disk);
+        disk_put_part(part);
         module_put(owner);
 out:
         mutex_unlock(&bdev->bd_mutex);
@@ -1119,7 +1120,7 @@ static int __blkdev_put(struct block_device *bdev, int for_part)
                 module_put(owner);
 
                 if (bdev->bd_contains != bdev) {
-                        kobject_put(&bdev->bd_part->dev.kobj);
+                        disk_put_part(bdev->bd_part);
                         bdev->bd_part = NULL;
                 }
                 bdev->bd_disk = NULL;
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index e77fa144a07d..96c8bf41e455 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -314,19 +314,29 @@ static inline void disk_sysfs_add_subdirs(struct gendisk *disk)
         kobject_put(k);
 }
 
+static void delete_partition_rcu_cb(struct rcu_head *head)
+{
+        struct hd_struct *part = container_of(head, struct hd_struct, rcu_head);
+
+        part->start_sect = 0;
+        part->nr_sects = 0;
+        part_stat_set_all(part, 0);
+        put_device(&part->dev);
+}
+
 void delete_partition(struct gendisk *disk, int partno)
 {
-        struct hd_struct *p = disk->part[partno - 1];
+        struct hd_struct *part;
 
-        if (!p)
+        part = disk->__part[partno-1];
+        if (!part)
                 return;
-        disk->part[partno - 1] = NULL;
-        p->start_sect = 0;
-        p->nr_sects = 0;
-        part_stat_set_all(p, 0);
-        kobject_put(p->holder_dir);
-        device_del(&p->dev);
-        put_device(&p->dev);
+
+        rcu_assign_pointer(disk->__part[partno-1], NULL);
+        kobject_put(part->holder_dir);
+        device_del(&part->dev);
+
+        call_rcu(&part->rcu_head, delete_partition_rcu_cb);
 }
 
 static ssize_t whole_disk_show(struct device *dev,
@@ -343,7 +353,7 @@ int add_partition(struct gendisk *disk, int partno,
         struct hd_struct *p;
         int err;
 
-        if (disk->part[partno - 1])
+        if (disk->__part[partno - 1])
                 return -EBUSY;
 
         p = kzalloc(sizeof(*p), GFP_KERNEL);
@@ -391,7 +401,8 @@ int add_partition(struct gendisk *disk, int partno,
         }
 
         /* everything is up and running, commence */
-        disk->part[partno - 1] = p;
+        INIT_RCU_HEAD(&p->rcu_head);
+        rcu_assign_pointer(disk->__part[partno - 1], p);
 
         /* suppress uevent if the disk supresses it */
         if (!disk->dev.uevent_suppress)
@@ -414,9 +425,9 @@ out_put:
 void register_disk(struct gendisk *disk)
 {
         struct block_device *bdev;
+        struct disk_part_iter piter;
+        struct hd_struct *part;
         char *s;
-        int i;
-        struct hd_struct *p;
         int err;
 
         disk->dev.parent = disk->driverfs_dev;
@@ -466,16 +477,16 @@ exit:
         kobject_uevent(&disk->dev.kobj, KOBJ_ADD);
 
         /* announce possible partitions */
-        for (i = 0; i < disk_max_parts(disk); i++) {
-                p = disk->part[i];
-                if (!p || !p->nr_sects)
-                        continue;
-                kobject_uevent(&p->dev.kobj, KOBJ_ADD);
-        }
+        disk_part_iter_init(&piter, disk, 0);
+        while ((part = disk_part_iter_next(&piter)))
+                kobject_uevent(&part->dev.kobj, KOBJ_ADD);
+        disk_part_iter_exit(&piter);
 }
 
 int rescan_partitions(struct gendisk *disk, struct block_device *bdev)
 {
+        struct disk_part_iter piter;
+        struct hd_struct *part;
         struct parsed_partitions *state;
         int p, res;
 
@@ -485,8 +496,12 @@ int rescan_partitions(struct gendisk *disk, struct block_device *bdev)
         if (res)
                 return res;
         bdev->bd_invalidated = 0;
-        for (p = 1; p <= disk_max_parts(disk); p++)
-                delete_partition(disk, p);
+
+        disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY);
+        while ((part = disk_part_iter_next(&piter)))
+                delete_partition(disk, part->partno);
+        disk_part_iter_exit(&piter);
+
         if (disk->fops->revalidate_disk)
                 disk->fops->revalidate_disk(disk);
         if (!get_capacity(disk) || !(state = check_partition(disk, bdev)))
@@ -545,13 +560,18 @@ EXPORT_SYMBOL(read_dev_sector);
 
 void del_gendisk(struct gendisk *disk)
 {
-        int p;
+        struct disk_part_iter piter;
+        struct hd_struct *part;
 
         /* invalidate stuff */
-        for (p = disk_max_parts(disk); p > 0; p--) {
-                invalidate_partition(disk, p);
-                delete_partition(disk, p);
+        disk_part_iter_init(&piter, disk,
+                             DISK_PITER_INCL_EMPTY | DISK_PITER_REVERSE);
+        while ((part = disk_part_iter_next(&piter))) {
+                invalidate_partition(disk, part->partno);
+                delete_partition(disk, part->partno);
         }
+        disk_part_iter_exit(&piter);
+
         invalidate_partition(disk, 0);
         disk->capacity = 0;
         disk->flags &= ~GENHD_FL_UP;