| Message ID | 1535476780-5773-2-git-send-email-longman@redhat.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | fs/dcache: Track # of negative dentries | expand |
On Tue, Aug 28, 2018 at 01:19:39PM -0400, Waiman Long wrote: > The current dentry number tracking code doesn't distinguish between > positive & negative dentries. It just reports the total number of > dentries in the LRU lists. > > As excessive number of negative dentries can have an impact on system > performance, it will be wise to track the number of positive and > negative dentries separately. > > This patch adds tracking for the total number of negative dentries in > the system LRU lists and reports it in the /proc/sys/fs/dentry-state > file. The number, however, does not include negative dentries that are > in flight but not in the LRU yet. > > The number of positive dentries in the LRU lists can be roughly found > by subtracting the number of negative dentries from the total. > > Signed-off-by: Waiman Long <longman@redhat.com> > --- > Documentation/sysctl/fs.txt | 19 +++++++++++++------ > fs/dcache.c | 45 +++++++++++++++++++++++++++++++++++++++++++++ > include/linux/dcache.h | 7 ++++--- > 3 files changed, 62 insertions(+), 9 deletions(-) > > diff --git a/Documentation/sysctl/fs.txt b/Documentation/sysctl/fs.txt > index 819caf8..118bb93 100644 > --- a/Documentation/sysctl/fs.txt > +++ b/Documentation/sysctl/fs.txt > @@ -63,19 +63,26 @@ struct { > int nr_unused; > int age_limit; /* age in seconds */ > int want_pages; /* pages requested by system */ > - int dummy[2]; > + int nr_negative; /* # of unused negative dentries */ > + int dummy; > } dentry_stat = {0, 0, 45, 0,}; That's not a backwards compatible ABI change. Those dummy fields used to represent some metric we no longer calculate, and there are probably still monitoring apps out there that think they still have the old meaning. i.e. they are still visible to userspace: $ cat /proc/sys/fs/dentry-state 83090 67661 45 0 0 0 $ IOWs, you can add new fields for new metrics to the end of the structure, but you can't re-use existing fields even if they aren't calculated anymore. [....] > @@ -214,6 +226,28 @@ static inline int dentry_string_cmp(const unsigned char *cs, const unsigned char > > #endif > > +static inline void __neg_dentry_dec(struct dentry *dentry) > +{ > + this_cpu_dec(nr_dentry_neg); > +} > + > +static inline void neg_dentry_dec(struct dentry *dentry) > +{ > + if (unlikely(d_is_negative(dentry))) > + __neg_dentry_dec(dentry); unlikely() considered harmful. The workload you are trying to optimise is whe negative dentries are the common case. IOWs, static branch prediction hints like this will be wrong exactly when we want the branch to be predicted correctly by the hardware. > +} > + > +static inline void __neg_dentry_inc(struct dentry *dentry) > +{ > + this_cpu_inc(nr_dentry_neg); > +} > + > +static inline void neg_dentry_inc(struct dentry *dentry) > +{ > + if (unlikely(d_is_negative(dentry))) > + __neg_dentry_inc(dentry); > +} These wrappers obfuscate the code - they do not do what the name suggests and instead are conditional on dentry state. I'd just open code this stuff - the code is much better without the wrappers. > + > static inline int dentry_cmp(const struct dentry *dentry, const unsigned char *ct, unsigned tcount) > { > /* > @@ -331,6 +365,8 @@ static inline void __d_clear_type_and_inode(struct dentry *dentry) > flags &= ~(DCACHE_ENTRY_TYPE | DCACHE_FALLTHRU); > WRITE_ONCE(dentry->d_flags, flags); > dentry->d_inode = NULL; > + if (dentry->d_flags & DCACHE_LRU_LIST) > + __neg_dentry_inc(dentry); > } > > static void dentry_free(struct dentry *dentry) > @@ -395,6 +431,7 @@ static void d_lru_add(struct dentry *dentry) > dentry->d_flags |= DCACHE_LRU_LIST; > this_cpu_inc(nr_dentry_unused); > WARN_ON_ONCE(!list_lru_add(&dentry->d_sb->s_dentry_lru, &dentry->d_lru)); > + neg_dentry_inc(dentry); Like this - why on earth would we increment the negative dentry count for every dentry that is added to LRU? Open coding this_cpu_inc(nr_dentry_unused); + if (d_is_negative(dentry)) + this_cpu_inc(nr_dentry_neg); WARN_ON_ONCE(!list_lru_add(&dentry->d_sb->s_dentry_lru, &dentry->d_lru)); That's obvious to the reader what we are doing, and it aggregates all the accounting in a single location. Same for the rest of the code. Cheers, Dave.
On 08/28/2018 08:11 PM, Dave Chinner wrote: > On Tue, Aug 28, 2018 at 01:19:39PM -0400, Waiman Long wrote: >> The current dentry number tracking code doesn't distinguish between >> positive & negative dentries. It just reports the total number of >> dentries in the LRU lists. >> >> As excessive number of negative dentries can have an impact on system >> performance, it will be wise to track the number of positive and >> negative dentries separately. >> >> This patch adds tracking for the total number of negative dentries in >> the system LRU lists and reports it in the /proc/sys/fs/dentry-state >> file. The number, however, does not include negative dentries that are >> in flight but not in the LRU yet. >> >> The number of positive dentries in the LRU lists can be roughly found >> by subtracting the number of negative dentries from the total. >> >> Signed-off-by: Waiman Long <longman@redhat.com> >> --- >> Documentation/sysctl/fs.txt | 19 +++++++++++++------ >> fs/dcache.c | 45 +++++++++++++++++++++++++++++++++++++++++++++ >> include/linux/dcache.h | 7 ++++--- >> 3 files changed, 62 insertions(+), 9 deletions(-) >> >> diff --git a/Documentation/sysctl/fs.txt b/Documentation/sysctl/fs.txt >> index 819caf8..118bb93 100644 >> --- a/Documentation/sysctl/fs.txt >> +++ b/Documentation/sysctl/fs.txt >> @@ -63,19 +63,26 @@ struct { >> int nr_unused; >> int age_limit; /* age in seconds */ >> int want_pages; /* pages requested by system */ >> - int dummy[2]; >> + int nr_negative; /* # of unused negative dentries */ >> + int dummy; >> } dentry_stat = {0, 0, 45, 0,}; > That's not a backwards compatible ABI change. Those dummy fields > used to represent some metric we no longer calculate, and there are > probably still monitoring apps out there that think they still have > the old meaning. i.e. they are still visible to userspace: > > $ cat /proc/sys/fs/dentry-state > 83090 67661 45 0 0 0 > $ > > IOWs, you can add new fields for new metrics to the end of the > structure, but you can't re-use existing fields even if they > aren't calculated anymore. > > [....] I looked up the git history and the state of the dentry_stat structure hadn't changed since it was first put into git in 2.6.12-rc2 on Apr 16, 2005. That was over 13 years ago. Even adding an extra argument can have the potential of breaking old applications depending on how the parsing code was written. Given that systems that are still using some very old tools are not likely to upgrade to the latest kernel anyway. I don't see that as a big problem. >> @@ -214,6 +226,28 @@ static inline int dentry_string_cmp(const unsigned char *cs, const unsigned char >> >> #endif >> >> +static inline void __neg_dentry_dec(struct dentry *dentry) >> +{ >> + this_cpu_dec(nr_dentry_neg); >> +} >> + >> +static inline void neg_dentry_dec(struct dentry *dentry) >> +{ >> + if (unlikely(d_is_negative(dentry))) >> + __neg_dentry_dec(dentry); > unlikely() considered harmful. > > The workload you are trying to optimise is whe negative dentries are > the common case. IOWs, static branch prediction hints like this will > be wrong exactly when we want the branch to be predicted correctly > by the hardware. You are right. I will remove the branch hints. >> +} >> + >> +static inline void __neg_dentry_inc(struct dentry *dentry) >> +{ >> + this_cpu_inc(nr_dentry_neg); >> +} >> + >> +static inline void neg_dentry_inc(struct dentry *dentry) >> +{ >> + if (unlikely(d_is_negative(dentry))) >> + __neg_dentry_inc(dentry); >> +} > These wrappers obfuscate the code - they do not do what the > name suggests and instead are conditional on dentry state. > > I'd just open code this stuff - the code is much better without > the wrappers. Sure. I will open code the counter updates. >> + >> static inline int dentry_cmp(const struct dentry *dentry, const unsigned char *ct, unsigned tcount) >> { >> /* >> @@ -331,6 +365,8 @@ static inline void __d_clear_type_and_inode(struct dentry *dentry) >> flags &= ~(DCACHE_ENTRY_TYPE | DCACHE_FALLTHRU); >> WRITE_ONCE(dentry->d_flags, flags); >> dentry->d_inode = NULL; >> + if (dentry->d_flags & DCACHE_LRU_LIST) >> + __neg_dentry_inc(dentry); >> } >> >> static void dentry_free(struct dentry *dentry) >> @@ -395,6 +431,7 @@ static void d_lru_add(struct dentry *dentry) >> dentry->d_flags |= DCACHE_LRU_LIST; >> this_cpu_inc(nr_dentry_unused); >> WARN_ON_ONCE(!list_lru_add(&dentry->d_sb->s_dentry_lru, &dentry->d_lru)); >> + neg_dentry_inc(dentry); > Like this - why on earth would we increment the negative dentry > count for every dentry that is added to LRU? Open coding > > this_cpu_inc(nr_dentry_unused); > + if (d_is_negative(dentry)) > + this_cpu_inc(nr_dentry_neg); > WARN_ON_ONCE(!list_lru_add(&dentry->d_sb->s_dentry_lru, &dentry->d_lru)); > > That's obvious to the reader what we are doing, and it aggregates > all the accounting in a single location. Same for the rest of the > code. > > Cheers, > > Dave. Cheers, Longman
On Wed, Aug 29, 2018 at 01:11:08PM -0400, Waiman Long wrote: > On 08/28/2018 08:11 PM, Dave Chinner wrote: > > On Tue, Aug 28, 2018 at 01:19:39PM -0400, Waiman Long wrote: > >> The current dentry number tracking code doesn't distinguish between > >> positive & negative dentries. It just reports the total number of > >> dentries in the LRU lists. > >> > >> As excessive number of negative dentries can have an impact on system > >> performance, it will be wise to track the number of positive and > >> negative dentries separately. > >> > >> This patch adds tracking for the total number of negative dentries in > >> the system LRU lists and reports it in the /proc/sys/fs/dentry-state > >> file. The number, however, does not include negative dentries that are > >> in flight but not in the LRU yet. > >> > >> The number of positive dentries in the LRU lists can be roughly found > >> by subtracting the number of negative dentries from the total. > >> > >> Signed-off-by: Waiman Long <longman@redhat.com> > >> --- > >> Documentation/sysctl/fs.txt | 19 +++++++++++++------ > >> fs/dcache.c | 45 +++++++++++++++++++++++++++++++++++++++++++++ > >> include/linux/dcache.h | 7 ++++--- > >> 3 files changed, 62 insertions(+), 9 deletions(-) > >> > >> diff --git a/Documentation/sysctl/fs.txt b/Documentation/sysctl/fs.txt > >> index 819caf8..118bb93 100644 > >> --- a/Documentation/sysctl/fs.txt > >> +++ b/Documentation/sysctl/fs.txt > >> @@ -63,19 +63,26 @@ struct { > >> int nr_unused; > >> int age_limit; /* age in seconds */ > >> int want_pages; /* pages requested by system */ > >> - int dummy[2]; > >> + int nr_negative; /* # of unused negative dentries */ > >> + int dummy; > >> } dentry_stat = {0, 0, 45, 0,}; > > That's not a backwards compatible ABI change. Those dummy fields > > used to represent some metric we no longer calculate, and there are > > probably still monitoring apps out there that think they still have > > the old meaning. i.e. they are still visible to userspace: > > > > $ cat /proc/sys/fs/dentry-state > > 83090 67661 45 0 0 0 > > $ > > > > IOWs, you can add new fields for new metrics to the end of the > > structure, but you can't re-use existing fields even if they > > aren't calculated anymore. > > > > [....] > > I looked up the git history and the state of the dentry_stat structure > hadn't changed since it was first put into git in 2.6.12-rc2 on Apr 16, > 2005. That was over 13 years ago. Even adding an extra argument can have > the potential of breaking old applications depending on how the parsing > code was written. I'm pretty we've had this discussion many times before w.r.t. /proc/self/mount* and other multi-field proc files. IIRC, The answer has always been that it's OK to extend lines with new fields as existing apps /should/ ignore them, but it's not OK to remove or redefine existing fields in the line because existing apps /will/ misinterpret what that field means. > Given that systems that are still using some very old tools are not > likely to upgrade to the latest kernel anyway. I don't see that as a big > problem. I don't think that matters when it comes to changing what information we expose in proc files. Cheers, Dave.
On 08/29/2018 09:43 PM, Dave Chinner wrote: > On Wed, Aug 29, 2018 at 01:11:08PM -0400, Waiman Long wrote: >> On 08/28/2018 08:11 PM, Dave Chinner wrote: >>> On Tue, Aug 28, 2018 at 01:19:39PM -0400, Waiman Long wrote: >>>> The current dentry number tracking code doesn't distinguish between >>>> positive & negative dentries. It just reports the total number of >>>> dentries in the LRU lists. >>>> >>>> As excessive number of negative dentries can have an impact on system >>>> performance, it will be wise to track the number of positive and >>>> negative dentries separately. >>>> >>>> This patch adds tracking for the total number of negative dentries in >>>> the system LRU lists and reports it in the /proc/sys/fs/dentry-state >>>> file. The number, however, does not include negative dentries that are >>>> in flight but not in the LRU yet. >>>> >>>> The number of positive dentries in the LRU lists can be roughly found >>>> by subtracting the number of negative dentries from the total. >>>> >>>> Signed-off-by: Waiman Long <longman@redhat.com> >>>> --- >>>> Documentation/sysctl/fs.txt | 19 +++++++++++++------ >>>> fs/dcache.c | 45 +++++++++++++++++++++++++++++++++++++++++++++ >>>> include/linux/dcache.h | 7 ++++--- >>>> 3 files changed, 62 insertions(+), 9 deletions(-) >>>> >>>> diff --git a/Documentation/sysctl/fs.txt b/Documentation/sysctl/fs.txt >>>> index 819caf8..118bb93 100644 >>>> --- a/Documentation/sysctl/fs.txt >>>> +++ b/Documentation/sysctl/fs.txt >>>> @@ -63,19 +63,26 @@ struct { >>>> int nr_unused; >>>> int age_limit; /* age in seconds */ >>>> int want_pages; /* pages requested by system */ >>>> - int dummy[2]; >>>> + int nr_negative; /* # of unused negative dentries */ >>>> + int dummy; >>>> } dentry_stat = {0, 0, 45, 0,}; >>> That's not a backwards compatible ABI change. Those dummy fields >>> used to represent some metric we no longer calculate, and there are >>> probably still monitoring apps out there that think they still have >>> the old meaning. i.e. they are still visible to userspace: >>> >>> $ cat /proc/sys/fs/dentry-state >>> 83090 67661 45 0 0 0 >>> $ >>> >>> IOWs, you can add new fields for new metrics to the end of the >>> structure, but you can't re-use existing fields even if they >>> aren't calculated anymore. >>> >>> [....] >> I looked up the git history and the state of the dentry_stat structure >> hadn't changed since it was first put into git in 2.6.12-rc2 on Apr 16, >> 2005. That was over 13 years ago. Even adding an extra argument can have >> the potential of breaking old applications depending on how the parsing >> code was written. > I'm pretty we've had this discussion many times before w.r.t. > /proc/self/mount* and other multi-field proc files. > > IIRC, The answer has always been that it's OK to extend lines with > new fields as existing apps /should/ ignore them, but it's not OK to > remove or redefine existing fields in the line because existing apps > /will/ misinterpret what that field means. > >> Given that systems that are still using some very old tools are not >> likely to upgrade to the latest kernel anyway. I don't see that as a big >> problem. > I don't think that matters when it comes to changing what > information we expose in proc files. > > Cheers, > > Dave. I am not against appending the new count to the end. I just want to make sure that it is the right thing to do. Cheers, Longman
On Wed, Aug 29, 2018 at 10:11:53AM +1000, Dave Chinner wrote: > > +++ b/Documentation/sysctl/fs.txt > > @@ -63,19 +63,26 @@ struct { > > int nr_unused; > > int age_limit; /* age in seconds */ > > int want_pages; /* pages requested by system */ > > - int dummy[2]; > > + int nr_negative; /* # of unused negative dentries */ > > + int dummy; > > } dentry_stat = {0, 0, 45, 0,}; > > That's not a backwards compatible ABI change. Those dummy fields > used to represent some metric we no longer calculate, and there are > probably still monitoring apps out there that think they still have > the old meaning. i.e. they are still visible to userspace: I believe you are incorrect. dentry_stat was introduced in 2.1.60 with this hunk: +struct { + int nr_dentry; + int nr_unused; + int age_limit; /* age in seconds */ + int want_pages; /* pages requested by system */ + int dummy[2]; +} dentry_stat = {0, 0, 45, 0,}; + Looking through the rest of the dentry_stat changes in the 2.1.60 release, it's not replacing anything, it's adding new information.
On 08/31/2018 10:31 AM, Matthew Wilcox wrote: > On Wed, Aug 29, 2018 at 10:11:53AM +1000, Dave Chinner wrote: >>> +++ b/Documentation/sysctl/fs.txt >>> @@ -63,19 +63,26 @@ struct { >>> int nr_unused; >>> int age_limit; /* age in seconds */ >>> int want_pages; /* pages requested by system */ >>> - int dummy[2]; >>> + int nr_negative; /* # of unused negative dentries */ >>> + int dummy; >>> } dentry_stat = {0, 0, 45, 0,}; >> That's not a backwards compatible ABI change. Those dummy fields >> used to represent some metric we no longer calculate, and there are >> probably still monitoring apps out there that think they still have >> the old meaning. i.e. they are still visible to userspace: > I believe you are incorrect. dentry_stat was introduced in 2.1.60 with > this hunk: > > +struct { > + int nr_dentry; > + int nr_unused; > + int age_limit; /* age in seconds */ > + int want_pages; /* pages requested by system */ > + int dummy[2]; > +} dentry_stat = {0, 0, 45, 0,}; > + > > Looking through the rest of the dentry_stat changes in the 2.1.60 release, > it's not replacing anything, it's adding new information. Thanks for looking up earlier non-git source tree. If that is the case, the dummy[2] was there just for future extension purpose. It should be perfectly fine to reuse one of the dummy entry for negative dentry count then as no sane application would have checked the last 2 entries of dentry-state and do dummy things if they are non-zero. Cheers, Longman
diff --git a/Documentation/sysctl/fs.txt b/Documentation/sysctl/fs.txt index 819caf8..118bb93 100644 --- a/Documentation/sysctl/fs.txt +++ b/Documentation/sysctl/fs.txt @@ -63,19 +63,26 @@ struct { int nr_unused; int age_limit; /* age in seconds */ int want_pages; /* pages requested by system */ - int dummy[2]; + int nr_negative; /* # of unused negative dentries */ + int dummy; } dentry_stat = {0, 0, 45, 0,}; --------------------------------------------------------------- +-------------------------------------------------------------- + +Dentries are dynamically allocated and deallocated. + +nr_dentry shows the total number of dentries allocated (active ++ unused). nr_unused shows the number of dentries that are not +actively used, but are saved in the LRU list for future reuse. -Dentries are dynamically allocated and deallocated, and -nr_dentry seems to be 0 all the time. Hence it's safe to -assume that only nr_unused, age_limit and want_pages are -used. Nr_unused seems to be exactly what its name says. Age_limit is the age in seconds after which dcache entries can be reclaimed when memory is short and want_pages is nonzero when shrink_dcache_pages() has been called and the dcache isn't pruned yet. +nr_negative shows the number of unused dentries that are also +negative dentries which do not mapped to actual files if negative +dentries tracking is enabled. + ============================================================== dquot-max & dquot-nr: diff --git a/fs/dcache.c b/fs/dcache.c index 2e7e8d8..69f5541 100644 --- a/fs/dcache.c +++ b/fs/dcache.c @@ -119,6 +119,7 @@ struct dentry_stat_t dentry_stat = { static DEFINE_PER_CPU(long, nr_dentry); static DEFINE_PER_CPU(long, nr_dentry_unused); +static DEFINE_PER_CPU(long, nr_dentry_neg); #if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS) @@ -152,11 +153,22 @@ static long get_nr_dentry_unused(void) return sum < 0 ? 0 : sum; } +static long get_nr_dentry_neg(void) +{ + int i; + long sum = 0; + + for_each_possible_cpu(i) + sum += per_cpu(nr_dentry_neg, i); + return sum < 0 ? 0 : sum; +} + int proc_nr_dentry(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos) { dentry_stat.nr_dentry = get_nr_dentry(); dentry_stat.nr_unused = get_nr_dentry_unused(); + dentry_stat.nr_negative = get_nr_dentry_neg(); return proc_doulongvec_minmax(table, write, buffer, lenp, ppos); } #endif @@ -214,6 +226,28 @@ static inline int dentry_string_cmp(const unsigned char *cs, const unsigned char #endif +static inline void __neg_dentry_dec(struct dentry *dentry) +{ + this_cpu_dec(nr_dentry_neg); +} + +static inline void neg_dentry_dec(struct dentry *dentry) +{ + if (unlikely(d_is_negative(dentry))) + __neg_dentry_dec(dentry); +} + +static inline void __neg_dentry_inc(struct dentry *dentry) +{ + this_cpu_inc(nr_dentry_neg); +} + +static inline void neg_dentry_inc(struct dentry *dentry) +{ + if (unlikely(d_is_negative(dentry))) + __neg_dentry_inc(dentry); +} + static inline int dentry_cmp(const struct dentry *dentry, const unsigned char *ct, unsigned tcount) { /* @@ -331,6 +365,8 @@ static inline void __d_clear_type_and_inode(struct dentry *dentry) flags &= ~(DCACHE_ENTRY_TYPE | DCACHE_FALLTHRU); WRITE_ONCE(dentry->d_flags, flags); dentry->d_inode = NULL; + if (dentry->d_flags & DCACHE_LRU_LIST) + __neg_dentry_inc(dentry); } static void dentry_free(struct dentry *dentry) @@ -395,6 +431,7 @@ static void d_lru_add(struct dentry *dentry) dentry->d_flags |= DCACHE_LRU_LIST; this_cpu_inc(nr_dentry_unused); WARN_ON_ONCE(!list_lru_add(&dentry->d_sb->s_dentry_lru, &dentry->d_lru)); + neg_dentry_inc(dentry); } static void d_lru_del(struct dentry *dentry) @@ -403,6 +440,7 @@ static void d_lru_del(struct dentry *dentry) dentry->d_flags &= ~DCACHE_LRU_LIST; this_cpu_dec(nr_dentry_unused); WARN_ON_ONCE(!list_lru_del(&dentry->d_sb->s_dentry_lru, &dentry->d_lru)); + neg_dentry_dec(dentry); } static void d_shrink_del(struct dentry *dentry) @@ -433,6 +471,7 @@ static void d_lru_isolate(struct list_lru_one *lru, struct dentry *dentry) dentry->d_flags &= ~DCACHE_LRU_LIST; this_cpu_dec(nr_dentry_unused); list_lru_isolate(lru, &dentry->d_lru); + neg_dentry_dec(dentry); } static void d_lru_shrink_move(struct list_lru_one *lru, struct dentry *dentry, @@ -441,6 +480,7 @@ static void d_lru_shrink_move(struct list_lru_one *lru, struct dentry *dentry, D_FLAG_VERIFY(dentry, DCACHE_LRU_LIST); dentry->d_flags |= DCACHE_SHRINK_LIST; list_lru_isolate_move(lru, &dentry->d_lru, list); + neg_dentry_dec(dentry); } /** @@ -1840,6 +1880,11 @@ static void __d_instantiate(struct dentry *dentry, struct inode *inode) WARN_ON(d_in_lookup(dentry)); spin_lock(&dentry->d_lock); + /* + * Decrement negative dentry count if it was in the LRU list. + */ + if (dentry->d_flags & DCACHE_LRU_LIST) + __neg_dentry_dec(dentry); hlist_add_head(&dentry->d_u.d_alias, &inode->i_dentry); raw_write_seqcount_begin(&dentry->d_seq); __d_set_inode_and_type(dentry, inode, add_flags); diff --git a/include/linux/dcache.h b/include/linux/dcache.h index ef4b70f..df942e5 100644 --- a/include/linux/dcache.h +++ b/include/linux/dcache.h @@ -62,9 +62,10 @@ struct qstr { struct dentry_stat_t { long nr_dentry; long nr_unused; - long age_limit; /* age in seconds */ - long want_pages; /* pages requested by system */ - long dummy[2]; + long age_limit; /* age in seconds */ + long want_pages; /* pages requested by system */ + long nr_negative; /* # of unused negative dentries */ + long dummy; }; extern struct dentry_stat_t dentry_stat;
The current dentry number tracking code doesn't distinguish between positive & negative dentries. It just reports the total number of dentries in the LRU lists. As excessive number of negative dentries can have an impact on system performance, it will be wise to track the number of positive and negative dentries separately. This patch adds tracking for the total number of negative dentries in the system LRU lists and reports it in the /proc/sys/fs/dentry-state file. The number, however, does not include negative dentries that are in flight but not in the LRU yet. The number of positive dentries in the LRU lists can be roughly found by subtracting the number of negative dentries from the total. Signed-off-by: Waiman Long <longman@redhat.com> --- Documentation/sysctl/fs.txt | 19 +++++++++++++------ fs/dcache.c | 45 +++++++++++++++++++++++++++++++++++++++++++++ include/linux/dcache.h | 7 ++++--- 3 files changed, 62 insertions(+), 9 deletions(-)