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