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 <linux/mount.h>
  20 #include "internal.h"
  21
  22 #include <asm/uaccess.h>
  23 #include <asm/unistd.h>
  24
  25 typedef ssize_t (*io_fn_t)(struct file *, char __user *, size_t, loff_t *);
  26 typedef ssize_t (*iter_fn_t)(struct kiocb *, struct iov_iter *);
  27
  28 const struct file_operations generic_ro_fops = {
  29         .llseek         = generic_file_llseek,
  30         .read_iter      = generic_file_read_iter,
  31         .mmap           = generic_file_readonly_mmap,
  32         .splice_read    = generic_file_splice_read,
  33 };
  34
  35 EXPORT_SYMBOL(generic_ro_fops);
  36
  37 static inline int unsigned_offsets(struct file *file)
  38 {
  39         return file->f_mode & FMODE_UNSIGNED_OFFSET;
  40 }
  41
  42 /**
  43  * vfs_setpos - update the file offset for lseek
  44  * @file:       file structure in question
  45  * @offset:     file offset to seek to
  46  * @maxsize:    maximum file size
  47  *
  48  * This is a low-level filesystem helper for updating the file offset to
  49  * the value specified by @offset if the given offset is valid and it is
  50  * not equal to the current file offset.
  51  *
  52  * Return the specified offset on success and -EINVAL on invalid offset.
  53  */
  54 loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize)
  55 {
  56         if (offset < 0 && !unsigned_offsets(file))
  57                 return -EINVAL;
  58         if (offset > maxsize)
  59                 return -EINVAL;
  60
  61         if (offset != file->f_pos) {
  62                 file->f_pos = offset;
  63                 file->f_version = 0;
  64         }
  65         return offset;
  66 }
  67 EXPORT_SYMBOL(vfs_setpos);
  68
  69 /**
  70  * generic_file_llseek_size - generic llseek implementation for regular files
  71  * @file:       file structure to seek on
  72  * @offset:     file offset to seek to
  73  * @whence:     type of seek
  74  * @size:       max size of this file in file system
  75  * @eof:        offset used for SEEK_END position
  76  *
  77  * This is a variant of generic_file_llseek that allows passing in a custom
  78  * maximum file size and a custom EOF position, for e.g. hashed directories
  79  *
  80  * Synchronization:
  81  * SEEK_SET and SEEK_END are unsynchronized (but atomic on 64bit platforms)
  82  * SEEK_CUR is synchronized against other SEEK_CURs, but not read/writes.
  83  * read/writes behave like SEEK_SET against seeks.
  84  */
  85 loff_t
  86 generic_file_llseek_size(struct file *file, loff_t offset, int whence,
  87                 loff_t maxsize, loff_t eof)
  88 {
  89         switch (whence) {
  90         case SEEK_END:
  91                 offset += eof;
  92                 break;
  93         case SEEK_CUR:
  94                 /*
  95                  * Here we special-case the lseek(fd, 0, SEEK_CUR)
  96                  * position-querying operation.  Avoid rewriting the "same"
  97                  * f_pos value back to the file because a concurrent read(),
  98                  * write() or lseek() might have altered it
  99                  */
 100                 if (offset == 0)
 101                         return file->f_pos;
 102                 /*
 103                  * f_lock protects against read/modify/write race with other
 104                  * SEEK_CURs. Note that parallel writes and reads behave
 105                  * like SEEK_SET.
 106                  */
 107                 spin_lock(&file->f_lock);
 108                 offset = vfs_setpos(file, file->f_pos + offset, maxsize);
 109                 spin_unlock(&file->f_lock);
 110                 return offset;
 111         case SEEK_DATA:
 112                 /*
 113                  * In the generic case the entire file is data, so as long as
 114                  * offset isn't at the end of the file then the offset is data.
 115                  */
 116                 if (offset >= eof)
 117                         return -ENXIO;
 118                 break;
 119         case SEEK_HOLE:
 120                 /*
 121                  * There is a virtual hole at the end of the file, so as long as
 122                  * offset isn't i_size or larger, return i_size.
 123                  */
 124                 if (offset >= eof)
 125                         return -ENXIO;
 126                 offset = eof;
 127                 break;
 128         }
 129
 130         return vfs_setpos(file, offset, maxsize);
 131 }
 132 EXPORT_SYMBOL(generic_file_llseek_size);
 133
 134 /**
 135  * generic_file_llseek - generic llseek implementation for regular files
 136  * @file:       file structure to seek on
 137  * @offset:     file offset to seek to
 138  * @whence:     type of seek
 139  *
 140  * This is a generic implemenation of ->llseek useable for all normal local
 141  * filesystems.  It just updates the file offset to the value specified by
 142  * @offset and @whence.
 143  */
 144 loff_t generic_file_llseek(struct file *file, loff_t offset, int whence)
 145 {
 146         struct inode *inode = file->f_mapping->host;
 147
 148         return generic_file_llseek_size(file, offset, whence,
 149                                         inode->i_sb->s_maxbytes,
 150                                         i_size_read(inode));
 151 }
 152 EXPORT_SYMBOL(generic_file_llseek);
 153
 154 /**
 155  * fixed_size_llseek - llseek implementation for fixed-sized devices
 156  * @file:       file structure to seek on
 157  * @offset:     file offset to seek to
 158  * @whence:     type of seek
 159  * @size:       size of the file
 160  *
 161  */
 162 loff_t fixed_size_llseek(struct file *file, loff_t offset, int whence, loff_t size)
 163 {
 164         switch (whence) {
 165         case SEEK_SET: case SEEK_CUR: case SEEK_END:
 166                 return generic_file_llseek_size(file, offset, whence,
 167                                                 size, size);
 168         default:
 169                 return -EINVAL;
 170         }
 171 }
 172 EXPORT_SYMBOL(fixed_size_llseek);
 173
 174 /**
 175  * noop_llseek - No Operation Performed llseek implementation
 176  * @file:       file structure to seek on
 177  * @offset:     file offset to seek to
 178  * @whence:     type of seek
 179  *
 180  * This is an implementation of ->llseek useable for the rare special case when
 181  * userspace expects the seek to succeed but the (device) file is actually not
 182  * able to perform the seek. In this case you use noop_llseek() instead of
 183  * falling back to the default implementation of ->llseek.
 184  */
 185 loff_t noop_llseek(struct file *file, loff_t offset, int whence)
 186 {
 187         return file->f_pos;
 188 }
 189 EXPORT_SYMBOL(noop_llseek);
 190
 191 loff_t no_llseek(struct file *file, loff_t offset, int whence)
 192 {
 193         return -ESPIPE;
 194 }
 195 EXPORT_SYMBOL(no_llseek);
 196
 197 loff_t default_llseek(struct file *file, loff_t offset, int whence)
 198 {
 199         struct inode *inode = file_inode(file);
 200         loff_t retval;
 201
 202         mutex_lock(&inode->i_mutex);
 203         switch (whence) {
 204                 case SEEK_END:
 205                         offset += i_size_read(inode);
 206                         break;
 207                 case SEEK_CUR:
 208                         if (offset == 0) {
 209                                 retval = file->f_pos;
 210                                 goto out;
 211                         }
 212                         offset += file->f_pos;
 213                         break;
 214                 case SEEK_DATA:
 215                         /*
 216                          * In the generic case the entire file is data, so as
 217                          * long as offset isn't at the end of the file then the
 218                          * offset is data.
 219                          */
 220                         if (offset >= inode->i_size) {
 221                                 retval = -ENXIO;
 222                                 goto out;
 223                         }
 224                         break;
 225                 case SEEK_HOLE:
 226                         /*
 227                          * There is a virtual hole at the end of the file, so
 228                          * as long as offset isn't i_size or larger, return
 229                          * i_size.
 230                          */
 231                         if (offset >= inode->i_size) {
 232                                 retval = -ENXIO;
 233                                 goto out;
 234                         }
 235                         offset = inode->i_size;
 236                         break;
 237         }
 238         retval = -EINVAL;
 239         if (offset >= 0 || unsigned_offsets(file)) {
 240                 if (offset != file->f_pos) {
 241                         file->f_pos = offset;
 242                         file->f_version = 0;
 243                 }
 244                 retval = offset;
 245         }
 246 out:
 247         mutex_unlock(&inode->i_mutex);
 248         return retval;
 249 }
 250 EXPORT_SYMBOL(default_llseek);
 251
 252 loff_t vfs_llseek(struct file *file, loff_t offset, int whence)
 253 {
 254         loff_t (*fn)(struct file *, loff_t, int);
 255
 256         fn = no_llseek;
 257         if (file->f_mode & FMODE_LSEEK) {
 258                 if (file->f_op->llseek)
 259                         fn = file->f_op->llseek;
 260         }
 261         return fn(file, offset, whence);
 262 }
 263 EXPORT_SYMBOL(vfs_llseek);
 264
 265 static inline struct fd fdget_pos(int fd)
 266 {
 267         return __to_fd(__fdget_pos(fd));
 268 }
 269
 270 static inline void fdput_pos(struct fd f)
 271 {
 272         if (f.flags & FDPUT_POS_UNLOCK)
 273                 mutex_unlock(&f.file->f_pos_lock);
 274         fdput(f);
 275 }
 276
 277 SYSCALL_DEFINE3(lseek, unsigned int, fd, off_t, offset, unsigned int, whence)
 278 {
 279         off_t retval;
 280         struct fd f = fdget_pos(fd);
 281         if (!f.file)
 282                 return -EBADF;
 283
 284         retval = -EINVAL;
 285         if (whence <= SEEK_MAX) {
 286                 loff_t res = vfs_llseek(f.file, offset, whence);
 287                 retval = res;
 288                 if (res != (loff_t)retval)
 289                         retval = -EOVERFLOW;    /* LFS: should only happen on 32 bit platforms */
 290         }
 291         fdput_pos(f);
 292         return retval;
 293 }
 294
 295 #ifdef CONFIG_COMPAT
 296 COMPAT_SYSCALL_DEFINE3(lseek, unsigned int, fd, compat_off_t, offset, unsigned int, whence)
 297 {
 298         return sys_lseek(fd, offset, whence);
 299 }
 300 #endif
 301
 302 #ifdef __ARCH_WANT_SYS_LLSEEK
 303 SYSCALL_DEFINE5(llseek, unsigned int, fd, unsigned long, offset_high,
 304                 unsigned long, offset_low, loff_t __user *, result,
 305                 unsigned int, whence)
 306 {
 307         int retval;
 308         struct fd f = fdget_pos(fd);
 309         loff_t offset;
 310
 311         if (!f.file)
 312                 return -EBADF;
 313
 314         retval = -EINVAL;
 315         if (whence > SEEK_MAX)
 316                 goto out_putf;
 317
 318         offset = vfs_llseek(f.file, ((loff_t) offset_high << 32) | offset_low,
 319                         whence);
 320
 321         retval = (int)offset;
 322         if (offset >= 0) {
 323                 retval = -EFAULT;
 324                 if (!copy_to_user(result, &offset, sizeof(offset)))
 325                         retval = 0;
 326         }
 327 out_putf:
 328         fdput_pos(f);
 329         return retval;
 330 }
 331 #endif
 332
 333 ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos)
 334 {
 335         struct kiocb kiocb;
 336         ssize_t ret;
 337
 338         if (!file->f_op->read_iter)
 339                 return -EINVAL;
 340
 341         init_sync_kiocb(&kiocb, file);
 342         kiocb.ki_pos = *ppos;
 343
 344         iter->type |= READ;
 345         ret = file->f_op->read_iter(&kiocb, iter);
 346         BUG_ON(ret == -EIOCBQUEUED);
 347         if (ret > 0)
 348                 *ppos = kiocb.ki_pos;
 349         return ret;
 350 }
 351 EXPORT_SYMBOL(vfs_iter_read);
 352
 353 ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos)
 354 {
 355         struct kiocb kiocb;
 356         ssize_t ret;
 357
 358         if (!file->f_op->write_iter)
 359                 return -EINVAL;
 360
 361         init_sync_kiocb(&kiocb, file);
 362         kiocb.ki_pos = *ppos;
 363
 364         iter->type |= WRITE;
 365         ret = file->f_op->write_iter(&kiocb, iter);
 366         BUG_ON(ret == -EIOCBQUEUED);
 367         if (ret > 0)
 368                 *ppos = kiocb.ki_pos;
 369         return ret;
 370 }
 371 EXPORT_SYMBOL(vfs_iter_write);
 372
 373 /*
 374  * rw_verify_area doesn't like huge counts. We limit
 375  * them to something that fits in "int" so that others
 376  * won't have to do range checks all the time.
 377  */
 378 int rw_verify_area(int read_write, struct file *file, const loff_t *ppos, size_t count)
 379 {
 380         struct inode *inode;
 381         loff_t pos;
 382         int retval = -EINVAL;
 383
 384         inode = file_inode(file);
 385         if (unlikely((ssize_t) count < 0))
 386                 return retval;
 387         pos = *ppos;
 388         if (unlikely(pos < 0)) {
 389                 if (!unsigned_offsets(file))
 390                         return retval;
 391                 if (count >= -pos) /* both values are in 0..LLONG_MAX */
 392                         return -EOVERFLOW;
 393         } else if (unlikely((loff_t) (pos + count) < 0)) {
 394                 if (!unsigned_offsets(file))
 395                         return retval;
 396         }
 397
 398         if (unlikely(inode->i_flctx && mandatory_lock(inode))) {
 399                 retval = locks_mandatory_area(inode, file, pos, pos + count - 1,
 400                                 read_write == READ ? F_RDLCK : F_WRLCK);
 401                 if (retval < 0)
 402                         return retval;
 403         }
 404         retval = security_file_permission(file,
 405                                 read_write == READ ? MAY_READ : MAY_WRITE);
 406         if (retval)
 407                 return retval;
 408         return count > MAX_RW_COUNT ? MAX_RW_COUNT : count;
 409 }
 410
 411 static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
 412 {
 413         struct iovec iov = { .iov_base = buf, .iov_len = len };
 414         struct kiocb kiocb;
 415         struct iov_iter iter;
 416         ssize_t ret;
 417
 418         init_sync_kiocb(&kiocb, filp);
 419         kiocb.ki_pos = *ppos;
 420         iov_iter_init(&iter, READ, &iov, 1, len);
 421
 422         ret = filp->f_op->read_iter(&kiocb, &iter);
 423         BUG_ON(ret == -EIOCBQUEUED);
 424         *ppos = kiocb.ki_pos;
 425         return ret;
 426 }
 427
 428 ssize_t __vfs_read(struct file *file, char __user *buf, size_t count,
 429                    loff_t *pos)
 430 {
 431         if (file->f_op->read)
 432                 return file->f_op->read(file, buf, count, pos);
 433         else if (file->f_op->read_iter)
 434                 return new_sync_read(file, buf, count, pos);
 435         else
 436                 return -EINVAL;
 437 }
 438 EXPORT_SYMBOL(__vfs_read);
 439
 440 ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
 441 {
 442         ssize_t ret;
 443
 444         if (!(file->f_mode & FMODE_READ))
 445                 return -EBADF;
 446         if (!(file->f_mode & FMODE_CAN_READ))
 447                 return -EINVAL;
 448         if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
 449                 return -EFAULT;
 450
 451         ret = rw_verify_area(READ, file, pos, count);
 452         if (ret >= 0) {
 453                 count = ret;
 454                 ret = __vfs_read(file, buf, count, pos);
 455                 if (ret > 0) {
 456                         fsnotify_access(file);
 457                         add_rchar(current, ret);
 458                 }
 459                 inc_syscr(current);
 460         }
 461
 462         return ret;
 463 }
 464
 465 EXPORT_SYMBOL(vfs_read);
 466
 467 static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
 468 {
 469         struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
 470         struct kiocb kiocb;
 471         struct iov_iter iter;
 472         ssize_t ret;
 473
 474         init_sync_kiocb(&kiocb, filp);
 475         kiocb.ki_pos = *ppos;
 476         iov_iter_init(&iter, WRITE, &iov, 1, len);
 477
 478         ret = filp->f_op->write_iter(&kiocb, &iter);
 479         BUG_ON(ret == -EIOCBQUEUED);
 480         if (ret > 0)
 481                 *ppos = kiocb.ki_pos;
 482         return ret;
 483 }
 484
 485 ssize_t __vfs_write(struct file *file, const char __user *p, size_t count,
 486                     loff_t *pos)
 487 {
 488         if (file->f_op->write)
 489                 return file->f_op->write(file, p, count, pos);
 490         else if (file->f_op->write_iter)
 491                 return new_sync_write(file, p, count, pos);
 492         else
 493                 return -EINVAL;
 494 }
 495 EXPORT_SYMBOL(__vfs_write);
 496
 497 ssize_t __kernel_write(struct file *file, const char *buf, size_t count, loff_t *pos)
 498 {
 499         mm_segment_t old_fs;
 500         const char __user *p;
 501         ssize_t ret;
 502
 503         if (!(file->f_mode & FMODE_CAN_WRITE))
 504                 return -EINVAL;
 505
 506         old_fs = get_fs();
 507         set_fs(get_ds());
 508         p = (__force const char __user *)buf;
 509         if (count > MAX_RW_COUNT)
 510                 count =  MAX_RW_COUNT;
 511         ret = __vfs_write(file, p, count, pos);
 512         set_fs(old_fs);
 513         if (ret > 0) {
 514                 fsnotify_modify(file);
 515                 add_wchar(current, ret);
 516         }
 517         inc_syscw(current);
 518         return ret;
 519 }
 520
 521 EXPORT_SYMBOL(__kernel_write);
 522
 523 ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
 524 {
 525         ssize_t ret;
 526
 527         if (!(file->f_mode & FMODE_WRITE))
 528                 return -EBADF;
 529         if (!(file->f_mode & FMODE_CAN_WRITE))
 530                 return -EINVAL;
 531         if (unlikely(!access_ok(VERIFY_READ, buf, count)))
 532                 return -EFAULT;
 533
 534         ret = rw_verify_area(WRITE, file, pos, count);
 535         if (ret >= 0) {
 536                 count = ret;
 537                 file_start_write(file);
 538                 ret = __vfs_write(file, buf, count, pos);
 539                 if (ret > 0) {
 540                         fsnotify_modify(file);
 541                         add_wchar(current, ret);
 542                 }
 543                 inc_syscw(current);
 544                 file_end_write(file);
 545         }
 546
 547         return ret;
 548 }
 549
 550 EXPORT_SYMBOL(vfs_write);
 551
 552 static inline loff_t file_pos_read(struct file *file)
 553 {
 554         return file->f_pos;
 555 }
 556
 557 static inline void file_pos_write(struct file *file, loff_t pos)
 558 {
 559         file->f_pos = pos;
 560 }
 561
 562 SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
 563 {
 564         struct fd f = fdget_pos(fd);
 565         ssize_t ret = -EBADF;
 566
 567         if (f.file) {
 568                 loff_t pos = file_pos_read(f.file);
 569                 ret = vfs_read(f.file, buf, count, &pos);
 570                 if (ret >= 0)
 571                         file_pos_write(f.file, pos);
 572                 fdput_pos(f);
 573         }
 574         return ret;
 575 }
 576
 577 SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
 578                 size_t, count)
 579 {
 580         struct fd f = fdget_pos(fd);
 581         ssize_t ret = -EBADF;
 582
 583         if (f.file) {
 584                 loff_t pos = file_pos_read(f.file);
 585                 ret = vfs_write(f.file, buf, count, &pos);
 586                 if (ret >= 0)
 587                         file_pos_write(f.file, pos);
 588                 fdput_pos(f);
 589         }
 590
 591         return ret;
 592 }
 593
 594 SYSCALL_DEFINE4(pread64, unsigned int, fd, 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_PREAD)
 607                         ret = vfs_read(f.file, buf, count, &pos);
 608                 fdput(f);
 609         }
 610
 611         return ret;
 612 }
 613
 614 SYSCALL_DEFINE4(pwrite64, unsigned int, fd, const char __user *, buf,
 615                          size_t, count, loff_t, pos)
 616 {
 617         struct fd f;
 618         ssize_t ret = -EBADF;
 619
 620         if (pos < 0)
 621                 return -EINVAL;
 622
 623         f = fdget(fd);
 624         if (f.file) {
 625                 ret = -ESPIPE;
 626                 if (f.file->f_mode & FMODE_PWRITE)
 627                         ret = vfs_write(f.file, buf, count, &pos);
 628                 fdput(f);
 629         }
 630
 631         return ret;
 632 }
 633
 634 /*
 635  * Reduce an iovec's length in-place.  Return the resulting number of segments
 636  */
 637 unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to)
 638 {
 639         unsigned long seg = 0;
 640         size_t len = 0;
 641
 642         while (seg < nr_segs) {
 643                 seg++;
 644                 if (len + iov->iov_len >= to) {
 645                         iov->iov_len = to - len;
 646                         break;
 647                 }
 648                 len += iov->iov_len;
 649                 iov++;
 650         }
 651         return seg;
 652 }
 653 EXPORT_SYMBOL(iov_shorten);
 654
 655 static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,
 656                 loff_t *ppos, iter_fn_t fn)
 657 {
 658         struct kiocb kiocb;
 659         ssize_t ret;
 660
 661         init_sync_kiocb(&kiocb, filp);
 662         kiocb.ki_pos = *ppos;
 663
 664         ret = fn(&kiocb, iter);
 665         BUG_ON(ret == -EIOCBQUEUED);
 666         *ppos = kiocb.ki_pos;
 667         return ret;
 668 }
 669
 670 /* Do it by hand, with file-ops */
 671 static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,
 672                 loff_t *ppos, io_fn_t fn)
 673 {
 674         ssize_t ret = 0;
 675
 676         while (iov_iter_count(iter)) {
 677                 struct iovec iovec = iov_iter_iovec(iter);
 678                 ssize_t nr;
 679
 680                 nr = fn(filp, iovec.iov_base, iovec.iov_len, ppos);
 681
 682                 if (nr < 0) {
 683                         if (!ret)
 684                                 ret = nr;
 685                         break;
 686                 }
 687                 ret += nr;
 688                 if (nr != iovec.iov_len)
 689                         break;
 690                 iov_iter_advance(iter, nr);
 691         }
 692
 693         return ret;
 694 }
 695
 696 /* A write operation does a read from user space and vice versa */
 697 #define vrfy_dir(type) ((type) == READ ? VERIFY_WRITE : VERIFY_READ)
 698
 699 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
 700                               unsigned long nr_segs, unsigned long fast_segs,
 701                               struct iovec *fast_pointer,
 702                               struct iovec **ret_pointer)
 703 {
 704         unsigned long seg;
 705         ssize_t ret;
 706         struct iovec *iov = fast_pointer;
 707
 708         /*
 709          * SuS says "The readv() function *may* fail if the iovcnt argument
 710          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
 711          * traditionally returned zero for zero segments, so...
 712          */
 713         if (nr_segs == 0) {
 714                 ret = 0;
 715                 goto out;
 716         }
 717
 718         /*
 719          * First get the "struct iovec" from user memory and
 720          * verify all the pointers
 721          */
 722         if (nr_segs > UIO_MAXIOV) {
 723                 ret = -EINVAL;
 724                 goto out;
 725         }
 726         if (nr_segs > fast_segs) {
 727                 iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
 728                 if (iov == NULL) {
 729                         ret = -ENOMEM;
 730                         goto out;
 731                 }
 732         }
 733         if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
 734                 ret = -EFAULT;
 735                 goto out;
 736         }
 737
 738         /*
 739          * According to the Single Unix Specification we should return EINVAL
 740          * if an element length is < 0 when cast to ssize_t or if the
 741          * total length would overflow the ssize_t return value of the
 742          * system call.
 743          *
 744          * Linux caps all read/write calls to MAX_RW_COUNT, and avoids the
 745          * overflow case.
 746          */
 747         ret = 0;
 748         for (seg = 0; seg < nr_segs; seg++) {
 749                 void __user *buf = iov[seg].iov_base;
 750                 ssize_t len = (ssize_t)iov[seg].iov_len;
 751
 752                 /* see if we we're about to use an invalid len or if
 753                  * it's about to overflow ssize_t */
 754                 if (len < 0) {
 755                         ret = -EINVAL;
 756                         goto out;
 757                 }
 758                 if (type >= 0
 759                     && unlikely(!access_ok(vrfy_dir(type), buf, len))) {
 760                         ret = -EFAULT;
 761                         goto out;
 762                 }
 763                 if (len > MAX_RW_COUNT - ret) {
 764                         len = MAX_RW_COUNT - ret;
 765                         iov[seg].iov_len = len;
 766                 }
 767                 ret += len;
 768         }
 769 out:
 770         *ret_pointer = iov;
 771         return ret;
 772 }
 773
 774 static ssize_t do_readv_writev(int type, struct file *file,
 775                                const struct iovec __user * uvector,
 776                                unsigned long nr_segs, loff_t *pos)
 777 {
 778         size_t tot_len;
 779         struct iovec iovstack[UIO_FASTIOV];
 780         struct iovec *iov = iovstack;
 781         struct iov_iter iter;
 782         ssize_t ret;
 783         io_fn_t fn;
 784         iter_fn_t iter_fn;
 785
 786         ret = import_iovec(type, uvector, nr_segs,
 787                            ARRAY_SIZE(iovstack), &iov, &iter);
 788         if (ret < 0)
 789                 return ret;
 790
 791         tot_len = iov_iter_count(&iter);
 792         if (!tot_len)
 793                 goto out;
 794         ret = rw_verify_area(type, file, pos, tot_len);
 795         if (ret < 0)
 796                 goto out;
 797
 798         if (type == READ) {
 799                 fn = file->f_op->read;
 800                 iter_fn = file->f_op->read_iter;
 801         } else {
 802                 fn = (io_fn_t)file->f_op->write;
 803                 iter_fn = file->f_op->write_iter;
 804                 file_start_write(file);
 805         }
 806
 807         if (iter_fn)
 808                 ret = do_iter_readv_writev(file, &iter, pos, iter_fn);
 809         else
 810                 ret = do_loop_readv_writev(file, &iter, pos, fn);
 811
 812         if (type != READ)
 813                 file_end_write(file);
 814
 815 out:
 816         kfree(iov);
 817         if ((ret + (type == READ)) > 0) {
 818                 if (type == READ)
 819                         fsnotify_access(file);
 820                 else
 821                         fsnotify_modify(file);
 822         }
 823         return ret;
 824 }
 825
 826 ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
 827                   unsigned long vlen, loff_t *pos)
 828 {
 829         if (!(file->f_mode & FMODE_READ))
 830                 return -EBADF;
 831         if (!(file->f_mode & FMODE_CAN_READ))
 832                 return -EINVAL;
 833
 834         return do_readv_writev(READ, file, vec, vlen, pos);
 835 }
 836
 837 EXPORT_SYMBOL(vfs_readv);
 838
 839 ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
 840                    unsigned long vlen, loff_t *pos)
 841 {
 842         if (!(file->f_mode & FMODE_WRITE))
 843                 return -EBADF;
 844         if (!(file->f_mode & FMODE_CAN_WRITE))
 845                 return -EINVAL;
 846
 847         return do_readv_writev(WRITE, file, vec, vlen, pos);
 848 }
 849
 850 EXPORT_SYMBOL(vfs_writev);
 851
 852 SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
 853                 unsigned long, vlen)
 854 {
 855         struct fd f = fdget_pos(fd);
 856         ssize_t ret = -EBADF;
 857
 858         if (f.file) {
 859                 loff_t pos = file_pos_read(f.file);
 860                 ret = vfs_readv(f.file, vec, vlen, &pos);
 861                 if (ret >= 0)
 862                         file_pos_write(f.file, pos);
 863                 fdput_pos(f);
 864         }
 865
 866         if (ret > 0)
 867                 add_rchar(current, ret);
 868         inc_syscr(current);
 869         return ret;
 870 }
 871
 872 SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *, vec,
 873                 unsigned long, vlen)
 874 {
 875         struct fd f = fdget_pos(fd);
 876         ssize_t ret = -EBADF;
 877
 878         if (f.file) {
 879                 loff_t pos = file_pos_read(f.file);
 880                 ret = vfs_writev(f.file, vec, vlen, &pos);
 881                 if (ret >= 0)
 882                         file_pos_write(f.file, pos);
 883                 fdput_pos(f);
 884         }
 885
 886         if (ret > 0)
 887                 add_wchar(current, ret);
 888         inc_syscw(current);
 889         return ret;
 890 }
 891
 892 static inline loff_t pos_from_hilo(unsigned long high, unsigned long low)
 893 {
 894 #define HALF_LONG_BITS (BITS_PER_LONG / 2)
 895         return (((loff_t)high << HALF_LONG_BITS) << HALF_LONG_BITS) | low;
 896 }
 897
 898 SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
 899                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
 900 {
 901         loff_t pos = pos_from_hilo(pos_h, pos_l);
 902         struct fd f;
 903         ssize_t ret = -EBADF;
 904
 905         if (pos < 0)
 906                 return -EINVAL;
 907
 908         f = fdget(fd);
 909         if (f.file) {
 910                 ret = -ESPIPE;
 911                 if (f.file->f_mode & FMODE_PREAD)
 912                         ret = vfs_readv(f.file, vec, vlen, &pos);
 913                 fdput(f);
 914         }
 915
 916         if (ret > 0)
 917                 add_rchar(current, ret);
 918         inc_syscr(current);
 919         return ret;
 920 }
 921
 922 SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
 923                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
 924 {
 925         loff_t pos = pos_from_hilo(pos_h, pos_l);
 926         struct fd f;
 927         ssize_t ret = -EBADF;
 928
 929         if (pos < 0)
 930                 return -EINVAL;
 931
 932         f = fdget(fd);
 933         if (f.file) {
 934                 ret = -ESPIPE;
 935                 if (f.file->f_mode & FMODE_PWRITE)
 936                         ret = vfs_writev(f.file, vec, vlen, &pos);
 937                 fdput(f);
 938         }
 939
 940         if (ret > 0)
 941                 add_wchar(current, ret);
 942         inc_syscw(current);
 943         return ret;
 944 }
 945
 946 #ifdef CONFIG_COMPAT
 947
 948 static ssize_t compat_do_readv_writev(int type, struct file *file,
 949                                const struct compat_iovec __user *uvector,
 950                                unsigned long nr_segs, loff_t *pos)
 951 {
 952         compat_ssize_t tot_len;
 953         struct iovec iovstack[UIO_FASTIOV];
 954         struct iovec *iov = iovstack;
 955         struct iov_iter iter;
 956         ssize_t ret;
 957         io_fn_t fn;
 958         iter_fn_t iter_fn;
 959
 960         ret = compat_import_iovec(type, uvector, nr_segs,
 961                                   UIO_FASTIOV, &iov, &iter);
 962         if (ret < 0)
 963                 return ret;
 964
 965         tot_len = iov_iter_count(&iter);
 966         if (!tot_len)
 967                 goto out;
 968         ret = rw_verify_area(type, file, pos, tot_len);
 969         if (ret < 0)
 970                 goto out;
 971
 972         if (type == READ) {
 973                 fn = file->f_op->read;
 974                 iter_fn = file->f_op->read_iter;
 975         } else {
 976                 fn = (io_fn_t)file->f_op->write;
 977                 iter_fn = file->f_op->write_iter;
 978                 file_start_write(file);
 979         }
 980
 981         if (iter_fn)
 982                 ret = do_iter_readv_writev(file, &iter, pos, iter_fn);
 983         else
 984                 ret = do_loop_readv_writev(file, &iter, pos, fn);
 985
 986         if (type != READ)
 987                 file_end_write(file);
 988
 989 out:
 990         kfree(iov);
 991         if ((ret + (type == READ)) > 0) {
 992                 if (type == READ)
 993                         fsnotify_access(file);
 994                 else
 995                         fsnotify_modify(file);
 996         }
 997         return ret;
 998 }
 999
1000 static size_t compat_readv(struct file *file,
1001                            const struct compat_iovec __user *vec,
1002                            unsigned long vlen, loff_t *pos)
1003 {
1004         ssize_t ret = -EBADF;
1005
1006         if (!(file->f_mode & FMODE_READ))
1007                 goto out;
1008
1009         ret = -EINVAL;
1010         if (!(file->f_mode & FMODE_CAN_READ))
1011                 goto out;
1012
1013         ret = compat_do_readv_writev(READ, file, vec, vlen, pos);
1014
1015 out:
1016         if (ret > 0)
1017                 add_rchar(current, ret);
1018         inc_syscr(current);
1019         return ret;
1020 }
1021
1022 COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
1023                 const struct compat_iovec __user *,vec,
1024                 compat_ulong_t, vlen)
1025 {
1026         struct fd f = fdget_pos(fd);
1027         ssize_t ret;
1028         loff_t pos;
1029
1030         if (!f.file)
1031                 return -EBADF;
1032         pos = f.file->f_pos;
1033         ret = compat_readv(f.file, vec, vlen, &pos);
1034         if (ret >= 0)
1035                 f.file->f_pos = pos;
1036         fdput_pos(f);
1037         return ret;
1038 }
1039
1040 static long __compat_sys_preadv64(unsigned long fd,
1041                                   const struct compat_iovec __user *vec,
1042                                   unsigned long vlen, loff_t pos)
1043 {
1044         struct fd f;
1045         ssize_t ret;
1046
1047         if (pos < 0)
1048                 return -EINVAL;
1049         f = fdget(fd);
1050         if (!f.file)
1051                 return -EBADF;
1052         ret = -ESPIPE;
1053         if (f.file->f_mode & FMODE_PREAD)
1054                 ret = compat_readv(f.file, vec, vlen, &pos);
1055         fdput(f);
1056         return ret;
1057 }
1058
1059 #ifdef __ARCH_WANT_COMPAT_SYS_PREADV64
1060 COMPAT_SYSCALL_DEFINE4(preadv64, unsigned long, fd,
1061                 const struct compat_iovec __user *,vec,
1062                 unsigned long, vlen, loff_t, pos)
1063 {
1064         return __compat_sys_preadv64(fd, vec, vlen, pos);
1065 }
1066 #endif
1067
1068 COMPAT_SYSCALL_DEFINE5(preadv, compat_ulong_t, fd,
1069                 const struct compat_iovec __user *,vec,
1070                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high)
1071 {
1072         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1073
1074         return __compat_sys_preadv64(fd, vec, vlen, pos);
1075 }
1076
1077 static size_t compat_writev(struct file *file,
1078                             const struct compat_iovec __user *vec,
1079                             unsigned long vlen, loff_t *pos)
1080 {
1081         ssize_t ret = -EBADF;
1082
1083         if (!(file->f_mode & FMODE_WRITE))
1084                 goto out;
1085
1086         ret = -EINVAL;
1087         if (!(file->f_mode & FMODE_CAN_WRITE))
1088                 goto out;
1089
1090         ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos);
1091
1092 out:
1093         if (ret > 0)
1094                 add_wchar(current, ret);
1095         inc_syscw(current);
1096         return ret;
1097 }
1098
1099 COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
1100                 const struct compat_iovec __user *, vec,
1101                 compat_ulong_t, vlen)
1102 {
1103         struct fd f = fdget_pos(fd);
1104         ssize_t ret;
1105         loff_t pos;
1106
1107         if (!f.file)
1108                 return -EBADF;
1109         pos = f.file->f_pos;
1110         ret = compat_writev(f.file, vec, vlen, &pos);
1111         if (ret >= 0)
1112                 f.file->f_pos = pos;
1113         fdput_pos(f);
1114         return ret;
1115 }
1116
1117 static long __compat_sys_pwritev64(unsigned long fd,
1118                                    const struct compat_iovec __user *vec,
1119                                    unsigned long vlen, loff_t pos)
1120 {
1121         struct fd f;
1122         ssize_t ret;
1123
1124         if (pos < 0)
1125                 return -EINVAL;
1126         f = fdget(fd);
1127         if (!f.file)
1128                 return -EBADF;
1129         ret = -ESPIPE;
1130         if (f.file->f_mode & FMODE_PWRITE)
1131                 ret = compat_writev(f.file, vec, vlen, &pos);
1132         fdput(f);
1133         return ret;
1134 }
1135
1136 #ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64
1137 COMPAT_SYSCALL_DEFINE4(pwritev64, unsigned long, fd,
1138                 const struct compat_iovec __user *,vec,
1139                 unsigned long, vlen, loff_t, pos)
1140 {
1141         return __compat_sys_pwritev64(fd, vec, vlen, pos);
1142 }
1143 #endif
1144
1145 COMPAT_SYSCALL_DEFINE5(pwritev, compat_ulong_t, fd,
1146                 const struct compat_iovec __user *,vec,
1147                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high)
1148 {
1149         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1150
1151         return __compat_sys_pwritev64(fd, vec, vlen, pos);
1152 }
1153 #endif
1154
1155 static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
1156                            size_t count, loff_t max)
1157 {
1158         struct fd in, out;
1159         struct inode *in_inode, *out_inode;
1160         loff_t pos;
1161         loff_t out_pos;
1162         ssize_t retval;
1163         int fl;
1164
1165         /*
1166          * Get input file, and verify that it is ok..
1167          */
1168         retval = -EBADF;
1169         in = fdget(in_fd);
1170         if (!in.file)
1171                 goto out;
1172         if (!(in.file->f_mode & FMODE_READ))
1173                 goto fput_in;
1174         retval = -ESPIPE;
1175         if (!ppos) {
1176                 pos = in.file->f_pos;
1177         } else {
1178                 pos = *ppos;
1179                 if (!(in.file->f_mode & FMODE_PREAD))
1180                         goto fput_in;
1181         }
1182         retval = rw_verify_area(READ, in.file, &pos, count);
1183         if (retval < 0)
1184                 goto fput_in;
1185         count = retval;
1186
1187         /*
1188          * Get output file, and verify that it is ok..
1189          */
1190         retval = -EBADF;
1191         out = fdget(out_fd);
1192         if (!out.file)
1193                 goto fput_in;
1194         if (!(out.file->f_mode & FMODE_WRITE))
1195                 goto fput_out;
1196         retval = -EINVAL;
1197         in_inode = file_inode(in.file);
1198         out_inode = file_inode(out.file);
1199         out_pos = out.file->f_pos;
1200         retval = rw_verify_area(WRITE, out.file, &out_pos, count);
1201         if (retval < 0)
1202                 goto fput_out;
1203         count = retval;
1204
1205         if (!max)
1206                 max = min(in_inode->i_sb->s_maxbytes, out_inode->i_sb->s_maxbytes);
1207
1208         if (unlikely(pos + count > max)) {
1209                 retval = -EOVERFLOW;
1210                 if (pos >= max)
1211                         goto fput_out;
1212                 count = max - pos;
1213         }
1214
1215         fl = 0;
1216 #if 0
1217         /*
1218          * We need to debate whether we can enable this or not. The
1219          * man page documents EAGAIN return for the output at least,
1220          * and the application is arguably buggy if it doesn't expect
1221          * EAGAIN on a non-blocking file descriptor.
1222          */
1223         if (in.file->f_flags & O_NONBLOCK)
1224                 fl = SPLICE_F_NONBLOCK;
1225 #endif
1226         file_start_write(out.file);
1227         retval = do_splice_direct(in.file, &pos, out.file, &out_pos, count, fl);
1228         file_end_write(out.file);
1229
1230         if (retval > 0) {
1231                 add_rchar(current, retval);
1232                 add_wchar(current, retval);
1233                 fsnotify_access(in.file);
1234                 fsnotify_modify(out.file);
1235                 out.file->f_pos = out_pos;
1236                 if (ppos)
1237                         *ppos = pos;
1238                 else
1239                         in.file->f_pos = pos;
1240         }
1241
1242         inc_syscr(current);
1243         inc_syscw(current);
1244         if (pos > max)
1245                 retval = -EOVERFLOW;
1246
1247 fput_out:
1248         fdput(out);
1249 fput_in:
1250         fdput(in);
1251 out:
1252         return retval;
1253 }
1254
1255 SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd, off_t __user *, offset, size_t, count)
1256 {
1257         loff_t pos;
1258         off_t off;
1259         ssize_t ret;
1260
1261         if (offset) {
1262                 if (unlikely(get_user(off, offset)))
1263                         return -EFAULT;
1264                 pos = off;
1265                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
1266                 if (unlikely(put_user(pos, offset)))
1267                         return -EFAULT;
1268                 return ret;
1269         }
1270
1271         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1272 }
1273
1274 SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, loff_t __user *, offset, size_t, count)
1275 {
1276         loff_t pos;
1277         ssize_t ret;
1278
1279         if (offset) {
1280                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1281                         return -EFAULT;
1282                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1283                 if (unlikely(put_user(pos, offset)))
1284                         return -EFAULT;
1285                 return ret;
1286         }
1287
1288         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1289 }
1290
1291 #ifdef CONFIG_COMPAT
1292 COMPAT_SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd,
1293                 compat_off_t __user *, offset, compat_size_t, count)
1294 {
1295         loff_t pos;
1296         off_t off;
1297         ssize_t ret;
1298
1299         if (offset) {
1300                 if (unlikely(get_user(off, offset)))
1301                         return -EFAULT;
1302                 pos = off;
1303                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
1304                 if (unlikely(put_user(pos, offset)))
1305                         return -EFAULT;
1306                 return ret;
1307         }
1308
1309         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1310 }
1311
1312 COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd,
1313                 compat_loff_t __user *, offset, compat_size_t, count)
1314 {
1315         loff_t pos;
1316         ssize_t ret;
1317
1318         if (offset) {
1319                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1320                         return -EFAULT;
1321                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1322                 if (unlikely(put_user(pos, offset)))
1323                         return -EFAULT;
1324                 return ret;
1325         }
1326
1327         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1328 }
1329 #endif
1330
1331 /*
1332  * copy_file_range() differs from regular file read and write in that it
1333  * specifically allows return partial success.  When it does so is up to
1334  * the copy_file_range method.
1335  */
1336 ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,
1337                             struct file *file_out, loff_t pos_out,
1338                             size_t len, unsigned int flags)
1339 {
1340         struct inode *inode_in = file_inode(file_in);
1341         struct inode *inode_out = file_inode(file_out);
1342         ssize_t ret;
1343
1344         if (flags != 0)
1345                 return -EINVAL;
1346
1347         /* copy_file_range allows full ssize_t len, ignoring MAX_RW_COUNT  */
1348         ret = rw_verify_area(READ, file_in, &pos_in, len);
1349         if (ret >= 0)
1350                 ret = rw_verify_area(WRITE, file_out, &pos_out, len);
1351         if (ret < 0)
1352                 return ret;
1353
1354         if (!(file_in->f_mode & FMODE_READ) ||
1355             !(file_out->f_mode & FMODE_WRITE) ||
1356             (file_out->f_flags & O_APPEND))
1357                 return -EBADF;
1358
1359         /* this could be relaxed once a method supports cross-fs copies */
1360         if (inode_in->i_sb != inode_out->i_sb)
1361                 return -EXDEV;
1362
1363         if (len == 0)
1364                 return 0;
1365
1366         ret = mnt_want_write_file(file_out);
1367         if (ret)
1368                 return ret;
1369
1370         ret = -EOPNOTSUPP;
1371         if (file_out->f_op->copy_file_range)
1372                 ret = file_out->f_op->copy_file_range(file_in, pos_in, file_out,
1373                                                       pos_out, len, flags);
1374         if (ret == -EOPNOTSUPP)
1375                 ret = do_splice_direct(file_in, &pos_in, file_out, &pos_out,
1376                                 len > MAX_RW_COUNT ? MAX_RW_COUNT : len, 0);
1377
1378         if (ret > 0) {
1379                 fsnotify_access(file_in);
1380                 add_rchar(current, ret);
1381                 fsnotify_modify(file_out);
1382                 add_wchar(current, ret);
1383         }
1384         inc_syscr(current);
1385         inc_syscw(current);
1386
1387         mnt_drop_write_file(file_out);
1388
1389         return ret;
1390 }
1391 EXPORT_SYMBOL(vfs_copy_file_range);
1392
1393 SYSCALL_DEFINE6(copy_file_range, int, fd_in, loff_t __user *, off_in,
1394                 int, fd_out, loff_t __user *, off_out,
1395                 size_t, len, unsigned int, flags)
1396 {
1397         loff_t pos_in;
1398         loff_t pos_out;
1399         struct fd f_in;
1400         struct fd f_out;
1401         ssize_t ret = -EBADF;
1402
1403         f_in = fdget(fd_in);
1404         if (!f_in.file)
1405                 goto out2;
1406
1407         f_out = fdget(fd_out);
1408         if (!f_out.file)
1409                 goto out1;
1410
1411         ret = -EFAULT;
1412         if (off_in) {
1413                 if (copy_from_user(&pos_in, off_in, sizeof(loff_t)))
1414                         goto out;
1415         } else {
1416                 pos_in = f_in.file->f_pos;
1417         }
1418
1419         if (off_out) {
1420                 if (copy_from_user(&pos_out, off_out, sizeof(loff_t)))
1421                         goto out;
1422         } else {
1423                 pos_out = f_out.file->f_pos;
1424         }
1425
1426         ret = vfs_copy_file_range(f_in.file, pos_in, f_out.file, pos_out, len,
1427                                   flags);
1428         if (ret > 0) {
1429                 pos_in += ret;
1430                 pos_out += ret;
1431
1432                 if (off_in) {
1433                         if (copy_to_user(off_in, &pos_in, sizeof(loff_t)))
1434                                 ret = -EFAULT;
1435                 } else {
1436                         f_in.file->f_pos = pos_in;
1437                 }
1438
1439                 if (off_out) {
1440                         if (copy_to_user(off_out, &pos_out, sizeof(loff_t)))
1441                                 ret = -EFAULT;
1442                 } else {
1443                         f_out.file->f_pos = pos_out;
1444                 }
1445         }
1446
1447 out:
1448         fdput(f_out);
1449 out1:
1450         fdput(f_in);
1451 out2:
1452         return ret;
1453 }
1454
1455 static int clone_verify_area(struct file *file, loff_t pos, u64 len, bool write)
1456 {
1457         struct inode *inode = file_inode(file);
1458
1459         if (unlikely(pos < 0))
1460                 return -EINVAL;
1461
1462          if (unlikely((loff_t) (pos + len) < 0))
1463                 return -EINVAL;
1464
1465         if (unlikely(inode->i_flctx && mandatory_lock(inode))) {
1466                 loff_t end = len ? pos + len - 1 : OFFSET_MAX;
1467                 int retval;
1468
1469                 retval = locks_mandatory_area(inode, file, pos, end,
1470                                 write ? F_WRLCK : F_RDLCK);
1471                 if (retval < 0)
1472                         return retval;
1473         }
1474
1475         return security_file_permission(file, write ? MAY_WRITE : MAY_READ);
1476 }
1477
1478 int vfs_clone_file_range(struct file *file_in, loff_t pos_in,
1479                 struct file *file_out, loff_t pos_out, u64 len)
1480 {
1481         struct inode *inode_in = file_inode(file_in);
1482         struct inode *inode_out = file_inode(file_out);
1483         int ret;
1484
1485         if (inode_in->i_sb != inode_out->i_sb ||
1486             file_in->f_path.mnt != file_out->f_path.mnt)
1487                 return -EXDEV;
1488
1489         if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode))
1490                 return -EISDIR;
1491         if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode))
1492                 return -EOPNOTSUPP;
1493
1494         if (!(file_in->f_mode & FMODE_READ) ||
1495             !(file_out->f_mode & FMODE_WRITE) ||
1496             (file_out->f_flags & O_APPEND) ||
1497             !file_in->f_op->clone_file_range)
1498                 return -EBADF;
1499
1500         ret = clone_verify_area(file_in, pos_in, len, false);
1501         if (ret)
1502                 return ret;
1503
1504         ret = clone_verify_area(file_out, pos_out, len, true);
1505         if (ret)
1506                 return ret;
1507
1508         if (pos_in + len > i_size_read(inode_in))
1509                 return -EINVAL;
1510
1511         ret = mnt_want_write_file(file_out);
1512         if (ret)
1513                 return ret;
1514
1515         ret = file_in->f_op->clone_file_range(file_in, pos_in,
1516                         file_out, pos_out, len);
1517         if (!ret) {
1518                 fsnotify_access(file_in);
1519                 fsnotify_modify(file_out);
1520         }
1521
1522         mnt_drop_write_file(file_out);
1523         return ret;
1524 }
1525 EXPORT_SYMBOL(vfs_clone_file_range);