mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Erez Zadok <ezk@cs.sunysb.edu>
To: Valerie Aurora <vaurora@redhat.com>
Cc: Jan Blunck <jblunck@suse.de>,
	Alexander Viro <viro@zeniv.linux.org.uk>,
	Christoph Hellwig <hch@infradead.org>,
	Andy Whitcroft <apw@canonical.com>,
	Scott James Remnant <scott@canonical.com>,
	Sandu Popa Marius <sandupopamarius@gmail.com>,
	Jan Rekorajski <baggins@sith.mimuw.edu.pl>,
	"J. R. Okajima" <hooanon05@yahoo.co.jp>,
	Arnd Bergmann <arnd@arndb.de>,
	Vladimir Dronnikov <dronnikov@gmail.com>,
	Felix Fietkau <nbd@openwrt.org>,
	linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: Re: [PATCH 24/41] union-mount: Make lookup work for union-mounted file systems
Date: Mon, 30 Nov 2009 23:10:28 -0500	[thread overview]
Message-ID: <200912010410.nB14ASgB030294@agora.fsl.cs.sunysb.edu> (raw)
In-Reply-To: Your message of "Wed, 21 Oct 2009 12:19:22 PDT." <1256152779-10054-25-git-send-email-vaurora@redhat.com>

In message <1256152779-10054-25-git-send-email-vaurora@redhat.com>, Valerie Aurora writes:
> From: Jan Blunck <jblunck@suse.de>
> 
> On union-mounted file systems the lookup function must also visit lower layers
> of the union-stack when doing a lookup. This patches add support for
> union-mounts to cached lookups and real lookups.
> 
> We have 3 different styles of lookup functions now:
> - multiple pathname components, follow mounts, follow union, follow symlinks
> - single pathname component, doesn't follow mounts, follow union, doesn't
>   follow symlinks
> - single pathname component doesn't follow mounts, doesn't follow unions,
>   doesn't follow symlinks
> 
> XXX - Needs to be re-organized to reduce code duplication.  But how?
> 
> - Create shared lookup_topmost() and build_union() functions that take
>   flags or function pointers for real_lookup(), cache_lookup(), etc.
> - Push union code farther down into cache_lookup(), etc.
> - (your idea here)
> 
> XXX - Symlinks to other file systems (and probably submounts) don't
> work - see comment in do_lookup().
> 
> Signed-off-by: Jan Blunck <jblunck@suse.de>
> Signed-off-by: Valerie Aurora <vaurora@redhat.com>
> ---
>  fs/namei.c            |  483 ++++++++++++++++++++++++++++++++++++++++++++++++-
>  include/linux/namei.h |    6 +
>  2 files changed, 481 insertions(+), 8 deletions(-)
> 
> diff --git a/fs/namei.c b/fs/namei.c
> index 408380d..b279686 100644
> --- a/fs/namei.c
> +++ b/fs/namei.c
> @@ -33,6 +33,7 @@
>  #include <linux/fcntl.h>
>  #include <linux/device_cgroup.h>
>  #include <linux/fs_struct.h>
> +#include <linux/union.h>
>  #include <asm/uaccess.h>
>  
>  #define ACC_MODE(x) ("\000\004\002\006"[(x)&O_ACCMODE])
> @@ -415,6 +416,173 @@ static struct dentry *cache_lookup(struct dentry *parent, struct qstr *name,
>  	return dentry;
>  }
>  
> +/**
> + * __cache_lookup_topmost - lookup the topmost (non-)negative dentry
> + *
> + * @nd - parent's nameidata
> + * @name - pathname part to lookup
> + * @path - found dentry for pathname part
> + *
> + * This is used for union mount lookups from dcache. The first non-negative
> + * dentry is searched on all layers of the union stack. Otherwise the topmost
> + * negative dentry is returned.
> + */
> +static int __cache_lookup_topmost(struct nameidata *nd, struct qstr *name,
> +				  struct path *path)
> +{
> +	struct dentry *dentry;
> +
> +	dentry = d_lookup(nd->path.dentry, name);
> +	if (dentry && dentry->d_op && dentry->d_op->d_revalidate)
> +		dentry = do_revalidate(dentry, nd);
> +
> +	/*
> +	 * Remember the topmost negative dentry in case we don't find anything
> +	 */
> +	path->dentry = dentry;
> +	path->mnt = dentry ? nd->path.mnt : NULL;
> +
> +	if (!dentry || dentry->d_inode)
> +		return !dentry;

While it's a clever trick to return "!dentry" several times in this
function, it's less obvious to the reader what the intention is.  Perhaps
document it above the function?

It's also unclear what are the side effects of this function: what does it
do on success or failure: does it return a struct path/dentry/mnt that are
valid?  If so, where their refcounts incremented?  I'd like to see this
documented.

> +	/* look for the first non-negative dentry */
> +
> +	while (follow_union_down(&nd->path.mnt, &nd->path.dentry)) {
> +		dentry = d_hash_and_lookup(nd->path.dentry, name);
> +
> +		/*
> +		 * If parts of the union stack are not in the dcache we need
> +		 * to do a real lookup
> +		 */
> +		if (!dentry)
> +			goto out_dput;
> +
> +		/*
> +		 * If parts of the union don't survive the revalidation we
> +		 * need to do a real lookup
> +		 */
> +		if (dentry->d_op && dentry->d_op->d_revalidate) {
> +			dentry = do_revalidate(dentry, nd);
> +			if (!dentry)
> +				goto out_dput;
> +		}
> +
> +		if (dentry->d_inode)
> +			goto out_dput;
> +
> +		dput(dentry);
> +	}
> +
> +	return !dentry;
> +
> +out_dput:
> +	dput(path->dentry);
> +	path->dentry = dentry;
> +	path->mnt = dentry ? mntget(nd->path.mnt) : NULL;
> +	return !dentry;
> +}
> +
> +/**
> + * __cache_lookup_build_union - build the union stack for this part,
> + * cached version
> + *
> + * This is called after you have the topmost dentry in @path.
> + */
> +static int __cache_lookup_build_union(struct nameidata *nd, struct qstr *name,
> +				      struct path *path)
> +{
> +	struct path last = *path;
> +	struct dentry *dentry;
> +
> +	while (follow_union_down(&nd->path.mnt, &nd->path.dentry)) {
> +		dentry = d_hash_and_lookup(nd->path.dentry, name);
> +		if (!dentry)
> +			return 1;

Another function that can be made to return a boolean.

> +		if (dentry->d_op && dentry->d_op->d_revalidate) {
> +			dentry = do_revalidate(dentry, nd);
> +			if (!dentry)
> +				return 1;
> +		}
> +
> +		if (!dentry->d_inode) {
> +			dput(dentry);
> +			continue;
> +		}
> +
> +		/* only directories can be part of a union stack */
> +		if (!S_ISDIR(dentry->d_inode->i_mode)) {
> +			dput(dentry);
> +			break;
> +		}
> +
> +		/* Add the newly discovered dir to the union stack */
> +		append_to_union(last.mnt, last.dentry, nd->path.mnt, dentry);

BTW, the name 'append_to_union', specifically the 'append' part, implies
that a union has a start and an end -- and that you append to the END.  But,
where is the end here?  The bottom or the top of the union.  I think the
term append may be confusing: perhaps a better term would be
"push_onto_union" (and the converse, "pop_top_of_union").

> +
> +		if (last.dentry != path->dentry)
> +			path_put(&last);
> +		last.dentry = dentry;
> +		last.mnt = mntget(nd->path.mnt);
> +	}
> +
> +	if (last.dentry != path->dentry)
> +		path_put(&last);
> +
> +	return 0;
> +}
> +
> +/**
> + * cache_lookup_union - lookup a single pathname part from dcache
> + *
> + * This is a union mount capable version of what d_lookup() & revalidate()
> + * would do. This function returns a valid (union) dentry on success.
> + *
> + * Remember: On failure it means that parts of the union aren't cached. You
> + * should call real_lookup() afterwards to find the proper (union) dentry.
> + */
> +static int cache_lookup_union(struct nameidata *nd, struct qstr *name,
> +			      struct path *path)
> +{
> +	int res ;
> +
> +	if (!IS_MNT_UNION(nd->path.mnt)) {
> +		path->dentry = cache_lookup(nd->path.dentry, name, nd);
> +		path->mnt = path->dentry ? nd->path.mnt : NULL;
> +		res = path->dentry ? 0 : 1;
> +	} else {
> +		struct path safe = {
> +			.dentry = nd->path.dentry,
> +			.mnt = nd->path.mnt
> +		};

There's something unclean about having to save the nd->path and later on
restore it.  Is this due to a limitation of __cache_lookup_build_union
below, or something else?  You also (below) compare the saved mnt version
against what you just got: was this the reason for saving the nd->path?

> +		path_get(&safe);
> +		res = __cache_lookup_topmost(nd, name, path);
> +		if (res)
> +			goto out;
> +
> +		/* only directories can be part of a union stack */
> +		if (!path->dentry->d_inode ||
> +		    !S_ISDIR(path->dentry->d_inode->i_mode))
> +			goto out;
> +
> +		/* Build the union stack for this part */
> +		res = __cache_lookup_build_union(nd, name, path);
> +		if (res) {
> +			dput(path->dentry);
> +			if (path->mnt != safe.mnt)
> +				mntput(path->mnt);
> +			goto out;
> +		}
> +
> +out:
> +		path_put(&nd->path);
> +		nd->path.dentry = safe.dentry;
> +		nd->path.mnt = safe.mnt;
> +	}
> +
> +	return res;
> +}
> +
>  /*
>   * Short-cut version of permission(), for calling by
>   * path_walk(), when dcache lock is held.  Combines parts
> @@ -536,6 +704,146 @@ out_unlock:
>  	return res;
>  }
>  
> +/**
> + * __real_lookup_topmost - lookup topmost dentry, non-cached version
> + *
> + * If we reach a dentry with restricted access, we just stop the lookup
> + * because we shouldn't see through that dentry. Same thing for dentry
> + * type mismatch and whiteouts.
> + *
> + * FIXME:
> + * - handle DT_WHT

If this function doesn't yet handle DT_WHT, isn't it sort of a fundamental
functionality that's missing (handling whiteouts)?!

> + * - handle union stacks in use
> + * - handle union stacks mounted upon union stacks
> + * - avoid unnecessary allocations of union locks
> + */
> +static int __real_lookup_topmost(struct nameidata *nd, struct qstr *name,
> +				 struct path *path)
> +{
> +	struct path next;
> +	int err;
> +
> +	err = real_lookup(nd, name, path);
> +	if (err)
> +		return err;
> +
> +	if (path->dentry->d_inode)
> +		return 0;
> +
> +	while (follow_union_down(&nd->path.mnt, &nd->path.dentry)) {
> +		name->hash = full_name_hash(name->name, name->len);
> +		if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
> +			err = nd->path.dentry->d_op->d_hash(nd->path.dentry,
> +							    name);
> +			if (err < 0)
> +				goto out;
> +		}
> +
> +		err = real_lookup(nd, name, &next);
> +		if (err)
> +			goto out;
> +
> +		if (next.dentry->d_inode) {
> +			dput(path->dentry);
> +			mntget(next.mnt);
> +			*path = next;
> +			goto out;
> +		}
> +
> +		dput(next.dentry);
> +	}
> +out:
> +	if (err)
> +		dput(path->dentry);
> +	return err;
> +}
> +
> +/**
> + * __real_lookup_build_union: build the union stack for this pathname
> + * part, non-cached version
> + *
> + * Called when not all parts of the union stack are in cache
> + */
> +
> +static int __real_lookup_build_union(struct nameidata *nd, struct qstr *name,
> +				     struct path *path)
> +{
> +	struct path last = *path;
> +	struct path next;
> +	int err = 0;
> +
> +	while (follow_union_down(&nd->path.mnt, &nd->path.dentry)) {
> +		/* We need to recompute the hash for lower layer lookups */
> +		name->hash = full_name_hash(name->name, name->len);
> +		if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
> +			err = nd->path.dentry->d_op->d_hash(nd->path.dentry,
> +							    name);
> +			if (err < 0)
> +				goto out;
> +		}
> +
> +		err = real_lookup(nd, name, &next);
> +		if (err)
> +			goto out;
> +
> +		if (!next.dentry->d_inode) {
> +			dput(next.dentry);
> +			continue;
> +		}
> +
> +		/* only directories can be part of a union stack */
> +		if (!S_ISDIR(next.dentry->d_inode->i_mode)) {
> +			dput(next.dentry);
> +			break;
> +		}
> +
> +		/* now we know we found something "real" */
> +		append_to_union(last.mnt, last.dentry, next.mnt, next.dentry);
> +
> +		if (last.dentry != path->dentry)
> +			path_put(&last);
> +		last.dentry = next.dentry;
> +		last.mnt = mntget(next.mnt);
> +	}
> +
> +	if (last.dentry != path->dentry)
> +		path_put(&last);
> +out:
> +	return err;
> +}
> +
> +static int real_lookup_union(struct nameidata *nd, struct qstr *name,
> +			     struct path *path)
> +{
> +	struct path safe = { .dentry = nd->path.dentry, .mnt = nd->path.mnt };
> +	int res ;
> +
> +	path_get(&safe);
> +	res = __real_lookup_topmost(nd, name, path);
> +	if (res)
> +		goto out;
> +
> +	/* only directories can be part of a union stack */
> +	if (!path->dentry->d_inode ||
> +	    !S_ISDIR(path->dentry->d_inode->i_mode))
> +		goto out;
> +
> +	/* Build the union stack for this part */
> +	res = __real_lookup_build_union(nd, name, path);
> +	if (res) {
> +		dput(path->dentry);
> +		if (path->mnt != safe.mnt)
> +			mntput(path->mnt);
> +		goto out;
> +	}
> +
> +out:
> +	path_put(&nd->path);
> +	nd->path.dentry = safe.dentry;
> +	nd->path.mnt = safe.mnt;
> +	return res;
> +}
> +
>  /*
>   * Wrapper to retry pathname resolution whenever the underlying
>   * file system returns an ESTALE.
> @@ -790,6 +1098,7 @@ static __always_inline void follow_dotdot(struct nameidata *nd)
>  		nd->path.mnt = parent;
>  	}
>  	follow_mount(&nd->path);
> +	follow_union_mount(&nd->path.mnt, &nd->path.dentry);
>  }
>  
>  /*
> @@ -802,6 +1111,9 @@ static int do_lookup(struct nameidata *nd, struct qstr *name,
>  {
>  	int err;
>  
> +	if (IS_MNT_UNION(nd->path.mnt))
> +		goto need_union_lookup;
> +
>  	path->dentry = __d_lookup(nd->path.dentry, name);
>  	path->mnt = nd->path.mnt;
>  	if (!path->dentry)
> @@ -810,7 +1122,25 @@ static int do_lookup(struct nameidata *nd, struct qstr *name,
>  		goto need_revalidate;
>  
>  done:
> -	__follow_mount(path);
> +	if (nd->path.mnt != path->mnt) {
> +		/*
> +		 * XXX FIXME: We only want to set this flag if we
> +		 * crossed from the top layer to the bottom layer of a
> +		 * union mount.  But nd->path.mnt != path->mnt is also
> +		 * true when we cross from the top layer of a union
> +		 * mount to another file system, either by symlink or
> +		 * file system mounted on a directory in the union
> +		 * mount (probably - haven't tested).
> +		 *
> +		 * This might be an issue for every mnt/mnt comparison
> +		 * - or maybe just during the brief window between
> +		 * do_lookup() and do_follow_link() or follow_mount().
> +		 */
> +		nd->um_flags |= LAST_LOWLEVEL;

It's unclear to me why you need an extra flag to mark the bottom of the
union.  And, if you needed such a marker, then why couldn't it have been set
upon the very first union-mount on top of a non-unioned f/s?  (or use
is_unionized instead?)

> +		follow_mount(path);
> +	} else
> +		__follow_mount(path);
> +	follow_union_mount(&path->mnt, &path->dentry);
>  	return 0;
>  
>  need_lookup:
> @@ -819,6 +1149,16 @@ need_lookup:
>  		goto fail;
>  	goto done;
>  
> +need_union_lookup:
> +	err = cache_lookup_union(nd, name, path);
> +	if (!err && path->dentry)
> +		goto done;
> +
> +	err = real_lookup_union(nd, name, path);
> +	if (err)
> +		goto fail;
> +	goto done;
> +
>  need_revalidate:
>  	path->dentry = do_revalidate(path->dentry, nd);
>  	if (!path->dentry)
> @@ -857,6 +1197,8 @@ static int __link_path_walk(const char *name, struct nameidata *nd)
>  	if (nd->depth)
>  		lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE);
>  
> +	follow_union_mount(&nd->path.mnt, &nd->path.dentry);
> +
>  	/* At this point we know we have a real path component. */
>  	for(;;) {
>  		unsigned long hash;
> @@ -1041,6 +1383,7 @@ static int path_init(int dfd, const char *name, unsigned int flags, struct namei
>  
>  	nd->last_type = LAST_ROOT; /* if there are only slashes... */
>  	nd->flags = flags;
> +	nd->um_flags = 0;
>  	nd->depth = 0;
>  	nd->root.mnt = NULL;
>  
> @@ -1249,6 +1592,130 @@ static int lookup_hash(struct nameidata *nd, struct qstr *name,
>  	return err;
>  }
>  
> +static int __hash_lookup_topmost(struct nameidata *nd, struct qstr *name,
> +				 struct path *path)
> +{
> +	struct path next;
> +	int err;
> +
> +	err = lookup_hash(nd, name, path);
> +	if (err)
> +		return err;
> +
> +	if (path->dentry->d_inode)
> +		return 0;
> +
> +	while (follow_union_down(&nd->path.mnt, &nd->path.dentry)) {
> +		name->hash = full_name_hash(name->name, name->len);
> +		if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
> +			err = nd->path.dentry->d_op->d_hash(nd->path.dentry,
> +							    name);
> +			if (err < 0)
> +				goto out;
> +		}
> +
> +		mutex_lock(&nd->path.dentry->d_inode->i_mutex);
> +		err = lookup_hash(nd, name, &next);
> +		mutex_unlock(&nd->path.dentry->d_inode->i_mutex);
> +		if (err)
> +			goto out;
> +
> +		if (next.dentry->d_inode) {
> +			dput(path->dentry);
> +			mntget(next.mnt);
> +			*path = next;
> +			goto out;
> +		}
> +
> +		dput(next.dentry);
> +	}
> +out:
> +	if (err)
> +		dput(path->dentry);
> +	return err;
> +}
> +
> +static int __hash_lookup_build_union(struct nameidata *nd, struct qstr *name,
> +				     struct path *path)
> +{
> +	struct path last = *path;
> +	struct path next;
> +	int err = 0;
> +
> +	while (follow_union_down(&nd->path.mnt, &nd->path.dentry)) {
> +		/* We need to recompute the hash for lower layer lookups */
> +		name->hash = full_name_hash(name->name, name->len);
> +		if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
> +			err = nd->path.dentry->d_op->d_hash(nd->path.dentry,
> +							    name);
> +			if (err < 0)
> +				goto out;
> +		}
> +
> +		mutex_lock(&nd->path.dentry->d_inode->i_mutex);
> +		err = lookup_hash(nd, name, &next);
> +		mutex_unlock(&nd->path.dentry->d_inode->i_mutex);
> +		if (err)
> +			goto out;
> +
> +		if (!next.dentry->d_inode) {
> +			dput(next.dentry);
> +			continue;
> +		}
> +
> +		/* only directories can be part of a union stack */
> +		if (!S_ISDIR(next.dentry->d_inode->i_mode)) {
> +			dput(next.dentry);
> +			break;
> +		}
> +
> +		/* now we know we found something "real" */
> +		append_to_union(last.mnt, last.dentry, next.mnt, next.dentry);
> +
> +		if (last.dentry != path->dentry)
> +			path_put(&last);
> +		last.dentry = next.dentry;
> +		last.mnt = mntget(next.mnt);
> +	}
> +
> +	if (last.dentry != path->dentry)
> +		path_put(&last);
> +out:
> +	return err;
> +}
> +
> +static int hash_lookup_union(struct nameidata *nd, struct qstr *name,
> +			     struct path *path)
> +{
> +	struct path safe = { .dentry = nd->path.dentry, .mnt = nd->path.mnt };
> +	int res ;
> +
> +	path_get(&safe);
> +	res = __hash_lookup_topmost(nd, name, path);
> +	if (res)
> +		goto out;
> +
> +	/* only directories can be part of a union stack */
> +	if (!path->dentry->d_inode ||
> +	    !S_ISDIR(path->dentry->d_inode->i_mode))
> +		goto out;
> +
> +	/* Build the union stack for this part */
> +	res = __hash_lookup_build_union(nd, name, path);
> +	if (res) {
> +		dput(path->dentry);
> +		if (path->mnt != safe.mnt)
> +			mntput(path->mnt);
> +		goto out;
> +	}
> +
> +out:
> +	path_put(&nd->path);
> +	nd->path.dentry = safe.dentry;
> +	nd->path.mnt = safe.mnt;
> +	return res;
> +}
> +
>  static int __lookup_one_len(const char *name, struct qstr *this,
>  		struct dentry *base, int len)
>  {
> @@ -1756,7 +2223,7 @@ struct file *do_filp_open(int dfd, const char *pathname,
>  	if (flag & O_EXCL)
>  		nd.flags |= LOOKUP_EXCL;
>  	mutex_lock(&dir->d_inode->i_mutex);
> -	error = lookup_hash(&nd, &nd.last, &path);
> +	error = hash_lookup_union(&nd, &nd.last, &path);
>  
>  do_last:
>  	if (error) {
> @@ -1920,7 +2387,7 @@ do_link:
>  	}
>  	dir = nd.path.dentry;
>  	mutex_lock(&dir->d_inode->i_mutex);
> -	error = lookup_hash(&nd, &nd.last, &path);
> +	error = hash_lookup_union(&nd, &nd.last, &path);
>  	__putname(nd.last.name);
>  	goto do_last;
>  }
> @@ -1971,7 +2438,7 @@ struct dentry *lookup_create(struct nameidata *nd, int is_dir)
>  	/*
>  	 * Do the final lookup.
>  	 */
> -	err = lookup_hash(nd, &nd->last, &path);
> +	err = hash_lookup_union(nd, &nd->last, &path);
>  	if (err) {
>  		path.dentry = ERR_PTR(err);
>  		goto fail;
> @@ -2467,7 +2934,7 @@ static long do_rmdir(int dfd, const char __user *pathname)
>  	nd.flags &= ~LOOKUP_PARENT;
>  
>  	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
> -	error = lookup_hash(&nd, &nd.last, &path);
> +	error = hash_lookup_union(&nd, &nd.last, &path);
>  	if (error)
>  		goto exit2;
>  	error = mnt_want_write(nd.path.mnt);
> @@ -2550,7 +3017,7 @@ static long do_unlinkat(int dfd, const char __user *pathname)
>  	nd.flags &= ~LOOKUP_PARENT;
>  
>  	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
> -	error = lookup_hash(&nd, &nd.last, &path);
> +	error = hash_lookup_union(&nd, &nd.last, &path);
>  	if (!error) {
>  		/* Why not before? Because we want correct error value */
>  		if (nd.last.name[nd.last.len])
> @@ -2954,7 +3421,7 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
>  
>  	trap = lock_rename(new_dir, old_dir);
>  
> -	error = lookup_hash(&oldnd, &oldnd.last, &old);
> +	error = hash_lookup_union(&oldnd, &oldnd.last, &old);
>  	if (error)
>  		goto exit3;
>  	/* source must exist */
> @@ -2973,7 +3440,7 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
>  	error = -EINVAL;
>  	if (old.dentry == trap)
>  		goto exit4;
> -	error = lookup_hash(&newnd, &newnd.last, &new);
> +	error = hash_lookup_union(&newnd, &newnd.last, &new);
>  	if (error)
>  		goto exit4;
>  	/* target should not be an ancestor of source */
> diff --git a/include/linux/namei.h b/include/linux/namei.h
> index d870ae2..81afb59 100644
> --- a/include/linux/namei.h
> +++ b/include/linux/namei.h
> @@ -20,6 +20,7 @@ struct nameidata {
>  	struct qstr	last;
>  	struct path	root;
>  	unsigned int	flags;
> +	unsigned int	um_flags;

BTW, do we need a separate um_flags, or is there enough space in 'flags' to
store UM's flags as well?

>  	int		last_type;
>  	unsigned	depth;
>  	char *saved_names[MAX_NESTED_LINKS + 1];
> @@ -35,6 +36,9 @@ struct nameidata {
>   */
>  enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
>  
> +#define LAST_UNION             0x01
> +#define LAST_LOWLEVEL          0x02
> +
>  /*
>   * The bitmask for a lookup event:
>   *  - follow links at the end
> @@ -49,6 +53,8 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
>  #define LOOKUP_CONTINUE		 4
>  #define LOOKUP_PARENT		16
>  #define LOOKUP_REVAL		64
> +#define LOOKUP_TOPMOST	       128
> +
>  /*
>   * Intent data
>   */
> -- 
> 1.6.3.3
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

Erez.

  parent reply	other threads:[~2009-12-01  4:11 UTC|newest]

Thread overview: 100+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2009-10-21 19:18 [RFC PATCH 00/40] Writable overlays (union mounts) Valerie Aurora
2009-10-21 19:18 ` [PATCH 01/41] VFS: BUG() if somebody tries to rehash an already hashed dentry Valerie Aurora
2009-10-21 19:19   ` [PATCH 02/41] VFS: propagate mnt_flags into do_loopback Valerie Aurora
2009-10-21 19:19     ` [PATCH 03/41] VFS: Make lookup_hash() return a struct path Valerie Aurora
2009-10-21 19:19       ` [PATCH 04/41] VFS: Remove unnecessary micro-optimization in cached_lookup() Valerie Aurora
2009-10-21 19:19         ` [PATCH 05/41] VFS: Make real_lookup() return a struct path Valerie Aurora
2009-10-21 19:19           ` [PATCH 06/41] VFS: Introduce dput() variant that maintains a kill-list Valerie Aurora
2009-10-21 19:19             ` [PATCH 07/41] VFS: Add read-only users count to superblock Valerie Aurora
2009-10-21 19:19               ` [PATCH 08/41] Don't replace nameidata path when following links Valerie Aurora
2009-10-21 19:19                 ` [PATCH 09/41] whiteout: Don't return information about whiteouts to userspace Valerie Aurora
2009-10-21 19:19                   ` [PATCH 10/41] whiteout: Add vfs_whiteout() and whiteout inode operation Valerie Aurora
2009-10-21 19:19                     ` [PATCH 11/41] whiteout: Set S_OPAQUE inode flag when creating directories Valerie Aurora
2009-10-21 19:19                       ` [PATCH 12/41] union-mount: Allow removal of a directory Valerie Aurora
2009-10-21 19:19                         ` [PATCH 13/41] whiteout: tmpfs whiteout support Valerie Aurora
2009-10-21 19:19                           ` [PATCH 14/41] whiteout: Split of ext2_append_link() from ext2_add_link() Valerie Aurora
2009-10-21 19:19                             ` [PATCH 15/41] whiteout: ext2 whiteout support Valerie Aurora
2009-10-21 19:19                               ` [PATCH 16/41] whiteout: jffs2 " Valerie Aurora
2009-10-21 19:19                                 ` [PATCH 17/41] whiteout: Add path_whiteout() helper Valerie Aurora
2009-10-21 19:19                                   ` [PATCH 18/41] union-mount: Documentation Valerie Aurora
2009-10-21 19:19                                     ` [PATCH 19/41] union-mount: Introduce MNT_UNION and MS_UNION flags Valerie Aurora
2009-10-21 19:19                                       ` [PATCH 20/41] union-mount: Introduce union_mount structure Valerie Aurora
2009-10-21 19:19                                         ` [PATCH 21/41] union-mount: Drive the union cache via dcache Valerie Aurora
2009-10-21 19:19                                           ` [PATCH 22/41] union-mount: Some checks during namespace changes Valerie Aurora
2009-10-21 19:19                                             ` [PATCH 23/41] union-mount: Changes to the namespace handling Valerie Aurora
2009-10-21 19:19                                               ` [PATCH 24/41] union-mount: Make lookup work for union-mounted file systems Valerie Aurora
2009-10-21 19:19                                                 ` [PATCH 25/41] union-mount: stop lookup when directory has S_OPAQUE flag set Valerie Aurora
2009-10-21 19:19                                                   ` [PATCH 26/41] union-mount: stop lookup when finding a whiteout Valerie Aurora
2009-10-21 19:19                                                     ` [PATCH 27/41] union-mount: in-kernel file copy between union mounted filesystems Valerie Aurora
2009-10-21 19:19                                                       ` [PATCH 28/41] union-mount: call do_whiteout() on unlink and rmdir Valerie Aurora
2009-10-21 19:19                                                         ` [PATCH 29/41] union-mount: Always create topmost directory on open Valerie Aurora
2009-10-21 19:19                                                           ` [PATCH 30/41] fallthru: Basic fallthru definitions Valerie Aurora
2009-10-21 19:19                                                             ` [PATCH 31/41] fallthru: Support for fallthru entries in union mount lookup Valerie Aurora
2009-10-21 19:19                                                               ` [PATCH 32/41] fallthru: ext2 fallthru support Valerie Aurora
2009-10-21 19:19                                                                 ` [PATCH 33/41] fallthru: jffs2 " Valerie Aurora
2009-10-21 19:19                                                                   ` [PATCH 34/41] fallthru: tmpfs " Valerie Aurora
2009-10-21 19:19                                                                     ` [PATCH 35/41] union-mount: Copy up directory entries on first readdir() Valerie Aurora
2009-10-21 19:19                                                                       ` [PATCH 36/41] union-mount: Increment read-only users count for read-only layer Valerie Aurora
2009-10-21 19:19                                                                         ` [PATCH 37/41] union-mount: Check read-only/read-write status of layers Valerie Aurora
2009-10-21 19:19                                                                           ` [PATCH 38/41] union-mount: Make pivot_root work with union mounts Valerie Aurora
2009-10-21 19:19                                                                             ` [PATCH 39/41] union-mount: Ignore read-only file system in permission checks Valerie Aurora
2009-10-21 19:19                                                                               ` [PATCH 40/41] union-mount: Make truncate work in all its glorious UNIX variations Valerie Aurora
2009-10-21 19:19                                                                                 ` [PATCH 41/41] union-mount: Add support for rename by __union_copyup() Valerie Aurora
2009-12-01  4:57                                                                                   ` Erez Zadok
2009-12-01  4:50                                                                                 ` [PATCH 40/41] union-mount: Make truncate work in all its glorious UNIX variations Erez Zadok
2009-12-01  4:34                                                                               ` [PATCH 39/41] union-mount: Ignore read-only file system in permission checks Erez Zadok
2009-12-01  4:26                                                                             ` [PATCH 38/41] union-mount: Make pivot_root work with union mounts Erez Zadok
2009-12-01  4:18                                                                       ` [PATCH 35/41] union-mount: Copy up directory entries on first readdir() Erez Zadok
2009-12-01  4:17                                                                     ` [PATCH 34/41] fallthru: tmpfs fallthru support Erez Zadok
2009-12-01  4:17                                                                   ` [PATCH 33/41] fallthru: jffs2 " Erez Zadok
2009-12-01  4:17                                                                 ` [PATCH 32/41] fallthru: ext2 " Erez Zadok
2009-12-01  4:15                                                               ` [PATCH 31/41] fallthru: Support for fallthru entries in union mount lookup Erez Zadok
2009-12-01  4:14                                                             ` [PATCH 30/41] fallthru: Basic fallthru definitions Erez Zadok
2009-12-01  4:14                                                           ` [PATCH 29/41] union-mount: Always create topmost directory on open Erez Zadok
2009-12-01  4:13                                                       ` [PATCH 27/41] union-mount: in-kernel file copy between union mounted filesystems Erez Zadok
2009-12-01  4:11                                                     ` [PATCH 26/41] union-mount: stop lookup when finding a whiteout Erez Zadok
2009-12-01  4:10                                                   ` [PATCH 25/41] union-mount: stop lookup when directory has S_OPAQUE flag set Erez Zadok
2009-12-01  4:10                                                 ` Erez Zadok [this message]
2009-11-30  9:15                                               ` [PATCH 23/41] union-mount: Changes to the namespace handling Erez Zadok
2009-11-30  9:04                                             ` [PATCH 22/41] union-mount: Some checks during namespace changes Erez Zadok
2009-11-30  8:57                                           ` [PATCH 21/41] union-mount: Drive the union cache via dcache Erez Zadok
2009-11-30  8:46                                         ` [PATCH 20/41] union-mount: Introduce union_mount structure Erez Zadok
2010-01-26 22:38                                           ` Valerie Aurora
2009-11-30  8:02                                       ` [PATCH 19/41] union-mount: Introduce MNT_UNION and MS_UNION flags Erez Zadok
2010-01-26 20:03                                         ` Valerie Aurora
2009-12-01  5:37                                     ` [PATCH 18/41] union-mount: Documentation Erez Zadok
2009-11-30  7:57                                   ` [PATCH 17/41] whiteout: Add path_whiteout() helper Erez Zadok
2010-01-26 20:02                                     ` Valerie Aurora
2009-10-21 22:50                                 ` [PATCH 16/41] whiteout: jffs2 whiteout support David Woodhouse
2009-10-27  2:21                                   ` Valerie Aurora
2009-11-30  7:51                                 ` Erez Zadok
2010-01-26 19:52                                   ` Valerie Aurora
2009-10-21 21:17                               ` [PATCH 15/41] whiteout: ext2 " Andreas Dilger
2009-10-27  2:14                                 ` Valerie Aurora
2009-11-30  7:45                               ` Erez Zadok
2009-11-30  6:32                             ` [PATCH 14/41] whiteout: Split of ext2_append_link() from ext2_add_link() Erez Zadok
2009-11-30  6:26                           ` [PATCH 13/41] whiteout: tmpfs whiteout support Erez Zadok
2010-01-21  2:02                             ` Valerie Aurora
2009-11-30  6:13                         ` [PATCH 12/41] union-mount: Allow removal of a directory Erez Zadok
2010-01-21  0:52                           ` Valerie Aurora
2009-10-27 14:36                     ` [PATCH 10/41] whiteout: Add vfs_whiteout() and whiteout inode operation Eric Paris
2009-10-27 21:22                       ` Valerie Aurora
2009-11-30  3:04                     ` Erez Zadok
2010-01-21  0:35                       ` Valerie Aurora
2009-11-30  2:53                   ` [PATCH 09/41] whiteout: Don't return information about whiteouts to userspace Erez Zadok
2010-01-21  0:19                     ` Valerie Aurora
2009-11-30  2:44                 ` [PATCH 08/41] Don't replace nameidata path when following links Erez Zadok
2009-11-30  2:33               ` [PATCH 07/41] VFS: Add read-only users count to superblock Erez Zadok
2009-11-30  2:28             ` [PATCH 06/41] VFS: Introduce dput() variant that maintains a kill-list Erez Zadok
2010-01-20 23:31               ` Valerie Aurora
2009-11-30  2:11           ` [PATCH 05/41] VFS: Make real_lookup() return a struct path Erez Zadok
2009-11-30  2:07         ` [PATCH 04/41] VFS: Remove unnecessary micro-optimization in cached_lookup() Erez Zadok
2009-12-10 21:25           ` Valerie Aurora
2009-11-30  2:02       ` [PATCH 03/41] VFS: Make lookup_hash() return a struct path Erez Zadok
2009-12-10 21:23         ` Valerie Aurora
2009-11-30  6:04       ` Erez Zadok
2009-12-10 21:24         ` Valerie Aurora
2009-11-30  1:43   ` [PATCH 01/41] VFS: BUG() if somebody tries to rehash an already hashed dentry Erez Zadok
2009-12-10 20:20     ` Valerie Aurora
2009-10-22  2:44 ` [RFC PATCH 00/40] Writable overlays (union mounts) hooanon05
2009-10-27  2:23   ` Valerie Aurora

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=200912010410.nB14ASgB030294@agora.fsl.cs.sunysb.edu \
    --to=ezk@cs.sunysb.edu \
    --cc=apw@canonical.com \
    --cc=arnd@arndb.de \
    --cc=baggins@sith.mimuw.edu.pl \
    --cc=dronnikov@gmail.com \
    --cc=hch@infradead.org \
    --cc=hooanon05@yahoo.co.jp \
    --cc=jblunck@suse.de \
    --cc=linux-fsdevel@vger.kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=nbd@openwrt.org \
    --cc=sandupopamarius@gmail.com \
    --cc=scott@canonical.com \
    --cc=vaurora@redhat.com \
    --cc=viro@zeniv.linux.org.uk \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®