]>
git.proxmox.com Git - mirror_ubuntu-zesty-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
);
154 * This is an exported API for the block driver, and will not
155 * acquire bd_mutex. This API should be used in case that
156 * caller has held bd_mutex already.
158 int __blkdev_reread_part(struct block_device
*bdev
)
160 struct gendisk
*disk
= bdev
->bd_disk
;
162 if (!disk_part_scan_enabled(disk
) || bdev
!= bdev
->bd_contains
)
164 if (!capable(CAP_SYS_ADMIN
))
167 lockdep_assert_held(&bdev
->bd_mutex
);
169 return rescan_partitions(disk
, bdev
);
171 EXPORT_SYMBOL(__blkdev_reread_part
);
174 * This is an exported API for the block driver, and will
175 * try to acquire bd_mutex. If bd_mutex has been held already
176 * in current context, please call __blkdev_reread_part().
178 * Make sure the held locks in current context aren't required
179 * in open()/close() handler and I/O path for avoiding ABBA deadlock:
180 * - bd_mutex is held before calling block driver's open/close
182 * - reading partition table may submit I/O to the block device
184 int blkdev_reread_part(struct block_device
*bdev
)
188 mutex_lock(&bdev
->bd_mutex
);
189 res
= __blkdev_reread_part(bdev
);
190 mutex_unlock(&bdev
->bd_mutex
);
194 EXPORT_SYMBOL(blkdev_reread_part
);
196 static int blk_ioctl_discard(struct block_device
*bdev
, fmode_t mode
,
197 unsigned long arg
, unsigned long flags
)
202 if (!(mode
& FMODE_WRITE
))
205 if (copy_from_user(range
, (void __user
*)arg
, sizeof(range
)))
218 if (start
+ len
> (i_size_read(bdev
->bd_inode
) >> 9))
220 return blkdev_issue_discard(bdev
, start
, len
, GFP_KERNEL
, flags
);
223 static int blk_ioctl_zeroout(struct block_device
*bdev
, fmode_t mode
,
229 if (!(mode
& FMODE_WRITE
))
232 if (copy_from_user(range
, (void __user
*)arg
, sizeof(range
)))
245 if (start
+ len
> (i_size_read(bdev
->bd_inode
) >> 9))
248 return blkdev_issue_zeroout(bdev
, start
, len
, GFP_KERNEL
, false);
251 static int put_ushort(unsigned long arg
, unsigned short val
)
253 return put_user(val
, (unsigned short __user
*)arg
);
256 static int put_int(unsigned long arg
, int val
)
258 return put_user(val
, (int __user
*)arg
);
261 static int put_uint(unsigned long arg
, unsigned int val
)
263 return put_user(val
, (unsigned int __user
*)arg
);
266 static int put_long(unsigned long arg
, long val
)
268 return put_user(val
, (long __user
*)arg
);
271 static int put_ulong(unsigned long arg
, unsigned long val
)
273 return put_user(val
, (unsigned long __user
*)arg
);
276 static int put_u64(unsigned long arg
, u64 val
)
278 return put_user(val
, (u64 __user
*)arg
);
281 int __blkdev_driver_ioctl(struct block_device
*bdev
, fmode_t mode
,
282 unsigned cmd
, unsigned long arg
)
284 struct gendisk
*disk
= bdev
->bd_disk
;
286 if (disk
->fops
->ioctl
)
287 return disk
->fops
->ioctl(bdev
, mode
, cmd
, arg
);
292 * For the record: _GPL here is only because somebody decided to slap it
293 * on the previous export. Sheer idiocy, since it wasn't copyrightable
294 * at all and could be open-coded without any exports by anybody who cares.
296 EXPORT_SYMBOL_GPL(__blkdev_driver_ioctl
);
299 * Is it an unrecognized ioctl? The correct returns are either
300 * ENOTTY (final) or ENOIOCTLCMD ("I don't know this one, try a
301 * fallback"). ENOIOCTLCMD gets turned into ENOTTY by the ioctl
302 * code before returning.
304 * Confused drivers sometimes return EINVAL, which is wrong. It
305 * means "I understood the ioctl command, but the parameters to
308 * We should aim to just fix the broken drivers, the EINVAL case
311 static inline int is_unrecognized_ioctl(int ret
)
313 return ret
== -EINVAL
||
318 static int blkdev_flushbuf(struct block_device
*bdev
, fmode_t mode
,
319 unsigned cmd
, unsigned long arg
)
323 if (!capable(CAP_SYS_ADMIN
))
326 ret
= __blkdev_driver_ioctl(bdev
, mode
, cmd
, arg
);
327 if (!is_unrecognized_ioctl(ret
))
331 invalidate_bdev(bdev
);
335 static int blkdev_roset(struct block_device
*bdev
, fmode_t mode
,
336 unsigned cmd
, unsigned long arg
)
340 ret
= __blkdev_driver_ioctl(bdev
, mode
, cmd
, arg
);
341 if (!is_unrecognized_ioctl(ret
))
343 if (!capable(CAP_SYS_ADMIN
))
345 if (get_user(n
, (int __user
*)arg
))
347 set_device_ro(bdev
, n
);
351 static int blkdev_getgeo(struct block_device
*bdev
,
352 struct hd_geometry __user
*argp
)
354 struct gendisk
*disk
= bdev
->bd_disk
;
355 struct hd_geometry geo
;
360 if (!disk
->fops
->getgeo
)
364 * We need to set the startsect first, the driver may
365 * want to override it.
367 memset(&geo
, 0, sizeof(geo
));
368 geo
.start
= get_start_sect(bdev
);
369 ret
= disk
->fops
->getgeo(bdev
, &geo
);
372 if (copy_to_user(argp
, &geo
, sizeof(geo
)))
377 /* set the logical block size */
378 static int blkdev_bszset(struct block_device
*bdev
, fmode_t mode
,
383 if (!capable(CAP_SYS_ADMIN
))
387 if (get_user(n
, argp
))
390 if (!(mode
& FMODE_EXCL
)) {
392 if (blkdev_get(bdev
, mode
| FMODE_EXCL
, &bdev
) < 0)
396 ret
= set_blocksize(bdev
, n
);
397 if (!(mode
& FMODE_EXCL
))
398 blkdev_put(bdev
, mode
| FMODE_EXCL
);
403 * always keep this in sync with compat_blkdev_ioctl()
405 int blkdev_ioctl(struct block_device
*bdev
, fmode_t mode
, unsigned cmd
,
408 struct backing_dev_info
*bdi
;
409 void __user
*argp
= (void __user
*)arg
;
411 unsigned int max_sectors
;
415 return blkdev_flushbuf(bdev
, mode
, cmd
, arg
);
417 return blkdev_roset(bdev
, mode
, cmd
, arg
);
419 return blk_ioctl_discard(bdev
, mode
, arg
, 0);
421 return blk_ioctl_discard(bdev
, mode
, arg
,
422 BLKDEV_DISCARD_SECURE
);
424 return blk_ioctl_zeroout(bdev
, mode
, arg
);
426 return blkdev_getgeo(bdev
, argp
);
431 bdi
= blk_get_backing_dev_info(bdev
);
432 return put_long(arg
, (bdi
->ra_pages
* PAGE_CACHE_SIZE
) / 512);
434 return put_int(arg
, bdev_read_only(bdev
) != 0);
435 case BLKBSZGET
: /* get block device soft block size (cf. BLKSSZGET) */
436 return put_int(arg
, block_size(bdev
));
437 case BLKSSZGET
: /* get block device logical block size */
438 return put_int(arg
, bdev_logical_block_size(bdev
));
439 case BLKPBSZGET
: /* get block device physical block size */
440 return put_uint(arg
, bdev_physical_block_size(bdev
));
442 return put_uint(arg
, bdev_io_min(bdev
));
444 return put_uint(arg
, bdev_io_opt(bdev
));
446 return put_int(arg
, bdev_alignment_offset(bdev
));
447 case BLKDISCARDZEROES
:
448 return put_uint(arg
, bdev_discard_zeroes_data(bdev
));
450 max_sectors
= min_t(unsigned int, USHRT_MAX
,
451 queue_max_sectors(bdev_get_queue(bdev
)));
452 return put_ushort(arg
, max_sectors
);
454 return put_ushort(arg
, !blk_queue_nonrot(bdev_get_queue(bdev
)));
457 if(!capable(CAP_SYS_ADMIN
))
459 bdi
= blk_get_backing_dev_info(bdev
);
460 bdi
->ra_pages
= (arg
* 512) / PAGE_CACHE_SIZE
;
463 return blkdev_bszset(bdev
, mode
, argp
);
465 return blkpg_ioctl(bdev
, argp
);
467 return blkdev_reread_part(bdev
);
469 size
= i_size_read(bdev
->bd_inode
);
470 if ((size
>> 9) > ~0UL)
472 return put_ulong(arg
, size
>> 9);
474 return put_u64(arg
, i_size_read(bdev
->bd_inode
));
478 case BLKTRACETEARDOWN
:
479 return blk_trace_ioctl(bdev
, cmd
, argp
);
481 return __blkdev_driver_ioctl(bdev
, mode
, cmd
, arg
);
484 EXPORT_SYMBOL_GPL(blkdev_ioctl
);