Changeset 8300c72 in mainline for uspace/lib

Timestamp:

2025-03-03T22:58:05Z (7 months ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

master

Children:

77a0119

Parents:

f35749e

Message:

Quiesce devices before proceeding with shutdown.

Only implemented for e1k, uhci and xhci.

Location:

uspace/lib

Files:

• device/include/devman.h (modified) (2 diffs)
• device/include/ipc/devman.h (modified) (3 diffs)
• device/src/devman.c (modified) (3 diffs)
• drv/generic/driver.c (modified) (3 diffs)
• drv/include/ddf/driver.h (modified) (3 diffs)
• usbhost/include/usb/host/hcd.h (modified) (2 diffs)
• usbhost/src/hcd.c (modified) (4 diffs)

uspace/lib/device/include/devman.h

@@ -52 +52 @@
 extern errno_t devman_drv_fun_online(devman_handle_t);
 extern errno_t devman_drv_fun_offline(devman_handle_t);
+extern errno_t devman_drv_fun_quiesce(devman_handle_t);
 extern errno_t devman_drv_fun_wait_stable(devman_handle_t);
 
@@ -71 +72 @@
 extern errno_t devman_fun_online(devman_handle_t);
 extern errno_t devman_fun_offline(devman_handle_t);
+extern errno_t devman_fun_quiesce(devman_handle_t);
 
 extern errno_t devman_add_device_to_category(devman_handle_t, const char *);
 extern errno_t devman_fun_sid_to_handle(service_id_t, devman_handle_t *);
+extern errno_t devman_quiesce_devices(const char *);
 extern errno_t devman_get_drivers(devman_handle_t **, size_t *);
 extern errno_t devman_driver_get_devices(devman_handle_t, devman_handle_t **,

uspace/lib/device/include/ipc/devman.h

@@ -148 +148 @@
         DEVMAN_DRV_FUN_ONLINE,
         DEVMAN_DRV_FUN_OFFLINE,
+        DEVMAN_DRV_FUN_QUIESCE,
         DEVMAN_DRV_FUN_WAIT_STABLE,
         DEVMAN_REMOVE_FUNCTION
@@ -156 +157 @@
         DRIVER_DEV_REMOVE,
         DRIVER_DEV_GONE,
+        DRIVER_DEV_QUIESCE,
         DRIVER_FUN_ONLINE,
         DRIVER_FUN_OFFLINE,
@@ -171 +173 @@
         DEVMAN_FUN_ONLINE,
         DEVMAN_FUN_OFFLINE,
+        DEVMAN_FUN_QUIESCE,
         DEVMAN_FUN_GET_PATH,
         DEVMAN_FUN_SID_TO_HANDLE,

uspace/lib/device/src/devman.c

@@ -343 +343 @@
 }
 
+errno_t devman_drv_fun_quiesce(devman_handle_t funh)
+{
+        async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
+        if (exch == NULL)
+                return ENOMEM;
+
+        errno_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_QUIESCE, funh);
+
+        devman_exchange_end(exch);
+        return retval;
+}
+
 errno_t devman_drv_fun_wait_stable(devman_handle_t funh)
 {
@@ -506 +518 @@
 }
 
+errno_t devman_fun_quiesce(devman_handle_t funh)
+{
+        async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
+        if (exch == NULL)
+                return ENOMEM;
+
+        errno_t retval = async_req_1_0(exch, DEVMAN_FUN_QUIESCE, funh);
+
+        devman_exchange_end(exch);
+        return retval;
+}
+
 static errno_t devman_get_handles_once(sysarg_t method, sysarg_t arg1,
     devman_handle_t *handle_buf, size_t buf_size, size_t *act_size)
@@ -632 +656 @@
 }
 
+errno_t devman_quiesce_devices(const char *path)
+{
+        devman_handle_t funh;
+        errno_t rc;
+
+        funh = 0;
+        rc = devman_fun_get_handle(path, &funh, 0);
+        if (rc != EOK)
+                return rc;
+
+        return devman_fun_quiesce(funh);
+}
+
 errno_t devman_get_drivers(devman_handle_t **drvs,
     size_t *count)

uspace/lib/drv/generic/driver.c

@@ -237 +237 @@
 }
 
+static void driver_dev_quiesce(ipc_call_t *icall)
+{
+        devman_handle_t devh = ipc_get_arg1(icall);
+        ddf_fun_t *fun;
+        link_t *link;
+
+        fibril_mutex_lock(&devices_mutex);
+        ddf_dev_t *dev = driver_get_device(devh);
+        if (dev != NULL)
+                dev_add_ref(dev);
+        fibril_mutex_unlock(&devices_mutex);
+
+        if (dev == NULL) {
+                async_answer_0(icall, ENOENT);
+                return;
+        }
+
+        errno_t rc;
+
+        if (driver->driver_ops->dev_quiesce != NULL) {
+                rc = driver->driver_ops->dev_quiesce(dev);
+        } else {
+                /*
+                 * If the driver does not implement quiesce, we will
+                 * simply request all subordinate functions to quiesce.
+                 */
+                fibril_mutex_lock(&functions_mutex);
+                link = list_first(&functions);
+                while (link != NULL) {
+                        fun = list_get_instance(link, ddf_fun_t, link);
+                        if (fun->dev == dev)
+                                ddf_fun_quiesce(fun);
+                        link = list_next(link, &functions);
+                }
+                fibril_mutex_unlock(&functions_mutex);
+                rc = EOK;
+        }
+
+        dev_del_ref(dev);
+        async_answer_0(icall, rc);
+}
+
 static void driver_fun_online(ipc_call_t *icall)
 {
@@ -357 +399 @@
                 case DRIVER_DEV_GONE:
                         driver_dev_gone(&call);
+                        break;
+                case DRIVER_DEV_QUIESCE:
+                        driver_dev_quiesce(&call);
                         break;
                 case DRIVER_FUN_ONLINE:
@@ -903 +948 @@
 }
 
+/** Quiesce function.
+ *
+ * @param fun Function to quiesce
+ *
+ * @return EOK on success or an error code
+ *
+ */
+errno_t ddf_fun_quiesce(ddf_fun_t *fun)
+{
+        assert(fun->bound == true);
+
+        errno_t res = devman_drv_fun_quiesce(fun->handle);
+        if (res != EOK)
+                return res;
+
+        return EOK;
+}
+
 /** Add single match ID to inner function.
  *

uspace/lib/drv/include/ddf/driver.h

@@ -86 +86 @@
 /** Generic device driver operations */
 typedef struct driver_ops {
-        /** Callback method for passing a new device to the device driver */
+        /** Ask driver to add a new device */
         errno_t (*dev_add)(ddf_dev_t *);
 
@@ -94 +94 @@
         /** Inform driver a device disappeared */
         errno_t (*dev_gone)(ddf_dev_t *);
+
+        /** Ask driver to quiesce device (disable interrupts and DMA) */
+        errno_t (*dev_quiesce)(ddf_dev_t *);
 
         /** Ask driver to online a specific function */
@@ -129 +132 @@
 extern errno_t ddf_fun_online(ddf_fun_t *);
 extern errno_t ddf_fun_offline(ddf_fun_t *);
+extern errno_t ddf_fun_quiesce(ddf_fun_t *);
 extern errno_t ddf_fun_add_match_id(ddf_fun_t *, const char *, int);
 extern void ddf_fun_set_ops(ddf_fun_t *, const ddf_dev_ops_t *);

uspace/lib/usbhost/include/usb/host/hcd.h

@@ -1 +1 @@
 /*
+ * Copyright (c) 2025 Jiri Svoboda
  * Copyright (c) 2011 Jan Vesely
  * Copyright (c) 2018 Ondrej Hlavaty
@@ -101 +102 @@
         /** HC is gone. */
         int (*hc_gone)(hc_device_t *);
+
+        /** Quiesce HC. */
+        int (*hc_quiesce)(hc_device_t *);
 } hc_driver_t;
 

uspace/lib/usbhost/src/hcd.c

@@ -1 +1 @@
 /*
+ * Copyright (c) 2025 Jiri Svoboda
  * Copyright (c) 2011 Jan Vesely
  * Copyright (c) 2018 Ondrej Hlavaty
@@ -58 +59 @@
 int hc_dev_remove(ddf_dev_t *);
 int hc_dev_gone(ddf_dev_t *);
+int hc_dev_quiesce(ddf_dev_t *);
 int hc_fun_online(ddf_fun_t *);
 int hc_fun_offline(ddf_fun_t *);
@@ -65 +67 @@
         .dev_remove = hc_dev_remove,
         .dev_gone = hc_dev_gone,
+        .dev_quiesce = hc_dev_quiesce,
         .fun_online = hc_fun_online,
         .fun_offline = hc_fun_offline,
@@ -358 +361 @@
 }
 
+errno_t hc_dev_quiesce(ddf_dev_t *dev)
+{
+        errno_t err = ENOTSUP;
+        hc_device_t *hcd = dev_to_hcd(dev);
+
+        if (hc_driver->hc_quiesce)
+                err = hc_driver->hc_quiesce(hcd);
+
+        return err;
+}
+
 errno_t hc_fun_online(ddf_fun_t *fun)
 {