Changeset 0511549 in mainline

Timestamp:

2013-09-10T23:11:34Z (11 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

de3d15b4

Parents:

5df1963

Message:

Add devctl list-drv subcommand to list known drivers.

Location:

uspace

Files:

• app/devctl/devctl.c (modified) (2 diffs)
• lib/c/generic/devman.c (modified) (1 diff)
• lib/c/include/devman.h (modified) (1 diff)
• lib/c/include/ipc/devman.h (modified) (1 diff)
• srv/devman/client_conn.c (modified) (4 diffs)
• srv/devman/devman.h (modified) (2 diffs)
• srv/devman/driver.c (modified) (5 diffs)
• srv/devman/driver.h (modified) (2 diffs)
• srv/devman/drv_conn.c (modified) (1 diff)

uspace/app/devctl/devctl.c

@@ -159 +159 @@
 }
 
+static int drv_list(void)
+{
+        devman_handle_t *drvs;
+        size_t ndrvs;
+        size_t i;
+        int rc;
+
+        rc = devman_get_drivers(&drvs, &ndrvs);
+        if (rc != EOK)
+                return rc;
+
+        printf("Got %d handles\n", ndrvs);
+        for (i = 0; i < ndrvs; i++) {
+                rc = devman_driver_get_name(drvs[i], drv_name, MAX_NAME_LENGTH);
+                if (rc != EOK)
+                        continue;
+                printf("%3d %s\n", (int)drvs[i], drv_name);
+        }
+        free(drvs);
+
+        return EOK;
+}
+
 static void print_syntax(void)
 {
-        printf("syntax: devctl [(online|offline) <function>]\n");
+        printf("syntax:\n");
+        printf("\tdevctl\n");
+        printf("\tdevctl online <function>]\n");
+        printf("\tdevctl offline <function>]\n");
+        printf("\tdevctl list-drv\n");
 }
 
@@ -194 +221 @@
                         return 2;
                 }
+        } else if (str_cmp(argv[1], "list-drv") == 0) {
+                rc = drv_list();
+                if (rc != EOK)
+                        return 2;
         } else {
                 printf(NAME ": Invalid argument '%s'.\n", argv[1]);

uspace/lib/c/generic/devman.c

@@ -592 +592 @@
 }
 
+int devman_get_drivers(devman_handle_t **drvs,
+    size_t *count)
+{
+        return devman_get_handles_internal(DEVMAN_GET_DRIVERS, 0, drvs, count);
+}
+
+int devman_driver_get_name(devman_handle_t handle, char *buf, size_t buf_size)
+{
+        return devman_get_str_internal(DEVMAN_DRIVER_GET_NAME, handle, buf,
+            buf_size);
+}
+
 /** @}
  */

uspace/lib/c/include/devman.h

@@ -71 +71 @@
 extern int devman_add_device_to_category(devman_handle_t, const char *);
 extern int devman_fun_sid_to_handle(service_id_t, devman_handle_t *);
+extern int devman_get_drivers(devman_handle_t **, size_t *);
+extern int devman_driver_get_name(devman_handle_t, char *, size_t);
 
 #endif

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

@@ -161 +161 @@
         DEVMAN_FUN_OFFLINE,
         DEVMAN_FUN_GET_PATH,
-        DEVMAN_FUN_SID_TO_HANDLE
+        DEVMAN_FUN_SID_TO_HANDLE,
+        DEVMAN_GET_DRIVERS,
+        DEVMAN_DRIVER_GET_NAME
 } client_to_devman_t;
 

uspace/srv/devman/client_conn.c

@@ -317 +317 @@
 }
 
-
 /** Get handle for child device of a function. */
 static void devman_fun_get_child(ipc_callid_t iid, ipc_call_t *icall)
@@ -417 +416 @@
 }
 
+/** Get list of all registered drivers. */
+static void devman_get_drivers(ipc_callid_t iid, ipc_call_t *icall)
+{
+        ipc_callid_t callid;
+        size_t size;
+        size_t act_size;
+        int rc;
+        
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
+        if (hdl_buf == NULL) {
+                async_answer_0(callid, ENOMEM);
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+        
+        rc = driver_get_list(&drivers_list, hdl_buf, size, &act_size);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        sysarg_t retval = async_data_read_finalize(callid, hdl_buf, size);
+        free(hdl_buf);
+        
+        async_answer_1(iid, retval, act_size);
+}
+
+/** Get driver name. */
+static void devman_driver_get_name(ipc_callid_t iid, ipc_call_t *icall)
+{
+        devman_handle_t handle = IPC_GET_ARG1(*icall);
+
+        driver_t *drv = driver_find(&drivers_list, handle);
+        if (drv == NULL) {
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+
+        ipc_callid_t data_callid;
+        size_t data_len;
+        if (!async_data_read_receive(&data_callid, &data_len)) {
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+
+        void *buffer = malloc(data_len);
+        if (buffer == NULL) {
+                async_answer_0(data_callid, ENOMEM);
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+
+        fibril_mutex_lock(&drv->driver_mutex);
+
+        size_t sent_length = str_size(drv->name);
+        if (sent_length > data_len) {
+                sent_length = data_len;
+        }
+
+        async_data_read_finalize(data_callid, drv->name, sent_length);
+        async_answer_0(iid, EOK);
+
+        fibril_mutex_unlock(&drv->driver_mutex);
+
+        free(buffer);
+}
+
 /** Function for handling connections from a client to the device manager. */
 void devman_connection_client(ipc_callid_t iid, ipc_call_t *icall)
@@ -441 +514 @@
                         break;
                 case DEVMAN_FUN_GET_NAME:
+                        printf("devman_fun_get_name\n");
                         devman_fun_get_name(callid, &call);
                         break;
@@ -457 +531 @@
                 case DEVMAN_FUN_SID_TO_HANDLE:
                         devman_fun_sid_to_handle(callid, &call);
+                        break;
+                case DEVMAN_GET_DRIVERS:
+                        devman_get_drivers(callid, &call);
+                        break;
+                case DEVMAN_DRIVER_GET_NAME:
+                        printf("devman_get_driver_name\n");
+                        devman_driver_get_name(callid, &call);
                         break;
                 default:

uspace/srv/devman/devman.h

@@ -80 +80 @@
         /** Pointers to previous and next drivers in a linked list. */
         link_t drivers;
+        /** Handle */
+        devman_handle_t handle;
         
         /**
@@ -110 +112 @@
         /** Fibril mutex for list of drivers. */
         fibril_mutex_t drivers_mutex;
+        /** Next free handle */
+        devman_handle_t next_handle;
 } driver_list_t;
 

uspace/srv/devman/driver.c

@@ -58 +58 @@
         list_initialize(&drv_list->drivers);
         fibril_mutex_initialize(&drv_list->drivers_mutex);
+        drv_list->next_handle = 1;
 }
 
@@ -81 +82 @@
         fibril_mutex_lock(&drivers_list->drivers_mutex);
         list_prepend(&drv->drivers, &drivers_list->drivers);
+        drv->handle = drivers_list->next_handle++;
         fibril_mutex_unlock(&drivers_list->drivers_mutex);
 
@@ -299 +301 @@
 }
 
-/** Find device driver in the list of device drivers.
+/** Find device driver by handle.
+ *
+ * @param drv_list      The list of device drivers
+ * @param handle        Driver handle
+ * @return              The device driver, if it is in the list,
+ *                      NULL otherwise.
+ */
+driver_t *driver_find(driver_list_t *drv_list, devman_handle_t handle)
+{
+        driver_t *res = NULL;
+        
+        fibril_mutex_lock(&drv_list->drivers_mutex);
+        
+        list_foreach(drv_list->drivers, drivers, driver_t, drv) {
+                if (drv->handle == handle) {
+                        res = drv;
+                        break;
+                }
+        }
+        
+        fibril_mutex_unlock(&drv_list->drivers_mutex);
+        
+        return res;
+}
+
+
+/** Find device driver by name.
  *
  * @param drv_list      The list of device drivers.
@@ -306 +334 @@
  *                      list, NULL otherwise.
  */
-driver_t *find_driver(driver_list_t *drv_list, const char *drv_name)
+driver_t *driver_find_by_name(driver_list_t *drv_list, const char *drv_name)
 {
         driver_t *res = NULL;
@@ -669 +697 @@
 }
 
+/** Get list of registered drivers. */
+int driver_get_list(driver_list_t *driver_list, devman_handle_t *hdl_buf,
+    size_t buf_size, size_t *act_size)
+{
+        size_t act_cnt;
+        size_t buf_cnt;
+
+        fibril_mutex_lock(&driver_list->drivers_mutex);
+
+        buf_cnt = buf_size / sizeof(devman_handle_t);
+
+        act_cnt = list_count(&driver_list->drivers);
+        *act_size = act_cnt * sizeof(devman_handle_t);
+
+        if (buf_size % sizeof(devman_handle_t) != 0) {
+                fibril_mutex_unlock(&driver_list->drivers_mutex);
+                return EINVAL;
+        }
+
+        size_t pos = 0;
+        list_foreach(driver_list->drivers, drivers, driver_t, drv) {
+                if (pos < buf_cnt) {
+                        hdl_buf[pos] = drv->handle;
+                }
+
+                pos++;
+        }
+
+        fibril_mutex_unlock(&driver_list->drivers_mutex);
+        return EOK;
+}
+
 /** @}
  */

uspace/srv/devman/driver.h

@@ -56 +56 @@
 extern int driver_fun_offline(dev_tree_t *, fun_node_t *);
 
-extern driver_t *find_driver(driver_list_t *, const char *);
+extern driver_t *driver_find(driver_list_t *, devman_handle_t);
+extern driver_t *driver_find_by_name(driver_list_t *, const char *);
 extern void initialize_running_driver(driver_t *, dev_tree_t *);
 
@@ -62 +63 @@
 extern void clean_driver(driver_t *);
 extern void delete_driver(driver_t *);
+extern int driver_get_list(driver_list_t *, devman_handle_t *, size_t, size_t *);
 
 #endif

uspace/srv/devman/drv_conn.c

@@ -83 +83 @@
         
         /* Find driver structure. */
-        driver = find_driver(&drivers_list, drv_name);
+        driver = driver_find_by_name(&drivers_list, drv_name);
         if (driver == NULL) {
                 log_msg(LOG_DEFAULT, LVL_ERROR, "No driver named `%s' was found.", drv_name);