1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * 4 * Copyright (C) 2011 Novell Inc. 5 */ 6 7 #include <uapi/linux/magic.h> 8 #include <linux/fs.h> 9 #include <linux/namei.h> 10 #include <linux/xattr.h> 11 #include <linux/mount.h> 12 #include <linux/parser.h> 13 #include <linux/module.h> 14 #include <linux/statfs.h> 15 #include <linux/seq_file.h> 16 #include <linux/posix_acl_xattr.h> 17 #include <linux/exportfs.h> 18 #include <linux/file.h> 19 #include <linux/fs_context.h> 20 #include <linux/fs_parser.h> 21 #include "overlayfs.h" 22 #include "params.h" 23 24 MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 25 MODULE_DESCRIPTION("Overlay filesystem"); 26 MODULE_LICENSE("GPL"); 27 28 29 struct ovl_dir_cache; 30 31 static struct dentry *ovl_d_real(struct dentry *dentry, 32 const struct inode *inode) 33 { 34 struct dentry *real = NULL, *lower; 35 int err; 36 37 /* It's an overlay file */ 38 if (inode && d_inode(dentry) == inode) 39 return dentry; 40 41 if (!d_is_reg(dentry)) { 42 if (!inode || inode == d_inode(dentry)) 43 return dentry; 44 goto bug; 45 } 46 47 real = ovl_dentry_upper(dentry); 48 if (real && (inode == d_inode(real))) 49 return real; 50 51 if (real && !inode && ovl_has_upperdata(d_inode(dentry))) 52 return real; 53 54 /* 55 * Best effort lazy lookup of lowerdata for !inode case to return 56 * the real lowerdata dentry. The only current caller of d_real() with 57 * NULL inode is d_real_inode() from trace_uprobe and this caller is 58 * likely going to be followed reading from the file, before placing 59 * uprobes on offset within the file, so lowerdata should be available 60 * when setting the uprobe. 61 */ 62 err = ovl_verify_lowerdata(dentry); 63 if (err) 64 goto bug; 65 lower = ovl_dentry_lowerdata(dentry); 66 if (!lower) 67 goto bug; 68 real = lower; 69 70 /* Handle recursion */ 71 real = d_real(real, inode); 72 73 if (!inode || inode == d_inode(real)) 74 return real; 75 bug: 76 WARN(1, "%s(%pd4, %s:%lu): real dentry (%p/%lu) not found\n", 77 __func__, dentry, inode ? inode->i_sb->s_id : "NULL", 78 inode ? inode->i_ino : 0, real, 79 real && d_inode(real) ? d_inode(real)->i_ino : 0); 80 return dentry; 81 } 82 83 static int ovl_revalidate_real(struct dentry *d, unsigned int flags, bool weak) 84 { 85 int ret = 1; 86 87 if (!d) 88 return 1; 89 90 if (weak) { 91 if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) 92 ret = d->d_op->d_weak_revalidate(d, flags); 93 } else if (d->d_flags & DCACHE_OP_REVALIDATE) { 94 ret = d->d_op->d_revalidate(d, flags); 95 if (!ret) { 96 if (!(flags & LOOKUP_RCU)) 97 d_invalidate(d); 98 ret = -ESTALE; 99 } 100 } 101 return ret; 102 } 103 104 static int ovl_dentry_revalidate_common(struct dentry *dentry, 105 unsigned int flags, bool weak) 106 { 107 struct ovl_entry *oe = OVL_E(dentry); 108 struct ovl_path *lowerstack = ovl_lowerstack(oe); 109 struct inode *inode = d_inode_rcu(dentry); 110 struct dentry *upper; 111 unsigned int i; 112 int ret = 1; 113 114 /* Careful in RCU mode */ 115 if (!inode) 116 return -ECHILD; 117 118 upper = ovl_i_dentry_upper(inode); 119 if (upper) 120 ret = ovl_revalidate_real(upper, flags, weak); 121 122 for (i = 0; ret > 0 && i < ovl_numlower(oe); i++) 123 ret = ovl_revalidate_real(lowerstack[i].dentry, flags, weak); 124 125 return ret; 126 } 127 128 static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 129 { 130 return ovl_dentry_revalidate_common(dentry, flags, false); 131 } 132 133 static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 134 { 135 return ovl_dentry_revalidate_common(dentry, flags, true); 136 } 137 138 static const struct dentry_operations ovl_dentry_operations = { 139 .d_real = ovl_d_real, 140 .d_revalidate = ovl_dentry_revalidate, 141 .d_weak_revalidate = ovl_dentry_weak_revalidate, 142 }; 143 144 static struct kmem_cache *ovl_inode_cachep; 145 146 static struct inode *ovl_alloc_inode(struct super_block *sb) 147 { 148 struct ovl_inode *oi = alloc_inode_sb(sb, ovl_inode_cachep, GFP_KERNEL); 149 150 if (!oi) 151 return NULL; 152 153 oi->cache = NULL; 154 oi->redirect = NULL; 155 oi->version = 0; 156 oi->flags = 0; 157 oi->__upperdentry = NULL; 158 oi->lowerdata_redirect = NULL; 159 oi->oe = NULL; 160 mutex_init(&oi->lock); 161 162 return &oi->vfs_inode; 163 } 164 165 static void ovl_free_inode(struct inode *inode) 166 { 167 struct ovl_inode *oi = OVL_I(inode); 168 169 kfree(oi->redirect); 170 mutex_destroy(&oi->lock); 171 kmem_cache_free(ovl_inode_cachep, oi); 172 } 173 174 static void ovl_destroy_inode(struct inode *inode) 175 { 176 struct ovl_inode *oi = OVL_I(inode); 177 178 dput(oi->__upperdentry); 179 ovl_free_entry(oi->oe); 180 if (S_ISDIR(inode->i_mode)) 181 ovl_dir_cache_free(inode); 182 else 183 kfree(oi->lowerdata_redirect); 184 } 185 186 static void ovl_put_super(struct super_block *sb) 187 { 188 struct ovl_fs *ofs = sb->s_fs_info; 189 190 if (ofs) 191 ovl_free_fs(ofs); 192 } 193 194 /* Sync real dirty inodes in upper filesystem (if it exists) */ 195 static int ovl_sync_fs(struct super_block *sb, int wait) 196 { 197 struct ovl_fs *ofs = sb->s_fs_info; 198 struct super_block *upper_sb; 199 int ret; 200 201 ret = ovl_sync_status(ofs); 202 /* 203 * We have to always set the err, because the return value isn't 204 * checked in syncfs, and instead indirectly return an error via 205 * the sb's writeback errseq, which VFS inspects after this call. 206 */ 207 if (ret < 0) { 208 errseq_set(&sb->s_wb_err, -EIO); 209 return -EIO; 210 } 211 212 if (!ret) 213 return ret; 214 215 /* 216 * Not called for sync(2) call or an emergency sync (SB_I_SKIP_SYNC). 217 * All the super blocks will be iterated, including upper_sb. 218 * 219 * If this is a syncfs(2) call, then we do need to call 220 * sync_filesystem() on upper_sb, but enough if we do it when being 221 * called with wait == 1. 222 */ 223 if (!wait) 224 return 0; 225 226 upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 227 228 down_read(&upper_sb->s_umount); 229 ret = sync_filesystem(upper_sb); 230 up_read(&upper_sb->s_umount); 231 232 return ret; 233 } 234 235 /** 236 * ovl_statfs 237 * @dentry: The dentry to query 238 * @buf: The struct kstatfs to fill in with stats 239 * 240 * Get the filesystem statistics. As writes always target the upper layer 241 * filesystem pass the statfs to the upper filesystem (if it exists) 242 */ 243 static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 244 { 245 struct super_block *sb = dentry->d_sb; 246 struct ovl_fs *ofs = OVL_FS(sb); 247 struct dentry *root_dentry = sb->s_root; 248 struct path path; 249 int err; 250 251 ovl_path_real(root_dentry, &path); 252 253 err = vfs_statfs(&path, buf); 254 if (!err) { 255 buf->f_namelen = ofs->namelen; 256 buf->f_type = OVERLAYFS_SUPER_MAGIC; 257 if (ovl_has_fsid(ofs)) 258 buf->f_fsid = uuid_to_fsid(sb->s_uuid.b); 259 } 260 261 return err; 262 } 263 264 static const struct super_operations ovl_super_operations = { 265 .alloc_inode = ovl_alloc_inode, 266 .free_inode = ovl_free_inode, 267 .destroy_inode = ovl_destroy_inode, 268 .drop_inode = generic_delete_inode, 269 .put_super = ovl_put_super, 270 .sync_fs = ovl_sync_fs, 271 .statfs = ovl_statfs, 272 .show_options = ovl_show_options, 273 }; 274 275 #define OVL_WORKDIR_NAME "work" 276 #define OVL_INDEXDIR_NAME "index" 277 278 static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 279 const char *name, bool persist) 280 { 281 struct inode *dir = ofs->workbasedir->d_inode; 282 struct vfsmount *mnt = ovl_upper_mnt(ofs); 283 struct dentry *work; 284 int err; 285 bool retried = false; 286 287 inode_lock_nested(dir, I_MUTEX_PARENT); 288 retry: 289 work = ovl_lookup_upper(ofs, name, ofs->workbasedir, strlen(name)); 290 291 if (!IS_ERR(work)) { 292 struct iattr attr = { 293 .ia_valid = ATTR_MODE, 294 .ia_mode = S_IFDIR | 0, 295 }; 296 297 if (work->d_inode) { 298 err = -EEXIST; 299 if (retried) 300 goto out_dput; 301 302 if (persist) 303 goto out_unlock; 304 305 retried = true; 306 err = ovl_workdir_cleanup(ofs, dir, mnt, work, 0); 307 dput(work); 308 if (err == -EINVAL) { 309 work = ERR_PTR(err); 310 goto out_unlock; 311 } 312 goto retry; 313 } 314 315 err = ovl_mkdir_real(ofs, dir, &work, attr.ia_mode); 316 if (err) 317 goto out_dput; 318 319 /* Weird filesystem returning with hashed negative (kernfs)? */ 320 err = -EINVAL; 321 if (d_really_is_negative(work)) 322 goto out_dput; 323 324 /* 325 * Try to remove POSIX ACL xattrs from workdir. We are good if: 326 * 327 * a) success (there was a POSIX ACL xattr and was removed) 328 * b) -ENODATA (there was no POSIX ACL xattr) 329 * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 330 * 331 * There are various other error values that could effectively 332 * mean that the xattr doesn't exist (e.g. -ERANGE is returned 333 * if the xattr name is too long), but the set of filesystems 334 * allowed as upper are limited to "normal" ones, where checking 335 * for the above two errors is sufficient. 336 */ 337 err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_DEFAULT); 338 if (err && err != -ENODATA && err != -EOPNOTSUPP) 339 goto out_dput; 340 341 err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_ACCESS); 342 if (err && err != -ENODATA && err != -EOPNOTSUPP) 343 goto out_dput; 344 345 /* Clear any inherited mode bits */ 346 inode_lock(work->d_inode); 347 err = ovl_do_notify_change(ofs, work, &attr); 348 inode_unlock(work->d_inode); 349 if (err) 350 goto out_dput; 351 } else { 352 err = PTR_ERR(work); 353 goto out_err; 354 } 355 out_unlock: 356 inode_unlock(dir); 357 return work; 358 359 out_dput: 360 dput(work); 361 out_err: 362 pr_warn("failed to create directory %s/%s (errno: %i); mounting read-only\n", 363 ofs->config.workdir, name, -err); 364 work = NULL; 365 goto out_unlock; 366 } 367 368 static int ovl_check_namelen(const struct path *path, struct ovl_fs *ofs, 369 const char *name) 370 { 371 struct kstatfs statfs; 372 int err = vfs_statfs(path, &statfs); 373 374 if (err) 375 pr_err("statfs failed on '%s'\n", name); 376 else 377 ofs->namelen = max(ofs->namelen, statfs.f_namelen); 378 379 return err; 380 } 381 382 static int ovl_lower_dir(const char *name, struct path *path, 383 struct ovl_fs *ofs, int *stack_depth) 384 { 385 int fh_type; 386 int err; 387 388 err = ovl_check_namelen(path, ofs, name); 389 if (err) 390 return err; 391 392 *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 393 394 /* 395 * The inodes index feature and NFS export need to encode and decode 396 * file handles, so they require that all layers support them. 397 */ 398 fh_type = ovl_can_decode_fh(path->dentry->d_sb); 399 if ((ofs->config.nfs_export || 400 (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 401 ofs->config.index = false; 402 ofs->config.nfs_export = false; 403 pr_warn("fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 404 name); 405 } 406 ofs->nofh |= !fh_type; 407 /* 408 * Decoding origin file handle is required for persistent st_ino. 409 * Without persistent st_ino, xino=auto falls back to xino=off. 410 */ 411 if (ofs->config.xino == OVL_XINO_AUTO && 412 ofs->config.upperdir && !fh_type) { 413 ofs->config.xino = OVL_XINO_OFF; 414 pr_warn("fs on '%s' does not support file handles, falling back to xino=off.\n", 415 name); 416 } 417 418 /* Check if lower fs has 32bit inode numbers */ 419 if (fh_type != FILEID_INO32_GEN) 420 ofs->xino_mode = -1; 421 422 return 0; 423 } 424 425 /* Workdir should not be subdir of upperdir and vice versa */ 426 static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 427 { 428 bool ok = false; 429 430 if (workdir != upperdir) { 431 ok = (lock_rename(workdir, upperdir) == NULL); 432 unlock_rename(workdir, upperdir); 433 } 434 return ok; 435 } 436 437 static int ovl_own_xattr_get(const struct xattr_handler *handler, 438 struct dentry *dentry, struct inode *inode, 439 const char *name, void *buffer, size_t size) 440 { 441 return -EOPNOTSUPP; 442 } 443 444 static int ovl_own_xattr_set(const struct xattr_handler *handler, 445 struct mnt_idmap *idmap, 446 struct dentry *dentry, struct inode *inode, 447 const char *name, const void *value, 448 size_t size, int flags) 449 { 450 return -EOPNOTSUPP; 451 } 452 453 static int ovl_other_xattr_get(const struct xattr_handler *handler, 454 struct dentry *dentry, struct inode *inode, 455 const char *name, void *buffer, size_t size) 456 { 457 return ovl_xattr_get(dentry, inode, name, buffer, size); 458 } 459 460 static int ovl_other_xattr_set(const struct xattr_handler *handler, 461 struct mnt_idmap *idmap, 462 struct dentry *dentry, struct inode *inode, 463 const char *name, const void *value, 464 size_t size, int flags) 465 { 466 return ovl_xattr_set(dentry, inode, name, value, size, flags); 467 } 468 469 static const struct xattr_handler ovl_own_trusted_xattr_handler = { 470 .prefix = OVL_XATTR_TRUSTED_PREFIX, 471 .get = ovl_own_xattr_get, 472 .set = ovl_own_xattr_set, 473 }; 474 475 static const struct xattr_handler ovl_own_user_xattr_handler = { 476 .prefix = OVL_XATTR_USER_PREFIX, 477 .get = ovl_own_xattr_get, 478 .set = ovl_own_xattr_set, 479 }; 480 481 static const struct xattr_handler ovl_other_xattr_handler = { 482 .prefix = "", /* catch all */ 483 .get = ovl_other_xattr_get, 484 .set = ovl_other_xattr_set, 485 }; 486 487 static const struct xattr_handler *ovl_trusted_xattr_handlers[] = { 488 &ovl_own_trusted_xattr_handler, 489 &ovl_other_xattr_handler, 490 NULL 491 }; 492 493 static const struct xattr_handler *ovl_user_xattr_handlers[] = { 494 &ovl_own_user_xattr_handler, 495 &ovl_other_xattr_handler, 496 NULL 497 }; 498 499 static int ovl_setup_trap(struct super_block *sb, struct dentry *dir, 500 struct inode **ptrap, const char *name) 501 { 502 struct inode *trap; 503 int err; 504 505 trap = ovl_get_trap_inode(sb, dir); 506 err = PTR_ERR_OR_ZERO(trap); 507 if (err) { 508 if (err == -ELOOP) 509 pr_err("conflicting %s path\n", name); 510 return err; 511 } 512 513 *ptrap = trap; 514 return 0; 515 } 516 517 /* 518 * Determine how we treat concurrent use of upperdir/workdir based on the 519 * index feature. This is papering over mount leaks of container runtimes, 520 * for example, an old overlay mount is leaked and now its upperdir is 521 * attempted to be used as a lower layer in a new overlay mount. 522 */ 523 static int ovl_report_in_use(struct ovl_fs *ofs, const char *name) 524 { 525 if (ofs->config.index) { 526 pr_err("%s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n", 527 name); 528 return -EBUSY; 529 } else { 530 pr_warn("%s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n", 531 name); 532 return 0; 533 } 534 } 535 536 static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs, 537 struct ovl_layer *upper_layer, 538 const struct path *upperpath) 539 { 540 struct vfsmount *upper_mnt; 541 int err; 542 543 /* Upperdir path should not be r/o */ 544 if (__mnt_is_readonly(upperpath->mnt)) { 545 pr_err("upper fs is r/o, try multi-lower layers mount\n"); 546 err = -EINVAL; 547 goto out; 548 } 549 550 err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 551 if (err) 552 goto out; 553 554 err = ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap, 555 "upperdir"); 556 if (err) 557 goto out; 558 559 upper_mnt = clone_private_mount(upperpath); 560 err = PTR_ERR(upper_mnt); 561 if (IS_ERR(upper_mnt)) { 562 pr_err("failed to clone upperpath\n"); 563 goto out; 564 } 565 566 /* Don't inherit atime flags */ 567 upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 568 upper_layer->mnt = upper_mnt; 569 upper_layer->idx = 0; 570 upper_layer->fsid = 0; 571 572 err = -ENOMEM; 573 upper_layer->name = kstrdup(ofs->config.upperdir, GFP_KERNEL); 574 if (!upper_layer->name) 575 goto out; 576 577 /* 578 * Inherit SB_NOSEC flag from upperdir. 579 * 580 * This optimization changes behavior when a security related attribute 581 * (suid/sgid/security.*) is changed on an underlying layer. This is 582 * okay because we don't yet have guarantees in that case, but it will 583 * need careful treatment once we want to honour changes to underlying 584 * filesystems. 585 */ 586 if (upper_mnt->mnt_sb->s_flags & SB_NOSEC) 587 sb->s_flags |= SB_NOSEC; 588 589 if (ovl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) { 590 ofs->upperdir_locked = true; 591 } else { 592 err = ovl_report_in_use(ofs, "upperdir"); 593 if (err) 594 goto out; 595 } 596 597 err = 0; 598 out: 599 return err; 600 } 601 602 /* 603 * Returns 1 if RENAME_WHITEOUT is supported, 0 if not supported and 604 * negative values if error is encountered. 605 */ 606 static int ovl_check_rename_whiteout(struct ovl_fs *ofs) 607 { 608 struct dentry *workdir = ofs->workdir; 609 struct inode *dir = d_inode(workdir); 610 struct dentry *temp; 611 struct dentry *dest; 612 struct dentry *whiteout; 613 struct name_snapshot name; 614 int err; 615 616 inode_lock_nested(dir, I_MUTEX_PARENT); 617 618 temp = ovl_create_temp(ofs, workdir, OVL_CATTR(S_IFREG | 0)); 619 err = PTR_ERR(temp); 620 if (IS_ERR(temp)) 621 goto out_unlock; 622 623 dest = ovl_lookup_temp(ofs, workdir); 624 err = PTR_ERR(dest); 625 if (IS_ERR(dest)) { 626 dput(temp); 627 goto out_unlock; 628 } 629 630 /* Name is inline and stable - using snapshot as a copy helper */ 631 take_dentry_name_snapshot(&name, temp); 632 err = ovl_do_rename(ofs, dir, temp, dir, dest, RENAME_WHITEOUT); 633 if (err) { 634 if (err == -EINVAL) 635 err = 0; 636 goto cleanup_temp; 637 } 638 639 whiteout = ovl_lookup_upper(ofs, name.name.name, workdir, name.name.len); 640 err = PTR_ERR(whiteout); 641 if (IS_ERR(whiteout)) 642 goto cleanup_temp; 643 644 err = ovl_is_whiteout(whiteout); 645 646 /* Best effort cleanup of whiteout and temp file */ 647 if (err) 648 ovl_cleanup(ofs, dir, whiteout); 649 dput(whiteout); 650 651 cleanup_temp: 652 ovl_cleanup(ofs, dir, temp); 653 release_dentry_name_snapshot(&name); 654 dput(temp); 655 dput(dest); 656 657 out_unlock: 658 inode_unlock(dir); 659 660 return err; 661 } 662 663 static struct dentry *ovl_lookup_or_create(struct ovl_fs *ofs, 664 struct dentry *parent, 665 const char *name, umode_t mode) 666 { 667 size_t len = strlen(name); 668 struct dentry *child; 669 670 inode_lock_nested(parent->d_inode, I_MUTEX_PARENT); 671 child = ovl_lookup_upper(ofs, name, parent, len); 672 if (!IS_ERR(child) && !child->d_inode) 673 child = ovl_create_real(ofs, parent->d_inode, child, 674 OVL_CATTR(mode)); 675 inode_unlock(parent->d_inode); 676 dput(parent); 677 678 return child; 679 } 680 681 /* 682 * Creates $workdir/work/incompat/volatile/dirty file if it is not already 683 * present. 684 */ 685 static int ovl_create_volatile_dirty(struct ovl_fs *ofs) 686 { 687 unsigned int ctr; 688 struct dentry *d = dget(ofs->workbasedir); 689 static const char *const volatile_path[] = { 690 OVL_WORKDIR_NAME, "incompat", "volatile", "dirty" 691 }; 692 const char *const *name = volatile_path; 693 694 for (ctr = ARRAY_SIZE(volatile_path); ctr; ctr--, name++) { 695 d = ovl_lookup_or_create(ofs, d, *name, ctr > 1 ? S_IFDIR : S_IFREG); 696 if (IS_ERR(d)) 697 return PTR_ERR(d); 698 } 699 dput(d); 700 return 0; 701 } 702 703 static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs, 704 const struct path *workpath) 705 { 706 struct vfsmount *mnt = ovl_upper_mnt(ofs); 707 struct dentry *workdir; 708 struct file *tmpfile; 709 bool rename_whiteout; 710 bool d_type; 711 int fh_type; 712 int err; 713 714 err = mnt_want_write(mnt); 715 if (err) 716 return err; 717 718 workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 719 err = PTR_ERR(workdir); 720 if (IS_ERR_OR_NULL(workdir)) 721 goto out; 722 723 ofs->workdir = workdir; 724 725 err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir"); 726 if (err) 727 goto out; 728 729 /* 730 * Upper should support d_type, else whiteouts are visible. Given 731 * workdir and upper are on same fs, we can do iterate_dir() on 732 * workdir. This check requires successful creation of workdir in 733 * previous step. 734 */ 735 err = ovl_check_d_type_supported(workpath); 736 if (err < 0) 737 goto out; 738 739 d_type = err; 740 if (!d_type) 741 pr_warn("upper fs needs to support d_type.\n"); 742 743 /* Check if upper/work fs supports O_TMPFILE */ 744 tmpfile = ovl_do_tmpfile(ofs, ofs->workdir, S_IFREG | 0); 745 ofs->tmpfile = !IS_ERR(tmpfile); 746 if (ofs->tmpfile) 747 fput(tmpfile); 748 else 749 pr_warn("upper fs does not support tmpfile.\n"); 750 751 752 /* Check if upper/work fs supports RENAME_WHITEOUT */ 753 err = ovl_check_rename_whiteout(ofs); 754 if (err < 0) 755 goto out; 756 757 rename_whiteout = err; 758 if (!rename_whiteout) 759 pr_warn("upper fs does not support RENAME_WHITEOUT.\n"); 760 761 /* 762 * Check if upper/work fs supports (trusted|user).overlay.* xattr 763 */ 764 err = ovl_setxattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE, "0", 1); 765 if (err) { 766 pr_warn("failed to set xattr on upper\n"); 767 ofs->noxattr = true; 768 if (ovl_redirect_follow(ofs)) { 769 ofs->config.redirect_mode = OVL_REDIRECT_NOFOLLOW; 770 pr_warn("...falling back to redirect_dir=nofollow.\n"); 771 } 772 if (ofs->config.metacopy) { 773 ofs->config.metacopy = false; 774 pr_warn("...falling back to metacopy=off.\n"); 775 } 776 if (ofs->config.index) { 777 ofs->config.index = false; 778 pr_warn("...falling back to index=off.\n"); 779 } 780 /* 781 * xattr support is required for persistent st_ino. 782 * Without persistent st_ino, xino=auto falls back to xino=off. 783 */ 784 if (ofs->config.xino == OVL_XINO_AUTO) { 785 ofs->config.xino = OVL_XINO_OFF; 786 pr_warn("...falling back to xino=off.\n"); 787 } 788 if (err == -EPERM && !ofs->config.userxattr) 789 pr_info("try mounting with 'userxattr' option\n"); 790 err = 0; 791 } else { 792 ovl_removexattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE); 793 } 794 795 /* 796 * We allowed sub-optimal upper fs configuration and don't want to break 797 * users over kernel upgrade, but we never allowed remote upper fs, so 798 * we can enforce strict requirements for remote upper fs. 799 */ 800 if (ovl_dentry_remote(ofs->workdir) && 801 (!d_type || !rename_whiteout || ofs->noxattr)) { 802 pr_err("upper fs missing required features.\n"); 803 err = -EINVAL; 804 goto out; 805 } 806 807 /* 808 * For volatile mount, create a incompat/volatile/dirty file to keep 809 * track of it. 810 */ 811 if (ofs->config.ovl_volatile) { 812 err = ovl_create_volatile_dirty(ofs); 813 if (err < 0) { 814 pr_err("Failed to create volatile/dirty file.\n"); 815 goto out; 816 } 817 } 818 819 /* Check if upper/work fs supports file handles */ 820 fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 821 if (ofs->config.index && !fh_type) { 822 ofs->config.index = false; 823 pr_warn("upper fs does not support file handles, falling back to index=off.\n"); 824 } 825 ofs->nofh |= !fh_type; 826 827 /* Check if upper fs has 32bit inode numbers */ 828 if (fh_type != FILEID_INO32_GEN) 829 ofs->xino_mode = -1; 830 831 /* NFS export of r/w mount depends on index */ 832 if (ofs->config.nfs_export && !ofs->config.index) { 833 pr_warn("NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 834 ofs->config.nfs_export = false; 835 } 836 out: 837 mnt_drop_write(mnt); 838 return err; 839 } 840 841 static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs, 842 const struct path *upperpath, 843 const struct path *workpath) 844 { 845 int err; 846 847 err = -EINVAL; 848 if (upperpath->mnt != workpath->mnt) { 849 pr_err("workdir and upperdir must reside under the same mount\n"); 850 return err; 851 } 852 if (!ovl_workdir_ok(workpath->dentry, upperpath->dentry)) { 853 pr_err("workdir and upperdir must be separate subtrees\n"); 854 return err; 855 } 856 857 ofs->workbasedir = dget(workpath->dentry); 858 859 if (ovl_inuse_trylock(ofs->workbasedir)) { 860 ofs->workdir_locked = true; 861 } else { 862 err = ovl_report_in_use(ofs, "workdir"); 863 if (err) 864 return err; 865 } 866 867 err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap, 868 "workdir"); 869 if (err) 870 return err; 871 872 return ovl_make_workdir(sb, ofs, workpath); 873 } 874 875 static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs, 876 struct ovl_entry *oe, const struct path *upperpath) 877 { 878 struct vfsmount *mnt = ovl_upper_mnt(ofs); 879 struct dentry *indexdir; 880 int err; 881 882 err = mnt_want_write(mnt); 883 if (err) 884 return err; 885 886 /* Verify lower root is upper root origin */ 887 err = ovl_verify_origin(ofs, upperpath->dentry, 888 ovl_lowerstack(oe)->dentry, true); 889 if (err) { 890 pr_err("failed to verify upper root origin\n"); 891 goto out; 892 } 893 894 /* index dir will act also as workdir */ 895 iput(ofs->workdir_trap); 896 ofs->workdir_trap = NULL; 897 dput(ofs->workdir); 898 ofs->workdir = NULL; 899 indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 900 if (IS_ERR(indexdir)) { 901 err = PTR_ERR(indexdir); 902 } else if (indexdir) { 903 ofs->indexdir = indexdir; 904 ofs->workdir = dget(indexdir); 905 906 err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap, 907 "indexdir"); 908 if (err) 909 goto out; 910 911 /* 912 * Verify upper root is exclusively associated with index dir. 913 * Older kernels stored upper fh in ".overlay.origin" 914 * xattr. If that xattr exists, verify that it is a match to 915 * upper dir file handle. In any case, verify or set xattr 916 * ".overlay.upper" to indicate that index may have 917 * directory entries. 918 */ 919 if (ovl_check_origin_xattr(ofs, ofs->indexdir)) { 920 err = ovl_verify_set_fh(ofs, ofs->indexdir, 921 OVL_XATTR_ORIGIN, 922 upperpath->dentry, true, false); 923 if (err) 924 pr_err("failed to verify index dir 'origin' xattr\n"); 925 } 926 err = ovl_verify_upper(ofs, ofs->indexdir, upperpath->dentry, 927 true); 928 if (err) 929 pr_err("failed to verify index dir 'upper' xattr\n"); 930 931 /* Cleanup bad/stale/orphan index entries */ 932 if (!err) 933 err = ovl_indexdir_cleanup(ofs); 934 } 935 if (err || !ofs->indexdir) 936 pr_warn("try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 937 938 out: 939 mnt_drop_write(mnt); 940 return err; 941 } 942 943 static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid) 944 { 945 unsigned int i; 946 947 if (!ofs->config.nfs_export && !ovl_upper_mnt(ofs)) 948 return true; 949 950 /* 951 * We allow using single lower with null uuid for index and nfs_export 952 * for example to support those features with single lower squashfs. 953 * To avoid regressions in setups of overlay with re-formatted lower 954 * squashfs, do not allow decoding origin with lower null uuid unless 955 * user opted-in to one of the new features that require following the 956 * lower inode of non-dir upper. 957 */ 958 if (ovl_allow_offline_changes(ofs) && uuid_is_null(uuid)) 959 return false; 960 961 for (i = 0; i < ofs->numfs; i++) { 962 /* 963 * We use uuid to associate an overlay lower file handle with a 964 * lower layer, so we can accept lower fs with null uuid as long 965 * as all lower layers with null uuid are on the same fs. 966 * if we detect multiple lower fs with the same uuid, we 967 * disable lower file handle decoding on all of them. 968 */ 969 if (ofs->fs[i].is_lower && 970 uuid_equal(&ofs->fs[i].sb->s_uuid, uuid)) { 971 ofs->fs[i].bad_uuid = true; 972 return false; 973 } 974 } 975 return true; 976 } 977 978 /* Get a unique fsid for the layer */ 979 static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) 980 { 981 struct super_block *sb = path->mnt->mnt_sb; 982 unsigned int i; 983 dev_t dev; 984 int err; 985 bool bad_uuid = false; 986 bool warn = false; 987 988 for (i = 0; i < ofs->numfs; i++) { 989 if (ofs->fs[i].sb == sb) 990 return i; 991 } 992 993 if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) { 994 bad_uuid = true; 995 if (ofs->config.xino == OVL_XINO_AUTO) { 996 ofs->config.xino = OVL_XINO_OFF; 997 warn = true; 998 } 999 if (ofs->config.index || ofs->config.nfs_export) { 1000 ofs->config.index = false; 1001 ofs->config.nfs_export = false; 1002 warn = true; 1003 } 1004 if (warn) { 1005 pr_warn("%s uuid detected in lower fs '%pd2', falling back to xino=%s,index=off,nfs_export=off.\n", 1006 uuid_is_null(&sb->s_uuid) ? "null" : 1007 "conflicting", 1008 path->dentry, ovl_xino_mode(&ofs->config)); 1009 } 1010 } 1011 1012 err = get_anon_bdev(&dev); 1013 if (err) { 1014 pr_err("failed to get anonymous bdev for lowerpath\n"); 1015 return err; 1016 } 1017 1018 ofs->fs[ofs->numfs].sb = sb; 1019 ofs->fs[ofs->numfs].pseudo_dev = dev; 1020 ofs->fs[ofs->numfs].bad_uuid = bad_uuid; 1021 1022 return ofs->numfs++; 1023 } 1024 1025 /* 1026 * The fsid after the last lower fsid is used for the data layers. 1027 * It is a "null fs" with a null sb, null uuid, and no pseudo dev. 1028 */ 1029 static int ovl_get_data_fsid(struct ovl_fs *ofs) 1030 { 1031 return ofs->numfs; 1032 } 1033 1034 1035 static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, 1036 struct ovl_fs_context *ctx, struct ovl_layer *layers) 1037 { 1038 int err; 1039 unsigned int i; 1040 size_t nr_merged_lower; 1041 1042 ofs->fs = kcalloc(ctx->nr + 2, sizeof(struct ovl_sb), GFP_KERNEL); 1043 if (ofs->fs == NULL) 1044 return -ENOMEM; 1045 1046 /* 1047 * idx/fsid 0 are reserved for upper fs even with lower only overlay 1048 * and the last fsid is reserved for "null fs" of the data layers. 1049 */ 1050 ofs->numfs++; 1051 1052 /* 1053 * All lower layers that share the same fs as upper layer, use the same 1054 * pseudo_dev as upper layer. Allocate fs[0].pseudo_dev even for lower 1055 * only overlay to simplify ovl_fs_free(). 1056 * is_lower will be set if upper fs is shared with a lower layer. 1057 */ 1058 err = get_anon_bdev(&ofs->fs[0].pseudo_dev); 1059 if (err) { 1060 pr_err("failed to get anonymous bdev for upper fs\n"); 1061 return err; 1062 } 1063 1064 if (ovl_upper_mnt(ofs)) { 1065 ofs->fs[0].sb = ovl_upper_mnt(ofs)->mnt_sb; 1066 ofs->fs[0].is_lower = false; 1067 } 1068 1069 nr_merged_lower = ctx->nr - ctx->nr_data; 1070 for (i = 0; i < ctx->nr; i++) { 1071 struct ovl_fs_context_layer *l = &ctx->lower[i]; 1072 struct vfsmount *mnt; 1073 struct inode *trap; 1074 int fsid; 1075 1076 if (i < nr_merged_lower) 1077 fsid = ovl_get_fsid(ofs, &l->path); 1078 else 1079 fsid = ovl_get_data_fsid(ofs); 1080 if (fsid < 0) 1081 return fsid; 1082 1083 /* 1084 * Check if lower root conflicts with this overlay layers before 1085 * checking if it is in-use as upperdir/workdir of "another" 1086 * mount, because we do not bother to check in ovl_is_inuse() if 1087 * the upperdir/workdir is in fact in-use by our 1088 * upperdir/workdir. 1089 */ 1090 err = ovl_setup_trap(sb, l->path.dentry, &trap, "lowerdir"); 1091 if (err) 1092 return err; 1093 1094 if (ovl_is_inuse(l->path.dentry)) { 1095 err = ovl_report_in_use(ofs, "lowerdir"); 1096 if (err) { 1097 iput(trap); 1098 return err; 1099 } 1100 } 1101 1102 mnt = clone_private_mount(&l->path); 1103 err = PTR_ERR(mnt); 1104 if (IS_ERR(mnt)) { 1105 pr_err("failed to clone lowerpath\n"); 1106 iput(trap); 1107 return err; 1108 } 1109 1110 /* 1111 * Make lower layers R/O. That way fchmod/fchown on lower file 1112 * will fail instead of modifying lower fs. 1113 */ 1114 mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1115 1116 layers[ofs->numlayer].trap = trap; 1117 layers[ofs->numlayer].mnt = mnt; 1118 layers[ofs->numlayer].idx = ofs->numlayer; 1119 layers[ofs->numlayer].fsid = fsid; 1120 layers[ofs->numlayer].fs = &ofs->fs[fsid]; 1121 layers[ofs->numlayer].name = l->name; 1122 l->name = NULL; 1123 ofs->numlayer++; 1124 ofs->fs[fsid].is_lower = true; 1125 } 1126 1127 /* 1128 * When all layers on same fs, overlay can use real inode numbers. 1129 * With mount option "xino=<on|auto>", mounter declares that there are 1130 * enough free high bits in underlying fs to hold the unique fsid. 1131 * If overlayfs does encounter underlying inodes using the high xino 1132 * bits reserved for fsid, it emits a warning and uses the original 1133 * inode number or a non persistent inode number allocated from a 1134 * dedicated range. 1135 */ 1136 if (ofs->numfs - !ovl_upper_mnt(ofs) == 1) { 1137 if (ofs->config.xino == OVL_XINO_ON) 1138 pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n"); 1139 ofs->xino_mode = 0; 1140 } else if (ofs->config.xino == OVL_XINO_OFF) { 1141 ofs->xino_mode = -1; 1142 } else if (ofs->xino_mode < 0) { 1143 /* 1144 * This is a roundup of number of bits needed for encoding 1145 * fsid, where fsid 0 is reserved for upper fs (even with 1146 * lower only overlay) +1 extra bit is reserved for the non 1147 * persistent inode number range that is used for resolving 1148 * xino lower bits overflow. 1149 */ 1150 BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 30); 1151 ofs->xino_mode = ilog2(ofs->numfs - 1) + 2; 1152 } 1153 1154 if (ofs->xino_mode > 0) { 1155 pr_info("\"xino\" feature enabled using %d upper inode bits.\n", 1156 ofs->xino_mode); 1157 } 1158 1159 return 0; 1160 } 1161 1162 static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1163 struct ovl_fs_context *ctx, 1164 struct ovl_fs *ofs, 1165 struct ovl_layer *layers) 1166 { 1167 int err; 1168 unsigned int i; 1169 size_t nr_merged_lower; 1170 struct ovl_entry *oe; 1171 struct ovl_path *lowerstack; 1172 1173 struct ovl_fs_context_layer *l; 1174 1175 if (!ofs->config.upperdir && ctx->nr == 1) { 1176 pr_err("at least 2 lowerdir are needed while upperdir nonexistent\n"); 1177 return ERR_PTR(-EINVAL); 1178 } 1179 1180 err = -EINVAL; 1181 for (i = 0; i < ctx->nr; i++) { 1182 l = &ctx->lower[i]; 1183 1184 err = ovl_lower_dir(l->name, &l->path, ofs, &sb->s_stack_depth); 1185 if (err) 1186 return ERR_PTR(err); 1187 } 1188 1189 err = -EINVAL; 1190 sb->s_stack_depth++; 1191 if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 1192 pr_err("maximum fs stacking depth exceeded\n"); 1193 return ERR_PTR(err); 1194 } 1195 1196 err = ovl_get_layers(sb, ofs, ctx, layers); 1197 if (err) 1198 return ERR_PTR(err); 1199 1200 err = -ENOMEM; 1201 /* Data-only layers are not merged in root directory */ 1202 nr_merged_lower = ctx->nr - ctx->nr_data; 1203 oe = ovl_alloc_entry(nr_merged_lower); 1204 if (!oe) 1205 return ERR_PTR(err); 1206 1207 lowerstack = ovl_lowerstack(oe); 1208 for (i = 0; i < nr_merged_lower; i++) { 1209 l = &ctx->lower[i]; 1210 lowerstack[i].dentry = dget(l->path.dentry); 1211 lowerstack[i].layer = &ofs->layers[i + 1]; 1212 } 1213 ofs->numdatalayer = ctx->nr_data; 1214 1215 return oe; 1216 } 1217 1218 /* 1219 * Check if this layer root is a descendant of: 1220 * - another layer of this overlayfs instance 1221 * - upper/work dir of any overlayfs instance 1222 */ 1223 static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs, 1224 struct dentry *dentry, const char *name, 1225 bool is_lower) 1226 { 1227 struct dentry *next = dentry, *parent; 1228 int err = 0; 1229 1230 if (!dentry) 1231 return 0; 1232 1233 parent = dget_parent(next); 1234 1235 /* Walk back ancestors to root (inclusive) looking for traps */ 1236 while (!err && parent != next) { 1237 if (is_lower && ovl_lookup_trap_inode(sb, parent)) { 1238 err = -ELOOP; 1239 pr_err("overlapping %s path\n", name); 1240 } else if (ovl_is_inuse(parent)) { 1241 err = ovl_report_in_use(ofs, name); 1242 } 1243 next = parent; 1244 parent = dget_parent(next); 1245 dput(next); 1246 } 1247 1248 dput(parent); 1249 1250 return err; 1251 } 1252 1253 /* 1254 * Check if any of the layers or work dirs overlap. 1255 */ 1256 static int ovl_check_overlapping_layers(struct super_block *sb, 1257 struct ovl_fs *ofs) 1258 { 1259 int i, err; 1260 1261 if (ovl_upper_mnt(ofs)) { 1262 err = ovl_check_layer(sb, ofs, ovl_upper_mnt(ofs)->mnt_root, 1263 "upperdir", false); 1264 if (err) 1265 return err; 1266 1267 /* 1268 * Checking workbasedir avoids hitting ovl_is_inuse(parent) of 1269 * this instance and covers overlapping work and index dirs, 1270 * unless work or index dir have been moved since created inside 1271 * workbasedir. In that case, we already have their traps in 1272 * inode cache and we will catch that case on lookup. 1273 */ 1274 err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir", 1275 false); 1276 if (err) 1277 return err; 1278 } 1279 1280 for (i = 1; i < ofs->numlayer; i++) { 1281 err = ovl_check_layer(sb, ofs, 1282 ofs->layers[i].mnt->mnt_root, 1283 "lowerdir", true); 1284 if (err) 1285 return err; 1286 } 1287 1288 return 0; 1289 } 1290 1291 static struct dentry *ovl_get_root(struct super_block *sb, 1292 struct dentry *upperdentry, 1293 struct ovl_entry *oe) 1294 { 1295 struct dentry *root; 1296 struct ovl_path *lowerpath = ovl_lowerstack(oe); 1297 unsigned long ino = d_inode(lowerpath->dentry)->i_ino; 1298 int fsid = lowerpath->layer->fsid; 1299 struct ovl_inode_params oip = { 1300 .upperdentry = upperdentry, 1301 .oe = oe, 1302 }; 1303 1304 root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 1305 if (!root) 1306 return NULL; 1307 1308 if (upperdentry) { 1309 /* Root inode uses upper st_ino/i_ino */ 1310 ino = d_inode(upperdentry)->i_ino; 1311 fsid = 0; 1312 ovl_dentry_set_upper_alias(root); 1313 if (ovl_is_impuredir(sb, upperdentry)) 1314 ovl_set_flag(OVL_IMPURE, d_inode(root)); 1315 } 1316 1317 /* Root is always merge -> can have whiteouts */ 1318 ovl_set_flag(OVL_WHITEOUTS, d_inode(root)); 1319 ovl_dentry_set_flag(OVL_E_CONNECTED, root); 1320 ovl_set_upperdata(d_inode(root)); 1321 ovl_inode_init(d_inode(root), &oip, ino, fsid); 1322 ovl_dentry_init_flags(root, upperdentry, oe, DCACHE_OP_WEAK_REVALIDATE); 1323 /* root keeps a reference of upperdentry */ 1324 dget(upperdentry); 1325 1326 return root; 1327 } 1328 1329 int ovl_fill_super(struct super_block *sb, struct fs_context *fc) 1330 { 1331 struct ovl_fs *ofs = sb->s_fs_info; 1332 struct ovl_fs_context *ctx = fc->fs_private; 1333 struct dentry *root_dentry; 1334 struct ovl_entry *oe; 1335 struct ovl_layer *layers; 1336 struct cred *cred; 1337 int err; 1338 1339 err = -EIO; 1340 if (WARN_ON(fc->user_ns != current_user_ns())) 1341 goto out_err; 1342 1343 sb->s_d_op = &ovl_dentry_operations; 1344 1345 err = -ENOMEM; 1346 ofs->creator_cred = cred = prepare_creds(); 1347 if (!cred) 1348 goto out_err; 1349 1350 err = ovl_fs_params_verify(ctx, &ofs->config); 1351 if (err) 1352 goto out_err; 1353 1354 err = -EINVAL; 1355 if (ctx->nr == 0) { 1356 if (!(fc->sb_flags & SB_SILENT)) 1357 pr_err("missing 'lowerdir'\n"); 1358 goto out_err; 1359 } 1360 1361 err = -ENOMEM; 1362 layers = kcalloc(ctx->nr + 1, sizeof(struct ovl_layer), GFP_KERNEL); 1363 if (!layers) 1364 goto out_err; 1365 1366 ofs->layers = layers; 1367 /* Layer 0 is reserved for upper even if there's no upper */ 1368 ofs->numlayer = 1; 1369 1370 sb->s_stack_depth = 0; 1371 sb->s_maxbytes = MAX_LFS_FILESIZE; 1372 atomic_long_set(&ofs->last_ino, 1); 1373 /* Assume underlying fs uses 32bit inodes unless proven otherwise */ 1374 if (ofs->config.xino != OVL_XINO_OFF) { 1375 ofs->xino_mode = BITS_PER_LONG - 32; 1376 if (!ofs->xino_mode) { 1377 pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n"); 1378 ofs->config.xino = OVL_XINO_OFF; 1379 } 1380 } 1381 1382 /* alloc/destroy_inode needed for setting up traps in inode cache */ 1383 sb->s_op = &ovl_super_operations; 1384 1385 if (ofs->config.upperdir) { 1386 struct super_block *upper_sb; 1387 1388 err = -EINVAL; 1389 if (!ofs->config.workdir) { 1390 pr_err("missing 'workdir'\n"); 1391 goto out_err; 1392 } 1393 1394 err = ovl_get_upper(sb, ofs, &layers[0], &ctx->upper); 1395 if (err) 1396 goto out_err; 1397 1398 upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 1399 if (!ovl_should_sync(ofs)) { 1400 ofs->errseq = errseq_sample(&upper_sb->s_wb_err); 1401 if (errseq_check(&upper_sb->s_wb_err, ofs->errseq)) { 1402 err = -EIO; 1403 pr_err("Cannot mount volatile when upperdir has an unseen error. Sync upperdir fs to clear state.\n"); 1404 goto out_err; 1405 } 1406 } 1407 1408 err = ovl_get_workdir(sb, ofs, &ctx->upper, &ctx->work); 1409 if (err) 1410 goto out_err; 1411 1412 if (!ofs->workdir) 1413 sb->s_flags |= SB_RDONLY; 1414 1415 sb->s_stack_depth = upper_sb->s_stack_depth; 1416 sb->s_time_gran = upper_sb->s_time_gran; 1417 } 1418 oe = ovl_get_lowerstack(sb, ctx, ofs, layers); 1419 err = PTR_ERR(oe); 1420 if (IS_ERR(oe)) 1421 goto out_err; 1422 1423 /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 1424 if (!ovl_upper_mnt(ofs)) 1425 sb->s_flags |= SB_RDONLY; 1426 1427 if (!ovl_origin_uuid(ofs) && ofs->numfs > 1) { 1428 pr_warn("The uuid=off requires a single fs for lower and upper, falling back to uuid=null.\n"); 1429 ofs->config.uuid = OVL_UUID_NULL; 1430 } else if (ovl_has_fsid(ofs)) { 1431 /* Use per instance uuid/fsid */ 1432 uuid_gen(&sb->s_uuid); 1433 } 1434 1435 if (!ovl_force_readonly(ofs) && ofs->config.index) { 1436 err = ovl_get_indexdir(sb, ofs, oe, &ctx->upper); 1437 if (err) 1438 goto out_free_oe; 1439 1440 /* Force r/o mount with no index dir */ 1441 if (!ofs->indexdir) 1442 sb->s_flags |= SB_RDONLY; 1443 } 1444 1445 err = ovl_check_overlapping_layers(sb, ofs); 1446 if (err) 1447 goto out_free_oe; 1448 1449 /* Show index=off in /proc/mounts for forced r/o mount */ 1450 if (!ofs->indexdir) { 1451 ofs->config.index = false; 1452 if (ovl_upper_mnt(ofs) && ofs->config.nfs_export) { 1453 pr_warn("NFS export requires an index dir, falling back to nfs_export=off.\n"); 1454 ofs->config.nfs_export = false; 1455 } 1456 } 1457 1458 if (ofs->config.metacopy && ofs->config.nfs_export) { 1459 pr_warn("NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 1460 ofs->config.nfs_export = false; 1461 } 1462 1463 /* 1464 * Support encoding decodable file handles with nfs_export=on 1465 * and encoding non-decodable file handles with nfs_export=off 1466 * if all layers support file handles. 1467 */ 1468 if (ofs->config.nfs_export) 1469 sb->s_export_op = &ovl_export_operations; 1470 else if (!ofs->nofh) 1471 sb->s_export_op = &ovl_export_fid_operations; 1472 1473 /* Never override disk quota limits or use reserved space */ 1474 cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 1475 1476 sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1477 sb->s_xattr = ofs->config.userxattr ? ovl_user_xattr_handlers : 1478 ovl_trusted_xattr_handlers; 1479 sb->s_fs_info = ofs; 1480 sb->s_flags |= SB_POSIXACL; 1481 sb->s_iflags |= SB_I_SKIP_SYNC | SB_I_IMA_UNVERIFIABLE_SIGNATURE; 1482 1483 err = -ENOMEM; 1484 root_dentry = ovl_get_root(sb, ctx->upper.dentry, oe); 1485 if (!root_dentry) 1486 goto out_free_oe; 1487 1488 sb->s_root = root_dentry; 1489 1490 return 0; 1491 1492 out_free_oe: 1493 ovl_free_entry(oe); 1494 out_err: 1495 ovl_free_fs(ofs); 1496 sb->s_fs_info = NULL; 1497 return err; 1498 } 1499 1500 static struct file_system_type ovl_fs_type = { 1501 .owner = THIS_MODULE, 1502 .name = "overlay", 1503 .init_fs_context = ovl_init_fs_context, 1504 .parameters = ovl_parameter_spec, 1505 .fs_flags = FS_USERNS_MOUNT, 1506 .kill_sb = kill_anon_super, 1507 }; 1508 MODULE_ALIAS_FS("overlay"); 1509 1510 static void ovl_inode_init_once(void *foo) 1511 { 1512 struct ovl_inode *oi = foo; 1513 1514 inode_init_once(&oi->vfs_inode); 1515 } 1516 1517 static int __init ovl_init(void) 1518 { 1519 int err; 1520 1521 ovl_inode_cachep = kmem_cache_create("ovl_inode", 1522 sizeof(struct ovl_inode), 0, 1523 (SLAB_RECLAIM_ACCOUNT| 1524 SLAB_MEM_SPREAD|SLAB_ACCOUNT), 1525 ovl_inode_init_once); 1526 if (ovl_inode_cachep == NULL) 1527 return -ENOMEM; 1528 1529 err = ovl_aio_request_cache_init(); 1530 if (!err) { 1531 err = register_filesystem(&ovl_fs_type); 1532 if (!err) 1533 return 0; 1534 1535 ovl_aio_request_cache_destroy(); 1536 } 1537 kmem_cache_destroy(ovl_inode_cachep); 1538 1539 return err; 1540 } 1541 1542 static void __exit ovl_exit(void) 1543 { 1544 unregister_filesystem(&ovl_fs_type); 1545 1546 /* 1547 * Make sure all delayed rcu free inodes are flushed before we 1548 * destroy cache. 1549 */ 1550 rcu_barrier(); 1551 kmem_cache_destroy(ovl_inode_cachep); 1552 ovl_aio_request_cache_destroy(); 1553 } 1554 1555 module_init(ovl_init); 1556 module_exit(ovl_exit); 1557