block: add partition resize function to blkpg ioctl

Add a new operation code (BLKPG_RESIZE_PARTITION) to the BLKPG ioctl that
allows altering the size of an existing partition, even if it is currently
in use.

This patch converts hd_struct->nr_sects into sequence counter because
One might extend a partition while IO is happening to it and update of
nr_sects can be non-atomic on 32bit machines with 64bit sector_t. This
can lead to issues like reading inconsistent size of a partition. Sequence
counter have been used so that readers don't have to take bdev mutex lock
as we call sector_in_part() very frequently.

Now all the access to hd_struct->nr_sects should happen using sequence
counter read/update helper functions part_nr_sects_read/part_nr_sects_write.
There is one exception though, set_capacity()/get_capacity(). I think
theoritically race should exist there too but this patch does not
modify set_capacity()/get_capacity() due to sheer number of call sites
and I am afraid that change might break something. I have left that as a
TODO item. We can handle it later if need be. This patch does not introduce
any new races as such w.r.t set_capacity()/get_capacity().

v2: Add CONFIG_LBDAF test to UP preempt case as suggested by Phillip.

Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Phillip Susi <psusi@ubuntu.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

1 files changed, 56 insertions, 3 deletions

diff --git a/block/ioctl.c b/block/ioctl.c
index ba15b2dbfb98..4476e0e85d16 100644
--- a/block/ioctl.c
+++ b/block/ioctl.c
@@ -13,7 +13,7 @@ static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user
 {
         struct block_device *bdevp;
         struct gendisk *disk;
-        struct hd_struct *part;
+        struct hd_struct *part, *lpart;
         struct blkpg_ioctl_arg a;
         struct blkpg_partition p;
         struct disk_part_iter piter;
@@ -36,8 +36,8 @@ static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user
                 case BLKPG_ADD_PARTITION:
                         start = p.start >> 9;
                         length = p.length >> 9;
-                        /* check for fit in a hd_struct */ 
-                        if (sizeof(sector_t) == sizeof(long) && 
+                        /* check for fit in a hd_struct */
+                        if (sizeof(sector_t) == sizeof(long) &&
                             sizeof(long long) > sizeof(long)) {
                                 long pstart = start, plength = length;
                                 if (pstart != start || plength != length
@@ -92,6 +92,59 @@ static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user
                         bdput(bdevp);
 
                         return 0;
+                case BLKPG_RESIZE_PARTITION:
+                        start = p.start >> 9;
+                        /* new length of partition in bytes */
+                        length = p.length >> 9;
+                        /* check for fit in a hd_struct */
+                        if (sizeof(sector_t) == sizeof(long) &&
+                            sizeof(long long) > sizeof(long)) {
+                                long pstart = start, plength = length;
+                                if (pstart != start || plength != length
+                                    || pstart < 0 || plength < 0)
+                                        return -EINVAL;
+                        }
+                        part = disk_get_part(disk, partno);
+                        if (!part)
+                                return -ENXIO;
+                        bdevp = bdget(part_devt(part));
+                        if (!bdevp) {
+                                disk_put_part(part);
+                                return -ENOMEM;
+                        }
+                        mutex_lock(&bdevp->bd_mutex);
+                        mutex_lock_nested(&bdev->bd_mutex, 1);
+                        if (start != part->start_sect) {
+                                mutex_unlock(&bdevp->bd_mutex);
+                                mutex_unlock(&bdev->bd_mutex);
+                                bdput(bdevp);
+                                disk_put_part(part);
+                                return -EINVAL;
+                        }
+                        /* overlap? */
+                        disk_part_iter_init(&piter, disk,
+                                            DISK_PITER_INCL_EMPTY);
+                        while ((lpart = disk_part_iter_next(&piter))) {
+                                if (lpart->partno != partno &&
+                                   !(start + length <= lpart->start_sect ||
+                                   start >= lpart->start_sect + lpart->nr_sects)
+                                   ) {
+                                        disk_part_iter_exit(&piter);
+                                        mutex_unlock(&bdevp->bd_mutex);
+                                        mutex_unlock(&bdev->bd_mutex);
+                                        bdput(bdevp);
+                                        disk_put_part(part);
+                                        return -EBUSY;
+                                }
+                        }
+                        disk_part_iter_exit(&piter);
+                        part_nr_sects_write(part, (sector_t)length);
+                        i_size_write(bdevp->bd_inode, p.length);
+                        mutex_unlock(&bdevp->bd_mutex);
+                        mutex_unlock(&bdev->bd_mutex);
+                        bdput(bdevp);
+                        disk_put_part(part);
+                        return 0;
                 default:
                         return -EINVAL;
         }