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