Changeset d7427a7e in mainline for uspace/srv

Timestamp:

2011-08-18T20:27:02Z (14 years ago)

Author:

Petr Koupy <petr.koupy@…>

Branches:

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

Children:

be79a663

Parents:

0cc32f2 (diff), ef7052ec (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 mainline changes.

Location:

uspace/srv

Files:

• devman/devman.c (modified) (1 diff)
• devman/devman.h (modified) (3 diffs)
• devman/main.c (modified) (3 diffs)
• loc/category.c (modified) (4 diffs)
• loc/category.h (modified) (3 diffs)
• loc/loc.c (modified) (8 diffs)
• loc/loc.h (modified) (2 diffs)

uspace/srv/devman/devman.c

@@ -1100 +1100 @@
 }
 
+/** Remove function from device tree.
+ *
+ * @param tree          Device tree
+ * @param node          Function node to remove
+ */
+void remove_fun_node(dev_tree_t *tree, fun_node_t *fun)
+{
+        assert(tree != NULL);
+        assert(fun != NULL);
+        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
+        
+        /* Remove the node from the handle-to-node map. */
+        unsigned long key = fun->handle;
+        hash_table_remove(&tree->devman_functions, &key, 1);
+        
+        /* Remove the node from the list of its parent's children. */
+        if (fun->dev != NULL)
+                list_remove(&fun->dev_functions);
+}
+
 /** Find function node with a specified path in the device tree.
  * 

uspace/srv/devman/devman.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -154 +155 @@
         /** Name of the function, assigned by the device driver */
         char *name;
+        /** Function type */
+        fun_type_t ftype;
         
         /** Full path and name of the device in device hierarchy */
@@ -265 +268 @@
 extern bool insert_dev_node(dev_tree_t *, dev_node_t *, fun_node_t *);
 extern bool insert_fun_node(dev_tree_t *, fun_node_t *, char *, dev_node_t *);
+extern void remove_fun_node(dev_tree_t *, fun_node_t *);
 
 /* Loc services */

uspace/srv/devman/main.c

@@ -278 +278 @@
                 return;
         }
-
+        
         fun_node_t *fun = create_fun_node();
+        fun->ftype = ftype;
+        
         if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) {
                 fibril_rwlock_write_unlock(&tree->rwlock);
@@ -367 +369 @@
 }
 
+/** Remove function. */
+static void devman_remove_function(ipc_callid_t callid, ipc_call_t *call)
+{
+        devman_handle_t fun_handle = IPC_GET_ARG1(*call);
+        dev_tree_t *tree = &device_tree;
+        int rc;
+        
+        fibril_rwlock_write_lock(&tree->rwlock);
+        
+        fun_node_t *fun = find_fun_node_no_lock(&device_tree, fun_handle);
+        if (fun == NULL) {
+                fibril_rwlock_write_unlock(&tree->rwlock);
+                async_answer_0(callid, ENOENT);
+                return;
+        }
+        
+        log_msg(LVL_DEBUG, "devman_remove_function(fun='%s')", fun->pathname);
+        
+        if (fun->ftype == fun_inner) {
+                /* Handle possible descendants */
+                /* TODO */
+                log_msg(LVL_WARN, "devman_remove_function(): not handling "
+                    "descendants\n");
+        } else {
+                /* Unregister from location service */
+                rc = loc_service_unregister(fun->service_id);
+                if (rc != EOK) {
+                        log_msg(LVL_ERROR, "Failed unregistering tree service.");
+                        fibril_rwlock_write_unlock(&tree->rwlock);
+                        async_answer_0(callid, EIO);
+                        return;
+                }
+        }
+        
+        remove_fun_node(&device_tree, fun);
+        fibril_rwlock_write_unlock(&tree->rwlock);
+        delete_fun_node(fun);
+        
+        log_msg(LVL_DEBUG, "devman_remove_function() succeeded.");
+        async_answer_0(callid, EOK);
+}
+
 /** Initialize driver which has registered itself as running and ready.
  *
@@ -418 +462 @@
                 case DEVMAN_ADD_DEVICE_TO_CATEGORY:
                         devman_add_function_to_cat(callid, &call);
+                        break;
+                case DEVMAN_REMOVE_FUNCTION:
+                        devman_remove_function(callid, &call);
                         break;
                 default:

uspace/srv/loc/category.c

@@ -93 +93 @@
         cat->id = loc_create_id();
         link_initialize(&cat->cat_list);
-        list_initialize(&cat->services);
+        list_initialize(&cat->svc_memb);
 }
 
@@ -113 +113 @@
 {
         assert(fibril_mutex_is_locked(&cat->mutex));
+        assert(fibril_mutex_is_locked(&services_list_mutex));
 
         /* Verify that category does not contain this service yet. */
-        list_foreach(cat->services, item) {
-
-                loc_service_t *csvc = list_get_instance(item, loc_service_t,
-                    cat_services);
-                if (csvc == svc) {
+        list_foreach(cat->svc_memb, item) {
+                svc_categ_t *memb = list_get_instance(item, svc_categ_t,
+                    cat_link);
+                if (memb->svc == svc) {
                         return EEXIST;
                 }
         }
 
-        list_append(&svc->cat_services, &cat->services);
+        svc_categ_t *nmemb = malloc(sizeof(svc_categ_t));
+        if (nmemb == NULL)
+                return ENOMEM;
+
+        nmemb->svc = svc;
+        nmemb->cat = cat;
+
+        list_append(&nmemb->cat_link, &cat->svc_memb);
+        list_append(&nmemb->svc_link, &svc->cat_memb);
+
         return EOK;
+}
+
+/** Remove service from category. */
+void category_remove_service(svc_categ_t *memb)
+{
+        assert(fibril_mutex_is_locked(&memb->cat->mutex));
+        assert(fibril_mutex_is_locked(&services_list_mutex));
+
+        list_remove(&memb->cat_link);
+        list_remove(&memb->svc_link);
+
+        free(memb);
 }
 
@@ -169 +190 @@
         buf_cnt = buf_size / sizeof(service_id_t);
 
-        act_cnt = list_count(&cat->services);
+        act_cnt = list_count(&cat->svc_memb);
         *act_size = act_cnt * sizeof(service_id_t);
 
@@ -176 +197 @@
 
         size_t pos = 0;
-        list_foreach(cat->services, item) {
-                loc_service_t *svc =
-                    list_get_instance(item, loc_service_t, cat_services);
+        list_foreach(cat->svc_memb, item) {
+                svc_categ_t *memb =
+                    list_get_instance(item, svc_categ_t, cat_link);
 
                 if (pos < buf_cnt)
-                        id_buf[pos] = svc->id;
+                        id_buf[pos] = memb->svc->id;
                 pos++;
         }

uspace/srv/loc/category.h

@@ -55 +55 @@
         link_t cat_list;
 
-        /** List of services in this category (loc_service_t) */
-        list_t services;
+        /** List of service memberships in this category (svc_categ_t) */
+        list_t svc_memb;
 } category_t;
 
@@ -67 +67 @@
 } categ_dir_t;
 
+/** Service in category membership. */
+typedef struct {
+        /** Link to category_t.svc_memb list */
+        link_t cat_link;
+        /** Link to loc_service_t.cat_memb list */
+        link_t svc_link;
+        
+        /** Category */
+        category_t *cat;
+        /** Service */
+        loc_service_t *svc;
+} svc_categ_t;
+
 extern void categ_dir_init(categ_dir_t *);
 extern void categ_dir_add_cat(categ_dir_t *, category_t *);
@@ -73 +86 @@
 extern category_t *category_new(const char *);
 extern int category_add_service(category_t *, loc_service_t *);
+extern void category_remove_service(svc_categ_t *);
 extern category_t *category_get(categ_dir_t *, catid_t);
 extern category_t *category_find_by_name(categ_dir_t *, const char *);

uspace/srv/loc/loc.c

@@ -67 +67 @@
  **/
 
-static FIBRIL_MUTEX_INITIALIZE(services_list_mutex);
+FIBRIL_MUTEX_INITIALIZE(services_list_mutex);
 static FIBRIL_CONDVAR_INITIALIZE(services_list_cv);
 static FIBRIL_MUTEX_INITIALIZE(servers_list_mutex);
@@ -311 +311 @@
 {
         assert(fibril_mutex_is_locked(&services_list_mutex));
-
+        assert(fibril_mutex_is_locked(&cdir.mutex));
+        
         loc_namespace_delref(service->namespace);
         list_remove(&(service->services));
         list_remove(&(service->server_services));
+        
+        /* Remove service from all categories. */
+        while (!list_empty(&service->cat_memb)) {
+                link_t *link = list_first(&service->cat_memb);
+                svc_categ_t *memb = list_get_instance(link, svc_categ_t,
+                    svc_link);
+                fibril_mutex_lock(&memb->cat->mutex);
+                category_remove_service(memb);
+                fibril_mutex_unlock(&memb->cat->mutex);
+        }
         
         free(service->name);
@@ -415 +426 @@
         fibril_mutex_lock(&services_list_mutex);
         fibril_mutex_lock(&server->services_mutex);
+        fibril_mutex_lock(&cdir.mutex);
         
         while (!list_empty(&server->services)) {
@@ -423 +435 @@
         }
         
+        fibril_mutex_unlock(&cdir.mutex);
         fibril_mutex_unlock(&server->services_mutex);
         fibril_mutex_unlock(&services_list_mutex);
@@ -492 +505 @@
         link_initialize(&service->services);
         link_initialize(&service->server_services);
+        list_initialize(&service->cat_memb);
         
         /* Check that service is not already registered */
@@ -529 +543 @@
  *
  */
-static int loc_service_unregister(ipc_callid_t iid, ipc_call_t *icall, 
+static void loc_service_unregister(ipc_callid_t iid, ipc_call_t *icall, 
     loc_server_t *server)
 {
-        /* TODO */
-        return EOK;
+        loc_service_t *svc;
+        
+        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(iid, ENOENT);
+                return;
+        }
+        
+        fibril_mutex_lock(&cdir.mutex);
+        loc_service_unregister_core(svc);
+        fibril_mutex_unlock(&cdir.mutex);
+        fibril_mutex_unlock(&services_list_mutex);
+        async_answer_0(iid, EOK);
 }
 
@@ -1176 +1203 @@
         
         fibril_mutex_lock(&services_list_mutex);
+        fibril_mutex_lock(&cdir.mutex);
         loc_service_unregister_core(null_services[i]);
+        fibril_mutex_unlock(&cdir.mutex);
         fibril_mutex_unlock(&services_list_mutex);
         
@@ -1242 +1271 @@
 
         cat = category_new("usbhc");
+        categ_dir_add_cat(&cdir, cat);
+
+        cat = category_new("virtual");
         categ_dir_add_cat(&cdir, cat);
 

uspace/srv/loc/loc.h

@@ -89 +89 @@
         /** Link to list of services in category (category_t.services) */
         link_t cat_services;
+        /** List of category memberships (svc_categ_t) */
+        list_t cat_memb;
         /** Unique service identifier */
         service_id_t id;
@@ -101 +103 @@
 } loc_service_t;
 
+extern fibril_mutex_t services_list_mutex;
+
 extern service_id_t loc_create_id(void);
 extern void loc_category_change_event(void);