block/ioctl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/capability.h>
   3 #include <linux/compat.h>
   4 #include <linux/blkdev.h>
   5 #include <linux/export.h>
   6 #include <linux/gfp.h>
   7 #include <linux/blkpg.h>
   8 #include <linux/hdreg.h>
   9 #include <linux/backing-dev.h>
  10 #include <linux/fs.h>
  11 #include <linux/blktrace_api.h>
  12 #include <linux/pr.h>
  13 #include <linux/uaccess.h>
  14 #include "blk.h"
  15
  16 static int blkpg_do_ioctl(struct block_device *bdev,
  17                           struct blkpg_partition __user *upart, int op)
  18 {
  19         struct gendisk *disk = bdev->bd_disk;
  20         struct blkpg_partition p;
  21         sector_t start, length;
  22
  23         if (!capable(CAP_SYS_ADMIN))
  24                 return -EACCES;
  25         if (copy_from_user(&p, upart, sizeof(struct blkpg_partition)))
  26                 return -EFAULT;
  27         if (bdev_is_partition(bdev))
  28                 return -EINVAL;
  29
  30         if (p.pno <= 0)
  31                 return -EINVAL;
  32
  33         if (op == BLKPG_DEL_PARTITION)
  34                 return bdev_del_partition(disk, p.pno);
  35
  36         if (p.start < 0 || p.length <= 0 || p.start + p.length < 0)
  37                 return -EINVAL;
  38         /* Check that the partition is aligned to the block size */
  39         if (!IS_ALIGNED(p.start | p.length, bdev_logical_block_size(bdev)))
  40                 return -EINVAL;
  41
  42         start = p.start >> SECTOR_SHIFT;
  43         length = p.length >> SECTOR_SHIFT;
  44
  45         switch (op) {
  46         case BLKPG_ADD_PARTITION:
  47                 return bdev_add_partition(disk, p.pno, start, length);
  48         case BLKPG_RESIZE_PARTITION:
  49                 return bdev_resize_partition(disk, p.pno, start, length);
  50         default:
  51                 return -EINVAL;
  52         }
  53 }
  54
  55 static int blkpg_ioctl(struct block_device *bdev,
  56                        struct blkpg_ioctl_arg __user *arg)
  57 {
  58         struct blkpg_partition __user *udata;
  59         int op;
  60
  61         if (get_user(op, &arg->op) || get_user(udata, &arg->data))
  62                 return -EFAULT;
  63
  64         return blkpg_do_ioctl(bdev, udata, op);
  65 }
  66
  67 #ifdef CONFIG_COMPAT
  68 struct compat_blkpg_ioctl_arg {
  69         compat_int_t op;
  70         compat_int_t flags;
  71         compat_int_t datalen;
  72         compat_caddr_t data;
  73 };
  74
  75 static int compat_blkpg_ioctl(struct block_device *bdev,
  76                               struct compat_blkpg_ioctl_arg __user *arg)
  77 {
  78         compat_caddr_t udata;
  79         int op;
  80
  81         if (get_user(op, &arg->op) || get_user(udata, &arg->data))
  82                 return -EFAULT;
  83
  84         return blkpg_do_ioctl(bdev, compat_ptr(udata), op);
  85 }
  86 #endif
  87
  88 static int blk_ioctl_discard(struct block_device *bdev, fmode_t mode,
  89                 unsigned long arg)
  90 {
  91         uint64_t range[2];
  92         uint64_t start, len, end;
  93         struct inode *inode = bdev->bd_inode;
  94         int err;
  95
  96         if (!(mode & FMODE_WRITE))
  97                 return -EBADF;
  98
  99         if (!bdev_max_discard_sectors(bdev))
 100                 return -EOPNOTSUPP;
 101
 102         if (copy_from_user(range, (void __user *)arg, sizeof(range)))
 103                 return -EFAULT;
 104
 105         start = range[0];
 106         len = range[1];
 107
 108         if (start & 511)
 109                 return -EINVAL;
 110         if (len & 511)
 111                 return -EINVAL;
 112
 113         if (check_add_overflow(start, len, &end) ||
 114             end > bdev_nr_bytes(bdev))
 115                 return -EINVAL;
 116
 117         filemap_invalidate_lock(inode->i_mapping);
 118         err = truncate_bdev_range(bdev, mode, start, start + len - 1);
 119         if (err)
 120                 goto fail;
 121         err = blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_KERNEL);
 122 fail:
 123         filemap_invalidate_unlock(inode->i_mapping);
 124         return err;
 125 }
 126
 127 static int blk_ioctl_secure_erase(struct block_device *bdev, fmode_t mode,
 128                 void __user *argp)
 129 {
 130         uint64_t start, len;
 131         uint64_t range[2];
 132         int err;
 133
 134         if (!(mode & FMODE_WRITE))
 135                 return -EBADF;
 136         if (!bdev_max_secure_erase_sectors(bdev))
 137                 return -EOPNOTSUPP;
 138         if (copy_from_user(range, argp, sizeof(range)))
 139                 return -EFAULT;
 140
 141         start = range[0];
 142         len = range[1];
 143         if ((start & 511) || (len & 511))
 144                 return -EINVAL;
 145         if (start + len > bdev_nr_bytes(bdev))
 146                 return -EINVAL;
 147
 148         filemap_invalidate_lock(bdev->bd_inode->i_mapping);
 149         err = truncate_bdev_range(bdev, mode, start, start + len - 1);
 150         if (!err)
 151                 err = blkdev_issue_secure_erase(bdev, start >> 9, len >> 9,
 152                                                 GFP_KERNEL);
 153         filemap_invalidate_unlock(bdev->bd_inode->i_mapping);
 154         return err;
 155 }
 156
 157
 158 static int blk_ioctl_zeroout(struct block_device *bdev, fmode_t mode,
 159                 unsigned long arg)
 160 {
 161         uint64_t range[2];
 162         uint64_t start, end, len;
 163         struct inode *inode = bdev->bd_inode;
 164         int err;
 165
 166         if (!(mode & FMODE_WRITE))
 167                 return -EBADF;
 168
 169         if (copy_from_user(range, (void __user *)arg, sizeof(range)))
 170                 return -EFAULT;
 171
 172         start = range[0];
 173         len = range[1];
 174         end = start + len - 1;
 175
 176         if (start & 511)
 177                 return -EINVAL;
 178         if (len & 511)
 179                 return -EINVAL;
 180         if (end >= (uint64_t)bdev_nr_bytes(bdev))
 181                 return -EINVAL;
 182         if (end < start)
 183                 return -EINVAL;
 184
 185         /* Invalidate the page cache, including dirty pages */
 186         filemap_invalidate_lock(inode->i_mapping);
 187         err = truncate_bdev_range(bdev, mode, start, end);
 188         if (err)
 189                 goto fail;
 190
 191         err = blkdev_issue_zeroout(bdev, start >> 9, len >> 9, GFP_KERNEL,
 192                                    BLKDEV_ZERO_NOUNMAP);
 193
 194 fail:
 195         filemap_invalidate_unlock(inode->i_mapping);
 196         return err;
 197 }
 198
 199 static int put_ushort(unsigned short __user *argp, unsigned short val)
 200 {
 201         return put_user(val, argp);
 202 }
 203
 204 static int put_int(int __user *argp, int val)
 205 {
 206         return put_user(val, argp);
 207 }
 208
 209 static int put_uint(unsigned int __user *argp, unsigned int val)
 210 {
 211         return put_user(val, argp);
 212 }
 213
 214 static int put_long(long __user *argp, long val)
 215 {
 216         return put_user(val, argp);
 217 }
 218
 219 static int put_ulong(unsigned long __user *argp, unsigned long val)
 220 {
 221         return put_user(val, argp);
 222 }
 223
 224 static int put_u64(u64 __user *argp, u64 val)
 225 {
 226         return put_user(val, argp);
 227 }
 228
 229 #ifdef CONFIG_COMPAT
 230 static int compat_put_long(compat_long_t __user *argp, long val)
 231 {
 232         return put_user(val, argp);
 233 }
 234
 235 static int compat_put_ulong(compat_ulong_t __user *argp, compat_ulong_t val)
 236 {
 237         return put_user(val, argp);
 238 }
 239 #endif
 240
 241 #ifdef CONFIG_COMPAT
 242 /*
 243  * This is the equivalent of compat_ptr_ioctl(), to be used by block
 244  * drivers that implement only commands that are completely compatible
 245  * between 32-bit and 64-bit user space
 246  */
 247 int blkdev_compat_ptr_ioctl(struct block_device *bdev, fmode_t mode,
 248                         unsigned cmd, unsigned long arg)
 249 {
 250         struct gendisk *disk = bdev->bd_disk;
 251
 252         if (disk->fops->ioctl)
 253                 return disk->fops->ioctl(bdev, mode, cmd,
 254                                          (unsigned long)compat_ptr(arg));
 255
 256         return -ENOIOCTLCMD;
 257 }
 258 EXPORT_SYMBOL(blkdev_compat_ptr_ioctl);
 259 #endif
 260
 261 static int blkdev_pr_register(struct block_device *bdev,
 262                 struct pr_registration __user *arg)
 263 {
 264         const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
 265         struct pr_registration reg;
 266
 267         if (!capable(CAP_SYS_ADMIN))
 268                 return -EPERM;
 269         if (!ops || !ops->pr_register)
 270                 return -EOPNOTSUPP;
 271         if (copy_from_user(&reg, arg, sizeof(reg)))
 272                 return -EFAULT;
 273
 274         if (reg.flags & ~PR_FL_IGNORE_KEY)
 275                 return -EOPNOTSUPP;
 276         return ops->pr_register(bdev, reg.old_key, reg.new_key, reg.flags);
 277 }
 278
 279 static int blkdev_pr_reserve(struct block_device *bdev,
 280                 struct pr_reservation __user *arg)
 281 {
 282         const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
 283         struct pr_reservation rsv;
 284
 285         if (!capable(CAP_SYS_ADMIN))
 286                 return -EPERM;
 287         if (!ops || !ops->pr_reserve)
 288                 return -EOPNOTSUPP;
 289         if (copy_from_user(&rsv, arg, sizeof(rsv)))
 290                 return -EFAULT;
 291
 292         if (rsv.flags & ~PR_FL_IGNORE_KEY)
 293                 return -EOPNOTSUPP;
 294         return ops->pr_reserve(bdev, rsv.key, rsv.type, rsv.flags);
 295 }
 296
 297 static int blkdev_pr_release(struct block_device *bdev,
 298                 struct pr_reservation __user *arg)
 299 {
 300         const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
 301         struct pr_reservation rsv;
 302
 303         if (!capable(CAP_SYS_ADMIN))
 304                 return -EPERM;
 305         if (!ops || !ops->pr_release)
 306                 return -EOPNOTSUPP;
 307         if (copy_from_user(&rsv, arg, sizeof(rsv)))
 308                 return -EFAULT;
 309
 310         if (rsv.flags)
 311                 return -EOPNOTSUPP;
 312         return ops->pr_release(bdev, rsv.key, rsv.type);
 313 }
 314
 315 static int blkdev_pr_preempt(struct block_device *bdev,
 316                 struct pr_preempt __user *arg, bool abort)
 317 {
 318         const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
 319         struct pr_preempt p;
 320
 321         if (!capable(CAP_SYS_ADMIN))
 322                 return -EPERM;
 323         if (!ops || !ops->pr_preempt)
 324                 return -EOPNOTSUPP;
 325         if (copy_from_user(&p, arg, sizeof(p)))
 326                 return -EFAULT;
 327
 328         if (p.flags)
 329                 return -EOPNOTSUPP;
 330         return ops->pr_preempt(bdev, p.old_key, p.new_key, p.type, abort);
 331 }
 332
 333 static int blkdev_pr_clear(struct block_device *bdev,
 334                 struct pr_clear __user *arg)
 335 {
 336         const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
 337         struct pr_clear c;
 338
 339         if (!capable(CAP_SYS_ADMIN))
 340                 return -EPERM;
 341         if (!ops || !ops->pr_clear)
 342                 return -EOPNOTSUPP;
 343         if (copy_from_user(&c, arg, sizeof(c)))
 344                 return -EFAULT;
 345
 346         if (c.flags)
 347                 return -EOPNOTSUPP;
 348         return ops->pr_clear(bdev, c.key);
 349 }
 350
 351 static int blkdev_flushbuf(struct block_device *bdev, fmode_t mode,
 352                 unsigned cmd, unsigned long arg)
 353 {
 354         if (!capable(CAP_SYS_ADMIN))
 355                 return -EACCES;
 356         fsync_bdev(bdev);
 357         invalidate_bdev(bdev);
 358         return 0;
 359 }
 360
 361 static int blkdev_roset(struct block_device *bdev, fmode_t mode,
 362                 unsigned cmd, unsigned long arg)
 363 {
 364         int ret, n;
 365
 366         if (!capable(CAP_SYS_ADMIN))
 367                 return -EACCES;
 368
 369         if (get_user(n, (int __user *)arg))
 370                 return -EFAULT;
 371         if (bdev->bd_disk->fops->set_read_only) {
 372                 ret = bdev->bd_disk->fops->set_read_only(bdev, n);
 373                 if (ret)
 374                         return ret;
 375         }
 376         bdev->bd_read_only = n;
 377         return 0;
 378 }
 379
 380 static int blkdev_getgeo(struct block_device *bdev,
 381                 struct hd_geometry __user *argp)
 382 {
 383         struct gendisk *disk = bdev->bd_disk;
 384         struct hd_geometry geo;
 385         int ret;
 386
 387         if (!argp)
 388                 return -EINVAL;
 389         if (!disk->fops->getgeo)
 390                 return -ENOTTY;
 391
 392         /*
 393          * We need to set the startsect first, the driver may
 394          * want to override it.
 395          */
 396         memset(&geo, 0, sizeof(geo));
 397         geo.start = get_start_sect(bdev);
 398         ret = disk->fops->getgeo(bdev, &geo);
 399         if (ret)
 400                 return ret;
 401         if (copy_to_user(argp, &geo, sizeof(geo)))
 402                 return -EFAULT;
 403         return 0;
 404 }
 405
 406 #ifdef CONFIG_COMPAT
 407 struct compat_hd_geometry {
 408         unsigned char heads;
 409         unsigned char sectors;
 410         unsigned short cylinders;
 411         u32 start;
 412 };
 413
 414 static int compat_hdio_getgeo(struct block_device *bdev,
 415                               struct compat_hd_geometry __user *ugeo)
 416 {
 417         struct gendisk *disk = bdev->bd_disk;
 418         struct hd_geometry geo;
 419         int ret;
 420
 421         if (!ugeo)
 422                 return -EINVAL;
 423         if (!disk->fops->getgeo)
 424                 return -ENOTTY;
 425
 426         memset(&geo, 0, sizeof(geo));
 427         /*
 428          * We need to set the startsect first, the driver may
 429          * want to override it.
 430          */
 431         geo.start = get_start_sect(bdev);
 432         ret = disk->fops->getgeo(bdev, &geo);
 433         if (ret)
 434                 return ret;
 435
 436         ret = copy_to_user(ugeo, &geo, 4);
 437         ret |= put_user(geo.start, &ugeo->start);
 438         if (ret)
 439                 ret = -EFAULT;
 440
 441         return ret;
 442 }
 443 #endif
 444
 445 /* set the logical block size */
 446 static int blkdev_bszset(struct block_device *bdev, fmode_t mode,
 447                 int __user *argp)
 448 {
 449         int ret, n;
 450
 451         if (!capable(CAP_SYS_ADMIN))
 452                 return -EACCES;
 453         if (!argp)
 454                 return -EINVAL;
 455         if (get_user(n, argp))
 456                 return -EFAULT;
 457
 458         if (mode & FMODE_EXCL)
 459                 return set_blocksize(bdev, n);
 460
 461         if (IS_ERR(blkdev_get_by_dev(bdev->bd_dev, mode | FMODE_EXCL, &bdev)))
 462                 return -EBUSY;
 463         ret = set_blocksize(bdev, n);
 464         blkdev_put(bdev, mode | FMODE_EXCL);
 465
 466         return ret;
 467 }
 468
 469 /*
 470  * Common commands that are handled the same way on native and compat
 471  * user space. Note the separate arg/argp parameters that are needed
 472  * to deal with the compat_ptr() conversion.
 473  */
 474 static int blkdev_common_ioctl(struct block_device *bdev, fmode_t mode,
 475                                unsigned int cmd, unsigned long arg,
 476                                void __user *argp)
 477 {
 478         unsigned int max_sectors;
 479
 480         switch (cmd) {
 481         case BLKFLSBUF:
 482                 return blkdev_flushbuf(bdev, mode, cmd, arg);
 483         case BLKROSET:
 484                 return blkdev_roset(bdev, mode, cmd, arg);
 485         case BLKDISCARD:
 486                 return blk_ioctl_discard(bdev, mode, arg);
 487         case BLKSECDISCARD:
 488                 return blk_ioctl_secure_erase(bdev, mode, argp);
 489         case BLKZEROOUT:
 490                 return blk_ioctl_zeroout(bdev, mode, arg);
 491         case BLKGETDISKSEQ:
 492                 return put_u64(argp, bdev->bd_disk->diskseq);
 493         case BLKREPORTZONE:
 494                 return blkdev_report_zones_ioctl(bdev, mode, cmd, arg);
 495         case BLKRESETZONE:
 496         case BLKOPENZONE:
 497         case BLKCLOSEZONE:
 498         case BLKFINISHZONE:
 499                 return blkdev_zone_mgmt_ioctl(bdev, mode, cmd, arg);
 500         case BLKGETZONESZ:
 501                 return put_uint(argp, bdev_zone_sectors(bdev));
 502         case BLKGETNRZONES:
 503                 return put_uint(argp, bdev_nr_zones(bdev));
 504         case BLKROGET:
 505                 return put_int(argp, bdev_read_only(bdev) != 0);
 506         case BLKSSZGET: /* get block device logical block size */
 507                 return put_int(argp, bdev_logical_block_size(bdev));
 508         case BLKPBSZGET: /* get block device physical block size */
 509                 return put_uint(argp, bdev_physical_block_size(bdev));
 510         case BLKIOMIN:
 511                 return put_uint(argp, bdev_io_min(bdev));
 512         case BLKIOOPT:
 513                 return put_uint(argp, bdev_io_opt(bdev));
 514         case BLKALIGNOFF:
 515                 return put_int(argp, bdev_alignment_offset(bdev));
 516         case BLKDISCARDZEROES:
 517                 return put_uint(argp, 0);
 518         case BLKSECTGET:
 519                 max_sectors = min_t(unsigned int, USHRT_MAX,
 520                                     queue_max_sectors(bdev_get_queue(bdev)));
 521                 return put_ushort(argp, max_sectors);
 522         case BLKROTATIONAL:
 523                 return put_ushort(argp, !bdev_nonrot(bdev));
 524         case BLKRASET:
 525         case BLKFRASET:
 526                 if(!capable(CAP_SYS_ADMIN))
 527                         return -EACCES;
 528                 bdev->bd_disk->bdi->ra_pages = (arg * 512) / PAGE_SIZE;
 529                 return 0;
 530         case BLKRRPART:
 531                 if (!capable(CAP_SYS_ADMIN))
 532                         return -EACCES;
 533                 if (bdev_is_partition(bdev))
 534                         return -EINVAL;
 535                 return disk_scan_partitions(bdev->bd_disk, mode);
 536         case BLKTRACESTART:
 537         case BLKTRACESTOP:
 538         case BLKTRACETEARDOWN:
 539                 return blk_trace_ioctl(bdev, cmd, argp);
 540         case IOC_PR_REGISTER:
 541                 return blkdev_pr_register(bdev, argp);
 542         case IOC_PR_RESERVE:
 543                 return blkdev_pr_reserve(bdev, argp);
 544         case IOC_PR_RELEASE:
 545                 return blkdev_pr_release(bdev, argp);
 546         case IOC_PR_PREEMPT:
 547                 return blkdev_pr_preempt(bdev, argp, false);
 548         case IOC_PR_PREEMPT_ABORT:
 549                 return blkdev_pr_preempt(bdev, argp, true);
 550         case IOC_PR_CLEAR:
 551                 return blkdev_pr_clear(bdev, argp);
 552         default:
 553                 return -ENOIOCTLCMD;
 554         }
 555 }
 556
 557 /*
 558  * Always keep this in sync with compat_blkdev_ioctl()
 559  * to handle all incompatible commands in both functions.
 560  *
 561  * New commands must be compatible and go into blkdev_common_ioctl
 562  */
 563 long blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 564 {
 565         struct block_device *bdev = I_BDEV(file->f_mapping->host);
 566         void __user *argp = (void __user *)arg;
 567         fmode_t mode = file->f_mode;
 568         int ret;
 569
 570         /*
 571          * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
 572          * to updated it before every ioctl.
 573          */
 574         if (file->f_flags & O_NDELAY)
 575                 mode |= FMODE_NDELAY;
 576         else
 577                 mode &= ~FMODE_NDELAY;
 578
 579         switch (cmd) {
 580         /* These need separate implementations for the data structure */
 581         case HDIO_GETGEO:
 582                 return blkdev_getgeo(bdev, argp);
 583         case BLKPG:
 584                 return blkpg_ioctl(bdev, argp);
 585
 586         /* Compat mode returns 32-bit data instead of 'long' */
 587         case BLKRAGET:
 588         case BLKFRAGET:
 589                 if (!argp)
 590                         return -EINVAL;
 591                 return put_long(argp,
 592                         (bdev->bd_disk->bdi->ra_pages * PAGE_SIZE) / 512);
 593         case BLKGETSIZE:
 594                 if (bdev_nr_sectors(bdev) > ~0UL)
 595                         return -EFBIG;
 596                 return put_ulong(argp, bdev_nr_sectors(bdev));
 597
 598         /* The data is compatible, but the command number is different */
 599         case BLKBSZGET: /* get block device soft block size (cf. BLKSSZGET) */
 600                 return put_int(argp, block_size(bdev));
 601         case BLKBSZSET:
 602                 return blkdev_bszset(bdev, mode, argp);
 603         case BLKGETSIZE64:
 604                 return put_u64(argp, bdev_nr_bytes(bdev));
 605
 606         /* Incompatible alignment on i386 */
 607         case BLKTRACESETUP:
 608                 return blk_trace_ioctl(bdev, cmd, argp);
 609         default:
 610                 break;
 611         }
 612
 613         ret = blkdev_common_ioctl(bdev, mode, cmd, arg, argp);
 614         if (ret != -ENOIOCTLCMD)
 615                 return ret;
 616
 617         if (!bdev->bd_disk->fops->ioctl)
 618                 return -ENOTTY;
 619         return bdev->bd_disk->fops->ioctl(bdev, mode, cmd, arg);
 620 }
 621
 622 #ifdef CONFIG_COMPAT
 623
 624 #define BLKBSZGET_32            _IOR(0x12, 112, int)
 625 #define BLKBSZSET_32            _IOW(0x12, 113, int)
 626 #define BLKGETSIZE64_32         _IOR(0x12, 114, int)
 627
 628 /* Most of the generic ioctls are handled in the normal fallback path.
 629    This assumes the blkdev's low level compat_ioctl always returns
 630    ENOIOCTLCMD for unknown ioctls. */
 631 long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 632 {
 633         int ret;
 634         void __user *argp = compat_ptr(arg);
 635         struct block_device *bdev = I_BDEV(file->f_mapping->host);
 636         struct gendisk *disk = bdev->bd_disk;
 637         fmode_t mode = file->f_mode;
 638
 639         /*
 640          * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
 641          * to updated it before every ioctl.
 642          */
 643         if (file->f_flags & O_NDELAY)
 644                 mode |= FMODE_NDELAY;
 645         else
 646                 mode &= ~FMODE_NDELAY;
 647
 648         switch (cmd) {
 649         /* These need separate implementations for the data structure */
 650         case HDIO_GETGEO:
 651                 return compat_hdio_getgeo(bdev, argp);
 652         case BLKPG:
 653                 return compat_blkpg_ioctl(bdev, argp);
 654
 655         /* Compat mode returns 32-bit data instead of 'long' */
 656         case BLKRAGET:
 657         case BLKFRAGET:
 658                 if (!argp)
 659                         return -EINVAL;
 660                 return compat_put_long(argp,
 661                         (bdev->bd_disk->bdi->ra_pages * PAGE_SIZE) / 512);
 662         case BLKGETSIZE:
 663                 if (bdev_nr_sectors(bdev) > ~(compat_ulong_t)0)
 664                         return -EFBIG;
 665                 return compat_put_ulong(argp, bdev_nr_sectors(bdev));
 666
 667         /* The data is compatible, but the command number is different */
 668         case BLKBSZGET_32: /* get the logical block size (cf. BLKSSZGET) */
 669                 return put_int(argp, bdev_logical_block_size(bdev));
 670         case BLKBSZSET_32:
 671                 return blkdev_bszset(bdev, mode, argp);
 672         case BLKGETSIZE64_32:
 673                 return put_u64(argp, bdev_nr_bytes(bdev));
 674
 675         /* Incompatible alignment on i386 */
 676         case BLKTRACESETUP32:
 677                 return blk_trace_ioctl(bdev, cmd, argp);
 678         default:
 679                 break;
 680         }
 681
 682         ret = blkdev_common_ioctl(bdev, mode, cmd, arg, argp);
 683         if (ret == -ENOIOCTLCMD && disk->fops->compat_ioctl)
 684                 ret = disk->fops->compat_ioctl(bdev, mode, cmd, arg);
 685
 686         return ret;
 687 }
 688 #endif