Changeset 81685dd9 in mainline

Timestamp:

2017-10-20T07:18:57Z (7 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

feab36ae

Parents:

04efacc

Message:

Add devctl unload-drv subcommand to manually unload a driver that is not in use.

Location:

uspace

Files:

• app/devctl/devctl.c (modified) (3 diffs)
• lib/c/generic/devman.c (modified) (1 diff)
• lib/c/include/devman.h (modified) (1 diff)
• lib/c/include/ipc/devman.h (modified) (2 diffs)
• lib/drv/generic/driver.c (modified) (6 diffs)
• srv/devman/client_conn.c (modified) (2 diffs)
• srv/devman/driver.c (modified) (1 diff)
• srv/devman/driver.h (modified) (1 diff)

uspace/app/devctl/devctl.c

@@ -337 +337 @@
 }
 
+static int drv_unload(const char *drvname)
+{
+        int rc;
+        devman_handle_t drvh;
+
+        rc = devman_driver_get_handle(drvname, &drvh);
+        if (rc != EOK) {
+                printf("Failed resolving driver '%s' (%d).\n", drvname, rc);
+                return rc;
+        }
+
+        rc = devman_driver_unload(drvh);
+        if (rc != EOK) {
+                printf("Failed unloading driver '%s' (%d).\n", drvname, rc);
+                return rc;
+        }
+
+        return EOK;
+}
+
 static void print_syntax(void)
 {
@@ -346 +366 @@
         printf("\tdevctl show-drv <driver-name>\n");
         printf("\tdevctl load-drv <driver-name>\n");
+        printf("\tdevctl unload-drv <driver-name>\n");
 }
 
@@ -412 +433 @@
                 if (rc != EOK)
                         return 2;
+        } else if (str_cmp(argv[1], "unload-drv") == 0) {
+                if (argc < 3) {
+                        printf(NAME ": Argument missing.\n");
+                        print_syntax();
+                        return 1;
+                }
+
+                rc = drv_unload(argv[2]);
+                if (rc != EOK)
+                        return 2;
         } else {
                 printf(NAME ": Invalid argument '%s'.\n", argv[1]);

uspace/lib/c/generic/devman.c

@@ -719 +719 @@
 }
 
+int devman_driver_unload(devman_handle_t drvh)
+{
+        async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
+        if (exch == NULL)
+                return ENOMEM;
+        
+        int rc = async_req_1_0(exch, DEVMAN_DRIVER_UNLOAD, drvh);
+        
+        devman_exchange_end(exch);
+        return rc;
+}
+
 /** @}
  */

uspace/lib/c/include/devman.h

@@ -82 +82 @@
 extern int devman_driver_get_state(devman_handle_t, driver_state_t *);
 extern int devman_driver_load(devman_handle_t);
+extern int devman_driver_unload(devman_handle_t);
 
 #endif

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

@@ -156 +156 @@
         DRIVER_FUN_ONLINE,
         DRIVER_FUN_OFFLINE,
+        DRIVER_STOP
 } devman_to_driver_t;
 
@@ -176 +177 @@
         DEVMAN_DRIVER_GET_NAME,
         DEVMAN_DRIVER_GET_STATE,
-        DEVMAN_DRIVER_LOAD
+        DEVMAN_DRIVER_LOAD,
+        DEVMAN_DRIVER_UNLOAD
 } client_to_devman_t;
 

uspace/lib/drv/generic/driver.c

@@ -68 +68 @@
 FIBRIL_MUTEX_INITIALIZE(functions_mutex);
 
+FIBRIL_RWLOCK_INITIALIZE(stopping_lock);
+static bool stopping = false;
+
 static ddf_dev_t *create_device(void);
 static void delete_device(ddf_dev_t *);
@@ -127 +130 @@
         }
         
+        fibril_rwlock_read_lock(&stopping_lock);
+
+        if (stopping) {
+                fibril_rwlock_read_unlock(&stopping_lock);
+                async_answer_0(iid, EIO);
+                return;
+        }
+        
         ddf_dev_t *dev = create_device();
         if (!dev) {
+                fibril_rwlock_read_unlock(&stopping_lock);
                 free(dev_name);
                 async_answer_0(iid, ENOMEM);
@@ -148 +160 @@
         
         if (res != EOK) {
+                fibril_rwlock_read_unlock(&stopping_lock);
                 dev_del_ref(dev);
                 async_answer_0(iid, res);
@@ -156 +169 @@
         list_append(&dev->link, &devices);
         fibril_mutex_unlock(&devices_mutex);
+        fibril_rwlock_read_unlock(&stopping_lock);
         
         async_answer_0(iid, res);
@@ -282 +296 @@
         
         async_answer_0(iid, (sysarg_t) rc);
+}
+
+static void driver_stop(ipc_callid_t iid, ipc_call_t *icall)
+{
+        /* Prevent new devices from being added */
+        fibril_rwlock_write_lock(&stopping_lock);
+        stopping = true;
+
+        /* Check if there are any devices */
+        fibril_mutex_lock(&devices_mutex);
+        if (list_first(&devices) != NULL) {
+                /* Devices exist, roll back */
+                fibril_mutex_unlock(&devices_mutex);
+                stopping = false;
+                fibril_rwlock_write_unlock(&stopping_lock);
+                async_answer_0(iid, EBUSY);
+                return;
+        }
+
+        fibril_rwlock_write_unlock(&stopping_lock);
+
+        /* There should be no functions at this point */
+        fibril_mutex_lock(&functions_mutex);
+        assert(list_first(&functions) == NULL);
+        fibril_mutex_unlock(&functions_mutex);
+
+        /* Reply with success and terminate */
+        async_answer_0(iid, EOK);
+        exit(0);
 }
 
@@ -312 +355 @@
                 case DRIVER_FUN_OFFLINE:
                         driver_fun_offline(callid, &call);
+                        break;
+                case DRIVER_STOP:
+                        driver_stop(callid, &call);
                         break;
                 default:

uspace/srv/devman/client_conn.c

@@ -726 +726 @@
 }
 
+/** Unload a driver by user request. */
+static void devman_driver_unload(ipc_callid_t iid, ipc_call_t *icall)
+{
+        driver_t *drv;
+        int rc;
+        
+        drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
+        if (drv == NULL) {
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        fibril_mutex_lock(&drv->driver_mutex);
+        rc = stop_driver(drv);
+        fibril_mutex_unlock(&drv->driver_mutex);
+
+        async_answer_0(iid, rc);
+}
+
 /** Function for handling connections from a client to the device manager. */
 void devman_connection_client(ipc_callid_t iid, ipc_call_t *icall, void *arg)
@@ -794 +813 @@
                         devman_driver_load(callid, &call);
                         break;
+                case DEVMAN_DRIVER_UNLOAD:
+                        devman_driver_unload(callid, &call);
+                        break;
                 default:
                         async_answer_0(callid, ENOENT);

uspace/srv/devman/driver.c

@@ -298 +298 @@
         drv->state = DRIVER_STARTING;
         return true;
+}
+
+/** Stop a driver
+ *
+ * @param drv           The driver's structure.
+ * @return              True if the driver's task is successfully spawned, false
+ *                      otherwise.
+ */
+int stop_driver(driver_t *drv)
+{
+        async_exch_t *exch;
+        sysarg_t retval;
+        
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "stop_driver(drv=\"%s\")", drv->name);
+
+        exch = async_exchange_begin(drv->sess);
+        retval = async_req_0_0(exch, DRIVER_STOP);
+        loc_exchange_end(exch);
+        
+        if (retval != EOK)
+                return retval;
+        
+        drv->state = DRIVER_NOT_STARTED;
+        async_hangup(drv->sess);
+        drv->sess = NULL;
+        return EOK;
 }
 

uspace/srv/devman/driver.h

@@ -50 +50 @@
 extern void detach_driver(dev_tree_t *, dev_node_t *);
 extern bool start_driver(driver_t *);
+extern int stop_driver(driver_t *);
 extern void add_device(driver_t *, dev_node_t *, dev_tree_t *);
 extern int driver_dev_remove(dev_tree_t *, dev_node_t *);