From: Greg Kroah-Hartman Date: Mon, 8 Apr 2024 09:23:26 +0000 (+0200) Subject: 5.10-stable patches X-Git-Tag: v5.15.154~50 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=b7e00677d347dcf9d58820b9c4ac3bdfbdfa7101;p=thirdparty%2Fkernel%2Fstable-queue.git 5.10-stable patches added patches: driver-core-introduce-device_link_wait_removal.patch of-dynamic-synchronize-of_changeset_destroy-with-the-devlink-removals.patch --- diff --git a/queue-5.10/driver-core-introduce-device_link_wait_removal.patch b/queue-5.10/driver-core-introduce-device_link_wait_removal.patch new file mode 100644 index 00000000000..1c5b4bb4233 --- /dev/null +++ b/queue-5.10/driver-core-introduce-device_link_wait_removal.patch @@ -0,0 +1,119 @@ +From 0462c56c290a99a7f03e817ae5b843116dfb575c Mon Sep 17 00:00:00 2001 +From: Herve Codina +Date: Mon, 25 Mar 2024 16:21:25 +0100 +Subject: driver core: Introduce device_link_wait_removal() + +From: Herve Codina + +commit 0462c56c290a99a7f03e817ae5b843116dfb575c upstream. + +The commit 80dd33cf72d1 ("drivers: base: Fix device link removal") +introduces a workqueue to release the consumer and supplier devices used +in the devlink. +In the job queued, devices are release and in turn, when all the +references to these devices are dropped, the release function of the +device itself is called. + +Nothing is present to provide some synchronisation with this workqueue +in order to ensure that all ongoing releasing operations are done and +so, some other operations can be started safely. + +For instance, in the following sequence: + 1) of_platform_depopulate() + 2) of_overlay_remove() + +During the step 1, devices are released and related devlinks are removed +(jobs pushed in the workqueue). +During the step 2, OF nodes are destroyed but, without any +synchronisation with devlink removal jobs, of_overlay_remove() can raise +warnings related to missing of_node_put(): + ERROR: memory leak, expected refcount 1 instead of 2 + +Indeed, the missing of_node_put() call is going to be done, too late, +from the workqueue job execution. + +Introduce device_link_wait_removal() to offer a way to synchronize +operations waiting for the end of devlink removals (i.e. end of +workqueue jobs). +Also, as a flushing operation is done on the workqueue, the workqueue +used is moved from a system-wide workqueue to a local one. + +Cc: stable@vger.kernel.org +Signed-off-by: Herve Codina +Tested-by: Luca Ceresoli +Reviewed-by: Nuno Sa +Reviewed-by: Saravana Kannan +Acked-by: Greg Kroah-Hartman +Link: https://lore.kernel.org/r/20240325152140.198219-2-herve.codina@bootlin.com +Signed-off-by: Rob Herring +Signed-off-by: Greg Kroah-Hartman +--- + drivers/base/core.c | 26 +++++++++++++++++++++++--- + include/linux/device.h | 1 + + 2 files changed, 24 insertions(+), 3 deletions(-) + +--- a/drivers/base/core.c ++++ b/drivers/base/core.c +@@ -53,6 +53,7 @@ static unsigned int defer_sync_state_cou + static unsigned int defer_fw_devlink_count; + static LIST_HEAD(deferred_fw_devlink); + static DEFINE_MUTEX(defer_fw_devlink_lock); ++static struct workqueue_struct *device_link_wq; + static bool fw_devlink_is_permissive(void); + + #ifdef CONFIG_SRCU +@@ -364,12 +365,26 @@ static void devlink_dev_release(struct d + /* + * It may take a while to complete this work because of the SRCU + * synchronization in device_link_release_fn() and if the consumer or +- * supplier devices get deleted when it runs, so put it into the "long" +- * workqueue. ++ * supplier devices get deleted when it runs, so put it into the ++ * dedicated workqueue. + */ +- queue_work(system_long_wq, &link->rm_work); ++ queue_work(device_link_wq, &link->rm_work); + } + ++/** ++ * device_link_wait_removal - Wait for ongoing devlink removal jobs to terminate ++ */ ++void device_link_wait_removal(void) ++{ ++ /* ++ * devlink removal jobs are queued in the dedicated work queue. ++ * To be sure that all removal jobs are terminated, ensure that any ++ * scheduled work has run to completion. ++ */ ++ flush_workqueue(device_link_wq); ++} ++EXPORT_SYMBOL_GPL(device_link_wait_removal); ++ + static struct class devlink_class = { + .name = "devlink", + .owner = THIS_MODULE, +@@ -3415,9 +3430,14 @@ int __init devices_init(void) + sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); + if (!sysfs_dev_char_kobj) + goto char_kobj_err; ++ device_link_wq = alloc_workqueue("device_link_wq", 0, 0); ++ if (!device_link_wq) ++ goto wq_err; + + return 0; + ++ wq_err: ++ kobject_put(sysfs_dev_char_kobj); + char_kobj_err: + kobject_put(sysfs_dev_block_kobj); + block_kobj_err: +--- a/include/linux/device.h ++++ b/include/linux/device.h +@@ -973,6 +973,7 @@ void device_link_del(struct device_link + void device_link_remove(void *consumer, struct device *supplier); + void device_links_supplier_sync_state_pause(void); + void device_links_supplier_sync_state_resume(void); ++void device_link_wait_removal(void); + + extern __printf(3, 4) + int dev_err_probe(const struct device *dev, int err, const char *fmt, ...); diff --git a/queue-5.10/of-dynamic-synchronize-of_changeset_destroy-with-the-devlink-removals.patch b/queue-5.10/of-dynamic-synchronize-of_changeset_destroy-with-the-devlink-removals.patch new file mode 100644 index 00000000000..a5df7a3e775 --- /dev/null +++ b/queue-5.10/of-dynamic-synchronize-of_changeset_destroy-with-the-devlink-removals.patch @@ -0,0 +1,71 @@ +From 8917e7385346bd6584890ed362985c219fe6ae84 Mon Sep 17 00:00:00 2001 +From: Herve Codina +Date: Mon, 25 Mar 2024 16:21:26 +0100 +Subject: of: dynamic: Synchronize of_changeset_destroy() with the devlink removals + +From: Herve Codina + +commit 8917e7385346bd6584890ed362985c219fe6ae84 upstream. + +In the following sequence: + 1) of_platform_depopulate() + 2) of_overlay_remove() + +During the step 1, devices are destroyed and devlinks are removed. +During the step 2, OF nodes are destroyed but +__of_changeset_entry_destroy() can raise warnings related to missing +of_node_put(): + ERROR: memory leak, expected refcount 1 instead of 2 ... + +Indeed, during the devlink removals performed at step 1, the removal +itself releasing the device (and the attached of_node) is done by a job +queued in a workqueue and so, it is done asynchronously with respect to +function calls. +When the warning is present, of_node_put() will be called but wrongly +too late from the workqueue job. + +In order to be sure that any ongoing devlink removals are done before +the of_node destruction, synchronize the of_changeset_destroy() with the +devlink removals. + +Fixes: 80dd33cf72d1 ("drivers: base: Fix device link removal") +Cc: stable@vger.kernel.org +Signed-off-by: Herve Codina +Reviewed-by: Saravana Kannan +Tested-by: Luca Ceresoli +Reviewed-by: Nuno Sa +Link: https://lore.kernel.org/r/20240325152140.198219-3-herve.codina@bootlin.com +Signed-off-by: Rob Herring +Signed-off-by: Greg Kroah-Hartman +--- + drivers/of/dynamic.c | 12 ++++++++++++ + 1 file changed, 12 insertions(+) + +--- a/drivers/of/dynamic.c ++++ b/drivers/of/dynamic.c +@@ -9,6 +9,7 @@ + + #define pr_fmt(fmt) "OF: " fmt + ++#include + #include + #include + #include +@@ -675,6 +676,17 @@ void of_changeset_destroy(struct of_chan + { + struct of_changeset_entry *ce, *cen; + ++ /* ++ * When a device is deleted, the device links to/from it are also queued ++ * for deletion. Until these device links are freed, the devices ++ * themselves aren't freed. If the device being deleted is due to an ++ * overlay change, this device might be holding a reference to a device ++ * node that will be freed. So, wait until all already pending device ++ * links are deleted before freeing a device node. This ensures we don't ++ * free any device node that has a non-zero reference count. ++ */ ++ device_link_wait_removal(); ++ + list_for_each_entry_safe_reverse(ce, cen, &ocs->entries, node) + __of_changeset_entry_destroy(ce); + } diff --git a/queue-5.10/series b/queue-5.10/series index 7bd7316da22..03aef3ca5f6 100644 --- a/queue-5.10/series +++ b/queue-5.10/series @@ -234,3 +234,5 @@ ata-sata_sx4-fix-pdc20621_get_from_dimm-on-64-bit.patch scsi-mylex-fix-sysfs-buffer-lengths.patch ata-sata_mv-fix-pci-device-id-table-declaration-comp.patch alsa-hda-realtek-update-panasonic-cf-sz6-quirk-to-support-headset-with-microphone.patch +driver-core-introduce-device_link_wait_removal.patch +of-dynamic-synchronize-of_changeset_destroy-with-the-devlink-removals.patch