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
ovl_d_real(struct dentry * dentry,const struct inode * inode)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
ovl_revalidate_real(struct dentry * d,unsigned int flags,bool weak)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
ovl_dentry_revalidate_common(struct dentry * dentry,unsigned int flags,bool weak)1043bb7df92SMiklos Szeredi static int ovl_dentry_revalidate_common(struct dentry *dentry,
1053bb7df92SMiklos Szeredi unsigned int flags, bool weak)
1067c03b5d4SMiklos Szeredi {
107c54719c9SAl Viro struct ovl_entry *oe;
108c54719c9SAl Viro struct ovl_path *lowerstack;
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
118c54719c9SAl Viro oe = OVL_I_E(inode);
119c54719c9SAl Viro lowerstack = ovl_lowerstack(oe);
120672e4268SChen Zhongjin upper = ovl_i_dentry_upper(inode);
121bccece1eSMiklos Szeredi if (upper)
122bccece1eSMiklos Szeredi ret = ovl_revalidate_real(upper, flags, weak);
123bccece1eSMiklos Szeredi
1245522c9c7SAmir Goldstein for (i = 0; ret > 0 && i < ovl_numlower(oe); i++)
1255522c9c7SAmir Goldstein ret = ovl_revalidate_real(lowerstack[i].dentry, flags, weak);
1265522c9c7SAmir Goldstein
1277c03b5d4SMiklos Szeredi return ret;
1287c03b5d4SMiklos Szeredi }
1293bb7df92SMiklos Szeredi
ovl_dentry_revalidate(struct dentry * dentry,unsigned int flags)1303bb7df92SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags)
1313bb7df92SMiklos Szeredi {
1323bb7df92SMiklos Szeredi return ovl_dentry_revalidate_common(dentry, flags, false);
1337c03b5d4SMiklos Szeredi }
1347c03b5d4SMiklos Szeredi
ovl_dentry_weak_revalidate(struct dentry * dentry,unsigned int flags)1357c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags)
1367c03b5d4SMiklos Szeredi {
1373bb7df92SMiklos Szeredi return ovl_dentry_revalidate_common(dentry, flags, true);
1387c03b5d4SMiklos Szeredi }
1397c03b5d4SMiklos Szeredi
140e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = {
141d101a125SMiklos Szeredi .d_real = ovl_d_real,
1427c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate,
1437c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate,
1447c03b5d4SMiklos Szeredi };
1457c03b5d4SMiklos Szeredi
14613cf199dSAmir Goldstein static struct kmem_cache *ovl_inode_cachep;
14713cf199dSAmir Goldstein
ovl_alloc_inode(struct super_block * sb)14813cf199dSAmir Goldstein static struct inode *ovl_alloc_inode(struct super_block *sb)
14913cf199dSAmir Goldstein {
150fd60b288SMuchun Song struct ovl_inode *oi = alloc_inode_sb(sb, ovl_inode_cachep, GFP_KERNEL);
15113cf199dSAmir Goldstein
152b3885bd6SHirofumi Nakagawa if (!oi)
153b3885bd6SHirofumi Nakagawa return NULL;
154b3885bd6SHirofumi Nakagawa
15504a01ac7SMiklos Szeredi oi->cache = NULL;
156cf31c463SMiklos Szeredi oi->redirect = NULL;
15704a01ac7SMiklos Szeredi oi->version = 0;
15813c72075SMiklos Szeredi oi->flags = 0;
15909d8b586SMiklos Szeredi oi->__upperdentry = NULL;
1602b21da92SAmir Goldstein oi->lowerdata_redirect = NULL;
1610af950f5SAmir Goldstein oi->oe = NULL;
162a015dafcSAmir Goldstein mutex_init(&oi->lock);
16325b7713aSMiklos Szeredi
16413cf199dSAmir Goldstein return &oi->vfs_inode;
16513cf199dSAmir Goldstein }
16613cf199dSAmir Goldstein
ovl_free_inode(struct inode * inode)1670b269dedSAl Viro static void ovl_free_inode(struct inode *inode)
16813cf199dSAmir Goldstein {
1690b269dedSAl Viro struct ovl_inode *oi = OVL_I(inode);
17013cf199dSAmir Goldstein
1710b269dedSAl Viro kfree(oi->redirect);
172d9e8319aSAl Viro kfree(oi->oe);
1730b269dedSAl Viro mutex_destroy(&oi->lock);
1740b269dedSAl Viro kmem_cache_free(ovl_inode_cachep, oi);
17513cf199dSAmir Goldstein }
17613cf199dSAmir Goldstein
ovl_destroy_inode(struct inode * inode)17713cf199dSAmir Goldstein static void ovl_destroy_inode(struct inode *inode)
17813cf199dSAmir Goldstein {
17909d8b586SMiklos Szeredi struct ovl_inode *oi = OVL_I(inode);
18009d8b586SMiklos Szeredi
18109d8b586SMiklos Szeredi dput(oi->__upperdentry);
182d9e8319aSAl Viro ovl_stack_put(ovl_lowerstack(oi->oe), ovl_numlower(oi->oe));
1832664bd08SVivek Goyal if (S_ISDIR(inode->i_mode))
1844edb83bbSMiklos Szeredi ovl_dir_cache_free(inode);
1852b21da92SAmir Goldstein else
1862b21da92SAmir Goldstein kfree(oi->lowerdata_redirect);
18713cf199dSAmir Goldstein }
18813cf199dSAmir Goldstein
ovl_put_super(struct super_block * sb)189a9075cdbSMiklos Szeredi static void ovl_put_super(struct super_block *sb)
190a9075cdbSMiklos Szeredi {
191f01d0889SAndrea Righi struct ovl_fs *ofs = OVL_FS(sb);
192a9075cdbSMiklos Szeredi
1931784fbc2SChristian Brauner if (ofs)
194a9075cdbSMiklos Szeredi ovl_free_fs(ofs);
195a9075cdbSMiklos Szeredi }
196a9075cdbSMiklos Szeredi
197e8d4bfe3SChengguang Xu /* Sync real dirty inodes in upper filesystem (if it exists) */
ovl_sync_fs(struct super_block * sb,int wait)198e593b2bfSAmir Goldstein static int ovl_sync_fs(struct super_block *sb, int wait)
199e593b2bfSAmir Goldstein {
200f01d0889SAndrea Righi struct ovl_fs *ofs = OVL_FS(sb);
201e593b2bfSAmir Goldstein struct super_block *upper_sb;
202e593b2bfSAmir Goldstein int ret;
203e593b2bfSAmir Goldstein
204335d3fc5SSargun Dhillon ret = ovl_sync_status(ofs);
205335d3fc5SSargun Dhillon /*
206335d3fc5SSargun Dhillon * We have to always set the err, because the return value isn't
207335d3fc5SSargun Dhillon * checked in syncfs, and instead indirectly return an error via
208335d3fc5SSargun Dhillon * the sb's writeback errseq, which VFS inspects after this call.
209335d3fc5SSargun Dhillon */
210335d3fc5SSargun Dhillon if (ret < 0) {
211335d3fc5SSargun Dhillon errseq_set(&sb->s_wb_err, -EIO);
212335d3fc5SSargun Dhillon return -EIO;
213335d3fc5SSargun Dhillon }
214e8d4bfe3SChengguang Xu
215335d3fc5SSargun Dhillon if (!ret)
216335d3fc5SSargun Dhillon return ret;
217335d3fc5SSargun Dhillon
218e8d4bfe3SChengguang Xu /*
21932b1924bSKonstantin Khlebnikov * Not called for sync(2) call or an emergency sync (SB_I_SKIP_SYNC).
22032b1924bSKonstantin Khlebnikov * All the super blocks will be iterated, including upper_sb.
221e8d4bfe3SChengguang Xu *
222e8d4bfe3SChengguang Xu * If this is a syncfs(2) call, then we do need to call
223e8d4bfe3SChengguang Xu * sync_filesystem() on upper_sb, but enough if we do it when being
224e8d4bfe3SChengguang Xu * called with wait == 1.
225e8d4bfe3SChengguang Xu */
226e8d4bfe3SChengguang Xu if (!wait)
227e593b2bfSAmir Goldstein return 0;
228e593b2bfSAmir Goldstein
22908f4c7c8SMiklos Szeredi upper_sb = ovl_upper_mnt(ofs)->mnt_sb;
230e8d4bfe3SChengguang Xu
231e593b2bfSAmir Goldstein down_read(&upper_sb->s_umount);
232e8d4bfe3SChengguang Xu ret = sync_filesystem(upper_sb);
233e593b2bfSAmir Goldstein up_read(&upper_sb->s_umount);
234e8d4bfe3SChengguang Xu
235e593b2bfSAmir Goldstein return ret;
236e593b2bfSAmir Goldstein }
237e593b2bfSAmir Goldstein
238cc259639SAndy Whitcroft /**
239cc259639SAndy Whitcroft * ovl_statfs
2409c5dd803SYang Li * @dentry: The dentry to query
241cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats
242cc259639SAndy Whitcroft *
243cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer
2444ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists)
245cc259639SAndy Whitcroft */
ovl_statfs(struct dentry * dentry,struct kstatfs * buf)246cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf)
247cc259639SAndy Whitcroft {
248b0504bfeSAmir Goldstein struct super_block *sb = dentry->d_sb;
249b0504bfeSAmir Goldstein struct ovl_fs *ofs = OVL_FS(sb);
250b0504bfeSAmir Goldstein struct dentry *root_dentry = sb->s_root;
251cc259639SAndy Whitcroft struct path path;
252cc259639SAndy Whitcroft int err;
253cc259639SAndy Whitcroft
2544ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path);
255cc259639SAndy Whitcroft
256cc259639SAndy Whitcroft err = vfs_statfs(&path, buf);
257cc259639SAndy Whitcroft if (!err) {
2586b2d5fe4SMiklos Szeredi buf->f_namelen = ofs->namelen;
259cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC;
260b0504bfeSAmir Goldstein if (ovl_has_fsid(ofs))
261b0504bfeSAmir Goldstein buf->f_fsid = uuid_to_fsid(sb->s_uuid.b);
262cc259639SAndy Whitcroft }
263cc259639SAndy Whitcroft
264cc259639SAndy Whitcroft return err;
265cc259639SAndy Whitcroft }
266cc259639SAndy Whitcroft
267e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = {
26813cf199dSAmir Goldstein .alloc_inode = ovl_alloc_inode,
2690b269dedSAl Viro .free_inode = ovl_free_inode,
27013cf199dSAmir Goldstein .destroy_inode = ovl_destroy_inode,
27113cf199dSAmir Goldstein .drop_inode = generic_delete_inode,
272e9be9d5eSMiklos Szeredi .put_super = ovl_put_super,
273e593b2bfSAmir Goldstein .sync_fs = ovl_sync_fs,
274cc259639SAndy Whitcroft .statfs = ovl_statfs,
275f45827e8SErez Zadok .show_options = ovl_show_options,
276e9be9d5eSMiklos Szeredi };
277e9be9d5eSMiklos Szeredi
278e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work"
27902bcd157SAmir Goldstein #define OVL_INDEXDIR_NAME "index"
280e9be9d5eSMiklos Szeredi
ovl_workdir_create(struct ovl_fs * ofs,const char * name,bool persist)281ad204488SMiklos Szeredi static struct dentry *ovl_workdir_create(struct ovl_fs *ofs,
2826b8aa129SAmir Goldstein const char *name, bool persist)
283e9be9d5eSMiklos Szeredi {
284ad204488SMiklos Szeredi struct inode *dir = ofs->workbasedir->d_inode;
28508f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs);
286e9be9d5eSMiklos Szeredi struct dentry *work;
287e9be9d5eSMiklos Szeredi int err;
288e9be9d5eSMiklos Szeredi bool retried = false;
289e9be9d5eSMiklos Szeredi
2905955102cSAl Viro inode_lock_nested(dir, I_MUTEX_PARENT);
291e9be9d5eSMiklos Szeredi retry:
29222f289ceSChristian Brauner work = ovl_lookup_upper(ofs, name, ofs->workbasedir, strlen(name));
293e9be9d5eSMiklos Szeredi
294e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) {
295c11b9fddSMiklos Szeredi struct iattr attr = {
296c11b9fddSMiklos Szeredi .ia_valid = ATTR_MODE,
29732a3d848SAl Viro .ia_mode = S_IFDIR | 0,
298c11b9fddSMiklos Szeredi };
299e9be9d5eSMiklos Szeredi
300e9be9d5eSMiklos Szeredi if (work->d_inode) {
301e9be9d5eSMiklos Szeredi err = -EEXIST;
302e9be9d5eSMiklos Szeredi if (retried)
303e9be9d5eSMiklos Szeredi goto out_dput;
304e9be9d5eSMiklos Szeredi
3056b8aa129SAmir Goldstein if (persist)
3066b8aa129SAmir Goldstein goto out_unlock;
3076b8aa129SAmir Goldstein
308e9be9d5eSMiklos Szeredi retried = true;
309576bb263SChristian Brauner err = ovl_workdir_cleanup(ofs, dir, mnt, work, 0);
310e9be9d5eSMiklos Szeredi dput(work);
311235ce9edSAmir Goldstein if (err == -EINVAL) {
312235ce9edSAmir Goldstein work = ERR_PTR(err);
313235ce9edSAmir Goldstein goto out_unlock;
314235ce9edSAmir Goldstein }
315e9be9d5eSMiklos Szeredi goto retry;
316e9be9d5eSMiklos Szeredi }
317e9be9d5eSMiklos Szeredi
318576bb263SChristian Brauner err = ovl_mkdir_real(ofs, dir, &work, attr.ia_mode);
3191f5573cfSMiklos Szeredi if (err)
3201f5573cfSMiklos Szeredi goto out_dput;
3211f5573cfSMiklos Szeredi
3221f5573cfSMiklos Szeredi /* Weird filesystem returning with hashed negative (kernfs)? */
3231f5573cfSMiklos Szeredi err = -EINVAL;
3241f5573cfSMiklos Szeredi if (d_really_is_negative(work))
3251f5573cfSMiklos Szeredi goto out_dput;
326c11b9fddSMiklos Szeredi
327cb348edbSMiklos Szeredi /*
328cb348edbSMiklos Szeredi * Try to remove POSIX ACL xattrs from workdir. We are good if:
329cb348edbSMiklos Szeredi *
330cb348edbSMiklos Szeredi * a) success (there was a POSIX ACL xattr and was removed)
331cb348edbSMiklos Szeredi * b) -ENODATA (there was no POSIX ACL xattr)
332cb348edbSMiklos Szeredi * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported)
333cb348edbSMiklos Szeredi *
334cb348edbSMiklos Szeredi * There are various other error values that could effectively
335cb348edbSMiklos Szeredi * mean that the xattr doesn't exist (e.g. -ERANGE is returned
336cb348edbSMiklos Szeredi * if the xattr name is too long), but the set of filesystems
337cb348edbSMiklos Szeredi * allowed as upper are limited to "normal" ones, where checking
338cb348edbSMiklos Szeredi * for the above two errors is sufficient.
339cb348edbSMiklos Szeredi */
34031acceb9SChristian Brauner err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_DEFAULT);
341e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP)
342c11b9fddSMiklos Szeredi goto out_dput;
343c11b9fddSMiklos Szeredi
34431acceb9SChristian Brauner err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_ACCESS);
345e1ff3dd1SMiklos Szeredi if (err && err != -ENODATA && err != -EOPNOTSUPP)
346c11b9fddSMiklos Szeredi goto out_dput;
347c11b9fddSMiklos Szeredi
348c11b9fddSMiklos Szeredi /* Clear any inherited mode bits */
349c11b9fddSMiklos Szeredi inode_lock(work->d_inode);
350a15506eaSChristian Brauner err = ovl_do_notify_change(ofs, work, &attr);
351c11b9fddSMiklos Szeredi inode_unlock(work->d_inode);
352c11b9fddSMiklos Szeredi if (err)
353c11b9fddSMiklos Szeredi goto out_dput;
3546b8aa129SAmir Goldstein } else {
3556b8aa129SAmir Goldstein err = PTR_ERR(work);
3566b8aa129SAmir Goldstein goto out_err;
357e9be9d5eSMiklos Szeredi }
358e9be9d5eSMiklos Szeredi out_unlock:
3596b8aa129SAmir Goldstein inode_unlock(dir);
360e9be9d5eSMiklos Szeredi return work;
361e9be9d5eSMiklos Szeredi
362e9be9d5eSMiklos Szeredi out_dput:
363e9be9d5eSMiklos Szeredi dput(work);
3646b8aa129SAmir Goldstein out_err:
3651bd0a3aeSlijiazi pr_warn("failed to create directory %s/%s (errno: %i); mounting read-only\n",
366ad204488SMiklos Szeredi ofs->config.workdir, name, -err);
3676b8aa129SAmir Goldstein work = NULL;
368e9be9d5eSMiklos Szeredi goto out_unlock;
369e9be9d5eSMiklos Szeredi }
370e9be9d5eSMiklos Szeredi
ovl_check_namelen(const struct path * path,struct ovl_fs * ofs,const char * name)3712d343087SAl Viro static int ovl_check_namelen(const struct path *path, struct ovl_fs *ofs,
3726b2d5fe4SMiklos Szeredi const char *name)
3736b2d5fe4SMiklos Szeredi {
3746b2d5fe4SMiklos Szeredi struct kstatfs statfs;
3756b2d5fe4SMiklos Szeredi int err = vfs_statfs(path, &statfs);
3766b2d5fe4SMiklos Szeredi
3776b2d5fe4SMiklos Szeredi if (err)
3781bd0a3aeSlijiazi pr_err("statfs failed on '%s'\n", name);
3796b2d5fe4SMiklos Szeredi else
3806b2d5fe4SMiklos Szeredi ofs->namelen = max(ofs->namelen, statfs.f_namelen);
3816b2d5fe4SMiklos Szeredi
3826b2d5fe4SMiklos Szeredi return err;
3836b2d5fe4SMiklos Szeredi }
3846b2d5fe4SMiklos Szeredi
ovl_lower_dir(const char * name,struct path * path,struct ovl_fs * ofs,int * stack_depth)3856b2d5fe4SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path,
386f4288844SMiklos Szeredi struct ovl_fs *ofs, int *stack_depth)
387ab508822SMiklos Szeredi {
388e487d889SAmir Goldstein int fh_type;
389ab508822SMiklos Szeredi int err;
390ab508822SMiklos Szeredi
3916b2d5fe4SMiklos Szeredi err = ovl_check_namelen(path, ofs, name);
3926b2d5fe4SMiklos Szeredi if (err)
393b8e42a65SMiklos Szeredi return err;
3946b2d5fe4SMiklos Szeredi
395ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth);
396ab508822SMiklos Szeredi
39702bcd157SAmir Goldstein /*
398f168f109SAmir Goldstein * The inodes index feature and NFS export need to encode and decode
399f168f109SAmir Goldstein * file handles, so they require that all layers support them.
40002bcd157SAmir Goldstein */
401e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(path->dentry->d_sb);
402f168f109SAmir Goldstein if ((ofs->config.nfs_export ||
403e487d889SAmir Goldstein (ofs->config.index && ofs->config.upperdir)) && !fh_type) {
40402bcd157SAmir Goldstein ofs->config.index = false;
405f168f109SAmir Goldstein ofs->config.nfs_export = false;
4061bd0a3aeSlijiazi pr_warn("fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n",
407f168f109SAmir Goldstein name);
40802bcd157SAmir Goldstein }
40916aac5adSAmir Goldstein ofs->nofh |= !fh_type;
410b0e0f697SAmir Goldstein /*
411b0e0f697SAmir Goldstein * Decoding origin file handle is required for persistent st_ino.
412b0e0f697SAmir Goldstein * Without persistent st_ino, xino=auto falls back to xino=off.
413b0e0f697SAmir Goldstein */
414b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO &&
415b0e0f697SAmir Goldstein ofs->config.upperdir && !fh_type) {
416b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF;
417b0e0f697SAmir Goldstein pr_warn("fs on '%s' does not support file handles, falling back to xino=off.\n",
418b0e0f697SAmir Goldstein name);
419b0e0f697SAmir Goldstein }
42002bcd157SAmir Goldstein
421e487d889SAmir Goldstein /* Check if lower fs has 32bit inode numbers */
422e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN)
4230f831ec8SAmir Goldstein ofs->xino_mode = -1;
424e487d889SAmir Goldstein
425ab508822SMiklos Szeredi return 0;
426ab508822SMiklos Szeredi }
427ab508822SMiklos Szeredi
428e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */
ovl_workdir_ok(struct dentry * workdir,struct dentry * upperdir)429e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir)
430e9be9d5eSMiklos Szeredi {
431e9be9d5eSMiklos Szeredi bool ok = false;
432e9be9d5eSMiklos Szeredi
433e9be9d5eSMiklos Szeredi if (workdir != upperdir) {
434e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL);
435e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir);
436e9be9d5eSMiklos Szeredi }
437e9be9d5eSMiklos Szeredi return ok;
438e9be9d5eSMiklos Szeredi }
439e9be9d5eSMiklos Szeredi
ovl_own_xattr_get(const struct xattr_handler * handler,struct dentry * dentry,struct inode * inode,const char * name,void * buffer,size_t size)4400eb45fc3SAndreas Gruenbacher static int ovl_own_xattr_get(const struct xattr_handler *handler,
4410eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode,
4420eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size)
4430eb45fc3SAndreas Gruenbacher {
44448fab5d7SAmir Goldstein return -EOPNOTSUPP;
4450eb45fc3SAndreas Gruenbacher }
4460eb45fc3SAndreas Gruenbacher
ovl_own_xattr_set(const struct xattr_handler * handler,struct mnt_idmap * idmap,struct dentry * dentry,struct inode * inode,const char * name,const void * value,size_t size,int flags)447d837a49bSMiklos Szeredi static int ovl_own_xattr_set(const struct xattr_handler *handler,
44839f60c1cSChristian Brauner struct mnt_idmap *idmap,
449d837a49bSMiklos Szeredi struct dentry *dentry, struct inode *inode,
450d837a49bSMiklos Szeredi const char *name, const void *value,
451d837a49bSMiklos Szeredi size_t size, int flags)
452d837a49bSMiklos Szeredi {
45348fab5d7SAmir Goldstein return -EOPNOTSUPP;
454d837a49bSMiklos Szeredi }
455d837a49bSMiklos Szeredi
ovl_other_xattr_get(const struct xattr_handler * handler,struct dentry * dentry,struct inode * inode,const char * name,void * buffer,size_t size)4560eb45fc3SAndreas Gruenbacher static int ovl_other_xattr_get(const struct xattr_handler *handler,
4570eb45fc3SAndreas Gruenbacher struct dentry *dentry, struct inode *inode,
4580eb45fc3SAndreas Gruenbacher const char *name, void *buffer, size_t size)
4590eb45fc3SAndreas Gruenbacher {
4601d88f183SMiklos Szeredi return ovl_xattr_get(dentry, inode, name, buffer, size);
4610eb45fc3SAndreas Gruenbacher }
4620eb45fc3SAndreas Gruenbacher
ovl_other_xattr_set(const struct xattr_handler * handler,struct mnt_idmap * idmap,struct dentry * dentry,struct inode * inode,const char * name,const void * value,size_t size,int flags)4630e585cccSAndreas Gruenbacher static int ovl_other_xattr_set(const struct xattr_handler *handler,
46439f60c1cSChristian Brauner struct mnt_idmap *idmap,
4650e585cccSAndreas Gruenbacher struct dentry *dentry, struct inode *inode,
4660e585cccSAndreas Gruenbacher const char *name, const void *value,
4670e585cccSAndreas Gruenbacher size_t size, int flags)
4680e585cccSAndreas Gruenbacher {
4691d88f183SMiklos Szeredi return ovl_xattr_set(dentry, inode, name, value, size, flags);
4700e585cccSAndreas Gruenbacher }
4710e585cccSAndreas Gruenbacher
4722d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_trusted_xattr_handler = {
4732d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_TRUSTED_PREFIX,
4742d2f2d73SMiklos Szeredi .get = ovl_own_xattr_get,
4752d2f2d73SMiklos Szeredi .set = ovl_own_xattr_set,
4762d2f2d73SMiklos Szeredi };
4772d2f2d73SMiklos Szeredi
4782d2f2d73SMiklos Szeredi static const struct xattr_handler ovl_own_user_xattr_handler = {
4792d2f2d73SMiklos Szeredi .prefix = OVL_XATTR_USER_PREFIX,
4800eb45fc3SAndreas Gruenbacher .get = ovl_own_xattr_get,
481d837a49bSMiklos Szeredi .set = ovl_own_xattr_set,
482d837a49bSMiklos Szeredi };
483d837a49bSMiklos Szeredi
484d837a49bSMiklos Szeredi static const struct xattr_handler ovl_other_xattr_handler = {
485d837a49bSMiklos Szeredi .prefix = "", /* catch all */
4860eb45fc3SAndreas Gruenbacher .get = ovl_other_xattr_get,
487d837a49bSMiklos Szeredi .set = ovl_other_xattr_set,
488d837a49bSMiklos Szeredi };
489d837a49bSMiklos Szeredi
4902d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_trusted_xattr_handlers[] = {
4912d2f2d73SMiklos Szeredi &ovl_own_trusted_xattr_handler,
4922d2f2d73SMiklos Szeredi &ovl_other_xattr_handler,
4932d2f2d73SMiklos Szeredi NULL
4942d2f2d73SMiklos Szeredi };
4952d2f2d73SMiklos Szeredi
4962d2f2d73SMiklos Szeredi static const struct xattr_handler *ovl_user_xattr_handlers[] = {
4972d2f2d73SMiklos Szeredi &ovl_own_user_xattr_handler,
498d837a49bSMiklos Szeredi &ovl_other_xattr_handler,
499d837a49bSMiklos Szeredi NULL
500d837a49bSMiklos Szeredi };
501d837a49bSMiklos Szeredi
ovl_setup_trap(struct super_block * sb,struct dentry * dir,struct inode ** ptrap,const char * name)502146d62e5SAmir Goldstein static int ovl_setup_trap(struct super_block *sb, struct dentry *dir,
503146d62e5SAmir Goldstein struct inode **ptrap, const char *name)
504146d62e5SAmir Goldstein {
505146d62e5SAmir Goldstein struct inode *trap;
506146d62e5SAmir Goldstein int err;
507146d62e5SAmir Goldstein
508146d62e5SAmir Goldstein trap = ovl_get_trap_inode(sb, dir);
5091dac6f5bSArnd Bergmann err = PTR_ERR_OR_ZERO(trap);
5101dac6f5bSArnd Bergmann if (err) {
511146d62e5SAmir Goldstein if (err == -ELOOP)
5121bd0a3aeSlijiazi pr_err("conflicting %s path\n", name);
513146d62e5SAmir Goldstein return err;
514146d62e5SAmir Goldstein }
515146d62e5SAmir Goldstein
516146d62e5SAmir Goldstein *ptrap = trap;
517146d62e5SAmir Goldstein return 0;
518146d62e5SAmir Goldstein }
519146d62e5SAmir Goldstein
5200be0bfd2SAmir Goldstein /*
5210be0bfd2SAmir Goldstein * Determine how we treat concurrent use of upperdir/workdir based on the
5220be0bfd2SAmir Goldstein * index feature. This is papering over mount leaks of container runtimes,
5230be0bfd2SAmir Goldstein * for example, an old overlay mount is leaked and now its upperdir is
5240be0bfd2SAmir Goldstein * attempted to be used as a lower layer in a new overlay mount.
5250be0bfd2SAmir Goldstein */
ovl_report_in_use(struct ovl_fs * ofs,const char * name)5260be0bfd2SAmir Goldstein static int ovl_report_in_use(struct ovl_fs *ofs, const char *name)
5270be0bfd2SAmir Goldstein {
5280be0bfd2SAmir Goldstein if (ofs->config.index) {
5291bd0a3aeSlijiazi pr_err("%s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n",
5300be0bfd2SAmir Goldstein name);
5310be0bfd2SAmir Goldstein return -EBUSY;
5320be0bfd2SAmir Goldstein } else {
5331bd0a3aeSlijiazi pr_warn("%s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n",
5340be0bfd2SAmir Goldstein name);
5350be0bfd2SAmir Goldstein return 0;
5360be0bfd2SAmir Goldstein }
5370be0bfd2SAmir Goldstein }
5380be0bfd2SAmir Goldstein
ovl_get_upper(struct super_block * sb,struct ovl_fs * ofs,struct ovl_layer * upper_layer,const struct path * upperpath)539146d62e5SAmir Goldstein static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs,
540b36a5780SChristian Brauner struct ovl_layer *upper_layer,
541b36a5780SChristian Brauner const struct path *upperpath)
5426ee8acf0SMiklos Szeredi {
5435064975eSMiklos Szeredi struct vfsmount *upper_mnt;
5446ee8acf0SMiklos Szeredi int err;
5456ee8acf0SMiklos Szeredi
546e21a6c57SAmir Goldstein /* Upperdir path should not be r/o */
547e21a6c57SAmir Goldstein if (__mnt_is_readonly(upperpath->mnt)) {
5481bd0a3aeSlijiazi pr_err("upper fs is r/o, try multi-lower layers mount\n");
5496ee8acf0SMiklos Szeredi err = -EINVAL;
5506ee8acf0SMiklos Szeredi goto out;
5516ee8acf0SMiklos Szeredi }
5526ee8acf0SMiklos Szeredi
553ad204488SMiklos Szeredi err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir);
5546ee8acf0SMiklos Szeredi if (err)
5556ee8acf0SMiklos Szeredi goto out;
5566ee8acf0SMiklos Szeredi
557b8e42a65SMiklos Szeredi err = ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap,
558146d62e5SAmir Goldstein "upperdir");
559146d62e5SAmir Goldstein if (err)
560146d62e5SAmir Goldstein goto out;
561146d62e5SAmir Goldstein
5625064975eSMiklos Szeredi upper_mnt = clone_private_mount(upperpath);
5635064975eSMiklos Szeredi err = PTR_ERR(upper_mnt);
5645064975eSMiklos Szeredi if (IS_ERR(upper_mnt)) {
5651bd0a3aeSlijiazi pr_err("failed to clone upperpath\n");
5665064975eSMiklos Szeredi goto out;
5675064975eSMiklos Szeredi }
5685064975eSMiklos Szeredi
5695064975eSMiklos Szeredi /* Don't inherit atime flags */
5705064975eSMiklos Szeredi upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME);
571b8e42a65SMiklos Szeredi upper_layer->mnt = upper_mnt;
572b8e42a65SMiklos Szeredi upper_layer->idx = 0;
573b8e42a65SMiklos Szeredi upper_layer->fsid = 0;
5748c25741aSMiklos Szeredi
575654255faSJeffle Xu /*
576654255faSJeffle Xu * Inherit SB_NOSEC flag from upperdir.
577654255faSJeffle Xu *
578654255faSJeffle Xu * This optimization changes behavior when a security related attribute
579654255faSJeffle Xu * (suid/sgid/security.*) is changed on an underlying layer. This is
580654255faSJeffle Xu * okay because we don't yet have guarantees in that case, but it will
581654255faSJeffle Xu * need careful treatment once we want to honour changes to underlying
582654255faSJeffle Xu * filesystems.
583654255faSJeffle Xu */
584654255faSJeffle Xu if (upper_mnt->mnt_sb->s_flags & SB_NOSEC)
585654255faSJeffle Xu sb->s_flags |= SB_NOSEC;
586654255faSJeffle Xu
58708f4c7c8SMiklos Szeredi if (ovl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) {
5888c25741aSMiklos Szeredi ofs->upperdir_locked = true;
5898c25741aSMiklos Szeredi } else {
5900be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "upperdir");
5910be0bfd2SAmir Goldstein if (err)
5920be0bfd2SAmir Goldstein goto out;
5938c25741aSMiklos Szeredi }
5948c25741aSMiklos Szeredi
5956ee8acf0SMiklos Szeredi err = 0;
5966ee8acf0SMiklos Szeredi out:
5976ee8acf0SMiklos Szeredi return err;
5986ee8acf0SMiklos Szeredi }
5996ee8acf0SMiklos Szeredi
600cad218abSAmir Goldstein /*
601cad218abSAmir Goldstein * Returns 1 if RENAME_WHITEOUT is supported, 0 if not supported and
602cad218abSAmir Goldstein * negative values if error is encountered.
603cad218abSAmir Goldstein */
ovl_check_rename_whiteout(struct ovl_fs * ofs)604576bb263SChristian Brauner static int ovl_check_rename_whiteout(struct ovl_fs *ofs)
605cad218abSAmir Goldstein {
606576bb263SChristian Brauner struct dentry *workdir = ofs->workdir;
607cad218abSAmir Goldstein struct inode *dir = d_inode(workdir);
608cad218abSAmir Goldstein struct dentry *temp;
609cad218abSAmir Goldstein struct dentry *dest;
610cad218abSAmir Goldstein struct dentry *whiteout;
611cad218abSAmir Goldstein struct name_snapshot name;
612cad218abSAmir Goldstein int err;
613cad218abSAmir Goldstein
614cad218abSAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT);
615cad218abSAmir Goldstein
616576bb263SChristian Brauner temp = ovl_create_temp(ofs, workdir, OVL_CATTR(S_IFREG | 0));
617cad218abSAmir Goldstein err = PTR_ERR(temp);
618cad218abSAmir Goldstein if (IS_ERR(temp))
619cad218abSAmir Goldstein goto out_unlock;
620cad218abSAmir Goldstein
621576bb263SChristian Brauner dest = ovl_lookup_temp(ofs, workdir);
622cad218abSAmir Goldstein err = PTR_ERR(dest);
623cad218abSAmir Goldstein if (IS_ERR(dest)) {
624cad218abSAmir Goldstein dput(temp);
625cad218abSAmir Goldstein goto out_unlock;
626cad218abSAmir Goldstein }
627cad218abSAmir Goldstein
628cad218abSAmir Goldstein /* Name is inline and stable - using snapshot as a copy helper */
629cad218abSAmir Goldstein take_dentry_name_snapshot(&name, temp);
630576bb263SChristian Brauner err = ovl_do_rename(ofs, dir, temp, dir, dest, RENAME_WHITEOUT);
631cad218abSAmir Goldstein if (err) {
632cad218abSAmir Goldstein if (err == -EINVAL)
633cad218abSAmir Goldstein err = 0;
634cad218abSAmir Goldstein goto cleanup_temp;
635cad218abSAmir Goldstein }
636cad218abSAmir Goldstein
63722f289ceSChristian Brauner whiteout = ovl_lookup_upper(ofs, name.name.name, workdir, name.name.len);
638cad218abSAmir Goldstein err = PTR_ERR(whiteout);
639cad218abSAmir Goldstein if (IS_ERR(whiteout))
640cad218abSAmir Goldstein goto cleanup_temp;
641cad218abSAmir Goldstein
642cad218abSAmir Goldstein err = ovl_is_whiteout(whiteout);
643cad218abSAmir Goldstein
644cad218abSAmir Goldstein /* Best effort cleanup of whiteout and temp file */
645cad218abSAmir Goldstein if (err)
646576bb263SChristian Brauner ovl_cleanup(ofs, dir, whiteout);
647cad218abSAmir Goldstein dput(whiteout);
648cad218abSAmir Goldstein
649cad218abSAmir Goldstein cleanup_temp:
650576bb263SChristian Brauner ovl_cleanup(ofs, dir, temp);
651cad218abSAmir Goldstein release_dentry_name_snapshot(&name);
652cad218abSAmir Goldstein dput(temp);
653cad218abSAmir Goldstein dput(dest);
654cad218abSAmir Goldstein
655cad218abSAmir Goldstein out_unlock:
656cad218abSAmir Goldstein inode_unlock(dir);
657cad218abSAmir Goldstein
658cad218abSAmir Goldstein return err;
659cad218abSAmir Goldstein }
660cad218abSAmir Goldstein
ovl_lookup_or_create(struct ovl_fs * ofs,struct dentry * parent,const char * name,umode_t mode)661576bb263SChristian Brauner static struct dentry *ovl_lookup_or_create(struct ovl_fs *ofs,
662576bb263SChristian Brauner struct dentry *parent,
663c86243b0SVivek Goyal const char *name, umode_t mode)
664c86243b0SVivek Goyal {
665c86243b0SVivek Goyal size_t len = strlen(name);
666c86243b0SVivek Goyal struct dentry *child;
667c86243b0SVivek Goyal
668c86243b0SVivek Goyal inode_lock_nested(parent->d_inode, I_MUTEX_PARENT);
66922f289ceSChristian Brauner child = ovl_lookup_upper(ofs, name, parent, len);
670c86243b0SVivek Goyal if (!IS_ERR(child) && !child->d_inode)
671576bb263SChristian Brauner child = ovl_create_real(ofs, parent->d_inode, child,
672c86243b0SVivek Goyal OVL_CATTR(mode));
673c86243b0SVivek Goyal inode_unlock(parent->d_inode);
674c86243b0SVivek Goyal dput(parent);
675c86243b0SVivek Goyal
676c86243b0SVivek Goyal return child;
677c86243b0SVivek Goyal }
678c86243b0SVivek Goyal
679c86243b0SVivek Goyal /*
680c86243b0SVivek Goyal * Creates $workdir/work/incompat/volatile/dirty file if it is not already
681c86243b0SVivek Goyal * present.
682c86243b0SVivek Goyal */
ovl_create_volatile_dirty(struct ovl_fs * ofs)683c86243b0SVivek Goyal static int ovl_create_volatile_dirty(struct ovl_fs *ofs)
684c86243b0SVivek Goyal {
685c86243b0SVivek Goyal unsigned int ctr;
686c86243b0SVivek Goyal struct dentry *d = dget(ofs->workbasedir);
687c86243b0SVivek Goyal static const char *const volatile_path[] = {
688c86243b0SVivek Goyal OVL_WORKDIR_NAME, "incompat", "volatile", "dirty"
689c86243b0SVivek Goyal };
690c86243b0SVivek Goyal const char *const *name = volatile_path;
691c86243b0SVivek Goyal
692c86243b0SVivek Goyal for (ctr = ARRAY_SIZE(volatile_path); ctr; ctr--, name++) {
693576bb263SChristian Brauner d = ovl_lookup_or_create(ofs, d, *name, ctr > 1 ? S_IFDIR : S_IFREG);
694c86243b0SVivek Goyal if (IS_ERR(d))
695c86243b0SVivek Goyal return PTR_ERR(d);
696c86243b0SVivek Goyal }
697c86243b0SVivek Goyal dput(d);
698c86243b0SVivek Goyal return 0;
699c86243b0SVivek Goyal }
700c86243b0SVivek Goyal
ovl_make_workdir(struct super_block * sb,struct ovl_fs * ofs,const struct path * workpath)701146d62e5SAmir Goldstein static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs,
7022d343087SAl Viro const struct path *workpath)
7038ed61dc3SMiklos Szeredi {
70408f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs);
7052b1a7746SMiklos Szeredi struct dentry *workdir;
7062b1a7746SMiklos Szeredi struct file *tmpfile;
707d80172c2SAmir Goldstein bool rename_whiteout;
708d80172c2SAmir Goldstein bool d_type;
709e487d889SAmir Goldstein int fh_type;
7108ed61dc3SMiklos Szeredi int err;
7118ed61dc3SMiklos Szeredi
7122ba9d57eSAmir Goldstein err = mnt_want_write(mnt);
7132ba9d57eSAmir Goldstein if (err)
7142ba9d57eSAmir Goldstein return err;
7152ba9d57eSAmir Goldstein
716235ce9edSAmir Goldstein workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false);
717235ce9edSAmir Goldstein err = PTR_ERR(workdir);
718235ce9edSAmir Goldstein if (IS_ERR_OR_NULL(workdir))
7192ba9d57eSAmir Goldstein goto out;
7208ed61dc3SMiklos Szeredi
721235ce9edSAmir Goldstein ofs->workdir = workdir;
722235ce9edSAmir Goldstein
723146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir");
724146d62e5SAmir Goldstein if (err)
725146d62e5SAmir Goldstein goto out;
726146d62e5SAmir Goldstein
7278ed61dc3SMiklos Szeredi /*
7288ed61dc3SMiklos Szeredi * Upper should support d_type, else whiteouts are visible. Given
7298ed61dc3SMiklos Szeredi * workdir and upper are on same fs, we can do iterate_dir() on
7308ed61dc3SMiklos Szeredi * workdir. This check requires successful creation of workdir in
7318ed61dc3SMiklos Szeredi * previous step.
7328ed61dc3SMiklos Szeredi */
7338ed61dc3SMiklos Szeredi err = ovl_check_d_type_supported(workpath);
7348ed61dc3SMiklos Szeredi if (err < 0)
7352ba9d57eSAmir Goldstein goto out;
7368ed61dc3SMiklos Szeredi
737d80172c2SAmir Goldstein d_type = err;
738d80172c2SAmir Goldstein if (!d_type)
7391bd0a3aeSlijiazi pr_warn("upper fs needs to support d_type.\n");
7408ed61dc3SMiklos Szeredi
7418ed61dc3SMiklos Szeredi /* Check if upper/work fs supports O_TMPFILE */
7422b1a7746SMiklos Szeredi tmpfile = ovl_do_tmpfile(ofs, ofs->workdir, S_IFREG | 0);
7432b1a7746SMiklos Szeredi ofs->tmpfile = !IS_ERR(tmpfile);
744ad204488SMiklos Szeredi if (ofs->tmpfile)
7452b1a7746SMiklos Szeredi fput(tmpfile);
7468ed61dc3SMiklos Szeredi else
7471bd0a3aeSlijiazi pr_warn("upper fs does not support tmpfile.\n");
7488ed61dc3SMiklos Szeredi
749cad218abSAmir Goldstein
750cad218abSAmir Goldstein /* Check if upper/work fs supports RENAME_WHITEOUT */
751576bb263SChristian Brauner err = ovl_check_rename_whiteout(ofs);
752cad218abSAmir Goldstein if (err < 0)
753cad218abSAmir Goldstein goto out;
754cad218abSAmir Goldstein
755d80172c2SAmir Goldstein rename_whiteout = err;
756d80172c2SAmir Goldstein if (!rename_whiteout)
757cad218abSAmir Goldstein pr_warn("upper fs does not support RENAME_WHITEOUT.\n");
758cad218abSAmir Goldstein
7598ed61dc3SMiklos Szeredi /*
7602d2f2d73SMiklos Szeredi * Check if upper/work fs supports (trusted|user).overlay.* xattr
7618ed61dc3SMiklos Szeredi */
762c914c0e2SAmir Goldstein err = ovl_setxattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE, "0", 1);
7638ed61dc3SMiklos Szeredi if (err) {
764b10b85feSMiklos Szeredi pr_warn("failed to set xattr on upper\n");
765ad204488SMiklos Szeredi ofs->noxattr = true;
766af5f2396SAmir Goldstein if (ovl_redirect_follow(ofs)) {
767af5f2396SAmir Goldstein ofs->config.redirect_mode = OVL_REDIRECT_NOFOLLOW;
768af5f2396SAmir Goldstein pr_warn("...falling back to redirect_dir=nofollow.\n");
769af5f2396SAmir Goldstein }
770af5f2396SAmir Goldstein if (ofs->config.metacopy) {
771d5791044SVivek Goyal ofs->config.metacopy = false;
772af5f2396SAmir Goldstein pr_warn("...falling back to metacopy=off.\n");
773af5f2396SAmir Goldstein }
774af5f2396SAmir Goldstein if (ofs->config.index) {
775af5f2396SAmir Goldstein ofs->config.index = false;
776af5f2396SAmir Goldstein pr_warn("...falling back to index=off.\n");
777b0e0f697SAmir Goldstein }
778d9544c1bSAmir Goldstein if (ovl_has_fsid(ofs)) {
779d9544c1bSAmir Goldstein ofs->config.uuid = OVL_UUID_NULL;
780d9544c1bSAmir Goldstein pr_warn("...falling back to uuid=null.\n");
781d9544c1bSAmir Goldstein }
782b0e0f697SAmir Goldstein /*
783b0e0f697SAmir Goldstein * xattr support is required for persistent st_ino.
784b0e0f697SAmir Goldstein * Without persistent st_ino, xino=auto falls back to xino=off.
785b0e0f697SAmir Goldstein */
786b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO) {
787b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF;
788b10b85feSMiklos Szeredi pr_warn("...falling back to xino=off.\n");
789b0e0f697SAmir Goldstein }
790b10b85feSMiklos Szeredi if (err == -EPERM && !ofs->config.userxattr)
791b10b85feSMiklos Szeredi pr_info("try mounting with 'userxattr' option\n");
7922ba9d57eSAmir Goldstein err = 0;
7938ed61dc3SMiklos Szeredi } else {
794c914c0e2SAmir Goldstein ovl_removexattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE);
7958ed61dc3SMiklos Szeredi }
7968ed61dc3SMiklos Szeredi
797d80172c2SAmir Goldstein /*
798d80172c2SAmir Goldstein * We allowed sub-optimal upper fs configuration and don't want to break
799d80172c2SAmir Goldstein * users over kernel upgrade, but we never allowed remote upper fs, so
800d80172c2SAmir Goldstein * we can enforce strict requirements for remote upper fs.
801d80172c2SAmir Goldstein */
802d80172c2SAmir Goldstein if (ovl_dentry_remote(ofs->workdir) &&
803d80172c2SAmir Goldstein (!d_type || !rename_whiteout || ofs->noxattr)) {
804d80172c2SAmir Goldstein pr_err("upper fs missing required features.\n");
805d80172c2SAmir Goldstein err = -EINVAL;
806d80172c2SAmir Goldstein goto out;
807d80172c2SAmir Goldstein }
808d80172c2SAmir Goldstein
809c86243b0SVivek Goyal /*
810c86243b0SVivek Goyal * For volatile mount, create a incompat/volatile/dirty file to keep
811c86243b0SVivek Goyal * track of it.
812c86243b0SVivek Goyal */
813c86243b0SVivek Goyal if (ofs->config.ovl_volatile) {
814c86243b0SVivek Goyal err = ovl_create_volatile_dirty(ofs);
815c86243b0SVivek Goyal if (err < 0) {
816c86243b0SVivek Goyal pr_err("Failed to create volatile/dirty file.\n");
817c86243b0SVivek Goyal goto out;
818c86243b0SVivek Goyal }
819c86243b0SVivek Goyal }
820c86243b0SVivek Goyal
8218ed61dc3SMiklos Szeredi /* Check if upper/work fs supports file handles */
822e487d889SAmir Goldstein fh_type = ovl_can_decode_fh(ofs->workdir->d_sb);
823e487d889SAmir Goldstein if (ofs->config.index && !fh_type) {
824ad204488SMiklos Szeredi ofs->config.index = false;
8251bd0a3aeSlijiazi pr_warn("upper fs does not support file handles, falling back to index=off.\n");
8268ed61dc3SMiklos Szeredi }
82716aac5adSAmir Goldstein ofs->nofh |= !fh_type;
8288ed61dc3SMiklos Szeredi
829e487d889SAmir Goldstein /* Check if upper fs has 32bit inode numbers */
830e487d889SAmir Goldstein if (fh_type != FILEID_INO32_GEN)
8310f831ec8SAmir Goldstein ofs->xino_mode = -1;
832e487d889SAmir Goldstein
833f168f109SAmir Goldstein /* NFS export of r/w mount depends on index */
834f168f109SAmir Goldstein if (ofs->config.nfs_export && !ofs->config.index) {
8351bd0a3aeSlijiazi pr_warn("NFS export requires \"index=on\", falling back to nfs_export=off.\n");
836f168f109SAmir Goldstein ofs->config.nfs_export = false;
837f168f109SAmir Goldstein }
8382ba9d57eSAmir Goldstein out:
8392ba9d57eSAmir Goldstein mnt_drop_write(mnt);
8402ba9d57eSAmir Goldstein return err;
8418ed61dc3SMiklos Szeredi }
8428ed61dc3SMiklos Szeredi
ovl_get_workdir(struct super_block * sb,struct ovl_fs * ofs,const struct path * upperpath,const struct path * workpath)843146d62e5SAmir Goldstein static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs,
844b36a5780SChristian Brauner const struct path *upperpath,
845b36a5780SChristian Brauner const struct path *workpath)
846520d7c86SMiklos Szeredi {
847520d7c86SMiklos Szeredi int err;
848520d7c86SMiklos Szeredi
849520d7c86SMiklos Szeredi err = -EINVAL;
850b36a5780SChristian Brauner if (upperpath->mnt != workpath->mnt) {
8511bd0a3aeSlijiazi pr_err("workdir and upperdir must reside under the same mount\n");
852b36a5780SChristian Brauner return err;
853520d7c86SMiklos Szeredi }
854b36a5780SChristian Brauner if (!ovl_workdir_ok(workpath->dentry, upperpath->dentry)) {
8551bd0a3aeSlijiazi pr_err("workdir and upperdir must be separate subtrees\n");
856b36a5780SChristian Brauner return err;
857520d7c86SMiklos Szeredi }
858520d7c86SMiklos Szeredi
859b36a5780SChristian Brauner ofs->workbasedir = dget(workpath->dentry);
8608c25741aSMiklos Szeredi
8618c25741aSMiklos Szeredi if (ovl_inuse_trylock(ofs->workbasedir)) {
862ad204488SMiklos Szeredi ofs->workdir_locked = true;
863520d7c86SMiklos Szeredi } else {
8640be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "workdir");
8650be0bfd2SAmir Goldstein if (err)
866b36a5780SChristian Brauner return err;
867520d7c86SMiklos Szeredi }
868520d7c86SMiklos Szeredi
8690be0bfd2SAmir Goldstein err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap,
8700be0bfd2SAmir Goldstein "workdir");
8710be0bfd2SAmir Goldstein if (err)
872520d7c86SMiklos Szeredi return err;
873b36a5780SChristian Brauner
874b36a5780SChristian Brauner return ovl_make_workdir(sb, ofs, workpath);
875520d7c86SMiklos Szeredi }
876520d7c86SMiklos Szeredi
ovl_get_indexdir(struct super_block * sb,struct ovl_fs * ofs,struct ovl_entry * oe,const struct path * upperpath)877146d62e5SAmir Goldstein static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs,
8782d343087SAl Viro struct ovl_entry *oe, const struct path *upperpath)
879f7e3a7d9SMiklos Szeredi {
88008f4c7c8SMiklos Szeredi struct vfsmount *mnt = ovl_upper_mnt(ofs);
881235ce9edSAmir Goldstein struct dentry *indexdir;
882f7e3a7d9SMiklos Szeredi int err;
883f7e3a7d9SMiklos Szeredi
8842ba9d57eSAmir Goldstein err = mnt_want_write(mnt);
8852ba9d57eSAmir Goldstein if (err)
8862ba9d57eSAmir Goldstein return err;
8872ba9d57eSAmir Goldstein
888f7e3a7d9SMiklos Szeredi /* Verify lower root is upper root origin */
889610afc0bSMiklos Szeredi err = ovl_verify_origin(ofs, upperpath->dentry,
8905522c9c7SAmir Goldstein ovl_lowerstack(oe)->dentry, true);
891f7e3a7d9SMiklos Szeredi if (err) {
8921bd0a3aeSlijiazi pr_err("failed to verify upper root origin\n");
893f7e3a7d9SMiklos Szeredi goto out;
894f7e3a7d9SMiklos Szeredi }
895f7e3a7d9SMiklos Szeredi
89620396365SAmir Goldstein /* index dir will act also as workdir */
89720396365SAmir Goldstein iput(ofs->workdir_trap);
89820396365SAmir Goldstein ofs->workdir_trap = NULL;
89920396365SAmir Goldstein dput(ofs->workdir);
900470c1563SAmir Goldstein ofs->workdir = NULL;
901235ce9edSAmir Goldstein indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true);
902235ce9edSAmir Goldstein if (IS_ERR(indexdir)) {
903235ce9edSAmir Goldstein err = PTR_ERR(indexdir);
904235ce9edSAmir Goldstein } else if (indexdir) {
905235ce9edSAmir Goldstein ofs->indexdir = indexdir;
906235ce9edSAmir Goldstein ofs->workdir = dget(indexdir);
90720396365SAmir Goldstein
908146d62e5SAmir Goldstein err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap,
909146d62e5SAmir Goldstein "indexdir");
910146d62e5SAmir Goldstein if (err)
911146d62e5SAmir Goldstein goto out;
912146d62e5SAmir Goldstein
913ad1d615cSAmir Goldstein /*
914ad1d615cSAmir Goldstein * Verify upper root is exclusively associated with index dir.
9152d2f2d73SMiklos Szeredi * Older kernels stored upper fh in ".overlay.origin"
916ad1d615cSAmir Goldstein * xattr. If that xattr exists, verify that it is a match to
917ad1d615cSAmir Goldstein * upper dir file handle. In any case, verify or set xattr
9182d2f2d73SMiklos Szeredi * ".overlay.upper" to indicate that index may have
919ad1d615cSAmir Goldstein * directory entries.
920ad1d615cSAmir Goldstein */
921610afc0bSMiklos Szeredi if (ovl_check_origin_xattr(ofs, ofs->indexdir)) {
922610afc0bSMiklos Szeredi err = ovl_verify_set_fh(ofs, ofs->indexdir,
923610afc0bSMiklos Szeredi OVL_XATTR_ORIGIN,
924ad1d615cSAmir Goldstein upperpath->dentry, true, false);
925f7e3a7d9SMiklos Szeredi if (err)
9261bd0a3aeSlijiazi pr_err("failed to verify index dir 'origin' xattr\n");
927ad1d615cSAmir Goldstein }
928610afc0bSMiklos Szeredi err = ovl_verify_upper(ofs, ofs->indexdir, upperpath->dentry,
929610afc0bSMiklos Szeredi true);
930ad1d615cSAmir Goldstein if (err)
9311bd0a3aeSlijiazi pr_err("failed to verify index dir 'upper' xattr\n");
932f7e3a7d9SMiklos Szeredi
933f7e3a7d9SMiklos Szeredi /* Cleanup bad/stale/orphan index entries */
934f7e3a7d9SMiklos Szeredi if (!err)
9351eff1a1dSAmir Goldstein err = ovl_indexdir_cleanup(ofs);
936f7e3a7d9SMiklos Szeredi }
937ad204488SMiklos Szeredi if (err || !ofs->indexdir)
9381bd0a3aeSlijiazi pr_warn("try deleting index dir or mounting with '-o index=off' to disable inodes index.\n");
939f7e3a7d9SMiklos Szeredi
940f7e3a7d9SMiklos Szeredi out:
9412ba9d57eSAmir Goldstein mnt_drop_write(mnt);
942f7e3a7d9SMiklos Szeredi return err;
943f7e3a7d9SMiklos Szeredi }
944f7e3a7d9SMiklos Szeredi
ovl_lower_uuid_ok(struct ovl_fs * ofs,const uuid_t * uuid)9459df085f3SAmir Goldstein static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid)
9465148626bSAmir Goldstein {
9475148626bSAmir Goldstein unsigned int i;
9489df085f3SAmir Goldstein
94908f4c7c8SMiklos Szeredi if (!ofs->config.nfs_export && !ovl_upper_mnt(ofs))
9509df085f3SAmir Goldstein return true;
9519df085f3SAmir Goldstein
952a888db31SAmir Goldstein /*
953a888db31SAmir Goldstein * We allow using single lower with null uuid for index and nfs_export
954a888db31SAmir Goldstein * for example to support those features with single lower squashfs.
955a888db31SAmir Goldstein * To avoid regressions in setups of overlay with re-formatted lower
956a888db31SAmir Goldstein * squashfs, do not allow decoding origin with lower null uuid unless
957a888db31SAmir Goldstein * user opted-in to one of the new features that require following the
958a888db31SAmir Goldstein * lower inode of non-dir upper.
959a888db31SAmir Goldstein */
960ca45275cSVyacheslav Yurkov if (ovl_allow_offline_changes(ofs) && uuid_is_null(uuid))
961a888db31SAmir Goldstein return false;
962a888db31SAmir Goldstein
9631b81ddddSAmir Goldstein for (i = 0; i < ofs->numfs; i++) {
9649df085f3SAmir Goldstein /*
9659df085f3SAmir Goldstein * We use uuid to associate an overlay lower file handle with a
9669df085f3SAmir Goldstein * lower layer, so we can accept lower fs with null uuid as long
9679df085f3SAmir Goldstein * as all lower layers with null uuid are on the same fs.
9687e63c87fSAmir Goldstein * if we detect multiple lower fs with the same uuid, we
9697e63c87fSAmir Goldstein * disable lower file handle decoding on all of them.
9709df085f3SAmir Goldstein */
9711b81ddddSAmir Goldstein if (ofs->fs[i].is_lower &&
9721b81ddddSAmir Goldstein uuid_equal(&ofs->fs[i].sb->s_uuid, uuid)) {
97307f1e596SAmir Goldstein ofs->fs[i].bad_uuid = true;
9749df085f3SAmir Goldstein return false;
9759df085f3SAmir Goldstein }
9767e63c87fSAmir Goldstein }
9779df085f3SAmir Goldstein return true;
9789df085f3SAmir Goldstein }
9799df085f3SAmir Goldstein
9809df085f3SAmir Goldstein /* Get a unique fsid for the layer */
ovl_get_fsid(struct ovl_fs * ofs,const struct path * path)9819df085f3SAmir Goldstein static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path)
9829df085f3SAmir Goldstein {
9839df085f3SAmir Goldstein struct super_block *sb = path->mnt->mnt_sb;
9849df085f3SAmir Goldstein unsigned int i;
9855148626bSAmir Goldstein dev_t dev;
9865148626bSAmir Goldstein int err;
9877e63c87fSAmir Goldstein bool bad_uuid = false;
988b0e0f697SAmir Goldstein bool warn = false;
9895148626bSAmir Goldstein
99007f1e596SAmir Goldstein for (i = 0; i < ofs->numfs; i++) {
99107f1e596SAmir Goldstein if (ofs->fs[i].sb == sb)
99207f1e596SAmir Goldstein return i;
9935148626bSAmir Goldstein }
9945148626bSAmir Goldstein
9959df085f3SAmir Goldstein if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) {
9967e63c87fSAmir Goldstein bad_uuid = true;
997b0e0f697SAmir Goldstein if (ofs->config.xino == OVL_XINO_AUTO) {
998b0e0f697SAmir Goldstein ofs->config.xino = OVL_XINO_OFF;
999b0e0f697SAmir Goldstein warn = true;
1000b0e0f697SAmir Goldstein }
10017e63c87fSAmir Goldstein if (ofs->config.index || ofs->config.nfs_export) {
10029df085f3SAmir Goldstein ofs->config.index = false;
10039df085f3SAmir Goldstein ofs->config.nfs_export = false;
1004b0e0f697SAmir Goldstein warn = true;
1005b0e0f697SAmir Goldstein }
1006b0e0f697SAmir Goldstein if (warn) {
1007b0e0f697SAmir Goldstein pr_warn("%s uuid detected in lower fs '%pd2', falling back to xino=%s,index=off,nfs_export=off.\n",
10087e63c87fSAmir Goldstein uuid_is_null(&sb->s_uuid) ? "null" :
10097e63c87fSAmir Goldstein "conflicting",
1010dcb399deSAmir Goldstein path->dentry, ovl_xino_mode(&ofs->config));
10119df085f3SAmir Goldstein }
10127e63c87fSAmir Goldstein }
10139df085f3SAmir Goldstein
10145148626bSAmir Goldstein err = get_anon_bdev(&dev);
10155148626bSAmir Goldstein if (err) {
10161bd0a3aeSlijiazi pr_err("failed to get anonymous bdev for lowerpath\n");
10175148626bSAmir Goldstein return err;
10185148626bSAmir Goldstein }
10195148626bSAmir Goldstein
102007f1e596SAmir Goldstein ofs->fs[ofs->numfs].sb = sb;
102107f1e596SAmir Goldstein ofs->fs[ofs->numfs].pseudo_dev = dev;
102207f1e596SAmir Goldstein ofs->fs[ofs->numfs].bad_uuid = bad_uuid;
10235148626bSAmir Goldstein
102407f1e596SAmir Goldstein return ofs->numfs++;
10255148626bSAmir Goldstein }
10265148626bSAmir Goldstein
102737ebf056SAmir Goldstein /*
102837ebf056SAmir Goldstein * The fsid after the last lower fsid is used for the data layers.
102937ebf056SAmir Goldstein * It is a "null fs" with a null sb, null uuid, and no pseudo dev.
103037ebf056SAmir Goldstein */
ovl_get_data_fsid(struct ovl_fs * ofs)103137ebf056SAmir Goldstein static int ovl_get_data_fsid(struct ovl_fs *ofs)
103237ebf056SAmir Goldstein {
103337ebf056SAmir Goldstein return ofs->numfs;
103437ebf056SAmir Goldstein }
103537ebf056SAmir Goldstein
103637ebf056SAmir Goldstein
ovl_get_layers(struct super_block * sb,struct ovl_fs * ofs,struct ovl_fs_context * ctx,struct ovl_layer * layers)103794375f9dSAmir Goldstein static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs,
1038b36a5780SChristian Brauner struct ovl_fs_context *ctx, struct ovl_layer *layers)
1039520d7c86SMiklos Szeredi {
1040520d7c86SMiklos Szeredi int err;
1041520d7c86SMiklos Szeredi unsigned int i;
1042b36a5780SChristian Brauner size_t nr_merged_lower;
1043520d7c86SMiklos Szeredi
1044b36a5780SChristian Brauner ofs->fs = kcalloc(ctx->nr + 2, sizeof(struct ovl_sb), GFP_KERNEL);
104507f1e596SAmir Goldstein if (ofs->fs == NULL)
10469e88f905SAmir Goldstein return -ENOMEM;
10475148626bSAmir Goldstein
104837ebf056SAmir Goldstein /*
104937ebf056SAmir Goldstein * idx/fsid 0 are reserved for upper fs even with lower only overlay
105037ebf056SAmir Goldstein * and the last fsid is reserved for "null fs" of the data layers.
105137ebf056SAmir Goldstein */
105207f1e596SAmir Goldstein ofs->numfs++;
105307f1e596SAmir Goldstein
105407f1e596SAmir Goldstein /*
1055b7bf9908SAmir Goldstein * All lower layers that share the same fs as upper layer, use the same
1056b7bf9908SAmir Goldstein * pseudo_dev as upper layer. Allocate fs[0].pseudo_dev even for lower
1057b7bf9908SAmir Goldstein * only overlay to simplify ovl_fs_free().
10581b81ddddSAmir Goldstein * is_lower will be set if upper fs is shared with a lower layer.
105907f1e596SAmir Goldstein */
1060b7bf9908SAmir Goldstein err = get_anon_bdev(&ofs->fs[0].pseudo_dev);
1061b7bf9908SAmir Goldstein if (err) {
1062b7bf9908SAmir Goldstein pr_err("failed to get anonymous bdev for upper fs\n");
10639e88f905SAmir Goldstein return err;
1064b7bf9908SAmir Goldstein }
1065b7bf9908SAmir Goldstein
106608f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) {
106708f4c7c8SMiklos Szeredi ofs->fs[0].sb = ovl_upper_mnt(ofs)->mnt_sb;
10681b81ddddSAmir Goldstein ofs->fs[0].is_lower = false;
106907f1e596SAmir Goldstein }
107007f1e596SAmir Goldstein
1071b36a5780SChristian Brauner nr_merged_lower = ctx->nr - ctx->nr_data;
1072b36a5780SChristian Brauner for (i = 0; i < ctx->nr; i++) {
1073b36a5780SChristian Brauner struct ovl_fs_context_layer *l = &ctx->lower[i];
1074520d7c86SMiklos Szeredi struct vfsmount *mnt;
1075146d62e5SAmir Goldstein struct inode *trap;
10765148626bSAmir Goldstein int fsid;
1077520d7c86SMiklos Szeredi
1078b36a5780SChristian Brauner if (i < nr_merged_lower)
1079b36a5780SChristian Brauner fsid = ovl_get_fsid(ofs, &l->path);
108037ebf056SAmir Goldstein else
108137ebf056SAmir Goldstein fsid = ovl_get_data_fsid(ofs);
10829e88f905SAmir Goldstein if (fsid < 0)
10839e88f905SAmir Goldstein return fsid;
1084520d7c86SMiklos Szeredi
108524f14009Syoungjun /*
108624f14009Syoungjun * Check if lower root conflicts with this overlay layers before
108724f14009Syoungjun * checking if it is in-use as upperdir/workdir of "another"
108824f14009Syoungjun * mount, because we do not bother to check in ovl_is_inuse() if
108924f14009Syoungjun * the upperdir/workdir is in fact in-use by our
109024f14009Syoungjun * upperdir/workdir.
109124f14009Syoungjun */
1092b36a5780SChristian Brauner err = ovl_setup_trap(sb, l->path.dentry, &trap, "lowerdir");
1093146d62e5SAmir Goldstein if (err)
10949e88f905SAmir Goldstein return err;
1095146d62e5SAmir Goldstein
1096b36a5780SChristian Brauner if (ovl_is_inuse(l->path.dentry)) {
10970be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, "lowerdir");
109824f14009Syoungjun if (err) {
109924f14009Syoungjun iput(trap);
11009e88f905SAmir Goldstein return err;
11010be0bfd2SAmir Goldstein }
110224f14009Syoungjun }
11030be0bfd2SAmir Goldstein
1104b36a5780SChristian Brauner mnt = clone_private_mount(&l->path);
1105520d7c86SMiklos Szeredi err = PTR_ERR(mnt);
1106520d7c86SMiklos Szeredi if (IS_ERR(mnt)) {
11071bd0a3aeSlijiazi pr_err("failed to clone lowerpath\n");
1108146d62e5SAmir Goldstein iput(trap);
11099e88f905SAmir Goldstein return err;
1110520d7c86SMiklos Szeredi }
11115148626bSAmir Goldstein
1112520d7c86SMiklos Szeredi /*
1113520d7c86SMiklos Szeredi * Make lower layers R/O. That way fchmod/fchown on lower file
1114520d7c86SMiklos Szeredi * will fail instead of modifying lower fs.
1115520d7c86SMiklos Szeredi */
1116520d7c86SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME;
1117520d7c86SMiklos Szeredi
111813464165SMiklos Szeredi layers[ofs->numlayer].trap = trap;
111913464165SMiklos Szeredi layers[ofs->numlayer].mnt = mnt;
112013464165SMiklos Szeredi layers[ofs->numlayer].idx = ofs->numlayer;
112113464165SMiklos Szeredi layers[ofs->numlayer].fsid = fsid;
112213464165SMiklos Szeredi layers[ofs->numlayer].fs = &ofs->fs[fsid];
1123a535116dSAmir Goldstein /* Store for printing lowerdir=... in ovl_show_options() */
1124a535116dSAmir Goldstein ofs->config.lowerdirs[ofs->numlayer] = l->name;
1125b36a5780SChristian Brauner l->name = NULL;
112694375f9dSAmir Goldstein ofs->numlayer++;
11271b81ddddSAmir Goldstein ofs->fs[fsid].is_lower = true;
1128520d7c86SMiklos Szeredi }
1129e487d889SAmir Goldstein
1130795939a9SAmir Goldstein /*
1131795939a9SAmir Goldstein * When all layers on same fs, overlay can use real inode numbers.
1132926e94d7SAmir Goldstein * With mount option "xino=<on|auto>", mounter declares that there are
1133926e94d7SAmir Goldstein * enough free high bits in underlying fs to hold the unique fsid.
1134795939a9SAmir Goldstein * If overlayfs does encounter underlying inodes using the high xino
1135795939a9SAmir Goldstein * bits reserved for fsid, it emits a warning and uses the original
1136dfe51d47SAmir Goldstein * inode number or a non persistent inode number allocated from a
1137dfe51d47SAmir Goldstein * dedicated range.
1138795939a9SAmir Goldstein */
113908f4c7c8SMiklos Szeredi if (ofs->numfs - !ovl_upper_mnt(ofs) == 1) {
11400f831ec8SAmir Goldstein if (ofs->config.xino == OVL_XINO_ON)
11410f831ec8SAmir Goldstein pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n");
11420f831ec8SAmir Goldstein ofs->xino_mode = 0;
114353afcd31SAmir Goldstein } else if (ofs->config.xino == OVL_XINO_OFF) {
114453afcd31SAmir Goldstein ofs->xino_mode = -1;
1145926e94d7SAmir Goldstein } else if (ofs->xino_mode < 0) {
1146795939a9SAmir Goldstein /*
114707f1e596SAmir Goldstein * This is a roundup of number of bits needed for encoding
1148dfe51d47SAmir Goldstein * fsid, where fsid 0 is reserved for upper fs (even with
1149dfe51d47SAmir Goldstein * lower only overlay) +1 extra bit is reserved for the non
1150dfe51d47SAmir Goldstein * persistent inode number range that is used for resolving
1151dfe51d47SAmir Goldstein * xino lower bits overflow.
1152795939a9SAmir Goldstein */
1153dfe51d47SAmir Goldstein BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 30);
1154dfe51d47SAmir Goldstein ofs->xino_mode = ilog2(ofs->numfs - 1) + 2;
1155795939a9SAmir Goldstein }
1156795939a9SAmir Goldstein
11570f831ec8SAmir Goldstein if (ofs->xino_mode > 0) {
11581bd0a3aeSlijiazi pr_info("\"xino\" feature enabled using %d upper inode bits.\n",
11590f831ec8SAmir Goldstein ofs->xino_mode);
1160795939a9SAmir Goldstein }
1161e487d889SAmir Goldstein
11629e88f905SAmir Goldstein return 0;
1163520d7c86SMiklos Szeredi }
1164520d7c86SMiklos Szeredi
ovl_get_lowerstack(struct super_block * sb,struct ovl_fs_context * ctx,struct ovl_fs * ofs,struct ovl_layer * layers)11654155c10aSMiklos Szeredi static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb,
1166b36a5780SChristian Brauner struct ovl_fs_context *ctx,
1167b36a5780SChristian Brauner struct ovl_fs *ofs,
1168b36a5780SChristian Brauner struct ovl_layer *layers)
116953dbb0b4SMiklos Szeredi {
117053dbb0b4SMiklos Szeredi int err;
1171b8e42a65SMiklos Szeredi unsigned int i;
1172b36a5780SChristian Brauner size_t nr_merged_lower;
11734155c10aSMiklos Szeredi struct ovl_entry *oe;
1174b36a5780SChristian Brauner struct ovl_path *lowerstack;
117553dbb0b4SMiklos Szeredi
1176b36a5780SChristian Brauner struct ovl_fs_context_layer *l;
1177b36a5780SChristian Brauner
1178b36a5780SChristian Brauner if (!ofs->config.upperdir && ctx->nr == 1) {
11791bd0a3aeSlijiazi pr_err("at least 2 lowerdir are needed while upperdir nonexistent\n");
1180b8e42a65SMiklos Szeredi return ERR_PTR(-EINVAL);
118153dbb0b4SMiklos Szeredi }
118253dbb0b4SMiklos Szeredi
118337ebf056SAmir Goldstein err = -EINVAL;
1184b36a5780SChristian Brauner for (i = 0; i < ctx->nr; i++) {
1185b36a5780SChristian Brauner l = &ctx->lower[i];
118637ebf056SAmir Goldstein
1187b36a5780SChristian Brauner err = ovl_lower_dir(l->name, &l->path, ofs, &sb->s_stack_depth);
1188b36a5780SChristian Brauner if (err)
1189b36a5780SChristian Brauner return ERR_PTR(err);
119053dbb0b4SMiklos Szeredi }
119153dbb0b4SMiklos Szeredi
119253dbb0b4SMiklos Szeredi err = -EINVAL;
119353dbb0b4SMiklos Szeredi sb->s_stack_depth++;
119453dbb0b4SMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
11951bd0a3aeSlijiazi pr_err("maximum fs stacking depth exceeded\n");
1196b36a5780SChristian Brauner return ERR_PTR(err);
119753dbb0b4SMiklos Szeredi }
119853dbb0b4SMiklos Szeredi
1199b36a5780SChristian Brauner err = ovl_get_layers(sb, ofs, ctx, layers);
12004155c10aSMiklos Szeredi if (err)
1201b36a5780SChristian Brauner return ERR_PTR(err);
12024155c10aSMiklos Szeredi
12034155c10aSMiklos Szeredi err = -ENOMEM;
120437ebf056SAmir Goldstein /* Data-only layers are not merged in root directory */
1205b36a5780SChristian Brauner nr_merged_lower = ctx->nr - ctx->nr_data;
1206b36a5780SChristian Brauner oe = ovl_alloc_entry(nr_merged_lower);
12074155c10aSMiklos Szeredi if (!oe)
1208b36a5780SChristian Brauner return ERR_PTR(err);
12094155c10aSMiklos Szeredi
12105522c9c7SAmir Goldstein lowerstack = ovl_lowerstack(oe);
1211b36a5780SChristian Brauner for (i = 0; i < nr_merged_lower; i++) {
1212b36a5780SChristian Brauner l = &ctx->lower[i];
1213b36a5780SChristian Brauner lowerstack[i].dentry = dget(l->path.dentry);
12145522c9c7SAmir Goldstein lowerstack[i].layer = &ofs->layers[i + 1];
12154155c10aSMiklos Szeredi }
1216b36a5780SChristian Brauner ofs->numdatalayer = ctx->nr_data;
12174155c10aSMiklos Szeredi
12184155c10aSMiklos Szeredi return oe;
121953dbb0b4SMiklos Szeredi }
122053dbb0b4SMiklos Szeredi
1221146d62e5SAmir Goldstein /*
1222146d62e5SAmir Goldstein * Check if this layer root is a descendant of:
1223146d62e5SAmir Goldstein * - another layer of this overlayfs instance
1224146d62e5SAmir Goldstein * - upper/work dir of any overlayfs instance
1225146d62e5SAmir Goldstein */
ovl_check_layer(struct super_block * sb,struct ovl_fs * ofs,struct dentry * dentry,const char * name,bool is_lower)12260be0bfd2SAmir Goldstein static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs,
1227708fa015SMiklos Szeredi struct dentry *dentry, const char *name,
1228708fa015SMiklos Szeredi bool is_lower)
1229146d62e5SAmir Goldstein {
12309179c21dSMiklos Szeredi struct dentry *next = dentry, *parent;
1231146d62e5SAmir Goldstein int err = 0;
1232146d62e5SAmir Goldstein
12339179c21dSMiklos Szeredi if (!dentry)
1234146d62e5SAmir Goldstein return 0;
1235146d62e5SAmir Goldstein
1236146d62e5SAmir Goldstein parent = dget_parent(next);
12379179c21dSMiklos Szeredi
12389179c21dSMiklos Szeredi /* Walk back ancestors to root (inclusive) looking for traps */
12399179c21dSMiklos Szeredi while (!err && parent != next) {
1240708fa015SMiklos Szeredi if (is_lower && ovl_lookup_trap_inode(sb, parent)) {
1241146d62e5SAmir Goldstein err = -ELOOP;
12421bd0a3aeSlijiazi pr_err("overlapping %s path\n", name);
12430be0bfd2SAmir Goldstein } else if (ovl_is_inuse(parent)) {
12440be0bfd2SAmir Goldstein err = ovl_report_in_use(ofs, name);
1245146d62e5SAmir Goldstein }
1246146d62e5SAmir Goldstein next = parent;
12479179c21dSMiklos Szeredi parent = dget_parent(next);
12489179c21dSMiklos Szeredi dput(next);
1249146d62e5SAmir Goldstein }
1250146d62e5SAmir Goldstein
12519179c21dSMiklos Szeredi dput(parent);
1252146d62e5SAmir Goldstein
1253146d62e5SAmir Goldstein return err;
1254146d62e5SAmir Goldstein }
1255146d62e5SAmir Goldstein
1256146d62e5SAmir Goldstein /*
1257146d62e5SAmir Goldstein * Check if any of the layers or work dirs overlap.
1258146d62e5SAmir Goldstein */
ovl_check_overlapping_layers(struct super_block * sb,struct ovl_fs * ofs)1259146d62e5SAmir Goldstein static int ovl_check_overlapping_layers(struct super_block *sb,
1260146d62e5SAmir Goldstein struct ovl_fs *ofs)
1261146d62e5SAmir Goldstein {
1262146d62e5SAmir Goldstein int i, err;
1263146d62e5SAmir Goldstein
126408f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs)) {
126508f4c7c8SMiklos Szeredi err = ovl_check_layer(sb, ofs, ovl_upper_mnt(ofs)->mnt_root,
1266708fa015SMiklos Szeredi "upperdir", false);
1267146d62e5SAmir Goldstein if (err)
1268146d62e5SAmir Goldstein return err;
1269146d62e5SAmir Goldstein
1270146d62e5SAmir Goldstein /*
1271146d62e5SAmir Goldstein * Checking workbasedir avoids hitting ovl_is_inuse(parent) of
1272146d62e5SAmir Goldstein * this instance and covers overlapping work and index dirs,
1273146d62e5SAmir Goldstein * unless work or index dir have been moved since created inside
1274146d62e5SAmir Goldstein * workbasedir. In that case, we already have their traps in
1275146d62e5SAmir Goldstein * inode cache and we will catch that case on lookup.
1276146d62e5SAmir Goldstein */
1277708fa015SMiklos Szeredi err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir",
1278708fa015SMiklos Szeredi false);
1279146d62e5SAmir Goldstein if (err)
1280146d62e5SAmir Goldstein return err;
1281146d62e5SAmir Goldstein }
1282146d62e5SAmir Goldstein
128394375f9dSAmir Goldstein for (i = 1; i < ofs->numlayer; i++) {
12840be0bfd2SAmir Goldstein err = ovl_check_layer(sb, ofs,
128594375f9dSAmir Goldstein ofs->layers[i].mnt->mnt_root,
1286708fa015SMiklos Szeredi "lowerdir", true);
1287146d62e5SAmir Goldstein if (err)
1288146d62e5SAmir Goldstein return err;
1289146d62e5SAmir Goldstein }
1290146d62e5SAmir Goldstein
1291146d62e5SAmir Goldstein return 0;
1292146d62e5SAmir Goldstein }
1293146d62e5SAmir Goldstein
ovl_get_root(struct super_block * sb,struct dentry * upperdentry,struct ovl_entry * oe)12942effc5c2SAmir Goldstein static struct dentry *ovl_get_root(struct super_block *sb,
12952effc5c2SAmir Goldstein struct dentry *upperdentry,
12962effc5c2SAmir Goldstein struct ovl_entry *oe)
12972effc5c2SAmir Goldstein {
12982effc5c2SAmir Goldstein struct dentry *root;
12995522c9c7SAmir Goldstein struct ovl_path *lowerpath = ovl_lowerstack(oe);
130062c832edSAmir Goldstein unsigned long ino = d_inode(lowerpath->dentry)->i_ino;
130162c832edSAmir Goldstein int fsid = lowerpath->layer->fsid;
130262c832edSAmir Goldstein struct ovl_inode_params oip = {
130362c832edSAmir Goldstein .upperdentry = upperdentry,
13040af950f5SAmir Goldstein .oe = oe,
130562c832edSAmir Goldstein };
13062effc5c2SAmir Goldstein
13072effc5c2SAmir Goldstein root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0));
13082effc5c2SAmir Goldstein if (!root)
13092effc5c2SAmir Goldstein return NULL;
13102effc5c2SAmir Goldstein
13112effc5c2SAmir Goldstein if (upperdentry) {
131262c832edSAmir Goldstein /* Root inode uses upper st_ino/i_ino */
131362c832edSAmir Goldstein ino = d_inode(upperdentry)->i_ino;
131462c832edSAmir Goldstein fsid = 0;
13152effc5c2SAmir Goldstein ovl_dentry_set_upper_alias(root);
1316610afc0bSMiklos Szeredi if (ovl_is_impuredir(sb, upperdentry))
13172effc5c2SAmir Goldstein ovl_set_flag(OVL_IMPURE, d_inode(root));
13182effc5c2SAmir Goldstein }
13192effc5c2SAmir Goldstein
13202effc5c2SAmir Goldstein /* Root is always merge -> can have whiteouts */
13212effc5c2SAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, d_inode(root));
13222effc5c2SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, root);
13232effc5c2SAmir Goldstein ovl_set_upperdata(d_inode(root));
132462c832edSAmir Goldstein ovl_inode_init(d_inode(root), &oip, ino, fsid);
13250af950f5SAmir Goldstein ovl_dentry_init_flags(root, upperdentry, oe, DCACHE_OP_WEAK_REVALIDATE);
1326367d002dSAmir Goldstein /* root keeps a reference of upperdentry */
1327367d002dSAmir Goldstein dget(upperdentry);
13282effc5c2SAmir Goldstein
13292effc5c2SAmir Goldstein return root;
13302effc5c2SAmir Goldstein }
13312effc5c2SAmir Goldstein
ovl_fill_super(struct super_block * sb,struct fs_context * fc)13327fb7998bSChristian Brauner int ovl_fill_super(struct super_block *sb, struct fs_context *fc)
1333e9be9d5eSMiklos Szeredi {
13341784fbc2SChristian Brauner struct ovl_fs *ofs = sb->s_fs_info;
13351784fbc2SChristian Brauner struct ovl_fs_context *ctx = fc->fs_private;
1336e9be9d5eSMiklos Szeredi struct dentry *root_dentry;
13374155c10aSMiklos Szeredi struct ovl_entry *oe;
1338b8e42a65SMiklos Szeredi struct ovl_layer *layers;
133951f8f3c4SKonstantin Khlebnikov struct cred *cred;
1340e9be9d5eSMiklos Szeredi int err;
1341e9be9d5eSMiklos Szeredi
13429efb069dSMiklos Szeredi err = -EIO;
13431784fbc2SChristian Brauner if (WARN_ON(fc->user_ns != current_user_ns()))
13441784fbc2SChristian Brauner goto out_err;
13459efb069dSMiklos Szeredi
1346f4288844SMiklos Szeredi sb->s_d_op = &ovl_dentry_operations;
1347f4288844SMiklos Szeredi
1348f45827e8SErez Zadok err = -ENOMEM;
1349ad204488SMiklos Szeredi ofs->creator_cred = cred = prepare_creds();
1350c6fe6254SMiklos Szeredi if (!cred)
1351c6fe6254SMiklos Szeredi goto out_err;
1352c6fe6254SMiklos Szeredi
13531784fbc2SChristian Brauner err = ovl_fs_params_verify(ctx, &ofs->config);
1354f45827e8SErez Zadok if (err)
1355a9075cdbSMiklos Szeredi goto out_err;
1356f45827e8SErez Zadok
1357e9be9d5eSMiklos Szeredi err = -EINVAL;
1358b36a5780SChristian Brauner if (ctx->nr == 0) {
13591784fbc2SChristian Brauner if (!(fc->sb_flags & SB_SILENT))
13601bd0a3aeSlijiazi pr_err("missing 'lowerdir'\n");
1361a9075cdbSMiklos Szeredi goto out_err;
136253a08cb9SMiklos Szeredi }
136353a08cb9SMiklos Szeredi
1364b8e42a65SMiklos Szeredi err = -ENOMEM;
1365b36a5780SChristian Brauner layers = kcalloc(ctx->nr + 1, sizeof(struct ovl_layer), GFP_KERNEL);
1366b8e42a65SMiklos Szeredi if (!layers)
1367b8e42a65SMiklos Szeredi goto out_err;
1368b8e42a65SMiklos Szeredi
1369a535116dSAmir Goldstein ofs->config.lowerdirs = kcalloc(ctx->nr + 1, sizeof(char *), GFP_KERNEL);
1370a535116dSAmir Goldstein if (!ofs->config.lowerdirs) {
1371a535116dSAmir Goldstein kfree(layers);
1372a535116dSAmir Goldstein goto out_err;
1373a535116dSAmir Goldstein }
1374b8e42a65SMiklos Szeredi ofs->layers = layers;
1375a535116dSAmir Goldstein /*
1376a535116dSAmir Goldstein * Layer 0 is reserved for upper even if there's no upper.
1377*26532aebSAmir Goldstein * config.lowerdirs[0] is used for storing the user provided colon
1378*26532aebSAmir Goldstein * separated lowerdir string.
1379a535116dSAmir Goldstein */
1380*26532aebSAmir Goldstein ofs->config.lowerdirs[0] = ctx->lowerdir_all;
1381*26532aebSAmir Goldstein ctx->lowerdir_all = NULL;
1382b8e42a65SMiklos Szeredi ofs->numlayer = 1;
1383b8e42a65SMiklos Szeredi
138453a08cb9SMiklos Szeredi sb->s_stack_depth = 0;
1385cf9a6784SMiklos Szeredi sb->s_maxbytes = MAX_LFS_FILESIZE;
13864d314f78SAmir Goldstein atomic_long_set(&ofs->last_ino, 1);
13874f119628SWilliam Dean /* Assume underlying fs uses 32bit inodes unless proven otherwise */
138853afcd31SAmir Goldstein if (ofs->config.xino != OVL_XINO_OFF) {
13890f831ec8SAmir Goldstein ofs->xino_mode = BITS_PER_LONG - 32;
139053afcd31SAmir Goldstein if (!ofs->xino_mode) {
139153afcd31SAmir Goldstein pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n");
139253afcd31SAmir Goldstein ofs->config.xino = OVL_XINO_OFF;
139353afcd31SAmir Goldstein }
139453afcd31SAmir Goldstein }
1395795939a9SAmir Goldstein
1396146d62e5SAmir Goldstein /* alloc/destroy_inode needed for setting up traps in inode cache */
1397146d62e5SAmir Goldstein sb->s_op = &ovl_super_operations;
1398146d62e5SAmir Goldstein
1399ad204488SMiklos Szeredi if (ofs->config.upperdir) {
1400335d3fc5SSargun Dhillon struct super_block *upper_sb;
1401335d3fc5SSargun Dhillon
1402d7b49b10SChengguang Xu err = -EINVAL;
1403ad204488SMiklos Szeredi if (!ofs->config.workdir) {
14041bd0a3aeSlijiazi pr_err("missing 'workdir'\n");
1405a9075cdbSMiklos Szeredi goto out_err;
1406e9be9d5eSMiklos Szeredi }
1407e9be9d5eSMiklos Szeredi
1408b36a5780SChristian Brauner err = ovl_get_upper(sb, ofs, &layers[0], &ctx->upper);
140921a3b317SMiklos Szeredi if (err)
1410a9075cdbSMiklos Szeredi goto out_err;
1411d719e8f2SMiklos Szeredi
1412335d3fc5SSargun Dhillon upper_sb = ovl_upper_mnt(ofs)->mnt_sb;
1413335d3fc5SSargun Dhillon if (!ovl_should_sync(ofs)) {
1414335d3fc5SSargun Dhillon ofs->errseq = errseq_sample(&upper_sb->s_wb_err);
1415335d3fc5SSargun Dhillon if (errseq_check(&upper_sb->s_wb_err, ofs->errseq)) {
1416335d3fc5SSargun Dhillon err = -EIO;
1417335d3fc5SSargun Dhillon pr_err("Cannot mount volatile when upperdir has an unseen error. Sync upperdir fs to clear state.\n");
1418335d3fc5SSargun Dhillon goto out_err;
1419335d3fc5SSargun Dhillon }
1420335d3fc5SSargun Dhillon }
1421335d3fc5SSargun Dhillon
1422b36a5780SChristian Brauner err = ovl_get_workdir(sb, ofs, &ctx->upper, &ctx->work);
14238ed61dc3SMiklos Szeredi if (err)
1424a9075cdbSMiklos Szeredi goto out_err;
1425c6fe6254SMiklos Szeredi
1426ad204488SMiklos Szeredi if (!ofs->workdir)
14271751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
14286e88256eSMiklos Szeredi
1429335d3fc5SSargun Dhillon sb->s_stack_depth = upper_sb->s_stack_depth;
1430335d3fc5SSargun Dhillon sb->s_time_gran = upper_sb->s_time_gran;
143121765194SVivek Goyal }
1432b36a5780SChristian Brauner oe = ovl_get_lowerstack(sb, ctx, ofs, layers);
14334155c10aSMiklos Szeredi err = PTR_ERR(oe);
14344155c10aSMiklos Szeredi if (IS_ERR(oe))
1435a9075cdbSMiklos Szeredi goto out_err;
1436e9be9d5eSMiklos Szeredi
143771cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */
143808f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs))
14391751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
1440e9be9d5eSMiklos Szeredi
1441b0504bfeSAmir Goldstein if (!ovl_origin_uuid(ofs) && ofs->numfs > 1) {
1442b0504bfeSAmir Goldstein pr_warn("The uuid=off requires a single fs for lower and upper, falling back to uuid=null.\n");
1443b0504bfeSAmir Goldstein ofs->config.uuid = OVL_UUID_NULL;
1444d9544c1bSAmir Goldstein } else if (ovl_has_fsid(ofs) && ovl_upper_mnt(ofs)) {
1445d9544c1bSAmir Goldstein /* Use per instance persistent uuid/fsid */
1446d9544c1bSAmir Goldstein ovl_init_uuid_xattr(sb, ofs, &ctx->upper);
14475830fb6bSPavel Tikhomirov }
14485830fb6bSPavel Tikhomirov
1449470c1563SAmir Goldstein if (!ovl_force_readonly(ofs) && ofs->config.index) {
1450b36a5780SChristian Brauner err = ovl_get_indexdir(sb, ofs, oe, &ctx->upper);
145154fb347eSAmir Goldstein if (err)
14524155c10aSMiklos Szeredi goto out_free_oe;
14536e88256eSMiklos Szeredi
1454972d0093SAmir Goldstein /* Force r/o mount with no index dir */
145520396365SAmir Goldstein if (!ofs->indexdir)
14561751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
145702bcd157SAmir Goldstein }
145802bcd157SAmir Goldstein
1459146d62e5SAmir Goldstein err = ovl_check_overlapping_layers(sb, ofs);
1460146d62e5SAmir Goldstein if (err)
1461146d62e5SAmir Goldstein goto out_free_oe;
1462146d62e5SAmir Goldstein
1463972d0093SAmir Goldstein /* Show index=off in /proc/mounts for forced r/o mount */
1464f168f109SAmir Goldstein if (!ofs->indexdir) {
1465ad204488SMiklos Szeredi ofs->config.index = false;
146608f4c7c8SMiklos Szeredi if (ovl_upper_mnt(ofs) && ofs->config.nfs_export) {
14671bd0a3aeSlijiazi pr_warn("NFS export requires an index dir, falling back to nfs_export=off.\n");
1468f168f109SAmir Goldstein ofs->config.nfs_export = false;
1469f168f109SAmir Goldstein }
1470f168f109SAmir Goldstein }
147102bcd157SAmir Goldstein
1472d5791044SVivek Goyal if (ofs->config.metacopy && ofs->config.nfs_export) {
14731bd0a3aeSlijiazi pr_warn("NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n");
1474d5791044SVivek Goyal ofs->config.nfs_export = false;
1475d5791044SVivek Goyal }
1476d5791044SVivek Goyal
147716aac5adSAmir Goldstein /*
147816aac5adSAmir Goldstein * Support encoding decodable file handles with nfs_export=on
147916aac5adSAmir Goldstein * and encoding non-decodable file handles with nfs_export=off
148016aac5adSAmir Goldstein * if all layers support file handles.
148116aac5adSAmir Goldstein */
14828383f174SAmir Goldstein if (ofs->config.nfs_export)
14838383f174SAmir Goldstein sb->s_export_op = &ovl_export_operations;
148416aac5adSAmir Goldstein else if (!ofs->nofh)
148516aac5adSAmir Goldstein sb->s_export_op = &ovl_export_fid_operations;
14868383f174SAmir Goldstein
148751f8f3c4SKonstantin Khlebnikov /* Never override disk quota limits or use reserved space */
148851f8f3c4SKonstantin Khlebnikov cap_lower(cred->cap_effective, CAP_SYS_RESOURCE);
148951f8f3c4SKonstantin Khlebnikov
1490655042ccSVivek Goyal sb->s_magic = OVERLAYFS_SUPER_MAGIC;
14912d2f2d73SMiklos Szeredi sb->s_xattr = ofs->config.userxattr ? ovl_user_xattr_handlers :
14922d2f2d73SMiklos Szeredi ovl_trusted_xattr_handlers;
1493ad204488SMiklos Szeredi sb->s_fs_info = ofs;
1494de2a4a50SMiklos Szeredi sb->s_flags |= SB_POSIXACL;
1495a3116387SMimi Zohar sb->s_iflags |= SB_I_SKIP_SYNC;
1496655042ccSVivek Goyal
1497c6fe6254SMiklos Szeredi err = -ENOMEM;
1498b36a5780SChristian Brauner root_dentry = ovl_get_root(sb, ctx->upper.dentry, oe);
1499e9be9d5eSMiklos Szeredi if (!root_dentry)
15004155c10aSMiklos Szeredi goto out_free_oe;
1501e9be9d5eSMiklos Szeredi
1502e9be9d5eSMiklos Szeredi sb->s_root = root_dentry;
1503e9be9d5eSMiklos Szeredi
1504e9be9d5eSMiklos Szeredi return 0;
1505e9be9d5eSMiklos Szeredi
15064155c10aSMiklos Szeredi out_free_oe:
1507163db0daSAmir Goldstein ovl_free_entry(oe);
15084155c10aSMiklos Szeredi out_err:
1509ad204488SMiklos Szeredi ovl_free_fs(ofs);
15101784fbc2SChristian Brauner sb->s_fs_info = NULL;
1511e9be9d5eSMiklos Szeredi return err;
1512e9be9d5eSMiklos Szeredi }
1513e9be9d5eSMiklos Szeredi
1514f01d0889SAndrea Righi struct file_system_type ovl_fs_type = {
1515e9be9d5eSMiklos Szeredi .owner = THIS_MODULE,
1516ef94b186SMiklos Szeredi .name = "overlay",
15171784fbc2SChristian Brauner .init_fs_context = ovl_init_fs_context,
15181784fbc2SChristian Brauner .parameters = ovl_parameter_spec,
1519459c7c56SMiklos Szeredi .fs_flags = FS_USERNS_MOUNT,
1520e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super,
1521e9be9d5eSMiklos Szeredi };
1522ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay");
1523e9be9d5eSMiklos Szeredi
ovl_inode_init_once(void * foo)152413cf199dSAmir Goldstein static void ovl_inode_init_once(void *foo)
152513cf199dSAmir Goldstein {
152613cf199dSAmir Goldstein struct ovl_inode *oi = foo;
152713cf199dSAmir Goldstein
152813cf199dSAmir Goldstein inode_init_once(&oi->vfs_inode);
152913cf199dSAmir Goldstein }
153013cf199dSAmir Goldstein
ovl_init(void)1531e9be9d5eSMiklos Szeredi static int __init ovl_init(void)
1532e9be9d5eSMiklos Szeredi {
153313cf199dSAmir Goldstein int err;
153413cf199dSAmir Goldstein
153513cf199dSAmir Goldstein ovl_inode_cachep = kmem_cache_create("ovl_inode",
153613cf199dSAmir Goldstein sizeof(struct ovl_inode), 0,
153713cf199dSAmir Goldstein (SLAB_RECLAIM_ACCOUNT|
153813cf199dSAmir Goldstein SLAB_MEM_SPREAD|SLAB_ACCOUNT),
153913cf199dSAmir Goldstein ovl_inode_init_once);
154013cf199dSAmir Goldstein if (ovl_inode_cachep == NULL)
154113cf199dSAmir Goldstein return -ENOMEM;
154213cf199dSAmir Goldstein
15432406a307SJiufei Xue err = ovl_aio_request_cache_init();
15442406a307SJiufei Xue if (!err) {
154513cf199dSAmir Goldstein err = register_filesystem(&ovl_fs_type);
15462406a307SJiufei Xue if (!err)
15472406a307SJiufei Xue return 0;
15482406a307SJiufei Xue
15492406a307SJiufei Xue ovl_aio_request_cache_destroy();
15502406a307SJiufei Xue }
155113cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep);
155213cf199dSAmir Goldstein
155313cf199dSAmir Goldstein return err;
1554e9be9d5eSMiklos Szeredi }
1555e9be9d5eSMiklos Szeredi
ovl_exit(void)1556e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void)
1557e9be9d5eSMiklos Szeredi {
1558e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type);
155913cf199dSAmir Goldstein
156013cf199dSAmir Goldstein /*
156113cf199dSAmir Goldstein * Make sure all delayed rcu free inodes are flushed before we
156213cf199dSAmir Goldstein * destroy cache.
156313cf199dSAmir Goldstein */
156413cf199dSAmir Goldstein rcu_barrier();
156513cf199dSAmir Goldstein kmem_cache_destroy(ovl_inode_cachep);
15662406a307SJiufei Xue ovl_aio_request_cache_destroy();
1567e9be9d5eSMiklos Szeredi }
1568e9be9d5eSMiklos Szeredi
1569e9be9d5eSMiklos Szeredi module_init(ovl_init);
1570e9be9d5eSMiklos Szeredi module_exit(ovl_exit);
1571