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> 20e487d889SAmir Goldstein #include <linux/exportfs.h> 21e9be9d5eSMiklos Szeredi #include "overlayfs.h" 22e9be9d5eSMiklos Szeredi 23e9be9d5eSMiklos Szeredi MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 24e9be9d5eSMiklos Szeredi MODULE_DESCRIPTION("Overlay filesystem"); 25e9be9d5eSMiklos Szeredi MODULE_LICENSE("GPL"); 26e9be9d5eSMiklos Szeredi 27e9be9d5eSMiklos Szeredi 28e9be9d5eSMiklos Szeredi struct ovl_dir_cache; 29e9be9d5eSMiklos Szeredi 30a78d9f0dSMiklos Szeredi #define OVL_MAX_STACK 500 31a78d9f0dSMiklos Szeredi 32688ea0e5SMiklos Szeredi static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR); 33688ea0e5SMiklos Szeredi module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644); 34688ea0e5SMiklos Szeredi MODULE_PARM_DESC(ovl_redirect_dir_def, 35688ea0e5SMiklos Szeredi "Default to on or off for the redirect_dir feature"); 36e9be9d5eSMiklos Szeredi 37438c84c2SMiklos Szeredi static bool ovl_redirect_always_follow = 38438c84c2SMiklos Szeredi IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW); 39438c84c2SMiklos Szeredi module_param_named(redirect_always_follow, ovl_redirect_always_follow, 40438c84c2SMiklos Szeredi bool, 0644); 41438c84c2SMiklos Szeredi MODULE_PARM_DESC(ovl_redirect_always_follow, 42438c84c2SMiklos Szeredi "Follow redirects even if redirect_dir feature is turned off"); 43438c84c2SMiklos Szeredi 4402bcd157SAmir Goldstein static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX); 4502bcd157SAmir Goldstein module_param_named(index, ovl_index_def, bool, 0644); 4602bcd157SAmir Goldstein MODULE_PARM_DESC(ovl_index_def, 4702bcd157SAmir Goldstein "Default to on or off for the inodes index feature"); 4802bcd157SAmir Goldstein 49f168f109SAmir Goldstein static bool ovl_nfs_export_def = IS_ENABLED(CONFIG_OVERLAY_FS_NFS_EXPORT); 50f168f109SAmir Goldstein module_param_named(nfs_export, ovl_nfs_export_def, bool, 0644); 51f168f109SAmir Goldstein MODULE_PARM_DESC(ovl_nfs_export_def, 52f168f109SAmir Goldstein "Default to on or off for the NFS export feature"); 53f168f109SAmir Goldstein 54795939a9SAmir Goldstein static bool ovl_xino_auto_def = IS_ENABLED(CONFIG_OVERLAY_FS_XINO_AUTO); 55795939a9SAmir Goldstein module_param_named(xino_auto, ovl_xino_auto_def, bool, 0644); 56795939a9SAmir Goldstein MODULE_PARM_DESC(ovl_xino_auto_def, 57795939a9SAmir Goldstein "Auto enable xino feature"); 58795939a9SAmir Goldstein 594155c10aSMiklos Szeredi static void ovl_entry_stack_free(struct ovl_entry *oe) 604155c10aSMiklos Szeredi { 614155c10aSMiklos Szeredi unsigned int i; 624155c10aSMiklos Szeredi 634155c10aSMiklos Szeredi for (i = 0; i < oe->numlower; i++) 644155c10aSMiklos Szeredi dput(oe->lowerstack[i].dentry); 654155c10aSMiklos Szeredi } 664155c10aSMiklos Szeredi 67d5791044SVivek Goyal static bool ovl_metacopy_def = IS_ENABLED(CONFIG_OVERLAY_FS_METACOPY); 68d5791044SVivek Goyal module_param_named(metacopy, ovl_metacopy_def, bool, 0644); 69d5791044SVivek Goyal MODULE_PARM_DESC(ovl_metacopy_def, 70d5791044SVivek Goyal "Default to on or off for the metadata only copy up feature"); 71d5791044SVivek Goyal 72e9be9d5eSMiklos Szeredi static void ovl_dentry_release(struct dentry *dentry) 73e9be9d5eSMiklos Szeredi { 74e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 75e9be9d5eSMiklos Szeredi 76e9be9d5eSMiklos Szeredi if (oe) { 774155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 78e9be9d5eSMiklos Szeredi kfree_rcu(oe, rcu); 79e9be9d5eSMiklos Szeredi } 80e9be9d5eSMiklos Szeredi } 81e9be9d5eSMiklos Szeredi 822d902671SMiklos Szeredi static struct dentry *ovl_d_real(struct dentry *dentry, 83fb16043bSMiklos Szeredi const struct inode *inode) 84d101a125SMiklos Szeredi { 85d101a125SMiklos Szeredi struct dentry *real; 86d101a125SMiklos Szeredi 87e8c985baSMiklos Szeredi /* It's an overlay file */ 88e8c985baSMiklos Szeredi if (inode && d_inode(dentry) == inode) 89e8c985baSMiklos Szeredi return dentry; 90e8c985baSMiklos Szeredi 91ca4c8a3aSMiklos Szeredi if (!d_is_reg(dentry)) { 92d101a125SMiklos Szeredi if (!inode || inode == d_inode(dentry)) 93d101a125SMiklos Szeredi return dentry; 94d101a125SMiklos Szeredi goto bug; 95d101a125SMiklos Szeredi } 96d101a125SMiklos Szeredi 97d101a125SMiklos Szeredi real = ovl_dentry_upper(dentry); 98fb16043bSMiklos Szeredi if (real && (!inode || inode == d_inode(real))) 99d101a125SMiklos Szeredi return real; 100d101a125SMiklos Szeredi 101d101a125SMiklos Szeredi real = ovl_dentry_lower(dentry); 102d101a125SMiklos Szeredi if (!real) 103d101a125SMiklos Szeredi goto bug; 104d101a125SMiklos Szeredi 105c4fcfc16SMiklos Szeredi /* Handle recursion */ 106fb16043bSMiklos Szeredi real = d_real(real, inode); 107c4fcfc16SMiklos Szeredi 108d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 109d101a125SMiklos Szeredi return real; 110d101a125SMiklos Szeredi bug: 111656189d2SMiklos Szeredi WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry, 112d101a125SMiklos Szeredi inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0); 113d101a125SMiklos Szeredi return dentry; 114d101a125SMiklos Szeredi } 115d101a125SMiklos Szeredi 1167c03b5d4SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 1177c03b5d4SMiklos Szeredi { 1187c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1197c03b5d4SMiklos Szeredi unsigned int i; 1207c03b5d4SMiklos Szeredi int ret = 1; 1217c03b5d4SMiklos Szeredi 1227c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1237c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1247c03b5d4SMiklos Szeredi 1257c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_REVALIDATE) { 1267c03b5d4SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1277c03b5d4SMiklos Szeredi if (ret < 0) 1287c03b5d4SMiklos Szeredi return ret; 1297c03b5d4SMiklos Szeredi if (!ret) { 1307c03b5d4SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1317c03b5d4SMiklos Szeredi d_invalidate(d); 1327c03b5d4SMiklos Szeredi return -ESTALE; 1337c03b5d4SMiklos Szeredi } 1347c03b5d4SMiklos Szeredi } 1357c03b5d4SMiklos Szeredi } 1367c03b5d4SMiklos Szeredi return 1; 1377c03b5d4SMiklos Szeredi } 1387c03b5d4SMiklos Szeredi 1397c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 1407c03b5d4SMiklos Szeredi { 1417c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1427c03b5d4SMiklos Szeredi unsigned int i; 1437c03b5d4SMiklos Szeredi int ret = 1; 1447c03b5d4SMiklos Szeredi 1457c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1467c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1477c03b5d4SMiklos Szeredi 1487c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) { 1497c03b5d4SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1507c03b5d4SMiklos Szeredi if (ret <= 0) 1517c03b5d4SMiklos Szeredi break; 1527c03b5d4SMiklos Szeredi } 1537c03b5d4SMiklos Szeredi } 1547c03b5d4SMiklos Szeredi return ret; 1557c03b5d4SMiklos Szeredi } 1567c03b5d4SMiklos Szeredi 157e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 158e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 159d101a125SMiklos Szeredi .d_real = ovl_d_real, 160e9be9d5eSMiklos Szeredi }; 161e9be9d5eSMiklos Szeredi 1627c03b5d4SMiklos Szeredi static const struct dentry_operations ovl_reval_dentry_operations = { 1637c03b5d4SMiklos Szeredi .d_release = ovl_dentry_release, 164d101a125SMiklos Szeredi .d_real = ovl_d_real, 1657c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1667c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1677c03b5d4SMiklos Szeredi }; 1687c03b5d4SMiklos Szeredi 16913cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 17013cf199dSAmir Goldstein 17113cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 17213cf199dSAmir Goldstein { 17313cf199dSAmir Goldstein struct ovl_inode *oi = kmem_cache_alloc(ovl_inode_cachep, GFP_KERNEL); 17413cf199dSAmir Goldstein 175b3885bd6SHirofumi Nakagawa if (!oi) 176b3885bd6SHirofumi Nakagawa return NULL; 177b3885bd6SHirofumi Nakagawa 17804a01ac7SMiklos Szeredi oi->cache = NULL; 179cf31c463SMiklos Szeredi oi->redirect = NULL; 18004a01ac7SMiklos Szeredi oi->version = 0; 18113c72075SMiklos Szeredi oi->flags = 0; 18209d8b586SMiklos Szeredi oi->__upperdentry = NULL; 18325b7713aSMiklos Szeredi oi->lower = NULL; 1842664bd08SVivek Goyal oi->lowerdata = NULL; 185a015dafcSAmir Goldstein mutex_init(&oi->lock); 18625b7713aSMiklos Szeredi 18713cf199dSAmir Goldstein return &oi->vfs_inode; 18813cf199dSAmir Goldstein } 18913cf199dSAmir Goldstein 19013cf199dSAmir Goldstein static void ovl_i_callback(struct rcu_head *head) 19113cf199dSAmir Goldstein { 19213cf199dSAmir Goldstein struct inode *inode = container_of(head, struct inode, i_rcu); 19313cf199dSAmir Goldstein 19413cf199dSAmir Goldstein kmem_cache_free(ovl_inode_cachep, OVL_I(inode)); 19513cf199dSAmir Goldstein } 19613cf199dSAmir Goldstein 19713cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 19813cf199dSAmir Goldstein { 19909d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 20009d8b586SMiklos Szeredi 20109d8b586SMiklos Szeredi dput(oi->__upperdentry); 20231747edaSAmir Goldstein iput(oi->lower); 2032664bd08SVivek Goyal if (S_ISDIR(inode->i_mode)) 2044edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 2052664bd08SVivek Goyal else 2062664bd08SVivek Goyal iput(oi->lowerdata); 2072664bd08SVivek Goyal kfree(oi->redirect); 208a015dafcSAmir Goldstein mutex_destroy(&oi->lock); 20909d8b586SMiklos Szeredi 21013cf199dSAmir Goldstein call_rcu(&inode->i_rcu, ovl_i_callback); 21113cf199dSAmir Goldstein } 21213cf199dSAmir Goldstein 213ad204488SMiklos Szeredi static void ovl_free_fs(struct ovl_fs *ofs) 214e9be9d5eSMiklos Szeredi { 215dd662667SMiklos Szeredi unsigned i; 216e9be9d5eSMiklos Szeredi 217ad204488SMiklos Szeredi dput(ofs->indexdir); 218ad204488SMiklos Szeredi dput(ofs->workdir); 219ad204488SMiklos Szeredi if (ofs->workdir_locked) 220ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->workbasedir); 221ad204488SMiklos Szeredi dput(ofs->workbasedir); 222ad204488SMiklos Szeredi if (ofs->upperdir_locked) 223ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->upper_mnt->mnt_root); 224ad204488SMiklos Szeredi mntput(ofs->upper_mnt); 2255148626bSAmir Goldstein for (i = 0; i < ofs->numlower; i++) 226ad204488SMiklos Szeredi mntput(ofs->lower_layers[i].mnt); 2275148626bSAmir Goldstein for (i = 0; i < ofs->numlowerfs; i++) 2285148626bSAmir Goldstein free_anon_bdev(ofs->lower_fs[i].pseudo_dev); 229ad204488SMiklos Szeredi kfree(ofs->lower_layers); 2305148626bSAmir Goldstein kfree(ofs->lower_fs); 231e9be9d5eSMiklos Szeredi 232ad204488SMiklos Szeredi kfree(ofs->config.lowerdir); 233ad204488SMiklos Szeredi kfree(ofs->config.upperdir); 234ad204488SMiklos Szeredi kfree(ofs->config.workdir); 235438c84c2SMiklos Szeredi kfree(ofs->config.redirect_mode); 236ad204488SMiklos Szeredi if (ofs->creator_cred) 237ad204488SMiklos Szeredi put_cred(ofs->creator_cred); 238ad204488SMiklos Szeredi kfree(ofs); 239e9be9d5eSMiklos Szeredi } 240e9be9d5eSMiklos Szeredi 241a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 242a9075cdbSMiklos Szeredi { 243a9075cdbSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 244a9075cdbSMiklos Szeredi 245a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 246a9075cdbSMiklos Szeredi } 247a9075cdbSMiklos Szeredi 248e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */ 249e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 250e593b2bfSAmir Goldstein { 251ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 252e593b2bfSAmir Goldstein struct super_block *upper_sb; 253e593b2bfSAmir Goldstein int ret; 254e593b2bfSAmir Goldstein 255ad204488SMiklos Szeredi if (!ofs->upper_mnt) 256e593b2bfSAmir Goldstein return 0; 257e8d4bfe3SChengguang Xu 258e8d4bfe3SChengguang Xu /* 259e8d4bfe3SChengguang Xu * If this is a sync(2) call or an emergency sync, all the super blocks 260e8d4bfe3SChengguang Xu * will be iterated, including upper_sb, so no need to do anything. 261e8d4bfe3SChengguang Xu * 262e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call 263e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being 264e8d4bfe3SChengguang Xu * called with wait == 1. 265e8d4bfe3SChengguang Xu */ 266e8d4bfe3SChengguang Xu if (!wait) 267e593b2bfSAmir Goldstein return 0; 268e593b2bfSAmir Goldstein 269e8d4bfe3SChengguang Xu upper_sb = ofs->upper_mnt->mnt_sb; 270e8d4bfe3SChengguang Xu 271e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 272e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb); 273e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 274e8d4bfe3SChengguang Xu 275e593b2bfSAmir Goldstein return ret; 276e593b2bfSAmir Goldstein } 277e593b2bfSAmir Goldstein 278cc259639SAndy Whitcroft /** 279cc259639SAndy Whitcroft * ovl_statfs 280cc259639SAndy Whitcroft * @sb: The overlayfs super block 281cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 282cc259639SAndy Whitcroft * 283cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 2844ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 285cc259639SAndy Whitcroft */ 286cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 287cc259639SAndy Whitcroft { 288cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 289cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 290cc259639SAndy Whitcroft struct path path; 291cc259639SAndy Whitcroft int err; 292cc259639SAndy Whitcroft 2934ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 294cc259639SAndy Whitcroft 295cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 296cc259639SAndy Whitcroft if (!err) { 2976b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 298cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 299cc259639SAndy Whitcroft } 300cc259639SAndy Whitcroft 301cc259639SAndy Whitcroft return err; 302cc259639SAndy Whitcroft } 303cc259639SAndy Whitcroft 30402bcd157SAmir Goldstein /* Will this overlay be forced to mount/remount ro? */ 305ad204488SMiklos Szeredi static bool ovl_force_readonly(struct ovl_fs *ofs) 30602bcd157SAmir Goldstein { 307ad204488SMiklos Szeredi return (!ofs->upper_mnt || !ofs->workdir); 30802bcd157SAmir Goldstein } 30902bcd157SAmir Goldstein 310438c84c2SMiklos Szeredi static const char *ovl_redirect_mode_def(void) 311438c84c2SMiklos Szeredi { 312438c84c2SMiklos Szeredi return ovl_redirect_dir_def ? "on" : "off"; 313438c84c2SMiklos Szeredi } 314438c84c2SMiklos Szeredi 315795939a9SAmir Goldstein enum { 316795939a9SAmir Goldstein OVL_XINO_OFF, 317795939a9SAmir Goldstein OVL_XINO_AUTO, 318795939a9SAmir Goldstein OVL_XINO_ON, 319795939a9SAmir Goldstein }; 320795939a9SAmir Goldstein 321795939a9SAmir Goldstein static const char * const ovl_xino_str[] = { 322795939a9SAmir Goldstein "off", 323795939a9SAmir Goldstein "auto", 324795939a9SAmir Goldstein "on", 325795939a9SAmir Goldstein }; 326795939a9SAmir Goldstein 327795939a9SAmir Goldstein static inline int ovl_xino_def(void) 328795939a9SAmir Goldstein { 329795939a9SAmir Goldstein return ovl_xino_auto_def ? OVL_XINO_AUTO : OVL_XINO_OFF; 330795939a9SAmir Goldstein } 331795939a9SAmir Goldstein 332f45827e8SErez Zadok /** 333f45827e8SErez Zadok * ovl_show_options 334f45827e8SErez Zadok * 335f45827e8SErez Zadok * Prints the mount options for a given superblock. 336f45827e8SErez Zadok * Returns zero; does not fail. 337f45827e8SErez Zadok */ 338f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 339f45827e8SErez Zadok { 340f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 341ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 342f45827e8SErez Zadok 343ad204488SMiklos Szeredi seq_show_option(m, "lowerdir", ofs->config.lowerdir); 344ad204488SMiklos Szeredi if (ofs->config.upperdir) { 345ad204488SMiklos Szeredi seq_show_option(m, "upperdir", ofs->config.upperdir); 346ad204488SMiklos Szeredi seq_show_option(m, "workdir", ofs->config.workdir); 34753a08cb9SMiklos Szeredi } 348ad204488SMiklos Szeredi if (ofs->config.default_permissions) 3498d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 350438c84c2SMiklos Szeredi if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0) 351438c84c2SMiklos Szeredi seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode); 352ad204488SMiklos Szeredi if (ofs->config.index != ovl_index_def) 353438c84c2SMiklos Szeredi seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 354f168f109SAmir Goldstein if (ofs->config.nfs_export != ovl_nfs_export_def) 355f168f109SAmir Goldstein seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ? 356f168f109SAmir Goldstein "on" : "off"); 357795939a9SAmir Goldstein if (ofs->config.xino != ovl_xino_def()) 358795939a9SAmir Goldstein seq_printf(m, ",xino=%s", ovl_xino_str[ofs->config.xino]); 359d5791044SVivek Goyal if (ofs->config.metacopy != ovl_metacopy_def) 360d5791044SVivek Goyal seq_printf(m, ",metacopy=%s", 361d5791044SVivek Goyal ofs->config.metacopy ? "on" : "off"); 362f45827e8SErez Zadok return 0; 363f45827e8SErez Zadok } 364f45827e8SErez Zadok 3653cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 3663cdf6fe9SSeunghun Lee { 367ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 3683cdf6fe9SSeunghun Lee 3691751e8a6SLinus Torvalds if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 3703cdf6fe9SSeunghun Lee return -EROFS; 3713cdf6fe9SSeunghun Lee 3723cdf6fe9SSeunghun Lee return 0; 3733cdf6fe9SSeunghun Lee } 3743cdf6fe9SSeunghun Lee 375e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 37613cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 37713cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 37813cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 379e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 380e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 381cc259639SAndy Whitcroft .statfs = ovl_statfs, 382f45827e8SErez Zadok .show_options = ovl_show_options, 3833cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 384e9be9d5eSMiklos Szeredi }; 385e9be9d5eSMiklos Szeredi 386e9be9d5eSMiklos Szeredi enum { 387e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 388e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 389e9be9d5eSMiklos Szeredi OPT_WORKDIR, 3908d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 391438c84c2SMiklos Szeredi OPT_REDIRECT_DIR, 39202bcd157SAmir Goldstein OPT_INDEX_ON, 39302bcd157SAmir Goldstein OPT_INDEX_OFF, 394f168f109SAmir Goldstein OPT_NFS_EXPORT_ON, 395f168f109SAmir Goldstein OPT_NFS_EXPORT_OFF, 396795939a9SAmir Goldstein OPT_XINO_ON, 397795939a9SAmir Goldstein OPT_XINO_OFF, 398795939a9SAmir Goldstein OPT_XINO_AUTO, 399d5791044SVivek Goyal OPT_METACOPY_ON, 400d5791044SVivek Goyal OPT_METACOPY_OFF, 401e9be9d5eSMiklos Szeredi OPT_ERR, 402e9be9d5eSMiklos Szeredi }; 403e9be9d5eSMiklos Szeredi 404e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 405e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 406e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 407e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 4088d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 409438c84c2SMiklos Szeredi {OPT_REDIRECT_DIR, "redirect_dir=%s"}, 41002bcd157SAmir Goldstein {OPT_INDEX_ON, "index=on"}, 41102bcd157SAmir Goldstein {OPT_INDEX_OFF, "index=off"}, 412f168f109SAmir Goldstein {OPT_NFS_EXPORT_ON, "nfs_export=on"}, 413f168f109SAmir Goldstein {OPT_NFS_EXPORT_OFF, "nfs_export=off"}, 414795939a9SAmir Goldstein {OPT_XINO_ON, "xino=on"}, 415795939a9SAmir Goldstein {OPT_XINO_OFF, "xino=off"}, 416795939a9SAmir Goldstein {OPT_XINO_AUTO, "xino=auto"}, 417d5791044SVivek Goyal {OPT_METACOPY_ON, "metacopy=on"}, 418d5791044SVivek Goyal {OPT_METACOPY_OFF, "metacopy=off"}, 419e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 420e9be9d5eSMiklos Szeredi }; 421e9be9d5eSMiklos Szeredi 42291c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 42391c77947SMiklos Szeredi { 42491c77947SMiklos Szeredi char *sbegin = *s; 42591c77947SMiklos Szeredi char *p; 42691c77947SMiklos Szeredi 42791c77947SMiklos Szeredi if (sbegin == NULL) 42891c77947SMiklos Szeredi return NULL; 42991c77947SMiklos Szeredi 43091c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 43191c77947SMiklos Szeredi if (*p == '\\') { 43291c77947SMiklos Szeredi p++; 43391c77947SMiklos Szeredi if (!*p) 43491c77947SMiklos Szeredi break; 43591c77947SMiklos Szeredi } else if (*p == ',') { 43691c77947SMiklos Szeredi *p = '\0'; 43791c77947SMiklos Szeredi *s = p + 1; 43891c77947SMiklos Szeredi return sbegin; 43991c77947SMiklos Szeredi } 44091c77947SMiklos Szeredi } 44191c77947SMiklos Szeredi *s = NULL; 44291c77947SMiklos Szeredi return sbegin; 44391c77947SMiklos Szeredi } 44491c77947SMiklos Szeredi 445438c84c2SMiklos Szeredi static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode) 446438c84c2SMiklos Szeredi { 447438c84c2SMiklos Szeredi if (strcmp(mode, "on") == 0) { 448438c84c2SMiklos Szeredi config->redirect_dir = true; 449438c84c2SMiklos Szeredi /* 450438c84c2SMiklos Szeredi * Does not make sense to have redirect creation without 451438c84c2SMiklos Szeredi * redirect following. 452438c84c2SMiklos Szeredi */ 453438c84c2SMiklos Szeredi config->redirect_follow = true; 454438c84c2SMiklos Szeredi } else if (strcmp(mode, "follow") == 0) { 455438c84c2SMiklos Szeredi config->redirect_follow = true; 456438c84c2SMiklos Szeredi } else if (strcmp(mode, "off") == 0) { 457438c84c2SMiklos Szeredi if (ovl_redirect_always_follow) 458438c84c2SMiklos Szeredi config->redirect_follow = true; 459438c84c2SMiklos Szeredi } else if (strcmp(mode, "nofollow") != 0) { 460438c84c2SMiklos Szeredi pr_err("overlayfs: bad mount option \"redirect_dir=%s\"\n", 461438c84c2SMiklos Szeredi mode); 462438c84c2SMiklos Szeredi return -EINVAL; 463438c84c2SMiklos Szeredi } 464438c84c2SMiklos Szeredi 465438c84c2SMiklos Szeredi return 0; 466438c84c2SMiklos Szeredi } 467438c84c2SMiklos Szeredi 468e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 469e9be9d5eSMiklos Szeredi { 470e9be9d5eSMiklos Szeredi char *p; 471d5791044SVivek Goyal int err; 472e9be9d5eSMiklos Szeredi 473438c84c2SMiklos Szeredi config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL); 474438c84c2SMiklos Szeredi if (!config->redirect_mode) 475438c84c2SMiklos Szeredi return -ENOMEM; 476438c84c2SMiklos Szeredi 47791c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 478e9be9d5eSMiklos Szeredi int token; 479e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 480e9be9d5eSMiklos Szeredi 481e9be9d5eSMiklos Szeredi if (!*p) 482e9be9d5eSMiklos Szeredi continue; 483e9be9d5eSMiklos Szeredi 484e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 485e9be9d5eSMiklos Szeredi switch (token) { 486e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 487e9be9d5eSMiklos Szeredi kfree(config->upperdir); 488e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 489e9be9d5eSMiklos Szeredi if (!config->upperdir) 490e9be9d5eSMiklos Szeredi return -ENOMEM; 491e9be9d5eSMiklos Szeredi break; 492e9be9d5eSMiklos Szeredi 493e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 494e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 495e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 496e9be9d5eSMiklos Szeredi if (!config->lowerdir) 497e9be9d5eSMiklos Szeredi return -ENOMEM; 498e9be9d5eSMiklos Szeredi break; 499e9be9d5eSMiklos Szeredi 500e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 501e9be9d5eSMiklos Szeredi kfree(config->workdir); 502e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 503e9be9d5eSMiklos Szeredi if (!config->workdir) 504e9be9d5eSMiklos Szeredi return -ENOMEM; 505e9be9d5eSMiklos Szeredi break; 506e9be9d5eSMiklos Szeredi 5078d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 5088d3095f4SMiklos Szeredi config->default_permissions = true; 5098d3095f4SMiklos Szeredi break; 5108d3095f4SMiklos Szeredi 511438c84c2SMiklos Szeredi case OPT_REDIRECT_DIR: 512438c84c2SMiklos Szeredi kfree(config->redirect_mode); 513438c84c2SMiklos Szeredi config->redirect_mode = match_strdup(&args[0]); 514438c84c2SMiklos Szeredi if (!config->redirect_mode) 515438c84c2SMiklos Szeredi return -ENOMEM; 516a6c60655SMiklos Szeredi break; 517a6c60655SMiklos Szeredi 51802bcd157SAmir Goldstein case OPT_INDEX_ON: 51902bcd157SAmir Goldstein config->index = true; 52002bcd157SAmir Goldstein break; 52102bcd157SAmir Goldstein 52202bcd157SAmir Goldstein case OPT_INDEX_OFF: 52302bcd157SAmir Goldstein config->index = false; 52402bcd157SAmir Goldstein break; 52502bcd157SAmir Goldstein 526f168f109SAmir Goldstein case OPT_NFS_EXPORT_ON: 527f168f109SAmir Goldstein config->nfs_export = true; 528f168f109SAmir Goldstein break; 529f168f109SAmir Goldstein 530f168f109SAmir Goldstein case OPT_NFS_EXPORT_OFF: 531f168f109SAmir Goldstein config->nfs_export = false; 532f168f109SAmir Goldstein break; 533f168f109SAmir Goldstein 534795939a9SAmir Goldstein case OPT_XINO_ON: 535795939a9SAmir Goldstein config->xino = OVL_XINO_ON; 536795939a9SAmir Goldstein break; 537795939a9SAmir Goldstein 538795939a9SAmir Goldstein case OPT_XINO_OFF: 539795939a9SAmir Goldstein config->xino = OVL_XINO_OFF; 540795939a9SAmir Goldstein break; 541795939a9SAmir Goldstein 542795939a9SAmir Goldstein case OPT_XINO_AUTO: 543795939a9SAmir Goldstein config->xino = OVL_XINO_AUTO; 544795939a9SAmir Goldstein break; 545795939a9SAmir Goldstein 546d5791044SVivek Goyal case OPT_METACOPY_ON: 547d5791044SVivek Goyal config->metacopy = true; 548d5791044SVivek Goyal break; 549d5791044SVivek Goyal 550d5791044SVivek Goyal case OPT_METACOPY_OFF: 551d5791044SVivek Goyal config->metacopy = false; 552d5791044SVivek Goyal break; 553d5791044SVivek Goyal 554e9be9d5eSMiklos Szeredi default: 555bead55efShujianyang pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p); 556e9be9d5eSMiklos Szeredi return -EINVAL; 557e9be9d5eSMiklos Szeredi } 558e9be9d5eSMiklos Szeredi } 55971cbad7eShujianyang 56071cbad7eShujianyang /* Workdir is useless in non-upper mount */ 56171cbad7eShujianyang if (!config->upperdir && config->workdir) { 56271cbad7eShujianyang pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 56371cbad7eShujianyang config->workdir); 56471cbad7eShujianyang kfree(config->workdir); 56571cbad7eShujianyang config->workdir = NULL; 56671cbad7eShujianyang } 56771cbad7eShujianyang 568d5791044SVivek Goyal err = ovl_parse_redirect_mode(config, config->redirect_mode); 569d5791044SVivek Goyal if (err) 570d5791044SVivek Goyal return err; 571d5791044SVivek Goyal 572d5791044SVivek Goyal /* metacopy feature with upper requires redirect_dir=on */ 573d5791044SVivek Goyal if (config->upperdir && config->metacopy && !config->redirect_dir) { 574d5791044SVivek Goyal pr_warn("overlayfs: metadata only copy up requires \"redirect_dir=on\", falling back to metacopy=off.\n"); 575d5791044SVivek Goyal config->metacopy = false; 576d5791044SVivek Goyal } else if (config->metacopy && !config->redirect_follow) { 577d5791044SVivek Goyal pr_warn("overlayfs: metadata only copy up requires \"redirect_dir=follow\" on non-upper mount, falling back to metacopy=off.\n"); 578d5791044SVivek Goyal config->metacopy = false; 579d5791044SVivek Goyal } 580d5791044SVivek Goyal 581d5791044SVivek Goyal return 0; 582e9be9d5eSMiklos Szeredi } 583e9be9d5eSMiklos Szeredi 584e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 58502bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 586e9be9d5eSMiklos Szeredi 587ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 5886b8aa129SAmir Goldstein const char *name, bool persist) 589e9be9d5eSMiklos Szeredi { 590ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 591ad204488SMiklos Szeredi struct vfsmount *mnt = ofs->upper_mnt; 592e9be9d5eSMiklos Szeredi struct dentry *work; 593e9be9d5eSMiklos Szeredi int err; 594e9be9d5eSMiklos Szeredi bool retried = false; 5956b8aa129SAmir Goldstein bool locked = false; 596e9be9d5eSMiklos Szeredi 5975955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 5986b8aa129SAmir Goldstein locked = true; 5996b8aa129SAmir Goldstein 600e9be9d5eSMiklos Szeredi retry: 601ad204488SMiklos Szeredi work = lookup_one_len(name, ofs->workbasedir, strlen(name)); 602e9be9d5eSMiklos Szeredi 603e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 604c11b9fddSMiklos Szeredi struct iattr attr = { 605c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 60632a3d848SAl Viro .ia_mode = S_IFDIR | 0, 607c11b9fddSMiklos Szeredi }; 608e9be9d5eSMiklos Szeredi 609e9be9d5eSMiklos Szeredi if (work->d_inode) { 610e9be9d5eSMiklos Szeredi err = -EEXIST; 611e9be9d5eSMiklos Szeredi if (retried) 612e9be9d5eSMiklos Szeredi goto out_dput; 613e9be9d5eSMiklos Szeredi 6146b8aa129SAmir Goldstein if (persist) 6156b8aa129SAmir Goldstein goto out_unlock; 6166b8aa129SAmir Goldstein 617e9be9d5eSMiklos Szeredi retried = true; 618eea2fb48SMiklos Szeredi ovl_workdir_cleanup(dir, mnt, work, 0); 619e9be9d5eSMiklos Szeredi dput(work); 620e9be9d5eSMiklos Szeredi goto retry; 621e9be9d5eSMiklos Szeredi } 622e9be9d5eSMiklos Szeredi 62395a1c815SMiklos Szeredi work = ovl_create_real(dir, work, OVL_CATTR(attr.ia_mode)); 62495a1c815SMiklos Szeredi err = PTR_ERR(work); 62595a1c815SMiklos Szeredi if (IS_ERR(work)) 62695a1c815SMiklos Szeredi goto out_err; 627c11b9fddSMiklos Szeredi 628cb348edbSMiklos Szeredi /* 629cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 630cb348edbSMiklos Szeredi * 631cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 632cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 633cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 634cb348edbSMiklos Szeredi * 635cb348edbSMiklos Szeredi * There are various other error values that could effectively 636cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 637cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 638cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 639cb348edbSMiklos Szeredi * for the above two errors is sufficient. 640cb348edbSMiklos Szeredi */ 641c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 642e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 643c11b9fddSMiklos Szeredi goto out_dput; 644c11b9fddSMiklos Szeredi 645c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 646e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 647c11b9fddSMiklos Szeredi goto out_dput; 648c11b9fddSMiklos Szeredi 649c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 650c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 651c11b9fddSMiklos Szeredi err = notify_change(work, &attr, NULL); 652c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 653c11b9fddSMiklos Szeredi if (err) 654c11b9fddSMiklos Szeredi goto out_dput; 6556b8aa129SAmir Goldstein } else { 6566b8aa129SAmir Goldstein err = PTR_ERR(work); 6576b8aa129SAmir Goldstein goto out_err; 658e9be9d5eSMiklos Szeredi } 659e9be9d5eSMiklos Szeredi out_unlock: 6606b8aa129SAmir Goldstein if (locked) 6616b8aa129SAmir Goldstein inode_unlock(dir); 662e9be9d5eSMiklos Szeredi 663e9be9d5eSMiklos Szeredi return work; 664e9be9d5eSMiklos Szeredi 665e9be9d5eSMiklos Szeredi out_dput: 666e9be9d5eSMiklos Szeredi dput(work); 6676b8aa129SAmir Goldstein out_err: 6686b8aa129SAmir Goldstein pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n", 669ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 6706b8aa129SAmir Goldstein work = NULL; 671e9be9d5eSMiklos Szeredi goto out_unlock; 672e9be9d5eSMiklos Szeredi } 673e9be9d5eSMiklos Szeredi 67491c77947SMiklos Szeredi static void ovl_unescape(char *s) 67591c77947SMiklos Szeredi { 67691c77947SMiklos Szeredi char *d = s; 67791c77947SMiklos Szeredi 67891c77947SMiklos Szeredi for (;; s++, d++) { 67991c77947SMiklos Szeredi if (*s == '\\') 68091c77947SMiklos Szeredi s++; 68191c77947SMiklos Szeredi *d = *s; 68291c77947SMiklos Szeredi if (!*s) 68391c77947SMiklos Szeredi break; 68491c77947SMiklos Szeredi } 68591c77947SMiklos Szeredi } 68691c77947SMiklos Szeredi 687ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 688ab508822SMiklos Szeredi { 689a78d9f0dSMiklos Szeredi int err = -EINVAL; 690ab508822SMiklos Szeredi 691a78d9f0dSMiklos Szeredi if (!*name) { 692a78d9f0dSMiklos Szeredi pr_err("overlayfs: empty lowerdir\n"); 693a78d9f0dSMiklos Szeredi goto out; 694a78d9f0dSMiklos Szeredi } 695ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 696ab508822SMiklos Szeredi if (err) { 697ab508822SMiklos Szeredi pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); 698ab508822SMiklos Szeredi goto out; 699ab508822SMiklos Szeredi } 700ab508822SMiklos Szeredi err = -EINVAL; 7017c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 702ab508822SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported\n", name); 703ab508822SMiklos Szeredi goto out_put; 704ab508822SMiklos Szeredi } 7052b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 706ab508822SMiklos Szeredi pr_err("overlayfs: '%s' not a directory\n", name); 707ab508822SMiklos Szeredi goto out_put; 708ab508822SMiklos Szeredi } 709ab508822SMiklos Szeredi return 0; 710ab508822SMiklos Szeredi 711ab508822SMiklos Szeredi out_put: 7128aafcb59SMiklos Szeredi path_put_init(path); 713ab508822SMiklos Szeredi out: 714ab508822SMiklos Szeredi return err; 715ab508822SMiklos Szeredi } 716ab508822SMiklos Szeredi 717ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 718ab508822SMiklos Szeredi { 719ab508822SMiklos Szeredi int err = -ENOMEM; 720ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 721ab508822SMiklos Szeredi 722ab508822SMiklos Szeredi if (tmp) { 723ab508822SMiklos Szeredi ovl_unescape(tmp); 724ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 7257c03b5d4SMiklos Szeredi 7267c03b5d4SMiklos Szeredi if (!err) 7277c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) { 7287c03b5d4SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n", 7297c03b5d4SMiklos Szeredi tmp); 7308aafcb59SMiklos Szeredi path_put_init(path); 7317c03b5d4SMiklos Szeredi err = -EINVAL; 7327c03b5d4SMiklos Szeredi } 733ab508822SMiklos Szeredi kfree(tmp); 734ab508822SMiklos Szeredi } 735ab508822SMiklos Szeredi return err; 736ab508822SMiklos Szeredi } 737ab508822SMiklos Szeredi 7386b2d5fe4SMiklos Szeredi static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 7396b2d5fe4SMiklos Szeredi const char *name) 7406b2d5fe4SMiklos Szeredi { 7416b2d5fe4SMiklos Szeredi struct kstatfs statfs; 7426b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 7436b2d5fe4SMiklos Szeredi 7446b2d5fe4SMiklos Szeredi if (err) 7456b2d5fe4SMiklos Szeredi pr_err("overlayfs: statfs failed on '%s'\n", name); 7466b2d5fe4SMiklos Szeredi else 7476b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 7486b2d5fe4SMiklos Szeredi 7496b2d5fe4SMiklos Szeredi return err; 7506b2d5fe4SMiklos Szeredi } 7516b2d5fe4SMiklos Szeredi 7526b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 7536b2d5fe4SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth, bool *remote) 754ab508822SMiklos Szeredi { 755e487d889SAmir Goldstein int fh_type; 756ab508822SMiklos Szeredi int err; 757ab508822SMiklos Szeredi 758a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 759ab508822SMiklos Szeredi if (err) 760ab508822SMiklos Szeredi goto out; 761ab508822SMiklos Szeredi 7626b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 7636b2d5fe4SMiklos Szeredi if (err) 764ab508822SMiklos Szeredi goto out_put; 7656b2d5fe4SMiklos Szeredi 766ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 767ab508822SMiklos Szeredi 7687c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) 7697c03b5d4SMiklos Szeredi *remote = true; 7707c03b5d4SMiklos Szeredi 77102bcd157SAmir Goldstein /* 772f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode 773f168f109SAmir Goldstein * file handles, so they require that all layers support them. 77402bcd157SAmir Goldstein */ 775e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(path->dentry->d_sb); 776f168f109SAmir Goldstein if ((ofs->config.nfs_export || 777e487d889SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 77802bcd157SAmir Goldstein ofs->config.index = false; 779f168f109SAmir Goldstein ofs->config.nfs_export = false; 780f168f109SAmir Goldstein pr_warn("overlayfs: fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 781f168f109SAmir Goldstein name); 78202bcd157SAmir Goldstein } 78302bcd157SAmir Goldstein 784e487d889SAmir Goldstein /* Check if lower fs has 32bit inode numbers */ 785e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 786e487d889SAmir Goldstein ofs->xino_bits = 0; 787e487d889SAmir Goldstein 788ab508822SMiklos Szeredi return 0; 789ab508822SMiklos Szeredi 790ab508822SMiklos Szeredi out_put: 7918aafcb59SMiklos Szeredi path_put_init(path); 792ab508822SMiklos Szeredi out: 793ab508822SMiklos Szeredi return err; 794ab508822SMiklos Szeredi } 795ab508822SMiklos Szeredi 796e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 797e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 798e9be9d5eSMiklos Szeredi { 799e9be9d5eSMiklos Szeredi bool ok = false; 800e9be9d5eSMiklos Szeredi 801e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 802e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 803e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 804e9be9d5eSMiklos Szeredi } 805e9be9d5eSMiklos Szeredi return ok; 806e9be9d5eSMiklos Szeredi } 807e9be9d5eSMiklos Szeredi 808a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 809a78d9f0dSMiklos Szeredi { 810a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 811a78d9f0dSMiklos Szeredi char *s, *d; 812a78d9f0dSMiklos Szeredi 813a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 814a78d9f0dSMiklos Szeredi if (*s == '\\') { 815a78d9f0dSMiklos Szeredi s++; 816a78d9f0dSMiklos Szeredi } else if (*s == ':') { 817a78d9f0dSMiklos Szeredi *d = '\0'; 818a78d9f0dSMiklos Szeredi ctr++; 819a78d9f0dSMiklos Szeredi continue; 820a78d9f0dSMiklos Szeredi } 821a78d9f0dSMiklos Szeredi *d = *s; 822a78d9f0dSMiklos Szeredi if (!*s) 823a78d9f0dSMiklos Szeredi break; 824a78d9f0dSMiklos Szeredi } 825a78d9f0dSMiklos Szeredi return ctr; 826a78d9f0dSMiklos Szeredi } 827a78d9f0dSMiklos Szeredi 8280c97be22SAndreas Gruenbacher static int __maybe_unused 8290eb45fc3SAndreas Gruenbacher ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 8300eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8310eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 8320eb45fc3SAndreas Gruenbacher { 8331d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 8340eb45fc3SAndreas Gruenbacher } 8350eb45fc3SAndreas Gruenbacher 8360eb45fc3SAndreas Gruenbacher static int __maybe_unused 8370c97be22SAndreas Gruenbacher ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 838d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 839d837a49bSMiklos Szeredi const char *name, const void *value, 840d837a49bSMiklos Szeredi size_t size, int flags) 841d837a49bSMiklos Szeredi { 842d837a49bSMiklos Szeredi struct dentry *workdir = ovl_workdir(dentry); 84309d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 844d837a49bSMiklos Szeredi struct posix_acl *acl = NULL; 845d837a49bSMiklos Szeredi int err; 846d837a49bSMiklos Szeredi 847d837a49bSMiklos Szeredi /* Check that everything is OK before copy-up */ 848d837a49bSMiklos Szeredi if (value) { 849d837a49bSMiklos Szeredi acl = posix_acl_from_xattr(&init_user_ns, value, size); 850d837a49bSMiklos Szeredi if (IS_ERR(acl)) 851d837a49bSMiklos Szeredi return PTR_ERR(acl); 852d837a49bSMiklos Szeredi } 853d837a49bSMiklos Szeredi err = -EOPNOTSUPP; 854d837a49bSMiklos Szeredi if (!IS_POSIXACL(d_inode(workdir))) 855d837a49bSMiklos Szeredi goto out_acl_release; 856d837a49bSMiklos Szeredi if (!realinode->i_op->set_acl) 857d837a49bSMiklos Szeredi goto out_acl_release; 858d837a49bSMiklos Szeredi if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 859d837a49bSMiklos Szeredi err = acl ? -EACCES : 0; 860d837a49bSMiklos Szeredi goto out_acl_release; 861d837a49bSMiklos Szeredi } 862d837a49bSMiklos Szeredi err = -EPERM; 863d837a49bSMiklos Szeredi if (!inode_owner_or_capable(inode)) 864d837a49bSMiklos Szeredi goto out_acl_release; 865d837a49bSMiklos Szeredi 866d837a49bSMiklos Szeredi posix_acl_release(acl); 867d837a49bSMiklos Szeredi 868fd3220d3SMiklos Szeredi /* 869fd3220d3SMiklos Szeredi * Check if sgid bit needs to be cleared (actual setacl operation will 870fd3220d3SMiklos Szeredi * be done with mounter's capabilities and so that won't do it for us). 871fd3220d3SMiklos Szeredi */ 872fd3220d3SMiklos Szeredi if (unlikely(inode->i_mode & S_ISGID) && 873fd3220d3SMiklos Szeredi handler->flags == ACL_TYPE_ACCESS && 874fd3220d3SMiklos Szeredi !in_group_p(inode->i_gid) && 875fd3220d3SMiklos Szeredi !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 876fd3220d3SMiklos Szeredi struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 877fd3220d3SMiklos Szeredi 878fd3220d3SMiklos Szeredi err = ovl_setattr(dentry, &iattr); 879fd3220d3SMiklos Szeredi if (err) 880fd3220d3SMiklos Szeredi return err; 881fd3220d3SMiklos Szeredi } 882fd3220d3SMiklos Szeredi 8831d88f183SMiklos Szeredi err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 884ce31513aSMiklos Szeredi if (!err) 88509d8b586SMiklos Szeredi ovl_copyattr(ovl_inode_real(inode), inode); 886ce31513aSMiklos Szeredi 887ce31513aSMiklos Szeredi return err; 888d837a49bSMiklos Szeredi 889d837a49bSMiklos Szeredi out_acl_release: 890d837a49bSMiklos Szeredi posix_acl_release(acl); 891d837a49bSMiklos Szeredi return err; 892d837a49bSMiklos Szeredi } 893d837a49bSMiklos Szeredi 8940eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 8950eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8960eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 8970eb45fc3SAndreas Gruenbacher { 89848fab5d7SAmir Goldstein return -EOPNOTSUPP; 8990eb45fc3SAndreas Gruenbacher } 9000eb45fc3SAndreas Gruenbacher 901d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 902d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 903d837a49bSMiklos Szeredi const char *name, const void *value, 904d837a49bSMiklos Szeredi size_t size, int flags) 905d837a49bSMiklos Szeredi { 90648fab5d7SAmir Goldstein return -EOPNOTSUPP; 907d837a49bSMiklos Szeredi } 908d837a49bSMiklos Szeredi 9090eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 9100eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9110eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 9120eb45fc3SAndreas Gruenbacher { 9131d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 9140eb45fc3SAndreas Gruenbacher } 9150eb45fc3SAndreas Gruenbacher 9160e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 9170e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9180e585cccSAndreas Gruenbacher const char *name, const void *value, 9190e585cccSAndreas Gruenbacher size_t size, int flags) 9200e585cccSAndreas Gruenbacher { 9211d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 9220e585cccSAndreas Gruenbacher } 9230e585cccSAndreas Gruenbacher 9240c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 9250c97be22SAndreas Gruenbacher ovl_posix_acl_access_xattr_handler = { 926d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_ACCESS, 927d837a49bSMiklos Szeredi .flags = ACL_TYPE_ACCESS, 9280eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 929d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 930d837a49bSMiklos Szeredi }; 931d837a49bSMiklos Szeredi 9320c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 9330c97be22SAndreas Gruenbacher ovl_posix_acl_default_xattr_handler = { 934d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_DEFAULT, 935d837a49bSMiklos Szeredi .flags = ACL_TYPE_DEFAULT, 9360eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 937d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 938d837a49bSMiklos Szeredi }; 939d837a49bSMiklos Szeredi 940d837a49bSMiklos Szeredi static const struct xattr_handler ovl_own_xattr_handler = { 941d837a49bSMiklos Szeredi .prefix = OVL_XATTR_PREFIX, 9420eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 943d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 944d837a49bSMiklos Szeredi }; 945d837a49bSMiklos Szeredi 946d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 947d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 9480eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 949d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 950d837a49bSMiklos Szeredi }; 951d837a49bSMiklos Szeredi 952d837a49bSMiklos Szeredi static const struct xattr_handler *ovl_xattr_handlers[] = { 9530c97be22SAndreas Gruenbacher #ifdef CONFIG_FS_POSIX_ACL 954d837a49bSMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 955d837a49bSMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 9560c97be22SAndreas Gruenbacher #endif 957d837a49bSMiklos Szeredi &ovl_own_xattr_handler, 958d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 959d837a49bSMiklos Szeredi NULL 960d837a49bSMiklos Szeredi }; 961d837a49bSMiklos Szeredi 962ad204488SMiklos Szeredi static int ovl_get_upper(struct ovl_fs *ofs, struct path *upperpath) 9636ee8acf0SMiklos Szeredi { 9645064975eSMiklos Szeredi struct vfsmount *upper_mnt; 9656ee8acf0SMiklos Szeredi int err; 9666ee8acf0SMiklos Szeredi 967ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.upperdir, upperpath); 9686ee8acf0SMiklos Szeredi if (err) 9696ee8acf0SMiklos Szeredi goto out; 9706ee8acf0SMiklos Szeredi 9716ee8acf0SMiklos Szeredi /* Upper fs should not be r/o */ 9726ee8acf0SMiklos Szeredi if (sb_rdonly(upperpath->mnt->mnt_sb)) { 9736ee8acf0SMiklos Szeredi pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n"); 9746ee8acf0SMiklos Szeredi err = -EINVAL; 9756ee8acf0SMiklos Szeredi goto out; 9766ee8acf0SMiklos Szeredi } 9776ee8acf0SMiklos Szeredi 978ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 9796ee8acf0SMiklos Szeredi if (err) 9806ee8acf0SMiklos Szeredi goto out; 9816ee8acf0SMiklos Szeredi 9826ee8acf0SMiklos Szeredi err = -EBUSY; 9836ee8acf0SMiklos Szeredi if (ovl_inuse_trylock(upperpath->dentry)) { 984ad204488SMiklos Szeredi ofs->upperdir_locked = true; 985ad204488SMiklos Szeredi } else if (ofs->config.index) { 9866ee8acf0SMiklos Szeredi pr_err("overlayfs: upperdir is in-use by another mount, mount with '-o index=off' to override exclusive upperdir protection.\n"); 9876ee8acf0SMiklos Szeredi goto out; 9886ee8acf0SMiklos Szeredi } else { 9896ee8acf0SMiklos Szeredi pr_warn("overlayfs: upperdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 9906ee8acf0SMiklos Szeredi } 9915064975eSMiklos Szeredi 9925064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 9935064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 9945064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 9955064975eSMiklos Szeredi pr_err("overlayfs: failed to clone upperpath\n"); 9965064975eSMiklos Szeredi goto out; 9975064975eSMiklos Szeredi } 9985064975eSMiklos Szeredi 9995064975eSMiklos Szeredi /* Don't inherit atime flags */ 10005064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 1001ad204488SMiklos Szeredi ofs->upper_mnt = upper_mnt; 10026ee8acf0SMiklos Szeredi err = 0; 10036ee8acf0SMiklos Szeredi out: 10046ee8acf0SMiklos Szeredi return err; 10056ee8acf0SMiklos Szeredi } 10066ee8acf0SMiklos Szeredi 1007ad204488SMiklos Szeredi static int ovl_make_workdir(struct ovl_fs *ofs, struct path *workpath) 10088ed61dc3SMiklos Szeredi { 10092ba9d57eSAmir Goldstein struct vfsmount *mnt = ofs->upper_mnt; 10108ed61dc3SMiklos Szeredi struct dentry *temp; 1011e487d889SAmir Goldstein int fh_type; 10128ed61dc3SMiklos Szeredi int err; 10138ed61dc3SMiklos Szeredi 10142ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 10152ba9d57eSAmir Goldstein if (err) 10162ba9d57eSAmir Goldstein return err; 10172ba9d57eSAmir Goldstein 1018ad204488SMiklos Szeredi ofs->workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 1019ad204488SMiklos Szeredi if (!ofs->workdir) 10202ba9d57eSAmir Goldstein goto out; 10218ed61dc3SMiklos Szeredi 10228ed61dc3SMiklos Szeredi /* 10238ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 10248ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 10258ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 10268ed61dc3SMiklos Szeredi * previous step. 10278ed61dc3SMiklos Szeredi */ 10288ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 10298ed61dc3SMiklos Szeredi if (err < 0) 10302ba9d57eSAmir Goldstein goto out; 10318ed61dc3SMiklos Szeredi 10328ed61dc3SMiklos Szeredi /* 10338ed61dc3SMiklos Szeredi * We allowed this configuration and don't want to break users over 10348ed61dc3SMiklos Szeredi * kernel upgrade. So warn instead of erroring out. 10358ed61dc3SMiklos Szeredi */ 10368ed61dc3SMiklos Szeredi if (!err) 10378ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs needs to support d_type.\n"); 10388ed61dc3SMiklos Szeredi 10398ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 1040ad204488SMiklos Szeredi temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0); 1041ad204488SMiklos Szeredi ofs->tmpfile = !IS_ERR(temp); 1042ad204488SMiklos Szeredi if (ofs->tmpfile) 10438ed61dc3SMiklos Szeredi dput(temp); 10448ed61dc3SMiklos Szeredi else 10458ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support tmpfile.\n"); 10468ed61dc3SMiklos Szeredi 10478ed61dc3SMiklos Szeredi /* 10488ed61dc3SMiklos Szeredi * Check if upper/work fs supports trusted.overlay.* xattr 10498ed61dc3SMiklos Szeredi */ 1050ad204488SMiklos Szeredi err = ovl_do_setxattr(ofs->workdir, OVL_XATTR_OPAQUE, "0", 1, 0); 10518ed61dc3SMiklos Szeredi if (err) { 1052ad204488SMiklos Szeredi ofs->noxattr = true; 1053a683737bSAmir Goldstein ofs->config.index = false; 1054d5791044SVivek Goyal ofs->config.metacopy = false; 1055d5791044SVivek Goyal pr_warn("overlayfs: upper fs does not support xattr, falling back to index=off and metacopy=off.\n"); 10562ba9d57eSAmir Goldstein err = 0; 10578ed61dc3SMiklos Szeredi } else { 1058ad204488SMiklos Szeredi vfs_removexattr(ofs->workdir, OVL_XATTR_OPAQUE); 10598ed61dc3SMiklos Szeredi } 10608ed61dc3SMiklos Szeredi 10618ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 1062e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 1063e487d889SAmir Goldstein if (ofs->config.index && !fh_type) { 1064ad204488SMiklos Szeredi ofs->config.index = false; 10658ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support file handles, falling back to index=off.\n"); 10668ed61dc3SMiklos Szeredi } 10678ed61dc3SMiklos Szeredi 1068e487d889SAmir Goldstein /* Check if upper fs has 32bit inode numbers */ 1069e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 1070e487d889SAmir Goldstein ofs->xino_bits = 0; 1071e487d889SAmir Goldstein 1072f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */ 1073f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) { 1074f168f109SAmir Goldstein pr_warn("overlayfs: NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 1075f168f109SAmir Goldstein ofs->config.nfs_export = false; 1076f168f109SAmir Goldstein } 10772ba9d57eSAmir Goldstein out: 10782ba9d57eSAmir Goldstein mnt_drop_write(mnt); 10792ba9d57eSAmir Goldstein return err; 10808ed61dc3SMiklos Szeredi } 10818ed61dc3SMiklos Szeredi 1082ad204488SMiklos Szeredi static int ovl_get_workdir(struct ovl_fs *ofs, struct path *upperpath) 1083520d7c86SMiklos Szeredi { 1084520d7c86SMiklos Szeredi int err; 1085bca44b52SMiklos Szeredi struct path workpath = { }; 1086520d7c86SMiklos Szeredi 1087ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.workdir, &workpath); 1088520d7c86SMiklos Szeredi if (err) 1089520d7c86SMiklos Szeredi goto out; 1090520d7c86SMiklos Szeredi 1091520d7c86SMiklos Szeredi err = -EINVAL; 1092bca44b52SMiklos Szeredi if (upperpath->mnt != workpath.mnt) { 1093520d7c86SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 1094520d7c86SMiklos Szeredi goto out; 1095520d7c86SMiklos Szeredi } 1096bca44b52SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 1097520d7c86SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 1098520d7c86SMiklos Szeredi goto out; 1099520d7c86SMiklos Szeredi } 1100520d7c86SMiklos Szeredi 1101520d7c86SMiklos Szeredi err = -EBUSY; 1102bca44b52SMiklos Szeredi if (ovl_inuse_trylock(workpath.dentry)) { 1103ad204488SMiklos Szeredi ofs->workdir_locked = true; 1104ad204488SMiklos Szeredi } else if (ofs->config.index) { 1105520d7c86SMiklos Szeredi pr_err("overlayfs: workdir is in-use by another mount, mount with '-o index=off' to override exclusive workdir protection.\n"); 1106520d7c86SMiklos Szeredi goto out; 1107520d7c86SMiklos Szeredi } else { 1108520d7c86SMiklos Szeredi pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 1109520d7c86SMiklos Szeredi } 1110520d7c86SMiklos Szeredi 1111ad204488SMiklos Szeredi ofs->workbasedir = dget(workpath.dentry); 1112ad204488SMiklos Szeredi err = ovl_make_workdir(ofs, &workpath); 1113bca44b52SMiklos Szeredi if (err) 1114bca44b52SMiklos Szeredi goto out; 1115bca44b52SMiklos Szeredi 1116520d7c86SMiklos Szeredi err = 0; 1117520d7c86SMiklos Szeredi out: 1118bca44b52SMiklos Szeredi path_put(&workpath); 1119bca44b52SMiklos Szeredi 1120520d7c86SMiklos Szeredi return err; 1121520d7c86SMiklos Szeredi } 1122520d7c86SMiklos Szeredi 1123ad204488SMiklos Szeredi static int ovl_get_indexdir(struct ovl_fs *ofs, struct ovl_entry *oe, 112495e6d417SMiklos Szeredi struct path *upperpath) 1125f7e3a7d9SMiklos Szeredi { 11262ba9d57eSAmir Goldstein struct vfsmount *mnt = ofs->upper_mnt; 1127f7e3a7d9SMiklos Szeredi int err; 1128f7e3a7d9SMiklos Szeredi 11292ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 11302ba9d57eSAmir Goldstein if (err) 11312ba9d57eSAmir Goldstein return err; 11322ba9d57eSAmir Goldstein 1133f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 1134d9768076SAmir Goldstein err = ovl_verify_origin(upperpath->dentry, oe->lowerstack[0].dentry, 113505122443SAmir Goldstein true); 1136f7e3a7d9SMiklos Szeredi if (err) { 1137f7e3a7d9SMiklos Szeredi pr_err("overlayfs: failed to verify upper root origin\n"); 1138f7e3a7d9SMiklos Szeredi goto out; 1139f7e3a7d9SMiklos Szeredi } 1140f7e3a7d9SMiklos Szeredi 1141ad204488SMiklos Szeredi ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1142ad204488SMiklos Szeredi if (ofs->indexdir) { 1143ad1d615cSAmir Goldstein /* 1144ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir. 1145ad1d615cSAmir Goldstein * Older kernels stored upper fh in "trusted.overlay.origin" 1146ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to 1147ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr 1148ad1d615cSAmir Goldstein * "trusted.overlay.upper" to indicate that index may have 1149ad1d615cSAmir Goldstein * directory entries. 1150ad1d615cSAmir Goldstein */ 1151ad1d615cSAmir Goldstein if (ovl_check_origin_xattr(ofs->indexdir)) { 115205122443SAmir Goldstein err = ovl_verify_set_fh(ofs->indexdir, OVL_XATTR_ORIGIN, 1153ad1d615cSAmir Goldstein upperpath->dentry, true, false); 1154f7e3a7d9SMiklos Szeredi if (err) 1155ad1d615cSAmir Goldstein pr_err("overlayfs: failed to verify index dir 'origin' xattr\n"); 1156ad1d615cSAmir Goldstein } 1157ad1d615cSAmir Goldstein err = ovl_verify_upper(ofs->indexdir, upperpath->dentry, true); 1158ad1d615cSAmir Goldstein if (err) 1159ad1d615cSAmir Goldstein pr_err("overlayfs: failed to verify index dir 'upper' xattr\n"); 1160f7e3a7d9SMiklos Szeredi 1161f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 1162f7e3a7d9SMiklos Szeredi if (!err) 11631eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs); 1164f7e3a7d9SMiklos Szeredi } 1165ad204488SMiklos Szeredi if (err || !ofs->indexdir) 1166f7e3a7d9SMiklos Szeredi pr_warn("overlayfs: try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1167f7e3a7d9SMiklos Szeredi 1168f7e3a7d9SMiklos Szeredi out: 11692ba9d57eSAmir Goldstein mnt_drop_write(mnt); 1170f7e3a7d9SMiklos Szeredi return err; 1171f7e3a7d9SMiklos Szeredi } 1172f7e3a7d9SMiklos Szeredi 11735148626bSAmir Goldstein /* Get a unique fsid for the layer */ 11745148626bSAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, struct super_block *sb) 11755148626bSAmir Goldstein { 11765148626bSAmir Goldstein unsigned int i; 11775148626bSAmir Goldstein dev_t dev; 11785148626bSAmir Goldstein int err; 11795148626bSAmir Goldstein 11805148626bSAmir Goldstein /* fsid 0 is reserved for upper fs even with non upper overlay */ 11815148626bSAmir Goldstein if (ofs->upper_mnt && ofs->upper_mnt->mnt_sb == sb) 11825148626bSAmir Goldstein return 0; 11835148626bSAmir Goldstein 11845148626bSAmir Goldstein for (i = 0; i < ofs->numlowerfs; i++) { 11855148626bSAmir Goldstein if (ofs->lower_fs[i].sb == sb) 11865148626bSAmir Goldstein return i + 1; 11875148626bSAmir Goldstein } 11885148626bSAmir Goldstein 11895148626bSAmir Goldstein err = get_anon_bdev(&dev); 11905148626bSAmir Goldstein if (err) { 11915148626bSAmir Goldstein pr_err("overlayfs: failed to get anonymous bdev for lowerpath\n"); 11925148626bSAmir Goldstein return err; 11935148626bSAmir Goldstein } 11945148626bSAmir Goldstein 11955148626bSAmir Goldstein ofs->lower_fs[ofs->numlowerfs].sb = sb; 11965148626bSAmir Goldstein ofs->lower_fs[ofs->numlowerfs].pseudo_dev = dev; 11975148626bSAmir Goldstein ofs->numlowerfs++; 11985148626bSAmir Goldstein 11995148626bSAmir Goldstein return ofs->numlowerfs; 12005148626bSAmir Goldstein } 12015148626bSAmir Goldstein 1202ad204488SMiklos Szeredi static int ovl_get_lower_layers(struct ovl_fs *ofs, struct path *stack, 1203520d7c86SMiklos Szeredi unsigned int numlower) 1204520d7c86SMiklos Szeredi { 1205520d7c86SMiklos Szeredi int err; 1206520d7c86SMiklos Szeredi unsigned int i; 1207520d7c86SMiklos Szeredi 1208520d7c86SMiklos Szeredi err = -ENOMEM; 1209ad204488SMiklos Szeredi ofs->lower_layers = kcalloc(numlower, sizeof(struct ovl_layer), 1210520d7c86SMiklos Szeredi GFP_KERNEL); 1211ad204488SMiklos Szeredi if (ofs->lower_layers == NULL) 1212520d7c86SMiklos Szeredi goto out; 12135148626bSAmir Goldstein 12145148626bSAmir Goldstein ofs->lower_fs = kcalloc(numlower, sizeof(struct ovl_sb), 12155148626bSAmir Goldstein GFP_KERNEL); 12165148626bSAmir Goldstein if (ofs->lower_fs == NULL) 12175148626bSAmir Goldstein goto out; 12185148626bSAmir Goldstein 1219520d7c86SMiklos Szeredi for (i = 0; i < numlower; i++) { 1220520d7c86SMiklos Szeredi struct vfsmount *mnt; 12215148626bSAmir Goldstein int fsid; 1222520d7c86SMiklos Szeredi 12235148626bSAmir Goldstein err = fsid = ovl_get_fsid(ofs, stack[i].mnt->mnt_sb); 12245148626bSAmir Goldstein if (err < 0) 1225520d7c86SMiklos Szeredi goto out; 1226520d7c86SMiklos Szeredi 1227520d7c86SMiklos Szeredi mnt = clone_private_mount(&stack[i]); 1228520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1229520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 1230520d7c86SMiklos Szeredi pr_err("overlayfs: failed to clone lowerpath\n"); 1231520d7c86SMiklos Szeredi goto out; 1232520d7c86SMiklos Szeredi } 12335148626bSAmir Goldstein 1234520d7c86SMiklos Szeredi /* 1235520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1236520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1237520d7c86SMiklos Szeredi */ 1238520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1239520d7c86SMiklos Szeredi 1240ad204488SMiklos Szeredi ofs->lower_layers[ofs->numlower].mnt = mnt; 1241d583ed7dSAmir Goldstein ofs->lower_layers[ofs->numlower].idx = i + 1; 12425148626bSAmir Goldstein ofs->lower_layers[ofs->numlower].fsid = fsid; 12435148626bSAmir Goldstein if (fsid) { 12445148626bSAmir Goldstein ofs->lower_layers[ofs->numlower].fs = 12455148626bSAmir Goldstein &ofs->lower_fs[fsid - 1]; 12465148626bSAmir Goldstein } 1247ad204488SMiklos Szeredi ofs->numlower++; 1248520d7c86SMiklos Szeredi } 1249e487d889SAmir Goldstein 1250795939a9SAmir Goldstein /* 1251795939a9SAmir Goldstein * When all layers on same fs, overlay can use real inode numbers. 1252795939a9SAmir Goldstein * With mount option "xino=on", mounter declares that there are enough 1253795939a9SAmir Goldstein * free high bits in underlying fs to hold the unique fsid. 1254795939a9SAmir Goldstein * If overlayfs does encounter underlying inodes using the high xino 1255795939a9SAmir Goldstein * bits reserved for fsid, it emits a warning and uses the original 1256795939a9SAmir Goldstein * inode number. 1257795939a9SAmir Goldstein */ 1258795939a9SAmir Goldstein if (!ofs->numlowerfs || (ofs->numlowerfs == 1 && !ofs->upper_mnt)) { 1259e487d889SAmir Goldstein ofs->xino_bits = 0; 1260795939a9SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 1261795939a9SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_ON && !ofs->xino_bits) { 1262795939a9SAmir Goldstein /* 1263795939a9SAmir Goldstein * This is a roundup of number of bits needed for numlowerfs+1 1264795939a9SAmir Goldstein * (i.e. ilog2(numlowerfs+1 - 1) + 1). fsid 0 is reserved for 1265795939a9SAmir Goldstein * upper fs even with non upper overlay. 1266795939a9SAmir Goldstein */ 1267795939a9SAmir Goldstein BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 31); 1268795939a9SAmir Goldstein ofs->xino_bits = ilog2(ofs->numlowerfs) + 1; 1269795939a9SAmir Goldstein } 1270795939a9SAmir Goldstein 1271795939a9SAmir Goldstein if (ofs->xino_bits) { 1272795939a9SAmir Goldstein pr_info("overlayfs: \"xino\" feature enabled using %d upper inode bits.\n", 1273795939a9SAmir Goldstein ofs->xino_bits); 1274795939a9SAmir Goldstein } 1275e487d889SAmir Goldstein 1276520d7c86SMiklos Szeredi err = 0; 1277520d7c86SMiklos Szeredi out: 1278520d7c86SMiklos Szeredi return err; 1279520d7c86SMiklos Szeredi } 1280520d7c86SMiklos Szeredi 12814155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1282ad204488SMiklos Szeredi struct ovl_fs *ofs) 128353dbb0b4SMiklos Szeredi { 128453dbb0b4SMiklos Szeredi int err; 128553dbb0b4SMiklos Szeredi char *lowertmp, *lower; 12864155c10aSMiklos Szeredi struct path *stack = NULL; 12874155c10aSMiklos Szeredi unsigned int stacklen, numlower = 0, i; 128853dbb0b4SMiklos Szeredi bool remote = false; 12894155c10aSMiklos Szeredi struct ovl_entry *oe; 129053dbb0b4SMiklos Szeredi 129153dbb0b4SMiklos Szeredi err = -ENOMEM; 1292ad204488SMiklos Szeredi lowertmp = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 129353dbb0b4SMiklos Szeredi if (!lowertmp) 12944155c10aSMiklos Szeredi goto out_err; 129553dbb0b4SMiklos Szeredi 129653dbb0b4SMiklos Szeredi err = -EINVAL; 129753dbb0b4SMiklos Szeredi stacklen = ovl_split_lowerdirs(lowertmp); 129853dbb0b4SMiklos Szeredi if (stacklen > OVL_MAX_STACK) { 129953dbb0b4SMiklos Szeredi pr_err("overlayfs: too many lower directories, limit is %d\n", 130053dbb0b4SMiklos Szeredi OVL_MAX_STACK); 13014155c10aSMiklos Szeredi goto out_err; 1302ad204488SMiklos Szeredi } else if (!ofs->config.upperdir && stacklen == 1) { 130353dbb0b4SMiklos Szeredi pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n"); 13044155c10aSMiklos Szeredi goto out_err; 1305f168f109SAmir Goldstein } else if (!ofs->config.upperdir && ofs->config.nfs_export && 1306f168f109SAmir Goldstein ofs->config.redirect_follow) { 1307f168f109SAmir Goldstein pr_warn("overlayfs: NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n"); 1308f168f109SAmir Goldstein ofs->config.nfs_export = false; 130953dbb0b4SMiklos Szeredi } 131053dbb0b4SMiklos Szeredi 131153dbb0b4SMiklos Szeredi err = -ENOMEM; 131253dbb0b4SMiklos Szeredi stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL); 131353dbb0b4SMiklos Szeredi if (!stack) 13144155c10aSMiklos Szeredi goto out_err; 131553dbb0b4SMiklos Szeredi 131653dbb0b4SMiklos Szeredi err = -EINVAL; 131753dbb0b4SMiklos Szeredi lower = lowertmp; 131853dbb0b4SMiklos Szeredi for (numlower = 0; numlower < stacklen; numlower++) { 1319ad204488SMiklos Szeredi err = ovl_lower_dir(lower, &stack[numlower], ofs, 132053dbb0b4SMiklos Szeredi &sb->s_stack_depth, &remote); 132153dbb0b4SMiklos Szeredi if (err) 13224155c10aSMiklos Szeredi goto out_err; 132353dbb0b4SMiklos Szeredi 132453dbb0b4SMiklos Szeredi lower = strchr(lower, '\0') + 1; 132553dbb0b4SMiklos Szeredi } 132653dbb0b4SMiklos Szeredi 132753dbb0b4SMiklos Szeredi err = -EINVAL; 132853dbb0b4SMiklos Szeredi sb->s_stack_depth++; 132953dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 133053dbb0b4SMiklos Szeredi pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 13314155c10aSMiklos Szeredi goto out_err; 133253dbb0b4SMiklos Szeredi } 133353dbb0b4SMiklos Szeredi 1334ad204488SMiklos Szeredi err = ovl_get_lower_layers(ofs, stack, numlower); 13354155c10aSMiklos Szeredi if (err) 13364155c10aSMiklos Szeredi goto out_err; 13374155c10aSMiklos Szeredi 13384155c10aSMiklos Szeredi err = -ENOMEM; 13394155c10aSMiklos Szeredi oe = ovl_alloc_entry(numlower); 13404155c10aSMiklos Szeredi if (!oe) 13414155c10aSMiklos Szeredi goto out_err; 13424155c10aSMiklos Szeredi 13434155c10aSMiklos Szeredi for (i = 0; i < numlower; i++) { 13444155c10aSMiklos Szeredi oe->lowerstack[i].dentry = dget(stack[i].dentry); 1345ad204488SMiklos Szeredi oe->lowerstack[i].layer = &ofs->lower_layers[i]; 13464155c10aSMiklos Szeredi } 134753dbb0b4SMiklos Szeredi 134853dbb0b4SMiklos Szeredi if (remote) 134953dbb0b4SMiklos Szeredi sb->s_d_op = &ovl_reval_dentry_operations; 135053dbb0b4SMiklos Szeredi else 135153dbb0b4SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 135253dbb0b4SMiklos Szeredi 135353dbb0b4SMiklos Szeredi out: 135453dbb0b4SMiklos Szeredi for (i = 0; i < numlower; i++) 135553dbb0b4SMiklos Szeredi path_put(&stack[i]); 135653dbb0b4SMiklos Szeredi kfree(stack); 13574155c10aSMiklos Szeredi kfree(lowertmp); 13584155c10aSMiklos Szeredi 13594155c10aSMiklos Szeredi return oe; 13604155c10aSMiklos Szeredi 13614155c10aSMiklos Szeredi out_err: 13624155c10aSMiklos Szeredi oe = ERR_PTR(err); 136353dbb0b4SMiklos Szeredi goto out; 136453dbb0b4SMiklos Szeredi } 136553dbb0b4SMiklos Szeredi 1366e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1367e9be9d5eSMiklos Szeredi { 136833006cdfSKees Cook struct path upperpath = { }; 1369e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 13704155c10aSMiklos Szeredi struct ovl_entry *oe; 1371ad204488SMiklos Szeredi struct ovl_fs *ofs; 137251f8f3c4SKonstantin Khlebnikov struct cred *cred; 1373e9be9d5eSMiklos Szeredi int err; 1374e9be9d5eSMiklos Szeredi 1375f45827e8SErez Zadok err = -ENOMEM; 1376ad204488SMiklos Szeredi ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1377ad204488SMiklos Szeredi if (!ofs) 1378e9be9d5eSMiklos Szeredi goto out; 1379e9be9d5eSMiklos Szeredi 1380ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1381c6fe6254SMiklos Szeredi if (!cred) 1382c6fe6254SMiklos Szeredi goto out_err; 1383c6fe6254SMiklos Szeredi 1384ad204488SMiklos Szeredi ofs->config.index = ovl_index_def; 1385f168f109SAmir Goldstein ofs->config.nfs_export = ovl_nfs_export_def; 1386795939a9SAmir Goldstein ofs->config.xino = ovl_xino_def(); 1387d5791044SVivek Goyal ofs->config.metacopy = ovl_metacopy_def; 1388ad204488SMiklos Szeredi err = ovl_parse_opt((char *) data, &ofs->config); 1389f45827e8SErez Zadok if (err) 1390a9075cdbSMiklos Szeredi goto out_err; 1391f45827e8SErez Zadok 1392e9be9d5eSMiklos Szeredi err = -EINVAL; 1393ad204488SMiklos Szeredi if (!ofs->config.lowerdir) { 139407f2af7bSKonstantin Khlebnikov if (!silent) 139553a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'lowerdir'\n"); 1396a9075cdbSMiklos Szeredi goto out_err; 139753a08cb9SMiklos Szeredi } 139853a08cb9SMiklos Szeredi 139953a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 1400cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 1401e487d889SAmir Goldstein /* Assume underlaying fs uses 32bit inodes unless proven otherwise */ 1402795939a9SAmir Goldstein if (ofs->config.xino != OVL_XINO_OFF) 1403e487d889SAmir Goldstein ofs->xino_bits = BITS_PER_LONG - 32; 1404795939a9SAmir Goldstein 1405ad204488SMiklos Szeredi if (ofs->config.upperdir) { 1406ad204488SMiklos Szeredi if (!ofs->config.workdir) { 140753a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'workdir'\n"); 1408a9075cdbSMiklos Szeredi goto out_err; 1409e9be9d5eSMiklos Szeredi } 1410e9be9d5eSMiklos Szeredi 1411ad204488SMiklos Szeredi err = ovl_get_upper(ofs, &upperpath); 141221a3b317SMiklos Szeredi if (err) 1413a9075cdbSMiklos Szeredi goto out_err; 1414d719e8f2SMiklos Szeredi 1415ad204488SMiklos Szeredi err = ovl_get_workdir(ofs, &upperpath); 14168ed61dc3SMiklos Szeredi if (err) 1417a9075cdbSMiklos Szeredi goto out_err; 1418c6fe6254SMiklos Szeredi 1419ad204488SMiklos Szeredi if (!ofs->workdir) 14201751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 14216e88256eSMiklos Szeredi 1422ad204488SMiklos Szeredi sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth; 1423ad204488SMiklos Szeredi sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran; 1424c6fe6254SMiklos Szeredi 142521765194SVivek Goyal } 1426ad204488SMiklos Szeredi oe = ovl_get_lowerstack(sb, ofs); 14274155c10aSMiklos Szeredi err = PTR_ERR(oe); 14284155c10aSMiklos Szeredi if (IS_ERR(oe)) 1429a9075cdbSMiklos Szeredi goto out_err; 1430e9be9d5eSMiklos Szeredi 143171cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 1432ad204488SMiklos Szeredi if (!ofs->upper_mnt) 14331751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 1434e9be9d5eSMiklos Szeredi 1435ad204488SMiklos Szeredi if (!(ovl_force_readonly(ofs)) && ofs->config.index) { 1436ad204488SMiklos Szeredi err = ovl_get_indexdir(ofs, oe, &upperpath); 143754fb347eSAmir Goldstein if (err) 14384155c10aSMiklos Szeredi goto out_free_oe; 14396e88256eSMiklos Szeredi 1440972d0093SAmir Goldstein /* Force r/o mount with no index dir */ 1441972d0093SAmir Goldstein if (!ofs->indexdir) { 1442972d0093SAmir Goldstein dput(ofs->workdir); 1443972d0093SAmir Goldstein ofs->workdir = NULL; 14441751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 144502bcd157SAmir Goldstein } 144602bcd157SAmir Goldstein 1447972d0093SAmir Goldstein } 1448972d0093SAmir Goldstein 1449972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */ 1450f168f109SAmir Goldstein if (!ofs->indexdir) { 1451ad204488SMiklos Szeredi ofs->config.index = false; 1452f168f109SAmir Goldstein if (ofs->upper_mnt && ofs->config.nfs_export) { 1453f168f109SAmir Goldstein pr_warn("overlayfs: NFS export requires an index dir, falling back to nfs_export=off.\n"); 1454f168f109SAmir Goldstein ofs->config.nfs_export = false; 1455f168f109SAmir Goldstein } 1456f168f109SAmir Goldstein } 145702bcd157SAmir Goldstein 1458d5791044SVivek Goyal if (ofs->config.metacopy && ofs->config.nfs_export) { 1459d5791044SVivek Goyal pr_warn("overlayfs: NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 1460d5791044SVivek Goyal ofs->config.nfs_export = false; 1461d5791044SVivek Goyal } 1462d5791044SVivek Goyal 14638383f174SAmir Goldstein if (ofs->config.nfs_export) 14648383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations; 14658383f174SAmir Goldstein 146651f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 146751f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 146851f8f3c4SKonstantin Khlebnikov 1469655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1470655042ccSVivek Goyal sb->s_op = &ovl_super_operations; 1471655042ccSVivek Goyal sb->s_xattr = ovl_xattr_handlers; 1472ad204488SMiklos Szeredi sb->s_fs_info = ofs; 1473de2a4a50SMiklos Szeredi sb->s_flags |= SB_POSIXACL; 1474655042ccSVivek Goyal 1475c6fe6254SMiklos Szeredi err = -ENOMEM; 1476ca4c8a3aSMiklos Szeredi root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 1477e9be9d5eSMiklos Szeredi if (!root_dentry) 14784155c10aSMiklos Szeredi goto out_free_oe; 1479e9be9d5eSMiklos Szeredi 1480c62520a8SAmir Goldstein root_dentry->d_fsdata = oe; 1481c62520a8SAmir Goldstein 1482e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 1483f3a15685SAmir Goldstein if (upperpath.dentry) { 1484c62520a8SAmir Goldstein ovl_dentry_set_upper_alias(root_dentry); 148513c72075SMiklos Szeredi if (ovl_is_impuredir(upperpath.dentry)) 148613c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, d_inode(root_dentry)); 1487f3a15685SAmir Goldstein } 1488e9be9d5eSMiklos Szeredi 1489b79e05aaSAmir Goldstein /* Root is always merge -> can have whiteouts */ 1490b79e05aaSAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root_dentry)); 14912ca3c148SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root_dentry); 14920c288874SVivek Goyal ovl_set_upperdata(d_inode(root_dentry)); 149309d8b586SMiklos Szeredi ovl_inode_init(d_inode(root_dentry), upperpath.dentry, 14942664bd08SVivek Goyal ovl_dentry_lower(root_dentry), NULL); 1495ed06e069SMiklos Szeredi 1496e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1497e9be9d5eSMiklos Szeredi 1498e9be9d5eSMiklos Szeredi return 0; 1499e9be9d5eSMiklos Szeredi 15004155c10aSMiklos Szeredi out_free_oe: 15014155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 1502b9343632SChandan Rajendra kfree(oe); 15034155c10aSMiklos Szeredi out_err: 1504e9be9d5eSMiklos Szeredi path_put(&upperpath); 1505ad204488SMiklos Szeredi ovl_free_fs(ofs); 1506e9be9d5eSMiklos Szeredi out: 1507e9be9d5eSMiklos Szeredi return err; 1508e9be9d5eSMiklos Szeredi } 1509e9be9d5eSMiklos Szeredi 1510e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 1511e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 1512e9be9d5eSMiklos Szeredi { 1513e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 1514e9be9d5eSMiklos Szeredi } 1515e9be9d5eSMiklos Szeredi 1516e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 1517e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1518ef94b186SMiklos Szeredi .name = "overlay", 1519e9be9d5eSMiklos Szeredi .mount = ovl_mount, 1520e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 1521e9be9d5eSMiklos Szeredi }; 1522ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 1523e9be9d5eSMiklos Szeredi 152413cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 152513cf199dSAmir Goldstein { 152613cf199dSAmir Goldstein struct ovl_inode *oi = foo; 152713cf199dSAmir Goldstein 152813cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 152913cf199dSAmir Goldstein } 153013cf199dSAmir Goldstein 1531e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 1532e9be9d5eSMiklos Szeredi { 153313cf199dSAmir Goldstein int err; 153413cf199dSAmir Goldstein 153513cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 153613cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 153713cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 153813cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 153913cf199dSAmir Goldstein ovl_inode_init_once); 154013cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 154113cf199dSAmir Goldstein return -ENOMEM; 154213cf199dSAmir Goldstein 154313cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 154413cf199dSAmir Goldstein if (err) 154513cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 154613cf199dSAmir Goldstein 154713cf199dSAmir Goldstein return err; 1548e9be9d5eSMiklos Szeredi } 1549e9be9d5eSMiklos Szeredi 1550e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1551e9be9d5eSMiklos Szeredi { 1552e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 155313cf199dSAmir Goldstein 155413cf199dSAmir Goldstein /* 155513cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 155613cf199dSAmir Goldstein * destroy cache. 155713cf199dSAmir Goldstein */ 155813cf199dSAmir Goldstein rcu_barrier(); 155913cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 156013cf199dSAmir Goldstein 1561e9be9d5eSMiklos Szeredi } 1562e9be9d5eSMiklos Szeredi 1563e9be9d5eSMiklos Szeredi module_init(ovl_init); 1564e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1565