fs/overlayfs/namei.c - linux - Git at Google

 /*
  * 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)
 {
 	const char *s = d->name.name;
 	struct dentry *dentry = NULL;
 	int err;

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

 	while (*s++ == '/' && !IS_ERR_OR_NULL(base) && d_can_lookup(base)) {
 		const char *next = strchrnul(s, '/');
 		size_t slen = strlen(s);

 		if (WARN_ON(slen > d->name.len) ||
 		    WARN_ON(strcmp(d->name.name + d->name.len - slen, s)))
 			return -EIO;

 		err = ovl_lookup_single(base, d, s, next - s,
 					d->name.len - slen, next, &base);
 		dput(dentry);
 		if (err)
 			return err;
 		dentry = base;
 		s = next;
 	}
 	*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;
 }
	/*
	* 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)
	{
	const char *s = d->name.name;
	struct dentry *dentry = NULL;
	int err;

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

	while (*s++ == '/' && !IS_ERR_OR_NULL(base) && d_can_lookup(base)) {
	const char *next = strchrnul(s, '/');
	size_t slen = strlen(s);

	if (WARN_ON(slen > d->name.len) \|\|
	WARN_ON(strcmp(d->name.name + d->name.len - slen, s)))
	return -EIO;

	err = ovl_lookup_single(base, d, s, next - s,
	d->name.len - slen, next, &base);
	dput(dentry);
	if (err)
	return err;
	dentry = base;
	s = next;
	}
	*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;
	}