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" 21e9be9d5eSMiklos Szeredi 22e9be9d5eSMiklos Szeredi MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 23e9be9d5eSMiklos Szeredi MODULE_DESCRIPTION("Overlay filesystem"); 24e9be9d5eSMiklos Szeredi MODULE_LICENSE("GPL"); 25e9be9d5eSMiklos Szeredi 26e9be9d5eSMiklos Szeredi 27e9be9d5eSMiklos Szeredi struct ovl_dir_cache; 28e9be9d5eSMiklos Szeredi 29a78d9f0dSMiklos Szeredi #define OVL_MAX_STACK 500 30a78d9f0dSMiklos Szeredi 31688ea0e5SMiklos Szeredi static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR); 32688ea0e5SMiklos Szeredi module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644); 33688ea0e5SMiklos Szeredi MODULE_PARM_DESC(ovl_redirect_dir_def, 34688ea0e5SMiklos Szeredi "Default to on or off for the redirect_dir feature"); 35e9be9d5eSMiklos Szeredi 3602bcd157SAmir Goldstein static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX); 3702bcd157SAmir Goldstein module_param_named(index, ovl_index_def, bool, 0644); 3802bcd157SAmir Goldstein MODULE_PARM_DESC(ovl_index_def, 3902bcd157SAmir Goldstein "Default to on or off for the inodes index feature"); 4002bcd157SAmir Goldstein 414155c10aSMiklos Szeredi static void ovl_entry_stack_free(struct ovl_entry *oe) 424155c10aSMiklos Szeredi { 434155c10aSMiklos Szeredi unsigned int i; 444155c10aSMiklos Szeredi 454155c10aSMiklos Szeredi for (i = 0; i < oe->numlower; i++) 464155c10aSMiklos Szeredi dput(oe->lowerstack[i].dentry); 474155c10aSMiklos Szeredi } 484155c10aSMiklos Szeredi 49e9be9d5eSMiklos Szeredi static void ovl_dentry_release(struct dentry *dentry) 50e9be9d5eSMiklos Szeredi { 51e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 52e9be9d5eSMiklos Szeredi 53e9be9d5eSMiklos Szeredi if (oe) { 544155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 55e9be9d5eSMiklos Szeredi kfree_rcu(oe, rcu); 56e9be9d5eSMiklos Szeredi } 57e9be9d5eSMiklos Szeredi } 58e9be9d5eSMiklos Szeredi 59b0990fbbSAmir Goldstein static int ovl_check_append_only(struct inode *inode, int flag) 60b0990fbbSAmir Goldstein { 61b0990fbbSAmir Goldstein /* 62b0990fbbSAmir Goldstein * This test was moot in vfs may_open() because overlay inode does 63b0990fbbSAmir Goldstein * not have the S_APPEND flag, so re-check on real upper inode 64b0990fbbSAmir Goldstein */ 65b0990fbbSAmir Goldstein if (IS_APPEND(inode)) { 66b0990fbbSAmir Goldstein if ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND)) 67b0990fbbSAmir Goldstein return -EPERM; 68b0990fbbSAmir Goldstein if (flag & O_TRUNC) 69b0990fbbSAmir Goldstein return -EPERM; 70b0990fbbSAmir Goldstein } 71b0990fbbSAmir Goldstein 72b0990fbbSAmir Goldstein return 0; 73b0990fbbSAmir Goldstein } 74b0990fbbSAmir Goldstein 752d902671SMiklos Szeredi static struct dentry *ovl_d_real(struct dentry *dentry, 762d902671SMiklos Szeredi const struct inode *inode, 77495e6429SMiklos Szeredi unsigned int open_flags, unsigned int flags) 78d101a125SMiklos Szeredi { 79d101a125SMiklos Szeredi struct dentry *real; 80b0990fbbSAmir Goldstein int err; 81d101a125SMiklos Szeredi 82cd91304eSMiklos Szeredi if (flags & D_REAL_UPPER) 83cd91304eSMiklos Szeredi return ovl_dentry_upper(dentry); 84cd91304eSMiklos Szeredi 85ca4c8a3aSMiklos Szeredi if (!d_is_reg(dentry)) { 86d101a125SMiklos Szeredi if (!inode || inode == d_inode(dentry)) 87d101a125SMiklos Szeredi return dentry; 88d101a125SMiklos Szeredi goto bug; 89d101a125SMiklos Szeredi } 90d101a125SMiklos Szeredi 912d902671SMiklos Szeredi if (open_flags) { 92b0990fbbSAmir Goldstein err = ovl_open_maybe_copy_up(dentry, open_flags); 932d902671SMiklos Szeredi if (err) 942d902671SMiklos Szeredi return ERR_PTR(err); 952d902671SMiklos Szeredi } 962d902671SMiklos Szeredi 97d101a125SMiklos Szeredi real = ovl_dentry_upper(dentry); 98b0990fbbSAmir Goldstein if (real && (!inode || inode == d_inode(real))) { 99b0990fbbSAmir Goldstein if (!inode) { 100b0990fbbSAmir Goldstein err = ovl_check_append_only(d_inode(real), open_flags); 101b0990fbbSAmir Goldstein if (err) 102b0990fbbSAmir Goldstein return ERR_PTR(err); 103b0990fbbSAmir Goldstein } 104d101a125SMiklos Szeredi return real; 105b0990fbbSAmir Goldstein } 106d101a125SMiklos Szeredi 107d101a125SMiklos Szeredi real = ovl_dentry_lower(dentry); 108d101a125SMiklos Szeredi if (!real) 109d101a125SMiklos Szeredi goto bug; 110d101a125SMiklos Szeredi 111c4fcfc16SMiklos Szeredi /* Handle recursion */ 112495e6429SMiklos Szeredi real = d_real(real, inode, open_flags, 0); 113c4fcfc16SMiklos Szeredi 114d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 115d101a125SMiklos Szeredi return real; 116d101a125SMiklos Szeredi bug: 117656189d2SMiklos Szeredi WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry, 118d101a125SMiklos Szeredi inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0); 119d101a125SMiklos Szeredi return dentry; 120d101a125SMiklos Szeredi } 121d101a125SMiklos Szeredi 1227c03b5d4SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 1237c03b5d4SMiklos Szeredi { 1247c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1257c03b5d4SMiklos Szeredi unsigned int i; 1267c03b5d4SMiklos Szeredi int ret = 1; 1277c03b5d4SMiklos Szeredi 1287c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1297c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1307c03b5d4SMiklos Szeredi 1317c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_REVALIDATE) { 1327c03b5d4SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1337c03b5d4SMiklos Szeredi if (ret < 0) 1347c03b5d4SMiklos Szeredi return ret; 1357c03b5d4SMiklos Szeredi if (!ret) { 1367c03b5d4SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1377c03b5d4SMiklos Szeredi d_invalidate(d); 1387c03b5d4SMiklos Szeredi return -ESTALE; 1397c03b5d4SMiklos Szeredi } 1407c03b5d4SMiklos Szeredi } 1417c03b5d4SMiklos Szeredi } 1427c03b5d4SMiklos Szeredi return 1; 1437c03b5d4SMiklos Szeredi } 1447c03b5d4SMiklos Szeredi 1457c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 1467c03b5d4SMiklos Szeredi { 1477c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1487c03b5d4SMiklos Szeredi unsigned int i; 1497c03b5d4SMiklos Szeredi int ret = 1; 1507c03b5d4SMiklos Szeredi 1517c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1527c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1537c03b5d4SMiklos Szeredi 1547c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) { 1557c03b5d4SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1567c03b5d4SMiklos Szeredi if (ret <= 0) 1577c03b5d4SMiklos Szeredi break; 1587c03b5d4SMiklos Szeredi } 1597c03b5d4SMiklos Szeredi } 1607c03b5d4SMiklos Szeredi return ret; 1617c03b5d4SMiklos Szeredi } 1627c03b5d4SMiklos Szeredi 163e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 164e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 165d101a125SMiklos Szeredi .d_real = ovl_d_real, 166e9be9d5eSMiklos Szeredi }; 167e9be9d5eSMiklos Szeredi 1687c03b5d4SMiklos Szeredi static const struct dentry_operations ovl_reval_dentry_operations = { 1697c03b5d4SMiklos Szeredi .d_release = ovl_dentry_release, 170d101a125SMiklos Szeredi .d_real = ovl_d_real, 1717c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1727c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1737c03b5d4SMiklos Szeredi }; 1747c03b5d4SMiklos Szeredi 17513cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 17613cf199dSAmir Goldstein 17713cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 17813cf199dSAmir Goldstein { 17913cf199dSAmir Goldstein struct ovl_inode *oi = kmem_cache_alloc(ovl_inode_cachep, GFP_KERNEL); 18013cf199dSAmir Goldstein 181b3885bd6SHirofumi Nakagawa if (!oi) 182b3885bd6SHirofumi Nakagawa return NULL; 183b3885bd6SHirofumi Nakagawa 18404a01ac7SMiklos Szeredi oi->cache = NULL; 185cf31c463SMiklos Szeredi oi->redirect = NULL; 18604a01ac7SMiklos Szeredi oi->version = 0; 18713c72075SMiklos Szeredi oi->flags = 0; 18809d8b586SMiklos Szeredi oi->__upperdentry = NULL; 18925b7713aSMiklos Szeredi oi->lower = NULL; 190a015dafcSAmir Goldstein mutex_init(&oi->lock); 19125b7713aSMiklos Szeredi 19213cf199dSAmir Goldstein return &oi->vfs_inode; 19313cf199dSAmir Goldstein } 19413cf199dSAmir Goldstein 19513cf199dSAmir Goldstein static void ovl_i_callback(struct rcu_head *head) 19613cf199dSAmir Goldstein { 19713cf199dSAmir Goldstein struct inode *inode = container_of(head, struct inode, i_rcu); 19813cf199dSAmir Goldstein 19913cf199dSAmir Goldstein kmem_cache_free(ovl_inode_cachep, OVL_I(inode)); 20013cf199dSAmir Goldstein } 20113cf199dSAmir Goldstein 20213cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 20313cf199dSAmir Goldstein { 20409d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 20509d8b586SMiklos Szeredi 20609d8b586SMiklos Szeredi dput(oi->__upperdentry); 207cf31c463SMiklos Szeredi kfree(oi->redirect); 2084edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 209a015dafcSAmir Goldstein mutex_destroy(&oi->lock); 21009d8b586SMiklos Szeredi 21113cf199dSAmir Goldstein call_rcu(&inode->i_rcu, ovl_i_callback); 21213cf199dSAmir Goldstein } 21313cf199dSAmir Goldstein 214ad204488SMiklos Szeredi static void ovl_free_fs(struct ovl_fs *ofs) 215e9be9d5eSMiklos Szeredi { 216dd662667SMiklos Szeredi unsigned i; 217e9be9d5eSMiklos Szeredi 218ad204488SMiklos Szeredi dput(ofs->indexdir); 219ad204488SMiklos Szeredi dput(ofs->workdir); 220ad204488SMiklos Szeredi if (ofs->workdir_locked) 221ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->workbasedir); 222ad204488SMiklos Szeredi dput(ofs->workbasedir); 223ad204488SMiklos Szeredi if (ofs->upperdir_locked) 224ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->upper_mnt->mnt_root); 225ad204488SMiklos Szeredi mntput(ofs->upper_mnt); 226ad204488SMiklos Szeredi for (i = 0; i < ofs->numlower; i++) { 227ad204488SMiklos Szeredi mntput(ofs->lower_layers[i].mnt); 228ad204488SMiklos Szeredi free_anon_bdev(ofs->lower_layers[i].pseudo_dev); 2292a9c6d06SChandan Rajendra } 230ad204488SMiklos Szeredi kfree(ofs->lower_layers); 231e9be9d5eSMiklos Szeredi 232ad204488SMiklos Szeredi kfree(ofs->config.lowerdir); 233ad204488SMiklos Szeredi kfree(ofs->config.upperdir); 234ad204488SMiklos Szeredi kfree(ofs->config.workdir); 235ad204488SMiklos Szeredi if (ofs->creator_cred) 236ad204488SMiklos Szeredi put_cred(ofs->creator_cred); 237ad204488SMiklos Szeredi kfree(ofs); 238e9be9d5eSMiklos Szeredi } 239e9be9d5eSMiklos Szeredi 240a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 241a9075cdbSMiklos Szeredi { 242a9075cdbSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 243a9075cdbSMiklos Szeredi 244a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 245a9075cdbSMiklos Szeredi } 246a9075cdbSMiklos Szeredi 247e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 248e593b2bfSAmir Goldstein { 249ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 250e593b2bfSAmir Goldstein struct super_block *upper_sb; 251e593b2bfSAmir Goldstein int ret; 252e593b2bfSAmir Goldstein 253ad204488SMiklos Szeredi if (!ofs->upper_mnt) 254e593b2bfSAmir Goldstein return 0; 255ad204488SMiklos Szeredi upper_sb = ofs->upper_mnt->mnt_sb; 256e593b2bfSAmir Goldstein if (!upper_sb->s_op->sync_fs) 257e593b2bfSAmir Goldstein return 0; 258e593b2bfSAmir Goldstein 259e593b2bfSAmir Goldstein /* real inodes have already been synced by sync_filesystem(ovl_sb) */ 260e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 261e593b2bfSAmir Goldstein ret = upper_sb->s_op->sync_fs(upper_sb, wait); 262e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 263e593b2bfSAmir Goldstein return ret; 264e593b2bfSAmir Goldstein } 265e593b2bfSAmir Goldstein 266cc259639SAndy Whitcroft /** 267cc259639SAndy Whitcroft * ovl_statfs 268cc259639SAndy Whitcroft * @sb: The overlayfs super block 269cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 270cc259639SAndy Whitcroft * 271cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 2724ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 273cc259639SAndy Whitcroft */ 274cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 275cc259639SAndy Whitcroft { 276cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 277cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 278cc259639SAndy Whitcroft struct path path; 279cc259639SAndy Whitcroft int err; 280cc259639SAndy Whitcroft 2814ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 282cc259639SAndy Whitcroft 283cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 284cc259639SAndy Whitcroft if (!err) { 2856b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 286cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 287cc259639SAndy Whitcroft } 288cc259639SAndy Whitcroft 289cc259639SAndy Whitcroft return err; 290cc259639SAndy Whitcroft } 291cc259639SAndy Whitcroft 29202bcd157SAmir Goldstein /* Will this overlay be forced to mount/remount ro? */ 293ad204488SMiklos Szeredi static bool ovl_force_readonly(struct ovl_fs *ofs) 29402bcd157SAmir Goldstein { 295ad204488SMiklos Szeredi return (!ofs->upper_mnt || !ofs->workdir); 29602bcd157SAmir Goldstein } 29702bcd157SAmir Goldstein 298f45827e8SErez Zadok /** 299f45827e8SErez Zadok * ovl_show_options 300f45827e8SErez Zadok * 301f45827e8SErez Zadok * Prints the mount options for a given superblock. 302f45827e8SErez Zadok * Returns zero; does not fail. 303f45827e8SErez Zadok */ 304f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 305f45827e8SErez Zadok { 306f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 307ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 308f45827e8SErez Zadok 309ad204488SMiklos Szeredi seq_show_option(m, "lowerdir", ofs->config.lowerdir); 310ad204488SMiklos Szeredi if (ofs->config.upperdir) { 311ad204488SMiklos Szeredi seq_show_option(m, "upperdir", ofs->config.upperdir); 312ad204488SMiklos Szeredi seq_show_option(m, "workdir", ofs->config.workdir); 31353a08cb9SMiklos Szeredi } 314ad204488SMiklos Szeredi if (ofs->config.default_permissions) 3158d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 316ad204488SMiklos Szeredi if (ofs->config.redirect_dir != ovl_redirect_dir_def) 317c5bef3a7SAmir Goldstein seq_printf(m, ",redirect_dir=%s", 318ad204488SMiklos Szeredi ofs->config.redirect_dir ? "on" : "off"); 319ad204488SMiklos Szeredi if (ofs->config.index != ovl_index_def) 32002bcd157SAmir Goldstein seq_printf(m, ",index=%s", 321ad204488SMiklos Szeredi ofs->config.index ? "on" : "off"); 322f45827e8SErez Zadok return 0; 323f45827e8SErez Zadok } 324f45827e8SErez Zadok 3253cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 3263cdf6fe9SSeunghun Lee { 327ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 3283cdf6fe9SSeunghun Lee 329ad204488SMiklos Szeredi if (!(*flags & MS_RDONLY) && ovl_force_readonly(ofs)) 3303cdf6fe9SSeunghun Lee return -EROFS; 3313cdf6fe9SSeunghun Lee 3323cdf6fe9SSeunghun Lee return 0; 3333cdf6fe9SSeunghun Lee } 3343cdf6fe9SSeunghun Lee 335e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 33613cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 33713cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 33813cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 339e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 340e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 341cc259639SAndy Whitcroft .statfs = ovl_statfs, 342f45827e8SErez Zadok .show_options = ovl_show_options, 3433cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 344e9be9d5eSMiklos Szeredi }; 345e9be9d5eSMiklos Szeredi 346e9be9d5eSMiklos Szeredi enum { 347e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 348e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 349e9be9d5eSMiklos Szeredi OPT_WORKDIR, 3508d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 351a6c60655SMiklos Szeredi OPT_REDIRECT_DIR_ON, 352a6c60655SMiklos Szeredi OPT_REDIRECT_DIR_OFF, 35302bcd157SAmir Goldstein OPT_INDEX_ON, 35402bcd157SAmir Goldstein OPT_INDEX_OFF, 355e9be9d5eSMiklos Szeredi OPT_ERR, 356e9be9d5eSMiklos Szeredi }; 357e9be9d5eSMiklos Szeredi 358e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 359e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 360e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 361e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 3628d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 363a6c60655SMiklos Szeredi {OPT_REDIRECT_DIR_ON, "redirect_dir=on"}, 364a6c60655SMiklos Szeredi {OPT_REDIRECT_DIR_OFF, "redirect_dir=off"}, 36502bcd157SAmir Goldstein {OPT_INDEX_ON, "index=on"}, 36602bcd157SAmir Goldstein {OPT_INDEX_OFF, "index=off"}, 367e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 368e9be9d5eSMiklos Szeredi }; 369e9be9d5eSMiklos Szeredi 37091c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 37191c77947SMiklos Szeredi { 37291c77947SMiklos Szeredi char *sbegin = *s; 37391c77947SMiklos Szeredi char *p; 37491c77947SMiklos Szeredi 37591c77947SMiklos Szeredi if (sbegin == NULL) 37691c77947SMiklos Szeredi return NULL; 37791c77947SMiklos Szeredi 37891c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 37991c77947SMiklos Szeredi if (*p == '\\') { 38091c77947SMiklos Szeredi p++; 38191c77947SMiklos Szeredi if (!*p) 38291c77947SMiklos Szeredi break; 38391c77947SMiklos Szeredi } else if (*p == ',') { 38491c77947SMiklos Szeredi *p = '\0'; 38591c77947SMiklos Szeredi *s = p + 1; 38691c77947SMiklos Szeredi return sbegin; 38791c77947SMiklos Szeredi } 38891c77947SMiklos Szeredi } 38991c77947SMiklos Szeredi *s = NULL; 39091c77947SMiklos Szeredi return sbegin; 39191c77947SMiklos Szeredi } 39291c77947SMiklos Szeredi 393e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 394e9be9d5eSMiklos Szeredi { 395e9be9d5eSMiklos Szeredi char *p; 396e9be9d5eSMiklos Szeredi 39791c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 398e9be9d5eSMiklos Szeredi int token; 399e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 400e9be9d5eSMiklos Szeredi 401e9be9d5eSMiklos Szeredi if (!*p) 402e9be9d5eSMiklos Szeredi continue; 403e9be9d5eSMiklos Szeredi 404e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 405e9be9d5eSMiklos Szeredi switch (token) { 406e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 407e9be9d5eSMiklos Szeredi kfree(config->upperdir); 408e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 409e9be9d5eSMiklos Szeredi if (!config->upperdir) 410e9be9d5eSMiklos Szeredi return -ENOMEM; 411e9be9d5eSMiklos Szeredi break; 412e9be9d5eSMiklos Szeredi 413e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 414e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 415e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 416e9be9d5eSMiklos Szeredi if (!config->lowerdir) 417e9be9d5eSMiklos Szeredi return -ENOMEM; 418e9be9d5eSMiklos Szeredi break; 419e9be9d5eSMiklos Szeredi 420e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 421e9be9d5eSMiklos Szeredi kfree(config->workdir); 422e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 423e9be9d5eSMiklos Szeredi if (!config->workdir) 424e9be9d5eSMiklos Szeredi return -ENOMEM; 425e9be9d5eSMiklos Szeredi break; 426e9be9d5eSMiklos Szeredi 4278d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 4288d3095f4SMiklos Szeredi config->default_permissions = true; 4298d3095f4SMiklos Szeredi break; 4308d3095f4SMiklos Szeredi 431a6c60655SMiklos Szeredi case OPT_REDIRECT_DIR_ON: 432a6c60655SMiklos Szeredi config->redirect_dir = true; 433a6c60655SMiklos Szeredi break; 434a6c60655SMiklos Szeredi 435a6c60655SMiklos Szeredi case OPT_REDIRECT_DIR_OFF: 436a6c60655SMiklos Szeredi config->redirect_dir = false; 437a6c60655SMiklos Szeredi break; 438a6c60655SMiklos Szeredi 43902bcd157SAmir Goldstein case OPT_INDEX_ON: 44002bcd157SAmir Goldstein config->index = true; 44102bcd157SAmir Goldstein break; 44202bcd157SAmir Goldstein 44302bcd157SAmir Goldstein case OPT_INDEX_OFF: 44402bcd157SAmir Goldstein config->index = false; 44502bcd157SAmir Goldstein break; 44602bcd157SAmir Goldstein 447e9be9d5eSMiklos Szeredi default: 448bead55efShujianyang pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p); 449e9be9d5eSMiklos Szeredi return -EINVAL; 450e9be9d5eSMiklos Szeredi } 451e9be9d5eSMiklos Szeredi } 45271cbad7eShujianyang 45371cbad7eShujianyang /* Workdir is useless in non-upper mount */ 45471cbad7eShujianyang if (!config->upperdir && config->workdir) { 45571cbad7eShujianyang pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 45671cbad7eShujianyang config->workdir); 45771cbad7eShujianyang kfree(config->workdir); 45871cbad7eShujianyang config->workdir = NULL; 45971cbad7eShujianyang } 46071cbad7eShujianyang 461e9be9d5eSMiklos Szeredi return 0; 462e9be9d5eSMiklos Szeredi } 463e9be9d5eSMiklos Szeredi 464e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 46502bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 466e9be9d5eSMiklos Szeredi 467ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 4686b8aa129SAmir Goldstein const char *name, bool persist) 469e9be9d5eSMiklos Szeredi { 470ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 471ad204488SMiklos Szeredi struct vfsmount *mnt = ofs->upper_mnt; 472e9be9d5eSMiklos Szeredi struct dentry *work; 473e9be9d5eSMiklos Szeredi int err; 474e9be9d5eSMiklos Szeredi bool retried = false; 4756b8aa129SAmir Goldstein bool locked = false; 476e9be9d5eSMiklos Szeredi 477e9be9d5eSMiklos Szeredi err = mnt_want_write(mnt); 478e9be9d5eSMiklos Szeredi if (err) 4796b8aa129SAmir Goldstein goto out_err; 480e9be9d5eSMiklos Szeredi 4815955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 4826b8aa129SAmir Goldstein locked = true; 4836b8aa129SAmir Goldstein 484e9be9d5eSMiklos Szeredi retry: 485ad204488SMiklos Szeredi work = lookup_one_len(name, ofs->workbasedir, strlen(name)); 486e9be9d5eSMiklos Szeredi 487e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 488c11b9fddSMiklos Szeredi struct iattr attr = { 489c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 49032a3d848SAl Viro .ia_mode = S_IFDIR | 0, 491c11b9fddSMiklos Szeredi }; 492e9be9d5eSMiklos Szeredi 493e9be9d5eSMiklos Szeredi if (work->d_inode) { 494e9be9d5eSMiklos Szeredi err = -EEXIST; 495e9be9d5eSMiklos Szeredi if (retried) 496e9be9d5eSMiklos Szeredi goto out_dput; 497e9be9d5eSMiklos Szeredi 4986b8aa129SAmir Goldstein if (persist) 4996b8aa129SAmir Goldstein goto out_unlock; 5006b8aa129SAmir Goldstein 501e9be9d5eSMiklos Szeredi retried = true; 502eea2fb48SMiklos Szeredi ovl_workdir_cleanup(dir, mnt, work, 0); 503e9be9d5eSMiklos Szeredi dput(work); 504e9be9d5eSMiklos Szeredi goto retry; 505e9be9d5eSMiklos Szeredi } 506e9be9d5eSMiklos Szeredi 50732a3d848SAl Viro err = ovl_create_real(dir, work, 50832a3d848SAl Viro &(struct cattr){.mode = S_IFDIR | 0}, 50932a3d848SAl Viro NULL, true); 510e9be9d5eSMiklos Szeredi if (err) 511e9be9d5eSMiklos Szeredi goto out_dput; 512c11b9fddSMiklos Szeredi 513cb348edbSMiklos Szeredi /* 514cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 515cb348edbSMiklos Szeredi * 516cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 517cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 518cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 519cb348edbSMiklos Szeredi * 520cb348edbSMiklos Szeredi * There are various other error values that could effectively 521cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 522cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 523cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 524cb348edbSMiklos Szeredi * for the above two errors is sufficient. 525cb348edbSMiklos Szeredi */ 526c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 527e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 528c11b9fddSMiklos Szeredi goto out_dput; 529c11b9fddSMiklos Szeredi 530c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 531e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 532c11b9fddSMiklos Szeredi goto out_dput; 533c11b9fddSMiklos Szeredi 534c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 535c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 536c11b9fddSMiklos Szeredi err = notify_change(work, &attr, NULL); 537c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 538c11b9fddSMiklos Szeredi if (err) 539c11b9fddSMiklos Szeredi goto out_dput; 5406b8aa129SAmir Goldstein } else { 5416b8aa129SAmir Goldstein err = PTR_ERR(work); 5426b8aa129SAmir Goldstein goto out_err; 543e9be9d5eSMiklos Szeredi } 544e9be9d5eSMiklos Szeredi out_unlock: 545e9be9d5eSMiklos Szeredi mnt_drop_write(mnt); 5466b8aa129SAmir Goldstein if (locked) 5476b8aa129SAmir Goldstein inode_unlock(dir); 548e9be9d5eSMiklos Szeredi 549e9be9d5eSMiklos Szeredi return work; 550e9be9d5eSMiklos Szeredi 551e9be9d5eSMiklos Szeredi out_dput: 552e9be9d5eSMiklos Szeredi dput(work); 5536b8aa129SAmir Goldstein out_err: 5546b8aa129SAmir Goldstein pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n", 555ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 5566b8aa129SAmir Goldstein work = NULL; 557e9be9d5eSMiklos Szeredi goto out_unlock; 558e9be9d5eSMiklos Szeredi } 559e9be9d5eSMiklos Szeredi 56091c77947SMiklos Szeredi static void ovl_unescape(char *s) 56191c77947SMiklos Szeredi { 56291c77947SMiklos Szeredi char *d = s; 56391c77947SMiklos Szeredi 56491c77947SMiklos Szeredi for (;; s++, d++) { 56591c77947SMiklos Szeredi if (*s == '\\') 56691c77947SMiklos Szeredi s++; 56791c77947SMiklos Szeredi *d = *s; 56891c77947SMiklos Szeredi if (!*s) 56991c77947SMiklos Szeredi break; 57091c77947SMiklos Szeredi } 57191c77947SMiklos Szeredi } 57291c77947SMiklos Szeredi 573ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 574ab508822SMiklos Szeredi { 575a78d9f0dSMiklos Szeredi int err = -EINVAL; 576ab508822SMiklos Szeredi 577a78d9f0dSMiklos Szeredi if (!*name) { 578a78d9f0dSMiklos Szeredi pr_err("overlayfs: empty lowerdir\n"); 579a78d9f0dSMiklos Szeredi goto out; 580a78d9f0dSMiklos Szeredi } 581ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 582ab508822SMiklos Szeredi if (err) { 583ab508822SMiklos Szeredi pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); 584ab508822SMiklos Szeredi goto out; 585ab508822SMiklos Szeredi } 586ab508822SMiklos Szeredi err = -EINVAL; 5877c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 588ab508822SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported\n", name); 589ab508822SMiklos Szeredi goto out_put; 590ab508822SMiklos Szeredi } 5912b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 592ab508822SMiklos Szeredi pr_err("overlayfs: '%s' not a directory\n", name); 593ab508822SMiklos Szeredi goto out_put; 594ab508822SMiklos Szeredi } 595ab508822SMiklos Szeredi return 0; 596ab508822SMiklos Szeredi 597ab508822SMiklos Szeredi out_put: 5988aafcb59SMiklos Szeredi path_put_init(path); 599ab508822SMiklos Szeredi out: 600ab508822SMiklos Szeredi return err; 601ab508822SMiklos Szeredi } 602ab508822SMiklos Szeredi 603ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 604ab508822SMiklos Szeredi { 605ab508822SMiklos Szeredi int err = -ENOMEM; 606ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 607ab508822SMiklos Szeredi 608ab508822SMiklos Szeredi if (tmp) { 609ab508822SMiklos Szeredi ovl_unescape(tmp); 610ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 6117c03b5d4SMiklos Szeredi 6127c03b5d4SMiklos Szeredi if (!err) 6137c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) { 6147c03b5d4SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n", 6157c03b5d4SMiklos Szeredi tmp); 6168aafcb59SMiklos Szeredi path_put_init(path); 6177c03b5d4SMiklos Szeredi err = -EINVAL; 6187c03b5d4SMiklos Szeredi } 619ab508822SMiklos Szeredi kfree(tmp); 620ab508822SMiklos Szeredi } 621ab508822SMiklos Szeredi return err; 622ab508822SMiklos Szeredi } 623ab508822SMiklos Szeredi 6246b2d5fe4SMiklos Szeredi static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 6256b2d5fe4SMiklos Szeredi const char *name) 6266b2d5fe4SMiklos Szeredi { 6276b2d5fe4SMiklos Szeredi struct kstatfs statfs; 6286b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 6296b2d5fe4SMiklos Szeredi 6306b2d5fe4SMiklos Szeredi if (err) 6316b2d5fe4SMiklos Szeredi pr_err("overlayfs: statfs failed on '%s'\n", name); 6326b2d5fe4SMiklos Szeredi else 6336b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 6346b2d5fe4SMiklos Szeredi 6356b2d5fe4SMiklos Szeredi return err; 6366b2d5fe4SMiklos Szeredi } 6376b2d5fe4SMiklos Szeredi 6386b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 6396b2d5fe4SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth, bool *remote) 640ab508822SMiklos Szeredi { 641ab508822SMiklos Szeredi int err; 642ab508822SMiklos Szeredi 643a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 644ab508822SMiklos Szeredi if (err) 645ab508822SMiklos Szeredi goto out; 646ab508822SMiklos Szeredi 6476b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 6486b2d5fe4SMiklos Szeredi if (err) 649ab508822SMiklos Szeredi goto out_put; 6506b2d5fe4SMiklos Szeredi 651ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 652ab508822SMiklos Szeredi 6537c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) 6547c03b5d4SMiklos Szeredi *remote = true; 6557c03b5d4SMiklos Szeredi 65602bcd157SAmir Goldstein /* 65702bcd157SAmir Goldstein * The inodes index feature needs to encode and decode file 65802bcd157SAmir Goldstein * handles, so it requires that all layers support them. 65902bcd157SAmir Goldstein */ 66002bcd157SAmir Goldstein if (ofs->config.index && !ovl_can_decode_fh(path->dentry->d_sb)) { 66102bcd157SAmir Goldstein ofs->config.index = false; 66202bcd157SAmir Goldstein pr_warn("overlayfs: fs on '%s' does not support file handles, falling back to index=off.\n", name); 66302bcd157SAmir Goldstein } 66402bcd157SAmir Goldstein 665ab508822SMiklos Szeredi return 0; 666ab508822SMiklos Szeredi 667ab508822SMiklos Szeredi out_put: 6688aafcb59SMiklos Szeredi path_put_init(path); 669ab508822SMiklos Szeredi out: 670ab508822SMiklos Szeredi return err; 671ab508822SMiklos Szeredi } 672ab508822SMiklos Szeredi 673e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 674e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 675e9be9d5eSMiklos Szeredi { 676e9be9d5eSMiklos Szeredi bool ok = false; 677e9be9d5eSMiklos Szeredi 678e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 679e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 680e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 681e9be9d5eSMiklos Szeredi } 682e9be9d5eSMiklos Szeredi return ok; 683e9be9d5eSMiklos Szeredi } 684e9be9d5eSMiklos Szeredi 685a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 686a78d9f0dSMiklos Szeredi { 687a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 688a78d9f0dSMiklos Szeredi char *s, *d; 689a78d9f0dSMiklos Szeredi 690a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 691a78d9f0dSMiklos Szeredi if (*s == '\\') { 692a78d9f0dSMiklos Szeredi s++; 693a78d9f0dSMiklos Szeredi } else if (*s == ':') { 694a78d9f0dSMiklos Szeredi *d = '\0'; 695a78d9f0dSMiklos Szeredi ctr++; 696a78d9f0dSMiklos Szeredi continue; 697a78d9f0dSMiklos Szeredi } 698a78d9f0dSMiklos Szeredi *d = *s; 699a78d9f0dSMiklos Szeredi if (!*s) 700a78d9f0dSMiklos Szeredi break; 701a78d9f0dSMiklos Szeredi } 702a78d9f0dSMiklos Szeredi return ctr; 703a78d9f0dSMiklos Szeredi } 704a78d9f0dSMiklos Szeredi 7050c97be22SAndreas Gruenbacher static int __maybe_unused 7060eb45fc3SAndreas Gruenbacher ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 7070eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 7080eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 7090eb45fc3SAndreas Gruenbacher { 7101d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 7110eb45fc3SAndreas Gruenbacher } 7120eb45fc3SAndreas Gruenbacher 7130eb45fc3SAndreas Gruenbacher static int __maybe_unused 7140c97be22SAndreas Gruenbacher ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 715d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 716d837a49bSMiklos Szeredi const char *name, const void *value, 717d837a49bSMiklos Szeredi size_t size, int flags) 718d837a49bSMiklos Szeredi { 719d837a49bSMiklos Szeredi struct dentry *workdir = ovl_workdir(dentry); 72009d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 721d837a49bSMiklos Szeredi struct posix_acl *acl = NULL; 722d837a49bSMiklos Szeredi int err; 723d837a49bSMiklos Szeredi 724d837a49bSMiklos Szeredi /* Check that everything is OK before copy-up */ 725d837a49bSMiklos Szeredi if (value) { 726d837a49bSMiklos Szeredi acl = posix_acl_from_xattr(&init_user_ns, value, size); 727d837a49bSMiklos Szeredi if (IS_ERR(acl)) 728d837a49bSMiklos Szeredi return PTR_ERR(acl); 729d837a49bSMiklos Szeredi } 730d837a49bSMiklos Szeredi err = -EOPNOTSUPP; 731d837a49bSMiklos Szeredi if (!IS_POSIXACL(d_inode(workdir))) 732d837a49bSMiklos Szeredi goto out_acl_release; 733d837a49bSMiklos Szeredi if (!realinode->i_op->set_acl) 734d837a49bSMiklos Szeredi goto out_acl_release; 735d837a49bSMiklos Szeredi if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 736d837a49bSMiklos Szeredi err = acl ? -EACCES : 0; 737d837a49bSMiklos Szeredi goto out_acl_release; 738d837a49bSMiklos Szeredi } 739d837a49bSMiklos Szeredi err = -EPERM; 740d837a49bSMiklos Szeredi if (!inode_owner_or_capable(inode)) 741d837a49bSMiklos Szeredi goto out_acl_release; 742d837a49bSMiklos Szeredi 743d837a49bSMiklos Szeredi posix_acl_release(acl); 744d837a49bSMiklos Szeredi 745fd3220d3SMiklos Szeredi /* 746fd3220d3SMiklos Szeredi * Check if sgid bit needs to be cleared (actual setacl operation will 747fd3220d3SMiklos Szeredi * be done with mounter's capabilities and so that won't do it for us). 748fd3220d3SMiklos Szeredi */ 749fd3220d3SMiklos Szeredi if (unlikely(inode->i_mode & S_ISGID) && 750fd3220d3SMiklos Szeredi handler->flags == ACL_TYPE_ACCESS && 751fd3220d3SMiklos Szeredi !in_group_p(inode->i_gid) && 752fd3220d3SMiklos Szeredi !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 753fd3220d3SMiklos Szeredi struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 754fd3220d3SMiklos Szeredi 755fd3220d3SMiklos Szeredi err = ovl_setattr(dentry, &iattr); 756fd3220d3SMiklos Szeredi if (err) 757fd3220d3SMiklos Szeredi return err; 758fd3220d3SMiklos Szeredi } 759fd3220d3SMiklos Szeredi 7601d88f183SMiklos Szeredi err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 761ce31513aSMiklos Szeredi if (!err) 76209d8b586SMiklos Szeredi ovl_copyattr(ovl_inode_real(inode), inode); 763ce31513aSMiklos Szeredi 764ce31513aSMiklos Szeredi return err; 765d837a49bSMiklos Szeredi 766d837a49bSMiklos Szeredi out_acl_release: 767d837a49bSMiklos Szeredi posix_acl_release(acl); 768d837a49bSMiklos Szeredi return err; 769d837a49bSMiklos Szeredi } 770d837a49bSMiklos Szeredi 7710eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 7720eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 7730eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 7740eb45fc3SAndreas Gruenbacher { 77548fab5d7SAmir Goldstein return -EOPNOTSUPP; 7760eb45fc3SAndreas Gruenbacher } 7770eb45fc3SAndreas Gruenbacher 778d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 779d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 780d837a49bSMiklos Szeredi const char *name, const void *value, 781d837a49bSMiklos Szeredi size_t size, int flags) 782d837a49bSMiklos Szeredi { 78348fab5d7SAmir Goldstein return -EOPNOTSUPP; 784d837a49bSMiklos Szeredi } 785d837a49bSMiklos Szeredi 7860eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 7870eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 7880eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 7890eb45fc3SAndreas Gruenbacher { 7901d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 7910eb45fc3SAndreas Gruenbacher } 7920eb45fc3SAndreas Gruenbacher 7930e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 7940e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 7950e585cccSAndreas Gruenbacher const char *name, const void *value, 7960e585cccSAndreas Gruenbacher size_t size, int flags) 7970e585cccSAndreas Gruenbacher { 7981d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 7990e585cccSAndreas Gruenbacher } 8000e585cccSAndreas Gruenbacher 8010c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 8020c97be22SAndreas Gruenbacher ovl_posix_acl_access_xattr_handler = { 803d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_ACCESS, 804d837a49bSMiklos Szeredi .flags = ACL_TYPE_ACCESS, 8050eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 806d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 807d837a49bSMiklos Szeredi }; 808d837a49bSMiklos Szeredi 8090c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 8100c97be22SAndreas Gruenbacher ovl_posix_acl_default_xattr_handler = { 811d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_DEFAULT, 812d837a49bSMiklos Szeredi .flags = ACL_TYPE_DEFAULT, 8130eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 814d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 815d837a49bSMiklos Szeredi }; 816d837a49bSMiklos Szeredi 817d837a49bSMiklos Szeredi static const struct xattr_handler ovl_own_xattr_handler = { 818d837a49bSMiklos Szeredi .prefix = OVL_XATTR_PREFIX, 8190eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 820d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 821d837a49bSMiklos Szeredi }; 822d837a49bSMiklos Szeredi 823d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 824d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 8250eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 826d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 827d837a49bSMiklos Szeredi }; 828d837a49bSMiklos Szeredi 829d837a49bSMiklos Szeredi static const struct xattr_handler *ovl_xattr_handlers[] = { 8300c97be22SAndreas Gruenbacher #ifdef CONFIG_FS_POSIX_ACL 831d837a49bSMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 832d837a49bSMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 8330c97be22SAndreas Gruenbacher #endif 834d837a49bSMiklos Szeredi &ovl_own_xattr_handler, 835d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 836d837a49bSMiklos Szeredi NULL 837d837a49bSMiklos Szeredi }; 838d837a49bSMiklos Szeredi 839ad204488SMiklos Szeredi static int ovl_get_upper(struct ovl_fs *ofs, struct path *upperpath) 8406ee8acf0SMiklos Szeredi { 8415064975eSMiklos Szeredi struct vfsmount *upper_mnt; 8426ee8acf0SMiklos Szeredi int err; 8436ee8acf0SMiklos Szeredi 844ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.upperdir, upperpath); 8456ee8acf0SMiklos Szeredi if (err) 8466ee8acf0SMiklos Szeredi goto out; 8476ee8acf0SMiklos Szeredi 8486ee8acf0SMiklos Szeredi /* Upper fs should not be r/o */ 8496ee8acf0SMiklos Szeredi if (sb_rdonly(upperpath->mnt->mnt_sb)) { 8506ee8acf0SMiklos Szeredi pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n"); 8516ee8acf0SMiklos Szeredi err = -EINVAL; 8526ee8acf0SMiklos Szeredi goto out; 8536ee8acf0SMiklos Szeredi } 8546ee8acf0SMiklos Szeredi 855ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 8566ee8acf0SMiklos Szeredi if (err) 8576ee8acf0SMiklos Szeredi goto out; 8586ee8acf0SMiklos Szeredi 8596ee8acf0SMiklos Szeredi err = -EBUSY; 8606ee8acf0SMiklos Szeredi if (ovl_inuse_trylock(upperpath->dentry)) { 861ad204488SMiklos Szeredi ofs->upperdir_locked = true; 862ad204488SMiklos Szeredi } else if (ofs->config.index) { 8636ee8acf0SMiklos Szeredi pr_err("overlayfs: upperdir is in-use by another mount, mount with '-o index=off' to override exclusive upperdir protection.\n"); 8646ee8acf0SMiklos Szeredi goto out; 8656ee8acf0SMiklos Szeredi } else { 8666ee8acf0SMiklos Szeredi pr_warn("overlayfs: upperdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 8676ee8acf0SMiklos Szeredi } 8685064975eSMiklos Szeredi 8695064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 8705064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 8715064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 8725064975eSMiklos Szeredi pr_err("overlayfs: failed to clone upperpath\n"); 8735064975eSMiklos Szeredi goto out; 8745064975eSMiklos Szeredi } 8755064975eSMiklos Szeredi 8765064975eSMiklos Szeredi /* Don't inherit atime flags */ 8775064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 878ad204488SMiklos Szeredi ofs->upper_mnt = upper_mnt; 8796ee8acf0SMiklos Szeredi err = 0; 8806ee8acf0SMiklos Szeredi out: 8816ee8acf0SMiklos Szeredi return err; 8826ee8acf0SMiklos Szeredi } 8836ee8acf0SMiklos Szeredi 884ad204488SMiklos Szeredi static int ovl_make_workdir(struct ovl_fs *ofs, struct path *workpath) 8858ed61dc3SMiklos Szeredi { 8868ed61dc3SMiklos Szeredi struct dentry *temp; 8878ed61dc3SMiklos Szeredi int err; 8888ed61dc3SMiklos Szeredi 889ad204488SMiklos Szeredi ofs->workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 890ad204488SMiklos Szeredi if (!ofs->workdir) 8918ed61dc3SMiklos Szeredi return 0; 8928ed61dc3SMiklos Szeredi 8938ed61dc3SMiklos Szeredi /* 8948ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 8958ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 8968ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 8978ed61dc3SMiklos Szeredi * previous step. 8988ed61dc3SMiklos Szeredi */ 8998ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 9008ed61dc3SMiklos Szeredi if (err < 0) 9018ed61dc3SMiklos Szeredi return err; 9028ed61dc3SMiklos Szeredi 9038ed61dc3SMiklos Szeredi /* 9048ed61dc3SMiklos Szeredi * We allowed this configuration and don't want to break users over 9058ed61dc3SMiklos Szeredi * kernel upgrade. So warn instead of erroring out. 9068ed61dc3SMiklos Szeredi */ 9078ed61dc3SMiklos Szeredi if (!err) 9088ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs needs to support d_type.\n"); 9098ed61dc3SMiklos Szeredi 9108ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 911ad204488SMiklos Szeredi temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0); 912ad204488SMiklos Szeredi ofs->tmpfile = !IS_ERR(temp); 913ad204488SMiklos Szeredi if (ofs->tmpfile) 9148ed61dc3SMiklos Szeredi dput(temp); 9158ed61dc3SMiklos Szeredi else 9168ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support tmpfile.\n"); 9178ed61dc3SMiklos Szeredi 9188ed61dc3SMiklos Szeredi /* 9198ed61dc3SMiklos Szeredi * Check if upper/work fs supports trusted.overlay.* xattr 9208ed61dc3SMiklos Szeredi */ 921ad204488SMiklos Szeredi err = ovl_do_setxattr(ofs->workdir, OVL_XATTR_OPAQUE, "0", 1, 0); 9228ed61dc3SMiklos Szeredi if (err) { 923ad204488SMiklos Szeredi ofs->noxattr = true; 9248ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support xattr.\n"); 9258ed61dc3SMiklos Szeredi } else { 926ad204488SMiklos Szeredi vfs_removexattr(ofs->workdir, OVL_XATTR_OPAQUE); 9278ed61dc3SMiklos Szeredi } 9288ed61dc3SMiklos Szeredi 9298ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 930ad204488SMiklos Szeredi if (ofs->config.index && 931ad204488SMiklos Szeredi !ovl_can_decode_fh(ofs->workdir->d_sb)) { 932ad204488SMiklos Szeredi ofs->config.index = false; 9338ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support file handles, falling back to index=off.\n"); 9348ed61dc3SMiklos Szeredi } 9358ed61dc3SMiklos Szeredi 9368ed61dc3SMiklos Szeredi return 0; 9378ed61dc3SMiklos Szeredi } 9388ed61dc3SMiklos Szeredi 939ad204488SMiklos Szeredi static int ovl_get_workdir(struct ovl_fs *ofs, struct path *upperpath) 940520d7c86SMiklos Szeredi { 941520d7c86SMiklos Szeredi int err; 942bca44b52SMiklos Szeredi struct path workpath = { }; 943520d7c86SMiklos Szeredi 944ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.workdir, &workpath); 945520d7c86SMiklos Szeredi if (err) 946520d7c86SMiklos Szeredi goto out; 947520d7c86SMiklos Szeredi 948520d7c86SMiklos Szeredi err = -EINVAL; 949bca44b52SMiklos Szeredi if (upperpath->mnt != workpath.mnt) { 950520d7c86SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 951520d7c86SMiklos Szeredi goto out; 952520d7c86SMiklos Szeredi } 953bca44b52SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 954520d7c86SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 955520d7c86SMiklos Szeredi goto out; 956520d7c86SMiklos Szeredi } 957520d7c86SMiklos Szeredi 958520d7c86SMiklos Szeredi err = -EBUSY; 959bca44b52SMiklos Szeredi if (ovl_inuse_trylock(workpath.dentry)) { 960ad204488SMiklos Szeredi ofs->workdir_locked = true; 961ad204488SMiklos Szeredi } else if (ofs->config.index) { 962520d7c86SMiklos Szeredi pr_err("overlayfs: workdir is in-use by another mount, mount with '-o index=off' to override exclusive workdir protection.\n"); 963520d7c86SMiklos Szeredi goto out; 964520d7c86SMiklos Szeredi } else { 965520d7c86SMiklos Szeredi pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 966520d7c86SMiklos Szeredi } 967520d7c86SMiklos Szeredi 968ad204488SMiklos Szeredi ofs->workbasedir = dget(workpath.dentry); 969ad204488SMiklos Szeredi err = ovl_make_workdir(ofs, &workpath); 970bca44b52SMiklos Szeredi if (err) 971bca44b52SMiklos Szeredi goto out; 972bca44b52SMiklos Szeredi 973520d7c86SMiklos Szeredi err = 0; 974520d7c86SMiklos Szeredi out: 975bca44b52SMiklos Szeredi path_put(&workpath); 976bca44b52SMiklos Szeredi 977520d7c86SMiklos Szeredi return err; 978520d7c86SMiklos Szeredi } 979520d7c86SMiklos Szeredi 980ad204488SMiklos Szeredi static int ovl_get_indexdir(struct ovl_fs *ofs, struct ovl_entry *oe, 98195e6d417SMiklos Szeredi struct path *upperpath) 982f7e3a7d9SMiklos Szeredi { 983f7e3a7d9SMiklos Szeredi int err; 984f7e3a7d9SMiklos Szeredi 985f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 986f7e3a7d9SMiklos Szeredi err = ovl_verify_origin(upperpath->dentry, 987f7e3a7d9SMiklos Szeredi oe->lowerstack[0].layer->mnt, 988f7e3a7d9SMiklos Szeredi oe->lowerstack[0].dentry, 989f7e3a7d9SMiklos Szeredi false, true); 990f7e3a7d9SMiklos Szeredi if (err) { 991f7e3a7d9SMiklos Szeredi pr_err("overlayfs: failed to verify upper root origin\n"); 992f7e3a7d9SMiklos Szeredi goto out; 993f7e3a7d9SMiklos Szeredi } 994f7e3a7d9SMiklos Szeredi 995ad204488SMiklos Szeredi ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 996ad204488SMiklos Szeredi if (ofs->indexdir) { 997f7e3a7d9SMiklos Szeredi /* Verify upper root is index dir origin */ 998ad204488SMiklos Szeredi err = ovl_verify_origin(ofs->indexdir, ofs->upper_mnt, 999f7e3a7d9SMiklos Szeredi upperpath->dentry, true, true); 1000f7e3a7d9SMiklos Szeredi if (err) 1001f7e3a7d9SMiklos Szeredi pr_err("overlayfs: failed to verify index dir origin\n"); 1002f7e3a7d9SMiklos Szeredi 1003f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 1004f7e3a7d9SMiklos Szeredi if (!err) 1005ad204488SMiklos Szeredi err = ovl_indexdir_cleanup(ofs->indexdir, 1006ad204488SMiklos Szeredi ofs->upper_mnt, 1007f7e3a7d9SMiklos Szeredi oe->lowerstack, 1008f7e3a7d9SMiklos Szeredi oe->numlower); 1009f7e3a7d9SMiklos Szeredi } 1010ad204488SMiklos Szeredi if (err || !ofs->indexdir) 1011f7e3a7d9SMiklos Szeredi pr_warn("overlayfs: try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1012f7e3a7d9SMiklos Szeredi 1013f7e3a7d9SMiklos Szeredi out: 1014f7e3a7d9SMiklos Szeredi return err; 1015f7e3a7d9SMiklos Szeredi } 1016f7e3a7d9SMiklos Szeredi 1017ad204488SMiklos Szeredi static int ovl_get_lower_layers(struct ovl_fs *ofs, struct path *stack, 1018520d7c86SMiklos Szeredi unsigned int numlower) 1019520d7c86SMiklos Szeredi { 1020520d7c86SMiklos Szeredi int err; 1021520d7c86SMiklos Szeredi unsigned int i; 1022520d7c86SMiklos Szeredi 1023520d7c86SMiklos Szeredi err = -ENOMEM; 1024ad204488SMiklos Szeredi ofs->lower_layers = kcalloc(numlower, sizeof(struct ovl_layer), 1025520d7c86SMiklos Szeredi GFP_KERNEL); 1026ad204488SMiklos Szeredi if (ofs->lower_layers == NULL) 1027520d7c86SMiklos Szeredi goto out; 1028520d7c86SMiklos Szeredi for (i = 0; i < numlower; i++) { 1029520d7c86SMiklos Szeredi struct vfsmount *mnt; 1030520d7c86SMiklos Szeredi dev_t dev; 1031520d7c86SMiklos Szeredi 1032520d7c86SMiklos Szeredi err = get_anon_bdev(&dev); 1033520d7c86SMiklos Szeredi if (err) { 1034520d7c86SMiklos Szeredi pr_err("overlayfs: failed to get anonymous bdev for lowerpath\n"); 1035520d7c86SMiklos Szeredi goto out; 1036520d7c86SMiklos Szeredi } 1037520d7c86SMiklos Szeredi 1038520d7c86SMiklos Szeredi mnt = clone_private_mount(&stack[i]); 1039520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1040520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 1041520d7c86SMiklos Szeredi pr_err("overlayfs: failed to clone lowerpath\n"); 1042520d7c86SMiklos Szeredi free_anon_bdev(dev); 1043520d7c86SMiklos Szeredi goto out; 1044520d7c86SMiklos Szeredi } 1045520d7c86SMiklos Szeredi /* 1046520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1047520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1048520d7c86SMiklos Szeredi */ 1049520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1050520d7c86SMiklos Szeredi 1051ad204488SMiklos Szeredi ofs->lower_layers[ofs->numlower].mnt = mnt; 1052ad204488SMiklos Szeredi ofs->lower_layers[ofs->numlower].pseudo_dev = dev; 1053ad204488SMiklos Szeredi ofs->numlower++; 1054520d7c86SMiklos Szeredi 1055520d7c86SMiklos Szeredi /* Check if all lower layers are on same sb */ 1056520d7c86SMiklos Szeredi if (i == 0) 1057ad204488SMiklos Szeredi ofs->same_sb = mnt->mnt_sb; 1058ad204488SMiklos Szeredi else if (ofs->same_sb != mnt->mnt_sb) 1059ad204488SMiklos Szeredi ofs->same_sb = NULL; 1060520d7c86SMiklos Szeredi } 1061520d7c86SMiklos Szeredi err = 0; 1062520d7c86SMiklos Szeredi out: 1063520d7c86SMiklos Szeredi return err; 1064520d7c86SMiklos Szeredi } 1065520d7c86SMiklos Szeredi 10664155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1067ad204488SMiklos Szeredi struct ovl_fs *ofs) 106853dbb0b4SMiklos Szeredi { 106953dbb0b4SMiklos Szeredi int err; 107053dbb0b4SMiklos Szeredi char *lowertmp, *lower; 10714155c10aSMiklos Szeredi struct path *stack = NULL; 10724155c10aSMiklos Szeredi unsigned int stacklen, numlower = 0, i; 107353dbb0b4SMiklos Szeredi bool remote = false; 10744155c10aSMiklos Szeredi struct ovl_entry *oe; 107553dbb0b4SMiklos Szeredi 107653dbb0b4SMiklos Szeredi err = -ENOMEM; 1077ad204488SMiklos Szeredi lowertmp = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 107853dbb0b4SMiklos Szeredi if (!lowertmp) 10794155c10aSMiklos Szeredi goto out_err; 108053dbb0b4SMiklos Szeredi 108153dbb0b4SMiklos Szeredi err = -EINVAL; 108253dbb0b4SMiklos Szeredi stacklen = ovl_split_lowerdirs(lowertmp); 108353dbb0b4SMiklos Szeredi if (stacklen > OVL_MAX_STACK) { 108453dbb0b4SMiklos Szeredi pr_err("overlayfs: too many lower directories, limit is %d\n", 108553dbb0b4SMiklos Szeredi OVL_MAX_STACK); 10864155c10aSMiklos Szeredi goto out_err; 1087ad204488SMiklos Szeredi } else if (!ofs->config.upperdir && stacklen == 1) { 108853dbb0b4SMiklos Szeredi pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n"); 10894155c10aSMiklos Szeredi goto out_err; 109053dbb0b4SMiklos Szeredi } 109153dbb0b4SMiklos Szeredi 109253dbb0b4SMiklos Szeredi err = -ENOMEM; 109353dbb0b4SMiklos Szeredi stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL); 109453dbb0b4SMiklos Szeredi if (!stack) 10954155c10aSMiklos Szeredi goto out_err; 109653dbb0b4SMiklos Szeredi 109753dbb0b4SMiklos Szeredi err = -EINVAL; 109853dbb0b4SMiklos Szeredi lower = lowertmp; 109953dbb0b4SMiklos Szeredi for (numlower = 0; numlower < stacklen; numlower++) { 1100ad204488SMiklos Szeredi err = ovl_lower_dir(lower, &stack[numlower], ofs, 110153dbb0b4SMiklos Szeredi &sb->s_stack_depth, &remote); 110253dbb0b4SMiklos Szeredi if (err) 11034155c10aSMiklos Szeredi goto out_err; 110453dbb0b4SMiklos Szeredi 110553dbb0b4SMiklos Szeredi lower = strchr(lower, '\0') + 1; 110653dbb0b4SMiklos Szeredi } 110753dbb0b4SMiklos Szeredi 110853dbb0b4SMiklos Szeredi err = -EINVAL; 110953dbb0b4SMiklos Szeredi sb->s_stack_depth++; 111053dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 111153dbb0b4SMiklos Szeredi pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 11124155c10aSMiklos Szeredi goto out_err; 111353dbb0b4SMiklos Szeredi } 111453dbb0b4SMiklos Szeredi 1115ad204488SMiklos Szeredi err = ovl_get_lower_layers(ofs, stack, numlower); 11164155c10aSMiklos Szeredi if (err) 11174155c10aSMiklos Szeredi goto out_err; 11184155c10aSMiklos Szeredi 11194155c10aSMiklos Szeredi err = -ENOMEM; 11204155c10aSMiklos Szeredi oe = ovl_alloc_entry(numlower); 11214155c10aSMiklos Szeredi if (!oe) 11224155c10aSMiklos Szeredi goto out_err; 11234155c10aSMiklos Szeredi 11244155c10aSMiklos Szeredi for (i = 0; i < numlower; i++) { 11254155c10aSMiklos Szeredi oe->lowerstack[i].dentry = dget(stack[i].dentry); 1126ad204488SMiklos Szeredi oe->lowerstack[i].layer = &ofs->lower_layers[i]; 11274155c10aSMiklos Szeredi } 112853dbb0b4SMiklos Szeredi 112953dbb0b4SMiklos Szeredi if (remote) 113053dbb0b4SMiklos Szeredi sb->s_d_op = &ovl_reval_dentry_operations; 113153dbb0b4SMiklos Szeredi else 113253dbb0b4SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 113353dbb0b4SMiklos Szeredi 113453dbb0b4SMiklos Szeredi out: 113553dbb0b4SMiklos Szeredi for (i = 0; i < numlower; i++) 113653dbb0b4SMiklos Szeredi path_put(&stack[i]); 113753dbb0b4SMiklos Szeredi kfree(stack); 11384155c10aSMiklos Szeredi kfree(lowertmp); 11394155c10aSMiklos Szeredi 11404155c10aSMiklos Szeredi return oe; 11414155c10aSMiklos Szeredi 11424155c10aSMiklos Szeredi out_err: 11434155c10aSMiklos Szeredi oe = ERR_PTR(err); 114453dbb0b4SMiklos Szeredi goto out; 114553dbb0b4SMiklos Szeredi } 114653dbb0b4SMiklos Szeredi 1147e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1148e9be9d5eSMiklos Szeredi { 114933006cdfSKees Cook struct path upperpath = { }; 1150e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 11514155c10aSMiklos Szeredi struct ovl_entry *oe; 1152ad204488SMiklos Szeredi struct ovl_fs *ofs; 115351f8f3c4SKonstantin Khlebnikov struct cred *cred; 1154e9be9d5eSMiklos Szeredi int err; 1155e9be9d5eSMiklos Szeredi 1156f45827e8SErez Zadok err = -ENOMEM; 1157ad204488SMiklos Szeredi ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1158ad204488SMiklos Szeredi if (!ofs) 1159e9be9d5eSMiklos Szeredi goto out; 1160e9be9d5eSMiklos Szeredi 1161ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1162c6fe6254SMiklos Szeredi if (!cred) 1163c6fe6254SMiklos Szeredi goto out_err; 1164c6fe6254SMiklos Szeredi 1165ad204488SMiklos Szeredi ofs->config.redirect_dir = ovl_redirect_dir_def; 1166ad204488SMiklos Szeredi ofs->config.index = ovl_index_def; 1167ad204488SMiklos Szeredi err = ovl_parse_opt((char *) data, &ofs->config); 1168f45827e8SErez Zadok if (err) 1169a9075cdbSMiklos Szeredi goto out_err; 1170f45827e8SErez Zadok 1171e9be9d5eSMiklos Szeredi err = -EINVAL; 1172ad204488SMiklos Szeredi if (!ofs->config.lowerdir) { 117307f2af7bSKonstantin Khlebnikov if (!silent) 117453a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'lowerdir'\n"); 1175a9075cdbSMiklos Szeredi goto out_err; 117653a08cb9SMiklos Szeredi } 117753a08cb9SMiklos Szeredi 117853a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 1179cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 1180ad204488SMiklos Szeredi if (ofs->config.upperdir) { 1181ad204488SMiklos Szeredi if (!ofs->config.workdir) { 118253a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'workdir'\n"); 1183a9075cdbSMiklos Szeredi goto out_err; 1184e9be9d5eSMiklos Szeredi } 1185e9be9d5eSMiklos Szeredi 1186ad204488SMiklos Szeredi err = ovl_get_upper(ofs, &upperpath); 118721a3b317SMiklos Szeredi if (err) 1188a9075cdbSMiklos Szeredi goto out_err; 1189d719e8f2SMiklos Szeredi 1190ad204488SMiklos Szeredi err = ovl_get_workdir(ofs, &upperpath); 11918ed61dc3SMiklos Szeredi if (err) 1192a9075cdbSMiklos Szeredi goto out_err; 1193c6fe6254SMiklos Szeredi 1194ad204488SMiklos Szeredi if (!ofs->workdir) 11956e88256eSMiklos Szeredi sb->s_flags |= MS_RDONLY; 11966e88256eSMiklos Szeredi 1197ad204488SMiklos Szeredi sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth; 1198ad204488SMiklos Szeredi sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran; 1199c6fe6254SMiklos Szeredi 120021765194SVivek Goyal } 1201ad204488SMiklos Szeredi oe = ovl_get_lowerstack(sb, ofs); 12024155c10aSMiklos Szeredi err = PTR_ERR(oe); 12034155c10aSMiklos Szeredi if (IS_ERR(oe)) 1204a9075cdbSMiklos Szeredi goto out_err; 1205e9be9d5eSMiklos Szeredi 120671cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 1207ad204488SMiklos Szeredi if (!ofs->upper_mnt) 1208e9be9d5eSMiklos Szeredi sb->s_flags |= MS_RDONLY; 1209ad204488SMiklos Szeredi else if (ofs->upper_mnt->mnt_sb != ofs->same_sb) 1210ad204488SMiklos Szeredi ofs->same_sb = NULL; 1211e9be9d5eSMiklos Szeredi 1212ad204488SMiklos Szeredi if (!(ovl_force_readonly(ofs)) && ofs->config.index) { 1213ad204488SMiklos Szeredi err = ovl_get_indexdir(ofs, oe, &upperpath); 121454fb347eSAmir Goldstein if (err) 12154155c10aSMiklos Szeredi goto out_free_oe; 12166e88256eSMiklos Szeredi 1217ad204488SMiklos Szeredi if (!ofs->indexdir) 12186e88256eSMiklos Szeredi sb->s_flags |= MS_RDONLY; 121902bcd157SAmir Goldstein } 122002bcd157SAmir Goldstein 122102bcd157SAmir Goldstein /* Show index=off/on in /proc/mounts for any of the reasons above */ 1222ad204488SMiklos Szeredi if (!ofs->indexdir) 1223ad204488SMiklos Szeredi ofs->config.index = false; 122402bcd157SAmir Goldstein 122551f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 122651f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 122751f8f3c4SKonstantin Khlebnikov 1228655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1229655042ccSVivek Goyal sb->s_op = &ovl_super_operations; 1230655042ccSVivek Goyal sb->s_xattr = ovl_xattr_handlers; 1231ad204488SMiklos Szeredi sb->s_fs_info = ofs; 1232655042ccSVivek Goyal sb->s_flags |= MS_POSIXACL | MS_NOREMOTELOCK; 1233655042ccSVivek Goyal 1234c6fe6254SMiklos Szeredi err = -ENOMEM; 1235ca4c8a3aSMiklos Szeredi root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 1236e9be9d5eSMiklos Szeredi if (!root_dentry) 12374155c10aSMiklos Szeredi goto out_free_oe; 1238e9be9d5eSMiklos Szeredi 1239e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 1240f3a15685SAmir Goldstein if (upperpath.dentry) { 124155acc661SMiklos Szeredi oe->has_upper = true; 124213c72075SMiklos Szeredi if (ovl_is_impuredir(upperpath.dentry)) 124313c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, d_inode(root_dentry)); 1244f3a15685SAmir Goldstein } 1245e9be9d5eSMiklos Szeredi 1246e9be9d5eSMiklos Szeredi root_dentry->d_fsdata = oe; 1247e9be9d5eSMiklos Szeredi 1248b79e05aaSAmir Goldstein /* Root is always merge -> can have whiteouts */ 1249b79e05aaSAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root_dentry)); 125009d8b586SMiklos Szeredi ovl_inode_init(d_inode(root_dentry), upperpath.dentry, 125109d8b586SMiklos Szeredi ovl_dentry_lower(root_dentry)); 1252ed06e069SMiklos Szeredi 1253e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1254e9be9d5eSMiklos Szeredi 1255e9be9d5eSMiklos Szeredi return 0; 1256e9be9d5eSMiklos Szeredi 12574155c10aSMiklos Szeredi out_free_oe: 12584155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 1259b9343632SChandan Rajendra kfree(oe); 12604155c10aSMiklos Szeredi out_err: 1261e9be9d5eSMiklos Szeredi path_put(&upperpath); 1262ad204488SMiklos Szeredi ovl_free_fs(ofs); 1263e9be9d5eSMiklos Szeredi out: 1264e9be9d5eSMiklos Szeredi return err; 1265e9be9d5eSMiklos Szeredi } 1266e9be9d5eSMiklos Szeredi 1267e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 1268e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 1269e9be9d5eSMiklos Szeredi { 1270e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 1271e9be9d5eSMiklos Szeredi } 1272e9be9d5eSMiklos Szeredi 1273e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 1274e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1275ef94b186SMiklos Szeredi .name = "overlay", 1276e9be9d5eSMiklos Szeredi .mount = ovl_mount, 1277e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 1278e9be9d5eSMiklos Szeredi }; 1279ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 1280e9be9d5eSMiklos Szeredi 128113cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 128213cf199dSAmir Goldstein { 128313cf199dSAmir Goldstein struct ovl_inode *oi = foo; 128413cf199dSAmir Goldstein 128513cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 128613cf199dSAmir Goldstein } 128713cf199dSAmir Goldstein 1288e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 1289e9be9d5eSMiklos Szeredi { 129013cf199dSAmir Goldstein int err; 129113cf199dSAmir Goldstein 129213cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 129313cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 129413cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 129513cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 129613cf199dSAmir Goldstein ovl_inode_init_once); 129713cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 129813cf199dSAmir Goldstein return -ENOMEM; 129913cf199dSAmir Goldstein 130013cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 130113cf199dSAmir Goldstein if (err) 130213cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 130313cf199dSAmir Goldstein 130413cf199dSAmir Goldstein return err; 1305e9be9d5eSMiklos Szeredi } 1306e9be9d5eSMiklos Szeredi 1307e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1308e9be9d5eSMiklos Szeredi { 1309e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 131013cf199dSAmir Goldstein 131113cf199dSAmir Goldstein /* 131213cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 131313cf199dSAmir Goldstein * destroy cache. 131413cf199dSAmir Goldstein */ 131513cf199dSAmir Goldstein rcu_barrier(); 131613cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 131713cf199dSAmir Goldstein 1318e9be9d5eSMiklos Szeredi } 1319e9be9d5eSMiklos Szeredi 1320e9be9d5eSMiklos Szeredi module_init(ovl_init); 1321e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1322