1
2
3
4
5
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
26#define FIEMAP_MAX_EXTENTS (UINT_MAX / sizeof(struct fiemap_extent))
27
28
29
30
31
32
33
34
35
36
37
38
39long 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
53static int ioctl_fibmap(struct file *filp, int __user *p)
54{
55 struct address_space *mapping = filp->f_mapping;
56 int res, block;
57
58
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
72
73
74
75
76
77
78
79
80
81
82
83
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)
88int 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
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}
125EXPORT_SYMBOL(fiemap_fill_next_extent);
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141int 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}
152EXPORT_SYMBOL(fiemap_check_flags);
153
154static 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
169
170 if (len > maxbytes || (maxbytes - len) < start)
171 *new_len = maxbytes - start;
172
173 return 0;
174}
175
176static 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
221static 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);
233fdput:
234 fdput(src_file);
235 return ret;
236}
237
238static 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
250static inline sector_t logical_to_blk(struct inode *inode, loff_t offset)
251{
252 return (offset >> inode->i_blkbits);
253}
254
255static inline loff_t blk_to_logical(struct inode *inode, sector_t blk)
256{
257 return (blk << inode->i_blkbits);
258}
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280int __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
298
299
300
301 if (len >= isize) {
302 whole_file = true;
303 len = isize;
304 }
305
306
307
308
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
319
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
329 if (!buffer_mapped(&map_bh)) {
330 start_blk++;
331
332
333
334
335
336
337
338
339 if (!past_eof &&
340 blk_to_logical(inode, start_blk) >= isize)
341 past_eof = 1;
342
343
344
345
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
359 if (start_blk > last_blk || past_eof || ret)
360 break;
361 } else {
362
363
364
365
366
367
368
369
370
371
372
373
374
375
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
386
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
405
406
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
420 if (ret == 1)
421 ret = 0;
422
423 return ret;
424}
425EXPORT_SYMBOL(__generic_block_fiemap);
426
427
428
429
430
431
432
433
434
435
436
437
438
439int 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}
449EXPORT_SYMBOL(generic_block_fiemap);
450
451#endif
452
453
454
455
456
457
458
459
460int 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
484static 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
503static 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
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
526static 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
538 if ((flag ^ filp->f_flags) & FASYNC) {
539 if (filp->f_op->fasync)
540
541 error = filp->f_op->fasync(fd, filp, on);
542 else
543 error = -ENOTTY;
544 }
545 return error < 0 ? error : 0;
546}
547
548static 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
556 if (sb->s_op->freeze_fs == NULL && sb->s_op->freeze_super == NULL)
557 return -EOPNOTSUPP;
558
559
560 if (sb->s_op->freeze_super)
561 return sb->s_op->freeze_super(sb);
562 return freeze_super(sb);
563}
564
565static 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
573 if (sb->s_op->thaw_super)
574 return sb->s_op->thaw_super(sb);
575 return thaw_super(sb);
576}
577
578static 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
613out:
614 kfree(same);
615 return ret;
616}
617
618
619
620
621
622
623
624
625int 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
692int ksys_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
706SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
707{
708 return ksys_ioctl(fd, cmd, arg);
709}
710