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 { 214dd662667SMiklos Szeredi unsigned i; 215e9be9d5eSMiklos Szeredi 2160be0bfd2SAmir Goldstein iput(ofs->workbasedir_trap); 217146d62e5SAmir Goldstein iput(ofs->indexdir_trap); 218146d62e5SAmir Goldstein iput(ofs->workdir_trap); 219146d62e5SAmir Goldstein iput(ofs->upperdir_trap); 220ad204488SMiklos Szeredi dput(ofs->indexdir); 221ad204488SMiklos Szeredi dput(ofs->workdir); 222ad204488SMiklos Szeredi if (ofs->workdir_locked) 223ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->workbasedir); 224ad204488SMiklos Szeredi dput(ofs->workbasedir); 225ad204488SMiklos Szeredi if (ofs->upperdir_locked) 226ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->upper_mnt->mnt_root); 227ad204488SMiklos Szeredi mntput(ofs->upper_mnt); 22894375f9dSAmir Goldstein for (i = 1; i < ofs->numlayer; i++) { 22994375f9dSAmir Goldstein iput(ofs->layers[i].trap); 23094375f9dSAmir Goldstein mntput(ofs->layers[i].mnt); 231146d62e5SAmir Goldstein } 23294375f9dSAmir Goldstein kfree(ofs->layers); 233b7bf9908SAmir Goldstein for (i = 0; i < ofs->numfs; i++) 23407f1e596SAmir Goldstein free_anon_bdev(ofs->fs[i].pseudo_dev); 23507f1e596SAmir Goldstein kfree(ofs->fs); 236e9be9d5eSMiklos Szeredi 237ad204488SMiklos Szeredi kfree(ofs->config.lowerdir); 238ad204488SMiklos Szeredi kfree(ofs->config.upperdir); 239ad204488SMiklos Szeredi kfree(ofs->config.workdir); 240438c84c2SMiklos Szeredi kfree(ofs->config.redirect_mode); 241ad204488SMiklos Szeredi if (ofs->creator_cred) 242ad204488SMiklos Szeredi put_cred(ofs->creator_cred); 243ad204488SMiklos Szeredi kfree(ofs); 244e9be9d5eSMiklos Szeredi } 245e9be9d5eSMiklos Szeredi 246a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 247a9075cdbSMiklos Szeredi { 248a9075cdbSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 249a9075cdbSMiklos Szeredi 250a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 251a9075cdbSMiklos Szeredi } 252a9075cdbSMiklos Szeredi 253e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */ 254e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 255e593b2bfSAmir Goldstein { 256ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 257e593b2bfSAmir Goldstein struct super_block *upper_sb; 258e593b2bfSAmir Goldstein int ret; 259e593b2bfSAmir Goldstein 260ad204488SMiklos Szeredi if (!ofs->upper_mnt) 261e593b2bfSAmir Goldstein return 0; 262e8d4bfe3SChengguang Xu 263e8d4bfe3SChengguang Xu /* 264e8d4bfe3SChengguang Xu * If this is a sync(2) call or an emergency sync, all the super blocks 265e8d4bfe3SChengguang Xu * will be iterated, including upper_sb, so no need to do anything. 266e8d4bfe3SChengguang Xu * 267e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call 268e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being 269e8d4bfe3SChengguang Xu * called with wait == 1. 270e8d4bfe3SChengguang Xu */ 271e8d4bfe3SChengguang Xu if (!wait) 272e593b2bfSAmir Goldstein return 0; 273e593b2bfSAmir Goldstein 274e8d4bfe3SChengguang Xu upper_sb = ofs->upper_mnt->mnt_sb; 275e8d4bfe3SChengguang Xu 276e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 277e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb); 278e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 279e8d4bfe3SChengguang Xu 280e593b2bfSAmir Goldstein return ret; 281e593b2bfSAmir Goldstein } 282e593b2bfSAmir Goldstein 283cc259639SAndy Whitcroft /** 284cc259639SAndy Whitcroft * ovl_statfs 285cc259639SAndy Whitcroft * @sb: The overlayfs super block 286cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 287cc259639SAndy Whitcroft * 288cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 2894ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 290cc259639SAndy Whitcroft */ 291cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 292cc259639SAndy Whitcroft { 293cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 294cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 295cc259639SAndy Whitcroft struct path path; 296cc259639SAndy Whitcroft int err; 297cc259639SAndy Whitcroft 2984ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 299cc259639SAndy Whitcroft 300cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 301cc259639SAndy Whitcroft if (!err) { 3026b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 303cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 304cc259639SAndy Whitcroft } 305cc259639SAndy Whitcroft 306cc259639SAndy Whitcroft return err; 307cc259639SAndy Whitcroft } 308cc259639SAndy Whitcroft 30902bcd157SAmir Goldstein /* Will this overlay be forced to mount/remount ro? */ 310ad204488SMiklos Szeredi static bool ovl_force_readonly(struct ovl_fs *ofs) 31102bcd157SAmir Goldstein { 312ad204488SMiklos Szeredi return (!ofs->upper_mnt || !ofs->workdir); 31302bcd157SAmir Goldstein } 31402bcd157SAmir Goldstein 315438c84c2SMiklos Szeredi static const char *ovl_redirect_mode_def(void) 316438c84c2SMiklos Szeredi { 317438c84c2SMiklos Szeredi return ovl_redirect_dir_def ? "on" : "off"; 318438c84c2SMiklos Szeredi } 319438c84c2SMiklos Szeredi 320795939a9SAmir Goldstein enum { 321795939a9SAmir Goldstein OVL_XINO_OFF, 322795939a9SAmir Goldstein OVL_XINO_AUTO, 323795939a9SAmir Goldstein OVL_XINO_ON, 324795939a9SAmir Goldstein }; 325795939a9SAmir Goldstein 326795939a9SAmir Goldstein static const char * const ovl_xino_str[] = { 327795939a9SAmir Goldstein "off", 328795939a9SAmir Goldstein "auto", 329795939a9SAmir Goldstein "on", 330795939a9SAmir Goldstein }; 331795939a9SAmir Goldstein 332795939a9SAmir Goldstein static inline int ovl_xino_def(void) 333795939a9SAmir Goldstein { 334795939a9SAmir Goldstein return ovl_xino_auto_def ? OVL_XINO_AUTO : OVL_XINO_OFF; 335795939a9SAmir Goldstein } 336795939a9SAmir Goldstein 337f45827e8SErez Zadok /** 338f45827e8SErez Zadok * ovl_show_options 339f45827e8SErez Zadok * 340f45827e8SErez Zadok * Prints the mount options for a given superblock. 341f45827e8SErez Zadok * Returns zero; does not fail. 342f45827e8SErez Zadok */ 343f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 344f45827e8SErez Zadok { 345f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 346ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 347f45827e8SErez Zadok 348ad204488SMiklos Szeredi seq_show_option(m, "lowerdir", ofs->config.lowerdir); 349ad204488SMiklos Szeredi if (ofs->config.upperdir) { 350ad204488SMiklos Szeredi seq_show_option(m, "upperdir", ofs->config.upperdir); 351ad204488SMiklos Szeredi seq_show_option(m, "workdir", ofs->config.workdir); 35253a08cb9SMiklos Szeredi } 353ad204488SMiklos Szeredi if (ofs->config.default_permissions) 3548d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 355438c84c2SMiklos Szeredi if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0) 356438c84c2SMiklos Szeredi seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode); 357ad204488SMiklos Szeredi if (ofs->config.index != ovl_index_def) 358438c84c2SMiklos Szeredi seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 359f168f109SAmir Goldstein if (ofs->config.nfs_export != ovl_nfs_export_def) 360f168f109SAmir Goldstein seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ? 361f168f109SAmir Goldstein "on" : "off"); 3620f831ec8SAmir Goldstein if (ofs->config.xino != ovl_xino_def() && !ovl_same_fs(sb)) 363795939a9SAmir Goldstein seq_printf(m, ",xino=%s", ovl_xino_str[ofs->config.xino]); 364d5791044SVivek Goyal if (ofs->config.metacopy != ovl_metacopy_def) 365d5791044SVivek Goyal seq_printf(m, ",metacopy=%s", 366d5791044SVivek Goyal ofs->config.metacopy ? "on" : "off"); 367f45827e8SErez Zadok return 0; 368f45827e8SErez Zadok } 369f45827e8SErez Zadok 3703cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 3713cdf6fe9SSeunghun Lee { 372ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 3733cdf6fe9SSeunghun Lee 3741751e8a6SLinus Torvalds if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 3753cdf6fe9SSeunghun Lee return -EROFS; 3763cdf6fe9SSeunghun Lee 3773cdf6fe9SSeunghun Lee return 0; 3783cdf6fe9SSeunghun Lee } 3793cdf6fe9SSeunghun Lee 380e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 38113cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 3820b269dedSAl Viro .free_inode = ovl_free_inode, 38313cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 38413cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 385e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 386e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 387cc259639SAndy Whitcroft .statfs = ovl_statfs, 388f45827e8SErez Zadok .show_options = ovl_show_options, 3893cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 390e9be9d5eSMiklos Szeredi }; 391e9be9d5eSMiklos Szeredi 392e9be9d5eSMiklos Szeredi enum { 393e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 394e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 395e9be9d5eSMiklos Szeredi OPT_WORKDIR, 3968d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 397438c84c2SMiklos Szeredi OPT_REDIRECT_DIR, 39802bcd157SAmir Goldstein OPT_INDEX_ON, 39902bcd157SAmir Goldstein OPT_INDEX_OFF, 400f168f109SAmir Goldstein OPT_NFS_EXPORT_ON, 401f168f109SAmir Goldstein OPT_NFS_EXPORT_OFF, 402795939a9SAmir Goldstein OPT_XINO_ON, 403795939a9SAmir Goldstein OPT_XINO_OFF, 404795939a9SAmir Goldstein OPT_XINO_AUTO, 405d5791044SVivek Goyal OPT_METACOPY_ON, 406d5791044SVivek Goyal OPT_METACOPY_OFF, 407e9be9d5eSMiklos Szeredi OPT_ERR, 408e9be9d5eSMiklos Szeredi }; 409e9be9d5eSMiklos Szeredi 410e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 411e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 412e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 413e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 4148d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 415438c84c2SMiklos Szeredi {OPT_REDIRECT_DIR, "redirect_dir=%s"}, 41602bcd157SAmir Goldstein {OPT_INDEX_ON, "index=on"}, 41702bcd157SAmir Goldstein {OPT_INDEX_OFF, "index=off"}, 418f168f109SAmir Goldstein {OPT_NFS_EXPORT_ON, "nfs_export=on"}, 419f168f109SAmir Goldstein {OPT_NFS_EXPORT_OFF, "nfs_export=off"}, 420795939a9SAmir Goldstein {OPT_XINO_ON, "xino=on"}, 421795939a9SAmir Goldstein {OPT_XINO_OFF, "xino=off"}, 422795939a9SAmir Goldstein {OPT_XINO_AUTO, "xino=auto"}, 423d5791044SVivek Goyal {OPT_METACOPY_ON, "metacopy=on"}, 424d5791044SVivek Goyal {OPT_METACOPY_OFF, "metacopy=off"}, 425e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 426e9be9d5eSMiklos Szeredi }; 427e9be9d5eSMiklos Szeredi 42891c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 42991c77947SMiklos Szeredi { 43091c77947SMiklos Szeredi char *sbegin = *s; 43191c77947SMiklos Szeredi char *p; 43291c77947SMiklos Szeredi 43391c77947SMiklos Szeredi if (sbegin == NULL) 43491c77947SMiklos Szeredi return NULL; 43591c77947SMiklos Szeredi 43691c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 43791c77947SMiklos Szeredi if (*p == '\\') { 43891c77947SMiklos Szeredi p++; 43991c77947SMiklos Szeredi if (!*p) 44091c77947SMiklos Szeredi break; 44191c77947SMiklos Szeredi } else if (*p == ',') { 44291c77947SMiklos Szeredi *p = '\0'; 44391c77947SMiklos Szeredi *s = p + 1; 44491c77947SMiklos Szeredi return sbegin; 44591c77947SMiklos Szeredi } 44691c77947SMiklos Szeredi } 44791c77947SMiklos Szeredi *s = NULL; 44891c77947SMiklos Szeredi return sbegin; 44991c77947SMiklos Szeredi } 45091c77947SMiklos Szeredi 451438c84c2SMiklos Szeredi static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode) 452438c84c2SMiklos Szeredi { 453438c84c2SMiklos Szeredi if (strcmp(mode, "on") == 0) { 454438c84c2SMiklos Szeredi config->redirect_dir = true; 455438c84c2SMiklos Szeredi /* 456438c84c2SMiklos Szeredi * Does not make sense to have redirect creation without 457438c84c2SMiklos Szeredi * redirect following. 458438c84c2SMiklos Szeredi */ 459438c84c2SMiklos Szeredi config->redirect_follow = true; 460438c84c2SMiklos Szeredi } else if (strcmp(mode, "follow") == 0) { 461438c84c2SMiklos Szeredi config->redirect_follow = true; 462438c84c2SMiklos Szeredi } else if (strcmp(mode, "off") == 0) { 463438c84c2SMiklos Szeredi if (ovl_redirect_always_follow) 464438c84c2SMiklos Szeredi config->redirect_follow = true; 465438c84c2SMiklos Szeredi } else if (strcmp(mode, "nofollow") != 0) { 4661bd0a3aeSlijiazi pr_err("bad mount option \"redirect_dir=%s\"\n", 467438c84c2SMiklos Szeredi mode); 468438c84c2SMiklos Szeredi return -EINVAL; 469438c84c2SMiklos Szeredi } 470438c84c2SMiklos Szeredi 471438c84c2SMiklos Szeredi return 0; 472438c84c2SMiklos Szeredi } 473438c84c2SMiklos Szeredi 474e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 475e9be9d5eSMiklos Szeredi { 476e9be9d5eSMiklos Szeredi char *p; 477d5791044SVivek Goyal int err; 478d47748e5SMiklos Szeredi bool metacopy_opt = false, redirect_opt = false; 479e9be9d5eSMiklos Szeredi 480438c84c2SMiklos Szeredi config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL); 481438c84c2SMiklos Szeredi if (!config->redirect_mode) 482438c84c2SMiklos Szeredi return -ENOMEM; 483438c84c2SMiklos Szeredi 48491c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 485e9be9d5eSMiklos Szeredi int token; 486e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 487e9be9d5eSMiklos Szeredi 488e9be9d5eSMiklos Szeredi if (!*p) 489e9be9d5eSMiklos Szeredi continue; 490e9be9d5eSMiklos Szeredi 491e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 492e9be9d5eSMiklos Szeredi switch (token) { 493e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 494e9be9d5eSMiklos Szeredi kfree(config->upperdir); 495e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 496e9be9d5eSMiklos Szeredi if (!config->upperdir) 497e9be9d5eSMiklos Szeredi return -ENOMEM; 498e9be9d5eSMiklos Szeredi break; 499e9be9d5eSMiklos Szeredi 500e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 501e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 502e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 503e9be9d5eSMiklos Szeredi if (!config->lowerdir) 504e9be9d5eSMiklos Szeredi return -ENOMEM; 505e9be9d5eSMiklos Szeredi break; 506e9be9d5eSMiklos Szeredi 507e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 508e9be9d5eSMiklos Szeredi kfree(config->workdir); 509e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 510e9be9d5eSMiklos Szeredi if (!config->workdir) 511e9be9d5eSMiklos Szeredi return -ENOMEM; 512e9be9d5eSMiklos Szeredi break; 513e9be9d5eSMiklos Szeredi 5148d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 5158d3095f4SMiklos Szeredi config->default_permissions = true; 5168d3095f4SMiklos Szeredi break; 5178d3095f4SMiklos Szeredi 518438c84c2SMiklos Szeredi case OPT_REDIRECT_DIR: 519438c84c2SMiklos Szeredi kfree(config->redirect_mode); 520438c84c2SMiklos Szeredi config->redirect_mode = match_strdup(&args[0]); 521438c84c2SMiklos Szeredi if (!config->redirect_mode) 522438c84c2SMiklos Szeredi return -ENOMEM; 523d47748e5SMiklos Szeredi redirect_opt = true; 524a6c60655SMiklos Szeredi break; 525a6c60655SMiklos Szeredi 52602bcd157SAmir Goldstein case OPT_INDEX_ON: 52702bcd157SAmir Goldstein config->index = true; 52802bcd157SAmir Goldstein break; 52902bcd157SAmir Goldstein 53002bcd157SAmir Goldstein case OPT_INDEX_OFF: 53102bcd157SAmir Goldstein config->index = false; 53202bcd157SAmir Goldstein break; 53302bcd157SAmir Goldstein 534f168f109SAmir Goldstein case OPT_NFS_EXPORT_ON: 535f168f109SAmir Goldstein config->nfs_export = true; 536f168f109SAmir Goldstein break; 537f168f109SAmir Goldstein 538f168f109SAmir Goldstein case OPT_NFS_EXPORT_OFF: 539f168f109SAmir Goldstein config->nfs_export = false; 540f168f109SAmir Goldstein break; 541f168f109SAmir Goldstein 542795939a9SAmir Goldstein case OPT_XINO_ON: 543795939a9SAmir Goldstein config->xino = OVL_XINO_ON; 544795939a9SAmir Goldstein break; 545795939a9SAmir Goldstein 546795939a9SAmir Goldstein case OPT_XINO_OFF: 547795939a9SAmir Goldstein config->xino = OVL_XINO_OFF; 548795939a9SAmir Goldstein break; 549795939a9SAmir Goldstein 550795939a9SAmir Goldstein case OPT_XINO_AUTO: 551795939a9SAmir Goldstein config->xino = OVL_XINO_AUTO; 552795939a9SAmir Goldstein break; 553795939a9SAmir Goldstein 554d5791044SVivek Goyal case OPT_METACOPY_ON: 555d5791044SVivek Goyal config->metacopy = true; 556d47748e5SMiklos Szeredi metacopy_opt = true; 557d5791044SVivek Goyal break; 558d5791044SVivek Goyal 559d5791044SVivek Goyal case OPT_METACOPY_OFF: 560d5791044SVivek Goyal config->metacopy = false; 561d5791044SVivek Goyal break; 562d5791044SVivek Goyal 563e9be9d5eSMiklos Szeredi default: 5641bd0a3aeSlijiazi pr_err("unrecognized mount option \"%s\" or missing value\n", 5651bd0a3aeSlijiazi p); 566e9be9d5eSMiklos Szeredi return -EINVAL; 567e9be9d5eSMiklos Szeredi } 568e9be9d5eSMiklos Szeredi } 56971cbad7eShujianyang 57071cbad7eShujianyang /* Workdir is useless in non-upper mount */ 57171cbad7eShujianyang if (!config->upperdir && config->workdir) { 5721bd0a3aeSlijiazi pr_info("option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 57371cbad7eShujianyang config->workdir); 57471cbad7eShujianyang kfree(config->workdir); 57571cbad7eShujianyang config->workdir = NULL; 57671cbad7eShujianyang } 57771cbad7eShujianyang 578d5791044SVivek Goyal err = ovl_parse_redirect_mode(config, config->redirect_mode); 579d5791044SVivek Goyal if (err) 580d5791044SVivek Goyal return err; 581d5791044SVivek Goyal 582d47748e5SMiklos Szeredi /* 583d47748e5SMiklos Szeredi * This is to make the logic below simpler. It doesn't make any other 584d47748e5SMiklos Szeredi * difference, since config->redirect_dir is only used for upper. 585d47748e5SMiklos Szeredi */ 586d47748e5SMiklos Szeredi if (!config->upperdir && config->redirect_follow) 587d47748e5SMiklos Szeredi config->redirect_dir = true; 588d47748e5SMiklos Szeredi 589d47748e5SMiklos Szeredi /* Resolve metacopy -> redirect_dir dependency */ 590d47748e5SMiklos Szeredi if (config->metacopy && !config->redirect_dir) { 591d47748e5SMiklos Szeredi if (metacopy_opt && redirect_opt) { 5921bd0a3aeSlijiazi pr_err("conflicting options: metacopy=on,redirect_dir=%s\n", 593d47748e5SMiklos Szeredi config->redirect_mode); 594d47748e5SMiklos Szeredi return -EINVAL; 595d47748e5SMiklos Szeredi } 596d47748e5SMiklos Szeredi if (redirect_opt) { 597d47748e5SMiklos Szeredi /* 598d47748e5SMiklos Szeredi * There was an explicit redirect_dir=... that resulted 599d47748e5SMiklos Szeredi * in this conflict. 600d47748e5SMiklos Szeredi */ 6011bd0a3aeSlijiazi pr_info("disabling metacopy due to redirect_dir=%s\n", 602d47748e5SMiklos Szeredi config->redirect_mode); 603d5791044SVivek Goyal config->metacopy = false; 604d47748e5SMiklos Szeredi } else { 605d47748e5SMiklos Szeredi /* Automatically enable redirect otherwise. */ 606d47748e5SMiklos Szeredi config->redirect_follow = config->redirect_dir = true; 607d47748e5SMiklos Szeredi } 608d5791044SVivek Goyal } 609d5791044SVivek Goyal 610d5791044SVivek Goyal return 0; 611e9be9d5eSMiklos Szeredi } 612e9be9d5eSMiklos Szeredi 613e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 61402bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 615e9be9d5eSMiklos Szeredi 616ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 6176b8aa129SAmir Goldstein const char *name, bool persist) 618e9be9d5eSMiklos Szeredi { 619ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 620ad204488SMiklos Szeredi struct vfsmount *mnt = ofs->upper_mnt; 621e9be9d5eSMiklos Szeredi struct dentry *work; 622e9be9d5eSMiklos Szeredi int err; 623e9be9d5eSMiklos Szeredi bool retried = false; 6246b8aa129SAmir Goldstein bool locked = false; 625e9be9d5eSMiklos Szeredi 6265955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 6276b8aa129SAmir Goldstein locked = true; 6286b8aa129SAmir Goldstein 629e9be9d5eSMiklos Szeredi retry: 630ad204488SMiklos Szeredi work = lookup_one_len(name, ofs->workbasedir, strlen(name)); 631e9be9d5eSMiklos Szeredi 632e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 633c11b9fddSMiklos Szeredi struct iattr attr = { 634c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 63532a3d848SAl Viro .ia_mode = S_IFDIR | 0, 636c11b9fddSMiklos Szeredi }; 637e9be9d5eSMiklos Szeredi 638e9be9d5eSMiklos Szeredi if (work->d_inode) { 639e9be9d5eSMiklos Szeredi err = -EEXIST; 640e9be9d5eSMiklos Szeredi if (retried) 641e9be9d5eSMiklos Szeredi goto out_dput; 642e9be9d5eSMiklos Szeredi 6436b8aa129SAmir Goldstein if (persist) 6446b8aa129SAmir Goldstein goto out_unlock; 6456b8aa129SAmir Goldstein 646e9be9d5eSMiklos Szeredi retried = true; 647eea2fb48SMiklos Szeredi ovl_workdir_cleanup(dir, mnt, work, 0); 648e9be9d5eSMiklos Szeredi dput(work); 649e9be9d5eSMiklos Szeredi goto retry; 650e9be9d5eSMiklos Szeredi } 651e9be9d5eSMiklos Szeredi 65295a1c815SMiklos Szeredi work = ovl_create_real(dir, work, OVL_CATTR(attr.ia_mode)); 65395a1c815SMiklos Szeredi err = PTR_ERR(work); 65495a1c815SMiklos Szeredi if (IS_ERR(work)) 65595a1c815SMiklos Szeredi goto out_err; 656c11b9fddSMiklos Szeredi 657cb348edbSMiklos Szeredi /* 658cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 659cb348edbSMiklos Szeredi * 660cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 661cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 662cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 663cb348edbSMiklos Szeredi * 664cb348edbSMiklos Szeredi * There are various other error values that could effectively 665cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 666cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 667cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 668cb348edbSMiklos Szeredi * for the above two errors is sufficient. 669cb348edbSMiklos Szeredi */ 670c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 671e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 672c11b9fddSMiklos Szeredi goto out_dput; 673c11b9fddSMiklos Szeredi 674c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 675e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 676c11b9fddSMiklos Szeredi goto out_dput; 677c11b9fddSMiklos Szeredi 678c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 679c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 680c11b9fddSMiklos Szeredi err = notify_change(work, &attr, NULL); 681c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 682c11b9fddSMiklos Szeredi if (err) 683c11b9fddSMiklos Szeredi goto out_dput; 6846b8aa129SAmir Goldstein } else { 6856b8aa129SAmir Goldstein err = PTR_ERR(work); 6866b8aa129SAmir Goldstein goto out_err; 687e9be9d5eSMiklos Szeredi } 688e9be9d5eSMiklos Szeredi out_unlock: 6896b8aa129SAmir Goldstein if (locked) 6906b8aa129SAmir Goldstein inode_unlock(dir); 691e9be9d5eSMiklos Szeredi 692e9be9d5eSMiklos Szeredi return work; 693e9be9d5eSMiklos Szeredi 694e9be9d5eSMiklos Szeredi out_dput: 695e9be9d5eSMiklos Szeredi dput(work); 6966b8aa129SAmir Goldstein out_err: 6971bd0a3aeSlijiazi pr_warn("failed to create directory %s/%s (errno: %i); mounting read-only\n", 698ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 6996b8aa129SAmir Goldstein work = NULL; 700e9be9d5eSMiklos Szeredi goto out_unlock; 701e9be9d5eSMiklos Szeredi } 702e9be9d5eSMiklos Szeredi 70391c77947SMiklos Szeredi static void ovl_unescape(char *s) 70491c77947SMiklos Szeredi { 70591c77947SMiklos Szeredi char *d = s; 70691c77947SMiklos Szeredi 70791c77947SMiklos Szeredi for (;; s++, d++) { 70891c77947SMiklos Szeredi if (*s == '\\') 70991c77947SMiklos Szeredi s++; 71091c77947SMiklos Szeredi *d = *s; 71191c77947SMiklos Szeredi if (!*s) 71291c77947SMiklos Szeredi break; 71391c77947SMiklos Szeredi } 71491c77947SMiklos Szeredi } 71591c77947SMiklos Szeredi 716ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 717ab508822SMiklos Szeredi { 718a78d9f0dSMiklos Szeredi int err = -EINVAL; 719ab508822SMiklos Szeredi 720a78d9f0dSMiklos Szeredi if (!*name) { 7211bd0a3aeSlijiazi pr_err("empty lowerdir\n"); 722a78d9f0dSMiklos Szeredi goto out; 723a78d9f0dSMiklos Szeredi } 724ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 725ab508822SMiklos Szeredi if (err) { 7261bd0a3aeSlijiazi pr_err("failed to resolve '%s': %i\n", name, err); 727ab508822SMiklos Szeredi goto out; 728ab508822SMiklos Szeredi } 729ab508822SMiklos Szeredi err = -EINVAL; 7307c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 7311bd0a3aeSlijiazi pr_err("filesystem on '%s' not supported\n", name); 732ab508822SMiklos Szeredi goto out_put; 733ab508822SMiklos Szeredi } 7342b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 7351bd0a3aeSlijiazi pr_err("'%s' not a directory\n", name); 736ab508822SMiklos Szeredi goto out_put; 737ab508822SMiklos Szeredi } 738ab508822SMiklos Szeredi return 0; 739ab508822SMiklos Szeredi 740ab508822SMiklos Szeredi out_put: 7418aafcb59SMiklos Szeredi path_put_init(path); 742ab508822SMiklos Szeredi out: 743ab508822SMiklos Szeredi return err; 744ab508822SMiklos Szeredi } 745ab508822SMiklos Szeredi 746ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 747ab508822SMiklos Szeredi { 748ab508822SMiklos Szeredi int err = -ENOMEM; 749ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 750ab508822SMiklos Szeredi 751ab508822SMiklos Szeredi if (tmp) { 752ab508822SMiklos Szeredi ovl_unescape(tmp); 753ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 7547c03b5d4SMiklos Szeredi 755bccece1eSMiklos Szeredi if (!err && path->dentry->d_flags & DCACHE_OP_REAL) { 7561bd0a3aeSlijiazi pr_err("filesystem on '%s' not supported as upperdir\n", 7577c03b5d4SMiklos Szeredi tmp); 7588aafcb59SMiklos Szeredi path_put_init(path); 7597c03b5d4SMiklos Szeredi err = -EINVAL; 7607c03b5d4SMiklos Szeredi } 761ab508822SMiklos Szeredi kfree(tmp); 762ab508822SMiklos Szeredi } 763ab508822SMiklos Szeredi return err; 764ab508822SMiklos Szeredi } 765ab508822SMiklos Szeredi 7666b2d5fe4SMiklos Szeredi static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 7676b2d5fe4SMiklos Szeredi const char *name) 7686b2d5fe4SMiklos Szeredi { 7696b2d5fe4SMiklos Szeredi struct kstatfs statfs; 7706b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 7716b2d5fe4SMiklos Szeredi 7726b2d5fe4SMiklos Szeredi if (err) 7731bd0a3aeSlijiazi pr_err("statfs failed on '%s'\n", name); 7746b2d5fe4SMiklos Szeredi else 7756b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 7766b2d5fe4SMiklos Szeredi 7776b2d5fe4SMiklos Szeredi return err; 7786b2d5fe4SMiklos Szeredi } 7796b2d5fe4SMiklos Szeredi 7806b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 781f4288844SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth) 782ab508822SMiklos Szeredi { 783e487d889SAmir Goldstein int fh_type; 784ab508822SMiklos Szeredi int err; 785ab508822SMiklos Szeredi 786a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 787ab508822SMiklos Szeredi if (err) 788ab508822SMiklos Szeredi goto out; 789ab508822SMiklos Szeredi 7906b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 7916b2d5fe4SMiklos Szeredi if (err) 792ab508822SMiklos Szeredi goto out_put; 7936b2d5fe4SMiklos Szeredi 794ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 795ab508822SMiklos Szeredi 79602bcd157SAmir Goldstein /* 797f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode 798f168f109SAmir Goldstein * file handles, so they require that all layers support them. 79902bcd157SAmir Goldstein */ 800e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(path->dentry->d_sb); 801f168f109SAmir Goldstein if ((ofs->config.nfs_export || 802e487d889SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 80302bcd157SAmir Goldstein ofs->config.index = false; 804f168f109SAmir Goldstein ofs->config.nfs_export = false; 8051bd0a3aeSlijiazi pr_warn("fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 806f168f109SAmir Goldstein name); 80702bcd157SAmir Goldstein } 80802bcd157SAmir Goldstein 809e487d889SAmir Goldstein /* Check if lower fs has 32bit inode numbers */ 810e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 8110f831ec8SAmir Goldstein ofs->xino_mode = -1; 812e487d889SAmir Goldstein 813ab508822SMiklos Szeredi return 0; 814ab508822SMiklos Szeredi 815ab508822SMiklos Szeredi out_put: 8168aafcb59SMiklos Szeredi path_put_init(path); 817ab508822SMiklos Szeredi out: 818ab508822SMiklos Szeredi return err; 819ab508822SMiklos Szeredi } 820ab508822SMiklos Szeredi 821e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 822e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 823e9be9d5eSMiklos Szeredi { 824e9be9d5eSMiklos Szeredi bool ok = false; 825e9be9d5eSMiklos Szeredi 826e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 827e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 828e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 829e9be9d5eSMiklos Szeredi } 830e9be9d5eSMiklos Szeredi return ok; 831e9be9d5eSMiklos Szeredi } 832e9be9d5eSMiklos Szeredi 833a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 834a78d9f0dSMiklos Szeredi { 835a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 836a78d9f0dSMiklos Szeredi char *s, *d; 837a78d9f0dSMiklos Szeredi 838a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 839a78d9f0dSMiklos Szeredi if (*s == '\\') { 840a78d9f0dSMiklos Szeredi s++; 841a78d9f0dSMiklos Szeredi } else if (*s == ':') { 842a78d9f0dSMiklos Szeredi *d = '\0'; 843a78d9f0dSMiklos Szeredi ctr++; 844a78d9f0dSMiklos Szeredi continue; 845a78d9f0dSMiklos Szeredi } 846a78d9f0dSMiklos Szeredi *d = *s; 847a78d9f0dSMiklos Szeredi if (!*s) 848a78d9f0dSMiklos Szeredi break; 849a78d9f0dSMiklos Szeredi } 850a78d9f0dSMiklos Szeredi return ctr; 851a78d9f0dSMiklos Szeredi } 852a78d9f0dSMiklos Szeredi 8530c97be22SAndreas Gruenbacher static int __maybe_unused 8540eb45fc3SAndreas Gruenbacher ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 8550eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8560eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 8570eb45fc3SAndreas Gruenbacher { 8581d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 8590eb45fc3SAndreas Gruenbacher } 8600eb45fc3SAndreas Gruenbacher 8610eb45fc3SAndreas Gruenbacher static int __maybe_unused 8620c97be22SAndreas Gruenbacher ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 863d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 864d837a49bSMiklos Szeredi const char *name, const void *value, 865d837a49bSMiklos Szeredi size_t size, int flags) 866d837a49bSMiklos Szeredi { 867d837a49bSMiklos Szeredi struct dentry *workdir = ovl_workdir(dentry); 86809d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 869d837a49bSMiklos Szeredi struct posix_acl *acl = NULL; 870d837a49bSMiklos Szeredi int err; 871d837a49bSMiklos Szeredi 872d837a49bSMiklos Szeredi /* Check that everything is OK before copy-up */ 873d837a49bSMiklos Szeredi if (value) { 874d837a49bSMiklos Szeredi acl = posix_acl_from_xattr(&init_user_ns, value, size); 875d837a49bSMiklos Szeredi if (IS_ERR(acl)) 876d837a49bSMiklos Szeredi return PTR_ERR(acl); 877d837a49bSMiklos Szeredi } 878d837a49bSMiklos Szeredi err = -EOPNOTSUPP; 879d837a49bSMiklos Szeredi if (!IS_POSIXACL(d_inode(workdir))) 880d837a49bSMiklos Szeredi goto out_acl_release; 881d837a49bSMiklos Szeredi if (!realinode->i_op->set_acl) 882d837a49bSMiklos Szeredi goto out_acl_release; 883d837a49bSMiklos Szeredi if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 884d837a49bSMiklos Szeredi err = acl ? -EACCES : 0; 885d837a49bSMiklos Szeredi goto out_acl_release; 886d837a49bSMiklos Szeredi } 887d837a49bSMiklos Szeredi err = -EPERM; 888d837a49bSMiklos Szeredi if (!inode_owner_or_capable(inode)) 889d837a49bSMiklos Szeredi goto out_acl_release; 890d837a49bSMiklos Szeredi 891d837a49bSMiklos Szeredi posix_acl_release(acl); 892d837a49bSMiklos Szeredi 893fd3220d3SMiklos Szeredi /* 894fd3220d3SMiklos Szeredi * Check if sgid bit needs to be cleared (actual setacl operation will 895fd3220d3SMiklos Szeredi * be done with mounter's capabilities and so that won't do it for us). 896fd3220d3SMiklos Szeredi */ 897fd3220d3SMiklos Szeredi if (unlikely(inode->i_mode & S_ISGID) && 898fd3220d3SMiklos Szeredi handler->flags == ACL_TYPE_ACCESS && 899fd3220d3SMiklos Szeredi !in_group_p(inode->i_gid) && 900fd3220d3SMiklos Szeredi !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 901fd3220d3SMiklos Szeredi struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 902fd3220d3SMiklos Szeredi 903fd3220d3SMiklos Szeredi err = ovl_setattr(dentry, &iattr); 904fd3220d3SMiklos Szeredi if (err) 905fd3220d3SMiklos Szeredi return err; 906fd3220d3SMiklos Szeredi } 907fd3220d3SMiklos Szeredi 9081d88f183SMiklos Szeredi err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 909ce31513aSMiklos Szeredi if (!err) 91009d8b586SMiklos Szeredi ovl_copyattr(ovl_inode_real(inode), inode); 911ce31513aSMiklos Szeredi 912ce31513aSMiklos Szeredi return err; 913d837a49bSMiklos Szeredi 914d837a49bSMiklos Szeredi out_acl_release: 915d837a49bSMiklos Szeredi posix_acl_release(acl); 916d837a49bSMiklos Szeredi return err; 917d837a49bSMiklos Szeredi } 918d837a49bSMiklos Szeredi 9190eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 9200eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9210eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 9220eb45fc3SAndreas Gruenbacher { 92348fab5d7SAmir Goldstein return -EOPNOTSUPP; 9240eb45fc3SAndreas Gruenbacher } 9250eb45fc3SAndreas Gruenbacher 926d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 927d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 928d837a49bSMiklos Szeredi const char *name, const void *value, 929d837a49bSMiklos Szeredi size_t size, int flags) 930d837a49bSMiklos Szeredi { 93148fab5d7SAmir Goldstein return -EOPNOTSUPP; 932d837a49bSMiklos Szeredi } 933d837a49bSMiklos Szeredi 9340eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 9350eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9360eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 9370eb45fc3SAndreas Gruenbacher { 9381d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 9390eb45fc3SAndreas Gruenbacher } 9400eb45fc3SAndreas Gruenbacher 9410e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 9420e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9430e585cccSAndreas Gruenbacher const char *name, const void *value, 9440e585cccSAndreas Gruenbacher size_t size, int flags) 9450e585cccSAndreas Gruenbacher { 9461d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 9470e585cccSAndreas Gruenbacher } 9480e585cccSAndreas Gruenbacher 9490c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 9500c97be22SAndreas Gruenbacher ovl_posix_acl_access_xattr_handler = { 951d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_ACCESS, 952d837a49bSMiklos Szeredi .flags = ACL_TYPE_ACCESS, 9530eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 954d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 955d837a49bSMiklos Szeredi }; 956d837a49bSMiklos Szeredi 9570c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 9580c97be22SAndreas Gruenbacher ovl_posix_acl_default_xattr_handler = { 959d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_DEFAULT, 960d837a49bSMiklos Szeredi .flags = ACL_TYPE_DEFAULT, 9610eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 962d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 963d837a49bSMiklos Szeredi }; 964d837a49bSMiklos Szeredi 965d837a49bSMiklos Szeredi static const struct xattr_handler ovl_own_xattr_handler = { 966d837a49bSMiklos Szeredi .prefix = OVL_XATTR_PREFIX, 9670eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 968d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 969d837a49bSMiklos Szeredi }; 970d837a49bSMiklos Szeredi 971d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 972d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 9730eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 974d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 975d837a49bSMiklos Szeredi }; 976d837a49bSMiklos Szeredi 977d837a49bSMiklos Szeredi static const struct xattr_handler *ovl_xattr_handlers[] = { 9780c97be22SAndreas Gruenbacher #ifdef CONFIG_FS_POSIX_ACL 979d837a49bSMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 980d837a49bSMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 9810c97be22SAndreas Gruenbacher #endif 982d837a49bSMiklos Szeredi &ovl_own_xattr_handler, 983d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 984d837a49bSMiklos Szeredi NULL 985d837a49bSMiklos Szeredi }; 986d837a49bSMiklos Szeredi 987146d62e5SAmir Goldstein static int ovl_setup_trap(struct super_block *sb, struct dentry *dir, 988146d62e5SAmir Goldstein struct inode **ptrap, const char *name) 989146d62e5SAmir Goldstein { 990146d62e5SAmir Goldstein struct inode *trap; 991146d62e5SAmir Goldstein int err; 992146d62e5SAmir Goldstein 993146d62e5SAmir Goldstein trap = ovl_get_trap_inode(sb, dir); 9941dac6f5bSArnd Bergmann err = PTR_ERR_OR_ZERO(trap); 9951dac6f5bSArnd Bergmann if (err) { 996146d62e5SAmir Goldstein if (err == -ELOOP) 9971bd0a3aeSlijiazi pr_err("conflicting %s path\n", name); 998146d62e5SAmir Goldstein return err; 999146d62e5SAmir Goldstein } 1000146d62e5SAmir Goldstein 1001146d62e5SAmir Goldstein *ptrap = trap; 1002146d62e5SAmir Goldstein return 0; 1003146d62e5SAmir Goldstein } 1004146d62e5SAmir Goldstein 10050be0bfd2SAmir Goldstein /* 10060be0bfd2SAmir Goldstein * Determine how we treat concurrent use of upperdir/workdir based on the 10070be0bfd2SAmir Goldstein * index feature. This is papering over mount leaks of container runtimes, 10080be0bfd2SAmir Goldstein * for example, an old overlay mount is leaked and now its upperdir is 10090be0bfd2SAmir Goldstein * attempted to be used as a lower layer in a new overlay mount. 10100be0bfd2SAmir Goldstein */ 10110be0bfd2SAmir Goldstein static int ovl_report_in_use(struct ovl_fs *ofs, const char *name) 10120be0bfd2SAmir Goldstein { 10130be0bfd2SAmir Goldstein if (ofs->config.index) { 10141bd0a3aeSlijiazi pr_err("%s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n", 10150be0bfd2SAmir Goldstein name); 10160be0bfd2SAmir Goldstein return -EBUSY; 10170be0bfd2SAmir Goldstein } else { 10181bd0a3aeSlijiazi pr_warn("%s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n", 10190be0bfd2SAmir Goldstein name); 10200be0bfd2SAmir Goldstein return 0; 10210be0bfd2SAmir Goldstein } 10220be0bfd2SAmir Goldstein } 10230be0bfd2SAmir Goldstein 1024146d62e5SAmir Goldstein static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs, 1025146d62e5SAmir Goldstein struct path *upperpath) 10266ee8acf0SMiklos Szeredi { 10275064975eSMiklos Szeredi struct vfsmount *upper_mnt; 10286ee8acf0SMiklos Szeredi int err; 10296ee8acf0SMiklos Szeredi 1030ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.upperdir, upperpath); 10316ee8acf0SMiklos Szeredi if (err) 10326ee8acf0SMiklos Szeredi goto out; 10336ee8acf0SMiklos Szeredi 10346ee8acf0SMiklos Szeredi /* Upper fs should not be r/o */ 10356ee8acf0SMiklos Szeredi if (sb_rdonly(upperpath->mnt->mnt_sb)) { 10361bd0a3aeSlijiazi pr_err("upper fs is r/o, try multi-lower layers mount\n"); 10376ee8acf0SMiklos Szeredi err = -EINVAL; 10386ee8acf0SMiklos Szeredi goto out; 10396ee8acf0SMiklos Szeredi } 10406ee8acf0SMiklos Szeredi 1041ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 10426ee8acf0SMiklos Szeredi if (err) 10436ee8acf0SMiklos Szeredi goto out; 10446ee8acf0SMiklos Szeredi 1045146d62e5SAmir Goldstein err = ovl_setup_trap(sb, upperpath->dentry, &ofs->upperdir_trap, 1046146d62e5SAmir Goldstein "upperdir"); 1047146d62e5SAmir Goldstein if (err) 1048146d62e5SAmir Goldstein goto out; 1049146d62e5SAmir Goldstein 10505064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 10515064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 10525064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 10531bd0a3aeSlijiazi pr_err("failed to clone upperpath\n"); 10545064975eSMiklos Szeredi goto out; 10555064975eSMiklos Szeredi } 10565064975eSMiklos Szeredi 10575064975eSMiklos Szeredi /* Don't inherit atime flags */ 10585064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 1059ad204488SMiklos Szeredi ofs->upper_mnt = upper_mnt; 10608c25741aSMiklos Szeredi 10618c25741aSMiklos Szeredi if (ovl_inuse_trylock(ofs->upper_mnt->mnt_root)) { 10628c25741aSMiklos Szeredi ofs->upperdir_locked = true; 10638c25741aSMiklos Szeredi } else { 10640be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "upperdir"); 10650be0bfd2SAmir Goldstein if (err) 10660be0bfd2SAmir Goldstein goto out; 10678c25741aSMiklos Szeredi } 10688c25741aSMiklos Szeredi 10696ee8acf0SMiklos Szeredi err = 0; 10706ee8acf0SMiklos Szeredi out: 10716ee8acf0SMiklos Szeredi return err; 10726ee8acf0SMiklos Szeredi } 10736ee8acf0SMiklos Szeredi 1074cad218abSAmir Goldstein /* 1075cad218abSAmir Goldstein * Returns 1 if RENAME_WHITEOUT is supported, 0 if not supported and 1076cad218abSAmir Goldstein * negative values if error is encountered. 1077cad218abSAmir Goldstein */ 1078cad218abSAmir Goldstein static int ovl_check_rename_whiteout(struct dentry *workdir) 1079cad218abSAmir Goldstein { 1080cad218abSAmir Goldstein struct inode *dir = d_inode(workdir); 1081cad218abSAmir Goldstein struct dentry *temp; 1082cad218abSAmir Goldstein struct dentry *dest; 1083cad218abSAmir Goldstein struct dentry *whiteout; 1084cad218abSAmir Goldstein struct name_snapshot name; 1085cad218abSAmir Goldstein int err; 1086cad218abSAmir Goldstein 1087cad218abSAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 1088cad218abSAmir Goldstein 1089cad218abSAmir Goldstein temp = ovl_create_temp(workdir, OVL_CATTR(S_IFREG | 0)); 1090cad218abSAmir Goldstein err = PTR_ERR(temp); 1091cad218abSAmir Goldstein if (IS_ERR(temp)) 1092cad218abSAmir Goldstein goto out_unlock; 1093cad218abSAmir Goldstein 1094cad218abSAmir Goldstein dest = ovl_lookup_temp(workdir); 1095cad218abSAmir Goldstein err = PTR_ERR(dest); 1096cad218abSAmir Goldstein if (IS_ERR(dest)) { 1097cad218abSAmir Goldstein dput(temp); 1098cad218abSAmir Goldstein goto out_unlock; 1099cad218abSAmir Goldstein } 1100cad218abSAmir Goldstein 1101cad218abSAmir Goldstein /* Name is inline and stable - using snapshot as a copy helper */ 1102cad218abSAmir Goldstein take_dentry_name_snapshot(&name, temp); 1103cad218abSAmir Goldstein err = ovl_do_rename(dir, temp, dir, dest, RENAME_WHITEOUT); 1104cad218abSAmir Goldstein if (err) { 1105cad218abSAmir Goldstein if (err == -EINVAL) 1106cad218abSAmir Goldstein err = 0; 1107cad218abSAmir Goldstein goto cleanup_temp; 1108cad218abSAmir Goldstein } 1109cad218abSAmir Goldstein 1110cad218abSAmir Goldstein whiteout = lookup_one_len(name.name.name, workdir, name.name.len); 1111cad218abSAmir Goldstein err = PTR_ERR(whiteout); 1112cad218abSAmir Goldstein if (IS_ERR(whiteout)) 1113cad218abSAmir Goldstein goto cleanup_temp; 1114cad218abSAmir Goldstein 1115cad218abSAmir Goldstein err = ovl_is_whiteout(whiteout); 1116cad218abSAmir Goldstein 1117cad218abSAmir Goldstein /* Best effort cleanup of whiteout and temp file */ 1118cad218abSAmir Goldstein if (err) 1119cad218abSAmir Goldstein ovl_cleanup(dir, whiteout); 1120cad218abSAmir Goldstein dput(whiteout); 1121cad218abSAmir Goldstein 1122cad218abSAmir Goldstein cleanup_temp: 1123cad218abSAmir Goldstein ovl_cleanup(dir, temp); 1124cad218abSAmir Goldstein release_dentry_name_snapshot(&name); 1125cad218abSAmir Goldstein dput(temp); 1126cad218abSAmir Goldstein dput(dest); 1127cad218abSAmir Goldstein 1128cad218abSAmir Goldstein out_unlock: 1129cad218abSAmir Goldstein inode_unlock(dir); 1130cad218abSAmir Goldstein 1131cad218abSAmir Goldstein return err; 1132cad218abSAmir Goldstein } 1133cad218abSAmir Goldstein 1134146d62e5SAmir Goldstein static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs, 1135146d62e5SAmir Goldstein struct path *workpath) 11368ed61dc3SMiklos Szeredi { 11372ba9d57eSAmir Goldstein struct vfsmount *mnt = ofs->upper_mnt; 11388ed61dc3SMiklos Szeredi struct dentry *temp; 1139d80172c2SAmir Goldstein bool rename_whiteout; 1140d80172c2SAmir Goldstein bool d_type; 1141e487d889SAmir Goldstein int fh_type; 11428ed61dc3SMiklos Szeredi int err; 11438ed61dc3SMiklos Szeredi 11442ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 11452ba9d57eSAmir Goldstein if (err) 11462ba9d57eSAmir Goldstein return err; 11472ba9d57eSAmir Goldstein 1148ad204488SMiklos Szeredi ofs->workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 1149ad204488SMiklos Szeredi if (!ofs->workdir) 11502ba9d57eSAmir Goldstein goto out; 11518ed61dc3SMiklos Szeredi 1152146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir"); 1153146d62e5SAmir Goldstein if (err) 1154146d62e5SAmir Goldstein goto out; 1155146d62e5SAmir Goldstein 11568ed61dc3SMiklos Szeredi /* 11578ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 11588ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 11598ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 11608ed61dc3SMiklos Szeredi * previous step. 11618ed61dc3SMiklos Szeredi */ 11628ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 11638ed61dc3SMiklos Szeredi if (err < 0) 11642ba9d57eSAmir Goldstein goto out; 11658ed61dc3SMiklos Szeredi 1166d80172c2SAmir Goldstein d_type = err; 1167d80172c2SAmir Goldstein if (!d_type) 11681bd0a3aeSlijiazi pr_warn("upper fs needs to support d_type.\n"); 11698ed61dc3SMiklos Szeredi 11708ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 1171ad204488SMiklos Szeredi temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0); 1172ad204488SMiklos Szeredi ofs->tmpfile = !IS_ERR(temp); 1173ad204488SMiklos Szeredi if (ofs->tmpfile) 11748ed61dc3SMiklos Szeredi dput(temp); 11758ed61dc3SMiklos Szeredi else 11761bd0a3aeSlijiazi pr_warn("upper fs does not support tmpfile.\n"); 11778ed61dc3SMiklos Szeredi 1178cad218abSAmir Goldstein 1179cad218abSAmir Goldstein /* Check if upper/work fs supports RENAME_WHITEOUT */ 1180cad218abSAmir Goldstein err = ovl_check_rename_whiteout(ofs->workdir); 1181cad218abSAmir Goldstein if (err < 0) 1182cad218abSAmir Goldstein goto out; 1183cad218abSAmir Goldstein 1184d80172c2SAmir Goldstein rename_whiteout = err; 1185d80172c2SAmir Goldstein if (!rename_whiteout) 1186cad218abSAmir Goldstein pr_warn("upper fs does not support RENAME_WHITEOUT.\n"); 1187cad218abSAmir Goldstein 11888ed61dc3SMiklos Szeredi /* 11898ed61dc3SMiklos Szeredi * Check if upper/work fs supports trusted.overlay.* xattr 11908ed61dc3SMiklos Szeredi */ 1191ad204488SMiklos Szeredi err = ovl_do_setxattr(ofs->workdir, OVL_XATTR_OPAQUE, "0", 1, 0); 11928ed61dc3SMiklos Szeredi if (err) { 1193ad204488SMiklos Szeredi ofs->noxattr = true; 1194a683737bSAmir Goldstein ofs->config.index = false; 1195d5791044SVivek Goyal ofs->config.metacopy = false; 11961bd0a3aeSlijiazi pr_warn("upper fs does not support xattr, falling back to index=off and metacopy=off.\n"); 11972ba9d57eSAmir Goldstein err = 0; 11988ed61dc3SMiklos Szeredi } else { 1199ad204488SMiklos Szeredi vfs_removexattr(ofs->workdir, OVL_XATTR_OPAQUE); 12008ed61dc3SMiklos Szeredi } 12018ed61dc3SMiklos Szeredi 1202d80172c2SAmir Goldstein /* 1203d80172c2SAmir Goldstein * We allowed sub-optimal upper fs configuration and don't want to break 1204d80172c2SAmir Goldstein * users over kernel upgrade, but we never allowed remote upper fs, so 1205d80172c2SAmir Goldstein * we can enforce strict requirements for remote upper fs. 1206d80172c2SAmir Goldstein */ 1207d80172c2SAmir Goldstein if (ovl_dentry_remote(ofs->workdir) && 1208d80172c2SAmir Goldstein (!d_type || !rename_whiteout || ofs->noxattr)) { 1209d80172c2SAmir Goldstein pr_err("upper fs missing required features.\n"); 1210d80172c2SAmir Goldstein err = -EINVAL; 1211d80172c2SAmir Goldstein goto out; 1212d80172c2SAmir Goldstein } 1213d80172c2SAmir Goldstein 12148ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 1215e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 1216e487d889SAmir Goldstein if (ofs->config.index && !fh_type) { 1217ad204488SMiklos Szeredi ofs->config.index = false; 12181bd0a3aeSlijiazi pr_warn("upper fs does not support file handles, falling back to index=off.\n"); 12198ed61dc3SMiklos Szeredi } 12208ed61dc3SMiklos Szeredi 1221e487d889SAmir Goldstein /* Check if upper fs has 32bit inode numbers */ 1222e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 12230f831ec8SAmir Goldstein ofs->xino_mode = -1; 1224e487d889SAmir Goldstein 1225f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */ 1226f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) { 12271bd0a3aeSlijiazi pr_warn("NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 1228f168f109SAmir Goldstein ofs->config.nfs_export = false; 1229f168f109SAmir Goldstein } 12302ba9d57eSAmir Goldstein out: 12312ba9d57eSAmir Goldstein mnt_drop_write(mnt); 12322ba9d57eSAmir Goldstein return err; 12338ed61dc3SMiklos Szeredi } 12348ed61dc3SMiklos Szeredi 1235146d62e5SAmir Goldstein static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs, 1236146d62e5SAmir Goldstein struct path *upperpath) 1237520d7c86SMiklos Szeredi { 1238520d7c86SMiklos Szeredi int err; 1239bca44b52SMiklos Szeredi struct path workpath = { }; 1240520d7c86SMiklos Szeredi 1241ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.workdir, &workpath); 1242520d7c86SMiklos Szeredi if (err) 1243520d7c86SMiklos Szeredi goto out; 1244520d7c86SMiklos Szeredi 1245520d7c86SMiklos Szeredi err = -EINVAL; 1246bca44b52SMiklos Szeredi if (upperpath->mnt != workpath.mnt) { 12471bd0a3aeSlijiazi pr_err("workdir and upperdir must reside under the same mount\n"); 1248520d7c86SMiklos Szeredi goto out; 1249520d7c86SMiklos Szeredi } 1250bca44b52SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 12511bd0a3aeSlijiazi pr_err("workdir and upperdir must be separate subtrees\n"); 1252520d7c86SMiklos Szeredi goto out; 1253520d7c86SMiklos Szeredi } 1254520d7c86SMiklos Szeredi 12558c25741aSMiklos Szeredi ofs->workbasedir = dget(workpath.dentry); 12568c25741aSMiklos Szeredi 12578c25741aSMiklos Szeredi if (ovl_inuse_trylock(ofs->workbasedir)) { 1258ad204488SMiklos Szeredi ofs->workdir_locked = true; 1259520d7c86SMiklos Szeredi } else { 12600be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "workdir"); 12610be0bfd2SAmir Goldstein if (err) 12620be0bfd2SAmir Goldstein goto out; 1263520d7c86SMiklos Szeredi } 1264520d7c86SMiklos Szeredi 12650be0bfd2SAmir Goldstein err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap, 12660be0bfd2SAmir Goldstein "workdir"); 12670be0bfd2SAmir Goldstein if (err) 12680be0bfd2SAmir Goldstein goto out; 12690be0bfd2SAmir Goldstein 1270146d62e5SAmir Goldstein err = ovl_make_workdir(sb, ofs, &workpath); 1271bca44b52SMiklos Szeredi 1272520d7c86SMiklos Szeredi out: 1273bca44b52SMiklos Szeredi path_put(&workpath); 1274bca44b52SMiklos Szeredi 1275520d7c86SMiklos Szeredi return err; 1276520d7c86SMiklos Szeredi } 1277520d7c86SMiklos Szeredi 1278146d62e5SAmir Goldstein static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs, 1279146d62e5SAmir Goldstein struct ovl_entry *oe, struct path *upperpath) 1280f7e3a7d9SMiklos Szeredi { 12812ba9d57eSAmir Goldstein struct vfsmount *mnt = ofs->upper_mnt; 1282f7e3a7d9SMiklos Szeredi int err; 1283f7e3a7d9SMiklos Szeredi 12842ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 12852ba9d57eSAmir Goldstein if (err) 12862ba9d57eSAmir Goldstein return err; 12872ba9d57eSAmir Goldstein 1288f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 1289d9768076SAmir Goldstein err = ovl_verify_origin(upperpath->dentry, oe->lowerstack[0].dentry, 129005122443SAmir Goldstein true); 1291f7e3a7d9SMiklos Szeredi if (err) { 12921bd0a3aeSlijiazi pr_err("failed to verify upper root origin\n"); 1293f7e3a7d9SMiklos Szeredi goto out; 1294f7e3a7d9SMiklos Szeredi } 1295f7e3a7d9SMiklos Szeredi 1296ad204488SMiklos Szeredi ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1297ad204488SMiklos Szeredi if (ofs->indexdir) { 1298146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap, 1299146d62e5SAmir Goldstein "indexdir"); 1300146d62e5SAmir Goldstein if (err) 1301146d62e5SAmir Goldstein goto out; 1302146d62e5SAmir Goldstein 1303ad1d615cSAmir Goldstein /* 1304ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir. 1305ad1d615cSAmir Goldstein * Older kernels stored upper fh in "trusted.overlay.origin" 1306ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to 1307ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr 1308ad1d615cSAmir Goldstein * "trusted.overlay.upper" to indicate that index may have 1309ad1d615cSAmir Goldstein * directory entries. 1310ad1d615cSAmir Goldstein */ 1311ad1d615cSAmir Goldstein if (ovl_check_origin_xattr(ofs->indexdir)) { 131205122443SAmir Goldstein err = ovl_verify_set_fh(ofs->indexdir, OVL_XATTR_ORIGIN, 1313ad1d615cSAmir Goldstein upperpath->dentry, true, false); 1314f7e3a7d9SMiklos Szeredi if (err) 13151bd0a3aeSlijiazi pr_err("failed to verify index dir 'origin' xattr\n"); 1316ad1d615cSAmir Goldstein } 1317ad1d615cSAmir Goldstein err = ovl_verify_upper(ofs->indexdir, upperpath->dentry, true); 1318ad1d615cSAmir Goldstein if (err) 13191bd0a3aeSlijiazi pr_err("failed to verify index dir 'upper' xattr\n"); 1320f7e3a7d9SMiklos Szeredi 1321f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 1322f7e3a7d9SMiklos Szeredi if (!err) 13231eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs); 1324f7e3a7d9SMiklos Szeredi } 1325ad204488SMiklos Szeredi if (err || !ofs->indexdir) 13261bd0a3aeSlijiazi pr_warn("try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1327f7e3a7d9SMiklos Szeredi 1328f7e3a7d9SMiklos Szeredi out: 13292ba9d57eSAmir Goldstein mnt_drop_write(mnt); 1330f7e3a7d9SMiklos Szeredi return err; 1331f7e3a7d9SMiklos Szeredi } 1332f7e3a7d9SMiklos Szeredi 13339df085f3SAmir Goldstein static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid) 13345148626bSAmir Goldstein { 13355148626bSAmir Goldstein unsigned int i; 13369df085f3SAmir Goldstein 13377e63c87fSAmir Goldstein if (!ofs->config.nfs_export && !ofs->upper_mnt) 13389df085f3SAmir Goldstein return true; 13399df085f3SAmir Goldstein 13401b81ddddSAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 13419df085f3SAmir Goldstein /* 13429df085f3SAmir Goldstein * We use uuid to associate an overlay lower file handle with a 13439df085f3SAmir Goldstein * lower layer, so we can accept lower fs with null uuid as long 13449df085f3SAmir Goldstein * as all lower layers with null uuid are on the same fs. 13457e63c87fSAmir Goldstein * if we detect multiple lower fs with the same uuid, we 13467e63c87fSAmir Goldstein * disable lower file handle decoding on all of them. 13479df085f3SAmir Goldstein */ 13481b81ddddSAmir Goldstein if (ofs->fs[i].is_lower && 13491b81ddddSAmir Goldstein uuid_equal(&ofs->fs[i].sb->s_uuid, uuid)) { 135007f1e596SAmir Goldstein ofs->fs[i].bad_uuid = true; 13519df085f3SAmir Goldstein return false; 13529df085f3SAmir Goldstein } 13537e63c87fSAmir Goldstein } 13549df085f3SAmir Goldstein return true; 13559df085f3SAmir Goldstein } 13569df085f3SAmir Goldstein 13579df085f3SAmir Goldstein /* Get a unique fsid for the layer */ 13589df085f3SAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) 13599df085f3SAmir Goldstein { 13609df085f3SAmir Goldstein struct super_block *sb = path->mnt->mnt_sb; 13619df085f3SAmir Goldstein unsigned int i; 13625148626bSAmir Goldstein dev_t dev; 13635148626bSAmir Goldstein int err; 13647e63c87fSAmir Goldstein bool bad_uuid = false; 13655148626bSAmir Goldstein 136607f1e596SAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 136707f1e596SAmir Goldstein if (ofs->fs[i].sb == sb) 136807f1e596SAmir Goldstein return i; 13695148626bSAmir Goldstein } 13705148626bSAmir Goldstein 13719df085f3SAmir Goldstein if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) { 13727e63c87fSAmir Goldstein bad_uuid = true; 13737e63c87fSAmir Goldstein if (ofs->config.index || ofs->config.nfs_export) { 13749df085f3SAmir Goldstein ofs->config.index = false; 13759df085f3SAmir Goldstein ofs->config.nfs_export = false; 13761bd0a3aeSlijiazi pr_warn("%s uuid detected in lower fs '%pd2', falling back to index=off,nfs_export=off.\n", 13777e63c87fSAmir Goldstein uuid_is_null(&sb->s_uuid) ? "null" : 13787e63c87fSAmir Goldstein "conflicting", 13799df085f3SAmir Goldstein path->dentry); 13809df085f3SAmir Goldstein } 13817e63c87fSAmir Goldstein } 13829df085f3SAmir Goldstein 13835148626bSAmir Goldstein err = get_anon_bdev(&dev); 13845148626bSAmir Goldstein if (err) { 13851bd0a3aeSlijiazi pr_err("failed to get anonymous bdev for lowerpath\n"); 13865148626bSAmir Goldstein return err; 13875148626bSAmir Goldstein } 13885148626bSAmir Goldstein 138907f1e596SAmir Goldstein ofs->fs[ofs->numfs].sb = sb; 139007f1e596SAmir Goldstein ofs->fs[ofs->numfs].pseudo_dev = dev; 139107f1e596SAmir Goldstein ofs->fs[ofs->numfs].bad_uuid = bad_uuid; 13925148626bSAmir Goldstein 139307f1e596SAmir Goldstein return ofs->numfs++; 13945148626bSAmir Goldstein } 13955148626bSAmir Goldstein 139694375f9dSAmir Goldstein static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, 1397146d62e5SAmir Goldstein struct path *stack, unsigned int numlower) 1398520d7c86SMiklos Szeredi { 1399520d7c86SMiklos Szeredi int err; 1400520d7c86SMiklos Szeredi unsigned int i; 140113464165SMiklos Szeredi struct ovl_layer *layers; 1402520d7c86SMiklos Szeredi 1403520d7c86SMiklos Szeredi err = -ENOMEM; 140413464165SMiklos Szeredi layers = kcalloc(numlower + 1, sizeof(struct ovl_layer), GFP_KERNEL); 140513464165SMiklos Szeredi if (!layers) 1406520d7c86SMiklos Szeredi goto out; 140713464165SMiklos Szeredi ofs->layers = layers; 14085148626bSAmir Goldstein 140907f1e596SAmir Goldstein ofs->fs = kcalloc(numlower + 1, sizeof(struct ovl_sb), GFP_KERNEL); 141007f1e596SAmir Goldstein if (ofs->fs == NULL) 14115148626bSAmir Goldstein goto out; 14125148626bSAmir Goldstein 141307f1e596SAmir Goldstein /* idx/fsid 0 are reserved for upper fs even with lower only overlay */ 141407f1e596SAmir Goldstein ofs->numfs++; 141507f1e596SAmir Goldstein 141613464165SMiklos Szeredi layers[0].mnt = ofs->upper_mnt; 141713464165SMiklos Szeredi layers[0].idx = 0; 141813464165SMiklos Szeredi layers[0].fsid = 0; 141994375f9dSAmir Goldstein ofs->numlayer = 1; 142094375f9dSAmir Goldstein 142107f1e596SAmir Goldstein /* 1422b7bf9908SAmir Goldstein * All lower layers that share the same fs as upper layer, use the same 1423b7bf9908SAmir Goldstein * pseudo_dev as upper layer. Allocate fs[0].pseudo_dev even for lower 1424b7bf9908SAmir Goldstein * only overlay to simplify ovl_fs_free(). 14251b81ddddSAmir Goldstein * is_lower will be set if upper fs is shared with a lower layer. 142607f1e596SAmir Goldstein */ 1427b7bf9908SAmir Goldstein err = get_anon_bdev(&ofs->fs[0].pseudo_dev); 1428b7bf9908SAmir Goldstein if (err) { 1429b7bf9908SAmir Goldstein pr_err("failed to get anonymous bdev for upper fs\n"); 1430b7bf9908SAmir Goldstein goto out; 1431b7bf9908SAmir Goldstein } 1432b7bf9908SAmir Goldstein 143307f1e596SAmir Goldstein if (ofs->upper_mnt) { 143407f1e596SAmir Goldstein ofs->fs[0].sb = ofs->upper_mnt->mnt_sb; 14351b81ddddSAmir Goldstein ofs->fs[0].is_lower = false; 143607f1e596SAmir Goldstein } 143707f1e596SAmir Goldstein 1438520d7c86SMiklos Szeredi for (i = 0; i < numlower; i++) { 1439520d7c86SMiklos Szeredi struct vfsmount *mnt; 1440146d62e5SAmir Goldstein struct inode *trap; 14415148626bSAmir Goldstein int fsid; 1442520d7c86SMiklos Szeredi 14439df085f3SAmir Goldstein err = fsid = ovl_get_fsid(ofs, &stack[i]); 14445148626bSAmir Goldstein if (err < 0) 1445520d7c86SMiklos Szeredi goto out; 1446520d7c86SMiklos Szeredi 1447146d62e5SAmir Goldstein err = ovl_setup_trap(sb, stack[i].dentry, &trap, "lowerdir"); 1448146d62e5SAmir Goldstein if (err) 1449146d62e5SAmir Goldstein goto out; 1450146d62e5SAmir Goldstein 14510be0bfd2SAmir Goldstein if (ovl_is_inuse(stack[i].dentry)) { 14520be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "lowerdir"); 14530be0bfd2SAmir Goldstein if (err) 14540be0bfd2SAmir Goldstein goto out; 14550be0bfd2SAmir Goldstein } 14560be0bfd2SAmir Goldstein 1457520d7c86SMiklos Szeredi mnt = clone_private_mount(&stack[i]); 1458520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1459520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 14601bd0a3aeSlijiazi pr_err("failed to clone lowerpath\n"); 1461146d62e5SAmir Goldstein iput(trap); 1462520d7c86SMiklos Szeredi goto out; 1463520d7c86SMiklos Szeredi } 14645148626bSAmir Goldstein 1465520d7c86SMiklos Szeredi /* 1466520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1467520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1468520d7c86SMiklos Szeredi */ 1469520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1470520d7c86SMiklos Szeredi 147113464165SMiklos Szeredi layers[ofs->numlayer].trap = trap; 147213464165SMiklos Szeredi layers[ofs->numlayer].mnt = mnt; 147313464165SMiklos Szeredi layers[ofs->numlayer].idx = ofs->numlayer; 147413464165SMiklos Szeredi layers[ofs->numlayer].fsid = fsid; 147513464165SMiklos Szeredi layers[ofs->numlayer].fs = &ofs->fs[fsid]; 147694375f9dSAmir Goldstein ofs->numlayer++; 14771b81ddddSAmir Goldstein ofs->fs[fsid].is_lower = true; 1478520d7c86SMiklos Szeredi } 1479e487d889SAmir Goldstein 1480795939a9SAmir Goldstein /* 1481795939a9SAmir Goldstein * When all layers on same fs, overlay can use real inode numbers. 1482795939a9SAmir Goldstein * With mount option "xino=on", mounter declares that there are enough 1483795939a9SAmir Goldstein * free high bits in underlying fs to hold the unique fsid. 1484795939a9SAmir Goldstein * If overlayfs does encounter underlying inodes using the high xino 1485795939a9SAmir Goldstein * bits reserved for fsid, it emits a warning and uses the original 1486795939a9SAmir Goldstein * inode number. 1487795939a9SAmir Goldstein */ 148807f1e596SAmir Goldstein if (ofs->numfs - !ofs->upper_mnt == 1) { 14890f831ec8SAmir Goldstein if (ofs->config.xino == OVL_XINO_ON) 14900f831ec8SAmir Goldstein pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n"); 14910f831ec8SAmir Goldstein ofs->xino_mode = 0; 149253afcd31SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_OFF) { 149353afcd31SAmir Goldstein ofs->xino_mode = -1; 14940f831ec8SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_ON && ofs->xino_mode < 0) { 1495795939a9SAmir Goldstein /* 149607f1e596SAmir Goldstein * This is a roundup of number of bits needed for encoding 149707f1e596SAmir Goldstein * fsid, where fsid 0 is reserved for upper fs even with 149807f1e596SAmir Goldstein * lower only overlay. 1499795939a9SAmir Goldstein */ 1500795939a9SAmir Goldstein BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 31); 150107f1e596SAmir Goldstein ofs->xino_mode = ilog2(ofs->numfs - 1) + 1; 1502795939a9SAmir Goldstein } 1503795939a9SAmir Goldstein 15040f831ec8SAmir Goldstein if (ofs->xino_mode > 0) { 15051bd0a3aeSlijiazi pr_info("\"xino\" feature enabled using %d upper inode bits.\n", 15060f831ec8SAmir Goldstein ofs->xino_mode); 1507795939a9SAmir Goldstein } 1508e487d889SAmir Goldstein 1509520d7c86SMiklos Szeredi err = 0; 1510520d7c86SMiklos Szeredi out: 1511520d7c86SMiklos Szeredi return err; 1512520d7c86SMiklos Szeredi } 1513520d7c86SMiklos Szeredi 15144155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1515ad204488SMiklos Szeredi struct ovl_fs *ofs) 151653dbb0b4SMiklos Szeredi { 151753dbb0b4SMiklos Szeredi int err; 151853dbb0b4SMiklos Szeredi char *lowertmp, *lower; 15194155c10aSMiklos Szeredi struct path *stack = NULL; 15204155c10aSMiklos Szeredi unsigned int stacklen, numlower = 0, i; 15214155c10aSMiklos Szeredi struct ovl_entry *oe; 152253dbb0b4SMiklos Szeredi 152353dbb0b4SMiklos Szeredi err = -ENOMEM; 1524ad204488SMiklos Szeredi lowertmp = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 152553dbb0b4SMiklos Szeredi if (!lowertmp) 15264155c10aSMiklos Szeredi goto out_err; 152753dbb0b4SMiklos Szeredi 152853dbb0b4SMiklos Szeredi err = -EINVAL; 152953dbb0b4SMiklos Szeredi stacklen = ovl_split_lowerdirs(lowertmp); 153053dbb0b4SMiklos Szeredi if (stacklen > OVL_MAX_STACK) { 15311bd0a3aeSlijiazi pr_err("too many lower directories, limit is %d\n", 153253dbb0b4SMiklos Szeredi OVL_MAX_STACK); 15334155c10aSMiklos Szeredi goto out_err; 1534ad204488SMiklos Szeredi } else if (!ofs->config.upperdir && stacklen == 1) { 15351bd0a3aeSlijiazi pr_err("at least 2 lowerdir are needed while upperdir nonexistent\n"); 15364155c10aSMiklos Szeredi goto out_err; 1537f168f109SAmir Goldstein } else if (!ofs->config.upperdir && ofs->config.nfs_export && 1538f168f109SAmir Goldstein ofs->config.redirect_follow) { 15391bd0a3aeSlijiazi pr_warn("NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n"); 1540f168f109SAmir Goldstein ofs->config.nfs_export = false; 154153dbb0b4SMiklos Szeredi } 154253dbb0b4SMiklos Szeredi 154353dbb0b4SMiklos Szeredi err = -ENOMEM; 154453dbb0b4SMiklos Szeredi stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL); 154553dbb0b4SMiklos Szeredi if (!stack) 15464155c10aSMiklos Szeredi goto out_err; 154753dbb0b4SMiklos Szeredi 154853dbb0b4SMiklos Szeredi err = -EINVAL; 154953dbb0b4SMiklos Szeredi lower = lowertmp; 155053dbb0b4SMiklos Szeredi for (numlower = 0; numlower < stacklen; numlower++) { 1551ad204488SMiklos Szeredi err = ovl_lower_dir(lower, &stack[numlower], ofs, 1552f4288844SMiklos Szeredi &sb->s_stack_depth); 155353dbb0b4SMiklos Szeredi if (err) 15544155c10aSMiklos Szeredi goto out_err; 155553dbb0b4SMiklos Szeredi 155653dbb0b4SMiklos Szeredi lower = strchr(lower, '\0') + 1; 155753dbb0b4SMiklos Szeredi } 155853dbb0b4SMiklos Szeredi 155953dbb0b4SMiklos Szeredi err = -EINVAL; 156053dbb0b4SMiklos Szeredi sb->s_stack_depth++; 156153dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 15621bd0a3aeSlijiazi pr_err("maximum fs stacking depth exceeded\n"); 15634155c10aSMiklos Szeredi goto out_err; 156453dbb0b4SMiklos Szeredi } 156553dbb0b4SMiklos Szeredi 156694375f9dSAmir Goldstein err = ovl_get_layers(sb, ofs, stack, numlower); 15674155c10aSMiklos Szeredi if (err) 15684155c10aSMiklos Szeredi goto out_err; 15694155c10aSMiklos Szeredi 15704155c10aSMiklos Szeredi err = -ENOMEM; 15714155c10aSMiklos Szeredi oe = ovl_alloc_entry(numlower); 15724155c10aSMiklos Szeredi if (!oe) 15734155c10aSMiklos Szeredi goto out_err; 15744155c10aSMiklos Szeredi 15754155c10aSMiklos Szeredi for (i = 0; i < numlower; i++) { 15764155c10aSMiklos Szeredi oe->lowerstack[i].dentry = dget(stack[i].dentry); 157794375f9dSAmir Goldstein oe->lowerstack[i].layer = &ofs->layers[i+1]; 15784155c10aSMiklos Szeredi } 157953dbb0b4SMiklos Szeredi 158053dbb0b4SMiklos Szeredi out: 158153dbb0b4SMiklos Szeredi for (i = 0; i < numlower; i++) 158253dbb0b4SMiklos Szeredi path_put(&stack[i]); 158353dbb0b4SMiklos Szeredi kfree(stack); 15844155c10aSMiklos Szeredi kfree(lowertmp); 15854155c10aSMiklos Szeredi 15864155c10aSMiklos Szeredi return oe; 15874155c10aSMiklos Szeredi 15884155c10aSMiklos Szeredi out_err: 15894155c10aSMiklos Szeredi oe = ERR_PTR(err); 159053dbb0b4SMiklos Szeredi goto out; 159153dbb0b4SMiklos Szeredi } 159253dbb0b4SMiklos Szeredi 1593146d62e5SAmir Goldstein /* 1594146d62e5SAmir Goldstein * Check if this layer root is a descendant of: 1595146d62e5SAmir Goldstein * - another layer of this overlayfs instance 1596146d62e5SAmir Goldstein * - upper/work dir of any overlayfs instance 1597146d62e5SAmir Goldstein */ 15980be0bfd2SAmir Goldstein static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs, 15990be0bfd2SAmir Goldstein struct dentry *dentry, const char *name) 1600146d62e5SAmir Goldstein { 16019179c21dSMiklos Szeredi struct dentry *next = dentry, *parent; 1602146d62e5SAmir Goldstein int err = 0; 1603146d62e5SAmir Goldstein 16049179c21dSMiklos Szeredi if (!dentry) 1605146d62e5SAmir Goldstein return 0; 1606146d62e5SAmir Goldstein 1607146d62e5SAmir Goldstein parent = dget_parent(next); 16089179c21dSMiklos Szeredi 16099179c21dSMiklos Szeredi /* Walk back ancestors to root (inclusive) looking for traps */ 16109179c21dSMiklos Szeredi while (!err && parent != next) { 16110be0bfd2SAmir Goldstein if (ovl_lookup_trap_inode(sb, parent)) { 1612146d62e5SAmir Goldstein err = -ELOOP; 16131bd0a3aeSlijiazi pr_err("overlapping %s path\n", name); 16140be0bfd2SAmir Goldstein } else if (ovl_is_inuse(parent)) { 16150be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, name); 1616146d62e5SAmir Goldstein } 1617146d62e5SAmir Goldstein next = parent; 16189179c21dSMiklos Szeredi parent = dget_parent(next); 16199179c21dSMiklos Szeredi dput(next); 1620146d62e5SAmir Goldstein } 1621146d62e5SAmir Goldstein 16229179c21dSMiklos Szeredi dput(parent); 1623146d62e5SAmir Goldstein 1624146d62e5SAmir Goldstein return err; 1625146d62e5SAmir Goldstein } 1626146d62e5SAmir Goldstein 1627146d62e5SAmir Goldstein /* 1628146d62e5SAmir Goldstein * Check if any of the layers or work dirs overlap. 1629146d62e5SAmir Goldstein */ 1630146d62e5SAmir Goldstein static int ovl_check_overlapping_layers(struct super_block *sb, 1631146d62e5SAmir Goldstein struct ovl_fs *ofs) 1632146d62e5SAmir Goldstein { 1633146d62e5SAmir Goldstein int i, err; 1634146d62e5SAmir Goldstein 1635146d62e5SAmir Goldstein if (ofs->upper_mnt) { 16360be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, ofs->upper_mnt->mnt_root, 16370be0bfd2SAmir Goldstein "upperdir"); 1638146d62e5SAmir Goldstein if (err) 1639146d62e5SAmir Goldstein return err; 1640146d62e5SAmir Goldstein 1641146d62e5SAmir Goldstein /* 1642146d62e5SAmir Goldstein * Checking workbasedir avoids hitting ovl_is_inuse(parent) of 1643146d62e5SAmir Goldstein * this instance and covers overlapping work and index dirs, 1644146d62e5SAmir Goldstein * unless work or index dir have been moved since created inside 1645146d62e5SAmir Goldstein * workbasedir. In that case, we already have their traps in 1646146d62e5SAmir Goldstein * inode cache and we will catch that case on lookup. 1647146d62e5SAmir Goldstein */ 16480be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir"); 1649146d62e5SAmir Goldstein if (err) 1650146d62e5SAmir Goldstein return err; 1651146d62e5SAmir Goldstein } 1652146d62e5SAmir Goldstein 165394375f9dSAmir Goldstein for (i = 1; i < ofs->numlayer; i++) { 16540be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, 165594375f9dSAmir Goldstein ofs->layers[i].mnt->mnt_root, 1656146d62e5SAmir Goldstein "lowerdir"); 1657146d62e5SAmir Goldstein if (err) 1658146d62e5SAmir Goldstein return err; 1659146d62e5SAmir Goldstein } 1660146d62e5SAmir Goldstein 1661146d62e5SAmir Goldstein return 0; 1662146d62e5SAmir Goldstein } 1663146d62e5SAmir Goldstein 16642effc5c2SAmir Goldstein static struct dentry *ovl_get_root(struct super_block *sb, 16652effc5c2SAmir Goldstein struct dentry *upperdentry, 16662effc5c2SAmir Goldstein struct ovl_entry *oe) 16672effc5c2SAmir Goldstein { 16682effc5c2SAmir Goldstein struct dentry *root; 166962c832edSAmir Goldstein struct ovl_path *lowerpath = &oe->lowerstack[0]; 167062c832edSAmir Goldstein unsigned long ino = d_inode(lowerpath->dentry)->i_ino; 167162c832edSAmir Goldstein int fsid = lowerpath->layer->fsid; 167262c832edSAmir Goldstein struct ovl_inode_params oip = { 167362c832edSAmir Goldstein .upperdentry = upperdentry, 167462c832edSAmir Goldstein .lowerpath = lowerpath, 167562c832edSAmir Goldstein }; 16762effc5c2SAmir Goldstein 16772effc5c2SAmir Goldstein root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 16782effc5c2SAmir Goldstein if (!root) 16792effc5c2SAmir Goldstein return NULL; 16802effc5c2SAmir Goldstein 16812effc5c2SAmir Goldstein root->d_fsdata = oe; 16822effc5c2SAmir Goldstein 16832effc5c2SAmir Goldstein if (upperdentry) { 168462c832edSAmir Goldstein /* Root inode uses upper st_ino/i_ino */ 168562c832edSAmir Goldstein ino = d_inode(upperdentry)->i_ino; 168662c832edSAmir Goldstein fsid = 0; 16872effc5c2SAmir Goldstein ovl_dentry_set_upper_alias(root); 16882effc5c2SAmir Goldstein if (ovl_is_impuredir(upperdentry)) 16892effc5c2SAmir Goldstein ovl_set_flag(OVL_IMPURE, d_inode(root)); 16902effc5c2SAmir Goldstein } 16912effc5c2SAmir Goldstein 16922effc5c2SAmir Goldstein /* Root is always merge -> can have whiteouts */ 16932effc5c2SAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root)); 16942effc5c2SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root); 16952effc5c2SAmir Goldstein ovl_set_upperdata(d_inode(root)); 169662c832edSAmir Goldstein ovl_inode_init(d_inode(root), &oip, ino, fsid); 1697f4288844SMiklos Szeredi ovl_dentry_update_reval(root, upperdentry, DCACHE_OP_WEAK_REVALIDATE); 16982effc5c2SAmir Goldstein 16992effc5c2SAmir Goldstein return root; 17002effc5c2SAmir Goldstein } 17012effc5c2SAmir Goldstein 1702e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1703e9be9d5eSMiklos Szeredi { 170433006cdfSKees Cook struct path upperpath = { }; 1705e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 17064155c10aSMiklos Szeredi struct ovl_entry *oe; 1707ad204488SMiklos Szeredi struct ovl_fs *ofs; 170851f8f3c4SKonstantin Khlebnikov struct cred *cred; 1709e9be9d5eSMiklos Szeredi int err; 1710e9be9d5eSMiklos Szeredi 1711f4288844SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 1712f4288844SMiklos Szeredi 1713f45827e8SErez Zadok err = -ENOMEM; 1714ad204488SMiklos Szeredi ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1715ad204488SMiklos Szeredi if (!ofs) 1716e9be9d5eSMiklos Szeredi goto out; 1717e9be9d5eSMiklos Szeredi 1718ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1719c6fe6254SMiklos Szeredi if (!cred) 1720c6fe6254SMiklos Szeredi goto out_err; 1721c6fe6254SMiklos Szeredi 1722ad204488SMiklos Szeredi ofs->config.index = ovl_index_def; 1723f168f109SAmir Goldstein ofs->config.nfs_export = ovl_nfs_export_def; 1724795939a9SAmir Goldstein ofs->config.xino = ovl_xino_def(); 1725d5791044SVivek Goyal ofs->config.metacopy = ovl_metacopy_def; 1726ad204488SMiklos Szeredi err = ovl_parse_opt((char *) data, &ofs->config); 1727f45827e8SErez Zadok if (err) 1728a9075cdbSMiklos Szeredi goto out_err; 1729f45827e8SErez Zadok 1730e9be9d5eSMiklos Szeredi err = -EINVAL; 1731ad204488SMiklos Szeredi if (!ofs->config.lowerdir) { 173207f2af7bSKonstantin Khlebnikov if (!silent) 17331bd0a3aeSlijiazi pr_err("missing 'lowerdir'\n"); 1734a9075cdbSMiklos Szeredi goto out_err; 173553a08cb9SMiklos Szeredi } 173653a08cb9SMiklos Szeredi 173753a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 1738cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 17394d314f78SAmir Goldstein atomic_long_set(&ofs->last_ino, 1); 1740e487d889SAmir Goldstein /* Assume underlaying fs uses 32bit inodes unless proven otherwise */ 174153afcd31SAmir Goldstein if (ofs->config.xino != OVL_XINO_OFF) { 17420f831ec8SAmir Goldstein ofs->xino_mode = BITS_PER_LONG - 32; 174353afcd31SAmir Goldstein if (!ofs->xino_mode) { 174453afcd31SAmir Goldstein pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n"); 174553afcd31SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 174653afcd31SAmir Goldstein } 174753afcd31SAmir Goldstein } 1748795939a9SAmir Goldstein 1749146d62e5SAmir Goldstein /* alloc/destroy_inode needed for setting up traps in inode cache */ 1750146d62e5SAmir Goldstein sb->s_op = &ovl_super_operations; 1751146d62e5SAmir Goldstein 1752ad204488SMiklos Szeredi if (ofs->config.upperdir) { 1753ad204488SMiklos Szeredi if (!ofs->config.workdir) { 17541bd0a3aeSlijiazi pr_err("missing 'workdir'\n"); 1755a9075cdbSMiklos Szeredi goto out_err; 1756e9be9d5eSMiklos Szeredi } 1757e9be9d5eSMiklos Szeredi 1758146d62e5SAmir Goldstein err = ovl_get_upper(sb, ofs, &upperpath); 175921a3b317SMiklos Szeredi if (err) 1760a9075cdbSMiklos Szeredi goto out_err; 1761d719e8f2SMiklos Szeredi 1762146d62e5SAmir Goldstein err = ovl_get_workdir(sb, ofs, &upperpath); 17638ed61dc3SMiklos Szeredi if (err) 1764a9075cdbSMiklos Szeredi goto out_err; 1765c6fe6254SMiklos Szeredi 1766ad204488SMiklos Szeredi if (!ofs->workdir) 17671751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 17686e88256eSMiklos Szeredi 1769ad204488SMiklos Szeredi sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth; 1770ad204488SMiklos Szeredi sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran; 1771c6fe6254SMiklos Szeredi 177221765194SVivek Goyal } 1773ad204488SMiklos Szeredi oe = ovl_get_lowerstack(sb, ofs); 17744155c10aSMiklos Szeredi err = PTR_ERR(oe); 17754155c10aSMiklos Szeredi if (IS_ERR(oe)) 1776a9075cdbSMiklos Szeredi goto out_err; 1777e9be9d5eSMiklos Szeredi 177871cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 1779ad204488SMiklos Szeredi if (!ofs->upper_mnt) 17801751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 1781e9be9d5eSMiklos Szeredi 1782ad204488SMiklos Szeredi if (!(ovl_force_readonly(ofs)) && ofs->config.index) { 1783146d62e5SAmir Goldstein err = ovl_get_indexdir(sb, ofs, oe, &upperpath); 178454fb347eSAmir Goldstein if (err) 17854155c10aSMiklos Szeredi goto out_free_oe; 17866e88256eSMiklos Szeredi 1787972d0093SAmir Goldstein /* Force r/o mount with no index dir */ 1788972d0093SAmir Goldstein if (!ofs->indexdir) { 1789972d0093SAmir Goldstein dput(ofs->workdir); 1790972d0093SAmir Goldstein ofs->workdir = NULL; 17911751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 179202bcd157SAmir Goldstein } 179302bcd157SAmir Goldstein 1794972d0093SAmir Goldstein } 1795972d0093SAmir Goldstein 1796146d62e5SAmir Goldstein err = ovl_check_overlapping_layers(sb, ofs); 1797146d62e5SAmir Goldstein if (err) 1798146d62e5SAmir Goldstein goto out_free_oe; 1799146d62e5SAmir Goldstein 1800972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */ 1801f168f109SAmir Goldstein if (!ofs->indexdir) { 1802ad204488SMiklos Szeredi ofs->config.index = false; 1803f168f109SAmir Goldstein if (ofs->upper_mnt && ofs->config.nfs_export) { 18041bd0a3aeSlijiazi pr_warn("NFS export requires an index dir, falling back to nfs_export=off.\n"); 1805f168f109SAmir Goldstein ofs->config.nfs_export = false; 1806f168f109SAmir Goldstein } 1807f168f109SAmir Goldstein } 180802bcd157SAmir Goldstein 1809d5791044SVivek Goyal if (ofs->config.metacopy && ofs->config.nfs_export) { 18101bd0a3aeSlijiazi pr_warn("NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 1811d5791044SVivek Goyal ofs->config.nfs_export = false; 1812d5791044SVivek Goyal } 1813d5791044SVivek Goyal 18148383f174SAmir Goldstein if (ofs->config.nfs_export) 18158383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations; 18168383f174SAmir Goldstein 181751f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 181851f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 181951f8f3c4SKonstantin Khlebnikov 1820655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1821655042ccSVivek Goyal sb->s_xattr = ovl_xattr_handlers; 1822ad204488SMiklos Szeredi sb->s_fs_info = ofs; 1823de2a4a50SMiklos Szeredi sb->s_flags |= SB_POSIXACL; 1824655042ccSVivek Goyal 1825c6fe6254SMiklos Szeredi err = -ENOMEM; 18262effc5c2SAmir Goldstein root_dentry = ovl_get_root(sb, upperpath.dentry, oe); 1827e9be9d5eSMiklos Szeredi if (!root_dentry) 18284155c10aSMiklos Szeredi goto out_free_oe; 1829e9be9d5eSMiklos Szeredi 1830e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 1831ed06e069SMiklos Szeredi 1832e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1833e9be9d5eSMiklos Szeredi 1834e9be9d5eSMiklos Szeredi return 0; 1835e9be9d5eSMiklos Szeredi 18364155c10aSMiklos Szeredi out_free_oe: 18374155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 1838b9343632SChandan Rajendra kfree(oe); 18394155c10aSMiklos Szeredi out_err: 1840e9be9d5eSMiklos Szeredi path_put(&upperpath); 1841ad204488SMiklos Szeredi ovl_free_fs(ofs); 1842e9be9d5eSMiklos Szeredi out: 1843e9be9d5eSMiklos Szeredi return err; 1844e9be9d5eSMiklos Szeredi } 1845e9be9d5eSMiklos Szeredi 1846e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 1847e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 1848e9be9d5eSMiklos Szeredi { 1849e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 1850e9be9d5eSMiklos Szeredi } 1851e9be9d5eSMiklos Szeredi 1852e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 1853e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1854ef94b186SMiklos Szeredi .name = "overlay", 1855e9be9d5eSMiklos Szeredi .mount = ovl_mount, 1856e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 1857e9be9d5eSMiklos Szeredi }; 1858ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 1859e9be9d5eSMiklos Szeredi 186013cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 186113cf199dSAmir Goldstein { 186213cf199dSAmir Goldstein struct ovl_inode *oi = foo; 186313cf199dSAmir Goldstein 186413cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 186513cf199dSAmir Goldstein } 186613cf199dSAmir Goldstein 1867e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 1868e9be9d5eSMiklos Szeredi { 186913cf199dSAmir Goldstein int err; 187013cf199dSAmir Goldstein 187113cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 187213cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 187313cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 187413cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 187513cf199dSAmir Goldstein ovl_inode_init_once); 187613cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 187713cf199dSAmir Goldstein return -ENOMEM; 187813cf199dSAmir Goldstein 18792406a307SJiufei Xue err = ovl_aio_request_cache_init(); 18802406a307SJiufei Xue if (!err) { 188113cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 18822406a307SJiufei Xue if (!err) 18832406a307SJiufei Xue return 0; 18842406a307SJiufei Xue 18852406a307SJiufei Xue ovl_aio_request_cache_destroy(); 18862406a307SJiufei Xue } 188713cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 188813cf199dSAmir Goldstein 188913cf199dSAmir Goldstein return err; 1890e9be9d5eSMiklos Szeredi } 1891e9be9d5eSMiklos Szeredi 1892e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1893e9be9d5eSMiklos Szeredi { 1894e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 189513cf199dSAmir Goldstein 189613cf199dSAmir Goldstein /* 189713cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 189813cf199dSAmir Goldstein * destroy cache. 189913cf199dSAmir Goldstein */ 190013cf199dSAmir Goldstein rcu_barrier(); 190113cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 19022406a307SJiufei Xue ovl_aio_request_cache_destroy(); 1903e9be9d5eSMiklos Szeredi } 1904e9be9d5eSMiklos Szeredi 1905e9be9d5eSMiklos Szeredi module_init(ovl_init); 1906e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1907