~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/ioctl.c

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 (!capable(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 (!capable(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 SYSCALL_DEFINE3(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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp