]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - block/ioctl.c
1 #include <linux/capability.h>
2 #include <linux/blkdev.h>
3 #include <linux/export.h>
5 #include <linux/blkpg.h>
6 #include <linux/hdreg.h>
7 #include <linux/backing-dev.h>
9 #include <linux/blktrace_api.h>
10 #include <asm/uaccess.h>
12 static int blkpg_ioctl(struct block_device
*bdev
, struct blkpg_ioctl_arg __user
*arg
)
14 struct block_device
*bdevp
;
16 struct hd_struct
*part
, *lpart
;
17 struct blkpg_ioctl_arg a
;
18 struct blkpg_partition p
;
19 struct disk_part_iter piter
;
20 long long start
, length
;
23 if (!capable(CAP_SYS_ADMIN
))
25 if (copy_from_user(&a
, arg
, sizeof(struct blkpg_ioctl_arg
)))
27 if (copy_from_user(&p
, a
.data
, sizeof(struct blkpg_partition
)))
30 if (bdev
!= bdev
->bd_contains
)
36 case BLKPG_ADD_PARTITION
:
38 length
= p
.length
>> 9;
39 /* check for fit in a hd_struct */
40 if (sizeof(sector_t
) == sizeof(long) &&
41 sizeof(long long) > sizeof(long)) {
42 long pstart
= start
, plength
= length
;
43 if (pstart
!= start
|| plength
!= length
44 || pstart
< 0 || plength
< 0 || partno
> 65535)
48 mutex_lock(&bdev
->bd_mutex
);
51 disk_part_iter_init(&piter
, disk
,
52 DISK_PITER_INCL_EMPTY
);
53 while ((part
= disk_part_iter_next(&piter
))) {
54 if (!(start
+ length
<= part
->start_sect
||
55 start
>= part
->start_sect
+ part
->nr_sects
)) {
56 disk_part_iter_exit(&piter
);
57 mutex_unlock(&bdev
->bd_mutex
);
61 disk_part_iter_exit(&piter
);
64 part
= add_partition(disk
, partno
, start
, length
,
65 ADDPART_FLAG_NONE
, NULL
);
66 mutex_unlock(&bdev
->bd_mutex
);
67 return PTR_ERR_OR_ZERO(part
);
68 case BLKPG_DEL_PARTITION
:
69 part
= disk_get_part(disk
, partno
);
73 bdevp
= bdget(part_devt(part
));
78 mutex_lock(&bdevp
->bd_mutex
);
79 if (bdevp
->bd_openers
) {
80 mutex_unlock(&bdevp
->bd_mutex
);
86 invalidate_bdev(bdevp
);
88 mutex_lock_nested(&bdev
->bd_mutex
, 1);
89 delete_partition(disk
, partno
);
90 mutex_unlock(&bdev
->bd_mutex
);
91 mutex_unlock(&bdevp
->bd_mutex
);
95 case BLKPG_RESIZE_PARTITION
:
97 /* new length of partition in bytes */
98 length
= p
.length
>> 9;
99 /* check for fit in a hd_struct */
100 if (sizeof(sector_t
) == sizeof(long) &&
101 sizeof(long long) > sizeof(long)) {
102 long pstart
= start
, plength
= length
;
103 if (pstart
!= start
|| plength
!= length
104 || pstart
< 0 || plength
< 0)
107 part
= disk_get_part(disk
, partno
);
110 bdevp
= bdget(part_devt(part
));
115 mutex_lock(&bdevp
->bd_mutex
);
116 mutex_lock_nested(&bdev
->bd_mutex
, 1);
117 if (start
!= part
->start_sect
) {
118 mutex_unlock(&bdevp
->bd_mutex
);
119 mutex_unlock(&bdev
->bd_mutex
);
125 disk_part_iter_init(&piter
, disk
,
126 DISK_PITER_INCL_EMPTY
);
127 while ((lpart
= disk_part_iter_next(&piter
))) {
128 if (lpart
->partno
!= partno
&&
129 !(start
+ length
<= lpart
->start_sect
||
130 start
>= lpart
->start_sect
+ lpart
->nr_sects
)
132 disk_part_iter_exit(&piter
);
133 mutex_unlock(&bdevp
->bd_mutex
);
134 mutex_unlock(&bdev
->bd_mutex
);
140 disk_part_iter_exit(&piter
);
141 part_nr_sects_write(part
, (sector_t
)length
);
142 i_size_write(bdevp
->bd_inode
, p
.length
);
143 mutex_unlock(&bdevp
->bd_mutex
);
144 mutex_unlock(&bdev
->bd_mutex
);
153 static int blkdev_reread_part(struct block_device
*bdev
)
155 struct gendisk
*disk
= bdev
->bd_disk
;
158 if (!disk_part_scan_enabled(disk
) || bdev
!= bdev
->bd_contains
)
160 if (!capable(CAP_SYS_ADMIN
))
162 if (!mutex_trylock(&bdev
->bd_mutex
))
164 res
= rescan_partitions(disk
, bdev
);
165 mutex_unlock(&bdev
->bd_mutex
);
169 static int blk_ioctl_discard(struct block_device
*bdev
, uint64_t start
,
170 uint64_t len
, int secure
)
172 unsigned long flags
= 0;
181 if (start
+ len
> (i_size_read(bdev
->bd_inode
) >> 9))
184 flags
|= BLKDEV_DISCARD_SECURE
;
185 return blkdev_issue_discard(bdev
, start
, len
, GFP_KERNEL
, flags
);
188 static int blk_ioctl_zeroout(struct block_device
*bdev
, uint64_t start
,
198 if (start
+ len
> (i_size_read(bdev
->bd_inode
) >> 9))
201 return blkdev_issue_zeroout(bdev
, start
, len
, GFP_KERNEL
);
204 static int put_ushort(unsigned long arg
, unsigned short val
)
206 return put_user(val
, (unsigned short __user
*)arg
);
209 static int put_int(unsigned long arg
, int val
)
211 return put_user(val
, (int __user
*)arg
);
214 static int put_uint(unsigned long arg
, unsigned int val
)
216 return put_user(val
, (unsigned int __user
*)arg
);
219 static int put_long(unsigned long arg
, long val
)
221 return put_user(val
, (long __user
*)arg
);
224 static int put_ulong(unsigned long arg
, unsigned long val
)
226 return put_user(val
, (unsigned long __user
*)arg
);
229 static int put_u64(unsigned long arg
, u64 val
)
231 return put_user(val
, (u64 __user
*)arg
);
234 int __blkdev_driver_ioctl(struct block_device
*bdev
, fmode_t mode
,
235 unsigned cmd
, unsigned long arg
)
237 struct gendisk
*disk
= bdev
->bd_disk
;
239 if (disk
->fops
->ioctl
)
240 return disk
->fops
->ioctl(bdev
, mode
, cmd
, arg
);
245 * For the record: _GPL here is only because somebody decided to slap it
246 * on the previous export. Sheer idiocy, since it wasn't copyrightable
247 * at all and could be open-coded without any exports by anybody who cares.
249 EXPORT_SYMBOL_GPL(__blkdev_driver_ioctl
);
252 * Is it an unrecognized ioctl? The correct returns are either
253 * ENOTTY (final) or ENOIOCTLCMD ("I don't know this one, try a
254 * fallback"). ENOIOCTLCMD gets turned into ENOTTY by the ioctl
255 * code before returning.
257 * Confused drivers sometimes return EINVAL, which is wrong. It
258 * means "I understood the ioctl command, but the parameters to
261 * We should aim to just fix the broken drivers, the EINVAL case
264 static inline int is_unrecognized_ioctl(int ret
)
266 return ret
== -EINVAL
||
272 * always keep this in sync with compat_blkdev_ioctl()
274 int blkdev_ioctl(struct block_device
*bdev
, fmode_t mode
, unsigned cmd
,
277 struct gendisk
*disk
= bdev
->bd_disk
;
278 struct backing_dev_info
*bdi
;
284 if (!capable(CAP_SYS_ADMIN
))
287 ret
= __blkdev_driver_ioctl(bdev
, mode
, cmd
, arg
);
288 if (!is_unrecognized_ioctl(ret
))
292 invalidate_bdev(bdev
);
296 ret
= __blkdev_driver_ioctl(bdev
, mode
, cmd
, arg
);
297 if (!is_unrecognized_ioctl(ret
))
299 if (!capable(CAP_SYS_ADMIN
))
301 if (get_user(n
, (int __user
*)(arg
)))
303 set_device_ro(bdev
, n
);
307 case BLKSECDISCARD
: {
310 if (!(mode
& FMODE_WRITE
))
313 if (copy_from_user(range
, (void __user
*)arg
, sizeof(range
)))
316 return blk_ioctl_discard(bdev
, range
[0], range
[1],
317 cmd
== BLKSECDISCARD
);
322 if (!(mode
& FMODE_WRITE
))
325 if (copy_from_user(range
, (void __user
*)arg
, sizeof(range
)))
328 return blk_ioctl_zeroout(bdev
, range
[0], range
[1]);
332 struct hd_geometry geo
;
336 if (!disk
->fops
->getgeo
)
340 * We need to set the startsect first, the driver may
341 * want to override it.
343 memset(&geo
, 0, sizeof(geo
));
344 geo
.start
= get_start_sect(bdev
);
345 ret
= disk
->fops
->getgeo(bdev
, &geo
);
348 if (copy_to_user((struct hd_geometry __user
*)arg
, &geo
,
357 bdi
= blk_get_backing_dev_info(bdev
);
360 return put_long(arg
, (bdi
->ra_pages
* PAGE_CACHE_SIZE
) / 512);
362 return put_int(arg
, bdev_read_only(bdev
) != 0);
363 case BLKBSZGET
: /* get block device soft block size (cf. BLKSSZGET) */
364 return put_int(arg
, block_size(bdev
));
365 case BLKSSZGET
: /* get block device logical block size */
366 return put_int(arg
, bdev_logical_block_size(bdev
));
367 case BLKPBSZGET
: /* get block device physical block size */
368 return put_uint(arg
, bdev_physical_block_size(bdev
));
370 return put_uint(arg
, bdev_io_min(bdev
));
372 return put_uint(arg
, bdev_io_opt(bdev
));
374 return put_int(arg
, bdev_alignment_offset(bdev
));
375 case BLKDISCARDZEROES
:
376 return put_uint(arg
, bdev_discard_zeroes_data(bdev
));
378 return put_ushort(arg
, queue_max_sectors(bdev_get_queue(bdev
)));
380 return put_ushort(arg
, !blk_queue_nonrot(bdev_get_queue(bdev
)));
383 if(!capable(CAP_SYS_ADMIN
))
385 bdi
= blk_get_backing_dev_info(bdev
);
388 bdi
->ra_pages
= (arg
* 512) / PAGE_CACHE_SIZE
;
391 /* set the logical block size */
392 if (!capable(CAP_SYS_ADMIN
))
396 if (get_user(n
, (int __user
*) arg
))
398 if (!(mode
& FMODE_EXCL
)) {
400 if (blkdev_get(bdev
, mode
| FMODE_EXCL
, &bdev
) < 0)
403 ret
= set_blocksize(bdev
, n
);
404 if (!(mode
& FMODE_EXCL
))
405 blkdev_put(bdev
, mode
| FMODE_EXCL
);
408 ret
= blkpg_ioctl(bdev
, (struct blkpg_ioctl_arg __user
*) arg
);
411 ret
= blkdev_reread_part(bdev
);
414 size
= i_size_read(bdev
->bd_inode
);
415 if ((size
>> 9) > ~0UL)
417 return put_ulong(arg
, size
>> 9);
419 return put_u64(arg
, i_size_read(bdev
->bd_inode
));
423 case BLKTRACETEARDOWN
:
424 ret
= blk_trace_ioctl(bdev
, cmd
, (char __user
*) arg
);
427 ret
= __blkdev_driver_ioctl(bdev
, mode
, cmd
, arg
);
431 EXPORT_SYMBOL_GPL(blkdev_ioctl
);