[mirror_ubuntu-zesty-kernel.git] / fs / overlayfs / namei.c

/*
 * Copyright (C) 2011 Novell Inc.
 * Copyright (C) 2016 Red Hat, Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */

#include <linux/fs.h>
#include <linux/namei.h>
#include <linux/xattr.h>
#include <linux/ratelimit.h>
#include "overlayfs.h"
#include "ovl_entry.h"

struct ovl_lookup_data {
	struct qstr name;
	bool is_dir;
	bool opaque;
	bool stop;
	bool last;
	char *redirect;
};

static int ovl_check_redirect(struct dentry *dentry, struct ovl_lookup_data *d,
			      size_t prelen, const char *post)
{
	int res;
	char *s, *next, *buf = NULL;

	res = vfs_getxattr(dentry, OVL_XATTR_REDIRECT, NULL, 0);
	if (res < 0) {
		if (res == -ENODATA || res == -EOPNOTSUPP)
			return 0;
		goto fail;
	}
	buf = kzalloc(prelen + res + strlen(post) + 1, GFP_TEMPORARY);
	if (!buf)
		return -ENOMEM;

	if (res == 0)
		goto invalid;

	res = vfs_getxattr(dentry, OVL_XATTR_REDIRECT, buf, res);
	if (res < 0)
		goto fail;
	if (res == 0)
		goto invalid;
	if (buf[0] == '/') {
		for (s = buf; *s++ == '/'; s = next) {
			next = strchrnul(s, '/');
			if (s == next)
				goto invalid;
		}
	} else {
		if (strchr(buf, '/') != NULL)
			goto invalid;

		memmove(buf + prelen, buf, res);
		memcpy(buf, d->name.name, prelen);
	}

	strcat(buf, post);
	kfree(d->redirect);
	d->redirect = buf;
	d->name.name = d->redirect;
	d->name.len = strlen(d->redirect);

	return 0;

err_free:
	kfree(buf);
	return 0;
fail:
	pr_warn_ratelimited("overlayfs: failed to get redirect (%i)\n", res);
	goto err_free;
invalid:
	pr_warn_ratelimited("overlayfs: invalid redirect (%s)\n", buf);
	goto err_free;
}

static bool ovl_is_opaquedir(struct dentry *dentry)
{
	int res;
	char val;

	if (!d_is_dir(dentry))
		return false;

	res = vfs_getxattr(dentry, OVL_XATTR_OPAQUE, &val, 1);
	if (res == 1 && val == 'y')
		return true;

	return false;
}

static int ovl_lookup_single(struct dentry *base, struct ovl_lookup_data *d,
			     const char *name, unsigned int namelen,
			     size_t prelen, const char *post,
			     struct dentry **ret)
{
	struct dentry *this;
	int err;

	this = lookup_one_len_unlocked(name, base, namelen);
	if (IS_ERR(this)) {
		err = PTR_ERR(this);
		this = NULL;
		if (err == -ENOENT || err == -ENAMETOOLONG)
			goto out;
		goto out_err;
	}
	if (!this->d_inode)
		goto put_and_out;

	if (ovl_dentry_weird(this)) {
		/* Don't support traversing automounts and other weirdness */
		err = -EREMOTE;
		goto out_err;
	}
	if (ovl_is_whiteout(this)) {
		d->stop = d->opaque = true;
		goto put_and_out;
	}
	if (!d_can_lookup(this)) {
		d->stop = true;
		if (d->is_dir)
			goto put_and_out;
		goto out;
	}
	d->is_dir = true;
	if (!d->last && ovl_is_opaquedir(this)) {
		d->stop = d->opaque = true;
		goto out;
	}
	err = ovl_check_redirect(this, d, prelen, post);
	if (err)
		goto out_err;
out:
	*ret = this;
	return 0;

put_and_out:
	dput(this);
	this = NULL;
	goto out;

out_err:
	dput(this);
	return err;
}

static int ovl_lookup_layer(struct dentry *base, struct ovl_lookup_data *d,
			    struct dentry **ret)
{
	/* Counting down from the end, since the prefix can change */
	size_t rem = d->name.len - 1;
	struct dentry *dentry = NULL;
	int err;

	if (d->name.name[0] != '/')
		return ovl_lookup_single(base, d, d->name.name, d->name.len,
					 0, "", ret);

	while (!IS_ERR_OR_NULL(base) && d_can_lookup(base)) {
		const char *s = d->name.name + d->name.len - rem;
		const char *next = strchrnul(s, '/');
		size_t thislen = next - s;
		bool end = !next[0];

		/* Verify we did not go off the rails */
		if (WARN_ON(s[-1] != '/'))
			return -EIO;

		err = ovl_lookup_single(base, d, s, thislen,
					d->name.len - rem, next, &base);
		dput(dentry);
		if (err)
			return err;
		dentry = base;
		if (end)
			break;

		rem -= thislen + 1;

		if (WARN_ON(rem >= d->name.len))
			return -EIO;
	}
	*ret = dentry;
	return 0;
}

/*
 * Returns next layer in stack starting from top.
 * Returns -1 if this is the last layer.
 */
int ovl_path_next(int idx, struct dentry *dentry, struct path *path)
{
	struct ovl_entry *oe = dentry->d_fsdata;

	BUG_ON(idx < 0);
	if (idx == 0) {
		ovl_path_upper(dentry, path);
		if (path->dentry)
			return oe->numlower ? 1 : -1;
		idx++;
	}
	BUG_ON(idx > oe->numlower);
	*path = oe->lowerstack[idx - 1];

	return (idx < oe->numlower) ? idx + 1 : -1;
}

struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
			  unsigned int flags)
{
	struct ovl_entry *oe;
	const struct cred *old_cred;
	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
	struct ovl_entry *poe = dentry->d_parent->d_fsdata;
	struct path *stack = NULL;
	struct dentry *upperdir, *upperdentry = NULL;
	unsigned int ctr = 0;
	struct inode *inode = NULL;
	bool upperopaque = false;
	char *upperredirect = NULL;
	struct dentry *this;
	unsigned int i;
	int err;
	struct ovl_lookup_data d = {
		.name = dentry->d_name,
		.is_dir = false,
		.opaque = false,
		.stop = false,
		.last = !poe->numlower,
		.redirect = NULL,
	};

	if (dentry->d_name.len > ofs->namelen)
		return ERR_PTR(-ENAMETOOLONG);

	old_cred = ovl_override_creds(dentry->d_sb);
	upperdir = ovl_upperdentry_dereference(poe);
	if (upperdir) {
		err = ovl_lookup_layer(upperdir, &d, &upperdentry);
		if (err)
			goto out;

		if (upperdentry && unlikely(ovl_dentry_remote(upperdentry))) {
			dput(upperdentry);
			err = -EREMOTE;
			goto out;
		}

		if (d.redirect) {
			upperredirect = kstrdup(d.redirect, GFP_KERNEL);
			if (!upperredirect)
				goto out_put_upper;
			if (d.redirect[0] == '/')
				poe = dentry->d_sb->s_root->d_fsdata;
		}
		upperopaque = d.opaque;
	}

	if (!d.stop && poe->numlower) {
		err = -ENOMEM;
		stack = kcalloc(ofs->numlower, sizeof(struct path),
				GFP_TEMPORARY);
		if (!stack)
			goto out_put_upper;
	}

	for (i = 0; !d.stop && i < poe->numlower; i++) {
		struct path lowerpath = poe->lowerstack[i];

		d.last = i == poe->numlower - 1;
		err = ovl_lookup_layer(lowerpath.dentry, &d, &this);
		if (err)
			goto out_put;

		if (!this)
			continue;

		stack[ctr].dentry = this;
		stack[ctr].mnt = lowerpath.mnt;
		ctr++;

		if (d.stop)
			break;

		if (d.redirect &&
		    d.redirect[0] == '/' &&
		    poe != dentry->d_sb->s_root->d_fsdata) {
			poe = dentry->d_sb->s_root->d_fsdata;

			/* Find the current layer on the root dentry */
			for (i = 0; i < poe->numlower; i++)
				if (poe->lowerstack[i].mnt == lowerpath.mnt)
					break;
			if (WARN_ON(i == poe->numlower))
				break;
		}
	}

	oe = ovl_alloc_entry(ctr);
	err = -ENOMEM;
	if (!oe)
		goto out_put;

	if (upperdentry || ctr) {
		struct dentry *realdentry;
		struct inode *realinode;

		realdentry = upperdentry ? upperdentry : stack[0].dentry;
		realinode = d_inode(realdentry);

		err = -ENOMEM;
		if (upperdentry && !d_is_dir(upperdentry)) {
			inode = ovl_get_inode(dentry->d_sb, realinode);
		} else {
			inode = ovl_new_inode(dentry->d_sb, realinode->i_mode,
					      realinode->i_rdev);
			if (inode)
				ovl_inode_init(inode, realinode, !!upperdentry);
		}
		if (!inode)
			goto out_free_oe;
		ovl_copyattr(realdentry->d_inode, inode);
	}

	revert_creds(old_cred);
	oe->opaque = upperopaque;
	oe->redirect = upperredirect;
	oe->__upperdentry = upperdentry;
	memcpy(oe->lowerstack, stack, sizeof(struct path) * ctr);
	kfree(stack);
	kfree(d.redirect);
	dentry->d_fsdata = oe;
	d_add(dentry, inode);

	return NULL;

out_free_oe:
	kfree(oe);
out_put:
	for (i = 0; i < ctr; i++)
		dput(stack[i].dentry);
	kfree(stack);
out_put_upper:
	dput(upperdentry);
	kfree(upperredirect);
out:
	kfree(d.redirect);
	revert_creds(old_cred);
	return ERR_PTR(err);
}

bool ovl_lower_positive(struct dentry *dentry)
{
	struct ovl_entry *oe = dentry->d_fsdata;
	struct ovl_entry *poe = dentry->d_parent->d_fsdata;
	const struct qstr *name = &dentry->d_name;
	unsigned int i;
	bool positive = false;
	bool done = false;

	/*
	 * If dentry is negative, then lower is positive iff this is a
	 * whiteout.
	 */
	if (!dentry->d_inode)
		return oe->opaque;

	/* Negative upper -> positive lower */
	if (!oe->__upperdentry)
		return true;

	/* Positive upper -> have to look up lower to see whether it exists */
	for (i = 0; !done && !positive && i < poe->numlower; i++) {
		struct dentry *this;
		struct dentry *lowerdir = poe->lowerstack[i].dentry;

		this = lookup_one_len_unlocked(name->name, lowerdir,
					       name->len);
		if (IS_ERR(this)) {
			switch (PTR_ERR(this)) {
			case -ENOENT:
			case -ENAMETOOLONG:
				break;

			default:
				/*
				 * Assume something is there, we just couldn't
				 * access it.
				 */
				positive = true;
				break;
			}
		} else {
			if (this->d_inode) {
				positive = !ovl_is_whiteout(this);
				done = true;
			}
			dput(this);
		}
	}

	return positive;
}
Commit	Line	Data
bbb1e54d MS	1	/*
	2	* Copyright (C) 2011 Novell Inc.
	3	* Copyright (C) 2016 Red Hat, Inc.
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 as published by
	7	* the Free Software Foundation.
	8	*/
	9
	10	#include <linux/fs.h>
	11	#include <linux/namei.h>
	12	#include <linux/xattr.h>
02b69b28	13	#include <linux/ratelimit.h>
bbb1e54d MS	14	#include "overlayfs.h"
	15	#include "ovl_entry.h"
	16
e28edc46 MS	17	struct ovl_lookup_data {
	18	struct qstr name;
	19	bool is_dir;
	20	bool opaque;
	21	bool stop;
	22	bool last;
02b69b28	23	char *redirect;
e28edc46	24	};
bbb1e54d	25
02b69b28 MS	26	static int ovl_check_redirect(struct dentry dentry, struct ovl_lookup_data d,
	27	size_t prelen, const char *post)
	28	{
	29	int res;
	30	char s, next, *buf = NULL;
	31
	32	res = vfs_getxattr(dentry, OVL_XATTR_REDIRECT, NULL, 0);
	33	if (res < 0) {
	34	if (res == -ENODATA \|\| res == -EOPNOTSUPP)
	35	return 0;
	36	goto fail;
	37	}
	38	buf = kzalloc(prelen + res + strlen(post) + 1, GFP_TEMPORARY);
	39	if (!buf)
	40	return -ENOMEM;
	41
	42	if (res == 0)
	43	goto invalid;
	44
	45	res = vfs_getxattr(dentry, OVL_XATTR_REDIRECT, buf, res);
	46	if (res < 0)
	47	goto fail;
	48	if (res == 0)
	49	goto invalid;
	50	if (buf[0] == '/') {
	51	for (s = buf; *s++ == '/'; s = next) {
	52	next = strchrnul(s, '/');
	53	if (s == next)
	54	goto invalid;
	55	}
	56	} else {
	57	if (strchr(buf, '/') != NULL)
	58	goto invalid;
	59
	60	memmove(buf + prelen, buf, res);
	61	memcpy(buf, d->name.name, prelen);
	62	}
	63
	64	strcat(buf, post);
	65	kfree(d->redirect);
	66	d->redirect = buf;
	67	d->name.name = d->redirect;
	68	d->name.len = strlen(d->redirect);
	69
	70	return 0;
	71
	72	err_free:
	73	kfree(buf);
	74	return 0;
	75	fail:
	76	pr_warn_ratelimited("overlayfs: failed to get redirect (%i)\n", res);
	77	goto err_free;
	78	invalid:
	79	pr_warn_ratelimited("overlayfs: invalid redirect (%s)\n", buf);
	80	goto err_free;
	81	}
	82
bbb1e54d MS	83	static bool ovl_is_opaquedir(struct dentry *dentry)
	84	{
	85	int res;
	86	char val;
	87
	88	if (!d_is_dir(dentry))
	89	return false;
	90
	91	res = vfs_getxattr(dentry, OVL_XATTR_OPAQUE, &val, 1);
	92	if (res == 1 && val == 'y')
	93	return true;
	94
	95	return false;
	96	}
	97
e28edc46 MS	98	static int ovl_lookup_single(struct dentry base, struct ovl_lookup_data d,
e28edc46 MS	99	const char *name, unsigned int namelen,
02b69b28	100	size_t prelen, const char *post,
e28edc46 MS	101	struct dentry **ret)
	102	{
	103	struct dentry *this;
	104	int err;
	105
	106	this = lookup_one_len_unlocked(name, base, namelen);
	107	if (IS_ERR(this)) {
	108	err = PTR_ERR(this);
	109	this = NULL;
	110	if (err == -ENOENT \|\| err == -ENAMETOOLONG)
	111	goto out;
	112	goto out_err;
	113	}
	114	if (!this->d_inode)
	115	goto put_and_out;
	116
	117	if (ovl_dentry_weird(this)) {
	118	/* Don't support traversing automounts and other weirdness */
	119	err = -EREMOTE;
	120	goto out_err;
	121	}
	122	if (ovl_is_whiteout(this)) {
	123	d->stop = d->opaque = true;
	124	goto put_and_out;
	125	}
	126	if (!d_can_lookup(this)) {
	127	d->stop = true;
	128	if (d->is_dir)
	129	goto put_and_out;
	130	goto out;
	131	}
	132	d->is_dir = true;
	133	if (!d->last && ovl_is_opaquedir(this)) {
	134	d->stop = d->opaque = true;
	135	goto out;
	136	}
02b69b28 MS	137	err = ovl_check_redirect(this, d, prelen, post);
	138	if (err)
	139	goto out_err;
e28edc46 MS	140	out:
	141	*ret = this;
	142	return 0;
	143
	144	put_and_out:
	145	dput(this);
	146	this = NULL;
	147	goto out;
	148
	149	out_err:
	150	dput(this);
	151	return err;
	152	}
	153
	154	static int ovl_lookup_layer(struct dentry base, struct ovl_lookup_data d,
	155	struct dentry **ret)
	156	{
4c7d0c9c AG	157	/* Counting down from the end, since the prefix can change */
4c7d0c9c AG	158	size_t rem = d->name.len - 1;
02b69b28 MS	159	struct dentry *dentry = NULL;
	160	int err;
	161
4c7d0c9c	162	if (d->name.name[0] != '/')
02b69b28 MS	163	return ovl_lookup_single(base, d, d->name.name, d->name.len,
	164	0, "", ret);
	165
4c7d0c9c AG	166	while (!IS_ERR_OR_NULL(base) && d_can_lookup(base)) {
4c7d0c9c AG	167	const char *s = d->name.name + d->name.len - rem;
02b69b28	168	const char *next = strchrnul(s, '/');
4c7d0c9c AG	169	size_t thislen = next - s;
4c7d0c9c AG	170	bool end = !next[0];
02b69b28	171
4c7d0c9c AG	172	/* Verify we did not go off the rails */
4c7d0c9c AG	173	if (WARN_ON(s[-1] != '/'))
02b69b28 MS	174	return -EIO;
02b69b28 MS	175
4c7d0c9c AG	176	err = ovl_lookup_single(base, d, s, thislen,
4c7d0c9c AG	177	d->name.len - rem, next, &base);
02b69b28 MS	178	dput(dentry);
	179	if (err)
	180	return err;
	181	dentry = base;
4c7d0c9c AG	182	if (end)
	183	break;
	184
	185	rem -= thislen + 1;
	186
	187	if (WARN_ON(rem >= d->name.len))
	188	return -EIO;
02b69b28 MS	189	}
	190	*ret = dentry;
	191	return 0;
e28edc46 MS	192	}
e28edc46 MS	193
bbb1e54d MS	194	/*
	195	* Returns next layer in stack starting from top.
	196	* Returns -1 if this is the last layer.
	197	*/
	198	int ovl_path_next(int idx, struct dentry dentry, struct path path)
	199	{
	200	struct ovl_entry *oe = dentry->d_fsdata;
	201
	202	BUG_ON(idx < 0);
	203	if (idx == 0) {
	204	ovl_path_upper(dentry, path);
	205	if (path->dentry)
	206	return oe->numlower ? 1 : -1;
	207	idx++;
	208	}
	209	BUG_ON(idx > oe->numlower);
	210	*path = oe->lowerstack[idx - 1];
	211
	212	return (idx < oe->numlower) ? idx + 1 : -1;
	213	}
	214
	215	struct dentry ovl_lookup(struct inode dir, struct dentry *dentry,
	216	unsigned int flags)
	217	{
	218	struct ovl_entry *oe;
	219	const struct cred *old_cred;
6b2d5fe4	220	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
bbb1e54d MS	221	struct ovl_entry *poe = dentry->d_parent->d_fsdata;
	222	struct path *stack = NULL;
	223	struct dentry upperdir, upperdentry = NULL;
	224	unsigned int ctr = 0;
	225	struct inode *inode = NULL;
	226	bool upperopaque = false;
02b69b28	227	char *upperredirect = NULL;
bbb1e54d MS	228	struct dentry *this;
	229	unsigned int i;
	230	int err;
e28edc46 MS	231	struct ovl_lookup_data d = {
	232	.name = dentry->d_name,
	233	.is_dir = false,
	234	.opaque = false,
	235	.stop = false,
	236	.last = !poe->numlower,
02b69b28	237	.redirect = NULL,
e28edc46	238	};
bbb1e54d	239
6b2d5fe4 MS	240	if (dentry->d_name.len > ofs->namelen)
	241	return ERR_PTR(-ENAMETOOLONG);
	242
bbb1e54d MS	243	old_cred = ovl_override_creds(dentry->d_sb);
	244	upperdir = ovl_upperdentry_dereference(poe);
	245	if (upperdir) {
e28edc46 MS	246	err = ovl_lookup_layer(upperdir, &d, &upperdentry);
e28edc46 MS	247	if (err)
bbb1e54d MS	248	goto out;
bbb1e54d MS	249
e28edc46 MS	250	if (upperdentry && unlikely(ovl_dentry_remote(upperdentry))) {
	251	dput(upperdentry);
	252	err = -EREMOTE;
	253	goto out;
bbb1e54d	254	}
02b69b28 MS	255
	256	if (d.redirect) {
	257	upperredirect = kstrdup(d.redirect, GFP_KERNEL);
	258	if (!upperredirect)
	259	goto out_put_upper;
	260	if (d.redirect[0] == '/')
	261	poe = dentry->d_sb->s_root->d_fsdata;
	262	}
e28edc46	263	upperopaque = d.opaque;
bbb1e54d MS	264	}
bbb1e54d MS	265
e28edc46	266	if (!d.stop && poe->numlower) {
bbb1e54d	267	err = -ENOMEM;
02b69b28	268	stack = kcalloc(ofs->numlower, sizeof(struct path),
e28edc46	269	GFP_TEMPORARY);
bbb1e54d MS	270	if (!stack)
	271	goto out_put_upper;
	272	}
	273
e28edc46	274	for (i = 0; !d.stop && i < poe->numlower; i++) {
bbb1e54d MS	275	struct path lowerpath = poe->lowerstack[i];
bbb1e54d MS	276
e28edc46 MS	277	d.last = i == poe->numlower - 1;
	278	err = ovl_lookup_layer(lowerpath.dentry, &d, &this);
	279	if (err)
bbb1e54d	280	goto out_put;
6b2d5fe4	281
bbb1e54d MS	282	if (!this)
bbb1e54d MS	283	continue;
bbb1e54d MS	284
	285	stack[ctr].dentry = this;
	286	stack[ctr].mnt = lowerpath.mnt;
	287	ctr++;
02b69b28 MS	288
	289	if (d.stop)
	290	break;
	291
	292	if (d.redirect &&
	293	d.redirect[0] == '/' &&
	294	poe != dentry->d_sb->s_root->d_fsdata) {
	295	poe = dentry->d_sb->s_root->d_fsdata;
	296
	297	/* Find the current layer on the root dentry */
	298	for (i = 0; i < poe->numlower; i++)
	299	if (poe->lowerstack[i].mnt == lowerpath.mnt)
	300	break;
	301	if (WARN_ON(i == poe->numlower))
	302	break;
	303	}
bbb1e54d MS	304	}
	305
	306	oe = ovl_alloc_entry(ctr);
	307	err = -ENOMEM;
	308	if (!oe)
	309	goto out_put;
	310
	311	if (upperdentry \|\| ctr) {
	312	struct dentry *realdentry;
	313	struct inode *realinode;
	314
	315	realdentry = upperdentry ? upperdentry : stack[0].dentry;
	316	realinode = d_inode(realdentry);
	317
	318	err = -ENOMEM;
	319	if (upperdentry && !d_is_dir(upperdentry)) {
	320	inode = ovl_get_inode(dentry->d_sb, realinode);
	321	} else {
	322	inode = ovl_new_inode(dentry->d_sb, realinode->i_mode,
	323	realinode->i_rdev);
	324	if (inode)
	325	ovl_inode_init(inode, realinode, !!upperdentry);
	326	}
	327	if (!inode)
	328	goto out_free_oe;
	329	ovl_copyattr(realdentry->d_inode, inode);
	330	}
	331
	332	revert_creds(old_cred);
	333	oe->opaque = upperopaque;
02b69b28	334	oe->redirect = upperredirect;
bbb1e54d MS	335	oe->__upperdentry = upperdentry;
	336	memcpy(oe->lowerstack, stack, sizeof(struct path) * ctr);
	337	kfree(stack);
02b69b28	338	kfree(d.redirect);
bbb1e54d MS	339	dentry->d_fsdata = oe;
	340	d_add(dentry, inode);
	341
	342	return NULL;
	343
	344	out_free_oe:
	345	kfree(oe);
	346	out_put:
	347	for (i = 0; i < ctr; i++)
	348	dput(stack[i].dentry);
	349	kfree(stack);
	350	out_put_upper:
	351	dput(upperdentry);
02b69b28	352	kfree(upperredirect);
bbb1e54d	353	out:
02b69b28	354	kfree(d.redirect);
bbb1e54d MS	355	revert_creds(old_cred);
	356	return ERR_PTR(err);
	357	}
	358
	359	bool ovl_lower_positive(struct dentry *dentry)
	360	{
	361	struct ovl_entry *oe = dentry->d_fsdata;
	362	struct ovl_entry *poe = dentry->d_parent->d_fsdata;
	363	const struct qstr *name = &dentry->d_name;
	364	unsigned int i;
	365	bool positive = false;
	366	bool done = false;
	367
	368	/*
	369	* If dentry is negative, then lower is positive iff this is a
	370	* whiteout.
	371	*/
	372	if (!dentry->d_inode)
	373	return oe->opaque;
	374
	375	/* Negative upper -> positive lower */
	376	if (!oe->__upperdentry)
	377	return true;
	378
	379	/* Positive upper -> have to look up lower to see whether it exists */
	380	for (i = 0; !done && !positive && i < poe->numlower; i++) {
	381	struct dentry *this;
	382	struct dentry *lowerdir = poe->lowerstack[i].dentry;
	383
	384	this = lookup_one_len_unlocked(name->name, lowerdir,
	385	name->len);
	386	if (IS_ERR(this)) {
	387	switch (PTR_ERR(this)) {
	388	case -ENOENT:
	389	case -ENAMETOOLONG:
	390	break;
	391
	392	default:
	393	/*
	394	* Assume something is there, we just couldn't
	395	* access it.
	396	*/
	397	positive = true;
	398	break;
	399	}
	400	} else {
	401	if (this->d_inode) {
	402	positive = !ovl_is_whiteout(this);
	403	done = true;
	404	}
	405	dput(this);
	406	}
	407	}
	408
	409	return positive;
	410	}