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 1167c03b5d4SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 1177c03b5d4SMiklos Szeredi { 1187c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1197c03b5d4SMiklos Szeredi unsigned int i; 1207c03b5d4SMiklos Szeredi int ret = 1; 1217c03b5d4SMiklos Szeredi 1227c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1237c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1247c03b5d4SMiklos Szeredi 1257c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_REVALIDATE) { 1267c03b5d4SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1277c03b5d4SMiklos Szeredi if (ret < 0) 1287c03b5d4SMiklos Szeredi return ret; 1297c03b5d4SMiklos Szeredi if (!ret) { 1307c03b5d4SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1317c03b5d4SMiklos Szeredi d_invalidate(d); 1327c03b5d4SMiklos Szeredi return -ESTALE; 1337c03b5d4SMiklos Szeredi } 1347c03b5d4SMiklos Szeredi } 1357c03b5d4SMiklos Szeredi } 1367c03b5d4SMiklos Szeredi return 1; 1377c03b5d4SMiklos Szeredi } 1387c03b5d4SMiklos Szeredi 1397c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 1407c03b5d4SMiklos Szeredi { 1417c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1427c03b5d4SMiklos Szeredi unsigned int i; 1437c03b5d4SMiklos Szeredi int ret = 1; 1447c03b5d4SMiklos Szeredi 1457c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1467c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1477c03b5d4SMiklos Szeredi 1487c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) { 1497c03b5d4SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1507c03b5d4SMiklos Szeredi if (ret <= 0) 1517c03b5d4SMiklos Szeredi break; 1527c03b5d4SMiklos Szeredi } 1537c03b5d4SMiklos Szeredi } 1547c03b5d4SMiklos Szeredi return ret; 1557c03b5d4SMiklos Szeredi } 1567c03b5d4SMiklos Szeredi 157e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 158e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 159d101a125SMiklos Szeredi .d_real = ovl_d_real, 160e9be9d5eSMiklos Szeredi }; 161e9be9d5eSMiklos Szeredi 1627c03b5d4SMiklos Szeredi static const struct dentry_operations ovl_reval_dentry_operations = { 1637c03b5d4SMiklos Szeredi .d_release = ovl_dentry_release, 164d101a125SMiklos Szeredi .d_real = ovl_d_real, 1657c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1667c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1677c03b5d4SMiklos Szeredi }; 1687c03b5d4SMiklos Szeredi 16913cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 17013cf199dSAmir Goldstein 17113cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 17213cf199dSAmir Goldstein { 17313cf199dSAmir Goldstein struct ovl_inode *oi = kmem_cache_alloc(ovl_inode_cachep, GFP_KERNEL); 17413cf199dSAmir Goldstein 175b3885bd6SHirofumi Nakagawa if (!oi) 176b3885bd6SHirofumi Nakagawa return NULL; 177b3885bd6SHirofumi Nakagawa 17804a01ac7SMiklos Szeredi oi->cache = NULL; 179cf31c463SMiklos Szeredi oi->redirect = NULL; 18004a01ac7SMiklos Szeredi oi->version = 0; 18113c72075SMiklos Szeredi oi->flags = 0; 18209d8b586SMiklos Szeredi oi->__upperdentry = NULL; 18325b7713aSMiklos Szeredi oi->lower = NULL; 1842664bd08SVivek Goyal oi->lowerdata = NULL; 185a015dafcSAmir Goldstein mutex_init(&oi->lock); 18625b7713aSMiklos Szeredi 18713cf199dSAmir Goldstein return &oi->vfs_inode; 18813cf199dSAmir Goldstein } 18913cf199dSAmir Goldstein 1900b269dedSAl Viro static void ovl_free_inode(struct inode *inode) 19113cf199dSAmir Goldstein { 1920b269dedSAl Viro struct ovl_inode *oi = OVL_I(inode); 19313cf199dSAmir Goldstein 1940b269dedSAl Viro kfree(oi->redirect); 1950b269dedSAl Viro mutex_destroy(&oi->lock); 1960b269dedSAl Viro kmem_cache_free(ovl_inode_cachep, oi); 19713cf199dSAmir Goldstein } 19813cf199dSAmir Goldstein 19913cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 20013cf199dSAmir Goldstein { 20109d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 20209d8b586SMiklos Szeredi 20309d8b586SMiklos Szeredi dput(oi->__upperdentry); 20431747edaSAmir Goldstein iput(oi->lower); 2052664bd08SVivek Goyal if (S_ISDIR(inode->i_mode)) 2064edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 2072664bd08SVivek Goyal else 2082664bd08SVivek Goyal iput(oi->lowerdata); 20913cf199dSAmir Goldstein } 21013cf199dSAmir Goldstein 211ad204488SMiklos Szeredi static void ovl_free_fs(struct ovl_fs *ofs) 212e9be9d5eSMiklos Szeredi { 213dd662667SMiklos Szeredi unsigned i; 214e9be9d5eSMiklos Szeredi 2150be0bfd2SAmir Goldstein iput(ofs->workbasedir_trap); 216146d62e5SAmir Goldstein iput(ofs->indexdir_trap); 217146d62e5SAmir Goldstein iput(ofs->workdir_trap); 218146d62e5SAmir Goldstein iput(ofs->upperdir_trap); 219ad204488SMiklos Szeredi dput(ofs->indexdir); 220ad204488SMiklos Szeredi dput(ofs->workdir); 221ad204488SMiklos Szeredi if (ofs->workdir_locked) 222ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->workbasedir); 223ad204488SMiklos Szeredi dput(ofs->workbasedir); 224ad204488SMiklos Szeredi if (ofs->upperdir_locked) 225ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->upper_mnt->mnt_root); 226ad204488SMiklos Szeredi mntput(ofs->upper_mnt); 227146d62e5SAmir Goldstein for (i = 0; i < ofs->numlower; i++) { 228146d62e5SAmir Goldstein iput(ofs->lower_layers[i].trap); 229ad204488SMiklos Szeredi mntput(ofs->lower_layers[i].mnt); 230146d62e5SAmir Goldstein } 2315148626bSAmir Goldstein for (i = 0; i < ofs->numlowerfs; i++) 2325148626bSAmir Goldstein free_anon_bdev(ofs->lower_fs[i].pseudo_dev); 233ad204488SMiklos Szeredi kfree(ofs->lower_layers); 2345148626bSAmir Goldstein kfree(ofs->lower_fs); 235e9be9d5eSMiklos Szeredi 236ad204488SMiklos Szeredi kfree(ofs->config.lowerdir); 237ad204488SMiklos Szeredi kfree(ofs->config.upperdir); 238ad204488SMiklos Szeredi kfree(ofs->config.workdir); 239438c84c2SMiklos Szeredi kfree(ofs->config.redirect_mode); 240ad204488SMiklos Szeredi if (ofs->creator_cred) 241ad204488SMiklos Szeredi put_cred(ofs->creator_cred); 242ad204488SMiklos Szeredi kfree(ofs); 243e9be9d5eSMiklos Szeredi } 244e9be9d5eSMiklos Szeredi 245a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 246a9075cdbSMiklos Szeredi { 247a9075cdbSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 248a9075cdbSMiklos Szeredi 249a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 250a9075cdbSMiklos Szeredi } 251a9075cdbSMiklos Szeredi 252e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */ 253e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 254e593b2bfSAmir Goldstein { 255ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 256e593b2bfSAmir Goldstein struct super_block *upper_sb; 257e593b2bfSAmir Goldstein int ret; 258e593b2bfSAmir Goldstein 259ad204488SMiklos Szeredi if (!ofs->upper_mnt) 260e593b2bfSAmir Goldstein return 0; 261e8d4bfe3SChengguang Xu 262e8d4bfe3SChengguang Xu /* 263e8d4bfe3SChengguang Xu * If this is a sync(2) call or an emergency sync, all the super blocks 264e8d4bfe3SChengguang Xu * will be iterated, including upper_sb, so no need to do anything. 265e8d4bfe3SChengguang Xu * 266e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call 267e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being 268e8d4bfe3SChengguang Xu * called with wait == 1. 269e8d4bfe3SChengguang Xu */ 270e8d4bfe3SChengguang Xu if (!wait) 271e593b2bfSAmir Goldstein return 0; 272e593b2bfSAmir Goldstein 273e8d4bfe3SChengguang Xu upper_sb = ofs->upper_mnt->mnt_sb; 274e8d4bfe3SChengguang Xu 275e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 276e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb); 277e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 278e8d4bfe3SChengguang Xu 279e593b2bfSAmir Goldstein return ret; 280e593b2bfSAmir Goldstein } 281e593b2bfSAmir Goldstein 282cc259639SAndy Whitcroft /** 283cc259639SAndy Whitcroft * ovl_statfs 284cc259639SAndy Whitcroft * @sb: The overlayfs super block 285cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 286cc259639SAndy Whitcroft * 287cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 2884ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 289cc259639SAndy Whitcroft */ 290cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 291cc259639SAndy Whitcroft { 292cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 293cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 294cc259639SAndy Whitcroft struct path path; 295cc259639SAndy Whitcroft int err; 296cc259639SAndy Whitcroft 2974ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 298cc259639SAndy Whitcroft 299cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 300cc259639SAndy Whitcroft if (!err) { 3016b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 302cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 303cc259639SAndy Whitcroft } 304cc259639SAndy Whitcroft 305cc259639SAndy Whitcroft return err; 306cc259639SAndy Whitcroft } 307cc259639SAndy Whitcroft 30802bcd157SAmir Goldstein /* Will this overlay be forced to mount/remount ro? */ 309ad204488SMiklos Szeredi static bool ovl_force_readonly(struct ovl_fs *ofs) 31002bcd157SAmir Goldstein { 311ad204488SMiklos Szeredi return (!ofs->upper_mnt || !ofs->workdir); 31202bcd157SAmir Goldstein } 31302bcd157SAmir Goldstein 314438c84c2SMiklos Szeredi static const char *ovl_redirect_mode_def(void) 315438c84c2SMiklos Szeredi { 316438c84c2SMiklos Szeredi return ovl_redirect_dir_def ? "on" : "off"; 317438c84c2SMiklos Szeredi } 318438c84c2SMiklos Szeredi 319795939a9SAmir Goldstein enum { 320795939a9SAmir Goldstein OVL_XINO_OFF, 321795939a9SAmir Goldstein OVL_XINO_AUTO, 322795939a9SAmir Goldstein OVL_XINO_ON, 323795939a9SAmir Goldstein }; 324795939a9SAmir Goldstein 325795939a9SAmir Goldstein static const char * const ovl_xino_str[] = { 326795939a9SAmir Goldstein "off", 327795939a9SAmir Goldstein "auto", 328795939a9SAmir Goldstein "on", 329795939a9SAmir Goldstein }; 330795939a9SAmir Goldstein 331795939a9SAmir Goldstein static inline int ovl_xino_def(void) 332795939a9SAmir Goldstein { 333795939a9SAmir Goldstein return ovl_xino_auto_def ? OVL_XINO_AUTO : OVL_XINO_OFF; 334795939a9SAmir Goldstein } 335795939a9SAmir Goldstein 336f45827e8SErez Zadok /** 337f45827e8SErez Zadok * ovl_show_options 338f45827e8SErez Zadok * 339f45827e8SErez Zadok * Prints the mount options for a given superblock. 340f45827e8SErez Zadok * Returns zero; does not fail. 341f45827e8SErez Zadok */ 342f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 343f45827e8SErez Zadok { 344f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 345ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 346f45827e8SErez Zadok 347ad204488SMiklos Szeredi seq_show_option(m, "lowerdir", ofs->config.lowerdir); 348ad204488SMiklos Szeredi if (ofs->config.upperdir) { 349ad204488SMiklos Szeredi seq_show_option(m, "upperdir", ofs->config.upperdir); 350ad204488SMiklos Szeredi seq_show_option(m, "workdir", ofs->config.workdir); 35153a08cb9SMiklos Szeredi } 352ad204488SMiklos Szeredi if (ofs->config.default_permissions) 3538d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 354438c84c2SMiklos Szeredi if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0) 355438c84c2SMiklos Szeredi seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode); 356ad204488SMiklos Szeredi if (ofs->config.index != ovl_index_def) 357438c84c2SMiklos Szeredi seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 358f168f109SAmir Goldstein if (ofs->config.nfs_export != ovl_nfs_export_def) 359f168f109SAmir Goldstein seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ? 360f168f109SAmir Goldstein "on" : "off"); 361795939a9SAmir Goldstein if (ofs->config.xino != ovl_xino_def()) 362795939a9SAmir Goldstein seq_printf(m, ",xino=%s", ovl_xino_str[ofs->config.xino]); 363d5791044SVivek Goyal if (ofs->config.metacopy != ovl_metacopy_def) 364d5791044SVivek Goyal seq_printf(m, ",metacopy=%s", 365d5791044SVivek Goyal ofs->config.metacopy ? "on" : "off"); 366f45827e8SErez Zadok return 0; 367f45827e8SErez Zadok } 368f45827e8SErez Zadok 3693cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 3703cdf6fe9SSeunghun Lee { 371ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 3723cdf6fe9SSeunghun Lee 3731751e8a6SLinus Torvalds if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 3743cdf6fe9SSeunghun Lee return -EROFS; 3753cdf6fe9SSeunghun Lee 3763cdf6fe9SSeunghun Lee return 0; 3773cdf6fe9SSeunghun Lee } 3783cdf6fe9SSeunghun Lee 379e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 38013cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 3810b269dedSAl Viro .free_inode = ovl_free_inode, 38213cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 38313cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 384e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 385e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 386cc259639SAndy Whitcroft .statfs = ovl_statfs, 387f45827e8SErez Zadok .show_options = ovl_show_options, 3883cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 389e9be9d5eSMiklos Szeredi }; 390e9be9d5eSMiklos Szeredi 391e9be9d5eSMiklos Szeredi enum { 392e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 393e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 394e9be9d5eSMiklos Szeredi OPT_WORKDIR, 3958d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 396438c84c2SMiklos Szeredi OPT_REDIRECT_DIR, 39702bcd157SAmir Goldstein OPT_INDEX_ON, 39802bcd157SAmir Goldstein OPT_INDEX_OFF, 399f168f109SAmir Goldstein OPT_NFS_EXPORT_ON, 400f168f109SAmir Goldstein OPT_NFS_EXPORT_OFF, 401795939a9SAmir Goldstein OPT_XINO_ON, 402795939a9SAmir Goldstein OPT_XINO_OFF, 403795939a9SAmir Goldstein OPT_XINO_AUTO, 404d5791044SVivek Goyal OPT_METACOPY_ON, 405d5791044SVivek Goyal OPT_METACOPY_OFF, 406e9be9d5eSMiklos Szeredi OPT_ERR, 407e9be9d5eSMiklos Szeredi }; 408e9be9d5eSMiklos Szeredi 409e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 410e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 411e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 412e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 4138d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 414438c84c2SMiklos Szeredi {OPT_REDIRECT_DIR, "redirect_dir=%s"}, 41502bcd157SAmir Goldstein {OPT_INDEX_ON, "index=on"}, 41602bcd157SAmir Goldstein {OPT_INDEX_OFF, "index=off"}, 417f168f109SAmir Goldstein {OPT_NFS_EXPORT_ON, "nfs_export=on"}, 418f168f109SAmir Goldstein {OPT_NFS_EXPORT_OFF, "nfs_export=off"}, 419795939a9SAmir Goldstein {OPT_XINO_ON, "xino=on"}, 420795939a9SAmir Goldstein {OPT_XINO_OFF, "xino=off"}, 421795939a9SAmir Goldstein {OPT_XINO_AUTO, "xino=auto"}, 422d5791044SVivek Goyal {OPT_METACOPY_ON, "metacopy=on"}, 423d5791044SVivek Goyal {OPT_METACOPY_OFF, "metacopy=off"}, 424e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 425e9be9d5eSMiklos Szeredi }; 426e9be9d5eSMiklos Szeredi 42791c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 42891c77947SMiklos Szeredi { 42991c77947SMiklos Szeredi char *sbegin = *s; 43091c77947SMiklos Szeredi char *p; 43191c77947SMiklos Szeredi 43291c77947SMiklos Szeredi if (sbegin == NULL) 43391c77947SMiklos Szeredi return NULL; 43491c77947SMiklos Szeredi 43591c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 43691c77947SMiklos Szeredi if (*p == '\\') { 43791c77947SMiklos Szeredi p++; 43891c77947SMiklos Szeredi if (!*p) 43991c77947SMiklos Szeredi break; 44091c77947SMiklos Szeredi } else if (*p == ',') { 44191c77947SMiklos Szeredi *p = '\0'; 44291c77947SMiklos Szeredi *s = p + 1; 44391c77947SMiklos Szeredi return sbegin; 44491c77947SMiklos Szeredi } 44591c77947SMiklos Szeredi } 44691c77947SMiklos Szeredi *s = NULL; 44791c77947SMiklos Szeredi return sbegin; 44891c77947SMiklos Szeredi } 44991c77947SMiklos Szeredi 450438c84c2SMiklos Szeredi static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode) 451438c84c2SMiklos Szeredi { 452438c84c2SMiklos Szeredi if (strcmp(mode, "on") == 0) { 453438c84c2SMiklos Szeredi config->redirect_dir = true; 454438c84c2SMiklos Szeredi /* 455438c84c2SMiklos Szeredi * Does not make sense to have redirect creation without 456438c84c2SMiklos Szeredi * redirect following. 457438c84c2SMiklos Szeredi */ 458438c84c2SMiklos Szeredi config->redirect_follow = true; 459438c84c2SMiklos Szeredi } else if (strcmp(mode, "follow") == 0) { 460438c84c2SMiklos Szeredi config->redirect_follow = true; 461438c84c2SMiklos Szeredi } else if (strcmp(mode, "off") == 0) { 462438c84c2SMiklos Szeredi if (ovl_redirect_always_follow) 463438c84c2SMiklos Szeredi config->redirect_follow = true; 464438c84c2SMiklos Szeredi } else if (strcmp(mode, "nofollow") != 0) { 465438c84c2SMiklos Szeredi pr_err("overlayfs: bad mount option \"redirect_dir=%s\"\n", 466438c84c2SMiklos Szeredi mode); 467438c84c2SMiklos Szeredi return -EINVAL; 468438c84c2SMiklos Szeredi } 469438c84c2SMiklos Szeredi 470438c84c2SMiklos Szeredi return 0; 471438c84c2SMiklos Szeredi } 472438c84c2SMiklos Szeredi 473e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 474e9be9d5eSMiklos Szeredi { 475e9be9d5eSMiklos Szeredi char *p; 476d5791044SVivek Goyal int err; 477d47748e5SMiklos Szeredi bool metacopy_opt = false, redirect_opt = false; 478e9be9d5eSMiklos Szeredi 479438c84c2SMiklos Szeredi config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL); 480438c84c2SMiklos Szeredi if (!config->redirect_mode) 481438c84c2SMiklos Szeredi return -ENOMEM; 482438c84c2SMiklos Szeredi 48391c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 484e9be9d5eSMiklos Szeredi int token; 485e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 486e9be9d5eSMiklos Szeredi 487e9be9d5eSMiklos Szeredi if (!*p) 488e9be9d5eSMiklos Szeredi continue; 489e9be9d5eSMiklos Szeredi 490e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 491e9be9d5eSMiklos Szeredi switch (token) { 492e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 493e9be9d5eSMiklos Szeredi kfree(config->upperdir); 494e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 495e9be9d5eSMiklos Szeredi if (!config->upperdir) 496e9be9d5eSMiklos Szeredi return -ENOMEM; 497e9be9d5eSMiklos Szeredi break; 498e9be9d5eSMiklos Szeredi 499e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 500e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 501e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 502e9be9d5eSMiklos Szeredi if (!config->lowerdir) 503e9be9d5eSMiklos Szeredi return -ENOMEM; 504e9be9d5eSMiklos Szeredi break; 505e9be9d5eSMiklos Szeredi 506e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 507e9be9d5eSMiklos Szeredi kfree(config->workdir); 508e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 509e9be9d5eSMiklos Szeredi if (!config->workdir) 510e9be9d5eSMiklos Szeredi return -ENOMEM; 511e9be9d5eSMiklos Szeredi break; 512e9be9d5eSMiklos Szeredi 5138d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 5148d3095f4SMiklos Szeredi config->default_permissions = true; 5158d3095f4SMiklos Szeredi break; 5168d3095f4SMiklos Szeredi 517438c84c2SMiklos Szeredi case OPT_REDIRECT_DIR: 518438c84c2SMiklos Szeredi kfree(config->redirect_mode); 519438c84c2SMiklos Szeredi config->redirect_mode = match_strdup(&args[0]); 520438c84c2SMiklos Szeredi if (!config->redirect_mode) 521438c84c2SMiklos Szeredi return -ENOMEM; 522d47748e5SMiklos Szeredi redirect_opt = true; 523a6c60655SMiklos Szeredi break; 524a6c60655SMiklos Szeredi 52502bcd157SAmir Goldstein case OPT_INDEX_ON: 52602bcd157SAmir Goldstein config->index = true; 52702bcd157SAmir Goldstein break; 52802bcd157SAmir Goldstein 52902bcd157SAmir Goldstein case OPT_INDEX_OFF: 53002bcd157SAmir Goldstein config->index = false; 53102bcd157SAmir Goldstein break; 53202bcd157SAmir Goldstein 533f168f109SAmir Goldstein case OPT_NFS_EXPORT_ON: 534f168f109SAmir Goldstein config->nfs_export = true; 535f168f109SAmir Goldstein break; 536f168f109SAmir Goldstein 537f168f109SAmir Goldstein case OPT_NFS_EXPORT_OFF: 538f168f109SAmir Goldstein config->nfs_export = false; 539f168f109SAmir Goldstein break; 540f168f109SAmir Goldstein 541795939a9SAmir Goldstein case OPT_XINO_ON: 542795939a9SAmir Goldstein config->xino = OVL_XINO_ON; 543795939a9SAmir Goldstein break; 544795939a9SAmir Goldstein 545795939a9SAmir Goldstein case OPT_XINO_OFF: 546795939a9SAmir Goldstein config->xino = OVL_XINO_OFF; 547795939a9SAmir Goldstein break; 548795939a9SAmir Goldstein 549795939a9SAmir Goldstein case OPT_XINO_AUTO: 550795939a9SAmir Goldstein config->xino = OVL_XINO_AUTO; 551795939a9SAmir Goldstein break; 552795939a9SAmir Goldstein 553d5791044SVivek Goyal case OPT_METACOPY_ON: 554d5791044SVivek Goyal config->metacopy = true; 555d47748e5SMiklos Szeredi metacopy_opt = true; 556d5791044SVivek Goyal break; 557d5791044SVivek Goyal 558d5791044SVivek Goyal case OPT_METACOPY_OFF: 559d5791044SVivek Goyal config->metacopy = false; 560d5791044SVivek Goyal break; 561d5791044SVivek Goyal 562e9be9d5eSMiklos Szeredi default: 563bead55efShujianyang pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p); 564e9be9d5eSMiklos Szeredi return -EINVAL; 565e9be9d5eSMiklos Szeredi } 566e9be9d5eSMiklos Szeredi } 56771cbad7eShujianyang 56871cbad7eShujianyang /* Workdir is useless in non-upper mount */ 56971cbad7eShujianyang if (!config->upperdir && config->workdir) { 57071cbad7eShujianyang pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 57171cbad7eShujianyang config->workdir); 57271cbad7eShujianyang kfree(config->workdir); 57371cbad7eShujianyang config->workdir = NULL; 57471cbad7eShujianyang } 57571cbad7eShujianyang 576d5791044SVivek Goyal err = ovl_parse_redirect_mode(config, config->redirect_mode); 577d5791044SVivek Goyal if (err) 578d5791044SVivek Goyal return err; 579d5791044SVivek Goyal 580d47748e5SMiklos Szeredi /* 581d47748e5SMiklos Szeredi * This is to make the logic below simpler. It doesn't make any other 582d47748e5SMiklos Szeredi * difference, since config->redirect_dir is only used for upper. 583d47748e5SMiklos Szeredi */ 584d47748e5SMiklos Szeredi if (!config->upperdir && config->redirect_follow) 585d47748e5SMiklos Szeredi config->redirect_dir = true; 586d47748e5SMiklos Szeredi 587d47748e5SMiklos Szeredi /* Resolve metacopy -> redirect_dir dependency */ 588d47748e5SMiklos Szeredi if (config->metacopy && !config->redirect_dir) { 589d47748e5SMiklos Szeredi if (metacopy_opt && redirect_opt) { 590d47748e5SMiklos Szeredi pr_err("overlayfs: conflicting options: metacopy=on,redirect_dir=%s\n", 591d47748e5SMiklos Szeredi config->redirect_mode); 592d47748e5SMiklos Szeredi return -EINVAL; 593d47748e5SMiklos Szeredi } 594d47748e5SMiklos Szeredi if (redirect_opt) { 595d47748e5SMiklos Szeredi /* 596d47748e5SMiklos Szeredi * There was an explicit redirect_dir=... that resulted 597d47748e5SMiklos Szeredi * in this conflict. 598d47748e5SMiklos Szeredi */ 599d47748e5SMiklos Szeredi pr_info("overlayfs: disabling metacopy due to redirect_dir=%s\n", 600d47748e5SMiklos Szeredi config->redirect_mode); 601d5791044SVivek Goyal config->metacopy = false; 602d47748e5SMiklos Szeredi } else { 603d47748e5SMiklos Szeredi /* Automatically enable redirect otherwise. */ 604d47748e5SMiklos Szeredi config->redirect_follow = config->redirect_dir = true; 605d47748e5SMiklos Szeredi } 606d5791044SVivek Goyal } 607d5791044SVivek Goyal 608d5791044SVivek Goyal return 0; 609e9be9d5eSMiklos Szeredi } 610e9be9d5eSMiklos Szeredi 611e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 61202bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 613e9be9d5eSMiklos Szeredi 614ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 6156b8aa129SAmir Goldstein const char *name, bool persist) 616e9be9d5eSMiklos Szeredi { 617ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 618ad204488SMiklos Szeredi struct vfsmount *mnt = ofs->upper_mnt; 619e9be9d5eSMiklos Szeredi struct dentry *work; 620e9be9d5eSMiklos Szeredi int err; 621e9be9d5eSMiklos Szeredi bool retried = false; 6226b8aa129SAmir Goldstein bool locked = false; 623e9be9d5eSMiklos Szeredi 6245955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 6256b8aa129SAmir Goldstein locked = true; 6266b8aa129SAmir Goldstein 627e9be9d5eSMiklos Szeredi retry: 628ad204488SMiklos Szeredi work = lookup_one_len(name, ofs->workbasedir, strlen(name)); 629e9be9d5eSMiklos Szeredi 630e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 631c11b9fddSMiklos Szeredi struct iattr attr = { 632c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 63332a3d848SAl Viro .ia_mode = S_IFDIR | 0, 634c11b9fddSMiklos Szeredi }; 635e9be9d5eSMiklos Szeredi 636e9be9d5eSMiklos Szeredi if (work->d_inode) { 637e9be9d5eSMiklos Szeredi err = -EEXIST; 638e9be9d5eSMiklos Szeredi if (retried) 639e9be9d5eSMiklos Szeredi goto out_dput; 640e9be9d5eSMiklos Szeredi 6416b8aa129SAmir Goldstein if (persist) 6426b8aa129SAmir Goldstein goto out_unlock; 6436b8aa129SAmir Goldstein 644e9be9d5eSMiklos Szeredi retried = true; 645eea2fb48SMiklos Szeredi ovl_workdir_cleanup(dir, mnt, work, 0); 646e9be9d5eSMiklos Szeredi dput(work); 647e9be9d5eSMiklos Szeredi goto retry; 648e9be9d5eSMiklos Szeredi } 649e9be9d5eSMiklos Szeredi 65095a1c815SMiklos Szeredi work = ovl_create_real(dir, work, OVL_CATTR(attr.ia_mode)); 65195a1c815SMiklos Szeredi err = PTR_ERR(work); 65295a1c815SMiklos Szeredi if (IS_ERR(work)) 65395a1c815SMiklos Szeredi goto out_err; 654c11b9fddSMiklos Szeredi 655cb348edbSMiklos Szeredi /* 656cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 657cb348edbSMiklos Szeredi * 658cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 659cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 660cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 661cb348edbSMiklos Szeredi * 662cb348edbSMiklos Szeredi * There are various other error values that could effectively 663cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 664cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 665cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 666cb348edbSMiklos Szeredi * for the above two errors is sufficient. 667cb348edbSMiklos Szeredi */ 668c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 669e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 670c11b9fddSMiklos Szeredi goto out_dput; 671c11b9fddSMiklos Szeredi 672c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 673e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 674c11b9fddSMiklos Szeredi goto out_dput; 675c11b9fddSMiklos Szeredi 676c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 677c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 678c11b9fddSMiklos Szeredi err = notify_change(work, &attr, NULL); 679c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 680c11b9fddSMiklos Szeredi if (err) 681c11b9fddSMiklos Szeredi goto out_dput; 6826b8aa129SAmir Goldstein } else { 6836b8aa129SAmir Goldstein err = PTR_ERR(work); 6846b8aa129SAmir Goldstein goto out_err; 685e9be9d5eSMiklos Szeredi } 686e9be9d5eSMiklos Szeredi out_unlock: 6876b8aa129SAmir Goldstein if (locked) 6886b8aa129SAmir Goldstein inode_unlock(dir); 689e9be9d5eSMiklos Szeredi 690e9be9d5eSMiklos Szeredi return work; 691e9be9d5eSMiklos Szeredi 692e9be9d5eSMiklos Szeredi out_dput: 693e9be9d5eSMiklos Szeredi dput(work); 6946b8aa129SAmir Goldstein out_err: 6956b8aa129SAmir Goldstein pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n", 696ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 6976b8aa129SAmir Goldstein work = NULL; 698e9be9d5eSMiklos Szeredi goto out_unlock; 699e9be9d5eSMiklos Szeredi } 700e9be9d5eSMiklos Szeredi 70191c77947SMiklos Szeredi static void ovl_unescape(char *s) 70291c77947SMiklos Szeredi { 70391c77947SMiklos Szeredi char *d = s; 70491c77947SMiklos Szeredi 70591c77947SMiklos Szeredi for (;; s++, d++) { 70691c77947SMiklos Szeredi if (*s == '\\') 70791c77947SMiklos Szeredi s++; 70891c77947SMiklos Szeredi *d = *s; 70991c77947SMiklos Szeredi if (!*s) 71091c77947SMiklos Szeredi break; 71191c77947SMiklos Szeredi } 71291c77947SMiklos Szeredi } 71391c77947SMiklos Szeredi 714ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 715ab508822SMiklos Szeredi { 716a78d9f0dSMiklos Szeredi int err = -EINVAL; 717ab508822SMiklos Szeredi 718a78d9f0dSMiklos Szeredi if (!*name) { 719a78d9f0dSMiklos Szeredi pr_err("overlayfs: empty lowerdir\n"); 720a78d9f0dSMiklos Szeredi goto out; 721a78d9f0dSMiklos Szeredi } 722ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 723ab508822SMiklos Szeredi if (err) { 724ab508822SMiklos Szeredi pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); 725ab508822SMiklos Szeredi goto out; 726ab508822SMiklos Szeredi } 727ab508822SMiklos Szeredi err = -EINVAL; 7287c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 729ab508822SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported\n", name); 730ab508822SMiklos Szeredi goto out_put; 731ab508822SMiklos Szeredi } 7322b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 733ab508822SMiklos Szeredi pr_err("overlayfs: '%s' not a directory\n", name); 734ab508822SMiklos Szeredi goto out_put; 735ab508822SMiklos Szeredi } 736ab508822SMiklos Szeredi return 0; 737ab508822SMiklos Szeredi 738ab508822SMiklos Szeredi out_put: 7398aafcb59SMiklos Szeredi path_put_init(path); 740ab508822SMiklos Szeredi out: 741ab508822SMiklos Szeredi return err; 742ab508822SMiklos Szeredi } 743ab508822SMiklos Szeredi 744ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 745ab508822SMiklos Szeredi { 746ab508822SMiklos Szeredi int err = -ENOMEM; 747ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 748ab508822SMiklos Szeredi 749ab508822SMiklos Szeredi if (tmp) { 750ab508822SMiklos Szeredi ovl_unescape(tmp); 751ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 7527c03b5d4SMiklos Szeredi 7537c03b5d4SMiklos Szeredi if (!err) 7547c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) { 7557c03b5d4SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n", 7567c03b5d4SMiklos Szeredi tmp); 7578aafcb59SMiklos Szeredi path_put_init(path); 7587c03b5d4SMiklos Szeredi err = -EINVAL; 7597c03b5d4SMiklos Szeredi } 760ab508822SMiklos Szeredi kfree(tmp); 761ab508822SMiklos Szeredi } 762ab508822SMiklos Szeredi return err; 763ab508822SMiklos Szeredi } 764ab508822SMiklos Szeredi 7656b2d5fe4SMiklos Szeredi static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 7666b2d5fe4SMiklos Szeredi const char *name) 7676b2d5fe4SMiklos Szeredi { 7686b2d5fe4SMiklos Szeredi struct kstatfs statfs; 7696b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 7706b2d5fe4SMiklos Szeredi 7716b2d5fe4SMiklos Szeredi if (err) 7726b2d5fe4SMiklos Szeredi pr_err("overlayfs: statfs failed on '%s'\n", name); 7736b2d5fe4SMiklos Szeredi else 7746b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 7756b2d5fe4SMiklos Szeredi 7766b2d5fe4SMiklos Szeredi return err; 7776b2d5fe4SMiklos Szeredi } 7786b2d5fe4SMiklos Szeredi 7796b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 7806b2d5fe4SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth, bool *remote) 781ab508822SMiklos Szeredi { 782e487d889SAmir Goldstein int fh_type; 783ab508822SMiklos Szeredi int err; 784ab508822SMiklos Szeredi 785a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 786ab508822SMiklos Szeredi if (err) 787ab508822SMiklos Szeredi goto out; 788ab508822SMiklos Szeredi 7896b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 7906b2d5fe4SMiklos Szeredi if (err) 791ab508822SMiklos Szeredi goto out_put; 7926b2d5fe4SMiklos Szeredi 793ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 794ab508822SMiklos Szeredi 7957c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) 7967c03b5d4SMiklos Szeredi *remote = true; 7977c03b5d4SMiklos Szeredi 79802bcd157SAmir Goldstein /* 799f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode 800f168f109SAmir Goldstein * file handles, so they require that all layers support them. 80102bcd157SAmir Goldstein */ 802e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(path->dentry->d_sb); 803f168f109SAmir Goldstein if ((ofs->config.nfs_export || 804e487d889SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 80502bcd157SAmir Goldstein ofs->config.index = false; 806f168f109SAmir Goldstein ofs->config.nfs_export = false; 807f168f109SAmir Goldstein pr_warn("overlayfs: fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 808f168f109SAmir Goldstein name); 80902bcd157SAmir Goldstein } 81002bcd157SAmir Goldstein 811e487d889SAmir Goldstein /* Check if lower fs has 32bit inode numbers */ 812e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 813e487d889SAmir Goldstein ofs->xino_bits = 0; 814e487d889SAmir Goldstein 815ab508822SMiklos Szeredi return 0; 816ab508822SMiklos Szeredi 817ab508822SMiklos Szeredi out_put: 8188aafcb59SMiklos Szeredi path_put_init(path); 819ab508822SMiklos Szeredi out: 820ab508822SMiklos Szeredi return err; 821ab508822SMiklos Szeredi } 822ab508822SMiklos Szeredi 823e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 824e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 825e9be9d5eSMiklos Szeredi { 826e9be9d5eSMiklos Szeredi bool ok = false; 827e9be9d5eSMiklos Szeredi 828e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 829e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 830e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 831e9be9d5eSMiklos Szeredi } 832e9be9d5eSMiklos Szeredi return ok; 833e9be9d5eSMiklos Szeredi } 834e9be9d5eSMiklos Szeredi 835a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 836a78d9f0dSMiklos Szeredi { 837a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 838a78d9f0dSMiklos Szeredi char *s, *d; 839a78d9f0dSMiklos Szeredi 840a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 841a78d9f0dSMiklos Szeredi if (*s == '\\') { 842a78d9f0dSMiklos Szeredi s++; 843a78d9f0dSMiklos Szeredi } else if (*s == ':') { 844a78d9f0dSMiklos Szeredi *d = '\0'; 845a78d9f0dSMiklos Szeredi ctr++; 846a78d9f0dSMiklos Szeredi continue; 847a78d9f0dSMiklos Szeredi } 848a78d9f0dSMiklos Szeredi *d = *s; 849a78d9f0dSMiklos Szeredi if (!*s) 850a78d9f0dSMiklos Szeredi break; 851a78d9f0dSMiklos Szeredi } 852a78d9f0dSMiklos Szeredi return ctr; 853a78d9f0dSMiklos Szeredi } 854a78d9f0dSMiklos Szeredi 8550c97be22SAndreas Gruenbacher static int __maybe_unused 8560eb45fc3SAndreas Gruenbacher ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 8570eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8580eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 8590eb45fc3SAndreas Gruenbacher { 8601d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 8610eb45fc3SAndreas Gruenbacher } 8620eb45fc3SAndreas Gruenbacher 8630eb45fc3SAndreas Gruenbacher static int __maybe_unused 8640c97be22SAndreas Gruenbacher ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 865d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 866d837a49bSMiklos Szeredi const char *name, const void *value, 867d837a49bSMiklos Szeredi size_t size, int flags) 868d837a49bSMiklos Szeredi { 869d837a49bSMiklos Szeredi struct dentry *workdir = ovl_workdir(dentry); 87009d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 871d837a49bSMiklos Szeredi struct posix_acl *acl = NULL; 872d837a49bSMiklos Szeredi int err; 873d837a49bSMiklos Szeredi 874d837a49bSMiklos Szeredi /* Check that everything is OK before copy-up */ 875d837a49bSMiklos Szeredi if (value) { 876d837a49bSMiklos Szeredi acl = posix_acl_from_xattr(&init_user_ns, value, size); 877d837a49bSMiklos Szeredi if (IS_ERR(acl)) 878d837a49bSMiklos Szeredi return PTR_ERR(acl); 879d837a49bSMiklos Szeredi } 880d837a49bSMiklos Szeredi err = -EOPNOTSUPP; 881d837a49bSMiklos Szeredi if (!IS_POSIXACL(d_inode(workdir))) 882d837a49bSMiklos Szeredi goto out_acl_release; 883d837a49bSMiklos Szeredi if (!realinode->i_op->set_acl) 884d837a49bSMiklos Szeredi goto out_acl_release; 885d837a49bSMiklos Szeredi if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 886d837a49bSMiklos Szeredi err = acl ? -EACCES : 0; 887d837a49bSMiklos Szeredi goto out_acl_release; 888d837a49bSMiklos Szeredi } 889d837a49bSMiklos Szeredi err = -EPERM; 890d837a49bSMiklos Szeredi if (!inode_owner_or_capable(inode)) 891d837a49bSMiklos Szeredi goto out_acl_release; 892d837a49bSMiklos Szeredi 893d837a49bSMiklos Szeredi posix_acl_release(acl); 894d837a49bSMiklos Szeredi 895fd3220d3SMiklos Szeredi /* 896fd3220d3SMiklos Szeredi * Check if sgid bit needs to be cleared (actual setacl operation will 897fd3220d3SMiklos Szeredi * be done with mounter's capabilities and so that won't do it for us). 898fd3220d3SMiklos Szeredi */ 899fd3220d3SMiklos Szeredi if (unlikely(inode->i_mode & S_ISGID) && 900fd3220d3SMiklos Szeredi handler->flags == ACL_TYPE_ACCESS && 901fd3220d3SMiklos Szeredi !in_group_p(inode->i_gid) && 902fd3220d3SMiklos Szeredi !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 903fd3220d3SMiklos Szeredi struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 904fd3220d3SMiklos Szeredi 905fd3220d3SMiklos Szeredi err = ovl_setattr(dentry, &iattr); 906fd3220d3SMiklos Szeredi if (err) 907fd3220d3SMiklos Szeredi return err; 908fd3220d3SMiklos Szeredi } 909fd3220d3SMiklos Szeredi 9101d88f183SMiklos Szeredi err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 911ce31513aSMiklos Szeredi if (!err) 91209d8b586SMiklos Szeredi ovl_copyattr(ovl_inode_real(inode), inode); 913ce31513aSMiklos Szeredi 914ce31513aSMiklos Szeredi return err; 915d837a49bSMiklos Szeredi 916d837a49bSMiklos Szeredi out_acl_release: 917d837a49bSMiklos Szeredi posix_acl_release(acl); 918d837a49bSMiklos Szeredi return err; 919d837a49bSMiklos Szeredi } 920d837a49bSMiklos Szeredi 9210eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 9220eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9230eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 9240eb45fc3SAndreas Gruenbacher { 92548fab5d7SAmir Goldstein return -EOPNOTSUPP; 9260eb45fc3SAndreas Gruenbacher } 9270eb45fc3SAndreas Gruenbacher 928d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 929d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 930d837a49bSMiklos Szeredi const char *name, const void *value, 931d837a49bSMiklos Szeredi size_t size, int flags) 932d837a49bSMiklos Szeredi { 93348fab5d7SAmir Goldstein return -EOPNOTSUPP; 934d837a49bSMiklos Szeredi } 935d837a49bSMiklos Szeredi 9360eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 9370eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9380eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 9390eb45fc3SAndreas Gruenbacher { 9401d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 9410eb45fc3SAndreas Gruenbacher } 9420eb45fc3SAndreas Gruenbacher 9430e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 9440e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9450e585cccSAndreas Gruenbacher const char *name, const void *value, 9460e585cccSAndreas Gruenbacher size_t size, int flags) 9470e585cccSAndreas Gruenbacher { 9481d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 9490e585cccSAndreas Gruenbacher } 9500e585cccSAndreas Gruenbacher 9510c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 9520c97be22SAndreas Gruenbacher ovl_posix_acl_access_xattr_handler = { 953d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_ACCESS, 954d837a49bSMiklos Szeredi .flags = ACL_TYPE_ACCESS, 9550eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 956d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 957d837a49bSMiklos Szeredi }; 958d837a49bSMiklos Szeredi 9590c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 9600c97be22SAndreas Gruenbacher ovl_posix_acl_default_xattr_handler = { 961d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_DEFAULT, 962d837a49bSMiklos Szeredi .flags = ACL_TYPE_DEFAULT, 9630eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 964d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 965d837a49bSMiklos Szeredi }; 966d837a49bSMiklos Szeredi 967d837a49bSMiklos Szeredi static const struct xattr_handler ovl_own_xattr_handler = { 968d837a49bSMiklos Szeredi .prefix = OVL_XATTR_PREFIX, 9690eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 970d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 971d837a49bSMiklos Szeredi }; 972d837a49bSMiklos Szeredi 973d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 974d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 9750eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 976d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 977d837a49bSMiklos Szeredi }; 978d837a49bSMiklos Szeredi 979d837a49bSMiklos Szeredi static const struct xattr_handler *ovl_xattr_handlers[] = { 9800c97be22SAndreas Gruenbacher #ifdef CONFIG_FS_POSIX_ACL 981d837a49bSMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 982d837a49bSMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 9830c97be22SAndreas Gruenbacher #endif 984d837a49bSMiklos Szeredi &ovl_own_xattr_handler, 985d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 986d837a49bSMiklos Szeredi NULL 987d837a49bSMiklos Szeredi }; 988d837a49bSMiklos Szeredi 989146d62e5SAmir Goldstein static int ovl_setup_trap(struct super_block *sb, struct dentry *dir, 990146d62e5SAmir Goldstein struct inode **ptrap, const char *name) 991146d62e5SAmir Goldstein { 992146d62e5SAmir Goldstein struct inode *trap; 993146d62e5SAmir Goldstein int err; 994146d62e5SAmir Goldstein 995146d62e5SAmir Goldstein trap = ovl_get_trap_inode(sb, dir); 9961dac6f5bSArnd Bergmann err = PTR_ERR_OR_ZERO(trap); 9971dac6f5bSArnd Bergmann if (err) { 998146d62e5SAmir Goldstein if (err == -ELOOP) 999146d62e5SAmir Goldstein pr_err("overlayfs: conflicting %s path\n", name); 1000146d62e5SAmir Goldstein return err; 1001146d62e5SAmir Goldstein } 1002146d62e5SAmir Goldstein 1003146d62e5SAmir Goldstein *ptrap = trap; 1004146d62e5SAmir Goldstein return 0; 1005146d62e5SAmir Goldstein } 1006146d62e5SAmir Goldstein 10070be0bfd2SAmir Goldstein /* 10080be0bfd2SAmir Goldstein * Determine how we treat concurrent use of upperdir/workdir based on the 10090be0bfd2SAmir Goldstein * index feature. This is papering over mount leaks of container runtimes, 10100be0bfd2SAmir Goldstein * for example, an old overlay mount is leaked and now its upperdir is 10110be0bfd2SAmir Goldstein * attempted to be used as a lower layer in a new overlay mount. 10120be0bfd2SAmir Goldstein */ 10130be0bfd2SAmir Goldstein static int ovl_report_in_use(struct ovl_fs *ofs, const char *name) 10140be0bfd2SAmir Goldstein { 10150be0bfd2SAmir Goldstein if (ofs->config.index) { 10160be0bfd2SAmir Goldstein pr_err("overlayfs: %s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n", 10170be0bfd2SAmir Goldstein name); 10180be0bfd2SAmir Goldstein return -EBUSY; 10190be0bfd2SAmir Goldstein } else { 10200be0bfd2SAmir Goldstein pr_warn("overlayfs: %s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n", 10210be0bfd2SAmir Goldstein name); 10220be0bfd2SAmir Goldstein return 0; 10230be0bfd2SAmir Goldstein } 10240be0bfd2SAmir Goldstein } 10250be0bfd2SAmir Goldstein 1026146d62e5SAmir Goldstein static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs, 1027146d62e5SAmir Goldstein struct path *upperpath) 10286ee8acf0SMiklos Szeredi { 10295064975eSMiklos Szeredi struct vfsmount *upper_mnt; 10306ee8acf0SMiklos Szeredi int err; 10316ee8acf0SMiklos Szeredi 1032ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.upperdir, upperpath); 10336ee8acf0SMiklos Szeredi if (err) 10346ee8acf0SMiklos Szeredi goto out; 10356ee8acf0SMiklos Szeredi 10366ee8acf0SMiklos Szeredi /* Upper fs should not be r/o */ 10376ee8acf0SMiklos Szeredi if (sb_rdonly(upperpath->mnt->mnt_sb)) { 10386ee8acf0SMiklos Szeredi pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n"); 10396ee8acf0SMiklos Szeredi err = -EINVAL; 10406ee8acf0SMiklos Szeredi goto out; 10416ee8acf0SMiklos Szeredi } 10426ee8acf0SMiklos Szeredi 1043ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 10446ee8acf0SMiklos Szeredi if (err) 10456ee8acf0SMiklos Szeredi goto out; 10466ee8acf0SMiklos Szeredi 1047146d62e5SAmir Goldstein err = ovl_setup_trap(sb, upperpath->dentry, &ofs->upperdir_trap, 1048146d62e5SAmir Goldstein "upperdir"); 1049146d62e5SAmir Goldstein if (err) 1050146d62e5SAmir Goldstein goto out; 1051146d62e5SAmir Goldstein 10525064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 10535064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 10545064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 10555064975eSMiklos Szeredi pr_err("overlayfs: failed to clone upperpath\n"); 10565064975eSMiklos Szeredi goto out; 10575064975eSMiklos Szeredi } 10585064975eSMiklos Szeredi 10595064975eSMiklos Szeredi /* Don't inherit atime flags */ 10605064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 1061ad204488SMiklos Szeredi ofs->upper_mnt = upper_mnt; 10628c25741aSMiklos Szeredi 10638c25741aSMiklos Szeredi if (ovl_inuse_trylock(ofs->upper_mnt->mnt_root)) { 10648c25741aSMiklos Szeredi ofs->upperdir_locked = true; 10658c25741aSMiklos Szeredi } else { 10660be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "upperdir"); 10670be0bfd2SAmir Goldstein if (err) 10680be0bfd2SAmir Goldstein goto out; 10698c25741aSMiklos Szeredi } 10708c25741aSMiklos Szeredi 10716ee8acf0SMiklos Szeredi err = 0; 10726ee8acf0SMiklos Szeredi out: 10736ee8acf0SMiklos Szeredi return err; 10746ee8acf0SMiklos Szeredi } 10756ee8acf0SMiklos Szeredi 1076146d62e5SAmir Goldstein static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs, 1077146d62e5SAmir Goldstein struct path *workpath) 10788ed61dc3SMiklos Szeredi { 10792ba9d57eSAmir Goldstein struct vfsmount *mnt = ofs->upper_mnt; 10808ed61dc3SMiklos Szeredi struct dentry *temp; 1081e487d889SAmir Goldstein int fh_type; 10828ed61dc3SMiklos Szeredi int err; 10838ed61dc3SMiklos Szeredi 10842ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 10852ba9d57eSAmir Goldstein if (err) 10862ba9d57eSAmir Goldstein return err; 10872ba9d57eSAmir Goldstein 1088ad204488SMiklos Szeredi ofs->workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 1089ad204488SMiklos Szeredi if (!ofs->workdir) 10902ba9d57eSAmir Goldstein goto out; 10918ed61dc3SMiklos Szeredi 1092146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir"); 1093146d62e5SAmir Goldstein if (err) 1094146d62e5SAmir Goldstein goto out; 1095146d62e5SAmir Goldstein 10968ed61dc3SMiklos Szeredi /* 10978ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 10988ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 10998ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 11008ed61dc3SMiklos Szeredi * previous step. 11018ed61dc3SMiklos Szeredi */ 11028ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 11038ed61dc3SMiklos Szeredi if (err < 0) 11042ba9d57eSAmir Goldstein goto out; 11058ed61dc3SMiklos Szeredi 11068ed61dc3SMiklos Szeredi /* 11078ed61dc3SMiklos Szeredi * We allowed this configuration and don't want to break users over 11088ed61dc3SMiklos Szeredi * kernel upgrade. So warn instead of erroring out. 11098ed61dc3SMiklos Szeredi */ 11108ed61dc3SMiklos Szeredi if (!err) 11118ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs needs to support d_type.\n"); 11128ed61dc3SMiklos Szeredi 11138ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 1114ad204488SMiklos Szeredi temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0); 1115ad204488SMiklos Szeredi ofs->tmpfile = !IS_ERR(temp); 1116ad204488SMiklos Szeredi if (ofs->tmpfile) 11178ed61dc3SMiklos Szeredi dput(temp); 11188ed61dc3SMiklos Szeredi else 11198ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support tmpfile.\n"); 11208ed61dc3SMiklos Szeredi 11218ed61dc3SMiklos Szeredi /* 11228ed61dc3SMiklos Szeredi * Check if upper/work fs supports trusted.overlay.* xattr 11238ed61dc3SMiklos Szeredi */ 1124ad204488SMiklos Szeredi err = ovl_do_setxattr(ofs->workdir, OVL_XATTR_OPAQUE, "0", 1, 0); 11258ed61dc3SMiklos Szeredi if (err) { 1126ad204488SMiklos Szeredi ofs->noxattr = true; 1127a683737bSAmir Goldstein ofs->config.index = false; 1128d5791044SVivek Goyal ofs->config.metacopy = false; 1129d5791044SVivek Goyal pr_warn("overlayfs: upper fs does not support xattr, falling back to index=off and metacopy=off.\n"); 11302ba9d57eSAmir Goldstein err = 0; 11318ed61dc3SMiklos Szeredi } else { 1132ad204488SMiklos Szeredi vfs_removexattr(ofs->workdir, OVL_XATTR_OPAQUE); 11338ed61dc3SMiklos Szeredi } 11348ed61dc3SMiklos Szeredi 11358ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 1136e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 1137e487d889SAmir Goldstein if (ofs->config.index && !fh_type) { 1138ad204488SMiklos Szeredi ofs->config.index = false; 11398ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support file handles, falling back to index=off.\n"); 11408ed61dc3SMiklos Szeredi } 11418ed61dc3SMiklos Szeredi 1142e487d889SAmir Goldstein /* Check if upper fs has 32bit inode numbers */ 1143e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 1144e487d889SAmir Goldstein ofs->xino_bits = 0; 1145e487d889SAmir Goldstein 1146f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */ 1147f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) { 1148f168f109SAmir Goldstein pr_warn("overlayfs: NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 1149f168f109SAmir Goldstein ofs->config.nfs_export = false; 1150f168f109SAmir Goldstein } 11512ba9d57eSAmir Goldstein out: 11522ba9d57eSAmir Goldstein mnt_drop_write(mnt); 11532ba9d57eSAmir Goldstein return err; 11548ed61dc3SMiklos Szeredi } 11558ed61dc3SMiklos Szeredi 1156146d62e5SAmir Goldstein static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs, 1157146d62e5SAmir Goldstein struct path *upperpath) 1158520d7c86SMiklos Szeredi { 1159520d7c86SMiklos Szeredi int err; 1160bca44b52SMiklos Szeredi struct path workpath = { }; 1161520d7c86SMiklos Szeredi 1162ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.workdir, &workpath); 1163520d7c86SMiklos Szeredi if (err) 1164520d7c86SMiklos Szeredi goto out; 1165520d7c86SMiklos Szeredi 1166520d7c86SMiklos Szeredi err = -EINVAL; 1167bca44b52SMiklos Szeredi if (upperpath->mnt != workpath.mnt) { 1168520d7c86SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 1169520d7c86SMiklos Szeredi goto out; 1170520d7c86SMiklos Szeredi } 1171bca44b52SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 1172520d7c86SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 1173520d7c86SMiklos Szeredi goto out; 1174520d7c86SMiklos Szeredi } 1175520d7c86SMiklos Szeredi 11768c25741aSMiklos Szeredi ofs->workbasedir = dget(workpath.dentry); 11778c25741aSMiklos Szeredi 11788c25741aSMiklos Szeredi if (ovl_inuse_trylock(ofs->workbasedir)) { 1179ad204488SMiklos Szeredi ofs->workdir_locked = true; 1180520d7c86SMiklos Szeredi } else { 11810be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "workdir"); 11820be0bfd2SAmir Goldstein if (err) 11830be0bfd2SAmir Goldstein goto out; 1184520d7c86SMiklos Szeredi } 1185520d7c86SMiklos Szeredi 11860be0bfd2SAmir Goldstein err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap, 11870be0bfd2SAmir Goldstein "workdir"); 11880be0bfd2SAmir Goldstein if (err) 11890be0bfd2SAmir Goldstein goto out; 11900be0bfd2SAmir Goldstein 1191146d62e5SAmir Goldstein err = ovl_make_workdir(sb, ofs, &workpath); 1192bca44b52SMiklos Szeredi 1193520d7c86SMiklos Szeredi out: 1194bca44b52SMiklos Szeredi path_put(&workpath); 1195bca44b52SMiklos Szeredi 1196520d7c86SMiklos Szeredi return err; 1197520d7c86SMiklos Szeredi } 1198520d7c86SMiklos Szeredi 1199146d62e5SAmir Goldstein static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs, 1200146d62e5SAmir Goldstein struct ovl_entry *oe, struct path *upperpath) 1201f7e3a7d9SMiklos Szeredi { 12022ba9d57eSAmir Goldstein struct vfsmount *mnt = ofs->upper_mnt; 1203f7e3a7d9SMiklos Szeredi int err; 1204f7e3a7d9SMiklos Szeredi 12052ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 12062ba9d57eSAmir Goldstein if (err) 12072ba9d57eSAmir Goldstein return err; 12082ba9d57eSAmir Goldstein 1209f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 1210d9768076SAmir Goldstein err = ovl_verify_origin(upperpath->dentry, oe->lowerstack[0].dentry, 121105122443SAmir Goldstein true); 1212f7e3a7d9SMiklos Szeredi if (err) { 1213f7e3a7d9SMiklos Szeredi pr_err("overlayfs: failed to verify upper root origin\n"); 1214f7e3a7d9SMiklos Szeredi goto out; 1215f7e3a7d9SMiklos Szeredi } 1216f7e3a7d9SMiklos Szeredi 1217ad204488SMiklos Szeredi ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1218ad204488SMiklos Szeredi if (ofs->indexdir) { 1219146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap, 1220146d62e5SAmir Goldstein "indexdir"); 1221146d62e5SAmir Goldstein if (err) 1222146d62e5SAmir Goldstein goto out; 1223146d62e5SAmir Goldstein 1224ad1d615cSAmir Goldstein /* 1225ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir. 1226ad1d615cSAmir Goldstein * Older kernels stored upper fh in "trusted.overlay.origin" 1227ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to 1228ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr 1229ad1d615cSAmir Goldstein * "trusted.overlay.upper" to indicate that index may have 1230ad1d615cSAmir Goldstein * directory entries. 1231ad1d615cSAmir Goldstein */ 1232ad1d615cSAmir Goldstein if (ovl_check_origin_xattr(ofs->indexdir)) { 123305122443SAmir Goldstein err = ovl_verify_set_fh(ofs->indexdir, OVL_XATTR_ORIGIN, 1234ad1d615cSAmir Goldstein upperpath->dentry, true, false); 1235f7e3a7d9SMiklos Szeredi if (err) 1236ad1d615cSAmir Goldstein pr_err("overlayfs: failed to verify index dir 'origin' xattr\n"); 1237ad1d615cSAmir Goldstein } 1238ad1d615cSAmir Goldstein err = ovl_verify_upper(ofs->indexdir, upperpath->dentry, true); 1239ad1d615cSAmir Goldstein if (err) 1240ad1d615cSAmir Goldstein pr_err("overlayfs: failed to verify index dir 'upper' xattr\n"); 1241f7e3a7d9SMiklos Szeredi 1242f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 1243f7e3a7d9SMiklos Szeredi if (!err) 12441eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs); 1245f7e3a7d9SMiklos Szeredi } 1246ad204488SMiklos Szeredi if (err || !ofs->indexdir) 1247f7e3a7d9SMiklos Szeredi pr_warn("overlayfs: try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1248f7e3a7d9SMiklos Szeredi 1249f7e3a7d9SMiklos Szeredi out: 12502ba9d57eSAmir Goldstein mnt_drop_write(mnt); 1251f7e3a7d9SMiklos Szeredi return err; 1252f7e3a7d9SMiklos Szeredi } 1253f7e3a7d9SMiklos Szeredi 12549df085f3SAmir Goldstein static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid) 12555148626bSAmir Goldstein { 12565148626bSAmir Goldstein unsigned int i; 12579df085f3SAmir Goldstein 12587e63c87fSAmir Goldstein if (!ofs->config.nfs_export && !ofs->upper_mnt) 12599df085f3SAmir Goldstein return true; 12609df085f3SAmir Goldstein 12619df085f3SAmir Goldstein for (i = 0; i < ofs->numlowerfs; i++) { 12629df085f3SAmir Goldstein /* 12639df085f3SAmir Goldstein * We use uuid to associate an overlay lower file handle with a 12649df085f3SAmir Goldstein * lower layer, so we can accept lower fs with null uuid as long 12659df085f3SAmir Goldstein * as all lower layers with null uuid are on the same fs. 12667e63c87fSAmir Goldstein * if we detect multiple lower fs with the same uuid, we 12677e63c87fSAmir Goldstein * disable lower file handle decoding on all of them. 12689df085f3SAmir Goldstein */ 12697e63c87fSAmir Goldstein if (uuid_equal(&ofs->lower_fs[i].sb->s_uuid, uuid)) { 12707e63c87fSAmir Goldstein ofs->lower_fs[i].bad_uuid = true; 12719df085f3SAmir Goldstein return false; 12729df085f3SAmir Goldstein } 12737e63c87fSAmir Goldstein } 12749df085f3SAmir Goldstein return true; 12759df085f3SAmir Goldstein } 12769df085f3SAmir Goldstein 12779df085f3SAmir Goldstein /* Get a unique fsid for the layer */ 12789df085f3SAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) 12799df085f3SAmir Goldstein { 12809df085f3SAmir Goldstein struct super_block *sb = path->mnt->mnt_sb; 12819df085f3SAmir Goldstein unsigned int i; 12825148626bSAmir Goldstein dev_t dev; 12835148626bSAmir Goldstein int err; 12847e63c87fSAmir Goldstein bool bad_uuid = false; 12855148626bSAmir Goldstein 12865148626bSAmir Goldstein /* fsid 0 is reserved for upper fs even with non upper overlay */ 12875148626bSAmir Goldstein if (ofs->upper_mnt && ofs->upper_mnt->mnt_sb == sb) 12885148626bSAmir Goldstein return 0; 12895148626bSAmir Goldstein 12905148626bSAmir Goldstein for (i = 0; i < ofs->numlowerfs; i++) { 12915148626bSAmir Goldstein if (ofs->lower_fs[i].sb == sb) 12925148626bSAmir Goldstein return i + 1; 12935148626bSAmir Goldstein } 12945148626bSAmir Goldstein 12959df085f3SAmir Goldstein if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) { 12967e63c87fSAmir Goldstein bad_uuid = true; 12977e63c87fSAmir Goldstein if (ofs->config.index || ofs->config.nfs_export) { 12989df085f3SAmir Goldstein ofs->config.index = false; 12999df085f3SAmir Goldstein ofs->config.nfs_export = false; 13009df085f3SAmir Goldstein pr_warn("overlayfs: %s uuid detected in lower fs '%pd2', falling back to index=off,nfs_export=off.\n", 13017e63c87fSAmir Goldstein uuid_is_null(&sb->s_uuid) ? "null" : 13027e63c87fSAmir Goldstein "conflicting", 13039df085f3SAmir Goldstein path->dentry); 13049df085f3SAmir Goldstein } 13057e63c87fSAmir Goldstein } 13069df085f3SAmir Goldstein 13075148626bSAmir Goldstein err = get_anon_bdev(&dev); 13085148626bSAmir Goldstein if (err) { 13095148626bSAmir Goldstein pr_err("overlayfs: failed to get anonymous bdev for lowerpath\n"); 13105148626bSAmir Goldstein return err; 13115148626bSAmir Goldstein } 13125148626bSAmir Goldstein 13135148626bSAmir Goldstein ofs->lower_fs[ofs->numlowerfs].sb = sb; 13145148626bSAmir Goldstein ofs->lower_fs[ofs->numlowerfs].pseudo_dev = dev; 13157e63c87fSAmir Goldstein ofs->lower_fs[ofs->numlowerfs].bad_uuid = bad_uuid; 13165148626bSAmir Goldstein ofs->numlowerfs++; 13175148626bSAmir Goldstein 13185148626bSAmir Goldstein return ofs->numlowerfs; 13195148626bSAmir Goldstein } 13205148626bSAmir Goldstein 1321146d62e5SAmir Goldstein static int ovl_get_lower_layers(struct super_block *sb, struct ovl_fs *ofs, 1322146d62e5SAmir Goldstein struct path *stack, unsigned int numlower) 1323520d7c86SMiklos Szeredi { 1324520d7c86SMiklos Szeredi int err; 1325520d7c86SMiklos Szeredi unsigned int i; 1326520d7c86SMiklos Szeredi 1327520d7c86SMiklos Szeredi err = -ENOMEM; 1328ad204488SMiklos Szeredi ofs->lower_layers = kcalloc(numlower, sizeof(struct ovl_layer), 1329520d7c86SMiklos Szeredi GFP_KERNEL); 1330ad204488SMiklos Szeredi if (ofs->lower_layers == NULL) 1331520d7c86SMiklos Szeredi goto out; 13325148626bSAmir Goldstein 13335148626bSAmir Goldstein ofs->lower_fs = kcalloc(numlower, sizeof(struct ovl_sb), 13345148626bSAmir Goldstein GFP_KERNEL); 13355148626bSAmir Goldstein if (ofs->lower_fs == NULL) 13365148626bSAmir Goldstein goto out; 13375148626bSAmir Goldstein 1338520d7c86SMiklos Szeredi for (i = 0; i < numlower; i++) { 1339520d7c86SMiklos Szeredi struct vfsmount *mnt; 1340146d62e5SAmir Goldstein struct inode *trap; 13415148626bSAmir Goldstein int fsid; 1342520d7c86SMiklos Szeredi 13439df085f3SAmir Goldstein err = fsid = ovl_get_fsid(ofs, &stack[i]); 13445148626bSAmir Goldstein if (err < 0) 1345520d7c86SMiklos Szeredi goto out; 1346520d7c86SMiklos Szeredi 1347146d62e5SAmir Goldstein err = ovl_setup_trap(sb, stack[i].dentry, &trap, "lowerdir"); 1348146d62e5SAmir Goldstein if (err) 1349146d62e5SAmir Goldstein goto out; 1350146d62e5SAmir Goldstein 13510be0bfd2SAmir Goldstein if (ovl_is_inuse(stack[i].dentry)) { 13520be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "lowerdir"); 13530be0bfd2SAmir Goldstein if (err) 13540be0bfd2SAmir Goldstein goto out; 13550be0bfd2SAmir Goldstein } 13560be0bfd2SAmir Goldstein 1357520d7c86SMiklos Szeredi mnt = clone_private_mount(&stack[i]); 1358520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1359520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 1360520d7c86SMiklos Szeredi pr_err("overlayfs: failed to clone lowerpath\n"); 1361146d62e5SAmir Goldstein iput(trap); 1362520d7c86SMiklos Szeredi goto out; 1363520d7c86SMiklos Szeredi } 13645148626bSAmir Goldstein 1365520d7c86SMiklos Szeredi /* 1366520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1367520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1368520d7c86SMiklos Szeredi */ 1369520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1370520d7c86SMiklos Szeredi 1371146d62e5SAmir Goldstein ofs->lower_layers[ofs->numlower].trap = trap; 1372ad204488SMiklos Szeredi ofs->lower_layers[ofs->numlower].mnt = mnt; 1373d583ed7dSAmir Goldstein ofs->lower_layers[ofs->numlower].idx = i + 1; 13745148626bSAmir Goldstein ofs->lower_layers[ofs->numlower].fsid = fsid; 13755148626bSAmir Goldstein if (fsid) { 13765148626bSAmir Goldstein ofs->lower_layers[ofs->numlower].fs = 13775148626bSAmir Goldstein &ofs->lower_fs[fsid - 1]; 13785148626bSAmir Goldstein } 1379ad204488SMiklos Szeredi ofs->numlower++; 1380520d7c86SMiklos Szeredi } 1381e487d889SAmir Goldstein 1382795939a9SAmir Goldstein /* 1383795939a9SAmir Goldstein * When all layers on same fs, overlay can use real inode numbers. 1384795939a9SAmir Goldstein * With mount option "xino=on", mounter declares that there are enough 1385795939a9SAmir Goldstein * free high bits in underlying fs to hold the unique fsid. 1386795939a9SAmir Goldstein * If overlayfs does encounter underlying inodes using the high xino 1387795939a9SAmir Goldstein * bits reserved for fsid, it emits a warning and uses the original 1388795939a9SAmir Goldstein * inode number. 1389795939a9SAmir Goldstein */ 1390795939a9SAmir Goldstein if (!ofs->numlowerfs || (ofs->numlowerfs == 1 && !ofs->upper_mnt)) { 1391e487d889SAmir Goldstein ofs->xino_bits = 0; 1392795939a9SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 1393795939a9SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_ON && !ofs->xino_bits) { 1394795939a9SAmir Goldstein /* 1395795939a9SAmir Goldstein * This is a roundup of number of bits needed for numlowerfs+1 1396795939a9SAmir Goldstein * (i.e. ilog2(numlowerfs+1 - 1) + 1). fsid 0 is reserved for 1397795939a9SAmir Goldstein * upper fs even with non upper overlay. 1398795939a9SAmir Goldstein */ 1399795939a9SAmir Goldstein BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 31); 1400795939a9SAmir Goldstein ofs->xino_bits = ilog2(ofs->numlowerfs) + 1; 1401795939a9SAmir Goldstein } 1402795939a9SAmir Goldstein 1403795939a9SAmir Goldstein if (ofs->xino_bits) { 1404795939a9SAmir Goldstein pr_info("overlayfs: \"xino\" feature enabled using %d upper inode bits.\n", 1405795939a9SAmir Goldstein ofs->xino_bits); 1406795939a9SAmir Goldstein } 1407e487d889SAmir Goldstein 1408520d7c86SMiklos Szeredi err = 0; 1409520d7c86SMiklos Szeredi out: 1410520d7c86SMiklos Szeredi return err; 1411520d7c86SMiklos Szeredi } 1412520d7c86SMiklos Szeredi 14134155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1414ad204488SMiklos Szeredi struct ovl_fs *ofs) 141553dbb0b4SMiklos Szeredi { 141653dbb0b4SMiklos Szeredi int err; 141753dbb0b4SMiklos Szeredi char *lowertmp, *lower; 14184155c10aSMiklos Szeredi struct path *stack = NULL; 14194155c10aSMiklos Szeredi unsigned int stacklen, numlower = 0, i; 142053dbb0b4SMiklos Szeredi bool remote = false; 14214155c10aSMiklos Szeredi struct ovl_entry *oe; 142253dbb0b4SMiklos Szeredi 142353dbb0b4SMiklos Szeredi err = -ENOMEM; 1424ad204488SMiklos Szeredi lowertmp = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 142553dbb0b4SMiklos Szeredi if (!lowertmp) 14264155c10aSMiklos Szeredi goto out_err; 142753dbb0b4SMiklos Szeredi 142853dbb0b4SMiklos Szeredi err = -EINVAL; 142953dbb0b4SMiklos Szeredi stacklen = ovl_split_lowerdirs(lowertmp); 143053dbb0b4SMiklos Szeredi if (stacklen > OVL_MAX_STACK) { 143153dbb0b4SMiklos Szeredi pr_err("overlayfs: too many lower directories, limit is %d\n", 143253dbb0b4SMiklos Szeredi OVL_MAX_STACK); 14334155c10aSMiklos Szeredi goto out_err; 1434ad204488SMiklos Szeredi } else if (!ofs->config.upperdir && stacklen == 1) { 143553dbb0b4SMiklos Szeredi pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n"); 14364155c10aSMiklos Szeredi goto out_err; 1437f168f109SAmir Goldstein } else if (!ofs->config.upperdir && ofs->config.nfs_export && 1438f168f109SAmir Goldstein ofs->config.redirect_follow) { 1439f168f109SAmir Goldstein pr_warn("overlayfs: NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n"); 1440f168f109SAmir Goldstein ofs->config.nfs_export = false; 144153dbb0b4SMiklos Szeredi } 144253dbb0b4SMiklos Szeredi 144353dbb0b4SMiklos Szeredi err = -ENOMEM; 144453dbb0b4SMiklos Szeredi stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL); 144553dbb0b4SMiklos Szeredi if (!stack) 14464155c10aSMiklos Szeredi goto out_err; 144753dbb0b4SMiklos Szeredi 144853dbb0b4SMiklos Szeredi err = -EINVAL; 144953dbb0b4SMiklos Szeredi lower = lowertmp; 145053dbb0b4SMiklos Szeredi for (numlower = 0; numlower < stacklen; numlower++) { 1451ad204488SMiklos Szeredi err = ovl_lower_dir(lower, &stack[numlower], ofs, 145253dbb0b4SMiklos Szeredi &sb->s_stack_depth, &remote); 145353dbb0b4SMiklos Szeredi if (err) 14544155c10aSMiklos Szeredi goto out_err; 145553dbb0b4SMiklos Szeredi 145653dbb0b4SMiklos Szeredi lower = strchr(lower, '\0') + 1; 145753dbb0b4SMiklos Szeredi } 145853dbb0b4SMiklos Szeredi 145953dbb0b4SMiklos Szeredi err = -EINVAL; 146053dbb0b4SMiklos Szeredi sb->s_stack_depth++; 146153dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 146253dbb0b4SMiklos Szeredi pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 14634155c10aSMiklos Szeredi goto out_err; 146453dbb0b4SMiklos Szeredi } 146553dbb0b4SMiklos Szeredi 1466146d62e5SAmir Goldstein err = ovl_get_lower_layers(sb, ofs, stack, numlower); 14674155c10aSMiklos Szeredi if (err) 14684155c10aSMiklos Szeredi goto out_err; 14694155c10aSMiklos Szeredi 14704155c10aSMiklos Szeredi err = -ENOMEM; 14714155c10aSMiklos Szeredi oe = ovl_alloc_entry(numlower); 14724155c10aSMiklos Szeredi if (!oe) 14734155c10aSMiklos Szeredi goto out_err; 14744155c10aSMiklos Szeredi 14754155c10aSMiklos Szeredi for (i = 0; i < numlower; i++) { 14764155c10aSMiklos Szeredi oe->lowerstack[i].dentry = dget(stack[i].dentry); 1477ad204488SMiklos Szeredi oe->lowerstack[i].layer = &ofs->lower_layers[i]; 14784155c10aSMiklos Szeredi } 147953dbb0b4SMiklos Szeredi 148053dbb0b4SMiklos Szeredi if (remote) 148153dbb0b4SMiklos Szeredi sb->s_d_op = &ovl_reval_dentry_operations; 148253dbb0b4SMiklos Szeredi else 148353dbb0b4SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 148453dbb0b4SMiklos Szeredi 148553dbb0b4SMiklos Szeredi out: 148653dbb0b4SMiklos Szeredi for (i = 0; i < numlower; i++) 148753dbb0b4SMiklos Szeredi path_put(&stack[i]); 148853dbb0b4SMiklos Szeredi kfree(stack); 14894155c10aSMiklos Szeredi kfree(lowertmp); 14904155c10aSMiklos Szeredi 14914155c10aSMiklos Szeredi return oe; 14924155c10aSMiklos Szeredi 14934155c10aSMiklos Szeredi out_err: 14944155c10aSMiklos Szeredi oe = ERR_PTR(err); 149553dbb0b4SMiklos Szeredi goto out; 149653dbb0b4SMiklos Szeredi } 149753dbb0b4SMiklos Szeredi 1498146d62e5SAmir Goldstein /* 1499146d62e5SAmir Goldstein * Check if this layer root is a descendant of: 1500146d62e5SAmir Goldstein * - another layer of this overlayfs instance 1501146d62e5SAmir Goldstein * - upper/work dir of any overlayfs instance 1502146d62e5SAmir Goldstein */ 15030be0bfd2SAmir Goldstein static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs, 15040be0bfd2SAmir Goldstein struct dentry *dentry, const char *name) 1505146d62e5SAmir Goldstein { 15069179c21dSMiklos Szeredi struct dentry *next = dentry, *parent; 1507146d62e5SAmir Goldstein int err = 0; 1508146d62e5SAmir Goldstein 15099179c21dSMiklos Szeredi if (!dentry) 1510146d62e5SAmir Goldstein return 0; 1511146d62e5SAmir Goldstein 1512146d62e5SAmir Goldstein parent = dget_parent(next); 15139179c21dSMiklos Szeredi 15149179c21dSMiklos Szeredi /* Walk back ancestors to root (inclusive) looking for traps */ 15159179c21dSMiklos Szeredi while (!err && parent != next) { 15160be0bfd2SAmir Goldstein if (ovl_lookup_trap_inode(sb, parent)) { 1517146d62e5SAmir Goldstein err = -ELOOP; 1518146d62e5SAmir Goldstein pr_err("overlayfs: overlapping %s path\n", name); 15190be0bfd2SAmir Goldstein } else if (ovl_is_inuse(parent)) { 15200be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, name); 1521146d62e5SAmir Goldstein } 1522146d62e5SAmir Goldstein next = parent; 15239179c21dSMiklos Szeredi parent = dget_parent(next); 15249179c21dSMiklos Szeredi dput(next); 1525146d62e5SAmir Goldstein } 1526146d62e5SAmir Goldstein 15279179c21dSMiklos Szeredi dput(parent); 1528146d62e5SAmir Goldstein 1529146d62e5SAmir Goldstein return err; 1530146d62e5SAmir Goldstein } 1531146d62e5SAmir Goldstein 1532146d62e5SAmir Goldstein /* 1533146d62e5SAmir Goldstein * Check if any of the layers or work dirs overlap. 1534146d62e5SAmir Goldstein */ 1535146d62e5SAmir Goldstein static int ovl_check_overlapping_layers(struct super_block *sb, 1536146d62e5SAmir Goldstein struct ovl_fs *ofs) 1537146d62e5SAmir Goldstein { 1538146d62e5SAmir Goldstein int i, err; 1539146d62e5SAmir Goldstein 1540146d62e5SAmir Goldstein if (ofs->upper_mnt) { 15410be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, ofs->upper_mnt->mnt_root, 15420be0bfd2SAmir Goldstein "upperdir"); 1543146d62e5SAmir Goldstein if (err) 1544146d62e5SAmir Goldstein return err; 1545146d62e5SAmir Goldstein 1546146d62e5SAmir Goldstein /* 1547146d62e5SAmir Goldstein * Checking workbasedir avoids hitting ovl_is_inuse(parent) of 1548146d62e5SAmir Goldstein * this instance and covers overlapping work and index dirs, 1549146d62e5SAmir Goldstein * unless work or index dir have been moved since created inside 1550146d62e5SAmir Goldstein * workbasedir. In that case, we already have their traps in 1551146d62e5SAmir Goldstein * inode cache and we will catch that case on lookup. 1552146d62e5SAmir Goldstein */ 15530be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir"); 1554146d62e5SAmir Goldstein if (err) 1555146d62e5SAmir Goldstein return err; 1556146d62e5SAmir Goldstein } 1557146d62e5SAmir Goldstein 1558146d62e5SAmir Goldstein for (i = 0; i < ofs->numlower; i++) { 15590be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, 15600be0bfd2SAmir Goldstein ofs->lower_layers[i].mnt->mnt_root, 1561146d62e5SAmir Goldstein "lowerdir"); 1562146d62e5SAmir Goldstein if (err) 1563146d62e5SAmir Goldstein return err; 1564146d62e5SAmir Goldstein } 1565146d62e5SAmir Goldstein 1566146d62e5SAmir Goldstein return 0; 1567146d62e5SAmir Goldstein } 1568146d62e5SAmir Goldstein 1569e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1570e9be9d5eSMiklos Szeredi { 157133006cdfSKees Cook struct path upperpath = { }; 1572e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 15734155c10aSMiklos Szeredi struct ovl_entry *oe; 1574ad204488SMiklos Szeredi struct ovl_fs *ofs; 157551f8f3c4SKonstantin Khlebnikov struct cred *cred; 1576e9be9d5eSMiklos Szeredi int err; 1577e9be9d5eSMiklos Szeredi 1578f45827e8SErez Zadok err = -ENOMEM; 1579ad204488SMiklos Szeredi ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1580ad204488SMiklos Szeredi if (!ofs) 1581e9be9d5eSMiklos Szeredi goto out; 1582e9be9d5eSMiklos Szeredi 1583ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1584c6fe6254SMiklos Szeredi if (!cred) 1585c6fe6254SMiklos Szeredi goto out_err; 1586c6fe6254SMiklos Szeredi 1587ad204488SMiklos Szeredi ofs->config.index = ovl_index_def; 1588f168f109SAmir Goldstein ofs->config.nfs_export = ovl_nfs_export_def; 1589795939a9SAmir Goldstein ofs->config.xino = ovl_xino_def(); 1590d5791044SVivek Goyal ofs->config.metacopy = ovl_metacopy_def; 1591ad204488SMiklos Szeredi err = ovl_parse_opt((char *) data, &ofs->config); 1592f45827e8SErez Zadok if (err) 1593a9075cdbSMiklos Szeredi goto out_err; 1594f45827e8SErez Zadok 1595e9be9d5eSMiklos Szeredi err = -EINVAL; 1596ad204488SMiklos Szeredi if (!ofs->config.lowerdir) { 159707f2af7bSKonstantin Khlebnikov if (!silent) 159853a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'lowerdir'\n"); 1599a9075cdbSMiklos Szeredi goto out_err; 160053a08cb9SMiklos Szeredi } 160153a08cb9SMiklos Szeredi 160253a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 1603cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 1604e487d889SAmir Goldstein /* Assume underlaying fs uses 32bit inodes unless proven otherwise */ 1605795939a9SAmir Goldstein if (ofs->config.xino != OVL_XINO_OFF) 1606e487d889SAmir Goldstein ofs->xino_bits = BITS_PER_LONG - 32; 1607795939a9SAmir Goldstein 1608146d62e5SAmir Goldstein /* alloc/destroy_inode needed for setting up traps in inode cache */ 1609146d62e5SAmir Goldstein sb->s_op = &ovl_super_operations; 1610146d62e5SAmir Goldstein 1611ad204488SMiklos Szeredi if (ofs->config.upperdir) { 1612ad204488SMiklos Szeredi if (!ofs->config.workdir) { 161353a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'workdir'\n"); 1614a9075cdbSMiklos Szeredi goto out_err; 1615e9be9d5eSMiklos Szeredi } 1616e9be9d5eSMiklos Szeredi 1617146d62e5SAmir Goldstein err = ovl_get_upper(sb, ofs, &upperpath); 161821a3b317SMiklos Szeredi if (err) 1619a9075cdbSMiklos Szeredi goto out_err; 1620d719e8f2SMiklos Szeredi 1621146d62e5SAmir Goldstein err = ovl_get_workdir(sb, ofs, &upperpath); 16228ed61dc3SMiklos Szeredi if (err) 1623a9075cdbSMiklos Szeredi goto out_err; 1624c6fe6254SMiklos Szeredi 1625ad204488SMiklos Szeredi if (!ofs->workdir) 16261751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 16276e88256eSMiklos Szeredi 1628ad204488SMiklos Szeredi sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth; 1629ad204488SMiklos Szeredi sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran; 1630c6fe6254SMiklos Szeredi 163121765194SVivek Goyal } 1632ad204488SMiklos Szeredi oe = ovl_get_lowerstack(sb, ofs); 16334155c10aSMiklos Szeredi err = PTR_ERR(oe); 16344155c10aSMiklos Szeredi if (IS_ERR(oe)) 1635a9075cdbSMiklos Szeredi goto out_err; 1636e9be9d5eSMiklos Szeredi 163771cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 1638ad204488SMiklos Szeredi if (!ofs->upper_mnt) 16391751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 1640e9be9d5eSMiklos Szeredi 1641ad204488SMiklos Szeredi if (!(ovl_force_readonly(ofs)) && ofs->config.index) { 1642146d62e5SAmir Goldstein err = ovl_get_indexdir(sb, ofs, oe, &upperpath); 164354fb347eSAmir Goldstein if (err) 16444155c10aSMiklos Szeredi goto out_free_oe; 16456e88256eSMiklos Szeredi 1646972d0093SAmir Goldstein /* Force r/o mount with no index dir */ 1647972d0093SAmir Goldstein if (!ofs->indexdir) { 1648972d0093SAmir Goldstein dput(ofs->workdir); 1649972d0093SAmir Goldstein ofs->workdir = NULL; 16501751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 165102bcd157SAmir Goldstein } 165202bcd157SAmir Goldstein 1653972d0093SAmir Goldstein } 1654972d0093SAmir Goldstein 1655146d62e5SAmir Goldstein err = ovl_check_overlapping_layers(sb, ofs); 1656146d62e5SAmir Goldstein if (err) 1657146d62e5SAmir Goldstein goto out_free_oe; 1658146d62e5SAmir Goldstein 1659972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */ 1660f168f109SAmir Goldstein if (!ofs->indexdir) { 1661ad204488SMiklos Szeredi ofs->config.index = false; 1662f168f109SAmir Goldstein if (ofs->upper_mnt && ofs->config.nfs_export) { 1663f168f109SAmir Goldstein pr_warn("overlayfs: NFS export requires an index dir, falling back to nfs_export=off.\n"); 1664f168f109SAmir Goldstein ofs->config.nfs_export = false; 1665f168f109SAmir Goldstein } 1666f168f109SAmir Goldstein } 166702bcd157SAmir Goldstein 1668d5791044SVivek Goyal if (ofs->config.metacopy && ofs->config.nfs_export) { 1669d5791044SVivek Goyal pr_warn("overlayfs: NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 1670d5791044SVivek Goyal ofs->config.nfs_export = false; 1671d5791044SVivek Goyal } 1672d5791044SVivek Goyal 16738383f174SAmir Goldstein if (ofs->config.nfs_export) 16748383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations; 16758383f174SAmir Goldstein 167651f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 167751f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 167851f8f3c4SKonstantin Khlebnikov 1679655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1680655042ccSVivek Goyal sb->s_xattr = ovl_xattr_handlers; 1681ad204488SMiklos Szeredi sb->s_fs_info = ofs; 1682de2a4a50SMiklos Szeredi sb->s_flags |= SB_POSIXACL; 1683655042ccSVivek Goyal 1684c6fe6254SMiklos Szeredi err = -ENOMEM; 1685ca4c8a3aSMiklos Szeredi root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 1686e9be9d5eSMiklos Szeredi if (!root_dentry) 16874155c10aSMiklos Szeredi goto out_free_oe; 1688e9be9d5eSMiklos Szeredi 1689c62520a8SAmir Goldstein root_dentry->d_fsdata = oe; 1690c62520a8SAmir Goldstein 1691e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 1692f3a15685SAmir Goldstein if (upperpath.dentry) { 1693c62520a8SAmir Goldstein ovl_dentry_set_upper_alias(root_dentry); 169413c72075SMiklos Szeredi if (ovl_is_impuredir(upperpath.dentry)) 169513c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, d_inode(root_dentry)); 1696f3a15685SAmir Goldstein } 1697e9be9d5eSMiklos Szeredi 1698b79e05aaSAmir Goldstein /* Root is always merge -> can have whiteouts */ 1699b79e05aaSAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root_dentry)); 17002ca3c148SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root_dentry); 17010c288874SVivek Goyal ovl_set_upperdata(d_inode(root_dentry)); 170209d8b586SMiklos Szeredi ovl_inode_init(d_inode(root_dentry), upperpath.dentry, 17032664bd08SVivek Goyal ovl_dentry_lower(root_dentry), NULL); 1704ed06e069SMiklos Szeredi 1705e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1706e9be9d5eSMiklos Szeredi 1707e9be9d5eSMiklos Szeredi return 0; 1708e9be9d5eSMiklos Szeredi 17094155c10aSMiklos Szeredi out_free_oe: 17104155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 1711b9343632SChandan Rajendra kfree(oe); 17124155c10aSMiklos Szeredi out_err: 1713e9be9d5eSMiklos Szeredi path_put(&upperpath); 1714ad204488SMiklos Szeredi ovl_free_fs(ofs); 1715e9be9d5eSMiklos Szeredi out: 1716e9be9d5eSMiklos Szeredi return err; 1717e9be9d5eSMiklos Szeredi } 1718e9be9d5eSMiklos Szeredi 1719e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 1720e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 1721e9be9d5eSMiklos Szeredi { 1722e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 1723e9be9d5eSMiklos Szeredi } 1724e9be9d5eSMiklos Szeredi 1725e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 1726e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1727ef94b186SMiklos Szeredi .name = "overlay", 1728e9be9d5eSMiklos Szeredi .mount = ovl_mount, 1729e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 1730e9be9d5eSMiklos Szeredi }; 1731ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 1732e9be9d5eSMiklos Szeredi 173313cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 173413cf199dSAmir Goldstein { 173513cf199dSAmir Goldstein struct ovl_inode *oi = foo; 173613cf199dSAmir Goldstein 173713cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 173813cf199dSAmir Goldstein } 173913cf199dSAmir Goldstein 1740e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 1741e9be9d5eSMiklos Szeredi { 174213cf199dSAmir Goldstein int err; 174313cf199dSAmir Goldstein 174413cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 174513cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 174613cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 174713cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 174813cf199dSAmir Goldstein ovl_inode_init_once); 174913cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 175013cf199dSAmir Goldstein return -ENOMEM; 175113cf199dSAmir Goldstein 175213cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 175313cf199dSAmir Goldstein if (err) 175413cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 175513cf199dSAmir Goldstein 175613cf199dSAmir Goldstein return err; 1757e9be9d5eSMiklos Szeredi } 1758e9be9d5eSMiklos Szeredi 1759e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1760e9be9d5eSMiklos Szeredi { 1761e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 176213cf199dSAmir Goldstein 176313cf199dSAmir Goldstein /* 176413cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 176513cf199dSAmir Goldstein * destroy cache. 176613cf199dSAmir Goldstein */ 176713cf199dSAmir Goldstein rcu_barrier(); 176813cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 176913cf199dSAmir Goldstein 1770e9be9d5eSMiklos Szeredi } 1771e9be9d5eSMiklos Szeredi 1772e9be9d5eSMiklos Szeredi module_init(ovl_init); 1773e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1774