@@ -526,6 +526,8 @@ static inline void dentry_unlist(struct dentry *dentry, struct dentry *parent)
if (unlikely(list_empty(&dentry->d_child)))
return;
__list_del_entry(&dentry->d_child);
+ parent->d_nchildren--;
+
/*
* Cursors can move around the list of children. While we'd been
* a normal list member, it didn't matter - ->d_child.next would've
@@ -1738,6 +1740,7 @@ static struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
dentry->d_sb = sb;
dentry->d_op = NULL;
dentry->d_fsdata = NULL;
+ dentry->d_nchildren = 0;
INIT_HLIST_BL_NODE(&dentry->d_hash);
INIT_LIST_HEAD(&dentry->d_lru);
INIT_LIST_HEAD(&dentry->d_subdirs);
@@ -1782,6 +1785,7 @@ struct dentry *d_alloc(struct dentry * parent, const struct qstr *name)
__dget_dlock(parent);
dentry->d_parent = parent;
list_add(&dentry->d_child, &parent->d_subdirs);
+ parent->d_nchildren++;
spin_unlock(&parent->d_lock);
return dentry;
@@ -2762,10 +2766,10 @@ static void swap_names(struct dentry *dentry, struct dentry *target)
* Both are internal.
*/
unsigned int i;
- BUILD_BUG_ON(!IS_ALIGNED(DNAME_INLINE_LEN, sizeof(long)));
- for (i = 0; i < DNAME_INLINE_LEN / sizeof(long); i++) {
- swap(((long *) &dentry->d_iname)[i],
- ((long *) &target->d_iname)[i]);
+ BUILD_BUG_ON(!IS_ALIGNED(DNAME_INLINE_LEN, sizeof(int)));
+ for (i = 0; i < DNAME_INLINE_LEN / sizeof(int); i++) {
+ swap(((int *) &dentry->d_iname)[i],
+ ((int *) &target->d_iname)[i]);
}
}
}
@@ -2855,6 +2859,10 @@ static void __d_move(struct dentry *dentry, struct dentry *target,
dentry->d_parent->d_lockref.count++;
if (dentry != old_parent) /* wasn't IS_ROOT */
WARN_ON(!--old_parent->d_lockref.count);
+
+ /* Adjust d_nchildren */
+ dentry->d_parent->d_nchildren++;
+ old_parent->d_nchildren--;
} else {
target->d_parent = old_parent;
swap_names(dentry, target);
@@ -75,12 +75,12 @@ extern struct dentry_stat_t dentry_stat;
* large memory footprint increase).
*/
#ifdef CONFIG_64BIT
-# define DNAME_INLINE_LEN 32 /* 192 bytes */
+# define DNAME_INLINE_LEN 28 /* 192 bytes */
#else
# ifdef CONFIG_SMP
-# define DNAME_INLINE_LEN 36 /* 128 bytes */
+# define DNAME_INLINE_LEN 32 /* 128 bytes */
# else
-# define DNAME_INLINE_LEN 40 /* 128 bytes */
+# define DNAME_INLINE_LEN 36 /* 128 bytes */
# endif
#endif
@@ -96,6 +96,7 @@ struct dentry {
struct inode *d_inode; /* Where the name belongs to - NULL is
* negative */
unsigned char d_iname[DNAME_INLINE_LEN]; /* small names */
+ unsigned int d_nchildren; /* # of children (directory only) */
/* Ref lookup also touches following */
struct lockref d_lockref; /* per-dentry lock and refcount */
Add a new field d_nchildren to struct dentry to track the number of children in a directory. Theoretically, we could use reference count (d_lockref.count) as a proxy for the number of children. Normally the reference count should be quite close to the number of children. However, when the directory dentry is heavily contended, the reference count can differ from the number of children by quite a bit. The d_nchildren field is updated only when d_lock has already been held, so the performance cost of this tracking should be negligible. Signed-off-by: Waiman Long <longman@redhat.com> --- fs/dcache.c | 16 ++++++++++++---- include/linux/dcache.h | 7 ++++--- 2 files changed, 16 insertions(+), 7 deletions(-)