Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/fs/ioctl.c

  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  */
 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 
 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)
 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  */
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 
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 
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 
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 = -EXDEV;
227         if (src_file.file->f_path.mnt != dst_file->f_path.mnt)
228                 goto fdput;
229         ret = do_clone_file_range(src_file.file, off, dst_file, destoff, olen);
230 fdput:
231         fdput(src_file);
232         return ret;
233 }
234 
235 static long ioctl_file_clone_range(struct file *file, void __user *argp)
236 {
237         struct file_clone_range args;
238 
239         if (copy_from_user(&args, argp, sizeof(args)))
240                 return -EFAULT;
241         return ioctl_file_clone(file, args.src_fd, args.src_offset,
242                                 args.src_length, args.dest_offset);
243 }
244 
245 #ifdef CONFIG_BLOCK
246 
247 static inline sector_t logical_to_blk(struct inode *inode, loff_t offset)
248 {
249         return (offset >> inode->i_blkbits);
250 }
251 
252 static inline loff_t blk_to_logical(struct inode *inode, sector_t blk)
253 {
254         return (blk << inode->i_blkbits);
255 }
256 
257 /**
258  * __generic_block_fiemap - FIEMAP for block based inodes (no locking)
259  * @inode: the inode to map
260  * @fieinfo: the fiemap info struct that will be passed back to userspace
261  * @start: where to start mapping in the inode
262  * @len: how much space to map
263  * @get_block: the fs's get_block function
264  *
265  * This does FIEMAP for block based inodes.  Basically it will just loop
266  * through get_block until we hit the number of extents we want to map, or we
267  * go past the end of the file and hit a hole.
268  *
269  * If it is possible to have data blocks beyond a hole past @inode->i_size, then
270  * please do not use this function, it will stop at the first unmapped block
271  * beyond i_size.
272  *
273  * If you use this function directly, you need to do your own locking. Use
274  * generic_block_fiemap if you want the locking done for you.
275  */
276 
277 int __generic_block_fiemap(struct inode *inode,
278                            struct fiemap_extent_info *fieinfo, loff_t start,
279                            loff_t len, get_block_t *get_block)
280 {
281         struct buffer_head map_bh;
282         sector_t start_blk, last_blk;
283         loff_t isize = i_size_read(inode);
284         u64 logical = 0, phys = 0, size = 0;
285         u32 flags = FIEMAP_EXTENT_MERGED;
286         bool past_eof = false, whole_file = false;
287         int ret = 0;
288 
289         ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
290         if (ret)
291                 return ret;
292 
293         /*
294          * Either the i_mutex or other appropriate locking needs to be held
295          * since we expect isize to not change at all through the duration of
296          * this call.
297          */
298         if (len >= isize) {
299                 whole_file = true;
300                 len = isize;
301         }
302 
303         /*
304          * Some filesystems can't deal with being asked to map less than
305          * blocksize, so make sure our len is at least block length.
306          */
307         if (logical_to_blk(inode, len) == 0)
308                 len = blk_to_logical(inode, 1);
309 
310         start_blk = logical_to_blk(inode, start);
311         last_blk = logical_to_blk(inode, start + len - 1);
312 
313         do {
314                 /*
315                  * we set b_size to the total size we want so it will map as
316                  * many contiguous blocks as possible at once
317                  */
318                 memset(&map_bh, 0, sizeof(struct buffer_head));
319                 map_bh.b_size = len;
320 
321                 ret = get_block(inode, start_blk, &map_bh, 0);
322                 if (ret)
323                         break;
324 
325                 /* HOLE */
326                 if (!buffer_mapped(&map_bh)) {
327                         start_blk++;
328 
329                         /*
330                          * We want to handle the case where there is an
331                          * allocated block at the front of the file, and then
332                          * nothing but holes up to the end of the file properly,
333                          * to make sure that extent at the front gets properly
334                          * marked with FIEMAP_EXTENT_LAST
335                          */
336                         if (!past_eof &&
337                             blk_to_logical(inode, start_blk) >= isize)
338                                 past_eof = 1;
339 
340                         /*
341                          * First hole after going past the EOF, this is our
342                          * last extent
343                          */
344                         if (past_eof && size) {
345                                 flags = FIEMAP_EXTENT_MERGED|FIEMAP_EXTENT_LAST;
346                                 ret = fiemap_fill_next_extent(fieinfo, logical,
347                                                               phys, size,
348                                                               flags);
349                         } else if (size) {
350                                 ret = fiemap_fill_next_extent(fieinfo, logical,
351                                                               phys, size, flags);
352                                 size = 0;
353                         }
354 
355                         /* if we have holes up to/past EOF then we're done */
356                         if (start_blk > last_blk || past_eof || ret)
357                                 break;
358                 } else {
359                         /*
360                          * We have gone over the length of what we wanted to
361                          * map, and it wasn't the entire file, so add the extent
362                          * we got last time and exit.
363                          *
364                          * This is for the case where say we want to map all the
365                          * way up to the second to the last block in a file, but
366                          * the last block is a hole, making the second to last
367                          * block FIEMAP_EXTENT_LAST.  In this case we want to
368                          * see if there is a hole after the second to last block
369                          * so we can mark it properly.  If we found data after
370                          * we exceeded the length we were requesting, then we
371                          * are good to go, just add the extent to the fieinfo
372                          * and break
373                          */
374                         if (start_blk > last_blk && !whole_file) {
375                                 ret = fiemap_fill_next_extent(fieinfo, logical,
376                                                               phys, size,
377                                                               flags);
378                                 break;
379                         }
380 
381                         /*
382                          * if size != 0 then we know we already have an extent
383                          * to add, so add it.
384                          */
385                         if (size) {
386                                 ret = fiemap_fill_next_extent(fieinfo, logical,
387                                                               phys, size,
388                                                               flags);
389                                 if (ret)
390                                         break;
391                         }
392 
393                         logical = blk_to_logical(inode, start_blk);
394                         phys = blk_to_logical(inode, map_bh.b_blocknr);
395                         size = map_bh.b_size;
396                         flags = FIEMAP_EXTENT_MERGED;
397 
398                         start_blk += logical_to_blk(inode, size);
399 
400                         /*
401                          * If we are past the EOF, then we need to make sure as
402                          * soon as we find a hole that the last extent we found
403                          * is marked with FIEMAP_EXTENT_LAST
404                          */
405                         if (!past_eof && logical + size >= isize)
406                                 past_eof = true;
407                 }
408                 cond_resched();
409                 if (fatal_signal_pending(current)) {
410                         ret = -EINTR;
411                         break;
412                 }
413 
414         } while (1);
415 
416         /* If ret is 1 then we just hit the end of the extent array */
417         if (ret == 1)
418                 ret = 0;
419 
420         return ret;
421 }
422 EXPORT_SYMBOL(__generic_block_fiemap);
423 
424 /**
425  * generic_block_fiemap - FIEMAP for block based inodes
426  * @inode: The inode to map
427  * @fieinfo: The mapping information
428  * @start: The initial block to map
429  * @len: The length of the extect to attempt to map
430  * @get_block: The block mapping function for the fs
431  *
432  * Calls __generic_block_fiemap to map the inode, after taking
433  * the inode's mutex lock.
434  */
435 
436 int generic_block_fiemap(struct inode *inode,
437                          struct fiemap_extent_info *fieinfo, u64 start,
438                          u64 len, get_block_t *get_block)
439 {
440         int ret;
441         inode_lock(inode);
442         ret = __generic_block_fiemap(inode, fieinfo, start, len, get_block);
443         inode_unlock(inode);
444         return ret;
445 }
446 EXPORT_SYMBOL(generic_block_fiemap);
447 
448 #endif  /*  CONFIG_BLOCK  */
449 
450 /*
451  * This provides compatibility with legacy XFS pre-allocation ioctls
452  * which predate the fallocate syscall.
453  *
454  * Only the l_start, l_len and l_whence fields of the 'struct space_resv'
455  * are used here, rest are ignored.
456  */
457 int ioctl_preallocate(struct file *filp, void __user *argp)
458 {
459         struct inode *inode = file_inode(filp);
460         struct space_resv sr;
461 
462         if (copy_from_user(&sr, argp, sizeof(sr)))
463                 return -EFAULT;
464 
465         switch (sr.l_whence) {
466         case SEEK_SET:
467                 break;
468         case SEEK_CUR:
469                 sr.l_start += filp->f_pos;
470                 break;
471         case SEEK_END:
472                 sr.l_start += i_size_read(inode);
473                 break;
474         default:
475                 return -EINVAL;
476         }
477 
478         return vfs_fallocate(filp, FALLOC_FL_KEEP_SIZE, sr.l_start, sr.l_len);
479 }
480 
481 static int file_ioctl(struct file *filp, unsigned int cmd,
482                 unsigned long arg)
483 {
484         struct inode *inode = file_inode(filp);
485         int __user *p = (int __user *)arg;
486 
487         switch (cmd) {
488         case FIBMAP:
489                 return ioctl_fibmap(filp, p);
490         case FIONREAD:
491                 return put_user(i_size_read(inode) - filp->f_pos, p);
492         case FS_IOC_RESVSP:
493         case FS_IOC_RESVSP64:
494                 return ioctl_preallocate(filp, p);
495         }
496 
497         return vfs_ioctl(filp, cmd, arg);
498 }
499 
500 static int ioctl_fionbio(struct file *filp, int __user *argp)
501 {
502         unsigned int flag;
503         int on, error;
504 
505         error = get_user(on, argp);
506         if (error)
507                 return error;
508         flag = O_NONBLOCK;
509 #ifdef __sparc__
510         /* SunOS compatibility item. */
511         if (O_NONBLOCK != O_NDELAY)
512                 flag |= O_NDELAY;
513 #endif
514         spin_lock(&filp->f_lock);
515         if (on)
516                 filp->f_flags |= flag;
517         else
518                 filp->f_flags &= ~flag;
519         spin_unlock(&filp->f_lock);
520         return error;
521 }
522 
523 static int ioctl_fioasync(unsigned int fd, struct file *filp,
524                           int __user *argp)
525 {
526         unsigned int flag;
527         int on, error;
528 
529         error = get_user(on, argp);
530         if (error)
531                 return error;
532         flag = on ? FASYNC : 0;
533 
534         /* Did FASYNC state change ? */
535         if ((flag ^ filp->f_flags) & FASYNC) {
536                 if (filp->f_op->fasync)
537                         /* fasync() adjusts filp->f_flags */
538                         error = filp->f_op->fasync(fd, filp, on);
539                 else
540                         error = -ENOTTY;
541         }
542         return error < 0 ? error : 0;
543 }
544 
545 static int ioctl_fsfreeze(struct file *filp)
546 {
547         struct super_block *sb = file_inode(filp)->i_sb;
548 
549         if (!capable(CAP_SYS_ADMIN))
550                 return -EPERM;
551 
552         /* If filesystem doesn't support freeze feature, return. */
553         if (sb->s_op->freeze_fs == NULL && sb->s_op->freeze_super == NULL)
554                 return -EOPNOTSUPP;
555 
556         /* Freeze */
557         if (sb->s_op->freeze_super)
558                 return sb->s_op->freeze_super(sb);
559         return freeze_super(sb);
560 }
561 
562 static int ioctl_fsthaw(struct file *filp)
563 {
564         struct super_block *sb = file_inode(filp)->i_sb;
565 
566         if (!capable(CAP_SYS_ADMIN))
567                 return -EPERM;
568 
569         /* Thaw */
570         if (sb->s_op->thaw_super)
571                 return sb->s_op->thaw_super(sb);
572         return thaw_super(sb);
573 }
574 
575 static int ioctl_file_dedupe_range(struct file *file, void __user *arg)
576 {
577         struct file_dedupe_range __user *argp = arg;
578         struct file_dedupe_range *same = NULL;
579         int ret;
580         unsigned long size;
581         u16 count;
582 
583         if (get_user(count, &argp->dest_count)) {
584                 ret = -EFAULT;
585                 goto out;
586         }
587 
588         size = offsetof(struct file_dedupe_range __user, info[count]);
589         if (size > PAGE_SIZE) {
590                 ret = -ENOMEM;
591                 goto out;
592         }
593 
594         same = memdup_user(argp, size);
595         if (IS_ERR(same)) {
596                 ret = PTR_ERR(same);
597                 same = NULL;
598                 goto out;
599         }
600 
601         same->dest_count = count;
602         ret = vfs_dedupe_file_range(file, same);
603         if (ret)
604                 goto out;
605 
606         ret = copy_to_user(argp, same, size);
607         if (ret)
608                 ret = -EFAULT;
609 
610 out:
611         kfree(same);
612         return ret;
613 }
614 
615 /*
616  * When you add any new common ioctls to the switches above and below
617  * please update compat_sys_ioctl() too.
618  *
619  * do_vfs_ioctl() is not for drivers and not intended to be EXPORT_SYMBOL()'d.
620  * It's just a simple helper for sys_ioctl and compat_sys_ioctl.
621  */
622 int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
623              unsigned long arg)
624 {
625         int error = 0;
626         int __user *argp = (int __user *)arg;
627         struct inode *inode = file_inode(filp);
628 
629         switch (cmd) {
630         case FIOCLEX:
631                 set_close_on_exec(fd, 1);
632                 break;
633 
634         case FIONCLEX:
635                 set_close_on_exec(fd, 0);
636                 break;
637 
638         case FIONBIO:
639                 error = ioctl_fionbio(filp, argp);
640                 break;
641 
642         case FIOASYNC:
643                 error = ioctl_fioasync(fd, filp, argp);
644                 break;
645 
646         case FIOQSIZE:
647                 if (S_ISDIR(inode->i_mode) || S_ISREG(inode->i_mode) ||
648                     S_ISLNK(inode->i_mode)) {
649                         loff_t res = inode_get_bytes(inode);
650                         error = copy_to_user(argp, &res, sizeof(res)) ?
651                                         -EFAULT : 0;
652                 } else
653                         error = -ENOTTY;
654                 break;
655 
656         case FIFREEZE:
657                 error = ioctl_fsfreeze(filp);
658                 break;
659 
660         case FITHAW:
661                 error = ioctl_fsthaw(filp);
662                 break;
663 
664         case FS_IOC_FIEMAP:
665                 return ioctl_fiemap(filp, arg);
666 
667         case FIGETBSZ:
668                 return put_user(inode->i_sb->s_blocksize, argp);
669 
670         case FICLONE:
671                 return ioctl_file_clone(filp, arg, 0, 0, 0);
672 
673         case FICLONERANGE:
674                 return ioctl_file_clone_range(filp, argp);
675 
676         case FIDEDUPERANGE:
677                 return ioctl_file_dedupe_range(filp, argp);
678 
679         default:
680                 if (S_ISREG(inode->i_mode))
681                         error = file_ioctl(filp, cmd, arg);
682                 else
683                         error = vfs_ioctl(filp, cmd, arg);
684                 break;
685         }
686         return error;
687 }
688 
689 SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
690 {
691         int error;
692         struct fd f = fdget(fd);
693 
694         if (!f.file)
695                 return -EBADF;
696         error = security_file_ioctl(f.file, cmd, arg);
697         if (!error)
698                 error = do_vfs_ioctl(f.file, fd, cmd, arg);
699         fdput(f);
700         return error;
701 }
702 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us