xref: /openbmc/linux/block/ioctl.c (revision 19758688) 
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 "blk.h"
15 
16 static int blkpg_do_ioctl(struct block_device *bdev,
17 			  struct blkpg_partition __user *upart, int op)
18 {
19 	struct gendisk *disk = bdev->bd_disk;
20 	struct blkpg_partition p;
21 	sector_t start, length;
22 
23 	if (!capable(CAP_SYS_ADMIN))
24 		return -EACCES;
25 	if (copy_from_user(&p, upart, sizeof(struct blkpg_partition)))
26 		return -EFAULT;
27 	if (bdev_is_partition(bdev))
28 		return -EINVAL;
29 
30 	if (p.pno <= 0)
31 		return -EINVAL;
32 
33 	if (op == BLKPG_DEL_PARTITION)
34 		return bdev_del_partition(disk, p.pno);
35 
36 	if (p.start < 0 || p.length <= 0 || p.start + p.length < 0)
37 		return -EINVAL;
38 	/* Check that the partition is aligned to the block size */
39 	if (!IS_ALIGNED(p.start | p.length, bdev_logical_block_size(bdev)))
40 		return -EINVAL;
41 
42 	start = p.start >> SECTOR_SHIFT;
43 	length = p.length >> SECTOR_SHIFT;
44 
45 	switch (op) {
46 	case BLKPG_ADD_PARTITION:
47 		return bdev_add_partition(disk, p.pno, start, length);
48 	case BLKPG_RESIZE_PARTITION:
49 		return bdev_resize_partition(disk, p.pno, start, length);
50 	default:
51 		return -EINVAL;
52 	}
53 }
54 
55 static int blkpg_ioctl(struct block_device *bdev,
56 		       struct blkpg_ioctl_arg __user *arg)
57 {
58 	struct blkpg_partition __user *udata;
59 	int op;
60 
61 	if (get_user(op, &arg->op) || get_user(udata, &arg->data))
62 		return -EFAULT;
63 
64 	return blkpg_do_ioctl(bdev, udata, op);
65 }
66 
67 #ifdef CONFIG_COMPAT
68 struct compat_blkpg_ioctl_arg {
69 	compat_int_t op;
70 	compat_int_t flags;
71 	compat_int_t datalen;
72 	compat_caddr_t data;
73 };
74 
75 static int compat_blkpg_ioctl(struct block_device *bdev,
76 			      struct compat_blkpg_ioctl_arg __user *arg)
77 {
78 	compat_caddr_t udata;
79 	int op;
80 
81 	if (get_user(op, &arg->op) || get_user(udata, &arg->data))
82 		return -EFAULT;
83 
84 	return blkpg_do_ioctl(bdev, compat_ptr(udata), op);
85 }
86 #endif
87 
88 static int blk_ioctl_discard(struct block_device *bdev, blk_mode_t mode,
89 		unsigned long arg)
90 {
91 	uint64_t range[2];
92 	uint64_t start, len;
93 	struct inode *inode = bdev->bd_inode;
94 	int err;
95 
96 	if (!(mode & BLK_OPEN_WRITE))
97 		return -EBADF;
98 
99 	if (!bdev_max_discard_sectors(bdev))
100 		return -EOPNOTSUPP;
101 
102 	if (copy_from_user(range, (void __user *)arg, sizeof(range)))
103 		return -EFAULT;
104 
105 	start = range[0];
106 	len = range[1];
107 
108 	if (start & 511)
109 		return -EINVAL;
110 	if (len & 511)
111 		return -EINVAL;
112 
113 	if (start + len > bdev_nr_bytes(bdev))
114 		return -EINVAL;
115 
116 	filemap_invalidate_lock(inode->i_mapping);
117 	err = truncate_bdev_range(bdev, mode, start, start + len - 1);
118 	if (err)
119 		goto fail;
120 	err = blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_KERNEL);
121 fail:
122 	filemap_invalidate_unlock(inode->i_mapping);
123 	return err;
124 }
125 
126 static int blk_ioctl_secure_erase(struct block_device *bdev, blk_mode_t mode,
127 		void __user *argp)
128 {
129 	uint64_t start, len;
130 	uint64_t range[2];
131 	int err;
132 
133 	if (!(mode & BLK_OPEN_WRITE))
134 		return -EBADF;
135 	if (!bdev_max_secure_erase_sectors(bdev))
136 		return -EOPNOTSUPP;
137 	if (copy_from_user(range, argp, sizeof(range)))
138 		return -EFAULT;
139 
140 	start = range[0];
141 	len = range[1];
142 	if ((start & 511) || (len & 511))
143 		return -EINVAL;
144 	if (start + len > bdev_nr_bytes(bdev))
145 		return -EINVAL;
146 
147 	filemap_invalidate_lock(bdev->bd_inode->i_mapping);
148 	err = truncate_bdev_range(bdev, mode, start, start + len - 1);
149 	if (!err)
150 		err = blkdev_issue_secure_erase(bdev, start >> 9, len >> 9,
151 						GFP_KERNEL);
152 	filemap_invalidate_unlock(bdev->bd_inode->i_mapping);
153 	return err;
154 }
155 
156 
157 static int blk_ioctl_zeroout(struct block_device *bdev, blk_mode_t mode,
158 		unsigned long arg)
159 {
160 	uint64_t range[2];
161 	uint64_t start, end, len;
162 	struct inode *inode = bdev->bd_inode;
163 	int err;
164 
165 	if (!(mode & BLK_OPEN_WRITE))
166 		return -EBADF;
167 
168 	if (copy_from_user(range, (void __user *)arg, sizeof(range)))
169 		return -EFAULT;
170 
171 	start = range[0];
172 	len = range[1];
173 	end = start + len - 1;
174 
175 	if (start & 511)
176 		return -EINVAL;
177 	if (len & 511)
178 		return -EINVAL;
179 	if (end >= (uint64_t)bdev_nr_bytes(bdev))
180 		return -EINVAL;
181 	if (end < start)
182 		return -EINVAL;
183 
184 	/* Invalidate the page cache, including dirty pages */
185 	filemap_invalidate_lock(inode->i_mapping);
186 	err = truncate_bdev_range(bdev, mode, start, end);
187 	if (err)
188 		goto fail;
189 
190 	err = blkdev_issue_zeroout(bdev, start >> 9, len >> 9, GFP_KERNEL,
191 				   BLKDEV_ZERO_NOUNMAP);
192 
193 fail:
194 	filemap_invalidate_unlock(inode->i_mapping);
195 	return err;
196 }
197 
198 static int put_ushort(unsigned short __user *argp, unsigned short val)
199 {
200 	return put_user(val, argp);
201 }
202 
203 static int put_int(int __user *argp, int val)
204 {
205 	return put_user(val, argp);
206 }
207 
208 static int put_uint(unsigned int __user *argp, unsigned int val)
209 {
210 	return put_user(val, argp);
211 }
212 
213 static int put_long(long __user *argp, long val)
214 {
215 	return put_user(val, argp);
216 }
217 
218 static int put_ulong(unsigned long __user *argp, unsigned long val)
219 {
220 	return put_user(val, argp);
221 }
222 
223 static int put_u64(u64 __user *argp, u64 val)
224 {
225 	return put_user(val, argp);
226 }
227 
228 #ifdef CONFIG_COMPAT
229 static int compat_put_long(compat_long_t __user *argp, long val)
230 {
231 	return put_user(val, argp);
232 }
233 
234 static int compat_put_ulong(compat_ulong_t __user *argp, compat_ulong_t val)
235 {
236 	return put_user(val, argp);
237 }
238 #endif
239 
240 #ifdef CONFIG_COMPAT
241 /*
242  * This is the equivalent of compat_ptr_ioctl(), to be used by block
243  * drivers that implement only commands that are completely compatible
244  * between 32-bit and 64-bit user space
245  */
246 int blkdev_compat_ptr_ioctl(struct block_device *bdev, blk_mode_t mode,
247 			unsigned cmd, unsigned long arg)
248 {
249 	struct gendisk *disk = bdev->bd_disk;
250 
251 	if (disk->fops->ioctl)
252 		return disk->fops->ioctl(bdev, mode, cmd,
253 					 (unsigned long)compat_ptr(arg));
254 
255 	return -ENOIOCTLCMD;
256 }
257 EXPORT_SYMBOL(blkdev_compat_ptr_ioctl);
258 #endif
259 
260 static bool blkdev_pr_allowed(struct block_device *bdev, blk_mode_t mode)
261 {
262 	/* no sense to make reservations for partitions */
263 	if (bdev_is_partition(bdev))
264 		return false;
265 
266 	if (capable(CAP_SYS_ADMIN))
267 		return true;
268 	/*
269 	 * Only allow unprivileged reservations if the file descriptor is open
270 	 * for writing.
271 	 */
272 	return mode & BLK_OPEN_WRITE;
273 }
274 
275 static int blkdev_pr_register(struct block_device *bdev, blk_mode_t mode,
276 		struct pr_registration __user *arg)
277 {
278 	const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
279 	struct pr_registration reg;
280 
281 	if (!blkdev_pr_allowed(bdev, mode))
282 		return -EPERM;
283 	if (!ops || !ops->pr_register)
284 		return -EOPNOTSUPP;
285 	if (copy_from_user(&reg, arg, sizeof(reg)))
286 		return -EFAULT;
287 
288 	if (reg.flags & ~PR_FL_IGNORE_KEY)
289 		return -EOPNOTSUPP;
290 	return ops->pr_register(bdev, reg.old_key, reg.new_key, reg.flags);
291 }
292 
293 static int blkdev_pr_reserve(struct block_device *bdev, blk_mode_t mode,
294 		struct pr_reservation __user *arg)
295 {
296 	const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
297 	struct pr_reservation rsv;
298 
299 	if (!blkdev_pr_allowed(bdev, mode))
300 		return -EPERM;
301 	if (!ops || !ops->pr_reserve)
302 		return -EOPNOTSUPP;
303 	if (copy_from_user(&rsv, arg, sizeof(rsv)))
304 		return -EFAULT;
305 
306 	if (rsv.flags & ~PR_FL_IGNORE_KEY)
307 		return -EOPNOTSUPP;
308 	return ops->pr_reserve(bdev, rsv.key, rsv.type, rsv.flags);
309 }
310 
311 static int blkdev_pr_release(struct block_device *bdev, blk_mode_t mode,
312 		struct pr_reservation __user *arg)
313 {
314 	const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
315 	struct pr_reservation rsv;
316 
317 	if (!blkdev_pr_allowed(bdev, mode))
318 		return -EPERM;
319 	if (!ops || !ops->pr_release)
320 		return -EOPNOTSUPP;
321 	if (copy_from_user(&rsv, arg, sizeof(rsv)))
322 		return -EFAULT;
323 
324 	if (rsv.flags)
325 		return -EOPNOTSUPP;
326 	return ops->pr_release(bdev, rsv.key, rsv.type);
327 }
328 
329 static int blkdev_pr_preempt(struct block_device *bdev, blk_mode_t mode,
330 		struct pr_preempt __user *arg, bool abort)
331 {
332 	const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
333 	struct pr_preempt p;
334 
335 	if (!blkdev_pr_allowed(bdev, mode))
336 		return -EPERM;
337 	if (!ops || !ops->pr_preempt)
338 		return -EOPNOTSUPP;
339 	if (copy_from_user(&p, arg, sizeof(p)))
340 		return -EFAULT;
341 
342 	if (p.flags)
343 		return -EOPNOTSUPP;
344 	return ops->pr_preempt(bdev, p.old_key, p.new_key, p.type, abort);
345 }
346 
347 static int blkdev_pr_clear(struct block_device *bdev, blk_mode_t mode,
348 		struct pr_clear __user *arg)
349 {
350 	const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
351 	struct pr_clear c;
352 
353 	if (!blkdev_pr_allowed(bdev, mode))
354 		return -EPERM;
355 	if (!ops || !ops->pr_clear)
356 		return -EOPNOTSUPP;
357 	if (copy_from_user(&c, arg, sizeof(c)))
358 		return -EFAULT;
359 
360 	if (c.flags)
361 		return -EOPNOTSUPP;
362 	return ops->pr_clear(bdev, c.key);
363 }
364 
365 static int blkdev_flushbuf(struct block_device *bdev, unsigned cmd,
366 		unsigned long arg)
367 {
368 	if (!capable(CAP_SYS_ADMIN))
369 		return -EACCES;
370 
371 	mutex_lock(&bdev->bd_holder_lock);
372 	if (bdev->bd_holder_ops && bdev->bd_holder_ops->sync)
373 		bdev->bd_holder_ops->sync(bdev);
374 	else
375 		sync_blockdev(bdev);
376 	mutex_unlock(&bdev->bd_holder_lock);
377 
378 	invalidate_bdev(bdev);
379 	return 0;
380 }
381 
382 static int blkdev_roset(struct block_device *bdev, unsigned cmd,
383 		unsigned long arg)
384 {
385 	int ret, n;
386 
387 	if (!capable(CAP_SYS_ADMIN))
388 		return -EACCES;
389 
390 	if (get_user(n, (int __user *)arg))
391 		return -EFAULT;
392 	if (bdev->bd_disk->fops->set_read_only) {
393 		ret = bdev->bd_disk->fops->set_read_only(bdev, n);
394 		if (ret)
395 			return ret;
396 	}
397 	bdev->bd_read_only = n;
398 	return 0;
399 }
400 
401 static int blkdev_getgeo(struct block_device *bdev,
402 		struct hd_geometry __user *argp)
403 {
404 	struct gendisk *disk = bdev->bd_disk;
405 	struct hd_geometry geo;
406 	int ret;
407 
408 	if (!argp)
409 		return -EINVAL;
410 	if (!disk->fops->getgeo)
411 		return -ENOTTY;
412 
413 	/*
414 	 * We need to set the startsect first, the driver may
415 	 * want to override it.
416 	 */
417 	memset(&geo, 0, sizeof(geo));
418 	geo.start = get_start_sect(bdev);
419 	ret = disk->fops->getgeo(bdev, &geo);
420 	if (ret)
421 		return ret;
422 	if (copy_to_user(argp, &geo, sizeof(geo)))
423 		return -EFAULT;
424 	return 0;
425 }
426 
427 #ifdef CONFIG_COMPAT
428 struct compat_hd_geometry {
429 	unsigned char heads;
430 	unsigned char sectors;
431 	unsigned short cylinders;
432 	u32 start;
433 };
434 
435 static int compat_hdio_getgeo(struct block_device *bdev,
436 			      struct compat_hd_geometry __user *ugeo)
437 {
438 	struct gendisk *disk = bdev->bd_disk;
439 	struct hd_geometry geo;
440 	int ret;
441 
442 	if (!ugeo)
443 		return -EINVAL;
444 	if (!disk->fops->getgeo)
445 		return -ENOTTY;
446 
447 	memset(&geo, 0, sizeof(geo));
448 	/*
449 	 * We need to set the startsect first, the driver may
450 	 * want to override it.
451 	 */
452 	geo.start = get_start_sect(bdev);
453 	ret = disk->fops->getgeo(bdev, &geo);
454 	if (ret)
455 		return ret;
456 
457 	ret = copy_to_user(ugeo, &geo, 4);
458 	ret |= put_user(geo.start, &ugeo->start);
459 	if (ret)
460 		ret = -EFAULT;
461 
462 	return ret;
463 }
464 #endif
465 
466 /* set the logical block size */
467 static int blkdev_bszset(struct block_device *bdev, blk_mode_t mode,
468 		int __user *argp)
469 {
470 	int ret, n;
471 
472 	if (!capable(CAP_SYS_ADMIN))
473 		return -EACCES;
474 	if (!argp)
475 		return -EINVAL;
476 	if (get_user(n, argp))
477 		return -EFAULT;
478 
479 	if (mode & BLK_OPEN_EXCL)
480 		return set_blocksize(bdev, n);
481 
482 	if (IS_ERR(blkdev_get_by_dev(bdev->bd_dev, mode, &bdev, NULL)))
483 		return -EBUSY;
484 	ret = set_blocksize(bdev, n);
485 	blkdev_put(bdev, &bdev);
486 
487 	return ret;
488 }
489 
490 /*
491  * Common commands that are handled the same way on native and compat
492  * user space. Note the separate arg/argp parameters that are needed
493  * to deal with the compat_ptr() conversion.
494  */
495 static int blkdev_common_ioctl(struct block_device *bdev, blk_mode_t mode,
496 			       unsigned int cmd, unsigned long arg,
497 			       void __user *argp)
498 {
499 	unsigned int max_sectors;
500 
501 	switch (cmd) {
502 	case BLKFLSBUF:
503 		return blkdev_flushbuf(bdev, cmd, arg);
504 	case BLKROSET:
505 		return blkdev_roset(bdev, cmd, arg);
506 	case BLKDISCARD:
507 		return blk_ioctl_discard(bdev, mode, arg);
508 	case BLKSECDISCARD:
509 		return blk_ioctl_secure_erase(bdev, mode, argp);
510 	case BLKZEROOUT:
511 		return blk_ioctl_zeroout(bdev, mode, arg);
512 	case BLKGETDISKSEQ:
513 		return put_u64(argp, bdev->bd_disk->diskseq);
514 	case BLKREPORTZONE:
515 		return blkdev_report_zones_ioctl(bdev, cmd, arg);
516 	case BLKRESETZONE:
517 	case BLKOPENZONE:
518 	case BLKCLOSEZONE:
519 	case BLKFINISHZONE:
520 		return blkdev_zone_mgmt_ioctl(bdev, mode, cmd, arg);
521 	case BLKGETZONESZ:
522 		return put_uint(argp, bdev_zone_sectors(bdev));
523 	case BLKGETNRZONES:
524 		return put_uint(argp, bdev_nr_zones(bdev));
525 	case BLKROGET:
526 		return put_int(argp, bdev_read_only(bdev) != 0);
527 	case BLKSSZGET: /* get block device logical block size */
528 		return put_int(argp, bdev_logical_block_size(bdev));
529 	case BLKPBSZGET: /* get block device physical block size */
530 		return put_uint(argp, bdev_physical_block_size(bdev));
531 	case BLKIOMIN:
532 		return put_uint(argp, bdev_io_min(bdev));
533 	case BLKIOOPT:
534 		return put_uint(argp, bdev_io_opt(bdev));
535 	case BLKALIGNOFF:
536 		return put_int(argp, bdev_alignment_offset(bdev));
537 	case BLKDISCARDZEROES:
538 		return put_uint(argp, 0);
539 	case BLKSECTGET:
540 		max_sectors = min_t(unsigned int, USHRT_MAX,
541 				    queue_max_sectors(bdev_get_queue(bdev)));
542 		return put_ushort(argp, max_sectors);
543 	case BLKROTATIONAL:
544 		return put_ushort(argp, !bdev_nonrot(bdev));
545 	case BLKRASET:
546 	case BLKFRASET:
547 		if(!capable(CAP_SYS_ADMIN))
548 			return -EACCES;
549 		bdev->bd_disk->bdi->ra_pages = (arg * 512) / PAGE_SIZE;
550 		return 0;
551 	case BLKRRPART:
552 		if (!capable(CAP_SYS_ADMIN))
553 			return -EACCES;
554 		if (bdev_is_partition(bdev))
555 			return -EINVAL;
556 		return disk_scan_partitions(bdev->bd_disk, mode);
557 	case BLKTRACESTART:
558 	case BLKTRACESTOP:
559 	case BLKTRACETEARDOWN:
560 		return blk_trace_ioctl(bdev, cmd, argp);
561 	case IOC_PR_REGISTER:
562 		return blkdev_pr_register(bdev, mode, argp);
563 	case IOC_PR_RESERVE:
564 		return blkdev_pr_reserve(bdev, mode, argp);
565 	case IOC_PR_RELEASE:
566 		return blkdev_pr_release(bdev, mode, argp);
567 	case IOC_PR_PREEMPT:
568 		return blkdev_pr_preempt(bdev, mode, argp, false);
569 	case IOC_PR_PREEMPT_ABORT:
570 		return blkdev_pr_preempt(bdev, mode, argp, true);
571 	case IOC_PR_CLEAR:
572 		return blkdev_pr_clear(bdev, mode, argp);
573 	default:
574 		return -ENOIOCTLCMD;
575 	}
576 }
577 
578 /*
579  * Always keep this in sync with compat_blkdev_ioctl()
580  * to handle all incompatible commands in both functions.
581  *
582  * New commands must be compatible and go into blkdev_common_ioctl
583  */
584 long blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
585 {
586 	struct block_device *bdev = I_BDEV(file->f_mapping->host);
587 	void __user *argp = (void __user *)arg;
588 	blk_mode_t mode = file_to_blk_mode(file);
589 	int ret;
590 
591 	switch (cmd) {
592 	/* These need separate implementations for the data structure */
593 	case HDIO_GETGEO:
594 		return blkdev_getgeo(bdev, argp);
595 	case BLKPG:
596 		return blkpg_ioctl(bdev, argp);
597 
598 	/* Compat mode returns 32-bit data instead of 'long' */
599 	case BLKRAGET:
600 	case BLKFRAGET:
601 		if (!argp)
602 			return -EINVAL;
603 		return put_long(argp,
604 			(bdev->bd_disk->bdi->ra_pages * PAGE_SIZE) / 512);
605 	case BLKGETSIZE:
606 		if (bdev_nr_sectors(bdev) > ~0UL)
607 			return -EFBIG;
608 		return put_ulong(argp, bdev_nr_sectors(bdev));
609 
610 	/* The data is compatible, but the command number is different */
611 	case BLKBSZGET: /* get block device soft block size (cf. BLKSSZGET) */
612 		return put_int(argp, block_size(bdev));
613 	case BLKBSZSET:
614 		return blkdev_bszset(bdev, mode, argp);
615 	case BLKGETSIZE64:
616 		return put_u64(argp, bdev_nr_bytes(bdev));
617 
618 	/* Incompatible alignment on i386 */
619 	case BLKTRACESETUP:
620 		return blk_trace_ioctl(bdev, cmd, argp);
621 	default:
622 		break;
623 	}
624 
625 	ret = blkdev_common_ioctl(bdev, mode, cmd, arg, argp);
626 	if (ret != -ENOIOCTLCMD)
627 		return ret;
628 
629 	if (!bdev->bd_disk->fops->ioctl)
630 		return -ENOTTY;
631 	return bdev->bd_disk->fops->ioctl(bdev, mode, cmd, arg);
632 }
633 
634 #ifdef CONFIG_COMPAT
635 
636 #define BLKBSZGET_32		_IOR(0x12, 112, int)
637 #define BLKBSZSET_32		_IOW(0x12, 113, int)
638 #define BLKGETSIZE64_32		_IOR(0x12, 114, int)
639 
640 /* Most of the generic ioctls are handled in the normal fallback path.
641    This assumes the blkdev's low level compat_ioctl always returns
642    ENOIOCTLCMD for unknown ioctls. */
643 long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
644 {
645 	int ret;
646 	void __user *argp = compat_ptr(arg);
647 	struct block_device *bdev = I_BDEV(file->f_mapping->host);
648 	struct gendisk *disk = bdev->bd_disk;
649 	blk_mode_t mode = file_to_blk_mode(file);
650 
651 	switch (cmd) {
652 	/* These need separate implementations for the data structure */
653 	case HDIO_GETGEO:
654 		return compat_hdio_getgeo(bdev, argp);
655 	case BLKPG:
656 		return compat_blkpg_ioctl(bdev, argp);
657 
658 	/* Compat mode returns 32-bit data instead of 'long' */
659 	case BLKRAGET:
660 	case BLKFRAGET:
661 		if (!argp)
662 			return -EINVAL;
663 		return compat_put_long(argp,
664 			(bdev->bd_disk->bdi->ra_pages * PAGE_SIZE) / 512);
665 	case BLKGETSIZE:
666 		if (bdev_nr_sectors(bdev) > ~(compat_ulong_t)0)
667 			return -EFBIG;
668 		return compat_put_ulong(argp, bdev_nr_sectors(bdev));
669 
670 	/* The data is compatible, but the command number is different */
671 	case BLKBSZGET_32: /* get the logical block size (cf. BLKSSZGET) */
672 		return put_int(argp, bdev_logical_block_size(bdev));
673 	case BLKBSZSET_32:
674 		return blkdev_bszset(bdev, mode, argp);
675 	case BLKGETSIZE64_32:
676 		return put_u64(argp, bdev_nr_bytes(bdev));
677 
678 	/* Incompatible alignment on i386 */
679 	case BLKTRACESETUP32:
680 		return blk_trace_ioctl(bdev, cmd, argp);
681 	default:
682 		break;
683 	}
684 
685 	ret = blkdev_common_ioctl(bdev, mode, cmd, arg, argp);
686 	if (ret == -ENOIOCTLCMD && disk->fops->compat_ioctl)
687 		ret = disk->fops->compat_ioctl(bdev, mode, cmd, arg);
688 
689 	return ret;
690 }
691 #endif
692