firmware: arm_scmi: Fix SCMI core cleanup paths
Sudeep Holla
maintainerv2 cover firmware: arm_scmi: Fix SCMI core cleanup paths
This series fixes a set of SCMI core and mailbox transport lifetime issues found around device creation, channel setup failure, notification teardown and malformed firmware descriptions.
Most of these issues were found by Sashiko[1][2] while reviewing the ACPI SCMI PCC work[3]. They are posted separately because the problems are independent SCMI core and mailbox transport cleanup bugs, and do not depend on the ACPI PCC series.
Here is the attempt to fix them, some of them can be dropped if it is too theoretical. I have addressed all the issues that made sense to me at the time of reading the report.
The fixes tighten ownership and teardown rules for generated SCMI devices, transport devices and transport channels. They make internal transport devices reachable by explicit teardown without exposing them to normal SCMI driver binding, ensure partially initialized channels are unwound on setup failures, and avoid IDR/device lifetime races during probe failure and device unbind.
The series also fixes notifier and notification teardown ordering. Requested device notifiers are unregistered before protocol IDRs are destroyed, RCU is used around requested-device protocol lookups, and transport callbacks are stopped before notification state is released.
The mailbox transport fixes cover both setup failure unwinding and an early interrupt window: mailbox callbacks can run as soon as mbox_request_channel() binds the client and starts the controller, so the SCMI mailbox transport now publishes its cinfo before requesting channels.
Fixes tags need to be checked again or even dropped if it is not a stable material. Just some placeholders that I thought are appropriated are in place.
Summary:
- Fix OF node reference ownership for generated SCMI devices.
- Allow explicit teardown lookup of internal transport devices.
- Clean up TX/RX channels when SCMI channel setup fails midway.
- Fix SCMI device lifetime handling around child lookup and bus ID reuse.
- Free transport resources when IDR insertion fails after channel setup.
- Unregister requested-device notifier before active protocol IDR teardown.
- Unwind mailbox channels on TX receiver and P2A receiver setup failures.
- Protect requested-device protocol lookup with RCU.
- Avoid modifying an IDR while iterating it during channel cleanup.
- Clear the SystemPower singleton flag on SCMI device creation failure.
- Reject out-of-range DT protocol IDs instead of allowing u8 truncation.
- Stop transport callbacks before releasing notification state.
- Publish mailbox cinfo before requesting mailbox channels.
[1] https://sashiko.dev/#/patchset/[email protected]
[2] https://sashiko.dev/#/patchset/[email protected]
[3] https://patch.msgid.link/[email protected]
---
Changes in v2:
(Mostly addressing the additional issues found by Sashiko)
- Added fixes for IDR mutation during channel cleanup.
- Added SystemPower singleton flag unwind on device creation failure.
- Added validation to skip out-of-range DT protocol IDs.
- Moved notification teardown after transport channel cleanup.
- Published mailbox cinfo before mbox_request_channel() can enable callbacks.
- Link to v1: https://patch.msgid.link/[email protected]
---
Sudeep Holla (14):
firmware: arm_scmi: Fix OF node reference handling
firmware: arm_scmi: Fix transport device teardown lookup
firmware: arm_scmi: Clean up channels on setup failure
firmware: arm_scmi: Fix SCMI device destroy lifetimes
firmware: arm_scmi: Free transport channel on IDR failure
firmware: arm_scmi: Unregister device notifier before IDR teardown
firmware: arm_scmi: Unwind TX receiver mailbox setup failure
firmware: arm_scmi: Unwind P2A receiver mailbox setup failure
firmware: arm_scmi: Protect device request lookup with RCU
firmware: arm_scmi: Avoid IDR updates while cleaning channels
firmware: arm_scmi: Clear SystemPower flag on create failure
firmware: arm_scmi: Reject out of range DT protocol IDs
firmware: arm_scmi: Stop channels before notification teardown
firmware: arm_scmi: Publish mailbox cinfo before channel request
drivers/firmware/arm_scmi/bus.c | 72 ++++++++++++++++---------- drivers/firmware/arm_scmi/common.h | 2 + drivers/firmware/arm_scmi/driver.c | 44 +++++++++------- drivers/firmware/arm_scmi/transports/mailbox.c | 26 +++++++--- 4 files changed, 90 insertions(+), 54 deletions(-)
---
base-commit: dc59e4fea9d83f03bad6bddf3fa2e52491777482
change-id: 20260629-scmi_core_fixes-da3cd753b4ea
Signature · 2 lines
Regards, Sudeep
Sudeep Holla
maintainerPATCH v2 1/14 firmware: arm_scmi: Fix OF node reference handling
SCMI devices store the DT node in dev.of_node through device_set_node(), but that helper only assigns the fwnode and of_node pointers without taking an OF node reference.
Take a reference when assigning the node and release it from the SCMI device release path. With the device owning that reference, remove the separate channel-side get/put pair from the core driver.
--- drivers/firmware/arm_scmi/bus.c | 3 ++- drivers/firmware/arm_scmi/driver.c | 4 ---- 2 files changed, 2 insertions(+), 5 deletions(-)
drivers/firmware/arm_scmi/bus.c +2 -1
@@ -395,6 +395,7 @@ static void scmi_device_release(struct device *dev) {struct scmi_device *scmi_dev =to_scmi_dev (dev); +of_node_put (dev->of_node);kfree_const (scmi_dev->name);kfree (scmi_dev); }
@@ -465,7 +466,7 @@ __scmi_device_create(struct device_node *np, struct device *parent, scmi_dev->id = id; scmi_dev->protocol_id = protocol; scmi_dev->dev.parent = parent; -device_set_node (&scmi_dev->dev,of_fwnode_handle (np)); +device_set_node (&scmi_dev->dev,of_fwnode_handle (of_node_get (np))); scmi_dev->dev.bus = &scmi_bus_type; scmi_dev->dev.release = scmi_device_release;dev_set_name (&scmi_dev->dev,"scmi_dev.%d" , id);
drivers/firmware/arm_scmi/driver.c +0 -4
@@ -2778,13 +2778,11 @@ static int scmi_chan_setup(struct scmi_info *info, struct device_node *of_node,devm_kfree (info->dev, cinfo);return -EINVAL ; } -of_node_get (of_node); cinfo->id = prot_id; cinfo->dev = &tdev->dev; ret = info->desc->ops->chan_setup (cinfo, info->dev, tx);if (ret) { -of_node_put (of_node);scmi_device_destroy (info->dev, prot_id, name);devm_kfree (info->dev, cinfo);return ret;
@@ -2807,7 +2805,6 @@ static int scmi_chan_setup(struct scmi_info *info, struct device_node *of_node, "unable to allocate SCMI idr slot err %d\n", ret);/* Destroy channel and device only if created by this call. */ if (tdev) { -of_node_put (of_node);scmi_device_destroy (info->dev, prot_id, name);devm_kfree (info->dev, cinfo); }
@@ -2892,7 +2889,6 @@ static int scmi_chan_destroy(int id, void *p, void *idr)struct scmi_info *info =handle_to_scmi_info (cinfo->handle);struct scmi_device *sdev =to_scmi_dev (cinfo->dev); -of_node_put (cinfo->dev->of_node);scmi_device_destroy (info->dev, id, sdev->name); cinfo->dev =NULL ; }
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 2/14 firmware: arm_scmi: Fix transport device teardown lookup
In reply to Sudeep HollaSCMI transport devices are deliberately excluded from normal SCMI bus matching so protocol drivers cannot bind to the internal transport children. However, scmi_device_destroy() uses the same protocol/name lookup to find devices that must be unregistered during channel teardown.
Split the match helper so driver matching still skips transport devices, while explicit child lookup can find them for teardown. Use a shared transport-device name prefix macro for both matching and name generation.
Since transport-device names are derived from direction and protocol ID, reject duplicate protocol channel setup before creating or finding a transport device. This prevents malformed firmware with duplicate protocol child nodes from reusing an existing transport device and then destroying it when the duplicate IDR insertion fails.
--- drivers/firmware/arm_scmi/bus.c | 22 +++++++++++++++++----- drivers/firmware/arm_scmi/common.h | 2 ++ drivers/firmware/arm_scmi/driver.c | 5 ++++- 3 files changed, 23 insertions(+), 6 deletions(-)
drivers/firmware/arm_scmi/bus.c +17 -5
@@ -201,21 +201,33 @@ scmi_protocol_table_unregister(const struct scmi_device_id *id_table)scmi_protocol_device_unrequest (entry); } -static int scmi_dev_match_by_id_table (struct scmi_device *scmi_dev, -const struct scmi_device_id *id_table) +static bool scmi_device_is_transport (const struct scmi_device *scmi_dev) +{ +return !strncmp (scmi_dev->name,SCMI_TRANSPORT_DEVNAME_PREFIX , +strlen (SCMI_TRANSPORT_DEVNAME_PREFIX )); +} + +static int __scmi_dev_match_by_id_table (struct scmi_device *scmi_dev, +const struct scmi_device_id *id_table, +bool skip_transport) {if (!id_table || !id_table->name)return 0 ; -/* Always skip transport devices from matching */ for (; id_table->protocol_id && id_table->name; id_table++)if (id_table->protocol_id == scmi_dev->protocol_id && -strncmp (scmi_dev->name,"__scmi_transport_device" ,23 ) && + !(skip_transport &&scmi_device_is_transport (scmi_dev)) && !strcmp (id_table->name, scmi_dev->name))return 1 ;return 0 ; } +static int scmi_dev_match_by_id_table (struct scmi_device *scmi_dev, +const struct scmi_device_id *id_table) +{ +return __scmi_dev_match_by_id_table (scmi_dev, id_table, true); +} +static int scmi_dev_match_id (struct scmi_device *scmi_dev,const struct scmi_driver *scmi_drv) {
@@ -235,7 +247,7 @@ static int scmi_match_by_id_table(struct device *dev, const void *data)struct scmi_device *scmi_dev =to_scmi_dev (dev);const struct scmi_device_id *id_table = data; -return scmi_dev_match_by_id_table (scmi_dev, id_table); +return __scmi_dev_match_by_id_table (scmi_dev, id_table, false); } static struct scmi_device *scmi_child_dev_find(struct device *parent,
drivers/firmware/arm_scmi/common.h +2 -0
@@ -34,6 +34,8 @@#define SCMI_SHMEM_MAX_PAYLOAD_SIZE 104 +#define SCMI_TRANSPORT_DEVNAME_PREFIX "__scmi_transport_device" +enum scmi_error_codes {SCMI_SUCCESS =0 ,/* Success */ SCMI_ERR_SUPPORT =-1 ,/* Not supported */
drivers/firmware/arm_scmi/driver.c +4 -1
@@ -2751,6 +2751,9 @@ static int scmi_chan_setup(struct scmi_info *info, struct device_node *of_node, idx = tx ?0 :1 ; idr = tx ? &info->tx_idr : &info->rx_idr; +if (idr_find (idr, prot_id)) +return -EEXIST ; +if (!info->desc->ops->chan_available (of_node, idx)) { cinfo =idr_find (idr,SCMI_PROTOCOL_BASE );if (unlikely (!cinfo))/* Possible only if platform has no Rx */
@@ -2768,7 +2771,7 @@ static int scmi_chan_setup(struct scmi_info *info, struct device_node *of_node, cinfo->no_completion_irq = info->desc->no_completion_irq;/* Create a unique name for this transport device */ -snprintf (name,32 ,"__scmi_transport_device_%s_%02X" , +snprintf (name,sizeof (name),SCMI_TRANSPORT_DEVNAME_PREFIX "_%s_%02X" , idx ?"rx" :"tx" , prot_id);/* Create a uniquely named, dedicated transport device for this chan */ tdev =scmi_device_create (of_node, info->dev, prot_id, name);
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 3/14 firmware: arm_scmi: Clean up channels on setup failure
In reply to Sudeep Hollascmi_channels_setup() can fail after the common BASE channel or earlier protocol channels have already been registered in the TX/RX IDRs.
Route this failure through the existing channel cleanup label so the transport channels, transport devices and IDR state created before the failure are released before the probe error path frees the SCMI instance ID.
--- drivers/firmware/arm_scmi/driver.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
drivers/firmware/arm_scmi/driver.c +1 -2
@@ -3262,7 +3262,7 @@ static int scmi_probe(struct platform_device *pdev) ret =scmi_channels_setup (info);if (ret) { err_str ="failed to setup channels\n" ; - goto clear_ida; + goto clear_txrx_setup; } ret =bus_register_notifier (&scmi_bus_type, &info->bus_nb);
@@ -3377,7 +3377,6 @@ static int scmi_probe(struct platform_device *pdev)bus_unregister_notifier (&scmi_bus_type, &info->bus_nb); clear_txrx_setup:scmi_cleanup_txrx_channels (info); -clear_ida:ida_free (&scmi_id, info->id); out_err:
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 4/14 firmware: arm_scmi: Fix SCMI device destroy lifetimes
In reply to Sudeep Hollascmi_child_dev_find() drops the reference returned by device_find_child() before returning the scmi_device pointer. A concurrent unregister can then release the device while the destroy path is still using the returned pointer.
Make the lookup helper return the device_find_child() reference and keep it until scmi_device_destroy() has finished unregistering the child.
Also split device_unregister() in __scmi_device_destroy() so the SCMI bus ID is not made reusable until after device_del() has removed the old scmi_dev.N name from sysfs. This avoids a new SCMI device reusing the same ID while the old device is still registered.
--- drivers/firmware/arm_scmi/bus.c | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-)
drivers/firmware/arm_scmi/bus.c +14 -11
@@ -250,8 +250,9 @@ static int scmi_match_by_id_table(struct device *dev, const void *data)return __scmi_dev_match_by_id_table (scmi_dev, id_table, false); } -static struct scmi_device *scmi_child_dev_find (struct device *parent, -int prot_id,const char *name) +/* Returns a device_find_child() reference which must be dropped by caller. */ +static struct scmi_device * +scmi_child_dev_find_get (struct device *parent,int prot_id,const char *name) {struct scmi_device_id id_table[2 ] = {0 };struct device *dev;
@@ -263,9 +264,6 @@ static struct scmi_device *scmi_child_dev_find(struct device *parent,if (!dev)return NULL ; -/* Drop the refcnt bumped implicitly by device_find_child */ -put_device (dev); -return to_scmi_dev (dev); }
@@ -422,8 +420,9 @@ static void __scmi_device_destroy(struct scmi_device *scmi_dev)if (scmi_dev->protocol_id ==SCMI_PROTOCOL_SYSTEM )atomic_set (&scmi_syspower_registered,0 ); +device_del (&scmi_dev->dev);ida_free (&scmi_bus_id, scmi_dev->id); -device_unregister (&scmi_dev->dev); +put_device (&scmi_dev->dev); } static struct scmi_device *
@@ -440,9 +439,11 @@ __scmi_device_create(struct device_node *np, struct device *parent,* each DT defined protocol at probe time, and the concurrent * registration of SCMI drivers. */ - scmi_dev =scmi_child_dev_find (parent, protocol, name); -if (scmi_dev) + scmi_dev =scmi_child_dev_find_get (parent, protocol, name); +if (scmi_dev) { +put_device (&scmi_dev->dev);return scmi_dev; + }/* * Ignore any possible subsequent failures while creating the device
@@ -492,8 +493,8 @@ __scmi_device_create(struct device_node *np, struct device *parent,return scmi_dev; put_dev: +ida_free (&scmi_bus_id, scmi_dev->id);put_device (&scmi_dev->dev); -ida_free (&scmi_bus_id, id);return NULL ; }
@@ -574,9 +575,11 @@ void scmi_device_destroy(struct device *parent, int protocol, const char *name) {struct scmi_device *scmi_dev; - scmi_dev =scmi_child_dev_find (parent, protocol, name); -if (scmi_dev) + scmi_dev =scmi_child_dev_find_get (parent, protocol, name); +if (scmi_dev) {__scmi_device_destroy (scmi_dev); +put_device (&scmi_dev->dev); + } }EXPORT_SYMBOL_GPL (scmi_device_destroy);
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 5/14 firmware: arm_scmi: Free transport channel on IDR failure
In reply to Sudeep HollaIf transport channel setup succeeds but the following IDR insertion fails, the error path destroys the transport device and frees the channel info without invoking the transport cleanup callback.
Call chan_free() before destroying the device so transport specific resources such as IRQs, mailbox channels and mapped shared memory are released consistently with the normal teardown path.
--- drivers/firmware/arm_scmi/driver.c | 1 + 1 file changed, 1 insertion(+)
drivers/firmware/arm_scmi/driver.c +1 -0
@@ -2808,6 +2808,7 @@ static int scmi_chan_setup(struct scmi_info *info, struct device_node *of_node, "unable to allocate SCMI idr slot err %d\n", ret);/* Destroy channel and device only if created by this call. */ if (tdev) { + info->desc->ops->chan_free (prot_id, cinfo, idr);scmi_device_destroy (info->dev, prot_id, name);devm_kfree (info->dev, cinfo); }
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 6/14 firmware: arm_scmi: Unregister device notifier before IDR teardown
In reply to Sudeep HollaThe requested-devices notifier looks up protocol fwnodes from the active_protocols IDR. During remove, unregister the notifier before releasing and destroying active_protocols so no notifier callback can race with the IDR teardown.
Keep the bus notifier registered until after the protocol state is torn down, matching the existing remove ordering for SCMI bus users.
--- drivers/firmware/arm_scmi/driver.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
drivers/firmware/arm_scmi/driver.c +3 -2
@@ -3402,6 +3402,9 @@ static void scmi_remove(struct platform_device *pdev)scmi_notification_exit (&info->handle); +blocking_notifier_chain_unregister (&scmi_requested_devices_nh, + &info->dev_req_nb); +mutex_lock (&info->protocols_mtx);idr_destroy (&info->protocols);mutex_unlock (&info->protocols_mtx);
@@ -3410,8 +3413,6 @@ static void scmi_remove(struct platform_device *pdev)of_node_put (child);idr_destroy (&info->active_protocols); -blocking_notifier_chain_unregister (&scmi_requested_devices_nh, - &info->dev_req_nb);bus_unregister_notifier (&scmi_bus_type, &info->bus_nb);/* Safe to free channels since no more users */
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 7/14 firmware: arm_scmi: Unwind TX receiver mailbox setup failure
In reply to Sudeep Hollamailbox_chan_setup() can request an additional unidirectional TX receiver channel after successfully acquiring the primary channel. If that second request fails, the function returns immediately and leaves the primary channel allocated.
Unwind the primary mailbox channel before returning the error so probe deferral or other setup failures do not leave the channel busy for later probe attempts.
--- drivers/firmware/arm_scmi/transports/mailbox.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/firmware/arm_scmi/transports/mailbox.c +6 -1
@@ -225,9 +225,10 @@ static int mailbox_chan_setup(struct scmi_chan_info *cinfo, struct device *dev, smbox->chan_receiver =mbox_request_channel (cl, a2p_rx_chan);if (IS_ERR (smbox->chan_receiver)) { ret =PTR_ERR (smbox->chan_receiver); + smbox->chan_receiver =NULL ;if (ret != -EPROBE_DEFER )dev_err (cdev,"failed to request SCMI Tx Receiver mailbox\n" ); -return ret; + goto err_free_chan; } }
@@ -246,6 +247,10 @@ static int mailbox_chan_setup(struct scmi_chan_info *cinfo, struct device *dev,mutex_init (&smbox->chan_lock);return 0 ; + +err_free_chan: +mbox_free_channel (smbox->chan); +return ret; }static int mailbox_chan_free (int id,void *p,void *data)
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 8/14 firmware: arm_scmi: Unwind P2A receiver mailbox setup failure
In reply to Sudeep Hollamailbox_chan_setup() can request an additional P2A receiver channel after successfully acquiring the primary P2A channel. If that later request fails, the function returns immediately and leaves the primary channel allocated.
Unwind the primary mailbox channel before returning the error so probe deferral or other setup failures do not leave the channel busy for later probe attempts.
--- drivers/firmware/arm_scmi/transports/mailbox.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
drivers/firmware/arm_scmi/transports/mailbox.c +4 -1
@@ -236,9 +236,10 @@ static int mailbox_chan_setup(struct scmi_chan_info *cinfo, struct device *dev, smbox->chan_platform_receiver =mbox_request_channel (cl, p2a_rx_chan);if (IS_ERR (smbox->chan_platform_receiver)) { ret =PTR_ERR (smbox->chan_platform_receiver); + smbox->chan_platform_receiver =NULL ;if (ret != -EPROBE_DEFER )dev_err (cdev,"failed to request SCMI P2A Receiver mailbox\n" ); -return ret; + goto err_free_chan; } }
@@ -248,6 +249,8 @@ static int mailbox_chan_setup(struct scmi_chan_info *cinfo, struct device *dev,return 0 ; +err_free_chan_receiver: +mbox_free_channel (smbox->chan_receiver); err_free_chan:mbox_free_channel (smbox->chan);return ret;
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 9/14 firmware: arm_scmi: Protect device request lookup with RCU
In reply to Sudeep HollaThe SCMI device request notifier looks up protocol OF nodes from the active_protocols IDR. The IDR lookup can run concurrently with protocol activation while probe is still registering protocols and creating their SCMI devices.
Wrap the lookup in an RCU read-side critical section as required by the IDR API for lockless readers.
--- drivers/firmware/arm_scmi/driver.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/firmware/arm_scmi/driver.c +3 -0
@@ -33,6 +33,7 @@#include <linux/of.h> #include <linux/platform_device.h> #include <linux/processor.h> +#include <linux/rcupdate.h> #include <linux/refcount.h> #include <linux/slab.h> #include <linux/xarray.h>
@@ -2957,7 +2958,9 @@ static int scmi_device_request_notifier(struct notifier_block *nb,struct scmi_device_id *id_table = data;struct scmi_info *info =req_nb_to_scmi_info (nb); +rcu_read_lock (); np =idr_find (&info->active_protocols, id_table->protocol_id); +rcu_read_unlock ();if (!np)return NOTIFY_DONE ;
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 10/14 firmware: arm_scmi: Avoid IDR updates while cleaning channels
In reply to Sudeep Hollascmi_cleanup_channels() walks the TX/RX channel IDRs with idr_for_each() to free transport resources and destroy the dedicated transport devices before calling idr_destroy().
The destroy callback removed each entry from the same IDR being walked. That is not needed for this cleanup path, and it is unsafe because idr_for_each() has not advanced its radix-tree iterator while the callback is running. Removing the current entry from the callback can invalidate the iterator state. The callback also cannot be protected by rcu_read_lock(), because scmi_device_destroy() may sleep.
Leave IDR teardown to the following idr_destroy() call and keep the callback limited to device destruction.
--- drivers/firmware/arm_scmi/driver.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
drivers/firmware/arm_scmi/driver.c +1 -3
@@ -2886,7 +2886,7 @@ static int scmi_channels_setup(struct scmi_info *info)return 0 ; } -static int scmi_chan_destroy (int id,void *p,void *idr) +static int scmi_chan_destroy (int id,void *p,void *data) {struct scmi_chan_info *cinfo = p;
@@ -2898,8 +2898,6 @@ static int scmi_chan_destroy(int id, void *p, void *idr) cinfo->dev =NULL ; } -idr_remove (idr, id); -return 0 ; }
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 11/14 firmware: arm_scmi: Clear SystemPower flag on create failure
In reply to Sudeep Holla__scmi_device_create() reserves the singleton SystemPower protocol device by setting scmi_syspower_registered before allocating and registering the SCMI device.
If any later step fails, the function returns NULL but leaves the flag set. A subsequent retry, for example after probe deferral, then observes the stale reservation and rejects creation of the SystemPower protocol device permanently.
Route all failures after the successful reservation through a common unwind path which clears scmi_syspower_registered again. Keep the duplicate-device rejection path unchanged because that path did not acquire the reservation.
--- drivers/firmware/arm_scmi/bus.c | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-)
drivers/firmware/arm_scmi/bus.c +12 -10
@@ -431,6 +431,7 @@ __scmi_device_create(struct device_node *np, struct device *parent, {int id, retval;struct scmi_device *scmi_dev; +bool syspower = (protocol ==SCMI_PROTOCOL_SYSTEM );/* * If the same protocol/name device already exist under the same parent
@@ -446,14 +447,12 @@ __scmi_device_create(struct device_node *np, struct device *parent, }/* -* Ignore any possible subsequent failures while creating the device -* since we are doomed anyway at that point; not using a mutex which -* spans across this whole function to keep things simple and to avoid -* to serialize all the __scmi_device_create calls across possibly -* different SCMI server instances (parent) +* Reserve the singleton SystemPower protocol device before +* allocation and registration. This keeps creation simple without +* a mutex spanning the whole function; error paths after the +* reservation must drop it again. */ -if (protocol ==SCMI_PROTOCOL_SYSTEM && -atomic_cmpxchg (&scmi_syspower_registered,0 ,1 )) { +if (syspower &&atomic_cmpxchg (&scmi_syspower_registered,0 ,1 )) {dev_warn (parent,"SCMI SystemPower protocol device must be unique !\n" );return NULL ;
@@ -461,19 +460,19 @@ __scmi_device_create(struct device_node *np, struct device *parent, scmi_dev =kzalloc_obj (*scmi_dev);if (!scmi_dev) -return NULL ; + goto clear_syspower; scmi_dev->name =kstrdup_const (name ?:"unknown" ,GFP_KERNEL );if (!scmi_dev->name) {kfree (scmi_dev); -return NULL ; + goto clear_syspower; } id =ida_alloc_min (&scmi_bus_id,1 ,GFP_KERNEL );if (id <0 ) {kfree_const (scmi_dev->name);kfree (scmi_dev); -return NULL ; + goto clear_syspower; } scmi_dev->id = id;
@@ -495,6 +494,9 @@ __scmi_device_create(struct device_node *np, struct device *parent, put_dev:ida_free (&scmi_bus_id, scmi_dev->id);put_device (&scmi_dev->dev); +clear_syspower: +if (syspower) +atomic_set (&scmi_syspower_registered,0 );return NULL ; }
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 12/14 firmware: arm_scmi: Reject out of range DT protocol IDs
In reply to Sudeep HollaSCMI protocol IDs carried in message headers are limited by MSG_PROTOCOL_ID_MASK. The DT parsing paths noticed protocol IDs outside that range, but only logged an error and then kept processing the invalid value.
That lets a malformed 32-bit DT reg value reach helpers which take a u8 protocol ID, where it can be truncated and/or treated as a different protocol.
For channel setup, two different out-of-range values can also be used as distinct IDR keys while aliasing the generated SCMI protocol identity.
Skip DT protocol nodes whose reg value does not fit the SCMI protocol ID field before setting up channels or creating protocol devices.
--- drivers/firmware/arm_scmi/driver.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
drivers/firmware/arm_scmi/driver.c +6 -2
@@ -2874,9 +2874,11 @@ static int scmi_channels_setup(struct scmi_info *info)if (of_property_read_u32 (child,"reg" , &prot_id))continue ; -if (!FIELD_FIT (MSG_PROTOCOL_ID_MASK , prot_id)) +if (!FIELD_FIT (MSG_PROTOCOL_ID_MASK , prot_id)) {dev_err (info->dev,"Out of range protocol %d\n" , prot_id); +continue ; + } ret =scmi_txrx_setup (info, child, prot_id);if (ret)
@@ -3341,8 +3343,10 @@ static int scmi_probe(struct platform_device *pdev)if (of_property_read_u32 (child,"reg" , &prot_id))continue ; -if (!FIELD_FIT (MSG_PROTOCOL_ID_MASK , prot_id)) +if (!FIELD_FIT (MSG_PROTOCOL_ID_MASK , prot_id)) {dev_err (dev,"Out of range protocol %d\n" , prot_id); +continue ; + }if (!scmi_is_protocol_implemented (handle, prot_id)) { dev_err(dev, "SCMI protocol %d not implemented\n",
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 13/14 firmware: arm_scmi: Stop channels before notification teardown
In reply to Sudeep Hollascmi_notification_exit() clears and releases the notification instance, but transport callbacks can still deliver incoming notifications until the TX/RX channels are freed.
During remove, an RX interrupt in that window can enter scmi_notify() while the notification instance is being torn down and then dereference freed notification state. The same ordering exists on the probe error path after notification initialization.
Unregister the requested device notifier first, then stop transport callbacks by cleaning up the TX/RX channels before releasing the notification core. This keeps the notification data alive until no transport callback can queue or process a new event.
--- drivers/firmware/arm_scmi/driver.c | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-)
drivers/firmware/arm_scmi/driver.c +7 -8
@@ -3328,7 +3328,7 @@ static int scmi_probe(struct platform_device *pdev)dev_err (dev,"%s" , err_str);return 0 ; } - goto notification_exit; + goto raw_mode_cleanup; }mutex_lock (&scmi_list_mutex);
@@ -3372,10 +3372,9 @@ static int scmi_probe(struct platform_device *pdev)return 0 ; -notification_exit: +raw_mode_cleanup:if (IS_ENABLED (CONFIG_ARM_SCMI_RAW_MODE_SUPPORT ))scmi_raw_mode_cleanup (info->raw); -scmi_notification_exit (&info->handle); clear_dev_req_notifier:blocking_notifier_chain_unregister (&scmi_requested_devices_nh, &info->dev_req_nb);
@@ -3383,6 +3382,7 @@ static int scmi_probe(struct platform_device *pdev)bus_unregister_notifier (&scmi_bus_type, &info->bus_nb); clear_txrx_setup:scmi_cleanup_txrx_channels (info); +scmi_notification_exit (&info->handle);ida_free (&scmi_id, info->id); out_err:
@@ -3405,11 +3405,13 @@ static void scmi_remove(struct platform_device *pdev)list_del (&info->node);mutex_unlock (&scmi_list_mutex); -scmi_notification_exit (&info->handle); -blocking_notifier_chain_unregister (&scmi_requested_devices_nh, &info->dev_req_nb); +/* Stop transport callbacks before tearing down notifications. */ +scmi_cleanup_txrx_channels (info); +scmi_notification_exit (&info->handle); +mutex_lock (&info->protocols_mtx);idr_destroy (&info->protocols);mutex_unlock (&info->protocols_mtx);
@@ -3420,9 +3422,6 @@ static void scmi_remove(struct platform_device *pdev)bus_unregister_notifier (&scmi_bus_type, &info->bus_nb); -/* Safe to free channels since no more users */ -scmi_cleanup_txrx_channels (info); -ida_free (&scmi_id, info->id); }
Signature · 1 line
2.43.0
Sudeep Holla
maintainerPATCH v2 14/14 firmware: arm_scmi: Publish mailbox cinfo before channel request
In reply to Sudeep Hollamailbox_chan_setup() initializes smbox->cinfo only after all mailbox channels have been requested successfully. That is too late because mbox_request_channel() binds the client before invoking the controller startup callback, and startup can enable interrupt delivery.
If a pending or spurious mailbox interrupt fires during that window, mbox_chan_received_data() can call the SCMI mailbox rx_callback() before smbox->cinfo is set. The callback dereferences smbox->cinfo on both the spurious IRQ path and the normal RX path, so this can crash before channel setup has completed.
Publish cinfo->transport_info and smbox->cinfo, and initialize the chan_lock, before requesting any mailbox channel. Clear the early published pointers again on setup failure so later cleanup does not see a half-initialized transport.
--- drivers/firmware/arm_scmi/transports/mailbox.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-)
drivers/firmware/arm_scmi/transports/mailbox.c +9 -5
@@ -211,13 +211,18 @@ static int mailbox_chan_setup(struct scmi_chan_info *cinfo, struct device *dev, cl->tx_block = false; cl->knows_txdone = tx; + cinfo->transport_info = smbox; + smbox->cinfo = cinfo; +mutex_init (&smbox->chan_lock); + smbox->chan =mbox_request_channel (cl, tx ?0 : p2a_chan);if (IS_ERR (smbox->chan)) { ret =PTR_ERR (smbox->chan); + smbox->chan =NULL ;if (ret != -EPROBE_DEFER )dev_err (cdev,"failed to request SCMI %s mailbox\n" , desc); -return ret; + goto err_clear_cinfo; }/* Additional unidirectional channel for TX if needed */
@@ -243,16 +248,15 @@ static int mailbox_chan_setup(struct scmi_chan_info *cinfo, struct device *dev, } } - cinfo->transport_info = smbox; - smbox->cinfo = cinfo; -mutex_init (&smbox->chan_lock); -return 0 ; err_free_chan_receiver:mbox_free_channel (smbox->chan_receiver); err_free_chan:mbox_free_channel (smbox->chan); +err_clear_cinfo: + cinfo->transport_info =NULL ; + smbox->cinfo =NULL ;return ret; }
Signature · 1 line
2.43.0