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