mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-04 09:59:32 +00:00
![Amir Goldstein](/assets/img/avatar_default.png)
ovl_lookup_layer() iterates on path elements of d->name.name
but also frees and allocates a new pointer for d->name.name.
For the case of lookup in upper layer, the initial d->name.name
pointer is stable (dentry->d_name), but for lower layers, the
initial d->name.name can be d->redirect, which can be freed during
iteration.
[SzM]
Keep the count of remaining characters in the redirect path and calculate
the current position from that. This works becuase only the prefix is
modified, the ending always stays the same.
Fixes: 02b69b284c
("ovl: lookup redirects")
Signed-off-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
410 lines
8.6 KiB
C
410 lines
8.6 KiB
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;
|
|
}
|