Commit 7f879e1a authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'ovl-update-5.6' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/vfs 

Pull overlayfs update from Miklos Szeredi:

 - Try to preserve holes in sparse files when copying up, thus saving
   disk space and improving performance.

 - Fix a performance regression introduced in v4.19 by preserving
   asynchronicity of IO when fowarding to underlying layers. Add VFS
   helpers to submit async iocbs.

 - Fix a regression in lseek(2) introduced in v4.19 that breaks >2G
   seeks on 32bit kernels.

 - Fix a corner case where st_ino/st_dev was not preserved across copy
   up.

 - Miscellaneous fixes and cleanups.

* tag 'ovl-update-5.6' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/vfs:
  ovl: fix lseek overflow on 32bit
  ovl: add splice file read write helper
  ovl: implement async IO routines
  vfs: add vfs_iocb_iter_[read|write] helper functions
  ovl: layer is const
  ovl: fix corner case of non-constant st_dev;st_ino
  ovl: fix corner case of conflicting lower layer uuid
  ovl: generalize the lower_fs[] array
  ovl: simplify ovl_same_sb() helper
  ovl: generalize the lower_layers[] array
  ovl: improving copy-up efficiency for big sparse file
  ovl: use ovl_inode_lock in ovl_llseek()
  ovl: use pr_fmt auto generate prefix
  ovl: fix wrong WARN_ON() in ovl_cache_update_ino()
parents a45ad71e a4ac9d45

fs/overlayfs/copy_up.c

+40 −3
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ 


static int ovl_ccup_set(const char *buf, const struct kernel_param *param)

{

	pr_warn("overlayfs: \"check_copy_up\" module option is obsolete\n");

	pr_warn("\"check_copy_up\" module option is obsolete\n");

	return 0;

}
@@ -123,6 +123,9 @@ static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len) 
	loff_t old_pos = 0;

	loff_t new_pos = 0;

	loff_t cloned;

	loff_t data_pos = -1;

	loff_t hole_len;

	bool skip_hole = false;

	int error = 0;



	if (len == 0)
@@ -144,7 +147,11 @@ static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len) 
		goto out;

	/* Couldn't clone, so now we try to copy the data */



	/* FIXME: copy up sparse files efficiently */

	/* Check if lower fs supports seek operation */

	if (old_file->f_mode & FMODE_LSEEK &&

	    old_file->f_op->llseek)

		skip_hole = true;



	while (len) {

		size_t this_len = OVL_COPY_UP_CHUNK_SIZE;

		long bytes;
@@ -157,6 +164,36 @@ static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len) 
			break;

		}



		/*

		 * Fill zero for hole will cost unnecessary disk space

		 * and meanwhile slow down the copy-up speed, so we do

		 * an optimization for hole during copy-up, it relies

		 * on SEEK_DATA implementation in lower fs so if lower

		 * fs does not support it, copy-up will behave as before.

		 *

		 * Detail logic of hole detection as below:

		 * When we detect next data position is larger than current

		 * position we will skip that hole, otherwise we copy

		 * data in the size of OVL_COPY_UP_CHUNK_SIZE. Actually,

		 * it may not recognize all kind of holes and sometimes

		 * only skips partial of hole area. However, it will be

		 * enough for most of the use cases.

		 */



		if (skip_hole && data_pos < old_pos) {

			data_pos = vfs_llseek(old_file, old_pos, SEEK_DATA);

			if (data_pos > old_pos) {

				hole_len = data_pos - old_pos;

				len -= hole_len;

				old_pos = new_pos = data_pos;

				continue;

			} else if (data_pos == -ENXIO) {

				break;

			} else if (data_pos < 0) {

				skip_hole = false;

			}

		}



		bytes = do_splice_direct(old_file, &old_pos,

					 new_file, &new_pos,

					 this_len, SPLICE_F_MOVE);
@@ -480,7 +517,7 @@ static int ovl_copy_up_inode(struct ovl_copy_up_ctx *c, struct dentry *temp) 
	}



	inode_lock(temp->d_inode);

	if (c->metacopy)

	if (S_ISREG(c->stat.mode))

		err = ovl_set_size(temp, &c->stat);

	if (!err)

		err = ovl_set_attr(temp, &c->stat);

fs/overlayfs/dir.c

+5 −5
Original line number Diff line number Diff line
@@ -35,7 +35,7 @@ int ovl_cleanup(struct inode *wdir, struct dentry *wdentry) 
	dput(wdentry);



	if (err) {

		pr_err("overlayfs: cleanup of '%pd2' failed (%i)\n",

		pr_err("cleanup of '%pd2' failed (%i)\n",

		       wdentry, err);

	}
@@ -53,7 +53,7 @@ static struct dentry *ovl_lookup_temp(struct dentry *workdir) 


	temp = lookup_one_len(name, workdir, strlen(name));

	if (!IS_ERR(temp) && temp->d_inode) {

		pr_err("overlayfs: workdir/%s already exists\n", name);

		pr_err("workdir/%s already exists\n", name);

		dput(temp);

		temp = ERR_PTR(-EIO);

	}
@@ -134,7 +134,7 @@ static int ovl_mkdir_real(struct inode *dir, struct dentry **newdentry, 
	d = lookup_one_len(dentry->d_name.name, dentry->d_parent,

			   dentry->d_name.len);

	if (IS_ERR(d)) {

		pr_warn("overlayfs: failed lookup after mkdir (%pd2, err=%i).\n",

		pr_warn("failed lookup after mkdir (%pd2, err=%i).\n",

			dentry, err);

		return PTR_ERR(d);

	}
@@ -267,7 +267,7 @@ static int ovl_instantiate(struct dentry *dentry, struct inode *inode, 


	d_instantiate(dentry, inode);

	if (inode != oip.newinode) {

		pr_warn_ratelimited("overlayfs: newly created inode found in cache (%pd2)\n",

		pr_warn_ratelimited("newly created inode found in cache (%pd2)\n",

				    dentry);

	}
@@ -1009,7 +1009,7 @@ static int ovl_set_redirect(struct dentry *dentry, bool samedir) 
		spin_unlock(&dentry->d_lock);

	} else {

		kfree(redirect);

		pr_warn_ratelimited("overlayfs: failed to set redirect (%i)\n",

		pr_warn_ratelimited("failed to set redirect (%i)\n",

				    err);

		/* Fall back to userspace copy-up */

		err = -EXDEV;

fs/overlayfs/export.c

+13 −15
Original line number Diff line number Diff line
@@ -30,7 +30,7 @@ static int ovl_encode_maybe_copy_up(struct dentry *dentry) 
	}



	if (err) {

		pr_warn_ratelimited("overlayfs: failed to copy up on encode (%pd2, err=%i)\n",

		pr_warn_ratelimited("failed to copy up on encode (%pd2, err=%i)\n",

				    dentry, err);

	}
@@ -244,7 +244,7 @@ out: 
	return err;



fail:

	pr_warn_ratelimited("overlayfs: failed to encode file handle (%pd2, err=%i, buflen=%d, len=%d, type=%d)\n",

	pr_warn_ratelimited("failed to encode file handle (%pd2, err=%i, buflen=%d, len=%d, type=%d)\n",

			    dentry, err, buflen, fh ? (int)fh->fb.len : 0,

			    fh ? fh->fb.type : 0);

	goto out;
@@ -358,7 +358,7 @@ static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx) 
 */

static struct dentry *ovl_lookup_real_one(struct dentry *connected,

					  struct dentry *real,

					  struct ovl_layer *layer)

					  const struct ovl_layer *layer)

{

	struct inode *dir = d_inode(connected);

	struct dentry *this, *parent = NULL;
@@ -406,7 +406,7 @@ out: 
	return this;



fail:

	pr_warn_ratelimited("overlayfs: failed to lookup one by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",

	pr_warn_ratelimited("failed to lookup one by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",

			    real, layer->idx, connected, err);

	this = ERR_PTR(err);

	goto out;
@@ -414,17 +414,16 @@ fail: 


static struct dentry *ovl_lookup_real(struct super_block *sb,

				      struct dentry *real,

				      struct ovl_layer *layer);

				      const struct ovl_layer *layer);



/*

 * Lookup an indexed or hashed overlay dentry by real inode.

 */

static struct dentry *ovl_lookup_real_inode(struct super_block *sb,

					    struct dentry *real,

					    struct ovl_layer *layer)

					    const struct ovl_layer *layer)

{

	struct ovl_fs *ofs = sb->s_fs_info;

	struct ovl_layer upper_layer = { .mnt = ofs->upper_mnt };

	struct dentry *index = NULL;

	struct dentry *this = NULL;

	struct inode *inode;
@@ -466,7 +465,7 @@ static struct dentry *ovl_lookup_real_inode(struct super_block *sb, 
		 * recursive call walks back from indexed upper to the topmost

		 * connected/hashed upper parent (or up to root).

		 */

		this = ovl_lookup_real(sb, upper, &upper_layer);

		this = ovl_lookup_real(sb, upper, &ofs->layers[0]);

		dput(upper);

	}
@@ -487,7 +486,7 @@ static struct dentry *ovl_lookup_real_inode(struct super_block *sb, 
 */

static struct dentry *ovl_lookup_real_ancestor(struct super_block *sb,

					       struct dentry *real,

					       struct ovl_layer *layer)

					       const struct ovl_layer *layer)

{

	struct dentry *next, *parent = NULL;

	struct dentry *ancestor = ERR_PTR(-EIO);
@@ -540,7 +539,7 @@ static struct dentry *ovl_lookup_real_ancestor(struct super_block *sb, 
 */

static struct dentry *ovl_lookup_real(struct super_block *sb,

				      struct dentry *real,

				      struct ovl_layer *layer)

				      const struct ovl_layer *layer)

{

	struct dentry *connected;

	int err = 0;
@@ -631,7 +630,7 @@ static struct dentry *ovl_lookup_real(struct super_block *sb, 
	return connected;



fail:

	pr_warn_ratelimited("overlayfs: failed to lookup by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",

	pr_warn_ratelimited("failed to lookup by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",

			    real, layer->idx, connected, err);

	dput(connected);

	return ERR_PTR(err);
@@ -646,8 +645,7 @@ static struct dentry *ovl_get_dentry(struct super_block *sb, 
				     struct dentry *index)

{

	struct ovl_fs *ofs = sb->s_fs_info;

	struct ovl_layer upper_layer = { .mnt = ofs->upper_mnt };

	struct ovl_layer *layer = upper ? &upper_layer : lowerpath->layer;

	const struct ovl_layer *layer = upper ? &ofs->layers[0] : lowerpath->layer;

	struct dentry *real = upper ?: (index ?: lowerpath->dentry);



	/*
@@ -822,7 +820,7 @@ out: 
	return dentry;



out_err:

	pr_warn_ratelimited("overlayfs: failed to decode file handle (len=%d, type=%d, flags=%x, err=%i)\n",

	pr_warn_ratelimited("failed to decode file handle (len=%d, type=%d, flags=%x, err=%i)\n",

			    fh_len, fh_type, flags, err);

	dentry = ERR_PTR(err);

	goto out;
@@ -831,7 +829,7 @@ out_err: 
static struct dentry *ovl_fh_to_parent(struct super_block *sb, struct fid *fid,

				       int fh_len, int fh_type)

{

	pr_warn_ratelimited("overlayfs: connectable file handles not supported; use 'no_subtree_check' exportfs option.\n");

	pr_warn_ratelimited("connectable file handles not supported; use 'no_subtree_check' exportfs option.\n");

	return ERR_PTR(-EACCES);

}

fs/overlayfs/file.c

+148 −14
Original line number Diff line number Diff line
@@ -9,8 +9,19 @@ 
#include <linux/xattr.h>

#include <linux/uio.h>

#include <linux/uaccess.h>

#include <linux/splice.h>

#include <linux/mm.h>

#include <linux/fs.h>

#include "overlayfs.h"



struct ovl_aio_req {

	struct kiocb iocb;

	struct kiocb *orig_iocb;

	struct fd fd;

};



static struct kmem_cache *ovl_aio_request_cachep;



static char ovl_whatisit(struct inode *inode, struct inode *realinode)

{

	if (realinode != ovl_inode_upper(inode))
@@ -146,7 +157,7 @@ static loff_t ovl_llseek(struct file *file, loff_t offset, int whence) 
	struct inode *inode = file_inode(file);

	struct fd real;

	const struct cred *old_cred;

	ssize_t ret;

	loff_t ret;



	/*

	 * The two special cases below do not need to involve real fs,
@@ -171,7 +182,7 @@ static loff_t ovl_llseek(struct file *file, loff_t offset, int whence) 
	 * limitations that are more strict than ->s_maxbytes for specific

	 * files, so we use the real file to perform seeks.

	 */

	inode_lock(inode);

	ovl_inode_lock(inode);

	real.file->f_pos = file->f_pos;



	old_cred = ovl_override_creds(inode->i_sb);
@@ -179,7 +190,7 @@ static loff_t ovl_llseek(struct file *file, loff_t offset, int whence) 
	revert_creds(old_cred);



	file->f_pos = real.file->f_pos;

	inode_unlock(inode);

	ovl_inode_unlock(inode);



	fdput(real);
@@ -225,6 +236,33 @@ static rwf_t ovl_iocb_to_rwf(struct kiocb *iocb) 
	return flags;

}



static void ovl_aio_cleanup_handler(struct ovl_aio_req *aio_req)

{

	struct kiocb *iocb = &aio_req->iocb;

	struct kiocb *orig_iocb = aio_req->orig_iocb;



	if (iocb->ki_flags & IOCB_WRITE) {

		struct inode *inode = file_inode(orig_iocb->ki_filp);



		file_end_write(iocb->ki_filp);

		ovl_copyattr(ovl_inode_real(inode), inode);

	}



	orig_iocb->ki_pos = iocb->ki_pos;

	fdput(aio_req->fd);

	kmem_cache_free(ovl_aio_request_cachep, aio_req);

}



static void ovl_aio_rw_complete(struct kiocb *iocb, long res, long res2)

{

	struct ovl_aio_req *aio_req = container_of(iocb,

						   struct ovl_aio_req, iocb);

	struct kiocb *orig_iocb = aio_req->orig_iocb;



	ovl_aio_cleanup_handler(aio_req);

	orig_iocb->ki_complete(orig_iocb, res, res2);

}



static ssize_t ovl_read_iter(struct kiocb *iocb, struct iov_iter *iter)

{

	struct file *file = iocb->ki_filp;
@@ -240,10 +278,28 @@ static ssize_t ovl_read_iter(struct kiocb *iocb, struct iov_iter *iter) 
		return ret;



	old_cred = ovl_override_creds(file_inode(file)->i_sb);

	if (is_sync_kiocb(iocb)) {

		ret = vfs_iter_read(real.file, iter, &iocb->ki_pos,

				    ovl_iocb_to_rwf(iocb));

	} else {

		struct ovl_aio_req *aio_req;



		ret = -ENOMEM;

		aio_req = kmem_cache_zalloc(ovl_aio_request_cachep, GFP_KERNEL);

		if (!aio_req)

			goto out;



		aio_req->fd = real;

		real.flags = 0;

		aio_req->orig_iocb = iocb;

		kiocb_clone(&aio_req->iocb, iocb, real.file);

		aio_req->iocb.ki_complete = ovl_aio_rw_complete;

		ret = vfs_iocb_iter_read(real.file, &aio_req->iocb, iter);

		if (ret != -EIOCBQUEUED)

			ovl_aio_cleanup_handler(aio_req);

	}

out:

	revert_creds(old_cred);



	ovl_file_accessed(file);



	fdput(real);
@@ -274,15 +330,33 @@ static ssize_t ovl_write_iter(struct kiocb *iocb, struct iov_iter *iter) 
		goto out_unlock;



	old_cred = ovl_override_creds(file_inode(file)->i_sb);

	if (is_sync_kiocb(iocb)) {

		file_start_write(real.file);

		ret = vfs_iter_write(real.file, iter, &iocb->ki_pos,

				     ovl_iocb_to_rwf(iocb));

		file_end_write(real.file);

	revert_creds(old_cred);



		/* Update size */

		ovl_copyattr(ovl_inode_real(inode), inode);

	} else {

		struct ovl_aio_req *aio_req;



		ret = -ENOMEM;

		aio_req = kmem_cache_zalloc(ovl_aio_request_cachep, GFP_KERNEL);

		if (!aio_req)

			goto out;



		file_start_write(real.file);

		aio_req->fd = real;

		real.flags = 0;

		aio_req->orig_iocb = iocb;

		kiocb_clone(&aio_req->iocb, iocb, real.file);

		aio_req->iocb.ki_complete = ovl_aio_rw_complete;

		ret = vfs_iocb_iter_write(real.file, &aio_req->iocb, iter);

		if (ret != -EIOCBQUEUED)

			ovl_aio_cleanup_handler(aio_req);

	}

out:

	revert_creds(old_cred);

	fdput(real);



out_unlock:
@@ -291,6 +365,48 @@ out_unlock: 
	return ret;

}



static ssize_t ovl_splice_read(struct file *in, loff_t *ppos,

			 struct pipe_inode_info *pipe, size_t len,

			 unsigned int flags)

{

	ssize_t ret;

	struct fd real;

	const struct cred *old_cred;



	ret = ovl_real_fdget(in, &real);

	if (ret)

		return ret;



	old_cred = ovl_override_creds(file_inode(in)->i_sb);

	ret = generic_file_splice_read(real.file, ppos, pipe, len, flags);

	revert_creds(old_cred);



	ovl_file_accessed(in);

	fdput(real);

	return ret;

}



static ssize_t

ovl_splice_write(struct pipe_inode_info *pipe, struct file *out,

			  loff_t *ppos, size_t len, unsigned int flags)

{

	struct fd real;

	const struct cred *old_cred;

	ssize_t ret;



	ret = ovl_real_fdget(out, &real);

	if (ret)

		return ret;



	old_cred = ovl_override_creds(file_inode(out)->i_sb);

	ret = iter_file_splice_write(pipe, real.file, ppos, len, flags);

	revert_creds(old_cred);



	ovl_file_accessed(out);

	fdput(real);

	return ret;

}



static int ovl_fsync(struct file *file, loff_t start, loff_t end, int datasync)

{

	struct fd real;
@@ -647,7 +763,25 @@ const struct file_operations ovl_file_operations = { 
	.fadvise	= ovl_fadvise,

	.unlocked_ioctl	= ovl_ioctl,

	.compat_ioctl	= ovl_compat_ioctl,

	.splice_read    = ovl_splice_read,

	.splice_write   = ovl_splice_write,



	.copy_file_range	= ovl_copy_file_range,

	.remap_file_range	= ovl_remap_file_range,

};



int __init ovl_aio_request_cache_init(void)

{

	ovl_aio_request_cachep = kmem_cache_create("ovl_aio_req",

						   sizeof(struct ovl_aio_req),

						   0, SLAB_HWCACHE_ALIGN, NULL);

	if (!ovl_aio_request_cachep)

		return -ENOMEM;



	return 0;

}



void ovl_aio_request_cache_destroy(void)

{

	kmem_cache_destroy(ovl_aio_request_cachep);

}

fs/overlayfs/inode.c

+38 −28
Original line number Diff line number Diff line
@@ -75,10 +75,9 @@ out: 
	return err;

}



static int ovl_map_dev_ino(struct dentry *dentry, struct kstat *stat,

			   struct ovl_layer *lower_layer)

static int ovl_map_dev_ino(struct dentry *dentry, struct kstat *stat, int fsid)

{

	bool samefs = ovl_same_sb(dentry->d_sb);

	bool samefs = ovl_same_fs(dentry->d_sb);

	unsigned int xinobits = ovl_xino_bits(dentry->d_sb);



	if (samefs) {
@@ -100,12 +99,10 @@ static int ovl_map_dev_ino(struct dentry *dentry, struct kstat *stat, 
		 * persistent for a given layer configuration.

		 */

		if (stat->ino >> shift) {

			pr_warn_ratelimited("overlayfs: inode number too big (%pd2, ino=%llu, xinobits=%d)\n",

			pr_warn_ratelimited("inode number too big (%pd2, ino=%llu, xinobits=%d)\n",

					    dentry, stat->ino, xinobits);

		} else {

			if (lower_layer)

				stat->ino |= ((u64)lower_layer->fsid) << shift;



			stat->ino |= ((u64)fsid) << shift;

			stat->dev = dentry->d_sb->s_dev;

			return 0;

		}
@@ -124,15 +121,14 @@ static int ovl_map_dev_ino(struct dentry *dentry, struct kstat *stat, 
		 */

		stat->dev = dentry->d_sb->s_dev;

		stat->ino = dentry->d_inode->i_ino;

	} else if (lower_layer && lower_layer->fsid) {

	} else {

		/*

		 * For non-samefs setup, if we cannot map all layers st_ino

		 * to a unified address space, we need to make sure that st_dev

		 * is unique per lower fs. Upper layer uses real st_dev and

		 * lower layers use the unique anonymous bdev assigned to the

		 * lower fs.

		 * is unique per underlying fs, so we use the unique anonymous

		 * bdev assigned to the underlying fs.

		 */

		stat->dev = lower_layer->fs->pseudo_dev;

		stat->dev = OVL_FS(dentry->d_sb)->fs[fsid].pseudo_dev;

	}



	return 0;
@@ -146,8 +142,7 @@ int ovl_getattr(const struct path *path, struct kstat *stat, 
	struct path realpath;

	const struct cred *old_cred;

	bool is_dir = S_ISDIR(dentry->d_inode->i_mode);

	bool samefs = ovl_same_sb(dentry->d_sb);

	struct ovl_layer *lower_layer = NULL;

	int fsid = 0;

	int err;

	bool metacopy_blocks = false;
@@ -168,9 +163,9 @@ int ovl_getattr(const struct path *path, struct kstat *stat, 
	 * If lower filesystem supports NFS file handles, this also guaranties

	 * persistent st_ino across mount cycle.

	 */

	if (!is_dir || samefs || ovl_xino_bits(dentry->d_sb)) {

	if (!is_dir || ovl_same_dev(dentry->d_sb)) {

		if (!OVL_TYPE_UPPER(type)) {

			lower_layer = ovl_layer_lower(dentry);

			fsid = ovl_layer_lower(dentry)->fsid;

		} else if (OVL_TYPE_ORIGIN(type)) {

			struct kstat lowerstat;

			u32 lowermask = STATX_INO | STATX_BLOCKS |
@@ -200,13 +195,7 @@ int ovl_getattr(const struct path *path, struct kstat *stat, 
			if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) ||

			    (!ovl_verify_lower(dentry->d_sb) &&

			     (is_dir || lowerstat.nlink == 1))) {

				lower_layer = ovl_layer_lower(dentry);

				/*

				 * Cannot use origin st_dev;st_ino because

				 * origin inode content may differ from overlay

				 * inode content.

				 */

				if (samefs || lower_layer->fsid)

				fsid = ovl_layer_lower(dentry)->fsid;

				stat->ino = lowerstat.ino;

			}
@@ -241,7 +230,7 @@ int ovl_getattr(const struct path *path, struct kstat *stat, 
		}

	}



	err = ovl_map_dev_ino(dentry, stat, lower_layer);

	err = ovl_map_dev_ino(dentry, stat, fsid);

	if (err)

		goto out;
@@ -527,6 +516,27 @@ static const struct address_space_operations ovl_aops = { 
 * [...] &ovl_i_mutex_dir_key[depth]   (stack_depth=2)

 * [...] &ovl_i_mutex_dir_key[depth]#2 (stack_depth=1)

 * [...] &type->i_mutex_dir_key        (stack_depth=0)

 *

 * Locking order w.r.t ovl_want_write() is important for nested overlayfs.

 *

 * This chain is valid:

 * - inode->i_rwsem			(inode_lock[2])

 * - upper_mnt->mnt_sb->s_writers	(ovl_want_write[0])

 * - OVL_I(inode)->lock			(ovl_inode_lock[2])

 * - OVL_I(lowerinode)->lock		(ovl_inode_lock[1])

 *

 * And this chain is valid:

 * - inode->i_rwsem			(inode_lock[2])

 * - OVL_I(inode)->lock			(ovl_inode_lock[2])

 * - lowerinode->i_rwsem		(inode_lock[1])

 * - OVL_I(lowerinode)->lock		(ovl_inode_lock[1])

 *

 * But lowerinode->i_rwsem SHOULD NOT be acquired while ovl_want_write() is

 * held, because it is in reverse order of the non-nested case using the same

 * upper fs:

 * - inode->i_rwsem			(inode_lock[1])

 * - upper_mnt->mnt_sb->s_writers	(ovl_want_write[0])

 * - OVL_I(inode)->lock			(ovl_inode_lock[1])

 */

#define OVL_MAX_NESTING FILESYSTEM_MAX_STACK_DEPTH
@@ -565,7 +575,7 @@ static void ovl_fill_inode(struct inode *inode, umode_t mode, dev_t rdev, 
	 * ovl_new_inode(), ino arg is 0, so i_ino will be updated to real

	 * upper inode i_ino on ovl_inode_init() or ovl_inode_update().

	 */

	if (ovl_same_sb(inode->i_sb) || xinobits) {

	if (ovl_same_dev(inode->i_sb)) {

		inode->i_ino = ino;

		if (xinobits && fsid && !(ino >> (64 - xinobits)))

			inode->i_ino |= (unsigned long)fsid << (64 - xinobits);
@@ -698,7 +708,7 @@ unsigned int ovl_get_nlink(struct dentry *lowerdentry, 
	return nlink;



fail:

	pr_warn_ratelimited("overlayfs: failed to get index nlink (%pd2, err=%i)\n",

	pr_warn_ratelimited("failed to get index nlink (%pd2, err=%i)\n",

			    upperdentry, err);

	return fallback;

}
@@ -969,7 +979,7 @@ out: 
	return inode;



out_err:

	pr_warn_ratelimited("overlayfs: failed to get inode (%i)\n", err);

	pr_warn_ratelimited("failed to get inode (%i)\n", err);

	inode = ERR_PTR(err);

	goto out;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE