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