Changeset 07b39338 in mainline for uspace/srv

Timestamp:

2011-08-20T18:21:49Z (15 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

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

Children:

6ab014d

Parents:

0cf27ee (diff), f00af83 (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 libposix.

Location:

uspace/srv

Files:

• devman/devman.c (modified) (15 diffs)
• devman/devman.h (modified) (10 diffs)
• devman/main.c (modified) (13 diffs)
• hid/input/generic/input.c (modified) (4 diffs)
• hid/input/port/adb_mouse.c (modified) (1 diff)
• hw/irc/apic/apic.c (modified) (1 diff)
• loader/main.c (modified) (4 diffs)
• loc/category.c (modified) (4 diffs)
• loc/category.h (modified) (3 diffs)
• loc/loc.c (modified) (13 diffs)
• loc/loc.h (modified) (3 diffs)
• vfs/vfs.c (modified) (6 diffs)
• vfs/vfs.h (modified) (6 diffs)
• vfs/vfs_file.c (modified) (14 diffs)
• vfs/vfs_lookup.c (modified) (1 diff)
• vfs/vfs_node.c (modified) (1 diff)
• vfs/vfs_ops.c (modified) (2 diffs)

uspace/srv/devman/devman.c

@@ -73 +73 @@
 }
 
-static int loc_devices_class_compare(unsigned long key[], hash_count_t keys,
-    link_t *item)
-{
-        dev_class_info_t *class_info
-            = hash_table_get_instance(item, dev_class_info_t, loc_link);
-        assert(class_info != NULL);
-
-        return (class_info->service_id == (service_id_t) key[0]);
-}
-
 static void devices_remove_callback(link_t *item)
 {
@@ -102 +92 @@
         .hash = devices_hash,
         .compare = loc_functions_compare,
-        .remove_callback = devices_remove_callback
-};
-
-static hash_table_operations_t loc_devices_class_ops = {
-        .hash = devices_hash,
-        .compare = loc_devices_class_compare,
         .remove_callback = devices_remove_callback
 };
@@ -564 +548 @@
 
         fibril_mutex_lock(&driver->driver_mutex);
-        
-        async_exch_t *exch = async_exchange_begin(driver->sess);
-        async_sess_t *sess = async_connect_me_to(EXCHANGE_SERIALIZE, exch,
-            DRIVER_DEVMAN, 0, 0);
-        async_exchange_end(exch);
-
-        if (!sess) {
-                fibril_mutex_unlock(&driver->driver_mutex);
-                return;
-        }
 
         /*
@@ -599 +573 @@
                 fibril_mutex_unlock(&driver->driver_mutex);
 
-                add_device(sess, driver, dev, tree);
+                add_device(driver, dev, tree);
 
                 /*
@@ -619 +593 @@
                 link = driver->devices.head.next;
         }
-
-        async_hangup(sess);
 
         /*
@@ -734 +706 @@
  * @param node          The device's node in the device tree.
  */
-void add_device(async_sess_t *sess, driver_t *drv, dev_node_t *dev,
-    dev_tree_t *tree)
+void add_device(driver_t *drv, dev_node_t *dev, dev_tree_t *tree)
 {
         /*
@@ -752 +723 @@
         }
         
-        async_exch_t *exch = async_exchange_begin(sess);
+        async_exch_t *exch = async_exchange_begin(drv->sess);
         
         ipc_call_t answer;
@@ -822 +793 @@
         fibril_mutex_unlock(&drv->driver_mutex);
 
-        if (is_running) {
-                /* Notify the driver about the new device. */
-                async_exch_t *exch = async_exchange_begin(drv->sess);
-                async_sess_t *sess = async_connect_me_to(EXCHANGE_SERIALIZE, exch,
-                    DRIVER_DEVMAN, 0, 0);
-                async_exchange_end(exch);
-                
-                if (sess) {
-                        add_device(sess, drv, dev, tree);
-                        async_hangup(sess);
-                }
-        }
+        /* Notify the driver about the new device. */
+        if (is_running)
+                add_device(drv, dev, tree);
         
         return true;
@@ -936 +898 @@
 }
 
+/** Get list of device functions. */
+int dev_get_functions(dev_tree_t *tree, dev_node_t *dev,
+    devman_handle_t *hdl_buf, size_t buf_size, size_t *act_size)
+{
+        size_t act_cnt;
+        size_t buf_cnt;
+
+        assert(fibril_rwlock_is_locked(&tree->rwlock));
+
+        buf_cnt = buf_size / sizeof(devman_handle_t);
+
+        act_cnt = list_count(&dev->functions);
+        *act_size = act_cnt * sizeof(devman_handle_t);
+
+        if (buf_size % sizeof(devman_handle_t) != 0)
+                return EINVAL;
+
+        size_t pos = 0;
+        list_foreach(dev->functions, item) {
+                fun_node_t *fun =
+                    list_get_instance(item, fun_node_t, dev_functions);
+
+                if (pos < buf_cnt)
+                        hdl_buf[pos] = fun->handle;
+                pos++;
+        }
+
+        return EOK;
+}
+
+
 /* Function nodes */
 
@@ -950 +943 @@
                 link_initialize(&res->dev_functions);
                 list_initialize(&res->match_ids.ids);
-                list_initialize(&res->classes);
                 link_initialize(&res->devman_fun);
                 link_initialize(&res->loc_fun);
@@ -1115 +1107 @@
         
         return true;
+}
+
+/** 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);
 }
 
@@ -1142 +1154 @@
         char *rel_path = path;
         char *next_path_elem = NULL;
-        bool cont = true;
+        bool cont = (rel_path[1] != '\0');
         
         while (cont && fun != NULL) {
@@ -1193 +1205 @@
 }
 
-/** Find function node by its class name and index. */
-fun_node_t *find_fun_node_by_class(class_list_t *class_list,
-    const char *class_name, const char *dev_name)
-{
-        assert(class_list != NULL);
-        assert(class_name != NULL);
-        assert(dev_name != NULL);
-
-        fibril_rwlock_read_lock(&class_list->rwlock);
-
-        dev_class_t *cl = find_dev_class_no_lock(class_list, class_name);
-        if (cl == NULL) {
-                fibril_rwlock_read_unlock(&class_list->rwlock);
-                return NULL;
-        }
-
-        dev_class_info_t *dev = find_dev_in_class(cl, dev_name);
-        if (dev == NULL) {
-                fibril_rwlock_read_unlock(&class_list->rwlock);
-                return NULL;
-        }
-
-        fun_node_t *fun = dev->fun;
-
-        fibril_rwlock_read_unlock(&class_list->rwlock);
-
-        return fun;
-}
-
-
 /** Find child function node with a specified name.
  *
@@ -1235 +1217 @@
         return find_fun_node_in_device(pfun->child, name);
 }
-
-/* Device classes */
-
-/** Create device class.
- *
- * @return      Device class.
- */
-dev_class_t *create_dev_class(void)
-{
-        dev_class_t *cl;
-        
-        cl = (dev_class_t *) malloc(sizeof(dev_class_t));
-        if (cl != NULL) {
-                memset(cl, 0, sizeof(dev_class_t));
-                list_initialize(&cl->devices);
-                fibril_mutex_initialize(&cl->mutex);
-        }
-        
-        return cl;
-}
-
-/** Create device class info.
- *
- * @return              Device class info.
- */
-dev_class_info_t *create_dev_class_info(void)
-{
-        dev_class_info_t *info;
-        
-        info = (dev_class_info_t *) malloc(sizeof(dev_class_info_t));
-        if (info != NULL) {
-                memset(info, 0, sizeof(dev_class_info_t));
-                link_initialize(&info->dev_classes);
-                link_initialize(&info->loc_link);
-                link_initialize(&info->link);
-        }
-        
-        return info;
-}
-
-size_t get_new_class_dev_idx(dev_class_t *cl)
-{
-        size_t dev_idx;
-        
-        fibril_mutex_lock(&cl->mutex);
-        dev_idx = ++cl->curr_dev_idx;
-        fibril_mutex_unlock(&cl->mutex);
-        
-        return dev_idx;
-}
-
-
-/** Create unique device name within the class.
- *
- * @param cl            The class.
- * @param base_dev_name Contains the base name for the device if it was
- *                      specified by the driver when it registered the device by
- *                      the class; NULL if driver specified no base name.
- * @return              The unique name for the device within the class.
- */
-char *create_dev_name_for_class(dev_class_t *cl, const char *base_dev_name)
-{
-        char *dev_name;
-        const char *base_name;
-        
-        if (base_dev_name != NULL)
-                base_name = base_dev_name;
-        else
-                base_name = cl->base_dev_name;
-        
-        size_t idx = get_new_class_dev_idx(cl);
-        asprintf(&dev_name, "%s%zu", base_name, idx);
-        
-        return dev_name;
-}
-
-/** Add the device function to the class.
- *
- * The device may be added to multiple classes and a class may contain multiple
- * devices. The class and the device are associated with each other by the
- * dev_class_info_t structure.
- *
- * @param dev           The device.
- * @param class         The class.
- * @param base_dev_name The base name of the device within the class if
- *                      specified by the driver, NULL otherwise.
- * @return              dev_class_info_t structure which associates the device
- *                      with the class.
- */
-dev_class_info_t *add_function_to_class(fun_node_t *fun, dev_class_t *cl,
-    const char *base_dev_name)
-{
-        dev_class_info_t *info;
-
-        assert(fun != NULL);
-        assert(cl != NULL);
-
-        info = create_dev_class_info();
-
-        
-        if (info != NULL) {
-                info->dev_class = cl;
-                info->fun = fun;
-                
-                /* Add the device to the class. */
-                fibril_mutex_lock(&cl->mutex);
-                list_append(&info->link, &cl->devices);
-                fibril_mutex_unlock(&cl->mutex);
-                
-                /* Add the class to the device. */
-                list_append(&info->dev_classes, &fun->classes);
-                
-                /* Create unique name for the device within the class. */
-                info->dev_name = create_dev_name_for_class(cl, base_dev_name);
-        }
-        
-        return info;
-}
-
-dev_class_t *get_dev_class(class_list_t *class_list, char *class_name)
-{
-        dev_class_t *cl;
-        
-        fibril_rwlock_write_lock(&class_list->rwlock);
-        cl = find_dev_class_no_lock(class_list, class_name);
-        if (cl == NULL) {
-                cl = create_dev_class();
-                if (cl != NULL) {
-                        cl->name = class_name;
-                        cl->base_dev_name = "";
-                        add_dev_class_no_lock(class_list, cl);
-                }
-        }
-
-        fibril_rwlock_write_unlock(&class_list->rwlock);
-        return cl;
-}
-
-dev_class_t *find_dev_class_no_lock(class_list_t *class_list,
-    const char *class_name)
-{
-        dev_class_t *cl;
-        
-        list_foreach(class_list->classes, link) {
-                cl = list_get_instance(link, dev_class_t, link);
-                if (str_cmp(cl->name, class_name) == 0) {
-                        return cl;
-                }
-        }
-        
-        return NULL;
-}
-
-void add_dev_class_no_lock(class_list_t *class_list, dev_class_t *cl)
-{
-        list_append(&cl->link, &class_list->classes);
-}
-
-dev_class_info_t *find_dev_in_class(dev_class_t *dev_class, const char *dev_name)
-{
-        assert(dev_class != NULL);
-        assert(dev_name != NULL);
-
-        list_foreach(dev_class->devices, link) {
-                dev_class_info_t *dev = list_get_instance(link,
-                    dev_class_info_t, link);
-
-                if (str_cmp(dev->dev_name, dev_name) == 0) {
-                        return dev;
-                }
-        }
-
-        return NULL;
-}
-
-void init_class_list(class_list_t *class_list)
-{
-        list_initialize(&class_list->classes);
-        fibril_rwlock_initialize(&class_list->rwlock);
-        hash_table_create(&class_list->loc_functions, DEVICE_BUCKETS, 1,
-            &loc_devices_class_ops);
-}
-
 
 /* loc devices */
@@ -1436 +1235 @@
 }
 
-fun_node_t *find_loc_class_function(class_list_t *classes,
-    service_id_t service_id)
-{
-        fun_node_t *fun = NULL;
-        dev_class_info_t *cli;
-        link_t *link;
-        unsigned long key = (unsigned long)service_id;
-        
-        fibril_rwlock_read_lock(&classes->rwlock);
-        link = hash_table_find(&classes->loc_functions, &key);
-        if (link != NULL) {
-                cli = hash_table_get_instance(link, dev_class_info_t,
-                    loc_link);
-                fun = cli->fun;
-        }
-        fibril_rwlock_read_unlock(&classes->rwlock);
-        
-        return fun;
-}
-
-void class_add_loc_function(class_list_t *class_list, dev_class_info_t *cli)
-{
-        unsigned long key = (unsigned long) cli->service_id;
-        
-        fibril_rwlock_write_lock(&class_list->rwlock);
-        hash_table_insert(&class_list->loc_functions, &key, &cli->loc_link);
-        fibril_rwlock_write_unlock(&class_list->rwlock);
-
-        assert(find_loc_class_function(class_list, cli->service_id) != NULL);
-}
-
 void tree_add_loc_function(dev_tree_t *tree, fun_node_t *fun)
 {

uspace/srv/devman/devman.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -53 +54 @@
 #define DEVICE_BUCKETS 256
 
-#define LOC_CLASS_NAMESPACE "class"
 #define LOC_DEVICE_NAMESPACE "devices"
 #define LOC_SEPARATOR '\\'
@@ -155 +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 */
@@ -170 +172 @@
         match_id_list_t match_ids;
         
-        /** List of device classes to which this device function belongs. */
-        list_t classes;
         /** Service ID if the device function is registered with loc. */
         service_id_t service_id;
@@ -214 +214 @@
 } dev_tree_t;
 
-typedef struct dev_class {
-        /** The name of the class. */
-        const char *name;
-        
-        /**
-         * Pointer to the previous and next class in the list of registered
-         * classes.
-         */
-        link_t link;
-        
-        /**
-         * List of dev_class_info structures - one for each device registered by
-         * this class.
-         */
-        list_t devices;
-        
-        /**
-         * Default base name for the device within the class, might be overrided
-         * by the driver.
-         */
-        const char *base_dev_name;
-        
-        /** Unique numerical identifier of the newly added device. */
-        size_t curr_dev_idx;
-        /** Synchronize access to the list of devices in this class. */
-        fibril_mutex_t mutex;
-} dev_class_t;
-
-/**
- * Provides n-to-m mapping between function nodes and classes - each function
- * can register in an arbitrary number of classes and each class can contain
- * an arbitrary number of device functions.
- */
-typedef struct dev_class_info {
-        /** The class. */
-        dev_class_t *dev_class;
-        /** The device. */
-        fun_node_t *fun;
-        
-        /**
-         * Pointer to the previous and next class info in the list of devices
-         * registered by the class.
-         */
-        link_t link;
-        
-        /**
-         * Pointer to the previous and next class info in the list of classes
-         * by which the device is registered.
-         */
-        link_t dev_classes;
-        
-        /** The name of the device function within the class. */
-        char *dev_name;
-        /** Service ID in the class namespace. */
-        service_id_t service_id;
-        
-        /**
-         * Link to hash table of services registered with location service using
-         * their class names.
-         */
-        link_t loc_link;
-} dev_class_info_t;
-
-/** The list of device classes. */
-typedef struct class_list {
-        /** List of classes. */
-        list_t classes;
-        
-        /**
-         * Hash table of services registered with location service using their
-         * class name, indexed by service IDs.
-         */
-        hash_table_t loc_functions;
-        
-        /** Fibril mutex for list of classes. */
-        fibril_rwlock_t rwlock;
-} class_list_t;
-
 /* Match ids and scores */
 
@@ -313 +235 @@
 extern void add_driver(driver_list_t *, driver_t *);
 extern void attach_driver(dev_node_t *, driver_t *);
-extern void add_device(async_sess_t *, driver_t *, dev_node_t *, dev_tree_t *);
+extern void add_device(driver_t *, dev_node_t *, dev_tree_t *);
 extern bool start_driver(driver_t *);
 
@@ -331 +253 @@
 extern dev_node_t *find_dev_node(dev_tree_t *tree, devman_handle_t handle);
 extern dev_node_t *find_dev_function(dev_node_t *, const char *);
+extern int dev_get_functions(dev_tree_t *tree, dev_node_t *, devman_handle_t *,
+    size_t, size_t *);
 
 extern fun_node_t *create_fun_node(void);
@@ -339 +263 @@
 extern fun_node_t *find_fun_node_by_path(dev_tree_t *, char *);
 extern fun_node_t *find_fun_node_in_device(dev_node_t *, const char *);
-extern fun_node_t *find_fun_node_by_class(class_list_t *, const char *, const char *);
 
 /* Device tree */
@@ -347 +270 @@
 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 *);
-
-/* Device classes */
-
-extern dev_class_t *create_dev_class(void);
-extern dev_class_info_t *create_dev_class_info(void);
-extern size_t get_new_class_dev_idx(dev_class_t *);
-extern char *create_dev_name_for_class(dev_class_t *, const char *);
-extern dev_class_info_t *add_function_to_class(fun_node_t *, dev_class_t *,
-    const char *);
-
-extern void init_class_list(class_list_t *);
-
-extern dev_class_t *get_dev_class(class_list_t *, char *);
-extern dev_class_t *find_dev_class_no_lock(class_list_t *, const char *);
-extern dev_class_info_t *find_dev_in_class(dev_class_t *, const char *);
-extern void add_dev_class_no_lock(class_list_t *, dev_class_t *);
+extern void remove_fun_node(dev_tree_t *, fun_node_t *);
 
 /* Loc services */
@@ -369 +277 @@
 
 extern fun_node_t *find_loc_tree_function(dev_tree_t *, service_id_t);
-extern fun_node_t *find_loc_class_function(class_list_t *, service_id_t);
-
-extern void class_add_loc_function(class_list_t *, dev_class_info_t *);
+
 extern void tree_add_loc_function(dev_tree_t *, fun_node_t *);
 

uspace/srv/devman/main.c

@@ -64 +64 @@
 static driver_list_t drivers_list;
 static dev_tree_t device_tree;
-static class_list_t class_list;
 
 /** Register running driver. */
@@ -279 +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);
@@ -333 +334 @@
 }
 
-static void loc_register_class_dev(dev_class_info_t *cli)
-{
-        /* Create loc path and name for the service. */
-        char *loc_pathname = NULL;
-
-        asprintf(&loc_pathname, "%s/%s%c%s", LOC_CLASS_NAMESPACE,
-            cli->dev_class->name, LOC_SEPARATOR, cli->dev_name);
-        if (loc_pathname == NULL)
-                return;
-        
-        /*
-         * Register the device with location service and remember its
-         * service ID.
-         */
-        loc_service_register_with_iface(loc_pathname,
-            &cli->service_id, DEVMAN_CONNECT_FROM_LOC);
-        
-        /*
-         * Add device to the hash map of class devices registered with
-         * location service.
-         */
-        class_add_loc_function(&class_list, cli);
-        
-        free(loc_pathname);
-}
-
-static void devman_add_function_to_class(ipc_callid_t callid, ipc_call_t *call)
+static void devman_add_function_to_cat(ipc_callid_t callid, ipc_call_t *call)
 {
         devman_handle_t handle = IPC_GET_ARG1(*call);
@@ -365 +340 @@
         int rc;
         
-        /* Get class name. */
-        char *class_name;
-        rc = async_data_write_accept((void **) &class_name, true,
+        /* Get category name. */
+        char *cat_name;
+        rc = async_data_write_accept((void **) &cat_name, true,
             0, 0, 0, 0);
         if (rc != EOK) {
@@ -380 +355 @@
         }
         
-        dev_class_t *cl = get_dev_class(&class_list, class_name);
-        dev_class_info_t *class_info = add_function_to_class(fun, cl, NULL);
-        
-        /* Register the device's class alias with location service. */
-        loc_register_class_dev(class_info);
-        
-        rc = loc_category_get_id(class_name, &cat_id, IPC_FLAG_BLOCKING);
+        rc = loc_category_get_id(cat_name, &cat_id, IPC_FLAG_BLOCKING);
         if (rc == EOK) {
                 loc_service_add_to_cat(fun->service_id, cat_id);
         } else {
                 log_msg(LVL_ERROR, "Failed adding function `%s' to category "
-                    "`%s'.", fun->pathname, class_name);
-        }
-        
-        log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.",
-            fun->pathname, class_name, class_info->dev_name);
-
+                    "`%s'.", fun->pathname, cat_name);
+        }
+        
+        log_msg(LVL_NOTE, "Function `%s' added to category `%s'.",
+            fun->pathname, cat_name);
+
+        async_answer_0(callid, EOK);
+}
+
+/** 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);
 }
@@ -449 +460 @@
                         devman_add_function(callid, &call);
                         break;
-                case DEVMAN_ADD_DEVICE_TO_CLASS:
-                        devman_add_function_to_class(callid, &call);
+                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:
@@ -483 +497 @@
 }
 
-/** Find handle for the device instance identified by device class name. */
-static void devman_function_get_handle_by_class(ipc_callid_t iid,
-    ipc_call_t *icall)
-{
-        char *classname;
-        char *devname;
-
-        int rc = async_data_write_accept((void **) &classname, true, 0, 0, 0, 0);
-        if (rc != EOK) {
-                async_answer_0(iid, rc);
-                return;
-        }
-        rc = async_data_write_accept((void **) &devname, true, 0, 0, 0, 0);
-        if (rc != EOK) {
-                free(classname);
-                async_answer_0(iid, rc);
-                return;
-        }
-
-
-        fun_node_t *fun = find_fun_node_by_class(&class_list,
-            classname, devname);
-
-        free(classname);
-        free(devname);
-
-        if (fun == NULL) {
-                async_answer_0(iid, ENOENT);
-                return;
-        }
-
-        async_answer_1(iid, EOK, fun->handle);
-}
-
-/** Find device path by its handle. */
-static void devman_get_device_path_by_handle(ipc_callid_t iid,
-    ipc_call_t *icall)
+/** Get device name. */
+static void devman_fun_get_name(ipc_callid_t iid, ipc_call_t *icall)
 {
         devman_handle_t handle = IPC_GET_ARG1(*icall);
@@ -543 +522 @@
         }
 
+        size_t sent_length = str_size(fun->name);
+        if (sent_length > data_len) {
+                sent_length = data_len;
+        }
+
+        async_data_read_finalize(data_callid, fun->name, sent_length);
+        async_answer_0(iid, EOK);
+
+        free(buffer);
+}
+
+
+/** Get device path. */
+static void devman_fun_get_path(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);
+                return;
+        }
+
+        void *buffer = malloc(data_len);
+        if (buffer == NULL) {
+                async_answer_0(data_callid, ENOMEM);
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+
         size_t sent_length = str_size(fun->pathname);
         if (sent_length > data_len) {
@@ -554 +570 @@
 }
 
+static void devman_dev_get_functions(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;
+        }
+        
+        fibril_rwlock_read_lock(&device_tree.rwlock);
+        
+        dev_node_t *dev = find_dev_node_no_lock(&device_tree,
+            IPC_GET_ARG1(*icall));
+        if (dev == NULL) {
+                fibril_rwlock_read_unlock(&device_tree.rwlock);
+                async_answer_0(callid, ENOENT);
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
+        if (hdl_buf == NULL) {
+                fibril_rwlock_read_unlock(&device_tree.rwlock);
+                async_answer_0(callid, ENOMEM);
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+        
+        rc = dev_get_functions(&device_tree, dev, hdl_buf, size, &act_size);
+        if (rc != EOK) {
+                fibril_rwlock_read_unlock(&device_tree.rwlock);
+                async_answer_0(callid, rc);
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        fibril_rwlock_read_unlock(&device_tree.rwlock);
+        
+        sysarg_t retval = async_data_read_finalize(callid, hdl_buf, size);
+        free(hdl_buf);
+        
+        async_answer_1(iid, retval, act_size);
+}
+
+
+/** Get handle for child device of a function. */
+static void devman_fun_get_child(ipc_callid_t iid, ipc_call_t *icall)
+{
+        fun_node_t *fun;
+        
+        fibril_rwlock_read_lock(&device_tree.rwlock);
+        
+        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
+        if (fun == NULL) {
+                fibril_rwlock_read_unlock(&device_tree.rwlock);
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        if (fun->child == NULL) {
+                fibril_rwlock_read_unlock(&device_tree.rwlock);
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        async_answer_1(iid, EOK, fun->child->handle);
+        
+        fibril_rwlock_read_unlock(&device_tree.rwlock);
+}
+
+/** Find handle for the function instance identified by its service ID. */
+static void devman_fun_sid_to_handle(ipc_callid_t iid, ipc_call_t *icall)
+{
+        fun_node_t *fun;
+
+        fun = find_loc_tree_function(&device_tree, IPC_GET_ARG1(*icall));
+        
+        if (fun == NULL) {
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+
+        async_answer_1(iid, EOK, fun->handle);
+}
 
 /** Function for handling connections from a client to the device manager. */
@@ -572 +676 @@
                         devman_function_get_handle(callid, &call);
                         break;
-                case DEVMAN_DEVICE_GET_HANDLE_BY_CLASS:
-                        devman_function_get_handle_by_class(callid, &call);
-                        break;
-                case DEVMAN_DEVICE_GET_DEVICE_PATH:
-                        devman_get_device_path_by_handle(callid, &call);
+                case DEVMAN_DEV_GET_FUNCTIONS:
+                        devman_dev_get_functions(callid, &call);
+                        break;
+                case DEVMAN_FUN_GET_CHILD:
+                        devman_fun_get_child(callid, &call);
+                        break;
+                case DEVMAN_FUN_GET_NAME:
+                        devman_fun_get_name(callid, &call);
+                        break;
+                case DEVMAN_FUN_GET_PATH:
+                        devman_fun_get_path(callid, &call);
+                        break;
+                case DEVMAN_FUN_SID_TO_HANDLE:
+                        devman_fun_sid_to_handle(callid, &call);
                         break;
                 default:
@@ -678 +791 @@
 
         fun = find_loc_tree_function(&device_tree, service_id);
-        if (fun == NULL)
-                fun = find_loc_class_function(&class_list, service_id);
         
         if (fun == NULL || fun->dev->drv == NULL) {
+                log_msg(LVL_WARN, "devman_connection_loc(): function "
+                    "not found.\n");
                 async_answer_0(iid, ENOENT);
                 return;
@@ -687 +800 @@
         
         dev = fun->dev;
-        
-        if ((dev->state != DEVICE_USABLE) || (!dev->drv->sess)) {
-                async_answer_0(iid, EINVAL);
-                return;
-        }
         
         async_exch_t *exch = async_exchange_begin(dev->drv->sess);
@@ -753 +861 @@
         }
 
-        init_class_list(&class_list);
-        
         /*
          * !!! devman_connection ... as the device manager is not a real loc

uspace/srv/hid/input/generic/input.c

@@ -66 +66 @@
 #include <abi/ipc/methods.h>
 
-/* In microseconds */
-#define DISCOVERY_POLL_INTERVAL  (10 * 1000 * 1000)
-
 #define NUM_LAYOUTS  3
 
@@ -497 +494 @@
 }
 
-/** Periodically check for new input devices.
- *
- * Looks under /loc/class/keyboard and /loc/class/mouse.
- *
- * @param arg Ignored
- *
- */
-static int dev_discovery_fibril(void *arg)
-{
-        category_id_t keyboard_cat, mouse_cat;
+static int dev_check_new_kbdevs(void)
+{
+        category_id_t keyboard_cat;
         service_id_t *svcs;
         size_t count, i;
@@ -518 +508 @@
         }
         
+        /*
+         * Check for new keyboard devices
+         */
+        rc = loc_category_get_svcs(keyboard_cat, &svcs, &count);
+        if (rc != EOK) {
+                printf("%s: Failed getting list of keyboard devices.\n",
+                    NAME);
+                return EIO;
+        }
+
+        for (i = 0; i < count; i++) {
+                already_known = false;
+                
+                /* Determine whether we already know this device. */
+                list_foreach(kbd_devs, kdev_link) {
+                        kbd_dev_t *kdev = list_get_instance(kdev_link,
+                            kbd_dev_t, kbd_devs);
+                        if (kdev->svc_id == svcs[i]) {
+                                already_known = true;
+                                break;
+                        }
+                }
+                
+                if (!already_known) {
+                        kbd_dev_t *kdev;
+                        if (kbd_add_kbdev(svcs[i], &kdev) == EOK) {
+                                printf("%s: Connected keyboard device '%s'\n",
+                                    NAME, kdev->svc_name);
+                        }
+                }
+        }
+        
+        free(svcs);
+        
+        /* XXX Handle device removal */
+        
+        return EOK;
+}
+
+static int dev_check_new_mousedevs(void)
+{
+        category_id_t mouse_cat;
+        service_id_t *svcs;
+        size_t count, i;
+        bool already_known;
+        int rc;
+        
         rc = loc_category_get_id("mouse", &mouse_cat, IPC_FLAG_BLOCKING);
         if (rc != EOK) {
@@ -524 +561 @@
         }
         
-        while (true) {
-                async_usleep(DISCOVERY_POLL_INTERVAL);
-                
-                /*
-                 * Check for new keyboard devices
-                 */
-                rc = loc_category_get_svcs(keyboard_cat, &svcs, &count);
-                if (rc != EOK) {
-                        printf("%s: Failed getting list of keyboard devices.\n",
-                            NAME);
-                        continue;
-                }
-
-                for (i = 0; i < count; i++) {
-                        already_known = false;
-                        
-                        /* Determine whether we already know this device. */
-                        list_foreach(kbd_devs, kdev_link) {
-                                kbd_dev_t *kdev = list_get_instance(kdev_link,
-                                    kbd_dev_t, kbd_devs);
-                                if (kdev->svc_id == svcs[i]) {
-                                        already_known = true;
-                                        break;
-                                }
-                        }
-
-                        if (!already_known) {
-                                kbd_dev_t *kdev;
-                                if (kbd_add_kbdev(svcs[i], &kdev) == EOK) {
-                                        printf("%s: Connected keyboard device '%s'\n",
-                                            NAME, kdev->svc_name);
-                                }
+        /*
+         * Check for new mouse devices
+         */
+        rc = loc_category_get_svcs(mouse_cat, &svcs, &count);
+        if (rc != EOK) {
+                printf("%s: Failed getting list of mouse devices.\n",
+                    NAME);
+                return EIO;
+        }
+        
+        for (i = 0; i < count; i++) {
+                already_known = false;
+                
+                /* Determine whether we already know this device. */
+                list_foreach(mouse_devs, mdev_link) {
+                        mouse_dev_t *mdev = list_get_instance(mdev_link,
+                            mouse_dev_t, mouse_devs);
+                        if (mdev->svc_id == svcs[i]) {
+                                already_known = true;
+                                break;
                         }
                 }
                 
-                /* XXX Handle device removal */
-                
-                /*
-                 * Check for new mouse devices
-                 */
-                rc = loc_category_get_svcs(mouse_cat, &svcs, &count);
-                if (rc != EOK) {
-                        printf("%s: Failed getting list of mouse devices.\n",
-                            NAME);
-                        continue;
-                }
-
-                for (i = 0; i < count; i++) {
-                        already_known = false;
-                        
-                        /* Determine whether we already know this device. */
-                        list_foreach(mouse_devs, mdev_link) {
-                                mouse_dev_t *mdev = list_get_instance(mdev_link,
-                                    mouse_dev_t, mouse_devs);
-                                if (mdev->svc_id == svcs[i]) {
-                                        already_known = true;
-                                        break;
-                                }
-                        }
-
-                        if (!already_known) {
-                                mouse_dev_t *mdev;
-                                if (mouse_add_mousedev(svcs[i], &mdev) == EOK) {
-                                        printf("%s: Connected mouse device '%s'\n",
-                                            NAME, mdev->svc_name);
-                                }
+                if (!already_known) {
+                        mouse_dev_t *mdev;
+                        if (mouse_add_mousedev(svcs[i], &mdev) == EOK) {
+                                printf("%s: Connected mouse device '%s'\n",
+                                    NAME, mdev->svc_name);
                         }
                 }
-                
-                /* XXX Handle device removal */
-        }
+        }
+        
+        free(svcs);
+        
+        /* XXX Handle device removal */
         
         return EOK;
 }
 
-/** Start a fibril for discovering new devices. */
-static void input_start_dev_discovery(void)
-{
-        fid_t fid = fibril_create(dev_discovery_fibril, NULL);
-        if (!fid) {
-                printf("%s: Failed to create device discovery fibril.\n",
-                    NAME);
-                return;
-        }
-        
-        fibril_add_ready(fid);
+static int dev_check_new(void)
+{
+        int rc;
+        
+        rc = dev_check_new_kbdevs();
+        if (rc != EOK)
+                return rc;
+        
+        rc = dev_check_new_mousedevs();
+        if (rc != EOK)
+                return rc;
+
+        return EOK;
+}
+
+static void cat_change_cb(void)
+{
+        dev_check_new();
+}
+
+/** Start listening for new devices. */
+static int input_start_dev_discovery(void)
+{
+        int rc;
+
+        rc = loc_register_cat_change_cb(cat_change_cb);
+        if (rc != EOK) {
+                printf("%s: Failed registering callback for device discovery. "
+                    "(%d)\n", NAME, rc);
+                return rc;
+        }
+
+        return dev_check_new();
 }
 

uspace/srv/hid/input/port/adb_mouse.c

@@ -42 +42 @@
 #include <errno.h>
 #include <loc.h>
+#include <stdio.h>
 
 static mouse_dev_t *mouse_dev;

uspace/srv/hw/irc/apic/apic.c

@@ -45 +45 @@
 #include <errno.h>
 #include <async.h>
+#include <stdio.h>
 
 #define NAME  "apic"

uspace/srv/loader/main.c

@@ -61 +61 @@
 #include <elf/elf.h>
 #include <elf/elf_load.h>
+#include <vfs/vfs.h>
 
 #ifdef CONFIG_RTLD
@@ -89 +90 @@
 
 /** Number of preset files */
-static int filc = 0;
-/** Preset files vector */
-static fdi_node_t **filv = NULL;
-/** Buffer holding all preset files */
-static fdi_node_t *fil_buf = NULL;
+static unsigned int filc = 0;
 
 static elf_info_t prog_info;
@@ -239 +236 @@
 static void ldr_set_files(ipc_callid_t rid, ipc_call_t *request)
 {
-        fdi_node_t *buf;
-        size_t buf_size;
-        int rc = async_data_write_accept((void **) &buf, false, 0, 0,
-            sizeof(fdi_node_t), &buf_size);
-        
-        if (rc == EOK) {
-                int count = buf_size / sizeof(fdi_node_t);
-                
-                /*
-                 * Allocate new filv
-                 */
-                fdi_node_t **_filv = (fdi_node_t **) calloc(count + 1, sizeof(fdi_node_t *));
-                if (_filv == NULL) {
-                        free(buf);
-                        async_answer_0(rid, ENOMEM);
-                        return;
+        size_t count = IPC_GET_ARG1(*request);
+
+        async_exch_t *vfs_exch = vfs_exchange_begin();
+
+        for (filc = 0; filc < count; filc++) {
+                ipc_callid_t callid;
+                int fd;
+
+                if (!async_state_change_receive(&callid, NULL, NULL, NULL)) {
+                        async_answer_0(callid, EINVAL);
+                        break;
                 }
-                
-                /*
-                 * Fill the new filv with argument pointers
-                 */
-                int i;
-                for (i = 0; i < count; i++)
-                        _filv[i] = &buf[i];
-                
-                _filv[count] = NULL;
-                
-                /*
-                 * Copy temporary data to global variables
-                 */
-                if (fil_buf != NULL)
-                        free(fil_buf);
-                
-                if (filv != NULL)
-                        free(filv);
-                
-                filc = count;
-                fil_buf = buf;
-                filv = _filv;
-        }
-        
+                async_state_change_finalize(callid, vfs_exch);
+                fd = fd_wait();
+                assert(fd == (int) filc);
+        }
+
+        vfs_exchange_end(vfs_exch);
+
         async_answer_0(rid, EOK);
 }
@@ -308 +283 @@
         
         pcb.filc = filc;
-        pcb.filv = filv;
         
         if (prog_info.interp == NULL) {

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);
@@ -84 +84 @@
 /** Service directory ogranized by categories (yellow pages) */
 static categ_dir_t cdir;
+
+static FIBRIL_MUTEX_INITIALIZE(callback_sess_mutex);
+static async_sess_t *callback_sess = NULL;
 
 service_id_t loc_create_id(void)
@@ -308 +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);
@@ -412 +426 @@
         fibril_mutex_lock(&services_list_mutex);
         fibril_mutex_lock(&server->services_mutex);
+        fibril_mutex_lock(&cdir.mutex);
         
         while (!list_empty(&server->services)) {
@@ -420 +435 @@
         }
         
+        fibril_mutex_unlock(&cdir.mutex);
         fibril_mutex_unlock(&server->services_mutex);
         fibril_mutex_unlock(&services_list_mutex);
@@ -489 +505 @@
         link_initialize(&service->services);
         link_initialize(&service->server_services);
+        list_initialize(&service->cat_memb);
         
         /* Check that service is not already registered */
@@ -526 +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);
+}
+
+static void loc_category_get_name(ipc_callid_t iid, ipc_call_t *icall)
+{
+        ipc_callid_t callid;
+        size_t size;
+        size_t act_size;
+        category_t *cat;
+        
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        fibril_mutex_lock(&cdir.mutex);
+        
+        cat = category_get(&cdir, IPC_GET_ARG1(*icall));
+        if (cat == NULL) {
+                fibril_mutex_unlock(&cdir.mutex);
+                async_answer_0(callid, ENOENT);
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        act_size = str_size(cat->name);
+        if (act_size > size) {
+                fibril_mutex_unlock(&cdir.mutex);
+                async_answer_0(callid, EOVERFLOW);
+                async_answer_0(iid, EOVERFLOW);
+                return;
+        }
+        
+        sysarg_t retval = async_data_read_finalize(callid, cat->name,
+            min(size, act_size));
+        
+        fibril_mutex_unlock(&cdir.mutex);
+        
+        async_answer_0(iid, retval);
 }
 
@@ -571 +640 @@
         async_answer_0(iid, retval);
 }
-
 
 /** Connect client to the service.
@@ -728 +796 @@
  *
  */
+static void loc_callback_create(ipc_callid_t iid, ipc_call_t *icall)
+{
+        async_sess_t *cb_sess = async_callback_receive(EXCHANGE_SERIALIZE);
+        if (cb_sess == NULL) {
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+        
+        fibril_mutex_lock(&callback_sess_mutex);
+        if (callback_sess != NULL) {
+                fibril_mutex_unlock(&callback_sess_mutex);
+                async_answer_0(iid, EEXIST);
+                return;
+        }
+        
+        callback_sess = cb_sess;
+        fibril_mutex_unlock(&callback_sess_mutex);
+        
+        async_answer_0(iid, EOK);
+}
+
+void loc_category_change_event(void)
+{
+        fibril_mutex_lock(&callback_sess_mutex);
+
+        if (callback_sess != NULL) {
+                async_exch_t *exch = async_exchange_begin(callback_sess);
+                async_msg_0(exch, LOC_EVENT_CAT_CHANGE);
+                async_exchange_end(exch);
+        }
+
+        fibril_mutex_unlock(&callback_sess_mutex);
+}
+
+/** Find ID for category specified by name.
+ *
+ * On success, answer will contain EOK int retval and service ID in arg1.
+ * On failure, error code will be sent in retval.
+ *
+ */
 static void loc_category_get_id(ipc_callid_t iid, ipc_call_t *icall)
 {
@@ -1095 +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);
         
@@ -1129 +1239 @@
 
         async_answer_0(iid, retval);
+
+        loc_category_change_event();
 }
 
@@ -1156 +1268 @@
 
         cat = category_new("serial");
+        categ_dir_add_cat(&cdir, cat);
+
+        cat = category_new("usbhc");
+        categ_dir_add_cat(&cdir, cat);
+
+        cat = category_new("virtual");
         categ_dir_add_cat(&cdir, cat);
 
@@ -1244 +1362 @@
                         loc_namespace_get_id(callid, &call);
                         break;
+                case LOC_CALLBACK_CREATE:
+                        loc_callback_create(callid, &call);
+                        break;
                 case LOC_CATEGORY_GET_ID:
                         loc_category_get_id(callid, &call);
+                        break;
+                case LOC_CATEGORY_GET_NAME:
+                        loc_category_get_name(callid, &call);
                         break;
                 case LOC_CATEGORY_GET_SVCS:

uspace/srv/loc/loc.h

@@ -36 +36 @@
 #define LOC_H_
 
+#include <ipc/loc.h>
 #include <async.h>
 #include <fibril_synch.h>
@@ -89 +90 @@
         /** 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 +104 @@
 } 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);
 
 #endif

uspace/srv/vfs/vfs.c

@@ -36 +36 @@
  */
 
+#include <vfs/vfs.h>
 #include <ipc/services.h>
+#include <abi/ipc/event.h>
+#include <event.h>
 #include <ns.h>
 #include <async.h>
@@ -45 +48 @@
 #include <as.h>
 #include <atomic.h>
+#include <macros.h>
 #include "vfs.h"
 
 #define NAME  "vfs"
+
+enum {
+        VFS_TASK_STATE_CHANGE
+};
 
 static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
@@ -80 +88 @@
                         vfs_open(callid, &call);
                         break;
-                case VFS_IN_OPEN_NODE:
-                        vfs_open_node(callid, &call);
-                        break;
                 case VFS_IN_CLOSE:
                         vfs_close(callid, &call);
@@ -118 +123 @@
                 case VFS_IN_DUP:
                         vfs_dup(callid, &call);
+                        break;
+                case VFS_IN_WAIT_HANDLE:
+                        vfs_wait_handle(callid, &call);
+                        break;
                 default:
                         async_answer_0(callid, ENOTSUP);
@@ -128 +137 @@
          * connection fibril terminates.
          */
+}
+
+static void notification_received(ipc_callid_t callid, ipc_call_t *call)
+{
+        switch (IPC_GET_IMETHOD(*call)) {
+        case VFS_TASK_STATE_CHANGE:
+                if (IPC_GET_ARG1(*call) == VFS_PASS_HANDLE)
+                        vfs_pass_handle(
+                            (task_id_t) MERGE_LOUP32(IPC_GET_ARG4(*call),
+                            IPC_GET_ARG5(*call)), call->in_task_id,
+                            (int) IPC_GET_ARG2(*call));
+                break;
+        default:
+                break;
+        }
 }
 
@@ -170 +194 @@
 
         /*
+         * Set notification handler and subscribe to notifications.
+         */
+        async_set_interrupt_received(notification_received);
+        event_task_subscribe(EVENT_TASK_STATE_CHANGE, VFS_TASK_STATE_CHANGE);
+
+        /*
          * Register at the naming service.
          */

uspace/srv/vfs/vfs.h

@@ -41 +41 @@
 #include <bool.h>
 #include <ipc/vfs.h>
+#include <task.h>
 
 #ifndef dprintf
@@ -175 +176 @@
 extern int vfs_lookup_internal(char *, int, vfs_lookup_res_t *,
     vfs_pair_t *, ...);
-extern int vfs_open_node_internal(vfs_lookup_res_t *);
 
 extern bool vfs_nodes_init(void);
@@ -189 +189 @@
 extern void vfs_client_data_destroy(void *);
 
+extern void vfs_pass_handle(task_id_t, task_id_t, int);
+extern int vfs_wait_handle_internal(void);
+
 extern vfs_file_t *vfs_file_get(int);
 extern void vfs_file_put(vfs_file_t *);
@@ -197 +200 @@
 extern void vfs_node_addref(vfs_node_t *);
 extern void vfs_node_delref(vfs_node_t *);
+extern int vfs_open_node_remote(vfs_node_t *);
 
 extern void vfs_register(ipc_callid_t, ipc_call_t *);
@@ -202 +206 @@
 extern void vfs_unmount(ipc_callid_t, ipc_call_t *);
 extern void vfs_open(ipc_callid_t, ipc_call_t *);
-extern void vfs_open_node(ipc_callid_t, ipc_call_t *);
 extern void vfs_sync(ipc_callid_t, ipc_call_t *);
 extern void vfs_dup(ipc_callid_t, ipc_call_t *);
@@ -215 +218 @@
 extern void vfs_unlink(ipc_callid_t, ipc_call_t *);
 extern void vfs_rename(ipc_callid_t, ipc_call_t *);
+extern void vfs_wait_handle(ipc_callid_t, ipc_call_t *);
 
 #endif

uspace/srv/vfs/vfs_file.c

@@ -43 +43 @@
 #include <fibril.h>
 #include <fibril_synch.h>
+#include <adt/list.h>
+#include <task.h>
 #include "vfs.h"
 
@@ -50 +52 @@
 typedef struct {
         fibril_mutex_t lock;
+        fibril_condvar_t cv;
+        list_t passed_handles;
         vfs_file_t **files;
 } vfs_client_data_t;
 
+typedef struct {
+        link_t link;
+        int handle;
+} vfs_boxed_handle_t;
+
+static int _vfs_fd_free(vfs_client_data_t *, int);
+
 /** Initialize the table of open files. */
-static bool vfs_files_init(void)
-{
-        fibril_mutex_lock(&VFS_DATA->lock);
-        if (!FILES) {
-                FILES = malloc(MAX_OPEN_FILES * sizeof(vfs_file_t *));
-                if (!FILES) {
-                        fibril_mutex_unlock(&VFS_DATA->lock);
+static bool vfs_files_init(vfs_client_data_t *vfs_data)
+{
+        fibril_mutex_lock(&vfs_data->lock);
+        if (!vfs_data->files) {
+                vfs_data->files = malloc(MAX_OPEN_FILES * sizeof(vfs_file_t *));
+                if (!vfs_data->files) {
+                        fibril_mutex_unlock(&vfs_data->lock);
                         return false;
                 }
-                memset(FILES, 0, MAX_OPEN_FILES * sizeof(vfs_file_t *));
-        }
-        fibril_mutex_unlock(&VFS_DATA->lock);
+                memset(vfs_data->files, 0, MAX_OPEN_FILES * sizeof(vfs_file_t *));
+        }
+        fibril_mutex_unlock(&vfs_data->lock);
         return true;
 }
 
 /** Cleanup the table of open files. */
-static void vfs_files_done(void)
+static void vfs_files_done(vfs_client_data_t *vfs_data)
 {
         int i;
 
-        if (!FILES)
+        if (!vfs_data->files)
                 return;
 
         for (i = 0; i < MAX_OPEN_FILES; i++) {
-                if (FILES[i]) {
-                        (void) vfs_fd_free(i);
-                }
-        }
-        
-        free(FILES);
+                if (vfs_data->files[i])
+                        (void) _vfs_fd_free(vfs_data, i);
+        }
+        
+        free(vfs_data->files);
+
+        while (!list_empty(&vfs_data->passed_handles)) {
+                link_t *lnk;
+                vfs_boxed_handle_t *bh;
+                
+                lnk = list_first(&vfs_data->passed_handles);
+                list_remove(lnk);
+
+                bh = list_get_instance(lnk, vfs_boxed_handle_t, link);
+                free(bh);
+        }
 }
 
@@ -93 +114 @@
         if (vfs_data) {
                 fibril_mutex_initialize(&vfs_data->lock);
+                fibril_condvar_initialize(&vfs_data->cv);
+                list_initialize(&vfs_data->passed_handles);
                 vfs_data->files = NULL;
         }
@@ -103 +126 @@
         vfs_client_data_t *vfs_data = (vfs_client_data_t *) data;
 
-        vfs_files_done();
+        vfs_files_done(vfs_data);
         free(vfs_data);
 }
@@ -131 +154 @@
  *                      incremented.
  */
-static void vfs_file_addref(vfs_file_t *file)
-{
-        assert(fibril_mutex_is_locked(&VFS_DATA->lock));
+static void vfs_file_addref(vfs_client_data_t *vfs_data, vfs_file_t *file)
+{
+        assert(fibril_mutex_is_locked(&vfs_data->lock));
 
         file->refcnt++;
@@ -143 +166 @@
  *                      decremented.
  */
-static int vfs_file_delref(vfs_file_t *file)
+static int vfs_file_delref(vfs_client_data_t *vfs_data, vfs_file_t *file)
 {
         int rc = EOK;
 
-        assert(fibril_mutex_is_locked(&VFS_DATA->lock));
+        assert(fibril_mutex_is_locked(&vfs_data->lock));
 
         if (file->refcnt-- == 1) {
@@ -162 +185 @@
 }
 
-
-/** Allocate a file descriptor.
- *
- * @param desc If true, look for an available file descriptor
- *             in a descending order.
- *
- * @return First available file descriptor or a negative error
- *         code.
- */
-int vfs_fd_alloc(bool desc)
-{
-        if (!vfs_files_init())
+static int _vfs_fd_alloc(vfs_client_data_t *vfs_data, bool desc)
+{
+        if (!vfs_files_init(vfs_data))
                 return ENOMEM;
         
@@ -182 +196 @@
                 i = 0;
         
-        fibril_mutex_lock(&VFS_DATA->lock);
+        fibril_mutex_lock(&vfs_data->lock);
         while (true) {
-                if (!FILES[i]) {
-                        FILES[i] = (vfs_file_t *) malloc(sizeof(vfs_file_t));
-                        if (!FILES[i]) {
-                                fibril_mutex_unlock(&VFS_DATA->lock);
+                if (!vfs_data->files[i]) {
+                        vfs_data->files[i] = (vfs_file_t *) malloc(sizeof(vfs_file_t));
+                        if (!vfs_data->files[i]) {
+                                fibril_mutex_unlock(&vfs_data->lock);
                                 return ENOMEM;
                         }
                         
-                        memset(FILES[i], 0, sizeof(vfs_file_t));
-                        fibril_mutex_initialize(&FILES[i]->lock);
-                        vfs_file_addref(FILES[i]);
-                        fibril_mutex_unlock(&VFS_DATA->lock);
+                        memset(vfs_data->files[i], 0, sizeof(vfs_file_t));
+                        fibril_mutex_initialize(&vfs_data->files[i]->lock);
+                        vfs_file_addref(vfs_data, vfs_data->files[i]);
+                        fibril_mutex_unlock(&vfs_data->lock);
                         return (int) i;
                 }
@@ -210 +224 @@
                 }
         }
-        fibril_mutex_unlock(&VFS_DATA->lock);
+        fibril_mutex_unlock(&vfs_data->lock);
         
         return EMFILE;
+}
+
+/** Allocate a file descriptor.
+ *
+ * @param desc If true, look for an available file descriptor
+ *             in a descending order.
+ *
+ * @return First available file descriptor or a negative error
+ *         code.
+ */
+int vfs_fd_alloc(bool desc)
+{
+        return _vfs_fd_alloc(VFS_DATA, desc);
+}
+
+static int _vfs_fd_free(vfs_client_data_t *vfs_data, int fd)
+{
+        int rc;
+
+        if (!vfs_files_init(vfs_data))
+                return ENOMEM;
+
+        fibril_mutex_lock(&vfs_data->lock);     
+        if ((fd < 0) || (fd >= MAX_OPEN_FILES) || !vfs_data->files[fd]) {
+                fibril_mutex_unlock(&vfs_data->lock);
+                return EBADF;
+        }
+        
+        rc = vfs_file_delref(vfs_data, vfs_data->files[fd]);
+        vfs_data->files[fd] = NULL;
+        fibril_mutex_unlock(&vfs_data->lock);
+        
+        return rc;
 }
 
@@ -224 +271 @@
 int vfs_fd_free(int fd)
 {
-        int rc;
-
-        if (!vfs_files_init())
-                return ENOMEM;
-
-        fibril_mutex_lock(&VFS_DATA->lock);     
-        if ((fd < 0) || (fd >= MAX_OPEN_FILES) || (FILES[fd] == NULL)) {
-                fibril_mutex_unlock(&VFS_DATA->lock);
-                return EBADF;
-        }
-        
-        rc = vfs_file_delref(FILES[fd]);
-        FILES[fd] = NULL;
-        fibril_mutex_unlock(&VFS_DATA->lock);
-        
-        return rc;
+        return _vfs_fd_free(VFS_DATA, fd);
 }
 
@@ -253 +285 @@
 int vfs_fd_assign(vfs_file_t *file, int fd)
 {
-        if (!vfs_files_init())
+        if (!vfs_files_init(VFS_DATA))
                 return ENOMEM;
 
@@ -263 +295 @@
         
         FILES[fd] = file;
-        vfs_file_addref(FILES[fd]);
+        vfs_file_addref(VFS_DATA, FILES[fd]);
         fibril_mutex_unlock(&VFS_DATA->lock);
         
@@ -269 +301 @@
 }
 
-/** Find VFS file structure for a given file descriptor.
- *
- * @param fd            File descriptor.
- *
- * @return              VFS file structure corresponding to fd.
- */
-vfs_file_t *vfs_file_get(int fd)
-{
-        if (!vfs_files_init())
+static vfs_file_t *_vfs_file_get(vfs_client_data_t *vfs_data, int fd)
+{
+        if (!vfs_files_init(vfs_data))
                 return NULL;
         
-        fibril_mutex_lock(&VFS_DATA->lock);
+        fibril_mutex_lock(&vfs_data->lock);
         if ((fd >= 0) && (fd < MAX_OPEN_FILES)) {
-                vfs_file_t *file = FILES[fd];
+                vfs_file_t *file = vfs_data->files[fd];
                 if (file != NULL) {
-                        vfs_file_addref(file);
-                        fibril_mutex_unlock(&VFS_DATA->lock);
+                        vfs_file_addref(vfs_data, file);
+                        fibril_mutex_unlock(&vfs_data->lock);
                         return file;
                 }
         }
-        fibril_mutex_unlock(&VFS_DATA->lock);
+        fibril_mutex_unlock(&vfs_data->lock);
         
         return NULL;
 }
 
+/** Find VFS file structure for a given file descriptor.
+ *
+ * @param fd            File descriptor.
+ *
+ * @return              VFS file structure corresponding to fd.
+ */
+vfs_file_t *vfs_file_get(int fd)
+{
+        return _vfs_file_get(VFS_DATA, fd);
+}
+
+static void _vfs_file_put(vfs_client_data_t *vfs_data, vfs_file_t *file)
+{
+        fibril_mutex_lock(&vfs_data->lock);
+        vfs_file_delref(vfs_data, file);
+        fibril_mutex_unlock(&vfs_data->lock);
+}
+
 /** Stop using a file structure.
  *
@@ -300 +344 @@
 void vfs_file_put(vfs_file_t *file)
 {
-        fibril_mutex_lock(&VFS_DATA->lock);
-        vfs_file_delref(file);
-        fibril_mutex_unlock(&VFS_DATA->lock);
+        _vfs_file_put(VFS_DATA, file);
+}
+
+void vfs_pass_handle(task_id_t donor_id, task_id_t acceptor_id, int donor_fd)
+{
+        vfs_client_data_t *donor_data = NULL;
+        vfs_client_data_t *acceptor_data = NULL;
+        vfs_file_t *donor_file = NULL;
+        vfs_file_t *acceptor_file = NULL;
+        vfs_boxed_handle_t *bh;
+        int acceptor_fd;
+
+        acceptor_data = async_get_client_data_by_id(acceptor_id);
+        if (!acceptor_data)
+                return;
+
+        bh = malloc(sizeof(vfs_boxed_handle_t));
+        assert(bh);
+
+        link_initialize(&bh->link);
+        bh->handle = -1;
+
+        donor_data = async_get_client_data_by_id(donor_id);
+        if (!donor_data)
+                goto out;
+
+        donor_file = _vfs_file_get(donor_data, donor_fd);
+        if (!donor_file)
+                goto out;
+
+        acceptor_fd = _vfs_fd_alloc(acceptor_data, false);
+        if (acceptor_fd < 0)
+                goto out;
+
+        bh->handle = acceptor_fd;
+
+        /*
+         * Add a new reference to the underlying VFS node.
+         */
+        vfs_node_addref(donor_file->node);
+        (void) vfs_open_node_remote(donor_file->node);
+
+        acceptor_file = _vfs_file_get(acceptor_data, acceptor_fd);
+        assert(acceptor_file);
+
+        /*
+         * Inherit attributes from the donor.
+         */
+        acceptor_file->node = donor_file->node;
+        acceptor_file->append = donor_file->append;
+        acceptor_file->pos = donor_file->pos;
+
+out:
+        fibril_mutex_lock(&acceptor_data->lock);
+        list_append(&bh->link, &acceptor_data->passed_handles);
+        fibril_condvar_broadcast(&acceptor_data->cv);
+        fibril_mutex_unlock(&acceptor_data->lock);
+
+        if (donor_data)
+                async_put_client_data_by_id(donor_id);
+        if (acceptor_data)
+                async_put_client_data_by_id(acceptor_id);
+        if (donor_file)
+                _vfs_file_put(donor_data, donor_file);
+        if (acceptor_file)
+                _vfs_file_put(acceptor_data, acceptor_file);
+
+}
+
+int vfs_wait_handle_internal(void)
+{
+        vfs_client_data_t *vfs_data = VFS_DATA; 
+        int fd;
+        
+        fibril_mutex_lock(&vfs_data->lock);
+        while (list_empty(&vfs_data->passed_handles))
+                fibril_condvar_wait(&vfs_data->cv, &vfs_data->lock);
+        link_t *lnk = list_first(&vfs_data->passed_handles);
+        list_remove(lnk);
+        fibril_mutex_unlock(&vfs_data->lock);
+
+        vfs_boxed_handle_t *bh = list_get_instance(lnk, vfs_boxed_handle_t, link);
+        fd = bh->handle;
+        free(bh);
+
+        return fd;
 }
 

uspace/srv/vfs/vfs_lookup.c

@@ -201 +201 @@
 }
 
-/** Perform a node open operation.
- *
- * @return EOK on success or an error code from errno.h.
- *
- */
-int vfs_open_node_internal(vfs_lookup_res_t *result)
-{
-        async_exch_t *exch = vfs_exchange_grab(result->triplet.fs_handle);
-        
-        ipc_call_t answer;
-        aid_t req = async_send_2(exch, VFS_OUT_OPEN_NODE,
-            (sysarg_t) result->triplet.service_id,
-            (sysarg_t) result->triplet.index, &answer);
-        
-        sysarg_t rc;
-        async_wait_for(req, &rc);
-        vfs_exchange_release(exch);
-        
-        if (rc == EOK) {
-                result->size =
-                    MERGE_LOUP32(IPC_GET_ARG1(answer), IPC_GET_ARG2(answer));
-                result->lnkcnt = (unsigned int) IPC_GET_ARG3(answer);
-                if (IPC_GET_ARG4(answer) & L_FILE)
-                        result->type = VFS_NODE_FILE;
-                else if (IPC_GET_ARG4(answer) & L_DIRECTORY)
-                        result->type = VFS_NODE_DIRECTORY;
-                else
-                        result->type = VFS_NODE_UNKNOWN;
-        }
-        
-        return rc;
-}
-
 /**
  * @}

uspace/srv/vfs/vfs_node.c

@@ -293 +293 @@
 }
 
+
+/** Perform a remote node open operation.
+ *
+ * @return EOK on success or an error code from errno.h.
+ *
+ */
+int vfs_open_node_remote(vfs_node_t *node)
+{
+        async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
+        
+        ipc_call_t answer;
+        aid_t req = async_send_2(exch, VFS_OUT_OPEN_NODE,
+            (sysarg_t) node->service_id, (sysarg_t) node->index, &answer);
+        
+        vfs_exchange_release(exch);
+
+        sysarg_t rc;
+        async_wait_for(req, &rc);
+        
+        return rc;
+}
+
 /**
  * @}

uspace/srv/vfs/vfs_ops.c

@@ -618 +618 @@
 }
 
-void vfs_open_node(ipc_callid_t rid, ipc_call_t *request)
-{
-        // FIXME: check for sanity of the supplied fs, dev and index
-        
-        /*
-         * The interface is open_node(fs, dev, index, oflag).
-         */
-        vfs_lookup_res_t lr;
-        
-        lr.triplet.fs_handle = IPC_GET_ARG1(*request);
-        lr.triplet.service_id = IPC_GET_ARG2(*request);
-        lr.triplet.index = IPC_GET_ARG3(*request);
-        int oflag = IPC_GET_ARG4(*request);
-        
-        fibril_rwlock_read_lock(&namespace_rwlock);
-        
-        int rc = vfs_open_node_internal(&lr);
-        if (rc != EOK) {
-                fibril_rwlock_read_unlock(&namespace_rwlock);
-                async_answer_0(rid, rc);
-                return;
-        }
-        
-        vfs_node_t *node = vfs_node_get(&lr);
-        fibril_rwlock_read_unlock(&namespace_rwlock);
-        
-        /* Truncate the file if requested and if necessary. */
-        if (oflag & O_TRUNC) {
-                fibril_rwlock_write_lock(&node->contents_rwlock);
-                if (node->size) {
-                        rc = vfs_truncate_internal(node->fs_handle,
-                            node->service_id, node->index, 0);
-                        if (rc) {
-                                fibril_rwlock_write_unlock(&node->contents_rwlock);
-                                vfs_node_put(node);
-                                async_answer_0(rid, rc);
-                                return;
-                        }
-                        node->size = 0;
-                }
-                fibril_rwlock_write_unlock(&node->contents_rwlock);
-        }
-        
-        /*
-         * Get ourselves a file descriptor and the corresponding vfs_file_t
-         * structure.
-         */
-        int fd = vfs_fd_alloc((oflag & O_DESC) != 0);
-        if (fd < 0) {
-                vfs_node_put(node);
-                async_answer_0(rid, fd);
-                return;
-        }
-        vfs_file_t *file = vfs_file_get(fd);
-        file->node = node;
-        if (oflag & O_APPEND)
-                file->append = true;
-        
-        /*
-         * The following increase in reference count is for the fact that the
-         * file is being opened and that a file structure is pointing to it.
-         * It is necessary so that the file will not disappear when
-         * vfs_node_put() is called. The reference will be dropped by the
-         * respective VFS_IN_CLOSE.
-         */
-        vfs_node_addref(node);
-        vfs_node_put(node);
-        vfs_file_put(file);
-        
-        /* Success! Return the new file descriptor to the client. */
-        async_answer_1(rid, EOK, fd);
-}
-
 void vfs_sync(ipc_callid_t rid, ipc_call_t *request)
 {
@@ -1349 +1276 @@
 }
 
+void vfs_wait_handle(ipc_callid_t rid, ipc_call_t *request)
+{
+        int fd = vfs_wait_handle_internal();
+        async_answer_1(rid, EOK, fd);
+}
+
 /**
  * @}