Merge branch 'work.ipc' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
[muen/linux.git] / fs / read_write.c
1 /*
2  *  linux/fs/read_write.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  */
6
7 #include <linux/slab.h>
8 #include <linux/stat.h>
9 #include <linux/sched/xacct.h>
10 #include <linux/fcntl.h>
11 #include <linux/file.h>
12 #include <linux/uio.h>
13 #include <linux/fsnotify.h>
14 #include <linux/security.h>
15 #include <linux/export.h>
16 #include <linux/syscalls.h>
17 #include <linux/pagemap.h>
18 #include <linux/splice.h>
19 #include <linux/compat.h>
20 #include <linux/mount.h>
21 #include <linux/fs.h>
22 #include "internal.h"
23
24 #include <linux/uaccess.h>
25 #include <asm/unistd.h>
26
27 const struct file_operations generic_ro_fops = {
28         .llseek         = generic_file_llseek,
29         .read_iter      = generic_file_read_iter,
30         .mmap           = generic_file_readonly_mmap,
31         .splice_read    = generic_file_splice_read,
32 };
33
34 EXPORT_SYMBOL(generic_ro_fops);
35
36 static inline bool unsigned_offsets(struct file *file)
37 {
38         return file->f_mode & FMODE_UNSIGNED_OFFSET;
39 }
40
41 /**
42  * vfs_setpos - update the file offset for lseek
43  * @file:       file structure in question
44  * @offset:     file offset to seek to
45  * @maxsize:    maximum file size
46  *
47  * This is a low-level filesystem helper for updating the file offset to
48  * the value specified by @offset if the given offset is valid and it is
49  * not equal to the current file offset.
50  *
51  * Return the specified offset on success and -EINVAL on invalid offset.
52  */
53 loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize)
54 {
55         if (offset < 0 && !unsigned_offsets(file))
56                 return -EINVAL;
57         if (offset > maxsize)
58                 return -EINVAL;
59
60         if (offset != file->f_pos) {
61                 file->f_pos = offset;
62                 file->f_version = 0;
63         }
64         return offset;
65 }
66 EXPORT_SYMBOL(vfs_setpos);
67
68 /**
69  * generic_file_llseek_size - generic llseek implementation for regular files
70  * @file:       file structure to seek on
71  * @offset:     file offset to seek to
72  * @whence:     type of seek
73  * @size:       max size of this file in file system
74  * @eof:        offset used for SEEK_END position
75  *
76  * This is a variant of generic_file_llseek that allows passing in a custom
77  * maximum file size and a custom EOF position, for e.g. hashed directories
78  *
79  * Synchronization:
80  * SEEK_SET and SEEK_END are unsynchronized (but atomic on 64bit platforms)
81  * SEEK_CUR is synchronized against other SEEK_CURs, but not read/writes.
82  * read/writes behave like SEEK_SET against seeks.
83  */
84 loff_t
85 generic_file_llseek_size(struct file *file, loff_t offset, int whence,
86                 loff_t maxsize, loff_t eof)
87 {
88         switch (whence) {
89         case SEEK_END:
90                 offset += eof;
91                 break;
92         case SEEK_CUR:
93                 /*
94                  * Here we special-case the lseek(fd, 0, SEEK_CUR)
95                  * position-querying operation.  Avoid rewriting the "same"
96                  * f_pos value back to the file because a concurrent read(),
97                  * write() or lseek() might have altered it
98                  */
99                 if (offset == 0)
100                         return file->f_pos;
101                 /*
102                  * f_lock protects against read/modify/write race with other
103                  * SEEK_CURs. Note that parallel writes and reads behave
104                  * like SEEK_SET.
105                  */
106                 spin_lock(&file->f_lock);
107                 offset = vfs_setpos(file, file->f_pos + offset, maxsize);
108                 spin_unlock(&file->f_lock);
109                 return offset;
110         case SEEK_DATA:
111                 /*
112                  * In the generic case the entire file is data, so as long as
113                  * offset isn't at the end of the file then the offset is data.
114                  */
115                 if (offset >= eof)
116                         return -ENXIO;
117                 break;
118         case SEEK_HOLE:
119                 /*
120                  * There is a virtual hole at the end of the file, so as long as
121                  * offset isn't i_size or larger, return i_size.
122                  */
123                 if (offset >= eof)
124                         return -ENXIO;
125                 offset = eof;
126                 break;
127         }
128
129         return vfs_setpos(file, offset, maxsize);
130 }
131 EXPORT_SYMBOL(generic_file_llseek_size);
132
133 /**
134  * generic_file_llseek - generic llseek implementation for regular files
135  * @file:       file structure to seek on
136  * @offset:     file offset to seek to
137  * @whence:     type of seek
138  *
139  * This is a generic implemenation of ->llseek useable for all normal local
140  * filesystems.  It just updates the file offset to the value specified by
141  * @offset and @whence.
142  */
143 loff_t generic_file_llseek(struct file *file, loff_t offset, int whence)
144 {
145         struct inode *inode = file->f_mapping->host;
146
147         return generic_file_llseek_size(file, offset, whence,
148                                         inode->i_sb->s_maxbytes,
149                                         i_size_read(inode));
150 }
151 EXPORT_SYMBOL(generic_file_llseek);
152
153 /**
154  * fixed_size_llseek - llseek implementation for fixed-sized devices
155  * @file:       file structure to seek on
156  * @offset:     file offset to seek to
157  * @whence:     type of seek
158  * @size:       size of the file
159  *
160  */
161 loff_t fixed_size_llseek(struct file *file, loff_t offset, int whence, loff_t size)
162 {
163         switch (whence) {
164         case SEEK_SET: case SEEK_CUR: case SEEK_END:
165                 return generic_file_llseek_size(file, offset, whence,
166                                                 size, size);
167         default:
168                 return -EINVAL;
169         }
170 }
171 EXPORT_SYMBOL(fixed_size_llseek);
172
173 /**
174  * no_seek_end_llseek - llseek implementation for fixed-sized devices
175  * @file:       file structure to seek on
176  * @offset:     file offset to seek to
177  * @whence:     type of seek
178  *
179  */
180 loff_t no_seek_end_llseek(struct file *file, loff_t offset, int whence)
181 {
182         switch (whence) {
183         case SEEK_SET: case SEEK_CUR:
184                 return generic_file_llseek_size(file, offset, whence,
185                                                 OFFSET_MAX, 0);
186         default:
187                 return -EINVAL;
188         }
189 }
190 EXPORT_SYMBOL(no_seek_end_llseek);
191
192 /**
193  * no_seek_end_llseek_size - llseek implementation for fixed-sized devices
194  * @file:       file structure to seek on
195  * @offset:     file offset to seek to
196  * @whence:     type of seek
197  * @size:       maximal offset allowed
198  *
199  */
200 loff_t no_seek_end_llseek_size(struct file *file, loff_t offset, int whence, loff_t size)
201 {
202         switch (whence) {
203         case SEEK_SET: case SEEK_CUR:
204                 return generic_file_llseek_size(file, offset, whence,
205                                                 size, 0);
206         default:
207                 return -EINVAL;
208         }
209 }
210 EXPORT_SYMBOL(no_seek_end_llseek_size);
211
212 /**
213  * noop_llseek - No Operation Performed llseek implementation
214  * @file:       file structure to seek on
215  * @offset:     file offset to seek to
216  * @whence:     type of seek
217  *
218  * This is an implementation of ->llseek useable for the rare special case when
219  * userspace expects the seek to succeed but the (device) file is actually not
220  * able to perform the seek. In this case you use noop_llseek() instead of
221  * falling back to the default implementation of ->llseek.
222  */
223 loff_t noop_llseek(struct file *file, loff_t offset, int whence)
224 {
225         return file->f_pos;
226 }
227 EXPORT_SYMBOL(noop_llseek);
228
229 loff_t no_llseek(struct file *file, loff_t offset, int whence)
230 {
231         return -ESPIPE;
232 }
233 EXPORT_SYMBOL(no_llseek);
234
235 loff_t default_llseek(struct file *file, loff_t offset, int whence)
236 {
237         struct inode *inode = file_inode(file);
238         loff_t retval;
239
240         inode_lock(inode);
241         switch (whence) {
242                 case SEEK_END:
243                         offset += i_size_read(inode);
244                         break;
245                 case SEEK_CUR:
246                         if (offset == 0) {
247                                 retval = file->f_pos;
248                                 goto out;
249                         }
250                         offset += file->f_pos;
251                         break;
252                 case SEEK_DATA:
253                         /*
254                          * In the generic case the entire file is data, so as
255                          * long as offset isn't at the end of the file then the
256                          * offset is data.
257                          */
258                         if (offset >= inode->i_size) {
259                                 retval = -ENXIO;
260                                 goto out;
261                         }
262                         break;
263                 case SEEK_HOLE:
264                         /*
265                          * There is a virtual hole at the end of the file, so
266                          * as long as offset isn't i_size or larger, return
267                          * i_size.
268                          */
269                         if (offset >= inode->i_size) {
270                                 retval = -ENXIO;
271                                 goto out;
272                         }
273                         offset = inode->i_size;
274                         break;
275         }
276         retval = -EINVAL;
277         if (offset >= 0 || unsigned_offsets(file)) {
278                 if (offset != file->f_pos) {
279                         file->f_pos = offset;
280                         file->f_version = 0;
281                 }
282                 retval = offset;
283         }
284 out:
285         inode_unlock(inode);
286         return retval;
287 }
288 EXPORT_SYMBOL(default_llseek);
289
290 loff_t vfs_llseek(struct file *file, loff_t offset, int whence)
291 {
292         loff_t (*fn)(struct file *, loff_t, int);
293
294         fn = no_llseek;
295         if (file->f_mode & FMODE_LSEEK) {
296                 if (file->f_op->llseek)
297                         fn = file->f_op->llseek;
298         }
299         return fn(file, offset, whence);
300 }
301 EXPORT_SYMBOL(vfs_llseek);
302
303 SYSCALL_DEFINE3(lseek, unsigned int, fd, off_t, offset, unsigned int, whence)
304 {
305         off_t retval;
306         struct fd f = fdget_pos(fd);
307         if (!f.file)
308                 return -EBADF;
309
310         retval = -EINVAL;
311         if (whence <= SEEK_MAX) {
312                 loff_t res = vfs_llseek(f.file, offset, whence);
313                 retval = res;
314                 if (res != (loff_t)retval)
315                         retval = -EOVERFLOW;    /* LFS: should only happen on 32 bit platforms */
316         }
317         fdput_pos(f);
318         return retval;
319 }
320
321 #ifdef CONFIG_COMPAT
322 COMPAT_SYSCALL_DEFINE3(lseek, unsigned int, fd, compat_off_t, offset, unsigned int, whence)
323 {
324         return sys_lseek(fd, offset, whence);
325 }
326 #endif
327
328 #ifdef __ARCH_WANT_SYS_LLSEEK
329 SYSCALL_DEFINE5(llseek, unsigned int, fd, unsigned long, offset_high,
330                 unsigned long, offset_low, loff_t __user *, result,
331                 unsigned int, whence)
332 {
333         int retval;
334         struct fd f = fdget_pos(fd);
335         loff_t offset;
336
337         if (!f.file)
338                 return -EBADF;
339
340         retval = -EINVAL;
341         if (whence > SEEK_MAX)
342                 goto out_putf;
343
344         offset = vfs_llseek(f.file, ((loff_t) offset_high << 32) | offset_low,
345                         whence);
346
347         retval = (int)offset;
348         if (offset >= 0) {
349                 retval = -EFAULT;
350                 if (!copy_to_user(result, &offset, sizeof(offset)))
351                         retval = 0;
352         }
353 out_putf:
354         fdput_pos(f);
355         return retval;
356 }
357 #endif
358
359 int rw_verify_area(int read_write, struct file *file, const loff_t *ppos, size_t count)
360 {
361         struct inode *inode;
362         loff_t pos;
363         int retval = -EINVAL;
364
365         inode = file_inode(file);
366         if (unlikely((ssize_t) count < 0))
367                 return retval;
368         pos = *ppos;
369         if (unlikely(pos < 0)) {
370                 if (!unsigned_offsets(file))
371                         return retval;
372                 if (count >= -pos) /* both values are in 0..LLONG_MAX */
373                         return -EOVERFLOW;
374         } else if (unlikely((loff_t) (pos + count) < 0)) {
375                 if (!unsigned_offsets(file))
376                         return retval;
377         }
378
379         if (unlikely(inode->i_flctx && mandatory_lock(inode))) {
380                 retval = locks_mandatory_area(inode, file, pos, pos + count - 1,
381                                 read_write == READ ? F_RDLCK : F_WRLCK);
382                 if (retval < 0)
383                         return retval;
384         }
385         return security_file_permission(file,
386                                 read_write == READ ? MAY_READ : MAY_WRITE);
387 }
388
389 static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
390 {
391         struct iovec iov = { .iov_base = buf, .iov_len = len };
392         struct kiocb kiocb;
393         struct iov_iter iter;
394         ssize_t ret;
395
396         init_sync_kiocb(&kiocb, filp);
397         kiocb.ki_pos = *ppos;
398         iov_iter_init(&iter, READ, &iov, 1, len);
399
400         ret = call_read_iter(filp, &kiocb, &iter);
401         BUG_ON(ret == -EIOCBQUEUED);
402         *ppos = kiocb.ki_pos;
403         return ret;
404 }
405
406 ssize_t __vfs_read(struct file *file, char __user *buf, size_t count,
407                    loff_t *pos)
408 {
409         if (file->f_op->read)
410                 return file->f_op->read(file, buf, count, pos);
411         else if (file->f_op->read_iter)
412                 return new_sync_read(file, buf, count, pos);
413         else
414                 return -EINVAL;
415 }
416 EXPORT_SYMBOL(__vfs_read);
417
418 ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
419 {
420         ssize_t ret;
421
422         if (!(file->f_mode & FMODE_READ))
423                 return -EBADF;
424         if (!(file->f_mode & FMODE_CAN_READ))
425                 return -EINVAL;
426         if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
427                 return -EFAULT;
428
429         ret = rw_verify_area(READ, file, pos, count);
430         if (!ret) {
431                 if (count > MAX_RW_COUNT)
432                         count =  MAX_RW_COUNT;
433                 ret = __vfs_read(file, buf, count, pos);
434                 if (ret > 0) {
435                         fsnotify_access(file);
436                         add_rchar(current, ret);
437                 }
438                 inc_syscr(current);
439         }
440
441         return ret;
442 }
443
444 EXPORT_SYMBOL(vfs_read);
445
446 static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
447 {
448         struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
449         struct kiocb kiocb;
450         struct iov_iter iter;
451         ssize_t ret;
452
453         init_sync_kiocb(&kiocb, filp);
454         kiocb.ki_pos = *ppos;
455         iov_iter_init(&iter, WRITE, &iov, 1, len);
456
457         ret = call_write_iter(filp, &kiocb, &iter);
458         BUG_ON(ret == -EIOCBQUEUED);
459         if (ret > 0)
460                 *ppos = kiocb.ki_pos;
461         return ret;
462 }
463
464 ssize_t __vfs_write(struct file *file, const char __user *p, size_t count,
465                     loff_t *pos)
466 {
467         if (file->f_op->write)
468                 return file->f_op->write(file, p, count, pos);
469         else if (file->f_op->write_iter)
470                 return new_sync_write(file, p, count, pos);
471         else
472                 return -EINVAL;
473 }
474 EXPORT_SYMBOL(__vfs_write);
475
476 ssize_t __kernel_write(struct file *file, const char *buf, size_t count, loff_t *pos)
477 {
478         mm_segment_t old_fs;
479         const char __user *p;
480         ssize_t ret;
481
482         if (!(file->f_mode & FMODE_CAN_WRITE))
483                 return -EINVAL;
484
485         old_fs = get_fs();
486         set_fs(get_ds());
487         p = (__force const char __user *)buf;
488         if (count > MAX_RW_COUNT)
489                 count =  MAX_RW_COUNT;
490         ret = __vfs_write(file, p, count, pos);
491         set_fs(old_fs);
492         if (ret > 0) {
493                 fsnotify_modify(file);
494                 add_wchar(current, ret);
495         }
496         inc_syscw(current);
497         return ret;
498 }
499
500 EXPORT_SYMBOL(__kernel_write);
501
502 ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
503 {
504         ssize_t ret;
505
506         if (!(file->f_mode & FMODE_WRITE))
507                 return -EBADF;
508         if (!(file->f_mode & FMODE_CAN_WRITE))
509                 return -EINVAL;
510         if (unlikely(!access_ok(VERIFY_READ, buf, count)))
511                 return -EFAULT;
512
513         ret = rw_verify_area(WRITE, file, pos, count);
514         if (!ret) {
515                 if (count > MAX_RW_COUNT)
516                         count =  MAX_RW_COUNT;
517                 file_start_write(file);
518                 ret = __vfs_write(file, buf, count, pos);
519                 if (ret > 0) {
520                         fsnotify_modify(file);
521                         add_wchar(current, ret);
522                 }
523                 inc_syscw(current);
524                 file_end_write(file);
525         }
526
527         return ret;
528 }
529
530 EXPORT_SYMBOL(vfs_write);
531
532 static inline loff_t file_pos_read(struct file *file)
533 {
534         return file->f_pos;
535 }
536
537 static inline void file_pos_write(struct file *file, loff_t pos)
538 {
539         file->f_pos = pos;
540 }
541
542 SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
543 {
544         struct fd f = fdget_pos(fd);
545         ssize_t ret = -EBADF;
546
547         if (f.file) {
548                 loff_t pos = file_pos_read(f.file);
549                 ret = vfs_read(f.file, buf, count, &pos);
550                 if (ret >= 0)
551                         file_pos_write(f.file, pos);
552                 fdput_pos(f);
553         }
554         return ret;
555 }
556
557 SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
558                 size_t, count)
559 {
560         struct fd f = fdget_pos(fd);
561         ssize_t ret = -EBADF;
562
563         if (f.file) {
564                 loff_t pos = file_pos_read(f.file);
565                 ret = vfs_write(f.file, buf, count, &pos);
566                 if (ret >= 0)
567                         file_pos_write(f.file, pos);
568                 fdput_pos(f);
569         }
570
571         return ret;
572 }
573
574 SYSCALL_DEFINE4(pread64, unsigned int, fd, char __user *, buf,
575                         size_t, count, loff_t, pos)
576 {
577         struct fd f;
578         ssize_t ret = -EBADF;
579
580         if (pos < 0)
581                 return -EINVAL;
582
583         f = fdget(fd);
584         if (f.file) {
585                 ret = -ESPIPE;
586                 if (f.file->f_mode & FMODE_PREAD)
587                         ret = vfs_read(f.file, buf, count, &pos);
588                 fdput(f);
589         }
590
591         return ret;
592 }
593
594 SYSCALL_DEFINE4(pwrite64, unsigned int, fd, const char __user *, buf,
595                          size_t, count, loff_t, pos)
596 {
597         struct fd f;
598         ssize_t ret = -EBADF;
599
600         if (pos < 0)
601                 return -EINVAL;
602
603         f = fdget(fd);
604         if (f.file) {
605                 ret = -ESPIPE;
606                 if (f.file->f_mode & FMODE_PWRITE)  
607                         ret = vfs_write(f.file, buf, count, &pos);
608                 fdput(f);
609         }
610
611         return ret;
612 }
613
614 /*
615  * Reduce an iovec's length in-place.  Return the resulting number of segments
616  */
617 unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to)
618 {
619         unsigned long seg = 0;
620         size_t len = 0;
621
622         while (seg < nr_segs) {
623                 seg++;
624                 if (len + iov->iov_len >= to) {
625                         iov->iov_len = to - len;
626                         break;
627                 }
628                 len += iov->iov_len;
629                 iov++;
630         }
631         return seg;
632 }
633 EXPORT_SYMBOL(iov_shorten);
634
635 static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,
636                 loff_t *ppos, int type, rwf_t flags)
637 {
638         struct kiocb kiocb;
639         ssize_t ret;
640
641         init_sync_kiocb(&kiocb, filp);
642         ret = kiocb_set_rw_flags(&kiocb, flags);
643         if (ret)
644                 return ret;
645         kiocb.ki_pos = *ppos;
646
647         if (type == READ)
648                 ret = call_read_iter(filp, &kiocb, iter);
649         else
650                 ret = call_write_iter(filp, &kiocb, iter);
651         BUG_ON(ret == -EIOCBQUEUED);
652         *ppos = kiocb.ki_pos;
653         return ret;
654 }
655
656 /* Do it by hand, with file-ops */
657 static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,
658                 loff_t *ppos, int type, rwf_t flags)
659 {
660         ssize_t ret = 0;
661
662         if (flags & ~RWF_HIPRI)
663                 return -EOPNOTSUPP;
664
665         while (iov_iter_count(iter)) {
666                 struct iovec iovec = iov_iter_iovec(iter);
667                 ssize_t nr;
668
669                 if (type == READ) {
670                         nr = filp->f_op->read(filp, iovec.iov_base,
671                                               iovec.iov_len, ppos);
672                 } else {
673                         nr = filp->f_op->write(filp, iovec.iov_base,
674                                                iovec.iov_len, ppos);
675                 }
676
677                 if (nr < 0) {
678                         if (!ret)
679                                 ret = nr;
680                         break;
681                 }
682                 ret += nr;
683                 if (nr != iovec.iov_len)
684                         break;
685                 iov_iter_advance(iter, nr);
686         }
687
688         return ret;
689 }
690
691 /* A write operation does a read from user space and vice versa */
692 #define vrfy_dir(type) ((type) == READ ? VERIFY_WRITE : VERIFY_READ)
693
694 /**
695  * rw_copy_check_uvector() - Copy an array of &struct iovec from userspace
696  *     into the kernel and check that it is valid.
697  *
698  * @type: One of %CHECK_IOVEC_ONLY, %READ, or %WRITE.
699  * @uvector: Pointer to the userspace array.
700  * @nr_segs: Number of elements in userspace array.
701  * @fast_segs: Number of elements in @fast_pointer.
702  * @fast_pointer: Pointer to (usually small on-stack) kernel array.
703  * @ret_pointer: (output parameter) Pointer to a variable that will point to
704  *     either @fast_pointer, a newly allocated kernel array, or NULL,
705  *     depending on which array was used.
706  *
707  * This function copies an array of &struct iovec of @nr_segs from
708  * userspace into the kernel and checks that each element is valid (e.g.
709  * it does not point to a kernel address or cause overflow by being too
710  * large, etc.).
711  *
712  * As an optimization, the caller may provide a pointer to a small
713  * on-stack array in @fast_pointer, typically %UIO_FASTIOV elements long
714  * (the size of this array, or 0 if unused, should be given in @fast_segs).
715  *
716  * @ret_pointer will always point to the array that was used, so the
717  * caller must take care not to call kfree() on it e.g. in case the
718  * @fast_pointer array was used and it was allocated on the stack.
719  *
720  * Return: The total number of bytes covered by the iovec array on success
721  *   or a negative error code on error.
722  */
723 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
724                               unsigned long nr_segs, unsigned long fast_segs,
725                               struct iovec *fast_pointer,
726                               struct iovec **ret_pointer)
727 {
728         unsigned long seg;
729         ssize_t ret;
730         struct iovec *iov = fast_pointer;
731
732         /*
733          * SuS says "The readv() function *may* fail if the iovcnt argument
734          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
735          * traditionally returned zero for zero segments, so...
736          */
737         if (nr_segs == 0) {
738                 ret = 0;
739                 goto out;
740         }
741
742         /*
743          * First get the "struct iovec" from user memory and
744          * verify all the pointers
745          */
746         if (nr_segs > UIO_MAXIOV) {
747                 ret = -EINVAL;
748                 goto out;
749         }
750         if (nr_segs > fast_segs) {
751                 iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
752                 if (iov == NULL) {
753                         ret = -ENOMEM;
754                         goto out;
755                 }
756         }
757         if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
758                 ret = -EFAULT;
759                 goto out;
760         }
761
762         /*
763          * According to the Single Unix Specification we should return EINVAL
764          * if an element length is < 0 when cast to ssize_t or if the
765          * total length would overflow the ssize_t return value of the
766          * system call.
767          *
768          * Linux caps all read/write calls to MAX_RW_COUNT, and avoids the
769          * overflow case.
770          */
771         ret = 0;
772         for (seg = 0; seg < nr_segs; seg++) {
773                 void __user *buf = iov[seg].iov_base;
774                 ssize_t len = (ssize_t)iov[seg].iov_len;
775
776                 /* see if we we're about to use an invalid len or if
777                  * it's about to overflow ssize_t */
778                 if (len < 0) {
779                         ret = -EINVAL;
780                         goto out;
781                 }
782                 if (type >= 0
783                     && unlikely(!access_ok(vrfy_dir(type), buf, len))) {
784                         ret = -EFAULT;
785                         goto out;
786                 }
787                 if (len > MAX_RW_COUNT - ret) {
788                         len = MAX_RW_COUNT - ret;
789                         iov[seg].iov_len = len;
790                 }
791                 ret += len;
792         }
793 out:
794         *ret_pointer = iov;
795         return ret;
796 }
797
798 #ifdef CONFIG_COMPAT
799 ssize_t compat_rw_copy_check_uvector(int type,
800                 const struct compat_iovec __user *uvector, unsigned long nr_segs,
801                 unsigned long fast_segs, struct iovec *fast_pointer,
802                 struct iovec **ret_pointer)
803 {
804         compat_ssize_t tot_len;
805         struct iovec *iov = *ret_pointer = fast_pointer;
806         ssize_t ret = 0;
807         int seg;
808
809         /*
810          * SuS says "The readv() function *may* fail if the iovcnt argument
811          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
812          * traditionally returned zero for zero segments, so...
813          */
814         if (nr_segs == 0)
815                 goto out;
816
817         ret = -EINVAL;
818         if (nr_segs > UIO_MAXIOV)
819                 goto out;
820         if (nr_segs > fast_segs) {
821                 ret = -ENOMEM;
822                 iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
823                 if (iov == NULL)
824                         goto out;
825         }
826         *ret_pointer = iov;
827
828         ret = -EFAULT;
829         if (!access_ok(VERIFY_READ, uvector, nr_segs*sizeof(*uvector)))
830                 goto out;
831
832         /*
833          * Single unix specification:
834          * We should -EINVAL if an element length is not >= 0 and fitting an
835          * ssize_t.
836          *
837          * In Linux, the total length is limited to MAX_RW_COUNT, there is
838          * no overflow possibility.
839          */
840         tot_len = 0;
841         ret = -EINVAL;
842         for (seg = 0; seg < nr_segs; seg++) {
843                 compat_uptr_t buf;
844                 compat_ssize_t len;
845
846                 if (__get_user(len, &uvector->iov_len) ||
847                    __get_user(buf, &uvector->iov_base)) {
848                         ret = -EFAULT;
849                         goto out;
850                 }
851                 if (len < 0)    /* size_t not fitting in compat_ssize_t .. */
852                         goto out;
853                 if (type >= 0 &&
854                     !access_ok(vrfy_dir(type), compat_ptr(buf), len)) {
855                         ret = -EFAULT;
856                         goto out;
857                 }
858                 if (len > MAX_RW_COUNT - tot_len)
859                         len = MAX_RW_COUNT - tot_len;
860                 tot_len += len;
861                 iov->iov_base = compat_ptr(buf);
862                 iov->iov_len = (compat_size_t) len;
863                 uvector++;
864                 iov++;
865         }
866         ret = tot_len;
867
868 out:
869         return ret;
870 }
871 #endif
872
873 static ssize_t do_iter_read(struct file *file, struct iov_iter *iter,
874                 loff_t *pos, rwf_t flags)
875 {
876         size_t tot_len;
877         ssize_t ret = 0;
878
879         if (!(file->f_mode & FMODE_READ))
880                 return -EBADF;
881         if (!(file->f_mode & FMODE_CAN_READ))
882                 return -EINVAL;
883
884         tot_len = iov_iter_count(iter);
885         if (!tot_len)
886                 goto out;
887         ret = rw_verify_area(READ, file, pos, tot_len);
888         if (ret < 0)
889                 return ret;
890
891         if (file->f_op->read_iter)
892                 ret = do_iter_readv_writev(file, iter, pos, READ, flags);
893         else
894                 ret = do_loop_readv_writev(file, iter, pos, READ, flags);
895 out:
896         if (ret >= 0)
897                 fsnotify_access(file);
898         return ret;
899 }
900
901 ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
902                 rwf_t flags)
903 {
904         if (!file->f_op->read_iter)
905                 return -EINVAL;
906         return do_iter_read(file, iter, ppos, flags);
907 }
908 EXPORT_SYMBOL(vfs_iter_read);
909
910 static ssize_t do_iter_write(struct file *file, struct iov_iter *iter,
911                 loff_t *pos, rwf_t flags)
912 {
913         size_t tot_len;
914         ssize_t ret = 0;
915
916         if (!(file->f_mode & FMODE_WRITE))
917                 return -EBADF;
918         if (!(file->f_mode & FMODE_CAN_WRITE))
919                 return -EINVAL;
920
921         tot_len = iov_iter_count(iter);
922         if (!tot_len)
923                 return 0;
924         ret = rw_verify_area(WRITE, file, pos, tot_len);
925         if (ret < 0)
926                 return ret;
927
928         if (file->f_op->write_iter)
929                 ret = do_iter_readv_writev(file, iter, pos, WRITE, flags);
930         else
931                 ret = do_loop_readv_writev(file, iter, pos, WRITE, flags);
932         if (ret > 0)
933                 fsnotify_modify(file);
934         return ret;
935 }
936
937 ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
938                 rwf_t flags)
939 {
940         if (!file->f_op->write_iter)
941                 return -EINVAL;
942         return do_iter_write(file, iter, ppos, flags);
943 }
944 EXPORT_SYMBOL(vfs_iter_write);
945
946 ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
947                   unsigned long vlen, loff_t *pos, rwf_t flags)
948 {
949         struct iovec iovstack[UIO_FASTIOV];
950         struct iovec *iov = iovstack;
951         struct iov_iter iter;
952         ssize_t ret;
953
954         ret = import_iovec(READ, vec, vlen, ARRAY_SIZE(iovstack), &iov, &iter);
955         if (ret >= 0) {
956                 ret = do_iter_read(file, &iter, pos, flags);
957                 kfree(iov);
958         }
959
960         return ret;
961 }
962 EXPORT_SYMBOL(vfs_readv);
963
964 ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
965                    unsigned long vlen, loff_t *pos, rwf_t flags)
966 {
967         struct iovec iovstack[UIO_FASTIOV];
968         struct iovec *iov = iovstack;
969         struct iov_iter iter;
970         ssize_t ret;
971
972         ret = import_iovec(WRITE, vec, vlen, ARRAY_SIZE(iovstack), &iov, &iter);
973         if (ret >= 0) {
974                 file_start_write(file);
975                 ret = do_iter_write(file, &iter, pos, flags);
976                 file_end_write(file);
977                 kfree(iov);
978         }
979         return ret;
980 }
981 EXPORT_SYMBOL(vfs_writev);
982
983 static ssize_t do_readv(unsigned long fd, const struct iovec __user *vec,
984                         unsigned long vlen, rwf_t flags)
985 {
986         struct fd f = fdget_pos(fd);
987         ssize_t ret = -EBADF;
988
989         if (f.file) {
990                 loff_t pos = file_pos_read(f.file);
991                 ret = vfs_readv(f.file, vec, vlen, &pos, flags);
992                 if (ret >= 0)
993                         file_pos_write(f.file, pos);
994                 fdput_pos(f);
995         }
996
997         if (ret > 0)
998                 add_rchar(current, ret);
999         inc_syscr(current);
1000         return ret;
1001 }
1002
1003 static ssize_t do_writev(unsigned long fd, const struct iovec __user *vec,
1004                          unsigned long vlen, rwf_t flags)
1005 {
1006         struct fd f = fdget_pos(fd);
1007         ssize_t ret = -EBADF;
1008
1009         if (f.file) {
1010                 loff_t pos = file_pos_read(f.file);
1011                 ret = vfs_writev(f.file, vec, vlen, &pos, flags);
1012                 if (ret >= 0)
1013                         file_pos_write(f.file, pos);
1014                 fdput_pos(f);
1015         }
1016
1017         if (ret > 0)
1018                 add_wchar(current, ret);
1019         inc_syscw(current);
1020         return ret;
1021 }
1022
1023 static inline loff_t pos_from_hilo(unsigned long high, unsigned long low)
1024 {
1025 #define HALF_LONG_BITS (BITS_PER_LONG / 2)
1026         return (((loff_t)high << HALF_LONG_BITS) << HALF_LONG_BITS) | low;
1027 }
1028
1029 static ssize_t do_preadv(unsigned long fd, const struct iovec __user *vec,
1030                          unsigned long vlen, loff_t pos, rwf_t flags)
1031 {
1032         struct fd f;
1033         ssize_t ret = -EBADF;
1034
1035         if (pos < 0)
1036                 return -EINVAL;
1037
1038         f = fdget(fd);
1039         if (f.file) {
1040                 ret = -ESPIPE;
1041                 if (f.file->f_mode & FMODE_PREAD)
1042                         ret = vfs_readv(f.file, vec, vlen, &pos, flags);
1043                 fdput(f);
1044         }
1045
1046         if (ret > 0)
1047                 add_rchar(current, ret);
1048         inc_syscr(current);
1049         return ret;
1050 }
1051
1052 static ssize_t do_pwritev(unsigned long fd, const struct iovec __user *vec,
1053                           unsigned long vlen, loff_t pos, rwf_t flags)
1054 {
1055         struct fd f;
1056         ssize_t ret = -EBADF;
1057
1058         if (pos < 0)
1059                 return -EINVAL;
1060
1061         f = fdget(fd);
1062         if (f.file) {
1063                 ret = -ESPIPE;
1064                 if (f.file->f_mode & FMODE_PWRITE)
1065                         ret = vfs_writev(f.file, vec, vlen, &pos, flags);
1066                 fdput(f);
1067         }
1068
1069         if (ret > 0)
1070                 add_wchar(current, ret);
1071         inc_syscw(current);
1072         return ret;
1073 }
1074
1075 SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
1076                 unsigned long, vlen)
1077 {
1078         return do_readv(fd, vec, vlen, 0);
1079 }
1080
1081 SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *, vec,
1082                 unsigned long, vlen)
1083 {
1084         return do_writev(fd, vec, vlen, 0);
1085 }
1086
1087 SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
1088                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
1089 {
1090         loff_t pos = pos_from_hilo(pos_h, pos_l);
1091
1092         return do_preadv(fd, vec, vlen, pos, 0);
1093 }
1094
1095 SYSCALL_DEFINE6(preadv2, unsigned long, fd, const struct iovec __user *, vec,
1096                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h,
1097                 rwf_t, flags)
1098 {
1099         loff_t pos = pos_from_hilo(pos_h, pos_l);
1100
1101         if (pos == -1)
1102                 return do_readv(fd, vec, vlen, flags);
1103
1104         return do_preadv(fd, vec, vlen, pos, flags);
1105 }
1106
1107 SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
1108                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
1109 {
1110         loff_t pos = pos_from_hilo(pos_h, pos_l);
1111
1112         return do_pwritev(fd, vec, vlen, pos, 0);
1113 }
1114
1115 SYSCALL_DEFINE6(pwritev2, unsigned long, fd, const struct iovec __user *, vec,
1116                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h,
1117                 rwf_t, flags)
1118 {
1119         loff_t pos = pos_from_hilo(pos_h, pos_l);
1120
1121         if (pos == -1)
1122                 return do_writev(fd, vec, vlen, flags);
1123
1124         return do_pwritev(fd, vec, vlen, pos, flags);
1125 }
1126
1127 #ifdef CONFIG_COMPAT
1128 static size_t compat_readv(struct file *file,
1129                            const struct compat_iovec __user *vec,
1130                            unsigned long vlen, loff_t *pos, rwf_t flags)
1131 {
1132         struct iovec iovstack[UIO_FASTIOV];
1133         struct iovec *iov = iovstack;
1134         struct iov_iter iter;
1135         ssize_t ret;
1136
1137         ret = compat_import_iovec(READ, vec, vlen, UIO_FASTIOV, &iov, &iter);
1138         if (ret >= 0) {
1139                 ret = do_iter_read(file, &iter, pos, flags);
1140                 kfree(iov);
1141         }
1142         if (ret > 0)
1143                 add_rchar(current, ret);
1144         inc_syscr(current);
1145         return ret;
1146 }
1147
1148 static size_t do_compat_readv(compat_ulong_t fd,
1149                                  const struct compat_iovec __user *vec,
1150                                  compat_ulong_t vlen, rwf_t flags)
1151 {
1152         struct fd f = fdget_pos(fd);
1153         ssize_t ret;
1154         loff_t pos;
1155
1156         if (!f.file)
1157                 return -EBADF;
1158         pos = f.file->f_pos;
1159         ret = compat_readv(f.file, vec, vlen, &pos, flags);
1160         if (ret >= 0)
1161                 f.file->f_pos = pos;
1162         fdput_pos(f);
1163         return ret;
1164
1165 }
1166
1167 COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
1168                 const struct compat_iovec __user *,vec,
1169                 compat_ulong_t, vlen)
1170 {
1171         return do_compat_readv(fd, vec, vlen, 0);
1172 }
1173
1174 static long do_compat_preadv64(unsigned long fd,
1175                                   const struct compat_iovec __user *vec,
1176                                   unsigned long vlen, loff_t pos, rwf_t flags)
1177 {
1178         struct fd f;
1179         ssize_t ret;
1180
1181         if (pos < 0)
1182                 return -EINVAL;
1183         f = fdget(fd);
1184         if (!f.file)
1185                 return -EBADF;
1186         ret = -ESPIPE;
1187         if (f.file->f_mode & FMODE_PREAD)
1188                 ret = compat_readv(f.file, vec, vlen, &pos, flags);
1189         fdput(f);
1190         return ret;
1191 }
1192
1193 #ifdef __ARCH_WANT_COMPAT_SYS_PREADV64
1194 COMPAT_SYSCALL_DEFINE4(preadv64, unsigned long, fd,
1195                 const struct compat_iovec __user *,vec,
1196                 unsigned long, vlen, loff_t, pos)
1197 {
1198         return do_compat_preadv64(fd, vec, vlen, pos, 0);
1199 }
1200 #endif
1201
1202 COMPAT_SYSCALL_DEFINE5(preadv, compat_ulong_t, fd,
1203                 const struct compat_iovec __user *,vec,
1204                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high)
1205 {
1206         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1207
1208         return do_compat_preadv64(fd, vec, vlen, pos, 0);
1209 }
1210
1211 #ifdef __ARCH_WANT_COMPAT_SYS_PREADV64V2
1212 COMPAT_SYSCALL_DEFINE5(preadv64v2, unsigned long, fd,
1213                 const struct compat_iovec __user *,vec,
1214                 unsigned long, vlen, loff_t, pos, rwf_t, flags)
1215 {
1216         return do_compat_preadv64(fd, vec, vlen, pos, flags);
1217 }
1218 #endif
1219
1220 COMPAT_SYSCALL_DEFINE6(preadv2, compat_ulong_t, fd,
1221                 const struct compat_iovec __user *,vec,
1222                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high,
1223                 rwf_t, flags)
1224 {
1225         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1226
1227         if (pos == -1)
1228                 return do_compat_readv(fd, vec, vlen, flags);
1229
1230         return do_compat_preadv64(fd, vec, vlen, pos, flags);
1231 }
1232
1233 static size_t compat_writev(struct file *file,
1234                             const struct compat_iovec __user *vec,
1235                             unsigned long vlen, loff_t *pos, rwf_t flags)
1236 {
1237         struct iovec iovstack[UIO_FASTIOV];
1238         struct iovec *iov = iovstack;
1239         struct iov_iter iter;
1240         ssize_t ret;
1241
1242         ret = compat_import_iovec(WRITE, vec, vlen, UIO_FASTIOV, &iov, &iter);
1243         if (ret >= 0) {
1244                 file_start_write(file);
1245                 ret = do_iter_write(file, &iter, pos, flags);
1246                 file_end_write(file);
1247                 kfree(iov);
1248         }
1249         if (ret > 0)
1250                 add_wchar(current, ret);
1251         inc_syscw(current);
1252         return ret;
1253 }
1254
1255 static size_t do_compat_writev(compat_ulong_t fd,
1256                                   const struct compat_iovec __user* vec,
1257                                   compat_ulong_t vlen, rwf_t flags)
1258 {
1259         struct fd f = fdget_pos(fd);
1260         ssize_t ret;
1261         loff_t pos;
1262
1263         if (!f.file)
1264                 return -EBADF;
1265         pos = f.file->f_pos;
1266         ret = compat_writev(f.file, vec, vlen, &pos, flags);
1267         if (ret >= 0)
1268                 f.file->f_pos = pos;
1269         fdput_pos(f);
1270         return ret;
1271 }
1272
1273 COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
1274                 const struct compat_iovec __user *, vec,
1275                 compat_ulong_t, vlen)
1276 {
1277         return do_compat_writev(fd, vec, vlen, 0);
1278 }
1279
1280 static long do_compat_pwritev64(unsigned long fd,
1281                                    const struct compat_iovec __user *vec,
1282                                    unsigned long vlen, loff_t pos, rwf_t flags)
1283 {
1284         struct fd f;
1285         ssize_t ret;
1286
1287         if (pos < 0)
1288                 return -EINVAL;
1289         f = fdget(fd);
1290         if (!f.file)
1291                 return -EBADF;
1292         ret = -ESPIPE;
1293         if (f.file->f_mode & FMODE_PWRITE)
1294                 ret = compat_writev(f.file, vec, vlen, &pos, flags);
1295         fdput(f);
1296         return ret;
1297 }
1298
1299 #ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64
1300 COMPAT_SYSCALL_DEFINE4(pwritev64, unsigned long, fd,
1301                 const struct compat_iovec __user *,vec,
1302                 unsigned long, vlen, loff_t, pos)
1303 {
1304         return do_compat_pwritev64(fd, vec, vlen, pos, 0);
1305 }
1306 #endif
1307
1308 COMPAT_SYSCALL_DEFINE5(pwritev, compat_ulong_t, fd,
1309                 const struct compat_iovec __user *,vec,
1310                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high)
1311 {
1312         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1313
1314         return do_compat_pwritev64(fd, vec, vlen, pos, 0);
1315 }
1316
1317 #ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64V2
1318 COMPAT_SYSCALL_DEFINE5(pwritev64v2, unsigned long, fd,
1319                 const struct compat_iovec __user *,vec,
1320                 unsigned long, vlen, loff_t, pos, rwf_t, flags)
1321 {
1322         return do_compat_pwritev64(fd, vec, vlen, pos, flags);
1323 }
1324 #endif
1325
1326 COMPAT_SYSCALL_DEFINE6(pwritev2, compat_ulong_t, fd,
1327                 const struct compat_iovec __user *,vec,
1328                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high, rwf_t, flags)
1329 {
1330         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1331
1332         if (pos == -1)
1333                 return do_compat_writev(fd, vec, vlen, flags);
1334
1335         return do_compat_pwritev64(fd, vec, vlen, pos, flags);
1336 }
1337
1338 #endif
1339
1340 static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
1341                            size_t count, loff_t max)
1342 {
1343         struct fd in, out;
1344         struct inode *in_inode, *out_inode;
1345         loff_t pos;
1346         loff_t out_pos;
1347         ssize_t retval;
1348         int fl;
1349
1350         /*
1351          * Get input file, and verify that it is ok..
1352          */
1353         retval = -EBADF;
1354         in = fdget(in_fd);
1355         if (!in.file)
1356                 goto out;
1357         if (!(in.file->f_mode & FMODE_READ))
1358                 goto fput_in;
1359         retval = -ESPIPE;
1360         if (!ppos) {
1361                 pos = in.file->f_pos;
1362         } else {
1363                 pos = *ppos;
1364                 if (!(in.file->f_mode & FMODE_PREAD))
1365                         goto fput_in;
1366         }
1367         retval = rw_verify_area(READ, in.file, &pos, count);
1368         if (retval < 0)
1369                 goto fput_in;
1370         if (count > MAX_RW_COUNT)
1371                 count =  MAX_RW_COUNT;
1372
1373         /*
1374          * Get output file, and verify that it is ok..
1375          */
1376         retval = -EBADF;
1377         out = fdget(out_fd);
1378         if (!out.file)
1379                 goto fput_in;
1380         if (!(out.file->f_mode & FMODE_WRITE))
1381                 goto fput_out;
1382         retval = -EINVAL;
1383         in_inode = file_inode(in.file);
1384         out_inode = file_inode(out.file);
1385         out_pos = out.file->f_pos;
1386         retval = rw_verify_area(WRITE, out.file, &out_pos, count);
1387         if (retval < 0)
1388                 goto fput_out;
1389
1390         if (!max)
1391                 max = min(in_inode->i_sb->s_maxbytes, out_inode->i_sb->s_maxbytes);
1392
1393         if (unlikely(pos + count > max)) {
1394                 retval = -EOVERFLOW;
1395                 if (pos >= max)
1396                         goto fput_out;
1397                 count = max - pos;
1398         }
1399
1400         fl = 0;
1401 #if 0
1402         /*
1403          * We need to debate whether we can enable this or not. The
1404          * man page documents EAGAIN return for the output at least,
1405          * and the application is arguably buggy if it doesn't expect
1406          * EAGAIN on a non-blocking file descriptor.
1407          */
1408         if (in.file->f_flags & O_NONBLOCK)
1409                 fl = SPLICE_F_NONBLOCK;
1410 #endif
1411         file_start_write(out.file);
1412         retval = do_splice_direct(in.file, &pos, out.file, &out_pos, count, fl);
1413         file_end_write(out.file);
1414
1415         if (retval > 0) {
1416                 add_rchar(current, retval);
1417                 add_wchar(current, retval);
1418                 fsnotify_access(in.file);
1419                 fsnotify_modify(out.file);
1420                 out.file->f_pos = out_pos;
1421                 if (ppos)
1422                         *ppos = pos;
1423                 else
1424                         in.file->f_pos = pos;
1425         }
1426
1427         inc_syscr(current);
1428         inc_syscw(current);
1429         if (pos > max)
1430                 retval = -EOVERFLOW;
1431
1432 fput_out:
1433         fdput(out);
1434 fput_in:
1435         fdput(in);
1436 out:
1437         return retval;
1438 }
1439
1440 SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd, off_t __user *, offset, size_t, count)
1441 {
1442         loff_t pos;
1443         off_t off;
1444         ssize_t ret;
1445
1446         if (offset) {
1447                 if (unlikely(get_user(off, offset)))
1448                         return -EFAULT;
1449                 pos = off;
1450                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
1451                 if (unlikely(put_user(pos, offset)))
1452                         return -EFAULT;
1453                 return ret;
1454         }
1455
1456         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1457 }
1458
1459 SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, loff_t __user *, offset, size_t, count)
1460 {
1461         loff_t pos;
1462         ssize_t ret;
1463
1464         if (offset) {
1465                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1466                         return -EFAULT;
1467                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1468                 if (unlikely(put_user(pos, offset)))
1469                         return -EFAULT;
1470                 return ret;
1471         }
1472
1473         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1474 }
1475
1476 #ifdef CONFIG_COMPAT
1477 COMPAT_SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd,
1478                 compat_off_t __user *, offset, compat_size_t, count)
1479 {
1480         loff_t pos;
1481         off_t off;
1482         ssize_t ret;
1483
1484         if (offset) {
1485                 if (unlikely(get_user(off, offset)))
1486                         return -EFAULT;
1487                 pos = off;
1488                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
1489                 if (unlikely(put_user(pos, offset)))
1490                         return -EFAULT;
1491                 return ret;
1492         }
1493
1494         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1495 }
1496
1497 COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd,
1498                 compat_loff_t __user *, offset, compat_size_t, count)
1499 {
1500         loff_t pos;
1501         ssize_t ret;
1502
1503         if (offset) {
1504                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1505                         return -EFAULT;
1506                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1507                 if (unlikely(put_user(pos, offset)))
1508                         return -EFAULT;
1509                 return ret;
1510         }
1511
1512         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1513 }
1514 #endif
1515
1516 /*
1517  * copy_file_range() differs from regular file read and write in that it
1518  * specifically allows return partial success.  When it does so is up to
1519  * the copy_file_range method.
1520  */
1521 ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,
1522                             struct file *file_out, loff_t pos_out,
1523                             size_t len, unsigned int flags)
1524 {
1525         struct inode *inode_in = file_inode(file_in);
1526         struct inode *inode_out = file_inode(file_out);
1527         ssize_t ret;
1528
1529         if (flags != 0)
1530                 return -EINVAL;
1531
1532         if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode))
1533                 return -EISDIR;
1534         if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode))
1535                 return -EINVAL;
1536
1537         ret = rw_verify_area(READ, file_in, &pos_in, len);
1538         if (unlikely(ret))
1539                 return ret;
1540
1541         ret = rw_verify_area(WRITE, file_out, &pos_out, len);
1542         if (unlikely(ret))
1543                 return ret;
1544
1545         if (!(file_in->f_mode & FMODE_READ) ||
1546             !(file_out->f_mode & FMODE_WRITE) ||
1547             (file_out->f_flags & O_APPEND))
1548                 return -EBADF;
1549
1550         /* this could be relaxed once a method supports cross-fs copies */
1551         if (inode_in->i_sb != inode_out->i_sb)
1552                 return -EXDEV;
1553
1554         if (len == 0)
1555                 return 0;
1556
1557         file_start_write(file_out);
1558
1559         /*
1560          * Try cloning first, this is supported by more file systems, and
1561          * more efficient if both clone and copy are supported (e.g. NFS).
1562          */
1563         if (file_in->f_op->clone_file_range) {
1564                 ret = file_in->f_op->clone_file_range(file_in, pos_in,
1565                                 file_out, pos_out, len);
1566                 if (ret == 0) {
1567                         ret = len;
1568                         goto done;
1569                 }
1570         }
1571
1572         if (file_out->f_op->copy_file_range) {
1573                 ret = file_out->f_op->copy_file_range(file_in, pos_in, file_out,
1574                                                       pos_out, len, flags);
1575                 if (ret != -EOPNOTSUPP)
1576                         goto done;
1577         }
1578
1579         ret = do_splice_direct(file_in, &pos_in, file_out, &pos_out,
1580                         len > MAX_RW_COUNT ? MAX_RW_COUNT : len, 0);
1581
1582 done:
1583         if (ret > 0) {
1584                 fsnotify_access(file_in);
1585                 add_rchar(current, ret);
1586                 fsnotify_modify(file_out);
1587                 add_wchar(current, ret);
1588         }
1589
1590         inc_syscr(current);
1591         inc_syscw(current);
1592
1593         file_end_write(file_out);
1594
1595         return ret;
1596 }
1597 EXPORT_SYMBOL(vfs_copy_file_range);
1598
1599 SYSCALL_DEFINE6(copy_file_range, int, fd_in, loff_t __user *, off_in,
1600                 int, fd_out, loff_t __user *, off_out,
1601                 size_t, len, unsigned int, flags)
1602 {
1603         loff_t pos_in;
1604         loff_t pos_out;
1605         struct fd f_in;
1606         struct fd f_out;
1607         ssize_t ret = -EBADF;
1608
1609         f_in = fdget(fd_in);
1610         if (!f_in.file)
1611                 goto out2;
1612
1613         f_out = fdget(fd_out);
1614         if (!f_out.file)
1615                 goto out1;
1616
1617         ret = -EFAULT;
1618         if (off_in) {
1619                 if (copy_from_user(&pos_in, off_in, sizeof(loff_t)))
1620                         goto out;
1621         } else {
1622                 pos_in = f_in.file->f_pos;
1623         }
1624
1625         if (off_out) {
1626                 if (copy_from_user(&pos_out, off_out, sizeof(loff_t)))
1627                         goto out;
1628         } else {
1629                 pos_out = f_out.file->f_pos;
1630         }
1631
1632         ret = vfs_copy_file_range(f_in.file, pos_in, f_out.file, pos_out, len,
1633                                   flags);
1634         if (ret > 0) {
1635                 pos_in += ret;
1636                 pos_out += ret;
1637
1638                 if (off_in) {
1639                         if (copy_to_user(off_in, &pos_in, sizeof(loff_t)))
1640                                 ret = -EFAULT;
1641                 } else {
1642                         f_in.file->f_pos = pos_in;
1643                 }
1644
1645                 if (off_out) {
1646                         if (copy_to_user(off_out, &pos_out, sizeof(loff_t)))
1647                                 ret = -EFAULT;
1648                 } else {
1649                         f_out.file->f_pos = pos_out;
1650                 }
1651         }
1652
1653 out:
1654         fdput(f_out);
1655 out1:
1656         fdput(f_in);
1657 out2:
1658         return ret;
1659 }
1660
1661 static int clone_verify_area(struct file *file, loff_t pos, u64 len, bool write)
1662 {
1663         struct inode *inode = file_inode(file);
1664
1665         if (unlikely(pos < 0))
1666                 return -EINVAL;
1667
1668          if (unlikely((loff_t) (pos + len) < 0))
1669                 return -EINVAL;
1670
1671         if (unlikely(inode->i_flctx && mandatory_lock(inode))) {
1672                 loff_t end = len ? pos + len - 1 : OFFSET_MAX;
1673                 int retval;
1674
1675                 retval = locks_mandatory_area(inode, file, pos, end,
1676                                 write ? F_WRLCK : F_RDLCK);
1677                 if (retval < 0)
1678                         return retval;
1679         }
1680
1681         return security_file_permission(file, write ? MAY_WRITE : MAY_READ);
1682 }
1683
1684 /*
1685  * Check that the two inodes are eligible for cloning, the ranges make
1686  * sense, and then flush all dirty data.  Caller must ensure that the
1687  * inodes have been locked against any other modifications.
1688  *
1689  * Returns: 0 for "nothing to clone", 1 for "something to clone", or
1690  * the usual negative error code.
1691  */
1692 int vfs_clone_file_prep_inodes(struct inode *inode_in, loff_t pos_in,
1693                                struct inode *inode_out, loff_t pos_out,
1694                                u64 *len, bool is_dedupe)
1695 {
1696         loff_t bs = inode_out->i_sb->s_blocksize;
1697         loff_t blen;
1698         loff_t isize;
1699         bool same_inode = (inode_in == inode_out);
1700         int ret;
1701
1702         /* Don't touch certain kinds of inodes */
1703         if (IS_IMMUTABLE(inode_out))
1704                 return -EPERM;
1705
1706         if (IS_SWAPFILE(inode_in) || IS_SWAPFILE(inode_out))
1707                 return -ETXTBSY;
1708
1709         /* Don't reflink dirs, pipes, sockets... */
1710         if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode))
1711                 return -EISDIR;
1712         if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode))
1713                 return -EINVAL;
1714
1715         /* Are we going all the way to the end? */
1716         isize = i_size_read(inode_in);
1717         if (isize == 0)
1718                 return 0;
1719
1720         /* Zero length dedupe exits immediately; reflink goes to EOF. */
1721         if (*len == 0) {
1722                 if (is_dedupe || pos_in == isize)
1723                         return 0;
1724                 if (pos_in > isize)
1725                         return -EINVAL;
1726                 *len = isize - pos_in;
1727         }
1728
1729         /* Ensure offsets don't wrap and the input is inside i_size */
1730         if (pos_in + *len < pos_in || pos_out + *len < pos_out ||
1731             pos_in + *len > isize)
1732                 return -EINVAL;
1733
1734         /* Don't allow dedupe past EOF in the dest file */
1735         if (is_dedupe) {
1736                 loff_t  disize;
1737
1738                 disize = i_size_read(inode_out);
1739                 if (pos_out >= disize || pos_out + *len > disize)
1740                         return -EINVAL;
1741         }
1742
1743         /* If we're linking to EOF, continue to the block boundary. */
1744         if (pos_in + *len == isize)
1745                 blen = ALIGN(isize, bs) - pos_in;
1746         else
1747                 blen = *len;
1748
1749         /* Only reflink if we're aligned to block boundaries */
1750         if (!IS_ALIGNED(pos_in, bs) || !IS_ALIGNED(pos_in + blen, bs) ||
1751             !IS_ALIGNED(pos_out, bs) || !IS_ALIGNED(pos_out + blen, bs))
1752                 return -EINVAL;
1753
1754         /* Don't allow overlapped reflink within the same file */
1755         if (same_inode) {
1756                 if (pos_out + blen > pos_in && pos_out < pos_in + blen)
1757                         return -EINVAL;
1758         }
1759
1760         /* Wait for the completion of any pending IOs on both files */
1761         inode_dio_wait(inode_in);
1762         if (!same_inode)
1763                 inode_dio_wait(inode_out);
1764
1765         ret = filemap_write_and_wait_range(inode_in->i_mapping,
1766                         pos_in, pos_in + *len - 1);
1767         if (ret)
1768                 return ret;
1769
1770         ret = filemap_write_and_wait_range(inode_out->i_mapping,
1771                         pos_out, pos_out + *len - 1);
1772         if (ret)
1773                 return ret;
1774
1775         /*
1776          * Check that the extents are the same.
1777          */
1778         if (is_dedupe) {
1779                 bool            is_same = false;
1780
1781                 ret = vfs_dedupe_file_range_compare(inode_in, pos_in,
1782                                 inode_out, pos_out, *len, &is_same);
1783                 if (ret)
1784                         return ret;
1785                 if (!is_same)
1786                         return -EBADE;
1787         }
1788
1789         return 1;
1790 }
1791 EXPORT_SYMBOL(vfs_clone_file_prep_inodes);
1792
1793 int vfs_clone_file_range(struct file *file_in, loff_t pos_in,
1794                 struct file *file_out, loff_t pos_out, u64 len)
1795 {
1796         struct inode *inode_in = file_inode(file_in);
1797         struct inode *inode_out = file_inode(file_out);
1798         int ret;
1799
1800         if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode))
1801                 return -EISDIR;
1802         if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode))
1803                 return -EINVAL;
1804
1805         /*
1806          * FICLONE/FICLONERANGE ioctls enforce that src and dest files are on
1807          * the same mount. Practically, they only need to be on the same file
1808          * system.
1809          */
1810         if (inode_in->i_sb != inode_out->i_sb)
1811                 return -EXDEV;
1812
1813         if (!(file_in->f_mode & FMODE_READ) ||
1814             !(file_out->f_mode & FMODE_WRITE) ||
1815             (file_out->f_flags & O_APPEND))
1816                 return -EBADF;
1817
1818         if (!file_in->f_op->clone_file_range)
1819                 return -EOPNOTSUPP;
1820
1821         ret = clone_verify_area(file_in, pos_in, len, false);
1822         if (ret)
1823                 return ret;
1824
1825         ret = clone_verify_area(file_out, pos_out, len, true);
1826         if (ret)
1827                 return ret;
1828
1829         if (pos_in + len > i_size_read(inode_in))
1830                 return -EINVAL;
1831
1832         ret = file_in->f_op->clone_file_range(file_in, pos_in,
1833                         file_out, pos_out, len);
1834         if (!ret) {
1835                 fsnotify_access(file_in);
1836                 fsnotify_modify(file_out);
1837         }
1838
1839         return ret;
1840 }
1841 EXPORT_SYMBOL(vfs_clone_file_range);
1842
1843 /*
1844  * Read a page's worth of file data into the page cache.  Return the page
1845  * locked.
1846  */
1847 static struct page *vfs_dedupe_get_page(struct inode *inode, loff_t offset)
1848 {
1849         struct address_space *mapping;
1850         struct page *page;
1851         pgoff_t n;
1852
1853         n = offset >> PAGE_SHIFT;
1854         mapping = inode->i_mapping;
1855         page = read_mapping_page(mapping, n, NULL);
1856         if (IS_ERR(page))
1857                 return page;
1858         if (!PageUptodate(page)) {
1859                 put_page(page);
1860                 return ERR_PTR(-EIO);
1861         }
1862         lock_page(page);
1863         return page;
1864 }
1865
1866 /*
1867  * Compare extents of two files to see if they are the same.
1868  * Caller must have locked both inodes to prevent write races.
1869  */
1870 int vfs_dedupe_file_range_compare(struct inode *src, loff_t srcoff,
1871                                   struct inode *dest, loff_t destoff,
1872                                   loff_t len, bool *is_same)
1873 {
1874         loff_t src_poff;
1875         loff_t dest_poff;
1876         void *src_addr;
1877         void *dest_addr;
1878         struct page *src_page;
1879         struct page *dest_page;
1880         loff_t cmp_len;
1881         bool same;
1882         int error;
1883
1884         error = -EINVAL;
1885         same = true;
1886         while (len) {
1887                 src_poff = srcoff & (PAGE_SIZE - 1);
1888                 dest_poff = destoff & (PAGE_SIZE - 1);
1889                 cmp_len = min(PAGE_SIZE - src_poff,
1890                               PAGE_SIZE - dest_poff);
1891                 cmp_len = min(cmp_len, len);
1892                 if (cmp_len <= 0)
1893                         goto out_error;
1894
1895                 src_page = vfs_dedupe_get_page(src, srcoff);
1896                 if (IS_ERR(src_page)) {
1897                         error = PTR_ERR(src_page);
1898                         goto out_error;
1899                 }
1900                 dest_page = vfs_dedupe_get_page(dest, destoff);
1901                 if (IS_ERR(dest_page)) {
1902                         error = PTR_ERR(dest_page);
1903                         unlock_page(src_page);
1904                         put_page(src_page);
1905                         goto out_error;
1906                 }
1907                 src_addr = kmap_atomic(src_page);
1908                 dest_addr = kmap_atomic(dest_page);
1909
1910                 flush_dcache_page(src_page);
1911                 flush_dcache_page(dest_page);
1912
1913                 if (memcmp(src_addr + src_poff, dest_addr + dest_poff, cmp_len))
1914                         same = false;
1915
1916                 kunmap_atomic(dest_addr);
1917                 kunmap_atomic(src_addr);
1918                 unlock_page(dest_page);
1919                 unlock_page(src_page);
1920                 put_page(dest_page);
1921                 put_page(src_page);
1922
1923                 if (!same)
1924                         break;
1925
1926                 srcoff += cmp_len;
1927                 destoff += cmp_len;
1928                 len -= cmp_len;
1929         }
1930
1931         *is_same = same;
1932         return 0;
1933
1934 out_error:
1935         return error;
1936 }
1937 EXPORT_SYMBOL(vfs_dedupe_file_range_compare);
1938
1939 int vfs_dedupe_file_range(struct file *file, struct file_dedupe_range *same)
1940 {
1941         struct file_dedupe_range_info *info;
1942         struct inode *src = file_inode(file);
1943         u64 off;
1944         u64 len;
1945         int i;
1946         int ret;
1947         bool is_admin = capable(CAP_SYS_ADMIN);
1948         u16 count = same->dest_count;
1949         struct file *dst_file;
1950         loff_t dst_off;
1951         ssize_t deduped;
1952
1953         if (!(file->f_mode & FMODE_READ))
1954                 return -EINVAL;
1955
1956         if (same->reserved1 || same->reserved2)
1957                 return -EINVAL;
1958
1959         off = same->src_offset;
1960         len = same->src_length;
1961
1962         ret = -EISDIR;
1963         if (S_ISDIR(src->i_mode))
1964                 goto out;
1965
1966         ret = -EINVAL;
1967         if (!S_ISREG(src->i_mode))
1968                 goto out;
1969
1970         ret = clone_verify_area(file, off, len, false);
1971         if (ret < 0)
1972                 goto out;
1973         ret = 0;
1974
1975         if (off + len > i_size_read(src))
1976                 return -EINVAL;
1977
1978         /* pre-format output fields to sane values */
1979         for (i = 0; i < count; i++) {
1980                 same->info[i].bytes_deduped = 0ULL;
1981                 same->info[i].status = FILE_DEDUPE_RANGE_SAME;
1982         }
1983
1984         for (i = 0, info = same->info; i < count; i++, info++) {
1985                 struct inode *dst;
1986                 struct fd dst_fd = fdget(info->dest_fd);
1987
1988                 dst_file = dst_fd.file;
1989                 if (!dst_file) {
1990                         info->status = -EBADF;
1991                         goto next_loop;
1992                 }
1993                 dst = file_inode(dst_file);
1994
1995                 ret = mnt_want_write_file(dst_file);
1996                 if (ret) {
1997                         info->status = ret;
1998                         goto next_loop;
1999                 }
2000
2001                 dst_off = info->dest_offset;
2002                 ret = clone_verify_area(dst_file, dst_off, len, true);
2003                 if (ret < 0) {
2004                         info->status = ret;
2005                         goto next_file;
2006                 }
2007                 ret = 0;
2008
2009                 if (info->reserved) {
2010                         info->status = -EINVAL;
2011                 } else if (!(is_admin || (dst_file->f_mode & FMODE_WRITE))) {
2012                         info->status = -EINVAL;
2013                 } else if (file->f_path.mnt != dst_file->f_path.mnt) {
2014                         info->status = -EXDEV;
2015                 } else if (S_ISDIR(dst->i_mode)) {
2016                         info->status = -EISDIR;
2017                 } else if (dst_file->f_op->dedupe_file_range == NULL) {
2018                         info->status = -EINVAL;
2019                 } else {
2020                         deduped = dst_file->f_op->dedupe_file_range(file, off,
2021                                                         len, dst_file,
2022                                                         info->dest_offset);
2023                         if (deduped == -EBADE)
2024                                 info->status = FILE_DEDUPE_RANGE_DIFFERS;
2025                         else if (deduped < 0)
2026                                 info->status = deduped;
2027                         else
2028                                 info->bytes_deduped += deduped;
2029                 }
2030
2031 next_file:
2032                 mnt_drop_write_file(dst_file);
2033 next_loop:
2034                 fdput(dst_fd);
2035
2036                 if (fatal_signal_pending(current))
2037                         goto out;
2038         }
2039
2040 out:
2041         return ret;
2042 }
2043 EXPORT_SYMBOL(vfs_dedupe_file_range);