Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/signal
[linux-3.10.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/fcntl.h>
10 #include <linux/file.h>
11 #include <linux/uio.h>
12 #include <linux/fsnotify.h>
13 #include <linux/security.h>
14 #include <linux/export.h>
15 #include <linux/syscalls.h>
16 #include <linux/pagemap.h>
17 #include <linux/splice.h>
18 #include <linux/compat.h>
19 #include "read_write.h"
20 #include "internal.h"
21
22 #include <asm/uaccess.h>
23 #include <asm/unistd.h>
24
25 const struct file_operations generic_ro_fops = {
26         .llseek         = generic_file_llseek,
27         .read           = do_sync_read,
28         .aio_read       = generic_file_aio_read,
29         .mmap           = generic_file_readonly_mmap,
30         .splice_read    = generic_file_splice_read,
31 };
32
33 EXPORT_SYMBOL(generic_ro_fops);
34
35 static inline int unsigned_offsets(struct file *file)
36 {
37         return file->f_mode & FMODE_UNSIGNED_OFFSET;
38 }
39
40 static loff_t lseek_execute(struct file *file, struct inode *inode,
41                 loff_t offset, loff_t maxsize)
42 {
43         if (offset < 0 && !unsigned_offsets(file))
44                 return -EINVAL;
45         if (offset > maxsize)
46                 return -EINVAL;
47
48         if (offset != file->f_pos) {
49                 file->f_pos = offset;
50                 file->f_version = 0;
51         }
52         return offset;
53 }
54
55 /**
56  * generic_file_llseek_size - generic llseek implementation for regular files
57  * @file:       file structure to seek on
58  * @offset:     file offset to seek to
59  * @whence:     type of seek
60  * @size:       max size of this file in file system
61  * @eof:        offset used for SEEK_END position
62  *
63  * This is a variant of generic_file_llseek that allows passing in a custom
64  * maximum file size and a custom EOF position, for e.g. hashed directories
65  *
66  * Synchronization:
67  * SEEK_SET and SEEK_END are unsynchronized (but atomic on 64bit platforms)
68  * SEEK_CUR is synchronized against other SEEK_CURs, but not read/writes.
69  * read/writes behave like SEEK_SET against seeks.
70  */
71 loff_t
72 generic_file_llseek_size(struct file *file, loff_t offset, int whence,
73                 loff_t maxsize, loff_t eof)
74 {
75         struct inode *inode = file->f_mapping->host;
76
77         switch (whence) {
78         case SEEK_END:
79                 offset += eof;
80                 break;
81         case SEEK_CUR:
82                 /*
83                  * Here we special-case the lseek(fd, 0, SEEK_CUR)
84                  * position-querying operation.  Avoid rewriting the "same"
85                  * f_pos value back to the file because a concurrent read(),
86                  * write() or lseek() might have altered it
87                  */
88                 if (offset == 0)
89                         return file->f_pos;
90                 /*
91                  * f_lock protects against read/modify/write race with other
92                  * SEEK_CURs. Note that parallel writes and reads behave
93                  * like SEEK_SET.
94                  */
95                 spin_lock(&file->f_lock);
96                 offset = lseek_execute(file, inode, file->f_pos + offset,
97                                        maxsize);
98                 spin_unlock(&file->f_lock);
99                 return offset;
100         case SEEK_DATA:
101                 /*
102                  * In the generic case the entire file is data, so as long as
103                  * offset isn't at the end of the file then the offset is data.
104                  */
105                 if (offset >= eof)
106                         return -ENXIO;
107                 break;
108         case SEEK_HOLE:
109                 /*
110                  * There is a virtual hole at the end of the file, so as long as
111                  * offset isn't i_size or larger, return i_size.
112                  */
113                 if (offset >= eof)
114                         return -ENXIO;
115                 offset = eof;
116                 break;
117         }
118
119         return lseek_execute(file, inode, offset, maxsize);
120 }
121 EXPORT_SYMBOL(generic_file_llseek_size);
122
123 /**
124  * generic_file_llseek - generic llseek implementation for regular files
125  * @file:       file structure to seek on
126  * @offset:     file offset to seek to
127  * @whence:     type of seek
128  *
129  * This is a generic implemenation of ->llseek useable for all normal local
130  * filesystems.  It just updates the file offset to the value specified by
131  * @offset and @whence.
132  */
133 loff_t generic_file_llseek(struct file *file, loff_t offset, int whence)
134 {
135         struct inode *inode = file->f_mapping->host;
136
137         return generic_file_llseek_size(file, offset, whence,
138                                         inode->i_sb->s_maxbytes,
139                                         i_size_read(inode));
140 }
141 EXPORT_SYMBOL(generic_file_llseek);
142
143 /**
144  * noop_llseek - No Operation Performed llseek implementation
145  * @file:       file structure to seek on
146  * @offset:     file offset to seek to
147  * @whence:     type of seek
148  *
149  * This is an implementation of ->llseek useable for the rare special case when
150  * userspace expects the seek to succeed but the (device) file is actually not
151  * able to perform the seek. In this case you use noop_llseek() instead of
152  * falling back to the default implementation of ->llseek.
153  */
154 loff_t noop_llseek(struct file *file, loff_t offset, int whence)
155 {
156         return file->f_pos;
157 }
158 EXPORT_SYMBOL(noop_llseek);
159
160 loff_t no_llseek(struct file *file, loff_t offset, int whence)
161 {
162         return -ESPIPE;
163 }
164 EXPORT_SYMBOL(no_llseek);
165
166 loff_t default_llseek(struct file *file, loff_t offset, int whence)
167 {
168         struct inode *inode = file_inode(file);
169         loff_t retval;
170
171         mutex_lock(&inode->i_mutex);
172         switch (whence) {
173                 case SEEK_END:
174                         offset += i_size_read(inode);
175                         break;
176                 case SEEK_CUR:
177                         if (offset == 0) {
178                                 retval = file->f_pos;
179                                 goto out;
180                         }
181                         offset += file->f_pos;
182                         break;
183                 case SEEK_DATA:
184                         /*
185                          * In the generic case the entire file is data, so as
186                          * long as offset isn't at the end of the file then the
187                          * offset is data.
188                          */
189                         if (offset >= inode->i_size) {
190                                 retval = -ENXIO;
191                                 goto out;
192                         }
193                         break;
194                 case SEEK_HOLE:
195                         /*
196                          * There is a virtual hole at the end of the file, so
197                          * as long as offset isn't i_size or larger, return
198                          * i_size.
199                          */
200                         if (offset >= inode->i_size) {
201                                 retval = -ENXIO;
202                                 goto out;
203                         }
204                         offset = inode->i_size;
205                         break;
206         }
207         retval = -EINVAL;
208         if (offset >= 0 || unsigned_offsets(file)) {
209                 if (offset != file->f_pos) {
210                         file->f_pos = offset;
211                         file->f_version = 0;
212                 }
213                 retval = offset;
214         }
215 out:
216         mutex_unlock(&inode->i_mutex);
217         return retval;
218 }
219 EXPORT_SYMBOL(default_llseek);
220
221 loff_t vfs_llseek(struct file *file, loff_t offset, int whence)
222 {
223         loff_t (*fn)(struct file *, loff_t, int);
224
225         fn = no_llseek;
226         if (file->f_mode & FMODE_LSEEK) {
227                 if (file->f_op && file->f_op->llseek)
228                         fn = file->f_op->llseek;
229         }
230         return fn(file, offset, whence);
231 }
232 EXPORT_SYMBOL(vfs_llseek);
233
234 SYSCALL_DEFINE3(lseek, unsigned int, fd, off_t, offset, unsigned int, whence)
235 {
236         off_t retval;
237         struct fd f = fdget(fd);
238         if (!f.file)
239                 return -EBADF;
240
241         retval = -EINVAL;
242         if (whence <= SEEK_MAX) {
243                 loff_t res = vfs_llseek(f.file, offset, whence);
244                 retval = res;
245                 if (res != (loff_t)retval)
246                         retval = -EOVERFLOW;    /* LFS: should only happen on 32 bit platforms */
247         }
248         fdput(f);
249         return retval;
250 }
251
252 #ifdef CONFIG_COMPAT
253 COMPAT_SYSCALL_DEFINE3(lseek, unsigned int, fd, compat_off_t, offset, unsigned int, whence)
254 {
255         return sys_lseek(fd, offset, whence);
256 }
257 #endif
258
259 #ifdef __ARCH_WANT_SYS_LLSEEK
260 SYSCALL_DEFINE5(llseek, unsigned int, fd, unsigned long, offset_high,
261                 unsigned long, offset_low, loff_t __user *, result,
262                 unsigned int, whence)
263 {
264         int retval;
265         struct fd f = fdget(fd);
266         loff_t offset;
267
268         if (!f.file)
269                 return -EBADF;
270
271         retval = -EINVAL;
272         if (whence > SEEK_MAX)
273                 goto out_putf;
274
275         offset = vfs_llseek(f.file, ((loff_t) offset_high << 32) | offset_low,
276                         whence);
277
278         retval = (int)offset;
279         if (offset >= 0) {
280                 retval = -EFAULT;
281                 if (!copy_to_user(result, &offset, sizeof(offset)))
282                         retval = 0;
283         }
284 out_putf:
285         fdput(f);
286         return retval;
287 }
288 #endif
289
290 /*
291  * rw_verify_area doesn't like huge counts. We limit
292  * them to something that fits in "int" so that others
293  * won't have to do range checks all the time.
294  */
295 int rw_verify_area(int read_write, struct file *file, loff_t *ppos, size_t count)
296 {
297         struct inode *inode;
298         loff_t pos;
299         int retval = -EINVAL;
300
301         inode = file_inode(file);
302         if (unlikely((ssize_t) count < 0))
303                 return retval;
304         pos = *ppos;
305         if (unlikely(pos < 0)) {
306                 if (!unsigned_offsets(file))
307                         return retval;
308                 if (count >= -pos) /* both values are in 0..LLONG_MAX */
309                         return -EOVERFLOW;
310         } else if (unlikely((loff_t) (pos + count) < 0)) {
311                 if (!unsigned_offsets(file))
312                         return retval;
313         }
314
315         if (unlikely(inode->i_flock && mandatory_lock(inode))) {
316                 retval = locks_mandatory_area(
317                         read_write == READ ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE,
318                         inode, file, pos, count);
319                 if (retval < 0)
320                         return retval;
321         }
322         retval = security_file_permission(file,
323                                 read_write == READ ? MAY_READ : MAY_WRITE);
324         if (retval)
325                 return retval;
326         return count > MAX_RW_COUNT ? MAX_RW_COUNT : count;
327 }
328
329 static void wait_on_retry_sync_kiocb(struct kiocb *iocb)
330 {
331         set_current_state(TASK_UNINTERRUPTIBLE);
332         if (!kiocbIsKicked(iocb))
333                 schedule();
334         else
335                 kiocbClearKicked(iocb);
336         __set_current_state(TASK_RUNNING);
337 }
338
339 ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
340 {
341         struct iovec iov = { .iov_base = buf, .iov_len = len };
342         struct kiocb kiocb;
343         ssize_t ret;
344
345         init_sync_kiocb(&kiocb, filp);
346         kiocb.ki_pos = *ppos;
347         kiocb.ki_left = len;
348         kiocb.ki_nbytes = len;
349
350         for (;;) {
351                 ret = filp->f_op->aio_read(&kiocb, &iov, 1, kiocb.ki_pos);
352                 if (ret != -EIOCBRETRY)
353                         break;
354                 wait_on_retry_sync_kiocb(&kiocb);
355         }
356
357         if (-EIOCBQUEUED == ret)
358                 ret = wait_on_sync_kiocb(&kiocb);
359         *ppos = kiocb.ki_pos;
360         return ret;
361 }
362
363 EXPORT_SYMBOL(do_sync_read);
364
365 ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
366 {
367         ssize_t ret;
368
369         if (!(file->f_mode & FMODE_READ))
370                 return -EBADF;
371         if (!file->f_op || (!file->f_op->read && !file->f_op->aio_read))
372                 return -EINVAL;
373         if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
374                 return -EFAULT;
375
376         ret = rw_verify_area(READ, file, pos, count);
377         if (ret >= 0) {
378                 count = ret;
379                 if (file->f_op->read)
380                         ret = file->f_op->read(file, buf, count, pos);
381                 else
382                         ret = do_sync_read(file, buf, count, pos);
383                 if (ret > 0) {
384                         fsnotify_access(file);
385                         add_rchar(current, ret);
386                 }
387                 inc_syscr(current);
388         }
389
390         return ret;
391 }
392
393 EXPORT_SYMBOL(vfs_read);
394
395 ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
396 {
397         struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
398         struct kiocb kiocb;
399         ssize_t ret;
400
401         init_sync_kiocb(&kiocb, filp);
402         kiocb.ki_pos = *ppos;
403         kiocb.ki_left = len;
404         kiocb.ki_nbytes = len;
405
406         for (;;) {
407                 ret = filp->f_op->aio_write(&kiocb, &iov, 1, kiocb.ki_pos);
408                 if (ret != -EIOCBRETRY)
409                         break;
410                 wait_on_retry_sync_kiocb(&kiocb);
411         }
412
413         if (-EIOCBQUEUED == ret)
414                 ret = wait_on_sync_kiocb(&kiocb);
415         *ppos = kiocb.ki_pos;
416         return ret;
417 }
418
419 EXPORT_SYMBOL(do_sync_write);
420
421 ssize_t __kernel_write(struct file *file, const char *buf, size_t count, loff_t *pos)
422 {
423         mm_segment_t old_fs;
424         const char __user *p;
425         ssize_t ret;
426
427         if (!file->f_op || (!file->f_op->write && !file->f_op->aio_write))
428                 return -EINVAL;
429
430         old_fs = get_fs();
431         set_fs(get_ds());
432         p = (__force const char __user *)buf;
433         if (count > MAX_RW_COUNT)
434                 count =  MAX_RW_COUNT;
435         if (file->f_op->write)
436                 ret = file->f_op->write(file, p, count, pos);
437         else
438                 ret = do_sync_write(file, p, count, pos);
439         set_fs(old_fs);
440         if (ret > 0) {
441                 fsnotify_modify(file);
442                 add_wchar(current, ret);
443         }
444         inc_syscw(current);
445         return ret;
446 }
447
448 ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
449 {
450         ssize_t ret;
451
452         if (!(file->f_mode & FMODE_WRITE))
453                 return -EBADF;
454         if (!file->f_op || (!file->f_op->write && !file->f_op->aio_write))
455                 return -EINVAL;
456         if (unlikely(!access_ok(VERIFY_READ, buf, count)))
457                 return -EFAULT;
458
459         ret = rw_verify_area(WRITE, file, pos, count);
460         if (ret >= 0) {
461                 count = ret;
462                 if (file->f_op->write)
463                         ret = file->f_op->write(file, buf, count, pos);
464                 else
465                         ret = do_sync_write(file, buf, count, pos);
466                 if (ret > 0) {
467                         fsnotify_modify(file);
468                         add_wchar(current, ret);
469                 }
470                 inc_syscw(current);
471         }
472
473         return ret;
474 }
475
476 EXPORT_SYMBOL(vfs_write);
477
478 static inline loff_t file_pos_read(struct file *file)
479 {
480         return file->f_pos;
481 }
482
483 static inline void file_pos_write(struct file *file, loff_t pos)
484 {
485         file->f_pos = pos;
486 }
487
488 SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
489 {
490         struct fd f = fdget(fd);
491         ssize_t ret = -EBADF;
492
493         if (f.file) {
494                 loff_t pos = file_pos_read(f.file);
495                 ret = vfs_read(f.file, buf, count, &pos);
496                 file_pos_write(f.file, pos);
497                 fdput(f);
498         }
499         return ret;
500 }
501
502 SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
503                 size_t, count)
504 {
505         struct fd f = fdget(fd);
506         ssize_t ret = -EBADF;
507
508         if (f.file) {
509                 loff_t pos = file_pos_read(f.file);
510                 ret = vfs_write(f.file, buf, count, &pos);
511                 file_pos_write(f.file, pos);
512                 fdput(f);
513         }
514
515         return ret;
516 }
517
518 SYSCALL_DEFINE4(pread64, unsigned int, fd, char __user *, buf,
519                         size_t, count, loff_t, pos)
520 {
521         struct fd f;
522         ssize_t ret = -EBADF;
523
524         if (pos < 0)
525                 return -EINVAL;
526
527         f = fdget(fd);
528         if (f.file) {
529                 ret = -ESPIPE;
530                 if (f.file->f_mode & FMODE_PREAD)
531                         ret = vfs_read(f.file, buf, count, &pos);
532                 fdput(f);
533         }
534
535         return ret;
536 }
537
538 SYSCALL_DEFINE4(pwrite64, unsigned int, fd, const char __user *, buf,
539                          size_t, count, loff_t, pos)
540 {
541         struct fd f;
542         ssize_t ret = -EBADF;
543
544         if (pos < 0)
545                 return -EINVAL;
546
547         f = fdget(fd);
548         if (f.file) {
549                 ret = -ESPIPE;
550                 if (f.file->f_mode & FMODE_PWRITE)  
551                         ret = vfs_write(f.file, buf, count, &pos);
552                 fdput(f);
553         }
554
555         return ret;
556 }
557
558 /*
559  * Reduce an iovec's length in-place.  Return the resulting number of segments
560  */
561 unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to)
562 {
563         unsigned long seg = 0;
564         size_t len = 0;
565
566         while (seg < nr_segs) {
567                 seg++;
568                 if (len + iov->iov_len >= to) {
569                         iov->iov_len = to - len;
570                         break;
571                 }
572                 len += iov->iov_len;
573                 iov++;
574         }
575         return seg;
576 }
577 EXPORT_SYMBOL(iov_shorten);
578
579 ssize_t do_sync_readv_writev(struct file *filp, const struct iovec *iov,
580                 unsigned long nr_segs, size_t len, loff_t *ppos, iov_fn_t fn)
581 {
582         struct kiocb kiocb;
583         ssize_t ret;
584
585         init_sync_kiocb(&kiocb, filp);
586         kiocb.ki_pos = *ppos;
587         kiocb.ki_left = len;
588         kiocb.ki_nbytes = len;
589
590         for (;;) {
591                 ret = fn(&kiocb, iov, nr_segs, kiocb.ki_pos);
592                 if (ret != -EIOCBRETRY)
593                         break;
594                 wait_on_retry_sync_kiocb(&kiocb);
595         }
596
597         if (ret == -EIOCBQUEUED)
598                 ret = wait_on_sync_kiocb(&kiocb);
599         *ppos = kiocb.ki_pos;
600         return ret;
601 }
602
603 /* Do it by hand, with file-ops */
604 ssize_t do_loop_readv_writev(struct file *filp, struct iovec *iov,
605                 unsigned long nr_segs, loff_t *ppos, io_fn_t fn)
606 {
607         struct iovec *vector = iov;
608         ssize_t ret = 0;
609
610         while (nr_segs > 0) {
611                 void __user *base;
612                 size_t len;
613                 ssize_t nr;
614
615                 base = vector->iov_base;
616                 len = vector->iov_len;
617                 vector++;
618                 nr_segs--;
619
620                 nr = fn(filp, base, len, ppos);
621
622                 if (nr < 0) {
623                         if (!ret)
624                                 ret = nr;
625                         break;
626                 }
627                 ret += nr;
628                 if (nr != len)
629                         break;
630         }
631
632         return ret;
633 }
634
635 /* A write operation does a read from user space and vice versa */
636 #define vrfy_dir(type) ((type) == READ ? VERIFY_WRITE : VERIFY_READ)
637
638 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
639                               unsigned long nr_segs, unsigned long fast_segs,
640                               struct iovec *fast_pointer,
641                               struct iovec **ret_pointer)
642 {
643         unsigned long seg;
644         ssize_t ret;
645         struct iovec *iov = fast_pointer;
646
647         /*
648          * SuS says "The readv() function *may* fail if the iovcnt argument
649          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
650          * traditionally returned zero for zero segments, so...
651          */
652         if (nr_segs == 0) {
653                 ret = 0;
654                 goto out;
655         }
656
657         /*
658          * First get the "struct iovec" from user memory and
659          * verify all the pointers
660          */
661         if (nr_segs > UIO_MAXIOV) {
662                 ret = -EINVAL;
663                 goto out;
664         }
665         if (nr_segs > fast_segs) {
666                 iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
667                 if (iov == NULL) {
668                         ret = -ENOMEM;
669                         goto out;
670                 }
671         }
672         if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
673                 ret = -EFAULT;
674                 goto out;
675         }
676
677         /*
678          * According to the Single Unix Specification we should return EINVAL
679          * if an element length is < 0 when cast to ssize_t or if the
680          * total length would overflow the ssize_t return value of the
681          * system call.
682          *
683          * Linux caps all read/write calls to MAX_RW_COUNT, and avoids the
684          * overflow case.
685          */
686         ret = 0;
687         for (seg = 0; seg < nr_segs; seg++) {
688                 void __user *buf = iov[seg].iov_base;
689                 ssize_t len = (ssize_t)iov[seg].iov_len;
690
691                 /* see if we we're about to use an invalid len or if
692                  * it's about to overflow ssize_t */
693                 if (len < 0) {
694                         ret = -EINVAL;
695                         goto out;
696                 }
697                 if (type >= 0
698                     && unlikely(!access_ok(vrfy_dir(type), buf, len))) {
699                         ret = -EFAULT;
700                         goto out;
701                 }
702                 if (len > MAX_RW_COUNT - ret) {
703                         len = MAX_RW_COUNT - ret;
704                         iov[seg].iov_len = len;
705                 }
706                 ret += len;
707         }
708 out:
709         *ret_pointer = iov;
710         return ret;
711 }
712
713 static ssize_t do_readv_writev(int type, struct file *file,
714                                const struct iovec __user * uvector,
715                                unsigned long nr_segs, loff_t *pos)
716 {
717         size_t tot_len;
718         struct iovec iovstack[UIO_FASTIOV];
719         struct iovec *iov = iovstack;
720         ssize_t ret;
721         io_fn_t fn;
722         iov_fn_t fnv;
723
724         if (!file->f_op) {
725                 ret = -EINVAL;
726                 goto out;
727         }
728
729         ret = rw_copy_check_uvector(type, uvector, nr_segs,
730                                     ARRAY_SIZE(iovstack), iovstack, &iov);
731         if (ret <= 0)
732                 goto out;
733
734         tot_len = ret;
735         ret = rw_verify_area(type, file, pos, tot_len);
736         if (ret < 0)
737                 goto out;
738
739         fnv = NULL;
740         if (type == READ) {
741                 fn = file->f_op->read;
742                 fnv = file->f_op->aio_read;
743         } else {
744                 fn = (io_fn_t)file->f_op->write;
745                 fnv = file->f_op->aio_write;
746         }
747
748         if (fnv)
749                 ret = do_sync_readv_writev(file, iov, nr_segs, tot_len,
750                                                 pos, fnv);
751         else
752                 ret = do_loop_readv_writev(file, iov, nr_segs, pos, fn);
753
754 out:
755         if (iov != iovstack)
756                 kfree(iov);
757         if ((ret + (type == READ)) > 0) {
758                 if (type == READ)
759                         fsnotify_access(file);
760                 else
761                         fsnotify_modify(file);
762         }
763         return ret;
764 }
765
766 ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
767                   unsigned long vlen, loff_t *pos)
768 {
769         if (!(file->f_mode & FMODE_READ))
770                 return -EBADF;
771         if (!file->f_op || (!file->f_op->aio_read && !file->f_op->read))
772                 return -EINVAL;
773
774         return do_readv_writev(READ, file, vec, vlen, pos);
775 }
776
777 EXPORT_SYMBOL(vfs_readv);
778
779 ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
780                    unsigned long vlen, loff_t *pos)
781 {
782         if (!(file->f_mode & FMODE_WRITE))
783                 return -EBADF;
784         if (!file->f_op || (!file->f_op->aio_write && !file->f_op->write))
785                 return -EINVAL;
786
787         return do_readv_writev(WRITE, file, vec, vlen, pos);
788 }
789
790 EXPORT_SYMBOL(vfs_writev);
791
792 SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
793                 unsigned long, vlen)
794 {
795         struct fd f = fdget(fd);
796         ssize_t ret = -EBADF;
797
798         if (f.file) {
799                 loff_t pos = file_pos_read(f.file);
800                 ret = vfs_readv(f.file, vec, vlen, &pos);
801                 file_pos_write(f.file, pos);
802                 fdput(f);
803         }
804
805         if (ret > 0)
806                 add_rchar(current, ret);
807         inc_syscr(current);
808         return ret;
809 }
810
811 SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *, vec,
812                 unsigned long, vlen)
813 {
814         struct fd f = fdget(fd);
815         ssize_t ret = -EBADF;
816
817         if (f.file) {
818                 loff_t pos = file_pos_read(f.file);
819                 ret = vfs_writev(f.file, vec, vlen, &pos);
820                 file_pos_write(f.file, pos);
821                 fdput(f);
822         }
823
824         if (ret > 0)
825                 add_wchar(current, ret);
826         inc_syscw(current);
827         return ret;
828 }
829
830 static inline loff_t pos_from_hilo(unsigned long high, unsigned long low)
831 {
832 #define HALF_LONG_BITS (BITS_PER_LONG / 2)
833         return (((loff_t)high << HALF_LONG_BITS) << HALF_LONG_BITS) | low;
834 }
835
836 SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
837                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
838 {
839         loff_t pos = pos_from_hilo(pos_h, pos_l);
840         struct fd f;
841         ssize_t ret = -EBADF;
842
843         if (pos < 0)
844                 return -EINVAL;
845
846         f = fdget(fd);
847         if (f.file) {
848                 ret = -ESPIPE;
849                 if (f.file->f_mode & FMODE_PREAD)
850                         ret = vfs_readv(f.file, vec, vlen, &pos);
851                 fdput(f);
852         }
853
854         if (ret > 0)
855                 add_rchar(current, ret);
856         inc_syscr(current);
857         return ret;
858 }
859
860 SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
861                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
862 {
863         loff_t pos = pos_from_hilo(pos_h, pos_l);
864         struct fd f;
865         ssize_t ret = -EBADF;
866
867         if (pos < 0)
868                 return -EINVAL;
869
870         f = fdget(fd);
871         if (f.file) {
872                 ret = -ESPIPE;
873                 if (f.file->f_mode & FMODE_PWRITE)
874                         ret = vfs_writev(f.file, vec, vlen, &pos);
875                 fdput(f);
876         }
877
878         if (ret > 0)
879                 add_wchar(current, ret);
880         inc_syscw(current);
881         return ret;
882 }
883
884 static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
885                            size_t count, loff_t max)
886 {
887         struct fd in, out;
888         struct inode *in_inode, *out_inode;
889         loff_t pos;
890         ssize_t retval;
891         int fl;
892
893         /*
894          * Get input file, and verify that it is ok..
895          */
896         retval = -EBADF;
897         in = fdget(in_fd);
898         if (!in.file)
899                 goto out;
900         if (!(in.file->f_mode & FMODE_READ))
901                 goto fput_in;
902         retval = -ESPIPE;
903         if (!ppos)
904                 ppos = &in.file->f_pos;
905         else
906                 if (!(in.file->f_mode & FMODE_PREAD))
907                         goto fput_in;
908         retval = rw_verify_area(READ, in.file, ppos, count);
909         if (retval < 0)
910                 goto fput_in;
911         count = retval;
912
913         /*
914          * Get output file, and verify that it is ok..
915          */
916         retval = -EBADF;
917         out = fdget(out_fd);
918         if (!out.file)
919                 goto fput_in;
920         if (!(out.file->f_mode & FMODE_WRITE))
921                 goto fput_out;
922         retval = -EINVAL;
923         in_inode = file_inode(in.file);
924         out_inode = file_inode(out.file);
925         retval = rw_verify_area(WRITE, out.file, &out.file->f_pos, count);
926         if (retval < 0)
927                 goto fput_out;
928         count = retval;
929
930         if (!max)
931                 max = min(in_inode->i_sb->s_maxbytes, out_inode->i_sb->s_maxbytes);
932
933         pos = *ppos;
934         if (unlikely(pos + count > max)) {
935                 retval = -EOVERFLOW;
936                 if (pos >= max)
937                         goto fput_out;
938                 count = max - pos;
939         }
940
941         fl = 0;
942 #if 0
943         /*
944          * We need to debate whether we can enable this or not. The
945          * man page documents EAGAIN return for the output at least,
946          * and the application is arguably buggy if it doesn't expect
947          * EAGAIN on a non-blocking file descriptor.
948          */
949         if (in.file->f_flags & O_NONBLOCK)
950                 fl = SPLICE_F_NONBLOCK;
951 #endif
952         retval = do_splice_direct(in.file, ppos, out.file, count, fl);
953
954         if (retval > 0) {
955                 add_rchar(current, retval);
956                 add_wchar(current, retval);
957                 fsnotify_access(in.file);
958                 fsnotify_modify(out.file);
959         }
960
961         inc_syscr(current);
962         inc_syscw(current);
963         if (*ppos > max)
964                 retval = -EOVERFLOW;
965
966 fput_out:
967         fdput(out);
968 fput_in:
969         fdput(in);
970 out:
971         return retval;
972 }
973
974 SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd, off_t __user *, offset, size_t, count)
975 {
976         loff_t pos;
977         off_t off;
978         ssize_t ret;
979
980         if (offset) {
981                 if (unlikely(get_user(off, offset)))
982                         return -EFAULT;
983                 pos = off;
984                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
985                 if (unlikely(put_user(pos, offset)))
986                         return -EFAULT;
987                 return ret;
988         }
989
990         return do_sendfile(out_fd, in_fd, NULL, count, 0);
991 }
992
993 SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, loff_t __user *, offset, size_t, count)
994 {
995         loff_t pos;
996         ssize_t ret;
997
998         if (offset) {
999                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1000                         return -EFAULT;
1001                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1002                 if (unlikely(put_user(pos, offset)))
1003                         return -EFAULT;
1004                 return ret;
1005         }
1006
1007         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1008 }
1009
1010 #ifdef CONFIG_COMPAT
1011 COMPAT_SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd,
1012                 compat_off_t __user *, offset, compat_size_t, count)
1013 {
1014         loff_t pos;
1015         off_t off;
1016         ssize_t ret;
1017
1018         if (offset) {
1019                 if (unlikely(get_user(off, offset)))
1020                         return -EFAULT;
1021                 pos = off;
1022                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
1023                 if (unlikely(put_user(pos, offset)))
1024                         return -EFAULT;
1025                 return ret;
1026         }
1027
1028         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1029 }
1030
1031 COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd,
1032                 compat_loff_t __user *, offset, compat_size_t, count)
1033 {
1034         loff_t pos;
1035         ssize_t ret;
1036
1037         if (offset) {
1038                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1039                         return -EFAULT;
1040                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1041                 if (unlikely(put_user(pos, offset)))
1042                         return -EFAULT;
1043                 return ret;
1044         }
1045
1046         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1047 }
1048 #endif