[PATCH 3/5] driver core: async device shutdown infrastructure
David Jeffery
djeffery at redhat.com
Tue Jun 16 09:10:23 PDT 2026
On Tue, Jun 16, 2026 at 11:23 AM David Jeffery <djeffery at redhat.com> 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 <djeffery at redhat.com>
> Signed-off-by: Stuart Hayes <stuart.w.hayes at gmail.com>
> Tested-by: Laurence Oberman <loberman at redhat.com>
> ---
> .../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
More information about the kexec
mailing list