Changeset 9a487cc in mainline

Timestamp:

2012-06-18T09:55:40Z (13 years ago)

Author:

Frantisek Princ <frantisek.princ@…>

Branches:

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

Children:

06d85e5

Parents:

49c94a3 (diff), 75b9c3d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge with mainline

Location:

uspace

Files:

• app/devctl/devctl.c (modified) (2 diffs)
• app/loc/loc.c (modified) (2 diffs)
• lib/c/generic/async.c (modified) (1 diff)
• lib/c/generic/devman.c (modified) (2 diffs)
• lib/c/generic/loc.c (modified) (1 diff)
• lib/c/include/devman.h (modified) (1 diff)
• lib/c/include/ipc/devman.h (modified) (1 diff)
• lib/c/include/ipc/loc.h (modified) (1 diff)
• lib/c/include/loc.h (modified) (1 diff)
• srv/devman/main.c (modified) (2 diffs)
• srv/locsrv/locsrv.c (modified) (2 diffs)

uspace/app/devctl/devctl.c

@@ -44 +44 @@
 #define MAX_NAME_LENGTH 1024
 
+char name[MAX_NAME_LENGTH];
+char drv_name[MAX_NAME_LENGTH];
+
 static int fun_subtree_print(devman_handle_t funh, int lvl)
 {
-        char name[MAX_NAME_LENGTH];
         devman_handle_t devh;
         devman_handle_t *cfuns;
@@ -57 +59 @@
 
         rc = devman_fun_get_name(funh, name, MAX_NAME_LENGTH);
-        if (rc != EOK) {
-                str_cpy(name, MAX_NAME_LENGTH, "unknown");
-                return ENOMEM;
-        }
+        if (rc != EOK)
+                return ELIMIT;
 
         if (name[0] == '\0')
                 str_cpy(name, MAX_NAME_LENGTH, "/");
 
-        printf("%s (%" PRIun ")\n", name, funh);
+        rc = devman_fun_get_driver_name(funh, drv_name, MAX_NAME_LENGTH);
+        if (rc != EOK && rc != EINVAL)
+                return ELIMIT;
+
+        if (rc == EINVAL)
+                printf("%s\n", name);
+        else
+                printf("%s : %s\n", name, drv_name);
 
         rc = devman_fun_get_child(funh, &devh);

uspace/app/loc/loc.c

@@ -48 +48 @@
         size_t svc_cnt;
         char *svc_name;
+        char *server_name;
         int rc;
         size_t j;
 
-        printf("%s (%" PRIun "):\n", cat_name, cat_id);
+        printf("%s:\n", cat_name);
 
         rc = loc_category_get_svcs(cat_id, &svc_ids, &svc_cnt);
@@ -67 +68 @@
                         continue;
                 }
-                printf("\t%s (%" PRIun ")\n", svc_name, svc_ids[j]);
+
+                rc = loc_service_get_server_name(svc_ids[j], &server_name);
+                if (rc != EOK && rc != EINVAL) {
+                        free(svc_name);
+                        printf(NAME ": Unknown service name (SID %"
+                            PRIun ").\n", svc_ids[j]);
+                        continue;
+                }
+
+                if (rc == EOK)
+                        printf("\t%s : %s\n", svc_name, server_name);
+                else
+                        printf("\t%s\n", svc_name);
+        
                 free(svc_name);
+                free(server_name);
         }
 

uspace/lib/c/generic/async.c

@@ -1388 +1388 @@
 
         futex_down(&async_futex);
-        if (msg->done)
+        if (msg->done) {
                 amsg_destroy(msg);
-        else 
+        } else {
+                msg->dataptr = NULL;
                 msg->forget = true;
+        }
         futex_up(&async_futex);
 }

uspace/lib/c/generic/devman.c

@@ -430 +430 @@
         async_wait_for(req, &retval);
         
-        if (retval != EOK)
-                return retval;
+        if (retval != EOK) {
+                return retval;
+        }
         
         act_size = IPC_GET_ARG2(dreply);
@@ -449 +450 @@
 {
         return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, buf,
+            buf_size);
+}
+
+int devman_fun_get_driver_name(devman_handle_t handle, char *buf, size_t buf_size)
+{
+        return devman_get_str_internal(DEVMAN_FUN_GET_DRIVER_NAME, handle, buf,
             buf_size);
 }

uspace/lib/c/generic/loc.c

@@ -450 +450 @@
 }
 
+/** Get service server name.
+ *
+ * Provided ID of a service, return the name of its server.
+ *
+ * @param svc_id        Service ID
+ * @param name          Place to store pointer to new string. Caller should
+ *                      free it using free().
+ * @return              EOK on success or negative error code
+ */
+int loc_service_get_server_name(service_id_t svc_id, char **name)
+{
+        return loc_get_name_internal(LOC_SERVICE_GET_SERVER_NAME, svc_id, name);
+}
+
 int loc_namespace_get_id(const char *name, service_id_t *handle,
     unsigned int flags)

uspace/lib/c/include/devman.h

@@ -64 +64 @@
     size_t *);
 extern int devman_fun_get_name(devman_handle_t, char *, size_t);
+extern int devman_fun_get_driver_name(devman_handle_t, char *, size_t);
 extern int devman_fun_get_path(devman_handle_t, char *, size_t);
 extern int devman_fun_online(devman_handle_t);

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

@@ -157 +157 @@
         DEVMAN_FUN_GET_CHILD,
         DEVMAN_FUN_GET_NAME,
+        DEVMAN_FUN_GET_DRIVER_NAME,
         DEVMAN_FUN_ONLINE,
         DEVMAN_FUN_OFFLINE,

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

@@ -56 +56 @@
         LOC_SERVICE_GET_ID,
         LOC_SERVICE_GET_NAME,
+        LOC_SERVICE_GET_SERVER_NAME,
         LOC_NAMESPACE_GET_ID,
         LOC_CALLBACK_CREATE,

uspace/lib/c/include/loc.h

@@ -56 +56 @@
     unsigned int);
 extern int loc_service_get_name(service_id_t, char **);
+extern int loc_service_get_server_name(service_id_t, char **);
 extern int loc_namespace_get_id(const char *, service_id_t *,
     unsigned int);

uspace/srv/devman/main.c

@@ -855 +855 @@
 }
 
+/** Get function driver name. */
+static void devman_fun_get_driver_name(ipc_callid_t iid, ipc_call_t *icall)
+{
+        devman_handle_t handle = IPC_GET_ARG1(*icall);
+
+        fun_node_t *fun = find_fun_node(&device_tree, handle);
+        if (fun == 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);
+                fun_del_ref(fun);
+                return;
+        }
+
+        void *buffer = malloc(data_len);
+        if (buffer == NULL) {
+                async_answer_0(data_callid, ENOMEM);
+                async_answer_0(iid, ENOMEM);
+                fun_del_ref(fun);
+                return;
+        }
+
+        fibril_rwlock_read_lock(&device_tree.rwlock);
+
+        /* Check function state */
+        if (fun->state == FUN_REMOVED) {
+                fibril_rwlock_read_unlock(&device_tree.rwlock);
+                free(buffer);
+
+                async_answer_0(data_callid, ENOENT);
+                async_answer_0(iid, ENOENT);
+                fun_del_ref(fun);
+                return;
+        }
+
+        /* Check whether function has a driver */
+        if (fun->child == NULL || fun->child->drv == NULL) {
+                fibril_rwlock_read_unlock(&device_tree.rwlock);
+                free(buffer);
+
+                async_answer_0(data_callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                fun_del_ref(fun);
+                return;
+        }
+
+        size_t sent_length = str_size(fun->child->drv->name);
+        if (sent_length > data_len) {
+                sent_length = data_len;
+        }
+
+        async_data_read_finalize(data_callid, fun->child->drv->name,
+            sent_length);
+        async_answer_0(iid, EOK);
+
+        fibril_rwlock_read_unlock(&device_tree.rwlock);
+        fun_del_ref(fun);
+        free(buffer);
+}
 
 /** Get device path. */
@@ -1082 +1146 @@
                 case DEVMAN_FUN_GET_NAME:
                         devman_fun_get_name(callid, &call);
+                        break;
+                case DEVMAN_FUN_GET_DRIVER_NAME:
+                        devman_fun_get_driver_name(callid, &call);
                         break;
                 case DEVMAN_FUN_GET_PATH:

uspace/srv/locsrv/locsrv.c

@@ -656 +656 @@
 }
 
+static void loc_service_get_server_name(ipc_callid_t iid, ipc_call_t *icall)
+{
+        ipc_callid_t callid;
+        size_t size;
+        size_t act_size;
+        loc_service_t *svc;
+        
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        fibril_mutex_lock(&services_list_mutex);
+        
+        svc = loc_service_find_id(IPC_GET_ARG1(*icall));
+        if (svc == NULL) {
+                fibril_mutex_unlock(&services_list_mutex);
+                async_answer_0(callid, ENOENT);
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        if (svc->server == NULL) {
+                fibril_mutex_unlock(&services_list_mutex);
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        act_size = str_size(svc->server->name);
+        if (act_size > size) {
+                fibril_mutex_unlock(&services_list_mutex);
+                async_answer_0(callid, EOVERFLOW);
+                async_answer_0(iid, EOVERFLOW);
+                return;
+        }
+        
+        sysarg_t retval = async_data_read_finalize(callid, svc->server->name,
+            min(size, act_size));
+        
+        fibril_mutex_unlock(&services_list_mutex);
+        
+        async_answer_0(iid, retval);
+}
+
 /** Connect client to the service.
  *
@@ -1404 +1450 @@
                 case LOC_SERVICE_GET_NAME:
                         loc_service_get_name(callid, &call);
+                        break;
+                case LOC_SERVICE_GET_SERVER_NAME:
+                        loc_service_get_server_name(callid, &call);
                         break;
                 case LOC_NAMESPACE_GET_ID: