FAILED: patch "[PATCH] driver core: take parent lock in async device attach" failed to apply to 5.15-stable tree
Subsystems (2)
[email protected]
maintainerThe patch below does not apply to the 5.15-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-5.15.y
git checkout FETCH_HEAD
git cherry-pick -x 187a62f99da29b1a55602b0d401a783d8dc86161
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026110317-rigging-rarity-dd61@gregkh' --subject-prefix 'PATCH 5.15.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From 187a62f99da29b1a55602b0d401a783d8dc86161 Mon Sep 17 00:00:00 2001
From: Mario Peter <[email protected]>
Date: Wed, 14 Oct 2026 15:31:09 +0200
Subject: [PATCH] driver core: take parent lock in async device attach
For device types with need_parent_lock set (only USB interfaces), probe() must run with the parent device locked. A synchronous attach after device_add() gets this from the caller, e.g. usb_set_configuration() holds the udev lock while adding interfaces. __device_attach_async_helper() runs the probe from an async worker instead, where that lock isn't held, and only takes device_lock(dev).
With async probing enabled for the hub driver (e.g. driver_async_probe=* or driver_async_probe=hub), this races when a multi-TT hub is configured. For multi-TT hubs, hub_probe() calls usb_set_interface(hdev, 0, 1) to select the TT-per-port altsetting, and usb_set_interface() creates the endpoint devices of the interface a second time:
usb_set_configuration() async worker
[udev locked]
device_add(intf)
queues the probe ----------> __device_attach_async_helper()
[intf locked, udev not locked]
hub_probe()
usb_set_interface(hdev, 0, 1)
create_intf_ep_devs(intf) create_intf_ep_devs(intf)create_intf_ep_devs() checks and sets intf->ep_devs_created without a lock of its own. If usb_set_configuration() has created ep_81 but not yet set the flag, usb_set_interface() skips removing the endpoint devices of the old altsetting and creates ep_81 again. With a synchronous probe, hub_probe() runs inside device_add() with the udev lock held, and usb_set_configuration() then finds ep_devs_created already set.
Single-TT hubs don't call usb_set_interface() from hub_probe() and don't show this warning, but their probe runs without the udev lock as well.
On an i.MX8MM board with an onboard USB2514 hub this hit 11 of 100 boots:
sysfs: cannot create duplicate filename '.../1-1/1-1:1.0/ep_81'
Call trace: sysfs_warn_dup usb_create_ep_devs create_intf_ep_devs usb_set_interface hub_probe usb_probe_interface really_probe __device_attach_async_helper async_run_entry_fn
It also shows on v7.3-rc6 in QEMU, with dummy_hcd and a raw-gadget program emulating a multi-TT hub: re-authorizing the hub in a loop, while a SCHED_FIFO task preempts the writing task at random points for 3 ms, hit the warning in 29 of 6000 iterations.
Take the parent lock in __device_attach_async_helper() as well, like __driver_attach_async_helper() does, and move __device_driver_lock/unlock() up for that. With this the warning was gone in 300 boots on the board and in 6000 iterations in QEMU.
[ johan: switch to async_schedule_dev_nocall() to avoid deadlock if
async_schedule_dev() runs synchronously when parent lock is held ]
[ Fold the nested conditions into a single if statement; correct commit
message to mention "device types" rather than "buses" for "need_parent_lock". - Danilo ]
drivers/base/dd.c +45 -38
@@ -1030,6 +1030,38 @@ static int __device_attach_driver(struct device_driver *drv, void *_data)return ret ==0 ; } +/* +* __device_driver_lock - acquire locks needed to manipulate dev->drv +* @dev: Device we will update driver info for +* @parent: Parent device. Needed if the device type requires parent lock +* +* This function will take the required locks for manipulating dev->drv. +* Normally this will just be the @dev lock, but when called for a USB +* interface, @parent lock will be held as well. +*/ +static void __device_driver_lock (struct device *dev,struct device *parent) +{ +if (dev->type && dev->type->need_parent_lock && parent) +device_lock (parent); +device_lock (dev); +} + +/* +* __device_driver_unlock - release locks needed to manipulate dev->drv +* @dev: Device we will update driver info for +* @parent: Parent device. Needed if the device type requires parent lock +* +* This function will release the required locks for manipulating dev->drv. +* Normally this will just be the @dev lock, but when called for a +* USB interface, @parent lock will be released as well. +*/ +static void __device_driver_unlock (struct device *dev,struct device *parent) +{ +device_unlock (dev); +if (dev->type && dev->type->need_parent_lock && parent) +device_unlock (parent); +} +static void __device_attach_async_helper (void *_dev,async_cookie_t cookie) {struct device *dev = _dev;
@@ -1039,7 +1071,7 @@ static void __device_attach_async_helper(void *_dev, async_cookie_t cookie) .want_async = true, }; -device_lock (dev); +__device_driver_lock (dev, dev->parent);/* * Check if device has already been removed or claimed. This may
@@ -1061,7 +1093,7 @@ static void __device_attach_async_helper(void *_dev, async_cookie_t cookie)if (dev->parent)pm_runtime_put (dev->parent); out_unlock: -device_unlock (dev); +__device_driver_unlock (dev, dev->parent);put_device (dev); }
@@ -1118,8 +1150,11 @@ static int __device_attach(struct device *dev, bool allow_async) } out_unlock:device_unlock (dev); -if (async) -async_schedule_dev (__device_attach_async_helper, dev); +if (async && !async_schedule_dev_nocall (__device_attach_async_helper, dev)) { +put_device (dev); + ret =2 ;/* retry synchronously */ + } +return ret; }
@@ -1146,48 +1181,20 @@ EXPORT_SYMBOL_GPL(device_attach);void device_initial_probe (struct device *dev) {struct subsys_private *sp =bus_to_subsys (dev->bus); +int ret;if (!sp)return ; -if (sp->drivers_autoprobe) -__device_attach (dev, true); +if (sp->drivers_autoprobe) { + ret =__device_attach (dev, true); +if (ret ==2 ) +__device_attach (dev, false); + }subsys_put (sp); } -/* -* __device_driver_lock - acquire locks needed to manipulate dev->drv -* @dev: Device we will update driver info for -* @parent: Parent device. Needed if the device type requires parent lock -* -* This function will take the required locks for manipulating dev->drv. -* Normally this will just be the @dev lock, but when called for a USB -* interface, @parent lock will be held as well. -*/ -static void __device_driver_lock (struct device *dev,struct device *parent) -{ -if (dev->type && dev->type->need_parent_lock && parent) -device_lock (parent); -device_lock (dev); -} - -/* -* __device_driver_unlock - release locks needed to manipulate dev->drv -* @dev: Device we will update driver info for -* @parent: Parent device. Needed if the device type requires parent lock -* -* This function will release the required locks for manipulating dev->drv. -* Normally this will just be the @dev lock, but when called for a -* USB interface, @parent lock will be released as well. -*/ -static void __device_driver_unlock (struct device *dev,struct device *parent) -{ -device_unlock (dev); -if (dev->type && dev->type->need_parent_lock && parent) -device_unlock (parent); -} -/** * device_driver_attach - attach a specific driver to a specific device * @drv: Driver to attach