From: Greg Kroah-Hartman Date: Tue, 10 May 2022 11:12:28 +0000 (+0200) Subject: 5.10-stable patches X-Git-Tag: v4.9.313~26 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=1bacf7fd0de5704d7fa29bd2034583dfe6cdf798;p=thirdparty%2Fkernel%2Fstable-queue.git 5.10-stable patches added patches: rcu-apply-callbacks-processing-time-limit-only-on-softirq.patch rcu-fix-callbacks-processing-time-limit-retaining-cond_resched.patch --- diff --git a/queue-5.10/rcu-apply-callbacks-processing-time-limit-only-on-softirq.patch b/queue-5.10/rcu-apply-callbacks-processing-time-limit-only-on-softirq.patch new file mode 100644 index 00000000000..da906005d6a --- /dev/null +++ b/queue-5.10/rcu-apply-callbacks-processing-time-limit-only-on-softirq.patch @@ -0,0 +1,91 @@ +From a554ba288845fd3f6f12311fd76a51694233458a Mon Sep 17 00:00:00 2001 +From: Frederic Weisbecker +Date: Tue, 19 Oct 2021 02:08:15 +0200 +Subject: rcu: Apply callbacks processing time limit only on softirq + +From: Frederic Weisbecker + +commit a554ba288845fd3f6f12311fd76a51694233458a upstream. + +Time limit only makes sense when callbacks are serviced in softirq mode +because: + +_ In case we need to get back to the scheduler, + cond_resched_tasks_rcu_qs() is called after each callback. + +_ In case some other softirq vector needs the CPU, the call to + local_bh_enable() before cond_resched_tasks_rcu_qs() takes care about + them via a call to do_softirq(). + +Therefore, make sure the time limit only applies to softirq mode. + +Reviewed-by: Valentin Schneider +Tested-by: Valentin Schneider +Tested-by: Sebastian Andrzej Siewior +Signed-off-by: Frederic Weisbecker +Cc: Valentin Schneider +Cc: Peter Zijlstra +Cc: Sebastian Andrzej Siewior +Cc: Josh Triplett +Cc: Joel Fernandes +Cc: Boqun Feng +Cc: Neeraj Upadhyay +Cc: Uladzislau Rezki +Cc: Thomas Gleixner +Signed-off-by: Paul E. McKenney +[UR: backport to 5.10-stable] +Signed-off-by: Uladzislau Rezki (Sony) +Signed-off-by: Greg Kroah-Hartman +--- + kernel/rcu/tree.c | 26 +++++++++++++------------- + 1 file changed, 13 insertions(+), 13 deletions(-) + +--- a/kernel/rcu/tree.c ++++ b/kernel/rcu/tree.c +@@ -2456,7 +2456,7 @@ static void rcu_do_batch(struct rcu_data + div = READ_ONCE(rcu_divisor); + div = div < 0 ? 7 : div > sizeof(long) * 8 - 2 ? sizeof(long) * 8 - 2 : div; + bl = max(rdp->blimit, pending >> div); +- if (unlikely(bl > 100)) { ++ if (in_serving_softirq() && unlikely(bl > 100)) { + long rrn = READ_ONCE(rcu_resched_ns); + + rrn = rrn < NSEC_PER_MSEC ? NSEC_PER_MSEC : rrn > NSEC_PER_SEC ? NSEC_PER_SEC : rrn; +@@ -2494,6 +2494,18 @@ static void rcu_do_batch(struct rcu_data + if (-rcl.len >= bl && (need_resched() || + (!is_idle_task(current) && !rcu_is_callbacks_kthread()))) + break; ++ ++ /* ++ * Make sure we don't spend too much time here and deprive other ++ * softirq vectors of CPU cycles. ++ */ ++ if (unlikely(tlimit)) { ++ /* only call local_clock() every 32 callbacks */ ++ if (likely((-rcl.len & 31) || local_clock() < tlimit)) ++ continue; ++ /* Exceeded the time limit, so leave. */ ++ break; ++ } + } else { + local_bh_enable(); + lockdep_assert_irqs_enabled(); +@@ -2501,18 +2513,6 @@ static void rcu_do_batch(struct rcu_data + lockdep_assert_irqs_enabled(); + local_bh_disable(); + } +- +- /* +- * Make sure we don't spend too much time here and deprive other +- * softirq vectors of CPU cycles. +- */ +- if (unlikely(tlimit)) { +- /* only call local_clock() every 32 callbacks */ +- if (likely((-rcl.len & 31) || local_clock() < tlimit)) +- continue; +- /* Exceeded the time limit, so leave. */ +- break; +- } + } + + local_irq_save(flags); diff --git a/queue-5.10/rcu-fix-callbacks-processing-time-limit-retaining-cond_resched.patch b/queue-5.10/rcu-fix-callbacks-processing-time-limit-retaining-cond_resched.patch new file mode 100644 index 00000000000..f622106fd49 --- /dev/null +++ b/queue-5.10/rcu-fix-callbacks-processing-time-limit-retaining-cond_resched.patch @@ -0,0 +1,83 @@ +From 3e61e95e2d095e308616cba4ffb640f95a480e01 Mon Sep 17 00:00:00 2001 +From: Frederic Weisbecker +Date: Tue, 19 Oct 2021 02:08:14 +0200 +Subject: rcu: Fix callbacks processing time limit retaining cond_resched() + +From: Frederic Weisbecker + +commit 3e61e95e2d095e308616cba4ffb640f95a480e01 upstream. + +The callbacks processing time limit makes sure we are not exceeding a +given amount of time executing the queue. + +However its "continue" clause bypasses the cond_resched() call on +rcuc and NOCB kthreads, delaying it until we reach the limit, which can +be very long... + +Make sure the scheduler has a higher priority than the time limit. + +Reviewed-by: Valentin Schneider +Tested-by: Valentin Schneider +Tested-by: Sebastian Andrzej Siewior +Signed-off-by: Frederic Weisbecker +Cc: Valentin Schneider +Cc: Peter Zijlstra +Cc: Sebastian Andrzej Siewior +Cc: Josh Triplett +Cc: Joel Fernandes +Cc: Boqun Feng +Cc: Neeraj Upadhyay +Cc: Uladzislau Rezki +Cc: Thomas Gleixner +Signed-off-by: Paul E. McKenney +[UR: backport to 5.10-stable + commit update] +Signed-off-by: Uladzislau Rezki (Sony) +Signed-off-by: Greg Kroah-Hartman +--- + kernel/rcu/tree.c | 28 ++++++++++++++++------------ + 1 file changed, 16 insertions(+), 12 deletions(-) + +--- a/kernel/rcu/tree.c ++++ b/kernel/rcu/tree.c +@@ -2490,10 +2490,22 @@ static void rcu_do_batch(struct rcu_data + * Stop only if limit reached and CPU has something to do. + * Note: The rcl structure counts down from zero. + */ +- if (-rcl.len >= bl && !offloaded && +- (need_resched() || +- (!is_idle_task(current) && !rcu_is_callbacks_kthread()))) +- break; ++ if (in_serving_softirq()) { ++ if (-rcl.len >= bl && (need_resched() || ++ (!is_idle_task(current) && !rcu_is_callbacks_kthread()))) ++ break; ++ } else { ++ local_bh_enable(); ++ lockdep_assert_irqs_enabled(); ++ cond_resched_tasks_rcu_qs(); ++ lockdep_assert_irqs_enabled(); ++ local_bh_disable(); ++ } ++ ++ /* ++ * Make sure we don't spend too much time here and deprive other ++ * softirq vectors of CPU cycles. ++ */ + if (unlikely(tlimit)) { + /* only call local_clock() every 32 callbacks */ + if (likely((-rcl.len & 31) || local_clock() < tlimit)) +@@ -2501,14 +2513,6 @@ static void rcu_do_batch(struct rcu_data + /* Exceeded the time limit, so leave. */ + break; + } +- if (offloaded) { +- WARN_ON_ONCE(in_serving_softirq()); +- local_bh_enable(); +- lockdep_assert_irqs_enabled(); +- cond_resched_tasks_rcu_qs(); +- lockdep_assert_irqs_enabled(); +- local_bh_disable(); +- } + } + + local_irq_save(flags); diff --git a/queue-5.10/series b/queue-5.10/series index 50b01d037c7..371fadb6018 100644 --- a/queue-5.10/series +++ b/queue-5.10/series @@ -63,3 +63,5 @@ x86-kvm-preserve-bsp-msr_kvm_poll_control-across-sus.patch kvm-x86-do-not-change-icr-on-write-to-apic_self_ipi.patch kvm-x86-mmu-avoid-null-pointer-dereference-on-page-f.patch kvm-lapic-enable-timer-posted-interrupt-only-when-mw.patch +rcu-fix-callbacks-processing-time-limit-retaining-cond_resched.patch +rcu-apply-callbacks-processing-time-limit-only-on-softirq.patch