Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
Pull vfs pile 2 (of many) from Al Viro: "Mostly Miklos' series this time" * 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs: constify dcache.c inlined helpers where possible fuse: drop dentry on failed revalidate fuse: clean up return in fuse_dentry_revalidate() fuse: use d_materialise_unique() sysfs: use check_submounts_and_drop() nfs: use check_submounts_and_drop() gfs2: use check_submounts_and_drop() afs: use check_submounts_and_drop() vfs: check unlinked ancestors before mount vfs: check submounts and drop atomically vfs: add d_walk() vfs: restructure d_genocide()
This commit is contained in:
commit
dc0755cdb1
10
fs/afs/dir.c
10
fs/afs/dir.c
@ -685,16 +685,12 @@ not_found:
|
|||||||
spin_unlock(&dentry->d_lock);
|
spin_unlock(&dentry->d_lock);
|
||||||
|
|
||||||
out_bad:
|
out_bad:
|
||||||
if (dentry->d_inode) {
|
/* don't unhash if we have submounts */
|
||||||
/* don't unhash if we have submounts */
|
if (check_submounts_and_drop(dentry) != 0)
|
||||||
if (have_submounts(dentry))
|
goto out_skip;
|
||||||
goto out_skip;
|
|
||||||
}
|
|
||||||
|
|
||||||
_debug("dropping dentry %s/%s",
|
_debug("dropping dentry %s/%s",
|
||||||
parent->d_name.name, dentry->d_name.name);
|
parent->d_name.name, dentry->d_name.name);
|
||||||
shrink_dcache_parent(dentry);
|
|
||||||
d_drop(dentry);
|
|
||||||
dput(parent);
|
dput(parent);
|
||||||
key_put(key);
|
key_put(key);
|
||||||
|
|
||||||
|
417
fs/dcache.c
417
fs/dcache.c
@ -1031,34 +1031,56 @@ static struct dentry *try_to_ascend(struct dentry *old, int locked, unsigned seq
|
|||||||
return new;
|
return new;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Search for at least 1 mount point in the dentry's subdirs.
|
|
||||||
* We descend to the next level whenever the d_subdirs
|
|
||||||
* list is non-empty and continue searching.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* have_submounts - check for mounts over a dentry
|
* enum d_walk_ret - action to talke during tree walk
|
||||||
* @parent: dentry to check.
|
* @D_WALK_CONTINUE: contrinue walk
|
||||||
*
|
* @D_WALK_QUIT: quit walk
|
||||||
* Return true if the parent or its subdirectories contain
|
* @D_WALK_NORETRY: quit when retry is needed
|
||||||
* a mount point
|
* @D_WALK_SKIP: skip this dentry and its children
|
||||||
*/
|
*/
|
||||||
int have_submounts(struct dentry *parent)
|
enum d_walk_ret {
|
||||||
|
D_WALK_CONTINUE,
|
||||||
|
D_WALK_QUIT,
|
||||||
|
D_WALK_NORETRY,
|
||||||
|
D_WALK_SKIP,
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* d_walk - walk the dentry tree
|
||||||
|
* @parent: start of walk
|
||||||
|
* @data: data passed to @enter() and @finish()
|
||||||
|
* @enter: callback when first entering the dentry
|
||||||
|
* @finish: callback when successfully finished the walk
|
||||||
|
*
|
||||||
|
* The @enter() and @finish() callbacks are called with d_lock held.
|
||||||
|
*/
|
||||||
|
static void d_walk(struct dentry *parent, void *data,
|
||||||
|
enum d_walk_ret (*enter)(void *, struct dentry *),
|
||||||
|
void (*finish)(void *))
|
||||||
{
|
{
|
||||||
struct dentry *this_parent;
|
struct dentry *this_parent;
|
||||||
struct list_head *next;
|
struct list_head *next;
|
||||||
unsigned seq;
|
unsigned seq;
|
||||||
int locked = 0;
|
int locked = 0;
|
||||||
|
enum d_walk_ret ret;
|
||||||
|
bool retry = true;
|
||||||
|
|
||||||
seq = read_seqbegin(&rename_lock);
|
seq = read_seqbegin(&rename_lock);
|
||||||
again:
|
again:
|
||||||
this_parent = parent;
|
this_parent = parent;
|
||||||
|
|
||||||
if (d_mountpoint(parent))
|
|
||||||
goto positive;
|
|
||||||
spin_lock(&this_parent->d_lock);
|
spin_lock(&this_parent->d_lock);
|
||||||
|
|
||||||
|
ret = enter(data, this_parent);
|
||||||
|
switch (ret) {
|
||||||
|
case D_WALK_CONTINUE:
|
||||||
|
break;
|
||||||
|
case D_WALK_QUIT:
|
||||||
|
case D_WALK_SKIP:
|
||||||
|
goto out_unlock;
|
||||||
|
case D_WALK_NORETRY:
|
||||||
|
retry = false;
|
||||||
|
break;
|
||||||
|
}
|
||||||
repeat:
|
repeat:
|
||||||
next = this_parent->d_subdirs.next;
|
next = this_parent->d_subdirs.next;
|
||||||
resume:
|
resume:
|
||||||
@ -1068,12 +1090,22 @@ resume:
|
|||||||
next = tmp->next;
|
next = tmp->next;
|
||||||
|
|
||||||
spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
|
spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
|
||||||
/* Have we found a mount point ? */
|
|
||||||
if (d_mountpoint(dentry)) {
|
ret = enter(data, dentry);
|
||||||
|
switch (ret) {
|
||||||
|
case D_WALK_CONTINUE:
|
||||||
|
break;
|
||||||
|
case D_WALK_QUIT:
|
||||||
spin_unlock(&dentry->d_lock);
|
spin_unlock(&dentry->d_lock);
|
||||||
spin_unlock(&this_parent->d_lock);
|
goto out_unlock;
|
||||||
goto positive;
|
case D_WALK_NORETRY:
|
||||||
|
retry = false;
|
||||||
|
break;
|
||||||
|
case D_WALK_SKIP:
|
||||||
|
spin_unlock(&dentry->d_lock);
|
||||||
|
continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!list_empty(&dentry->d_subdirs)) {
|
if (!list_empty(&dentry->d_subdirs)) {
|
||||||
spin_unlock(&this_parent->d_lock);
|
spin_unlock(&this_parent->d_lock);
|
||||||
spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
|
spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
|
||||||
@ -1094,28 +1126,96 @@ resume:
|
|||||||
next = child->d_u.d_child.next;
|
next = child->d_u.d_child.next;
|
||||||
goto resume;
|
goto resume;
|
||||||
}
|
}
|
||||||
|
if (!locked && read_seqretry(&rename_lock, seq)) {
|
||||||
|
spin_unlock(&this_parent->d_lock);
|
||||||
|
goto rename_retry;
|
||||||
|
}
|
||||||
|
if (finish)
|
||||||
|
finish(data);
|
||||||
|
|
||||||
|
out_unlock:
|
||||||
spin_unlock(&this_parent->d_lock);
|
spin_unlock(&this_parent->d_lock);
|
||||||
if (!locked && read_seqretry(&rename_lock, seq))
|
|
||||||
goto rename_retry;
|
|
||||||
if (locked)
|
if (locked)
|
||||||
write_sequnlock(&rename_lock);
|
write_sequnlock(&rename_lock);
|
||||||
return 0; /* No mount points found in tree */
|
return;
|
||||||
positive:
|
|
||||||
if (!locked && read_seqretry(&rename_lock, seq))
|
|
||||||
goto rename_retry;
|
|
||||||
if (locked)
|
|
||||||
write_sequnlock(&rename_lock);
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
rename_retry:
|
rename_retry:
|
||||||
|
if (!retry)
|
||||||
|
return;
|
||||||
if (locked)
|
if (locked)
|
||||||
goto again;
|
goto again;
|
||||||
locked = 1;
|
locked = 1;
|
||||||
write_seqlock(&rename_lock);
|
write_seqlock(&rename_lock);
|
||||||
goto again;
|
goto again;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Search for at least 1 mount point in the dentry's subdirs.
|
||||||
|
* We descend to the next level whenever the d_subdirs
|
||||||
|
* list is non-empty and continue searching.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/**
|
||||||
|
* have_submounts - check for mounts over a dentry
|
||||||
|
* @parent: dentry to check.
|
||||||
|
*
|
||||||
|
* Return true if the parent or its subdirectories contain
|
||||||
|
* a mount point
|
||||||
|
*/
|
||||||
|
|
||||||
|
static enum d_walk_ret check_mount(void *data, struct dentry *dentry)
|
||||||
|
{
|
||||||
|
int *ret = data;
|
||||||
|
if (d_mountpoint(dentry)) {
|
||||||
|
*ret = 1;
|
||||||
|
return D_WALK_QUIT;
|
||||||
|
}
|
||||||
|
return D_WALK_CONTINUE;
|
||||||
|
}
|
||||||
|
|
||||||
|
int have_submounts(struct dentry *parent)
|
||||||
|
{
|
||||||
|
int ret = 0;
|
||||||
|
|
||||||
|
d_walk(parent, &ret, check_mount, NULL);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
EXPORT_SYMBOL(have_submounts);
|
EXPORT_SYMBOL(have_submounts);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Called by mount code to set a mountpoint and check if the mountpoint is
|
||||||
|
* reachable (e.g. NFS can unhash a directory dentry and then the complete
|
||||||
|
* subtree can become unreachable).
|
||||||
|
*
|
||||||
|
* Only one of check_submounts_and_drop() and d_set_mounted() must succeed. For
|
||||||
|
* this reason take rename_lock and d_lock on dentry and ancestors.
|
||||||
|
*/
|
||||||
|
int d_set_mounted(struct dentry *dentry)
|
||||||
|
{
|
||||||
|
struct dentry *p;
|
||||||
|
int ret = -ENOENT;
|
||||||
|
write_seqlock(&rename_lock);
|
||||||
|
for (p = dentry->d_parent; !IS_ROOT(p); p = p->d_parent) {
|
||||||
|
/* Need exclusion wrt. check_submounts_and_drop() */
|
||||||
|
spin_lock(&p->d_lock);
|
||||||
|
if (unlikely(d_unhashed(p))) {
|
||||||
|
spin_unlock(&p->d_lock);
|
||||||
|
goto out;
|
||||||
|
}
|
||||||
|
spin_unlock(&p->d_lock);
|
||||||
|
}
|
||||||
|
spin_lock(&dentry->d_lock);
|
||||||
|
if (!d_unlinked(dentry)) {
|
||||||
|
dentry->d_flags |= DCACHE_MOUNTED;
|
||||||
|
ret = 0;
|
||||||
|
}
|
||||||
|
spin_unlock(&dentry->d_lock);
|
||||||
|
out:
|
||||||
|
write_sequnlock(&rename_lock);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Search the dentry child list of the specified parent,
|
* Search the dentry child list of the specified parent,
|
||||||
* and move any unused dentries to the end of the unused
|
* and move any unused dentries to the end of the unused
|
||||||
@ -1130,93 +1230,46 @@ EXPORT_SYMBOL(have_submounts);
|
|||||||
* drop the lock and return early due to latency
|
* drop the lock and return early due to latency
|
||||||
* constraints.
|
* constraints.
|
||||||
*/
|
*/
|
||||||
static int select_parent(struct dentry *parent, struct list_head *dispose)
|
|
||||||
|
struct select_data {
|
||||||
|
struct dentry *start;
|
||||||
|
struct list_head dispose;
|
||||||
|
int found;
|
||||||
|
};
|
||||||
|
|
||||||
|
static enum d_walk_ret select_collect(void *_data, struct dentry *dentry)
|
||||||
{
|
{
|
||||||
struct dentry *this_parent;
|
struct select_data *data = _data;
|
||||||
struct list_head *next;
|
enum d_walk_ret ret = D_WALK_CONTINUE;
|
||||||
unsigned seq;
|
|
||||||
int found = 0;
|
|
||||||
int locked = 0;
|
|
||||||
|
|
||||||
seq = read_seqbegin(&rename_lock);
|
if (data->start == dentry)
|
||||||
again:
|
goto out;
|
||||||
this_parent = parent;
|
|
||||||
spin_lock(&this_parent->d_lock);
|
|
||||||
repeat:
|
|
||||||
next = this_parent->d_subdirs.next;
|
|
||||||
resume:
|
|
||||||
while (next != &this_parent->d_subdirs) {
|
|
||||||
struct list_head *tmp = next;
|
|
||||||
struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
|
|
||||||
next = tmp->next;
|
|
||||||
|
|
||||||
spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
|
/*
|
||||||
|
* move only zero ref count dentries to the dispose list.
|
||||||
/*
|
*
|
||||||
* move only zero ref count dentries to the dispose list.
|
* Those which are presently on the shrink list, being processed
|
||||||
*
|
* by shrink_dentry_list(), shouldn't be moved. Otherwise the
|
||||||
* Those which are presently on the shrink list, being processed
|
* loop in shrink_dcache_parent() might not make any progress
|
||||||
* by shrink_dentry_list(), shouldn't be moved. Otherwise the
|
* and loop forever.
|
||||||
* loop in shrink_dcache_parent() might not make any progress
|
*/
|
||||||
* and loop forever.
|
if (dentry->d_lockref.count) {
|
||||||
*/
|
dentry_lru_del(dentry);
|
||||||
if (dentry->d_lockref.count) {
|
} else if (!(dentry->d_flags & DCACHE_SHRINK_LIST)) {
|
||||||
dentry_lru_del(dentry);
|
dentry_lru_move_list(dentry, &data->dispose);
|
||||||
} else if (!(dentry->d_flags & DCACHE_SHRINK_LIST)) {
|
dentry->d_flags |= DCACHE_SHRINK_LIST;
|
||||||
dentry_lru_move_list(dentry, dispose);
|
data->found++;
|
||||||
dentry->d_flags |= DCACHE_SHRINK_LIST;
|
ret = D_WALK_NORETRY;
|
||||||
found++;
|
|
||||||
}
|
|
||||||
/*
|
|
||||||
* We can return to the caller if we have found some (this
|
|
||||||
* ensures forward progress). We'll be coming back to find
|
|
||||||
* the rest.
|
|
||||||
*/
|
|
||||||
if (found && need_resched()) {
|
|
||||||
spin_unlock(&dentry->d_lock);
|
|
||||||
goto out;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Descend a level if the d_subdirs list is non-empty.
|
|
||||||
*/
|
|
||||||
if (!list_empty(&dentry->d_subdirs)) {
|
|
||||||
spin_unlock(&this_parent->d_lock);
|
|
||||||
spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
|
|
||||||
this_parent = dentry;
|
|
||||||
spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
|
|
||||||
goto repeat;
|
|
||||||
}
|
|
||||||
|
|
||||||
spin_unlock(&dentry->d_lock);
|
|
||||||
}
|
}
|
||||||
/*
|
/*
|
||||||
* All done at this level ... ascend and resume the search.
|
* We can return to the caller if we have found some (this
|
||||||
|
* ensures forward progress). We'll be coming back to find
|
||||||
|
* the rest.
|
||||||
*/
|
*/
|
||||||
if (this_parent != parent) {
|
if (data->found && need_resched())
|
||||||
struct dentry *child = this_parent;
|
ret = D_WALK_QUIT;
|
||||||
this_parent = try_to_ascend(this_parent, locked, seq);
|
|
||||||
if (!this_parent)
|
|
||||||
goto rename_retry;
|
|
||||||
next = child->d_u.d_child.next;
|
|
||||||
goto resume;
|
|
||||||
}
|
|
||||||
out:
|
out:
|
||||||
spin_unlock(&this_parent->d_lock);
|
return ret;
|
||||||
if (!locked && read_seqretry(&rename_lock, seq))
|
|
||||||
goto rename_retry;
|
|
||||||
if (locked)
|
|
||||||
write_sequnlock(&rename_lock);
|
|
||||||
return found;
|
|
||||||
|
|
||||||
rename_retry:
|
|
||||||
if (found)
|
|
||||||
return found;
|
|
||||||
if (locked)
|
|
||||||
goto again;
|
|
||||||
locked = 1;
|
|
||||||
write_seqlock(&rename_lock);
|
|
||||||
goto again;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@ -1225,18 +1278,90 @@ rename_retry:
|
|||||||
*
|
*
|
||||||
* Prune the dcache to remove unused children of the parent dentry.
|
* Prune the dcache to remove unused children of the parent dentry.
|
||||||
*/
|
*/
|
||||||
void shrink_dcache_parent(struct dentry * parent)
|
void shrink_dcache_parent(struct dentry *parent)
|
||||||
{
|
{
|
||||||
LIST_HEAD(dispose);
|
for (;;) {
|
||||||
int found;
|
struct select_data data;
|
||||||
|
|
||||||
while ((found = select_parent(parent, &dispose)) != 0) {
|
INIT_LIST_HEAD(&data.dispose);
|
||||||
shrink_dentry_list(&dispose);
|
data.start = parent;
|
||||||
|
data.found = 0;
|
||||||
|
|
||||||
|
d_walk(parent, &data, select_collect, NULL);
|
||||||
|
if (!data.found)
|
||||||
|
break;
|
||||||
|
|
||||||
|
shrink_dentry_list(&data.dispose);
|
||||||
cond_resched();
|
cond_resched();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
EXPORT_SYMBOL(shrink_dcache_parent);
|
EXPORT_SYMBOL(shrink_dcache_parent);
|
||||||
|
|
||||||
|
static enum d_walk_ret check_and_collect(void *_data, struct dentry *dentry)
|
||||||
|
{
|
||||||
|
struct select_data *data = _data;
|
||||||
|
|
||||||
|
if (d_mountpoint(dentry)) {
|
||||||
|
data->found = -EBUSY;
|
||||||
|
return D_WALK_QUIT;
|
||||||
|
}
|
||||||
|
|
||||||
|
return select_collect(_data, dentry);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void check_and_drop(void *_data)
|
||||||
|
{
|
||||||
|
struct select_data *data = _data;
|
||||||
|
|
||||||
|
if (d_mountpoint(data->start))
|
||||||
|
data->found = -EBUSY;
|
||||||
|
if (!data->found)
|
||||||
|
__d_drop(data->start);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* check_submounts_and_drop - prune dcache, check for submounts and drop
|
||||||
|
*
|
||||||
|
* All done as a single atomic operation relative to has_unlinked_ancestor().
|
||||||
|
* Returns 0 if successfully unhashed @parent. If there were submounts then
|
||||||
|
* return -EBUSY.
|
||||||
|
*
|
||||||
|
* @dentry: dentry to prune and drop
|
||||||
|
*/
|
||||||
|
int check_submounts_and_drop(struct dentry *dentry)
|
||||||
|
{
|
||||||
|
int ret = 0;
|
||||||
|
|
||||||
|
/* Negative dentries can be dropped without further checks */
|
||||||
|
if (!dentry->d_inode) {
|
||||||
|
d_drop(dentry);
|
||||||
|
goto out;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (;;) {
|
||||||
|
struct select_data data;
|
||||||
|
|
||||||
|
INIT_LIST_HEAD(&data.dispose);
|
||||||
|
data.start = dentry;
|
||||||
|
data.found = 0;
|
||||||
|
|
||||||
|
d_walk(dentry, &data, check_and_collect, check_and_drop);
|
||||||
|
ret = data.found;
|
||||||
|
|
||||||
|
if (!list_empty(&data.dispose))
|
||||||
|
shrink_dentry_list(&data.dispose);
|
||||||
|
|
||||||
|
if (ret <= 0)
|
||||||
|
break;
|
||||||
|
|
||||||
|
cond_resched();
|
||||||
|
}
|
||||||
|
|
||||||
|
out:
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
EXPORT_SYMBOL(check_submounts_and_drop);
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* __d_alloc - allocate a dcache entry
|
* __d_alloc - allocate a dcache entry
|
||||||
* @sb: filesystem it will belong to
|
* @sb: filesystem it will belong to
|
||||||
@ -2928,68 +3053,24 @@ int is_subdir(struct dentry *new_dentry, struct dentry *old_dentry)
|
|||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
void d_genocide(struct dentry *root)
|
static enum d_walk_ret d_genocide_kill(void *data, struct dentry *dentry)
|
||||||
{
|
{
|
||||||
struct dentry *this_parent;
|
struct dentry *root = data;
|
||||||
struct list_head *next;
|
if (dentry != root) {
|
||||||
unsigned seq;
|
if (d_unhashed(dentry) || !dentry->d_inode)
|
||||||
int locked = 0;
|
return D_WALK_SKIP;
|
||||||
|
|
||||||
seq = read_seqbegin(&rename_lock);
|
|
||||||
again:
|
|
||||||
this_parent = root;
|
|
||||||
spin_lock(&this_parent->d_lock);
|
|
||||||
repeat:
|
|
||||||
next = this_parent->d_subdirs.next;
|
|
||||||
resume:
|
|
||||||
while (next != &this_parent->d_subdirs) {
|
|
||||||
struct list_head *tmp = next;
|
|
||||||
struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
|
|
||||||
next = tmp->next;
|
|
||||||
|
|
||||||
spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
|
|
||||||
if (d_unhashed(dentry) || !dentry->d_inode) {
|
|
||||||
spin_unlock(&dentry->d_lock);
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
if (!list_empty(&dentry->d_subdirs)) {
|
|
||||||
spin_unlock(&this_parent->d_lock);
|
|
||||||
spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
|
|
||||||
this_parent = dentry;
|
|
||||||
spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
|
|
||||||
goto repeat;
|
|
||||||
}
|
|
||||||
if (!(dentry->d_flags & DCACHE_GENOCIDE)) {
|
if (!(dentry->d_flags & DCACHE_GENOCIDE)) {
|
||||||
dentry->d_flags |= DCACHE_GENOCIDE;
|
dentry->d_flags |= DCACHE_GENOCIDE;
|
||||||
dentry->d_lockref.count--;
|
dentry->d_lockref.count--;
|
||||||
}
|
}
|
||||||
spin_unlock(&dentry->d_lock);
|
|
||||||
}
|
}
|
||||||
if (this_parent != root) {
|
return D_WALK_CONTINUE;
|
||||||
struct dentry *child = this_parent;
|
}
|
||||||
if (!(this_parent->d_flags & DCACHE_GENOCIDE)) {
|
|
||||||
this_parent->d_flags |= DCACHE_GENOCIDE;
|
|
||||||
this_parent->d_lockref.count--;
|
|
||||||
}
|
|
||||||
this_parent = try_to_ascend(this_parent, locked, seq);
|
|
||||||
if (!this_parent)
|
|
||||||
goto rename_retry;
|
|
||||||
next = child->d_u.d_child.next;
|
|
||||||
goto resume;
|
|
||||||
}
|
|
||||||
spin_unlock(&this_parent->d_lock);
|
|
||||||
if (!locked && read_seqretry(&rename_lock, seq))
|
|
||||||
goto rename_retry;
|
|
||||||
if (locked)
|
|
||||||
write_sequnlock(&rename_lock);
|
|
||||||
return;
|
|
||||||
|
|
||||||
rename_retry:
|
void d_genocide(struct dentry *parent)
|
||||||
if (locked)
|
{
|
||||||
goto again;
|
d_walk(parent, parent, d_genocide_kill, NULL);
|
||||||
locked = 1;
|
|
||||||
write_seqlock(&rename_lock);
|
|
||||||
goto again;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void d_tmpfile(struct dentry *dentry, struct inode *inode)
|
void d_tmpfile(struct dentry *dentry, struct inode *inode)
|
||||||
|
@ -182,10 +182,11 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
|
|||||||
struct inode *inode;
|
struct inode *inode;
|
||||||
struct dentry *parent;
|
struct dentry *parent;
|
||||||
struct fuse_conn *fc;
|
struct fuse_conn *fc;
|
||||||
|
int ret;
|
||||||
|
|
||||||
inode = ACCESS_ONCE(entry->d_inode);
|
inode = ACCESS_ONCE(entry->d_inode);
|
||||||
if (inode && is_bad_inode(inode))
|
if (inode && is_bad_inode(inode))
|
||||||
return 0;
|
goto invalid;
|
||||||
else if (fuse_dentry_time(entry) < get_jiffies_64()) {
|
else if (fuse_dentry_time(entry) < get_jiffies_64()) {
|
||||||
int err;
|
int err;
|
||||||
struct fuse_entry_out outarg;
|
struct fuse_entry_out outarg;
|
||||||
@ -195,20 +196,23 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
|
|||||||
|
|
||||||
/* For negative dentries, always do a fresh lookup */
|
/* For negative dentries, always do a fresh lookup */
|
||||||
if (!inode)
|
if (!inode)
|
||||||
return 0;
|
goto invalid;
|
||||||
|
|
||||||
|
ret = -ECHILD;
|
||||||
if (flags & LOOKUP_RCU)
|
if (flags & LOOKUP_RCU)
|
||||||
return -ECHILD;
|
goto out;
|
||||||
|
|
||||||
fc = get_fuse_conn(inode);
|
fc = get_fuse_conn(inode);
|
||||||
req = fuse_get_req_nopages(fc);
|
req = fuse_get_req_nopages(fc);
|
||||||
|
ret = PTR_ERR(req);
|
||||||
if (IS_ERR(req))
|
if (IS_ERR(req))
|
||||||
return 0;
|
goto out;
|
||||||
|
|
||||||
forget = fuse_alloc_forget();
|
forget = fuse_alloc_forget();
|
||||||
if (!forget) {
|
if (!forget) {
|
||||||
fuse_put_request(fc, req);
|
fuse_put_request(fc, req);
|
||||||
return 0;
|
ret = -ENOMEM;
|
||||||
|
goto out;
|
||||||
}
|
}
|
||||||
|
|
||||||
attr_version = fuse_get_attr_version(fc);
|
attr_version = fuse_get_attr_version(fc);
|
||||||
@ -227,7 +231,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
|
|||||||
struct fuse_inode *fi = get_fuse_inode(inode);
|
struct fuse_inode *fi = get_fuse_inode(inode);
|
||||||
if (outarg.nodeid != get_node_id(inode)) {
|
if (outarg.nodeid != get_node_id(inode)) {
|
||||||
fuse_queue_forget(fc, forget, outarg.nodeid, 1);
|
fuse_queue_forget(fc, forget, outarg.nodeid, 1);
|
||||||
return 0;
|
goto invalid;
|
||||||
}
|
}
|
||||||
spin_lock(&fc->lock);
|
spin_lock(&fc->lock);
|
||||||
fi->nlookup++;
|
fi->nlookup++;
|
||||||
@ -235,7 +239,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
|
|||||||
}
|
}
|
||||||
kfree(forget);
|
kfree(forget);
|
||||||
if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
|
if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
|
||||||
return 0;
|
goto invalid;
|
||||||
|
|
||||||
fuse_change_attributes(inode, &outarg.attr,
|
fuse_change_attributes(inode, &outarg.attr,
|
||||||
entry_attr_timeout(&outarg),
|
entry_attr_timeout(&outarg),
|
||||||
@ -249,7 +253,15 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
|
|||||||
dput(parent);
|
dput(parent);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return 1;
|
ret = 1;
|
||||||
|
out:
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
invalid:
|
||||||
|
ret = 0;
|
||||||
|
if (check_submounts_and_drop(entry) != 0)
|
||||||
|
ret = 1;
|
||||||
|
goto out;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int invalid_nodeid(u64 nodeid)
|
static int invalid_nodeid(u64 nodeid)
|
||||||
@ -267,26 +279,6 @@ int fuse_valid_type(int m)
|
|||||||
S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
|
S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
|
||||||
* Add a directory inode to a dentry, ensuring that no other dentry
|
|
||||||
* refers to this inode. Called with fc->inst_mutex.
|
|
||||||
*/
|
|
||||||
static struct dentry *fuse_d_add_directory(struct dentry *entry,
|
|
||||||
struct inode *inode)
|
|
||||||
{
|
|
||||||
struct dentry *alias = d_find_alias(inode);
|
|
||||||
if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
|
|
||||||
/* This tries to shrink the subtree below alias */
|
|
||||||
fuse_invalidate_entry(alias);
|
|
||||||
dput(alias);
|
|
||||||
if (!hlist_empty(&inode->i_dentry))
|
|
||||||
return ERR_PTR(-EBUSY);
|
|
||||||
} else {
|
|
||||||
dput(alias);
|
|
||||||
}
|
|
||||||
return d_splice_alias(inode, entry);
|
|
||||||
}
|
|
||||||
|
|
||||||
int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
|
int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
|
||||||
struct fuse_entry_out *outarg, struct inode **inode)
|
struct fuse_entry_out *outarg, struct inode **inode)
|
||||||
{
|
{
|
||||||
@ -345,6 +337,24 @@ int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
|
|||||||
return err;
|
return err;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static struct dentry *fuse_materialise_dentry(struct dentry *dentry,
|
||||||
|
struct inode *inode)
|
||||||
|
{
|
||||||
|
struct dentry *newent;
|
||||||
|
|
||||||
|
if (inode && S_ISDIR(inode->i_mode)) {
|
||||||
|
struct fuse_conn *fc = get_fuse_conn(inode);
|
||||||
|
|
||||||
|
mutex_lock(&fc->inst_mutex);
|
||||||
|
newent = d_materialise_unique(dentry, inode);
|
||||||
|
mutex_unlock(&fc->inst_mutex);
|
||||||
|
} else {
|
||||||
|
newent = d_materialise_unique(dentry, inode);
|
||||||
|
}
|
||||||
|
|
||||||
|
return newent;
|
||||||
|
}
|
||||||
|
|
||||||
static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
|
static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
|
||||||
unsigned int flags)
|
unsigned int flags)
|
||||||
{
|
{
|
||||||
@ -352,7 +362,6 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
|
|||||||
struct fuse_entry_out outarg;
|
struct fuse_entry_out outarg;
|
||||||
struct inode *inode;
|
struct inode *inode;
|
||||||
struct dentry *newent;
|
struct dentry *newent;
|
||||||
struct fuse_conn *fc = get_fuse_conn(dir);
|
|
||||||
bool outarg_valid = true;
|
bool outarg_valid = true;
|
||||||
|
|
||||||
err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
|
err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
|
||||||
@ -368,16 +377,10 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
|
|||||||
if (inode && get_node_id(inode) == FUSE_ROOT_ID)
|
if (inode && get_node_id(inode) == FUSE_ROOT_ID)
|
||||||
goto out_iput;
|
goto out_iput;
|
||||||
|
|
||||||
if (inode && S_ISDIR(inode->i_mode)) {
|
newent = fuse_materialise_dentry(entry, inode);
|
||||||
mutex_lock(&fc->inst_mutex);
|
err = PTR_ERR(newent);
|
||||||
newent = fuse_d_add_directory(entry, inode);
|
if (IS_ERR(newent))
|
||||||
mutex_unlock(&fc->inst_mutex);
|
goto out_err;
|
||||||
err = PTR_ERR(newent);
|
|
||||||
if (IS_ERR(newent))
|
|
||||||
goto out_iput;
|
|
||||||
} else {
|
|
||||||
newent = d_splice_alias(inode, entry);
|
|
||||||
}
|
|
||||||
|
|
||||||
entry = newent ? newent : entry;
|
entry = newent ? newent : entry;
|
||||||
if (outarg_valid)
|
if (outarg_valid)
|
||||||
@ -1275,18 +1278,10 @@ static int fuse_direntplus_link(struct file *file,
|
|||||||
if (!inode)
|
if (!inode)
|
||||||
goto out;
|
goto out;
|
||||||
|
|
||||||
if (S_ISDIR(inode->i_mode)) {
|
alias = fuse_materialise_dentry(dentry, inode);
|
||||||
mutex_lock(&fc->inst_mutex);
|
err = PTR_ERR(alias);
|
||||||
alias = fuse_d_add_directory(dentry, inode);
|
if (IS_ERR(alias))
|
||||||
mutex_unlock(&fc->inst_mutex);
|
goto out;
|
||||||
err = PTR_ERR(alias);
|
|
||||||
if (IS_ERR(alias)) {
|
|
||||||
iput(inode);
|
|
||||||
goto out;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
alias = d_splice_alias(inode, dentry);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (alias) {
|
if (alias) {
|
||||||
dput(dentry);
|
dput(dentry);
|
||||||
|
@ -93,12 +93,9 @@ invalid_gunlock:
|
|||||||
if (!had_lock)
|
if (!had_lock)
|
||||||
gfs2_glock_dq_uninit(&d_gh);
|
gfs2_glock_dq_uninit(&d_gh);
|
||||||
invalid:
|
invalid:
|
||||||
if (inode && S_ISDIR(inode->i_mode)) {
|
if (check_submounts_and_drop(dentry) != 0)
|
||||||
if (have_submounts(dentry))
|
goto valid;
|
||||||
goto valid;
|
|
||||||
shrink_dcache_parent(dentry);
|
|
||||||
}
|
|
||||||
d_drop(dentry);
|
|
||||||
dput(parent);
|
dput(parent);
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
|
@ -126,6 +126,7 @@ extern int invalidate_inodes(struct super_block *, bool);
|
|||||||
* dcache.c
|
* dcache.c
|
||||||
*/
|
*/
|
||||||
extern struct dentry *__d_alloc(struct super_block *, const struct qstr *);
|
extern struct dentry *__d_alloc(struct super_block *, const struct qstr *);
|
||||||
|
extern int d_set_mounted(struct dentry *dentry);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* read_write.c
|
* read_write.c
|
||||||
|
@ -611,6 +611,7 @@ static struct mountpoint *new_mountpoint(struct dentry *dentry)
|
|||||||
{
|
{
|
||||||
struct list_head *chain = mountpoint_hashtable + hash(NULL, dentry);
|
struct list_head *chain = mountpoint_hashtable + hash(NULL, dentry);
|
||||||
struct mountpoint *mp;
|
struct mountpoint *mp;
|
||||||
|
int ret;
|
||||||
|
|
||||||
list_for_each_entry(mp, chain, m_hash) {
|
list_for_each_entry(mp, chain, m_hash) {
|
||||||
if (mp->m_dentry == dentry) {
|
if (mp->m_dentry == dentry) {
|
||||||
@ -626,14 +627,12 @@ static struct mountpoint *new_mountpoint(struct dentry *dentry)
|
|||||||
if (!mp)
|
if (!mp)
|
||||||
return ERR_PTR(-ENOMEM);
|
return ERR_PTR(-ENOMEM);
|
||||||
|
|
||||||
spin_lock(&dentry->d_lock);
|
ret = d_set_mounted(dentry);
|
||||||
if (d_unlinked(dentry)) {
|
if (ret) {
|
||||||
spin_unlock(&dentry->d_lock);
|
|
||||||
kfree(mp);
|
kfree(mp);
|
||||||
return ERR_PTR(-ENOENT);
|
return ERR_PTR(ret);
|
||||||
}
|
}
|
||||||
dentry->d_flags |= DCACHE_MOUNTED;
|
|
||||||
spin_unlock(&dentry->d_lock);
|
|
||||||
mp->m_dentry = dentry;
|
mp->m_dentry = dentry;
|
||||||
mp->m_count = 1;
|
mp->m_count = 1;
|
||||||
list_add(&mp->m_hash, chain);
|
list_add(&mp->m_hash, chain);
|
||||||
|
@ -1135,14 +1135,13 @@ out_zap_parent:
|
|||||||
if (inode && S_ISDIR(inode->i_mode)) {
|
if (inode && S_ISDIR(inode->i_mode)) {
|
||||||
/* Purge readdir caches. */
|
/* Purge readdir caches. */
|
||||||
nfs_zap_caches(inode);
|
nfs_zap_caches(inode);
|
||||||
/* If we have submounts, don't unhash ! */
|
|
||||||
if (have_submounts(dentry))
|
|
||||||
goto out_valid;
|
|
||||||
if (dentry->d_flags & DCACHE_DISCONNECTED)
|
if (dentry->d_flags & DCACHE_DISCONNECTED)
|
||||||
goto out_valid;
|
goto out_valid;
|
||||||
shrink_dcache_parent(dentry);
|
|
||||||
}
|
}
|
||||||
d_drop(dentry);
|
/* If we have submounts, don't unhash ! */
|
||||||
|
if (check_submounts_and_drop(dentry) != 0)
|
||||||
|
goto out_valid;
|
||||||
|
|
||||||
dput(parent);
|
dput(parent);
|
||||||
dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
|
dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
|
||||||
__func__, dentry->d_parent->d_name.name,
|
__func__, dentry->d_parent->d_name.name,
|
||||||
|
@ -297,7 +297,6 @@ static int sysfs_dentry_delete(const struct dentry *dentry)
|
|||||||
static int sysfs_dentry_revalidate(struct dentry *dentry, unsigned int flags)
|
static int sysfs_dentry_revalidate(struct dentry *dentry, unsigned int flags)
|
||||||
{
|
{
|
||||||
struct sysfs_dirent *sd;
|
struct sysfs_dirent *sd;
|
||||||
int is_dir;
|
|
||||||
int type;
|
int type;
|
||||||
|
|
||||||
if (flags & LOOKUP_RCU)
|
if (flags & LOOKUP_RCU)
|
||||||
@ -341,18 +340,15 @@ out_bad:
|
|||||||
* is performed at its new name the dentry will be readded
|
* is performed at its new name the dentry will be readded
|
||||||
* to the dcache hashes.
|
* to the dcache hashes.
|
||||||
*/
|
*/
|
||||||
is_dir = (sysfs_type(sd) == SYSFS_DIR);
|
|
||||||
mutex_unlock(&sysfs_mutex);
|
mutex_unlock(&sysfs_mutex);
|
||||||
if (is_dir) {
|
|
||||||
/* If we have submounts we must allow the vfs caches
|
/* If we have submounts we must allow the vfs caches
|
||||||
* to lie about the state of the filesystem to prevent
|
* to lie about the state of the filesystem to prevent
|
||||||
* leaks and other nasty things.
|
* leaks and other nasty things.
|
||||||
*/
|
*/
|
||||||
if (have_submounts(dentry))
|
if (check_submounts_and_drop(dentry) != 0)
|
||||||
goto out_valid;
|
goto out_valid;
|
||||||
shrink_dcache_parent(dentry);
|
|
||||||
}
|
|
||||||
d_drop(dentry);
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -212,7 +212,7 @@ struct dentry_operations {
|
|||||||
|
|
||||||
extern seqlock_t rename_lock;
|
extern seqlock_t rename_lock;
|
||||||
|
|
||||||
static inline int dname_external(struct dentry *dentry)
|
static inline int dname_external(const struct dentry *dentry)
|
||||||
{
|
{
|
||||||
return dentry->d_name.name != dentry->d_iname;
|
return dentry->d_name.name != dentry->d_iname;
|
||||||
}
|
}
|
||||||
@ -253,6 +253,7 @@ extern void d_prune_aliases(struct inode *);
|
|||||||
|
|
||||||
/* test whether we have any submounts in a subdir tree */
|
/* test whether we have any submounts in a subdir tree */
|
||||||
extern int have_submounts(struct dentry *);
|
extern int have_submounts(struct dentry *);
|
||||||
|
extern int check_submounts_and_drop(struct dentry *);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* This adds the entry to the hash queues.
|
* This adds the entry to the hash queues.
|
||||||
@ -357,17 +358,17 @@ extern struct dentry *dget_parent(struct dentry *dentry);
|
|||||||
* Returns true if the dentry passed is not currently hashed.
|
* Returns true if the dentry passed is not currently hashed.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
static inline int d_unhashed(struct dentry *dentry)
|
static inline int d_unhashed(const struct dentry *dentry)
|
||||||
{
|
{
|
||||||
return hlist_bl_unhashed(&dentry->d_hash);
|
return hlist_bl_unhashed(&dentry->d_hash);
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline int d_unlinked(struct dentry *dentry)
|
static inline int d_unlinked(const struct dentry *dentry)
|
||||||
{
|
{
|
||||||
return d_unhashed(dentry) && !IS_ROOT(dentry);
|
return d_unhashed(dentry) && !IS_ROOT(dentry);
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline int cant_mount(struct dentry *dentry)
|
static inline int cant_mount(const struct dentry *dentry)
|
||||||
{
|
{
|
||||||
return (dentry->d_flags & DCACHE_CANT_MOUNT);
|
return (dentry->d_flags & DCACHE_CANT_MOUNT);
|
||||||
}
|
}
|
||||||
@ -381,12 +382,12 @@ static inline void dont_mount(struct dentry *dentry)
|
|||||||
|
|
||||||
extern void dput(struct dentry *);
|
extern void dput(struct dentry *);
|
||||||
|
|
||||||
static inline bool d_managed(struct dentry *dentry)
|
static inline bool d_managed(const struct dentry *dentry)
|
||||||
{
|
{
|
||||||
return dentry->d_flags & DCACHE_MANAGED_DENTRY;
|
return dentry->d_flags & DCACHE_MANAGED_DENTRY;
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline bool d_mountpoint(struct dentry *dentry)
|
static inline bool d_mountpoint(const struct dentry *dentry)
|
||||||
{
|
{
|
||||||
return dentry->d_flags & DCACHE_MOUNTED;
|
return dentry->d_flags & DCACHE_MOUNTED;
|
||||||
}
|
}
|
||||||
|
Loading…
Reference in New Issue
Block a user