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> 18e9be9d5eSMiklos Szeredi #include "overlayfs.h" 19e9be9d5eSMiklos Szeredi 20e9be9d5eSMiklos Szeredi MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 21e9be9d5eSMiklos Szeredi MODULE_DESCRIPTION("Overlay filesystem"); 22e9be9d5eSMiklos Szeredi MODULE_LICENSE("GPL"); 23e9be9d5eSMiklos Szeredi 24e9be9d5eSMiklos Szeredi 25e9be9d5eSMiklos Szeredi struct ovl_dir_cache; 26e9be9d5eSMiklos Szeredi 27a78d9f0dSMiklos Szeredi #define OVL_MAX_STACK 500 28a78d9f0dSMiklos Szeredi 29688ea0e5SMiklos Szeredi static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR); 30688ea0e5SMiklos Szeredi module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644); 31253e7483SNicolas Schier MODULE_PARM_DESC(redirect_dir, 32688ea0e5SMiklos Szeredi "Default to on or off for the redirect_dir feature"); 33e9be9d5eSMiklos Szeredi 34438c84c2SMiklos Szeredi static bool ovl_redirect_always_follow = 35438c84c2SMiklos Szeredi IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW); 36438c84c2SMiklos Szeredi module_param_named(redirect_always_follow, ovl_redirect_always_follow, 37438c84c2SMiklos Szeredi bool, 0644); 38253e7483SNicolas Schier MODULE_PARM_DESC(redirect_always_follow, 39438c84c2SMiklos Szeredi "Follow redirects even if redirect_dir feature is turned off"); 40438c84c2SMiklos Szeredi 4102bcd157SAmir Goldstein static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX); 4202bcd157SAmir Goldstein module_param_named(index, ovl_index_def, bool, 0644); 43253e7483SNicolas Schier MODULE_PARM_DESC(index, 4402bcd157SAmir Goldstein "Default to on or off for the inodes index feature"); 4502bcd157SAmir Goldstein 46f168f109SAmir Goldstein static bool ovl_nfs_export_def = IS_ENABLED(CONFIG_OVERLAY_FS_NFS_EXPORT); 47f168f109SAmir Goldstein module_param_named(nfs_export, ovl_nfs_export_def, bool, 0644); 48253e7483SNicolas Schier MODULE_PARM_DESC(nfs_export, 49f168f109SAmir Goldstein "Default to on or off for the NFS export feature"); 50f168f109SAmir Goldstein 51795939a9SAmir Goldstein static bool ovl_xino_auto_def = IS_ENABLED(CONFIG_OVERLAY_FS_XINO_AUTO); 52795939a9SAmir Goldstein module_param_named(xino_auto, ovl_xino_auto_def, bool, 0644); 53253e7483SNicolas Schier MODULE_PARM_DESC(xino_auto, 54795939a9SAmir Goldstein "Auto enable xino feature"); 55795939a9SAmir Goldstein 564155c10aSMiklos Szeredi static void ovl_entry_stack_free(struct ovl_entry *oe) 574155c10aSMiklos Szeredi { 584155c10aSMiklos Szeredi unsigned int i; 594155c10aSMiklos Szeredi 604155c10aSMiklos Szeredi for (i = 0; i < oe->numlower; i++) 614155c10aSMiklos Szeredi dput(oe->lowerstack[i].dentry); 624155c10aSMiklos Szeredi } 634155c10aSMiklos Szeredi 64d5791044SVivek Goyal static bool ovl_metacopy_def = IS_ENABLED(CONFIG_OVERLAY_FS_METACOPY); 65d5791044SVivek Goyal module_param_named(metacopy, ovl_metacopy_def, bool, 0644); 66253e7483SNicolas Schier MODULE_PARM_DESC(metacopy, 67d5791044SVivek Goyal "Default to on or off for the metadata only copy up feature"); 68d5791044SVivek Goyal 69e9be9d5eSMiklos Szeredi static void ovl_dentry_release(struct dentry *dentry) 70e9be9d5eSMiklos Szeredi { 71e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 72e9be9d5eSMiklos Szeredi 73e9be9d5eSMiklos Szeredi if (oe) { 744155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 75e9be9d5eSMiklos Szeredi kfree_rcu(oe, rcu); 76e9be9d5eSMiklos Szeredi } 77e9be9d5eSMiklos Szeredi } 78e9be9d5eSMiklos Szeredi 792d902671SMiklos Szeredi static struct dentry *ovl_d_real(struct dentry *dentry, 80fb16043bSMiklos Szeredi const struct inode *inode) 81d101a125SMiklos Szeredi { 82cef4cbffSMiklos Szeredi struct dentry *real = NULL, *lower; 83d101a125SMiklos Szeredi 84e8c985baSMiklos Szeredi /* It's an overlay file */ 85e8c985baSMiklos Szeredi if (inode && d_inode(dentry) == inode) 86e8c985baSMiklos Szeredi return dentry; 87e8c985baSMiklos Szeredi 88ca4c8a3aSMiklos Szeredi if (!d_is_reg(dentry)) { 89d101a125SMiklos Szeredi if (!inode || inode == d_inode(dentry)) 90d101a125SMiklos Szeredi return dentry; 91d101a125SMiklos Szeredi goto bug; 92d101a125SMiklos Szeredi } 93d101a125SMiklos Szeredi 94d101a125SMiklos Szeredi real = ovl_dentry_upper(dentry); 952c3d7358SVivek Goyal if (real && (inode == d_inode(real))) 96d101a125SMiklos Szeredi return real; 97d101a125SMiklos Szeredi 982c3d7358SVivek Goyal if (real && !inode && ovl_has_upperdata(d_inode(dentry))) 992c3d7358SVivek Goyal return real; 1002c3d7358SVivek Goyal 101cef4cbffSMiklos Szeredi lower = ovl_dentry_lowerdata(dentry); 102cef4cbffSMiklos Szeredi if (!lower) 103d101a125SMiklos Szeredi goto bug; 104cef4cbffSMiklos Szeredi real = lower; 105d101a125SMiklos Szeredi 106c4fcfc16SMiklos Szeredi /* Handle recursion */ 107fb16043bSMiklos Szeredi real = d_real(real, inode); 108c4fcfc16SMiklos Szeredi 109d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 110d101a125SMiklos Szeredi return real; 111d101a125SMiklos Szeredi bug: 112cef4cbffSMiklos Szeredi WARN(1, "%s(%pd4, %s:%lu): real dentry (%p/%lu) not found\n", 113cef4cbffSMiklos Szeredi __func__, dentry, inode ? inode->i_sb->s_id : "NULL", 114cef4cbffSMiklos Szeredi inode ? inode->i_ino : 0, real, 115cef4cbffSMiklos Szeredi real && d_inode(real) ? d_inode(real)->i_ino : 0); 116d101a125SMiklos Szeredi return dentry; 117d101a125SMiklos Szeredi } 118d101a125SMiklos Szeredi 1193bb7df92SMiklos Szeredi static int ovl_revalidate_real(struct dentry *d, unsigned int flags, bool weak) 1203bb7df92SMiklos Szeredi { 1213bb7df92SMiklos Szeredi int ret = 1; 1223bb7df92SMiklos Szeredi 1233bb7df92SMiklos Szeredi if (weak) { 1243bb7df92SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) 1253bb7df92SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1263bb7df92SMiklos Szeredi } else if (d->d_flags & DCACHE_OP_REVALIDATE) { 1273bb7df92SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1283bb7df92SMiklos Szeredi if (!ret) { 1293bb7df92SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1303bb7df92SMiklos Szeredi d_invalidate(d); 1313bb7df92SMiklos Szeredi ret = -ESTALE; 1323bb7df92SMiklos Szeredi } 1333bb7df92SMiklos Szeredi } 1343bb7df92SMiklos Szeredi return ret; 1353bb7df92SMiklos Szeredi } 1363bb7df92SMiklos Szeredi 1373bb7df92SMiklos Szeredi static int ovl_dentry_revalidate_common(struct dentry *dentry, 1383bb7df92SMiklos Szeredi unsigned int flags, bool weak) 1397c03b5d4SMiklos Szeredi { 1407c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 141bccece1eSMiklos Szeredi struct dentry *upper; 1427c03b5d4SMiklos Szeredi unsigned int i; 1437c03b5d4SMiklos Szeredi int ret = 1; 1447c03b5d4SMiklos Szeredi 145bccece1eSMiklos Szeredi upper = ovl_dentry_upper(dentry); 146bccece1eSMiklos Szeredi if (upper) 147bccece1eSMiklos Szeredi ret = ovl_revalidate_real(upper, flags, weak); 148bccece1eSMiklos Szeredi 1493bb7df92SMiklos Szeredi for (i = 0; ret > 0 && i < oe->numlower; i++) { 1503bb7df92SMiklos Szeredi ret = ovl_revalidate_real(oe->lowerstack[i].dentry, flags, 1513bb7df92SMiklos Szeredi weak); 1523bb7df92SMiklos Szeredi } 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 = { 167e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 168d101a125SMiklos Szeredi .d_real = ovl_d_real, 1697c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1707c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1717c03b5d4SMiklos Szeredi }; 1727c03b5d4SMiklos Szeredi 17313cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 17413cf199dSAmir Goldstein 17513cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 17613cf199dSAmir Goldstein { 177fd60b288SMuchun Song struct ovl_inode *oi = alloc_inode_sb(sb, ovl_inode_cachep, GFP_KERNEL); 17813cf199dSAmir Goldstein 179b3885bd6SHirofumi Nakagawa if (!oi) 180b3885bd6SHirofumi Nakagawa return NULL; 181b3885bd6SHirofumi Nakagawa 18204a01ac7SMiklos Szeredi oi->cache = NULL; 183cf31c463SMiklos Szeredi oi->redirect = NULL; 18404a01ac7SMiklos Szeredi oi->version = 0; 18513c72075SMiklos Szeredi oi->flags = 0; 18609d8b586SMiklos Szeredi oi->__upperdentry = NULL; 187ffa5723cSAmir Goldstein oi->lowerpath.dentry = NULL; 188ffa5723cSAmir Goldstein oi->lowerpath.layer = NULL; 1892664bd08SVivek Goyal oi->lowerdata = NULL; 190a015dafcSAmir Goldstein mutex_init(&oi->lock); 19125b7713aSMiklos Szeredi 19213cf199dSAmir Goldstein return &oi->vfs_inode; 19313cf199dSAmir Goldstein } 19413cf199dSAmir Goldstein 1950b269dedSAl Viro static void ovl_free_inode(struct inode *inode) 19613cf199dSAmir Goldstein { 1970b269dedSAl Viro struct ovl_inode *oi = OVL_I(inode); 19813cf199dSAmir Goldstein 1990b269dedSAl Viro kfree(oi->redirect); 2000b269dedSAl Viro mutex_destroy(&oi->lock); 2010b269dedSAl Viro kmem_cache_free(ovl_inode_cachep, oi); 20213cf199dSAmir Goldstein } 20313cf199dSAmir Goldstein 20413cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 20513cf199dSAmir Goldstein { 20609d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 20709d8b586SMiklos Szeredi 20809d8b586SMiklos Szeredi dput(oi->__upperdentry); 209ffa5723cSAmir Goldstein dput(oi->lowerpath.dentry); 2102664bd08SVivek Goyal if (S_ISDIR(inode->i_mode)) 2114edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 2122664bd08SVivek Goyal else 2132664bd08SVivek Goyal iput(oi->lowerdata); 21413cf199dSAmir Goldstein } 21513cf199dSAmir Goldstein 216ad204488SMiklos Szeredi static void ovl_free_fs(struct ovl_fs *ofs) 217e9be9d5eSMiklos Szeredi { 218df820f8dSMiklos Szeredi struct vfsmount **mounts; 219dd662667SMiklos Szeredi unsigned i; 220e9be9d5eSMiklos Szeredi 2210be0bfd2SAmir Goldstein iput(ofs->workbasedir_trap); 222146d62e5SAmir Goldstein iput(ofs->indexdir_trap); 223146d62e5SAmir Goldstein iput(ofs->workdir_trap); 224c21c839bSChengguang Xu dput(ofs->whiteout); 225ad204488SMiklos Szeredi dput(ofs->indexdir); 226ad204488SMiklos Szeredi dput(ofs->workdir); 227ad204488SMiklos Szeredi if (ofs->workdir_locked) 228ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->workbasedir); 229ad204488SMiklos Szeredi dput(ofs->workbasedir); 230ad204488SMiklos Szeredi if (ofs->upperdir_locked) 23108f4c7c8SMiklos Szeredi ovl_inuse_unlock(ovl_upper_mnt(ofs)->mnt_root); 232df820f8dSMiklos Szeredi 233df820f8dSMiklos Szeredi /* Hack! Reuse ofs->layers as a vfsmount array before freeing it */ 234df820f8dSMiklos Szeredi mounts = (struct vfsmount **) ofs->layers; 235b8e42a65SMiklos Szeredi for (i = 0; i < ofs->numlayer; i++) { 23694375f9dSAmir Goldstein iput(ofs->layers[i].trap); 237df820f8dSMiklos Szeredi mounts[i] = ofs->layers[i].mnt; 238146d62e5SAmir Goldstein } 239df820f8dSMiklos Szeredi kern_unmount_array(mounts, ofs->numlayer); 24094375f9dSAmir Goldstein kfree(ofs->layers); 241b7bf9908SAmir Goldstein for (i = 0; i < ofs->numfs; i++) 24207f1e596SAmir Goldstein free_anon_bdev(ofs->fs[i].pseudo_dev); 24307f1e596SAmir Goldstein kfree(ofs->fs); 244e9be9d5eSMiklos Szeredi 245ad204488SMiklos Szeredi kfree(ofs->config.lowerdir); 246ad204488SMiklos Szeredi kfree(ofs->config.upperdir); 247ad204488SMiklos Szeredi kfree(ofs->config.workdir); 248438c84c2SMiklos Szeredi kfree(ofs->config.redirect_mode); 249ad204488SMiklos Szeredi if (ofs->creator_cred) 250ad204488SMiklos Szeredi put_cred(ofs->creator_cred); 251ad204488SMiklos Szeredi kfree(ofs); 252e9be9d5eSMiklos Szeredi } 253e9be9d5eSMiklos Szeredi 254a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 255a9075cdbSMiklos Szeredi { 256a9075cdbSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 257a9075cdbSMiklos Szeredi 258a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 259a9075cdbSMiklos Szeredi } 260a9075cdbSMiklos Szeredi 261e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */ 262e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 263e593b2bfSAmir Goldstein { 264ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 265e593b2bfSAmir Goldstein struct super_block *upper_sb; 266e593b2bfSAmir Goldstein int ret; 267e593b2bfSAmir Goldstein 268335d3fc5SSargun Dhillon ret = ovl_sync_status(ofs); 269335d3fc5SSargun Dhillon /* 270335d3fc5SSargun Dhillon * We have to always set the err, because the return value isn't 271335d3fc5SSargun Dhillon * checked in syncfs, and instead indirectly return an error via 272335d3fc5SSargun Dhillon * the sb's writeback errseq, which VFS inspects after this call. 273335d3fc5SSargun Dhillon */ 274335d3fc5SSargun Dhillon if (ret < 0) { 275335d3fc5SSargun Dhillon errseq_set(&sb->s_wb_err, -EIO); 276335d3fc5SSargun Dhillon return -EIO; 277335d3fc5SSargun Dhillon } 278e8d4bfe3SChengguang Xu 279335d3fc5SSargun Dhillon if (!ret) 280335d3fc5SSargun Dhillon return ret; 281335d3fc5SSargun Dhillon 282e8d4bfe3SChengguang Xu /* 28332b1924bSKonstantin Khlebnikov * Not called for sync(2) call or an emergency sync (SB_I_SKIP_SYNC). 28432b1924bSKonstantin Khlebnikov * All the super blocks will be iterated, including upper_sb. 285e8d4bfe3SChengguang Xu * 286e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call 287e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being 288e8d4bfe3SChengguang Xu * called with wait == 1. 289e8d4bfe3SChengguang Xu */ 290e8d4bfe3SChengguang Xu if (!wait) 291e593b2bfSAmir Goldstein return 0; 292e593b2bfSAmir Goldstein 29308f4c7c8SMiklos Szeredi upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 294e8d4bfe3SChengguang Xu 295e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 296e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb); 297e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 298e8d4bfe3SChengguang Xu 299e593b2bfSAmir Goldstein return ret; 300e593b2bfSAmir Goldstein } 301e593b2bfSAmir Goldstein 302cc259639SAndy Whitcroft /** 303cc259639SAndy Whitcroft * ovl_statfs 304*9c5dd803SYang Li * @dentry: The dentry to query 305cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 306cc259639SAndy Whitcroft * 307cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 3084ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 309cc259639SAndy Whitcroft */ 310cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 311cc259639SAndy Whitcroft { 312cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 313cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 314cc259639SAndy Whitcroft struct path path; 315cc259639SAndy Whitcroft int err; 316cc259639SAndy Whitcroft 3174ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 318cc259639SAndy Whitcroft 319cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 320cc259639SAndy Whitcroft if (!err) { 3216b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 322cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 323cc259639SAndy Whitcroft } 324cc259639SAndy Whitcroft 325cc259639SAndy Whitcroft return err; 326cc259639SAndy Whitcroft } 327cc259639SAndy Whitcroft 32802bcd157SAmir Goldstein /* Will this overlay be forced to mount/remount ro? */ 329ad204488SMiklos Szeredi static bool ovl_force_readonly(struct ovl_fs *ofs) 33002bcd157SAmir Goldstein { 33108f4c7c8SMiklos Szeredi return (!ovl_upper_mnt(ofs) || !ofs->workdir); 33202bcd157SAmir Goldstein } 33302bcd157SAmir Goldstein 334438c84c2SMiklos Szeredi static const char *ovl_redirect_mode_def(void) 335438c84c2SMiklos Szeredi { 336438c84c2SMiklos Szeredi return ovl_redirect_dir_def ? "on" : "off"; 337438c84c2SMiklos Szeredi } 338438c84c2SMiklos Szeredi 339795939a9SAmir Goldstein static const char * const ovl_xino_str[] = { 340795939a9SAmir Goldstein "off", 341795939a9SAmir Goldstein "auto", 342795939a9SAmir Goldstein "on", 343795939a9SAmir Goldstein }; 344795939a9SAmir Goldstein 345795939a9SAmir Goldstein static inline int ovl_xino_def(void) 346795939a9SAmir Goldstein { 347795939a9SAmir Goldstein return ovl_xino_auto_def ? OVL_XINO_AUTO : OVL_XINO_OFF; 348795939a9SAmir Goldstein } 349795939a9SAmir Goldstein 350f45827e8SErez Zadok /** 351f45827e8SErez Zadok * ovl_show_options 352*9c5dd803SYang Li * @m: the seq_file handle 353*9c5dd803SYang Li * @dentry: The dentry to query 354f45827e8SErez Zadok * 355f45827e8SErez Zadok * Prints the mount options for a given superblock. 356f45827e8SErez Zadok * Returns zero; does not fail. 357f45827e8SErez Zadok */ 358f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 359f45827e8SErez Zadok { 360f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 361ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 362f45827e8SErez Zadok 363ad204488SMiklos Szeredi seq_show_option(m, "lowerdir", ofs->config.lowerdir); 364ad204488SMiklos Szeredi if (ofs->config.upperdir) { 365ad204488SMiklos Szeredi seq_show_option(m, "upperdir", ofs->config.upperdir); 366ad204488SMiklos Szeredi seq_show_option(m, "workdir", ofs->config.workdir); 36753a08cb9SMiklos Szeredi } 368ad204488SMiklos Szeredi if (ofs->config.default_permissions) 3698d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 370438c84c2SMiklos Szeredi if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0) 371438c84c2SMiklos Szeredi seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode); 372ad204488SMiklos Szeredi if (ofs->config.index != ovl_index_def) 373438c84c2SMiklos Szeredi seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 3745830fb6bSPavel Tikhomirov if (!ofs->config.uuid) 3755830fb6bSPavel Tikhomirov seq_puts(m, ",uuid=off"); 376f168f109SAmir Goldstein if (ofs->config.nfs_export != ovl_nfs_export_def) 377f168f109SAmir Goldstein seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ? 378f168f109SAmir Goldstein "on" : "off"); 3790f831ec8SAmir Goldstein if (ofs->config.xino != ovl_xino_def() && !ovl_same_fs(sb)) 380795939a9SAmir Goldstein seq_printf(m, ",xino=%s", ovl_xino_str[ofs->config.xino]); 381d5791044SVivek Goyal if (ofs->config.metacopy != ovl_metacopy_def) 382d5791044SVivek Goyal seq_printf(m, ",metacopy=%s", 383d5791044SVivek Goyal ofs->config.metacopy ? "on" : "off"); 384c86243b0SVivek Goyal if (ofs->config.ovl_volatile) 385c86243b0SVivek Goyal seq_puts(m, ",volatile"); 386321b46b9SGiuseppe Scrivano if (ofs->config.userxattr) 387321b46b9SGiuseppe Scrivano seq_puts(m, ",userxattr"); 388f45827e8SErez Zadok return 0; 389f45827e8SErez Zadok } 390f45827e8SErez Zadok 3913cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 3923cdf6fe9SSeunghun Lee { 393ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 394399c109dSChengguang Xu struct super_block *upper_sb; 395399c109dSChengguang Xu int ret = 0; 3963cdf6fe9SSeunghun Lee 3971751e8a6SLinus Torvalds if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 3983cdf6fe9SSeunghun Lee return -EROFS; 3993cdf6fe9SSeunghun Lee 400399c109dSChengguang Xu if (*flags & SB_RDONLY && !sb_rdonly(sb)) { 40108f4c7c8SMiklos Szeredi upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 402c86243b0SVivek Goyal if (ovl_should_sync(ofs)) { 403399c109dSChengguang Xu down_read(&upper_sb->s_umount); 404399c109dSChengguang Xu ret = sync_filesystem(upper_sb); 405399c109dSChengguang Xu up_read(&upper_sb->s_umount); 406399c109dSChengguang Xu } 407c86243b0SVivek Goyal } 408399c109dSChengguang Xu 409399c109dSChengguang Xu return ret; 4103cdf6fe9SSeunghun Lee } 4113cdf6fe9SSeunghun Lee 412e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 41313cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 4140b269dedSAl Viro .free_inode = ovl_free_inode, 41513cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 41613cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 417e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 418e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 419cc259639SAndy Whitcroft .statfs = ovl_statfs, 420f45827e8SErez Zadok .show_options = ovl_show_options, 4213cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 422e9be9d5eSMiklos Szeredi }; 423e9be9d5eSMiklos Szeredi 424e9be9d5eSMiklos Szeredi enum { 425e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 426e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 427e9be9d5eSMiklos Szeredi OPT_WORKDIR, 4288d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 429438c84c2SMiklos Szeredi OPT_REDIRECT_DIR, 43002bcd157SAmir Goldstein OPT_INDEX_ON, 43102bcd157SAmir Goldstein OPT_INDEX_OFF, 4325830fb6bSPavel Tikhomirov OPT_UUID_ON, 4335830fb6bSPavel Tikhomirov OPT_UUID_OFF, 434f168f109SAmir Goldstein OPT_NFS_EXPORT_ON, 4352d2f2d73SMiklos Szeredi OPT_USERXATTR, 436f168f109SAmir Goldstein OPT_NFS_EXPORT_OFF, 437795939a9SAmir Goldstein OPT_XINO_ON, 438795939a9SAmir Goldstein OPT_XINO_OFF, 439795939a9SAmir Goldstein OPT_XINO_AUTO, 440d5791044SVivek Goyal OPT_METACOPY_ON, 441d5791044SVivek Goyal OPT_METACOPY_OFF, 442c86243b0SVivek Goyal OPT_VOLATILE, 443e9be9d5eSMiklos Szeredi OPT_ERR, 444e9be9d5eSMiklos Szeredi }; 445e9be9d5eSMiklos Szeredi 446e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 447e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 448e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 449e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 4508d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 451438c84c2SMiklos Szeredi {OPT_REDIRECT_DIR, "redirect_dir=%s"}, 45202bcd157SAmir Goldstein {OPT_INDEX_ON, "index=on"}, 45302bcd157SAmir Goldstein {OPT_INDEX_OFF, "index=off"}, 4542d2f2d73SMiklos Szeredi {OPT_USERXATTR, "userxattr"}, 4555830fb6bSPavel Tikhomirov {OPT_UUID_ON, "uuid=on"}, 4565830fb6bSPavel Tikhomirov {OPT_UUID_OFF, "uuid=off"}, 457f168f109SAmir Goldstein {OPT_NFS_EXPORT_ON, "nfs_export=on"}, 458f168f109SAmir Goldstein {OPT_NFS_EXPORT_OFF, "nfs_export=off"}, 459795939a9SAmir Goldstein {OPT_XINO_ON, "xino=on"}, 460795939a9SAmir Goldstein {OPT_XINO_OFF, "xino=off"}, 461795939a9SAmir Goldstein {OPT_XINO_AUTO, "xino=auto"}, 462d5791044SVivek Goyal {OPT_METACOPY_ON, "metacopy=on"}, 463d5791044SVivek Goyal {OPT_METACOPY_OFF, "metacopy=off"}, 464c86243b0SVivek Goyal {OPT_VOLATILE, "volatile"}, 465e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 466e9be9d5eSMiklos Szeredi }; 467e9be9d5eSMiklos Szeredi 46891c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 46991c77947SMiklos Szeredi { 47091c77947SMiklos Szeredi char *sbegin = *s; 47191c77947SMiklos Szeredi char *p; 47291c77947SMiklos Szeredi 47391c77947SMiklos Szeredi if (sbegin == NULL) 47491c77947SMiklos Szeredi return NULL; 47591c77947SMiklos Szeredi 47691c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 47791c77947SMiklos Szeredi if (*p == '\\') { 47891c77947SMiklos Szeredi p++; 47991c77947SMiklos Szeredi if (!*p) 48091c77947SMiklos Szeredi break; 48191c77947SMiklos Szeredi } else if (*p == ',') { 48291c77947SMiklos Szeredi *p = '\0'; 48391c77947SMiklos Szeredi *s = p + 1; 48491c77947SMiklos Szeredi return sbegin; 48591c77947SMiklos Szeredi } 48691c77947SMiklos Szeredi } 48791c77947SMiklos Szeredi *s = NULL; 48891c77947SMiklos Szeredi return sbegin; 48991c77947SMiklos Szeredi } 49091c77947SMiklos Szeredi 491438c84c2SMiklos Szeredi static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode) 492438c84c2SMiklos Szeredi { 493438c84c2SMiklos Szeredi if (strcmp(mode, "on") == 0) { 494438c84c2SMiklos Szeredi config->redirect_dir = true; 495438c84c2SMiklos Szeredi /* 496438c84c2SMiklos Szeredi * Does not make sense to have redirect creation without 497438c84c2SMiklos Szeredi * redirect following. 498438c84c2SMiklos Szeredi */ 499438c84c2SMiklos Szeredi config->redirect_follow = true; 500438c84c2SMiklos Szeredi } else if (strcmp(mode, "follow") == 0) { 501438c84c2SMiklos Szeredi config->redirect_follow = true; 502438c84c2SMiklos Szeredi } else if (strcmp(mode, "off") == 0) { 503438c84c2SMiklos Szeredi if (ovl_redirect_always_follow) 504438c84c2SMiklos Szeredi config->redirect_follow = true; 505438c84c2SMiklos Szeredi } else if (strcmp(mode, "nofollow") != 0) { 5061bd0a3aeSlijiazi pr_err("bad mount option \"redirect_dir=%s\"\n", 507438c84c2SMiklos Szeredi mode); 508438c84c2SMiklos Szeredi return -EINVAL; 509438c84c2SMiklos Szeredi } 510438c84c2SMiklos Szeredi 511438c84c2SMiklos Szeredi return 0; 512438c84c2SMiklos Szeredi } 513438c84c2SMiklos Szeredi 514e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 515e9be9d5eSMiklos Szeredi { 516e9be9d5eSMiklos Szeredi char *p; 517d5791044SVivek Goyal int err; 518d47748e5SMiklos Szeredi bool metacopy_opt = false, redirect_opt = false; 519b0def88dSAmir Goldstein bool nfs_export_opt = false, index_opt = false; 520e9be9d5eSMiklos Szeredi 521438c84c2SMiklos Szeredi config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL); 522438c84c2SMiklos Szeredi if (!config->redirect_mode) 523438c84c2SMiklos Szeredi return -ENOMEM; 524438c84c2SMiklos Szeredi 52591c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 526e9be9d5eSMiklos Szeredi int token; 527e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 528e9be9d5eSMiklos Szeredi 529e9be9d5eSMiklos Szeredi if (!*p) 530e9be9d5eSMiklos Szeredi continue; 531e9be9d5eSMiklos Szeredi 532e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 533e9be9d5eSMiklos Szeredi switch (token) { 534e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 535e9be9d5eSMiklos Szeredi kfree(config->upperdir); 536e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 537e9be9d5eSMiklos Szeredi if (!config->upperdir) 538e9be9d5eSMiklos Szeredi return -ENOMEM; 539e9be9d5eSMiklos Szeredi break; 540e9be9d5eSMiklos Szeredi 541e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 542e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 543e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 544e9be9d5eSMiklos Szeredi if (!config->lowerdir) 545e9be9d5eSMiklos Szeredi return -ENOMEM; 546e9be9d5eSMiklos Szeredi break; 547e9be9d5eSMiklos Szeredi 548e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 549e9be9d5eSMiklos Szeredi kfree(config->workdir); 550e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 551e9be9d5eSMiklos Szeredi if (!config->workdir) 552e9be9d5eSMiklos Szeredi return -ENOMEM; 553e9be9d5eSMiklos Szeredi break; 554e9be9d5eSMiklos Szeredi 5558d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 5568d3095f4SMiklos Szeredi config->default_permissions = true; 5578d3095f4SMiklos Szeredi break; 5588d3095f4SMiklos Szeredi 559438c84c2SMiklos Szeredi case OPT_REDIRECT_DIR: 560438c84c2SMiklos Szeredi kfree(config->redirect_mode); 561438c84c2SMiklos Szeredi config->redirect_mode = match_strdup(&args[0]); 562438c84c2SMiklos Szeredi if (!config->redirect_mode) 563438c84c2SMiklos Szeredi return -ENOMEM; 564d47748e5SMiklos Szeredi redirect_opt = true; 565a6c60655SMiklos Szeredi break; 566a6c60655SMiklos Szeredi 56702bcd157SAmir Goldstein case OPT_INDEX_ON: 56802bcd157SAmir Goldstein config->index = true; 569b0def88dSAmir Goldstein index_opt = true; 57002bcd157SAmir Goldstein break; 57102bcd157SAmir Goldstein 57202bcd157SAmir Goldstein case OPT_INDEX_OFF: 57302bcd157SAmir Goldstein config->index = false; 574b0def88dSAmir Goldstein index_opt = true; 57502bcd157SAmir Goldstein break; 57602bcd157SAmir Goldstein 5775830fb6bSPavel Tikhomirov case OPT_UUID_ON: 5785830fb6bSPavel Tikhomirov config->uuid = true; 5795830fb6bSPavel Tikhomirov break; 5805830fb6bSPavel Tikhomirov 5815830fb6bSPavel Tikhomirov case OPT_UUID_OFF: 5825830fb6bSPavel Tikhomirov config->uuid = false; 5835830fb6bSPavel Tikhomirov break; 5845830fb6bSPavel Tikhomirov 585f168f109SAmir Goldstein case OPT_NFS_EXPORT_ON: 586f168f109SAmir Goldstein config->nfs_export = true; 587b0def88dSAmir Goldstein nfs_export_opt = true; 588f168f109SAmir Goldstein break; 589f168f109SAmir Goldstein 590f168f109SAmir Goldstein case OPT_NFS_EXPORT_OFF: 591f168f109SAmir Goldstein config->nfs_export = false; 592b0def88dSAmir Goldstein nfs_export_opt = true; 593f168f109SAmir Goldstein break; 594f168f109SAmir Goldstein 595795939a9SAmir Goldstein case OPT_XINO_ON: 596795939a9SAmir Goldstein config->xino = OVL_XINO_ON; 597795939a9SAmir Goldstein break; 598795939a9SAmir Goldstein 599795939a9SAmir Goldstein case OPT_XINO_OFF: 600795939a9SAmir Goldstein config->xino = OVL_XINO_OFF; 601795939a9SAmir Goldstein break; 602795939a9SAmir Goldstein 603795939a9SAmir Goldstein case OPT_XINO_AUTO: 604795939a9SAmir Goldstein config->xino = OVL_XINO_AUTO; 605795939a9SAmir Goldstein break; 606795939a9SAmir Goldstein 607d5791044SVivek Goyal case OPT_METACOPY_ON: 608d5791044SVivek Goyal config->metacopy = true; 609d47748e5SMiklos Szeredi metacopy_opt = true; 610d5791044SVivek Goyal break; 611d5791044SVivek Goyal 612d5791044SVivek Goyal case OPT_METACOPY_OFF: 613d5791044SVivek Goyal config->metacopy = false; 614b0def88dSAmir Goldstein metacopy_opt = true; 615d5791044SVivek Goyal break; 616d5791044SVivek Goyal 617c86243b0SVivek Goyal case OPT_VOLATILE: 618c86243b0SVivek Goyal config->ovl_volatile = true; 619c86243b0SVivek Goyal break; 620c86243b0SVivek Goyal 6212d2f2d73SMiklos Szeredi case OPT_USERXATTR: 6222d2f2d73SMiklos Szeredi config->userxattr = true; 6232d2f2d73SMiklos Szeredi break; 6242d2f2d73SMiklos Szeredi 625e9be9d5eSMiklos Szeredi default: 6261bd0a3aeSlijiazi pr_err("unrecognized mount option \"%s\" or missing value\n", 6271bd0a3aeSlijiazi p); 628e9be9d5eSMiklos Szeredi return -EINVAL; 629e9be9d5eSMiklos Szeredi } 630e9be9d5eSMiklos Szeredi } 63171cbad7eShujianyang 632f0e1266eSAmir Goldstein /* Workdir/index are useless in non-upper mount */ 633f0e1266eSAmir Goldstein if (!config->upperdir) { 634f0e1266eSAmir Goldstein if (config->workdir) { 6351bd0a3aeSlijiazi pr_info("option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 63671cbad7eShujianyang config->workdir); 63771cbad7eShujianyang kfree(config->workdir); 63871cbad7eShujianyang config->workdir = NULL; 63971cbad7eShujianyang } 640f0e1266eSAmir Goldstein if (config->index && index_opt) { 641f0e1266eSAmir Goldstein pr_info("option \"index=on\" is useless in a non-upper mount, ignore\n"); 642f0e1266eSAmir Goldstein index_opt = false; 643f0e1266eSAmir Goldstein } 644f0e1266eSAmir Goldstein config->index = false; 645f0e1266eSAmir Goldstein } 64671cbad7eShujianyang 647c86243b0SVivek Goyal if (!config->upperdir && config->ovl_volatile) { 648c86243b0SVivek Goyal pr_info("option \"volatile\" is meaningless in a non-upper mount, ignoring it.\n"); 649c86243b0SVivek Goyal config->ovl_volatile = false; 650c86243b0SVivek Goyal } 651c86243b0SVivek Goyal 652d5791044SVivek Goyal err = ovl_parse_redirect_mode(config, config->redirect_mode); 653d5791044SVivek Goyal if (err) 654d5791044SVivek Goyal return err; 655d5791044SVivek Goyal 656d47748e5SMiklos Szeredi /* 657d47748e5SMiklos Szeredi * This is to make the logic below simpler. It doesn't make any other 658d47748e5SMiklos Szeredi * difference, since config->redirect_dir is only used for upper. 659d47748e5SMiklos Szeredi */ 660d47748e5SMiklos Szeredi if (!config->upperdir && config->redirect_follow) 661d47748e5SMiklos Szeredi config->redirect_dir = true; 662d47748e5SMiklos Szeredi 663d47748e5SMiklos Szeredi /* Resolve metacopy -> redirect_dir dependency */ 664d47748e5SMiklos Szeredi if (config->metacopy && !config->redirect_dir) { 665d47748e5SMiklos Szeredi if (metacopy_opt && redirect_opt) { 6661bd0a3aeSlijiazi pr_err("conflicting options: metacopy=on,redirect_dir=%s\n", 667d47748e5SMiklos Szeredi config->redirect_mode); 668d47748e5SMiklos Szeredi return -EINVAL; 669d47748e5SMiklos Szeredi } 670d47748e5SMiklos Szeredi if (redirect_opt) { 671d47748e5SMiklos Szeredi /* 672d47748e5SMiklos Szeredi * There was an explicit redirect_dir=... that resulted 673d47748e5SMiklos Szeredi * in this conflict. 674d47748e5SMiklos Szeredi */ 6751bd0a3aeSlijiazi pr_info("disabling metacopy due to redirect_dir=%s\n", 676d47748e5SMiklos Szeredi config->redirect_mode); 677d5791044SVivek Goyal config->metacopy = false; 678d47748e5SMiklos Szeredi } else { 679d47748e5SMiklos Szeredi /* Automatically enable redirect otherwise. */ 680d47748e5SMiklos Szeredi config->redirect_follow = config->redirect_dir = true; 681d47748e5SMiklos Szeredi } 682d5791044SVivek Goyal } 683d5791044SVivek Goyal 684b0def88dSAmir Goldstein /* Resolve nfs_export -> index dependency */ 685b0def88dSAmir Goldstein if (config->nfs_export && !config->index) { 686f0e1266eSAmir Goldstein if (!config->upperdir && config->redirect_follow) { 687f0e1266eSAmir Goldstein pr_info("NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n"); 688f0e1266eSAmir Goldstein config->nfs_export = false; 689f0e1266eSAmir Goldstein } else if (nfs_export_opt && index_opt) { 690b0def88dSAmir Goldstein pr_err("conflicting options: nfs_export=on,index=off\n"); 691b0def88dSAmir Goldstein return -EINVAL; 692f0e1266eSAmir Goldstein } else if (index_opt) { 693b0def88dSAmir Goldstein /* 694b0def88dSAmir Goldstein * There was an explicit index=off that resulted 695b0def88dSAmir Goldstein * in this conflict. 696b0def88dSAmir Goldstein */ 697b0def88dSAmir Goldstein pr_info("disabling nfs_export due to index=off\n"); 698b0def88dSAmir Goldstein config->nfs_export = false; 699b0def88dSAmir Goldstein } else { 700b0def88dSAmir Goldstein /* Automatically enable index otherwise. */ 701b0def88dSAmir Goldstein config->index = true; 702b0def88dSAmir Goldstein } 703b0def88dSAmir Goldstein } 704b0def88dSAmir Goldstein 705b0def88dSAmir Goldstein /* Resolve nfs_export -> !metacopy dependency */ 706b0def88dSAmir Goldstein if (config->nfs_export && config->metacopy) { 707b0def88dSAmir Goldstein if (nfs_export_opt && metacopy_opt) { 708b0def88dSAmir Goldstein pr_err("conflicting options: nfs_export=on,metacopy=on\n"); 709b0def88dSAmir Goldstein return -EINVAL; 710b0def88dSAmir Goldstein } 711b0def88dSAmir Goldstein if (metacopy_opt) { 712b0def88dSAmir Goldstein /* 713b0def88dSAmir Goldstein * There was an explicit metacopy=on that resulted 714b0def88dSAmir Goldstein * in this conflict. 715b0def88dSAmir Goldstein */ 716b0def88dSAmir Goldstein pr_info("disabling nfs_export due to metacopy=on\n"); 717b0def88dSAmir Goldstein config->nfs_export = false; 718b0def88dSAmir Goldstein } else { 719b0def88dSAmir Goldstein /* 720b0def88dSAmir Goldstein * There was an explicit nfs_export=on that resulted 721b0def88dSAmir Goldstein * in this conflict. 722b0def88dSAmir Goldstein */ 723b0def88dSAmir Goldstein pr_info("disabling metacopy due to nfs_export=on\n"); 724b0def88dSAmir Goldstein config->metacopy = false; 725b0def88dSAmir Goldstein } 726b0def88dSAmir Goldstein } 727b0def88dSAmir Goldstein 7282d2f2d73SMiklos Szeredi 7292d2f2d73SMiklos Szeredi /* Resolve userxattr -> !redirect && !metacopy dependency */ 7302d2f2d73SMiklos Szeredi if (config->userxattr) { 7312d2f2d73SMiklos Szeredi if (config->redirect_follow && redirect_opt) { 7322d2f2d73SMiklos Szeredi pr_err("conflicting options: userxattr,redirect_dir=%s\n", 7332d2f2d73SMiklos Szeredi config->redirect_mode); 7342d2f2d73SMiklos Szeredi return -EINVAL; 7352d2f2d73SMiklos Szeredi } 7362d2f2d73SMiklos Szeredi if (config->metacopy && metacopy_opt) { 7372d2f2d73SMiklos Szeredi pr_err("conflicting options: userxattr,metacopy=on\n"); 7382d2f2d73SMiklos Szeredi return -EINVAL; 7392d2f2d73SMiklos Szeredi } 7402d2f2d73SMiklos Szeredi /* 7412d2f2d73SMiklos Szeredi * Silently disable default setting of redirect and metacopy. 7422d2f2d73SMiklos Szeredi * This shall be the default in the future as well: these 7432d2f2d73SMiklos Szeredi * options must be explicitly enabled if used together with 7442d2f2d73SMiklos Szeredi * userxattr. 7452d2f2d73SMiklos Szeredi */ 7462d2f2d73SMiklos Szeredi config->redirect_dir = config->redirect_follow = false; 7472d2f2d73SMiklos Szeredi config->metacopy = false; 7482d2f2d73SMiklos Szeredi } 7492d2f2d73SMiklos Szeredi 750d5791044SVivek Goyal return 0; 751e9be9d5eSMiklos Szeredi } 752e9be9d5eSMiklos Szeredi 753e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 75402bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 755e9be9d5eSMiklos Szeredi 756ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 7576b8aa129SAmir Goldstein const char *name, bool persist) 758e9be9d5eSMiklos Szeredi { 759ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 76008f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 761e9be9d5eSMiklos Szeredi struct dentry *work; 762e9be9d5eSMiklos Szeredi int err; 763e9be9d5eSMiklos Szeredi bool retried = false; 764e9be9d5eSMiklos Szeredi 7655955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 766e9be9d5eSMiklos Szeredi retry: 76722f289ceSChristian Brauner work = ovl_lookup_upper(ofs, name, ofs->workbasedir, strlen(name)); 768e9be9d5eSMiklos Szeredi 769e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 770c11b9fddSMiklos Szeredi struct iattr attr = { 771c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 77232a3d848SAl Viro .ia_mode = S_IFDIR | 0, 773c11b9fddSMiklos Szeredi }; 774e9be9d5eSMiklos Szeredi 775e9be9d5eSMiklos Szeredi if (work->d_inode) { 776e9be9d5eSMiklos Szeredi err = -EEXIST; 777e9be9d5eSMiklos Szeredi if (retried) 778e9be9d5eSMiklos Szeredi goto out_dput; 779e9be9d5eSMiklos Szeredi 7806b8aa129SAmir Goldstein if (persist) 7816b8aa129SAmir Goldstein goto out_unlock; 7826b8aa129SAmir Goldstein 783e9be9d5eSMiklos Szeredi retried = true; 784576bb263SChristian Brauner err = ovl_workdir_cleanup(ofs, dir, mnt, work, 0); 785e9be9d5eSMiklos Szeredi dput(work); 786235ce9edSAmir Goldstein if (err == -EINVAL) { 787235ce9edSAmir Goldstein work = ERR_PTR(err); 788235ce9edSAmir Goldstein goto out_unlock; 789235ce9edSAmir Goldstein } 790e9be9d5eSMiklos Szeredi goto retry; 791e9be9d5eSMiklos Szeredi } 792e9be9d5eSMiklos Szeredi 793576bb263SChristian Brauner err = ovl_mkdir_real(ofs, dir, &work, attr.ia_mode); 7941f5573cfSMiklos Szeredi if (err) 7951f5573cfSMiklos Szeredi goto out_dput; 7961f5573cfSMiklos Szeredi 7971f5573cfSMiklos Szeredi /* Weird filesystem returning with hashed negative (kernfs)? */ 7981f5573cfSMiklos Szeredi err = -EINVAL; 7991f5573cfSMiklos Szeredi if (d_really_is_negative(work)) 8001f5573cfSMiklos Szeredi goto out_dput; 801c11b9fddSMiklos Szeredi 802cb348edbSMiklos Szeredi /* 803cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 804cb348edbSMiklos Szeredi * 805cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 806cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 807cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 808cb348edbSMiklos Szeredi * 809cb348edbSMiklos Szeredi * There are various other error values that could effectively 810cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 811cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 812cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 813cb348edbSMiklos Szeredi * for the above two errors is sufficient. 814cb348edbSMiklos Szeredi */ 815c914c0e2SAmir Goldstein err = ovl_do_removexattr(ofs, work, 816c7c7a1a1STycho Andersen XATTR_NAME_POSIX_ACL_DEFAULT); 817e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 818c11b9fddSMiklos Szeredi goto out_dput; 819c11b9fddSMiklos Szeredi 820c914c0e2SAmir Goldstein err = ovl_do_removexattr(ofs, work, 821c7c7a1a1STycho Andersen XATTR_NAME_POSIX_ACL_ACCESS); 822e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 823c11b9fddSMiklos Szeredi goto out_dput; 824c11b9fddSMiklos Szeredi 825c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 826c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 827a15506eaSChristian Brauner err = ovl_do_notify_change(ofs, work, &attr); 828c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 829c11b9fddSMiklos Szeredi if (err) 830c11b9fddSMiklos Szeredi goto out_dput; 8316b8aa129SAmir Goldstein } else { 8326b8aa129SAmir Goldstein err = PTR_ERR(work); 8336b8aa129SAmir Goldstein goto out_err; 834e9be9d5eSMiklos Szeredi } 835e9be9d5eSMiklos Szeredi out_unlock: 8366b8aa129SAmir Goldstein inode_unlock(dir); 837e9be9d5eSMiklos Szeredi return work; 838e9be9d5eSMiklos Szeredi 839e9be9d5eSMiklos Szeredi out_dput: 840e9be9d5eSMiklos Szeredi dput(work); 8416b8aa129SAmir Goldstein out_err: 8421bd0a3aeSlijiazi pr_warn("failed to create directory %s/%s (errno: %i); mounting read-only\n", 843ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 8446b8aa129SAmir Goldstein work = NULL; 845e9be9d5eSMiklos Szeredi goto out_unlock; 846e9be9d5eSMiklos Szeredi } 847e9be9d5eSMiklos Szeredi 84891c77947SMiklos Szeredi static void ovl_unescape(char *s) 84991c77947SMiklos Szeredi { 85091c77947SMiklos Szeredi char *d = s; 85191c77947SMiklos Szeredi 85291c77947SMiklos Szeredi for (;; s++, d++) { 85391c77947SMiklos Szeredi if (*s == '\\') 85491c77947SMiklos Szeredi s++; 85591c77947SMiklos Szeredi *d = *s; 85691c77947SMiklos Szeredi if (!*s) 85791c77947SMiklos Szeredi break; 85891c77947SMiklos Szeredi } 85991c77947SMiklos Szeredi } 86091c77947SMiklos Szeredi 861ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 862ab508822SMiklos Szeredi { 863a78d9f0dSMiklos Szeredi int err = -EINVAL; 864ab508822SMiklos Szeredi 865a78d9f0dSMiklos Szeredi if (!*name) { 8661bd0a3aeSlijiazi pr_err("empty lowerdir\n"); 867a78d9f0dSMiklos Szeredi goto out; 868a78d9f0dSMiklos Szeredi } 869ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 870ab508822SMiklos Szeredi if (err) { 8711bd0a3aeSlijiazi pr_err("failed to resolve '%s': %i\n", name, err); 872ab508822SMiklos Szeredi goto out; 873ab508822SMiklos Szeredi } 874ab508822SMiklos Szeredi err = -EINVAL; 8757c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 8761bd0a3aeSlijiazi pr_err("filesystem on '%s' not supported\n", name); 877ab508822SMiklos Szeredi goto out_put; 878ab508822SMiklos Szeredi } 8792b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 8801bd0a3aeSlijiazi pr_err("'%s' not a directory\n", name); 881ab508822SMiklos Szeredi goto out_put; 882ab508822SMiklos Szeredi } 883ab508822SMiklos Szeredi return 0; 884ab508822SMiklos Szeredi 885ab508822SMiklos Szeredi out_put: 8868aafcb59SMiklos Szeredi path_put_init(path); 887ab508822SMiklos Szeredi out: 888ab508822SMiklos Szeredi return err; 889ab508822SMiklos Szeredi } 890ab508822SMiklos Szeredi 891ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 892ab508822SMiklos Szeredi { 893ab508822SMiklos Szeredi int err = -ENOMEM; 894ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 895ab508822SMiklos Szeredi 896ab508822SMiklos Szeredi if (tmp) { 897ab508822SMiklos Szeredi ovl_unescape(tmp); 898ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 8997c03b5d4SMiklos Szeredi 900bccece1eSMiklos Szeredi if (!err && path->dentry->d_flags & DCACHE_OP_REAL) { 9011bd0a3aeSlijiazi pr_err("filesystem on '%s' not supported as upperdir\n", 9027c03b5d4SMiklos Szeredi tmp); 9038aafcb59SMiklos Szeredi path_put_init(path); 9047c03b5d4SMiklos Szeredi err = -EINVAL; 9057c03b5d4SMiklos Szeredi } 906ab508822SMiklos Szeredi kfree(tmp); 907ab508822SMiklos Szeredi } 908ab508822SMiklos Szeredi return err; 909ab508822SMiklos Szeredi } 910ab508822SMiklos Szeredi 9116b2d5fe4SMiklos Szeredi static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 9126b2d5fe4SMiklos Szeredi const char *name) 9136b2d5fe4SMiklos Szeredi { 9146b2d5fe4SMiklos Szeredi struct kstatfs statfs; 9156b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 9166b2d5fe4SMiklos Szeredi 9176b2d5fe4SMiklos Szeredi if (err) 9181bd0a3aeSlijiazi pr_err("statfs failed on '%s'\n", name); 9196b2d5fe4SMiklos Szeredi else 9206b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 9216b2d5fe4SMiklos Szeredi 9226b2d5fe4SMiklos Szeredi return err; 9236b2d5fe4SMiklos Szeredi } 9246b2d5fe4SMiklos Szeredi 9256b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 926f4288844SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth) 927ab508822SMiklos Szeredi { 928e487d889SAmir Goldstein int fh_type; 929ab508822SMiklos Szeredi int err; 930ab508822SMiklos Szeredi 931a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 932ab508822SMiklos Szeredi if (err) 933b8e42a65SMiklos Szeredi return err; 934ab508822SMiklos Szeredi 9356b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 9366b2d5fe4SMiklos Szeredi if (err) 937b8e42a65SMiklos Szeredi return err; 9386b2d5fe4SMiklos Szeredi 939ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 940ab508822SMiklos Szeredi 94102bcd157SAmir Goldstein /* 942f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode 943f168f109SAmir Goldstein * file handles, so they require that all layers support them. 94402bcd157SAmir Goldstein */ 945e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(path->dentry->d_sb); 946f168f109SAmir Goldstein if ((ofs->config.nfs_export || 947e487d889SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 94802bcd157SAmir Goldstein ofs->config.index = false; 949f168f109SAmir Goldstein ofs->config.nfs_export = false; 9501bd0a3aeSlijiazi pr_warn("fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 951f168f109SAmir Goldstein name); 95202bcd157SAmir Goldstein } 953b0e0f697SAmir Goldstein /* 954b0e0f697SAmir Goldstein * Decoding origin file handle is required for persistent st_ino. 955b0e0f697SAmir Goldstein * Without persistent st_ino, xino=auto falls back to xino=off. 956b0e0f697SAmir Goldstein */ 957b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO && 958b0e0f697SAmir Goldstein ofs->config.upperdir && !fh_type) { 959b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 960b0e0f697SAmir Goldstein pr_warn("fs on '%s' does not support file handles, falling back to xino=off.\n", 961b0e0f697SAmir Goldstein name); 962b0e0f697SAmir Goldstein } 96302bcd157SAmir Goldstein 964e487d889SAmir Goldstein /* Check if lower fs has 32bit inode numbers */ 965e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 9660f831ec8SAmir Goldstein ofs->xino_mode = -1; 967e487d889SAmir Goldstein 968ab508822SMiklos Szeredi return 0; 969ab508822SMiklos Szeredi } 970ab508822SMiklos Szeredi 971e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 972e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 973e9be9d5eSMiklos Szeredi { 974e9be9d5eSMiklos Szeredi bool ok = false; 975e9be9d5eSMiklos Szeredi 976e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 977e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 978e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 979e9be9d5eSMiklos Szeredi } 980e9be9d5eSMiklos Szeredi return ok; 981e9be9d5eSMiklos Szeredi } 982e9be9d5eSMiklos Szeredi 983a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 984a78d9f0dSMiklos Szeredi { 985a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 986a78d9f0dSMiklos Szeredi char *s, *d; 987a78d9f0dSMiklos Szeredi 988a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 989a78d9f0dSMiklos Szeredi if (*s == '\\') { 990a78d9f0dSMiklos Szeredi s++; 991a78d9f0dSMiklos Szeredi } else if (*s == ':') { 992a78d9f0dSMiklos Szeredi *d = '\0'; 993a78d9f0dSMiklos Szeredi ctr++; 994a78d9f0dSMiklos Szeredi continue; 995a78d9f0dSMiklos Szeredi } 996a78d9f0dSMiklos Szeredi *d = *s; 997a78d9f0dSMiklos Szeredi if (!*s) 998a78d9f0dSMiklos Szeredi break; 999a78d9f0dSMiklos Szeredi } 1000a78d9f0dSMiklos Szeredi return ctr; 1001a78d9f0dSMiklos Szeredi } 1002a78d9f0dSMiklos Szeredi 10030c97be22SAndreas Gruenbacher static int __maybe_unused 10040eb45fc3SAndreas Gruenbacher ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 10050eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 10060eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 10070eb45fc3SAndreas Gruenbacher { 10084a47c638SChristian Brauner if (!IS_POSIXACL(inode)) 10094a47c638SChristian Brauner return -EOPNOTSUPP; 10104a47c638SChristian Brauner 10111d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 10120eb45fc3SAndreas Gruenbacher } 10130eb45fc3SAndreas Gruenbacher 10140eb45fc3SAndreas Gruenbacher static int __maybe_unused 10150c97be22SAndreas Gruenbacher ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 1016e65ce2a5SChristian Brauner struct user_namespace *mnt_userns, 1017d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 1018d837a49bSMiklos Szeredi const char *name, const void *value, 1019d837a49bSMiklos Szeredi size_t size, int flags) 1020d837a49bSMiklos Szeredi { 1021d837a49bSMiklos Szeredi struct dentry *workdir = ovl_workdir(dentry); 102209d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 1023d837a49bSMiklos Szeredi struct posix_acl *acl = NULL; 1024d837a49bSMiklos Szeredi int err; 1025d837a49bSMiklos Szeredi 10264a47c638SChristian Brauner if (!IS_POSIXACL(inode)) 10274a47c638SChristian Brauner return -EOPNOTSUPP; 10284a47c638SChristian Brauner 1029d837a49bSMiklos Szeredi /* Check that everything is OK before copy-up */ 1030d837a49bSMiklos Szeredi if (value) { 1031d837a49bSMiklos Szeredi acl = posix_acl_from_xattr(&init_user_ns, value, size); 1032d837a49bSMiklos Szeredi if (IS_ERR(acl)) 1033d837a49bSMiklos Szeredi return PTR_ERR(acl); 1034d837a49bSMiklos Szeredi } 1035d837a49bSMiklos Szeredi err = -EOPNOTSUPP; 1036d837a49bSMiklos Szeredi if (!IS_POSIXACL(d_inode(workdir))) 1037d837a49bSMiklos Szeredi goto out_acl_release; 1038d837a49bSMiklos Szeredi if (!realinode->i_op->set_acl) 1039d837a49bSMiklos Szeredi goto out_acl_release; 1040d837a49bSMiklos Szeredi if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 1041d837a49bSMiklos Szeredi err = acl ? -EACCES : 0; 1042d837a49bSMiklos Szeredi goto out_acl_release; 1043d837a49bSMiklos Szeredi } 1044d837a49bSMiklos Szeredi err = -EPERM; 104521cb47beSChristian Brauner if (!inode_owner_or_capable(&init_user_ns, inode)) 1046d837a49bSMiklos Szeredi goto out_acl_release; 1047d837a49bSMiklos Szeredi 1048d837a49bSMiklos Szeredi posix_acl_release(acl); 1049d837a49bSMiklos Szeredi 1050fd3220d3SMiklos Szeredi /* 1051fd3220d3SMiklos Szeredi * Check if sgid bit needs to be cleared (actual setacl operation will 1052fd3220d3SMiklos Szeredi * be done with mounter's capabilities and so that won't do it for us). 1053fd3220d3SMiklos Szeredi */ 1054fd3220d3SMiklos Szeredi if (unlikely(inode->i_mode & S_ISGID) && 1055fd3220d3SMiklos Szeredi handler->flags == ACL_TYPE_ACCESS && 1056fd3220d3SMiklos Szeredi !in_group_p(inode->i_gid) && 10570558c1bfSChristian Brauner !capable_wrt_inode_uidgid(&init_user_ns, inode, CAP_FSETID)) { 1058fd3220d3SMiklos Szeredi struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 1059fd3220d3SMiklos Szeredi 1060549c7297SChristian Brauner err = ovl_setattr(&init_user_ns, dentry, &iattr); 1061fd3220d3SMiklos Szeredi if (err) 1062fd3220d3SMiklos Szeredi return err; 1063fd3220d3SMiklos Szeredi } 1064fd3220d3SMiklos Szeredi 10651d88f183SMiklos Szeredi err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 1066ce31513aSMiklos Szeredi return err; 1067d837a49bSMiklos Szeredi 1068d837a49bSMiklos Szeredi out_acl_release: 1069d837a49bSMiklos Szeredi posix_acl_release(acl); 1070d837a49bSMiklos Szeredi return err; 1071d837a49bSMiklos Szeredi } 1072d837a49bSMiklos Szeredi 10730eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 10740eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 10750eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 10760eb45fc3SAndreas Gruenbacher { 107748fab5d7SAmir Goldstein return -EOPNOTSUPP; 10780eb45fc3SAndreas Gruenbacher } 10790eb45fc3SAndreas Gruenbacher 1080d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 1081e65ce2a5SChristian Brauner struct user_namespace *mnt_userns, 1082d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 1083d837a49bSMiklos Szeredi const char *name, const void *value, 1084d837a49bSMiklos Szeredi size_t size, int flags) 1085d837a49bSMiklos Szeredi { 108648fab5d7SAmir Goldstein return -EOPNOTSUPP; 1087d837a49bSMiklos Szeredi } 1088d837a49bSMiklos Szeredi 10890eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 10900eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 10910eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 10920eb45fc3SAndreas Gruenbacher { 10931d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 10940eb45fc3SAndreas Gruenbacher } 10950eb45fc3SAndreas Gruenbacher 10960e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 1097e65ce2a5SChristian Brauner struct user_namespace *mnt_userns, 10980e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 10990e585cccSAndreas Gruenbacher const char *name, const void *value, 11000e585cccSAndreas Gruenbacher size_t size, int flags) 11010e585cccSAndreas Gruenbacher { 11021d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 11030e585cccSAndreas Gruenbacher } 11040e585cccSAndreas Gruenbacher 11050c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 11060c97be22SAndreas Gruenbacher ovl_posix_acl_access_xattr_handler = { 1107d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_ACCESS, 1108d837a49bSMiklos Szeredi .flags = ACL_TYPE_ACCESS, 11090eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 1110d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 1111d837a49bSMiklos Szeredi }; 1112d837a49bSMiklos Szeredi 11130c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 11140c97be22SAndreas Gruenbacher ovl_posix_acl_default_xattr_handler = { 1115d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_DEFAULT, 1116d837a49bSMiklos Szeredi .flags = ACL_TYPE_DEFAULT, 11170eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 1118d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 1119d837a49bSMiklos Szeredi }; 1120d837a49bSMiklos Szeredi 11212d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_trusted_xattr_handler = { 11222d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_TRUSTED_PREFIX, 11232d2f2d73SMiklos Szeredi .get = ovl_own_xattr_get, 11242d2f2d73SMiklos Szeredi .set = ovl_own_xattr_set, 11252d2f2d73SMiklos Szeredi }; 11262d2f2d73SMiklos Szeredi 11272d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_user_xattr_handler = { 11282d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_USER_PREFIX, 11290eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 1130d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 1131d837a49bSMiklos Szeredi }; 1132d837a49bSMiklos Szeredi 1133d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 1134d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 11350eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 1136d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 1137d837a49bSMiklos Szeredi }; 1138d837a49bSMiklos Szeredi 11392d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_trusted_xattr_handlers[] = { 11400c97be22SAndreas Gruenbacher #ifdef CONFIG_FS_POSIX_ACL 1141d837a49bSMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 1142d837a49bSMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 11430c97be22SAndreas Gruenbacher #endif 11442d2f2d73SMiklos Szeredi &ovl_own_trusted_xattr_handler, 11452d2f2d73SMiklos Szeredi &ovl_other_xattr_handler, 11462d2f2d73SMiklos Szeredi NULL 11472d2f2d73SMiklos Szeredi }; 11482d2f2d73SMiklos Szeredi 11492d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_user_xattr_handlers[] = { 11502d2f2d73SMiklos Szeredi #ifdef CONFIG_FS_POSIX_ACL 11512d2f2d73SMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 11522d2f2d73SMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 11532d2f2d73SMiklos Szeredi #endif 11542d2f2d73SMiklos Szeredi &ovl_own_user_xattr_handler, 1155d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 1156d837a49bSMiklos Szeredi NULL 1157d837a49bSMiklos Szeredi }; 1158d837a49bSMiklos Szeredi 1159146d62e5SAmir Goldstein static int ovl_setup_trap(struct super_block *sb, struct dentry *dir, 1160146d62e5SAmir Goldstein struct inode **ptrap, const char *name) 1161146d62e5SAmir Goldstein { 1162146d62e5SAmir Goldstein struct inode *trap; 1163146d62e5SAmir Goldstein int err; 1164146d62e5SAmir Goldstein 1165146d62e5SAmir Goldstein trap = ovl_get_trap_inode(sb, dir); 11661dac6f5bSArnd Bergmann err = PTR_ERR_OR_ZERO(trap); 11671dac6f5bSArnd Bergmann if (err) { 1168146d62e5SAmir Goldstein if (err == -ELOOP) 11691bd0a3aeSlijiazi pr_err("conflicting %s path\n", name); 1170146d62e5SAmir Goldstein return err; 1171146d62e5SAmir Goldstein } 1172146d62e5SAmir Goldstein 1173146d62e5SAmir Goldstein *ptrap = trap; 1174146d62e5SAmir Goldstein return 0; 1175146d62e5SAmir Goldstein } 1176146d62e5SAmir Goldstein 11770be0bfd2SAmir Goldstein /* 11780be0bfd2SAmir Goldstein * Determine how we treat concurrent use of upperdir/workdir based on the 11790be0bfd2SAmir Goldstein * index feature. This is papering over mount leaks of container runtimes, 11800be0bfd2SAmir Goldstein * for example, an old overlay mount is leaked and now its upperdir is 11810be0bfd2SAmir Goldstein * attempted to be used as a lower layer in a new overlay mount. 11820be0bfd2SAmir Goldstein */ 11830be0bfd2SAmir Goldstein static int ovl_report_in_use(struct ovl_fs *ofs, const char *name) 11840be0bfd2SAmir Goldstein { 11850be0bfd2SAmir Goldstein if (ofs->config.index) { 11861bd0a3aeSlijiazi pr_err("%s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n", 11870be0bfd2SAmir Goldstein name); 11880be0bfd2SAmir Goldstein return -EBUSY; 11890be0bfd2SAmir Goldstein } else { 11901bd0a3aeSlijiazi pr_warn("%s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n", 11910be0bfd2SAmir Goldstein name); 11920be0bfd2SAmir Goldstein return 0; 11930be0bfd2SAmir Goldstein } 11940be0bfd2SAmir Goldstein } 11950be0bfd2SAmir Goldstein 1196146d62e5SAmir Goldstein static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs, 1197b8e42a65SMiklos Szeredi struct ovl_layer *upper_layer, struct path *upperpath) 11986ee8acf0SMiklos Szeredi { 11995064975eSMiklos Szeredi struct vfsmount *upper_mnt; 12006ee8acf0SMiklos Szeredi int err; 12016ee8acf0SMiklos Szeredi 1202ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.upperdir, upperpath); 12036ee8acf0SMiklos Szeredi if (err) 12046ee8acf0SMiklos Szeredi goto out; 12056ee8acf0SMiklos Szeredi 1206e21a6c57SAmir Goldstein /* Upperdir path should not be r/o */ 1207e21a6c57SAmir Goldstein if (__mnt_is_readonly(upperpath->mnt)) { 12081bd0a3aeSlijiazi pr_err("upper fs is r/o, try multi-lower layers mount\n"); 12096ee8acf0SMiklos Szeredi err = -EINVAL; 12106ee8acf0SMiklos Szeredi goto out; 12116ee8acf0SMiklos Szeredi } 12126ee8acf0SMiklos Szeredi 1213ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 12146ee8acf0SMiklos Szeredi if (err) 12156ee8acf0SMiklos Szeredi goto out; 12166ee8acf0SMiklos Szeredi 1217b8e42a65SMiklos Szeredi err = ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap, 1218146d62e5SAmir Goldstein "upperdir"); 1219146d62e5SAmir Goldstein if (err) 1220146d62e5SAmir Goldstein goto out; 1221146d62e5SAmir Goldstein 12225064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 12235064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 12245064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 12251bd0a3aeSlijiazi pr_err("failed to clone upperpath\n"); 12265064975eSMiklos Szeredi goto out; 12275064975eSMiklos Szeredi } 12285064975eSMiklos Szeredi 12295064975eSMiklos Szeredi /* Don't inherit atime flags */ 12305064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 1231b8e42a65SMiklos Szeredi upper_layer->mnt = upper_mnt; 1232b8e42a65SMiklos Szeredi upper_layer->idx = 0; 1233b8e42a65SMiklos Szeredi upper_layer->fsid = 0; 12348c25741aSMiklos Szeredi 1235654255faSJeffle Xu /* 1236654255faSJeffle Xu * Inherit SB_NOSEC flag from upperdir. 1237654255faSJeffle Xu * 1238654255faSJeffle Xu * This optimization changes behavior when a security related attribute 1239654255faSJeffle Xu * (suid/sgid/security.*) is changed on an underlying layer. This is 1240654255faSJeffle Xu * okay because we don't yet have guarantees in that case, but it will 1241654255faSJeffle Xu * need careful treatment once we want to honour changes to underlying 1242654255faSJeffle Xu * filesystems. 1243654255faSJeffle Xu */ 1244654255faSJeffle Xu if (upper_mnt->mnt_sb->s_flags & SB_NOSEC) 1245654255faSJeffle Xu sb->s_flags |= SB_NOSEC; 1246654255faSJeffle Xu 124708f4c7c8SMiklos Szeredi if (ovl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) { 12488c25741aSMiklos Szeredi ofs->upperdir_locked = true; 12498c25741aSMiklos Szeredi } else { 12500be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "upperdir"); 12510be0bfd2SAmir Goldstein if (err) 12520be0bfd2SAmir Goldstein goto out; 12538c25741aSMiklos Szeredi } 12548c25741aSMiklos Szeredi 12556ee8acf0SMiklos Szeredi err = 0; 12566ee8acf0SMiklos Szeredi out: 12576ee8acf0SMiklos Szeredi return err; 12586ee8acf0SMiklos Szeredi } 12596ee8acf0SMiklos Szeredi 1260cad218abSAmir Goldstein /* 1261cad218abSAmir Goldstein * Returns 1 if RENAME_WHITEOUT is supported, 0 if not supported and 1262cad218abSAmir Goldstein * negative values if error is encountered. 1263cad218abSAmir Goldstein */ 1264576bb263SChristian Brauner static int ovl_check_rename_whiteout(struct ovl_fs *ofs) 1265cad218abSAmir Goldstein { 1266576bb263SChristian Brauner struct dentry *workdir = ofs->workdir; 1267cad218abSAmir Goldstein struct inode *dir = d_inode(workdir); 1268cad218abSAmir Goldstein struct dentry *temp; 1269cad218abSAmir Goldstein struct dentry *dest; 1270cad218abSAmir Goldstein struct dentry *whiteout; 1271cad218abSAmir Goldstein struct name_snapshot name; 1272cad218abSAmir Goldstein int err; 1273cad218abSAmir Goldstein 1274cad218abSAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 1275cad218abSAmir Goldstein 1276576bb263SChristian Brauner temp = ovl_create_temp(ofs, workdir, OVL_CATTR(S_IFREG | 0)); 1277cad218abSAmir Goldstein err = PTR_ERR(temp); 1278cad218abSAmir Goldstein if (IS_ERR(temp)) 1279cad218abSAmir Goldstein goto out_unlock; 1280cad218abSAmir Goldstein 1281576bb263SChristian Brauner dest = ovl_lookup_temp(ofs, workdir); 1282cad218abSAmir Goldstein err = PTR_ERR(dest); 1283cad218abSAmir Goldstein if (IS_ERR(dest)) { 1284cad218abSAmir Goldstein dput(temp); 1285cad218abSAmir Goldstein goto out_unlock; 1286cad218abSAmir Goldstein } 1287cad218abSAmir Goldstein 1288cad218abSAmir Goldstein /* Name is inline and stable - using snapshot as a copy helper */ 1289cad218abSAmir Goldstein take_dentry_name_snapshot(&name, temp); 1290576bb263SChristian Brauner err = ovl_do_rename(ofs, dir, temp, dir, dest, RENAME_WHITEOUT); 1291cad218abSAmir Goldstein if (err) { 1292cad218abSAmir Goldstein if (err == -EINVAL) 1293cad218abSAmir Goldstein err = 0; 1294cad218abSAmir Goldstein goto cleanup_temp; 1295cad218abSAmir Goldstein } 1296cad218abSAmir Goldstein 129722f289ceSChristian Brauner whiteout = ovl_lookup_upper(ofs, name.name.name, workdir, name.name.len); 1298cad218abSAmir Goldstein err = PTR_ERR(whiteout); 1299cad218abSAmir Goldstein if (IS_ERR(whiteout)) 1300cad218abSAmir Goldstein goto cleanup_temp; 1301cad218abSAmir Goldstein 1302cad218abSAmir Goldstein err = ovl_is_whiteout(whiteout); 1303cad218abSAmir Goldstein 1304cad218abSAmir Goldstein /* Best effort cleanup of whiteout and temp file */ 1305cad218abSAmir Goldstein if (err) 1306576bb263SChristian Brauner ovl_cleanup(ofs, dir, whiteout); 1307cad218abSAmir Goldstein dput(whiteout); 1308cad218abSAmir Goldstein 1309cad218abSAmir Goldstein cleanup_temp: 1310576bb263SChristian Brauner ovl_cleanup(ofs, dir, temp); 1311cad218abSAmir Goldstein release_dentry_name_snapshot(&name); 1312cad218abSAmir Goldstein dput(temp); 1313cad218abSAmir Goldstein dput(dest); 1314cad218abSAmir Goldstein 1315cad218abSAmir Goldstein out_unlock: 1316cad218abSAmir Goldstein inode_unlock(dir); 1317cad218abSAmir Goldstein 1318cad218abSAmir Goldstein return err; 1319cad218abSAmir Goldstein } 1320cad218abSAmir Goldstein 1321576bb263SChristian Brauner static struct dentry *ovl_lookup_or_create(struct ovl_fs *ofs, 1322576bb263SChristian Brauner struct dentry *parent, 1323c86243b0SVivek Goyal const char *name, umode_t mode) 1324c86243b0SVivek Goyal { 1325c86243b0SVivek Goyal size_t len = strlen(name); 1326c86243b0SVivek Goyal struct dentry *child; 1327c86243b0SVivek Goyal 1328c86243b0SVivek Goyal inode_lock_nested(parent->d_inode, I_MUTEX_PARENT); 132922f289ceSChristian Brauner child = ovl_lookup_upper(ofs, name, parent, len); 1330c86243b0SVivek Goyal if (!IS_ERR(child) && !child->d_inode) 1331576bb263SChristian Brauner child = ovl_create_real(ofs, parent->d_inode, child, 1332c86243b0SVivek Goyal OVL_CATTR(mode)); 1333c86243b0SVivek Goyal inode_unlock(parent->d_inode); 1334c86243b0SVivek Goyal dput(parent); 1335c86243b0SVivek Goyal 1336c86243b0SVivek Goyal return child; 1337c86243b0SVivek Goyal } 1338c86243b0SVivek Goyal 1339c86243b0SVivek Goyal /* 1340c86243b0SVivek Goyal * Creates $workdir/work/incompat/volatile/dirty file if it is not already 1341c86243b0SVivek Goyal * present. 1342c86243b0SVivek Goyal */ 1343c86243b0SVivek Goyal static int ovl_create_volatile_dirty(struct ovl_fs *ofs) 1344c86243b0SVivek Goyal { 1345c86243b0SVivek Goyal unsigned int ctr; 1346c86243b0SVivek Goyal struct dentry *d = dget(ofs->workbasedir); 1347c86243b0SVivek Goyal static const char *const volatile_path[] = { 1348c86243b0SVivek Goyal OVL_WORKDIR_NAME, "incompat", "volatile", "dirty" 1349c86243b0SVivek Goyal }; 1350c86243b0SVivek Goyal const char *const *name = volatile_path; 1351c86243b0SVivek Goyal 1352c86243b0SVivek Goyal for (ctr = ARRAY_SIZE(volatile_path); ctr; ctr--, name++) { 1353576bb263SChristian Brauner d = ovl_lookup_or_create(ofs, d, *name, ctr > 1 ? S_IFDIR : S_IFREG); 1354c86243b0SVivek Goyal if (IS_ERR(d)) 1355c86243b0SVivek Goyal return PTR_ERR(d); 1356c86243b0SVivek Goyal } 1357c86243b0SVivek Goyal dput(d); 1358c86243b0SVivek Goyal return 0; 1359c86243b0SVivek Goyal } 1360c86243b0SVivek Goyal 1361146d62e5SAmir Goldstein static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs, 1362146d62e5SAmir Goldstein struct path *workpath) 13638ed61dc3SMiklos Szeredi { 136408f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 1365235ce9edSAmir Goldstein struct dentry *temp, *workdir; 1366d80172c2SAmir Goldstein bool rename_whiteout; 1367d80172c2SAmir Goldstein bool d_type; 1368e487d889SAmir Goldstein int fh_type; 13698ed61dc3SMiklos Szeredi int err; 13708ed61dc3SMiklos Szeredi 13712ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 13722ba9d57eSAmir Goldstein if (err) 13732ba9d57eSAmir Goldstein return err; 13742ba9d57eSAmir Goldstein 1375235ce9edSAmir Goldstein workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 1376235ce9edSAmir Goldstein err = PTR_ERR(workdir); 1377235ce9edSAmir Goldstein if (IS_ERR_OR_NULL(workdir)) 13782ba9d57eSAmir Goldstein goto out; 13798ed61dc3SMiklos Szeredi 1380235ce9edSAmir Goldstein ofs->workdir = workdir; 1381235ce9edSAmir Goldstein 1382146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir"); 1383146d62e5SAmir Goldstein if (err) 1384146d62e5SAmir Goldstein goto out; 1385146d62e5SAmir Goldstein 13868ed61dc3SMiklos Szeredi /* 13878ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 13888ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 13898ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 13908ed61dc3SMiklos Szeredi * previous step. 13918ed61dc3SMiklos Szeredi */ 13928ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 13938ed61dc3SMiklos Szeredi if (err < 0) 13942ba9d57eSAmir Goldstein goto out; 13958ed61dc3SMiklos Szeredi 1396d80172c2SAmir Goldstein d_type = err; 1397d80172c2SAmir Goldstein if (!d_type) 13981bd0a3aeSlijiazi pr_warn("upper fs needs to support d_type.\n"); 13998ed61dc3SMiklos Szeredi 14008ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 1401576bb263SChristian Brauner temp = ovl_do_tmpfile(ofs, ofs->workdir, S_IFREG | 0); 1402ad204488SMiklos Szeredi ofs->tmpfile = !IS_ERR(temp); 1403ad204488SMiklos Szeredi if (ofs->tmpfile) 14048ed61dc3SMiklos Szeredi dput(temp); 14058ed61dc3SMiklos Szeredi else 14061bd0a3aeSlijiazi pr_warn("upper fs does not support tmpfile.\n"); 14078ed61dc3SMiklos Szeredi 1408cad218abSAmir Goldstein 1409cad218abSAmir Goldstein /* Check if upper/work fs supports RENAME_WHITEOUT */ 1410576bb263SChristian Brauner err = ovl_check_rename_whiteout(ofs); 1411cad218abSAmir Goldstein if (err < 0) 1412cad218abSAmir Goldstein goto out; 1413cad218abSAmir Goldstein 1414d80172c2SAmir Goldstein rename_whiteout = err; 1415d80172c2SAmir Goldstein if (!rename_whiteout) 1416cad218abSAmir Goldstein pr_warn("upper fs does not support RENAME_WHITEOUT.\n"); 1417cad218abSAmir Goldstein 14188ed61dc3SMiklos Szeredi /* 14192d2f2d73SMiklos Szeredi * Check if upper/work fs supports (trusted|user).overlay.* xattr 14208ed61dc3SMiklos Szeredi */ 1421c914c0e2SAmir Goldstein err = ovl_setxattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE, "0", 1); 14228ed61dc3SMiklos Szeredi if (err) { 1423b10b85feSMiklos Szeredi pr_warn("failed to set xattr on upper\n"); 1424ad204488SMiklos Szeredi ofs->noxattr = true; 1425b0e0f697SAmir Goldstein if (ofs->config.index || ofs->config.metacopy) { 1426a683737bSAmir Goldstein ofs->config.index = false; 1427d5791044SVivek Goyal ofs->config.metacopy = false; 1428b10b85feSMiklos Szeredi pr_warn("...falling back to index=off,metacopy=off.\n"); 1429b0e0f697SAmir Goldstein } 1430b0e0f697SAmir Goldstein /* 1431b0e0f697SAmir Goldstein * xattr support is required for persistent st_ino. 1432b0e0f697SAmir Goldstein * Without persistent st_ino, xino=auto falls back to xino=off. 1433b0e0f697SAmir Goldstein */ 1434b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO) { 1435b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 1436b10b85feSMiklos Szeredi pr_warn("...falling back to xino=off.\n"); 1437b0e0f697SAmir Goldstein } 1438b10b85feSMiklos Szeredi if (err == -EPERM && !ofs->config.userxattr) 1439b10b85feSMiklos Szeredi pr_info("try mounting with 'userxattr' option\n"); 14402ba9d57eSAmir Goldstein err = 0; 14418ed61dc3SMiklos Szeredi } else { 1442c914c0e2SAmir Goldstein ovl_removexattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE); 14438ed61dc3SMiklos Szeredi } 14448ed61dc3SMiklos Szeredi 1445d80172c2SAmir Goldstein /* 1446d80172c2SAmir Goldstein * We allowed sub-optimal upper fs configuration and don't want to break 1447d80172c2SAmir Goldstein * users over kernel upgrade, but we never allowed remote upper fs, so 1448d80172c2SAmir Goldstein * we can enforce strict requirements for remote upper fs. 1449d80172c2SAmir Goldstein */ 1450d80172c2SAmir Goldstein if (ovl_dentry_remote(ofs->workdir) && 1451d80172c2SAmir Goldstein (!d_type || !rename_whiteout || ofs->noxattr)) { 1452d80172c2SAmir Goldstein pr_err("upper fs missing required features.\n"); 1453d80172c2SAmir Goldstein err = -EINVAL; 1454d80172c2SAmir Goldstein goto out; 1455d80172c2SAmir Goldstein } 1456d80172c2SAmir Goldstein 1457c86243b0SVivek Goyal /* 1458c86243b0SVivek Goyal * For volatile mount, create a incompat/volatile/dirty file to keep 1459c86243b0SVivek Goyal * track of it. 1460c86243b0SVivek Goyal */ 1461c86243b0SVivek Goyal if (ofs->config.ovl_volatile) { 1462c86243b0SVivek Goyal err = ovl_create_volatile_dirty(ofs); 1463c86243b0SVivek Goyal if (err < 0) { 1464c86243b0SVivek Goyal pr_err("Failed to create volatile/dirty file.\n"); 1465c86243b0SVivek Goyal goto out; 1466c86243b0SVivek Goyal } 1467c86243b0SVivek Goyal } 1468c86243b0SVivek Goyal 14698ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 1470e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 1471e487d889SAmir Goldstein if (ofs->config.index && !fh_type) { 1472ad204488SMiklos Szeredi ofs->config.index = false; 14731bd0a3aeSlijiazi pr_warn("upper fs does not support file handles, falling back to index=off.\n"); 14748ed61dc3SMiklos Szeredi } 14758ed61dc3SMiklos Szeredi 1476e487d889SAmir Goldstein /* Check if upper fs has 32bit inode numbers */ 1477e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 14780f831ec8SAmir Goldstein ofs->xino_mode = -1; 1479e487d889SAmir Goldstein 1480f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */ 1481f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) { 14821bd0a3aeSlijiazi pr_warn("NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 1483f168f109SAmir Goldstein ofs->config.nfs_export = false; 1484f168f109SAmir Goldstein } 14852ba9d57eSAmir Goldstein out: 14862ba9d57eSAmir Goldstein mnt_drop_write(mnt); 14872ba9d57eSAmir Goldstein return err; 14888ed61dc3SMiklos Szeredi } 14898ed61dc3SMiklos Szeredi 1490146d62e5SAmir Goldstein static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs, 1491146d62e5SAmir Goldstein struct path *upperpath) 1492520d7c86SMiklos Szeredi { 1493520d7c86SMiklos Szeredi int err; 1494bca44b52SMiklos Szeredi struct path workpath = { }; 1495520d7c86SMiklos Szeredi 1496ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.workdir, &workpath); 1497520d7c86SMiklos Szeredi if (err) 1498520d7c86SMiklos Szeredi goto out; 1499520d7c86SMiklos Szeredi 1500520d7c86SMiklos Szeredi err = -EINVAL; 1501bca44b52SMiklos Szeredi if (upperpath->mnt != workpath.mnt) { 15021bd0a3aeSlijiazi pr_err("workdir and upperdir must reside under the same mount\n"); 1503520d7c86SMiklos Szeredi goto out; 1504520d7c86SMiklos Szeredi } 1505bca44b52SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 15061bd0a3aeSlijiazi pr_err("workdir and upperdir must be separate subtrees\n"); 1507520d7c86SMiklos Szeredi goto out; 1508520d7c86SMiklos Szeredi } 1509520d7c86SMiklos Szeredi 15108c25741aSMiklos Szeredi ofs->workbasedir = dget(workpath.dentry); 15118c25741aSMiklos Szeredi 15128c25741aSMiklos Szeredi if (ovl_inuse_trylock(ofs->workbasedir)) { 1513ad204488SMiklos Szeredi ofs->workdir_locked = true; 1514520d7c86SMiklos Szeredi } else { 15150be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "workdir"); 15160be0bfd2SAmir Goldstein if (err) 15170be0bfd2SAmir Goldstein goto out; 1518520d7c86SMiklos Szeredi } 1519520d7c86SMiklos Szeredi 15200be0bfd2SAmir Goldstein err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap, 15210be0bfd2SAmir Goldstein "workdir"); 15220be0bfd2SAmir Goldstein if (err) 15230be0bfd2SAmir Goldstein goto out; 15240be0bfd2SAmir Goldstein 1525146d62e5SAmir Goldstein err = ovl_make_workdir(sb, ofs, &workpath); 1526bca44b52SMiklos Szeredi 1527520d7c86SMiklos Szeredi out: 1528bca44b52SMiklos Szeredi path_put(&workpath); 1529bca44b52SMiklos Szeredi 1530520d7c86SMiklos Szeredi return err; 1531520d7c86SMiklos Szeredi } 1532520d7c86SMiklos Szeredi 1533146d62e5SAmir Goldstein static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs, 1534146d62e5SAmir Goldstein struct ovl_entry *oe, struct path *upperpath) 1535f7e3a7d9SMiklos Szeredi { 153608f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 1537235ce9edSAmir Goldstein struct dentry *indexdir; 1538f7e3a7d9SMiklos Szeredi int err; 1539f7e3a7d9SMiklos Szeredi 15402ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 15412ba9d57eSAmir Goldstein if (err) 15422ba9d57eSAmir Goldstein return err; 15432ba9d57eSAmir Goldstein 1544f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 1545610afc0bSMiklos Szeredi err = ovl_verify_origin(ofs, upperpath->dentry, 1546610afc0bSMiklos Szeredi oe->lowerstack[0].dentry, true); 1547f7e3a7d9SMiklos Szeredi if (err) { 15481bd0a3aeSlijiazi pr_err("failed to verify upper root origin\n"); 1549f7e3a7d9SMiklos Szeredi goto out; 1550f7e3a7d9SMiklos Szeredi } 1551f7e3a7d9SMiklos Szeredi 155220396365SAmir Goldstein /* index dir will act also as workdir */ 155320396365SAmir Goldstein iput(ofs->workdir_trap); 155420396365SAmir Goldstein ofs->workdir_trap = NULL; 155520396365SAmir Goldstein dput(ofs->workdir); 1556470c1563SAmir Goldstein ofs->workdir = NULL; 1557235ce9edSAmir Goldstein indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1558235ce9edSAmir Goldstein if (IS_ERR(indexdir)) { 1559235ce9edSAmir Goldstein err = PTR_ERR(indexdir); 1560235ce9edSAmir Goldstein } else if (indexdir) { 1561235ce9edSAmir Goldstein ofs->indexdir = indexdir; 1562235ce9edSAmir Goldstein ofs->workdir = dget(indexdir); 156320396365SAmir Goldstein 1564146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap, 1565146d62e5SAmir Goldstein "indexdir"); 1566146d62e5SAmir Goldstein if (err) 1567146d62e5SAmir Goldstein goto out; 1568146d62e5SAmir Goldstein 1569ad1d615cSAmir Goldstein /* 1570ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir. 15712d2f2d73SMiklos Szeredi * Older kernels stored upper fh in ".overlay.origin" 1572ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to 1573ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr 15742d2f2d73SMiklos Szeredi * ".overlay.upper" to indicate that index may have 1575ad1d615cSAmir Goldstein * directory entries. 1576ad1d615cSAmir Goldstein */ 1577610afc0bSMiklos Szeredi if (ovl_check_origin_xattr(ofs, ofs->indexdir)) { 1578610afc0bSMiklos Szeredi err = ovl_verify_set_fh(ofs, ofs->indexdir, 1579610afc0bSMiklos Szeredi OVL_XATTR_ORIGIN, 1580ad1d615cSAmir Goldstein upperpath->dentry, true, false); 1581f7e3a7d9SMiklos Szeredi if (err) 15821bd0a3aeSlijiazi pr_err("failed to verify index dir 'origin' xattr\n"); 1583ad1d615cSAmir Goldstein } 1584610afc0bSMiklos Szeredi err = ovl_verify_upper(ofs, ofs->indexdir, upperpath->dentry, 1585610afc0bSMiklos Szeredi true); 1586ad1d615cSAmir Goldstein if (err) 15871bd0a3aeSlijiazi pr_err("failed to verify index dir 'upper' xattr\n"); 1588f7e3a7d9SMiklos Szeredi 1589f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 1590f7e3a7d9SMiklos Szeredi if (!err) 15911eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs); 1592f7e3a7d9SMiklos Szeredi } 1593ad204488SMiklos Szeredi if (err || !ofs->indexdir) 15941bd0a3aeSlijiazi pr_warn("try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1595f7e3a7d9SMiklos Szeredi 1596f7e3a7d9SMiklos Szeredi out: 15972ba9d57eSAmir Goldstein mnt_drop_write(mnt); 1598f7e3a7d9SMiklos Szeredi return err; 1599f7e3a7d9SMiklos Szeredi } 1600f7e3a7d9SMiklos Szeredi 16019df085f3SAmir Goldstein static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid) 16025148626bSAmir Goldstein { 16035148626bSAmir Goldstein unsigned int i; 16049df085f3SAmir Goldstein 160508f4c7c8SMiklos Szeredi if (!ofs->config.nfs_export && !ovl_upper_mnt(ofs)) 16069df085f3SAmir Goldstein return true; 16079df085f3SAmir Goldstein 1608a888db31SAmir Goldstein /* 1609a888db31SAmir Goldstein * We allow using single lower with null uuid for index and nfs_export 1610a888db31SAmir Goldstein * for example to support those features with single lower squashfs. 1611a888db31SAmir Goldstein * To avoid regressions in setups of overlay with re-formatted lower 1612a888db31SAmir Goldstein * squashfs, do not allow decoding origin with lower null uuid unless 1613a888db31SAmir Goldstein * user opted-in to one of the new features that require following the 1614a888db31SAmir Goldstein * lower inode of non-dir upper. 1615a888db31SAmir Goldstein */ 1616ca45275cSVyacheslav Yurkov if (ovl_allow_offline_changes(ofs) && uuid_is_null(uuid)) 1617a888db31SAmir Goldstein return false; 1618a888db31SAmir Goldstein 16191b81ddddSAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 16209df085f3SAmir Goldstein /* 16219df085f3SAmir Goldstein * We use uuid to associate an overlay lower file handle with a 16229df085f3SAmir Goldstein * lower layer, so we can accept lower fs with null uuid as long 16239df085f3SAmir Goldstein * as all lower layers with null uuid are on the same fs. 16247e63c87fSAmir Goldstein * if we detect multiple lower fs with the same uuid, we 16257e63c87fSAmir Goldstein * disable lower file handle decoding on all of them. 16269df085f3SAmir Goldstein */ 16271b81ddddSAmir Goldstein if (ofs->fs[i].is_lower && 16281b81ddddSAmir Goldstein uuid_equal(&ofs->fs[i].sb->s_uuid, uuid)) { 162907f1e596SAmir Goldstein ofs->fs[i].bad_uuid = true; 16309df085f3SAmir Goldstein return false; 16319df085f3SAmir Goldstein } 16327e63c87fSAmir Goldstein } 16339df085f3SAmir Goldstein return true; 16349df085f3SAmir Goldstein } 16359df085f3SAmir Goldstein 16369df085f3SAmir Goldstein /* Get a unique fsid for the layer */ 16379df085f3SAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) 16389df085f3SAmir Goldstein { 16399df085f3SAmir Goldstein struct super_block *sb = path->mnt->mnt_sb; 16409df085f3SAmir Goldstein unsigned int i; 16415148626bSAmir Goldstein dev_t dev; 16425148626bSAmir Goldstein int err; 16437e63c87fSAmir Goldstein bool bad_uuid = false; 1644b0e0f697SAmir Goldstein bool warn = false; 16455148626bSAmir Goldstein 164607f1e596SAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 164707f1e596SAmir Goldstein if (ofs->fs[i].sb == sb) 164807f1e596SAmir Goldstein return i; 16495148626bSAmir Goldstein } 16505148626bSAmir Goldstein 16519df085f3SAmir Goldstein if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) { 16527e63c87fSAmir Goldstein bad_uuid = true; 1653b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO) { 1654b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 1655b0e0f697SAmir Goldstein warn = true; 1656b0e0f697SAmir Goldstein } 16577e63c87fSAmir Goldstein if (ofs->config.index || ofs->config.nfs_export) { 16589df085f3SAmir Goldstein ofs->config.index = false; 16599df085f3SAmir Goldstein ofs->config.nfs_export = false; 1660b0e0f697SAmir Goldstein warn = true; 1661b0e0f697SAmir Goldstein } 1662b0e0f697SAmir Goldstein if (warn) { 1663b0e0f697SAmir Goldstein pr_warn("%s uuid detected in lower fs '%pd2', falling back to xino=%s,index=off,nfs_export=off.\n", 16647e63c87fSAmir Goldstein uuid_is_null(&sb->s_uuid) ? "null" : 16657e63c87fSAmir Goldstein "conflicting", 1666b0e0f697SAmir Goldstein path->dentry, ovl_xino_str[ofs->config.xino]); 16679df085f3SAmir Goldstein } 16687e63c87fSAmir Goldstein } 16699df085f3SAmir Goldstein 16705148626bSAmir Goldstein err = get_anon_bdev(&dev); 16715148626bSAmir Goldstein if (err) { 16721bd0a3aeSlijiazi pr_err("failed to get anonymous bdev for lowerpath\n"); 16735148626bSAmir Goldstein return err; 16745148626bSAmir Goldstein } 16755148626bSAmir Goldstein 167607f1e596SAmir Goldstein ofs->fs[ofs->numfs].sb = sb; 167707f1e596SAmir Goldstein ofs->fs[ofs->numfs].pseudo_dev = dev; 167807f1e596SAmir Goldstein ofs->fs[ofs->numfs].bad_uuid = bad_uuid; 16795148626bSAmir Goldstein 168007f1e596SAmir Goldstein return ofs->numfs++; 16815148626bSAmir Goldstein } 16825148626bSAmir Goldstein 168394375f9dSAmir Goldstein static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, 1684b8e42a65SMiklos Szeredi struct path *stack, unsigned int numlower, 1685b8e42a65SMiklos Szeredi struct ovl_layer *layers) 1686520d7c86SMiklos Szeredi { 1687520d7c86SMiklos Szeredi int err; 1688520d7c86SMiklos Szeredi unsigned int i; 1689520d7c86SMiklos Szeredi 1690520d7c86SMiklos Szeredi err = -ENOMEM; 169107f1e596SAmir Goldstein ofs->fs = kcalloc(numlower + 1, sizeof(struct ovl_sb), GFP_KERNEL); 169207f1e596SAmir Goldstein if (ofs->fs == NULL) 16935148626bSAmir Goldstein goto out; 16945148626bSAmir Goldstein 169507f1e596SAmir Goldstein /* idx/fsid 0 are reserved for upper fs even with lower only overlay */ 169607f1e596SAmir Goldstein ofs->numfs++; 169707f1e596SAmir Goldstein 169807f1e596SAmir Goldstein /* 1699b7bf9908SAmir Goldstein * All lower layers that share the same fs as upper layer, use the same 1700b7bf9908SAmir Goldstein * pseudo_dev as upper layer. Allocate fs[0].pseudo_dev even for lower 1701b7bf9908SAmir Goldstein * only overlay to simplify ovl_fs_free(). 17021b81ddddSAmir Goldstein * is_lower will be set if upper fs is shared with a lower layer. 170307f1e596SAmir Goldstein */ 1704b7bf9908SAmir Goldstein err = get_anon_bdev(&ofs->fs[0].pseudo_dev); 1705b7bf9908SAmir Goldstein if (err) { 1706b7bf9908SAmir Goldstein pr_err("failed to get anonymous bdev for upper fs\n"); 1707b7bf9908SAmir Goldstein goto out; 1708b7bf9908SAmir Goldstein } 1709b7bf9908SAmir Goldstein 171008f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 171108f4c7c8SMiklos Szeredi ofs->fs[0].sb = ovl_upper_mnt(ofs)->mnt_sb; 17121b81ddddSAmir Goldstein ofs->fs[0].is_lower = false; 171307f1e596SAmir Goldstein } 171407f1e596SAmir Goldstein 1715520d7c86SMiklos Szeredi for (i = 0; i < numlower; i++) { 1716520d7c86SMiklos Szeredi struct vfsmount *mnt; 1717146d62e5SAmir Goldstein struct inode *trap; 17185148626bSAmir Goldstein int fsid; 1719520d7c86SMiklos Szeredi 17209df085f3SAmir Goldstein err = fsid = ovl_get_fsid(ofs, &stack[i]); 17215148626bSAmir Goldstein if (err < 0) 1722520d7c86SMiklos Szeredi goto out; 1723520d7c86SMiklos Szeredi 172424f14009Syoungjun /* 172524f14009Syoungjun * Check if lower root conflicts with this overlay layers before 172624f14009Syoungjun * checking if it is in-use as upperdir/workdir of "another" 172724f14009Syoungjun * mount, because we do not bother to check in ovl_is_inuse() if 172824f14009Syoungjun * the upperdir/workdir is in fact in-use by our 172924f14009Syoungjun * upperdir/workdir. 173024f14009Syoungjun */ 1731146d62e5SAmir Goldstein err = ovl_setup_trap(sb, stack[i].dentry, &trap, "lowerdir"); 1732146d62e5SAmir Goldstein if (err) 1733146d62e5SAmir Goldstein goto out; 1734146d62e5SAmir Goldstein 17350be0bfd2SAmir Goldstein if (ovl_is_inuse(stack[i].dentry)) { 17360be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "lowerdir"); 173724f14009Syoungjun if (err) { 173824f14009Syoungjun iput(trap); 17390be0bfd2SAmir Goldstein goto out; 17400be0bfd2SAmir Goldstein } 174124f14009Syoungjun } 17420be0bfd2SAmir Goldstein 1743520d7c86SMiklos Szeredi mnt = clone_private_mount(&stack[i]); 1744520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1745520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 17461bd0a3aeSlijiazi pr_err("failed to clone lowerpath\n"); 1747146d62e5SAmir Goldstein iput(trap); 1748520d7c86SMiklos Szeredi goto out; 1749520d7c86SMiklos Szeredi } 17505148626bSAmir Goldstein 1751520d7c86SMiklos Szeredi /* 1752520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1753520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1754520d7c86SMiklos Szeredi */ 1755520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1756520d7c86SMiklos Szeredi 175713464165SMiklos Szeredi layers[ofs->numlayer].trap = trap; 175813464165SMiklos Szeredi layers[ofs->numlayer].mnt = mnt; 175913464165SMiklos Szeredi layers[ofs->numlayer].idx = ofs->numlayer; 176013464165SMiklos Szeredi layers[ofs->numlayer].fsid = fsid; 176113464165SMiklos Szeredi layers[ofs->numlayer].fs = &ofs->fs[fsid]; 176294375f9dSAmir Goldstein ofs->numlayer++; 17631b81ddddSAmir Goldstein ofs->fs[fsid].is_lower = true; 1764520d7c86SMiklos Szeredi } 1765e487d889SAmir Goldstein 1766795939a9SAmir Goldstein /* 1767795939a9SAmir Goldstein * When all layers on same fs, overlay can use real inode numbers. 1768926e94d7SAmir Goldstein * With mount option "xino=<on|auto>", mounter declares that there are 1769926e94d7SAmir Goldstein * enough free high bits in underlying fs to hold the unique fsid. 1770795939a9SAmir Goldstein * If overlayfs does encounter underlying inodes using the high xino 1771795939a9SAmir Goldstein * bits reserved for fsid, it emits a warning and uses the original 1772dfe51d47SAmir Goldstein * inode number or a non persistent inode number allocated from a 1773dfe51d47SAmir Goldstein * dedicated range. 1774795939a9SAmir Goldstein */ 177508f4c7c8SMiklos Szeredi if (ofs->numfs - !ovl_upper_mnt(ofs) == 1) { 17760f831ec8SAmir Goldstein if (ofs->config.xino == OVL_XINO_ON) 17770f831ec8SAmir Goldstein pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n"); 17780f831ec8SAmir Goldstein ofs->xino_mode = 0; 177953afcd31SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_OFF) { 178053afcd31SAmir Goldstein ofs->xino_mode = -1; 1781926e94d7SAmir Goldstein } else if (ofs->xino_mode < 0) { 1782795939a9SAmir Goldstein /* 178307f1e596SAmir Goldstein * This is a roundup of number of bits needed for encoding 1784dfe51d47SAmir Goldstein * fsid, where fsid 0 is reserved for upper fs (even with 1785dfe51d47SAmir Goldstein * lower only overlay) +1 extra bit is reserved for the non 1786dfe51d47SAmir Goldstein * persistent inode number range that is used for resolving 1787dfe51d47SAmir Goldstein * xino lower bits overflow. 1788795939a9SAmir Goldstein */ 1789dfe51d47SAmir Goldstein BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 30); 1790dfe51d47SAmir Goldstein ofs->xino_mode = ilog2(ofs->numfs - 1) + 2; 1791795939a9SAmir Goldstein } 1792795939a9SAmir Goldstein 17930f831ec8SAmir Goldstein if (ofs->xino_mode > 0) { 17941bd0a3aeSlijiazi pr_info("\"xino\" feature enabled using %d upper inode bits.\n", 17950f831ec8SAmir Goldstein ofs->xino_mode); 1796795939a9SAmir Goldstein } 1797e487d889SAmir Goldstein 1798520d7c86SMiklos Szeredi err = 0; 1799520d7c86SMiklos Szeredi out: 1800520d7c86SMiklos Szeredi return err; 1801520d7c86SMiklos Szeredi } 1802520d7c86SMiklos Szeredi 18034155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1804b8e42a65SMiklos Szeredi const char *lower, unsigned int numlower, 1805b8e42a65SMiklos Szeredi struct ovl_fs *ofs, struct ovl_layer *layers) 180653dbb0b4SMiklos Szeredi { 180753dbb0b4SMiklos Szeredi int err; 18084155c10aSMiklos Szeredi struct path *stack = NULL; 1809b8e42a65SMiklos Szeredi unsigned int i; 18104155c10aSMiklos Szeredi struct ovl_entry *oe; 181153dbb0b4SMiklos Szeredi 1812b8e42a65SMiklos Szeredi if (!ofs->config.upperdir && numlower == 1) { 18131bd0a3aeSlijiazi pr_err("at least 2 lowerdir are needed while upperdir nonexistent\n"); 1814b8e42a65SMiklos Szeredi return ERR_PTR(-EINVAL); 181553dbb0b4SMiklos Szeredi } 181653dbb0b4SMiklos Szeredi 1817b8e42a65SMiklos Szeredi stack = kcalloc(numlower, sizeof(struct path), GFP_KERNEL); 181853dbb0b4SMiklos Szeredi if (!stack) 1819b8e42a65SMiklos Szeredi return ERR_PTR(-ENOMEM); 182053dbb0b4SMiklos Szeredi 182153dbb0b4SMiklos Szeredi err = -EINVAL; 1822b8e42a65SMiklos Szeredi for (i = 0; i < numlower; i++) { 1823b8e42a65SMiklos Szeredi err = ovl_lower_dir(lower, &stack[i], ofs, &sb->s_stack_depth); 182453dbb0b4SMiklos Szeredi if (err) 18254155c10aSMiklos Szeredi goto out_err; 182653dbb0b4SMiklos Szeredi 182753dbb0b4SMiklos Szeredi lower = strchr(lower, '\0') + 1; 182853dbb0b4SMiklos Szeredi } 182953dbb0b4SMiklos Szeredi 183053dbb0b4SMiklos Szeredi err = -EINVAL; 183153dbb0b4SMiklos Szeredi sb->s_stack_depth++; 183253dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 18331bd0a3aeSlijiazi pr_err("maximum fs stacking depth exceeded\n"); 18344155c10aSMiklos Szeredi goto out_err; 183553dbb0b4SMiklos Szeredi } 183653dbb0b4SMiklos Szeredi 1837b8e42a65SMiklos Szeredi err = ovl_get_layers(sb, ofs, stack, numlower, layers); 18384155c10aSMiklos Szeredi if (err) 18394155c10aSMiklos Szeredi goto out_err; 18404155c10aSMiklos Szeredi 18414155c10aSMiklos Szeredi err = -ENOMEM; 18424155c10aSMiklos Szeredi oe = ovl_alloc_entry(numlower); 18434155c10aSMiklos Szeredi if (!oe) 18444155c10aSMiklos Szeredi goto out_err; 18454155c10aSMiklos Szeredi 18464155c10aSMiklos Szeredi for (i = 0; i < numlower; i++) { 18474155c10aSMiklos Szeredi oe->lowerstack[i].dentry = dget(stack[i].dentry); 184894375f9dSAmir Goldstein oe->lowerstack[i].layer = &ofs->layers[i+1]; 18494155c10aSMiklos Szeredi } 185053dbb0b4SMiklos Szeredi 185153dbb0b4SMiklos Szeredi out: 185253dbb0b4SMiklos Szeredi for (i = 0; i < numlower; i++) 185353dbb0b4SMiklos Szeredi path_put(&stack[i]); 185453dbb0b4SMiklos Szeredi kfree(stack); 18554155c10aSMiklos Szeredi 18564155c10aSMiklos Szeredi return oe; 18574155c10aSMiklos Szeredi 18584155c10aSMiklos Szeredi out_err: 18594155c10aSMiklos Szeredi oe = ERR_PTR(err); 186053dbb0b4SMiklos Szeredi goto out; 186153dbb0b4SMiklos Szeredi } 186253dbb0b4SMiklos Szeredi 1863146d62e5SAmir Goldstein /* 1864146d62e5SAmir Goldstein * Check if this layer root is a descendant of: 1865146d62e5SAmir Goldstein * - another layer of this overlayfs instance 1866146d62e5SAmir Goldstein * - upper/work dir of any overlayfs instance 1867146d62e5SAmir Goldstein */ 18680be0bfd2SAmir Goldstein static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs, 1869708fa015SMiklos Szeredi struct dentry *dentry, const char *name, 1870708fa015SMiklos Szeredi bool is_lower) 1871146d62e5SAmir Goldstein { 18729179c21dSMiklos Szeredi struct dentry *next = dentry, *parent; 1873146d62e5SAmir Goldstein int err = 0; 1874146d62e5SAmir Goldstein 18759179c21dSMiklos Szeredi if (!dentry) 1876146d62e5SAmir Goldstein return 0; 1877146d62e5SAmir Goldstein 1878146d62e5SAmir Goldstein parent = dget_parent(next); 18799179c21dSMiklos Szeredi 18809179c21dSMiklos Szeredi /* Walk back ancestors to root (inclusive) looking for traps */ 18819179c21dSMiklos Szeredi while (!err && parent != next) { 1882708fa015SMiklos Szeredi if (is_lower && ovl_lookup_trap_inode(sb, parent)) { 1883146d62e5SAmir Goldstein err = -ELOOP; 18841bd0a3aeSlijiazi pr_err("overlapping %s path\n", name); 18850be0bfd2SAmir Goldstein } else if (ovl_is_inuse(parent)) { 18860be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, name); 1887146d62e5SAmir Goldstein } 1888146d62e5SAmir Goldstein next = parent; 18899179c21dSMiklos Szeredi parent = dget_parent(next); 18909179c21dSMiklos Szeredi dput(next); 1891146d62e5SAmir Goldstein } 1892146d62e5SAmir Goldstein 18939179c21dSMiklos Szeredi dput(parent); 1894146d62e5SAmir Goldstein 1895146d62e5SAmir Goldstein return err; 1896146d62e5SAmir Goldstein } 1897146d62e5SAmir Goldstein 1898146d62e5SAmir Goldstein /* 1899146d62e5SAmir Goldstein * Check if any of the layers or work dirs overlap. 1900146d62e5SAmir Goldstein */ 1901146d62e5SAmir Goldstein static int ovl_check_overlapping_layers(struct super_block *sb, 1902146d62e5SAmir Goldstein struct ovl_fs *ofs) 1903146d62e5SAmir Goldstein { 1904146d62e5SAmir Goldstein int i, err; 1905146d62e5SAmir Goldstein 190608f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 190708f4c7c8SMiklos Szeredi err = ovl_check_layer(sb, ofs, ovl_upper_mnt(ofs)->mnt_root, 1908708fa015SMiklos Szeredi "upperdir", false); 1909146d62e5SAmir Goldstein if (err) 1910146d62e5SAmir Goldstein return err; 1911146d62e5SAmir Goldstein 1912146d62e5SAmir Goldstein /* 1913146d62e5SAmir Goldstein * Checking workbasedir avoids hitting ovl_is_inuse(parent) of 1914146d62e5SAmir Goldstein * this instance and covers overlapping work and index dirs, 1915146d62e5SAmir Goldstein * unless work or index dir have been moved since created inside 1916146d62e5SAmir Goldstein * workbasedir. In that case, we already have their traps in 1917146d62e5SAmir Goldstein * inode cache and we will catch that case on lookup. 1918146d62e5SAmir Goldstein */ 1919708fa015SMiklos Szeredi err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir", 1920708fa015SMiklos Szeredi false); 1921146d62e5SAmir Goldstein if (err) 1922146d62e5SAmir Goldstein return err; 1923146d62e5SAmir Goldstein } 1924146d62e5SAmir Goldstein 192594375f9dSAmir Goldstein for (i = 1; i < ofs->numlayer; i++) { 19260be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, 192794375f9dSAmir Goldstein ofs->layers[i].mnt->mnt_root, 1928708fa015SMiklos Szeredi "lowerdir", true); 1929146d62e5SAmir Goldstein if (err) 1930146d62e5SAmir Goldstein return err; 1931146d62e5SAmir Goldstein } 1932146d62e5SAmir Goldstein 1933146d62e5SAmir Goldstein return 0; 1934146d62e5SAmir Goldstein } 1935146d62e5SAmir Goldstein 19362effc5c2SAmir Goldstein static struct dentry *ovl_get_root(struct super_block *sb, 19372effc5c2SAmir Goldstein struct dentry *upperdentry, 19382effc5c2SAmir Goldstein struct ovl_entry *oe) 19392effc5c2SAmir Goldstein { 19402effc5c2SAmir Goldstein struct dentry *root; 194162c832edSAmir Goldstein struct ovl_path *lowerpath = &oe->lowerstack[0]; 194262c832edSAmir Goldstein unsigned long ino = d_inode(lowerpath->dentry)->i_ino; 194362c832edSAmir Goldstein int fsid = lowerpath->layer->fsid; 194462c832edSAmir Goldstein struct ovl_inode_params oip = { 194562c832edSAmir Goldstein .upperdentry = upperdentry, 194662c832edSAmir Goldstein .lowerpath = lowerpath, 194762c832edSAmir Goldstein }; 19482effc5c2SAmir Goldstein 19492effc5c2SAmir Goldstein root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 19502effc5c2SAmir Goldstein if (!root) 19512effc5c2SAmir Goldstein return NULL; 19522effc5c2SAmir Goldstein 19532effc5c2SAmir Goldstein root->d_fsdata = oe; 19542effc5c2SAmir Goldstein 19552effc5c2SAmir Goldstein if (upperdentry) { 195662c832edSAmir Goldstein /* Root inode uses upper st_ino/i_ino */ 195762c832edSAmir Goldstein ino = d_inode(upperdentry)->i_ino; 195862c832edSAmir Goldstein fsid = 0; 19592effc5c2SAmir Goldstein ovl_dentry_set_upper_alias(root); 1960610afc0bSMiklos Szeredi if (ovl_is_impuredir(sb, upperdentry)) 19612effc5c2SAmir Goldstein ovl_set_flag(OVL_IMPURE, d_inode(root)); 19622effc5c2SAmir Goldstein } 19632effc5c2SAmir Goldstein 19642effc5c2SAmir Goldstein /* Root is always merge -> can have whiteouts */ 19652effc5c2SAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root)); 19662effc5c2SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root); 19672effc5c2SAmir Goldstein ovl_set_upperdata(d_inode(root)); 196862c832edSAmir Goldstein ovl_inode_init(d_inode(root), &oip, ino, fsid); 1969f4288844SMiklos Szeredi ovl_dentry_update_reval(root, upperdentry, DCACHE_OP_WEAK_REVALIDATE); 19702effc5c2SAmir Goldstein 19712effc5c2SAmir Goldstein return root; 19722effc5c2SAmir Goldstein } 19732effc5c2SAmir Goldstein 19744a47c638SChristian Brauner static bool ovl_has_idmapped_layers(struct ovl_fs *ofs) 19754a47c638SChristian Brauner { 19764a47c638SChristian Brauner 19774a47c638SChristian Brauner unsigned int i; 19784a47c638SChristian Brauner const struct vfsmount *mnt; 19794a47c638SChristian Brauner 19804a47c638SChristian Brauner for (i = 0; i < ofs->numlayer; i++) { 19814a47c638SChristian Brauner mnt = ofs->layers[i].mnt; 19824a47c638SChristian Brauner if (mnt && is_idmapped_mnt(mnt)) 19834a47c638SChristian Brauner return true; 19844a47c638SChristian Brauner } 19854a47c638SChristian Brauner return false; 19864a47c638SChristian Brauner } 19874a47c638SChristian Brauner 1988e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1989e9be9d5eSMiklos Szeredi { 199033006cdfSKees Cook struct path upperpath = { }; 1991e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 19924155c10aSMiklos Szeredi struct ovl_entry *oe; 1993ad204488SMiklos Szeredi struct ovl_fs *ofs; 1994b8e42a65SMiklos Szeredi struct ovl_layer *layers; 199551f8f3c4SKonstantin Khlebnikov struct cred *cred; 1996b8e42a65SMiklos Szeredi char *splitlower = NULL; 1997b8e42a65SMiklos Szeredi unsigned int numlower; 1998e9be9d5eSMiklos Szeredi int err; 1999e9be9d5eSMiklos Szeredi 20009efb069dSMiklos Szeredi err = -EIO; 20019efb069dSMiklos Szeredi if (WARN_ON(sb->s_user_ns != current_user_ns())) 20029efb069dSMiklos Szeredi goto out; 20039efb069dSMiklos Szeredi 2004f4288844SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 2005f4288844SMiklos Szeredi 2006f45827e8SErez Zadok err = -ENOMEM; 2007ad204488SMiklos Szeredi ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 2008ad204488SMiklos Szeredi if (!ofs) 2009e9be9d5eSMiklos Szeredi goto out; 2010e9be9d5eSMiklos Szeredi 2011d7b49b10SChengguang Xu err = -ENOMEM; 2012ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 2013c6fe6254SMiklos Szeredi if (!cred) 2014c6fe6254SMiklos Szeredi goto out_err; 2015c6fe6254SMiklos Szeredi 2016c21c839bSChengguang Xu /* Is there a reason anyone would want not to share whiteouts? */ 2017c21c839bSChengguang Xu ofs->share_whiteout = true; 2018c21c839bSChengguang Xu 2019ad204488SMiklos Szeredi ofs->config.index = ovl_index_def; 20205830fb6bSPavel Tikhomirov ofs->config.uuid = true; 2021f168f109SAmir Goldstein ofs->config.nfs_export = ovl_nfs_export_def; 2022795939a9SAmir Goldstein ofs->config.xino = ovl_xino_def(); 2023d5791044SVivek Goyal ofs->config.metacopy = ovl_metacopy_def; 2024ad204488SMiklos Szeredi err = ovl_parse_opt((char *) data, &ofs->config); 2025f45827e8SErez Zadok if (err) 2026a9075cdbSMiklos Szeredi goto out_err; 2027f45827e8SErez Zadok 2028e9be9d5eSMiklos Szeredi err = -EINVAL; 2029ad204488SMiklos Szeredi if (!ofs->config.lowerdir) { 203007f2af7bSKonstantin Khlebnikov if (!silent) 20311bd0a3aeSlijiazi pr_err("missing 'lowerdir'\n"); 2032a9075cdbSMiklos Szeredi goto out_err; 203353a08cb9SMiklos Szeredi } 203453a08cb9SMiklos Szeredi 2035b8e42a65SMiklos Szeredi err = -ENOMEM; 2036b8e42a65SMiklos Szeredi splitlower = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 2037b8e42a65SMiklos Szeredi if (!splitlower) 2038b8e42a65SMiklos Szeredi goto out_err; 2039b8e42a65SMiklos Szeredi 2040d7b49b10SChengguang Xu err = -EINVAL; 2041b8e42a65SMiklos Szeredi numlower = ovl_split_lowerdirs(splitlower); 2042b8e42a65SMiklos Szeredi if (numlower > OVL_MAX_STACK) { 2043b8e42a65SMiklos Szeredi pr_err("too many lower directories, limit is %d\n", 2044b8e42a65SMiklos Szeredi OVL_MAX_STACK); 2045b8e42a65SMiklos Szeredi goto out_err; 2046b8e42a65SMiklos Szeredi } 2047b8e42a65SMiklos Szeredi 2048d7b49b10SChengguang Xu err = -ENOMEM; 2049b8e42a65SMiklos Szeredi layers = kcalloc(numlower + 1, sizeof(struct ovl_layer), GFP_KERNEL); 2050b8e42a65SMiklos Szeredi if (!layers) 2051b8e42a65SMiklos Szeredi goto out_err; 2052b8e42a65SMiklos Szeredi 2053b8e42a65SMiklos Szeredi ofs->layers = layers; 2054b8e42a65SMiklos Szeredi /* Layer 0 is reserved for upper even if there's no upper */ 2055b8e42a65SMiklos Szeredi ofs->numlayer = 1; 2056b8e42a65SMiklos Szeredi 205753a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 2058cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 20594d314f78SAmir Goldstein atomic_long_set(&ofs->last_ino, 1); 2060e487d889SAmir Goldstein /* Assume underlaying fs uses 32bit inodes unless proven otherwise */ 206153afcd31SAmir Goldstein if (ofs->config.xino != OVL_XINO_OFF) { 20620f831ec8SAmir Goldstein ofs->xino_mode = BITS_PER_LONG - 32; 206353afcd31SAmir Goldstein if (!ofs->xino_mode) { 206453afcd31SAmir Goldstein pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n"); 206553afcd31SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 206653afcd31SAmir Goldstein } 206753afcd31SAmir Goldstein } 2068795939a9SAmir Goldstein 2069146d62e5SAmir Goldstein /* alloc/destroy_inode needed for setting up traps in inode cache */ 2070146d62e5SAmir Goldstein sb->s_op = &ovl_super_operations; 2071146d62e5SAmir Goldstein 2072ad204488SMiklos Szeredi if (ofs->config.upperdir) { 2073335d3fc5SSargun Dhillon struct super_block *upper_sb; 2074335d3fc5SSargun Dhillon 2075d7b49b10SChengguang Xu err = -EINVAL; 2076ad204488SMiklos Szeredi if (!ofs->config.workdir) { 20771bd0a3aeSlijiazi pr_err("missing 'workdir'\n"); 2078a9075cdbSMiklos Szeredi goto out_err; 2079e9be9d5eSMiklos Szeredi } 2080e9be9d5eSMiklos Szeredi 2081b8e42a65SMiklos Szeredi err = ovl_get_upper(sb, ofs, &layers[0], &upperpath); 208221a3b317SMiklos Szeredi if (err) 2083a9075cdbSMiklos Szeredi goto out_err; 2084d719e8f2SMiklos Szeredi 2085335d3fc5SSargun Dhillon upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 2086335d3fc5SSargun Dhillon if (!ovl_should_sync(ofs)) { 2087335d3fc5SSargun Dhillon ofs->errseq = errseq_sample(&upper_sb->s_wb_err); 2088335d3fc5SSargun Dhillon if (errseq_check(&upper_sb->s_wb_err, ofs->errseq)) { 2089335d3fc5SSargun Dhillon err = -EIO; 2090335d3fc5SSargun Dhillon pr_err("Cannot mount volatile when upperdir has an unseen error. Sync upperdir fs to clear state.\n"); 2091335d3fc5SSargun Dhillon goto out_err; 2092335d3fc5SSargun Dhillon } 2093335d3fc5SSargun Dhillon } 2094335d3fc5SSargun Dhillon 2095146d62e5SAmir Goldstein err = ovl_get_workdir(sb, ofs, &upperpath); 20968ed61dc3SMiklos Szeredi if (err) 2097a9075cdbSMiklos Szeredi goto out_err; 2098c6fe6254SMiklos Szeredi 2099ad204488SMiklos Szeredi if (!ofs->workdir) 21001751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 21016e88256eSMiklos Szeredi 2102335d3fc5SSargun Dhillon sb->s_stack_depth = upper_sb->s_stack_depth; 2103335d3fc5SSargun Dhillon sb->s_time_gran = upper_sb->s_time_gran; 210421765194SVivek Goyal } 2105b8e42a65SMiklos Szeredi oe = ovl_get_lowerstack(sb, splitlower, numlower, ofs, layers); 21064155c10aSMiklos Szeredi err = PTR_ERR(oe); 21074155c10aSMiklos Szeredi if (IS_ERR(oe)) 2108a9075cdbSMiklos Szeredi goto out_err; 2109e9be9d5eSMiklos Szeredi 211071cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 211108f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 21121751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 2113e9be9d5eSMiklos Szeredi 21145830fb6bSPavel Tikhomirov if (!ofs->config.uuid && ofs->numfs > 1) { 21155830fb6bSPavel Tikhomirov pr_warn("The uuid=off requires a single fs for lower and upper, falling back to uuid=on.\n"); 21165830fb6bSPavel Tikhomirov ofs->config.uuid = true; 21175830fb6bSPavel Tikhomirov } 21185830fb6bSPavel Tikhomirov 2119470c1563SAmir Goldstein if (!ovl_force_readonly(ofs) && ofs->config.index) { 2120146d62e5SAmir Goldstein err = ovl_get_indexdir(sb, ofs, oe, &upperpath); 212154fb347eSAmir Goldstein if (err) 21224155c10aSMiklos Szeredi goto out_free_oe; 21236e88256eSMiklos Szeredi 2124972d0093SAmir Goldstein /* Force r/o mount with no index dir */ 212520396365SAmir Goldstein if (!ofs->indexdir) 21261751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 212702bcd157SAmir Goldstein } 212802bcd157SAmir Goldstein 2129146d62e5SAmir Goldstein err = ovl_check_overlapping_layers(sb, ofs); 2130146d62e5SAmir Goldstein if (err) 2131146d62e5SAmir Goldstein goto out_free_oe; 2132146d62e5SAmir Goldstein 2133972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */ 2134f168f109SAmir Goldstein if (!ofs->indexdir) { 2135ad204488SMiklos Szeredi ofs->config.index = false; 213608f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs) && ofs->config.nfs_export) { 21371bd0a3aeSlijiazi pr_warn("NFS export requires an index dir, falling back to nfs_export=off.\n"); 2138f168f109SAmir Goldstein ofs->config.nfs_export = false; 2139f168f109SAmir Goldstein } 2140f168f109SAmir Goldstein } 214102bcd157SAmir Goldstein 2142d5791044SVivek Goyal if (ofs->config.metacopy && ofs->config.nfs_export) { 21431bd0a3aeSlijiazi pr_warn("NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 2144d5791044SVivek Goyal ofs->config.nfs_export = false; 2145d5791044SVivek Goyal } 2146d5791044SVivek Goyal 21478383f174SAmir Goldstein if (ofs->config.nfs_export) 21488383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations; 21498383f174SAmir Goldstein 215051f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 215151f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 215251f8f3c4SKonstantin Khlebnikov 2153655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 21542d2f2d73SMiklos Szeredi sb->s_xattr = ofs->config.userxattr ? ovl_user_xattr_handlers : 21552d2f2d73SMiklos Szeredi ovl_trusted_xattr_handlers; 2156ad204488SMiklos Szeredi sb->s_fs_info = ofs; 21574a47c638SChristian Brauner if (ovl_has_idmapped_layers(ofs)) 21584a47c638SChristian Brauner pr_warn("POSIX ACLs are not yet supported with idmapped layers, mounting without ACL support.\n"); 21594a47c638SChristian Brauner else 2160de2a4a50SMiklos Szeredi sb->s_flags |= SB_POSIXACL; 216132b1924bSKonstantin Khlebnikov sb->s_iflags |= SB_I_SKIP_SYNC; 2162655042ccSVivek Goyal 2163c6fe6254SMiklos Szeredi err = -ENOMEM; 21642effc5c2SAmir Goldstein root_dentry = ovl_get_root(sb, upperpath.dentry, oe); 2165e9be9d5eSMiklos Szeredi if (!root_dentry) 21664155c10aSMiklos Szeredi goto out_free_oe; 2167e9be9d5eSMiklos Szeredi 2168e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 2169b8e42a65SMiklos Szeredi kfree(splitlower); 2170ed06e069SMiklos Szeredi 2171e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 2172e9be9d5eSMiklos Szeredi 2173e9be9d5eSMiklos Szeredi return 0; 2174e9be9d5eSMiklos Szeredi 21754155c10aSMiklos Szeredi out_free_oe: 21764155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 2177b9343632SChandan Rajendra kfree(oe); 21784155c10aSMiklos Szeredi out_err: 2179b8e42a65SMiklos Szeredi kfree(splitlower); 2180e9be9d5eSMiklos Szeredi path_put(&upperpath); 2181ad204488SMiklos Szeredi ovl_free_fs(ofs); 2182e9be9d5eSMiklos Szeredi out: 2183e9be9d5eSMiklos Szeredi return err; 2184e9be9d5eSMiklos Szeredi } 2185e9be9d5eSMiklos Szeredi 2186e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 2187e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 2188e9be9d5eSMiklos Szeredi { 2189e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 2190e9be9d5eSMiklos Szeredi } 2191e9be9d5eSMiklos Szeredi 2192e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 2193e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 2194ef94b186SMiklos Szeredi .name = "overlay", 2195459c7c56SMiklos Szeredi .fs_flags = FS_USERNS_MOUNT, 2196e9be9d5eSMiklos Szeredi .mount = ovl_mount, 2197e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 2198e9be9d5eSMiklos Szeredi }; 2199ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 2200e9be9d5eSMiklos Szeredi 220113cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 220213cf199dSAmir Goldstein { 220313cf199dSAmir Goldstein struct ovl_inode *oi = foo; 220413cf199dSAmir Goldstein 220513cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 220613cf199dSAmir Goldstein } 220713cf199dSAmir Goldstein 2208e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 2209e9be9d5eSMiklos Szeredi { 221013cf199dSAmir Goldstein int err; 221113cf199dSAmir Goldstein 221213cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 221313cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 221413cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 221513cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 221613cf199dSAmir Goldstein ovl_inode_init_once); 221713cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 221813cf199dSAmir Goldstein return -ENOMEM; 221913cf199dSAmir Goldstein 22202406a307SJiufei Xue err = ovl_aio_request_cache_init(); 22212406a307SJiufei Xue if (!err) { 222213cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 22232406a307SJiufei Xue if (!err) 22242406a307SJiufei Xue return 0; 22252406a307SJiufei Xue 22262406a307SJiufei Xue ovl_aio_request_cache_destroy(); 22272406a307SJiufei Xue } 222813cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 222913cf199dSAmir Goldstein 223013cf199dSAmir Goldstein return err; 2231e9be9d5eSMiklos Szeredi } 2232e9be9d5eSMiklos Szeredi 2233e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 2234e9be9d5eSMiklos Szeredi { 2235e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 223613cf199dSAmir Goldstein 223713cf199dSAmir Goldstein /* 223813cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 223913cf199dSAmir Goldstein * destroy cache. 224013cf199dSAmir Goldstein */ 224113cf199dSAmir Goldstein rcu_barrier(); 224213cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 22432406a307SJiufei Xue ovl_aio_request_cache_destroy(); 2244e9be9d5eSMiklos Szeredi } 2245e9be9d5eSMiklos Szeredi 2246e9be9d5eSMiklos Szeredi module_init(ovl_init); 2247e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 2248