Re: [PATCH v3] driver core: take parent lock in async device attach

[sashiko-bot@kernel.org]

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] driver-core: UAF on dev->parent in async device attach
--

commit c5f34060c20ab88f32e94e3a0ebf364f523925ee
Author: Mario Peter <mario.peter@leica-geosystems.com>

    driver core: take parent lock in async device attach
    
    On buses with need_parent_lock set (only USB), 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.

> diff --git a/drivers/base/dd.c b/drivers/base/dd.c
> index f6525a7ee8c54..9dc7cce9bd8d2 100644
> --- a/drivers/base/dd.c
> +++ b/drivers/base/dd.c
[ ... ]
> @@ -1029,6 +1029,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 bus 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 (parent && dev->bus->need_parent_lock)
> +		device_lock(parent);

[Severity: High]
Could this acquire a mutex within freed parent memory?

If this is called with a dangling parent pointer from
__device_attach_async_helper(), this will dereference the freed memory.

[ ... ]
> @@ -1038,7 +1070,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);

[Severity: High]
Can this cause a use-after-free on dev->parent?

In the device removal path, device_del() sets dev->p->dead to true via
kill_device() and later drops the child's reference to dev->parent via
put_device(dev->parent).

If the parent device is also being removed and its final reference is dropped,
the parent could be freed. 

If this async worker runs delayed, taking the lock before checking
dev->p->dead could pass a dangling dev->parent pointer. Prior to this patch,
device_lock(dev) was called, and dev->parent was never accessed if
dev->p->dead was true.

>  
>  	/*
>  	 * Check if device has already been removed or claimed. This may
> @@ -1060,7 +1092,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);

[Severity: High]
If dev->parent was freed before the dev->p->dead check above, wouldn't this
unlock path also dereference the same dangling pointer?

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261013140408.1226841-1-johan@kernel.org?part=1