* [PATCH] thermal/drivers/rcar_thermal: wait for IRQs before cancelling work
@ 2026-11-18 7:23 Yaohan Li
2026-11-18 9:00 ` Niklas Söderlund
2026-11-19 2:29 ` [PATCH v2] thermal/drivers/rcar_thermal: disable the work before masking the interrupt Yaohan Li
0 siblings, 2 replies; 5+ messages in thread
From: Yaohan Li @ 2026-11-18 7:23 UTC (permalink / raw)
To: niklas.soderlund, rafael, daniel.lezcano
Cc: rui.zhang, lukasz.luba, geert+renesas, magnus.damm,
linux-renesas-soc, linux-pm, linux-kernel, edubezval
rcar_thermal_remove() masks the interrupt sources and cancels the
delayed work of each sensor. rcar_thermal_irq() reads INTMSK and STR
under common->lock, drops the lock, and only then walks the sensors and
queues priv->work for every sensor whose status changed.
A handler that sampled the status before the mask was written can
therefore reach queue_delayed_work() after cancel_delayed_work_sync()
has returned. The work stays pending past the end of ->remove(), devres
then frees common, priv and the thermal zone, and rcar_thermal_work()
runs 300 ms later on freed memory.
Waiting for the handler is not enough on its own: rcar_thermal_work()
calls rcar_thermal_irq_enable() once it has updated the temperature, so
a work that is still running when the removal starts re-enables its
source and undoes the mask that ->remove() has just written.
Record the shutdown in rcar_thermal_common under common->lock and make
_rcar_thermal_irq_ctrl() refuse to enable anything once that state is
visible. The removal then publishes the shutdown, masks all sources,
waits for the handlers with synchronize_irq() and only then cancels the
work, so neither a source nor a work item can be brought back after it
returns.
Fixes: 697ee786f15d ("thermal: rcar_thermal: Prevent doing work after unbind")
Signed-off-by: Yaohan Li <shunsheng1218@gmail.com>
---
Prepared against v7.4-rc1-1969-g666539eecdf4.
AI assistance: the analysis, the change and its review notes were
prepared with Claude (Anthropic) as a coding assistant. The author
reviewed the reasoning and takes responsibility for the content.
Testing: compile tested only (arm64, gcc 11.4). No R-Car hardware was
available, so the unbind race was not run.
drivers/thermal/renesas/rcar_thermal.c | 43 +++++++++++++++++++++++++-
1 file changed, 42 insertions(+), 1 deletion(-)
diff --git a/drivers/thermal/renesas/rcar_thermal.c b/drivers/thermal/renesas/rcar_thermal.c
index af6d09a75bb6..1d6ee37968e2 100644
--- a/drivers/thermal/renesas/rcar_thermal.c
+++ b/drivers/thermal/renesas/rcar_thermal.c
@@ -39,11 +39,17 @@
/* THSSR */
#define CTEMP 0x3f
+/* .nirqs of every supported chip is at most this */
+#define RCAR_THERMAL_MAX_IRQ 2
+
struct rcar_thermal_common {
void __iomem *base;
struct device *dev;
struct list_head head;
spinlock_t lock;
+ bool shutdown;
+ int irqs[RCAR_THERMAL_MAX_IRQ];
+ int nirqs;
};
struct rcar_thermal_chip {
@@ -301,6 +307,15 @@ static void _rcar_thermal_irq_ctrl(struct rcar_thermal_priv *priv, int enable)
spin_lock_irqsave(&common->lock, flags);
+ /*
+ * rcar_thermal_work() re-enables its source when it finishes, so a
+ * work that was still running when the device went away would undo
+ * the mask that rcar_thermal_remove() writes. Once the shutdown
+ * state is visible nothing may enable the sources again.
+ */
+ if (common->shutdown)
+ enable = 0;
+
rcar_thermal_common_bset(common, INTMSK, mask, enable ? 0 : mask);
spin_unlock_irqrestore(&common->lock, flags);
@@ -376,9 +391,33 @@ static void rcar_thermal_remove(struct platform_device *pdev)
struct rcar_thermal_common *common = platform_get_drvdata(pdev);
struct device *dev = &pdev->dev;
struct rcar_thermal_priv *priv;
+ unsigned long flags;
+ int i;
- rcar_thermal_for_each_priv(priv, common) {
+ /*
+ * Publish the shutdown state before anything else: a work that is
+ * still running re-enables its interrupt source on its way out, and
+ * has to be prevented from undoing the mask written below.
+ */
+ spin_lock_irqsave(&common->lock, flags);
+ common->shutdown = true;
+ spin_unlock_irqrestore(&common->lock, flags);
+
+ /*
+ * Mask the sources, then wait for a handler that sampled the status
+ * before the mask was written. The handler drops common->lock
+ * before it queues the work, so without the wait it could queue
+ * priv->work after cancel_delayed_work_sync() has returned and leave
+ * the work running on a priv that devres frees once ->remove() has
+ * finished.
+ */
+ rcar_thermal_for_each_priv(priv, common)
rcar_thermal_irq_disable(priv);
+
+ for (i = 0; i < common->nirqs; i++)
+ synchronize_irq(common->irqs[i]);
+
+ rcar_thermal_for_each_priv(priv, common) {
cancel_delayed_work_sync(&priv->work);
if (priv->chip->use_of_thermal)
thermal_remove_hwmon_sysfs(priv->zone);
@@ -449,6 +488,8 @@ static int rcar_thermal_probe(struct platform_device *pdev)
if (ret)
goto error_unregister;
+ common->irqs[common->nirqs++] = irq;
+
/* update ENR bits */
if (chip->irq_per_ch)
enr_bits |= 1 << i;
--
2.34.1
^ permalink raw reply related [flat|nested] 5+ messages in thread* Re: [PATCH] thermal/drivers/rcar_thermal: wait for IRQs before cancelling work
2026-11-18 7:23 [PATCH] thermal/drivers/rcar_thermal: wait for IRQs before cancelling work Yaohan Li
@ 2026-11-18 9:00 ` Niklas Söderlund
2026-11-19 2:29 ` [PATCH v2] thermal/drivers/rcar_thermal: disable the work before masking the interrupt Yaohan Li
1 sibling, 0 replies; 5+ messages in thread
From: Niklas Söderlund @ 2026-11-18 9:00 UTC (permalink / raw)
To: Yaohan Li
Cc: rafael, daniel.lezcano, rui.zhang, lukasz.luba, geert+renesas,
magnus.damm, linux-renesas-soc, linux-pm, linux-kernel, edubezval
Hi Yaohan,
Thanks for your work.
On 2026-11-18 15:23:21 +0800, Yaohan Li wrote:
> rcar_thermal_remove() masks the interrupt sources and cancels the
> delayed work of each sensor. rcar_thermal_irq() reads INTMSK and STR
> under common->lock, drops the lock, and only then walks the sensors and
> queues priv->work for every sensor whose status changed.
>
> A handler that sampled the status before the mask was written can
> therefore reach queue_delayed_work() after cancel_delayed_work_sync()
> has returned. The work stays pending past the end of ->remove(), devres
> then frees common, priv and the thermal zone, and rcar_thermal_work()
> runs 300 ms later on freed memory.
>
> Waiting for the handler is not enough on its own: rcar_thermal_work()
> calls rcar_thermal_irq_enable() once it has updated the temperature, so
> a work that is still running when the removal starts re-enables its
> source and undoes the mask that ->remove() has just written.
>
> Record the shutdown in rcar_thermal_common under common->lock and make
> _rcar_thermal_irq_ctrl() refuse to enable anything once that state is
> visible. The removal then publishes the shutdown, masks all sources,
> waits for the handlers with synchronize_irq() and only then cancels the
> work, so neither a source nor a work item can be brought back after it
> returns.
>
> Fixes: 697ee786f15d ("thermal: rcar_thermal: Prevent doing work after unbind")
> Signed-off-by: Yaohan Li <shunsheng1218@gmail.com>
> ---
> Prepared against v7.4-rc1-1969-g666539eecdf4.
>
> AI assistance: the analysis, the change and its review notes were
> prepared with Claude (Anthropic) as a coding assistant. The author
> reviewed the reasoning and takes responsibility for the content.
>
> Testing: compile tested only (arm64, gcc 11.4). No R-Car hardware was
> available, so the unbind race was not run.
> drivers/thermal/renesas/rcar_thermal.c | 43 +++++++++++++++++++++++++-
> 1 file changed, 42 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/thermal/renesas/rcar_thermal.c b/drivers/thermal/renesas/rcar_thermal.c
> index af6d09a75bb6..1d6ee37968e2 100644
> --- a/drivers/thermal/renesas/rcar_thermal.c
> +++ b/drivers/thermal/renesas/rcar_thermal.c
> @@ -39,11 +39,17 @@
> /* THSSR */
> #define CTEMP 0x3f
>
> +/* .nirqs of every supported chip is at most this */
> +#define RCAR_THERMAL_MAX_IRQ 2
> +
> struct rcar_thermal_common {
> void __iomem *base;
> struct device *dev;
> struct list_head head;
> spinlock_t lock;
> + bool shutdown;
> + int irqs[RCAR_THERMAL_MAX_IRQ];
> + int nirqs;
> };
>
> struct rcar_thermal_chip {
> @@ -301,6 +307,15 @@ static void _rcar_thermal_irq_ctrl(struct rcar_thermal_priv *priv, int enable)
>
> spin_lock_irqsave(&common->lock, flags);
>
> + /*
> + * rcar_thermal_work() re-enables its source when it finishes, so a
> + * work that was still running when the device went away would undo
> + * the mask that rcar_thermal_remove() writes. Once the shutdown
> + * state is visible nothing may enable the sources again.
> + */
> + if (common->shutdown)
> + enable = 0;
> +
> rcar_thermal_common_bset(common, INTMSK, mask, enable ? 0 : mask);
>
> spin_unlock_irqrestore(&common->lock, flags);
> @@ -376,9 +391,33 @@ static void rcar_thermal_remove(struct platform_device *pdev)
> struct rcar_thermal_common *common = platform_get_drvdata(pdev);
> struct device *dev = &pdev->dev;
> struct rcar_thermal_priv *priv;
> + unsigned long flags;
> + int i;
>
> - rcar_thermal_for_each_priv(priv, common) {
> + /*
> + * Publish the shutdown state before anything else: a work that is
> + * still running re-enables its interrupt source on its way out, and
> + * has to be prevented from undoing the mask written below.
> + */
> + spin_lock_irqsave(&common->lock, flags);
> + common->shutdown = true;
> + spin_unlock_irqrestore(&common->lock, flags);
Adding a shutdown flag seems like a lot of complexity for somehting like
this. Would not being more clever here avoid that? Maybe something like
this,
/* No more work will be able to queued hence the irq can not rearm
* itself from the top half.
*/
disable_work_sync()
/* Disable any new interrupts in case they currently are enabled. */
rcar_thermal_irq_disable()
/* Wait for any bottom half interrupt to complete. */
synchronize_irq()
Now there can't be any races!
For this flag,
Nacked-by: Niklas Söderlund <niklas.soderlund+renesas@ragnatech.se>
> +
> + /*
> + * Mask the sources, then wait for a handler that sampled the status
> + * before the mask was written. The handler drops common->lock
> + * before it queues the work, so without the wait it could queue
> + * priv->work after cancel_delayed_work_sync() has returned and leave
> + * the work running on a priv that devres frees once ->remove() has
> + * finished.
> + */
> + rcar_thermal_for_each_priv(priv, common)
> rcar_thermal_irq_disable(priv);
> +
> + for (i = 0; i < common->nirqs; i++)
> + synchronize_irq(common->irqs[i]);
> +
> + rcar_thermal_for_each_priv(priv, common) {
> cancel_delayed_work_sync(&priv->work);
> if (priv->chip->use_of_thermal)
> thermal_remove_hwmon_sysfs(priv->zone);
> @@ -449,6 +488,8 @@ static int rcar_thermal_probe(struct platform_device *pdev)
> if (ret)
> goto error_unregister;
>
> + common->irqs[common->nirqs++] = irq;
> +
> /* update ENR bits */
> if (chip->irq_per_ch)
> enr_bits |= 1 << i;
> --
> 2.34.1
>
--
Kind Regards,
Niklas Söderlund
^ permalink raw reply [flat|nested] 5+ messages in thread* [PATCH v2] thermal/drivers/rcar_thermal: disable the work before masking the interrupt
2026-11-18 7:23 [PATCH] thermal/drivers/rcar_thermal: wait for IRQs before cancelling work Yaohan Li
2026-11-18 9:00 ` Niklas Söderlund
@ 2026-11-19 2:29 ` Yaohan Li
2026-11-19 6:22 ` Niklas Söderlund
1 sibling, 1 reply; 5+ messages in thread
From: Yaohan Li @ 2026-11-19 2:29 UTC (permalink / raw)
To: niklas.soderlund, rafael, daniel.lezcano
Cc: rui.zhang, lukasz.luba, geert+renesas, magnus.damm,
linux-renesas-soc, linux-pm, linux-kernel, edubezval
rcar_thermal_remove() masks the interrupt sources and then cancels the
delayed work of each sensor. rcar_thermal_irq() drops common->lock before
it walks the sensors and queues priv->work for those whose status changed,
so a handler that read the status before the mask was written can still
queue the work after cancel_delayed_work_sync() has returned. The work
then runs after ->remove() has finished and devres has freed common, priv
and the thermal zone.
Waiting for the handler alone is not enough either: rcar_thermal_work()
re-enables its interrupt source once it has updated the temperature, so a
work that is still running when the removal starts undoes the mask that
->remove() has just written.
Disable the work before the source is masked. That makes the
queue_delayed_work() calls in rcar_thermal_irq() no-ops and guarantees
that the re-enable in rcar_thermal_work() has already happened, so the
mask that follows cannot be undone.
The interrupt line is shared, so waiting for the handler once does not keep
it from running again later; unregister it in ->remove() instead of only
calling synchronize_irq(). devm_free_irq() waits for a handler that is
running right now as well, and the slot is marked unused so that the probe
failure path, which also ends here, cannot release it twice.
Every sensor that the removal walks has been through INIT_DELAYED_WORK()
before it is linked into common->head, so no uninitialised work is touched.
The interrupt numbers are recorded in an array whose unused slots stay
negative, instead of being counted separately.
Fixes: 697ee786f15d ("thermal: rcar_thermal: Prevent doing work after unbind")
Signed-off-by: Yaohan Li <shunsheng1218@gmail.com>
---
Prepared against v7.4-rc1-1969-g666539eecdf4.
Compile tested only: arm64, aarch64-linux-gnu-gcc 11.4, CONFIG_RCAR_THERMAL=y.
No hardware was available, so the removal path was not exercised and no race
injection was run.
AI assistance: prepared with Claude (Anthropic) as a coding assistant; the
author reviewed the reasoning and takes responsibility for the content.
Changes in v2:
- Drop the shutdown flag and the separate IRQ count. Niklas asked for less
state, so the removal now disables the delayed work before the source is
masked and unregisters the shared IRQ instead of waiting for it once.
- Keep the interrupt numbers in an array whose unused slots stay negative.
---
drivers/thermal/renesas/rcar_thermal.c | 37 ++++++++++++++++++++++++--
1 file changed, 35 insertions(+), 2 deletions(-)
diff --git a/drivers/thermal/renesas/rcar_thermal.c b/drivers/thermal/renesas/rcar_thermal.c
index af6d09a75bb6..3310ed4a8bda 100644
--- a/drivers/thermal/renesas/rcar_thermal.c
+++ b/drivers/thermal/renesas/rcar_thermal.c
@@ -39,11 +39,15 @@
/* THSSR */
#define CTEMP 0x3f
+/* .nirqs of every supported chip is at most this */
+#define RCAR_THERMAL_MAX_IRQ 2
+
struct rcar_thermal_common {
void __iomem *base;
struct device *dev;
struct list_head head;
spinlock_t lock;
+ int irqs[RCAR_THERMAL_MAX_IRQ];
};
struct rcar_thermal_chip {
@@ -376,10 +380,34 @@ static void rcar_thermal_remove(struct platform_device *pdev)
struct rcar_thermal_common *common = platform_get_drvdata(pdev);
struct device *dev = &pdev->dev;
struct rcar_thermal_priv *priv;
+ int i;
- rcar_thermal_for_each_priv(priv, common) {
+ /*
+ * Stop the work from being queued again and wait for a running one to
+ * finish before the interrupt source is masked: rcar_thermal_work()
+ * re-enables its source when it is done, so it has to be gone before
+ * the source is disabled for good.
+ */
+ rcar_thermal_for_each_priv(priv, common)
+ disable_delayed_work_sync(&priv->work);
+
+ rcar_thermal_for_each_priv(priv, common)
rcar_thermal_irq_disable(priv);
- cancel_delayed_work_sync(&priv->work);
+
+ /*
+ * The handler is shared, so waiting for it once is not enough: another
+ * user of the line can invoke it again after that, when the zones and
+ * the sensors it walks are already gone. Unregister it here; that
+ * waits for a handler that is running right now as well.
+ */
+ for (i = 0; i < RCAR_THERMAL_MAX_IRQ; i++) {
+ if (common->irqs[i] < 0)
+ continue;
+ devm_free_irq(dev, common->irqs[i], common);
+ common->irqs[i] = -ENOENT;
+ }
+
+ rcar_thermal_for_each_priv(priv, common) {
if (priv->chip->use_of_thermal)
thermal_remove_hwmon_sysfs(priv->zone);
else
@@ -413,6 +441,9 @@ static int rcar_thermal_probe(struct platform_device *pdev)
spin_lock_init(&common->lock);
common->dev = dev;
+ for (i = 0; i < RCAR_THERMAL_MAX_IRQ; i++)
+ common->irqs[i] = -ENOENT;
+
pm_runtime_enable(dev);
pm_runtime_get_sync(dev);
@@ -449,6 +480,8 @@ static int rcar_thermal_probe(struct platform_device *pdev)
if (ret)
goto error_unregister;
+ common->irqs[i] = irq;
+
/* update ENR bits */
if (chip->irq_per_ch)
enr_bits |= 1 << i;
--
2.34.1
^ permalink raw reply related [flat|nested] 5+ messages in thread* Re: [PATCH v2] thermal/drivers/rcar_thermal: disable the work before masking the interrupt
2026-11-19 2:29 ` [PATCH v2] thermal/drivers/rcar_thermal: disable the work before masking the interrupt Yaohan Li
@ 2026-11-19 6:22 ` Niklas Söderlund
2026-11-19 11:18 ` Yaohan Li
0 siblings, 1 reply; 5+ messages in thread
From: Niklas Söderlund @ 2026-11-19 6:22 UTC (permalink / raw)
To: Yaohan Li
Cc: rafael, daniel.lezcano, rui.zhang, lukasz.luba, geert+renesas,
magnus.damm, linux-renesas-soc, linux-pm, linux-kernel, edubezval
Hi Yaohan,
Thanks for your work.
On 2026-11-19 10:29:03 +0800, Yaohan Li wrote:
> rcar_thermal_remove() masks the interrupt sources and then cancels the
> delayed work of each sensor. rcar_thermal_irq() drops common->lock before
> it walks the sensors and queues priv->work for those whose status changed,
> so a handler that read the status before the mask was written can still
> queue the work after cancel_delayed_work_sync() has returned. The work
> then runs after ->remove() has finished and devres has freed common, priv
> and the thermal zone.
>
> Waiting for the handler alone is not enough either: rcar_thermal_work()
> re-enables its interrupt source once it has updated the temperature, so a
> work that is still running when the removal starts undoes the mask that
> ->remove() has just written.
>
> Disable the work before the source is masked. That makes the
> queue_delayed_work() calls in rcar_thermal_irq() no-ops and guarantees
> that the re-enable in rcar_thermal_work() has already happened, so the
> mask that follows cannot be undone.
>
> The interrupt line is shared, so waiting for the handler once does not keep
> it from running again later; unregister it in ->remove() instead of only
> calling synchronize_irq(). devm_free_irq() waits for a handler that is
> running right now as well, and the slot is marked unused so that the probe
> failure path, which also ends here, cannot release it twice.
>
> Every sensor that the removal walks has been through INIT_DELAYED_WORK()
> before it is linked into common->head, so no uninitialised work is touched.
> The interrupt numbers are recorded in an array whose unused slots stay
> negative, instead of being counted separately.
>
> Fixes: 697ee786f15d ("thermal: rcar_thermal: Prevent doing work after unbind")
> Signed-off-by: Yaohan Li <shunsheng1218@gmail.com>
>
> ---
> Prepared against v7.4-rc1-1969-g666539eecdf4.
>
> Compile tested only: arm64, aarch64-linux-gnu-gcc 11.4, CONFIG_RCAR_THERMAL=y.
> No hardware was available, so the removal path was not exercised and no race
> injection was run.
Ohh, could you test this please. It's a rather large change and while it
looks correct it could behave differently then expected.
>
> AI assistance: prepared with Claude (Anthropic) as a coding assistant; the
> author reviewed the reasoning and takes responsibility for the content.
>
> Changes in v2:
> - Drop the shutdown flag and the separate IRQ count. Niklas asked for less
> state, so the removal now disables the delayed work before the source is
> masked and unregisters the shared IRQ instead of waiting for it once.
> - Keep the interrupt numbers in an array whose unused slots stay negative.
> ---
> drivers/thermal/renesas/rcar_thermal.c | 37 ++++++++++++++++++++++++--
> 1 file changed, 35 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/thermal/renesas/rcar_thermal.c b/drivers/thermal/renesas/rcar_thermal.c
> index af6d09a75bb6..3310ed4a8bda 100644
> --- a/drivers/thermal/renesas/rcar_thermal.c
> +++ b/drivers/thermal/renesas/rcar_thermal.c
> @@ -39,11 +39,15 @@
> /* THSSR */
> #define CTEMP 0x3f
>
> +/* .nirqs of every supported chip is at most this */
.nirqs is not really needed here. Just say something along the line of
max number of supported interrupts or some such.
> +#define RCAR_THERMAL_MAX_IRQ 2
> +
> struct rcar_thermal_common {
> void __iomem *base;
> struct device *dev;
> struct list_head head;
> spinlock_t lock;
> + int irqs[RCAR_THERMAL_MAX_IRQ];
> };
>
> struct rcar_thermal_chip {
> @@ -376,10 +380,34 @@ static void rcar_thermal_remove(struct platform_device *pdev)
> struct rcar_thermal_common *common = platform_get_drvdata(pdev);
> struct device *dev = &pdev->dev;
> struct rcar_thermal_priv *priv;
> + int i;
unsigned.
>
> - rcar_thermal_for_each_priv(priv, common) {
> + /*
> + * Stop the work from being queued again and wait for a running one to
> + * finish before the interrupt source is masked: rcar_thermal_work()
> + * re-enables its source when it is done, so it has to be gone before
> + * the source is disabled for good.
I think you can make this less verbose and more to the point.
> + */
> + rcar_thermal_for_each_priv(priv, common)
> + disable_delayed_work_sync(&priv->work);
> +
> + rcar_thermal_for_each_priv(priv, common)
> rcar_thermal_irq_disable(priv);
> - cancel_delayed_work_sync(&priv->work);
> +
> + /*
> + * The handler is shared, so waiting for it once is not enough: another
> + * user of the line can invoke it again after that, when the zones and
line?
> + * the sensors it walks are already gone. Unregister it here; that
> + * waits for a handler that is running right now as well.
I don't understand this.
> + */
> + for (i = 0; i < RCAR_THERMAL_MAX_IRQ; i++) {
Please declare the loop variable in the for () statement to reduce
scope.
> + if (common->irqs[i] < 0)
> + continue;
> + devm_free_irq(dev, common->irqs[i], common);
> + common->irqs[i] = -ENOENT;
> + }
> +
> + rcar_thermal_for_each_priv(priv, common) {
> if (priv->chip->use_of_thermal)
> thermal_remove_hwmon_sysfs(priv->zone);
> else
> @@ -413,6 +441,9 @@ static int rcar_thermal_probe(struct platform_device *pdev)
> spin_lock_init(&common->lock);
> common->dev = dev;
>
> + for (i = 0; i < RCAR_THERMAL_MAX_IRQ; i++)
Here you can't declare the loop variable as the function already
declares it at the function level. This is likely because this function
pre-dates when it was OK to declare it directly in the loop definition.
No need to update old tested code en-mass, but lets use the better way
in new code.
> + common->irqs[i] = -ENOENT;
> +
> pm_runtime_enable(dev);
> pm_runtime_get_sync(dev);
>
> @@ -449,6 +480,8 @@ static int rcar_thermal_probe(struct platform_device *pdev)
> if (ret)
> goto error_unregister;
>
> + common->irqs[i] = irq;
> +
> /* update ENR bits */
> if (chip->irq_per_ch)
> enr_bits |= 1 << i;
> --
> 2.34.1
>
--
Kind Regards,
Niklas Söderlund
^ permalink raw reply [flat|nested] 5+ messages in thread* Re: [PATCH v2] thermal/drivers/rcar_thermal: disable the work before masking the interrupt
2026-11-19 6:22 ` Niklas Söderlund
@ 2026-11-19 11:18 ` Yaohan Li
0 siblings, 0 replies; 5+ messages in thread
From: Yaohan Li @ 2026-11-19 11:18 UTC (permalink / raw)
To: Niklas Söderlund
Cc: Rafael J. Wysocki, Daniel Lezcano, Zhang Rui, Lukasz Luba,
Geert Uytterhoeven, Magnus Damm, linux-renesas-soc, linux-pm,
linux-kernel, Eduardo Valentin
Hi Niklas,
thanks for the review. The code changes you asked for are in my tree, and I
would like to check the testing question with you before posting a v3.
The delayed work is now disabled before the interrupt source is masked, so
the handler cannot queue new work after the cancellation, and a work that is
already running cannot re-enable the source behind the mask. The shared
interrupt is unregistered with devm_free_irq() rather than waited for with
synchronize_irq(): the line stays registered for its other users, and they
can raise it again after synchronize_irq() returns. The RCAR_THERMAL_MAX_IRQ
comment, the loop variable and the two comments in rcar_thermal_remove() are
as you suggested, and the shutdown flag is gone.
On testing: there is no R-Car hardware here, so what I have is a controlled
ordering test on a KASAN kernel, 17 checks, all passing. It uses the real
delayed work, workqueue, wait and signal machinery and a simulated interrupt
line shared by two handlers. It shows that a work queued after
cancel_delayed_work_sync() still runs while the same queue attempt after
disable_delayed_work_sync() is rejected, that a running work undoes a mask
written before the cancellation, and that after synchronize_irq() another
user of the line can invoke our handler again while devm_free_irq() ends
that.
What the test does not do is run rcar_thermal's own ->remove(). It
re-implements the removal ordering, because exercising the driver would need
a real platform device, MMIO and a thermal zone, so the behaviour of the
interrupt status registers on real hardware remains unverified.
I can send the v3 with these changes if that is useful; if you would rather
see a different shape for the removal sequence, I will rework that first.
Thanks,
Yaohan
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2026-11-19 11:18 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-18 7:23 [PATCH] thermal/drivers/rcar_thermal: wait for IRQs before cancelling work Yaohan Li
2026-11-18 9:00 ` Niklas Söderlund
2026-11-19 2:29 ` [PATCH v2] thermal/drivers/rcar_thermal: disable the work before masking the interrupt Yaohan Li
2026-11-19 6:22 ` Niklas Söderlund
2026-11-19 11:18 ` Yaohan Li
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox