1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2e9be9d5eSMiklos Szeredi /* 3e9be9d5eSMiklos Szeredi * 4e9be9d5eSMiklos Szeredi * Copyright (C) 2011 Novell Inc. 5e9be9d5eSMiklos Szeredi */ 6e9be9d5eSMiklos Szeredi 75b825c3aSIngo Molnar #include <uapi/linux/magic.h> 8e9be9d5eSMiklos Szeredi #include <linux/fs.h> 9e9be9d5eSMiklos Szeredi #include <linux/namei.h> 10e9be9d5eSMiklos Szeredi #include <linux/xattr.h> 11e9be9d5eSMiklos Szeredi #include <linux/mount.h> 12e9be9d5eSMiklos Szeredi #include <linux/parser.h> 13e9be9d5eSMiklos Szeredi #include <linux/module.h> 14cc259639SAndy Whitcroft #include <linux/statfs.h> 15f45827e8SErez Zadok #include <linux/seq_file.h> 16d837a49bSMiklos Szeredi #include <linux/posix_acl_xattr.h> 17e487d889SAmir Goldstein #include <linux/exportfs.h> 18e9be9d5eSMiklos Szeredi #include "overlayfs.h" 19e9be9d5eSMiklos Szeredi 20e9be9d5eSMiklos Szeredi MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 21e9be9d5eSMiklos Szeredi MODULE_DESCRIPTION("Overlay filesystem"); 22e9be9d5eSMiklos Szeredi MODULE_LICENSE("GPL"); 23e9be9d5eSMiklos Szeredi 24e9be9d5eSMiklos Szeredi 25e9be9d5eSMiklos Szeredi struct ovl_dir_cache; 26e9be9d5eSMiklos Szeredi 27a78d9f0dSMiklos Szeredi #define OVL_MAX_STACK 500 28a78d9f0dSMiklos Szeredi 29688ea0e5SMiklos Szeredi static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR); 30688ea0e5SMiklos Szeredi module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644); 31253e7483SNicolas Schier MODULE_PARM_DESC(redirect_dir, 32688ea0e5SMiklos Szeredi "Default to on or off for the redirect_dir feature"); 33e9be9d5eSMiklos Szeredi 34438c84c2SMiklos Szeredi static bool ovl_redirect_always_follow = 35438c84c2SMiklos Szeredi IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW); 36438c84c2SMiklos Szeredi module_param_named(redirect_always_follow, ovl_redirect_always_follow, 37438c84c2SMiklos Szeredi bool, 0644); 38253e7483SNicolas Schier MODULE_PARM_DESC(redirect_always_follow, 39438c84c2SMiklos Szeredi "Follow redirects even if redirect_dir feature is turned off"); 40438c84c2SMiklos Szeredi 4102bcd157SAmir Goldstein static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX); 4202bcd157SAmir Goldstein module_param_named(index, ovl_index_def, bool, 0644); 43253e7483SNicolas Schier MODULE_PARM_DESC(index, 4402bcd157SAmir Goldstein "Default to on or off for the inodes index feature"); 4502bcd157SAmir Goldstein 46f168f109SAmir Goldstein static bool ovl_nfs_export_def = IS_ENABLED(CONFIG_OVERLAY_FS_NFS_EXPORT); 47f168f109SAmir Goldstein module_param_named(nfs_export, ovl_nfs_export_def, bool, 0644); 48253e7483SNicolas Schier MODULE_PARM_DESC(nfs_export, 49f168f109SAmir Goldstein "Default to on or off for the NFS export feature"); 50f168f109SAmir Goldstein 51795939a9SAmir Goldstein static bool ovl_xino_auto_def = IS_ENABLED(CONFIG_OVERLAY_FS_XINO_AUTO); 52795939a9SAmir Goldstein module_param_named(xino_auto, ovl_xino_auto_def, bool, 0644); 53253e7483SNicolas Schier MODULE_PARM_DESC(xino_auto, 54795939a9SAmir Goldstein "Auto enable xino feature"); 55795939a9SAmir Goldstein 564155c10aSMiklos Szeredi static void ovl_entry_stack_free(struct ovl_entry *oe) 574155c10aSMiklos Szeredi { 584155c10aSMiklos Szeredi unsigned int i; 594155c10aSMiklos Szeredi 604155c10aSMiklos Szeredi for (i = 0; i < oe->numlower; i++) 614155c10aSMiklos Szeredi dput(oe->lowerstack[i].dentry); 624155c10aSMiklos Szeredi } 634155c10aSMiklos Szeredi 64d5791044SVivek Goyal static bool ovl_metacopy_def = IS_ENABLED(CONFIG_OVERLAY_FS_METACOPY); 65d5791044SVivek Goyal module_param_named(metacopy, ovl_metacopy_def, bool, 0644); 66253e7483SNicolas Schier MODULE_PARM_DESC(metacopy, 67d5791044SVivek Goyal "Default to on or off for the metadata only copy up feature"); 68d5791044SVivek Goyal 69e9be9d5eSMiklos Szeredi static void ovl_dentry_release(struct dentry *dentry) 70e9be9d5eSMiklos Szeredi { 71e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 72e9be9d5eSMiklos Szeredi 73e9be9d5eSMiklos Szeredi if (oe) { 744155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 75e9be9d5eSMiklos Szeredi kfree_rcu(oe, rcu); 76e9be9d5eSMiklos Szeredi } 77e9be9d5eSMiklos Szeredi } 78e9be9d5eSMiklos Szeredi 792d902671SMiklos Szeredi static struct dentry *ovl_d_real(struct dentry *dentry, 80fb16043bSMiklos Szeredi const struct inode *inode) 81d101a125SMiklos Szeredi { 82cef4cbffSMiklos Szeredi struct dentry *real = NULL, *lower; 83d101a125SMiklos Szeredi 84e8c985baSMiklos Szeredi /* It's an overlay file */ 85e8c985baSMiklos Szeredi if (inode && d_inode(dentry) == inode) 86e8c985baSMiklos Szeredi return dentry; 87e8c985baSMiklos Szeredi 88ca4c8a3aSMiklos Szeredi if (!d_is_reg(dentry)) { 89d101a125SMiklos Szeredi if (!inode || inode == d_inode(dentry)) 90d101a125SMiklos Szeredi return dentry; 91d101a125SMiklos Szeredi goto bug; 92d101a125SMiklos Szeredi } 93d101a125SMiklos Szeredi 94d101a125SMiklos Szeredi real = ovl_dentry_upper(dentry); 952c3d7358SVivek Goyal if (real && (inode == d_inode(real))) 96d101a125SMiklos Szeredi return real; 97d101a125SMiklos Szeredi 982c3d7358SVivek Goyal if (real && !inode && ovl_has_upperdata(d_inode(dentry))) 992c3d7358SVivek Goyal return real; 1002c3d7358SVivek Goyal 101cef4cbffSMiklos Szeredi lower = ovl_dentry_lowerdata(dentry); 102cef4cbffSMiklos Szeredi if (!lower) 103d101a125SMiklos Szeredi goto bug; 104cef4cbffSMiklos Szeredi real = lower; 105d101a125SMiklos Szeredi 106c4fcfc16SMiklos Szeredi /* Handle recursion */ 107fb16043bSMiklos Szeredi real = d_real(real, inode); 108c4fcfc16SMiklos Szeredi 109d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 110d101a125SMiklos Szeredi return real; 111d101a125SMiklos Szeredi bug: 112cef4cbffSMiklos Szeredi WARN(1, "%s(%pd4, %s:%lu): real dentry (%p/%lu) not found\n", 113cef4cbffSMiklos Szeredi __func__, dentry, inode ? inode->i_sb->s_id : "NULL", 114cef4cbffSMiklos Szeredi inode ? inode->i_ino : 0, real, 115cef4cbffSMiklos Szeredi real && d_inode(real) ? d_inode(real)->i_ino : 0); 116d101a125SMiklos Szeredi return dentry; 117d101a125SMiklos Szeredi } 118d101a125SMiklos Szeredi 1193bb7df92SMiklos Szeredi static int ovl_revalidate_real(struct dentry *d, unsigned int flags, bool weak) 1203bb7df92SMiklos Szeredi { 1213bb7df92SMiklos Szeredi int ret = 1; 1223bb7df92SMiklos Szeredi 1233bb7df92SMiklos Szeredi if (weak) { 1243bb7df92SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) 1253bb7df92SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1263bb7df92SMiklos Szeredi } else if (d->d_flags & DCACHE_OP_REVALIDATE) { 1273bb7df92SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1283bb7df92SMiklos Szeredi if (!ret) { 1293bb7df92SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1303bb7df92SMiklos Szeredi d_invalidate(d); 1313bb7df92SMiklos Szeredi ret = -ESTALE; 1323bb7df92SMiklos Szeredi } 1333bb7df92SMiklos Szeredi } 1343bb7df92SMiklos Szeredi return ret; 1353bb7df92SMiklos Szeredi } 1363bb7df92SMiklos Szeredi 1373bb7df92SMiklos Szeredi static int ovl_dentry_revalidate_common(struct dentry *dentry, 1383bb7df92SMiklos Szeredi unsigned int flags, bool weak) 1397c03b5d4SMiklos Szeredi { 1407c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 141bccece1eSMiklos Szeredi struct dentry *upper; 1427c03b5d4SMiklos Szeredi unsigned int i; 1437c03b5d4SMiklos Szeredi int ret = 1; 1447c03b5d4SMiklos Szeredi 145bccece1eSMiklos Szeredi upper = ovl_dentry_upper(dentry); 146bccece1eSMiklos Szeredi if (upper) 147bccece1eSMiklos Szeredi ret = ovl_revalidate_real(upper, flags, weak); 148bccece1eSMiklos Szeredi 1493bb7df92SMiklos Szeredi for (i = 0; ret > 0 && i < oe->numlower; i++) { 1503bb7df92SMiklos Szeredi ret = ovl_revalidate_real(oe->lowerstack[i].dentry, flags, 1513bb7df92SMiklos Szeredi weak); 1523bb7df92SMiklos Szeredi } 1537c03b5d4SMiklos Szeredi return ret; 1547c03b5d4SMiklos Szeredi } 1553bb7df92SMiklos Szeredi 1563bb7df92SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 1573bb7df92SMiklos Szeredi { 1583bb7df92SMiklos Szeredi return ovl_dentry_revalidate_common(dentry, flags, false); 1597c03b5d4SMiklos Szeredi } 1607c03b5d4SMiklos Szeredi 1617c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 1627c03b5d4SMiklos Szeredi { 1633bb7df92SMiklos Szeredi return ovl_dentry_revalidate_common(dentry, flags, true); 1647c03b5d4SMiklos Szeredi } 1657c03b5d4SMiklos Szeredi 166e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 167e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 168d101a125SMiklos Szeredi .d_real = ovl_d_real, 1697c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1707c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1717c03b5d4SMiklos Szeredi }; 1727c03b5d4SMiklos Szeredi 17313cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 17413cf199dSAmir Goldstein 17513cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 17613cf199dSAmir Goldstein { 17713cf199dSAmir Goldstein struct ovl_inode *oi = kmem_cache_alloc(ovl_inode_cachep, GFP_KERNEL); 17813cf199dSAmir Goldstein 179b3885bd6SHirofumi Nakagawa if (!oi) 180b3885bd6SHirofumi Nakagawa return NULL; 181b3885bd6SHirofumi Nakagawa 18204a01ac7SMiklos Szeredi oi->cache = NULL; 183cf31c463SMiklos Szeredi oi->redirect = NULL; 18404a01ac7SMiklos Szeredi oi->version = 0; 18513c72075SMiklos Szeredi oi->flags = 0; 18609d8b586SMiklos Szeredi oi->__upperdentry = NULL; 18725b7713aSMiklos Szeredi oi->lower = NULL; 1882664bd08SVivek Goyal oi->lowerdata = NULL; 189a015dafcSAmir Goldstein mutex_init(&oi->lock); 19025b7713aSMiklos Szeredi 19113cf199dSAmir Goldstein return &oi->vfs_inode; 19213cf199dSAmir Goldstein } 19313cf199dSAmir Goldstein 1940b269dedSAl Viro static void ovl_free_inode(struct inode *inode) 19513cf199dSAmir Goldstein { 1960b269dedSAl Viro struct ovl_inode *oi = OVL_I(inode); 19713cf199dSAmir Goldstein 1980b269dedSAl Viro kfree(oi->redirect); 1990b269dedSAl Viro mutex_destroy(&oi->lock); 2000b269dedSAl Viro kmem_cache_free(ovl_inode_cachep, oi); 20113cf199dSAmir Goldstein } 20213cf199dSAmir Goldstein 20313cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 20413cf199dSAmir Goldstein { 20509d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 20609d8b586SMiklos Szeredi 20709d8b586SMiklos Szeredi dput(oi->__upperdentry); 20831747edaSAmir Goldstein iput(oi->lower); 2092664bd08SVivek Goyal if (S_ISDIR(inode->i_mode)) 2104edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 2112664bd08SVivek Goyal else 2122664bd08SVivek Goyal iput(oi->lowerdata); 21313cf199dSAmir Goldstein } 21413cf199dSAmir Goldstein 215ad204488SMiklos Szeredi static void ovl_free_fs(struct ovl_fs *ofs) 216e9be9d5eSMiklos Szeredi { 217df820f8dSMiklos Szeredi struct vfsmount **mounts; 218dd662667SMiklos Szeredi unsigned i; 219e9be9d5eSMiklos Szeredi 2200be0bfd2SAmir Goldstein iput(ofs->workbasedir_trap); 221146d62e5SAmir Goldstein iput(ofs->indexdir_trap); 222146d62e5SAmir Goldstein iput(ofs->workdir_trap); 223c21c839bSChengguang Xu dput(ofs->whiteout); 224ad204488SMiklos Szeredi dput(ofs->indexdir); 225ad204488SMiklos Szeredi dput(ofs->workdir); 226ad204488SMiklos Szeredi if (ofs->workdir_locked) 227ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->workbasedir); 228ad204488SMiklos Szeredi dput(ofs->workbasedir); 229ad204488SMiklos Szeredi if (ofs->upperdir_locked) 23008f4c7c8SMiklos Szeredi ovl_inuse_unlock(ovl_upper_mnt(ofs)->mnt_root); 231df820f8dSMiklos Szeredi 232df820f8dSMiklos Szeredi /* Hack! Reuse ofs->layers as a vfsmount array before freeing it */ 233df820f8dSMiklos Szeredi mounts = (struct vfsmount **) ofs->layers; 234b8e42a65SMiklos Szeredi for (i = 0; i < ofs->numlayer; i++) { 23594375f9dSAmir Goldstein iput(ofs->layers[i].trap); 236df820f8dSMiklos Szeredi mounts[i] = ofs->layers[i].mnt; 237146d62e5SAmir Goldstein } 238df820f8dSMiklos Szeredi kern_unmount_array(mounts, ofs->numlayer); 23994375f9dSAmir Goldstein kfree(ofs->layers); 240b7bf9908SAmir Goldstein for (i = 0; i < ofs->numfs; i++) 24107f1e596SAmir Goldstein free_anon_bdev(ofs->fs[i].pseudo_dev); 24207f1e596SAmir Goldstein kfree(ofs->fs); 243e9be9d5eSMiklos Szeredi 244ad204488SMiklos Szeredi kfree(ofs->config.lowerdir); 245ad204488SMiklos Szeredi kfree(ofs->config.upperdir); 246ad204488SMiklos Szeredi kfree(ofs->config.workdir); 247438c84c2SMiklos Szeredi kfree(ofs->config.redirect_mode); 248ad204488SMiklos Szeredi if (ofs->creator_cred) 249ad204488SMiklos Szeredi put_cred(ofs->creator_cred); 250ad204488SMiklos Szeredi kfree(ofs); 251e9be9d5eSMiklos Szeredi } 252e9be9d5eSMiklos Szeredi 253a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 254a9075cdbSMiklos Szeredi { 255a9075cdbSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 256a9075cdbSMiklos Szeredi 257a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 258a9075cdbSMiklos Szeredi } 259a9075cdbSMiklos Szeredi 260e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */ 261e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 262e593b2bfSAmir Goldstein { 263ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 264e593b2bfSAmir Goldstein struct super_block *upper_sb; 265e593b2bfSAmir Goldstein int ret; 266e593b2bfSAmir Goldstein 26708f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 268e593b2bfSAmir Goldstein return 0; 269e8d4bfe3SChengguang Xu 270c86243b0SVivek Goyal if (!ovl_should_sync(ofs)) 271c86243b0SVivek Goyal return 0; 272e8d4bfe3SChengguang Xu /* 27332b1924bSKonstantin Khlebnikov * Not called for sync(2) call or an emergency sync (SB_I_SKIP_SYNC). 27432b1924bSKonstantin Khlebnikov * All the super blocks will be iterated, including upper_sb. 275e8d4bfe3SChengguang Xu * 276e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call 277e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being 278e8d4bfe3SChengguang Xu * called with wait == 1. 279e8d4bfe3SChengguang Xu */ 280e8d4bfe3SChengguang Xu if (!wait) 281e593b2bfSAmir Goldstein return 0; 282e593b2bfSAmir Goldstein 28308f4c7c8SMiklos Szeredi upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 284e8d4bfe3SChengguang Xu 285e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 286e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb); 287e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 288e8d4bfe3SChengguang Xu 289e593b2bfSAmir Goldstein return ret; 290e593b2bfSAmir Goldstein } 291e593b2bfSAmir Goldstein 292cc259639SAndy Whitcroft /** 293cc259639SAndy Whitcroft * ovl_statfs 294cc259639SAndy Whitcroft * @sb: The overlayfs super block 295cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 296cc259639SAndy Whitcroft * 297cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 2984ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 299cc259639SAndy Whitcroft */ 300cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 301cc259639SAndy Whitcroft { 302cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 303cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 304cc259639SAndy Whitcroft struct path path; 305cc259639SAndy Whitcroft int err; 306cc259639SAndy Whitcroft 3074ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 308cc259639SAndy Whitcroft 309cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 310cc259639SAndy Whitcroft if (!err) { 3116b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 312cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 313cc259639SAndy Whitcroft } 314cc259639SAndy Whitcroft 315cc259639SAndy Whitcroft return err; 316cc259639SAndy Whitcroft } 317cc259639SAndy Whitcroft 31802bcd157SAmir Goldstein /* Will this overlay be forced to mount/remount ro? */ 319ad204488SMiklos Szeredi static bool ovl_force_readonly(struct ovl_fs *ofs) 32002bcd157SAmir Goldstein { 32108f4c7c8SMiklos Szeredi return (!ovl_upper_mnt(ofs) || !ofs->workdir); 32202bcd157SAmir Goldstein } 32302bcd157SAmir Goldstein 324438c84c2SMiklos Szeredi static const char *ovl_redirect_mode_def(void) 325438c84c2SMiklos Szeredi { 326438c84c2SMiklos Szeredi return ovl_redirect_dir_def ? "on" : "off"; 327438c84c2SMiklos Szeredi } 328438c84c2SMiklos Szeredi 329795939a9SAmir Goldstein static const char * const ovl_xino_str[] = { 330795939a9SAmir Goldstein "off", 331795939a9SAmir Goldstein "auto", 332795939a9SAmir Goldstein "on", 333795939a9SAmir Goldstein }; 334795939a9SAmir Goldstein 335795939a9SAmir Goldstein static inline int ovl_xino_def(void) 336795939a9SAmir Goldstein { 337795939a9SAmir Goldstein return ovl_xino_auto_def ? OVL_XINO_AUTO : OVL_XINO_OFF; 338795939a9SAmir Goldstein } 339795939a9SAmir Goldstein 340f45827e8SErez Zadok /** 341f45827e8SErez Zadok * ovl_show_options 342f45827e8SErez Zadok * 343f45827e8SErez Zadok * Prints the mount options for a given superblock. 344f45827e8SErez Zadok * Returns zero; does not fail. 345f45827e8SErez Zadok */ 346f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 347f45827e8SErez Zadok { 348f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 349ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 350f45827e8SErez Zadok 351ad204488SMiklos Szeredi seq_show_option(m, "lowerdir", ofs->config.lowerdir); 352ad204488SMiklos Szeredi if (ofs->config.upperdir) { 353ad204488SMiklos Szeredi seq_show_option(m, "upperdir", ofs->config.upperdir); 354ad204488SMiklos Szeredi seq_show_option(m, "workdir", ofs->config.workdir); 35553a08cb9SMiklos Szeredi } 356ad204488SMiklos Szeredi if (ofs->config.default_permissions) 3578d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 358438c84c2SMiklos Szeredi if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0) 359438c84c2SMiklos Szeredi seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode); 360ad204488SMiklos Szeredi if (ofs->config.index != ovl_index_def) 361438c84c2SMiklos Szeredi seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 3625830fb6bSPavel Tikhomirov if (!ofs->config.uuid) 3635830fb6bSPavel Tikhomirov seq_puts(m, ",uuid=off"); 364f168f109SAmir Goldstein if (ofs->config.nfs_export != ovl_nfs_export_def) 365f168f109SAmir Goldstein seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ? 366f168f109SAmir Goldstein "on" : "off"); 3670f831ec8SAmir Goldstein if (ofs->config.xino != ovl_xino_def() && !ovl_same_fs(sb)) 368795939a9SAmir Goldstein seq_printf(m, ",xino=%s", ovl_xino_str[ofs->config.xino]); 369d5791044SVivek Goyal if (ofs->config.metacopy != ovl_metacopy_def) 370d5791044SVivek Goyal seq_printf(m, ",metacopy=%s", 371d5791044SVivek Goyal ofs->config.metacopy ? "on" : "off"); 372c86243b0SVivek Goyal if (ofs->config.ovl_volatile) 373c86243b0SVivek Goyal seq_puts(m, ",volatile"); 374f45827e8SErez Zadok return 0; 375f45827e8SErez Zadok } 376f45827e8SErez Zadok 3773cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 3783cdf6fe9SSeunghun Lee { 379ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 380399c109dSChengguang Xu struct super_block *upper_sb; 381399c109dSChengguang Xu int ret = 0; 3823cdf6fe9SSeunghun Lee 3831751e8a6SLinus Torvalds if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 3843cdf6fe9SSeunghun Lee return -EROFS; 3853cdf6fe9SSeunghun Lee 386399c109dSChengguang Xu if (*flags & SB_RDONLY && !sb_rdonly(sb)) { 38708f4c7c8SMiklos Szeredi upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 388c86243b0SVivek Goyal if (ovl_should_sync(ofs)) { 389399c109dSChengguang Xu down_read(&upper_sb->s_umount); 390399c109dSChengguang Xu ret = sync_filesystem(upper_sb); 391399c109dSChengguang Xu up_read(&upper_sb->s_umount); 392399c109dSChengguang Xu } 393c86243b0SVivek Goyal } 394399c109dSChengguang Xu 395399c109dSChengguang Xu return ret; 3963cdf6fe9SSeunghun Lee } 3973cdf6fe9SSeunghun Lee 398e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 39913cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 4000b269dedSAl Viro .free_inode = ovl_free_inode, 40113cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 40213cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 403e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 404e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 405cc259639SAndy Whitcroft .statfs = ovl_statfs, 406f45827e8SErez Zadok .show_options = ovl_show_options, 4073cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 408e9be9d5eSMiklos Szeredi }; 409e9be9d5eSMiklos Szeredi 410e9be9d5eSMiklos Szeredi enum { 411e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 412e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 413e9be9d5eSMiklos Szeredi OPT_WORKDIR, 4148d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 415438c84c2SMiklos Szeredi OPT_REDIRECT_DIR, 41602bcd157SAmir Goldstein OPT_INDEX_ON, 41702bcd157SAmir Goldstein OPT_INDEX_OFF, 4185830fb6bSPavel Tikhomirov OPT_UUID_ON, 4195830fb6bSPavel Tikhomirov OPT_UUID_OFF, 420f168f109SAmir Goldstein OPT_NFS_EXPORT_ON, 421*2d2f2d73SMiklos Szeredi OPT_USERXATTR, 422f168f109SAmir Goldstein OPT_NFS_EXPORT_OFF, 423795939a9SAmir Goldstein OPT_XINO_ON, 424795939a9SAmir Goldstein OPT_XINO_OFF, 425795939a9SAmir Goldstein OPT_XINO_AUTO, 426d5791044SVivek Goyal OPT_METACOPY_ON, 427d5791044SVivek Goyal OPT_METACOPY_OFF, 428c86243b0SVivek Goyal OPT_VOLATILE, 429e9be9d5eSMiklos Szeredi OPT_ERR, 430e9be9d5eSMiklos Szeredi }; 431e9be9d5eSMiklos Szeredi 432e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 433e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 434e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 435e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 4368d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 437438c84c2SMiklos Szeredi {OPT_REDIRECT_DIR, "redirect_dir=%s"}, 43802bcd157SAmir Goldstein {OPT_INDEX_ON, "index=on"}, 43902bcd157SAmir Goldstein {OPT_INDEX_OFF, "index=off"}, 440*2d2f2d73SMiklos Szeredi {OPT_USERXATTR, "userxattr"}, 4415830fb6bSPavel Tikhomirov {OPT_UUID_ON, "uuid=on"}, 4425830fb6bSPavel Tikhomirov {OPT_UUID_OFF, "uuid=off"}, 443f168f109SAmir Goldstein {OPT_NFS_EXPORT_ON, "nfs_export=on"}, 444f168f109SAmir Goldstein {OPT_NFS_EXPORT_OFF, "nfs_export=off"}, 445795939a9SAmir Goldstein {OPT_XINO_ON, "xino=on"}, 446795939a9SAmir Goldstein {OPT_XINO_OFF, "xino=off"}, 447795939a9SAmir Goldstein {OPT_XINO_AUTO, "xino=auto"}, 448d5791044SVivek Goyal {OPT_METACOPY_ON, "metacopy=on"}, 449d5791044SVivek Goyal {OPT_METACOPY_OFF, "metacopy=off"}, 450c86243b0SVivek Goyal {OPT_VOLATILE, "volatile"}, 451e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 452e9be9d5eSMiklos Szeredi }; 453e9be9d5eSMiklos Szeredi 45491c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 45591c77947SMiklos Szeredi { 45691c77947SMiklos Szeredi char *sbegin = *s; 45791c77947SMiklos Szeredi char *p; 45891c77947SMiklos Szeredi 45991c77947SMiklos Szeredi if (sbegin == NULL) 46091c77947SMiklos Szeredi return NULL; 46191c77947SMiklos Szeredi 46291c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 46391c77947SMiklos Szeredi if (*p == '\\') { 46491c77947SMiklos Szeredi p++; 46591c77947SMiklos Szeredi if (!*p) 46691c77947SMiklos Szeredi break; 46791c77947SMiklos Szeredi } else if (*p == ',') { 46891c77947SMiklos Szeredi *p = '\0'; 46991c77947SMiklos Szeredi *s = p + 1; 47091c77947SMiklos Szeredi return sbegin; 47191c77947SMiklos Szeredi } 47291c77947SMiklos Szeredi } 47391c77947SMiklos Szeredi *s = NULL; 47491c77947SMiklos Szeredi return sbegin; 47591c77947SMiklos Szeredi } 47691c77947SMiklos Szeredi 477438c84c2SMiklos Szeredi static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode) 478438c84c2SMiklos Szeredi { 479438c84c2SMiklos Szeredi if (strcmp(mode, "on") == 0) { 480438c84c2SMiklos Szeredi config->redirect_dir = true; 481438c84c2SMiklos Szeredi /* 482438c84c2SMiklos Szeredi * Does not make sense to have redirect creation without 483438c84c2SMiklos Szeredi * redirect following. 484438c84c2SMiklos Szeredi */ 485438c84c2SMiklos Szeredi config->redirect_follow = true; 486438c84c2SMiklos Szeredi } else if (strcmp(mode, "follow") == 0) { 487438c84c2SMiklos Szeredi config->redirect_follow = true; 488438c84c2SMiklos Szeredi } else if (strcmp(mode, "off") == 0) { 489438c84c2SMiklos Szeredi if (ovl_redirect_always_follow) 490438c84c2SMiklos Szeredi config->redirect_follow = true; 491438c84c2SMiklos Szeredi } else if (strcmp(mode, "nofollow") != 0) { 4921bd0a3aeSlijiazi pr_err("bad mount option \"redirect_dir=%s\"\n", 493438c84c2SMiklos Szeredi mode); 494438c84c2SMiklos Szeredi return -EINVAL; 495438c84c2SMiklos Szeredi } 496438c84c2SMiklos Szeredi 497438c84c2SMiklos Szeredi return 0; 498438c84c2SMiklos Szeredi } 499438c84c2SMiklos Szeredi 500e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 501e9be9d5eSMiklos Szeredi { 502e9be9d5eSMiklos Szeredi char *p; 503d5791044SVivek Goyal int err; 504d47748e5SMiklos Szeredi bool metacopy_opt = false, redirect_opt = false; 505b0def88dSAmir Goldstein bool nfs_export_opt = false, index_opt = false; 506e9be9d5eSMiklos Szeredi 507438c84c2SMiklos Szeredi config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL); 508438c84c2SMiklos Szeredi if (!config->redirect_mode) 509438c84c2SMiklos Szeredi return -ENOMEM; 510438c84c2SMiklos Szeredi 51191c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 512e9be9d5eSMiklos Szeredi int token; 513e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 514e9be9d5eSMiklos Szeredi 515e9be9d5eSMiklos Szeredi if (!*p) 516e9be9d5eSMiklos Szeredi continue; 517e9be9d5eSMiklos Szeredi 518e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 519e9be9d5eSMiklos Szeredi switch (token) { 520e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 521e9be9d5eSMiklos Szeredi kfree(config->upperdir); 522e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 523e9be9d5eSMiklos Szeredi if (!config->upperdir) 524e9be9d5eSMiklos Szeredi return -ENOMEM; 525e9be9d5eSMiklos Szeredi break; 526e9be9d5eSMiklos Szeredi 527e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 528e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 529e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 530e9be9d5eSMiklos Szeredi if (!config->lowerdir) 531e9be9d5eSMiklos Szeredi return -ENOMEM; 532e9be9d5eSMiklos Szeredi break; 533e9be9d5eSMiklos Szeredi 534e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 535e9be9d5eSMiklos Szeredi kfree(config->workdir); 536e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 537e9be9d5eSMiklos Szeredi if (!config->workdir) 538e9be9d5eSMiklos Szeredi return -ENOMEM; 539e9be9d5eSMiklos Szeredi break; 540e9be9d5eSMiklos Szeredi 5418d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 5428d3095f4SMiklos Szeredi config->default_permissions = true; 5438d3095f4SMiklos Szeredi break; 5448d3095f4SMiklos Szeredi 545438c84c2SMiklos Szeredi case OPT_REDIRECT_DIR: 546438c84c2SMiklos Szeredi kfree(config->redirect_mode); 547438c84c2SMiklos Szeredi config->redirect_mode = match_strdup(&args[0]); 548438c84c2SMiklos Szeredi if (!config->redirect_mode) 549438c84c2SMiklos Szeredi return -ENOMEM; 550d47748e5SMiklos Szeredi redirect_opt = true; 551a6c60655SMiklos Szeredi break; 552a6c60655SMiklos Szeredi 55302bcd157SAmir Goldstein case OPT_INDEX_ON: 55402bcd157SAmir Goldstein config->index = true; 555b0def88dSAmir Goldstein index_opt = true; 55602bcd157SAmir Goldstein break; 55702bcd157SAmir Goldstein 55802bcd157SAmir Goldstein case OPT_INDEX_OFF: 55902bcd157SAmir Goldstein config->index = false; 560b0def88dSAmir Goldstein index_opt = true; 56102bcd157SAmir Goldstein break; 56202bcd157SAmir Goldstein 5635830fb6bSPavel Tikhomirov case OPT_UUID_ON: 5645830fb6bSPavel Tikhomirov config->uuid = true; 5655830fb6bSPavel Tikhomirov break; 5665830fb6bSPavel Tikhomirov 5675830fb6bSPavel Tikhomirov case OPT_UUID_OFF: 5685830fb6bSPavel Tikhomirov config->uuid = false; 5695830fb6bSPavel Tikhomirov break; 5705830fb6bSPavel Tikhomirov 571f168f109SAmir Goldstein case OPT_NFS_EXPORT_ON: 572f168f109SAmir Goldstein config->nfs_export = true; 573b0def88dSAmir Goldstein nfs_export_opt = true; 574f168f109SAmir Goldstein break; 575f168f109SAmir Goldstein 576f168f109SAmir Goldstein case OPT_NFS_EXPORT_OFF: 577f168f109SAmir Goldstein config->nfs_export = false; 578b0def88dSAmir Goldstein nfs_export_opt = true; 579f168f109SAmir Goldstein break; 580f168f109SAmir Goldstein 581795939a9SAmir Goldstein case OPT_XINO_ON: 582795939a9SAmir Goldstein config->xino = OVL_XINO_ON; 583795939a9SAmir Goldstein break; 584795939a9SAmir Goldstein 585795939a9SAmir Goldstein case OPT_XINO_OFF: 586795939a9SAmir Goldstein config->xino = OVL_XINO_OFF; 587795939a9SAmir Goldstein break; 588795939a9SAmir Goldstein 589795939a9SAmir Goldstein case OPT_XINO_AUTO: 590795939a9SAmir Goldstein config->xino = OVL_XINO_AUTO; 591795939a9SAmir Goldstein break; 592795939a9SAmir Goldstein 593d5791044SVivek Goyal case OPT_METACOPY_ON: 594d5791044SVivek Goyal config->metacopy = true; 595d47748e5SMiklos Szeredi metacopy_opt = true; 596d5791044SVivek Goyal break; 597d5791044SVivek Goyal 598d5791044SVivek Goyal case OPT_METACOPY_OFF: 599d5791044SVivek Goyal config->metacopy = false; 600b0def88dSAmir Goldstein metacopy_opt = true; 601d5791044SVivek Goyal break; 602d5791044SVivek Goyal 603c86243b0SVivek Goyal case OPT_VOLATILE: 604c86243b0SVivek Goyal config->ovl_volatile = true; 605c86243b0SVivek Goyal break; 606c86243b0SVivek Goyal 607*2d2f2d73SMiklos Szeredi case OPT_USERXATTR: 608*2d2f2d73SMiklos Szeredi config->userxattr = true; 609*2d2f2d73SMiklos Szeredi break; 610*2d2f2d73SMiklos Szeredi 611e9be9d5eSMiklos Szeredi default: 6121bd0a3aeSlijiazi pr_err("unrecognized mount option \"%s\" or missing value\n", 6131bd0a3aeSlijiazi p); 614e9be9d5eSMiklos Szeredi return -EINVAL; 615e9be9d5eSMiklos Szeredi } 616e9be9d5eSMiklos Szeredi } 61771cbad7eShujianyang 618f0e1266eSAmir Goldstein /* Workdir/index are useless in non-upper mount */ 619f0e1266eSAmir Goldstein if (!config->upperdir) { 620f0e1266eSAmir Goldstein if (config->workdir) { 6211bd0a3aeSlijiazi pr_info("option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 62271cbad7eShujianyang config->workdir); 62371cbad7eShujianyang kfree(config->workdir); 62471cbad7eShujianyang config->workdir = NULL; 62571cbad7eShujianyang } 626f0e1266eSAmir Goldstein if (config->index && index_opt) { 627f0e1266eSAmir Goldstein pr_info("option \"index=on\" is useless in a non-upper mount, ignore\n"); 628f0e1266eSAmir Goldstein index_opt = false; 629f0e1266eSAmir Goldstein } 630f0e1266eSAmir Goldstein config->index = false; 631f0e1266eSAmir Goldstein } 63271cbad7eShujianyang 633c86243b0SVivek Goyal if (!config->upperdir && config->ovl_volatile) { 634c86243b0SVivek Goyal pr_info("option \"volatile\" is meaningless in a non-upper mount, ignoring it.\n"); 635c86243b0SVivek Goyal config->ovl_volatile = false; 636c86243b0SVivek Goyal } 637c86243b0SVivek Goyal 638d5791044SVivek Goyal err = ovl_parse_redirect_mode(config, config->redirect_mode); 639d5791044SVivek Goyal if (err) 640d5791044SVivek Goyal return err; 641d5791044SVivek Goyal 642d47748e5SMiklos Szeredi /* 643d47748e5SMiklos Szeredi * This is to make the logic below simpler. It doesn't make any other 644d47748e5SMiklos Szeredi * difference, since config->redirect_dir is only used for upper. 645d47748e5SMiklos Szeredi */ 646d47748e5SMiklos Szeredi if (!config->upperdir && config->redirect_follow) 647d47748e5SMiklos Szeredi config->redirect_dir = true; 648d47748e5SMiklos Szeredi 649d47748e5SMiklos Szeredi /* Resolve metacopy -> redirect_dir dependency */ 650d47748e5SMiklos Szeredi if (config->metacopy && !config->redirect_dir) { 651d47748e5SMiklos Szeredi if (metacopy_opt && redirect_opt) { 6521bd0a3aeSlijiazi pr_err("conflicting options: metacopy=on,redirect_dir=%s\n", 653d47748e5SMiklos Szeredi config->redirect_mode); 654d47748e5SMiklos Szeredi return -EINVAL; 655d47748e5SMiklos Szeredi } 656d47748e5SMiklos Szeredi if (redirect_opt) { 657d47748e5SMiklos Szeredi /* 658d47748e5SMiklos Szeredi * There was an explicit redirect_dir=... that resulted 659d47748e5SMiklos Szeredi * in this conflict. 660d47748e5SMiklos Szeredi */ 6611bd0a3aeSlijiazi pr_info("disabling metacopy due to redirect_dir=%s\n", 662d47748e5SMiklos Szeredi config->redirect_mode); 663d5791044SVivek Goyal config->metacopy = false; 664d47748e5SMiklos Szeredi } else { 665d47748e5SMiklos Szeredi /* Automatically enable redirect otherwise. */ 666d47748e5SMiklos Szeredi config->redirect_follow = config->redirect_dir = true; 667d47748e5SMiklos Szeredi } 668d5791044SVivek Goyal } 669d5791044SVivek Goyal 670b0def88dSAmir Goldstein /* Resolve nfs_export -> index dependency */ 671b0def88dSAmir Goldstein if (config->nfs_export && !config->index) { 672f0e1266eSAmir Goldstein if (!config->upperdir && config->redirect_follow) { 673f0e1266eSAmir Goldstein pr_info("NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n"); 674f0e1266eSAmir Goldstein config->nfs_export = false; 675f0e1266eSAmir Goldstein } else if (nfs_export_opt && index_opt) { 676b0def88dSAmir Goldstein pr_err("conflicting options: nfs_export=on,index=off\n"); 677b0def88dSAmir Goldstein return -EINVAL; 678f0e1266eSAmir Goldstein } else if (index_opt) { 679b0def88dSAmir Goldstein /* 680b0def88dSAmir Goldstein * There was an explicit index=off that resulted 681b0def88dSAmir Goldstein * in this conflict. 682b0def88dSAmir Goldstein */ 683b0def88dSAmir Goldstein pr_info("disabling nfs_export due to index=off\n"); 684b0def88dSAmir Goldstein config->nfs_export = false; 685b0def88dSAmir Goldstein } else { 686b0def88dSAmir Goldstein /* Automatically enable index otherwise. */ 687b0def88dSAmir Goldstein config->index = true; 688b0def88dSAmir Goldstein } 689b0def88dSAmir Goldstein } 690b0def88dSAmir Goldstein 691b0def88dSAmir Goldstein /* Resolve nfs_export -> !metacopy dependency */ 692b0def88dSAmir Goldstein if (config->nfs_export && config->metacopy) { 693b0def88dSAmir Goldstein if (nfs_export_opt && metacopy_opt) { 694b0def88dSAmir Goldstein pr_err("conflicting options: nfs_export=on,metacopy=on\n"); 695b0def88dSAmir Goldstein return -EINVAL; 696b0def88dSAmir Goldstein } 697b0def88dSAmir Goldstein if (metacopy_opt) { 698b0def88dSAmir Goldstein /* 699b0def88dSAmir Goldstein * There was an explicit metacopy=on that resulted 700b0def88dSAmir Goldstein * in this conflict. 701b0def88dSAmir Goldstein */ 702b0def88dSAmir Goldstein pr_info("disabling nfs_export due to metacopy=on\n"); 703b0def88dSAmir Goldstein config->nfs_export = false; 704b0def88dSAmir Goldstein } else { 705b0def88dSAmir Goldstein /* 706b0def88dSAmir Goldstein * There was an explicit nfs_export=on that resulted 707b0def88dSAmir Goldstein * in this conflict. 708b0def88dSAmir Goldstein */ 709b0def88dSAmir Goldstein pr_info("disabling metacopy due to nfs_export=on\n"); 710b0def88dSAmir Goldstein config->metacopy = false; 711b0def88dSAmir Goldstein } 712b0def88dSAmir Goldstein } 713b0def88dSAmir Goldstein 714*2d2f2d73SMiklos Szeredi 715*2d2f2d73SMiklos Szeredi /* Resolve userxattr -> !redirect && !metacopy dependency */ 716*2d2f2d73SMiklos Szeredi if (config->userxattr) { 717*2d2f2d73SMiklos Szeredi if (config->redirect_follow && redirect_opt) { 718*2d2f2d73SMiklos Szeredi pr_err("conflicting options: userxattr,redirect_dir=%s\n", 719*2d2f2d73SMiklos Szeredi config->redirect_mode); 720*2d2f2d73SMiklos Szeredi return -EINVAL; 721*2d2f2d73SMiklos Szeredi } 722*2d2f2d73SMiklos Szeredi if (config->metacopy && metacopy_opt) { 723*2d2f2d73SMiklos Szeredi pr_err("conflicting options: userxattr,metacopy=on\n"); 724*2d2f2d73SMiklos Szeredi return -EINVAL; 725*2d2f2d73SMiklos Szeredi } 726*2d2f2d73SMiklos Szeredi /* 727*2d2f2d73SMiklos Szeredi * Silently disable default setting of redirect and metacopy. 728*2d2f2d73SMiklos Szeredi * This shall be the default in the future as well: these 729*2d2f2d73SMiklos Szeredi * options must be explicitly enabled if used together with 730*2d2f2d73SMiklos Szeredi * userxattr. 731*2d2f2d73SMiklos Szeredi */ 732*2d2f2d73SMiklos Szeredi config->redirect_dir = config->redirect_follow = false; 733*2d2f2d73SMiklos Szeredi config->metacopy = false; 734*2d2f2d73SMiklos Szeredi } 735*2d2f2d73SMiklos Szeredi 736d5791044SVivek Goyal return 0; 737e9be9d5eSMiklos Szeredi } 738e9be9d5eSMiklos Szeredi 739e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 74002bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 741e9be9d5eSMiklos Szeredi 742ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 7436b8aa129SAmir Goldstein const char *name, bool persist) 744e9be9d5eSMiklos Szeredi { 745ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 74608f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 747e9be9d5eSMiklos Szeredi struct dentry *work; 748e9be9d5eSMiklos Szeredi int err; 749e9be9d5eSMiklos Szeredi bool retried = false; 750e9be9d5eSMiklos Szeredi 7515955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 752e9be9d5eSMiklos Szeredi retry: 753ad204488SMiklos Szeredi work = lookup_one_len(name, ofs->workbasedir, strlen(name)); 754e9be9d5eSMiklos Szeredi 755e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 756c11b9fddSMiklos Szeredi struct iattr attr = { 757c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 75832a3d848SAl Viro .ia_mode = S_IFDIR | 0, 759c11b9fddSMiklos Szeredi }; 760e9be9d5eSMiklos Szeredi 761e9be9d5eSMiklos Szeredi if (work->d_inode) { 762e9be9d5eSMiklos Szeredi err = -EEXIST; 763e9be9d5eSMiklos Szeredi if (retried) 764e9be9d5eSMiklos Szeredi goto out_dput; 765e9be9d5eSMiklos Szeredi 7666b8aa129SAmir Goldstein if (persist) 7676b8aa129SAmir Goldstein goto out_unlock; 7686b8aa129SAmir Goldstein 769e9be9d5eSMiklos Szeredi retried = true; 770235ce9edSAmir Goldstein err = ovl_workdir_cleanup(dir, mnt, work, 0); 771e9be9d5eSMiklos Szeredi dput(work); 772235ce9edSAmir Goldstein if (err == -EINVAL) { 773235ce9edSAmir Goldstein work = ERR_PTR(err); 774235ce9edSAmir Goldstein goto out_unlock; 775235ce9edSAmir Goldstein } 776e9be9d5eSMiklos Szeredi goto retry; 777e9be9d5eSMiklos Szeredi } 778e9be9d5eSMiklos Szeredi 77995a1c815SMiklos Szeredi work = ovl_create_real(dir, work, OVL_CATTR(attr.ia_mode)); 78095a1c815SMiklos Szeredi err = PTR_ERR(work); 78195a1c815SMiklos Szeredi if (IS_ERR(work)) 78295a1c815SMiklos Szeredi goto out_err; 783c11b9fddSMiklos Szeredi 784cb348edbSMiklos Szeredi /* 785cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 786cb348edbSMiklos Szeredi * 787cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 788cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 789cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 790cb348edbSMiklos Szeredi * 791cb348edbSMiklos Szeredi * There are various other error values that could effectively 792cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 793cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 794cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 795cb348edbSMiklos Szeredi * for the above two errors is sufficient. 796cb348edbSMiklos Szeredi */ 797c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 798e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 799c11b9fddSMiklos Szeredi goto out_dput; 800c11b9fddSMiklos Szeredi 801c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 802e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 803c11b9fddSMiklos Szeredi goto out_dput; 804c11b9fddSMiklos Szeredi 805c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 806c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 807c11b9fddSMiklos Szeredi err = notify_change(work, &attr, NULL); 808c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 809c11b9fddSMiklos Szeredi if (err) 810c11b9fddSMiklos Szeredi goto out_dput; 8116b8aa129SAmir Goldstein } else { 8126b8aa129SAmir Goldstein err = PTR_ERR(work); 8136b8aa129SAmir Goldstein goto out_err; 814e9be9d5eSMiklos Szeredi } 815e9be9d5eSMiklos Szeredi out_unlock: 8166b8aa129SAmir Goldstein inode_unlock(dir); 817e9be9d5eSMiklos Szeredi return work; 818e9be9d5eSMiklos Szeredi 819e9be9d5eSMiklos Szeredi out_dput: 820e9be9d5eSMiklos Szeredi dput(work); 8216b8aa129SAmir Goldstein out_err: 8221bd0a3aeSlijiazi pr_warn("failed to create directory %s/%s (errno: %i); mounting read-only\n", 823ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 8246b8aa129SAmir Goldstein work = NULL; 825e9be9d5eSMiklos Szeredi goto out_unlock; 826e9be9d5eSMiklos Szeredi } 827e9be9d5eSMiklos Szeredi 82891c77947SMiklos Szeredi static void ovl_unescape(char *s) 82991c77947SMiklos Szeredi { 83091c77947SMiklos Szeredi char *d = s; 83191c77947SMiklos Szeredi 83291c77947SMiklos Szeredi for (;; s++, d++) { 83391c77947SMiklos Szeredi if (*s == '\\') 83491c77947SMiklos Szeredi s++; 83591c77947SMiklos Szeredi *d = *s; 83691c77947SMiklos Szeredi if (!*s) 83791c77947SMiklos Szeredi break; 83891c77947SMiklos Szeredi } 83991c77947SMiklos Szeredi } 84091c77947SMiklos Szeredi 841ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 842ab508822SMiklos Szeredi { 843a78d9f0dSMiklos Szeredi int err = -EINVAL; 844ab508822SMiklos Szeredi 845a78d9f0dSMiklos Szeredi if (!*name) { 8461bd0a3aeSlijiazi pr_err("empty lowerdir\n"); 847a78d9f0dSMiklos Szeredi goto out; 848a78d9f0dSMiklos Szeredi } 849ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 850ab508822SMiklos Szeredi if (err) { 8511bd0a3aeSlijiazi pr_err("failed to resolve '%s': %i\n", name, err); 852ab508822SMiklos Szeredi goto out; 853ab508822SMiklos Szeredi } 854ab508822SMiklos Szeredi err = -EINVAL; 8557c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 8561bd0a3aeSlijiazi pr_err("filesystem on '%s' not supported\n", name); 857ab508822SMiklos Szeredi goto out_put; 858ab508822SMiklos Szeredi } 8592b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 8601bd0a3aeSlijiazi pr_err("'%s' not a directory\n", name); 861ab508822SMiklos Szeredi goto out_put; 862ab508822SMiklos Szeredi } 863ab508822SMiklos Szeredi return 0; 864ab508822SMiklos Szeredi 865ab508822SMiklos Szeredi out_put: 8668aafcb59SMiklos Szeredi path_put_init(path); 867ab508822SMiklos Szeredi out: 868ab508822SMiklos Szeredi return err; 869ab508822SMiklos Szeredi } 870ab508822SMiklos Szeredi 871ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 872ab508822SMiklos Szeredi { 873ab508822SMiklos Szeredi int err = -ENOMEM; 874ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 875ab508822SMiklos Szeredi 876ab508822SMiklos Szeredi if (tmp) { 877ab508822SMiklos Szeredi ovl_unescape(tmp); 878ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 8797c03b5d4SMiklos Szeredi 880bccece1eSMiklos Szeredi if (!err && path->dentry->d_flags & DCACHE_OP_REAL) { 8811bd0a3aeSlijiazi pr_err("filesystem on '%s' not supported as upperdir\n", 8827c03b5d4SMiklos Szeredi tmp); 8838aafcb59SMiklos Szeredi path_put_init(path); 8847c03b5d4SMiklos Szeredi err = -EINVAL; 8857c03b5d4SMiklos Szeredi } 886ab508822SMiklos Szeredi kfree(tmp); 887ab508822SMiklos Szeredi } 888ab508822SMiklos Szeredi return err; 889ab508822SMiklos Szeredi } 890ab508822SMiklos Szeredi 8916b2d5fe4SMiklos Szeredi static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 8926b2d5fe4SMiklos Szeredi const char *name) 8936b2d5fe4SMiklos Szeredi { 8946b2d5fe4SMiklos Szeredi struct kstatfs statfs; 8956b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 8966b2d5fe4SMiklos Szeredi 8976b2d5fe4SMiklos Szeredi if (err) 8981bd0a3aeSlijiazi pr_err("statfs failed on '%s'\n", name); 8996b2d5fe4SMiklos Szeredi else 9006b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 9016b2d5fe4SMiklos Szeredi 9026b2d5fe4SMiklos Szeredi return err; 9036b2d5fe4SMiklos Szeredi } 9046b2d5fe4SMiklos Szeredi 9056b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 906f4288844SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth) 907ab508822SMiklos Szeredi { 908e487d889SAmir Goldstein int fh_type; 909ab508822SMiklos Szeredi int err; 910ab508822SMiklos Szeredi 911a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 912ab508822SMiklos Szeredi if (err) 913b8e42a65SMiklos Szeredi return err; 914ab508822SMiklos Szeredi 9156b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 9166b2d5fe4SMiklos Szeredi if (err) 917b8e42a65SMiklos Szeredi return err; 9186b2d5fe4SMiklos Szeredi 919ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 920ab508822SMiklos Szeredi 92102bcd157SAmir Goldstein /* 922f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode 923f168f109SAmir Goldstein * file handles, so they require that all layers support them. 92402bcd157SAmir Goldstein */ 925e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(path->dentry->d_sb); 926f168f109SAmir Goldstein if ((ofs->config.nfs_export || 927e487d889SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 92802bcd157SAmir Goldstein ofs->config.index = false; 929f168f109SAmir Goldstein ofs->config.nfs_export = false; 9301bd0a3aeSlijiazi pr_warn("fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 931f168f109SAmir Goldstein name); 93202bcd157SAmir Goldstein } 93302bcd157SAmir Goldstein 934e487d889SAmir Goldstein /* Check if lower fs has 32bit inode numbers */ 935e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 9360f831ec8SAmir Goldstein ofs->xino_mode = -1; 937e487d889SAmir Goldstein 938ab508822SMiklos Szeredi return 0; 939ab508822SMiklos Szeredi } 940ab508822SMiklos Szeredi 941e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 942e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 943e9be9d5eSMiklos Szeredi { 944e9be9d5eSMiklos Szeredi bool ok = false; 945e9be9d5eSMiklos Szeredi 946e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 947e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 948e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 949e9be9d5eSMiklos Szeredi } 950e9be9d5eSMiklos Szeredi return ok; 951e9be9d5eSMiklos Szeredi } 952e9be9d5eSMiklos Szeredi 953a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 954a78d9f0dSMiklos Szeredi { 955a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 956a78d9f0dSMiklos Szeredi char *s, *d; 957a78d9f0dSMiklos Szeredi 958a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 959a78d9f0dSMiklos Szeredi if (*s == '\\') { 960a78d9f0dSMiklos Szeredi s++; 961a78d9f0dSMiklos Szeredi } else if (*s == ':') { 962a78d9f0dSMiklos Szeredi *d = '\0'; 963a78d9f0dSMiklos Szeredi ctr++; 964a78d9f0dSMiklos Szeredi continue; 965a78d9f0dSMiklos Szeredi } 966a78d9f0dSMiklos Szeredi *d = *s; 967a78d9f0dSMiklos Szeredi if (!*s) 968a78d9f0dSMiklos Szeredi break; 969a78d9f0dSMiklos Szeredi } 970a78d9f0dSMiklos Szeredi return ctr; 971a78d9f0dSMiklos Szeredi } 972a78d9f0dSMiklos Szeredi 9730c97be22SAndreas Gruenbacher static int __maybe_unused 9740eb45fc3SAndreas Gruenbacher ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 9750eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 9760eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 9770eb45fc3SAndreas Gruenbacher { 9781d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 9790eb45fc3SAndreas Gruenbacher } 9800eb45fc3SAndreas Gruenbacher 9810eb45fc3SAndreas Gruenbacher static int __maybe_unused 9820c97be22SAndreas Gruenbacher ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 983d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 984d837a49bSMiklos Szeredi const char *name, const void *value, 985d837a49bSMiklos Szeredi size_t size, int flags) 986d837a49bSMiklos Szeredi { 987d837a49bSMiklos Szeredi struct dentry *workdir = ovl_workdir(dentry); 98809d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 989d837a49bSMiklos Szeredi struct posix_acl *acl = NULL; 990d837a49bSMiklos Szeredi int err; 991d837a49bSMiklos Szeredi 992d837a49bSMiklos Szeredi /* Check that everything is OK before copy-up */ 993d837a49bSMiklos Szeredi if (value) { 994d837a49bSMiklos Szeredi acl = posix_acl_from_xattr(&init_user_ns, value, size); 995d837a49bSMiklos Szeredi if (IS_ERR(acl)) 996d837a49bSMiklos Szeredi return PTR_ERR(acl); 997d837a49bSMiklos Szeredi } 998d837a49bSMiklos Szeredi err = -EOPNOTSUPP; 999d837a49bSMiklos Szeredi if (!IS_POSIXACL(d_inode(workdir))) 1000d837a49bSMiklos Szeredi goto out_acl_release; 1001d837a49bSMiklos Szeredi if (!realinode->i_op->set_acl) 1002d837a49bSMiklos Szeredi goto out_acl_release; 1003d837a49bSMiklos Szeredi if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 1004d837a49bSMiklos Szeredi err = acl ? -EACCES : 0; 1005d837a49bSMiklos Szeredi goto out_acl_release; 1006d837a49bSMiklos Szeredi } 1007d837a49bSMiklos Szeredi err = -EPERM; 1008d837a49bSMiklos Szeredi if (!inode_owner_or_capable(inode)) 1009d837a49bSMiklos Szeredi goto out_acl_release; 1010d837a49bSMiklos Szeredi 1011d837a49bSMiklos Szeredi posix_acl_release(acl); 1012d837a49bSMiklos Szeredi 1013fd3220d3SMiklos Szeredi /* 1014fd3220d3SMiklos Szeredi * Check if sgid bit needs to be cleared (actual setacl operation will 1015fd3220d3SMiklos Szeredi * be done with mounter's capabilities and so that won't do it for us). 1016fd3220d3SMiklos Szeredi */ 1017fd3220d3SMiklos Szeredi if (unlikely(inode->i_mode & S_ISGID) && 1018fd3220d3SMiklos Szeredi handler->flags == ACL_TYPE_ACCESS && 1019fd3220d3SMiklos Szeredi !in_group_p(inode->i_gid) && 1020fd3220d3SMiklos Szeredi !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 1021fd3220d3SMiklos Szeredi struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 1022fd3220d3SMiklos Szeredi 1023fd3220d3SMiklos Szeredi err = ovl_setattr(dentry, &iattr); 1024fd3220d3SMiklos Szeredi if (err) 1025fd3220d3SMiklos Szeredi return err; 1026fd3220d3SMiklos Szeredi } 1027fd3220d3SMiklos Szeredi 10281d88f183SMiklos Szeredi err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 1029ce31513aSMiklos Szeredi if (!err) 103009d8b586SMiklos Szeredi ovl_copyattr(ovl_inode_real(inode), inode); 1031ce31513aSMiklos Szeredi 1032ce31513aSMiklos Szeredi return err; 1033d837a49bSMiklos Szeredi 1034d837a49bSMiklos Szeredi out_acl_release: 1035d837a49bSMiklos Szeredi posix_acl_release(acl); 1036d837a49bSMiklos Szeredi return err; 1037d837a49bSMiklos Szeredi } 1038d837a49bSMiklos Szeredi 10390eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 10400eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 10410eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 10420eb45fc3SAndreas Gruenbacher { 104348fab5d7SAmir Goldstein return -EOPNOTSUPP; 10440eb45fc3SAndreas Gruenbacher } 10450eb45fc3SAndreas Gruenbacher 1046d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 1047d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 1048d837a49bSMiklos Szeredi const char *name, const void *value, 1049d837a49bSMiklos Szeredi size_t size, int flags) 1050d837a49bSMiklos Szeredi { 105148fab5d7SAmir Goldstein return -EOPNOTSUPP; 1052d837a49bSMiklos Szeredi } 1053d837a49bSMiklos Szeredi 10540eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 10550eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 10560eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 10570eb45fc3SAndreas Gruenbacher { 10581d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 10590eb45fc3SAndreas Gruenbacher } 10600eb45fc3SAndreas Gruenbacher 10610e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 10620e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 10630e585cccSAndreas Gruenbacher const char *name, const void *value, 10640e585cccSAndreas Gruenbacher size_t size, int flags) 10650e585cccSAndreas Gruenbacher { 10661d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 10670e585cccSAndreas Gruenbacher } 10680e585cccSAndreas Gruenbacher 10690c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 10700c97be22SAndreas Gruenbacher ovl_posix_acl_access_xattr_handler = { 1071d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_ACCESS, 1072d837a49bSMiklos Szeredi .flags = ACL_TYPE_ACCESS, 10730eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 1074d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 1075d837a49bSMiklos Szeredi }; 1076d837a49bSMiklos Szeredi 10770c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 10780c97be22SAndreas Gruenbacher ovl_posix_acl_default_xattr_handler = { 1079d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_DEFAULT, 1080d837a49bSMiklos Szeredi .flags = ACL_TYPE_DEFAULT, 10810eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 1082d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 1083d837a49bSMiklos Szeredi }; 1084d837a49bSMiklos Szeredi 1085*2d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_trusted_xattr_handler = { 1086*2d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_TRUSTED_PREFIX, 1087*2d2f2d73SMiklos Szeredi .get = ovl_own_xattr_get, 1088*2d2f2d73SMiklos Szeredi .set = ovl_own_xattr_set, 1089*2d2f2d73SMiklos Szeredi }; 1090*2d2f2d73SMiklos Szeredi 1091*2d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_user_xattr_handler = { 1092*2d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_USER_PREFIX, 10930eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 1094d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 1095d837a49bSMiklos Szeredi }; 1096d837a49bSMiklos Szeredi 1097d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 1098d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 10990eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 1100d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 1101d837a49bSMiklos Szeredi }; 1102d837a49bSMiklos Szeredi 1103*2d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_trusted_xattr_handlers[] = { 11040c97be22SAndreas Gruenbacher #ifdef CONFIG_FS_POSIX_ACL 1105d837a49bSMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 1106d837a49bSMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 11070c97be22SAndreas Gruenbacher #endif 1108*2d2f2d73SMiklos Szeredi &ovl_own_trusted_xattr_handler, 1109*2d2f2d73SMiklos Szeredi &ovl_other_xattr_handler, 1110*2d2f2d73SMiklos Szeredi NULL 1111*2d2f2d73SMiklos Szeredi }; 1112*2d2f2d73SMiklos Szeredi 1113*2d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_user_xattr_handlers[] = { 1114*2d2f2d73SMiklos Szeredi #ifdef CONFIG_FS_POSIX_ACL 1115*2d2f2d73SMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 1116*2d2f2d73SMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 1117*2d2f2d73SMiklos Szeredi #endif 1118*2d2f2d73SMiklos Szeredi &ovl_own_user_xattr_handler, 1119d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 1120d837a49bSMiklos Szeredi NULL 1121d837a49bSMiklos Szeredi }; 1122d837a49bSMiklos Szeredi 1123146d62e5SAmir Goldstein static int ovl_setup_trap(struct super_block *sb, struct dentry *dir, 1124146d62e5SAmir Goldstein struct inode **ptrap, const char *name) 1125146d62e5SAmir Goldstein { 1126146d62e5SAmir Goldstein struct inode *trap; 1127146d62e5SAmir Goldstein int err; 1128146d62e5SAmir Goldstein 1129146d62e5SAmir Goldstein trap = ovl_get_trap_inode(sb, dir); 11301dac6f5bSArnd Bergmann err = PTR_ERR_OR_ZERO(trap); 11311dac6f5bSArnd Bergmann if (err) { 1132146d62e5SAmir Goldstein if (err == -ELOOP) 11331bd0a3aeSlijiazi pr_err("conflicting %s path\n", name); 1134146d62e5SAmir Goldstein return err; 1135146d62e5SAmir Goldstein } 1136146d62e5SAmir Goldstein 1137146d62e5SAmir Goldstein *ptrap = trap; 1138146d62e5SAmir Goldstein return 0; 1139146d62e5SAmir Goldstein } 1140146d62e5SAmir Goldstein 11410be0bfd2SAmir Goldstein /* 11420be0bfd2SAmir Goldstein * Determine how we treat concurrent use of upperdir/workdir based on the 11430be0bfd2SAmir Goldstein * index feature. This is papering over mount leaks of container runtimes, 11440be0bfd2SAmir Goldstein * for example, an old overlay mount is leaked and now its upperdir is 11450be0bfd2SAmir Goldstein * attempted to be used as a lower layer in a new overlay mount. 11460be0bfd2SAmir Goldstein */ 11470be0bfd2SAmir Goldstein static int ovl_report_in_use(struct ovl_fs *ofs, const char *name) 11480be0bfd2SAmir Goldstein { 11490be0bfd2SAmir Goldstein if (ofs->config.index) { 11501bd0a3aeSlijiazi pr_err("%s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n", 11510be0bfd2SAmir Goldstein name); 11520be0bfd2SAmir Goldstein return -EBUSY; 11530be0bfd2SAmir Goldstein } else { 11541bd0a3aeSlijiazi pr_warn("%s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n", 11550be0bfd2SAmir Goldstein name); 11560be0bfd2SAmir Goldstein return 0; 11570be0bfd2SAmir Goldstein } 11580be0bfd2SAmir Goldstein } 11590be0bfd2SAmir Goldstein 1160146d62e5SAmir Goldstein static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs, 1161b8e42a65SMiklos Szeredi struct ovl_layer *upper_layer, struct path *upperpath) 11626ee8acf0SMiklos Szeredi { 11635064975eSMiklos Szeredi struct vfsmount *upper_mnt; 11646ee8acf0SMiklos Szeredi int err; 11656ee8acf0SMiklos Szeredi 1166ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.upperdir, upperpath); 11676ee8acf0SMiklos Szeredi if (err) 11686ee8acf0SMiklos Szeredi goto out; 11696ee8acf0SMiklos Szeredi 11706ee8acf0SMiklos Szeredi /* Upper fs should not be r/o */ 11716ee8acf0SMiklos Szeredi if (sb_rdonly(upperpath->mnt->mnt_sb)) { 11721bd0a3aeSlijiazi pr_err("upper fs is r/o, try multi-lower layers mount\n"); 11736ee8acf0SMiklos Szeredi err = -EINVAL; 11746ee8acf0SMiklos Szeredi goto out; 11756ee8acf0SMiklos Szeredi } 11766ee8acf0SMiklos Szeredi 1177ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 11786ee8acf0SMiklos Szeredi if (err) 11796ee8acf0SMiklos Szeredi goto out; 11806ee8acf0SMiklos Szeredi 1181b8e42a65SMiklos Szeredi err = ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap, 1182146d62e5SAmir Goldstein "upperdir"); 1183146d62e5SAmir Goldstein if (err) 1184146d62e5SAmir Goldstein goto out; 1185146d62e5SAmir Goldstein 11865064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 11875064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 11885064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 11891bd0a3aeSlijiazi pr_err("failed to clone upperpath\n"); 11905064975eSMiklos Szeredi goto out; 11915064975eSMiklos Szeredi } 11925064975eSMiklos Szeredi 11935064975eSMiklos Szeredi /* Don't inherit atime flags */ 11945064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 1195b8e42a65SMiklos Szeredi upper_layer->mnt = upper_mnt; 1196b8e42a65SMiklos Szeredi upper_layer->idx = 0; 1197b8e42a65SMiklos Szeredi upper_layer->fsid = 0; 11988c25741aSMiklos Szeredi 1199654255faSJeffle Xu /* 1200654255faSJeffle Xu * Inherit SB_NOSEC flag from upperdir. 1201654255faSJeffle Xu * 1202654255faSJeffle Xu * This optimization changes behavior when a security related attribute 1203654255faSJeffle Xu * (suid/sgid/security.*) is changed on an underlying layer. This is 1204654255faSJeffle Xu * okay because we don't yet have guarantees in that case, but it will 1205654255faSJeffle Xu * need careful treatment once we want to honour changes to underlying 1206654255faSJeffle Xu * filesystems. 1207654255faSJeffle Xu */ 1208654255faSJeffle Xu if (upper_mnt->mnt_sb->s_flags & SB_NOSEC) 1209654255faSJeffle Xu sb->s_flags |= SB_NOSEC; 1210654255faSJeffle Xu 121108f4c7c8SMiklos Szeredi if (ovl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) { 12128c25741aSMiklos Szeredi ofs->upperdir_locked = true; 12138c25741aSMiklos Szeredi } else { 12140be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "upperdir"); 12150be0bfd2SAmir Goldstein if (err) 12160be0bfd2SAmir Goldstein goto out; 12178c25741aSMiklos Szeredi } 12188c25741aSMiklos Szeredi 12196ee8acf0SMiklos Szeredi err = 0; 12206ee8acf0SMiklos Szeredi out: 12216ee8acf0SMiklos Szeredi return err; 12226ee8acf0SMiklos Szeredi } 12236ee8acf0SMiklos Szeredi 1224cad218abSAmir Goldstein /* 1225cad218abSAmir Goldstein * Returns 1 if RENAME_WHITEOUT is supported, 0 if not supported and 1226cad218abSAmir Goldstein * negative values if error is encountered. 1227cad218abSAmir Goldstein */ 1228cad218abSAmir Goldstein static int ovl_check_rename_whiteout(struct dentry *workdir) 1229cad218abSAmir Goldstein { 1230cad218abSAmir Goldstein struct inode *dir = d_inode(workdir); 1231cad218abSAmir Goldstein struct dentry *temp; 1232cad218abSAmir Goldstein struct dentry *dest; 1233cad218abSAmir Goldstein struct dentry *whiteout; 1234cad218abSAmir Goldstein struct name_snapshot name; 1235cad218abSAmir Goldstein int err; 1236cad218abSAmir Goldstein 1237cad218abSAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 1238cad218abSAmir Goldstein 1239cad218abSAmir Goldstein temp = ovl_create_temp(workdir, OVL_CATTR(S_IFREG | 0)); 1240cad218abSAmir Goldstein err = PTR_ERR(temp); 1241cad218abSAmir Goldstein if (IS_ERR(temp)) 1242cad218abSAmir Goldstein goto out_unlock; 1243cad218abSAmir Goldstein 1244cad218abSAmir Goldstein dest = ovl_lookup_temp(workdir); 1245cad218abSAmir Goldstein err = PTR_ERR(dest); 1246cad218abSAmir Goldstein if (IS_ERR(dest)) { 1247cad218abSAmir Goldstein dput(temp); 1248cad218abSAmir Goldstein goto out_unlock; 1249cad218abSAmir Goldstein } 1250cad218abSAmir Goldstein 1251cad218abSAmir Goldstein /* Name is inline and stable - using snapshot as a copy helper */ 1252cad218abSAmir Goldstein take_dentry_name_snapshot(&name, temp); 1253cad218abSAmir Goldstein err = ovl_do_rename(dir, temp, dir, dest, RENAME_WHITEOUT); 1254cad218abSAmir Goldstein if (err) { 1255cad218abSAmir Goldstein if (err == -EINVAL) 1256cad218abSAmir Goldstein err = 0; 1257cad218abSAmir Goldstein goto cleanup_temp; 1258cad218abSAmir Goldstein } 1259cad218abSAmir Goldstein 1260cad218abSAmir Goldstein whiteout = lookup_one_len(name.name.name, workdir, name.name.len); 1261cad218abSAmir Goldstein err = PTR_ERR(whiteout); 1262cad218abSAmir Goldstein if (IS_ERR(whiteout)) 1263cad218abSAmir Goldstein goto cleanup_temp; 1264cad218abSAmir Goldstein 1265cad218abSAmir Goldstein err = ovl_is_whiteout(whiteout); 1266cad218abSAmir Goldstein 1267cad218abSAmir Goldstein /* Best effort cleanup of whiteout and temp file */ 1268cad218abSAmir Goldstein if (err) 1269cad218abSAmir Goldstein ovl_cleanup(dir, whiteout); 1270cad218abSAmir Goldstein dput(whiteout); 1271cad218abSAmir Goldstein 1272cad218abSAmir Goldstein cleanup_temp: 1273cad218abSAmir Goldstein ovl_cleanup(dir, temp); 1274cad218abSAmir Goldstein release_dentry_name_snapshot(&name); 1275cad218abSAmir Goldstein dput(temp); 1276cad218abSAmir Goldstein dput(dest); 1277cad218abSAmir Goldstein 1278cad218abSAmir Goldstein out_unlock: 1279cad218abSAmir Goldstein inode_unlock(dir); 1280cad218abSAmir Goldstein 1281cad218abSAmir Goldstein return err; 1282cad218abSAmir Goldstein } 1283cad218abSAmir Goldstein 1284c86243b0SVivek Goyal static struct dentry *ovl_lookup_or_create(struct dentry *parent, 1285c86243b0SVivek Goyal const char *name, umode_t mode) 1286c86243b0SVivek Goyal { 1287c86243b0SVivek Goyal size_t len = strlen(name); 1288c86243b0SVivek Goyal struct dentry *child; 1289c86243b0SVivek Goyal 1290c86243b0SVivek Goyal inode_lock_nested(parent->d_inode, I_MUTEX_PARENT); 1291c86243b0SVivek Goyal child = lookup_one_len(name, parent, len); 1292c86243b0SVivek Goyal if (!IS_ERR(child) && !child->d_inode) 1293c86243b0SVivek Goyal child = ovl_create_real(parent->d_inode, child, 1294c86243b0SVivek Goyal OVL_CATTR(mode)); 1295c86243b0SVivek Goyal inode_unlock(parent->d_inode); 1296c86243b0SVivek Goyal dput(parent); 1297c86243b0SVivek Goyal 1298c86243b0SVivek Goyal return child; 1299c86243b0SVivek Goyal } 1300c86243b0SVivek Goyal 1301c86243b0SVivek Goyal /* 1302c86243b0SVivek Goyal * Creates $workdir/work/incompat/volatile/dirty file if it is not already 1303c86243b0SVivek Goyal * present. 1304c86243b0SVivek Goyal */ 1305c86243b0SVivek Goyal static int ovl_create_volatile_dirty(struct ovl_fs *ofs) 1306c86243b0SVivek Goyal { 1307c86243b0SVivek Goyal unsigned int ctr; 1308c86243b0SVivek Goyal struct dentry *d = dget(ofs->workbasedir); 1309c86243b0SVivek Goyal static const char *const volatile_path[] = { 1310c86243b0SVivek Goyal OVL_WORKDIR_NAME, "incompat", "volatile", "dirty" 1311c86243b0SVivek Goyal }; 1312c86243b0SVivek Goyal const char *const *name = volatile_path; 1313c86243b0SVivek Goyal 1314c86243b0SVivek Goyal for (ctr = ARRAY_SIZE(volatile_path); ctr; ctr--, name++) { 1315c86243b0SVivek Goyal d = ovl_lookup_or_create(d, *name, ctr > 1 ? S_IFDIR : S_IFREG); 1316c86243b0SVivek Goyal if (IS_ERR(d)) 1317c86243b0SVivek Goyal return PTR_ERR(d); 1318c86243b0SVivek Goyal } 1319c86243b0SVivek Goyal dput(d); 1320c86243b0SVivek Goyal return 0; 1321c86243b0SVivek Goyal } 1322c86243b0SVivek Goyal 1323146d62e5SAmir Goldstein static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs, 1324146d62e5SAmir Goldstein struct path *workpath) 13258ed61dc3SMiklos Szeredi { 132608f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 1327235ce9edSAmir Goldstein struct dentry *temp, *workdir; 1328d80172c2SAmir Goldstein bool rename_whiteout; 1329d80172c2SAmir Goldstein bool d_type; 1330e487d889SAmir Goldstein int fh_type; 13318ed61dc3SMiklos Szeredi int err; 13328ed61dc3SMiklos Szeredi 13332ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 13342ba9d57eSAmir Goldstein if (err) 13352ba9d57eSAmir Goldstein return err; 13362ba9d57eSAmir Goldstein 1337235ce9edSAmir Goldstein workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 1338235ce9edSAmir Goldstein err = PTR_ERR(workdir); 1339235ce9edSAmir Goldstein if (IS_ERR_OR_NULL(workdir)) 13402ba9d57eSAmir Goldstein goto out; 13418ed61dc3SMiklos Szeredi 1342235ce9edSAmir Goldstein ofs->workdir = workdir; 1343235ce9edSAmir Goldstein 1344146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir"); 1345146d62e5SAmir Goldstein if (err) 1346146d62e5SAmir Goldstein goto out; 1347146d62e5SAmir Goldstein 13488ed61dc3SMiklos Szeredi /* 13498ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 13508ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 13518ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 13528ed61dc3SMiklos Szeredi * previous step. 13538ed61dc3SMiklos Szeredi */ 13548ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 13558ed61dc3SMiklos Szeredi if (err < 0) 13562ba9d57eSAmir Goldstein goto out; 13578ed61dc3SMiklos Szeredi 1358d80172c2SAmir Goldstein d_type = err; 1359d80172c2SAmir Goldstein if (!d_type) 13601bd0a3aeSlijiazi pr_warn("upper fs needs to support d_type.\n"); 13618ed61dc3SMiklos Szeredi 13628ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 1363ad204488SMiklos Szeredi temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0); 1364ad204488SMiklos Szeredi ofs->tmpfile = !IS_ERR(temp); 1365ad204488SMiklos Szeredi if (ofs->tmpfile) 13668ed61dc3SMiklos Szeredi dput(temp); 13678ed61dc3SMiklos Szeredi else 13681bd0a3aeSlijiazi pr_warn("upper fs does not support tmpfile.\n"); 13698ed61dc3SMiklos Szeredi 1370cad218abSAmir Goldstein 1371cad218abSAmir Goldstein /* Check if upper/work fs supports RENAME_WHITEOUT */ 1372cad218abSAmir Goldstein err = ovl_check_rename_whiteout(ofs->workdir); 1373cad218abSAmir Goldstein if (err < 0) 1374cad218abSAmir Goldstein goto out; 1375cad218abSAmir Goldstein 1376d80172c2SAmir Goldstein rename_whiteout = err; 1377d80172c2SAmir Goldstein if (!rename_whiteout) 1378cad218abSAmir Goldstein pr_warn("upper fs does not support RENAME_WHITEOUT.\n"); 1379cad218abSAmir Goldstein 13808ed61dc3SMiklos Szeredi /* 1381*2d2f2d73SMiklos Szeredi * Check if upper/work fs supports (trusted|user).overlay.* xattr 13828ed61dc3SMiklos Szeredi */ 1383610afc0bSMiklos Szeredi err = ovl_do_setxattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE, "0", 1); 13848ed61dc3SMiklos Szeredi if (err) { 1385ad204488SMiklos Szeredi ofs->noxattr = true; 1386a683737bSAmir Goldstein ofs->config.index = false; 1387d5791044SVivek Goyal ofs->config.metacopy = false; 13881bd0a3aeSlijiazi pr_warn("upper fs does not support xattr, falling back to index=off and metacopy=off.\n"); 13892ba9d57eSAmir Goldstein err = 0; 13908ed61dc3SMiklos Szeredi } else { 1391610afc0bSMiklos Szeredi ovl_do_removexattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE); 13928ed61dc3SMiklos Szeredi } 13938ed61dc3SMiklos Szeredi 1394d80172c2SAmir Goldstein /* 1395d80172c2SAmir Goldstein * We allowed sub-optimal upper fs configuration and don't want to break 1396d80172c2SAmir Goldstein * users over kernel upgrade, but we never allowed remote upper fs, so 1397d80172c2SAmir Goldstein * we can enforce strict requirements for remote upper fs. 1398d80172c2SAmir Goldstein */ 1399d80172c2SAmir Goldstein if (ovl_dentry_remote(ofs->workdir) && 1400d80172c2SAmir Goldstein (!d_type || !rename_whiteout || ofs->noxattr)) { 1401d80172c2SAmir Goldstein pr_err("upper fs missing required features.\n"); 1402d80172c2SAmir Goldstein err = -EINVAL; 1403d80172c2SAmir Goldstein goto out; 1404d80172c2SAmir Goldstein } 1405d80172c2SAmir Goldstein 1406c86243b0SVivek Goyal /* 1407c86243b0SVivek Goyal * For volatile mount, create a incompat/volatile/dirty file to keep 1408c86243b0SVivek Goyal * track of it. 1409c86243b0SVivek Goyal */ 1410c86243b0SVivek Goyal if (ofs->config.ovl_volatile) { 1411c86243b0SVivek Goyal err = ovl_create_volatile_dirty(ofs); 1412c86243b0SVivek Goyal if (err < 0) { 1413c86243b0SVivek Goyal pr_err("Failed to create volatile/dirty file.\n"); 1414c86243b0SVivek Goyal goto out; 1415c86243b0SVivek Goyal } 1416c86243b0SVivek Goyal } 1417c86243b0SVivek Goyal 14188ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 1419e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 1420e487d889SAmir Goldstein if (ofs->config.index && !fh_type) { 1421ad204488SMiklos Szeredi ofs->config.index = false; 14221bd0a3aeSlijiazi pr_warn("upper fs does not support file handles, falling back to index=off.\n"); 14238ed61dc3SMiklos Szeredi } 14248ed61dc3SMiklos Szeredi 1425e487d889SAmir Goldstein /* Check if upper fs has 32bit inode numbers */ 1426e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 14270f831ec8SAmir Goldstein ofs->xino_mode = -1; 1428e487d889SAmir Goldstein 1429f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */ 1430f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) { 14311bd0a3aeSlijiazi pr_warn("NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 1432f168f109SAmir Goldstein ofs->config.nfs_export = false; 1433f168f109SAmir Goldstein } 14342ba9d57eSAmir Goldstein out: 14352ba9d57eSAmir Goldstein mnt_drop_write(mnt); 14362ba9d57eSAmir Goldstein return err; 14378ed61dc3SMiklos Szeredi } 14388ed61dc3SMiklos Szeredi 1439146d62e5SAmir Goldstein static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs, 1440146d62e5SAmir Goldstein struct path *upperpath) 1441520d7c86SMiklos Szeredi { 1442520d7c86SMiklos Szeredi int err; 1443bca44b52SMiklos Szeredi struct path workpath = { }; 1444520d7c86SMiklos Szeredi 1445ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.workdir, &workpath); 1446520d7c86SMiklos Szeredi if (err) 1447520d7c86SMiklos Szeredi goto out; 1448520d7c86SMiklos Szeredi 1449520d7c86SMiklos Szeredi err = -EINVAL; 1450bca44b52SMiklos Szeredi if (upperpath->mnt != workpath.mnt) { 14511bd0a3aeSlijiazi pr_err("workdir and upperdir must reside under the same mount\n"); 1452520d7c86SMiklos Szeredi goto out; 1453520d7c86SMiklos Szeredi } 1454bca44b52SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 14551bd0a3aeSlijiazi pr_err("workdir and upperdir must be separate subtrees\n"); 1456520d7c86SMiklos Szeredi goto out; 1457520d7c86SMiklos Szeredi } 1458520d7c86SMiklos Szeredi 14598c25741aSMiklos Szeredi ofs->workbasedir = dget(workpath.dentry); 14608c25741aSMiklos Szeredi 14618c25741aSMiklos Szeredi if (ovl_inuse_trylock(ofs->workbasedir)) { 1462ad204488SMiklos Szeredi ofs->workdir_locked = true; 1463520d7c86SMiklos Szeredi } else { 14640be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "workdir"); 14650be0bfd2SAmir Goldstein if (err) 14660be0bfd2SAmir Goldstein goto out; 1467520d7c86SMiklos Szeredi } 1468520d7c86SMiklos Szeredi 14690be0bfd2SAmir Goldstein err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap, 14700be0bfd2SAmir Goldstein "workdir"); 14710be0bfd2SAmir Goldstein if (err) 14720be0bfd2SAmir Goldstein goto out; 14730be0bfd2SAmir Goldstein 1474146d62e5SAmir Goldstein err = ovl_make_workdir(sb, ofs, &workpath); 1475bca44b52SMiklos Szeredi 1476520d7c86SMiklos Szeredi out: 1477bca44b52SMiklos Szeredi path_put(&workpath); 1478bca44b52SMiklos Szeredi 1479520d7c86SMiklos Szeredi return err; 1480520d7c86SMiklos Szeredi } 1481520d7c86SMiklos Szeredi 1482146d62e5SAmir Goldstein static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs, 1483146d62e5SAmir Goldstein struct ovl_entry *oe, struct path *upperpath) 1484f7e3a7d9SMiklos Szeredi { 148508f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 1486235ce9edSAmir Goldstein struct dentry *indexdir; 1487f7e3a7d9SMiklos Szeredi int err; 1488f7e3a7d9SMiklos Szeredi 14892ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 14902ba9d57eSAmir Goldstein if (err) 14912ba9d57eSAmir Goldstein return err; 14922ba9d57eSAmir Goldstein 1493f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 1494610afc0bSMiklos Szeredi err = ovl_verify_origin(ofs, upperpath->dentry, 1495610afc0bSMiklos Szeredi oe->lowerstack[0].dentry, true); 1496f7e3a7d9SMiklos Szeredi if (err) { 14971bd0a3aeSlijiazi pr_err("failed to verify upper root origin\n"); 1498f7e3a7d9SMiklos Szeredi goto out; 1499f7e3a7d9SMiklos Szeredi } 1500f7e3a7d9SMiklos Szeredi 150120396365SAmir Goldstein /* index dir will act also as workdir */ 150220396365SAmir Goldstein iput(ofs->workdir_trap); 150320396365SAmir Goldstein ofs->workdir_trap = NULL; 150420396365SAmir Goldstein dput(ofs->workdir); 1505470c1563SAmir Goldstein ofs->workdir = NULL; 1506235ce9edSAmir Goldstein indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1507235ce9edSAmir Goldstein if (IS_ERR(indexdir)) { 1508235ce9edSAmir Goldstein err = PTR_ERR(indexdir); 1509235ce9edSAmir Goldstein } else if (indexdir) { 1510235ce9edSAmir Goldstein ofs->indexdir = indexdir; 1511235ce9edSAmir Goldstein ofs->workdir = dget(indexdir); 151220396365SAmir Goldstein 1513146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap, 1514146d62e5SAmir Goldstein "indexdir"); 1515146d62e5SAmir Goldstein if (err) 1516146d62e5SAmir Goldstein goto out; 1517146d62e5SAmir Goldstein 1518ad1d615cSAmir Goldstein /* 1519ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir. 1520*2d2f2d73SMiklos Szeredi * Older kernels stored upper fh in ".overlay.origin" 1521ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to 1522ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr 1523*2d2f2d73SMiklos Szeredi * ".overlay.upper" to indicate that index may have 1524ad1d615cSAmir Goldstein * directory entries. 1525ad1d615cSAmir Goldstein */ 1526610afc0bSMiklos Szeredi if (ovl_check_origin_xattr(ofs, ofs->indexdir)) { 1527610afc0bSMiklos Szeredi err = ovl_verify_set_fh(ofs, ofs->indexdir, 1528610afc0bSMiklos Szeredi OVL_XATTR_ORIGIN, 1529ad1d615cSAmir Goldstein upperpath->dentry, true, false); 1530f7e3a7d9SMiklos Szeredi if (err) 15311bd0a3aeSlijiazi pr_err("failed to verify index dir 'origin' xattr\n"); 1532ad1d615cSAmir Goldstein } 1533610afc0bSMiklos Szeredi err = ovl_verify_upper(ofs, ofs->indexdir, upperpath->dentry, 1534610afc0bSMiklos Szeredi true); 1535ad1d615cSAmir Goldstein if (err) 15361bd0a3aeSlijiazi pr_err("failed to verify index dir 'upper' xattr\n"); 1537f7e3a7d9SMiklos Szeredi 1538f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 1539f7e3a7d9SMiklos Szeredi if (!err) 15401eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs); 1541f7e3a7d9SMiklos Szeredi } 1542ad204488SMiklos Szeredi if (err || !ofs->indexdir) 15431bd0a3aeSlijiazi pr_warn("try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1544f7e3a7d9SMiklos Szeredi 1545f7e3a7d9SMiklos Szeredi out: 15462ba9d57eSAmir Goldstein mnt_drop_write(mnt); 1547f7e3a7d9SMiklos Szeredi return err; 1548f7e3a7d9SMiklos Szeredi } 1549f7e3a7d9SMiklos Szeredi 15509df085f3SAmir Goldstein static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid) 15515148626bSAmir Goldstein { 15525148626bSAmir Goldstein unsigned int i; 15539df085f3SAmir Goldstein 155408f4c7c8SMiklos Szeredi if (!ofs->config.nfs_export && !ovl_upper_mnt(ofs)) 15559df085f3SAmir Goldstein return true; 15569df085f3SAmir Goldstein 1557a888db31SAmir Goldstein /* 1558a888db31SAmir Goldstein * We allow using single lower with null uuid for index and nfs_export 1559a888db31SAmir Goldstein * for example to support those features with single lower squashfs. 1560a888db31SAmir Goldstein * To avoid regressions in setups of overlay with re-formatted lower 1561a888db31SAmir Goldstein * squashfs, do not allow decoding origin with lower null uuid unless 1562a888db31SAmir Goldstein * user opted-in to one of the new features that require following the 1563a888db31SAmir Goldstein * lower inode of non-dir upper. 1564a888db31SAmir Goldstein */ 1565a888db31SAmir Goldstein if (!ofs->config.index && !ofs->config.metacopy && !ofs->config.xino && 1566a888db31SAmir Goldstein uuid_is_null(uuid)) 1567a888db31SAmir Goldstein return false; 1568a888db31SAmir Goldstein 15691b81ddddSAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 15709df085f3SAmir Goldstein /* 15719df085f3SAmir Goldstein * We use uuid to associate an overlay lower file handle with a 15729df085f3SAmir Goldstein * lower layer, so we can accept lower fs with null uuid as long 15739df085f3SAmir Goldstein * as all lower layers with null uuid are on the same fs. 15747e63c87fSAmir Goldstein * if we detect multiple lower fs with the same uuid, we 15757e63c87fSAmir Goldstein * disable lower file handle decoding on all of them. 15769df085f3SAmir Goldstein */ 15771b81ddddSAmir Goldstein if (ofs->fs[i].is_lower && 15781b81ddddSAmir Goldstein uuid_equal(&ofs->fs[i].sb->s_uuid, uuid)) { 157907f1e596SAmir Goldstein ofs->fs[i].bad_uuid = true; 15809df085f3SAmir Goldstein return false; 15819df085f3SAmir Goldstein } 15827e63c87fSAmir Goldstein } 15839df085f3SAmir Goldstein return true; 15849df085f3SAmir Goldstein } 15859df085f3SAmir Goldstein 15869df085f3SAmir Goldstein /* Get a unique fsid for the layer */ 15879df085f3SAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) 15889df085f3SAmir Goldstein { 15899df085f3SAmir Goldstein struct super_block *sb = path->mnt->mnt_sb; 15909df085f3SAmir Goldstein unsigned int i; 15915148626bSAmir Goldstein dev_t dev; 15925148626bSAmir Goldstein int err; 15937e63c87fSAmir Goldstein bool bad_uuid = false; 15945148626bSAmir Goldstein 159507f1e596SAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 159607f1e596SAmir Goldstein if (ofs->fs[i].sb == sb) 159707f1e596SAmir Goldstein return i; 15985148626bSAmir Goldstein } 15995148626bSAmir Goldstein 16009df085f3SAmir Goldstein if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) { 16017e63c87fSAmir Goldstein bad_uuid = true; 16027e63c87fSAmir Goldstein if (ofs->config.index || ofs->config.nfs_export) { 16039df085f3SAmir Goldstein ofs->config.index = false; 16049df085f3SAmir Goldstein ofs->config.nfs_export = false; 16051bd0a3aeSlijiazi pr_warn("%s uuid detected in lower fs '%pd2', falling back to index=off,nfs_export=off.\n", 16067e63c87fSAmir Goldstein uuid_is_null(&sb->s_uuid) ? "null" : 16077e63c87fSAmir Goldstein "conflicting", 16089df085f3SAmir Goldstein path->dentry); 16099df085f3SAmir Goldstein } 16107e63c87fSAmir Goldstein } 16119df085f3SAmir Goldstein 16125148626bSAmir Goldstein err = get_anon_bdev(&dev); 16135148626bSAmir Goldstein if (err) { 16141bd0a3aeSlijiazi pr_err("failed to get anonymous bdev for lowerpath\n"); 16155148626bSAmir Goldstein return err; 16165148626bSAmir Goldstein } 16175148626bSAmir Goldstein 161807f1e596SAmir Goldstein ofs->fs[ofs->numfs].sb = sb; 161907f1e596SAmir Goldstein ofs->fs[ofs->numfs].pseudo_dev = dev; 162007f1e596SAmir Goldstein ofs->fs[ofs->numfs].bad_uuid = bad_uuid; 16215148626bSAmir Goldstein 162207f1e596SAmir Goldstein return ofs->numfs++; 16235148626bSAmir Goldstein } 16245148626bSAmir Goldstein 162594375f9dSAmir Goldstein static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, 1626b8e42a65SMiklos Szeredi struct path *stack, unsigned int numlower, 1627b8e42a65SMiklos Szeredi struct ovl_layer *layers) 1628520d7c86SMiklos Szeredi { 1629520d7c86SMiklos Szeredi int err; 1630520d7c86SMiklos Szeredi unsigned int i; 1631520d7c86SMiklos Szeredi 1632520d7c86SMiklos Szeredi err = -ENOMEM; 163307f1e596SAmir Goldstein ofs->fs = kcalloc(numlower + 1, sizeof(struct ovl_sb), GFP_KERNEL); 163407f1e596SAmir Goldstein if (ofs->fs == NULL) 16355148626bSAmir Goldstein goto out; 16365148626bSAmir Goldstein 163707f1e596SAmir Goldstein /* idx/fsid 0 are reserved for upper fs even with lower only overlay */ 163807f1e596SAmir Goldstein ofs->numfs++; 163907f1e596SAmir Goldstein 164007f1e596SAmir Goldstein /* 1641b7bf9908SAmir Goldstein * All lower layers that share the same fs as upper layer, use the same 1642b7bf9908SAmir Goldstein * pseudo_dev as upper layer. Allocate fs[0].pseudo_dev even for lower 1643b7bf9908SAmir Goldstein * only overlay to simplify ovl_fs_free(). 16441b81ddddSAmir Goldstein * is_lower will be set if upper fs is shared with a lower layer. 164507f1e596SAmir Goldstein */ 1646b7bf9908SAmir Goldstein err = get_anon_bdev(&ofs->fs[0].pseudo_dev); 1647b7bf9908SAmir Goldstein if (err) { 1648b7bf9908SAmir Goldstein pr_err("failed to get anonymous bdev for upper fs\n"); 1649b7bf9908SAmir Goldstein goto out; 1650b7bf9908SAmir Goldstein } 1651b7bf9908SAmir Goldstein 165208f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 165308f4c7c8SMiklos Szeredi ofs->fs[0].sb = ovl_upper_mnt(ofs)->mnt_sb; 16541b81ddddSAmir Goldstein ofs->fs[0].is_lower = false; 165507f1e596SAmir Goldstein } 165607f1e596SAmir Goldstein 1657520d7c86SMiklos Szeredi for (i = 0; i < numlower; i++) { 1658520d7c86SMiklos Szeredi struct vfsmount *mnt; 1659146d62e5SAmir Goldstein struct inode *trap; 16605148626bSAmir Goldstein int fsid; 1661520d7c86SMiklos Szeredi 16629df085f3SAmir Goldstein err = fsid = ovl_get_fsid(ofs, &stack[i]); 16635148626bSAmir Goldstein if (err < 0) 1664520d7c86SMiklos Szeredi goto out; 1665520d7c86SMiklos Szeredi 166624f14009Syoungjun /* 166724f14009Syoungjun * Check if lower root conflicts with this overlay layers before 166824f14009Syoungjun * checking if it is in-use as upperdir/workdir of "another" 166924f14009Syoungjun * mount, because we do not bother to check in ovl_is_inuse() if 167024f14009Syoungjun * the upperdir/workdir is in fact in-use by our 167124f14009Syoungjun * upperdir/workdir. 167224f14009Syoungjun */ 1673146d62e5SAmir Goldstein err = ovl_setup_trap(sb, stack[i].dentry, &trap, "lowerdir"); 1674146d62e5SAmir Goldstein if (err) 1675146d62e5SAmir Goldstein goto out; 1676146d62e5SAmir Goldstein 16770be0bfd2SAmir Goldstein if (ovl_is_inuse(stack[i].dentry)) { 16780be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "lowerdir"); 167924f14009Syoungjun if (err) { 168024f14009Syoungjun iput(trap); 16810be0bfd2SAmir Goldstein goto out; 16820be0bfd2SAmir Goldstein } 168324f14009Syoungjun } 16840be0bfd2SAmir Goldstein 1685520d7c86SMiklos Szeredi mnt = clone_private_mount(&stack[i]); 1686520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1687520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 16881bd0a3aeSlijiazi pr_err("failed to clone lowerpath\n"); 1689146d62e5SAmir Goldstein iput(trap); 1690520d7c86SMiklos Szeredi goto out; 1691520d7c86SMiklos Szeredi } 16925148626bSAmir Goldstein 1693520d7c86SMiklos Szeredi /* 1694520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1695520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1696520d7c86SMiklos Szeredi */ 1697520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1698520d7c86SMiklos Szeredi 169913464165SMiklos Szeredi layers[ofs->numlayer].trap = trap; 170013464165SMiklos Szeredi layers[ofs->numlayer].mnt = mnt; 170113464165SMiklos Szeredi layers[ofs->numlayer].idx = ofs->numlayer; 170213464165SMiklos Szeredi layers[ofs->numlayer].fsid = fsid; 170313464165SMiklos Szeredi layers[ofs->numlayer].fs = &ofs->fs[fsid]; 170494375f9dSAmir Goldstein ofs->numlayer++; 17051b81ddddSAmir Goldstein ofs->fs[fsid].is_lower = true; 1706520d7c86SMiklos Szeredi } 1707e487d889SAmir Goldstein 1708795939a9SAmir Goldstein /* 1709795939a9SAmir Goldstein * When all layers on same fs, overlay can use real inode numbers. 1710926e94d7SAmir Goldstein * With mount option "xino=<on|auto>", mounter declares that there are 1711926e94d7SAmir Goldstein * enough free high bits in underlying fs to hold the unique fsid. 1712795939a9SAmir Goldstein * If overlayfs does encounter underlying inodes using the high xino 1713795939a9SAmir Goldstein * bits reserved for fsid, it emits a warning and uses the original 1714dfe51d47SAmir Goldstein * inode number or a non persistent inode number allocated from a 1715dfe51d47SAmir Goldstein * dedicated range. 1716795939a9SAmir Goldstein */ 171708f4c7c8SMiklos Szeredi if (ofs->numfs - !ovl_upper_mnt(ofs) == 1) { 17180f831ec8SAmir Goldstein if (ofs->config.xino == OVL_XINO_ON) 17190f831ec8SAmir Goldstein pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n"); 17200f831ec8SAmir Goldstein ofs->xino_mode = 0; 172153afcd31SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_OFF) { 172253afcd31SAmir Goldstein ofs->xino_mode = -1; 1723926e94d7SAmir Goldstein } else if (ofs->xino_mode < 0) { 1724795939a9SAmir Goldstein /* 172507f1e596SAmir Goldstein * This is a roundup of number of bits needed for encoding 1726dfe51d47SAmir Goldstein * fsid, where fsid 0 is reserved for upper fs (even with 1727dfe51d47SAmir Goldstein * lower only overlay) +1 extra bit is reserved for the non 1728dfe51d47SAmir Goldstein * persistent inode number range that is used for resolving 1729dfe51d47SAmir Goldstein * xino lower bits overflow. 1730795939a9SAmir Goldstein */ 1731dfe51d47SAmir Goldstein BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 30); 1732dfe51d47SAmir Goldstein ofs->xino_mode = ilog2(ofs->numfs - 1) + 2; 1733795939a9SAmir Goldstein } 1734795939a9SAmir Goldstein 17350f831ec8SAmir Goldstein if (ofs->xino_mode > 0) { 17361bd0a3aeSlijiazi pr_info("\"xino\" feature enabled using %d upper inode bits.\n", 17370f831ec8SAmir Goldstein ofs->xino_mode); 1738795939a9SAmir Goldstein } 1739e487d889SAmir Goldstein 1740520d7c86SMiklos Szeredi err = 0; 1741520d7c86SMiklos Szeredi out: 1742520d7c86SMiklos Szeredi return err; 1743520d7c86SMiklos Szeredi } 1744520d7c86SMiklos Szeredi 17454155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1746b8e42a65SMiklos Szeredi const char *lower, unsigned int numlower, 1747b8e42a65SMiklos Szeredi struct ovl_fs *ofs, struct ovl_layer *layers) 174853dbb0b4SMiklos Szeredi { 174953dbb0b4SMiklos Szeredi int err; 17504155c10aSMiklos Szeredi struct path *stack = NULL; 1751b8e42a65SMiklos Szeredi unsigned int i; 17524155c10aSMiklos Szeredi struct ovl_entry *oe; 175353dbb0b4SMiklos Szeredi 1754b8e42a65SMiklos Szeredi if (!ofs->config.upperdir && numlower == 1) { 17551bd0a3aeSlijiazi pr_err("at least 2 lowerdir are needed while upperdir nonexistent\n"); 1756b8e42a65SMiklos Szeredi return ERR_PTR(-EINVAL); 175753dbb0b4SMiklos Szeredi } 175853dbb0b4SMiklos Szeredi 1759b8e42a65SMiklos Szeredi stack = kcalloc(numlower, sizeof(struct path), GFP_KERNEL); 176053dbb0b4SMiklos Szeredi if (!stack) 1761b8e42a65SMiklos Szeredi return ERR_PTR(-ENOMEM); 176253dbb0b4SMiklos Szeredi 176353dbb0b4SMiklos Szeredi err = -EINVAL; 1764b8e42a65SMiklos Szeredi for (i = 0; i < numlower; i++) { 1765b8e42a65SMiklos Szeredi err = ovl_lower_dir(lower, &stack[i], ofs, &sb->s_stack_depth); 176653dbb0b4SMiklos Szeredi if (err) 17674155c10aSMiklos Szeredi goto out_err; 176853dbb0b4SMiklos Szeredi 176953dbb0b4SMiklos Szeredi lower = strchr(lower, '\0') + 1; 177053dbb0b4SMiklos Szeredi } 177153dbb0b4SMiklos Szeredi 177253dbb0b4SMiklos Szeredi err = -EINVAL; 177353dbb0b4SMiklos Szeredi sb->s_stack_depth++; 177453dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 17751bd0a3aeSlijiazi pr_err("maximum fs stacking depth exceeded\n"); 17764155c10aSMiklos Szeredi goto out_err; 177753dbb0b4SMiklos Szeredi } 177853dbb0b4SMiklos Szeredi 1779b8e42a65SMiklos Szeredi err = ovl_get_layers(sb, ofs, stack, numlower, layers); 17804155c10aSMiklos Szeredi if (err) 17814155c10aSMiklos Szeredi goto out_err; 17824155c10aSMiklos Szeredi 17834155c10aSMiklos Szeredi err = -ENOMEM; 17844155c10aSMiklos Szeredi oe = ovl_alloc_entry(numlower); 17854155c10aSMiklos Szeredi if (!oe) 17864155c10aSMiklos Szeredi goto out_err; 17874155c10aSMiklos Szeredi 17884155c10aSMiklos Szeredi for (i = 0; i < numlower; i++) { 17894155c10aSMiklos Szeredi oe->lowerstack[i].dentry = dget(stack[i].dentry); 179094375f9dSAmir Goldstein oe->lowerstack[i].layer = &ofs->layers[i+1]; 17914155c10aSMiklos Szeredi } 179253dbb0b4SMiklos Szeredi 179353dbb0b4SMiklos Szeredi out: 179453dbb0b4SMiklos Szeredi for (i = 0; i < numlower; i++) 179553dbb0b4SMiklos Szeredi path_put(&stack[i]); 179653dbb0b4SMiklos Szeredi kfree(stack); 17974155c10aSMiklos Szeredi 17984155c10aSMiklos Szeredi return oe; 17994155c10aSMiklos Szeredi 18004155c10aSMiklos Szeredi out_err: 18014155c10aSMiklos Szeredi oe = ERR_PTR(err); 180253dbb0b4SMiklos Szeredi goto out; 180353dbb0b4SMiklos Szeredi } 180453dbb0b4SMiklos Szeredi 1805146d62e5SAmir Goldstein /* 1806146d62e5SAmir Goldstein * Check if this layer root is a descendant of: 1807146d62e5SAmir Goldstein * - another layer of this overlayfs instance 1808146d62e5SAmir Goldstein * - upper/work dir of any overlayfs instance 1809146d62e5SAmir Goldstein */ 18100be0bfd2SAmir Goldstein static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs, 18110be0bfd2SAmir Goldstein struct dentry *dentry, const char *name) 1812146d62e5SAmir Goldstein { 18139179c21dSMiklos Szeredi struct dentry *next = dentry, *parent; 1814146d62e5SAmir Goldstein int err = 0; 1815146d62e5SAmir Goldstein 18169179c21dSMiklos Szeredi if (!dentry) 1817146d62e5SAmir Goldstein return 0; 1818146d62e5SAmir Goldstein 1819146d62e5SAmir Goldstein parent = dget_parent(next); 18209179c21dSMiklos Szeredi 18219179c21dSMiklos Szeredi /* Walk back ancestors to root (inclusive) looking for traps */ 18229179c21dSMiklos Szeredi while (!err && parent != next) { 18230be0bfd2SAmir Goldstein if (ovl_lookup_trap_inode(sb, parent)) { 1824146d62e5SAmir Goldstein err = -ELOOP; 18251bd0a3aeSlijiazi pr_err("overlapping %s path\n", name); 18260be0bfd2SAmir Goldstein } else if (ovl_is_inuse(parent)) { 18270be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, name); 1828146d62e5SAmir Goldstein } 1829146d62e5SAmir Goldstein next = parent; 18309179c21dSMiklos Szeredi parent = dget_parent(next); 18319179c21dSMiklos Szeredi dput(next); 1832146d62e5SAmir Goldstein } 1833146d62e5SAmir Goldstein 18349179c21dSMiklos Szeredi dput(parent); 1835146d62e5SAmir Goldstein 1836146d62e5SAmir Goldstein return err; 1837146d62e5SAmir Goldstein } 1838146d62e5SAmir Goldstein 1839146d62e5SAmir Goldstein /* 1840146d62e5SAmir Goldstein * Check if any of the layers or work dirs overlap. 1841146d62e5SAmir Goldstein */ 1842146d62e5SAmir Goldstein static int ovl_check_overlapping_layers(struct super_block *sb, 1843146d62e5SAmir Goldstein struct ovl_fs *ofs) 1844146d62e5SAmir Goldstein { 1845146d62e5SAmir Goldstein int i, err; 1846146d62e5SAmir Goldstein 184708f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 184808f4c7c8SMiklos Szeredi err = ovl_check_layer(sb, ofs, ovl_upper_mnt(ofs)->mnt_root, 18490be0bfd2SAmir Goldstein "upperdir"); 1850146d62e5SAmir Goldstein if (err) 1851146d62e5SAmir Goldstein return err; 1852146d62e5SAmir Goldstein 1853146d62e5SAmir Goldstein /* 1854146d62e5SAmir Goldstein * Checking workbasedir avoids hitting ovl_is_inuse(parent) of 1855146d62e5SAmir Goldstein * this instance and covers overlapping work and index dirs, 1856146d62e5SAmir Goldstein * unless work or index dir have been moved since created inside 1857146d62e5SAmir Goldstein * workbasedir. In that case, we already have their traps in 1858146d62e5SAmir Goldstein * inode cache and we will catch that case on lookup. 1859146d62e5SAmir Goldstein */ 18600be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir"); 1861146d62e5SAmir Goldstein if (err) 1862146d62e5SAmir Goldstein return err; 1863146d62e5SAmir Goldstein } 1864146d62e5SAmir Goldstein 186594375f9dSAmir Goldstein for (i = 1; i < ofs->numlayer; i++) { 18660be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, 186794375f9dSAmir Goldstein ofs->layers[i].mnt->mnt_root, 1868146d62e5SAmir Goldstein "lowerdir"); 1869146d62e5SAmir Goldstein if (err) 1870146d62e5SAmir Goldstein return err; 1871146d62e5SAmir Goldstein } 1872146d62e5SAmir Goldstein 1873146d62e5SAmir Goldstein return 0; 1874146d62e5SAmir Goldstein } 1875146d62e5SAmir Goldstein 18762effc5c2SAmir Goldstein static struct dentry *ovl_get_root(struct super_block *sb, 18772effc5c2SAmir Goldstein struct dentry *upperdentry, 18782effc5c2SAmir Goldstein struct ovl_entry *oe) 18792effc5c2SAmir Goldstein { 18802effc5c2SAmir Goldstein struct dentry *root; 188162c832edSAmir Goldstein struct ovl_path *lowerpath = &oe->lowerstack[0]; 188262c832edSAmir Goldstein unsigned long ino = d_inode(lowerpath->dentry)->i_ino; 188362c832edSAmir Goldstein int fsid = lowerpath->layer->fsid; 188462c832edSAmir Goldstein struct ovl_inode_params oip = { 188562c832edSAmir Goldstein .upperdentry = upperdentry, 188662c832edSAmir Goldstein .lowerpath = lowerpath, 188762c832edSAmir Goldstein }; 18882effc5c2SAmir Goldstein 18892effc5c2SAmir Goldstein root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 18902effc5c2SAmir Goldstein if (!root) 18912effc5c2SAmir Goldstein return NULL; 18922effc5c2SAmir Goldstein 18932effc5c2SAmir Goldstein root->d_fsdata = oe; 18942effc5c2SAmir Goldstein 18952effc5c2SAmir Goldstein if (upperdentry) { 189662c832edSAmir Goldstein /* Root inode uses upper st_ino/i_ino */ 189762c832edSAmir Goldstein ino = d_inode(upperdentry)->i_ino; 189862c832edSAmir Goldstein fsid = 0; 18992effc5c2SAmir Goldstein ovl_dentry_set_upper_alias(root); 1900610afc0bSMiklos Szeredi if (ovl_is_impuredir(sb, upperdentry)) 19012effc5c2SAmir Goldstein ovl_set_flag(OVL_IMPURE, d_inode(root)); 19022effc5c2SAmir Goldstein } 19032effc5c2SAmir Goldstein 19042effc5c2SAmir Goldstein /* Root is always merge -> can have whiteouts */ 19052effc5c2SAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root)); 19062effc5c2SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root); 19072effc5c2SAmir Goldstein ovl_set_upperdata(d_inode(root)); 190862c832edSAmir Goldstein ovl_inode_init(d_inode(root), &oip, ino, fsid); 1909f4288844SMiklos Szeredi ovl_dentry_update_reval(root, upperdentry, DCACHE_OP_WEAK_REVALIDATE); 19102effc5c2SAmir Goldstein 19112effc5c2SAmir Goldstein return root; 19122effc5c2SAmir Goldstein } 19132effc5c2SAmir Goldstein 1914e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1915e9be9d5eSMiklos Szeredi { 191633006cdfSKees Cook struct path upperpath = { }; 1917e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 19184155c10aSMiklos Szeredi struct ovl_entry *oe; 1919ad204488SMiklos Szeredi struct ovl_fs *ofs; 1920b8e42a65SMiklos Szeredi struct ovl_layer *layers; 192151f8f3c4SKonstantin Khlebnikov struct cred *cred; 1922b8e42a65SMiklos Szeredi char *splitlower = NULL; 1923b8e42a65SMiklos Szeredi unsigned int numlower; 1924e9be9d5eSMiklos Szeredi int err; 1925e9be9d5eSMiklos Szeredi 1926f4288844SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 1927f4288844SMiklos Szeredi 1928f45827e8SErez Zadok err = -ENOMEM; 1929ad204488SMiklos Szeredi ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1930ad204488SMiklos Szeredi if (!ofs) 1931e9be9d5eSMiklos Szeredi goto out; 1932e9be9d5eSMiklos Szeredi 1933ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1934c6fe6254SMiklos Szeredi if (!cred) 1935c6fe6254SMiklos Szeredi goto out_err; 1936c6fe6254SMiklos Szeredi 1937c21c839bSChengguang Xu /* Is there a reason anyone would want not to share whiteouts? */ 1938c21c839bSChengguang Xu ofs->share_whiteout = true; 1939c21c839bSChengguang Xu 1940ad204488SMiklos Szeredi ofs->config.index = ovl_index_def; 19415830fb6bSPavel Tikhomirov ofs->config.uuid = true; 1942f168f109SAmir Goldstein ofs->config.nfs_export = ovl_nfs_export_def; 1943795939a9SAmir Goldstein ofs->config.xino = ovl_xino_def(); 1944d5791044SVivek Goyal ofs->config.metacopy = ovl_metacopy_def; 1945ad204488SMiklos Szeredi err = ovl_parse_opt((char *) data, &ofs->config); 1946f45827e8SErez Zadok if (err) 1947a9075cdbSMiklos Szeredi goto out_err; 1948f45827e8SErez Zadok 1949e9be9d5eSMiklos Szeredi err = -EINVAL; 1950ad204488SMiklos Szeredi if (!ofs->config.lowerdir) { 195107f2af7bSKonstantin Khlebnikov if (!silent) 19521bd0a3aeSlijiazi pr_err("missing 'lowerdir'\n"); 1953a9075cdbSMiklos Szeredi goto out_err; 195453a08cb9SMiklos Szeredi } 195553a08cb9SMiklos Szeredi 1956b8e42a65SMiklos Szeredi err = -ENOMEM; 1957b8e42a65SMiklos Szeredi splitlower = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 1958b8e42a65SMiklos Szeredi if (!splitlower) 1959b8e42a65SMiklos Szeredi goto out_err; 1960b8e42a65SMiklos Szeredi 1961b8e42a65SMiklos Szeredi numlower = ovl_split_lowerdirs(splitlower); 1962b8e42a65SMiklos Szeredi if (numlower > OVL_MAX_STACK) { 1963b8e42a65SMiklos Szeredi pr_err("too many lower directories, limit is %d\n", 1964b8e42a65SMiklos Szeredi OVL_MAX_STACK); 1965b8e42a65SMiklos Szeredi goto out_err; 1966b8e42a65SMiklos Szeredi } 1967b8e42a65SMiklos Szeredi 1968b8e42a65SMiklos Szeredi layers = kcalloc(numlower + 1, sizeof(struct ovl_layer), GFP_KERNEL); 1969b8e42a65SMiklos Szeredi if (!layers) 1970b8e42a65SMiklos Szeredi goto out_err; 1971b8e42a65SMiklos Szeredi 1972b8e42a65SMiklos Szeredi ofs->layers = layers; 1973b8e42a65SMiklos Szeredi /* Layer 0 is reserved for upper even if there's no upper */ 1974b8e42a65SMiklos Szeredi ofs->numlayer = 1; 1975b8e42a65SMiklos Szeredi 197653a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 1977cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 19784d314f78SAmir Goldstein atomic_long_set(&ofs->last_ino, 1); 1979e487d889SAmir Goldstein /* Assume underlaying fs uses 32bit inodes unless proven otherwise */ 198053afcd31SAmir Goldstein if (ofs->config.xino != OVL_XINO_OFF) { 19810f831ec8SAmir Goldstein ofs->xino_mode = BITS_PER_LONG - 32; 198253afcd31SAmir Goldstein if (!ofs->xino_mode) { 198353afcd31SAmir Goldstein pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n"); 198453afcd31SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 198553afcd31SAmir Goldstein } 198653afcd31SAmir Goldstein } 1987795939a9SAmir Goldstein 1988146d62e5SAmir Goldstein /* alloc/destroy_inode needed for setting up traps in inode cache */ 1989146d62e5SAmir Goldstein sb->s_op = &ovl_super_operations; 1990146d62e5SAmir Goldstein 1991ad204488SMiklos Szeredi if (ofs->config.upperdir) { 1992ad204488SMiklos Szeredi if (!ofs->config.workdir) { 19931bd0a3aeSlijiazi pr_err("missing 'workdir'\n"); 1994a9075cdbSMiklos Szeredi goto out_err; 1995e9be9d5eSMiklos Szeredi } 1996e9be9d5eSMiklos Szeredi 1997b8e42a65SMiklos Szeredi err = ovl_get_upper(sb, ofs, &layers[0], &upperpath); 199821a3b317SMiklos Szeredi if (err) 1999a9075cdbSMiklos Szeredi goto out_err; 2000d719e8f2SMiklos Szeredi 2001146d62e5SAmir Goldstein err = ovl_get_workdir(sb, ofs, &upperpath); 20028ed61dc3SMiklos Szeredi if (err) 2003a9075cdbSMiklos Szeredi goto out_err; 2004c6fe6254SMiklos Szeredi 2005ad204488SMiklos Szeredi if (!ofs->workdir) 20061751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 20076e88256eSMiklos Szeredi 200808f4c7c8SMiklos Szeredi sb->s_stack_depth = ovl_upper_mnt(ofs)->mnt_sb->s_stack_depth; 200908f4c7c8SMiklos Szeredi sb->s_time_gran = ovl_upper_mnt(ofs)->mnt_sb->s_time_gran; 2010c6fe6254SMiklos Szeredi 201121765194SVivek Goyal } 2012b8e42a65SMiklos Szeredi oe = ovl_get_lowerstack(sb, splitlower, numlower, ofs, layers); 20134155c10aSMiklos Szeredi err = PTR_ERR(oe); 20144155c10aSMiklos Szeredi if (IS_ERR(oe)) 2015a9075cdbSMiklos Szeredi goto out_err; 2016e9be9d5eSMiklos Szeredi 201771cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 201808f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 20191751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 2020e9be9d5eSMiklos Szeredi 20215830fb6bSPavel Tikhomirov if (!ofs->config.uuid && ofs->numfs > 1) { 20225830fb6bSPavel Tikhomirov pr_warn("The uuid=off requires a single fs for lower and upper, falling back to uuid=on.\n"); 20235830fb6bSPavel Tikhomirov ofs->config.uuid = true; 20245830fb6bSPavel Tikhomirov } 20255830fb6bSPavel Tikhomirov 2026470c1563SAmir Goldstein if (!ovl_force_readonly(ofs) && ofs->config.index) { 2027146d62e5SAmir Goldstein err = ovl_get_indexdir(sb, ofs, oe, &upperpath); 202854fb347eSAmir Goldstein if (err) 20294155c10aSMiklos Szeredi goto out_free_oe; 20306e88256eSMiklos Szeredi 2031972d0093SAmir Goldstein /* Force r/o mount with no index dir */ 203220396365SAmir Goldstein if (!ofs->indexdir) 20331751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 203402bcd157SAmir Goldstein } 203502bcd157SAmir Goldstein 2036146d62e5SAmir Goldstein err = ovl_check_overlapping_layers(sb, ofs); 2037146d62e5SAmir Goldstein if (err) 2038146d62e5SAmir Goldstein goto out_free_oe; 2039146d62e5SAmir Goldstein 2040972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */ 2041f168f109SAmir Goldstein if (!ofs->indexdir) { 2042ad204488SMiklos Szeredi ofs->config.index = false; 204308f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs) && ofs->config.nfs_export) { 20441bd0a3aeSlijiazi pr_warn("NFS export requires an index dir, falling back to nfs_export=off.\n"); 2045f168f109SAmir Goldstein ofs->config.nfs_export = false; 2046f168f109SAmir Goldstein } 2047f168f109SAmir Goldstein } 204802bcd157SAmir Goldstein 2049d5791044SVivek Goyal if (ofs->config.metacopy && ofs->config.nfs_export) { 20501bd0a3aeSlijiazi pr_warn("NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 2051d5791044SVivek Goyal ofs->config.nfs_export = false; 2052d5791044SVivek Goyal } 2053d5791044SVivek Goyal 20548383f174SAmir Goldstein if (ofs->config.nfs_export) 20558383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations; 20568383f174SAmir Goldstein 205751f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 205851f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 205951f8f3c4SKonstantin Khlebnikov 2060655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 2061*2d2f2d73SMiklos Szeredi sb->s_xattr = ofs->config.userxattr ? ovl_user_xattr_handlers : 2062*2d2f2d73SMiklos Szeredi ovl_trusted_xattr_handlers; 2063ad204488SMiklos Szeredi sb->s_fs_info = ofs; 2064de2a4a50SMiklos Szeredi sb->s_flags |= SB_POSIXACL; 206532b1924bSKonstantin Khlebnikov sb->s_iflags |= SB_I_SKIP_SYNC; 2066655042ccSVivek Goyal 2067c6fe6254SMiklos Szeredi err = -ENOMEM; 20682effc5c2SAmir Goldstein root_dentry = ovl_get_root(sb, upperpath.dentry, oe); 2069e9be9d5eSMiklos Szeredi if (!root_dentry) 20704155c10aSMiklos Szeredi goto out_free_oe; 2071e9be9d5eSMiklos Szeredi 2072e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 2073b8e42a65SMiklos Szeredi kfree(splitlower); 2074ed06e069SMiklos Szeredi 2075e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 2076e9be9d5eSMiklos Szeredi 2077e9be9d5eSMiklos Szeredi return 0; 2078e9be9d5eSMiklos Szeredi 20794155c10aSMiklos Szeredi out_free_oe: 20804155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 2081b9343632SChandan Rajendra kfree(oe); 20824155c10aSMiklos Szeredi out_err: 2083b8e42a65SMiklos Szeredi kfree(splitlower); 2084e9be9d5eSMiklos Szeredi path_put(&upperpath); 2085ad204488SMiklos Szeredi ovl_free_fs(ofs); 2086e9be9d5eSMiklos Szeredi out: 2087e9be9d5eSMiklos Szeredi return err; 2088e9be9d5eSMiklos Szeredi } 2089e9be9d5eSMiklos Szeredi 2090e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 2091e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 2092e9be9d5eSMiklos Szeredi { 2093e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 2094e9be9d5eSMiklos Szeredi } 2095e9be9d5eSMiklos Szeredi 2096e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 2097e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 2098ef94b186SMiklos Szeredi .name = "overlay", 2099e9be9d5eSMiklos Szeredi .mount = ovl_mount, 2100e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 2101e9be9d5eSMiklos Szeredi }; 2102ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 2103e9be9d5eSMiklos Szeredi 210413cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 210513cf199dSAmir Goldstein { 210613cf199dSAmir Goldstein struct ovl_inode *oi = foo; 210713cf199dSAmir Goldstein 210813cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 210913cf199dSAmir Goldstein } 211013cf199dSAmir Goldstein 2111e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 2112e9be9d5eSMiklos Szeredi { 211313cf199dSAmir Goldstein int err; 211413cf199dSAmir Goldstein 211513cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 211613cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 211713cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 211813cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 211913cf199dSAmir Goldstein ovl_inode_init_once); 212013cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 212113cf199dSAmir Goldstein return -ENOMEM; 212213cf199dSAmir Goldstein 21232406a307SJiufei Xue err = ovl_aio_request_cache_init(); 21242406a307SJiufei Xue if (!err) { 212513cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 21262406a307SJiufei Xue if (!err) 21272406a307SJiufei Xue return 0; 21282406a307SJiufei Xue 21292406a307SJiufei Xue ovl_aio_request_cache_destroy(); 21302406a307SJiufei Xue } 213113cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 213213cf199dSAmir Goldstein 213313cf199dSAmir Goldstein return err; 2134e9be9d5eSMiklos Szeredi } 2135e9be9d5eSMiklos Szeredi 2136e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 2137e9be9d5eSMiklos Szeredi { 2138e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 213913cf199dSAmir Goldstein 214013cf199dSAmir Goldstein /* 214113cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 214213cf199dSAmir Goldstein * destroy cache. 214313cf199dSAmir Goldstein */ 214413cf199dSAmir Goldstein rcu_barrier(); 214513cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 21462406a307SJiufei Xue ovl_aio_request_cache_destroy(); 2147e9be9d5eSMiklos Szeredi } 2148e9be9d5eSMiklos Szeredi 2149e9be9d5eSMiklos Szeredi module_init(ovl_init); 2150e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 2151