When vmbus_device_register() fails, it drops the device it was setting
up, and the device's release, vmbus_device_release(), calls
hv_process_channel_removal() on the channel. That function is for
channels the host has rescinded and starts with
BUG_ON(!channel->rescind), so the kernel stops there. Without the
BUG_ON, it would unmap and release the relid, unlink the channel and
free it, and then the error path of vmbus_add_channel_work() would do
all of that again.

When device_register() fails, clear the device's channel pointer before
dropping the device, and only remove the channel in
vmbus_device_release() if there is one: vmbus_add_channel_work() cleans
it up. A concurrent driver_attach() can still match the device while it
is being removed, so make vmbus_match() skip a device without a channel.

The later failures, creating the channels directory or the primary
channel's kobject, come after device_register() may have bound a driver,
and a driver can hold on to the channel past its remove callback unless
the channel was rescinded (hv_sock's connection, or the sub-channels it
opened). So do not unregister the device for them: its channel is then
just missing from sysfs, as it is while the device is being set up. A
sub-channel of such a device is refused, as when its own kobject cannot
be added.

Fixes: c2e5df616e1a ("vmbus: add per-channel sysfs info")
Cc: [email protected]
Signed-off-by: Yuqiang Sun <[email protected]>
---

Notes:
    The bug was found with kbound, a research static analysis prototype.
    The patch, the changelog and the test setup were written with the help
    of an AI coding assistant (Claude); I have reviewed them and tested them
    as described in the cover letter.
    
    Changes in v2: vmbus_match() skips a device without a channel, and the
    failures after device_register() keep the device instead of
    unregistering it (Sashiko review of v1).

 drivers/hv/vmbus_drv.c | 46 ++++++++++++++++++++++--------------------
 1 file changed, 24 insertions(+), 22 deletions(-)

diff --git a/drivers/hv/vmbus_drv.c b/drivers/hv/vmbus_drv.c
index fc0f16f51266..1b9bc82bebd0 100644
--- a/drivers/hv/vmbus_drv.c
+++ b/drivers/hv/vmbus_drv.c
@@ -840,9 +840,14 @@ static int vmbus_match(struct device *device, const struct 
device_driver *driver
 {
        const struct hv_driver *drv = drv_to_hv_drv(driver);
        struct hv_device *hv_dev = device_to_hv_device(device);
+       struct vmbus_channel *channel = READ_ONCE(hv_dev->channel);
+
+       /* None if vmbus_device_register() failed */
+       if (!channel)
+               return 0;
 
        /* The hv_sock driver handles all hv_sock offers. */
-       if (is_hvsock_channel(hv_dev->channel))
+       if (is_hvsock_channel(channel))
                return drv->hvsock;
 
        if (hv_vmbus_get_id(drv, hv_dev))
@@ -979,9 +984,15 @@ static void vmbus_device_release(struct device *device)
 
        hv_debug_rm_dev_dir(hv_dev);
 
-       mutex_lock(&vmbus_connection.channel_mutex);
-       hv_process_channel_removal(channel);
-       mutex_unlock(&vmbus_connection.channel_mutex);
+       /*
+        * No channel if vmbus_device_register() failed: the channel was not
+        * rescinded, and vmbus_add_channel_work() cleans it up.
+        */
+       if (channel) {
+               mutex_lock(&vmbus_connection.channel_mutex);
+               hv_process_channel_removal(channel);
+               mutex_unlock(&vmbus_connection.channel_mutex);
+       }
        kfree(hv_dev);
 }
 
@@ -2103,6 +2114,10 @@ int vmbus_add_channel_kobj(struct hv_device *dev, struct 
vmbus_channel *channel)
        u32 relid = channel->offermsg.child_relid;
        int ret;
 
+       /* The device has no channels directory if creating it failed */
+       if (!dev->channels_kset)
+               return -ENOENT;
+
        /*
         * On failure the kobject keeps its reference: the callers' error
         * paths drop it in free_channel(), which also frees the channel.
@@ -2189,6 +2204,7 @@ int vmbus_device_register(struct hv_device 
*child_device_obj)
        ret = device_register(&child_device_obj->device);
        if (ret) {
                pr_err("Unable to register child device\n");
+               WRITE_ONCE(child_device_obj->channel, NULL);
                put_device(&child_device_obj->device);
                return ret;
        }
@@ -2205,31 +2221,17 @@ int vmbus_device_register(struct hv_device 
*child_device_obj)
         * here. The race can't result in a kernel failure, but the user space
         * program may get an error in accessing "channels" or its
         * subdirectories. See also comments with vmbus_add_dynid() about a
-        * related race condition.
+        * related race condition. For the same reason, the device stays
+        * registered if its channel cannot be shown in sysfs.
         */
        child_device_obj->channels_kset = kset_create_and_add("channels",
                                                              NULL, kobj);
-       if (!child_device_obj->channels_kset) {
-               ret = -ENOMEM;
-               goto err_dev_unregister;
-       }
-
-       ret = vmbus_add_channel_kobj(child_device_obj,
-                                    child_device_obj->channel);
-       if (ret) {
+       if (!child_device_obj->channels_kset ||
+           vmbus_add_channel_kobj(child_device_obj, child_device_obj->channel))
                pr_err("Unable to register primary channel\n");
-               goto err_kset_unregister;
-       }
        hv_debug_add_dev_dir(child_device_obj);
 
        return 0;
-
-err_kset_unregister:
-       kset_unregister(child_device_obj->channels_kset);
-
-err_dev_unregister:
-       device_unregister(&child_device_obj->device);
-       return ret;
 }
 
 /*
-- 
2.53.0


Reply via email to