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