On Tue, Jun 16, 2026 at 11:23 AM David Jeffery <[email protected]> wrote: > > Patterned after async suspend, allow devices to mark themselves as wanting > to perform async shutdown. Devices using async shutdown wait only for their > dependencies to shutdown before executing their shutdown routine. > > Sync shutdown devices are shut down one at a time and will only wait for an > async shutdown device if the async device is a dependency. > > Enabled by default, async shutdown can be explicitly enabled or disabled > by using the kernel parameter "core.async_shutdown=<bool>" > > Signed-off-by: David Jeffery <[email protected]> > Signed-off-by: Stuart Hayes <[email protected]> > Tested-by: Laurence Oberman <[email protected]> > --- > .../admin-guide/kernel-parameters.txt | 10 ++ > drivers/base/base.h | 2 + > drivers/base/core.c | 127 +++++++++++++++++- > include/linux/device.h | 2 + > 4 files changed, 140 insertions(+), 1 deletion(-) > > diff --git a/Documentation/admin-guide/kernel-parameters.txt > b/Documentation/admin-guide/kernel-parameters.txt > index b5a51a36a048..dd912f47ace4 100644 > --- a/Documentation/admin-guide/kernel-parameters.txt > +++ b/Documentation/admin-guide/kernel-parameters.txt > @@ -1019,6 +1019,16 @@ Kernel parameters > seconds. A value of 0 disables the blank timer. > Defaults to 0. > > + core.async_shutdown= > + [KNL] > + Format: <bool> > + Enable or disable asynchronous shutdown support. When > + enabled, on system shutdown unrelated devices flagged > + as async shutdown compatible may be shut down in > + parallel and asynchronously. When disabled, device > + shutdown is performed in a serially and synchronously. > + Enabled by default. > + > coredump_filter= > [KNL] Change the default value for > /proc/<pid>/coredump_filter. > diff --git a/drivers/base/base.h b/drivers/base/base.h > index a5b7abc10ff0..40dbf588a5d6 100644 > --- a/drivers/base/base.h > +++ b/drivers/base/base.h > @@ -103,6 +103,7 @@ struct driver_private { > * dev_err_probe() for later retrieval via debugfs > * @device: pointer back to the struct device that this structure is > * associated with. > + * @complete: completion for device shutdown ordering > * @dead: This device is currently either in the process of or has been > * removed from the system. Any asynchronous events scheduled for this > * device should exit without taking any action. > @@ -119,6 +120,7 @@ struct device_private { > const struct device_driver *async_driver; > char *deferred_probe_reason; > struct device *device; > + struct completion complete; > u8 dead:1; > }; > #define to_device_private_parent(obj) \ > diff --git a/drivers/base/core.c b/drivers/base/core.c > index 3b3d983b1747..751fe2e13b3a 100644 > --- a/drivers/base/core.c > +++ b/drivers/base/core.c > @@ -9,6 +9,7 @@ > */ > > #include <linux/acpi.h> > +#include <linux/async.h> > #include <linux/blkdev.h> > #include <linux/cleanup.h> > #include <linux/cpufreq.h> > @@ -37,6 +38,10 @@ > #include "physical_location.h" > #include "power/power.h" > > +static bool async_shutdown = true; > +module_param(async_shutdown, bool, 0644); > +MODULE_PARM_DESC(async_shutdown, "Enable asynchronous device shutdown > support"); > + > /* Device links support. */ > static LIST_HEAD(deferred_sync); > static unsigned int defer_sync_state_count = 1; > @@ -3606,6 +3611,7 @@ static int device_private_init(struct device *dev) > klist_init(&dev->p->klist_children, klist_children_get, > klist_children_put); > INIT_LIST_HEAD(&dev->p->deferred_probe); > + init_completion(&dev->p->complete); > return 0; > } > > @@ -3895,6 +3901,7 @@ bool kill_device(struct device *dev) > if (dev->p->dead) > return false; > dev->p->dead = true; > + complete_all(&dev->p->complete); > return true; > } > EXPORT_SYMBOL_GPL(kill_device); > @@ -4865,6 +4872,37 @@ int device_change_owner(struct device *dev, kuid_t > kuid, kgid_t kgid) > return error; > } > > +static bool wants_async_shutdown(struct device *dev) > +{ > + return async_shutdown && dev_async_shutdown(dev); > +} > + > +static int wait_for_device_shutdown(struct device *dev, void *data) > +{ > + bool async = *(bool *)data; > + > + if (async || wants_async_shutdown(dev)) > + wait_for_completion(&dev->p->complete); > + > + return 0; > +} > + > +static void wait_for_shutdown_dependencies(struct device *dev, bool async) > +{ > + struct device_link *link; > + int idx; > + > + device_for_each_child(dev, &async, wait_for_device_shutdown); > + > + idx = device_links_read_lock(); > + > + dev_for_each_link_to_consumer(link, dev) > + if (!device_link_flag_is_sync_state_only(link->flags)) > + wait_for_device_shutdown(link->consumer, &async); > + > + device_links_read_unlock(idx); > +} > + > static void __shutdown_one_device(struct device *dev) > { > if (dev->p->dead) > @@ -4888,6 +4926,8 @@ static void __shutdown_one_device(struct device *dev) > dev_info(dev, "shutdown\n"); > dev->driver->shutdown(dev); > } > + > + complete_all(&dev->p->complete); > } > > static void shutdown_one_device(struct device *dev) > @@ -4917,6 +4957,80 @@ static void shutdown_one_device(struct device *dev) > put_device(dev); > } > > +static void async_shutdown_handler(void *data, async_cookie_t cookie) > +{ > + struct device *dev = data; > + > + wait_for_shutdown_dependencies(dev, true); > + shutdown_one_device(dev); > +} > + > +static bool shutdown_device_async(struct device *dev) > +{ > + if (async_schedule_dev_nocall(async_shutdown_handler, dev)) > + return true; > + > + dev_clear_async_shutdown(dev); > + return false; > +} > + > + > +static void start_async_shutdown_devices(void) > +{ > + struct device *dev, *next, *ndev, *needs_put = NULL; > + bool clear_async = false; > + > + if (!async_shutdown) > + return; > + > + spin_lock(&devices_kset->list_lock); > +restart: > + list_for_each_entry_safe_reverse(dev, next, &devices_kset->list, > + kobj.entry) { > + if (wants_async_shutdown(dev)) { > + if (clear_async) { > + dev_clear_async_shutdown(dev); > + continue; > + } > + get_device(dev); > + > + if (!list_entry_is_head(next, &devices_kset->list, > + kobj.entry)) > + ndev = get_device(next); > + else > + ndev = NULL; > + spin_unlock(&devices_kset->list_lock); > + > + if (shutdown_device_async(dev)) { > + list_del_init(&dev->kobj.entry);
Sashiko detected a locking error here. The lock rework made list_del_init occur while not holding the spinlock, which is a potential list corruption issue. This will be corrected in the next iteration. David Jeffery
