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 "overlayfs.h" 20 21 MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 22 MODULE_DESCRIPTION("Overlay filesystem"); 23 MODULE_LICENSE("GPL"); 24 25 26 struct ovl_dir_cache; 27 28 #define OVL_MAX_STACK 500 29 30 static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR); 31 module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644); 32 MODULE_PARM_DESC(redirect_dir, 33 "Default to on or off for the redirect_dir feature"); 34 35 static bool ovl_redirect_always_follow = 36 IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW); 37 module_param_named(redirect_always_follow, ovl_redirect_always_follow, 38 bool, 0644); 39 MODULE_PARM_DESC(redirect_always_follow, 40 "Follow redirects even if redirect_dir feature is turned off"); 41 42 static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX); 43 module_param_named(index, ovl_index_def, bool, 0644); 44 MODULE_PARM_DESC(index, 45 "Default to on or off for the inodes index feature"); 46 47 static bool ovl_nfs_export_def = IS_ENABLED(CONFIG_OVERLAY_FS_NFS_EXPORT); 48 module_param_named(nfs_export, ovl_nfs_export_def, bool, 0644); 49 MODULE_PARM_DESC(nfs_export, 50 "Default to on or off for the NFS export feature"); 51 52 static bool ovl_xino_auto_def = IS_ENABLED(CONFIG_OVERLAY_FS_XINO_AUTO); 53 module_param_named(xino_auto, ovl_xino_auto_def, bool, 0644); 54 MODULE_PARM_DESC(xino_auto, 55 "Auto enable xino feature"); 56 57 static bool ovl_metacopy_def = IS_ENABLED(CONFIG_OVERLAY_FS_METACOPY); 58 module_param_named(metacopy, ovl_metacopy_def, bool, 0644); 59 MODULE_PARM_DESC(metacopy, 60 "Default to on or off for the metadata only copy up feature"); 61 62 static struct dentry *ovl_d_real(struct dentry *dentry, 63 const struct inode *inode) 64 { 65 struct dentry *real = NULL, *lower; 66 67 /* It's an overlay file */ 68 if (inode && d_inode(dentry) == inode) 69 return dentry; 70 71 if (!d_is_reg(dentry)) { 72 if (!inode || inode == d_inode(dentry)) 73 return dentry; 74 goto bug; 75 } 76 77 real = ovl_dentry_upper(dentry); 78 if (real && (inode == d_inode(real))) 79 return real; 80 81 if (real && !inode && ovl_has_upperdata(d_inode(dentry))) 82 return real; 83 84 /* 85 * Best effort lazy lookup of lowerdata for !inode case to return 86 * the real lowerdata dentry. The only current caller of d_real() with 87 * NULL inode is d_real_inode() from trace_uprobe and this caller is 88 * likely going to be followed reading from the file, before placing 89 * uprobes on offset within the file, so lowerdata should be available 90 * when setting the uprobe. 91 */ 92 ovl_maybe_lookup_lowerdata(dentry); 93 lower = ovl_dentry_lowerdata(dentry); 94 if (!lower) 95 goto bug; 96 real = lower; 97 98 /* Handle recursion */ 99 real = d_real(real, inode); 100 101 if (!inode || inode == d_inode(real)) 102 return real; 103 bug: 104 WARN(1, "%s(%pd4, %s:%lu): real dentry (%p/%lu) not found\n", 105 __func__, dentry, inode ? inode->i_sb->s_id : "NULL", 106 inode ? inode->i_ino : 0, real, 107 real && d_inode(real) ? d_inode(real)->i_ino : 0); 108 return dentry; 109 } 110 111 static int ovl_revalidate_real(struct dentry *d, unsigned int flags, bool weak) 112 { 113 int ret = 1; 114 115 if (!d) 116 return 1; 117 118 if (weak) { 119 if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) 120 ret = d->d_op->d_weak_revalidate(d, flags); 121 } else if (d->d_flags & DCACHE_OP_REVALIDATE) { 122 ret = d->d_op->d_revalidate(d, flags); 123 if (!ret) { 124 if (!(flags & LOOKUP_RCU)) 125 d_invalidate(d); 126 ret = -ESTALE; 127 } 128 } 129 return ret; 130 } 131 132 static int ovl_dentry_revalidate_common(struct dentry *dentry, 133 unsigned int flags, bool weak) 134 { 135 struct ovl_entry *oe = OVL_E(dentry); 136 struct ovl_path *lowerstack = ovl_lowerstack(oe); 137 struct inode *inode = d_inode_rcu(dentry); 138 struct dentry *upper; 139 unsigned int i; 140 int ret = 1; 141 142 /* Careful in RCU mode */ 143 if (!inode) 144 return -ECHILD; 145 146 upper = ovl_i_dentry_upper(inode); 147 if (upper) 148 ret = ovl_revalidate_real(upper, flags, weak); 149 150 for (i = 0; ret > 0 && i < ovl_numlower(oe); i++) 151 ret = ovl_revalidate_real(lowerstack[i].dentry, flags, weak); 152 153 return ret; 154 } 155 156 static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 157 { 158 return ovl_dentry_revalidate_common(dentry, flags, false); 159 } 160 161 static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 162 { 163 return ovl_dentry_revalidate_common(dentry, flags, true); 164 } 165 166 static const struct dentry_operations ovl_dentry_operations = { 167 .d_real = ovl_d_real, 168 .d_revalidate = ovl_dentry_revalidate, 169 .d_weak_revalidate = ovl_dentry_weak_revalidate, 170 }; 171 172 static struct kmem_cache *ovl_inode_cachep; 173 174 static struct inode *ovl_alloc_inode(struct super_block *sb) 175 { 176 struct ovl_inode *oi = alloc_inode_sb(sb, ovl_inode_cachep, GFP_KERNEL); 177 178 if (!oi) 179 return NULL; 180 181 oi->cache = NULL; 182 oi->redirect = NULL; 183 oi->version = 0; 184 oi->flags = 0; 185 oi->__upperdentry = NULL; 186 oi->lowerdata_redirect = NULL; 187 oi->oe = NULL; 188 mutex_init(&oi->lock); 189 190 return &oi->vfs_inode; 191 } 192 193 static void ovl_free_inode(struct inode *inode) 194 { 195 struct ovl_inode *oi = OVL_I(inode); 196 197 kfree(oi->redirect); 198 mutex_destroy(&oi->lock); 199 kmem_cache_free(ovl_inode_cachep, oi); 200 } 201 202 static void ovl_destroy_inode(struct inode *inode) 203 { 204 struct ovl_inode *oi = OVL_I(inode); 205 206 dput(oi->__upperdentry); 207 ovl_free_entry(oi->oe); 208 if (S_ISDIR(inode->i_mode)) 209 ovl_dir_cache_free(inode); 210 else 211 kfree(oi->lowerdata_redirect); 212 } 213 214 static void ovl_free_fs(struct ovl_fs *ofs) 215 { 216 struct vfsmount **mounts; 217 unsigned i; 218 219 iput(ofs->workbasedir_trap); 220 iput(ofs->indexdir_trap); 221 iput(ofs->workdir_trap); 222 dput(ofs->whiteout); 223 dput(ofs->indexdir); 224 dput(ofs->workdir); 225 if (ofs->workdir_locked) 226 ovl_inuse_unlock(ofs->workbasedir); 227 dput(ofs->workbasedir); 228 if (ofs->upperdir_locked) 229 ovl_inuse_unlock(ovl_upper_mnt(ofs)->mnt_root); 230 231 /* Hack! Reuse ofs->layers as a vfsmount array before freeing it */ 232 mounts = (struct vfsmount **) ofs->layers; 233 for (i = 0; i < ofs->numlayer; i++) { 234 iput(ofs->layers[i].trap); 235 mounts[i] = ofs->layers[i].mnt; 236 } 237 kern_unmount_array(mounts, ofs->numlayer); 238 kfree(ofs->layers); 239 for (i = 0; i < ofs->numfs; i++) 240 free_anon_bdev(ofs->fs[i].pseudo_dev); 241 kfree(ofs->fs); 242 243 kfree(ofs->config.lowerdir); 244 kfree(ofs->config.upperdir); 245 kfree(ofs->config.workdir); 246 kfree(ofs->config.redirect_mode); 247 if (ofs->creator_cred) 248 put_cred(ofs->creator_cred); 249 kfree(ofs); 250 } 251 252 static void ovl_put_super(struct super_block *sb) 253 { 254 struct ovl_fs *ofs = sb->s_fs_info; 255 256 ovl_free_fs(ofs); 257 } 258 259 /* Sync real dirty inodes in upper filesystem (if it exists) */ 260 static int ovl_sync_fs(struct super_block *sb, int wait) 261 { 262 struct ovl_fs *ofs = sb->s_fs_info; 263 struct super_block *upper_sb; 264 int ret; 265 266 ret = ovl_sync_status(ofs); 267 /* 268 * We have to always set the err, because the return value isn't 269 * checked in syncfs, and instead indirectly return an error via 270 * the sb's writeback errseq, which VFS inspects after this call. 271 */ 272 if (ret < 0) { 273 errseq_set(&sb->s_wb_err, -EIO); 274 return -EIO; 275 } 276 277 if (!ret) 278 return ret; 279 280 /* 281 * Not called for sync(2) call or an emergency sync (SB_I_SKIP_SYNC). 282 * All the super blocks will be iterated, including upper_sb. 283 * 284 * If this is a syncfs(2) call, then we do need to call 285 * sync_filesystem() on upper_sb, but enough if we do it when being 286 * called with wait == 1. 287 */ 288 if (!wait) 289 return 0; 290 291 upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 292 293 down_read(&upper_sb->s_umount); 294 ret = sync_filesystem(upper_sb); 295 up_read(&upper_sb->s_umount); 296 297 return ret; 298 } 299 300 /** 301 * ovl_statfs 302 * @dentry: The dentry to query 303 * @buf: The struct kstatfs to fill in with stats 304 * 305 * Get the filesystem statistics. As writes always target the upper layer 306 * filesystem pass the statfs to the upper filesystem (if it exists) 307 */ 308 static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 309 { 310 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 311 struct dentry *root_dentry = dentry->d_sb->s_root; 312 struct path path; 313 int err; 314 315 ovl_path_real(root_dentry, &path); 316 317 err = vfs_statfs(&path, buf); 318 if (!err) { 319 buf->f_namelen = ofs->namelen; 320 buf->f_type = OVERLAYFS_SUPER_MAGIC; 321 } 322 323 return err; 324 } 325 326 /* Will this overlay be forced to mount/remount ro? */ 327 static bool ovl_force_readonly(struct ovl_fs *ofs) 328 { 329 return (!ovl_upper_mnt(ofs) || !ofs->workdir); 330 } 331 332 static const char *ovl_redirect_mode_def(void) 333 { 334 return ovl_redirect_dir_def ? "on" : "off"; 335 } 336 337 static const char * const ovl_xino_str[] = { 338 "off", 339 "auto", 340 "on", 341 }; 342 343 static inline int ovl_xino_def(void) 344 { 345 return ovl_xino_auto_def ? OVL_XINO_AUTO : OVL_XINO_OFF; 346 } 347 348 /** 349 * ovl_show_options 350 * @m: the seq_file handle 351 * @dentry: The dentry to query 352 * 353 * Prints the mount options for a given superblock. 354 * Returns zero; does not fail. 355 */ 356 static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 357 { 358 struct super_block *sb = dentry->d_sb; 359 struct ovl_fs *ofs = sb->s_fs_info; 360 361 seq_show_option(m, "lowerdir", ofs->config.lowerdir); 362 if (ofs->config.upperdir) { 363 seq_show_option(m, "upperdir", ofs->config.upperdir); 364 seq_show_option(m, "workdir", ofs->config.workdir); 365 } 366 if (ofs->config.default_permissions) 367 seq_puts(m, ",default_permissions"); 368 if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0) 369 seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode); 370 if (ofs->config.index != ovl_index_def) 371 seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 372 if (!ofs->config.uuid) 373 seq_puts(m, ",uuid=off"); 374 if (ofs->config.nfs_export != ovl_nfs_export_def) 375 seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ? 376 "on" : "off"); 377 if (ofs->config.xino != ovl_xino_def() && !ovl_same_fs(sb)) 378 seq_printf(m, ",xino=%s", ovl_xino_str[ofs->config.xino]); 379 if (ofs->config.metacopy != ovl_metacopy_def) 380 seq_printf(m, ",metacopy=%s", 381 ofs->config.metacopy ? "on" : "off"); 382 if (ofs->config.ovl_volatile) 383 seq_puts(m, ",volatile"); 384 if (ofs->config.userxattr) 385 seq_puts(m, ",userxattr"); 386 return 0; 387 } 388 389 static int ovl_remount(struct super_block *sb, int *flags, char *data) 390 { 391 struct ovl_fs *ofs = sb->s_fs_info; 392 struct super_block *upper_sb; 393 int ret = 0; 394 395 if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 396 return -EROFS; 397 398 if (*flags & SB_RDONLY && !sb_rdonly(sb)) { 399 upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 400 if (ovl_should_sync(ofs)) { 401 down_read(&upper_sb->s_umount); 402 ret = sync_filesystem(upper_sb); 403 up_read(&upper_sb->s_umount); 404 } 405 } 406 407 return ret; 408 } 409 410 static const struct super_operations ovl_super_operations = { 411 .alloc_inode = ovl_alloc_inode, 412 .free_inode = ovl_free_inode, 413 .destroy_inode = ovl_destroy_inode, 414 .drop_inode = generic_delete_inode, 415 .put_super = ovl_put_super, 416 .sync_fs = ovl_sync_fs, 417 .statfs = ovl_statfs, 418 .show_options = ovl_show_options, 419 .remount_fs = ovl_remount, 420 }; 421 422 enum { 423 OPT_LOWERDIR, 424 OPT_UPPERDIR, 425 OPT_WORKDIR, 426 OPT_DEFAULT_PERMISSIONS, 427 OPT_REDIRECT_DIR, 428 OPT_INDEX_ON, 429 OPT_INDEX_OFF, 430 OPT_UUID_ON, 431 OPT_UUID_OFF, 432 OPT_NFS_EXPORT_ON, 433 OPT_USERXATTR, 434 OPT_NFS_EXPORT_OFF, 435 OPT_XINO_ON, 436 OPT_XINO_OFF, 437 OPT_XINO_AUTO, 438 OPT_METACOPY_ON, 439 OPT_METACOPY_OFF, 440 OPT_VOLATILE, 441 OPT_ERR, 442 }; 443 444 static const match_table_t ovl_tokens = { 445 {OPT_LOWERDIR, "lowerdir=%s"}, 446 {OPT_UPPERDIR, "upperdir=%s"}, 447 {OPT_WORKDIR, "workdir=%s"}, 448 {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 449 {OPT_REDIRECT_DIR, "redirect_dir=%s"}, 450 {OPT_INDEX_ON, "index=on"}, 451 {OPT_INDEX_OFF, "index=off"}, 452 {OPT_USERXATTR, "userxattr"}, 453 {OPT_UUID_ON, "uuid=on"}, 454 {OPT_UUID_OFF, "uuid=off"}, 455 {OPT_NFS_EXPORT_ON, "nfs_export=on"}, 456 {OPT_NFS_EXPORT_OFF, "nfs_export=off"}, 457 {OPT_XINO_ON, "xino=on"}, 458 {OPT_XINO_OFF, "xino=off"}, 459 {OPT_XINO_AUTO, "xino=auto"}, 460 {OPT_METACOPY_ON, "metacopy=on"}, 461 {OPT_METACOPY_OFF, "metacopy=off"}, 462 {OPT_VOLATILE, "volatile"}, 463 {OPT_ERR, NULL} 464 }; 465 466 static char *ovl_next_opt(char **s) 467 { 468 char *sbegin = *s; 469 char *p; 470 471 if (sbegin == NULL) 472 return NULL; 473 474 for (p = sbegin; *p; p++) { 475 if (*p == '\\') { 476 p++; 477 if (!*p) 478 break; 479 } else if (*p == ',') { 480 *p = '\0'; 481 *s = p + 1; 482 return sbegin; 483 } 484 } 485 *s = NULL; 486 return sbegin; 487 } 488 489 static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode) 490 { 491 if (strcmp(mode, "on") == 0) { 492 config->redirect_dir = true; 493 /* 494 * Does not make sense to have redirect creation without 495 * redirect following. 496 */ 497 config->redirect_follow = true; 498 } else if (strcmp(mode, "follow") == 0) { 499 config->redirect_follow = true; 500 } else if (strcmp(mode, "off") == 0) { 501 if (ovl_redirect_always_follow) 502 config->redirect_follow = true; 503 } else if (strcmp(mode, "nofollow") != 0) { 504 pr_err("bad mount option \"redirect_dir=%s\"\n", 505 mode); 506 return -EINVAL; 507 } 508 509 return 0; 510 } 511 512 static int ovl_parse_opt(char *opt, struct ovl_config *config) 513 { 514 char *p; 515 int err; 516 bool metacopy_opt = false, redirect_opt = false; 517 bool nfs_export_opt = false, index_opt = false; 518 519 config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL); 520 if (!config->redirect_mode) 521 return -ENOMEM; 522 523 while ((p = ovl_next_opt(&opt)) != NULL) { 524 int token; 525 substring_t args[MAX_OPT_ARGS]; 526 527 if (!*p) 528 continue; 529 530 token = match_token(p, ovl_tokens, args); 531 switch (token) { 532 case OPT_UPPERDIR: 533 kfree(config->upperdir); 534 config->upperdir = match_strdup(&args[0]); 535 if (!config->upperdir) 536 return -ENOMEM; 537 break; 538 539 case OPT_LOWERDIR: 540 kfree(config->lowerdir); 541 config->lowerdir = match_strdup(&args[0]); 542 if (!config->lowerdir) 543 return -ENOMEM; 544 break; 545 546 case OPT_WORKDIR: 547 kfree(config->workdir); 548 config->workdir = match_strdup(&args[0]); 549 if (!config->workdir) 550 return -ENOMEM; 551 break; 552 553 case OPT_DEFAULT_PERMISSIONS: 554 config->default_permissions = true; 555 break; 556 557 case OPT_REDIRECT_DIR: 558 kfree(config->redirect_mode); 559 config->redirect_mode = match_strdup(&args[0]); 560 if (!config->redirect_mode) 561 return -ENOMEM; 562 redirect_opt = true; 563 break; 564 565 case OPT_INDEX_ON: 566 config->index = true; 567 index_opt = true; 568 break; 569 570 case OPT_INDEX_OFF: 571 config->index = false; 572 index_opt = true; 573 break; 574 575 case OPT_UUID_ON: 576 config->uuid = true; 577 break; 578 579 case OPT_UUID_OFF: 580 config->uuid = false; 581 break; 582 583 case OPT_NFS_EXPORT_ON: 584 config->nfs_export = true; 585 nfs_export_opt = true; 586 break; 587 588 case OPT_NFS_EXPORT_OFF: 589 config->nfs_export = false; 590 nfs_export_opt = true; 591 break; 592 593 case OPT_XINO_ON: 594 config->xino = OVL_XINO_ON; 595 break; 596 597 case OPT_XINO_OFF: 598 config->xino = OVL_XINO_OFF; 599 break; 600 601 case OPT_XINO_AUTO: 602 config->xino = OVL_XINO_AUTO; 603 break; 604 605 case OPT_METACOPY_ON: 606 config->metacopy = true; 607 metacopy_opt = true; 608 break; 609 610 case OPT_METACOPY_OFF: 611 config->metacopy = false; 612 metacopy_opt = true; 613 break; 614 615 case OPT_VOLATILE: 616 config->ovl_volatile = true; 617 break; 618 619 case OPT_USERXATTR: 620 config->userxattr = true; 621 break; 622 623 default: 624 pr_err("unrecognized mount option \"%s\" or missing value\n", 625 p); 626 return -EINVAL; 627 } 628 } 629 630 /* Workdir/index are useless in non-upper mount */ 631 if (!config->upperdir) { 632 if (config->workdir) { 633 pr_info("option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 634 config->workdir); 635 kfree(config->workdir); 636 config->workdir = NULL; 637 } 638 if (config->index && index_opt) { 639 pr_info("option \"index=on\" is useless in a non-upper mount, ignore\n"); 640 index_opt = false; 641 } 642 config->index = false; 643 } 644 645 if (!config->upperdir && config->ovl_volatile) { 646 pr_info("option \"volatile\" is meaningless in a non-upper mount, ignoring it.\n"); 647 config->ovl_volatile = false; 648 } 649 650 err = ovl_parse_redirect_mode(config, config->redirect_mode); 651 if (err) 652 return err; 653 654 /* 655 * This is to make the logic below simpler. It doesn't make any other 656 * difference, since config->redirect_dir is only used for upper. 657 */ 658 if (!config->upperdir && config->redirect_follow) 659 config->redirect_dir = true; 660 661 /* Resolve metacopy -> redirect_dir dependency */ 662 if (config->metacopy && !config->redirect_dir) { 663 if (metacopy_opt && redirect_opt) { 664 pr_err("conflicting options: metacopy=on,redirect_dir=%s\n", 665 config->redirect_mode); 666 return -EINVAL; 667 } 668 if (redirect_opt) { 669 /* 670 * There was an explicit redirect_dir=... that resulted 671 * in this conflict. 672 */ 673 pr_info("disabling metacopy due to redirect_dir=%s\n", 674 config->redirect_mode); 675 config->metacopy = false; 676 } else { 677 /* Automatically enable redirect otherwise. */ 678 config->redirect_follow = config->redirect_dir = true; 679 } 680 } 681 682 /* Resolve nfs_export -> index dependency */ 683 if (config->nfs_export && !config->index) { 684 if (!config->upperdir && config->redirect_follow) { 685 pr_info("NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n"); 686 config->nfs_export = false; 687 } else if (nfs_export_opt && index_opt) { 688 pr_err("conflicting options: nfs_export=on,index=off\n"); 689 return -EINVAL; 690 } else if (index_opt) { 691 /* 692 * There was an explicit index=off that resulted 693 * in this conflict. 694 */ 695 pr_info("disabling nfs_export due to index=off\n"); 696 config->nfs_export = false; 697 } else { 698 /* Automatically enable index otherwise. */ 699 config->index = true; 700 } 701 } 702 703 /* Resolve nfs_export -> !metacopy dependency */ 704 if (config->nfs_export && config->metacopy) { 705 if (nfs_export_opt && metacopy_opt) { 706 pr_err("conflicting options: nfs_export=on,metacopy=on\n"); 707 return -EINVAL; 708 } 709 if (metacopy_opt) { 710 /* 711 * There was an explicit metacopy=on that resulted 712 * in this conflict. 713 */ 714 pr_info("disabling nfs_export due to metacopy=on\n"); 715 config->nfs_export = false; 716 } else { 717 /* 718 * There was an explicit nfs_export=on that resulted 719 * in this conflict. 720 */ 721 pr_info("disabling metacopy due to nfs_export=on\n"); 722 config->metacopy = false; 723 } 724 } 725 726 727 /* Resolve userxattr -> !redirect && !metacopy dependency */ 728 if (config->userxattr) { 729 if (config->redirect_follow && redirect_opt) { 730 pr_err("conflicting options: userxattr,redirect_dir=%s\n", 731 config->redirect_mode); 732 return -EINVAL; 733 } 734 if (config->metacopy && metacopy_opt) { 735 pr_err("conflicting options: userxattr,metacopy=on\n"); 736 return -EINVAL; 737 } 738 /* 739 * Silently disable default setting of redirect and metacopy. 740 * This shall be the default in the future as well: these 741 * options must be explicitly enabled if used together with 742 * userxattr. 743 */ 744 config->redirect_dir = config->redirect_follow = false; 745 config->metacopy = false; 746 } 747 748 return 0; 749 } 750 751 #define OVL_WORKDIR_NAME "work" 752 #define OVL_INDEXDIR_NAME "index" 753 754 static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 755 const char *name, bool persist) 756 { 757 struct inode *dir = ofs->workbasedir->d_inode; 758 struct vfsmount *mnt = ovl_upper_mnt(ofs); 759 struct dentry *work; 760 int err; 761 bool retried = false; 762 763 inode_lock_nested(dir, I_MUTEX_PARENT); 764 retry: 765 work = ovl_lookup_upper(ofs, name, ofs->workbasedir, strlen(name)); 766 767 if (!IS_ERR(work)) { 768 struct iattr attr = { 769 .ia_valid = ATTR_MODE, 770 .ia_mode = S_IFDIR | 0, 771 }; 772 773 if (work->d_inode) { 774 err = -EEXIST; 775 if (retried) 776 goto out_dput; 777 778 if (persist) 779 goto out_unlock; 780 781 retried = true; 782 err = ovl_workdir_cleanup(ofs, dir, mnt, work, 0); 783 dput(work); 784 if (err == -EINVAL) { 785 work = ERR_PTR(err); 786 goto out_unlock; 787 } 788 goto retry; 789 } 790 791 err = ovl_mkdir_real(ofs, dir, &work, attr.ia_mode); 792 if (err) 793 goto out_dput; 794 795 /* Weird filesystem returning with hashed negative (kernfs)? */ 796 err = -EINVAL; 797 if (d_really_is_negative(work)) 798 goto out_dput; 799 800 /* 801 * Try to remove POSIX ACL xattrs from workdir. We are good if: 802 * 803 * a) success (there was a POSIX ACL xattr and was removed) 804 * b) -ENODATA (there was no POSIX ACL xattr) 805 * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 806 * 807 * There are various other error values that could effectively 808 * mean that the xattr doesn't exist (e.g. -ERANGE is returned 809 * if the xattr name is too long), but the set of filesystems 810 * allowed as upper are limited to "normal" ones, where checking 811 * for the above two errors is sufficient. 812 */ 813 err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_DEFAULT); 814 if (err && err != -ENODATA && err != -EOPNOTSUPP) 815 goto out_dput; 816 817 err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_ACCESS); 818 if (err && err != -ENODATA && err != -EOPNOTSUPP) 819 goto out_dput; 820 821 /* Clear any inherited mode bits */ 822 inode_lock(work->d_inode); 823 err = ovl_do_notify_change(ofs, work, &attr); 824 inode_unlock(work->d_inode); 825 if (err) 826 goto out_dput; 827 } else { 828 err = PTR_ERR(work); 829 goto out_err; 830 } 831 out_unlock: 832 inode_unlock(dir); 833 return work; 834 835 out_dput: 836 dput(work); 837 out_err: 838 pr_warn("failed to create directory %s/%s (errno: %i); mounting read-only\n", 839 ofs->config.workdir, name, -err); 840 work = NULL; 841 goto out_unlock; 842 } 843 844 static void ovl_unescape(char *s) 845 { 846 char *d = s; 847 848 for (;; s++, d++) { 849 if (*s == '\\') 850 s++; 851 *d = *s; 852 if (!*s) 853 break; 854 } 855 } 856 857 static int ovl_mount_dir_noesc(const char *name, struct path *path) 858 { 859 int err = -EINVAL; 860 861 if (!*name) { 862 pr_err("empty lowerdir\n"); 863 goto out; 864 } 865 err = kern_path(name, LOOKUP_FOLLOW, path); 866 if (err) { 867 pr_err("failed to resolve '%s': %i\n", name, err); 868 goto out; 869 } 870 err = -EINVAL; 871 if (ovl_dentry_weird(path->dentry)) { 872 pr_err("filesystem on '%s' not supported\n", name); 873 goto out_put; 874 } 875 if (!d_is_dir(path->dentry)) { 876 pr_err("'%s' not a directory\n", name); 877 goto out_put; 878 } 879 return 0; 880 881 out_put: 882 path_put_init(path); 883 out: 884 return err; 885 } 886 887 static int ovl_mount_dir(const char *name, struct path *path) 888 { 889 int err = -ENOMEM; 890 char *tmp = kstrdup(name, GFP_KERNEL); 891 892 if (tmp) { 893 ovl_unescape(tmp); 894 err = ovl_mount_dir_noesc(tmp, path); 895 896 if (!err && path->dentry->d_flags & DCACHE_OP_REAL) { 897 pr_err("filesystem on '%s' not supported as upperdir\n", 898 tmp); 899 path_put_init(path); 900 err = -EINVAL; 901 } 902 kfree(tmp); 903 } 904 return err; 905 } 906 907 static int ovl_check_namelen(const struct path *path, struct ovl_fs *ofs, 908 const char *name) 909 { 910 struct kstatfs statfs; 911 int err = vfs_statfs(path, &statfs); 912 913 if (err) 914 pr_err("statfs failed on '%s'\n", name); 915 else 916 ofs->namelen = max(ofs->namelen, statfs.f_namelen); 917 918 return err; 919 } 920 921 static int ovl_lower_dir(const char *name, struct path *path, 922 struct ovl_fs *ofs, int *stack_depth) 923 { 924 int fh_type; 925 int err; 926 927 err = ovl_mount_dir_noesc(name, path); 928 if (err) 929 return err; 930 931 err = ovl_check_namelen(path, ofs, name); 932 if (err) 933 return err; 934 935 *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 936 937 /* 938 * The inodes index feature and NFS export need to encode and decode 939 * file handles, so they require that all layers support them. 940 */ 941 fh_type = ovl_can_decode_fh(path->dentry->d_sb); 942 if ((ofs->config.nfs_export || 943 (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 944 ofs->config.index = false; 945 ofs->config.nfs_export = false; 946 pr_warn("fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 947 name); 948 } 949 /* 950 * Decoding origin file handle is required for persistent st_ino. 951 * Without persistent st_ino, xino=auto falls back to xino=off. 952 */ 953 if (ofs->config.xino == OVL_XINO_AUTO && 954 ofs->config.upperdir && !fh_type) { 955 ofs->config.xino = OVL_XINO_OFF; 956 pr_warn("fs on '%s' does not support file handles, falling back to xino=off.\n", 957 name); 958 } 959 960 /* Check if lower fs has 32bit inode numbers */ 961 if (fh_type != FILEID_INO32_GEN) 962 ofs->xino_mode = -1; 963 964 return 0; 965 } 966 967 /* Workdir should not be subdir of upperdir and vice versa */ 968 static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 969 { 970 bool ok = false; 971 972 if (workdir != upperdir) { 973 ok = (lock_rename(workdir, upperdir) == NULL); 974 unlock_rename(workdir, upperdir); 975 } 976 return ok; 977 } 978 979 static unsigned int ovl_split_lowerdirs(char *str) 980 { 981 unsigned int ctr = 1; 982 char *s, *d; 983 984 for (s = d = str;; s++, d++) { 985 if (*s == '\\') { 986 s++; 987 } else if (*s == ':') { 988 *d = '\0'; 989 ctr++; 990 continue; 991 } 992 *d = *s; 993 if (!*s) 994 break; 995 } 996 return ctr; 997 } 998 999 static int ovl_own_xattr_get(const struct xattr_handler *handler, 1000 struct dentry *dentry, struct inode *inode, 1001 const char *name, void *buffer, size_t size) 1002 { 1003 return -EOPNOTSUPP; 1004 } 1005 1006 static int ovl_own_xattr_set(const struct xattr_handler *handler, 1007 struct mnt_idmap *idmap, 1008 struct dentry *dentry, struct inode *inode, 1009 const char *name, const void *value, 1010 size_t size, int flags) 1011 { 1012 return -EOPNOTSUPP; 1013 } 1014 1015 static int ovl_other_xattr_get(const struct xattr_handler *handler, 1016 struct dentry *dentry, struct inode *inode, 1017 const char *name, void *buffer, size_t size) 1018 { 1019 return ovl_xattr_get(dentry, inode, name, buffer, size); 1020 } 1021 1022 static int ovl_other_xattr_set(const struct xattr_handler *handler, 1023 struct mnt_idmap *idmap, 1024 struct dentry *dentry, struct inode *inode, 1025 const char *name, const void *value, 1026 size_t size, int flags) 1027 { 1028 return ovl_xattr_set(dentry, inode, name, value, size, flags); 1029 } 1030 1031 static const struct xattr_handler ovl_own_trusted_xattr_handler = { 1032 .prefix = OVL_XATTR_TRUSTED_PREFIX, 1033 .get = ovl_own_xattr_get, 1034 .set = ovl_own_xattr_set, 1035 }; 1036 1037 static const struct xattr_handler ovl_own_user_xattr_handler = { 1038 .prefix = OVL_XATTR_USER_PREFIX, 1039 .get = ovl_own_xattr_get, 1040 .set = ovl_own_xattr_set, 1041 }; 1042 1043 static const struct xattr_handler ovl_other_xattr_handler = { 1044 .prefix = "", /* catch all */ 1045 .get = ovl_other_xattr_get, 1046 .set = ovl_other_xattr_set, 1047 }; 1048 1049 static const struct xattr_handler *ovl_trusted_xattr_handlers[] = { 1050 &ovl_own_trusted_xattr_handler, 1051 &ovl_other_xattr_handler, 1052 NULL 1053 }; 1054 1055 static const struct xattr_handler *ovl_user_xattr_handlers[] = { 1056 &ovl_own_user_xattr_handler, 1057 &ovl_other_xattr_handler, 1058 NULL 1059 }; 1060 1061 static int ovl_setup_trap(struct super_block *sb, struct dentry *dir, 1062 struct inode **ptrap, const char *name) 1063 { 1064 struct inode *trap; 1065 int err; 1066 1067 trap = ovl_get_trap_inode(sb, dir); 1068 err = PTR_ERR_OR_ZERO(trap); 1069 if (err) { 1070 if (err == -ELOOP) 1071 pr_err("conflicting %s path\n", name); 1072 return err; 1073 } 1074 1075 *ptrap = trap; 1076 return 0; 1077 } 1078 1079 /* 1080 * Determine how we treat concurrent use of upperdir/workdir based on the 1081 * index feature. This is papering over mount leaks of container runtimes, 1082 * for example, an old overlay mount is leaked and now its upperdir is 1083 * attempted to be used as a lower layer in a new overlay mount. 1084 */ 1085 static int ovl_report_in_use(struct ovl_fs *ofs, const char *name) 1086 { 1087 if (ofs->config.index) { 1088 pr_err("%s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n", 1089 name); 1090 return -EBUSY; 1091 } else { 1092 pr_warn("%s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n", 1093 name); 1094 return 0; 1095 } 1096 } 1097 1098 static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs, 1099 struct ovl_layer *upper_layer, struct path *upperpath) 1100 { 1101 struct vfsmount *upper_mnt; 1102 int err; 1103 1104 err = ovl_mount_dir(ofs->config.upperdir, upperpath); 1105 if (err) 1106 goto out; 1107 1108 /* Upperdir path should not be r/o */ 1109 if (__mnt_is_readonly(upperpath->mnt)) { 1110 pr_err("upper fs is r/o, try multi-lower layers mount\n"); 1111 err = -EINVAL; 1112 goto out; 1113 } 1114 1115 err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 1116 if (err) 1117 goto out; 1118 1119 err = ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap, 1120 "upperdir"); 1121 if (err) 1122 goto out; 1123 1124 upper_mnt = clone_private_mount(upperpath); 1125 err = PTR_ERR(upper_mnt); 1126 if (IS_ERR(upper_mnt)) { 1127 pr_err("failed to clone upperpath\n"); 1128 goto out; 1129 } 1130 1131 /* Don't inherit atime flags */ 1132 upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 1133 upper_layer->mnt = upper_mnt; 1134 upper_layer->idx = 0; 1135 upper_layer->fsid = 0; 1136 1137 /* 1138 * Inherit SB_NOSEC flag from upperdir. 1139 * 1140 * This optimization changes behavior when a security related attribute 1141 * (suid/sgid/security.*) is changed on an underlying layer. This is 1142 * okay because we don't yet have guarantees in that case, but it will 1143 * need careful treatment once we want to honour changes to underlying 1144 * filesystems. 1145 */ 1146 if (upper_mnt->mnt_sb->s_flags & SB_NOSEC) 1147 sb->s_flags |= SB_NOSEC; 1148 1149 if (ovl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) { 1150 ofs->upperdir_locked = true; 1151 } else { 1152 err = ovl_report_in_use(ofs, "upperdir"); 1153 if (err) 1154 goto out; 1155 } 1156 1157 err = 0; 1158 out: 1159 return err; 1160 } 1161 1162 /* 1163 * Returns 1 if RENAME_WHITEOUT is supported, 0 if not supported and 1164 * negative values if error is encountered. 1165 */ 1166 static int ovl_check_rename_whiteout(struct ovl_fs *ofs) 1167 { 1168 struct dentry *workdir = ofs->workdir; 1169 struct inode *dir = d_inode(workdir); 1170 struct dentry *temp; 1171 struct dentry *dest; 1172 struct dentry *whiteout; 1173 struct name_snapshot name; 1174 int err; 1175 1176 inode_lock_nested(dir, I_MUTEX_PARENT); 1177 1178 temp = ovl_create_temp(ofs, workdir, OVL_CATTR(S_IFREG | 0)); 1179 err = PTR_ERR(temp); 1180 if (IS_ERR(temp)) 1181 goto out_unlock; 1182 1183 dest = ovl_lookup_temp(ofs, workdir); 1184 err = PTR_ERR(dest); 1185 if (IS_ERR(dest)) { 1186 dput(temp); 1187 goto out_unlock; 1188 } 1189 1190 /* Name is inline and stable - using snapshot as a copy helper */ 1191 take_dentry_name_snapshot(&name, temp); 1192 err = ovl_do_rename(ofs, dir, temp, dir, dest, RENAME_WHITEOUT); 1193 if (err) { 1194 if (err == -EINVAL) 1195 err = 0; 1196 goto cleanup_temp; 1197 } 1198 1199 whiteout = ovl_lookup_upper(ofs, name.name.name, workdir, name.name.len); 1200 err = PTR_ERR(whiteout); 1201 if (IS_ERR(whiteout)) 1202 goto cleanup_temp; 1203 1204 err = ovl_is_whiteout(whiteout); 1205 1206 /* Best effort cleanup of whiteout and temp file */ 1207 if (err) 1208 ovl_cleanup(ofs, dir, whiteout); 1209 dput(whiteout); 1210 1211 cleanup_temp: 1212 ovl_cleanup(ofs, dir, temp); 1213 release_dentry_name_snapshot(&name); 1214 dput(temp); 1215 dput(dest); 1216 1217 out_unlock: 1218 inode_unlock(dir); 1219 1220 return err; 1221 } 1222 1223 static struct dentry *ovl_lookup_or_create(struct ovl_fs *ofs, 1224 struct dentry *parent, 1225 const char *name, umode_t mode) 1226 { 1227 size_t len = strlen(name); 1228 struct dentry *child; 1229 1230 inode_lock_nested(parent->d_inode, I_MUTEX_PARENT); 1231 child = ovl_lookup_upper(ofs, name, parent, len); 1232 if (!IS_ERR(child) && !child->d_inode) 1233 child = ovl_create_real(ofs, parent->d_inode, child, 1234 OVL_CATTR(mode)); 1235 inode_unlock(parent->d_inode); 1236 dput(parent); 1237 1238 return child; 1239 } 1240 1241 /* 1242 * Creates $workdir/work/incompat/volatile/dirty file if it is not already 1243 * present. 1244 */ 1245 static int ovl_create_volatile_dirty(struct ovl_fs *ofs) 1246 { 1247 unsigned int ctr; 1248 struct dentry *d = dget(ofs->workbasedir); 1249 static const char *const volatile_path[] = { 1250 OVL_WORKDIR_NAME, "incompat", "volatile", "dirty" 1251 }; 1252 const char *const *name = volatile_path; 1253 1254 for (ctr = ARRAY_SIZE(volatile_path); ctr; ctr--, name++) { 1255 d = ovl_lookup_or_create(ofs, d, *name, ctr > 1 ? S_IFDIR : S_IFREG); 1256 if (IS_ERR(d)) 1257 return PTR_ERR(d); 1258 } 1259 dput(d); 1260 return 0; 1261 } 1262 1263 static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs, 1264 const struct path *workpath) 1265 { 1266 struct vfsmount *mnt = ovl_upper_mnt(ofs); 1267 struct dentry *workdir; 1268 struct file *tmpfile; 1269 bool rename_whiteout; 1270 bool d_type; 1271 int fh_type; 1272 int err; 1273 1274 err = mnt_want_write(mnt); 1275 if (err) 1276 return err; 1277 1278 workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 1279 err = PTR_ERR(workdir); 1280 if (IS_ERR_OR_NULL(workdir)) 1281 goto out; 1282 1283 ofs->workdir = workdir; 1284 1285 err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir"); 1286 if (err) 1287 goto out; 1288 1289 /* 1290 * Upper should support d_type, else whiteouts are visible. Given 1291 * workdir and upper are on same fs, we can do iterate_dir() on 1292 * workdir. This check requires successful creation of workdir in 1293 * previous step. 1294 */ 1295 err = ovl_check_d_type_supported(workpath); 1296 if (err < 0) 1297 goto out; 1298 1299 d_type = err; 1300 if (!d_type) 1301 pr_warn("upper fs needs to support d_type.\n"); 1302 1303 /* Check if upper/work fs supports O_TMPFILE */ 1304 tmpfile = ovl_do_tmpfile(ofs, ofs->workdir, S_IFREG | 0); 1305 ofs->tmpfile = !IS_ERR(tmpfile); 1306 if (ofs->tmpfile) 1307 fput(tmpfile); 1308 else 1309 pr_warn("upper fs does not support tmpfile.\n"); 1310 1311 1312 /* Check if upper/work fs supports RENAME_WHITEOUT */ 1313 err = ovl_check_rename_whiteout(ofs); 1314 if (err < 0) 1315 goto out; 1316 1317 rename_whiteout = err; 1318 if (!rename_whiteout) 1319 pr_warn("upper fs does not support RENAME_WHITEOUT.\n"); 1320 1321 /* 1322 * Check if upper/work fs supports (trusted|user).overlay.* xattr 1323 */ 1324 err = ovl_setxattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE, "0", 1); 1325 if (err) { 1326 pr_warn("failed to set xattr on upper\n"); 1327 ofs->noxattr = true; 1328 if (ofs->config.index || ofs->config.metacopy) { 1329 ofs->config.index = false; 1330 ofs->config.metacopy = false; 1331 pr_warn("...falling back to index=off,metacopy=off.\n"); 1332 } 1333 /* 1334 * xattr support is required for persistent st_ino. 1335 * Without persistent st_ino, xino=auto falls back to xino=off. 1336 */ 1337 if (ofs->config.xino == OVL_XINO_AUTO) { 1338 ofs->config.xino = OVL_XINO_OFF; 1339 pr_warn("...falling back to xino=off.\n"); 1340 } 1341 if (err == -EPERM && !ofs->config.userxattr) 1342 pr_info("try mounting with 'userxattr' option\n"); 1343 err = 0; 1344 } else { 1345 ovl_removexattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE); 1346 } 1347 1348 /* 1349 * We allowed sub-optimal upper fs configuration and don't want to break 1350 * users over kernel upgrade, but we never allowed remote upper fs, so 1351 * we can enforce strict requirements for remote upper fs. 1352 */ 1353 if (ovl_dentry_remote(ofs->workdir) && 1354 (!d_type || !rename_whiteout || ofs->noxattr)) { 1355 pr_err("upper fs missing required features.\n"); 1356 err = -EINVAL; 1357 goto out; 1358 } 1359 1360 /* 1361 * For volatile mount, create a incompat/volatile/dirty file to keep 1362 * track of it. 1363 */ 1364 if (ofs->config.ovl_volatile) { 1365 err = ovl_create_volatile_dirty(ofs); 1366 if (err < 0) { 1367 pr_err("Failed to create volatile/dirty file.\n"); 1368 goto out; 1369 } 1370 } 1371 1372 /* Check if upper/work fs supports file handles */ 1373 fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 1374 if (ofs->config.index && !fh_type) { 1375 ofs->config.index = false; 1376 pr_warn("upper fs does not support file handles, falling back to index=off.\n"); 1377 } 1378 1379 /* Check if upper fs has 32bit inode numbers */ 1380 if (fh_type != FILEID_INO32_GEN) 1381 ofs->xino_mode = -1; 1382 1383 /* NFS export of r/w mount depends on index */ 1384 if (ofs->config.nfs_export && !ofs->config.index) { 1385 pr_warn("NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 1386 ofs->config.nfs_export = false; 1387 } 1388 out: 1389 mnt_drop_write(mnt); 1390 return err; 1391 } 1392 1393 static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs, 1394 const struct path *upperpath) 1395 { 1396 int err; 1397 struct path workpath = { }; 1398 1399 err = ovl_mount_dir(ofs->config.workdir, &workpath); 1400 if (err) 1401 goto out; 1402 1403 err = -EINVAL; 1404 if (upperpath->mnt != workpath.mnt) { 1405 pr_err("workdir and upperdir must reside under the same mount\n"); 1406 goto out; 1407 } 1408 if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 1409 pr_err("workdir and upperdir must be separate subtrees\n"); 1410 goto out; 1411 } 1412 1413 ofs->workbasedir = dget(workpath.dentry); 1414 1415 if (ovl_inuse_trylock(ofs->workbasedir)) { 1416 ofs->workdir_locked = true; 1417 } else { 1418 err = ovl_report_in_use(ofs, "workdir"); 1419 if (err) 1420 goto out; 1421 } 1422 1423 err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap, 1424 "workdir"); 1425 if (err) 1426 goto out; 1427 1428 err = ovl_make_workdir(sb, ofs, &workpath); 1429 1430 out: 1431 path_put(&workpath); 1432 1433 return err; 1434 } 1435 1436 static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs, 1437 struct ovl_entry *oe, const struct path *upperpath) 1438 { 1439 struct vfsmount *mnt = ovl_upper_mnt(ofs); 1440 struct dentry *indexdir; 1441 int err; 1442 1443 err = mnt_want_write(mnt); 1444 if (err) 1445 return err; 1446 1447 /* Verify lower root is upper root origin */ 1448 err = ovl_verify_origin(ofs, upperpath->dentry, 1449 ovl_lowerstack(oe)->dentry, true); 1450 if (err) { 1451 pr_err("failed to verify upper root origin\n"); 1452 goto out; 1453 } 1454 1455 /* index dir will act also as workdir */ 1456 iput(ofs->workdir_trap); 1457 ofs->workdir_trap = NULL; 1458 dput(ofs->workdir); 1459 ofs->workdir = NULL; 1460 indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1461 if (IS_ERR(indexdir)) { 1462 err = PTR_ERR(indexdir); 1463 } else if (indexdir) { 1464 ofs->indexdir = indexdir; 1465 ofs->workdir = dget(indexdir); 1466 1467 err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap, 1468 "indexdir"); 1469 if (err) 1470 goto out; 1471 1472 /* 1473 * Verify upper root is exclusively associated with index dir. 1474 * Older kernels stored upper fh in ".overlay.origin" 1475 * xattr. If that xattr exists, verify that it is a match to 1476 * upper dir file handle. In any case, verify or set xattr 1477 * ".overlay.upper" to indicate that index may have 1478 * directory entries. 1479 */ 1480 if (ovl_check_origin_xattr(ofs, ofs->indexdir)) { 1481 err = ovl_verify_set_fh(ofs, ofs->indexdir, 1482 OVL_XATTR_ORIGIN, 1483 upperpath->dentry, true, false); 1484 if (err) 1485 pr_err("failed to verify index dir 'origin' xattr\n"); 1486 } 1487 err = ovl_verify_upper(ofs, ofs->indexdir, upperpath->dentry, 1488 true); 1489 if (err) 1490 pr_err("failed to verify index dir 'upper' xattr\n"); 1491 1492 /* Cleanup bad/stale/orphan index entries */ 1493 if (!err) 1494 err = ovl_indexdir_cleanup(ofs); 1495 } 1496 if (err || !ofs->indexdir) 1497 pr_warn("try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1498 1499 out: 1500 mnt_drop_write(mnt); 1501 return err; 1502 } 1503 1504 static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid) 1505 { 1506 unsigned int i; 1507 1508 if (!ofs->config.nfs_export && !ovl_upper_mnt(ofs)) 1509 return true; 1510 1511 /* 1512 * We allow using single lower with null uuid for index and nfs_export 1513 * for example to support those features with single lower squashfs. 1514 * To avoid regressions in setups of overlay with re-formatted lower 1515 * squashfs, do not allow decoding origin with lower null uuid unless 1516 * user opted-in to one of the new features that require following the 1517 * lower inode of non-dir upper. 1518 */ 1519 if (ovl_allow_offline_changes(ofs) && uuid_is_null(uuid)) 1520 return false; 1521 1522 for (i = 0; i < ofs->numfs; i++) { 1523 /* 1524 * We use uuid to associate an overlay lower file handle with a 1525 * lower layer, so we can accept lower fs with null uuid as long 1526 * as all lower layers with null uuid are on the same fs. 1527 * if we detect multiple lower fs with the same uuid, we 1528 * disable lower file handle decoding on all of them. 1529 */ 1530 if (ofs->fs[i].is_lower && 1531 uuid_equal(&ofs->fs[i].sb->s_uuid, uuid)) { 1532 ofs->fs[i].bad_uuid = true; 1533 return false; 1534 } 1535 } 1536 return true; 1537 } 1538 1539 /* Get a unique fsid for the layer */ 1540 static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) 1541 { 1542 struct super_block *sb = path->mnt->mnt_sb; 1543 unsigned int i; 1544 dev_t dev; 1545 int err; 1546 bool bad_uuid = false; 1547 bool warn = false; 1548 1549 for (i = 0; i < ofs->numfs; i++) { 1550 if (ofs->fs[i].sb == sb) 1551 return i; 1552 } 1553 1554 if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) { 1555 bad_uuid = true; 1556 if (ofs->config.xino == OVL_XINO_AUTO) { 1557 ofs->config.xino = OVL_XINO_OFF; 1558 warn = true; 1559 } 1560 if (ofs->config.index || ofs->config.nfs_export) { 1561 ofs->config.index = false; 1562 ofs->config.nfs_export = false; 1563 warn = true; 1564 } 1565 if (warn) { 1566 pr_warn("%s uuid detected in lower fs '%pd2', falling back to xino=%s,index=off,nfs_export=off.\n", 1567 uuid_is_null(&sb->s_uuid) ? "null" : 1568 "conflicting", 1569 path->dentry, ovl_xino_str[ofs->config.xino]); 1570 } 1571 } 1572 1573 err = get_anon_bdev(&dev); 1574 if (err) { 1575 pr_err("failed to get anonymous bdev for lowerpath\n"); 1576 return err; 1577 } 1578 1579 ofs->fs[ofs->numfs].sb = sb; 1580 ofs->fs[ofs->numfs].pseudo_dev = dev; 1581 ofs->fs[ofs->numfs].bad_uuid = bad_uuid; 1582 1583 return ofs->numfs++; 1584 } 1585 1586 /* 1587 * The fsid after the last lower fsid is used for the data layers. 1588 * It is a "null fs" with a null sb, null uuid, and no pseudo dev. 1589 */ 1590 static int ovl_get_data_fsid(struct ovl_fs *ofs) 1591 { 1592 return ofs->numfs; 1593 } 1594 1595 1596 static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, 1597 struct path *stack, unsigned int numlower, 1598 struct ovl_layer *layers) 1599 { 1600 int err; 1601 unsigned int i; 1602 1603 ofs->fs = kcalloc(numlower + 2, sizeof(struct ovl_sb), GFP_KERNEL); 1604 if (ofs->fs == NULL) 1605 return -ENOMEM; 1606 1607 /* 1608 * idx/fsid 0 are reserved for upper fs even with lower only overlay 1609 * and the last fsid is reserved for "null fs" of the data layers. 1610 */ 1611 ofs->numfs++; 1612 1613 /* 1614 * All lower layers that share the same fs as upper layer, use the same 1615 * pseudo_dev as upper layer. Allocate fs[0].pseudo_dev even for lower 1616 * only overlay to simplify ovl_fs_free(). 1617 * is_lower will be set if upper fs is shared with a lower layer. 1618 */ 1619 err = get_anon_bdev(&ofs->fs[0].pseudo_dev); 1620 if (err) { 1621 pr_err("failed to get anonymous bdev for upper fs\n"); 1622 return err; 1623 } 1624 1625 if (ovl_upper_mnt(ofs)) { 1626 ofs->fs[0].sb = ovl_upper_mnt(ofs)->mnt_sb; 1627 ofs->fs[0].is_lower = false; 1628 } 1629 1630 for (i = 0; i < numlower; i++) { 1631 struct vfsmount *mnt; 1632 struct inode *trap; 1633 int fsid; 1634 1635 if (i < numlower - ofs->numdatalayer) 1636 fsid = ovl_get_fsid(ofs, &stack[i]); 1637 else 1638 fsid = ovl_get_data_fsid(ofs); 1639 if (fsid < 0) 1640 return fsid; 1641 1642 /* 1643 * Check if lower root conflicts with this overlay layers before 1644 * checking if it is in-use as upperdir/workdir of "another" 1645 * mount, because we do not bother to check in ovl_is_inuse() if 1646 * the upperdir/workdir is in fact in-use by our 1647 * upperdir/workdir. 1648 */ 1649 err = ovl_setup_trap(sb, stack[i].dentry, &trap, "lowerdir"); 1650 if (err) 1651 return err; 1652 1653 if (ovl_is_inuse(stack[i].dentry)) { 1654 err = ovl_report_in_use(ofs, "lowerdir"); 1655 if (err) { 1656 iput(trap); 1657 return err; 1658 } 1659 } 1660 1661 mnt = clone_private_mount(&stack[i]); 1662 err = PTR_ERR(mnt); 1663 if (IS_ERR(mnt)) { 1664 pr_err("failed to clone lowerpath\n"); 1665 iput(trap); 1666 return err; 1667 } 1668 1669 /* 1670 * Make lower layers R/O. That way fchmod/fchown on lower file 1671 * will fail instead of modifying lower fs. 1672 */ 1673 mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1674 1675 layers[ofs->numlayer].trap = trap; 1676 layers[ofs->numlayer].mnt = mnt; 1677 layers[ofs->numlayer].idx = ofs->numlayer; 1678 layers[ofs->numlayer].fsid = fsid; 1679 layers[ofs->numlayer].fs = &ofs->fs[fsid]; 1680 ofs->numlayer++; 1681 ofs->fs[fsid].is_lower = true; 1682 } 1683 1684 /* 1685 * When all layers on same fs, overlay can use real inode numbers. 1686 * With mount option "xino=<on|auto>", mounter declares that there are 1687 * enough free high bits in underlying fs to hold the unique fsid. 1688 * If overlayfs does encounter underlying inodes using the high xino 1689 * bits reserved for fsid, it emits a warning and uses the original 1690 * inode number or a non persistent inode number allocated from a 1691 * dedicated range. 1692 */ 1693 if (ofs->numfs - !ovl_upper_mnt(ofs) == 1) { 1694 if (ofs->config.xino == OVL_XINO_ON) 1695 pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n"); 1696 ofs->xino_mode = 0; 1697 } else if (ofs->config.xino == OVL_XINO_OFF) { 1698 ofs->xino_mode = -1; 1699 } else if (ofs->xino_mode < 0) { 1700 /* 1701 * This is a roundup of number of bits needed for encoding 1702 * fsid, where fsid 0 is reserved for upper fs (even with 1703 * lower only overlay) +1 extra bit is reserved for the non 1704 * persistent inode number range that is used for resolving 1705 * xino lower bits overflow. 1706 */ 1707 BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 30); 1708 ofs->xino_mode = ilog2(ofs->numfs - 1) + 2; 1709 } 1710 1711 if (ofs->xino_mode > 0) { 1712 pr_info("\"xino\" feature enabled using %d upper inode bits.\n", 1713 ofs->xino_mode); 1714 } 1715 1716 return 0; 1717 } 1718 1719 static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1720 const char *lower, unsigned int numlower, 1721 struct ovl_fs *ofs, struct ovl_layer *layers) 1722 { 1723 int err; 1724 struct path *stack = NULL; 1725 struct ovl_path *lowerstack; 1726 unsigned int numlowerdata = 0; 1727 unsigned int i; 1728 struct ovl_entry *oe; 1729 1730 if (!ofs->config.upperdir && numlower == 1) { 1731 pr_err("at least 2 lowerdir are needed while upperdir nonexistent\n"); 1732 return ERR_PTR(-EINVAL); 1733 } 1734 1735 stack = kcalloc(numlower, sizeof(struct path), GFP_KERNEL); 1736 if (!stack) 1737 return ERR_PTR(-ENOMEM); 1738 1739 for (i = 0; i < numlower;) { 1740 err = ovl_lower_dir(lower, &stack[i], ofs, &sb->s_stack_depth); 1741 if (err) 1742 goto out_err; 1743 1744 lower = strchr(lower, '\0') + 1; 1745 1746 i++; 1747 if (i == numlower) 1748 break; 1749 1750 err = -EINVAL; 1751 /* 1752 * Empty lower layer path could mean :: separator that indicates 1753 * a data-only lower data. 1754 * Several data-only layers are allowed, but they all need to be 1755 * at the bottom of the stack. 1756 */ 1757 if (*lower) { 1758 /* normal lower dir */ 1759 if (numlowerdata) { 1760 pr_err("lower data-only dirs must be at the bottom of the stack.\n"); 1761 goto out_err; 1762 } 1763 } else { 1764 /* data-only lower dir */ 1765 if (!ofs->config.metacopy) { 1766 pr_err("lower data-only dirs require metacopy support.\n"); 1767 goto out_err; 1768 } 1769 if (i == numlower - 1) { 1770 pr_err("lowerdir argument must not end with double colon.\n"); 1771 goto out_err; 1772 } 1773 lower++; 1774 numlower--; 1775 numlowerdata++; 1776 } 1777 } 1778 1779 if (numlowerdata) { 1780 ofs->numdatalayer = numlowerdata; 1781 pr_info("using the lowest %d of %d lowerdirs as data layers\n", 1782 numlowerdata, numlower); 1783 } 1784 1785 err = -EINVAL; 1786 sb->s_stack_depth++; 1787 if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 1788 pr_err("maximum fs stacking depth exceeded\n"); 1789 goto out_err; 1790 } 1791 1792 err = ovl_get_layers(sb, ofs, stack, numlower, layers); 1793 if (err) 1794 goto out_err; 1795 1796 err = -ENOMEM; 1797 /* Data-only layers are not merged in root directory */ 1798 oe = ovl_alloc_entry(numlower - numlowerdata); 1799 if (!oe) 1800 goto out_err; 1801 1802 lowerstack = ovl_lowerstack(oe); 1803 for (i = 0; i < numlower - numlowerdata; i++) { 1804 lowerstack[i].dentry = dget(stack[i].dentry); 1805 lowerstack[i].layer = &ofs->layers[i+1]; 1806 } 1807 1808 out: 1809 for (i = 0; i < numlower; i++) 1810 path_put(&stack[i]); 1811 kfree(stack); 1812 1813 return oe; 1814 1815 out_err: 1816 oe = ERR_PTR(err); 1817 goto out; 1818 } 1819 1820 /* 1821 * Check if this layer root is a descendant of: 1822 * - another layer of this overlayfs instance 1823 * - upper/work dir of any overlayfs instance 1824 */ 1825 static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs, 1826 struct dentry *dentry, const char *name, 1827 bool is_lower) 1828 { 1829 struct dentry *next = dentry, *parent; 1830 int err = 0; 1831 1832 if (!dentry) 1833 return 0; 1834 1835 parent = dget_parent(next); 1836 1837 /* Walk back ancestors to root (inclusive) looking for traps */ 1838 while (!err && parent != next) { 1839 if (is_lower && ovl_lookup_trap_inode(sb, parent)) { 1840 err = -ELOOP; 1841 pr_err("overlapping %s path\n", name); 1842 } else if (ovl_is_inuse(parent)) { 1843 err = ovl_report_in_use(ofs, name); 1844 } 1845 next = parent; 1846 parent = dget_parent(next); 1847 dput(next); 1848 } 1849 1850 dput(parent); 1851 1852 return err; 1853 } 1854 1855 /* 1856 * Check if any of the layers or work dirs overlap. 1857 */ 1858 static int ovl_check_overlapping_layers(struct super_block *sb, 1859 struct ovl_fs *ofs) 1860 { 1861 int i, err; 1862 1863 if (ovl_upper_mnt(ofs)) { 1864 err = ovl_check_layer(sb, ofs, ovl_upper_mnt(ofs)->mnt_root, 1865 "upperdir", false); 1866 if (err) 1867 return err; 1868 1869 /* 1870 * Checking workbasedir avoids hitting ovl_is_inuse(parent) of 1871 * this instance and covers overlapping work and index dirs, 1872 * unless work or index dir have been moved since created inside 1873 * workbasedir. In that case, we already have their traps in 1874 * inode cache and we will catch that case on lookup. 1875 */ 1876 err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir", 1877 false); 1878 if (err) 1879 return err; 1880 } 1881 1882 for (i = 1; i < ofs->numlayer; i++) { 1883 err = ovl_check_layer(sb, ofs, 1884 ofs->layers[i].mnt->mnt_root, 1885 "lowerdir", true); 1886 if (err) 1887 return err; 1888 } 1889 1890 return 0; 1891 } 1892 1893 static struct dentry *ovl_get_root(struct super_block *sb, 1894 struct dentry *upperdentry, 1895 struct ovl_entry *oe) 1896 { 1897 struct dentry *root; 1898 struct ovl_path *lowerpath = ovl_lowerstack(oe); 1899 unsigned long ino = d_inode(lowerpath->dentry)->i_ino; 1900 int fsid = lowerpath->layer->fsid; 1901 struct ovl_inode_params oip = { 1902 .upperdentry = upperdentry, 1903 .oe = oe, 1904 }; 1905 1906 root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 1907 if (!root) 1908 return NULL; 1909 1910 if (upperdentry) { 1911 /* Root inode uses upper st_ino/i_ino */ 1912 ino = d_inode(upperdentry)->i_ino; 1913 fsid = 0; 1914 ovl_dentry_set_upper_alias(root); 1915 if (ovl_is_impuredir(sb, upperdentry)) 1916 ovl_set_flag(OVL_IMPURE, d_inode(root)); 1917 } 1918 1919 /* Root is always merge -> can have whiteouts */ 1920 ovl_set_flag(OVL_WHITEOUTS, d_inode(root)); 1921 ovl_dentry_set_flag(OVL_E_CONNECTED, root); 1922 ovl_set_upperdata(d_inode(root)); 1923 ovl_inode_init(d_inode(root), &oip, ino, fsid); 1924 ovl_dentry_init_flags(root, upperdentry, oe, DCACHE_OP_WEAK_REVALIDATE); 1925 /* root keeps a reference of upperdentry */ 1926 dget(upperdentry); 1927 1928 return root; 1929 } 1930 1931 static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1932 { 1933 struct path upperpath = { }; 1934 struct dentry *root_dentry; 1935 struct ovl_entry *oe; 1936 struct ovl_fs *ofs; 1937 struct ovl_layer *layers; 1938 struct cred *cred; 1939 char *splitlower = NULL; 1940 unsigned int numlower; 1941 int err; 1942 1943 err = -EIO; 1944 if (WARN_ON(sb->s_user_ns != current_user_ns())) 1945 goto out; 1946 1947 sb->s_d_op = &ovl_dentry_operations; 1948 1949 err = -ENOMEM; 1950 ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1951 if (!ofs) 1952 goto out; 1953 1954 err = -ENOMEM; 1955 ofs->creator_cred = cred = prepare_creds(); 1956 if (!cred) 1957 goto out_err; 1958 1959 ofs->config.index = ovl_index_def; 1960 ofs->config.uuid = true; 1961 ofs->config.nfs_export = ovl_nfs_export_def; 1962 ofs->config.xino = ovl_xino_def(); 1963 ofs->config.metacopy = ovl_metacopy_def; 1964 err = ovl_parse_opt((char *) data, &ofs->config); 1965 if (err) 1966 goto out_err; 1967 1968 err = -EINVAL; 1969 if (!ofs->config.lowerdir) { 1970 if (!silent) 1971 pr_err("missing 'lowerdir'\n"); 1972 goto out_err; 1973 } 1974 1975 err = -ENOMEM; 1976 splitlower = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 1977 if (!splitlower) 1978 goto out_err; 1979 1980 err = -EINVAL; 1981 numlower = ovl_split_lowerdirs(splitlower); 1982 if (numlower > OVL_MAX_STACK) { 1983 pr_err("too many lower directories, limit is %d\n", 1984 OVL_MAX_STACK); 1985 goto out_err; 1986 } 1987 1988 err = -ENOMEM; 1989 layers = kcalloc(numlower + 1, sizeof(struct ovl_layer), GFP_KERNEL); 1990 if (!layers) 1991 goto out_err; 1992 1993 ofs->layers = layers; 1994 /* Layer 0 is reserved for upper even if there's no upper */ 1995 ofs->numlayer = 1; 1996 1997 sb->s_stack_depth = 0; 1998 sb->s_maxbytes = MAX_LFS_FILESIZE; 1999 atomic_long_set(&ofs->last_ino, 1); 2000 /* Assume underlying fs uses 32bit inodes unless proven otherwise */ 2001 if (ofs->config.xino != OVL_XINO_OFF) { 2002 ofs->xino_mode = BITS_PER_LONG - 32; 2003 if (!ofs->xino_mode) { 2004 pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n"); 2005 ofs->config.xino = OVL_XINO_OFF; 2006 } 2007 } 2008 2009 /* alloc/destroy_inode needed for setting up traps in inode cache */ 2010 sb->s_op = &ovl_super_operations; 2011 2012 if (ofs->config.upperdir) { 2013 struct super_block *upper_sb; 2014 2015 err = -EINVAL; 2016 if (!ofs->config.workdir) { 2017 pr_err("missing 'workdir'\n"); 2018 goto out_err; 2019 } 2020 2021 err = ovl_get_upper(sb, ofs, &layers[0], &upperpath); 2022 if (err) 2023 goto out_err; 2024 2025 upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 2026 if (!ovl_should_sync(ofs)) { 2027 ofs->errseq = errseq_sample(&upper_sb->s_wb_err); 2028 if (errseq_check(&upper_sb->s_wb_err, ofs->errseq)) { 2029 err = -EIO; 2030 pr_err("Cannot mount volatile when upperdir has an unseen error. Sync upperdir fs to clear state.\n"); 2031 goto out_err; 2032 } 2033 } 2034 2035 err = ovl_get_workdir(sb, ofs, &upperpath); 2036 if (err) 2037 goto out_err; 2038 2039 if (!ofs->workdir) 2040 sb->s_flags |= SB_RDONLY; 2041 2042 sb->s_stack_depth = upper_sb->s_stack_depth; 2043 sb->s_time_gran = upper_sb->s_time_gran; 2044 } 2045 oe = ovl_get_lowerstack(sb, splitlower, numlower, ofs, layers); 2046 err = PTR_ERR(oe); 2047 if (IS_ERR(oe)) 2048 goto out_err; 2049 2050 /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 2051 if (!ovl_upper_mnt(ofs)) 2052 sb->s_flags |= SB_RDONLY; 2053 2054 if (!ofs->config.uuid && ofs->numfs > 1) { 2055 pr_warn("The uuid=off requires a single fs for lower and upper, falling back to uuid=on.\n"); 2056 ofs->config.uuid = true; 2057 } 2058 2059 if (!ovl_force_readonly(ofs) && ofs->config.index) { 2060 err = ovl_get_indexdir(sb, ofs, oe, &upperpath); 2061 if (err) 2062 goto out_free_oe; 2063 2064 /* Force r/o mount with no index dir */ 2065 if (!ofs->indexdir) 2066 sb->s_flags |= SB_RDONLY; 2067 } 2068 2069 err = ovl_check_overlapping_layers(sb, ofs); 2070 if (err) 2071 goto out_free_oe; 2072 2073 /* Show index=off in /proc/mounts for forced r/o mount */ 2074 if (!ofs->indexdir) { 2075 ofs->config.index = false; 2076 if (ovl_upper_mnt(ofs) && ofs->config.nfs_export) { 2077 pr_warn("NFS export requires an index dir, falling back to nfs_export=off.\n"); 2078 ofs->config.nfs_export = false; 2079 } 2080 } 2081 2082 if (ofs->config.metacopy && ofs->config.nfs_export) { 2083 pr_warn("NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 2084 ofs->config.nfs_export = false; 2085 } 2086 2087 if (ofs->config.nfs_export) 2088 sb->s_export_op = &ovl_export_operations; 2089 2090 /* Never override disk quota limits or use reserved space */ 2091 cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 2092 2093 sb->s_magic = OVERLAYFS_SUPER_MAGIC; 2094 sb->s_xattr = ofs->config.userxattr ? ovl_user_xattr_handlers : 2095 ovl_trusted_xattr_handlers; 2096 sb->s_fs_info = ofs; 2097 sb->s_flags |= SB_POSIXACL; 2098 sb->s_iflags |= SB_I_SKIP_SYNC; 2099 2100 err = -ENOMEM; 2101 root_dentry = ovl_get_root(sb, upperpath.dentry, oe); 2102 if (!root_dentry) 2103 goto out_free_oe; 2104 2105 path_put(&upperpath); 2106 kfree(splitlower); 2107 2108 sb->s_root = root_dentry; 2109 2110 return 0; 2111 2112 out_free_oe: 2113 ovl_free_entry(oe); 2114 out_err: 2115 kfree(splitlower); 2116 path_put(&upperpath); 2117 ovl_free_fs(ofs); 2118 out: 2119 return err; 2120 } 2121 2122 static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 2123 const char *dev_name, void *raw_data) 2124 { 2125 return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 2126 } 2127 2128 static struct file_system_type ovl_fs_type = { 2129 .owner = THIS_MODULE, 2130 .name = "overlay", 2131 .fs_flags = FS_USERNS_MOUNT, 2132 .mount = ovl_mount, 2133 .kill_sb = kill_anon_super, 2134 }; 2135 MODULE_ALIAS_FS("overlay"); 2136 2137 static void ovl_inode_init_once(void *foo) 2138 { 2139 struct ovl_inode *oi = foo; 2140 2141 inode_init_once(&oi->vfs_inode); 2142 } 2143 2144 static int __init ovl_init(void) 2145 { 2146 int err; 2147 2148 ovl_inode_cachep = kmem_cache_create("ovl_inode", 2149 sizeof(struct ovl_inode), 0, 2150 (SLAB_RECLAIM_ACCOUNT| 2151 SLAB_MEM_SPREAD|SLAB_ACCOUNT), 2152 ovl_inode_init_once); 2153 if (ovl_inode_cachep == NULL) 2154 return -ENOMEM; 2155 2156 err = ovl_aio_request_cache_init(); 2157 if (!err) { 2158 err = register_filesystem(&ovl_fs_type); 2159 if (!err) 2160 return 0; 2161 2162 ovl_aio_request_cache_destroy(); 2163 } 2164 kmem_cache_destroy(ovl_inode_cachep); 2165 2166 return err; 2167 } 2168 2169 static void __exit ovl_exit(void) 2170 { 2171 unregister_filesystem(&ovl_fs_type); 2172 2173 /* 2174 * Make sure all delayed rcu free inodes are flushed before we 2175 * destroy cache. 2176 */ 2177 rcu_barrier(); 2178 kmem_cache_destroy(ovl_inode_cachep); 2179 ovl_aio_request_cache_destroy(); 2180 } 2181 2182 module_init(ovl_init); 2183 module_exit(ovl_exit); 2184