Changes in uspace/srv/devmap/devmap.c [a405563:63e0bdd] in mainline

File:

• uspace/srv/devmap/devmap.c (modified) (33 diffs)

uspace/srv/devmap/devmap.c

@@ -42 +42 @@
 #include <errno.h>
 #include <bool.h>
-#include <fibril_sync.h>
+#include <fibril_synch.h>
 #include <stdlib.h>
-#include <string.h>
+#include <str.h>
 #include <ipc/devmap.h>
+#include <assert.h>
 
 #define NAME          "devmap"
@@ -61 +62 @@
         link_t devices;
         /** Phone asociated with this driver */
-        ipcarg_t phone;
+        sysarg_t phone;
         /** Device driver name */
         char *name;
@@ -67 +68 @@
         fibril_mutex_t devices_mutex;
 } devmap_driver_t;
+
+/** Info about registered namespaces
+ *
+ */
+typedef struct {
+        /** Pointer to the previous and next device in the list of all namespaces */
+        link_t namespaces;
+        /** Unique namespace identifier */
+        devmap_handle_t handle;
+        /** Namespace name */
+        char *name;
+        /** Reference count */
+        size_t refcnt;
+} devmap_namespace_t;
 
 /** Info about registered device
@@ -77 +92 @@
             owned by one driver */
         link_t driver_devices;
-        /** Unique device identifier  */
-        dev_handle_t handle;
+        /** Unique device identifier */
+        devmap_handle_t handle;
+        /** Device namespace */
+        devmap_namespace_t *namespace;
         /** Device name */
         char *name;
         /** Device driver handling this device */
         devmap_driver_t *driver;
+        /** Use this interface when forwarding to driver. */
+        sysarg_t forward_interface;
 } devmap_device_t;
 
 LIST_INITIALIZE(devices_list);
+LIST_INITIALIZE(namespaces_list);
 LIST_INITIALIZE(drivers_list);
 
@@ -101 +121 @@
 static FIBRIL_MUTEX_INITIALIZE(null_devices_mutex);
 
-static dev_handle_t last_handle = 0;
+static devmap_handle_t last_handle = 0;
 static devmap_device_t *null_devices[NULL_DEVICES];
 
-static dev_handle_t devmap_create_handle(void)
+/*
+ * Dummy list for null devices. This is necessary so that null devices can
+ * be used just as any other devices, e.g. in devmap_device_unregister_core().
+ */
+static LIST_INITIALIZE(dummy_null_driver_devices);
+
+static devmap_handle_t devmap_create_handle(void)
 {
         /* TODO: allow reusing old handles after their unregistration
@@ -117 +143 @@
 }
 
-/** Find device with given name.
- *
- */
-static devmap_device_t *devmap_device_find_name(const char *name)
-{
-        link_t *item = devices_list.next;
-        devmap_device_t *device = NULL;
-        
-        while (item != &devices_list) {
-                device = list_get_instance(item, devmap_device_t, devices);
-                if (str_cmp(device->name, name) == 0)
-                        break;
-                item = item->next;
-        }
-        
-        if (item == &devices_list)
+/** Convert fully qualified device name to namespace and device name.
+ *
+ * A fully qualified device name can be either a plain device name
+ * (then the namespace is considered to be an empty string) or consist
+ * of two components separated by a slash. No more than one slash
+ * is allowed.
+ *
+ */
+static bool devmap_fqdn_split(const char *fqdn, char **ns_name, char **name)
+{
+        size_t cnt = 0;
+        size_t slash_offset = 0;
+        size_t slash_after = 0;
+        
+        size_t offset = 0;
+        size_t offset_prev = 0;
+        wchar_t c;
+        
+        while ((c = str_decode(fqdn, &offset, STR_NO_LIMIT)) != 0) {
+                if (c == '/') {
+                        cnt++;
+                        slash_offset = offset_prev;
+                        slash_after = offset;
+                }
+                offset_prev = offset;
+        }
+        
+        /* More than one slash */
+        if (cnt > 1)
+                return false;
+        
+        /* No slash -> namespace is empty */
+        if (cnt == 0) {
+                *ns_name = str_dup("");
+                if (*ns_name == NULL)
+                        return false;
+                
+                *name = str_dup(fqdn);
+                if (*name == NULL) {
+                        free(*ns_name);
+                        return false;
+                }
+                
+                if (str_cmp(*name, "") == 0) {
+                        free(*name);
+                        free(*ns_name);
+                        return false;
+                }
+                
+                return true;
+        }
+        
+        /* Exactly one slash */
+        *ns_name = str_ndup(fqdn, slash_offset);
+        if (*ns_name == NULL)
+                return false;
+        
+        *name = str_dup(fqdn + slash_after);
+        if (*name == NULL) {
+                free(*ns_name);
+                return false;
+        }
+        
+        if (str_cmp(*name, "") == 0) {
+                free(*name);
+                free(*ns_name);
+                return false;
+        }
+        
+        return true;
+}
+
+/** Find namespace with given name. */
+static devmap_namespace_t *devmap_namespace_find_name(const char *name)
+{
+        link_t *item;
+        
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+        
+        for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
+                devmap_namespace_t *namespace =
+                    list_get_instance(item, devmap_namespace_t, namespaces);
+                if (str_cmp(namespace->name, name) == 0)
+                        return namespace;
+        }
+        
+        return NULL;
+}
+
+/** Find namespace with given handle.
+ *
+ * @todo: use hash table
+ *
+ */
+static devmap_namespace_t *devmap_namespace_find_handle(devmap_handle_t handle)
+{
+        link_t *item;
+        
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+        
+        for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
+                devmap_namespace_t *namespace =
+                    list_get_instance(item, devmap_namespace_t, namespaces);
+                if (namespace->handle == handle)
+                        return namespace;
+        }
+        
+        return NULL;
+}
+
+/** Find device with given name. */
+static devmap_device_t *devmap_device_find_name(const char *ns_name,
+    const char *name)
+{
+        link_t *item;
+        
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+        
+        for (item = devices_list.next; item != &devices_list; item = item->next) {
+                devmap_device_t *device =
+                    list_get_instance(item, devmap_device_t, devices);
+                if ((str_cmp(device->namespace->name, ns_name) == 0)
+                    && (str_cmp(device->name, name) == 0))
+                        return device;
+        }
+        
+        return NULL;
+}
+
+/** Find device with given handle.
+ *
+ * @todo: use hash table
+ *
+ */
+static devmap_device_t *devmap_device_find_handle(devmap_handle_t handle)
+{
+        link_t *item;
+        
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+        
+        for (item = devices_list.next; item != &devices_list; item = item->next) {
+                devmap_device_t *device =
+                    list_get_instance(item, devmap_device_t, devices);
+                if (device->handle == handle)
+                        return device;
+        }
+        
+        return NULL;
+}
+
+/** Create a namespace (if not already present). */
+static devmap_namespace_t *devmap_namespace_create(const char *ns_name)
+{
+        devmap_namespace_t *namespace;
+        
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+        
+        namespace = devmap_namespace_find_name(ns_name);
+        if (namespace != NULL)
+                return namespace;
+        
+        namespace = (devmap_namespace_t *) malloc(sizeof(devmap_namespace_t));
+        if (namespace == NULL)
                 return NULL;
         
-        device = list_get_instance(item, devmap_device_t, devices);
-        return device;
-}
-
-/** Find device with given handle.
- *
- * @todo: use hash table
- *
- */
-static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)
-{
-        fibril_mutex_lock(&devices_list_mutex);
-        
-        link_t *item = (&devices_list)->next;
-        devmap_device_t *device = NULL;
-        
-        while (item != &devices_list) {
-                device = list_get_instance(item, devmap_device_t, devices);
-                if (device->handle == handle)
-                        break;
-                item = item->next;
-        }
-        
-        if (item == &devices_list) {
-                fibril_mutex_unlock(&devices_list_mutex);
+        namespace->name = str_dup(ns_name);
+        if (namespace->name == NULL) {
+                free(namespace);
                 return NULL;
         }
         
-        device = list_get_instance(item, devmap_device_t, devices);
-        
-        fibril_mutex_unlock(&devices_list_mutex);
-        
-        return device;
-}
-
-/**
- * Unregister device and free it. It's assumed that driver's device list is
- * already locked.
- */
-static int devmap_device_unregister_core(devmap_device_t *device)
-{
+        namespace->handle = devmap_create_handle();
+        namespace->refcnt = 0;
+        
+        /*
+         * Insert new namespace into list of registered namespaces
+         */
+        list_append(&(namespace->namespaces), &namespaces_list);
+        
+        return namespace;
+}
+
+/** Destroy a namespace (if it is no longer needed). */
+static void devmap_namespace_destroy(devmap_namespace_t *namespace)
+{
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+
+        if (namespace->refcnt == 0) {
+                list_remove(&(namespace->namespaces));
+                
+                free(namespace->name);
+                free(namespace);
+        }
+}
+
+/** Increase namespace reference count by including device. */
+static void devmap_namespace_addref(devmap_namespace_t *namespace,
+    devmap_device_t *device)
+{
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+
+        device->namespace = namespace;
+        namespace->refcnt++;
+}
+
+/** Decrease namespace reference count. */
+static void devmap_namespace_delref(devmap_namespace_t *namespace)
+{
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+
+        namespace->refcnt--;
+        devmap_namespace_destroy(namespace);
+}
+
+/** Unregister device and free it. */
+static void devmap_device_unregister_core(devmap_device_t *device)
+{
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+
+        devmap_namespace_delref(device->namespace);
         list_remove(&(device->devices));
         list_remove(&(device->driver_devices));
@@ -181 +368 @@
         free(device->name);
         free(device);
-        
-        return EOK;
 }
 
@@ -189 +374 @@
  * drivers.
  */
-static void devmap_driver_register(devmap_driver_t **odriver)
-{
-        *odriver = NULL;
-        
+static devmap_driver_t *devmap_driver_register(void)
+{
         ipc_call_t icall;
         ipc_callid_t iid = async_get_call(&icall);
         
-        if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {
-                ipc_answer_0(iid, EREFUSED);
-                return;
-        }
-        
-        devmap_driver_t *driver = (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
-        
+        if (IPC_GET_IMETHOD(icall) != DEVMAP_DRIVER_REGISTER) {
+                async_answer_0(iid, EREFUSED);
+                return NULL;
+        }
+        
+        devmap_driver_t *driver =
+            (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
         if (driver == NULL) {
-                ipc_answer_0(iid, ENOMEM);
-                return;
+                async_answer_0(iid, ENOMEM);
+                return NULL;
         }
         
@@ -211 +394 @@
          * Get driver name
          */
-        ipc_callid_t callid;
-        size_t name_size;
-        if (!ipc_data_write_receive(&callid, &name_size)) {
+        int rc = async_data_write_accept((void **) &driver->name, true, 0,
+            DEVMAP_NAME_MAXLEN, 0, NULL);
+        if (rc != EOK) {
                 free(driver);
-                ipc_answer_0(callid, EREFUSED);
-                ipc_answer_0(iid, EREFUSED);
-                return;
-        }
-        
-        if (name_size > DEVMAP_NAME_MAXLEN) {
-                free(driver);
-                ipc_answer_0(callid, EINVAL);
-                ipc_answer_0(iid, EREFUSED);
-                return;
+                async_answer_0(iid, rc);
+                return NULL;
         }
         
         /*
-         * Allocate buffer for device name.
-         */
-        driver->name = (char *) malloc(name_size + 1);
-        if (driver->name == NULL) {
-                free(driver);
-                ipc_answer_0(callid, ENOMEM);
-                ipc_answer_0(iid, EREFUSED);
-                return;
-        }
-        
-        /*
-         * Send confirmation to sender and get data into buffer.
-         */
-        if (ipc_data_write_finalize(callid, driver->name, name_size) != EOK) {
+         * Create connection to the driver
+         */
+        ipc_call_t call;
+        ipc_callid_t callid = async_get_call(&call);
+        
+        if (IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) {
                 free(driver->name);
                 free(driver);
-                ipc_answer_0(iid, EREFUSED);
-                return;
-        }
-        
-        driver->name[name_size] = 0;
-        
-        /* Initialize mutex for list of devices owned by this driver */
+                async_answer_0(callid, ENOTSUP);
+                async_answer_0(iid, ENOTSUP);
+                return NULL;
+        }
+        
+        driver->phone = IPC_GET_ARG5(call);
+        async_answer_0(callid, EOK);
+        
+        /*
+         * Initialize mutex for list of devices
+         * owned by this driver
+         */
         fibril_mutex_initialize(&driver->devices_mutex);
         
@@ -257 +429 @@
          */
         list_initialize(&driver->devices);
-        
-        /*
-         * Create connection to the driver
-         */
-        ipc_call_t call;
-        callid = async_get_call(&call);
-        
-        if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
-                ipc_answer_0(callid, ENOTSUP);
-                
-                free(driver->name);
-                free(driver);
-                ipc_answer_0(iid, ENOTSUP);
-                return;
-        }
-        
-        driver->phone = IPC_GET_ARG5(call);
-        
-        ipc_answer_0(callid, EOK);
-        
-        list_initialize(&(driver->drivers));
+
+        link_initialize(&driver->drivers);
         
         fibril_mutex_lock(&drivers_list_mutex);
         
         /* TODO:
-         * check that no driver with name equal to driver->name is registered
+         * Check that no driver with name equal to
+         * driver->name is registered
          */
         
@@ -291 +445 @@
         fibril_mutex_unlock(&drivers_list_mutex);
         
-        ipc_answer_0(iid, EOK);
-        
-        *odriver = driver;
+        async_answer_0(iid, EOK);
+        
+        return driver;
 }
 
@@ -309 +463 @@
         
         if (driver->phone != 0)
-                ipc_hangup(driver->phone);
+                async_hangup(driver->phone);
         
         /* Remove it from list of drivers */
@@ -328 +482 @@
         fibril_mutex_unlock(&drivers_list_mutex);
         
-        /* free name and driver */
+        /* Free name and driver */
         if (driver->name != NULL)
                 free(driver->name);
@@ -344 +498 @@
 {
         if (driver == NULL) {
-                ipc_answer_0(iid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
                 return;
         }
         
         /* Create new device entry */
-        devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
+        devmap_device_t *device =
+            (devmap_device_t *) malloc(sizeof(devmap_device_t));
         if (device == NULL) {
-                ipc_answer_0(iid, ENOMEM);
-                return;
-        }
-        
-        /* Get device name */
-        ipc_callid_t callid;
-        size_t size;
-        if (!ipc_data_write_receive(&callid, &size)) {
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+        
+        /* Set the interface, if any. */
+        device->forward_interface = IPC_GET_ARG1(*icall);
+
+        /* Get fqdn */
+        char *fqdn;
+        int rc = async_data_write_accept((void **) &fqdn, true, 0,
+            DEVMAP_NAME_MAXLEN, 0, NULL);
+        if (rc != EOK) {
                 free(device);
-                ipc_answer_0(iid, EREFUSED);
-                return;
-        }
-        
-        if (size > DEVMAP_NAME_MAXLEN) {
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        char *ns_name;
+        if (!devmap_fqdn_split(fqdn, &ns_name, &device->name)) {
+                free(fqdn);
                 free(device);
-                ipc_answer_0(callid, EINVAL);
-                ipc_answer_0(iid, EREFUSED);
-                return;
-        }
-        
-        /* +1 for terminating \0 */
-        device->name = (char *) malloc(size + 1);
-        
-        if (device->name == NULL) {
-                free(device);
-                ipc_answer_0(callid, ENOMEM);
-                ipc_answer_0(iid, EREFUSED);
-                return;
-        }
-        
-        ipc_data_write_finalize(callid, device->name, size);
-        device->name[size] = 0;
-        
-        list_initialize(&(device->devices));
-        list_initialize(&(device->driver_devices));
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        free(fqdn);
         
         fibril_mutex_lock(&devices_list_mutex);
         
-        /* Check that device with such name is not already registered */
-        if (NULL != devmap_device_find_name(device->name)) {
-                printf(NAME ": Device '%s' already registered\n", device->name);
+        devmap_namespace_t *namespace = devmap_namespace_create(ns_name);
+        free(ns_name);
+        if (namespace == NULL) {
                 fibril_mutex_unlock(&devices_list_mutex);
                 free(device->name);
                 free(device);
-                ipc_answer_0(iid, EEXISTS);
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+        
+        link_initialize(&device->devices);
+        link_initialize(&device->driver_devices);
+        
+        /* Check that device is not already registered */
+        if (devmap_device_find_name(namespace->name, device->name) != NULL) {
+                printf("%s: Device '%s/%s' already registered\n", NAME,
+                    device->namespace->name, device->name);
+                devmap_namespace_destroy(namespace);
+                fibril_mutex_unlock(&devices_list_mutex);
+                free(device->name);
+                free(device);
+                async_answer_0(iid, EEXISTS);
                 return;
         }
@@ -401 +562 @@
         /* Get unique device handle */
         device->handle = devmap_create_handle();
-        
+
+        devmap_namespace_addref(namespace, device);
         device->driver = driver;
         
@@ -416 +578 @@
         fibril_mutex_unlock(&devices_list_mutex);
         
-        ipc_answer_1(iid, EOK, device->handle);
+        async_answer_1(iid, EOK, device->handle);
 }
 
@@ -437 +599 @@
 static void devmap_forward(ipc_callid_t callid, ipc_call_t *call)
 {
+        fibril_mutex_lock(&devices_list_mutex);
+        
         /*
          * Get handle from request
          */
-        dev_handle_t handle = IPC_GET_ARG2(*call);
+        devmap_handle_t handle = IPC_GET_ARG2(*call);
         devmap_device_t *dev = devmap_device_find_handle(handle);
         
         if ((dev == NULL) || (dev->driver == NULL) || (dev->driver->phone == 0)) {
-                ipc_answer_0(callid, ENOENT);
-                return;
-        }
-        
-        ipc_forward_fast(callid, dev->driver->phone, dev->handle,
-            IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
+                fibril_mutex_unlock(&devices_list_mutex);
+                async_answer_0(callid, ENOENT);
+                return;
+        }
+        
+        if (dev->forward_interface == 0) {
+                async_forward_fast(callid, dev->driver->phone,
+                    dev->handle, 0, 0,
+                    IPC_FF_NONE);
+        } else {
+                async_forward_fast(callid, dev->driver->phone,
+                    dev->forward_interface, dev->handle, 0,
+                    IPC_FF_NONE);
+        }
+        
+        fibril_mutex_unlock(&devices_list_mutex);
 }
 
@@ -458 +632 @@
  *
  */
-static void devmap_get_handle(ipc_callid_t iid, ipc_call_t *icall)
-{
-        /*
-         * Wait for incoming message with device name (but do not
-         * read the name itself until the buffer is allocated).
-         */
-        ipc_callid_t callid;
-        size_t size;
-        if (!ipc_data_write_receive(&callid, &size)) {
-                ipc_answer_0(callid, EREFUSED);
-                ipc_answer_0(iid, EREFUSED);
-                return;
-        }
-        
-        if ((size < 1) || (size > DEVMAP_NAME_MAXLEN)) {
-                ipc_answer_0(callid, EINVAL);
-                ipc_answer_0(iid, EREFUSED);
-                return;
-        }
-        
-        /*
-         * Allocate buffer for device name.
-         */
-        char *name = (char *) malloc(size + 1);
-        if (name == NULL) {
-                ipc_answer_0(callid, ENOMEM);
-                ipc_answer_0(iid, EREFUSED);
-                return;
-        }
-        
-        /*
-         * Send confirmation to sender and get data into buffer.
-         */
-        ipcarg_t retval = ipc_data_write_finalize(callid, name, size);
-        if (retval != EOK) {
-                ipc_answer_0(iid, EREFUSED);
-                free(name);
-                return;
-        }
-        name[size] = '\0';
+static void devmap_device_get_handle(ipc_callid_t iid, ipc_call_t *icall)
+{
+        char *fqdn;
+        
+        /* Get fqdn */
+        int rc = async_data_write_accept((void **) &fqdn, true, 0,
+            DEVMAP_NAME_MAXLEN, 0, NULL);
+        if (rc != EOK) {
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        char *ns_name;
+        char *name;
+        if (!devmap_fqdn_split(fqdn, &ns_name, &name)) {
+                free(fqdn);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        free(fqdn);
         
         fibril_mutex_lock(&devices_list_mutex);
         const devmap_device_t *dev;
+        
 recheck:
-
+        
         /*
          * Find device name in the list of known devices.
          */
-        dev = devmap_device_find_name(name);
+        dev = devmap_device_find_name(ns_name, name);
         
         /*
@@ -519 +675 @@
                 }
                 
-                ipc_answer_0(iid, ENOENT);
+                async_answer_0(iid, ENOENT);
+                free(ns_name);
                 free(name);
                 fibril_mutex_unlock(&devices_list_mutex);
                 return;
         }
+        
+        async_answer_1(iid, EOK, dev->handle);
+        
         fibril_mutex_unlock(&devices_list_mutex);
-        
-        ipc_answer_1(iid, EOK, dev->handle);
+        free(ns_name);
         free(name);
 }
 
-/** Find name of device identified by id and send it to caller.
- *
- */
-static void devmap_get_name(ipc_callid_t iid, ipc_call_t *icall)
-{
-        const devmap_device_t *device = devmap_device_find_handle(IPC_GET_ARG1(*icall));
+/** Find handle for namespace identified by name.
+ *
+ * In answer will be send EOK and device handle in arg1 or a error
+ * code from errno.h.
+ *
+ */
+static void devmap_namespace_get_handle(ipc_callid_t iid, ipc_call_t *icall)
+{
+        char *name;
+        
+        /* Get device name */
+        int rc = async_data_write_accept((void **) &name, true, 0,
+            DEVMAP_NAME_MAXLEN, 0, NULL);
+        if (rc != EOK) {
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        fibril_mutex_lock(&devices_list_mutex);
+        const devmap_namespace_t *namespace;
+        
+recheck:
         
         /*
-         * Device not found.
-         */
-        if (device == NULL) {
-                ipc_answer_0(iid, ENOENT);
-                return;
-        }
-        
-        ipc_answer_0(iid, EOK);
-        
-        /* FIXME:
-         * We have no channel from DEVMAP to client, therefore
-         * sending must be initiated by client.
-         *
-         * size_t name_size = str_size(device->name);
-         *
-         * int rc = ipc_data_write_send(phone, device->name, name_size);
-         * if (rc != EOK) {
-         *     async_wait_for(req, NULL);
-         *     return rc;
-         * }
-         */
-        
-        /* TODO: send name in response */
-}
-
-static void devmap_get_count(ipc_callid_t iid, ipc_call_t *icall)
+         * Find namespace name in the list of known namespaces.
+         */
+        namespace = devmap_namespace_find_name(name);
+        
+        /*
+         * Namespace was not found.
+         */
+        if (namespace == NULL) {
+                if (IPC_GET_ARG1(*icall) & IPC_FLAG_BLOCKING) {
+                        /* Blocking lookup */
+                        fibril_condvar_wait(&devices_list_cv,
+                            &devices_list_mutex);
+                        goto recheck;
+                }
+                
+                async_answer_0(iid, ENOENT);
+                free(name);
+                fibril_mutex_unlock(&devices_list_mutex);
+                return;
+        }
+        
+        async_answer_1(iid, EOK, namespace->handle);
+        
+        fibril_mutex_unlock(&devices_list_mutex);
+        free(name);
+}
+
+static void devmap_handle_probe(ipc_callid_t iid, ipc_call_t *icall)
 {
         fibril_mutex_lock(&devices_list_mutex);
-        ipc_answer_1(iid, EOK, list_count(&devices_list));
+        
+        devmap_namespace_t *namespace =
+            devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
+        if (namespace == NULL) {
+                devmap_device_t *dev =
+                    devmap_device_find_handle(IPC_GET_ARG1(*icall));
+                if (dev == NULL)
+                        async_answer_1(iid, EOK, DEV_HANDLE_NONE);
+                else
+                        async_answer_1(iid, EOK, DEV_HANDLE_DEVICE);
+        } else
+                async_answer_1(iid, EOK, DEV_HANDLE_NAMESPACE);
+        
         fibril_mutex_unlock(&devices_list_mutex);
 }
 
-static void devmap_get_devices(ipc_callid_t iid, ipc_call_t *icall)
+static void devmap_get_namespace_count(ipc_callid_t iid, ipc_call_t *icall)
 {
         fibril_mutex_lock(&devices_list_mutex);
-        
+        async_answer_1(iid, EOK, list_count(&namespaces_list));
+        fibril_mutex_unlock(&devices_list_mutex);
+}
+
+static void devmap_get_device_count(ipc_callid_t iid, ipc_call_t *icall)
+{
+        fibril_mutex_lock(&devices_list_mutex);
+        
+        devmap_namespace_t *namespace =
+            devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
+        if (namespace == NULL)
+                async_answer_0(iid, EEXISTS);
+        else
+                async_answer_1(iid, EOK, namespace->refcnt);
+        
+        fibril_mutex_unlock(&devices_list_mutex);
+}
+
+static void devmap_get_namespaces(ipc_callid_t iid, ipc_call_t *icall)
+{
         ipc_callid_t callid;
         size_t size;
-        if (!ipc_data_read_receive(&callid, &size)) {
-                ipc_answer_0(callid, EREFUSED);
-                ipc_answer_0(iid, EREFUSED);
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
                 return;
         }
         
         if ((size % sizeof(dev_desc_t)) != 0) {
-                ipc_answer_0(callid, EINVAL);
-                ipc_answer_0(iid, EREFUSED);
-                return;
-        }
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        fibril_mutex_lock(&devices_list_mutex);
         
         size_t count = size / sizeof(dev_desc_t);
+        if (count != list_count(&namespaces_list)) {
+                fibril_mutex_unlock(&devices_list_mutex);
+                async_answer_0(callid, EOVERFLOW);
+                async_answer_0(iid, EOVERFLOW);
+                return;
+        }
+        
         dev_desc_t *desc = (dev_desc_t *) malloc(size);
         if (desc == NULL) {
-                ipc_answer_0(callid, ENOMEM);
-                ipc_answer_0(iid, EREFUSED);
-                return;
-        }
-        
+                fibril_mutex_unlock(&devices_list_mutex);
+                async_answer_0(callid, ENOMEM);
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+        
+        link_t *item;
         size_t pos = 0;
-        link_t *item = devices_list.next;
-        
-        while ((item != &devices_list) && (pos < count)) {
-                devmap_device_t *device = list_get_instance(item, devmap_device_t, devices);
+        for (item = namespaces_list.next; item != &namespaces_list;
+            item = item->next) {
+                devmap_namespace_t *namespace =
+                    list_get_instance(item, devmap_namespace_t, namespaces);
                 
-                desc[pos].handle = device->handle;
-                str_cpy(desc[pos].name, DEVMAP_NAME_MAXLEN, device->name);
+                desc[pos].handle = namespace->handle;
+                str_cpy(desc[pos].name, DEVMAP_NAME_MAXLEN, namespace->name);
                 pos++;
-                item = item->next;
-        }
-        
-        ipcarg_t retval = ipc_data_read_finalize(callid, desc, pos * sizeof(dev_desc_t));
-        if (retval != EOK) {
-                ipc_answer_0(iid, EREFUSED);
-                free(desc);
-                return;
-        }
+        }
+        
+        sysarg_t retval = async_data_read_finalize(callid, desc, size);
         
         free(desc);
-        
         fibril_mutex_unlock(&devices_list_mutex);
         
-        ipc_answer_1(iid, EOK, pos);
+        async_answer_0(iid, retval);
+}
+
+static void devmap_get_devices(ipc_callid_t iid, ipc_call_t *icall)
+{
+        /* FIXME: Use faster algorithm which can make better use
+           of namespaces */
+        
+        ipc_callid_t callid;
+        size_t size;
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        if ((size % sizeof(dev_desc_t)) != 0) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        fibril_mutex_lock(&devices_list_mutex);
+        
+        devmap_namespace_t *namespace =
+            devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
+        if (namespace == NULL) {
+                fibril_mutex_unlock(&devices_list_mutex);
+                async_answer_0(callid, ENOENT);
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        size_t count = size / sizeof(dev_desc_t);
+        if (count != namespace->refcnt) {
+                fibril_mutex_unlock(&devices_list_mutex);
+                async_answer_0(callid, EOVERFLOW);
+                async_answer_0(iid, EOVERFLOW);
+                return;
+        }
+        
+        dev_desc_t *desc = (dev_desc_t *) malloc(size);
+        if (desc == NULL) {
+                fibril_mutex_unlock(&devices_list_mutex);
+                async_answer_0(callid, ENOMEM);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        link_t *item;
+        size_t pos = 0;
+        for (item = devices_list.next; item != &devices_list; item = item->next) {
+                devmap_device_t *device =
+                    list_get_instance(item, devmap_device_t, devices);
+                
+                if (device->namespace == namespace) {
+                        desc[pos].handle = device->handle;
+                        str_cpy(desc[pos].name, DEVMAP_NAME_MAXLEN, device->name);
+                        pos++;
+                }
+        }
+        
+        sysarg_t retval = async_data_read_finalize(callid, desc, size);
+        
+        free(desc);
+        fibril_mutex_unlock(&devices_list_mutex);
+        
+        async_answer_0(iid, retval);
 }
 
@@ -638 +917 @@
         if (!fnd) {
                 fibril_mutex_unlock(&null_devices_mutex);
-                ipc_answer_0(iid, ENOMEM);
-                return;
-        }
-        
-        /* Create NULL device entry */
-        devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+        
+        char null[DEVMAP_NAME_MAXLEN];
+        snprintf(null, DEVMAP_NAME_MAXLEN, "%u", i);
+        
+        char *dev_name = str_dup(null);
+        if (dev_name == NULL) {
+                fibril_mutex_unlock(&null_devices_mutex);
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+        
+        devmap_device_t *device =
+            (devmap_device_t *) malloc(sizeof(devmap_device_t));
         if (device == NULL) {
                 fibril_mutex_unlock(&null_devices_mutex);
-                ipc_answer_0(iid, ENOMEM);
-                return;
-        }
-        
-        char null[DEVMAP_NAME_MAXLEN];
-        snprintf(null, DEVMAP_NAME_MAXLEN, "null%u", i);
-        
-        device->name = str_dup(null);
-        if (device->name == NULL) {
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+        
+        fibril_mutex_lock(&devices_list_mutex);
+        
+        devmap_namespace_t *namespace = devmap_namespace_create("null");
+        if (namespace == NULL) {
+                fibril_mutex_lock(&devices_list_mutex);
                 fibril_mutex_unlock(&null_devices_mutex);
-                free(device);
-                ipc_answer_0(iid, ENOMEM);
-                return;
-        }
-        
-        list_initialize(&(device->devices));
-        list_initialize(&(device->driver_devices));
-        
-        fibril_mutex_lock(&devices_list_mutex);
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+        
+        link_initialize(&device->devices);
+        link_initialize(&device->driver_devices);
         
         /* Get unique device handle */
@@ -670 +956 @@
         device->driver = NULL;
         
-        /* Insert device into list of all devices
-           and into null devices array */
+        devmap_namespace_addref(namespace, device);
+        device->name = dev_name;
+        
+        /*
+         * Insert device into list of all devices and into null devices array.
+         * Insert device into a dummy list of null driver's devices so that it
+         * can be safely removed later.
+         */
         list_append(&device->devices, &devices_list);
+        list_append(&device->driver_devices, &dummy_null_driver_devices);
         null_devices[i] = device;
         
@@ -678 +971 @@
         fibril_mutex_unlock(&null_devices_mutex);
         
-        ipc_answer_1(iid, EOK, (ipcarg_t) i);
+        async_answer_1(iid, EOK, (sysarg_t) i);
 }
 
 static void devmap_null_destroy(ipc_callid_t iid, ipc_call_t *icall)
 {
+        sysarg_t i = IPC_GET_ARG1(*icall);
+        if (i >= NULL_DEVICES) {
+                async_answer_0(iid, ELIMIT);
+                return;
+        }
+        
         fibril_mutex_lock(&null_devices_mutex);
         
-        ipcarg_t i = IPC_GET_ARG1(*icall);
-        
         if (null_devices[i] == NULL) {
-                ipc_answer_0(iid, ENOENT);
-                return;
-        }
-        
+                fibril_mutex_unlock(&null_devices_mutex);
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        fibril_mutex_lock(&devices_list_mutex);
         devmap_device_unregister_core(null_devices[i]);
+        fibril_mutex_unlock(&devices_list_mutex);
+        
         null_devices[i] = NULL;
         
         fibril_mutex_unlock(&null_devices_mutex);
-        
-        ipc_answer_0(iid, EOK);
+        async_answer_0(iid, EOK);
 }
 
@@ -723 +1023 @@
 {
         /* Accept connection */
-        ipc_answer_0(iid, EOK);
-        
-        devmap_driver_t *driver = NULL;
-        devmap_driver_register(&driver);
-        
-        if (NULL == driver)
+        async_answer_0(iid, EOK);
+        
+        devmap_driver_t *driver = devmap_driver_register();
+        if (driver == NULL)
                 return;
         
@@ -736 +1034 @@
                 ipc_callid_t callid = async_get_call(&call);
                 
-                switch (IPC_GET_METHOD(call)) {
+                switch (IPC_GET_IMETHOD(call)) {
                 case IPC_M_PHONE_HUNGUP:
                         cont = false;
@@ -742 +1040 @@
                 case DEVMAP_DRIVER_UNREGISTER:
                         if (NULL == driver)
-                                ipc_answer_0(callid, ENOENT);
+                                async_answer_0(callid, ENOENT);
                         else
-                                ipc_answer_0(callid, EOK);
+                                async_answer_0(callid, EOK);
                         break;
                 case DEVMAP_DEVICE_REGISTER:
@@ -755 +1053 @@
                         break;
                 case DEVMAP_DEVICE_GET_HANDLE:
-                        devmap_get_handle(callid, &call);
-                        break;
-                case DEVMAP_DEVICE_GET_NAME:
-                        devmap_get_name(callid, &call);
+                        devmap_device_get_handle(callid, &call);
+                        break;
+                case DEVMAP_NAMESPACE_GET_HANDLE:
+                        devmap_namespace_get_handle(callid, &call);
                         break;
                 default:
-                        if (!(callid & IPC_CALLID_NOTIFICATION))
-                                ipc_answer_0(callid, ENOENT);
+                        async_answer_0(callid, ENOENT);
                 }
         }
@@ -781 +1078 @@
 {
         /* Accept connection */
-        ipc_answer_0(iid, EOK);
+        async_answer_0(iid, EOK);
         
         bool cont = true;
@@ -788 +1085 @@
                 ipc_callid_t callid = async_get_call(&call);
                 
-                switch (IPC_GET_METHOD(call)) {
+                switch (IPC_GET_IMETHOD(call)) {
                 case IPC_M_PHONE_HUNGUP:
                         cont = false;
                         continue;
                 case DEVMAP_DEVICE_GET_HANDLE:
-                        devmap_get_handle(callid, &call);
-                        break;
-                case DEVMAP_DEVICE_GET_NAME:
-                        devmap_get_name(callid, &call);
-                        break;
-                case DEVMAP_DEVICE_NULL_CREATE:
+                        devmap_device_get_handle(callid, &call);
+                        break;
+                case DEVMAP_NAMESPACE_GET_HANDLE:
+                        devmap_namespace_get_handle(callid, &call);
+                        break;
+                case DEVMAP_HANDLE_PROBE:
+                        devmap_handle_probe(callid, &call);
+                        break;
+                case DEVMAP_NULL_CREATE:
                         devmap_null_create(callid, &call);
                         break;
-                case DEVMAP_DEVICE_NULL_DESTROY:
+                case DEVMAP_NULL_DESTROY:
                         devmap_null_destroy(callid, &call);
                         break;
-                case DEVMAP_DEVICE_GET_COUNT:
-                        devmap_get_count(callid, &call);
-                        break;
-                case DEVMAP_DEVICE_GET_DEVICES:
+                case DEVMAP_GET_NAMESPACE_COUNT:
+                        devmap_get_namespace_count(callid, &call);
+                        break;
+                case DEVMAP_GET_DEVICE_COUNT:
+                        devmap_get_device_count(callid, &call);
+                        break;
+                case DEVMAP_GET_NAMESPACES:
+                        devmap_get_namespaces(callid, &call);
+                        break;
+                case DEVMAP_GET_DEVICES:
                         devmap_get_devices(callid, &call);
                         break;
                 default:
-                        if (!(callid & IPC_CALLID_NOTIFICATION))
-                                ipc_answer_0(callid, ENOENT);
+                        async_answer_0(callid, ENOENT);
                 }
         }
@@ -823 +1128 @@
 {
         /* Select interface */
-        switch ((ipcarg_t) (IPC_GET_ARG1(*icall))) {
+        switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
         case DEVMAP_DRIVER:
                 devmap_connection_driver(iid, icall);
@@ -836 +1141 @@
         default:
                 /* No such interface */
-                ipc_answer_0(iid, ENOENT);
+                async_answer_0(iid, ENOENT);
         }
 }
@@ -845 +1150 @@
 int main(int argc, char *argv[])
 {
-        printf(NAME ": HelenOS Device Mapper\n");
+        printf("%s: HelenOS Device Mapper\n", NAME);
         
         if (!devmap_init()) {
-                printf(NAME ": Error while initializing service\n");
+                printf("%s: Error while initializing service\n", NAME);
                 return -1;
         }
@@ -856 +1161 @@
         
         /* Register device mapper at naming service */
-        ipcarg_t phonead;
-        if (ipc_connect_to_me(PHONE_NS, SERVICE_DEVMAP, 0, 0, &phonead) != 0) 
+        if (service_register(SERVICE_DEVMAP) != EOK)
                 return -1;
         
-        printf(NAME ": Accepting connections\n");
+        printf("%s: Accepting connections\n", NAME);
         async_manager();
         
@@ -867 +1171 @@
 }
 
-/** 
+/**
  * @}
  */