Commit 3e4f7a49 authored by Ingo Molnar's avatar Ingo Molnar
Browse files

Merge branch 'rcu/urgent' of... 

Merge branch 'rcu/urgent' of git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu

 into rcu/urgent

Pull an urgent RCU fix from Paul E. McKenney:

 "This series contains a pair of commits that permit RCU synchronous grace
  periods (synchronize_rcu() and friends) to work correctly throughout boot.
  This eliminates the current "dead time" starting when the scheduler spawns
  its first taks and ending when the last of RCU's kthreads is spawned
  (this last happens during early_initcall() time).  Although RCU's
  synchronous grace periods have long been documented as not working
  during this time, prior to 4.9, the expedited grace periods worked by
  accident, and some ACPI code came to rely on this unintentional behavior.
  (Note that this unintentional behavior was -not- reliable.  For example,
  failures from ACPI could occur on !SMP systems and on systems booting
  with the rcu_normal kernel boot parameter.)

  Either way, there is a bug that needs fixing, and the 4.9 switch of RCU's
  expedited grace periods to workqueues could be considered to have caused
  a regression.  This series therefore makes RCU's expedited grace periods
  operate correctly throughout the boot process.  This has been demonstrated
  to fix the problems ACPI was encountering, and has the added longer-term
  benefit of simplifying RCU's behavior."

Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parents f4d3935e 52d7e48b

include/linux/rcupdate.h

+4 −0
Original line number Diff line number Diff line
@@ -444,6 +444,10 @@ bool __rcu_is_watching(void); 
#error "Unknown RCU implementation specified to kernel configuration"

#endif



#define RCU_SCHEDULER_INACTIVE	0

#define RCU_SCHEDULER_INIT	1

#define RCU_SCHEDULER_RUNNING	2



/*

 * init_rcu_head_on_stack()/destroy_rcu_head_on_stack() are needed for dynamic

 * initialization and destruction of rcu_head on the stack. rcu_head structures

kernel/rcu/rcu.h

+1 −0
Original line number Diff line number Diff line
@@ -136,6 +136,7 @@ int rcu_jiffies_till_stall_check(void); 
#define TPS(x)  tracepoint_string(x)



void rcu_early_boot_tests(void);

void rcu_test_sync_prims(void);



/*

 * This function really isn't for public consumption, but RCU is special in

kernel/rcu/tiny.c

+0 −4
Original line number Diff line number Diff line
@@ -185,9 +185,6 @@ static __latent_entropy void rcu_process_callbacks(struct softirq_action *unused 
 * benefits of doing might_sleep() to reduce latency.)

 *

 * Cool, huh?  (Due to Josh Triplett.)

 *

 * But we want to make this a static inline later.  The cond_resched()

 * currently makes this problematic.

 */

void synchronize_sched(void)

{
@@ -195,7 +192,6 @@ void synchronize_sched(void) 
			 lock_is_held(&rcu_lock_map) ||

			 lock_is_held(&rcu_sched_lock_map),

			 "Illegal synchronize_sched() in RCU read-side critical section");

	cond_resched();

}

EXPORT_SYMBOL_GPL(synchronize_sched);

kernel/rcu/tiny_plugin.h

+7 −2
Original line number Diff line number Diff line
@@ -60,12 +60,17 @@ EXPORT_SYMBOL_GPL(rcu_scheduler_active); 


/*

 * During boot, we forgive RCU lockdep issues.  After this function is

 * invoked, we start taking RCU lockdep issues seriously.

 * invoked, we start taking RCU lockdep issues seriously.  Note that unlike

 * Tree RCU, Tiny RCU transitions directly from RCU_SCHEDULER_INACTIVE

 * to RCU_SCHEDULER_RUNNING, skipping the RCU_SCHEDULER_INIT stage.

 * The reason for this is that Tiny RCU does not need kthreads, so does

 * not have to care about the fact that the scheduler is half-initialized

 * at a certain phase of the boot process.

 */

void __init rcu_scheduler_starting(void)

{

	WARN_ON(nr_context_switches() > 0);

	rcu_scheduler_active = 1;

	rcu_scheduler_active = RCU_SCHEDULER_RUNNING;

}



#endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */

kernel/rcu/tree.c

+20 −13
Original line number Diff line number Diff line
@@ -127,13 +127,16 @@ int rcu_num_nodes __read_mostly = NUM_RCU_NODES; /* Total # rcu_nodes in use. */ 
int sysctl_panic_on_rcu_stall __read_mostly;



/*

 * The rcu_scheduler_active variable transitions from zero to one just

 * before the first task is spawned.  So when this variable is zero, RCU

 * can assume that there is but one task, allowing RCU to (for example)

 * The rcu_scheduler_active variable is initialized to the value

 * RCU_SCHEDULER_INACTIVE and transitions RCU_SCHEDULER_INIT just before the

 * first task is spawned.  So when this variable is RCU_SCHEDULER_INACTIVE,

 * RCU can assume that there is but one task, allowing RCU to (for example)

 * optimize synchronize_rcu() to a simple barrier().  When this variable

 * is one, RCU must actually do all the hard work required to detect real

 * grace periods.  This variable is also used to suppress boot-time false

 * positives from lockdep-RCU error checking.

 * is RCU_SCHEDULER_INIT, RCU must actually do all the hard work required

 * to detect real grace periods.  This variable is also used to suppress

 * boot-time false positives from lockdep-RCU error checking.  Finally, it

 * transitions from RCU_SCHEDULER_INIT to RCU_SCHEDULER_RUNNING after RCU

 * is fully initialized, including all of its kthreads having been spawned.

 */

int rcu_scheduler_active __read_mostly;

EXPORT_SYMBOL_GPL(rcu_scheduler_active);
@@ -3980,18 +3983,22 @@ static int __init rcu_spawn_gp_kthread(void) 
early_initcall(rcu_spawn_gp_kthread);



/*

 * This function is invoked towards the end of the scheduler's initialization

 * process.  Before this is called, the idle task might contain

 * RCU read-side critical sections (during which time, this idle

 * task is booting the system).  After this function is called, the

 * idle tasks are prohibited from containing RCU read-side critical

 * sections.  This function also enables RCU lockdep checking.

 * This function is invoked towards the end of the scheduler's

 * initialization process.  Before this is called, the idle task might

 * contain synchronous grace-period primitives (during which time, this idle

 * task is booting the system, and such primitives are no-ops).  After this

 * function is called, any synchronous grace-period primitives are run as

 * expedited, with the requesting task driving the grace period forward.

 * A later core_initcall() rcu_exp_runtime_mode() will switch to full

 * runtime RCU functionality.

 */

void rcu_scheduler_starting(void)

{

	WARN_ON(num_online_cpus() != 1);

	WARN_ON(nr_context_switches() > 0);

	rcu_scheduler_active = 1;

	rcu_test_sync_prims();

	rcu_scheduler_active = RCU_SCHEDULER_INIT;

	rcu_test_sync_prims();

}



/*

CRA Git | Maintained and supported by SUSTech CRA and CCSE