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