1 files changed, 89 insertions, 84 deletions

diff --git a/block/ioctl.c b/block/ioctl.c
index 38bee321e1fa..c832d639b6e2 100644
--- a/block/ioctl.c
+++ b/block/ioctl.c
@@ -201,97 +201,41 @@ static int put_u64(unsigned long arg, u64 val)
         return put_user(val, (u64 __user *)arg);
 }
 
-static int blkdev_locked_ioctl(struct file *file, struct block_device *bdev,
-                                unsigned cmd, unsigned long arg)
-{
-        struct backing_dev_info *bdi;
-        int ret, n;
-
-        switch (cmd) {
-        case BLKRAGET:
-        case BLKFRAGET:
-                if (!arg)
-                        return -EINVAL;
-                bdi = blk_get_backing_dev_info(bdev);
-                if (bdi == NULL)
-                        return -ENOTTY;
-                return put_long(arg, (bdi->ra_pages * PAGE_CACHE_SIZE) / 512);
-        case BLKROGET:
-                return put_int(arg, bdev_read_only(bdev) != 0);
-        case BLKBSZGET: /* get the logical block size (cf. BLKSSZGET) */
-                return put_int(arg, block_size(bdev));
-        case BLKSSZGET: /* get block device hardware sector size */
-                return put_int(arg, bdev_hardsect_size(bdev));
-        case BLKSECTGET:
-                return put_ushort(arg, bdev_get_queue(bdev)->max_sectors);
-        case BLKRASET:
-        case BLKFRASET:
-                if(!capable(CAP_SYS_ADMIN))
-                        return -EACCES;
-                bdi = blk_get_backing_dev_info(bdev);
-                if (bdi == NULL)
-                        return -ENOTTY;
-                bdi->ra_pages = (arg * 512) / PAGE_CACHE_SIZE;
-                return 0;
-        case BLKBSZSET:
-                /* set the logical block size */
-                if (!capable(CAP_SYS_ADMIN))
-                        return -EACCES;
-                if (!arg)
-                        return -EINVAL;
-                if (get_user(n, (int __user *) arg))
-                        return -EFAULT;
-                if (bd_claim(bdev, file) < 0)
-                        return -EBUSY;
-                ret = set_blocksize(bdev, n);
-                bd_release(bdev);
-                return ret;
-        case BLKPG:
-                return blkpg_ioctl(bdev, (struct blkpg_ioctl_arg __user *) arg);
-        case BLKRRPART:
-                return blkdev_reread_part(bdev);
-        case BLKGETSIZE:
-                if ((bdev->bd_inode->i_size >> 9) > ~0UL)
-                        return -EFBIG;
-                return put_ulong(arg, bdev->bd_inode->i_size >> 9);
-        case BLKGETSIZE64:
-                return put_u64(arg, bdev->bd_inode->i_size);
-        case BLKTRACESTART:
-        case BLKTRACESTOP:
-        case BLKTRACESETUP:
-        case BLKTRACETEARDOWN:
-                return blk_trace_ioctl(bdev, cmd, (char __user *) arg);
-        }
-        return -ENOIOCTLCMD;
-}
-
-int blkdev_driver_ioctl(struct inode *inode, struct file *file,
-                        struct gendisk *disk, unsigned cmd, unsigned long arg)
+int __blkdev_driver_ioctl(struct block_device *bdev, fmode_t mode,
+                        unsigned cmd, unsigned long arg)
 {
+        struct gendisk *disk = bdev->bd_disk;
         int ret;
-        if (disk->fops->unlocked_ioctl)
-                return disk->fops->unlocked_ioctl(file, cmd, arg);
 
-        if (disk->fops->ioctl) {
+        if (disk->fops->ioctl)
+                return disk->fops->ioctl(bdev, mode, cmd, arg);
+
+        if (disk->fops->locked_ioctl) {
                 lock_kernel();
-                ret = disk->fops->ioctl(inode, file, cmd, arg);
+                ret = disk->fops->locked_ioctl(bdev, mode, cmd, arg);
                 unlock_kernel();
                 return ret;
         }
 
         return -ENOTTY;
 }
-EXPORT_SYMBOL_GPL(blkdev_driver_ioctl);
+/*
+ * For the record: _GPL here is only because somebody decided to slap it
+ * on the previous export.  Sheer idiocy, since it wasn't copyrightable
+ * at all and could be open-coded without any exports by anybody who cares.
+ */
+EXPORT_SYMBOL_GPL(__blkdev_driver_ioctl);
 
 /*
  * always keep this in sync with compat_blkdev_ioctl() and
  * compat_blkdev_locked_ioctl()
  */
-int blkdev_ioctl(struct inode *inode, struct file *file, unsigned cmd,
+int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
                         unsigned long arg)
 {
-        struct block_device *bdev = inode->i_bdev;
         struct gendisk *disk = bdev->bd_disk;
+        struct backing_dev_info *bdi;
+        loff_t size;
         int ret, n;
 
         switch(cmd) {
@@ -299,7 +243,7 @@ int blkdev_ioctl(struct inode *inode, struct file *file, unsigned cmd,
                 if (!capable(CAP_SYS_ADMIN))
                         return -EACCES;
 
-                ret = blkdev_driver_ioctl(inode, file, disk, cmd, arg);
+                ret = __blkdev_driver_ioctl(bdev, mode, cmd, arg);
                 /* -EINVAL to handle old uncorrected drivers */
                 if (ret != -EINVAL && ret != -ENOTTY)
                         return ret;
@@ -311,7 +255,7 @@ int blkdev_ioctl(struct inode *inode, struct file *file, unsigned cmd,
                 return 0;
 
         case BLKROSET:
-                ret = blkdev_driver_ioctl(inode, file, disk, cmd, arg);
+                ret = __blkdev_driver_ioctl(bdev, mode, cmd, arg);
                 /* -EINVAL to handle old uncorrected drivers */
                 if (ret != -EINVAL && ret != -ENOTTY)
                         return ret;
@@ -327,7 +271,7 @@ int blkdev_ioctl(struct inode *inode, struct file *file, unsigned cmd,
         case BLKDISCARD: {
                 uint64_t range[2];
 
-                if (!(file->f_mode & FMODE_WRITE))
+                if (!(mode & FMODE_WRITE))
                         return -EBADF;
 
                 if (copy_from_user(range, (void __user *)arg, sizeof(range)))
@@ -357,14 +301,75 @@ int blkdev_ioctl(struct inode *inode, struct file *file, unsigned cmd,
                         return -EFAULT;
                 return 0;
         }
-        }
-
-        lock_kernel();
-        ret = blkdev_locked_ioctl(file, bdev, cmd, arg);
-        unlock_kernel();
-        if (ret != -ENOIOCTLCMD)
+        case BLKRAGET:
+        case BLKFRAGET:
+                if (!arg)
+                        return -EINVAL;
+                bdi = blk_get_backing_dev_info(bdev);
+                if (bdi == NULL)
+                        return -ENOTTY;
+                return put_long(arg, (bdi->ra_pages * PAGE_CACHE_SIZE) / 512);
+        case BLKROGET:
+                return put_int(arg, bdev_read_only(bdev) != 0);
+        case BLKBSZGET: /* get the logical block size (cf. BLKSSZGET) */
+                return put_int(arg, block_size(bdev));
+        case BLKSSZGET: /* get block device hardware sector size */
+                return put_int(arg, bdev_hardsect_size(bdev));
+        case BLKSECTGET:
+                return put_ushort(arg, bdev_get_queue(bdev)->max_sectors);
+        case BLKRASET:
+        case BLKFRASET:
+                if(!capable(CAP_SYS_ADMIN))
+                        return -EACCES;
+                bdi = blk_get_backing_dev_info(bdev);
+                if (bdi == NULL)
+                        return -ENOTTY;
+                lock_kernel();
+                bdi->ra_pages = (arg * 512) / PAGE_CACHE_SIZE;
+                unlock_kernel();
+                return 0;
+        case BLKBSZSET:
+                /* set the logical block size */
+                if (!capable(CAP_SYS_ADMIN))
+                        return -EACCES;
+                if (!arg)
+                        return -EINVAL;
+                if (get_user(n, (int __user *) arg))
+                        return -EFAULT;
+                if (!(mode & FMODE_EXCL) && bd_claim(bdev, &bdev) < 0)
+                        return -EBUSY;
+                ret = set_blocksize(bdev, n);
+                if (!(mode & FMODE_EXCL))
+                        bd_release(bdev);
                 return ret;
-
-        return blkdev_driver_ioctl(inode, file, disk, cmd, arg);
+        case BLKPG:
+                lock_kernel();
+                ret = blkpg_ioctl(bdev, (struct blkpg_ioctl_arg __user *) arg);
+                unlock_kernel();
+                break;
+        case BLKRRPART:
+                lock_kernel();
+                ret = blkdev_reread_part(bdev);
+                unlock_kernel();
+                break;
+        case BLKGETSIZE:
+                size = bdev->bd_inode->i_size;
+                if ((size >> 9) > ~0UL)
+                        return -EFBIG;
+                return put_ulong(arg, size >> 9);
+        case BLKGETSIZE64:
+                return put_u64(arg, bdev->bd_inode->i_size);
+        case BLKTRACESTART:
+        case BLKTRACESTOP:
+        case BLKTRACESETUP:
+        case BLKTRACETEARDOWN:
+                lock_kernel();
+                ret = blk_trace_ioctl(bdev, cmd, (char __user *) arg);
+                unlock_kernel();
+                break;
+        default:
+                ret = __blkdev_driver_ioctl(bdev, mode, cmd, arg);
+        }
+        return ret;
 }
 EXPORT_SYMBOL_GPL(blkdev_ioctl);