Merge branch 'overlayfs-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/vfs
Pull overlayfs updates from Miklos Szeredi: - Report constant st_ino values across copy-up even if underlying layers are on different filesystems, but using different st_dev values for each layer. Ideally we'd report the same st_dev across the overlay, and it's possible to do for filesystems that use only 32bits for st_ino by unifying the inum space. It would be nice if it wasn't a choice of 32 or 64, rather filesystems could report their current maximum (that could change on resize, so it wouldn't be set in stone). - miscellaneus fixes and a cleanup of ovl_fill_super(), that was long overdue. - created a path_put_init() helper that clears out the pointers after putting the ref. I think this could be useful elsewhere, so added it to <linux/path.h> * 'overlayfs-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/vfs: (30 commits) ovl: remove unneeded arg from ovl_verify_origin() ovl: Put upperdentry if ovl_check_origin() fails ovl: rename ufs to ofs ovl: clean up getting lower layers ovl: clean up workdir creation ovl: clean up getting upper layer ovl: move ovl_get_workdir() and ovl_get_lower_layers() ovl: reduce the number of arguments for ovl_workdir_create() ovl: change order of setup in ovl_fill_super() ovl: factor out ovl_free_fs() helper ovl: grab reference to workbasedir early ovl: split out ovl_get_indexdir() from ovl_fill_super() ovl: split out ovl_get_lower_layers() from ovl_fill_super() ovl: split out ovl_get_workdir() from ovl_fill_super() ovl: split out ovl_get_upper() from ovl_fill_super() ovl: split out ovl_get_lowerstack() from ovl_fill_super() ovl: split out ovl_get_workpath() from ovl_fill_super() ovl: split out ovl_get_upperpath() from ovl_fill_super() ovl: use path_put_init() in error paths for ovl_fill_super() vfs: add path_put_init() ...
This commit is contained in:
commit
b04a23421b
|
@ -22,7 +22,6 @@
|
|||
#include <linux/ratelimit.h>
|
||||
#include <linux/exportfs.h>
|
||||
#include "overlayfs.h"
|
||||
#include "ovl_entry.h"
|
||||
|
||||
#define OVL_COPY_UP_CHUNK_SIZE (1 << 20)
|
||||
|
||||
|
@ -486,6 +485,7 @@ static int ovl_copy_up_inode(struct ovl_copy_up_ctx *c, struct dentry *temp)
|
|||
static int ovl_copy_up_locked(struct ovl_copy_up_ctx *c)
|
||||
{
|
||||
struct inode *udir = c->destdir->d_inode;
|
||||
struct inode *inode;
|
||||
struct dentry *newdentry = NULL;
|
||||
struct dentry *temp = NULL;
|
||||
int err;
|
||||
|
@ -508,7 +508,11 @@ static int ovl_copy_up_locked(struct ovl_copy_up_ctx *c)
|
|||
if (err)
|
||||
goto out_cleanup;
|
||||
|
||||
ovl_inode_update(d_inode(c->dentry), newdentry);
|
||||
inode = d_inode(c->dentry);
|
||||
ovl_inode_update(inode, newdentry);
|
||||
if (S_ISDIR(inode->i_mode))
|
||||
ovl_set_flag(OVL_WHITEOUTS, inode);
|
||||
|
||||
out:
|
||||
dput(temp);
|
||||
return err;
|
||||
|
|
|
@ -181,6 +181,11 @@ static bool ovl_type_origin(struct dentry *dentry)
|
|||
return OVL_TYPE_ORIGIN(ovl_path_type(dentry));
|
||||
}
|
||||
|
||||
static bool ovl_may_have_whiteouts(struct dentry *dentry)
|
||||
{
|
||||
return ovl_test_flag(OVL_WHITEOUTS, d_inode(dentry));
|
||||
}
|
||||
|
||||
static int ovl_create_upper(struct dentry *dentry, struct inode *inode,
|
||||
struct cattr *attr, struct dentry *hardlink)
|
||||
{
|
||||
|
@ -300,7 +305,6 @@ static struct dentry *ovl_check_empty_and_clear(struct dentry *dentry)
|
|||
{
|
||||
int err;
|
||||
struct dentry *ret = NULL;
|
||||
enum ovl_path_type type = ovl_path_type(dentry);
|
||||
LIST_HEAD(list);
|
||||
|
||||
err = ovl_check_empty_dir(dentry, &list);
|
||||
|
@ -313,13 +317,13 @@ static struct dentry *ovl_check_empty_and_clear(struct dentry *dentry)
|
|||
* When removing an empty opaque directory, then it makes no sense to
|
||||
* replace it with an exact replica of itself.
|
||||
*
|
||||
* If no upperdentry then skip clearing whiteouts.
|
||||
* If upperdentry has whiteouts, clear them.
|
||||
*
|
||||
* Can race with copy-up, since we don't hold the upperdir mutex.
|
||||
* Doesn't matter, since copy-up can't create a non-empty directory
|
||||
* from an empty one.
|
||||
*/
|
||||
if (OVL_TYPE_UPPER(type) && OVL_TYPE_MERGE(type))
|
||||
if (!list_empty(&list))
|
||||
ret = ovl_clear_empty(dentry, &list);
|
||||
|
||||
out_free:
|
||||
|
@ -698,8 +702,9 @@ static int ovl_remove_upper(struct dentry *dentry, bool is_dir)
|
|||
struct dentry *opaquedir = NULL;
|
||||
int err;
|
||||
|
||||
/* Redirect dir can be !ovl_lower_positive && OVL_TYPE_MERGE */
|
||||
if (is_dir && ovl_dentry_get_redirect(dentry)) {
|
||||
/* Redirect/origin dir can be !ovl_lower_positive && not clean */
|
||||
if (is_dir && (ovl_dentry_get_redirect(dentry) ||
|
||||
ovl_may_have_whiteouts(dentry))) {
|
||||
opaquedir = ovl_check_empty_and_clear(dentry);
|
||||
err = PTR_ERR(opaquedir);
|
||||
if (IS_ERR(opaquedir))
|
||||
|
@ -946,7 +951,8 @@ static int ovl_rename(struct inode *olddir, struct dentry *old,
|
|||
|
||||
old_cred = ovl_override_creds(old->d_sb);
|
||||
|
||||
if (overwrite && new_is_dir && ovl_type_merge_or_lower(new)) {
|
||||
if (overwrite && new_is_dir && (ovl_type_merge_or_lower(new) ||
|
||||
ovl_may_have_whiteouts(new))) {
|
||||
opaquedir = ovl_check_empty_and_clear(new);
|
||||
err = PTR_ERR(opaquedir);
|
||||
if (IS_ERR(opaquedir)) {
|
||||
|
@ -1069,9 +1075,10 @@ static int ovl_rename(struct inode *olddir, struct dentry *old,
|
|||
drop_nlink(d_inode(new));
|
||||
}
|
||||
|
||||
ovl_dentry_version_inc(old->d_parent,
|
||||
!overwrite && ovl_type_origin(new));
|
||||
ovl_dentry_version_inc(new->d_parent, ovl_type_origin(old));
|
||||
ovl_dentry_version_inc(old->d_parent, ovl_type_origin(old) ||
|
||||
(!overwrite && ovl_type_origin(new)));
|
||||
ovl_dentry_version_inc(new->d_parent, ovl_type_origin(old) ||
|
||||
(d_inode(new) && ovl_type_origin(new)));
|
||||
|
||||
out_dput:
|
||||
dput(newdentry);
|
||||
|
|
|
@ -15,6 +15,14 @@
|
|||
#include <linux/ratelimit.h>
|
||||
#include "overlayfs.h"
|
||||
|
||||
|
||||
static dev_t ovl_get_pseudo_dev(struct dentry *dentry)
|
||||
{
|
||||
struct ovl_entry *oe = dentry->d_fsdata;
|
||||
|
||||
return oe->lowerstack[0].layer->pseudo_dev;
|
||||
}
|
||||
|
||||
int ovl_setattr(struct dentry *dentry, struct iattr *attr)
|
||||
{
|
||||
int err;
|
||||
|
@ -66,6 +74,7 @@ int ovl_getattr(const struct path *path, struct kstat *stat,
|
|||
struct path realpath;
|
||||
const struct cred *old_cred;
|
||||
bool is_dir = S_ISDIR(dentry->d_inode->i_mode);
|
||||
bool samefs = ovl_same_sb(dentry->d_sb);
|
||||
int err;
|
||||
|
||||
type = ovl_path_real(dentry, &realpath);
|
||||
|
@ -75,16 +84,13 @@ int ovl_getattr(const struct path *path, struct kstat *stat,
|
|||
goto out;
|
||||
|
||||
/*
|
||||
* When all layers are on the same fs, all real inode number are
|
||||
* unique, so we use the overlay st_dev, which is friendly to du -x.
|
||||
*
|
||||
* We also use st_ino of the copy up origin, if we know it.
|
||||
* This guaranties constant st_dev/st_ino across copy up.
|
||||
* For non-dir or same fs, we use st_ino of the copy up origin, if we
|
||||
* know it. This guaranties constant st_dev/st_ino across copy up.
|
||||
*
|
||||
* If filesystem supports NFS export ops, this also guaranties
|
||||
* persistent st_ino across mount cycle.
|
||||
*/
|
||||
if (ovl_same_sb(dentry->d_sb)) {
|
||||
if (!is_dir || samefs) {
|
||||
if (OVL_TYPE_ORIGIN(type)) {
|
||||
struct kstat lowerstat;
|
||||
u32 lowermask = STATX_INO | (!is_dir ? STATX_NLINK : 0);
|
||||
|
@ -95,7 +101,6 @@ int ovl_getattr(const struct path *path, struct kstat *stat,
|
|||
if (err)
|
||||
goto out;
|
||||
|
||||
WARN_ON_ONCE(stat->dev != lowerstat.dev);
|
||||
/*
|
||||
* Lower hardlinks may be broken on copy up to different
|
||||
* upper files, so we cannot use the lower origin st_ino
|
||||
|
@ -107,17 +112,36 @@ int ovl_getattr(const struct path *path, struct kstat *stat,
|
|||
if (is_dir || lowerstat.nlink == 1 ||
|
||||
ovl_test_flag(OVL_INDEX, d_inode(dentry)))
|
||||
stat->ino = lowerstat.ino;
|
||||
|
||||
if (samefs)
|
||||
WARN_ON_ONCE(stat->dev != lowerstat.dev);
|
||||
else
|
||||
stat->dev = ovl_get_pseudo_dev(dentry);
|
||||
}
|
||||
stat->dev = dentry->d_sb->s_dev;
|
||||
} else if (is_dir) {
|
||||
if (samefs) {
|
||||
/*
|
||||
* When all layers are on the same fs, all real inode
|
||||
* number are unique, so we use the overlay st_dev,
|
||||
* which is friendly to du -x.
|
||||
*/
|
||||
stat->dev = dentry->d_sb->s_dev;
|
||||
} else if (!OVL_TYPE_UPPER(type)) {
|
||||
/*
|
||||
* For non-samefs setup, to make sure that st_dev/st_ino
|
||||
* pair is unique across the system, we use a unique
|
||||
* anonymous st_dev for lower layer inode.
|
||||
*/
|
||||
stat->dev = ovl_get_pseudo_dev(dentry);
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
* If not all layers are on the same fs the pair {real st_ino;
|
||||
* overlay st_dev} is not unique, so use the non persistent
|
||||
* overlay st_ino.
|
||||
*
|
||||
* Always use the overlay st_dev for directories, so 'find
|
||||
* -xdev' will scan the entire overlay mount and won't cross the
|
||||
* overlay mount boundaries.
|
||||
*
|
||||
* If not all layers are on the same fs the pair {real st_ino;
|
||||
* overlay st_dev} is not unique, so use the non persistent
|
||||
* overlay st_ino for directories.
|
||||
*/
|
||||
stat->dev = dentry->d_sb->s_dev;
|
||||
stat->ino = dentry->d_inode->i_ino;
|
||||
|
@ -409,6 +433,7 @@ static inline void ovl_lockdep_annotate_inode_mutex_key(struct inode *inode)
|
|||
#ifdef CONFIG_LOCKDEP
|
||||
static struct lock_class_key ovl_i_mutex_key[OVL_MAX_NESTING];
|
||||
static struct lock_class_key ovl_i_mutex_dir_key[OVL_MAX_NESTING];
|
||||
static struct lock_class_key ovl_i_lock_key[OVL_MAX_NESTING];
|
||||
|
||||
int depth = inode->i_sb->s_stack_depth - 1;
|
||||
|
||||
|
@ -419,6 +444,8 @@ static inline void ovl_lockdep_annotate_inode_mutex_key(struct inode *inode)
|
|||
lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_dir_key[depth]);
|
||||
else
|
||||
lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_key[depth]);
|
||||
|
||||
lockdep_set_class(&OVL_I(inode)->lock, &ovl_i_lock_key[depth]);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -657,6 +684,16 @@ struct inode *ovl_get_inode(struct dentry *dentry, struct dentry *upperdentry,
|
|||
if (upperdentry && ovl_is_impuredir(upperdentry))
|
||||
ovl_set_flag(OVL_IMPURE, inode);
|
||||
|
||||
/* Check for non-merge dir that may have whiteouts */
|
||||
if (S_ISDIR(realinode->i_mode)) {
|
||||
struct ovl_entry *oe = dentry->d_fsdata;
|
||||
|
||||
if (((upperdentry && lowerdentry) || oe->numlower > 1) ||
|
||||
ovl_check_origin_xattr(upperdentry ?: lowerdentry)) {
|
||||
ovl_set_flag(OVL_WHITEOUTS, inode);
|
||||
}
|
||||
}
|
||||
|
||||
if (inode->i_state & I_NEW)
|
||||
unlock_new_inode(inode);
|
||||
out:
|
||||
|
|
|
@ -15,7 +15,6 @@
|
|||
#include <linux/mount.h>
|
||||
#include <linux/exportfs.h>
|
||||
#include "overlayfs.h"
|
||||
#include "ovl_entry.h"
|
||||
|
||||
struct ovl_lookup_data {
|
||||
struct qstr name;
|
||||
|
@ -286,16 +285,15 @@ static int ovl_lookup_layer(struct dentry *base, struct ovl_lookup_data *d,
|
|||
|
||||
|
||||
static int ovl_check_origin(struct dentry *upperdentry,
|
||||
struct path *lowerstack, unsigned int numlower,
|
||||
struct path **stackp, unsigned int *ctrp)
|
||||
struct ovl_path *lower, unsigned int numlower,
|
||||
struct ovl_path **stackp, unsigned int *ctrp)
|
||||
{
|
||||
struct vfsmount *mnt;
|
||||
struct dentry *origin = NULL;
|
||||
int i;
|
||||
|
||||
|
||||
for (i = 0; i < numlower; i++) {
|
||||
mnt = lowerstack[i].mnt;
|
||||
mnt = lower[i].layer->mnt;
|
||||
origin = ovl_get_origin(upperdentry, mnt);
|
||||
if (IS_ERR(origin))
|
||||
return PTR_ERR(origin);
|
||||
|
@ -309,12 +307,12 @@ static int ovl_check_origin(struct dentry *upperdentry,
|
|||
|
||||
BUG_ON(*ctrp);
|
||||
if (!*stackp)
|
||||
*stackp = kmalloc(sizeof(struct path), GFP_KERNEL);
|
||||
*stackp = kmalloc(sizeof(struct ovl_path), GFP_KERNEL);
|
||||
if (!*stackp) {
|
||||
dput(origin);
|
||||
return -ENOMEM;
|
||||
}
|
||||
**stackp = (struct path) { .dentry = origin, .mnt = mnt };
|
||||
**stackp = (struct ovl_path){.dentry = origin, .layer = lower[i].layer};
|
||||
*ctrp = 1;
|
||||
|
||||
return 0;
|
||||
|
@ -350,8 +348,8 @@ static int ovl_verify_origin_fh(struct dentry *dentry, const struct ovl_fh *fh)
|
|||
*
|
||||
* Return 0 on match, -ESTALE on mismatch, < 0 on error.
|
||||
*/
|
||||
int ovl_verify_origin(struct dentry *dentry, struct vfsmount *mnt,
|
||||
struct dentry *origin, bool is_upper, bool set)
|
||||
int ovl_verify_origin(struct dentry *dentry, struct dentry *origin,
|
||||
bool is_upper, bool set)
|
||||
{
|
||||
struct inode *inode;
|
||||
struct ovl_fh *fh;
|
||||
|
@ -384,13 +382,13 @@ fail:
|
|||
* OVL_XATTR_ORIGIN and that origin file handle can be decoded to lower path.
|
||||
* Return 0 on match, -ESTALE on mismatch or stale origin, < 0 on error.
|
||||
*/
|
||||
int ovl_verify_index(struct dentry *index, struct path *lowerstack,
|
||||
int ovl_verify_index(struct dentry *index, struct ovl_path *lower,
|
||||
unsigned int numlower)
|
||||
{
|
||||
struct ovl_fh *fh = NULL;
|
||||
size_t len;
|
||||
struct path origin = { };
|
||||
struct path *stack = &origin;
|
||||
struct ovl_path origin = { };
|
||||
struct ovl_path *stack = &origin;
|
||||
unsigned int ctr = 0;
|
||||
int err;
|
||||
|
||||
|
@ -429,7 +427,7 @@ int ovl_verify_index(struct dentry *index, struct path *lowerstack,
|
|||
if (err)
|
||||
goto fail;
|
||||
|
||||
err = ovl_check_origin(index, lowerstack, numlower, &stack, &ctr);
|
||||
err = ovl_check_origin(index, lower, numlower, &stack, &ctr);
|
||||
if (!err && !ctr)
|
||||
err = -ESTALE;
|
||||
if (err)
|
||||
|
@ -568,11 +566,24 @@ int ovl_path_next(int idx, struct dentry *dentry, struct path *path)
|
|||
idx++;
|
||||
}
|
||||
BUG_ON(idx > oe->numlower);
|
||||
*path = oe->lowerstack[idx - 1];
|
||||
path->dentry = oe->lowerstack[idx - 1].dentry;
|
||||
path->mnt = oe->lowerstack[idx - 1].layer->mnt;
|
||||
|
||||
return (idx < oe->numlower) ? idx + 1 : -1;
|
||||
}
|
||||
|
||||
static int ovl_find_layer(struct ovl_fs *ofs, struct ovl_path *path)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ofs->numlower; i++) {
|
||||
if (ofs->lower_layers[i].mnt == path->layer->mnt)
|
||||
break;
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
|
||||
unsigned int flags)
|
||||
{
|
||||
|
@ -581,7 +592,7 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
|
|||
struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
|
||||
struct ovl_entry *poe = dentry->d_parent->d_fsdata;
|
||||
struct ovl_entry *roe = dentry->d_sb->s_root->d_fsdata;
|
||||
struct path *stack = NULL;
|
||||
struct ovl_path *stack = NULL;
|
||||
struct dentry *upperdir, *upperdentry = NULL;
|
||||
struct dentry *index = NULL;
|
||||
unsigned int ctr = 0;
|
||||
|
@ -630,7 +641,7 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
|
|||
err = ovl_check_origin(upperdentry, roe->lowerstack,
|
||||
roe->numlower, &stack, &ctr);
|
||||
if (err)
|
||||
goto out;
|
||||
goto out_put_upper;
|
||||
}
|
||||
|
||||
if (d.redirect) {
|
||||
|
@ -646,17 +657,17 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
|
|||
|
||||
if (!d.stop && poe->numlower) {
|
||||
err = -ENOMEM;
|
||||
stack = kcalloc(ofs->numlower, sizeof(struct path),
|
||||
stack = kcalloc(ofs->numlower, sizeof(struct ovl_path),
|
||||
GFP_KERNEL);
|
||||
if (!stack)
|
||||
goto out_put_upper;
|
||||
}
|
||||
|
||||
for (i = 0; !d.stop && i < poe->numlower; i++) {
|
||||
struct path lowerpath = poe->lowerstack[i];
|
||||
struct ovl_path lower = poe->lowerstack[i];
|
||||
|
||||
d.last = i == poe->numlower - 1;
|
||||
err = ovl_lookup_layer(lowerpath.dentry, &d, &this);
|
||||
err = ovl_lookup_layer(lower.dentry, &d, &this);
|
||||
if (err)
|
||||
goto out_put;
|
||||
|
||||
|
@ -664,7 +675,7 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
|
|||
continue;
|
||||
|
||||
stack[ctr].dentry = this;
|
||||
stack[ctr].mnt = lowerpath.mnt;
|
||||
stack[ctr].layer = lower.layer;
|
||||
ctr++;
|
||||
|
||||
if (d.stop)
|
||||
|
@ -674,10 +685,8 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
|
|||
poe = roe;
|
||||
|
||||
/* 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))
|
||||
i = ovl_find_layer(ofs, &lower);
|
||||
if (WARN_ON(i == ofs->numlower))
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -700,7 +709,7 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
|
|||
goto out_put;
|
||||
|
||||
oe->opaque = upperopaque;
|
||||
memcpy(oe->lowerstack, stack, sizeof(struct path) * ctr);
|
||||
memcpy(oe->lowerstack, stack, sizeof(struct ovl_path) * ctr);
|
||||
dentry->d_fsdata = oe;
|
||||
|
||||
if (upperdentry)
|
||||
|
|
|
@ -9,6 +9,7 @@
|
|||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/uuid.h>
|
||||
#include "ovl_entry.h"
|
||||
|
||||
enum ovl_path_type {
|
||||
__OVL_PATH_UPPER = (1 << 0),
|
||||
|
@ -28,7 +29,10 @@ enum ovl_path_type {
|
|||
#define OVL_XATTR_NLINK OVL_XATTR_PREFIX "nlink"
|
||||
|
||||
enum ovl_flag {
|
||||
/* Pure upper dir that may contain non pure upper entries */
|
||||
OVL_IMPURE,
|
||||
/* Non-merge dir that may contain whiteout entries */
|
||||
OVL_WHITEOUTS,
|
||||
OVL_INDEX,
|
||||
};
|
||||
|
||||
|
@ -223,6 +227,7 @@ bool ovl_is_whiteout(struct dentry *dentry);
|
|||
struct file *ovl_path_open(struct path *path, int flags);
|
||||
int ovl_copy_up_start(struct dentry *dentry);
|
||||
void ovl_copy_up_end(struct dentry *dentry);
|
||||
bool ovl_check_origin_xattr(struct dentry *dentry);
|
||||
bool ovl_check_dir_xattr(struct dentry *dentry, const char *name);
|
||||
int ovl_check_setxattr(struct dentry *dentry, struct dentry *upperdentry,
|
||||
const char *name, const void *value, size_t size,
|
||||
|
@ -244,9 +249,9 @@ static inline bool ovl_is_impuredir(struct dentry *dentry)
|
|||
|
||||
|
||||
/* namei.c */
|
||||
int ovl_verify_origin(struct dentry *dentry, struct vfsmount *mnt,
|
||||
struct dentry *origin, bool is_upper, bool set);
|
||||
int ovl_verify_index(struct dentry *index, struct path *lowerstack,
|
||||
int ovl_verify_origin(struct dentry *dentry, struct dentry *origin,
|
||||
bool is_upper, bool set);
|
||||
int ovl_verify_index(struct dentry *index, struct ovl_path *lower,
|
||||
unsigned int numlower);
|
||||
int ovl_get_index_name(struct dentry *origin, struct qstr *name);
|
||||
int ovl_path_next(int idx, struct dentry *dentry, struct path *path);
|
||||
|
@ -263,7 +268,7 @@ int ovl_check_d_type_supported(struct path *realpath);
|
|||
void ovl_workdir_cleanup(struct inode *dir, struct vfsmount *mnt,
|
||||
struct dentry *dentry, int level);
|
||||
int ovl_indexdir_cleanup(struct dentry *dentry, struct vfsmount *mnt,
|
||||
struct path *lowerstack, unsigned int numlower);
|
||||
struct ovl_path *lower, unsigned int numlower);
|
||||
|
||||
/* inode.c */
|
||||
int ovl_set_nlink_upper(struct dentry *dentry);
|
||||
|
|
|
@ -17,11 +17,21 @@ struct ovl_config {
|
|||
bool index;
|
||||
};
|
||||
|
||||
struct ovl_layer {
|
||||
struct vfsmount *mnt;
|
||||
dev_t pseudo_dev;
|
||||
};
|
||||
|
||||
struct ovl_path {
|
||||
struct ovl_layer *layer;
|
||||
struct dentry *dentry;
|
||||
};
|
||||
|
||||
/* private information held for overlayfs's superblock */
|
||||
struct ovl_fs {
|
||||
struct vfsmount *upper_mnt;
|
||||
unsigned numlower;
|
||||
struct vfsmount **lower_mnt;
|
||||
struct ovl_layer *lower_layers;
|
||||
/* workbasedir is the path at workdir= mount option */
|
||||
struct dentry *workbasedir;
|
||||
/* workdir is the 'work' directory under workbasedir */
|
||||
|
@ -52,7 +62,7 @@ struct ovl_entry {
|
|||
struct rcu_head rcu;
|
||||
};
|
||||
unsigned numlower;
|
||||
struct path lowerstack[];
|
||||
struct ovl_path lowerstack[];
|
||||
};
|
||||
|
||||
struct ovl_entry *ovl_alloc_entry(unsigned int numlower);
|
||||
|
|
|
@ -26,6 +26,7 @@ struct ovl_cache_entry {
|
|||
struct list_head l_node;
|
||||
struct rb_node node;
|
||||
struct ovl_cache_entry *next_maybe_whiteout;
|
||||
bool is_upper;
|
||||
bool is_whiteout;
|
||||
char name[];
|
||||
};
|
||||
|
@ -158,6 +159,7 @@ static struct ovl_cache_entry *ovl_cache_entry_new(struct ovl_readdir_data *rdd,
|
|||
/* Defer setting d_ino for upper entry to ovl_iterate() */
|
||||
if (ovl_calc_d_ino(rdd, p))
|
||||
p->ino = 0;
|
||||
p->is_upper = rdd->is_upper;
|
||||
p->is_whiteout = false;
|
||||
|
||||
if (d_type == DT_CHR) {
|
||||
|
@ -316,22 +318,38 @@ static inline int ovl_dir_read(struct path *realpath,
|
|||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
* Can we iterate real dir directly?
|
||||
*
|
||||
* Non-merge dir may contain whiteouts from a time it was a merge upper, before
|
||||
* lower dir was removed under it and possibly before it was rotated from upper
|
||||
* to lower layer.
|
||||
*/
|
||||
static bool ovl_dir_is_real(struct dentry *dir)
|
||||
{
|
||||
return !ovl_test_flag(OVL_WHITEOUTS, d_inode(dir));
|
||||
}
|
||||
|
||||
static void ovl_dir_reset(struct file *file)
|
||||
{
|
||||
struct ovl_dir_file *od = file->private_data;
|
||||
struct ovl_dir_cache *cache = od->cache;
|
||||
struct dentry *dentry = file->f_path.dentry;
|
||||
enum ovl_path_type type = ovl_path_type(dentry);
|
||||
bool is_real;
|
||||
|
||||
if (cache && ovl_dentry_version_get(dentry) != cache->version) {
|
||||
ovl_cache_put(od, dentry);
|
||||
od->cache = NULL;
|
||||
od->cursor = NULL;
|
||||
}
|
||||
WARN_ON(!od->is_real && !OVL_TYPE_MERGE(type));
|
||||
if (od->is_real && OVL_TYPE_MERGE(type))
|
||||
is_real = ovl_dir_is_real(dentry);
|
||||
if (od->is_real != is_real) {
|
||||
/* is_real can only become false when dir is copied up */
|
||||
if (WARN_ON(is_real))
|
||||
return;
|
||||
od->is_real = false;
|
||||
}
|
||||
}
|
||||
|
||||
static int ovl_dir_read_merged(struct dentry *dentry, struct list_head *list,
|
||||
struct rb_root *root)
|
||||
|
@ -816,7 +834,7 @@ static int ovl_dir_open(struct inode *inode, struct file *file)
|
|||
return PTR_ERR(realfile);
|
||||
}
|
||||
od->realfile = realfile;
|
||||
od->is_real = !OVL_TYPE_MERGE(type);
|
||||
od->is_real = ovl_dir_is_real(file->f_path.dentry);
|
||||
od->is_upper = OVL_TYPE_UPPER(type);
|
||||
file->private_data = od;
|
||||
|
||||
|
@ -835,7 +853,7 @@ const struct file_operations ovl_dir_operations = {
|
|||
int ovl_check_empty_dir(struct dentry *dentry, struct list_head *list)
|
||||
{
|
||||
int err;
|
||||
struct ovl_cache_entry *p;
|
||||
struct ovl_cache_entry *p, *n;
|
||||
struct rb_root root = RB_ROOT;
|
||||
|
||||
err = ovl_dir_read_merged(dentry, list, &root);
|
||||
|
@ -844,18 +862,29 @@ int ovl_check_empty_dir(struct dentry *dentry, struct list_head *list)
|
|||
|
||||
err = 0;
|
||||
|
||||
list_for_each_entry(p, list, l_node) {
|
||||
if (p->is_whiteout)
|
||||
list_for_each_entry_safe(p, n, list, l_node) {
|
||||
/*
|
||||
* Select whiteouts in upperdir, they should
|
||||
* be cleared when deleting this directory.
|
||||
*/
|
||||
if (p->is_whiteout) {
|
||||
if (p->is_upper)
|
||||
continue;
|
||||
goto del_entry;
|
||||
}
|
||||
|
||||
if (p->name[0] == '.') {
|
||||
if (p->len == 1)
|
||||
continue;
|
||||
goto del_entry;
|
||||
if (p->len == 2 && p->name[1] == '.')
|
||||
continue;
|
||||
goto del_entry;
|
||||
}
|
||||
err = -ENOTEMPTY;
|
||||
break;
|
||||
|
||||
del_entry:
|
||||
list_del(&p->l_node);
|
||||
kfree(p);
|
||||
}
|
||||
|
||||
return err;
|
||||
|
@ -869,7 +898,7 @@ void ovl_cleanup_whiteouts(struct dentry *upper, struct list_head *list)
|
|||
list_for_each_entry(p, list, l_node) {
|
||||
struct dentry *dentry;
|
||||
|
||||
if (!p->is_whiteout)
|
||||
if (WARN_ON(!p->is_whiteout || !p->is_upper))
|
||||
continue;
|
||||
|
||||
dentry = lookup_one_len(p->name, upper, p->len);
|
||||
|
@ -985,7 +1014,7 @@ void ovl_workdir_cleanup(struct inode *dir, struct vfsmount *mnt,
|
|||
}
|
||||
|
||||
int ovl_indexdir_cleanup(struct dentry *dentry, struct vfsmount *mnt,
|
||||
struct path *lowerstack, unsigned int numlower)
|
||||
struct ovl_path *lower, unsigned int numlower)
|
||||
{
|
||||
int err;
|
||||
struct dentry *index = NULL;
|
||||
|
@ -1020,7 +1049,7 @@ int ovl_indexdir_cleanup(struct dentry *dentry, struct vfsmount *mnt,
|
|||
index = NULL;
|
||||
break;
|
||||
}
|
||||
err = ovl_verify_index(index, lowerstack, numlower);
|
||||
err = ovl_verify_index(index, lower, numlower);
|
||||
/* Cleanup stale and orphan index entries */
|
||||
if (err && (err == -ESTALE || err == -ENOENT))
|
||||
err = ovl_cleanup(dir, index);
|
||||
|
|
|
@ -18,7 +18,6 @@
|
|||
#include <linux/seq_file.h>
|
||||
#include <linux/posix_acl_xattr.h>
|
||||
#include "overlayfs.h"
|
||||
#include "ovl_entry.h"
|
||||
|
||||
MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
|
||||
MODULE_DESCRIPTION("Overlay filesystem");
|
||||
|
@ -39,15 +38,20 @@ module_param_named(index, ovl_index_def, bool, 0644);
|
|||
MODULE_PARM_DESC(ovl_index_def,
|
||||
"Default to on or off for the inodes index feature");
|
||||
|
||||
static void ovl_entry_stack_free(struct ovl_entry *oe)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < oe->numlower; i++)
|
||||
dput(oe->lowerstack[i].dentry);
|
||||
}
|
||||
|
||||
static void ovl_dentry_release(struct dentry *dentry)
|
||||
{
|
||||
struct ovl_entry *oe = dentry->d_fsdata;
|
||||
|
||||
if (oe) {
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < oe->numlower; i++)
|
||||
dput(oe->lowerstack[i].dentry);
|
||||
ovl_entry_stack_free(oe);
|
||||
kfree_rcu(oe, rcu);
|
||||
}
|
||||
}
|
||||
|
@ -207,39 +211,48 @@ static void ovl_destroy_inode(struct inode *inode)
|
|||
call_rcu(&inode->i_rcu, ovl_i_callback);
|
||||
}
|
||||
|
||||
static void ovl_put_super(struct super_block *sb)
|
||||
static void ovl_free_fs(struct ovl_fs *ofs)
|
||||
{
|
||||
struct ovl_fs *ufs = sb->s_fs_info;
|
||||
unsigned i;
|
||||
|
||||
dput(ufs->indexdir);
|
||||
dput(ufs->workdir);
|
||||
if (ufs->workdir_locked)
|
||||
ovl_inuse_unlock(ufs->workbasedir);
|
||||
dput(ufs->workbasedir);
|
||||
if (ufs->upper_mnt && ufs->upperdir_locked)
|
||||
ovl_inuse_unlock(ufs->upper_mnt->mnt_root);
|
||||
mntput(ufs->upper_mnt);
|
||||
for (i = 0; i < ufs->numlower; i++)
|
||||
mntput(ufs->lower_mnt[i]);
|
||||
kfree(ufs->lower_mnt);
|
||||
dput(ofs->indexdir);
|
||||
dput(ofs->workdir);
|
||||
if (ofs->workdir_locked)
|
||||
ovl_inuse_unlock(ofs->workbasedir);
|
||||
dput(ofs->workbasedir);
|
||||
if (ofs->upperdir_locked)
|
||||
ovl_inuse_unlock(ofs->upper_mnt->mnt_root);
|
||||
mntput(ofs->upper_mnt);
|
||||
for (i = 0; i < ofs->numlower; i++) {
|
||||
mntput(ofs->lower_layers[i].mnt);
|
||||
free_anon_bdev(ofs->lower_layers[i].pseudo_dev);
|
||||
}
|
||||
kfree(ofs->lower_layers);
|
||||
|
||||
kfree(ufs->config.lowerdir);
|
||||
kfree(ufs->config.upperdir);
|
||||
kfree(ufs->config.workdir);
|
||||
put_cred(ufs->creator_cred);
|
||||
kfree(ufs);
|
||||
kfree(ofs->config.lowerdir);
|
||||
kfree(ofs->config.upperdir);
|
||||
kfree(ofs->config.workdir);
|
||||
if (ofs->creator_cred)
|
||||
put_cred(ofs->creator_cred);
|
||||
kfree(ofs);
|
||||
}
|
||||
|
||||
static void ovl_put_super(struct super_block *sb)
|
||||
{
|
||||
struct ovl_fs *ofs = sb->s_fs_info;
|
||||
|
||||
ovl_free_fs(ofs);
|
||||
}
|
||||
|
||||
static int ovl_sync_fs(struct super_block *sb, int wait)
|
||||
{
|
||||
struct ovl_fs *ufs = sb->s_fs_info;
|
||||
struct ovl_fs *ofs = sb->s_fs_info;
|
||||
struct super_block *upper_sb;
|
||||
int ret;
|
||||
|
||||
if (!ufs->upper_mnt)
|
||||
if (!ofs->upper_mnt)
|
||||
return 0;
|
||||
upper_sb = ufs->upper_mnt->mnt_sb;
|
||||
upper_sb = ofs->upper_mnt->mnt_sb;
|
||||
if (!upper_sb->s_op->sync_fs)
|
||||
return 0;
|
||||
|
||||
|
@ -277,9 +290,9 @@ static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf)
|
|||
}
|
||||
|
||||
/* Will this overlay be forced to mount/remount ro? */
|
||||
static bool ovl_force_readonly(struct ovl_fs *ufs)
|
||||
static bool ovl_force_readonly(struct ovl_fs *ofs)
|
||||
{
|
||||
return (!ufs->upper_mnt || !ufs->workdir);
|
||||
return (!ofs->upper_mnt || !ofs->workdir);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -291,29 +304,29 @@ static bool ovl_force_readonly(struct ovl_fs *ufs)
|
|||
static int ovl_show_options(struct seq_file *m, struct dentry *dentry)
|
||||
{
|
||||
struct super_block *sb = dentry->d_sb;
|
||||
struct ovl_fs *ufs = sb->s_fs_info;
|
||||
struct ovl_fs *ofs = sb->s_fs_info;
|
||||
|
||||
seq_show_option(m, "lowerdir", ufs->config.lowerdir);
|
||||
if (ufs->config.upperdir) {
|
||||
seq_show_option(m, "upperdir", ufs->config.upperdir);
|
||||
seq_show_option(m, "workdir", ufs->config.workdir);
|
||||
seq_show_option(m, "lowerdir", ofs->config.lowerdir);
|
||||
if (ofs->config.upperdir) {
|
||||
seq_show_option(m, "upperdir", ofs->config.upperdir);
|
||||
seq_show_option(m, "workdir", ofs->config.workdir);
|
||||
}
|
||||
if (ufs->config.default_permissions)
|
||||
if (ofs->config.default_permissions)
|
||||
seq_puts(m, ",default_permissions");
|
||||
if (ufs->config.redirect_dir != ovl_redirect_dir_def)
|
||||
if (ofs->config.redirect_dir != ovl_redirect_dir_def)
|
||||
seq_printf(m, ",redirect_dir=%s",
|
||||
ufs->config.redirect_dir ? "on" : "off");
|
||||
if (ufs->config.index != ovl_index_def)
|
||||
ofs->config.redirect_dir ? "on" : "off");
|
||||
if (ofs->config.index != ovl_index_def)
|
||||
seq_printf(m, ",index=%s",
|
||||
ufs->config.index ? "on" : "off");
|
||||
ofs->config.index ? "on" : "off");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ovl_remount(struct super_block *sb, int *flags, char *data)
|
||||
{
|
||||
struct ovl_fs *ufs = sb->s_fs_info;
|
||||
struct ovl_fs *ofs = sb->s_fs_info;
|
||||
|
||||
if (!(*flags & MS_RDONLY) && ovl_force_readonly(ufs))
|
||||
if (!(*flags & MS_RDONLY) && ovl_force_readonly(ofs))
|
||||
return -EROFS;
|
||||
|
||||
return 0;
|
||||
|
@ -451,13 +464,11 @@ static int ovl_parse_opt(char *opt, struct ovl_config *config)
|
|||
#define OVL_WORKDIR_NAME "work"
|
||||
#define OVL_INDEXDIR_NAME "index"
|
||||
|
||||
static struct dentry *ovl_workdir_create(struct super_block *sb,
|
||||
struct ovl_fs *ufs,
|
||||
struct dentry *dentry,
|
||||
static struct dentry *ovl_workdir_create(struct ovl_fs *ofs,
|
||||
const char *name, bool persist)
|
||||
{
|
||||
struct inode *dir = dentry->d_inode;
|
||||
struct vfsmount *mnt = ufs->upper_mnt;
|
||||
struct inode *dir = ofs->workbasedir->d_inode;
|
||||
struct vfsmount *mnt = ofs->upper_mnt;
|
||||
struct dentry *work;
|
||||
int err;
|
||||
bool retried = false;
|
||||
|
@ -471,7 +482,7 @@ static struct dentry *ovl_workdir_create(struct super_block *sb,
|
|||
locked = true;
|
||||
|
||||
retry:
|
||||
work = lookup_one_len(name, dentry, strlen(name));
|
||||
work = lookup_one_len(name, ofs->workbasedir, strlen(name));
|
||||
|
||||
if (!IS_ERR(work)) {
|
||||
struct iattr attr = {
|
||||
|
@ -541,8 +552,7 @@ out_dput:
|
|||
dput(work);
|
||||
out_err:
|
||||
pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n",
|
||||
ufs->config.workdir, name, -err);
|
||||
sb->s_flags |= MS_RDONLY;
|
||||
ofs->config.workdir, name, -err);
|
||||
work = NULL;
|
||||
goto out_unlock;
|
||||
}
|
||||
|
@ -585,7 +595,7 @@ static int ovl_mount_dir_noesc(const char *name, struct path *path)
|
|||
return 0;
|
||||
|
||||
out_put:
|
||||
path_put(path);
|
||||
path_put_init(path);
|
||||
out:
|
||||
return err;
|
||||
}
|
||||
|
@ -603,7 +613,7 @@ static int ovl_mount_dir(const char *name, struct path *path)
|
|||
if (ovl_dentry_remote(path->dentry)) {
|
||||
pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n",
|
||||
tmp);
|
||||
path_put(path);
|
||||
path_put_init(path);
|
||||
err = -EINVAL;
|
||||
}
|
||||
kfree(tmp);
|
||||
|
@ -655,7 +665,7 @@ static int ovl_lower_dir(const char *name, struct path *path,
|
|||
return 0;
|
||||
|
||||
out_put:
|
||||
path_put(path);
|
||||
path_put_init(path);
|
||||
out:
|
||||
return err;
|
||||
}
|
||||
|
@ -826,129 +836,269 @@ static const struct xattr_handler *ovl_xattr_handlers[] = {
|
|||
NULL
|
||||
};
|
||||
|
||||
static int ovl_fill_super(struct super_block *sb, void *data, int silent)
|
||||
static int ovl_get_upper(struct ovl_fs *ofs, struct path *upperpath)
|
||||
{
|
||||
struct path upperpath = { };
|
||||
struct path workpath = { };
|
||||
struct dentry *root_dentry;
|
||||
struct ovl_entry *oe;
|
||||
struct ovl_fs *ufs;
|
||||
struct path *stack = NULL;
|
||||
char *lowertmp;
|
||||
char *lower;
|
||||
unsigned int numlower;
|
||||
unsigned int stacklen = 0;
|
||||
unsigned int i;
|
||||
bool remote = false;
|
||||
struct cred *cred;
|
||||
struct vfsmount *upper_mnt;
|
||||
int err;
|
||||
|
||||
err = -ENOMEM;
|
||||
ufs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL);
|
||||
if (!ufs)
|
||||
err = ovl_mount_dir(ofs->config.upperdir, upperpath);
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
ufs->config.redirect_dir = ovl_redirect_dir_def;
|
||||
ufs->config.index = ovl_index_def;
|
||||
err = ovl_parse_opt((char *) data, &ufs->config);
|
||||
if (err)
|
||||
goto out_free_config;
|
||||
|
||||
err = -EINVAL;
|
||||
if (!ufs->config.lowerdir) {
|
||||
if (!silent)
|
||||
pr_err("overlayfs: missing 'lowerdir'\n");
|
||||
goto out_free_config;
|
||||
}
|
||||
|
||||
sb->s_stack_depth = 0;
|
||||
sb->s_maxbytes = MAX_LFS_FILESIZE;
|
||||
if (ufs->config.upperdir) {
|
||||
if (!ufs->config.workdir) {
|
||||
pr_err("overlayfs: missing 'workdir'\n");
|
||||
goto out_free_config;
|
||||
}
|
||||
|
||||
err = ovl_mount_dir(ufs->config.upperdir, &upperpath);
|
||||
if (err)
|
||||
goto out_free_config;
|
||||
|
||||
/* Upper fs should not be r/o */
|
||||
if (sb_rdonly(upperpath.mnt->mnt_sb)) {
|
||||
if (sb_rdonly(upperpath->mnt->mnt_sb)) {
|
||||
pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n");
|
||||
err = -EINVAL;
|
||||
goto out_put_upperpath;
|
||||
goto out;
|
||||
}
|
||||
|
||||
err = ovl_check_namelen(&upperpath, ufs, ufs->config.upperdir);
|
||||
err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir);
|
||||
if (err)
|
||||
goto out_put_upperpath;
|
||||
goto out;
|
||||
|
||||
err = -EBUSY;
|
||||
if (ovl_inuse_trylock(upperpath.dentry)) {
|
||||
ufs->upperdir_locked = true;
|
||||
} else if (ufs->config.index) {
|
||||
if (ovl_inuse_trylock(upperpath->dentry)) {
|
||||
ofs->upperdir_locked = true;
|
||||
} else if (ofs->config.index) {
|
||||
pr_err("overlayfs: upperdir is in-use by another mount, mount with '-o index=off' to override exclusive upperdir protection.\n");
|
||||
goto out_put_upperpath;
|
||||
goto out;
|
||||
} else {
|
||||
pr_warn("overlayfs: upperdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n");
|
||||
}
|
||||
|
||||
err = ovl_mount_dir(ufs->config.workdir, &workpath);
|
||||
upper_mnt = clone_private_mount(upperpath);
|
||||
err = PTR_ERR(upper_mnt);
|
||||
if (IS_ERR(upper_mnt)) {
|
||||
pr_err("overlayfs: failed to clone upperpath\n");
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* Don't inherit atime flags */
|
||||
upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME);
|
||||
ofs->upper_mnt = upper_mnt;
|
||||
err = 0;
|
||||
out:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int ovl_make_workdir(struct ovl_fs *ofs, struct path *workpath)
|
||||
{
|
||||
struct dentry *temp;
|
||||
int err;
|
||||
|
||||
ofs->workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false);
|
||||
if (!ofs->workdir)
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* Upper should support d_type, else whiteouts are visible. Given
|
||||
* workdir and upper are on same fs, we can do iterate_dir() on
|
||||
* workdir. This check requires successful creation of workdir in
|
||||
* previous step.
|
||||
*/
|
||||
err = ovl_check_d_type_supported(workpath);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
/*
|
||||
* We allowed this configuration and don't want to break users over
|
||||
* kernel upgrade. So warn instead of erroring out.
|
||||
*/
|
||||
if (!err)
|
||||
pr_warn("overlayfs: upper fs needs to support d_type.\n");
|
||||
|
||||
/* Check if upper/work fs supports O_TMPFILE */
|
||||
temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0);
|
||||
ofs->tmpfile = !IS_ERR(temp);
|
||||
if (ofs->tmpfile)
|
||||
dput(temp);
|
||||
else
|
||||
pr_warn("overlayfs: upper fs does not support tmpfile.\n");
|
||||
|
||||
/*
|
||||
* Check if upper/work fs supports trusted.overlay.* xattr
|
||||
*/
|
||||
err = ovl_do_setxattr(ofs->workdir, OVL_XATTR_OPAQUE, "0", 1, 0);
|
||||
if (err) {
|
||||
ofs->noxattr = true;
|
||||
pr_warn("overlayfs: upper fs does not support xattr.\n");
|
||||
} else {
|
||||
vfs_removexattr(ofs->workdir, OVL_XATTR_OPAQUE);
|
||||
}
|
||||
|
||||
/* Check if upper/work fs supports file handles */
|
||||
if (ofs->config.index &&
|
||||
!ovl_can_decode_fh(ofs->workdir->d_sb)) {
|
||||
ofs->config.index = false;
|
||||
pr_warn("overlayfs: upper fs does not support file handles, falling back to index=off.\n");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ovl_get_workdir(struct ovl_fs *ofs, struct path *upperpath)
|
||||
{
|
||||
int err;
|
||||
struct path workpath = { };
|
||||
|
||||
err = ovl_mount_dir(ofs->config.workdir, &workpath);
|
||||
if (err)
|
||||
goto out_unlock_upperdentry;
|
||||
goto out;
|
||||
|
||||
err = -EINVAL;
|
||||
if (upperpath.mnt != workpath.mnt) {
|
||||
if (upperpath->mnt != workpath.mnt) {
|
||||
pr_err("overlayfs: workdir and upperdir must reside under the same mount\n");
|
||||
goto out_put_workpath;
|
||||
goto out;
|
||||
}
|
||||
if (!ovl_workdir_ok(workpath.dentry, upperpath.dentry)) {
|
||||
if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) {
|
||||
pr_err("overlayfs: workdir and upperdir must be separate subtrees\n");
|
||||
goto out_put_workpath;
|
||||
goto out;
|
||||
}
|
||||
|
||||
err = -EBUSY;
|
||||
if (ovl_inuse_trylock(workpath.dentry)) {
|
||||
ufs->workdir_locked = true;
|
||||
} else if (ufs->config.index) {
|
||||
ofs->workdir_locked = true;
|
||||
} else if (ofs->config.index) {
|
||||
pr_err("overlayfs: workdir is in-use by another mount, mount with '-o index=off' to override exclusive workdir protection.\n");
|
||||
goto out_put_workpath;
|
||||
goto out;
|
||||
} else {
|
||||
pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n");
|
||||
}
|
||||
|
||||
ufs->workbasedir = workpath.dentry;
|
||||
sb->s_stack_depth = upperpath.mnt->mnt_sb->s_stack_depth;
|
||||
ofs->workbasedir = dget(workpath.dentry);
|
||||
err = ovl_make_workdir(ofs, &workpath);
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
err = 0;
|
||||
out:
|
||||
path_put(&workpath);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int ovl_get_indexdir(struct ovl_fs *ofs, struct ovl_entry *oe,
|
||||
struct path *upperpath)
|
||||
{
|
||||
int err;
|
||||
|
||||
/* Verify lower root is upper root origin */
|
||||
err = ovl_verify_origin(upperpath->dentry, oe->lowerstack[0].dentry,
|
||||
false, true);
|
||||
if (err) {
|
||||
pr_err("overlayfs: failed to verify upper root origin\n");
|
||||
goto out;
|
||||
}
|
||||
|
||||
ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true);
|
||||
if (ofs->indexdir) {
|
||||
/* Verify upper root is index dir origin */
|
||||
err = ovl_verify_origin(ofs->indexdir, upperpath->dentry,
|
||||
true, true);
|
||||
if (err)
|
||||
pr_err("overlayfs: failed to verify index dir origin\n");
|
||||
|
||||
/* Cleanup bad/stale/orphan index entries */
|
||||
if (!err)
|
||||
err = ovl_indexdir_cleanup(ofs->indexdir,
|
||||
ofs->upper_mnt,
|
||||
oe->lowerstack,
|
||||
oe->numlower);
|
||||
}
|
||||
if (err || !ofs->indexdir)
|
||||
pr_warn("overlayfs: try deleting index dir or mounting with '-o index=off' to disable inodes index.\n");
|
||||
|
||||
out:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int ovl_get_lower_layers(struct ovl_fs *ofs, struct path *stack,
|
||||
unsigned int numlower)
|
||||
{
|
||||
int err;
|
||||
unsigned int i;
|
||||
|
||||
err = -ENOMEM;
|
||||
lowertmp = kstrdup(ufs->config.lowerdir, GFP_KERNEL);
|
||||
ofs->lower_layers = kcalloc(numlower, sizeof(struct ovl_layer),
|
||||
GFP_KERNEL);
|
||||
if (ofs->lower_layers == NULL)
|
||||
goto out;
|
||||
for (i = 0; i < numlower; i++) {
|
||||
struct vfsmount *mnt;
|
||||
dev_t dev;
|
||||
|
||||
err = get_anon_bdev(&dev);
|
||||
if (err) {
|
||||
pr_err("overlayfs: failed to get anonymous bdev for lowerpath\n");
|
||||
goto out;
|
||||
}
|
||||
|
||||
mnt = clone_private_mount(&stack[i]);
|
||||
err = PTR_ERR(mnt);
|
||||
if (IS_ERR(mnt)) {
|
||||
pr_err("overlayfs: failed to clone lowerpath\n");
|
||||
free_anon_bdev(dev);
|
||||
goto out;
|
||||
}
|
||||
/*
|
||||
* Make lower layers R/O. That way fchmod/fchown on lower file
|
||||
* will fail instead of modifying lower fs.
|
||||
*/
|
||||
mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME;
|
||||
|
||||
ofs->lower_layers[ofs->numlower].mnt = mnt;
|
||||
ofs->lower_layers[ofs->numlower].pseudo_dev = dev;
|
||||
ofs->numlower++;
|
||||
|
||||
/* Check if all lower layers are on same sb */
|
||||
if (i == 0)
|
||||
ofs->same_sb = mnt->mnt_sb;
|
||||
else if (ofs->same_sb != mnt->mnt_sb)
|
||||
ofs->same_sb = NULL;
|
||||
}
|
||||
err = 0;
|
||||
out:
|
||||
return err;
|
||||
}
|
||||
|
||||
static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb,
|
||||
struct ovl_fs *ofs)
|
||||
{
|
||||
int err;
|
||||
char *lowertmp, *lower;
|
||||
struct path *stack = NULL;
|
||||
unsigned int stacklen, numlower = 0, i;
|
||||
bool remote = false;
|
||||
struct ovl_entry *oe;
|
||||
|
||||
err = -ENOMEM;
|
||||
lowertmp = kstrdup(ofs->config.lowerdir, GFP_KERNEL);
|
||||
if (!lowertmp)
|
||||
goto out_unlock_workdentry;
|
||||
goto out_err;
|
||||
|
||||
err = -EINVAL;
|
||||
stacklen = ovl_split_lowerdirs(lowertmp);
|
||||
if (stacklen > OVL_MAX_STACK) {
|
||||
pr_err("overlayfs: too many lower directories, limit is %d\n",
|
||||
OVL_MAX_STACK);
|
||||
goto out_free_lowertmp;
|
||||
} else if (!ufs->config.upperdir && stacklen == 1) {
|
||||
goto out_err;
|
||||
} else if (!ofs->config.upperdir && stacklen == 1) {
|
||||
pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n");
|
||||
goto out_free_lowertmp;
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
err = -ENOMEM;
|
||||
stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL);
|
||||
if (!stack)
|
||||
goto out_free_lowertmp;
|
||||
goto out_err;
|
||||
|
||||
err = -EINVAL;
|
||||
lower = lowertmp;
|
||||
for (numlower = 0; numlower < stacklen; numlower++) {
|
||||
err = ovl_lower_dir(lower, &stack[numlower], ufs,
|
||||
err = ovl_lower_dir(lower, &stack[numlower], ofs,
|
||||
&sb->s_stack_depth, &remote);
|
||||
if (err)
|
||||
goto out_put_lowerpath;
|
||||
goto out_err;
|
||||
|
||||
lower = strchr(lower, '\0') + 1;
|
||||
}
|
||||
|
@ -957,190 +1107,144 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent)
|
|||
sb->s_stack_depth++;
|
||||
if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
|
||||
pr_err("overlayfs: maximum fs stacking depth exceeded\n");
|
||||
goto out_put_lowerpath;
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
if (ufs->config.upperdir) {
|
||||
ufs->upper_mnt = clone_private_mount(&upperpath);
|
||||
err = PTR_ERR(ufs->upper_mnt);
|
||||
if (IS_ERR(ufs->upper_mnt)) {
|
||||
pr_err("overlayfs: failed to clone upperpath\n");
|
||||
goto out_put_lowerpath;
|
||||
}
|
||||
|
||||
/* Don't inherit atime flags */
|
||||
ufs->upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME);
|
||||
|
||||
sb->s_time_gran = ufs->upper_mnt->mnt_sb->s_time_gran;
|
||||
|
||||
ufs->workdir = ovl_workdir_create(sb, ufs, workpath.dentry,
|
||||
OVL_WORKDIR_NAME, false);
|
||||
/*
|
||||
* Upper should support d_type, else whiteouts are visible.
|
||||
* Given workdir and upper are on same fs, we can do
|
||||
* iterate_dir() on workdir. This check requires successful
|
||||
* creation of workdir in previous step.
|
||||
*/
|
||||
if (ufs->workdir) {
|
||||
struct dentry *temp;
|
||||
|
||||
err = ovl_check_d_type_supported(&workpath);
|
||||
if (err < 0)
|
||||
goto out_put_workdir;
|
||||
|
||||
/*
|
||||
* We allowed this configuration and don't want to
|
||||
* break users over kernel upgrade. So warn instead
|
||||
* of erroring out.
|
||||
*/
|
||||
if (!err)
|
||||
pr_warn("overlayfs: upper fs needs to support d_type.\n");
|
||||
|
||||
/* Check if upper/work fs supports O_TMPFILE */
|
||||
temp = ovl_do_tmpfile(ufs->workdir, S_IFREG | 0);
|
||||
ufs->tmpfile = !IS_ERR(temp);
|
||||
if (ufs->tmpfile)
|
||||
dput(temp);
|
||||
else
|
||||
pr_warn("overlayfs: upper fs does not support tmpfile.\n");
|
||||
|
||||
/*
|
||||
* Check if upper/work fs supports trusted.overlay.*
|
||||
* xattr
|
||||
*/
|
||||
err = ovl_do_setxattr(ufs->workdir, OVL_XATTR_OPAQUE,
|
||||
"0", 1, 0);
|
||||
if (err) {
|
||||
ufs->noxattr = true;
|
||||
pr_warn("overlayfs: upper fs does not support xattr.\n");
|
||||
} else {
|
||||
vfs_removexattr(ufs->workdir, OVL_XATTR_OPAQUE);
|
||||
}
|
||||
|
||||
/* Check if upper/work fs supports file handles */
|
||||
if (ufs->config.index &&
|
||||
!ovl_can_decode_fh(ufs->workdir->d_sb)) {
|
||||
ufs->config.index = false;
|
||||
pr_warn("overlayfs: upper fs does not support file handles, falling back to index=off.\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
err = ovl_get_lower_layers(ofs, stack, numlower);
|
||||
if (err)
|
||||
goto out_err;
|
||||
|
||||
err = -ENOMEM;
|
||||
ufs->lower_mnt = kcalloc(numlower, sizeof(struct vfsmount *), GFP_KERNEL);
|
||||
if (ufs->lower_mnt == NULL)
|
||||
goto out_put_workdir;
|
||||
oe = ovl_alloc_entry(numlower);
|
||||
if (!oe)
|
||||
goto out_err;
|
||||
|
||||
for (i = 0; i < numlower; i++) {
|
||||
struct vfsmount *mnt = clone_private_mount(&stack[i]);
|
||||
|
||||
err = PTR_ERR(mnt);
|
||||
if (IS_ERR(mnt)) {
|
||||
pr_err("overlayfs: failed to clone lowerpath\n");
|
||||
goto out_put_lower_mnt;
|
||||
oe->lowerstack[i].dentry = dget(stack[i].dentry);
|
||||
oe->lowerstack[i].layer = &ofs->lower_layers[i];
|
||||
}
|
||||
/*
|
||||
* Make lower_mnt R/O. That way fchmod/fchown on lower file
|
||||
* will fail instead of modifying lower fs.
|
||||
*/
|
||||
mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME;
|
||||
|
||||
ufs->lower_mnt[ufs->numlower] = mnt;
|
||||
ufs->numlower++;
|
||||
|
||||
/* Check if all lower layers are on same sb */
|
||||
if (i == 0)
|
||||
ufs->same_sb = mnt->mnt_sb;
|
||||
else if (ufs->same_sb != mnt->mnt_sb)
|
||||
ufs->same_sb = NULL;
|
||||
}
|
||||
|
||||
/* If the upper fs is nonexistent, we mark overlayfs r/o too */
|
||||
if (!ufs->upper_mnt)
|
||||
sb->s_flags |= MS_RDONLY;
|
||||
else if (ufs->upper_mnt->mnt_sb != ufs->same_sb)
|
||||
ufs->same_sb = NULL;
|
||||
|
||||
if (!(ovl_force_readonly(ufs)) && ufs->config.index) {
|
||||
/* Verify lower root is upper root origin */
|
||||
err = ovl_verify_origin(upperpath.dentry, ufs->lower_mnt[0],
|
||||
stack[0].dentry, false, true);
|
||||
if (err) {
|
||||
pr_err("overlayfs: failed to verify upper root origin\n");
|
||||
goto out_put_lower_mnt;
|
||||
}
|
||||
|
||||
ufs->indexdir = ovl_workdir_create(sb, ufs, workpath.dentry,
|
||||
OVL_INDEXDIR_NAME, true);
|
||||
if (ufs->indexdir) {
|
||||
/* Verify upper root is index dir origin */
|
||||
err = ovl_verify_origin(ufs->indexdir, ufs->upper_mnt,
|
||||
upperpath.dentry, true, true);
|
||||
if (err)
|
||||
pr_err("overlayfs: failed to verify index dir origin\n");
|
||||
|
||||
/* Cleanup bad/stale/orphan index entries */
|
||||
if (!err)
|
||||
err = ovl_indexdir_cleanup(ufs->indexdir,
|
||||
ufs->upper_mnt,
|
||||
stack, numlower);
|
||||
}
|
||||
if (err || !ufs->indexdir)
|
||||
pr_warn("overlayfs: try deleting index dir or mounting with '-o index=off' to disable inodes index.\n");
|
||||
if (err)
|
||||
goto out_put_indexdir;
|
||||
}
|
||||
|
||||
/* Show index=off/on in /proc/mounts for any of the reasons above */
|
||||
if (!ufs->indexdir)
|
||||
ufs->config.index = false;
|
||||
|
||||
if (remote)
|
||||
sb->s_d_op = &ovl_reval_dentry_operations;
|
||||
else
|
||||
sb->s_d_op = &ovl_dentry_operations;
|
||||
|
||||
out:
|
||||
for (i = 0; i < numlower; i++)
|
||||
path_put(&stack[i]);
|
||||
kfree(stack);
|
||||
kfree(lowertmp);
|
||||
|
||||
return oe;
|
||||
|
||||
out_err:
|
||||
oe = ERR_PTR(err);
|
||||
goto out;
|
||||
}
|
||||
|
||||
static int ovl_fill_super(struct super_block *sb, void *data, int silent)
|
||||
{
|
||||
struct path upperpath = { };
|
||||
struct dentry *root_dentry;
|
||||
struct ovl_entry *oe;
|
||||
struct ovl_fs *ofs;
|
||||
struct cred *cred;
|
||||
int err;
|
||||
|
||||
err = -ENOMEM;
|
||||
ufs->creator_cred = cred = prepare_creds();
|
||||
ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL);
|
||||
if (!ofs)
|
||||
goto out;
|
||||
|
||||
ofs->creator_cred = cred = prepare_creds();
|
||||
if (!cred)
|
||||
goto out_put_indexdir;
|
||||
goto out_err;
|
||||
|
||||
ofs->config.redirect_dir = ovl_redirect_dir_def;
|
||||
ofs->config.index = ovl_index_def;
|
||||
err = ovl_parse_opt((char *) data, &ofs->config);
|
||||
if (err)
|
||||
goto out_err;
|
||||
|
||||
err = -EINVAL;
|
||||
if (!ofs->config.lowerdir) {
|
||||
if (!silent)
|
||||
pr_err("overlayfs: missing 'lowerdir'\n");
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
sb->s_stack_depth = 0;
|
||||
sb->s_maxbytes = MAX_LFS_FILESIZE;
|
||||
if (ofs->config.upperdir) {
|
||||
if (!ofs->config.workdir) {
|
||||
pr_err("overlayfs: missing 'workdir'\n");
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
err = ovl_get_upper(ofs, &upperpath);
|
||||
if (err)
|
||||
goto out_err;
|
||||
|
||||
err = ovl_get_workdir(ofs, &upperpath);
|
||||
if (err)
|
||||
goto out_err;
|
||||
|
||||
if (!ofs->workdir)
|
||||
sb->s_flags |= MS_RDONLY;
|
||||
|
||||
sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth;
|
||||
sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran;
|
||||
|
||||
}
|
||||
oe = ovl_get_lowerstack(sb, ofs);
|
||||
err = PTR_ERR(oe);
|
||||
if (IS_ERR(oe))
|
||||
goto out_err;
|
||||
|
||||
/* If the upper fs is nonexistent, we mark overlayfs r/o too */
|
||||
if (!ofs->upper_mnt)
|
||||
sb->s_flags |= MS_RDONLY;
|
||||
else if (ofs->upper_mnt->mnt_sb != ofs->same_sb)
|
||||
ofs->same_sb = NULL;
|
||||
|
||||
if (!(ovl_force_readonly(ofs)) && ofs->config.index) {
|
||||
err = ovl_get_indexdir(ofs, oe, &upperpath);
|
||||
if (err)
|
||||
goto out_free_oe;
|
||||
|
||||
if (!ofs->indexdir)
|
||||
sb->s_flags |= MS_RDONLY;
|
||||
}
|
||||
|
||||
/* Show index=off/on in /proc/mounts for any of the reasons above */
|
||||
if (!ofs->indexdir)
|
||||
ofs->config.index = false;
|
||||
|
||||
/* Never override disk quota limits or use reserved space */
|
||||
cap_lower(cred->cap_effective, CAP_SYS_RESOURCE);
|
||||
|
||||
err = -ENOMEM;
|
||||
oe = ovl_alloc_entry(numlower);
|
||||
if (!oe)
|
||||
goto out_put_cred;
|
||||
|
||||
sb->s_magic = OVERLAYFS_SUPER_MAGIC;
|
||||
sb->s_op = &ovl_super_operations;
|
||||
sb->s_xattr = ovl_xattr_handlers;
|
||||
sb->s_fs_info = ufs;
|
||||
sb->s_fs_info = ofs;
|
||||
sb->s_flags |= MS_POSIXACL | MS_NOREMOTELOCK;
|
||||
|
||||
err = -ENOMEM;
|
||||
root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0));
|
||||
if (!root_dentry)
|
||||
goto out_free_oe;
|
||||
|
||||
mntput(upperpath.mnt);
|
||||
for (i = 0; i < numlower; i++)
|
||||
mntput(stack[i].mnt);
|
||||
mntput(workpath.mnt);
|
||||
kfree(lowertmp);
|
||||
|
||||
if (upperpath.dentry) {
|
||||
oe->has_upper = true;
|
||||
if (ovl_is_impuredir(upperpath.dentry))
|
||||
ovl_set_flag(OVL_IMPURE, d_inode(root_dentry));
|
||||
}
|
||||
for (i = 0; i < numlower; i++) {
|
||||
oe->lowerstack[i].dentry = stack[i].dentry;
|
||||
oe->lowerstack[i].mnt = ufs->lower_mnt[i];
|
||||
}
|
||||
kfree(stack);
|
||||
|
||||
root_dentry->d_fsdata = oe;
|
||||
|
||||
/* Root is always merge -> can have whiteouts */
|
||||
ovl_set_flag(OVL_WHITEOUTS, d_inode(root_dentry));
|
||||
ovl_inode_init(d_inode(root_dentry), upperpath.dentry,
|
||||
ovl_dentry_lower(root_dentry));
|
||||
|
||||
|
@ -1149,39 +1253,11 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent)
|
|||
return 0;
|
||||
|
||||
out_free_oe:
|
||||
ovl_entry_stack_free(oe);
|
||||
kfree(oe);
|
||||
out_put_cred:
|
||||
put_cred(ufs->creator_cred);
|
||||
out_put_indexdir:
|
||||
dput(ufs->indexdir);
|
||||
out_put_lower_mnt:
|
||||
for (i = 0; i < ufs->numlower; i++)
|
||||
mntput(ufs->lower_mnt[i]);
|
||||
kfree(ufs->lower_mnt);
|
||||
out_put_workdir:
|
||||
dput(ufs->workdir);
|
||||
mntput(ufs->upper_mnt);
|
||||
out_put_lowerpath:
|
||||
for (i = 0; i < numlower; i++)
|
||||
path_put(&stack[i]);
|
||||
kfree(stack);
|
||||
out_free_lowertmp:
|
||||
kfree(lowertmp);
|
||||
out_unlock_workdentry:
|
||||
if (ufs->workdir_locked)
|
||||
ovl_inuse_unlock(workpath.dentry);
|
||||
out_put_workpath:
|
||||
path_put(&workpath);
|
||||
out_unlock_upperdentry:
|
||||
if (ufs->upperdir_locked)
|
||||
ovl_inuse_unlock(upperpath.dentry);
|
||||
out_put_upperpath:
|
||||
out_err:
|
||||
path_put(&upperpath);
|
||||
out_free_config:
|
||||
kfree(ufs->config.lowerdir);
|
||||
kfree(ufs->config.upperdir);
|
||||
kfree(ufs->config.workdir);
|
||||
kfree(ufs);
|
||||
ovl_free_fs(ofs);
|
||||
out:
|
||||
return err;
|
||||
}
|
||||
|
|
|
@ -17,7 +17,6 @@
|
|||
#include <linux/namei.h>
|
||||
#include <linux/ratelimit.h>
|
||||
#include "overlayfs.h"
|
||||
#include "ovl_entry.h"
|
||||
|
||||
int ovl_want_write(struct dentry *dentry)
|
||||
{
|
||||
|
@ -125,7 +124,12 @@ void ovl_path_lower(struct dentry *dentry, struct path *path)
|
|||
{
|
||||
struct ovl_entry *oe = dentry->d_fsdata;
|
||||
|
||||
*path = oe->numlower ? oe->lowerstack[0] : (struct path) { };
|
||||
if (oe->numlower) {
|
||||
path->mnt = oe->lowerstack[0].layer->mnt;
|
||||
path->dentry = oe->lowerstack[0].dentry;
|
||||
} else {
|
||||
*path = (struct path) { };
|
||||
}
|
||||
}
|
||||
|
||||
enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path)
|
||||
|
@ -329,6 +333,19 @@ void ovl_copy_up_end(struct dentry *dentry)
|
|||
mutex_unlock(&OVL_I(d_inode(dentry))->lock);
|
||||
}
|
||||
|
||||
bool ovl_check_origin_xattr(struct dentry *dentry)
|
||||
{
|
||||
int res;
|
||||
|
||||
res = vfs_getxattr(dentry, OVL_XATTR_ORIGIN, NULL, 0);
|
||||
|
||||
/* Zero size value means "copied up but origin unknown" */
|
||||
if (res >= 0)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ovl_check_dir_xattr(struct dentry *dentry, const char *name)
|
||||
{
|
||||
int res;
|
||||
|
|
|
@ -18,4 +18,10 @@ static inline int path_equal(const struct path *path1, const struct path *path2)
|
|||
return path1->mnt == path2->mnt && path1->dentry == path2->dentry;
|
||||
}
|
||||
|
||||
static inline void path_put_init(struct path *path)
|
||||
{
|
||||
path_put(path);
|
||||
*path = (struct path) { };
|
||||
}
|
||||
|
||||
#endif /* _LINUX_PATH_H */
|
||||
|
|
Loading…
Reference in New Issue