NFSD: memory shrinker for NFSv4 clients
Subsystems (2)
Dai Ngo
reviewerv2 cover NFSD: memory shrinker for NFSv4 clients
This patch series implements the memory shrinker for NFSv4 clients to react to system low memory condition.
The memory shrinker's count callback is used to trigger the laundromat. The actual work of destroying the expired clients is done by the laundromat itself. We can not destroying the expired clients on the memory shrinler's scan callback context to avoid possible deadlock.
By destroying the expired clients, all states associated with these clients are also released.
v2:
. fix kernel test robot errors in nfsd.h when CONFIG_NFSD_V4 not defined.
---
Dai Ngo (2):
NFSD: keep track of the number of courtesy clients in the system
NFSD: add shrinker to reap courtesy clients on low memory condition
fs/nfsd/netns.h | 5 ++++ fs/nfsd/nfs4state.c | 69 ++++++++++++++++++++++++++++++++++++++++++------ fs/nfsd/nfsctl.c | 6 +++-- fs/nfsd/nfsd.h | 9 +++++-- 4 files changed, 77 insertions(+), 12 deletions(-)
Dai Ngo
reviewerPATCH v2 1/2 NFSD: keep track of the number of courtesy clients in the system
Add counter nfs4_courtesy_client_count to nfsd_net to keep track of the number of courtesy clients in the system.
--- fs/nfsd/netns.h | 2 ++ fs/nfsd/nfs4state.c | 20 +++++++++++++++----- 2 files changed, 17 insertions(+), 5 deletions(-)
fs/nfsd/netns.h +2 -0
@@ -192,6 +192,8 @@ struct nfsd_net {atomic_t nfs4_client_count;int nfs4_max_clients; + +atomic_t nfsd_courtesy_client_count; };/* Simple check to find out if a given net was properly initialized */
fs/nfsd/nfs4state.c +15 -5
@@ -169,7 +169,8 @@ static __be32 get_client_locked(struct nfs4_client *clp)if (is_client_expired (clp))return nfserr_expired;atomic_inc (&clp->cl_rpc_users); - clp->cl_state =NFSD4_ACTIVE ; +if (xchg (&clp->cl_state,NFSD4_ACTIVE ) !=NFSD4_ACTIVE ) +atomic_add_unless (&nn->nfsd_courtesy_client_count,-1 ,0 );return nfs_ok; }
@@ -190,7 +191,8 @@ renew_client_locked(struct nfs4_client *clp)list_move_tail (&clp->cl_lru, &nn->client_lru); clp->cl_time =ktime_get_boottime_seconds (); - clp->cl_state =NFSD4_ACTIVE ; +if (xchg (&clp->cl_state,NFSD4_ACTIVE ) !=NFSD4_ACTIVE ) +atomic_add_unless (&nn->nfsd_courtesy_client_count,-1 ,0 ); }static void put_client_renew_locked (struct nfs4_client *clp)
@@ -2233,6 +2235,8 @@ __destroy_client(struct nfs4_client *clp)if (clp->cl_cb_conn.cb_xprt)svc_xprt_put (clp->cl_cb_conn.cb_xprt);atomic_add_unless (&nn->nfs4_client_count,-1 ,0 ); +if (clp->cl_state !=NFSD4_ACTIVE ) +atomic_add_unless (&nn->nfsd_courtesy_client_count,-1 ,0 );free_client (clp);wake_up_all (&expiry_wq); }
@@ -4356,6 +4360,8 @@ void nfsd4_init_leases_net(struct nfsd_net *nn) max_clients = (u64 )si.totalram * si.mem_unit / (1024 *1024 *1024 ); max_clients *=NFS4_CLIENTS_PER_GB ; nn->nfs4_max_clients =max_t (int, max_clients,NFS4_CLIENTS_PER_GB ); + +atomic_set (&nn->nfsd_courtesy_client_count,0 ); }static void init_nfs4_replay (struct nfs4_replay *rp)
@@ -5864,7 +5870,7 @@ static void nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, struct laundry_time *lt) { - unsigned int maxreap, reapcnt = 0; + unsigned int oldstate, maxreap, reapcnt = 0;struct list_head *pos, *next;struct nfs4_client *clp;
@@ -5878,8 +5884,12 @@ nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, goto exp_client;if (!state_expired (lt, clp->cl_time))break ; -if (!atomic_read (&clp->cl_rpc_users)) - clp->cl_state =NFSD4_COURTESY ; + oldstate =NFSD4_ACTIVE ; +if (!atomic_read (&clp->cl_rpc_users)) { + oldstate =xchg (&clp->cl_state,NFSD4_COURTESY ); +if (oldstate ==NFSD4_ACTIVE ) +atomic_inc (&nn->nfsd_courtesy_client_count); + }if (!client_has_state (clp)) goto exp_client;if (!nfs4_anylock_blockers (clp))
Signature · 1 line
2.9.5
Jeff Layton
maintainerRe: [PATCH v2 1/2] NFSD: keep track of the number of courtesy clients in the system
Quoted 27 lines · Dai Ngo
Add counter
nfs4_courtesy_client_counttonfsd_netto keep track of the number of courtesy clients in the system.Signed-off-by Dai Ngo <[email protected]>--- fs/nfsd/netns.h | 2 ++ fs/nfsd/nfs4state.c | 20 +++++++++++++++----- 2 files changed, 17 insertions(+), 5 deletions(-)fs/nfsd/netns.h +2
-0@@ -192,6 +192,8 @@ struct nfsd_net {atomic_t nfs4_client_count;int nfs4_max_clients; + +atomic_t nfsd_courtesy_client_count; };/* Simple check to find out if a given net was properly initialized */ fs/nfsd/nfs4state.c +0
-0
fs/nfsd/nfs4state.c static __be32 get_client_locked(struct nfs4_client *clp) · line 172
Quoted 5 lines
fs/nfsd/nfs4state.c +1
-1@@ -169,7 +169,8 @@ static __be32 get_client_locked(struct nfs4_client *clp)if (is_client_expired (clp))return nfserr_expired;atomic_inc (&clp->cl_rpc_users); - clp->cl_state =NFSD4_ACTIVE ; +if (xchg (&clp->cl_state,NFSD4_ACTIVE ) !=NFSD4_ACTIVE )
The xchg calls seem like overkill. The cl_state is protected by the nn->client_lock. Nothing else can race in and change it here.
Quoted 56 lines
fs/nfsd/nfs4state.c +14
-4+atomic_add_unless (&nn->nfsd_courtesy_client_count,-1 ,0 );return nfs_ok; }@@ -190,7 +191,8 @@ renew_client_locked(struct nfs4_client *clp)list_move_tail (&clp->cl_lru, &nn->client_lru); clp->cl_time =ktime_get_boottime_seconds (); - clp->cl_state =NFSD4_ACTIVE ; +if (xchg (&clp->cl_state,NFSD4_ACTIVE ) !=NFSD4_ACTIVE ) +atomic_add_unless (&nn->nfsd_courtesy_client_count,-1 ,0 ); }static void put_client_renew_locked (struct nfs4_client *clp)@@ -2233,6 +2235,8 @@ __destroy_client(struct nfs4_client *clp)if (clp->cl_cb_conn.cb_xprt)svc_xprt_put (clp->cl_cb_conn.cb_xprt);atomic_add_unless (&nn->nfs4_client_count,-1 ,0 ); +if (clp->cl_state !=NFSD4_ACTIVE ) +atomic_add_unless (&nn->nfsd_courtesy_client_count,-1 ,0 );free_client (clp);wake_up_all (&expiry_wq); }@@ -4356,6 +4360,8 @@ void nfsd4_init_leases_net(struct nfsd_net *nn) max_clients = (u64 )si.totalram * si.mem_unit / (1024 *1024 *1024 ); max_clients *=NFS4_CLIENTS_PER_GB ; nn->nfs4_max_clients =max_t (int, max_clients,NFS4_CLIENTS_PER_GB ); + +atomic_set (&nn->nfsd_courtesy_client_count,0 ); }static void init_nfs4_replay (struct nfs4_replay *rp)@@ -5864,7 +5870,7 @@ static void nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, struct laundry_time *lt) { - unsigned int maxreap, reapcnt = 0; + unsigned int oldstate, maxreap, reapcnt = 0;struct list_head *pos, *next;struct nfs4_client *clp;@@ -5878,8 +5884,12 @@ nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, goto exp_client;if (!state_expired (lt, clp->cl_time))break ; -if (!atomic_read (&clp->cl_rpc_users)) - clp->cl_state =NFSD4_COURTESY ; + oldstate =NFSD4_ACTIVE ; +if (!atomic_read (&clp->cl_rpc_users)) { + oldstate =xchg (&clp->cl_state,NFSD4_COURTESY ); +if (oldstate ==NFSD4_ACTIVE ) +atomic_inc (&nn->nfsd_courtesy_client_count); + }if (!client_has_state (clp)) goto exp_client;if (!nfs4_anylock_blockers (clp))
Signature · 1 line
Jeff Layton <[email protected]>
[email protected]
reviewerRe: [PATCH v2 1/2] NFSD: keep track of the number of courtesy clients in the system
Quoted 22 lines · Jeff Layton
Quoted 21 lines · Dai Ngo
Add counter
nfs4_courtesy_client_counttonfsd_netto keep track of the number of courtesy clients in the system.Signed-off-by Dai Ngo <[email protected]>--- fs/nfsd/netns.h | 2 ++ fs/nfsd/nfs4state.c | 20 +++++++++++++++----- 2 files changed, 17 insertions(+), 5 deletions(-)fs/nfsd/netns.h +2
-0@@ -192,6 +192,8 @@ struct nfsd_net {atomic_t nfs4_client_count;int nfs4_max_clients; + +atomic_t nfsd_courtesy_client_count; };
Quoted 13 lines
fs/nfsd/nfs4state.c static __be32 get_client_locked(struct nfs4_client *clp) · line 172
Quoted 11 lines
fs/nfsd/netns.h +0
-0/* Simple check to find out if a given net was properly initialized */ fs/nfsd/nfs4state.c +1
-1@@ -169,7 +169,8 @@ static __be32 get_client_locked(struct nfs4_client *clp)if (is_client_expired (clp))return nfserr_expired;atomic_inc (&clp->cl_rpc_users); - clp->cl_state =NFSD4_ACTIVE ; +if (xchg (&clp->cl_state,NFSD4_ACTIVE ) !=NFSD4_ACTIVE )The xchg calls seem like overkill. The
cl_stateis protected by thenn->client_lock. Nothing else can race in and change it here.
I use the 'xchg' calls for convenience and readability and not for protection in this case. But if you think this is overkill or unnecessary then I remove it.
Fix in v2.
Thanks,
-Dai
Quoted 57 lines
Quoted 57 lines
fs/nfsd/nfs4state.c +14
-4+atomic_add_unless (&nn->nfsd_courtesy_client_count,-1 ,0 );return nfs_ok; }@@ -190,7 +191,8 @@ renew_client_locked(struct nfs4_client *clp)list_move_tail (&clp->cl_lru, &nn->client_lru); clp->cl_time =ktime_get_boottime_seconds (); - clp->cl_state =NFSD4_ACTIVE ; +if (xchg (&clp->cl_state,NFSD4_ACTIVE ) !=NFSD4_ACTIVE ) +atomic_add_unless (&nn->nfsd_courtesy_client_count,-1 ,0 ); }static void put_client_renew_locked (struct nfs4_client *clp)@@ -2233,6 +2235,8 @@ __destroy_client(struct nfs4_client *clp)if (clp->cl_cb_conn.cb_xprt)svc_xprt_put (clp->cl_cb_conn.cb_xprt);atomic_add_unless (&nn->nfs4_client_count,-1 ,0 ); +if (clp->cl_state !=NFSD4_ACTIVE ) +atomic_add_unless (&nn->nfsd_courtesy_client_count,-1 ,0 );free_client (clp);wake_up_all (&expiry_wq); }@@ -4356,6 +4360,8 @@ void nfsd4_init_leases_net(struct nfsd_net *nn) max_clients = (u64 )si.totalram * si.mem_unit / (1024 *1024 *1024 ); max_clients *=NFS4_CLIENTS_PER_GB ; nn->nfs4_max_clients =max_t (int, max_clients,NFS4_CLIENTS_PER_GB ); + +atomic_set (&nn->nfsd_courtesy_client_count,0 ); }static void init_nfs4_replay (struct nfs4_replay *rp)@@ -5864,7 +5870,7 @@ static void nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, struct laundry_time *lt) { - unsigned int maxreap, reapcnt = 0; + unsigned int oldstate, maxreap, reapcnt = 0;struct list_head *pos, *next;struct nfs4_client *clp;@@ -5878,8 +5884,12 @@ nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, goto exp_client;if (!state_expired (lt, clp->cl_time))break ; -if (!atomic_read (&clp->cl_rpc_users)) - clp->cl_state =NFSD4_COURTESY ; + oldstate =NFSD4_ACTIVE ; +if (!atomic_read (&clp->cl_rpc_users)) { + oldstate =xchg (&clp->cl_state,NFSD4_COURTESY ); +if (oldstate ==NFSD4_ACTIVE ) +atomic_inc (&nn->nfsd_courtesy_client_count); + }if (!client_has_state (clp)) goto exp_client;if (!nfs4_anylock_blockers (clp))
Jeff Layton
maintainerRe: [PATCH v2 1/2] NFSD: keep track of the number of courtesy clients in the system
Quoted 37 lines · On Mon, 2022-08-29 at 11:24 -0700, [email protected] wrote:
Quoted 22 lines · Jeff Layton
Quoted 21 lines · Dai Ngo
Add counter
nfs4_courtesy_client_counttonfsd_netto keep track of the number of courtesy clients in the system.Signed-off-by Dai Ngo <[email protected]>--- fs/nfsd/netns.h | 2 ++ fs/nfsd/nfs4state.c | 20 +++++++++++++++----- 2 files changed, 17 insertions(+), 5 deletions(-)fs/nfsd/netns.h +2
-0@@ -192,6 +192,8 @@ struct nfsd_net {atomic_t nfs4_client_count;int nfs4_max_clients; + +atomic_t nfsd_courtesy_client_count; };Quoted 13 lines
fs/nfsd/nfs4state.c static __be32 get_client_locked(struct nfs4_client *clp) · line 172
Quoted 11 lines
fs/nfsd/netns.h +0
-0/* Simple check to find out if a given net was properly initialized */ fs/nfsd/nfs4state.c +1
-1@@ -169,7 +169,8 @@ static __be32 get_client_locked(struct nfs4_client *clp)if (is_client_expired (clp))return nfserr_expired;atomic_inc (&clp->cl_rpc_users); - clp->cl_state =NFSD4_ACTIVE ; +if (xchg (&clp->cl_state,NFSD4_ACTIVE ) !=NFSD4_ACTIVE )The xchg calls seem like overkill. The
cl_stateis protected by thenn->client_lock. Nothing else can race in and change it here.
Quoted 8 lines
I use the 'xchg' calls for convenience and readability and not for protection in this case. But if you think this is overkill or unnecessary then I remove it.
Fix in v2.
Thanks,
-Dai
No worries, it's a minor thing. It probably doesn't hurt anything in this context, but the xchg operation itself has to be atomic. We already hold the spinlock in these places, so there's no need to demand that here.
Quoted 56 lines
Quoted 56 lines
Quoted 56 lines
fs/nfsd/nfs4state.c +14
-4+atomic_add_unless (&nn->nfsd_courtesy_client_count,-1 ,0 );return nfs_ok; }@@ -190,7 +191,8 @@ renew_client_locked(struct nfs4_client *clp)list_move_tail (&clp->cl_lru, &nn->client_lru); clp->cl_time =ktime_get_boottime_seconds (); - clp->cl_state =NFSD4_ACTIVE ; +if (xchg (&clp->cl_state,NFSD4_ACTIVE ) !=NFSD4_ACTIVE ) +atomic_add_unless (&nn->nfsd_courtesy_client_count,-1 ,0 ); }static void put_client_renew_locked (struct nfs4_client *clp)@@ -2233,6 +2235,8 @@ __destroy_client(struct nfs4_client *clp)if (clp->cl_cb_conn.cb_xprt)svc_xprt_put (clp->cl_cb_conn.cb_xprt);atomic_add_unless (&nn->nfs4_client_count,-1 ,0 ); +if (clp->cl_state !=NFSD4_ACTIVE ) +atomic_add_unless (&nn->nfsd_courtesy_client_count,-1 ,0 );free_client (clp);wake_up_all (&expiry_wq); }@@ -4356,6 +4360,8 @@ void nfsd4_init_leases_net(struct nfsd_net *nn) max_clients = (u64 )si.totalram * si.mem_unit / (1024 *1024 *1024 ); max_clients *=NFS4_CLIENTS_PER_GB ; nn->nfs4_max_clients =max_t (int, max_clients,NFS4_CLIENTS_PER_GB ); + +atomic_set (&nn->nfsd_courtesy_client_count,0 ); }static void init_nfs4_replay (struct nfs4_replay *rp)@@ -5864,7 +5870,7 @@ static void nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, struct laundry_time *lt) { - unsigned int maxreap, reapcnt = 0; + unsigned int oldstate, maxreap, reapcnt = 0;struct list_head *pos, *next;struct nfs4_client *clp;@@ -5878,8 +5884,12 @@ nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, goto exp_client;if (!state_expired (lt, clp->cl_time))break ; -if (!atomic_read (&clp->cl_rpc_users)) - clp->cl_state =NFSD4_COURTESY ; + oldstate =NFSD4_ACTIVE ; +if (!atomic_read (&clp->cl_rpc_users)) { + oldstate =xchg (&clp->cl_state,NFSD4_COURTESY ); +if (oldstate ==NFSD4_ACTIVE ) +atomic_inc (&nn->nfsd_courtesy_client_count); + }if (!client_has_state (clp)) goto exp_client;if (!nfs4_anylock_blockers (clp))
Signature · 1 line
Jeff Layton <[email protected]>
Dai Ngo
reviewerPATCH v2 2/2 NFSD: add shrinker to reap courtesy clients on low memory condition
In reply to Dai NgoAdd the courtesy client shrinker to react to low memory condition triggered by the memory shrinker.
On the shrinker's count callback, we increment a callback counter and return the number of outstanding courtesy clients. When the laundromat runs, it checks if this counter is not zero and starts reaping old courtesy clients. The maximum number of clients to be reaped is limited to NFSD_CIENT_MAX_TRIM_PER_RUN (128). This limit is to prevent the laundromat from spending too much time reaping the clients and not processing other tasks in a timely manner.
The laundromat is rescheduled to run sooner if it detects low low memory condition and there are more clients to reap.
On the shrinker's scan callback, we return the number of clients That were reaped since the last scan callback. We can not reap the clients on the scan callback context since destroying the client might require call into the underlying filesystem or other subsystems which might allocate memory which can cause deadlock.
--- fs/nfsd/netns.h | 3 +++ fs/nfsd/nfs4state.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++---- fs/nfsd/nfsctl.c | 6 ++++-- fs/nfsd/nfsd.h | 9 +++++++-- 4 files changed, 61 insertions(+), 8 deletions(-)
fs/nfsd/netns.h +3 -0
@@ -194,6 +194,9 @@ struct nfsd_net {int nfs4_max_clients;atomic_t nfsd_courtesy_client_count; +atomic_t nfsd_client_shrinker_cb_count; +atomic_t nfsd_client_shrinker_reapcount; +struct shrinker nfsd_client_shrinker; };/* Simple check to find out if a given net was properly initialized */
fs/nfsd/nfs4state.c +47 -4
84 lines not on this page · raw message
fs/nfsd/nfsctl.c +4 -2
@@ -1481,11 +1481,12 @@ static __net_init int nfsd_init_net(struct net *net) goto out_idmap_error; nn->nfsd_versions =NULL ; nn->nfsd4_minorversions =NULL ; + retval =nfsd4_init_leases_net (nn); +if (retval) + goto out_drc_error; retval =nfsd_reply_cache_init (nn);if (retval) goto out_drc_error; -nfsd4_init_leases_net (nn); -get_random_bytes (&nn->siphash_key,sizeof (nn->siphash_key));seqlock_init (&nn->writeverf_lock);
@@ -1507,6 +1508,7 @@ static __net_exit void nfsd_exit_net(struct net *net)nfsd_idmap_shutdown (net);nfsd_export_shutdown (net);nfsd_netns_free_versions (net_generic (net, nfsd_net_id)); +nfsd4_leases_net_shutdown (nn); }static struct pernet_operations nfsd_net_ops = {
fs/nfsd/nfsd.h +7 -2
@@ -498,7 +498,11 @@ extern void unregister_cld_notifier(void);extern void nfsd4_ssc_init_umount_work (struct nfsd_net *nn);#endif -extern void nfsd4_init_leases_net (struct nfsd_net *nn); +extern int nfsd4_init_leases_net (struct nfsd_net *nn); +static inline void nfsd4_leases_net_shutdown (struct nfsd_net *nn) +{ +unregister_shrinker (&nn->nfsd_client_shrinker); +};#else /* CONFIG_NFSD_V4 */ static inline int nfsd4_is_junction (struct dentry *dentry)
@@ -506,7 +510,8 @@ static inline int nfsd4_is_junction(struct dentry *dentry)return 0 ; } -static inline void nfsd4_init_leases_net (struct nfsd_net *nn) {}; +static inline int nfsd4_init_leases_net (struct nfsd_net *nn) {return 0 ; }; +static inline void nfsd4_leases_net_shutdown (struct nfsd_net *nn) { };#define register_cld_notifier () 0#define unregister_cld_notifier () do { } while(0)
Signature · 1 line
2.9.5
Jeff Layton
maintainerRe: [PATCH v2 2/2] NFSD: add shrinker to reap courtesy clients on low memory condition
Quoted 60 lines · Dai Ngo
Add the courtesy client shrinker to react to low memory condition triggered by the memory shrinker.
On the shrinker's count callback, we increment a callback counter and return the number of outstanding courtesy clients. When the laundromat runs, it checks if this counter is not zero and starts reaping old courtesy clients. The maximum number of clients to be reaped is limited to
NFSD_CIENT_MAX_TRIM_PER_RUN(128). This limit is to prevent the laundromat from spending too much time reaping the clients and not processing other tasks in a timely manner.The laundromat is rescheduled to run sooner if it detects low low memory condition and there are more clients to reap.
On the shrinker's scan callback, we return the number of clients That were reaped since the last scan callback. We can not reap the clients on the scan callback context since destroying the client might require call into the underlying filesystem or other subsystems which might allocate memory which can cause deadlock.
Signed-off-by Dai Ngo <[email protected]>--- fs/nfsd/netns.h | 3 +++ fs/nfsd/nfs4state.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++---- fs/nfsd/nfsctl.c | 6 ++++-- fs/nfsd/nfsd.h | 9 +++++++-- 4 files changed, 61 insertions(+), 8 deletions(-)fs/nfsd/netns.h +3
-0@@ -194,6 +194,9 @@ struct nfsd_net {int nfs4_max_clients;atomic_t nfsd_courtesy_client_count; +atomic_t nfsd_client_shrinker_cb_count; +atomic_t nfsd_client_shrinker_reapcount; +struct shrinker nfsd_client_shrinker; };/* Simple check to find out if a given net was properly initialized */ fs/nfsd/nfs4state.c +9
-1@@ -4341,7 +4341,39 @@ nfsd4_init_slabs(void)return -ENOMEM ; } -void nfsd4_init_leases_net (struct nfsd_net *nn) +static unsigned long +nfsd_courtesy_client_count (struct shrinker *shrink,struct shrink_control *sc) +{ +struct nfsd_net *nn =container_of (shrink, + struct nfsd_net, nfsd_client_shrinker); + +atomic_inc (&nn->nfsd_client_shrinker_cb_count); +return (unsigned long )atomic_read (&nn->nfsd_courtesy_client_count); +}
fs/nfsd/nfs4state.c nfsd4_init_slabs(void) · line 4362
Quoted 10 lines
fs/nfsd/nfs4state.c +10
-0+ +static unsigned long +nfsd_courtesy_client_scan (struct shrinker *shrink,struct shrink_control *sc) +{ +struct nfsd_net *nn =container_of (shrink, + struct nfsd_net, nfsd_client_shrinker); +unsigned long cnt; + + cnt =atomic_read (&nn->nfsd_client_shrinker_reapcount); +atomic_set (&nn->nfsd_client_shrinker_reapcount,0 );
Is it legit to return that we freed these objects when it hasn't actually been done yet? Maybe this should always return 0? I'm not sure what the rules are with shrinkers.
Either way, it seems like "scan" should cue the laundromat to run ASAP. When this is called, it may be quite some time before the laundromat runs again. Currently, it's always just scheduled it out to when we know there may be work to be done, but this is a different situation.
Quoted 119 lines
fs/nfsd/nfs4state.c +28
-3+return cnt; +} + +static int +nfsd_register_client_shrinker (struct nfsd_net *nn) +{ + nn->nfsd_client_shrinker.scan_objects = nfsd_courtesy_client_scan; + nn->nfsd_client_shrinker.count_objects = nfsd_courtesy_client_count; + nn->nfsd_client_shrinker.seeks =DEFAULT_SEEKS ; +return register_shrinker (&nn->nfsd_client_shrinker,"nfsd-client" ); +} + +int +nfsd4_init_leases_net (struct nfsd_net *nn) {struct sysinfo si;u64 max_clients;@@ -4362,6 +4394,8 @@ void nfsd4_init_leases_net(struct nfsd_net *nn) nn->nfs4_max_clients =max_t (int, max_clients,NFS4_CLIENTS_PER_GB );atomic_set (&nn->nfsd_courtesy_client_count,0 ); +atomic_set (&nn->nfsd_client_shrinker_cb_count,0 ); +return nfsd_register_client_shrinker (nn); }static void init_nfs4_replay (struct nfs4_replay *rp)@@ -5870,12 +5904,17 @@ static void nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, struct laundry_time *lt) { - unsigned int oldstate, maxreap, reapcnt = 0; + unsigned int oldstate, maxreap = 0, reapcnt = 0; +int cb_cnt;struct list_head *pos, *next;struct nfs4_client *clp; - maxreap = (atomic_read (&nn->nfs4_client_count) >= nn->nfs4_max_clients) ? -NFSD_CLIENT_MAX_TRIM_PER_RUN :0 ; + cb_cnt =atomic_read (&nn->nfsd_client_shrinker_cb_count); +if (atomic_read (&nn->nfs4_client_count) >= nn->nfs4_max_clients || + cb_cnt) { + maxreap =NFSD_CLIENT_MAX_TRIM_PER_RUN ; +atomic_set (&nn->nfsd_client_shrinker_cb_count,0 ); + }INIT_LIST_HEAD (reaplist);spin_lock (&nn->client_lock);list_for_each_safe (pos, next, &nn->client_lru) {@@ -5902,6 +5941,8 @@ nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, } }spin_unlock (&nn->client_lock); +if (cb_cnt) +atomic_add (reapcnt, &nn->nfsd_client_shrinker_reapcount); } static time64_t@@ -5942,6 +5983,8 @@ nfs4_laundromat(struct nfsd_net *nn)list_del_init (&clp->cl_lru);expire_client (clp); } +if (atomic_read (&nn->nfsd_client_shrinker_cb_count) >0 ) + lt.new_timeo =NFSD_LAUNDROMAT_MINTIMEOUT ;spin_lock (&state_lock);list_for_each_safe (pos, next, &nn->del_recall_lru) { dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);fs/nfsd/nfsctl.c +4
-2@@ -1481,11 +1481,12 @@ static __net_init int nfsd_init_net(struct net *net) goto out_idmap_error; nn->nfsd_versions =NULL ; nn->nfsd4_minorversions =NULL ; + retval =nfsd4_init_leases_net (nn); +if (retval) + goto out_drc_error; retval =nfsd_reply_cache_init (nn);if (retval) goto out_drc_error; -nfsd4_init_leases_net (nn); -get_random_bytes (&nn->siphash_key,sizeof (nn->siphash_key));seqlock_init (&nn->writeverf_lock);@@ -1507,6 +1508,7 @@ static __net_exit void nfsd_exit_net(struct net *net)nfsd_idmap_shutdown (net);nfsd_export_shutdown (net);nfsd_netns_free_versions (net_generic (net, nfsd_net_id)); +nfsd4_leases_net_shutdown (nn); }static struct pernet_operations nfsd_net_ops = {fs/nfsd/nfsd.h +7
-2@@ -498,7 +498,11 @@ extern void unregister_cld_notifier(void);extern void nfsd4_ssc_init_umount_work (struct nfsd_net *nn);#endif -extern void nfsd4_init_leases_net (struct nfsd_net *nn); +extern int nfsd4_init_leases_net (struct nfsd_net *nn); +static inline void nfsd4_leases_net_shutdown (struct nfsd_net *nn) +{ +unregister_shrinker (&nn->nfsd_client_shrinker); +};#else /* CONFIG_NFSD_V4 */ static inline int nfsd4_is_junction (struct dentry *dentry)@@ -506,7 +510,8 @@ static inline int nfsd4_is_junction(struct dentry *dentry)return 0 ; } -static inline void nfsd4_init_leases_net (struct nfsd_net *nn) {}; +static inline int nfsd4_init_leases_net (struct nfsd_net *nn) {return 0 ; }; +static inline void nfsd4_leases_net_shutdown (struct nfsd_net *nn) { };#define register_cld_notifier () 0#define unregister_cld_notifier () do { } while(0)
Signature · 1 line
Jeff Layton <[email protected]>
[email protected]
reviewerRe: [PATCH v2 2/2] NFSD: add shrinker to reap courtesy clients on low memory condition
Quoted 66 lines · Jeff Layton
Quoted 65 lines · Dai Ngo
Add the courtesy client shrinker to react to low memory condition triggered by the memory shrinker.
On the shrinker's count callback, we increment a callback counter and return the number of outstanding courtesy clients. When the laundromat runs, it checks if this counter is not zero and starts reaping old courtesy clients. The maximum number of clients to be reaped is limited to
NFSD_CIENT_MAX_TRIM_PER_RUN(128). This limit is to prevent the laundromat from spending too much time reaping the clients and not processing other tasks in a timely manner.The laundromat is rescheduled to run sooner if it detects low low memory condition and there are more clients to reap.
On the shrinker's scan callback, we return the number of clients That were reaped since the last scan callback. We can not reap the clients on the scan callback context since destroying the client might require call into the underlying filesystem or other subsystems which might allocate memory which can cause deadlock.
Signed-off-by Dai Ngo <[email protected]>--- fs/nfsd/netns.h | 3 +++ fs/nfsd/nfs4state.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++---- fs/nfsd/nfsctl.c | 6 ++++-- fs/nfsd/nfsd.h | 9 +++++++-- 4 files changed, 61 insertions(+), 8 deletions(-)fs/nfsd/netns.h +3
-0@@ -194,6 +194,9 @@ struct nfsd_net {int nfs4_max_clients;atomic_t nfsd_courtesy_client_count; +atomic_t nfsd_client_shrinker_cb_count; +atomic_t nfsd_client_shrinker_reapcount; +struct shrinker nfsd_client_shrinker; };/* Simple check to find out if a given net was properly initialized */ fs/nfsd/nfs4state.c +14
-1@@ -4341,7 +4341,39 @@ nfsd4_init_slabs(void)return -ENOMEM ; } -void nfsd4_init_leases_net (struct nfsd_net *nn) +static unsigned long +nfsd_courtesy_client_count (struct shrinker *shrink,struct shrink_control *sc) +{ +struct nfsd_net *nn =container_of (shrink, + struct nfsd_net, nfsd_client_shrinker); + +atomic_inc (&nn->nfsd_client_shrinker_cb_count); +return (unsigned long )atomic_read (&nn->nfsd_courtesy_client_count); +} + +static unsigned long +nfsd_courtesy_client_scan (struct shrinker *shrink,struct shrink_control *sc) +{ + struct nfsd_net *nn = container_of(shrink,
Quoted 8 lines
fs/nfsd/nfs4state.c nfsd4_init_slabs(void) · line 4362
Quoted 5 lines
fs/nfsd/nfs4state.c +5
-0+ struct nfsd_net, nfsd_client_shrinker); +unsigned long cnt; + + cnt =atomic_read (&nn->nfsd_client_shrinker_reapcount); +atomic_set (&nn->nfsd_client_shrinker_reapcount,0 );Is it legit to return that we freed these objects when it hasn't actually been done yet? Maybe this should always return 0? I'm not sure what the rules are with shrinkers.
nfsd_client_shrinker_reapcount is the actual number of clients that the laudromat was able to destroy in its last run.
Quoted 5 lines
Either way, it seems like "scan" should cue the laundromat to run ASAP. When this is called, it may be quite some time before the laundromat runs again. Currently, it's always just scheduled it out to when we know there may be work to be done, but this is a different situation.
Normally the "scan" callback is used to free unused resources and return the number of objects freed. For the NFSv4 clients, we can not free the clients on the "scan" context due to potential deadlock and also the laundromat might block while destroying the clients. Because of this we use the "count" callback to notify the laundromat of the low memory condition.
In the "count" callback we do not call mod_delayed_work to kick start the laundromat since we do not want to rely on the inner working mod_delayed_work to guarantee no deadlock. I also think we should do the minimal while on the memory shrinker's callback context.
Once the laundromat runs it monitors the low memory condition and reschedules itself to run immediately (NFSD_LAUNDROMAT_MINTIMEOUT) if needed.
Thanks,
-Dai
Quoted 120 lines
Quoted 120 lines
fs/nfsd/nfs4state.c +28
-3+return cnt; +} + +static int +nfsd_register_client_shrinker (struct nfsd_net *nn) +{ + nn->nfsd_client_shrinker.scan_objects = nfsd_courtesy_client_scan; + nn->nfsd_client_shrinker.count_objects = nfsd_courtesy_client_count; + nn->nfsd_client_shrinker.seeks =DEFAULT_SEEKS ; +return register_shrinker (&nn->nfsd_client_shrinker,"nfsd-client" ); +} + +int +nfsd4_init_leases_net (struct nfsd_net *nn) {struct sysinfo si;u64 max_clients;@@ -4362,6 +4394,8 @@ void nfsd4_init_leases_net(struct nfsd_net *nn) nn->nfs4_max_clients =max_t (int, max_clients,NFS4_CLIENTS_PER_GB );atomic_set (&nn->nfsd_courtesy_client_count,0 ); +atomic_set (&nn->nfsd_client_shrinker_cb_count,0 ); +return nfsd_register_client_shrinker (nn); }static void init_nfs4_replay (struct nfs4_replay *rp)@@ -5870,12 +5904,17 @@ static void nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, struct laundry_time *lt) { - unsigned int oldstate, maxreap, reapcnt = 0; + unsigned int oldstate, maxreap = 0, reapcnt = 0; +int cb_cnt;struct list_head *pos, *next;struct nfs4_client *clp; - maxreap = (atomic_read (&nn->nfs4_client_count) >= nn->nfs4_max_clients) ? -NFSD_CLIENT_MAX_TRIM_PER_RUN :0 ; + cb_cnt =atomic_read (&nn->nfsd_client_shrinker_cb_count); +if (atomic_read (&nn->nfs4_client_count) >= nn->nfs4_max_clients || + cb_cnt) { + maxreap =NFSD_CLIENT_MAX_TRIM_PER_RUN ; +atomic_set (&nn->nfsd_client_shrinker_cb_count,0 ); + }INIT_LIST_HEAD (reaplist);spin_lock (&nn->client_lock);list_for_each_safe (pos, next, &nn->client_lru) {@@ -5902,6 +5941,8 @@ nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, } }spin_unlock (&nn->client_lock); +if (cb_cnt) +atomic_add (reapcnt, &nn->nfsd_client_shrinker_reapcount); } static time64_t@@ -5942,6 +5983,8 @@ nfs4_laundromat(struct nfsd_net *nn)list_del_init (&clp->cl_lru);expire_client (clp); } +if (atomic_read (&nn->nfsd_client_shrinker_cb_count) >0 ) + lt.new_timeo =NFSD_LAUNDROMAT_MINTIMEOUT ;spin_lock (&state_lock);list_for_each_safe (pos, next, &nn->del_recall_lru) { dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);fs/nfsd/nfsctl.c +4
-2@@ -1481,11 +1481,12 @@ static __net_init int nfsd_init_net(struct net *net) goto out_idmap_error; nn->nfsd_versions =NULL ; nn->nfsd4_minorversions =NULL ; + retval =nfsd4_init_leases_net (nn); +if (retval) + goto out_drc_error; retval =nfsd_reply_cache_init (nn);if (retval) goto out_drc_error; -nfsd4_init_leases_net (nn); -get_random_bytes (&nn->siphash_key,sizeof (nn->siphash_key));seqlock_init (&nn->writeverf_lock);@@ -1507,6 +1508,7 @@ static __net_exit void nfsd_exit_net(struct net *net)nfsd_idmap_shutdown (net);nfsd_export_shutdown (net);nfsd_netns_free_versions (net_generic (net, nfsd_net_id)); +nfsd4_leases_net_shutdown (nn); }static struct pernet_operations nfsd_net_ops = {fs/nfsd/nfsd.h +7
-2@@ -498,7 +498,11 @@ extern void unregister_cld_notifier(void);extern void nfsd4_ssc_init_umount_work (struct nfsd_net *nn);#endif -extern void nfsd4_init_leases_net (struct nfsd_net *nn); +extern int nfsd4_init_leases_net (struct nfsd_net *nn); +static inline void nfsd4_leases_net_shutdown (struct nfsd_net *nn) +{ +unregister_shrinker (&nn->nfsd_client_shrinker); +};#else /* CONFIG_NFSD_V4 */ static inline int nfsd4_is_junction (struct dentry *dentry)@@ -506,7 +510,8 @@ static inline int nfsd4_is_junction(struct dentry *dentry)return 0 ; } -static inline void nfsd4_init_leases_net (struct nfsd_net *nn) {}; +static inline int nfsd4_init_leases_net (struct nfsd_net *nn) {return 0 ; }; +static inline void nfsd4_leases_net_shutdown (struct nfsd_net *nn) { };#define register_cld_notifier () 0#define unregister_cld_notifier () do { } while(0)
Jeff Layton
maintainerRe: [PATCH v2 2/2] NFSD: add shrinker to reap courtesy clients on low memory condition
Quoted 92 lines · On Mon, 2022-08-29 at 11:25 -0700, [email protected] wrote:
Quoted 66 lines · Jeff Layton
Quoted 65 lines · Dai Ngo
Add the courtesy client shrinker to react to low memory condition triggered by the memory shrinker.
On the shrinker's count callback, we increment a callback counter and return the number of outstanding courtesy clients. When the laundromat runs, it checks if this counter is not zero and starts reaping old courtesy clients. The maximum number of clients to be reaped is limited to
NFSD_CIENT_MAX_TRIM_PER_RUN(128). This limit is to prevent the laundromat from spending too much time reaping the clients and not processing other tasks in a timely manner.The laundromat is rescheduled to run sooner if it detects low low memory condition and there are more clients to reap.
On the shrinker's scan callback, we return the number of clients That were reaped since the last scan callback. We can not reap the clients on the scan callback context since destroying the client might require call into the underlying filesystem or other subsystems which might allocate memory which can cause deadlock.
Signed-off-by Dai Ngo <[email protected]>--- fs/nfsd/netns.h | 3 +++ fs/nfsd/nfs4state.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++---- fs/nfsd/nfsctl.c | 6 ++++-- fs/nfsd/nfsd.h | 9 +++++++-- 4 files changed, 61 insertions(+), 8 deletions(-)fs/nfsd/netns.h +3
-0@@ -194,6 +194,9 @@ struct nfsd_net {int nfs4_max_clients;atomic_t nfsd_courtesy_client_count; +atomic_t nfsd_client_shrinker_cb_count; +atomic_t nfsd_client_shrinker_reapcount; +struct shrinker nfsd_client_shrinker; };/* Simple check to find out if a given net was properly initialized */ fs/nfsd/nfs4state.c +14
-1@@ -4341,7 +4341,39 @@ nfsd4_init_slabs(void)return -ENOMEM ; } -void nfsd4_init_leases_net (struct nfsd_net *nn) +static unsigned long +nfsd_courtesy_client_count (struct shrinker *shrink,struct shrink_control *sc) +{ +struct nfsd_net *nn =container_of (shrink, + struct nfsd_net, nfsd_client_shrinker); + +atomic_inc (&nn->nfsd_client_shrinker_cb_count); +return (unsigned long )atomic_read (&nn->nfsd_courtesy_client_count); +} + +static unsigned long +nfsd_courtesy_client_scan (struct shrinker *shrink,struct shrink_control *sc) +{ + struct nfsd_net *nn = container_of(shrink,Quoted 8 lines
fs/nfsd/nfs4state.c nfsd4_init_slabs(void) · line 4362
Quoted 5 lines
fs/nfsd/nfs4state.c +5
-0+ struct nfsd_net, nfsd_client_shrinker); +unsigned long cnt; + + cnt =atomic_read (&nn->nfsd_client_shrinker_reapcount); +atomic_set (&nn->nfsd_client_shrinker_reapcount,0 );Is it legit to return that we freed these objects when it hasn't actually been done yet? Maybe this should always return 0? I'm not sure what the rules are with shrinkers.
nfsd_client_shrinker_reapcountis the actual number of clients that the laudromat was able to destroy in its last run.Quoted 5 lines
Either way, it seems like "scan" should cue the laundromat to run ASAP. When this is called, it may be quite some time before the laundromat runs again. Currently, it's always just scheduled it out to when we know there may be work to be done, but this is a different situation.
Normally the "scan" callback is used to free unused resources and return the number of objects freed. For the NFSv4 clients, we can not free the clients on the "scan" context due to potential deadlock and also the laundromat might block while destroying the clients. Because of this we use the "count" callback to notify the laundromat of the low memory condition.
Quoted 5 lines
In the "count" callback we do not call
mod_delayed_workto kick start the laundromat since we do not want to rely on the inner workingmod_delayed_workto guarantee no deadlock. I also think we should do the minimal while on the memory shrinker's callback context.
Are you aware of a specific problem with shrinkers and queueing work?
As I understand it, shrinkers are run in the context of an allocation. An allocation crosses a threshold of some sort and and we start trying to free stuff using shrinkers. queueing delayed work will never allocate anything, so I would think it'd be safe to do in the count callback.
Quoted 127 lines
Once the laundromat runs it monitors the low memory condition and reschedules itself to run immediately (
NFSD_LAUNDROMAT_MINTIMEOUT) if needed.Thanks,
-DaiQuoted 120 lines
Quoted 120 lines
fs/nfsd/nfs4state.c +28
-3+return cnt; +} + +static int +nfsd_register_client_shrinker (struct nfsd_net *nn) +{ + nn->nfsd_client_shrinker.scan_objects = nfsd_courtesy_client_scan; + nn->nfsd_client_shrinker.count_objects = nfsd_courtesy_client_count; + nn->nfsd_client_shrinker.seeks =DEFAULT_SEEKS ; +return register_shrinker (&nn->nfsd_client_shrinker,"nfsd-client" ); +} + +int +nfsd4_init_leases_net (struct nfsd_net *nn) {struct sysinfo si;u64 max_clients;@@ -4362,6 +4394,8 @@ void nfsd4_init_leases_net(struct nfsd_net *nn) nn->nfs4_max_clients =max_t (int, max_clients,NFS4_CLIENTS_PER_GB );atomic_set (&nn->nfsd_courtesy_client_count,0 ); +atomic_set (&nn->nfsd_client_shrinker_cb_count,0 ); +return nfsd_register_client_shrinker (nn); }static void init_nfs4_replay (struct nfs4_replay *rp)@@ -5870,12 +5904,17 @@ static void nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, struct laundry_time *lt) { - unsigned int oldstate, maxreap, reapcnt = 0; + unsigned int oldstate, maxreap = 0, reapcnt = 0; +int cb_cnt;struct list_head *pos, *next;struct nfs4_client *clp; - maxreap = (atomic_read (&nn->nfs4_client_count) >= nn->nfs4_max_clients) ? -NFSD_CLIENT_MAX_TRIM_PER_RUN :0 ; + cb_cnt =atomic_read (&nn->nfsd_client_shrinker_cb_count); +if (atomic_read (&nn->nfs4_client_count) >= nn->nfs4_max_clients || + cb_cnt) { + maxreap =NFSD_CLIENT_MAX_TRIM_PER_RUN ; +atomic_set (&nn->nfsd_client_shrinker_cb_count,0 ); + }INIT_LIST_HEAD (reaplist);spin_lock (&nn->client_lock);list_for_each_safe (pos, next, &nn->client_lru) {@@ -5902,6 +5941,8 @@ nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, } }spin_unlock (&nn->client_lock); +if (cb_cnt) +atomic_add (reapcnt, &nn->nfsd_client_shrinker_reapcount); } static time64_t@@ -5942,6 +5983,8 @@ nfs4_laundromat(struct nfsd_net *nn)list_del_init (&clp->cl_lru);expire_client (clp); } +if (atomic_read (&nn->nfsd_client_shrinker_cb_count) >0 ) + lt.new_timeo =NFSD_LAUNDROMAT_MINTIMEOUT ;spin_lock (&state_lock);list_for_each_safe (pos, next, &nn->del_recall_lru) { dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);fs/nfsd/nfsctl.c +4
-2@@ -1481,11 +1481,12 @@ static __net_init int nfsd_init_net(struct net *net) goto out_idmap_error; nn->nfsd_versions =NULL ; nn->nfsd4_minorversions =NULL ; + retval =nfsd4_init_leases_net (nn); +if (retval) + goto out_drc_error; retval =nfsd_reply_cache_init (nn);if (retval) goto out_drc_error; -nfsd4_init_leases_net (nn); -get_random_bytes (&nn->siphash_key,sizeof (nn->siphash_key));seqlock_init (&nn->writeverf_lock);@@ -1507,6 +1508,7 @@ static __net_exit void nfsd_exit_net(struct net *net)nfsd_idmap_shutdown (net);nfsd_export_shutdown (net);nfsd_netns_free_versions (net_generic (net, nfsd_net_id)); +nfsd4_leases_net_shutdown (nn); }static struct pernet_operations nfsd_net_ops = {fs/nfsd/nfsd.h +7
-2@@ -498,7 +498,11 @@ extern void unregister_cld_notifier(void);extern void nfsd4_ssc_init_umount_work (struct nfsd_net *nn);#endif -extern void nfsd4_init_leases_net (struct nfsd_net *nn); +extern int nfsd4_init_leases_net (struct nfsd_net *nn); +static inline void nfsd4_leases_net_shutdown (struct nfsd_net *nn) +{ +unregister_shrinker (&nn->nfsd_client_shrinker); +};#else /* CONFIG_NFSD_V4 */ static inline int nfsd4_is_junction (struct dentry *dentry)@@ -506,7 +510,8 @@ static inline int nfsd4_is_junction(struct dentry *dentry)return 0 ; } -static inline void nfsd4_init_leases_net (struct nfsd_net *nn) {}; +static inline int nfsd4_init_leases_net (struct nfsd_net *nn) {return 0 ; }; +static inline void nfsd4_leases_net_shutdown (struct nfsd_net *nn) { };#define register_cld_notifier () 0#define unregister_cld_notifier () do { } while(0)
Signature · 1 line
Jeff Layton <[email protected]>
[email protected]
reviewerRe: [PATCH v2 2/2] NFSD: add shrinker to reap courtesy clients on low memory condition
Quoted 95 lines · Jeff Layton
Quoted 89 lines · On Mon, 2022-08-29 at 11:25 -0700, [email protected] wrote:
Quoted 66 lines · Jeff Layton
Quoted 65 lines · Dai Ngo
Add the courtesy client shrinker to react to low memory condition triggered by the memory shrinker.
On the shrinker's count callback, we increment a callback counter and return the number of outstanding courtesy clients. When the laundromat runs, it checks if this counter is not zero and starts reaping old courtesy clients. The maximum number of clients to be reaped is limited to
NFSD_CIENT_MAX_TRIM_PER_RUN(128). This limit is to prevent the laundromat from spending too much time reaping the clients and not processing other tasks in a timely manner.The laundromat is rescheduled to run sooner if it detects low low memory condition and there are more clients to reap.
On the shrinker's scan callback, we return the number of clients That were reaped since the last scan callback. We can not reap the clients on the scan callback context since destroying the client might require call into the underlying filesystem or other subsystems which might allocate memory which can cause deadlock.
Signed-off-by Dai Ngo <[email protected]>--- fs/nfsd/netns.h | 3 +++ fs/nfsd/nfs4state.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++---- fs/nfsd/nfsctl.c | 6 ++++-- fs/nfsd/nfsd.h | 9 +++++++-- 4 files changed, 61 insertions(+), 8 deletions(-)fs/nfsd/netns.h +3
-0@@ -194,6 +194,9 @@ struct nfsd_net {int nfs4_max_clients;atomic_t nfsd_courtesy_client_count; +atomic_t nfsd_client_shrinker_cb_count; +atomic_t nfsd_client_shrinker_reapcount; +struct shrinker nfsd_client_shrinker; };/* Simple check to find out if a given net was properly initialized */ fs/nfsd/nfs4state.c +14
-1@@ -4341,7 +4341,39 @@ nfsd4_init_slabs(void)return -ENOMEM ; } -void nfsd4_init_leases_net (struct nfsd_net *nn) +static unsigned long +nfsd_courtesy_client_count (struct shrinker *shrink,struct shrink_control *sc) +{ +struct nfsd_net *nn =container_of (shrink, + struct nfsd_net, nfsd_client_shrinker); + +atomic_inc (&nn->nfsd_client_shrinker_cb_count); +return (unsigned long )atomic_read (&nn->nfsd_courtesy_client_count); +} + +static unsigned long +nfsd_courtesy_client_scan (struct shrinker *shrink,struct shrink_control *sc) +{ + struct nfsd_net *nn = container_of(shrink,Quoted 8 lines
fs/nfsd/nfs4state.c nfsd4_init_slabs(void) · line 4362
Quoted 5 lines
fs/nfsd/nfs4state.c +5
-0+ struct nfsd_net, nfsd_client_shrinker); +unsigned long cnt; + + cnt =atomic_read (&nn->nfsd_client_shrinker_reapcount); +atomic_set (&nn->nfsd_client_shrinker_reapcount,0 );Is it legit to return that we freed these objects when it hasn't actually been done yet? Maybe this should always return 0? I'm not sure what the rules are with shrinkers.
nfsd_client_shrinker_reapcountis the actual number of clients that the laudromat was able to destroy in its last run.Quoted 4 lines
Either way, it seems like "scan" should cue the laundromat to run ASAP. When this is called, it may be quite some time before the laundromat runs again. Currently, it's always just scheduled it out to when we know there may be work to be done, but this is a different situation.
Normally the "scan" callback is used to free unused resources and return the number of objects freed. For the NFSv4 clients, we can not free the clients on the "scan" context due to potential deadlock and also the laundromat might block while destroying the clients. Because of this we use the "count" callback to notify the laundromat of the low memory condition.
Quoted 5 lines
In the "count" callback we do not call
mod_delayed_workto kick start the laundromat since we do not want to rely on the inner workingmod_delayed_workto guarantee no deadlock. I also think we should do the minimal while on the memory shrinker's callback context.
Quoted 6 lines
Are you aware of a specific problem with shrinkers and queueing work?
As I understand it, shrinkers are run in the context of an allocation. An allocation crosses a threshold of some sort and and we start trying to free stuff using shrinkers. queueing delayed work will never allocate anything, so I would think it'd be safe to do in the count callback.
ok, I'll try to add mod_delayed_work on the "count" callback. I remember vaguely that I ran into some trouble before but that might have been caused by something else.
-Dai
Quoted 127 lines
Quoted 127 lines
Once the laundromat runs it monitors the low memory condition and reschedules itself to run immediately (
NFSD_LAUNDROMAT_MINTIMEOUT) if needed.Thanks,
-DaiQuoted 119 lines
Quoted 119 lines
fs/nfsd/nfs4state.c +28
-3+return cnt; +} + +static int +nfsd_register_client_shrinker (struct nfsd_net *nn) +{ + nn->nfsd_client_shrinker.scan_objects = nfsd_courtesy_client_scan; + nn->nfsd_client_shrinker.count_objects = nfsd_courtesy_client_count; + nn->nfsd_client_shrinker.seeks =DEFAULT_SEEKS ; +return register_shrinker (&nn->nfsd_client_shrinker,"nfsd-client" ); +} + +int +nfsd4_init_leases_net (struct nfsd_net *nn) {struct sysinfo si;u64 max_clients;@@ -4362,6 +4394,8 @@ void nfsd4_init_leases_net(struct nfsd_net *nn) nn->nfs4_max_clients =max_t (int, max_clients,NFS4_CLIENTS_PER_GB );atomic_set (&nn->nfsd_courtesy_client_count,0 ); +atomic_set (&nn->nfsd_client_shrinker_cb_count,0 ); +return nfsd_register_client_shrinker (nn); }static void init_nfs4_replay (struct nfs4_replay *rp)@@ -5870,12 +5904,17 @@ static void nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, struct laundry_time *lt) { - unsigned int oldstate, maxreap, reapcnt = 0; + unsigned int oldstate, maxreap = 0, reapcnt = 0; +int cb_cnt;struct list_head *pos, *next;struct nfs4_client *clp; - maxreap = (atomic_read (&nn->nfs4_client_count) >= nn->nfs4_max_clients) ? -NFSD_CLIENT_MAX_TRIM_PER_RUN :0 ; + cb_cnt =atomic_read (&nn->nfsd_client_shrinker_cb_count); +if (atomic_read (&nn->nfs4_client_count) >= nn->nfs4_max_clients || + cb_cnt) { + maxreap =NFSD_CLIENT_MAX_TRIM_PER_RUN ; +atomic_set (&nn->nfsd_client_shrinker_cb_count,0 ); + }INIT_LIST_HEAD (reaplist);spin_lock (&nn->client_lock);list_for_each_safe (pos, next, &nn->client_lru) {@@ -5902,6 +5941,8 @@ nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist, } }spin_unlock (&nn->client_lock); +if (cb_cnt) +atomic_add (reapcnt, &nn->nfsd_client_shrinker_reapcount); } static time64_t@@ -5942,6 +5983,8 @@ nfs4_laundromat(struct nfsd_net *nn)list_del_init (&clp->cl_lru);expire_client (clp); } +if (atomic_read (&nn->nfsd_client_shrinker_cb_count) >0 ) + lt.new_timeo =NFSD_LAUNDROMAT_MINTIMEOUT ;spin_lock (&state_lock);list_for_each_safe (pos, next, &nn->del_recall_lru) { dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);fs/nfsd/nfsctl.c +4
-2@@ -1481,11 +1481,12 @@ static __net_init int nfsd_init_net(struct net *net) goto out_idmap_error; nn->nfsd_versions =NULL ; nn->nfsd4_minorversions =NULL ; + retval =nfsd4_init_leases_net (nn); +if (retval) + goto out_drc_error; retval =nfsd_reply_cache_init (nn);if (retval) goto out_drc_error; -nfsd4_init_leases_net (nn); -get_random_bytes (&nn->siphash_key,sizeof (nn->siphash_key));seqlock_init (&nn->writeverf_lock);@@ -1507,6 +1508,7 @@ static __net_exit void nfsd_exit_net(struct net *net)nfsd_idmap_shutdown (net);nfsd_export_shutdown (net);nfsd_netns_free_versions (net_generic (net, nfsd_net_id)); +nfsd4_leases_net_shutdown (nn); }static struct pernet_operations nfsd_net_ops = {fs/nfsd/nfsd.h +7
-2@@ -498,7 +498,11 @@ extern void unregister_cld_notifier(void);extern void nfsd4_ssc_init_umount_work (struct nfsd_net *nn);#endif -extern void nfsd4_init_leases_net (struct nfsd_net *nn); +extern int nfsd4_init_leases_net (struct nfsd_net *nn); +static inline void nfsd4_leases_net_shutdown (struct nfsd_net *nn) +{ +unregister_shrinker (&nn->nfsd_client_shrinker); +};#else /* CONFIG_NFSD_V4 */ static inline int nfsd4_is_junction (struct dentry *dentry)@@ -506,7 +510,8 @@ static inline int nfsd4_is_junction(struct dentry *dentry)return 0 ; } -static inline void nfsd4_init_leases_net (struct nfsd_net *nn) {}; +static inline int nfsd4_init_leases_net (struct nfsd_net *nn) {return 0 ; }; +static inline void nfsd4_leases_net_shutdown (struct nfsd_net *nn) { };#define register_cld_notifier () 0#define unregister_cld_notifier () do { } while(0)