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 #ifdef __ARCH_WANT_SYS_LLSEEK
 335 SYSCALL_DEFINE5(llseek, unsigned int, fd, unsigned long, offset_high,
 336                 unsigned long, offset_low, loff_t __user *, result,
 337                 unsigned int, whence)
 338 {
 339         int retval;
 340         struct fd f = fdget_pos(fd);
 341         loff_t offset;
 342
 343         if (!f.file)
 344                 return -EBADF;
 345
 346         retval = -EINVAL;
 347         if (whence > SEEK_MAX)
 348                 goto out_putf;
 349
 350         offset = vfs_llseek(f.file, ((loff_t) offset_high << 32) | offset_low,
 351                         whence);
 352
 353         retval = (int)offset;
 354         if (offset >= 0) {
 355                 retval = -EFAULT;
 356                 if (!copy_to_user(result, &offset, sizeof(offset)))
 357                         retval = 0;
 358         }
 359 out_putf:
 360         fdput_pos(f);
 361         return retval;
 362 }
 363 #endif
 364
 365 int rw_verify_area(int read_write, struct file *file, const loff_t *ppos, size_t count)
 366 {
 367         struct inode *inode;
 368         loff_t pos;
 369         int retval = -EINVAL;
 370
 371         inode = file_inode(file);
 372         if (unlikely((ssize_t) count < 0))
 373                 return retval;
 374         pos = *ppos;
 375         if (unlikely(pos < 0)) {
 376                 if (!unsigned_offsets(file))
 377                         return retval;
 378                 if (count >= -pos) /* both values are in 0..LLONG_MAX */
 379                         return -EOVERFLOW;
 380         } else if (unlikely((loff_t) (pos + count) < 0)) {
 381                 if (!unsigned_offsets(file))
 382                         return retval;
 383         }
 384
 385         if (unlikely(inode->i_flctx && mandatory_lock(inode))) {
 386                 retval = locks_mandatory_area(inode, file, pos, pos + count - 1,
 387                                 read_write == READ ? F_RDLCK : F_WRLCK);
 388                 if (retval < 0)
 389                         return retval;
 390         }
 391         return security_file_permission(file,
 392                                 read_write == READ ? MAY_READ : MAY_WRITE);
 393 }
 394
 395 static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
 396 {
 397         struct iovec iov = { .iov_base = buf, .iov_len = len };
 398         struct kiocb kiocb;
 399         struct iov_iter iter;
 400         ssize_t ret;
 401
 402         init_sync_kiocb(&kiocb, filp);
 403         kiocb.ki_pos = *ppos;
 404         iov_iter_init(&iter, READ, &iov, 1, len);
 405
 406         ret = call_read_iter(filp, &kiocb, &iter);
 407         BUG_ON(ret == -EIOCBQUEUED);
 408         *ppos = kiocb.ki_pos;
 409         return ret;
 410 }
 411
 412 ssize_t __vfs_read(struct file *file, char __user *buf, size_t count,
 413                    loff_t *pos)
 414 {
 415         if (file->f_op->read)
 416                 return file->f_op->read(file, buf, count, pos);
 417         else if (file->f_op->read_iter)
 418                 return new_sync_read(file, buf, count, pos);
 419         else
 420                 return -EINVAL;
 421 }
 422
 423 ssize_t kernel_read(struct file *file, void *buf, size_t count, loff_t *pos)
 424 {
 425         mm_segment_t old_fs;
 426         ssize_t result;
 427
 428         old_fs = get_fs();
 429         set_fs(get_ds());
 430         /* The cast to a user pointer is valid due to the set_fs() */
 431         result = vfs_read(file, (void __user *)buf, count, pos);
 432         set_fs(old_fs);
 433         return result;
 434 }
 435 EXPORT_SYMBOL(kernel_read);
 436
 437 ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
 438 {
 439         ssize_t ret;
 440
 441         if (!(file->f_mode & FMODE_READ))
 442                 return -EBADF;
 443         if (!(file->f_mode & FMODE_CAN_READ))
 444                 return -EINVAL;
 445         if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
 446                 return -EFAULT;
 447
 448         ret = rw_verify_area(READ, file, pos, count);
 449         if (!ret) {
 450                 if (count > MAX_RW_COUNT)
 451                         count =  MAX_RW_COUNT;
 452                 ret = __vfs_read(file, buf, count, pos);
 453                 if (ret > 0) {
 454                         fsnotify_access(file);
 455                         add_rchar(current, ret);
 456                 }
 457                 inc_syscr(current);
 458         }
 459
 460         return ret;
 461 }
 462
 463 static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
 464 {
 465         struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
 466         struct kiocb kiocb;
 467         struct iov_iter iter;
 468         ssize_t ret;
 469
 470         init_sync_kiocb(&kiocb, filp);
 471         kiocb.ki_pos = *ppos;
 472         iov_iter_init(&iter, WRITE, &iov, 1, len);
 473
 474         ret = call_write_iter(filp, &kiocb, &iter);
 475         BUG_ON(ret == -EIOCBQUEUED);
 476         if (ret > 0)
 477                 *ppos = kiocb.ki_pos;
 478         return ret;
 479 }
 480
 481 ssize_t __vfs_write(struct file *file, const char __user *p, size_t count,
 482                     loff_t *pos)
 483 {
 484         if (file->f_op->write)
 485                 return file->f_op->write(file, p, count, pos);
 486         else if (file->f_op->write_iter)
 487                 return new_sync_write(file, p, count, pos);
 488         else
 489                 return -EINVAL;
 490 }
 491
 492 ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_t *pos)
 493 {
 494         mm_segment_t old_fs;
 495         const char __user *p;
 496         ssize_t ret;
 497
 498         if (!(file->f_mode & FMODE_CAN_WRITE))
 499                 return -EINVAL;
 500
 501         old_fs = get_fs();
 502         set_fs(get_ds());
 503         p = (__force const char __user *)buf;
 504         if (count > MAX_RW_COUNT)
 505                 count =  MAX_RW_COUNT;
 506         ret = __vfs_write(file, p, count, pos);
 507         set_fs(old_fs);
 508         if (ret > 0) {
 509                 fsnotify_modify(file);
 510                 add_wchar(current, ret);
 511         }
 512         inc_syscw(current);
 513         return ret;
 514 }
 515 EXPORT_SYMBOL(__kernel_write);
 516
 517 ssize_t kernel_write(struct file *file, const void *buf, size_t count,
 518                             loff_t *pos)
 519 {
 520         mm_segment_t old_fs;
 521         ssize_t res;
 522
 523         old_fs = get_fs();
 524         set_fs(get_ds());
 525         /* The cast to a user pointer is valid due to the set_fs() */
 526         res = vfs_write(file, (__force const char __user *)buf, count, pos);
 527         set_fs(old_fs);
 528
 529         return res;
 530 }
 531 EXPORT_SYMBOL(kernel_write);
 532
 533 ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
 534 {
 535         ssize_t ret;
 536
 537         if (!(file->f_mode & FMODE_WRITE))
 538                 return -EBADF;
 539         if (!(file->f_mode & FMODE_CAN_WRITE))
 540                 return -EINVAL;
 541         if (unlikely(!access_ok(VERIFY_READ, buf, count)))
 542                 return -EFAULT;
 543
 544         ret = rw_verify_area(WRITE, file, pos, count);
 545         if (!ret) {
 546                 if (count > MAX_RW_COUNT)
 547                         count =  MAX_RW_COUNT;
 548                 file_start_write(file);
 549                 ret = __vfs_write(file, buf, count, pos);
 550                 if (ret > 0) {
 551                         fsnotify_modify(file);
 552                         add_wchar(current, ret);
 553                 }
 554                 inc_syscw(current);
 555                 file_end_write(file);
 556         }
 557
 558         return ret;
 559 }
 560
 561 static inline loff_t file_pos_read(struct file *file)
 562 {
 563         return file->f_pos;
 564 }
 565
 566 static inline void file_pos_write(struct file *file, loff_t pos)
 567 {
 568         file->f_pos = pos;
 569 }
 570
 571 ssize_t ksys_read(unsigned int fd, char __user *buf, size_t count)
 572 {
 573         struct fd f = fdget_pos(fd);
 574         ssize_t ret = -EBADF;
 575
 576         if (f.file) {
 577                 loff_t pos = file_pos_read(f.file);
 578                 ret = vfs_read(f.file, buf, count, &pos);
 579                 if (ret >= 0)
 580                         file_pos_write(f.file, pos);
 581                 fdput_pos(f);
 582         }
 583         return ret;
 584 }
 585
 586 SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
 587 {
 588         return ksys_read(fd, buf, count);
 589 }
 590
 591 ssize_t ksys_write(unsigned int fd, const char __user *buf, size_t count)
 592 {
 593         struct fd f = fdget_pos(fd);
 594         ssize_t ret = -EBADF;
 595
 596         if (f.file) {
 597                 loff_t pos = file_pos_read(f.file);
 598                 ret = vfs_write(f.file, buf, count, &pos);
 599                 if (ret >= 0)
 600                         file_pos_write(f.file, pos);
 601                 fdput_pos(f);
 602         }
 603
 604         return ret;
 605 }
 606
 607 SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
 608                 size_t, count)
 609 {
 610         return ksys_write(fd, buf, count);
 611 }
 612
 613 SYSCALL_DEFINE4(pread64, unsigned int, fd, char __user *, buf,
 614                         size_t, count, loff_t, pos)
 615 {
 616         struct fd f;
 617         ssize_t ret = -EBADF;
 618
 619         if (pos < 0)
 620                 return -EINVAL;
 621
 622         f = fdget(fd);
 623         if (f.file) {
 624                 ret = -ESPIPE;
 625                 if (f.file->f_mode & FMODE_PREAD)
 626                         ret = vfs_read(f.file, buf, count, &pos);
 627                 fdput(f);
 628         }
 629
 630         return ret;
 631 }
 632
 633 SYSCALL_DEFINE4(pwrite64, unsigned int, fd, const char __user *, buf,
 634                          size_t, count, loff_t, pos)
 635 {
 636         struct fd f;
 637         ssize_t ret = -EBADF;
 638
 639         if (pos < 0)
 640                 return -EINVAL;
 641
 642         f = fdget(fd);
 643         if (f.file) {
 644                 ret = -ESPIPE;
 645                 if (f.file->f_mode & FMODE_PWRITE)
 646                         ret = vfs_write(f.file, buf, count, &pos);
 647                 fdput(f);
 648         }
 649
 650         return ret;
 651 }
 652
 653 static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,
 654                 loff_t *ppos, int type, rwf_t flags)
 655 {
 656         struct kiocb kiocb;
 657         ssize_t ret;
 658
 659         init_sync_kiocb(&kiocb, filp);
 660         ret = kiocb_set_rw_flags(&kiocb, flags);
 661         if (ret)
 662                 return ret;
 663         kiocb.ki_pos = *ppos;
 664
 665         if (type == READ)
 666                 ret = call_read_iter(filp, &kiocb, iter);
 667         else
 668                 ret = call_write_iter(filp, &kiocb, iter);
 669         BUG_ON(ret == -EIOCBQUEUED);
 670         *ppos = kiocb.ki_pos;
 671         return ret;
 672 }
 673
 674 /* Do it by hand, with file-ops */
 675 static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,
 676                 loff_t *ppos, int type, rwf_t flags)
 677 {
 678         ssize_t ret = 0;
 679
 680         if (flags & ~RWF_HIPRI)
 681                 return -EOPNOTSUPP;
 682
 683         while (iov_iter_count(iter)) {
 684                 struct iovec iovec = iov_iter_iovec(iter);
 685                 ssize_t nr;
 686
 687                 if (type == READ) {
 688                         nr = filp->f_op->read(filp, iovec.iov_base,
 689                                               iovec.iov_len, ppos);
 690                 } else {
 691                         nr = filp->f_op->write(filp, iovec.iov_base,
 692                                                iovec.iov_len, ppos);
 693                 }
 694
 695                 if (nr < 0) {
 696                         if (!ret)
 697                                 ret = nr;
 698                         break;
 699                 }
 700                 ret += nr;
 701                 if (nr != iovec.iov_len)
 702                         break;
 703                 iov_iter_advance(iter, nr);
 704         }
 705
 706         return ret;
 707 }
 708
 709 /* A write operation does a read from user space and vice versa */
 710 #define vrfy_dir(type) ((type) == READ ? VERIFY_WRITE : VERIFY_READ)
 711
 712 /**
 713  * rw_copy_check_uvector() - Copy an array of &struct iovec from userspace
 714  *     into the kernel and check that it is valid.
 715  *
 716  * @type: One of %CHECK_IOVEC_ONLY, %READ, or %WRITE.
 717  * @uvector: Pointer to the userspace array.
 718  * @nr_segs: Number of elements in userspace array.
 719  * @fast_segs: Number of elements in @fast_pointer.
 720  * @fast_pointer: Pointer to (usually small on-stack) kernel array.
 721  * @ret_pointer: (output parameter) Pointer to a variable that will point to
 722  *     either @fast_pointer, a newly allocated kernel array, or NULL,
 723  *     depending on which array was used.
 724  *
 725  * This function copies an array of &struct iovec of @nr_segs from
 726  * userspace into the kernel and checks that each element is valid (e.g.
 727  * it does not point to a kernel address or cause overflow by being too
 728  * large, etc.).
 729  *
 730  * As an optimization, the caller may provide a pointer to a small
 731  * on-stack array in @fast_pointer, typically %UIO_FASTIOV elements long
 732  * (the size of this array, or 0 if unused, should be given in @fast_segs).
 733  *
 734  * @ret_pointer will always point to the array that was used, so the
 735  * caller must take care not to call kfree() on it e.g. in case the
 736  * @fast_pointer array was used and it was allocated on the stack.
 737  *
 738  * Return: The total number of bytes covered by the iovec array on success
 739  *   or a negative error code on error.
 740  */
 741 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
 742                               unsigned long nr_segs, unsigned long fast_segs,
 743                               struct iovec *fast_pointer,
 744                               struct iovec **ret_pointer)
 745 {
 746         unsigned long seg;
 747         ssize_t ret;
 748         struct iovec *iov = fast_pointer;
 749
 750         /*
 751          * SuS says "The readv() function *may* fail if the iovcnt argument
 752          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
 753          * traditionally returned zero for zero segments, so...
 754          */
 755         if (nr_segs == 0) {
 756                 ret = 0;
 757                 goto out;
 758         }
 759
 760         /*
 761          * First get the "struct iovec" from user memory and
 762          * verify all the pointers
 763          */
 764         if (nr_segs > UIO_MAXIOV) {
 765                 ret = -EINVAL;
 766                 goto out;
 767         }
 768         if (nr_segs > fast_segs) {
 769                 iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
 770                 if (iov == NULL) {
 771                         ret = -ENOMEM;
 772                         goto out;
 773                 }
 774         }
 775         if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
 776                 ret = -EFAULT;
 777                 goto out;
 778         }
 779
 780         /*
 781          * According to the Single Unix Specification we should return EINVAL
 782          * if an element length is < 0 when cast to ssize_t or if the
 783          * total length would overflow the ssize_t return value of the
 784          * system call.
 785          *
 786          * Linux caps all read/write calls to MAX_RW_COUNT, and avoids the
 787          * overflow case.
 788          */
 789         ret = 0;
 790         for (seg = 0; seg < nr_segs; seg++) {
 791                 void __user *buf = iov[seg].iov_base;
 792                 ssize_t len = (ssize_t)iov[seg].iov_len;
 793
 794                 /* see if we we're about to use an invalid len or if
 795                  * it's about to overflow ssize_t */
 796                 if (len < 0) {
 797                         ret = -EINVAL;
 798                         goto out;
 799                 }
 800                 if (type >= 0
 801                     && unlikely(!access_ok(vrfy_dir(type), buf, len))) {
 802                         ret = -EFAULT;
 803                         goto out;
 804                 }
 805                 if (len > MAX_RW_COUNT - ret) {
 806                         len = MAX_RW_COUNT - ret;
 807                         iov[seg].iov_len = len;
 808                 }
 809                 ret += len;
 810         }
 811 out:
 812         *ret_pointer = iov;
 813         return ret;
 814 }
 815
 816 #ifdef CONFIG_COMPAT
 817 ssize_t compat_rw_copy_check_uvector(int type,
 818                 const struct compat_iovec __user *uvector, unsigned long nr_segs,
 819                 unsigned long fast_segs, struct iovec *fast_pointer,
 820                 struct iovec **ret_pointer)
 821 {
 822         compat_ssize_t tot_len;
 823         struct iovec *iov = *ret_pointer = fast_pointer;
 824         ssize_t ret = 0;
 825         int seg;
 826
 827         /*
 828          * SuS says "The readv() function *may* fail if the iovcnt argument
 829          * was less than or equal to 0, or greater than {IOV_MAX}.  Linux has
 830          * traditionally returned zero for zero segments, so...
 831          */
 832         if (nr_segs == 0)
 833                 goto out;
 834
 835         ret = -EINVAL;
 836         if (nr_segs > UIO_MAXIOV)
 837                 goto out;
 838         if (nr_segs > fast_segs) {
 839                 ret = -ENOMEM;
 840                 iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
 841                 if (iov == NULL)
 842                         goto out;
 843         }
 844         *ret_pointer = iov;
 845
 846         ret = -EFAULT;
 847         if (!access_ok(VERIFY_READ, uvector, nr_segs*sizeof(*uvector)))
 848                 goto out;
 849
 850         /*
 851          * Single unix specification:
 852          * We should -EINVAL if an element length is not >= 0 and fitting an
 853          * ssize_t.
 854          *
 855          * In Linux, the total length is limited to MAX_RW_COUNT, there is
 856          * no overflow possibility.
 857          */
 858         tot_len = 0;
 859         ret = -EINVAL;
 860         for (seg = 0; seg < nr_segs; seg++) {
 861                 compat_uptr_t buf;
 862                 compat_ssize_t len;
 863
 864                 if (__get_user(len, &uvector->iov_len) ||
 865                    __get_user(buf, &uvector->iov_base)) {
 866                         ret = -EFAULT;
 867                         goto out;
 868                 }
 869                 if (len < 0)    /* size_t not fitting in compat_ssize_t .. */
 870                         goto out;
 871                 if (type >= 0 &&
 872                     !access_ok(vrfy_dir(type), compat_ptr(buf), len)) {
 873                         ret = -EFAULT;
 874                         goto out;
 875                 }
 876                 if (len > MAX_RW_COUNT - tot_len)
 877                         len = MAX_RW_COUNT - tot_len;
 878                 tot_len += len;
 879                 iov->iov_base = compat_ptr(buf);
 880                 iov->iov_len = (compat_size_t) len;
 881                 uvector++;
 882                 iov++;
 883         }
 884         ret = tot_len;
 885
 886 out:
 887         return ret;
 888 }
 889 #endif
 890
 891 static ssize_t do_iter_read(struct file *file, struct iov_iter *iter,
 892                 loff_t *pos, rwf_t flags)
 893 {
 894         size_t tot_len;
 895         ssize_t ret = 0;
 896
 897         if (!(file->f_mode & FMODE_READ))
 898                 return -EBADF;
 899         if (!(file->f_mode & FMODE_CAN_READ))
 900                 return -EINVAL;
 901
 902         tot_len = iov_iter_count(iter);
 903         if (!tot_len)
 904                 goto out;
 905         ret = rw_verify_area(READ, file, pos, tot_len);
 906         if (ret < 0)
 907                 return ret;
 908
 909         if (file->f_op->read_iter)
 910                 ret = do_iter_readv_writev(file, iter, pos, READ, flags);
 911         else
 912                 ret = do_loop_readv_writev(file, iter, pos, READ, flags);
 913 out:
 914         if (ret >= 0)
 915                 fsnotify_access(file);
 916         return ret;
 917 }
 918
 919 ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
 920                 rwf_t flags)
 921 {
 922         if (!file->f_op->read_iter)
 923                 return -EINVAL;
 924         return do_iter_read(file, iter, ppos, flags);
 925 }
 926 EXPORT_SYMBOL(vfs_iter_read);
 927
 928 static ssize_t do_iter_write(struct file *file, struct iov_iter *iter,
 929                 loff_t *pos, rwf_t flags)
 930 {
 931         size_t tot_len;
 932         ssize_t ret = 0;
 933
 934         if (!(file->f_mode & FMODE_WRITE))
 935                 return -EBADF;
 936         if (!(file->f_mode & FMODE_CAN_WRITE))
 937                 return -EINVAL;
 938
 939         tot_len = iov_iter_count(iter);
 940         if (!tot_len)
 941                 return 0;
 942         ret = rw_verify_area(WRITE, file, pos, tot_len);
 943         if (ret < 0)
 944                 return ret;
 945
 946         if (file->f_op->write_iter)
 947                 ret = do_iter_readv_writev(file, iter, pos, WRITE, flags);
 948         else
 949                 ret = do_loop_readv_writev(file, iter, pos, WRITE, flags);
 950         if (ret > 0)
 951                 fsnotify_modify(file);
 952         return ret;
 953 }
 954
 955 ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
 956                 rwf_t flags)
 957 {
 958         if (!file->f_op->write_iter)
 959                 return -EINVAL;
 960         return do_iter_write(file, iter, ppos, flags);
 961 }
 962 EXPORT_SYMBOL(vfs_iter_write);
 963
 964 ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
 965                   unsigned long vlen, loff_t *pos, rwf_t flags)
 966 {
 967         struct iovec iovstack[UIO_FASTIOV];
 968         struct iovec *iov = iovstack;
 969         struct iov_iter iter;
 970         ssize_t ret;
 971
 972         ret = import_iovec(READ, vec, vlen, ARRAY_SIZE(iovstack), &iov, &iter);
 973         if (ret >= 0) {
 974                 ret = do_iter_read(file, &iter, pos, flags);
 975                 kfree(iov);
 976         }
 977
 978         return ret;
 979 }
 980
 981 static ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
 982                    unsigned long vlen, loff_t *pos, rwf_t flags)
 983 {
 984         struct iovec iovstack[UIO_FASTIOV];
 985         struct iovec *iov = iovstack;
 986         struct iov_iter iter;
 987         ssize_t ret;
 988
 989         ret = import_iovec(WRITE, vec, vlen, ARRAY_SIZE(iovstack), &iov, &iter);
 990         if (ret >= 0) {
 991                 file_start_write(file);
 992                 ret = do_iter_write(file, &iter, pos, flags);
 993                 file_end_write(file);
 994                 kfree(iov);
 995         }
 996         return ret;
 997 }
 998
 999 static ssize_t do_readv(unsigned long fd, const struct iovec __user *vec,
1000                         unsigned long vlen, rwf_t flags)
1001 {
1002         struct fd f = fdget_pos(fd);
1003         ssize_t ret = -EBADF;
1004
1005         if (f.file) {
1006                 loff_t pos = file_pos_read(f.file);
1007                 ret = vfs_readv(f.file, vec, vlen, &pos, flags);
1008                 if (ret >= 0)
1009                         file_pos_write(f.file, pos);
1010                 fdput_pos(f);
1011         }
1012
1013         if (ret > 0)
1014                 add_rchar(current, ret);
1015         inc_syscr(current);
1016         return ret;
1017 }
1018
1019 static ssize_t do_writev(unsigned long fd, const struct iovec __user *vec,
1020                          unsigned long vlen, rwf_t flags)
1021 {
1022         struct fd f = fdget_pos(fd);
1023         ssize_t ret = -EBADF;
1024
1025         if (f.file) {
1026                 loff_t pos = file_pos_read(f.file);
1027                 ret = vfs_writev(f.file, vec, vlen, &pos, flags);
1028                 if (ret >= 0)
1029                         file_pos_write(f.file, pos);
1030                 fdput_pos(f);
1031         }
1032
1033         if (ret > 0)
1034                 add_wchar(current, ret);
1035         inc_syscw(current);
1036         return ret;
1037 }
1038
1039 static inline loff_t pos_from_hilo(unsigned long high, unsigned long low)
1040 {
1041 #define HALF_LONG_BITS (BITS_PER_LONG / 2)
1042         return (((loff_t)high << HALF_LONG_BITS) << HALF_LONG_BITS) | low;
1043 }
1044
1045 static ssize_t do_preadv(unsigned long fd, const struct iovec __user *vec,
1046                          unsigned long vlen, loff_t pos, rwf_t flags)
1047 {
1048         struct fd f;
1049         ssize_t ret = -EBADF;
1050
1051         if (pos < 0)
1052                 return -EINVAL;
1053
1054         f = fdget(fd);
1055         if (f.file) {
1056                 ret = -ESPIPE;
1057                 if (f.file->f_mode & FMODE_PREAD)
1058                         ret = vfs_readv(f.file, vec, vlen, &pos, flags);
1059                 fdput(f);
1060         }
1061
1062         if (ret > 0)
1063                 add_rchar(current, ret);
1064         inc_syscr(current);
1065         return ret;
1066 }
1067
1068 static ssize_t do_pwritev(unsigned long fd, const struct iovec __user *vec,
1069                           unsigned long vlen, loff_t pos, rwf_t flags)
1070 {
1071         struct fd f;
1072         ssize_t ret = -EBADF;
1073
1074         if (pos < 0)
1075                 return -EINVAL;
1076
1077         f = fdget(fd);
1078         if (f.file) {
1079                 ret = -ESPIPE;
1080                 if (f.file->f_mode & FMODE_PWRITE)
1081                         ret = vfs_writev(f.file, vec, vlen, &pos, flags);
1082                 fdput(f);
1083         }
1084
1085         if (ret > 0)
1086                 add_wchar(current, ret);
1087         inc_syscw(current);
1088         return ret;
1089 }
1090
1091 SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
1092                 unsigned long, vlen)
1093 {
1094         return do_readv(fd, vec, vlen, 0);
1095 }
1096
1097 SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *, vec,
1098                 unsigned long, vlen)
1099 {
1100         return do_writev(fd, vec, vlen, 0);
1101 }
1102
1103 SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
1104                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
1105 {
1106         loff_t pos = pos_from_hilo(pos_h, pos_l);
1107
1108         return do_preadv(fd, vec, vlen, pos, 0);
1109 }
1110
1111 SYSCALL_DEFINE6(preadv2, unsigned long, fd, const struct iovec __user *, vec,
1112                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h,
1113                 rwf_t, flags)
1114 {
1115         loff_t pos = pos_from_hilo(pos_h, pos_l);
1116
1117         if (pos == -1)
1118                 return do_readv(fd, vec, vlen, flags);
1119
1120         return do_preadv(fd, vec, vlen, pos, flags);
1121 }
1122
1123 SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
1124                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
1125 {
1126         loff_t pos = pos_from_hilo(pos_h, pos_l);
1127
1128         return do_pwritev(fd, vec, vlen, pos, 0);
1129 }
1130
1131 SYSCALL_DEFINE6(pwritev2, unsigned long, fd, const struct iovec __user *, vec,
1132                 unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h,
1133                 rwf_t, flags)
1134 {
1135         loff_t pos = pos_from_hilo(pos_h, pos_l);
1136
1137         if (pos == -1)
1138                 return do_writev(fd, vec, vlen, flags);
1139
1140         return do_pwritev(fd, vec, vlen, pos, flags);
1141 }
1142
1143 #ifdef CONFIG_COMPAT
1144 static size_t compat_readv(struct file *file,
1145                            const struct compat_iovec __user *vec,
1146                            unsigned long vlen, loff_t *pos, rwf_t flags)
1147 {
1148         struct iovec iovstack[UIO_FASTIOV];
1149         struct iovec *iov = iovstack;
1150         struct iov_iter iter;
1151         ssize_t ret;
1152
1153         ret = compat_import_iovec(READ, vec, vlen, UIO_FASTIOV, &iov, &iter);
1154         if (ret >= 0) {
1155                 ret = do_iter_read(file, &iter, pos, flags);
1156                 kfree(iov);
1157         }
1158         if (ret > 0)
1159                 add_rchar(current, ret);
1160         inc_syscr(current);
1161         return ret;
1162 }
1163
1164 static size_t do_compat_readv(compat_ulong_t fd,
1165                                  const struct compat_iovec __user *vec,
1166                                  compat_ulong_t vlen, rwf_t flags)
1167 {
1168         struct fd f = fdget_pos(fd);
1169         ssize_t ret;
1170         loff_t pos;
1171
1172         if (!f.file)
1173                 return -EBADF;
1174         pos = f.file->f_pos;
1175         ret = compat_readv(f.file, vec, vlen, &pos, flags);
1176         if (ret >= 0)
1177                 f.file->f_pos = pos;
1178         fdput_pos(f);
1179         return ret;
1180
1181 }
1182
1183 COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
1184                 const struct compat_iovec __user *,vec,
1185                 compat_ulong_t, vlen)
1186 {
1187         return do_compat_readv(fd, vec, vlen, 0);
1188 }
1189
1190 static long do_compat_preadv64(unsigned long fd,
1191                                   const struct compat_iovec __user *vec,
1192                                   unsigned long vlen, loff_t pos, rwf_t flags)
1193 {
1194         struct fd f;
1195         ssize_t ret;
1196
1197         if (pos < 0)
1198                 return -EINVAL;
1199         f = fdget(fd);
1200         if (!f.file)
1201                 return -EBADF;
1202         ret = -ESPIPE;
1203         if (f.file->f_mode & FMODE_PREAD)
1204                 ret = compat_readv(f.file, vec, vlen, &pos, flags);
1205         fdput(f);
1206         return ret;
1207 }
1208
1209 #ifdef __ARCH_WANT_COMPAT_SYS_PREADV64
1210 COMPAT_SYSCALL_DEFINE4(preadv64, unsigned long, fd,
1211                 const struct compat_iovec __user *,vec,
1212                 unsigned long, vlen, loff_t, pos)
1213 {
1214         return do_compat_preadv64(fd, vec, vlen, pos, 0);
1215 }
1216 #endif
1217
1218 COMPAT_SYSCALL_DEFINE5(preadv, compat_ulong_t, fd,
1219                 const struct compat_iovec __user *,vec,
1220                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high)
1221 {
1222         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1223
1224         return do_compat_preadv64(fd, vec, vlen, pos, 0);
1225 }
1226
1227 #ifdef __ARCH_WANT_COMPAT_SYS_PREADV64V2
1228 COMPAT_SYSCALL_DEFINE5(preadv64v2, unsigned long, fd,
1229                 const struct compat_iovec __user *,vec,
1230                 unsigned long, vlen, loff_t, pos, rwf_t, flags)
1231 {
1232         return do_compat_preadv64(fd, vec, vlen, pos, flags);
1233 }
1234 #endif
1235
1236 COMPAT_SYSCALL_DEFINE6(preadv2, compat_ulong_t, fd,
1237                 const struct compat_iovec __user *,vec,
1238                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high,
1239                 rwf_t, flags)
1240 {
1241         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1242
1243         if (pos == -1)
1244                 return do_compat_readv(fd, vec, vlen, flags);
1245
1246         return do_compat_preadv64(fd, vec, vlen, pos, flags);
1247 }
1248
1249 static size_t compat_writev(struct file *file,
1250                             const struct compat_iovec __user *vec,
1251                             unsigned long vlen, loff_t *pos, rwf_t flags)
1252 {
1253         struct iovec iovstack[UIO_FASTIOV];
1254         struct iovec *iov = iovstack;
1255         struct iov_iter iter;
1256         ssize_t ret;
1257
1258         ret = compat_import_iovec(WRITE, vec, vlen, UIO_FASTIOV, &iov, &iter);
1259         if (ret >= 0) {
1260                 file_start_write(file);
1261                 ret = do_iter_write(file, &iter, pos, flags);
1262                 file_end_write(file);
1263                 kfree(iov);
1264         }
1265         if (ret > 0)
1266                 add_wchar(current, ret);
1267         inc_syscw(current);
1268         return ret;
1269 }
1270
1271 static size_t do_compat_writev(compat_ulong_t fd,
1272                                   const struct compat_iovec __user* vec,
1273                                   compat_ulong_t vlen, rwf_t flags)
1274 {
1275         struct fd f = fdget_pos(fd);
1276         ssize_t ret;
1277         loff_t pos;
1278
1279         if (!f.file)
1280                 return -EBADF;
1281         pos = f.file->f_pos;
1282         ret = compat_writev(f.file, vec, vlen, &pos, flags);
1283         if (ret >= 0)
1284                 f.file->f_pos = pos;
1285         fdput_pos(f);
1286         return ret;
1287 }
1288
1289 COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
1290                 const struct compat_iovec __user *, vec,
1291                 compat_ulong_t, vlen)
1292 {
1293         return do_compat_writev(fd, vec, vlen, 0);
1294 }
1295
1296 static long do_compat_pwritev64(unsigned long fd,
1297                                    const struct compat_iovec __user *vec,
1298                                    unsigned long vlen, loff_t pos, rwf_t flags)
1299 {
1300         struct fd f;
1301         ssize_t ret;
1302
1303         if (pos < 0)
1304                 return -EINVAL;
1305         f = fdget(fd);
1306         if (!f.file)
1307                 return -EBADF;
1308         ret = -ESPIPE;
1309         if (f.file->f_mode & FMODE_PWRITE)
1310                 ret = compat_writev(f.file, vec, vlen, &pos, flags);
1311         fdput(f);
1312         return ret;
1313 }
1314
1315 #ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64
1316 COMPAT_SYSCALL_DEFINE4(pwritev64, unsigned long, fd,
1317                 const struct compat_iovec __user *,vec,
1318                 unsigned long, vlen, loff_t, pos)
1319 {
1320         return do_compat_pwritev64(fd, vec, vlen, pos, 0);
1321 }
1322 #endif
1323
1324 COMPAT_SYSCALL_DEFINE5(pwritev, compat_ulong_t, fd,
1325                 const struct compat_iovec __user *,vec,
1326                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high)
1327 {
1328         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1329
1330         return do_compat_pwritev64(fd, vec, vlen, pos, 0);
1331 }
1332
1333 #ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64V2
1334 COMPAT_SYSCALL_DEFINE5(pwritev64v2, unsigned long, fd,
1335                 const struct compat_iovec __user *,vec,
1336                 unsigned long, vlen, loff_t, pos, rwf_t, flags)
1337 {
1338         return do_compat_pwritev64(fd, vec, vlen, pos, flags);
1339 }
1340 #endif
1341
1342 COMPAT_SYSCALL_DEFINE6(pwritev2, compat_ulong_t, fd,
1343                 const struct compat_iovec __user *,vec,
1344                 compat_ulong_t, vlen, u32, pos_low, u32, pos_high, rwf_t, flags)
1345 {
1346         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
1347
1348         if (pos == -1)
1349                 return do_compat_writev(fd, vec, vlen, flags);
1350
1351         return do_compat_pwritev64(fd, vec, vlen, pos, flags);
1352 }
1353
1354 #endif
1355
1356 static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
1357                            size_t count, loff_t max)
1358 {
1359         struct fd in, out;
1360         struct inode *in_inode, *out_inode;
1361         loff_t pos;
1362         loff_t out_pos;
1363         ssize_t retval;
1364         int fl;
1365
1366         /*
1367          * Get input file, and verify that it is ok..
1368          */
1369         retval = -EBADF;
1370         in = fdget(in_fd);
1371         if (!in.file)
1372                 goto out;
1373         if (!(in.file->f_mode & FMODE_READ))
1374                 goto fput_in;
1375         retval = -ESPIPE;
1376         if (!ppos) {
1377                 pos = in.file->f_pos;
1378         } else {
1379                 pos = *ppos;
1380                 if (!(in.file->f_mode & FMODE_PREAD))
1381                         goto fput_in;
1382         }
1383         retval = rw_verify_area(READ, in.file, &pos, count);
1384         if (retval < 0)
1385                 goto fput_in;
1386         if (count > MAX_RW_COUNT)
1387                 count =  MAX_RW_COUNT;
1388
1389         /*
1390          * Get output file, and verify that it is ok..
1391          */
1392         retval = -EBADF;
1393         out = fdget(out_fd);
1394         if (!out.file)
1395                 goto fput_in;
1396         if (!(out.file->f_mode & FMODE_WRITE))
1397                 goto fput_out;
1398         retval = -EINVAL;
1399         in_inode = file_inode(in.file);
1400         out_inode = file_inode(out.file);
1401         out_pos = out.file->f_pos;
1402         retval = rw_verify_area(WRITE, out.file, &out_pos, count);
1403         if (retval < 0)
1404                 goto fput_out;
1405
1406         if (!max)
1407                 max = min(in_inode->i_sb->s_maxbytes, out_inode->i_sb->s_maxbytes);
1408
1409         if (unlikely(pos + count > max)) {
1410                 retval = -EOVERFLOW;
1411                 if (pos >= max)
1412                         goto fput_out;
1413                 count = max - pos;
1414         }
1415
1416         fl = 0;
1417 #if 0
1418         /*
1419          * We need to debate whether we can enable this or not. The
1420          * man page documents EAGAIN return for the output at least,
1421          * and the application is arguably buggy if it doesn't expect
1422          * EAGAIN on a non-blocking file descriptor.
1423          */
1424         if (in.file->f_flags & O_NONBLOCK)
1425                 fl = SPLICE_F_NONBLOCK;
1426 #endif
1427         file_start_write(out.file);
1428         retval = do_splice_direct(in.file, &pos, out.file, &out_pos, count, fl);
1429         file_end_write(out.file);
1430
1431         if (retval > 0) {
1432                 add_rchar(current, retval);
1433                 add_wchar(current, retval);
1434                 fsnotify_access(in.file);
1435                 fsnotify_modify(out.file);
1436                 out.file->f_pos = out_pos;
1437                 if (ppos)
1438                         *ppos = pos;
1439                 else
1440                         in.file->f_pos = pos;
1441         }
1442
1443         inc_syscr(current);
1444         inc_syscw(current);
1445         if (pos > max)
1446                 retval = -EOVERFLOW;
1447
1448 fput_out:
1449         fdput(out);
1450 fput_in:
1451         fdput(in);
1452 out:
1453         return retval;
1454 }
1455
1456 SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd, off_t __user *, offset, size_t, count)
1457 {
1458         loff_t pos;
1459         off_t off;
1460         ssize_t ret;
1461
1462         if (offset) {
1463                 if (unlikely(get_user(off, offset)))
1464                         return -EFAULT;
1465                 pos = off;
1466                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
1467                 if (unlikely(put_user(pos, offset)))
1468                         return -EFAULT;
1469                 return ret;
1470         }
1471
1472         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1473 }
1474
1475 SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, loff_t __user *, offset, size_t, count)
1476 {
1477         loff_t pos;
1478         ssize_t ret;
1479
1480         if (offset) {
1481                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1482                         return -EFAULT;
1483                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1484                 if (unlikely(put_user(pos, offset)))
1485                         return -EFAULT;
1486                 return ret;
1487         }
1488
1489         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1490 }
1491
1492 #ifdef CONFIG_COMPAT
1493 COMPAT_SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd,
1494                 compat_off_t __user *, offset, compat_size_t, count)
1495 {
1496         loff_t pos;
1497         off_t off;
1498         ssize_t ret;
1499
1500         if (offset) {
1501                 if (unlikely(get_user(off, offset)))
1502                         return -EFAULT;
1503                 pos = off;
1504                 ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
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
1513 COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd,
1514                 compat_loff_t __user *, offset, compat_size_t, count)
1515 {
1516         loff_t pos;
1517         ssize_t ret;
1518
1519         if (offset) {
1520                 if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
1521                         return -EFAULT;
1522                 ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
1523                 if (unlikely(put_user(pos, offset)))
1524                         return -EFAULT;
1525                 return ret;
1526         }
1527
1528         return do_sendfile(out_fd, in_fd, NULL, count, 0);
1529 }
1530 #endif
1531
1532 /*
1533  * copy_file_range() differs from regular file read and write in that it
1534  * specifically allows return partial success.  When it does so is up to
1535  * the copy_file_range method.
1536  */
1537 ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,
1538                             struct file *file_out, loff_t pos_out,
1539                             size_t len, unsigned int flags)
1540 {
1541         struct inode *inode_in = file_inode(file_in);
1542         struct inode *inode_out = file_inode(file_out);
1543         ssize_t ret;
1544
1545         if (flags != 0)
1546                 return -EINVAL;
1547
1548         if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode))
1549                 return -EISDIR;
1550         if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode))
1551                 return -EINVAL;
1552
1553         ret = rw_verify_area(READ, file_in, &pos_in, len);
1554         if (unlikely(ret))
1555                 return ret;
1556
1557         ret = rw_verify_area(WRITE, file_out, &pos_out, len);
1558         if (unlikely(ret))
1559                 return ret;
1560
1561         if (!(file_in->f_mode & FMODE_READ) ||
1562             !(file_out->f_mode & FMODE_WRITE) ||
1563             (file_out->f_flags & O_APPEND))
1564                 return -EBADF;
1565
1566         /* this could be relaxed once a method supports cross-fs copies */
1567         if (inode_in->i_sb != inode_out->i_sb)
1568                 return -EXDEV;
1569
1570         if (len == 0)
1571                 return 0;
1572
1573         file_start_write(file_out);
1574
1575         /*
1576          * Try cloning first, this is supported by more file systems, and
1577          * more efficient if both clone and copy are supported (e.g. NFS).
1578          */
1579         if (file_in->f_op->clone_file_range) {
1580                 ret = file_in->f_op->clone_file_range(file_in, pos_in,
1581                                 file_out, pos_out, len);
1582                 if (ret == 0) {
1583                         ret = len;
1584                         goto done;
1585                 }
1586         }
1587
1588         if (file_out->f_op->copy_file_range) {
1589                 ret = file_out->f_op->copy_file_range(file_in, pos_in, file_out,
1590                                                       pos_out, len, flags);
1591                 if (ret != -EOPNOTSUPP)
1592                         goto done;
1593         }
1594
1595         ret = do_splice_direct(file_in, &pos_in, file_out, &pos_out,
1596                         len > MAX_RW_COUNT ? MAX_RW_COUNT : len, 0);
1597
1598 done:
1599         if (ret > 0) {
1600                 fsnotify_access(file_in);
1601                 add_rchar(current, ret);
1602                 fsnotify_modify(file_out);
1603                 add_wchar(current, ret);
1604         }
1605
1606         inc_syscr(current);
1607         inc_syscw(current);
1608
1609         file_end_write(file_out);
1610
1611         return ret;
1612 }
1613 EXPORT_SYMBOL(vfs_copy_file_range);
1614
1615 SYSCALL_DEFINE6(copy_file_range, int, fd_in, loff_t __user *, off_in,
1616                 int, fd_out, loff_t __user *, off_out,
1617                 size_t, len, unsigned int, flags)
1618 {
1619         loff_t pos_in;
1620         loff_t pos_out;
1621         struct fd f_in;
1622         struct fd f_out;
1623         ssize_t ret = -EBADF;
1624
1625         f_in = fdget(fd_in);
1626         if (!f_in.file)
1627                 goto out2;
1628
1629         f_out = fdget(fd_out);
1630         if (!f_out.file)
1631                 goto out1;
1632
1633         ret = -EFAULT;
1634         if (off_in) {
1635                 if (copy_from_user(&pos_in, off_in, sizeof(loff_t)))
1636                         goto out;
1637         } else {
1638                 pos_in = f_in.file->f_pos;
1639         }
1640
1641         if (off_out) {
1642                 if (copy_from_user(&pos_out, off_out, sizeof(loff_t)))
1643                         goto out;
1644         } else {
1645                 pos_out = f_out.file->f_pos;
1646         }
1647
1648         ret = vfs_copy_file_range(f_in.file, pos_in, f_out.file, pos_out, len,
1649                                   flags);
1650         if (ret > 0) {
1651                 pos_in += ret;
1652                 pos_out += ret;
1653
1654                 if (off_in) {
1655                         if (copy_to_user(off_in, &pos_in, sizeof(loff_t)))
1656                                 ret = -EFAULT;
1657                 } else {
1658                         f_in.file->f_pos = pos_in;
1659                 }
1660
1661                 if (off_out) {
1662                         if (copy_to_user(off_out, &pos_out, sizeof(loff_t)))
1663                                 ret = -EFAULT;
1664                 } else {
1665                         f_out.file->f_pos = pos_out;
1666                 }
1667         }
1668
1669 out:
1670         fdput(f_out);
1671 out1:
1672         fdput(f_in);
1673 out2:
1674         return ret;
1675 }
1676
1677 static int clone_verify_area(struct file *file, loff_t pos, u64 len, bool write)
1678 {
1679         struct inode *inode = file_inode(file);
1680
1681         if (unlikely(pos < 0))
1682                 return -EINVAL;
1683
1684          if (unlikely((loff_t) (pos + len) < 0))
1685                 return -EINVAL;
1686
1687         if (unlikely(inode->i_flctx && mandatory_lock(inode))) {
1688                 loff_t end = len ? pos + len - 1 : OFFSET_MAX;
1689                 int retval;
1690
1691                 retval = locks_mandatory_area(inode, file, pos, end,
1692                                 write ? F_WRLCK : F_RDLCK);
1693                 if (retval < 0)
1694                         return retval;
1695         }
1696
1697         return security_file_permission(file, write ? MAY_WRITE : MAY_READ);
1698 }
1699
1700 /*
1701  * Check that the two inodes are eligible for cloning, the ranges make
1702  * sense, and then flush all dirty data.  Caller must ensure that the
1703  * inodes have been locked against any other modifications.
1704  *
1705  * Returns: 0 for "nothing to clone", 1 for "something to clone", or
1706  * the usual negative error code.
1707  */
1708 int vfs_clone_file_prep_inodes(struct inode *inode_in, loff_t pos_in,
1709                                struct inode *inode_out, loff_t pos_out,
1710                                u64 *len, bool is_dedupe)
1711 {
1712         loff_t bs = inode_out->i_sb->s_blocksize;
1713         loff_t blen;
1714         loff_t isize;
1715         bool same_inode = (inode_in == inode_out);
1716         int ret;
1717
1718         /* Don't touch certain kinds of inodes */
1719         if (IS_IMMUTABLE(inode_out))
1720                 return -EPERM;
1721
1722         if (IS_SWAPFILE(inode_in) || IS_SWAPFILE(inode_out))
1723                 return -ETXTBSY;
1724
1725         /* Don't reflink dirs, pipes, sockets... */
1726         if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode))
1727                 return -EISDIR;
1728         if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode))
1729                 return -EINVAL;
1730
1731         /* Are we going all the way to the end? */
1732         isize = i_size_read(inode_in);
1733         if (isize == 0)
1734                 return 0;
1735
1736         /* Zero length dedupe exits immediately; reflink goes to EOF. */
1737         if (*len == 0) {
1738                 if (is_dedupe || pos_in == isize)
1739                         return 0;
1740                 if (pos_in > isize)
1741                         return -EINVAL;
1742                 *len = isize - pos_in;
1743         }
1744
1745         /* Ensure offsets don't wrap and the input is inside i_size */
1746         if (pos_in + *len < pos_in || pos_out + *len < pos_out ||
1747             pos_in + *len > isize)
1748                 return -EINVAL;
1749
1750         /* Don't allow dedupe past EOF in the dest file */
1751         if (is_dedupe) {
1752                 loff_t  disize;
1753
1754                 disize = i_size_read(inode_out);
1755                 if (pos_out >= disize || pos_out + *len > disize)
1756                         return -EINVAL;
1757         }
1758
1759         /* If we're linking to EOF, continue to the block boundary. */
1760         if (pos_in + *len == isize)
1761                 blen = ALIGN(isize, bs) - pos_in;
1762         else
1763                 blen = *len;
1764
1765         /* Only reflink if we're aligned to block boundaries */
1766         if (!IS_ALIGNED(pos_in, bs) || !IS_ALIGNED(pos_in + blen, bs) ||
1767             !IS_ALIGNED(pos_out, bs) || !IS_ALIGNED(pos_out + blen, bs))
1768                 return -EINVAL;
1769
1770         /* Don't allow overlapped reflink within the same file */
1771         if (same_inode) {
1772                 if (pos_out + blen > pos_in && pos_out < pos_in + blen)
1773                         return -EINVAL;
1774         }
1775
1776         /* Wait for the completion of any pending IOs on both files */
1777         inode_dio_wait(inode_in);
1778         if (!same_inode)
1779                 inode_dio_wait(inode_out);
1780
1781         ret = filemap_write_and_wait_range(inode_in->i_mapping,
1782                         pos_in, pos_in + *len - 1);
1783         if (ret)
1784                 return ret;
1785
1786         ret = filemap_write_and_wait_range(inode_out->i_mapping,
1787                         pos_out, pos_out + *len - 1);
1788         if (ret)
1789                 return ret;
1790
1791         /*
1792          * Check that the extents are the same.
1793          */
1794         if (is_dedupe) {
1795                 bool            is_same = false;
1796
1797                 ret = vfs_dedupe_file_range_compare(inode_in, pos_in,
1798                                 inode_out, pos_out, *len, &is_same);
1799                 if (ret)
1800                         return ret;
1801                 if (!is_same)
1802                         return -EBADE;
1803         }
1804
1805         return 1;
1806 }
1807 EXPORT_SYMBOL(vfs_clone_file_prep_inodes);
1808
1809 int vfs_clone_file_range(struct file *file_in, loff_t pos_in,
1810                 struct file *file_out, loff_t pos_out, u64 len)
1811 {
1812         struct inode *inode_in = file_inode(file_in);
1813         struct inode *inode_out = file_inode(file_out);
1814         int ret;
1815
1816         if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode))
1817                 return -EISDIR;
1818         if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode))
1819                 return -EINVAL;
1820
1821         /*
1822          * FICLONE/FICLONERANGE ioctls enforce that src and dest files are on
1823          * the same mount. Practically, they only need to be on the same file
1824          * system.
1825          */
1826         if (inode_in->i_sb != inode_out->i_sb)
1827                 return -EXDEV;
1828
1829         if (!(file_in->f_mode & FMODE_READ) ||
1830             !(file_out->f_mode & FMODE_WRITE) ||
1831             (file_out->f_flags & O_APPEND))
1832                 return -EBADF;
1833
1834         if (!file_in->f_op->clone_file_range)
1835                 return -EOPNOTSUPP;
1836
1837         ret = clone_verify_area(file_in, pos_in, len, false);
1838         if (ret)
1839                 return ret;
1840
1841         ret = clone_verify_area(file_out, pos_out, len, true);
1842         if (ret)
1843                 return ret;
1844
1845         if (pos_in + len > i_size_read(inode_in))
1846                 return -EINVAL;
1847
1848         ret = file_in->f_op->clone_file_range(file_in, pos_in,
1849                         file_out, pos_out, len);
1850         if (!ret) {
1851                 fsnotify_access(file_in);
1852                 fsnotify_modify(file_out);
1853         }
1854
1855         return ret;
1856 }
1857 EXPORT_SYMBOL(vfs_clone_file_range);
1858
1859 /*
1860  * Read a page's worth of file data into the page cache.  Return the page
1861  * locked.
1862  */
1863 static struct page *vfs_dedupe_get_page(struct inode *inode, loff_t offset)
1864 {
1865         struct address_space *mapping;
1866         struct page *page;
1867         pgoff_t n;
1868
1869         n = offset >> PAGE_SHIFT;
1870         mapping = inode->i_mapping;
1871         page = read_mapping_page(mapping, n, NULL);
1872         if (IS_ERR(page))
1873                 return page;
1874         if (!PageUptodate(page)) {
1875                 put_page(page);
1876                 return ERR_PTR(-EIO);
1877         }
1878         lock_page(page);
1879         return page;
1880 }
1881
1882 /*
1883  * Compare extents of two files to see if they are the same.
1884  * Caller must have locked both inodes to prevent write races.
1885  */
1886 int vfs_dedupe_file_range_compare(struct inode *src, loff_t srcoff,
1887                                   struct inode *dest, loff_t destoff,
1888                                   loff_t len, bool *is_same)
1889 {
1890         loff_t src_poff;
1891         loff_t dest_poff;
1892         void *src_addr;
1893         void *dest_addr;
1894         struct page *src_page;
1895         struct page *dest_page;
1896         loff_t cmp_len;
1897         bool same;
1898         int error;
1899
1900         error = -EINVAL;
1901         same = true;
1902         while (len) {
1903                 src_poff = srcoff & (PAGE_SIZE - 1);
1904                 dest_poff = destoff & (PAGE_SIZE - 1);
1905                 cmp_len = min(PAGE_SIZE - src_poff,
1906                               PAGE_SIZE - dest_poff);
1907                 cmp_len = min(cmp_len, len);
1908                 if (cmp_len <= 0)
1909                         goto out_error;
1910
1911                 src_page = vfs_dedupe_get_page(src, srcoff);
1912                 if (IS_ERR(src_page)) {
1913                         error = PTR_ERR(src_page);
1914                         goto out_error;
1915                 }
1916                 dest_page = vfs_dedupe_get_page(dest, destoff);
1917                 if (IS_ERR(dest_page)) {
1918                         error = PTR_ERR(dest_page);
1919                         unlock_page(src_page);
1920                         put_page(src_page);
1921                         goto out_error;
1922                 }
1923                 src_addr = kmap_atomic(src_page);
1924                 dest_addr = kmap_atomic(dest_page);
1925
1926                 flush_dcache_page(src_page);
1927                 flush_dcache_page(dest_page);
1928
1929                 if (memcmp(src_addr + src_poff, dest_addr + dest_poff, cmp_len))
1930                         same = false;
1931
1932                 kunmap_atomic(dest_addr);
1933                 kunmap_atomic(src_addr);
1934                 unlock_page(dest_page);
1935                 unlock_page(src_page);
1936                 put_page(dest_page);
1937                 put_page(src_page);
1938
1939                 if (!same)
1940                         break;
1941
1942                 srcoff += cmp_len;
1943                 destoff += cmp_len;
1944                 len -= cmp_len;
1945         }
1946
1947         *is_same = same;
1948         return 0;
1949
1950 out_error:
1951         return error;
1952 }
1953 EXPORT_SYMBOL(vfs_dedupe_file_range_compare);
1954
1955 int vfs_dedupe_file_range(struct file *file, struct file_dedupe_range *same)
1956 {
1957         struct file_dedupe_range_info *info;
1958         struct inode *src = file_inode(file);
1959         u64 off;
1960         u64 len;
1961         int i;
1962         int ret;
1963         bool is_admin = capable(CAP_SYS_ADMIN);
1964         u16 count = same->dest_count;
1965         struct file *dst_file;
1966         loff_t dst_off;
1967         ssize_t deduped;
1968
1969         if (!(file->f_mode & FMODE_READ))
1970                 return -EINVAL;
1971
1972         if (same->reserved1 || same->reserved2)
1973                 return -EINVAL;
1974
1975         off = same->src_offset;
1976         len = same->src_length;
1977
1978         ret = -EISDIR;
1979         if (S_ISDIR(src->i_mode))
1980                 goto out;
1981
1982         ret = -EINVAL;
1983         if (!S_ISREG(src->i_mode))
1984                 goto out;
1985
1986         ret = clone_verify_area(file, off, len, false);
1987         if (ret < 0)
1988                 goto out;
1989         ret = 0;
1990
1991         if (off + len > i_size_read(src))
1992                 return -EINVAL;
1993
1994         /* pre-format output fields to sane values */
1995         for (i = 0; i < count; i++) {
1996                 same->info[i].bytes_deduped = 0ULL;
1997                 same->info[i].status = FILE_DEDUPE_RANGE_SAME;
1998         }
1999
2000         for (i = 0, info = same->info; i < count; i++, info++) {
2001                 struct inode *dst;
2002                 struct fd dst_fd = fdget(info->dest_fd);
2003
2004                 dst_file = dst_fd.file;
2005                 if (!dst_file) {
2006                         info->status = -EBADF;
2007                         goto next_loop;
2008                 }
2009                 dst = file_inode(dst_file);
2010
2011                 ret = mnt_want_write_file(dst_file);
2012                 if (ret) {
2013                         info->status = ret;
2014                         goto next_loop;
2015                 }
2016
2017                 dst_off = info->dest_offset;
2018                 ret = clone_verify_area(dst_file, dst_off, len, true);
2019                 if (ret < 0) {
2020                         info->status = ret;
2021                         goto next_file;
2022                 }
2023                 ret = 0;
2024
2025                 if (info->reserved) {
2026                         info->status = -EINVAL;
2027                 } else if (!(is_admin || (dst_file->f_mode & FMODE_WRITE))) {
2028                         info->status = -EINVAL;
2029                 } else if (file->f_path.mnt != dst_file->f_path.mnt) {
2030                         info->status = -EXDEV;
2031                 } else if (S_ISDIR(dst->i_mode)) {
2032                         info->status = -EISDIR;
2033                 } else if (dst_file->f_op->dedupe_file_range == NULL) {
2034                         info->status = -EINVAL;
2035                 } else {
2036                         deduped = dst_file->f_op->dedupe_file_range(file, off,
2037                                                         len, dst_file,
2038                                                         info->dest_offset);
2039                         if (deduped == -EBADE)
2040                                 info->status = FILE_DEDUPE_RANGE_DIFFERS;
2041                         else if (deduped < 0)
2042                                 info->status = deduped;
2043                         else
2044                                 info->bytes_deduped += deduped;
2045                 }
2046
2047 next_file:
2048                 mnt_drop_write_file(dst_file);
2049 next_loop:
2050                 fdput(dst_fd);
2051
2052                 if (fatal_signal_pending(current))
2053                         goto out;
2054         }
2055
2056 out:
2057         return ret;
2058 }
2059 EXPORT_SYMBOL(vfs_dedupe_file_range);