fs/overlayfs/file.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2017 Red Hat, Inc.
   4  */
   5
   6 #include <linux/cred.h>
   7 #include <linux/file.h>
   8 #include <linux/mount.h>
   9 #include <linux/xattr.h>
  10 #include <linux/uio.h>
  11 #include <linux/uaccess.h>
  12 #include <linux/splice.h>
  13 #include <linux/security.h>
  14 #include <linux/mm.h>
  15 #include <linux/fs.h>
  16 #include "overlayfs.h"
  17
  18 struct ovl_aio_req {
  19         struct kiocb iocb;
  20         struct kiocb *orig_iocb;
  21         struct fd fd;
  22 };
  23
  24 static struct kmem_cache *ovl_aio_request_cachep;
  25
  26 static char ovl_whatisit(struct inode *inode, struct inode *realinode)
  27 {
  28         if (realinode != ovl_inode_upper(inode))
  29                 return 'l';
  30         if (ovl_has_upperdata(inode))
  31                 return 'u';
  32         else
  33                 return 'm';
  34 }
  35
  36 static struct file *ovl_open_realfile(const struct file *file,
  37                                       struct inode *realinode)
  38 {
  39         struct inode *inode = file_inode(file);
  40         struct file *realfile;
  41         const struct cred *old_cred;
  42         int flags = file->f_flags | O_NOATIME | FMODE_NONOTIFY;
  43         int acc_mode = ACC_MODE(flags);
  44         int err;
  45
  46         if (flags & O_APPEND)
  47                 acc_mode |= MAY_APPEND;
  48
  49         old_cred = ovl_override_creds(inode->i_sb);
  50         err = inode_permission(realinode, MAY_OPEN | acc_mode);
  51         if (err) {
  52                 realfile = ERR_PTR(err);
  53         } else if (!inode_owner_or_capable(realinode)) {
  54                 realfile = ERR_PTR(-EPERM);
  55         } else {
  56                 realfile = open_with_fake_path(&file->f_path, flags, realinode,
  57                                                current_cred());
  58         }
  59         revert_creds(old_cred);
  60
  61         pr_debug("open(%p[%pD2/%c], 0%o) -> (%p, 0%o)\n",
  62                  file, file, ovl_whatisit(inode, realinode), file->f_flags,
  63                  realfile, IS_ERR(realfile) ? 0 : realfile->f_flags);
  64
  65         return realfile;
  66 }
  67
  68 #define OVL_SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT)
  69
  70 static int ovl_change_flags(struct file *file, unsigned int flags)
  71 {
  72         struct inode *inode = file_inode(file);
  73         int err;
  74
  75         /* No atime modificaton on underlying */
  76         flags |= O_NOATIME | FMODE_NONOTIFY;
  77
  78         /* If some flag changed that cannot be changed then something's amiss */
  79         if (WARN_ON((file->f_flags ^ flags) & ~OVL_SETFL_MASK))
  80                 return -EIO;
  81
  82         flags &= OVL_SETFL_MASK;
  83
  84         if (((flags ^ file->f_flags) & O_APPEND) && IS_APPEND(inode))
  85                 return -EPERM;
  86
  87         if (flags & O_DIRECT) {
  88                 if (!file->f_mapping->a_ops ||
  89                     !file->f_mapping->a_ops->direct_IO)
  90                         return -EINVAL;
  91         }
  92
  93         if (file->f_op->check_flags) {
  94                 err = file->f_op->check_flags(flags);
  95                 if (err)
  96                         return err;
  97         }
  98
  99         spin_lock(&file->f_lock);
 100         file->f_flags = (file->f_flags & ~OVL_SETFL_MASK) | flags;
 101         spin_unlock(&file->f_lock);
 102
 103         return 0;
 104 }
 105
 106 static int ovl_real_fdget_meta(const struct file *file, struct fd *real,
 107                                bool allow_meta)
 108 {
 109         struct inode *inode = file_inode(file);
 110         struct inode *realinode;
 111
 112         real->flags = 0;
 113         real->file = file->private_data;
 114
 115         if (allow_meta)
 116                 realinode = ovl_inode_real(inode);
 117         else
 118                 realinode = ovl_inode_realdata(inode);
 119
 120         /* Has it been copied up since we'd opened it? */
 121         if (unlikely(file_inode(real->file) != realinode)) {
 122                 real->flags = FDPUT_FPUT;
 123                 real->file = ovl_open_realfile(file, realinode);
 124
 125                 return PTR_ERR_OR_ZERO(real->file);
 126         }
 127
 128         /* Did the flags change since open? */
 129         if (unlikely((file->f_flags ^ real->file->f_flags) & ~O_NOATIME))
 130                 return ovl_change_flags(real->file, file->f_flags);
 131
 132         return 0;
 133 }
 134
 135 static int ovl_real_fdget(const struct file *file, struct fd *real)
 136 {
 137         return ovl_real_fdget_meta(file, real, false);
 138 }
 139
 140 static int ovl_open(struct inode *inode, struct file *file)
 141 {
 142         struct file *realfile;
 143         int err;
 144
 145         err = ovl_maybe_copy_up(file_dentry(file), file->f_flags);
 146         if (err)
 147                 return err;
 148
 149         /* No longer need these flags, so don't pass them on to underlying fs */
 150         file->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
 151
 152         realfile = ovl_open_realfile(file, ovl_inode_realdata(inode));
 153         if (IS_ERR(realfile))
 154                 return PTR_ERR(realfile);
 155
 156         file->private_data = realfile;
 157
 158         return 0;
 159 }
 160
 161 static int ovl_release(struct inode *inode, struct file *file)
 162 {
 163         fput(file->private_data);
 164
 165         return 0;
 166 }
 167
 168 static loff_t ovl_llseek(struct file *file, loff_t offset, int whence)
 169 {
 170         struct inode *inode = file_inode(file);
 171         struct fd real;
 172         const struct cred *old_cred;
 173         loff_t ret;
 174
 175         /*
 176          * The two special cases below do not need to involve real fs,
 177          * so we can optimizing concurrent callers.
 178          */
 179         if (offset == 0) {
 180                 if (whence == SEEK_CUR)
 181                         return file->f_pos;
 182
 183                 if (whence == SEEK_SET)
 184                         return vfs_setpos(file, 0, 0);
 185         }
 186
 187         ret = ovl_real_fdget(file, &real);
 188         if (ret)
 189                 return ret;
 190
 191         /*
 192          * Overlay file f_pos is the master copy that is preserved
 193          * through copy up and modified on read/write, but only real
 194          * fs knows how to SEEK_HOLE/SEEK_DATA and real fs may impose
 195          * limitations that are more strict than ->s_maxbytes for specific
 196          * files, so we use the real file to perform seeks.
 197          */
 198         ovl_inode_lock(inode);
 199         real.file->f_pos = file->f_pos;
 200
 201         old_cred = ovl_override_creds(inode->i_sb);
 202         ret = vfs_llseek(real.file, offset, whence);
 203         revert_creds(old_cred);
 204
 205         file->f_pos = real.file->f_pos;
 206         ovl_inode_unlock(inode);
 207
 208         fdput(real);
 209
 210         return ret;
 211 }
 212
 213 static void ovl_file_accessed(struct file *file)
 214 {
 215         struct inode *inode, *upperinode;
 216
 217         if (file->f_flags & O_NOATIME)
 218                 return;
 219
 220         inode = file_inode(file);
 221         upperinode = ovl_inode_upper(inode);
 222
 223         if (!upperinode)
 224                 return;
 225
 226         if ((!timespec64_equal(&inode->i_mtime, &upperinode->i_mtime) ||
 227              !timespec64_equal(&inode->i_ctime, &upperinode->i_ctime))) {
 228                 inode->i_mtime = upperinode->i_mtime;
 229                 inode->i_ctime = upperinode->i_ctime;
 230         }
 231
 232         touch_atime(&file->f_path);
 233 }
 234
 235 static rwf_t ovl_iocb_to_rwf(int ifl)
 236 {
 237         rwf_t flags = 0;
 238
 239         if (ifl & IOCB_NOWAIT)
 240                 flags |= RWF_NOWAIT;
 241         if (ifl & IOCB_HIPRI)
 242                 flags |= RWF_HIPRI;
 243         if (ifl & IOCB_DSYNC)
 244                 flags |= RWF_DSYNC;
 245         if (ifl & IOCB_SYNC)
 246                 flags |= RWF_SYNC;
 247
 248         return flags;
 249 }
 250
 251 static void ovl_aio_cleanup_handler(struct ovl_aio_req *aio_req)
 252 {
 253         struct kiocb *iocb = &aio_req->iocb;
 254         struct kiocb *orig_iocb = aio_req->orig_iocb;
 255
 256         if (iocb->ki_flags & IOCB_WRITE) {
 257                 struct inode *inode = file_inode(orig_iocb->ki_filp);
 258
 259                 /* Actually acquired in ovl_write_iter() */
 260                 __sb_writers_acquired(file_inode(iocb->ki_filp)->i_sb,
 261                                       SB_FREEZE_WRITE);
 262                 file_end_write(iocb->ki_filp);
 263                 ovl_copyattr(ovl_inode_real(inode), inode);
 264         }
 265
 266         orig_iocb->ki_pos = iocb->ki_pos;
 267         fdput(aio_req->fd);
 268         kmem_cache_free(ovl_aio_request_cachep, aio_req);
 269 }
 270
 271 static void ovl_aio_rw_complete(struct kiocb *iocb, long res, long res2)
 272 {
 273         struct ovl_aio_req *aio_req = container_of(iocb,
 274                                                    struct ovl_aio_req, iocb);
 275         struct kiocb *orig_iocb = aio_req->orig_iocb;
 276
 277         ovl_aio_cleanup_handler(aio_req);
 278         orig_iocb->ki_complete(orig_iocb, res, res2);
 279 }
 280
 281 static ssize_t ovl_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 282 {
 283         struct file *file = iocb->ki_filp;
 284         struct fd real;
 285         const struct cred *old_cred;
 286         ssize_t ret;
 287
 288         if (!iov_iter_count(iter))
 289                 return 0;
 290
 291         ret = ovl_real_fdget(file, &real);
 292         if (ret)
 293                 return ret;
 294
 295         old_cred = ovl_override_creds(file_inode(file)->i_sb);
 296         if (is_sync_kiocb(iocb)) {
 297                 ret = vfs_iter_read(real.file, iter, &iocb->ki_pos,
 298                                     ovl_iocb_to_rwf(iocb->ki_flags));
 299         } else {
 300                 struct ovl_aio_req *aio_req;
 301
 302                 ret = -ENOMEM;
 303                 aio_req = kmem_cache_zalloc(ovl_aio_request_cachep, GFP_KERNEL);
 304                 if (!aio_req)
 305                         goto out;
 306
 307                 aio_req->fd = real;
 308                 real.flags = 0;
 309                 aio_req->orig_iocb = iocb;
 310                 kiocb_clone(&aio_req->iocb, iocb, real.file);
 311                 aio_req->iocb.ki_complete = ovl_aio_rw_complete;
 312                 ret = vfs_iocb_iter_read(real.file, &aio_req->iocb, iter);
 313                 if (ret != -EIOCBQUEUED)
 314                         ovl_aio_cleanup_handler(aio_req);
 315         }
 316 out:
 317         revert_creds(old_cred);
 318         ovl_file_accessed(file);
 319
 320         fdput(real);
 321
 322         return ret;
 323 }
 324
 325 static ssize_t ovl_write_iter(struct kiocb *iocb, struct iov_iter *iter)
 326 {
 327         struct file *file = iocb->ki_filp;
 328         struct inode *inode = file_inode(file);
 329         struct fd real;
 330         const struct cred *old_cred;
 331         ssize_t ret;
 332
 333         if (!iov_iter_count(iter))
 334                 return 0;
 335
 336         inode_lock(inode);
 337         /* Update mode */
 338         ovl_copyattr(ovl_inode_real(inode), inode);
 339         ret = file_remove_privs(file);
 340         if (ret)
 341                 goto out_unlock;
 342
 343         ret = ovl_real_fdget(file, &real);
 344         if (ret)
 345                 goto out_unlock;
 346
 347         old_cred = ovl_override_creds(file_inode(file)->i_sb);
 348         if (is_sync_kiocb(iocb)) {
 349                 file_start_write(real.file);
 350                 ret = vfs_iter_write(real.file, iter, &iocb->ki_pos,
 351                                      ovl_iocb_to_rwf(iocb->ki_flags));
 352                 file_end_write(real.file);
 353                 /* Update size */
 354                 ovl_copyattr(ovl_inode_real(inode), inode);
 355         } else {
 356                 struct ovl_aio_req *aio_req;
 357
 358                 ret = -ENOMEM;
 359                 aio_req = kmem_cache_zalloc(ovl_aio_request_cachep, GFP_KERNEL);
 360                 if (!aio_req)
 361                         goto out;
 362
 363                 file_start_write(real.file);
 364                 /* Pacify lockdep, same trick as done in aio_write() */
 365                 __sb_writers_release(file_inode(real.file)->i_sb,
 366                                      SB_FREEZE_WRITE);
 367                 aio_req->fd = real;
 368                 real.flags = 0;
 369                 aio_req->orig_iocb = iocb;
 370                 kiocb_clone(&aio_req->iocb, iocb, real.file);
 371                 aio_req->iocb.ki_complete = ovl_aio_rw_complete;
 372                 ret = vfs_iocb_iter_write(real.file, &aio_req->iocb, iter);
 373                 if (ret != -EIOCBQUEUED)
 374                         ovl_aio_cleanup_handler(aio_req);
 375         }
 376 out:
 377         revert_creds(old_cred);
 378         fdput(real);
 379
 380 out_unlock:
 381         inode_unlock(inode);
 382
 383         return ret;
 384 }
 385
 386 static ssize_t ovl_splice_read(struct file *in, loff_t *ppos,
 387                          struct pipe_inode_info *pipe, size_t len,
 388                          unsigned int flags)
 389 {
 390         ssize_t ret;
 391         struct fd real;
 392         const struct cred *old_cred;
 393
 394         ret = ovl_real_fdget(in, &real);
 395         if (ret)
 396                 return ret;
 397
 398         old_cred = ovl_override_creds(file_inode(in)->i_sb);
 399         ret = generic_file_splice_read(real.file, ppos, pipe, len, flags);
 400         revert_creds(old_cred);
 401
 402         ovl_file_accessed(in);
 403         fdput(real);
 404         return ret;
 405 }
 406
 407 static ssize_t
 408 ovl_splice_write(struct pipe_inode_info *pipe, struct file *out,
 409                           loff_t *ppos, size_t len, unsigned int flags)
 410 {
 411         struct fd real;
 412         const struct cred *old_cred;
 413         ssize_t ret;
 414
 415         ret = ovl_real_fdget(out, &real);
 416         if (ret)
 417                 return ret;
 418
 419         old_cred = ovl_override_creds(file_inode(out)->i_sb);
 420         ret = iter_file_splice_write(pipe, real.file, ppos, len, flags);
 421         revert_creds(old_cred);
 422
 423         ovl_file_accessed(out);
 424         fdput(real);
 425         return ret;
 426 }
 427
 428 static int ovl_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 429 {
 430         struct fd real;
 431         const struct cred *old_cred;
 432         int ret;
 433
 434         ret = ovl_real_fdget_meta(file, &real, !datasync);
 435         if (ret)
 436                 return ret;
 437
 438         /* Don't sync lower file for fear of receiving EROFS error */
 439         if (file_inode(real.file) == ovl_inode_upper(file_inode(file))) {
 440                 old_cred = ovl_override_creds(file_inode(file)->i_sb);
 441                 ret = vfs_fsync_range(real.file, start, end, datasync);
 442                 revert_creds(old_cred);
 443         }
 444
 445         fdput(real);
 446
 447         return ret;
 448 }
 449
 450 static int ovl_mmap(struct file *file, struct vm_area_struct *vma)
 451 {
 452         struct file *realfile = file->private_data;
 453         const struct cred *old_cred;
 454         int ret;
 455
 456         if (!realfile->f_op->mmap)
 457                 return -ENODEV;
 458
 459         if (WARN_ON(file != vma->vm_file))
 460                 return -EIO;
 461
 462         vma->vm_file = get_file(realfile);
 463
 464         old_cred = ovl_override_creds(file_inode(file)->i_sb);
 465         ret = call_mmap(vma->vm_file, vma);
 466         revert_creds(old_cred);
 467
 468         if (ret) {
 469                 /* Drop reference count from new vm_file value */
 470                 fput(realfile);
 471         } else {
 472                 /* Drop reference count from previous vm_file value */
 473                 fput(file);
 474         }
 475
 476         ovl_file_accessed(file);
 477
 478         return ret;
 479 }
 480
 481 static long ovl_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
 482 {
 483         struct inode *inode = file_inode(file);
 484         struct fd real;
 485         const struct cred *old_cred;
 486         int ret;
 487
 488         ret = ovl_real_fdget(file, &real);
 489         if (ret)
 490                 return ret;
 491
 492         old_cred = ovl_override_creds(file_inode(file)->i_sb);
 493         ret = vfs_fallocate(real.file, mode, offset, len);
 494         revert_creds(old_cred);
 495
 496         /* Update size */
 497         ovl_copyattr(ovl_inode_real(inode), inode);
 498
 499         fdput(real);
 500
 501         return ret;
 502 }
 503
 504 static int ovl_fadvise(struct file *file, loff_t offset, loff_t len, int advice)
 505 {
 506         struct fd real;
 507         const struct cred *old_cred;
 508         int ret;
 509
 510         ret = ovl_real_fdget(file, &real);
 511         if (ret)
 512                 return ret;
 513
 514         old_cred = ovl_override_creds(file_inode(file)->i_sb);
 515         ret = vfs_fadvise(real.file, offset, len, advice);
 516         revert_creds(old_cred);
 517
 518         fdput(real);
 519
 520         return ret;
 521 }
 522
 523 static long ovl_real_ioctl(struct file *file, unsigned int cmd,
 524                            unsigned long arg)
 525 {
 526         struct fd real;
 527         const struct cred *old_cred;
 528         long ret;
 529
 530         ret = ovl_real_fdget(file, &real);
 531         if (ret)
 532                 return ret;
 533
 534         old_cred = ovl_override_creds(file_inode(file)->i_sb);
 535         ret = security_file_ioctl(real.file, cmd, arg);
 536         if (!ret)
 537                 ret = vfs_ioctl(real.file, cmd, arg);
 538         revert_creds(old_cred);
 539
 540         fdput(real);
 541
 542         return ret;
 543 }
 544
 545 static long ovl_ioctl_set_flags(struct file *file, unsigned int cmd,
 546                                 unsigned long arg, unsigned int iflags)
 547 {
 548         long ret;
 549         struct inode *inode = file_inode(file);
 550         unsigned int old_iflags;
 551
 552         if (!inode_owner_or_capable(inode))
 553                 return -EACCES;
 554
 555         ret = mnt_want_write_file(file);
 556         if (ret)
 557                 return ret;
 558
 559         inode_lock(inode);
 560
 561         /* Check the capability before cred override */
 562         ret = -EPERM;
 563         old_iflags = READ_ONCE(inode->i_flags);
 564         if (((iflags ^ old_iflags) & (S_APPEND | S_IMMUTABLE)) &&
 565             !capable(CAP_LINUX_IMMUTABLE))
 566                 goto unlock;
 567
 568         ret = ovl_maybe_copy_up(file_dentry(file), O_WRONLY);
 569         if (ret)
 570                 goto unlock;
 571
 572         ret = ovl_real_ioctl(file, cmd, arg);
 573
 574         ovl_copyflags(ovl_inode_real(inode), inode);
 575 unlock:
 576         inode_unlock(inode);
 577
 578         mnt_drop_write_file(file);
 579
 580         return ret;
 581
 582 }
 583
 584 static unsigned int ovl_fsflags_to_iflags(unsigned int flags)
 585 {
 586         unsigned int iflags = 0;
 587
 588         if (flags & FS_SYNC_FL)
 589                 iflags |= S_SYNC;
 590         if (flags & FS_APPEND_FL)
 591                 iflags |= S_APPEND;
 592         if (flags & FS_IMMUTABLE_FL)
 593                 iflags |= S_IMMUTABLE;
 594         if (flags & FS_NOATIME_FL)
 595                 iflags |= S_NOATIME;
 596
 597         return iflags;
 598 }
 599
 600 static long ovl_ioctl_set_fsflags(struct file *file, unsigned int cmd,
 601                                   unsigned long arg)
 602 {
 603         unsigned int flags;
 604
 605         if (get_user(flags, (int __user *) arg))
 606                 return -EFAULT;
 607
 608         return ovl_ioctl_set_flags(file, cmd, arg,
 609                                    ovl_fsflags_to_iflags(flags));
 610 }
 611
 612 static unsigned int ovl_fsxflags_to_iflags(unsigned int xflags)
 613 {
 614         unsigned int iflags = 0;
 615
 616         if (xflags & FS_XFLAG_SYNC)
 617                 iflags |= S_SYNC;
 618         if (xflags & FS_XFLAG_APPEND)
 619                 iflags |= S_APPEND;
 620         if (xflags & FS_XFLAG_IMMUTABLE)
 621                 iflags |= S_IMMUTABLE;
 622         if (xflags & FS_XFLAG_NOATIME)
 623                 iflags |= S_NOATIME;
 624
 625         return iflags;
 626 }
 627
 628 static long ovl_ioctl_set_fsxflags(struct file *file, unsigned int cmd,
 629                                    unsigned long arg)
 630 {
 631         struct fsxattr fa;
 632
 633         memset(&fa, 0, sizeof(fa));
 634         if (copy_from_user(&fa, (void __user *) arg, sizeof(fa)))
 635                 return -EFAULT;
 636
 637         return ovl_ioctl_set_flags(file, cmd, arg,
 638                                    ovl_fsxflags_to_iflags(fa.fsx_xflags));
 639 }
 640
 641 static long ovl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 642 {
 643         long ret;
 644
 645         switch (cmd) {
 646         case FS_IOC_GETFLAGS:
 647         case FS_IOC_FSGETXATTR:
 648                 ret = ovl_real_ioctl(file, cmd, arg);
 649                 break;
 650
 651         case FS_IOC_SETFLAGS:
 652                 ret = ovl_ioctl_set_fsflags(file, cmd, arg);
 653                 break;
 654
 655         case FS_IOC_FSSETXATTR:
 656                 ret = ovl_ioctl_set_fsxflags(file, cmd, arg);
 657                 break;
 658
 659         default:
 660                 ret = -ENOTTY;
 661         }
 662
 663         return ret;
 664 }
 665
 666 static long ovl_compat_ioctl(struct file *file, unsigned int cmd,
 667                              unsigned long arg)
 668 {
 669         switch (cmd) {
 670         case FS_IOC32_GETFLAGS:
 671                 cmd = FS_IOC_GETFLAGS;
 672                 break;
 673
 674         case FS_IOC32_SETFLAGS:
 675                 cmd = FS_IOC_SETFLAGS;
 676                 break;
 677
 678         default:
 679                 return -ENOIOCTLCMD;
 680         }
 681
 682         return ovl_ioctl(file, cmd, arg);
 683 }
 684
 685 enum ovl_copyop {
 686         OVL_COPY,
 687         OVL_CLONE,
 688         OVL_DEDUPE,
 689 };
 690
 691 static loff_t ovl_copyfile(struct file *file_in, loff_t pos_in,
 692                             struct file *file_out, loff_t pos_out,
 693                             loff_t len, unsigned int flags, enum ovl_copyop op)
 694 {
 695         struct inode *inode_out = file_inode(file_out);
 696         struct fd real_in, real_out;
 697         const struct cred *old_cred;
 698         loff_t ret;
 699
 700         ret = ovl_real_fdget(file_out, &real_out);
 701         if (ret)
 702                 return ret;
 703
 704         ret = ovl_real_fdget(file_in, &real_in);
 705         if (ret) {
 706                 fdput(real_out);
 707                 return ret;
 708         }
 709
 710         old_cred = ovl_override_creds(file_inode(file_out)->i_sb);
 711         switch (op) {
 712         case OVL_COPY:
 713                 ret = vfs_copy_file_range(real_in.file, pos_in,
 714                                           real_out.file, pos_out, len, flags);
 715                 break;
 716
 717         case OVL_CLONE:
 718                 ret = vfs_clone_file_range(real_in.file, pos_in,
 719                                            real_out.file, pos_out, len, flags);
 720                 break;
 721
 722         case OVL_DEDUPE:
 723                 ret = vfs_dedupe_file_range_one(real_in.file, pos_in,
 724                                                 real_out.file, pos_out, len,
 725                                                 flags);
 726                 break;
 727         }
 728         revert_creds(old_cred);
 729
 730         /* Update size */
 731         ovl_copyattr(ovl_inode_real(inode_out), inode_out);
 732
 733         fdput(real_in);
 734         fdput(real_out);
 735
 736         return ret;
 737 }
 738
 739 static ssize_t ovl_copy_file_range(struct file *file_in, loff_t pos_in,
 740                                    struct file *file_out, loff_t pos_out,
 741                                    size_t len, unsigned int flags)
 742 {
 743         return ovl_copyfile(file_in, pos_in, file_out, pos_out, len, flags,
 744                             OVL_COPY);
 745 }
 746
 747 static loff_t ovl_remap_file_range(struct file *file_in, loff_t pos_in,
 748                                    struct file *file_out, loff_t pos_out,
 749                                    loff_t len, unsigned int remap_flags)
 750 {
 751         enum ovl_copyop op;
 752
 753         if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
 754                 return -EINVAL;
 755
 756         if (remap_flags & REMAP_FILE_DEDUP)
 757                 op = OVL_DEDUPE;
 758         else
 759                 op = OVL_CLONE;
 760
 761         /*
 762          * Don't copy up because of a dedupe request, this wouldn't make sense
 763          * most of the time (data would be duplicated instead of deduplicated).
 764          */
 765         if (op == OVL_DEDUPE &&
 766             (!ovl_inode_upper(file_inode(file_in)) ||
 767              !ovl_inode_upper(file_inode(file_out))))
 768                 return -EPERM;
 769
 770         return ovl_copyfile(file_in, pos_in, file_out, pos_out, len,
 771                             remap_flags, op);
 772 }
 773
 774 const struct file_operations ovl_file_operations = {
 775         .open           = ovl_open,
 776         .release        = ovl_release,
 777         .llseek         = ovl_llseek,
 778         .read_iter      = ovl_read_iter,
 779         .write_iter     = ovl_write_iter,
 780         .fsync          = ovl_fsync,
 781         .mmap           = ovl_mmap,
 782         .fallocate      = ovl_fallocate,
 783         .fadvise        = ovl_fadvise,
 784         .unlocked_ioctl = ovl_ioctl,
 785         .compat_ioctl   = ovl_compat_ioctl,
 786         .splice_read    = ovl_splice_read,
 787         .splice_write   = ovl_splice_write,
 788
 789         .copy_file_range        = ovl_copy_file_range,
 790         .remap_file_range       = ovl_remap_file_range,
 791 };
 792
 793 int __init ovl_aio_request_cache_init(void)
 794 {
 795         ovl_aio_request_cachep = kmem_cache_create("ovl_aio_req",
 796                                                    sizeof(struct ovl_aio_req),
 797                                                    0, SLAB_HWCACHE_ALIGN, NULL);
 798         if (!ovl_aio_request_cachep)
 799                 return -ENOMEM;
 800
 801         return 0;
 802 }
 803
 804 void ovl_aio_request_cache_destroy(void)
 805 {
 806         kmem_cache_destroy(ovl_aio_request_cachep);
 807 }