Skip to contentSkip to conversation

Revert "SUNRPC: Reduce thread wake-up rate when receiving large RPC messages"

PATCH In review [email protected] 5 participants 11 messages Jan 3, 2025 – Jan 6, 2025

Subsystems (3)
lore
Share & tools
lore

[email protected]

author maintainer
#0 lore raw

PATCH 1/2 Revert "SUNRPC: Reduce thread wake-up rate when receiving large RPC messages"

From: Chuck Lever <[email protected]>

I noticed that a handful of NFSv3 fstests were taking an unexpectedly long time to run. Troubleshooting showed that the server's TCP window closed and never re-opened, which caused the client to trigger an RPC retransmit timeout after 180 seconds.

The client's recovery action was to establish a fresh connection and retransmit the timed-out requests. This worked, but it adds a long delay.

I tracked the problem to the commit that attempted to reduce the rate at which the network layer delivers TCP socket data_ready callbacks. Under most circumstances this change worked as expected, but for NFSv3, which has no session or other type of throttling, it can overwhelm the receiver on occasion.

I'm sure I could tweak the lowat settings, but the small benefit doesn't seem worth the bother. Just revert it.

Fixes 2b877fc53e97 ("SUNRPC: Reduce thread wake-up rate when receiving large RPC messages")
Cc Jakub Kicinski <[email protected]>
---
 net/sunrpc/svcsock.c | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)
net/sunrpc/svcsock.c +1 -11
index 95397677673b..cb3bd12f5818 100644
@@ -1083,9 +1083,6 @@ static void svc_tcp_fragment_received(struct svc_sock *svsk)
 	/* If we have more data, signal svc_xprt_enqueue() to try again */
 	svsk->sk_tcplen = 0;
 	svsk->sk_marker = xdr_zero;
-
-	smp_wmb();
-	tcp_set_rcvlowat(svsk->sk_sk, 1);
 }
 
 /**
@@ -1175,17 +1172,10 @@ static int svc_tcp_recvfrom(struct svc_rqst *rqstp)
 		goto err_delete;
 	if (len == want)
 		svc_tcp_fragment_received(svsk);
-	else {
-		/* Avoid more ->sk_data_ready() calls until the rest
-		 * of the message has arrived. This reduces service
-		 * thread wake-ups on large incoming messages. */
-		tcp_set_rcvlowat(svsk->sk_sk,
-				 svc_sock_reclen(svsk) - svsk->sk_tcplen);
-
+	else
 		trace_svcsock_tcp_recv_short(&svsk->sk_xprt,
 				svc_sock_reclen(svsk),
 				svsk->sk_tcplen - sizeof(rpc_fraghdr));
-	}
 	goto err_noclose;
 error:
 	if (len != -EAGAIN)
Signature · 1 line
2.47.0
author maintainer
#1 lore raw

PATCH 2/2 NFSD: Change the filecache laundrette workqueue again

From: Chuck Lever <[email protected]>

Youzhong Yang <[email protected]> noticed the workqueue subsystem complaining about how long the filecache laundrette was running. This resulted in switching from using the system_wq for the laundrette to system_unbound_wq (see commit 4b84551a35e3 ("nfsd: use system_unbound_wq for nfsd_file_gc_worker()").

However, I've seen the laundrette running for multiple milliseconds on some workloads, delaying other work. For the purpose of scheduling fairness, perhaps a better choice would be to process filecache disposal queues on the system_long_wq instead.

---
 fs/nfsd/filecache.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/nfsd/filecache.c +1 -1
index a1cdba42c4fa..91a535c2dede 100644
@@ -112,7 +112,7 @@ static void
 nfsd_file_schedule_laundrette(void)
 {
 	if (test_bit(NFSD_FILE_CACHE_UP, &nfsd_file_flags))
-		queue_delayed_work(system_unbound_wq, &nfsd_filecache_laundrette,
+		queue_delayed_work(system_long_wq, &nfsd_filecache_laundrette,
 				   NFSD_LAUNDRETTE_DELAY);
 }
 
Signature · 1 line
2.47.0
maintainer Reviewed-by on v1 1/2
#9 lore raw
In reply to [email protected]
Quoted 42 lines · On Thu, 2025-01-02 at 20:00 -0500, [email protected] wrote:

From: Chuck Lever <[email protected]>

I noticed that a handful of NFSv3 fstests were taking an unexpectedly long time to run. Troubleshooting showed that the server's TCP window closed and never re-opened, which caused the client to trigger an RPC retransmit timeout after 180 seconds.

The client's recovery action was to establish a fresh connection and retransmit the timed-out requests. This worked, but it adds a long delay.

I tracked the problem to the commit that attempted to reduce the rate at which the network layer delivers TCP socket data_ready callbacks. Under most circumstances this change worked as expected, but for NFSv3, which has no session or other type of throttling, it can overwhelm the receiver on occasion.

I'm sure I could tweak the lowat settings, but the small benefit doesn't seem worth the bother. Just revert it.

Fixes 2b877fc53e97 ("SUNRPC: Reduce thread wake-up rate when receiving large RPC messages")
Cc Jakub Kicinski <[email protected]>
---
 net/sunrpc/svcsock.c | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)
net/sunrpc/svcsock.c +0 -3
index 95397677673b..cb3bd12f5818 100644
@@ -1083,9 +1083,6 @@ static void svc_tcp_fragment_received(struct svc_sock *svsk)
 	/* If we have more data, signal svc_xprt_enqueue() to try again */
 	svsk->sk_tcplen = 0;
 	svsk->sk_marker = xdr_zero;
-
-	smp_wmb();
-	tcp_set_rcvlowat(svsk->sk_sk, 1);
 }
 
 /**

net/sunrpc/svcsock.c static int svc_tcp_recvfrom(struct svc_rqst *rqstp) · line 1183

Quoted 9 lines
net/sunrpc/svcsock.c +0 -6
@@ -1175,17 +1172,10 @@ static int svc_tcp_recvfrom(struct svc_rqst *rqstp)
 		goto err_delete;
 	if (len == want)
 		svc_tcp_fragment_received(svsk);
-	else {
-		/* Avoid more ->sk_data_ready() calls until the rest
-		 * of the message has arrived. This reduces service
-		 * thread wake-ups on large incoming messages. */
-		tcp_set_rcvlowat(svsk->sk_sk,
-				 svc_sock_reclen(svsk) - svsk->sk_tcplen);

Could we instead clamp this to the window size so that we at least only do a wakeup for each window-size chunk?

net/sunrpc/svcsock.c static int svc_tcp_recvfrom(struct svc_rqst *rqstp) · line 1181

Quoted 9 lines
net/sunrpc/svcsock.c +1 -2
-
+	else
 		trace_svcsock_tcp_recv_short(&svsk->sk_xprt,
 				svc_sock_reclen(svsk),
 				svsk->sk_tcplen - sizeof(rpc_fraghdr));
-	}
 	goto err_noclose;
 error:
 	if (len != -EAGAIN)

Reverting for now is fine though.

maintainer Reviewed-by on v1 2/2
#2 lore raw

Re: [PATCH v1 2/2] NFSD: Change the filecache laundrette workqueue again

In reply to [email protected]
Quoted 24 lines · On Thu, 2025-01-02 at 20:00 -0500, [email protected] wrote:

From: Chuck Lever <[email protected]>

Youzhong Yang <[email protected]> noticed the workqueue subsystem complaining about how long the filecache laundrette was running. This resulted in switching from using the system_wq for the laundrette to system_unbound_wq (see commit 4b84551a35e3 ("nfsd: use system_unbound_wq for nfsd_file_gc_worker()").

However, I've seen the laundrette running for multiple milliseconds on some workloads, delaying other work. For the purpose of scheduling fairness, perhaps a better choice would be to process filecache disposal queues on the system_long_wq instead.

---
 fs/nfsd/filecache.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/nfsd/filecache.c +0 -0
index a1cdba42c4fa..91a535c2dede 100644

fs/nfsd/filecache.c static void · line 118

Quoted 8 lines
fs/nfsd/filecache.c +1 -1
@@ -112,7 +112,7 @@ static void
 nfsd_file_schedule_laundrette(void)
 {
 	if (test_bit(NFSD_FILE_CACHE_UP, &nfsd_file_flags))
-		queue_delayed_work(system_unbound_wq, &nfsd_filecache_laundrette,
+		queue_delayed_work(system_long_wq, &nfsd_filecache_laundrette,
 				   NFSD_LAUNDRETTE_DELAY);
 }
 

TIL that there is system_long_wq! Seems like a reasonable thing to do since this is generally low-priority work.

#3 lore raw

Re: [PATCH v1 2/2] NFSD: Change the filecache laundrette workqueue again

In reply to [email protected]
Quoted 24 lines · On Fri, 03 Jan 2025, [email protected] wrote:

From: Chuck Lever <[email protected]>

Youzhong Yang <[email protected]> noticed the workqueue subsystem complaining about how long the filecache laundrette was running. This resulted in switching from using the system_wq for the laundrette to system_unbound_wq (see commit 4b84551a35e3 ("nfsd: use system_unbound_wq for nfsd_file_gc_worker()").

However, I've seen the laundrette running for multiple milliseconds on some workloads, delaying other work. For the purpose of scheduling fairness, perhaps a better choice would be to process filecache disposal queues on the system_long_wq instead.

---
 fs/nfsd/filecache.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/nfsd/filecache.c +0 -0
index a1cdba42c4fa..91a535c2dede 100644

fs/nfsd/filecache.c static void · line 116

Quoted 6 lines
fs/nfsd/filecache.c +1 -1
@@ -112,7 +112,7 @@ static void
 nfsd_file_schedule_laundrette(void)
 {
 	if (test_bit(NFSD_FILE_CACHE_UP, &nfsd_file_flags))
-		queue_delayed_work(system_unbound_wq, &nfsd_filecache_laundrette,
+		queue_delayed_work(system_long_wq, &nfsd_filecache_laundrette,
 				   NFSD_LAUNDRETTE_DELAY);

This doesn't seem right to me.
"unbound_wq" is not bound to an CPU. It just gets allocated that thread which shouldn't interfere with any other work (except for normal scheduling contention) until the queue limit is reach, which is unlikely to happen often.

"long_wq" IS bound to a CPU and is concurrency managed so it could interfere with other things. The idea is that work items scheduled there are not in a hurry and could take longer. But I dont' think they should take very long...

I think the problem is elsewhere.
list_lru_walk() can hold a spin lock for as long as it takes to walk nr_to_walk objects. This will tie up the CPU no matter which work queue it is running on.

I think that instead of passing "list_lru_count()" we should pass some constant like 1024.

cnt = list_lru_count()
while (cnt > 0) {
num = min(cnt, 1024);
list_lru_walk(...., num);
cond_sched()
cnt -= num;
}

Then run it from system_wq.

list_lru_shrink is most often called as list_lru_shrink_walk() from a shrinker, and the pattern there is essentially that above. A count is taken, possibly scaled down, then the shrinker is called in batches.

NeilBrown

#4 lore raw

Re: [PATCH v1 2/2] NFSD: Change the filecache laundrette workqueue again

Quoted 1 line · NeilBrown

On Fri, 03 Jan 2025, [email protected] wrote:

...

Quoted 11 lines

I think that instead of passing "list_lru_count()" we should pass some constant like 1024.

cnt = list_lru_count()

while (cnt > 0) {
   num = min(cnt, 1024);
   list_lru_walk(...., num);
   cond_sched()
   cnt -= num;
}
Quoted 5 lines

Then run it from system_wq.

list_lru_shrink is most often called as list_lru_shrink_walk() from a shrinker, and the pattern there is essentially that above. A count is taken, possibly scaled down, then the shrinker is called in batches.

BTW, there's nothing wrong with taking some msecs or even tens of msecs running on system_unbound_wq, so the current state may be fine too.

Thanks.

Signature · 1 line
tejun
#10 lore raw
In reply to Jeff Layton
Quoted 41 lines · Jeff Layton
Quoted 40 lines · On Thu, 2025-01-02 at 20:00 -0500, [email protected] wrote:

From: Chuck Lever <[email protected]>

I noticed that a handful of NFSv3 fstests were taking an unexpectedly long time to run. Troubleshooting showed that the server's TCP window closed and never re-opened, which caused the client to trigger an RPC retransmit timeout after 180 seconds.

The client's recovery action was to establish a fresh connection and retransmit the timed-out requests. This worked, but it adds a long delay.

I tracked the problem to the commit that attempted to reduce the rate at which the network layer delivers TCP socket data_ready callbacks. Under most circumstances this change worked as expected, but for NFSv3, which has no session or other type of throttling, it can overwhelm the receiver on occasion.

I'm sure I could tweak the lowat settings, but the small benefit doesn't seem worth the bother. Just revert it.

Fixes 2b877fc53e97 ("SUNRPC: Reduce thread wake-up rate when receiving large RPC messages")
Cc Jakub Kicinski <[email protected]>
---
 net/sunrpc/svcsock.c | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)
net/sunrpc/svcsock.c +0 -3
index 95397677673b..cb3bd12f5818 100644
@@ -1083,9 +1083,6 @@ static void svc_tcp_fragment_received(struct svc_sock *svsk)
 	/* If we have more data, signal svc_xprt_enqueue() to try again */
 	svsk->sk_tcplen = 0;
 	svsk->sk_marker = xdr_zero;
-
-	smp_wmb();
-	tcp_set_rcvlowat(svsk->sk_sk, 1);
 }
 
Quoted 14 lines

net/sunrpc/svcsock.c static int svc_tcp_recvfrom(struct svc_rqst *rqstp) · line 1183

Quoted 11 lines
net/sunrpc/svcsock.c +0 -6
 /**
@@ -1175,17 +1172,10 @@ static int svc_tcp_recvfrom(struct svc_rqst *rqstp)
 		goto err_delete;
 	if (len == want)
 		svc_tcp_fragment_received(svsk);
-	else {
-		/* Avoid more ->sk_data_ready() calls until the rest
-		 * of the message has arrived. This reduces service
-		 * thread wake-ups on large incoming messages. */
-		tcp_set_rcvlowat(svsk->sk_sk,
-				 svc_sock_reclen(svsk) - svsk->sk_tcplen);

Could we instead clamp this to the window size so that we at least only do a wakeup for each window-size chunk?

tcp_set_rcvlowat() already imposes and upper limit - based on configured queue space. So I don't think we need to clamp.

I note that the calculation is wrong. sk_tcplen includes the size of the 4byte length header, but svc_sock_reclen() does not. Other places there these two numbers are compared, sizeof(rpc_fraghdr) is subtracted from sk_tcplen.
So there is a corner case where the size passed to tcp_set_rcvlowat() is negative. The two numbers in the subtraction are u32 and the function expects "int".
I didn't dig enough to understand how an negative would be handled.

Quoted 12 lines

net/sunrpc/svcsock.c static int svc_tcp_recvfrom(struct svc_rqst *rqstp) · line 1181

Quoted 10 lines
net/sunrpc/svcsock.c +1 -2
-
+	else
 		trace_svcsock_tcp_recv_short(&svsk->sk_xprt,
 				svc_sock_reclen(svsk),
 				svsk->sk_tcplen - sizeof(rpc_fraghdr));
-	}
 	goto err_noclose;
 error:
 	if (len != -EAGAIN)

Reverting for now is fine though.

Agreed. I would expect modern network cards to deliver fairly large packets to the application already. Still, it would be nice to understand what is really happening. Setting rcvlowat shouldn't be able to cause the window size to go to zero.

NeilBrown

Quoted 3 lines
#5 lore raw

Re: [PATCH v1 2/2] NFSD: Change the filecache laundrette workqueue again

In reply to Tejun Heo
Quoted 14 lines · Tejun Heo
Quoted 1 line · NeilBrown

On Fri, 03 Jan 2025, [email protected] wrote:

...

Quoted 11 lines

I think that instead of passing "list_lru_count()" we should pass some constant like 1024.

cnt = list_lru_count()

while (cnt > 0) {
    num = min(cnt, 1024);
    list_lru_walk(...., num);
    cond_sched()
    cnt -= num;
}
Quoted 8 lines
Quoted 5 lines

Then run it from system_wq.

list_lru_shrink is most often called as list_lru_shrink_walk() from a shrinker, and the pattern there is essentially that above. A count is taken, possibly scaled down, then the shrinker is called in batches.

BTW, there's nothing wrong with taking some msecs or even tens of msecs running on system_unbound_wq, so the current state may be fine too.

My thinking was that this work is low priority, so there should be plenty of opportunity to set it aside for a few moments and handle higher priority work. Maybe not worrisome on systems with a high core count, but on small SMP (eg VM guests), I've found that tasks like this can be rude neighbors.

We could do this by adding a cond_resched() call site in the loop, or take Neil's suggestion of breaking up the free list across multiple work items that handle one or just a few file releases each.

Signature · 1 line
Chuck Lever
#6 lore raw

Re: [PATCH v1 2/2] NFSD: Change the filecache laundrette workqueue again

Quoted 21 lines · Chuck Lever
Quoted 20 lines · Tejun Heo
Quoted 1 line · NeilBrown

On Fri, 03 Jan 2025, [email protected] wrote:

...

Quoted 16 lines

I think that instead of passing "list_lru_count()" we should pass some constant like 1024.

cnt = list_lru_count()

while (cnt > 0) {
    num = min(cnt, 1024);
    list_lru_walk(...., num);
    cond_sched()
    cnt -= num;
}

Then run it from system_wq.

list_lru_shrink is most often called as list_lru_shrink_walk() from a shrinker, and the pattern there is essentially that above. A count is taken, possibly scaled down, then the shrinker is called in batches.

Quoted 8 lines
Quoted 2 lines

BTW, there's nothing wrong with taking some msecs or even tens of msecs running on system_unbound_wq, so the current state may be fine too.

My thinking was that this work is low priority, so there should be plenty of opportunity to set it aside for a few moments and handle higher priority work. Maybe not worrisome on systems with a high core count, but on small SMP (eg VM guests), I've found that tasks like this can be rude neighbors.

None of the different work queues are expected to "set aside" the work for more than a normal scheduling time slice.
system_long_wq was created "so that flush_scheduled_work() doesn't take so long" but flush_scheduled_work() is never called now (and would generate a warning if it was) so system_long_wq should really be removed.

system_unbound_wq uses threads that are not bound to a CPU so the scheduler can move them around. That is most suitable for something that might run for a long time.

system_wq is bound to the CPU that schedules the work, but it can run multiple work items - potentially long running ones - without trouble by helping the scheduler share the CPU among them. This requires that they can sleep of course.

I haven't seen the actually symptoms that resulted in the various changes to this code, but that last point is I think the key one. The work item, like all kernel code, needs to have scheduler points if it might run for a longish time. list_lru_walk() doesn't contain any scheduling points so giving a large "nr_to_walk" is always a bad idea.

Quoted 4 lines

We could do this by adding a cond_resched() call site in the loop, or take Neil's suggestion of breaking up the free list across multiple work items that handle one or just a few file releases each.

I guess I should send a proper patch.

NeilBrown

Quoted 4 lines
Signature · 2 lines
-- 
Chuck Lever
#7 lore raw

Re: [PATCH v1 2/2] NFSD: Change the filecache laundrette workqueue again

Quoted 38 lines · NeilBrown
Quoted 21 lines · Chuck Lever
Quoted 20 lines · Tejun Heo
Quoted 1 line · NeilBrown

On Fri, 03 Jan 2025, [email protected] wrote:

...

Quoted 16 lines

I think that instead of passing "list_lru_count()" we should pass some constant like 1024.

cnt = list_lru_count()

while (cnt > 0) {
     num = min(cnt, 1024);
     list_lru_walk(...., num);
     cond_sched()
     cnt -= num;
}

Then run it from system_wq.

list_lru_shrink is most often called as list_lru_shrink_walk() from a shrinker, and the pattern there is essentially that above. A count is taken, possibly scaled down, then the shrinker is called in batches.

Quoted 8 lines
Quoted 2 lines

BTW, there's nothing wrong with taking some msecs or even tens of msecs running on system_unbound_wq, so the current state may be fine too.

My thinking was that this work is low priority, so there should be plenty of opportunity to set it aside for a few moments and handle higher priority work. Maybe not worrisome on systems with a high core count, but on small SMP (eg VM guests), I've found that tasks like this can be rude neighbors.

None of the different work queues are expected to "set aside" the work for more than a normal scheduling time slice.
system_long_wq was created "so that flush_scheduled_work() doesn't take so long" but flush_scheduled_work() is never called now (and would generate a warning if it was) so system_long_wq should really be removed.

Quoted 3 lines

system_unbound_wq uses threads that are not bound to a CPU so the scheduler can move them around. That is most suitable for something that might run for a long time.

That's not my understanding: unbound selects a CPU to run the work item on, and it can be (and usually is) not the same CPU as the one that invoked queue_work(). Then it isn't rescheduled. The work items are expected to complete quickly; work item termination is the typical reschedule point. My understanding, as always, could be stale.

But that's neither here nor there: I've dropped the patch to replace system_unbound_wq with system_long_wq.

Quoted 10 lines

system_wq is bound to the CPU that schedules the work, but it can run multiple work items - potentially long running ones - without trouble by helping the scheduler share the CPU among them. This requires that they can sleep of course.

I haven't seen the actually symptoms that resulted in the various changes to this code, but that last point is I think the key one. The work item, like all kernel code, needs to have scheduler points if it might run for a longish time. list_lru_walk() doesn't contain any scheduling points so giving a large "nr_to_walk" is always a bad idea.

That might be a overstated... I don't see other consumers that are so concerned about rescheduling. But then it's not clear if they are dealing with lengthy LRU lists.

Quoted 5 lines
Quoted 3 lines

We could do this by adding a cond_resched() call site in the loop, or take Neil's suggestion of breaking up the free list across multiple work items that handle one or just a few file releases each.

I guess I should send a proper patch.

More comments in reply to that patch. Generally speaking, I'm comfortable chopping up the work as you propose, we just have to address some details.

Signature · 1 line
Chuck Lever
#8 lore raw

Re: [PATCH v1 2/2] NFSD: Change the filecache laundrette workqueue again

Quoted 43 lines · Chuck Lever
Quoted 38 lines · NeilBrown
Quoted 21 lines · Chuck Lever
Quoted 20 lines · Tejun Heo
Quoted 1 line · NeilBrown

On Fri, 03 Jan 2025, [email protected] wrote:

...

Quoted 16 lines

I think that instead of passing "list_lru_count()" we should pass some constant like 1024.

cnt = list_lru_count()

while (cnt > 0) {
     num = min(cnt, 1024);
     list_lru_walk(...., num);
     cond_sched()
     cnt -= num;
}

Then run it from system_wq.

list_lru_shrink is most often called as list_lru_shrink_walk() from a shrinker, and the pattern there is essentially that above. A count is taken, possibly scaled down, then the shrinker is called in batches.

Quoted 8 lines
Quoted 2 lines

BTW, there's nothing wrong with taking some msecs or even tens of msecs running on system_unbound_wq, so the current state may be fine too.

My thinking was that this work is low priority, so there should be plenty of opportunity to set it aside for a few moments and handle higher priority work. Maybe not worrisome on systems with a high core count, but on small SMP (eg VM guests), I've found that tasks like this can be rude neighbors.

None of the different work queues are expected to "set aside" the work for more than a normal scheduling time slice.
system_long_wq was created "so that flush_scheduled_work() doesn't take so long" but flush_scheduled_work() is never called now (and would generate a warning if it was) so system_long_wq should really be removed.

Quoted 3 lines

system_unbound_wq uses threads that are not bound to a CPU so the scheduler can move them around. That is most suitable for something that might run for a long time.

Quoted 5 lines

That's not my understanding: unbound selects a CPU to run the work item on, and it can be (and usually is) not the same CPU as the one that invoked queue_work(). Then it isn't rescheduled. The work items are expected to complete quickly; work item termination is the typical reschedule point. My understanding, as always, could be stale.

If the work item will never schedule, then there isn't much point in using a work queue. The code can be run inline, or with a timer.

Quoted 16 lines

But that's neither here nor there: I've dropped the patch to replace system_unbound_wq with system_long_wq.

Quoted 10 lines

system_wq is bound to the CPU that schedules the work, but it can run multiple work items - potentially long running ones - without trouble by helping the scheduler share the CPU among them. This requires that they can sleep of course.

I haven't seen the actually symptoms that resulted in the various changes to this code, but that last point is I think the key one. The work item, like all kernel code, needs to have scheduler points if it might run for a longish time. list_lru_walk() doesn't contain any scheduling points so giving a large "nr_to_walk" is always a bad idea.

Quoted 3 lines

That might be a overstated... I don't see other consumers that are so concerned about rescheduling. But then it's not clear if they are dealing with lengthy LRU lists.

There are very few callers of list_lru_walk(). shrink_dcache_sb() is the closest analogue and it uses batches of 1024. xfs_buftarg_drain() uses batches of LONG_MAX !!!

Mostly the lru is walked in a shrinker callback, and the shrinker manages the batch size.

Thanks,
NeilBrown

Quoted 16 lines
Quoted 7 lines
Quoted 5 lines

We could do this by adding a cond_resched() call site in the loop, or take Neil's suggestion of breaking up the free list across multiple work items that handle one or just a few file releases each.

I guess I should send a proper patch.

More comments in reply to that patch. Generally speaking, I'm comfortable chopping up the work as you propose, we just have to address some details.

Signature · 1 line
Chuck Lever