1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2e9be9d5eSMiklos Szeredi /* 3e9be9d5eSMiklos Szeredi * 4e9be9d5eSMiklos Szeredi * Copyright (C) 2011 Novell Inc. 5e9be9d5eSMiklos Szeredi */ 6e9be9d5eSMiklos Szeredi 75b825c3aSIngo Molnar #include <uapi/linux/magic.h> 8e9be9d5eSMiklos Szeredi #include <linux/fs.h> 9e9be9d5eSMiklos Szeredi #include <linux/namei.h> 10e9be9d5eSMiklos Szeredi #include <linux/xattr.h> 11e9be9d5eSMiklos Szeredi #include <linux/mount.h> 12e9be9d5eSMiklos Szeredi #include <linux/parser.h> 13e9be9d5eSMiklos Szeredi #include <linux/module.h> 14cc259639SAndy Whitcroft #include <linux/statfs.h> 15f45827e8SErez Zadok #include <linux/seq_file.h> 16d837a49bSMiklos Szeredi #include <linux/posix_acl_xattr.h> 17e487d889SAmir Goldstein #include <linux/exportfs.h> 182b1a7746SMiklos Szeredi #include <linux/file.h> 19dcb399deSAmir Goldstein #include <linux/fs_parser.h> 20e9be9d5eSMiklos Szeredi #include "overlayfs.h" 21e9be9d5eSMiklos Szeredi 22e9be9d5eSMiklos Szeredi MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 23e9be9d5eSMiklos Szeredi MODULE_DESCRIPTION("Overlay filesystem"); 24e9be9d5eSMiklos Szeredi MODULE_LICENSE("GPL"); 25e9be9d5eSMiklos Szeredi 26e9be9d5eSMiklos Szeredi 27e9be9d5eSMiklos Szeredi struct ovl_dir_cache; 28e9be9d5eSMiklos Szeredi 29a78d9f0dSMiklos Szeredi #define OVL_MAX_STACK 500 30a78d9f0dSMiklos Szeredi 31688ea0e5SMiklos Szeredi static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR); 32688ea0e5SMiklos Szeredi module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644); 33253e7483SNicolas Schier MODULE_PARM_DESC(redirect_dir, 34688ea0e5SMiklos Szeredi "Default to on or off for the redirect_dir feature"); 35e9be9d5eSMiklos Szeredi 36438c84c2SMiklos Szeredi static bool ovl_redirect_always_follow = 37438c84c2SMiklos Szeredi IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW); 38438c84c2SMiklos Szeredi module_param_named(redirect_always_follow, ovl_redirect_always_follow, 39438c84c2SMiklos Szeredi bool, 0644); 40253e7483SNicolas Schier MODULE_PARM_DESC(redirect_always_follow, 41438c84c2SMiklos Szeredi "Follow redirects even if redirect_dir feature is turned off"); 42438c84c2SMiklos Szeredi 4302bcd157SAmir Goldstein static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX); 4402bcd157SAmir Goldstein module_param_named(index, ovl_index_def, bool, 0644); 45253e7483SNicolas Schier MODULE_PARM_DESC(index, 4602bcd157SAmir Goldstein "Default to on or off for the inodes index feature"); 4702bcd157SAmir Goldstein 48f168f109SAmir Goldstein static bool ovl_nfs_export_def = IS_ENABLED(CONFIG_OVERLAY_FS_NFS_EXPORT); 49f168f109SAmir Goldstein module_param_named(nfs_export, ovl_nfs_export_def, bool, 0644); 50253e7483SNicolas Schier MODULE_PARM_DESC(nfs_export, 51f168f109SAmir Goldstein "Default to on or off for the NFS export feature"); 52f168f109SAmir Goldstein 53795939a9SAmir Goldstein static bool ovl_xino_auto_def = IS_ENABLED(CONFIG_OVERLAY_FS_XINO_AUTO); 54795939a9SAmir Goldstein module_param_named(xino_auto, ovl_xino_auto_def, bool, 0644); 55253e7483SNicolas Schier MODULE_PARM_DESC(xino_auto, 56795939a9SAmir Goldstein "Auto enable xino feature"); 57795939a9SAmir Goldstein 58d5791044SVivek Goyal static bool ovl_metacopy_def = IS_ENABLED(CONFIG_OVERLAY_FS_METACOPY); 59d5791044SVivek Goyal module_param_named(metacopy, ovl_metacopy_def, bool, 0644); 60253e7483SNicolas Schier MODULE_PARM_DESC(metacopy, 61d5791044SVivek Goyal "Default to on or off for the metadata only copy up feature"); 62d5791044SVivek Goyal 632d902671SMiklos Szeredi static struct dentry *ovl_d_real(struct dentry *dentry, 64fb16043bSMiklos Szeredi const struct inode *inode) 65d101a125SMiklos Szeredi { 66cef4cbffSMiklos Szeredi struct dentry *real = NULL, *lower; 67d101a125SMiklos Szeredi 68e8c985baSMiklos Szeredi /* It's an overlay file */ 69e8c985baSMiklos Szeredi if (inode && d_inode(dentry) == inode) 70e8c985baSMiklos Szeredi return dentry; 71e8c985baSMiklos Szeredi 72ca4c8a3aSMiklos Szeredi if (!d_is_reg(dentry)) { 73d101a125SMiklos Szeredi if (!inode || inode == d_inode(dentry)) 74d101a125SMiklos Szeredi return dentry; 75d101a125SMiklos Szeredi goto bug; 76d101a125SMiklos Szeredi } 77d101a125SMiklos Szeredi 78d101a125SMiklos Szeredi real = ovl_dentry_upper(dentry); 792c3d7358SVivek Goyal if (real && (inode == d_inode(real))) 80d101a125SMiklos Szeredi return real; 81d101a125SMiklos Szeredi 822c3d7358SVivek Goyal if (real && !inode && ovl_has_upperdata(d_inode(dentry))) 832c3d7358SVivek Goyal return real; 842c3d7358SVivek Goyal 8541665644SAmir Goldstein /* 8642dd69aeSAmir Goldstein * Best effort lazy lookup of lowerdata for !inode case to return 8741665644SAmir Goldstein * the real lowerdata dentry. The only current caller of d_real() with 8841665644SAmir Goldstein * NULL inode is d_real_inode() from trace_uprobe and this caller is 8941665644SAmir Goldstein * likely going to be followed reading from the file, before placing 9041665644SAmir Goldstein * uprobes on offset within the file, so lowerdata should be available 9141665644SAmir Goldstein * when setting the uprobe. 9241665644SAmir Goldstein */ 9342dd69aeSAmir Goldstein ovl_maybe_lookup_lowerdata(dentry); 94cef4cbffSMiklos Szeredi lower = ovl_dentry_lowerdata(dentry); 95cef4cbffSMiklos Szeredi if (!lower) 96d101a125SMiklos Szeredi goto bug; 97cef4cbffSMiklos Szeredi real = lower; 98d101a125SMiklos Szeredi 99c4fcfc16SMiklos Szeredi /* Handle recursion */ 100fb16043bSMiklos Szeredi real = d_real(real, inode); 101c4fcfc16SMiklos Szeredi 102d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 103d101a125SMiklos Szeredi return real; 104d101a125SMiklos Szeredi bug: 105cef4cbffSMiklos Szeredi WARN(1, "%s(%pd4, %s:%lu): real dentry (%p/%lu) not found\n", 106cef4cbffSMiklos Szeredi __func__, dentry, inode ? inode->i_sb->s_id : "NULL", 107cef4cbffSMiklos Szeredi inode ? inode->i_ino : 0, real, 108cef4cbffSMiklos Szeredi real && d_inode(real) ? d_inode(real)->i_ino : 0); 109d101a125SMiklos Szeredi return dentry; 110d101a125SMiklos Szeredi } 111d101a125SMiklos Szeredi 1123bb7df92SMiklos Szeredi static int ovl_revalidate_real(struct dentry *d, unsigned int flags, bool weak) 1133bb7df92SMiklos Szeredi { 1143bb7df92SMiklos Szeredi int ret = 1; 1153bb7df92SMiklos Szeredi 11641665644SAmir Goldstein if (!d) 11741665644SAmir Goldstein return 1; 11841665644SAmir Goldstein 1193bb7df92SMiklos Szeredi if (weak) { 1203bb7df92SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) 1213bb7df92SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1223bb7df92SMiklos Szeredi } else if (d->d_flags & DCACHE_OP_REVALIDATE) { 1233bb7df92SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1243bb7df92SMiklos Szeredi if (!ret) { 1253bb7df92SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1263bb7df92SMiklos Szeredi d_invalidate(d); 1273bb7df92SMiklos Szeredi ret = -ESTALE; 1283bb7df92SMiklos Szeredi } 1293bb7df92SMiklos Szeredi } 1303bb7df92SMiklos Szeredi return ret; 1313bb7df92SMiklos Szeredi } 1323bb7df92SMiklos Szeredi 1333bb7df92SMiklos Szeredi static int ovl_dentry_revalidate_common(struct dentry *dentry, 1343bb7df92SMiklos Szeredi unsigned int flags, bool weak) 1357c03b5d4SMiklos Szeredi { 136a6ff2bc0SAmir Goldstein struct ovl_entry *oe = OVL_E(dentry); 1375522c9c7SAmir Goldstein struct ovl_path *lowerstack = ovl_lowerstack(oe); 138672e4268SChen Zhongjin struct inode *inode = d_inode_rcu(dentry); 139bccece1eSMiklos Szeredi struct dentry *upper; 1407c03b5d4SMiklos Szeredi unsigned int i; 1417c03b5d4SMiklos Szeredi int ret = 1; 1427c03b5d4SMiklos Szeredi 143672e4268SChen Zhongjin /* Careful in RCU mode */ 144672e4268SChen Zhongjin if (!inode) 145672e4268SChen Zhongjin return -ECHILD; 146672e4268SChen Zhongjin 147672e4268SChen Zhongjin upper = ovl_i_dentry_upper(inode); 148bccece1eSMiklos Szeredi if (upper) 149bccece1eSMiklos Szeredi ret = ovl_revalidate_real(upper, flags, weak); 150bccece1eSMiklos Szeredi 1515522c9c7SAmir Goldstein for (i = 0; ret > 0 && i < ovl_numlower(oe); i++) 1525522c9c7SAmir Goldstein ret = ovl_revalidate_real(lowerstack[i].dentry, flags, weak); 1535522c9c7SAmir Goldstein 1547c03b5d4SMiklos Szeredi return ret; 1557c03b5d4SMiklos Szeredi } 1563bb7df92SMiklos Szeredi 1573bb7df92SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 1583bb7df92SMiklos Szeredi { 1593bb7df92SMiklos Szeredi return ovl_dentry_revalidate_common(dentry, flags, false); 1607c03b5d4SMiklos Szeredi } 1617c03b5d4SMiklos Szeredi 1627c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 1637c03b5d4SMiklos Szeredi { 1643bb7df92SMiklos Szeredi return ovl_dentry_revalidate_common(dentry, flags, true); 1657c03b5d4SMiklos Szeredi } 1667c03b5d4SMiklos Szeredi 167e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 168d101a125SMiklos Szeredi .d_real = ovl_d_real, 1697c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1707c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1717c03b5d4SMiklos Szeredi }; 1727c03b5d4SMiklos Szeredi 17313cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 17413cf199dSAmir Goldstein 17513cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 17613cf199dSAmir Goldstein { 177fd60b288SMuchun Song struct ovl_inode *oi = alloc_inode_sb(sb, ovl_inode_cachep, GFP_KERNEL); 17813cf199dSAmir Goldstein 179b3885bd6SHirofumi Nakagawa if (!oi) 180b3885bd6SHirofumi Nakagawa return NULL; 181b3885bd6SHirofumi Nakagawa 18204a01ac7SMiklos Szeredi oi->cache = NULL; 183cf31c463SMiklos Szeredi oi->redirect = NULL; 18404a01ac7SMiklos Szeredi oi->version = 0; 18513c72075SMiklos Szeredi oi->flags = 0; 18609d8b586SMiklos Szeredi oi->__upperdentry = NULL; 1872b21da92SAmir Goldstein oi->lowerdata_redirect = NULL; 1880af950f5SAmir Goldstein oi->oe = NULL; 189a015dafcSAmir Goldstein mutex_init(&oi->lock); 19025b7713aSMiklos Szeredi 19113cf199dSAmir Goldstein return &oi->vfs_inode; 19213cf199dSAmir Goldstein } 19313cf199dSAmir Goldstein 1940b269dedSAl Viro static void ovl_free_inode(struct inode *inode) 19513cf199dSAmir Goldstein { 1960b269dedSAl Viro struct ovl_inode *oi = OVL_I(inode); 19713cf199dSAmir Goldstein 1980b269dedSAl Viro kfree(oi->redirect); 1990b269dedSAl Viro mutex_destroy(&oi->lock); 2000b269dedSAl Viro kmem_cache_free(ovl_inode_cachep, oi); 20113cf199dSAmir Goldstein } 20213cf199dSAmir Goldstein 20313cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 20413cf199dSAmir Goldstein { 20509d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 20609d8b586SMiklos Szeredi 20709d8b586SMiklos Szeredi dput(oi->__upperdentry); 2080af950f5SAmir Goldstein ovl_free_entry(oi->oe); 2092664bd08SVivek Goyal if (S_ISDIR(inode->i_mode)) 2104edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 2112b21da92SAmir Goldstein else 2122b21da92SAmir Goldstein kfree(oi->lowerdata_redirect); 21313cf199dSAmir Goldstein } 21413cf199dSAmir Goldstein 215ad204488SMiklos Szeredi static void ovl_free_fs(struct ovl_fs *ofs) 216e9be9d5eSMiklos Szeredi { 217df820f8dSMiklos Szeredi struct vfsmount **mounts; 218dd662667SMiklos Szeredi unsigned i; 219e9be9d5eSMiklos Szeredi 2200be0bfd2SAmir Goldstein iput(ofs->workbasedir_trap); 221146d62e5SAmir Goldstein iput(ofs->indexdir_trap); 222146d62e5SAmir Goldstein iput(ofs->workdir_trap); 223c21c839bSChengguang Xu dput(ofs->whiteout); 224ad204488SMiklos Szeredi dput(ofs->indexdir); 225ad204488SMiklos Szeredi dput(ofs->workdir); 226ad204488SMiklos Szeredi if (ofs->workdir_locked) 227ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->workbasedir); 228ad204488SMiklos Szeredi dput(ofs->workbasedir); 229ad204488SMiklos Szeredi if (ofs->upperdir_locked) 23008f4c7c8SMiklos Szeredi ovl_inuse_unlock(ovl_upper_mnt(ofs)->mnt_root); 231df820f8dSMiklos Szeredi 232df820f8dSMiklos Szeredi /* Hack! Reuse ofs->layers as a vfsmount array before freeing it */ 233df820f8dSMiklos Szeredi mounts = (struct vfsmount **) ofs->layers; 234b8e42a65SMiklos Szeredi for (i = 0; i < ofs->numlayer; i++) { 23594375f9dSAmir Goldstein iput(ofs->layers[i].trap); 236df820f8dSMiklos Szeredi mounts[i] = ofs->layers[i].mnt; 237146d62e5SAmir Goldstein } 238df820f8dSMiklos Szeredi kern_unmount_array(mounts, ofs->numlayer); 23994375f9dSAmir Goldstein kfree(ofs->layers); 240b7bf9908SAmir Goldstein for (i = 0; i < ofs->numfs; i++) 24107f1e596SAmir Goldstein free_anon_bdev(ofs->fs[i].pseudo_dev); 24207f1e596SAmir Goldstein kfree(ofs->fs); 243e9be9d5eSMiklos Szeredi 244ad204488SMiklos Szeredi kfree(ofs->config.lowerdir); 245ad204488SMiklos Szeredi kfree(ofs->config.upperdir); 246ad204488SMiklos Szeredi kfree(ofs->config.workdir); 247ad204488SMiklos Szeredi if (ofs->creator_cred) 248ad204488SMiklos Szeredi put_cred(ofs->creator_cred); 249ad204488SMiklos Szeredi kfree(ofs); 250e9be9d5eSMiklos Szeredi } 251e9be9d5eSMiklos Szeredi 252a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 253a9075cdbSMiklos Szeredi { 254a9075cdbSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 255a9075cdbSMiklos Szeredi 256a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 257a9075cdbSMiklos Szeredi } 258a9075cdbSMiklos Szeredi 259e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */ 260e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 261e593b2bfSAmir Goldstein { 262ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 263e593b2bfSAmir Goldstein struct super_block *upper_sb; 264e593b2bfSAmir Goldstein int ret; 265e593b2bfSAmir Goldstein 266335d3fc5SSargun Dhillon ret = ovl_sync_status(ofs); 267335d3fc5SSargun Dhillon /* 268335d3fc5SSargun Dhillon * We have to always set the err, because the return value isn't 269335d3fc5SSargun Dhillon * checked in syncfs, and instead indirectly return an error via 270335d3fc5SSargun Dhillon * the sb's writeback errseq, which VFS inspects after this call. 271335d3fc5SSargun Dhillon */ 272335d3fc5SSargun Dhillon if (ret < 0) { 273335d3fc5SSargun Dhillon errseq_set(&sb->s_wb_err, -EIO); 274335d3fc5SSargun Dhillon return -EIO; 275335d3fc5SSargun Dhillon } 276e8d4bfe3SChengguang Xu 277335d3fc5SSargun Dhillon if (!ret) 278335d3fc5SSargun Dhillon return ret; 279335d3fc5SSargun Dhillon 280e8d4bfe3SChengguang Xu /* 28132b1924bSKonstantin Khlebnikov * Not called for sync(2) call or an emergency sync (SB_I_SKIP_SYNC). 28232b1924bSKonstantin Khlebnikov * All the super blocks will be iterated, including upper_sb. 283e8d4bfe3SChengguang Xu * 284e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call 285e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being 286e8d4bfe3SChengguang Xu * called with wait == 1. 287e8d4bfe3SChengguang Xu */ 288e8d4bfe3SChengguang Xu if (!wait) 289e593b2bfSAmir Goldstein return 0; 290e593b2bfSAmir Goldstein 29108f4c7c8SMiklos Szeredi upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 292e8d4bfe3SChengguang Xu 293e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 294e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb); 295e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 296e8d4bfe3SChengguang Xu 297e593b2bfSAmir Goldstein return ret; 298e593b2bfSAmir Goldstein } 299e593b2bfSAmir Goldstein 300cc259639SAndy Whitcroft /** 301cc259639SAndy Whitcroft * ovl_statfs 3029c5dd803SYang Li * @dentry: The dentry to query 303cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 304cc259639SAndy Whitcroft * 305cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 3064ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 307cc259639SAndy Whitcroft */ 308cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 309cc259639SAndy Whitcroft { 310cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 311cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 312cc259639SAndy Whitcroft struct path path; 313cc259639SAndy Whitcroft int err; 314cc259639SAndy Whitcroft 3154ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 316cc259639SAndy Whitcroft 317cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 318cc259639SAndy Whitcroft if (!err) { 3196b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 320cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 321cc259639SAndy Whitcroft } 322cc259639SAndy Whitcroft 323cc259639SAndy Whitcroft return err; 324cc259639SAndy Whitcroft } 325cc259639SAndy Whitcroft 32602bcd157SAmir Goldstein /* Will this overlay be forced to mount/remount ro? */ 327ad204488SMiklos Szeredi static bool ovl_force_readonly(struct ovl_fs *ofs) 32802bcd157SAmir Goldstein { 32908f4c7c8SMiklos Szeredi return (!ovl_upper_mnt(ofs) || !ofs->workdir); 33002bcd157SAmir Goldstein } 33102bcd157SAmir Goldstein 332*af5f2396SAmir Goldstein static const struct constant_table ovl_parameter_redirect_dir[] = { 333*af5f2396SAmir Goldstein { "off", OVL_REDIRECT_OFF }, 334*af5f2396SAmir Goldstein { "follow", OVL_REDIRECT_FOLLOW }, 335*af5f2396SAmir Goldstein { "nofollow", OVL_REDIRECT_NOFOLLOW }, 336*af5f2396SAmir Goldstein { "on", OVL_REDIRECT_ON }, 337*af5f2396SAmir Goldstein {} 338*af5f2396SAmir Goldstein }; 339*af5f2396SAmir Goldstein 340*af5f2396SAmir Goldstein static const char *ovl_redirect_mode(struct ovl_config *config) 341438c84c2SMiklos Szeredi { 342*af5f2396SAmir Goldstein return ovl_parameter_redirect_dir[config->redirect_mode].name; 343*af5f2396SAmir Goldstein } 344*af5f2396SAmir Goldstein 345*af5f2396SAmir Goldstein static int ovl_redirect_mode_def(void) 346*af5f2396SAmir Goldstein { 347*af5f2396SAmir Goldstein return ovl_redirect_dir_def ? OVL_REDIRECT_ON : 348*af5f2396SAmir Goldstein ovl_redirect_always_follow ? OVL_REDIRECT_FOLLOW : 349*af5f2396SAmir Goldstein OVL_REDIRECT_NOFOLLOW; 350438c84c2SMiklos Szeredi } 351438c84c2SMiklos Szeredi 352dcb399deSAmir Goldstein static const struct constant_table ovl_parameter_xino[] = { 353dcb399deSAmir Goldstein { "off", OVL_XINO_OFF }, 354dcb399deSAmir Goldstein { "auto", OVL_XINO_AUTO }, 355dcb399deSAmir Goldstein { "on", OVL_XINO_ON }, 356dcb399deSAmir Goldstein {} 357795939a9SAmir Goldstein }; 358795939a9SAmir Goldstein 359dcb399deSAmir Goldstein static const char *ovl_xino_mode(struct ovl_config *config) 360dcb399deSAmir Goldstein { 361dcb399deSAmir Goldstein return ovl_parameter_xino[config->xino].name; 362dcb399deSAmir Goldstein } 363dcb399deSAmir Goldstein 364795939a9SAmir Goldstein static inline int ovl_xino_def(void) 365795939a9SAmir Goldstein { 366795939a9SAmir Goldstein return ovl_xino_auto_def ? OVL_XINO_AUTO : OVL_XINO_OFF; 367795939a9SAmir Goldstein } 368795939a9SAmir Goldstein 369f45827e8SErez Zadok /** 370f45827e8SErez Zadok * ovl_show_options 3719c5dd803SYang Li * @m: the seq_file handle 3729c5dd803SYang Li * @dentry: The dentry to query 373f45827e8SErez Zadok * 374f45827e8SErez Zadok * Prints the mount options for a given superblock. 375f45827e8SErez Zadok * Returns zero; does not fail. 376f45827e8SErez Zadok */ 377f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 378f45827e8SErez Zadok { 379f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 380ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 381f45827e8SErez Zadok 382ad204488SMiklos Szeredi seq_show_option(m, "lowerdir", ofs->config.lowerdir); 383ad204488SMiklos Szeredi if (ofs->config.upperdir) { 384ad204488SMiklos Szeredi seq_show_option(m, "upperdir", ofs->config.upperdir); 385ad204488SMiklos Szeredi seq_show_option(m, "workdir", ofs->config.workdir); 38653a08cb9SMiklos Szeredi } 387ad204488SMiklos Szeredi if (ofs->config.default_permissions) 3888d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 389*af5f2396SAmir Goldstein if (ofs->config.redirect_mode != ovl_redirect_mode_def()) 390*af5f2396SAmir Goldstein seq_printf(m, ",redirect_dir=%s", 391*af5f2396SAmir Goldstein ovl_redirect_mode(&ofs->config)); 392ad204488SMiklos Szeredi if (ofs->config.index != ovl_index_def) 393438c84c2SMiklos Szeredi seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 3945830fb6bSPavel Tikhomirov if (!ofs->config.uuid) 3955830fb6bSPavel Tikhomirov seq_puts(m, ",uuid=off"); 396f168f109SAmir Goldstein if (ofs->config.nfs_export != ovl_nfs_export_def) 397f168f109SAmir Goldstein seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ? 398f168f109SAmir Goldstein "on" : "off"); 399dcb399deSAmir Goldstein if (ofs->config.xino != ovl_xino_def() && !ovl_same_fs(ofs)) 400dcb399deSAmir Goldstein seq_printf(m, ",xino=%s", ovl_xino_mode(&ofs->config)); 401d5791044SVivek Goyal if (ofs->config.metacopy != ovl_metacopy_def) 402d5791044SVivek Goyal seq_printf(m, ",metacopy=%s", 403d5791044SVivek Goyal ofs->config.metacopy ? "on" : "off"); 404c86243b0SVivek Goyal if (ofs->config.ovl_volatile) 405c86243b0SVivek Goyal seq_puts(m, ",volatile"); 406321b46b9SGiuseppe Scrivano if (ofs->config.userxattr) 407321b46b9SGiuseppe Scrivano seq_puts(m, ",userxattr"); 408f45827e8SErez Zadok return 0; 409f45827e8SErez Zadok } 410f45827e8SErez Zadok 4113cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 4123cdf6fe9SSeunghun Lee { 413ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 414399c109dSChengguang Xu struct super_block *upper_sb; 415399c109dSChengguang Xu int ret = 0; 4163cdf6fe9SSeunghun Lee 4171751e8a6SLinus Torvalds if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 4183cdf6fe9SSeunghun Lee return -EROFS; 4193cdf6fe9SSeunghun Lee 420399c109dSChengguang Xu if (*flags & SB_RDONLY && !sb_rdonly(sb)) { 42108f4c7c8SMiklos Szeredi upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 422c86243b0SVivek Goyal if (ovl_should_sync(ofs)) { 423399c109dSChengguang Xu down_read(&upper_sb->s_umount); 424399c109dSChengguang Xu ret = sync_filesystem(upper_sb); 425399c109dSChengguang Xu up_read(&upper_sb->s_umount); 426399c109dSChengguang Xu } 427c86243b0SVivek Goyal } 428399c109dSChengguang Xu 429399c109dSChengguang Xu return ret; 4303cdf6fe9SSeunghun Lee } 4313cdf6fe9SSeunghun Lee 432e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 43313cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 4340b269dedSAl Viro .free_inode = ovl_free_inode, 43513cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 43613cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 437e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 438e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 439cc259639SAndy Whitcroft .statfs = ovl_statfs, 440f45827e8SErez Zadok .show_options = ovl_show_options, 4413cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 442e9be9d5eSMiklos Szeredi }; 443e9be9d5eSMiklos Szeredi 444e9be9d5eSMiklos Szeredi enum { 445e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 446e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 447e9be9d5eSMiklos Szeredi OPT_WORKDIR, 4488d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 449*af5f2396SAmir Goldstein OPT_REDIRECT_DIR_ON, 450*af5f2396SAmir Goldstein OPT_REDIRECT_DIR_OFF, 451*af5f2396SAmir Goldstein OPT_REDIRECT_DIR_FOLLOW, 452*af5f2396SAmir Goldstein OPT_REDIRECT_DIR_NOFOLLOW, 45302bcd157SAmir Goldstein OPT_INDEX_ON, 45402bcd157SAmir Goldstein OPT_INDEX_OFF, 4555830fb6bSPavel Tikhomirov OPT_UUID_ON, 4565830fb6bSPavel Tikhomirov OPT_UUID_OFF, 457f168f109SAmir Goldstein OPT_NFS_EXPORT_ON, 4582d2f2d73SMiklos Szeredi OPT_USERXATTR, 459f168f109SAmir Goldstein OPT_NFS_EXPORT_OFF, 460795939a9SAmir Goldstein OPT_XINO_ON, 461795939a9SAmir Goldstein OPT_XINO_OFF, 462795939a9SAmir Goldstein OPT_XINO_AUTO, 463d5791044SVivek Goyal OPT_METACOPY_ON, 464d5791044SVivek Goyal OPT_METACOPY_OFF, 465c86243b0SVivek Goyal OPT_VOLATILE, 466e9be9d5eSMiklos Szeredi OPT_ERR, 467e9be9d5eSMiklos Szeredi }; 468e9be9d5eSMiklos Szeredi 469e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 470e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 471e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 472e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 4738d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 474*af5f2396SAmir Goldstein {OPT_REDIRECT_DIR_ON, "redirect_dir=on"}, 475*af5f2396SAmir Goldstein {OPT_REDIRECT_DIR_OFF, "redirect_dir=off"}, 476*af5f2396SAmir Goldstein {OPT_REDIRECT_DIR_FOLLOW, "redirect_dir=follow"}, 477*af5f2396SAmir Goldstein {OPT_REDIRECT_DIR_NOFOLLOW, "redirect_dir=nofollow"}, 47802bcd157SAmir Goldstein {OPT_INDEX_ON, "index=on"}, 47902bcd157SAmir Goldstein {OPT_INDEX_OFF, "index=off"}, 4802d2f2d73SMiklos Szeredi {OPT_USERXATTR, "userxattr"}, 4815830fb6bSPavel Tikhomirov {OPT_UUID_ON, "uuid=on"}, 4825830fb6bSPavel Tikhomirov {OPT_UUID_OFF, "uuid=off"}, 483f168f109SAmir Goldstein {OPT_NFS_EXPORT_ON, "nfs_export=on"}, 484f168f109SAmir Goldstein {OPT_NFS_EXPORT_OFF, "nfs_export=off"}, 485795939a9SAmir Goldstein {OPT_XINO_ON, "xino=on"}, 486795939a9SAmir Goldstein {OPT_XINO_OFF, "xino=off"}, 487795939a9SAmir Goldstein {OPT_XINO_AUTO, "xino=auto"}, 488d5791044SVivek Goyal {OPT_METACOPY_ON, "metacopy=on"}, 489d5791044SVivek Goyal {OPT_METACOPY_OFF, "metacopy=off"}, 490c86243b0SVivek Goyal {OPT_VOLATILE, "volatile"}, 491e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 492e9be9d5eSMiklos Szeredi }; 493e9be9d5eSMiklos Szeredi 49491c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 49591c77947SMiklos Szeredi { 49691c77947SMiklos Szeredi char *sbegin = *s; 49791c77947SMiklos Szeredi char *p; 49891c77947SMiklos Szeredi 49991c77947SMiklos Szeredi if (sbegin == NULL) 50091c77947SMiklos Szeredi return NULL; 50191c77947SMiklos Szeredi 50291c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 50391c77947SMiklos Szeredi if (*p == '\\') { 50491c77947SMiklos Szeredi p++; 50591c77947SMiklos Szeredi if (!*p) 50691c77947SMiklos Szeredi break; 50791c77947SMiklos Szeredi } else if (*p == ',') { 50891c77947SMiklos Szeredi *p = '\0'; 50991c77947SMiklos Szeredi *s = p + 1; 51091c77947SMiklos Szeredi return sbegin; 51191c77947SMiklos Szeredi } 51291c77947SMiklos Szeredi } 51391c77947SMiklos Szeredi *s = NULL; 51491c77947SMiklos Szeredi return sbegin; 51591c77947SMiklos Szeredi } 51691c77947SMiklos Szeredi 517e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 518e9be9d5eSMiklos Szeredi { 519e9be9d5eSMiklos Szeredi char *p; 520d47748e5SMiklos Szeredi bool metacopy_opt = false, redirect_opt = false; 521b0def88dSAmir Goldstein bool nfs_export_opt = false, index_opt = false; 522e9be9d5eSMiklos Szeredi 52391c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 524e9be9d5eSMiklos Szeredi int token; 525e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 526e9be9d5eSMiklos Szeredi 527e9be9d5eSMiklos Szeredi if (!*p) 528e9be9d5eSMiklos Szeredi continue; 529e9be9d5eSMiklos Szeredi 530e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 531e9be9d5eSMiklos Szeredi switch (token) { 532e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 533e9be9d5eSMiklos Szeredi kfree(config->upperdir); 534e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 535e9be9d5eSMiklos Szeredi if (!config->upperdir) 536e9be9d5eSMiklos Szeredi return -ENOMEM; 537e9be9d5eSMiklos Szeredi break; 538e9be9d5eSMiklos Szeredi 539e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 540e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 541e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 542e9be9d5eSMiklos Szeredi if (!config->lowerdir) 543e9be9d5eSMiklos Szeredi return -ENOMEM; 544e9be9d5eSMiklos Szeredi break; 545e9be9d5eSMiklos Szeredi 546e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 547e9be9d5eSMiklos Szeredi kfree(config->workdir); 548e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 549e9be9d5eSMiklos Szeredi if (!config->workdir) 550e9be9d5eSMiklos Szeredi return -ENOMEM; 551e9be9d5eSMiklos Szeredi break; 552e9be9d5eSMiklos Szeredi 5538d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 5548d3095f4SMiklos Szeredi config->default_permissions = true; 5558d3095f4SMiklos Szeredi break; 5568d3095f4SMiklos Szeredi 557*af5f2396SAmir Goldstein case OPT_REDIRECT_DIR_ON: 558*af5f2396SAmir Goldstein config->redirect_mode = OVL_REDIRECT_ON; 559*af5f2396SAmir Goldstein redirect_opt = true; 560*af5f2396SAmir Goldstein break; 561*af5f2396SAmir Goldstein 562*af5f2396SAmir Goldstein case OPT_REDIRECT_DIR_OFF: 563*af5f2396SAmir Goldstein config->redirect_mode = ovl_redirect_always_follow ? 564*af5f2396SAmir Goldstein OVL_REDIRECT_FOLLOW : 565*af5f2396SAmir Goldstein OVL_REDIRECT_NOFOLLOW; 566*af5f2396SAmir Goldstein redirect_opt = true; 567*af5f2396SAmir Goldstein break; 568*af5f2396SAmir Goldstein 569*af5f2396SAmir Goldstein case OPT_REDIRECT_DIR_FOLLOW: 570*af5f2396SAmir Goldstein config->redirect_mode = OVL_REDIRECT_FOLLOW; 571*af5f2396SAmir Goldstein redirect_opt = true; 572*af5f2396SAmir Goldstein break; 573*af5f2396SAmir Goldstein 574*af5f2396SAmir Goldstein case OPT_REDIRECT_DIR_NOFOLLOW: 575*af5f2396SAmir Goldstein config->redirect_mode = OVL_REDIRECT_NOFOLLOW; 576d47748e5SMiklos Szeredi redirect_opt = true; 577a6c60655SMiklos Szeredi break; 578a6c60655SMiklos Szeredi 57902bcd157SAmir Goldstein case OPT_INDEX_ON: 58002bcd157SAmir Goldstein config->index = true; 581b0def88dSAmir Goldstein index_opt = true; 58202bcd157SAmir Goldstein break; 58302bcd157SAmir Goldstein 58402bcd157SAmir Goldstein case OPT_INDEX_OFF: 58502bcd157SAmir Goldstein config->index = false; 586b0def88dSAmir Goldstein index_opt = true; 58702bcd157SAmir Goldstein break; 58802bcd157SAmir Goldstein 5895830fb6bSPavel Tikhomirov case OPT_UUID_ON: 5905830fb6bSPavel Tikhomirov config->uuid = true; 5915830fb6bSPavel Tikhomirov break; 5925830fb6bSPavel Tikhomirov 5935830fb6bSPavel Tikhomirov case OPT_UUID_OFF: 5945830fb6bSPavel Tikhomirov config->uuid = false; 5955830fb6bSPavel Tikhomirov break; 5965830fb6bSPavel Tikhomirov 597f168f109SAmir Goldstein case OPT_NFS_EXPORT_ON: 598f168f109SAmir Goldstein config->nfs_export = true; 599b0def88dSAmir Goldstein nfs_export_opt = true; 600f168f109SAmir Goldstein break; 601f168f109SAmir Goldstein 602f168f109SAmir Goldstein case OPT_NFS_EXPORT_OFF: 603f168f109SAmir Goldstein config->nfs_export = false; 604b0def88dSAmir Goldstein nfs_export_opt = true; 605f168f109SAmir Goldstein break; 606f168f109SAmir Goldstein 607795939a9SAmir Goldstein case OPT_XINO_ON: 608795939a9SAmir Goldstein config->xino = OVL_XINO_ON; 609795939a9SAmir Goldstein break; 610795939a9SAmir Goldstein 611795939a9SAmir Goldstein case OPT_XINO_OFF: 612795939a9SAmir Goldstein config->xino = OVL_XINO_OFF; 613795939a9SAmir Goldstein break; 614795939a9SAmir Goldstein 615795939a9SAmir Goldstein case OPT_XINO_AUTO: 616795939a9SAmir Goldstein config->xino = OVL_XINO_AUTO; 617795939a9SAmir Goldstein break; 618795939a9SAmir Goldstein 619d5791044SVivek Goyal case OPT_METACOPY_ON: 620d5791044SVivek Goyal config->metacopy = true; 621d47748e5SMiklos Szeredi metacopy_opt = true; 622d5791044SVivek Goyal break; 623d5791044SVivek Goyal 624d5791044SVivek Goyal case OPT_METACOPY_OFF: 625d5791044SVivek Goyal config->metacopy = false; 626b0def88dSAmir Goldstein metacopy_opt = true; 627d5791044SVivek Goyal break; 628d5791044SVivek Goyal 629c86243b0SVivek Goyal case OPT_VOLATILE: 630c86243b0SVivek Goyal config->ovl_volatile = true; 631c86243b0SVivek Goyal break; 632c86243b0SVivek Goyal 6332d2f2d73SMiklos Szeredi case OPT_USERXATTR: 6342d2f2d73SMiklos Szeredi config->userxattr = true; 6352d2f2d73SMiklos Szeredi break; 6362d2f2d73SMiklos Szeredi 637e9be9d5eSMiklos Szeredi default: 6381bd0a3aeSlijiazi pr_err("unrecognized mount option \"%s\" or missing value\n", 6391bd0a3aeSlijiazi p); 640e9be9d5eSMiklos Szeredi return -EINVAL; 641e9be9d5eSMiklos Szeredi } 642e9be9d5eSMiklos Szeredi } 64371cbad7eShujianyang 644f0e1266eSAmir Goldstein /* Workdir/index are useless in non-upper mount */ 645f0e1266eSAmir Goldstein if (!config->upperdir) { 646f0e1266eSAmir Goldstein if (config->workdir) { 6471bd0a3aeSlijiazi pr_info("option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 64871cbad7eShujianyang config->workdir); 64971cbad7eShujianyang kfree(config->workdir); 65071cbad7eShujianyang config->workdir = NULL; 65171cbad7eShujianyang } 652f0e1266eSAmir Goldstein if (config->index && index_opt) { 653f0e1266eSAmir Goldstein pr_info("option \"index=on\" is useless in a non-upper mount, ignore\n"); 654f0e1266eSAmir Goldstein index_opt = false; 655f0e1266eSAmir Goldstein } 656f0e1266eSAmir Goldstein config->index = false; 657f0e1266eSAmir Goldstein } 65871cbad7eShujianyang 659c86243b0SVivek Goyal if (!config->upperdir && config->ovl_volatile) { 660c86243b0SVivek Goyal pr_info("option \"volatile\" is meaningless in a non-upper mount, ignoring it.\n"); 661c86243b0SVivek Goyal config->ovl_volatile = false; 662c86243b0SVivek Goyal } 663c86243b0SVivek Goyal 664d47748e5SMiklos Szeredi /* 665d47748e5SMiklos Szeredi * This is to make the logic below simpler. It doesn't make any other 666*af5f2396SAmir Goldstein * difference, since redirect_dir=on is only used for upper. 667d47748e5SMiklos Szeredi */ 668*af5f2396SAmir Goldstein if (!config->upperdir && config->redirect_mode == OVL_REDIRECT_FOLLOW) 669*af5f2396SAmir Goldstein config->redirect_mode = OVL_REDIRECT_ON; 670d47748e5SMiklos Szeredi 671d47748e5SMiklos Szeredi /* Resolve metacopy -> redirect_dir dependency */ 672*af5f2396SAmir Goldstein if (config->metacopy && config->redirect_mode != OVL_REDIRECT_ON) { 673d47748e5SMiklos Szeredi if (metacopy_opt && redirect_opt) { 6741bd0a3aeSlijiazi pr_err("conflicting options: metacopy=on,redirect_dir=%s\n", 675*af5f2396SAmir Goldstein ovl_redirect_mode(config)); 676d47748e5SMiklos Szeredi return -EINVAL; 677d47748e5SMiklos Szeredi } 678d47748e5SMiklos Szeredi if (redirect_opt) { 679d47748e5SMiklos Szeredi /* 680d47748e5SMiklos Szeredi * There was an explicit redirect_dir=... that resulted 681d47748e5SMiklos Szeredi * in this conflict. 682d47748e5SMiklos Szeredi */ 6831bd0a3aeSlijiazi pr_info("disabling metacopy due to redirect_dir=%s\n", 684*af5f2396SAmir Goldstein ovl_redirect_mode(config)); 685d5791044SVivek Goyal config->metacopy = false; 686d47748e5SMiklos Szeredi } else { 687d47748e5SMiklos Szeredi /* Automatically enable redirect otherwise. */ 688*af5f2396SAmir Goldstein config->redirect_mode = OVL_REDIRECT_ON; 689d47748e5SMiklos Szeredi } 690d5791044SVivek Goyal } 691d5791044SVivek Goyal 692b0def88dSAmir Goldstein /* Resolve nfs_export -> index dependency */ 693b0def88dSAmir Goldstein if (config->nfs_export && !config->index) { 694*af5f2396SAmir Goldstein if (!config->upperdir && 695*af5f2396SAmir Goldstein config->redirect_mode != OVL_REDIRECT_NOFOLLOW) { 696f0e1266eSAmir Goldstein pr_info("NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n"); 697f0e1266eSAmir Goldstein config->nfs_export = false; 698f0e1266eSAmir Goldstein } else if (nfs_export_opt && index_opt) { 699b0def88dSAmir Goldstein pr_err("conflicting options: nfs_export=on,index=off\n"); 700b0def88dSAmir Goldstein return -EINVAL; 701f0e1266eSAmir Goldstein } else if (index_opt) { 702b0def88dSAmir Goldstein /* 703b0def88dSAmir Goldstein * There was an explicit index=off that resulted 704b0def88dSAmir Goldstein * in this conflict. 705b0def88dSAmir Goldstein */ 706b0def88dSAmir Goldstein pr_info("disabling nfs_export due to index=off\n"); 707b0def88dSAmir Goldstein config->nfs_export = false; 708b0def88dSAmir Goldstein } else { 709b0def88dSAmir Goldstein /* Automatically enable index otherwise. */ 710b0def88dSAmir Goldstein config->index = true; 711b0def88dSAmir Goldstein } 712b0def88dSAmir Goldstein } 713b0def88dSAmir Goldstein 714b0def88dSAmir Goldstein /* Resolve nfs_export -> !metacopy dependency */ 715b0def88dSAmir Goldstein if (config->nfs_export && config->metacopy) { 716b0def88dSAmir Goldstein if (nfs_export_opt && metacopy_opt) { 717b0def88dSAmir Goldstein pr_err("conflicting options: nfs_export=on,metacopy=on\n"); 718b0def88dSAmir Goldstein return -EINVAL; 719b0def88dSAmir Goldstein } 720b0def88dSAmir Goldstein if (metacopy_opt) { 721b0def88dSAmir Goldstein /* 722b0def88dSAmir Goldstein * There was an explicit metacopy=on that resulted 723b0def88dSAmir Goldstein * in this conflict. 724b0def88dSAmir Goldstein */ 725b0def88dSAmir Goldstein pr_info("disabling nfs_export due to metacopy=on\n"); 726b0def88dSAmir Goldstein config->nfs_export = false; 727b0def88dSAmir Goldstein } else { 728b0def88dSAmir Goldstein /* 729b0def88dSAmir Goldstein * There was an explicit nfs_export=on that resulted 730b0def88dSAmir Goldstein * in this conflict. 731b0def88dSAmir Goldstein */ 732b0def88dSAmir Goldstein pr_info("disabling metacopy due to nfs_export=on\n"); 733b0def88dSAmir Goldstein config->metacopy = false; 734b0def88dSAmir Goldstein } 735b0def88dSAmir Goldstein } 736b0def88dSAmir Goldstein 7372d2f2d73SMiklos Szeredi 7382d2f2d73SMiklos Szeredi /* Resolve userxattr -> !redirect && !metacopy dependency */ 7392d2f2d73SMiklos Szeredi if (config->userxattr) { 740*af5f2396SAmir Goldstein if (redirect_opt && 741*af5f2396SAmir Goldstein config->redirect_mode != OVL_REDIRECT_NOFOLLOW) { 7422d2f2d73SMiklos Szeredi pr_err("conflicting options: userxattr,redirect_dir=%s\n", 743*af5f2396SAmir Goldstein ovl_redirect_mode(config)); 7442d2f2d73SMiklos Szeredi return -EINVAL; 7452d2f2d73SMiklos Szeredi } 7462d2f2d73SMiklos Szeredi if (config->metacopy && metacopy_opt) { 7472d2f2d73SMiklos Szeredi pr_err("conflicting options: userxattr,metacopy=on\n"); 7482d2f2d73SMiklos Szeredi return -EINVAL; 7492d2f2d73SMiklos Szeredi } 7502d2f2d73SMiklos Szeredi /* 7512d2f2d73SMiklos Szeredi * Silently disable default setting of redirect and metacopy. 7522d2f2d73SMiklos Szeredi * This shall be the default in the future as well: these 7532d2f2d73SMiklos Szeredi * options must be explicitly enabled if used together with 7542d2f2d73SMiklos Szeredi * userxattr. 7552d2f2d73SMiklos Szeredi */ 756*af5f2396SAmir Goldstein config->redirect_mode = OVL_REDIRECT_NOFOLLOW; 7572d2f2d73SMiklos Szeredi config->metacopy = false; 7582d2f2d73SMiklos Szeredi } 7592d2f2d73SMiklos Szeredi 760d5791044SVivek Goyal return 0; 761e9be9d5eSMiklos Szeredi } 762e9be9d5eSMiklos Szeredi 763e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 76402bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 765e9be9d5eSMiklos Szeredi 766ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 7676b8aa129SAmir Goldstein const char *name, bool persist) 768e9be9d5eSMiklos Szeredi { 769ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 77008f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 771e9be9d5eSMiklos Szeredi struct dentry *work; 772e9be9d5eSMiklos Szeredi int err; 773e9be9d5eSMiklos Szeredi bool retried = false; 774e9be9d5eSMiklos Szeredi 7755955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 776e9be9d5eSMiklos Szeredi retry: 77722f289ceSChristian Brauner work = ovl_lookup_upper(ofs, name, ofs->workbasedir, strlen(name)); 778e9be9d5eSMiklos Szeredi 779e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 780c11b9fddSMiklos Szeredi struct iattr attr = { 781c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 78232a3d848SAl Viro .ia_mode = S_IFDIR | 0, 783c11b9fddSMiklos Szeredi }; 784e9be9d5eSMiklos Szeredi 785e9be9d5eSMiklos Szeredi if (work->d_inode) { 786e9be9d5eSMiklos Szeredi err = -EEXIST; 787e9be9d5eSMiklos Szeredi if (retried) 788e9be9d5eSMiklos Szeredi goto out_dput; 789e9be9d5eSMiklos Szeredi 7906b8aa129SAmir Goldstein if (persist) 7916b8aa129SAmir Goldstein goto out_unlock; 7926b8aa129SAmir Goldstein 793e9be9d5eSMiklos Szeredi retried = true; 794576bb263SChristian Brauner err = ovl_workdir_cleanup(ofs, dir, mnt, work, 0); 795e9be9d5eSMiklos Szeredi dput(work); 796235ce9edSAmir Goldstein if (err == -EINVAL) { 797235ce9edSAmir Goldstein work = ERR_PTR(err); 798235ce9edSAmir Goldstein goto out_unlock; 799235ce9edSAmir Goldstein } 800e9be9d5eSMiklos Szeredi goto retry; 801e9be9d5eSMiklos Szeredi } 802e9be9d5eSMiklos Szeredi 803576bb263SChristian Brauner err = ovl_mkdir_real(ofs, dir, &work, attr.ia_mode); 8041f5573cfSMiklos Szeredi if (err) 8051f5573cfSMiklos Szeredi goto out_dput; 8061f5573cfSMiklos Szeredi 8071f5573cfSMiklos Szeredi /* Weird filesystem returning with hashed negative (kernfs)? */ 8081f5573cfSMiklos Szeredi err = -EINVAL; 8091f5573cfSMiklos Szeredi if (d_really_is_negative(work)) 8101f5573cfSMiklos Szeredi goto out_dput; 811c11b9fddSMiklos Szeredi 812cb348edbSMiklos Szeredi /* 813cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 814cb348edbSMiklos Szeredi * 815cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 816cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 817cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 818cb348edbSMiklos Szeredi * 819cb348edbSMiklos Szeredi * There are various other error values that could effectively 820cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 821cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 822cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 823cb348edbSMiklos Szeredi * for the above two errors is sufficient. 824cb348edbSMiklos Szeredi */ 82531acceb9SChristian Brauner err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_DEFAULT); 826e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 827c11b9fddSMiklos Szeredi goto out_dput; 828c11b9fddSMiklos Szeredi 82931acceb9SChristian Brauner err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_ACCESS); 830e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 831c11b9fddSMiklos Szeredi goto out_dput; 832c11b9fddSMiklos Szeredi 833c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 834c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 835a15506eaSChristian Brauner err = ovl_do_notify_change(ofs, work, &attr); 836c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 837c11b9fddSMiklos Szeredi if (err) 838c11b9fddSMiklos Szeredi goto out_dput; 8396b8aa129SAmir Goldstein } else { 8406b8aa129SAmir Goldstein err = PTR_ERR(work); 8416b8aa129SAmir Goldstein goto out_err; 842e9be9d5eSMiklos Szeredi } 843e9be9d5eSMiklos Szeredi out_unlock: 8446b8aa129SAmir Goldstein inode_unlock(dir); 845e9be9d5eSMiklos Szeredi return work; 846e9be9d5eSMiklos Szeredi 847e9be9d5eSMiklos Szeredi out_dput: 848e9be9d5eSMiklos Szeredi dput(work); 8496b8aa129SAmir Goldstein out_err: 8501bd0a3aeSlijiazi pr_warn("failed to create directory %s/%s (errno: %i); mounting read-only\n", 851ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 8526b8aa129SAmir Goldstein work = NULL; 853e9be9d5eSMiklos Szeredi goto out_unlock; 854e9be9d5eSMiklos Szeredi } 855e9be9d5eSMiklos Szeredi 85691c77947SMiklos Szeredi static void ovl_unescape(char *s) 85791c77947SMiklos Szeredi { 85891c77947SMiklos Szeredi char *d = s; 85991c77947SMiklos Szeredi 86091c77947SMiklos Szeredi for (;; s++, d++) { 86191c77947SMiklos Szeredi if (*s == '\\') 86291c77947SMiklos Szeredi s++; 86391c77947SMiklos Szeredi *d = *s; 86491c77947SMiklos Szeredi if (!*s) 86591c77947SMiklos Szeredi break; 86691c77947SMiklos Szeredi } 86791c77947SMiklos Szeredi } 86891c77947SMiklos Szeredi 869ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 870ab508822SMiklos Szeredi { 871a78d9f0dSMiklos Szeredi int err = -EINVAL; 872ab508822SMiklos Szeredi 873a78d9f0dSMiklos Szeredi if (!*name) { 8741bd0a3aeSlijiazi pr_err("empty lowerdir\n"); 875a78d9f0dSMiklos Szeredi goto out; 876a78d9f0dSMiklos Szeredi } 877ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 878ab508822SMiklos Szeredi if (err) { 8791bd0a3aeSlijiazi pr_err("failed to resolve '%s': %i\n", name, err); 880ab508822SMiklos Szeredi goto out; 881ab508822SMiklos Szeredi } 882ab508822SMiklos Szeredi err = -EINVAL; 8837c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 8841bd0a3aeSlijiazi pr_err("filesystem on '%s' not supported\n", name); 885ab508822SMiklos Szeredi goto out_put; 886ab508822SMiklos Szeredi } 8872b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 8881bd0a3aeSlijiazi pr_err("'%s' not a directory\n", name); 889ab508822SMiklos Szeredi goto out_put; 890ab508822SMiklos Szeredi } 891ab508822SMiklos Szeredi return 0; 892ab508822SMiklos Szeredi 893ab508822SMiklos Szeredi out_put: 8948aafcb59SMiklos Szeredi path_put_init(path); 895ab508822SMiklos Szeredi out: 896ab508822SMiklos Szeredi return err; 897ab508822SMiklos Szeredi } 898ab508822SMiklos Szeredi 899ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 900ab508822SMiklos Szeredi { 901ab508822SMiklos Szeredi int err = -ENOMEM; 902ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 903ab508822SMiklos Szeredi 904ab508822SMiklos Szeredi if (tmp) { 905ab508822SMiklos Szeredi ovl_unescape(tmp); 906ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 9077c03b5d4SMiklos Szeredi 908bccece1eSMiklos Szeredi if (!err && path->dentry->d_flags & DCACHE_OP_REAL) { 9091bd0a3aeSlijiazi pr_err("filesystem on '%s' not supported as upperdir\n", 9107c03b5d4SMiklos Szeredi tmp); 9118aafcb59SMiklos Szeredi path_put_init(path); 9127c03b5d4SMiklos Szeredi err = -EINVAL; 9137c03b5d4SMiklos Szeredi } 914ab508822SMiklos Szeredi kfree(tmp); 915ab508822SMiklos Szeredi } 916ab508822SMiklos Szeredi return err; 917ab508822SMiklos Szeredi } 918ab508822SMiklos Szeredi 9192d343087SAl Viro static int ovl_check_namelen(const struct path *path, struct ovl_fs *ofs, 9206b2d5fe4SMiklos Szeredi const char *name) 9216b2d5fe4SMiklos Szeredi { 9226b2d5fe4SMiklos Szeredi struct kstatfs statfs; 9236b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 9246b2d5fe4SMiklos Szeredi 9256b2d5fe4SMiklos Szeredi if (err) 9261bd0a3aeSlijiazi pr_err("statfs failed on '%s'\n", name); 9276b2d5fe4SMiklos Szeredi else 9286b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 9296b2d5fe4SMiklos Szeredi 9306b2d5fe4SMiklos Szeredi return err; 9316b2d5fe4SMiklos Szeredi } 9326b2d5fe4SMiklos Szeredi 9336b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 934f4288844SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth) 935ab508822SMiklos Szeredi { 936e487d889SAmir Goldstein int fh_type; 937ab508822SMiklos Szeredi int err; 938ab508822SMiklos Szeredi 939a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 940ab508822SMiklos Szeredi if (err) 941b8e42a65SMiklos Szeredi return err; 942ab508822SMiklos Szeredi 9436b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 9446b2d5fe4SMiklos Szeredi if (err) 945b8e42a65SMiklos Szeredi return err; 9466b2d5fe4SMiklos Szeredi 947ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 948ab508822SMiklos Szeredi 94902bcd157SAmir Goldstein /* 950f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode 951f168f109SAmir Goldstein * file handles, so they require that all layers support them. 95202bcd157SAmir Goldstein */ 953e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(path->dentry->d_sb); 954f168f109SAmir Goldstein if ((ofs->config.nfs_export || 955e487d889SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 95602bcd157SAmir Goldstein ofs->config.index = false; 957f168f109SAmir Goldstein ofs->config.nfs_export = false; 9581bd0a3aeSlijiazi pr_warn("fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 959f168f109SAmir Goldstein name); 96002bcd157SAmir Goldstein } 961b0e0f697SAmir Goldstein /* 962b0e0f697SAmir Goldstein * Decoding origin file handle is required for persistent st_ino. 963b0e0f697SAmir Goldstein * Without persistent st_ino, xino=auto falls back to xino=off. 964b0e0f697SAmir Goldstein */ 965b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO && 966b0e0f697SAmir Goldstein ofs->config.upperdir && !fh_type) { 967b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 968b0e0f697SAmir Goldstein pr_warn("fs on '%s' does not support file handles, falling back to xino=off.\n", 969b0e0f697SAmir Goldstein name); 970b0e0f697SAmir Goldstein } 97102bcd157SAmir Goldstein 972e487d889SAmir Goldstein /* Check if lower fs has 32bit inode numbers */ 973e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 9740f831ec8SAmir Goldstein ofs->xino_mode = -1; 975e487d889SAmir Goldstein 976ab508822SMiklos Szeredi return 0; 977ab508822SMiklos Szeredi } 978ab508822SMiklos Szeredi 979e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 980e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 981e9be9d5eSMiklos Szeredi { 982e9be9d5eSMiklos Szeredi bool ok = false; 983e9be9d5eSMiklos Szeredi 984e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 985e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 986e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 987e9be9d5eSMiklos Szeredi } 988e9be9d5eSMiklos Szeredi return ok; 989e9be9d5eSMiklos Szeredi } 990e9be9d5eSMiklos Szeredi 991a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 992a78d9f0dSMiklos Szeredi { 993a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 994a78d9f0dSMiklos Szeredi char *s, *d; 995a78d9f0dSMiklos Szeredi 996a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 997a78d9f0dSMiklos Szeredi if (*s == '\\') { 998a78d9f0dSMiklos Szeredi s++; 999a78d9f0dSMiklos Szeredi } else if (*s == ':') { 1000a78d9f0dSMiklos Szeredi *d = '\0'; 1001a78d9f0dSMiklos Szeredi ctr++; 1002a78d9f0dSMiklos Szeredi continue; 1003a78d9f0dSMiklos Szeredi } 1004a78d9f0dSMiklos Szeredi *d = *s; 1005a78d9f0dSMiklos Szeredi if (!*s) 1006a78d9f0dSMiklos Szeredi break; 1007a78d9f0dSMiklos Szeredi } 1008a78d9f0dSMiklos Szeredi return ctr; 1009a78d9f0dSMiklos Szeredi } 1010a78d9f0dSMiklos Szeredi 10110eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 10120eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 10130eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 10140eb45fc3SAndreas Gruenbacher { 101548fab5d7SAmir Goldstein return -EOPNOTSUPP; 10160eb45fc3SAndreas Gruenbacher } 10170eb45fc3SAndreas Gruenbacher 1018d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 101939f60c1cSChristian Brauner struct mnt_idmap *idmap, 1020d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 1021d837a49bSMiklos Szeredi const char *name, const void *value, 1022d837a49bSMiklos Szeredi size_t size, int flags) 1023d837a49bSMiklos Szeredi { 102448fab5d7SAmir Goldstein return -EOPNOTSUPP; 1025d837a49bSMiklos Szeredi } 1026d837a49bSMiklos Szeredi 10270eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 10280eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 10290eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 10300eb45fc3SAndreas Gruenbacher { 10311d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 10320eb45fc3SAndreas Gruenbacher } 10330eb45fc3SAndreas Gruenbacher 10340e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 103539f60c1cSChristian Brauner struct mnt_idmap *idmap, 10360e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 10370e585cccSAndreas Gruenbacher const char *name, const void *value, 10380e585cccSAndreas Gruenbacher size_t size, int flags) 10390e585cccSAndreas Gruenbacher { 10401d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 10410e585cccSAndreas Gruenbacher } 10420e585cccSAndreas Gruenbacher 10432d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_trusted_xattr_handler = { 10442d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_TRUSTED_PREFIX, 10452d2f2d73SMiklos Szeredi .get = ovl_own_xattr_get, 10462d2f2d73SMiklos Szeredi .set = ovl_own_xattr_set, 10472d2f2d73SMiklos Szeredi }; 10482d2f2d73SMiklos Szeredi 10492d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_user_xattr_handler = { 10502d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_USER_PREFIX, 10510eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 1052d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 1053d837a49bSMiklos Szeredi }; 1054d837a49bSMiklos Szeredi 1055d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 1056d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 10570eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 1058d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 1059d837a49bSMiklos Szeredi }; 1060d837a49bSMiklos Szeredi 10612d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_trusted_xattr_handlers[] = { 10622d2f2d73SMiklos Szeredi &ovl_own_trusted_xattr_handler, 10632d2f2d73SMiklos Szeredi &ovl_other_xattr_handler, 10642d2f2d73SMiklos Szeredi NULL 10652d2f2d73SMiklos Szeredi }; 10662d2f2d73SMiklos Szeredi 10672d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_user_xattr_handlers[] = { 10682d2f2d73SMiklos Szeredi &ovl_own_user_xattr_handler, 1069d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 1070d837a49bSMiklos Szeredi NULL 1071d837a49bSMiklos Szeredi }; 1072d837a49bSMiklos Szeredi 1073146d62e5SAmir Goldstein static int ovl_setup_trap(struct super_block *sb, struct dentry *dir, 1074146d62e5SAmir Goldstein struct inode **ptrap, const char *name) 1075146d62e5SAmir Goldstein { 1076146d62e5SAmir Goldstein struct inode *trap; 1077146d62e5SAmir Goldstein int err; 1078146d62e5SAmir Goldstein 1079146d62e5SAmir Goldstein trap = ovl_get_trap_inode(sb, dir); 10801dac6f5bSArnd Bergmann err = PTR_ERR_OR_ZERO(trap); 10811dac6f5bSArnd Bergmann if (err) { 1082146d62e5SAmir Goldstein if (err == -ELOOP) 10831bd0a3aeSlijiazi pr_err("conflicting %s path\n", name); 1084146d62e5SAmir Goldstein return err; 1085146d62e5SAmir Goldstein } 1086146d62e5SAmir Goldstein 1087146d62e5SAmir Goldstein *ptrap = trap; 1088146d62e5SAmir Goldstein return 0; 1089146d62e5SAmir Goldstein } 1090146d62e5SAmir Goldstein 10910be0bfd2SAmir Goldstein /* 10920be0bfd2SAmir Goldstein * Determine how we treat concurrent use of upperdir/workdir based on the 10930be0bfd2SAmir Goldstein * index feature. This is papering over mount leaks of container runtimes, 10940be0bfd2SAmir Goldstein * for example, an old overlay mount is leaked and now its upperdir is 10950be0bfd2SAmir Goldstein * attempted to be used as a lower layer in a new overlay mount. 10960be0bfd2SAmir Goldstein */ 10970be0bfd2SAmir Goldstein static int ovl_report_in_use(struct ovl_fs *ofs, const char *name) 10980be0bfd2SAmir Goldstein { 10990be0bfd2SAmir Goldstein if (ofs->config.index) { 11001bd0a3aeSlijiazi pr_err("%s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n", 11010be0bfd2SAmir Goldstein name); 11020be0bfd2SAmir Goldstein return -EBUSY; 11030be0bfd2SAmir Goldstein } else { 11041bd0a3aeSlijiazi pr_warn("%s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n", 11050be0bfd2SAmir Goldstein name); 11060be0bfd2SAmir Goldstein return 0; 11070be0bfd2SAmir Goldstein } 11080be0bfd2SAmir Goldstein } 11090be0bfd2SAmir Goldstein 1110146d62e5SAmir Goldstein static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs, 1111b8e42a65SMiklos Szeredi struct ovl_layer *upper_layer, struct path *upperpath) 11126ee8acf0SMiklos Szeredi { 11135064975eSMiklos Szeredi struct vfsmount *upper_mnt; 11146ee8acf0SMiklos Szeredi int err; 11156ee8acf0SMiklos Szeredi 1116ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.upperdir, upperpath); 11176ee8acf0SMiklos Szeredi if (err) 11186ee8acf0SMiklos Szeredi goto out; 11196ee8acf0SMiklos Szeredi 1120e21a6c57SAmir Goldstein /* Upperdir path should not be r/o */ 1121e21a6c57SAmir Goldstein if (__mnt_is_readonly(upperpath->mnt)) { 11221bd0a3aeSlijiazi pr_err("upper fs is r/o, try multi-lower layers mount\n"); 11236ee8acf0SMiklos Szeredi err = -EINVAL; 11246ee8acf0SMiklos Szeredi goto out; 11256ee8acf0SMiklos Szeredi } 11266ee8acf0SMiklos Szeredi 1127ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 11286ee8acf0SMiklos Szeredi if (err) 11296ee8acf0SMiklos Szeredi goto out; 11306ee8acf0SMiklos Szeredi 1131b8e42a65SMiklos Szeredi err = ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap, 1132146d62e5SAmir Goldstein "upperdir"); 1133146d62e5SAmir Goldstein if (err) 1134146d62e5SAmir Goldstein goto out; 1135146d62e5SAmir Goldstein 11365064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 11375064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 11385064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 11391bd0a3aeSlijiazi pr_err("failed to clone upperpath\n"); 11405064975eSMiklos Szeredi goto out; 11415064975eSMiklos Szeredi } 11425064975eSMiklos Szeredi 11435064975eSMiklos Szeredi /* Don't inherit atime flags */ 11445064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 1145b8e42a65SMiklos Szeredi upper_layer->mnt = upper_mnt; 1146b8e42a65SMiklos Szeredi upper_layer->idx = 0; 1147b8e42a65SMiklos Szeredi upper_layer->fsid = 0; 11488c25741aSMiklos Szeredi 1149654255faSJeffle Xu /* 1150654255faSJeffle Xu * Inherit SB_NOSEC flag from upperdir. 1151654255faSJeffle Xu * 1152654255faSJeffle Xu * This optimization changes behavior when a security related attribute 1153654255faSJeffle Xu * (suid/sgid/security.*) is changed on an underlying layer. This is 1154654255faSJeffle Xu * okay because we don't yet have guarantees in that case, but it will 1155654255faSJeffle Xu * need careful treatment once we want to honour changes to underlying 1156654255faSJeffle Xu * filesystems. 1157654255faSJeffle Xu */ 1158654255faSJeffle Xu if (upper_mnt->mnt_sb->s_flags & SB_NOSEC) 1159654255faSJeffle Xu sb->s_flags |= SB_NOSEC; 1160654255faSJeffle Xu 116108f4c7c8SMiklos Szeredi if (ovl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) { 11628c25741aSMiklos Szeredi ofs->upperdir_locked = true; 11638c25741aSMiklos Szeredi } else { 11640be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "upperdir"); 11650be0bfd2SAmir Goldstein if (err) 11660be0bfd2SAmir Goldstein goto out; 11678c25741aSMiklos Szeredi } 11688c25741aSMiklos Szeredi 11696ee8acf0SMiklos Szeredi err = 0; 11706ee8acf0SMiklos Szeredi out: 11716ee8acf0SMiklos Szeredi return err; 11726ee8acf0SMiklos Szeredi } 11736ee8acf0SMiklos Szeredi 1174cad218abSAmir Goldstein /* 1175cad218abSAmir Goldstein * Returns 1 if RENAME_WHITEOUT is supported, 0 if not supported and 1176cad218abSAmir Goldstein * negative values if error is encountered. 1177cad218abSAmir Goldstein */ 1178576bb263SChristian Brauner static int ovl_check_rename_whiteout(struct ovl_fs *ofs) 1179cad218abSAmir Goldstein { 1180576bb263SChristian Brauner struct dentry *workdir = ofs->workdir; 1181cad218abSAmir Goldstein struct inode *dir = d_inode(workdir); 1182cad218abSAmir Goldstein struct dentry *temp; 1183cad218abSAmir Goldstein struct dentry *dest; 1184cad218abSAmir Goldstein struct dentry *whiteout; 1185cad218abSAmir Goldstein struct name_snapshot name; 1186cad218abSAmir Goldstein int err; 1187cad218abSAmir Goldstein 1188cad218abSAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 1189cad218abSAmir Goldstein 1190576bb263SChristian Brauner temp = ovl_create_temp(ofs, workdir, OVL_CATTR(S_IFREG | 0)); 1191cad218abSAmir Goldstein err = PTR_ERR(temp); 1192cad218abSAmir Goldstein if (IS_ERR(temp)) 1193cad218abSAmir Goldstein goto out_unlock; 1194cad218abSAmir Goldstein 1195576bb263SChristian Brauner dest = ovl_lookup_temp(ofs, workdir); 1196cad218abSAmir Goldstein err = PTR_ERR(dest); 1197cad218abSAmir Goldstein if (IS_ERR(dest)) { 1198cad218abSAmir Goldstein dput(temp); 1199cad218abSAmir Goldstein goto out_unlock; 1200cad218abSAmir Goldstein } 1201cad218abSAmir Goldstein 1202cad218abSAmir Goldstein /* Name is inline and stable - using snapshot as a copy helper */ 1203cad218abSAmir Goldstein take_dentry_name_snapshot(&name, temp); 1204576bb263SChristian Brauner err = ovl_do_rename(ofs, dir, temp, dir, dest, RENAME_WHITEOUT); 1205cad218abSAmir Goldstein if (err) { 1206cad218abSAmir Goldstein if (err == -EINVAL) 1207cad218abSAmir Goldstein err = 0; 1208cad218abSAmir Goldstein goto cleanup_temp; 1209cad218abSAmir Goldstein } 1210cad218abSAmir Goldstein 121122f289ceSChristian Brauner whiteout = ovl_lookup_upper(ofs, name.name.name, workdir, name.name.len); 1212cad218abSAmir Goldstein err = PTR_ERR(whiteout); 1213cad218abSAmir Goldstein if (IS_ERR(whiteout)) 1214cad218abSAmir Goldstein goto cleanup_temp; 1215cad218abSAmir Goldstein 1216cad218abSAmir Goldstein err = ovl_is_whiteout(whiteout); 1217cad218abSAmir Goldstein 1218cad218abSAmir Goldstein /* Best effort cleanup of whiteout and temp file */ 1219cad218abSAmir Goldstein if (err) 1220576bb263SChristian Brauner ovl_cleanup(ofs, dir, whiteout); 1221cad218abSAmir Goldstein dput(whiteout); 1222cad218abSAmir Goldstein 1223cad218abSAmir Goldstein cleanup_temp: 1224576bb263SChristian Brauner ovl_cleanup(ofs, dir, temp); 1225cad218abSAmir Goldstein release_dentry_name_snapshot(&name); 1226cad218abSAmir Goldstein dput(temp); 1227cad218abSAmir Goldstein dput(dest); 1228cad218abSAmir Goldstein 1229cad218abSAmir Goldstein out_unlock: 1230cad218abSAmir Goldstein inode_unlock(dir); 1231cad218abSAmir Goldstein 1232cad218abSAmir Goldstein return err; 1233cad218abSAmir Goldstein } 1234cad218abSAmir Goldstein 1235576bb263SChristian Brauner static struct dentry *ovl_lookup_or_create(struct ovl_fs *ofs, 1236576bb263SChristian Brauner struct dentry *parent, 1237c86243b0SVivek Goyal const char *name, umode_t mode) 1238c86243b0SVivek Goyal { 1239c86243b0SVivek Goyal size_t len = strlen(name); 1240c86243b0SVivek Goyal struct dentry *child; 1241c86243b0SVivek Goyal 1242c86243b0SVivek Goyal inode_lock_nested(parent->d_inode, I_MUTEX_PARENT); 124322f289ceSChristian Brauner child = ovl_lookup_upper(ofs, name, parent, len); 1244c86243b0SVivek Goyal if (!IS_ERR(child) && !child->d_inode) 1245576bb263SChristian Brauner child = ovl_create_real(ofs, parent->d_inode, child, 1246c86243b0SVivek Goyal OVL_CATTR(mode)); 1247c86243b0SVivek Goyal inode_unlock(parent->d_inode); 1248c86243b0SVivek Goyal dput(parent); 1249c86243b0SVivek Goyal 1250c86243b0SVivek Goyal return child; 1251c86243b0SVivek Goyal } 1252c86243b0SVivek Goyal 1253c86243b0SVivek Goyal /* 1254c86243b0SVivek Goyal * Creates $workdir/work/incompat/volatile/dirty file if it is not already 1255c86243b0SVivek Goyal * present. 1256c86243b0SVivek Goyal */ 1257c86243b0SVivek Goyal static int ovl_create_volatile_dirty(struct ovl_fs *ofs) 1258c86243b0SVivek Goyal { 1259c86243b0SVivek Goyal unsigned int ctr; 1260c86243b0SVivek Goyal struct dentry *d = dget(ofs->workbasedir); 1261c86243b0SVivek Goyal static const char *const volatile_path[] = { 1262c86243b0SVivek Goyal OVL_WORKDIR_NAME, "incompat", "volatile", "dirty" 1263c86243b0SVivek Goyal }; 1264c86243b0SVivek Goyal const char *const *name = volatile_path; 1265c86243b0SVivek Goyal 1266c86243b0SVivek Goyal for (ctr = ARRAY_SIZE(volatile_path); ctr; ctr--, name++) { 1267576bb263SChristian Brauner d = ovl_lookup_or_create(ofs, d, *name, ctr > 1 ? S_IFDIR : S_IFREG); 1268c86243b0SVivek Goyal if (IS_ERR(d)) 1269c86243b0SVivek Goyal return PTR_ERR(d); 1270c86243b0SVivek Goyal } 1271c86243b0SVivek Goyal dput(d); 1272c86243b0SVivek Goyal return 0; 1273c86243b0SVivek Goyal } 1274c86243b0SVivek Goyal 1275146d62e5SAmir Goldstein static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs, 12762d343087SAl Viro const struct path *workpath) 12778ed61dc3SMiklos Szeredi { 127808f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 12792b1a7746SMiklos Szeredi struct dentry *workdir; 12802b1a7746SMiklos Szeredi struct file *tmpfile; 1281d80172c2SAmir Goldstein bool rename_whiteout; 1282d80172c2SAmir Goldstein bool d_type; 1283e487d889SAmir Goldstein int fh_type; 12848ed61dc3SMiklos Szeredi int err; 12858ed61dc3SMiklos Szeredi 12862ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 12872ba9d57eSAmir Goldstein if (err) 12882ba9d57eSAmir Goldstein return err; 12892ba9d57eSAmir Goldstein 1290235ce9edSAmir Goldstein workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 1291235ce9edSAmir Goldstein err = PTR_ERR(workdir); 1292235ce9edSAmir Goldstein if (IS_ERR_OR_NULL(workdir)) 12932ba9d57eSAmir Goldstein goto out; 12948ed61dc3SMiklos Szeredi 1295235ce9edSAmir Goldstein ofs->workdir = workdir; 1296235ce9edSAmir Goldstein 1297146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir"); 1298146d62e5SAmir Goldstein if (err) 1299146d62e5SAmir Goldstein goto out; 1300146d62e5SAmir Goldstein 13018ed61dc3SMiklos Szeredi /* 13028ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 13038ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 13048ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 13058ed61dc3SMiklos Szeredi * previous step. 13068ed61dc3SMiklos Szeredi */ 13078ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 13088ed61dc3SMiklos Szeredi if (err < 0) 13092ba9d57eSAmir Goldstein goto out; 13108ed61dc3SMiklos Szeredi 1311d80172c2SAmir Goldstein d_type = err; 1312d80172c2SAmir Goldstein if (!d_type) 13131bd0a3aeSlijiazi pr_warn("upper fs needs to support d_type.\n"); 13148ed61dc3SMiklos Szeredi 13158ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 13162b1a7746SMiklos Szeredi tmpfile = ovl_do_tmpfile(ofs, ofs->workdir, S_IFREG | 0); 13172b1a7746SMiklos Szeredi ofs->tmpfile = !IS_ERR(tmpfile); 1318ad204488SMiklos Szeredi if (ofs->tmpfile) 13192b1a7746SMiklos Szeredi fput(tmpfile); 13208ed61dc3SMiklos Szeredi else 13211bd0a3aeSlijiazi pr_warn("upper fs does not support tmpfile.\n"); 13228ed61dc3SMiklos Szeredi 1323cad218abSAmir Goldstein 1324cad218abSAmir Goldstein /* Check if upper/work fs supports RENAME_WHITEOUT */ 1325576bb263SChristian Brauner err = ovl_check_rename_whiteout(ofs); 1326cad218abSAmir Goldstein if (err < 0) 1327cad218abSAmir Goldstein goto out; 1328cad218abSAmir Goldstein 1329d80172c2SAmir Goldstein rename_whiteout = err; 1330d80172c2SAmir Goldstein if (!rename_whiteout) 1331cad218abSAmir Goldstein pr_warn("upper fs does not support RENAME_WHITEOUT.\n"); 1332cad218abSAmir Goldstein 13338ed61dc3SMiklos Szeredi /* 13342d2f2d73SMiklos Szeredi * Check if upper/work fs supports (trusted|user).overlay.* xattr 13358ed61dc3SMiklos Szeredi */ 1336c914c0e2SAmir Goldstein err = ovl_setxattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE, "0", 1); 13378ed61dc3SMiklos Szeredi if (err) { 1338b10b85feSMiklos Szeredi pr_warn("failed to set xattr on upper\n"); 1339ad204488SMiklos Szeredi ofs->noxattr = true; 1340*af5f2396SAmir Goldstein if (ovl_redirect_follow(ofs)) { 1341*af5f2396SAmir Goldstein ofs->config.redirect_mode = OVL_REDIRECT_NOFOLLOW; 1342*af5f2396SAmir Goldstein pr_warn("...falling back to redirect_dir=nofollow.\n"); 1343*af5f2396SAmir Goldstein } 1344*af5f2396SAmir Goldstein if (ofs->config.metacopy) { 1345d5791044SVivek Goyal ofs->config.metacopy = false; 1346*af5f2396SAmir Goldstein pr_warn("...falling back to metacopy=off.\n"); 1347*af5f2396SAmir Goldstein } 1348*af5f2396SAmir Goldstein if (ofs->config.index) { 1349*af5f2396SAmir Goldstein ofs->config.index = false; 1350*af5f2396SAmir Goldstein pr_warn("...falling back to index=off.\n"); 1351b0e0f697SAmir Goldstein } 1352b0e0f697SAmir Goldstein /* 1353b0e0f697SAmir Goldstein * xattr support is required for persistent st_ino. 1354b0e0f697SAmir Goldstein * Without persistent st_ino, xino=auto falls back to xino=off. 1355b0e0f697SAmir Goldstein */ 1356b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO) { 1357b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 1358b10b85feSMiklos Szeredi pr_warn("...falling back to xino=off.\n"); 1359b0e0f697SAmir Goldstein } 1360b10b85feSMiklos Szeredi if (err == -EPERM && !ofs->config.userxattr) 1361b10b85feSMiklos Szeredi pr_info("try mounting with 'userxattr' option\n"); 13622ba9d57eSAmir Goldstein err = 0; 13638ed61dc3SMiklos Szeredi } else { 1364c914c0e2SAmir Goldstein ovl_removexattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE); 13658ed61dc3SMiklos Szeredi } 13668ed61dc3SMiklos Szeredi 1367d80172c2SAmir Goldstein /* 1368d80172c2SAmir Goldstein * We allowed sub-optimal upper fs configuration and don't want to break 1369d80172c2SAmir Goldstein * users over kernel upgrade, but we never allowed remote upper fs, so 1370d80172c2SAmir Goldstein * we can enforce strict requirements for remote upper fs. 1371d80172c2SAmir Goldstein */ 1372d80172c2SAmir Goldstein if (ovl_dentry_remote(ofs->workdir) && 1373d80172c2SAmir Goldstein (!d_type || !rename_whiteout || ofs->noxattr)) { 1374d80172c2SAmir Goldstein pr_err("upper fs missing required features.\n"); 1375d80172c2SAmir Goldstein err = -EINVAL; 1376d80172c2SAmir Goldstein goto out; 1377d80172c2SAmir Goldstein } 1378d80172c2SAmir Goldstein 1379c86243b0SVivek Goyal /* 1380c86243b0SVivek Goyal * For volatile mount, create a incompat/volatile/dirty file to keep 1381c86243b0SVivek Goyal * track of it. 1382c86243b0SVivek Goyal */ 1383c86243b0SVivek Goyal if (ofs->config.ovl_volatile) { 1384c86243b0SVivek Goyal err = ovl_create_volatile_dirty(ofs); 1385c86243b0SVivek Goyal if (err < 0) { 1386c86243b0SVivek Goyal pr_err("Failed to create volatile/dirty file.\n"); 1387c86243b0SVivek Goyal goto out; 1388c86243b0SVivek Goyal } 1389c86243b0SVivek Goyal } 1390c86243b0SVivek Goyal 13918ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 1392e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 1393e487d889SAmir Goldstein if (ofs->config.index && !fh_type) { 1394ad204488SMiklos Szeredi ofs->config.index = false; 13951bd0a3aeSlijiazi pr_warn("upper fs does not support file handles, falling back to index=off.\n"); 13968ed61dc3SMiklos Szeredi } 13978ed61dc3SMiklos Szeredi 1398e487d889SAmir Goldstein /* Check if upper fs has 32bit inode numbers */ 1399e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 14000f831ec8SAmir Goldstein ofs->xino_mode = -1; 1401e487d889SAmir Goldstein 1402f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */ 1403f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) { 14041bd0a3aeSlijiazi pr_warn("NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 1405f168f109SAmir Goldstein ofs->config.nfs_export = false; 1406f168f109SAmir Goldstein } 14072ba9d57eSAmir Goldstein out: 14082ba9d57eSAmir Goldstein mnt_drop_write(mnt); 14092ba9d57eSAmir Goldstein return err; 14108ed61dc3SMiklos Szeredi } 14118ed61dc3SMiklos Szeredi 1412146d62e5SAmir Goldstein static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs, 14132d343087SAl Viro const struct path *upperpath) 1414520d7c86SMiklos Szeredi { 1415520d7c86SMiklos Szeredi int err; 1416bca44b52SMiklos Szeredi struct path workpath = { }; 1417520d7c86SMiklos Szeredi 1418ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.workdir, &workpath); 1419520d7c86SMiklos Szeredi if (err) 1420520d7c86SMiklos Szeredi goto out; 1421520d7c86SMiklos Szeredi 1422520d7c86SMiklos Szeredi err = -EINVAL; 1423bca44b52SMiklos Szeredi if (upperpath->mnt != workpath.mnt) { 14241bd0a3aeSlijiazi pr_err("workdir and upperdir must reside under the same mount\n"); 1425520d7c86SMiklos Szeredi goto out; 1426520d7c86SMiklos Szeredi } 1427bca44b52SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 14281bd0a3aeSlijiazi pr_err("workdir and upperdir must be separate subtrees\n"); 1429520d7c86SMiklos Szeredi goto out; 1430520d7c86SMiklos Szeredi } 1431520d7c86SMiklos Szeredi 14328c25741aSMiklos Szeredi ofs->workbasedir = dget(workpath.dentry); 14338c25741aSMiklos Szeredi 14348c25741aSMiklos Szeredi if (ovl_inuse_trylock(ofs->workbasedir)) { 1435ad204488SMiklos Szeredi ofs->workdir_locked = true; 1436520d7c86SMiklos Szeredi } else { 14370be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "workdir"); 14380be0bfd2SAmir Goldstein if (err) 14390be0bfd2SAmir Goldstein goto out; 1440520d7c86SMiklos Szeredi } 1441520d7c86SMiklos Szeredi 14420be0bfd2SAmir Goldstein err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap, 14430be0bfd2SAmir Goldstein "workdir"); 14440be0bfd2SAmir Goldstein if (err) 14450be0bfd2SAmir Goldstein goto out; 14460be0bfd2SAmir Goldstein 1447146d62e5SAmir Goldstein err = ovl_make_workdir(sb, ofs, &workpath); 1448bca44b52SMiklos Szeredi 1449520d7c86SMiklos Szeredi out: 1450bca44b52SMiklos Szeredi path_put(&workpath); 1451bca44b52SMiklos Szeredi 1452520d7c86SMiklos Szeredi return err; 1453520d7c86SMiklos Szeredi } 1454520d7c86SMiklos Szeredi 1455146d62e5SAmir Goldstein static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs, 14562d343087SAl Viro struct ovl_entry *oe, const struct path *upperpath) 1457f7e3a7d9SMiklos Szeredi { 145808f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 1459235ce9edSAmir Goldstein struct dentry *indexdir; 1460f7e3a7d9SMiklos Szeredi int err; 1461f7e3a7d9SMiklos Szeredi 14622ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 14632ba9d57eSAmir Goldstein if (err) 14642ba9d57eSAmir Goldstein return err; 14652ba9d57eSAmir Goldstein 1466f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 1467610afc0bSMiklos Szeredi err = ovl_verify_origin(ofs, upperpath->dentry, 14685522c9c7SAmir Goldstein ovl_lowerstack(oe)->dentry, true); 1469f7e3a7d9SMiklos Szeredi if (err) { 14701bd0a3aeSlijiazi pr_err("failed to verify upper root origin\n"); 1471f7e3a7d9SMiklos Szeredi goto out; 1472f7e3a7d9SMiklos Szeredi } 1473f7e3a7d9SMiklos Szeredi 147420396365SAmir Goldstein /* index dir will act also as workdir */ 147520396365SAmir Goldstein iput(ofs->workdir_trap); 147620396365SAmir Goldstein ofs->workdir_trap = NULL; 147720396365SAmir Goldstein dput(ofs->workdir); 1478470c1563SAmir Goldstein ofs->workdir = NULL; 1479235ce9edSAmir Goldstein indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1480235ce9edSAmir Goldstein if (IS_ERR(indexdir)) { 1481235ce9edSAmir Goldstein err = PTR_ERR(indexdir); 1482235ce9edSAmir Goldstein } else if (indexdir) { 1483235ce9edSAmir Goldstein ofs->indexdir = indexdir; 1484235ce9edSAmir Goldstein ofs->workdir = dget(indexdir); 148520396365SAmir Goldstein 1486146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap, 1487146d62e5SAmir Goldstein "indexdir"); 1488146d62e5SAmir Goldstein if (err) 1489146d62e5SAmir Goldstein goto out; 1490146d62e5SAmir Goldstein 1491ad1d615cSAmir Goldstein /* 1492ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir. 14932d2f2d73SMiklos Szeredi * Older kernels stored upper fh in ".overlay.origin" 1494ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to 1495ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr 14962d2f2d73SMiklos Szeredi * ".overlay.upper" to indicate that index may have 1497ad1d615cSAmir Goldstein * directory entries. 1498ad1d615cSAmir Goldstein */ 1499610afc0bSMiklos Szeredi if (ovl_check_origin_xattr(ofs, ofs->indexdir)) { 1500610afc0bSMiklos Szeredi err = ovl_verify_set_fh(ofs, ofs->indexdir, 1501610afc0bSMiklos Szeredi OVL_XATTR_ORIGIN, 1502ad1d615cSAmir Goldstein upperpath->dentry, true, false); 1503f7e3a7d9SMiklos Szeredi if (err) 15041bd0a3aeSlijiazi pr_err("failed to verify index dir 'origin' xattr\n"); 1505ad1d615cSAmir Goldstein } 1506610afc0bSMiklos Szeredi err = ovl_verify_upper(ofs, ofs->indexdir, upperpath->dentry, 1507610afc0bSMiklos Szeredi true); 1508ad1d615cSAmir Goldstein if (err) 15091bd0a3aeSlijiazi pr_err("failed to verify index dir 'upper' xattr\n"); 1510f7e3a7d9SMiklos Szeredi 1511f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 1512f7e3a7d9SMiklos Szeredi if (!err) 15131eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs); 1514f7e3a7d9SMiklos Szeredi } 1515ad204488SMiklos Szeredi if (err || !ofs->indexdir) 15161bd0a3aeSlijiazi pr_warn("try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1517f7e3a7d9SMiklos Szeredi 1518f7e3a7d9SMiklos Szeredi out: 15192ba9d57eSAmir Goldstein mnt_drop_write(mnt); 1520f7e3a7d9SMiklos Szeredi return err; 1521f7e3a7d9SMiklos Szeredi } 1522f7e3a7d9SMiklos Szeredi 15239df085f3SAmir Goldstein static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid) 15245148626bSAmir Goldstein { 15255148626bSAmir Goldstein unsigned int i; 15269df085f3SAmir Goldstein 152708f4c7c8SMiklos Szeredi if (!ofs->config.nfs_export && !ovl_upper_mnt(ofs)) 15289df085f3SAmir Goldstein return true; 15299df085f3SAmir Goldstein 1530a888db31SAmir Goldstein /* 1531a888db31SAmir Goldstein * We allow using single lower with null uuid for index and nfs_export 1532a888db31SAmir Goldstein * for example to support those features with single lower squashfs. 1533a888db31SAmir Goldstein * To avoid regressions in setups of overlay with re-formatted lower 1534a888db31SAmir Goldstein * squashfs, do not allow decoding origin with lower null uuid unless 1535a888db31SAmir Goldstein * user opted-in to one of the new features that require following the 1536a888db31SAmir Goldstein * lower inode of non-dir upper. 1537a888db31SAmir Goldstein */ 1538ca45275cSVyacheslav Yurkov if (ovl_allow_offline_changes(ofs) && uuid_is_null(uuid)) 1539a888db31SAmir Goldstein return false; 1540a888db31SAmir Goldstein 15411b81ddddSAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 15429df085f3SAmir Goldstein /* 15439df085f3SAmir Goldstein * We use uuid to associate an overlay lower file handle with a 15449df085f3SAmir Goldstein * lower layer, so we can accept lower fs with null uuid as long 15459df085f3SAmir Goldstein * as all lower layers with null uuid are on the same fs. 15467e63c87fSAmir Goldstein * if we detect multiple lower fs with the same uuid, we 15477e63c87fSAmir Goldstein * disable lower file handle decoding on all of them. 15489df085f3SAmir Goldstein */ 15491b81ddddSAmir Goldstein if (ofs->fs[i].is_lower && 15501b81ddddSAmir Goldstein uuid_equal(&ofs->fs[i].sb->s_uuid, uuid)) { 155107f1e596SAmir Goldstein ofs->fs[i].bad_uuid = true; 15529df085f3SAmir Goldstein return false; 15539df085f3SAmir Goldstein } 15547e63c87fSAmir Goldstein } 15559df085f3SAmir Goldstein return true; 15569df085f3SAmir Goldstein } 15579df085f3SAmir Goldstein 15589df085f3SAmir Goldstein /* Get a unique fsid for the layer */ 15599df085f3SAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) 15609df085f3SAmir Goldstein { 15619df085f3SAmir Goldstein struct super_block *sb = path->mnt->mnt_sb; 15629df085f3SAmir Goldstein unsigned int i; 15635148626bSAmir Goldstein dev_t dev; 15645148626bSAmir Goldstein int err; 15657e63c87fSAmir Goldstein bool bad_uuid = false; 1566b0e0f697SAmir Goldstein bool warn = false; 15675148626bSAmir Goldstein 156807f1e596SAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 156907f1e596SAmir Goldstein if (ofs->fs[i].sb == sb) 157007f1e596SAmir Goldstein return i; 15715148626bSAmir Goldstein } 15725148626bSAmir Goldstein 15739df085f3SAmir Goldstein if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) { 15747e63c87fSAmir Goldstein bad_uuid = true; 1575b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO) { 1576b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 1577b0e0f697SAmir Goldstein warn = true; 1578b0e0f697SAmir Goldstein } 15797e63c87fSAmir Goldstein if (ofs->config.index || ofs->config.nfs_export) { 15809df085f3SAmir Goldstein ofs->config.index = false; 15819df085f3SAmir Goldstein ofs->config.nfs_export = false; 1582b0e0f697SAmir Goldstein warn = true; 1583b0e0f697SAmir Goldstein } 1584b0e0f697SAmir Goldstein if (warn) { 1585b0e0f697SAmir Goldstein pr_warn("%s uuid detected in lower fs '%pd2', falling back to xino=%s,index=off,nfs_export=off.\n", 15867e63c87fSAmir Goldstein uuid_is_null(&sb->s_uuid) ? "null" : 15877e63c87fSAmir Goldstein "conflicting", 1588dcb399deSAmir Goldstein path->dentry, ovl_xino_mode(&ofs->config)); 15899df085f3SAmir Goldstein } 15907e63c87fSAmir Goldstein } 15919df085f3SAmir Goldstein 15925148626bSAmir Goldstein err = get_anon_bdev(&dev); 15935148626bSAmir Goldstein if (err) { 15941bd0a3aeSlijiazi pr_err("failed to get anonymous bdev for lowerpath\n"); 15955148626bSAmir Goldstein return err; 15965148626bSAmir Goldstein } 15975148626bSAmir Goldstein 159807f1e596SAmir Goldstein ofs->fs[ofs->numfs].sb = sb; 159907f1e596SAmir Goldstein ofs->fs[ofs->numfs].pseudo_dev = dev; 160007f1e596SAmir Goldstein ofs->fs[ofs->numfs].bad_uuid = bad_uuid; 16015148626bSAmir Goldstein 160207f1e596SAmir Goldstein return ofs->numfs++; 16035148626bSAmir Goldstein } 16045148626bSAmir Goldstein 160537ebf056SAmir Goldstein /* 160637ebf056SAmir Goldstein * The fsid after the last lower fsid is used for the data layers. 160737ebf056SAmir Goldstein * It is a "null fs" with a null sb, null uuid, and no pseudo dev. 160837ebf056SAmir Goldstein */ 160937ebf056SAmir Goldstein static int ovl_get_data_fsid(struct ovl_fs *ofs) 161037ebf056SAmir Goldstein { 161137ebf056SAmir Goldstein return ofs->numfs; 161237ebf056SAmir Goldstein } 161337ebf056SAmir Goldstein 161437ebf056SAmir Goldstein 161594375f9dSAmir Goldstein static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, 1616b8e42a65SMiklos Szeredi struct path *stack, unsigned int numlower, 1617b8e42a65SMiklos Szeredi struct ovl_layer *layers) 1618520d7c86SMiklos Szeredi { 1619520d7c86SMiklos Szeredi int err; 1620520d7c86SMiklos Szeredi unsigned int i; 1621520d7c86SMiklos Szeredi 162237ebf056SAmir Goldstein ofs->fs = kcalloc(numlower + 2, sizeof(struct ovl_sb), GFP_KERNEL); 162307f1e596SAmir Goldstein if (ofs->fs == NULL) 16249e88f905SAmir Goldstein return -ENOMEM; 16255148626bSAmir Goldstein 162637ebf056SAmir Goldstein /* 162737ebf056SAmir Goldstein * idx/fsid 0 are reserved for upper fs even with lower only overlay 162837ebf056SAmir Goldstein * and the last fsid is reserved for "null fs" of the data layers. 162937ebf056SAmir Goldstein */ 163007f1e596SAmir Goldstein ofs->numfs++; 163107f1e596SAmir Goldstein 163207f1e596SAmir Goldstein /* 1633b7bf9908SAmir Goldstein * All lower layers that share the same fs as upper layer, use the same 1634b7bf9908SAmir Goldstein * pseudo_dev as upper layer. Allocate fs[0].pseudo_dev even for lower 1635b7bf9908SAmir Goldstein * only overlay to simplify ovl_fs_free(). 16361b81ddddSAmir Goldstein * is_lower will be set if upper fs is shared with a lower layer. 163707f1e596SAmir Goldstein */ 1638b7bf9908SAmir Goldstein err = get_anon_bdev(&ofs->fs[0].pseudo_dev); 1639b7bf9908SAmir Goldstein if (err) { 1640b7bf9908SAmir Goldstein pr_err("failed to get anonymous bdev for upper fs\n"); 16419e88f905SAmir Goldstein return err; 1642b7bf9908SAmir Goldstein } 1643b7bf9908SAmir Goldstein 164408f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 164508f4c7c8SMiklos Szeredi ofs->fs[0].sb = ovl_upper_mnt(ofs)->mnt_sb; 16461b81ddddSAmir Goldstein ofs->fs[0].is_lower = false; 164707f1e596SAmir Goldstein } 164807f1e596SAmir Goldstein 1649520d7c86SMiklos Szeredi for (i = 0; i < numlower; i++) { 1650520d7c86SMiklos Szeredi struct vfsmount *mnt; 1651146d62e5SAmir Goldstein struct inode *trap; 16525148626bSAmir Goldstein int fsid; 1653520d7c86SMiklos Szeredi 165437ebf056SAmir Goldstein if (i < numlower - ofs->numdatalayer) 16559e88f905SAmir Goldstein fsid = ovl_get_fsid(ofs, &stack[i]); 165637ebf056SAmir Goldstein else 165737ebf056SAmir Goldstein fsid = ovl_get_data_fsid(ofs); 16589e88f905SAmir Goldstein if (fsid < 0) 16599e88f905SAmir Goldstein return fsid; 1660520d7c86SMiklos Szeredi 166124f14009Syoungjun /* 166224f14009Syoungjun * Check if lower root conflicts with this overlay layers before 166324f14009Syoungjun * checking if it is in-use as upperdir/workdir of "another" 166424f14009Syoungjun * mount, because we do not bother to check in ovl_is_inuse() if 166524f14009Syoungjun * the upperdir/workdir is in fact in-use by our 166624f14009Syoungjun * upperdir/workdir. 166724f14009Syoungjun */ 1668146d62e5SAmir Goldstein err = ovl_setup_trap(sb, stack[i].dentry, &trap, "lowerdir"); 1669146d62e5SAmir Goldstein if (err) 16709e88f905SAmir Goldstein return err; 1671146d62e5SAmir Goldstein 16720be0bfd2SAmir Goldstein if (ovl_is_inuse(stack[i].dentry)) { 16730be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "lowerdir"); 167424f14009Syoungjun if (err) { 167524f14009Syoungjun iput(trap); 16769e88f905SAmir Goldstein return err; 16770be0bfd2SAmir Goldstein } 167824f14009Syoungjun } 16790be0bfd2SAmir Goldstein 1680520d7c86SMiklos Szeredi mnt = clone_private_mount(&stack[i]); 1681520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1682520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 16831bd0a3aeSlijiazi pr_err("failed to clone lowerpath\n"); 1684146d62e5SAmir Goldstein iput(trap); 16859e88f905SAmir Goldstein return err; 1686520d7c86SMiklos Szeredi } 16875148626bSAmir Goldstein 1688520d7c86SMiklos Szeredi /* 1689520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1690520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1691520d7c86SMiklos Szeredi */ 1692520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1693520d7c86SMiklos Szeredi 169413464165SMiklos Szeredi layers[ofs->numlayer].trap = trap; 169513464165SMiklos Szeredi layers[ofs->numlayer].mnt = mnt; 169613464165SMiklos Szeredi layers[ofs->numlayer].idx = ofs->numlayer; 169713464165SMiklos Szeredi layers[ofs->numlayer].fsid = fsid; 169813464165SMiklos Szeredi layers[ofs->numlayer].fs = &ofs->fs[fsid]; 169994375f9dSAmir Goldstein ofs->numlayer++; 17001b81ddddSAmir Goldstein ofs->fs[fsid].is_lower = true; 1701520d7c86SMiklos Szeredi } 1702e487d889SAmir Goldstein 1703795939a9SAmir Goldstein /* 1704795939a9SAmir Goldstein * When all layers on same fs, overlay can use real inode numbers. 1705926e94d7SAmir Goldstein * With mount option "xino=<on|auto>", mounter declares that there are 1706926e94d7SAmir Goldstein * enough free high bits in underlying fs to hold the unique fsid. 1707795939a9SAmir Goldstein * If overlayfs does encounter underlying inodes using the high xino 1708795939a9SAmir Goldstein * bits reserved for fsid, it emits a warning and uses the original 1709dfe51d47SAmir Goldstein * inode number or a non persistent inode number allocated from a 1710dfe51d47SAmir Goldstein * dedicated range. 1711795939a9SAmir Goldstein */ 171208f4c7c8SMiklos Szeredi if (ofs->numfs - !ovl_upper_mnt(ofs) == 1) { 17130f831ec8SAmir Goldstein if (ofs->config.xino == OVL_XINO_ON) 17140f831ec8SAmir Goldstein pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n"); 17150f831ec8SAmir Goldstein ofs->xino_mode = 0; 171653afcd31SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_OFF) { 171753afcd31SAmir Goldstein ofs->xino_mode = -1; 1718926e94d7SAmir Goldstein } else if (ofs->xino_mode < 0) { 1719795939a9SAmir Goldstein /* 172007f1e596SAmir Goldstein * This is a roundup of number of bits needed for encoding 1721dfe51d47SAmir Goldstein * fsid, where fsid 0 is reserved for upper fs (even with 1722dfe51d47SAmir Goldstein * lower only overlay) +1 extra bit is reserved for the non 1723dfe51d47SAmir Goldstein * persistent inode number range that is used for resolving 1724dfe51d47SAmir Goldstein * xino lower bits overflow. 1725795939a9SAmir Goldstein */ 1726dfe51d47SAmir Goldstein BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 30); 1727dfe51d47SAmir Goldstein ofs->xino_mode = ilog2(ofs->numfs - 1) + 2; 1728795939a9SAmir Goldstein } 1729795939a9SAmir Goldstein 17300f831ec8SAmir Goldstein if (ofs->xino_mode > 0) { 17311bd0a3aeSlijiazi pr_info("\"xino\" feature enabled using %d upper inode bits.\n", 17320f831ec8SAmir Goldstein ofs->xino_mode); 1733795939a9SAmir Goldstein } 1734e487d889SAmir Goldstein 17359e88f905SAmir Goldstein return 0; 1736520d7c86SMiklos Szeredi } 1737520d7c86SMiklos Szeredi 17384155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1739b8e42a65SMiklos Szeredi const char *lower, unsigned int numlower, 1740b8e42a65SMiklos Szeredi struct ovl_fs *ofs, struct ovl_layer *layers) 174153dbb0b4SMiklos Szeredi { 174253dbb0b4SMiklos Szeredi int err; 17434155c10aSMiklos Szeredi struct path *stack = NULL; 17445522c9c7SAmir Goldstein struct ovl_path *lowerstack; 174537ebf056SAmir Goldstein unsigned int numlowerdata = 0; 1746b8e42a65SMiklos Szeredi unsigned int i; 17474155c10aSMiklos Szeredi struct ovl_entry *oe; 174853dbb0b4SMiklos Szeredi 1749b8e42a65SMiklos Szeredi if (!ofs->config.upperdir && numlower == 1) { 17501bd0a3aeSlijiazi pr_err("at least 2 lowerdir are needed while upperdir nonexistent\n"); 1751b8e42a65SMiklos Szeredi return ERR_PTR(-EINVAL); 175253dbb0b4SMiklos Szeredi } 175353dbb0b4SMiklos Szeredi 1754b8e42a65SMiklos Szeredi stack = kcalloc(numlower, sizeof(struct path), GFP_KERNEL); 175553dbb0b4SMiklos Szeredi if (!stack) 1756b8e42a65SMiklos Szeredi return ERR_PTR(-ENOMEM); 175753dbb0b4SMiklos Szeredi 175837ebf056SAmir Goldstein for (i = 0; i < numlower;) { 1759b8e42a65SMiklos Szeredi err = ovl_lower_dir(lower, &stack[i], ofs, &sb->s_stack_depth); 176053dbb0b4SMiklos Szeredi if (err) 17614155c10aSMiklos Szeredi goto out_err; 176253dbb0b4SMiklos Szeredi 176353dbb0b4SMiklos Szeredi lower = strchr(lower, '\0') + 1; 176437ebf056SAmir Goldstein 176537ebf056SAmir Goldstein i++; 176637ebf056SAmir Goldstein if (i == numlower) 176737ebf056SAmir Goldstein break; 176837ebf056SAmir Goldstein 176937ebf056SAmir Goldstein err = -EINVAL; 177037ebf056SAmir Goldstein /* 177137ebf056SAmir Goldstein * Empty lower layer path could mean :: separator that indicates 177237ebf056SAmir Goldstein * a data-only lower data. 177337ebf056SAmir Goldstein * Several data-only layers are allowed, but they all need to be 177437ebf056SAmir Goldstein * at the bottom of the stack. 177537ebf056SAmir Goldstein */ 177637ebf056SAmir Goldstein if (*lower) { 177737ebf056SAmir Goldstein /* normal lower dir */ 177837ebf056SAmir Goldstein if (numlowerdata) { 177937ebf056SAmir Goldstein pr_err("lower data-only dirs must be at the bottom of the stack.\n"); 178037ebf056SAmir Goldstein goto out_err; 178137ebf056SAmir Goldstein } 178237ebf056SAmir Goldstein } else { 178337ebf056SAmir Goldstein /* data-only lower dir */ 178437ebf056SAmir Goldstein if (!ofs->config.metacopy) { 178537ebf056SAmir Goldstein pr_err("lower data-only dirs require metacopy support.\n"); 178637ebf056SAmir Goldstein goto out_err; 178737ebf056SAmir Goldstein } 178837ebf056SAmir Goldstein if (i == numlower - 1) { 178937ebf056SAmir Goldstein pr_err("lowerdir argument must not end with double colon.\n"); 179037ebf056SAmir Goldstein goto out_err; 179137ebf056SAmir Goldstein } 179237ebf056SAmir Goldstein lower++; 179337ebf056SAmir Goldstein numlower--; 179437ebf056SAmir Goldstein numlowerdata++; 179537ebf056SAmir Goldstein } 179637ebf056SAmir Goldstein } 179737ebf056SAmir Goldstein 179837ebf056SAmir Goldstein if (numlowerdata) { 179937ebf056SAmir Goldstein ofs->numdatalayer = numlowerdata; 180037ebf056SAmir Goldstein pr_info("using the lowest %d of %d lowerdirs as data layers\n", 180137ebf056SAmir Goldstein numlowerdata, numlower); 180253dbb0b4SMiklos Szeredi } 180353dbb0b4SMiklos Szeredi 180453dbb0b4SMiklos Szeredi err = -EINVAL; 180553dbb0b4SMiklos Szeredi sb->s_stack_depth++; 180653dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 18071bd0a3aeSlijiazi pr_err("maximum fs stacking depth exceeded\n"); 18084155c10aSMiklos Szeredi goto out_err; 180953dbb0b4SMiklos Szeredi } 181053dbb0b4SMiklos Szeredi 1811b8e42a65SMiklos Szeredi err = ovl_get_layers(sb, ofs, stack, numlower, layers); 18124155c10aSMiklos Szeredi if (err) 18134155c10aSMiklos Szeredi goto out_err; 18144155c10aSMiklos Szeredi 18154155c10aSMiklos Szeredi err = -ENOMEM; 181637ebf056SAmir Goldstein /* Data-only layers are not merged in root directory */ 181737ebf056SAmir Goldstein oe = ovl_alloc_entry(numlower - numlowerdata); 18184155c10aSMiklos Szeredi if (!oe) 18194155c10aSMiklos Szeredi goto out_err; 18204155c10aSMiklos Szeredi 18215522c9c7SAmir Goldstein lowerstack = ovl_lowerstack(oe); 182237ebf056SAmir Goldstein for (i = 0; i < numlower - numlowerdata; i++) { 18235522c9c7SAmir Goldstein lowerstack[i].dentry = dget(stack[i].dentry); 18245522c9c7SAmir Goldstein lowerstack[i].layer = &ofs->layers[i+1]; 18254155c10aSMiklos Szeredi } 182653dbb0b4SMiklos Szeredi 182753dbb0b4SMiklos Szeredi out: 182853dbb0b4SMiklos Szeredi for (i = 0; i < numlower; i++) 182953dbb0b4SMiklos Szeredi path_put(&stack[i]); 183053dbb0b4SMiklos Szeredi kfree(stack); 18314155c10aSMiklos Szeredi 18324155c10aSMiklos Szeredi return oe; 18334155c10aSMiklos Szeredi 18344155c10aSMiklos Szeredi out_err: 18354155c10aSMiklos Szeredi oe = ERR_PTR(err); 183653dbb0b4SMiklos Szeredi goto out; 183753dbb0b4SMiklos Szeredi } 183853dbb0b4SMiklos Szeredi 1839146d62e5SAmir Goldstein /* 1840146d62e5SAmir Goldstein * Check if this layer root is a descendant of: 1841146d62e5SAmir Goldstein * - another layer of this overlayfs instance 1842146d62e5SAmir Goldstein * - upper/work dir of any overlayfs instance 1843146d62e5SAmir Goldstein */ 18440be0bfd2SAmir Goldstein static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs, 1845708fa015SMiklos Szeredi struct dentry *dentry, const char *name, 1846708fa015SMiklos Szeredi bool is_lower) 1847146d62e5SAmir Goldstein { 18489179c21dSMiklos Szeredi struct dentry *next = dentry, *parent; 1849146d62e5SAmir Goldstein int err = 0; 1850146d62e5SAmir Goldstein 18519179c21dSMiklos Szeredi if (!dentry) 1852146d62e5SAmir Goldstein return 0; 1853146d62e5SAmir Goldstein 1854146d62e5SAmir Goldstein parent = dget_parent(next); 18559179c21dSMiklos Szeredi 18569179c21dSMiklos Szeredi /* Walk back ancestors to root (inclusive) looking for traps */ 18579179c21dSMiklos Szeredi while (!err && parent != next) { 1858708fa015SMiklos Szeredi if (is_lower && ovl_lookup_trap_inode(sb, parent)) { 1859146d62e5SAmir Goldstein err = -ELOOP; 18601bd0a3aeSlijiazi pr_err("overlapping %s path\n", name); 18610be0bfd2SAmir Goldstein } else if (ovl_is_inuse(parent)) { 18620be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, name); 1863146d62e5SAmir Goldstein } 1864146d62e5SAmir Goldstein next = parent; 18659179c21dSMiklos Szeredi parent = dget_parent(next); 18669179c21dSMiklos Szeredi dput(next); 1867146d62e5SAmir Goldstein } 1868146d62e5SAmir Goldstein 18699179c21dSMiklos Szeredi dput(parent); 1870146d62e5SAmir Goldstein 1871146d62e5SAmir Goldstein return err; 1872146d62e5SAmir Goldstein } 1873146d62e5SAmir Goldstein 1874146d62e5SAmir Goldstein /* 1875146d62e5SAmir Goldstein * Check if any of the layers or work dirs overlap. 1876146d62e5SAmir Goldstein */ 1877146d62e5SAmir Goldstein static int ovl_check_overlapping_layers(struct super_block *sb, 1878146d62e5SAmir Goldstein struct ovl_fs *ofs) 1879146d62e5SAmir Goldstein { 1880146d62e5SAmir Goldstein int i, err; 1881146d62e5SAmir Goldstein 188208f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 188308f4c7c8SMiklos Szeredi err = ovl_check_layer(sb, ofs, ovl_upper_mnt(ofs)->mnt_root, 1884708fa015SMiklos Szeredi "upperdir", false); 1885146d62e5SAmir Goldstein if (err) 1886146d62e5SAmir Goldstein return err; 1887146d62e5SAmir Goldstein 1888146d62e5SAmir Goldstein /* 1889146d62e5SAmir Goldstein * Checking workbasedir avoids hitting ovl_is_inuse(parent) of 1890146d62e5SAmir Goldstein * this instance and covers overlapping work and index dirs, 1891146d62e5SAmir Goldstein * unless work or index dir have been moved since created inside 1892146d62e5SAmir Goldstein * workbasedir. In that case, we already have their traps in 1893146d62e5SAmir Goldstein * inode cache and we will catch that case on lookup. 1894146d62e5SAmir Goldstein */ 1895708fa015SMiklos Szeredi err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir", 1896708fa015SMiklos Szeredi false); 1897146d62e5SAmir Goldstein if (err) 1898146d62e5SAmir Goldstein return err; 1899146d62e5SAmir Goldstein } 1900146d62e5SAmir Goldstein 190194375f9dSAmir Goldstein for (i = 1; i < ofs->numlayer; i++) { 19020be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, 190394375f9dSAmir Goldstein ofs->layers[i].mnt->mnt_root, 1904708fa015SMiklos Szeredi "lowerdir", true); 1905146d62e5SAmir Goldstein if (err) 1906146d62e5SAmir Goldstein return err; 1907146d62e5SAmir Goldstein } 1908146d62e5SAmir Goldstein 1909146d62e5SAmir Goldstein return 0; 1910146d62e5SAmir Goldstein } 1911146d62e5SAmir Goldstein 19122effc5c2SAmir Goldstein static struct dentry *ovl_get_root(struct super_block *sb, 19132effc5c2SAmir Goldstein struct dentry *upperdentry, 19142effc5c2SAmir Goldstein struct ovl_entry *oe) 19152effc5c2SAmir Goldstein { 19162effc5c2SAmir Goldstein struct dentry *root; 19175522c9c7SAmir Goldstein struct ovl_path *lowerpath = ovl_lowerstack(oe); 191862c832edSAmir Goldstein unsigned long ino = d_inode(lowerpath->dentry)->i_ino; 191962c832edSAmir Goldstein int fsid = lowerpath->layer->fsid; 192062c832edSAmir Goldstein struct ovl_inode_params oip = { 192162c832edSAmir Goldstein .upperdentry = upperdentry, 19220af950f5SAmir Goldstein .oe = oe, 192362c832edSAmir Goldstein }; 19242effc5c2SAmir Goldstein 19252effc5c2SAmir Goldstein root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 19262effc5c2SAmir Goldstein if (!root) 19272effc5c2SAmir Goldstein return NULL; 19282effc5c2SAmir Goldstein 19292effc5c2SAmir Goldstein if (upperdentry) { 193062c832edSAmir Goldstein /* Root inode uses upper st_ino/i_ino */ 193162c832edSAmir Goldstein ino = d_inode(upperdentry)->i_ino; 193262c832edSAmir Goldstein fsid = 0; 19332effc5c2SAmir Goldstein ovl_dentry_set_upper_alias(root); 1934610afc0bSMiklos Szeredi if (ovl_is_impuredir(sb, upperdentry)) 19352effc5c2SAmir Goldstein ovl_set_flag(OVL_IMPURE, d_inode(root)); 19362effc5c2SAmir Goldstein } 19372effc5c2SAmir Goldstein 19382effc5c2SAmir Goldstein /* Root is always merge -> can have whiteouts */ 19392effc5c2SAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root)); 19402effc5c2SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root); 19412effc5c2SAmir Goldstein ovl_set_upperdata(d_inode(root)); 194262c832edSAmir Goldstein ovl_inode_init(d_inode(root), &oip, ino, fsid); 19430af950f5SAmir Goldstein ovl_dentry_init_flags(root, upperdentry, oe, DCACHE_OP_WEAK_REVALIDATE); 1944367d002dSAmir Goldstein /* root keeps a reference of upperdentry */ 1945367d002dSAmir Goldstein dget(upperdentry); 19462effc5c2SAmir Goldstein 19472effc5c2SAmir Goldstein return root; 19482effc5c2SAmir Goldstein } 19492effc5c2SAmir Goldstein 1950e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1951e9be9d5eSMiklos Szeredi { 195233006cdfSKees Cook struct path upperpath = { }; 1953e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 19544155c10aSMiklos Szeredi struct ovl_entry *oe; 1955ad204488SMiklos Szeredi struct ovl_fs *ofs; 1956b8e42a65SMiklos Szeredi struct ovl_layer *layers; 195751f8f3c4SKonstantin Khlebnikov struct cred *cred; 1958b8e42a65SMiklos Szeredi char *splitlower = NULL; 1959b8e42a65SMiklos Szeredi unsigned int numlower; 1960e9be9d5eSMiklos Szeredi int err; 1961e9be9d5eSMiklos Szeredi 19629efb069dSMiklos Szeredi err = -EIO; 19639efb069dSMiklos Szeredi if (WARN_ON(sb->s_user_ns != current_user_ns())) 19649efb069dSMiklos Szeredi goto out; 19659efb069dSMiklos Szeredi 1966f4288844SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 1967f4288844SMiklos Szeredi 1968f45827e8SErez Zadok err = -ENOMEM; 1969ad204488SMiklos Szeredi ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1970ad204488SMiklos Szeredi if (!ofs) 1971e9be9d5eSMiklos Szeredi goto out; 1972e9be9d5eSMiklos Szeredi 1973d7b49b10SChengguang Xu err = -ENOMEM; 1974ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1975c6fe6254SMiklos Szeredi if (!cred) 1976c6fe6254SMiklos Szeredi goto out_err; 1977c6fe6254SMiklos Szeredi 1978*af5f2396SAmir Goldstein ofs->config.redirect_mode = ovl_redirect_mode_def(); 1979ad204488SMiklos Szeredi ofs->config.index = ovl_index_def; 19805830fb6bSPavel Tikhomirov ofs->config.uuid = true; 1981f168f109SAmir Goldstein ofs->config.nfs_export = ovl_nfs_export_def; 1982795939a9SAmir Goldstein ofs->config.xino = ovl_xino_def(); 1983d5791044SVivek Goyal ofs->config.metacopy = ovl_metacopy_def; 1984ad204488SMiklos Szeredi err = ovl_parse_opt((char *) data, &ofs->config); 1985f45827e8SErez Zadok if (err) 1986a9075cdbSMiklos Szeredi goto out_err; 1987f45827e8SErez Zadok 1988e9be9d5eSMiklos Szeredi err = -EINVAL; 1989ad204488SMiklos Szeredi if (!ofs->config.lowerdir) { 199007f2af7bSKonstantin Khlebnikov if (!silent) 19911bd0a3aeSlijiazi pr_err("missing 'lowerdir'\n"); 1992a9075cdbSMiklos Szeredi goto out_err; 199353a08cb9SMiklos Szeredi } 199453a08cb9SMiklos Szeredi 1995b8e42a65SMiklos Szeredi err = -ENOMEM; 1996b8e42a65SMiklos Szeredi splitlower = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 1997b8e42a65SMiklos Szeredi if (!splitlower) 1998b8e42a65SMiklos Szeredi goto out_err; 1999b8e42a65SMiklos Szeredi 2000d7b49b10SChengguang Xu err = -EINVAL; 2001b8e42a65SMiklos Szeredi numlower = ovl_split_lowerdirs(splitlower); 2002b8e42a65SMiklos Szeredi if (numlower > OVL_MAX_STACK) { 2003b8e42a65SMiklos Szeredi pr_err("too many lower directories, limit is %d\n", 2004b8e42a65SMiklos Szeredi OVL_MAX_STACK); 2005b8e42a65SMiklos Szeredi goto out_err; 2006b8e42a65SMiklos Szeredi } 2007b8e42a65SMiklos Szeredi 2008d7b49b10SChengguang Xu err = -ENOMEM; 2009b8e42a65SMiklos Szeredi layers = kcalloc(numlower + 1, sizeof(struct ovl_layer), GFP_KERNEL); 2010b8e42a65SMiklos Szeredi if (!layers) 2011b8e42a65SMiklos Szeredi goto out_err; 2012b8e42a65SMiklos Szeredi 2013b8e42a65SMiklos Szeredi ofs->layers = layers; 2014b8e42a65SMiklos Szeredi /* Layer 0 is reserved for upper even if there's no upper */ 2015b8e42a65SMiklos Szeredi ofs->numlayer = 1; 2016b8e42a65SMiklos Szeredi 201753a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 2018cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 20194d314f78SAmir Goldstein atomic_long_set(&ofs->last_ino, 1); 20204f119628SWilliam Dean /* Assume underlying fs uses 32bit inodes unless proven otherwise */ 202153afcd31SAmir Goldstein if (ofs->config.xino != OVL_XINO_OFF) { 20220f831ec8SAmir Goldstein ofs->xino_mode = BITS_PER_LONG - 32; 202353afcd31SAmir Goldstein if (!ofs->xino_mode) { 202453afcd31SAmir Goldstein pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n"); 202553afcd31SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 202653afcd31SAmir Goldstein } 202753afcd31SAmir Goldstein } 2028795939a9SAmir Goldstein 2029146d62e5SAmir Goldstein /* alloc/destroy_inode needed for setting up traps in inode cache */ 2030146d62e5SAmir Goldstein sb->s_op = &ovl_super_operations; 2031146d62e5SAmir Goldstein 2032ad204488SMiklos Szeredi if (ofs->config.upperdir) { 2033335d3fc5SSargun Dhillon struct super_block *upper_sb; 2034335d3fc5SSargun Dhillon 2035d7b49b10SChengguang Xu err = -EINVAL; 2036ad204488SMiklos Szeredi if (!ofs->config.workdir) { 20371bd0a3aeSlijiazi pr_err("missing 'workdir'\n"); 2038a9075cdbSMiklos Szeredi goto out_err; 2039e9be9d5eSMiklos Szeredi } 2040e9be9d5eSMiklos Szeredi 2041b8e42a65SMiklos Szeredi err = ovl_get_upper(sb, ofs, &layers[0], &upperpath); 204221a3b317SMiklos Szeredi if (err) 2043a9075cdbSMiklos Szeredi goto out_err; 2044d719e8f2SMiklos Szeredi 2045335d3fc5SSargun Dhillon upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 2046335d3fc5SSargun Dhillon if (!ovl_should_sync(ofs)) { 2047335d3fc5SSargun Dhillon ofs->errseq = errseq_sample(&upper_sb->s_wb_err); 2048335d3fc5SSargun Dhillon if (errseq_check(&upper_sb->s_wb_err, ofs->errseq)) { 2049335d3fc5SSargun Dhillon err = -EIO; 2050335d3fc5SSargun Dhillon pr_err("Cannot mount volatile when upperdir has an unseen error. Sync upperdir fs to clear state.\n"); 2051335d3fc5SSargun Dhillon goto out_err; 2052335d3fc5SSargun Dhillon } 2053335d3fc5SSargun Dhillon } 2054335d3fc5SSargun Dhillon 2055146d62e5SAmir Goldstein err = ovl_get_workdir(sb, ofs, &upperpath); 20568ed61dc3SMiklos Szeredi if (err) 2057a9075cdbSMiklos Szeredi goto out_err; 2058c6fe6254SMiklos Szeredi 2059ad204488SMiklos Szeredi if (!ofs->workdir) 20601751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 20616e88256eSMiklos Szeredi 2062335d3fc5SSargun Dhillon sb->s_stack_depth = upper_sb->s_stack_depth; 2063335d3fc5SSargun Dhillon sb->s_time_gran = upper_sb->s_time_gran; 206421765194SVivek Goyal } 2065b8e42a65SMiklos Szeredi oe = ovl_get_lowerstack(sb, splitlower, numlower, ofs, layers); 20664155c10aSMiklos Szeredi err = PTR_ERR(oe); 20674155c10aSMiklos Szeredi if (IS_ERR(oe)) 2068a9075cdbSMiklos Szeredi goto out_err; 2069e9be9d5eSMiklos Szeredi 207071cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 207108f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 20721751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 2073e9be9d5eSMiklos Szeredi 20745830fb6bSPavel Tikhomirov if (!ofs->config.uuid && ofs->numfs > 1) { 20755830fb6bSPavel Tikhomirov pr_warn("The uuid=off requires a single fs for lower and upper, falling back to uuid=on.\n"); 20765830fb6bSPavel Tikhomirov ofs->config.uuid = true; 20775830fb6bSPavel Tikhomirov } 20785830fb6bSPavel Tikhomirov 2079470c1563SAmir Goldstein if (!ovl_force_readonly(ofs) && ofs->config.index) { 2080146d62e5SAmir Goldstein err = ovl_get_indexdir(sb, ofs, oe, &upperpath); 208154fb347eSAmir Goldstein if (err) 20824155c10aSMiklos Szeredi goto out_free_oe; 20836e88256eSMiklos Szeredi 2084972d0093SAmir Goldstein /* Force r/o mount with no index dir */ 208520396365SAmir Goldstein if (!ofs->indexdir) 20861751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 208702bcd157SAmir Goldstein } 208802bcd157SAmir Goldstein 2089146d62e5SAmir Goldstein err = ovl_check_overlapping_layers(sb, ofs); 2090146d62e5SAmir Goldstein if (err) 2091146d62e5SAmir Goldstein goto out_free_oe; 2092146d62e5SAmir Goldstein 2093972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */ 2094f168f109SAmir Goldstein if (!ofs->indexdir) { 2095ad204488SMiklos Szeredi ofs->config.index = false; 209608f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs) && ofs->config.nfs_export) { 20971bd0a3aeSlijiazi pr_warn("NFS export requires an index dir, falling back to nfs_export=off.\n"); 2098f168f109SAmir Goldstein ofs->config.nfs_export = false; 2099f168f109SAmir Goldstein } 2100f168f109SAmir Goldstein } 210102bcd157SAmir Goldstein 2102d5791044SVivek Goyal if (ofs->config.metacopy && ofs->config.nfs_export) { 21031bd0a3aeSlijiazi pr_warn("NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 2104d5791044SVivek Goyal ofs->config.nfs_export = false; 2105d5791044SVivek Goyal } 2106d5791044SVivek Goyal 21078383f174SAmir Goldstein if (ofs->config.nfs_export) 21088383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations; 21098383f174SAmir Goldstein 211051f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 211151f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 211251f8f3c4SKonstantin Khlebnikov 2113655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 21142d2f2d73SMiklos Szeredi sb->s_xattr = ofs->config.userxattr ? ovl_user_xattr_handlers : 21152d2f2d73SMiklos Szeredi ovl_trusted_xattr_handlers; 2116ad204488SMiklos Szeredi sb->s_fs_info = ofs; 2117de2a4a50SMiklos Szeredi sb->s_flags |= SB_POSIXACL; 211832b1924bSKonstantin Khlebnikov sb->s_iflags |= SB_I_SKIP_SYNC; 2119655042ccSVivek Goyal 2120c6fe6254SMiklos Szeredi err = -ENOMEM; 21212effc5c2SAmir Goldstein root_dentry = ovl_get_root(sb, upperpath.dentry, oe); 2122e9be9d5eSMiklos Szeredi if (!root_dentry) 21234155c10aSMiklos Szeredi goto out_free_oe; 2124e9be9d5eSMiklos Szeredi 2125367d002dSAmir Goldstein path_put(&upperpath); 2126b8e42a65SMiklos Szeredi kfree(splitlower); 2127ed06e069SMiklos Szeredi 2128e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 2129e9be9d5eSMiklos Szeredi 2130e9be9d5eSMiklos Szeredi return 0; 2131e9be9d5eSMiklos Szeredi 21324155c10aSMiklos Szeredi out_free_oe: 2133163db0daSAmir Goldstein ovl_free_entry(oe); 21344155c10aSMiklos Szeredi out_err: 2135b8e42a65SMiklos Szeredi kfree(splitlower); 2136e9be9d5eSMiklos Szeredi path_put(&upperpath); 2137ad204488SMiklos Szeredi ovl_free_fs(ofs); 2138e9be9d5eSMiklos Szeredi out: 2139e9be9d5eSMiklos Szeredi return err; 2140e9be9d5eSMiklos Szeredi } 2141e9be9d5eSMiklos Szeredi 2142e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 2143e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 2144e9be9d5eSMiklos Szeredi { 2145e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 2146e9be9d5eSMiklos Szeredi } 2147e9be9d5eSMiklos Szeredi 2148e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 2149e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 2150ef94b186SMiklos Szeredi .name = "overlay", 2151459c7c56SMiklos Szeredi .fs_flags = FS_USERNS_MOUNT, 2152e9be9d5eSMiklos Szeredi .mount = ovl_mount, 2153e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 2154e9be9d5eSMiklos Szeredi }; 2155ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 2156e9be9d5eSMiklos Szeredi 215713cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 215813cf199dSAmir Goldstein { 215913cf199dSAmir Goldstein struct ovl_inode *oi = foo; 216013cf199dSAmir Goldstein 216113cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 216213cf199dSAmir Goldstein } 216313cf199dSAmir Goldstein 2164e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 2165e9be9d5eSMiklos Szeredi { 216613cf199dSAmir Goldstein int err; 216713cf199dSAmir Goldstein 216813cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 216913cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 217013cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 217113cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 217213cf199dSAmir Goldstein ovl_inode_init_once); 217313cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 217413cf199dSAmir Goldstein return -ENOMEM; 217513cf199dSAmir Goldstein 21762406a307SJiufei Xue err = ovl_aio_request_cache_init(); 21772406a307SJiufei Xue if (!err) { 217813cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 21792406a307SJiufei Xue if (!err) 21802406a307SJiufei Xue return 0; 21812406a307SJiufei Xue 21822406a307SJiufei Xue ovl_aio_request_cache_destroy(); 21832406a307SJiufei Xue } 218413cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 218513cf199dSAmir Goldstein 218613cf199dSAmir Goldstein return err; 2187e9be9d5eSMiklos Szeredi } 2188e9be9d5eSMiklos Szeredi 2189e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 2190e9be9d5eSMiklos Szeredi { 2191e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 219213cf199dSAmir Goldstein 219313cf199dSAmir Goldstein /* 219413cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 219513cf199dSAmir Goldstein * destroy cache. 219613cf199dSAmir Goldstein */ 219713cf199dSAmir Goldstein rcu_barrier(); 219813cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 21992406a307SJiufei Xue ovl_aio_request_cache_destroy(); 2200e9be9d5eSMiklos Szeredi } 2201e9be9d5eSMiklos Szeredi 2202e9be9d5eSMiklos Szeredi module_init(ovl_init); 2203e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 2204