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 { 82d101a125SMiklos Szeredi struct dentry *real; 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 1012c3d7358SVivek Goyal real = ovl_dentry_lowerdata(dentry); 102d101a125SMiklos Szeredi if (!real) 103d101a125SMiklos Szeredi goto bug; 104d101a125SMiklos Szeredi 105c4fcfc16SMiklos Szeredi /* Handle recursion */ 106fb16043bSMiklos Szeredi real = d_real(real, inode); 107c4fcfc16SMiklos Szeredi 108d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 109d101a125SMiklos Szeredi return real; 110d101a125SMiklos Szeredi bug: 111656189d2SMiklos Szeredi WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry, 112d101a125SMiklos Szeredi inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0); 113d101a125SMiklos Szeredi return dentry; 114d101a125SMiklos Szeredi } 115d101a125SMiklos Szeredi 1163bb7df92SMiklos Szeredi static int ovl_revalidate_real(struct dentry *d, unsigned int flags, bool weak) 1173bb7df92SMiklos Szeredi { 1183bb7df92SMiklos Szeredi int ret = 1; 1193bb7df92SMiklos Szeredi 1203bb7df92SMiklos Szeredi if (weak) { 1213bb7df92SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) 1223bb7df92SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1233bb7df92SMiklos Szeredi } else if (d->d_flags & DCACHE_OP_REVALIDATE) { 1243bb7df92SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1253bb7df92SMiklos Szeredi if (!ret) { 1263bb7df92SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1273bb7df92SMiklos Szeredi d_invalidate(d); 1283bb7df92SMiklos Szeredi ret = -ESTALE; 1293bb7df92SMiklos Szeredi } 1303bb7df92SMiklos Szeredi } 1313bb7df92SMiklos Szeredi return ret; 1323bb7df92SMiklos Szeredi } 1333bb7df92SMiklos Szeredi 1343bb7df92SMiklos Szeredi static int ovl_dentry_revalidate_common(struct dentry *dentry, 1353bb7df92SMiklos Szeredi unsigned int flags, bool weak) 1367c03b5d4SMiklos Szeredi { 1377c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 138bccece1eSMiklos Szeredi struct dentry *upper; 1397c03b5d4SMiklos Szeredi unsigned int i; 1407c03b5d4SMiklos Szeredi int ret = 1; 1417c03b5d4SMiklos Szeredi 142bccece1eSMiklos Szeredi upper = ovl_dentry_upper(dentry); 143bccece1eSMiklos Szeredi if (upper) 144bccece1eSMiklos Szeredi ret = ovl_revalidate_real(upper, flags, weak); 145bccece1eSMiklos Szeredi 1463bb7df92SMiklos Szeredi for (i = 0; ret > 0 && i < oe->numlower; i++) { 1473bb7df92SMiklos Szeredi ret = ovl_revalidate_real(oe->lowerstack[i].dentry, flags, 1483bb7df92SMiklos Szeredi weak); 1493bb7df92SMiklos Szeredi } 1507c03b5d4SMiklos Szeredi return ret; 1517c03b5d4SMiklos Szeredi } 1523bb7df92SMiklos Szeredi 1533bb7df92SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 1543bb7df92SMiklos Szeredi { 1553bb7df92SMiklos Szeredi return ovl_dentry_revalidate_common(dentry, flags, false); 1567c03b5d4SMiklos Szeredi } 1577c03b5d4SMiklos Szeredi 1587c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 1597c03b5d4SMiklos Szeredi { 1603bb7df92SMiklos Szeredi return ovl_dentry_revalidate_common(dentry, flags, true); 1617c03b5d4SMiklos Szeredi } 1627c03b5d4SMiklos Szeredi 163e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 164e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 165d101a125SMiklos Szeredi .d_real = ovl_d_real, 1667c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1677c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1687c03b5d4SMiklos Szeredi }; 1697c03b5d4SMiklos Szeredi 17013cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 17113cf199dSAmir Goldstein 17213cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 17313cf199dSAmir Goldstein { 17413cf199dSAmir Goldstein struct ovl_inode *oi = kmem_cache_alloc(ovl_inode_cachep, GFP_KERNEL); 17513cf199dSAmir Goldstein 176b3885bd6SHirofumi Nakagawa if (!oi) 177b3885bd6SHirofumi Nakagawa return NULL; 178b3885bd6SHirofumi Nakagawa 17904a01ac7SMiklos Szeredi oi->cache = NULL; 180cf31c463SMiklos Szeredi oi->redirect = NULL; 18104a01ac7SMiklos Szeredi oi->version = 0; 18213c72075SMiklos Szeredi oi->flags = 0; 18309d8b586SMiklos Szeredi oi->__upperdentry = NULL; 18425b7713aSMiklos Szeredi oi->lower = NULL; 1852664bd08SVivek Goyal oi->lowerdata = NULL; 186a015dafcSAmir Goldstein mutex_init(&oi->lock); 18725b7713aSMiklos Szeredi 18813cf199dSAmir Goldstein return &oi->vfs_inode; 18913cf199dSAmir Goldstein } 19013cf199dSAmir Goldstein 1910b269dedSAl Viro static void ovl_free_inode(struct inode *inode) 19213cf199dSAmir Goldstein { 1930b269dedSAl Viro struct ovl_inode *oi = OVL_I(inode); 19413cf199dSAmir Goldstein 1950b269dedSAl Viro kfree(oi->redirect); 1960b269dedSAl Viro mutex_destroy(&oi->lock); 1970b269dedSAl Viro kmem_cache_free(ovl_inode_cachep, oi); 19813cf199dSAmir Goldstein } 19913cf199dSAmir Goldstein 20013cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 20113cf199dSAmir Goldstein { 20209d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 20309d8b586SMiklos Szeredi 20409d8b586SMiklos Szeredi dput(oi->__upperdentry); 20531747edaSAmir Goldstein iput(oi->lower); 2062664bd08SVivek Goyal if (S_ISDIR(inode->i_mode)) 2074edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 2082664bd08SVivek Goyal else 2092664bd08SVivek Goyal iput(oi->lowerdata); 21013cf199dSAmir Goldstein } 21113cf199dSAmir Goldstein 212ad204488SMiklos Szeredi static void ovl_free_fs(struct ovl_fs *ofs) 213e9be9d5eSMiklos Szeredi { 214df820f8dSMiklos Szeredi struct vfsmount **mounts; 215dd662667SMiklos Szeredi unsigned i; 216e9be9d5eSMiklos Szeredi 2170be0bfd2SAmir Goldstein iput(ofs->workbasedir_trap); 218146d62e5SAmir Goldstein iput(ofs->indexdir_trap); 219146d62e5SAmir Goldstein iput(ofs->workdir_trap); 220c21c839bSChengguang Xu dput(ofs->whiteout); 221ad204488SMiklos Szeredi dput(ofs->indexdir); 222ad204488SMiklos Szeredi dput(ofs->workdir); 223ad204488SMiklos Szeredi if (ofs->workdir_locked) 224ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->workbasedir); 225ad204488SMiklos Szeredi dput(ofs->workbasedir); 226ad204488SMiklos Szeredi if (ofs->upperdir_locked) 22708f4c7c8SMiklos Szeredi ovl_inuse_unlock(ovl_upper_mnt(ofs)->mnt_root); 228df820f8dSMiklos Szeredi 229df820f8dSMiklos Szeredi /* Hack! Reuse ofs->layers as a vfsmount array before freeing it */ 230df820f8dSMiklos Szeredi mounts = (struct vfsmount **) ofs->layers; 231b8e42a65SMiklos Szeredi for (i = 0; i < ofs->numlayer; i++) { 23294375f9dSAmir Goldstein iput(ofs->layers[i].trap); 233df820f8dSMiklos Szeredi mounts[i] = ofs->layers[i].mnt; 234146d62e5SAmir Goldstein } 235df820f8dSMiklos Szeredi kern_unmount_array(mounts, ofs->numlayer); 23694375f9dSAmir Goldstein kfree(ofs->layers); 237b7bf9908SAmir Goldstein for (i = 0; i < ofs->numfs; i++) 23807f1e596SAmir Goldstein free_anon_bdev(ofs->fs[i].pseudo_dev); 23907f1e596SAmir Goldstein kfree(ofs->fs); 240e9be9d5eSMiklos Szeredi 241ad204488SMiklos Szeredi kfree(ofs->config.lowerdir); 242ad204488SMiklos Szeredi kfree(ofs->config.upperdir); 243ad204488SMiklos Szeredi kfree(ofs->config.workdir); 244438c84c2SMiklos Szeredi kfree(ofs->config.redirect_mode); 245ad204488SMiklos Szeredi if (ofs->creator_cred) 246ad204488SMiklos Szeredi put_cred(ofs->creator_cred); 247ad204488SMiklos Szeredi kfree(ofs); 248e9be9d5eSMiklos Szeredi } 249e9be9d5eSMiklos Szeredi 250a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 251a9075cdbSMiklos Szeredi { 252a9075cdbSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 253a9075cdbSMiklos Szeredi 254a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 255a9075cdbSMiklos Szeredi } 256a9075cdbSMiklos Szeredi 257e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */ 258e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 259e593b2bfSAmir Goldstein { 260ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 261e593b2bfSAmir Goldstein struct super_block *upper_sb; 262e593b2bfSAmir Goldstein int ret; 263e593b2bfSAmir Goldstein 26408f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 265e593b2bfSAmir Goldstein return 0; 266e8d4bfe3SChengguang Xu 267e8d4bfe3SChengguang Xu /* 26832b1924bSKonstantin Khlebnikov * Not called for sync(2) call or an emergency sync (SB_I_SKIP_SYNC). 26932b1924bSKonstantin Khlebnikov * All the super blocks will be iterated, including upper_sb. 270e8d4bfe3SChengguang Xu * 271e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call 272e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being 273e8d4bfe3SChengguang Xu * called with wait == 1. 274e8d4bfe3SChengguang Xu */ 275e8d4bfe3SChengguang Xu if (!wait) 276e593b2bfSAmir Goldstein return 0; 277e593b2bfSAmir Goldstein 27808f4c7c8SMiklos Szeredi upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 279e8d4bfe3SChengguang Xu 280e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 281e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb); 282e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 283e8d4bfe3SChengguang Xu 284e593b2bfSAmir Goldstein return ret; 285e593b2bfSAmir Goldstein } 286e593b2bfSAmir Goldstein 287cc259639SAndy Whitcroft /** 288cc259639SAndy Whitcroft * ovl_statfs 289cc259639SAndy Whitcroft * @sb: The overlayfs super block 290cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 291cc259639SAndy Whitcroft * 292cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 2934ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 294cc259639SAndy Whitcroft */ 295cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 296cc259639SAndy Whitcroft { 297cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 298cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 299cc259639SAndy Whitcroft struct path path; 300cc259639SAndy Whitcroft int err; 301cc259639SAndy Whitcroft 3024ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 303cc259639SAndy Whitcroft 304cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 305cc259639SAndy Whitcroft if (!err) { 3066b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 307cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 308cc259639SAndy Whitcroft } 309cc259639SAndy Whitcroft 310cc259639SAndy Whitcroft return err; 311cc259639SAndy Whitcroft } 312cc259639SAndy Whitcroft 31302bcd157SAmir Goldstein /* Will this overlay be forced to mount/remount ro? */ 314ad204488SMiklos Szeredi static bool ovl_force_readonly(struct ovl_fs *ofs) 31502bcd157SAmir Goldstein { 31608f4c7c8SMiklos Szeredi return (!ovl_upper_mnt(ofs) || !ofs->workdir); 31702bcd157SAmir Goldstein } 31802bcd157SAmir Goldstein 319438c84c2SMiklos Szeredi static const char *ovl_redirect_mode_def(void) 320438c84c2SMiklos Szeredi { 321438c84c2SMiklos Szeredi return ovl_redirect_dir_def ? "on" : "off"; 322438c84c2SMiklos Szeredi } 323438c84c2SMiklos Szeredi 324795939a9SAmir Goldstein static const char * const ovl_xino_str[] = { 325795939a9SAmir Goldstein "off", 326795939a9SAmir Goldstein "auto", 327795939a9SAmir Goldstein "on", 328795939a9SAmir Goldstein }; 329795939a9SAmir Goldstein 330795939a9SAmir Goldstein static inline int ovl_xino_def(void) 331795939a9SAmir Goldstein { 332795939a9SAmir Goldstein return ovl_xino_auto_def ? OVL_XINO_AUTO : OVL_XINO_OFF; 333795939a9SAmir Goldstein } 334795939a9SAmir Goldstein 335f45827e8SErez Zadok /** 336f45827e8SErez Zadok * ovl_show_options 337f45827e8SErez Zadok * 338f45827e8SErez Zadok * Prints the mount options for a given superblock. 339f45827e8SErez Zadok * Returns zero; does not fail. 340f45827e8SErez Zadok */ 341f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 342f45827e8SErez Zadok { 343f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 344ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 345f45827e8SErez Zadok 346ad204488SMiklos Szeredi seq_show_option(m, "lowerdir", ofs->config.lowerdir); 347ad204488SMiklos Szeredi if (ofs->config.upperdir) { 348ad204488SMiklos Szeredi seq_show_option(m, "upperdir", ofs->config.upperdir); 349ad204488SMiklos Szeredi seq_show_option(m, "workdir", ofs->config.workdir); 35053a08cb9SMiklos Szeredi } 351ad204488SMiklos Szeredi if (ofs->config.default_permissions) 3528d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 353438c84c2SMiklos Szeredi if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0) 354438c84c2SMiklos Szeredi seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode); 355ad204488SMiklos Szeredi if (ofs->config.index != ovl_index_def) 356438c84c2SMiklos Szeredi seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 357f168f109SAmir Goldstein if (ofs->config.nfs_export != ovl_nfs_export_def) 358f168f109SAmir Goldstein seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ? 359f168f109SAmir Goldstein "on" : "off"); 3600f831ec8SAmir Goldstein if (ofs->config.xino != ovl_xino_def() && !ovl_same_fs(sb)) 361795939a9SAmir Goldstein seq_printf(m, ",xino=%s", ovl_xino_str[ofs->config.xino]); 362d5791044SVivek Goyal if (ofs->config.metacopy != ovl_metacopy_def) 363d5791044SVivek Goyal seq_printf(m, ",metacopy=%s", 364d5791044SVivek Goyal ofs->config.metacopy ? "on" : "off"); 365f45827e8SErez Zadok return 0; 366f45827e8SErez Zadok } 367f45827e8SErez Zadok 3683cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 3693cdf6fe9SSeunghun Lee { 370ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 371399c109dSChengguang Xu struct super_block *upper_sb; 372399c109dSChengguang Xu int ret = 0; 3733cdf6fe9SSeunghun Lee 3741751e8a6SLinus Torvalds if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 3753cdf6fe9SSeunghun Lee return -EROFS; 3763cdf6fe9SSeunghun Lee 377399c109dSChengguang Xu if (*flags & SB_RDONLY && !sb_rdonly(sb)) { 37808f4c7c8SMiklos Szeredi upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 379399c109dSChengguang Xu down_read(&upper_sb->s_umount); 380399c109dSChengguang Xu ret = sync_filesystem(upper_sb); 381399c109dSChengguang Xu up_read(&upper_sb->s_umount); 382399c109dSChengguang Xu } 383399c109dSChengguang Xu 384399c109dSChengguang Xu return ret; 3853cdf6fe9SSeunghun Lee } 3863cdf6fe9SSeunghun Lee 387e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 38813cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 3890b269dedSAl Viro .free_inode = ovl_free_inode, 39013cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 39113cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 392e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 393e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 394cc259639SAndy Whitcroft .statfs = ovl_statfs, 395f45827e8SErez Zadok .show_options = ovl_show_options, 3963cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 397e9be9d5eSMiklos Szeredi }; 398e9be9d5eSMiklos Szeredi 399e9be9d5eSMiklos Szeredi enum { 400e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 401e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 402e9be9d5eSMiklos Szeredi OPT_WORKDIR, 4038d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 404438c84c2SMiklos Szeredi OPT_REDIRECT_DIR, 40502bcd157SAmir Goldstein OPT_INDEX_ON, 40602bcd157SAmir Goldstein OPT_INDEX_OFF, 407f168f109SAmir Goldstein OPT_NFS_EXPORT_ON, 408f168f109SAmir Goldstein OPT_NFS_EXPORT_OFF, 409795939a9SAmir Goldstein OPT_XINO_ON, 410795939a9SAmir Goldstein OPT_XINO_OFF, 411795939a9SAmir Goldstein OPT_XINO_AUTO, 412d5791044SVivek Goyal OPT_METACOPY_ON, 413d5791044SVivek Goyal OPT_METACOPY_OFF, 414e9be9d5eSMiklos Szeredi OPT_ERR, 415e9be9d5eSMiklos Szeredi }; 416e9be9d5eSMiklos Szeredi 417e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 418e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 419e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 420e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 4218d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 422438c84c2SMiklos Szeredi {OPT_REDIRECT_DIR, "redirect_dir=%s"}, 42302bcd157SAmir Goldstein {OPT_INDEX_ON, "index=on"}, 42402bcd157SAmir Goldstein {OPT_INDEX_OFF, "index=off"}, 425f168f109SAmir Goldstein {OPT_NFS_EXPORT_ON, "nfs_export=on"}, 426f168f109SAmir Goldstein {OPT_NFS_EXPORT_OFF, "nfs_export=off"}, 427795939a9SAmir Goldstein {OPT_XINO_ON, "xino=on"}, 428795939a9SAmir Goldstein {OPT_XINO_OFF, "xino=off"}, 429795939a9SAmir Goldstein {OPT_XINO_AUTO, "xino=auto"}, 430d5791044SVivek Goyal {OPT_METACOPY_ON, "metacopy=on"}, 431d5791044SVivek Goyal {OPT_METACOPY_OFF, "metacopy=off"}, 432e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 433e9be9d5eSMiklos Szeredi }; 434e9be9d5eSMiklos Szeredi 43591c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 43691c77947SMiklos Szeredi { 43791c77947SMiklos Szeredi char *sbegin = *s; 43891c77947SMiklos Szeredi char *p; 43991c77947SMiklos Szeredi 44091c77947SMiklos Szeredi if (sbegin == NULL) 44191c77947SMiklos Szeredi return NULL; 44291c77947SMiklos Szeredi 44391c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 44491c77947SMiklos Szeredi if (*p == '\\') { 44591c77947SMiklos Szeredi p++; 44691c77947SMiklos Szeredi if (!*p) 44791c77947SMiklos Szeredi break; 44891c77947SMiklos Szeredi } else if (*p == ',') { 44991c77947SMiklos Szeredi *p = '\0'; 45091c77947SMiklos Szeredi *s = p + 1; 45191c77947SMiklos Szeredi return sbegin; 45291c77947SMiklos Szeredi } 45391c77947SMiklos Szeredi } 45491c77947SMiklos Szeredi *s = NULL; 45591c77947SMiklos Szeredi return sbegin; 45691c77947SMiklos Szeredi } 45791c77947SMiklos Szeredi 458438c84c2SMiklos Szeredi static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode) 459438c84c2SMiklos Szeredi { 460438c84c2SMiklos Szeredi if (strcmp(mode, "on") == 0) { 461438c84c2SMiklos Szeredi config->redirect_dir = true; 462438c84c2SMiklos Szeredi /* 463438c84c2SMiklos Szeredi * Does not make sense to have redirect creation without 464438c84c2SMiklos Szeredi * redirect following. 465438c84c2SMiklos Szeredi */ 466438c84c2SMiklos Szeredi config->redirect_follow = true; 467438c84c2SMiklos Szeredi } else if (strcmp(mode, "follow") == 0) { 468438c84c2SMiklos Szeredi config->redirect_follow = true; 469438c84c2SMiklos Szeredi } else if (strcmp(mode, "off") == 0) { 470438c84c2SMiklos Szeredi if (ovl_redirect_always_follow) 471438c84c2SMiklos Szeredi config->redirect_follow = true; 472438c84c2SMiklos Szeredi } else if (strcmp(mode, "nofollow") != 0) { 4731bd0a3aeSlijiazi pr_err("bad mount option \"redirect_dir=%s\"\n", 474438c84c2SMiklos Szeredi mode); 475438c84c2SMiklos Szeredi return -EINVAL; 476438c84c2SMiklos Szeredi } 477438c84c2SMiklos Szeredi 478438c84c2SMiklos Szeredi return 0; 479438c84c2SMiklos Szeredi } 480438c84c2SMiklos Szeredi 481e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 482e9be9d5eSMiklos Szeredi { 483e9be9d5eSMiklos Szeredi char *p; 484d5791044SVivek Goyal int err; 485d47748e5SMiklos Szeredi bool metacopy_opt = false, redirect_opt = false; 486b0def88dSAmir Goldstein bool nfs_export_opt = false, index_opt = false; 487e9be9d5eSMiklos Szeredi 488438c84c2SMiklos Szeredi config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL); 489438c84c2SMiklos Szeredi if (!config->redirect_mode) 490438c84c2SMiklos Szeredi return -ENOMEM; 491438c84c2SMiklos Szeredi 49291c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 493e9be9d5eSMiklos Szeredi int token; 494e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 495e9be9d5eSMiklos Szeredi 496e9be9d5eSMiklos Szeredi if (!*p) 497e9be9d5eSMiklos Szeredi continue; 498e9be9d5eSMiklos Szeredi 499e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 500e9be9d5eSMiklos Szeredi switch (token) { 501e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 502e9be9d5eSMiklos Szeredi kfree(config->upperdir); 503e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 504e9be9d5eSMiklos Szeredi if (!config->upperdir) 505e9be9d5eSMiklos Szeredi return -ENOMEM; 506e9be9d5eSMiklos Szeredi break; 507e9be9d5eSMiklos Szeredi 508e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 509e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 510e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 511e9be9d5eSMiklos Szeredi if (!config->lowerdir) 512e9be9d5eSMiklos Szeredi return -ENOMEM; 513e9be9d5eSMiklos Szeredi break; 514e9be9d5eSMiklos Szeredi 515e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 516e9be9d5eSMiklos Szeredi kfree(config->workdir); 517e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 518e9be9d5eSMiklos Szeredi if (!config->workdir) 519e9be9d5eSMiklos Szeredi return -ENOMEM; 520e9be9d5eSMiklos Szeredi break; 521e9be9d5eSMiklos Szeredi 5228d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 5238d3095f4SMiklos Szeredi config->default_permissions = true; 5248d3095f4SMiklos Szeredi break; 5258d3095f4SMiklos Szeredi 526438c84c2SMiklos Szeredi case OPT_REDIRECT_DIR: 527438c84c2SMiklos Szeredi kfree(config->redirect_mode); 528438c84c2SMiklos Szeredi config->redirect_mode = match_strdup(&args[0]); 529438c84c2SMiklos Szeredi if (!config->redirect_mode) 530438c84c2SMiklos Szeredi return -ENOMEM; 531d47748e5SMiklos Szeredi redirect_opt = true; 532a6c60655SMiklos Szeredi break; 533a6c60655SMiklos Szeredi 53402bcd157SAmir Goldstein case OPT_INDEX_ON: 53502bcd157SAmir Goldstein config->index = true; 536b0def88dSAmir Goldstein index_opt = true; 53702bcd157SAmir Goldstein break; 53802bcd157SAmir Goldstein 53902bcd157SAmir Goldstein case OPT_INDEX_OFF: 54002bcd157SAmir Goldstein config->index = false; 541b0def88dSAmir Goldstein index_opt = true; 54202bcd157SAmir Goldstein break; 54302bcd157SAmir Goldstein 544f168f109SAmir Goldstein case OPT_NFS_EXPORT_ON: 545f168f109SAmir Goldstein config->nfs_export = true; 546b0def88dSAmir Goldstein nfs_export_opt = true; 547f168f109SAmir Goldstein break; 548f168f109SAmir Goldstein 549f168f109SAmir Goldstein case OPT_NFS_EXPORT_OFF: 550f168f109SAmir Goldstein config->nfs_export = false; 551b0def88dSAmir Goldstein nfs_export_opt = true; 552f168f109SAmir Goldstein break; 553f168f109SAmir Goldstein 554795939a9SAmir Goldstein case OPT_XINO_ON: 555795939a9SAmir Goldstein config->xino = OVL_XINO_ON; 556795939a9SAmir Goldstein break; 557795939a9SAmir Goldstein 558795939a9SAmir Goldstein case OPT_XINO_OFF: 559795939a9SAmir Goldstein config->xino = OVL_XINO_OFF; 560795939a9SAmir Goldstein break; 561795939a9SAmir Goldstein 562795939a9SAmir Goldstein case OPT_XINO_AUTO: 563795939a9SAmir Goldstein config->xino = OVL_XINO_AUTO; 564795939a9SAmir Goldstein break; 565795939a9SAmir Goldstein 566d5791044SVivek Goyal case OPT_METACOPY_ON: 567d5791044SVivek Goyal config->metacopy = true; 568d47748e5SMiklos Szeredi metacopy_opt = true; 569d5791044SVivek Goyal break; 570d5791044SVivek Goyal 571d5791044SVivek Goyal case OPT_METACOPY_OFF: 572d5791044SVivek Goyal config->metacopy = false; 573b0def88dSAmir Goldstein metacopy_opt = true; 574d5791044SVivek Goyal break; 575d5791044SVivek Goyal 576e9be9d5eSMiklos Szeredi default: 5771bd0a3aeSlijiazi pr_err("unrecognized mount option \"%s\" or missing value\n", 5781bd0a3aeSlijiazi p); 579e9be9d5eSMiklos Szeredi return -EINVAL; 580e9be9d5eSMiklos Szeredi } 581e9be9d5eSMiklos Szeredi } 58271cbad7eShujianyang 58371cbad7eShujianyang /* Workdir is useless in non-upper mount */ 58471cbad7eShujianyang if (!config->upperdir && config->workdir) { 5851bd0a3aeSlijiazi pr_info("option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 58671cbad7eShujianyang config->workdir); 58771cbad7eShujianyang kfree(config->workdir); 58871cbad7eShujianyang config->workdir = NULL; 58971cbad7eShujianyang } 59071cbad7eShujianyang 591d5791044SVivek Goyal err = ovl_parse_redirect_mode(config, config->redirect_mode); 592d5791044SVivek Goyal if (err) 593d5791044SVivek Goyal return err; 594d5791044SVivek Goyal 595d47748e5SMiklos Szeredi /* 596d47748e5SMiklos Szeredi * This is to make the logic below simpler. It doesn't make any other 597d47748e5SMiklos Szeredi * difference, since config->redirect_dir is only used for upper. 598d47748e5SMiklos Szeredi */ 599d47748e5SMiklos Szeredi if (!config->upperdir && config->redirect_follow) 600d47748e5SMiklos Szeredi config->redirect_dir = true; 601d47748e5SMiklos Szeredi 602d47748e5SMiklos Szeredi /* Resolve metacopy -> redirect_dir dependency */ 603d47748e5SMiklos Szeredi if (config->metacopy && !config->redirect_dir) { 604d47748e5SMiklos Szeredi if (metacopy_opt && redirect_opt) { 6051bd0a3aeSlijiazi pr_err("conflicting options: metacopy=on,redirect_dir=%s\n", 606d47748e5SMiklos Szeredi config->redirect_mode); 607d47748e5SMiklos Szeredi return -EINVAL; 608d47748e5SMiklos Szeredi } 609d47748e5SMiklos Szeredi if (redirect_opt) { 610d47748e5SMiklos Szeredi /* 611d47748e5SMiklos Szeredi * There was an explicit redirect_dir=... that resulted 612d47748e5SMiklos Szeredi * in this conflict. 613d47748e5SMiklos Szeredi */ 6141bd0a3aeSlijiazi pr_info("disabling metacopy due to redirect_dir=%s\n", 615d47748e5SMiklos Szeredi config->redirect_mode); 616d5791044SVivek Goyal config->metacopy = false; 617d47748e5SMiklos Szeredi } else { 618d47748e5SMiklos Szeredi /* Automatically enable redirect otherwise. */ 619d47748e5SMiklos Szeredi config->redirect_follow = config->redirect_dir = true; 620d47748e5SMiklos Szeredi } 621d5791044SVivek Goyal } 622d5791044SVivek Goyal 623b0def88dSAmir Goldstein /* Resolve nfs_export -> index dependency */ 624b0def88dSAmir Goldstein if (config->nfs_export && !config->index) { 625b0def88dSAmir Goldstein if (nfs_export_opt && index_opt) { 626b0def88dSAmir Goldstein pr_err("conflicting options: nfs_export=on,index=off\n"); 627b0def88dSAmir Goldstein return -EINVAL; 628b0def88dSAmir Goldstein } 629b0def88dSAmir Goldstein if (index_opt) { 630b0def88dSAmir Goldstein /* 631b0def88dSAmir Goldstein * There was an explicit index=off that resulted 632b0def88dSAmir Goldstein * in this conflict. 633b0def88dSAmir Goldstein */ 634b0def88dSAmir Goldstein pr_info("disabling nfs_export due to index=off\n"); 635b0def88dSAmir Goldstein config->nfs_export = false; 636b0def88dSAmir Goldstein } else { 637b0def88dSAmir Goldstein /* Automatically enable index otherwise. */ 638b0def88dSAmir Goldstein config->index = true; 639b0def88dSAmir Goldstein } 640b0def88dSAmir Goldstein } 641b0def88dSAmir Goldstein 642b0def88dSAmir Goldstein /* Resolve nfs_export -> !metacopy dependency */ 643b0def88dSAmir Goldstein if (config->nfs_export && config->metacopy) { 644b0def88dSAmir Goldstein if (nfs_export_opt && metacopy_opt) { 645b0def88dSAmir Goldstein pr_err("conflicting options: nfs_export=on,metacopy=on\n"); 646b0def88dSAmir Goldstein return -EINVAL; 647b0def88dSAmir Goldstein } 648b0def88dSAmir Goldstein if (metacopy_opt) { 649b0def88dSAmir Goldstein /* 650b0def88dSAmir Goldstein * There was an explicit metacopy=on that resulted 651b0def88dSAmir Goldstein * in this conflict. 652b0def88dSAmir Goldstein */ 653b0def88dSAmir Goldstein pr_info("disabling nfs_export due to metacopy=on\n"); 654b0def88dSAmir Goldstein config->nfs_export = false; 655b0def88dSAmir Goldstein } else { 656b0def88dSAmir Goldstein /* 657b0def88dSAmir Goldstein * There was an explicit nfs_export=on that resulted 658b0def88dSAmir Goldstein * in this conflict. 659b0def88dSAmir Goldstein */ 660b0def88dSAmir Goldstein pr_info("disabling metacopy due to nfs_export=on\n"); 661b0def88dSAmir Goldstein config->metacopy = false; 662b0def88dSAmir Goldstein } 663b0def88dSAmir Goldstein } 664b0def88dSAmir Goldstein 665d5791044SVivek Goyal return 0; 666e9be9d5eSMiklos Szeredi } 667e9be9d5eSMiklos Szeredi 668e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 66902bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 670e9be9d5eSMiklos Szeredi 671ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 6726b8aa129SAmir Goldstein const char *name, bool persist) 673e9be9d5eSMiklos Szeredi { 674ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 67508f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 676e9be9d5eSMiklos Szeredi struct dentry *work; 677e9be9d5eSMiklos Szeredi int err; 678e9be9d5eSMiklos Szeredi bool retried = false; 679e9be9d5eSMiklos Szeredi 6805955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 681e9be9d5eSMiklos Szeredi retry: 682ad204488SMiklos Szeredi work = lookup_one_len(name, ofs->workbasedir, strlen(name)); 683e9be9d5eSMiklos Szeredi 684e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 685c11b9fddSMiklos Szeredi struct iattr attr = { 686c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 68732a3d848SAl Viro .ia_mode = S_IFDIR | 0, 688c11b9fddSMiklos Szeredi }; 689e9be9d5eSMiklos Szeredi 690e9be9d5eSMiklos Szeredi if (work->d_inode) { 691e9be9d5eSMiklos Szeredi err = -EEXIST; 692e9be9d5eSMiklos Szeredi if (retried) 693e9be9d5eSMiklos Szeredi goto out_dput; 694e9be9d5eSMiklos Szeredi 6956b8aa129SAmir Goldstein if (persist) 6966b8aa129SAmir Goldstein goto out_unlock; 6976b8aa129SAmir Goldstein 698e9be9d5eSMiklos Szeredi retried = true; 699eea2fb48SMiklos Szeredi ovl_workdir_cleanup(dir, mnt, work, 0); 700e9be9d5eSMiklos Szeredi dput(work); 701e9be9d5eSMiklos Szeredi goto retry; 702e9be9d5eSMiklos Szeredi } 703e9be9d5eSMiklos Szeredi 70495a1c815SMiklos Szeredi work = ovl_create_real(dir, work, OVL_CATTR(attr.ia_mode)); 70595a1c815SMiklos Szeredi err = PTR_ERR(work); 70695a1c815SMiklos Szeredi if (IS_ERR(work)) 70795a1c815SMiklos Szeredi goto out_err; 708c11b9fddSMiklos Szeredi 709cb348edbSMiklos Szeredi /* 710cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 711cb348edbSMiklos Szeredi * 712cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 713cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 714cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 715cb348edbSMiklos Szeredi * 716cb348edbSMiklos Szeredi * There are various other error values that could effectively 717cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 718cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 719cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 720cb348edbSMiklos Szeredi * for the above two errors is sufficient. 721cb348edbSMiklos Szeredi */ 722c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 723e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 724c11b9fddSMiklos Szeredi goto out_dput; 725c11b9fddSMiklos Szeredi 726c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 727e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 728c11b9fddSMiklos Szeredi goto out_dput; 729c11b9fddSMiklos Szeredi 730c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 731c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 732c11b9fddSMiklos Szeredi err = notify_change(work, &attr, NULL); 733c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 734c11b9fddSMiklos Szeredi if (err) 735c11b9fddSMiklos Szeredi goto out_dput; 7366b8aa129SAmir Goldstein } else { 7376b8aa129SAmir Goldstein err = PTR_ERR(work); 7386b8aa129SAmir Goldstein goto out_err; 739e9be9d5eSMiklos Szeredi } 740e9be9d5eSMiklos Szeredi out_unlock: 7416b8aa129SAmir Goldstein inode_unlock(dir); 742e9be9d5eSMiklos Szeredi return work; 743e9be9d5eSMiklos Szeredi 744e9be9d5eSMiklos Szeredi out_dput: 745e9be9d5eSMiklos Szeredi dput(work); 7466b8aa129SAmir Goldstein out_err: 7471bd0a3aeSlijiazi pr_warn("failed to create directory %s/%s (errno: %i); mounting read-only\n", 748ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 7496b8aa129SAmir Goldstein work = NULL; 750e9be9d5eSMiklos Szeredi goto out_unlock; 751e9be9d5eSMiklos Szeredi } 752e9be9d5eSMiklos Szeredi 75391c77947SMiklos Szeredi static void ovl_unescape(char *s) 75491c77947SMiklos Szeredi { 75591c77947SMiklos Szeredi char *d = s; 75691c77947SMiklos Szeredi 75791c77947SMiklos Szeredi for (;; s++, d++) { 75891c77947SMiklos Szeredi if (*s == '\\') 75991c77947SMiklos Szeredi s++; 76091c77947SMiklos Szeredi *d = *s; 76191c77947SMiklos Szeredi if (!*s) 76291c77947SMiklos Szeredi break; 76391c77947SMiklos Szeredi } 76491c77947SMiklos Szeredi } 76591c77947SMiklos Szeredi 766ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 767ab508822SMiklos Szeredi { 768a78d9f0dSMiklos Szeredi int err = -EINVAL; 769ab508822SMiklos Szeredi 770a78d9f0dSMiklos Szeredi if (!*name) { 7711bd0a3aeSlijiazi pr_err("empty lowerdir\n"); 772a78d9f0dSMiklos Szeredi goto out; 773a78d9f0dSMiklos Szeredi } 774ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 775ab508822SMiklos Szeredi if (err) { 7761bd0a3aeSlijiazi pr_err("failed to resolve '%s': %i\n", name, err); 777ab508822SMiklos Szeredi goto out; 778ab508822SMiklos Szeredi } 779ab508822SMiklos Szeredi err = -EINVAL; 7807c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 7811bd0a3aeSlijiazi pr_err("filesystem on '%s' not supported\n", name); 782ab508822SMiklos Szeredi goto out_put; 783ab508822SMiklos Szeredi } 7842b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 7851bd0a3aeSlijiazi pr_err("'%s' not a directory\n", name); 786ab508822SMiklos Szeredi goto out_put; 787ab508822SMiklos Szeredi } 788ab508822SMiklos Szeredi return 0; 789ab508822SMiklos Szeredi 790ab508822SMiklos Szeredi out_put: 7918aafcb59SMiklos Szeredi path_put_init(path); 792ab508822SMiklos Szeredi out: 793ab508822SMiklos Szeredi return err; 794ab508822SMiklos Szeredi } 795ab508822SMiklos Szeredi 796ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 797ab508822SMiklos Szeredi { 798ab508822SMiklos Szeredi int err = -ENOMEM; 799ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 800ab508822SMiklos Szeredi 801ab508822SMiklos Szeredi if (tmp) { 802ab508822SMiklos Szeredi ovl_unescape(tmp); 803ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 8047c03b5d4SMiklos Szeredi 805bccece1eSMiklos Szeredi if (!err && path->dentry->d_flags & DCACHE_OP_REAL) { 8061bd0a3aeSlijiazi pr_err("filesystem on '%s' not supported as upperdir\n", 8077c03b5d4SMiklos Szeredi tmp); 8088aafcb59SMiklos Szeredi path_put_init(path); 8097c03b5d4SMiklos Szeredi err = -EINVAL; 8107c03b5d4SMiklos Szeredi } 811ab508822SMiklos Szeredi kfree(tmp); 812ab508822SMiklos Szeredi } 813ab508822SMiklos Szeredi return err; 814ab508822SMiklos Szeredi } 815ab508822SMiklos Szeredi 8166b2d5fe4SMiklos Szeredi static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 8176b2d5fe4SMiklos Szeredi const char *name) 8186b2d5fe4SMiklos Szeredi { 8196b2d5fe4SMiklos Szeredi struct kstatfs statfs; 8206b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 8216b2d5fe4SMiklos Szeredi 8226b2d5fe4SMiklos Szeredi if (err) 8231bd0a3aeSlijiazi pr_err("statfs failed on '%s'\n", name); 8246b2d5fe4SMiklos Szeredi else 8256b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 8266b2d5fe4SMiklos Szeredi 8276b2d5fe4SMiklos Szeredi return err; 8286b2d5fe4SMiklos Szeredi } 8296b2d5fe4SMiklos Szeredi 8306b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 831f4288844SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth) 832ab508822SMiklos Szeredi { 833e487d889SAmir Goldstein int fh_type; 834ab508822SMiklos Szeredi int err; 835ab508822SMiklos Szeredi 836a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 837ab508822SMiklos Szeredi if (err) 838b8e42a65SMiklos Szeredi return err; 839ab508822SMiklos Szeredi 8406b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 8416b2d5fe4SMiklos Szeredi if (err) 842b8e42a65SMiklos Szeredi return err; 8436b2d5fe4SMiklos Szeredi 844ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 845ab508822SMiklos Szeredi 84602bcd157SAmir Goldstein /* 847f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode 848f168f109SAmir Goldstein * file handles, so they require that all layers support them. 84902bcd157SAmir Goldstein */ 850e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(path->dentry->d_sb); 851f168f109SAmir Goldstein if ((ofs->config.nfs_export || 852e487d889SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 85302bcd157SAmir Goldstein ofs->config.index = false; 854f168f109SAmir Goldstein ofs->config.nfs_export = false; 8551bd0a3aeSlijiazi pr_warn("fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 856f168f109SAmir Goldstein name); 85702bcd157SAmir Goldstein } 85802bcd157SAmir Goldstein 859e487d889SAmir Goldstein /* Check if lower fs has 32bit inode numbers */ 860e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 8610f831ec8SAmir Goldstein ofs->xino_mode = -1; 862e487d889SAmir Goldstein 863ab508822SMiklos Szeredi return 0; 864ab508822SMiklos Szeredi } 865ab508822SMiklos Szeredi 866e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 867e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 868e9be9d5eSMiklos Szeredi { 869e9be9d5eSMiklos Szeredi bool ok = false; 870e9be9d5eSMiklos Szeredi 871e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 872e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 873e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 874e9be9d5eSMiklos Szeredi } 875e9be9d5eSMiklos Szeredi return ok; 876e9be9d5eSMiklos Szeredi } 877e9be9d5eSMiklos Szeredi 878a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 879a78d9f0dSMiklos Szeredi { 880a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 881a78d9f0dSMiklos Szeredi char *s, *d; 882a78d9f0dSMiklos Szeredi 883a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 884a78d9f0dSMiklos Szeredi if (*s == '\\') { 885a78d9f0dSMiklos Szeredi s++; 886a78d9f0dSMiklos Szeredi } else if (*s == ':') { 887a78d9f0dSMiklos Szeredi *d = '\0'; 888a78d9f0dSMiklos Szeredi ctr++; 889a78d9f0dSMiklos Szeredi continue; 890a78d9f0dSMiklos Szeredi } 891a78d9f0dSMiklos Szeredi *d = *s; 892a78d9f0dSMiklos Szeredi if (!*s) 893a78d9f0dSMiklos Szeredi break; 894a78d9f0dSMiklos Szeredi } 895a78d9f0dSMiklos Szeredi return ctr; 896a78d9f0dSMiklos Szeredi } 897a78d9f0dSMiklos Szeredi 8980c97be22SAndreas Gruenbacher static int __maybe_unused 8990eb45fc3SAndreas Gruenbacher ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 9000eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9010eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 9020eb45fc3SAndreas Gruenbacher { 9031d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 9040eb45fc3SAndreas Gruenbacher } 9050eb45fc3SAndreas Gruenbacher 9060eb45fc3SAndreas Gruenbacher static int __maybe_unused 9070c97be22SAndreas Gruenbacher ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 908d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 909d837a49bSMiklos Szeredi const char *name, const void *value, 910d837a49bSMiklos Szeredi size_t size, int flags) 911d837a49bSMiklos Szeredi { 912d837a49bSMiklos Szeredi struct dentry *workdir = ovl_workdir(dentry); 91309d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 914d837a49bSMiklos Szeredi struct posix_acl *acl = NULL; 915d837a49bSMiklos Szeredi int err; 916d837a49bSMiklos Szeredi 917d837a49bSMiklos Szeredi /* Check that everything is OK before copy-up */ 918d837a49bSMiklos Szeredi if (value) { 919d837a49bSMiklos Szeredi acl = posix_acl_from_xattr(&init_user_ns, value, size); 920d837a49bSMiklos Szeredi if (IS_ERR(acl)) 921d837a49bSMiklos Szeredi return PTR_ERR(acl); 922d837a49bSMiklos Szeredi } 923d837a49bSMiklos Szeredi err = -EOPNOTSUPP; 924d837a49bSMiklos Szeredi if (!IS_POSIXACL(d_inode(workdir))) 925d837a49bSMiklos Szeredi goto out_acl_release; 926d837a49bSMiklos Szeredi if (!realinode->i_op->set_acl) 927d837a49bSMiklos Szeredi goto out_acl_release; 928d837a49bSMiklos Szeredi if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 929d837a49bSMiklos Szeredi err = acl ? -EACCES : 0; 930d837a49bSMiklos Szeredi goto out_acl_release; 931d837a49bSMiklos Szeredi } 932d837a49bSMiklos Szeredi err = -EPERM; 933d837a49bSMiklos Szeredi if (!inode_owner_or_capable(inode)) 934d837a49bSMiklos Szeredi goto out_acl_release; 935d837a49bSMiklos Szeredi 936d837a49bSMiklos Szeredi posix_acl_release(acl); 937d837a49bSMiklos Szeredi 938fd3220d3SMiklos Szeredi /* 939fd3220d3SMiklos Szeredi * Check if sgid bit needs to be cleared (actual setacl operation will 940fd3220d3SMiklos Szeredi * be done with mounter's capabilities and so that won't do it for us). 941fd3220d3SMiklos Szeredi */ 942fd3220d3SMiklos Szeredi if (unlikely(inode->i_mode & S_ISGID) && 943fd3220d3SMiklos Szeredi handler->flags == ACL_TYPE_ACCESS && 944fd3220d3SMiklos Szeredi !in_group_p(inode->i_gid) && 945fd3220d3SMiklos Szeredi !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 946fd3220d3SMiklos Szeredi struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 947fd3220d3SMiklos Szeredi 948fd3220d3SMiklos Szeredi err = ovl_setattr(dentry, &iattr); 949fd3220d3SMiklos Szeredi if (err) 950fd3220d3SMiklos Szeredi return err; 951fd3220d3SMiklos Szeredi } 952fd3220d3SMiklos Szeredi 9531d88f183SMiklos Szeredi err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 954ce31513aSMiklos Szeredi if (!err) 95509d8b586SMiklos Szeredi ovl_copyattr(ovl_inode_real(inode), inode); 956ce31513aSMiklos Szeredi 957ce31513aSMiklos Szeredi return err; 958d837a49bSMiklos Szeredi 959d837a49bSMiklos Szeredi out_acl_release: 960d837a49bSMiklos Szeredi posix_acl_release(acl); 961d837a49bSMiklos Szeredi return err; 962d837a49bSMiklos Szeredi } 963d837a49bSMiklos Szeredi 9640eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 9650eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9660eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 9670eb45fc3SAndreas Gruenbacher { 96848fab5d7SAmir Goldstein return -EOPNOTSUPP; 9690eb45fc3SAndreas Gruenbacher } 9700eb45fc3SAndreas Gruenbacher 971d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 972d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 973d837a49bSMiklos Szeredi const char *name, const void *value, 974d837a49bSMiklos Szeredi size_t size, int flags) 975d837a49bSMiklos Szeredi { 97648fab5d7SAmir Goldstein return -EOPNOTSUPP; 977d837a49bSMiklos Szeredi } 978d837a49bSMiklos Szeredi 9790eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 9800eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9810eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 9820eb45fc3SAndreas Gruenbacher { 9831d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 9840eb45fc3SAndreas Gruenbacher } 9850eb45fc3SAndreas Gruenbacher 9860e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 9870e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9880e585cccSAndreas Gruenbacher const char *name, const void *value, 9890e585cccSAndreas Gruenbacher size_t size, int flags) 9900e585cccSAndreas Gruenbacher { 9911d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 9920e585cccSAndreas Gruenbacher } 9930e585cccSAndreas Gruenbacher 9940c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 9950c97be22SAndreas Gruenbacher ovl_posix_acl_access_xattr_handler = { 996d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_ACCESS, 997d837a49bSMiklos Szeredi .flags = ACL_TYPE_ACCESS, 9980eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 999d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 1000d837a49bSMiklos Szeredi }; 1001d837a49bSMiklos Szeredi 10020c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 10030c97be22SAndreas Gruenbacher ovl_posix_acl_default_xattr_handler = { 1004d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_DEFAULT, 1005d837a49bSMiklos Szeredi .flags = ACL_TYPE_DEFAULT, 10060eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 1007d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 1008d837a49bSMiklos Szeredi }; 1009d837a49bSMiklos Szeredi 1010d837a49bSMiklos Szeredi static const struct xattr_handler ovl_own_xattr_handler = { 1011d837a49bSMiklos Szeredi .prefix = OVL_XATTR_PREFIX, 10120eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 1013d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 1014d837a49bSMiklos Szeredi }; 1015d837a49bSMiklos Szeredi 1016d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 1017d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 10180eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 1019d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 1020d837a49bSMiklos Szeredi }; 1021d837a49bSMiklos Szeredi 1022d837a49bSMiklos Szeredi static const struct xattr_handler *ovl_xattr_handlers[] = { 10230c97be22SAndreas Gruenbacher #ifdef CONFIG_FS_POSIX_ACL 1024d837a49bSMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 1025d837a49bSMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 10260c97be22SAndreas Gruenbacher #endif 1027d837a49bSMiklos Szeredi &ovl_own_xattr_handler, 1028d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 1029d837a49bSMiklos Szeredi NULL 1030d837a49bSMiklos Szeredi }; 1031d837a49bSMiklos Szeredi 1032146d62e5SAmir Goldstein static int ovl_setup_trap(struct super_block *sb, struct dentry *dir, 1033146d62e5SAmir Goldstein struct inode **ptrap, const char *name) 1034146d62e5SAmir Goldstein { 1035146d62e5SAmir Goldstein struct inode *trap; 1036146d62e5SAmir Goldstein int err; 1037146d62e5SAmir Goldstein 1038146d62e5SAmir Goldstein trap = ovl_get_trap_inode(sb, dir); 10391dac6f5bSArnd Bergmann err = PTR_ERR_OR_ZERO(trap); 10401dac6f5bSArnd Bergmann if (err) { 1041146d62e5SAmir Goldstein if (err == -ELOOP) 10421bd0a3aeSlijiazi pr_err("conflicting %s path\n", name); 1043146d62e5SAmir Goldstein return err; 1044146d62e5SAmir Goldstein } 1045146d62e5SAmir Goldstein 1046146d62e5SAmir Goldstein *ptrap = trap; 1047146d62e5SAmir Goldstein return 0; 1048146d62e5SAmir Goldstein } 1049146d62e5SAmir Goldstein 10500be0bfd2SAmir Goldstein /* 10510be0bfd2SAmir Goldstein * Determine how we treat concurrent use of upperdir/workdir based on the 10520be0bfd2SAmir Goldstein * index feature. This is papering over mount leaks of container runtimes, 10530be0bfd2SAmir Goldstein * for example, an old overlay mount is leaked and now its upperdir is 10540be0bfd2SAmir Goldstein * attempted to be used as a lower layer in a new overlay mount. 10550be0bfd2SAmir Goldstein */ 10560be0bfd2SAmir Goldstein static int ovl_report_in_use(struct ovl_fs *ofs, const char *name) 10570be0bfd2SAmir Goldstein { 10580be0bfd2SAmir Goldstein if (ofs->config.index) { 10591bd0a3aeSlijiazi pr_err("%s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n", 10600be0bfd2SAmir Goldstein name); 10610be0bfd2SAmir Goldstein return -EBUSY; 10620be0bfd2SAmir Goldstein } else { 10631bd0a3aeSlijiazi pr_warn("%s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n", 10640be0bfd2SAmir Goldstein name); 10650be0bfd2SAmir Goldstein return 0; 10660be0bfd2SAmir Goldstein } 10670be0bfd2SAmir Goldstein } 10680be0bfd2SAmir Goldstein 1069146d62e5SAmir Goldstein static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs, 1070b8e42a65SMiklos Szeredi struct ovl_layer *upper_layer, struct path *upperpath) 10716ee8acf0SMiklos Szeredi { 10725064975eSMiklos Szeredi struct vfsmount *upper_mnt; 10736ee8acf0SMiklos Szeredi int err; 10746ee8acf0SMiklos Szeredi 1075ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.upperdir, upperpath); 10766ee8acf0SMiklos Szeredi if (err) 10776ee8acf0SMiklos Szeredi goto out; 10786ee8acf0SMiklos Szeredi 10796ee8acf0SMiklos Szeredi /* Upper fs should not be r/o */ 10806ee8acf0SMiklos Szeredi if (sb_rdonly(upperpath->mnt->mnt_sb)) { 10811bd0a3aeSlijiazi pr_err("upper fs is r/o, try multi-lower layers mount\n"); 10826ee8acf0SMiklos Szeredi err = -EINVAL; 10836ee8acf0SMiklos Szeredi goto out; 10846ee8acf0SMiklos Szeredi } 10856ee8acf0SMiklos Szeredi 1086ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 10876ee8acf0SMiklos Szeredi if (err) 10886ee8acf0SMiklos Szeredi goto out; 10896ee8acf0SMiklos Szeredi 1090b8e42a65SMiklos Szeredi err = ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap, 1091146d62e5SAmir Goldstein "upperdir"); 1092146d62e5SAmir Goldstein if (err) 1093146d62e5SAmir Goldstein goto out; 1094146d62e5SAmir Goldstein 10955064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 10965064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 10975064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 10981bd0a3aeSlijiazi pr_err("failed to clone upperpath\n"); 10995064975eSMiklos Szeredi goto out; 11005064975eSMiklos Szeredi } 11015064975eSMiklos Szeredi 11025064975eSMiklos Szeredi /* Don't inherit atime flags */ 11035064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 1104b8e42a65SMiklos Szeredi upper_layer->mnt = upper_mnt; 1105b8e42a65SMiklos Szeredi upper_layer->idx = 0; 1106b8e42a65SMiklos Szeredi upper_layer->fsid = 0; 11078c25741aSMiklos Szeredi 1108654255faSJeffle Xu /* 1109654255faSJeffle Xu * Inherit SB_NOSEC flag from upperdir. 1110654255faSJeffle Xu * 1111654255faSJeffle Xu * This optimization changes behavior when a security related attribute 1112654255faSJeffle Xu * (suid/sgid/security.*) is changed on an underlying layer. This is 1113654255faSJeffle Xu * okay because we don't yet have guarantees in that case, but it will 1114654255faSJeffle Xu * need careful treatment once we want to honour changes to underlying 1115654255faSJeffle Xu * filesystems. 1116654255faSJeffle Xu */ 1117654255faSJeffle Xu if (upper_mnt->mnt_sb->s_flags & SB_NOSEC) 1118654255faSJeffle Xu sb->s_flags |= SB_NOSEC; 1119654255faSJeffle Xu 112008f4c7c8SMiklos Szeredi if (ovl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) { 11218c25741aSMiklos Szeredi ofs->upperdir_locked = true; 11228c25741aSMiklos Szeredi } else { 11230be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "upperdir"); 11240be0bfd2SAmir Goldstein if (err) 11250be0bfd2SAmir Goldstein goto out; 11268c25741aSMiklos Szeredi } 11278c25741aSMiklos Szeredi 11286ee8acf0SMiklos Szeredi err = 0; 11296ee8acf0SMiklos Szeredi out: 11306ee8acf0SMiklos Szeredi return err; 11316ee8acf0SMiklos Szeredi } 11326ee8acf0SMiklos Szeredi 1133cad218abSAmir Goldstein /* 1134cad218abSAmir Goldstein * Returns 1 if RENAME_WHITEOUT is supported, 0 if not supported and 1135cad218abSAmir Goldstein * negative values if error is encountered. 1136cad218abSAmir Goldstein */ 1137cad218abSAmir Goldstein static int ovl_check_rename_whiteout(struct dentry *workdir) 1138cad218abSAmir Goldstein { 1139cad218abSAmir Goldstein struct inode *dir = d_inode(workdir); 1140cad218abSAmir Goldstein struct dentry *temp; 1141cad218abSAmir Goldstein struct dentry *dest; 1142cad218abSAmir Goldstein struct dentry *whiteout; 1143cad218abSAmir Goldstein struct name_snapshot name; 1144cad218abSAmir Goldstein int err; 1145cad218abSAmir Goldstein 1146cad218abSAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 1147cad218abSAmir Goldstein 1148cad218abSAmir Goldstein temp = ovl_create_temp(workdir, OVL_CATTR(S_IFREG | 0)); 1149cad218abSAmir Goldstein err = PTR_ERR(temp); 1150cad218abSAmir Goldstein if (IS_ERR(temp)) 1151cad218abSAmir Goldstein goto out_unlock; 1152cad218abSAmir Goldstein 1153cad218abSAmir Goldstein dest = ovl_lookup_temp(workdir); 1154cad218abSAmir Goldstein err = PTR_ERR(dest); 1155cad218abSAmir Goldstein if (IS_ERR(dest)) { 1156cad218abSAmir Goldstein dput(temp); 1157cad218abSAmir Goldstein goto out_unlock; 1158cad218abSAmir Goldstein } 1159cad218abSAmir Goldstein 1160cad218abSAmir Goldstein /* Name is inline and stable - using snapshot as a copy helper */ 1161cad218abSAmir Goldstein take_dentry_name_snapshot(&name, temp); 1162cad218abSAmir Goldstein err = ovl_do_rename(dir, temp, dir, dest, RENAME_WHITEOUT); 1163cad218abSAmir Goldstein if (err) { 1164cad218abSAmir Goldstein if (err == -EINVAL) 1165cad218abSAmir Goldstein err = 0; 1166cad218abSAmir Goldstein goto cleanup_temp; 1167cad218abSAmir Goldstein } 1168cad218abSAmir Goldstein 1169cad218abSAmir Goldstein whiteout = lookup_one_len(name.name.name, workdir, name.name.len); 1170cad218abSAmir Goldstein err = PTR_ERR(whiteout); 1171cad218abSAmir Goldstein if (IS_ERR(whiteout)) 1172cad218abSAmir Goldstein goto cleanup_temp; 1173cad218abSAmir Goldstein 1174cad218abSAmir Goldstein err = ovl_is_whiteout(whiteout); 1175cad218abSAmir Goldstein 1176cad218abSAmir Goldstein /* Best effort cleanup of whiteout and temp file */ 1177cad218abSAmir Goldstein if (err) 1178cad218abSAmir Goldstein ovl_cleanup(dir, whiteout); 1179cad218abSAmir Goldstein dput(whiteout); 1180cad218abSAmir Goldstein 1181cad218abSAmir Goldstein cleanup_temp: 1182cad218abSAmir Goldstein ovl_cleanup(dir, temp); 1183cad218abSAmir Goldstein release_dentry_name_snapshot(&name); 1184cad218abSAmir Goldstein dput(temp); 1185cad218abSAmir Goldstein dput(dest); 1186cad218abSAmir Goldstein 1187cad218abSAmir Goldstein out_unlock: 1188cad218abSAmir Goldstein inode_unlock(dir); 1189cad218abSAmir Goldstein 1190cad218abSAmir Goldstein return err; 1191cad218abSAmir Goldstein } 1192cad218abSAmir Goldstein 1193146d62e5SAmir Goldstein static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs, 1194146d62e5SAmir Goldstein struct path *workpath) 11958ed61dc3SMiklos Szeredi { 119608f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 11978ed61dc3SMiklos Szeredi struct dentry *temp; 1198d80172c2SAmir Goldstein bool rename_whiteout; 1199d80172c2SAmir Goldstein bool d_type; 1200e487d889SAmir Goldstein int fh_type; 12018ed61dc3SMiklos Szeredi int err; 12028ed61dc3SMiklos Szeredi 12032ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 12042ba9d57eSAmir Goldstein if (err) 12052ba9d57eSAmir Goldstein return err; 12062ba9d57eSAmir Goldstein 1207ad204488SMiklos Szeredi ofs->workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 1208ad204488SMiklos Szeredi if (!ofs->workdir) 12092ba9d57eSAmir Goldstein goto out; 12108ed61dc3SMiklos Szeredi 1211146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir"); 1212146d62e5SAmir Goldstein if (err) 1213146d62e5SAmir Goldstein goto out; 1214146d62e5SAmir Goldstein 12158ed61dc3SMiklos Szeredi /* 12168ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 12178ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 12188ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 12198ed61dc3SMiklos Szeredi * previous step. 12208ed61dc3SMiklos Szeredi */ 12218ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 12228ed61dc3SMiklos Szeredi if (err < 0) 12232ba9d57eSAmir Goldstein goto out; 12248ed61dc3SMiklos Szeredi 1225d80172c2SAmir Goldstein d_type = err; 1226d80172c2SAmir Goldstein if (!d_type) 12271bd0a3aeSlijiazi pr_warn("upper fs needs to support d_type.\n"); 12288ed61dc3SMiklos Szeredi 12298ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 1230ad204488SMiklos Szeredi temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0); 1231ad204488SMiklos Szeredi ofs->tmpfile = !IS_ERR(temp); 1232ad204488SMiklos Szeredi if (ofs->tmpfile) 12338ed61dc3SMiklos Szeredi dput(temp); 12348ed61dc3SMiklos Szeredi else 12351bd0a3aeSlijiazi pr_warn("upper fs does not support tmpfile.\n"); 12368ed61dc3SMiklos Szeredi 1237cad218abSAmir Goldstein 1238cad218abSAmir Goldstein /* Check if upper/work fs supports RENAME_WHITEOUT */ 1239cad218abSAmir Goldstein err = ovl_check_rename_whiteout(ofs->workdir); 1240cad218abSAmir Goldstein if (err < 0) 1241cad218abSAmir Goldstein goto out; 1242cad218abSAmir Goldstein 1243d80172c2SAmir Goldstein rename_whiteout = err; 1244d80172c2SAmir Goldstein if (!rename_whiteout) 1245cad218abSAmir Goldstein pr_warn("upper fs does not support RENAME_WHITEOUT.\n"); 1246cad218abSAmir Goldstein 12478ed61dc3SMiklos Szeredi /* 12488ed61dc3SMiklos Szeredi * Check if upper/work fs supports trusted.overlay.* xattr 12498ed61dc3SMiklos Szeredi */ 1250ad204488SMiklos Szeredi err = ovl_do_setxattr(ofs->workdir, OVL_XATTR_OPAQUE, "0", 1, 0); 12518ed61dc3SMiklos Szeredi if (err) { 1252ad204488SMiklos Szeredi ofs->noxattr = true; 1253a683737bSAmir Goldstein ofs->config.index = false; 1254d5791044SVivek Goyal ofs->config.metacopy = false; 12551bd0a3aeSlijiazi pr_warn("upper fs does not support xattr, falling back to index=off and metacopy=off.\n"); 12562ba9d57eSAmir Goldstein err = 0; 12578ed61dc3SMiklos Szeredi } else { 1258ad204488SMiklos Szeredi vfs_removexattr(ofs->workdir, OVL_XATTR_OPAQUE); 12598ed61dc3SMiklos Szeredi } 12608ed61dc3SMiklos Szeredi 1261d80172c2SAmir Goldstein /* 1262d80172c2SAmir Goldstein * We allowed sub-optimal upper fs configuration and don't want to break 1263d80172c2SAmir Goldstein * users over kernel upgrade, but we never allowed remote upper fs, so 1264d80172c2SAmir Goldstein * we can enforce strict requirements for remote upper fs. 1265d80172c2SAmir Goldstein */ 1266d80172c2SAmir Goldstein if (ovl_dentry_remote(ofs->workdir) && 1267d80172c2SAmir Goldstein (!d_type || !rename_whiteout || ofs->noxattr)) { 1268d80172c2SAmir Goldstein pr_err("upper fs missing required features.\n"); 1269d80172c2SAmir Goldstein err = -EINVAL; 1270d80172c2SAmir Goldstein goto out; 1271d80172c2SAmir Goldstein } 1272d80172c2SAmir Goldstein 12738ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 1274e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 1275e487d889SAmir Goldstein if (ofs->config.index && !fh_type) { 1276ad204488SMiklos Szeredi ofs->config.index = false; 12771bd0a3aeSlijiazi pr_warn("upper fs does not support file handles, falling back to index=off.\n"); 12788ed61dc3SMiklos Szeredi } 12798ed61dc3SMiklos Szeredi 1280e487d889SAmir Goldstein /* Check if upper fs has 32bit inode numbers */ 1281e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 12820f831ec8SAmir Goldstein ofs->xino_mode = -1; 1283e487d889SAmir Goldstein 1284f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */ 1285f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) { 12861bd0a3aeSlijiazi pr_warn("NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 1287f168f109SAmir Goldstein ofs->config.nfs_export = false; 1288f168f109SAmir Goldstein } 12892ba9d57eSAmir Goldstein out: 12902ba9d57eSAmir Goldstein mnt_drop_write(mnt); 12912ba9d57eSAmir Goldstein return err; 12928ed61dc3SMiklos Szeredi } 12938ed61dc3SMiklos Szeredi 1294146d62e5SAmir Goldstein static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs, 1295146d62e5SAmir Goldstein struct path *upperpath) 1296520d7c86SMiklos Szeredi { 1297520d7c86SMiklos Szeredi int err; 1298bca44b52SMiklos Szeredi struct path workpath = { }; 1299520d7c86SMiklos Szeredi 1300ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.workdir, &workpath); 1301520d7c86SMiklos Szeredi if (err) 1302520d7c86SMiklos Szeredi goto out; 1303520d7c86SMiklos Szeredi 1304520d7c86SMiklos Szeredi err = -EINVAL; 1305bca44b52SMiklos Szeredi if (upperpath->mnt != workpath.mnt) { 13061bd0a3aeSlijiazi pr_err("workdir and upperdir must reside under the same mount\n"); 1307520d7c86SMiklos Szeredi goto out; 1308520d7c86SMiklos Szeredi } 1309bca44b52SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 13101bd0a3aeSlijiazi pr_err("workdir and upperdir must be separate subtrees\n"); 1311520d7c86SMiklos Szeredi goto out; 1312520d7c86SMiklos Szeredi } 1313520d7c86SMiklos Szeredi 13148c25741aSMiklos Szeredi ofs->workbasedir = dget(workpath.dentry); 13158c25741aSMiklos Szeredi 13168c25741aSMiklos Szeredi if (ovl_inuse_trylock(ofs->workbasedir)) { 1317ad204488SMiklos Szeredi ofs->workdir_locked = true; 1318520d7c86SMiklos Szeredi } else { 13190be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "workdir"); 13200be0bfd2SAmir Goldstein if (err) 13210be0bfd2SAmir Goldstein goto out; 1322520d7c86SMiklos Szeredi } 1323520d7c86SMiklos Szeredi 13240be0bfd2SAmir Goldstein err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap, 13250be0bfd2SAmir Goldstein "workdir"); 13260be0bfd2SAmir Goldstein if (err) 13270be0bfd2SAmir Goldstein goto out; 13280be0bfd2SAmir Goldstein 1329146d62e5SAmir Goldstein err = ovl_make_workdir(sb, ofs, &workpath); 1330bca44b52SMiklos Szeredi 1331520d7c86SMiklos Szeredi out: 1332bca44b52SMiklos Szeredi path_put(&workpath); 1333bca44b52SMiklos Szeredi 1334520d7c86SMiklos Szeredi return err; 1335520d7c86SMiklos Szeredi } 1336520d7c86SMiklos Szeredi 1337146d62e5SAmir Goldstein static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs, 1338146d62e5SAmir Goldstein struct ovl_entry *oe, struct path *upperpath) 1339f7e3a7d9SMiklos Szeredi { 134008f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 1341f7e3a7d9SMiklos Szeredi int err; 1342f7e3a7d9SMiklos Szeredi 13432ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 13442ba9d57eSAmir Goldstein if (err) 13452ba9d57eSAmir Goldstein return err; 13462ba9d57eSAmir Goldstein 1347f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 1348d9768076SAmir Goldstein err = ovl_verify_origin(upperpath->dentry, oe->lowerstack[0].dentry, 134905122443SAmir Goldstein true); 1350f7e3a7d9SMiklos Szeredi if (err) { 13511bd0a3aeSlijiazi pr_err("failed to verify upper root origin\n"); 1352f7e3a7d9SMiklos Szeredi goto out; 1353f7e3a7d9SMiklos Szeredi } 1354f7e3a7d9SMiklos Szeredi 1355ad204488SMiklos Szeredi ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1356ad204488SMiklos Szeredi if (ofs->indexdir) { 1357146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap, 1358146d62e5SAmir Goldstein "indexdir"); 1359146d62e5SAmir Goldstein if (err) 1360146d62e5SAmir Goldstein goto out; 1361146d62e5SAmir Goldstein 1362ad1d615cSAmir Goldstein /* 1363ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir. 1364ad1d615cSAmir Goldstein * Older kernels stored upper fh in "trusted.overlay.origin" 1365ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to 1366ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr 1367ad1d615cSAmir Goldstein * "trusted.overlay.upper" to indicate that index may have 1368ad1d615cSAmir Goldstein * directory entries. 1369ad1d615cSAmir Goldstein */ 1370ad1d615cSAmir Goldstein if (ovl_check_origin_xattr(ofs->indexdir)) { 137105122443SAmir Goldstein err = ovl_verify_set_fh(ofs->indexdir, OVL_XATTR_ORIGIN, 1372ad1d615cSAmir Goldstein upperpath->dentry, true, false); 1373f7e3a7d9SMiklos Szeredi if (err) 13741bd0a3aeSlijiazi pr_err("failed to verify index dir 'origin' xattr\n"); 1375ad1d615cSAmir Goldstein } 1376ad1d615cSAmir Goldstein err = ovl_verify_upper(ofs->indexdir, upperpath->dentry, true); 1377ad1d615cSAmir Goldstein if (err) 13781bd0a3aeSlijiazi pr_err("failed to verify index dir 'upper' xattr\n"); 1379f7e3a7d9SMiklos Szeredi 1380f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 1381f7e3a7d9SMiklos Szeredi if (!err) 13821eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs); 1383f7e3a7d9SMiklos Szeredi } 1384ad204488SMiklos Szeredi if (err || !ofs->indexdir) 13851bd0a3aeSlijiazi pr_warn("try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1386f7e3a7d9SMiklos Szeredi 1387f7e3a7d9SMiklos Szeredi out: 13882ba9d57eSAmir Goldstein mnt_drop_write(mnt); 1389f7e3a7d9SMiklos Szeredi return err; 1390f7e3a7d9SMiklos Szeredi } 1391f7e3a7d9SMiklos Szeredi 13929df085f3SAmir Goldstein static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid) 13935148626bSAmir Goldstein { 13945148626bSAmir Goldstein unsigned int i; 13959df085f3SAmir Goldstein 139608f4c7c8SMiklos Szeredi if (!ofs->config.nfs_export && !ovl_upper_mnt(ofs)) 13979df085f3SAmir Goldstein return true; 13989df085f3SAmir Goldstein 13991b81ddddSAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 14009df085f3SAmir Goldstein /* 14019df085f3SAmir Goldstein * We use uuid to associate an overlay lower file handle with a 14029df085f3SAmir Goldstein * lower layer, so we can accept lower fs with null uuid as long 14039df085f3SAmir Goldstein * as all lower layers with null uuid are on the same fs. 14047e63c87fSAmir Goldstein * if we detect multiple lower fs with the same uuid, we 14057e63c87fSAmir Goldstein * disable lower file handle decoding on all of them. 14069df085f3SAmir Goldstein */ 14071b81ddddSAmir Goldstein if (ofs->fs[i].is_lower && 14081b81ddddSAmir Goldstein uuid_equal(&ofs->fs[i].sb->s_uuid, uuid)) { 140907f1e596SAmir Goldstein ofs->fs[i].bad_uuid = true; 14109df085f3SAmir Goldstein return false; 14119df085f3SAmir Goldstein } 14127e63c87fSAmir Goldstein } 14139df085f3SAmir Goldstein return true; 14149df085f3SAmir Goldstein } 14159df085f3SAmir Goldstein 14169df085f3SAmir Goldstein /* Get a unique fsid for the layer */ 14179df085f3SAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) 14189df085f3SAmir Goldstein { 14199df085f3SAmir Goldstein struct super_block *sb = path->mnt->mnt_sb; 14209df085f3SAmir Goldstein unsigned int i; 14215148626bSAmir Goldstein dev_t dev; 14225148626bSAmir Goldstein int err; 14237e63c87fSAmir Goldstein bool bad_uuid = false; 14245148626bSAmir Goldstein 142507f1e596SAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 142607f1e596SAmir Goldstein if (ofs->fs[i].sb == sb) 142707f1e596SAmir Goldstein return i; 14285148626bSAmir Goldstein } 14295148626bSAmir Goldstein 14309df085f3SAmir Goldstein if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) { 14317e63c87fSAmir Goldstein bad_uuid = true; 14327e63c87fSAmir Goldstein if (ofs->config.index || ofs->config.nfs_export) { 14339df085f3SAmir Goldstein ofs->config.index = false; 14349df085f3SAmir Goldstein ofs->config.nfs_export = false; 14351bd0a3aeSlijiazi pr_warn("%s uuid detected in lower fs '%pd2', falling back to index=off,nfs_export=off.\n", 14367e63c87fSAmir Goldstein uuid_is_null(&sb->s_uuid) ? "null" : 14377e63c87fSAmir Goldstein "conflicting", 14389df085f3SAmir Goldstein path->dentry); 14399df085f3SAmir Goldstein } 14407e63c87fSAmir Goldstein } 14419df085f3SAmir Goldstein 14425148626bSAmir Goldstein err = get_anon_bdev(&dev); 14435148626bSAmir Goldstein if (err) { 14441bd0a3aeSlijiazi pr_err("failed to get anonymous bdev for lowerpath\n"); 14455148626bSAmir Goldstein return err; 14465148626bSAmir Goldstein } 14475148626bSAmir Goldstein 144807f1e596SAmir Goldstein ofs->fs[ofs->numfs].sb = sb; 144907f1e596SAmir Goldstein ofs->fs[ofs->numfs].pseudo_dev = dev; 145007f1e596SAmir Goldstein ofs->fs[ofs->numfs].bad_uuid = bad_uuid; 14515148626bSAmir Goldstein 145207f1e596SAmir Goldstein return ofs->numfs++; 14535148626bSAmir Goldstein } 14545148626bSAmir Goldstein 145594375f9dSAmir Goldstein static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, 1456b8e42a65SMiklos Szeredi struct path *stack, unsigned int numlower, 1457b8e42a65SMiklos Szeredi struct ovl_layer *layers) 1458520d7c86SMiklos Szeredi { 1459520d7c86SMiklos Szeredi int err; 1460520d7c86SMiklos Szeredi unsigned int i; 1461520d7c86SMiklos Szeredi 1462520d7c86SMiklos Szeredi err = -ENOMEM; 146307f1e596SAmir Goldstein ofs->fs = kcalloc(numlower + 1, sizeof(struct ovl_sb), GFP_KERNEL); 146407f1e596SAmir Goldstein if (ofs->fs == NULL) 14655148626bSAmir Goldstein goto out; 14665148626bSAmir Goldstein 146707f1e596SAmir Goldstein /* idx/fsid 0 are reserved for upper fs even with lower only overlay */ 146807f1e596SAmir Goldstein ofs->numfs++; 146907f1e596SAmir Goldstein 147007f1e596SAmir Goldstein /* 1471b7bf9908SAmir Goldstein * All lower layers that share the same fs as upper layer, use the same 1472b7bf9908SAmir Goldstein * pseudo_dev as upper layer. Allocate fs[0].pseudo_dev even for lower 1473b7bf9908SAmir Goldstein * only overlay to simplify ovl_fs_free(). 14741b81ddddSAmir Goldstein * is_lower will be set if upper fs is shared with a lower layer. 147507f1e596SAmir Goldstein */ 1476b7bf9908SAmir Goldstein err = get_anon_bdev(&ofs->fs[0].pseudo_dev); 1477b7bf9908SAmir Goldstein if (err) { 1478b7bf9908SAmir Goldstein pr_err("failed to get anonymous bdev for upper fs\n"); 1479b7bf9908SAmir Goldstein goto out; 1480b7bf9908SAmir Goldstein } 1481b7bf9908SAmir Goldstein 148208f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 148308f4c7c8SMiklos Szeredi ofs->fs[0].sb = ovl_upper_mnt(ofs)->mnt_sb; 14841b81ddddSAmir Goldstein ofs->fs[0].is_lower = false; 148507f1e596SAmir Goldstein } 148607f1e596SAmir Goldstein 1487520d7c86SMiklos Szeredi for (i = 0; i < numlower; i++) { 1488520d7c86SMiklos Szeredi struct vfsmount *mnt; 1489146d62e5SAmir Goldstein struct inode *trap; 14905148626bSAmir Goldstein int fsid; 1491520d7c86SMiklos Szeredi 14929df085f3SAmir Goldstein err = fsid = ovl_get_fsid(ofs, &stack[i]); 14935148626bSAmir Goldstein if (err < 0) 1494520d7c86SMiklos Szeredi goto out; 1495520d7c86SMiklos Szeredi 149624f14009Syoungjun /* 149724f14009Syoungjun * Check if lower root conflicts with this overlay layers before 149824f14009Syoungjun * checking if it is in-use as upperdir/workdir of "another" 149924f14009Syoungjun * mount, because we do not bother to check in ovl_is_inuse() if 150024f14009Syoungjun * the upperdir/workdir is in fact in-use by our 150124f14009Syoungjun * upperdir/workdir. 150224f14009Syoungjun */ 1503146d62e5SAmir Goldstein err = ovl_setup_trap(sb, stack[i].dentry, &trap, "lowerdir"); 1504146d62e5SAmir Goldstein if (err) 1505146d62e5SAmir Goldstein goto out; 1506146d62e5SAmir Goldstein 15070be0bfd2SAmir Goldstein if (ovl_is_inuse(stack[i].dentry)) { 15080be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "lowerdir"); 150924f14009Syoungjun if (err) { 151024f14009Syoungjun iput(trap); 15110be0bfd2SAmir Goldstein goto out; 15120be0bfd2SAmir Goldstein } 151324f14009Syoungjun } 15140be0bfd2SAmir Goldstein 1515520d7c86SMiklos Szeredi mnt = clone_private_mount(&stack[i]); 1516520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1517520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 15181bd0a3aeSlijiazi pr_err("failed to clone lowerpath\n"); 1519146d62e5SAmir Goldstein iput(trap); 1520520d7c86SMiklos Szeredi goto out; 1521520d7c86SMiklos Szeredi } 15225148626bSAmir Goldstein 1523520d7c86SMiklos Szeredi /* 1524520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1525520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1526520d7c86SMiklos Szeredi */ 1527520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1528520d7c86SMiklos Szeredi 152913464165SMiklos Szeredi layers[ofs->numlayer].trap = trap; 153013464165SMiklos Szeredi layers[ofs->numlayer].mnt = mnt; 153113464165SMiklos Szeredi layers[ofs->numlayer].idx = ofs->numlayer; 153213464165SMiklos Szeredi layers[ofs->numlayer].fsid = fsid; 153313464165SMiklos Szeredi layers[ofs->numlayer].fs = &ofs->fs[fsid]; 153494375f9dSAmir Goldstein ofs->numlayer++; 15351b81ddddSAmir Goldstein ofs->fs[fsid].is_lower = true; 1536520d7c86SMiklos Szeredi } 1537e487d889SAmir Goldstein 1538795939a9SAmir Goldstein /* 1539795939a9SAmir Goldstein * When all layers on same fs, overlay can use real inode numbers. 1540926e94d7SAmir Goldstein * With mount option "xino=<on|auto>", mounter declares that there are 1541926e94d7SAmir Goldstein * enough free high bits in underlying fs to hold the unique fsid. 1542795939a9SAmir Goldstein * If overlayfs does encounter underlying inodes using the high xino 1543795939a9SAmir Goldstein * bits reserved for fsid, it emits a warning and uses the original 1544dfe51d47SAmir Goldstein * inode number or a non persistent inode number allocated from a 1545dfe51d47SAmir Goldstein * dedicated range. 1546795939a9SAmir Goldstein */ 154708f4c7c8SMiklos Szeredi if (ofs->numfs - !ovl_upper_mnt(ofs) == 1) { 15480f831ec8SAmir Goldstein if (ofs->config.xino == OVL_XINO_ON) 15490f831ec8SAmir Goldstein pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n"); 15500f831ec8SAmir Goldstein ofs->xino_mode = 0; 155153afcd31SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_OFF) { 155253afcd31SAmir Goldstein ofs->xino_mode = -1; 1553926e94d7SAmir Goldstein } else if (ofs->xino_mode < 0) { 1554795939a9SAmir Goldstein /* 155507f1e596SAmir Goldstein * This is a roundup of number of bits needed for encoding 1556dfe51d47SAmir Goldstein * fsid, where fsid 0 is reserved for upper fs (even with 1557dfe51d47SAmir Goldstein * lower only overlay) +1 extra bit is reserved for the non 1558dfe51d47SAmir Goldstein * persistent inode number range that is used for resolving 1559dfe51d47SAmir Goldstein * xino lower bits overflow. 1560795939a9SAmir Goldstein */ 1561dfe51d47SAmir Goldstein BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 30); 1562dfe51d47SAmir Goldstein ofs->xino_mode = ilog2(ofs->numfs - 1) + 2; 1563795939a9SAmir Goldstein } 1564795939a9SAmir Goldstein 15650f831ec8SAmir Goldstein if (ofs->xino_mode > 0) { 15661bd0a3aeSlijiazi pr_info("\"xino\" feature enabled using %d upper inode bits.\n", 15670f831ec8SAmir Goldstein ofs->xino_mode); 1568795939a9SAmir Goldstein } 1569e487d889SAmir Goldstein 1570520d7c86SMiklos Szeredi err = 0; 1571520d7c86SMiklos Szeredi out: 1572520d7c86SMiklos Szeredi return err; 1573520d7c86SMiklos Szeredi } 1574520d7c86SMiklos Szeredi 15754155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1576b8e42a65SMiklos Szeredi const char *lower, unsigned int numlower, 1577b8e42a65SMiklos Szeredi struct ovl_fs *ofs, struct ovl_layer *layers) 157853dbb0b4SMiklos Szeredi { 157953dbb0b4SMiklos Szeredi int err; 15804155c10aSMiklos Szeredi struct path *stack = NULL; 1581b8e42a65SMiklos Szeredi unsigned int i; 15824155c10aSMiklos Szeredi struct ovl_entry *oe; 158353dbb0b4SMiklos Szeredi 1584b8e42a65SMiklos Szeredi if (!ofs->config.upperdir && numlower == 1) { 15851bd0a3aeSlijiazi pr_err("at least 2 lowerdir are needed while upperdir nonexistent\n"); 1586b8e42a65SMiklos Szeredi return ERR_PTR(-EINVAL); 1587f168f109SAmir Goldstein } else if (!ofs->config.upperdir && ofs->config.nfs_export && 1588f168f109SAmir Goldstein ofs->config.redirect_follow) { 15891bd0a3aeSlijiazi pr_warn("NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n"); 1590f168f109SAmir Goldstein ofs->config.nfs_export = false; 159153dbb0b4SMiklos Szeredi } 159253dbb0b4SMiklos Szeredi 1593b8e42a65SMiklos Szeredi stack = kcalloc(numlower, sizeof(struct path), GFP_KERNEL); 159453dbb0b4SMiklos Szeredi if (!stack) 1595b8e42a65SMiklos Szeredi return ERR_PTR(-ENOMEM); 159653dbb0b4SMiklos Szeredi 159753dbb0b4SMiklos Szeredi err = -EINVAL; 1598b8e42a65SMiklos Szeredi for (i = 0; i < numlower; i++) { 1599b8e42a65SMiklos Szeredi err = ovl_lower_dir(lower, &stack[i], ofs, &sb->s_stack_depth); 160053dbb0b4SMiklos Szeredi if (err) 16014155c10aSMiklos Szeredi goto out_err; 160253dbb0b4SMiklos Szeredi 160353dbb0b4SMiklos Szeredi lower = strchr(lower, '\0') + 1; 160453dbb0b4SMiklos Szeredi } 160553dbb0b4SMiklos Szeredi 160653dbb0b4SMiklos Szeredi err = -EINVAL; 160753dbb0b4SMiklos Szeredi sb->s_stack_depth++; 160853dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 16091bd0a3aeSlijiazi pr_err("maximum fs stacking depth exceeded\n"); 16104155c10aSMiklos Szeredi goto out_err; 161153dbb0b4SMiklos Szeredi } 161253dbb0b4SMiklos Szeredi 1613b8e42a65SMiklos Szeredi err = ovl_get_layers(sb, ofs, stack, numlower, layers); 16144155c10aSMiklos Szeredi if (err) 16154155c10aSMiklos Szeredi goto out_err; 16164155c10aSMiklos Szeredi 16174155c10aSMiklos Szeredi err = -ENOMEM; 16184155c10aSMiklos Szeredi oe = ovl_alloc_entry(numlower); 16194155c10aSMiklos Szeredi if (!oe) 16204155c10aSMiklos Szeredi goto out_err; 16214155c10aSMiklos Szeredi 16224155c10aSMiklos Szeredi for (i = 0; i < numlower; i++) { 16234155c10aSMiklos Szeredi oe->lowerstack[i].dentry = dget(stack[i].dentry); 162494375f9dSAmir Goldstein oe->lowerstack[i].layer = &ofs->layers[i+1]; 16254155c10aSMiklos Szeredi } 162653dbb0b4SMiklos Szeredi 162753dbb0b4SMiklos Szeredi out: 162853dbb0b4SMiklos Szeredi for (i = 0; i < numlower; i++) 162953dbb0b4SMiklos Szeredi path_put(&stack[i]); 163053dbb0b4SMiklos Szeredi kfree(stack); 16314155c10aSMiklos Szeredi 16324155c10aSMiklos Szeredi return oe; 16334155c10aSMiklos Szeredi 16344155c10aSMiklos Szeredi out_err: 16354155c10aSMiklos Szeredi oe = ERR_PTR(err); 163653dbb0b4SMiklos Szeredi goto out; 163753dbb0b4SMiklos Szeredi } 163853dbb0b4SMiklos Szeredi 1639146d62e5SAmir Goldstein /* 1640146d62e5SAmir Goldstein * Check if this layer root is a descendant of: 1641146d62e5SAmir Goldstein * - another layer of this overlayfs instance 1642146d62e5SAmir Goldstein * - upper/work dir of any overlayfs instance 1643146d62e5SAmir Goldstein */ 16440be0bfd2SAmir Goldstein static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs, 16450be0bfd2SAmir Goldstein struct dentry *dentry, const char *name) 1646146d62e5SAmir Goldstein { 16479179c21dSMiklos Szeredi struct dentry *next = dentry, *parent; 1648146d62e5SAmir Goldstein int err = 0; 1649146d62e5SAmir Goldstein 16509179c21dSMiklos Szeredi if (!dentry) 1651146d62e5SAmir Goldstein return 0; 1652146d62e5SAmir Goldstein 1653146d62e5SAmir Goldstein parent = dget_parent(next); 16549179c21dSMiklos Szeredi 16559179c21dSMiklos Szeredi /* Walk back ancestors to root (inclusive) looking for traps */ 16569179c21dSMiklos Szeredi while (!err && parent != next) { 16570be0bfd2SAmir Goldstein if (ovl_lookup_trap_inode(sb, parent)) { 1658146d62e5SAmir Goldstein err = -ELOOP; 16591bd0a3aeSlijiazi pr_err("overlapping %s path\n", name); 16600be0bfd2SAmir Goldstein } else if (ovl_is_inuse(parent)) { 16610be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, name); 1662146d62e5SAmir Goldstein } 1663146d62e5SAmir Goldstein next = parent; 16649179c21dSMiklos Szeredi parent = dget_parent(next); 16659179c21dSMiklos Szeredi dput(next); 1666146d62e5SAmir Goldstein } 1667146d62e5SAmir Goldstein 16689179c21dSMiklos Szeredi dput(parent); 1669146d62e5SAmir Goldstein 1670146d62e5SAmir Goldstein return err; 1671146d62e5SAmir Goldstein } 1672146d62e5SAmir Goldstein 1673146d62e5SAmir Goldstein /* 1674146d62e5SAmir Goldstein * Check if any of the layers or work dirs overlap. 1675146d62e5SAmir Goldstein */ 1676146d62e5SAmir Goldstein static int ovl_check_overlapping_layers(struct super_block *sb, 1677146d62e5SAmir Goldstein struct ovl_fs *ofs) 1678146d62e5SAmir Goldstein { 1679146d62e5SAmir Goldstein int i, err; 1680146d62e5SAmir Goldstein 168108f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 168208f4c7c8SMiklos Szeredi err = ovl_check_layer(sb, ofs, ovl_upper_mnt(ofs)->mnt_root, 16830be0bfd2SAmir Goldstein "upperdir"); 1684146d62e5SAmir Goldstein if (err) 1685146d62e5SAmir Goldstein return err; 1686146d62e5SAmir Goldstein 1687146d62e5SAmir Goldstein /* 1688146d62e5SAmir Goldstein * Checking workbasedir avoids hitting ovl_is_inuse(parent) of 1689146d62e5SAmir Goldstein * this instance and covers overlapping work and index dirs, 1690146d62e5SAmir Goldstein * unless work or index dir have been moved since created inside 1691146d62e5SAmir Goldstein * workbasedir. In that case, we already have their traps in 1692146d62e5SAmir Goldstein * inode cache and we will catch that case on lookup. 1693146d62e5SAmir Goldstein */ 16940be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir"); 1695146d62e5SAmir Goldstein if (err) 1696146d62e5SAmir Goldstein return err; 1697146d62e5SAmir Goldstein } 1698146d62e5SAmir Goldstein 169994375f9dSAmir Goldstein for (i = 1; i < ofs->numlayer; i++) { 17000be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, 170194375f9dSAmir Goldstein ofs->layers[i].mnt->mnt_root, 1702146d62e5SAmir Goldstein "lowerdir"); 1703146d62e5SAmir Goldstein if (err) 1704146d62e5SAmir Goldstein return err; 1705146d62e5SAmir Goldstein } 1706146d62e5SAmir Goldstein 1707146d62e5SAmir Goldstein return 0; 1708146d62e5SAmir Goldstein } 1709146d62e5SAmir Goldstein 17102effc5c2SAmir Goldstein static struct dentry *ovl_get_root(struct super_block *sb, 17112effc5c2SAmir Goldstein struct dentry *upperdentry, 17122effc5c2SAmir Goldstein struct ovl_entry *oe) 17132effc5c2SAmir Goldstein { 17142effc5c2SAmir Goldstein struct dentry *root; 171562c832edSAmir Goldstein struct ovl_path *lowerpath = &oe->lowerstack[0]; 171662c832edSAmir Goldstein unsigned long ino = d_inode(lowerpath->dentry)->i_ino; 171762c832edSAmir Goldstein int fsid = lowerpath->layer->fsid; 171862c832edSAmir Goldstein struct ovl_inode_params oip = { 171962c832edSAmir Goldstein .upperdentry = upperdentry, 172062c832edSAmir Goldstein .lowerpath = lowerpath, 172162c832edSAmir Goldstein }; 17222effc5c2SAmir Goldstein 17232effc5c2SAmir Goldstein root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 17242effc5c2SAmir Goldstein if (!root) 17252effc5c2SAmir Goldstein return NULL; 17262effc5c2SAmir Goldstein 17272effc5c2SAmir Goldstein root->d_fsdata = oe; 17282effc5c2SAmir Goldstein 17292effc5c2SAmir Goldstein if (upperdentry) { 173062c832edSAmir Goldstein /* Root inode uses upper st_ino/i_ino */ 173162c832edSAmir Goldstein ino = d_inode(upperdentry)->i_ino; 173262c832edSAmir Goldstein fsid = 0; 17332effc5c2SAmir Goldstein ovl_dentry_set_upper_alias(root); 17342effc5c2SAmir Goldstein if (ovl_is_impuredir(upperdentry)) 17352effc5c2SAmir Goldstein ovl_set_flag(OVL_IMPURE, d_inode(root)); 17362effc5c2SAmir Goldstein } 17372effc5c2SAmir Goldstein 17382effc5c2SAmir Goldstein /* Root is always merge -> can have whiteouts */ 17392effc5c2SAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root)); 17402effc5c2SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root); 17412effc5c2SAmir Goldstein ovl_set_upperdata(d_inode(root)); 174262c832edSAmir Goldstein ovl_inode_init(d_inode(root), &oip, ino, fsid); 1743f4288844SMiklos Szeredi ovl_dentry_update_reval(root, upperdentry, DCACHE_OP_WEAK_REVALIDATE); 17442effc5c2SAmir Goldstein 17452effc5c2SAmir Goldstein return root; 17462effc5c2SAmir Goldstein } 17472effc5c2SAmir Goldstein 1748e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1749e9be9d5eSMiklos Szeredi { 175033006cdfSKees Cook struct path upperpath = { }; 1751e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 17524155c10aSMiklos Szeredi struct ovl_entry *oe; 1753ad204488SMiklos Szeredi struct ovl_fs *ofs; 1754b8e42a65SMiklos Szeredi struct ovl_layer *layers; 175551f8f3c4SKonstantin Khlebnikov struct cred *cred; 1756b8e42a65SMiklos Szeredi char *splitlower = NULL; 1757b8e42a65SMiklos Szeredi unsigned int numlower; 1758e9be9d5eSMiklos Szeredi int err; 1759e9be9d5eSMiklos Szeredi 1760f4288844SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 1761f4288844SMiklos Szeredi 1762f45827e8SErez Zadok err = -ENOMEM; 1763ad204488SMiklos Szeredi ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1764ad204488SMiklos Szeredi if (!ofs) 1765e9be9d5eSMiklos Szeredi goto out; 1766e9be9d5eSMiklos Szeredi 1767ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1768c6fe6254SMiklos Szeredi if (!cred) 1769c6fe6254SMiklos Szeredi goto out_err; 1770c6fe6254SMiklos Szeredi 1771c21c839bSChengguang Xu /* Is there a reason anyone would want not to share whiteouts? */ 1772c21c839bSChengguang Xu ofs->share_whiteout = true; 1773c21c839bSChengguang Xu 1774ad204488SMiklos Szeredi ofs->config.index = ovl_index_def; 1775f168f109SAmir Goldstein ofs->config.nfs_export = ovl_nfs_export_def; 1776795939a9SAmir Goldstein ofs->config.xino = ovl_xino_def(); 1777d5791044SVivek Goyal ofs->config.metacopy = ovl_metacopy_def; 1778ad204488SMiklos Szeredi err = ovl_parse_opt((char *) data, &ofs->config); 1779f45827e8SErez Zadok if (err) 1780a9075cdbSMiklos Szeredi goto out_err; 1781f45827e8SErez Zadok 1782e9be9d5eSMiklos Szeredi err = -EINVAL; 1783ad204488SMiklos Szeredi if (!ofs->config.lowerdir) { 178407f2af7bSKonstantin Khlebnikov if (!silent) 17851bd0a3aeSlijiazi pr_err("missing 'lowerdir'\n"); 1786a9075cdbSMiklos Szeredi goto out_err; 178753a08cb9SMiklos Szeredi } 178853a08cb9SMiklos Szeredi 1789b8e42a65SMiklos Szeredi err = -ENOMEM; 1790b8e42a65SMiklos Szeredi splitlower = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 1791b8e42a65SMiklos Szeredi if (!splitlower) 1792b8e42a65SMiklos Szeredi goto out_err; 1793b8e42a65SMiklos Szeredi 1794b8e42a65SMiklos Szeredi numlower = ovl_split_lowerdirs(splitlower); 1795b8e42a65SMiklos Szeredi if (numlower > OVL_MAX_STACK) { 1796b8e42a65SMiklos Szeredi pr_err("too many lower directories, limit is %d\n", 1797b8e42a65SMiklos Szeredi OVL_MAX_STACK); 1798b8e42a65SMiklos Szeredi goto out_err; 1799b8e42a65SMiklos Szeredi } 1800b8e42a65SMiklos Szeredi 1801b8e42a65SMiklos Szeredi layers = kcalloc(numlower + 1, sizeof(struct ovl_layer), GFP_KERNEL); 1802b8e42a65SMiklos Szeredi if (!layers) 1803b8e42a65SMiklos Szeredi goto out_err; 1804b8e42a65SMiklos Szeredi 1805b8e42a65SMiklos Szeredi ofs->layers = layers; 1806b8e42a65SMiklos Szeredi /* Layer 0 is reserved for upper even if there's no upper */ 1807b8e42a65SMiklos Szeredi ofs->numlayer = 1; 1808b8e42a65SMiklos Szeredi 180953a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 1810cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 18114d314f78SAmir Goldstein atomic_long_set(&ofs->last_ino, 1); 1812e487d889SAmir Goldstein /* Assume underlaying fs uses 32bit inodes unless proven otherwise */ 181353afcd31SAmir Goldstein if (ofs->config.xino != OVL_XINO_OFF) { 18140f831ec8SAmir Goldstein ofs->xino_mode = BITS_PER_LONG - 32; 181553afcd31SAmir Goldstein if (!ofs->xino_mode) { 181653afcd31SAmir Goldstein pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n"); 181753afcd31SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 181853afcd31SAmir Goldstein } 181953afcd31SAmir Goldstein } 1820795939a9SAmir Goldstein 1821146d62e5SAmir Goldstein /* alloc/destroy_inode needed for setting up traps in inode cache */ 1822146d62e5SAmir Goldstein sb->s_op = &ovl_super_operations; 1823146d62e5SAmir Goldstein 1824ad204488SMiklos Szeredi if (ofs->config.upperdir) { 1825ad204488SMiklos Szeredi if (!ofs->config.workdir) { 18261bd0a3aeSlijiazi pr_err("missing 'workdir'\n"); 1827a9075cdbSMiklos Szeredi goto out_err; 1828e9be9d5eSMiklos Szeredi } 1829e9be9d5eSMiklos Szeredi 1830b8e42a65SMiklos Szeredi err = ovl_get_upper(sb, ofs, &layers[0], &upperpath); 183121a3b317SMiklos Szeredi if (err) 1832a9075cdbSMiklos Szeredi goto out_err; 1833d719e8f2SMiklos Szeredi 1834146d62e5SAmir Goldstein err = ovl_get_workdir(sb, ofs, &upperpath); 18358ed61dc3SMiklos Szeredi if (err) 1836a9075cdbSMiklos Szeredi goto out_err; 1837c6fe6254SMiklos Szeredi 1838ad204488SMiklos Szeredi if (!ofs->workdir) 18391751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 18406e88256eSMiklos Szeredi 184108f4c7c8SMiklos Szeredi sb->s_stack_depth = ovl_upper_mnt(ofs)->mnt_sb->s_stack_depth; 184208f4c7c8SMiklos Szeredi sb->s_time_gran = ovl_upper_mnt(ofs)->mnt_sb->s_time_gran; 1843c6fe6254SMiklos Szeredi 184421765194SVivek Goyal } 1845b8e42a65SMiklos Szeredi oe = ovl_get_lowerstack(sb, splitlower, numlower, ofs, layers); 18464155c10aSMiklos Szeredi err = PTR_ERR(oe); 18474155c10aSMiklos Szeredi if (IS_ERR(oe)) 1848a9075cdbSMiklos Szeredi goto out_err; 1849e9be9d5eSMiklos Szeredi 185071cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 185108f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 18521751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 1853e9be9d5eSMiklos Szeredi 1854ad204488SMiklos Szeredi if (!(ovl_force_readonly(ofs)) && ofs->config.index) { 185562a8a85bSAmir Goldstein /* index dir will act also as workdir */ 185662a8a85bSAmir Goldstein dput(ofs->workdir); 185762a8a85bSAmir Goldstein ofs->workdir = NULL; 185862a8a85bSAmir Goldstein iput(ofs->workdir_trap); 185962a8a85bSAmir Goldstein ofs->workdir_trap = NULL; 186062a8a85bSAmir Goldstein 1861146d62e5SAmir Goldstein err = ovl_get_indexdir(sb, ofs, oe, &upperpath); 186254fb347eSAmir Goldstein if (err) 18634155c10aSMiklos Szeredi goto out_free_oe; 18646e88256eSMiklos Szeredi 1865972d0093SAmir Goldstein /* Force r/o mount with no index dir */ 186662a8a85bSAmir Goldstein if (ofs->indexdir) 186762a8a85bSAmir Goldstein ofs->workdir = dget(ofs->indexdir); 186862a8a85bSAmir Goldstein else 18691751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 187002bcd157SAmir Goldstein } 187102bcd157SAmir Goldstein 1872146d62e5SAmir Goldstein err = ovl_check_overlapping_layers(sb, ofs); 1873146d62e5SAmir Goldstein if (err) 1874146d62e5SAmir Goldstein goto out_free_oe; 1875146d62e5SAmir Goldstein 1876972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */ 1877f168f109SAmir Goldstein if (!ofs->indexdir) { 1878ad204488SMiklos Szeredi ofs->config.index = false; 187908f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs) && ofs->config.nfs_export) { 18801bd0a3aeSlijiazi pr_warn("NFS export requires an index dir, falling back to nfs_export=off.\n"); 1881f168f109SAmir Goldstein ofs->config.nfs_export = false; 1882f168f109SAmir Goldstein } 1883f168f109SAmir Goldstein } 188402bcd157SAmir Goldstein 1885d5791044SVivek Goyal if (ofs->config.metacopy && ofs->config.nfs_export) { 18861bd0a3aeSlijiazi pr_warn("NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 1887d5791044SVivek Goyal ofs->config.nfs_export = false; 1888d5791044SVivek Goyal } 1889d5791044SVivek Goyal 18908383f174SAmir Goldstein if (ofs->config.nfs_export) 18918383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations; 18928383f174SAmir Goldstein 189351f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 189451f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 189551f8f3c4SKonstantin Khlebnikov 1896655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1897655042ccSVivek Goyal sb->s_xattr = ovl_xattr_handlers; 1898ad204488SMiklos Szeredi sb->s_fs_info = ofs; 1899de2a4a50SMiklos Szeredi sb->s_flags |= SB_POSIXACL; 190032b1924bSKonstantin Khlebnikov sb->s_iflags |= SB_I_SKIP_SYNC; 1901655042ccSVivek Goyal 1902c6fe6254SMiklos Szeredi err = -ENOMEM; 19032effc5c2SAmir Goldstein root_dentry = ovl_get_root(sb, upperpath.dentry, oe); 1904e9be9d5eSMiklos Szeredi if (!root_dentry) 19054155c10aSMiklos Szeredi goto out_free_oe; 1906e9be9d5eSMiklos Szeredi 1907e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 1908b8e42a65SMiklos Szeredi kfree(splitlower); 1909ed06e069SMiklos Szeredi 1910e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1911e9be9d5eSMiklos Szeredi 1912e9be9d5eSMiklos Szeredi return 0; 1913e9be9d5eSMiklos Szeredi 19144155c10aSMiklos Szeredi out_free_oe: 19154155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 1916b9343632SChandan Rajendra kfree(oe); 19174155c10aSMiklos Szeredi out_err: 1918b8e42a65SMiklos Szeredi kfree(splitlower); 1919e9be9d5eSMiklos Szeredi path_put(&upperpath); 1920ad204488SMiklos Szeredi ovl_free_fs(ofs); 1921e9be9d5eSMiklos Szeredi out: 1922e9be9d5eSMiklos Szeredi return err; 1923e9be9d5eSMiklos Szeredi } 1924e9be9d5eSMiklos Szeredi 1925e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 1926e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 1927e9be9d5eSMiklos Szeredi { 1928e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 1929e9be9d5eSMiklos Szeredi } 1930e9be9d5eSMiklos Szeredi 1931e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 1932e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1933ef94b186SMiklos Szeredi .name = "overlay", 1934e9be9d5eSMiklos Szeredi .mount = ovl_mount, 1935e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 1936e9be9d5eSMiklos Szeredi }; 1937ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 1938e9be9d5eSMiklos Szeredi 193913cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 194013cf199dSAmir Goldstein { 194113cf199dSAmir Goldstein struct ovl_inode *oi = foo; 194213cf199dSAmir Goldstein 194313cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 194413cf199dSAmir Goldstein } 194513cf199dSAmir Goldstein 1946e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 1947e9be9d5eSMiklos Szeredi { 194813cf199dSAmir Goldstein int err; 194913cf199dSAmir Goldstein 195013cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 195113cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 195213cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 195313cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 195413cf199dSAmir Goldstein ovl_inode_init_once); 195513cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 195613cf199dSAmir Goldstein return -ENOMEM; 195713cf199dSAmir Goldstein 19582406a307SJiufei Xue err = ovl_aio_request_cache_init(); 19592406a307SJiufei Xue if (!err) { 196013cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 19612406a307SJiufei Xue if (!err) 19622406a307SJiufei Xue return 0; 19632406a307SJiufei Xue 19642406a307SJiufei Xue ovl_aio_request_cache_destroy(); 19652406a307SJiufei Xue } 196613cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 196713cf199dSAmir Goldstein 196813cf199dSAmir Goldstein return err; 1969e9be9d5eSMiklos Szeredi } 1970e9be9d5eSMiklos Szeredi 1971e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1972e9be9d5eSMiklos Szeredi { 1973e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 197413cf199dSAmir Goldstein 197513cf199dSAmir Goldstein /* 197613cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 197713cf199dSAmir Goldstein * destroy cache. 197813cf199dSAmir Goldstein */ 197913cf199dSAmir Goldstein rcu_barrier(); 198013cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 19812406a307SJiufei Xue ovl_aio_request_cache_destroy(); 1982e9be9d5eSMiklos Szeredi } 1983e9be9d5eSMiklos Szeredi 1984e9be9d5eSMiklos Szeredi module_init(ovl_init); 1985e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1986