fs/read_write.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/fs/read_write.c
   4  *
   5  *  Copyright (C) 1991, 1992  Linus Torvalds
   6  */
   7
   8 #include <linux/slab.h>
   9 #include <linux/stat.h>
  10 #include <linux/sched/xacct.h>
  11 #include <linux/fcntl.h>
  12 #include <linux/file.h>
  13 #include <linux/uio.h>
  14 #include <linux/fsnotify.h>
  15 #include <linux/security.h>
  16 #include <linux/export.h>
  17 #include <linux/syscalls.h>
  18 #include <linux/pagemap.h>
  19 #include <linux/splice.h>
  20 #include <linux/compat.h>
  21 #include <linux/mount.h>
  22 #include <linux/fs.h>
  23 #include "internal.h"
  24
  25 #include <linux/uaccess.h>
  26 #include <asm/unistd.h>
  27
  28 const struct file_operations generic_ro_fops = {
  29         .llseek         = generic_file_llseek,
  30         .read_iter      = generic_file_read_iter,
  31         .mmap           = generic_file_readonly_mmap,
  32         .splice_read    = generic_file_splice_read,
  33 };
  34
  35 EXPORT_SYMBOL(generic_ro_fops);
  36
  37 static inline bool unsigned_offsets(struct file *file)
  38 {
  39         return file->f_mode & FMODE_UNSIGNED_OFFSET;
  40 }
  41
  42 /**
  43  * vfs_setpos - update the file offset for lseek
  44  * @file:       file structure in question
  45  * @offset:     file offset to seek to
  46  * @maxsize:    maximum file size
  47  *
  48  * This is a low-level filesystem helper for updating the file offset to
  49  * the value specified by @offset if the given offset is valid and it is
  50  * not equal to the current file offset.
  51  *
  52  * Return the specified offset on success and -EINVAL on invalid offset.
  53  */
  54 loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize)
  55 {
  56         if (offset < 0 && !unsigned_offsets(file))
  57                 return -EINVAL;
  58         if (offset > maxsize)
  59                 return -EINVAL;
  60
  61         if (offset != file->f_pos) {
  62                 file->f_pos = offset;
  63                 file->f_version = 0;
  64         }
  65         return offset;
  66 }
  67 EXPORT_SYMBOL(vfs_setpos);
  68
  69 /**
  70  * generic_file_llseek_size - generic llseek implementation for regular files
  71  * @file:       file structure to seek on
  72  * @offset:     file offset to seek to
  73  * @whence:     type of seek
  74  * @size:       max size of this file in file system
  75  * @eof:        offset used for SEEK_END position
  76  *
  77  * This is a variant of generic_file_llseek that allows passing in a custom
  78  * maximum file size and a custom EOF position, for e.g. hashed directories
  79  *
  80  * Synchronization:
  81  * SEEK_SET and SEEK_END are unsynchronized (but atomic on 64bit platforms)
  82  * SEEK_CUR is synchronized against other SEEK_CURs, but not read/writes.
  83  * read/writes behave like SEEK_SET against seeks.
  84  */
  85 loff_t
  86 generic_file_llseek_size(struct file *file, loff_t offset, int whence,
  87                 loff_t maxsize, loff_t eof)
  88 {
  89         switch (whence) {
  90         case SEEK_END:
  91                 offset += eof;
  92                 break;
  93         case SEEK_CUR:
  94                 /*
  95                  * Here we special-case the lseek(fd, 0, SEEK_CUR)
  96                  * position-querying operation.  Avoid rewriting the "same"
  97                  * f_pos value back to the file because a concurrent read(),
  98                  * write() or lseek() might have altered it
  99                  */
 100                 if (offset == 0)
 101                         return file->f_pos;
 102                 /*
 103                  * f_lock protects against read/modify/write race with other
 104                  * SEEK_CURs. Note that parallel writes and reads behave
 105                  * like SEEK_SET.
 106                  */
 107                 spin_lock(&file->f_lock);
 108                 offset = vfs_setpos(file, file->f_pos + offset, maxsize);
 109                 spin_unlock(&file->f_lock);
 110                 return offset;
 111         case SEEK_DATA:
 112                 /*
 113                  * In the generic case the entire file is data, so as long as
 114                  * offset isn't at the end of the file then the offset is data.
 115                  */
 116                 if ((unsigned long long)offset >= eof)
 117                         return -ENXIO;
 118                 break;
 119         case SEEK_HOLE:
 120                 /*
 121                  * There is a virtual hole at the end of the file, so as long as
 122                  * offset isn't i_size or larger, return i_size.
 123                  */
 124                 if ((unsigned long long)offset >= eof)
 125                         return -ENXIO;
 126                 offset = eof;
 127                 break;
 128         }
 129
 130         return vfs_setpos(file, offset, maxsize);
 131 }
 132 EXPORT_SYMBOL(generic_file_llseek_size);
 133
 134 /**
 135  * generic_file_llseek - generic llseek implementation for regular files
 136  * @file:       file structure to seek on
 137  * @offset:     file offset to seek to
 138  * @whence:     type of seek
 139  *
 140  * This is a generic implemenation of ->llseek useable for all normal local
 141  * filesystems.  It just updates the file offset to the value specified by
 142  * @offset and @whence.
 143  */
 144 loff_t generic_file_llseek(struct file *file, loff_t offset, int whence)
 145 {
 146         struct inode *inode = file->f_mapping->host;
 147
 148         return generic_file_llseek_size(file, offset, whence,
 149                                         inode->i_sb->s_maxbytes,
 150                                         i_size_read(inode));
 151 }
 152 EXPORT_SYMBOL(generic_file_llseek);
 153
 154 /**
 155  * fixed_size_llseek - llseek implementation for fixed-sized devices
 156  * @file:       file structure to seek on
 157  * @offset:     file offset to seek to
 158  * @whence:     type of seek
 159  * @size:       size of the file
 160  *
 161  */
 162 loff_t fixed_size_llseek(struct file *file, loff_t offset, int whence, loff_t size)
 163 {
 164         switch (whence) {
 165         case SEEK_SET: case SEEK_CUR: case SEEK_END:
 166                 return generic_file_llseek_size(file, offset, whence,
 167                                                 size, size);
 168         default:
 169                 return -EINVAL;
 170         }
 171 }
 172 EXPORT_SYMBOL(fixed_size_llseek);
 173
 174 /**
 175  * no_seek_end_llseek - llseek implementation for fixed-sized devices
 176  * @file:       file structure to seek on
 177  * @offset:     file offset to seek to
 178  * @whence:     type of seek
 179  *
 180  */
 181 loff_t no_seek_end_llseek(struct file *file, loff_t offset, int whence)
 182 {
 183         switch (whence) {
 184         case SEEK_SET: case SEEK_CUR:
 185                 return generic_file_llseek_size(file, offset, whence,
 186                                                 OFFSET_MAX, 0);
 187         default:
 188                 return -EINVAL;
 189         }
 190 }
 191 EXPORT_SYMBOL(no_seek_end_llseek);
 192
 193 /**
 194  * no_seek_end_llseek_size - llseek implementation for fixed-sized devices
 195  * @file:       file structure to seek on
 196  * @offset:     file offset to seek to
 197  * @whence:     type of seek
 198  * @size:       maximal offset allowed
 199  *
 200  */
 201 loff_t no_seek_end_llseek_size(struct file *file, loff_t offset, int whence, loff_t size)
 202 {
 203         switch (whence) {
 204         case SEEK_SET: case SEEK_CUR:
 205                 return generic_file_llseek_size(file, offset, whence,
 206                                                 size, 0);
 207         default:
 208                 return -EINVAL;
 209         }
 210 }
 211 EXPORT_SYMBOL(no_seek_end_llseek_size);
 212
 213 /**
 214  * noop_llseek - No Operation Performed llseek implementation
 215  * @file:       file structure to seek on
 216  * @offset:     file offset to seek to
 217  * @whence:     type of seek
 218  *
 219  * This is an implementation of ->llseek useable for the rare special case when
 220  * userspace expects the seek to succeed but the (device) file is actually not
 221  * able to perform the seek. In this case you use noop_llseek() instead of
 222  * falling back to the default implementation of ->llseek.
 223  */
 224 loff_t noop_llseek(struct file *file, loff_t offset, int whence)
 225 {
 226         return file->f_pos;
 227 }
 228 EXPORT_SYMBOL(noop_llseek);
 229
 230 loff_t no_llseek(struct file *file, loff_t offset, int whence)
 231 {
 232         return -ESPIPE;
 233 }
 234 EXPORT_SYMBOL(no_llseek);
 235
 236 loff_t default_llseek(struct file *file, loff_t offset, int whence)
 237 {
 238         struct inode *inode = file_inode(file);
 239         loff_t retval;
 240
 241         inode_lock(inode);
 242         switch (whence) {
 243                 case SEEK_END:
 244                         offset += i_size_read(inode);
 245                         break;
 246                 case SEEK_CUR:
 247                         if (offset == 0) {
 248                                 retval = file->f_pos;
 249                                 goto out;
 250                         }
 251                         offset += file->f_pos;
 252                         break;
 253                 case SEEK_DATA:
 254                         /*
 255                          * In the generic case the entire file is data, so as
 256                          * long as offset isn't at the end of the file then the
 257                          * offset is data.
 258                          */
 259                         if (offset >= inode->i_size) {
 260                                 retval = -ENXIO;
 261                                 goto out;
 262                         }
 263                         break;
 264                 case SEEK_HOLE:
 265                         /*
 266                          * There is a virtual hole at the end of the file, so
 267                          * as long as offset isn't i_size or larger, return
 268                          * i_size.
 269                          */
 270                         if (offset >= inode->i_size) {
 271                                 retval = -ENXIO;
 272                                 goto out;
 273                         }
 274                         offset = inode->i_size;
 275                         break;
 276         }
 277         retval = -EINVAL;
 278         if (offset >= 0 || unsigned_offsets(file)) {
 279                 if (offset != file->f_pos) {
 280                         file->f_pos = offset;
 281                         file->f_version = 0;
 282                 }
 283                 retval = offset;
 284         }
 285 out:
 286         inode_unlock(inode);
 287         return retval;
 288 }
 289 EXPORT_SYMBOL(default_llseek);
 290
 291 loff_t vfs_llseek(struct file *file, loff_t offset, int whence)
 292 {
 293         loff_t (*fn)(struct file *, loff_t, int);
 294
 295         fn = no_llseek;
 296         if (file->f_mode & FMODE_LSEEK) {
 297                 if (file->f_op->llseek)
 298                         fn = file->f_op->llseek;
 299         }
 300         return fn(file, offset, whence);
 301 }
 302 EXPORT_SYMBOL(vfs_llseek);
 303
 304 off_t ksys_lseek(unsigned int fd, off_t offset, unsigned int whence)
 305 {
 306         off_t retval;
 307         struct fd f = fdget_pos(fd);
 308         if (!f.file)
 309                 return -EBADF;
 310
 311         retval = -EINVAL;
 312         if (whence <= SEEK_MAX) {
 313                 loff_t res = vfs_llseek(f.file, offset, whence);
 314                 retval = res;
 315                 if (res != (loff_t)retval)
 316                         retval = -EOVERFLOW;    /* LFS: should only happen on 32 bit platforms */
 317         }
 318         fdput_pos(f);
 319         return retval;
 320 }
 321
 322 SYSCALL_DEFINE3(lseek, unsigned int, fd, off_t, offset, unsigned int, whence)
 323 {
 324         return ksys_lseek(fd, offset, whence);
 325 }
 326
 327 #ifdef CONFIG_COMPAT
 328 COMPAT_SYSCALL_DEFINE3(lseek, unsigned int, fd, compat_off_t, offset, unsigned int, whence)
 329 {
 330         return ksys_lseek(fd, offset, whence);
 331 }
 332 #endif
 333
 334 #if !defined(CONFIG_64BIT) || defined(CONFIG_COMPAT) || \
 335         defined(__ARCH_WANT_SYS_LLSEEK)
 336 SYSCALL_DEFINE5(llseek, unsigned int, fd, unsigned long, offset_high,
 337                 unsigned long, offset_low, loff_t __user *, result,
 338                 unsigned int, whence)
 339 {
 340         int retval;
 341         struct fd f = fdget_pos(fd);
 342         loff_t offset;
 343
 344         if (!f.file)
 345                 return -EBADF;
 346
 347         retval = -EINVAL;
 348         if (whence > SEEK_MAX)
 349                 goto out_putf;
 350
 351         offset = vfs_llseek(f.file, ((loff_t) offset_high << 32) | offset_low,
 352                         whence);
 353
 354         retval = (int)offset;
 355         if (offset >= 0) {
 356                 retval = -EFAULT;
 357                 if (!copy_to_user(result, &offset, sizeof(offset)))
 358                         retval = 0;
 359         }
 360 out_putf:
 361         fdput_pos(f);
 362         return retval;
 363 }
 364 #endif
 365
 366 int rw_verify_area(int read_write, struct file *file, const loff_t *ppos, size_t count)
 367 {
 368         struct inode *inode;
 369         int retval = -EINVAL;
 370
 371         inode = file_inode(file);
 372         if (unlikely((ssize_t) count < 0))
 373                 return retval;
 374
 375         /*
 376          * ranged mandatory locking does not apply to streams - it makes sense
 377          * only for files where position has a meaning.
 378          */
 379         if (ppos) {
 380                 loff_t pos = *ppos;
 381
 382                 if (unlikely(pos < 0)) {
 383                         if (!unsigned_offsets(file))
 384                                 return retval;
 385                         if (count >= -pos) /* both values are in 0..LLONG_MAX */
 386                                 return -EOVERFLOW;
 387                 } else if (unlikely((loff_t) (pos + count) < 0)) {
 388                         if (!unsigned_offsets(file))
 389                                 return retval;
 390                 }
 391
 392                 if (unlikely(inode->i_flctx && mandatory_lock(inode))) {
 393                         retval = locks_mandatory_area(inode, file, pos, pos + count - 1,
 394                                         read_write == READ ? F_RDLCK : F_WRLCK);
 395                         if (retval < 0)
 396                                 return retval;
 397                 }
 398         }
 399
 400         return security_file_permission(file,
 401                                 read_write == READ ? MAY_READ : MAY_WRITE);
 402 }
 403
 404 static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
 405 {
 406         struct iovec iov = { .iov_base = buf, .iov_len = len };
 407         struct kiocb kiocb;
 408         struct iov_iter iter;
 409         ssize_t ret;
 410
 411         init_sync_kiocb(&kiocb, filp);
 412         kiocb.ki_pos = (ppos ? *ppos : 0);
 413         iov_iter_init(&iter, READ, &iov, 1, len);
 414
 415         ret = call_read_iter(filp, &kiocb, &iter);
 416         BUG_ON(ret == -EIOCBQUEUED);
 417         if (ppos)
 418                 *ppos = kiocb.ki_pos;
 419         return ret;
 420 }
 421
 422 ssize_t __vfs_read(struct file *file, char __user *buf, size_t count,
 423                    loff_t *pos)
 424 {
 425         if (file->f_op->read)
 426                 return file->f_op->read(file, buf, count, pos);
 427         else if (file->f_op->read_iter)
 428                 return new_sync_read(file, buf, count, pos);
 429         else
 430                 return -EINVAL;
 431 }
 432
 433 ssize_t kernel_read(struct file *file, void *buf, size_t count, loff_t *pos)
 434 {
 435         mm_segment_t old_fs;
 436         ssize_t result;
 437
 438         old_fs = get_fs();
 439         set_fs(KERNEL_DS);
 440         /* The cast to a user pointer is valid due to the set_fs() */
 441         result = vfs_read(file, (void __user *)buf, count, pos);
 442         set_fs(old_fs);
 443         return result;
 444 }
 445 EXPORT_SYMBOL(kernel_read);
 446
 447 ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
 448 {
 449         ssize_t ret;
 450
 451         if (!(file->f_mode & FMODE_READ))
 452                 return -EBADF;
 453         if (!(file->f_mode & FMODE_CAN_READ))
 454                 return -EINVAL;
 455         if (unlikely(!access_ok(buf, count)))
 456                 return -EFAULT;
 457
 458         ret = rw_verify_area(READ, file, pos, count);
 459         if (!ret) {
 460                 if (count > MAX_RW_COUNT)
 461                         count =  MAX_RW_COUNT;
 462                 ret = __vfs_read(file, buf, count, pos);
 463                 if (ret > 0) {
 464                         fsnotify_access(file);
 465                         add_rchar(current, ret);
 466                 }
 467                 inc_syscr(current);
 468         }
 469
 470         return ret;
 471 }
 472
 473 static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
 474 {
 475         struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
 476         struct kiocb kiocb;
 477         struct iov_iter iter;
 478         ssize_t ret;
 479
 480         init_sync_kiocb(&kiocb, filp);
 481         kiocb.ki_pos = (ppos ? *ppos : 0);
 482         iov_iter_init(&iter, WRITE, &iov, 1, len);
 483
 484         ret = call_write_iter(filp, &kiocb, &iter);
 485         BUG_ON(ret == -EIOCBQUEUED);
 486         if (ret > 0 && ppos)
 487                 *ppos = kiocb.ki_pos;
 488         return ret;
 489 }
 490
 491 static ssize_t __vfs_write(struct file *file, const char __user *p,
 492                            size_t count, loff_t *pos)
 493 {
 494         if (file->f_op->write)
 495                 return file->f_op->write(file, p, count, pos);
 496         else if (file->f_op->write_iter)
 497                 return new_sync_write(file, p, count, pos);
 498         else
 499                 return -EINVAL;
 500 }
 501
 502 ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_t *pos)
 503 {
 504         mm_segment_t old_fs;
 505         const char __user *p;
 506         ssize_t ret;
 507
 508         if (WARN_ON_ONCE(!(file->f_mode & FMODE_WRITE)))
 509                 return -EBADF;
 510         if (!(file->f_mode & FMODE_CAN_WRITE))
 511                 return -EINVAL;
 512
 513         old_fs = get_fs();
 514         set_fs(KERNEL_DS);
 515         p = (__force const char __user *)buf;
 516         if (count > MAX_RW_COUNT)
 517                 count =  MAX_RW_COUNT;
 518         ret = __vfs_write(file, p, count, pos);
 519         set_fs(old_fs);
 520         if (ret > 0) {
 521                 fsnotify_modify(file);
 522                 add_wchar(current, ret);
 523         }
 524         inc_syscw(current);
 525         return ret;
 526 }
 527
 528 ssize_t kernel_write(struct file *file, const void *buf, size_t count,
 529                             loff_t *pos)
 530 {
 531         mm_segment_t old_fs;
 532         ssize_t res;
 533
 534         old_fs = get_fs();
 535         set_fs(KERNEL_DS);
 536         /* The cast to a user pointer is valid due to the set_fs() */
 537         res = vfs_write(file, (__force const char __user *)buf, count, pos);
 538         set_fs(old_fs);
 539
 540         return res;
 541 }
 542 EXPORT_SYMBOL(kernel_write);
 543
 544 ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
 545 {
 546         ssize_t ret;
 547
 548         if (!(file->f_mode & FMODE_WRITE))
 549                 return -EBADF;
 550         if (!(file->f_mode & FMODE_CAN_WRITE))
 551                 return -EINVAL;
 552         if (unlikely(!access_ok(buf, count)))
 553                 return -EFAULT;
 554
 555         ret = rw_verify_area(WRITE, file, pos, count);
 556         if (!ret) {
 557                 if (count > MAX_RW_COUNT)
 558                         count =  MAX_RW_COUNT;
 559                 file_start_write(file);
 560                 ret = __vfs_write(file, buf, count, pos);
 561                 if (ret > 0) {
 562                         fsnotify_modify(file);
 563                         add_wchar(current, ret);
 564                 }
 565                 inc_syscw(current);
 566                 file_end_write(file);
 567         }
 568
 569         return ret;
 570 }
 571
 572 /* file_ppos returns &file->f_pos or NULL if file is stream */
 573 static inline loff_t *file_ppos(struct file *file)
 574 {
 575         return file->f_mode & FMODE_STREAM ? NULL : &file->f_pos;
 576 }
 577
 578 ssize_t ksys_read(unsigned int fd, char __user *buf, size_t count)
 579 {
 580         struct fd f = fdget_pos(fd);
 581         ssize_t ret = -EBADF;
 582
 583         if (f.file) {
 584                 loff_t pos, *ppos = file_ppos(f.file);
 585                 if (ppos) {
 586                         pos = *ppos;
 587                         ppos = &pos;
 588                 }
 589                 ret = vfs_read(f.file, buf, count, ppos);
 590                 if (ret >= 0 && ppos)
 591                         f.file->f_pos = pos;
 592                 fdput_pos(f);
 593         }
 594         return ret;
 595 }
 596
 597 SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
 598 {
 599         return ksys_read(fd, buf, count);
 600 }
 601
 602 ssize_t ksys_write(unsigned int fd, const char __user *buf, size_t count)
 603 {
 604         struct fd f = fdget_pos(fd);
 605         ssize_t ret = -EBADF;
 606
 607         if (f.file) {
 608                 loff_t pos, *ppos = file_ppos(f.file);
 609                 if (ppos) {
 610                         pos = *ppos;
 611                         ppos = &pos;
 612                 }
 613                 ret = vfs_write(f.file, buf, count, ppos);
 614                 if (ret >= 0 && ppos)
 615                         f.file->f_pos = pos;
 616                 fdput_pos(f);
 617         }
 618
 619         return ret;
 620 }
 621
 622 SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
 623                 size_t, count)
 624 {
 625         return ksys_write(fd, buf, count);
 626 }
 627
 628 ssize_t ksys_pread64(unsigned int fd, char __user *buf, size_t count,
 629                      loff_t pos)
 630 {
 631         struct fd f;
 632         ssize_t ret = -EBADF;
 633
 634         if (pos < 0)
 635                 return -EINVAL;
 636
 637         f = fdget(fd);
 638         if (f.file) {
 639                 ret = -ESPIPE;
 640                 if (f.file->f_mode & FMODE_PREAD)
 641                         ret = vfs_read(f.file, buf, count, &pos);
 642                 fdput(f);
 643         }
 644
 645         return ret;
 646 }
 647
 648 SYSCALL_DEFINE4(pread64, unsigned int, fd, char __user *, buf,
 649                         size_t, count, loff_t, pos)
 650 {
 651         return ksys_pread64(fd, buf, count, pos);
 652 }
 653
 654 ssize_t ksys_pwrite64(unsigned int fd, const char __user *buf,
 655                       size_t count, loff_t pos)
 656 {
 657         struct fd f;
 658         ssize_t ret = -EBADF;
 659
 660         if (pos < 0)
 661                 return -EINVAL;
 662
 663         f = fdget(fd);
 664         if (f.file) {
 665                 ret = -ESPIPE;
 666                 if (f.file->f_mode & FMODE_PWRITE)
 667                         ret = vfs_write(f.file, buf, count, &pos);
 668                 fdput(f);
 669         }
 670
 671         return ret;
 672 }
 673
 674 SYSCALL_DEFINE4(pwrite64, unsigned int, fd, const char __user *, buf,
 675                          size_t, count, loff_t, pos)
 676 {
 677         return ksys_pwrite64(fd, buf, count, pos);
 678 }
 679
 680 static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,
 681                 loff_t *ppos, int type, rwf_t flags)
 682 {
 683         struct kiocb kiocb;
 684         ssize_t ret;
 685
 686         init_sync_kiocb(&kiocb, filp);
 687         ret = kiocb_set_rw_flags(&kiocb, flags);
 688         if (ret)
 689                 return ret;
 690         kiocb.ki_pos = (ppos ? *ppos : 0);
 691
 692         if (type == READ)
 693                 ret = call_read_iter(filp, &kiocb, iter);
 694         else
 695                 ret = call_write_iter(filp, &kiocb, iter);
 696         BUG_ON(ret == -EIOCBQUEUED);
 697         if (ppos)
 698                 *ppos = kiocb.ki_pos;
 699         return ret;
 700 }
 701
 702 /* Do it by hand, with file-ops */
 703 static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,
 704                 loff_t *ppos, int type, rwf_t flags)
 705 {
 706         ssize_t ret = 0;
 707
 708         if (flags & ~RWF_HIPRI)
 709                 return -EOPNOTSUPP;
 710
 711         while (iov_iter_count(iter)) {
 712                 struct iovec iovec = iov_iter_iovec(iter);
 713                 ssize_t nr;
 714
 715                 if (type == READ) {
 716                         nr = filp->f_op->read(filp, iovec.iov_base,
 717                                               iovec.iov_len, ppos);
 718                 } else {
 719                         nr = filp->f_op->write(filp, iovec.iov_base,
 720                                                iovec.iov_len, ppos);
 721                 }
 722
 723                 if (nr < 0) {
 724                         if (!ret)
 725                                 ret = nr;
 726                         break;
 727                 }
 728                 ret += nr;
 729                 if (nr != iovec.iov_len)
 730                         break;
 731                 iov_iter_advance(iter, nr);
 732         }
 733
 734         return ret;
 735 }
 736
 737 /**
 738  * rw_copy_check_uvector() - Copy an array of &struct iovec from userspace
 739  *     into the kernel and check that it is valid.
 740  *
 741  * @type: One of %CHECK_IOVEC_ONLY, %READ, or %WRITE.
 742  * @uvector: Pointer to the userspace array.
 743  * @nr_segs: Number of elements in userspace array.
 744  * @fast_segs: Number of elements in @fast_pointer.
 745  * @fast_pointer: Pointer to (usually small on-stack) kernel array.
 746  * @ret_pointer: (output parameter) Pointer to a variable that will point to
 747  *     either @fast_pointer, a newly allocated kernel array, or NULL,
 748  *     depending on which array was used.
 749  *
 750  * This function copies an array of &struct iovec of @nr_segs from
 751  * userspace into the kernel and checks that each element is valid (e.g.
 752  * it does not point to a kernel address or cause overflow by being too
 753  * large, etc.).
 754  *
 755  * As an optimization, the caller may provide a pointer to a small
 756  * on-stack array in @fast_pointer, typically %UIO_FASTIOV elements long
 757  * (the size of this array, or 0 if unused, should be given in @fast_segs).
 758  *
 759  * @ret_pointer will always point to the array that was used, so the
 760  * caller must take care not to call kfree() on it e.g. in case the
 761  * @fast_pointer array was used and it was allocated on the stack.
 762  *
 763  * Return: The total number of bytes covered by the iovec array on success
 764  *   or a negative error code on error.
 765  */
 766 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
 767                               unsigned long nr_segs, unsigned long fast_segs,
 768                               struct iovec *fast_pointer,
 769                               struct iovec **ret_pointer)
 770 {
 771         unsigned long seg;
 772         ssize_t ret;
 773         struct iovec *iov = fast_pointer;
 774
 775         /*
 776          * SuS says "The readv() function *may* fail if the iovcnt argument
 777          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
 778          * traditionally returned zero for zero segments, so...
 779          */
 780         if (nr_segs == 0) {
 781                 ret = 0;
 782                 goto out;
 783         }
 784
 785         /*
 786          * First get the "struct iovec" from user memory and
 787          * verify all the pointers
 788          */
 789         if (nr_segs > UIO_MAXIOV) {
 790                 ret = -EINVAL;
 791                 goto out;
 792         }
 793         if (nr_segs > fast_segs) {
 794                 iov = kmalloc_array(nr_segs, sizeof(struct iovec), GFP_KERNEL);
 795                 if (iov == NULL) {
 796                         ret = -ENOMEM;
 797                         goto out;
 798                 }
 799         }
 800         if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
 801                 ret = -EFAULT;
 802                 goto out;
 803         }
 804
 805         /*
 806          * According to the Single Unix Specification we should return EINVAL
 807          * if an element length is < 0 when cast to ssize_t or if the
 808          * total length would overflow the ssize_t return value of the
 809          * system call.
 810          *
 811          * Linux caps all read/write calls to MAX_RW_COUNT, and avoids the
 812          * overflow case.
 813          */
 814         ret = 0;
 815         for (seg = 0; seg < nr_segs; seg++) {
 816                 void __user *buf = iov[seg].iov_base;
 817                 ssize_t len = (ssize_t)iov[seg].iov_len;
 818
 819                 /* see if we we're about to use an invalid len or if
 820                  * it's about to overflow ssize_t */
 821                 if (len < 0) {
 822                         ret = -EINVAL;
 823                         goto out;
 824                 }
 825                 if (type >= 0
 826                     && unlikely(!access_ok(buf, len))) {
 827                         ret = -EFAULT;
 828                         goto out;
 829                 }
 830                 if (len > MAX_RW_COUNT - ret) {
 831                         len = MAX_RW_COUNT - ret;
 832                         iov[seg].iov_len = len;
 833                 }
 834                 ret += len;
 835         }
 836 out:
 837         *ret_pointer = iov;
 838         return ret;
 839 }
 840
 841 #ifdef CONFIG_COMPAT
 842 ssize_t compat_rw_copy_check_uvector(int type,
 843                 const struct compat_iovec __user *uvector, unsigned long nr_segs,
 844                 unsigned long fast_segs, struct iovec *fast_pointer,
 845                 struct iovec **ret_pointer)
 846 {
 847         compat_ssize_t tot_len;
 848         struct iovec *iov = *ret_pointer = fast_pointer;
 849         ssize_t ret = 0;
 850         int seg;
 851
 852         /*
 853          * SuS says "The readv() function *may* fail if the iovcnt argument
 854          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
 855          * traditionally returned zero for zero segments, so...
 856          */
 857         if (nr_segs == 0)
 858                 goto out;
 859
 860         ret = -EINVAL;
 861         if (nr_segs > UIO_MAXIOV)
 862                 goto out;
 863         if (nr_segs > fast_segs) {
 864                 ret = -ENOMEM;
 865                 iov = kmalloc_array(nr_segs, sizeof(struct iovec), GFP_KERNEL);
 866                 if (iov == NULL)
 867                         goto out;
 868         }
 869         *ret_pointer = iov;
 870
 871         ret = -EFAULT;
 872         if (!access_ok(uvector, nr_segs*sizeof(*uvector)))
 873                 goto out;
 874
 875         /*
 876          * Single unix specification:
 877          * We should -EINVAL if an element length is not >= 0 and fitting an
 878          * ssize_t.
 879          *
 880          * In Linux, the total length is limited to MAX_RW_COUNT, there is
 881          * no overflow possibility.
 882          */
 883         tot_len = 0;
 884         ret = -EINVAL;
 885         for (seg = 0; seg < nr_segs; seg++) {
 886                 compat_uptr_t buf;
 887                 compat_ssize_t len;
 888
 889                 if (__get_user(len, &uvector->iov_len) ||
 890                    __get_user(buf, &uvector->iov_base)) {
 891                         ret = -EFAULT;
 892                         goto out;
 893                 }
 894                 if (len < 0)    /* size_t not fitting in compat_ssize_t .. */
 895                         goto out;
 896                 if (type >= 0 &&
 897                     !access_ok(compat_ptr(buf), len)) {
 898                         ret = -EFAULT;
 899                         goto out;
 900                 }
 901                 if (len > MAX_RW_COUNT - tot_len)
 902                         len = MAX_RW_COUNT - tot_len;
 903                 tot_len += len;
 904                 iov->iov_base = compat_ptr(buf);
 905                 iov->iov_len = (compat_size_t) len;
 906                 uvector++;
 907                 iov++;
 908         }
 909         ret = tot_len;
 910
 911 out:
 912         return ret;
 913 }
 914 #endif
 915
 916 static ssize_t do_iter_read(struct file *file, struct iov_iter *iter,
 917                 loff_t *pos, rwf_t flags)
 918 {
 919         size_t tot_len;
 920         ssize_t ret = 0;
 921
 922         if (!(file->f_mode & FMODE_READ))
 923                 return -EBADF;
 924         if (!(file->f_mode & FMODE_CAN_READ))
 925                 return -EINVAL;
 926
 927         tot_len = iov_iter_count(iter);
 928         if (!tot_len)
 929                 goto out;
 930         ret = rw_verify_area(READ, file, pos, tot_len);
 931         if (ret < 0)
 932                 return ret;
 933
 934         if (file->f_op->read_iter)
 935                 ret = do_iter_readv_writev(file, iter, pos, READ, flags);
 936         else
 937                 ret = do_loop_readv_writev(file, iter, pos, READ, flags);
 938 out:
 939         if (ret >= 0)
 940                 fsnotify_access(file);
 941         return ret;
 942 }
 943
 944 ssize_t vfs_iocb_iter_read(struct file *file, struct kiocb *iocb,
 945                            struct iov_iter *iter)
 946 {
 947         size_t tot_len;
 948         ssize_t ret = 0;
 949
 950         if (!file->f_op->read_iter)
 951                 return -EINVAL;
 952         if (!(file->f_mode & FMODE_READ))
 953                 return -EBADF;
 954         if (!(file->f_mode & FMODE_CAN_READ))
 955                 return -EINVAL;
 956
 957         tot_len = iov_iter_count(iter);
 958         if (!tot_len)
 959                 goto out;
 960         ret = rw_verify_area(READ, file, &iocb->ki_pos, tot_len);
 961         if (ret < 0)
 962                 return ret;
 963
 964         ret = call_read_iter(file, iocb, iter);
 965 out:
 966         if (ret >= 0)
 967                 fsnotify_access(file);
 968         return ret;
 969 }
 970 EXPORT_SYMBOL(vfs_iocb_iter_read);
 971
 972 ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
 973                 rwf_t flags)
 974 {
 975         if (!file->f_op->read_iter)
 976                 return -EINVAL;
 977         return do_iter_read(file, iter, ppos, flags);
 978 }
 979 EXPORT_SYMBOL(vfs_iter_read);
 980
 981 static ssize_t do_iter_write(struct file *file, struct iov_iter *iter,
 982                 loff_t *pos, rwf_t flags)
 983 {
 984         size_t tot_len;
 985         ssize_t ret = 0;
 986
 987         if (!(file->f_mode & FMODE_WRITE))
 988                 return -EBADF;
 989         if (!(file->f_mode & FMODE_CAN_WRITE))
 990                 return -EINVAL;
 991
 992         tot_len = iov_iter_count(iter);
 993         if (!tot_len)
 994                 return 0;
 995         ret = rw_verify_area(WRITE, file, pos, tot_len);
 996         if (ret < 0)
 997                 return ret;
 998
 999         if (file->f_op->write_iter)
1000                 ret = do_iter_readv_writev(file, iter, pos, WRITE, flags);
1001         else
1002                 ret = do_loop_readv_writev(file, iter, pos, WRITE, flags);
1003         if (ret > 0)
1004                 fsnotify_modify(file);
1005         return ret;
1006 }
1007
1008 ssize_t vfs_iocb_iter_write(struct file *file, struct kiocb *iocb,
1009                             struct iov_iter *iter)
1010 {
1011         size_t tot_len;
1012         ssize_t ret = 0;
1013
1014         if (!file->f_op->write_iter)
1015                 return -EINVAL;
1016         if (!(file->f_mode & FMODE_WRITE))
1017                 return -EBADF;
1018         if (!(file->f_mode & FMODE_CAN_WRITE))
1019                 return -EINVAL;
1020
1021         tot_len = iov_iter_count(iter);
1022         if (!tot_len)
1023                 return 0;
1024         ret = rw_verify_area(WRITE, file, &iocb->ki_pos, tot_len);
1025         if (ret < 0)
1026                 return ret;
1027
1028         ret = call_write_iter(file, iocb, iter);
1029         if (ret > 0)
1030                 fsnotify_modify(file);
1031
1032         return ret;
1033 }
1034 EXPORT_SYMBOL(vfs_iocb_iter_write);
1035
1036 ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
1037                 rwf_t flags)
1038 {
1039         if (!file->f_op->write_iter)
1040                 return -EINVAL;
1041         return do_iter_write(file, iter, ppos, flags);
1042 }
1043 EXPORT_SYMBOL(vfs_iter_write);
1044
1045 ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
1046                   unsigned long vlen, loff_t *pos, rwf_t flags)
1047 {
1048         struct iovec iovstack[UIO_FASTIOV];
1049         struct iovec *iov = iovstack;
1050         struct iov_iter iter;
1051         ssize_t ret;
1052
1053         ret = import_iovec(READ, vec, vlen, ARRAY_SIZE(iovstack), &iov, &iter);
1054         if (ret >= 0) {
1055                 ret = do_iter_read(file, &iter, pos, flags);
1056                 kfree(iov);
1057         }
1058
1059         return ret;
1060 }
1061
1062 static ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
1063                    unsigned long vlen, loff_t *pos, rwf_t flags)
1064 {
1065         struct iovec iovstack[UIO_FASTIOV];
1066         struct iovec *iov = iovstack;
1067         struct iov_iter iter;
1068         ssize_t ret;
1069
1070         ret = import_iovec(WRITE, vec, vlen, ARRAY_SIZE(iovstack), &iov, &iter);
1071         if (ret >= 0) {
1072                 file_start_write(file);
1073                 ret = do_iter_write(file, &iter, pos, flags);
1074                 file_end_write(file);
1075                 kfree(iov);
1076         }
1077         return ret;
1078 }
1079
1080 static ssize_t do_readv(unsigned long fd, const struct iovec __user *vec,
1081                         unsigned long vlen, rwf_t flags)
1082 {
1083         struct fd f = fdget_pos(fd);
1084         ssize_t ret = -EBADF;
1085
1086         if (f.file) {
1087                 loff_t pos, *ppos = file_ppos(f.file);
1088                 if (ppos) {
1089                         pos = *ppos;
1090                         ppos = &pos;
1091                 }
1092                 ret = vfs_readv(f.file, vec, vlen, ppos, flags);
1093                 if (ret >= 0 && ppos)
1094                         f.file->f_pos = pos;
1095                 fdput_pos(f);
1096         }
1097
1098         if (ret > 0)
1099                 add_rchar(current, ret);
1100         inc_syscr(current);
1101         return ret;
1102 }
1103
1104 static ssize_t do_writev(unsigned long fd, const struct iovec __user *vec,
1105                          unsigned long vlen, rwf_t flags)
1106 {
1107         struct fd f = fdget_pos(fd);
1108         ssize_t ret = -EBADF;
1109
1110         if (f.file) {
1111                 loff_t pos, *ppos = file_ppos(f.file);
1112                 if (ppos) {
1113                         pos = *ppos;
1114                         ppos = &pos;
1115                 }
1116                 ret = vfs_writev(f.file, vec, vlen, ppos, flags);
1117                 if (ret >= 0 && ppos)
1118                         f.file->f_pos = pos;
1119                 fdput_pos(f);
1120         }
1121
1122         if (ret > 0)
1123                 add_wchar(current, ret);
1124         inc_syscw(current);
1125         return ret;
1126 }
1127
1128 static inline loff_t pos_from_hilo(unsigned long high, unsigned long low)
1129 {
1130 #define HALF_LONG_BITS (BITS_PER_LONG / 2)
1131         return (((loff_t)high << HALF_LONG_BITS) << HALF_LONG_BITS) | low;
1132 }
1133
1134 static ssize_t do_preadv(unsigned long fd, const struct iovec __user *vec,
1135                          unsigned long vlen, loff_t pos, rwf_t flags)
1136 {
1137         struct fd f;
1138         ssize_t ret = -EBADF;
1139
1140         if (pos < 0)
1141                 return -EINVAL;
1142
1143         f = fdget(fd);
1144         if (f.file) {
1145                 ret = -ESPIPE;
1146                 if (f.file->f_mode & FMODE_PREAD)
1147                         ret = vfs_readv(f.file, vec, vlen, &pos, flags);
1148                 fdput(f);
1149         }
1150
1151         if (ret > 0)
1152                 add_rchar(current, ret);
1153         inc_syscr(current);
1154         return ret;
1155 }
1156
1157 static ssize_t do_pwritev(unsigned long fd, const struct iovec __user *vec,
1158                           unsigned long vlen, loff_t pos, rwf_t flags)
1159 {
1160         struct fd f;
1161         ssize_t ret = -EBADF;
1162
1163         if (pos < 0)
1164                 return -EINVAL;
1165
1166         f = fdget(fd);
1167         if (f.file) {
1168                 ret = -ESPIPE;
1169                 if (f.file->f_mode & FMODE_PWRITE)
1170                         ret = vfs_writev(f.file, vec, vlen, &pos, flags);
1171                 fdput(f);
1172         }
1173
1174         if (ret > 0)
1175                 add_wchar(current, ret);
1176         inc_syscw(current);
1177         return ret;
1178 }
1179
1180 SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
1181                 unsigned long, vlen)
1182 {
1183         return do_readv(fd, vec, vlen, 0);
1184 }
1185
1186 SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *, vec,
1187                 unsigned long, vlen)
1188 {
1189         return do_writev(fd, vec, vlen, 0);
1190 }
1191
1192 SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
1193                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
1194 {
1195         loff_t pos = pos_from_hilo(pos_h, pos_l);
1196
1197         return do_preadv(fd, vec, vlen, pos, 0);
1198 }
1199
1200 SYSCALL_DEFINE6(preadv2, unsigned long, fd, const struct iovec __user *, vec,
1201                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h,
1202                 rwf_t, flags)
1203 {
1204         loff_t pos = pos_from_hilo(pos_h, pos_l);
1205
1206         if (pos == -1)
1207                 return do_readv(fd, vec, vlen, flags);
1208
1209         return do_preadv(fd, vec, vlen, pos, flags);
1210 }
1211
1212 SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
1213                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
1214 {
1215         loff_t pos = pos_from_hilo(pos_h, pos_l);
1216
1217         return do_pwritev(fd, vec, vlen, pos, 0);
1218 }
1219
1220 SYSCALL_DEFINE6(pwritev2, unsigned long, fd, const struct iovec __user *, vec,
1221                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h,
1222                 rwf_t, flags)
1223 {
1224         loff_t pos = pos_from_hilo(pos_h, pos_l);
1225
1226         if (pos == -1)
1227                 return do_writev(fd, vec, vlen, flags);
1228
1229         return do_pwritev(fd, vec, vlen, pos, flags);
1230 }
1231
1232 #ifdef CONFIG_COMPAT
1233 static size_t compat_readv(struct file *file,
1234                            const struct compat_iovec __user *vec,
1235                            unsigned long vlen, loff_t *pos, rwf_t flags)
1236 {
1237         struct iovec iovstack[UIO_FASTIOV];
1238         struct iovec *iov = iovstack;
1239         struct iov_iter iter;
1240         ssize_t ret;
1241
1242         ret = compat_import_iovec(READ, vec, vlen, UIO_FASTIOV, &iov, &iter);
1243         if (ret >= 0) {
1244                 ret = do_iter_read(file, &iter, pos, flags);
1245                 kfree(iov);
1246         }
1247         if (ret > 0)
1248                 add_rchar(current, ret);
1249         inc_syscr(current);
1250         return ret;
1251 }
1252
1253 static size_t do_compat_readv(compat_ulong_t fd,
1254                                  const struct compat_iovec __user *vec,
1255                                  compat_ulong_t vlen, rwf_t flags)
1256 {
1257         struct fd f = fdget_pos(fd);
1258         ssize_t ret;
1259         loff_t pos;
1260
1261         if (!f.file)
1262                 return -EBADF;
1263         pos = f.file->f_pos;
1264         ret = compat_readv(f.file, vec, vlen, &pos, flags);
1265         if (ret >= 0)
1266                 f.file->f_pos = pos;
1267         fdput_pos(f);
1268         return ret;
1269
1270 }
1271
1272 COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
1273                 const struct compat_iovec __user *,vec,
1274                 compat_ulong_t, vlen)
1275 {
1276         return do_compat_readv(fd, vec, vlen, 0);
1277 }
1278
1279 static long do_compat_preadv64(unsigned long fd,
1280                                   const struct compat_iovec __user *vec,
1281                                   unsigned long vlen, loff_t pos, rwf_t flags)
1282 {
1283         struct fd f;
1284         ssize_t ret;
1285
1286         if (pos < 0)
1287                 return -EINVAL;
1288         f = fdget(fd);
1289         if (!f.file)
1290                 return -EBADF;
1291         ret = -ESPIPE;
1292         if (f.file->f_mode & FMODE_PREAD)
1293                 ret = compat_readv(f.file, vec, vlen, &pos, flags);
1294         fdput(f);
1295         return ret;
1296 }
1297
1298 #ifdef __ARCH_WANT_COMPAT_SYS_PREADV64
1299 COMPAT_SYSCALL_DEFINE4(preadv64, unsigned long, fd,
1300                 const struct compat_iovec __user *,vec,
1301                 unsigned long, vlen, loff_t, pos)
1302 {
1303         return do_compat_preadv64(fd, vec, vlen, pos, 0);
1304 }
1305 #endif
1306
1307 COMPAT_SYSCALL_DEFINE5(preadv, compat_ulong_t, fd,
1308                 const struct compat_iovec __user *,vec,
1309                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high)
1310 {
1311         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1312
1313         return do_compat_preadv64(fd, vec, vlen, pos, 0);
1314 }
1315
1316 #ifdef __ARCH_WANT_COMPAT_SYS_PREADV64V2
1317 COMPAT_SYSCALL_DEFINE5(preadv64v2, unsigned long, fd,
1318                 const struct compat_iovec __user *,vec,
1319                 unsigned long, vlen, loff_t, pos, rwf_t, flags)
1320 {
1321         if (pos == -1)
1322                 return do_compat_readv(fd, vec, vlen, flags);
1323
1324         return do_compat_preadv64(fd, vec, vlen, pos, flags);
1325 }
1326 #endif
1327
1328 COMPAT_SYSCALL_DEFINE6(preadv2, compat_ulong_t, fd,
1329                 const struct compat_iovec __user *,vec,
1330                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high,
1331                 rwf_t, flags)
1332 {
1333         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1334
1335         if (pos == -1)
1336                 return do_compat_readv(fd, vec, vlen, flags);
1337
1338         return do_compat_preadv64(fd, vec, vlen, pos, flags);
1339 }
1340
1341 static size_t compat_writev(struct file *file,
1342                             const struct compat_iovec __user *vec,
1343                             unsigned long vlen, loff_t *pos, rwf_t flags)
1344 {
1345         struct iovec iovstack[UIO_FASTIOV];
1346         struct iovec *iov = iovstack;
1347         struct iov_iter iter;
1348         ssize_t ret;
1349
1350         ret = compat_import_iovec(WRITE, vec, vlen, UIO_FASTIOV, &iov, &iter);
1351         if (ret >= 0) {
1352                 file_start_write(file);
1353                 ret = do_iter_write(file, &iter, pos, flags);
1354                 file_end_write(file);
1355                 kfree(iov);
1356         }
1357         if (ret > 0)
1358                 add_wchar(current, ret);
1359         inc_syscw(current);
1360         return ret;
1361 }
1362
1363 static size_t do_compat_writev(compat_ulong_t fd,
1364                                   const struct compat_iovec __user* vec,
1365                                   compat_ulong_t vlen, rwf_t flags)
1366 {
1367         struct fd f = fdget_pos(fd);
1368         ssize_t ret;
1369         loff_t pos;
1370
1371         if (!f.file)
1372                 return -EBADF;
1373         pos = f.file->f_pos;
1374         ret = compat_writev(f.file, vec, vlen, &pos, flags);
1375         if (ret >= 0)
1376                 f.file->f_pos = pos;
1377         fdput_pos(f);
1378         return ret;
1379 }
1380
1381 COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
1382                 const struct compat_iovec __user *, vec,
1383                 compat_ulong_t, vlen)
1384 {
1385         return do_compat_writev(fd, vec, vlen, 0);
1386 }
1387
1388 static long do_compat_pwritev64(unsigned long fd,
1389                                    const struct compat_iovec __user *vec,
1390                                    unsigned long vlen, loff_t pos, rwf_t flags)
1391 {
1392         struct fd f;
1393         ssize_t ret;
1394
1395         if (pos < 0)
1396                 return -EINVAL;
1397         f = fdget(fd);
1398         if (!f.file)
1399                 return -EBADF;
1400         ret = -ESPIPE;
1401         if (f.file->f_mode & FMODE_PWRITE)
1402                 ret = compat_writev(f.file, vec, vlen, &pos, flags);
1403         fdput(f);
1404         return ret;
1405 }
1406
1407 #ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64
1408 COMPAT_SYSCALL_DEFINE4(pwritev64, unsigned long, fd,
1409                 const struct compat_iovec __user *,vec,
1410                 unsigned long, vlen, loff_t, pos)
1411 {
1412         return do_compat_pwritev64(fd, vec, vlen, pos, 0);
1413 }
1414 #endif
1415
1416 COMPAT_SYSCALL_DEFINE5(pwritev, compat_ulong_t, fd,
1417                 const struct compat_iovec __user *,vec,
1418                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high)
1419 {
1420         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1421
1422         return do_compat_pwritev64(fd, vec, vlen, pos, 0);
1423 }
1424
1425 #ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64V2
1426 COMPAT_SYSCALL_DEFINE5(pwritev64v2, unsigned long, fd,
1427                 const struct compat_iovec __user *,vec,
1428                 unsigned long, vlen, loff_t, pos, rwf_t, flags)
1429 {
1430         if (pos == -1)
1431                 return do_compat_writev(fd, vec, vlen, flags);
1432
1433         return do_compat_pwritev64(fd, vec, vlen, pos, flags);
1434 }
1435 #endif
1436
1437 COMPAT_SYSCALL_DEFINE6(pwritev2, compat_ulong_t, fd,
1438                 const struct compat_iovec __user *,vec,
1439                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high, rwf_t, flags)
1440 {
1441         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1442
1443         if (pos == -1)
1444                 return do_compat_writev(fd, vec, vlen, flags);
1445
1446         return do_compat_pwritev64(fd, vec, vlen, pos, flags);
1447 }
1448
1449 #endif
1450
1451 static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
1452                            size_t count, loff_t max)
1453 {
1454         struct fd in, out;
1455         struct inode *in_inode, *out_inode;
1456         loff_t pos;
1457         loff_t out_pos;
1458         ssize_t retval;
1459         int fl;
1460
1461         /*
1462          * Get input file, and verify that it is ok..
1463          */
1464         retval = -EBADF;
1465         in = fdget(in_fd);
1466         if (!in.file)
1467                 goto out;
1468         if (!(in.file->f_mode & FMODE_READ))
1469                 goto fput_in;
1470         retval = -ESPIPE;
1471         if (!ppos) {
1472                 pos = in.file->f_pos;
1473         } else {
1474                 pos = *ppos;
1475                 if (!(in.file->f_mode & FMODE_PREAD))
1476                         goto fput_in;
1477         }
1478         retval = rw_verify_area(READ, in.file, &pos, count);
1479         if (retval < 0)
1480                 goto fput_in;
1481         if (count > MAX_RW_COUNT)
1482                 count =  MAX_RW_COUNT;
1483
1484         /*
1485          * Get output file, and verify that it is ok..
1486          */
1487         retval = -EBADF;
1488         out = fdget(out_fd);
1489         if (!out.file)
1490                 goto fput_in;
1491         if (!(out.file->f_mode & FMODE_WRITE))
1492                 goto fput_out;
1493         in_inode = file_inode(in.file);
1494         out_inode = file_inode(out.file);
1495         out_pos = out.file->f_pos;
1496         retval = rw_verify_area(WRITE, out.file, &out_pos, count);
1497         if (retval < 0)
1498                 goto fput_out;
1499
1500         if (!max)
1501                 max = min(in_inode->i_sb->s_maxbytes, out_inode->i_sb->s_maxbytes);
1502
1503         if (unlikely(pos + count > max)) {
1504                 retval = -EOVERFLOW;
1505                 if (pos >= max)
1506                         goto fput_out;
1507                 count = max - pos;
1508         }
1509
1510         fl = 0;
1511 #if 0
1512         /*
1513          * We need to debate whether we can enable this or not. The
1514          * man page documents EAGAIN return for the output at least,
1515          * and the application is arguably buggy if it doesn't expect
1516          * EAGAIN on a non-blocking file descriptor.
1517          */
1518         if (in.file->f_flags & O_NONBLOCK)
1519                 fl = SPLICE_F_NONBLOCK;
1520 #endif
1521         file_start_write(out.file);
1522         retval = do_splice_direct(in.file, &pos, out.file, &out_pos, count, fl);
1523         file_end_write(out.file);
1524
1525         if (retval > 0) {
1526                 add_rchar(current, retval);
1527                 add_wchar(current, retval);
1528                 fsnotify_access(in.file);
1529                 fsnotify_modify(out.file);
1530                 out.file->f_pos = out_pos;
1531                 if (ppos)
1532                         *ppos = pos;
1533                 else
1534                         in.file->f_pos = pos;
1535         }
1536
1537         inc_syscr(current);
1538         inc_syscw(current);
1539         if (pos > max)
1540                 retval = -EOVERFLOW;
1541
1542 fput_out:
1543         fdput(out);
1544 fput_in:
1545         fdput(in);
1546 out:
1547         return retval;
1548 }
1549
1550 SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd, off_t __user *, offset, size_t, count)
1551 {
1552         loff_t pos;
1553         off_t off;
1554         ssize_t ret;
1555
1556         if (offset) {
1557                 if (unlikely(get_user(off, offset)))
1558                         return -EFAULT;
1559                 pos = off;
1560                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
1561                 if (unlikely(put_user(pos, offset)))
1562                         return -EFAULT;
1563                 return ret;
1564         }
1565
1566         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1567 }
1568
1569 SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, loff_t __user *, offset, size_t, count)
1570 {
1571         loff_t pos;
1572         ssize_t ret;
1573
1574         if (offset) {
1575                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1576                         return -EFAULT;
1577                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1578                 if (unlikely(put_user(pos, offset)))
1579                         return -EFAULT;
1580                 return ret;
1581         }
1582
1583         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1584 }
1585
1586 #ifdef CONFIG_COMPAT
1587 COMPAT_SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd,
1588                 compat_off_t __user *, offset, compat_size_t, count)
1589 {
1590         loff_t pos;
1591         off_t off;
1592         ssize_t ret;
1593
1594         if (offset) {
1595                 if (unlikely(get_user(off, offset)))
1596                         return -EFAULT;
1597                 pos = off;
1598                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
1599                 if (unlikely(put_user(pos, offset)))
1600                         return -EFAULT;
1601                 return ret;
1602         }
1603
1604         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1605 }
1606
1607 COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd,
1608                 compat_loff_t __user *, offset, compat_size_t, count)
1609 {
1610         loff_t pos;
1611         ssize_t ret;
1612
1613         if (offset) {
1614                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1615                         return -EFAULT;
1616                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1617                 if (unlikely(put_user(pos, offset)))
1618                         return -EFAULT;
1619                 return ret;
1620         }
1621
1622         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1623 }
1624 #endif
1625
1626 /**
1627  * generic_copy_file_range - copy data between two files
1628  * @file_in:    file structure to read from
1629  * @pos_in:     file offset to read from
1630  * @file_out:   file structure to write data to
1631  * @pos_out:    file offset to write data to
1632  * @len:        amount of data to copy
1633  * @flags:      copy flags
1634  *
1635  * This is a generic filesystem helper to copy data from one file to another.
1636  * It has no constraints on the source or destination file owners - the files
1637  * can belong to different superblocks and different filesystem types. Short
1638  * copies are allowed.
1639  *
1640  * This should be called from the @file_out filesystem, as per the
1641  * ->copy_file_range() method.
1642  *
1643  * Returns the number of bytes copied or a negative error indicating the
1644  * failure.
1645  */
1646
1647 ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in,
1648                                 struct file *file_out, loff_t pos_out,
1649                                 size_t len, unsigned int flags)
1650 {
1651         return do_splice_direct(file_in, &pos_in, file_out, &pos_out,
1652                                 len > MAX_RW_COUNT ? MAX_RW_COUNT : len, 0);
1653 }
1654 EXPORT_SYMBOL(generic_copy_file_range);
1655
1656 static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in,
1657                                   struct file *file_out, loff_t pos_out,
1658                                   size_t len, unsigned int flags)
1659 {
1660         /*
1661          * Although we now allow filesystems to handle cross sb copy, passing
1662          * a file of the wrong filesystem type to filesystem driver can result
1663          * in an attempt to dereference the wrong type of ->private_data, so
1664          * avoid doing that until we really have a good reason.  NFS defines
1665          * several different file_system_type structures, but they all end up
1666          * using the same ->copy_file_range() function pointer.
1667          */
1668         if (file_out->f_op->copy_file_range &&
1669             file_out->f_op->copy_file_range == file_in->f_op->copy_file_range)
1670                 return file_out->f_op->copy_file_range(file_in, pos_in,
1671                                                        file_out, pos_out,
1672                                                        len, flags);
1673
1674         return generic_copy_file_range(file_in, pos_in, file_out, pos_out, len,
1675                                        flags);
1676 }
1677
1678 /*
1679  * copy_file_range() differs from regular file read and write in that it
1680  * specifically allows return partial success.  When it does so is up to
1681  * the copy_file_range method.
1682  */
1683 ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,
1684                             struct file *file_out, loff_t pos_out,
1685                             size_t len, unsigned int flags)
1686 {
1687         ssize_t ret;
1688
1689         if (flags != 0)
1690                 return -EINVAL;
1691
1692         ret = generic_copy_file_checks(file_in, pos_in, file_out, pos_out, &len,
1693                                        flags);
1694         if (unlikely(ret))
1695                 return ret;
1696
1697         ret = rw_verify_area(READ, file_in, &pos_in, len);
1698         if (unlikely(ret))
1699                 return ret;
1700
1701         ret = rw_verify_area(WRITE, file_out, &pos_out, len);
1702         if (unlikely(ret))
1703                 return ret;
1704
1705         if (len == 0)
1706                 return 0;
1707
1708         file_start_write(file_out);
1709
1710         /*
1711          * Try cloning first, this is supported by more file systems, and
1712          * more efficient if both clone and copy are supported (e.g. NFS).
1713          */
1714         if (file_in->f_op->remap_file_range &&
1715             file_inode(file_in)->i_sb == file_inode(file_out)->i_sb) {
1716                 loff_t cloned;
1717
1718                 cloned = file_in->f_op->remap_file_range(file_in, pos_in,
1719                                 file_out, pos_out,
1720                                 min_t(loff_t, MAX_RW_COUNT, len),
1721                                 REMAP_FILE_CAN_SHORTEN);
1722                 if (cloned > 0) {
1723                         ret = cloned;
1724                         goto done;
1725                 }
1726         }
1727
1728         ret = do_copy_file_range(file_in, pos_in, file_out, pos_out, len,
1729                                 flags);
1730         WARN_ON_ONCE(ret == -EOPNOTSUPP);
1731 done:
1732         if (ret > 0) {
1733                 fsnotify_access(file_in);
1734                 add_rchar(current, ret);
1735                 fsnotify_modify(file_out);
1736                 add_wchar(current, ret);
1737         }
1738
1739         inc_syscr(current);
1740         inc_syscw(current);
1741
1742         file_end_write(file_out);
1743
1744         return ret;
1745 }
1746 EXPORT_SYMBOL(vfs_copy_file_range);
1747
1748 SYSCALL_DEFINE6(copy_file_range, int, fd_in, loff_t __user *, off_in,
1749                 int, fd_out, loff_t __user *, off_out,
1750                 size_t, len, unsigned int, flags)
1751 {
1752         loff_t pos_in;
1753         loff_t pos_out;
1754         struct fd f_in;
1755         struct fd f_out;
1756         ssize_t ret = -EBADF;
1757
1758         f_in = fdget(fd_in);
1759         if (!f_in.file)
1760                 goto out2;
1761
1762         f_out = fdget(fd_out);
1763         if (!f_out.file)
1764                 goto out1;
1765
1766         ret = -EFAULT;
1767         if (off_in) {
1768                 if (copy_from_user(&pos_in, off_in, sizeof(loff_t)))
1769                         goto out;
1770         } else {
1771                 pos_in = f_in.file->f_pos;
1772         }
1773
1774         if (off_out) {
1775                 if (copy_from_user(&pos_out, off_out, sizeof(loff_t)))
1776                         goto out;
1777         } else {
1778                 pos_out = f_out.file->f_pos;
1779         }
1780
1781         ret = vfs_copy_file_range(f_in.file, pos_in, f_out.file, pos_out, len,
1782                                   flags);
1783         if (ret > 0) {
1784                 pos_in += ret;
1785                 pos_out += ret;
1786
1787                 if (off_in) {
1788                         if (copy_to_user(off_in, &pos_in, sizeof(loff_t)))
1789                                 ret = -EFAULT;
1790                 } else {
1791                         f_in.file->f_pos = pos_in;
1792                 }
1793
1794                 if (off_out) {
1795                         if (copy_to_user(off_out, &pos_out, sizeof(loff_t)))
1796                                 ret = -EFAULT;
1797                 } else {
1798                         f_out.file->f_pos = pos_out;
1799                 }
1800         }
1801
1802 out:
1803         fdput(f_out);
1804 out1:
1805         fdput(f_in);
1806 out2:
1807         return ret;
1808 }
1809
1810 static int remap_verify_area(struct file *file, loff_t pos, loff_t len,
1811                              bool write)
1812 {
1813         struct inode *inode = file_inode(file);
1814
1815         if (unlikely(pos < 0 || len < 0))
1816                 return -EINVAL;
1817
1818          if (unlikely((loff_t) (pos + len) < 0))
1819                 return -EINVAL;
1820
1821         if (unlikely(inode->i_flctx && mandatory_lock(inode))) {
1822                 loff_t end = len ? pos + len - 1 : OFFSET_MAX;
1823                 int retval;
1824
1825                 retval = locks_mandatory_area(inode, file, pos, end,
1826                                 write ? F_WRLCK : F_RDLCK);
1827                 if (retval < 0)
1828                         return retval;
1829         }
1830
1831         return security_file_permission(file, write ? MAY_WRITE : MAY_READ);
1832 }
1833 /*
1834  * Ensure that we don't remap a partial EOF block in the middle of something
1835  * else.  Assume that the offsets have already been checked for block
1836  * alignment.
1837  *
1838  * For clone we only link a partial EOF block above or at the destination file's
1839  * EOF.  For deduplication we accept a partial EOF block only if it ends at the
1840  * destination file's EOF (can not link it into the middle of a file).
1841  *
1842  * Shorten the request if possible.
1843  */
1844 static int generic_remap_check_len(struct inode *inode_in,
1845                                    struct inode *inode_out,
1846                                    loff_t pos_out,
1847                                    loff_t *len,
1848                                    unsigned int remap_flags)
1849 {
1850         u64 blkmask = i_blocksize(inode_in) - 1;
1851         loff_t new_len = *len;
1852
1853         if ((*len & blkmask) == 0)
1854                 return 0;
1855
1856         if (pos_out + *len < i_size_read(inode_out))
1857                 new_len &= ~blkmask;
1858
1859         if (new_len == *len)
1860                 return 0;
1861
1862         if (remap_flags & REMAP_FILE_CAN_SHORTEN) {
1863                 *len = new_len;
1864                 return 0;
1865         }
1866
1867         return (remap_flags & REMAP_FILE_DEDUP) ? -EBADE : -EINVAL;
1868 }
1869
1870 /* Read a page's worth of file data into the page cache. */
1871 static struct page *vfs_dedupe_get_page(struct inode *inode, loff_t offset)
1872 {
1873         struct page *page;
1874
1875         page = read_mapping_page(inode->i_mapping, offset >> PAGE_SHIFT, NULL);
1876         if (IS_ERR(page))
1877                 return page;
1878         if (!PageUptodate(page)) {
1879                 put_page(page);
1880                 return ERR_PTR(-EIO);
1881         }
1882         return page;
1883 }
1884
1885 /*
1886  * Lock two pages, ensuring that we lock in offset order if the pages are from
1887  * the same file.
1888  */
1889 static void vfs_lock_two_pages(struct page *page1, struct page *page2)
1890 {
1891         /* Always lock in order of increasing index. */
1892         if (page1->index > page2->index)
1893                 swap(page1, page2);
1894
1895         lock_page(page1);
1896         if (page1 != page2)
1897                 lock_page(page2);
1898 }
1899
1900 /* Unlock two pages, being careful not to unlock the same page twice. */
1901 static void vfs_unlock_two_pages(struct page *page1, struct page *page2)
1902 {
1903         unlock_page(page1);
1904         if (page1 != page2)
1905                 unlock_page(page2);
1906 }
1907
1908 /*
1909  * Compare extents of two files to see if they are the same.
1910  * Caller must have locked both inodes to prevent write races.
1911  */
1912 static int vfs_dedupe_file_range_compare(struct inode *src, loff_t srcoff,
1913                                          struct inode *dest, loff_t destoff,
1914                                          loff_t len, bool *is_same)
1915 {
1916         loff_t src_poff;
1917         loff_t dest_poff;
1918         void *src_addr;
1919         void *dest_addr;
1920         struct page *src_page;
1921         struct page *dest_page;
1922         loff_t cmp_len;
1923         bool same;
1924         int error;
1925
1926         error = -EINVAL;
1927         same = true;
1928         while (len) {
1929                 src_poff = srcoff & (PAGE_SIZE - 1);
1930                 dest_poff = destoff & (PAGE_SIZE - 1);
1931                 cmp_len = min(PAGE_SIZE - src_poff,
1932                               PAGE_SIZE - dest_poff);
1933                 cmp_len = min(cmp_len, len);
1934                 if (cmp_len <= 0)
1935                         goto out_error;
1936
1937                 src_page = vfs_dedupe_get_page(src, srcoff);
1938                 if (IS_ERR(src_page)) {
1939                         error = PTR_ERR(src_page);
1940                         goto out_error;
1941                 }
1942                 dest_page = vfs_dedupe_get_page(dest, destoff);
1943                 if (IS_ERR(dest_page)) {
1944                         error = PTR_ERR(dest_page);
1945                         put_page(src_page);
1946                         goto out_error;
1947                 }
1948
1949                 vfs_lock_two_pages(src_page, dest_page);
1950
1951                 /*
1952                  * Now that we've locked both pages, make sure they're still
1953                  * mapped to the file data we're interested in.  If not,
1954                  * someone is invalidating pages on us and we lose.
1955                  */
1956                 if (!PageUptodate(src_page) || !PageUptodate(dest_page) ||
1957                     src_page->mapping != src->i_mapping ||
1958                     dest_page->mapping != dest->i_mapping) {
1959                         same = false;
1960                         goto unlock;
1961                 }
1962
1963                 src_addr = kmap_atomic(src_page);
1964                 dest_addr = kmap_atomic(dest_page);
1965
1966                 flush_dcache_page(src_page);
1967                 flush_dcache_page(dest_page);
1968
1969                 if (memcmp(src_addr + src_poff, dest_addr + dest_poff, cmp_len))
1970                         same = false;
1971
1972                 kunmap_atomic(dest_addr);
1973                 kunmap_atomic(src_addr);
1974 unlock:
1975                 vfs_unlock_two_pages(src_page, dest_page);
1976                 put_page(dest_page);
1977                 put_page(src_page);
1978
1979                 if (!same)
1980                         break;
1981
1982                 srcoff += cmp_len;
1983                 destoff += cmp_len;
1984                 len -= cmp_len;
1985         }
1986
1987         *is_same = same;
1988         return 0;
1989
1990 out_error:
1991         return error;
1992 }
1993
1994 /*
1995  * Check that the two inodes are eligible for cloning, the ranges make
1996  * sense, and then flush all dirty data.  Caller must ensure that the
1997  * inodes have been locked against any other modifications.
1998  *
1999  * If there's an error, then the usual negative error code is returned.
2000  * Otherwise returns 0 with *len set to the request length.
2001  */
2002 int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
2003                                   struct file *file_out, loff_t pos_out,
2004                                   loff_t *len, unsigned int remap_flags)
2005 {
2006         struct inode *inode_in = file_inode(file_in);
2007         struct inode *inode_out = file_inode(file_out);
2008         bool same_inode = (inode_in == inode_out);
2009         int ret;
2010
2011         /* Don't touch certain kinds of inodes */
2012         if (IS_IMMUTABLE(inode_out))
2013                 return -EPERM;
2014
2015         if (IS_SWAPFILE(inode_in) || IS_SWAPFILE(inode_out))
2016                 return -ETXTBSY;
2017
2018         /* Don't reflink dirs, pipes, sockets... */
2019         if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode))
2020                 return -EISDIR;
2021         if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode))
2022                 return -EINVAL;
2023
2024         /* Zero length dedupe exits immediately; reflink goes to EOF. */
2025         if (*len == 0) {
2026                 loff_t isize = i_size_read(inode_in);
2027
2028                 if ((remap_flags & REMAP_FILE_DEDUP) || pos_in == isize)
2029                         return 0;
2030                 if (pos_in > isize)
2031                         return -EINVAL;
2032                 *len = isize - pos_in;
2033                 if (*len == 0)
2034                         return 0;
2035         }
2036
2037         /* Check that we don't violate system file offset limits. */
2038         ret = generic_remap_checks(file_in, pos_in, file_out, pos_out, len,
2039                         remap_flags);
2040         if (ret)
2041                 return ret;
2042
2043         /* Wait for the completion of any pending IOs on both files */
2044         inode_dio_wait(inode_in);
2045         if (!same_inode)
2046                 inode_dio_wait(inode_out);
2047
2048         ret = filemap_write_and_wait_range(inode_in->i_mapping,
2049                         pos_in, pos_in + *len - 1);
2050         if (ret)
2051                 return ret;
2052
2053         ret = filemap_write_and_wait_range(inode_out->i_mapping,
2054                         pos_out, pos_out + *len - 1);
2055         if (ret)
2056                 return ret;
2057
2058         /*
2059          * Check that the extents are the same.
2060          */
2061         if (remap_flags & REMAP_FILE_DEDUP) {
2062                 bool            is_same = false;
2063
2064                 ret = vfs_dedupe_file_range_compare(inode_in, pos_in,
2065                                 inode_out, pos_out, *len, &is_same);
2066                 if (ret)
2067                         return ret;
2068                 if (!is_same)
2069                         return -EBADE;
2070         }
2071
2072         ret = generic_remap_check_len(inode_in, inode_out, pos_out, len,
2073                         remap_flags);
2074         if (ret)
2075                 return ret;
2076
2077         /* If can't alter the file contents, we're done. */
2078         if (!(remap_flags & REMAP_FILE_DEDUP))
2079                 ret = file_modified(file_out);
2080
2081         return ret;
2082 }
2083 EXPORT_SYMBOL(generic_remap_file_range_prep);
2084
2085 loff_t do_clone_file_range(struct file *file_in, loff_t pos_in,
2086                            struct file *file_out, loff_t pos_out,
2087                            loff_t len, unsigned int remap_flags)
2088 {
2089         loff_t ret;
2090
2091         WARN_ON_ONCE(remap_flags & REMAP_FILE_DEDUP);
2092
2093         /*
2094          * FICLONE/FICLONERANGE ioctls enforce that src and dest files are on
2095          * the same mount. Practically, they only need to be on the same file
2096          * system.
2097          */
2098         if (file_inode(file_in)->i_sb != file_inode(file_out)->i_sb)
2099                 return -EXDEV;
2100
2101         ret = generic_file_rw_checks(file_in, file_out);
2102         if (ret < 0)
2103                 return ret;
2104
2105         if (!file_in->f_op->remap_file_range)
2106                 return -EOPNOTSUPP;
2107
2108         ret = remap_verify_area(file_in, pos_in, len, false);
2109         if (ret)
2110                 return ret;
2111
2112         ret = remap_verify_area(file_out, pos_out, len, true);
2113         if (ret)
2114                 return ret;
2115
2116         ret = file_in->f_op->remap_file_range(file_in, pos_in,
2117                         file_out, pos_out, len, remap_flags);
2118         if (ret < 0)
2119                 return ret;
2120
2121         fsnotify_access(file_in);
2122         fsnotify_modify(file_out);
2123         return ret;
2124 }
2125 EXPORT_SYMBOL(do_clone_file_range);
2126
2127 loff_t vfs_clone_file_range(struct file *file_in, loff_t pos_in,
2128                             struct file *file_out, loff_t pos_out,
2129                             loff_t len, unsigned int remap_flags)
2130 {
2131         loff_t ret;
2132
2133         file_start_write(file_out);
2134         ret = do_clone_file_range(file_in, pos_in, file_out, pos_out, len,
2135                                   remap_flags);
2136         file_end_write(file_out);
2137
2138         return ret;
2139 }
2140 EXPORT_SYMBOL(vfs_clone_file_range);
2141
2142 /* Check whether we are allowed to dedupe the destination file */
2143 static bool allow_file_dedupe(struct file *file)
2144 {
2145         if (capable(CAP_SYS_ADMIN))
2146                 return true;
2147         if (file->f_mode & FMODE_WRITE)
2148                 return true;
2149         if (uid_eq(current_fsuid(), file_inode(file)->i_uid))
2150                 return true;
2151         if (!inode_permission(file_inode(file), MAY_WRITE))
2152                 return true;
2153         return false;
2154 }
2155
2156 loff_t vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
2157                                  struct file *dst_file, loff_t dst_pos,
2158                                  loff_t len, unsigned int remap_flags)
2159 {
2160         loff_t ret;
2161
2162         WARN_ON_ONCE(remap_flags & ~(REMAP_FILE_DEDUP |
2163                                      REMAP_FILE_CAN_SHORTEN));
2164
2165         ret = mnt_want_write_file(dst_file);
2166         if (ret)
2167                 return ret;
2168
2169         ret = remap_verify_area(dst_file, dst_pos, len, true);
2170         if (ret < 0)
2171                 goto out_drop_write;
2172
2173         ret = -EPERM;
2174         if (!allow_file_dedupe(dst_file))
2175                 goto out_drop_write;
2176
2177         ret = -EXDEV;
2178         if (src_file->f_path.mnt != dst_file->f_path.mnt)
2179                 goto out_drop_write;
2180
2181         ret = -EISDIR;
2182         if (S_ISDIR(file_inode(dst_file)->i_mode))
2183                 goto out_drop_write;
2184
2185         ret = -EINVAL;
2186         if (!dst_file->f_op->remap_file_range)
2187                 goto out_drop_write;
2188
2189         if (len == 0) {
2190                 ret = 0;
2191                 goto out_drop_write;
2192         }
2193
2194         ret = dst_file->f_op->remap_file_range(src_file, src_pos, dst_file,
2195                         dst_pos, len, remap_flags | REMAP_FILE_DEDUP);
2196 out_drop_write:
2197         mnt_drop_write_file(dst_file);
2198
2199         return ret;
2200 }
2201 EXPORT_SYMBOL(vfs_dedupe_file_range_one);
2202
2203 int vfs_dedupe_file_range(struct file *file, struct file_dedupe_range *same)
2204 {
2205         struct file_dedupe_range_info *info;
2206         struct inode *src = file_inode(file);
2207         u64 off;
2208         u64 len;
2209         int i;
2210         int ret;
2211         u16 count = same->dest_count;
2212         loff_t deduped;
2213
2214         if (!(file->f_mode & FMODE_READ))
2215                 return -EINVAL;
2216
2217         if (same->reserved1 || same->reserved2)
2218                 return -EINVAL;
2219
2220         off = same->src_offset;
2221         len = same->src_length;
2222
2223         if (S_ISDIR(src->i_mode))
2224                 return -EISDIR;
2225
2226         if (!S_ISREG(src->i_mode))
2227                 return -EINVAL;
2228
2229         if (!file->f_op->remap_file_range)
2230                 return -EOPNOTSUPP;
2231
2232         ret = remap_verify_area(file, off, len, false);
2233         if (ret < 0)
2234                 return ret;
2235         ret = 0;
2236
2237         if (off + len > i_size_read(src))
2238                 return -EINVAL;
2239
2240         /* Arbitrary 1G limit on a single dedupe request, can be raised. */
2241         len = min_t(u64, len, 1 << 30);
2242
2243         /* pre-format output fields to sane values */
2244         for (i = 0; i < count; i++) {
2245                 same->info[i].bytes_deduped = 0ULL;
2246                 same->info[i].status = FILE_DEDUPE_RANGE_SAME;
2247         }
2248
2249         for (i = 0, info = same->info; i < count; i++, info++) {
2250                 struct fd dst_fd = fdget(info->dest_fd);
2251                 struct file *dst_file = dst_fd.file;
2252
2253                 if (!dst_file) {
2254                         info->status = -EBADF;
2255                         goto next_loop;
2256                 }
2257
2258                 if (info->reserved) {
2259                         info->status = -EINVAL;
2260                         goto next_fdput;
2261                 }
2262
2263                 deduped = vfs_dedupe_file_range_one(file, off, dst_file,
2264                                                     info->dest_offset, len,
2265                                                     REMAP_FILE_CAN_SHORTEN);
2266                 if (deduped == -EBADE)
2267                         info->status = FILE_DEDUPE_RANGE_DIFFERS;
2268                 else if (deduped < 0)
2269                         info->status = deduped;
2270                 else
2271                         info->bytes_deduped = len;
2272
2273 next_fdput:
2274                 fdput(dst_fd);
2275 next_loop:
2276                 if (fatal_signal_pending(current))
2277                         break;
2278         }
2279         return ret;
2280 }
2281 EXPORT_SYMBOL(vfs_dedupe_file_range);