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