xref: /openbmc/linux/fs/ioctl.c (revision 8bd1369b)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  linux/fs/ioctl.c
4  *
5  *  Copyright (C) 1991, 1992  Linus Torvalds
6  */
7 
8 #include <linux/syscalls.h>
9 #include <linux/mm.h>
10 #include <linux/capability.h>
11 #include <linux/file.h>
12 #include <linux/fs.h>
13 #include <linux/security.h>
14 #include <linux/export.h>
15 #include <linux/uaccess.h>
16 #include <linux/writeback.h>
17 #include <linux/buffer_head.h>
18 #include <linux/falloc.h>
19 #include <linux/sched/signal.h>
20 
21 #include "internal.h"
22 
23 #include <asm/ioctls.h>
24 
25 /* So that the fiemap access checks can't overflow on 32 bit machines. */
26 #define FIEMAP_MAX_EXTENTS	(UINT_MAX / sizeof(struct fiemap_extent))
27 
28 /**
29  * vfs_ioctl - call filesystem specific ioctl methods
30  * @filp:	open file to invoke ioctl method on
31  * @cmd:	ioctl command to execute
32  * @arg:	command-specific argument for ioctl
33  *
34  * Invokes filesystem specific ->unlocked_ioctl, if one exists; otherwise
35  * returns -ENOTTY.
36  *
37  * Returns 0 on success, -errno on error.
38  */
39 long vfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
40 {
41 	int error = -ENOTTY;
42 
43 	if (!filp->f_op->unlocked_ioctl)
44 		goto out;
45 
46 	error = filp->f_op->unlocked_ioctl(filp, cmd, arg);
47 	if (error == -ENOIOCTLCMD)
48 		error = -ENOTTY;
49  out:
50 	return error;
51 }
52 
53 static int ioctl_fibmap(struct file *filp, int __user *p)
54 {
55 	struct address_space *mapping = filp->f_mapping;
56 	int res, block;
57 
58 	/* do we support this mess? */
59 	if (!mapping->a_ops->bmap)
60 		return -EINVAL;
61 	if (!capable(CAP_SYS_RAWIO))
62 		return -EPERM;
63 	res = get_user(block, p);
64 	if (res)
65 		return res;
66 	res = mapping->a_ops->bmap(mapping, block);
67 	return put_user(res, p);
68 }
69 
70 /**
71  * fiemap_fill_next_extent - Fiemap helper function
72  * @fieinfo:	Fiemap context passed into ->fiemap
73  * @logical:	Extent logical start offset, in bytes
74  * @phys:	Extent physical start offset, in bytes
75  * @len:	Extent length, in bytes
76  * @flags:	FIEMAP_EXTENT flags that describe this extent
77  *
78  * Called from file system ->fiemap callback. Will populate extent
79  * info as passed in via arguments and copy to user memory. On
80  * success, extent count on fieinfo is incremented.
81  *
82  * Returns 0 on success, -errno on error, 1 if this was the last
83  * extent that will fit in user array.
84  */
85 #define SET_UNKNOWN_FLAGS	(FIEMAP_EXTENT_DELALLOC)
86 #define SET_NO_UNMOUNTED_IO_FLAGS	(FIEMAP_EXTENT_DATA_ENCRYPTED)
87 #define SET_NOT_ALIGNED_FLAGS	(FIEMAP_EXTENT_DATA_TAIL|FIEMAP_EXTENT_DATA_INLINE)
88 int fiemap_fill_next_extent(struct fiemap_extent_info *fieinfo, u64 logical,
89 			    u64 phys, u64 len, u32 flags)
90 {
91 	struct fiemap_extent extent;
92 	struct fiemap_extent __user *dest = fieinfo->fi_extents_start;
93 
94 	/* only count the extents */
95 	if (fieinfo->fi_extents_max == 0) {
96 		fieinfo->fi_extents_mapped++;
97 		return (flags & FIEMAP_EXTENT_LAST) ? 1 : 0;
98 	}
99 
100 	if (fieinfo->fi_extents_mapped >= fieinfo->fi_extents_max)
101 		return 1;
102 
103 	if (flags & SET_UNKNOWN_FLAGS)
104 		flags |= FIEMAP_EXTENT_UNKNOWN;
105 	if (flags & SET_NO_UNMOUNTED_IO_FLAGS)
106 		flags |= FIEMAP_EXTENT_ENCODED;
107 	if (flags & SET_NOT_ALIGNED_FLAGS)
108 		flags |= FIEMAP_EXTENT_NOT_ALIGNED;
109 
110 	memset(&extent, 0, sizeof(extent));
111 	extent.fe_logical = logical;
112 	extent.fe_physical = phys;
113 	extent.fe_length = len;
114 	extent.fe_flags = flags;
115 
116 	dest += fieinfo->fi_extents_mapped;
117 	if (copy_to_user(dest, &extent, sizeof(extent)))
118 		return -EFAULT;
119 
120 	fieinfo->fi_extents_mapped++;
121 	if (fieinfo->fi_extents_mapped == fieinfo->fi_extents_max)
122 		return 1;
123 	return (flags & FIEMAP_EXTENT_LAST) ? 1 : 0;
124 }
125 EXPORT_SYMBOL(fiemap_fill_next_extent);
126 
127 /**
128  * fiemap_check_flags - check validity of requested flags for fiemap
129  * @fieinfo:	Fiemap context passed into ->fiemap
130  * @fs_flags:	Set of fiemap flags that the file system understands
131  *
132  * Called from file system ->fiemap callback. This will compute the
133  * intersection of valid fiemap flags and those that the fs supports. That
134  * value is then compared against the user supplied flags. In case of bad user
135  * flags, the invalid values will be written into the fieinfo structure, and
136  * -EBADR is returned, which tells ioctl_fiemap() to return those values to
137  * userspace. For this reason, a return code of -EBADR should be preserved.
138  *
139  * Returns 0 on success, -EBADR on bad flags.
140  */
141 int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags)
142 {
143 	u32 incompat_flags;
144 
145 	incompat_flags = fieinfo->fi_flags & ~(FIEMAP_FLAGS_COMPAT & fs_flags);
146 	if (incompat_flags) {
147 		fieinfo->fi_flags = incompat_flags;
148 		return -EBADR;
149 	}
150 	return 0;
151 }
152 EXPORT_SYMBOL(fiemap_check_flags);
153 
154 static int fiemap_check_ranges(struct super_block *sb,
155 			       u64 start, u64 len, u64 *new_len)
156 {
157 	u64 maxbytes = (u64) sb->s_maxbytes;
158 
159 	*new_len = len;
160 
161 	if (len == 0)
162 		return -EINVAL;
163 
164 	if (start > maxbytes)
165 		return -EFBIG;
166 
167 	/*
168 	 * Shrink request scope to what the fs can actually handle.
169 	 */
170 	if (len > maxbytes || (maxbytes - len) < start)
171 		*new_len = maxbytes - start;
172 
173 	return 0;
174 }
175 
176 static int ioctl_fiemap(struct file *filp, unsigned long arg)
177 {
178 	struct fiemap fiemap;
179 	struct fiemap __user *ufiemap = (struct fiemap __user *) arg;
180 	struct fiemap_extent_info fieinfo = { 0, };
181 	struct inode *inode = file_inode(filp);
182 	struct super_block *sb = inode->i_sb;
183 	u64 len;
184 	int error;
185 
186 	if (!inode->i_op->fiemap)
187 		return -EOPNOTSUPP;
188 
189 	if (copy_from_user(&fiemap, ufiemap, sizeof(fiemap)))
190 		return -EFAULT;
191 
192 	if (fiemap.fm_extent_count > FIEMAP_MAX_EXTENTS)
193 		return -EINVAL;
194 
195 	error = fiemap_check_ranges(sb, fiemap.fm_start, fiemap.fm_length,
196 				    &len);
197 	if (error)
198 		return error;
199 
200 	fieinfo.fi_flags = fiemap.fm_flags;
201 	fieinfo.fi_extents_max = fiemap.fm_extent_count;
202 	fieinfo.fi_extents_start = ufiemap->fm_extents;
203 
204 	if (fiemap.fm_extent_count != 0 &&
205 	    !access_ok(VERIFY_WRITE, fieinfo.fi_extents_start,
206 		       fieinfo.fi_extents_max * sizeof(struct fiemap_extent)))
207 		return -EFAULT;
208 
209 	if (fieinfo.fi_flags & FIEMAP_FLAG_SYNC)
210 		filemap_write_and_wait(inode->i_mapping);
211 
212 	error = inode->i_op->fiemap(inode, &fieinfo, fiemap.fm_start, len);
213 	fiemap.fm_flags = fieinfo.fi_flags;
214 	fiemap.fm_mapped_extents = fieinfo.fi_extents_mapped;
215 	if (copy_to_user(ufiemap, &fiemap, sizeof(fiemap)))
216 		error = -EFAULT;
217 
218 	return error;
219 }
220 
221 static long ioctl_file_clone(struct file *dst_file, unsigned long srcfd,
222 			     u64 off, u64 olen, u64 destoff)
223 {
224 	struct fd src_file = fdget(srcfd);
225 	int ret;
226 
227 	if (!src_file.file)
228 		return -EBADF;
229 	ret = -EXDEV;
230 	if (src_file.file->f_path.mnt != dst_file->f_path.mnt)
231 		goto fdput;
232 	ret = do_clone_file_range(src_file.file, off, dst_file, destoff, olen);
233 fdput:
234 	fdput(src_file);
235 	return ret;
236 }
237 
238 static long ioctl_file_clone_range(struct file *file, void __user *argp)
239 {
240 	struct file_clone_range args;
241 
242 	if (copy_from_user(&args, argp, sizeof(args)))
243 		return -EFAULT;
244 	return ioctl_file_clone(file, args.src_fd, args.src_offset,
245 				args.src_length, args.dest_offset);
246 }
247 
248 #ifdef CONFIG_BLOCK
249 
250 static inline sector_t logical_to_blk(struct inode *inode, loff_t offset)
251 {
252 	return (offset >> inode->i_blkbits);
253 }
254 
255 static inline loff_t blk_to_logical(struct inode *inode, sector_t blk)
256 {
257 	return (blk << inode->i_blkbits);
258 }
259 
260 /**
261  * __generic_block_fiemap - FIEMAP for block based inodes (no locking)
262  * @inode: the inode to map
263  * @fieinfo: the fiemap info struct that will be passed back to userspace
264  * @start: where to start mapping in the inode
265  * @len: how much space to map
266  * @get_block: the fs's get_block function
267  *
268  * This does FIEMAP for block based inodes.  Basically it will just loop
269  * through get_block until we hit the number of extents we want to map, or we
270  * go past the end of the file and hit a hole.
271  *
272  * If it is possible to have data blocks beyond a hole past @inode->i_size, then
273  * please do not use this function, it will stop at the first unmapped block
274  * beyond i_size.
275  *
276  * If you use this function directly, you need to do your own locking. Use
277  * generic_block_fiemap if you want the locking done for you.
278  */
279 
280 int __generic_block_fiemap(struct inode *inode,
281 			   struct fiemap_extent_info *fieinfo, loff_t start,
282 			   loff_t len, get_block_t *get_block)
283 {
284 	struct buffer_head map_bh;
285 	sector_t start_blk, last_blk;
286 	loff_t isize = i_size_read(inode);
287 	u64 logical = 0, phys = 0, size = 0;
288 	u32 flags = FIEMAP_EXTENT_MERGED;
289 	bool past_eof = false, whole_file = false;
290 	int ret = 0;
291 
292 	ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
293 	if (ret)
294 		return ret;
295 
296 	/*
297 	 * Either the i_mutex or other appropriate locking needs to be held
298 	 * since we expect isize to not change at all through the duration of
299 	 * this call.
300 	 */
301 	if (len >= isize) {
302 		whole_file = true;
303 		len = isize;
304 	}
305 
306 	/*
307 	 * Some filesystems can't deal with being asked to map less than
308 	 * blocksize, so make sure our len is at least block length.
309 	 */
310 	if (logical_to_blk(inode, len) == 0)
311 		len = blk_to_logical(inode, 1);
312 
313 	start_blk = logical_to_blk(inode, start);
314 	last_blk = logical_to_blk(inode, start + len - 1);
315 
316 	do {
317 		/*
318 		 * we set b_size to the total size we want so it will map as
319 		 * many contiguous blocks as possible at once
320 		 */
321 		memset(&map_bh, 0, sizeof(struct buffer_head));
322 		map_bh.b_size = len;
323 
324 		ret = get_block(inode, start_blk, &map_bh, 0);
325 		if (ret)
326 			break;
327 
328 		/* HOLE */
329 		if (!buffer_mapped(&map_bh)) {
330 			start_blk++;
331 
332 			/*
333 			 * We want to handle the case where there is an
334 			 * allocated block at the front of the file, and then
335 			 * nothing but holes up to the end of the file properly,
336 			 * to make sure that extent at the front gets properly
337 			 * marked with FIEMAP_EXTENT_LAST
338 			 */
339 			if (!past_eof &&
340 			    blk_to_logical(inode, start_blk) >= isize)
341 				past_eof = 1;
342 
343 			/*
344 			 * First hole after going past the EOF, this is our
345 			 * last extent
346 			 */
347 			if (past_eof && size) {
348 				flags = FIEMAP_EXTENT_MERGED|FIEMAP_EXTENT_LAST;
349 				ret = fiemap_fill_next_extent(fieinfo, logical,
350 							      phys, size,
351 							      flags);
352 			} else if (size) {
353 				ret = fiemap_fill_next_extent(fieinfo, logical,
354 							      phys, size, flags);
355 				size = 0;
356 			}
357 
358 			/* if we have holes up to/past EOF then we're done */
359 			if (start_blk > last_blk || past_eof || ret)
360 				break;
361 		} else {
362 			/*
363 			 * We have gone over the length of what we wanted to
364 			 * map, and it wasn't the entire file, so add the extent
365 			 * we got last time and exit.
366 			 *
367 			 * This is for the case where say we want to map all the
368 			 * way up to the second to the last block in a file, but
369 			 * the last block is a hole, making the second to last
370 			 * block FIEMAP_EXTENT_LAST.  In this case we want to
371 			 * see if there is a hole after the second to last block
372 			 * so we can mark it properly.  If we found data after
373 			 * we exceeded the length we were requesting, then we
374 			 * are good to go, just add the extent to the fieinfo
375 			 * and break
376 			 */
377 			if (start_blk > last_blk && !whole_file) {
378 				ret = fiemap_fill_next_extent(fieinfo, logical,
379 							      phys, size,
380 							      flags);
381 				break;
382 			}
383 
384 			/*
385 			 * if size != 0 then we know we already have an extent
386 			 * to add, so add it.
387 			 */
388 			if (size) {
389 				ret = fiemap_fill_next_extent(fieinfo, logical,
390 							      phys, size,
391 							      flags);
392 				if (ret)
393 					break;
394 			}
395 
396 			logical = blk_to_logical(inode, start_blk);
397 			phys = blk_to_logical(inode, map_bh.b_blocknr);
398 			size = map_bh.b_size;
399 			flags = FIEMAP_EXTENT_MERGED;
400 
401 			start_blk += logical_to_blk(inode, size);
402 
403 			/*
404 			 * If we are past the EOF, then we need to make sure as
405 			 * soon as we find a hole that the last extent we found
406 			 * is marked with FIEMAP_EXTENT_LAST
407 			 */
408 			if (!past_eof && logical + size >= isize)
409 				past_eof = true;
410 		}
411 		cond_resched();
412 		if (fatal_signal_pending(current)) {
413 			ret = -EINTR;
414 			break;
415 		}
416 
417 	} while (1);
418 
419 	/* If ret is 1 then we just hit the end of the extent array */
420 	if (ret == 1)
421 		ret = 0;
422 
423 	return ret;
424 }
425 EXPORT_SYMBOL(__generic_block_fiemap);
426 
427 /**
428  * generic_block_fiemap - FIEMAP for block based inodes
429  * @inode: The inode to map
430  * @fieinfo: The mapping information
431  * @start: The initial block to map
432  * @len: The length of the extect to attempt to map
433  * @get_block: The block mapping function for the fs
434  *
435  * Calls __generic_block_fiemap to map the inode, after taking
436  * the inode's mutex lock.
437  */
438 
439 int generic_block_fiemap(struct inode *inode,
440 			 struct fiemap_extent_info *fieinfo, u64 start,
441 			 u64 len, get_block_t *get_block)
442 {
443 	int ret;
444 	inode_lock(inode);
445 	ret = __generic_block_fiemap(inode, fieinfo, start, len, get_block);
446 	inode_unlock(inode);
447 	return ret;
448 }
449 EXPORT_SYMBOL(generic_block_fiemap);
450 
451 #endif  /*  CONFIG_BLOCK  */
452 
453 /*
454  * This provides compatibility with legacy XFS pre-allocation ioctls
455  * which predate the fallocate syscall.
456  *
457  * Only the l_start, l_len and l_whence fields of the 'struct space_resv'
458  * are used here, rest are ignored.
459  */
460 int ioctl_preallocate(struct file *filp, void __user *argp)
461 {
462 	struct inode *inode = file_inode(filp);
463 	struct space_resv sr;
464 
465 	if (copy_from_user(&sr, argp, sizeof(sr)))
466 		return -EFAULT;
467 
468 	switch (sr.l_whence) {
469 	case SEEK_SET:
470 		break;
471 	case SEEK_CUR:
472 		sr.l_start += filp->f_pos;
473 		break;
474 	case SEEK_END:
475 		sr.l_start += i_size_read(inode);
476 		break;
477 	default:
478 		return -EINVAL;
479 	}
480 
481 	return vfs_fallocate(filp, FALLOC_FL_KEEP_SIZE, sr.l_start, sr.l_len);
482 }
483 
484 static int file_ioctl(struct file *filp, unsigned int cmd,
485 		unsigned long arg)
486 {
487 	struct inode *inode = file_inode(filp);
488 	int __user *p = (int __user *)arg;
489 
490 	switch (cmd) {
491 	case FIBMAP:
492 		return ioctl_fibmap(filp, p);
493 	case FIONREAD:
494 		return put_user(i_size_read(inode) - filp->f_pos, p);
495 	case FS_IOC_RESVSP:
496 	case FS_IOC_RESVSP64:
497 		return ioctl_preallocate(filp, p);
498 	}
499 
500 	return vfs_ioctl(filp, cmd, arg);
501 }
502 
503 static int ioctl_fionbio(struct file *filp, int __user *argp)
504 {
505 	unsigned int flag;
506 	int on, error;
507 
508 	error = get_user(on, argp);
509 	if (error)
510 		return error;
511 	flag = O_NONBLOCK;
512 #ifdef __sparc__
513 	/* SunOS compatibility item. */
514 	if (O_NONBLOCK != O_NDELAY)
515 		flag |= O_NDELAY;
516 #endif
517 	spin_lock(&filp->f_lock);
518 	if (on)
519 		filp->f_flags |= flag;
520 	else
521 		filp->f_flags &= ~flag;
522 	spin_unlock(&filp->f_lock);
523 	return error;
524 }
525 
526 static int ioctl_fioasync(unsigned int fd, struct file *filp,
527 			  int __user *argp)
528 {
529 	unsigned int flag;
530 	int on, error;
531 
532 	error = get_user(on, argp);
533 	if (error)
534 		return error;
535 	flag = on ? FASYNC : 0;
536 
537 	/* Did FASYNC state change ? */
538 	if ((flag ^ filp->f_flags) & FASYNC) {
539 		if (filp->f_op->fasync)
540 			/* fasync() adjusts filp->f_flags */
541 			error = filp->f_op->fasync(fd, filp, on);
542 		else
543 			error = -ENOTTY;
544 	}
545 	return error < 0 ? error : 0;
546 }
547 
548 static int ioctl_fsfreeze(struct file *filp)
549 {
550 	struct super_block *sb = file_inode(filp)->i_sb;
551 
552 	if (!ns_capable(sb->s_user_ns, CAP_SYS_ADMIN))
553 		return -EPERM;
554 
555 	/* If filesystem doesn't support freeze feature, return. */
556 	if (sb->s_op->freeze_fs == NULL && sb->s_op->freeze_super == NULL)
557 		return -EOPNOTSUPP;
558 
559 	/* Freeze */
560 	if (sb->s_op->freeze_super)
561 		return sb->s_op->freeze_super(sb);
562 	return freeze_super(sb);
563 }
564 
565 static int ioctl_fsthaw(struct file *filp)
566 {
567 	struct super_block *sb = file_inode(filp)->i_sb;
568 
569 	if (!ns_capable(sb->s_user_ns, CAP_SYS_ADMIN))
570 		return -EPERM;
571 
572 	/* Thaw */
573 	if (sb->s_op->thaw_super)
574 		return sb->s_op->thaw_super(sb);
575 	return thaw_super(sb);
576 }
577 
578 static int ioctl_file_dedupe_range(struct file *file, void __user *arg)
579 {
580 	struct file_dedupe_range __user *argp = arg;
581 	struct file_dedupe_range *same = NULL;
582 	int ret;
583 	unsigned long size;
584 	u16 count;
585 
586 	if (get_user(count, &argp->dest_count)) {
587 		ret = -EFAULT;
588 		goto out;
589 	}
590 
591 	size = offsetof(struct file_dedupe_range __user, info[count]);
592 	if (size > PAGE_SIZE) {
593 		ret = -ENOMEM;
594 		goto out;
595 	}
596 
597 	same = memdup_user(argp, size);
598 	if (IS_ERR(same)) {
599 		ret = PTR_ERR(same);
600 		same = NULL;
601 		goto out;
602 	}
603 
604 	same->dest_count = count;
605 	ret = vfs_dedupe_file_range(file, same);
606 	if (ret)
607 		goto out;
608 
609 	ret = copy_to_user(argp, same, size);
610 	if (ret)
611 		ret = -EFAULT;
612 
613 out:
614 	kfree(same);
615 	return ret;
616 }
617 
618 /*
619  * When you add any new common ioctls to the switches above and below
620  * please update compat_sys_ioctl() too.
621  *
622  * do_vfs_ioctl() is not for drivers and not intended to be EXPORT_SYMBOL()'d.
623  * It's just a simple helper for sys_ioctl and compat_sys_ioctl.
624  */
625 int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
626 	     unsigned long arg)
627 {
628 	int error = 0;
629 	int __user *argp = (int __user *)arg;
630 	struct inode *inode = file_inode(filp);
631 
632 	switch (cmd) {
633 	case FIOCLEX:
634 		set_close_on_exec(fd, 1);
635 		break;
636 
637 	case FIONCLEX:
638 		set_close_on_exec(fd, 0);
639 		break;
640 
641 	case FIONBIO:
642 		error = ioctl_fionbio(filp, argp);
643 		break;
644 
645 	case FIOASYNC:
646 		error = ioctl_fioasync(fd, filp, argp);
647 		break;
648 
649 	case FIOQSIZE:
650 		if (S_ISDIR(inode->i_mode) || S_ISREG(inode->i_mode) ||
651 		    S_ISLNK(inode->i_mode)) {
652 			loff_t res = inode_get_bytes(inode);
653 			error = copy_to_user(argp, &res, sizeof(res)) ?
654 					-EFAULT : 0;
655 		} else
656 			error = -ENOTTY;
657 		break;
658 
659 	case FIFREEZE:
660 		error = ioctl_fsfreeze(filp);
661 		break;
662 
663 	case FITHAW:
664 		error = ioctl_fsthaw(filp);
665 		break;
666 
667 	case FS_IOC_FIEMAP:
668 		return ioctl_fiemap(filp, arg);
669 
670 	case FIGETBSZ:
671 		return put_user(inode->i_sb->s_blocksize, argp);
672 
673 	case FICLONE:
674 		return ioctl_file_clone(filp, arg, 0, 0, 0);
675 
676 	case FICLONERANGE:
677 		return ioctl_file_clone_range(filp, argp);
678 
679 	case FIDEDUPERANGE:
680 		return ioctl_file_dedupe_range(filp, argp);
681 
682 	default:
683 		if (S_ISREG(inode->i_mode))
684 			error = file_ioctl(filp, cmd, arg);
685 		else
686 			error = vfs_ioctl(filp, cmd, arg);
687 		break;
688 	}
689 	return error;
690 }
691 
692 int ksys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
693 {
694 	int error;
695 	struct fd f = fdget(fd);
696 
697 	if (!f.file)
698 		return -EBADF;
699 	error = security_file_ioctl(f.file, cmd, arg);
700 	if (!error)
701 		error = do_vfs_ioctl(f.file, fd, cmd, arg);
702 	fdput(f);
703 	return error;
704 }
705 
706 SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
707 {
708 	return ksys_ioctl(fd, cmd, arg);
709 }
710