fs/read_write.c

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