nfs: new subdir Documentation/filesystems/nfs

[safe/jmp/linux-2.6] / block / compat_ioctl.c

diff --git a/block/compat_ioctl.c b/block/compat_ioctl.c
index 504344d..9bd086c 100644 (file)
--- a/block/compat_ioctl.c
+++ b/block/compat_ioctl.c
@@ -21,6 +21,11 @@ static int compat_put_int(unsigned long arg, int val)
        return put_user(val, (compat_int_t __user *)compat_ptr(arg));
 }
 
        return put_user(val, (compat_int_t __user *)compat_ptr(arg));
 }
 

+static int compat_put_uint(unsigned long arg, unsigned int val)
+{
+       return put_user(val, (compat_uint_t __user *)compat_ptr(arg));
+}
+

 static int compat_put_long(unsigned long arg, long val)
 {
        return put_user(val, (compat_long_t __user *)compat_ptr(arg));
 static int compat_put_long(unsigned long arg, long val)
 {
        return put_user(val, (compat_long_t __user *)compat_ptr(arg));


@@ -177,7 +182,7 @@ struct compat_blkpg_ioctl_arg {
        compat_caddr_t data;
 };
 
        compat_caddr_t data;
 };
 

-static int compat_blkpg_ioctl(struct inode *inode, struct file *file,
+static int compat_blkpg_ioctl(struct block_device *bdev, fmode_t mode,

                unsigned int cmd, struct compat_blkpg_ioctl_arg __user *ua32)
 {
        struct blkpg_ioctl_arg __user *a = compat_alloc_user_space(sizeof(*a));
                unsigned int cmd, struct compat_blkpg_ioctl_arg __user *ua32)
 {
        struct blkpg_ioctl_arg __user *a = compat_alloc_user_space(sizeof(*a));


@@ -196,7 +201,7 @@ static int compat_blkpg_ioctl(struct inode *inode, struct file *file,
        if (err)
                return err;
 
        if (err)
                return err;
 

-       return blkdev_ioctl(inode, file, cmd, (unsigned long)a);
+       return blkdev_ioctl(bdev, mode, cmd, (unsigned long)a);

 }
 
 #define BLKBSZGET_32           _IOR(0x12, 112, int)
 }
 
 #define BLKBSZGET_32           _IOR(0x12, 112, int)


@@ -568,7 +573,7 @@ static int compat_blk_trace_setup(struct block_device *bdev, char __user *arg)
        memcpy(&buts.name, &cbuts.name, 32);
 
        mutex_lock(&bdev->bd_mutex);
        memcpy(&buts.name, &cbuts.name, 32);
 
        mutex_lock(&bdev->bd_mutex);

-       ret = do_blk_trace_setup(q, b, bdev->bd_dev, &buts);
+       ret = do_blk_trace_setup(q, b, bdev->bd_dev, bdev, &buts);

        mutex_unlock(&bdev->bd_mutex);
        if (ret)
                return ret;
        mutex_unlock(&bdev->bd_mutex);
        if (ret)
                return ret;


@@ -582,8 +587,6 @@ static int compat_blk_trace_setup(struct block_device *bdev, char __user *arg)
 static int compat_blkdev_driver_ioctl(struct block_device *bdev, fmode_t mode,
                        unsigned cmd, unsigned long arg)
 {
 static int compat_blkdev_driver_ioctl(struct block_device *bdev, fmode_t mode,
                        unsigned cmd, unsigned long arg)
 {

-       int ret;
-

        switch (cmd) {
        case HDIO_GET_UNMASKINTR:
        case HDIO_GET_MULTCOUNT:
        switch (cmd) {
        case HDIO_GET_UNMASKINTR:
        case HDIO_GET_MULTCOUNT:


@@ -679,6 +682,29 @@ static int compat_blkdev_driver_ioctl(struct block_device *bdev, fmode_t mode,
        case DVD_WRITE_STRUCT:
        case DVD_AUTH:
                arg = (unsigned long)compat_ptr(arg);
        case DVD_WRITE_STRUCT:
        case DVD_AUTH:
                arg = (unsigned long)compat_ptr(arg);

+       /* These intepret arg as an unsigned long, not as a pointer,
+        * so we must not do compat_ptr() conversion. */
+       case HDIO_SET_MULTCOUNT:
+       case HDIO_SET_UNMASKINTR:
+       case HDIO_SET_KEEPSETTINGS:
+       case HDIO_SET_32BIT:
+       case HDIO_SET_NOWERR:
+       case HDIO_SET_DMA:
+       case HDIO_SET_PIO_MODE:
+       case HDIO_SET_NICE:
+       case HDIO_SET_WCACHE:
+       case HDIO_SET_ACOUSTIC:
+       case HDIO_SET_BUSSTATE:
+       case HDIO_SET_ADDRESS:
+       case CDROMEJECT_SW:
+       case CDROM_SET_OPTIONS:
+       case CDROM_CLEAR_OPTIONS:
+       case CDROM_SELECT_SPEED:
+       case CDROM_SELECT_DISC:
+       case CDROM_MEDIA_CHANGED:
+       case CDROM_DRIVE_STATUS:
+       case CDROM_LOCKDOOR:
+       case CDROM_DEBUG:

                break;
        default:
                /* unknown ioctl number */
                break;
        default:
                /* unknown ioctl number */


@@ -688,12 +714,54 @@ static int compat_blkdev_driver_ioctl(struct block_device *bdev, fmode_t mode,
        return __blkdev_driver_ioctl(bdev, mode, cmd, arg);
 }
 
        return __blkdev_driver_ioctl(bdev, mode, cmd, arg);
 }
 

-static int compat_blkdev_locked_ioctl(struct block_device *bdev,
-                               unsigned cmd, unsigned long arg)
+/* Most of the generic ioctls are handled in the normal fallback path.
+   This assumes the blkdev's low level compat_ioctl always returns
+   ENOIOCTLCMD for unknown ioctls. */
+long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)

 {
 {

+       int ret = -ENOIOCTLCMD;
+       struct inode *inode = file->f_mapping->host;
+       struct block_device *bdev = inode->i_bdev;
+       struct gendisk *disk = bdev->bd_disk;
+       fmode_t mode = file->f_mode;

        struct backing_dev_info *bdi;
        struct backing_dev_info *bdi;

+       loff_t size;
+
+       /*
+        * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
+        * to updated it before every ioctl.
+        */
+       if (file->f_flags & O_NDELAY)
+               mode |= FMODE_NDELAY;
+       else
+               mode &= ~FMODE_NDELAY;

 
        switch (cmd) {
 
        switch (cmd) {

+       case HDIO_GETGEO:
+               return compat_hdio_getgeo(disk, bdev, compat_ptr(arg));
+       case BLKPBSZGET:
+               return compat_put_uint(arg, bdev_physical_block_size(bdev));
+       case BLKIOMIN:
+               return compat_put_uint(arg, bdev_io_min(bdev));
+       case BLKIOOPT:
+               return compat_put_uint(arg, bdev_io_opt(bdev));
+       case BLKALIGNOFF:
+               return compat_put_int(arg, bdev_alignment_offset(bdev));
+       case BLKFLSBUF:
+       case BLKROSET:
+       case BLKDISCARD:
+       /*
+        * the ones below are implemented in blkdev_locked_ioctl,
+        * but we call blkdev_ioctl, which gets the lock for us
+        */
+       case BLKRRPART:
+               return blkdev_ioctl(bdev, mode, cmd,
+                               (unsigned long)compat_ptr(arg));
+       case BLKBSZSET_32:
+               return blkdev_ioctl(bdev, mode, BLKBSZSET,
+                               (unsigned long)compat_ptr(arg));
+       case BLKPG:
+               return compat_blkpg_ioctl(bdev, mode, cmd, compat_ptr(arg));

        case BLKRAGET:
        case BLKFRAGET:
                if (!arg)
        case BLKRAGET:
        case BLKFRAGET:
                if (!arg)


@@ -708,10 +776,10 @@ static int compat_blkdev_locked_ioctl(struct block_device *bdev,
        case BLKBSZGET_32: /* get the logical block size (cf. BLKSSZGET) */
                return compat_put_int(arg, block_size(bdev));
        case BLKSSZGET: /* get block device hardware sector size */
        case BLKBSZGET_32: /* get the logical block size (cf. BLKSSZGET) */
                return compat_put_int(arg, block_size(bdev));
        case BLKSSZGET: /* get block device hardware sector size */

-               return compat_put_int(arg, bdev_hardsect_size(bdev));
+               return compat_put_int(arg, bdev_logical_block_size(bdev));

        case BLKSECTGET:
                return compat_put_ushort(arg,
        case BLKSECTGET:
                return compat_put_ushort(arg,

-                                        bdev_get_queue(bdev)->max_sectors);
+                                        queue_max_sectors(bdev_get_queue(bdev)));

        case BLKRASET: /* compatible, but no compat_ptr (!) */
        case BLKFRASET:
                if (!capable(CAP_SYS_ADMIN))
        case BLKRASET: /* compatible, but no compat_ptr (!) */
        case BLKFRASET:
                if (!capable(CAP_SYS_ADMIN))


@@ -722,64 +790,31 @@ static int compat_blkdev_locked_ioctl(struct block_device *bdev,
                bdi->ra_pages = (arg * 512) / PAGE_CACHE_SIZE;
                return 0;
        case BLKGETSIZE:
                bdi->ra_pages = (arg * 512) / PAGE_CACHE_SIZE;
                return 0;
        case BLKGETSIZE:

-               if ((bdev->bd_inode->i_size >> 9) > ~0UL)
+               size = bdev->bd_inode->i_size;
+               if ((size >> 9) > ~0UL)

                        return -EFBIG;
                        return -EFBIG;

-               return compat_put_ulong(arg, bdev->bd_inode->i_size >> 9);
+               return compat_put_ulong(arg, size >> 9);

 
        case BLKGETSIZE64_32:
                return compat_put_u64(arg, bdev->bd_inode->i_size);
 
        case BLKTRACESETUP32:
 
        case BLKGETSIZE64_32:
                return compat_put_u64(arg, bdev->bd_inode->i_size);
 
        case BLKTRACESETUP32:

-               return compat_blk_trace_setup(bdev, compat_ptr(arg));
+               lock_kernel();
+               ret = compat_blk_trace_setup(bdev, compat_ptr(arg));
+               unlock_kernel();
+               return ret;

        case BLKTRACESTART: /* compatible */
        case BLKTRACESTOP:  /* compatible */
        case BLKTRACETEARDOWN: /* compatible */
        case BLKTRACESTART: /* compatible */
        case BLKTRACESTOP:  /* compatible */
        case BLKTRACETEARDOWN: /* compatible */

-               return blk_trace_ioctl(bdev, cmd, compat_ptr(arg));
-       }
-       return -ENOIOCTLCMD;
-}
-
-/* Most of the generic ioctls are handled in the normal fallback path.
-   This assumes the blkdev's low level compat_ioctl always returns
-   ENOIOCTLCMD for unknown ioctls. */
-long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
-{
-       int ret = -ENOIOCTLCMD;
-       struct inode *inode = file->f_mapping->host;
-       struct block_device *bdev = inode->i_bdev;
-       struct gendisk *disk = bdev->bd_disk;
-       fmode_t mode = file->f_mode;
-       if (file->f_flags & O_NDELAY)
-               mode |= FMODE_NDELAY_NOW;
-
-       switch (cmd) {
-       case HDIO_GETGEO:
-               return compat_hdio_getgeo(disk, bdev, compat_ptr(arg));
-       case BLKFLSBUF:
-       case BLKROSET:
-       case BLKDISCARD:
-       /*
-        * the ones below are implemented in blkdev_locked_ioctl,
-        * but we call blkdev_ioctl, which gets the lock for us
-        */
-       case BLKRRPART:
-               return blkdev_ioctl(inode, file, cmd,
-                               (unsigned long)compat_ptr(arg));
-       case BLKBSZSET_32:
-               return blkdev_ioctl(inode, file, BLKBSZSET,
-                               (unsigned long)compat_ptr(arg));
-       case BLKPG:
-               return compat_blkpg_ioctl(inode, file, cmd, compat_ptr(arg));
-       }
-
-       lock_kernel();
-       ret = compat_blkdev_locked_ioctl(bdev, cmd, arg);
-       unlock_kernel();
-       if (ret == -ENOIOCTLCMD && disk->fops->compat_ioctl)
-               ret = disk->fops->compat_ioctl(bdev, mode, cmd, arg);
-
-       if (ret != -ENOIOCTLCMD)
+               lock_kernel();
+               ret = blk_trace_ioctl(bdev, cmd, compat_ptr(arg));
+               unlock_kernel();

                return ret;
                return ret;

-
-       return compat_blkdev_driver_ioctl(bdev, mode, cmd, arg);
+       default:
+               if (disk->fops->compat_ioctl)
+                       ret = disk->fops->compat_ioctl(bdev, mode, cmd, arg);
+               if (ret == -ENOIOCTLCMD)
+                       ret = compat_blkdev_driver_ioctl(bdev, mode, cmd, arg);
+               return ret;
+       }

 }
 }