mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-28 11:49:32 +00:00
rcu: Associate quiescent-state reports with grace period
As noted in earlier commit logs, CPU hotplug operations running concurrently with grace-period initialization can result in a given leaf rcu_node structure having all CPUs offline and no blocked readers, but with this rcu_node structure nevertheless blocking the current grace period. Therefore, the quiescent-state forcing code now checks for this situation and repairs it. Unfortunately, this checking can result in false positives, for example, when the last task has just removed itself from this leaf rcu_node structure, but has not yet started clearing the ->qsmask bits further up the structure. This means that the grace-period kthread (which forces quiescent states) and some other task might be attempting to concurrently clear these ->qsmask bits. This is usually not a problem: One of these tasks will be the first to acquire the upper-level rcu_node structure's lock and with therefore clear the bit, and the other task, seeing the bit already cleared, will stop trying to clear bits. Sadly, this means that the following unusual sequence of events -can- result in a problem: 1. The grace-period kthread wins, and clears the ->qsmask bits. 2. This is the last thing blocking the current grace period, so that the grace-period kthread clears ->qsmask bits all the way to the root and finds that the root ->qsmask field is now zero. 3. Another grace period is required, so that the grace period kthread initializes it, including setting all the needed qsmask bits. 4. The leaf rcu_node structure (the one that started this whole mess) is blocking this new grace period, either because it has at least one online CPU or because there is at least one task that had blocked within an RCU read-side critical section while running on one of this leaf rcu_node structure's CPUs. (And yes, that CPU might well have gone offline before the grace period in step (3) above started, which can mean that there is a task on the leaf rcu_node structure's ->blkd_tasks list, but ->qsmask equal to zero.) 5. The other kthread didn't get around to trying to clear the upper level ->qsmask bits until all the above had happened. This means that it now sees bits set in the upper-level ->qsmask field, so it proceeds to clear them. Too bad that it is doing so on behalf of a quiescent state that does not apply to the current grace period! This sequence of events can result in the new grace period being too short. It can also result in the new grace period ending before the leaf rcu_node structure's ->qsmask bits have been cleared, which will result in splats during initialization of the next grace period. In addition, it can result in tasks blocking the new grace period still being queued at the start of the next grace period, which will result in other splats. Sasha's testing turned up another of these splats, as did rcutorture testing. (And yes, rcutorture is being adjusted to make these splats show up more quickly. Which probably is having the undesirable side effect of making other problems show up less quickly. Can't have everything!) Reported-by: Sasha Levin <sasha.levin@oracle.com> Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com> Cc: <stable@vger.kernel.org> # 4.0.x Tested-by: Sasha Levin <sasha.levin@oracle.com>
This commit is contained in:
parent
a77da14ce9
commit
654e953340
1 changed files with 22 additions and 12 deletions
|
@ -2132,25 +2132,32 @@ static void rcu_report_qs_rsp(struct rcu_state *rsp, unsigned long flags)
|
|||
* Similar to rcu_report_qs_rdp(), for which it is a helper function.
|
||||
* Allows quiescent states for a group of CPUs to be reported at one go
|
||||
* to the specified rcu_node structure, though all the CPUs in the group
|
||||
* must be represented by the same rcu_node structure (which need not be
|
||||
* a leaf rcu_node structure, though it often will be). That structure's
|
||||
* lock must be held upon entry, and it is released before return.
|
||||
* must be represented by the same rcu_node structure (which need not be a
|
||||
* leaf rcu_node structure, though it often will be). The gps parameter
|
||||
* is the grace-period snapshot, which means that the quiescent states
|
||||
* are valid only if rnp->gpnum is equal to gps. That structure's lock
|
||||
* must be held upon entry, and it is released before return.
|
||||
*/
|
||||
static void
|
||||
rcu_report_qs_rnp(unsigned long mask, struct rcu_state *rsp,
|
||||
struct rcu_node *rnp, unsigned long flags)
|
||||
struct rcu_node *rnp, unsigned long gps, unsigned long flags)
|
||||
__releases(rnp->lock)
|
||||
{
|
||||
unsigned long oldmask = 0;
|
||||
struct rcu_node *rnp_c;
|
||||
|
||||
/* Walk up the rcu_node hierarchy. */
|
||||
for (;;) {
|
||||
if (!(rnp->qsmask & mask)) {
|
||||
if (!(rnp->qsmask & mask) || rnp->gpnum != gps) {
|
||||
|
||||
/* Our bit has already been cleared, so done. */
|
||||
/*
|
||||
* Our bit has already been cleared, or the
|
||||
* relevant grace period is already over, so done.
|
||||
*/
|
||||
raw_spin_unlock_irqrestore(&rnp->lock, flags);
|
||||
return;
|
||||
}
|
||||
WARN_ON_ONCE(oldmask); /* Any child must be all zeroed! */
|
||||
rnp->qsmask &= ~mask;
|
||||
trace_rcu_quiescent_state_report(rsp->name, rnp->gpnum,
|
||||
mask, rnp->qsmask, rnp->level,
|
||||
|
@ -2174,7 +2181,7 @@ rcu_report_qs_rnp(unsigned long mask, struct rcu_state *rsp,
|
|||
rnp = rnp->parent;
|
||||
raw_spin_lock_irqsave(&rnp->lock, flags);
|
||||
smp_mb__after_unlock_lock();
|
||||
WARN_ON_ONCE(rnp_c->qsmask);
|
||||
oldmask = rnp_c->qsmask;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -2196,6 +2203,7 @@ static void rcu_report_unblock_qs_rnp(struct rcu_state *rsp,
|
|||
struct rcu_node *rnp, unsigned long flags)
|
||||
__releases(rnp->lock)
|
||||
{
|
||||
unsigned long gps;
|
||||
unsigned long mask;
|
||||
struct rcu_node *rnp_p;
|
||||
|
||||
|
@ -2215,12 +2223,13 @@ static void rcu_report_unblock_qs_rnp(struct rcu_state *rsp,
|
|||
return;
|
||||
}
|
||||
|
||||
/* Report up the rest of the hierarchy. */
|
||||
/* Report up the rest of the hierarchy, tracking current ->gpnum. */
|
||||
gps = rnp->gpnum;
|
||||
mask = rnp->grpmask;
|
||||
raw_spin_unlock(&rnp->lock); /* irqs remain disabled. */
|
||||
raw_spin_lock(&rnp_p->lock); /* irqs already disabled. */
|
||||
smp_mb__after_unlock_lock();
|
||||
rcu_report_qs_rnp(mask, rsp, rnp_p, flags);
|
||||
rcu_report_qs_rnp(mask, rsp, rnp_p, gps, flags);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -2271,7 +2280,8 @@ rcu_report_qs_rdp(int cpu, struct rcu_state *rsp, struct rcu_data *rdp)
|
|||
*/
|
||||
needwake = rcu_accelerate_cbs(rsp, rnp, rdp);
|
||||
|
||||
rcu_report_qs_rnp(mask, rsp, rnp, flags); /* rlses rnp->lock */
|
||||
rcu_report_qs_rnp(mask, rsp, rnp, rnp->gpnum, flags);
|
||||
/* ^^^ Released rnp->lock */
|
||||
if (needwake)
|
||||
rcu_gp_kthread_wake(rsp);
|
||||
}
|
||||
|
@ -2747,8 +2757,8 @@ static void force_qs_rnp(struct rcu_state *rsp,
|
|||
}
|
||||
}
|
||||
if (mask != 0) {
|
||||
/* Idle/offline CPUs, report. */
|
||||
rcu_report_qs_rnp(mask, rsp, rnp, flags);
|
||||
/* Idle/offline CPUs, report (releases rnp->lock. */
|
||||
rcu_report_qs_rnp(mask, rsp, rnp, rnp->gpnum, flags);
|
||||
} else {
|
||||
/* Nothing to do here, so just drop the lock. */
|
||||
raw_spin_unlock_irqrestore(&rnp->lock, flags);
|
||||
|
|
Loading…
Reference in a new issue