fs/read_write.c

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