1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2e9be9d5eSMiklos Szeredi /* 3e9be9d5eSMiklos Szeredi * 4e9be9d5eSMiklos Szeredi * Copyright (C) 2011 Novell Inc. 5e9be9d5eSMiklos Szeredi */ 6e9be9d5eSMiklos Szeredi 75b825c3aSIngo Molnar #include <uapi/linux/magic.h> 8e9be9d5eSMiklos Szeredi #include <linux/fs.h> 9e9be9d5eSMiklos Szeredi #include <linux/namei.h> 10e9be9d5eSMiklos Szeredi #include <linux/xattr.h> 11e9be9d5eSMiklos Szeredi #include <linux/mount.h> 12e9be9d5eSMiklos Szeredi #include <linux/parser.h> 13e9be9d5eSMiklos Szeredi #include <linux/module.h> 14cc259639SAndy Whitcroft #include <linux/statfs.h> 15f45827e8SErez Zadok #include <linux/seq_file.h> 16d837a49bSMiklos Szeredi #include <linux/posix_acl_xattr.h> 17e487d889SAmir Goldstein #include <linux/exportfs.h> 182b1a7746SMiklos Szeredi #include <linux/file.h> 191784fbc2SChristian Brauner #include <linux/fs_context.h> 20dcb399deSAmir Goldstein #include <linux/fs_parser.h> 21e9be9d5eSMiklos Szeredi #include "overlayfs.h" 227fb7998bSChristian Brauner #include "params.h" 23e9be9d5eSMiklos Szeredi 24e9be9d5eSMiklos Szeredi MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 25e9be9d5eSMiklos Szeredi MODULE_DESCRIPTION("Overlay filesystem"); 26e9be9d5eSMiklos Szeredi MODULE_LICENSE("GPL"); 27e9be9d5eSMiklos Szeredi 28e9be9d5eSMiklos Szeredi 29e9be9d5eSMiklos Szeredi struct ovl_dir_cache; 30e9be9d5eSMiklos Szeredi 312d902671SMiklos Szeredi static struct dentry *ovl_d_real(struct dentry *dentry, 32fb16043bSMiklos Szeredi const struct inode *inode) 33d101a125SMiklos Szeredi { 34cef4cbffSMiklos Szeredi struct dentry *real = NULL, *lower; 35184996e9SAlexander Larsson int err; 36d101a125SMiklos Szeredi 37e8c985baSMiklos Szeredi /* It's an overlay file */ 38e8c985baSMiklos Szeredi if (inode && d_inode(dentry) == inode) 39e8c985baSMiklos Szeredi return dentry; 40e8c985baSMiklos Szeredi 41ca4c8a3aSMiklos Szeredi if (!d_is_reg(dentry)) { 42d101a125SMiklos Szeredi if (!inode || inode == d_inode(dentry)) 43d101a125SMiklos Szeredi return dentry; 44d101a125SMiklos Szeredi goto bug; 45d101a125SMiklos Szeredi } 46d101a125SMiklos Szeredi 47d101a125SMiklos Szeredi real = ovl_dentry_upper(dentry); 482c3d7358SVivek Goyal if (real && (inode == d_inode(real))) 49d101a125SMiklos Szeredi return real; 50d101a125SMiklos Szeredi 512c3d7358SVivek Goyal if (real && !inode && ovl_has_upperdata(d_inode(dentry))) 522c3d7358SVivek Goyal return real; 532c3d7358SVivek Goyal 5441665644SAmir Goldstein /* 5542dd69aeSAmir Goldstein * Best effort lazy lookup of lowerdata for !inode case to return 5641665644SAmir Goldstein * the real lowerdata dentry. The only current caller of d_real() with 5741665644SAmir Goldstein * NULL inode is d_real_inode() from trace_uprobe and this caller is 5841665644SAmir Goldstein * likely going to be followed reading from the file, before placing 5941665644SAmir Goldstein * uprobes on offset within the file, so lowerdata should be available 6041665644SAmir Goldstein * when setting the uprobe. 6141665644SAmir Goldstein */ 62184996e9SAlexander Larsson err = ovl_verify_lowerdata(dentry); 63184996e9SAlexander Larsson if (err) 64184996e9SAlexander Larsson goto bug; 65cef4cbffSMiklos Szeredi lower = ovl_dentry_lowerdata(dentry); 66cef4cbffSMiklos Szeredi if (!lower) 67d101a125SMiklos Szeredi goto bug; 68cef4cbffSMiklos Szeredi real = lower; 69d101a125SMiklos Szeredi 70c4fcfc16SMiklos Szeredi /* Handle recursion */ 71fb16043bSMiklos Szeredi real = d_real(real, inode); 72c4fcfc16SMiklos Szeredi 73d101a125SMiklos Szeredi if (!inode || inode == d_inode(real)) 74d101a125SMiklos Szeredi return real; 75d101a125SMiklos Szeredi bug: 76cef4cbffSMiklos Szeredi WARN(1, "%s(%pd4, %s:%lu): real dentry (%p/%lu) not found\n", 77cef4cbffSMiklos Szeredi __func__, dentry, inode ? inode->i_sb->s_id : "NULL", 78cef4cbffSMiklos Szeredi inode ? inode->i_ino : 0, real, 79cef4cbffSMiklos Szeredi real && d_inode(real) ? d_inode(real)->i_ino : 0); 80d101a125SMiklos Szeredi return dentry; 81d101a125SMiklos Szeredi } 82d101a125SMiklos Szeredi 833bb7df92SMiklos Szeredi static int ovl_revalidate_real(struct dentry *d, unsigned int flags, bool weak) 843bb7df92SMiklos Szeredi { 853bb7df92SMiklos Szeredi int ret = 1; 863bb7df92SMiklos Szeredi 8741665644SAmir Goldstein if (!d) 8841665644SAmir Goldstein return 1; 8941665644SAmir Goldstein 903bb7df92SMiklos Szeredi if (weak) { 913bb7df92SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) 923bb7df92SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 933bb7df92SMiklos Szeredi } else if (d->d_flags & DCACHE_OP_REVALIDATE) { 943bb7df92SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 953bb7df92SMiklos Szeredi if (!ret) { 963bb7df92SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 973bb7df92SMiklos Szeredi d_invalidate(d); 983bb7df92SMiklos Szeredi ret = -ESTALE; 993bb7df92SMiklos Szeredi } 1003bb7df92SMiklos Szeredi } 1013bb7df92SMiklos Szeredi return ret; 1023bb7df92SMiklos Szeredi } 1033bb7df92SMiklos Szeredi 1043bb7df92SMiklos Szeredi static int ovl_dentry_revalidate_common(struct dentry *dentry, 1053bb7df92SMiklos Szeredi unsigned int flags, bool weak) 1067c03b5d4SMiklos Szeredi { 107a6ff2bc0SAmir Goldstein struct ovl_entry *oe = OVL_E(dentry); 1085522c9c7SAmir Goldstein struct ovl_path *lowerstack = ovl_lowerstack(oe); 109672e4268SChen Zhongjin struct inode *inode = d_inode_rcu(dentry); 110bccece1eSMiklos Szeredi struct dentry *upper; 1117c03b5d4SMiklos Szeredi unsigned int i; 1127c03b5d4SMiklos Szeredi int ret = 1; 1137c03b5d4SMiklos Szeredi 114672e4268SChen Zhongjin /* Careful in RCU mode */ 115672e4268SChen Zhongjin if (!inode) 116672e4268SChen Zhongjin return -ECHILD; 117672e4268SChen Zhongjin 118672e4268SChen Zhongjin upper = ovl_i_dentry_upper(inode); 119bccece1eSMiklos Szeredi if (upper) 120bccece1eSMiklos Szeredi ret = ovl_revalidate_real(upper, flags, weak); 121bccece1eSMiklos Szeredi 1225522c9c7SAmir Goldstein for (i = 0; ret > 0 && i < ovl_numlower(oe); i++) 1235522c9c7SAmir Goldstein ret = ovl_revalidate_real(lowerstack[i].dentry, flags, weak); 1245522c9c7SAmir Goldstein 1257c03b5d4SMiklos Szeredi return ret; 1267c03b5d4SMiklos Szeredi } 1273bb7df92SMiklos Szeredi 1283bb7df92SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 1293bb7df92SMiklos Szeredi { 1303bb7df92SMiklos Szeredi return ovl_dentry_revalidate_common(dentry, flags, false); 1317c03b5d4SMiklos Szeredi } 1327c03b5d4SMiklos Szeredi 1337c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 1347c03b5d4SMiklos Szeredi { 1353bb7df92SMiklos Szeredi return ovl_dentry_revalidate_common(dentry, flags, true); 1367c03b5d4SMiklos Szeredi } 1377c03b5d4SMiklos Szeredi 138e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 139d101a125SMiklos Szeredi .d_real = ovl_d_real, 1407c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 1417c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 1427c03b5d4SMiklos Szeredi }; 1437c03b5d4SMiklos Szeredi 14413cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep; 14513cf199dSAmir Goldstein 14613cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb) 14713cf199dSAmir Goldstein { 148fd60b288SMuchun Song struct ovl_inode *oi = alloc_inode_sb(sb, ovl_inode_cachep, GFP_KERNEL); 14913cf199dSAmir Goldstein 150b3885bd6SHirofumi Nakagawa if (!oi) 151b3885bd6SHirofumi Nakagawa return NULL; 152b3885bd6SHirofumi Nakagawa 15304a01ac7SMiklos Szeredi oi->cache = NULL; 154cf31c463SMiklos Szeredi oi->redirect = NULL; 15504a01ac7SMiklos Szeredi oi->version = 0; 15613c72075SMiklos Szeredi oi->flags = 0; 15709d8b586SMiklos Szeredi oi->__upperdentry = NULL; 1582b21da92SAmir Goldstein oi->lowerdata_redirect = NULL; 1590af950f5SAmir Goldstein oi->oe = NULL; 160a015dafcSAmir Goldstein mutex_init(&oi->lock); 16125b7713aSMiklos Szeredi 16213cf199dSAmir Goldstein return &oi->vfs_inode; 16313cf199dSAmir Goldstein } 16413cf199dSAmir Goldstein 1650b269dedSAl Viro static void ovl_free_inode(struct inode *inode) 16613cf199dSAmir Goldstein { 1670b269dedSAl Viro struct ovl_inode *oi = OVL_I(inode); 16813cf199dSAmir Goldstein 1690b269dedSAl Viro kfree(oi->redirect); 170*d9e8319aSAl Viro kfree(oi->oe); 1710b269dedSAl Viro mutex_destroy(&oi->lock); 1720b269dedSAl Viro kmem_cache_free(ovl_inode_cachep, oi); 17313cf199dSAmir Goldstein } 17413cf199dSAmir Goldstein 17513cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 17613cf199dSAmir Goldstein { 17709d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 17809d8b586SMiklos Szeredi 17909d8b586SMiklos Szeredi dput(oi->__upperdentry); 180*d9e8319aSAl Viro ovl_stack_put(ovl_lowerstack(oi->oe), ovl_numlower(oi->oe)); 1812664bd08SVivek Goyal if (S_ISDIR(inode->i_mode)) 1824edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 1832b21da92SAmir Goldstein else 1842b21da92SAmir Goldstein kfree(oi->lowerdata_redirect); 18513cf199dSAmir Goldstein } 18613cf199dSAmir Goldstein 187a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 188a9075cdbSMiklos Szeredi { 189f01d0889SAndrea Righi struct ovl_fs *ofs = OVL_FS(sb); 190a9075cdbSMiklos Szeredi 1911784fbc2SChristian Brauner if (ofs) 192a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 193a9075cdbSMiklos Szeredi } 194a9075cdbSMiklos Szeredi 195e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */ 196e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 197e593b2bfSAmir Goldstein { 198f01d0889SAndrea Righi struct ovl_fs *ofs = OVL_FS(sb); 199e593b2bfSAmir Goldstein struct super_block *upper_sb; 200e593b2bfSAmir Goldstein int ret; 201e593b2bfSAmir Goldstein 202335d3fc5SSargun Dhillon ret = ovl_sync_status(ofs); 203335d3fc5SSargun Dhillon /* 204335d3fc5SSargun Dhillon * We have to always set the err, because the return value isn't 205335d3fc5SSargun Dhillon * checked in syncfs, and instead indirectly return an error via 206335d3fc5SSargun Dhillon * the sb's writeback errseq, which VFS inspects after this call. 207335d3fc5SSargun Dhillon */ 208335d3fc5SSargun Dhillon if (ret < 0) { 209335d3fc5SSargun Dhillon errseq_set(&sb->s_wb_err, -EIO); 210335d3fc5SSargun Dhillon return -EIO; 211335d3fc5SSargun Dhillon } 212e8d4bfe3SChengguang Xu 213335d3fc5SSargun Dhillon if (!ret) 214335d3fc5SSargun Dhillon return ret; 215335d3fc5SSargun Dhillon 216e8d4bfe3SChengguang Xu /* 21732b1924bSKonstantin Khlebnikov * Not called for sync(2) call or an emergency sync (SB_I_SKIP_SYNC). 21832b1924bSKonstantin Khlebnikov * All the super blocks will be iterated, including upper_sb. 219e8d4bfe3SChengguang Xu * 220e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call 221e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being 222e8d4bfe3SChengguang Xu * called with wait == 1. 223e8d4bfe3SChengguang Xu */ 224e8d4bfe3SChengguang Xu if (!wait) 225e593b2bfSAmir Goldstein return 0; 226e593b2bfSAmir Goldstein 22708f4c7c8SMiklos Szeredi upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 228e8d4bfe3SChengguang Xu 229e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 230e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb); 231e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 232e8d4bfe3SChengguang Xu 233e593b2bfSAmir Goldstein return ret; 234e593b2bfSAmir Goldstein } 235e593b2bfSAmir Goldstein 236cc259639SAndy Whitcroft /** 237cc259639SAndy Whitcroft * ovl_statfs 2389c5dd803SYang Li * @dentry: The dentry to query 239cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 240cc259639SAndy Whitcroft * 241cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 2424ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 243cc259639SAndy Whitcroft */ 244cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 245cc259639SAndy Whitcroft { 246b0504bfeSAmir Goldstein struct super_block *sb = dentry->d_sb; 247b0504bfeSAmir Goldstein struct ovl_fs *ofs = OVL_FS(sb); 248b0504bfeSAmir Goldstein struct dentry *root_dentry = sb->s_root; 249cc259639SAndy Whitcroft struct path path; 250cc259639SAndy Whitcroft int err; 251cc259639SAndy Whitcroft 2524ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 253cc259639SAndy Whitcroft 254cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 255cc259639SAndy Whitcroft if (!err) { 2566b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 257cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 258b0504bfeSAmir Goldstein if (ovl_has_fsid(ofs)) 259b0504bfeSAmir Goldstein buf->f_fsid = uuid_to_fsid(sb->s_uuid.b); 260cc259639SAndy Whitcroft } 261cc259639SAndy Whitcroft 262cc259639SAndy Whitcroft return err; 263cc259639SAndy Whitcroft } 264cc259639SAndy Whitcroft 265e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 26613cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 2670b269dedSAl Viro .free_inode = ovl_free_inode, 26813cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 26913cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 270e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 271e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 272cc259639SAndy Whitcroft .statfs = ovl_statfs, 273f45827e8SErez Zadok .show_options = ovl_show_options, 274e9be9d5eSMiklos Szeredi }; 275e9be9d5eSMiklos Szeredi 276e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 27702bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 278e9be9d5eSMiklos Szeredi 279ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 2806b8aa129SAmir Goldstein const char *name, bool persist) 281e9be9d5eSMiklos Szeredi { 282ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 28308f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 284e9be9d5eSMiklos Szeredi struct dentry *work; 285e9be9d5eSMiklos Szeredi int err; 286e9be9d5eSMiklos Szeredi bool retried = false; 287e9be9d5eSMiklos Szeredi 2885955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 289e9be9d5eSMiklos Szeredi retry: 29022f289ceSChristian Brauner work = ovl_lookup_upper(ofs, name, ofs->workbasedir, strlen(name)); 291e9be9d5eSMiklos Szeredi 292e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 293c11b9fddSMiklos Szeredi struct iattr attr = { 294c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 29532a3d848SAl Viro .ia_mode = S_IFDIR | 0, 296c11b9fddSMiklos Szeredi }; 297e9be9d5eSMiklos Szeredi 298e9be9d5eSMiklos Szeredi if (work->d_inode) { 299e9be9d5eSMiklos Szeredi err = -EEXIST; 300e9be9d5eSMiklos Szeredi if (retried) 301e9be9d5eSMiklos Szeredi goto out_dput; 302e9be9d5eSMiklos Szeredi 3036b8aa129SAmir Goldstein if (persist) 3046b8aa129SAmir Goldstein goto out_unlock; 3056b8aa129SAmir Goldstein 306e9be9d5eSMiklos Szeredi retried = true; 307576bb263SChristian Brauner err = ovl_workdir_cleanup(ofs, dir, mnt, work, 0); 308e9be9d5eSMiklos Szeredi dput(work); 309235ce9edSAmir Goldstein if (err == -EINVAL) { 310235ce9edSAmir Goldstein work = ERR_PTR(err); 311235ce9edSAmir Goldstein goto out_unlock; 312235ce9edSAmir Goldstein } 313e9be9d5eSMiklos Szeredi goto retry; 314e9be9d5eSMiklos Szeredi } 315e9be9d5eSMiklos Szeredi 316576bb263SChristian Brauner err = ovl_mkdir_real(ofs, dir, &work, attr.ia_mode); 3171f5573cfSMiklos Szeredi if (err) 3181f5573cfSMiklos Szeredi goto out_dput; 3191f5573cfSMiklos Szeredi 3201f5573cfSMiklos Szeredi /* Weird filesystem returning with hashed negative (kernfs)? */ 3211f5573cfSMiklos Szeredi err = -EINVAL; 3221f5573cfSMiklos Szeredi if (d_really_is_negative(work)) 3231f5573cfSMiklos Szeredi goto out_dput; 324c11b9fddSMiklos Szeredi 325cb348edbSMiklos Szeredi /* 326cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 327cb348edbSMiklos Szeredi * 328cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 329cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 330cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 331cb348edbSMiklos Szeredi * 332cb348edbSMiklos Szeredi * There are various other error values that could effectively 333cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 334cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 335cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 336cb348edbSMiklos Szeredi * for the above two errors is sufficient. 337cb348edbSMiklos Szeredi */ 33831acceb9SChristian Brauner err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_DEFAULT); 339e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 340c11b9fddSMiklos Szeredi goto out_dput; 341c11b9fddSMiklos Szeredi 34231acceb9SChristian Brauner err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_ACCESS); 343e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 344c11b9fddSMiklos Szeredi goto out_dput; 345c11b9fddSMiklos Szeredi 346c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 347c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 348a15506eaSChristian Brauner err = ovl_do_notify_change(ofs, work, &attr); 349c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 350c11b9fddSMiklos Szeredi if (err) 351c11b9fddSMiklos Szeredi goto out_dput; 3526b8aa129SAmir Goldstein } else { 3536b8aa129SAmir Goldstein err = PTR_ERR(work); 3546b8aa129SAmir Goldstein goto out_err; 355e9be9d5eSMiklos Szeredi } 356e9be9d5eSMiklos Szeredi out_unlock: 3576b8aa129SAmir Goldstein inode_unlock(dir); 358e9be9d5eSMiklos Szeredi return work; 359e9be9d5eSMiklos Szeredi 360e9be9d5eSMiklos Szeredi out_dput: 361e9be9d5eSMiklos Szeredi dput(work); 3626b8aa129SAmir Goldstein out_err: 3631bd0a3aeSlijiazi pr_warn("failed to create directory %s/%s (errno: %i); mounting read-only\n", 364ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 3656b8aa129SAmir Goldstein work = NULL; 366e9be9d5eSMiklos Szeredi goto out_unlock; 367e9be9d5eSMiklos Szeredi } 368e9be9d5eSMiklos Szeredi 3692d343087SAl Viro static int ovl_check_namelen(const struct path *path, struct ovl_fs *ofs, 3706b2d5fe4SMiklos Szeredi const char *name) 3716b2d5fe4SMiklos Szeredi { 3726b2d5fe4SMiklos Szeredi struct kstatfs statfs; 3736b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 3746b2d5fe4SMiklos Szeredi 3756b2d5fe4SMiklos Szeredi if (err) 3761bd0a3aeSlijiazi pr_err("statfs failed on '%s'\n", name); 3776b2d5fe4SMiklos Szeredi else 3786b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 3796b2d5fe4SMiklos Szeredi 3806b2d5fe4SMiklos Szeredi return err; 3816b2d5fe4SMiklos Szeredi } 3826b2d5fe4SMiklos Szeredi 3836b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 384f4288844SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth) 385ab508822SMiklos Szeredi { 386e487d889SAmir Goldstein int fh_type; 387ab508822SMiklos Szeredi int err; 388ab508822SMiklos Szeredi 3896b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 3906b2d5fe4SMiklos Szeredi if (err) 391b8e42a65SMiklos Szeredi return err; 3926b2d5fe4SMiklos Szeredi 393ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 394ab508822SMiklos Szeredi 39502bcd157SAmir Goldstein /* 396f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode 397f168f109SAmir Goldstein * file handles, so they require that all layers support them. 39802bcd157SAmir Goldstein */ 399e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(path->dentry->d_sb); 400f168f109SAmir Goldstein if ((ofs->config.nfs_export || 401e487d889SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 40202bcd157SAmir Goldstein ofs->config.index = false; 403f168f109SAmir Goldstein ofs->config.nfs_export = false; 4041bd0a3aeSlijiazi pr_warn("fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 405f168f109SAmir Goldstein name); 40602bcd157SAmir Goldstein } 40716aac5adSAmir Goldstein ofs->nofh |= !fh_type; 408b0e0f697SAmir Goldstein /* 409b0e0f697SAmir Goldstein * Decoding origin file handle is required for persistent st_ino. 410b0e0f697SAmir Goldstein * Without persistent st_ino, xino=auto falls back to xino=off. 411b0e0f697SAmir Goldstein */ 412b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO && 413b0e0f697SAmir Goldstein ofs->config.upperdir && !fh_type) { 414b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 415b0e0f697SAmir Goldstein pr_warn("fs on '%s' does not support file handles, falling back to xino=off.\n", 416b0e0f697SAmir Goldstein name); 417b0e0f697SAmir Goldstein } 41802bcd157SAmir Goldstein 419e487d889SAmir Goldstein /* Check if lower fs has 32bit inode numbers */ 420e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 4210f831ec8SAmir Goldstein ofs->xino_mode = -1; 422e487d889SAmir Goldstein 423ab508822SMiklos Szeredi return 0; 424ab508822SMiklos Szeredi } 425ab508822SMiklos Szeredi 426e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 427e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 428e9be9d5eSMiklos Szeredi { 429e9be9d5eSMiklos Szeredi bool ok = false; 430e9be9d5eSMiklos Szeredi 431e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 432e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 433e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 434e9be9d5eSMiklos Szeredi } 435e9be9d5eSMiklos Szeredi return ok; 436e9be9d5eSMiklos Szeredi } 437e9be9d5eSMiklos Szeredi 4380eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 4390eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 4400eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 4410eb45fc3SAndreas Gruenbacher { 44248fab5d7SAmir Goldstein return -EOPNOTSUPP; 4430eb45fc3SAndreas Gruenbacher } 4440eb45fc3SAndreas Gruenbacher 445d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 44639f60c1cSChristian Brauner struct mnt_idmap *idmap, 447d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 448d837a49bSMiklos Szeredi const char *name, const void *value, 449d837a49bSMiklos Szeredi size_t size, int flags) 450d837a49bSMiklos Szeredi { 45148fab5d7SAmir Goldstein return -EOPNOTSUPP; 452d837a49bSMiklos Szeredi } 453d837a49bSMiklos Szeredi 4540eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 4550eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 4560eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 4570eb45fc3SAndreas Gruenbacher { 4581d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 4590eb45fc3SAndreas Gruenbacher } 4600eb45fc3SAndreas Gruenbacher 4610e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 46239f60c1cSChristian Brauner struct mnt_idmap *idmap, 4630e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 4640e585cccSAndreas Gruenbacher const char *name, const void *value, 4650e585cccSAndreas Gruenbacher size_t size, int flags) 4660e585cccSAndreas Gruenbacher { 4671d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 4680e585cccSAndreas Gruenbacher } 4690e585cccSAndreas Gruenbacher 4702d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_trusted_xattr_handler = { 4712d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_TRUSTED_PREFIX, 4722d2f2d73SMiklos Szeredi .get = ovl_own_xattr_get, 4732d2f2d73SMiklos Szeredi .set = ovl_own_xattr_set, 4742d2f2d73SMiklos Szeredi }; 4752d2f2d73SMiklos Szeredi 4762d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_user_xattr_handler = { 4772d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_USER_PREFIX, 4780eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 479d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 480d837a49bSMiklos Szeredi }; 481d837a49bSMiklos Szeredi 482d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 483d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 4840eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 485d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 486d837a49bSMiklos Szeredi }; 487d837a49bSMiklos Szeredi 4882d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_trusted_xattr_handlers[] = { 4892d2f2d73SMiklos Szeredi &ovl_own_trusted_xattr_handler, 4902d2f2d73SMiklos Szeredi &ovl_other_xattr_handler, 4912d2f2d73SMiklos Szeredi NULL 4922d2f2d73SMiklos Szeredi }; 4932d2f2d73SMiklos Szeredi 4942d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_user_xattr_handlers[] = { 4952d2f2d73SMiklos Szeredi &ovl_own_user_xattr_handler, 496d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 497d837a49bSMiklos Szeredi NULL 498d837a49bSMiklos Szeredi }; 499d837a49bSMiklos Szeredi 500146d62e5SAmir Goldstein static int ovl_setup_trap(struct super_block *sb, struct dentry *dir, 501146d62e5SAmir Goldstein struct inode **ptrap, const char *name) 502146d62e5SAmir Goldstein { 503146d62e5SAmir Goldstein struct inode *trap; 504146d62e5SAmir Goldstein int err; 505146d62e5SAmir Goldstein 506146d62e5SAmir Goldstein trap = ovl_get_trap_inode(sb, dir); 5071dac6f5bSArnd Bergmann err = PTR_ERR_OR_ZERO(trap); 5081dac6f5bSArnd Bergmann if (err) { 509146d62e5SAmir Goldstein if (err == -ELOOP) 5101bd0a3aeSlijiazi pr_err("conflicting %s path\n", name); 511146d62e5SAmir Goldstein return err; 512146d62e5SAmir Goldstein } 513146d62e5SAmir Goldstein 514146d62e5SAmir Goldstein *ptrap = trap; 515146d62e5SAmir Goldstein return 0; 516146d62e5SAmir Goldstein } 517146d62e5SAmir Goldstein 5180be0bfd2SAmir Goldstein /* 5190be0bfd2SAmir Goldstein * Determine how we treat concurrent use of upperdir/workdir based on the 5200be0bfd2SAmir Goldstein * index feature. This is papering over mount leaks of container runtimes, 5210be0bfd2SAmir Goldstein * for example, an old overlay mount is leaked and now its upperdir is 5220be0bfd2SAmir Goldstein * attempted to be used as a lower layer in a new overlay mount. 5230be0bfd2SAmir Goldstein */ 5240be0bfd2SAmir Goldstein static int ovl_report_in_use(struct ovl_fs *ofs, const char *name) 5250be0bfd2SAmir Goldstein { 5260be0bfd2SAmir Goldstein if (ofs->config.index) { 5271bd0a3aeSlijiazi pr_err("%s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n", 5280be0bfd2SAmir Goldstein name); 5290be0bfd2SAmir Goldstein return -EBUSY; 5300be0bfd2SAmir Goldstein } else { 5311bd0a3aeSlijiazi pr_warn("%s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n", 5320be0bfd2SAmir Goldstein name); 5330be0bfd2SAmir Goldstein return 0; 5340be0bfd2SAmir Goldstein } 5350be0bfd2SAmir Goldstein } 5360be0bfd2SAmir Goldstein 537146d62e5SAmir Goldstein static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs, 538b36a5780SChristian Brauner struct ovl_layer *upper_layer, 539b36a5780SChristian Brauner const struct path *upperpath) 5406ee8acf0SMiklos Szeredi { 5415064975eSMiklos Szeredi struct vfsmount *upper_mnt; 5426ee8acf0SMiklos Szeredi int err; 5436ee8acf0SMiklos Szeredi 544e21a6c57SAmir Goldstein /* Upperdir path should not be r/o */ 545e21a6c57SAmir Goldstein if (__mnt_is_readonly(upperpath->mnt)) { 5461bd0a3aeSlijiazi pr_err("upper fs is r/o, try multi-lower layers mount\n"); 5476ee8acf0SMiklos Szeredi err = -EINVAL; 5486ee8acf0SMiklos Szeredi goto out; 5496ee8acf0SMiklos Szeredi } 5506ee8acf0SMiklos Szeredi 551ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 5526ee8acf0SMiklos Szeredi if (err) 5536ee8acf0SMiklos Szeredi goto out; 5546ee8acf0SMiklos Szeredi 555b8e42a65SMiklos Szeredi err = ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap, 556146d62e5SAmir Goldstein "upperdir"); 557146d62e5SAmir Goldstein if (err) 558146d62e5SAmir Goldstein goto out; 559146d62e5SAmir Goldstein 5605064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 5615064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 5625064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 5631bd0a3aeSlijiazi pr_err("failed to clone upperpath\n"); 5645064975eSMiklos Szeredi goto out; 5655064975eSMiklos Szeredi } 5665064975eSMiklos Szeredi 5675064975eSMiklos Szeredi /* Don't inherit atime flags */ 5685064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 569b8e42a65SMiklos Szeredi upper_layer->mnt = upper_mnt; 570b8e42a65SMiklos Szeredi upper_layer->idx = 0; 571b8e42a65SMiklos Szeredi upper_layer->fsid = 0; 5728c25741aSMiklos Szeredi 573b36a5780SChristian Brauner err = -ENOMEM; 574b36a5780SChristian Brauner upper_layer->name = kstrdup(ofs->config.upperdir, GFP_KERNEL); 575b36a5780SChristian Brauner if (!upper_layer->name) 576b36a5780SChristian Brauner goto out; 577b36a5780SChristian Brauner 578654255faSJeffle Xu /* 579654255faSJeffle Xu * Inherit SB_NOSEC flag from upperdir. 580654255faSJeffle Xu * 581654255faSJeffle Xu * This optimization changes behavior when a security related attribute 582654255faSJeffle Xu * (suid/sgid/security.*) is changed on an underlying layer. This is 583654255faSJeffle Xu * okay because we don't yet have guarantees in that case, but it will 584654255faSJeffle Xu * need careful treatment once we want to honour changes to underlying 585654255faSJeffle Xu * filesystems. 586654255faSJeffle Xu */ 587654255faSJeffle Xu if (upper_mnt->mnt_sb->s_flags & SB_NOSEC) 588654255faSJeffle Xu sb->s_flags |= SB_NOSEC; 589654255faSJeffle Xu 59008f4c7c8SMiklos Szeredi if (ovl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) { 5918c25741aSMiklos Szeredi ofs->upperdir_locked = true; 5928c25741aSMiklos Szeredi } else { 5930be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "upperdir"); 5940be0bfd2SAmir Goldstein if (err) 5950be0bfd2SAmir Goldstein goto out; 5968c25741aSMiklos Szeredi } 5978c25741aSMiklos Szeredi 5986ee8acf0SMiklos Szeredi err = 0; 5996ee8acf0SMiklos Szeredi out: 6006ee8acf0SMiklos Szeredi return err; 6016ee8acf0SMiklos Szeredi } 6026ee8acf0SMiklos Szeredi 603cad218abSAmir Goldstein /* 604cad218abSAmir Goldstein * Returns 1 if RENAME_WHITEOUT is supported, 0 if not supported and 605cad218abSAmir Goldstein * negative values if error is encountered. 606cad218abSAmir Goldstein */ 607576bb263SChristian Brauner static int ovl_check_rename_whiteout(struct ovl_fs *ofs) 608cad218abSAmir Goldstein { 609576bb263SChristian Brauner struct dentry *workdir = ofs->workdir; 610cad218abSAmir Goldstein struct inode *dir = d_inode(workdir); 611cad218abSAmir Goldstein struct dentry *temp; 612cad218abSAmir Goldstein struct dentry *dest; 613cad218abSAmir Goldstein struct dentry *whiteout; 614cad218abSAmir Goldstein struct name_snapshot name; 615cad218abSAmir Goldstein int err; 616cad218abSAmir Goldstein 617cad218abSAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 618cad218abSAmir Goldstein 619576bb263SChristian Brauner temp = ovl_create_temp(ofs, workdir, OVL_CATTR(S_IFREG | 0)); 620cad218abSAmir Goldstein err = PTR_ERR(temp); 621cad218abSAmir Goldstein if (IS_ERR(temp)) 622cad218abSAmir Goldstein goto out_unlock; 623cad218abSAmir Goldstein 624576bb263SChristian Brauner dest = ovl_lookup_temp(ofs, workdir); 625cad218abSAmir Goldstein err = PTR_ERR(dest); 626cad218abSAmir Goldstein if (IS_ERR(dest)) { 627cad218abSAmir Goldstein dput(temp); 628cad218abSAmir Goldstein goto out_unlock; 629cad218abSAmir Goldstein } 630cad218abSAmir Goldstein 631cad218abSAmir Goldstein /* Name is inline and stable - using snapshot as a copy helper */ 632cad218abSAmir Goldstein take_dentry_name_snapshot(&name, temp); 633576bb263SChristian Brauner err = ovl_do_rename(ofs, dir, temp, dir, dest, RENAME_WHITEOUT); 634cad218abSAmir Goldstein if (err) { 635cad218abSAmir Goldstein if (err == -EINVAL) 636cad218abSAmir Goldstein err = 0; 637cad218abSAmir Goldstein goto cleanup_temp; 638cad218abSAmir Goldstein } 639cad218abSAmir Goldstein 64022f289ceSChristian Brauner whiteout = ovl_lookup_upper(ofs, name.name.name, workdir, name.name.len); 641cad218abSAmir Goldstein err = PTR_ERR(whiteout); 642cad218abSAmir Goldstein if (IS_ERR(whiteout)) 643cad218abSAmir Goldstein goto cleanup_temp; 644cad218abSAmir Goldstein 645cad218abSAmir Goldstein err = ovl_is_whiteout(whiteout); 646cad218abSAmir Goldstein 647cad218abSAmir Goldstein /* Best effort cleanup of whiteout and temp file */ 648cad218abSAmir Goldstein if (err) 649576bb263SChristian Brauner ovl_cleanup(ofs, dir, whiteout); 650cad218abSAmir Goldstein dput(whiteout); 651cad218abSAmir Goldstein 652cad218abSAmir Goldstein cleanup_temp: 653576bb263SChristian Brauner ovl_cleanup(ofs, dir, temp); 654cad218abSAmir Goldstein release_dentry_name_snapshot(&name); 655cad218abSAmir Goldstein dput(temp); 656cad218abSAmir Goldstein dput(dest); 657cad218abSAmir Goldstein 658cad218abSAmir Goldstein out_unlock: 659cad218abSAmir Goldstein inode_unlock(dir); 660cad218abSAmir Goldstein 661cad218abSAmir Goldstein return err; 662cad218abSAmir Goldstein } 663cad218abSAmir Goldstein 664576bb263SChristian Brauner static struct dentry *ovl_lookup_or_create(struct ovl_fs *ofs, 665576bb263SChristian Brauner struct dentry *parent, 666c86243b0SVivek Goyal const char *name, umode_t mode) 667c86243b0SVivek Goyal { 668c86243b0SVivek Goyal size_t len = strlen(name); 669c86243b0SVivek Goyal struct dentry *child; 670c86243b0SVivek Goyal 671c86243b0SVivek Goyal inode_lock_nested(parent->d_inode, I_MUTEX_PARENT); 67222f289ceSChristian Brauner child = ovl_lookup_upper(ofs, name, parent, len); 673c86243b0SVivek Goyal if (!IS_ERR(child) && !child->d_inode) 674576bb263SChristian Brauner child = ovl_create_real(ofs, parent->d_inode, child, 675c86243b0SVivek Goyal OVL_CATTR(mode)); 676c86243b0SVivek Goyal inode_unlock(parent->d_inode); 677c86243b0SVivek Goyal dput(parent); 678c86243b0SVivek Goyal 679c86243b0SVivek Goyal return child; 680c86243b0SVivek Goyal } 681c86243b0SVivek Goyal 682c86243b0SVivek Goyal /* 683c86243b0SVivek Goyal * Creates $workdir/work/incompat/volatile/dirty file if it is not already 684c86243b0SVivek Goyal * present. 685c86243b0SVivek Goyal */ 686c86243b0SVivek Goyal static int ovl_create_volatile_dirty(struct ovl_fs *ofs) 687c86243b0SVivek Goyal { 688c86243b0SVivek Goyal unsigned int ctr; 689c86243b0SVivek Goyal struct dentry *d = dget(ofs->workbasedir); 690c86243b0SVivek Goyal static const char *const volatile_path[] = { 691c86243b0SVivek Goyal OVL_WORKDIR_NAME, "incompat", "volatile", "dirty" 692c86243b0SVivek Goyal }; 693c86243b0SVivek Goyal const char *const *name = volatile_path; 694c86243b0SVivek Goyal 695c86243b0SVivek Goyal for (ctr = ARRAY_SIZE(volatile_path); ctr; ctr--, name++) { 696576bb263SChristian Brauner d = ovl_lookup_or_create(ofs, d, *name, ctr > 1 ? S_IFDIR : S_IFREG); 697c86243b0SVivek Goyal if (IS_ERR(d)) 698c86243b0SVivek Goyal return PTR_ERR(d); 699c86243b0SVivek Goyal } 700c86243b0SVivek Goyal dput(d); 701c86243b0SVivek Goyal return 0; 702c86243b0SVivek Goyal } 703c86243b0SVivek Goyal 704146d62e5SAmir Goldstein static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs, 7052d343087SAl Viro const struct path *workpath) 7068ed61dc3SMiklos Szeredi { 70708f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 7082b1a7746SMiklos Szeredi struct dentry *workdir; 7092b1a7746SMiklos Szeredi struct file *tmpfile; 710d80172c2SAmir Goldstein bool rename_whiteout; 711d80172c2SAmir Goldstein bool d_type; 712e487d889SAmir Goldstein int fh_type; 7138ed61dc3SMiklos Szeredi int err; 7148ed61dc3SMiklos Szeredi 7152ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 7162ba9d57eSAmir Goldstein if (err) 7172ba9d57eSAmir Goldstein return err; 7182ba9d57eSAmir Goldstein 719235ce9edSAmir Goldstein workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 720235ce9edSAmir Goldstein err = PTR_ERR(workdir); 721235ce9edSAmir Goldstein if (IS_ERR_OR_NULL(workdir)) 7222ba9d57eSAmir Goldstein goto out; 7238ed61dc3SMiklos Szeredi 724235ce9edSAmir Goldstein ofs->workdir = workdir; 725235ce9edSAmir Goldstein 726146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir"); 727146d62e5SAmir Goldstein if (err) 728146d62e5SAmir Goldstein goto out; 729146d62e5SAmir Goldstein 7308ed61dc3SMiklos Szeredi /* 7318ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 7328ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 7338ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 7348ed61dc3SMiklos Szeredi * previous step. 7358ed61dc3SMiklos Szeredi */ 7368ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 7378ed61dc3SMiklos Szeredi if (err < 0) 7382ba9d57eSAmir Goldstein goto out; 7398ed61dc3SMiklos Szeredi 740d80172c2SAmir Goldstein d_type = err; 741d80172c2SAmir Goldstein if (!d_type) 7421bd0a3aeSlijiazi pr_warn("upper fs needs to support d_type.\n"); 7438ed61dc3SMiklos Szeredi 7448ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 7452b1a7746SMiklos Szeredi tmpfile = ovl_do_tmpfile(ofs, ofs->workdir, S_IFREG | 0); 7462b1a7746SMiklos Szeredi ofs->tmpfile = !IS_ERR(tmpfile); 747ad204488SMiklos Szeredi if (ofs->tmpfile) 7482b1a7746SMiklos Szeredi fput(tmpfile); 7498ed61dc3SMiklos Szeredi else 7501bd0a3aeSlijiazi pr_warn("upper fs does not support tmpfile.\n"); 7518ed61dc3SMiklos Szeredi 752cad218abSAmir Goldstein 753cad218abSAmir Goldstein /* Check if upper/work fs supports RENAME_WHITEOUT */ 754576bb263SChristian Brauner err = ovl_check_rename_whiteout(ofs); 755cad218abSAmir Goldstein if (err < 0) 756cad218abSAmir Goldstein goto out; 757cad218abSAmir Goldstein 758d80172c2SAmir Goldstein rename_whiteout = err; 759d80172c2SAmir Goldstein if (!rename_whiteout) 760cad218abSAmir Goldstein pr_warn("upper fs does not support RENAME_WHITEOUT.\n"); 761cad218abSAmir Goldstein 7628ed61dc3SMiklos Szeredi /* 7632d2f2d73SMiklos Szeredi * Check if upper/work fs supports (trusted|user).overlay.* xattr 7648ed61dc3SMiklos Szeredi */ 765c914c0e2SAmir Goldstein err = ovl_setxattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE, "0", 1); 7668ed61dc3SMiklos Szeredi if (err) { 767b10b85feSMiklos Szeredi pr_warn("failed to set xattr on upper\n"); 768ad204488SMiklos Szeredi ofs->noxattr = true; 769af5f2396SAmir Goldstein if (ovl_redirect_follow(ofs)) { 770af5f2396SAmir Goldstein ofs->config.redirect_mode = OVL_REDIRECT_NOFOLLOW; 771af5f2396SAmir Goldstein pr_warn("...falling back to redirect_dir=nofollow.\n"); 772af5f2396SAmir Goldstein } 773af5f2396SAmir Goldstein if (ofs->config.metacopy) { 774d5791044SVivek Goyal ofs->config.metacopy = false; 775af5f2396SAmir Goldstein pr_warn("...falling back to metacopy=off.\n"); 776af5f2396SAmir Goldstein } 777af5f2396SAmir Goldstein if (ofs->config.index) { 778af5f2396SAmir Goldstein ofs->config.index = false; 779af5f2396SAmir Goldstein pr_warn("...falling back to index=off.\n"); 780b0e0f697SAmir Goldstein } 781d9544c1bSAmir Goldstein if (ovl_has_fsid(ofs)) { 782d9544c1bSAmir Goldstein ofs->config.uuid = OVL_UUID_NULL; 783d9544c1bSAmir Goldstein pr_warn("...falling back to uuid=null.\n"); 784d9544c1bSAmir Goldstein } 785b0e0f697SAmir Goldstein /* 786b0e0f697SAmir Goldstein * xattr support is required for persistent st_ino. 787b0e0f697SAmir Goldstein * Without persistent st_ino, xino=auto falls back to xino=off. 788b0e0f697SAmir Goldstein */ 789b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO) { 790b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 791b10b85feSMiklos Szeredi pr_warn("...falling back to xino=off.\n"); 792b0e0f697SAmir Goldstein } 793b10b85feSMiklos Szeredi if (err == -EPERM && !ofs->config.userxattr) 794b10b85feSMiklos Szeredi pr_info("try mounting with 'userxattr' option\n"); 7952ba9d57eSAmir Goldstein err = 0; 7968ed61dc3SMiklos Szeredi } else { 797c914c0e2SAmir Goldstein ovl_removexattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE); 7988ed61dc3SMiklos Szeredi } 7998ed61dc3SMiklos Szeredi 800d80172c2SAmir Goldstein /* 801d80172c2SAmir Goldstein * We allowed sub-optimal upper fs configuration and don't want to break 802d80172c2SAmir Goldstein * users over kernel upgrade, but we never allowed remote upper fs, so 803d80172c2SAmir Goldstein * we can enforce strict requirements for remote upper fs. 804d80172c2SAmir Goldstein */ 805d80172c2SAmir Goldstein if (ovl_dentry_remote(ofs->workdir) && 806d80172c2SAmir Goldstein (!d_type || !rename_whiteout || ofs->noxattr)) { 807d80172c2SAmir Goldstein pr_err("upper fs missing required features.\n"); 808d80172c2SAmir Goldstein err = -EINVAL; 809d80172c2SAmir Goldstein goto out; 810d80172c2SAmir Goldstein } 811d80172c2SAmir Goldstein 812c86243b0SVivek Goyal /* 813c86243b0SVivek Goyal * For volatile mount, create a incompat/volatile/dirty file to keep 814c86243b0SVivek Goyal * track of it. 815c86243b0SVivek Goyal */ 816c86243b0SVivek Goyal if (ofs->config.ovl_volatile) { 817c86243b0SVivek Goyal err = ovl_create_volatile_dirty(ofs); 818c86243b0SVivek Goyal if (err < 0) { 819c86243b0SVivek Goyal pr_err("Failed to create volatile/dirty file.\n"); 820c86243b0SVivek Goyal goto out; 821c86243b0SVivek Goyal } 822c86243b0SVivek Goyal } 823c86243b0SVivek Goyal 8248ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 825e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 826e487d889SAmir Goldstein if (ofs->config.index && !fh_type) { 827ad204488SMiklos Szeredi ofs->config.index = false; 8281bd0a3aeSlijiazi pr_warn("upper fs does not support file handles, falling back to index=off.\n"); 8298ed61dc3SMiklos Szeredi } 83016aac5adSAmir Goldstein ofs->nofh |= !fh_type; 8318ed61dc3SMiklos Szeredi 832e487d889SAmir Goldstein /* Check if upper fs has 32bit inode numbers */ 833e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 8340f831ec8SAmir Goldstein ofs->xino_mode = -1; 835e487d889SAmir Goldstein 836f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */ 837f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) { 8381bd0a3aeSlijiazi pr_warn("NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 839f168f109SAmir Goldstein ofs->config.nfs_export = false; 840f168f109SAmir Goldstein } 8412ba9d57eSAmir Goldstein out: 8422ba9d57eSAmir Goldstein mnt_drop_write(mnt); 8432ba9d57eSAmir Goldstein return err; 8448ed61dc3SMiklos Szeredi } 8458ed61dc3SMiklos Szeredi 846146d62e5SAmir Goldstein static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs, 847b36a5780SChristian Brauner const struct path *upperpath, 848b36a5780SChristian Brauner const struct path *workpath) 849520d7c86SMiklos Szeredi { 850520d7c86SMiklos Szeredi int err; 851520d7c86SMiklos Szeredi 852520d7c86SMiklos Szeredi err = -EINVAL; 853b36a5780SChristian Brauner if (upperpath->mnt != workpath->mnt) { 8541bd0a3aeSlijiazi pr_err("workdir and upperdir must reside under the same mount\n"); 855b36a5780SChristian Brauner return err; 856520d7c86SMiklos Szeredi } 857b36a5780SChristian Brauner if (!ovl_workdir_ok(workpath->dentry, upperpath->dentry)) { 8581bd0a3aeSlijiazi pr_err("workdir and upperdir must be separate subtrees\n"); 859b36a5780SChristian Brauner return err; 860520d7c86SMiklos Szeredi } 861520d7c86SMiklos Szeredi 862b36a5780SChristian Brauner ofs->workbasedir = dget(workpath->dentry); 8638c25741aSMiklos Szeredi 8648c25741aSMiklos Szeredi if (ovl_inuse_trylock(ofs->workbasedir)) { 865ad204488SMiklos Szeredi ofs->workdir_locked = true; 866520d7c86SMiklos Szeredi } else { 8670be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "workdir"); 8680be0bfd2SAmir Goldstein if (err) 869b36a5780SChristian Brauner return err; 870520d7c86SMiklos Szeredi } 871520d7c86SMiklos Szeredi 8720be0bfd2SAmir Goldstein err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap, 8730be0bfd2SAmir Goldstein "workdir"); 8740be0bfd2SAmir Goldstein if (err) 875520d7c86SMiklos Szeredi return err; 876b36a5780SChristian Brauner 877b36a5780SChristian Brauner return ovl_make_workdir(sb, ofs, workpath); 878520d7c86SMiklos Szeredi } 879520d7c86SMiklos Szeredi 880146d62e5SAmir Goldstein static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs, 8812d343087SAl Viro struct ovl_entry *oe, const struct path *upperpath) 882f7e3a7d9SMiklos Szeredi { 88308f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 884235ce9edSAmir Goldstein struct dentry *indexdir; 885f7e3a7d9SMiklos Szeredi int err; 886f7e3a7d9SMiklos Szeredi 8872ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 8882ba9d57eSAmir Goldstein if (err) 8892ba9d57eSAmir Goldstein return err; 8902ba9d57eSAmir Goldstein 891f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 892610afc0bSMiklos Szeredi err = ovl_verify_origin(ofs, upperpath->dentry, 8935522c9c7SAmir Goldstein ovl_lowerstack(oe)->dentry, true); 894f7e3a7d9SMiklos Szeredi if (err) { 8951bd0a3aeSlijiazi pr_err("failed to verify upper root origin\n"); 896f7e3a7d9SMiklos Szeredi goto out; 897f7e3a7d9SMiklos Szeredi } 898f7e3a7d9SMiklos Szeredi 89920396365SAmir Goldstein /* index dir will act also as workdir */ 90020396365SAmir Goldstein iput(ofs->workdir_trap); 90120396365SAmir Goldstein ofs->workdir_trap = NULL; 90220396365SAmir Goldstein dput(ofs->workdir); 903470c1563SAmir Goldstein ofs->workdir = NULL; 904235ce9edSAmir Goldstein indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 905235ce9edSAmir Goldstein if (IS_ERR(indexdir)) { 906235ce9edSAmir Goldstein err = PTR_ERR(indexdir); 907235ce9edSAmir Goldstein } else if (indexdir) { 908235ce9edSAmir Goldstein ofs->indexdir = indexdir; 909235ce9edSAmir Goldstein ofs->workdir = dget(indexdir); 91020396365SAmir Goldstein 911146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap, 912146d62e5SAmir Goldstein "indexdir"); 913146d62e5SAmir Goldstein if (err) 914146d62e5SAmir Goldstein goto out; 915146d62e5SAmir Goldstein 916ad1d615cSAmir Goldstein /* 917ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir. 9182d2f2d73SMiklos Szeredi * Older kernels stored upper fh in ".overlay.origin" 919ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to 920ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr 9212d2f2d73SMiklos Szeredi * ".overlay.upper" to indicate that index may have 922ad1d615cSAmir Goldstein * directory entries. 923ad1d615cSAmir Goldstein */ 924610afc0bSMiklos Szeredi if (ovl_check_origin_xattr(ofs, ofs->indexdir)) { 925610afc0bSMiklos Szeredi err = ovl_verify_set_fh(ofs, ofs->indexdir, 926610afc0bSMiklos Szeredi OVL_XATTR_ORIGIN, 927ad1d615cSAmir Goldstein upperpath->dentry, true, false); 928f7e3a7d9SMiklos Szeredi if (err) 9291bd0a3aeSlijiazi pr_err("failed to verify index dir 'origin' xattr\n"); 930ad1d615cSAmir Goldstein } 931610afc0bSMiklos Szeredi err = ovl_verify_upper(ofs, ofs->indexdir, upperpath->dentry, 932610afc0bSMiklos Szeredi true); 933ad1d615cSAmir Goldstein if (err) 9341bd0a3aeSlijiazi pr_err("failed to verify index dir 'upper' xattr\n"); 935f7e3a7d9SMiklos Szeredi 936f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 937f7e3a7d9SMiklos Szeredi if (!err) 9381eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs); 939f7e3a7d9SMiklos Szeredi } 940ad204488SMiklos Szeredi if (err || !ofs->indexdir) 9411bd0a3aeSlijiazi pr_warn("try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 942f7e3a7d9SMiklos Szeredi 943f7e3a7d9SMiklos Szeredi out: 9442ba9d57eSAmir Goldstein mnt_drop_write(mnt); 945f7e3a7d9SMiklos Szeredi return err; 946f7e3a7d9SMiklos Szeredi } 947f7e3a7d9SMiklos Szeredi 9489df085f3SAmir Goldstein static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid) 9495148626bSAmir Goldstein { 9505148626bSAmir Goldstein unsigned int i; 9519df085f3SAmir Goldstein 95208f4c7c8SMiklos Szeredi if (!ofs->config.nfs_export && !ovl_upper_mnt(ofs)) 9539df085f3SAmir Goldstein return true; 9549df085f3SAmir Goldstein 955a888db31SAmir Goldstein /* 956a888db31SAmir Goldstein * We allow using single lower with null uuid for index and nfs_export 957a888db31SAmir Goldstein * for example to support those features with single lower squashfs. 958a888db31SAmir Goldstein * To avoid regressions in setups of overlay with re-formatted lower 959a888db31SAmir Goldstein * squashfs, do not allow decoding origin with lower null uuid unless 960a888db31SAmir Goldstein * user opted-in to one of the new features that require following the 961a888db31SAmir Goldstein * lower inode of non-dir upper. 962a888db31SAmir Goldstein */ 963ca45275cSVyacheslav Yurkov if (ovl_allow_offline_changes(ofs) && uuid_is_null(uuid)) 964a888db31SAmir Goldstein return false; 965a888db31SAmir Goldstein 9661b81ddddSAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 9679df085f3SAmir Goldstein /* 9689df085f3SAmir Goldstein * We use uuid to associate an overlay lower file handle with a 9699df085f3SAmir Goldstein * lower layer, so we can accept lower fs with null uuid as long 9709df085f3SAmir Goldstein * as all lower layers with null uuid are on the same fs. 9717e63c87fSAmir Goldstein * if we detect multiple lower fs with the same uuid, we 9727e63c87fSAmir Goldstein * disable lower file handle decoding on all of them. 9739df085f3SAmir Goldstein */ 9741b81ddddSAmir Goldstein if (ofs->fs[i].is_lower && 9751b81ddddSAmir Goldstein uuid_equal(&ofs->fs[i].sb->s_uuid, uuid)) { 97607f1e596SAmir Goldstein ofs->fs[i].bad_uuid = true; 9779df085f3SAmir Goldstein return false; 9789df085f3SAmir Goldstein } 9797e63c87fSAmir Goldstein } 9809df085f3SAmir Goldstein return true; 9819df085f3SAmir Goldstein } 9829df085f3SAmir Goldstein 9839df085f3SAmir Goldstein /* Get a unique fsid for the layer */ 9849df085f3SAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) 9859df085f3SAmir Goldstein { 9869df085f3SAmir Goldstein struct super_block *sb = path->mnt->mnt_sb; 9879df085f3SAmir Goldstein unsigned int i; 9885148626bSAmir Goldstein dev_t dev; 9895148626bSAmir Goldstein int err; 9907e63c87fSAmir Goldstein bool bad_uuid = false; 991b0e0f697SAmir Goldstein bool warn = false; 9925148626bSAmir Goldstein 99307f1e596SAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 99407f1e596SAmir Goldstein if (ofs->fs[i].sb == sb) 99507f1e596SAmir Goldstein return i; 9965148626bSAmir Goldstein } 9975148626bSAmir Goldstein 9989df085f3SAmir Goldstein if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) { 9997e63c87fSAmir Goldstein bad_uuid = true; 1000b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO) { 1001b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 1002b0e0f697SAmir Goldstein warn = true; 1003b0e0f697SAmir Goldstein } 10047e63c87fSAmir Goldstein if (ofs->config.index || ofs->config.nfs_export) { 10059df085f3SAmir Goldstein ofs->config.index = false; 10069df085f3SAmir Goldstein ofs->config.nfs_export = false; 1007b0e0f697SAmir Goldstein warn = true; 1008b0e0f697SAmir Goldstein } 1009b0e0f697SAmir Goldstein if (warn) { 1010b0e0f697SAmir Goldstein pr_warn("%s uuid detected in lower fs '%pd2', falling back to xino=%s,index=off,nfs_export=off.\n", 10117e63c87fSAmir Goldstein uuid_is_null(&sb->s_uuid) ? "null" : 10127e63c87fSAmir Goldstein "conflicting", 1013dcb399deSAmir Goldstein path->dentry, ovl_xino_mode(&ofs->config)); 10149df085f3SAmir Goldstein } 10157e63c87fSAmir Goldstein } 10169df085f3SAmir Goldstein 10175148626bSAmir Goldstein err = get_anon_bdev(&dev); 10185148626bSAmir Goldstein if (err) { 10191bd0a3aeSlijiazi pr_err("failed to get anonymous bdev for lowerpath\n"); 10205148626bSAmir Goldstein return err; 10215148626bSAmir Goldstein } 10225148626bSAmir Goldstein 102307f1e596SAmir Goldstein ofs->fs[ofs->numfs].sb = sb; 102407f1e596SAmir Goldstein ofs->fs[ofs->numfs].pseudo_dev = dev; 102507f1e596SAmir Goldstein ofs->fs[ofs->numfs].bad_uuid = bad_uuid; 10265148626bSAmir Goldstein 102707f1e596SAmir Goldstein return ofs->numfs++; 10285148626bSAmir Goldstein } 10295148626bSAmir Goldstein 103037ebf056SAmir Goldstein /* 103137ebf056SAmir Goldstein * The fsid after the last lower fsid is used for the data layers. 103237ebf056SAmir Goldstein * It is a "null fs" with a null sb, null uuid, and no pseudo dev. 103337ebf056SAmir Goldstein */ 103437ebf056SAmir Goldstein static int ovl_get_data_fsid(struct ovl_fs *ofs) 103537ebf056SAmir Goldstein { 103637ebf056SAmir Goldstein return ofs->numfs; 103737ebf056SAmir Goldstein } 103837ebf056SAmir Goldstein 103937ebf056SAmir Goldstein 104094375f9dSAmir Goldstein static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, 1041b36a5780SChristian Brauner struct ovl_fs_context *ctx, struct ovl_layer *layers) 1042520d7c86SMiklos Szeredi { 1043520d7c86SMiklos Szeredi int err; 1044520d7c86SMiklos Szeredi unsigned int i; 1045b36a5780SChristian Brauner size_t nr_merged_lower; 1046520d7c86SMiklos Szeredi 1047b36a5780SChristian Brauner ofs->fs = kcalloc(ctx->nr + 2, sizeof(struct ovl_sb), GFP_KERNEL); 104807f1e596SAmir Goldstein if (ofs->fs == NULL) 10499e88f905SAmir Goldstein return -ENOMEM; 10505148626bSAmir Goldstein 105137ebf056SAmir Goldstein /* 105237ebf056SAmir Goldstein * idx/fsid 0 are reserved for upper fs even with lower only overlay 105337ebf056SAmir Goldstein * and the last fsid is reserved for "null fs" of the data layers. 105437ebf056SAmir Goldstein */ 105507f1e596SAmir Goldstein ofs->numfs++; 105607f1e596SAmir Goldstein 105707f1e596SAmir Goldstein /* 1058b7bf9908SAmir Goldstein * All lower layers that share the same fs as upper layer, use the same 1059b7bf9908SAmir Goldstein * pseudo_dev as upper layer. Allocate fs[0].pseudo_dev even for lower 1060b7bf9908SAmir Goldstein * only overlay to simplify ovl_fs_free(). 10611b81ddddSAmir Goldstein * is_lower will be set if upper fs is shared with a lower layer. 106207f1e596SAmir Goldstein */ 1063b7bf9908SAmir Goldstein err = get_anon_bdev(&ofs->fs[0].pseudo_dev); 1064b7bf9908SAmir Goldstein if (err) { 1065b7bf9908SAmir Goldstein pr_err("failed to get anonymous bdev for upper fs\n"); 10669e88f905SAmir Goldstein return err; 1067b7bf9908SAmir Goldstein } 1068b7bf9908SAmir Goldstein 106908f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 107008f4c7c8SMiklos Szeredi ofs->fs[0].sb = ovl_upper_mnt(ofs)->mnt_sb; 10711b81ddddSAmir Goldstein ofs->fs[0].is_lower = false; 107207f1e596SAmir Goldstein } 107307f1e596SAmir Goldstein 1074b36a5780SChristian Brauner nr_merged_lower = ctx->nr - ctx->nr_data; 1075b36a5780SChristian Brauner for (i = 0; i < ctx->nr; i++) { 1076b36a5780SChristian Brauner struct ovl_fs_context_layer *l = &ctx->lower[i]; 1077520d7c86SMiklos Szeredi struct vfsmount *mnt; 1078146d62e5SAmir Goldstein struct inode *trap; 10795148626bSAmir Goldstein int fsid; 1080520d7c86SMiklos Szeredi 1081b36a5780SChristian Brauner if (i < nr_merged_lower) 1082b36a5780SChristian Brauner fsid = ovl_get_fsid(ofs, &l->path); 108337ebf056SAmir Goldstein else 108437ebf056SAmir Goldstein fsid = ovl_get_data_fsid(ofs); 10859e88f905SAmir Goldstein if (fsid < 0) 10869e88f905SAmir Goldstein return fsid; 1087520d7c86SMiklos Szeredi 108824f14009Syoungjun /* 108924f14009Syoungjun * Check if lower root conflicts with this overlay layers before 109024f14009Syoungjun * checking if it is in-use as upperdir/workdir of "another" 109124f14009Syoungjun * mount, because we do not bother to check in ovl_is_inuse() if 109224f14009Syoungjun * the upperdir/workdir is in fact in-use by our 109324f14009Syoungjun * upperdir/workdir. 109424f14009Syoungjun */ 1095b36a5780SChristian Brauner err = ovl_setup_trap(sb, l->path.dentry, &trap, "lowerdir"); 1096146d62e5SAmir Goldstein if (err) 10979e88f905SAmir Goldstein return err; 1098146d62e5SAmir Goldstein 1099b36a5780SChristian Brauner if (ovl_is_inuse(l->path.dentry)) { 11000be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "lowerdir"); 110124f14009Syoungjun if (err) { 110224f14009Syoungjun iput(trap); 11039e88f905SAmir Goldstein return err; 11040be0bfd2SAmir Goldstein } 110524f14009Syoungjun } 11060be0bfd2SAmir Goldstein 1107b36a5780SChristian Brauner mnt = clone_private_mount(&l->path); 1108520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1109520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 11101bd0a3aeSlijiazi pr_err("failed to clone lowerpath\n"); 1111146d62e5SAmir Goldstein iput(trap); 11129e88f905SAmir Goldstein return err; 1113520d7c86SMiklos Szeredi } 11145148626bSAmir Goldstein 1115520d7c86SMiklos Szeredi /* 1116520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1117520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1118520d7c86SMiklos Szeredi */ 1119520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1120520d7c86SMiklos Szeredi 112113464165SMiklos Szeredi layers[ofs->numlayer].trap = trap; 112213464165SMiklos Szeredi layers[ofs->numlayer].mnt = mnt; 112313464165SMiklos Szeredi layers[ofs->numlayer].idx = ofs->numlayer; 112413464165SMiklos Szeredi layers[ofs->numlayer].fsid = fsid; 112513464165SMiklos Szeredi layers[ofs->numlayer].fs = &ofs->fs[fsid]; 1126b36a5780SChristian Brauner layers[ofs->numlayer].name = l->name; 1127b36a5780SChristian Brauner l->name = NULL; 112894375f9dSAmir Goldstein ofs->numlayer++; 11291b81ddddSAmir Goldstein ofs->fs[fsid].is_lower = true; 1130520d7c86SMiklos Szeredi } 1131e487d889SAmir Goldstein 1132795939a9SAmir Goldstein /* 1133795939a9SAmir Goldstein * When all layers on same fs, overlay can use real inode numbers. 1134926e94d7SAmir Goldstein * With mount option "xino=<on|auto>", mounter declares that there are 1135926e94d7SAmir Goldstein * enough free high bits in underlying fs to hold the unique fsid. 1136795939a9SAmir Goldstein * If overlayfs does encounter underlying inodes using the high xino 1137795939a9SAmir Goldstein * bits reserved for fsid, it emits a warning and uses the original 1138dfe51d47SAmir Goldstein * inode number or a non persistent inode number allocated from a 1139dfe51d47SAmir Goldstein * dedicated range. 1140795939a9SAmir Goldstein */ 114108f4c7c8SMiklos Szeredi if (ofs->numfs - !ovl_upper_mnt(ofs) == 1) { 11420f831ec8SAmir Goldstein if (ofs->config.xino == OVL_XINO_ON) 11430f831ec8SAmir Goldstein pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n"); 11440f831ec8SAmir Goldstein ofs->xino_mode = 0; 114553afcd31SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_OFF) { 114653afcd31SAmir Goldstein ofs->xino_mode = -1; 1147926e94d7SAmir Goldstein } else if (ofs->xino_mode < 0) { 1148795939a9SAmir Goldstein /* 114907f1e596SAmir Goldstein * This is a roundup of number of bits needed for encoding 1150dfe51d47SAmir Goldstein * fsid, where fsid 0 is reserved for upper fs (even with 1151dfe51d47SAmir Goldstein * lower only overlay) +1 extra bit is reserved for the non 1152dfe51d47SAmir Goldstein * persistent inode number range that is used for resolving 1153dfe51d47SAmir Goldstein * xino lower bits overflow. 1154795939a9SAmir Goldstein */ 1155dfe51d47SAmir Goldstein BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 30); 1156dfe51d47SAmir Goldstein ofs->xino_mode = ilog2(ofs->numfs - 1) + 2; 1157795939a9SAmir Goldstein } 1158795939a9SAmir Goldstein 11590f831ec8SAmir Goldstein if (ofs->xino_mode > 0) { 11601bd0a3aeSlijiazi pr_info("\"xino\" feature enabled using %d upper inode bits.\n", 11610f831ec8SAmir Goldstein ofs->xino_mode); 1162795939a9SAmir Goldstein } 1163e487d889SAmir Goldstein 11649e88f905SAmir Goldstein return 0; 1165520d7c86SMiklos Szeredi } 1166520d7c86SMiklos Szeredi 11674155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1168b36a5780SChristian Brauner struct ovl_fs_context *ctx, 1169b36a5780SChristian Brauner struct ovl_fs *ofs, 1170b36a5780SChristian Brauner struct ovl_layer *layers) 117153dbb0b4SMiklos Szeredi { 117253dbb0b4SMiklos Szeredi int err; 1173b8e42a65SMiklos Szeredi unsigned int i; 1174b36a5780SChristian Brauner size_t nr_merged_lower; 11754155c10aSMiklos Szeredi struct ovl_entry *oe; 1176b36a5780SChristian Brauner struct ovl_path *lowerstack; 117753dbb0b4SMiklos Szeredi 1178b36a5780SChristian Brauner struct ovl_fs_context_layer *l; 1179b36a5780SChristian Brauner 1180b36a5780SChristian Brauner if (!ofs->config.upperdir && ctx->nr == 1) { 11811bd0a3aeSlijiazi pr_err("at least 2 lowerdir are needed while upperdir nonexistent\n"); 1182b8e42a65SMiklos Szeredi return ERR_PTR(-EINVAL); 118353dbb0b4SMiklos Szeredi } 118453dbb0b4SMiklos Szeredi 118537ebf056SAmir Goldstein err = -EINVAL; 1186b36a5780SChristian Brauner for (i = 0; i < ctx->nr; i++) { 1187b36a5780SChristian Brauner l = &ctx->lower[i]; 118837ebf056SAmir Goldstein 1189b36a5780SChristian Brauner err = ovl_lower_dir(l->name, &l->path, ofs, &sb->s_stack_depth); 1190b36a5780SChristian Brauner if (err) 1191b36a5780SChristian Brauner return ERR_PTR(err); 119253dbb0b4SMiklos Szeredi } 119353dbb0b4SMiklos Szeredi 119453dbb0b4SMiklos Szeredi err = -EINVAL; 119553dbb0b4SMiklos Szeredi sb->s_stack_depth++; 119653dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 11971bd0a3aeSlijiazi pr_err("maximum fs stacking depth exceeded\n"); 1198b36a5780SChristian Brauner return ERR_PTR(err); 119953dbb0b4SMiklos Szeredi } 120053dbb0b4SMiklos Szeredi 1201b36a5780SChristian Brauner err = ovl_get_layers(sb, ofs, ctx, layers); 12024155c10aSMiklos Szeredi if (err) 1203b36a5780SChristian Brauner return ERR_PTR(err); 12044155c10aSMiklos Szeredi 12054155c10aSMiklos Szeredi err = -ENOMEM; 120637ebf056SAmir Goldstein /* Data-only layers are not merged in root directory */ 1207b36a5780SChristian Brauner nr_merged_lower = ctx->nr - ctx->nr_data; 1208b36a5780SChristian Brauner oe = ovl_alloc_entry(nr_merged_lower); 12094155c10aSMiklos Szeredi if (!oe) 1210b36a5780SChristian Brauner return ERR_PTR(err); 12114155c10aSMiklos Szeredi 12125522c9c7SAmir Goldstein lowerstack = ovl_lowerstack(oe); 1213b36a5780SChristian Brauner for (i = 0; i < nr_merged_lower; i++) { 1214b36a5780SChristian Brauner l = &ctx->lower[i]; 1215b36a5780SChristian Brauner lowerstack[i].dentry = dget(l->path.dentry); 12165522c9c7SAmir Goldstein lowerstack[i].layer = &ofs->layers[i + 1]; 12174155c10aSMiklos Szeredi } 1218b36a5780SChristian Brauner ofs->numdatalayer = ctx->nr_data; 12194155c10aSMiklos Szeredi 12204155c10aSMiklos Szeredi return oe; 122153dbb0b4SMiklos Szeredi } 122253dbb0b4SMiklos Szeredi 1223146d62e5SAmir Goldstein /* 1224146d62e5SAmir Goldstein * Check if this layer root is a descendant of: 1225146d62e5SAmir Goldstein * - another layer of this overlayfs instance 1226146d62e5SAmir Goldstein * - upper/work dir of any overlayfs instance 1227146d62e5SAmir Goldstein */ 12280be0bfd2SAmir Goldstein static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs, 1229708fa015SMiklos Szeredi struct dentry *dentry, const char *name, 1230708fa015SMiklos Szeredi bool is_lower) 1231146d62e5SAmir Goldstein { 12329179c21dSMiklos Szeredi struct dentry *next = dentry, *parent; 1233146d62e5SAmir Goldstein int err = 0; 1234146d62e5SAmir Goldstein 12359179c21dSMiklos Szeredi if (!dentry) 1236146d62e5SAmir Goldstein return 0; 1237146d62e5SAmir Goldstein 1238146d62e5SAmir Goldstein parent = dget_parent(next); 12399179c21dSMiklos Szeredi 12409179c21dSMiklos Szeredi /* Walk back ancestors to root (inclusive) looking for traps */ 12419179c21dSMiklos Szeredi while (!err && parent != next) { 1242708fa015SMiklos Szeredi if (is_lower && ovl_lookup_trap_inode(sb, parent)) { 1243146d62e5SAmir Goldstein err = -ELOOP; 12441bd0a3aeSlijiazi pr_err("overlapping %s path\n", name); 12450be0bfd2SAmir Goldstein } else if (ovl_is_inuse(parent)) { 12460be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, name); 1247146d62e5SAmir Goldstein } 1248146d62e5SAmir Goldstein next = parent; 12499179c21dSMiklos Szeredi parent = dget_parent(next); 12509179c21dSMiklos Szeredi dput(next); 1251146d62e5SAmir Goldstein } 1252146d62e5SAmir Goldstein 12539179c21dSMiklos Szeredi dput(parent); 1254146d62e5SAmir Goldstein 1255146d62e5SAmir Goldstein return err; 1256146d62e5SAmir Goldstein } 1257146d62e5SAmir Goldstein 1258146d62e5SAmir Goldstein /* 1259146d62e5SAmir Goldstein * Check if any of the layers or work dirs overlap. 1260146d62e5SAmir Goldstein */ 1261146d62e5SAmir Goldstein static int ovl_check_overlapping_layers(struct super_block *sb, 1262146d62e5SAmir Goldstein struct ovl_fs *ofs) 1263146d62e5SAmir Goldstein { 1264146d62e5SAmir Goldstein int i, err; 1265146d62e5SAmir Goldstein 126608f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 126708f4c7c8SMiklos Szeredi err = ovl_check_layer(sb, ofs, ovl_upper_mnt(ofs)->mnt_root, 1268708fa015SMiklos Szeredi "upperdir", false); 1269146d62e5SAmir Goldstein if (err) 1270146d62e5SAmir Goldstein return err; 1271146d62e5SAmir Goldstein 1272146d62e5SAmir Goldstein /* 1273146d62e5SAmir Goldstein * Checking workbasedir avoids hitting ovl_is_inuse(parent) of 1274146d62e5SAmir Goldstein * this instance and covers overlapping work and index dirs, 1275146d62e5SAmir Goldstein * unless work or index dir have been moved since created inside 1276146d62e5SAmir Goldstein * workbasedir. In that case, we already have their traps in 1277146d62e5SAmir Goldstein * inode cache and we will catch that case on lookup. 1278146d62e5SAmir Goldstein */ 1279708fa015SMiklos Szeredi err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir", 1280708fa015SMiklos Szeredi false); 1281146d62e5SAmir Goldstein if (err) 1282146d62e5SAmir Goldstein return err; 1283146d62e5SAmir Goldstein } 1284146d62e5SAmir Goldstein 128594375f9dSAmir Goldstein for (i = 1; i < ofs->numlayer; i++) { 12860be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, 128794375f9dSAmir Goldstein ofs->layers[i].mnt->mnt_root, 1288708fa015SMiklos Szeredi "lowerdir", true); 1289146d62e5SAmir Goldstein if (err) 1290146d62e5SAmir Goldstein return err; 1291146d62e5SAmir Goldstein } 1292146d62e5SAmir Goldstein 1293146d62e5SAmir Goldstein return 0; 1294146d62e5SAmir Goldstein } 1295146d62e5SAmir Goldstein 12962effc5c2SAmir Goldstein static struct dentry *ovl_get_root(struct super_block *sb, 12972effc5c2SAmir Goldstein struct dentry *upperdentry, 12982effc5c2SAmir Goldstein struct ovl_entry *oe) 12992effc5c2SAmir Goldstein { 13002effc5c2SAmir Goldstein struct dentry *root; 13015522c9c7SAmir Goldstein struct ovl_path *lowerpath = ovl_lowerstack(oe); 130262c832edSAmir Goldstein unsigned long ino = d_inode(lowerpath->dentry)->i_ino; 130362c832edSAmir Goldstein int fsid = lowerpath->layer->fsid; 130462c832edSAmir Goldstein struct ovl_inode_params oip = { 130562c832edSAmir Goldstein .upperdentry = upperdentry, 13060af950f5SAmir Goldstein .oe = oe, 130762c832edSAmir Goldstein }; 13082effc5c2SAmir Goldstein 13092effc5c2SAmir Goldstein root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 13102effc5c2SAmir Goldstein if (!root) 13112effc5c2SAmir Goldstein return NULL; 13122effc5c2SAmir Goldstein 13132effc5c2SAmir Goldstein if (upperdentry) { 131462c832edSAmir Goldstein /* Root inode uses upper st_ino/i_ino */ 131562c832edSAmir Goldstein ino = d_inode(upperdentry)->i_ino; 131662c832edSAmir Goldstein fsid = 0; 13172effc5c2SAmir Goldstein ovl_dentry_set_upper_alias(root); 1318610afc0bSMiklos Szeredi if (ovl_is_impuredir(sb, upperdentry)) 13192effc5c2SAmir Goldstein ovl_set_flag(OVL_IMPURE, d_inode(root)); 13202effc5c2SAmir Goldstein } 13212effc5c2SAmir Goldstein 13222effc5c2SAmir Goldstein /* Root is always merge -> can have whiteouts */ 13232effc5c2SAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root)); 13242effc5c2SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root); 13252effc5c2SAmir Goldstein ovl_set_upperdata(d_inode(root)); 132662c832edSAmir Goldstein ovl_inode_init(d_inode(root), &oip, ino, fsid); 13270af950f5SAmir Goldstein ovl_dentry_init_flags(root, upperdentry, oe, DCACHE_OP_WEAK_REVALIDATE); 1328367d002dSAmir Goldstein /* root keeps a reference of upperdentry */ 1329367d002dSAmir Goldstein dget(upperdentry); 13302effc5c2SAmir Goldstein 13312effc5c2SAmir Goldstein return root; 13322effc5c2SAmir Goldstein } 13332effc5c2SAmir Goldstein 13347fb7998bSChristian Brauner int ovl_fill_super(struct super_block *sb, struct fs_context *fc) 1335e9be9d5eSMiklos Szeredi { 13361784fbc2SChristian Brauner struct ovl_fs *ofs = sb->s_fs_info; 13371784fbc2SChristian Brauner struct ovl_fs_context *ctx = fc->fs_private; 1338e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 13394155c10aSMiklos Szeredi struct ovl_entry *oe; 1340b8e42a65SMiklos Szeredi struct ovl_layer *layers; 134151f8f3c4SKonstantin Khlebnikov struct cred *cred; 1342e9be9d5eSMiklos Szeredi int err; 1343e9be9d5eSMiklos Szeredi 13449efb069dSMiklos Szeredi err = -EIO; 13451784fbc2SChristian Brauner if (WARN_ON(fc->user_ns != current_user_ns())) 13461784fbc2SChristian Brauner goto out_err; 13479efb069dSMiklos Szeredi 1348f4288844SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 1349f4288844SMiklos Szeredi 1350f45827e8SErez Zadok err = -ENOMEM; 1351ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1352c6fe6254SMiklos Szeredi if (!cred) 1353c6fe6254SMiklos Szeredi goto out_err; 1354c6fe6254SMiklos Szeredi 13551784fbc2SChristian Brauner err = ovl_fs_params_verify(ctx, &ofs->config); 1356f45827e8SErez Zadok if (err) 1357a9075cdbSMiklos Szeredi goto out_err; 1358f45827e8SErez Zadok 1359e9be9d5eSMiklos Szeredi err = -EINVAL; 1360b36a5780SChristian Brauner if (ctx->nr == 0) { 13611784fbc2SChristian Brauner if (!(fc->sb_flags & SB_SILENT)) 13621bd0a3aeSlijiazi pr_err("missing 'lowerdir'\n"); 1363a9075cdbSMiklos Szeredi goto out_err; 136453a08cb9SMiklos Szeredi } 136553a08cb9SMiklos Szeredi 1366b8e42a65SMiklos Szeredi err = -ENOMEM; 1367b36a5780SChristian Brauner layers = kcalloc(ctx->nr + 1, sizeof(struct ovl_layer), GFP_KERNEL); 1368b8e42a65SMiklos Szeredi if (!layers) 1369b8e42a65SMiklos Szeredi goto out_err; 1370b8e42a65SMiklos Szeredi 1371b8e42a65SMiklos Szeredi ofs->layers = layers; 1372b8e42a65SMiklos Szeredi /* Layer 0 is reserved for upper even if there's no upper */ 1373b8e42a65SMiklos Szeredi ofs->numlayer = 1; 1374b8e42a65SMiklos Szeredi 137553a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 1376cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 13774d314f78SAmir Goldstein atomic_long_set(&ofs->last_ino, 1); 13784f119628SWilliam Dean /* Assume underlying fs uses 32bit inodes unless proven otherwise */ 137953afcd31SAmir Goldstein if (ofs->config.xino != OVL_XINO_OFF) { 13800f831ec8SAmir Goldstein ofs->xino_mode = BITS_PER_LONG - 32; 138153afcd31SAmir Goldstein if (!ofs->xino_mode) { 138253afcd31SAmir Goldstein pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n"); 138353afcd31SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 138453afcd31SAmir Goldstein } 138553afcd31SAmir Goldstein } 1386795939a9SAmir Goldstein 1387146d62e5SAmir Goldstein /* alloc/destroy_inode needed for setting up traps in inode cache */ 1388146d62e5SAmir Goldstein sb->s_op = &ovl_super_operations; 1389146d62e5SAmir Goldstein 1390ad204488SMiklos Szeredi if (ofs->config.upperdir) { 1391335d3fc5SSargun Dhillon struct super_block *upper_sb; 1392335d3fc5SSargun Dhillon 1393d7b49b10SChengguang Xu err = -EINVAL; 1394ad204488SMiklos Szeredi if (!ofs->config.workdir) { 13951bd0a3aeSlijiazi pr_err("missing 'workdir'\n"); 1396a9075cdbSMiklos Szeredi goto out_err; 1397e9be9d5eSMiklos Szeredi } 1398e9be9d5eSMiklos Szeredi 1399b36a5780SChristian Brauner err = ovl_get_upper(sb, ofs, &layers[0], &ctx->upper); 140021a3b317SMiklos Szeredi if (err) 1401a9075cdbSMiklos Szeredi goto out_err; 1402d719e8f2SMiklos Szeredi 1403335d3fc5SSargun Dhillon upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 1404335d3fc5SSargun Dhillon if (!ovl_should_sync(ofs)) { 1405335d3fc5SSargun Dhillon ofs->errseq = errseq_sample(&upper_sb->s_wb_err); 1406335d3fc5SSargun Dhillon if (errseq_check(&upper_sb->s_wb_err, ofs->errseq)) { 1407335d3fc5SSargun Dhillon err = -EIO; 1408335d3fc5SSargun Dhillon pr_err("Cannot mount volatile when upperdir has an unseen error. Sync upperdir fs to clear state.\n"); 1409335d3fc5SSargun Dhillon goto out_err; 1410335d3fc5SSargun Dhillon } 1411335d3fc5SSargun Dhillon } 1412335d3fc5SSargun Dhillon 1413b36a5780SChristian Brauner err = ovl_get_workdir(sb, ofs, &ctx->upper, &ctx->work); 14148ed61dc3SMiklos Szeredi if (err) 1415a9075cdbSMiklos Szeredi goto out_err; 1416c6fe6254SMiklos Szeredi 1417ad204488SMiklos Szeredi if (!ofs->workdir) 14181751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 14196e88256eSMiklos Szeredi 1420335d3fc5SSargun Dhillon sb->s_stack_depth = upper_sb->s_stack_depth; 1421335d3fc5SSargun Dhillon sb->s_time_gran = upper_sb->s_time_gran; 142221765194SVivek Goyal } 1423b36a5780SChristian Brauner oe = ovl_get_lowerstack(sb, ctx, ofs, layers); 14244155c10aSMiklos Szeredi err = PTR_ERR(oe); 14254155c10aSMiklos Szeredi if (IS_ERR(oe)) 1426a9075cdbSMiklos Szeredi goto out_err; 1427e9be9d5eSMiklos Szeredi 142871cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 142908f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 14301751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 1431e9be9d5eSMiklos Szeredi 1432b0504bfeSAmir Goldstein if (!ovl_origin_uuid(ofs) && ofs->numfs > 1) { 1433b0504bfeSAmir Goldstein pr_warn("The uuid=off requires a single fs for lower and upper, falling back to uuid=null.\n"); 1434b0504bfeSAmir Goldstein ofs->config.uuid = OVL_UUID_NULL; 1435d9544c1bSAmir Goldstein } else if (ovl_has_fsid(ofs) && ovl_upper_mnt(ofs)) { 1436d9544c1bSAmir Goldstein /* Use per instance persistent uuid/fsid */ 1437d9544c1bSAmir Goldstein ovl_init_uuid_xattr(sb, ofs, &ctx->upper); 14385830fb6bSPavel Tikhomirov } 14395830fb6bSPavel Tikhomirov 1440470c1563SAmir Goldstein if (!ovl_force_readonly(ofs) && ofs->config.index) { 1441b36a5780SChristian Brauner err = ovl_get_indexdir(sb, ofs, oe, &ctx->upper); 144254fb347eSAmir Goldstein if (err) 14434155c10aSMiklos Szeredi goto out_free_oe; 14446e88256eSMiklos Szeredi 1445972d0093SAmir Goldstein /* Force r/o mount with no index dir */ 144620396365SAmir Goldstein if (!ofs->indexdir) 14471751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 144802bcd157SAmir Goldstein } 144902bcd157SAmir Goldstein 1450146d62e5SAmir Goldstein err = ovl_check_overlapping_layers(sb, ofs); 1451146d62e5SAmir Goldstein if (err) 1452146d62e5SAmir Goldstein goto out_free_oe; 1453146d62e5SAmir Goldstein 1454972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */ 1455f168f109SAmir Goldstein if (!ofs->indexdir) { 1456ad204488SMiklos Szeredi ofs->config.index = false; 145708f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs) && ofs->config.nfs_export) { 14581bd0a3aeSlijiazi pr_warn("NFS export requires an index dir, falling back to nfs_export=off.\n"); 1459f168f109SAmir Goldstein ofs->config.nfs_export = false; 1460f168f109SAmir Goldstein } 1461f168f109SAmir Goldstein } 146202bcd157SAmir Goldstein 1463d5791044SVivek Goyal if (ofs->config.metacopy && ofs->config.nfs_export) { 14641bd0a3aeSlijiazi pr_warn("NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 1465d5791044SVivek Goyal ofs->config.nfs_export = false; 1466d5791044SVivek Goyal } 1467d5791044SVivek Goyal 146816aac5adSAmir Goldstein /* 146916aac5adSAmir Goldstein * Support encoding decodable file handles with nfs_export=on 147016aac5adSAmir Goldstein * and encoding non-decodable file handles with nfs_export=off 147116aac5adSAmir Goldstein * if all layers support file handles. 147216aac5adSAmir Goldstein */ 14738383f174SAmir Goldstein if (ofs->config.nfs_export) 14748383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations; 147516aac5adSAmir Goldstein else if (!ofs->nofh) 147616aac5adSAmir Goldstein sb->s_export_op = &ovl_export_fid_operations; 14778383f174SAmir Goldstein 147851f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 147951f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 148051f8f3c4SKonstantin Khlebnikov 1481655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 14822d2f2d73SMiklos Szeredi sb->s_xattr = ofs->config.userxattr ? ovl_user_xattr_handlers : 14832d2f2d73SMiklos Szeredi ovl_trusted_xattr_handlers; 1484ad204488SMiklos Szeredi sb->s_fs_info = ofs; 1485de2a4a50SMiklos Szeredi sb->s_flags |= SB_POSIXACL; 148618b44bc5SEric Snowberg sb->s_iflags |= SB_I_SKIP_SYNC | SB_I_IMA_UNVERIFIABLE_SIGNATURE; 1487655042ccSVivek Goyal 1488c6fe6254SMiklos Szeredi err = -ENOMEM; 1489b36a5780SChristian Brauner root_dentry = ovl_get_root(sb, ctx->upper.dentry, oe); 1490e9be9d5eSMiklos Szeredi if (!root_dentry) 14914155c10aSMiklos Szeredi goto out_free_oe; 1492e9be9d5eSMiklos Szeredi 1493e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1494e9be9d5eSMiklos Szeredi 1495e9be9d5eSMiklos Szeredi return 0; 1496e9be9d5eSMiklos Szeredi 14974155c10aSMiklos Szeredi out_free_oe: 1498163db0daSAmir Goldstein ovl_free_entry(oe); 14994155c10aSMiklos Szeredi out_err: 1500ad204488SMiklos Szeredi ovl_free_fs(ofs); 15011784fbc2SChristian Brauner sb->s_fs_info = NULL; 1502e9be9d5eSMiklos Szeredi return err; 1503e9be9d5eSMiklos Szeredi } 1504e9be9d5eSMiklos Szeredi 1505f01d0889SAndrea Righi struct file_system_type ovl_fs_type = { 1506e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1507ef94b186SMiklos Szeredi .name = "overlay", 15081784fbc2SChristian Brauner .init_fs_context = ovl_init_fs_context, 15091784fbc2SChristian Brauner .parameters = ovl_parameter_spec, 1510459c7c56SMiklos Szeredi .fs_flags = FS_USERNS_MOUNT, 1511e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 1512e9be9d5eSMiklos Szeredi }; 1513ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 1514e9be9d5eSMiklos Szeredi 151513cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 151613cf199dSAmir Goldstein { 151713cf199dSAmir Goldstein struct ovl_inode *oi = foo; 151813cf199dSAmir Goldstein 151913cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 152013cf199dSAmir Goldstein } 152113cf199dSAmir Goldstein 1522e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 1523e9be9d5eSMiklos Szeredi { 152413cf199dSAmir Goldstein int err; 152513cf199dSAmir Goldstein 152613cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 152713cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 152813cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 152913cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 153013cf199dSAmir Goldstein ovl_inode_init_once); 153113cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 153213cf199dSAmir Goldstein return -ENOMEM; 153313cf199dSAmir Goldstein 15342406a307SJiufei Xue err = ovl_aio_request_cache_init(); 15352406a307SJiufei Xue if (!err) { 153613cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 15372406a307SJiufei Xue if (!err) 15382406a307SJiufei Xue return 0; 15392406a307SJiufei Xue 15402406a307SJiufei Xue ovl_aio_request_cache_destroy(); 15412406a307SJiufei Xue } 154213cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 154313cf199dSAmir Goldstein 154413cf199dSAmir Goldstein return err; 1545e9be9d5eSMiklos Szeredi } 1546e9be9d5eSMiklos Szeredi 1547e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1548e9be9d5eSMiklos Szeredi { 1549e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 155013cf199dSAmir Goldstein 155113cf199dSAmir Goldstein /* 155213cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 155313cf199dSAmir Goldstein * destroy cache. 155413cf199dSAmir Goldstein */ 155513cf199dSAmir Goldstein rcu_barrier(); 155613cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 15572406a307SJiufei Xue ovl_aio_request_cache_destroy(); 1558e9be9d5eSMiklos Szeredi } 1559e9be9d5eSMiklos Szeredi 1560e9be9d5eSMiklos Szeredi module_init(ovl_init); 1561e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1562