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 <linux/pagemap.h> 15 #include <linux/io_uring/cmd.h> 16 #include <linux/blk-integrity.h> 17 #include <uapi/linux/blkdev.h> 18 #include "blk.h" 19 #include "blk-crypto-internal.h" 20 21 static int blkpg_do_ioctl(struct block_device *bdev, 22 struct blkpg_partition __user *upart, int op) 23 { 24 struct gendisk *disk = bdev->bd_disk; 25 struct blkpg_partition p; 26 sector_t start, length, capacity, end; 27 28 if (!capable(CAP_SYS_ADMIN)) 29 return -EACCES; 30 if (copy_from_user(&p, upart, sizeof(struct blkpg_partition))) 31 return -EFAULT; 32 if (bdev_is_partition(bdev)) 33 return -EINVAL; 34 35 if (p.pno <= 0) 36 return -EINVAL; 37 38 if (op == BLKPG_DEL_PARTITION) 39 return bdev_del_partition(disk, p.pno); 40 41 if (p.start < 0 || p.length <= 0 || LLONG_MAX - p.length < p.start) 42 return -EINVAL; 43 /* Check that the partition is aligned to the block size */ 44 if (!IS_ALIGNED(p.start | p.length, bdev_logical_block_size(bdev))) 45 return -EINVAL; 46 47 start = p.start >> SECTOR_SHIFT; 48 length = p.length >> SECTOR_SHIFT; 49 capacity = get_capacity(disk); 50 51 if (check_add_overflow(start, length, &end)) 52 return -EINVAL; 53 54 if (start >= capacity || end > capacity) 55 return -EINVAL; 56 57 switch (op) { 58 case BLKPG_ADD_PARTITION: 59 return bdev_add_partition(disk, p.pno, start, length); 60 case BLKPG_RESIZE_PARTITION: 61 return bdev_resize_partition(disk, p.pno, start, length); 62 default: 63 return -EINVAL; 64 } 65 } 66 67 static int blkpg_ioctl(struct block_device *bdev, 68 struct blkpg_ioctl_arg __user *arg) 69 { 70 struct blkpg_partition __user *udata; 71 int op; 72 73 if (get_user(op, &arg->op) || get_user(udata, &arg->data)) 74 return -EFAULT; 75 76 return blkpg_do_ioctl(bdev, udata, op); 77 } 78 79 #ifdef CONFIG_COMPAT 80 struct compat_blkpg_ioctl_arg { 81 compat_int_t op; 82 compat_int_t flags; 83 compat_int_t datalen; 84 compat_caddr_t data; 85 }; 86 87 static int compat_blkpg_ioctl(struct block_device *bdev, 88 struct compat_blkpg_ioctl_arg __user *arg) 89 { 90 compat_caddr_t udata; 91 int op; 92 93 if (get_user(op, &arg->op) || get_user(udata, &arg->data)) 94 return -EFAULT; 95 96 return blkpg_do_ioctl(bdev, compat_ptr(udata), op); 97 } 98 #endif 99 100 /* 101 * Check that [start, start + len) is a valid range from the block device's 102 * perspective, including verifying that it can be correctly translated into 103 * logical block addresses. 104 */ 105 static int blk_validate_byte_range(struct block_device *bdev, 106 uint64_t start, uint64_t len) 107 { 108 unsigned int bs_mask = bdev_logical_block_size(bdev) - 1; 109 uint64_t end; 110 111 if ((start | len) & bs_mask) 112 return -EINVAL; 113 if (!len) 114 return -EINVAL; 115 if (check_add_overflow(start, len, &end) || end > bdev_nr_bytes(bdev)) 116 return -EINVAL; 117 118 return 0; 119 } 120 121 static int blk_ioctl_discard(struct block_device *bdev, blk_mode_t mode, 122 unsigned long arg) 123 { 124 uint64_t range[2], start, len; 125 struct bio *prev = NULL, *bio; 126 sector_t sector, nr_sects; 127 struct blk_plug plug; 128 int err; 129 130 if (copy_from_user(range, (void __user *)arg, sizeof(range))) 131 return -EFAULT; 132 start = range[0]; 133 len = range[1]; 134 135 if (!bdev_max_discard_sectors(bdev)) 136 return -EOPNOTSUPP; 137 138 if (!(mode & BLK_OPEN_WRITE)) 139 return -EBADF; 140 if (bdev_read_only(bdev)) 141 return -EPERM; 142 err = blk_validate_byte_range(bdev, start, len); 143 if (err) 144 return err; 145 146 inode_lock(bdev->bd_mapping->host); 147 filemap_invalidate_lock(bdev->bd_mapping); 148 err = truncate_bdev_range(bdev, mode, start, start + len - 1); 149 if (err) 150 goto fail; 151 152 sector = start >> SECTOR_SHIFT; 153 nr_sects = len >> SECTOR_SHIFT; 154 155 blk_start_plug(&plug); 156 while (1) { 157 if (fatal_signal_pending(current)) { 158 if (prev) 159 bio_await_chain(prev); 160 err = -EINTR; 161 goto out_unplug; 162 } 163 bio = blk_alloc_discard_bio(bdev, §or, &nr_sects, 164 GFP_KERNEL); 165 if (!bio) 166 break; 167 prev = bio_chain_and_submit(prev, bio); 168 } 169 if (prev) { 170 err = submit_bio_wait(prev); 171 if (err == -EOPNOTSUPP) 172 err = 0; 173 bio_put(prev); 174 } 175 out_unplug: 176 blk_finish_plug(&plug); 177 fail: 178 filemap_invalidate_unlock(bdev->bd_mapping); 179 inode_unlock(bdev->bd_mapping->host); 180 return err; 181 } 182 183 static int blk_ioctl_secure_erase(struct block_device *bdev, blk_mode_t mode, 184 void __user *argp) 185 { 186 uint64_t start, len, end; 187 uint64_t range[2]; 188 int err; 189 190 if (!(mode & BLK_OPEN_WRITE)) 191 return -EBADF; 192 if (!bdev_max_secure_erase_sectors(bdev)) 193 return -EOPNOTSUPP; 194 if (copy_from_user(range, argp, sizeof(range))) 195 return -EFAULT; 196 197 start = range[0]; 198 len = range[1]; 199 if ((start & 511) || (len & 511)) 200 return -EINVAL; 201 if (check_add_overflow(start, len, &end) || 202 end > bdev_nr_bytes(bdev)) 203 return -EINVAL; 204 205 inode_lock(bdev->bd_mapping->host); 206 filemap_invalidate_lock(bdev->bd_mapping); 207 err = truncate_bdev_range(bdev, mode, start, end - 1); 208 if (!err) 209 err = blkdev_issue_secure_erase(bdev, start >> 9, len >> 9, 210 GFP_KERNEL); 211 filemap_invalidate_unlock(bdev->bd_mapping); 212 inode_unlock(bdev->bd_mapping->host); 213 return err; 214 } 215 216 217 static int blk_ioctl_zeroout(struct block_device *bdev, blk_mode_t mode, 218 unsigned long arg) 219 { 220 uint64_t range[2]; 221 uint64_t start, end, len; 222 int err; 223 224 if (!(mode & BLK_OPEN_WRITE)) 225 return -EBADF; 226 227 if (copy_from_user(range, (void __user *)arg, sizeof(range))) 228 return -EFAULT; 229 230 start = range[0]; 231 len = range[1]; 232 end = start + len - 1; 233 234 if (start & 511) 235 return -EINVAL; 236 if (len & 511) 237 return -EINVAL; 238 if (end >= (uint64_t)bdev_nr_bytes(bdev)) 239 return -EINVAL; 240 if (end < start) 241 return -EINVAL; 242 243 /* Invalidate the page cache, including dirty pages */ 244 inode_lock(bdev->bd_mapping->host); 245 filemap_invalidate_lock(bdev->bd_mapping); 246 err = truncate_bdev_range(bdev, mode, start, end); 247 if (err) 248 goto fail; 249 250 err = blkdev_issue_zeroout(bdev, start >> 9, len >> 9, GFP_KERNEL, 251 BLKDEV_ZERO_NOUNMAP | BLKDEV_ZERO_KILLABLE); 252 253 fail: 254 filemap_invalidate_unlock(bdev->bd_mapping); 255 inode_unlock(bdev->bd_mapping->host); 256 return err; 257 } 258 259 static int put_ushort(unsigned short __user *argp, unsigned short val) 260 { 261 return put_user(val, argp); 262 } 263 264 static int put_int(int __user *argp, int val) 265 { 266 return put_user(val, argp); 267 } 268 269 static int put_uint(unsigned int __user *argp, unsigned int val) 270 { 271 return put_user(val, argp); 272 } 273 274 static int put_long(long __user *argp, long val) 275 { 276 return put_user(val, argp); 277 } 278 279 static int put_ulong(unsigned long __user *argp, unsigned long val) 280 { 281 return put_user(val, argp); 282 } 283 284 static int put_u64(u64 __user *argp, u64 val) 285 { 286 return put_user(val, argp); 287 } 288 289 #ifdef CONFIG_COMPAT 290 static int compat_put_long(compat_long_t __user *argp, long val) 291 { 292 return put_user(val, argp); 293 } 294 295 static int compat_put_ulong(compat_ulong_t __user *argp, compat_ulong_t val) 296 { 297 return put_user(val, argp); 298 } 299 #endif 300 301 #ifdef CONFIG_COMPAT 302 /* 303 * This is the equivalent of compat_ptr_ioctl(), to be used by block 304 * drivers that implement only commands that are completely compatible 305 * between 32-bit and 64-bit user space 306 */ 307 int blkdev_compat_ptr_ioctl(struct block_device *bdev, blk_mode_t mode, 308 unsigned cmd, unsigned long arg) 309 { 310 struct gendisk *disk = bdev->bd_disk; 311 312 if (disk->fops->ioctl) 313 return disk->fops->ioctl(bdev, mode, cmd, 314 (unsigned long)compat_ptr(arg)); 315 316 return -ENOIOCTLCMD; 317 } 318 EXPORT_SYMBOL(blkdev_compat_ptr_ioctl); 319 #endif 320 321 static bool blkdev_pr_allowed(struct block_device *bdev, blk_mode_t mode) 322 { 323 /* no sense to make reservations for partitions */ 324 if (bdev_is_partition(bdev)) 325 return false; 326 327 if (capable(CAP_SYS_ADMIN)) 328 return true; 329 /* 330 * Only allow unprivileged reservations if the file descriptor is open 331 * for writing. 332 */ 333 return mode & BLK_OPEN_WRITE; 334 } 335 336 static int blkdev_pr_register(struct block_device *bdev, blk_mode_t mode, 337 struct pr_registration __user *arg) 338 { 339 const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops; 340 struct pr_registration reg; 341 342 if (!blkdev_pr_allowed(bdev, mode)) 343 return -EPERM; 344 if (!ops || !ops->pr_register) 345 return -EOPNOTSUPP; 346 if (copy_from_user(®, arg, sizeof(reg))) 347 return -EFAULT; 348 349 if (reg.flags & ~PR_FL_IGNORE_KEY) 350 return -EOPNOTSUPP; 351 return ops->pr_register(bdev, reg.old_key, reg.new_key, reg.flags); 352 } 353 354 static int blkdev_pr_reserve(struct block_device *bdev, blk_mode_t mode, 355 struct pr_reservation __user *arg) 356 { 357 const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops; 358 struct pr_reservation rsv; 359 360 if (!blkdev_pr_allowed(bdev, mode)) 361 return -EPERM; 362 if (!ops || !ops->pr_reserve) 363 return -EOPNOTSUPP; 364 if (copy_from_user(&rsv, arg, sizeof(rsv))) 365 return -EFAULT; 366 367 if (rsv.flags & ~PR_FL_IGNORE_KEY) 368 return -EOPNOTSUPP; 369 return ops->pr_reserve(bdev, rsv.key, rsv.type, rsv.flags); 370 } 371 372 static int blkdev_pr_release(struct block_device *bdev, blk_mode_t mode, 373 struct pr_reservation __user *arg) 374 { 375 const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops; 376 struct pr_reservation rsv; 377 378 if (!blkdev_pr_allowed(bdev, mode)) 379 return -EPERM; 380 if (!ops || !ops->pr_release) 381 return -EOPNOTSUPP; 382 if (copy_from_user(&rsv, arg, sizeof(rsv))) 383 return -EFAULT; 384 385 if (rsv.flags) 386 return -EOPNOTSUPP; 387 return ops->pr_release(bdev, rsv.key, rsv.type); 388 } 389 390 static int blkdev_pr_preempt(struct block_device *bdev, blk_mode_t mode, 391 struct pr_preempt __user *arg, bool abort) 392 { 393 const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops; 394 struct pr_preempt p; 395 396 if (!blkdev_pr_allowed(bdev, mode)) 397 return -EPERM; 398 if (!ops || !ops->pr_preempt) 399 return -EOPNOTSUPP; 400 if (copy_from_user(&p, arg, sizeof(p))) 401 return -EFAULT; 402 403 if (p.flags) 404 return -EOPNOTSUPP; 405 return ops->pr_preempt(bdev, p.old_key, p.new_key, p.type, abort); 406 } 407 408 static int blkdev_pr_clear(struct block_device *bdev, blk_mode_t mode, 409 struct pr_clear __user *arg) 410 { 411 const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops; 412 struct pr_clear c; 413 414 if (!blkdev_pr_allowed(bdev, mode)) 415 return -EPERM; 416 if (!ops || !ops->pr_clear) 417 return -EOPNOTSUPP; 418 if (copy_from_user(&c, arg, sizeof(c))) 419 return -EFAULT; 420 421 if (c.flags) 422 return -EOPNOTSUPP; 423 return ops->pr_clear(bdev, c.key); 424 } 425 426 static int blkdev_flushbuf(struct block_device *bdev, unsigned cmd, 427 unsigned long arg) 428 { 429 if (!capable(CAP_SYS_ADMIN)) 430 return -EACCES; 431 432 mutex_lock(&bdev->bd_holder_lock); 433 if (bdev->bd_holder_ops && bdev->bd_holder_ops->sync) 434 bdev->bd_holder_ops->sync(bdev); 435 else { 436 mutex_unlock(&bdev->bd_holder_lock); 437 sync_blockdev(bdev); 438 } 439 440 invalidate_bdev(bdev); 441 return 0; 442 } 443 444 static int blkdev_roset(struct block_device *bdev, unsigned cmd, 445 unsigned long arg) 446 { 447 int ret, n; 448 449 if (!capable(CAP_SYS_ADMIN)) 450 return -EACCES; 451 452 if (get_user(n, (int __user *)arg)) 453 return -EFAULT; 454 if (bdev->bd_disk->fops->set_read_only) { 455 ret = bdev->bd_disk->fops->set_read_only(bdev, n); 456 if (ret) 457 return ret; 458 } 459 if (n) 460 bdev_set_flag(bdev, BD_READ_ONLY); 461 else 462 bdev_clear_flag(bdev, BD_READ_ONLY); 463 return 0; 464 } 465 466 static int blkdev_getgeo(struct block_device *bdev, 467 struct hd_geometry __user *argp) 468 { 469 struct gendisk *disk = bdev->bd_disk; 470 struct hd_geometry geo; 471 int ret; 472 473 if (!argp) 474 return -EINVAL; 475 if (!disk->fops->getgeo) 476 return -ENOTTY; 477 478 /* 479 * We need to set the startsect first, the driver may 480 * want to override it. 481 */ 482 memset(&geo, 0, sizeof(geo)); 483 geo.start = get_start_sect(bdev); 484 ret = disk->fops->getgeo(disk, &geo); 485 if (ret) 486 return ret; 487 if (copy_to_user(argp, &geo, sizeof(geo))) 488 return -EFAULT; 489 return 0; 490 } 491 492 #ifdef CONFIG_COMPAT 493 struct compat_hd_geometry { 494 unsigned char heads; 495 unsigned char sectors; 496 unsigned short cylinders; 497 u32 start; 498 }; 499 500 static int compat_hdio_getgeo(struct block_device *bdev, 501 struct compat_hd_geometry __user *ugeo) 502 { 503 struct gendisk *disk = bdev->bd_disk; 504 struct hd_geometry geo; 505 int ret; 506 507 if (!ugeo) 508 return -EINVAL; 509 if (!disk->fops->getgeo) 510 return -ENOTTY; 511 512 memset(&geo, 0, sizeof(geo)); 513 /* 514 * We need to set the startsect first, the driver may 515 * want to override it. 516 */ 517 geo.start = get_start_sect(bdev); 518 ret = disk->fops->getgeo(disk, &geo); 519 if (ret) 520 return ret; 521 522 ret = copy_to_user(ugeo, &geo, 4); 523 ret |= put_user(geo.start, &ugeo->start); 524 if (ret) 525 ret = -EFAULT; 526 527 return ret; 528 } 529 #endif 530 531 /* set the logical block size */ 532 static int blkdev_bszset(struct file *file, blk_mode_t mode, 533 int __user *argp) 534 { 535 // this one might be file_inode(file)->i_rdev - a rare valid 536 // use of file_inode() for those. 537 dev_t dev = I_BDEV(file->f_mapping->host)->bd_dev; 538 struct file *excl_file; 539 int ret, n; 540 541 if (!capable(CAP_SYS_ADMIN)) 542 return -EACCES; 543 if (!argp) 544 return -EINVAL; 545 if (get_user(n, argp)) 546 return -EFAULT; 547 548 if (mode & BLK_OPEN_EXCL) 549 return set_blocksize(file, n); 550 551 excl_file = bdev_file_open_by_dev(dev, mode, &dev, NULL); 552 if (IS_ERR(excl_file)) 553 return -EBUSY; 554 ret = set_blocksize(excl_file, n); 555 fput(excl_file); 556 return ret; 557 } 558 559 /* 560 * Common commands that are handled the same way on native and compat 561 * user space. Note the separate arg/argp parameters that are needed 562 * to deal with the compat_ptr() conversion. 563 */ 564 static int blkdev_common_ioctl(struct block_device *bdev, blk_mode_t mode, 565 unsigned int cmd, unsigned long arg, 566 void __user *argp) 567 { 568 unsigned int max_sectors; 569 570 switch (cmd) { 571 case BLKFLSBUF: 572 return blkdev_flushbuf(bdev, cmd, arg); 573 case BLKROSET: 574 return blkdev_roset(bdev, cmd, arg); 575 case BLKDISCARD: 576 return blk_ioctl_discard(bdev, mode, arg); 577 case BLKSECDISCARD: 578 return blk_ioctl_secure_erase(bdev, mode, argp); 579 case BLKZEROOUT: 580 return blk_ioctl_zeroout(bdev, mode, arg); 581 case BLKGETDISKSEQ: 582 return put_u64(argp, bdev->bd_disk->diskseq); 583 case BLKREPORTZONE: 584 case BLKREPORTZONEV2: 585 return blkdev_report_zones_ioctl(bdev, cmd, arg); 586 case BLKRESETZONE: 587 case BLKOPENZONE: 588 case BLKCLOSEZONE: 589 case BLKFINISHZONE: 590 return blkdev_zone_mgmt_ioctl(bdev, mode, cmd, arg); 591 case BLKGETZONESZ: 592 return put_uint(argp, bdev_zone_sectors(bdev)); 593 case BLKGETNRZONES: 594 return put_uint(argp, bdev_nr_zones(bdev)); 595 case BLKROGET: 596 return put_int(argp, bdev_read_only(bdev) != 0); 597 case BLKSSZGET: /* get block device logical block size */ 598 return put_int(argp, bdev_logical_block_size(bdev)); 599 case BLKPBSZGET: /* get block device physical block size */ 600 return put_uint(argp, bdev_physical_block_size(bdev)); 601 case BLKIOMIN: 602 return put_uint(argp, bdev_io_min(bdev)); 603 case BLKIOOPT: 604 return put_uint(argp, bdev_io_opt(bdev)); 605 case BLKALIGNOFF: 606 return put_int(argp, bdev_alignment_offset(bdev)); 607 case BLKDISCARDZEROES: 608 return put_uint(argp, 0); 609 case BLKSECTGET: 610 max_sectors = min_t(unsigned int, USHRT_MAX, 611 queue_max_sectors(bdev_get_queue(bdev))); 612 return put_ushort(argp, max_sectors); 613 case BLKROTATIONAL: 614 return put_ushort(argp, !bdev_nonrot(bdev)); 615 case BLKRASET: 616 case BLKFRASET: 617 if(!capable(CAP_SYS_ADMIN)) 618 return -EACCES; 619 bdev->bd_disk->bdi->ra_pages = (arg * 512) / PAGE_SIZE; 620 return 0; 621 case BLKRRPART: 622 if (!capable(CAP_SYS_ADMIN)) 623 return -EACCES; 624 if (bdev_is_partition(bdev)) 625 return -EINVAL; 626 return disk_scan_partitions(bdev->bd_disk, 627 mode | BLK_OPEN_STRICT_SCAN); 628 case BLKTRACESTART: 629 case BLKTRACESTOP: 630 case BLKTRACETEARDOWN: 631 return blk_trace_ioctl(bdev, cmd, argp); 632 case BLKCRYPTOIMPORTKEY: 633 case BLKCRYPTOGENERATEKEY: 634 case BLKCRYPTOPREPAREKEY: 635 return blk_crypto_ioctl(bdev, cmd, argp); 636 case IOC_PR_REGISTER: 637 return blkdev_pr_register(bdev, mode, argp); 638 case IOC_PR_RESERVE: 639 return blkdev_pr_reserve(bdev, mode, argp); 640 case IOC_PR_RELEASE: 641 return blkdev_pr_release(bdev, mode, argp); 642 case IOC_PR_PREEMPT: 643 return blkdev_pr_preempt(bdev, mode, argp, false); 644 case IOC_PR_PREEMPT_ABORT: 645 return blkdev_pr_preempt(bdev, mode, argp, true); 646 case IOC_PR_CLEAR: 647 return blkdev_pr_clear(bdev, mode, argp); 648 default: 649 return blk_get_meta_cap(bdev, cmd, argp); 650 } 651 } 652 653 /* 654 * Always keep this in sync with compat_blkdev_ioctl() 655 * to handle all incompatible commands in both functions. 656 * 657 * New commands must be compatible and go into blkdev_common_ioctl 658 */ 659 long blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg) 660 { 661 struct block_device *bdev = I_BDEV(file->f_mapping->host); 662 void __user *argp = (void __user *)arg; 663 blk_mode_t mode = file_to_blk_mode(file); 664 int ret; 665 666 switch (cmd) { 667 /* These need separate implementations for the data structure */ 668 case HDIO_GETGEO: 669 return blkdev_getgeo(bdev, argp); 670 case BLKPG: 671 return blkpg_ioctl(bdev, argp); 672 673 /* Compat mode returns 32-bit data instead of 'long' */ 674 case BLKRAGET: 675 case BLKFRAGET: 676 if (!argp) 677 return -EINVAL; 678 return put_long(argp, 679 (bdev->bd_disk->bdi->ra_pages * PAGE_SIZE) / 512); 680 case BLKGETSIZE: 681 if (bdev_nr_sectors(bdev) > ~0UL) 682 return -EFBIG; 683 return put_ulong(argp, bdev_nr_sectors(bdev)); 684 685 /* The data is compatible, but the command number is different */ 686 case BLKBSZGET: /* get block device soft block size (cf. BLKSSZGET) */ 687 return put_int(argp, block_size(bdev)); 688 case BLKBSZSET: 689 return blkdev_bszset(file, mode, argp); 690 case BLKGETSIZE64: 691 return put_u64(argp, bdev_nr_bytes(bdev)); 692 693 /* Incompatible alignment on i386 */ 694 case BLKTRACESETUP: 695 case BLKTRACESETUP2: 696 return blk_trace_ioctl(bdev, cmd, argp); 697 default: 698 break; 699 } 700 701 ret = blkdev_common_ioctl(bdev, mode, cmd, arg, argp); 702 if (ret != -ENOIOCTLCMD) 703 return ret; 704 705 if (!bdev->bd_disk->fops->ioctl) 706 return -ENOTTY; 707 return bdev->bd_disk->fops->ioctl(bdev, mode, cmd, arg); 708 } 709 710 #ifdef CONFIG_COMPAT 711 712 #define BLKBSZGET_32 _IOR(0x12, 112, int) 713 #define BLKBSZSET_32 _IOW(0x12, 113, int) 714 #define BLKGETSIZE64_32 _IOR(0x12, 114, int) 715 716 /* Most of the generic ioctls are handled in the normal fallback path. 717 This assumes the blkdev's low level compat_ioctl always returns 718 ENOIOCTLCMD for unknown ioctls. */ 719 long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg) 720 { 721 int ret; 722 void __user *argp = compat_ptr(arg); 723 struct block_device *bdev = I_BDEV(file->f_mapping->host); 724 struct gendisk *disk = bdev->bd_disk; 725 blk_mode_t mode = file_to_blk_mode(file); 726 727 switch (cmd) { 728 /* These need separate implementations for the data structure */ 729 case HDIO_GETGEO: 730 return compat_hdio_getgeo(bdev, argp); 731 case BLKPG: 732 return compat_blkpg_ioctl(bdev, argp); 733 734 /* Compat mode returns 32-bit data instead of 'long' */ 735 case BLKRAGET: 736 case BLKFRAGET: 737 if (!argp) 738 return -EINVAL; 739 return compat_put_long(argp, 740 (bdev->bd_disk->bdi->ra_pages * PAGE_SIZE) / 512); 741 case BLKGETSIZE: 742 if (bdev_nr_sectors(bdev) > ~(compat_ulong_t)0) 743 return -EFBIG; 744 return compat_put_ulong(argp, bdev_nr_sectors(bdev)); 745 746 /* The data is compatible, but the command number is different */ 747 case BLKBSZGET_32: /* get the logical block size (cf. BLKSSZGET) */ 748 return put_int(argp, bdev_logical_block_size(bdev)); 749 case BLKBSZSET_32: 750 return blkdev_bszset(file, mode, argp); 751 case BLKGETSIZE64_32: 752 return put_u64(argp, bdev_nr_bytes(bdev)); 753 754 /* Incompatible alignment on i386 */ 755 case BLKTRACESETUP32: 756 return blk_trace_ioctl(bdev, cmd, argp); 757 default: 758 break; 759 } 760 761 ret = blkdev_common_ioctl(bdev, mode, cmd, arg, argp); 762 if (ret == -ENOIOCTLCMD && disk->fops->compat_ioctl) 763 ret = disk->fops->compat_ioctl(bdev, mode, cmd, arg); 764 765 return ret; 766 } 767 #endif 768 769 struct blk_iou_cmd { 770 int res; 771 bool nowait; 772 }; 773 774 static void blk_cmd_complete(struct io_tw_req tw_req, io_tw_token_t tw) 775 { 776 struct io_uring_cmd *cmd = io_uring_cmd_from_tw(tw_req); 777 struct blk_iou_cmd *bic = io_uring_cmd_to_pdu(cmd, struct blk_iou_cmd); 778 779 if (bic->res == -EAGAIN && bic->nowait) 780 io_uring_cmd_issue_blocking(cmd); 781 else 782 io_uring_cmd_done(cmd, bic->res, 783 IO_URING_CMD_TASK_WORK_ISSUE_FLAGS); 784 } 785 786 static void bio_cmd_bio_end_io(struct bio *bio) 787 { 788 struct io_uring_cmd *cmd = bio->bi_private; 789 struct blk_iou_cmd *bic = io_uring_cmd_to_pdu(cmd, struct blk_iou_cmd); 790 791 if (unlikely(bio->bi_status) && !bic->res) 792 bic->res = blk_status_to_errno(bio->bi_status); 793 794 io_uring_cmd_do_in_task_lazy(cmd, blk_cmd_complete); 795 bio_put(bio); 796 } 797 798 static int blkdev_cmd_discard(struct io_uring_cmd *cmd, 799 struct block_device *bdev, 800 uint64_t start, uint64_t len, bool nowait) 801 { 802 struct blk_iou_cmd *bic = io_uring_cmd_to_pdu(cmd, struct blk_iou_cmd); 803 gfp_t gfp = nowait ? GFP_NOWAIT : GFP_KERNEL; 804 sector_t sector = start >> SECTOR_SHIFT; 805 sector_t nr_sects = len >> SECTOR_SHIFT; 806 struct bio *prev = NULL, *bio; 807 int err; 808 809 if (!bdev_max_discard_sectors(bdev)) 810 return -EOPNOTSUPP; 811 if (!(file_to_blk_mode(cmd->file) & BLK_OPEN_WRITE)) 812 return -EBADF; 813 if (bdev_read_only(bdev)) 814 return -EPERM; 815 err = blk_validate_byte_range(bdev, start, len); 816 if (err) 817 return err; 818 819 err = filemap_invalidate_pages(bdev->bd_mapping, start, 820 start + len - 1, nowait); 821 if (err) 822 return err; 823 824 while (true) { 825 bio = blk_alloc_discard_bio(bdev, §or, &nr_sects, gfp); 826 if (!bio) 827 break; 828 if (nowait) { 829 /* 830 * Don't allow multi-bio non-blocking submissions as 831 * subsequent bios may fail but we won't get a direct 832 * indication of that. Normally, the caller should 833 * retry from a blocking context. 834 */ 835 if (unlikely(nr_sects)) { 836 bio_put(bio); 837 return -EAGAIN; 838 } 839 bio->bi_opf |= REQ_NOWAIT; 840 } 841 842 prev = bio_chain_and_submit(prev, bio); 843 } 844 if (unlikely(!prev)) 845 return -EAGAIN; 846 if (unlikely(nr_sects)) 847 bic->res = -EAGAIN; 848 849 prev->bi_private = cmd; 850 prev->bi_end_io = bio_cmd_bio_end_io; 851 submit_bio(prev); 852 return -EIOCBQUEUED; 853 } 854 855 int blkdev_uring_cmd(struct io_uring_cmd *cmd, unsigned int issue_flags) 856 { 857 struct block_device *bdev = I_BDEV(cmd->file->f_mapping->host); 858 struct blk_iou_cmd *bic = io_uring_cmd_to_pdu(cmd, struct blk_iou_cmd); 859 const struct io_uring_sqe *sqe = cmd->sqe; 860 u32 cmd_op = cmd->cmd_op; 861 uint64_t start, len; 862 863 if (unlikely(sqe->ioprio || sqe->__pad1 || sqe->len || 864 sqe->rw_flags || sqe->file_index)) 865 return -EINVAL; 866 867 bic->res = 0; 868 bic->nowait = issue_flags & IO_URING_F_NONBLOCK; 869 870 start = READ_ONCE(sqe->addr); 871 len = READ_ONCE(sqe->addr3); 872 873 switch (cmd_op) { 874 case BLOCK_URING_CMD_DISCARD: 875 return blkdev_cmd_discard(cmd, bdev, start, len, bic->nowait); 876 } 877 return -EINVAL; 878 } 879