Merge tag 'staging-4.14-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh...
[linux-2.6-microblaze.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 ((unsigned long long)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 ((unsigned long long)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
417 ssize_t kernel_read(struct file *file, void *buf, size_t count, loff_t *pos)
418 {
419         mm_segment_t old_fs;
420         ssize_t result;
421
422         old_fs = get_fs();
423         set_fs(get_ds());
424         /* The cast to a user pointer is valid due to the set_fs() */
425         result = vfs_read(file, (void __user *)buf, count, pos);
426         set_fs(old_fs);
427         return result;
428 }
429 EXPORT_SYMBOL(kernel_read);
430
431 ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
432 {
433         ssize_t ret;
434
435         if (!(file->f_mode & FMODE_READ))
436                 return -EBADF;
437         if (!(file->f_mode & FMODE_CAN_READ))
438                 return -EINVAL;
439         if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
440                 return -EFAULT;
441
442         ret = rw_verify_area(READ, file, pos, count);
443         if (!ret) {
444                 if (count > MAX_RW_COUNT)
445                         count =  MAX_RW_COUNT;
446                 ret = __vfs_read(file, buf, count, pos);
447                 if (ret > 0) {
448                         fsnotify_access(file);
449                         add_rchar(current, ret);
450                 }
451                 inc_syscr(current);
452         }
453
454         return ret;
455 }
456
457 static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
458 {
459         struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
460         struct kiocb kiocb;
461         struct iov_iter iter;
462         ssize_t ret;
463
464         init_sync_kiocb(&kiocb, filp);
465         kiocb.ki_pos = *ppos;
466         iov_iter_init(&iter, WRITE, &iov, 1, len);
467
468         ret = call_write_iter(filp, &kiocb, &iter);
469         BUG_ON(ret == -EIOCBQUEUED);
470         if (ret > 0)
471                 *ppos = kiocb.ki_pos;
472         return ret;
473 }
474
475 ssize_t __vfs_write(struct file *file, const char __user *p, size_t count,
476                     loff_t *pos)
477 {
478         if (file->f_op->write)
479                 return file->f_op->write(file, p, count, pos);
480         else if (file->f_op->write_iter)
481                 return new_sync_write(file, p, count, pos);
482         else
483                 return -EINVAL;
484 }
485
486 ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_t *pos)
487 {
488         mm_segment_t old_fs;
489         const char __user *p;
490         ssize_t ret;
491
492         if (!(file->f_mode & FMODE_CAN_WRITE))
493                 return -EINVAL;
494
495         old_fs = get_fs();
496         set_fs(get_ds());
497         p = (__force const char __user *)buf;
498         if (count > MAX_RW_COUNT)
499                 count =  MAX_RW_COUNT;
500         ret = __vfs_write(file, p, count, pos);
501         set_fs(old_fs);
502         if (ret > 0) {
503                 fsnotify_modify(file);
504                 add_wchar(current, ret);
505         }
506         inc_syscw(current);
507         return ret;
508 }
509 EXPORT_SYMBOL(__kernel_write);
510
511 ssize_t kernel_write(struct file *file, const void *buf, size_t count,
512                             loff_t *pos)
513 {
514         mm_segment_t old_fs;
515         ssize_t res;
516
517         old_fs = get_fs();
518         set_fs(get_ds());
519         /* The cast to a user pointer is valid due to the set_fs() */
520         res = vfs_write(file, (__force const char __user *)buf, count, pos);
521         set_fs(old_fs);
522
523         return res;
524 }
525 EXPORT_SYMBOL(kernel_write);
526
527 ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
528 {
529         ssize_t ret;
530
531         if (!(file->f_mode & FMODE_WRITE))
532                 return -EBADF;
533         if (!(file->f_mode & FMODE_CAN_WRITE))
534                 return -EINVAL;
535         if (unlikely(!access_ok(VERIFY_READ, buf, count)))
536                 return -EFAULT;
537
538         ret = rw_verify_area(WRITE, file, pos, count);
539         if (!ret) {
540                 if (count > MAX_RW_COUNT)
541                         count =  MAX_RW_COUNT;
542                 file_start_write(file);
543                 ret = __vfs_write(file, buf, count, pos);
544                 if (ret > 0) {
545                         fsnotify_modify(file);
546                         add_wchar(current, ret);
547                 }
548                 inc_syscw(current);
549                 file_end_write(file);
550         }
551
552         return ret;
553 }
554
555 static inline loff_t file_pos_read(struct file *file)
556 {
557         return file->f_pos;
558 }
559
560 static inline void file_pos_write(struct file *file, loff_t pos)
561 {
562         file->f_pos = pos;
563 }
564
565 SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
566 {
567         struct fd f = fdget_pos(fd);
568         ssize_t ret = -EBADF;
569
570         if (f.file) {
571                 loff_t pos = file_pos_read(f.file);
572                 ret = vfs_read(f.file, buf, count, &pos);
573                 if (ret >= 0)
574                         file_pos_write(f.file, pos);
575                 fdput_pos(f);
576         }
577         return ret;
578 }
579
580 SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
581                 size_t, count)
582 {
583         struct fd f = fdget_pos(fd);
584         ssize_t ret = -EBADF;
585
586         if (f.file) {
587                 loff_t pos = file_pos_read(f.file);
588                 ret = vfs_write(f.file, buf, count, &pos);
589                 if (ret >= 0)
590                         file_pos_write(f.file, pos);
591                 fdput_pos(f);
592         }
593
594         return ret;
595 }
596
597 SYSCALL_DEFINE4(pread64, unsigned int, fd, char __user *, buf,
598                         size_t, count, loff_t, pos)
599 {
600         struct fd f;
601         ssize_t ret = -EBADF;
602
603         if (pos < 0)
604                 return -EINVAL;
605
606         f = fdget(fd);
607         if (f.file) {
608                 ret = -ESPIPE;
609                 if (f.file->f_mode & FMODE_PREAD)
610                         ret = vfs_read(f.file, buf, count, &pos);
611                 fdput(f);
612         }
613
614         return ret;
615 }
616
617 SYSCALL_DEFINE4(pwrite64, unsigned int, fd, const char __user *, buf,
618                          size_t, count, loff_t, pos)
619 {
620         struct fd f;
621         ssize_t ret = -EBADF;
622
623         if (pos < 0)
624                 return -EINVAL;
625
626         f = fdget(fd);
627         if (f.file) {
628                 ret = -ESPIPE;
629                 if (f.file->f_mode & FMODE_PWRITE)  
630                         ret = vfs_write(f.file, buf, count, &pos);
631                 fdput(f);
632         }
633
634         return ret;
635 }
636
637 /*
638  * Reduce an iovec's length in-place.  Return the resulting number of segments
639  */
640 unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to)
641 {
642         unsigned long seg = 0;
643         size_t len = 0;
644
645         while (seg < nr_segs) {
646                 seg++;
647                 if (len + iov->iov_len >= to) {
648                         iov->iov_len = to - len;
649                         break;
650                 }
651                 len += iov->iov_len;
652                 iov++;
653         }
654         return seg;
655 }
656 EXPORT_SYMBOL(iov_shorten);
657
658 static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,
659                 loff_t *ppos, int type, rwf_t flags)
660 {
661         struct kiocb kiocb;
662         ssize_t ret;
663
664         init_sync_kiocb(&kiocb, filp);
665         ret = kiocb_set_rw_flags(&kiocb, flags);
666         if (ret)
667                 return ret;
668         kiocb.ki_pos = *ppos;
669
670         if (type == READ)
671                 ret = call_read_iter(filp, &kiocb, iter);
672         else
673                 ret = call_write_iter(filp, &kiocb, iter);
674         BUG_ON(ret == -EIOCBQUEUED);
675         *ppos = kiocb.ki_pos;
676         return ret;
677 }
678
679 /* Do it by hand, with file-ops */
680 static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,
681                 loff_t *ppos, int type, rwf_t flags)
682 {
683         ssize_t ret = 0;
684
685         if (flags & ~RWF_HIPRI)
686                 return -EOPNOTSUPP;
687
688         while (iov_iter_count(iter)) {
689                 struct iovec iovec = iov_iter_iovec(iter);
690                 ssize_t nr;
691
692                 if (type == READ) {
693                         nr = filp->f_op->read(filp, iovec.iov_base,
694                                               iovec.iov_len, ppos);
695                 } else {
696                         nr = filp->f_op->write(filp, iovec.iov_base,
697                                                iovec.iov_len, ppos);
698                 }
699
700                 if (nr < 0) {
701                         if (!ret)
702                                 ret = nr;
703                         break;
704                 }
705                 ret += nr;
706                 if (nr != iovec.iov_len)
707                         break;
708                 iov_iter_advance(iter, nr);
709         }
710
711         return ret;
712 }
713
714 /* A write operation does a read from user space and vice versa */
715 #define vrfy_dir(type) ((type) == READ ? VERIFY_WRITE : VERIFY_READ)
716
717 /**
718  * rw_copy_check_uvector() - Copy an array of &struct iovec from userspace
719  *     into the kernel and check that it is valid.
720  *
721  * @type: One of %CHECK_IOVEC_ONLY, %READ, or %WRITE.
722  * @uvector: Pointer to the userspace array.
723  * @nr_segs: Number of elements in userspace array.
724  * @fast_segs: Number of elements in @fast_pointer.
725  * @fast_pointer: Pointer to (usually small on-stack) kernel array.
726  * @ret_pointer: (output parameter) Pointer to a variable that will point to
727  *     either @fast_pointer, a newly allocated kernel array, or NULL,
728  *     depending on which array was used.
729  *
730  * This function copies an array of &struct iovec of @nr_segs from
731  * userspace into the kernel and checks that each element is valid (e.g.
732  * it does not point to a kernel address or cause overflow by being too
733  * large, etc.).
734  *
735  * As an optimization, the caller may provide a pointer to a small
736  * on-stack array in @fast_pointer, typically %UIO_FASTIOV elements long
737  * (the size of this array, or 0 if unused, should be given in @fast_segs).
738  *
739  * @ret_pointer will always point to the array that was used, so the
740  * caller must take care not to call kfree() on it e.g. in case the
741  * @fast_pointer array was used and it was allocated on the stack.
742  *
743  * Return: The total number of bytes covered by the iovec array on success
744  *   or a negative error code on error.
745  */
746 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
747                               unsigned long nr_segs, unsigned long fast_segs,
748                               struct iovec *fast_pointer,
749                               struct iovec **ret_pointer)
750 {
751         unsigned long seg;
752         ssize_t ret;
753         struct iovec *iov = fast_pointer;
754
755         /*
756          * SuS says "The readv() function *may* fail if the iovcnt argument
757          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
758          * traditionally returned zero for zero segments, so...
759          */
760         if (nr_segs == 0) {
761                 ret = 0;
762                 goto out;
763         }
764
765         /*
766          * First get the "struct iovec" from user memory and
767          * verify all the pointers
768          */
769         if (nr_segs > UIO_MAXIOV) {
770                 ret = -EINVAL;
771                 goto out;
772         }
773         if (nr_segs > fast_segs) {
774                 iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
775                 if (iov == NULL) {
776                         ret = -ENOMEM;
777                         goto out;
778                 }
779         }
780         if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
781                 ret = -EFAULT;
782                 goto out;
783         }
784
785         /*
786          * According to the Single Unix Specification we should return EINVAL
787          * if an element length is < 0 when cast to ssize_t or if the
788          * total length would overflow the ssize_t return value of the
789          * system call.
790          *
791          * Linux caps all read/write calls to MAX_RW_COUNT, and avoids the
792          * overflow case.
793          */
794         ret = 0;
795         for (seg = 0; seg < nr_segs; seg++) {
796                 void __user *buf = iov[seg].iov_base;
797                 ssize_t len = (ssize_t)iov[seg].iov_len;
798
799                 /* see if we we're about to use an invalid len or if
800                  * it's about to overflow ssize_t */
801                 if (len < 0) {
802                         ret = -EINVAL;
803                         goto out;
804                 }
805                 if (type >= 0
806                     && unlikely(!access_ok(vrfy_dir(type), buf, len))) {
807                         ret = -EFAULT;
808                         goto out;
809                 }
810                 if (len > MAX_RW_COUNT - ret) {
811                         len = MAX_RW_COUNT - ret;
812                         iov[seg].iov_len = len;
813                 }
814                 ret += len;
815         }
816 out:
817         *ret_pointer = iov;
818         return ret;
819 }
820
821 #ifdef CONFIG_COMPAT
822 ssize_t compat_rw_copy_check_uvector(int type,
823                 const struct compat_iovec __user *uvector, unsigned long nr_segs,
824                 unsigned long fast_segs, struct iovec *fast_pointer,
825                 struct iovec **ret_pointer)
826 {
827         compat_ssize_t tot_len;
828         struct iovec *iov = *ret_pointer = fast_pointer;
829         ssize_t ret = 0;
830         int seg;
831
832         /*
833          * SuS says "The readv() function *may* fail if the iovcnt argument
834          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
835          * traditionally returned zero for zero segments, so...
836          */
837         if (nr_segs == 0)
838                 goto out;
839
840         ret = -EINVAL;
841         if (nr_segs > UIO_MAXIOV)
842                 goto out;
843         if (nr_segs > fast_segs) {
844                 ret = -ENOMEM;
845                 iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
846                 if (iov == NULL)
847                         goto out;
848         }
849         *ret_pointer = iov;
850
851         ret = -EFAULT;
852         if (!access_ok(VERIFY_READ, uvector, nr_segs*sizeof(*uvector)))
853                 goto out;
854
855         /*
856          * Single unix specification:
857          * We should -EINVAL if an element length is not >= 0 and fitting an
858          * ssize_t.
859          *
860          * In Linux, the total length is limited to MAX_RW_COUNT, there is
861          * no overflow possibility.
862          */
863         tot_len = 0;
864         ret = -EINVAL;
865         for (seg = 0; seg < nr_segs; seg++) {
866                 compat_uptr_t buf;
867                 compat_ssize_t len;
868
869                 if (__get_user(len, &uvector->iov_len) ||
870                    __get_user(buf, &uvector->iov_base)) {
871                         ret = -EFAULT;
872                         goto out;
873                 }
874                 if (len < 0)    /* size_t not fitting in compat_ssize_t .. */
875                         goto out;
876                 if (type >= 0 &&
877                     !access_ok(vrfy_dir(type), compat_ptr(buf), len)) {
878                         ret = -EFAULT;
879                         goto out;
880                 }
881                 if (len > MAX_RW_COUNT - tot_len)
882                         len = MAX_RW_COUNT - tot_len;
883                 tot_len += len;
884                 iov->iov_base = compat_ptr(buf);
885                 iov->iov_len = (compat_size_t) len;
886                 uvector++;
887                 iov++;
888         }
889         ret = tot_len;
890
891 out:
892         return ret;
893 }
894 #endif
895
896 static ssize_t do_iter_read(struct file *file, struct iov_iter *iter,
897                 loff_t *pos, rwf_t flags)
898 {
899         size_t tot_len;
900         ssize_t ret = 0;
901
902         if (!(file->f_mode & FMODE_READ))
903                 return -EBADF;
904         if (!(file->f_mode & FMODE_CAN_READ))
905                 return -EINVAL;
906
907         tot_len = iov_iter_count(iter);
908         if (!tot_len)
909                 goto out;
910         ret = rw_verify_area(READ, file, pos, tot_len);
911         if (ret < 0)
912                 return ret;
913
914         if (file->f_op->read_iter)
915                 ret = do_iter_readv_writev(file, iter, pos, READ, flags);
916         else
917                 ret = do_loop_readv_writev(file, iter, pos, READ, flags);
918 out:
919         if (ret >= 0)
920                 fsnotify_access(file);
921         return ret;
922 }
923
924 ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
925                 rwf_t flags)
926 {
927         if (!file->f_op->read_iter)
928                 return -EINVAL;
929         return do_iter_read(file, iter, ppos, flags);
930 }
931 EXPORT_SYMBOL(vfs_iter_read);
932
933 static ssize_t do_iter_write(struct file *file, struct iov_iter *iter,
934                 loff_t *pos, rwf_t flags)
935 {
936         size_t tot_len;
937         ssize_t ret = 0;
938
939         if (!(file->f_mode & FMODE_WRITE))
940                 return -EBADF;
941         if (!(file->f_mode & FMODE_CAN_WRITE))
942                 return -EINVAL;
943
944         tot_len = iov_iter_count(iter);
945         if (!tot_len)
946                 return 0;
947         ret = rw_verify_area(WRITE, file, pos, tot_len);
948         if (ret < 0)
949                 return ret;
950
951         if (file->f_op->write_iter)
952                 ret = do_iter_readv_writev(file, iter, pos, WRITE, flags);
953         else
954                 ret = do_loop_readv_writev(file, iter, pos, WRITE, flags);
955         if (ret > 0)
956                 fsnotify_modify(file);
957         return ret;
958 }
959
960 ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
961                 rwf_t flags)
962 {
963         if (!file->f_op->write_iter)
964                 return -EINVAL;
965         return do_iter_write(file, iter, ppos, flags);
966 }
967 EXPORT_SYMBOL(vfs_iter_write);
968
969 ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
970                   unsigned long vlen, loff_t *pos, rwf_t flags)
971 {
972         struct iovec iovstack[UIO_FASTIOV];
973         struct iovec *iov = iovstack;
974         struct iov_iter iter;
975         ssize_t ret;
976
977         ret = import_iovec(READ, vec, vlen, ARRAY_SIZE(iovstack), &iov, &iter);
978         if (ret >= 0) {
979                 ret = do_iter_read(file, &iter, pos, flags);
980                 kfree(iov);
981         }
982
983         return ret;
984 }
985
986 static ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
987                    unsigned long vlen, loff_t *pos, rwf_t flags)
988 {
989         struct iovec iovstack[UIO_FASTIOV];
990         struct iovec *iov = iovstack;
991         struct iov_iter iter;
992         ssize_t ret;
993
994         ret = import_iovec(WRITE, vec, vlen, ARRAY_SIZE(iovstack), &iov, &iter);
995         if (ret >= 0) {
996                 file_start_write(file);
997                 ret = do_iter_write(file, &iter, pos, flags);
998                 file_end_write(file);
999                 kfree(iov);
1000         }
1001         return ret;
1002 }
1003
1004 static ssize_t do_readv(unsigned long fd, const struct iovec __user *vec,
1005                         unsigned long vlen, rwf_t flags)
1006 {
1007         struct fd f = fdget_pos(fd);
1008         ssize_t ret = -EBADF;
1009
1010         if (f.file) {
1011                 loff_t pos = file_pos_read(f.file);
1012                 ret = vfs_readv(f.file, vec, vlen, &pos, flags);
1013                 if (ret >= 0)
1014                         file_pos_write(f.file, pos);
1015                 fdput_pos(f);
1016         }
1017
1018         if (ret > 0)
1019                 add_rchar(current, ret);
1020         inc_syscr(current);
1021         return ret;
1022 }
1023
1024 static ssize_t do_writev(unsigned long fd, const struct iovec __user *vec,
1025                          unsigned long vlen, rwf_t flags)
1026 {
1027         struct fd f = fdget_pos(fd);
1028         ssize_t ret = -EBADF;
1029
1030         if (f.file) {
1031                 loff_t pos = file_pos_read(f.file);
1032                 ret = vfs_writev(f.file, vec, vlen, &pos, flags);
1033                 if (ret >= 0)
1034                         file_pos_write(f.file, pos);
1035                 fdput_pos(f);
1036         }
1037
1038         if (ret > 0)
1039                 add_wchar(current, ret);
1040         inc_syscw(current);
1041         return ret;
1042 }
1043
1044 static inline loff_t pos_from_hilo(unsigned long high, unsigned long low)
1045 {
1046 #define HALF_LONG_BITS (BITS_PER_LONG / 2)
1047         return (((loff_t)high << HALF_LONG_BITS) << HALF_LONG_BITS) | low;
1048 }
1049
1050 static ssize_t do_preadv(unsigned long fd, const struct iovec __user *vec,
1051                          unsigned long vlen, loff_t pos, rwf_t flags)
1052 {
1053         struct fd f;
1054         ssize_t ret = -EBADF;
1055
1056         if (pos < 0)
1057                 return -EINVAL;
1058
1059         f = fdget(fd);
1060         if (f.file) {
1061                 ret = -ESPIPE;
1062                 if (f.file->f_mode & FMODE_PREAD)
1063                         ret = vfs_readv(f.file, vec, vlen, &pos, flags);
1064                 fdput(f);
1065         }
1066
1067         if (ret > 0)
1068                 add_rchar(current, ret);
1069         inc_syscr(current);
1070         return ret;
1071 }
1072
1073 static ssize_t do_pwritev(unsigned long fd, const struct iovec __user *vec,
1074                           unsigned long vlen, loff_t pos, rwf_t flags)
1075 {
1076         struct fd f;
1077         ssize_t ret = -EBADF;
1078
1079         if (pos < 0)
1080                 return -EINVAL;
1081
1082         f = fdget(fd);
1083         if (f.file) {
1084                 ret = -ESPIPE;
1085                 if (f.file->f_mode & FMODE_PWRITE)
1086                         ret = vfs_writev(f.file, vec, vlen, &pos, flags);
1087                 fdput(f);
1088         }
1089
1090         if (ret > 0)
1091                 add_wchar(current, ret);
1092         inc_syscw(current);
1093         return ret;
1094 }
1095
1096 SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
1097                 unsigned long, vlen)
1098 {
1099         return do_readv(fd, vec, vlen, 0);
1100 }
1101
1102 SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *, vec,
1103                 unsigned long, vlen)
1104 {
1105         return do_writev(fd, vec, vlen, 0);
1106 }
1107
1108 SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
1109                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
1110 {
1111         loff_t pos = pos_from_hilo(pos_h, pos_l);
1112
1113         return do_preadv(fd, vec, vlen, pos, 0);
1114 }
1115
1116 SYSCALL_DEFINE6(preadv2, unsigned long, fd, const struct iovec __user *, vec,
1117                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h,
1118                 rwf_t, flags)
1119 {
1120         loff_t pos = pos_from_hilo(pos_h, pos_l);
1121
1122         if (pos == -1)
1123                 return do_readv(fd, vec, vlen, flags);
1124
1125         return do_preadv(fd, vec, vlen, pos, flags);
1126 }
1127
1128 SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
1129                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
1130 {
1131         loff_t pos = pos_from_hilo(pos_h, pos_l);
1132
1133         return do_pwritev(fd, vec, vlen, pos, 0);
1134 }
1135
1136 SYSCALL_DEFINE6(pwritev2, unsigned long, fd, const struct iovec __user *, vec,
1137                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h,
1138                 rwf_t, flags)
1139 {
1140         loff_t pos = pos_from_hilo(pos_h, pos_l);
1141
1142         if (pos == -1)
1143                 return do_writev(fd, vec, vlen, flags);
1144
1145         return do_pwritev(fd, vec, vlen, pos, flags);
1146 }
1147
1148 #ifdef CONFIG_COMPAT
1149 static size_t compat_readv(struct file *file,
1150                            const struct compat_iovec __user *vec,
1151                            unsigned long vlen, loff_t *pos, rwf_t flags)
1152 {
1153         struct iovec iovstack[UIO_FASTIOV];
1154         struct iovec *iov = iovstack;
1155         struct iov_iter iter;
1156         ssize_t ret;
1157
1158         ret = compat_import_iovec(READ, vec, vlen, UIO_FASTIOV, &iov, &iter);
1159         if (ret >= 0) {
1160                 ret = do_iter_read(file, &iter, pos, flags);
1161                 kfree(iov);
1162         }
1163         if (ret > 0)
1164                 add_rchar(current, ret);
1165         inc_syscr(current);
1166         return ret;
1167 }
1168
1169 static size_t do_compat_readv(compat_ulong_t fd,
1170                                  const struct compat_iovec __user *vec,
1171                                  compat_ulong_t vlen, rwf_t flags)
1172 {
1173         struct fd f = fdget_pos(fd);
1174         ssize_t ret;
1175         loff_t pos;
1176
1177         if (!f.file)
1178                 return -EBADF;
1179         pos = f.file->f_pos;
1180         ret = compat_readv(f.file, vec, vlen, &pos, flags);
1181         if (ret >= 0)
1182                 f.file->f_pos = pos;
1183         fdput_pos(f);
1184         return ret;
1185
1186 }
1187
1188 COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
1189                 const struct compat_iovec __user *,vec,
1190                 compat_ulong_t, vlen)
1191 {
1192         return do_compat_readv(fd, vec, vlen, 0);
1193 }
1194
1195 static long do_compat_preadv64(unsigned long fd,
1196                                   const struct compat_iovec __user *vec,
1197                                   unsigned long vlen, loff_t pos, rwf_t flags)
1198 {
1199         struct fd f;
1200         ssize_t ret;
1201
1202         if (pos < 0)
1203                 return -EINVAL;
1204         f = fdget(fd);
1205         if (!f.file)
1206                 return -EBADF;
1207         ret = -ESPIPE;
1208         if (f.file->f_mode & FMODE_PREAD)
1209                 ret = compat_readv(f.file, vec, vlen, &pos, flags);
1210         fdput(f);
1211         return ret;
1212 }
1213
1214 #ifdef __ARCH_WANT_COMPAT_SYS_PREADV64
1215 COMPAT_SYSCALL_DEFINE4(preadv64, unsigned long, fd,
1216                 const struct compat_iovec __user *,vec,
1217                 unsigned long, vlen, loff_t, pos)
1218 {
1219         return do_compat_preadv64(fd, vec, vlen, pos, 0);
1220 }
1221 #endif
1222
1223 COMPAT_SYSCALL_DEFINE5(preadv, compat_ulong_t, fd,
1224                 const struct compat_iovec __user *,vec,
1225                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high)
1226 {
1227         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1228
1229         return do_compat_preadv64(fd, vec, vlen, pos, 0);
1230 }
1231
1232 #ifdef __ARCH_WANT_COMPAT_SYS_PREADV64V2
1233 COMPAT_SYSCALL_DEFINE5(preadv64v2, unsigned long, fd,
1234                 const struct compat_iovec __user *,vec,
1235                 unsigned long, vlen, loff_t, pos, rwf_t, flags)
1236 {
1237         return do_compat_preadv64(fd, vec, vlen, pos, flags);
1238 }
1239 #endif
1240
1241 COMPAT_SYSCALL_DEFINE6(preadv2, compat_ulong_t, fd,
1242                 const struct compat_iovec __user *,vec,
1243                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high,
1244                 rwf_t, flags)
1245 {
1246         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1247
1248         if (pos == -1)
1249                 return do_compat_readv(fd, vec, vlen, flags);
1250
1251         return do_compat_preadv64(fd, vec, vlen, pos, flags);
1252 }
1253
1254 static size_t compat_writev(struct file *file,
1255                             const struct compat_iovec __user *vec,
1256                             unsigned long vlen, loff_t *pos, rwf_t flags)
1257 {
1258         struct iovec iovstack[UIO_FASTIOV];
1259         struct iovec *iov = iovstack;
1260         struct iov_iter iter;
1261         ssize_t ret;
1262
1263         ret = compat_import_iovec(WRITE, vec, vlen, UIO_FASTIOV, &iov, &iter);
1264         if (ret >= 0) {
1265                 file_start_write(file);
1266                 ret = do_iter_write(file, &iter, pos, flags);
1267                 file_end_write(file);
1268                 kfree(iov);
1269         }
1270         if (ret > 0)
1271                 add_wchar(current, ret);
1272         inc_syscw(current);
1273         return ret;
1274 }
1275
1276 static size_t do_compat_writev(compat_ulong_t fd,
1277                                   const struct compat_iovec __user* vec,
1278                                   compat_ulong_t vlen, rwf_t flags)
1279 {
1280         struct fd f = fdget_pos(fd);
1281         ssize_t ret;
1282         loff_t pos;
1283
1284         if (!f.file)
1285                 return -EBADF;
1286         pos = f.file->f_pos;
1287         ret = compat_writev(f.file, vec, vlen, &pos, flags);
1288         if (ret >= 0)
1289                 f.file->f_pos = pos;
1290         fdput_pos(f);
1291         return ret;
1292 }
1293
1294 COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
1295                 const struct compat_iovec __user *, vec,
1296                 compat_ulong_t, vlen)
1297 {
1298         return do_compat_writev(fd, vec, vlen, 0);
1299 }
1300
1301 static long do_compat_pwritev64(unsigned long fd,
1302                                    const struct compat_iovec __user *vec,
1303                                    unsigned long vlen, loff_t pos, rwf_t flags)
1304 {
1305         struct fd f;
1306         ssize_t ret;
1307
1308         if (pos < 0)
1309                 return -EINVAL;
1310         f = fdget(fd);
1311         if (!f.file)
1312                 return -EBADF;
1313         ret = -ESPIPE;
1314         if (f.file->f_mode & FMODE_PWRITE)
1315                 ret = compat_writev(f.file, vec, vlen, &pos, flags);
1316         fdput(f);
1317         return ret;
1318 }
1319
1320 #ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64
1321 COMPAT_SYSCALL_DEFINE4(pwritev64, unsigned long, fd,
1322                 const struct compat_iovec __user *,vec,
1323                 unsigned long, vlen, loff_t, pos)
1324 {
1325         return do_compat_pwritev64(fd, vec, vlen, pos, 0);
1326 }
1327 #endif
1328
1329 COMPAT_SYSCALL_DEFINE5(pwritev, compat_ulong_t, fd,
1330                 const struct compat_iovec __user *,vec,
1331                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high)
1332 {
1333         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1334
1335         return do_compat_pwritev64(fd, vec, vlen, pos, 0);
1336 }
1337
1338 #ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64V2
1339 COMPAT_SYSCALL_DEFINE5(pwritev64v2, unsigned long, fd,
1340                 const struct compat_iovec __user *,vec,
1341                 unsigned long, vlen, loff_t, pos, rwf_t, flags)
1342 {
1343         return do_compat_pwritev64(fd, vec, vlen, pos, flags);
1344 }
1345 #endif
1346
1347 COMPAT_SYSCALL_DEFINE6(pwritev2, compat_ulong_t, fd,
1348                 const struct compat_iovec __user *,vec,
1349                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high, rwf_t, flags)
1350 {
1351         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1352
1353         if (pos == -1)
1354                 return do_compat_writev(fd, vec, vlen, flags);
1355
1356         return do_compat_pwritev64(fd, vec, vlen, pos, flags);
1357 }
1358
1359 #endif
1360
1361 static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
1362                            size_t count, loff_t max)
1363 {
1364         struct fd in, out;
1365         struct inode *in_inode, *out_inode;
1366         loff_t pos;
1367         loff_t out_pos;
1368         ssize_t retval;
1369         int fl;
1370
1371         /*
1372          * Get input file, and verify that it is ok..
1373          */
1374         retval = -EBADF;
1375         in = fdget(in_fd);
1376         if (!in.file)
1377                 goto out;
1378         if (!(in.file->f_mode & FMODE_READ))
1379                 goto fput_in;
1380         retval = -ESPIPE;
1381         if (!ppos) {
1382                 pos = in.file->f_pos;
1383         } else {
1384                 pos = *ppos;
1385                 if (!(in.file->f_mode & FMODE_PREAD))
1386                         goto fput_in;
1387         }
1388         retval = rw_verify_area(READ, in.file, &pos, count);
1389         if (retval < 0)
1390                 goto fput_in;
1391         if (count > MAX_RW_COUNT)
1392                 count =  MAX_RW_COUNT;
1393
1394         /*
1395          * Get output file, and verify that it is ok..
1396          */
1397         retval = -EBADF;
1398         out = fdget(out_fd);
1399         if (!out.file)
1400                 goto fput_in;
1401         if (!(out.file->f_mode & FMODE_WRITE))
1402                 goto fput_out;
1403         retval = -EINVAL;
1404         in_inode = file_inode(in.file);
1405         out_inode = file_inode(out.file);
1406         out_pos = out.file->f_pos;
1407         retval = rw_verify_area(WRITE, out.file, &out_pos, count);
1408         if (retval < 0)
1409                 goto fput_out;
1410
1411         if (!max)
1412                 max = min(in_inode->i_sb->s_maxbytes, out_inode->i_sb->s_maxbytes);
1413
1414         if (unlikely(pos + count > max)) {
1415                 retval = -EOVERFLOW;
1416                 if (pos >= max)
1417                         goto fput_out;
1418                 count = max - pos;
1419         }
1420
1421         fl = 0;
1422 #if 0
1423         /*
1424          * We need to debate whether we can enable this or not. The
1425          * man page documents EAGAIN return for the output at least,
1426          * and the application is arguably buggy if it doesn't expect
1427          * EAGAIN on a non-blocking file descriptor.
1428          */
1429         if (in.file->f_flags & O_NONBLOCK)
1430                 fl = SPLICE_F_NONBLOCK;
1431 #endif
1432         file_start_write(out.file);
1433         retval = do_splice_direct(in.file, &pos, out.file, &out_pos, count, fl);
1434         file_end_write(out.file);
1435
1436         if (retval > 0) {
1437                 add_rchar(current, retval);
1438                 add_wchar(current, retval);
1439                 fsnotify_access(in.file);
1440                 fsnotify_modify(out.file);
1441                 out.file->f_pos = out_pos;
1442                 if (ppos)
1443                         *ppos = pos;
1444                 else
1445                         in.file->f_pos = pos;
1446         }
1447
1448         inc_syscr(current);
1449         inc_syscw(current);
1450         if (pos > max)
1451                 retval = -EOVERFLOW;
1452
1453 fput_out:
1454         fdput(out);
1455 fput_in:
1456         fdput(in);
1457 out:
1458         return retval;
1459 }
1460
1461 SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd, off_t __user *, offset, size_t, count)
1462 {
1463         loff_t pos;
1464         off_t off;
1465         ssize_t ret;
1466
1467         if (offset) {
1468                 if (unlikely(get_user(off, offset)))
1469                         return -EFAULT;
1470                 pos = off;
1471                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
1472                 if (unlikely(put_user(pos, offset)))
1473                         return -EFAULT;
1474                 return ret;
1475         }
1476
1477         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1478 }
1479
1480 SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, loff_t __user *, offset, size_t, count)
1481 {
1482         loff_t pos;
1483         ssize_t ret;
1484
1485         if (offset) {
1486                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1487                         return -EFAULT;
1488                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
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 #ifdef CONFIG_COMPAT
1498 COMPAT_SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd,
1499                 compat_off_t __user *, offset, compat_size_t, count)
1500 {
1501         loff_t pos;
1502         off_t off;
1503         ssize_t ret;
1504
1505         if (offset) {
1506                 if (unlikely(get_user(off, offset)))
1507                         return -EFAULT;
1508                 pos = off;
1509                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
1510                 if (unlikely(put_user(pos, offset)))
1511                         return -EFAULT;
1512                 return ret;
1513         }
1514
1515         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1516 }
1517
1518 COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd,
1519                 compat_loff_t __user *, offset, compat_size_t, count)
1520 {
1521         loff_t pos;
1522         ssize_t ret;
1523
1524         if (offset) {
1525                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1526                         return -EFAULT;
1527                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1528                 if (unlikely(put_user(pos, offset)))
1529                         return -EFAULT;
1530                 return ret;
1531         }
1532
1533         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1534 }
1535 #endif
1536
1537 /*
1538  * copy_file_range() differs from regular file read and write in that it
1539  * specifically allows return partial success.  When it does so is up to
1540  * the copy_file_range method.
1541  */
1542 ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,
1543                             struct file *file_out, loff_t pos_out,
1544                             size_t len, unsigned int flags)
1545 {
1546         struct inode *inode_in = file_inode(file_in);
1547         struct inode *inode_out = file_inode(file_out);
1548         ssize_t ret;
1549
1550         if (flags != 0)
1551                 return -EINVAL;
1552
1553         if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode))
1554                 return -EISDIR;
1555         if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode))
1556                 return -EINVAL;
1557
1558         ret = rw_verify_area(READ, file_in, &pos_in, len);
1559         if (unlikely(ret))
1560                 return ret;
1561
1562         ret = rw_verify_area(WRITE, file_out, &pos_out, len);
1563         if (unlikely(ret))
1564                 return ret;
1565
1566         if (!(file_in->f_mode & FMODE_READ) ||
1567             !(file_out->f_mode & FMODE_WRITE) ||
1568             (file_out->f_flags & O_APPEND))
1569                 return -EBADF;
1570
1571         /* this could be relaxed once a method supports cross-fs copies */
1572         if (inode_in->i_sb != inode_out->i_sb)
1573                 return -EXDEV;
1574
1575         if (len == 0)
1576                 return 0;
1577
1578         file_start_write(file_out);
1579
1580         /*
1581          * Try cloning first, this is supported by more file systems, and
1582          * more efficient if both clone and copy are supported (e.g. NFS).
1583          */
1584         if (file_in->f_op->clone_file_range) {
1585                 ret = file_in->f_op->clone_file_range(file_in, pos_in,
1586                                 file_out, pos_out, len);
1587                 if (ret == 0) {
1588                         ret = len;
1589                         goto done;
1590                 }
1591         }
1592
1593         if (file_out->f_op->copy_file_range) {
1594                 ret = file_out->f_op->copy_file_range(file_in, pos_in, file_out,
1595                                                       pos_out, len, flags);
1596                 if (ret != -EOPNOTSUPP)
1597                         goto done;
1598         }
1599
1600         ret = do_splice_direct(file_in, &pos_in, file_out, &pos_out,
1601                         len > MAX_RW_COUNT ? MAX_RW_COUNT : len, 0);
1602
1603 done:
1604         if (ret > 0) {
1605                 fsnotify_access(file_in);
1606                 add_rchar(current, ret);
1607                 fsnotify_modify(file_out);
1608                 add_wchar(current, ret);
1609         }
1610
1611         inc_syscr(current);
1612         inc_syscw(current);
1613
1614         file_end_write(file_out);
1615
1616         return ret;
1617 }
1618 EXPORT_SYMBOL(vfs_copy_file_range);
1619
1620 SYSCALL_DEFINE6(copy_file_range, int, fd_in, loff_t __user *, off_in,
1621                 int, fd_out, loff_t __user *, off_out,
1622                 size_t, len, unsigned int, flags)
1623 {
1624         loff_t pos_in;
1625         loff_t pos_out;
1626         struct fd f_in;
1627         struct fd f_out;
1628         ssize_t ret = -EBADF;
1629
1630         f_in = fdget(fd_in);
1631         if (!f_in.file)
1632                 goto out2;
1633
1634         f_out = fdget(fd_out);
1635         if (!f_out.file)
1636                 goto out1;
1637
1638         ret = -EFAULT;
1639         if (off_in) {
1640                 if (copy_from_user(&pos_in, off_in, sizeof(loff_t)))
1641                         goto out;
1642         } else {
1643                 pos_in = f_in.file->f_pos;
1644         }
1645
1646         if (off_out) {
1647                 if (copy_from_user(&pos_out, off_out, sizeof(loff_t)))
1648                         goto out;
1649         } else {
1650                 pos_out = f_out.file->f_pos;
1651         }
1652
1653         ret = vfs_copy_file_range(f_in.file, pos_in, f_out.file, pos_out, len,
1654                                   flags);
1655         if (ret > 0) {
1656                 pos_in += ret;
1657                 pos_out += ret;
1658
1659                 if (off_in) {
1660                         if (copy_to_user(off_in, &pos_in, sizeof(loff_t)))
1661                                 ret = -EFAULT;
1662                 } else {
1663                         f_in.file->f_pos = pos_in;
1664                 }
1665
1666                 if (off_out) {
1667                         if (copy_to_user(off_out, &pos_out, sizeof(loff_t)))
1668                                 ret = -EFAULT;
1669                 } else {
1670                         f_out.file->f_pos = pos_out;
1671                 }
1672         }
1673
1674 out:
1675         fdput(f_out);
1676 out1:
1677         fdput(f_in);
1678 out2:
1679         return ret;
1680 }
1681
1682 static int clone_verify_area(struct file *file, loff_t pos, u64 len, bool write)
1683 {
1684         struct inode *inode = file_inode(file);
1685
1686         if (unlikely(pos < 0))
1687                 return -EINVAL;
1688
1689          if (unlikely((loff_t) (pos + len) < 0))
1690                 return -EINVAL;
1691
1692         if (unlikely(inode->i_flctx && mandatory_lock(inode))) {
1693                 loff_t end = len ? pos + len - 1 : OFFSET_MAX;
1694                 int retval;
1695
1696                 retval = locks_mandatory_area(inode, file, pos, end,
1697                                 write ? F_WRLCK : F_RDLCK);
1698                 if (retval < 0)
1699                         return retval;
1700         }
1701
1702         return security_file_permission(file, write ? MAY_WRITE : MAY_READ);
1703 }
1704
1705 /*
1706  * Check that the two inodes are eligible for cloning, the ranges make
1707  * sense, and then flush all dirty data.  Caller must ensure that the
1708  * inodes have been locked against any other modifications.
1709  *
1710  * Returns: 0 for "nothing to clone", 1 for "something to clone", or
1711  * the usual negative error code.
1712  */
1713 int vfs_clone_file_prep_inodes(struct inode *inode_in, loff_t pos_in,
1714                                struct inode *inode_out, loff_t pos_out,
1715                                u64 *len, bool is_dedupe)
1716 {
1717         loff_t bs = inode_out->i_sb->s_blocksize;
1718         loff_t blen;
1719         loff_t isize;
1720         bool same_inode = (inode_in == inode_out);
1721         int ret;
1722
1723         /* Don't touch certain kinds of inodes */
1724         if (IS_IMMUTABLE(inode_out))
1725                 return -EPERM;
1726
1727         if (IS_SWAPFILE(inode_in) || IS_SWAPFILE(inode_out))
1728                 return -ETXTBSY;
1729
1730         /* Don't reflink dirs, pipes, sockets... */
1731         if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode))
1732                 return -EISDIR;
1733         if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode))
1734                 return -EINVAL;
1735
1736         /* Are we going all the way to the end? */
1737         isize = i_size_read(inode_in);
1738         if (isize == 0)
1739                 return 0;
1740
1741         /* Zero length dedupe exits immediately; reflink goes to EOF. */
1742         if (*len == 0) {
1743                 if (is_dedupe || pos_in == isize)
1744                         return 0;
1745                 if (pos_in > isize)
1746                         return -EINVAL;
1747                 *len = isize - pos_in;
1748         }
1749
1750         /* Ensure offsets don't wrap and the input is inside i_size */
1751         if (pos_in + *len < pos_in || pos_out + *len < pos_out ||
1752             pos_in + *len > isize)
1753                 return -EINVAL;
1754
1755         /* Don't allow dedupe past EOF in the dest file */
1756         if (is_dedupe) {
1757                 loff_t  disize;
1758
1759                 disize = i_size_read(inode_out);
1760                 if (pos_out >= disize || pos_out + *len > disize)
1761                         return -EINVAL;
1762         }
1763
1764         /* If we're linking to EOF, continue to the block boundary. */
1765         if (pos_in + *len == isize)
1766                 blen = ALIGN(isize, bs) - pos_in;
1767         else
1768                 blen = *len;
1769
1770         /* Only reflink if we're aligned to block boundaries */
1771         if (!IS_ALIGNED(pos_in, bs) || !IS_ALIGNED(pos_in + blen, bs) ||
1772             !IS_ALIGNED(pos_out, bs) || !IS_ALIGNED(pos_out + blen, bs))
1773                 return -EINVAL;
1774
1775         /* Don't allow overlapped reflink within the same file */
1776         if (same_inode) {
1777                 if (pos_out + blen > pos_in && pos_out < pos_in + blen)
1778                         return -EINVAL;
1779         }
1780
1781         /* Wait for the completion of any pending IOs on both files */
1782         inode_dio_wait(inode_in);
1783         if (!same_inode)
1784                 inode_dio_wait(inode_out);
1785
1786         ret = filemap_write_and_wait_range(inode_in->i_mapping,
1787                         pos_in, pos_in + *len - 1);
1788         if (ret)
1789                 return ret;
1790
1791         ret = filemap_write_and_wait_range(inode_out->i_mapping,
1792                         pos_out, pos_out + *len - 1);
1793         if (ret)
1794                 return ret;
1795
1796         /*
1797          * Check that the extents are the same.
1798          */
1799         if (is_dedupe) {
1800                 bool            is_same = false;
1801
1802                 ret = vfs_dedupe_file_range_compare(inode_in, pos_in,
1803                                 inode_out, pos_out, *len, &is_same);
1804                 if (ret)
1805                         return ret;
1806                 if (!is_same)
1807                         return -EBADE;
1808         }
1809
1810         return 1;
1811 }
1812 EXPORT_SYMBOL(vfs_clone_file_prep_inodes);
1813
1814 int vfs_clone_file_range(struct file *file_in, loff_t pos_in,
1815                 struct file *file_out, loff_t pos_out, u64 len)
1816 {
1817         struct inode *inode_in = file_inode(file_in);
1818         struct inode *inode_out = file_inode(file_out);
1819         int ret;
1820
1821         if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode))
1822                 return -EISDIR;
1823         if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode))
1824                 return -EINVAL;
1825
1826         /*
1827          * FICLONE/FICLONERANGE ioctls enforce that src and dest files are on
1828          * the same mount. Practically, they only need to be on the same file
1829          * system.
1830          */
1831         if (inode_in->i_sb != inode_out->i_sb)
1832                 return -EXDEV;
1833
1834         if (!(file_in->f_mode & FMODE_READ) ||
1835             !(file_out->f_mode & FMODE_WRITE) ||
1836             (file_out->f_flags & O_APPEND))
1837                 return -EBADF;
1838
1839         if (!file_in->f_op->clone_file_range)
1840                 return -EOPNOTSUPP;
1841
1842         ret = clone_verify_area(file_in, pos_in, len, false);
1843         if (ret)
1844                 return ret;
1845
1846         ret = clone_verify_area(file_out, pos_out, len, true);
1847         if (ret)
1848                 return ret;
1849
1850         if (pos_in + len > i_size_read(inode_in))
1851                 return -EINVAL;
1852
1853         ret = file_in->f_op->clone_file_range(file_in, pos_in,
1854                         file_out, pos_out, len);
1855         if (!ret) {
1856                 fsnotify_access(file_in);
1857                 fsnotify_modify(file_out);
1858         }
1859
1860         return ret;
1861 }
1862 EXPORT_SYMBOL(vfs_clone_file_range);
1863
1864 /*
1865  * Read a page's worth of file data into the page cache.  Return the page
1866  * locked.
1867  */
1868 static struct page *vfs_dedupe_get_page(struct inode *inode, loff_t offset)
1869 {
1870         struct address_space *mapping;
1871         struct page *page;
1872         pgoff_t n;
1873
1874         n = offset >> PAGE_SHIFT;
1875         mapping = inode->i_mapping;
1876         page = read_mapping_page(mapping, n, NULL);
1877         if (IS_ERR(page))
1878                 return page;
1879         if (!PageUptodate(page)) {
1880                 put_page(page);
1881                 return ERR_PTR(-EIO);
1882         }
1883         lock_page(page);
1884         return page;
1885 }
1886
1887 /*
1888  * Compare extents of two files to see if they are the same.
1889  * Caller must have locked both inodes to prevent write races.
1890  */
1891 int vfs_dedupe_file_range_compare(struct inode *src, loff_t srcoff,
1892                                   struct inode *dest, loff_t destoff,
1893                                   loff_t len, bool *is_same)
1894 {
1895         loff_t src_poff;
1896         loff_t dest_poff;
1897         void *src_addr;
1898         void *dest_addr;
1899         struct page *src_page;
1900         struct page *dest_page;
1901         loff_t cmp_len;
1902         bool same;
1903         int error;
1904
1905         error = -EINVAL;
1906         same = true;
1907         while (len) {
1908                 src_poff = srcoff & (PAGE_SIZE - 1);
1909                 dest_poff = destoff & (PAGE_SIZE - 1);
1910                 cmp_len = min(PAGE_SIZE - src_poff,
1911                               PAGE_SIZE - dest_poff);
1912                 cmp_len = min(cmp_len, len);
1913                 if (cmp_len <= 0)
1914                         goto out_error;
1915
1916                 src_page = vfs_dedupe_get_page(src, srcoff);
1917                 if (IS_ERR(src_page)) {
1918                         error = PTR_ERR(src_page);
1919                         goto out_error;
1920                 }
1921                 dest_page = vfs_dedupe_get_page(dest, destoff);
1922                 if (IS_ERR(dest_page)) {
1923                         error = PTR_ERR(dest_page);
1924                         unlock_page(src_page);
1925                         put_page(src_page);
1926                         goto out_error;
1927                 }
1928                 src_addr = kmap_atomic(src_page);
1929                 dest_addr = kmap_atomic(dest_page);
1930
1931                 flush_dcache_page(src_page);
1932                 flush_dcache_page(dest_page);
1933
1934                 if (memcmp(src_addr + src_poff, dest_addr + dest_poff, cmp_len))
1935                         same = false;
1936
1937                 kunmap_atomic(dest_addr);
1938                 kunmap_atomic(src_addr);
1939                 unlock_page(dest_page);
1940                 unlock_page(src_page);
1941                 put_page(dest_page);
1942                 put_page(src_page);
1943
1944                 if (!same)
1945                         break;
1946
1947                 srcoff += cmp_len;
1948                 destoff += cmp_len;
1949                 len -= cmp_len;
1950         }
1951
1952         *is_same = same;
1953         return 0;
1954
1955 out_error:
1956         return error;
1957 }
1958 EXPORT_SYMBOL(vfs_dedupe_file_range_compare);
1959
1960 int vfs_dedupe_file_range(struct file *file, struct file_dedupe_range *same)
1961 {
1962         struct file_dedupe_range_info *info;
1963         struct inode *src = file_inode(file);
1964         u64 off;
1965         u64 len;
1966         int i;
1967         int ret;
1968         bool is_admin = capable(CAP_SYS_ADMIN);
1969         u16 count = same->dest_count;
1970         struct file *dst_file;
1971         loff_t dst_off;
1972         ssize_t deduped;
1973
1974         if (!(file->f_mode & FMODE_READ))
1975                 return -EINVAL;
1976
1977         if (same->reserved1 || same->reserved2)
1978                 return -EINVAL;
1979
1980         off = same->src_offset;
1981         len = same->src_length;
1982
1983         ret = -EISDIR;
1984         if (S_ISDIR(src->i_mode))
1985                 goto out;
1986
1987         ret = -EINVAL;
1988         if (!S_ISREG(src->i_mode))
1989                 goto out;
1990
1991         ret = clone_verify_area(file, off, len, false);
1992         if (ret < 0)
1993                 goto out;
1994         ret = 0;
1995
1996         if (off + len > i_size_read(src))
1997                 return -EINVAL;
1998
1999         /* pre-format output fields to sane values */
2000         for (i = 0; i < count; i++) {
2001                 same->info[i].bytes_deduped = 0ULL;
2002                 same->info[i].status = FILE_DEDUPE_RANGE_SAME;
2003         }
2004
2005         for (i = 0, info = same->info; i < count; i++, info++) {
2006                 struct inode *dst;
2007                 struct fd dst_fd = fdget(info->dest_fd);
2008
2009                 dst_file = dst_fd.file;
2010                 if (!dst_file) {
2011                         info->status = -EBADF;
2012                         goto next_loop;
2013                 }
2014                 dst = file_inode(dst_file);
2015
2016                 ret = mnt_want_write_file(dst_file);
2017                 if (ret) {
2018                         info->status = ret;
2019                         goto next_loop;
2020                 }
2021
2022                 dst_off = info->dest_offset;
2023                 ret = clone_verify_area(dst_file, dst_off, len, true);
2024                 if (ret < 0) {
2025                         info->status = ret;
2026                         goto next_file;
2027                 }
2028                 ret = 0;
2029
2030                 if (info->reserved) {
2031                         info->status = -EINVAL;
2032                 } else if (!(is_admin || (dst_file->f_mode & FMODE_WRITE))) {
2033                         info->status = -EINVAL;
2034                 } else if (file->f_path.mnt != dst_file->f_path.mnt) {
2035                         info->status = -EXDEV;
2036                 } else if (S_ISDIR(dst->i_mode)) {
2037                         info->status = -EISDIR;
2038                 } else if (dst_file->f_op->dedupe_file_range == NULL) {
2039                         info->status = -EINVAL;
2040                 } else {
2041                         deduped = dst_file->f_op->dedupe_file_range(file, off,
2042                                                         len, dst_file,
2043                                                         info->dest_offset);
2044                         if (deduped == -EBADE)
2045                                 info->status = FILE_DEDUPE_RANGE_DIFFERS;
2046                         else if (deduped < 0)
2047                                 info->status = deduped;
2048                         else
2049                                 info->bytes_deduped += deduped;
2050                 }
2051
2052 next_file:
2053                 mnt_drop_write_file(dst_file);
2054 next_loop:
2055                 fdput(dst_fd);
2056
2057                 if (fatal_signal_pending(current))
2058                         goto out;
2059         }
2060
2061 out:
2062         return ret;
2063 }
2064 EXPORT_SYMBOL(vfs_dedupe_file_range);