Torture-test updates for v6.3
Subsystems (4)
Paul E. McKenney
maintainercover Torture-test updates for v6.3
Hello!
This series provides torture-testing updates:
1. rcu-tasks: Use accurate runstart time for RCU Tasks boot-time
testing, courtesy of Zqiang.
2. Seed torture_random_state on CPU.
3. rcu-tasks: Improve comments explaining tasks_rcu_exit_srcu
purpose, courtesy of Frederic Weisbecker.
4. Provide for initialization failure.
5. rcu-tasks: Remove preemption disablement around
srcu_read_[un]lock() calls, courtesy of Frederic Weisbecker.
6. Add tests using SLAB_TYPESAFE_BY_RCU.
7. Allow non-rtmutex lock types to be boosted, courtesy of "Joel
Fernandes (Google)".
8. rcu-tasks: Fix synchronize_rcu_tasks() VS zap_pid_ns_processes(),
courtesy of Frederic Weisbecker.
9. Make the rt_boost factor a tunable, courtesy of "Joel Fernandes
(Google)".
10. rcu-tasks: Make rude RCU-Tasks work well with CPU hotplug,
courtesy of Zqiang.
11. rcu-tasks: Handle queue-shrink/callback-enqueue race condition,
courtesy of Zqiang.
12. Drop sparse lock-acquisition annotations.
13. Fix hang during kthread shutdown phase, courtesy of "Joel
Fernandes (Google)".
Thanx, Paul
------------------------------------------------------------------------
b/include/linux/rcupdate.h | 2 b/kernel/locking/locktorture.c | 99 +++++++++-------- b/kernel/pid_namespace.c | 17 ++ b/kernel/rcu/rcutorture.c | 12 +- b/kernel/rcu/refscale.c | 16 +- b/kernel/rcu/tasks.h | 8 - b/kernel/torture.c | 2 kernel/locking/locktorture.c | 12 +- kernel/rcu/refscale.c | 236 +++++++++++++++++++++++++++++++++++++++++ kernel/rcu/tasks.h | 77 +++++++++---- kernel/torture.c | 2 11 files changed, 393 insertions(+), 90 deletions(-)
Paul E. McKenney
maintainerPATCH 1/7 torture: Seed torture_random_state on CPU
The DEFINE_TORTURE_RANDOM_PERCPU() macro defines per-CPU random-number generators for torture testing, but the seeds for each CPU's instance will be identical if they are first used at the same time. This commit therefore adds the CPU number to the mix when reseeding.
--- kernel/torture.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/torture.c +1 -1
@@ -450,7 +450,7 @@ unsigned long torture_random(struct torture_random_state *trsp) {if (--trsp->trs_count <0 ) { - trsp->trs_state += (unsigned long )local_clock (); + trsp->trs_state += (unsigned long )local_clock () +raw_smp_processor_id (); trsp->trs_count =TORTURE_RANDOM_REFRESH ; } trsp->trs_state = trsp->trs_state * TORTURE_RANDOM_MULT +
Signature · 1 line
2.31.1.189.g2e36527f23
Paul E. McKenney
maintainerPATCH 2/7 refscale: Provide for initialization failure
In reply to Paul E. McKenneyCurrent tests all have init() functions that are guaranteed to succeed. But upcoming tests will need to allocate memory, thus possibly failing. This commit therefore handles init() function failure.
--- kernel/rcu/refscale.c | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-)
kernel/rcu/refscale.c +11 -5
@@ -124,7 +124,7 @@ static int exp_idx;// Operations vector for selecting different types of tests. struct ref_scale_ops { -void (*init)(void ); +bool (*init)(void );void (*cleanup)(void );void (*readsection)(const int nloops);void (*delaysection)(const int nloops,const int udl,const int ndl);
@@ -162,8 +162,9 @@ static void ref_rcu_delay_section(const int nloops, const int udl, const int ndl } } -static void rcu_sync_scale_init (void ) +static bool rcu_sync_scale_init (void ) { +return true; }static struct ref_scale_ops rcu_ops = {
@@ -315,9 +316,10 @@ static struct ref_scale_ops refcnt_ops = {// Definitions for rwlock static rwlock_t test_rwlock; -static void ref_rwlock_init (void ) +static bool ref_rwlock_init (void ) {rwlock_init (&test_rwlock); +return true; }static void ref_rwlock_section (const int nloops)
@@ -351,9 +353,10 @@ static struct ref_scale_ops rwlock_ops = {// Definitions for rwsem static struct rw_semaphore test_rwsem; -static void ref_rwsem_init (void ) +static bool ref_rwsem_init (void ) {init_rwsem (&test_rwsem); +return true; }static void ref_rwsem_section (const int nloops)
@@ -833,7 +836,10 @@ ref_scale_init(void) goto unwind; }if (cur_ops->init) - cur_ops->init (); +if (!cur_ops->init ()) { + firsterr = -EUCLEAN ; + goto unwind; + }ref_scale_print_module_parms (cur_ops,"Start of test" );
Signature · 1 line
2.31.1.189.g2e36527f23
Paul E. McKenney
maintainerPATCH 1/6 rcu-tasks: Use accurate runstart time for RCU Tasks boot-time testing
In reply to Paul E. McKenneyFrom: Zqiang <[email protected]>
Currently, test_rcu_tasks_callback() reads from the jiffies counter only once when this function is invoked. This introduces inaccuracies because of the latencies induced by the synchronize_rcu_tasks*() invocations. This commit therefore re-reads the jiffies counter at the beginning of each test, thus avoiding penalizing later tests for the latencies induced by earlier tests.
Therefore, this commit at the start of each RCU Tasks test, re-fetch the jiffies time as the runstart time.
--- kernel/rcu/tasks.h | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
kernel/rcu/tasks.h +3 -5
@@ -1815,23 +1815,21 @@ static void test_rcu_tasks_callback(struct rcu_head *rhp)static void rcu_tasks_initiate_self_tests (void ) { -unsigned long j = jiffies; -pr_info ("Running RCU-tasks wait API self tests\n" );#ifdef CONFIG_TASKS_RCU - tests[0 ].runstart = j; + tests[0 ].runstart = jiffies;synchronize_rcu_tasks ();call_rcu_tasks (&tests[0 ].rh, test_rcu_tasks_callback);#endif #ifdef CONFIG_TASKS_RUDE_RCU - tests[1 ].runstart = j; + tests[1 ].runstart = jiffies;synchronize_rcu_tasks_rude ();call_rcu_tasks_rude (&tests[1 ].rh, test_rcu_tasks_callback);#endif #ifdef CONFIG_TASKS_TRACE_RCU - tests[2 ].runstart = j; + tests[2 ].runstart = jiffies;synchronize_rcu_tasks_trace ();call_rcu_tasks_trace (&tests[2 ].rh, test_rcu_tasks_callback);#endif
Signature · 1 line
2.31.1.189.g2e36527f23
Paul E. McKenney
maintainerPATCH 3/7 refscale: Add tests using SLAB_TYPESAFE_BY_RCU
In reply to Paul E. McKenneyThis commit adds three read-side-only tests of three use cases featuringSLAB_TYPESAFE_BY_RCU: One using per-object reference counting, one using per-object locking, and one using per-object sequence locking.
[ paulmck: Apply feedback from kernel test robot. ]
--- kernel/rcu/refscale.c | 236 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 236 insertions(+)
kernel/rcu/refscale.c +236 -0
@@ -76,6 +76,8 @@ torture_param(int, verbose_batched, 0, "Batch verbose debugging printk()s");// Wait until there are multiple CPUs before starting test. torture_param (int, holdoff,IS_BUILTIN (CONFIG_RCU_REF_SCALE_TEST ) ?10 :0 ,"Holdoff time before test start (s)" ); +// Number of typesafe_lookup structures, that is, the degree of concurrency. +torture_param (long, lookup_instances,0 ,"Number of typesafe_lookup structures." );// Number of loops per experiment, all readers execute operations concurrently. torture_param (long, loops,10000 ,"Number of loops per experiment." );// Number of readers, with -1 defaulting to about 75% of the CPUs.
@@ -526,6 +528,239 @@ static struct ref_scale_ops clock_ops = { .name = "clock" }; +//////////////////////////////////////////////////////////////////////// +// +// Methods leveraging SLAB_TYPESAFE_BY_RCU. +// + +// Item to look up in a typesafe manner. Array of pointers to these. +struct refscale_typesafe { +atomic_t rts_refctr;// Used by all flavors +spinlock_t rts_lock; +seqlock_t rts_seqlock; +unsigned int a; +unsigned int b; +}; + +static struct kmem_cache *typesafe_kmem_cachep; +static struct refscale_typesafe **rtsarray; +static long rtsarray_size; +static DEFINE_TORTURE_RANDOM_PERCPU (refscale_rand); +static bool (*rts_acquire)(struct refscale_typesafe *rtsp,unsigned int *start); +static bool (*rts_release)(struct refscale_typesafe *rtsp,unsigned int start); + +// Conditionally acquire an explicit in-structure reference count. +static bool typesafe_ref_acquire (struct refscale_typesafe *rtsp,unsigned int *start) +{ +return atomic_inc_not_zero (&rtsp->rts_refctr); +} + +// Unconditionally release an explicit in-structure reference count. +static bool typesafe_ref_release (struct refscale_typesafe *rtsp,unsigned int start) +{ +if (!atomic_dec_return (&rtsp->rts_refctr)) { +WRITE_ONCE (rtsp->a, rtsp->a +1 ); +kmem_cache_free (typesafe_kmem_cachep, rtsp); + } +return true; +} + +// Unconditionally acquire an explicit in-structure spinlock. +static bool typesafe_lock_acquire (struct refscale_typesafe *rtsp,unsigned int *start) +{ +spin_lock (&rtsp->rts_lock); +return true; +} + +// Unconditionally release an explicit in-structure spinlock. +static bool typesafe_lock_release (struct refscale_typesafe *rtsp,unsigned int start) +{ +spin_unlock (&rtsp->rts_lock); +return true; +} + +// Unconditionally acquire an explicit in-structure sequence lock. +static bool typesafe_seqlock_acquire (struct refscale_typesafe *rtsp,unsigned int *start) +{ + *start =read_seqbegin (&rtsp->rts_seqlock); +return true; +} + +// Conditionally release an explicit in-structure sequence lock. Return +// true if this release was successful, that is, if no retry is required. +static bool typesafe_seqlock_release (struct refscale_typesafe *rtsp,unsigned int start) +{ +return !read_seqretry (&rtsp->rts_seqlock, start); +} + +// Do a read-side critical section with the specified delay in +// microseconds and nanoseconds inserted so as to increase probability +// of failure. +static void typesafe_delay_section (const int nloops,const int udl,const int ndl) +{ +unsigned int a; +unsigned int b; +int i; +long idx; +struct refscale_typesafe *rtsp; +unsigned int start; + +for (i = nloops; i >=0 ; i--) { +preempt_disable (); + idx =torture_random (this_cpu_ptr (&refscale_rand)) % rtsarray_size; +preempt_enable (); +retry: +rcu_read_lock (); + rtsp =rcu_dereference (rtsarray[idx]); + a =READ_ONCE (rtsp->a); +if (!rts_acquire (rtsp, &start)) { +rcu_read_unlock (); + goto retry; + } +if (a !=READ_ONCE (rtsp->a)) { + (void )rts_release (rtsp, start); +rcu_read_unlock (); + goto retry; + } +un_delay (udl, ndl); +// Remember, seqlock read-side release can fail. +if (!rts_release (rtsp, start)) { +rcu_read_unlock (); + goto retry; + } + b =READ_ONCE (rtsp->a); +WARN_ONCE (a != b,"Re-read of ->a changed from %u to %u.\n" , a, b); + b = rtsp->b; +rcu_read_unlock (); +WARN_ON_ONCE (a * a != b); + } +} + +// Because the acquisition and release methods are expensive, there +// is no point in optimizing away the un_delay() function's two checks. +// Thus simply define typesafe_read_section() as a simple wrapper around +// typesafe_delay_section(). +static void typesafe_read_section (const int nloops) +{ +typesafe_delay_section (nloops,0 ,0 ); +} + +// Allocate and initialize one refscale_typesafe structure. +static struct refscale_typesafe *typesafe_alloc_one (void ) +{ +struct refscale_typesafe *rtsp; + + rtsp =kmem_cache_alloc (typesafe_kmem_cachep,GFP_KERNEL ); +if (!rtsp) +return NULL ; +atomic_set (&rtsp->rts_refctr,1 ); +WRITE_ONCE (rtsp->a, rtsp->a +1 ); +WRITE_ONCE (rtsp->b, rtsp->a * rtsp->a); +return rtsp; +} + +// Slab-allocator constructor for refscale_typesafe structures created +// out of a new slab of system memory. +static void refscale_typesafe_ctor (void *rtsp_in) +{ +struct refscale_typesafe *rtsp = rtsp_in; + +spin_lock_init (&rtsp->rts_lock); +seqlock_init (&rtsp->rts_seqlock); +preempt_disable (); + rtsp->a =torture_random (this_cpu_ptr (&refscale_rand)); +preempt_enable (); +} + +static struct ref_scale_ops typesafe_ref_ops; +static struct ref_scale_ops typesafe_lock_ops; +static struct ref_scale_ops typesafe_seqlock_ops; + +// Initialize for a typesafe test. +static bool typesafe_init (void ) +{ +long idx; +long si = lookup_instances; + + typesafe_kmem_cachep =kmem_cache_create ("refscale_typesafe" , +sizeof (struct refscale_typesafe ),sizeof (void *), +SLAB_TYPESAFE_BY_RCU , refscale_typesafe_ctor); +if (!typesafe_kmem_cachep) +return false; +if (si <0 ) + si = -si * nr_cpu_ids; +else if (si ==0 ) + si = nr_cpu_ids; + rtsarray_size = si; + rtsarray =kcalloc (si,sizeof (*rtsarray),GFP_KERNEL ); +if (!rtsarray) +return false; +for (idx =0 ; idx < rtsarray_size; idx++) { + rtsarray[idx] =typesafe_alloc_one (); +if (!rtsarray[idx]) +return false; + } +if (cur_ops == &typesafe_ref_ops) { + rts_acquire = typesafe_ref_acquire; + rts_release = typesafe_ref_release; + }else if (cur_ops == &typesafe_lock_ops) { + rts_acquire = typesafe_lock_acquire; + rts_release = typesafe_lock_release; + }else if (cur_ops == &typesafe_seqlock_ops) { + rts_acquire = typesafe_seqlock_acquire; + rts_release = typesafe_seqlock_release; + }else { +WARN_ON_ONCE (1 ); +return false; + } +return true; +} + +// Clean up after a typesafe test. +static void typesafe_cleanup (void ) +{ +long idx; + +if (rtsarray) { +for (idx =0 ; idx < rtsarray_size; idx++) +kmem_cache_free (typesafe_kmem_cachep, rtsarray[idx]); +kfree (rtsarray); + rtsarray =NULL ; + rtsarray_size =0 ; + } +if (typesafe_kmem_cachep) { +kmem_cache_destroy (typesafe_kmem_cachep); + typesafe_kmem_cachep =NULL ; + } + rts_acquire =NULL ; + rts_release =NULL ; +} + +// The typesafe_init() function distinguishes these structures by address. +static struct ref_scale_ops typesafe_ref_ops = { + .init = typesafe_init, + .cleanup = typesafe_cleanup, + .readsection = typesafe_read_section, + .delaysection = typesafe_delay_section, + .name ="typesafe_ref" +}; + +static struct ref_scale_ops typesafe_lock_ops = { + .init = typesafe_init, + .cleanup = typesafe_cleanup, + .readsection = typesafe_read_section, + .delaysection = typesafe_delay_section, + .name ="typesafe_lock" +}; + +static struct ref_scale_ops typesafe_seqlock_ops = { + .init = typesafe_init, + .cleanup = typesafe_cleanup, + .readsection = typesafe_read_section, + .delaysection = typesafe_delay_section, + .name ="typesafe_seqlock" +}; +static void rcu_scale_one_reader (void ) {if (readdelay <=0 )
@@ -815,6 +1050,7 @@ ref_scale_init(void)static struct ref_scale_ops *scale_ops[] = { &rcu_ops, &srcu_ops, RCU_TRACE_OPS RCU_TASKS_OPS &refcnt_ops, &rwlock_ops, &rwsem_ops, &lock_ops, &lock_irq_ops, &acqrel_ops, &clock_ops, + &typesafe_ref_ops, &typesafe_lock_ops, &typesafe_seqlock_ops, };if (!torture_init_begin (scale_type, verbose))
Signature · 1 line
2.31.1.189.g2e36527f23
Paul E. McKenney
maintainerPATCH 2/6 rcu-tasks: Improve comments explaining tasks_rcu_exit_srcu purpose
In reply to Paul E. McKenneyFrom: Frederic Weisbecker <[email protected]>
Make sure we don't need to look again into the depths of git blame in order not to miss a subtle part about how rcu-tasks is dealing with exiting tasks.
--- kernel/rcu/tasks.h | 37 +++++++++++++++++++++++++++++-------- 1 file changed, 29 insertions(+), 8 deletions(-)
kernel/rcu/tasks.h +29 -8
@@ -827,11 +827,21 @@ static void rcu_tasks_pertask(struct task_struct *t, struct list_head *hop)static void rcu_tasks_postscan (struct list_head *hop) {/* -* Wait for tasks that are in the process of exiting. This -* does only part of the job, ensuring that all tasks that were -* previously exiting reach the point where they have disabled -* preemption, allowing the later synchronize_rcu() to finish -* the job. +* Exiting tasks may escape the tasklist scan. Those are vulnerable +* until their final schedule() with TASK_DEAD state. To cope with +* this, divide the fragile exit path part in two intersecting +* read side critical sections: +* +* 1) An _SRCU_ read side starting before calling exit_notify(), +* which may remove the task from the tasklist, and ending after +* the final preempt_disable() call in do_exit(). +* +* 2) An _RCU_ read side starting with the final preempt_disable() +* call in do_exit() and ending with the final call to schedule() +* with TASK_DEAD state. +* +* This handles the part 1). And postgp will handle part 2) with a +* call to synchronize_rcu(). */ synchronize_srcu (&tasks_rcu_exit_srcu); }
@@ -898,7 +908,10 @@ static void rcu_tasks_postgp(struct rcu_tasks *rtp)* * In addition, this synchronize_rcu() waits for exiting tasks * to complete their final preempt_disable() region of execution, -* cleaning up after the synchronize_srcu() above. +* cleaning up after synchronize_srcu(&tasks_rcu_exit_srcu), +* enforcing the whole region before tasklist removal until +* the final schedule() with TASK_DEAD state to be an RCU TASKS +* read side critical section. */ synchronize_rcu (); }
@@ -988,7 +1001,11 @@ void show_rcu_tasks_classic_gp_kthread(void)EXPORT_SYMBOL_GPL (show_rcu_tasks_classic_gp_kthread);#endif // !defined(CONFIG_TINY_RCU) -/* Do the srcu_read_lock() for the above synchronize_srcu(). */ +/* +* Contribute to protect against tasklist scan blind spot while the +* task is exiting and may be removed from the tasklist. See +* corresponding synchronize_srcu() for further details. +*/ void exit_tasks_rcu_start(void) __acquires(&tasks_rcu_exit_srcu) {preempt_disable ();
@@ -996,7 +1013,11 @@ void exit_tasks_rcu_start(void) __acquires(&tasks_rcu_exit_srcu)preempt_enable (); } -/* Do the srcu_read_unlock() for the above synchronize_srcu(). */ +/* +* Contribute to protect against tasklist scan blind spot while the +* task is exiting and may be removed from the tasklist. See +* corresponding synchronize_srcu() for further details. +*/ void exit_tasks_rcu_finish(void) __releases(&tasks_rcu_exit_srcu) {struct task_struct *t = current;
Signature · 1 line
2.31.1.189.g2e36527f23
Paul E. McKenney
maintainerPATCH 4/7 locktorture: Allow non-rtmutex lock types to be boosted
In reply to Paul E. McKenneyFrom: "Joel Fernandes (Google)" <[email protected]>
Currently RT boosting is only done for rtmutex_lock, however with proxy execution, we also have the mutex_lock participating in priorities. To exercise the testing better, add RT boosting to other lock testing types as well, using a new knob (rt_boost).
Tested with boot parameters:
locktorture.torture_type=mutex_lock
locktorture.onoff_interval=1
locktorture.nwriters_stress=8
locktorture.stutter=0
locktorture.rt_boost=1
locktorture.rt_boost_factor=1
locktorture.nlocks=3
--- kernel/locking/locktorture.c | 99 ++++++++++++++++++++---------------- 1 file changed, 56 insertions(+), 43 deletions(-)
kernel/locking/locktorture.c +56 -43
@@ -46,6 +46,8 @@ torture_param(int, shutdown_secs, 0, "Shutdown time (j), <= zero to disable.");torture_param (int, stat_interval,60 ,"Number of seconds between stats printk()s" );torture_param (int, stutter,5 ,"Number of jiffies to run/halt test, 0=disable" ); +torture_param (int, rt_boost,2 , +"Do periodic rt-boost. 0=Disable, 1=Only for rt_mutex, 2=For all lock types." );torture_param (int, verbose,1 ,"Enable verbose debugging printk()s" );
@@ -127,15 +129,49 @@ static void torture_lock_busted_write_unlock(int tid __maybe_unused)/* BUGGY, do not use in real life!!! */ } -static void torture_boost_dummy (struct torture_random_state *trsp) +static void __torture_rt_boost (struct torture_random_state *trsp) { -/* Only rtmutexes care about priority */ +const unsigned int factor =50000 ;/* yes, quite arbitrary */ + +if (!rt_task (current)) { +/* +* Boost priority once every ~50k operations. When the +* task tries to take the lock, the rtmutex it will account +* for the new priority, and do any corresponding pi-dance. +*/ +if (trsp && !(torture_random (trsp) % + (cxt.nrealwriters_stress * factor))) { +sched_set_fifo (current); + }else /* common case, do nothing */ +return ; + }else { +/* +* The task will remain boosted for another ~500k operations, +* then restored back to its original prio, and so forth. +* +* When @trsp is nil, we want to force-reset the task for +* stopping the kthread. +*/ +if (!trsp || !(torture_random (trsp) % + (cxt.nrealwriters_stress * factor *2 ))) { +sched_set_normal (current,0 ); + }else /* common case, do nothing */ +return ; + } +} + +static void torture_rt_boost (struct torture_random_state *trsp) +{ +if (rt_boost !=2 ) +return ; + +__torture_rt_boost (trsp); }static struct lock_torture_ops lock_busted_ops = { .writelock = torture_lock_busted_write_lock, .write_delay = torture_lock_busted_write_delay, - .task_boost = torture_boost_dummy, + .task_boost = torture_rt_boost, .writeunlock = torture_lock_busted_write_unlock, .readlock =NULL , .read_delay =NULL ,
@@ -179,7 +215,7 @@ __releases(torture_spinlock)static struct lock_torture_ops spin_lock_ops = { .writelock = torture_spin_lock_write_lock, .write_delay = torture_spin_lock_write_delay, - .task_boost = torture_boost_dummy, + .task_boost = torture_rt_boost, .writeunlock = torture_spin_lock_write_unlock, .readlock =NULL , .read_delay =NULL ,
@@ -206,7 +242,7 @@ __releases(torture_spinlock)static struct lock_torture_ops spin_lock_irq_ops = { .writelock = torture_spin_lock_write_lock_irq, .write_delay = torture_spin_lock_write_delay, - .task_boost = torture_boost_dummy, + .task_boost = torture_rt_boost, .writeunlock = torture_lock_spin_write_unlock_irq, .readlock =NULL , .read_delay =NULL ,
@@ -275,7 +311,7 @@ __releases(torture_rwlock)static struct lock_torture_ops rw_lock_ops = { .writelock = torture_rwlock_write_lock, .write_delay = torture_rwlock_write_delay, - .task_boost = torture_boost_dummy, + .task_boost = torture_rt_boost, .writeunlock = torture_rwlock_write_unlock, .readlock = torture_rwlock_read_lock, .read_delay = torture_rwlock_read_delay,
@@ -318,7 +354,7 @@ __releases(torture_rwlock)static struct lock_torture_ops rw_lock_irq_ops = { .writelock = torture_rwlock_write_lock_irq, .write_delay = torture_rwlock_write_delay, - .task_boost = torture_boost_dummy, + .task_boost = torture_rt_boost, .writeunlock = torture_rwlock_write_unlock_irq, .readlock = torture_rwlock_read_lock_irq, .read_delay = torture_rwlock_read_delay,
@@ -358,7 +394,7 @@ __releases(torture_mutex)static struct lock_torture_ops mutex_lock_ops = { .writelock = torture_mutex_lock, .write_delay = torture_mutex_delay, - .task_boost = torture_boost_dummy, + .task_boost = torture_rt_boost, .writeunlock = torture_mutex_unlock, .readlock =NULL , .read_delay =NULL ,
@@ -456,7 +492,7 @@ static struct lock_torture_ops ww_mutex_lock_ops = { .exit = torture_ww_mutex_exit, .writelock = torture_ww_mutex_lock, .write_delay = torture_mutex_delay, - .task_boost = torture_boost_dummy, + .task_boost = torture_rt_boost, .writeunlock = torture_ww_mutex_unlock, .readlock = NULL, .read_delay = NULL,
@@ -474,37 +510,6 @@ __acquires(torture_rtmutex)return 0 ; } -static void torture_rtmutex_boost (struct torture_random_state *trsp) -{ -const unsigned int factor =50000 ;/* yes, quite arbitrary */ - -if (!rt_task (current)) { -/* -* Boost priority once every ~50k operations. When the -* task tries to take the lock, the rtmutex it will account -* for the new priority, and do any corresponding pi-dance. -*/ -if (trsp && !(torture_random (trsp) % - (cxt.nrealwriters_stress * factor))) { -sched_set_fifo (current); - }else /* common case, do nothing */ -return ; - }else { -/* -* The task will remain boosted for another ~500k operations, -* then restored back to its original prio, and so forth. -* -* When @trsp is nil, we want to force-reset the task for -* stopping the kthread. -*/ -if (!trsp || !(torture_random (trsp) % - (cxt.nrealwriters_stress * factor *2 ))) { -sched_set_normal (current,0 ); - }else /* common case, do nothing */ -return ; - } -} -static void torture_rtmutex_delay (struct torture_random_state *trsp) {const unsigned long shortdelay_us =2 ;
@@ -530,10 +535,18 @@ __releases(torture_rtmutex)rt_mutex_unlock (&torture_rtmutex); } +static void torture_rt_boost_rtmutex (struct torture_random_state *trsp) +{ +if (!rt_boost) +return ; + +__torture_rt_boost (trsp); +} +static struct lock_torture_ops rtmutex_lock_ops = { .writelock = torture_rtmutex_lock, .write_delay = torture_rtmutex_delay, - .task_boost = torture_rtmutex_boost, + .task_boost = torture_rt_boost_rtmutex, .writeunlock = torture_rtmutex_unlock, .readlock =NULL , .read_delay =NULL ,
@@ -600,7 +613,7 @@ __releases(torture_rwsem)static struct lock_torture_ops rwsem_lock_ops = { .writelock = torture_rwsem_down_write, .write_delay = torture_rwsem_write_delay, - .task_boost = torture_boost_dummy, + .task_boost = torture_rt_boost, .writeunlock = torture_rwsem_up_write, .readlock = torture_rwsem_down_read, .read_delay = torture_rwsem_read_delay,
@@ -652,7 +665,7 @@ static struct lock_torture_ops percpu_rwsem_lock_ops = { .exit = torture_percpu_rwsem_exit, .writelock = torture_percpu_rwsem_down_write, .write_delay = torture_rwsem_write_delay, - .task_boost = torture_boost_dummy, + .task_boost = torture_rt_boost, .writeunlock = torture_percpu_rwsem_up_write, .readlock = torture_percpu_rwsem_down_read, .read_delay = torture_rwsem_read_delay,
Signature · 1 line
2.31.1.189.g2e36527f23
Paul E. McKenney
maintainerPATCH 5/7 locktorture: Make the rt_boost factor a tunable
In reply to Paul E. McKenneyFrom: "Joel Fernandes (Google)" <[email protected]>
The rt boosting in locktorture has a factor variable s currently large enough that boosting only happens once every minute or so. Add a tunable to reduce the factor so that boosting happens more often, to test paths and arrive at failure modes earlier. With this change, I can set the factor to like 50 and have the boosting happens every 10 seconds or so.
Tested with boot parameters:
locktorture.torture_type=mutex_lock
locktorture.onoff_interval=1
locktorture.nwriters_stress=8
locktorture.stutter=0
locktorture.rt_boost=1
locktorture.rt_boost_factor=50
locktorture.nlocks=3
--- kernel/locking/locktorture.c | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-)
kernel/locking/locktorture.c +7 -5
@@ -48,6 +48,7 @@ torture_param(int, stat_interval, 60,torture_param (int, stutter,5 ,"Number of jiffies to run/halt test, 0=disable" );torture_param (int, rt_boost,2 ,"Do periodic rt-boost. 0=Disable, 1=Only for rt_mutex, 2=For all lock types." ); +torture_param (int, rt_boost_factor,50 ,"A factor determining how often rt-boost happens." );torture_param (int, verbose,1 ,"Enable verbose debugging printk()s" );
@@ -131,12 +132,12 @@ static void torture_lock_busted_write_unlock(int tid __maybe_unused)static void __torture_rt_boost (struct torture_random_state *trsp) { -const unsigned int factor =50000 ;/* yes, quite arbitrary */ +const unsigned int factor = rt_boost_factor;if (!rt_task (current)) {/* -* Boost priority once every ~50k operations. When the -* task tries to take the lock, the rtmutex it will account +* Boost priority once every rt_boost_factor operations. When +* the task tries to take the lock, the rtmutex it will account * for the new priority, and do any corresponding pi-dance. */ if (trsp && !(torture_random(trsp) %
@@ -146,8 +147,9 @@ static void __torture_rt_boost(struct torture_random_state *trsp)return ; }else {/* -* The task will remain boosted for another ~500k operations, -* then restored back to its original prio, and so forth. +* The task will remain boosted for another 10 * rt_boost_factor +* operations, then restored back to its original prio, and so +* forth. * * When @trsp is nil, we want to force-reset the task for * stopping the kthread.
Signature · 1 line
2.31.1.189.g2e36527f23
Paul E. McKenney
maintainerPATCH 3/6 rcu-tasks: Remove preemption disablement around srcu_read_[un]lock() calls
In reply to Paul E. McKenneyFrom: Frederic Weisbecker <[email protected]>
Ever since the following commit:
5a41344a3d83 ("srcu: Simplify __srcu_read_unlock() via this_cpu_dec()")SRCU doesn't rely anymore on preemption to be disabled in order to modify the per-CPU counter. And even then it used to be done from the API itself.
Therefore and after checking further, it appears to be safe to remove the preemption disablement around __srcu_read_[un]lock() in exit_tasks_rcu_start() and exit_tasks_rcu_finish()
--- kernel/rcu/tasks.h | 4 ---- 1 file changed, 4 deletions(-)
kernel/rcu/tasks.h +0 -4
@@ -1008,9 +1008,7 @@ EXPORT_SYMBOL_GPL(show_rcu_tasks_classic_gp_kthread);*/ void exit_tasks_rcu_start(void) __acquires(&tasks_rcu_exit_srcu) { -preempt_disable (); current->rcu_tasks_idx =__srcu_read_lock (&tasks_rcu_exit_srcu); -preempt_enable (); }/*
@@ -1022,9 +1020,7 @@ void exit_tasks_rcu_finish(void) __releases(&tasks_rcu_exit_srcu) {struct task_struct *t = current; -preempt_disable ();__srcu_read_unlock (&tasks_rcu_exit_srcu, t->rcu_tasks_idx); -preempt_enable ();exit_tasks_rcu_finish_trace (t); }
Signature · 1 line
2.31.1.189.g2e36527f23
Paul E. McKenney
maintainerPATCH 6/7 rcutorture: Drop sparse lock-acquisition annotations
In reply to Paul E. McKenneyThe sparse __acquires() and __releases() annotations provide very little value. The argument is ignored, so sparse cannot tell the differences between acquiring one lock and releasing another on the one hand and acquiring and releasing a given lock on the other. In addition, lockdep annotations provide much more precision, for but one example, actually knowing which lock is held.
This commit therefore removes the __acquires() and __releases() annotations from rcutorture.
--- kernel/rcu/rcutorture.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
kernel/rcu/rcutorture.c +6 -6
@@ -399,7 +399,7 @@ static int torture_readlock_not_held(void)return rcu_read_lock_bh_held () ||rcu_read_lock_sched_held (); } -static int rcu_torture_read_lock (void )__acquires (RCU ) +static int rcu_torture_read_lock (void ) {rcu_read_lock ();return 0 ;
@@ -441,7 +441,7 @@ rcu_read_delay(struct torture_random_state *rrsp, struct rt_read_seg *rtrsp) } } -static void rcu_torture_read_unlock (int idx)__releases (RCU ) +static void rcu_torture_read_unlock (int idx) {rcu_read_unlock (); }
@@ -625,7 +625,7 @@ static struct srcu_struct srcu_ctld;static struct srcu_struct *srcu_ctlp = &srcu_ctl;static struct rcu_torture_ops srcud_ops; -static int srcu_torture_read_lock (void )__acquires (srcu_ctlp) +static int srcu_torture_read_lock (void ) {if (cur_ops == &srcud_ops)return srcu_read_lock_nmisafe (srcu_ctlp);
@@ -652,7 +652,7 @@ srcu_read_delay(struct torture_random_state *rrsp, struct rt_read_seg *rtrsp) } } -static void srcu_torture_read_unlock (int idx)__releases (srcu_ctlp) +static void srcu_torture_read_unlock (int idx) {if (cur_ops == &srcud_ops)srcu_read_unlock_nmisafe (srcu_ctlp, idx);
@@ -814,13 +814,13 @@ static void synchronize_rcu_trivial(void) } } -static int rcu_torture_read_lock_trivial (void )__acquires (RCU ) +static int rcu_torture_read_lock_trivial (void ) {preempt_disable ();return 0 ; } -static void rcu_torture_read_unlock_trivial (int idx)__releases (RCU ) +static void rcu_torture_read_unlock_trivial (int idx) {preempt_enable (); }
Signature · 1 line
2.31.1.189.g2e36527f23
Paul E. McKenney
maintainerPATCH 4/6 rcu-tasks: Fix synchronize_rcu_tasks() VS zap_pid_ns_processes()
In reply to Paul E. McKenneyFrom: Frederic Weisbecker <[email protected]>
RCU Tasks and PID-namespace unshare can interact in do_exit() in a complicated circular dependency:
1) TASK A calls unshare(CLONE_NEWPID), this creates a new PID namespace that every subsequent child of TASK A will belong to. But TASK A doesn't itself belong to that new PID namespace.
2) TASK A forks() and creates TASK B. TASK A stays attached to its PID namespace (let's say PID_NS1) and TASK B is the first task belonging to the new PID namespace created by unshare() (let's call it PID_NS2).
3) Since TASK B is the first task attached to PID_NS2, it becomes the PID_NS2 child reaper.
4) TASK A forks() again and creates TASK C which get attached to PID_NS2. Note how TASK C has TASK A as a parent (belonging to PID_NS1) but has TASK B (belonging to PID_NS2) as a pid_namespace child_reaper.
5) TASK B exits and since it is the child reaper for PID_NS2, it has to kill all other tasks attached to PID_NS2, and wait for all of them to die before getting reaped itself (zap_pid_ns_process()).
6) TASK A calls synchronize_rcu_tasks() which leads to synchronize_srcu(&tasks_rcu_exit_srcu).
7) TASK B is waiting for TASK C to get reaped. But TASK B is under a tasks_rcu_exit_srcu SRCU critical section (exit_notify() is between exit_tasks_rcu_start() and exit_tasks_rcu_finish()), blocking TASK A.
8) TASK C exits and since TASK A is its parent, it waits for it to reap TASK C, but it can't because TASK A waits for TASK B that waits for TASK C.
Pid_namespace semantics can hardly be changed at this point. But the coverage of tasks_rcu_exit_srcu can be reduced instead.
The current task is assumed not to be concurrently reapable at this stage of exit_notify() and therefore tasks_rcu_exit_srcu can be temporarily relaxed without breaking its constraints, providing a way out of the deadlock scenario.
[ paulmck: Fix build failure by adding additional declaration. ]
--- include/linux/rcupdate.h | 2 ++ kernel/pid_namespace.c | 17 +++++++++++++++++ kernel/rcu/tasks.h | 15 +++++++++++++-- 3 files changed, 32 insertions(+), 2 deletions(-)
include/linux/rcupdate.h +2 -0
@@ -238,6 +238,7 @@ void synchronize_rcu_tasks_rude(void);#define rcu_note_voluntary_context_switch (t) rcu_tasks_qs(t, false)void exit_tasks_rcu_start (void ); +void exit_tasks_rcu_stop (void );void exit_tasks_rcu_finish (void );#else /* #ifdef CONFIG_TASKS_RCU_GENERIC */ #define rcu_tasks_classic_qs (t, preempt) do { } while (0)
@@ -246,6 +247,7 @@ void exit_tasks_rcu_finish(void);#define call_rcu_tasks call_rcu#define synchronize_rcu_tasks synchronize_rcustatic inline void exit_tasks_rcu_start (void ) { } +static inline void exit_tasks_rcu_stop (void ) { }static inline void exit_tasks_rcu_finish (void ) { }#endif /* #else #ifdef CONFIG_TASKS_RCU_GENERIC */
kernel/pid_namespace.c +17 -0
@@ -244,7 +244,24 @@ void zap_pid_ns_processes(struct pid_namespace *pid_ns)set_current_state (TASK_INTERRUPTIBLE );if (pid_ns->pid_allocated == init_pids)break ; +/* +* Release tasks_rcu_exit_srcu to avoid following deadlock: +* +* 1) TASK A unshare(CLONE_NEWPID) +* 2) TASK A fork() twice -> TASK B (child reaper for new ns) +* and TASK C +* 3) TASK B exits, kills TASK C, waits for TASK A to reap it +* 4) TASK A calls synchronize_rcu_tasks() +* -> synchronize_srcu(tasks_rcu_exit_srcu) +* 5) *DEADLOCK* +* +* It is considered safe to release tasks_rcu_exit_srcu here +* because we assume the current task can not be concurrently +* reaped at this point. +*/ +exit_tasks_rcu_stop ();schedule (); +exit_tasks_rcu_start (); }__set_current_state (TASK_RUNNING );
kernel/rcu/tasks.h +13 -2
@@ -1016,16 +1016,27 @@ void exit_tasks_rcu_start(void) __acquires(&tasks_rcu_exit_srcu)* task is exiting and may be removed from the tasklist. See * corresponding synchronize_srcu() for further details. */ -void exit_tasks_rcu_finish(void) __releases(&tasks_rcu_exit_srcu) +void exit_tasks_rcu_stop(void) __releases(&tasks_rcu_exit_srcu) {struct task_struct *t = current;__srcu_read_unlock (&tasks_rcu_exit_srcu, t->rcu_tasks_idx); -exit_tasks_rcu_finish_trace (t); +} + +/* +* Contribute to protect against tasklist scan blind spot while the +* task is exiting and may be removed from the tasklist. See +* corresponding synchronize_srcu() for further details. +*/ +void exit_tasks_rcu_finish (void ) +{ +exit_tasks_rcu_stop (); +exit_tasks_rcu_finish_trace (current); }#else /* #ifdef CONFIG_TASKS_RCU */ void exit_tasks_rcu_start (void ) { } +void exit_tasks_rcu_stop (void ) { }void exit_tasks_rcu_finish (void ) {exit_tasks_rcu_finish_trace (current); }#endif /* #else #ifdef CONFIG_TASKS_RCU */
Signature · 1 line
2.31.1.189.g2e36527f23
Paul E. McKenney
maintainerPATCH 7/7 torture: Fix hang during kthread shutdown phase
In reply to Paul E. McKenneyFrom: "Joel Fernandes (Google)" <[email protected]>
During rcutorture shutdown, the rcu_torture_cleanup() function calls torture_cleanup_begin(), which sets the fullstop global variable to FULLSTOP_RMMOD. This causes the rcutorture threads for readers and fakewriters to exit all of their "while" loops and start shutting down.
They then call torture_kthread_stopping(), which in turn waits for kthread_stop() to be called. However, rcu_torture_cleanup() has not yet called kthread_stop() on those threads, and before it gets a chance to do so, multiple instances of torture_kthread_stopping() invoke schedule_timeout_interruptible(1) in a tight loop. Tracing confirms that TIMER_SOFTIRQ can then continuously execute timer callbacks. If that TIMER_SOFTIRQ preempts the task executing rcu_torture_cleanup(), that task might never invoke kthread_stop().
This commit improves this situation by increasing the timeout passed to schedule_timeout_interruptible() from one jiffy to 1/20th of a second. This change prevents TIMER_SOFTIRQ from monopolizing its CPU, thus allowing rcu_torture_cleanup() to carry out the needed kthread_stop() invocations. Testing has shown 100 runs of TREE07 passing reliably, as oppose to the tens-of-percent failure rates seen beforehand.
--- kernel/torture.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/torture.c +1 -1
@@ -915,7 +915,7 @@ void torture_kthread_stopping(char *title)VERBOSE_TOROUT_STRING (buf);while (!kthread_should_stop ()) {torture_shutdown_absorb (title); -schedule_timeout_uninterruptible (1 ); +schedule_timeout_uninterruptible (HZ /20 ); } }EXPORT_SYMBOL_GPL (torture_kthread_stopping);
Signature · 1 line
2.31.1.189.g2e36527f23
Paul E. McKenney
maintainerPATCH 5/6 rcu-tasks: Make rude RCU-Tasks work well with CPU hotplug
In reply to Paul E. McKenneyFrom: Zqiang <[email protected]>
The synchronize_rcu_tasks_rude() function invokes rcu_tasks_rude_wait_gp() to wait one rude RCU-tasks grace period. The rcu_tasks_rude_wait_gp() function in turn checks if there is only a single online CPU. If so, it will immediately return, because a call to synchronize_rcu_tasks_rude() is by definition a grace period on a single-CPU system. (We could have blocked!)
Unfortunately, this check uses num_online_cpus() without synchronization, which can result in too-short grace periods. To see this, consider the following scenario:
CPU0 CPU1 (going offline)
migration/1 task:
cpu_stopper_thread
-> take_cpu_down
-> _cpu_disable
(dec __num_online_cpus)
->cpuhp_invoke_callback
preempt_disable
access old_data0
task1
del old_data0 .....
synchronize_rcu_tasks_rude()
task1 schedule out
....
task2 schedule in
rcu_tasks_rude_wait_gp()
->__num_online_cpus == 1
->return ....
task1 schedule in
->free old_data0
preempt_enable
When CPU1 decrements __num_online_cpus, its value becomes 1. However, CPU1 has not finished going offline, and will take one last trip through the scheduler and the idle loop before it actually stops executing instructions. Because synchronize_rcu_tasks_rude() is mostly used for tracing, and because both the scheduler and the idle loop can be traced, this means that CPU0's prematurely ended grace period might disrupt the tracing on CPU1. Given that this disruption might include CPU1 executing instructions in memory that was just now freed (and maybe reallocated), this is a matter of some concern.
This commit therefore removes that problematic single-CPU check from the rcu_tasks_rude_wait_gp() function. This dispenses with the single-CPU optimization, but there is no evidence indicating that this optimization is important. In addition, synchronize_rcu_tasks_generic() contains a similar optimization (albeit only for early boot), which also splats. (As in exactly why are you invoking synchronize_rcu_tasks_rude() so early in boot, anyway???)
It is OK for the synchronize_rcu_tasks_rude() function's check to be unsynchronized because the only times that this check can evaluate to true is when there is only a single CPU running with preemption disabled.
While in the area, this commit also fixes a minor bug in which a call to synchronize_rcu_tasks_rude() would instead be attributed to synchronize_rcu_tasks().
[ paulmck: Add "synchronize_" prefix and "()" suffix. ]
--- kernel/rcu/tasks.h | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
kernel/rcu/tasks.h +3 -5
@@ -560,8 +560,9 @@ static int __noreturn rcu_tasks_kthread(void *arg)static void synchronize_rcu_tasks_generic (struct rcu_tasks *rtp) {/* Complain if the scheduler has not started. */ -WARN_ONCE (rcu_scheduler_active ==RCU_SCHEDULER_INACTIVE , -"synchronize_rcu_tasks called too soon" ); +if (WARN_ONCE (rcu_scheduler_active ==RCU_SCHEDULER_INACTIVE , +"synchronize_%s() called too soon" , rtp->name)) +return ;// If the grace-period kthread is running, use it. if (READ_ONCE (rtp->kthread_ptr)) {
@@ -1064,9 +1065,6 @@ static void rcu_tasks_be_rude(struct work_struct *work)// Wait for one rude RCU-tasks grace period. static void rcu_tasks_rude_wait_gp (struct rcu_tasks *rtp) { -if (num_online_cpus () <=1 ) -return ;// Fastpath for only one CPU. - rtp->n_ipis +=cpumask_weight (cpu_online_mask);schedule_on_each_cpu (rcu_tasks_be_rude); }
Signature · 1 line
2.31.1.189.g2e36527f23
Paul E. McKenney
maintainerPATCH 6/6 rcu-tasks: Handle queue-shrink/callback-enqueue race condition
In reply to Paul E. McKenneyFrom: Zqiang <[email protected]>
The rcu_tasks_need_gpcb() determines whether or not: (1) There are callbacks needing another grace period, (2) There are callbacks ready to be invoked, and (3) It would be a good time to shrink back down to a single-CPU callback list. This third case is interesting because some other CPU might be adding new callbacks, which might suddenly make this a very bad time to be shrinking.
This is currently handled by requiring call_rcu_tasks_generic() to enqueue callbacks under the protection of rcu_read_lock() and requiring rcu_tasks_need_gpcb() to wait for an RCU grace period to elapse before finalizing the transition. This works well in practice.
Unfortunately, the current code assumes that a grace period whose end is detected by the poll_state_synchronize_rcu() in the second "if" condition actually ended before the earlier code counted the callbacks queued on CPUs other than CPU 0 (local variable "ncbsnz"). Given the current code, it is possible that a long-delayed call_rcu_tasks_generic() invocation will queue a callback on a non-zero CPU after these CPUs have had their callbacks counted and zero has been stored to ncbsnz. Such a callback would trigger the WARN_ON_ONCE() in the second "if" statement.
To see this, consider the following sequence of events:
o CPU 0 invokes rcu_tasks_one_gp(), and counts fewer than
rcu_task_collapse_lim callbacks. It sees at least one callback queued on some other CPU, thus setting ncbsnz to a non-zero value.
o CPU 1 invokes call_rcu_tasks_generic() and loads 42 from
->percpu_enqueue_lim. It therefore decides to enqueue its callback onto CPU 1's callback list, but is delayed.
o CPU 0 sees the rcu_task_cb_adjust is non-zero and that the number
of callbacks does not exceed rcu_task_collapse_lim. It therefore checks percpu_enqueue_lim, and sees that its value is greater than the value one. CPU 0 therefore starts the shift back to a single callback list. It sets ->percpu_enqueue_lim to 1, but CPU 1 has already read the old value of 42. It also gets a grace-period state value from get_state_synchronize_rcu().
o CPU 0 sees that ncbsnz is non-zero in its second "if" statement,
so it declines to finalize the shrink operation.
o CPU 0 again invokes rcu_tasks_one_gp(), and counts fewer than
rcu_task_collapse_lim callbacks. It also sees that there are no callback queued on any other CPU, and thus sets ncbsnz to zero.
o CPU 1 resumes execution and enqueues its callback onto its own
list. This invalidates the value of ncbsnz.
o CPU 0 sees the rcu_task_cb_adjust is non-zero and that the number
of callbacks does not exceed rcu_task_collapse_lim. It therefore checks percpu_enqueue_lim, but sees that its value is already
unity. It therefore does not get a new grace-period state value.
o CPU 0 sees that rcu_task_cb_adjust is non-zero, ncbsnz is zero,
and that poll_state_synchronize_rcu() says that the grace period has completed. it therefore finalizes the shrink operation, setting ->percpu_dequeue_lim to the value one.
o CPU 0 does a debug check, scanning the other CPUs' callback lists.
It sees that CPU 1's list has a callback, so it (rightly) triggers the WARN_ON_ONCE(). After all, the new value of ->percpu_dequeue_lim says to not bother looking at CPU 1's callback list, which means that this callback will never be invoked. This can result in hangs and maybe even OOMs.
Based on long experience with rcutorture, this is an extremely low-probability race condition, but it really can happen, especially in preemptible kernels or within guest OSes.
This commit therefore checks for completion of the grace period before counting callbacks. With this change, in the above failure scenario CPU 0 would know not to prematurely end the shrink operation because the grace period would not have completed before the count operation started.
[ paulmck: Adjust grace-period end rather than adding RCU reader. ] [ paulmck: Avoid spurious WARN_ON_ONCE() with ->percpu_dequeue_lim check. ]
--- kernel/rcu/tasks.h | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-)
kernel/rcu/tasks.h +8 -5
@@ -384,6 +384,7 @@ static int rcu_tasks_need_gpcb(struct rcu_tasks *rtp) {int cpu;unsigned long flags; +bool gpdone =poll_state_synchronize_rcu (rtp->percpu_dequeue_gpseq);long n;long ncbs =0 ;long ncbsnz =0 ;
@@ -425,21 +426,23 @@ static int rcu_tasks_need_gpcb(struct rcu_tasks *rtp)WRITE_ONCE (rtp->percpu_enqueue_shift,order_base_2 (nr_cpu_ids));smp_store_release (&rtp->percpu_enqueue_lim,1 ); rtp->percpu_dequeue_gpseq =get_state_synchronize_rcu (); + gpdone = false;pr_info ("Starting switch %s to CPU-0 callback queuing.\n" , rtp->name); }raw_spin_unlock_irqrestore (&rtp->cbs_gbl_lock, flags); } -if (rcu_task_cb_adjust && !ncbsnz && -poll_state_synchronize_rcu (rtp->percpu_dequeue_gpseq)) { +if (rcu_task_cb_adjust && !ncbsnz && gpdone) {raw_spin_lock_irqsave (&rtp->cbs_gbl_lock, flags);if (rtp->percpu_enqueue_lim < rtp->percpu_dequeue_lim) {WRITE_ONCE (rtp->percpu_dequeue_lim,1 );pr_info ("Completing switch %s to CPU-0 callback queuing.\n" , rtp->name); } -for (cpu = rtp->percpu_dequeue_lim; cpu < nr_cpu_ids; cpu++) { -struct rcu_tasks_percpu *rtpcp =per_cpu_ptr (rtp->rtpcpu, cpu); +if (rtp->percpu_dequeue_lim ==1 ) { +for (cpu = rtp->percpu_dequeue_lim; cpu < nr_cpu_ids; cpu++) { +struct rcu_tasks_percpu *rtpcp =per_cpu_ptr (rtp->rtpcpu, cpu); -WARN_ON_ONCE (rcu_segcblist_n_cbs (&rtpcp->cblist)); +WARN_ON_ONCE (rcu_segcblist_n_cbs (&rtpcp->cblist)); + } }raw_spin_unlock_irqrestore (&rtp->cbs_gbl_lock, flags); }
Signature · 1 line
2.31.1.189.g2e36527f23