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