Re: [PATCH 1/2] firmware: arm_scmi: Fix deadlock between reboot notifier and forceful work

From: Cristian Marussi

Date: Tue Nov 17 2026 - 06:25:37 EST


On Mon, Nov 16, 2026 at 06:25:52PM +0000, Sudeep Holla wrote:
> On Mon, Nov 16, 2026 at 08:42:10AM +0000, Cristian Marussi wrote:
> > From: Chengyu Liu <lui2012qwq@xxxxxxxxx>

Hi Sudeep,

> >
> > scmi_reboot_notifier() calls cancel_delayed_work_sync() while holding
> > sc->state_mtx, but the work it waits on - scmi_forceful_work_func() -
> > takes the same mutex. If a forceful transition work is in flight when
> > the reboot notifier fires, the notifier holds the lock and waits for
> > the callback while the callback waits for the lock: deadlock, and the
> > reboot wedges.
> >
> > Moving the cancel outside the lock is not sufficient on its own, as the
> > callback also calls unregister_reboot_notifier() unconditionally, which
> > blocks on the reboot chain rwsem (down_write vs. the in-progress
> > chain's down_read) while the notifier waits for the callback - the
> > deadlock would just move to a different lock. Fix both sides:
> >
> > - Notifier: compute the decision under state_mtx, drop the lock, then
> > cancel. A callback that slips in between sees state ==
> > SCMI_SYSPOWER_REBOOTING (not IN_PROGRESS), skips the forceful
> > request and finishes, so the cancel cannot miss it. (The callback's
> > own system_state early-return does not cover a work item that
> > started before the reboot began: kernel_restart_prepare() runs the
> > notifier chain before setting system_state.)
> >
> > - Callback: only unregister the reboot notifier when actually forcing
> > the transition - that is the only case that needs it, because the
> > forceful kernel_restart()/kernel_power_off() would otherwise
> > re-enter scmi_reboot_notifier and self-deadlock on state_mtx. When
> > the state is not IN_PROGRESS there is nothing to force, and skipping
> > the unregister keeps the callback from blocking on the reboot chain
> > rwsem while the notifier waits for it.
> >
> > Found by static analysis.
> >
> > Cc: stable@xxxxxxxxxxxxxxx
> > Fixes: 2c4b97fee94a ("firmware: arm_scmi: Add SCMI System Power Control driver")
> > Signed-off-by: Chengyu Liu <lui2012qwq@xxxxxxxxx>
> > [Cristian: drop lock before triggering forceful reboot (needs_forceful)]
> > Tested-by: Cristian Marussi <cristian.marussi@xxxxxxx>
> > Signed-off-by: Cristian Marussi <cristian.marussi@xxxxxxx>
> > ---
> > .../firmware/arm_scmi/scmi_power_control.c | 26 ++++++++++++++-----
> > 1 file changed, 19 insertions(+), 7 deletions(-)
> >
> > diff --git a/drivers/firmware/arm_scmi/scmi_power_control.c b/drivers/firmware/arm_scmi/scmi_power_control.c
> > index e791a206768c..e0680e33180e 100644
> > --- a/drivers/firmware/arm_scmi/scmi_power_control.c
> > +++ b/drivers/firmware/arm_scmi/scmi_power_control.c
> > @@ -121,6 +121,7 @@ static int scmi_reboot_notifier(struct notifier_block *nb,
> > unsigned long reason, void *__unused)
> > {
> > struct scmi_syspower_conf *sc = reboot_nb_to_sconf(nb);
> > + bool cancel_work;
> >
> > mutex_lock(&sc->state_mtx);
> > switch (reason) {
> > @@ -138,11 +139,18 @@ static int scmi_reboot_notifier(struct notifier_block *nb,
> > break;
> > }
> >
> > - if (sc->state == SCMI_SYSPOWER_REBOOTING) {
> > + cancel_work = sc->state == SCMI_SYSPOWER_REBOOTING;
> > + mutex_unlock(&sc->state_mtx);
> > +
> > + if (cancel_work) {
> > dev_dbg(sc->dev, "Reboot in progress...cancel delayed work.\n");
> > + /*
> > + * cancel_delayed_work_sync() waits for a running
> > + * scmi_forceful_work_func(), which takes state_mtx - it must
> > + * not be called with the lock held.
> > + */
> > cancel_delayed_work_sync(&sc->forceful_work);
>
> Sashiko still complains about the deadlock.
>

Yes I know.

> How about changing this to non-sync cancel_delayed_work() so that it doesn't
> wait and deadlock like it complains ?
>

Indeed I think this is just the solution...I mean dropping this patch as
a whole and keeping the original wider locking section BUT do not cancel
synchronously, but simply with cancel_delayed_work(&sc->forceful_work);

> > }
> > - mutex_unlock(&sc->state_mtx);
> >
> > return NOTIFY_OK;
> > }
> > @@ -181,6 +189,7 @@ static void scmi_forceful_work_func(struct work_struct *work)
> > {
> > struct scmi_syspower_conf *sc;
> > struct delayed_work *dwork;
> > + bool needs_forceful;
> >
> > if (system_state > SYSTEM_RUNNING)
> > return;
> > @@ -188,13 +197,16 @@ static void scmi_forceful_work_func(struct work_struct *work)
> > dwork = to_delayed_work(work);
> > sc = dwork_to_sconf(dwork);
> >
> > - dev_dbg(sc->dev, "Graceful request timed out...forcing !\n");
> > mutex_lock(&sc->state_mtx);
> > - /* avoid deadlock by unregistering reboot notifier first */
> > - unregister_reboot_notifier(&sc->reboot_nb);
> > - if (sc->state == SCMI_SYSPOWER_IN_PROGRESS)
> > - scmi_request_forceful_transition(sc);
> > + needs_forceful = sc->state == SCMI_SYSPOWER_IN_PROGRESS;
> > mutex_unlock(&sc->state_mtx);
> > +
> > + if (needs_forceful) {
> > + dev_dbg(sc->dev, "Graceful request timed out...forcing !\n");
> > + /* avoid deadlock by unregistering reboot notifier first */
> > + unregister_reboot_notifier(&sc->reboot_nb);
>
> And re-evaluate needs_forceful again here after un-registration before
> calling below forced transition ?
>

If all of this is locked as it was originally there is no need, the two
threads should just sync properly...

Let's see what Sashiko thinks..

Thanks,
Cristian