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 "overlayfs.h" 19 20 MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 21 MODULE_DESCRIPTION("Overlay filesystem"); 22 MODULE_LICENSE("GPL"); 23 24 25 struct ovl_dir_cache; 26 27 #define OVL_MAX_STACK 500 28 29 static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR); 30 module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644); 31 MODULE_PARM_DESC(redirect_dir, 32 "Default to on or off for the redirect_dir feature"); 33 34 static bool ovl_redirect_always_follow = 35 IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW); 36 module_param_named(redirect_always_follow, ovl_redirect_always_follow, 37 bool, 0644); 38 MODULE_PARM_DESC(redirect_always_follow, 39 "Follow redirects even if redirect_dir feature is turned off"); 40 41 static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX); 42 module_param_named(index, ovl_index_def, bool, 0644); 43 MODULE_PARM_DESC(index, 44 "Default to on or off for the inodes index feature"); 45 46 static bool ovl_nfs_export_def = IS_ENABLED(CONFIG_OVERLAY_FS_NFS_EXPORT); 47 module_param_named(nfs_export, ovl_nfs_export_def, bool, 0644); 48 MODULE_PARM_DESC(nfs_export, 49 "Default to on or off for the NFS export feature"); 50 51 static bool ovl_xino_auto_def = IS_ENABLED(CONFIG_OVERLAY_FS_XINO_AUTO); 52 module_param_named(xino_auto, ovl_xino_auto_def, bool, 0644); 53 MODULE_PARM_DESC(xino_auto, 54 "Auto enable xino feature"); 55 56 static void ovl_entry_stack_free(struct ovl_entry *oe) 57 { 58 unsigned int i; 59 60 for (i = 0; i < oe->numlower; i++) 61 dput(oe->lowerstack[i].dentry); 62 } 63 64 static bool ovl_metacopy_def = IS_ENABLED(CONFIG_OVERLAY_FS_METACOPY); 65 module_param_named(metacopy, ovl_metacopy_def, bool, 0644); 66 MODULE_PARM_DESC(metacopy, 67 "Default to on or off for the metadata only copy up feature"); 68 69 static void ovl_dentry_release(struct dentry *dentry) 70 { 71 struct ovl_entry *oe = dentry->d_fsdata; 72 73 if (oe) { 74 ovl_entry_stack_free(oe); 75 kfree_rcu(oe, rcu); 76 } 77 } 78 79 static struct dentry *ovl_d_real(struct dentry *dentry, 80 const struct inode *inode) 81 { 82 struct dentry *real; 83 84 /* It's an overlay file */ 85 if (inode && d_inode(dentry) == inode) 86 return dentry; 87 88 if (!d_is_reg(dentry)) { 89 if (!inode || inode == d_inode(dentry)) 90 return dentry; 91 goto bug; 92 } 93 94 real = ovl_dentry_upper(dentry); 95 if (real && (inode == d_inode(real))) 96 return real; 97 98 if (real && !inode && ovl_has_upperdata(d_inode(dentry))) 99 return real; 100 101 real = ovl_dentry_lowerdata(dentry); 102 if (!real) 103 goto bug; 104 105 /* Handle recursion */ 106 real = d_real(real, inode); 107 108 if (!inode || inode == d_inode(real)) 109 return real; 110 bug: 111 WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry, 112 inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0); 113 return dentry; 114 } 115 116 static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 117 { 118 struct ovl_entry *oe = dentry->d_fsdata; 119 unsigned int i; 120 int ret = 1; 121 122 for (i = 0; i < oe->numlower; i++) { 123 struct dentry *d = oe->lowerstack[i].dentry; 124 125 if (d->d_flags & DCACHE_OP_REVALIDATE) { 126 ret = d->d_op->d_revalidate(d, flags); 127 if (ret < 0) 128 return ret; 129 if (!ret) { 130 if (!(flags & LOOKUP_RCU)) 131 d_invalidate(d); 132 return -ESTALE; 133 } 134 } 135 } 136 return 1; 137 } 138 139 static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 140 { 141 struct ovl_entry *oe = dentry->d_fsdata; 142 unsigned int i; 143 int ret = 1; 144 145 for (i = 0; i < oe->numlower; i++) { 146 struct dentry *d = oe->lowerstack[i].dentry; 147 148 if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) { 149 ret = d->d_op->d_weak_revalidate(d, flags); 150 if (ret <= 0) 151 break; 152 } 153 } 154 return ret; 155 } 156 157 static const struct dentry_operations ovl_dentry_operations = { 158 .d_release = ovl_dentry_release, 159 .d_real = ovl_d_real, 160 }; 161 162 static const struct dentry_operations ovl_reval_dentry_operations = { 163 .d_release = ovl_dentry_release, 164 .d_real = ovl_d_real, 165 .d_revalidate = ovl_dentry_revalidate, 166 .d_weak_revalidate = ovl_dentry_weak_revalidate, 167 }; 168 169 static struct kmem_cache *ovl_inode_cachep; 170 171 static struct inode *ovl_alloc_inode(struct super_block *sb) 172 { 173 struct ovl_inode *oi = kmem_cache_alloc(ovl_inode_cachep, GFP_KERNEL); 174 175 if (!oi) 176 return NULL; 177 178 oi->cache = NULL; 179 oi->redirect = NULL; 180 oi->version = 0; 181 oi->flags = 0; 182 oi->__upperdentry = NULL; 183 oi->lower = NULL; 184 oi->lowerdata = NULL; 185 mutex_init(&oi->lock); 186 187 return &oi->vfs_inode; 188 } 189 190 static void ovl_free_inode(struct inode *inode) 191 { 192 struct ovl_inode *oi = OVL_I(inode); 193 194 kfree(oi->redirect); 195 mutex_destroy(&oi->lock); 196 kmem_cache_free(ovl_inode_cachep, oi); 197 } 198 199 static void ovl_destroy_inode(struct inode *inode) 200 { 201 struct ovl_inode *oi = OVL_I(inode); 202 203 dput(oi->__upperdentry); 204 iput(oi->lower); 205 if (S_ISDIR(inode->i_mode)) 206 ovl_dir_cache_free(inode); 207 else 208 iput(oi->lowerdata); 209 } 210 211 static void ovl_free_fs(struct ovl_fs *ofs) 212 { 213 unsigned i; 214 215 iput(ofs->indexdir_trap); 216 iput(ofs->workdir_trap); 217 iput(ofs->upperdir_trap); 218 dput(ofs->indexdir); 219 dput(ofs->workdir); 220 if (ofs->workdir_locked) 221 ovl_inuse_unlock(ofs->workbasedir); 222 dput(ofs->workbasedir); 223 if (ofs->upperdir_locked) 224 ovl_inuse_unlock(ofs->upper_mnt->mnt_root); 225 mntput(ofs->upper_mnt); 226 for (i = 0; i < ofs->numlower; i++) { 227 iput(ofs->lower_layers[i].trap); 228 mntput(ofs->lower_layers[i].mnt); 229 } 230 for (i = 0; i < ofs->numlowerfs; i++) 231 free_anon_bdev(ofs->lower_fs[i].pseudo_dev); 232 kfree(ofs->lower_layers); 233 kfree(ofs->lower_fs); 234 235 kfree(ofs->config.lowerdir); 236 kfree(ofs->config.upperdir); 237 kfree(ofs->config.workdir); 238 kfree(ofs->config.redirect_mode); 239 if (ofs->creator_cred) 240 put_cred(ofs->creator_cred); 241 kfree(ofs); 242 } 243 244 static void ovl_put_super(struct super_block *sb) 245 { 246 struct ovl_fs *ofs = sb->s_fs_info; 247 248 ovl_free_fs(ofs); 249 } 250 251 /* Sync real dirty inodes in upper filesystem (if it exists) */ 252 static int ovl_sync_fs(struct super_block *sb, int wait) 253 { 254 struct ovl_fs *ofs = sb->s_fs_info; 255 struct super_block *upper_sb; 256 int ret; 257 258 if (!ofs->upper_mnt) 259 return 0; 260 261 /* 262 * If this is a sync(2) call or an emergency sync, all the super blocks 263 * will be iterated, including upper_sb, so no need to do anything. 264 * 265 * If this is a syncfs(2) call, then we do need to call 266 * sync_filesystem() on upper_sb, but enough if we do it when being 267 * called with wait == 1. 268 */ 269 if (!wait) 270 return 0; 271 272 upper_sb = ofs->upper_mnt->mnt_sb; 273 274 down_read(&upper_sb->s_umount); 275 ret = sync_filesystem(upper_sb); 276 up_read(&upper_sb->s_umount); 277 278 return ret; 279 } 280 281 /** 282 * ovl_statfs 283 * @sb: The overlayfs super block 284 * @buf: The struct kstatfs to fill in with stats 285 * 286 * Get the filesystem statistics. As writes always target the upper layer 287 * filesystem pass the statfs to the upper filesystem (if it exists) 288 */ 289 static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 290 { 291 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 292 struct dentry *root_dentry = dentry->d_sb->s_root; 293 struct path path; 294 int err; 295 296 ovl_path_real(root_dentry, &path); 297 298 err = vfs_statfs(&path, buf); 299 if (!err) { 300 buf->f_namelen = ofs->namelen; 301 buf->f_type = OVERLAYFS_SUPER_MAGIC; 302 } 303 304 return err; 305 } 306 307 /* Will this overlay be forced to mount/remount ro? */ 308 static bool ovl_force_readonly(struct ovl_fs *ofs) 309 { 310 return (!ofs->upper_mnt || !ofs->workdir); 311 } 312 313 static const char *ovl_redirect_mode_def(void) 314 { 315 return ovl_redirect_dir_def ? "on" : "off"; 316 } 317 318 enum { 319 OVL_XINO_OFF, 320 OVL_XINO_AUTO, 321 OVL_XINO_ON, 322 }; 323 324 static const char * const ovl_xino_str[] = { 325 "off", 326 "auto", 327 "on", 328 }; 329 330 static inline int ovl_xino_def(void) 331 { 332 return ovl_xino_auto_def ? OVL_XINO_AUTO : OVL_XINO_OFF; 333 } 334 335 /** 336 * ovl_show_options 337 * 338 * Prints the mount options for a given superblock. 339 * Returns zero; does not fail. 340 */ 341 static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 342 { 343 struct super_block *sb = dentry->d_sb; 344 struct ovl_fs *ofs = sb->s_fs_info; 345 346 seq_show_option(m, "lowerdir", ofs->config.lowerdir); 347 if (ofs->config.upperdir) { 348 seq_show_option(m, "upperdir", ofs->config.upperdir); 349 seq_show_option(m, "workdir", ofs->config.workdir); 350 } 351 if (ofs->config.default_permissions) 352 seq_puts(m, ",default_permissions"); 353 if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0) 354 seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode); 355 if (ofs->config.index != ovl_index_def) 356 seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 357 if (ofs->config.nfs_export != ovl_nfs_export_def) 358 seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ? 359 "on" : "off"); 360 if (ofs->config.xino != ovl_xino_def()) 361 seq_printf(m, ",xino=%s", ovl_xino_str[ofs->config.xino]); 362 if (ofs->config.metacopy != ovl_metacopy_def) 363 seq_printf(m, ",metacopy=%s", 364 ofs->config.metacopy ? "on" : "off"); 365 return 0; 366 } 367 368 static int ovl_remount(struct super_block *sb, int *flags, char *data) 369 { 370 struct ovl_fs *ofs = sb->s_fs_info; 371 372 if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 373 return -EROFS; 374 375 return 0; 376 } 377 378 static const struct super_operations ovl_super_operations = { 379 .alloc_inode = ovl_alloc_inode, 380 .free_inode = ovl_free_inode, 381 .destroy_inode = ovl_destroy_inode, 382 .drop_inode = generic_delete_inode, 383 .put_super = ovl_put_super, 384 .sync_fs = ovl_sync_fs, 385 .statfs = ovl_statfs, 386 .show_options = ovl_show_options, 387 .remount_fs = ovl_remount, 388 }; 389 390 enum { 391 OPT_LOWERDIR, 392 OPT_UPPERDIR, 393 OPT_WORKDIR, 394 OPT_DEFAULT_PERMISSIONS, 395 OPT_REDIRECT_DIR, 396 OPT_INDEX_ON, 397 OPT_INDEX_OFF, 398 OPT_NFS_EXPORT_ON, 399 OPT_NFS_EXPORT_OFF, 400 OPT_XINO_ON, 401 OPT_XINO_OFF, 402 OPT_XINO_AUTO, 403 OPT_METACOPY_ON, 404 OPT_METACOPY_OFF, 405 OPT_ERR, 406 }; 407 408 static const match_table_t ovl_tokens = { 409 {OPT_LOWERDIR, "lowerdir=%s"}, 410 {OPT_UPPERDIR, "upperdir=%s"}, 411 {OPT_WORKDIR, "workdir=%s"}, 412 {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 413 {OPT_REDIRECT_DIR, "redirect_dir=%s"}, 414 {OPT_INDEX_ON, "index=on"}, 415 {OPT_INDEX_OFF, "index=off"}, 416 {OPT_NFS_EXPORT_ON, "nfs_export=on"}, 417 {OPT_NFS_EXPORT_OFF, "nfs_export=off"}, 418 {OPT_XINO_ON, "xino=on"}, 419 {OPT_XINO_OFF, "xino=off"}, 420 {OPT_XINO_AUTO, "xino=auto"}, 421 {OPT_METACOPY_ON, "metacopy=on"}, 422 {OPT_METACOPY_OFF, "metacopy=off"}, 423 {OPT_ERR, NULL} 424 }; 425 426 static char *ovl_next_opt(char **s) 427 { 428 char *sbegin = *s; 429 char *p; 430 431 if (sbegin == NULL) 432 return NULL; 433 434 for (p = sbegin; *p; p++) { 435 if (*p == '\\') { 436 p++; 437 if (!*p) 438 break; 439 } else if (*p == ',') { 440 *p = '\0'; 441 *s = p + 1; 442 return sbegin; 443 } 444 } 445 *s = NULL; 446 return sbegin; 447 } 448 449 static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode) 450 { 451 if (strcmp(mode, "on") == 0) { 452 config->redirect_dir = true; 453 /* 454 * Does not make sense to have redirect creation without 455 * redirect following. 456 */ 457 config->redirect_follow = true; 458 } else if (strcmp(mode, "follow") == 0) { 459 config->redirect_follow = true; 460 } else if (strcmp(mode, "off") == 0) { 461 if (ovl_redirect_always_follow) 462 config->redirect_follow = true; 463 } else if (strcmp(mode, "nofollow") != 0) { 464 pr_err("overlayfs: bad mount option \"redirect_dir=%s\"\n", 465 mode); 466 return -EINVAL; 467 } 468 469 return 0; 470 } 471 472 static int ovl_parse_opt(char *opt, struct ovl_config *config) 473 { 474 char *p; 475 int err; 476 bool metacopy_opt = false, redirect_opt = false; 477 478 config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL); 479 if (!config->redirect_mode) 480 return -ENOMEM; 481 482 while ((p = ovl_next_opt(&opt)) != NULL) { 483 int token; 484 substring_t args[MAX_OPT_ARGS]; 485 486 if (!*p) 487 continue; 488 489 token = match_token(p, ovl_tokens, args); 490 switch (token) { 491 case OPT_UPPERDIR: 492 kfree(config->upperdir); 493 config->upperdir = match_strdup(&args[0]); 494 if (!config->upperdir) 495 return -ENOMEM; 496 break; 497 498 case OPT_LOWERDIR: 499 kfree(config->lowerdir); 500 config->lowerdir = match_strdup(&args[0]); 501 if (!config->lowerdir) 502 return -ENOMEM; 503 break; 504 505 case OPT_WORKDIR: 506 kfree(config->workdir); 507 config->workdir = match_strdup(&args[0]); 508 if (!config->workdir) 509 return -ENOMEM; 510 break; 511 512 case OPT_DEFAULT_PERMISSIONS: 513 config->default_permissions = true; 514 break; 515 516 case OPT_REDIRECT_DIR: 517 kfree(config->redirect_mode); 518 config->redirect_mode = match_strdup(&args[0]); 519 if (!config->redirect_mode) 520 return -ENOMEM; 521 redirect_opt = true; 522 break; 523 524 case OPT_INDEX_ON: 525 config->index = true; 526 break; 527 528 case OPT_INDEX_OFF: 529 config->index = false; 530 break; 531 532 case OPT_NFS_EXPORT_ON: 533 config->nfs_export = true; 534 break; 535 536 case OPT_NFS_EXPORT_OFF: 537 config->nfs_export = false; 538 break; 539 540 case OPT_XINO_ON: 541 config->xino = OVL_XINO_ON; 542 break; 543 544 case OPT_XINO_OFF: 545 config->xino = OVL_XINO_OFF; 546 break; 547 548 case OPT_XINO_AUTO: 549 config->xino = OVL_XINO_AUTO; 550 break; 551 552 case OPT_METACOPY_ON: 553 config->metacopy = true; 554 metacopy_opt = true; 555 break; 556 557 case OPT_METACOPY_OFF: 558 config->metacopy = false; 559 break; 560 561 default: 562 pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p); 563 return -EINVAL; 564 } 565 } 566 567 /* Workdir is useless in non-upper mount */ 568 if (!config->upperdir && config->workdir) { 569 pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 570 config->workdir); 571 kfree(config->workdir); 572 config->workdir = NULL; 573 } 574 575 err = ovl_parse_redirect_mode(config, config->redirect_mode); 576 if (err) 577 return err; 578 579 /* 580 * This is to make the logic below simpler. It doesn't make any other 581 * difference, since config->redirect_dir is only used for upper. 582 */ 583 if (!config->upperdir && config->redirect_follow) 584 config->redirect_dir = true; 585 586 /* Resolve metacopy -> redirect_dir dependency */ 587 if (config->metacopy && !config->redirect_dir) { 588 if (metacopy_opt && redirect_opt) { 589 pr_err("overlayfs: conflicting options: metacopy=on,redirect_dir=%s\n", 590 config->redirect_mode); 591 return -EINVAL; 592 } 593 if (redirect_opt) { 594 /* 595 * There was an explicit redirect_dir=... that resulted 596 * in this conflict. 597 */ 598 pr_info("overlayfs: disabling metacopy due to redirect_dir=%s\n", 599 config->redirect_mode); 600 config->metacopy = false; 601 } else { 602 /* Automatically enable redirect otherwise. */ 603 config->redirect_follow = config->redirect_dir = true; 604 } 605 } 606 607 return 0; 608 } 609 610 #define OVL_WORKDIR_NAME "work" 611 #define OVL_INDEXDIR_NAME "index" 612 613 static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 614 const char *name, bool persist) 615 { 616 struct inode *dir = ofs->workbasedir->d_inode; 617 struct vfsmount *mnt = ofs->upper_mnt; 618 struct dentry *work; 619 int err; 620 bool retried = false; 621 bool locked = false; 622 623 inode_lock_nested(dir, I_MUTEX_PARENT); 624 locked = true; 625 626 retry: 627 work = lookup_one_len(name, ofs->workbasedir, strlen(name)); 628 629 if (!IS_ERR(work)) { 630 struct iattr attr = { 631 .ia_valid = ATTR_MODE, 632 .ia_mode = S_IFDIR | 0, 633 }; 634 635 if (work->d_inode) { 636 err = -EEXIST; 637 if (retried) 638 goto out_dput; 639 640 if (persist) 641 goto out_unlock; 642 643 retried = true; 644 ovl_workdir_cleanup(dir, mnt, work, 0); 645 dput(work); 646 goto retry; 647 } 648 649 work = ovl_create_real(dir, work, OVL_CATTR(attr.ia_mode)); 650 err = PTR_ERR(work); 651 if (IS_ERR(work)) 652 goto out_err; 653 654 /* 655 * Try to remove POSIX ACL xattrs from workdir. We are good if: 656 * 657 * a) success (there was a POSIX ACL xattr and was removed) 658 * b) -ENODATA (there was no POSIX ACL xattr) 659 * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 660 * 661 * There are various other error values that could effectively 662 * mean that the xattr doesn't exist (e.g. -ERANGE is returned 663 * if the xattr name is too long), but the set of filesystems 664 * allowed as upper are limited to "normal" ones, where checking 665 * for the above two errors is sufficient. 666 */ 667 err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 668 if (err && err != -ENODATA && err != -EOPNOTSUPP) 669 goto out_dput; 670 671 err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 672 if (err && err != -ENODATA && err != -EOPNOTSUPP) 673 goto out_dput; 674 675 /* Clear any inherited mode bits */ 676 inode_lock(work->d_inode); 677 err = notify_change(work, &attr, NULL); 678 inode_unlock(work->d_inode); 679 if (err) 680 goto out_dput; 681 } else { 682 err = PTR_ERR(work); 683 goto out_err; 684 } 685 out_unlock: 686 if (locked) 687 inode_unlock(dir); 688 689 return work; 690 691 out_dput: 692 dput(work); 693 out_err: 694 pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n", 695 ofs->config.workdir, name, -err); 696 work = NULL; 697 goto out_unlock; 698 } 699 700 static void ovl_unescape(char *s) 701 { 702 char *d = s; 703 704 for (;; s++, d++) { 705 if (*s == '\\') 706 s++; 707 *d = *s; 708 if (!*s) 709 break; 710 } 711 } 712 713 static int ovl_mount_dir_noesc(const char *name, struct path *path) 714 { 715 int err = -EINVAL; 716 717 if (!*name) { 718 pr_err("overlayfs: empty lowerdir\n"); 719 goto out; 720 } 721 err = kern_path(name, LOOKUP_FOLLOW, path); 722 if (err) { 723 pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); 724 goto out; 725 } 726 err = -EINVAL; 727 if (ovl_dentry_weird(path->dentry)) { 728 pr_err("overlayfs: filesystem on '%s' not supported\n", name); 729 goto out_put; 730 } 731 if (!d_is_dir(path->dentry)) { 732 pr_err("overlayfs: '%s' not a directory\n", name); 733 goto out_put; 734 } 735 return 0; 736 737 out_put: 738 path_put_init(path); 739 out: 740 return err; 741 } 742 743 static int ovl_mount_dir(const char *name, struct path *path) 744 { 745 int err = -ENOMEM; 746 char *tmp = kstrdup(name, GFP_KERNEL); 747 748 if (tmp) { 749 ovl_unescape(tmp); 750 err = ovl_mount_dir_noesc(tmp, path); 751 752 if (!err) 753 if (ovl_dentry_remote(path->dentry)) { 754 pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n", 755 tmp); 756 path_put_init(path); 757 err = -EINVAL; 758 } 759 kfree(tmp); 760 } 761 return err; 762 } 763 764 static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 765 const char *name) 766 { 767 struct kstatfs statfs; 768 int err = vfs_statfs(path, &statfs); 769 770 if (err) 771 pr_err("overlayfs: statfs failed on '%s'\n", name); 772 else 773 ofs->namelen = max(ofs->namelen, statfs.f_namelen); 774 775 return err; 776 } 777 778 static int ovl_lower_dir(const char *name, struct path *path, 779 struct ovl_fs *ofs, int *stack_depth, bool *remote) 780 { 781 int fh_type; 782 int err; 783 784 err = ovl_mount_dir_noesc(name, path); 785 if (err) 786 goto out; 787 788 err = ovl_check_namelen(path, ofs, name); 789 if (err) 790 goto out_put; 791 792 *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 793 794 if (ovl_dentry_remote(path->dentry)) 795 *remote = true; 796 797 /* 798 * The inodes index feature and NFS export need to encode and decode 799 * file handles, so they require that all layers support them. 800 */ 801 fh_type = ovl_can_decode_fh(path->dentry->d_sb); 802 if ((ofs->config.nfs_export || 803 (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 804 ofs->config.index = false; 805 ofs->config.nfs_export = false; 806 pr_warn("overlayfs: fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 807 name); 808 } 809 810 /* Check if lower fs has 32bit inode numbers */ 811 if (fh_type != FILEID_INO32_GEN) 812 ofs->xino_bits = 0; 813 814 return 0; 815 816 out_put: 817 path_put_init(path); 818 out: 819 return err; 820 } 821 822 /* Workdir should not be subdir of upperdir and vice versa */ 823 static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 824 { 825 bool ok = false; 826 827 if (workdir != upperdir) { 828 ok = (lock_rename(workdir, upperdir) == NULL); 829 unlock_rename(workdir, upperdir); 830 } 831 return ok; 832 } 833 834 static unsigned int ovl_split_lowerdirs(char *str) 835 { 836 unsigned int ctr = 1; 837 char *s, *d; 838 839 for (s = d = str;; s++, d++) { 840 if (*s == '\\') { 841 s++; 842 } else if (*s == ':') { 843 *d = '\0'; 844 ctr++; 845 continue; 846 } 847 *d = *s; 848 if (!*s) 849 break; 850 } 851 return ctr; 852 } 853 854 static int __maybe_unused 855 ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 856 struct dentry *dentry, struct inode *inode, 857 const char *name, void *buffer, size_t size) 858 { 859 return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 860 } 861 862 static int __maybe_unused 863 ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 864 struct dentry *dentry, struct inode *inode, 865 const char *name, const void *value, 866 size_t size, int flags) 867 { 868 struct dentry *workdir = ovl_workdir(dentry); 869 struct inode *realinode = ovl_inode_real(inode); 870 struct posix_acl *acl = NULL; 871 int err; 872 873 /* Check that everything is OK before copy-up */ 874 if (value) { 875 acl = posix_acl_from_xattr(&init_user_ns, value, size); 876 if (IS_ERR(acl)) 877 return PTR_ERR(acl); 878 } 879 err = -EOPNOTSUPP; 880 if (!IS_POSIXACL(d_inode(workdir))) 881 goto out_acl_release; 882 if (!realinode->i_op->set_acl) 883 goto out_acl_release; 884 if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 885 err = acl ? -EACCES : 0; 886 goto out_acl_release; 887 } 888 err = -EPERM; 889 if (!inode_owner_or_capable(inode)) 890 goto out_acl_release; 891 892 posix_acl_release(acl); 893 894 /* 895 * Check if sgid bit needs to be cleared (actual setacl operation will 896 * be done with mounter's capabilities and so that won't do it for us). 897 */ 898 if (unlikely(inode->i_mode & S_ISGID) && 899 handler->flags == ACL_TYPE_ACCESS && 900 !in_group_p(inode->i_gid) && 901 !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 902 struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 903 904 err = ovl_setattr(dentry, &iattr); 905 if (err) 906 return err; 907 } 908 909 err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 910 if (!err) 911 ovl_copyattr(ovl_inode_real(inode), inode); 912 913 return err; 914 915 out_acl_release: 916 posix_acl_release(acl); 917 return err; 918 } 919 920 static int ovl_own_xattr_get(const struct xattr_handler *handler, 921 struct dentry *dentry, struct inode *inode, 922 const char *name, void *buffer, size_t size) 923 { 924 return -EOPNOTSUPP; 925 } 926 927 static int ovl_own_xattr_set(const struct xattr_handler *handler, 928 struct dentry *dentry, struct inode *inode, 929 const char *name, const void *value, 930 size_t size, int flags) 931 { 932 return -EOPNOTSUPP; 933 } 934 935 static int ovl_other_xattr_get(const struct xattr_handler *handler, 936 struct dentry *dentry, struct inode *inode, 937 const char *name, void *buffer, size_t size) 938 { 939 return ovl_xattr_get(dentry, inode, name, buffer, size); 940 } 941 942 static int ovl_other_xattr_set(const struct xattr_handler *handler, 943 struct dentry *dentry, struct inode *inode, 944 const char *name, const void *value, 945 size_t size, int flags) 946 { 947 return ovl_xattr_set(dentry, inode, name, value, size, flags); 948 } 949 950 static const struct xattr_handler __maybe_unused 951 ovl_posix_acl_access_xattr_handler = { 952 .name = XATTR_NAME_POSIX_ACL_ACCESS, 953 .flags = ACL_TYPE_ACCESS, 954 .get = ovl_posix_acl_xattr_get, 955 .set = ovl_posix_acl_xattr_set, 956 }; 957 958 static const struct xattr_handler __maybe_unused 959 ovl_posix_acl_default_xattr_handler = { 960 .name = XATTR_NAME_POSIX_ACL_DEFAULT, 961 .flags = ACL_TYPE_DEFAULT, 962 .get = ovl_posix_acl_xattr_get, 963 .set = ovl_posix_acl_xattr_set, 964 }; 965 966 static const struct xattr_handler ovl_own_xattr_handler = { 967 .prefix = OVL_XATTR_PREFIX, 968 .get = ovl_own_xattr_get, 969 .set = ovl_own_xattr_set, 970 }; 971 972 static const struct xattr_handler ovl_other_xattr_handler = { 973 .prefix = "", /* catch all */ 974 .get = ovl_other_xattr_get, 975 .set = ovl_other_xattr_set, 976 }; 977 978 static const struct xattr_handler *ovl_xattr_handlers[] = { 979 #ifdef CONFIG_FS_POSIX_ACL 980 &ovl_posix_acl_access_xattr_handler, 981 &ovl_posix_acl_default_xattr_handler, 982 #endif 983 &ovl_own_xattr_handler, 984 &ovl_other_xattr_handler, 985 NULL 986 }; 987 988 static int ovl_setup_trap(struct super_block *sb, struct dentry *dir, 989 struct inode **ptrap, const char *name) 990 { 991 struct inode *trap; 992 int err; 993 994 trap = ovl_get_trap_inode(sb, dir); 995 err = PTR_ERR_OR_ZERO(trap); 996 if (err) { 997 if (err == -ELOOP) 998 pr_err("overlayfs: conflicting %s path\n", name); 999 return err; 1000 } 1001 1002 *ptrap = trap; 1003 return 0; 1004 } 1005 1006 static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs, 1007 struct path *upperpath) 1008 { 1009 struct vfsmount *upper_mnt; 1010 int err; 1011 1012 err = ovl_mount_dir(ofs->config.upperdir, upperpath); 1013 if (err) 1014 goto out; 1015 1016 /* Upper fs should not be r/o */ 1017 if (sb_rdonly(upperpath->mnt->mnt_sb)) { 1018 pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n"); 1019 err = -EINVAL; 1020 goto out; 1021 } 1022 1023 err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 1024 if (err) 1025 goto out; 1026 1027 err = ovl_setup_trap(sb, upperpath->dentry, &ofs->upperdir_trap, 1028 "upperdir"); 1029 if (err) 1030 goto out; 1031 1032 upper_mnt = clone_private_mount(upperpath); 1033 err = PTR_ERR(upper_mnt); 1034 if (IS_ERR(upper_mnt)) { 1035 pr_err("overlayfs: failed to clone upperpath\n"); 1036 goto out; 1037 } 1038 1039 /* Don't inherit atime flags */ 1040 upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 1041 ofs->upper_mnt = upper_mnt; 1042 1043 err = -EBUSY; 1044 if (ovl_inuse_trylock(ofs->upper_mnt->mnt_root)) { 1045 ofs->upperdir_locked = true; 1046 } else if (ofs->config.index) { 1047 pr_err("overlayfs: upperdir is in-use by another mount, mount with '-o index=off' to override exclusive upperdir protection.\n"); 1048 goto out; 1049 } else { 1050 pr_warn("overlayfs: upperdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 1051 } 1052 1053 err = 0; 1054 out: 1055 return err; 1056 } 1057 1058 static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs, 1059 struct path *workpath) 1060 { 1061 struct vfsmount *mnt = ofs->upper_mnt; 1062 struct dentry *temp; 1063 int fh_type; 1064 int err; 1065 1066 err = mnt_want_write(mnt); 1067 if (err) 1068 return err; 1069 1070 ofs->workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 1071 if (!ofs->workdir) 1072 goto out; 1073 1074 err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir"); 1075 if (err) 1076 goto out; 1077 1078 /* 1079 * Upper should support d_type, else whiteouts are visible. Given 1080 * workdir and upper are on same fs, we can do iterate_dir() on 1081 * workdir. This check requires successful creation of workdir in 1082 * previous step. 1083 */ 1084 err = ovl_check_d_type_supported(workpath); 1085 if (err < 0) 1086 goto out; 1087 1088 /* 1089 * We allowed this configuration and don't want to break users over 1090 * kernel upgrade. So warn instead of erroring out. 1091 */ 1092 if (!err) 1093 pr_warn("overlayfs: upper fs needs to support d_type.\n"); 1094 1095 /* Check if upper/work fs supports O_TMPFILE */ 1096 temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0); 1097 ofs->tmpfile = !IS_ERR(temp); 1098 if (ofs->tmpfile) 1099 dput(temp); 1100 else 1101 pr_warn("overlayfs: upper fs does not support tmpfile.\n"); 1102 1103 /* 1104 * Check if upper/work fs supports trusted.overlay.* xattr 1105 */ 1106 err = ovl_do_setxattr(ofs->workdir, OVL_XATTR_OPAQUE, "0", 1, 0); 1107 if (err) { 1108 ofs->noxattr = true; 1109 ofs->config.index = false; 1110 ofs->config.metacopy = false; 1111 pr_warn("overlayfs: upper fs does not support xattr, falling back to index=off and metacopy=off.\n"); 1112 err = 0; 1113 } else { 1114 vfs_removexattr(ofs->workdir, OVL_XATTR_OPAQUE); 1115 } 1116 1117 /* Check if upper/work fs supports file handles */ 1118 fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 1119 if (ofs->config.index && !fh_type) { 1120 ofs->config.index = false; 1121 pr_warn("overlayfs: upper fs does not support file handles, falling back to index=off.\n"); 1122 } 1123 1124 /* Check if upper fs has 32bit inode numbers */ 1125 if (fh_type != FILEID_INO32_GEN) 1126 ofs->xino_bits = 0; 1127 1128 /* NFS export of r/w mount depends on index */ 1129 if (ofs->config.nfs_export && !ofs->config.index) { 1130 pr_warn("overlayfs: NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 1131 ofs->config.nfs_export = false; 1132 } 1133 out: 1134 mnt_drop_write(mnt); 1135 return err; 1136 } 1137 1138 static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs, 1139 struct path *upperpath) 1140 { 1141 int err; 1142 struct path workpath = { }; 1143 1144 err = ovl_mount_dir(ofs->config.workdir, &workpath); 1145 if (err) 1146 goto out; 1147 1148 err = -EINVAL; 1149 if (upperpath->mnt != workpath.mnt) { 1150 pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 1151 goto out; 1152 } 1153 if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 1154 pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 1155 goto out; 1156 } 1157 1158 ofs->workbasedir = dget(workpath.dentry); 1159 1160 err = -EBUSY; 1161 if (ovl_inuse_trylock(ofs->workbasedir)) { 1162 ofs->workdir_locked = true; 1163 } else if (ofs->config.index) { 1164 pr_err("overlayfs: workdir is in-use by another mount, mount with '-o index=off' to override exclusive workdir protection.\n"); 1165 goto out; 1166 } else { 1167 pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 1168 } 1169 1170 err = ovl_make_workdir(sb, ofs, &workpath); 1171 1172 out: 1173 path_put(&workpath); 1174 1175 return err; 1176 } 1177 1178 static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs, 1179 struct ovl_entry *oe, struct path *upperpath) 1180 { 1181 struct vfsmount *mnt = ofs->upper_mnt; 1182 int err; 1183 1184 err = mnt_want_write(mnt); 1185 if (err) 1186 return err; 1187 1188 /* Verify lower root is upper root origin */ 1189 err = ovl_verify_origin(upperpath->dentry, oe->lowerstack[0].dentry, 1190 true); 1191 if (err) { 1192 pr_err("overlayfs: failed to verify upper root origin\n"); 1193 goto out; 1194 } 1195 1196 ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1197 if (ofs->indexdir) { 1198 err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap, 1199 "indexdir"); 1200 if (err) 1201 goto out; 1202 1203 /* 1204 * Verify upper root is exclusively associated with index dir. 1205 * Older kernels stored upper fh in "trusted.overlay.origin" 1206 * xattr. If that xattr exists, verify that it is a match to 1207 * upper dir file handle. In any case, verify or set xattr 1208 * "trusted.overlay.upper" to indicate that index may have 1209 * directory entries. 1210 */ 1211 if (ovl_check_origin_xattr(ofs->indexdir)) { 1212 err = ovl_verify_set_fh(ofs->indexdir, OVL_XATTR_ORIGIN, 1213 upperpath->dentry, true, false); 1214 if (err) 1215 pr_err("overlayfs: failed to verify index dir 'origin' xattr\n"); 1216 } 1217 err = ovl_verify_upper(ofs->indexdir, upperpath->dentry, true); 1218 if (err) 1219 pr_err("overlayfs: failed to verify index dir 'upper' xattr\n"); 1220 1221 /* Cleanup bad/stale/orphan index entries */ 1222 if (!err) 1223 err = ovl_indexdir_cleanup(ofs); 1224 } 1225 if (err || !ofs->indexdir) 1226 pr_warn("overlayfs: try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1227 1228 out: 1229 mnt_drop_write(mnt); 1230 return err; 1231 } 1232 1233 static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid) 1234 { 1235 unsigned int i; 1236 1237 if (!ofs->config.nfs_export && !(ofs->config.index && ofs->upper_mnt)) 1238 return true; 1239 1240 for (i = 0; i < ofs->numlowerfs; i++) { 1241 /* 1242 * We use uuid to associate an overlay lower file handle with a 1243 * lower layer, so we can accept lower fs with null uuid as long 1244 * as all lower layers with null uuid are on the same fs. 1245 */ 1246 if (uuid_equal(&ofs->lower_fs[i].sb->s_uuid, uuid)) 1247 return false; 1248 } 1249 return true; 1250 } 1251 1252 /* Get a unique fsid for the layer */ 1253 static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) 1254 { 1255 struct super_block *sb = path->mnt->mnt_sb; 1256 unsigned int i; 1257 dev_t dev; 1258 int err; 1259 1260 /* fsid 0 is reserved for upper fs even with non upper overlay */ 1261 if (ofs->upper_mnt && ofs->upper_mnt->mnt_sb == sb) 1262 return 0; 1263 1264 for (i = 0; i < ofs->numlowerfs; i++) { 1265 if (ofs->lower_fs[i].sb == sb) 1266 return i + 1; 1267 } 1268 1269 if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) { 1270 ofs->config.index = false; 1271 ofs->config.nfs_export = false; 1272 pr_warn("overlayfs: %s uuid detected in lower fs '%pd2', falling back to index=off,nfs_export=off.\n", 1273 uuid_is_null(&sb->s_uuid) ? "null" : "conflicting", 1274 path->dentry); 1275 } 1276 1277 err = get_anon_bdev(&dev); 1278 if (err) { 1279 pr_err("overlayfs: failed to get anonymous bdev for lowerpath\n"); 1280 return err; 1281 } 1282 1283 ofs->lower_fs[ofs->numlowerfs].sb = sb; 1284 ofs->lower_fs[ofs->numlowerfs].pseudo_dev = dev; 1285 ofs->numlowerfs++; 1286 1287 return ofs->numlowerfs; 1288 } 1289 1290 static int ovl_get_lower_layers(struct super_block *sb, struct ovl_fs *ofs, 1291 struct path *stack, unsigned int numlower) 1292 { 1293 int err; 1294 unsigned int i; 1295 1296 err = -ENOMEM; 1297 ofs->lower_layers = kcalloc(numlower, sizeof(struct ovl_layer), 1298 GFP_KERNEL); 1299 if (ofs->lower_layers == NULL) 1300 goto out; 1301 1302 ofs->lower_fs = kcalloc(numlower, sizeof(struct ovl_sb), 1303 GFP_KERNEL); 1304 if (ofs->lower_fs == NULL) 1305 goto out; 1306 1307 for (i = 0; i < numlower; i++) { 1308 struct vfsmount *mnt; 1309 struct inode *trap; 1310 int fsid; 1311 1312 err = fsid = ovl_get_fsid(ofs, &stack[i]); 1313 if (err < 0) 1314 goto out; 1315 1316 err = -EBUSY; 1317 if (ovl_is_inuse(stack[i].dentry)) { 1318 pr_err("overlayfs: lowerdir is in-use as upperdir/workdir\n"); 1319 goto out; 1320 } 1321 1322 err = ovl_setup_trap(sb, stack[i].dentry, &trap, "lowerdir"); 1323 if (err) 1324 goto out; 1325 1326 mnt = clone_private_mount(&stack[i]); 1327 err = PTR_ERR(mnt); 1328 if (IS_ERR(mnt)) { 1329 pr_err("overlayfs: failed to clone lowerpath\n"); 1330 iput(trap); 1331 goto out; 1332 } 1333 1334 /* 1335 * Make lower layers R/O. That way fchmod/fchown on lower file 1336 * will fail instead of modifying lower fs. 1337 */ 1338 mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1339 1340 ofs->lower_layers[ofs->numlower].trap = trap; 1341 ofs->lower_layers[ofs->numlower].mnt = mnt; 1342 ofs->lower_layers[ofs->numlower].idx = i + 1; 1343 ofs->lower_layers[ofs->numlower].fsid = fsid; 1344 if (fsid) { 1345 ofs->lower_layers[ofs->numlower].fs = 1346 &ofs->lower_fs[fsid - 1]; 1347 } 1348 ofs->numlower++; 1349 } 1350 1351 /* 1352 * When all layers on same fs, overlay can use real inode numbers. 1353 * With mount option "xino=on", mounter declares that there are enough 1354 * free high bits in underlying fs to hold the unique fsid. 1355 * If overlayfs does encounter underlying inodes using the high xino 1356 * bits reserved for fsid, it emits a warning and uses the original 1357 * inode number. 1358 */ 1359 if (!ofs->numlowerfs || (ofs->numlowerfs == 1 && !ofs->upper_mnt)) { 1360 ofs->xino_bits = 0; 1361 ofs->config.xino = OVL_XINO_OFF; 1362 } else if (ofs->config.xino == OVL_XINO_ON && !ofs->xino_bits) { 1363 /* 1364 * This is a roundup of number of bits needed for numlowerfs+1 1365 * (i.e. ilog2(numlowerfs+1 - 1) + 1). fsid 0 is reserved for 1366 * upper fs even with non upper overlay. 1367 */ 1368 BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 31); 1369 ofs->xino_bits = ilog2(ofs->numlowerfs) + 1; 1370 } 1371 1372 if (ofs->xino_bits) { 1373 pr_info("overlayfs: \"xino\" feature enabled using %d upper inode bits.\n", 1374 ofs->xino_bits); 1375 } 1376 1377 err = 0; 1378 out: 1379 return err; 1380 } 1381 1382 static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1383 struct ovl_fs *ofs) 1384 { 1385 int err; 1386 char *lowertmp, *lower; 1387 struct path *stack = NULL; 1388 unsigned int stacklen, numlower = 0, i; 1389 bool remote = false; 1390 struct ovl_entry *oe; 1391 1392 err = -ENOMEM; 1393 lowertmp = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 1394 if (!lowertmp) 1395 goto out_err; 1396 1397 err = -EINVAL; 1398 stacklen = ovl_split_lowerdirs(lowertmp); 1399 if (stacklen > OVL_MAX_STACK) { 1400 pr_err("overlayfs: too many lower directories, limit is %d\n", 1401 OVL_MAX_STACK); 1402 goto out_err; 1403 } else if (!ofs->config.upperdir && stacklen == 1) { 1404 pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n"); 1405 goto out_err; 1406 } else if (!ofs->config.upperdir && ofs->config.nfs_export && 1407 ofs->config.redirect_follow) { 1408 pr_warn("overlayfs: NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n"); 1409 ofs->config.nfs_export = false; 1410 } 1411 1412 err = -ENOMEM; 1413 stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL); 1414 if (!stack) 1415 goto out_err; 1416 1417 err = -EINVAL; 1418 lower = lowertmp; 1419 for (numlower = 0; numlower < stacklen; numlower++) { 1420 err = ovl_lower_dir(lower, &stack[numlower], ofs, 1421 &sb->s_stack_depth, &remote); 1422 if (err) 1423 goto out_err; 1424 1425 lower = strchr(lower, '\0') + 1; 1426 } 1427 1428 err = -EINVAL; 1429 sb->s_stack_depth++; 1430 if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 1431 pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 1432 goto out_err; 1433 } 1434 1435 err = ovl_get_lower_layers(sb, ofs, stack, numlower); 1436 if (err) 1437 goto out_err; 1438 1439 err = -ENOMEM; 1440 oe = ovl_alloc_entry(numlower); 1441 if (!oe) 1442 goto out_err; 1443 1444 for (i = 0; i < numlower; i++) { 1445 oe->lowerstack[i].dentry = dget(stack[i].dentry); 1446 oe->lowerstack[i].layer = &ofs->lower_layers[i]; 1447 } 1448 1449 if (remote) 1450 sb->s_d_op = &ovl_reval_dentry_operations; 1451 else 1452 sb->s_d_op = &ovl_dentry_operations; 1453 1454 out: 1455 for (i = 0; i < numlower; i++) 1456 path_put(&stack[i]); 1457 kfree(stack); 1458 kfree(lowertmp); 1459 1460 return oe; 1461 1462 out_err: 1463 oe = ERR_PTR(err); 1464 goto out; 1465 } 1466 1467 /* 1468 * Check if this layer root is a descendant of: 1469 * - another layer of this overlayfs instance 1470 * - upper/work dir of any overlayfs instance 1471 */ 1472 static int ovl_check_layer(struct super_block *sb, struct dentry *dentry, 1473 const char *name) 1474 { 1475 struct dentry *next = dentry, *parent; 1476 int err = 0; 1477 1478 if (!dentry) 1479 return 0; 1480 1481 parent = dget_parent(next); 1482 1483 /* Walk back ancestors to root (inclusive) looking for traps */ 1484 while (!err && parent != next) { 1485 if (ovl_is_inuse(parent)) { 1486 err = -EBUSY; 1487 pr_err("overlayfs: %s path overlapping in-use upperdir/workdir\n", 1488 name); 1489 } else if (ovl_lookup_trap_inode(sb, parent)) { 1490 err = -ELOOP; 1491 pr_err("overlayfs: overlapping %s path\n", name); 1492 } 1493 next = parent; 1494 parent = dget_parent(next); 1495 dput(next); 1496 } 1497 1498 dput(parent); 1499 1500 return err; 1501 } 1502 1503 /* 1504 * Check if any of the layers or work dirs overlap. 1505 */ 1506 static int ovl_check_overlapping_layers(struct super_block *sb, 1507 struct ovl_fs *ofs) 1508 { 1509 int i, err; 1510 1511 if (ofs->upper_mnt) { 1512 err = ovl_check_layer(sb, ofs->upper_mnt->mnt_root, "upperdir"); 1513 if (err) 1514 return err; 1515 1516 /* 1517 * Checking workbasedir avoids hitting ovl_is_inuse(parent) of 1518 * this instance and covers overlapping work and index dirs, 1519 * unless work or index dir have been moved since created inside 1520 * workbasedir. In that case, we already have their traps in 1521 * inode cache and we will catch that case on lookup. 1522 */ 1523 err = ovl_check_layer(sb, ofs->workbasedir, "workdir"); 1524 if (err) 1525 return err; 1526 } 1527 1528 for (i = 0; i < ofs->numlower; i++) { 1529 err = ovl_check_layer(sb, ofs->lower_layers[i].mnt->mnt_root, 1530 "lowerdir"); 1531 if (err) 1532 return err; 1533 } 1534 1535 return 0; 1536 } 1537 1538 static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1539 { 1540 struct path upperpath = { }; 1541 struct dentry *root_dentry; 1542 struct ovl_entry *oe; 1543 struct ovl_fs *ofs; 1544 struct cred *cred; 1545 int err; 1546 1547 err = -ENOMEM; 1548 ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1549 if (!ofs) 1550 goto out; 1551 1552 ofs->creator_cred = cred = prepare_creds(); 1553 if (!cred) 1554 goto out_err; 1555 1556 ofs->config.index = ovl_index_def; 1557 ofs->config.nfs_export = ovl_nfs_export_def; 1558 ofs->config.xino = ovl_xino_def(); 1559 ofs->config.metacopy = ovl_metacopy_def; 1560 err = ovl_parse_opt((char *) data, &ofs->config); 1561 if (err) 1562 goto out_err; 1563 1564 err = -EINVAL; 1565 if (!ofs->config.lowerdir) { 1566 if (!silent) 1567 pr_err("overlayfs: missing 'lowerdir'\n"); 1568 goto out_err; 1569 } 1570 1571 sb->s_stack_depth = 0; 1572 sb->s_maxbytes = MAX_LFS_FILESIZE; 1573 /* Assume underlaying fs uses 32bit inodes unless proven otherwise */ 1574 if (ofs->config.xino != OVL_XINO_OFF) 1575 ofs->xino_bits = BITS_PER_LONG - 32; 1576 1577 /* alloc/destroy_inode needed for setting up traps in inode cache */ 1578 sb->s_op = &ovl_super_operations; 1579 1580 if (ofs->config.upperdir) { 1581 if (!ofs->config.workdir) { 1582 pr_err("overlayfs: missing 'workdir'\n"); 1583 goto out_err; 1584 } 1585 1586 err = ovl_get_upper(sb, ofs, &upperpath); 1587 if (err) 1588 goto out_err; 1589 1590 err = ovl_get_workdir(sb, ofs, &upperpath); 1591 if (err) 1592 goto out_err; 1593 1594 if (!ofs->workdir) 1595 sb->s_flags |= SB_RDONLY; 1596 1597 sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth; 1598 sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran; 1599 1600 } 1601 oe = ovl_get_lowerstack(sb, ofs); 1602 err = PTR_ERR(oe); 1603 if (IS_ERR(oe)) 1604 goto out_err; 1605 1606 /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 1607 if (!ofs->upper_mnt) 1608 sb->s_flags |= SB_RDONLY; 1609 1610 if (!(ovl_force_readonly(ofs)) && ofs->config.index) { 1611 err = ovl_get_indexdir(sb, ofs, oe, &upperpath); 1612 if (err) 1613 goto out_free_oe; 1614 1615 /* Force r/o mount with no index dir */ 1616 if (!ofs->indexdir) { 1617 dput(ofs->workdir); 1618 ofs->workdir = NULL; 1619 sb->s_flags |= SB_RDONLY; 1620 } 1621 1622 } 1623 1624 err = ovl_check_overlapping_layers(sb, ofs); 1625 if (err) 1626 goto out_free_oe; 1627 1628 /* Show index=off in /proc/mounts for forced r/o mount */ 1629 if (!ofs->indexdir) { 1630 ofs->config.index = false; 1631 if (ofs->upper_mnt && ofs->config.nfs_export) { 1632 pr_warn("overlayfs: NFS export requires an index dir, falling back to nfs_export=off.\n"); 1633 ofs->config.nfs_export = false; 1634 } 1635 } 1636 1637 if (ofs->config.metacopy && ofs->config.nfs_export) { 1638 pr_warn("overlayfs: NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 1639 ofs->config.nfs_export = false; 1640 } 1641 1642 if (ofs->config.nfs_export) 1643 sb->s_export_op = &ovl_export_operations; 1644 1645 /* Never override disk quota limits or use reserved space */ 1646 cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 1647 1648 sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1649 sb->s_xattr = ovl_xattr_handlers; 1650 sb->s_fs_info = ofs; 1651 sb->s_flags |= SB_POSIXACL; 1652 1653 err = -ENOMEM; 1654 root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 1655 if (!root_dentry) 1656 goto out_free_oe; 1657 1658 root_dentry->d_fsdata = oe; 1659 1660 mntput(upperpath.mnt); 1661 if (upperpath.dentry) { 1662 ovl_dentry_set_upper_alias(root_dentry); 1663 if (ovl_is_impuredir(upperpath.dentry)) 1664 ovl_set_flag(OVL_IMPURE, d_inode(root_dentry)); 1665 } 1666 1667 /* Root is always merge -> can have whiteouts */ 1668 ovl_set_flag(OVL_WHITEOUTS, d_inode(root_dentry)); 1669 ovl_dentry_set_flag(OVL_E_CONNECTED, root_dentry); 1670 ovl_set_upperdata(d_inode(root_dentry)); 1671 ovl_inode_init(d_inode(root_dentry), upperpath.dentry, 1672 ovl_dentry_lower(root_dentry), NULL); 1673 1674 sb->s_root = root_dentry; 1675 1676 return 0; 1677 1678 out_free_oe: 1679 ovl_entry_stack_free(oe); 1680 kfree(oe); 1681 out_err: 1682 path_put(&upperpath); 1683 ovl_free_fs(ofs); 1684 out: 1685 return err; 1686 } 1687 1688 static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 1689 const char *dev_name, void *raw_data) 1690 { 1691 return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 1692 } 1693 1694 static struct file_system_type ovl_fs_type = { 1695 .owner = THIS_MODULE, 1696 .name = "overlay", 1697 .mount = ovl_mount, 1698 .kill_sb = kill_anon_super, 1699 }; 1700 MODULE_ALIAS_FS("overlay"); 1701 1702 static void ovl_inode_init_once(void *foo) 1703 { 1704 struct ovl_inode *oi = foo; 1705 1706 inode_init_once(&oi->vfs_inode); 1707 } 1708 1709 static int __init ovl_init(void) 1710 { 1711 int err; 1712 1713 ovl_inode_cachep = kmem_cache_create("ovl_inode", 1714 sizeof(struct ovl_inode), 0, 1715 (SLAB_RECLAIM_ACCOUNT| 1716 SLAB_MEM_SPREAD|SLAB_ACCOUNT), 1717 ovl_inode_init_once); 1718 if (ovl_inode_cachep == NULL) 1719 return -ENOMEM; 1720 1721 err = register_filesystem(&ovl_fs_type); 1722 if (err) 1723 kmem_cache_destroy(ovl_inode_cachep); 1724 1725 return err; 1726 } 1727 1728 static void __exit ovl_exit(void) 1729 { 1730 unregister_filesystem(&ovl_fs_type); 1731 1732 /* 1733 * Make sure all delayed rcu free inodes are flushed before we 1734 * destroy cache. 1735 */ 1736 rcu_barrier(); 1737 kmem_cache_destroy(ovl_inode_cachep); 1738 1739 } 1740 1741 module_init(ovl_init); 1742 module_exit(ovl_exit); 1743