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 67e9be9d5eSMiklos Szeredi static void ovl_dentry_release(struct dentry *dentry) 68e9be9d5eSMiklos Szeredi { 69e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 70e9be9d5eSMiklos Szeredi 71e9be9d5eSMiklos Szeredi if (oe) { 724155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 73e9be9d5eSMiklos Szeredi kfree_rcu(oe, rcu); 74e9be9d5eSMiklos Szeredi } 75e9be9d5eSMiklos Szeredi } 76e9be9d5eSMiklos Szeredi 772d902671SMiklos Szeredi static struct dentry *ovl_d_real(struct dentry *dentry, 78fb16043bSMiklos Szeredi const struct inode *inode) 79d101a125SMiklos Szeredi { 80d101a125SMiklos Szeredi struct dentry *real; 81d101a125SMiklos Szeredi 82e8c985baSMiklos Szeredi /* It's an overlay file */ 83e8c985baSMiklos Szeredi if (inode && d_inode(dentry) == inode) 84e8c985baSMiklos Szeredi return dentry; 85e8c985baSMiklos Szeredi 86ca4c8a3aSMiklos Szeredi if (!d_is_reg(dentry)) { 87d101a125SMiklos Szeredi if (!inode || inode == d_inode(dentry)) 88d101a125SMiklos Szeredi return dentry; 89d101a125SMiklos Szeredi goto bug; 90d101a125SMiklos Szeredi } 91d101a125SMiklos Szeredi 92d101a125SMiklos Szeredi real = ovl_dentry_upper(dentry); 93fb16043bSMiklos Szeredi if (real && (!inode || inode == d_inode(real))) 94d101a125SMiklos Szeredi return real; 95d101a125SMiklos Szeredi 96d101a125SMiklos Szeredi real = ovl_dentry_lower(dentry); 97d101a125SMiklos Szeredi if (!real) 98d101a125SMiklos Szeredi goto bug; 99d101a125SMiklos Szeredi 100c4fcfc16SMiklos Szeredi /* Handle recursion */ 101fb16043bSMiklos Szeredi real = d_real(real, inode); 102c4fcfc16SMiklos Szeredi 103d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 104d101a125SMiklos Szeredi return real; 105d101a125SMiklos Szeredi bug: 106656189d2SMiklos Szeredi WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry, 107d101a125SMiklos Szeredi inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0); 108d101a125SMiklos Szeredi return dentry; 109d101a125SMiklos Szeredi } 110d101a125SMiklos Szeredi 1117c03b5d4SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 1127c03b5d4SMiklos Szeredi { 1137c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1147c03b5d4SMiklos Szeredi unsigned int i; 1157c03b5d4SMiklos Szeredi int ret = 1; 1167c03b5d4SMiklos Szeredi 1177c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1187c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1197c03b5d4SMiklos Szeredi 1207c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_REVALIDATE) { 1217c03b5d4SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1227c03b5d4SMiklos Szeredi if (ret < 0) 1237c03b5d4SMiklos Szeredi return ret; 1247c03b5d4SMiklos Szeredi if (!ret) { 1257c03b5d4SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1267c03b5d4SMiklos Szeredi d_invalidate(d); 1277c03b5d4SMiklos Szeredi return -ESTALE; 1287c03b5d4SMiklos Szeredi } 1297c03b5d4SMiklos Szeredi } 1307c03b5d4SMiklos Szeredi } 1317c03b5d4SMiklos Szeredi return 1; 1327c03b5d4SMiklos Szeredi } 1337c03b5d4SMiklos Szeredi 1347c03b5d4SMiklos Szeredi static int ovl_dentry_weak_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_WEAK_REVALIDATE) { 1447c03b5d4SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1457c03b5d4SMiklos Szeredi if (ret <= 0) 1467c03b5d4SMiklos Szeredi break; 1477c03b5d4SMiklos Szeredi } 1487c03b5d4SMiklos Szeredi } 1497c03b5d4SMiklos Szeredi return ret; 1507c03b5d4SMiklos Szeredi } 1517c03b5d4SMiklos Szeredi 152e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 153e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 154d101a125SMiklos Szeredi .d_real = ovl_d_real, 155e9be9d5eSMiklos Szeredi }; 156e9be9d5eSMiklos Szeredi 1577c03b5d4SMiklos Szeredi static const struct dentry_operations ovl_reval_dentry_operations = { 1587c03b5d4SMiklos Szeredi .d_release = ovl_dentry_release, 159d101a125SMiklos Szeredi .d_real = ovl_d_real, 1607c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1617c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1627c03b5d4SMiklos Szeredi }; 1637c03b5d4SMiklos Szeredi 16413cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 16513cf199dSAmir Goldstein 16613cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 16713cf199dSAmir Goldstein { 16813cf199dSAmir Goldstein struct ovl_inode *oi = kmem_cache_alloc(ovl_inode_cachep, GFP_KERNEL); 16913cf199dSAmir Goldstein 170b3885bd6SHirofumi Nakagawa if (!oi) 171b3885bd6SHirofumi Nakagawa return NULL; 172b3885bd6SHirofumi Nakagawa 17304a01ac7SMiklos Szeredi oi->cache = NULL; 174cf31c463SMiklos Szeredi oi->redirect = NULL; 17504a01ac7SMiklos Szeredi oi->version = 0; 17613c72075SMiklos Szeredi oi->flags = 0; 17709d8b586SMiklos Szeredi oi->__upperdentry = NULL; 17825b7713aSMiklos Szeredi oi->lower = NULL; 179a015dafcSAmir Goldstein mutex_init(&oi->lock); 18025b7713aSMiklos Szeredi 18113cf199dSAmir Goldstein return &oi->vfs_inode; 18213cf199dSAmir Goldstein } 18313cf199dSAmir Goldstein 18413cf199dSAmir Goldstein static void ovl_i_callback(struct rcu_head *head) 18513cf199dSAmir Goldstein { 18613cf199dSAmir Goldstein struct inode *inode = container_of(head, struct inode, i_rcu); 18713cf199dSAmir Goldstein 18813cf199dSAmir Goldstein kmem_cache_free(ovl_inode_cachep, OVL_I(inode)); 18913cf199dSAmir Goldstein } 19013cf199dSAmir Goldstein 19113cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 19213cf199dSAmir Goldstein { 19309d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 19409d8b586SMiklos Szeredi 19509d8b586SMiklos Szeredi dput(oi->__upperdentry); 19631747edaSAmir Goldstein iput(oi->lower); 197cf31c463SMiklos Szeredi kfree(oi->redirect); 1984edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 199a015dafcSAmir Goldstein mutex_destroy(&oi->lock); 20009d8b586SMiklos Szeredi 20113cf199dSAmir Goldstein call_rcu(&inode->i_rcu, ovl_i_callback); 20213cf199dSAmir Goldstein } 20313cf199dSAmir Goldstein 204ad204488SMiklos Szeredi static void ovl_free_fs(struct ovl_fs *ofs) 205e9be9d5eSMiklos Szeredi { 206dd662667SMiklos Szeredi unsigned i; 207e9be9d5eSMiklos Szeredi 208ad204488SMiklos Szeredi dput(ofs->indexdir); 209ad204488SMiklos Szeredi dput(ofs->workdir); 210ad204488SMiklos Szeredi if (ofs->workdir_locked) 211ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->workbasedir); 212ad204488SMiklos Szeredi dput(ofs->workbasedir); 213ad204488SMiklos Szeredi if (ofs->upperdir_locked) 214ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->upper_mnt->mnt_root); 215ad204488SMiklos Szeredi mntput(ofs->upper_mnt); 2165148626bSAmir Goldstein for (i = 0; i < ofs->numlower; i++) 217ad204488SMiklos Szeredi mntput(ofs->lower_layers[i].mnt); 2185148626bSAmir Goldstein for (i = 0; i < ofs->numlowerfs; i++) 2195148626bSAmir Goldstein free_anon_bdev(ofs->lower_fs[i].pseudo_dev); 220ad204488SMiklos Szeredi kfree(ofs->lower_layers); 2215148626bSAmir Goldstein kfree(ofs->lower_fs); 222e9be9d5eSMiklos Szeredi 223ad204488SMiklos Szeredi kfree(ofs->config.lowerdir); 224ad204488SMiklos Szeredi kfree(ofs->config.upperdir); 225ad204488SMiklos Szeredi kfree(ofs->config.workdir); 226438c84c2SMiklos Szeredi kfree(ofs->config.redirect_mode); 227ad204488SMiklos Szeredi if (ofs->creator_cred) 228ad204488SMiklos Szeredi put_cred(ofs->creator_cred); 229ad204488SMiklos Szeredi kfree(ofs); 230e9be9d5eSMiklos Szeredi } 231e9be9d5eSMiklos Szeredi 232a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 233a9075cdbSMiklos Szeredi { 234a9075cdbSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 235a9075cdbSMiklos Szeredi 236a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 237a9075cdbSMiklos Szeredi } 238a9075cdbSMiklos Szeredi 239e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */ 240e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 241e593b2bfSAmir Goldstein { 242ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 243e593b2bfSAmir Goldstein struct super_block *upper_sb; 244e593b2bfSAmir Goldstein int ret; 245e593b2bfSAmir Goldstein 246ad204488SMiklos Szeredi if (!ofs->upper_mnt) 247e593b2bfSAmir Goldstein return 0; 248e8d4bfe3SChengguang Xu 249e8d4bfe3SChengguang Xu /* 250e8d4bfe3SChengguang Xu * If this is a sync(2) call or an emergency sync, all the super blocks 251e8d4bfe3SChengguang Xu * will be iterated, including upper_sb, so no need to do anything. 252e8d4bfe3SChengguang Xu * 253e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call 254e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being 255e8d4bfe3SChengguang Xu * called with wait == 1. 256e8d4bfe3SChengguang Xu */ 257e8d4bfe3SChengguang Xu if (!wait) 258e593b2bfSAmir Goldstein return 0; 259e593b2bfSAmir Goldstein 260e8d4bfe3SChengguang Xu upper_sb = ofs->upper_mnt->mnt_sb; 261e8d4bfe3SChengguang Xu 262e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 263e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb); 264e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 265e8d4bfe3SChengguang Xu 266e593b2bfSAmir Goldstein return ret; 267e593b2bfSAmir Goldstein } 268e593b2bfSAmir Goldstein 269cc259639SAndy Whitcroft /** 270cc259639SAndy Whitcroft * ovl_statfs 271cc259639SAndy Whitcroft * @sb: The overlayfs super block 272cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 273cc259639SAndy Whitcroft * 274cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 2754ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 276cc259639SAndy Whitcroft */ 277cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 278cc259639SAndy Whitcroft { 279cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 280cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 281cc259639SAndy Whitcroft struct path path; 282cc259639SAndy Whitcroft int err; 283cc259639SAndy Whitcroft 2844ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 285cc259639SAndy Whitcroft 286cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 287cc259639SAndy Whitcroft if (!err) { 2886b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 289cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 290cc259639SAndy Whitcroft } 291cc259639SAndy Whitcroft 292cc259639SAndy Whitcroft return err; 293cc259639SAndy Whitcroft } 294cc259639SAndy Whitcroft 29502bcd157SAmir Goldstein /* Will this overlay be forced to mount/remount ro? */ 296ad204488SMiklos Szeredi static bool ovl_force_readonly(struct ovl_fs *ofs) 29702bcd157SAmir Goldstein { 298ad204488SMiklos Szeredi return (!ofs->upper_mnt || !ofs->workdir); 29902bcd157SAmir Goldstein } 30002bcd157SAmir Goldstein 301438c84c2SMiklos Szeredi static const char *ovl_redirect_mode_def(void) 302438c84c2SMiklos Szeredi { 303438c84c2SMiklos Szeredi return ovl_redirect_dir_def ? "on" : "off"; 304438c84c2SMiklos Szeredi } 305438c84c2SMiklos Szeredi 306795939a9SAmir Goldstein enum { 307795939a9SAmir Goldstein OVL_XINO_OFF, 308795939a9SAmir Goldstein OVL_XINO_AUTO, 309795939a9SAmir Goldstein OVL_XINO_ON, 310795939a9SAmir Goldstein }; 311795939a9SAmir Goldstein 312795939a9SAmir Goldstein static const char * const ovl_xino_str[] = { 313795939a9SAmir Goldstein "off", 314795939a9SAmir Goldstein "auto", 315795939a9SAmir Goldstein "on", 316795939a9SAmir Goldstein }; 317795939a9SAmir Goldstein 318795939a9SAmir Goldstein static inline int ovl_xino_def(void) 319795939a9SAmir Goldstein { 320795939a9SAmir Goldstein return ovl_xino_auto_def ? OVL_XINO_AUTO : OVL_XINO_OFF; 321795939a9SAmir Goldstein } 322795939a9SAmir Goldstein 323f45827e8SErez Zadok /** 324f45827e8SErez Zadok * ovl_show_options 325f45827e8SErez Zadok * 326f45827e8SErez Zadok * Prints the mount options for a given superblock. 327f45827e8SErez Zadok * Returns zero; does not fail. 328f45827e8SErez Zadok */ 329f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 330f45827e8SErez Zadok { 331f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 332ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 333f45827e8SErez Zadok 334ad204488SMiklos Szeredi seq_show_option(m, "lowerdir", ofs->config.lowerdir); 335ad204488SMiklos Szeredi if (ofs->config.upperdir) { 336ad204488SMiklos Szeredi seq_show_option(m, "upperdir", ofs->config.upperdir); 337ad204488SMiklos Szeredi seq_show_option(m, "workdir", ofs->config.workdir); 33853a08cb9SMiklos Szeredi } 339ad204488SMiklos Szeredi if (ofs->config.default_permissions) 3408d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 341438c84c2SMiklos Szeredi if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0) 342438c84c2SMiklos Szeredi seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode); 343ad204488SMiklos Szeredi if (ofs->config.index != ovl_index_def) 344438c84c2SMiklos Szeredi seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 345f168f109SAmir Goldstein if (ofs->config.nfs_export != ovl_nfs_export_def) 346f168f109SAmir Goldstein seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ? 347f168f109SAmir Goldstein "on" : "off"); 348795939a9SAmir Goldstein if (ofs->config.xino != ovl_xino_def()) 349795939a9SAmir Goldstein seq_printf(m, ",xino=%s", ovl_xino_str[ofs->config.xino]); 350f45827e8SErez Zadok return 0; 351f45827e8SErez Zadok } 352f45827e8SErez Zadok 3533cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 3543cdf6fe9SSeunghun Lee { 355ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 3563cdf6fe9SSeunghun Lee 3571751e8a6SLinus Torvalds if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 3583cdf6fe9SSeunghun Lee return -EROFS; 3593cdf6fe9SSeunghun Lee 3603cdf6fe9SSeunghun Lee return 0; 3613cdf6fe9SSeunghun Lee } 3623cdf6fe9SSeunghun Lee 363e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 36413cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 36513cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 36613cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 367e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 368e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 369cc259639SAndy Whitcroft .statfs = ovl_statfs, 370f45827e8SErez Zadok .show_options = ovl_show_options, 3713cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 372e9be9d5eSMiklos Szeredi }; 373e9be9d5eSMiklos Szeredi 374e9be9d5eSMiklos Szeredi enum { 375e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 376e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 377e9be9d5eSMiklos Szeredi OPT_WORKDIR, 3788d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 379438c84c2SMiklos Szeredi OPT_REDIRECT_DIR, 38002bcd157SAmir Goldstein OPT_INDEX_ON, 38102bcd157SAmir Goldstein OPT_INDEX_OFF, 382f168f109SAmir Goldstein OPT_NFS_EXPORT_ON, 383f168f109SAmir Goldstein OPT_NFS_EXPORT_OFF, 384795939a9SAmir Goldstein OPT_XINO_ON, 385795939a9SAmir Goldstein OPT_XINO_OFF, 386795939a9SAmir Goldstein OPT_XINO_AUTO, 387e9be9d5eSMiklos Szeredi OPT_ERR, 388e9be9d5eSMiklos Szeredi }; 389e9be9d5eSMiklos Szeredi 390e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 391e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 392e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 393e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 3948d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 395438c84c2SMiklos Szeredi {OPT_REDIRECT_DIR, "redirect_dir=%s"}, 39602bcd157SAmir Goldstein {OPT_INDEX_ON, "index=on"}, 39702bcd157SAmir Goldstein {OPT_INDEX_OFF, "index=off"}, 398f168f109SAmir Goldstein {OPT_NFS_EXPORT_ON, "nfs_export=on"}, 399f168f109SAmir Goldstein {OPT_NFS_EXPORT_OFF, "nfs_export=off"}, 400795939a9SAmir Goldstein {OPT_XINO_ON, "xino=on"}, 401795939a9SAmir Goldstein {OPT_XINO_OFF, "xino=off"}, 402795939a9SAmir Goldstein {OPT_XINO_AUTO, "xino=auto"}, 403e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 404e9be9d5eSMiklos Szeredi }; 405e9be9d5eSMiklos Szeredi 40691c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 40791c77947SMiklos Szeredi { 40891c77947SMiklos Szeredi char *sbegin = *s; 40991c77947SMiklos Szeredi char *p; 41091c77947SMiklos Szeredi 41191c77947SMiklos Szeredi if (sbegin == NULL) 41291c77947SMiklos Szeredi return NULL; 41391c77947SMiklos Szeredi 41491c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 41591c77947SMiklos Szeredi if (*p == '\\') { 41691c77947SMiklos Szeredi p++; 41791c77947SMiklos Szeredi if (!*p) 41891c77947SMiklos Szeredi break; 41991c77947SMiklos Szeredi } else if (*p == ',') { 42091c77947SMiklos Szeredi *p = '\0'; 42191c77947SMiklos Szeredi *s = p + 1; 42291c77947SMiklos Szeredi return sbegin; 42391c77947SMiklos Szeredi } 42491c77947SMiklos Szeredi } 42591c77947SMiklos Szeredi *s = NULL; 42691c77947SMiklos Szeredi return sbegin; 42791c77947SMiklos Szeredi } 42891c77947SMiklos Szeredi 429438c84c2SMiklos Szeredi static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode) 430438c84c2SMiklos Szeredi { 431438c84c2SMiklos Szeredi if (strcmp(mode, "on") == 0) { 432438c84c2SMiklos Szeredi config->redirect_dir = true; 433438c84c2SMiklos Szeredi /* 434438c84c2SMiklos Szeredi * Does not make sense to have redirect creation without 435438c84c2SMiklos Szeredi * redirect following. 436438c84c2SMiklos Szeredi */ 437438c84c2SMiklos Szeredi config->redirect_follow = true; 438438c84c2SMiklos Szeredi } else if (strcmp(mode, "follow") == 0) { 439438c84c2SMiklos Szeredi config->redirect_follow = true; 440438c84c2SMiklos Szeredi } else if (strcmp(mode, "off") == 0) { 441438c84c2SMiklos Szeredi if (ovl_redirect_always_follow) 442438c84c2SMiklos Szeredi config->redirect_follow = true; 443438c84c2SMiklos Szeredi } else if (strcmp(mode, "nofollow") != 0) { 444438c84c2SMiklos Szeredi pr_err("overlayfs: bad mount option \"redirect_dir=%s\"\n", 445438c84c2SMiklos Szeredi mode); 446438c84c2SMiklos Szeredi return -EINVAL; 447438c84c2SMiklos Szeredi } 448438c84c2SMiklos Szeredi 449438c84c2SMiklos Szeredi return 0; 450438c84c2SMiklos Szeredi } 451438c84c2SMiklos Szeredi 452e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 453e9be9d5eSMiklos Szeredi { 454e9be9d5eSMiklos Szeredi char *p; 455e9be9d5eSMiklos Szeredi 456438c84c2SMiklos Szeredi config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL); 457438c84c2SMiklos Szeredi if (!config->redirect_mode) 458438c84c2SMiklos Szeredi return -ENOMEM; 459438c84c2SMiklos Szeredi 46091c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 461e9be9d5eSMiklos Szeredi int token; 462e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 463e9be9d5eSMiklos Szeredi 464e9be9d5eSMiklos Szeredi if (!*p) 465e9be9d5eSMiklos Szeredi continue; 466e9be9d5eSMiklos Szeredi 467e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 468e9be9d5eSMiklos Szeredi switch (token) { 469e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 470e9be9d5eSMiklos Szeredi kfree(config->upperdir); 471e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 472e9be9d5eSMiklos Szeredi if (!config->upperdir) 473e9be9d5eSMiklos Szeredi return -ENOMEM; 474e9be9d5eSMiklos Szeredi break; 475e9be9d5eSMiklos Szeredi 476e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 477e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 478e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 479e9be9d5eSMiklos Szeredi if (!config->lowerdir) 480e9be9d5eSMiklos Szeredi return -ENOMEM; 481e9be9d5eSMiklos Szeredi break; 482e9be9d5eSMiklos Szeredi 483e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 484e9be9d5eSMiklos Szeredi kfree(config->workdir); 485e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 486e9be9d5eSMiklos Szeredi if (!config->workdir) 487e9be9d5eSMiklos Szeredi return -ENOMEM; 488e9be9d5eSMiklos Szeredi break; 489e9be9d5eSMiklos Szeredi 4908d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 4918d3095f4SMiklos Szeredi config->default_permissions = true; 4928d3095f4SMiklos Szeredi break; 4938d3095f4SMiklos Szeredi 494438c84c2SMiklos Szeredi case OPT_REDIRECT_DIR: 495438c84c2SMiklos Szeredi kfree(config->redirect_mode); 496438c84c2SMiklos Szeredi config->redirect_mode = match_strdup(&args[0]); 497438c84c2SMiklos Szeredi if (!config->redirect_mode) 498438c84c2SMiklos Szeredi return -ENOMEM; 499a6c60655SMiklos Szeredi break; 500a6c60655SMiklos Szeredi 50102bcd157SAmir Goldstein case OPT_INDEX_ON: 50202bcd157SAmir Goldstein config->index = true; 50302bcd157SAmir Goldstein break; 50402bcd157SAmir Goldstein 50502bcd157SAmir Goldstein case OPT_INDEX_OFF: 50602bcd157SAmir Goldstein config->index = false; 50702bcd157SAmir Goldstein break; 50802bcd157SAmir Goldstein 509f168f109SAmir Goldstein case OPT_NFS_EXPORT_ON: 510f168f109SAmir Goldstein config->nfs_export = true; 511f168f109SAmir Goldstein break; 512f168f109SAmir Goldstein 513f168f109SAmir Goldstein case OPT_NFS_EXPORT_OFF: 514f168f109SAmir Goldstein config->nfs_export = false; 515f168f109SAmir Goldstein break; 516f168f109SAmir Goldstein 517795939a9SAmir Goldstein case OPT_XINO_ON: 518795939a9SAmir Goldstein config->xino = OVL_XINO_ON; 519795939a9SAmir Goldstein break; 520795939a9SAmir Goldstein 521795939a9SAmir Goldstein case OPT_XINO_OFF: 522795939a9SAmir Goldstein config->xino = OVL_XINO_OFF; 523795939a9SAmir Goldstein break; 524795939a9SAmir Goldstein 525795939a9SAmir Goldstein case OPT_XINO_AUTO: 526795939a9SAmir Goldstein config->xino = OVL_XINO_AUTO; 527795939a9SAmir Goldstein break; 528795939a9SAmir Goldstein 529e9be9d5eSMiklos Szeredi default: 530bead55efShujianyang pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p); 531e9be9d5eSMiklos Szeredi return -EINVAL; 532e9be9d5eSMiklos Szeredi } 533e9be9d5eSMiklos Szeredi } 53471cbad7eShujianyang 53571cbad7eShujianyang /* Workdir is useless in non-upper mount */ 53671cbad7eShujianyang if (!config->upperdir && config->workdir) { 53771cbad7eShujianyang pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 53871cbad7eShujianyang config->workdir); 53971cbad7eShujianyang kfree(config->workdir); 54071cbad7eShujianyang config->workdir = NULL; 54171cbad7eShujianyang } 54271cbad7eShujianyang 543438c84c2SMiklos Szeredi return ovl_parse_redirect_mode(config, config->redirect_mode); 544e9be9d5eSMiklos Szeredi } 545e9be9d5eSMiklos Szeredi 546e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 54702bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 548e9be9d5eSMiklos Szeredi 549ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 5506b8aa129SAmir Goldstein const char *name, bool persist) 551e9be9d5eSMiklos Szeredi { 552ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 553ad204488SMiklos Szeredi struct vfsmount *mnt = ofs->upper_mnt; 554e9be9d5eSMiklos Szeredi struct dentry *work; 555e9be9d5eSMiklos Szeredi int err; 556e9be9d5eSMiklos Szeredi bool retried = false; 5576b8aa129SAmir Goldstein bool locked = false; 558e9be9d5eSMiklos Szeredi 5595955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 5606b8aa129SAmir Goldstein locked = true; 5616b8aa129SAmir Goldstein 562e9be9d5eSMiklos Szeredi retry: 563ad204488SMiklos Szeredi work = lookup_one_len(name, ofs->workbasedir, strlen(name)); 564e9be9d5eSMiklos Szeredi 565e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 566c11b9fddSMiklos Szeredi struct iattr attr = { 567c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 56832a3d848SAl Viro .ia_mode = S_IFDIR | 0, 569c11b9fddSMiklos Szeredi }; 570e9be9d5eSMiklos Szeredi 571e9be9d5eSMiklos Szeredi if (work->d_inode) { 572e9be9d5eSMiklos Szeredi err = -EEXIST; 573e9be9d5eSMiklos Szeredi if (retried) 574e9be9d5eSMiklos Szeredi goto out_dput; 575e9be9d5eSMiklos Szeredi 5766b8aa129SAmir Goldstein if (persist) 5776b8aa129SAmir Goldstein goto out_unlock; 5786b8aa129SAmir Goldstein 579e9be9d5eSMiklos Szeredi retried = true; 580eea2fb48SMiklos Szeredi ovl_workdir_cleanup(dir, mnt, work, 0); 581e9be9d5eSMiklos Szeredi dput(work); 582e9be9d5eSMiklos Szeredi goto retry; 583e9be9d5eSMiklos Szeredi } 584e9be9d5eSMiklos Szeredi 58595a1c815SMiklos Szeredi work = ovl_create_real(dir, work, OVL_CATTR(attr.ia_mode)); 58695a1c815SMiklos Szeredi err = PTR_ERR(work); 58795a1c815SMiklos Szeredi if (IS_ERR(work)) 58895a1c815SMiklos Szeredi goto out_err; 589c11b9fddSMiklos Szeredi 590cb348edbSMiklos Szeredi /* 591cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 592cb348edbSMiklos Szeredi * 593cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 594cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 595cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 596cb348edbSMiklos Szeredi * 597cb348edbSMiklos Szeredi * There are various other error values that could effectively 598cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 599cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 600cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 601cb348edbSMiklos Szeredi * for the above two errors is sufficient. 602cb348edbSMiklos Szeredi */ 603c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 604e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 605c11b9fddSMiklos Szeredi goto out_dput; 606c11b9fddSMiklos Szeredi 607c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 608e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 609c11b9fddSMiklos Szeredi goto out_dput; 610c11b9fddSMiklos Szeredi 611c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 612c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 613c11b9fddSMiklos Szeredi err = notify_change(work, &attr, NULL); 614c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 615c11b9fddSMiklos Szeredi if (err) 616c11b9fddSMiklos Szeredi goto out_dput; 6176b8aa129SAmir Goldstein } else { 6186b8aa129SAmir Goldstein err = PTR_ERR(work); 6196b8aa129SAmir Goldstein goto out_err; 620e9be9d5eSMiklos Szeredi } 621e9be9d5eSMiklos Szeredi out_unlock: 6226b8aa129SAmir Goldstein if (locked) 6236b8aa129SAmir Goldstein inode_unlock(dir); 624e9be9d5eSMiklos Szeredi 625e9be9d5eSMiklos Szeredi return work; 626e9be9d5eSMiklos Szeredi 627e9be9d5eSMiklos Szeredi out_dput: 628e9be9d5eSMiklos Szeredi dput(work); 6296b8aa129SAmir Goldstein out_err: 6306b8aa129SAmir Goldstein pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n", 631ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 6326b8aa129SAmir Goldstein work = NULL; 633e9be9d5eSMiklos Szeredi goto out_unlock; 634e9be9d5eSMiklos Szeredi } 635e9be9d5eSMiklos Szeredi 63691c77947SMiklos Szeredi static void ovl_unescape(char *s) 63791c77947SMiklos Szeredi { 63891c77947SMiklos Szeredi char *d = s; 63991c77947SMiklos Szeredi 64091c77947SMiklos Szeredi for (;; s++, d++) { 64191c77947SMiklos Szeredi if (*s == '\\') 64291c77947SMiklos Szeredi s++; 64391c77947SMiklos Szeredi *d = *s; 64491c77947SMiklos Szeredi if (!*s) 64591c77947SMiklos Szeredi break; 64691c77947SMiklos Szeredi } 64791c77947SMiklos Szeredi } 64891c77947SMiklos Szeredi 649ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 650ab508822SMiklos Szeredi { 651a78d9f0dSMiklos Szeredi int err = -EINVAL; 652ab508822SMiklos Szeredi 653a78d9f0dSMiklos Szeredi if (!*name) { 654a78d9f0dSMiklos Szeredi pr_err("overlayfs: empty lowerdir\n"); 655a78d9f0dSMiklos Szeredi goto out; 656a78d9f0dSMiklos Szeredi } 657ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 658ab508822SMiklos Szeredi if (err) { 659ab508822SMiklos Szeredi pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); 660ab508822SMiklos Szeredi goto out; 661ab508822SMiklos Szeredi } 662ab508822SMiklos Szeredi err = -EINVAL; 6637c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 664ab508822SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported\n", name); 665ab508822SMiklos Szeredi goto out_put; 666ab508822SMiklos Szeredi } 6672b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 668ab508822SMiklos Szeredi pr_err("overlayfs: '%s' not a directory\n", name); 669ab508822SMiklos Szeredi goto out_put; 670ab508822SMiklos Szeredi } 671ab508822SMiklos Szeredi return 0; 672ab508822SMiklos Szeredi 673ab508822SMiklos Szeredi out_put: 6748aafcb59SMiklos Szeredi path_put_init(path); 675ab508822SMiklos Szeredi out: 676ab508822SMiklos Szeredi return err; 677ab508822SMiklos Szeredi } 678ab508822SMiklos Szeredi 679ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 680ab508822SMiklos Szeredi { 681ab508822SMiklos Szeredi int err = -ENOMEM; 682ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 683ab508822SMiklos Szeredi 684ab508822SMiklos Szeredi if (tmp) { 685ab508822SMiklos Szeredi ovl_unescape(tmp); 686ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 6877c03b5d4SMiklos Szeredi 6887c03b5d4SMiklos Szeredi if (!err) 6897c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) { 6907c03b5d4SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n", 6917c03b5d4SMiklos Szeredi tmp); 6928aafcb59SMiklos Szeredi path_put_init(path); 6937c03b5d4SMiklos Szeredi err = -EINVAL; 6947c03b5d4SMiklos Szeredi } 695ab508822SMiklos Szeredi kfree(tmp); 696ab508822SMiklos Szeredi } 697ab508822SMiklos Szeredi return err; 698ab508822SMiklos Szeredi } 699ab508822SMiklos Szeredi 7006b2d5fe4SMiklos Szeredi static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 7016b2d5fe4SMiklos Szeredi const char *name) 7026b2d5fe4SMiklos Szeredi { 7036b2d5fe4SMiklos Szeredi struct kstatfs statfs; 7046b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 7056b2d5fe4SMiklos Szeredi 7066b2d5fe4SMiklos Szeredi if (err) 7076b2d5fe4SMiklos Szeredi pr_err("overlayfs: statfs failed on '%s'\n", name); 7086b2d5fe4SMiklos Szeredi else 7096b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 7106b2d5fe4SMiklos Szeredi 7116b2d5fe4SMiklos Szeredi return err; 7126b2d5fe4SMiklos Szeredi } 7136b2d5fe4SMiklos Szeredi 7146b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 7156b2d5fe4SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth, bool *remote) 716ab508822SMiklos Szeredi { 717e487d889SAmir Goldstein int fh_type; 718ab508822SMiklos Szeredi int err; 719ab508822SMiklos Szeredi 720a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 721ab508822SMiklos Szeredi if (err) 722ab508822SMiklos Szeredi goto out; 723ab508822SMiklos Szeredi 7246b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 7256b2d5fe4SMiklos Szeredi if (err) 726ab508822SMiklos Szeredi goto out_put; 7276b2d5fe4SMiklos Szeredi 728ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 729ab508822SMiklos Szeredi 7307c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) 7317c03b5d4SMiklos Szeredi *remote = true; 7327c03b5d4SMiklos Szeredi 73302bcd157SAmir Goldstein /* 734f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode 735f168f109SAmir Goldstein * file handles, so they require that all layers support them. 73602bcd157SAmir Goldstein */ 737e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(path->dentry->d_sb); 738f168f109SAmir Goldstein if ((ofs->config.nfs_export || 739e487d889SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 74002bcd157SAmir Goldstein ofs->config.index = false; 741f168f109SAmir Goldstein ofs->config.nfs_export = false; 742f168f109SAmir Goldstein pr_warn("overlayfs: fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 743f168f109SAmir Goldstein name); 74402bcd157SAmir Goldstein } 74502bcd157SAmir Goldstein 746e487d889SAmir Goldstein /* Check if lower fs has 32bit inode numbers */ 747e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 748e487d889SAmir Goldstein ofs->xino_bits = 0; 749e487d889SAmir Goldstein 750ab508822SMiklos Szeredi return 0; 751ab508822SMiklos Szeredi 752ab508822SMiklos Szeredi out_put: 7538aafcb59SMiklos Szeredi path_put_init(path); 754ab508822SMiklos Szeredi out: 755ab508822SMiklos Szeredi return err; 756ab508822SMiklos Szeredi } 757ab508822SMiklos Szeredi 758e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 759e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 760e9be9d5eSMiklos Szeredi { 761e9be9d5eSMiklos Szeredi bool ok = false; 762e9be9d5eSMiklos Szeredi 763e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 764e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 765e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 766e9be9d5eSMiklos Szeredi } 767e9be9d5eSMiklos Szeredi return ok; 768e9be9d5eSMiklos Szeredi } 769e9be9d5eSMiklos Szeredi 770a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 771a78d9f0dSMiklos Szeredi { 772a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 773a78d9f0dSMiklos Szeredi char *s, *d; 774a78d9f0dSMiklos Szeredi 775a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 776a78d9f0dSMiklos Szeredi if (*s == '\\') { 777a78d9f0dSMiklos Szeredi s++; 778a78d9f0dSMiklos Szeredi } else if (*s == ':') { 779a78d9f0dSMiklos Szeredi *d = '\0'; 780a78d9f0dSMiklos Szeredi ctr++; 781a78d9f0dSMiklos Szeredi continue; 782a78d9f0dSMiklos Szeredi } 783a78d9f0dSMiklos Szeredi *d = *s; 784a78d9f0dSMiklos Szeredi if (!*s) 785a78d9f0dSMiklos Szeredi break; 786a78d9f0dSMiklos Szeredi } 787a78d9f0dSMiklos Szeredi return ctr; 788a78d9f0dSMiklos Szeredi } 789a78d9f0dSMiklos Szeredi 7900c97be22SAndreas Gruenbacher static int __maybe_unused 7910eb45fc3SAndreas Gruenbacher ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 7920eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 7930eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 7940eb45fc3SAndreas Gruenbacher { 7951d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 7960eb45fc3SAndreas Gruenbacher } 7970eb45fc3SAndreas Gruenbacher 7980eb45fc3SAndreas Gruenbacher static int __maybe_unused 7990c97be22SAndreas Gruenbacher ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 800d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 801d837a49bSMiklos Szeredi const char *name, const void *value, 802d837a49bSMiklos Szeredi size_t size, int flags) 803d837a49bSMiklos Szeredi { 804d837a49bSMiklos Szeredi struct dentry *workdir = ovl_workdir(dentry); 80509d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 806d837a49bSMiklos Szeredi struct posix_acl *acl = NULL; 807d837a49bSMiklos Szeredi int err; 808d837a49bSMiklos Szeredi 809d837a49bSMiklos Szeredi /* Check that everything is OK before copy-up */ 810d837a49bSMiklos Szeredi if (value) { 811d837a49bSMiklos Szeredi acl = posix_acl_from_xattr(&init_user_ns, value, size); 812d837a49bSMiklos Szeredi if (IS_ERR(acl)) 813d837a49bSMiklos Szeredi return PTR_ERR(acl); 814d837a49bSMiklos Szeredi } 815d837a49bSMiklos Szeredi err = -EOPNOTSUPP; 816d837a49bSMiklos Szeredi if (!IS_POSIXACL(d_inode(workdir))) 817d837a49bSMiklos Szeredi goto out_acl_release; 818d837a49bSMiklos Szeredi if (!realinode->i_op->set_acl) 819d837a49bSMiklos Szeredi goto out_acl_release; 820d837a49bSMiklos Szeredi if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 821d837a49bSMiklos Szeredi err = acl ? -EACCES : 0; 822d837a49bSMiklos Szeredi goto out_acl_release; 823d837a49bSMiklos Szeredi } 824d837a49bSMiklos Szeredi err = -EPERM; 825d837a49bSMiklos Szeredi if (!inode_owner_or_capable(inode)) 826d837a49bSMiklos Szeredi goto out_acl_release; 827d837a49bSMiklos Szeredi 828d837a49bSMiklos Szeredi posix_acl_release(acl); 829d837a49bSMiklos Szeredi 830fd3220d3SMiklos Szeredi /* 831fd3220d3SMiklos Szeredi * Check if sgid bit needs to be cleared (actual setacl operation will 832fd3220d3SMiklos Szeredi * be done with mounter's capabilities and so that won't do it for us). 833fd3220d3SMiklos Szeredi */ 834fd3220d3SMiklos Szeredi if (unlikely(inode->i_mode & S_ISGID) && 835fd3220d3SMiklos Szeredi handler->flags == ACL_TYPE_ACCESS && 836fd3220d3SMiklos Szeredi !in_group_p(inode->i_gid) && 837fd3220d3SMiklos Szeredi !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 838fd3220d3SMiklos Szeredi struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 839fd3220d3SMiklos Szeredi 840fd3220d3SMiklos Szeredi err = ovl_setattr(dentry, &iattr); 841fd3220d3SMiklos Szeredi if (err) 842fd3220d3SMiklos Szeredi return err; 843fd3220d3SMiklos Szeredi } 844fd3220d3SMiklos Szeredi 8451d88f183SMiklos Szeredi err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 846ce31513aSMiklos Szeredi if (!err) 84709d8b586SMiklos Szeredi ovl_copyattr(ovl_inode_real(inode), inode); 848ce31513aSMiklos Szeredi 849ce31513aSMiklos Szeredi return err; 850d837a49bSMiklos Szeredi 851d837a49bSMiklos Szeredi out_acl_release: 852d837a49bSMiklos Szeredi posix_acl_release(acl); 853d837a49bSMiklos Szeredi return err; 854d837a49bSMiklos Szeredi } 855d837a49bSMiklos Szeredi 8560eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 8570eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8580eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 8590eb45fc3SAndreas Gruenbacher { 86048fab5d7SAmir Goldstein return -EOPNOTSUPP; 8610eb45fc3SAndreas Gruenbacher } 8620eb45fc3SAndreas Gruenbacher 863d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 864d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 865d837a49bSMiklos Szeredi const char *name, const void *value, 866d837a49bSMiklos Szeredi size_t size, int flags) 867d837a49bSMiklos Szeredi { 86848fab5d7SAmir Goldstein return -EOPNOTSUPP; 869d837a49bSMiklos Szeredi } 870d837a49bSMiklos Szeredi 8710eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 8720eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8730eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 8740eb45fc3SAndreas Gruenbacher { 8751d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 8760eb45fc3SAndreas Gruenbacher } 8770eb45fc3SAndreas Gruenbacher 8780e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 8790e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8800e585cccSAndreas Gruenbacher const char *name, const void *value, 8810e585cccSAndreas Gruenbacher size_t size, int flags) 8820e585cccSAndreas Gruenbacher { 8831d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 8840e585cccSAndreas Gruenbacher } 8850e585cccSAndreas Gruenbacher 8860c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 8870c97be22SAndreas Gruenbacher ovl_posix_acl_access_xattr_handler = { 888d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_ACCESS, 889d837a49bSMiklos Szeredi .flags = ACL_TYPE_ACCESS, 8900eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 891d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 892d837a49bSMiklos Szeredi }; 893d837a49bSMiklos Szeredi 8940c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 8950c97be22SAndreas Gruenbacher ovl_posix_acl_default_xattr_handler = { 896d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_DEFAULT, 897d837a49bSMiklos Szeredi .flags = ACL_TYPE_DEFAULT, 8980eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 899d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 900d837a49bSMiklos Szeredi }; 901d837a49bSMiklos Szeredi 902d837a49bSMiklos Szeredi static const struct xattr_handler ovl_own_xattr_handler = { 903d837a49bSMiklos Szeredi .prefix = OVL_XATTR_PREFIX, 9040eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 905d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 906d837a49bSMiklos Szeredi }; 907d837a49bSMiklos Szeredi 908d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 909d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 9100eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 911d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 912d837a49bSMiklos Szeredi }; 913d837a49bSMiklos Szeredi 914d837a49bSMiklos Szeredi static const struct xattr_handler *ovl_xattr_handlers[] = { 9150c97be22SAndreas Gruenbacher #ifdef CONFIG_FS_POSIX_ACL 916d837a49bSMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 917d837a49bSMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 9180c97be22SAndreas Gruenbacher #endif 919d837a49bSMiklos Szeredi &ovl_own_xattr_handler, 920d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 921d837a49bSMiklos Szeredi NULL 922d837a49bSMiklos Szeredi }; 923d837a49bSMiklos Szeredi 924ad204488SMiklos Szeredi static int ovl_get_upper(struct ovl_fs *ofs, struct path *upperpath) 9256ee8acf0SMiklos Szeredi { 9265064975eSMiklos Szeredi struct vfsmount *upper_mnt; 9276ee8acf0SMiklos Szeredi int err; 9286ee8acf0SMiklos Szeredi 929ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.upperdir, upperpath); 9306ee8acf0SMiklos Szeredi if (err) 9316ee8acf0SMiklos Szeredi goto out; 9326ee8acf0SMiklos Szeredi 9336ee8acf0SMiklos Szeredi /* Upper fs should not be r/o */ 9346ee8acf0SMiklos Szeredi if (sb_rdonly(upperpath->mnt->mnt_sb)) { 9356ee8acf0SMiklos Szeredi pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n"); 9366ee8acf0SMiklos Szeredi err = -EINVAL; 9376ee8acf0SMiklos Szeredi goto out; 9386ee8acf0SMiklos Szeredi } 9396ee8acf0SMiklos Szeredi 940ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 9416ee8acf0SMiklos Szeredi if (err) 9426ee8acf0SMiklos Szeredi goto out; 9436ee8acf0SMiklos Szeredi 9446ee8acf0SMiklos Szeredi err = -EBUSY; 9456ee8acf0SMiklos Szeredi if (ovl_inuse_trylock(upperpath->dentry)) { 946ad204488SMiklos Szeredi ofs->upperdir_locked = true; 947ad204488SMiklos Szeredi } else if (ofs->config.index) { 9486ee8acf0SMiklos Szeredi pr_err("overlayfs: upperdir is in-use by another mount, mount with '-o index=off' to override exclusive upperdir protection.\n"); 9496ee8acf0SMiklos Szeredi goto out; 9506ee8acf0SMiklos Szeredi } else { 9516ee8acf0SMiklos Szeredi pr_warn("overlayfs: upperdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 9526ee8acf0SMiklos Szeredi } 9535064975eSMiklos Szeredi 9545064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 9555064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 9565064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 9575064975eSMiklos Szeredi pr_err("overlayfs: failed to clone upperpath\n"); 9585064975eSMiklos Szeredi goto out; 9595064975eSMiklos Szeredi } 9605064975eSMiklos Szeredi 9615064975eSMiklos Szeredi /* Don't inherit atime flags */ 9625064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 963ad204488SMiklos Szeredi ofs->upper_mnt = upper_mnt; 9646ee8acf0SMiklos Szeredi err = 0; 9656ee8acf0SMiklos Szeredi out: 9666ee8acf0SMiklos Szeredi return err; 9676ee8acf0SMiklos Szeredi } 9686ee8acf0SMiklos Szeredi 969ad204488SMiklos Szeredi static int ovl_make_workdir(struct ovl_fs *ofs, struct path *workpath) 9708ed61dc3SMiklos Szeredi { 9712ba9d57eSAmir Goldstein struct vfsmount *mnt = ofs->upper_mnt; 9728ed61dc3SMiklos Szeredi struct dentry *temp; 973e487d889SAmir Goldstein int fh_type; 9748ed61dc3SMiklos Szeredi int err; 9758ed61dc3SMiklos Szeredi 9762ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 9772ba9d57eSAmir Goldstein if (err) 9782ba9d57eSAmir Goldstein return err; 9792ba9d57eSAmir Goldstein 980ad204488SMiklos Szeredi ofs->workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 981ad204488SMiklos Szeredi if (!ofs->workdir) 9822ba9d57eSAmir Goldstein goto out; 9838ed61dc3SMiklos Szeredi 9848ed61dc3SMiklos Szeredi /* 9858ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 9868ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 9878ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 9888ed61dc3SMiklos Szeredi * previous step. 9898ed61dc3SMiklos Szeredi */ 9908ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 9918ed61dc3SMiklos Szeredi if (err < 0) 9922ba9d57eSAmir Goldstein goto out; 9938ed61dc3SMiklos Szeredi 9948ed61dc3SMiklos Szeredi /* 9958ed61dc3SMiklos Szeredi * We allowed this configuration and don't want to break users over 9968ed61dc3SMiklos Szeredi * kernel upgrade. So warn instead of erroring out. 9978ed61dc3SMiklos Szeredi */ 9988ed61dc3SMiklos Szeredi if (!err) 9998ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs needs to support d_type.\n"); 10008ed61dc3SMiklos Szeredi 10018ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 1002ad204488SMiklos Szeredi temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0); 1003ad204488SMiklos Szeredi ofs->tmpfile = !IS_ERR(temp); 1004ad204488SMiklos Szeredi if (ofs->tmpfile) 10058ed61dc3SMiklos Szeredi dput(temp); 10068ed61dc3SMiklos Szeredi else 10078ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support tmpfile.\n"); 10088ed61dc3SMiklos Szeredi 10098ed61dc3SMiklos Szeredi /* 10108ed61dc3SMiklos Szeredi * Check if upper/work fs supports trusted.overlay.* xattr 10118ed61dc3SMiklos Szeredi */ 1012ad204488SMiklos Szeredi err = ovl_do_setxattr(ofs->workdir, OVL_XATTR_OPAQUE, "0", 1, 0); 10138ed61dc3SMiklos Szeredi if (err) { 1014ad204488SMiklos Szeredi ofs->noxattr = true; 1015a683737bSAmir Goldstein ofs->config.index = false; 1016a683737bSAmir Goldstein pr_warn("overlayfs: upper fs does not support xattr, falling back to index=off.\n"); 10172ba9d57eSAmir Goldstein err = 0; 10188ed61dc3SMiklos Szeredi } else { 1019ad204488SMiklos Szeredi vfs_removexattr(ofs->workdir, OVL_XATTR_OPAQUE); 10208ed61dc3SMiklos Szeredi } 10218ed61dc3SMiklos Szeredi 10228ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 1023e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 1024e487d889SAmir Goldstein if (ofs->config.index && !fh_type) { 1025ad204488SMiklos Szeredi ofs->config.index = false; 10268ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support file handles, falling back to index=off.\n"); 10278ed61dc3SMiklos Szeredi } 10288ed61dc3SMiklos Szeredi 1029e487d889SAmir Goldstein /* Check if upper fs has 32bit inode numbers */ 1030e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 1031e487d889SAmir Goldstein ofs->xino_bits = 0; 1032e487d889SAmir Goldstein 1033f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */ 1034f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) { 1035f168f109SAmir Goldstein pr_warn("overlayfs: NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 1036f168f109SAmir Goldstein ofs->config.nfs_export = false; 1037f168f109SAmir Goldstein } 1038f168f109SAmir Goldstein 10392ba9d57eSAmir Goldstein out: 10402ba9d57eSAmir Goldstein mnt_drop_write(mnt); 10412ba9d57eSAmir Goldstein return err; 10428ed61dc3SMiklos Szeredi } 10438ed61dc3SMiklos Szeredi 1044ad204488SMiklos Szeredi static int ovl_get_workdir(struct ovl_fs *ofs, struct path *upperpath) 1045520d7c86SMiklos Szeredi { 1046520d7c86SMiklos Szeredi int err; 1047bca44b52SMiklos Szeredi struct path workpath = { }; 1048520d7c86SMiklos Szeredi 1049ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.workdir, &workpath); 1050520d7c86SMiklos Szeredi if (err) 1051520d7c86SMiklos Szeredi goto out; 1052520d7c86SMiklos Szeredi 1053520d7c86SMiklos Szeredi err = -EINVAL; 1054bca44b52SMiklos Szeredi if (upperpath->mnt != workpath.mnt) { 1055520d7c86SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 1056520d7c86SMiklos Szeredi goto out; 1057520d7c86SMiklos Szeredi } 1058bca44b52SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 1059520d7c86SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 1060520d7c86SMiklos Szeredi goto out; 1061520d7c86SMiklos Szeredi } 1062520d7c86SMiklos Szeredi 1063520d7c86SMiklos Szeredi err = -EBUSY; 1064bca44b52SMiklos Szeredi if (ovl_inuse_trylock(workpath.dentry)) { 1065ad204488SMiklos Szeredi ofs->workdir_locked = true; 1066ad204488SMiklos Szeredi } else if (ofs->config.index) { 1067520d7c86SMiklos Szeredi pr_err("overlayfs: workdir is in-use by another mount, mount with '-o index=off' to override exclusive workdir protection.\n"); 1068520d7c86SMiklos Szeredi goto out; 1069520d7c86SMiklos Szeredi } else { 1070520d7c86SMiklos Szeredi pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 1071520d7c86SMiklos Szeredi } 1072520d7c86SMiklos Szeredi 1073ad204488SMiklos Szeredi ofs->workbasedir = dget(workpath.dentry); 1074ad204488SMiklos Szeredi err = ovl_make_workdir(ofs, &workpath); 1075bca44b52SMiklos Szeredi if (err) 1076bca44b52SMiklos Szeredi goto out; 1077bca44b52SMiklos Szeredi 1078520d7c86SMiklos Szeredi err = 0; 1079520d7c86SMiklos Szeredi out: 1080bca44b52SMiklos Szeredi path_put(&workpath); 1081bca44b52SMiklos Szeredi 1082520d7c86SMiklos Szeredi return err; 1083520d7c86SMiklos Szeredi } 1084520d7c86SMiklos Szeredi 1085ad204488SMiklos Szeredi static int ovl_get_indexdir(struct ovl_fs *ofs, struct ovl_entry *oe, 108695e6d417SMiklos Szeredi struct path *upperpath) 1087f7e3a7d9SMiklos Szeredi { 10882ba9d57eSAmir Goldstein struct vfsmount *mnt = ofs->upper_mnt; 1089f7e3a7d9SMiklos Szeredi int err; 1090f7e3a7d9SMiklos Szeredi 10912ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 10922ba9d57eSAmir Goldstein if (err) 10932ba9d57eSAmir Goldstein return err; 10942ba9d57eSAmir Goldstein 1095f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 1096d9768076SAmir Goldstein err = ovl_verify_origin(upperpath->dentry, oe->lowerstack[0].dentry, 109705122443SAmir Goldstein true); 1098f7e3a7d9SMiklos Szeredi if (err) { 1099f7e3a7d9SMiklos Szeredi pr_err("overlayfs: failed to verify upper root origin\n"); 1100f7e3a7d9SMiklos Szeredi goto out; 1101f7e3a7d9SMiklos Szeredi } 1102f7e3a7d9SMiklos Szeredi 1103ad204488SMiklos Szeredi ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1104ad204488SMiklos Szeredi if (ofs->indexdir) { 1105ad1d615cSAmir Goldstein /* 1106ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir. 1107ad1d615cSAmir Goldstein * Older kernels stored upper fh in "trusted.overlay.origin" 1108ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to 1109ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr 1110ad1d615cSAmir Goldstein * "trusted.overlay.upper" to indicate that index may have 1111ad1d615cSAmir Goldstein * directory entries. 1112ad1d615cSAmir Goldstein */ 1113ad1d615cSAmir Goldstein if (ovl_check_origin_xattr(ofs->indexdir)) { 111405122443SAmir Goldstein err = ovl_verify_set_fh(ofs->indexdir, OVL_XATTR_ORIGIN, 1115ad1d615cSAmir Goldstein upperpath->dentry, true, false); 1116f7e3a7d9SMiklos Szeredi if (err) 1117ad1d615cSAmir Goldstein pr_err("overlayfs: failed to verify index dir 'origin' xattr\n"); 1118ad1d615cSAmir Goldstein } 1119ad1d615cSAmir Goldstein err = ovl_verify_upper(ofs->indexdir, upperpath->dentry, true); 1120ad1d615cSAmir Goldstein if (err) 1121ad1d615cSAmir Goldstein pr_err("overlayfs: failed to verify index dir 'upper' xattr\n"); 1122f7e3a7d9SMiklos Szeredi 1123f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 1124f7e3a7d9SMiklos Szeredi if (!err) 11251eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs); 1126f7e3a7d9SMiklos Szeredi } 1127ad204488SMiklos Szeredi if (err || !ofs->indexdir) 1128f7e3a7d9SMiklos Szeredi pr_warn("overlayfs: try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1129f7e3a7d9SMiklos Szeredi 1130f7e3a7d9SMiklos Szeredi out: 11312ba9d57eSAmir Goldstein mnt_drop_write(mnt); 1132f7e3a7d9SMiklos Szeredi return err; 1133f7e3a7d9SMiklos Szeredi } 1134f7e3a7d9SMiklos Szeredi 11355148626bSAmir Goldstein /* Get a unique fsid for the layer */ 11365148626bSAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, struct super_block *sb) 11375148626bSAmir Goldstein { 11385148626bSAmir Goldstein unsigned int i; 11395148626bSAmir Goldstein dev_t dev; 11405148626bSAmir Goldstein int err; 11415148626bSAmir Goldstein 11425148626bSAmir Goldstein /* fsid 0 is reserved for upper fs even with non upper overlay */ 11435148626bSAmir Goldstein if (ofs->upper_mnt && ofs->upper_mnt->mnt_sb == sb) 11445148626bSAmir Goldstein return 0; 11455148626bSAmir Goldstein 11465148626bSAmir Goldstein for (i = 0; i < ofs->numlowerfs; i++) { 11475148626bSAmir Goldstein if (ofs->lower_fs[i].sb == sb) 11485148626bSAmir Goldstein return i + 1; 11495148626bSAmir Goldstein } 11505148626bSAmir Goldstein 11515148626bSAmir Goldstein err = get_anon_bdev(&dev); 11525148626bSAmir Goldstein if (err) { 11535148626bSAmir Goldstein pr_err("overlayfs: failed to get anonymous bdev for lowerpath\n"); 11545148626bSAmir Goldstein return err; 11555148626bSAmir Goldstein } 11565148626bSAmir Goldstein 11575148626bSAmir Goldstein ofs->lower_fs[ofs->numlowerfs].sb = sb; 11585148626bSAmir Goldstein ofs->lower_fs[ofs->numlowerfs].pseudo_dev = dev; 11595148626bSAmir Goldstein ofs->numlowerfs++; 11605148626bSAmir Goldstein 11615148626bSAmir Goldstein return ofs->numlowerfs; 11625148626bSAmir Goldstein } 11635148626bSAmir Goldstein 1164ad204488SMiklos Szeredi static int ovl_get_lower_layers(struct ovl_fs *ofs, struct path *stack, 1165520d7c86SMiklos Szeredi unsigned int numlower) 1166520d7c86SMiklos Szeredi { 1167520d7c86SMiklos Szeredi int err; 1168520d7c86SMiklos Szeredi unsigned int i; 1169520d7c86SMiklos Szeredi 1170520d7c86SMiklos Szeredi err = -ENOMEM; 1171ad204488SMiklos Szeredi ofs->lower_layers = kcalloc(numlower, sizeof(struct ovl_layer), 1172520d7c86SMiklos Szeredi GFP_KERNEL); 1173ad204488SMiklos Szeredi if (ofs->lower_layers == NULL) 1174520d7c86SMiklos Szeredi goto out; 11755148626bSAmir Goldstein 11765148626bSAmir Goldstein ofs->lower_fs = kcalloc(numlower, sizeof(struct ovl_sb), 11775148626bSAmir Goldstein GFP_KERNEL); 11785148626bSAmir Goldstein if (ofs->lower_fs == NULL) 11795148626bSAmir Goldstein goto out; 11805148626bSAmir Goldstein 1181520d7c86SMiklos Szeredi for (i = 0; i < numlower; i++) { 1182520d7c86SMiklos Szeredi struct vfsmount *mnt; 11835148626bSAmir Goldstein int fsid; 1184520d7c86SMiklos Szeredi 11855148626bSAmir Goldstein err = fsid = ovl_get_fsid(ofs, stack[i].mnt->mnt_sb); 11865148626bSAmir Goldstein if (err < 0) 1187520d7c86SMiklos Szeredi goto out; 1188520d7c86SMiklos Szeredi 1189520d7c86SMiklos Szeredi mnt = clone_private_mount(&stack[i]); 1190520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1191520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 1192520d7c86SMiklos Szeredi pr_err("overlayfs: failed to clone lowerpath\n"); 1193520d7c86SMiklos Szeredi goto out; 1194520d7c86SMiklos Szeredi } 11955148626bSAmir Goldstein 1196520d7c86SMiklos Szeredi /* 1197520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1198520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1199520d7c86SMiklos Szeredi */ 1200520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1201520d7c86SMiklos Szeredi 1202ad204488SMiklos Szeredi ofs->lower_layers[ofs->numlower].mnt = mnt; 1203d583ed7dSAmir Goldstein ofs->lower_layers[ofs->numlower].idx = i + 1; 12045148626bSAmir Goldstein ofs->lower_layers[ofs->numlower].fsid = fsid; 12055148626bSAmir Goldstein if (fsid) { 12065148626bSAmir Goldstein ofs->lower_layers[ofs->numlower].fs = 12075148626bSAmir Goldstein &ofs->lower_fs[fsid - 1]; 12085148626bSAmir Goldstein } 1209ad204488SMiklos Szeredi ofs->numlower++; 1210520d7c86SMiklos Szeredi } 1211e487d889SAmir Goldstein 1212795939a9SAmir Goldstein /* 1213795939a9SAmir Goldstein * When all layers on same fs, overlay can use real inode numbers. 1214795939a9SAmir Goldstein * With mount option "xino=on", mounter declares that there are enough 1215795939a9SAmir Goldstein * free high bits in underlying fs to hold the unique fsid. 1216795939a9SAmir Goldstein * If overlayfs does encounter underlying inodes using the high xino 1217795939a9SAmir Goldstein * bits reserved for fsid, it emits a warning and uses the original 1218795939a9SAmir Goldstein * inode number. 1219795939a9SAmir Goldstein */ 1220795939a9SAmir Goldstein if (!ofs->numlowerfs || (ofs->numlowerfs == 1 && !ofs->upper_mnt)) { 1221e487d889SAmir Goldstein ofs->xino_bits = 0; 1222795939a9SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 1223795939a9SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_ON && !ofs->xino_bits) { 1224795939a9SAmir Goldstein /* 1225795939a9SAmir Goldstein * This is a roundup of number of bits needed for numlowerfs+1 1226795939a9SAmir Goldstein * (i.e. ilog2(numlowerfs+1 - 1) + 1). fsid 0 is reserved for 1227795939a9SAmir Goldstein * upper fs even with non upper overlay. 1228795939a9SAmir Goldstein */ 1229795939a9SAmir Goldstein BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 31); 1230795939a9SAmir Goldstein ofs->xino_bits = ilog2(ofs->numlowerfs) + 1; 1231795939a9SAmir Goldstein } 1232795939a9SAmir Goldstein 1233795939a9SAmir Goldstein if (ofs->xino_bits) { 1234795939a9SAmir Goldstein pr_info("overlayfs: \"xino\" feature enabled using %d upper inode bits.\n", 1235795939a9SAmir Goldstein ofs->xino_bits); 1236795939a9SAmir Goldstein } 1237e487d889SAmir Goldstein 1238520d7c86SMiklos Szeredi err = 0; 1239520d7c86SMiklos Szeredi out: 1240520d7c86SMiklos Szeredi return err; 1241520d7c86SMiklos Szeredi } 1242520d7c86SMiklos Szeredi 12434155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1244ad204488SMiklos Szeredi struct ovl_fs *ofs) 124553dbb0b4SMiklos Szeredi { 124653dbb0b4SMiklos Szeredi int err; 124753dbb0b4SMiklos Szeredi char *lowertmp, *lower; 12484155c10aSMiklos Szeredi struct path *stack = NULL; 12494155c10aSMiklos Szeredi unsigned int stacklen, numlower = 0, i; 125053dbb0b4SMiklos Szeredi bool remote = false; 12514155c10aSMiklos Szeredi struct ovl_entry *oe; 125253dbb0b4SMiklos Szeredi 125353dbb0b4SMiklos Szeredi err = -ENOMEM; 1254ad204488SMiklos Szeredi lowertmp = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 125553dbb0b4SMiklos Szeredi if (!lowertmp) 12564155c10aSMiklos Szeredi goto out_err; 125753dbb0b4SMiklos Szeredi 125853dbb0b4SMiklos Szeredi err = -EINVAL; 125953dbb0b4SMiklos Szeredi stacklen = ovl_split_lowerdirs(lowertmp); 126053dbb0b4SMiklos Szeredi if (stacklen > OVL_MAX_STACK) { 126153dbb0b4SMiklos Szeredi pr_err("overlayfs: too many lower directories, limit is %d\n", 126253dbb0b4SMiklos Szeredi OVL_MAX_STACK); 12634155c10aSMiklos Szeredi goto out_err; 1264ad204488SMiklos Szeredi } else if (!ofs->config.upperdir && stacklen == 1) { 126553dbb0b4SMiklos Szeredi pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n"); 12664155c10aSMiklos Szeredi goto out_err; 1267f168f109SAmir Goldstein } else if (!ofs->config.upperdir && ofs->config.nfs_export && 1268f168f109SAmir Goldstein ofs->config.redirect_follow) { 1269f168f109SAmir Goldstein pr_warn("overlayfs: NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n"); 1270f168f109SAmir Goldstein ofs->config.nfs_export = false; 127153dbb0b4SMiklos Szeredi } 127253dbb0b4SMiklos Szeredi 127353dbb0b4SMiklos Szeredi err = -ENOMEM; 127453dbb0b4SMiklos Szeredi stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL); 127553dbb0b4SMiklos Szeredi if (!stack) 12764155c10aSMiklos Szeredi goto out_err; 127753dbb0b4SMiklos Szeredi 127853dbb0b4SMiklos Szeredi err = -EINVAL; 127953dbb0b4SMiklos Szeredi lower = lowertmp; 128053dbb0b4SMiklos Szeredi for (numlower = 0; numlower < stacklen; numlower++) { 1281ad204488SMiklos Szeredi err = ovl_lower_dir(lower, &stack[numlower], ofs, 128253dbb0b4SMiklos Szeredi &sb->s_stack_depth, &remote); 128353dbb0b4SMiklos Szeredi if (err) 12844155c10aSMiklos Szeredi goto out_err; 128553dbb0b4SMiklos Szeredi 128653dbb0b4SMiklos Szeredi lower = strchr(lower, '\0') + 1; 128753dbb0b4SMiklos Szeredi } 128853dbb0b4SMiklos Szeredi 128953dbb0b4SMiklos Szeredi err = -EINVAL; 129053dbb0b4SMiklos Szeredi sb->s_stack_depth++; 129153dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 129253dbb0b4SMiklos Szeredi pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 12934155c10aSMiklos Szeredi goto out_err; 129453dbb0b4SMiklos Szeredi } 129553dbb0b4SMiklos Szeredi 1296ad204488SMiklos Szeredi err = ovl_get_lower_layers(ofs, stack, numlower); 12974155c10aSMiklos Szeredi if (err) 12984155c10aSMiklos Szeredi goto out_err; 12994155c10aSMiklos Szeredi 13004155c10aSMiklos Szeredi err = -ENOMEM; 13014155c10aSMiklos Szeredi oe = ovl_alloc_entry(numlower); 13024155c10aSMiklos Szeredi if (!oe) 13034155c10aSMiklos Szeredi goto out_err; 13044155c10aSMiklos Szeredi 13054155c10aSMiklos Szeredi for (i = 0; i < numlower; i++) { 13064155c10aSMiklos Szeredi oe->lowerstack[i].dentry = dget(stack[i].dentry); 1307ad204488SMiklos Szeredi oe->lowerstack[i].layer = &ofs->lower_layers[i]; 13084155c10aSMiklos Szeredi } 130953dbb0b4SMiklos Szeredi 131053dbb0b4SMiklos Szeredi if (remote) 131153dbb0b4SMiklos Szeredi sb->s_d_op = &ovl_reval_dentry_operations; 131253dbb0b4SMiklos Szeredi else 131353dbb0b4SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 131453dbb0b4SMiklos Szeredi 131553dbb0b4SMiklos Szeredi out: 131653dbb0b4SMiklos Szeredi for (i = 0; i < numlower; i++) 131753dbb0b4SMiklos Szeredi path_put(&stack[i]); 131853dbb0b4SMiklos Szeredi kfree(stack); 13194155c10aSMiklos Szeredi kfree(lowertmp); 13204155c10aSMiklos Szeredi 13214155c10aSMiklos Szeredi return oe; 13224155c10aSMiklos Szeredi 13234155c10aSMiklos Szeredi out_err: 13244155c10aSMiklos Szeredi oe = ERR_PTR(err); 132553dbb0b4SMiklos Szeredi goto out; 132653dbb0b4SMiklos Szeredi } 132753dbb0b4SMiklos Szeredi 1328e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1329e9be9d5eSMiklos Szeredi { 133033006cdfSKees Cook struct path upperpath = { }; 1331e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 13324155c10aSMiklos Szeredi struct ovl_entry *oe; 1333ad204488SMiklos Szeredi struct ovl_fs *ofs; 133451f8f3c4SKonstantin Khlebnikov struct cred *cred; 1335e9be9d5eSMiklos Szeredi int err; 1336e9be9d5eSMiklos Szeredi 1337f45827e8SErez Zadok err = -ENOMEM; 1338ad204488SMiklos Szeredi ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1339ad204488SMiklos Szeredi if (!ofs) 1340e9be9d5eSMiklos Szeredi goto out; 1341e9be9d5eSMiklos Szeredi 1342ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1343c6fe6254SMiklos Szeredi if (!cred) 1344c6fe6254SMiklos Szeredi goto out_err; 1345c6fe6254SMiklos Szeredi 1346ad204488SMiklos Szeredi ofs->config.index = ovl_index_def; 1347f168f109SAmir Goldstein ofs->config.nfs_export = ovl_nfs_export_def; 1348795939a9SAmir Goldstein ofs->config.xino = ovl_xino_def(); 1349ad204488SMiklos Szeredi err = ovl_parse_opt((char *) data, &ofs->config); 1350f45827e8SErez Zadok if (err) 1351a9075cdbSMiklos Szeredi goto out_err; 1352f45827e8SErez Zadok 1353e9be9d5eSMiklos Szeredi err = -EINVAL; 1354ad204488SMiklos Szeredi if (!ofs->config.lowerdir) { 135507f2af7bSKonstantin Khlebnikov if (!silent) 135653a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'lowerdir'\n"); 1357a9075cdbSMiklos Szeredi goto out_err; 135853a08cb9SMiklos Szeredi } 135953a08cb9SMiklos Szeredi 136053a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 1361cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 1362e487d889SAmir Goldstein /* Assume underlaying fs uses 32bit inodes unless proven otherwise */ 1363795939a9SAmir Goldstein if (ofs->config.xino != OVL_XINO_OFF) 1364e487d889SAmir Goldstein ofs->xino_bits = BITS_PER_LONG - 32; 1365795939a9SAmir Goldstein 1366ad204488SMiklos Szeredi if (ofs->config.upperdir) { 1367ad204488SMiklos Szeredi if (!ofs->config.workdir) { 136853a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'workdir'\n"); 1369a9075cdbSMiklos Szeredi goto out_err; 1370e9be9d5eSMiklos Szeredi } 1371e9be9d5eSMiklos Szeredi 1372ad204488SMiklos Szeredi err = ovl_get_upper(ofs, &upperpath); 137321a3b317SMiklos Szeredi if (err) 1374a9075cdbSMiklos Szeredi goto out_err; 1375d719e8f2SMiklos Szeredi 1376ad204488SMiklos Szeredi err = ovl_get_workdir(ofs, &upperpath); 13778ed61dc3SMiklos Szeredi if (err) 1378a9075cdbSMiklos Szeredi goto out_err; 1379c6fe6254SMiklos Szeredi 1380ad204488SMiklos Szeredi if (!ofs->workdir) 13811751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 13826e88256eSMiklos Szeredi 1383ad204488SMiklos Szeredi sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth; 1384ad204488SMiklos Szeredi sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran; 1385c6fe6254SMiklos Szeredi 138621765194SVivek Goyal } 1387ad204488SMiklos Szeredi oe = ovl_get_lowerstack(sb, ofs); 13884155c10aSMiklos Szeredi err = PTR_ERR(oe); 13894155c10aSMiklos Szeredi if (IS_ERR(oe)) 1390a9075cdbSMiklos Szeredi goto out_err; 1391e9be9d5eSMiklos Szeredi 139271cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 1393ad204488SMiklos Szeredi if (!ofs->upper_mnt) 13941751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 1395e9be9d5eSMiklos Szeredi 1396ad204488SMiklos Szeredi if (!(ovl_force_readonly(ofs)) && ofs->config.index) { 1397ad204488SMiklos Szeredi err = ovl_get_indexdir(ofs, oe, &upperpath); 139854fb347eSAmir Goldstein if (err) 13994155c10aSMiklos Szeredi goto out_free_oe; 14006e88256eSMiklos Szeredi 1401972d0093SAmir Goldstein /* Force r/o mount with no index dir */ 1402972d0093SAmir Goldstein if (!ofs->indexdir) { 1403972d0093SAmir Goldstein dput(ofs->workdir); 1404972d0093SAmir Goldstein ofs->workdir = NULL; 14051751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 140602bcd157SAmir Goldstein } 140702bcd157SAmir Goldstein 1408972d0093SAmir Goldstein } 1409972d0093SAmir Goldstein 1410972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */ 1411f168f109SAmir Goldstein if (!ofs->indexdir) { 1412ad204488SMiklos Szeredi ofs->config.index = false; 1413f168f109SAmir Goldstein if (ofs->upper_mnt && ofs->config.nfs_export) { 1414f168f109SAmir Goldstein pr_warn("overlayfs: NFS export requires an index dir, falling back to nfs_export=off.\n"); 1415f168f109SAmir Goldstein ofs->config.nfs_export = false; 1416f168f109SAmir Goldstein } 1417f168f109SAmir Goldstein } 141802bcd157SAmir Goldstein 14198383f174SAmir Goldstein if (ofs->config.nfs_export) 14208383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations; 14218383f174SAmir Goldstein 142251f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 142351f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 142451f8f3c4SKonstantin Khlebnikov 1425655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1426655042ccSVivek Goyal sb->s_op = &ovl_super_operations; 1427655042ccSVivek Goyal sb->s_xattr = ovl_xattr_handlers; 1428ad204488SMiklos Szeredi sb->s_fs_info = ofs; 1429de2a4a50SMiklos Szeredi sb->s_flags |= SB_POSIXACL; 1430655042ccSVivek Goyal 1431c6fe6254SMiklos Szeredi err = -ENOMEM; 1432ca4c8a3aSMiklos Szeredi root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 1433e9be9d5eSMiklos Szeredi if (!root_dentry) 14344155c10aSMiklos Szeredi goto out_free_oe; 1435e9be9d5eSMiklos Szeredi 1436c62520a8SAmir Goldstein root_dentry->d_fsdata = oe; 1437c62520a8SAmir Goldstein 1438e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 1439f3a15685SAmir Goldstein if (upperpath.dentry) { 1440c62520a8SAmir Goldstein ovl_dentry_set_upper_alias(root_dentry); 144113c72075SMiklos Szeredi if (ovl_is_impuredir(upperpath.dentry)) 144213c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, d_inode(root_dentry)); 1443f3a15685SAmir Goldstein } 1444e9be9d5eSMiklos Szeredi 1445b79e05aaSAmir Goldstein /* Root is always merge -> can have whiteouts */ 1446b79e05aaSAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root_dentry)); 14472ca3c148SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root_dentry); 144809d8b586SMiklos Szeredi ovl_inode_init(d_inode(root_dentry), upperpath.dentry, 144909d8b586SMiklos Szeredi ovl_dentry_lower(root_dentry)); 1450ed06e069SMiklos Szeredi 1451e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1452e9be9d5eSMiklos Szeredi 1453e9be9d5eSMiklos Szeredi return 0; 1454e9be9d5eSMiklos Szeredi 14554155c10aSMiklos Szeredi out_free_oe: 14564155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 1457b9343632SChandan Rajendra kfree(oe); 14584155c10aSMiklos Szeredi out_err: 1459e9be9d5eSMiklos Szeredi path_put(&upperpath); 1460ad204488SMiklos Szeredi ovl_free_fs(ofs); 1461e9be9d5eSMiklos Szeredi out: 1462e9be9d5eSMiklos Szeredi return err; 1463e9be9d5eSMiklos Szeredi } 1464e9be9d5eSMiklos Szeredi 1465e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 1466e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 1467e9be9d5eSMiklos Szeredi { 1468e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 1469e9be9d5eSMiklos Szeredi } 1470e9be9d5eSMiklos Szeredi 1471e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 1472e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1473ef94b186SMiklos Szeredi .name = "overlay", 1474e9be9d5eSMiklos Szeredi .mount = ovl_mount, 1475e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 1476e9be9d5eSMiklos Szeredi }; 1477ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 1478e9be9d5eSMiklos Szeredi 147913cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 148013cf199dSAmir Goldstein { 148113cf199dSAmir Goldstein struct ovl_inode *oi = foo; 148213cf199dSAmir Goldstein 148313cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 148413cf199dSAmir Goldstein } 148513cf199dSAmir Goldstein 1486e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 1487e9be9d5eSMiklos Szeredi { 148813cf199dSAmir Goldstein int err; 148913cf199dSAmir Goldstein 149013cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 149113cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 149213cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 149313cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 149413cf199dSAmir Goldstein ovl_inode_init_once); 149513cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 149613cf199dSAmir Goldstein return -ENOMEM; 149713cf199dSAmir Goldstein 149813cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 149913cf199dSAmir Goldstein if (err) 150013cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 150113cf199dSAmir Goldstein 150213cf199dSAmir Goldstein return err; 1503e9be9d5eSMiklos Szeredi } 1504e9be9d5eSMiklos Szeredi 1505e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1506e9be9d5eSMiklos Szeredi { 1507e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 150813cf199dSAmir Goldstein 150913cf199dSAmir Goldstein /* 151013cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 151113cf199dSAmir Goldstein * destroy cache. 151213cf199dSAmir Goldstein */ 151313cf199dSAmir Goldstein rcu_barrier(); 151413cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 151513cf199dSAmir Goldstein 1516e9be9d5eSMiklos Szeredi } 1517e9be9d5eSMiklos Szeredi 1518e9be9d5eSMiklos Szeredi module_init(ovl_init); 1519e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1520