mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-11-01 17:08:10 +00:00
Code Issues Releases Wiki Activity

kernfs: use VFS negative dentry caching

Browse source 
If there are many lookups for non-existent paths these negative lookups
can lead to a lot of overhead during path walks.

The VFS allows dentries to be created as negative and hashed, and caches
them so they can be used to reduce the fairly high overhead alloc/free
cycle that occurs during these lookups.

Use the kernfs node parent revision to identify if a change has been
made to the containing directory so that the negative dentry can be
discarded and the lookup redone.

Reviewed-by: Miklos Szeredi <mszeredi@redhat.com>
Signed-off-by: Ian Kent <raven@themaw.net>
Link: https://lore.kernel.org/r/162642770420.63632.15791924970508867106.stgit@web.messagingengine.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Ian Kent 2021-07-16 17:28:24 +08:00 committed by Greg Kroah-Hartman
parent 895adbec30
commit c7e7c04274
1 changed files with 35 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

53
fs/kernfs/dir.c
View file

@ -1039,9 +1039,31 @@ static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags)
if (flags & LOOKUP_RCU) if (flags & LOOKUP_RCU)
return -ECHILD; return -ECHILD;
/* Always perform fresh lookup for negatives */ /* Negative hashed dentry? */
if (d_really_is_negative(dentry)) if (d_really_is_negative(dentry)) {
goto out_bad_unlocked; struct kernfs_node *parent;
/* If the kernfs parent node has changed discard and
* proceed to ->lookup.
*/
mutex_lock(&kernfs_mutex);
spin_lock(&dentry->d_lock);
parent = kernfs_dentry_node(dentry->d_parent);
if (parent) {
if (kernfs_dir_changed(parent, dentry)) {
spin_unlock(&dentry->d_lock);
mutex_unlock(&kernfs_mutex);
return 0;
}
}
spin_unlock(&dentry->d_lock);
mutex_unlock(&kernfs_mutex);
/* The kernfs parent node hasn't changed, leave the
* dentry negative and return success.
*/
return 1;
}
kn = kernfs_dentry_node(dentry); kn = kernfs_dentry_node(dentry);
mutex_lock(&kernfs_mutex); mutex_lock(&kernfs_mutex);
@ -1067,7 +1089,6 @@ static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags)
return 1; return 1;
out_bad: out_bad:
mutex_unlock(&kernfs_mutex); mutex_unlock(&kernfs_mutex);
out_bad_unlocked:
return 0; return 0;
} }
@ -1082,33 +1103,27 @@ static struct dentry *kernfs_iop_lookup(struct inode *dir,
struct dentry *ret; struct dentry *ret;
struct kernfs_node *parent = dir->i_private; struct kernfs_node *parent = dir->i_private;
struct kernfs_node *kn; struct kernfs_node *kn;
struct inode *inode; struct inode *inode = NULL;
const void *ns = NULL; const void *ns = NULL;
mutex_lock(&kernfs_mutex); mutex_lock(&kernfs_mutex);
if (kernfs_ns_enabled(parent)) if (kernfs_ns_enabled(parent))
ns = kernfs_info(dir->i_sb)->ns; ns = kernfs_info(dir->i_sb)->ns;
kn = kernfs_find_ns(parent, dentry->d_name.name, ns); kn = kernfs_find_ns(parent, dentry->d_name.name, ns);
/* no such entry */
if (!kn || !kernfs_active(kn)) {
ret = NULL;
goto out_unlock;
}
/* attach dentry and inode */ /* attach dentry and inode */
if (kn && kernfs_active(kn)) {
inode = kernfs_get_inode(dir->i_sb, kn); inode = kernfs_get_inode(dir->i_sb, kn);
if (!inode) { if (!inode)
ret = ERR_PTR(-ENOMEM); inode = ERR_PTR(-ENOMEM);
goto out_unlock;
} }
/* Needed only for negative dentry validation */
/* instantiate and hash dentry */ if (!inode)
kernfs_set_rev(parent, dentry);
/* instantiate and hash (possibly negative) dentry */
ret = d_splice_alias(inode, dentry); ret = d_splice_alias(inode, dentry);
out_unlock:
mutex_unlock(&kernfs_mutex); mutex_unlock(&kernfs_mutex);
return ret; return ret;
} }