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