SUNRPC/cache: Allow garbage collection of invalid cache entries
Subsystems (3)
PATCH 1/1 SUNRPC/cache: Allow garbage collection of invalid cache entries
If the cache entry never gets initialised, we want the garbage collector to be able to evict it. Otherwise if the upcall daemon fails to initialise the entry, we end up never expiring it.
--- include/linux/sunrpc/cache.h | 3 --- net/sunrpc/cache.c | 36 +++++++++++++++++++----------------- 2 files changed, 19 insertions(+), 20 deletions(-)
include/linux/sunrpc/cache.h +0 -3
@@ -202,9 +202,6 @@ static inline void cache_put(struct cache_head *h, struct cache_detail *cd)static inline bool cache_is_expired (struct cache_detail *detail,struct cache_head *h) { -if (!test_bit (CACHE_VALID , &h->flags)) -return false; -return (h->expiry_time <seconds_since_boot ()) || (detail->flush_time >= h->last_refresh); }
net/sunrpc/cache.c +19 -17
@@ -65,13 +65,14 @@ static struct cache_head *sunrpc_cache_find_rcu(struct cache_detail *detail,rcu_read_lock ();hlist_for_each_entry_rcu (tmp, head, cache_list) { -if (detail->match (tmp, key)) { -if (cache_is_expired (detail, tmp)) -continue ; - tmp =cache_get_rcu (tmp); -rcu_read_unlock (); -return tmp; - } +if (!detail->match (tmp, key)) +continue ; +if (test_bit (CACHE_VALID , &tmp->flags) && +cache_is_expired (detail, tmp)) +continue ; + tmp =cache_get_rcu (tmp); +rcu_read_unlock (); +return tmp; }rcu_read_unlock ();return NULL ;
@@ -114,17 +115,18 @@ static struct cache_head *sunrpc_cache_add_entry(struct cache_detail *detail,/* check if entry appeared while we slept */ hlist_for_each_entry_rcu (tmp, head, cache_list) { -if (detail->match (tmp, key)) { -if (cache_is_expired (detail, tmp)) { -sunrpc_begin_cache_remove_entry (tmp, detail); - freeme = tmp; -break ; - } -cache_get (tmp); -spin_unlock (&detail->hash_lock); -cache_put (new, detail); -return tmp; +if (!detail->match (tmp, key)) +continue ; +if (test_bit (CACHE_VALID , &tmp->flags) && +cache_is_expired (detail, tmp)) { +sunrpc_begin_cache_remove_entry (tmp, detail); + freeme = tmp; +break ; } +cache_get (tmp); +spin_unlock (&detail->hash_lock); +cache_put (new, detail); +return tmp; }hlist_add_head_rcu (&new->cache_list, head);
Signature · 1 line
2.24.1
Quoted 3 lines · Trond Myklebust
If the cache entry never gets initialised, we want the garbage collector to be able to evict it. Otherwise if the upcall daemon fails to initialise the entry, we end up never expiring it.
Could you tell us more about what motivated this?
It's causing failures on pynfs server-reboot tests. I haven't pinned down the cause yet, but it looks like it could be a regression to the behavior Kinglong Mee describes in detail in his original patch.
Dropping for the time being.
--b.
Quoted 79 lines
Fixes d6fc8821c2d2 ("SUNRPC/Cache: Always treat the invalid cache as unexpired")Signed-off-by Trond Myklebust <[email protected]>--- include/linux/sunrpc/cache.h | 3 --- net/sunrpc/cache.c | 36 +++++++++++++++++++----------------- 2 files changed, 19 insertions(+), 20 deletions(-)include/linux/sunrpc/cache.h +0
-3@@ -202,9 +202,6 @@ static inline void cache_put(struct cache_head *h, struct cache_detail *cd)static inline bool cache_is_expired (struct cache_detail *detail,struct cache_head *h) { -if (!test_bit (CACHE_VALID , &h->flags)) -return false; -return (h->expiry_time <seconds_since_boot ()) || (detail->flush_time >= h->last_refresh); }net/sunrpc/cache.c +19
-17@@ -65,13 +65,14 @@ static struct cache_head *sunrpc_cache_find_rcu(struct cache_detail *detail,rcu_read_lock ();hlist_for_each_entry_rcu (tmp, head, cache_list) { -if (detail->match (tmp, key)) { -if (cache_is_expired (detail, tmp)) -continue ; - tmp =cache_get_rcu (tmp); -rcu_read_unlock (); -return tmp; - } +if (!detail->match (tmp, key)) +continue ; +if (test_bit (CACHE_VALID , &tmp->flags) && +cache_is_expired (detail, tmp)) +continue ; + tmp =cache_get_rcu (tmp); +rcu_read_unlock (); +return tmp; }rcu_read_unlock ();return NULL ;@@ -114,17 +115,18 @@ static struct cache_head *sunrpc_cache_add_entry(struct cache_detail *detail,/* check if entry appeared while we slept */ hlist_for_each_entry_rcu (tmp, head, cache_list) { -if (detail->match (tmp, key)) { -if (cache_is_expired (detail, tmp)) { -sunrpc_begin_cache_remove_entry (tmp, detail); - freeme = tmp; -break ; - } -cache_get (tmp); -spin_unlock (&detail->hash_lock); -cache_put (new, detail); -return tmp; +if (!detail->match (tmp, key)) +continue ; +if (test_bit (CACHE_VALID , &tmp->flags) && +cache_is_expired (detail, tmp)) { +sunrpc_begin_cache_remove_entry (tmp, detail); + freeme = tmp; +break ; } +cache_get (tmp); +spin_unlock (&detail->hash_lock); +cache_put (new, detail); +return tmp; }hlist_add_head_rcu (&new->cache_list, head);Signature · 1 line
2.24.1
Quoted 11 lines · J. Bruce Fields
Quoted 3 lines · Trond Myklebust
If the cache entry never gets initialised, we want the garbage collector to be able to evict it. Otherwise if the upcall daemon fails to initialise the entry, we end up never expiring it.
Could you tell us more about what motivated this?
It's causing failures on pynfs server-reboot tests. I haven't pinned down the cause yet, but it looks like it could be a regression to the behavior Kinglong Mee describes in detail in his original patch.
Can you point me to the tests that are failing?
The motivation here is to allow the garbage collector to do its job of evicting cache entries after they are supposed to have timed out. The fact that uninitialised cache entries are given an infinite lifetime, and are never evicted is a de facto memory leak if, for instance, the mountd daemon ignores the cache request, or the downcall in expkey_parse() or svc_export_parse() fails without being able to update the request.
The threads that are waiting for the cache replies already have a mechanism for dealing with timeouts (with cache_wait_req() and deferred requests), so the question is what is so special about uninitialised requests that we have to leak them in order to avoid a problem with reboot?
Quoted 90 lines
Dropping for the time being.
--b.
Quoted 86 lines
Fixes d6fc8821c2d2 ("SUNRPC/Cache: Always treat the invalid cacheas unexpired")
Signed-off-by Trond Myklebust <[email protected]>--- include/linux/sunrpc/cache.h | 3 --- net/sunrpc/cache.c | 36 +++++++++++++++++++------------- ---- 2 files changed, 19 insertions(+), 20 deletions(-)include/linux/sunrpc/cache.h +0
-3@@ -202,9 +202,6 @@ static inline void cache_put(struct cache_head *h, struct cache_detail *cd)static inline bool cache_is_expired (struct cache_detail *detail,struct cache_head *h) { -if (!test_bit (CACHE_VALID , &h->flags)) -return false; - return (h->expiry_time < seconds_since_boot()) ||include/linux/sunrpc/cache.h +0
-0(detail->flush_time >= h->last_refresh); }net/sunrpc/cache.c +8
-7@@ -65,13 +65,14 @@ static struct cache_head *sunrpc_cache_find_rcu(struct cache_detail *detail, rcu_read_lock();hlist_for_each_entry_rcu (tmp, head, cache_list) { -if (detail->match (tmp, key)) { -if (cache_is_expired (detail, tmp)) -continue ; - tmp =cache_get_rcu (tmp); -rcu_read_unlock (); -return tmp; - } +if (!detail->match (tmp, key)) +continue ; +if (test_bit (CACHE_VALID , &tmp->flags) && +cache_is_expired (detail, tmp)) +continue ; + tmp =cache_get_rcu (tmp); +rcu_read_unlock (); +return tmp; }rcu_read_unlock ();net/sunrpc/cache.c +11
-10return NULL ;@@ -114,17 +115,18 @@ static struct cache_head *sunrpc_cache_add_entry(struct cache_detail *detail,/* check if entry appeared while we slept */ hlist_for_each_entry_rcu(tmp, head, cache_list) { -if (detail->match (tmp, key)) { -if (cache_is_expired (detail, tmp)) { -sunrpc_begin_cache_remove_entry (tmp, detail); - freeme = tmp; -break ; - } -cache_get (tmp); -spin_unlock (&detail->hash_lock); -cache_put (new, detail); -return tmp; +if (!detail->match (tmp, key)) +continue ; +if (test_bit (CACHE_VALID , &tmp->flags) && +cache_is_expired (detail, tmp)) { +sunrpc_begin_cache_remove_entry (tmp, detail); + freeme = tmp; +break ; } +cache_get (tmp); +spin_unlock (&detail->hash_lock); +cache_put (new, detail); +return tmp; }
hlist_add_head_rcu(&new->cache_list, head);Signature · 1 line
2.24.1
Signature · 3 lines
Trond Myklebust Linux NFS client maintainer, Hammerspace [email protected]
Quoted 6 lines · Trond Myklebust
Quoted 5 lines · J. Bruce Fields
Quoted 3 lines · Trond Myklebust
If the cache entry never gets initialised, we want the garbage collector to be able to evict it. Otherwise if the upcall daemon fails to initialise the entry, we end up never expiring it.
Quoted 8 lines
Quoted 6 lines
Could you tell us more about what motivated this?
It's causing failures on pynfs server-reboot tests. I haven't pinned down the cause yet, but it looks like it could be a regression to the behavior Kinglong Mee describes in detail in his original patch.
Can you point me to the tests that are failing?
I'm basically doing
./nfs4.1/testserver.py myserver:/path reboot
--serverhelper=examples/server_helper.sh --serverhelperarg=myserver
For all I know at this point, the change could be exposing a pynfs-side bug.
Quoted 2 lines
The motivation here is to allow the garbage collector to do its job of evicting cache entries after they are supposed to have timed out.
Understood. I was curious whether this was found by code inspection or because you'd run across a case where the leak was causing a practical problem.
--b.
Quoted 11 lines
The fact that uninitialised cache entries are given an infinite lifetime, and are never evicted is a de facto memory leak if, for instance, the mountd daemon ignores the cache request, or the downcall in
expkey_parse()orsvc_export_parse()fails without being able to update the request.The threads that are waiting for the cache replies already have a mechanism for dealing with timeouts (with
cache_wait_req()and deferred requests), so the question is what is so special about uninitialised requests that we have to leak them in order to avoid a problem with reboot?
Quoted 33 lines · On Fri, 2020-02-07 at 13:18 -0500, [email protected] wrote:
Quoted 9 lines · Trond Myklebust
Quoted 8 lines · J. Bruce Fields
Quoted 4 lines · Trond Myklebust
If the cache entry never gets initialised, we want the garbage collector to be able to evict it. Otherwise if the upcall daemon
fails to initialise the entry, we end up never expiring it.Could you tell us more about what motivated this?
Quoted 8 lines
Quoted 6 lines
It's causing failures on pynfs server-reboot tests. I haven't pinned
down the cause yet, but it looks like it could be a regression to the
behavior Kinglong Mee describes in detail in his original patch.Can you point me to the tests that are failing?
I'm basically doing
./nfs4.1/testserver.pymyserver:/path reboot
--serverhelper=examples/server_helper.sh --serverhelperarg=myserverFor all I know at this point, the change could be exposing a pynfs- side
bug.Quoted 3 lines
The motivation here is to allow the garbage collector to do its job of
evicting cache entries after they are supposed to have timed out.
Quoted 5 lines
Understood. I was curious whether this was found by code inspection or
because you'd run across a case where the leak was causing a practical
problem.
I was seeing hangs in some cases where the path lookup was temporarily failing in the export path downcall. In that case, the mount daemon just ignores the returned error, and leaves it up to the kernel to fix what is happening.
The problem is that since the garbage collector is currently told to ignore stuff if CACHE_VALID is not set, and since cache_check() won't do a second upcall, then any RPC call trying to access data on the path that was affected just hangs and eventually times out. Nothing prompts for this condition to be fixed.
Quoted 16 lines
--b.
Quoted 13 lines
The fact that uninitialised cache entries are given an infinite lifetime, and are never evicted is a de facto memory leak if, for instance, the mountd daemon ignores the cache request, or the downcall
inexpkey_parse()orsvc_export_parse()fails without being able to update the request.The threads that are waiting for the cache replies already have a mechanism for dealing with timeouts (with
cache_wait_req()and deferred requests), so the question is what is so special about uninitialised requests that we have to leak them in order to avoid a
problem with reboot?
Trond Myklebust
CTO, Hammerspace Inc
4300 El Camino Real, Suite 105
Los Altos, CA 94022
www.hammer.space
Signature · 3 lines
Trond Myklebust Linux NFS client maintainer, Hammerspace [email protected]
Sorry, just getting back to this:
Quoted 16 lines · On Fri, Feb 07, 2020 at 01:18:17PM -0500, [email protected] wrote:
Quoted 6 lines · Trond Myklebust
Quoted 5 lines · J. Bruce Fields
Quoted 3 lines · Trond Myklebust
If the cache entry never gets initialised, we want the garbage collector to be able to evict it. Otherwise if the upcall daemon fails to initialise the entry, we end up never expiring it.
Quoted 8 lines
Quoted 6 lines
Could you tell us more about what motivated this?
It's causing failures on pynfs server-reboot tests. I haven't pinned down the cause yet, but it looks like it could be a regression to the behavior Kinglong Mee describes in detail in his original patch.
Can you point me to the tests that are failing?
Quoted 8 lines
I'm basically doing
./nfs4.1/testserver.pymyserver:/path reboot
--serverhelper=examples/server_helper.sh --serverhelperarg=myserverFor all I know at this point, the change could be exposing a pynfs-side bug.
From a trace, it's clear that the server is actually becoming unresponsive, so it's not a pynfs bug.
Quoted 6 lines
Quoted 2 lines
The motivation here is to allow the garbage collector to do its job of evicting cache entries after they are supposed to have timed out.
Understood. I was curious whether this was found by code inspection or because you'd run across a case where the leak was causing a practical problem.
I'm still curious.
Quoted 5 lines
Quoted 5 lines
The fact that uninitialised cache entries are given an infinite lifetime, and are never evicted is a de facto memory leak if, for instance, the mountd daemon ignores the cache request, or the downcall in
expkey_parse()orsvc_export_parse()fails without being able to update the request.
If mountd ignores cache requests, or downcalls fail, then the server's broken anyway. The server can't do anything without mountd.
Quoted 5 lines
Quoted 5 lines
The threads that are waiting for the cache replies already have a mechanism for dealing with timeouts (with
cache_wait_req()and deferred requests), so the question is what is so special about uninitialised requests that we have to leak them in order to avoid a problem with reboot?
I'm not sure I have this right yet. I'm just staring at the code and at Kinglong Mee's description on d6fc8821c2d2. I think the way it works is that a cash flush from mountd results in all cache entries (including invalid entries that nfsd threads are waiting on) being considered expired. So cache_check() returns an immediate ETIMEDOUT without waiting.
Maybe the cache_is_expired() logic should be something more like:
if (h->expiry_time < seconds_since_boot()) return true; if (!test_bit(CACHE_VALID, &h->flags)) return false; return h->expiry_time < seconds_since_boot();
So invalid cache entries (which are waiting for a reply from mountd) can expire, but they can't be flushed. If that makes sense.
As a stopgap we may want to revert or drop the "Allow garbage collection" patch, as the (preexisting) memory leak seems lower impact than the server hang.
--b.
Hi Bruce,
Quoted 86 lines · On Thu, 2020-03-26 at 16:40 -0400, [email protected] wrote:
Sorry, just getting back to this:
Quoted 24 lines · On Fri, Feb 07, 2020 at 01:18:17PM -0500, [email protected] wrote:
Quoted 19 lines · Trond Myklebust
Quoted 8 lines · J. Bruce Fields
Quoted 5 lines · Trond Myklebust
If the cache entry never gets initialised, we want the garbage
collector to be able to evict it. Otherwise if the upcall daemon
fails to initialise the entry, we end up never expiring it.Quoted 9 lines
Could you tell us more about what motivated this?
It's causing failures on pynfs server-reboot tests. I haven't pinned
down the cause yet, but it looks like it could be a regression to the
behavior Kinglong Mee describes in detail in his original patch.Quoted 1 line
Can you point me to the tests that are failing?
I'm basically doing
Quoted 7 lines
./nfs4.1/testserver.pymyserver:/path reboot
--serverhelper=examples/server_helper.sh --serverhelperarg=myserverFor all I know at this point, the change could be exposing a pynfs- side
bug.From a trace, it's clear that the server is actually becoming unresponsive, so it's not a pynfs bug.
Quoted 9 lines
Quoted 3 lines
The motivation here is to allow the garbage collector to do its job of
evicting cache entries after they are supposed to have timed out.Understood. I was curious whether this was found by code inspection or
because you'd run across a case where the leak was causing a practical
problem.I'm still curious.
Quoted 7 lines
Quoted 7 lines
The fact that uninitialised cache entries are given an infinite lifetime, and are never evicted is a de facto memory leak if, for instance, the mountd daemon ignores the cache request, or the downcall
inexpkey_parse()orsvc_export_parse()fails without being able to
update the request.If mountd ignores cache requests, or downcalls fail, then the server's
broken anyway. The server can't do anything without mountd.Quoted 6 lines
Quoted 6 lines
The threads that are waiting for the cache replies already have a mechanism for dealing with timeouts (with
cache_wait_req()and deferred requests), so the question is what is so special about uninitialised requests that we have to leak them in order to avoid a
problem with reboot?I'm not sure I have this right yet. I'm just staring at the code and at
Kinglong Mee's description ond6fc8821c2d2. I think the way it works is
that a cash flush from mountd results in all cache entries (including invalid entries that nfsd threads are waiting on) being considered expired. Socache_check()returns an immediate ETIMEDOUT without waiting.Maybe the
cache_is_expired()logic should be something more like:if (h->expiry_time < seconds_since_boot()) return true; if (!test_bit(CACHE_VALID, &h->flags)) return false; return h->expiry_time < seconds_since_boot();
Quoted 9 lines
So invalid cache entries (which are waiting for a reply from mountd) can
expire, but they can't be flushed. If that makes sense.As a stopgap we may want to revert or drop the "Allow garbage collection" patch, as the (preexisting) memory leak seems lower impact
than the server hang.
I believe you were probably seeing the effect of the cache_listeners_exist() test, which is just wrong for all cache upcall users except idmapper and svcauth_gss. We should not be creating negative cache entries just because the rpc.mountd daemon happens to be slow to connect to the upcall pipes when starting up, or because it crashes and fails to restart correctly.
That's why, when I resubmitted this patch, I included
https://git.linux-nfs.org/?p=cel/cel-2.6.git;a=commitdiff;h=b840228cd6096bebe16b3e4eb5d93597d0e02c6d
which turns off that particular test for all the upcalls to rpc.mountd.
Note that the patch series I sent includes a bunch of kernel tracepoints that we can enable to help debugging if we see anything similar happening in the future.
Cheers
Trond
Signature · 3 lines
Trond Myklebust Linux NFS client maintainer, Hammerspace [email protected]
Quoted 25 lines · Trond Myklebust
Quoted 8 lines · On Thu, 2020-03-26 at 16:40 -0400, [email protected] wrote:
Maybe the
cache_is_expired()logic should be something more like:if (h->expiry_time < seconds_since_boot()) return true; if (!test_bit(CACHE_VALID, &h->flags)) return false; return h->expiry_time < seconds_since_boot();Quoted 8 lines
So invalid cache entries (which are waiting for a reply from mountd) can
expire, but they can't be flushed. If that makes sense.As a stopgap we may want to revert or drop the "Allow garbage collection" patch, as the (preexisting) memory leak seems lower impact
than the server hang.I believe you were probably seeing the effect of the
cache_listeners_exist()test, which is just wrong for all cache upcall users except idmapper andsvcauth_gss. We should not be creating negative cache entries just because the rpc.mountd daemon happens to be slow to connect to the upcall pipes when starting up, or because it crashes and fails to restart correctly.
Quoted 4 lines
That's why, when I resubmitted this patch, I included
https://git.linux-nfs.org/?p=cel/cel-2.6.git;a=commitdiff;h=b840228cd6096bebe16b3e4eb5d93597d0e02c6dwhich turns off that particular test for all the upcalls to rpc.mountd.
The hangs persist with that patch, but go away with the change to the cache_is_expired() logic above.
--b.
Quoted 9 lines · J. Bruce Fields
Quoted 8 lines · Trond Myklebust
Quoted 7 lines · On Thu, 2020-03-26 at 16:40 -0400, [email protected] wrote:
Maybe the
cache_is_expired()logic should be something more like:if (h->expiry_time < seconds_since_boot()) return true; if (!test_bit(CACHE_VALID, &h->flags)) return false; return h->expiry_time < seconds_since_boot();
Did you mean
return detail->flush_time >= h->last_refresh;
instead of repeating the h->expiry_time check?
Quoted 20 lines
Quoted 20 lines
Quoted 10 lines
So invalid cache entries (which are waiting for a reply from mountd)
can
expire, but they can't be flushed. If that makes sense.As a stopgap we may want to revert or drop the "Allow garbage collection" patch, as the (preexisting) memory leak seems lower impact
than the server hang.I believe you were probably seeing the effect of the
cache_listeners_exist()test, which is just wrong for all cache upcall
users except idmapper andsvcauth_gss. We should not be creating negative cache entries just because the rpc.mountd daemon happens to be
slow to connect to the upcall pipes when starting up, or because it crashes and fails to restart correctly.
Quoted 8 lines
Quoted 5 lines
That's why, when I resubmitted this patch, I included
https://git.linux-nfs.org/?p=cel/cel-2.6.git;a=commitdiff;h=b840228cd6096bebe16b3e4eb5d93597d0e02c6dwhich turns off that particular test for all the upcalls to rpc.mountd.
The hangs persist with that patch, but go away with the change to the
cache_is_expired()logic above.
Fair enough. Do you want to send Chuck a fix?
Signature · 3 lines
Trond Myklebust Linux NFS client maintainer, Hammerspace [email protected]
PATCH 1/1 SUNRPC/cache: don't allow invalid entries to be flushed
From: "J. Bruce Fields" <[email protected]>
Trond points out in 277f27e2f277 that we allow invalid cache entries to persist indefinitely. That fix, however, reintroduces the problem fixed by Kinglong Mee's d6fc8821c2d2 "SUNRPC/Cache: Always treat the invalid cache as unexpired", where an invalid cache entry is immediately removed by a flush before mountd responds to it. The result is that the server thread that should be waiting for mountd to fill in that entry instead gets an -ETIMEDOUT return from cache_check(). Symptoms are the server becoming unresponsive after a restart, reproduceable by running pynfs 4.1 test REBT5.
Instead, take a compromise approach: allow invalid cache entries to be removed after they expire, but not to be removed by a cache flush.
--- include/linux/sunrpc/cache.h | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
include/linux/sunrpc/cache.h +5 -2
@@ -209,8 +209,11 @@ static inline void cache_put(struct cache_head *h, struct cache_detail *cd)static inline bool cache_is_expired (struct cache_detail *detail,struct cache_head *h) { -return (h->expiry_time <seconds_since_boot ()) || - (detail->flush_time >= h->last_refresh); +if (h->expiry_time <seconds_since_boot ()) +return true; +if (!test_bit (CACHE_VALID , &h->flags)) +return false; +return detail->flush_time >= h->last_refresh; } extern int cache_check(struct cache_detail *detail,
Signature · 1 line
2.25.1
Re: [PATCH] SUNRPC/cache: don't allow invalid entries to be flushed
Quoted 16 lines · J. Bruce Fields
From: "J. Bruce Fields" <[email protected]>
Trond points out in
277f27e2f277that we allow invalid cache entries to persist indefinitely. That fix, however, reintroduces the problem fixed by Kinglong Mee'sd6fc8821c2d2"SUNRPC/Cache: Always treat the invalid cache as unexpired", where an invalid cache entry is immediately removed by a flush before mountd responds to it. The result is that the server thread that should be waiting for mountd to fill in that entry instead gets an-ETIMEDOUTreturn fromcache_check(). Symptoms are the server becoming unresponsive after a restart, reproduceable by running pynfs 4.1 test REBT5.
Quoted 5 lines
Instead, take a compromise approach: allow invalid cache entries to be removed after they expire, but not to be removed by a cache flush.
Fixes 277f27e2f277 "SUNRPC/cache: Allow garbage collection..."Signed-off-by J. Bruce Fields <[email protected]>
Thanks, Bruce. checkpatch.pl is complaining loudly about the style of the short commit descriptions. I'll fix those up before applying it to nfsd-5.7.
Quoted 25 lines
---
include/linux/sunrpc/cache.h| 7 +++++--1 file changed, 5 insertions(+), 2 deletions(-)include/linux/sunrpc/cache.h +5
-2@@ -209,8 +209,11 @@ static inline void cache_put(struct cache_head *h, struct cache_detail *cd)static inline bool cache_is_expired (struct cache_detail *detail,struct cache_head *h) { -return (h->expiry_time <seconds_since_boot ()) || - (detail->flush_time >= h->last_refresh); +if (h->expiry_time <seconds_since_boot ()) +return true; +if (!test_bit (CACHE_VALID , &h->flags)) +return false; +return detail->flush_time >= h->last_refresh; } extern int cache_check(struct cache_detail *detail,Signature · 1 line
2.25.1
--
Chuck Lever