perf/arm-dmc620: Fix dmc620_pmu_irqs_lock/cpu_hotplug_lock circular lock dependency
PATCH v5 1/1 perf/arm-dmc620: Fix dmc620_pmu_irqs_lock/cpu_hotplug_lock circular lock dependency
The following circular locking dependency was reported when running cpus online/offline test on an arm64 system.
[ 84.195923] Chain exists of:
dmc620_pmu_irqs_lock --> cpu_hotplug_lock --> cpuhp_state-down[ 84.207305] Possible unsafe locking scenario:
[ 84.213212] CPU0 CPU1
[ 84.217729] ---- ----
[ 84.222247] lock(cpuhp_state-down);
[ 84.225899] lock(cpu_hotplug_lock);
[ 84.232068] lock(cpuhp_state-down);
[ 84.238237] lock(dmc620_pmu_irqs_lock);
[ 84.242236]
*** DEADLOCK ***The problematic locking order seems to be
lock(dmc620_pmu_irqs_lock) --> lock(cpu_hotplug_lock)
This locking order happens when dmc620_pmu_get_irq() calls cpuhp_state_add_instance_nocalls(). Since dmc620_pmu_irqs_lock is used for protecting the dmc620_pmu_irqs structure, we don't actually need to hold the lock when adding a new instance to the CPU hotplug subsystem.
Fix this possible deadlock scenario by adding a new dmc620_pmu_get_lock for protecting the call to __dmc620_pmu_get_irq(). While at it, rename dmc620_pmu_irqs_lock to dmc620_pmu_list_lock as it is now just protecting the iteration and modification of pmus_node and irqs_node lists.
As a result, cpuhp_state_add_instance_nocalls() won't be called with reanemd dmc620_pmu_list_lock held and cpu_hotplug_lock won't be acquired after dmc620_pmu_list_lock.
--- drivers/perf/arm_dmc620_pmu.c | 34 ++++++++++++++++++++++------------ 1 file changed, 22 insertions(+), 12 deletions(-)
drivers/perf/arm_dmc620_pmu.c +22 -12
@@ -66,8 +66,14 @@#define DMC620_PMU_COUNTERn_OFFSET (n) \ (DMC620_PMU_COUNTERS_BASE + 0x28 * (n)) +/* +* The allowable lock ordering is: +* - dmc620_pmu_get_lock (protects call to __dmc620_pmu_get_irq()) +* - dmc620_pmu_list_lock (protects pmus_node & irqs_node lists) +*/ +static DEFINE_MUTEX (dmc620_pmu_get_lock); +static DEFINE_MUTEX (dmc620_pmu_list_lock);static LIST_HEAD (dmc620_pmu_irqs); -static DEFINE_MUTEX (dmc620_pmu_irqs_lock);struct dmc620_pmu_irq {struct hlist_node node;
@@ -423,9 +429,11 @@ static struct dmc620_pmu_irq *__dmc620_pmu_get_irq(int irq_num)struct dmc620_pmu_irq *irq;int ret; +mutex_lock (&dmc620_pmu_list_lock);list_for_each_entry (irq, &dmc620_pmu_irqs, irqs_node)if (irq->irq_num == irq_num &&refcount_inc_not_zero (&irq->refcount)) -return irq; + goto unlock_out; +mutex_unlock (&dmc620_pmu_list_lock); irq =kzalloc (sizeof (*irq),GFP_KERNEL );if (!irq)
@@ -452,8 +460,10 @@ static struct dmc620_pmu_irq *__dmc620_pmu_get_irq(int irq_num) goto out_free_irq; irq->irq_num = irq_num; +mutex_lock (&dmc620_pmu_list_lock);list_add (&irq->irqs_node, &dmc620_pmu_irqs); - +unlock_out: +mutex_unlock (&dmc620_pmu_list_lock);return irq; out_free_irq:
@@ -467,17 +477,17 @@ static int dmc620_pmu_get_irq(struct dmc620_pmu *dmc620_pmu, int irq_num) {struct dmc620_pmu_irq *irq; -mutex_lock (&dmc620_pmu_irqs_lock); +mutex_lock (&dmc620_pmu_get_lock); irq =__dmc620_pmu_get_irq (irq_num); -mutex_unlock (&dmc620_pmu_irqs_lock); +mutex_unlock (&dmc620_pmu_get_lock);if (IS_ERR (irq))return PTR_ERR (irq); dmc620_pmu->irq = irq; -mutex_lock (&dmc620_pmu_irqs_lock); +mutex_lock (&dmc620_pmu_list_lock);list_add_rcu (&dmc620_pmu->pmus_node, &irq->pmus_node); -mutex_unlock (&dmc620_pmu_irqs_lock); +mutex_unlock (&dmc620_pmu_list_lock);return 0 ; }
@@ -486,16 +496,16 @@ static void dmc620_pmu_put_irq(struct dmc620_pmu *dmc620_pmu) {struct dmc620_pmu_irq *irq = dmc620_pmu->irq; -mutex_lock (&dmc620_pmu_irqs_lock); +mutex_lock (&dmc620_pmu_list_lock);list_del_rcu (&dmc620_pmu->pmus_node);if (!refcount_dec_and_test (&irq->refcount)) { -mutex_unlock (&dmc620_pmu_irqs_lock); +mutex_unlock (&dmc620_pmu_list_lock);return ; }list_del (&irq->irqs_node); -mutex_unlock (&dmc620_pmu_irqs_lock); +mutex_unlock (&dmc620_pmu_list_lock);free_irq (irq->irq_num, irq);cpuhp_state_remove_instance_nocalls (cpuhp_state_num, &irq->node);
@@ -638,10 +648,10 @@ static int dmc620_pmu_cpu_teardown(unsigned int cpu,return 0 ;/* We're only reading, but this isn't the place to be involving RCU */ -mutex_lock (&dmc620_pmu_irqs_lock); +mutex_lock (&dmc620_pmu_list_lock);list_for_each_entry (dmc620_pmu, &irq->pmus_node, pmus_node)perf_pmu_migrate_context (&dmc620_pmu->pmu, irq->cpu, target); -mutex_unlock (&dmc620_pmu_irqs_lock); +mutex_unlock (&dmc620_pmu_list_lock);WARN_ON (irq_set_affinity (irq->irq_num,cpumask_of (target))); irq->cpu = target;
Signature · 7 lines
2.31.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 46 lines · Waiman Long
The following circular locking dependency was reported when running cpus online/offline test on an arm64 system.
[ 84.195923] Chain exists of: dmc620_pmu_irqs_lock --> cpu_hotplug_lock --> cpuhp_state-down[ 84.207305] Possible unsafe locking scenario:[ 84.213212] CPU0 CPU1 [ 84.217729] ---- ---- [ 84.222247] lock(cpuhp_state-down); [ 84.225899] lock(cpu_hotplug_lock); [ 84.232068] lock(cpuhp_state-down); [ 84.238237] lock(dmc620_pmu_irqs_lock); [ 84.242236] *** DEADLOCK ***The problematic locking order seems to be
lock(dmc620_pmu_irqs_lock) --> lock(cpu_hotplug_lock)This locking order happens when
dmc620_pmu_get_irq()callscpuhp_state_add_instance_nocalls(). Sincedmc620_pmu_irqs_lockis used for protecting thedmc620_pmu_irqsstructure, we don't actually need to hold the lock when adding a new instance to the CPU hotplug subsystem.Fix this possible deadlock scenario by adding a new
dmc620_pmu_get_lockfor protecting the call to__dmc620_pmu_get_irq(). While at it, renamedmc620_pmu_irqs_locktodmc620_pmu_list_lockas it is now just protecting the iteration and modification ofpmus_nodeandirqs_nodelists.As a result,
cpuhp_state_add_instance_nocalls()won't be called with reanemddmc620_pmu_list_lockheld andcpu_hotplug_lockwon't be acquired afterdmc620_pmu_list_lock.Suggested-by Robin Murphy <[email protected]>Signed-off-by Waiman Long <[email protected]>--- drivers/perf/arm_dmc620_pmu.c | 34 ++++++++++++++++++++++------------ 1 file changed, 22 insertions(+), 12 deletions(-)drivers/perf/arm_dmc620_pmu.c +0
-0
drivers/perf/arm_dmc620_pmu.c line 72
Quoted 7 lines
drivers/perf/arm_dmc620_pmu.c +4
-0@@ -66,8 +66,14 @@#define DMC620_PMU_COUNTERn_OFFSET (n) \ (DMC620_PMU_COUNTERS_BASE + 0x28 * (n)) +/* +* The allowable lock ordering is: +* - dmc620_pmu_get_lock (protects call to __dmc620_pmu_get_irq()) +* - dmc620_pmu_list_lock (protects pmus_node & irqs_node lists)
Sorry, this isn't right: touching the irqs_node list *is* the aspect of __dmc620_pmu_get_irq() which warrants globally locking. It's then the pmus_node lists which want locking separately from that - those could strictly be locked per dmc620_pmu_irq instance, but that would be a big waste of space, so we can still combine them under a single global lock. I just went too far in thinking I could get away with (ab)using the same lock for both purposes since they didn't overlap :)
Quoted 56 lines
drivers/perf/arm_dmc620_pmu.c +13
-7+*/ +static DEFINE_MUTEX (dmc620_pmu_get_lock); +static DEFINE_MUTEX (dmc620_pmu_list_lock);static LIST_HEAD (dmc620_pmu_irqs); -static DEFINE_MUTEX (dmc620_pmu_irqs_lock);struct dmc620_pmu_irq {struct hlist_node node;@@ -423,9 +429,11 @@ static struct dmc620_pmu_irq *__dmc620_pmu_get_irq(int irq_num)struct dmc620_pmu_irq *irq;int ret; +mutex_lock (&dmc620_pmu_list_lock);list_for_each_entry (irq, &dmc620_pmu_irqs, irqs_node)if (irq->irq_num == irq_num &&refcount_inc_not_zero (&irq->refcount)) -return irq; + goto unlock_out; +mutex_unlock (&dmc620_pmu_list_lock); irq =kzalloc (sizeof (*irq),GFP_KERNEL );if (!irq)@@ -452,8 +460,10 @@ static struct dmc620_pmu_irq *__dmc620_pmu_get_irq(int irq_num) goto out_free_irq; irq->irq_num = irq_num; +mutex_lock (&dmc620_pmu_list_lock);list_add (&irq->irqs_node, &dmc620_pmu_irqs); - +unlock_out: +mutex_unlock (&dmc620_pmu_list_lock);return irq; out_free_irq:@@ -467,17 +477,17 @@ static int dmc620_pmu_get_irq(struct dmc620_pmu *dmc620_pmu, int irq_num) {struct dmc620_pmu_irq *irq; -mutex_lock (&dmc620_pmu_irqs_lock); +mutex_lock (&dmc620_pmu_get_lock); irq =__dmc620_pmu_get_irq (irq_num); -mutex_unlock (&dmc620_pmu_irqs_lock); +mutex_unlock (&dmc620_pmu_get_lock);if (IS_ERR (irq))return PTR_ERR (irq); dmc620_pmu->irq = irq; -mutex_lock (&dmc620_pmu_irqs_lock); +mutex_lock (&dmc620_pmu_list_lock);list_add_rcu (&dmc620_pmu->pmus_node, &irq->pmus_node); -mutex_unlock (&dmc620_pmu_irqs_lock); +mutex_unlock (&dmc620_pmu_list_lock);return 0 ; }
drivers/perf/arm_dmc620_pmu.c static void dmc620_pmu_put_irq(struct dmc620_pmu *dmc620_pmu) · line 500
Quoted 6 lines
drivers/perf/arm_dmc620_pmu.c +1
-1@@ -486,16 +496,16 @@ static void dmc620_pmu_put_irq(struct dmc620_pmu *dmc620_pmu) {struct dmc620_pmu_irq *irq = dmc620_pmu->irq; -mutex_lock (&dmc620_pmu_irqs_lock); +mutex_lock (&dmc620_pmu_list_lock);list_del_rcu (&dmc620_pmu->pmus_node);
Ah, it might be the laziness in this function that's misled you. Logically it ought to just be a case of dropping pmu_list_lock here after removing from the pmus_node list, then taking pmu_get_lock before the following list_del from the main global list (I think that shouldn't *need* to cover the refcount operation as well, but equally there's probably no harm if it does).
Thanks,
Robin.
Quoted 25 lines
drivers/perf/arm_dmc620_pmu.c +4
-4if (!refcount_dec_and_test (&irq->refcount)) { -mutex_unlock (&dmc620_pmu_irqs_lock); +mutex_unlock (&dmc620_pmu_list_lock);return ; }list_del (&irq->irqs_node); -mutex_unlock (&dmc620_pmu_irqs_lock); +mutex_unlock (&dmc620_pmu_list_lock);free_irq (irq->irq_num, irq);cpuhp_state_remove_instance_nocalls (cpuhp_state_num, &irq->node);@@ -638,10 +648,10 @@ static int dmc620_pmu_cpu_teardown(unsigned int cpu,return 0 ;/* We're only reading, but this isn't the place to be involving RCU */ -mutex_lock (&dmc620_pmu_irqs_lock); +mutex_lock (&dmc620_pmu_list_lock);list_for_each_entry (dmc620_pmu, &irq->pmus_node, pmus_node)perf_pmu_migrate_context (&dmc620_pmu->pmu, irq->cpu, target); -mutex_unlock (&dmc620_pmu_irqs_lock); +mutex_unlock (&dmc620_pmu_list_lock);WARN_ON (irq_set_affinity (irq->irq_num,cpumask_of (target))); irq->cpu = target;
Quoted 42 lines · Robin Murphy
Quoted 41 lines · Waiman Long
The following circular locking dependency was reported when running cpus online/offline test on an arm64 system.
[ 84.195923] Chain exists of:
dmc620_pmu_irqs_lock-->cpu_hotplug_lock--> cpuhp_state-down[ 84.207305] Possible unsafe locking scenario:
[ 84.213212] CPU0 CPU1 [ 84.217729] ---- ---- [ 84.222247]
lock(cpuhp_state-down);
[ 84.225899]lock(cpu_hotplug_lock);
[ 84.232068]lock(cpuhp_state-down);
[ 84.238237]lock(dmc620_pmu_irqs_lock); [ 84.242236]
*** DEADLOCK ***The problematic locking order seems to be
lock(dmc620_pmu_irqs_lock) -->
lock(cpu_hotplug_lock)This locking order happens when
dmc620_pmu_get_irq()callscpuhp_state_add_instance_nocalls(). Sincedmc620_pmu_irqs_lockis used for protecting thedmc620_pmu_irqsstructure, we don't actually need to hold the lock when adding a new instance to the CPU hotplug subsystem.Fix this possible deadlock scenario by adding a new
dmc620_pmu_get_lockfor protecting the call to__dmc620_pmu_get_irq(). While at it, renamedmc620_pmu_irqs_locktodmc620_pmu_list_lockas it is now just protecting the iteration and modification ofpmus_nodeandirqs_nodelists.As a result,
cpuhp_state_add_instance_nocalls()won't be called with reanemddmc620_pmu_list_lockheld andcpu_hotplug_lockwon't be acquired afterdmc620_pmu_list_lock.Suggested-by Robin Murphy <[email protected]>Signed-off-by Waiman Long <[email protected]>---
drivers/perf/arm_dmc620_pmu.c| 34 ++++++++++++++++++++++------------1 file changed, 22 insertions(+), 12 deletions(-)
Quoted 13 lines
Quoted 11 lines
drivers/perf/arm_dmc620_pmu.c +0
-0@@ -66,8 +66,14 @@ #define DMC620_PMU_COUNTERn_OFFSET(n) \ (DMC620_PMU_COUNTERS_BASE + 0x28 * (n))+/*
+ * The allowable lock ordering is:
+ * -dmc620_pmu_get_lock(protects call to__dmc620_pmu_get_irq())
+ * -dmc620_pmu_list_lock(protectspmus_node&irqs_nodelists)Sorry, this isn't right: touching the
irqs_nodelist *is* the aspect of__dmc620_pmu_get_irq()which warrants globally locking. It's then thepmus_nodelists which want locking separately from that - those could strictly be locked perdmc620_pmu_irqinstance, but that would be a big waste of space, so we can still combine them under a single global lock. I just went too far in thinking I could get away with (ab)using the same lock for both purposes since they didn't overlap :)
OK, you want separate locks for pmus_node list and irqs_node list. That will be fine too. I can make the change.
Thanks,
Longman
Quoted 86 lines
Quoted 51 lines
+ */
drivers/perf/arm_dmc620_pmu.c +2
-0+static DEFINE_MUTEX (dmc620_pmu_get_lock); +static DEFINE_MUTEX (dmc620_pmu_list_lock);static
LIST_HEAD(dmc620_pmu_irqs);
-staticDEFINE_MUTEX(dmc620_pmu_irqs_lock);
structdmc620_pmu_irq{
structhlist_nodenode;drivers/perf/arm_dmc620_pmu.c +5
-2@@ -423,9 +429,11 @@ static struct dmc620_pmu_irq *__dmc620_pmu_get_irq(int irq_num) struct dmc620_pmu_irq *irq; int ret; + mutex_lock(&dmc620_pmu_list_lock); list_for_each_entry(irq, &dmc620_pmu_irqs, irqs_node) if (irq->irq_num == irq_num && refcount_inc_not_zero(&irq->refcount)) - return irq; + goto unlock_out; + mutex_unlock(&dmc620_pmu_list_lock); irq = kzalloc(sizeof(*irq), GFP_KERNEL); if (!irq)@@ -452,8 +460,10 @@ static struct dmc620_pmu_irq *__dmc620_pmu_get_irq(int irq_num) goto out_free_irq; irq->irq_num = irq_num; + mutex_lock(&dmc620_pmu_list_lock); list_add(&irq->irqs_node, &dmc620_pmu_irqs); - +unlock_out: + mutex_unlock(&dmc620_pmu_list_lock); return irq;
out_free_irq:drivers/perf/arm_dmc620_pmu.c +4
-3@@ -467,17 +477,17 @@ static int dmc620_pmu_get_irq(struct dmc620_pmu *dmc620_pmu, int irq_num) { struct dmc620_pmu_irq *irq; - mutex_lock(&dmc620_pmu_irqs_lock); + mutex_lock(&dmc620_pmu_get_lock); irq = __dmc620_pmu_get_irq(irq_num); - mutex_unlock(&dmc620_pmu_irqs_lock); + mutex_unlock(&dmc620_pmu_get_lock); if (IS_ERR(irq)) return PTR_ERR(irq); dmc620_pmu->irq = irq; - mutex_lock(&dmc620_pmu_irqs_lock); + mutex_lock(&dmc620_pmu_list_lock); list_add_rcu(&dmc620_pmu->pmus_node, &irq->pmus_node); - mutex_unlock(&dmc620_pmu_irqs_lock); + mutex_unlock(&dmc620_pmu_list_lock); return 0; }drivers/perf/arm_dmc620_pmu.c static void dmc620_pmu_put_irq(struct · line 501
Quoted 6 lines
drivers/perf/arm_dmc620_pmu.c +1
-0@@ -486,16 +496,16 @@ static void dmc620_pmu_put_irq(struct dmc620_pmu *dmc620_pmu) { struct dmc620_pmu_irq *irq = dmc620_pmu->irq; - mutex_lock(&dmc620_pmu_irqs_lock); + mutex_lock(&dmc620_pmu_list_lock); list_del_rcu(&dmc620_pmu->pmus_node);Ah, it might be the laziness in this function that's misled you. Logically it ought to just be a case of dropping
pmu_list_lockhere after removing from thepmus_nodelist, then takingpmu_get_lockbefore the followinglist_delfrom the main global list (I think that shouldn't *need* to cover the refcount operation as well, but equally there's probably no harm if it does).Thanks,
Robin.Quoted 22 lines
drivers/perf/arm_dmc620_pmu.c +4
-4if (!refcount_dec_and_test(&irq->refcount)) { - mutex_unlock(&dmc620_pmu_irqs_lock); + mutex_unlock(&dmc620_pmu_list_lock); return; } list_del(&irq->irqs_node); - mutex_unlock(&dmc620_pmu_irqs_lock); + mutex_unlock(&dmc620_pmu_list_lock); free_irq(irq->irq_num, irq); cpuhp_state_remove_instance_nocalls(cpuhp_state_num, &irq->node);@@ -638,10 +648,10 @@ static int dmc620_pmu_cpu_teardown(unsigned int cpu, return 0; /* We're only reading, but this isn't the place to be involving RCU */ - mutex_lock(&dmc620_pmu_irqs_lock); + mutex_lock(&dmc620_pmu_list_lock); list_for_each_entry(dmc620_pmu, &irq->pmus_node, pmus_node) perf_pmu_migrate_context(&dmc620_pmu->pmu, irq->cpu, target); - mutex_unlock(&dmc620_pmu_irqs_lock); + mutex_unlock(&dmc620_pmu_list_lock); WARN_ON(irq_set_affinity(irq->irq_num, cpumask_of(target))); irq->cpu = target;