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> 191784fbc2SChristian Brauner #include <linux/fs_context.h> 20dcb399deSAmir Goldstein #include <linux/fs_parser.h> 21e9be9d5eSMiklos Szeredi #include "overlayfs.h" 22e9be9d5eSMiklos Szeredi 23e9be9d5eSMiklos Szeredi MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 24e9be9d5eSMiklos Szeredi MODULE_DESCRIPTION("Overlay filesystem"); 25e9be9d5eSMiklos Szeredi MODULE_LICENSE("GPL"); 26e9be9d5eSMiklos Szeredi 27e9be9d5eSMiklos Szeredi 28e9be9d5eSMiklos Szeredi struct ovl_dir_cache; 29e9be9d5eSMiklos Szeredi 30688ea0e5SMiklos Szeredi static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR); 31688ea0e5SMiklos Szeredi module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644); 32253e7483SNicolas Schier MODULE_PARM_DESC(redirect_dir, 33688ea0e5SMiklos Szeredi "Default to on or off for the redirect_dir feature"); 34e9be9d5eSMiklos Szeredi 35438c84c2SMiklos Szeredi static bool ovl_redirect_always_follow = 36438c84c2SMiklos Szeredi IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW); 37438c84c2SMiklos Szeredi module_param_named(redirect_always_follow, ovl_redirect_always_follow, 38438c84c2SMiklos Szeredi bool, 0644); 39253e7483SNicolas Schier MODULE_PARM_DESC(redirect_always_follow, 40438c84c2SMiklos Szeredi "Follow redirects even if redirect_dir feature is turned off"); 41438c84c2SMiklos Szeredi 4202bcd157SAmir Goldstein static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX); 4302bcd157SAmir Goldstein module_param_named(index, ovl_index_def, bool, 0644); 44253e7483SNicolas Schier MODULE_PARM_DESC(index, 4502bcd157SAmir Goldstein "Default to on or off for the inodes index feature"); 4602bcd157SAmir Goldstein 47f168f109SAmir Goldstein static bool ovl_nfs_export_def = IS_ENABLED(CONFIG_OVERLAY_FS_NFS_EXPORT); 48f168f109SAmir Goldstein module_param_named(nfs_export, ovl_nfs_export_def, bool, 0644); 49253e7483SNicolas Schier MODULE_PARM_DESC(nfs_export, 50f168f109SAmir Goldstein "Default to on or off for the NFS export feature"); 51f168f109SAmir Goldstein 52795939a9SAmir Goldstein static bool ovl_xino_auto_def = IS_ENABLED(CONFIG_OVERLAY_FS_XINO_AUTO); 53795939a9SAmir Goldstein module_param_named(xino_auto, ovl_xino_auto_def, bool, 0644); 54253e7483SNicolas Schier MODULE_PARM_DESC(xino_auto, 55795939a9SAmir Goldstein "Auto enable xino feature"); 56795939a9SAmir Goldstein 57d5791044SVivek Goyal static bool ovl_metacopy_def = IS_ENABLED(CONFIG_OVERLAY_FS_METACOPY); 58d5791044SVivek Goyal module_param_named(metacopy, ovl_metacopy_def, bool, 0644); 59253e7483SNicolas Schier MODULE_PARM_DESC(metacopy, 60d5791044SVivek Goyal "Default to on or off for the metadata only copy up feature"); 61d5791044SVivek Goyal 622d902671SMiklos Szeredi static struct dentry *ovl_d_real(struct dentry *dentry, 63fb16043bSMiklos Szeredi const struct inode *inode) 64d101a125SMiklos Szeredi { 65cef4cbffSMiklos Szeredi struct dentry *real = NULL, *lower; 66d101a125SMiklos Szeredi 67e8c985baSMiklos Szeredi /* It's an overlay file */ 68e8c985baSMiklos Szeredi if (inode && d_inode(dentry) == inode) 69e8c985baSMiklos Szeredi return dentry; 70e8c985baSMiklos Szeredi 71ca4c8a3aSMiklos Szeredi if (!d_is_reg(dentry)) { 72d101a125SMiklos Szeredi if (!inode || inode == d_inode(dentry)) 73d101a125SMiklos Szeredi return dentry; 74d101a125SMiklos Szeredi goto bug; 75d101a125SMiklos Szeredi } 76d101a125SMiklos Szeredi 77d101a125SMiklos Szeredi real = ovl_dentry_upper(dentry); 782c3d7358SVivek Goyal if (real && (inode == d_inode(real))) 79d101a125SMiklos Szeredi return real; 80d101a125SMiklos Szeredi 812c3d7358SVivek Goyal if (real && !inode && ovl_has_upperdata(d_inode(dentry))) 822c3d7358SVivek Goyal return real; 832c3d7358SVivek Goyal 8441665644SAmir Goldstein /* 8542dd69aeSAmir Goldstein * Best effort lazy lookup of lowerdata for !inode case to return 8641665644SAmir Goldstein * the real lowerdata dentry. The only current caller of d_real() with 8741665644SAmir Goldstein * NULL inode is d_real_inode() from trace_uprobe and this caller is 8841665644SAmir Goldstein * likely going to be followed reading from the file, before placing 8941665644SAmir Goldstein * uprobes on offset within the file, so lowerdata should be available 9041665644SAmir Goldstein * when setting the uprobe. 9141665644SAmir Goldstein */ 9242dd69aeSAmir Goldstein ovl_maybe_lookup_lowerdata(dentry); 93cef4cbffSMiklos Szeredi lower = ovl_dentry_lowerdata(dentry); 94cef4cbffSMiklos Szeredi if (!lower) 95d101a125SMiklos Szeredi goto bug; 96cef4cbffSMiklos Szeredi real = lower; 97d101a125SMiklos Szeredi 98c4fcfc16SMiklos Szeredi /* Handle recursion */ 99fb16043bSMiklos Szeredi real = d_real(real, inode); 100c4fcfc16SMiklos Szeredi 101d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 102d101a125SMiklos Szeredi return real; 103d101a125SMiklos Szeredi bug: 104cef4cbffSMiklos Szeredi WARN(1, "%s(%pd4, %s:%lu): real dentry (%p/%lu) not found\n", 105cef4cbffSMiklos Szeredi __func__, dentry, inode ? inode->i_sb->s_id : "NULL", 106cef4cbffSMiklos Szeredi inode ? inode->i_ino : 0, real, 107cef4cbffSMiklos Szeredi real && d_inode(real) ? d_inode(real)->i_ino : 0); 108d101a125SMiklos Szeredi return dentry; 109d101a125SMiklos Szeredi } 110d101a125SMiklos Szeredi 1113bb7df92SMiklos Szeredi static int ovl_revalidate_real(struct dentry *d, unsigned int flags, bool weak) 1123bb7df92SMiklos Szeredi { 1133bb7df92SMiklos Szeredi int ret = 1; 1143bb7df92SMiklos Szeredi 11541665644SAmir Goldstein if (!d) 11641665644SAmir Goldstein return 1; 11741665644SAmir Goldstein 1183bb7df92SMiklos Szeredi if (weak) { 1193bb7df92SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) 1203bb7df92SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1213bb7df92SMiklos Szeredi } else if (d->d_flags & DCACHE_OP_REVALIDATE) { 1223bb7df92SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1233bb7df92SMiklos Szeredi if (!ret) { 1243bb7df92SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1253bb7df92SMiklos Szeredi d_invalidate(d); 1263bb7df92SMiklos Szeredi ret = -ESTALE; 1273bb7df92SMiklos Szeredi } 1283bb7df92SMiklos Szeredi } 1293bb7df92SMiklos Szeredi return ret; 1303bb7df92SMiklos Szeredi } 1313bb7df92SMiklos Szeredi 1323bb7df92SMiklos Szeredi static int ovl_dentry_revalidate_common(struct dentry *dentry, 1333bb7df92SMiklos Szeredi unsigned int flags, bool weak) 1347c03b5d4SMiklos Szeredi { 135a6ff2bc0SAmir Goldstein struct ovl_entry *oe = OVL_E(dentry); 1365522c9c7SAmir Goldstein struct ovl_path *lowerstack = ovl_lowerstack(oe); 137672e4268SChen Zhongjin struct inode *inode = d_inode_rcu(dentry); 138bccece1eSMiklos Szeredi struct dentry *upper; 1397c03b5d4SMiklos Szeredi unsigned int i; 1407c03b5d4SMiklos Szeredi int ret = 1; 1417c03b5d4SMiklos Szeredi 142672e4268SChen Zhongjin /* Careful in RCU mode */ 143672e4268SChen Zhongjin if (!inode) 144672e4268SChen Zhongjin return -ECHILD; 145672e4268SChen Zhongjin 146672e4268SChen Zhongjin upper = ovl_i_dentry_upper(inode); 147bccece1eSMiklos Szeredi if (upper) 148bccece1eSMiklos Szeredi ret = ovl_revalidate_real(upper, flags, weak); 149bccece1eSMiklos Szeredi 1505522c9c7SAmir Goldstein for (i = 0; ret > 0 && i < ovl_numlower(oe); i++) 1515522c9c7SAmir Goldstein ret = ovl_revalidate_real(lowerstack[i].dentry, flags, weak); 1525522c9c7SAmir Goldstein 1537c03b5d4SMiklos Szeredi return ret; 1547c03b5d4SMiklos Szeredi } 1553bb7df92SMiklos Szeredi 1563bb7df92SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 1573bb7df92SMiklos Szeredi { 1583bb7df92SMiklos Szeredi return ovl_dentry_revalidate_common(dentry, flags, false); 1597c03b5d4SMiklos Szeredi } 1607c03b5d4SMiklos Szeredi 1617c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 1627c03b5d4SMiklos Szeredi { 1633bb7df92SMiklos Szeredi return ovl_dentry_revalidate_common(dentry, flags, true); 1647c03b5d4SMiklos Szeredi } 1657c03b5d4SMiklos Szeredi 166e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 167d101a125SMiklos Szeredi .d_real = ovl_d_real, 1687c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1697c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1707c03b5d4SMiklos Szeredi }; 1717c03b5d4SMiklos Szeredi 17213cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 17313cf199dSAmir Goldstein 17413cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 17513cf199dSAmir Goldstein { 176fd60b288SMuchun Song struct ovl_inode *oi = alloc_inode_sb(sb, ovl_inode_cachep, GFP_KERNEL); 17713cf199dSAmir Goldstein 178b3885bd6SHirofumi Nakagawa if (!oi) 179b3885bd6SHirofumi Nakagawa return NULL; 180b3885bd6SHirofumi Nakagawa 18104a01ac7SMiklos Szeredi oi->cache = NULL; 182cf31c463SMiklos Szeredi oi->redirect = NULL; 18304a01ac7SMiklos Szeredi oi->version = 0; 18413c72075SMiklos Szeredi oi->flags = 0; 18509d8b586SMiklos Szeredi oi->__upperdentry = NULL; 1862b21da92SAmir Goldstein oi->lowerdata_redirect = NULL; 1870af950f5SAmir Goldstein oi->oe = NULL; 188a015dafcSAmir Goldstein mutex_init(&oi->lock); 18925b7713aSMiklos Szeredi 19013cf199dSAmir Goldstein return &oi->vfs_inode; 19113cf199dSAmir Goldstein } 19213cf199dSAmir Goldstein 1930b269dedSAl Viro static void ovl_free_inode(struct inode *inode) 19413cf199dSAmir Goldstein { 1950b269dedSAl Viro struct ovl_inode *oi = OVL_I(inode); 19613cf199dSAmir Goldstein 1970b269dedSAl Viro kfree(oi->redirect); 1980b269dedSAl Viro mutex_destroy(&oi->lock); 1990b269dedSAl Viro kmem_cache_free(ovl_inode_cachep, oi); 20013cf199dSAmir Goldstein } 20113cf199dSAmir Goldstein 20213cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 20313cf199dSAmir Goldstein { 20409d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 20509d8b586SMiklos Szeredi 20609d8b586SMiklos Szeredi dput(oi->__upperdentry); 2070af950f5SAmir Goldstein ovl_free_entry(oi->oe); 2082664bd08SVivek Goyal if (S_ISDIR(inode->i_mode)) 2094edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 2102b21da92SAmir Goldstein else 2112b21da92SAmir Goldstein kfree(oi->lowerdata_redirect); 21213cf199dSAmir Goldstein } 21313cf199dSAmir Goldstein 214ad204488SMiklos Szeredi static void ovl_free_fs(struct ovl_fs *ofs) 215e9be9d5eSMiklos Szeredi { 216df820f8dSMiklos Szeredi struct vfsmount **mounts; 217dd662667SMiklos Szeredi unsigned i; 218e9be9d5eSMiklos Szeredi 2190be0bfd2SAmir Goldstein iput(ofs->workbasedir_trap); 220146d62e5SAmir Goldstein iput(ofs->indexdir_trap); 221146d62e5SAmir Goldstein iput(ofs->workdir_trap); 222c21c839bSChengguang Xu dput(ofs->whiteout); 223ad204488SMiklos Szeredi dput(ofs->indexdir); 224ad204488SMiklos Szeredi dput(ofs->workdir); 225ad204488SMiklos Szeredi if (ofs->workdir_locked) 226ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->workbasedir); 227ad204488SMiklos Szeredi dput(ofs->workbasedir); 228ad204488SMiklos Szeredi if (ofs->upperdir_locked) 22908f4c7c8SMiklos Szeredi ovl_inuse_unlock(ovl_upper_mnt(ofs)->mnt_root); 230df820f8dSMiklos Szeredi 231df820f8dSMiklos Szeredi /* Hack! Reuse ofs->layers as a vfsmount array before freeing it */ 232df820f8dSMiklos Szeredi mounts = (struct vfsmount **) ofs->layers; 233b8e42a65SMiklos Szeredi for (i = 0; i < ofs->numlayer; i++) { 23494375f9dSAmir Goldstein iput(ofs->layers[i].trap); 235df820f8dSMiklos Szeredi mounts[i] = ofs->layers[i].mnt; 236*b36a5780SChristian Brauner kfree(ofs->layers[i].name); 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.upperdir); 245ad204488SMiklos Szeredi kfree(ofs->config.workdir); 246ad204488SMiklos Szeredi if (ofs->creator_cred) 247ad204488SMiklos Szeredi put_cred(ofs->creator_cred); 248ad204488SMiklos Szeredi kfree(ofs); 249e9be9d5eSMiklos Szeredi } 250e9be9d5eSMiklos Szeredi 251a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 252a9075cdbSMiklos Szeredi { 253a9075cdbSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 254a9075cdbSMiklos Szeredi 2551784fbc2SChristian Brauner if (ofs) 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 332af5f2396SAmir Goldstein static const struct constant_table ovl_parameter_redirect_dir[] = { 333af5f2396SAmir Goldstein { "off", OVL_REDIRECT_OFF }, 334af5f2396SAmir Goldstein { "follow", OVL_REDIRECT_FOLLOW }, 335af5f2396SAmir Goldstein { "nofollow", OVL_REDIRECT_NOFOLLOW }, 336af5f2396SAmir Goldstein { "on", OVL_REDIRECT_ON }, 337af5f2396SAmir Goldstein {} 338af5f2396SAmir Goldstein }; 339af5f2396SAmir Goldstein 340af5f2396SAmir Goldstein static const char *ovl_redirect_mode(struct ovl_config *config) 341438c84c2SMiklos Szeredi { 342af5f2396SAmir Goldstein return ovl_parameter_redirect_dir[config->redirect_mode].name; 343af5f2396SAmir Goldstein } 344af5f2396SAmir Goldstein 345af5f2396SAmir Goldstein static int ovl_redirect_mode_def(void) 346af5f2396SAmir Goldstein { 347af5f2396SAmir Goldstein return ovl_redirect_dir_def ? OVL_REDIRECT_ON : 348af5f2396SAmir Goldstein ovl_redirect_always_follow ? OVL_REDIRECT_FOLLOW : 349af5f2396SAmir 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; 381*b36a5780SChristian Brauner size_t nr, nr_merged_lower = ofs->numlayer - ofs->numdatalayer; 382*b36a5780SChristian Brauner const struct ovl_layer *data_layers = &ofs->layers[nr_merged_lower]; 383f45827e8SErez Zadok 384*b36a5780SChristian Brauner /* ofs->layers[0] is the upper layer */ 385*b36a5780SChristian Brauner seq_printf(m, ",lowerdir=%s", ofs->layers[1].name); 386*b36a5780SChristian Brauner /* dump regular lower layers */ 387*b36a5780SChristian Brauner for (nr = 2; nr < nr_merged_lower; nr++) 388*b36a5780SChristian Brauner seq_printf(m, ":%s", ofs->layers[nr].name); 389*b36a5780SChristian Brauner /* dump data lower layers */ 390*b36a5780SChristian Brauner for (nr = 0; nr < ofs->numdatalayer; nr++) 391*b36a5780SChristian Brauner seq_printf(m, "::%s", data_layers[nr].name); 392ad204488SMiklos Szeredi if (ofs->config.upperdir) { 393ad204488SMiklos Szeredi seq_show_option(m, "upperdir", ofs->config.upperdir); 394ad204488SMiklos Szeredi seq_show_option(m, "workdir", ofs->config.workdir); 39553a08cb9SMiklos Szeredi } 396ad204488SMiklos Szeredi if (ofs->config.default_permissions) 3978d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 398af5f2396SAmir Goldstein if (ofs->config.redirect_mode != ovl_redirect_mode_def()) 399af5f2396SAmir Goldstein seq_printf(m, ",redirect_dir=%s", 400af5f2396SAmir Goldstein ovl_redirect_mode(&ofs->config)); 401ad204488SMiklos Szeredi if (ofs->config.index != ovl_index_def) 402438c84c2SMiklos Szeredi seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 4035830fb6bSPavel Tikhomirov if (!ofs->config.uuid) 4045830fb6bSPavel Tikhomirov seq_puts(m, ",uuid=off"); 405f168f109SAmir Goldstein if (ofs->config.nfs_export != ovl_nfs_export_def) 406f168f109SAmir Goldstein seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ? 407f168f109SAmir Goldstein "on" : "off"); 408dcb399deSAmir Goldstein if (ofs->config.xino != ovl_xino_def() && !ovl_same_fs(ofs)) 409dcb399deSAmir Goldstein seq_printf(m, ",xino=%s", ovl_xino_mode(&ofs->config)); 410d5791044SVivek Goyal if (ofs->config.metacopy != ovl_metacopy_def) 411d5791044SVivek Goyal seq_printf(m, ",metacopy=%s", 412d5791044SVivek Goyal ofs->config.metacopy ? "on" : "off"); 413c86243b0SVivek Goyal if (ofs->config.ovl_volatile) 414c86243b0SVivek Goyal seq_puts(m, ",volatile"); 415321b46b9SGiuseppe Scrivano if (ofs->config.userxattr) 416321b46b9SGiuseppe Scrivano seq_puts(m, ",userxattr"); 417f45827e8SErez Zadok return 0; 418f45827e8SErez Zadok } 419f45827e8SErez Zadok 4201784fbc2SChristian Brauner static int ovl_reconfigure(struct fs_context *fc) 4213cdf6fe9SSeunghun Lee { 4221784fbc2SChristian Brauner struct super_block *sb = fc->root->d_sb; 423ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 424399c109dSChengguang Xu struct super_block *upper_sb; 425399c109dSChengguang Xu int ret = 0; 4263cdf6fe9SSeunghun Lee 4271784fbc2SChristian Brauner if (!(fc->sb_flags & SB_RDONLY) && ovl_force_readonly(ofs)) 4283cdf6fe9SSeunghun Lee return -EROFS; 4293cdf6fe9SSeunghun Lee 4301784fbc2SChristian Brauner if (fc->sb_flags & SB_RDONLY && !sb_rdonly(sb)) { 43108f4c7c8SMiklos Szeredi upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 432c86243b0SVivek Goyal if (ovl_should_sync(ofs)) { 433399c109dSChengguang Xu down_read(&upper_sb->s_umount); 434399c109dSChengguang Xu ret = sync_filesystem(upper_sb); 435399c109dSChengguang Xu up_read(&upper_sb->s_umount); 436399c109dSChengguang Xu } 437c86243b0SVivek Goyal } 438399c109dSChengguang Xu 439399c109dSChengguang Xu return ret; 4403cdf6fe9SSeunghun Lee } 4413cdf6fe9SSeunghun Lee 442e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 44313cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 4440b269dedSAl Viro .free_inode = ovl_free_inode, 44513cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 44613cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 447e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 448e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 449cc259639SAndy Whitcroft .statfs = ovl_statfs, 450f45827e8SErez Zadok .show_options = ovl_show_options, 451e9be9d5eSMiklos Szeredi }; 452e9be9d5eSMiklos Szeredi 453e9be9d5eSMiklos Szeredi enum { 4541784fbc2SChristian Brauner Opt_lowerdir, 4551784fbc2SChristian Brauner Opt_upperdir, 4561784fbc2SChristian Brauner Opt_workdir, 4571784fbc2SChristian Brauner Opt_default_permissions, 4581784fbc2SChristian Brauner Opt_redirect_dir, 4591784fbc2SChristian Brauner Opt_index, 4601784fbc2SChristian Brauner Opt_uuid, 4611784fbc2SChristian Brauner Opt_nfs_export, 4621784fbc2SChristian Brauner Opt_userxattr, 4631784fbc2SChristian Brauner Opt_xino, 4641784fbc2SChristian Brauner Opt_metacopy, 4651784fbc2SChristian Brauner Opt_volatile, 466e9be9d5eSMiklos Szeredi }; 467e9be9d5eSMiklos Szeredi 4681784fbc2SChristian Brauner static const struct constant_table ovl_parameter_bool[] = { 4691784fbc2SChristian Brauner { "on", true }, 4701784fbc2SChristian Brauner { "off", false }, 4711784fbc2SChristian Brauner {} 472e9be9d5eSMiklos Szeredi }; 473e9be9d5eSMiklos Szeredi 474*b36a5780SChristian Brauner #define fsparam_string_empty(NAME, OPT) \ 475*b36a5780SChristian Brauner __fsparam(fs_param_is_string, NAME, OPT, fs_param_can_be_empty, NULL) 476*b36a5780SChristian Brauner 4771784fbc2SChristian Brauner static const struct fs_parameter_spec ovl_parameter_spec[] = { 478*b36a5780SChristian Brauner fsparam_string_empty("lowerdir", Opt_lowerdir), 4791784fbc2SChristian Brauner fsparam_string("upperdir", Opt_upperdir), 4801784fbc2SChristian Brauner fsparam_string("workdir", Opt_workdir), 4811784fbc2SChristian Brauner fsparam_flag("default_permissions", Opt_default_permissions), 4821784fbc2SChristian Brauner fsparam_enum("redirect_dir", Opt_redirect_dir, ovl_parameter_redirect_dir), 4831784fbc2SChristian Brauner fsparam_enum("index", Opt_index, ovl_parameter_bool), 4841784fbc2SChristian Brauner fsparam_enum("uuid", Opt_uuid, ovl_parameter_bool), 4851784fbc2SChristian Brauner fsparam_enum("nfs_export", Opt_nfs_export, ovl_parameter_bool), 4861784fbc2SChristian Brauner fsparam_flag("userxattr", Opt_userxattr), 4871784fbc2SChristian Brauner fsparam_enum("xino", Opt_xino, ovl_parameter_xino), 4881784fbc2SChristian Brauner fsparam_enum("metacopy", Opt_metacopy, ovl_parameter_bool), 4891784fbc2SChristian Brauner fsparam_flag("volatile", Opt_volatile), 4901784fbc2SChristian Brauner {} 4911784fbc2SChristian Brauner }; 49291c77947SMiklos Szeredi 4931784fbc2SChristian Brauner static int ovl_parse_param(struct fs_context *fc, struct fs_parameter *param) 494e9be9d5eSMiklos Szeredi { 495ac519625SAmir Goldstein int err = 0; 4961784fbc2SChristian Brauner struct fs_parse_result result; 4971784fbc2SChristian Brauner struct ovl_fs *ofs = fc->s_fs_info; 4981784fbc2SChristian Brauner struct ovl_config *config = &ofs->config; 4991784fbc2SChristian Brauner struct ovl_fs_context *ctx = fc->fs_private; 5001784fbc2SChristian Brauner int opt; 501e9be9d5eSMiklos Szeredi 5021784fbc2SChristian Brauner /* 5031784fbc2SChristian Brauner * On remount overlayfs has always ignored all mount options no 5041784fbc2SChristian Brauner * matter if malformed or not so for backwards compatibility we 5051784fbc2SChristian Brauner * do the same here. 5061784fbc2SChristian Brauner */ 5071784fbc2SChristian Brauner if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) 508ac519625SAmir Goldstein return 0; 509e9be9d5eSMiklos Szeredi 5101784fbc2SChristian Brauner opt = fs_parse(fc, ovl_parameter_spec, param, &result); 5111784fbc2SChristian Brauner if (opt < 0) 5121784fbc2SChristian Brauner return opt; 513e9be9d5eSMiklos Szeredi 5141784fbc2SChristian Brauner switch (opt) { 5151784fbc2SChristian Brauner case Opt_lowerdir: 516*b36a5780SChristian Brauner err = ovl_parse_param_lowerdir(param->string, fc); 517e9be9d5eSMiklos Szeredi break; 5181784fbc2SChristian Brauner case Opt_upperdir: 519*b36a5780SChristian Brauner fallthrough; 5201784fbc2SChristian Brauner case Opt_workdir: 521*b36a5780SChristian Brauner err = ovl_parse_param_upperdir(param->string, fc, 522*b36a5780SChristian Brauner (Opt_workdir == opt)); 523e9be9d5eSMiklos Szeredi break; 5241784fbc2SChristian Brauner case Opt_default_permissions: 5258d3095f4SMiklos Szeredi config->default_permissions = true; 5268d3095f4SMiklos Szeredi break; 5271784fbc2SChristian Brauner case Opt_redirect_dir: 5281784fbc2SChristian Brauner config->redirect_mode = result.uint_32; 5291784fbc2SChristian Brauner if (config->redirect_mode == OVL_REDIRECT_OFF) { 530af5f2396SAmir Goldstein config->redirect_mode = ovl_redirect_always_follow ? 531af5f2396SAmir Goldstein OVL_REDIRECT_FOLLOW : 532af5f2396SAmir Goldstein OVL_REDIRECT_NOFOLLOW; 5331784fbc2SChristian Brauner } 5341784fbc2SChristian Brauner ctx->set.redirect = true; 535af5f2396SAmir Goldstein break; 5361784fbc2SChristian Brauner case Opt_index: 5371784fbc2SChristian Brauner config->index = result.uint_32; 5381784fbc2SChristian Brauner ctx->set.index = true; 539af5f2396SAmir Goldstein break; 5401784fbc2SChristian Brauner case Opt_uuid: 5411784fbc2SChristian Brauner config->uuid = result.uint_32; 542a6c60655SMiklos Szeredi break; 5431784fbc2SChristian Brauner case Opt_nfs_export: 5441784fbc2SChristian Brauner config->nfs_export = result.uint_32; 5451784fbc2SChristian Brauner ctx->set.nfs_export = true; 54602bcd157SAmir Goldstein break; 5471784fbc2SChristian Brauner case Opt_xino: 5481784fbc2SChristian Brauner config->xino = result.uint_32; 54902bcd157SAmir Goldstein break; 5501784fbc2SChristian Brauner case Opt_metacopy: 5511784fbc2SChristian Brauner config->metacopy = result.uint_32; 5521784fbc2SChristian Brauner ctx->set.metacopy = true; 5535830fb6bSPavel Tikhomirov break; 5541784fbc2SChristian Brauner case Opt_volatile: 555c86243b0SVivek Goyal config->ovl_volatile = true; 556c86243b0SVivek Goyal break; 5571784fbc2SChristian Brauner case Opt_userxattr: 5582d2f2d73SMiklos Szeredi config->userxattr = true; 5592d2f2d73SMiklos Szeredi break; 560e9be9d5eSMiklos Szeredi default: 5611bd0a3aeSlijiazi pr_err("unrecognized mount option \"%s\" or missing value\n", 5621784fbc2SChristian Brauner param->key); 563e9be9d5eSMiklos Szeredi return -EINVAL; 564e9be9d5eSMiklos Szeredi } 565ac519625SAmir Goldstein 566ac519625SAmir Goldstein return err; 567ac519625SAmir Goldstein } 568ac519625SAmir Goldstein 5691784fbc2SChristian Brauner static int ovl_fs_params_verify(const struct ovl_fs_context *ctx, 5701784fbc2SChristian Brauner struct ovl_config *config) 571ac519625SAmir Goldstein { 5721784fbc2SChristian Brauner struct ovl_opt_set set = ctx->set; 57371cbad7eShujianyang 574*b36a5780SChristian Brauner if (ctx->nr_data > 0 && !config->metacopy) { 575*b36a5780SChristian Brauner pr_err("lower data-only dirs require metacopy support.\n"); 576*b36a5780SChristian Brauner return -EINVAL; 577*b36a5780SChristian Brauner } 578*b36a5780SChristian Brauner 579f0e1266eSAmir Goldstein /* Workdir/index are useless in non-upper mount */ 580f0e1266eSAmir Goldstein if (!config->upperdir) { 581f0e1266eSAmir Goldstein if (config->workdir) { 5821bd0a3aeSlijiazi pr_info("option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 58371cbad7eShujianyang config->workdir); 58471cbad7eShujianyang kfree(config->workdir); 58571cbad7eShujianyang config->workdir = NULL; 58671cbad7eShujianyang } 587ac519625SAmir Goldstein if (config->index && set.index) { 588f0e1266eSAmir Goldstein pr_info("option \"index=on\" is useless in a non-upper mount, ignore\n"); 589ac519625SAmir Goldstein set.index = false; 590f0e1266eSAmir Goldstein } 591f0e1266eSAmir Goldstein config->index = false; 592f0e1266eSAmir Goldstein } 59371cbad7eShujianyang 594c86243b0SVivek Goyal if (!config->upperdir && config->ovl_volatile) { 595c86243b0SVivek Goyal pr_info("option \"volatile\" is meaningless in a non-upper mount, ignoring it.\n"); 596c86243b0SVivek Goyal config->ovl_volatile = false; 597c86243b0SVivek Goyal } 598c86243b0SVivek Goyal 599d47748e5SMiklos Szeredi /* 600d47748e5SMiklos Szeredi * This is to make the logic below simpler. It doesn't make any other 601af5f2396SAmir Goldstein * difference, since redirect_dir=on is only used for upper. 602d47748e5SMiklos Szeredi */ 603af5f2396SAmir Goldstein if (!config->upperdir && config->redirect_mode == OVL_REDIRECT_FOLLOW) 604af5f2396SAmir Goldstein config->redirect_mode = OVL_REDIRECT_ON; 605d47748e5SMiklos Szeredi 606d47748e5SMiklos Szeredi /* Resolve metacopy -> redirect_dir dependency */ 607af5f2396SAmir Goldstein if (config->metacopy && config->redirect_mode != OVL_REDIRECT_ON) { 608ac519625SAmir Goldstein if (set.metacopy && set.redirect) { 6091bd0a3aeSlijiazi pr_err("conflicting options: metacopy=on,redirect_dir=%s\n", 610af5f2396SAmir Goldstein ovl_redirect_mode(config)); 611d47748e5SMiklos Szeredi return -EINVAL; 612d47748e5SMiklos Szeredi } 613ac519625SAmir Goldstein if (set.redirect) { 614d47748e5SMiklos Szeredi /* 615d47748e5SMiklos Szeredi * There was an explicit redirect_dir=... that resulted 616d47748e5SMiklos Szeredi * in this conflict. 617d47748e5SMiklos Szeredi */ 6181bd0a3aeSlijiazi pr_info("disabling metacopy due to redirect_dir=%s\n", 619af5f2396SAmir Goldstein ovl_redirect_mode(config)); 620d5791044SVivek Goyal config->metacopy = false; 621d47748e5SMiklos Szeredi } else { 622d47748e5SMiklos Szeredi /* Automatically enable redirect otherwise. */ 623af5f2396SAmir Goldstein config->redirect_mode = OVL_REDIRECT_ON; 624d47748e5SMiklos Szeredi } 625d5791044SVivek Goyal } 626d5791044SVivek Goyal 627b0def88dSAmir Goldstein /* Resolve nfs_export -> index dependency */ 628b0def88dSAmir Goldstein if (config->nfs_export && !config->index) { 629af5f2396SAmir Goldstein if (!config->upperdir && 630af5f2396SAmir Goldstein config->redirect_mode != OVL_REDIRECT_NOFOLLOW) { 631f0e1266eSAmir Goldstein pr_info("NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n"); 632f0e1266eSAmir Goldstein config->nfs_export = false; 633ac519625SAmir Goldstein } else if (set.nfs_export && set.index) { 634b0def88dSAmir Goldstein pr_err("conflicting options: nfs_export=on,index=off\n"); 635b0def88dSAmir Goldstein return -EINVAL; 636ac519625SAmir Goldstein } else if (set.index) { 637b0def88dSAmir Goldstein /* 638b0def88dSAmir Goldstein * There was an explicit index=off that resulted 639b0def88dSAmir Goldstein * in this conflict. 640b0def88dSAmir Goldstein */ 641b0def88dSAmir Goldstein pr_info("disabling nfs_export due to index=off\n"); 642b0def88dSAmir Goldstein config->nfs_export = false; 643b0def88dSAmir Goldstein } else { 644b0def88dSAmir Goldstein /* Automatically enable index otherwise. */ 645b0def88dSAmir Goldstein config->index = true; 646b0def88dSAmir Goldstein } 647b0def88dSAmir Goldstein } 648b0def88dSAmir Goldstein 649b0def88dSAmir Goldstein /* Resolve nfs_export -> !metacopy dependency */ 650b0def88dSAmir Goldstein if (config->nfs_export && config->metacopy) { 651ac519625SAmir Goldstein if (set.nfs_export && set.metacopy) { 652b0def88dSAmir Goldstein pr_err("conflicting options: nfs_export=on,metacopy=on\n"); 653b0def88dSAmir Goldstein return -EINVAL; 654b0def88dSAmir Goldstein } 655ac519625SAmir Goldstein if (set.metacopy) { 656b0def88dSAmir Goldstein /* 657b0def88dSAmir Goldstein * There was an explicit metacopy=on that resulted 658b0def88dSAmir Goldstein * in this conflict. 659b0def88dSAmir Goldstein */ 660b0def88dSAmir Goldstein pr_info("disabling nfs_export due to metacopy=on\n"); 661b0def88dSAmir Goldstein config->nfs_export = false; 662b0def88dSAmir Goldstein } else { 663b0def88dSAmir Goldstein /* 664b0def88dSAmir Goldstein * There was an explicit nfs_export=on that resulted 665b0def88dSAmir Goldstein * in this conflict. 666b0def88dSAmir Goldstein */ 667b0def88dSAmir Goldstein pr_info("disabling metacopy due to nfs_export=on\n"); 668b0def88dSAmir Goldstein config->metacopy = false; 669b0def88dSAmir Goldstein } 670b0def88dSAmir Goldstein } 671b0def88dSAmir Goldstein 6722d2f2d73SMiklos Szeredi 6732d2f2d73SMiklos Szeredi /* Resolve userxattr -> !redirect && !metacopy dependency */ 6742d2f2d73SMiklos Szeredi if (config->userxattr) { 675ac519625SAmir Goldstein if (set.redirect && 676af5f2396SAmir Goldstein config->redirect_mode != OVL_REDIRECT_NOFOLLOW) { 6772d2f2d73SMiklos Szeredi pr_err("conflicting options: userxattr,redirect_dir=%s\n", 678af5f2396SAmir Goldstein ovl_redirect_mode(config)); 6792d2f2d73SMiklos Szeredi return -EINVAL; 6802d2f2d73SMiklos Szeredi } 681ac519625SAmir Goldstein if (config->metacopy && set.metacopy) { 6822d2f2d73SMiklos Szeredi pr_err("conflicting options: userxattr,metacopy=on\n"); 6832d2f2d73SMiklos Szeredi return -EINVAL; 6842d2f2d73SMiklos Szeredi } 6852d2f2d73SMiklos Szeredi /* 6862d2f2d73SMiklos Szeredi * Silently disable default setting of redirect and metacopy. 6872d2f2d73SMiklos Szeredi * This shall be the default in the future as well: these 6882d2f2d73SMiklos Szeredi * options must be explicitly enabled if used together with 6892d2f2d73SMiklos Szeredi * userxattr. 6902d2f2d73SMiklos Szeredi */ 691af5f2396SAmir Goldstein config->redirect_mode = OVL_REDIRECT_NOFOLLOW; 6922d2f2d73SMiklos Szeredi config->metacopy = false; 6932d2f2d73SMiklos Szeredi } 6942d2f2d73SMiklos Szeredi 695d5791044SVivek Goyal return 0; 696e9be9d5eSMiklos Szeredi } 697e9be9d5eSMiklos Szeredi 698e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 69902bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 700e9be9d5eSMiklos Szeredi 701ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 7026b8aa129SAmir Goldstein const char *name, bool persist) 703e9be9d5eSMiklos Szeredi { 704ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 70508f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 706e9be9d5eSMiklos Szeredi struct dentry *work; 707e9be9d5eSMiklos Szeredi int err; 708e9be9d5eSMiklos Szeredi bool retried = false; 709e9be9d5eSMiklos Szeredi 7105955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 711e9be9d5eSMiklos Szeredi retry: 71222f289ceSChristian Brauner work = ovl_lookup_upper(ofs, name, ofs->workbasedir, strlen(name)); 713e9be9d5eSMiklos Szeredi 714e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 715c11b9fddSMiklos Szeredi struct iattr attr = { 716c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 71732a3d848SAl Viro .ia_mode = S_IFDIR | 0, 718c11b9fddSMiklos Szeredi }; 719e9be9d5eSMiklos Szeredi 720e9be9d5eSMiklos Szeredi if (work->d_inode) { 721e9be9d5eSMiklos Szeredi err = -EEXIST; 722e9be9d5eSMiklos Szeredi if (retried) 723e9be9d5eSMiklos Szeredi goto out_dput; 724e9be9d5eSMiklos Szeredi 7256b8aa129SAmir Goldstein if (persist) 7266b8aa129SAmir Goldstein goto out_unlock; 7276b8aa129SAmir Goldstein 728e9be9d5eSMiklos Szeredi retried = true; 729576bb263SChristian Brauner err = ovl_workdir_cleanup(ofs, dir, mnt, work, 0); 730e9be9d5eSMiklos Szeredi dput(work); 731235ce9edSAmir Goldstein if (err == -EINVAL) { 732235ce9edSAmir Goldstein work = ERR_PTR(err); 733235ce9edSAmir Goldstein goto out_unlock; 734235ce9edSAmir Goldstein } 735e9be9d5eSMiklos Szeredi goto retry; 736e9be9d5eSMiklos Szeredi } 737e9be9d5eSMiklos Szeredi 738576bb263SChristian Brauner err = ovl_mkdir_real(ofs, dir, &work, attr.ia_mode); 7391f5573cfSMiklos Szeredi if (err) 7401f5573cfSMiklos Szeredi goto out_dput; 7411f5573cfSMiklos Szeredi 7421f5573cfSMiklos Szeredi /* Weird filesystem returning with hashed negative (kernfs)? */ 7431f5573cfSMiklos Szeredi err = -EINVAL; 7441f5573cfSMiklos Szeredi if (d_really_is_negative(work)) 7451f5573cfSMiklos Szeredi goto out_dput; 746c11b9fddSMiklos Szeredi 747cb348edbSMiklos Szeredi /* 748cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 749cb348edbSMiklos Szeredi * 750cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 751cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 752cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 753cb348edbSMiklos Szeredi * 754cb348edbSMiklos Szeredi * There are various other error values that could effectively 755cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 756cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 757cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 758cb348edbSMiklos Szeredi * for the above two errors is sufficient. 759cb348edbSMiklos Szeredi */ 76031acceb9SChristian Brauner err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_DEFAULT); 761e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 762c11b9fddSMiklos Szeredi goto out_dput; 763c11b9fddSMiklos Szeredi 76431acceb9SChristian Brauner err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_ACCESS); 765e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 766c11b9fddSMiklos Szeredi goto out_dput; 767c11b9fddSMiklos Szeredi 768c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 769c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 770a15506eaSChristian Brauner err = ovl_do_notify_change(ofs, work, &attr); 771c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 772c11b9fddSMiklos Szeredi if (err) 773c11b9fddSMiklos Szeredi goto out_dput; 7746b8aa129SAmir Goldstein } else { 7756b8aa129SAmir Goldstein err = PTR_ERR(work); 7766b8aa129SAmir Goldstein goto out_err; 777e9be9d5eSMiklos Szeredi } 778e9be9d5eSMiklos Szeredi out_unlock: 7796b8aa129SAmir Goldstein inode_unlock(dir); 780e9be9d5eSMiklos Szeredi return work; 781e9be9d5eSMiklos Szeredi 782e9be9d5eSMiklos Szeredi out_dput: 783e9be9d5eSMiklos Szeredi dput(work); 7846b8aa129SAmir Goldstein out_err: 7851bd0a3aeSlijiazi pr_warn("failed to create directory %s/%s (errno: %i); mounting read-only\n", 786ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 7876b8aa129SAmir Goldstein work = NULL; 788e9be9d5eSMiklos Szeredi goto out_unlock; 789e9be9d5eSMiklos Szeredi } 790e9be9d5eSMiklos Szeredi 7912d343087SAl Viro static int ovl_check_namelen(const struct path *path, struct ovl_fs *ofs, 7926b2d5fe4SMiklos Szeredi const char *name) 7936b2d5fe4SMiklos Szeredi { 7946b2d5fe4SMiklos Szeredi struct kstatfs statfs; 7956b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 7966b2d5fe4SMiklos Szeredi 7976b2d5fe4SMiklos Szeredi if (err) 7981bd0a3aeSlijiazi pr_err("statfs failed on '%s'\n", name); 7996b2d5fe4SMiklos Szeredi else 8006b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 8016b2d5fe4SMiklos Szeredi 8026b2d5fe4SMiklos Szeredi return err; 8036b2d5fe4SMiklos Szeredi } 8046b2d5fe4SMiklos Szeredi 8056b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 806f4288844SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth) 807ab508822SMiklos Szeredi { 808e487d889SAmir Goldstein int fh_type; 809ab508822SMiklos Szeredi int err; 810ab508822SMiklos Szeredi 8116b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 8126b2d5fe4SMiklos Szeredi if (err) 813b8e42a65SMiklos Szeredi return err; 8146b2d5fe4SMiklos Szeredi 815ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 816ab508822SMiklos Szeredi 81702bcd157SAmir Goldstein /* 818f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode 819f168f109SAmir Goldstein * file handles, so they require that all layers support them. 82002bcd157SAmir Goldstein */ 821e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(path->dentry->d_sb); 822f168f109SAmir Goldstein if ((ofs->config.nfs_export || 823e487d889SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 82402bcd157SAmir Goldstein ofs->config.index = false; 825f168f109SAmir Goldstein ofs->config.nfs_export = false; 8261bd0a3aeSlijiazi pr_warn("fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 827f168f109SAmir Goldstein name); 82802bcd157SAmir Goldstein } 829b0e0f697SAmir Goldstein /* 830b0e0f697SAmir Goldstein * Decoding origin file handle is required for persistent st_ino. 831b0e0f697SAmir Goldstein * Without persistent st_ino, xino=auto falls back to xino=off. 832b0e0f697SAmir Goldstein */ 833b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO && 834b0e0f697SAmir Goldstein ofs->config.upperdir && !fh_type) { 835b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 836b0e0f697SAmir Goldstein pr_warn("fs on '%s' does not support file handles, falling back to xino=off.\n", 837b0e0f697SAmir Goldstein name); 838b0e0f697SAmir Goldstein } 83902bcd157SAmir Goldstein 840e487d889SAmir Goldstein /* Check if lower fs has 32bit inode numbers */ 841e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 8420f831ec8SAmir Goldstein ofs->xino_mode = -1; 843e487d889SAmir Goldstein 844ab508822SMiklos Szeredi return 0; 845ab508822SMiklos Szeredi } 846ab508822SMiklos Szeredi 847e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 848e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 849e9be9d5eSMiklos Szeredi { 850e9be9d5eSMiklos Szeredi bool ok = false; 851e9be9d5eSMiklos Szeredi 852e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 853e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 854e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 855e9be9d5eSMiklos Szeredi } 856e9be9d5eSMiklos Szeredi return ok; 857e9be9d5eSMiklos Szeredi } 858e9be9d5eSMiklos Szeredi 8590eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 8600eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8610eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 8620eb45fc3SAndreas Gruenbacher { 86348fab5d7SAmir Goldstein return -EOPNOTSUPP; 8640eb45fc3SAndreas Gruenbacher } 8650eb45fc3SAndreas Gruenbacher 866d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 86739f60c1cSChristian Brauner struct mnt_idmap *idmap, 868d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 869d837a49bSMiklos Szeredi const char *name, const void *value, 870d837a49bSMiklos Szeredi size_t size, int flags) 871d837a49bSMiklos Szeredi { 87248fab5d7SAmir Goldstein return -EOPNOTSUPP; 873d837a49bSMiklos Szeredi } 874d837a49bSMiklos Szeredi 8750eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 8760eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8770eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 8780eb45fc3SAndreas Gruenbacher { 8791d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 8800eb45fc3SAndreas Gruenbacher } 8810eb45fc3SAndreas Gruenbacher 8820e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 88339f60c1cSChristian Brauner struct mnt_idmap *idmap, 8840e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8850e585cccSAndreas Gruenbacher const char *name, const void *value, 8860e585cccSAndreas Gruenbacher size_t size, int flags) 8870e585cccSAndreas Gruenbacher { 8881d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 8890e585cccSAndreas Gruenbacher } 8900e585cccSAndreas Gruenbacher 8912d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_trusted_xattr_handler = { 8922d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_TRUSTED_PREFIX, 8932d2f2d73SMiklos Szeredi .get = ovl_own_xattr_get, 8942d2f2d73SMiklos Szeredi .set = ovl_own_xattr_set, 8952d2f2d73SMiklos Szeredi }; 8962d2f2d73SMiklos Szeredi 8972d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_user_xattr_handler = { 8982d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_USER_PREFIX, 8990eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 900d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 901d837a49bSMiklos Szeredi }; 902d837a49bSMiklos Szeredi 903d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 904d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 9050eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 906d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 907d837a49bSMiklos Szeredi }; 908d837a49bSMiklos Szeredi 9092d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_trusted_xattr_handlers[] = { 9102d2f2d73SMiklos Szeredi &ovl_own_trusted_xattr_handler, 9112d2f2d73SMiklos Szeredi &ovl_other_xattr_handler, 9122d2f2d73SMiklos Szeredi NULL 9132d2f2d73SMiklos Szeredi }; 9142d2f2d73SMiklos Szeredi 9152d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_user_xattr_handlers[] = { 9162d2f2d73SMiklos Szeredi &ovl_own_user_xattr_handler, 917d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 918d837a49bSMiklos Szeredi NULL 919d837a49bSMiklos Szeredi }; 920d837a49bSMiklos Szeredi 921146d62e5SAmir Goldstein static int ovl_setup_trap(struct super_block *sb, struct dentry *dir, 922146d62e5SAmir Goldstein struct inode **ptrap, const char *name) 923146d62e5SAmir Goldstein { 924146d62e5SAmir Goldstein struct inode *trap; 925146d62e5SAmir Goldstein int err; 926146d62e5SAmir Goldstein 927146d62e5SAmir Goldstein trap = ovl_get_trap_inode(sb, dir); 9281dac6f5bSArnd Bergmann err = PTR_ERR_OR_ZERO(trap); 9291dac6f5bSArnd Bergmann if (err) { 930146d62e5SAmir Goldstein if (err == -ELOOP) 9311bd0a3aeSlijiazi pr_err("conflicting %s path\n", name); 932146d62e5SAmir Goldstein return err; 933146d62e5SAmir Goldstein } 934146d62e5SAmir Goldstein 935146d62e5SAmir Goldstein *ptrap = trap; 936146d62e5SAmir Goldstein return 0; 937146d62e5SAmir Goldstein } 938146d62e5SAmir Goldstein 9390be0bfd2SAmir Goldstein /* 9400be0bfd2SAmir Goldstein * Determine how we treat concurrent use of upperdir/workdir based on the 9410be0bfd2SAmir Goldstein * index feature. This is papering over mount leaks of container runtimes, 9420be0bfd2SAmir Goldstein * for example, an old overlay mount is leaked and now its upperdir is 9430be0bfd2SAmir Goldstein * attempted to be used as a lower layer in a new overlay mount. 9440be0bfd2SAmir Goldstein */ 9450be0bfd2SAmir Goldstein static int ovl_report_in_use(struct ovl_fs *ofs, const char *name) 9460be0bfd2SAmir Goldstein { 9470be0bfd2SAmir Goldstein if (ofs->config.index) { 9481bd0a3aeSlijiazi pr_err("%s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n", 9490be0bfd2SAmir Goldstein name); 9500be0bfd2SAmir Goldstein return -EBUSY; 9510be0bfd2SAmir Goldstein } else { 9521bd0a3aeSlijiazi pr_warn("%s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n", 9530be0bfd2SAmir Goldstein name); 9540be0bfd2SAmir Goldstein return 0; 9550be0bfd2SAmir Goldstein } 9560be0bfd2SAmir Goldstein } 9570be0bfd2SAmir Goldstein 958146d62e5SAmir Goldstein static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs, 959*b36a5780SChristian Brauner struct ovl_layer *upper_layer, 960*b36a5780SChristian Brauner const struct path *upperpath) 9616ee8acf0SMiklos Szeredi { 9625064975eSMiklos Szeredi struct vfsmount *upper_mnt; 9636ee8acf0SMiklos Szeredi int err; 9646ee8acf0SMiklos Szeredi 965e21a6c57SAmir Goldstein /* Upperdir path should not be r/o */ 966e21a6c57SAmir Goldstein if (__mnt_is_readonly(upperpath->mnt)) { 9671bd0a3aeSlijiazi pr_err("upper fs is r/o, try multi-lower layers mount\n"); 9686ee8acf0SMiklos Szeredi err = -EINVAL; 9696ee8acf0SMiklos Szeredi goto out; 9706ee8acf0SMiklos Szeredi } 9716ee8acf0SMiklos Szeredi 972ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 9736ee8acf0SMiklos Szeredi if (err) 9746ee8acf0SMiklos Szeredi goto out; 9756ee8acf0SMiklos Szeredi 976b8e42a65SMiklos Szeredi err = ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap, 977146d62e5SAmir Goldstein "upperdir"); 978146d62e5SAmir Goldstein if (err) 979146d62e5SAmir Goldstein goto out; 980146d62e5SAmir Goldstein 9815064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 9825064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 9835064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 9841bd0a3aeSlijiazi pr_err("failed to clone upperpath\n"); 9855064975eSMiklos Szeredi goto out; 9865064975eSMiklos Szeredi } 9875064975eSMiklos Szeredi 9885064975eSMiklos Szeredi /* Don't inherit atime flags */ 9895064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 990b8e42a65SMiklos Szeredi upper_layer->mnt = upper_mnt; 991b8e42a65SMiklos Szeredi upper_layer->idx = 0; 992b8e42a65SMiklos Szeredi upper_layer->fsid = 0; 9938c25741aSMiklos Szeredi 994*b36a5780SChristian Brauner err = -ENOMEM; 995*b36a5780SChristian Brauner upper_layer->name = kstrdup(ofs->config.upperdir, GFP_KERNEL); 996*b36a5780SChristian Brauner if (!upper_layer->name) 997*b36a5780SChristian Brauner goto out; 998*b36a5780SChristian Brauner 999654255faSJeffle Xu /* 1000654255faSJeffle Xu * Inherit SB_NOSEC flag from upperdir. 1001654255faSJeffle Xu * 1002654255faSJeffle Xu * This optimization changes behavior when a security related attribute 1003654255faSJeffle Xu * (suid/sgid/security.*) is changed on an underlying layer. This is 1004654255faSJeffle Xu * okay because we don't yet have guarantees in that case, but it will 1005654255faSJeffle Xu * need careful treatment once we want to honour changes to underlying 1006654255faSJeffle Xu * filesystems. 1007654255faSJeffle Xu */ 1008654255faSJeffle Xu if (upper_mnt->mnt_sb->s_flags & SB_NOSEC) 1009654255faSJeffle Xu sb->s_flags |= SB_NOSEC; 1010654255faSJeffle Xu 101108f4c7c8SMiklos Szeredi if (ovl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) { 10128c25741aSMiklos Szeredi ofs->upperdir_locked = true; 10138c25741aSMiklos Szeredi } else { 10140be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "upperdir"); 10150be0bfd2SAmir Goldstein if (err) 10160be0bfd2SAmir Goldstein goto out; 10178c25741aSMiklos Szeredi } 10188c25741aSMiklos Szeredi 10196ee8acf0SMiklos Szeredi err = 0; 10206ee8acf0SMiklos Szeredi out: 10216ee8acf0SMiklos Szeredi return err; 10226ee8acf0SMiklos Szeredi } 10236ee8acf0SMiklos Szeredi 1024cad218abSAmir Goldstein /* 1025cad218abSAmir Goldstein * Returns 1 if RENAME_WHITEOUT is supported, 0 if not supported and 1026cad218abSAmir Goldstein * negative values if error is encountered. 1027cad218abSAmir Goldstein */ 1028576bb263SChristian Brauner static int ovl_check_rename_whiteout(struct ovl_fs *ofs) 1029cad218abSAmir Goldstein { 1030576bb263SChristian Brauner struct dentry *workdir = ofs->workdir; 1031cad218abSAmir Goldstein struct inode *dir = d_inode(workdir); 1032cad218abSAmir Goldstein struct dentry *temp; 1033cad218abSAmir Goldstein struct dentry *dest; 1034cad218abSAmir Goldstein struct dentry *whiteout; 1035cad218abSAmir Goldstein struct name_snapshot name; 1036cad218abSAmir Goldstein int err; 1037cad218abSAmir Goldstein 1038cad218abSAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 1039cad218abSAmir Goldstein 1040576bb263SChristian Brauner temp = ovl_create_temp(ofs, workdir, OVL_CATTR(S_IFREG | 0)); 1041cad218abSAmir Goldstein err = PTR_ERR(temp); 1042cad218abSAmir Goldstein if (IS_ERR(temp)) 1043cad218abSAmir Goldstein goto out_unlock; 1044cad218abSAmir Goldstein 1045576bb263SChristian Brauner dest = ovl_lookup_temp(ofs, workdir); 1046cad218abSAmir Goldstein err = PTR_ERR(dest); 1047cad218abSAmir Goldstein if (IS_ERR(dest)) { 1048cad218abSAmir Goldstein dput(temp); 1049cad218abSAmir Goldstein goto out_unlock; 1050cad218abSAmir Goldstein } 1051cad218abSAmir Goldstein 1052cad218abSAmir Goldstein /* Name is inline and stable - using snapshot as a copy helper */ 1053cad218abSAmir Goldstein take_dentry_name_snapshot(&name, temp); 1054576bb263SChristian Brauner err = ovl_do_rename(ofs, dir, temp, dir, dest, RENAME_WHITEOUT); 1055cad218abSAmir Goldstein if (err) { 1056cad218abSAmir Goldstein if (err == -EINVAL) 1057cad218abSAmir Goldstein err = 0; 1058cad218abSAmir Goldstein goto cleanup_temp; 1059cad218abSAmir Goldstein } 1060cad218abSAmir Goldstein 106122f289ceSChristian Brauner whiteout = ovl_lookup_upper(ofs, name.name.name, workdir, name.name.len); 1062cad218abSAmir Goldstein err = PTR_ERR(whiteout); 1063cad218abSAmir Goldstein if (IS_ERR(whiteout)) 1064cad218abSAmir Goldstein goto cleanup_temp; 1065cad218abSAmir Goldstein 1066cad218abSAmir Goldstein err = ovl_is_whiteout(whiteout); 1067cad218abSAmir Goldstein 1068cad218abSAmir Goldstein /* Best effort cleanup of whiteout and temp file */ 1069cad218abSAmir Goldstein if (err) 1070576bb263SChristian Brauner ovl_cleanup(ofs, dir, whiteout); 1071cad218abSAmir Goldstein dput(whiteout); 1072cad218abSAmir Goldstein 1073cad218abSAmir Goldstein cleanup_temp: 1074576bb263SChristian Brauner ovl_cleanup(ofs, dir, temp); 1075cad218abSAmir Goldstein release_dentry_name_snapshot(&name); 1076cad218abSAmir Goldstein dput(temp); 1077cad218abSAmir Goldstein dput(dest); 1078cad218abSAmir Goldstein 1079cad218abSAmir Goldstein out_unlock: 1080cad218abSAmir Goldstein inode_unlock(dir); 1081cad218abSAmir Goldstein 1082cad218abSAmir Goldstein return err; 1083cad218abSAmir Goldstein } 1084cad218abSAmir Goldstein 1085576bb263SChristian Brauner static struct dentry *ovl_lookup_or_create(struct ovl_fs *ofs, 1086576bb263SChristian Brauner struct dentry *parent, 1087c86243b0SVivek Goyal const char *name, umode_t mode) 1088c86243b0SVivek Goyal { 1089c86243b0SVivek Goyal size_t len = strlen(name); 1090c86243b0SVivek Goyal struct dentry *child; 1091c86243b0SVivek Goyal 1092c86243b0SVivek Goyal inode_lock_nested(parent->d_inode, I_MUTEX_PARENT); 109322f289ceSChristian Brauner child = ovl_lookup_upper(ofs, name, parent, len); 1094c86243b0SVivek Goyal if (!IS_ERR(child) && !child->d_inode) 1095576bb263SChristian Brauner child = ovl_create_real(ofs, parent->d_inode, child, 1096c86243b0SVivek Goyal OVL_CATTR(mode)); 1097c86243b0SVivek Goyal inode_unlock(parent->d_inode); 1098c86243b0SVivek Goyal dput(parent); 1099c86243b0SVivek Goyal 1100c86243b0SVivek Goyal return child; 1101c86243b0SVivek Goyal } 1102c86243b0SVivek Goyal 1103c86243b0SVivek Goyal /* 1104c86243b0SVivek Goyal * Creates $workdir/work/incompat/volatile/dirty file if it is not already 1105c86243b0SVivek Goyal * present. 1106c86243b0SVivek Goyal */ 1107c86243b0SVivek Goyal static int ovl_create_volatile_dirty(struct ovl_fs *ofs) 1108c86243b0SVivek Goyal { 1109c86243b0SVivek Goyal unsigned int ctr; 1110c86243b0SVivek Goyal struct dentry *d = dget(ofs->workbasedir); 1111c86243b0SVivek Goyal static const char *const volatile_path[] = { 1112c86243b0SVivek Goyal OVL_WORKDIR_NAME, "incompat", "volatile", "dirty" 1113c86243b0SVivek Goyal }; 1114c86243b0SVivek Goyal const char *const *name = volatile_path; 1115c86243b0SVivek Goyal 1116c86243b0SVivek Goyal for (ctr = ARRAY_SIZE(volatile_path); ctr; ctr--, name++) { 1117576bb263SChristian Brauner d = ovl_lookup_or_create(ofs, d, *name, ctr > 1 ? S_IFDIR : S_IFREG); 1118c86243b0SVivek Goyal if (IS_ERR(d)) 1119c86243b0SVivek Goyal return PTR_ERR(d); 1120c86243b0SVivek Goyal } 1121c86243b0SVivek Goyal dput(d); 1122c86243b0SVivek Goyal return 0; 1123c86243b0SVivek Goyal } 1124c86243b0SVivek Goyal 1125146d62e5SAmir Goldstein static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs, 11262d343087SAl Viro const struct path *workpath) 11278ed61dc3SMiklos Szeredi { 112808f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 11292b1a7746SMiklos Szeredi struct dentry *workdir; 11302b1a7746SMiklos Szeredi struct file *tmpfile; 1131d80172c2SAmir Goldstein bool rename_whiteout; 1132d80172c2SAmir Goldstein bool d_type; 1133e487d889SAmir Goldstein int fh_type; 11348ed61dc3SMiklos Szeredi int err; 11358ed61dc3SMiklos Szeredi 11362ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 11372ba9d57eSAmir Goldstein if (err) 11382ba9d57eSAmir Goldstein return err; 11392ba9d57eSAmir Goldstein 1140235ce9edSAmir Goldstein workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 1141235ce9edSAmir Goldstein err = PTR_ERR(workdir); 1142235ce9edSAmir Goldstein if (IS_ERR_OR_NULL(workdir)) 11432ba9d57eSAmir Goldstein goto out; 11448ed61dc3SMiklos Szeredi 1145235ce9edSAmir Goldstein ofs->workdir = workdir; 1146235ce9edSAmir Goldstein 1147146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir"); 1148146d62e5SAmir Goldstein if (err) 1149146d62e5SAmir Goldstein goto out; 1150146d62e5SAmir Goldstein 11518ed61dc3SMiklos Szeredi /* 11528ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 11538ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 11548ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 11558ed61dc3SMiklos Szeredi * previous step. 11568ed61dc3SMiklos Szeredi */ 11578ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 11588ed61dc3SMiklos Szeredi if (err < 0) 11592ba9d57eSAmir Goldstein goto out; 11608ed61dc3SMiklos Szeredi 1161d80172c2SAmir Goldstein d_type = err; 1162d80172c2SAmir Goldstein if (!d_type) 11631bd0a3aeSlijiazi pr_warn("upper fs needs to support d_type.\n"); 11648ed61dc3SMiklos Szeredi 11658ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 11662b1a7746SMiklos Szeredi tmpfile = ovl_do_tmpfile(ofs, ofs->workdir, S_IFREG | 0); 11672b1a7746SMiklos Szeredi ofs->tmpfile = !IS_ERR(tmpfile); 1168ad204488SMiklos Szeredi if (ofs->tmpfile) 11692b1a7746SMiklos Szeredi fput(tmpfile); 11708ed61dc3SMiklos Szeredi else 11711bd0a3aeSlijiazi pr_warn("upper fs does not support tmpfile.\n"); 11728ed61dc3SMiklos Szeredi 1173cad218abSAmir Goldstein 1174cad218abSAmir Goldstein /* Check if upper/work fs supports RENAME_WHITEOUT */ 1175576bb263SChristian Brauner err = ovl_check_rename_whiteout(ofs); 1176cad218abSAmir Goldstein if (err < 0) 1177cad218abSAmir Goldstein goto out; 1178cad218abSAmir Goldstein 1179d80172c2SAmir Goldstein rename_whiteout = err; 1180d80172c2SAmir Goldstein if (!rename_whiteout) 1181cad218abSAmir Goldstein pr_warn("upper fs does not support RENAME_WHITEOUT.\n"); 1182cad218abSAmir Goldstein 11838ed61dc3SMiklos Szeredi /* 11842d2f2d73SMiklos Szeredi * Check if upper/work fs supports (trusted|user).overlay.* xattr 11858ed61dc3SMiklos Szeredi */ 1186c914c0e2SAmir Goldstein err = ovl_setxattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE, "0", 1); 11878ed61dc3SMiklos Szeredi if (err) { 1188b10b85feSMiklos Szeredi pr_warn("failed to set xattr on upper\n"); 1189ad204488SMiklos Szeredi ofs->noxattr = true; 1190af5f2396SAmir Goldstein if (ovl_redirect_follow(ofs)) { 1191af5f2396SAmir Goldstein ofs->config.redirect_mode = OVL_REDIRECT_NOFOLLOW; 1192af5f2396SAmir Goldstein pr_warn("...falling back to redirect_dir=nofollow.\n"); 1193af5f2396SAmir Goldstein } 1194af5f2396SAmir Goldstein if (ofs->config.metacopy) { 1195d5791044SVivek Goyal ofs->config.metacopy = false; 1196af5f2396SAmir Goldstein pr_warn("...falling back to metacopy=off.\n"); 1197af5f2396SAmir Goldstein } 1198af5f2396SAmir Goldstein if (ofs->config.index) { 1199af5f2396SAmir Goldstein ofs->config.index = false; 1200af5f2396SAmir Goldstein pr_warn("...falling back to index=off.\n"); 1201b0e0f697SAmir Goldstein } 1202b0e0f697SAmir Goldstein /* 1203b0e0f697SAmir Goldstein * xattr support is required for persistent st_ino. 1204b0e0f697SAmir Goldstein * Without persistent st_ino, xino=auto falls back to xino=off. 1205b0e0f697SAmir Goldstein */ 1206b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO) { 1207b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 1208b10b85feSMiklos Szeredi pr_warn("...falling back to xino=off.\n"); 1209b0e0f697SAmir Goldstein } 1210b10b85feSMiklos Szeredi if (err == -EPERM && !ofs->config.userxattr) 1211b10b85feSMiklos Szeredi pr_info("try mounting with 'userxattr' option\n"); 12122ba9d57eSAmir Goldstein err = 0; 12138ed61dc3SMiklos Szeredi } else { 1214c914c0e2SAmir Goldstein ovl_removexattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE); 12158ed61dc3SMiklos Szeredi } 12168ed61dc3SMiklos Szeredi 1217d80172c2SAmir Goldstein /* 1218d80172c2SAmir Goldstein * We allowed sub-optimal upper fs configuration and don't want to break 1219d80172c2SAmir Goldstein * users over kernel upgrade, but we never allowed remote upper fs, so 1220d80172c2SAmir Goldstein * we can enforce strict requirements for remote upper fs. 1221d80172c2SAmir Goldstein */ 1222d80172c2SAmir Goldstein if (ovl_dentry_remote(ofs->workdir) && 1223d80172c2SAmir Goldstein (!d_type || !rename_whiteout || ofs->noxattr)) { 1224d80172c2SAmir Goldstein pr_err("upper fs missing required features.\n"); 1225d80172c2SAmir Goldstein err = -EINVAL; 1226d80172c2SAmir Goldstein goto out; 1227d80172c2SAmir Goldstein } 1228d80172c2SAmir Goldstein 1229c86243b0SVivek Goyal /* 1230c86243b0SVivek Goyal * For volatile mount, create a incompat/volatile/dirty file to keep 1231c86243b0SVivek Goyal * track of it. 1232c86243b0SVivek Goyal */ 1233c86243b0SVivek Goyal if (ofs->config.ovl_volatile) { 1234c86243b0SVivek Goyal err = ovl_create_volatile_dirty(ofs); 1235c86243b0SVivek Goyal if (err < 0) { 1236c86243b0SVivek Goyal pr_err("Failed to create volatile/dirty file.\n"); 1237c86243b0SVivek Goyal goto out; 1238c86243b0SVivek Goyal } 1239c86243b0SVivek Goyal } 1240c86243b0SVivek Goyal 12418ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 1242e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 1243e487d889SAmir Goldstein if (ofs->config.index && !fh_type) { 1244ad204488SMiklos Szeredi ofs->config.index = false; 12451bd0a3aeSlijiazi pr_warn("upper fs does not support file handles, falling back to index=off.\n"); 12468ed61dc3SMiklos Szeredi } 12478ed61dc3SMiklos Szeredi 1248e487d889SAmir Goldstein /* Check if upper fs has 32bit inode numbers */ 1249e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 12500f831ec8SAmir Goldstein ofs->xino_mode = -1; 1251e487d889SAmir Goldstein 1252f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */ 1253f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) { 12541bd0a3aeSlijiazi pr_warn("NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 1255f168f109SAmir Goldstein ofs->config.nfs_export = false; 1256f168f109SAmir Goldstein } 12572ba9d57eSAmir Goldstein out: 12582ba9d57eSAmir Goldstein mnt_drop_write(mnt); 12592ba9d57eSAmir Goldstein return err; 12608ed61dc3SMiklos Szeredi } 12618ed61dc3SMiklos Szeredi 1262146d62e5SAmir Goldstein static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs, 1263*b36a5780SChristian Brauner const struct path *upperpath, 1264*b36a5780SChristian Brauner const struct path *workpath) 1265520d7c86SMiklos Szeredi { 1266520d7c86SMiklos Szeredi int err; 1267520d7c86SMiklos Szeredi 1268520d7c86SMiklos Szeredi err = -EINVAL; 1269*b36a5780SChristian Brauner if (upperpath->mnt != workpath->mnt) { 12701bd0a3aeSlijiazi pr_err("workdir and upperdir must reside under the same mount\n"); 1271*b36a5780SChristian Brauner return err; 1272520d7c86SMiklos Szeredi } 1273*b36a5780SChristian Brauner if (!ovl_workdir_ok(workpath->dentry, upperpath->dentry)) { 12741bd0a3aeSlijiazi pr_err("workdir and upperdir must be separate subtrees\n"); 1275*b36a5780SChristian Brauner return err; 1276520d7c86SMiklos Szeredi } 1277520d7c86SMiklos Szeredi 1278*b36a5780SChristian Brauner ofs->workbasedir = dget(workpath->dentry); 12798c25741aSMiklos Szeredi 12808c25741aSMiklos Szeredi if (ovl_inuse_trylock(ofs->workbasedir)) { 1281ad204488SMiklos Szeredi ofs->workdir_locked = true; 1282520d7c86SMiklos Szeredi } else { 12830be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "workdir"); 12840be0bfd2SAmir Goldstein if (err) 1285*b36a5780SChristian Brauner return err; 1286520d7c86SMiklos Szeredi } 1287520d7c86SMiklos Szeredi 12880be0bfd2SAmir Goldstein err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap, 12890be0bfd2SAmir Goldstein "workdir"); 12900be0bfd2SAmir Goldstein if (err) 1291520d7c86SMiklos Szeredi return err; 1292*b36a5780SChristian Brauner 1293*b36a5780SChristian Brauner return ovl_make_workdir(sb, ofs, workpath); 1294520d7c86SMiklos Szeredi } 1295520d7c86SMiklos Szeredi 1296146d62e5SAmir Goldstein static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs, 12972d343087SAl Viro struct ovl_entry *oe, const struct path *upperpath) 1298f7e3a7d9SMiklos Szeredi { 129908f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 1300235ce9edSAmir Goldstein struct dentry *indexdir; 1301f7e3a7d9SMiklos Szeredi int err; 1302f7e3a7d9SMiklos Szeredi 13032ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 13042ba9d57eSAmir Goldstein if (err) 13052ba9d57eSAmir Goldstein return err; 13062ba9d57eSAmir Goldstein 1307f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 1308610afc0bSMiklos Szeredi err = ovl_verify_origin(ofs, upperpath->dentry, 13095522c9c7SAmir Goldstein ovl_lowerstack(oe)->dentry, true); 1310f7e3a7d9SMiklos Szeredi if (err) { 13111bd0a3aeSlijiazi pr_err("failed to verify upper root origin\n"); 1312f7e3a7d9SMiklos Szeredi goto out; 1313f7e3a7d9SMiklos Szeredi } 1314f7e3a7d9SMiklos Szeredi 131520396365SAmir Goldstein /* index dir will act also as workdir */ 131620396365SAmir Goldstein iput(ofs->workdir_trap); 131720396365SAmir Goldstein ofs->workdir_trap = NULL; 131820396365SAmir Goldstein dput(ofs->workdir); 1319470c1563SAmir Goldstein ofs->workdir = NULL; 1320235ce9edSAmir Goldstein indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1321235ce9edSAmir Goldstein if (IS_ERR(indexdir)) { 1322235ce9edSAmir Goldstein err = PTR_ERR(indexdir); 1323235ce9edSAmir Goldstein } else if (indexdir) { 1324235ce9edSAmir Goldstein ofs->indexdir = indexdir; 1325235ce9edSAmir Goldstein ofs->workdir = dget(indexdir); 132620396365SAmir Goldstein 1327146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap, 1328146d62e5SAmir Goldstein "indexdir"); 1329146d62e5SAmir Goldstein if (err) 1330146d62e5SAmir Goldstein goto out; 1331146d62e5SAmir Goldstein 1332ad1d615cSAmir Goldstein /* 1333ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir. 13342d2f2d73SMiklos Szeredi * Older kernels stored upper fh in ".overlay.origin" 1335ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to 1336ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr 13372d2f2d73SMiklos Szeredi * ".overlay.upper" to indicate that index may have 1338ad1d615cSAmir Goldstein * directory entries. 1339ad1d615cSAmir Goldstein */ 1340610afc0bSMiklos Szeredi if (ovl_check_origin_xattr(ofs, ofs->indexdir)) { 1341610afc0bSMiklos Szeredi err = ovl_verify_set_fh(ofs, ofs->indexdir, 1342610afc0bSMiklos Szeredi OVL_XATTR_ORIGIN, 1343ad1d615cSAmir Goldstein upperpath->dentry, true, false); 1344f7e3a7d9SMiklos Szeredi if (err) 13451bd0a3aeSlijiazi pr_err("failed to verify index dir 'origin' xattr\n"); 1346ad1d615cSAmir Goldstein } 1347610afc0bSMiklos Szeredi err = ovl_verify_upper(ofs, ofs->indexdir, upperpath->dentry, 1348610afc0bSMiklos Szeredi true); 1349ad1d615cSAmir Goldstein if (err) 13501bd0a3aeSlijiazi pr_err("failed to verify index dir 'upper' xattr\n"); 1351f7e3a7d9SMiklos Szeredi 1352f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 1353f7e3a7d9SMiklos Szeredi if (!err) 13541eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs); 1355f7e3a7d9SMiklos Szeredi } 1356ad204488SMiklos Szeredi if (err || !ofs->indexdir) 13571bd0a3aeSlijiazi pr_warn("try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1358f7e3a7d9SMiklos Szeredi 1359f7e3a7d9SMiklos Szeredi out: 13602ba9d57eSAmir Goldstein mnt_drop_write(mnt); 1361f7e3a7d9SMiklos Szeredi return err; 1362f7e3a7d9SMiklos Szeredi } 1363f7e3a7d9SMiklos Szeredi 13649df085f3SAmir Goldstein static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid) 13655148626bSAmir Goldstein { 13665148626bSAmir Goldstein unsigned int i; 13679df085f3SAmir Goldstein 136808f4c7c8SMiklos Szeredi if (!ofs->config.nfs_export && !ovl_upper_mnt(ofs)) 13699df085f3SAmir Goldstein return true; 13709df085f3SAmir Goldstein 1371a888db31SAmir Goldstein /* 1372a888db31SAmir Goldstein * We allow using single lower with null uuid for index and nfs_export 1373a888db31SAmir Goldstein * for example to support those features with single lower squashfs. 1374a888db31SAmir Goldstein * To avoid regressions in setups of overlay with re-formatted lower 1375a888db31SAmir Goldstein * squashfs, do not allow decoding origin with lower null uuid unless 1376a888db31SAmir Goldstein * user opted-in to one of the new features that require following the 1377a888db31SAmir Goldstein * lower inode of non-dir upper. 1378a888db31SAmir Goldstein */ 1379ca45275cSVyacheslav Yurkov if (ovl_allow_offline_changes(ofs) && uuid_is_null(uuid)) 1380a888db31SAmir Goldstein return false; 1381a888db31SAmir Goldstein 13821b81ddddSAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 13839df085f3SAmir Goldstein /* 13849df085f3SAmir Goldstein * We use uuid to associate an overlay lower file handle with a 13859df085f3SAmir Goldstein * lower layer, so we can accept lower fs with null uuid as long 13869df085f3SAmir Goldstein * as all lower layers with null uuid are on the same fs. 13877e63c87fSAmir Goldstein * if we detect multiple lower fs with the same uuid, we 13887e63c87fSAmir Goldstein * disable lower file handle decoding on all of them. 13899df085f3SAmir Goldstein */ 13901b81ddddSAmir Goldstein if (ofs->fs[i].is_lower && 13911b81ddddSAmir Goldstein uuid_equal(&ofs->fs[i].sb->s_uuid, uuid)) { 139207f1e596SAmir Goldstein ofs->fs[i].bad_uuid = true; 13939df085f3SAmir Goldstein return false; 13949df085f3SAmir Goldstein } 13957e63c87fSAmir Goldstein } 13969df085f3SAmir Goldstein return true; 13979df085f3SAmir Goldstein } 13989df085f3SAmir Goldstein 13999df085f3SAmir Goldstein /* Get a unique fsid for the layer */ 14009df085f3SAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) 14019df085f3SAmir Goldstein { 14029df085f3SAmir Goldstein struct super_block *sb = path->mnt->mnt_sb; 14039df085f3SAmir Goldstein unsigned int i; 14045148626bSAmir Goldstein dev_t dev; 14055148626bSAmir Goldstein int err; 14067e63c87fSAmir Goldstein bool bad_uuid = false; 1407b0e0f697SAmir Goldstein bool warn = false; 14085148626bSAmir Goldstein 140907f1e596SAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 141007f1e596SAmir Goldstein if (ofs->fs[i].sb == sb) 141107f1e596SAmir Goldstein return i; 14125148626bSAmir Goldstein } 14135148626bSAmir Goldstein 14149df085f3SAmir Goldstein if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) { 14157e63c87fSAmir Goldstein bad_uuid = true; 1416b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO) { 1417b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 1418b0e0f697SAmir Goldstein warn = true; 1419b0e0f697SAmir Goldstein } 14207e63c87fSAmir Goldstein if (ofs->config.index || ofs->config.nfs_export) { 14219df085f3SAmir Goldstein ofs->config.index = false; 14229df085f3SAmir Goldstein ofs->config.nfs_export = false; 1423b0e0f697SAmir Goldstein warn = true; 1424b0e0f697SAmir Goldstein } 1425b0e0f697SAmir Goldstein if (warn) { 1426b0e0f697SAmir Goldstein pr_warn("%s uuid detected in lower fs '%pd2', falling back to xino=%s,index=off,nfs_export=off.\n", 14277e63c87fSAmir Goldstein uuid_is_null(&sb->s_uuid) ? "null" : 14287e63c87fSAmir Goldstein "conflicting", 1429dcb399deSAmir Goldstein path->dentry, ovl_xino_mode(&ofs->config)); 14309df085f3SAmir Goldstein } 14317e63c87fSAmir Goldstein } 14329df085f3SAmir Goldstein 14335148626bSAmir Goldstein err = get_anon_bdev(&dev); 14345148626bSAmir Goldstein if (err) { 14351bd0a3aeSlijiazi pr_err("failed to get anonymous bdev for lowerpath\n"); 14365148626bSAmir Goldstein return err; 14375148626bSAmir Goldstein } 14385148626bSAmir Goldstein 143907f1e596SAmir Goldstein ofs->fs[ofs->numfs].sb = sb; 144007f1e596SAmir Goldstein ofs->fs[ofs->numfs].pseudo_dev = dev; 144107f1e596SAmir Goldstein ofs->fs[ofs->numfs].bad_uuid = bad_uuid; 14425148626bSAmir Goldstein 144307f1e596SAmir Goldstein return ofs->numfs++; 14445148626bSAmir Goldstein } 14455148626bSAmir Goldstein 144637ebf056SAmir Goldstein /* 144737ebf056SAmir Goldstein * The fsid after the last lower fsid is used for the data layers. 144837ebf056SAmir Goldstein * It is a "null fs" with a null sb, null uuid, and no pseudo dev. 144937ebf056SAmir Goldstein */ 145037ebf056SAmir Goldstein static int ovl_get_data_fsid(struct ovl_fs *ofs) 145137ebf056SAmir Goldstein { 145237ebf056SAmir Goldstein return ofs->numfs; 145337ebf056SAmir Goldstein } 145437ebf056SAmir Goldstein 145537ebf056SAmir Goldstein 145694375f9dSAmir Goldstein static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, 1457*b36a5780SChristian Brauner struct ovl_fs_context *ctx, struct ovl_layer *layers) 1458520d7c86SMiklos Szeredi { 1459520d7c86SMiklos Szeredi int err; 1460520d7c86SMiklos Szeredi unsigned int i; 1461*b36a5780SChristian Brauner size_t nr_merged_lower; 1462520d7c86SMiklos Szeredi 1463*b36a5780SChristian Brauner ofs->fs = kcalloc(ctx->nr + 2, sizeof(struct ovl_sb), GFP_KERNEL); 146407f1e596SAmir Goldstein if (ofs->fs == NULL) 14659e88f905SAmir Goldstein return -ENOMEM; 14665148626bSAmir Goldstein 146737ebf056SAmir Goldstein /* 146837ebf056SAmir Goldstein * idx/fsid 0 are reserved for upper fs even with lower only overlay 146937ebf056SAmir Goldstein * and the last fsid is reserved for "null fs" of the data layers. 147037ebf056SAmir Goldstein */ 147107f1e596SAmir Goldstein ofs->numfs++; 147207f1e596SAmir Goldstein 147307f1e596SAmir Goldstein /* 1474b7bf9908SAmir Goldstein * All lower layers that share the same fs as upper layer, use the same 1475b7bf9908SAmir Goldstein * pseudo_dev as upper layer. Allocate fs[0].pseudo_dev even for lower 1476b7bf9908SAmir Goldstein * only overlay to simplify ovl_fs_free(). 14771b81ddddSAmir Goldstein * is_lower will be set if upper fs is shared with a lower layer. 147807f1e596SAmir Goldstein */ 1479b7bf9908SAmir Goldstein err = get_anon_bdev(&ofs->fs[0].pseudo_dev); 1480b7bf9908SAmir Goldstein if (err) { 1481b7bf9908SAmir Goldstein pr_err("failed to get anonymous bdev for upper fs\n"); 14829e88f905SAmir Goldstein return err; 1483b7bf9908SAmir Goldstein } 1484b7bf9908SAmir Goldstein 148508f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 148608f4c7c8SMiklos Szeredi ofs->fs[0].sb = ovl_upper_mnt(ofs)->mnt_sb; 14871b81ddddSAmir Goldstein ofs->fs[0].is_lower = false; 148807f1e596SAmir Goldstein } 148907f1e596SAmir Goldstein 1490*b36a5780SChristian Brauner nr_merged_lower = ctx->nr - ctx->nr_data; 1491*b36a5780SChristian Brauner for (i = 0; i < ctx->nr; i++) { 1492*b36a5780SChristian Brauner struct ovl_fs_context_layer *l = &ctx->lower[i]; 1493520d7c86SMiklos Szeredi struct vfsmount *mnt; 1494146d62e5SAmir Goldstein struct inode *trap; 14955148626bSAmir Goldstein int fsid; 1496520d7c86SMiklos Szeredi 1497*b36a5780SChristian Brauner if (i < nr_merged_lower) 1498*b36a5780SChristian Brauner fsid = ovl_get_fsid(ofs, &l->path); 149937ebf056SAmir Goldstein else 150037ebf056SAmir Goldstein fsid = ovl_get_data_fsid(ofs); 15019e88f905SAmir Goldstein if (fsid < 0) 15029e88f905SAmir Goldstein return fsid; 1503520d7c86SMiklos Szeredi 150424f14009Syoungjun /* 150524f14009Syoungjun * Check if lower root conflicts with this overlay layers before 150624f14009Syoungjun * checking if it is in-use as upperdir/workdir of "another" 150724f14009Syoungjun * mount, because we do not bother to check in ovl_is_inuse() if 150824f14009Syoungjun * the upperdir/workdir is in fact in-use by our 150924f14009Syoungjun * upperdir/workdir. 151024f14009Syoungjun */ 1511*b36a5780SChristian Brauner err = ovl_setup_trap(sb, l->path.dentry, &trap, "lowerdir"); 1512146d62e5SAmir Goldstein if (err) 15139e88f905SAmir Goldstein return err; 1514146d62e5SAmir Goldstein 1515*b36a5780SChristian Brauner if (ovl_is_inuse(l->path.dentry)) { 15160be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "lowerdir"); 151724f14009Syoungjun if (err) { 151824f14009Syoungjun iput(trap); 15199e88f905SAmir Goldstein return err; 15200be0bfd2SAmir Goldstein } 152124f14009Syoungjun } 15220be0bfd2SAmir Goldstein 1523*b36a5780SChristian Brauner mnt = clone_private_mount(&l->path); 1524520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1525520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 15261bd0a3aeSlijiazi pr_err("failed to clone lowerpath\n"); 1527146d62e5SAmir Goldstein iput(trap); 15289e88f905SAmir Goldstein return err; 1529520d7c86SMiklos Szeredi } 15305148626bSAmir Goldstein 1531520d7c86SMiklos Szeredi /* 1532520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1533520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1534520d7c86SMiklos Szeredi */ 1535520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1536520d7c86SMiklos Szeredi 153713464165SMiklos Szeredi layers[ofs->numlayer].trap = trap; 153813464165SMiklos Szeredi layers[ofs->numlayer].mnt = mnt; 153913464165SMiklos Szeredi layers[ofs->numlayer].idx = ofs->numlayer; 154013464165SMiklos Szeredi layers[ofs->numlayer].fsid = fsid; 154113464165SMiklos Szeredi layers[ofs->numlayer].fs = &ofs->fs[fsid]; 1542*b36a5780SChristian Brauner layers[ofs->numlayer].name = l->name; 1543*b36a5780SChristian Brauner l->name = NULL; 154494375f9dSAmir Goldstein ofs->numlayer++; 15451b81ddddSAmir Goldstein ofs->fs[fsid].is_lower = true; 1546520d7c86SMiklos Szeredi } 1547e487d889SAmir Goldstein 1548795939a9SAmir Goldstein /* 1549795939a9SAmir Goldstein * When all layers on same fs, overlay can use real inode numbers. 1550926e94d7SAmir Goldstein * With mount option "xino=<on|auto>", mounter declares that there are 1551926e94d7SAmir Goldstein * enough free high bits in underlying fs to hold the unique fsid. 1552795939a9SAmir Goldstein * If overlayfs does encounter underlying inodes using the high xino 1553795939a9SAmir Goldstein * bits reserved for fsid, it emits a warning and uses the original 1554dfe51d47SAmir Goldstein * inode number or a non persistent inode number allocated from a 1555dfe51d47SAmir Goldstein * dedicated range. 1556795939a9SAmir Goldstein */ 155708f4c7c8SMiklos Szeredi if (ofs->numfs - !ovl_upper_mnt(ofs) == 1) { 15580f831ec8SAmir Goldstein if (ofs->config.xino == OVL_XINO_ON) 15590f831ec8SAmir Goldstein pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n"); 15600f831ec8SAmir Goldstein ofs->xino_mode = 0; 156153afcd31SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_OFF) { 156253afcd31SAmir Goldstein ofs->xino_mode = -1; 1563926e94d7SAmir Goldstein } else if (ofs->xino_mode < 0) { 1564795939a9SAmir Goldstein /* 156507f1e596SAmir Goldstein * This is a roundup of number of bits needed for encoding 1566dfe51d47SAmir Goldstein * fsid, where fsid 0 is reserved for upper fs (even with 1567dfe51d47SAmir Goldstein * lower only overlay) +1 extra bit is reserved for the non 1568dfe51d47SAmir Goldstein * persistent inode number range that is used for resolving 1569dfe51d47SAmir Goldstein * xino lower bits overflow. 1570795939a9SAmir Goldstein */ 1571dfe51d47SAmir Goldstein BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 30); 1572dfe51d47SAmir Goldstein ofs->xino_mode = ilog2(ofs->numfs - 1) + 2; 1573795939a9SAmir Goldstein } 1574795939a9SAmir Goldstein 15750f831ec8SAmir Goldstein if (ofs->xino_mode > 0) { 15761bd0a3aeSlijiazi pr_info("\"xino\" feature enabled using %d upper inode bits.\n", 15770f831ec8SAmir Goldstein ofs->xino_mode); 1578795939a9SAmir Goldstein } 1579e487d889SAmir Goldstein 15809e88f905SAmir Goldstein return 0; 1581520d7c86SMiklos Szeredi } 1582520d7c86SMiklos Szeredi 15834155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1584*b36a5780SChristian Brauner struct ovl_fs_context *ctx, 1585*b36a5780SChristian Brauner struct ovl_fs *ofs, 1586*b36a5780SChristian Brauner struct ovl_layer *layers) 158753dbb0b4SMiklos Szeredi { 158853dbb0b4SMiklos Szeredi int err; 1589b8e42a65SMiklos Szeredi unsigned int i; 1590*b36a5780SChristian Brauner size_t nr_merged_lower; 15914155c10aSMiklos Szeredi struct ovl_entry *oe; 1592*b36a5780SChristian Brauner struct ovl_path *lowerstack; 159353dbb0b4SMiklos Szeredi 1594*b36a5780SChristian Brauner struct ovl_fs_context_layer *l; 1595*b36a5780SChristian Brauner 1596*b36a5780SChristian Brauner if (!ofs->config.upperdir && ctx->nr == 1) { 15971bd0a3aeSlijiazi pr_err("at least 2 lowerdir are needed while upperdir nonexistent\n"); 1598b8e42a65SMiklos Szeredi return ERR_PTR(-EINVAL); 159953dbb0b4SMiklos Szeredi } 160053dbb0b4SMiklos Szeredi 160137ebf056SAmir Goldstein err = -EINVAL; 1602*b36a5780SChristian Brauner for (i = 0; i < ctx->nr; i++) { 1603*b36a5780SChristian Brauner l = &ctx->lower[i]; 160437ebf056SAmir Goldstein 1605*b36a5780SChristian Brauner err = ovl_lower_dir(l->name, &l->path, ofs, &sb->s_stack_depth); 1606*b36a5780SChristian Brauner if (err) 1607*b36a5780SChristian Brauner return ERR_PTR(err); 160853dbb0b4SMiklos Szeredi } 160953dbb0b4SMiklos Szeredi 161053dbb0b4SMiklos Szeredi err = -EINVAL; 161153dbb0b4SMiklos Szeredi sb->s_stack_depth++; 161253dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 16131bd0a3aeSlijiazi pr_err("maximum fs stacking depth exceeded\n"); 1614*b36a5780SChristian Brauner return ERR_PTR(err); 161553dbb0b4SMiklos Szeredi } 161653dbb0b4SMiklos Szeredi 1617*b36a5780SChristian Brauner err = ovl_get_layers(sb, ofs, ctx, layers); 16184155c10aSMiklos Szeredi if (err) 1619*b36a5780SChristian Brauner return ERR_PTR(err); 16204155c10aSMiklos Szeredi 16214155c10aSMiklos Szeredi err = -ENOMEM; 162237ebf056SAmir Goldstein /* Data-only layers are not merged in root directory */ 1623*b36a5780SChristian Brauner nr_merged_lower = ctx->nr - ctx->nr_data; 1624*b36a5780SChristian Brauner oe = ovl_alloc_entry(nr_merged_lower); 16254155c10aSMiklos Szeredi if (!oe) 1626*b36a5780SChristian Brauner return ERR_PTR(err); 16274155c10aSMiklos Szeredi 16285522c9c7SAmir Goldstein lowerstack = ovl_lowerstack(oe); 1629*b36a5780SChristian Brauner for (i = 0; i < nr_merged_lower; i++) { 1630*b36a5780SChristian Brauner l = &ctx->lower[i]; 1631*b36a5780SChristian Brauner lowerstack[i].dentry = dget(l->path.dentry); 16325522c9c7SAmir Goldstein lowerstack[i].layer = &ofs->layers[i + 1]; 16334155c10aSMiklos Szeredi } 1634*b36a5780SChristian Brauner ofs->numdatalayer = ctx->nr_data; 16354155c10aSMiklos Szeredi 16364155c10aSMiklos Szeredi return oe; 163753dbb0b4SMiklos Szeredi } 163853dbb0b4SMiklos Szeredi 1639146d62e5SAmir Goldstein /* 1640146d62e5SAmir Goldstein * Check if this layer root is a descendant of: 1641146d62e5SAmir Goldstein * - another layer of this overlayfs instance 1642146d62e5SAmir Goldstein * - upper/work dir of any overlayfs instance 1643146d62e5SAmir Goldstein */ 16440be0bfd2SAmir Goldstein static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs, 1645708fa015SMiklos Szeredi struct dentry *dentry, const char *name, 1646708fa015SMiklos Szeredi bool is_lower) 1647146d62e5SAmir Goldstein { 16489179c21dSMiklos Szeredi struct dentry *next = dentry, *parent; 1649146d62e5SAmir Goldstein int err = 0; 1650146d62e5SAmir Goldstein 16519179c21dSMiklos Szeredi if (!dentry) 1652146d62e5SAmir Goldstein return 0; 1653146d62e5SAmir Goldstein 1654146d62e5SAmir Goldstein parent = dget_parent(next); 16559179c21dSMiklos Szeredi 16569179c21dSMiklos Szeredi /* Walk back ancestors to root (inclusive) looking for traps */ 16579179c21dSMiklos Szeredi while (!err && parent != next) { 1658708fa015SMiklos Szeredi if (is_lower && ovl_lookup_trap_inode(sb, parent)) { 1659146d62e5SAmir Goldstein err = -ELOOP; 16601bd0a3aeSlijiazi pr_err("overlapping %s path\n", name); 16610be0bfd2SAmir Goldstein } else if (ovl_is_inuse(parent)) { 16620be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, name); 1663146d62e5SAmir Goldstein } 1664146d62e5SAmir Goldstein next = parent; 16659179c21dSMiklos Szeredi parent = dget_parent(next); 16669179c21dSMiklos Szeredi dput(next); 1667146d62e5SAmir Goldstein } 1668146d62e5SAmir Goldstein 16699179c21dSMiklos Szeredi dput(parent); 1670146d62e5SAmir Goldstein 1671146d62e5SAmir Goldstein return err; 1672146d62e5SAmir Goldstein } 1673146d62e5SAmir Goldstein 1674146d62e5SAmir Goldstein /* 1675146d62e5SAmir Goldstein * Check if any of the layers or work dirs overlap. 1676146d62e5SAmir Goldstein */ 1677146d62e5SAmir Goldstein static int ovl_check_overlapping_layers(struct super_block *sb, 1678146d62e5SAmir Goldstein struct ovl_fs *ofs) 1679146d62e5SAmir Goldstein { 1680146d62e5SAmir Goldstein int i, err; 1681146d62e5SAmir Goldstein 168208f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 168308f4c7c8SMiklos Szeredi err = ovl_check_layer(sb, ofs, ovl_upper_mnt(ofs)->mnt_root, 1684708fa015SMiklos Szeredi "upperdir", false); 1685146d62e5SAmir Goldstein if (err) 1686146d62e5SAmir Goldstein return err; 1687146d62e5SAmir Goldstein 1688146d62e5SAmir Goldstein /* 1689146d62e5SAmir Goldstein * Checking workbasedir avoids hitting ovl_is_inuse(parent) of 1690146d62e5SAmir Goldstein * this instance and covers overlapping work and index dirs, 1691146d62e5SAmir Goldstein * unless work or index dir have been moved since created inside 1692146d62e5SAmir Goldstein * workbasedir. In that case, we already have their traps in 1693146d62e5SAmir Goldstein * inode cache and we will catch that case on lookup. 1694146d62e5SAmir Goldstein */ 1695708fa015SMiklos Szeredi err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir", 1696708fa015SMiklos Szeredi false); 1697146d62e5SAmir Goldstein if (err) 1698146d62e5SAmir Goldstein return err; 1699146d62e5SAmir Goldstein } 1700146d62e5SAmir Goldstein 170194375f9dSAmir Goldstein for (i = 1; i < ofs->numlayer; i++) { 17020be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, 170394375f9dSAmir Goldstein ofs->layers[i].mnt->mnt_root, 1704708fa015SMiklos Szeredi "lowerdir", true); 1705146d62e5SAmir Goldstein if (err) 1706146d62e5SAmir Goldstein return err; 1707146d62e5SAmir Goldstein } 1708146d62e5SAmir Goldstein 1709146d62e5SAmir Goldstein return 0; 1710146d62e5SAmir Goldstein } 1711146d62e5SAmir Goldstein 17122effc5c2SAmir Goldstein static struct dentry *ovl_get_root(struct super_block *sb, 17132effc5c2SAmir Goldstein struct dentry *upperdentry, 17142effc5c2SAmir Goldstein struct ovl_entry *oe) 17152effc5c2SAmir Goldstein { 17162effc5c2SAmir Goldstein struct dentry *root; 17175522c9c7SAmir Goldstein struct ovl_path *lowerpath = ovl_lowerstack(oe); 171862c832edSAmir Goldstein unsigned long ino = d_inode(lowerpath->dentry)->i_ino; 171962c832edSAmir Goldstein int fsid = lowerpath->layer->fsid; 172062c832edSAmir Goldstein struct ovl_inode_params oip = { 172162c832edSAmir Goldstein .upperdentry = upperdentry, 17220af950f5SAmir Goldstein .oe = oe, 172362c832edSAmir Goldstein }; 17242effc5c2SAmir Goldstein 17252effc5c2SAmir Goldstein root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 17262effc5c2SAmir Goldstein if (!root) 17272effc5c2SAmir Goldstein return NULL; 17282effc5c2SAmir Goldstein 17292effc5c2SAmir Goldstein if (upperdentry) { 173062c832edSAmir Goldstein /* Root inode uses upper st_ino/i_ino */ 173162c832edSAmir Goldstein ino = d_inode(upperdentry)->i_ino; 173262c832edSAmir Goldstein fsid = 0; 17332effc5c2SAmir Goldstein ovl_dentry_set_upper_alias(root); 1734610afc0bSMiklos Szeredi if (ovl_is_impuredir(sb, upperdentry)) 17352effc5c2SAmir Goldstein ovl_set_flag(OVL_IMPURE, d_inode(root)); 17362effc5c2SAmir Goldstein } 17372effc5c2SAmir Goldstein 17382effc5c2SAmir Goldstein /* Root is always merge -> can have whiteouts */ 17392effc5c2SAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root)); 17402effc5c2SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root); 17412effc5c2SAmir Goldstein ovl_set_upperdata(d_inode(root)); 174262c832edSAmir Goldstein ovl_inode_init(d_inode(root), &oip, ino, fsid); 17430af950f5SAmir Goldstein ovl_dentry_init_flags(root, upperdentry, oe, DCACHE_OP_WEAK_REVALIDATE); 1744367d002dSAmir Goldstein /* root keeps a reference of upperdentry */ 1745367d002dSAmir Goldstein dget(upperdentry); 17462effc5c2SAmir Goldstein 17472effc5c2SAmir Goldstein return root; 17482effc5c2SAmir Goldstein } 17492effc5c2SAmir Goldstein 17501784fbc2SChristian Brauner static int ovl_fill_super(struct super_block *sb, struct fs_context *fc) 1751e9be9d5eSMiklos Szeredi { 17521784fbc2SChristian Brauner struct ovl_fs *ofs = sb->s_fs_info; 17531784fbc2SChristian Brauner struct ovl_fs_context *ctx = fc->fs_private; 1754e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 17554155c10aSMiklos Szeredi struct ovl_entry *oe; 1756b8e42a65SMiklos Szeredi struct ovl_layer *layers; 175751f8f3c4SKonstantin Khlebnikov struct cred *cred; 1758e9be9d5eSMiklos Szeredi int err; 1759e9be9d5eSMiklos Szeredi 17609efb069dSMiklos Szeredi err = -EIO; 17611784fbc2SChristian Brauner if (WARN_ON(fc->user_ns != current_user_ns())) 17621784fbc2SChristian Brauner goto out_err; 17639efb069dSMiklos Szeredi 1764f4288844SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 1765f4288844SMiklos Szeredi 1766f45827e8SErez Zadok err = -ENOMEM; 1767ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1768c6fe6254SMiklos Szeredi if (!cred) 1769c6fe6254SMiklos Szeredi goto out_err; 1770c6fe6254SMiklos Szeredi 17711784fbc2SChristian Brauner err = ovl_fs_params_verify(ctx, &ofs->config); 1772f45827e8SErez Zadok if (err) 1773a9075cdbSMiklos Szeredi goto out_err; 1774f45827e8SErez Zadok 1775e9be9d5eSMiklos Szeredi err = -EINVAL; 1776*b36a5780SChristian Brauner if (ctx->nr == 0) { 17771784fbc2SChristian Brauner if (!(fc->sb_flags & SB_SILENT)) 17781bd0a3aeSlijiazi pr_err("missing 'lowerdir'\n"); 1779a9075cdbSMiklos Szeredi goto out_err; 178053a08cb9SMiklos Szeredi } 178153a08cb9SMiklos Szeredi 1782b8e42a65SMiklos Szeredi err = -ENOMEM; 1783*b36a5780SChristian Brauner layers = kcalloc(ctx->nr + 1, sizeof(struct ovl_layer), GFP_KERNEL); 1784b8e42a65SMiklos Szeredi if (!layers) 1785b8e42a65SMiklos Szeredi goto out_err; 1786b8e42a65SMiklos Szeredi 1787b8e42a65SMiklos Szeredi ofs->layers = layers; 1788b8e42a65SMiklos Szeredi /* Layer 0 is reserved for upper even if there's no upper */ 1789b8e42a65SMiklos Szeredi ofs->numlayer = 1; 1790b8e42a65SMiklos Szeredi 179153a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 1792cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 17934d314f78SAmir Goldstein atomic_long_set(&ofs->last_ino, 1); 17944f119628SWilliam Dean /* Assume underlying fs uses 32bit inodes unless proven otherwise */ 179553afcd31SAmir Goldstein if (ofs->config.xino != OVL_XINO_OFF) { 17960f831ec8SAmir Goldstein ofs->xino_mode = BITS_PER_LONG - 32; 179753afcd31SAmir Goldstein if (!ofs->xino_mode) { 179853afcd31SAmir Goldstein pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n"); 179953afcd31SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 180053afcd31SAmir Goldstein } 180153afcd31SAmir Goldstein } 1802795939a9SAmir Goldstein 1803146d62e5SAmir Goldstein /* alloc/destroy_inode needed for setting up traps in inode cache */ 1804146d62e5SAmir Goldstein sb->s_op = &ovl_super_operations; 1805146d62e5SAmir Goldstein 1806ad204488SMiklos Szeredi if (ofs->config.upperdir) { 1807335d3fc5SSargun Dhillon struct super_block *upper_sb; 1808335d3fc5SSargun Dhillon 1809d7b49b10SChengguang Xu err = -EINVAL; 1810ad204488SMiklos Szeredi if (!ofs->config.workdir) { 18111bd0a3aeSlijiazi pr_err("missing 'workdir'\n"); 1812a9075cdbSMiklos Szeredi goto out_err; 1813e9be9d5eSMiklos Szeredi } 1814e9be9d5eSMiklos Szeredi 1815*b36a5780SChristian Brauner err = ovl_get_upper(sb, ofs, &layers[0], &ctx->upper); 181621a3b317SMiklos Szeredi if (err) 1817a9075cdbSMiklos Szeredi goto out_err; 1818d719e8f2SMiklos Szeredi 1819335d3fc5SSargun Dhillon upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 1820335d3fc5SSargun Dhillon if (!ovl_should_sync(ofs)) { 1821335d3fc5SSargun Dhillon ofs->errseq = errseq_sample(&upper_sb->s_wb_err); 1822335d3fc5SSargun Dhillon if (errseq_check(&upper_sb->s_wb_err, ofs->errseq)) { 1823335d3fc5SSargun Dhillon err = -EIO; 1824335d3fc5SSargun Dhillon pr_err("Cannot mount volatile when upperdir has an unseen error. Sync upperdir fs to clear state.\n"); 1825335d3fc5SSargun Dhillon goto out_err; 1826335d3fc5SSargun Dhillon } 1827335d3fc5SSargun Dhillon } 1828335d3fc5SSargun Dhillon 1829*b36a5780SChristian Brauner err = ovl_get_workdir(sb, ofs, &ctx->upper, &ctx->work); 18308ed61dc3SMiklos Szeredi if (err) 1831a9075cdbSMiklos Szeredi goto out_err; 1832c6fe6254SMiklos Szeredi 1833ad204488SMiklos Szeredi if (!ofs->workdir) 18341751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 18356e88256eSMiklos Szeredi 1836335d3fc5SSargun Dhillon sb->s_stack_depth = upper_sb->s_stack_depth; 1837335d3fc5SSargun Dhillon sb->s_time_gran = upper_sb->s_time_gran; 183821765194SVivek Goyal } 1839*b36a5780SChristian Brauner oe = ovl_get_lowerstack(sb, ctx, ofs, layers); 18404155c10aSMiklos Szeredi err = PTR_ERR(oe); 18414155c10aSMiklos Szeredi if (IS_ERR(oe)) 1842a9075cdbSMiklos Szeredi goto out_err; 1843e9be9d5eSMiklos Szeredi 184471cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 184508f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 18461751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 1847e9be9d5eSMiklos Szeredi 18485830fb6bSPavel Tikhomirov if (!ofs->config.uuid && ofs->numfs > 1) { 18495830fb6bSPavel Tikhomirov pr_warn("The uuid=off requires a single fs for lower and upper, falling back to uuid=on.\n"); 18505830fb6bSPavel Tikhomirov ofs->config.uuid = true; 18515830fb6bSPavel Tikhomirov } 18525830fb6bSPavel Tikhomirov 1853470c1563SAmir Goldstein if (!ovl_force_readonly(ofs) && ofs->config.index) { 1854*b36a5780SChristian Brauner err = ovl_get_indexdir(sb, ofs, oe, &ctx->upper); 185554fb347eSAmir Goldstein if (err) 18564155c10aSMiklos Szeredi goto out_free_oe; 18576e88256eSMiklos Szeredi 1858972d0093SAmir Goldstein /* Force r/o mount with no index dir */ 185920396365SAmir Goldstein if (!ofs->indexdir) 18601751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 186102bcd157SAmir Goldstein } 186202bcd157SAmir Goldstein 1863146d62e5SAmir Goldstein err = ovl_check_overlapping_layers(sb, ofs); 1864146d62e5SAmir Goldstein if (err) 1865146d62e5SAmir Goldstein goto out_free_oe; 1866146d62e5SAmir Goldstein 1867972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */ 1868f168f109SAmir Goldstein if (!ofs->indexdir) { 1869ad204488SMiklos Szeredi ofs->config.index = false; 187008f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs) && ofs->config.nfs_export) { 18711bd0a3aeSlijiazi pr_warn("NFS export requires an index dir, falling back to nfs_export=off.\n"); 1872f168f109SAmir Goldstein ofs->config.nfs_export = false; 1873f168f109SAmir Goldstein } 1874f168f109SAmir Goldstein } 187502bcd157SAmir Goldstein 1876d5791044SVivek Goyal if (ofs->config.metacopy && ofs->config.nfs_export) { 18771bd0a3aeSlijiazi pr_warn("NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 1878d5791044SVivek Goyal ofs->config.nfs_export = false; 1879d5791044SVivek Goyal } 1880d5791044SVivek Goyal 18818383f174SAmir Goldstein if (ofs->config.nfs_export) 18828383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations; 18838383f174SAmir Goldstein 188451f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 188551f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 188651f8f3c4SKonstantin Khlebnikov 1887655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 18882d2f2d73SMiklos Szeredi sb->s_xattr = ofs->config.userxattr ? ovl_user_xattr_handlers : 18892d2f2d73SMiklos Szeredi ovl_trusted_xattr_handlers; 1890ad204488SMiklos Szeredi sb->s_fs_info = ofs; 1891de2a4a50SMiklos Szeredi sb->s_flags |= SB_POSIXACL; 189232b1924bSKonstantin Khlebnikov sb->s_iflags |= SB_I_SKIP_SYNC; 1893655042ccSVivek Goyal 1894c6fe6254SMiklos Szeredi err = -ENOMEM; 1895*b36a5780SChristian Brauner root_dentry = ovl_get_root(sb, ctx->upper.dentry, oe); 1896e9be9d5eSMiklos Szeredi if (!root_dentry) 18974155c10aSMiklos Szeredi goto out_free_oe; 1898e9be9d5eSMiklos Szeredi 1899e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1900e9be9d5eSMiklos Szeredi 1901e9be9d5eSMiklos Szeredi return 0; 1902e9be9d5eSMiklos Szeredi 19034155c10aSMiklos Szeredi out_free_oe: 1904163db0daSAmir Goldstein ovl_free_entry(oe); 19054155c10aSMiklos Szeredi out_err: 1906ad204488SMiklos Szeredi ovl_free_fs(ofs); 19071784fbc2SChristian Brauner sb->s_fs_info = NULL; 1908e9be9d5eSMiklos Szeredi return err; 1909e9be9d5eSMiklos Szeredi } 1910e9be9d5eSMiklos Szeredi 19111784fbc2SChristian Brauner static int ovl_get_tree(struct fs_context *fc) 1912e9be9d5eSMiklos Szeredi { 19131784fbc2SChristian Brauner return get_tree_nodev(fc, ovl_fill_super); 19141784fbc2SChristian Brauner } 19151784fbc2SChristian Brauner 19161784fbc2SChristian Brauner static inline void ovl_fs_context_free(struct ovl_fs_context *ctx) 19171784fbc2SChristian Brauner { 1918*b36a5780SChristian Brauner ovl_parse_param_drop_lowerdir(ctx); 1919*b36a5780SChristian Brauner path_put(&ctx->upper); 1920*b36a5780SChristian Brauner path_put(&ctx->work); 1921*b36a5780SChristian Brauner kfree(ctx->lower); 19221784fbc2SChristian Brauner kfree(ctx); 19231784fbc2SChristian Brauner } 19241784fbc2SChristian Brauner 19251784fbc2SChristian Brauner static void ovl_free(struct fs_context *fc) 19261784fbc2SChristian Brauner { 19271784fbc2SChristian Brauner struct ovl_fs *ofs = fc->s_fs_info; 19281784fbc2SChristian Brauner struct ovl_fs_context *ctx = fc->fs_private; 19291784fbc2SChristian Brauner 19301784fbc2SChristian Brauner /* 19311784fbc2SChristian Brauner * ofs is stored in the fs_context when it is initialized. 19321784fbc2SChristian Brauner * ofs is transferred to the superblock on a successful mount, 19331784fbc2SChristian Brauner * but if an error occurs before the transfer we have to free 19341784fbc2SChristian Brauner * it here. 19351784fbc2SChristian Brauner */ 19361784fbc2SChristian Brauner if (ofs) 19371784fbc2SChristian Brauner ovl_free_fs(ofs); 19381784fbc2SChristian Brauner 19391784fbc2SChristian Brauner if (ctx) 19401784fbc2SChristian Brauner ovl_fs_context_free(ctx); 19411784fbc2SChristian Brauner } 19421784fbc2SChristian Brauner 19431784fbc2SChristian Brauner static const struct fs_context_operations ovl_context_ops = { 19441784fbc2SChristian Brauner .parse_param = ovl_parse_param, 19451784fbc2SChristian Brauner .get_tree = ovl_get_tree, 19461784fbc2SChristian Brauner .reconfigure = ovl_reconfigure, 19471784fbc2SChristian Brauner .free = ovl_free, 19481784fbc2SChristian Brauner }; 19491784fbc2SChristian Brauner 19501784fbc2SChristian Brauner /* 19511784fbc2SChristian Brauner * This is called during fsopen() and will record the user namespace of 19521784fbc2SChristian Brauner * the caller in fc->user_ns since we've raised FS_USERNS_MOUNT. We'll 19531784fbc2SChristian Brauner * need it when we actually create the superblock to verify that the 19541784fbc2SChristian Brauner * process creating the superblock is in the same user namespace as 19551784fbc2SChristian Brauner * process that called fsopen(). 19561784fbc2SChristian Brauner */ 19571784fbc2SChristian Brauner static int ovl_init_fs_context(struct fs_context *fc) 19581784fbc2SChristian Brauner { 19591784fbc2SChristian Brauner struct ovl_fs_context *ctx; 19601784fbc2SChristian Brauner struct ovl_fs *ofs; 19611784fbc2SChristian Brauner 19621784fbc2SChristian Brauner ctx = kzalloc(sizeof(*ctx), GFP_KERNEL_ACCOUNT); 19631784fbc2SChristian Brauner if (!ctx) 19641784fbc2SChristian Brauner return -ENOMEM; 19651784fbc2SChristian Brauner 1966*b36a5780SChristian Brauner /* 1967*b36a5780SChristian Brauner * By default we allocate for three lower layers. It's likely 1968*b36a5780SChristian Brauner * that it'll cover most users. 1969*b36a5780SChristian Brauner */ 1970*b36a5780SChristian Brauner ctx->lower = kmalloc_array(3, sizeof(*ctx->lower), GFP_KERNEL_ACCOUNT); 1971*b36a5780SChristian Brauner if (!ctx->lower) 1972*b36a5780SChristian Brauner goto out_err; 1973*b36a5780SChristian Brauner ctx->capacity = 3; 1974*b36a5780SChristian Brauner 19751784fbc2SChristian Brauner ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1976*b36a5780SChristian Brauner if (!ofs) 1977*b36a5780SChristian Brauner goto out_err; 19781784fbc2SChristian Brauner 19791784fbc2SChristian Brauner ofs->config.redirect_mode = ovl_redirect_mode_def(); 19801784fbc2SChristian Brauner ofs->config.index = ovl_index_def; 19811784fbc2SChristian Brauner ofs->config.uuid = true; 19821784fbc2SChristian Brauner ofs->config.nfs_export = ovl_nfs_export_def; 19831784fbc2SChristian Brauner ofs->config.xino = ovl_xino_def(); 19841784fbc2SChristian Brauner ofs->config.metacopy = ovl_metacopy_def; 19851784fbc2SChristian Brauner 19861784fbc2SChristian Brauner fc->s_fs_info = ofs; 19871784fbc2SChristian Brauner fc->fs_private = ctx; 19881784fbc2SChristian Brauner fc->ops = &ovl_context_ops; 19891784fbc2SChristian Brauner return 0; 1990*b36a5780SChristian Brauner 1991*b36a5780SChristian Brauner out_err: 1992*b36a5780SChristian Brauner ovl_fs_context_free(ctx); 1993*b36a5780SChristian Brauner return -ENOMEM; 1994*b36a5780SChristian Brauner 1995e9be9d5eSMiklos Szeredi } 1996e9be9d5eSMiklos Szeredi 1997e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 1998e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1999ef94b186SMiklos Szeredi .name = "overlay", 20001784fbc2SChristian Brauner .init_fs_context = ovl_init_fs_context, 20011784fbc2SChristian Brauner .parameters = ovl_parameter_spec, 2002459c7c56SMiklos Szeredi .fs_flags = FS_USERNS_MOUNT, 2003e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 2004e9be9d5eSMiklos Szeredi }; 2005ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 2006e9be9d5eSMiklos Szeredi 200713cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 200813cf199dSAmir Goldstein { 200913cf199dSAmir Goldstein struct ovl_inode *oi = foo; 201013cf199dSAmir Goldstein 201113cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 201213cf199dSAmir Goldstein } 201313cf199dSAmir Goldstein 2014e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 2015e9be9d5eSMiklos Szeredi { 201613cf199dSAmir Goldstein int err; 201713cf199dSAmir Goldstein 201813cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 201913cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 202013cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 202113cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 202213cf199dSAmir Goldstein ovl_inode_init_once); 202313cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 202413cf199dSAmir Goldstein return -ENOMEM; 202513cf199dSAmir Goldstein 20262406a307SJiufei Xue err = ovl_aio_request_cache_init(); 20272406a307SJiufei Xue if (!err) { 202813cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 20292406a307SJiufei Xue if (!err) 20302406a307SJiufei Xue return 0; 20312406a307SJiufei Xue 20322406a307SJiufei Xue ovl_aio_request_cache_destroy(); 20332406a307SJiufei Xue } 203413cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 203513cf199dSAmir Goldstein 203613cf199dSAmir Goldstein return err; 2037e9be9d5eSMiklos Szeredi } 2038e9be9d5eSMiklos Szeredi 2039e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 2040e9be9d5eSMiklos Szeredi { 2041e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 204213cf199dSAmir Goldstein 204313cf199dSAmir Goldstein /* 204413cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 204513cf199dSAmir Goldstein * destroy cache. 204613cf199dSAmir Goldstein */ 204713cf199dSAmir Goldstein rcu_barrier(); 204813cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 20492406a307SJiufei Xue ovl_aio_request_cache_destroy(); 2050e9be9d5eSMiklos Szeredi } 2051e9be9d5eSMiklos Szeredi 2052e9be9d5eSMiklos Szeredi module_init(ovl_init); 2053e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 2054