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 10e9be9d5eSMiklos Szeredi #include <linux/fs.h> 11e9be9d5eSMiklos Szeredi #include <linux/namei.h> 12e9be9d5eSMiklos Szeredi #include <linux/xattr.h> 13e9be9d5eSMiklos Szeredi #include <linux/mount.h> 14e9be9d5eSMiklos Szeredi #include <linux/parser.h> 15e9be9d5eSMiklos Szeredi #include <linux/module.h> 16cc259639SAndy Whitcroft #include <linux/statfs.h> 17f45827e8SErez Zadok #include <linux/seq_file.h> 18d837a49bSMiklos Szeredi #include <linux/posix_acl_xattr.h> 19e9be9d5eSMiklos Szeredi #include "overlayfs.h" 20bbb1e54dSMiklos Szeredi #include "ovl_entry.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 36e9be9d5eSMiklos Szeredi static void ovl_dentry_release(struct dentry *dentry) 37e9be9d5eSMiklos Szeredi { 38e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 39e9be9d5eSMiklos Szeredi 40e9be9d5eSMiklos Szeredi if (oe) { 41dd662667SMiklos Szeredi unsigned int i; 42dd662667SMiklos Szeredi 43e9be9d5eSMiklos Szeredi dput(oe->__upperdentry); 4402b69b28SMiklos Szeredi kfree(oe->redirect); 45dd662667SMiklos Szeredi for (i = 0; i < oe->numlower; i++) 46dd662667SMiklos Szeredi dput(oe->lowerstack[i].dentry); 47e9be9d5eSMiklos Szeredi kfree_rcu(oe, rcu); 48e9be9d5eSMiklos Szeredi } 49e9be9d5eSMiklos Szeredi } 50e9be9d5eSMiklos Szeredi 512d902671SMiklos Szeredi static struct dentry *ovl_d_real(struct dentry *dentry, 522d902671SMiklos Szeredi const struct inode *inode, 532d902671SMiklos Szeredi unsigned int open_flags) 54d101a125SMiklos Szeredi { 55d101a125SMiklos Szeredi struct dentry *real; 56d101a125SMiklos Szeredi 57ca4c8a3aSMiklos Szeredi if (!d_is_reg(dentry)) { 58d101a125SMiklos Szeredi if (!inode || inode == d_inode(dentry)) 59d101a125SMiklos Szeredi return dentry; 60d101a125SMiklos Szeredi goto bug; 61d101a125SMiklos Szeredi } 62d101a125SMiklos Szeredi 632d902671SMiklos Szeredi if (d_is_negative(dentry)) 642d902671SMiklos Szeredi return dentry; 652d902671SMiklos Szeredi 662d902671SMiklos Szeredi if (open_flags) { 672d902671SMiklos Szeredi int err = ovl_open_maybe_copy_up(dentry, open_flags); 682d902671SMiklos Szeredi 692d902671SMiklos Szeredi if (err) 702d902671SMiklos Szeredi return ERR_PTR(err); 712d902671SMiklos Szeredi } 722d902671SMiklos Szeredi 73d101a125SMiklos Szeredi real = ovl_dentry_upper(dentry); 74d101a125SMiklos Szeredi if (real && (!inode || inode == d_inode(real))) 75d101a125SMiklos Szeredi return real; 76d101a125SMiklos Szeredi 77d101a125SMiklos Szeredi real = ovl_dentry_lower(dentry); 78d101a125SMiklos Szeredi if (!real) 79d101a125SMiklos Szeredi goto bug; 80d101a125SMiklos Szeredi 81c4fcfc16SMiklos Szeredi /* Handle recursion */ 82c4fcfc16SMiklos Szeredi real = d_real(real, inode, open_flags); 83c4fcfc16SMiklos Szeredi 84d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 85d101a125SMiklos Szeredi return real; 86d101a125SMiklos Szeredi bug: 87656189d2SMiklos Szeredi WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry, 88d101a125SMiklos Szeredi inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0); 89d101a125SMiklos Szeredi return dentry; 90d101a125SMiklos Szeredi } 91d101a125SMiklos Szeredi 927c03b5d4SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 937c03b5d4SMiklos Szeredi { 947c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 957c03b5d4SMiklos Szeredi unsigned int i; 967c03b5d4SMiklos Szeredi int ret = 1; 977c03b5d4SMiklos Szeredi 987c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 997c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1007c03b5d4SMiklos Szeredi 1017c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_REVALIDATE) { 1027c03b5d4SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 1037c03b5d4SMiklos Szeredi if (ret < 0) 1047c03b5d4SMiklos Szeredi return ret; 1057c03b5d4SMiklos Szeredi if (!ret) { 1067c03b5d4SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 1077c03b5d4SMiklos Szeredi d_invalidate(d); 1087c03b5d4SMiklos Szeredi return -ESTALE; 1097c03b5d4SMiklos Szeredi } 1107c03b5d4SMiklos Szeredi } 1117c03b5d4SMiklos Szeredi } 1127c03b5d4SMiklos Szeredi return 1; 1137c03b5d4SMiklos Szeredi } 1147c03b5d4SMiklos Szeredi 1157c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 1167c03b5d4SMiklos Szeredi { 1177c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 1187c03b5d4SMiklos Szeredi unsigned int i; 1197c03b5d4SMiklos Szeredi int ret = 1; 1207c03b5d4SMiklos Szeredi 1217c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 1227c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 1237c03b5d4SMiklos Szeredi 1247c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) { 1257c03b5d4SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 1267c03b5d4SMiklos Szeredi if (ret <= 0) 1277c03b5d4SMiklos Szeredi break; 1287c03b5d4SMiklos Szeredi } 1297c03b5d4SMiklos Szeredi } 1307c03b5d4SMiklos Szeredi return ret; 1317c03b5d4SMiklos Szeredi } 1327c03b5d4SMiklos Szeredi 133e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 134e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 135d101a125SMiklos Szeredi .d_real = ovl_d_real, 136e9be9d5eSMiklos Szeredi }; 137e9be9d5eSMiklos Szeredi 1387c03b5d4SMiklos Szeredi static const struct dentry_operations ovl_reval_dentry_operations = { 1397c03b5d4SMiklos Szeredi .d_release = ovl_dentry_release, 140d101a125SMiklos Szeredi .d_real = ovl_d_real, 1417c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1427c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1437c03b5d4SMiklos Szeredi }; 1447c03b5d4SMiklos Szeredi 145e9be9d5eSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 146e9be9d5eSMiklos Szeredi { 147e9be9d5eSMiklos Szeredi struct ovl_fs *ufs = sb->s_fs_info; 148dd662667SMiklos Szeredi unsigned i; 149e9be9d5eSMiklos Szeredi 150e9be9d5eSMiklos Szeredi dput(ufs->workdir); 151e9be9d5eSMiklos Szeredi mntput(ufs->upper_mnt); 152dd662667SMiklos Szeredi for (i = 0; i < ufs->numlower; i++) 153dd662667SMiklos Szeredi mntput(ufs->lower_mnt[i]); 1545ffdbe8bSKonstantin Khlebnikov kfree(ufs->lower_mnt); 155e9be9d5eSMiklos Szeredi 156f45827e8SErez Zadok kfree(ufs->config.lowerdir); 157f45827e8SErez Zadok kfree(ufs->config.upperdir); 158f45827e8SErez Zadok kfree(ufs->config.workdir); 1593fe6e52fSAntonio Murdaca put_cred(ufs->creator_cred); 160e9be9d5eSMiklos Szeredi kfree(ufs); 161e9be9d5eSMiklos Szeredi } 162e9be9d5eSMiklos Szeredi 163e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 164e593b2bfSAmir Goldstein { 165e593b2bfSAmir Goldstein struct ovl_fs *ufs = sb->s_fs_info; 166e593b2bfSAmir Goldstein struct super_block *upper_sb; 167e593b2bfSAmir Goldstein int ret; 168e593b2bfSAmir Goldstein 169e593b2bfSAmir Goldstein if (!ufs->upper_mnt) 170e593b2bfSAmir Goldstein return 0; 171e593b2bfSAmir Goldstein upper_sb = ufs->upper_mnt->mnt_sb; 172e593b2bfSAmir Goldstein if (!upper_sb->s_op->sync_fs) 173e593b2bfSAmir Goldstein return 0; 174e593b2bfSAmir Goldstein 175e593b2bfSAmir Goldstein /* real inodes have already been synced by sync_filesystem(ovl_sb) */ 176e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 177e593b2bfSAmir Goldstein ret = upper_sb->s_op->sync_fs(upper_sb, wait); 178e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 179e593b2bfSAmir Goldstein return ret; 180e593b2bfSAmir Goldstein } 181e593b2bfSAmir Goldstein 182cc259639SAndy Whitcroft /** 183cc259639SAndy Whitcroft * ovl_statfs 184cc259639SAndy Whitcroft * @sb: The overlayfs super block 185cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 186cc259639SAndy Whitcroft * 187cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 1884ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 189cc259639SAndy Whitcroft */ 190cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 191cc259639SAndy Whitcroft { 192cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 193cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 194cc259639SAndy Whitcroft struct path path; 195cc259639SAndy Whitcroft int err; 196cc259639SAndy Whitcroft 1974ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 198cc259639SAndy Whitcroft 199cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 200cc259639SAndy Whitcroft if (!err) { 2016b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 202cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 203cc259639SAndy Whitcroft } 204cc259639SAndy Whitcroft 205cc259639SAndy Whitcroft return err; 206cc259639SAndy Whitcroft } 207cc259639SAndy Whitcroft 208f45827e8SErez Zadok /** 209f45827e8SErez Zadok * ovl_show_options 210f45827e8SErez Zadok * 211f45827e8SErez Zadok * Prints the mount options for a given superblock. 212f45827e8SErez Zadok * Returns zero; does not fail. 213f45827e8SErez Zadok */ 214f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 215f45827e8SErez Zadok { 216f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 217f45827e8SErez Zadok struct ovl_fs *ufs = sb->s_fs_info; 218f45827e8SErez Zadok 219a068acf2SKees Cook seq_show_option(m, "lowerdir", ufs->config.lowerdir); 22053a08cb9SMiklos Szeredi if (ufs->config.upperdir) { 221a068acf2SKees Cook seq_show_option(m, "upperdir", ufs->config.upperdir); 222a068acf2SKees Cook seq_show_option(m, "workdir", ufs->config.workdir); 22353a08cb9SMiklos Szeredi } 2248d3095f4SMiklos Szeredi if (ufs->config.default_permissions) 2258d3095f4SMiklos Szeredi seq_puts(m, ",default_permissions"); 226c5bef3a7SAmir Goldstein if (ufs->config.redirect_dir != ovl_redirect_dir_def) 227c5bef3a7SAmir Goldstein seq_printf(m, ",redirect_dir=%s", 228c5bef3a7SAmir Goldstein ufs->config.redirect_dir ? "on" : "off"); 229f45827e8SErez Zadok return 0; 230f45827e8SErez Zadok } 231f45827e8SErez Zadok 2323cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 2333cdf6fe9SSeunghun Lee { 2343cdf6fe9SSeunghun Lee struct ovl_fs *ufs = sb->s_fs_info; 2353cdf6fe9SSeunghun Lee 236cc6f67bcSMiklos Szeredi if (!(*flags & MS_RDONLY) && (!ufs->upper_mnt || !ufs->workdir)) 2373cdf6fe9SSeunghun Lee return -EROFS; 2383cdf6fe9SSeunghun Lee 2393cdf6fe9SSeunghun Lee return 0; 2403cdf6fe9SSeunghun Lee } 2413cdf6fe9SSeunghun Lee 242e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 243e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 244e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 245cc259639SAndy Whitcroft .statfs = ovl_statfs, 246f45827e8SErez Zadok .show_options = ovl_show_options, 2473cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 248eead4f2dSMiklos Szeredi .drop_inode = generic_delete_inode, 249e9be9d5eSMiklos Szeredi }; 250e9be9d5eSMiklos Szeredi 251e9be9d5eSMiklos Szeredi enum { 252e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 253e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 254e9be9d5eSMiklos Szeredi OPT_WORKDIR, 2558d3095f4SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 256a6c60655SMiklos Szeredi OPT_REDIRECT_DIR_ON, 257a6c60655SMiklos Szeredi OPT_REDIRECT_DIR_OFF, 258e9be9d5eSMiklos Szeredi OPT_ERR, 259e9be9d5eSMiklos Szeredi }; 260e9be9d5eSMiklos Szeredi 261e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 262e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 263e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 264e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 2658d3095f4SMiklos Szeredi {OPT_DEFAULT_PERMISSIONS, "default_permissions"}, 266a6c60655SMiklos Szeredi {OPT_REDIRECT_DIR_ON, "redirect_dir=on"}, 267a6c60655SMiklos Szeredi {OPT_REDIRECT_DIR_OFF, "redirect_dir=off"}, 268e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 269e9be9d5eSMiklos Szeredi }; 270e9be9d5eSMiklos Szeredi 27191c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 27291c77947SMiklos Szeredi { 27391c77947SMiklos Szeredi char *sbegin = *s; 27491c77947SMiklos Szeredi char *p; 27591c77947SMiklos Szeredi 27691c77947SMiklos Szeredi if (sbegin == NULL) 27791c77947SMiklos Szeredi return NULL; 27891c77947SMiklos Szeredi 27991c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 28091c77947SMiklos Szeredi if (*p == '\\') { 28191c77947SMiklos Szeredi p++; 28291c77947SMiklos Szeredi if (!*p) 28391c77947SMiklos Szeredi break; 28491c77947SMiklos Szeredi } else if (*p == ',') { 28591c77947SMiklos Szeredi *p = '\0'; 28691c77947SMiklos Szeredi *s = p + 1; 28791c77947SMiklos Szeredi return sbegin; 28891c77947SMiklos Szeredi } 28991c77947SMiklos Szeredi } 29091c77947SMiklos Szeredi *s = NULL; 29191c77947SMiklos Szeredi return sbegin; 29291c77947SMiklos Szeredi } 29391c77947SMiklos Szeredi 294e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 295e9be9d5eSMiklos Szeredi { 296e9be9d5eSMiklos Szeredi char *p; 297e9be9d5eSMiklos Szeredi 29891c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 299e9be9d5eSMiklos Szeredi int token; 300e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 301e9be9d5eSMiklos Szeredi 302e9be9d5eSMiklos Szeredi if (!*p) 303e9be9d5eSMiklos Szeredi continue; 304e9be9d5eSMiklos Szeredi 305e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 306e9be9d5eSMiklos Szeredi switch (token) { 307e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 308e9be9d5eSMiklos Szeredi kfree(config->upperdir); 309e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 310e9be9d5eSMiklos Szeredi if (!config->upperdir) 311e9be9d5eSMiklos Szeredi return -ENOMEM; 312e9be9d5eSMiklos Szeredi break; 313e9be9d5eSMiklos Szeredi 314e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 315e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 316e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 317e9be9d5eSMiklos Szeredi if (!config->lowerdir) 318e9be9d5eSMiklos Szeredi return -ENOMEM; 319e9be9d5eSMiklos Szeredi break; 320e9be9d5eSMiklos Szeredi 321e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 322e9be9d5eSMiklos Szeredi kfree(config->workdir); 323e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 324e9be9d5eSMiklos Szeredi if (!config->workdir) 325e9be9d5eSMiklos Szeredi return -ENOMEM; 326e9be9d5eSMiklos Szeredi break; 327e9be9d5eSMiklos Szeredi 3288d3095f4SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 3298d3095f4SMiklos Szeredi config->default_permissions = true; 3308d3095f4SMiklos Szeredi break; 3318d3095f4SMiklos Szeredi 332a6c60655SMiklos Szeredi case OPT_REDIRECT_DIR_ON: 333a6c60655SMiklos Szeredi config->redirect_dir = true; 334a6c60655SMiklos Szeredi break; 335a6c60655SMiklos Szeredi 336a6c60655SMiklos Szeredi case OPT_REDIRECT_DIR_OFF: 337a6c60655SMiklos Szeredi config->redirect_dir = false; 338a6c60655SMiklos Szeredi break; 339a6c60655SMiklos Szeredi 340e9be9d5eSMiklos Szeredi default: 341bead55efShujianyang pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p); 342e9be9d5eSMiklos Szeredi return -EINVAL; 343e9be9d5eSMiklos Szeredi } 344e9be9d5eSMiklos Szeredi } 34571cbad7eShujianyang 34671cbad7eShujianyang /* Workdir is useless in non-upper mount */ 34771cbad7eShujianyang if (!config->upperdir && config->workdir) { 34871cbad7eShujianyang pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 34971cbad7eShujianyang config->workdir); 35071cbad7eShujianyang kfree(config->workdir); 35171cbad7eShujianyang config->workdir = NULL; 35271cbad7eShujianyang } 35371cbad7eShujianyang 354e9be9d5eSMiklos Szeredi return 0; 355e9be9d5eSMiklos Szeredi } 356e9be9d5eSMiklos Szeredi 357e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 358e9be9d5eSMiklos Szeredi 359e9be9d5eSMiklos Szeredi static struct dentry *ovl_workdir_create(struct vfsmount *mnt, 360e9be9d5eSMiklos Szeredi struct dentry *dentry) 361e9be9d5eSMiklos Szeredi { 362e9be9d5eSMiklos Szeredi struct inode *dir = dentry->d_inode; 363e9be9d5eSMiklos Szeredi struct dentry *work; 364e9be9d5eSMiklos Szeredi int err; 365e9be9d5eSMiklos Szeredi bool retried = false; 366e9be9d5eSMiklos Szeredi 367e9be9d5eSMiklos Szeredi err = mnt_want_write(mnt); 368e9be9d5eSMiklos Szeredi if (err) 369e9be9d5eSMiklos Szeredi return ERR_PTR(err); 370e9be9d5eSMiklos Szeredi 3715955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 372e9be9d5eSMiklos Szeredi retry: 373e9be9d5eSMiklos Szeredi work = lookup_one_len(OVL_WORKDIR_NAME, dentry, 374e9be9d5eSMiklos Szeredi strlen(OVL_WORKDIR_NAME)); 375e9be9d5eSMiklos Szeredi 376e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 377c11b9fddSMiklos Szeredi struct iattr attr = { 378c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 37932a3d848SAl Viro .ia_mode = S_IFDIR | 0, 380c11b9fddSMiklos Szeredi }; 381e9be9d5eSMiklos Szeredi 382e9be9d5eSMiklos Szeredi if (work->d_inode) { 383e9be9d5eSMiklos Szeredi err = -EEXIST; 384e9be9d5eSMiklos Szeredi if (retried) 385e9be9d5eSMiklos Szeredi goto out_dput; 386e9be9d5eSMiklos Szeredi 387e9be9d5eSMiklos Szeredi retried = true; 388eea2fb48SMiklos Szeredi ovl_workdir_cleanup(dir, mnt, work, 0); 389e9be9d5eSMiklos Szeredi dput(work); 390e9be9d5eSMiklos Szeredi goto retry; 391e9be9d5eSMiklos Szeredi } 392e9be9d5eSMiklos Szeredi 39332a3d848SAl Viro err = ovl_create_real(dir, work, 39432a3d848SAl Viro &(struct cattr){.mode = S_IFDIR | 0}, 39532a3d848SAl Viro NULL, true); 396e9be9d5eSMiklos Szeredi if (err) 397e9be9d5eSMiklos Szeredi goto out_dput; 398c11b9fddSMiklos Szeredi 399cb348edbSMiklos Szeredi /* 400cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 401cb348edbSMiklos Szeredi * 402cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 403cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 404cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 405cb348edbSMiklos Szeredi * 406cb348edbSMiklos Szeredi * There are various other error values that could effectively 407cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 408cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 409cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 410cb348edbSMiklos Szeredi * for the above two errors is sufficient. 411cb348edbSMiklos Szeredi */ 412c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT); 413e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 414c11b9fddSMiklos Szeredi goto out_dput; 415c11b9fddSMiklos Szeredi 416c11b9fddSMiklos Szeredi err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS); 417e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 418c11b9fddSMiklos Szeredi goto out_dput; 419c11b9fddSMiklos Szeredi 420c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 421c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 422c11b9fddSMiklos Szeredi err = notify_change(work, &attr, NULL); 423c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 424c11b9fddSMiklos Szeredi if (err) 425c11b9fddSMiklos Szeredi goto out_dput; 426e9be9d5eSMiklos Szeredi } 427e9be9d5eSMiklos Szeredi out_unlock: 4285955102cSAl Viro inode_unlock(dir); 429e9be9d5eSMiklos Szeredi mnt_drop_write(mnt); 430e9be9d5eSMiklos Szeredi 431e9be9d5eSMiklos Szeredi return work; 432e9be9d5eSMiklos Szeredi 433e9be9d5eSMiklos Szeredi out_dput: 434e9be9d5eSMiklos Szeredi dput(work); 435e9be9d5eSMiklos Szeredi work = ERR_PTR(err); 436e9be9d5eSMiklos Szeredi goto out_unlock; 437e9be9d5eSMiklos Szeredi } 438e9be9d5eSMiklos Szeredi 43991c77947SMiklos Szeredi static void ovl_unescape(char *s) 44091c77947SMiklos Szeredi { 44191c77947SMiklos Szeredi char *d = s; 44291c77947SMiklos Szeredi 44391c77947SMiklos Szeredi for (;; s++, d++) { 44491c77947SMiklos Szeredi if (*s == '\\') 44591c77947SMiklos Szeredi s++; 44691c77947SMiklos Szeredi *d = *s; 44791c77947SMiklos Szeredi if (!*s) 44891c77947SMiklos Szeredi break; 44991c77947SMiklos Szeredi } 45091c77947SMiklos Szeredi } 45191c77947SMiklos Szeredi 452ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 453ab508822SMiklos Szeredi { 454a78d9f0dSMiklos Szeredi int err = -EINVAL; 455ab508822SMiklos Szeredi 456a78d9f0dSMiklos Szeredi if (!*name) { 457a78d9f0dSMiklos Szeredi pr_err("overlayfs: empty lowerdir\n"); 458a78d9f0dSMiklos Szeredi goto out; 459a78d9f0dSMiklos Szeredi } 460ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 461ab508822SMiklos Szeredi if (err) { 462ab508822SMiklos Szeredi pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); 463ab508822SMiklos Szeredi goto out; 464ab508822SMiklos Szeredi } 465ab508822SMiklos Szeredi err = -EINVAL; 4667c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 467ab508822SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported\n", name); 468ab508822SMiklos Szeredi goto out_put; 469ab508822SMiklos Szeredi } 4702b8c30e9SMiklos Szeredi if (!d_is_dir(path->dentry)) { 471ab508822SMiklos Szeredi pr_err("overlayfs: '%s' not a directory\n", name); 472ab508822SMiklos Szeredi goto out_put; 473ab508822SMiklos Szeredi } 474ab508822SMiklos Szeredi return 0; 475ab508822SMiklos Szeredi 476ab508822SMiklos Szeredi out_put: 477ab508822SMiklos Szeredi path_put(path); 478ab508822SMiklos Szeredi out: 479ab508822SMiklos Szeredi return err; 480ab508822SMiklos Szeredi } 481ab508822SMiklos Szeredi 482ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 483ab508822SMiklos Szeredi { 484ab508822SMiklos Szeredi int err = -ENOMEM; 485ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 486ab508822SMiklos Szeredi 487ab508822SMiklos Szeredi if (tmp) { 488ab508822SMiklos Szeredi ovl_unescape(tmp); 489ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 4907c03b5d4SMiklos Szeredi 4917c03b5d4SMiklos Szeredi if (!err) 4927c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) { 4937c03b5d4SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n", 4947c03b5d4SMiklos Szeredi tmp); 4957c03b5d4SMiklos Szeredi path_put(path); 4967c03b5d4SMiklos Szeredi err = -EINVAL; 4977c03b5d4SMiklos Szeredi } 498ab508822SMiklos Szeredi kfree(tmp); 499ab508822SMiklos Szeredi } 500ab508822SMiklos Szeredi return err; 501ab508822SMiklos Szeredi } 502ab508822SMiklos Szeredi 5036b2d5fe4SMiklos Szeredi static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs, 5046b2d5fe4SMiklos Szeredi const char *name) 5056b2d5fe4SMiklos Szeredi { 5066b2d5fe4SMiklos Szeredi struct kstatfs statfs; 5076b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 5086b2d5fe4SMiklos Szeredi 5096b2d5fe4SMiklos Szeredi if (err) 5106b2d5fe4SMiklos Szeredi pr_err("overlayfs: statfs failed on '%s'\n", name); 5116b2d5fe4SMiklos Szeredi else 5126b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 5136b2d5fe4SMiklos Szeredi 5146b2d5fe4SMiklos Szeredi return err; 5156b2d5fe4SMiklos Szeredi } 5166b2d5fe4SMiklos Szeredi 5176b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 5186b2d5fe4SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth, bool *remote) 519ab508822SMiklos Szeredi { 520ab508822SMiklos Szeredi int err; 521ab508822SMiklos Szeredi 522a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 523ab508822SMiklos Szeredi if (err) 524ab508822SMiklos Szeredi goto out; 525ab508822SMiklos Szeredi 5266b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 5276b2d5fe4SMiklos Szeredi if (err) 528ab508822SMiklos Szeredi goto out_put; 5296b2d5fe4SMiklos Szeredi 530ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 531ab508822SMiklos Szeredi 5327c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) 5337c03b5d4SMiklos Szeredi *remote = true; 5347c03b5d4SMiklos Szeredi 535ab508822SMiklos Szeredi return 0; 536ab508822SMiklos Szeredi 537ab508822SMiklos Szeredi out_put: 538ab508822SMiklos Szeredi path_put(path); 539ab508822SMiklos Szeredi out: 540ab508822SMiklos Szeredi return err; 541ab508822SMiklos Szeredi } 542ab508822SMiklos Szeredi 543e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 544e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 545e9be9d5eSMiklos Szeredi { 546e9be9d5eSMiklos Szeredi bool ok = false; 547e9be9d5eSMiklos Szeredi 548e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 549e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 550e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 551e9be9d5eSMiklos Szeredi } 552e9be9d5eSMiklos Szeredi return ok; 553e9be9d5eSMiklos Szeredi } 554e9be9d5eSMiklos Szeredi 555a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 556a78d9f0dSMiklos Szeredi { 557a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 558a78d9f0dSMiklos Szeredi char *s, *d; 559a78d9f0dSMiklos Szeredi 560a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 561a78d9f0dSMiklos Szeredi if (*s == '\\') { 562a78d9f0dSMiklos Szeredi s++; 563a78d9f0dSMiklos Szeredi } else if (*s == ':') { 564a78d9f0dSMiklos Szeredi *d = '\0'; 565a78d9f0dSMiklos Szeredi ctr++; 566a78d9f0dSMiklos Szeredi continue; 567a78d9f0dSMiklos Szeredi } 568a78d9f0dSMiklos Szeredi *d = *s; 569a78d9f0dSMiklos Szeredi if (!*s) 570a78d9f0dSMiklos Szeredi break; 571a78d9f0dSMiklos Szeredi } 572a78d9f0dSMiklos Szeredi return ctr; 573a78d9f0dSMiklos Szeredi } 574a78d9f0dSMiklos Szeredi 5750c97be22SAndreas Gruenbacher static int __maybe_unused 5760eb45fc3SAndreas Gruenbacher ovl_posix_acl_xattr_get(const struct xattr_handler *handler, 5770eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 5780eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 5790eb45fc3SAndreas Gruenbacher { 5800eb45fc3SAndreas Gruenbacher return ovl_xattr_get(dentry, handler->name, buffer, size); 5810eb45fc3SAndreas Gruenbacher } 5820eb45fc3SAndreas Gruenbacher 5830eb45fc3SAndreas Gruenbacher static int __maybe_unused 5840c97be22SAndreas Gruenbacher ovl_posix_acl_xattr_set(const struct xattr_handler *handler, 585d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 586d837a49bSMiklos Szeredi const char *name, const void *value, 587d837a49bSMiklos Szeredi size_t size, int flags) 588d837a49bSMiklos Szeredi { 589d837a49bSMiklos Szeredi struct dentry *workdir = ovl_workdir(dentry); 590d837a49bSMiklos Szeredi struct inode *realinode = ovl_inode_real(inode, NULL); 591d837a49bSMiklos Szeredi struct posix_acl *acl = NULL; 592d837a49bSMiklos Szeredi int err; 593d837a49bSMiklos Szeredi 594d837a49bSMiklos Szeredi /* Check that everything is OK before copy-up */ 595d837a49bSMiklos Szeredi if (value) { 596d837a49bSMiklos Szeredi acl = posix_acl_from_xattr(&init_user_ns, value, size); 597d837a49bSMiklos Szeredi if (IS_ERR(acl)) 598d837a49bSMiklos Szeredi return PTR_ERR(acl); 599d837a49bSMiklos Szeredi } 600d837a49bSMiklos Szeredi err = -EOPNOTSUPP; 601d837a49bSMiklos Szeredi if (!IS_POSIXACL(d_inode(workdir))) 602d837a49bSMiklos Szeredi goto out_acl_release; 603d837a49bSMiklos Szeredi if (!realinode->i_op->set_acl) 604d837a49bSMiklos Szeredi goto out_acl_release; 605d837a49bSMiklos Szeredi if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) { 606d837a49bSMiklos Szeredi err = acl ? -EACCES : 0; 607d837a49bSMiklos Szeredi goto out_acl_release; 608d837a49bSMiklos Szeredi } 609d837a49bSMiklos Szeredi err = -EPERM; 610d837a49bSMiklos Szeredi if (!inode_owner_or_capable(inode)) 611d837a49bSMiklos Szeredi goto out_acl_release; 612d837a49bSMiklos Szeredi 613d837a49bSMiklos Szeredi posix_acl_release(acl); 614d837a49bSMiklos Szeredi 615fd3220d3SMiklos Szeredi /* 616fd3220d3SMiklos Szeredi * Check if sgid bit needs to be cleared (actual setacl operation will 617fd3220d3SMiklos Szeredi * be done with mounter's capabilities and so that won't do it for us). 618fd3220d3SMiklos Szeredi */ 619fd3220d3SMiklos Szeredi if (unlikely(inode->i_mode & S_ISGID) && 620fd3220d3SMiklos Szeredi handler->flags == ACL_TYPE_ACCESS && 621fd3220d3SMiklos Szeredi !in_group_p(inode->i_gid) && 622fd3220d3SMiklos Szeredi !capable_wrt_inode_uidgid(inode, CAP_FSETID)) { 623fd3220d3SMiklos Szeredi struct iattr iattr = { .ia_valid = ATTR_KILL_SGID }; 624fd3220d3SMiklos Szeredi 625fd3220d3SMiklos Szeredi err = ovl_setattr(dentry, &iattr); 626fd3220d3SMiklos Szeredi if (err) 627fd3220d3SMiklos Szeredi return err; 628fd3220d3SMiklos Szeredi } 629fd3220d3SMiklos Szeredi 630ce31513aSMiklos Szeredi err = ovl_xattr_set(dentry, handler->name, value, size, flags); 631ce31513aSMiklos Szeredi if (!err) 632ce31513aSMiklos Szeredi ovl_copyattr(ovl_inode_real(inode, NULL), inode); 633ce31513aSMiklos Szeredi 634ce31513aSMiklos Szeredi return err; 635d837a49bSMiklos Szeredi 636d837a49bSMiklos Szeredi out_acl_release: 637d837a49bSMiklos Szeredi posix_acl_release(acl); 638d837a49bSMiklos Szeredi return err; 639d837a49bSMiklos Szeredi } 640d837a49bSMiklos Szeredi 6410eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 6420eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 6430eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 6440eb45fc3SAndreas Gruenbacher { 64548fab5d7SAmir Goldstein return -EOPNOTSUPP; 6460eb45fc3SAndreas Gruenbacher } 6470eb45fc3SAndreas Gruenbacher 648d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 649d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 650d837a49bSMiklos Szeredi const char *name, const void *value, 651d837a49bSMiklos Szeredi size_t size, int flags) 652d837a49bSMiklos Szeredi { 65348fab5d7SAmir Goldstein return -EOPNOTSUPP; 654d837a49bSMiklos Szeredi } 655d837a49bSMiklos Szeredi 6560eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 6570eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 6580eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 6590eb45fc3SAndreas Gruenbacher { 6600eb45fc3SAndreas Gruenbacher return ovl_xattr_get(dentry, name, buffer, size); 6610eb45fc3SAndreas Gruenbacher } 6620eb45fc3SAndreas Gruenbacher 6630e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 6640e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 6650e585cccSAndreas Gruenbacher const char *name, const void *value, 6660e585cccSAndreas Gruenbacher size_t size, int flags) 6670e585cccSAndreas Gruenbacher { 6680e585cccSAndreas Gruenbacher return ovl_xattr_set(dentry, name, value, size, flags); 6690e585cccSAndreas Gruenbacher } 6700e585cccSAndreas Gruenbacher 6710c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 6720c97be22SAndreas Gruenbacher ovl_posix_acl_access_xattr_handler = { 673d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_ACCESS, 674d837a49bSMiklos Szeredi .flags = ACL_TYPE_ACCESS, 6750eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 676d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 677d837a49bSMiklos Szeredi }; 678d837a49bSMiklos Szeredi 6790c97be22SAndreas Gruenbacher static const struct xattr_handler __maybe_unused 6800c97be22SAndreas Gruenbacher ovl_posix_acl_default_xattr_handler = { 681d837a49bSMiklos Szeredi .name = XATTR_NAME_POSIX_ACL_DEFAULT, 682d837a49bSMiklos Szeredi .flags = ACL_TYPE_DEFAULT, 6830eb45fc3SAndreas Gruenbacher .get = ovl_posix_acl_xattr_get, 684d837a49bSMiklos Szeredi .set = ovl_posix_acl_xattr_set, 685d837a49bSMiklos Szeredi }; 686d837a49bSMiklos Szeredi 687d837a49bSMiklos Szeredi static const struct xattr_handler ovl_own_xattr_handler = { 688d837a49bSMiklos Szeredi .prefix = OVL_XATTR_PREFIX, 6890eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 690d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 691d837a49bSMiklos Szeredi }; 692d837a49bSMiklos Szeredi 693d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 694d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 6950eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 696d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 697d837a49bSMiklos Szeredi }; 698d837a49bSMiklos Szeredi 699d837a49bSMiklos Szeredi static const struct xattr_handler *ovl_xattr_handlers[] = { 7000c97be22SAndreas Gruenbacher #ifdef CONFIG_FS_POSIX_ACL 701d837a49bSMiklos Szeredi &ovl_posix_acl_access_xattr_handler, 702d837a49bSMiklos Szeredi &ovl_posix_acl_default_xattr_handler, 7030c97be22SAndreas Gruenbacher #endif 704d837a49bSMiklos Szeredi &ovl_own_xattr_handler, 705d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 706d837a49bSMiklos Szeredi NULL 707d837a49bSMiklos Szeredi }; 708d837a49bSMiklos Szeredi 709e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 710e9be9d5eSMiklos Szeredi { 71153a08cb9SMiklos Szeredi struct path upperpath = { NULL, NULL }; 71253a08cb9SMiklos Szeredi struct path workpath = { NULL, NULL }; 713e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 71439b681f8SMiklos Szeredi struct inode *realinode; 715e9be9d5eSMiklos Szeredi struct ovl_entry *oe; 716e9be9d5eSMiklos Szeredi struct ovl_fs *ufs; 717a78d9f0dSMiklos Szeredi struct path *stack = NULL; 718a78d9f0dSMiklos Szeredi char *lowertmp; 719a78d9f0dSMiklos Szeredi char *lower; 720a78d9f0dSMiklos Szeredi unsigned int numlower; 721a78d9f0dSMiklos Szeredi unsigned int stacklen = 0; 722dd662667SMiklos Szeredi unsigned int i; 7237c03b5d4SMiklos Szeredi bool remote = false; 72451f8f3c4SKonstantin Khlebnikov struct cred *cred; 725e9be9d5eSMiklos Szeredi int err; 726e9be9d5eSMiklos Szeredi 727f45827e8SErez Zadok err = -ENOMEM; 728f45827e8SErez Zadok ufs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 729f45827e8SErez Zadok if (!ufs) 730e9be9d5eSMiklos Szeredi goto out; 731e9be9d5eSMiklos Szeredi 73239d3d60aSAmir Goldstein init_waitqueue_head(&ufs->copyup_wq); 733688ea0e5SMiklos Szeredi ufs->config.redirect_dir = ovl_redirect_dir_def; 734f45827e8SErez Zadok err = ovl_parse_opt((char *) data, &ufs->config); 735f45827e8SErez Zadok if (err) 736f45827e8SErez Zadok goto out_free_config; 737f45827e8SErez Zadok 738e9be9d5eSMiklos Szeredi err = -EINVAL; 73953a08cb9SMiklos Szeredi if (!ufs->config.lowerdir) { 74007f2af7bSKonstantin Khlebnikov if (!silent) 74153a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'lowerdir'\n"); 74253a08cb9SMiklos Szeredi goto out_free_config; 74353a08cb9SMiklos Szeredi } 74453a08cb9SMiklos Szeredi 74553a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 746cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 74753a08cb9SMiklos Szeredi if (ufs->config.upperdir) { 74853a08cb9SMiklos Szeredi if (!ufs->config.workdir) { 74953a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'workdir'\n"); 750e9be9d5eSMiklos Szeredi goto out_free_config; 751e9be9d5eSMiklos Szeredi } 752e9be9d5eSMiklos Szeredi 753f45827e8SErez Zadok err = ovl_mount_dir(ufs->config.upperdir, &upperpath); 754e9be9d5eSMiklos Szeredi if (err) 7553b7a9a24SMiklos Szeredi goto out_free_config; 756e9be9d5eSMiklos Szeredi 75771cbad7eShujianyang /* Upper fs should not be r/o */ 75871cbad7eShujianyang if (upperpath.mnt->mnt_sb->s_flags & MS_RDONLY) { 75971cbad7eShujianyang pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n"); 76071cbad7eShujianyang err = -EINVAL; 76171cbad7eShujianyang goto out_put_upperpath; 76271cbad7eShujianyang } 76371cbad7eShujianyang 7646b2d5fe4SMiklos Szeredi err = ovl_check_namelen(&upperpath, ufs, ufs->config.upperdir); 7656b2d5fe4SMiklos Szeredi if (err) 7666b2d5fe4SMiklos Szeredi goto out_put_upperpath; 7676b2d5fe4SMiklos Szeredi 768f45827e8SErez Zadok err = ovl_mount_dir(ufs->config.workdir, &workpath); 769e9be9d5eSMiklos Szeredi if (err) 7703b7a9a24SMiklos Szeredi goto out_put_upperpath; 7713b7a9a24SMiklos Szeredi 7722f83fd8cShujianyang err = -EINVAL; 773ab508822SMiklos Szeredi if (upperpath.mnt != workpath.mnt) { 774ab508822SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 775ab508822SMiklos Szeredi goto out_put_workpath; 776ab508822SMiklos Szeredi } 777ab508822SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath.dentry)) { 778ab508822SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 779ab508822SMiklos Szeredi goto out_put_workpath; 780ab508822SMiklos Szeredi } 781ab508822SMiklos Szeredi sb->s_stack_depth = upperpath.mnt->mnt_sb->s_stack_depth; 78253a08cb9SMiklos Szeredi } 783a78d9f0dSMiklos Szeredi err = -ENOMEM; 784a78d9f0dSMiklos Szeredi lowertmp = kstrdup(ufs->config.lowerdir, GFP_KERNEL); 785a78d9f0dSMiklos Szeredi if (!lowertmp) 786a78d9f0dSMiklos Szeredi goto out_put_workpath; 787ab508822SMiklos Szeredi 788a78d9f0dSMiklos Szeredi err = -EINVAL; 789a78d9f0dSMiklos Szeredi stacklen = ovl_split_lowerdirs(lowertmp); 7906be4506eShujianyang if (stacklen > OVL_MAX_STACK) { 791fd36570aSColin Ian King pr_err("overlayfs: too many lower directories, limit is %d\n", 7926be4506eShujianyang OVL_MAX_STACK); 793a78d9f0dSMiklos Szeredi goto out_free_lowertmp; 7946be4506eShujianyang } else if (!ufs->config.upperdir && stacklen == 1) { 7956be4506eShujianyang pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n"); 7966be4506eShujianyang goto out_free_lowertmp; 7976be4506eShujianyang } 798a78d9f0dSMiklos Szeredi 799313684c4SGeliang Tang err = -ENOMEM; 800a78d9f0dSMiklos Szeredi stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL); 801a78d9f0dSMiklos Szeredi if (!stack) 802a78d9f0dSMiklos Szeredi goto out_free_lowertmp; 803a78d9f0dSMiklos Szeredi 804313684c4SGeliang Tang err = -EINVAL; 805a78d9f0dSMiklos Szeredi lower = lowertmp; 806a78d9f0dSMiklos Szeredi for (numlower = 0; numlower < stacklen; numlower++) { 8076b2d5fe4SMiklos Szeredi err = ovl_lower_dir(lower, &stack[numlower], ufs, 8086b2d5fe4SMiklos Szeredi &sb->s_stack_depth, &remote); 8093b7a9a24SMiklos Szeredi if (err) 810a78d9f0dSMiklos Szeredi goto out_put_lowerpath; 811a78d9f0dSMiklos Szeredi 812a78d9f0dSMiklos Szeredi lower = strchr(lower, '\0') + 1; 813a78d9f0dSMiklos Szeredi } 814e9be9d5eSMiklos Szeredi 815e9be9d5eSMiklos Szeredi err = -EINVAL; 816ab508822SMiklos Szeredi sb->s_stack_depth++; 81769c433edSMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 81869c433edSMiklos Szeredi pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 8193b7a9a24SMiklos Szeredi goto out_put_lowerpath; 82069c433edSMiklos Szeredi } 82169c433edSMiklos Szeredi 82253a08cb9SMiklos Szeredi if (ufs->config.upperdir) { 823e9be9d5eSMiklos Szeredi ufs->upper_mnt = clone_private_mount(&upperpath); 824e9be9d5eSMiklos Szeredi err = PTR_ERR(ufs->upper_mnt); 825e9be9d5eSMiklos Szeredi if (IS_ERR(ufs->upper_mnt)) { 826e9be9d5eSMiklos Szeredi pr_err("overlayfs: failed to clone upperpath\n"); 8273b7a9a24SMiklos Szeredi goto out_put_lowerpath; 8283b7a9a24SMiklos Szeredi } 829d719e8f2SMiklos Szeredi /* Don't inherit atime flags */ 830d719e8f2SMiklos Szeredi ufs->upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 831d719e8f2SMiklos Szeredi 832d719e8f2SMiklos Szeredi sb->s_time_gran = ufs->upper_mnt->mnt_sb->s_time_gran; 8333b7a9a24SMiklos Szeredi 8343b7a9a24SMiklos Szeredi ufs->workdir = ovl_workdir_create(ufs->upper_mnt, workpath.dentry); 8353b7a9a24SMiklos Szeredi err = PTR_ERR(ufs->workdir); 8363b7a9a24SMiklos Szeredi if (IS_ERR(ufs->workdir)) { 837cc6f67bcSMiklos Szeredi pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n", 838cc6f67bcSMiklos Szeredi ufs->config.workdir, OVL_WORKDIR_NAME, -err); 839cc6f67bcSMiklos Szeredi sb->s_flags |= MS_RDONLY; 840cc6f67bcSMiklos Szeredi ufs->workdir = NULL; 841e9be9d5eSMiklos Szeredi } 84245aebeafSVivek Goyal 84345aebeafSVivek Goyal /* 84445aebeafSVivek Goyal * Upper should support d_type, else whiteouts are visible. 84545aebeafSVivek Goyal * Given workdir and upper are on same fs, we can do 84621765194SVivek Goyal * iterate_dir() on workdir. This check requires successful 84721765194SVivek Goyal * creation of workdir in previous step. 84845aebeafSVivek Goyal */ 84921765194SVivek Goyal if (ufs->workdir) { 850e7f52429SAmir Goldstein struct dentry *temp; 851e7f52429SAmir Goldstein 85245aebeafSVivek Goyal err = ovl_check_d_type_supported(&workpath); 85345aebeafSVivek Goyal if (err < 0) 85445aebeafSVivek Goyal goto out_put_workdir; 85545aebeafSVivek Goyal 856e7c0b599SVivek Goyal /* 857e7c0b599SVivek Goyal * We allowed this configuration and don't want to 858e7c0b599SVivek Goyal * break users over kernel upgrade. So warn instead 859e7c0b599SVivek Goyal * of erroring out. 860e7c0b599SVivek Goyal */ 861e7c0b599SVivek Goyal if (!err) 862e7c0b599SVivek Goyal pr_warn("overlayfs: upper fs needs to support d_type.\n"); 863e7f52429SAmir Goldstein 864e7f52429SAmir Goldstein /* Check if upper/work fs supports O_TMPFILE */ 865e7f52429SAmir Goldstein temp = ovl_do_tmpfile(ufs->workdir, S_IFREG | 0); 866e7f52429SAmir Goldstein ufs->tmpfile = !IS_ERR(temp); 867e7f52429SAmir Goldstein if (ufs->tmpfile) 868e7f52429SAmir Goldstein dput(temp); 869e7f52429SAmir Goldstein else 870e7f52429SAmir Goldstein pr_warn("overlayfs: upper fs does not support tmpfile.\n"); 87153a08cb9SMiklos Szeredi } 87221765194SVivek Goyal } 873e9be9d5eSMiklos Szeredi 8742f83fd8cShujianyang err = -ENOMEM; 875a78d9f0dSMiklos Szeredi ufs->lower_mnt = kcalloc(numlower, sizeof(struct vfsmount *), GFP_KERNEL); 876dd662667SMiklos Szeredi if (ufs->lower_mnt == NULL) 8773b7a9a24SMiklos Szeredi goto out_put_workdir; 878a78d9f0dSMiklos Szeredi for (i = 0; i < numlower; i++) { 879a78d9f0dSMiklos Szeredi struct vfsmount *mnt = clone_private_mount(&stack[i]); 880dd662667SMiklos Szeredi 8812f83fd8cShujianyang err = PTR_ERR(mnt); 882dd662667SMiklos Szeredi if (IS_ERR(mnt)) { 883dd662667SMiklos Szeredi pr_err("overlayfs: failed to clone lowerpath\n"); 884dd662667SMiklos Szeredi goto out_put_lower_mnt; 885e9be9d5eSMiklos Szeredi } 886dd662667SMiklos Szeredi /* 887dd662667SMiklos Szeredi * Make lower_mnt R/O. That way fchmod/fchown on lower file 888dd662667SMiklos Szeredi * will fail instead of modifying lower fs. 889dd662667SMiklos Szeredi */ 890d719e8f2SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 891dd662667SMiklos Szeredi 892a78d9f0dSMiklos Szeredi ufs->lower_mnt[ufs->numlower] = mnt; 893a78d9f0dSMiklos Szeredi ufs->numlower++; 894a78d9f0dSMiklos Szeredi } 895e9be9d5eSMiklos Szeredi 89671cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 89771cbad7eShujianyang if (!ufs->upper_mnt) 898e9be9d5eSMiklos Szeredi sb->s_flags |= MS_RDONLY; 899e9be9d5eSMiklos Szeredi 9007c03b5d4SMiklos Szeredi if (remote) 9017c03b5d4SMiklos Szeredi sb->s_d_op = &ovl_reval_dentry_operations; 9027c03b5d4SMiklos Szeredi else 903e9be9d5eSMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 904e9be9d5eSMiklos Szeredi 90551f8f3c4SKonstantin Khlebnikov ufs->creator_cred = cred = prepare_creds(); 90651f8f3c4SKonstantin Khlebnikov if (!cred) 9073fe6e52fSAntonio Murdaca goto out_put_lower_mnt; 9083fe6e52fSAntonio Murdaca 90951f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 91051f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 91151f8f3c4SKonstantin Khlebnikov 912e9be9d5eSMiklos Szeredi err = -ENOMEM; 913a78d9f0dSMiklos Szeredi oe = ovl_alloc_entry(numlower); 9143b7a9a24SMiklos Szeredi if (!oe) 9153fe6e52fSAntonio Murdaca goto out_put_cred; 916e9be9d5eSMiklos Szeredi 917655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 918655042ccSVivek Goyal sb->s_op = &ovl_super_operations; 919655042ccSVivek Goyal sb->s_xattr = ovl_xattr_handlers; 920655042ccSVivek Goyal sb->s_fs_info = ufs; 921655042ccSVivek Goyal sb->s_flags |= MS_POSIXACL | MS_NOREMOTELOCK; 922655042ccSVivek Goyal 923ca4c8a3aSMiklos Szeredi root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 924e9be9d5eSMiklos Szeredi if (!root_dentry) 9253b7a9a24SMiklos Szeredi goto out_free_oe; 926e9be9d5eSMiklos Szeredi 927e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 928a78d9f0dSMiklos Szeredi for (i = 0; i < numlower; i++) 929a78d9f0dSMiklos Szeredi mntput(stack[i].mnt); 930e9be9d5eSMiklos Szeredi path_put(&workpath); 931a78d9f0dSMiklos Szeredi kfree(lowertmp); 932e9be9d5eSMiklos Szeredi 933e9be9d5eSMiklos Szeredi oe->__upperdentry = upperpath.dentry; 934a78d9f0dSMiklos Szeredi for (i = 0; i < numlower; i++) { 935a78d9f0dSMiklos Szeredi oe->lowerstack[i].dentry = stack[i].dentry; 936a78d9f0dSMiklos Szeredi oe->lowerstack[i].mnt = ufs->lower_mnt[i]; 937a78d9f0dSMiklos Szeredi } 9380f95502aSKonstantin Khlebnikov kfree(stack); 939e9be9d5eSMiklos Szeredi 940e9be9d5eSMiklos Szeredi root_dentry->d_fsdata = oe; 941e9be9d5eSMiklos Szeredi 94239b681f8SMiklos Szeredi realinode = d_inode(ovl_dentry_real(root_dentry)); 94339b681f8SMiklos Szeredi ovl_inode_init(d_inode(root_dentry), realinode, !!upperpath.dentry); 94439b681f8SMiklos Szeredi ovl_copyattr(realinode, d_inode(root_dentry)); 945ed06e069SMiklos Szeredi 946e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 947e9be9d5eSMiklos Szeredi 948e9be9d5eSMiklos Szeredi return 0; 949e9be9d5eSMiklos Szeredi 9503b7a9a24SMiklos Szeredi out_free_oe: 9513b7a9a24SMiklos Szeredi kfree(oe); 9523fe6e52fSAntonio Murdaca out_put_cred: 9533fe6e52fSAntonio Murdaca put_cred(ufs->creator_cred); 954e9be9d5eSMiklos Szeredi out_put_lower_mnt: 955dd662667SMiklos Szeredi for (i = 0; i < ufs->numlower; i++) 956dd662667SMiklos Szeredi mntput(ufs->lower_mnt[i]); 957dd662667SMiklos Szeredi kfree(ufs->lower_mnt); 9583b7a9a24SMiklos Szeredi out_put_workdir: 9593b7a9a24SMiklos Szeredi dput(ufs->workdir); 960e9be9d5eSMiklos Szeredi mntput(ufs->upper_mnt); 961e9be9d5eSMiklos Szeredi out_put_lowerpath: 962a78d9f0dSMiklos Szeredi for (i = 0; i < numlower; i++) 963a78d9f0dSMiklos Szeredi path_put(&stack[i]); 964a78d9f0dSMiklos Szeredi kfree(stack); 965a78d9f0dSMiklos Szeredi out_free_lowertmp: 966a78d9f0dSMiklos Szeredi kfree(lowertmp); 9673b7a9a24SMiklos Szeredi out_put_workpath: 9683b7a9a24SMiklos Szeredi path_put(&workpath); 969e9be9d5eSMiklos Szeredi out_put_upperpath: 970e9be9d5eSMiklos Szeredi path_put(&upperpath); 971e9be9d5eSMiklos Szeredi out_free_config: 972f45827e8SErez Zadok kfree(ufs->config.lowerdir); 973f45827e8SErez Zadok kfree(ufs->config.upperdir); 974f45827e8SErez Zadok kfree(ufs->config.workdir); 975f45827e8SErez Zadok kfree(ufs); 976e9be9d5eSMiklos Szeredi out: 977e9be9d5eSMiklos Szeredi return err; 978e9be9d5eSMiklos Szeredi } 979e9be9d5eSMiklos Szeredi 980e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 981e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 982e9be9d5eSMiklos Szeredi { 983e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 984e9be9d5eSMiklos Szeredi } 985e9be9d5eSMiklos Szeredi 986e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 987e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 988ef94b186SMiklos Szeredi .name = "overlay", 989e9be9d5eSMiklos Szeredi .mount = ovl_mount, 990e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 991e9be9d5eSMiklos Szeredi }; 992ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 993e9be9d5eSMiklos Szeredi 994e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 995e9be9d5eSMiklos Szeredi { 996e9be9d5eSMiklos Szeredi return register_filesystem(&ovl_fs_type); 997e9be9d5eSMiklos Szeredi } 998e9be9d5eSMiklos Szeredi 999e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1000e9be9d5eSMiklos Szeredi { 1001e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 1002e9be9d5eSMiklos Szeredi } 1003e9be9d5eSMiklos Szeredi 1004e9be9d5eSMiklos Szeredi module_init(ovl_init); 1005e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1006