projects/linux·blob master · refs

1008 lines · 24.9 KiB

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
22static 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
68static 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
81struct 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
88static 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 */
106static 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
122static 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, &sector, &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);
171fail:
172 filemap_invalidate_unlock(bdev->bd_mapping);
173 inode_unlock(bdev->bd_mapping->host);
174 return err;
175}
176
177static 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
211static 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
247fail:
248 filemap_invalidate_unlock(bdev->bd_mapping);
249 inode_unlock(bdev->bd_mapping->host);
250 return err;
251}
252
253static int put_ushort(unsigned short __user *argp, unsigned short val)
254{
255 return put_user(val, argp);
256}
257
258static int put_int(int __user *argp, int val)
259{
260 return put_user(val, argp);
261}
262
263static int put_uint(unsigned int __user *argp, unsigned int val)
264{
265 return put_user(val, argp);
266}
267
268static int put_long(long __user *argp, long val)
269{
270 return put_user(val, argp);
271}
272
273static int put_ulong(unsigned long __user *argp, unsigned long val)
274{
275 return put_user(val, argp);
276}
277
278static int put_u64(u64 __user *argp, u64 val)
279{
280 return put_user(val, argp);
281}
282
283#ifdef CONFIG_COMPAT
284static int compat_put_long(compat_long_t __user *argp, long val)
285{
286 return put_user(val, argp);
287}
288
289static 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 */
301int 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}
312EXPORT_SYMBOL(blkdev_compat_ptr_ioctl);
313#endif
314
315enum pr_direction {
316 PR_IN, /* read from device */
317 PR_OUT, /* write to device */
318};
319
320static 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
342static 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(&reg, 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
360static 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
378static 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
396static 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
414static 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
432static 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;
482out:
483 kvfree(keys_info);
484 return ret;
485}
486
487static 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
513static 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
531static 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
553static 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
580struct compat_hd_geometry {
581 unsigned char heads;
582 unsigned char sectors;
583 unsigned short cylinders;
584 u32 start;
585};
586
587static 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 */
619static 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 */
651static 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 */
750long 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. */
810long 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
860struct blk_iou_cmd {
861 u64 start;
862 u64 len;
863 int res;
864 bool nowait;
865};
866
867static 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
879static 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
891static 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, &sector, &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
947static 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
981int 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}