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