Commit 2c5ca23f authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull overlayfs updates from Miklos Szeredi:

 - Support idmapped layers in overlayfs (Christian Brauner)

 - Add a fix to exportfs that is relevant to open_by_handle_at(2) as
   well

 - Introduce new lookup helpers that allow passing mnt_userns into
   inode_permission()

* tag 'ovl-update-5.19' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/vfs:
  ovl: support idmapped layers
  ovl: handle idmappings in ovl_xattr_{g,s}et()
  ovl: handle idmappings in layer open helpers
  ovl: handle idmappings in ovl_permission()
  ovl: use ovl_copy_{real,upper}attr() wrappers
  ovl: store lower path in ovl_inode
  ovl: handle idmappings for layer lookup
  ovl: handle idmappings for layer fileattrs
  ovl: use ovl_path_getxattr() wrapper
  ovl: use ovl_lookup_upper() wrapper
  ovl: use ovl_do_notify_change() wrapper
  ovl: pass layer mnt to ovl_open_realfile()
  ovl: pass ofs to setattr operations
  ovl: handle idmappings in creation operations
  ovl: add ovl_upper_mnt_userns() wrapper
  ovl: pass ofs to creation operations
  ovl: use wrappers to all vfs_*xattr() calls
  exportfs: support idmapped mounts
  fs: add two trivial lookup helpers
parents 73d15ba6 bc70682a

fs/exportfs/expfs.c

+3 −2
Original line number Diff line number Diff line
@@ -145,7 +145,7 @@ static struct dentry *reconnect_one(struct vfsmount *mnt, 
	if (err)

		goto out_err;

	dprintk("%s: found name: %s\n", __func__, nbuf);

	tmp = lookup_one_len_unlocked(nbuf, parent, strlen(nbuf));

	tmp = lookup_one_unlocked(mnt_user_ns(mnt), nbuf, parent, strlen(nbuf));

	if (IS_ERR(tmp)) {

		dprintk("%s: lookup failed: %d\n", __func__, PTR_ERR(tmp));

		err = PTR_ERR(tmp);
@@ -525,7 +525,8 @@ exportfs_decode_fh_raw(struct vfsmount *mnt, struct fid *fid, int fh_len, 
		}



		inode_lock(target_dir->d_inode);

		nresult = lookup_one_len(nbuf, target_dir, strlen(nbuf));

		nresult = lookup_one(mnt_user_ns(mnt), nbuf,

				     target_dir, strlen(nbuf));

		if (!IS_ERR(nresult)) {

			if (unlikely(nresult->d_inode != result->d_inode)) {

				dput(nresult);

fs/namei.c

+60 −10
Original line number Diff line number Diff line
@@ -2769,7 +2769,8 @@ struct dentry *lookup_one(struct user_namespace *mnt_userns, const char *name, 
EXPORT_SYMBOL(lookup_one);



/**

 * lookup_one_len_unlocked - filesystem helper to lookup single pathname component

 * lookup_one_unlocked - filesystem helper to lookup single pathname component

 * @mnt_userns:	idmapping of the mount the lookup is performed from

 * @name:	pathname component to lookup

 * @base:	base directory to lookup from

 * @len:	maximum length @len should be interpreted to
@@ -2780,14 +2781,15 @@ EXPORT_SYMBOL(lookup_one); 
 * Unlike lookup_one_len, it should be called without the parent

 * i_mutex held, and will take the i_mutex itself if necessary.

 */

struct dentry *lookup_one_len_unlocked(const char *name,

				       struct dentry *base, int len)

struct dentry *lookup_one_unlocked(struct user_namespace *mnt_userns,

				   const char *name, struct dentry *base,

				   int len)

{

	struct qstr this;

	int err;

	struct dentry *ret;



	err = lookup_one_common(&init_user_ns, name, base, len, &this);

	err = lookup_one_common(mnt_userns, name, base, len, &this);

	if (err)

		return ERR_PTR(err);
@@ -2796,6 +2798,59 @@ struct dentry *lookup_one_len_unlocked(const char *name, 
		ret = lookup_slow(&this, base, 0);

	return ret;

}

EXPORT_SYMBOL(lookup_one_unlocked);



/**

 * lookup_one_positive_unlocked - filesystem helper to lookup single

 *				  pathname component

 * @mnt_userns:	idmapping of the mount the lookup is performed from

 * @name:	pathname component to lookup

 * @base:	base directory to lookup from

 * @len:	maximum length @len should be interpreted to

 *

 * This helper will yield ERR_PTR(-ENOENT) on negatives. The helper returns

 * known positive or ERR_PTR(). This is what most of the users want.

 *

 * Note that pinned negative with unlocked parent _can_ become positive at any

 * time, so callers of lookup_one_unlocked() need to be very careful; pinned

 * positives have >d_inode stable, so this one avoids such problems.

 *

 * Note that this routine is purely a helper for filesystem usage and should

 * not be called by generic code.

 *

 * The helper should be called without i_mutex held.

 */

struct dentry *lookup_one_positive_unlocked(struct user_namespace *mnt_userns,

					    const char *name,

					    struct dentry *base, int len)

{

	struct dentry *ret = lookup_one_unlocked(mnt_userns, name, base, len);



	if (!IS_ERR(ret) && d_flags_negative(smp_load_acquire(&ret->d_flags))) {

		dput(ret);

		ret = ERR_PTR(-ENOENT);

	}

	return ret;

}

EXPORT_SYMBOL(lookup_one_positive_unlocked);



/**

 * lookup_one_len_unlocked - filesystem helper to lookup single pathname component

 * @name:	pathname component to lookup

 * @base:	base directory to lookup from

 * @len:	maximum length @len should be interpreted to

 *

 * Note that this routine is purely a helper for filesystem usage and should

 * not be called by generic code.

 *

 * Unlike lookup_one_len, it should be called without the parent

 * i_mutex held, and will take the i_mutex itself if necessary.

 */

struct dentry *lookup_one_len_unlocked(const char *name,

				       struct dentry *base, int len)

{

	return lookup_one_unlocked(&init_user_ns, name, base, len);

}

EXPORT_SYMBOL(lookup_one_len_unlocked);



/*
@@ -2809,12 +2864,7 @@ EXPORT_SYMBOL(lookup_one_len_unlocked); 
struct dentry *lookup_positive_unlocked(const char *name,

				       struct dentry *base, int len)

{

	struct dentry *ret = lookup_one_len_unlocked(name, base, len);

	if (!IS_ERR(ret) && d_flags_negative(smp_load_acquire(&ret->d_flags))) {

		dput(ret);

		ret = ERR_PTR(-ENOENT);

	}

	return ret;

	return lookup_one_positive_unlocked(&init_user_ns, name, base, len);

}

EXPORT_SYMBOL(lookup_positive_unlocked);

fs/overlayfs/copy_up.c

+49 −41
Original line number Diff line number Diff line
@@ -44,9 +44,9 @@ static bool ovl_must_copy_xattr(const char *name) 
	       !strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN);

}



int ovl_copy_xattr(struct super_block *sb, struct dentry *old,

		   struct dentry *new)

int ovl_copy_xattr(struct super_block *sb, struct path *oldpath, struct dentry *new)

{

	struct dentry *old = oldpath->dentry;

	ssize_t list_size, size, value_size = 0;

	char *buf, *name, *value = NULL;

	int error = 0;
@@ -94,9 +94,9 @@ int ovl_copy_xattr(struct super_block *sb, struct dentry *old, 
			continue; /* Discard */

		}

retry:

		size = vfs_getxattr(&init_user_ns, old, name, value, value_size);

		size = ovl_do_getxattr(oldpath, name, value, value_size);

		if (size == -ERANGE)

			size = vfs_getxattr(&init_user_ns, old, name, NULL, 0);

			size = ovl_do_getxattr(oldpath, name, NULL, 0);



		if (size < 0) {

			error = size;
@@ -117,7 +117,7 @@ int ovl_copy_xattr(struct super_block *sb, struct dentry *old, 
			goto retry;

		}



		error = vfs_setxattr(&init_user_ns, new, name, value, size, 0);

		error = ovl_do_setxattr(OVL_FS(sb), new, name, value, size, 0);

		if (error) {

			if (error != -EOPNOTSUPP || ovl_must_copy_xattr(name))

				break;
@@ -292,17 +292,19 @@ static int ovl_copy_up_data(struct ovl_fs *ofs, struct path *old, 
	return error;

}



static int ovl_set_size(struct dentry *upperdentry, struct kstat *stat)

static int ovl_set_size(struct ovl_fs *ofs,

			struct dentry *upperdentry, struct kstat *stat)

{

	struct iattr attr = {

		.ia_valid = ATTR_SIZE,

		.ia_size = stat->size,

	};



	return notify_change(&init_user_ns, upperdentry, &attr, NULL);

	return ovl_do_notify_change(ofs, upperdentry, &attr);

}



static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat)

static int ovl_set_timestamps(struct ovl_fs *ofs, struct dentry *upperdentry,

			      struct kstat *stat)

{

	struct iattr attr = {

		.ia_valid =
@@ -311,10 +313,11 @@ static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat) 
		.ia_mtime = stat->mtime,

	};



	return notify_change(&init_user_ns, upperdentry, &attr, NULL);

	return ovl_do_notify_change(ofs, upperdentry, &attr);

}



int ovl_set_attr(struct dentry *upperdentry, struct kstat *stat)

int ovl_set_attr(struct ovl_fs *ofs, struct dentry *upperdentry,

		 struct kstat *stat)

{

	int err = 0;
@@ -323,7 +326,7 @@ int ovl_set_attr(struct dentry *upperdentry, struct kstat *stat) 
			.ia_valid = ATTR_MODE,

			.ia_mode = stat->mode,

		};

		err = notify_change(&init_user_ns, upperdentry, &attr, NULL);

		err = ovl_do_notify_change(ofs, upperdentry, &attr);

	}

	if (!err) {

		struct iattr attr = {
@@ -331,10 +334,10 @@ int ovl_set_attr(struct dentry *upperdentry, struct kstat *stat) 
			.ia_uid = stat->uid,

			.ia_gid = stat->gid,

		};

		err = notify_change(&init_user_ns, upperdentry, &attr, NULL);

		err = ovl_do_notify_change(ofs, upperdentry, &attr);

	}

	if (!err)

		ovl_set_timestamps(upperdentry, stat);

		ovl_set_timestamps(ofs, upperdentry, stat);



	return err;

}
@@ -433,7 +436,7 @@ static int ovl_set_upper_fh(struct ovl_fs *ofs, struct dentry *upper, 
	if (IS_ERR(fh))

		return PTR_ERR(fh);



	err = ovl_do_setxattr(ofs, index, OVL_XATTR_UPPER, fh->buf, fh->fb.len);

	err = ovl_setxattr(ofs, index, OVL_XATTR_UPPER, fh->buf, fh->fb.len);



	kfree(fh);

	return err;
@@ -474,7 +477,7 @@ static int ovl_create_index(struct dentry *dentry, struct dentry *origin, 
	if (err)

		return err;



	temp = ovl_create_temp(indexdir, OVL_CATTR(S_IFDIR | 0));

	temp = ovl_create_temp(ofs, indexdir, OVL_CATTR(S_IFDIR | 0));

	err = PTR_ERR(temp);

	if (IS_ERR(temp))

		goto free_name;
@@ -483,16 +486,16 @@ static int ovl_create_index(struct dentry *dentry, struct dentry *origin, 
	if (err)

		goto out;



	index = lookup_one_len(name.name, indexdir, name.len);

	index = ovl_lookup_upper(ofs, name.name, indexdir, name.len);

	if (IS_ERR(index)) {

		err = PTR_ERR(index);

	} else {

		err = ovl_do_rename(dir, temp, dir, index, 0);

		err = ovl_do_rename(ofs, dir, temp, dir, index, 0);

		dput(index);

	}

out:

	if (err)

		ovl_cleanup(dir, temp);

		ovl_cleanup(ofs, dir, temp);

	dput(temp);

free_name:

	kfree(name.name);
@@ -519,6 +522,7 @@ static int ovl_link_up(struct ovl_copy_up_ctx *c) 
	int err;

	struct dentry *upper;

	struct dentry *upperdir = ovl_dentry_upper(c->parent);

	struct ovl_fs *ofs = OVL_FS(c->dentry->d_sb);

	struct inode *udir = d_inode(upperdir);



	/* Mark parent "impure" because it may now contain non-pure upper */
@@ -531,16 +535,16 @@ static int ovl_link_up(struct ovl_copy_up_ctx *c) 
		return err;



	inode_lock_nested(udir, I_MUTEX_PARENT);

	upper = lookup_one_len(c->dentry->d_name.name, upperdir,

	upper = ovl_lookup_upper(ofs, c->dentry->d_name.name, upperdir,

				 c->dentry->d_name.len);

	err = PTR_ERR(upper);

	if (!IS_ERR(upper)) {

		err = ovl_do_link(ovl_dentry_upper(c->dentry), udir, upper);

		err = ovl_do_link(ofs, ovl_dentry_upper(c->dentry), udir, upper);

		dput(upper);



		if (!err) {

			/* Restore timestamps on parent (best effort) */

			ovl_set_timestamps(upperdir, &c->pstat);

			ovl_set_timestamps(ofs, upperdir, &c->pstat);

			ovl_dentry_set_upper_alias(c->dentry);

		}

	}
@@ -578,7 +582,7 @@ static int ovl_copy_up_inode(struct ovl_copy_up_ctx *c, struct dentry *temp) 
			return err;

	}



	err = ovl_copy_xattr(c->dentry->d_sb, c->lowerpath.dentry, temp);

	err = ovl_copy_xattr(c->dentry->d_sb, &c->lowerpath, temp);

	if (err)

		return err;
@@ -614,9 +618,9 @@ static int ovl_copy_up_inode(struct ovl_copy_up_ctx *c, struct dentry *temp) 


	inode_lock(temp->d_inode);

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

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

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

	if (!err)

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

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

	inode_unlock(temp->d_inode);



	return err;
@@ -656,6 +660,7 @@ static void ovl_revert_cu_creds(struct ovl_cu_creds *cc) 
 */

static int ovl_copy_up_workdir(struct ovl_copy_up_ctx *c)

{

	struct ovl_fs *ofs = OVL_FS(c->dentry->d_sb);

	struct inode *inode;

	struct inode *udir = d_inode(c->destdir), *wdir = d_inode(c->workdir);

	struct dentry *temp, *upper;
@@ -677,7 +682,7 @@ static int ovl_copy_up_workdir(struct ovl_copy_up_ctx *c) 
	if (err)

		goto unlock;



	temp = ovl_create_temp(c->workdir, &cattr);

	temp = ovl_create_temp(ofs, c->workdir, &cattr);

	ovl_revert_cu_creds(&cc);



	err = PTR_ERR(temp);
@@ -694,12 +699,13 @@ static int ovl_copy_up_workdir(struct ovl_copy_up_ctx *c) 
			goto cleanup;

	}



	upper = lookup_one_len(c->destname.name, c->destdir, c->destname.len);

	upper = ovl_lookup_upper(ofs, c->destname.name, c->destdir,

				 c->destname.len);

	err = PTR_ERR(upper);

	if (IS_ERR(upper))

		goto cleanup;



	err = ovl_do_rename(wdir, temp, udir, upper, 0);

	err = ovl_do_rename(ofs, wdir, temp, udir, upper, 0);

	dput(upper);

	if (err)

		goto cleanup;
@@ -716,7 +722,7 @@ static int ovl_copy_up_workdir(struct ovl_copy_up_ctx *c) 
	return err;



cleanup:

	ovl_cleanup(wdir, temp);

	ovl_cleanup(ofs, wdir, temp);

	dput(temp);

	goto unlock;

}
@@ -724,6 +730,7 @@ static int ovl_copy_up_workdir(struct ovl_copy_up_ctx *c) 
/* Copyup using O_TMPFILE which does not require cross dir locking */

static int ovl_copy_up_tmpfile(struct ovl_copy_up_ctx *c)

{

	struct ovl_fs *ofs = OVL_FS(c->dentry->d_sb);

	struct inode *udir = d_inode(c->destdir);

	struct dentry *temp, *upper;

	struct ovl_cu_creds cc;
@@ -733,7 +740,7 @@ static int ovl_copy_up_tmpfile(struct ovl_copy_up_ctx *c) 
	if (err)

		return err;



	temp = ovl_do_tmpfile(c->workdir, c->stat.mode);

	temp = ovl_do_tmpfile(ofs, c->workdir, c->stat.mode);

	ovl_revert_cu_creds(&cc);



	if (IS_ERR(temp))
@@ -745,10 +752,11 @@ static int ovl_copy_up_tmpfile(struct ovl_copy_up_ctx *c) 


	inode_lock_nested(udir, I_MUTEX_PARENT);



	upper = lookup_one_len(c->destname.name, c->destdir, c->destname.len);

	upper = ovl_lookup_upper(ofs, c->destname.name, c->destdir,

				 c->destname.len);

	err = PTR_ERR(upper);

	if (!IS_ERR(upper)) {

		err = ovl_do_link(temp, udir, upper);

		err = ovl_do_link(ofs, temp, udir, upper);

		dput(upper);

	}

	inode_unlock(udir);
@@ -836,7 +844,7 @@ static int ovl_do_copy_up(struct ovl_copy_up_ctx *c) 


		/* Restore timestamps on parent (best effort) */

		inode_lock(udir);

		ovl_set_timestamps(c->destdir, &c->pstat);

		ovl_set_timestamps(ofs, c->destdir, &c->pstat);

		inode_unlock(udir);



		ovl_dentry_set_upper_alias(c->dentry);
@@ -865,12 +873,12 @@ static bool ovl_need_meta_copy_up(struct dentry *dentry, umode_t mode, 
	return true;

}



static ssize_t ovl_getxattr(struct dentry *dentry, char *name, char **value)

static ssize_t ovl_getxattr_value(struct path *path, char *name, char **value)

{

	ssize_t res;

	char *buf;



	res = vfs_getxattr(&init_user_ns, dentry, name, NULL, 0);

	res = ovl_do_getxattr(path, name, NULL, 0);

	if (res == -ENODATA || res == -EOPNOTSUPP)

		res = 0;
@@ -879,7 +887,7 @@ static ssize_t ovl_getxattr(struct dentry *dentry, char *name, char **value) 
		if (!buf)

			return -ENOMEM;



		res = vfs_getxattr(&init_user_ns, dentry, name, buf, res);

		res = ovl_do_getxattr(path, name, buf, res);

		if (res < 0)

			kfree(buf);

		else
@@ -906,7 +914,7 @@ static int ovl_copy_up_meta_inode_data(struct ovl_copy_up_ctx *c) 
		return -EIO;



	if (c->stat.size) {

		err = cap_size = ovl_getxattr(upperpath.dentry, XATTR_NAME_CAPS,

		err = cap_size = ovl_getxattr_value(&upperpath, XATTR_NAME_CAPS,

						    &capability);

		if (cap_size < 0)

			goto out;
@@ -921,14 +929,14 @@ static int ovl_copy_up_meta_inode_data(struct ovl_copy_up_ctx *c) 
	 * don't want that to happen for normal copy-up operation.

	 */

	if (capability) {

		err = vfs_setxattr(&init_user_ns, upperpath.dentry,

				   XATTR_NAME_CAPS, capability, cap_size, 0);

		err = ovl_do_setxattr(ofs, upperpath.dentry, XATTR_NAME_CAPS,

				      capability, cap_size, 0);

		if (err)

			goto out_free;

	}





	err = ovl_do_removexattr(ofs, upperpath.dentry, OVL_XATTR_METACOPY);

	err = ovl_removexattr(ofs, upperpath.dentry, OVL_XATTR_METACOPY);

	if (err)

		goto out_free;

fs/overlayfs/dir.c

+75 −72
Original line number Diff line number Diff line
@@ -23,15 +23,15 @@ MODULE_PARM_DESC(redirect_max, 


static int ovl_set_redirect(struct dentry *dentry, bool samedir);



int ovl_cleanup(struct inode *wdir, struct dentry *wdentry)

int ovl_cleanup(struct ovl_fs *ofs, struct inode *wdir, struct dentry *wdentry)

{

	int err;



	dget(wdentry);

	if (d_is_dir(wdentry))

		err = ovl_do_rmdir(wdir, wdentry);

		err = ovl_do_rmdir(ofs, wdir, wdentry);

	else

		err = ovl_do_unlink(wdir, wdentry);

		err = ovl_do_unlink(ofs, wdir, wdentry);

	dput(wdentry);



	if (err) {
@@ -42,7 +42,7 @@ int ovl_cleanup(struct inode *wdir, struct dentry *wdentry) 
	return err;

}



struct dentry *ovl_lookup_temp(struct dentry *workdir)

struct dentry *ovl_lookup_temp(struct ovl_fs *ofs, struct dentry *workdir)

{

	struct dentry *temp;

	char name[20];
@@ -51,7 +51,7 @@ struct dentry *ovl_lookup_temp(struct dentry *workdir) 
	/* counter is allowed to wrap, since temp dentries are ephemeral */

	snprintf(name, sizeof(name), "#%x", atomic_inc_return(&temp_id));



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

	temp = ovl_lookup_upper(ofs, name, workdir, strlen(name));

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

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

		dput(temp);
@@ -70,11 +70,11 @@ static struct dentry *ovl_whiteout(struct ovl_fs *ofs) 
	struct inode *wdir = workdir->d_inode;



	if (!ofs->whiteout) {

		whiteout = ovl_lookup_temp(workdir);

		whiteout = ovl_lookup_temp(ofs, workdir);

		if (IS_ERR(whiteout))

			goto out;



		err = ovl_do_whiteout(wdir, whiteout);

		err = ovl_do_whiteout(ofs, wdir, whiteout);

		if (err) {

			dput(whiteout);

			whiteout = ERR_PTR(err);
@@ -84,11 +84,11 @@ static struct dentry *ovl_whiteout(struct ovl_fs *ofs) 
	}



	if (ofs->share_whiteout) {

		whiteout = ovl_lookup_temp(workdir);

		whiteout = ovl_lookup_temp(ofs, workdir);

		if (IS_ERR(whiteout))

			goto out;



		err = ovl_do_link(ofs->whiteout, wdir, whiteout);

		err = ovl_do_link(ofs, ofs->whiteout, wdir, whiteout);

		if (!err)

			goto out;
@@ -122,27 +122,28 @@ int ovl_cleanup_and_whiteout(struct ovl_fs *ofs, struct inode *dir, 
	if (d_is_dir(dentry))

		flags = RENAME_EXCHANGE;



	err = ovl_do_rename(wdir, whiteout, dir, dentry, flags);

	err = ovl_do_rename(ofs, wdir, whiteout, dir, dentry, flags);

	if (err)

		goto kill_whiteout;

	if (flags)

		ovl_cleanup(wdir, dentry);

		ovl_cleanup(ofs, wdir, dentry);



out:

	dput(whiteout);

	return err;



kill_whiteout:

	ovl_cleanup(wdir, whiteout);

	ovl_cleanup(ofs, wdir, whiteout);

	goto out;

}



int ovl_mkdir_real(struct inode *dir, struct dentry **newdentry, umode_t mode)

int ovl_mkdir_real(struct ovl_fs *ofs, struct inode *dir,

		   struct dentry **newdentry, umode_t mode)

{

	int err;

	struct dentry *d, *dentry = *newdentry;



	err = ovl_do_mkdir(dir, dentry, mode);

	err = ovl_do_mkdir(ofs, dir, dentry, mode);

	if (err)

		return err;
@@ -154,7 +155,7 @@ int ovl_mkdir_real(struct inode *dir, struct dentry **newdentry, umode_t mode) 
	 * to it unhashed and negative. If that happens, try to

	 * lookup a new hashed and positive dentry.

	 */

	d = lookup_one_len(dentry->d_name.name, dentry->d_parent,

	d = ovl_lookup_upper(ofs, dentry->d_name.name, dentry->d_parent,

			     dentry->d_name.len);

	if (IS_ERR(d)) {

		pr_warn("failed lookup after mkdir (%pd2, err=%i).\n",
@@ -167,8 +168,8 @@ int ovl_mkdir_real(struct inode *dir, struct dentry **newdentry, umode_t mode) 
	return 0;

}



struct dentry *ovl_create_real(struct inode *dir, struct dentry *newdentry,

			       struct ovl_cattr *attr)

struct dentry *ovl_create_real(struct ovl_fs *ofs, struct inode *dir,

			       struct dentry *newdentry, struct ovl_cattr *attr)

{

	int err;
@@ -180,28 +181,28 @@ struct dentry *ovl_create_real(struct inode *dir, struct dentry *newdentry, 
		goto out;



	if (attr->hardlink) {

		err = ovl_do_link(attr->hardlink, dir, newdentry);

		err = ovl_do_link(ofs, attr->hardlink, dir, newdentry);

	} else {

		switch (attr->mode & S_IFMT) {

		case S_IFREG:

			err = ovl_do_create(dir, newdentry, attr->mode);

			err = ovl_do_create(ofs, dir, newdentry, attr->mode);

			break;



		case S_IFDIR:

			/* mkdir is special... */

			err =  ovl_mkdir_real(dir, &newdentry, attr->mode);

			err =  ovl_mkdir_real(ofs, dir, &newdentry, attr->mode);

			break;



		case S_IFCHR:

		case S_IFBLK:

		case S_IFIFO:

		case S_IFSOCK:

			err = ovl_do_mknod(dir, newdentry, attr->mode,

			err = ovl_do_mknod(ofs, dir, newdentry, attr->mode,

					   attr->rdev);

			break;



		case S_IFLNK:

			err = ovl_do_symlink(dir, newdentry, attr->link);

			err = ovl_do_symlink(ofs, dir, newdentry, attr->link);

			break;



		default:
@@ -223,10 +224,11 @@ struct dentry *ovl_create_real(struct inode *dir, struct dentry *newdentry, 
	return newdentry;

}



struct dentry *ovl_create_temp(struct dentry *workdir, struct ovl_cattr *attr)

struct dentry *ovl_create_temp(struct ovl_fs *ofs, struct dentry *workdir,

			       struct ovl_cattr *attr)

{

	return ovl_create_real(d_inode(workdir), ovl_lookup_temp(workdir),

			       attr);

	return ovl_create_real(ofs, d_inode(workdir),

			       ovl_lookup_temp(ofs, workdir), attr);

}



static int ovl_set_opaque_xerr(struct dentry *dentry, struct dentry *upper,
@@ -330,10 +332,9 @@ static int ovl_create_upper(struct dentry *dentry, struct inode *inode, 
		attr->mode &= ~current_umask();



	inode_lock_nested(udir, I_MUTEX_PARENT);

	newdentry = ovl_create_real(udir,

				    lookup_one_len(dentry->d_name.name,

						   upperdir,

						   dentry->d_name.len),

	newdentry = ovl_create_real(ofs, udir,

				    ovl_lookup_upper(ofs, dentry->d_name.name,

						     upperdir, dentry->d_name.len),

				    attr);

	err = PTR_ERR(newdentry);

	if (IS_ERR(newdentry))
@@ -353,7 +354,7 @@ static int ovl_create_upper(struct dentry *dentry, struct inode *inode, 
	return err;



out_cleanup:

	ovl_cleanup(udir, newdentry);

	ovl_cleanup(ofs, udir, newdentry);

	dput(newdentry);

	goto out_unlock;

}
@@ -361,6 +362,7 @@ static int ovl_create_upper(struct dentry *dentry, struct inode *inode, 
static struct dentry *ovl_clear_empty(struct dentry *dentry,

				      struct list_head *list)

{

	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);

	struct dentry *workdir = ovl_workdir(dentry);

	struct inode *wdir = workdir->d_inode;

	struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
@@ -391,12 +393,12 @@ static struct dentry *ovl_clear_empty(struct dentry *dentry, 
	if (upper->d_parent->d_inode != udir)

		goto out_unlock;



	opaquedir = ovl_create_temp(workdir, OVL_CATTR(stat.mode));

	opaquedir = ovl_create_temp(ofs, workdir, OVL_CATTR(stat.mode));

	err = PTR_ERR(opaquedir);

	if (IS_ERR(opaquedir))

		goto out_unlock;



	err = ovl_copy_xattr(dentry->d_sb, upper, opaquedir);

	err = ovl_copy_xattr(dentry->d_sb, &upperpath, opaquedir);

	if (err)

		goto out_cleanup;
@@ -405,17 +407,17 @@ static struct dentry *ovl_clear_empty(struct dentry *dentry, 
		goto out_cleanup;



	inode_lock(opaquedir->d_inode);

	err = ovl_set_attr(opaquedir, &stat);

	err = ovl_set_attr(ofs, opaquedir, &stat);

	inode_unlock(opaquedir->d_inode);

	if (err)

		goto out_cleanup;



	err = ovl_do_rename(wdir, opaquedir, udir, upper, RENAME_EXCHANGE);

	err = ovl_do_rename(ofs, wdir, opaquedir, udir, upper, RENAME_EXCHANGE);

	if (err)

		goto out_cleanup;



	ovl_cleanup_whiteouts(upper, list);

	ovl_cleanup(wdir, upper);

	ovl_cleanup_whiteouts(ofs, upper, list);

	ovl_cleanup(ofs, wdir, upper);

	unlock_rename(workdir, upperdir);



	/* dentry's upper doesn't match now, get rid of it */
@@ -424,7 +426,7 @@ static struct dentry *ovl_clear_empty(struct dentry *dentry, 
	return opaquedir;



out_cleanup:

	ovl_cleanup(wdir, opaquedir);

	ovl_cleanup(ofs, wdir, opaquedir);

	dput(opaquedir);

out_unlock:

	unlock_rename(workdir, upperdir);
@@ -432,8 +434,8 @@ static struct dentry *ovl_clear_empty(struct dentry *dentry, 
	return ERR_PTR(err);

}



static int ovl_set_upper_acl(struct dentry *upperdentry, const char *name,

			     const struct posix_acl *acl)

static int ovl_set_upper_acl(struct ovl_fs *ofs, struct dentry *upperdentry,

			     const char *name, const struct posix_acl *acl)

{

	void *buffer;

	size_t size;
@@ -451,7 +453,7 @@ static int ovl_set_upper_acl(struct dentry *upperdentry, const char *name, 
	if (err < 0)

		goto out_free;



	err = vfs_setxattr(&init_user_ns, upperdentry, name, buffer, size, XATTR_CREATE);

	err = ovl_do_setxattr(ofs, upperdentry, name, buffer, size, XATTR_CREATE);

out_free:

	kfree(buffer);

	return err;
@@ -460,6 +462,7 @@ static int ovl_set_upper_acl(struct dentry *upperdentry, const char *name, 
static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode,

				    struct ovl_cattr *cattr)

{

	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);

	struct dentry *workdir = ovl_workdir(dentry);

	struct inode *wdir = workdir->d_inode;

	struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
@@ -484,7 +487,7 @@ static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode, 
	if (err)

		goto out;



	upper = lookup_one_len(dentry->d_name.name, upperdir,

	upper = ovl_lookup_upper(ofs, dentry->d_name.name, upperdir,

				 dentry->d_name.len);

	err = PTR_ERR(upper);

	if (IS_ERR(upper))
@@ -494,7 +497,7 @@ static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode, 
	if (d_is_negative(upper) || !IS_WHITEOUT(d_inode(upper)))

		goto out_dput;



	newdentry = ovl_create_temp(workdir, cattr);

	newdentry = ovl_create_temp(ofs, workdir, cattr);

	err = PTR_ERR(newdentry);

	if (IS_ERR(newdentry))

		goto out_dput;
@@ -510,19 +513,19 @@ static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode, 
			.ia_mode = cattr->mode,

		};

		inode_lock(newdentry->d_inode);

		err = notify_change(&init_user_ns, newdentry, &attr, NULL);

		err = ovl_do_notify_change(ofs, newdentry, &attr);

		inode_unlock(newdentry->d_inode);

		if (err)

			goto out_cleanup;

	}

	if (!hardlink) {

		err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_ACCESS,

					acl);

		err = ovl_set_upper_acl(ofs, newdentry,

					XATTR_NAME_POSIX_ACL_ACCESS, acl);

		if (err)

			goto out_cleanup;



		err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_DEFAULT,

					default_acl);

		err = ovl_set_upper_acl(ofs, newdentry,

					XATTR_NAME_POSIX_ACL_DEFAULT, default_acl);

		if (err)

			goto out_cleanup;

	}
@@ -532,20 +535,20 @@ static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode, 
		if (err)

			goto out_cleanup;



		err = ovl_do_rename(wdir, newdentry, udir, upper,

		err = ovl_do_rename(ofs, wdir, newdentry, udir, upper,

				    RENAME_EXCHANGE);

		if (err)

			goto out_cleanup;



		ovl_cleanup(wdir, upper);

		ovl_cleanup(ofs, wdir, upper);

	} else {

		err = ovl_do_rename(wdir, newdentry, udir, upper, 0);

		err = ovl_do_rename(ofs, wdir, newdentry, udir, upper, 0);

		if (err)

			goto out_cleanup;

	}

	err = ovl_instantiate(dentry, inode, newdentry, hardlink);

	if (err) {

		ovl_cleanup(udir, newdentry);

		ovl_cleanup(ofs, udir, newdentry);

		dput(newdentry);

	}

out_dput:
@@ -560,7 +563,7 @@ static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode, 
	return err;



out_cleanup:

	ovl_cleanup(wdir, newdentry);

	ovl_cleanup(ofs, wdir, newdentry);

	dput(newdentry);

	goto out_dput;

}
@@ -767,7 +770,7 @@ static int ovl_remove_and_whiteout(struct dentry *dentry, 
	if (err)

		goto out_dput;



	upper = lookup_one_len(dentry->d_name.name, upperdir,

	upper = ovl_lookup_upper(ofs, dentry->d_name.name, upperdir,

				 dentry->d_name.len);

	err = PTR_ERR(upper);

	if (IS_ERR(upper))
@@ -800,6 +803,7 @@ static int ovl_remove_and_whiteout(struct dentry *dentry, 
static int ovl_remove_upper(struct dentry *dentry, bool is_dir,

			    struct list_head *list)

{

	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);

	struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);

	struct inode *dir = upperdir->d_inode;

	struct dentry *upper;
@@ -814,7 +818,7 @@ static int ovl_remove_upper(struct dentry *dentry, bool is_dir, 
	}



	inode_lock_nested(dir, I_MUTEX_PARENT);

	upper = lookup_one_len(dentry->d_name.name, upperdir,

	upper = ovl_lookup_upper(ofs, dentry->d_name.name, upperdir,

				 dentry->d_name.len);

	err = PTR_ERR(upper);

	if (IS_ERR(upper))
@@ -826,9 +830,9 @@ static int ovl_remove_upper(struct dentry *dentry, bool is_dir, 
		goto out_dput_upper;



	if (is_dir)

		err = vfs_rmdir(&init_user_ns, dir, upper);

		err = ovl_do_rmdir(ofs, dir, upper);

	else

		err = vfs_unlink(&init_user_ns, dir, upper, NULL);

		err = ovl_do_unlink(ofs, dir, upper);

	ovl_dir_modified(dentry->d_parent, ovl_type_origin(dentry));



	/*
@@ -880,7 +884,6 @@ static int ovl_do_remove(struct dentry *dentry, bool is_dir) 
{

	int err;

	const struct cred *old_cred;

	struct dentry *upperdentry;

	bool lower_positive = ovl_lower_positive(dentry);

	LIST_HEAD(list);
@@ -923,9 +926,8 @@ static int ovl_do_remove(struct dentry *dentry, bool is_dir) 
	 * Note: we fail to update ctime if there was no copy-up, only a

	 * whiteout

	 */

	upperdentry = ovl_dentry_upper(dentry);

	if (upperdentry)

		ovl_copyattr(d_inode(upperdentry), d_inode(dentry));

	if (ovl_dentry_upper(dentry))

		ovl_copyattr(d_inode(dentry));



out_drop_write:

	ovl_drop_write(dentry);
@@ -1095,6 +1097,7 @@ static int ovl_rename(struct user_namespace *mnt_userns, struct inode *olddir, 
	bool samedir = olddir == newdir;

	struct dentry *opaquedir = NULL;

	const struct cred *old_cred = NULL;

	struct ovl_fs *ofs = OVL_FS(old->d_sb);

	LIST_HEAD(list);



	err = -EINVAL;
@@ -1189,7 +1192,7 @@ static int ovl_rename(struct user_namespace *mnt_userns, struct inode *olddir, 


	trap = lock_rename(new_upperdir, old_upperdir);



	olddentry = lookup_one_len(old->d_name.name, old_upperdir,

	olddentry = ovl_lookup_upper(ofs, old->d_name.name, old_upperdir,

				     old->d_name.len);

	err = PTR_ERR(olddentry);

	if (IS_ERR(olddentry))
@@ -1199,7 +1202,7 @@ static int ovl_rename(struct user_namespace *mnt_userns, struct inode *olddir, 
	if (!ovl_matches_upper(old, olddentry))

		goto out_dput_old;



	newdentry = lookup_one_len(new->d_name.name, new_upperdir,

	newdentry = ovl_lookup_upper(ofs, new->d_name.name, new_upperdir,

				     new->d_name.len);

	err = PTR_ERR(newdentry);

	if (IS_ERR(newdentry))
@@ -1251,13 +1254,13 @@ static int ovl_rename(struct user_namespace *mnt_userns, struct inode *olddir, 
	if (err)

		goto out_dput;



	err = ovl_do_rename(old_upperdir->d_inode, olddentry,

	err = ovl_do_rename(ofs, old_upperdir->d_inode, olddentry,

			    new_upperdir->d_inode, newdentry, flags);

	if (err)

		goto out_dput;



	if (cleanup_whiteout)

		ovl_cleanup(old_upperdir->d_inode, newdentry);

		ovl_cleanup(ofs, old_upperdir->d_inode, newdentry);



	if (overwrite && d_inode(new)) {

		if (new_is_dir)
@@ -1272,9 +1275,9 @@ static int ovl_rename(struct user_namespace *mnt_userns, struct inode *olddir, 
			 (d_inode(new) && ovl_type_origin(new)));



	/* copy ctime: */

	ovl_copyattr(d_inode(olddentry), d_inode(old));

	ovl_copyattr(d_inode(old));

	if (d_inode(new) && ovl_dentry_upper(new))

		ovl_copyattr(d_inode(newdentry), d_inode(new));

		ovl_copyattr(d_inode(new));



out_dput:

	dput(newdentry);

fs/overlayfs/export.c

+5 −0
Original line number Diff line number Diff line
@@ -391,6 +391,11 @@ static struct dentry *ovl_lookup_real_one(struct dentry *connected, 
	 * pointer because we hold no lock on the real dentry.

	 */

	take_dentry_name_snapshot(&name, real);

	/*

	 * No mnt_userns handling here: it's an internal lookup.  Could skip

	 * permission checking altogether, but for now just use non-mnt_userns

	 * transformed ids.

	 */

	this = lookup_one_len(name.name.name, connected, name.name.len);

	release_dentry_name_snapshot(&name);

	err = PTR_ERR(this);