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 36438c84c2SMiklos Szeredi static bool ovl_redirect_always_follow = 37438c84c2SMiklos Szeredi IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW); 38438c84c2SMiklos Szeredi module_param_named(redirect_always_follow, ovl_redirect_always_follow, 39438c84c2SMiklos Szeredi bool, 0644); 40438c84c2SMiklos Szeredi MODULE_PARM_DESC(ovl_redirect_always_follow, 41438c84c2SMiklos Szeredi "Follow redirects even if redirect_dir feature is turned off"); 42438c84c2SMiklos Szeredi 4302bcd157SAmir Goldstein static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX); 4402bcd157SAmir Goldstein module_param_named(index, ovl_index_def, bool, 0644); 4502bcd157SAmir Goldstein MODULE_PARM_DESC(ovl_index_def, 4602bcd157SAmir Goldstein "Default to on or off for the inodes index feature"); 4702bcd157SAmir Goldstein 484155c10aSMiklos Szeredi static void ovl_entry_stack_free(struct ovl_entry *oe) 494155c10aSMiklos Szeredi { 504155c10aSMiklos Szeredi unsigned int i; 514155c10aSMiklos Szeredi 524155c10aSMiklos Szeredi for (i = 0; i < oe->numlower; i++) 534155c10aSMiklos Szeredi dput(oe->lowerstack[i].dentry); 544155c10aSMiklos Szeredi } 554155c10aSMiklos Szeredi 56e9be9d5eSMiklos Szeredi static void ovl_dentry_release(struct dentry *dentry) 57e9be9d5eSMiklos Szeredi { 58e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 59e9be9d5eSMiklos Szeredi 60e9be9d5eSMiklos Szeredi if (oe) { 614155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 62e9be9d5eSMiklos Szeredi kfree_rcu(oe, rcu); 63e9be9d5eSMiklos Szeredi } 64e9be9d5eSMiklos Szeredi } 65e9be9d5eSMiklos Szeredi 66b0990fbbSAmir Goldstein static int ovl_check_append_only(struct inode *inode, int flag) 67b0990fbbSAmir Goldstein { 68b0990fbbSAmir Goldstein /* 69b0990fbbSAmir Goldstein * This test was moot in vfs may_open() because overlay inode does 70b0990fbbSAmir Goldstein * not have the S_APPEND flag, so re-check on real upper inode 71b0990fbbSAmir Goldstein */ 72b0990fbbSAmir Goldstein if (IS_APPEND(inode)) { 73b0990fbbSAmir Goldstein if ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND)) 74b0990fbbSAmir Goldstein return -EPERM; 75b0990fbbSAmir Goldstein if (flag & O_TRUNC) 76b0990fbbSAmir Goldstein return -EPERM; 77b0990fbbSAmir Goldstein } 78b0990fbbSAmir Goldstein 79b0990fbbSAmir Goldstein return 0; 80b0990fbbSAmir Goldstein } 81b0990fbbSAmir Goldstein 822d902671SMiklos Szeredi static struct dentry *ovl_d_real(struct dentry *dentry, 832d902671SMiklos Szeredi const struct inode *inode, 84495e6429SMiklos Szeredi unsigned int open_flags, unsigned int flags) 85d101a125SMiklos Szeredi { 86d101a125SMiklos Szeredi struct dentry *real; 87b0990fbbSAmir Goldstein int err; 88d101a125SMiklos Szeredi 89cd91304eSMiklos Szeredi if (flags & D_REAL_UPPER) 90cd91304eSMiklos Szeredi return ovl_dentry_upper(dentry); 91cd91304eSMiklos Szeredi 92ca4c8a3aSMiklos Szeredi if (!d_is_reg(dentry)) { 93d101a125SMiklos Szeredi if (!inode || inode == d_inode(dentry)) 94d101a125SMiklos Szeredi return dentry; 95d101a125SMiklos Szeredi goto bug; 96d101a125SMiklos Szeredi } 97d101a125SMiklos Szeredi 982d902671SMiklos Szeredi if (open_flags) { 99b0990fbbSAmir Goldstein err = ovl_open_maybe_copy_up(dentry, open_flags); 1002d902671SMiklos Szeredi if (err) 1012d902671SMiklos Szeredi return ERR_PTR(err); 1022d902671SMiklos Szeredi } 1032d902671SMiklos Szeredi 104d101a125SMiklos Szeredi real = ovl_dentry_upper(dentry); 105b0990fbbSAmir Goldstein if (real && (!inode || inode == d_inode(real))) { 106b0990fbbSAmir Goldstein if (!inode) { 107b0990fbbSAmir Goldstein err = ovl_check_append_only(d_inode(real), open_flags); 108b0990fbbSAmir Goldstein if (err) 109b0990fbbSAmir Goldstein return ERR_PTR(err); 110b0990fbbSAmir Goldstein } 111d101a125SMiklos Szeredi return real; 112b0990fbbSAmir Goldstein } 113d101a125SMiklos Szeredi 114d101a125SMiklos Szeredi real = ovl_dentry_lower(dentry); 115d101a125SMiklos Szeredi if (!real) 116d101a125SMiklos Szeredi goto bug; 117d101a125SMiklos Szeredi 118c4fcfc16SMiklos Szeredi /* Handle recursion */ 119495e6429SMiklos Szeredi real = d_real(real, inode, open_flags, 0); 120c4fcfc16SMiklos Szeredi 121d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 122d101a125SMiklos Szeredi return real; 123d101a125SMiklos Szeredi bug: 124656189d2SMiklos Szeredi WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry, 125d101a125SMiklos Szeredi inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0); 126d101a125SMiklos Szeredi return dentry; 127d101a125SMiklos Szeredi } 128d101a125SMiklos Szeredi 1297c03b5d4SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 1307c03b5d4SMiklos Szeredi { 1317c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1327c03b5d4SMiklos Szeredi unsigned int i; 1337c03b5d4SMiklos Szeredi int ret = 1; 1347c03b5d4SMiklos Szeredi 1357c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1367c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1377c03b5d4SMiklos Szeredi 1387c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_REVALIDATE) { 1397c03b5d4SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1407c03b5d4SMiklos Szeredi if (ret < 0) 1417c03b5d4SMiklos Szeredi return ret; 1427c03b5d4SMiklos Szeredi if (!ret) { 1437c03b5d4SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1447c03b5d4SMiklos Szeredi d_invalidate(d); 1457c03b5d4SMiklos Szeredi return -ESTALE; 1467c03b5d4SMiklos Szeredi } 1477c03b5d4SMiklos Szeredi } 1487c03b5d4SMiklos Szeredi } 1497c03b5d4SMiklos Szeredi return 1; 1507c03b5d4SMiklos Szeredi } 1517c03b5d4SMiklos Szeredi 1527c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 1537c03b5d4SMiklos Szeredi { 1547c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1557c03b5d4SMiklos Szeredi unsigned int i; 1567c03b5d4SMiklos Szeredi int ret = 1; 1577c03b5d4SMiklos Szeredi 1587c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1597c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1607c03b5d4SMiklos Szeredi 1617c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) { 1627c03b5d4SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1637c03b5d4SMiklos Szeredi if (ret <= 0) 1647c03b5d4SMiklos Szeredi break; 1657c03b5d4SMiklos Szeredi } 1667c03b5d4SMiklos Szeredi } 1677c03b5d4SMiklos Szeredi return ret; 1687c03b5d4SMiklos Szeredi } 1697c03b5d4SMiklos Szeredi 170e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 171e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 172d101a125SMiklos Szeredi .d_real = ovl_d_real, 173e9be9d5eSMiklos Szeredi }; 174e9be9d5eSMiklos Szeredi 1757c03b5d4SMiklos Szeredi static const struct dentry_operations ovl_reval_dentry_operations = { 1767c03b5d4SMiklos Szeredi .d_release = ovl_dentry_release, 177d101a125SMiklos Szeredi .d_real = ovl_d_real, 1787c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1797c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1807c03b5d4SMiklos Szeredi }; 1817c03b5d4SMiklos Szeredi 18213cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 18313cf199dSAmir Goldstein 18413cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 18513cf199dSAmir Goldstein { 18613cf199dSAmir Goldstein struct ovl_inode *oi = kmem_cache_alloc(ovl_inode_cachep, GFP_KERNEL); 18713cf199dSAmir Goldstein 188b3885bd6SHirofumi Nakagawa if (!oi) 189b3885bd6SHirofumi Nakagawa return NULL; 190b3885bd6SHirofumi Nakagawa 19104a01ac7SMiklos Szeredi oi->cache = NULL; 192cf31c463SMiklos Szeredi oi->redirect = NULL; 19304a01ac7SMiklos Szeredi oi->version = 0; 19413c72075SMiklos Szeredi oi->flags = 0; 19509d8b586SMiklos Szeredi oi->__upperdentry = NULL; 19625b7713aSMiklos Szeredi oi->lower = NULL; 197a015dafcSAmir Goldstein mutex_init(&oi->lock); 19825b7713aSMiklos Szeredi 19913cf199dSAmir Goldstein return &oi->vfs_inode; 20013cf199dSAmir Goldstein } 20113cf199dSAmir Goldstein 20213cf199dSAmir Goldstein static void ovl_i_callback(struct rcu_head *head) 20313cf199dSAmir Goldstein { 20413cf199dSAmir Goldstein struct inode *inode = container_of(head, struct inode, i_rcu); 20513cf199dSAmir Goldstein 20613cf199dSAmir Goldstein kmem_cache_free(ovl_inode_cachep, OVL_I(inode)); 20713cf199dSAmir Goldstein } 20813cf199dSAmir Goldstein 20913cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 21013cf199dSAmir Goldstein { 21109d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 21209d8b586SMiklos Szeredi 21309d8b586SMiklos Szeredi dput(oi->__upperdentry); 21431747edaSAmir Goldstein iput(oi->lower); 215cf31c463SMiklos Szeredi kfree(oi->redirect); 2164edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 217a015dafcSAmir Goldstein mutex_destroy(&oi->lock); 21809d8b586SMiklos Szeredi 21913cf199dSAmir Goldstein call_rcu(&inode->i_rcu, ovl_i_callback); 22013cf199dSAmir Goldstein } 22113cf199dSAmir Goldstein 222ad204488SMiklos Szeredi static void ovl_free_fs(struct ovl_fs *ofs) 223e9be9d5eSMiklos Szeredi { 224dd662667SMiklos Szeredi unsigned i; 225e9be9d5eSMiklos Szeredi 226ad204488SMiklos Szeredi dput(ofs->indexdir); 227ad204488SMiklos Szeredi dput(ofs->workdir); 228ad204488SMiklos Szeredi if (ofs->workdir_locked) 229ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->workbasedir); 230ad204488SMiklos Szeredi dput(ofs->workbasedir); 231ad204488SMiklos Szeredi if (ofs->upperdir_locked) 232ad204488SMiklos Szeredi ovl_inuse_unlock(ofs->upper_mnt->mnt_root); 233ad204488SMiklos Szeredi mntput(ofs->upper_mnt); 234ad204488SMiklos Szeredi for (i = 0; i < ofs->numlower; i++) { 235ad204488SMiklos Szeredi mntput(ofs->lower_layers[i].mnt); 236ad204488SMiklos Szeredi free_anon_bdev(ofs->lower_layers[i].pseudo_dev); 2372a9c6d06SChandan Rajendra } 238ad204488SMiklos Szeredi kfree(ofs->lower_layers); 239e9be9d5eSMiklos Szeredi 240ad204488SMiklos Szeredi kfree(ofs->config.lowerdir); 241ad204488SMiklos Szeredi kfree(ofs->config.upperdir); 242ad204488SMiklos Szeredi kfree(ofs->config.workdir); 243438c84c2SMiklos Szeredi kfree(ofs->config.redirect_mode); 244ad204488SMiklos Szeredi if (ofs->creator_cred) 245ad204488SMiklos Szeredi put_cred(ofs->creator_cred); 246ad204488SMiklos Szeredi kfree(ofs); 247e9be9d5eSMiklos Szeredi } 248e9be9d5eSMiklos Szeredi 249a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 250a9075cdbSMiklos Szeredi { 251a9075cdbSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 252a9075cdbSMiklos Szeredi 253a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 254a9075cdbSMiklos Szeredi } 255a9075cdbSMiklos Szeredi 256e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */ 257e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 258e593b2bfSAmir Goldstein { 259ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 260e593b2bfSAmir Goldstein struct super_block *upper_sb; 261e593b2bfSAmir Goldstein int ret; 262e593b2bfSAmir Goldstein 263ad204488SMiklos Szeredi if (!ofs->upper_mnt) 264e593b2bfSAmir Goldstein return 0; 265e8d4bfe3SChengguang Xu 266e8d4bfe3SChengguang Xu /* 267e8d4bfe3SChengguang Xu * If this is a sync(2) call or an emergency sync, all the super blocks 268e8d4bfe3SChengguang Xu * will be iterated, including upper_sb, so no need to do anything. 269e8d4bfe3SChengguang Xu * 270e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call 271e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being 272e8d4bfe3SChengguang Xu * called with wait == 1. 273e8d4bfe3SChengguang Xu */ 274e8d4bfe3SChengguang Xu if (!wait) 275e593b2bfSAmir Goldstein return 0; 276e593b2bfSAmir Goldstein 277e8d4bfe3SChengguang Xu upper_sb = ofs->upper_mnt->mnt_sb; 278e8d4bfe3SChengguang Xu 279e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 280e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb); 281e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 282e8d4bfe3SChengguang Xu 283e593b2bfSAmir Goldstein return ret; 284e593b2bfSAmir Goldstein } 285e593b2bfSAmir Goldstein 286cc259639SAndy Whitcroft /** 287cc259639SAndy Whitcroft * ovl_statfs 288cc259639SAndy Whitcroft * @sb: The overlayfs super block 289cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 290cc259639SAndy Whitcroft * 291cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 2924ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 293cc259639SAndy Whitcroft */ 294cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 295cc259639SAndy Whitcroft { 296cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 297cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 298cc259639SAndy Whitcroft struct path path; 299cc259639SAndy Whitcroft int err; 300cc259639SAndy Whitcroft 3014ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 302cc259639SAndy Whitcroft 303cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 304cc259639SAndy Whitcroft if (!err) { 3056b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 306cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 307cc259639SAndy Whitcroft } 308cc259639SAndy Whitcroft 309cc259639SAndy Whitcroft return err; 310cc259639SAndy Whitcroft } 311cc259639SAndy Whitcroft 31202bcd157SAmir Goldstein /* Will this overlay be forced to mount/remount ro? */ 313ad204488SMiklos Szeredi static bool ovl_force_readonly(struct ovl_fs *ofs) 31402bcd157SAmir Goldstein { 315ad204488SMiklos Szeredi return (!ofs->upper_mnt || !ofs->workdir); 31602bcd157SAmir Goldstein } 31702bcd157SAmir Goldstein 318438c84c2SMiklos Szeredi static const char *ovl_redirect_mode_def(void) 319438c84c2SMiklos Szeredi { 320438c84c2SMiklos Szeredi return ovl_redirect_dir_def ? "on" : "off"; 321438c84c2SMiklos Szeredi } 322438c84c2SMiklos Szeredi 323f45827e8SErez Zadok /** 324f45827e8SErez Zadok * ovl_show_options 325f45827e8SErez Zadok * 326f45827e8SErez Zadok * Prints the mount options for a given superblock. 327f45827e8SErez Zadok * Returns zero; does not fail. 328f45827e8SErez Zadok */ 329f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 330f45827e8SErez Zadok { 331f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 332ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 333f45827e8SErez Zadok 334ad204488SMiklos Szeredi seq_show_option(m, "lowerdir", ofs->config.lowerdir); 335ad204488SMiklos Szeredi if (ofs->config.upperdir) { 336ad204488SMiklos Szeredi seq_show_option(m, "upperdir", ofs->config.upperdir); 337ad204488SMiklos Szeredi seq_show_option(m, "workdir", ofs->config.workdir); 33853a08cb9SMiklos Szeredi } 339ad204488SMiklos Szeredi if (ofs->config.default_permissions) 3408d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 341438c84c2SMiklos Szeredi if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0) 342438c84c2SMiklos Szeredi seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode); 343ad204488SMiklos Szeredi if (ofs->config.index != ovl_index_def) 344438c84c2SMiklos Szeredi seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off"); 345f45827e8SErez Zadok return 0; 346f45827e8SErez Zadok } 347f45827e8SErez Zadok 3483cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 3493cdf6fe9SSeunghun Lee { 350ad204488SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 3513cdf6fe9SSeunghun Lee 3521751e8a6SLinus Torvalds if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs)) 3533cdf6fe9SSeunghun Lee return -EROFS; 3543cdf6fe9SSeunghun Lee 3553cdf6fe9SSeunghun Lee return 0; 3563cdf6fe9SSeunghun Lee } 3573cdf6fe9SSeunghun Lee 358e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 35913cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 36013cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 36113cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 362e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 363e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 364cc259639SAndy Whitcroft .statfs = ovl_statfs, 365f45827e8SErez Zadok .show_options = ovl_show_options, 3663cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 367e9be9d5eSMiklos Szeredi }; 368e9be9d5eSMiklos Szeredi 369e9be9d5eSMiklos Szeredi enum { 370e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 371e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 372e9be9d5eSMiklos Szeredi OPT_WORKDIR, 3738d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 374438c84c2SMiklos Szeredi OPT_REDIRECT_DIR, 37502bcd157SAmir Goldstein OPT_INDEX_ON, 37602bcd157SAmir Goldstein OPT_INDEX_OFF, 377e9be9d5eSMiklos Szeredi OPT_ERR, 378e9be9d5eSMiklos Szeredi }; 379e9be9d5eSMiklos Szeredi 380e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 381e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 382e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 383e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 3848d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 385438c84c2SMiklos Szeredi {OPT_REDIRECT_DIR, "redirect_dir=%s"}, 38602bcd157SAmir Goldstein {OPT_INDEX_ON, "index=on"}, 38702bcd157SAmir Goldstein {OPT_INDEX_OFF, "index=off"}, 388e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 389e9be9d5eSMiklos Szeredi }; 390e9be9d5eSMiklos Szeredi 39191c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 39291c77947SMiklos Szeredi { 39391c77947SMiklos Szeredi char *sbegin = *s; 39491c77947SMiklos Szeredi char *p; 39591c77947SMiklos Szeredi 39691c77947SMiklos Szeredi if (sbegin == NULL) 39791c77947SMiklos Szeredi return NULL; 39891c77947SMiklos Szeredi 39991c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 40091c77947SMiklos Szeredi if (*p == '\\') { 40191c77947SMiklos Szeredi p++; 40291c77947SMiklos Szeredi if (!*p) 40391c77947SMiklos Szeredi break; 40491c77947SMiklos Szeredi } else if (*p == ',') { 40591c77947SMiklos Szeredi *p = '\0'; 40691c77947SMiklos Szeredi *s = p + 1; 40791c77947SMiklos Szeredi return sbegin; 40891c77947SMiklos Szeredi } 40991c77947SMiklos Szeredi } 41091c77947SMiklos Szeredi *s = NULL; 41191c77947SMiklos Szeredi return sbegin; 41291c77947SMiklos Szeredi } 41391c77947SMiklos Szeredi 414438c84c2SMiklos Szeredi static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode) 415438c84c2SMiklos Szeredi { 416438c84c2SMiklos Szeredi if (strcmp(mode, "on") == 0) { 417438c84c2SMiklos Szeredi config->redirect_dir = true; 418438c84c2SMiklos Szeredi /* 419438c84c2SMiklos Szeredi * Does not make sense to have redirect creation without 420438c84c2SMiklos Szeredi * redirect following. 421438c84c2SMiklos Szeredi */ 422438c84c2SMiklos Szeredi config->redirect_follow = true; 423438c84c2SMiklos Szeredi } else if (strcmp(mode, "follow") == 0) { 424438c84c2SMiklos Szeredi config->redirect_follow = true; 425438c84c2SMiklos Szeredi } else if (strcmp(mode, "off") == 0) { 426438c84c2SMiklos Szeredi if (ovl_redirect_always_follow) 427438c84c2SMiklos Szeredi config->redirect_follow = true; 428438c84c2SMiklos Szeredi } else if (strcmp(mode, "nofollow") != 0) { 429438c84c2SMiklos Szeredi pr_err("overlayfs: bad mount option \"redirect_dir=%s\"\n", 430438c84c2SMiklos Szeredi mode); 431438c84c2SMiklos Szeredi return -EINVAL; 432438c84c2SMiklos Szeredi } 433438c84c2SMiklos Szeredi 434438c84c2SMiklos Szeredi return 0; 435438c84c2SMiklos Szeredi } 436438c84c2SMiklos Szeredi 437e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 438e9be9d5eSMiklos Szeredi { 439e9be9d5eSMiklos Szeredi char *p; 440e9be9d5eSMiklos Szeredi 441438c84c2SMiklos Szeredi config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL); 442438c84c2SMiklos Szeredi if (!config->redirect_mode) 443438c84c2SMiklos Szeredi return -ENOMEM; 444438c84c2SMiklos Szeredi 44591c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 446e9be9d5eSMiklos Szeredi int token; 447e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 448e9be9d5eSMiklos Szeredi 449e9be9d5eSMiklos Szeredi if (!*p) 450e9be9d5eSMiklos Szeredi continue; 451e9be9d5eSMiklos Szeredi 452e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 453e9be9d5eSMiklos Szeredi switch (token) { 454e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 455e9be9d5eSMiklos Szeredi kfree(config->upperdir); 456e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 457e9be9d5eSMiklos Szeredi if (!config->upperdir) 458e9be9d5eSMiklos Szeredi return -ENOMEM; 459e9be9d5eSMiklos Szeredi break; 460e9be9d5eSMiklos Szeredi 461e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 462e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 463e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 464e9be9d5eSMiklos Szeredi if (!config->lowerdir) 465e9be9d5eSMiklos Szeredi return -ENOMEM; 466e9be9d5eSMiklos Szeredi break; 467e9be9d5eSMiklos Szeredi 468e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 469e9be9d5eSMiklos Szeredi kfree(config->workdir); 470e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 471e9be9d5eSMiklos Szeredi if (!config->workdir) 472e9be9d5eSMiklos Szeredi return -ENOMEM; 473e9be9d5eSMiklos Szeredi break; 474e9be9d5eSMiklos Szeredi 4758d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 4768d3095f4SMiklos Szeredi config->default_permissions = true; 4778d3095f4SMiklos Szeredi break; 4788d3095f4SMiklos Szeredi 479438c84c2SMiklos Szeredi case OPT_REDIRECT_DIR: 480438c84c2SMiklos Szeredi kfree(config->redirect_mode); 481438c84c2SMiklos Szeredi config->redirect_mode = match_strdup(&args[0]); 482438c84c2SMiklos Szeredi if (!config->redirect_mode) 483438c84c2SMiklos Szeredi return -ENOMEM; 484a6c60655SMiklos Szeredi break; 485a6c60655SMiklos Szeredi 48602bcd157SAmir Goldstein case OPT_INDEX_ON: 48702bcd157SAmir Goldstein config->index = true; 48802bcd157SAmir Goldstein break; 48902bcd157SAmir Goldstein 49002bcd157SAmir Goldstein case OPT_INDEX_OFF: 49102bcd157SAmir Goldstein config->index = false; 49202bcd157SAmir Goldstein break; 49302bcd157SAmir Goldstein 494e9be9d5eSMiklos Szeredi default: 495bead55efShujianyang pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p); 496e9be9d5eSMiklos Szeredi return -EINVAL; 497e9be9d5eSMiklos Szeredi } 498e9be9d5eSMiklos Szeredi } 49971cbad7eShujianyang 50071cbad7eShujianyang /* Workdir is useless in non-upper mount */ 50171cbad7eShujianyang if (!config->upperdir && config->workdir) { 50271cbad7eShujianyang pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 50371cbad7eShujianyang config->workdir); 50471cbad7eShujianyang kfree(config->workdir); 50571cbad7eShujianyang config->workdir = NULL; 50671cbad7eShujianyang } 50771cbad7eShujianyang 508438c84c2SMiklos Szeredi return ovl_parse_redirect_mode(config, config->redirect_mode); 509e9be9d5eSMiklos Szeredi } 510e9be9d5eSMiklos Szeredi 511e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 51202bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 513e9be9d5eSMiklos Szeredi 514ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 5156b8aa129SAmir Goldstein const char *name, bool persist) 516e9be9d5eSMiklos Szeredi { 517ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 518ad204488SMiklos Szeredi struct vfsmount *mnt = ofs->upper_mnt; 519e9be9d5eSMiklos Szeredi struct dentry *work; 520e9be9d5eSMiklos Szeredi int err; 521e9be9d5eSMiklos Szeredi bool retried = false; 5226b8aa129SAmir Goldstein bool locked = false; 523e9be9d5eSMiklos Szeredi 5245955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 5256b8aa129SAmir Goldstein locked = true; 5266b8aa129SAmir Goldstein 527e9be9d5eSMiklos Szeredi retry: 528ad204488SMiklos Szeredi work = lookup_one_len(name, ofs->workbasedir, strlen(name)); 529e9be9d5eSMiklos Szeredi 530e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 531c11b9fddSMiklos Szeredi struct iattr attr = { 532c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 53332a3d848SAl Viro .ia_mode = S_IFDIR | 0, 534c11b9fddSMiklos Szeredi }; 535e9be9d5eSMiklos Szeredi 536e9be9d5eSMiklos Szeredi if (work->d_inode) { 537e9be9d5eSMiklos Szeredi err = -EEXIST; 538e9be9d5eSMiklos Szeredi if (retried) 539e9be9d5eSMiklos Szeredi goto out_dput; 540e9be9d5eSMiklos Szeredi 5416b8aa129SAmir Goldstein if (persist) 5426b8aa129SAmir Goldstein goto out_unlock; 5436b8aa129SAmir Goldstein 544e9be9d5eSMiklos Szeredi retried = true; 545eea2fb48SMiklos Szeredi ovl_workdir_cleanup(dir, mnt, work, 0); 546e9be9d5eSMiklos Szeredi dput(work); 547e9be9d5eSMiklos Szeredi goto retry; 548e9be9d5eSMiklos Szeredi } 549e9be9d5eSMiklos Szeredi 55032a3d848SAl Viro err = ovl_create_real(dir, work, 55132a3d848SAl Viro &(struct cattr){.mode = S_IFDIR | 0}, 55232a3d848SAl Viro NULL, true); 553e9be9d5eSMiklos Szeredi if (err) 554e9be9d5eSMiklos Szeredi goto out_dput; 555c11b9fddSMiklos Szeredi 556cb348edbSMiklos Szeredi /* 557cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 558cb348edbSMiklos Szeredi * 559cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 560cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 561cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 562cb348edbSMiklos Szeredi * 563cb348edbSMiklos Szeredi * There are various other error values that could effectively 564cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 565cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 566cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 567cb348edbSMiklos Szeredi * for the above two errors is sufficient. 568cb348edbSMiklos Szeredi */ 569c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 570e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 571c11b9fddSMiklos Szeredi goto out_dput; 572c11b9fddSMiklos Szeredi 573c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 574e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 575c11b9fddSMiklos Szeredi goto out_dput; 576c11b9fddSMiklos Szeredi 577c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 578c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 579c11b9fddSMiklos Szeredi err = notify_change(work, &attr, NULL); 580c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 581c11b9fddSMiklos Szeredi if (err) 582c11b9fddSMiklos Szeredi goto out_dput; 5836b8aa129SAmir Goldstein } else { 5846b8aa129SAmir Goldstein err = PTR_ERR(work); 5856b8aa129SAmir Goldstein goto out_err; 586e9be9d5eSMiklos Szeredi } 587e9be9d5eSMiklos Szeredi out_unlock: 5886b8aa129SAmir Goldstein if (locked) 5896b8aa129SAmir Goldstein inode_unlock(dir); 590e9be9d5eSMiklos Szeredi 591e9be9d5eSMiklos Szeredi return work; 592e9be9d5eSMiklos Szeredi 593e9be9d5eSMiklos Szeredi out_dput: 594e9be9d5eSMiklos Szeredi dput(work); 5956b8aa129SAmir Goldstein out_err: 5966b8aa129SAmir Goldstein pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n", 597ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 5986b8aa129SAmir Goldstein work = NULL; 599e9be9d5eSMiklos Szeredi goto out_unlock; 600e9be9d5eSMiklos Szeredi } 601e9be9d5eSMiklos Szeredi 60291c77947SMiklos Szeredi static void ovl_unescape(char *s) 60391c77947SMiklos Szeredi { 60491c77947SMiklos Szeredi char *d = s; 60591c77947SMiklos Szeredi 60691c77947SMiklos Szeredi for (;; s++, d++) { 60791c77947SMiklos Szeredi if (*s == '\\') 60891c77947SMiklos Szeredi s++; 60991c77947SMiklos Szeredi *d = *s; 61091c77947SMiklos Szeredi if (!*s) 61191c77947SMiklos Szeredi break; 61291c77947SMiklos Szeredi } 61391c77947SMiklos Szeredi } 61491c77947SMiklos Szeredi 615ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 616ab508822SMiklos Szeredi { 617a78d9f0dSMiklos Szeredi int err = -EINVAL; 618ab508822SMiklos Szeredi 619a78d9f0dSMiklos Szeredi if (!*name) { 620a78d9f0dSMiklos Szeredi pr_err("overlayfs: empty lowerdir\n"); 621a78d9f0dSMiklos Szeredi goto out; 622a78d9f0dSMiklos Szeredi } 623ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 624ab508822SMiklos Szeredi if (err) { 625ab508822SMiklos Szeredi pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); 626ab508822SMiklos Szeredi goto out; 627ab508822SMiklos Szeredi } 628ab508822SMiklos Szeredi err = -EINVAL; 6297c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 630ab508822SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported\n", name); 631ab508822SMiklos Szeredi goto out_put; 632ab508822SMiklos Szeredi } 6332b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 634ab508822SMiklos Szeredi pr_err("overlayfs: '%s' not a directory\n", name); 635ab508822SMiklos Szeredi goto out_put; 636ab508822SMiklos Szeredi } 637ab508822SMiklos Szeredi return 0; 638ab508822SMiklos Szeredi 639ab508822SMiklos Szeredi out_put: 6408aafcb59SMiklos Szeredi path_put_init(path); 641ab508822SMiklos Szeredi out: 642ab508822SMiklos Szeredi return err; 643ab508822SMiklos Szeredi } 644ab508822SMiklos Szeredi 645ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 646ab508822SMiklos Szeredi { 647ab508822SMiklos Szeredi int err = -ENOMEM; 648ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 649ab508822SMiklos Szeredi 650ab508822SMiklos Szeredi if (tmp) { 651ab508822SMiklos Szeredi ovl_unescape(tmp); 652ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 6537c03b5d4SMiklos Szeredi 6547c03b5d4SMiklos Szeredi if (!err) 6557c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) { 6567c03b5d4SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n", 6577c03b5d4SMiklos Szeredi tmp); 6588aafcb59SMiklos Szeredi path_put_init(path); 6597c03b5d4SMiklos Szeredi err = -EINVAL; 6607c03b5d4SMiklos Szeredi } 661ab508822SMiklos Szeredi kfree(tmp); 662ab508822SMiklos Szeredi } 663ab508822SMiklos Szeredi return err; 664ab508822SMiklos Szeredi } 665ab508822SMiklos Szeredi 6666b2d5fe4SMiklos Szeredi static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 6676b2d5fe4SMiklos Szeredi const char *name) 6686b2d5fe4SMiklos Szeredi { 6696b2d5fe4SMiklos Szeredi struct kstatfs statfs; 6706b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 6716b2d5fe4SMiklos Szeredi 6726b2d5fe4SMiklos Szeredi if (err) 6736b2d5fe4SMiklos Szeredi pr_err("overlayfs: statfs failed on '%s'\n", name); 6746b2d5fe4SMiklos Szeredi else 6756b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 6766b2d5fe4SMiklos Szeredi 6776b2d5fe4SMiklos Szeredi return err; 6786b2d5fe4SMiklos Szeredi } 6796b2d5fe4SMiklos Szeredi 6806b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 6816b2d5fe4SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth, bool *remote) 682ab508822SMiklos Szeredi { 683ab508822SMiklos Szeredi int err; 684ab508822SMiklos Szeredi 685a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 686ab508822SMiklos Szeredi if (err) 687ab508822SMiklos Szeredi goto out; 688ab508822SMiklos Szeredi 6896b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 6906b2d5fe4SMiklos Szeredi if (err) 691ab508822SMiklos Szeredi goto out_put; 6926b2d5fe4SMiklos Szeredi 693ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 694ab508822SMiklos Szeredi 6957c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) 6967c03b5d4SMiklos Szeredi *remote = true; 6977c03b5d4SMiklos Szeredi 69802bcd157SAmir Goldstein /* 69902bcd157SAmir Goldstein * The inodes index feature needs to encode and decode file 70002bcd157SAmir Goldstein * handles, so it requires that all layers support them. 70102bcd157SAmir Goldstein */ 70202bcd157SAmir Goldstein if (ofs->config.index && !ovl_can_decode_fh(path->dentry->d_sb)) { 70302bcd157SAmir Goldstein ofs->config.index = false; 70402bcd157SAmir Goldstein pr_warn("overlayfs: fs on '%s' does not support file handles, falling back to index=off.\n", name); 70502bcd157SAmir Goldstein } 70602bcd157SAmir Goldstein 707ab508822SMiklos Szeredi return 0; 708ab508822SMiklos Szeredi 709ab508822SMiklos Szeredi out_put: 7108aafcb59SMiklos Szeredi path_put_init(path); 711ab508822SMiklos Szeredi out: 712ab508822SMiklos Szeredi return err; 713ab508822SMiklos Szeredi } 714ab508822SMiklos Szeredi 715e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 716e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 717e9be9d5eSMiklos Szeredi { 718e9be9d5eSMiklos Szeredi bool ok = false; 719e9be9d5eSMiklos Szeredi 720e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 721e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 722e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 723e9be9d5eSMiklos Szeredi } 724e9be9d5eSMiklos Szeredi return ok; 725e9be9d5eSMiklos Szeredi } 726e9be9d5eSMiklos Szeredi 727a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 728a78d9f0dSMiklos Szeredi { 729a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 730a78d9f0dSMiklos Szeredi char *s, *d; 731a78d9f0dSMiklos Szeredi 732a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 733a78d9f0dSMiklos Szeredi if (*s == '\\') { 734a78d9f0dSMiklos Szeredi s++; 735a78d9f0dSMiklos Szeredi } else if (*s == ':') { 736a78d9f0dSMiklos Szeredi *d = '\0'; 737a78d9f0dSMiklos Szeredi ctr++; 738a78d9f0dSMiklos Szeredi continue; 739a78d9f0dSMiklos Szeredi } 740a78d9f0dSMiklos Szeredi *d = *s; 741a78d9f0dSMiklos Szeredi if (!*s) 742a78d9f0dSMiklos Szeredi break; 743a78d9f0dSMiklos Szeredi } 744a78d9f0dSMiklos Szeredi return ctr; 745a78d9f0dSMiklos Szeredi } 746a78d9f0dSMiklos Szeredi 7470c97be22SAndreas Gruenbacher static int __maybe_unused 7480eb45fc3SAndreas Gruenbacher ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 7490eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 7500eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 7510eb45fc3SAndreas Gruenbacher { 7521d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, handler->name, buffer, size); 7530eb45fc3SAndreas Gruenbacher } 7540eb45fc3SAndreas Gruenbacher 7550eb45fc3SAndreas Gruenbacher static int __maybe_unused 7560c97be22SAndreas Gruenbacher ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 757d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 758d837a49bSMiklos Szeredi const char *name, const void *value, 759d837a49bSMiklos Szeredi size_t size, int flags) 760d837a49bSMiklos Szeredi { 761d837a49bSMiklos Szeredi struct dentry *workdir = ovl_workdir(dentry); 76209d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 763d837a49bSMiklos Szeredi struct posix_acl *acl = NULL; 764d837a49bSMiklos Szeredi int err; 765d837a49bSMiklos Szeredi 766d837a49bSMiklos Szeredi /* Check that everything is OK before copy-up */ 767d837a49bSMiklos Szeredi if (value) { 768d837a49bSMiklos Szeredi acl = posix_acl_from_xattr(&init_user_ns, value, size); 769d837a49bSMiklos Szeredi if (IS_ERR(acl)) 770d837a49bSMiklos Szeredi return PTR_ERR(acl); 771d837a49bSMiklos Szeredi } 772d837a49bSMiklos Szeredi err = -EOPNOTSUPP; 773d837a49bSMiklos Szeredi if (!IS_POSIXACL(d_inode(workdir))) 774d837a49bSMiklos Szeredi goto out_acl_release; 775d837a49bSMiklos Szeredi if (!realinode->i_op->set_acl) 776d837a49bSMiklos Szeredi goto out_acl_release; 777d837a49bSMiklos Szeredi if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 778d837a49bSMiklos Szeredi err = acl ? -EACCES : 0; 779d837a49bSMiklos Szeredi goto out_acl_release; 780d837a49bSMiklos Szeredi } 781d837a49bSMiklos Szeredi err = -EPERM; 782d837a49bSMiklos Szeredi if (!inode_owner_or_capable(inode)) 783d837a49bSMiklos Szeredi goto out_acl_release; 784d837a49bSMiklos Szeredi 785d837a49bSMiklos Szeredi posix_acl_release(acl); 786d837a49bSMiklos Szeredi 787fd3220d3SMiklos Szeredi /* 788fd3220d3SMiklos Szeredi * Check if sgid bit needs to be cleared (actual setacl operation will 789fd3220d3SMiklos Szeredi * be done with mounter's capabilities and so that won't do it for us). 790fd3220d3SMiklos Szeredi */ 791fd3220d3SMiklos Szeredi if (unlikely(inode->i_mode & S_ISGID) && 792fd3220d3SMiklos Szeredi handler->flags == ACL_TYPE_ACCESS && 793fd3220d3SMiklos Szeredi !in_group_p(inode->i_gid) && 794fd3220d3SMiklos Szeredi !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 795fd3220d3SMiklos Szeredi struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 796fd3220d3SMiklos Szeredi 797fd3220d3SMiklos Szeredi err = ovl_setattr(dentry, &iattr); 798fd3220d3SMiklos Szeredi if (err) 799fd3220d3SMiklos Szeredi return err; 800fd3220d3SMiklos Szeredi } 801fd3220d3SMiklos Szeredi 8021d88f183SMiklos Szeredi err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags); 803ce31513aSMiklos Szeredi if (!err) 80409d8b586SMiklos Szeredi ovl_copyattr(ovl_inode_real(inode), inode); 805ce31513aSMiklos Szeredi 806ce31513aSMiklos Szeredi return err; 807d837a49bSMiklos Szeredi 808d837a49bSMiklos Szeredi out_acl_release: 809d837a49bSMiklos Szeredi posix_acl_release(acl); 810d837a49bSMiklos Szeredi return err; 811d837a49bSMiklos Szeredi } 812d837a49bSMiklos Szeredi 8130eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 8140eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8150eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 8160eb45fc3SAndreas Gruenbacher { 81748fab5d7SAmir Goldstein return -EOPNOTSUPP; 8180eb45fc3SAndreas Gruenbacher } 8190eb45fc3SAndreas Gruenbacher 820d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 821d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 822d837a49bSMiklos Szeredi const char *name, const void *value, 823d837a49bSMiklos Szeredi size_t size, int flags) 824d837a49bSMiklos Szeredi { 82548fab5d7SAmir Goldstein return -EOPNOTSUPP; 826d837a49bSMiklos Szeredi } 827d837a49bSMiklos Szeredi 8280eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 8290eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8300eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 8310eb45fc3SAndreas Gruenbacher { 8321d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 8330eb45fc3SAndreas Gruenbacher } 8340eb45fc3SAndreas Gruenbacher 8350e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 8360e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 8370e585cccSAndreas Gruenbacher const char *name, const void *value, 8380e585cccSAndreas Gruenbacher size_t size, int flags) 8390e585cccSAndreas Gruenbacher { 8401d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 8410e585cccSAndreas Gruenbacher } 8420e585cccSAndreas Gruenbacher 8430c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 8440c97be22SAndreas Gruenbacher ovl_posix_acl_access_xattr_handler = { 845d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_ACCESS, 846d837a49bSMiklos Szeredi .flags = ACL_TYPE_ACCESS, 8470eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 848d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 849d837a49bSMiklos Szeredi }; 850d837a49bSMiklos Szeredi 8510c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 8520c97be22SAndreas Gruenbacher ovl_posix_acl_default_xattr_handler = { 853d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_DEFAULT, 854d837a49bSMiklos Szeredi .flags = ACL_TYPE_DEFAULT, 8550eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 856d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 857d837a49bSMiklos Szeredi }; 858d837a49bSMiklos Szeredi 859d837a49bSMiklos Szeredi static const struct xattr_handler ovl_own_xattr_handler = { 860d837a49bSMiklos Szeredi .prefix = OVL_XATTR_PREFIX, 8610eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 862d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 863d837a49bSMiklos Szeredi }; 864d837a49bSMiklos Szeredi 865d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 866d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 8670eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 868d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 869d837a49bSMiklos Szeredi }; 870d837a49bSMiklos Szeredi 871d837a49bSMiklos Szeredi static const struct xattr_handler *ovl_xattr_handlers[] = { 8720c97be22SAndreas Gruenbacher #ifdef CONFIG_FS_POSIX_ACL 873d837a49bSMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 874d837a49bSMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 8750c97be22SAndreas Gruenbacher #endif 876d837a49bSMiklos Szeredi &ovl_own_xattr_handler, 877d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 878d837a49bSMiklos Szeredi NULL 879d837a49bSMiklos Szeredi }; 880d837a49bSMiklos Szeredi 881ad204488SMiklos Szeredi static int ovl_get_upper(struct ovl_fs *ofs, struct path *upperpath) 8826ee8acf0SMiklos Szeredi { 8835064975eSMiklos Szeredi struct vfsmount *upper_mnt; 8846ee8acf0SMiklos Szeredi int err; 8856ee8acf0SMiklos Szeredi 886ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.upperdir, upperpath); 8876ee8acf0SMiklos Szeredi if (err) 8886ee8acf0SMiklos Szeredi goto out; 8896ee8acf0SMiklos Szeredi 8906ee8acf0SMiklos Szeredi /* Upper fs should not be r/o */ 8916ee8acf0SMiklos Szeredi if (sb_rdonly(upperpath->mnt->mnt_sb)) { 8926ee8acf0SMiklos Szeredi pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n"); 8936ee8acf0SMiklos Szeredi err = -EINVAL; 8946ee8acf0SMiklos Szeredi goto out; 8956ee8acf0SMiklos Szeredi } 8966ee8acf0SMiklos Szeredi 897ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 8986ee8acf0SMiklos Szeredi if (err) 8996ee8acf0SMiklos Szeredi goto out; 9006ee8acf0SMiklos Szeredi 9016ee8acf0SMiklos Szeredi err = -EBUSY; 9026ee8acf0SMiklos Szeredi if (ovl_inuse_trylock(upperpath->dentry)) { 903ad204488SMiklos Szeredi ofs->upperdir_locked = true; 904ad204488SMiklos Szeredi } else if (ofs->config.index) { 9056ee8acf0SMiklos Szeredi pr_err("overlayfs: upperdir is in-use by another mount, mount with '-o index=off' to override exclusive upperdir protection.\n"); 9066ee8acf0SMiklos Szeredi goto out; 9076ee8acf0SMiklos Szeredi } else { 9086ee8acf0SMiklos Szeredi pr_warn("overlayfs: upperdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 9096ee8acf0SMiklos Szeredi } 9105064975eSMiklos Szeredi 9115064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 9125064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 9135064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 9145064975eSMiklos Szeredi pr_err("overlayfs: failed to clone upperpath\n"); 9155064975eSMiklos Szeredi goto out; 9165064975eSMiklos Szeredi } 9175064975eSMiklos Szeredi 9185064975eSMiklos Szeredi /* Don't inherit atime flags */ 9195064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 920ad204488SMiklos Szeredi ofs->upper_mnt = upper_mnt; 9216ee8acf0SMiklos Szeredi err = 0; 9226ee8acf0SMiklos Szeredi out: 9236ee8acf0SMiklos Szeredi return err; 9246ee8acf0SMiklos Szeredi } 9256ee8acf0SMiklos Szeredi 926ad204488SMiklos Szeredi static int ovl_make_workdir(struct ovl_fs *ofs, struct path *workpath) 9278ed61dc3SMiklos Szeredi { 9282ba9d57eSAmir Goldstein struct vfsmount *mnt = ofs->upper_mnt; 9298ed61dc3SMiklos Szeredi struct dentry *temp; 9308ed61dc3SMiklos Szeredi int err; 9318ed61dc3SMiklos Szeredi 9322ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 9332ba9d57eSAmir Goldstein if (err) 9342ba9d57eSAmir Goldstein return err; 9352ba9d57eSAmir Goldstein 936ad204488SMiklos Szeredi ofs->workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 937ad204488SMiklos Szeredi if (!ofs->workdir) 9382ba9d57eSAmir Goldstein goto out; 9398ed61dc3SMiklos Szeredi 9408ed61dc3SMiklos Szeredi /* 9418ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 9428ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 9438ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 9448ed61dc3SMiklos Szeredi * previous step. 9458ed61dc3SMiklos Szeredi */ 9468ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 9478ed61dc3SMiklos Szeredi if (err < 0) 9482ba9d57eSAmir Goldstein goto out; 9498ed61dc3SMiklos Szeredi 9508ed61dc3SMiklos Szeredi /* 9518ed61dc3SMiklos Szeredi * We allowed this configuration and don't want to break users over 9528ed61dc3SMiklos Szeredi * kernel upgrade. So warn instead of erroring out. 9538ed61dc3SMiklos Szeredi */ 9548ed61dc3SMiklos Szeredi if (!err) 9558ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs needs to support d_type.\n"); 9568ed61dc3SMiklos Szeredi 9578ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 958ad204488SMiklos Szeredi temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0); 959ad204488SMiklos Szeredi ofs->tmpfile = !IS_ERR(temp); 960ad204488SMiklos Szeredi if (ofs->tmpfile) 9618ed61dc3SMiklos Szeredi dput(temp); 9628ed61dc3SMiklos Szeredi else 9638ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support tmpfile.\n"); 9648ed61dc3SMiklos Szeredi 9658ed61dc3SMiklos Szeredi /* 9668ed61dc3SMiklos Szeredi * Check if upper/work fs supports trusted.overlay.* xattr 9678ed61dc3SMiklos Szeredi */ 968ad204488SMiklos Szeredi err = ovl_do_setxattr(ofs->workdir, OVL_XATTR_OPAQUE, "0", 1, 0); 9698ed61dc3SMiklos Szeredi if (err) { 970ad204488SMiklos Szeredi ofs->noxattr = true; 9718ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support xattr.\n"); 9722ba9d57eSAmir Goldstein err = 0; 9738ed61dc3SMiklos Szeredi } else { 974ad204488SMiklos Szeredi vfs_removexattr(ofs->workdir, OVL_XATTR_OPAQUE); 9758ed61dc3SMiklos Szeredi } 9768ed61dc3SMiklos Szeredi 9778ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 978ad204488SMiklos Szeredi if (ofs->config.index && 979ad204488SMiklos Szeredi !ovl_can_decode_fh(ofs->workdir->d_sb)) { 980ad204488SMiklos Szeredi ofs->config.index = false; 9818ed61dc3SMiklos Szeredi pr_warn("overlayfs: upper fs does not support file handles, falling back to index=off.\n"); 9828ed61dc3SMiklos Szeredi } 9838ed61dc3SMiklos Szeredi 9842ba9d57eSAmir Goldstein out: 9852ba9d57eSAmir Goldstein mnt_drop_write(mnt); 9862ba9d57eSAmir Goldstein return err; 9878ed61dc3SMiklos Szeredi } 9888ed61dc3SMiklos Szeredi 989ad204488SMiklos Szeredi static int ovl_get_workdir(struct ovl_fs *ofs, struct path *upperpath) 990520d7c86SMiklos Szeredi { 991520d7c86SMiklos Szeredi int err; 992bca44b52SMiklos Szeredi struct path workpath = { }; 993520d7c86SMiklos Szeredi 994ad204488SMiklos Szeredi err = ovl_mount_dir(ofs->config.workdir, &workpath); 995520d7c86SMiklos Szeredi if (err) 996520d7c86SMiklos Szeredi goto out; 997520d7c86SMiklos Szeredi 998520d7c86SMiklos Szeredi err = -EINVAL; 999bca44b52SMiklos Szeredi if (upperpath->mnt != workpath.mnt) { 1000520d7c86SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 1001520d7c86SMiklos Szeredi goto out; 1002520d7c86SMiklos Szeredi } 1003bca44b52SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) { 1004520d7c86SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 1005520d7c86SMiklos Szeredi goto out; 1006520d7c86SMiklos Szeredi } 1007520d7c86SMiklos Szeredi 1008520d7c86SMiklos Szeredi err = -EBUSY; 1009bca44b52SMiklos Szeredi if (ovl_inuse_trylock(workpath.dentry)) { 1010ad204488SMiklos Szeredi ofs->workdir_locked = true; 1011ad204488SMiklos Szeredi } else if (ofs->config.index) { 1012520d7c86SMiklos Szeredi pr_err("overlayfs: workdir is in-use by another mount, mount with '-o index=off' to override exclusive workdir protection.\n"); 1013520d7c86SMiklos Szeredi goto out; 1014520d7c86SMiklos Szeredi } else { 1015520d7c86SMiklos Szeredi pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n"); 1016520d7c86SMiklos Szeredi } 1017520d7c86SMiklos Szeredi 1018ad204488SMiklos Szeredi ofs->workbasedir = dget(workpath.dentry); 1019ad204488SMiklos Szeredi err = ovl_make_workdir(ofs, &workpath); 1020bca44b52SMiklos Szeredi if (err) 1021bca44b52SMiklos Szeredi goto out; 1022bca44b52SMiklos Szeredi 1023520d7c86SMiklos Szeredi err = 0; 1024520d7c86SMiklos Szeredi out: 1025bca44b52SMiklos Szeredi path_put(&workpath); 1026bca44b52SMiklos Szeredi 1027520d7c86SMiklos Szeredi return err; 1028520d7c86SMiklos Szeredi } 1029520d7c86SMiklos Szeredi 1030ad204488SMiklos Szeredi static int ovl_get_indexdir(struct ovl_fs *ofs, struct ovl_entry *oe, 103195e6d417SMiklos Szeredi struct path *upperpath) 1032f7e3a7d9SMiklos Szeredi { 10332ba9d57eSAmir Goldstein struct vfsmount *mnt = ofs->upper_mnt; 1034f7e3a7d9SMiklos Szeredi int err; 1035f7e3a7d9SMiklos Szeredi 10362ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 10372ba9d57eSAmir Goldstein if (err) 10382ba9d57eSAmir Goldstein return err; 10392ba9d57eSAmir Goldstein 1040f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 1041d9768076SAmir Goldstein err = ovl_verify_origin(upperpath->dentry, oe->lowerstack[0].dentry, 1042f7e3a7d9SMiklos Szeredi false, true); 1043f7e3a7d9SMiklos Szeredi if (err) { 1044f7e3a7d9SMiklos Szeredi pr_err("overlayfs: failed to verify upper root origin\n"); 1045f7e3a7d9SMiklos Szeredi goto out; 1046f7e3a7d9SMiklos Szeredi } 1047f7e3a7d9SMiklos Szeredi 1048ad204488SMiklos Szeredi ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 1049ad204488SMiklos Szeredi if (ofs->indexdir) { 1050f7e3a7d9SMiklos Szeredi /* Verify upper root is index dir origin */ 1051d9768076SAmir Goldstein err = ovl_verify_origin(ofs->indexdir, upperpath->dentry, 1052d9768076SAmir Goldstein true, true); 1053f7e3a7d9SMiklos Szeredi if (err) 1054f7e3a7d9SMiklos Szeredi pr_err("overlayfs: failed to verify index dir origin\n"); 1055f7e3a7d9SMiklos Szeredi 1056f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 1057f7e3a7d9SMiklos Szeredi if (!err) 1058ad204488SMiklos Szeredi err = ovl_indexdir_cleanup(ofs->indexdir, 1059ad204488SMiklos Szeredi ofs->upper_mnt, 1060f7e3a7d9SMiklos Szeredi oe->lowerstack, 1061f7e3a7d9SMiklos Szeredi oe->numlower); 1062f7e3a7d9SMiklos Szeredi } 1063ad204488SMiklos Szeredi if (err || !ofs->indexdir) 1064f7e3a7d9SMiklos Szeredi pr_warn("overlayfs: try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 1065f7e3a7d9SMiklos Szeredi 1066f7e3a7d9SMiklos Szeredi out: 10672ba9d57eSAmir Goldstein mnt_drop_write(mnt); 1068f7e3a7d9SMiklos Szeredi return err; 1069f7e3a7d9SMiklos Szeredi } 1070f7e3a7d9SMiklos Szeredi 1071ad204488SMiklos Szeredi static int ovl_get_lower_layers(struct ovl_fs *ofs, struct path *stack, 1072520d7c86SMiklos Szeredi unsigned int numlower) 1073520d7c86SMiklos Szeredi { 1074520d7c86SMiklos Szeredi int err; 1075520d7c86SMiklos Szeredi unsigned int i; 1076520d7c86SMiklos Szeredi 1077520d7c86SMiklos Szeredi err = -ENOMEM; 1078ad204488SMiklos Szeredi ofs->lower_layers = kcalloc(numlower, sizeof(struct ovl_layer), 1079520d7c86SMiklos Szeredi GFP_KERNEL); 1080ad204488SMiklos Szeredi if (ofs->lower_layers == NULL) 1081520d7c86SMiklos Szeredi goto out; 1082520d7c86SMiklos Szeredi for (i = 0; i < numlower; i++) { 1083520d7c86SMiklos Szeredi struct vfsmount *mnt; 1084520d7c86SMiklos Szeredi dev_t dev; 1085520d7c86SMiklos Szeredi 1086520d7c86SMiklos Szeredi err = get_anon_bdev(&dev); 1087520d7c86SMiklos Szeredi if (err) { 1088520d7c86SMiklos Szeredi pr_err("overlayfs: failed to get anonymous bdev for lowerpath\n"); 1089520d7c86SMiklos Szeredi goto out; 1090520d7c86SMiklos Szeredi } 1091520d7c86SMiklos Szeredi 1092520d7c86SMiklos Szeredi mnt = clone_private_mount(&stack[i]); 1093520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1094520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 1095520d7c86SMiklos Szeredi pr_err("overlayfs: failed to clone lowerpath\n"); 1096520d7c86SMiklos Szeredi free_anon_bdev(dev); 1097520d7c86SMiklos Szeredi goto out; 1098520d7c86SMiklos Szeredi } 1099520d7c86SMiklos Szeredi /* 1100520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1101520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1102520d7c86SMiklos Szeredi */ 1103520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1104520d7c86SMiklos Szeredi 1105ad204488SMiklos Szeredi ofs->lower_layers[ofs->numlower].mnt = mnt; 1106ad204488SMiklos Szeredi ofs->lower_layers[ofs->numlower].pseudo_dev = dev; 1107ad204488SMiklos Szeredi ofs->numlower++; 1108520d7c86SMiklos Szeredi 1109520d7c86SMiklos Szeredi /* Check if all lower layers are on same sb */ 1110520d7c86SMiklos Szeredi if (i == 0) 1111ad204488SMiklos Szeredi ofs->same_sb = mnt->mnt_sb; 1112ad204488SMiklos Szeredi else if (ofs->same_sb != mnt->mnt_sb) 1113ad204488SMiklos Szeredi ofs->same_sb = NULL; 1114520d7c86SMiklos Szeredi } 1115520d7c86SMiklos Szeredi err = 0; 1116520d7c86SMiklos Szeredi out: 1117520d7c86SMiklos Szeredi return err; 1118520d7c86SMiklos Szeredi } 1119520d7c86SMiklos Szeredi 11204155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1121ad204488SMiklos Szeredi struct ovl_fs *ofs) 112253dbb0b4SMiklos Szeredi { 112353dbb0b4SMiklos Szeredi int err; 112453dbb0b4SMiklos Szeredi char *lowertmp, *lower; 11254155c10aSMiklos Szeredi struct path *stack = NULL; 11264155c10aSMiklos Szeredi unsigned int stacklen, numlower = 0, i; 112753dbb0b4SMiklos Szeredi bool remote = false; 11284155c10aSMiklos Szeredi struct ovl_entry *oe; 112953dbb0b4SMiklos Szeredi 113053dbb0b4SMiklos Szeredi err = -ENOMEM; 1131ad204488SMiklos Szeredi lowertmp = kstrdup(ofs->config.lowerdir, GFP_KERNEL); 113253dbb0b4SMiklos Szeredi if (!lowertmp) 11334155c10aSMiklos Szeredi goto out_err; 113453dbb0b4SMiklos Szeredi 113553dbb0b4SMiklos Szeredi err = -EINVAL; 113653dbb0b4SMiklos Szeredi stacklen = ovl_split_lowerdirs(lowertmp); 113753dbb0b4SMiklos Szeredi if (stacklen > OVL_MAX_STACK) { 113853dbb0b4SMiklos Szeredi pr_err("overlayfs: too many lower directories, limit is %d\n", 113953dbb0b4SMiklos Szeredi OVL_MAX_STACK); 11404155c10aSMiklos Szeredi goto out_err; 1141ad204488SMiklos Szeredi } else if (!ofs->config.upperdir && stacklen == 1) { 114253dbb0b4SMiklos Szeredi pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n"); 11434155c10aSMiklos Szeredi goto out_err; 114453dbb0b4SMiklos Szeredi } 114553dbb0b4SMiklos Szeredi 114653dbb0b4SMiklos Szeredi err = -ENOMEM; 114753dbb0b4SMiklos Szeredi stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL); 114853dbb0b4SMiklos Szeredi if (!stack) 11494155c10aSMiklos Szeredi goto out_err; 115053dbb0b4SMiklos Szeredi 115153dbb0b4SMiklos Szeredi err = -EINVAL; 115253dbb0b4SMiklos Szeredi lower = lowertmp; 115353dbb0b4SMiklos Szeredi for (numlower = 0; numlower < stacklen; numlower++) { 1154ad204488SMiklos Szeredi err = ovl_lower_dir(lower, &stack[numlower], ofs, 115553dbb0b4SMiklos Szeredi &sb->s_stack_depth, &remote); 115653dbb0b4SMiklos Szeredi if (err) 11574155c10aSMiklos Szeredi goto out_err; 115853dbb0b4SMiklos Szeredi 115953dbb0b4SMiklos Szeredi lower = strchr(lower, '\0') + 1; 116053dbb0b4SMiklos Szeredi } 116153dbb0b4SMiklos Szeredi 116253dbb0b4SMiklos Szeredi err = -EINVAL; 116353dbb0b4SMiklos Szeredi sb->s_stack_depth++; 116453dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 116553dbb0b4SMiklos Szeredi pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 11664155c10aSMiklos Szeredi goto out_err; 116753dbb0b4SMiklos Szeredi } 116853dbb0b4SMiklos Szeredi 1169ad204488SMiklos Szeredi err = ovl_get_lower_layers(ofs, stack, numlower); 11704155c10aSMiklos Szeredi if (err) 11714155c10aSMiklos Szeredi goto out_err; 11724155c10aSMiklos Szeredi 11734155c10aSMiklos Szeredi err = -ENOMEM; 11744155c10aSMiklos Szeredi oe = ovl_alloc_entry(numlower); 11754155c10aSMiklos Szeredi if (!oe) 11764155c10aSMiklos Szeredi goto out_err; 11774155c10aSMiklos Szeredi 11784155c10aSMiklos Szeredi for (i = 0; i < numlower; i++) { 11794155c10aSMiklos Szeredi oe->lowerstack[i].dentry = dget(stack[i].dentry); 1180ad204488SMiklos Szeredi oe->lowerstack[i].layer = &ofs->lower_layers[i]; 11814155c10aSMiklos Szeredi } 118253dbb0b4SMiklos Szeredi 118353dbb0b4SMiklos Szeredi if (remote) 118453dbb0b4SMiklos Szeredi sb->s_d_op = &ovl_reval_dentry_operations; 118553dbb0b4SMiklos Szeredi else 118653dbb0b4SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 118753dbb0b4SMiklos Szeredi 118853dbb0b4SMiklos Szeredi out: 118953dbb0b4SMiklos Szeredi for (i = 0; i < numlower; i++) 119053dbb0b4SMiklos Szeredi path_put(&stack[i]); 119153dbb0b4SMiklos Szeredi kfree(stack); 11924155c10aSMiklos Szeredi kfree(lowertmp); 11934155c10aSMiklos Szeredi 11944155c10aSMiklos Szeredi return oe; 11954155c10aSMiklos Szeredi 11964155c10aSMiklos Szeredi out_err: 11974155c10aSMiklos Szeredi oe = ERR_PTR(err); 119853dbb0b4SMiklos Szeredi goto out; 119953dbb0b4SMiklos Szeredi } 120053dbb0b4SMiklos Szeredi 1201e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 1202e9be9d5eSMiklos Szeredi { 120333006cdfSKees Cook struct path upperpath = { }; 1204e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 12054155c10aSMiklos Szeredi struct ovl_entry *oe; 1206ad204488SMiklos Szeredi struct ovl_fs *ofs; 120751f8f3c4SKonstantin Khlebnikov struct cred *cred; 1208e9be9d5eSMiklos Szeredi int err; 1209e9be9d5eSMiklos Szeredi 1210f45827e8SErez Zadok err = -ENOMEM; 1211ad204488SMiklos Szeredi ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 1212ad204488SMiklos Szeredi if (!ofs) 1213e9be9d5eSMiklos Szeredi goto out; 1214e9be9d5eSMiklos Szeredi 1215ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1216c6fe6254SMiklos Szeredi if (!cred) 1217c6fe6254SMiklos Szeredi goto out_err; 1218c6fe6254SMiklos Szeredi 1219ad204488SMiklos Szeredi ofs->config.index = ovl_index_def; 1220ad204488SMiklos Szeredi err = ovl_parse_opt((char *) data, &ofs->config); 1221f45827e8SErez Zadok if (err) 1222a9075cdbSMiklos Szeredi goto out_err; 1223f45827e8SErez Zadok 1224e9be9d5eSMiklos Szeredi err = -EINVAL; 1225ad204488SMiklos Szeredi if (!ofs->config.lowerdir) { 122607f2af7bSKonstantin Khlebnikov if (!silent) 122753a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'lowerdir'\n"); 1228a9075cdbSMiklos Szeredi goto out_err; 122953a08cb9SMiklos Szeredi } 123053a08cb9SMiklos Szeredi 123153a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 1232cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 1233ad204488SMiklos Szeredi if (ofs->config.upperdir) { 1234ad204488SMiklos Szeredi if (!ofs->config.workdir) { 123553a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'workdir'\n"); 1236a9075cdbSMiklos Szeredi goto out_err; 1237e9be9d5eSMiklos Szeredi } 1238e9be9d5eSMiklos Szeredi 1239ad204488SMiklos Szeredi err = ovl_get_upper(ofs, &upperpath); 124021a3b317SMiklos Szeredi if (err) 1241a9075cdbSMiklos Szeredi goto out_err; 1242d719e8f2SMiklos Szeredi 1243ad204488SMiklos Szeredi err = ovl_get_workdir(ofs, &upperpath); 12448ed61dc3SMiklos Szeredi if (err) 1245a9075cdbSMiklos Szeredi goto out_err; 1246c6fe6254SMiklos Szeredi 1247ad204488SMiklos Szeredi if (!ofs->workdir) 12481751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 12496e88256eSMiklos Szeredi 1250ad204488SMiklos Szeredi sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth; 1251ad204488SMiklos Szeredi sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran; 1252c6fe6254SMiklos Szeredi 125321765194SVivek Goyal } 1254ad204488SMiklos Szeredi oe = ovl_get_lowerstack(sb, ofs); 12554155c10aSMiklos Szeredi err = PTR_ERR(oe); 12564155c10aSMiklos Szeredi if (IS_ERR(oe)) 1257a9075cdbSMiklos Szeredi goto out_err; 1258e9be9d5eSMiklos Szeredi 125971cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 1260ad204488SMiklos Szeredi if (!ofs->upper_mnt) 12611751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 1262ad204488SMiklos Szeredi else if (ofs->upper_mnt->mnt_sb != ofs->same_sb) 1263ad204488SMiklos Szeredi ofs->same_sb = NULL; 1264e9be9d5eSMiklos Szeredi 1265ad204488SMiklos Szeredi if (!(ovl_force_readonly(ofs)) && ofs->config.index) { 1266ad204488SMiklos Szeredi err = ovl_get_indexdir(ofs, oe, &upperpath); 126754fb347eSAmir Goldstein if (err) 12684155c10aSMiklos Szeredi goto out_free_oe; 12696e88256eSMiklos Szeredi 1270ad204488SMiklos Szeredi if (!ofs->indexdir) 12711751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 127202bcd157SAmir Goldstein } 127302bcd157SAmir Goldstein 127402bcd157SAmir Goldstein /* Show index=off/on in /proc/mounts for any of the reasons above */ 1275ad204488SMiklos Szeredi if (!ofs->indexdir) 1276ad204488SMiklos Szeredi ofs->config.index = false; 127702bcd157SAmir Goldstein 127851f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 127951f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 128051f8f3c4SKonstantin Khlebnikov 1281655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1282655042ccSVivek Goyal sb->s_op = &ovl_super_operations; 1283655042ccSVivek Goyal sb->s_xattr = ovl_xattr_handlers; 1284ad204488SMiklos Szeredi sb->s_fs_info = ofs; 12851751e8a6SLinus Torvalds sb->s_flags |= SB_POSIXACL | SB_NOREMOTELOCK; 1286655042ccSVivek Goyal 1287c6fe6254SMiklos Szeredi err = -ENOMEM; 1288ca4c8a3aSMiklos Szeredi root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 1289e9be9d5eSMiklos Szeredi if (!root_dentry) 12904155c10aSMiklos Szeredi goto out_free_oe; 1291e9be9d5eSMiklos Szeredi 1292e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 1293f3a15685SAmir Goldstein if (upperpath.dentry) { 129455acc661SMiklos Szeredi oe->has_upper = true; 129513c72075SMiklos Szeredi if (ovl_is_impuredir(upperpath.dentry)) 129613c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, d_inode(root_dentry)); 1297f3a15685SAmir Goldstein } 1298e9be9d5eSMiklos Szeredi 1299e9be9d5eSMiklos Szeredi root_dentry->d_fsdata = oe; 1300e9be9d5eSMiklos Szeredi 1301b79e05aaSAmir Goldstein /* Root is always merge -> can have whiteouts */ 1302b79e05aaSAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root_dentry)); 130309d8b586SMiklos Szeredi ovl_inode_init(d_inode(root_dentry), upperpath.dentry, 130409d8b586SMiklos Szeredi ovl_dentry_lower(root_dentry)); 1305ed06e069SMiklos Szeredi 1306e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1307e9be9d5eSMiklos Szeredi 1308e9be9d5eSMiklos Szeredi return 0; 1309e9be9d5eSMiklos Szeredi 13104155c10aSMiklos Szeredi out_free_oe: 13114155c10aSMiklos Szeredi ovl_entry_stack_free(oe); 1312b9343632SChandan Rajendra kfree(oe); 13134155c10aSMiklos Szeredi out_err: 1314e9be9d5eSMiklos Szeredi path_put(&upperpath); 1315ad204488SMiklos Szeredi ovl_free_fs(ofs); 1316e9be9d5eSMiklos Szeredi out: 1317e9be9d5eSMiklos Szeredi return err; 1318e9be9d5eSMiklos Szeredi } 1319e9be9d5eSMiklos Szeredi 1320e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 1321e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 1322e9be9d5eSMiklos Szeredi { 1323e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 1324e9be9d5eSMiklos Szeredi } 1325e9be9d5eSMiklos Szeredi 1326e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 1327e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1328ef94b186SMiklos Szeredi .name = "overlay", 1329e9be9d5eSMiklos Szeredi .mount = ovl_mount, 1330e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 1331e9be9d5eSMiklos Szeredi }; 1332ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 1333e9be9d5eSMiklos Szeredi 133413cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 133513cf199dSAmir Goldstein { 133613cf199dSAmir Goldstein struct ovl_inode *oi = foo; 133713cf199dSAmir Goldstein 133813cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 133913cf199dSAmir Goldstein } 134013cf199dSAmir Goldstein 1341e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 1342e9be9d5eSMiklos Szeredi { 134313cf199dSAmir Goldstein int err; 134413cf199dSAmir Goldstein 134513cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 134613cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 134713cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 134813cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 134913cf199dSAmir Goldstein ovl_inode_init_once); 135013cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 135113cf199dSAmir Goldstein return -ENOMEM; 135213cf199dSAmir Goldstein 135313cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 135413cf199dSAmir Goldstein if (err) 135513cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 135613cf199dSAmir Goldstein 135713cf199dSAmir Goldstein return err; 1358e9be9d5eSMiklos Szeredi } 1359e9be9d5eSMiklos Szeredi 1360e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1361e9be9d5eSMiklos Szeredi { 1362e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 136313cf199dSAmir Goldstein 136413cf199dSAmir Goldstein /* 136513cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 136613cf199dSAmir Goldstein * destroy cache. 136713cf199dSAmir Goldstein */ 136813cf199dSAmir Goldstein rcu_barrier(); 136913cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 137013cf199dSAmir Goldstein 1371e9be9d5eSMiklos Szeredi } 1372e9be9d5eSMiklos Szeredi 1373e9be9d5eSMiklos Szeredi module_init(ovl_init); 1374e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1375