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); 1700b269dedSAl Viro mutex_destroy(&oi->lock); 1710b269dedSAl Viro kmem_cache_free(ovl_inode_cachep, oi); 17213cf199dSAmir Goldstein } 17313cf199dSAmir Goldstein 17413cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode) 17513cf199dSAmir Goldstein { 17609d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode); 17709d8b586SMiklos Szeredi 17809d8b586SMiklos Szeredi dput(oi->__upperdentry); 1790af950f5SAmir Goldstein ovl_free_entry(oi->oe); 1802664bd08SVivek Goyal if (S_ISDIR(inode->i_mode)) 1814edb83bbSMiklos Szeredi ovl_dir_cache_free(inode); 1822b21da92SAmir Goldstein else 1832b21da92SAmir Goldstein kfree(oi->lowerdata_redirect); 18413cf199dSAmir Goldstein } 18513cf199dSAmir Goldstein 186a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 187a9075cdbSMiklos Szeredi { 188*f01d0889SAndrea Righi struct ovl_fs *ofs = OVL_FS(sb); 189a9075cdbSMiklos Szeredi 1901784fbc2SChristian Brauner if (ofs) 191a9075cdbSMiklos Szeredi ovl_free_fs(ofs); 192a9075cdbSMiklos Szeredi } 193a9075cdbSMiklos Szeredi 194e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */ 195e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait) 196e593b2bfSAmir Goldstein { 197*f01d0889SAndrea Righi struct ovl_fs *ofs = OVL_FS(sb); 198e593b2bfSAmir Goldstein struct super_block *upper_sb; 199e593b2bfSAmir Goldstein int ret; 200e593b2bfSAmir Goldstein 201335d3fc5SSargun Dhillon ret = ovl_sync_status(ofs); 202335d3fc5SSargun Dhillon /* 203335d3fc5SSargun Dhillon * We have to always set the err, because the return value isn't 204335d3fc5SSargun Dhillon * checked in syncfs, and instead indirectly return an error via 205335d3fc5SSargun Dhillon * the sb's writeback errseq, which VFS inspects after this call. 206335d3fc5SSargun Dhillon */ 207335d3fc5SSargun Dhillon if (ret < 0) { 208335d3fc5SSargun Dhillon errseq_set(&sb->s_wb_err, -EIO); 209335d3fc5SSargun Dhillon return -EIO; 210335d3fc5SSargun Dhillon } 211e8d4bfe3SChengguang Xu 212335d3fc5SSargun Dhillon if (!ret) 213335d3fc5SSargun Dhillon return ret; 214335d3fc5SSargun Dhillon 215e8d4bfe3SChengguang Xu /* 21632b1924bSKonstantin Khlebnikov * Not called for sync(2) call or an emergency sync (SB_I_SKIP_SYNC). 21732b1924bSKonstantin Khlebnikov * All the super blocks will be iterated, including upper_sb. 218e8d4bfe3SChengguang Xu * 219e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call 220e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being 221e8d4bfe3SChengguang Xu * called with wait == 1. 222e8d4bfe3SChengguang Xu */ 223e8d4bfe3SChengguang Xu if (!wait) 224e593b2bfSAmir Goldstein return 0; 225e593b2bfSAmir Goldstein 22608f4c7c8SMiklos Szeredi upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 227e8d4bfe3SChengguang Xu 228e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount); 229e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb); 230e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount); 231e8d4bfe3SChengguang Xu 232e593b2bfSAmir Goldstein return ret; 233e593b2bfSAmir Goldstein } 234e593b2bfSAmir Goldstein 235cc259639SAndy Whitcroft /** 236cc259639SAndy Whitcroft * ovl_statfs 2379c5dd803SYang Li * @dentry: The dentry to query 238cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 239cc259639SAndy Whitcroft * 240cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 2414ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 242cc259639SAndy Whitcroft */ 243cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 244cc259639SAndy Whitcroft { 245b0504bfeSAmir Goldstein struct super_block *sb = dentry->d_sb; 246b0504bfeSAmir Goldstein struct ovl_fs *ofs = OVL_FS(sb); 247b0504bfeSAmir Goldstein struct dentry *root_dentry = sb->s_root; 248cc259639SAndy Whitcroft struct path path; 249cc259639SAndy Whitcroft int err; 250cc259639SAndy Whitcroft 2514ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 252cc259639SAndy Whitcroft 253cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 254cc259639SAndy Whitcroft if (!err) { 2556b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen; 256cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 257b0504bfeSAmir Goldstein if (ovl_has_fsid(ofs)) 258b0504bfeSAmir Goldstein buf->f_fsid = uuid_to_fsid(sb->s_uuid.b); 259cc259639SAndy Whitcroft } 260cc259639SAndy Whitcroft 261cc259639SAndy Whitcroft return err; 262cc259639SAndy Whitcroft } 263cc259639SAndy Whitcroft 264e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 26513cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode, 2660b269dedSAl Viro .free_inode = ovl_free_inode, 26713cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode, 26813cf199dSAmir Goldstein .drop_inode = generic_delete_inode, 269e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 270e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs, 271cc259639SAndy Whitcroft .statfs = ovl_statfs, 272f45827e8SErez Zadok .show_options = ovl_show_options, 273e9be9d5eSMiklos Szeredi }; 274e9be9d5eSMiklos Szeredi 275e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 27602bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index" 277e9be9d5eSMiklos Szeredi 278ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs, 2796b8aa129SAmir Goldstein const char *name, bool persist) 280e9be9d5eSMiklos Szeredi { 281ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode; 28208f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 283e9be9d5eSMiklos Szeredi struct dentry *work; 284e9be9d5eSMiklos Szeredi int err; 285e9be9d5eSMiklos Szeredi bool retried = false; 286e9be9d5eSMiklos Szeredi 2875955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT); 288e9be9d5eSMiklos Szeredi retry: 28922f289ceSChristian Brauner work = ovl_lookup_upper(ofs, name, ofs->workbasedir, strlen(name)); 290e9be9d5eSMiklos Szeredi 291e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 292c11b9fddSMiklos Szeredi struct iattr attr = { 293c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE, 29432a3d848SAl Viro .ia_mode = S_IFDIR | 0, 295c11b9fddSMiklos Szeredi }; 296e9be9d5eSMiklos Szeredi 297e9be9d5eSMiklos Szeredi if (work->d_inode) { 298e9be9d5eSMiklos Szeredi err = -EEXIST; 299e9be9d5eSMiklos Szeredi if (retried) 300e9be9d5eSMiklos Szeredi goto out_dput; 301e9be9d5eSMiklos Szeredi 3026b8aa129SAmir Goldstein if (persist) 3036b8aa129SAmir Goldstein goto out_unlock; 3046b8aa129SAmir Goldstein 305e9be9d5eSMiklos Szeredi retried = true; 306576bb263SChristian Brauner err = ovl_workdir_cleanup(ofs, dir, mnt, work, 0); 307e9be9d5eSMiklos Szeredi dput(work); 308235ce9edSAmir Goldstein if (err == -EINVAL) { 309235ce9edSAmir Goldstein work = ERR_PTR(err); 310235ce9edSAmir Goldstein goto out_unlock; 311235ce9edSAmir Goldstein } 312e9be9d5eSMiklos Szeredi goto retry; 313e9be9d5eSMiklos Szeredi } 314e9be9d5eSMiklos Szeredi 315576bb263SChristian Brauner err = ovl_mkdir_real(ofs, dir, &work, attr.ia_mode); 3161f5573cfSMiklos Szeredi if (err) 3171f5573cfSMiklos Szeredi goto out_dput; 3181f5573cfSMiklos Szeredi 3191f5573cfSMiklos Szeredi /* Weird filesystem returning with hashed negative (kernfs)? */ 3201f5573cfSMiklos Szeredi err = -EINVAL; 3211f5573cfSMiklos Szeredi if (d_really_is_negative(work)) 3221f5573cfSMiklos Szeredi goto out_dput; 323c11b9fddSMiklos Szeredi 324cb348edbSMiklos Szeredi /* 325cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if: 326cb348edbSMiklos Szeredi * 327cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed) 328cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr) 329cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported) 330cb348edbSMiklos Szeredi * 331cb348edbSMiklos Szeredi * There are various other error values that could effectively 332cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned 333cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems 334cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking 335cb348edbSMiklos Szeredi * for the above two errors is sufficient. 336cb348edbSMiklos Szeredi */ 33731acceb9SChristian Brauner err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_DEFAULT); 338e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 339c11b9fddSMiklos Szeredi goto out_dput; 340c11b9fddSMiklos Szeredi 34131acceb9SChristian Brauner err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_ACCESS); 342e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP) 343c11b9fddSMiklos Szeredi goto out_dput; 344c11b9fddSMiklos Szeredi 345c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */ 346c11b9fddSMiklos Szeredi inode_lock(work->d_inode); 347a15506eaSChristian Brauner err = ovl_do_notify_change(ofs, work, &attr); 348c11b9fddSMiklos Szeredi inode_unlock(work->d_inode); 349c11b9fddSMiklos Szeredi if (err) 350c11b9fddSMiklos Szeredi goto out_dput; 3516b8aa129SAmir Goldstein } else { 3526b8aa129SAmir Goldstein err = PTR_ERR(work); 3536b8aa129SAmir Goldstein goto out_err; 354e9be9d5eSMiklos Szeredi } 355e9be9d5eSMiklos Szeredi out_unlock: 3566b8aa129SAmir Goldstein inode_unlock(dir); 357e9be9d5eSMiklos Szeredi return work; 358e9be9d5eSMiklos Szeredi 359e9be9d5eSMiklos Szeredi out_dput: 360e9be9d5eSMiklos Szeredi dput(work); 3616b8aa129SAmir Goldstein out_err: 3621bd0a3aeSlijiazi pr_warn("failed to create directory %s/%s (errno: %i); mounting read-only\n", 363ad204488SMiklos Szeredi ofs->config.workdir, name, -err); 3646b8aa129SAmir Goldstein work = NULL; 365e9be9d5eSMiklos Szeredi goto out_unlock; 366e9be9d5eSMiklos Szeredi } 367e9be9d5eSMiklos Szeredi 3682d343087SAl Viro static int ovl_check_namelen(const struct path *path, struct ovl_fs *ofs, 3696b2d5fe4SMiklos Szeredi const char *name) 3706b2d5fe4SMiklos Szeredi { 3716b2d5fe4SMiklos Szeredi struct kstatfs statfs; 3726b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs); 3736b2d5fe4SMiklos Szeredi 3746b2d5fe4SMiklos Szeredi if (err) 3751bd0a3aeSlijiazi pr_err("statfs failed on '%s'\n", name); 3766b2d5fe4SMiklos Szeredi else 3776b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen); 3786b2d5fe4SMiklos Szeredi 3796b2d5fe4SMiklos Szeredi return err; 3806b2d5fe4SMiklos Szeredi } 3816b2d5fe4SMiklos Szeredi 3826b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, 383f4288844SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth) 384ab508822SMiklos Szeredi { 385e487d889SAmir Goldstein int fh_type; 386ab508822SMiklos Szeredi int err; 387ab508822SMiklos Szeredi 3886b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name); 3896b2d5fe4SMiklos Szeredi if (err) 390b8e42a65SMiklos Szeredi return err; 3916b2d5fe4SMiklos Szeredi 392ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 393ab508822SMiklos Szeredi 39402bcd157SAmir Goldstein /* 395f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode 396f168f109SAmir Goldstein * file handles, so they require that all layers support them. 39702bcd157SAmir Goldstein */ 398e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(path->dentry->d_sb); 399f168f109SAmir Goldstein if ((ofs->config.nfs_export || 400e487d889SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && !fh_type) { 40102bcd157SAmir Goldstein ofs->config.index = false; 402f168f109SAmir Goldstein ofs->config.nfs_export = false; 4031bd0a3aeSlijiazi pr_warn("fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n", 404f168f109SAmir Goldstein name); 40502bcd157SAmir Goldstein } 40616aac5adSAmir Goldstein ofs->nofh |= !fh_type; 407b0e0f697SAmir Goldstein /* 408b0e0f697SAmir Goldstein * Decoding origin file handle is required for persistent st_ino. 409b0e0f697SAmir Goldstein * Without persistent st_ino, xino=auto falls back to xino=off. 410b0e0f697SAmir Goldstein */ 411b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO && 412b0e0f697SAmir Goldstein ofs->config.upperdir && !fh_type) { 413b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 414b0e0f697SAmir Goldstein pr_warn("fs on '%s' does not support file handles, falling back to xino=off.\n", 415b0e0f697SAmir Goldstein name); 416b0e0f697SAmir Goldstein } 41702bcd157SAmir Goldstein 418e487d889SAmir Goldstein /* Check if lower fs has 32bit inode numbers */ 419e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 4200f831ec8SAmir Goldstein ofs->xino_mode = -1; 421e487d889SAmir Goldstein 422ab508822SMiklos Szeredi return 0; 423ab508822SMiklos Szeredi } 424ab508822SMiklos Szeredi 425e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 426e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 427e9be9d5eSMiklos Szeredi { 428e9be9d5eSMiklos Szeredi bool ok = false; 429e9be9d5eSMiklos Szeredi 430e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 431e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 432e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 433e9be9d5eSMiklos Szeredi } 434e9be9d5eSMiklos Szeredi return ok; 435e9be9d5eSMiklos Szeredi } 436e9be9d5eSMiklos Szeredi 4370eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler, 4380eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 4390eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 4400eb45fc3SAndreas Gruenbacher { 44148fab5d7SAmir Goldstein return -EOPNOTSUPP; 4420eb45fc3SAndreas Gruenbacher } 4430eb45fc3SAndreas Gruenbacher 444d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler, 44539f60c1cSChristian Brauner struct mnt_idmap *idmap, 446d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode, 447d837a49bSMiklos Szeredi const char *name, const void *value, 448d837a49bSMiklos Szeredi size_t size, int flags) 449d837a49bSMiklos Szeredi { 45048fab5d7SAmir Goldstein return -EOPNOTSUPP; 451d837a49bSMiklos Szeredi } 452d837a49bSMiklos Szeredi 4530eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler, 4540eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 4550eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size) 4560eb45fc3SAndreas Gruenbacher { 4571d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size); 4580eb45fc3SAndreas Gruenbacher } 4590eb45fc3SAndreas Gruenbacher 4600e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler, 46139f60c1cSChristian Brauner struct mnt_idmap *idmap, 4620e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode, 4630e585cccSAndreas Gruenbacher const char *name, const void *value, 4640e585cccSAndreas Gruenbacher size_t size, int flags) 4650e585cccSAndreas Gruenbacher { 4661d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags); 4670e585cccSAndreas Gruenbacher } 4680e585cccSAndreas Gruenbacher 4692d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_trusted_xattr_handler = { 4702d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_TRUSTED_PREFIX, 4712d2f2d73SMiklos Szeredi .get = ovl_own_xattr_get, 4722d2f2d73SMiklos Szeredi .set = ovl_own_xattr_set, 4732d2f2d73SMiklos Szeredi }; 4742d2f2d73SMiklos Szeredi 4752d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_user_xattr_handler = { 4762d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_USER_PREFIX, 4770eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get, 478d837a49bSMiklos Szeredi .set = ovl_own_xattr_set, 479d837a49bSMiklos Szeredi }; 480d837a49bSMiklos Szeredi 481d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = { 482d837a49bSMiklos Szeredi .prefix = "", /* catch all */ 4830eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get, 484d837a49bSMiklos Szeredi .set = ovl_other_xattr_set, 485d837a49bSMiklos Szeredi }; 486d837a49bSMiklos Szeredi 4872d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_trusted_xattr_handlers[] = { 4882d2f2d73SMiklos Szeredi &ovl_own_trusted_xattr_handler, 4892d2f2d73SMiklos Szeredi &ovl_other_xattr_handler, 4902d2f2d73SMiklos Szeredi NULL 4912d2f2d73SMiklos Szeredi }; 4922d2f2d73SMiklos Szeredi 4932d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_user_xattr_handlers[] = { 4942d2f2d73SMiklos Szeredi &ovl_own_user_xattr_handler, 495d837a49bSMiklos Szeredi &ovl_other_xattr_handler, 496d837a49bSMiklos Szeredi NULL 497d837a49bSMiklos Szeredi }; 498d837a49bSMiklos Szeredi 499146d62e5SAmir Goldstein static int ovl_setup_trap(struct super_block *sb, struct dentry *dir, 500146d62e5SAmir Goldstein struct inode **ptrap, const char *name) 501146d62e5SAmir Goldstein { 502146d62e5SAmir Goldstein struct inode *trap; 503146d62e5SAmir Goldstein int err; 504146d62e5SAmir Goldstein 505146d62e5SAmir Goldstein trap = ovl_get_trap_inode(sb, dir); 5061dac6f5bSArnd Bergmann err = PTR_ERR_OR_ZERO(trap); 5071dac6f5bSArnd Bergmann if (err) { 508146d62e5SAmir Goldstein if (err == -ELOOP) 5091bd0a3aeSlijiazi pr_err("conflicting %s path\n", name); 510146d62e5SAmir Goldstein return err; 511146d62e5SAmir Goldstein } 512146d62e5SAmir Goldstein 513146d62e5SAmir Goldstein *ptrap = trap; 514146d62e5SAmir Goldstein return 0; 515146d62e5SAmir Goldstein } 516146d62e5SAmir Goldstein 5170be0bfd2SAmir Goldstein /* 5180be0bfd2SAmir Goldstein * Determine how we treat concurrent use of upperdir/workdir based on the 5190be0bfd2SAmir Goldstein * index feature. This is papering over mount leaks of container runtimes, 5200be0bfd2SAmir Goldstein * for example, an old overlay mount is leaked and now its upperdir is 5210be0bfd2SAmir Goldstein * attempted to be used as a lower layer in a new overlay mount. 5220be0bfd2SAmir Goldstein */ 5230be0bfd2SAmir Goldstein static int ovl_report_in_use(struct ovl_fs *ofs, const char *name) 5240be0bfd2SAmir Goldstein { 5250be0bfd2SAmir Goldstein if (ofs->config.index) { 5261bd0a3aeSlijiazi pr_err("%s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n", 5270be0bfd2SAmir Goldstein name); 5280be0bfd2SAmir Goldstein return -EBUSY; 5290be0bfd2SAmir Goldstein } else { 5301bd0a3aeSlijiazi pr_warn("%s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n", 5310be0bfd2SAmir Goldstein name); 5320be0bfd2SAmir Goldstein return 0; 5330be0bfd2SAmir Goldstein } 5340be0bfd2SAmir Goldstein } 5350be0bfd2SAmir Goldstein 536146d62e5SAmir Goldstein static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs, 537b36a5780SChristian Brauner struct ovl_layer *upper_layer, 538b36a5780SChristian Brauner const struct path *upperpath) 5396ee8acf0SMiklos Szeredi { 5405064975eSMiklos Szeredi struct vfsmount *upper_mnt; 5416ee8acf0SMiklos Szeredi int err; 5426ee8acf0SMiklos Szeredi 543e21a6c57SAmir Goldstein /* Upperdir path should not be r/o */ 544e21a6c57SAmir Goldstein if (__mnt_is_readonly(upperpath->mnt)) { 5451bd0a3aeSlijiazi pr_err("upper fs is r/o, try multi-lower layers mount\n"); 5466ee8acf0SMiklos Szeredi err = -EINVAL; 5476ee8acf0SMiklos Szeredi goto out; 5486ee8acf0SMiklos Szeredi } 5496ee8acf0SMiklos Szeredi 550ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir); 5516ee8acf0SMiklos Szeredi if (err) 5526ee8acf0SMiklos Szeredi goto out; 5536ee8acf0SMiklos Szeredi 554b8e42a65SMiklos Szeredi err = ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap, 555146d62e5SAmir Goldstein "upperdir"); 556146d62e5SAmir Goldstein if (err) 557146d62e5SAmir Goldstein goto out; 558146d62e5SAmir Goldstein 5595064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath); 5605064975eSMiklos Szeredi err = PTR_ERR(upper_mnt); 5615064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) { 5621bd0a3aeSlijiazi pr_err("failed to clone upperpath\n"); 5635064975eSMiklos Szeredi goto out; 5645064975eSMiklos Szeredi } 5655064975eSMiklos Szeredi 5665064975eSMiklos Szeredi /* Don't inherit atime flags */ 5675064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME); 568b8e42a65SMiklos Szeredi upper_layer->mnt = upper_mnt; 569b8e42a65SMiklos Szeredi upper_layer->idx = 0; 570b8e42a65SMiklos Szeredi upper_layer->fsid = 0; 5718c25741aSMiklos Szeredi 572b36a5780SChristian Brauner err = -ENOMEM; 573b36a5780SChristian Brauner upper_layer->name = kstrdup(ofs->config.upperdir, GFP_KERNEL); 574b36a5780SChristian Brauner if (!upper_layer->name) 575b36a5780SChristian Brauner goto out; 576b36a5780SChristian Brauner 577654255faSJeffle Xu /* 578654255faSJeffle Xu * Inherit SB_NOSEC flag from upperdir. 579654255faSJeffle Xu * 580654255faSJeffle Xu * This optimization changes behavior when a security related attribute 581654255faSJeffle Xu * (suid/sgid/security.*) is changed on an underlying layer. This is 582654255faSJeffle Xu * okay because we don't yet have guarantees in that case, but it will 583654255faSJeffle Xu * need careful treatment once we want to honour changes to underlying 584654255faSJeffle Xu * filesystems. 585654255faSJeffle Xu */ 586654255faSJeffle Xu if (upper_mnt->mnt_sb->s_flags & SB_NOSEC) 587654255faSJeffle Xu sb->s_flags |= SB_NOSEC; 588654255faSJeffle Xu 58908f4c7c8SMiklos Szeredi if (ovl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) { 5908c25741aSMiklos Szeredi ofs->upperdir_locked = true; 5918c25741aSMiklos Szeredi } else { 5920be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "upperdir"); 5930be0bfd2SAmir Goldstein if (err) 5940be0bfd2SAmir Goldstein goto out; 5958c25741aSMiklos Szeredi } 5968c25741aSMiklos Szeredi 5976ee8acf0SMiklos Szeredi err = 0; 5986ee8acf0SMiklos Szeredi out: 5996ee8acf0SMiklos Szeredi return err; 6006ee8acf0SMiklos Szeredi } 6016ee8acf0SMiklos Szeredi 602cad218abSAmir Goldstein /* 603cad218abSAmir Goldstein * Returns 1 if RENAME_WHITEOUT is supported, 0 if not supported and 604cad218abSAmir Goldstein * negative values if error is encountered. 605cad218abSAmir Goldstein */ 606576bb263SChristian Brauner static int ovl_check_rename_whiteout(struct ovl_fs *ofs) 607cad218abSAmir Goldstein { 608576bb263SChristian Brauner struct dentry *workdir = ofs->workdir; 609cad218abSAmir Goldstein struct inode *dir = d_inode(workdir); 610cad218abSAmir Goldstein struct dentry *temp; 611cad218abSAmir Goldstein struct dentry *dest; 612cad218abSAmir Goldstein struct dentry *whiteout; 613cad218abSAmir Goldstein struct name_snapshot name; 614cad218abSAmir Goldstein int err; 615cad218abSAmir Goldstein 616cad218abSAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 617cad218abSAmir Goldstein 618576bb263SChristian Brauner temp = ovl_create_temp(ofs, workdir, OVL_CATTR(S_IFREG | 0)); 619cad218abSAmir Goldstein err = PTR_ERR(temp); 620cad218abSAmir Goldstein if (IS_ERR(temp)) 621cad218abSAmir Goldstein goto out_unlock; 622cad218abSAmir Goldstein 623576bb263SChristian Brauner dest = ovl_lookup_temp(ofs, workdir); 624cad218abSAmir Goldstein err = PTR_ERR(dest); 625cad218abSAmir Goldstein if (IS_ERR(dest)) { 626cad218abSAmir Goldstein dput(temp); 627cad218abSAmir Goldstein goto out_unlock; 628cad218abSAmir Goldstein } 629cad218abSAmir Goldstein 630cad218abSAmir Goldstein /* Name is inline and stable - using snapshot as a copy helper */ 631cad218abSAmir Goldstein take_dentry_name_snapshot(&name, temp); 632576bb263SChristian Brauner err = ovl_do_rename(ofs, dir, temp, dir, dest, RENAME_WHITEOUT); 633cad218abSAmir Goldstein if (err) { 634cad218abSAmir Goldstein if (err == -EINVAL) 635cad218abSAmir Goldstein err = 0; 636cad218abSAmir Goldstein goto cleanup_temp; 637cad218abSAmir Goldstein } 638cad218abSAmir Goldstein 63922f289ceSChristian Brauner whiteout = ovl_lookup_upper(ofs, name.name.name, workdir, name.name.len); 640cad218abSAmir Goldstein err = PTR_ERR(whiteout); 641cad218abSAmir Goldstein if (IS_ERR(whiteout)) 642cad218abSAmir Goldstein goto cleanup_temp; 643cad218abSAmir Goldstein 644cad218abSAmir Goldstein err = ovl_is_whiteout(whiteout); 645cad218abSAmir Goldstein 646cad218abSAmir Goldstein /* Best effort cleanup of whiteout and temp file */ 647cad218abSAmir Goldstein if (err) 648576bb263SChristian Brauner ovl_cleanup(ofs, dir, whiteout); 649cad218abSAmir Goldstein dput(whiteout); 650cad218abSAmir Goldstein 651cad218abSAmir Goldstein cleanup_temp: 652576bb263SChristian Brauner ovl_cleanup(ofs, dir, temp); 653cad218abSAmir Goldstein release_dentry_name_snapshot(&name); 654cad218abSAmir Goldstein dput(temp); 655cad218abSAmir Goldstein dput(dest); 656cad218abSAmir Goldstein 657cad218abSAmir Goldstein out_unlock: 658cad218abSAmir Goldstein inode_unlock(dir); 659cad218abSAmir Goldstein 660cad218abSAmir Goldstein return err; 661cad218abSAmir Goldstein } 662cad218abSAmir Goldstein 663576bb263SChristian Brauner static struct dentry *ovl_lookup_or_create(struct ovl_fs *ofs, 664576bb263SChristian Brauner struct dentry *parent, 665c86243b0SVivek Goyal const char *name, umode_t mode) 666c86243b0SVivek Goyal { 667c86243b0SVivek Goyal size_t len = strlen(name); 668c86243b0SVivek Goyal struct dentry *child; 669c86243b0SVivek Goyal 670c86243b0SVivek Goyal inode_lock_nested(parent->d_inode, I_MUTEX_PARENT); 67122f289ceSChristian Brauner child = ovl_lookup_upper(ofs, name, parent, len); 672c86243b0SVivek Goyal if (!IS_ERR(child) && !child->d_inode) 673576bb263SChristian Brauner child = ovl_create_real(ofs, parent->d_inode, child, 674c86243b0SVivek Goyal OVL_CATTR(mode)); 675c86243b0SVivek Goyal inode_unlock(parent->d_inode); 676c86243b0SVivek Goyal dput(parent); 677c86243b0SVivek Goyal 678c86243b0SVivek Goyal return child; 679c86243b0SVivek Goyal } 680c86243b0SVivek Goyal 681c86243b0SVivek Goyal /* 682c86243b0SVivek Goyal * Creates $workdir/work/incompat/volatile/dirty file if it is not already 683c86243b0SVivek Goyal * present. 684c86243b0SVivek Goyal */ 685c86243b0SVivek Goyal static int ovl_create_volatile_dirty(struct ovl_fs *ofs) 686c86243b0SVivek Goyal { 687c86243b0SVivek Goyal unsigned int ctr; 688c86243b0SVivek Goyal struct dentry *d = dget(ofs->workbasedir); 689c86243b0SVivek Goyal static const char *const volatile_path[] = { 690c86243b0SVivek Goyal OVL_WORKDIR_NAME, "incompat", "volatile", "dirty" 691c86243b0SVivek Goyal }; 692c86243b0SVivek Goyal const char *const *name = volatile_path; 693c86243b0SVivek Goyal 694c86243b0SVivek Goyal for (ctr = ARRAY_SIZE(volatile_path); ctr; ctr--, name++) { 695576bb263SChristian Brauner d = ovl_lookup_or_create(ofs, d, *name, ctr > 1 ? S_IFDIR : S_IFREG); 696c86243b0SVivek Goyal if (IS_ERR(d)) 697c86243b0SVivek Goyal return PTR_ERR(d); 698c86243b0SVivek Goyal } 699c86243b0SVivek Goyal dput(d); 700c86243b0SVivek Goyal return 0; 701c86243b0SVivek Goyal } 702c86243b0SVivek Goyal 703146d62e5SAmir Goldstein static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs, 7042d343087SAl Viro const struct path *workpath) 7058ed61dc3SMiklos Szeredi { 70608f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 7072b1a7746SMiklos Szeredi struct dentry *workdir; 7082b1a7746SMiklos Szeredi struct file *tmpfile; 709d80172c2SAmir Goldstein bool rename_whiteout; 710d80172c2SAmir Goldstein bool d_type; 711e487d889SAmir Goldstein int fh_type; 7128ed61dc3SMiklos Szeredi int err; 7138ed61dc3SMiklos Szeredi 7142ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 7152ba9d57eSAmir Goldstein if (err) 7162ba9d57eSAmir Goldstein return err; 7172ba9d57eSAmir Goldstein 718235ce9edSAmir Goldstein workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false); 719235ce9edSAmir Goldstein err = PTR_ERR(workdir); 720235ce9edSAmir Goldstein if (IS_ERR_OR_NULL(workdir)) 7212ba9d57eSAmir Goldstein goto out; 7228ed61dc3SMiklos Szeredi 723235ce9edSAmir Goldstein ofs->workdir = workdir; 724235ce9edSAmir Goldstein 725146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir"); 726146d62e5SAmir Goldstein if (err) 727146d62e5SAmir Goldstein goto out; 728146d62e5SAmir Goldstein 7298ed61dc3SMiklos Szeredi /* 7308ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given 7318ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on 7328ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in 7338ed61dc3SMiklos Szeredi * previous step. 7348ed61dc3SMiklos Szeredi */ 7358ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath); 7368ed61dc3SMiklos Szeredi if (err < 0) 7372ba9d57eSAmir Goldstein goto out; 7388ed61dc3SMiklos Szeredi 739d80172c2SAmir Goldstein d_type = err; 740d80172c2SAmir Goldstein if (!d_type) 7411bd0a3aeSlijiazi pr_warn("upper fs needs to support d_type.\n"); 7428ed61dc3SMiklos Szeredi 7438ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */ 7442b1a7746SMiklos Szeredi tmpfile = ovl_do_tmpfile(ofs, ofs->workdir, S_IFREG | 0); 7452b1a7746SMiklos Szeredi ofs->tmpfile = !IS_ERR(tmpfile); 746ad204488SMiklos Szeredi if (ofs->tmpfile) 7472b1a7746SMiklos Szeredi fput(tmpfile); 7488ed61dc3SMiklos Szeredi else 7491bd0a3aeSlijiazi pr_warn("upper fs does not support tmpfile.\n"); 7508ed61dc3SMiklos Szeredi 751cad218abSAmir Goldstein 752cad218abSAmir Goldstein /* Check if upper/work fs supports RENAME_WHITEOUT */ 753576bb263SChristian Brauner err = ovl_check_rename_whiteout(ofs); 754cad218abSAmir Goldstein if (err < 0) 755cad218abSAmir Goldstein goto out; 756cad218abSAmir Goldstein 757d80172c2SAmir Goldstein rename_whiteout = err; 758d80172c2SAmir Goldstein if (!rename_whiteout) 759cad218abSAmir Goldstein pr_warn("upper fs does not support RENAME_WHITEOUT.\n"); 760cad218abSAmir Goldstein 7618ed61dc3SMiklos Szeredi /* 7622d2f2d73SMiklos Szeredi * Check if upper/work fs supports (trusted|user).overlay.* xattr 7638ed61dc3SMiklos Szeredi */ 764c914c0e2SAmir Goldstein err = ovl_setxattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE, "0", 1); 7658ed61dc3SMiklos Szeredi if (err) { 766b10b85feSMiklos Szeredi pr_warn("failed to set xattr on upper\n"); 767ad204488SMiklos Szeredi ofs->noxattr = true; 768af5f2396SAmir Goldstein if (ovl_redirect_follow(ofs)) { 769af5f2396SAmir Goldstein ofs->config.redirect_mode = OVL_REDIRECT_NOFOLLOW; 770af5f2396SAmir Goldstein pr_warn("...falling back to redirect_dir=nofollow.\n"); 771af5f2396SAmir Goldstein } 772af5f2396SAmir Goldstein if (ofs->config.metacopy) { 773d5791044SVivek Goyal ofs->config.metacopy = false; 774af5f2396SAmir Goldstein pr_warn("...falling back to metacopy=off.\n"); 775af5f2396SAmir Goldstein } 776af5f2396SAmir Goldstein if (ofs->config.index) { 777af5f2396SAmir Goldstein ofs->config.index = false; 778af5f2396SAmir Goldstein pr_warn("...falling back to index=off.\n"); 779b0e0f697SAmir Goldstein } 780d9544c1bSAmir Goldstein if (ovl_has_fsid(ofs)) { 781d9544c1bSAmir Goldstein ofs->config.uuid = OVL_UUID_NULL; 782d9544c1bSAmir Goldstein pr_warn("...falling back to uuid=null.\n"); 783d9544c1bSAmir Goldstein } 784b0e0f697SAmir Goldstein /* 785b0e0f697SAmir Goldstein * xattr support is required for persistent st_ino. 786b0e0f697SAmir Goldstein * Without persistent st_ino, xino=auto falls back to xino=off. 787b0e0f697SAmir Goldstein */ 788b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO) { 789b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 790b10b85feSMiklos Szeredi pr_warn("...falling back to xino=off.\n"); 791b0e0f697SAmir Goldstein } 792b10b85feSMiklos Szeredi if (err == -EPERM && !ofs->config.userxattr) 793b10b85feSMiklos Szeredi pr_info("try mounting with 'userxattr' option\n"); 7942ba9d57eSAmir Goldstein err = 0; 7958ed61dc3SMiklos Szeredi } else { 796c914c0e2SAmir Goldstein ovl_removexattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE); 7978ed61dc3SMiklos Szeredi } 7988ed61dc3SMiklos Szeredi 799d80172c2SAmir Goldstein /* 800d80172c2SAmir Goldstein * We allowed sub-optimal upper fs configuration and don't want to break 801d80172c2SAmir Goldstein * users over kernel upgrade, but we never allowed remote upper fs, so 802d80172c2SAmir Goldstein * we can enforce strict requirements for remote upper fs. 803d80172c2SAmir Goldstein */ 804d80172c2SAmir Goldstein if (ovl_dentry_remote(ofs->workdir) && 805d80172c2SAmir Goldstein (!d_type || !rename_whiteout || ofs->noxattr)) { 806d80172c2SAmir Goldstein pr_err("upper fs missing required features.\n"); 807d80172c2SAmir Goldstein err = -EINVAL; 808d80172c2SAmir Goldstein goto out; 809d80172c2SAmir Goldstein } 810d80172c2SAmir Goldstein 811c86243b0SVivek Goyal /* 812c86243b0SVivek Goyal * For volatile mount, create a incompat/volatile/dirty file to keep 813c86243b0SVivek Goyal * track of it. 814c86243b0SVivek Goyal */ 815c86243b0SVivek Goyal if (ofs->config.ovl_volatile) { 816c86243b0SVivek Goyal err = ovl_create_volatile_dirty(ofs); 817c86243b0SVivek Goyal if (err < 0) { 818c86243b0SVivek Goyal pr_err("Failed to create volatile/dirty file.\n"); 819c86243b0SVivek Goyal goto out; 820c86243b0SVivek Goyal } 821c86243b0SVivek Goyal } 822c86243b0SVivek Goyal 8238ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */ 824e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(ofs->workdir->d_sb); 825e487d889SAmir Goldstein if (ofs->config.index && !fh_type) { 826ad204488SMiklos Szeredi ofs->config.index = false; 8271bd0a3aeSlijiazi pr_warn("upper fs does not support file handles, falling back to index=off.\n"); 8288ed61dc3SMiklos Szeredi } 82916aac5adSAmir Goldstein ofs->nofh |= !fh_type; 8308ed61dc3SMiklos Szeredi 831e487d889SAmir Goldstein /* Check if upper fs has 32bit inode numbers */ 832e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN) 8330f831ec8SAmir Goldstein ofs->xino_mode = -1; 834e487d889SAmir Goldstein 835f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */ 836f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) { 8371bd0a3aeSlijiazi pr_warn("NFS export requires \"index=on\", falling back to nfs_export=off.\n"); 838f168f109SAmir Goldstein ofs->config.nfs_export = false; 839f168f109SAmir Goldstein } 8402ba9d57eSAmir Goldstein out: 8412ba9d57eSAmir Goldstein mnt_drop_write(mnt); 8422ba9d57eSAmir Goldstein return err; 8438ed61dc3SMiklos Szeredi } 8448ed61dc3SMiklos Szeredi 845146d62e5SAmir Goldstein static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs, 846b36a5780SChristian Brauner const struct path *upperpath, 847b36a5780SChristian Brauner const struct path *workpath) 848520d7c86SMiklos Szeredi { 849520d7c86SMiklos Szeredi int err; 850520d7c86SMiklos Szeredi 851520d7c86SMiklos Szeredi err = -EINVAL; 852b36a5780SChristian Brauner if (upperpath->mnt != workpath->mnt) { 8531bd0a3aeSlijiazi pr_err("workdir and upperdir must reside under the same mount\n"); 854b36a5780SChristian Brauner return err; 855520d7c86SMiklos Szeredi } 856b36a5780SChristian Brauner if (!ovl_workdir_ok(workpath->dentry, upperpath->dentry)) { 8571bd0a3aeSlijiazi pr_err("workdir and upperdir must be separate subtrees\n"); 858b36a5780SChristian Brauner return err; 859520d7c86SMiklos Szeredi } 860520d7c86SMiklos Szeredi 861b36a5780SChristian Brauner ofs->workbasedir = dget(workpath->dentry); 8628c25741aSMiklos Szeredi 8638c25741aSMiklos Szeredi if (ovl_inuse_trylock(ofs->workbasedir)) { 864ad204488SMiklos Szeredi ofs->workdir_locked = true; 865520d7c86SMiklos Szeredi } else { 8660be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "workdir"); 8670be0bfd2SAmir Goldstein if (err) 868b36a5780SChristian Brauner return err; 869520d7c86SMiklos Szeredi } 870520d7c86SMiklos Szeredi 8710be0bfd2SAmir Goldstein err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap, 8720be0bfd2SAmir Goldstein "workdir"); 8730be0bfd2SAmir Goldstein if (err) 874520d7c86SMiklos Szeredi return err; 875b36a5780SChristian Brauner 876b36a5780SChristian Brauner return ovl_make_workdir(sb, ofs, workpath); 877520d7c86SMiklos Szeredi } 878520d7c86SMiklos Szeredi 879146d62e5SAmir Goldstein static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs, 8802d343087SAl Viro struct ovl_entry *oe, const struct path *upperpath) 881f7e3a7d9SMiklos Szeredi { 88208f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs); 883235ce9edSAmir Goldstein struct dentry *indexdir; 884f7e3a7d9SMiklos Szeredi int err; 885f7e3a7d9SMiklos Szeredi 8862ba9d57eSAmir Goldstein err = mnt_want_write(mnt); 8872ba9d57eSAmir Goldstein if (err) 8882ba9d57eSAmir Goldstein return err; 8892ba9d57eSAmir Goldstein 890f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */ 891610afc0bSMiklos Szeredi err = ovl_verify_origin(ofs, upperpath->dentry, 8925522c9c7SAmir Goldstein ovl_lowerstack(oe)->dentry, true); 893f7e3a7d9SMiklos Szeredi if (err) { 8941bd0a3aeSlijiazi pr_err("failed to verify upper root origin\n"); 895f7e3a7d9SMiklos Szeredi goto out; 896f7e3a7d9SMiklos Szeredi } 897f7e3a7d9SMiklos Szeredi 89820396365SAmir Goldstein /* index dir will act also as workdir */ 89920396365SAmir Goldstein iput(ofs->workdir_trap); 90020396365SAmir Goldstein ofs->workdir_trap = NULL; 90120396365SAmir Goldstein dput(ofs->workdir); 902470c1563SAmir Goldstein ofs->workdir = NULL; 903235ce9edSAmir Goldstein indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true); 904235ce9edSAmir Goldstein if (IS_ERR(indexdir)) { 905235ce9edSAmir Goldstein err = PTR_ERR(indexdir); 906235ce9edSAmir Goldstein } else if (indexdir) { 907235ce9edSAmir Goldstein ofs->indexdir = indexdir; 908235ce9edSAmir Goldstein ofs->workdir = dget(indexdir); 90920396365SAmir Goldstein 910146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap, 911146d62e5SAmir Goldstein "indexdir"); 912146d62e5SAmir Goldstein if (err) 913146d62e5SAmir Goldstein goto out; 914146d62e5SAmir Goldstein 915ad1d615cSAmir Goldstein /* 916ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir. 9172d2f2d73SMiklos Szeredi * Older kernels stored upper fh in ".overlay.origin" 918ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to 919ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr 9202d2f2d73SMiklos Szeredi * ".overlay.upper" to indicate that index may have 921ad1d615cSAmir Goldstein * directory entries. 922ad1d615cSAmir Goldstein */ 923610afc0bSMiklos Szeredi if (ovl_check_origin_xattr(ofs, ofs->indexdir)) { 924610afc0bSMiklos Szeredi err = ovl_verify_set_fh(ofs, ofs->indexdir, 925610afc0bSMiklos Szeredi OVL_XATTR_ORIGIN, 926ad1d615cSAmir Goldstein upperpath->dentry, true, false); 927f7e3a7d9SMiklos Szeredi if (err) 9281bd0a3aeSlijiazi pr_err("failed to verify index dir 'origin' xattr\n"); 929ad1d615cSAmir Goldstein } 930610afc0bSMiklos Szeredi err = ovl_verify_upper(ofs, ofs->indexdir, upperpath->dentry, 931610afc0bSMiklos Szeredi true); 932ad1d615cSAmir Goldstein if (err) 9331bd0a3aeSlijiazi pr_err("failed to verify index dir 'upper' xattr\n"); 934f7e3a7d9SMiklos Szeredi 935f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */ 936f7e3a7d9SMiklos Szeredi if (!err) 9371eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs); 938f7e3a7d9SMiklos Szeredi } 939ad204488SMiklos Szeredi if (err || !ofs->indexdir) 9401bd0a3aeSlijiazi pr_warn("try deleting index dir or mounting with '-o index=off' to disable inodes index.\n"); 941f7e3a7d9SMiklos Szeredi 942f7e3a7d9SMiklos Szeredi out: 9432ba9d57eSAmir Goldstein mnt_drop_write(mnt); 944f7e3a7d9SMiklos Szeredi return err; 945f7e3a7d9SMiklos Szeredi } 946f7e3a7d9SMiklos Szeredi 9479df085f3SAmir Goldstein static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid) 9485148626bSAmir Goldstein { 9495148626bSAmir Goldstein unsigned int i; 9509df085f3SAmir Goldstein 95108f4c7c8SMiklos Szeredi if (!ofs->config.nfs_export && !ovl_upper_mnt(ofs)) 9529df085f3SAmir Goldstein return true; 9539df085f3SAmir Goldstein 954a888db31SAmir Goldstein /* 955a888db31SAmir Goldstein * We allow using single lower with null uuid for index and nfs_export 956a888db31SAmir Goldstein * for example to support those features with single lower squashfs. 957a888db31SAmir Goldstein * To avoid regressions in setups of overlay with re-formatted lower 958a888db31SAmir Goldstein * squashfs, do not allow decoding origin with lower null uuid unless 959a888db31SAmir Goldstein * user opted-in to one of the new features that require following the 960a888db31SAmir Goldstein * lower inode of non-dir upper. 961a888db31SAmir Goldstein */ 962ca45275cSVyacheslav Yurkov if (ovl_allow_offline_changes(ofs) && uuid_is_null(uuid)) 963a888db31SAmir Goldstein return false; 964a888db31SAmir Goldstein 9651b81ddddSAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 9669df085f3SAmir Goldstein /* 9679df085f3SAmir Goldstein * We use uuid to associate an overlay lower file handle with a 9689df085f3SAmir Goldstein * lower layer, so we can accept lower fs with null uuid as long 9699df085f3SAmir Goldstein * as all lower layers with null uuid are on the same fs. 9707e63c87fSAmir Goldstein * if we detect multiple lower fs with the same uuid, we 9717e63c87fSAmir Goldstein * disable lower file handle decoding on all of them. 9729df085f3SAmir Goldstein */ 9731b81ddddSAmir Goldstein if (ofs->fs[i].is_lower && 9741b81ddddSAmir Goldstein uuid_equal(&ofs->fs[i].sb->s_uuid, uuid)) { 97507f1e596SAmir Goldstein ofs->fs[i].bad_uuid = true; 9769df085f3SAmir Goldstein return false; 9779df085f3SAmir Goldstein } 9787e63c87fSAmir Goldstein } 9799df085f3SAmir Goldstein return true; 9809df085f3SAmir Goldstein } 9819df085f3SAmir Goldstein 9829df085f3SAmir Goldstein /* Get a unique fsid for the layer */ 9839df085f3SAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) 9849df085f3SAmir Goldstein { 9859df085f3SAmir Goldstein struct super_block *sb = path->mnt->mnt_sb; 9869df085f3SAmir Goldstein unsigned int i; 9875148626bSAmir Goldstein dev_t dev; 9885148626bSAmir Goldstein int err; 9897e63c87fSAmir Goldstein bool bad_uuid = false; 990b0e0f697SAmir Goldstein bool warn = false; 9915148626bSAmir Goldstein 99207f1e596SAmir Goldstein for (i = 0; i < ofs->numfs; i++) { 99307f1e596SAmir Goldstein if (ofs->fs[i].sb == sb) 99407f1e596SAmir Goldstein return i; 9955148626bSAmir Goldstein } 9965148626bSAmir Goldstein 9979df085f3SAmir Goldstein if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) { 9987e63c87fSAmir Goldstein bad_uuid = true; 999b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO) { 1000b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 1001b0e0f697SAmir Goldstein warn = true; 1002b0e0f697SAmir Goldstein } 10037e63c87fSAmir Goldstein if (ofs->config.index || ofs->config.nfs_export) { 10049df085f3SAmir Goldstein ofs->config.index = false; 10059df085f3SAmir Goldstein ofs->config.nfs_export = false; 1006b0e0f697SAmir Goldstein warn = true; 1007b0e0f697SAmir Goldstein } 1008b0e0f697SAmir Goldstein if (warn) { 1009b0e0f697SAmir Goldstein pr_warn("%s uuid detected in lower fs '%pd2', falling back to xino=%s,index=off,nfs_export=off.\n", 10107e63c87fSAmir Goldstein uuid_is_null(&sb->s_uuid) ? "null" : 10117e63c87fSAmir Goldstein "conflicting", 1012dcb399deSAmir Goldstein path->dentry, ovl_xino_mode(&ofs->config)); 10139df085f3SAmir Goldstein } 10147e63c87fSAmir Goldstein } 10159df085f3SAmir Goldstein 10165148626bSAmir Goldstein err = get_anon_bdev(&dev); 10175148626bSAmir Goldstein if (err) { 10181bd0a3aeSlijiazi pr_err("failed to get anonymous bdev for lowerpath\n"); 10195148626bSAmir Goldstein return err; 10205148626bSAmir Goldstein } 10215148626bSAmir Goldstein 102207f1e596SAmir Goldstein ofs->fs[ofs->numfs].sb = sb; 102307f1e596SAmir Goldstein ofs->fs[ofs->numfs].pseudo_dev = dev; 102407f1e596SAmir Goldstein ofs->fs[ofs->numfs].bad_uuid = bad_uuid; 10255148626bSAmir Goldstein 102607f1e596SAmir Goldstein return ofs->numfs++; 10275148626bSAmir Goldstein } 10285148626bSAmir Goldstein 102937ebf056SAmir Goldstein /* 103037ebf056SAmir Goldstein * The fsid after the last lower fsid is used for the data layers. 103137ebf056SAmir Goldstein * It is a "null fs" with a null sb, null uuid, and no pseudo dev. 103237ebf056SAmir Goldstein */ 103337ebf056SAmir Goldstein static int ovl_get_data_fsid(struct ovl_fs *ofs) 103437ebf056SAmir Goldstein { 103537ebf056SAmir Goldstein return ofs->numfs; 103637ebf056SAmir Goldstein } 103737ebf056SAmir Goldstein 103837ebf056SAmir Goldstein 103994375f9dSAmir Goldstein static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, 1040b36a5780SChristian Brauner struct ovl_fs_context *ctx, struct ovl_layer *layers) 1041520d7c86SMiklos Szeredi { 1042520d7c86SMiklos Szeredi int err; 1043520d7c86SMiklos Szeredi unsigned int i; 1044b36a5780SChristian Brauner size_t nr_merged_lower; 1045520d7c86SMiklos Szeredi 1046b36a5780SChristian Brauner ofs->fs = kcalloc(ctx->nr + 2, sizeof(struct ovl_sb), GFP_KERNEL); 104707f1e596SAmir Goldstein if (ofs->fs == NULL) 10489e88f905SAmir Goldstein return -ENOMEM; 10495148626bSAmir Goldstein 105037ebf056SAmir Goldstein /* 105137ebf056SAmir Goldstein * idx/fsid 0 are reserved for upper fs even with lower only overlay 105237ebf056SAmir Goldstein * and the last fsid is reserved for "null fs" of the data layers. 105337ebf056SAmir Goldstein */ 105407f1e596SAmir Goldstein ofs->numfs++; 105507f1e596SAmir Goldstein 105607f1e596SAmir Goldstein /* 1057b7bf9908SAmir Goldstein * All lower layers that share the same fs as upper layer, use the same 1058b7bf9908SAmir Goldstein * pseudo_dev as upper layer. Allocate fs[0].pseudo_dev even for lower 1059b7bf9908SAmir Goldstein * only overlay to simplify ovl_fs_free(). 10601b81ddddSAmir Goldstein * is_lower will be set if upper fs is shared with a lower layer. 106107f1e596SAmir Goldstein */ 1062b7bf9908SAmir Goldstein err = get_anon_bdev(&ofs->fs[0].pseudo_dev); 1063b7bf9908SAmir Goldstein if (err) { 1064b7bf9908SAmir Goldstein pr_err("failed to get anonymous bdev for upper fs\n"); 10659e88f905SAmir Goldstein return err; 1066b7bf9908SAmir Goldstein } 1067b7bf9908SAmir Goldstein 106808f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 106908f4c7c8SMiklos Szeredi ofs->fs[0].sb = ovl_upper_mnt(ofs)->mnt_sb; 10701b81ddddSAmir Goldstein ofs->fs[0].is_lower = false; 107107f1e596SAmir Goldstein } 107207f1e596SAmir Goldstein 1073b36a5780SChristian Brauner nr_merged_lower = ctx->nr - ctx->nr_data; 1074b36a5780SChristian Brauner for (i = 0; i < ctx->nr; i++) { 1075b36a5780SChristian Brauner struct ovl_fs_context_layer *l = &ctx->lower[i]; 1076520d7c86SMiklos Szeredi struct vfsmount *mnt; 1077146d62e5SAmir Goldstein struct inode *trap; 10785148626bSAmir Goldstein int fsid; 1079520d7c86SMiklos Szeredi 1080b36a5780SChristian Brauner if (i < nr_merged_lower) 1081b36a5780SChristian Brauner fsid = ovl_get_fsid(ofs, &l->path); 108237ebf056SAmir Goldstein else 108337ebf056SAmir Goldstein fsid = ovl_get_data_fsid(ofs); 10849e88f905SAmir Goldstein if (fsid < 0) 10859e88f905SAmir Goldstein return fsid; 1086520d7c86SMiklos Szeredi 108724f14009Syoungjun /* 108824f14009Syoungjun * Check if lower root conflicts with this overlay layers before 108924f14009Syoungjun * checking if it is in-use as upperdir/workdir of "another" 109024f14009Syoungjun * mount, because we do not bother to check in ovl_is_inuse() if 109124f14009Syoungjun * the upperdir/workdir is in fact in-use by our 109224f14009Syoungjun * upperdir/workdir. 109324f14009Syoungjun */ 1094b36a5780SChristian Brauner err = ovl_setup_trap(sb, l->path.dentry, &trap, "lowerdir"); 1095146d62e5SAmir Goldstein if (err) 10969e88f905SAmir Goldstein return err; 1097146d62e5SAmir Goldstein 1098b36a5780SChristian Brauner if (ovl_is_inuse(l->path.dentry)) { 10990be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "lowerdir"); 110024f14009Syoungjun if (err) { 110124f14009Syoungjun iput(trap); 11029e88f905SAmir Goldstein return err; 11030be0bfd2SAmir Goldstein } 110424f14009Syoungjun } 11050be0bfd2SAmir Goldstein 1106b36a5780SChristian Brauner mnt = clone_private_mount(&l->path); 1107520d7c86SMiklos Szeredi err = PTR_ERR(mnt); 1108520d7c86SMiklos Szeredi if (IS_ERR(mnt)) { 11091bd0a3aeSlijiazi pr_err("failed to clone lowerpath\n"); 1110146d62e5SAmir Goldstein iput(trap); 11119e88f905SAmir Goldstein return err; 1112520d7c86SMiklos Szeredi } 11135148626bSAmir Goldstein 1114520d7c86SMiklos Szeredi /* 1115520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file 1116520d7c86SMiklos Szeredi * will fail instead of modifying lower fs. 1117520d7c86SMiklos Szeredi */ 1118520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME; 1119520d7c86SMiklos Szeredi 112013464165SMiklos Szeredi layers[ofs->numlayer].trap = trap; 112113464165SMiklos Szeredi layers[ofs->numlayer].mnt = mnt; 112213464165SMiklos Szeredi layers[ofs->numlayer].idx = ofs->numlayer; 112313464165SMiklos Szeredi layers[ofs->numlayer].fsid = fsid; 112413464165SMiklos Szeredi layers[ofs->numlayer].fs = &ofs->fs[fsid]; 1125b36a5780SChristian Brauner layers[ofs->numlayer].name = l->name; 1126b36a5780SChristian Brauner l->name = NULL; 112794375f9dSAmir Goldstein ofs->numlayer++; 11281b81ddddSAmir Goldstein ofs->fs[fsid].is_lower = true; 1129520d7c86SMiklos Szeredi } 1130e487d889SAmir Goldstein 1131795939a9SAmir Goldstein /* 1132795939a9SAmir Goldstein * When all layers on same fs, overlay can use real inode numbers. 1133926e94d7SAmir Goldstein * With mount option "xino=<on|auto>", mounter declares that there are 1134926e94d7SAmir Goldstein * enough free high bits in underlying fs to hold the unique fsid. 1135795939a9SAmir Goldstein * If overlayfs does encounter underlying inodes using the high xino 1136795939a9SAmir Goldstein * bits reserved for fsid, it emits a warning and uses the original 1137dfe51d47SAmir Goldstein * inode number or a non persistent inode number allocated from a 1138dfe51d47SAmir Goldstein * dedicated range. 1139795939a9SAmir Goldstein */ 114008f4c7c8SMiklos Szeredi if (ofs->numfs - !ovl_upper_mnt(ofs) == 1) { 11410f831ec8SAmir Goldstein if (ofs->config.xino == OVL_XINO_ON) 11420f831ec8SAmir Goldstein pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n"); 11430f831ec8SAmir Goldstein ofs->xino_mode = 0; 114453afcd31SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_OFF) { 114553afcd31SAmir Goldstein ofs->xino_mode = -1; 1146926e94d7SAmir Goldstein } else if (ofs->xino_mode < 0) { 1147795939a9SAmir Goldstein /* 114807f1e596SAmir Goldstein * This is a roundup of number of bits needed for encoding 1149dfe51d47SAmir Goldstein * fsid, where fsid 0 is reserved for upper fs (even with 1150dfe51d47SAmir Goldstein * lower only overlay) +1 extra bit is reserved for the non 1151dfe51d47SAmir Goldstein * persistent inode number range that is used for resolving 1152dfe51d47SAmir Goldstein * xino lower bits overflow. 1153795939a9SAmir Goldstein */ 1154dfe51d47SAmir Goldstein BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 30); 1155dfe51d47SAmir Goldstein ofs->xino_mode = ilog2(ofs->numfs - 1) + 2; 1156795939a9SAmir Goldstein } 1157795939a9SAmir Goldstein 11580f831ec8SAmir Goldstein if (ofs->xino_mode > 0) { 11591bd0a3aeSlijiazi pr_info("\"xino\" feature enabled using %d upper inode bits.\n", 11600f831ec8SAmir Goldstein ofs->xino_mode); 1161795939a9SAmir Goldstein } 1162e487d889SAmir Goldstein 11639e88f905SAmir Goldstein return 0; 1164520d7c86SMiklos Szeredi } 1165520d7c86SMiklos Szeredi 11664155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb, 1167b36a5780SChristian Brauner struct ovl_fs_context *ctx, 1168b36a5780SChristian Brauner struct ovl_fs *ofs, 1169b36a5780SChristian Brauner struct ovl_layer *layers) 117053dbb0b4SMiklos Szeredi { 117153dbb0b4SMiklos Szeredi int err; 1172b8e42a65SMiklos Szeredi unsigned int i; 1173b36a5780SChristian Brauner size_t nr_merged_lower; 11744155c10aSMiklos Szeredi struct ovl_entry *oe; 1175b36a5780SChristian Brauner struct ovl_path *lowerstack; 117653dbb0b4SMiklos Szeredi 1177b36a5780SChristian Brauner struct ovl_fs_context_layer *l; 1178b36a5780SChristian Brauner 1179b36a5780SChristian Brauner if (!ofs->config.upperdir && ctx->nr == 1) { 11801bd0a3aeSlijiazi pr_err("at least 2 lowerdir are needed while upperdir nonexistent\n"); 1181b8e42a65SMiklos Szeredi return ERR_PTR(-EINVAL); 118253dbb0b4SMiklos Szeredi } 118353dbb0b4SMiklos Szeredi 118437ebf056SAmir Goldstein err = -EINVAL; 1185b36a5780SChristian Brauner for (i = 0; i < ctx->nr; i++) { 1186b36a5780SChristian Brauner l = &ctx->lower[i]; 118737ebf056SAmir Goldstein 1188b36a5780SChristian Brauner err = ovl_lower_dir(l->name, &l->path, ofs, &sb->s_stack_depth); 1189b36a5780SChristian Brauner if (err) 1190b36a5780SChristian Brauner return ERR_PTR(err); 119153dbb0b4SMiklos Szeredi } 119253dbb0b4SMiklos Szeredi 119353dbb0b4SMiklos Szeredi err = -EINVAL; 119453dbb0b4SMiklos Szeredi sb->s_stack_depth++; 119553dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 11961bd0a3aeSlijiazi pr_err("maximum fs stacking depth exceeded\n"); 1197b36a5780SChristian Brauner return ERR_PTR(err); 119853dbb0b4SMiklos Szeredi } 119953dbb0b4SMiklos Szeredi 1200b36a5780SChristian Brauner err = ovl_get_layers(sb, ofs, ctx, layers); 12014155c10aSMiklos Szeredi if (err) 1202b36a5780SChristian Brauner return ERR_PTR(err); 12034155c10aSMiklos Szeredi 12044155c10aSMiklos Szeredi err = -ENOMEM; 120537ebf056SAmir Goldstein /* Data-only layers are not merged in root directory */ 1206b36a5780SChristian Brauner nr_merged_lower = ctx->nr - ctx->nr_data; 1207b36a5780SChristian Brauner oe = ovl_alloc_entry(nr_merged_lower); 12084155c10aSMiklos Szeredi if (!oe) 1209b36a5780SChristian Brauner return ERR_PTR(err); 12104155c10aSMiklos Szeredi 12115522c9c7SAmir Goldstein lowerstack = ovl_lowerstack(oe); 1212b36a5780SChristian Brauner for (i = 0; i < nr_merged_lower; i++) { 1213b36a5780SChristian Brauner l = &ctx->lower[i]; 1214b36a5780SChristian Brauner lowerstack[i].dentry = dget(l->path.dentry); 12155522c9c7SAmir Goldstein lowerstack[i].layer = &ofs->layers[i + 1]; 12164155c10aSMiklos Szeredi } 1217b36a5780SChristian Brauner ofs->numdatalayer = ctx->nr_data; 12184155c10aSMiklos Szeredi 12194155c10aSMiklos Szeredi return oe; 122053dbb0b4SMiklos Szeredi } 122153dbb0b4SMiklos Szeredi 1222146d62e5SAmir Goldstein /* 1223146d62e5SAmir Goldstein * Check if this layer root is a descendant of: 1224146d62e5SAmir Goldstein * - another layer of this overlayfs instance 1225146d62e5SAmir Goldstein * - upper/work dir of any overlayfs instance 1226146d62e5SAmir Goldstein */ 12270be0bfd2SAmir Goldstein static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs, 1228708fa015SMiklos Szeredi struct dentry *dentry, const char *name, 1229708fa015SMiklos Szeredi bool is_lower) 1230146d62e5SAmir Goldstein { 12319179c21dSMiklos Szeredi struct dentry *next = dentry, *parent; 1232146d62e5SAmir Goldstein int err = 0; 1233146d62e5SAmir Goldstein 12349179c21dSMiklos Szeredi if (!dentry) 1235146d62e5SAmir Goldstein return 0; 1236146d62e5SAmir Goldstein 1237146d62e5SAmir Goldstein parent = dget_parent(next); 12389179c21dSMiklos Szeredi 12399179c21dSMiklos Szeredi /* Walk back ancestors to root (inclusive) looking for traps */ 12409179c21dSMiklos Szeredi while (!err && parent != next) { 1241708fa015SMiklos Szeredi if (is_lower && ovl_lookup_trap_inode(sb, parent)) { 1242146d62e5SAmir Goldstein err = -ELOOP; 12431bd0a3aeSlijiazi pr_err("overlapping %s path\n", name); 12440be0bfd2SAmir Goldstein } else if (ovl_is_inuse(parent)) { 12450be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, name); 1246146d62e5SAmir Goldstein } 1247146d62e5SAmir Goldstein next = parent; 12489179c21dSMiklos Szeredi parent = dget_parent(next); 12499179c21dSMiklos Szeredi dput(next); 1250146d62e5SAmir Goldstein } 1251146d62e5SAmir Goldstein 12529179c21dSMiklos Szeredi dput(parent); 1253146d62e5SAmir Goldstein 1254146d62e5SAmir Goldstein return err; 1255146d62e5SAmir Goldstein } 1256146d62e5SAmir Goldstein 1257146d62e5SAmir Goldstein /* 1258146d62e5SAmir Goldstein * Check if any of the layers or work dirs overlap. 1259146d62e5SAmir Goldstein */ 1260146d62e5SAmir Goldstein static int ovl_check_overlapping_layers(struct super_block *sb, 1261146d62e5SAmir Goldstein struct ovl_fs *ofs) 1262146d62e5SAmir Goldstein { 1263146d62e5SAmir Goldstein int i, err; 1264146d62e5SAmir Goldstein 126508f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) { 126608f4c7c8SMiklos Szeredi err = ovl_check_layer(sb, ofs, ovl_upper_mnt(ofs)->mnt_root, 1267708fa015SMiklos Szeredi "upperdir", false); 1268146d62e5SAmir Goldstein if (err) 1269146d62e5SAmir Goldstein return err; 1270146d62e5SAmir Goldstein 1271146d62e5SAmir Goldstein /* 1272146d62e5SAmir Goldstein * Checking workbasedir avoids hitting ovl_is_inuse(parent) of 1273146d62e5SAmir Goldstein * this instance and covers overlapping work and index dirs, 1274146d62e5SAmir Goldstein * unless work or index dir have been moved since created inside 1275146d62e5SAmir Goldstein * workbasedir. In that case, we already have their traps in 1276146d62e5SAmir Goldstein * inode cache and we will catch that case on lookup. 1277146d62e5SAmir Goldstein */ 1278708fa015SMiklos Szeredi err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir", 1279708fa015SMiklos Szeredi false); 1280146d62e5SAmir Goldstein if (err) 1281146d62e5SAmir Goldstein return err; 1282146d62e5SAmir Goldstein } 1283146d62e5SAmir Goldstein 128494375f9dSAmir Goldstein for (i = 1; i < ofs->numlayer; i++) { 12850be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs, 128694375f9dSAmir Goldstein ofs->layers[i].mnt->mnt_root, 1287708fa015SMiklos Szeredi "lowerdir", true); 1288146d62e5SAmir Goldstein if (err) 1289146d62e5SAmir Goldstein return err; 1290146d62e5SAmir Goldstein } 1291146d62e5SAmir Goldstein 1292146d62e5SAmir Goldstein return 0; 1293146d62e5SAmir Goldstein } 1294146d62e5SAmir Goldstein 12952effc5c2SAmir Goldstein static struct dentry *ovl_get_root(struct super_block *sb, 12962effc5c2SAmir Goldstein struct dentry *upperdentry, 12972effc5c2SAmir Goldstein struct ovl_entry *oe) 12982effc5c2SAmir Goldstein { 12992effc5c2SAmir Goldstein struct dentry *root; 13005522c9c7SAmir Goldstein struct ovl_path *lowerpath = ovl_lowerstack(oe); 130162c832edSAmir Goldstein unsigned long ino = d_inode(lowerpath->dentry)->i_ino; 130262c832edSAmir Goldstein int fsid = lowerpath->layer->fsid; 130362c832edSAmir Goldstein struct ovl_inode_params oip = { 130462c832edSAmir Goldstein .upperdentry = upperdentry, 13050af950f5SAmir Goldstein .oe = oe, 130662c832edSAmir Goldstein }; 13072effc5c2SAmir Goldstein 13082effc5c2SAmir Goldstein root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); 13092effc5c2SAmir Goldstein if (!root) 13102effc5c2SAmir Goldstein return NULL; 13112effc5c2SAmir Goldstein 13122effc5c2SAmir Goldstein if (upperdentry) { 131362c832edSAmir Goldstein /* Root inode uses upper st_ino/i_ino */ 131462c832edSAmir Goldstein ino = d_inode(upperdentry)->i_ino; 131562c832edSAmir Goldstein fsid = 0; 13162effc5c2SAmir Goldstein ovl_dentry_set_upper_alias(root); 1317610afc0bSMiklos Szeredi if (ovl_is_impuredir(sb, upperdentry)) 13182effc5c2SAmir Goldstein ovl_set_flag(OVL_IMPURE, d_inode(root)); 13192effc5c2SAmir Goldstein } 13202effc5c2SAmir Goldstein 13212effc5c2SAmir Goldstein /* Root is always merge -> can have whiteouts */ 13222effc5c2SAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root)); 13232effc5c2SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root); 13242effc5c2SAmir Goldstein ovl_set_upperdata(d_inode(root)); 132562c832edSAmir Goldstein ovl_inode_init(d_inode(root), &oip, ino, fsid); 13260af950f5SAmir Goldstein ovl_dentry_init_flags(root, upperdentry, oe, DCACHE_OP_WEAK_REVALIDATE); 1327367d002dSAmir Goldstein /* root keeps a reference of upperdentry */ 1328367d002dSAmir Goldstein dget(upperdentry); 13292effc5c2SAmir Goldstein 13302effc5c2SAmir Goldstein return root; 13312effc5c2SAmir Goldstein } 13322effc5c2SAmir Goldstein 13337fb7998bSChristian Brauner int ovl_fill_super(struct super_block *sb, struct fs_context *fc) 1334e9be9d5eSMiklos Szeredi { 13351784fbc2SChristian Brauner struct ovl_fs *ofs = sb->s_fs_info; 13361784fbc2SChristian Brauner struct ovl_fs_context *ctx = fc->fs_private; 1337e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 13384155c10aSMiklos Szeredi struct ovl_entry *oe; 1339b8e42a65SMiklos Szeredi struct ovl_layer *layers; 134051f8f3c4SKonstantin Khlebnikov struct cred *cred; 1341e9be9d5eSMiklos Szeredi int err; 1342e9be9d5eSMiklos Szeredi 13439efb069dSMiklos Szeredi err = -EIO; 13441784fbc2SChristian Brauner if (WARN_ON(fc->user_ns != current_user_ns())) 13451784fbc2SChristian Brauner goto out_err; 13469efb069dSMiklos Szeredi 1347f4288844SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 1348f4288844SMiklos Szeredi 1349f45827e8SErez Zadok err = -ENOMEM; 1350ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds(); 1351c6fe6254SMiklos Szeredi if (!cred) 1352c6fe6254SMiklos Szeredi goto out_err; 1353c6fe6254SMiklos Szeredi 13541784fbc2SChristian Brauner err = ovl_fs_params_verify(ctx, &ofs->config); 1355f45827e8SErez Zadok if (err) 1356a9075cdbSMiklos Szeredi goto out_err; 1357f45827e8SErez Zadok 1358e9be9d5eSMiklos Szeredi err = -EINVAL; 1359b36a5780SChristian Brauner if (ctx->nr == 0) { 13601784fbc2SChristian Brauner if (!(fc->sb_flags & SB_SILENT)) 13611bd0a3aeSlijiazi pr_err("missing 'lowerdir'\n"); 1362a9075cdbSMiklos Szeredi goto out_err; 136353a08cb9SMiklos Szeredi } 136453a08cb9SMiklos Szeredi 1365b8e42a65SMiklos Szeredi err = -ENOMEM; 1366b36a5780SChristian Brauner layers = kcalloc(ctx->nr + 1, sizeof(struct ovl_layer), GFP_KERNEL); 1367b8e42a65SMiklos Szeredi if (!layers) 1368b8e42a65SMiklos Szeredi goto out_err; 1369b8e42a65SMiklos Szeredi 1370b8e42a65SMiklos Szeredi ofs->layers = layers; 1371b8e42a65SMiklos Szeredi /* Layer 0 is reserved for upper even if there's no upper */ 1372b8e42a65SMiklos Szeredi ofs->numlayer = 1; 1373b8e42a65SMiklos Szeredi 137453a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 1375cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE; 13764d314f78SAmir Goldstein atomic_long_set(&ofs->last_ino, 1); 13774f119628SWilliam Dean /* Assume underlying fs uses 32bit inodes unless proven otherwise */ 137853afcd31SAmir Goldstein if (ofs->config.xino != OVL_XINO_OFF) { 13790f831ec8SAmir Goldstein ofs->xino_mode = BITS_PER_LONG - 32; 138053afcd31SAmir Goldstein if (!ofs->xino_mode) { 138153afcd31SAmir Goldstein pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n"); 138253afcd31SAmir Goldstein ofs->config.xino = OVL_XINO_OFF; 138353afcd31SAmir Goldstein } 138453afcd31SAmir Goldstein } 1385795939a9SAmir Goldstein 1386146d62e5SAmir Goldstein /* alloc/destroy_inode needed for setting up traps in inode cache */ 1387146d62e5SAmir Goldstein sb->s_op = &ovl_super_operations; 1388146d62e5SAmir Goldstein 1389ad204488SMiklos Szeredi if (ofs->config.upperdir) { 1390335d3fc5SSargun Dhillon struct super_block *upper_sb; 1391335d3fc5SSargun Dhillon 1392d7b49b10SChengguang Xu err = -EINVAL; 1393ad204488SMiklos Szeredi if (!ofs->config.workdir) { 13941bd0a3aeSlijiazi pr_err("missing 'workdir'\n"); 1395a9075cdbSMiklos Szeredi goto out_err; 1396e9be9d5eSMiklos Szeredi } 1397e9be9d5eSMiklos Szeredi 1398b36a5780SChristian Brauner err = ovl_get_upper(sb, ofs, &layers[0], &ctx->upper); 139921a3b317SMiklos Szeredi if (err) 1400a9075cdbSMiklos Szeredi goto out_err; 1401d719e8f2SMiklos Szeredi 1402335d3fc5SSargun Dhillon upper_sb = ovl_upper_mnt(ofs)->mnt_sb; 1403335d3fc5SSargun Dhillon if (!ovl_should_sync(ofs)) { 1404335d3fc5SSargun Dhillon ofs->errseq = errseq_sample(&upper_sb->s_wb_err); 1405335d3fc5SSargun Dhillon if (errseq_check(&upper_sb->s_wb_err, ofs->errseq)) { 1406335d3fc5SSargun Dhillon err = -EIO; 1407335d3fc5SSargun Dhillon pr_err("Cannot mount volatile when upperdir has an unseen error. Sync upperdir fs to clear state.\n"); 1408335d3fc5SSargun Dhillon goto out_err; 1409335d3fc5SSargun Dhillon } 1410335d3fc5SSargun Dhillon } 1411335d3fc5SSargun Dhillon 1412b36a5780SChristian Brauner err = ovl_get_workdir(sb, ofs, &ctx->upper, &ctx->work); 14138ed61dc3SMiklos Szeredi if (err) 1414a9075cdbSMiklos Szeredi goto out_err; 1415c6fe6254SMiklos Szeredi 1416ad204488SMiklos Szeredi if (!ofs->workdir) 14171751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 14186e88256eSMiklos Szeredi 1419335d3fc5SSargun Dhillon sb->s_stack_depth = upper_sb->s_stack_depth; 1420335d3fc5SSargun Dhillon sb->s_time_gran = upper_sb->s_time_gran; 142121765194SVivek Goyal } 1422b36a5780SChristian Brauner oe = ovl_get_lowerstack(sb, ctx, ofs, layers); 14234155c10aSMiklos Szeredi err = PTR_ERR(oe); 14244155c10aSMiklos Szeredi if (IS_ERR(oe)) 1425a9075cdbSMiklos Szeredi goto out_err; 1426e9be9d5eSMiklos Szeredi 142771cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 142808f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 14291751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 1430e9be9d5eSMiklos Szeredi 1431b0504bfeSAmir Goldstein if (!ovl_origin_uuid(ofs) && ofs->numfs > 1) { 1432b0504bfeSAmir Goldstein pr_warn("The uuid=off requires a single fs for lower and upper, falling back to uuid=null.\n"); 1433b0504bfeSAmir Goldstein ofs->config.uuid = OVL_UUID_NULL; 1434d9544c1bSAmir Goldstein } else if (ovl_has_fsid(ofs) && ovl_upper_mnt(ofs)) { 1435d9544c1bSAmir Goldstein /* Use per instance persistent uuid/fsid */ 1436d9544c1bSAmir Goldstein ovl_init_uuid_xattr(sb, ofs, &ctx->upper); 14375830fb6bSPavel Tikhomirov } 14385830fb6bSPavel Tikhomirov 1439470c1563SAmir Goldstein if (!ovl_force_readonly(ofs) && ofs->config.index) { 1440b36a5780SChristian Brauner err = ovl_get_indexdir(sb, ofs, oe, &ctx->upper); 144154fb347eSAmir Goldstein if (err) 14424155c10aSMiklos Szeredi goto out_free_oe; 14436e88256eSMiklos Szeredi 1444972d0093SAmir Goldstein /* Force r/o mount with no index dir */ 144520396365SAmir Goldstein if (!ofs->indexdir) 14461751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 144702bcd157SAmir Goldstein } 144802bcd157SAmir Goldstein 1449146d62e5SAmir Goldstein err = ovl_check_overlapping_layers(sb, ofs); 1450146d62e5SAmir Goldstein if (err) 1451146d62e5SAmir Goldstein goto out_free_oe; 1452146d62e5SAmir Goldstein 1453972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */ 1454f168f109SAmir Goldstein if (!ofs->indexdir) { 1455ad204488SMiklos Szeredi ofs->config.index = false; 145608f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs) && ofs->config.nfs_export) { 14571bd0a3aeSlijiazi pr_warn("NFS export requires an index dir, falling back to nfs_export=off.\n"); 1458f168f109SAmir Goldstein ofs->config.nfs_export = false; 1459f168f109SAmir Goldstein } 1460f168f109SAmir Goldstein } 146102bcd157SAmir Goldstein 1462d5791044SVivek Goyal if (ofs->config.metacopy && ofs->config.nfs_export) { 14631bd0a3aeSlijiazi pr_warn("NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n"); 1464d5791044SVivek Goyal ofs->config.nfs_export = false; 1465d5791044SVivek Goyal } 1466d5791044SVivek Goyal 146716aac5adSAmir Goldstein /* 146816aac5adSAmir Goldstein * Support encoding decodable file handles with nfs_export=on 146916aac5adSAmir Goldstein * and encoding non-decodable file handles with nfs_export=off 147016aac5adSAmir Goldstein * if all layers support file handles. 147116aac5adSAmir Goldstein */ 14728383f174SAmir Goldstein if (ofs->config.nfs_export) 14738383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations; 147416aac5adSAmir Goldstein else if (!ofs->nofh) 147516aac5adSAmir Goldstein sb->s_export_op = &ovl_export_fid_operations; 14768383f174SAmir Goldstein 147751f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */ 147851f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); 147951f8f3c4SKonstantin Khlebnikov 1480655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC; 14812d2f2d73SMiklos Szeredi sb->s_xattr = ofs->config.userxattr ? ovl_user_xattr_handlers : 14822d2f2d73SMiklos Szeredi ovl_trusted_xattr_handlers; 1483ad204488SMiklos Szeredi sb->s_fs_info = ofs; 1484de2a4a50SMiklos Szeredi sb->s_flags |= SB_POSIXACL; 148518b44bc5SEric Snowberg sb->s_iflags |= SB_I_SKIP_SYNC | SB_I_IMA_UNVERIFIABLE_SIGNATURE; 1486655042ccSVivek Goyal 1487c6fe6254SMiklos Szeredi err = -ENOMEM; 1488b36a5780SChristian Brauner root_dentry = ovl_get_root(sb, ctx->upper.dentry, oe); 1489e9be9d5eSMiklos Szeredi if (!root_dentry) 14904155c10aSMiklos Szeredi goto out_free_oe; 1491e9be9d5eSMiklos Szeredi 1492e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1493e9be9d5eSMiklos Szeredi 1494e9be9d5eSMiklos Szeredi return 0; 1495e9be9d5eSMiklos Szeredi 14964155c10aSMiklos Szeredi out_free_oe: 1497163db0daSAmir Goldstein ovl_free_entry(oe); 14984155c10aSMiklos Szeredi out_err: 1499ad204488SMiklos Szeredi ovl_free_fs(ofs); 15001784fbc2SChristian Brauner sb->s_fs_info = NULL; 1501e9be9d5eSMiklos Szeredi return err; 1502e9be9d5eSMiklos Szeredi } 1503e9be9d5eSMiklos Szeredi 1504*f01d0889SAndrea Righi struct file_system_type ovl_fs_type = { 1505e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1506ef94b186SMiklos Szeredi .name = "overlay", 15071784fbc2SChristian Brauner .init_fs_context = ovl_init_fs_context, 15081784fbc2SChristian Brauner .parameters = ovl_parameter_spec, 1509459c7c56SMiklos Szeredi .fs_flags = FS_USERNS_MOUNT, 1510e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 1511e9be9d5eSMiklos Szeredi }; 1512ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 1513e9be9d5eSMiklos Szeredi 151413cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo) 151513cf199dSAmir Goldstein { 151613cf199dSAmir Goldstein struct ovl_inode *oi = foo; 151713cf199dSAmir Goldstein 151813cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode); 151913cf199dSAmir Goldstein } 152013cf199dSAmir Goldstein 1521e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 1522e9be9d5eSMiklos Szeredi { 152313cf199dSAmir Goldstein int err; 152413cf199dSAmir Goldstein 152513cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode", 152613cf199dSAmir Goldstein sizeof(struct ovl_inode), 0, 152713cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT| 152813cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT), 152913cf199dSAmir Goldstein ovl_inode_init_once); 153013cf199dSAmir Goldstein if (ovl_inode_cachep == NULL) 153113cf199dSAmir Goldstein return -ENOMEM; 153213cf199dSAmir Goldstein 15332406a307SJiufei Xue err = ovl_aio_request_cache_init(); 15342406a307SJiufei Xue if (!err) { 153513cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type); 15362406a307SJiufei Xue if (!err) 15372406a307SJiufei Xue return 0; 15382406a307SJiufei Xue 15392406a307SJiufei Xue ovl_aio_request_cache_destroy(); 15402406a307SJiufei Xue } 154113cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 154213cf199dSAmir Goldstein 154313cf199dSAmir Goldstein return err; 1544e9be9d5eSMiklos Szeredi } 1545e9be9d5eSMiklos Szeredi 1546e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1547e9be9d5eSMiklos Szeredi { 1548e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 154913cf199dSAmir Goldstein 155013cf199dSAmir Goldstein /* 155113cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we 155213cf199dSAmir Goldstein * destroy cache. 155313cf199dSAmir Goldstein */ 155413cf199dSAmir Goldstein rcu_barrier(); 155513cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep); 15562406a307SJiufei Xue ovl_aio_request_cache_destroy(); 1557e9be9d5eSMiklos Szeredi } 1558e9be9d5eSMiklos Szeredi 1559e9be9d5eSMiklos Szeredi module_init(ovl_init); 1560e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1561