1e9be9d5eSMiklos Szeredi /* 2e9be9d5eSMiklos Szeredi * 3e9be9d5eSMiklos Szeredi * Copyright (C) 2011 Novell Inc. 4e9be9d5eSMiklos Szeredi * 5e9be9d5eSMiklos Szeredi * This program is free software; you can redistribute it and/or modify it 6e9be9d5eSMiklos Szeredi * under the terms of the GNU General Public License version 2 as published by 7e9be9d5eSMiklos Szeredi * the Free Software Foundation. 8e9be9d5eSMiklos Szeredi */ 9e9be9d5eSMiklos Szeredi 105b825c3aSIngo Molnar #include <uapi/linux/magic.h> 11e9be9d5eSMiklos Szeredi #include <linux/fs.h> 12e9be9d5eSMiklos Szeredi #include <linux/namei.h> 13e9be9d5eSMiklos Szeredi #include <linux/xattr.h> 14e9be9d5eSMiklos Szeredi #include <linux/mount.h> 15e9be9d5eSMiklos Szeredi #include <linux/parser.h> 16e9be9d5eSMiklos Szeredi #include <linux/module.h> 17cc259639SAndy Whitcroft #include <linux/statfs.h> 18f45827e8SErez Zadok #include <linux/seq_file.h> 19d837a49bSMiklos Szeredi #include <linux/posix_acl_xattr.h> 20e9be9d5eSMiklos Szeredi #include "overlayfs.h" 21bbb1e54dSMiklos Szeredi #include "ovl_entry.h" 22e9be9d5eSMiklos Szeredi 23e9be9d5eSMiklos Szeredi MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 24e9be9d5eSMiklos Szeredi MODULE_DESCRIPTION("Overlay filesystem"); 25e9be9d5eSMiklos Szeredi MODULE_LICENSE("GPL"); 26e9be9d5eSMiklos Szeredi 27e9be9d5eSMiklos Szeredi 28e9be9d5eSMiklos Szeredi struct ovl_dir_cache; 29e9be9d5eSMiklos Szeredi 30a78d9f0dSMiklos Szeredi #define OVL_MAX_STACK 500 31a78d9f0dSMiklos Szeredi 32688ea0e5SMiklos Szeredi static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR); 33688ea0e5SMiklos Szeredi module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644); 34688ea0e5SMiklos Szeredi MODULE_PARM_DESC(ovl_redirect_dir_def, 35688ea0e5SMiklos Szeredi "Default to on or off for the redirect_dir feature"); 36e9be9d5eSMiklos Szeredi 3702bcd157SAmir Goldstein static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX); 3802bcd157SAmir Goldstein module_param_named(index, ovl_index_def, bool, 0644); 3902bcd157SAmir Goldstein MODULE_PARM_DESC(ovl_index_def, 4002bcd157SAmir Goldstein "Default to on or off for the inodes index feature"); 4102bcd157SAmir Goldstein 42e9be9d5eSMiklos Szeredi static void ovl_dentry_release(struct dentry *dentry) 43e9be9d5eSMiklos Szeredi { 44e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 45e9be9d5eSMiklos Szeredi 46e9be9d5eSMiklos Szeredi if (oe) { 47dd662667SMiklos Szeredi unsigned int i; 48dd662667SMiklos Szeredi 49dd662667SMiklos Szeredi for (i = 0; i < oe->numlower; i++) 50dd662667SMiklos Szeredi dput(oe->lowerstack[i].dentry); 51e9be9d5eSMiklos Szeredi kfree_rcu(oe, rcu); 52e9be9d5eSMiklos Szeredi } 53e9be9d5eSMiklos Szeredi } 54e9be9d5eSMiklos Szeredi 55b0990fbbSAmir Goldstein static int ovl_check_append_only(struct inode *inode, int flag) 56b0990fbbSAmir Goldstein { 57b0990fbbSAmir Goldstein /* 58b0990fbbSAmir Goldstein * This test was moot in vfs may_open() because overlay inode does 59b0990fbbSAmir Goldstein * not have the S_APPEND flag, so re-check on real upper inode 60b0990fbbSAmir Goldstein */ 61b0990fbbSAmir Goldstein if (IS_APPEND(inode)) { 62b0990fbbSAmir Goldstein if ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND)) 63b0990fbbSAmir Goldstein return -EPERM; 64b0990fbbSAmir Goldstein if (flag & O_TRUNC) 65b0990fbbSAmir Goldstein return -EPERM; 66b0990fbbSAmir Goldstein } 67b0990fbbSAmir Goldstein 68b0990fbbSAmir Goldstein return 0; 69b0990fbbSAmir Goldstein } 70b0990fbbSAmir Goldstein 712d902671SMiklos Szeredi static struct dentry *ovl_d_real(struct dentry *dentry, 722d902671SMiklos Szeredi const struct inode *inode, 73495e6429SMiklos Szeredi unsigned int open_flags, unsigned int flags) 74d101a125SMiklos Szeredi { 75d101a125SMiklos Szeredi struct dentry *real; 76b0990fbbSAmir Goldstein int err; 77d101a125SMiklos Szeredi 78cd91304eSMiklos Szeredi if (flags & D_REAL_UPPER) 79cd91304eSMiklos Szeredi return ovl_dentry_upper(dentry); 80cd91304eSMiklos Szeredi 81ca4c8a3aSMiklos Szeredi if (!d_is_reg(dentry)) { 82d101a125SMiklos Szeredi if (!inode || inode == d_inode(dentry)) 83d101a125SMiklos Szeredi return dentry; 84d101a125SMiklos Szeredi goto bug; 85d101a125SMiklos Szeredi } 86d101a125SMiklos Szeredi 872d902671SMiklos Szeredi if (open_flags) { 88b0990fbbSAmir Goldstein err = ovl_open_maybe_copy_up(dentry, open_flags); 892d902671SMiklos Szeredi if (err) 902d902671SMiklos Szeredi return ERR_PTR(err); 912d902671SMiklos Szeredi } 922d902671SMiklos Szeredi 93d101a125SMiklos Szeredi real = ovl_dentry_upper(dentry); 94b0990fbbSAmir Goldstein if (real && (!inode || inode == d_inode(real))) { 95b0990fbbSAmir Goldstein if (!inode) { 96b0990fbbSAmir Goldstein err = ovl_check_append_only(d_inode(real), open_flags); 97b0990fbbSAmir Goldstein if (err) 98b0990fbbSAmir Goldstein return ERR_PTR(err); 99b0990fbbSAmir Goldstein } 100d101a125SMiklos Szeredi return real; 101b0990fbbSAmir Goldstein } 102d101a125SMiklos Szeredi 103d101a125SMiklos Szeredi real = ovl_dentry_lower(dentry); 104d101a125SMiklos Szeredi if (!real) 105d101a125SMiklos Szeredi goto bug; 106d101a125SMiklos Szeredi 107c4fcfc16SMiklos Szeredi /* Handle recursion */ 108495e6429SMiklos Szeredi real = d_real(real, inode, open_flags, 0); 109c4fcfc16SMiklos Szeredi 110d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 111d101a125SMiklos Szeredi return real; 112d101a125SMiklos Szeredi bug: 113656189d2SMiklos Szeredi WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry, 114d101a125SMiklos Szeredi inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0); 115d101a125SMiklos Szeredi return dentry; 116d101a125SMiklos Szeredi } 117d101a125SMiklos Szeredi 1187c03b5d4SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 1197c03b5d4SMiklos Szeredi { 1207c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1217c03b5d4SMiklos Szeredi unsigned int i; 1227c03b5d4SMiklos Szeredi int ret = 1; 1237c03b5d4SMiklos Szeredi 1247c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1257c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1267c03b5d4SMiklos Szeredi 1277c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_REVALIDATE) { 1287c03b5d4SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1297c03b5d4SMiklos Szeredi if (ret < 0) 1307c03b5d4SMiklos Szeredi return ret; 1317c03b5d4SMiklos Szeredi if (!ret) { 1327c03b5d4SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1337c03b5d4SMiklos Szeredi d_invalidate(d); 1347c03b5d4SMiklos Szeredi return -ESTALE; 1357c03b5d4SMiklos Szeredi } 1367c03b5d4SMiklos Szeredi } 1377c03b5d4SMiklos Szeredi } 1387c03b5d4SMiklos Szeredi return 1; 1397c03b5d4SMiklos Szeredi } 1407c03b5d4SMiklos Szeredi 1417c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 1427c03b5d4SMiklos Szeredi { 1437c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1447c03b5d4SMiklos Szeredi unsigned int i; 1457c03b5d4SMiklos Szeredi int ret = 1; 1467c03b5d4SMiklos Szeredi 1477c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1487c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1497c03b5d4SMiklos Szeredi 1507c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) { 1517c03b5d4SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1527c03b5d4SMiklos Szeredi if (ret <= 0) 1537c03b5d4SMiklos Szeredi break; 1547c03b5d4SMiklos Szeredi } 1557c03b5d4SMiklos Szeredi } 1567c03b5d4SMiklos Szeredi return ret; 1577c03b5d4SMiklos Szeredi } 1587c03b5d4SMiklos Szeredi 159e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 160e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 161d101a125SMiklos Szeredi .d_real = ovl_d_real, 162e9be9d5eSMiklos Szeredi }; 163e9be9d5eSMiklos Szeredi 1647c03b5d4SMiklos Szeredi static const struct dentry_operations ovl_reval_dentry_operations = { 1657c03b5d4SMiklos Szeredi .d_release = ovl_dentry_release, 166d101a125SMiklos Szeredi .d_real = ovl_d_real, 1677c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1687c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1697c03b5d4SMiklos Szeredi }; 1707c03b5d4SMiklos Szeredi 17113cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 17213cf199dSAmir Goldstein 17313cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 17413cf199dSAmir Goldstein { 17513cf199dSAmir Goldstein struct ovl_inode *oi = kmem_cache_alloc(ovl_inode_cachep, GFP_KERNEL); 17613cf199dSAmir Goldstein 177b3885bd6SHirofumi Nakagawa if (!oi) 178b3885bd6SHirofumi Nakagawa return NULL; 179b3885bd6SHirofumi Nakagawa 18004a01ac7SMiklos Szeredi oi->cache = NULL; 181cf31c463SMiklos Szeredi oi->redirect = NULL; 18204a01ac7SMiklos Szeredi oi->version = 0; 18313c72075SMiklos Szeredi oi->flags = 0; 18409d8b586SMiklos Szeredi oi->__upperdentry = NULL; 18525b7713aSMiklos Szeredi oi->lower = NULL; 186a015dafcSAmir Goldstein mutex_init(&oi->lock); 18725b7713aSMiklos Szeredi 18813cf199dSAmir Goldstein return &oi->vfs_inode; 18913cf199dSAmir Goldstein } 19013cf199dSAmir Goldstein 19113cf199dSAmir Goldstein static void ovl_i_callback(struct rcu_head *head) 19213cf199dSAmir Goldstein { 19313cf199dSAmir Goldstein struct inode *inode = container_of(head, struct inode, i_rcu); 19413cf199dSAmir Goldstein 19513cf199dSAmir Goldstein kmem_cache_free(ovl_inode_cachep, OVL_I(inode)); 19613cf199dSAmir Goldstein } 19713cf199dSAmir Goldstein 19813cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 19913cf199dSAmir Goldstein { 20009d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 20109d8b586SMiklos Szeredi 20209d8b586SMiklos Szeredi dput(oi->__upperdentry); 203cf31c463SMiklos Szeredi kfree(oi->redirect); 2044edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 205a015dafcSAmir Goldstein mutex_destroy(&oi->lock); 20609d8b586SMiklos Szeredi 20713cf199dSAmir Goldstein call_rcu(&inode->i_rcu, ovl_i_callback); 20813cf199dSAmir Goldstein } 20913cf199dSAmir Goldstein 210e9be9d5eSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 211e9be9d5eSMiklos Szeredi { 212e9be9d5eSMiklos Szeredi struct ovl_fs *ufs = sb->s_fs_info; 213dd662667SMiklos Szeredi unsigned i; 214e9be9d5eSMiklos Szeredi 21502bcd157SAmir Goldstein dput(ufs->indexdir); 216e9be9d5eSMiklos Szeredi dput(ufs->workdir); 21785fdee1eSAmir Goldstein if (ufs->workdir_locked) 2182cac0c00SAmir Goldstein ovl_inuse_unlock(ufs->workbasedir); 2192cac0c00SAmir Goldstein dput(ufs->workbasedir); 22085fdee1eSAmir Goldstein if (ufs->upper_mnt && ufs->upperdir_locked) 2212cac0c00SAmir Goldstein ovl_inuse_unlock(ufs->upper_mnt->mnt_root); 222e9be9d5eSMiklos Szeredi mntput(ufs->upper_mnt); 223dd662667SMiklos Szeredi for (i = 0; i < ufs->numlower; i++) 224dd662667SMiklos Szeredi mntput(ufs->lower_mnt[i]); 2255ffdbe8bSKonstantin Khlebnikov kfree(ufs->lower_mnt); 226e9be9d5eSMiklos Szeredi 227f45827e8SErez Zadok kfree(ufs->config.lowerdir); 228f45827e8SErez Zadok kfree(ufs->config.upperdir); 229f45827e8SErez Zadok kfree(ufs->config.workdir); 2303fe6e52fSAntonio Murdaca put_cred(ufs->creator_cred); 231e9be9d5eSMiklos Szeredi kfree(ufs); 232e9be9d5eSMiklos Szeredi } 233e9be9d5eSMiklos Szeredi 234e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 235e593b2bfSAmir Goldstein { 236e593b2bfSAmir Goldstein struct ovl_fs *ufs = sb->s_fs_info; 237e593b2bfSAmir Goldstein struct super_block *upper_sb; 238e593b2bfSAmir Goldstein int ret; 239e593b2bfSAmir Goldstein 240e593b2bfSAmir Goldstein if (!ufs->upper_mnt) 241e593b2bfSAmir Goldstein return 0; 242e593b2bfSAmir Goldstein upper_sb = ufs->upper_mnt->mnt_sb; 243e593b2bfSAmir Goldstein if (!upper_sb->s_op->sync_fs) 244e593b2bfSAmir Goldstein return 0; 245e593b2bfSAmir Goldstein 246e593b2bfSAmir Goldstein /* real inodes have already been synced by sync_filesystem(ovl_sb) */ 247e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 248e593b2bfSAmir Goldstein ret = upper_sb->s_op->sync_fs(upper_sb, wait); 249e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 250e593b2bfSAmir Goldstein return ret; 251e593b2bfSAmir Goldstein } 252e593b2bfSAmir Goldstein 253cc259639SAndy Whitcroft /** 254cc259639SAndy Whitcroft * ovl_statfs 255cc259639SAndy Whitcroft * @sb: The overlayfs super block 256cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 257cc259639SAndy Whitcroft * 258cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 2594ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 260cc259639SAndy Whitcroft */ 261cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 262cc259639SAndy Whitcroft { 263cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 264cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 265cc259639SAndy Whitcroft struct path path; 266cc259639SAndy Whitcroft int err; 267cc259639SAndy Whitcroft 2684ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 269cc259639SAndy Whitcroft 270cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 271cc259639SAndy Whitcroft if (!err) { 2726b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 273cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 274cc259639SAndy Whitcroft } 275cc259639SAndy Whitcroft 276cc259639SAndy Whitcroft return err; 277cc259639SAndy Whitcroft } 278cc259639SAndy Whitcroft 27902bcd157SAmir Goldstein /* Will this overlay be forced to mount/remount ro? */ 28002bcd157SAmir Goldstein static bool ovl_force_readonly(struct ovl_fs *ufs) 28102bcd157SAmir Goldstein { 28202bcd157SAmir Goldstein return (!ufs->upper_mnt || !ufs->workdir); 28302bcd157SAmir Goldstein } 28402bcd157SAmir Goldstein 285f45827e8SErez Zadok /** 286f45827e8SErez Zadok * ovl_show_options 287f45827e8SErez Zadok * 288f45827e8SErez Zadok * Prints the mount options for a given superblock. 289f45827e8SErez Zadok * Returns zero; does not fail. 290f45827e8SErez Zadok */ 291f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 292f45827e8SErez Zadok { 293f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 294f45827e8SErez Zadok struct ovl_fs *ufs = sb->s_fs_info; 295f45827e8SErez Zadok 296a068acf2SKees Cook seq_show_option(m, "lowerdir", ufs->config.lowerdir); 29753a08cb9SMiklos Szeredi if (ufs->config.upperdir) { 298a068acf2SKees Cook seq_show_option(m, "upperdir", ufs->config.upperdir); 299a068acf2SKees Cook seq_show_option(m, "workdir", ufs->config.workdir); 30053a08cb9SMiklos Szeredi } 3018d3095f4SMiklos Szeredi if (ufs->config.default_permissions) 3028d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 303c5bef3a7SAmir Goldstein if (ufs->config.redirect_dir != ovl_redirect_dir_def) 304c5bef3a7SAmir Goldstein seq_printf(m, ",redirect_dir=%s", 305c5bef3a7SAmir Goldstein ufs->config.redirect_dir ? "on" : "off"); 30602bcd157SAmir Goldstein if (ufs->config.index != ovl_index_def) 30702bcd157SAmir Goldstein seq_printf(m, ",index=%s", 30802bcd157SAmir Goldstein ufs->config.index ? "on" : "off"); 309f45827e8SErez Zadok return 0; 310f45827e8SErez Zadok } 311f45827e8SErez Zadok 3123cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 3133cdf6fe9SSeunghun Lee { 3143cdf6fe9SSeunghun Lee struct ovl_fs *ufs = sb->s_fs_info; 3153cdf6fe9SSeunghun Lee 31602bcd157SAmir Goldstein if (!(*flags & MS_RDONLY) && ovl_force_readonly(ufs)) 3173cdf6fe9SSeunghun Lee return -EROFS; 3183cdf6fe9SSeunghun Lee 3193cdf6fe9SSeunghun Lee return 0; 3203cdf6fe9SSeunghun Lee } 3213cdf6fe9SSeunghun Lee 322e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 32313cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 32413cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 32513cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 326e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 327e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 328cc259639SAndy Whitcroft .statfs = ovl_statfs, 329f45827e8SErez Zadok .show_options = ovl_show_options, 3303cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 331e9be9d5eSMiklos Szeredi }; 332e9be9d5eSMiklos Szeredi 333e9be9d5eSMiklos Szeredi enum { 334e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 335e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 336e9be9d5eSMiklos Szeredi OPT_WORKDIR, 3378d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 338a6c60655SMiklos Szeredi OPT_REDIRECT_DIR_ON, 339a6c60655SMiklos Szeredi OPT_REDIRECT_DIR_OFF, 34002bcd157SAmir Goldstein OPT_INDEX_ON, 34102bcd157SAmir Goldstein OPT_INDEX_OFF, 342e9be9d5eSMiklos Szeredi OPT_ERR, 343e9be9d5eSMiklos Szeredi }; 344e9be9d5eSMiklos Szeredi 345e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 346e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 347e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 348e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 3498d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 350a6c60655SMiklos Szeredi {OPT_REDIRECT_DIR_ON, "redirect_dir=on"}, 351a6c60655SMiklos Szeredi {OPT_REDIRECT_DIR_OFF, "redirect_dir=off"}, 35202bcd157SAmir Goldstein {OPT_INDEX_ON, "index=on"}, 35302bcd157SAmir Goldstein {OPT_INDEX_OFF, "index=off"}, 354e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 355e9be9d5eSMiklos Szeredi }; 356e9be9d5eSMiklos Szeredi 35791c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 35891c77947SMiklos Szeredi { 35991c77947SMiklos Szeredi char *sbegin = *s; 36091c77947SMiklos Szeredi char *p; 36191c77947SMiklos Szeredi 36291c77947SMiklos Szeredi if (sbegin == NULL) 36391c77947SMiklos Szeredi return NULL; 36491c77947SMiklos Szeredi 36591c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 36691c77947SMiklos Szeredi if (*p == '\\') { 36791c77947SMiklos Szeredi p++; 36891c77947SMiklos Szeredi if (!*p) 36991c77947SMiklos Szeredi break; 37091c77947SMiklos Szeredi } else if (*p == ',') { 37191c77947SMiklos Szeredi *p = '\0'; 37291c77947SMiklos Szeredi *s = p + 1; 37391c77947SMiklos Szeredi return sbegin; 37491c77947SMiklos Szeredi } 37591c77947SMiklos Szeredi } 37691c77947SMiklos Szeredi *s = NULL; 37791c77947SMiklos Szeredi return sbegin; 37891c77947SMiklos Szeredi } 37991c77947SMiklos Szeredi 380e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 381e9be9d5eSMiklos Szeredi { 382e9be9d5eSMiklos Szeredi char *p; 383e9be9d5eSMiklos Szeredi 38491c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 385e9be9d5eSMiklos Szeredi int token; 386e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 387e9be9d5eSMiklos Szeredi 388e9be9d5eSMiklos Szeredi if (!*p) 389e9be9d5eSMiklos Szeredi continue; 390e9be9d5eSMiklos Szeredi 391e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 392e9be9d5eSMiklos Szeredi switch (token) { 393e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 394e9be9d5eSMiklos Szeredi kfree(config->upperdir); 395e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 396e9be9d5eSMiklos Szeredi if (!config->upperdir) 397e9be9d5eSMiklos Szeredi return -ENOMEM; 398e9be9d5eSMiklos Szeredi break; 399e9be9d5eSMiklos Szeredi 400e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 401e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 402e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 403e9be9d5eSMiklos Szeredi if (!config->lowerdir) 404e9be9d5eSMiklos Szeredi return -ENOMEM; 405e9be9d5eSMiklos Szeredi break; 406e9be9d5eSMiklos Szeredi 407e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 408e9be9d5eSMiklos Szeredi kfree(config->workdir); 409e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 410e9be9d5eSMiklos Szeredi if (!config->workdir) 411e9be9d5eSMiklos Szeredi return -ENOMEM; 412e9be9d5eSMiklos Szeredi break; 413e9be9d5eSMiklos Szeredi 4148d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 4158d3095f4SMiklos Szeredi config->default_permissions = true; 4168d3095f4SMiklos Szeredi break; 4178d3095f4SMiklos Szeredi 418a6c60655SMiklos Szeredi case OPT_REDIRECT_DIR_ON: 419a6c60655SMiklos Szeredi config->redirect_dir = true; 420a6c60655SMiklos Szeredi break; 421a6c60655SMiklos Szeredi 422a6c60655SMiklos Szeredi case OPT_REDIRECT_DIR_OFF: 423a6c60655SMiklos Szeredi config->redirect_dir = false; 424a6c60655SMiklos Szeredi break; 425a6c60655SMiklos Szeredi 42602bcd157SAmir Goldstein case OPT_INDEX_ON: 42702bcd157SAmir Goldstein config->index = true; 42802bcd157SAmir Goldstein break; 42902bcd157SAmir Goldstein 43002bcd157SAmir Goldstein case OPT_INDEX_OFF: 43102bcd157SAmir Goldstein config->index = false; 43202bcd157SAmir Goldstein break; 43302bcd157SAmir Goldstein 434e9be9d5eSMiklos Szeredi default: 435bead55efShujianyang pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p); 436e9be9d5eSMiklos Szeredi return -EINVAL; 437e9be9d5eSMiklos Szeredi } 438e9be9d5eSMiklos Szeredi } 43971cbad7eShujianyang 44071cbad7eShujianyang /* Workdir is useless in non-upper mount */ 44171cbad7eShujianyang if (!config->upperdir && config->workdir) { 44271cbad7eShujianyang pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 44371cbad7eShujianyang config->workdir); 44471cbad7eShujianyang kfree(config->workdir); 44571cbad7eShujianyang config->workdir = NULL; 44671cbad7eShujianyang } 44771cbad7eShujianyang 448e9be9d5eSMiklos Szeredi return 0; 449e9be9d5eSMiklos Szeredi } 450e9be9d5eSMiklos Szeredi 451e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 45202bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 453e9be9d5eSMiklos Szeredi 4546b8aa129SAmir Goldstein static struct dentry *ovl_workdir_create(struct super_block *sb, 4556b8aa129SAmir Goldstein struct ovl_fs *ufs, 4566b8aa129SAmir Goldstein struct dentry *dentry, 4576b8aa129SAmir Goldstein const char *name, bool persist) 458e9be9d5eSMiklos Szeredi { 459e9be9d5eSMiklos Szeredi struct inode *dir = dentry->d_inode; 4606b8aa129SAmir Goldstein struct vfsmount *mnt = ufs->upper_mnt; 461e9be9d5eSMiklos Szeredi struct dentry *work; 462e9be9d5eSMiklos Szeredi int err; 463e9be9d5eSMiklos Szeredi bool retried = false; 4646b8aa129SAmir Goldstein bool locked = false; 465e9be9d5eSMiklos Szeredi 466e9be9d5eSMiklos Szeredi err = mnt_want_write(mnt); 467e9be9d5eSMiklos Szeredi if (err) 4686b8aa129SAmir Goldstein goto out_err; 469e9be9d5eSMiklos Szeredi 4705955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 4716b8aa129SAmir Goldstein locked = true; 4726b8aa129SAmir Goldstein 473e9be9d5eSMiklos Szeredi retry: 4746b8aa129SAmir Goldstein work = lookup_one_len(name, dentry, strlen(name)); 475e9be9d5eSMiklos Szeredi 476e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 477c11b9fddSMiklos Szeredi struct iattr attr = { 478c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 47932a3d848SAl Viro .ia_mode = S_IFDIR | 0, 480c11b9fddSMiklos Szeredi }; 481e9be9d5eSMiklos Szeredi 482e9be9d5eSMiklos Szeredi if (work->d_inode) { 483e9be9d5eSMiklos Szeredi err = -EEXIST; 484e9be9d5eSMiklos Szeredi if (retried) 485e9be9d5eSMiklos Szeredi goto out_dput; 486e9be9d5eSMiklos Szeredi 4876b8aa129SAmir Goldstein if (persist) 4886b8aa129SAmir Goldstein goto out_unlock; 4896b8aa129SAmir Goldstein 490e9be9d5eSMiklos Szeredi retried = true; 491eea2fb48SMiklos Szeredi ovl_workdir_cleanup(dir, mnt, work, 0); 492e9be9d5eSMiklos Szeredi dput(work); 493e9be9d5eSMiklos Szeredi goto retry; 494e9be9d5eSMiklos Szeredi } 495e9be9d5eSMiklos Szeredi 49632a3d848SAl Viro err = ovl_create_real(dir, work, 49732a3d848SAl Viro &(struct cattr){.mode = S_IFDIR | 0}, 49832a3d848SAl Viro NULL, true); 499e9be9d5eSMiklos Szeredi if (err) 500e9be9d5eSMiklos Szeredi goto out_dput; 501c11b9fddSMiklos Szeredi 502cb348edbSMiklos Szeredi /* 503cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 504cb348edbSMiklos Szeredi * 505cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 506cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 507cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 508cb348edbSMiklos Szeredi * 509cb348edbSMiklos Szeredi * There are various other error values that could effectively 510cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 511cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 512cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 513cb348edbSMiklos Szeredi * for the above two errors is sufficient. 514cb348edbSMiklos Szeredi */ 515c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 516e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 517c11b9fddSMiklos Szeredi goto out_dput; 518c11b9fddSMiklos Szeredi 519c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 520e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 521c11b9fddSMiklos Szeredi goto out_dput; 522c11b9fddSMiklos Szeredi 523c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 524c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 525c11b9fddSMiklos Szeredi err = notify_change(work, &attr, NULL); 526c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 527c11b9fddSMiklos Szeredi if (err) 528c11b9fddSMiklos Szeredi goto out_dput; 5296b8aa129SAmir Goldstein } else { 5306b8aa129SAmir Goldstein err = PTR_ERR(work); 5316b8aa129SAmir Goldstein goto out_err; 532e9be9d5eSMiklos Szeredi } 533e9be9d5eSMiklos Szeredi out_unlock: 534e9be9d5eSMiklos Szeredi mnt_drop_write(mnt); 5356b8aa129SAmir Goldstein if (locked) 5366b8aa129SAmir Goldstein inode_unlock(dir); 537e9be9d5eSMiklos Szeredi 538e9be9d5eSMiklos Szeredi return work; 539e9be9d5eSMiklos Szeredi 540e9be9d5eSMiklos Szeredi out_dput: 541e9be9d5eSMiklos Szeredi dput(work); 5426b8aa129SAmir Goldstein out_err: 5436b8aa129SAmir Goldstein pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n", 5446b8aa129SAmir Goldstein ufs->config.workdir, name, -err); 5456b8aa129SAmir Goldstein sb->s_flags |= MS_RDONLY; 5466b8aa129SAmir Goldstein work = NULL; 547e9be9d5eSMiklos Szeredi goto out_unlock; 548e9be9d5eSMiklos Szeredi } 549e9be9d5eSMiklos Szeredi 55091c77947SMiklos Szeredi static void ovl_unescape(char *s) 55191c77947SMiklos Szeredi { 55291c77947SMiklos Szeredi char *d = s; 55391c77947SMiklos Szeredi 55491c77947SMiklos Szeredi for (;; s++, d++) { 55591c77947SMiklos Szeredi if (*s == '\\') 55691c77947SMiklos Szeredi s++; 55791c77947SMiklos Szeredi *d = *s; 55891c77947SMiklos Szeredi if (!*s) 55991c77947SMiklos Szeredi break; 56091c77947SMiklos Szeredi } 56191c77947SMiklos Szeredi } 56291c77947SMiklos Szeredi 563ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 564ab508822SMiklos Szeredi { 565a78d9f0dSMiklos Szeredi int err = -EINVAL; 566ab508822SMiklos Szeredi 567a78d9f0dSMiklos Szeredi if (!*name) { 568a78d9f0dSMiklos Szeredi pr_err("overlayfs: empty lowerdir\n"); 569a78d9f0dSMiklos Szeredi goto out; 570a78d9f0dSMiklos Szeredi } 571ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 572ab508822SMiklos Szeredi if (err) { 573ab508822SMiklos Szeredi pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); 574ab508822SMiklos Szeredi goto out; 575ab508822SMiklos Szeredi } 576ab508822SMiklos Szeredi err = -EINVAL; 5777c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 578ab508822SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported\n", name); 579ab508822SMiklos Szeredi goto out_put; 580ab508822SMiklos Szeredi } 5812b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 582ab508822SMiklos Szeredi pr_err("overlayfs: '%s' not a directory\n", name); 583ab508822SMiklos Szeredi goto out_put; 584ab508822SMiklos Szeredi } 585ab508822SMiklos Szeredi return 0; 586ab508822SMiklos Szeredi 587ab508822SMiklos Szeredi out_put: 588ab508822SMiklos Szeredi path_put(path); 589ab508822SMiklos Szeredi out: 590ab508822SMiklos Szeredi return err; 591ab508822SMiklos Szeredi } 592ab508822SMiklos Szeredi 593ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 594ab508822SMiklos Szeredi { 595ab508822SMiklos Szeredi int err = -ENOMEM; 596ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 597ab508822SMiklos Szeredi 598ab508822SMiklos Szeredi if (tmp) { 599ab508822SMiklos Szeredi ovl_unescape(tmp); 600ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 6017c03b5d4SMiklos Szeredi 6027c03b5d4SMiklos Szeredi if (!err) 6037c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) { 6047c03b5d4SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n", 6057c03b5d4SMiklos Szeredi tmp); 6067c03b5d4SMiklos Szeredi path_put(path); 6077c03b5d4SMiklos Szeredi err = -EINVAL; 6087c03b5d4SMiklos Szeredi } 609ab508822SMiklos Szeredi kfree(tmp); 610ab508822SMiklos Szeredi } 611ab508822SMiklos Szeredi return err; 612ab508822SMiklos Szeredi } 613ab508822SMiklos Szeredi 6146b2d5fe4SMiklos Szeredi static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 6156b2d5fe4SMiklos Szeredi const char *name) 6166b2d5fe4SMiklos Szeredi { 6176b2d5fe4SMiklos Szeredi struct kstatfs statfs; 6186b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 6196b2d5fe4SMiklos Szeredi 6206b2d5fe4SMiklos Szeredi if (err) 6216b2d5fe4SMiklos Szeredi pr_err("overlayfs: statfs failed on '%s'\n", name); 6226b2d5fe4SMiklos Szeredi else 6236b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 6246b2d5fe4SMiklos Szeredi 6256b2d5fe4SMiklos Szeredi return err; 6266b2d5fe4SMiklos Szeredi } 6276b2d5fe4SMiklos Szeredi 6286b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 6296b2d5fe4SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth, bool *remote) 630ab508822SMiklos Szeredi { 631ab508822SMiklos Szeredi int err; 632ab508822SMiklos Szeredi 633a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 634ab508822SMiklos Szeredi if (err) 635ab508822SMiklos Szeredi goto out; 636ab508822SMiklos Szeredi 6376b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 6386b2d5fe4SMiklos Szeredi if (err) 639ab508822SMiklos Szeredi goto out_put; 6406b2d5fe4SMiklos Szeredi 641ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 642ab508822SMiklos Szeredi 6437c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) 6447c03b5d4SMiklos Szeredi *remote = true; 6457c03b5d4SMiklos Szeredi 64602bcd157SAmir Goldstein /* 64702bcd157SAmir Goldstein * The inodes index feature needs to encode and decode file 64802bcd157SAmir Goldstein * handles, so it requires that all layers support them. 64902bcd157SAmir Goldstein */ 65002bcd157SAmir Goldstein if (ofs->config.index && !ovl_can_decode_fh(path->dentry->d_sb)) { 65102bcd157SAmir Goldstein ofs->config.index = false; 65202bcd157SAmir Goldstein pr_warn("overlayfs: fs on '%s' does not support file handles, falling back to index=off.\n", name); 65302bcd157SAmir Goldstein } 65402bcd157SAmir Goldstein 655ab508822SMiklos Szeredi return 0; 656ab508822SMiklos Szeredi 657ab508822SMiklos Szeredi out_put: 658ab508822SMiklos Szeredi path_put(path); 659ab508822SMiklos Szeredi out: 660ab508822SMiklos Szeredi return err; 661ab508822SMiklos Szeredi } 662ab508822SMiklos Szeredi 663e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 664e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 665e9be9d5eSMiklos Szeredi { 666e9be9d5eSMiklos Szeredi bool ok = false; 667e9be9d5eSMiklos Szeredi 668e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 669e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 670e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 671e9be9d5eSMiklos Szeredi } 672e9be9d5eSMiklos Szeredi return ok; 673e9be9d5eSMiklos Szeredi } 674e9be9d5eSMiklos Szeredi 675a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 676a78d9f0dSMiklos Szeredi { 677a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 678a78d9f0dSMiklos Szeredi char *s, *d; 679a78d9f0dSMiklos Szeredi 680a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 681a78d9f0dSMiklos Szeredi if (*s == '\\') { 682a78d9f0dSMiklos Szeredi s++; 683a78d9f0dSMiklos Szeredi } else if (*s == ':') { 684a78d9f0dSMiklos Szeredi *d = '\0'; 685a78d9f0dSMiklos Szeredi ctr++; 686a78d9f0dSMiklos Szeredi continue; 687a78d9f0dSMiklos Szeredi } 688a78d9f0dSMiklos Szeredi *d = *s; 689a78d9f0dSMiklos Szeredi if (!*s) 690a78d9f0dSMiklos Szeredi break; 691a78d9f0dSMiklos Szeredi } 692a78d9f0dSMiklos Szeredi return ctr; 693a78d9f0dSMiklos Szeredi } 694a78d9f0dSMiklos Szeredi 6950c97be22SAndreas Gruenbacher static int __maybe_unused 6960eb45fc3SAndreas Gruenbacher ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 6970eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 6980eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 6990eb45fc3SAndreas Gruenbacher { 7001d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 7010eb45fc3SAndreas Gruenbacher } 7020eb45fc3SAndreas Gruenbacher 7030eb45fc3SAndreas Gruenbacher static int __maybe_unused 7040c97be22SAndreas Gruenbacher ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 705d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 706d837a49bSMiklos Szeredi const char *name, const void *value, 707d837a49bSMiklos Szeredi size_t size, int flags) 708d837a49bSMiklos Szeredi { 709d837a49bSMiklos Szeredi struct dentry *workdir = ovl_workdir(dentry); 71009d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 711d837a49bSMiklos Szeredi struct posix_acl *acl = NULL; 712d837a49bSMiklos Szeredi int err; 713d837a49bSMiklos Szeredi 714d837a49bSMiklos Szeredi /* Check that everything is OK before copy-up */ 715d837a49bSMiklos Szeredi if (value) { 716d837a49bSMiklos Szeredi acl = posix_acl_from_xattr(&init_user_ns, value, size); 717d837a49bSMiklos Szeredi if (IS_ERR(acl)) 718d837a49bSMiklos Szeredi return PTR_ERR(acl); 719d837a49bSMiklos Szeredi } 720d837a49bSMiklos Szeredi err = -EOPNOTSUPP; 721d837a49bSMiklos Szeredi if (!IS_POSIXACL(d_inode(workdir))) 722d837a49bSMiklos Szeredi goto out_acl_release; 723d837a49bSMiklos Szeredi if (!realinode->i_op->set_acl) 724d837a49bSMiklos Szeredi goto out_acl_release; 725d837a49bSMiklos Szeredi if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 726d837a49bSMiklos Szeredi err = acl ? -EACCES : 0; 727d837a49bSMiklos Szeredi goto out_acl_release; 728d837a49bSMiklos Szeredi } 729d837a49bSMiklos Szeredi err = -EPERM; 730d837a49bSMiklos Szeredi if (!inode_owner_or_capable(inode)) 731d837a49bSMiklos Szeredi goto out_acl_release; 732d837a49bSMiklos Szeredi 733d837a49bSMiklos Szeredi posix_acl_release(acl); 734d837a49bSMiklos Szeredi 735fd3220d3SMiklos Szeredi /* 736fd3220d3SMiklos Szeredi * Check if sgid bit needs to be cleared (actual setacl operation will 737fd3220d3SMiklos Szeredi * be done with mounter's capabilities and so that won't do it for us). 738fd3220d3SMiklos Szeredi */ 739fd3220d3SMiklos Szeredi if (unlikely(inode->i_mode & S_ISGID) && 740fd3220d3SMiklos Szeredi handler->flags == ACL_TYPE_ACCESS && 741fd3220d3SMiklos Szeredi !in_group_p(inode->i_gid) && 742fd3220d3SMiklos Szeredi !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 743fd3220d3SMiklos Szeredi struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 744fd3220d3SMiklos Szeredi 745fd3220d3SMiklos Szeredi err = ovl_setattr(dentry, &iattr); 746fd3220d3SMiklos Szeredi if (err) 747fd3220d3SMiklos Szeredi return err; 748fd3220d3SMiklos Szeredi } 749fd3220d3SMiklos Szeredi 7501d88f183SMiklos Szeredi err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 751ce31513aSMiklos Szeredi if (!err) 75209d8b586SMiklos Szeredi ovl_copyattr(ovl_inode_real(inode), inode); 753ce31513aSMiklos Szeredi 754ce31513aSMiklos Szeredi return err; 755d837a49bSMiklos Szeredi 756d837a49bSMiklos Szeredi out_acl_release: 757d837a49bSMiklos Szeredi posix_acl_release(acl); 758d837a49bSMiklos Szeredi return err; 759d837a49bSMiklos Szeredi } 760d837a49bSMiklos Szeredi 7610eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 7620eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 7630eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 7640eb45fc3SAndreas Gruenbacher { 76548fab5d7SAmir Goldstein return -EOPNOTSUPP; 7660eb45fc3SAndreas Gruenbacher } 7670eb45fc3SAndreas Gruenbacher 768d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 769d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 770d837a49bSMiklos Szeredi const char *name, const void *value, 771d837a49bSMiklos Szeredi size_t size, int flags) 772d837a49bSMiklos Szeredi { 77348fab5d7SAmir Goldstein return -EOPNOTSUPP; 774d837a49bSMiklos Szeredi } 775d837a49bSMiklos Szeredi 7760eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 7770eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 7780eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 7790eb45fc3SAndreas Gruenbacher { 7801d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 7810eb45fc3SAndreas Gruenbacher } 7820eb45fc3SAndreas Gruenbacher 7830e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 7840e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 7850e585cccSAndreas Gruenbacher const char *name, const void *value, 7860e585cccSAndreas Gruenbacher size_t size, int flags) 7870e585cccSAndreas Gruenbacher { 7881d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 7890e585cccSAndreas Gruenbacher } 7900e585cccSAndreas Gruenbacher 7910c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 7920c97be22SAndreas Gruenbacher ovl_posix_acl_access_xattr_handler = { 793d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_ACCESS, 794d837a49bSMiklos Szeredi .flags = ACL_TYPE_ACCESS, 7950eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 796d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 797d837a49bSMiklos Szeredi }; 798d837a49bSMiklos Szeredi 7990c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 8000c97be22SAndreas Gruenbacher ovl_posix_acl_default_xattr_handler = { 801d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_DEFAULT, 802d837a49bSMiklos Szeredi .flags = ACL_TYPE_DEFAULT, 8030eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 804d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 805d837a49bSMiklos Szeredi }; 806d837a49bSMiklos Szeredi 807d837a49bSMiklos Szeredi static const struct xattr_handler ovl_own_xattr_handler = { 808d837a49bSMiklos Szeredi .prefix = OVL_XATTR_PREFIX, 8090eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 810d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 811d837a49bSMiklos Szeredi }; 812d837a49bSMiklos Szeredi 813d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 814d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 8150eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 816d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 817d837a49bSMiklos Szeredi }; 818d837a49bSMiklos Szeredi 819d837a49bSMiklos Szeredi static const struct xattr_handler *ovl_xattr_handlers[] = { 8200c97be22SAndreas Gruenbacher #ifdef CONFIG_FS_POSIX_ACL 821d837a49bSMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 822d837a49bSMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 8230c97be22SAndreas Gruenbacher #endif 824d837a49bSMiklos Szeredi &ovl_own_xattr_handler, 825d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 826d837a49bSMiklos Szeredi NULL 827d837a49bSMiklos Szeredi }; 828d837a49bSMiklos Szeredi 829e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 830e9be9d5eSMiklos Szeredi { 83133006cdfSKees Cook struct path upperpath = { }; 83233006cdfSKees Cook struct path workpath = { }; 833e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 834e9be9d5eSMiklos Szeredi struct ovl_entry *oe; 835e9be9d5eSMiklos Szeredi struct ovl_fs *ufs; 836a78d9f0dSMiklos Szeredi struct path *stack = NULL; 837a78d9f0dSMiklos Szeredi char *lowertmp; 838a78d9f0dSMiklos Szeredi char *lower; 839a78d9f0dSMiklos Szeredi unsigned int numlower; 840a78d9f0dSMiklos Szeredi unsigned int stacklen = 0; 841dd662667SMiklos Szeredi unsigned int i; 8427c03b5d4SMiklos Szeredi bool remote = false; 84351f8f3c4SKonstantin Khlebnikov struct cred *cred; 844e9be9d5eSMiklos Szeredi int err; 845e9be9d5eSMiklos Szeredi 846f45827e8SErez Zadok err = -ENOMEM; 847f45827e8SErez Zadok ufs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 848f45827e8SErez Zadok if (!ufs) 849e9be9d5eSMiklos Szeredi goto out; 850e9be9d5eSMiklos Szeredi 851688ea0e5SMiklos Szeredi ufs->config.redirect_dir = ovl_redirect_dir_def; 85202bcd157SAmir Goldstein ufs->config.index = ovl_index_def; 853f45827e8SErez Zadok err = ovl_parse_opt((char *) data, &ufs->config); 854f45827e8SErez Zadok if (err) 855f45827e8SErez Zadok goto out_free_config; 856f45827e8SErez Zadok 857e9be9d5eSMiklos Szeredi err = -EINVAL; 85853a08cb9SMiklos Szeredi if (!ufs->config.lowerdir) { 85907f2af7bSKonstantin Khlebnikov if (!silent) 86053a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'lowerdir'\n"); 86153a08cb9SMiklos Szeredi goto out_free_config; 86253a08cb9SMiklos Szeredi } 86353a08cb9SMiklos Szeredi 86453a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 865cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 86653a08cb9SMiklos Szeredi if (ufs->config.upperdir) { 86753a08cb9SMiklos Szeredi if (!ufs->config.workdir) { 86853a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'workdir'\n"); 869e9be9d5eSMiklos Szeredi goto out_free_config; 870e9be9d5eSMiklos Szeredi } 871e9be9d5eSMiklos Szeredi 872f45827e8SErez Zadok err = ovl_mount_dir(ufs->config.upperdir, &upperpath); 873e9be9d5eSMiklos Szeredi if (err) 8743b7a9a24SMiklos Szeredi goto out_free_config; 875e9be9d5eSMiklos Szeredi 87671cbad7eShujianyang /* Upper fs should not be r/o */ 877bc98a42cSDavid Howells if (sb_rdonly(upperpath.mnt->mnt_sb)) { 87871cbad7eShujianyang pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n"); 87971cbad7eShujianyang err = -EINVAL; 88071cbad7eShujianyang goto out_put_upperpath; 88171cbad7eShujianyang } 88271cbad7eShujianyang 8836b2d5fe4SMiklos Szeredi err = ovl_check_namelen(&upperpath, ufs, ufs->config.upperdir); 8846b2d5fe4SMiklos Szeredi if (err) 8856b2d5fe4SMiklos Szeredi goto out_put_upperpath; 8866b2d5fe4SMiklos Szeredi 8872cac0c00SAmir Goldstein err = -EBUSY; 88885fdee1eSAmir Goldstein if (ovl_inuse_trylock(upperpath.dentry)) { 88985fdee1eSAmir Goldstein ufs->upperdir_locked = true; 89085fdee1eSAmir Goldstein } else if (ufs->config.index) { 89185fdee1eSAmir Goldstein pr_err("overlayfs: upperdir is in-use by another mount, mount with '-o index=off' to override exclusive upperdir protection.\n"); 8922cac0c00SAmir Goldstein goto out_put_upperpath; 89385fdee1eSAmir Goldstein } else { 89485fdee1eSAmir Goldstein pr_warn("overlayfs: upperdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 8952cac0c00SAmir Goldstein } 8962cac0c00SAmir Goldstein 897f45827e8SErez Zadok err = ovl_mount_dir(ufs->config.workdir, &workpath); 898e9be9d5eSMiklos Szeredi if (err) 8992cac0c00SAmir Goldstein goto out_unlock_upperdentry; 9003b7a9a24SMiklos Szeredi 9012f83fd8cShujianyang err = -EINVAL; 902ab508822SMiklos Szeredi if (upperpath.mnt != workpath.mnt) { 903ab508822SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 904ab508822SMiklos Szeredi goto out_put_workpath; 905ab508822SMiklos Szeredi } 906ab508822SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath.dentry)) { 907ab508822SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 908ab508822SMiklos Szeredi goto out_put_workpath; 909ab508822SMiklos Szeredi } 9102cac0c00SAmir Goldstein 9112cac0c00SAmir Goldstein err = -EBUSY; 91285fdee1eSAmir Goldstein if (ovl_inuse_trylock(workpath.dentry)) { 91385fdee1eSAmir Goldstein ufs->workdir_locked = true; 91485fdee1eSAmir Goldstein } else if (ufs->config.index) { 91585fdee1eSAmir Goldstein pr_err("overlayfs: workdir is in-use by another mount, mount with '-o index=off' to override exclusive workdir protection.\n"); 9162cac0c00SAmir Goldstein goto out_put_workpath; 91785fdee1eSAmir Goldstein } else { 91885fdee1eSAmir Goldstein pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 9192cac0c00SAmir Goldstein } 9202cac0c00SAmir Goldstein 9212cac0c00SAmir Goldstein ufs->workbasedir = workpath.dentry; 922ab508822SMiklos Szeredi sb->s_stack_depth = upperpath.mnt->mnt_sb->s_stack_depth; 92353a08cb9SMiklos Szeredi } 924a78d9f0dSMiklos Szeredi err = -ENOMEM; 925a78d9f0dSMiklos Szeredi lowertmp = kstrdup(ufs->config.lowerdir, GFP_KERNEL); 926a78d9f0dSMiklos Szeredi if (!lowertmp) 9272cac0c00SAmir Goldstein goto out_unlock_workdentry; 928ab508822SMiklos Szeredi 929a78d9f0dSMiklos Szeredi err = -EINVAL; 930a78d9f0dSMiklos Szeredi stacklen = ovl_split_lowerdirs(lowertmp); 9316be4506eShujianyang if (stacklen > OVL_MAX_STACK) { 932fd36570aSColin Ian King pr_err("overlayfs: too many lower directories, limit is %d\n", 9336be4506eShujianyang OVL_MAX_STACK); 934a78d9f0dSMiklos Szeredi goto out_free_lowertmp; 9356be4506eShujianyang } else if (!ufs->config.upperdir && stacklen == 1) { 9366be4506eShujianyang pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n"); 9376be4506eShujianyang goto out_free_lowertmp; 9386be4506eShujianyang } 939a78d9f0dSMiklos Szeredi 940313684c4SGeliang Tang err = -ENOMEM; 941a78d9f0dSMiklos Szeredi stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL); 942a78d9f0dSMiklos Szeredi if (!stack) 943a78d9f0dSMiklos Szeredi goto out_free_lowertmp; 944a78d9f0dSMiklos Szeredi 945313684c4SGeliang Tang err = -EINVAL; 946a78d9f0dSMiklos Szeredi lower = lowertmp; 947a78d9f0dSMiklos Szeredi for (numlower = 0; numlower < stacklen; numlower++) { 9486b2d5fe4SMiklos Szeredi err = ovl_lower_dir(lower, &stack[numlower], ufs, 9496b2d5fe4SMiklos Szeredi &sb->s_stack_depth, &remote); 9503b7a9a24SMiklos Szeredi if (err) 951a78d9f0dSMiklos Szeredi goto out_put_lowerpath; 952a78d9f0dSMiklos Szeredi 953a78d9f0dSMiklos Szeredi lower = strchr(lower, '\0') + 1; 954a78d9f0dSMiklos Szeredi } 955e9be9d5eSMiklos Szeredi 956e9be9d5eSMiklos Szeredi err = -EINVAL; 957ab508822SMiklos Szeredi sb->s_stack_depth++; 95869c433edSMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 95969c433edSMiklos Szeredi pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 9603b7a9a24SMiklos Szeredi goto out_put_lowerpath; 96169c433edSMiklos Szeredi } 96269c433edSMiklos Szeredi 96353a08cb9SMiklos Szeredi if (ufs->config.upperdir) { 964e9be9d5eSMiklos Szeredi ufs->upper_mnt = clone_private_mount(&upperpath); 965e9be9d5eSMiklos Szeredi err = PTR_ERR(ufs->upper_mnt); 966e9be9d5eSMiklos Szeredi if (IS_ERR(ufs->upper_mnt)) { 967e9be9d5eSMiklos Szeredi pr_err("overlayfs: failed to clone upperpath\n"); 9683b7a9a24SMiklos Szeredi goto out_put_lowerpath; 9693b7a9a24SMiklos Szeredi } 9702cac0c00SAmir Goldstein 971d719e8f2SMiklos Szeredi /* Don't inherit atime flags */ 972d719e8f2SMiklos Szeredi ufs->upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 973d719e8f2SMiklos Szeredi 974d719e8f2SMiklos Szeredi sb->s_time_gran = ufs->upper_mnt->mnt_sb->s_time_gran; 9753b7a9a24SMiklos Szeredi 9766b8aa129SAmir Goldstein ufs->workdir = ovl_workdir_create(sb, ufs, workpath.dentry, 9776b8aa129SAmir Goldstein OVL_WORKDIR_NAME, false); 97845aebeafSVivek Goyal /* 97945aebeafSVivek Goyal * Upper should support d_type, else whiteouts are visible. 98045aebeafSVivek Goyal * Given workdir and upper are on same fs, we can do 98121765194SVivek Goyal * iterate_dir() on workdir. This check requires successful 98221765194SVivek Goyal * creation of workdir in previous step. 98345aebeafSVivek Goyal */ 98421765194SVivek Goyal if (ufs->workdir) { 985e7f52429SAmir Goldstein struct dentry *temp; 986e7f52429SAmir Goldstein 98745aebeafSVivek Goyal err = ovl_check_d_type_supported(&workpath); 98845aebeafSVivek Goyal if (err < 0) 98945aebeafSVivek Goyal goto out_put_workdir; 99045aebeafSVivek Goyal 991e7c0b599SVivek Goyal /* 992e7c0b599SVivek Goyal * We allowed this configuration and don't want to 993e7c0b599SVivek Goyal * break users over kernel upgrade. So warn instead 994e7c0b599SVivek Goyal * of erroring out. 995e7c0b599SVivek Goyal */ 996e7c0b599SVivek Goyal if (!err) 997e7c0b599SVivek Goyal pr_warn("overlayfs: upper fs needs to support d_type.\n"); 998e7f52429SAmir Goldstein 999e7f52429SAmir Goldstein /* Check if upper/work fs supports O_TMPFILE */ 1000e7f52429SAmir Goldstein temp = ovl_do_tmpfile(ufs->workdir, S_IFREG | 0); 1001e7f52429SAmir Goldstein ufs->tmpfile = !IS_ERR(temp); 1002e7f52429SAmir Goldstein if (ufs->tmpfile) 1003e7f52429SAmir Goldstein dput(temp); 1004e7f52429SAmir Goldstein else 1005e7f52429SAmir Goldstein pr_warn("overlayfs: upper fs does not support tmpfile.\n"); 100682b749b2SAmir Goldstein 100782b749b2SAmir Goldstein /* 100882b749b2SAmir Goldstein * Check if upper/work fs supports trusted.overlay.* 100982b749b2SAmir Goldstein * xattr 101082b749b2SAmir Goldstein */ 101182b749b2SAmir Goldstein err = ovl_do_setxattr(ufs->workdir, OVL_XATTR_OPAQUE, 101282b749b2SAmir Goldstein "0", 1, 0); 101382b749b2SAmir Goldstein if (err) { 101482b749b2SAmir Goldstein ufs->noxattr = true; 101582b749b2SAmir Goldstein pr_warn("overlayfs: upper fs does not support xattr.\n"); 101682b749b2SAmir Goldstein } else { 101782b749b2SAmir Goldstein vfs_removexattr(ufs->workdir, OVL_XATTR_OPAQUE); 101882b749b2SAmir Goldstein } 101902bcd157SAmir Goldstein 102002bcd157SAmir Goldstein /* Check if upper/work fs supports file handles */ 102102bcd157SAmir Goldstein if (ufs->config.index && 102202bcd157SAmir Goldstein !ovl_can_decode_fh(ufs->workdir->d_sb)) { 102302bcd157SAmir Goldstein ufs->config.index = false; 102402bcd157SAmir Goldstein pr_warn("overlayfs: upper fs does not support file handles, falling back to index=off.\n"); 102502bcd157SAmir Goldstein } 102653a08cb9SMiklos Szeredi } 102721765194SVivek Goyal } 1028e9be9d5eSMiklos Szeredi 10292f83fd8cShujianyang err = -ENOMEM; 1030a78d9f0dSMiklos Szeredi ufs->lower_mnt = kcalloc(numlower, sizeof(struct vfsmount *), GFP_KERNEL); 1031dd662667SMiklos Szeredi if (ufs->lower_mnt == NULL) 10323b7a9a24SMiklos Szeredi goto out_put_workdir; 1033a78d9f0dSMiklos Szeredi for (i = 0; i < numlower; i++) { 1034a78d9f0dSMiklos Szeredi struct vfsmount *mnt = clone_private_mount(&stack[i]); 1035dd662667SMiklos Szeredi 10362f83fd8cShujianyang err = PTR_ERR(mnt); 1037dd662667SMiklos Szeredi if (IS_ERR(mnt)) { 1038dd662667SMiklos Szeredi pr_err("overlayfs: failed to clone lowerpath\n"); 1039dd662667SMiklos Szeredi goto out_put_lower_mnt; 1040e9be9d5eSMiklos Szeredi } 1041dd662667SMiklos Szeredi /* 1042dd662667SMiklos Szeredi * Make lower_mnt R/O. That way fchmod/fchown on lower file 1043dd662667SMiklos Szeredi * will fail instead of modifying lower fs. 1044dd662667SMiklos Szeredi */ 1045d719e8f2SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1046dd662667SMiklos Szeredi 1047a78d9f0dSMiklos Szeredi ufs->lower_mnt[ufs->numlower] = mnt; 1048a78d9f0dSMiklos Szeredi ufs->numlower++; 10497bcd74b9SAmir Goldstein 10507bcd74b9SAmir Goldstein /* Check if all lower layers are on same sb */ 10517bcd74b9SAmir Goldstein if (i == 0) 10527bcd74b9SAmir Goldstein ufs->same_sb = mnt->mnt_sb; 10537bcd74b9SAmir Goldstein else if (ufs->same_sb != mnt->mnt_sb) 10547bcd74b9SAmir Goldstein ufs->same_sb = NULL; 1055a78d9f0dSMiklos Szeredi } 1056e9be9d5eSMiklos Szeredi 105771cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 105871cbad7eShujianyang if (!ufs->upper_mnt) 1059e9be9d5eSMiklos Szeredi sb->s_flags |= MS_RDONLY; 10607bcd74b9SAmir Goldstein else if (ufs->upper_mnt->mnt_sb != ufs->same_sb) 10617bcd74b9SAmir Goldstein ufs->same_sb = NULL; 1062e9be9d5eSMiklos Szeredi 106302bcd157SAmir Goldstein if (!(ovl_force_readonly(ufs)) && ufs->config.index) { 10648b88a2e6SAmir Goldstein /* Verify lower root is upper root origin */ 10658b88a2e6SAmir Goldstein err = ovl_verify_origin(upperpath.dentry, ufs->lower_mnt[0], 106654fb347eSAmir Goldstein stack[0].dentry, false, true); 10678b88a2e6SAmir Goldstein if (err) { 10688b88a2e6SAmir Goldstein pr_err("overlayfs: failed to verify upper root origin\n"); 10698b88a2e6SAmir Goldstein goto out_put_lower_mnt; 10708b88a2e6SAmir Goldstein } 10718b88a2e6SAmir Goldstein 107202bcd157SAmir Goldstein ufs->indexdir = ovl_workdir_create(sb, ufs, workpath.dentry, 107302bcd157SAmir Goldstein OVL_INDEXDIR_NAME, true); 107454fb347eSAmir Goldstein if (ufs->indexdir) { 107554fb347eSAmir Goldstein /* Verify upper root is index dir origin */ 107654fb347eSAmir Goldstein err = ovl_verify_origin(ufs->indexdir, ufs->upper_mnt, 107754fb347eSAmir Goldstein upperpath.dentry, true, true); 107854fb347eSAmir Goldstein if (err) 107954fb347eSAmir Goldstein pr_err("overlayfs: failed to verify index dir origin\n"); 1080415543d5SAmir Goldstein 1081caf70cb2SAmir Goldstein /* Cleanup bad/stale/orphan index entries */ 1082415543d5SAmir Goldstein if (!err) 1083415543d5SAmir Goldstein err = ovl_indexdir_cleanup(ufs->indexdir, 1084415543d5SAmir Goldstein ufs->upper_mnt, 1085415543d5SAmir Goldstein stack, numlower); 108654fb347eSAmir Goldstein } 108754fb347eSAmir Goldstein if (err || !ufs->indexdir) 108802bcd157SAmir Goldstein pr_warn("overlayfs: try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 108954fb347eSAmir Goldstein if (err) 109054fb347eSAmir Goldstein goto out_put_indexdir; 109102bcd157SAmir Goldstein } 109202bcd157SAmir Goldstein 109302bcd157SAmir Goldstein /* Show index=off/on in /proc/mounts for any of the reasons above */ 109402bcd157SAmir Goldstein if (!ufs->indexdir) 109502bcd157SAmir Goldstein ufs->config.index = false; 109602bcd157SAmir Goldstein 10977c03b5d4SMiklos Szeredi if (remote) 10987c03b5d4SMiklos Szeredi sb->s_d_op = &ovl_reval_dentry_operations; 10997c03b5d4SMiklos Szeredi else 1100e9be9d5eSMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 1101e9be9d5eSMiklos Szeredi 11028fc646b4SAmir Goldstein err = -ENOMEM; 110351f8f3c4SKonstantin Khlebnikov ufs->creator_cred = cred = prepare_creds(); 110451f8f3c4SKonstantin Khlebnikov if (!cred) 110502bcd157SAmir Goldstein goto out_put_indexdir; 11063fe6e52fSAntonio Murdaca 110751f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 110851f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 110951f8f3c4SKonstantin Khlebnikov 1110e9be9d5eSMiklos Szeredi err = -ENOMEM; 1111a78d9f0dSMiklos Szeredi oe = ovl_alloc_entry(numlower); 11123b7a9a24SMiklos Szeredi if (!oe) 11133fe6e52fSAntonio Murdaca goto out_put_cred; 1114e9be9d5eSMiklos Szeredi 1115655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1116655042ccSVivek Goyal sb->s_op = &ovl_super_operations; 1117655042ccSVivek Goyal sb->s_xattr = ovl_xattr_handlers; 1118655042ccSVivek Goyal sb->s_fs_info = ufs; 1119655042ccSVivek Goyal sb->s_flags |= MS_POSIXACL | MS_NOREMOTELOCK; 1120655042ccSVivek Goyal 1121ca4c8a3aSMiklos Szeredi root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 1122e9be9d5eSMiklos Szeredi if (!root_dentry) 11233b7a9a24SMiklos Szeredi goto out_free_oe; 1124e9be9d5eSMiklos Szeredi 1125e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 1126a78d9f0dSMiklos Szeredi for (i = 0; i < numlower; i++) 1127a78d9f0dSMiklos Szeredi mntput(stack[i].mnt); 11282cac0c00SAmir Goldstein mntput(workpath.mnt); 1129a78d9f0dSMiklos Szeredi kfree(lowertmp); 1130e9be9d5eSMiklos Szeredi 1131f3a15685SAmir Goldstein if (upperpath.dentry) { 113255acc661SMiklos Szeredi oe->has_upper = true; 113313c72075SMiklos Szeredi if (ovl_is_impuredir(upperpath.dentry)) 113413c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, d_inode(root_dentry)); 1135f3a15685SAmir Goldstein } 1136a78d9f0dSMiklos Szeredi for (i = 0; i < numlower; i++) { 1137a78d9f0dSMiklos Szeredi oe->lowerstack[i].dentry = stack[i].dentry; 1138a78d9f0dSMiklos Szeredi oe->lowerstack[i].mnt = ufs->lower_mnt[i]; 1139a78d9f0dSMiklos Szeredi } 11400f95502aSKonstantin Khlebnikov kfree(stack); 1141e9be9d5eSMiklos Szeredi 1142e9be9d5eSMiklos Szeredi root_dentry->d_fsdata = oe; 1143e9be9d5eSMiklos Szeredi 114409d8b586SMiklos Szeredi ovl_inode_init(d_inode(root_dentry), upperpath.dentry, 114509d8b586SMiklos Szeredi ovl_dentry_lower(root_dentry)); 1146ed06e069SMiklos Szeredi 1147e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1148e9be9d5eSMiklos Szeredi 1149e9be9d5eSMiklos Szeredi return 0; 1150e9be9d5eSMiklos Szeredi 11513b7a9a24SMiklos Szeredi out_free_oe: 11523b7a9a24SMiklos Szeredi kfree(oe); 11533fe6e52fSAntonio Murdaca out_put_cred: 11543fe6e52fSAntonio Murdaca put_cred(ufs->creator_cred); 115502bcd157SAmir Goldstein out_put_indexdir: 115602bcd157SAmir Goldstein dput(ufs->indexdir); 1157e9be9d5eSMiklos Szeredi out_put_lower_mnt: 1158dd662667SMiklos Szeredi for (i = 0; i < ufs->numlower; i++) 1159dd662667SMiklos Szeredi mntput(ufs->lower_mnt[i]); 1160dd662667SMiklos Szeredi kfree(ufs->lower_mnt); 11613b7a9a24SMiklos Szeredi out_put_workdir: 11623b7a9a24SMiklos Szeredi dput(ufs->workdir); 1163e9be9d5eSMiklos Szeredi mntput(ufs->upper_mnt); 1164e9be9d5eSMiklos Szeredi out_put_lowerpath: 1165a78d9f0dSMiklos Szeredi for (i = 0; i < numlower; i++) 1166a78d9f0dSMiklos Szeredi path_put(&stack[i]); 1167a78d9f0dSMiklos Szeredi kfree(stack); 1168a78d9f0dSMiklos Szeredi out_free_lowertmp: 1169a78d9f0dSMiklos Szeredi kfree(lowertmp); 11702cac0c00SAmir Goldstein out_unlock_workdentry: 117185fdee1eSAmir Goldstein if (ufs->workdir_locked) 11722cac0c00SAmir Goldstein ovl_inuse_unlock(workpath.dentry); 11733b7a9a24SMiklos Szeredi out_put_workpath: 11743b7a9a24SMiklos Szeredi path_put(&workpath); 11752cac0c00SAmir Goldstein out_unlock_upperdentry: 117685fdee1eSAmir Goldstein if (ufs->upperdir_locked) 11772cac0c00SAmir Goldstein ovl_inuse_unlock(upperpath.dentry); 1178e9be9d5eSMiklos Szeredi out_put_upperpath: 1179e9be9d5eSMiklos Szeredi path_put(&upperpath); 1180e9be9d5eSMiklos Szeredi out_free_config: 1181f45827e8SErez Zadok kfree(ufs->config.lowerdir); 1182f45827e8SErez Zadok kfree(ufs->config.upperdir); 1183f45827e8SErez Zadok kfree(ufs->config.workdir); 1184f45827e8SErez Zadok kfree(ufs); 1185e9be9d5eSMiklos Szeredi out: 1186e9be9d5eSMiklos Szeredi return err; 1187e9be9d5eSMiklos Szeredi } 1188e9be9d5eSMiklos Szeredi 1189e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 1190e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 1191e9be9d5eSMiklos Szeredi { 1192e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 1193e9be9d5eSMiklos Szeredi } 1194e9be9d5eSMiklos Szeredi 1195e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 1196e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1197ef94b186SMiklos Szeredi .name = "overlay", 1198e9be9d5eSMiklos Szeredi .mount = ovl_mount, 1199e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 1200e9be9d5eSMiklos Szeredi }; 1201ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 1202e9be9d5eSMiklos Szeredi 120313cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 120413cf199dSAmir Goldstein { 120513cf199dSAmir Goldstein struct ovl_inode *oi = foo; 120613cf199dSAmir Goldstein 120713cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 120813cf199dSAmir Goldstein } 120913cf199dSAmir Goldstein 1210e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 1211e9be9d5eSMiklos Szeredi { 121213cf199dSAmir Goldstein int err; 121313cf199dSAmir Goldstein 121413cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 121513cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 121613cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 121713cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 121813cf199dSAmir Goldstein ovl_inode_init_once); 121913cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 122013cf199dSAmir Goldstein return -ENOMEM; 122113cf199dSAmir Goldstein 122213cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 122313cf199dSAmir Goldstein if (err) 122413cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 122513cf199dSAmir Goldstein 122613cf199dSAmir Goldstein return err; 1227e9be9d5eSMiklos Szeredi } 1228e9be9d5eSMiklos Szeredi 1229e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1230e9be9d5eSMiklos Szeredi { 1231e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 123213cf199dSAmir Goldstein 123313cf199dSAmir Goldstein /* 123413cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 123513cf199dSAmir Goldstein * destroy cache. 123613cf199dSAmir Goldstein */ 123713cf199dSAmir Goldstein rcu_barrier(); 123813cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 123913cf199dSAmir Goldstein 1240e9be9d5eSMiklos Szeredi } 1241e9be9d5eSMiklos Szeredi 1242e9be9d5eSMiklos Szeredi module_init(ovl_init); 1243e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1244