1 /* 2 * 3 * Copyright (C) 2011 Novell Inc. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 as published by 7 * the Free Software Foundation. 8 */ 9 10 #include <uapi/linux/magic.h> 11 #include <linux/fs.h> 12 #include <linux/namei.h> 13 #include <linux/xattr.h> 14 #include <linux/mount.h> 15 #include <linux/parser.h> 16 #include <linux/module.h> 17 #include <linux/statfs.h> 18 #include <linux/seq_file.h> 19 #include <linux/posix_acl_xattr.h> 20 #include "overlayfs.h" 21 22 MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 23 MODULE_DESCRIPTION("Overlay filesystem"); 24 MODULE_LICENSE("GPL"); 25 26 27 struct ovl_dir_cache; 28 29 #define OVL_MAX_STACK 500 30 31 static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR); 32 module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644); 33 MODULE_PARM_DESC(ovl_redirect_dir_def, 34 "Default to on or off for the redirect_dir feature"); 35 36 static bool ovl_redirect_always_follow = 37 IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW); 38 module_param_named(redirect_always_follow, ovl_redirect_always_follow, 39 bool, 0644); 40 MODULE_PARM_DESC(ovl_redirect_always_follow, 41 "Follow redirects even if redirect_dir feature is turned off"); 42 43 static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX); 44 module_param_named(index, ovl_index_def, bool, 0644); 45 MODULE_PARM_DESC(ovl_index_def, 46 "Default to on or off for the inodes index feature"); 47 48 static void ovl_entry_stack_free(struct ovl_entry *oe) 49 { 50 unsigned int i; 51 52 for (i = 0; i < oe->numlower; i++) 53 dput(oe->lowerstack[i].dentry); 54 } 55 56 static void ovl_dentry_release(struct dentry *dentry) 57 { 58 struct ovl_entry *oe = dentry->d_fsdata; 59 60 if (oe) { 61 ovl_entry_stack_free(oe); 62 kfree_rcu(oe, rcu); 63 } 64 } 65 66 static int ovl_check_append_only(struct inode *inode, int flag) 67 { 68 /* 69 * This test was moot in vfs may_open() because overlay inode does 70 * not have the S_APPEND flag, so re-check on real upper inode 71 */ 72 if (IS_APPEND(inode)) { 73 if ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND)) 74 return -EPERM; 75 if (flag & O_TRUNC) 76 return -EPERM; 77 } 78 79 return 0; 80 } 81 82 static struct dentry *ovl_d_real(struct dentry *dentry, 83 const struct inode *inode, 84 unsigned int open_flags, unsigned int flags) 85 { 86 struct dentry *real; 87 int err; 88 89 if (flags & D_REAL_UPPER) 90 return ovl_dentry_upper(dentry); 91 92 if (!d_is_reg(dentry)) { 93 if (!inode || inode == d_inode(dentry)) 94 return dentry; 95 goto bug; 96 } 97 98 if (open_flags) { 99 err = ovl_open_maybe_copy_up(dentry, open_flags); 100 if (err) 101 return ERR_PTR(err); 102 } 103 104 real = ovl_dentry_upper(dentry); 105 if (real && (!inode || inode == d_inode(real))) { 106 if (!inode) { 107 err = ovl_check_append_only(d_inode(real), open_flags); 108 if (err) 109 return ERR_PTR(err); 110 } 111 return real; 112 } 113 114 real = ovl_dentry_lower(dentry); 115 if (!real) 116 goto bug; 117 118 /* Handle recursion */ 119 real = d_real(real, inode, open_flags, 0); 120 121 if (!inode || inode == d_inode(real)) 122 return real; 123 bug: 124 WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry, 125 inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0); 126 return dentry; 127 } 128 129 static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 130 { 131 struct ovl_entry *oe = dentry->d_fsdata; 132 unsigned int i; 133 int ret = 1; 134 135 for (i = 0; i < oe->numlower; i++) { 136 struct dentry *d = oe->lowerstack[i].dentry; 137 138 if (d->d_flags & DCACHE_OP_REVALIDATE) { 139 ret = d->d_op->d_revalidate(d, flags); 140 if (ret < 0) 141 return ret; 142 if (!ret) { 143 if (!(flags & LOOKUP_RCU)) 144 d_invalidate(d); 145 return -ESTALE; 146 } 147 } 148 } 149 return 1; 150 } 151 152 static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 153 { 154 struct ovl_entry *oe = dentry->d_fsdata; 155 unsigned int i; 156 int ret = 1; 157 158 for (i = 0; i < oe->numlower; i++) { 159 struct dentry *d = oe->lowerstack[i].dentry; 160 161 if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) { 162 ret = d->d_op->d_weak_revalidate(d, flags); 163 if (ret <= 0) 164 break; 165 } 166 } 167 return ret; 168 } 169 170 static const struct dentry_operations ovl_dentry_operations = { 171 .d_release = ovl_dentry_release, 172 .d_real = ovl_d_real, 173 }; 174 175 static const struct dentry_operations ovl_reval_dentry_operations = { 176 .d_release = ovl_dentry_release, 177 .d_real = ovl_d_real, 178 .d_revalidate = ovl_dentry_revalidate, 179 .d_weak_revalidate = ovl_dentry_weak_revalidate, 180 }; 181 182 static struct kmem_cache *ovl_inode_cachep; 183 184 static struct inode *ovl_alloc_inode(struct super_block *sb) 185 { 186 struct ovl_inode *oi = kmem_cache_alloc(ovl_inode_cachep, GFP_KERNEL); 187 188 if (!oi) 189 return NULL; 190 191 oi->cache = NULL; 192 oi->redirect = NULL; 193 oi->version = 0; 194 oi->flags = 0; 195 oi->__upperdentry = NULL; 196 oi->lower = NULL; 197 mutex_init(&oi->lock); 198 199 return &oi->vfs_inode; 200 } 201 202 static void ovl_i_callback(struct rcu_head *head) 203 { 204 struct inode *inode = container_of(head, struct inode, i_rcu); 205 206 kmem_cache_free(ovl_inode_cachep, OVL_I(inode)); 207 } 208 209 static void ovl_destroy_inode(struct inode *inode) 210 { 211 struct ovl_inode *oi = OVL_I(inode); 212 213 dput(oi->__upperdentry); 214 kfree(oi->redirect); 215 ovl_dir_cache_free(inode); 216 mutex_destroy(&oi->lock); 217 218 call_rcu(&inode->i_rcu, ovl_i_callback); 219 } 220 221 static void ovl_free_fs(struct ovl_fs *ofs) 222 { 223 unsigned i; 224 225 dput(ofs->indexdir); 226 dput(ofs->workdir); 227 if (ofs->workdir_locked) 228 ovl_inuse_unlock(ofs->workbasedir); 229 dput(ofs->workbasedir); 230 if (ofs->upperdir_locked) 231 ovl_inuse_unlock(ofs->upper_mnt->mnt_root); 232 mntput(ofs->upper_mnt); 233 for (i = 0; i < ofs->numlower; i++) { 234 mntput(ofs->lower_layers[i].mnt); 235 free_anon_bdev(ofs->lower_layers[i].pseudo_dev); 236 } 237 kfree(ofs->lower_layers); 238 239 kfree(ofs->config.lowerdir); 240 kfree(ofs->config.upperdir); 241 kfree(ofs->config.workdir); 242 kfree(ofs->config.redirect_mode); 243 if (ofs->creator_cred) 244 put_cred(ofs->creator_cred); 245 kfree(ofs); 246 } 247 248 static void ovl_put_super(struct super_block *sb) 249 { 250 struct ovl_fs *ofs = sb->s_fs_info; 251 252 ovl_free_fs(ofs); 253 } 254 255 /* Sync real dirty inodes in upper filesystem (if it exists) */ 256 static int ovl_sync_fs(struct super_block *sb, int wait) 257 { 258 struct ovl_fs *ofs = sb->s_fs_info; 259 struct super_block *upper_sb; 260 int ret; 261 262 if (!ofs->upper_mnt) 263 return 0; 264 265 /* 266 * If this is a sync(2) call or an emergency sync, all the super blocks 267 * will be iterated, including upper_sb, so no need to do anything. 268 * 269 * If this is a syncfs(2) call, then we do need to call 270 * sync_filesystem() on upper_sb, but enough if we do it when being 271 * called with wait == 1. 272 */ 273 if (!wait) 274 return 0; 275 276 upper_sb = ofs->upper_mnt->mnt_sb; 277 278 down_read(&upper_sb->s_umount); 279 ret = sync_filesystem(upper_sb); 280 up_read(&upper_sb->s_umount); 281 282 return ret; 283 } 284 285 /** 286 * ovl_statfs 287 * @sb: The overlayfs super block 288 * @buf: The struct kstatfs to fill in with stats 289 * 290 * Get the filesystem statistics. As writes always target the upper layer 291 * filesystem pass the statfs to the upper filesystem (if it exists) 292 */ 293 static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 294 { 295 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 296 struct dentry *root_dentry = dentry->d_sb->s_root; 297 struct path path; 298 int err; 299 300 ovl_path_real(root_dentry, &path); 301 302 err = vfs_statfs(&path, buf); 303 if (!err) { 304 buf->f_namelen = ofs->namelen; 305 buf->f_type = OVERLAYFS_SUPER_MAGIC; 306 } 307 308 return err; 309 } 310 311 /* Will this overlay be forced to mount/remount ro? */ 312 static bool ovl_force_readonly(struct ovl_fs *ofs) 313 { 314 return (!ofs->upper_mnt || !ofs->workdir); 315 } 316 317 static const char *ovl_redirect_mode_def(void) 318 { 319 return ovl_redirect_dir_def ? "on" : "off"; 320 } 321 322 /** 323 * ovl_show_options 324 * 325 * Prints the mount options for a given superblock. 326 * Returns zero; does not fail. 327 */ 328 static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 329 { 330 struct super_block *sb = dentry->d_sb; 331 struct ovl_fs *ofs = sb->s_fs_info; 332 333 seq_show_option(m, "lowerdir", ofs->config.lowerdir); 334 if (ofs->config.upperdir) { 335 seq_show_option(m, "upperdir", ofs->config.upperdir); 336 seq_show_option(m, "workdir", ofs->config.workdir); 337 } 338 if (ofs->config.default_permissions) 339 seq_puts(m, ",default_permissions"); 340 if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0) 341 seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode); 342 if (ofs->config.index != ovl_index_def) 343 seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 344 return 0; 345 } 346 347 static int ovl_remount(struct super_block *sb, int *flags, char *data) 348 { 349 struct ovl_fs *ofs = sb->s_fs_info; 350 351 if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 352 return -EROFS; 353 354 return 0; 355 } 356 357 static const struct super_operations ovl_super_operations = { 358 .alloc_inode = ovl_alloc_inode, 359 .destroy_inode = ovl_destroy_inode, 360 .drop_inode = generic_delete_inode, 361 .put_super = ovl_put_super, 362 .sync_fs = ovl_sync_fs, 363 .statfs = ovl_statfs, 364 .show_options = ovl_show_options, 365 .remount_fs = ovl_remount, 366 }; 367 368 enum { 369 OPT_LOWERDIR, 370 OPT_UPPERDIR, 371 OPT_WORKDIR, 372 OPT_DEFAULT_PERMISSIONS, 373 OPT_REDIRECT_DIR, 374 OPT_INDEX_ON, 375 OPT_INDEX_OFF, 376 OPT_ERR, 377 }; 378 379 static const match_table_t ovl_tokens = { 380 {OPT_LOWERDIR, "lowerdir=%s"}, 381 {OPT_UPPERDIR, "upperdir=%s"}, 382 {OPT_WORKDIR, "workdir=%s"}, 383 {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 384 {OPT_REDIRECT_DIR, "redirect_dir=%s"}, 385 {OPT_INDEX_ON, "index=on"}, 386 {OPT_INDEX_OFF, "index=off"}, 387 {OPT_ERR, NULL} 388 }; 389 390 static char *ovl_next_opt(char **s) 391 { 392 char *sbegin = *s; 393 char *p; 394 395 if (sbegin == NULL) 396 return NULL; 397 398 for (p = sbegin; *p; p++) { 399 if (*p == '\\') { 400 p++; 401 if (!*p) 402 break; 403 } else if (*p == ',') { 404 *p = '\0'; 405 *s = p + 1; 406 return sbegin; 407 } 408 } 409 *s = NULL; 410 return sbegin; 411 } 412 413 static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode) 414 { 415 if (strcmp(mode, "on") == 0) { 416 config->redirect_dir = true; 417 /* 418 * Does not make sense to have redirect creation without 419 * redirect following. 420 */ 421 config->redirect_follow = true; 422 } else if (strcmp(mode, "follow") == 0) { 423 config->redirect_follow = true; 424 } else if (strcmp(mode, "off") == 0) { 425 if (ovl_redirect_always_follow) 426 config->redirect_follow = true; 427 } else if (strcmp(mode, "nofollow") != 0) { 428 pr_err("overlayfs: bad mount option \"redirect_dir=%s\"\n", 429 mode); 430 return -EINVAL; 431 } 432 433 return 0; 434 } 435 436 static int ovl_parse_opt(char *opt, struct ovl_config *config) 437 { 438 char *p; 439 440 config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL); 441 if (!config->redirect_mode) 442 return -ENOMEM; 443 444 while ((p = ovl_next_opt(&opt)) != NULL) { 445 int token; 446 substring_t args[MAX_OPT_ARGS]; 447 448 if (!*p) 449 continue; 450 451 token = match_token(p, ovl_tokens, args); 452 switch (token) { 453 case OPT_UPPERDIR: 454 kfree(config->upperdir); 455 config->upperdir = match_strdup(&args[0]); 456 if (!config->upperdir) 457 return -ENOMEM; 458 break; 459 460 case OPT_LOWERDIR: 461 kfree(config->lowerdir); 462 config->lowerdir = match_strdup(&args[0]); 463 if (!config->lowerdir) 464 return -ENOMEM; 465 break; 466 467 case OPT_WORKDIR: 468 kfree(config->workdir); 469 config->workdir = match_strdup(&args[0]); 470 if (!config->workdir) 471 return -ENOMEM; 472 break; 473 474 case OPT_DEFAULT_PERMISSIONS: 475 config->default_permissions = true; 476 break; 477 478 case OPT_REDIRECT_DIR: 479 kfree(config->redirect_mode); 480 config->redirect_mode = match_strdup(&args[0]); 481 if (!config->redirect_mode) 482 return -ENOMEM; 483 break; 484 485 case OPT_INDEX_ON: 486 config->index = true; 487 break; 488 489 case OPT_INDEX_OFF: 490 config->index = false; 491 break; 492 493 default: 494 pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p); 495 return -EINVAL; 496 } 497 } 498 499 /* Workdir is useless in non-upper mount */ 500 if (!config->upperdir && config->workdir) { 501 pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 502 config->workdir); 503 kfree(config->workdir); 504 config->workdir = NULL; 505 } 506 507 return ovl_parse_redirect_mode(config, config->redirect_mode); 508 } 509 510 #define OVL_WORKDIR_NAME "work" 511 #define OVL_INDEXDIR_NAME "index" 512 513 static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 514 const char *name, bool persist) 515 { 516 struct inode *dir = ofs->workbasedir->d_inode; 517 struct vfsmount *mnt = ofs->upper_mnt; 518 struct dentry *work; 519 int err; 520 bool retried = false; 521 bool locked = false; 522 523 err = mnt_want_write(mnt); 524 if (err) 525 goto out_err; 526 527 inode_lock_nested(dir, I_MUTEX_PARENT); 528 locked = true; 529 530 retry: 531 work = lookup_one_len(name, ofs->workbasedir, strlen(name)); 532 533 if (!IS_ERR(work)) { 534 struct iattr attr = { 535 .ia_valid = ATTR_MODE, 536 .ia_mode = S_IFDIR | 0, 537 }; 538 539 if (work->d_inode) { 540 err = -EEXIST; 541 if (retried) 542 goto out_dput; 543 544 if (persist) 545 goto out_unlock; 546 547 retried = true; 548 ovl_workdir_cleanup(dir, mnt, work, 0); 549 dput(work); 550 goto retry; 551 } 552 553 err = ovl_create_real(dir, work, 554 &(struct cattr){.mode = S_IFDIR | 0}, 555 NULL, true); 556 if (err) 557 goto out_dput; 558 559 /* 560 * Try to remove POSIX ACL xattrs from workdir. We are good if: 561 * 562 * a) success (there was a POSIX ACL xattr and was removed) 563 * b) -ENODATA (there was no POSIX ACL xattr) 564 * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 565 * 566 * There are various other error values that could effectively 567 * mean that the xattr doesn't exist (e.g. -ERANGE is returned 568 * if the xattr name is too long), but the set of filesystems 569 * allowed as upper are limited to "normal" ones, where checking 570 * for the above two errors is sufficient. 571 */ 572 err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 573 if (err && err != -ENODATA && err != -EOPNOTSUPP) 574 goto out_dput; 575 576 err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 577 if (err && err != -ENODATA && err != -EOPNOTSUPP) 578 goto out_dput; 579 580 /* Clear any inherited mode bits */ 581 inode_lock(work->d_inode); 582 err = notify_change(work, &attr, NULL); 583 inode_unlock(work->d_inode); 584 if (err) 585 goto out_dput; 586 } else { 587 err = PTR_ERR(work); 588 goto out_err; 589 } 590 out_unlock: 591 mnt_drop_write(mnt); 592 if (locked) 593 inode_unlock(dir); 594 595 return work; 596 597 out_dput: 598 dput(work); 599 out_err: 600 pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n", 601 ofs->config.workdir, name, -err); 602 work = NULL; 603 goto out_unlock; 604 } 605 606 static void ovl_unescape(char *s) 607 { 608 char *d = s; 609 610 for (;; s++, d++) { 611 if (*s == '\\') 612 s++; 613 *d = *s; 614 if (!*s) 615 break; 616 } 617 } 618 619 static int ovl_mount_dir_noesc(const char *name, struct path *path) 620 { 621 int err = -EINVAL; 622 623 if (!*name) { 624 pr_err("overlayfs: empty lowerdir\n"); 625 goto out; 626 } 627 err = kern_path(name, LOOKUP_FOLLOW, path); 628 if (err) { 629 pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); 630 goto out; 631 } 632 err = -EINVAL; 633 if (ovl_dentry_weird(path->dentry)) { 634 pr_err("overlayfs: filesystem on '%s' not supported\n", name); 635 goto out_put; 636 } 637 if (!d_is_dir(path->dentry)) { 638 pr_err("overlayfs: '%s' not a directory\n", name); 639 goto out_put; 640 } 641 return 0; 642 643 out_put: 644 path_put_init(path); 645 out: 646 return err; 647 } 648 649 static int ovl_mount_dir(const char *name, struct path *path) 650 { 651 int err = -ENOMEM; 652 char *tmp = kstrdup(name, GFP_KERNEL); 653 654 if (tmp) { 655 ovl_unescape(tmp); 656 err = ovl_mount_dir_noesc(tmp, path); 657 658 if (!err) 659 if (ovl_dentry_remote(path->dentry)) { 660 pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n", 661 tmp); 662 path_put_init(path); 663 err = -EINVAL; 664 } 665 kfree(tmp); 666 } 667 return err; 668 } 669 670 static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 671 const char *name) 672 { 673 struct kstatfs statfs; 674 int err = vfs_statfs(path, &statfs); 675 676 if (err) 677 pr_err("overlayfs: statfs failed on '%s'\n", name); 678 else 679 ofs->namelen = max(ofs->namelen, statfs.f_namelen); 680 681 return err; 682 } 683 684 static int ovl_lower_dir(const char *name, struct path *path, 685 struct ovl_fs *ofs, int *stack_depth, bool *remote) 686 { 687 int err; 688 689 err = ovl_mount_dir_noesc(name, path); 690 if (err) 691 goto out; 692 693 err = ovl_check_namelen(path, ofs, name); 694 if (err) 695 goto out_put; 696 697 *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 698 699 if (ovl_dentry_remote(path->dentry)) 700 *remote = true; 701 702 /* 703 * The inodes index feature needs to encode and decode file 704 * handles, so it requires that all layers support them. 705 */ 706 if (ofs->config.index && !ovl_can_decode_fh(path->dentry->d_sb)) { 707 ofs->config.index = false; 708 pr_warn("overlayfs: fs on '%s' does not support file handles, falling back to index=off.\n", name); 709 } 710 711 return 0; 712 713 out_put: 714 path_put_init(path); 715 out: 716 return err; 717 } 718 719 /* Workdir should not be subdir of upperdir and vice versa */ 720 static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 721 { 722 bool ok = false; 723 724 if (workdir != upperdir) { 725 ok = (lock_rename(workdir, upperdir) == NULL); 726 unlock_rename(workdir, upperdir); 727 } 728 return ok; 729 } 730 731 static unsigned int ovl_split_lowerdirs(char *str) 732 { 733 unsigned int ctr = 1; 734 char *s, *d; 735 736 for (s = d = str;; s++, d++) { 737 if (*s == '\\') { 738 s++; 739 } else if (*s == ':') { 740 *d = '\0'; 741 ctr++; 742 continue; 743 } 744 *d = *s; 745 if (!*s) 746 break; 747 } 748 return ctr; 749 } 750 751 static int __maybe_unused 752 ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 753 struct dentry *dentry, struct inode *inode, 754 const char *name, void *buffer, size_t size) 755 { 756 return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 757 } 758 759 static int __maybe_unused 760 ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 761 struct dentry *dentry, struct inode *inode, 762 const char *name, const void *value, 763 size_t size, int flags) 764 { 765 struct dentry *workdir = ovl_workdir(dentry); 766 struct inode *realinode = ovl_inode_real(inode); 767 struct posix_acl *acl = NULL; 768 int err; 769 770 /* Check that everything is OK before copy-up */ 771 if (value) { 772 acl = posix_acl_from_xattr(&init_user_ns, value, size); 773 if (IS_ERR(acl)) 774 return PTR_ERR(acl); 775 } 776 err = -EOPNOTSUPP; 777 if (!IS_POSIXACL(d_inode(workdir))) 778 goto out_acl_release; 779 if (!realinode->i_op->set_acl) 780 goto out_acl_release; 781 if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 782 err = acl ? -EACCES : 0; 783 goto out_acl_release; 784 } 785 err = -EPERM; 786 if (!inode_owner_or_capable(inode)) 787 goto out_acl_release; 788 789 posix_acl_release(acl); 790 791 /* 792 * Check if sgid bit needs to be cleared (actual setacl operation will 793 * be done with mounter's capabilities and so that won't do it for us). 794 */ 795 if (unlikely(inode->i_mode & S_ISGID) && 796 handler->flags == ACL_TYPE_ACCESS && 797 !in_group_p(inode->i_gid) && 798 !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 799 struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 800 801 err = ovl_setattr(dentry, &iattr); 802 if (err) 803 return err; 804 } 805 806 err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 807 if (!err) 808 ovl_copyattr(ovl_inode_real(inode), inode); 809 810 return err; 811 812 out_acl_release: 813 posix_acl_release(acl); 814 return err; 815 } 816 817 static int ovl_own_xattr_get(const struct xattr_handler *handler, 818 struct dentry *dentry, struct inode *inode, 819 const char *name, void *buffer, size_t size) 820 { 821 return -EOPNOTSUPP; 822 } 823 824 static int ovl_own_xattr_set(const struct xattr_handler *handler, 825 struct dentry *dentry, struct inode *inode, 826 const char *name, const void *value, 827 size_t size, int flags) 828 { 829 return -EOPNOTSUPP; 830 } 831 832 static int ovl_other_xattr_get(const struct xattr_handler *handler, 833 struct dentry *dentry, struct inode *inode, 834 const char *name, void *buffer, size_t size) 835 { 836 return ovl_xattr_get(dentry, inode, name, buffer, size); 837 } 838 839 static int ovl_other_xattr_set(const struct xattr_handler *handler, 840 struct dentry *dentry, struct inode *inode, 841 const char *name, const void *value, 842 size_t size, int flags) 843 { 844 return ovl_xattr_set(dentry, inode, name, value, size, flags); 845 } 846 847 static const struct xattr_handler __maybe_unused 848 ovl_posix_acl_access_xattr_handler = { 849 .name = XATTR_NAME_POSIX_ACL_ACCESS, 850 .flags = ACL_TYPE_ACCESS, 851 .get = ovl_posix_acl_xattr_get, 852 .set = ovl_posix_acl_xattr_set, 853 }; 854 855 static const struct xattr_handler __maybe_unused 856 ovl_posix_acl_default_xattr_handler = { 857 .name = XATTR_NAME_POSIX_ACL_DEFAULT, 858 .flags = ACL_TYPE_DEFAULT, 859 .get = ovl_posix_acl_xattr_get, 860 .set = ovl_posix_acl_xattr_set, 861 }; 862 863 static const struct xattr_handler ovl_own_xattr_handler = { 864 .prefix = OVL_XATTR_PREFIX, 865 .get = ovl_own_xattr_get, 866 .set = ovl_own_xattr_set, 867 }; 868 869 static const struct xattr_handler ovl_other_xattr_handler = { 870 .prefix = "", /* catch all */ 871 .get = ovl_other_xattr_get, 872 .set = ovl_other_xattr_set, 873 }; 874 875 static const struct xattr_handler *ovl_xattr_handlers[] = { 876 #ifdef CONFIG_FS_POSIX_ACL 877 &ovl_posix_acl_access_xattr_handler, 878 &ovl_posix_acl_default_xattr_handler, 879 #endif 880 &ovl_own_xattr_handler, 881 &ovl_other_xattr_handler, 882 NULL 883 }; 884 885 static int ovl_get_upper(struct ovl_fs *ofs, struct path *upperpath) 886 { 887 struct vfsmount *upper_mnt; 888 int err; 889 890 err = ovl_mount_dir(ofs->config.upperdir, upperpath); 891 if (err) 892 goto out; 893 894 /* Upper fs should not be r/o */ 895 if (sb_rdonly(upperpath->mnt->mnt_sb)) { 896 pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n"); 897 err = -EINVAL; 898 goto out; 899 } 900 901 err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 902 if (err) 903 goto out; 904 905 err = -EBUSY; 906 if (ovl_inuse_trylock(upperpath->dentry)) { 907 ofs->upperdir_locked = true; 908 } else if (ofs->config.index) { 909 pr_err("overlayfs: upperdir is in-use by another mount, mount with '-o index=off' to override exclusive upperdir protection.\n"); 910 goto out; 911 } else { 912 pr_warn("overlayfs: upperdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 913 } 914 915 upper_mnt = clone_private_mount(upperpath); 916 err = PTR_ERR(upper_mnt); 917 if (IS_ERR(upper_mnt)) { 918 pr_err("overlayfs: failed to clone upperpath\n"); 919 goto out; 920 } 921 922 /* Don't inherit atime flags */ 923 upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 924 ofs->upper_mnt = upper_mnt; 925 err = 0; 926 out: 927 return err; 928 } 929 930 static int ovl_make_workdir(struct ovl_fs *ofs, struct path *workpath) 931 { 932 struct dentry *temp; 933 int err; 934 935 ofs->workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 936 if (!ofs->workdir) 937 return 0; 938 939 /* 940 * Upper should support d_type, else whiteouts are visible. Given 941 * workdir and upper are on same fs, we can do iterate_dir() on 942 * workdir. This check requires successful creation of workdir in 943 * previous step. 944 */ 945 err = ovl_check_d_type_supported(workpath); 946 if (err < 0) 947 return err; 948 949 /* 950 * We allowed this configuration and don't want to break users over 951 * kernel upgrade. So warn instead of erroring out. 952 */ 953 if (!err) 954 pr_warn("overlayfs: upper fs needs to support d_type.\n"); 955 956 /* Check if upper/work fs supports O_TMPFILE */ 957 temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0); 958 ofs->tmpfile = !IS_ERR(temp); 959 if (ofs->tmpfile) 960 dput(temp); 961 else 962 pr_warn("overlayfs: upper fs does not support tmpfile.\n"); 963 964 /* 965 * Check if upper/work fs supports trusted.overlay.* xattr 966 */ 967 err = ovl_do_setxattr(ofs->workdir, OVL_XATTR_OPAQUE, "0", 1, 0); 968 if (err) { 969 ofs->noxattr = true; 970 pr_warn("overlayfs: upper fs does not support xattr.\n"); 971 } else { 972 vfs_removexattr(ofs->workdir, OVL_XATTR_OPAQUE); 973 } 974 975 /* Check if upper/work fs supports file handles */ 976 if (ofs->config.index && 977 !ovl_can_decode_fh(ofs->workdir->d_sb)) { 978 ofs->config.index = false; 979 pr_warn("overlayfs: upper fs does not support file handles, falling back to index=off.\n"); 980 } 981 982 return 0; 983 } 984 985 static int ovl_get_workdir(struct ovl_fs *ofs, struct path *upperpath) 986 { 987 int err; 988 struct path workpath = { }; 989 990 err = ovl_mount_dir(ofs->config.workdir, &workpath); 991 if (err) 992 goto out; 993 994 err = -EINVAL; 995 if (upperpath->mnt != workpath.mnt) { 996 pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 997 goto out; 998 } 999 if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 1000 pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 1001 goto out; 1002 } 1003 1004 err = -EBUSY; 1005 if (ovl_inuse_trylock(workpath.dentry)) { 1006 ofs->workdir_locked = true; 1007 } else if (ofs->config.index) { 1008 pr_err("overlayfs: workdir is in-use by another mount, mount with '-o index=off' to override exclusive workdir protection.\n"); 1009 goto out; 1010 } else { 1011 pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 1012 } 1013 1014 ofs->workbasedir = dget(workpath.dentry); 1015 err = ovl_make_workdir(ofs, &workpath); 1016 if (err) 1017 goto out; 1018 1019 err = 0; 1020 out: 1021 path_put(&workpath); 1022 1023 return err; 1024 } 1025 1026 static int ovl_get_indexdir(struct ovl_fs *ofs, struct ovl_entry *oe, 1027 struct path *upperpath) 1028 { 1029 int err; 1030 1031 /* Verify lower root is upper root origin */ 1032 err = ovl_verify_origin(upperpath->dentry, oe->lowerstack[0].dentry, 1033 false, true); 1034 if (err) { 1035 pr_err("overlayfs: failed to verify upper root origin\n"); 1036 goto out; 1037 } 1038 1039 ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1040 if (ofs->indexdir) { 1041 /* Verify upper root is index dir origin */ 1042 err = ovl_verify_origin(ofs->indexdir, upperpath->dentry, 1043 true, true); 1044 if (err) 1045 pr_err("overlayfs: failed to verify index dir origin\n"); 1046 1047 /* Cleanup bad/stale/orphan index entries */ 1048 if (!err) 1049 err = ovl_indexdir_cleanup(ofs->indexdir, 1050 ofs->upper_mnt, 1051 oe->lowerstack, 1052 oe->numlower); 1053 } 1054 if (err || !ofs->indexdir) 1055 pr_warn("overlayfs: try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1056 1057 out: 1058 return err; 1059 } 1060 1061 static int ovl_get_lower_layers(struct ovl_fs *ofs, struct path *stack, 1062 unsigned int numlower) 1063 { 1064 int err; 1065 unsigned int i; 1066 1067 err = -ENOMEM; 1068 ofs->lower_layers = kcalloc(numlower, sizeof(struct ovl_layer), 1069 GFP_KERNEL); 1070 if (ofs->lower_layers == NULL) 1071 goto out; 1072 for (i = 0; i < numlower; i++) { 1073 struct vfsmount *mnt; 1074 dev_t dev; 1075 1076 err = get_anon_bdev(&dev); 1077 if (err) { 1078 pr_err("overlayfs: failed to get anonymous bdev for lowerpath\n"); 1079 goto out; 1080 } 1081 1082 mnt = clone_private_mount(&stack[i]); 1083 err = PTR_ERR(mnt); 1084 if (IS_ERR(mnt)) { 1085 pr_err("overlayfs: failed to clone lowerpath\n"); 1086 free_anon_bdev(dev); 1087 goto out; 1088 } 1089 /* 1090 * Make lower layers R/O. That way fchmod/fchown on lower file 1091 * will fail instead of modifying lower fs. 1092 */ 1093 mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1094 1095 ofs->lower_layers[ofs->numlower].mnt = mnt; 1096 ofs->lower_layers[ofs->numlower].pseudo_dev = dev; 1097 ofs->numlower++; 1098 1099 /* Check if all lower layers are on same sb */ 1100 if (i == 0) 1101 ofs->same_sb = mnt->mnt_sb; 1102 else if (ofs->same_sb != mnt->mnt_sb) 1103 ofs->same_sb = NULL; 1104 } 1105 err = 0; 1106 out: 1107 return err; 1108 } 1109 1110 static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1111 struct ovl_fs *ofs) 1112 { 1113 int err; 1114 char *lowertmp, *lower; 1115 struct path *stack = NULL; 1116 unsigned int stacklen, numlower = 0, i; 1117 bool remote = false; 1118 struct ovl_entry *oe; 1119 1120 err = -ENOMEM; 1121 lowertmp = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 1122 if (!lowertmp) 1123 goto out_err; 1124 1125 err = -EINVAL; 1126 stacklen = ovl_split_lowerdirs(lowertmp); 1127 if (stacklen > OVL_MAX_STACK) { 1128 pr_err("overlayfs: too many lower directories, limit is %d\n", 1129 OVL_MAX_STACK); 1130 goto out_err; 1131 } else if (!ofs->config.upperdir && stacklen == 1) { 1132 pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n"); 1133 goto out_err; 1134 } 1135 1136 err = -ENOMEM; 1137 stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL); 1138 if (!stack) 1139 goto out_err; 1140 1141 err = -EINVAL; 1142 lower = lowertmp; 1143 for (numlower = 0; numlower < stacklen; numlower++) { 1144 err = ovl_lower_dir(lower, &stack[numlower], ofs, 1145 &sb->s_stack_depth, &remote); 1146 if (err) 1147 goto out_err; 1148 1149 lower = strchr(lower, '\0') + 1; 1150 } 1151 1152 err = -EINVAL; 1153 sb->s_stack_depth++; 1154 if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 1155 pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 1156 goto out_err; 1157 } 1158 1159 err = ovl_get_lower_layers(ofs, stack, numlower); 1160 if (err) 1161 goto out_err; 1162 1163 err = -ENOMEM; 1164 oe = ovl_alloc_entry(numlower); 1165 if (!oe) 1166 goto out_err; 1167 1168 for (i = 0; i < numlower; i++) { 1169 oe->lowerstack[i].dentry = dget(stack[i].dentry); 1170 oe->lowerstack[i].layer = &ofs->lower_layers[i]; 1171 } 1172 1173 if (remote) 1174 sb->s_d_op = &ovl_reval_dentry_operations; 1175 else 1176 sb->s_d_op = &ovl_dentry_operations; 1177 1178 out: 1179 for (i = 0; i < numlower; i++) 1180 path_put(&stack[i]); 1181 kfree(stack); 1182 kfree(lowertmp); 1183 1184 return oe; 1185 1186 out_err: 1187 oe = ERR_PTR(err); 1188 goto out; 1189 } 1190 1191 static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1192 { 1193 struct path upperpath = { }; 1194 struct dentry *root_dentry; 1195 struct ovl_entry *oe; 1196 struct ovl_fs *ofs; 1197 struct cred *cred; 1198 int err; 1199 1200 err = -ENOMEM; 1201 ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1202 if (!ofs) 1203 goto out; 1204 1205 ofs->creator_cred = cred = prepare_creds(); 1206 if (!cred) 1207 goto out_err; 1208 1209 ofs->config.index = ovl_index_def; 1210 err = ovl_parse_opt((char *) data, &ofs->config); 1211 if (err) 1212 goto out_err; 1213 1214 err = -EINVAL; 1215 if (!ofs->config.lowerdir) { 1216 if (!silent) 1217 pr_err("overlayfs: missing 'lowerdir'\n"); 1218 goto out_err; 1219 } 1220 1221 sb->s_stack_depth = 0; 1222 sb->s_maxbytes = MAX_LFS_FILESIZE; 1223 if (ofs->config.upperdir) { 1224 if (!ofs->config.workdir) { 1225 pr_err("overlayfs: missing 'workdir'\n"); 1226 goto out_err; 1227 } 1228 1229 err = ovl_get_upper(ofs, &upperpath); 1230 if (err) 1231 goto out_err; 1232 1233 err = ovl_get_workdir(ofs, &upperpath); 1234 if (err) 1235 goto out_err; 1236 1237 if (!ofs->workdir) 1238 sb->s_flags |= SB_RDONLY; 1239 1240 sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth; 1241 sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran; 1242 1243 } 1244 oe = ovl_get_lowerstack(sb, ofs); 1245 err = PTR_ERR(oe); 1246 if (IS_ERR(oe)) 1247 goto out_err; 1248 1249 /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 1250 if (!ofs->upper_mnt) 1251 sb->s_flags |= SB_RDONLY; 1252 else if (ofs->upper_mnt->mnt_sb != ofs->same_sb) 1253 ofs->same_sb = NULL; 1254 1255 if (!(ovl_force_readonly(ofs)) && ofs->config.index) { 1256 err = ovl_get_indexdir(ofs, oe, &upperpath); 1257 if (err) 1258 goto out_free_oe; 1259 1260 if (!ofs->indexdir) 1261 sb->s_flags |= SB_RDONLY; 1262 } 1263 1264 /* Show index=off/on in /proc/mounts for any of the reasons above */ 1265 if (!ofs->indexdir) 1266 ofs->config.index = false; 1267 1268 /* Never override disk quota limits or use reserved space */ 1269 cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 1270 1271 sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1272 sb->s_op = &ovl_super_operations; 1273 sb->s_xattr = ovl_xattr_handlers; 1274 sb->s_fs_info = ofs; 1275 sb->s_flags |= SB_POSIXACL | SB_NOREMOTELOCK; 1276 1277 err = -ENOMEM; 1278 root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 1279 if (!root_dentry) 1280 goto out_free_oe; 1281 1282 mntput(upperpath.mnt); 1283 if (upperpath.dentry) { 1284 oe->has_upper = true; 1285 if (ovl_is_impuredir(upperpath.dentry)) 1286 ovl_set_flag(OVL_IMPURE, d_inode(root_dentry)); 1287 } 1288 1289 root_dentry->d_fsdata = oe; 1290 1291 /* Root is always merge -> can have whiteouts */ 1292 ovl_set_flag(OVL_WHITEOUTS, d_inode(root_dentry)); 1293 ovl_inode_init(d_inode(root_dentry), upperpath.dentry, 1294 ovl_dentry_lower(root_dentry)); 1295 1296 sb->s_root = root_dentry; 1297 1298 return 0; 1299 1300 out_free_oe: 1301 ovl_entry_stack_free(oe); 1302 kfree(oe); 1303 out_err: 1304 path_put(&upperpath); 1305 ovl_free_fs(ofs); 1306 out: 1307 return err; 1308 } 1309 1310 static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 1311 const char *dev_name, void *raw_data) 1312 { 1313 return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 1314 } 1315 1316 static struct file_system_type ovl_fs_type = { 1317 .owner = THIS_MODULE, 1318 .name = "overlay", 1319 .mount = ovl_mount, 1320 .kill_sb = kill_anon_super, 1321 }; 1322 MODULE_ALIAS_FS("overlay"); 1323 1324 static void ovl_inode_init_once(void *foo) 1325 { 1326 struct ovl_inode *oi = foo; 1327 1328 inode_init_once(&oi->vfs_inode); 1329 } 1330 1331 static int __init ovl_init(void) 1332 { 1333 int err; 1334 1335 ovl_inode_cachep = kmem_cache_create("ovl_inode", 1336 sizeof(struct ovl_inode), 0, 1337 (SLAB_RECLAIM_ACCOUNT| 1338 SLAB_MEM_SPREAD|SLAB_ACCOUNT), 1339 ovl_inode_init_once); 1340 if (ovl_inode_cachep == NULL) 1341 return -ENOMEM; 1342 1343 err = register_filesystem(&ovl_fs_type); 1344 if (err) 1345 kmem_cache_destroy(ovl_inode_cachep); 1346 1347 return err; 1348 } 1349 1350 static void __exit ovl_exit(void) 1351 { 1352 unregister_filesystem(&ovl_fs_type); 1353 1354 /* 1355 * Make sure all delayed rcu free inodes are flushed before we 1356 * destroy cache. 1357 */ 1358 rcu_barrier(); 1359 kmem_cache_destroy(ovl_inode_cachep); 1360 1361 } 1362 1363 module_init(ovl_init); 1364 module_exit(ovl_exit); 1365