1
2
3
4
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
23#define FIEMAP_MAX_EXTENTS (UINT_MAX / sizeof(struct fiemap_extent))
24
25
26
27
28
29
30
31
32
33
34
35
36
37static 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
61static int ioctl_fibmap(struct file *filp, int __user *p)
62{
63 struct address_space *mapping = filp->f_mapping;
64 int res, block;
65
66
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
80
81
82
83
84
85
86
87
88
89
90
91
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)
96int 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
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}
133EXPORT_SYMBOL(fiemap_fill_next_extent);
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149int 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}
160EXPORT_SYMBOL(fiemap_check_flags);
161
162static 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
177
178 if (len > maxbytes || (maxbytes - len) < start)
179 *new_len = maxbytes - start;
180
181 return 0;
182}
183
184static 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#define blk_to_logical(inode, blk) (blk << (inode)->i_blkbits)
232#define logical_to_blk(inode, offset) (offset >> (inode)->i_blkbits);
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252int __generic_block_fiemap(struct inode *inode,
253 struct fiemap_extent_info *fieinfo, u64 start,
254 u64 len, get_block_t *get_block)
255{
256 struct buffer_head tmp;
257 unsigned long long start_blk;
258 long long length = 0, map_len = 0;
259 u64 logical = 0, phys = 0, size = 0;
260 u32 flags = FIEMAP_EXTENT_MERGED;
261 int ret = 0, past_eof = 0, whole_file = 0;
262
263 if ((ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC)))
264 return ret;
265
266 start_blk = logical_to_blk(inode, start);
267
268 length = (long long)min_t(u64, len, i_size_read(inode));
269 if (length < len)
270 whole_file = 1;
271
272 map_len = length;
273
274 do {
275
276
277
278
279 memset(&tmp, 0, sizeof(struct buffer_head));
280 tmp.b_size = map_len;
281
282 ret = get_block(inode, start_blk, &tmp, 0);
283 if (ret)
284 break;
285
286
287 if (!buffer_mapped(&tmp)) {
288 length -= blk_to_logical(inode, 1);
289 start_blk++;
290
291
292
293
294
295
296
297
298 if (!past_eof &&
299 blk_to_logical(inode, start_blk) >=
300 blk_to_logical(inode, 0)+i_size_read(inode))
301 past_eof = 1;
302
303
304
305
306
307 if (past_eof && size) {
308 flags = FIEMAP_EXTENT_MERGED|FIEMAP_EXTENT_LAST;
309 ret = fiemap_fill_next_extent(fieinfo, logical,
310 phys, size,
311 flags);
312 break;
313 }
314
315
316 if (length <= 0 || past_eof)
317 break;
318 } else {
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334 if (length <= 0 && !whole_file) {
335 ret = fiemap_fill_next_extent(fieinfo, logical,
336 phys, size,
337 flags);
338 break;
339 }
340
341
342
343
344
345 if (size) {
346 ret = fiemap_fill_next_extent(fieinfo, logical,
347 phys, size,
348 flags);
349 if (ret)
350 break;
351 }
352
353 logical = blk_to_logical(inode, start_blk);
354 phys = blk_to_logical(inode, tmp.b_blocknr);
355 size = tmp.b_size;
356 flags = FIEMAP_EXTENT_MERGED;
357
358 length -= tmp.b_size;
359 start_blk += logical_to_blk(inode, size);
360
361
362
363
364
365
366 if (!past_eof &&
367 logical+size >=
368 blk_to_logical(inode, 0)+i_size_read(inode))
369 past_eof = 1;
370 }
371 cond_resched();
372 } while (1);
373
374
375 if (ret == 1)
376 ret = 0;
377
378 return ret;
379}
380EXPORT_SYMBOL(__generic_block_fiemap);
381
382
383
384
385
386
387
388
389
390
391
392
393
394int generic_block_fiemap(struct inode *inode,
395 struct fiemap_extent_info *fieinfo, u64 start,
396 u64 len, get_block_t *get_block)
397{
398 int ret;
399 mutex_lock(&inode->i_mutex);
400 ret = __generic_block_fiemap(inode, fieinfo, start, len, get_block);
401 mutex_unlock(&inode->i_mutex);
402 return ret;
403}
404EXPORT_SYMBOL(generic_block_fiemap);
405
406#endif
407
408
409
410
411
412
413
414
415int ioctl_preallocate(struct file *filp, void __user *argp)
416{
417 struct inode *inode = filp->f_path.dentry->d_inode;
418 struct space_resv sr;
419
420 if (copy_from_user(&sr, argp, sizeof(sr)))
421 return -EFAULT;
422
423 switch (sr.l_whence) {
424 case SEEK_SET:
425 break;
426 case SEEK_CUR:
427 sr.l_start += filp->f_pos;
428 break;
429 case SEEK_END:
430 sr.l_start += i_size_read(inode);
431 break;
432 default:
433 return -EINVAL;
434 }
435
436 return do_fallocate(filp, FALLOC_FL_KEEP_SIZE, sr.l_start, sr.l_len);
437}
438
439static int file_ioctl(struct file *filp, unsigned int cmd,
440 unsigned long arg)
441{
442 struct inode *inode = filp->f_path.dentry->d_inode;
443 int __user *p = (int __user *)arg;
444
445 switch (cmd) {
446 case FIBMAP:
447 return ioctl_fibmap(filp, p);
448 case FIONREAD:
449 return put_user(i_size_read(inode) - filp->f_pos, p);
450 case FS_IOC_RESVSP:
451 case FS_IOC_RESVSP64:
452 return ioctl_preallocate(filp, p);
453 }
454
455 return vfs_ioctl(filp, cmd, arg);
456}
457
458static int ioctl_fionbio(struct file *filp, int __user *argp)
459{
460 unsigned int flag;
461 int on, error;
462
463 error = get_user(on, argp);
464 if (error)
465 return error;
466 flag = O_NONBLOCK;
467#ifdef __sparc__
468
469 if (O_NONBLOCK != O_NDELAY)
470 flag |= O_NDELAY;
471#endif
472 spin_lock(&filp->f_lock);
473 if (on)
474 filp->f_flags |= flag;
475 else
476 filp->f_flags &= ~flag;
477 spin_unlock(&filp->f_lock);
478 return error;
479}
480
481static int ioctl_fioasync(unsigned int fd, struct file *filp,
482 int __user *argp)
483{
484 unsigned int flag;
485 int on, error;
486
487 error = get_user(on, argp);
488 if (error)
489 return error;
490 flag = on ? FASYNC : 0;
491
492
493 if ((flag ^ filp->f_flags) & FASYNC) {
494 if (filp->f_op && filp->f_op->fasync)
495
496 error = filp->f_op->fasync(fd, filp, on);
497 else
498 error = -ENOTTY;
499 }
500 return error < 0 ? error : 0;
501}
502
503static int ioctl_fsfreeze(struct file *filp)
504{
505 struct super_block *sb = filp->f_path.dentry->d_inode->i_sb;
506
507 if (!capable(CAP_SYS_ADMIN))
508 return -EPERM;
509
510
511 if (sb->s_op->freeze_fs == NULL)
512 return -EOPNOTSUPP;
513
514
515 if (sb->s_bdev == NULL)
516 return -EINVAL;
517
518
519 sb = freeze_bdev(sb->s_bdev);
520 if (IS_ERR(sb))
521 return PTR_ERR(sb);
522 return 0;
523}
524
525static int ioctl_fsthaw(struct file *filp)
526{
527 struct super_block *sb = filp->f_path.dentry->d_inode->i_sb;
528
529 if (!capable(CAP_SYS_ADMIN))
530 return -EPERM;
531
532
533 if (sb->s_bdev == NULL)
534 return -EINVAL;
535
536
537 return thaw_bdev(sb->s_bdev, sb);
538}
539
540
541
542
543
544
545
546
547int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
548 unsigned long arg)
549{
550 int error = 0;
551 int __user *argp = (int __user *)arg;
552
553 switch (cmd) {
554 case FIOCLEX:
555 set_close_on_exec(fd, 1);
556 break;
557
558 case FIONCLEX:
559 set_close_on_exec(fd, 0);
560 break;
561
562 case FIONBIO:
563 error = ioctl_fionbio(filp, argp);
564 break;
565
566 case FIOASYNC:
567 error = ioctl_fioasync(fd, filp, argp);
568 break;
569
570 case FIOQSIZE:
571 if (S_ISDIR(filp->f_path.dentry->d_inode->i_mode) ||
572 S_ISREG(filp->f_path.dentry->d_inode->i_mode) ||
573 S_ISLNK(filp->f_path.dentry->d_inode->i_mode)) {
574 loff_t res =
575 inode_get_bytes(filp->f_path.dentry->d_inode);
576 error = copy_to_user((loff_t __user *)arg, &res,
577 sizeof(res)) ? -EFAULT : 0;
578 } else
579 error = -ENOTTY;
580 break;
581
582 case FIFREEZE:
583 error = ioctl_fsfreeze(filp);
584 break;
585
586 case FITHAW:
587 error = ioctl_fsthaw(filp);
588 break;
589
590 case FS_IOC_FIEMAP:
591 return ioctl_fiemap(filp, arg);
592
593 case FIGETBSZ:
594 {
595 struct inode *inode = filp->f_path.dentry->d_inode;
596 int __user *p = (int __user *)arg;
597 return put_user(inode->i_sb->s_blocksize, p);
598 }
599
600 default:
601 if (S_ISREG(filp->f_path.dentry->d_inode->i_mode))
602 error = file_ioctl(filp, cmd, arg);
603 else
604 error = vfs_ioctl(filp, cmd, arg);
605 break;
606 }
607 return error;
608}
609
610SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
611{
612 struct file *filp;
613 int error = -EBADF;
614 int fput_needed;
615
616 filp = fget_light(fd, &fput_needed);
617 if (!filp)
618 goto out;
619
620 error = security_file_ioctl(filp, cmd, arg);
621 if (error)
622 goto out_fput;
623
624 error = do_vfs_ioctl(filp, fd, cmd, arg);
625 out_fput:
626 fput_light(filp, fput_needed);
627 out:
628 return error;
629}
630