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