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