1e9be9d5eSMiklos Szeredi /* 2e9be9d5eSMiklos Szeredi * 3e9be9d5eSMiklos Szeredi * Copyright (C) 2011 Novell Inc. 4e9be9d5eSMiklos Szeredi * 5e9be9d5eSMiklos Szeredi * This program is free software; you can redistribute it and/or modify it 6e9be9d5eSMiklos Szeredi * under the terms of the GNU General Public License version 2 as published by 7e9be9d5eSMiklos Szeredi * the Free Software Foundation. 8e9be9d5eSMiklos Szeredi */ 9e9be9d5eSMiklos Szeredi 105b825c3aSIngo Molnar #include <uapi/linux/magic.h> 11e9be9d5eSMiklos Szeredi #include <linux/fs.h> 12e9be9d5eSMiklos Szeredi #include <linux/namei.h> 13e9be9d5eSMiklos Szeredi #include <linux/xattr.h> 14e9be9d5eSMiklos Szeredi #include <linux/mount.h> 15e9be9d5eSMiklos Szeredi #include <linux/parser.h> 16e9be9d5eSMiklos Szeredi #include <linux/module.h> 17cc259639SAndy Whitcroft #include <linux/statfs.h> 18f45827e8SErez Zadok #include <linux/seq_file.h> 19d837a49bSMiklos Szeredi #include <linux/posix_acl_xattr.h> 20e9be9d5eSMiklos Szeredi #include "overlayfs.h" 21e9be9d5eSMiklos Szeredi 22e9be9d5eSMiklos Szeredi MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 23e9be9d5eSMiklos Szeredi MODULE_DESCRIPTION("Overlay filesystem"); 24e9be9d5eSMiklos Szeredi MODULE_LICENSE("GPL"); 25e9be9d5eSMiklos Szeredi 26e9be9d5eSMiklos Szeredi 27e9be9d5eSMiklos Szeredi struct ovl_dir_cache; 28e9be9d5eSMiklos Szeredi 29a78d9f0dSMiklos Szeredi #define OVL_MAX_STACK 500 30a78d9f0dSMiklos Szeredi 31688ea0e5SMiklos Szeredi static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR); 32688ea0e5SMiklos Szeredi module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644); 33688ea0e5SMiklos Szeredi MODULE_PARM_DESC(ovl_redirect_dir_def, 34688ea0e5SMiklos Szeredi "Default to on or off for the redirect_dir feature"); 35e9be9d5eSMiklos Szeredi 36438c84c2SMiklos Szeredi static bool ovl_redirect_always_follow = 37438c84c2SMiklos Szeredi IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW); 38438c84c2SMiklos Szeredi module_param_named(redirect_always_follow, ovl_redirect_always_follow, 39438c84c2SMiklos Szeredi bool, 0644); 40438c84c2SMiklos Szeredi MODULE_PARM_DESC(ovl_redirect_always_follow, 41438c84c2SMiklos Szeredi "Follow redirects even if redirect_dir feature is turned off"); 42438c84c2SMiklos Szeredi 4302bcd157SAmir Goldstein static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX); 4402bcd157SAmir Goldstein module_param_named(index, ovl_index_def, bool, 0644); 4502bcd157SAmir Goldstein MODULE_PARM_DESC(ovl_index_def, 4602bcd157SAmir Goldstein "Default to on or off for the inodes index feature"); 4702bcd157SAmir Goldstein 48f168f109SAmir Goldstein static bool ovl_nfs_export_def = IS_ENABLED(CONFIG_OVERLAY_FS_NFS_EXPORT); 49f168f109SAmir Goldstein module_param_named(nfs_export, ovl_nfs_export_def, bool, 0644); 50f168f109SAmir Goldstein MODULE_PARM_DESC(ovl_nfs_export_def, 51f168f109SAmir Goldstein "Default to on or off for the NFS export feature"); 52f168f109SAmir Goldstein 534155c10aSMiklos Szeredi static void ovl_entry_stack_free(struct ovl_entry *oe) 544155c10aSMiklos Szeredi { 554155c10aSMiklos Szeredi unsigned int i; 564155c10aSMiklos Szeredi 574155c10aSMiklos Szeredi for (i = 0; i < oe->numlower; i++) 584155c10aSMiklos Szeredi dput(oe->lowerstack[i].dentry); 594155c10aSMiklos Szeredi } 604155c10aSMiklos Szeredi 61e9be9d5eSMiklos Szeredi static void ovl_dentry_release(struct dentry *dentry) 62e9be9d5eSMiklos Szeredi { 63e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 64e9be9d5eSMiklos Szeredi 65e9be9d5eSMiklos Szeredi if (oe) { 664155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 67e9be9d5eSMiklos Szeredi kfree_rcu(oe, rcu); 68e9be9d5eSMiklos Szeredi } 69e9be9d5eSMiklos Szeredi } 70e9be9d5eSMiklos Szeredi 71b0990fbbSAmir Goldstein static int ovl_check_append_only(struct inode *inode, int flag) 72b0990fbbSAmir Goldstein { 73b0990fbbSAmir Goldstein /* 74b0990fbbSAmir Goldstein * This test was moot in vfs may_open() because overlay inode does 75b0990fbbSAmir Goldstein * not have the S_APPEND flag, so re-check on real upper inode 76b0990fbbSAmir Goldstein */ 77b0990fbbSAmir Goldstein if (IS_APPEND(inode)) { 78b0990fbbSAmir Goldstein if ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND)) 79b0990fbbSAmir Goldstein return -EPERM; 80b0990fbbSAmir Goldstein if (flag & O_TRUNC) 81b0990fbbSAmir Goldstein return -EPERM; 82b0990fbbSAmir Goldstein } 83b0990fbbSAmir Goldstein 84b0990fbbSAmir Goldstein return 0; 85b0990fbbSAmir Goldstein } 86b0990fbbSAmir Goldstein 872d902671SMiklos Szeredi static struct dentry *ovl_d_real(struct dentry *dentry, 882d902671SMiklos Szeredi const struct inode *inode, 89495e6429SMiklos Szeredi unsigned int open_flags, unsigned int flags) 90d101a125SMiklos Szeredi { 91d101a125SMiklos Szeredi struct dentry *real; 92b0990fbbSAmir Goldstein int err; 93d101a125SMiklos Szeredi 94cd91304eSMiklos Szeredi if (flags & D_REAL_UPPER) 95cd91304eSMiklos Szeredi return ovl_dentry_upper(dentry); 96cd91304eSMiklos Szeredi 97ca4c8a3aSMiklos Szeredi if (!d_is_reg(dentry)) { 98d101a125SMiklos Szeredi if (!inode || inode == d_inode(dentry)) 99d101a125SMiklos Szeredi return dentry; 100d101a125SMiklos Szeredi goto bug; 101d101a125SMiklos Szeredi } 102d101a125SMiklos Szeredi 1032d902671SMiklos Szeredi if (open_flags) { 104b0990fbbSAmir Goldstein err = ovl_open_maybe_copy_up(dentry, open_flags); 1052d902671SMiklos Szeredi if (err) 1062d902671SMiklos Szeredi return ERR_PTR(err); 1072d902671SMiklos Szeredi } 1082d902671SMiklos Szeredi 109d101a125SMiklos Szeredi real = ovl_dentry_upper(dentry); 110b0990fbbSAmir Goldstein if (real && (!inode || inode == d_inode(real))) { 111b0990fbbSAmir Goldstein if (!inode) { 112b0990fbbSAmir Goldstein err = ovl_check_append_only(d_inode(real), open_flags); 113b0990fbbSAmir Goldstein if (err) 114b0990fbbSAmir Goldstein return ERR_PTR(err); 115b0990fbbSAmir Goldstein } 116d101a125SMiklos Szeredi return real; 117b0990fbbSAmir Goldstein } 118d101a125SMiklos Szeredi 119d101a125SMiklos Szeredi real = ovl_dentry_lower(dentry); 120d101a125SMiklos Szeredi if (!real) 121d101a125SMiklos Szeredi goto bug; 122d101a125SMiklos Szeredi 123c4fcfc16SMiklos Szeredi /* Handle recursion */ 124495e6429SMiklos Szeredi real = d_real(real, inode, open_flags, 0); 125c4fcfc16SMiklos Szeredi 126d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 127d101a125SMiklos Szeredi return real; 128d101a125SMiklos Szeredi bug: 129656189d2SMiklos Szeredi WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry, 130d101a125SMiklos Szeredi inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0); 131d101a125SMiklos Szeredi return dentry; 132d101a125SMiklos Szeredi } 133d101a125SMiklos Szeredi 1347c03b5d4SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 1357c03b5d4SMiklos Szeredi { 1367c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1377c03b5d4SMiklos Szeredi unsigned int i; 1387c03b5d4SMiklos Szeredi int ret = 1; 1397c03b5d4SMiklos Szeredi 1407c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1417c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1427c03b5d4SMiklos Szeredi 1437c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_REVALIDATE) { 1447c03b5d4SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1457c03b5d4SMiklos Szeredi if (ret < 0) 1467c03b5d4SMiklos Szeredi return ret; 1477c03b5d4SMiklos Szeredi if (!ret) { 1487c03b5d4SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1497c03b5d4SMiklos Szeredi d_invalidate(d); 1507c03b5d4SMiklos Szeredi return -ESTALE; 1517c03b5d4SMiklos Szeredi } 1527c03b5d4SMiklos Szeredi } 1537c03b5d4SMiklos Szeredi } 1547c03b5d4SMiklos Szeredi return 1; 1557c03b5d4SMiklos Szeredi } 1567c03b5d4SMiklos Szeredi 1577c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 1587c03b5d4SMiklos Szeredi { 1597c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1607c03b5d4SMiklos Szeredi unsigned int i; 1617c03b5d4SMiklos Szeredi int ret = 1; 1627c03b5d4SMiklos Szeredi 1637c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1647c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1657c03b5d4SMiklos Szeredi 1667c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) { 1677c03b5d4SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1687c03b5d4SMiklos Szeredi if (ret <= 0) 1697c03b5d4SMiklos Szeredi break; 1707c03b5d4SMiklos Szeredi } 1717c03b5d4SMiklos Szeredi } 1727c03b5d4SMiklos Szeredi return ret; 1737c03b5d4SMiklos Szeredi } 1747c03b5d4SMiklos Szeredi 175e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 176e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 177d101a125SMiklos Szeredi .d_real = ovl_d_real, 178e9be9d5eSMiklos Szeredi }; 179e9be9d5eSMiklos Szeredi 1807c03b5d4SMiklos Szeredi static const struct dentry_operations ovl_reval_dentry_operations = { 1817c03b5d4SMiklos Szeredi .d_release = ovl_dentry_release, 182d101a125SMiklos Szeredi .d_real = ovl_d_real, 1837c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1847c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1857c03b5d4SMiklos Szeredi }; 1867c03b5d4SMiklos Szeredi 18713cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 18813cf199dSAmir Goldstein 18913cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 19013cf199dSAmir Goldstein { 19113cf199dSAmir Goldstein struct ovl_inode *oi = kmem_cache_alloc(ovl_inode_cachep, GFP_KERNEL); 19213cf199dSAmir Goldstein 193b3885bd6SHirofumi Nakagawa if (!oi) 194b3885bd6SHirofumi Nakagawa return NULL; 195b3885bd6SHirofumi Nakagawa 19604a01ac7SMiklos Szeredi oi->cache = NULL; 197cf31c463SMiklos Szeredi oi->redirect = NULL; 19804a01ac7SMiklos Szeredi oi->version = 0; 19913c72075SMiklos Szeredi oi->flags = 0; 20009d8b586SMiklos Szeredi oi->__upperdentry = NULL; 20125b7713aSMiklos Szeredi oi->lower = NULL; 202a015dafcSAmir Goldstein mutex_init(&oi->lock); 20325b7713aSMiklos Szeredi 20413cf199dSAmir Goldstein return &oi->vfs_inode; 20513cf199dSAmir Goldstein } 20613cf199dSAmir Goldstein 20713cf199dSAmir Goldstein static void ovl_i_callback(struct rcu_head *head) 20813cf199dSAmir Goldstein { 20913cf199dSAmir Goldstein struct inode *inode = container_of(head, struct inode, i_rcu); 21013cf199dSAmir Goldstein 21113cf199dSAmir Goldstein kmem_cache_free(ovl_inode_cachep, OVL_I(inode)); 21213cf199dSAmir Goldstein } 21313cf199dSAmir Goldstein 21413cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 21513cf199dSAmir Goldstein { 21609d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 21709d8b586SMiklos Szeredi 21809d8b586SMiklos Szeredi dput(oi->__upperdentry); 21931747edaSAmir Goldstein iput(oi->lower); 220cf31c463SMiklos Szeredi kfree(oi->redirect); 2214edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 222a015dafcSAmir Goldstein mutex_destroy(&oi->lock); 22309d8b586SMiklos Szeredi 22413cf199dSAmir Goldstein call_rcu(&inode->i_rcu, ovl_i_callback); 22513cf199dSAmir Goldstein } 22613cf199dSAmir Goldstein 227ad204488SMiklos Szeredi static void ovl_free_fs(struct ovl_fs *ofs) 228e9be9d5eSMiklos Szeredi { 229dd662667SMiklos Szeredi unsigned i; 230e9be9d5eSMiklos Szeredi 231ad204488SMiklos Szeredi dput(ofs->indexdir); 232ad204488SMiklos Szeredi dput(ofs->workdir); 233ad204488SMiklos Szeredi if (ofs->workdir_locked) 234ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->workbasedir); 235ad204488SMiklos Szeredi dput(ofs->workbasedir); 236ad204488SMiklos Szeredi if (ofs->upperdir_locked) 237ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->upper_mnt->mnt_root); 238ad204488SMiklos Szeredi mntput(ofs->upper_mnt); 2395148626bSAmir Goldstein for (i = 0; i < ofs->numlower; i++) 240ad204488SMiklos Szeredi mntput(ofs->lower_layers[i].mnt); 2415148626bSAmir Goldstein for (i = 0; i < ofs->numlowerfs; i++) 2425148626bSAmir Goldstein free_anon_bdev(ofs->lower_fs[i].pseudo_dev); 243ad204488SMiklos Szeredi kfree(ofs->lower_layers); 2445148626bSAmir Goldstein kfree(ofs->lower_fs); 245e9be9d5eSMiklos Szeredi 246ad204488SMiklos Szeredi kfree(ofs->config.lowerdir); 247ad204488SMiklos Szeredi kfree(ofs->config.upperdir); 248ad204488SMiklos Szeredi kfree(ofs->config.workdir); 249438c84c2SMiklos Szeredi kfree(ofs->config.redirect_mode); 250ad204488SMiklos Szeredi if (ofs->creator_cred) 251ad204488SMiklos Szeredi put_cred(ofs->creator_cred); 252ad204488SMiklos Szeredi kfree(ofs); 253e9be9d5eSMiklos Szeredi } 254e9be9d5eSMiklos Szeredi 255a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 256a9075cdbSMiklos Szeredi { 257a9075cdbSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 258a9075cdbSMiklos Szeredi 259a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 260a9075cdbSMiklos Szeredi } 261a9075cdbSMiklos Szeredi 262e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */ 263e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 264e593b2bfSAmir Goldstein { 265ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 266e593b2bfSAmir Goldstein struct super_block *upper_sb; 267e593b2bfSAmir Goldstein int ret; 268e593b2bfSAmir Goldstein 269ad204488SMiklos Szeredi if (!ofs->upper_mnt) 270e593b2bfSAmir Goldstein return 0; 271e8d4bfe3SChengguang Xu 272e8d4bfe3SChengguang Xu /* 273e8d4bfe3SChengguang Xu * If this is a sync(2) call or an emergency sync, all the super blocks 274e8d4bfe3SChengguang Xu * will be iterated, including upper_sb, so no need to do anything. 275e8d4bfe3SChengguang Xu * 276e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call 277e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being 278e8d4bfe3SChengguang Xu * called with wait == 1. 279e8d4bfe3SChengguang Xu */ 280e8d4bfe3SChengguang Xu if (!wait) 281e593b2bfSAmir Goldstein return 0; 282e593b2bfSAmir Goldstein 283e8d4bfe3SChengguang Xu upper_sb = ofs->upper_mnt->mnt_sb; 284e8d4bfe3SChengguang Xu 285e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 286e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb); 287e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 288e8d4bfe3SChengguang Xu 289e593b2bfSAmir Goldstein return ret; 290e593b2bfSAmir Goldstein } 291e593b2bfSAmir Goldstein 292cc259639SAndy Whitcroft /** 293cc259639SAndy Whitcroft * ovl_statfs 294cc259639SAndy Whitcroft * @sb: The overlayfs super block 295cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 296cc259639SAndy Whitcroft * 297cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 2984ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 299cc259639SAndy Whitcroft */ 300cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 301cc259639SAndy Whitcroft { 302cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 303cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 304cc259639SAndy Whitcroft struct path path; 305cc259639SAndy Whitcroft int err; 306cc259639SAndy Whitcroft 3074ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 308cc259639SAndy Whitcroft 309cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 310cc259639SAndy Whitcroft if (!err) { 3116b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 312cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 313cc259639SAndy Whitcroft } 314cc259639SAndy Whitcroft 315cc259639SAndy Whitcroft return err; 316cc259639SAndy Whitcroft } 317cc259639SAndy Whitcroft 31802bcd157SAmir Goldstein /* Will this overlay be forced to mount/remount ro? */ 319ad204488SMiklos Szeredi static bool ovl_force_readonly(struct ovl_fs *ofs) 32002bcd157SAmir Goldstein { 321ad204488SMiklos Szeredi return (!ofs->upper_mnt || !ofs->workdir); 32202bcd157SAmir Goldstein } 32302bcd157SAmir Goldstein 324438c84c2SMiklos Szeredi static const char *ovl_redirect_mode_def(void) 325438c84c2SMiklos Szeredi { 326438c84c2SMiklos Szeredi return ovl_redirect_dir_def ? "on" : "off"; 327438c84c2SMiklos Szeredi } 328438c84c2SMiklos Szeredi 329f45827e8SErez Zadok /** 330f45827e8SErez Zadok * ovl_show_options 331f45827e8SErez Zadok * 332f45827e8SErez Zadok * Prints the mount options for a given superblock. 333f45827e8SErez Zadok * Returns zero; does not fail. 334f45827e8SErez Zadok */ 335f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 336f45827e8SErez Zadok { 337f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 338ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 339f45827e8SErez Zadok 340ad204488SMiklos Szeredi seq_show_option(m, "lowerdir", ofs->config.lowerdir); 341ad204488SMiklos Szeredi if (ofs->config.upperdir) { 342ad204488SMiklos Szeredi seq_show_option(m, "upperdir", ofs->config.upperdir); 343ad204488SMiklos Szeredi seq_show_option(m, "workdir", ofs->config.workdir); 34453a08cb9SMiklos Szeredi } 345ad204488SMiklos Szeredi if (ofs->config.default_permissions) 3468d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 347438c84c2SMiklos Szeredi if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0) 348438c84c2SMiklos Szeredi seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode); 349ad204488SMiklos Szeredi if (ofs->config.index != ovl_index_def) 350438c84c2SMiklos Szeredi seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 351f168f109SAmir Goldstein if (ofs->config.nfs_export != ovl_nfs_export_def) 352f168f109SAmir Goldstein seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ? 353f168f109SAmir Goldstein "on" : "off"); 354f45827e8SErez Zadok return 0; 355f45827e8SErez Zadok } 356f45827e8SErez Zadok 3573cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 3583cdf6fe9SSeunghun Lee { 359ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 3603cdf6fe9SSeunghun Lee 3611751e8a6SLinus Torvalds if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 3623cdf6fe9SSeunghun Lee return -EROFS; 3633cdf6fe9SSeunghun Lee 3643cdf6fe9SSeunghun Lee return 0; 3653cdf6fe9SSeunghun Lee } 3663cdf6fe9SSeunghun Lee 367e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 36813cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 36913cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 37013cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 371e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 372e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 373cc259639SAndy Whitcroft .statfs = ovl_statfs, 374f45827e8SErez Zadok .show_options = ovl_show_options, 3753cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 376e9be9d5eSMiklos Szeredi }; 377e9be9d5eSMiklos Szeredi 378e9be9d5eSMiklos Szeredi enum { 379e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 380e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 381e9be9d5eSMiklos Szeredi OPT_WORKDIR, 3828d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 383438c84c2SMiklos Szeredi OPT_REDIRECT_DIR, 38402bcd157SAmir Goldstein OPT_INDEX_ON, 38502bcd157SAmir Goldstein OPT_INDEX_OFF, 386f168f109SAmir Goldstein OPT_NFS_EXPORT_ON, 387f168f109SAmir Goldstein OPT_NFS_EXPORT_OFF, 388e9be9d5eSMiklos Szeredi OPT_ERR, 389e9be9d5eSMiklos Szeredi }; 390e9be9d5eSMiklos Szeredi 391e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 392e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 393e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 394e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 3958d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 396438c84c2SMiklos Szeredi {OPT_REDIRECT_DIR, "redirect_dir=%s"}, 39702bcd157SAmir Goldstein {OPT_INDEX_ON, "index=on"}, 39802bcd157SAmir Goldstein {OPT_INDEX_OFF, "index=off"}, 399f168f109SAmir Goldstein {OPT_NFS_EXPORT_ON, "nfs_export=on"}, 400f168f109SAmir Goldstein {OPT_NFS_EXPORT_OFF, "nfs_export=off"}, 401e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 402e9be9d5eSMiklos Szeredi }; 403e9be9d5eSMiklos Szeredi 40491c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 40591c77947SMiklos Szeredi { 40691c77947SMiklos Szeredi char *sbegin = *s; 40791c77947SMiklos Szeredi char *p; 40891c77947SMiklos Szeredi 40991c77947SMiklos Szeredi if (sbegin == NULL) 41091c77947SMiklos Szeredi return NULL; 41191c77947SMiklos Szeredi 41291c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 41391c77947SMiklos Szeredi if (*p == '\\') { 41491c77947SMiklos Szeredi p++; 41591c77947SMiklos Szeredi if (!*p) 41691c77947SMiklos Szeredi break; 41791c77947SMiklos Szeredi } else if (*p == ',') { 41891c77947SMiklos Szeredi *p = '\0'; 41991c77947SMiklos Szeredi *s = p + 1; 42091c77947SMiklos Szeredi return sbegin; 42191c77947SMiklos Szeredi } 42291c77947SMiklos Szeredi } 42391c77947SMiklos Szeredi *s = NULL; 42491c77947SMiklos Szeredi return sbegin; 42591c77947SMiklos Szeredi } 42691c77947SMiklos Szeredi 427438c84c2SMiklos Szeredi static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode) 428438c84c2SMiklos Szeredi { 429438c84c2SMiklos Szeredi if (strcmp(mode, "on") == 0) { 430438c84c2SMiklos Szeredi config->redirect_dir = true; 431438c84c2SMiklos Szeredi /* 432438c84c2SMiklos Szeredi * Does not make sense to have redirect creation without 433438c84c2SMiklos Szeredi * redirect following. 434438c84c2SMiklos Szeredi */ 435438c84c2SMiklos Szeredi config->redirect_follow = true; 436438c84c2SMiklos Szeredi } else if (strcmp(mode, "follow") == 0) { 437438c84c2SMiklos Szeredi config->redirect_follow = true; 438438c84c2SMiklos Szeredi } else if (strcmp(mode, "off") == 0) { 439438c84c2SMiklos Szeredi if (ovl_redirect_always_follow) 440438c84c2SMiklos Szeredi config->redirect_follow = true; 441438c84c2SMiklos Szeredi } else if (strcmp(mode, "nofollow") != 0) { 442438c84c2SMiklos Szeredi pr_err("overlayfs: bad mount option \"redirect_dir=%s\"\n", 443438c84c2SMiklos Szeredi mode); 444438c84c2SMiklos Szeredi return -EINVAL; 445438c84c2SMiklos Szeredi } 446438c84c2SMiklos Szeredi 447438c84c2SMiklos Szeredi return 0; 448438c84c2SMiklos Szeredi } 449438c84c2SMiklos Szeredi 450e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 451e9be9d5eSMiklos Szeredi { 452e9be9d5eSMiklos Szeredi char *p; 453e9be9d5eSMiklos Szeredi 454438c84c2SMiklos Szeredi config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL); 455438c84c2SMiklos Szeredi if (!config->redirect_mode) 456438c84c2SMiklos Szeredi return -ENOMEM; 457438c84c2SMiklos Szeredi 45891c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 459e9be9d5eSMiklos Szeredi int token; 460e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 461e9be9d5eSMiklos Szeredi 462e9be9d5eSMiklos Szeredi if (!*p) 463e9be9d5eSMiklos Szeredi continue; 464e9be9d5eSMiklos Szeredi 465e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 466e9be9d5eSMiklos Szeredi switch (token) { 467e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 468e9be9d5eSMiklos Szeredi kfree(config->upperdir); 469e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 470e9be9d5eSMiklos Szeredi if (!config->upperdir) 471e9be9d5eSMiklos Szeredi return -ENOMEM; 472e9be9d5eSMiklos Szeredi break; 473e9be9d5eSMiklos Szeredi 474e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 475e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 476e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 477e9be9d5eSMiklos Szeredi if (!config->lowerdir) 478e9be9d5eSMiklos Szeredi return -ENOMEM; 479e9be9d5eSMiklos Szeredi break; 480e9be9d5eSMiklos Szeredi 481e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 482e9be9d5eSMiklos Szeredi kfree(config->workdir); 483e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 484e9be9d5eSMiklos Szeredi if (!config->workdir) 485e9be9d5eSMiklos Szeredi return -ENOMEM; 486e9be9d5eSMiklos Szeredi break; 487e9be9d5eSMiklos Szeredi 4888d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 4898d3095f4SMiklos Szeredi config->default_permissions = true; 4908d3095f4SMiklos Szeredi break; 4918d3095f4SMiklos Szeredi 492438c84c2SMiklos Szeredi case OPT_REDIRECT_DIR: 493438c84c2SMiklos Szeredi kfree(config->redirect_mode); 494438c84c2SMiklos Szeredi config->redirect_mode = match_strdup(&args[0]); 495438c84c2SMiklos Szeredi if (!config->redirect_mode) 496438c84c2SMiklos Szeredi return -ENOMEM; 497a6c60655SMiklos Szeredi break; 498a6c60655SMiklos Szeredi 49902bcd157SAmir Goldstein case OPT_INDEX_ON: 50002bcd157SAmir Goldstein config->index = true; 50102bcd157SAmir Goldstein break; 50202bcd157SAmir Goldstein 50302bcd157SAmir Goldstein case OPT_INDEX_OFF: 50402bcd157SAmir Goldstein config->index = false; 50502bcd157SAmir Goldstein break; 50602bcd157SAmir Goldstein 507f168f109SAmir Goldstein case OPT_NFS_EXPORT_ON: 508f168f109SAmir Goldstein config->nfs_export = true; 509f168f109SAmir Goldstein break; 510f168f109SAmir Goldstein 511f168f109SAmir Goldstein case OPT_NFS_EXPORT_OFF: 512f168f109SAmir Goldstein config->nfs_export = false; 513f168f109SAmir Goldstein break; 514f168f109SAmir Goldstein 515e9be9d5eSMiklos Szeredi default: 516bead55efShujianyang pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p); 517e9be9d5eSMiklos Szeredi return -EINVAL; 518e9be9d5eSMiklos Szeredi } 519e9be9d5eSMiklos Szeredi } 52071cbad7eShujianyang 52171cbad7eShujianyang /* Workdir is useless in non-upper mount */ 52271cbad7eShujianyang if (!config->upperdir && config->workdir) { 52371cbad7eShujianyang pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 52471cbad7eShujianyang config->workdir); 52571cbad7eShujianyang kfree(config->workdir); 52671cbad7eShujianyang config->workdir = NULL; 52771cbad7eShujianyang } 52871cbad7eShujianyang 529438c84c2SMiklos Szeredi return ovl_parse_redirect_mode(config, config->redirect_mode); 530e9be9d5eSMiklos Szeredi } 531e9be9d5eSMiklos Szeredi 532e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 53302bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 534e9be9d5eSMiklos Szeredi 535ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 5366b8aa129SAmir Goldstein const char *name, bool persist) 537e9be9d5eSMiklos Szeredi { 538ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 539ad204488SMiklos Szeredi struct vfsmount *mnt = ofs->upper_mnt; 540e9be9d5eSMiklos Szeredi struct dentry *work; 541e9be9d5eSMiklos Szeredi int err; 542e9be9d5eSMiklos Szeredi bool retried = false; 5436b8aa129SAmir Goldstein bool locked = false; 544e9be9d5eSMiklos Szeredi 5455955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 5466b8aa129SAmir Goldstein locked = true; 5476b8aa129SAmir Goldstein 548e9be9d5eSMiklos Szeredi retry: 549ad204488SMiklos Szeredi work = lookup_one_len(name, ofs->workbasedir, strlen(name)); 550e9be9d5eSMiklos Szeredi 551e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 552c11b9fddSMiklos Szeredi struct iattr attr = { 553c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 55432a3d848SAl Viro .ia_mode = S_IFDIR | 0, 555c11b9fddSMiklos Szeredi }; 556e9be9d5eSMiklos Szeredi 557e9be9d5eSMiklos Szeredi if (work->d_inode) { 558e9be9d5eSMiklos Szeredi err = -EEXIST; 559e9be9d5eSMiklos Szeredi if (retried) 560e9be9d5eSMiklos Szeredi goto out_dput; 561e9be9d5eSMiklos Szeredi 5626b8aa129SAmir Goldstein if (persist) 5636b8aa129SAmir Goldstein goto out_unlock; 5646b8aa129SAmir Goldstein 565e9be9d5eSMiklos Szeredi retried = true; 566eea2fb48SMiklos Szeredi ovl_workdir_cleanup(dir, mnt, work, 0); 567e9be9d5eSMiklos Szeredi dput(work); 568e9be9d5eSMiklos Szeredi goto retry; 569e9be9d5eSMiklos Szeredi } 570e9be9d5eSMiklos Szeredi 57132a3d848SAl Viro err = ovl_create_real(dir, work, 57232a3d848SAl Viro &(struct cattr){.mode = S_IFDIR | 0}, 57332a3d848SAl Viro NULL, true); 574e9be9d5eSMiklos Szeredi if (err) 575e9be9d5eSMiklos Szeredi goto out_dput; 576c11b9fddSMiklos Szeredi 577cb348edbSMiklos Szeredi /* 578cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 579cb348edbSMiklos Szeredi * 580cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 581cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 582cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 583cb348edbSMiklos Szeredi * 584cb348edbSMiklos Szeredi * There are various other error values that could effectively 585cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 586cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 587cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 588cb348edbSMiklos Szeredi * for the above two errors is sufficient. 589cb348edbSMiklos Szeredi */ 590c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 591e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 592c11b9fddSMiklos Szeredi goto out_dput; 593c11b9fddSMiklos Szeredi 594c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 595e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 596c11b9fddSMiklos Szeredi goto out_dput; 597c11b9fddSMiklos Szeredi 598c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 599c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 600c11b9fddSMiklos Szeredi err = notify_change(work, &attr, NULL); 601c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 602c11b9fddSMiklos Szeredi if (err) 603c11b9fddSMiklos Szeredi goto out_dput; 6046b8aa129SAmir Goldstein } else { 6056b8aa129SAmir Goldstein err = PTR_ERR(work); 6066b8aa129SAmir Goldstein goto out_err; 607e9be9d5eSMiklos Szeredi } 608e9be9d5eSMiklos Szeredi out_unlock: 6096b8aa129SAmir Goldstein if (locked) 6106b8aa129SAmir Goldstein inode_unlock(dir); 611e9be9d5eSMiklos Szeredi 612e9be9d5eSMiklos Szeredi return work; 613e9be9d5eSMiklos Szeredi 614e9be9d5eSMiklos Szeredi out_dput: 615e9be9d5eSMiklos Szeredi dput(work); 6166b8aa129SAmir Goldstein out_err: 6176b8aa129SAmir Goldstein pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n", 618ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 6196b8aa129SAmir Goldstein work = NULL; 620e9be9d5eSMiklos Szeredi goto out_unlock; 621e9be9d5eSMiklos Szeredi } 622e9be9d5eSMiklos Szeredi 62391c77947SMiklos Szeredi static void ovl_unescape(char *s) 62491c77947SMiklos Szeredi { 62591c77947SMiklos Szeredi char *d = s; 62691c77947SMiklos Szeredi 62791c77947SMiklos Szeredi for (;; s++, d++) { 62891c77947SMiklos Szeredi if (*s == '\\') 62991c77947SMiklos Szeredi s++; 63091c77947SMiklos Szeredi *d = *s; 63191c77947SMiklos Szeredi if (!*s) 63291c77947SMiklos Szeredi break; 63391c77947SMiklos Szeredi } 63491c77947SMiklos Szeredi } 63591c77947SMiklos Szeredi 636ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 637ab508822SMiklos Szeredi { 638a78d9f0dSMiklos Szeredi int err = -EINVAL; 639ab508822SMiklos Szeredi 640a78d9f0dSMiklos Szeredi if (!*name) { 641a78d9f0dSMiklos Szeredi pr_err("overlayfs: empty lowerdir\n"); 642a78d9f0dSMiklos Szeredi goto out; 643a78d9f0dSMiklos Szeredi } 644ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 645ab508822SMiklos Szeredi if (err) { 646ab508822SMiklos Szeredi pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); 647ab508822SMiklos Szeredi goto out; 648ab508822SMiklos Szeredi } 649ab508822SMiklos Szeredi err = -EINVAL; 6507c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 651ab508822SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported\n", name); 652ab508822SMiklos Szeredi goto out_put; 653ab508822SMiklos Szeredi } 6542b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 655ab508822SMiklos Szeredi pr_err("overlayfs: '%s' not a directory\n", name); 656ab508822SMiklos Szeredi goto out_put; 657ab508822SMiklos Szeredi } 658ab508822SMiklos Szeredi return 0; 659ab508822SMiklos Szeredi 660ab508822SMiklos Szeredi out_put: 6618aafcb59SMiklos Szeredi path_put_init(path); 662ab508822SMiklos Szeredi out: 663ab508822SMiklos Szeredi return err; 664ab508822SMiklos Szeredi } 665ab508822SMiklos Szeredi 666ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 667ab508822SMiklos Szeredi { 668ab508822SMiklos Szeredi int err = -ENOMEM; 669ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 670ab508822SMiklos Szeredi 671ab508822SMiklos Szeredi if (tmp) { 672ab508822SMiklos Szeredi ovl_unescape(tmp); 673ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 6747c03b5d4SMiklos Szeredi 6757c03b5d4SMiklos Szeredi if (!err) 6767c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) { 6777c03b5d4SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n", 6787c03b5d4SMiklos Szeredi tmp); 6798aafcb59SMiklos Szeredi path_put_init(path); 6807c03b5d4SMiklos Szeredi err = -EINVAL; 6817c03b5d4SMiklos Szeredi } 682ab508822SMiklos Szeredi kfree(tmp); 683ab508822SMiklos Szeredi } 684ab508822SMiklos Szeredi return err; 685ab508822SMiklos Szeredi } 686ab508822SMiklos Szeredi 6876b2d5fe4SMiklos Szeredi static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 6886b2d5fe4SMiklos Szeredi const char *name) 6896b2d5fe4SMiklos Szeredi { 6906b2d5fe4SMiklos Szeredi struct kstatfs statfs; 6916b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 6926b2d5fe4SMiklos Szeredi 6936b2d5fe4SMiklos Szeredi if (err) 6946b2d5fe4SMiklos Szeredi pr_err("overlayfs: statfs failed on '%s'\n", name); 6956b2d5fe4SMiklos Szeredi else 6966b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 6976b2d5fe4SMiklos Szeredi 6986b2d5fe4SMiklos Szeredi return err; 6996b2d5fe4SMiklos Szeredi } 7006b2d5fe4SMiklos Szeredi 7016b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 7026b2d5fe4SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth, bool *remote) 703ab508822SMiklos Szeredi { 704ab508822SMiklos Szeredi int err; 705ab508822SMiklos Szeredi 706a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 707ab508822SMiklos Szeredi if (err) 708ab508822SMiklos Szeredi goto out; 709ab508822SMiklos Szeredi 7106b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 7116b2d5fe4SMiklos Szeredi if (err) 712ab508822SMiklos Szeredi goto out_put; 7136b2d5fe4SMiklos Szeredi 714ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 715ab508822SMiklos Szeredi 7167c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) 7177c03b5d4SMiklos Szeredi *remote = true; 7187c03b5d4SMiklos Szeredi 71902bcd157SAmir Goldstein /* 720f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode 721f168f109SAmir Goldstein * file handles, so they require that all layers support them. 72202bcd157SAmir Goldstein */ 723f168f109SAmir Goldstein if ((ofs->config.nfs_export || 724f168f109SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && 725972d0093SAmir Goldstein !ovl_can_decode_fh(path->dentry->d_sb)) { 72602bcd157SAmir Goldstein ofs->config.index = false; 727f168f109SAmir Goldstein ofs->config.nfs_export = false; 728f168f109SAmir Goldstein pr_warn("overlayfs: fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 729f168f109SAmir Goldstein name); 73002bcd157SAmir Goldstein } 73102bcd157SAmir Goldstein 732ab508822SMiklos Szeredi return 0; 733ab508822SMiklos Szeredi 734ab508822SMiklos Szeredi out_put: 7358aafcb59SMiklos Szeredi path_put_init(path); 736ab508822SMiklos Szeredi out: 737ab508822SMiklos Szeredi return err; 738ab508822SMiklos Szeredi } 739ab508822SMiklos Szeredi 740e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 741e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 742e9be9d5eSMiklos Szeredi { 743e9be9d5eSMiklos Szeredi bool ok = false; 744e9be9d5eSMiklos Szeredi 745e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 746e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 747e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 748e9be9d5eSMiklos Szeredi } 749e9be9d5eSMiklos Szeredi return ok; 750e9be9d5eSMiklos Szeredi } 751e9be9d5eSMiklos Szeredi 752a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 753a78d9f0dSMiklos Szeredi { 754a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 755a78d9f0dSMiklos Szeredi char *s, *d; 756a78d9f0dSMiklos Szeredi 757a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 758a78d9f0dSMiklos Szeredi if (*s == '\\') { 759a78d9f0dSMiklos Szeredi s++; 760a78d9f0dSMiklos Szeredi } else if (*s == ':') { 761a78d9f0dSMiklos Szeredi *d = '\0'; 762a78d9f0dSMiklos Szeredi ctr++; 763a78d9f0dSMiklos Szeredi continue; 764a78d9f0dSMiklos Szeredi } 765a78d9f0dSMiklos Szeredi *d = *s; 766a78d9f0dSMiklos Szeredi if (!*s) 767a78d9f0dSMiklos Szeredi break; 768a78d9f0dSMiklos Szeredi } 769a78d9f0dSMiklos Szeredi return ctr; 770a78d9f0dSMiklos Szeredi } 771a78d9f0dSMiklos Szeredi 7720c97be22SAndreas Gruenbacher static int __maybe_unused 7730eb45fc3SAndreas Gruenbacher ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 7740eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 7750eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 7760eb45fc3SAndreas Gruenbacher { 7771d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 7780eb45fc3SAndreas Gruenbacher } 7790eb45fc3SAndreas Gruenbacher 7800eb45fc3SAndreas Gruenbacher static int __maybe_unused 7810c97be22SAndreas Gruenbacher ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 782d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 783d837a49bSMiklos Szeredi const char *name, const void *value, 784d837a49bSMiklos Szeredi size_t size, int flags) 785d837a49bSMiklos Szeredi { 786d837a49bSMiklos Szeredi struct dentry *workdir = ovl_workdir(dentry); 78709d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 788d837a49bSMiklos Szeredi struct posix_acl *acl = NULL; 789d837a49bSMiklos Szeredi int err; 790d837a49bSMiklos Szeredi 791d837a49bSMiklos Szeredi /* Check that everything is OK before copy-up */ 792d837a49bSMiklos Szeredi if (value) { 793d837a49bSMiklos Szeredi acl = posix_acl_from_xattr(&init_user_ns, value, size); 794d837a49bSMiklos Szeredi if (IS_ERR(acl)) 795d837a49bSMiklos Szeredi return PTR_ERR(acl); 796d837a49bSMiklos Szeredi } 797d837a49bSMiklos Szeredi err = -EOPNOTSUPP; 798d837a49bSMiklos Szeredi if (!IS_POSIXACL(d_inode(workdir))) 799d837a49bSMiklos Szeredi goto out_acl_release; 800d837a49bSMiklos Szeredi if (!realinode->i_op->set_acl) 801d837a49bSMiklos Szeredi goto out_acl_release; 802d837a49bSMiklos Szeredi if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 803d837a49bSMiklos Szeredi err = acl ? -EACCES : 0; 804d837a49bSMiklos Szeredi goto out_acl_release; 805d837a49bSMiklos Szeredi } 806d837a49bSMiklos Szeredi err = -EPERM; 807d837a49bSMiklos Szeredi if (!inode_owner_or_capable(inode)) 808d837a49bSMiklos Szeredi goto out_acl_release; 809d837a49bSMiklos Szeredi 810d837a49bSMiklos Szeredi posix_acl_release(acl); 811d837a49bSMiklos Szeredi 812fd3220d3SMiklos Szeredi /* 813fd3220d3SMiklos Szeredi * Check if sgid bit needs to be cleared (actual setacl operation will 814fd3220d3SMiklos Szeredi * be done with mounter's capabilities and so that won't do it for us). 815fd3220d3SMiklos Szeredi */ 816fd3220d3SMiklos Szeredi if (unlikely(inode->i_mode & S_ISGID) && 817fd3220d3SMiklos Szeredi handler->flags == ACL_TYPE_ACCESS && 818fd3220d3SMiklos Szeredi !in_group_p(inode->i_gid) && 819fd3220d3SMiklos Szeredi !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 820fd3220d3SMiklos Szeredi struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 821fd3220d3SMiklos Szeredi 822fd3220d3SMiklos Szeredi err = ovl_setattr(dentry, &iattr); 823fd3220d3SMiklos Szeredi if (err) 824fd3220d3SMiklos Szeredi return err; 825fd3220d3SMiklos Szeredi } 826fd3220d3SMiklos Szeredi 8271d88f183SMiklos Szeredi err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 828ce31513aSMiklos Szeredi if (!err) 82909d8b586SMiklos Szeredi ovl_copyattr(ovl_inode_real(inode), inode); 830ce31513aSMiklos Szeredi 831ce31513aSMiklos Szeredi return err; 832d837a49bSMiklos Szeredi 833d837a49bSMiklos Szeredi out_acl_release: 834d837a49bSMiklos Szeredi posix_acl_release(acl); 835d837a49bSMiklos Szeredi return err; 836d837a49bSMiklos Szeredi } 837d837a49bSMiklos Szeredi 8380eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 8390eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8400eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 8410eb45fc3SAndreas Gruenbacher { 84248fab5d7SAmir Goldstein return -EOPNOTSUPP; 8430eb45fc3SAndreas Gruenbacher } 8440eb45fc3SAndreas Gruenbacher 845d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 846d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 847d837a49bSMiklos Szeredi const char *name, const void *value, 848d837a49bSMiklos Szeredi size_t size, int flags) 849d837a49bSMiklos Szeredi { 85048fab5d7SAmir Goldstein return -EOPNOTSUPP; 851d837a49bSMiklos Szeredi } 852d837a49bSMiklos Szeredi 8530eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 8540eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8550eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 8560eb45fc3SAndreas Gruenbacher { 8571d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 8580eb45fc3SAndreas Gruenbacher } 8590eb45fc3SAndreas Gruenbacher 8600e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 8610e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8620e585cccSAndreas Gruenbacher const char *name, const void *value, 8630e585cccSAndreas Gruenbacher size_t size, int flags) 8640e585cccSAndreas Gruenbacher { 8651d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 8660e585cccSAndreas Gruenbacher } 8670e585cccSAndreas Gruenbacher 8680c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 8690c97be22SAndreas Gruenbacher ovl_posix_acl_access_xattr_handler = { 870d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_ACCESS, 871d837a49bSMiklos Szeredi .flags = ACL_TYPE_ACCESS, 8720eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 873d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 874d837a49bSMiklos Szeredi }; 875d837a49bSMiklos Szeredi 8760c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 8770c97be22SAndreas Gruenbacher ovl_posix_acl_default_xattr_handler = { 878d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_DEFAULT, 879d837a49bSMiklos Szeredi .flags = ACL_TYPE_DEFAULT, 8800eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 881d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 882d837a49bSMiklos Szeredi }; 883d837a49bSMiklos Szeredi 884d837a49bSMiklos Szeredi static const struct xattr_handler ovl_own_xattr_handler = { 885d837a49bSMiklos Szeredi .prefix = OVL_XATTR_PREFIX, 8860eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 887d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 888d837a49bSMiklos Szeredi }; 889d837a49bSMiklos Szeredi 890d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 891d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 8920eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 893d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 894d837a49bSMiklos Szeredi }; 895d837a49bSMiklos Szeredi 896d837a49bSMiklos Szeredi static const struct xattr_handler *ovl_xattr_handlers[] = { 8970c97be22SAndreas Gruenbacher #ifdef CONFIG_FS_POSIX_ACL 898d837a49bSMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 899d837a49bSMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 9000c97be22SAndreas Gruenbacher #endif 901d837a49bSMiklos Szeredi &ovl_own_xattr_handler, 902d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 903d837a49bSMiklos Szeredi NULL 904d837a49bSMiklos Szeredi }; 905d837a49bSMiklos Szeredi 906ad204488SMiklos Szeredi static int ovl_get_upper(struct ovl_fs *ofs, struct path *upperpath) 9076ee8acf0SMiklos Szeredi { 9085064975eSMiklos Szeredi struct vfsmount *upper_mnt; 9096ee8acf0SMiklos Szeredi int err; 9106ee8acf0SMiklos Szeredi 911ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.upperdir, upperpath); 9126ee8acf0SMiklos Szeredi if (err) 9136ee8acf0SMiklos Szeredi goto out; 9146ee8acf0SMiklos Szeredi 9156ee8acf0SMiklos Szeredi /* Upper fs should not be r/o */ 9166ee8acf0SMiklos Szeredi if (sb_rdonly(upperpath->mnt->mnt_sb)) { 9176ee8acf0SMiklos Szeredi pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n"); 9186ee8acf0SMiklos Szeredi err = -EINVAL; 9196ee8acf0SMiklos Szeredi goto out; 9206ee8acf0SMiklos Szeredi } 9216ee8acf0SMiklos Szeredi 922ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 9236ee8acf0SMiklos Szeredi if (err) 9246ee8acf0SMiklos Szeredi goto out; 9256ee8acf0SMiklos Szeredi 9266ee8acf0SMiklos Szeredi err = -EBUSY; 9276ee8acf0SMiklos Szeredi if (ovl_inuse_trylock(upperpath->dentry)) { 928ad204488SMiklos Szeredi ofs->upperdir_locked = true; 929ad204488SMiklos Szeredi } else if (ofs->config.index) { 9306ee8acf0SMiklos Szeredi pr_err("overlayfs: upperdir is in-use by another mount, mount with '-o index=off' to override exclusive upperdir protection.\n"); 9316ee8acf0SMiklos Szeredi goto out; 9326ee8acf0SMiklos Szeredi } else { 9336ee8acf0SMiklos Szeredi pr_warn("overlayfs: upperdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 9346ee8acf0SMiklos Szeredi } 9355064975eSMiklos Szeredi 9365064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 9375064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 9385064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 9395064975eSMiklos Szeredi pr_err("overlayfs: failed to clone upperpath\n"); 9405064975eSMiklos Szeredi goto out; 9415064975eSMiklos Szeredi } 9425064975eSMiklos Szeredi 9435064975eSMiklos Szeredi /* Don't inherit atime flags */ 9445064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 945ad204488SMiklos Szeredi ofs->upper_mnt = upper_mnt; 9466ee8acf0SMiklos Szeredi err = 0; 9476ee8acf0SMiklos Szeredi out: 9486ee8acf0SMiklos Szeredi return err; 9496ee8acf0SMiklos Szeredi } 9506ee8acf0SMiklos Szeredi 951ad204488SMiklos Szeredi static int ovl_make_workdir(struct ovl_fs *ofs, struct path *workpath) 9528ed61dc3SMiklos Szeredi { 9532ba9d57eSAmir Goldstein struct vfsmount *mnt = ofs->upper_mnt; 9548ed61dc3SMiklos Szeredi struct dentry *temp; 9558ed61dc3SMiklos Szeredi int err; 9568ed61dc3SMiklos Szeredi 9572ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 9582ba9d57eSAmir Goldstein if (err) 9592ba9d57eSAmir Goldstein return err; 9602ba9d57eSAmir Goldstein 961ad204488SMiklos Szeredi ofs->workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 962ad204488SMiklos Szeredi if (!ofs->workdir) 9632ba9d57eSAmir Goldstein goto out; 9648ed61dc3SMiklos Szeredi 9658ed61dc3SMiklos Szeredi /* 9668ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 9678ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 9688ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 9698ed61dc3SMiklos Szeredi * previous step. 9708ed61dc3SMiklos Szeredi */ 9718ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 9728ed61dc3SMiklos Szeredi if (err < 0) 9732ba9d57eSAmir Goldstein goto out; 9748ed61dc3SMiklos Szeredi 9758ed61dc3SMiklos Szeredi /* 9768ed61dc3SMiklos Szeredi * We allowed this configuration and don't want to break users over 9778ed61dc3SMiklos Szeredi * kernel upgrade. So warn instead of erroring out. 9788ed61dc3SMiklos Szeredi */ 9798ed61dc3SMiklos Szeredi if (!err) 9808ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs needs to support d_type.\n"); 9818ed61dc3SMiklos Szeredi 9828ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 983ad204488SMiklos Szeredi temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0); 984ad204488SMiklos Szeredi ofs->tmpfile = !IS_ERR(temp); 985ad204488SMiklos Szeredi if (ofs->tmpfile) 9868ed61dc3SMiklos Szeredi dput(temp); 9878ed61dc3SMiklos Szeredi else 9888ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support tmpfile.\n"); 9898ed61dc3SMiklos Szeredi 9908ed61dc3SMiklos Szeredi /* 9918ed61dc3SMiklos Szeredi * Check if upper/work fs supports trusted.overlay.* xattr 9928ed61dc3SMiklos Szeredi */ 993ad204488SMiklos Szeredi err = ovl_do_setxattr(ofs->workdir, OVL_XATTR_OPAQUE, "0", 1, 0); 9948ed61dc3SMiklos Szeredi if (err) { 995ad204488SMiklos Szeredi ofs->noxattr = true; 996a683737bSAmir Goldstein ofs->config.index = false; 997a683737bSAmir Goldstein pr_warn("overlayfs: upper fs does not support xattr, falling back to index=off.\n"); 9982ba9d57eSAmir Goldstein err = 0; 9998ed61dc3SMiklos Szeredi } else { 1000ad204488SMiklos Szeredi vfs_removexattr(ofs->workdir, OVL_XATTR_OPAQUE); 10018ed61dc3SMiklos Szeredi } 10028ed61dc3SMiklos Szeredi 10038ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 1004ad204488SMiklos Szeredi if (ofs->config.index && 1005ad204488SMiklos Szeredi !ovl_can_decode_fh(ofs->workdir->d_sb)) { 1006ad204488SMiklos Szeredi ofs->config.index = false; 10078ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support file handles, falling back to index=off.\n"); 10088ed61dc3SMiklos Szeredi } 10098ed61dc3SMiklos Szeredi 1010f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */ 1011f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) { 1012f168f109SAmir Goldstein pr_warn("overlayfs: NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 1013f168f109SAmir Goldstein ofs->config.nfs_export = false; 1014f168f109SAmir Goldstein } 1015f168f109SAmir Goldstein 10162ba9d57eSAmir Goldstein out: 10172ba9d57eSAmir Goldstein mnt_drop_write(mnt); 10182ba9d57eSAmir Goldstein return err; 10198ed61dc3SMiklos Szeredi } 10208ed61dc3SMiklos Szeredi 1021ad204488SMiklos Szeredi static int ovl_get_workdir(struct ovl_fs *ofs, struct path *upperpath) 1022520d7c86SMiklos Szeredi { 1023520d7c86SMiklos Szeredi int err; 1024bca44b52SMiklos Szeredi struct path workpath = { }; 1025520d7c86SMiklos Szeredi 1026ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.workdir, &workpath); 1027520d7c86SMiklos Szeredi if (err) 1028520d7c86SMiklos Szeredi goto out; 1029520d7c86SMiklos Szeredi 1030520d7c86SMiklos Szeredi err = -EINVAL; 1031bca44b52SMiklos Szeredi if (upperpath->mnt != workpath.mnt) { 1032520d7c86SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 1033520d7c86SMiklos Szeredi goto out; 1034520d7c86SMiklos Szeredi } 1035bca44b52SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 1036520d7c86SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 1037520d7c86SMiklos Szeredi goto out; 1038520d7c86SMiklos Szeredi } 1039520d7c86SMiklos Szeredi 1040520d7c86SMiklos Szeredi err = -EBUSY; 1041bca44b52SMiklos Szeredi if (ovl_inuse_trylock(workpath.dentry)) { 1042ad204488SMiklos Szeredi ofs->workdir_locked = true; 1043ad204488SMiklos Szeredi } else if (ofs->config.index) { 1044520d7c86SMiklos Szeredi pr_err("overlayfs: workdir is in-use by another mount, mount with '-o index=off' to override exclusive workdir protection.\n"); 1045520d7c86SMiklos Szeredi goto out; 1046520d7c86SMiklos Szeredi } else { 1047520d7c86SMiklos Szeredi pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 1048520d7c86SMiklos Szeredi } 1049520d7c86SMiklos Szeredi 1050ad204488SMiklos Szeredi ofs->workbasedir = dget(workpath.dentry); 1051ad204488SMiklos Szeredi err = ovl_make_workdir(ofs, &workpath); 1052bca44b52SMiklos Szeredi if (err) 1053bca44b52SMiklos Szeredi goto out; 1054bca44b52SMiklos Szeredi 1055520d7c86SMiklos Szeredi err = 0; 1056520d7c86SMiklos Szeredi out: 1057bca44b52SMiklos Szeredi path_put(&workpath); 1058bca44b52SMiklos Szeredi 1059520d7c86SMiklos Szeredi return err; 1060520d7c86SMiklos Szeredi } 1061520d7c86SMiklos Szeredi 1062ad204488SMiklos Szeredi static int ovl_get_indexdir(struct ovl_fs *ofs, struct ovl_entry *oe, 106395e6d417SMiklos Szeredi struct path *upperpath) 1064f7e3a7d9SMiklos Szeredi { 10652ba9d57eSAmir Goldstein struct vfsmount *mnt = ofs->upper_mnt; 1066f7e3a7d9SMiklos Szeredi int err; 1067f7e3a7d9SMiklos Szeredi 10682ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 10692ba9d57eSAmir Goldstein if (err) 10702ba9d57eSAmir Goldstein return err; 10712ba9d57eSAmir Goldstein 1072f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 1073d9768076SAmir Goldstein err = ovl_verify_origin(upperpath->dentry, oe->lowerstack[0].dentry, 107405122443SAmir Goldstein true); 1075f7e3a7d9SMiklos Szeredi if (err) { 1076f7e3a7d9SMiklos Szeredi pr_err("overlayfs: failed to verify upper root origin\n"); 1077f7e3a7d9SMiklos Szeredi goto out; 1078f7e3a7d9SMiklos Szeredi } 1079f7e3a7d9SMiklos Szeredi 1080ad204488SMiklos Szeredi ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1081ad204488SMiklos Szeredi if (ofs->indexdir) { 1082ad1d615cSAmir Goldstein /* 1083ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir. 1084ad1d615cSAmir Goldstein * Older kernels stored upper fh in "trusted.overlay.origin" 1085ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to 1086ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr 1087ad1d615cSAmir Goldstein * "trusted.overlay.upper" to indicate that index may have 1088ad1d615cSAmir Goldstein * directory entries. 1089ad1d615cSAmir Goldstein */ 1090ad1d615cSAmir Goldstein if (ovl_check_origin_xattr(ofs->indexdir)) { 109105122443SAmir Goldstein err = ovl_verify_set_fh(ofs->indexdir, OVL_XATTR_ORIGIN, 1092ad1d615cSAmir Goldstein upperpath->dentry, true, false); 1093f7e3a7d9SMiklos Szeredi if (err) 1094ad1d615cSAmir Goldstein pr_err("overlayfs: failed to verify index dir 'origin' xattr\n"); 1095ad1d615cSAmir Goldstein } 1096ad1d615cSAmir Goldstein err = ovl_verify_upper(ofs->indexdir, upperpath->dentry, true); 1097ad1d615cSAmir Goldstein if (err) 1098ad1d615cSAmir Goldstein pr_err("overlayfs: failed to verify index dir 'upper' xattr\n"); 1099f7e3a7d9SMiklos Szeredi 1100f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 1101f7e3a7d9SMiklos Szeredi if (!err) 11021eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs); 1103f7e3a7d9SMiklos Szeredi } 1104ad204488SMiklos Szeredi if (err || !ofs->indexdir) 1105f7e3a7d9SMiklos Szeredi pr_warn("overlayfs: try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1106f7e3a7d9SMiklos Szeredi 1107f7e3a7d9SMiklos Szeredi out: 11082ba9d57eSAmir Goldstein mnt_drop_write(mnt); 1109f7e3a7d9SMiklos Szeredi return err; 1110f7e3a7d9SMiklos Szeredi } 1111f7e3a7d9SMiklos Szeredi 11125148626bSAmir Goldstein /* Get a unique fsid for the layer */ 11135148626bSAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, struct super_block *sb) 11145148626bSAmir Goldstein { 11155148626bSAmir Goldstein unsigned int i; 11165148626bSAmir Goldstein dev_t dev; 11175148626bSAmir Goldstein int err; 11185148626bSAmir Goldstein 11195148626bSAmir Goldstein /* fsid 0 is reserved for upper fs even with non upper overlay */ 11205148626bSAmir Goldstein if (ofs->upper_mnt && ofs->upper_mnt->mnt_sb == sb) 11215148626bSAmir Goldstein return 0; 11225148626bSAmir Goldstein 11235148626bSAmir Goldstein for (i = 0; i < ofs->numlowerfs; i++) { 11245148626bSAmir Goldstein if (ofs->lower_fs[i].sb == sb) 11255148626bSAmir Goldstein return i + 1; 11265148626bSAmir Goldstein } 11275148626bSAmir Goldstein 11285148626bSAmir Goldstein err = get_anon_bdev(&dev); 11295148626bSAmir Goldstein if (err) { 11305148626bSAmir Goldstein pr_err("overlayfs: failed to get anonymous bdev for lowerpath\n"); 11315148626bSAmir Goldstein return err; 11325148626bSAmir Goldstein } 11335148626bSAmir Goldstein 11345148626bSAmir Goldstein ofs->lower_fs[ofs->numlowerfs].sb = sb; 11355148626bSAmir Goldstein ofs->lower_fs[ofs->numlowerfs].pseudo_dev = dev; 11365148626bSAmir Goldstein ofs->numlowerfs++; 11375148626bSAmir Goldstein 11385148626bSAmir Goldstein return ofs->numlowerfs; 11395148626bSAmir Goldstein } 11405148626bSAmir Goldstein 1141ad204488SMiklos Szeredi static int ovl_get_lower_layers(struct ovl_fs *ofs, struct path *stack, 1142520d7c86SMiklos Szeredi unsigned int numlower) 1143520d7c86SMiklos Szeredi { 1144520d7c86SMiklos Szeredi int err; 1145520d7c86SMiklos Szeredi unsigned int i; 1146520d7c86SMiklos Szeredi 1147520d7c86SMiklos Szeredi err = -ENOMEM; 1148ad204488SMiklos Szeredi ofs->lower_layers = kcalloc(numlower, sizeof(struct ovl_layer), 1149520d7c86SMiklos Szeredi GFP_KERNEL); 1150ad204488SMiklos Szeredi if (ofs->lower_layers == NULL) 1151520d7c86SMiklos Szeredi goto out; 11525148626bSAmir Goldstein 11535148626bSAmir Goldstein ofs->lower_fs = kcalloc(numlower, sizeof(struct ovl_sb), 11545148626bSAmir Goldstein GFP_KERNEL); 11555148626bSAmir Goldstein if (ofs->lower_fs == NULL) 11565148626bSAmir Goldstein goto out; 11575148626bSAmir Goldstein 1158520d7c86SMiklos Szeredi for (i = 0; i < numlower; i++) { 1159520d7c86SMiklos Szeredi struct vfsmount *mnt; 11605148626bSAmir Goldstein int fsid; 1161520d7c86SMiklos Szeredi 11625148626bSAmir Goldstein err = fsid = ovl_get_fsid(ofs, stack[i].mnt->mnt_sb); 11635148626bSAmir Goldstein if (err < 0) 1164520d7c86SMiklos Szeredi goto out; 1165520d7c86SMiklos Szeredi 1166520d7c86SMiklos Szeredi mnt = clone_private_mount(&stack[i]); 1167520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1168520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 1169520d7c86SMiklos Szeredi pr_err("overlayfs: failed to clone lowerpath\n"); 1170520d7c86SMiklos Szeredi goto out; 1171520d7c86SMiklos Szeredi } 11725148626bSAmir Goldstein 1173520d7c86SMiklos Szeredi /* 1174520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1175520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1176520d7c86SMiklos Szeredi */ 1177520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1178520d7c86SMiklos Szeredi 1179ad204488SMiklos Szeredi ofs->lower_layers[ofs->numlower].mnt = mnt; 1180d583ed7dSAmir Goldstein ofs->lower_layers[ofs->numlower].idx = i + 1; 11815148626bSAmir Goldstein ofs->lower_layers[ofs->numlower].fsid = fsid; 11825148626bSAmir Goldstein if (fsid) { 11835148626bSAmir Goldstein ofs->lower_layers[ofs->numlower].fs = 11845148626bSAmir Goldstein &ofs->lower_fs[fsid - 1]; 11855148626bSAmir Goldstein } 1186ad204488SMiklos Szeredi ofs->numlower++; 1187520d7c86SMiklos Szeredi } 1188520d7c86SMiklos Szeredi err = 0; 1189520d7c86SMiklos Szeredi out: 1190520d7c86SMiklos Szeredi return err; 1191520d7c86SMiklos Szeredi } 1192520d7c86SMiklos Szeredi 11934155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1194ad204488SMiklos Szeredi struct ovl_fs *ofs) 119553dbb0b4SMiklos Szeredi { 119653dbb0b4SMiklos Szeredi int err; 119753dbb0b4SMiklos Szeredi char *lowertmp, *lower; 11984155c10aSMiklos Szeredi struct path *stack = NULL; 11994155c10aSMiklos Szeredi unsigned int stacklen, numlower = 0, i; 120053dbb0b4SMiklos Szeredi bool remote = false; 12014155c10aSMiklos Szeredi struct ovl_entry *oe; 120253dbb0b4SMiklos Szeredi 120353dbb0b4SMiklos Szeredi err = -ENOMEM; 1204ad204488SMiklos Szeredi lowertmp = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 120553dbb0b4SMiklos Szeredi if (!lowertmp) 12064155c10aSMiklos Szeredi goto out_err; 120753dbb0b4SMiklos Szeredi 120853dbb0b4SMiklos Szeredi err = -EINVAL; 120953dbb0b4SMiklos Szeredi stacklen = ovl_split_lowerdirs(lowertmp); 121053dbb0b4SMiklos Szeredi if (stacklen > OVL_MAX_STACK) { 121153dbb0b4SMiklos Szeredi pr_err("overlayfs: too many lower directories, limit is %d\n", 121253dbb0b4SMiklos Szeredi OVL_MAX_STACK); 12134155c10aSMiklos Szeredi goto out_err; 1214ad204488SMiklos Szeredi } else if (!ofs->config.upperdir && stacklen == 1) { 121553dbb0b4SMiklos Szeredi pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n"); 12164155c10aSMiklos Szeredi goto out_err; 1217f168f109SAmir Goldstein } else if (!ofs->config.upperdir && ofs->config.nfs_export && 1218f168f109SAmir Goldstein ofs->config.redirect_follow) { 1219f168f109SAmir Goldstein pr_warn("overlayfs: NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n"); 1220f168f109SAmir Goldstein ofs->config.nfs_export = false; 122153dbb0b4SMiklos Szeredi } 122253dbb0b4SMiklos Szeredi 122353dbb0b4SMiklos Szeredi err = -ENOMEM; 122453dbb0b4SMiklos Szeredi stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL); 122553dbb0b4SMiklos Szeredi if (!stack) 12264155c10aSMiklos Szeredi goto out_err; 122753dbb0b4SMiklos Szeredi 122853dbb0b4SMiklos Szeredi err = -EINVAL; 122953dbb0b4SMiklos Szeredi lower = lowertmp; 123053dbb0b4SMiklos Szeredi for (numlower = 0; numlower < stacklen; numlower++) { 1231ad204488SMiklos Szeredi err = ovl_lower_dir(lower, &stack[numlower], ofs, 123253dbb0b4SMiklos Szeredi &sb->s_stack_depth, &remote); 123353dbb0b4SMiklos Szeredi if (err) 12344155c10aSMiklos Szeredi goto out_err; 123553dbb0b4SMiklos Szeredi 123653dbb0b4SMiklos Szeredi lower = strchr(lower, '\0') + 1; 123753dbb0b4SMiklos Szeredi } 123853dbb0b4SMiklos Szeredi 123953dbb0b4SMiklos Szeredi err = -EINVAL; 124053dbb0b4SMiklos Szeredi sb->s_stack_depth++; 124153dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 124253dbb0b4SMiklos Szeredi pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 12434155c10aSMiklos Szeredi goto out_err; 124453dbb0b4SMiklos Szeredi } 124553dbb0b4SMiklos Szeredi 1246ad204488SMiklos Szeredi err = ovl_get_lower_layers(ofs, stack, numlower); 12474155c10aSMiklos Szeredi if (err) 12484155c10aSMiklos Szeredi goto out_err; 12494155c10aSMiklos Szeredi 12504155c10aSMiklos Szeredi err = -ENOMEM; 12514155c10aSMiklos Szeredi oe = ovl_alloc_entry(numlower); 12524155c10aSMiklos Szeredi if (!oe) 12534155c10aSMiklos Szeredi goto out_err; 12544155c10aSMiklos Szeredi 12554155c10aSMiklos Szeredi for (i = 0; i < numlower; i++) { 12564155c10aSMiklos Szeredi oe->lowerstack[i].dentry = dget(stack[i].dentry); 1257ad204488SMiklos Szeredi oe->lowerstack[i].layer = &ofs->lower_layers[i]; 12584155c10aSMiklos Szeredi } 125953dbb0b4SMiklos Szeredi 126053dbb0b4SMiklos Szeredi if (remote) 126153dbb0b4SMiklos Szeredi sb->s_d_op = &ovl_reval_dentry_operations; 126253dbb0b4SMiklos Szeredi else 126353dbb0b4SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 126453dbb0b4SMiklos Szeredi 126553dbb0b4SMiklos Szeredi out: 126653dbb0b4SMiklos Szeredi for (i = 0; i < numlower; i++) 126753dbb0b4SMiklos Szeredi path_put(&stack[i]); 126853dbb0b4SMiklos Szeredi kfree(stack); 12694155c10aSMiklos Szeredi kfree(lowertmp); 12704155c10aSMiklos Szeredi 12714155c10aSMiklos Szeredi return oe; 12724155c10aSMiklos Szeredi 12734155c10aSMiklos Szeredi out_err: 12744155c10aSMiklos Szeredi oe = ERR_PTR(err); 127553dbb0b4SMiklos Szeredi goto out; 127653dbb0b4SMiklos Szeredi } 127753dbb0b4SMiklos Szeredi 1278e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1279e9be9d5eSMiklos Szeredi { 128033006cdfSKees Cook struct path upperpath = { }; 1281e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 12824155c10aSMiklos Szeredi struct ovl_entry *oe; 1283ad204488SMiklos Szeredi struct ovl_fs *ofs; 128451f8f3c4SKonstantin Khlebnikov struct cred *cred; 1285e9be9d5eSMiklos Szeredi int err; 1286e9be9d5eSMiklos Szeredi 1287f45827e8SErez Zadok err = -ENOMEM; 1288ad204488SMiklos Szeredi ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1289ad204488SMiklos Szeredi if (!ofs) 1290e9be9d5eSMiklos Szeredi goto out; 1291e9be9d5eSMiklos Szeredi 1292ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1293c6fe6254SMiklos Szeredi if (!cred) 1294c6fe6254SMiklos Szeredi goto out_err; 1295c6fe6254SMiklos Szeredi 1296ad204488SMiklos Szeredi ofs->config.index = ovl_index_def; 1297f168f109SAmir Goldstein ofs->config.nfs_export = ovl_nfs_export_def; 1298ad204488SMiklos Szeredi err = ovl_parse_opt((char *) data, &ofs->config); 1299f45827e8SErez Zadok if (err) 1300a9075cdbSMiklos Szeredi goto out_err; 1301f45827e8SErez Zadok 1302e9be9d5eSMiklos Szeredi err = -EINVAL; 1303ad204488SMiklos Szeredi if (!ofs->config.lowerdir) { 130407f2af7bSKonstantin Khlebnikov if (!silent) 130553a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'lowerdir'\n"); 1306a9075cdbSMiklos Szeredi goto out_err; 130753a08cb9SMiklos Szeredi } 130853a08cb9SMiklos Szeredi 130953a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 1310cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 1311ad204488SMiklos Szeredi if (ofs->config.upperdir) { 1312ad204488SMiklos Szeredi if (!ofs->config.workdir) { 131353a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'workdir'\n"); 1314a9075cdbSMiklos Szeredi goto out_err; 1315e9be9d5eSMiklos Szeredi } 1316e9be9d5eSMiklos Szeredi 1317ad204488SMiklos Szeredi err = ovl_get_upper(ofs, &upperpath); 131821a3b317SMiklos Szeredi if (err) 1319a9075cdbSMiklos Szeredi goto out_err; 1320d719e8f2SMiklos Szeredi 1321ad204488SMiklos Szeredi err = ovl_get_workdir(ofs, &upperpath); 13228ed61dc3SMiklos Szeredi if (err) 1323a9075cdbSMiklos Szeredi goto out_err; 1324c6fe6254SMiklos Szeredi 1325ad204488SMiklos Szeredi if (!ofs->workdir) 13261751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 13276e88256eSMiklos Szeredi 1328ad204488SMiklos Szeredi sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth; 1329ad204488SMiklos Szeredi sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran; 1330c6fe6254SMiklos Szeredi 133121765194SVivek Goyal } 1332ad204488SMiklos Szeredi oe = ovl_get_lowerstack(sb, ofs); 13334155c10aSMiklos Szeredi err = PTR_ERR(oe); 13344155c10aSMiklos Szeredi if (IS_ERR(oe)) 1335a9075cdbSMiklos Szeredi goto out_err; 1336e9be9d5eSMiklos Szeredi 133771cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 1338ad204488SMiklos Szeredi if (!ofs->upper_mnt) 13391751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 1340e9be9d5eSMiklos Szeredi 1341ad204488SMiklos Szeredi if (!(ovl_force_readonly(ofs)) && ofs->config.index) { 1342ad204488SMiklos Szeredi err = ovl_get_indexdir(ofs, oe, &upperpath); 134354fb347eSAmir Goldstein if (err) 13444155c10aSMiklos Szeredi goto out_free_oe; 13456e88256eSMiklos Szeredi 1346972d0093SAmir Goldstein /* Force r/o mount with no index dir */ 1347972d0093SAmir Goldstein if (!ofs->indexdir) { 1348972d0093SAmir Goldstein dput(ofs->workdir); 1349972d0093SAmir Goldstein ofs->workdir = NULL; 13501751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 135102bcd157SAmir Goldstein } 135202bcd157SAmir Goldstein 1353972d0093SAmir Goldstein } 1354972d0093SAmir Goldstein 1355972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */ 1356f168f109SAmir Goldstein if (!ofs->indexdir) { 1357ad204488SMiklos Szeredi ofs->config.index = false; 1358f168f109SAmir Goldstein if (ofs->upper_mnt && ofs->config.nfs_export) { 1359f168f109SAmir Goldstein pr_warn("overlayfs: NFS export requires an index dir, falling back to nfs_export=off.\n"); 1360f168f109SAmir Goldstein ofs->config.nfs_export = false; 1361f168f109SAmir Goldstein } 1362f168f109SAmir Goldstein } 136302bcd157SAmir Goldstein 13648383f174SAmir Goldstein if (ofs->config.nfs_export) 13658383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations; 13668383f174SAmir Goldstein 136751f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 136851f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 136951f8f3c4SKonstantin Khlebnikov 1370655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1371655042ccSVivek Goyal sb->s_op = &ovl_super_operations; 1372655042ccSVivek Goyal sb->s_xattr = ovl_xattr_handlers; 1373ad204488SMiklos Szeredi sb->s_fs_info = ofs; 13741751e8a6SLinus Torvalds sb->s_flags |= SB_POSIXACL | SB_NOREMOTELOCK; 1375655042ccSVivek Goyal 1376c6fe6254SMiklos Szeredi err = -ENOMEM; 1377ca4c8a3aSMiklos Szeredi root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 1378e9be9d5eSMiklos Szeredi if (!root_dentry) 13794155c10aSMiklos Szeredi goto out_free_oe; 1380e9be9d5eSMiklos Szeredi 1381c62520a8SAmir Goldstein root_dentry->d_fsdata = oe; 1382c62520a8SAmir Goldstein 1383e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 1384f3a15685SAmir Goldstein if (upperpath.dentry) { 1385c62520a8SAmir Goldstein ovl_dentry_set_upper_alias(root_dentry); 138613c72075SMiklos Szeredi if (ovl_is_impuredir(upperpath.dentry)) 138713c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, d_inode(root_dentry)); 1388f3a15685SAmir Goldstein } 1389e9be9d5eSMiklos Szeredi 1390b79e05aaSAmir Goldstein /* Root is always merge -> can have whiteouts */ 1391b79e05aaSAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root_dentry)); 13922ca3c148SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root_dentry); 139309d8b586SMiklos Szeredi ovl_inode_init(d_inode(root_dentry), upperpath.dentry, 139409d8b586SMiklos Szeredi ovl_dentry_lower(root_dentry)); 1395ed06e069SMiklos Szeredi 1396e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1397e9be9d5eSMiklos Szeredi 1398e9be9d5eSMiklos Szeredi return 0; 1399e9be9d5eSMiklos Szeredi 14004155c10aSMiklos Szeredi out_free_oe: 14014155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 1402b9343632SChandan Rajendra kfree(oe); 14034155c10aSMiklos Szeredi out_err: 1404e9be9d5eSMiklos Szeredi path_put(&upperpath); 1405ad204488SMiklos Szeredi ovl_free_fs(ofs); 1406e9be9d5eSMiklos Szeredi out: 1407e9be9d5eSMiklos Szeredi return err; 1408e9be9d5eSMiklos Szeredi } 1409e9be9d5eSMiklos Szeredi 1410e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 1411e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 1412e9be9d5eSMiklos Szeredi { 1413e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 1414e9be9d5eSMiklos Szeredi } 1415e9be9d5eSMiklos Szeredi 1416e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 1417e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1418ef94b186SMiklos Szeredi .name = "overlay", 1419e9be9d5eSMiklos Szeredi .mount = ovl_mount, 1420e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 1421e9be9d5eSMiklos Szeredi }; 1422ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 1423e9be9d5eSMiklos Szeredi 142413cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 142513cf199dSAmir Goldstein { 142613cf199dSAmir Goldstein struct ovl_inode *oi = foo; 142713cf199dSAmir Goldstein 142813cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 142913cf199dSAmir Goldstein } 143013cf199dSAmir Goldstein 1431e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 1432e9be9d5eSMiklos Szeredi { 143313cf199dSAmir Goldstein int err; 143413cf199dSAmir Goldstein 143513cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 143613cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 143713cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 143813cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 143913cf199dSAmir Goldstein ovl_inode_init_once); 144013cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 144113cf199dSAmir Goldstein return -ENOMEM; 144213cf199dSAmir Goldstein 144313cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 144413cf199dSAmir Goldstein if (err) 144513cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 144613cf199dSAmir Goldstein 144713cf199dSAmir Goldstein return err; 1448e9be9d5eSMiklos Szeredi } 1449e9be9d5eSMiklos Szeredi 1450e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1451e9be9d5eSMiklos Szeredi { 1452e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 145313cf199dSAmir Goldstein 145413cf199dSAmir Goldstein /* 145513cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 145613cf199dSAmir Goldstein * destroy cache. 145713cf199dSAmir Goldstein */ 145813cf199dSAmir Goldstein rcu_barrier(); 145913cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 146013cf199dSAmir Goldstein 1461e9be9d5eSMiklos Szeredi } 1462e9be9d5eSMiklos Szeredi 1463e9be9d5eSMiklos Szeredi module_init(ovl_init); 1464e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1465