Changeset 903bac0a in mainline for uspace/lib

Timestamp:

2011-08-19T09:00:38Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

e2ab36f1

Parents:

d894fbd (diff), 42a619b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Location:

uspace/lib

Files:

• block/libblock.c (modified) (36 diffs)
• block/libblock.h (modified) (3 diffs)
• c/Makefile (modified) (2 diffs)
• c/generic/devman.c (modified) (5 diffs)
• c/generic/devmap.c (deleted)
• c/generic/io/io.c (modified) (1 diff)
• c/generic/loc.c (added)
• c/generic/vfs/vfs.c (modified) (10 diffs)
• c/include/devman.h (modified) (3 diffs)
• c/include/ipc/devman.h (modified) (3 diffs)
• c/include/ipc/loc.h (moved) (moved from uspace/lib/c/include/ipc/devmap.h ) (2 diffs)
• c/include/ipc/services.h (modified) (1 diff)
• c/include/loc.h (moved) (moved from uspace/lib/c/include/devmap.h ) (1 diff)
• c/include/sys/stat.h (modified) (2 diffs)
• c/include/vfs/vfs.h (modified) (1 diff)
• drv/generic/driver.c (modified) (3 diffs)
• drv/include/ddf/driver.h (modified) (1 diff)
• ext2/libext2_filesystem.c (modified) (3 diffs)
• ext2/libext2_filesystem.h (modified) (2 diffs)
• ext2/libext2_superblock.c (modified) (2 diffs)
• ext2/libext2_superblock.h (modified) (1 diff)
• fs/libfs.c (modified) (33 diffs)
• fs/libfs.h (modified) (4 diffs)
• usb/include/usb/hc.h (modified) (2 diffs)
• usb/include/usb/usb.h (modified) (1 diff)
• usb/src/hc.c (modified) (1 diff)
• usb/src/resolve.c (modified) (2 diffs)

uspace/lib/block/libblock.c

@@ -39 +39 @@
 #include "libblock.h"
 #include "../../srv/vfs/vfs.h"
-#include <ipc/devmap.h>
+#include <ipc/loc.h>
 #include <ipc/bd.h>
 #include <ipc/services.h>
@@ -78 +78 @@
 typedef struct {
         link_t link;
-        devmap_handle_t devmap_handle;
+        service_id_t service_id;
         async_sess_t *sess;
         fibril_mutex_t comm_area_lock;
@@ -95 +95 @@
 static aoff64_t ba_ltop(devcon_t *, aoff64_t);
 
-static devcon_t *devcon_search(devmap_handle_t devmap_handle)
+static devcon_t *devcon_search(service_id_t service_id)
 {
         fibril_mutex_lock(&dcl_lock);
@@ -101 +101 @@
         list_foreach(dcl, cur) {
                 devcon_t *devcon = list_get_instance(cur, devcon_t, link);
-                if (devcon->devmap_handle == devmap_handle) {
+                if (devcon->service_id == service_id) {
                         fibril_mutex_unlock(&dcl_lock);
                         return devcon;
@@ -111 +111 @@
 }
 
-static int devcon_add(devmap_handle_t devmap_handle, async_sess_t *sess,
+static int devcon_add(service_id_t service_id, async_sess_t *sess,
     size_t bsize, void *comm_area, size_t comm_size)
 {
@@ -124 +124 @@
         
         link_initialize(&devcon->link);
-        devcon->devmap_handle = devmap_handle;
+        devcon->service_id = service_id;
         devcon->sess = sess;
         fibril_mutex_initialize(&devcon->comm_area_lock);
@@ -137 +137 @@
         list_foreach(dcl, cur) {
                 devcon_t *d = list_get_instance(cur, devcon_t, link);
-                if (d->devmap_handle == devmap_handle) {
+                if (d->service_id == service_id) {
                         fibril_mutex_unlock(&dcl_lock);
                         free(devcon);
@@ -155 +155 @@
 }
 
-int block_init(exch_mgmt_t mgmt, devmap_handle_t devmap_handle,
+int block_init(exch_mgmt_t mgmt, service_id_t service_id,
     size_t comm_size)
 {
@@ -163 +163 @@
                 return ENOMEM;
         
-        async_sess_t *sess = devmap_device_connect(mgmt, devmap_handle,
+        async_sess_t *sess = loc_service_connect(mgmt, service_id,
             IPC_FLAG_BLOCKING);
         if (!sess) {
@@ -190 +190 @@
         }
         
-        rc = devcon_add(devmap_handle, sess, bsize, comm_area, comm_size);
+        rc = devcon_add(service_id, sess, bsize, comm_area, comm_size);
         if (rc != EOK) {
                 munmap(comm_area, comm_size);
@@ -200 +200 @@
 }
 
-void block_fini(devmap_handle_t devmap_handle)
-{
-        devcon_t *devcon = devcon_search(devmap_handle);
+void block_fini(service_id_t service_id)
+{
+        devcon_t *devcon = devcon_search(service_id);
         assert(devcon);
         
         if (devcon->cache)
-                (void) block_cache_fini(devmap_handle);
+                (void) block_cache_fini(service_id);
         
         devcon_remove(devcon);
@@ -219 +219 @@
 }
 
-int block_bb_read(devmap_handle_t devmap_handle, aoff64_t ba)
+int block_bb_read(service_id_t service_id, aoff64_t ba)
 {
         void *bb_buf;
         int rc;
 
-        devcon_t *devcon = devcon_search(devmap_handle);
+        devcon_t *devcon = devcon_search(service_id);
         if (!devcon)
                 return ENOENT;
@@ -249 +249 @@
 }
 
-void *block_bb_get(devmap_handle_t devmap_handle)
-{
-        devcon_t *devcon = devcon_search(devmap_handle);
+void *block_bb_get(service_id_t service_id)
+{
+        devcon_t *devcon = devcon_search(service_id);
         assert(devcon);
         return devcon->bb_buf;
@@ -277 +277 @@
 };
 
-int block_cache_init(devmap_handle_t devmap_handle, size_t size, unsigned blocks,
+int block_cache_init(service_id_t service_id, size_t size, unsigned blocks,
     enum cache_mode mode)
 {
-        devcon_t *devcon = devcon_search(devmap_handle);
+        devcon_t *devcon = devcon_search(service_id);
         cache_t *cache;
         if (!devcon)
@@ -315 +315 @@
 }
 
-int block_cache_fini(devmap_handle_t devmap_handle)
-{
-        devcon_t *devcon = devcon_search(devmap_handle);
+int block_cache_fini(service_id_t service_id)
+{
+        devcon_t *devcon = devcon_search(service_id);
         cache_t *cache;
         int rc;
@@ -387 +387 @@
  * @param block                 Pointer to where the function will store the
  *                              block pointer on success.
- * @param devmap_handle         Device handle of the block device.
+ * @param service_id            Service ID of the block device.
  * @param ba                    Block address (logical).
  * @param flags                 If BLOCK_FLAGS_NOREAD is specified, block_get()
@@ -395 +395 @@
  * @return                      EOK on success or a negative error code.
  */
-int block_get(block_t **block, devmap_handle_t devmap_handle, aoff64_t ba, int flags)
+int block_get(block_t **block, service_id_t service_id, aoff64_t ba, int flags)
 {
         devcon_t *devcon;
@@ -408 +408 @@
         int rc;
         
-        devcon = devcon_search(devmap_handle);
+        devcon = devcon_search(service_id);
 
         assert(devcon);
@@ -536 +536 @@
 
                 block_initialize(b);
-                b->devmap_handle = devmap_handle;
+                b->service_id = service_id;
                 b->size = cache->lblock_size;
                 b->lba = ba;
@@ -586 +586 @@
 int block_put(block_t *block)
 {
-        devcon_t *devcon = devcon_search(block->devmap_handle);
+        devcon_t *devcon = devcon_search(block->service_id);
         cache_t *cache;
         unsigned blocks_cached;
@@ -687 +687 @@
 /** Read sequential data from a block device.
  *
- * @param devmap_handle Device handle of the block device.
+ * @param service_id    Service ID of the block device.
  * @param bufpos        Pointer to the first unread valid offset within the
  *                      communication buffer.
@@ -699 +699 @@
  * @return              EOK on success or a negative return code on failure.
  */
-int block_seqread(devmap_handle_t devmap_handle, size_t *bufpos, size_t *buflen,
+int block_seqread(service_id_t service_id, size_t *bufpos, size_t *buflen,
     aoff64_t *pos, void *dst, size_t size)
 {
@@ -707 +707 @@
         devcon_t *devcon;
 
-        devcon = devcon_search(devmap_handle);
+        devcon = devcon_search(service_id);
         assert(devcon);
         block_size = devcon->pblock_size;
@@ -753 +753 @@
 /** Read blocks directly from device (bypass cache).
  *
- * @param devmap_handle Device handle of the block device.
+ * @param service_id    Service ID of the block device.
  * @param ba            Address of first block (physical).
  * @param cnt           Number of blocks.
@@ -760 +760 @@
  * @return              EOK on success or negative error code on failure.
  */
-int block_read_direct(devmap_handle_t devmap_handle, aoff64_t ba, size_t cnt, void *buf)
+int block_read_direct(service_id_t service_id, aoff64_t ba, size_t cnt, void *buf)
 {
         devcon_t *devcon;
         int rc;
 
-        devcon = devcon_search(devmap_handle);
+        devcon = devcon_search(service_id);
         assert(devcon);
         
@@ -781 +781 @@
 /** Write blocks directly to device (bypass cache).
  *
- * @param devmap_handle Device handle of the block device.
+ * @param service_id    Service ID of the block device.
  * @param ba            Address of first block (physical).
  * @param cnt           Number of blocks.
@@ -788 +788 @@
  * @return              EOK on success or negative error code on failure.
  */
-int block_write_direct(devmap_handle_t devmap_handle, aoff64_t ba, size_t cnt,
+int block_write_direct(service_id_t service_id, aoff64_t ba, size_t cnt,
     const void *data)
 {
@@ -794 +794 @@
         int rc;
 
-        devcon = devcon_search(devmap_handle);
+        devcon = devcon_search(service_id);
         assert(devcon);
         
@@ -809 +809 @@
 /** Get device block size.
  *
- * @param devmap_handle Device handle of the block device.
+ * @param service_id    Service ID of the block device.
  * @param bsize         Output block size.
  *
  * @return              EOK on success or negative error code on failure.
  */
-int block_get_bsize(devmap_handle_t devmap_handle, size_t *bsize)
+int block_get_bsize(service_id_t service_id, size_t *bsize)
 {
         devcon_t *devcon;
 
-        devcon = devcon_search(devmap_handle);
+        devcon = devcon_search(service_id);
         assert(devcon);
         
@@ -826 +826 @@
 /** Get number of blocks on device.
  *
- * @param devmap_handle Device handle of the block device.
+ * @param service_id    Service ID of the block device.
  * @param nblocks       Output number of blocks.
  *
  * @return              EOK on success or negative error code on failure.
  */
-int block_get_nblocks(devmap_handle_t devmap_handle, aoff64_t *nblocks)
-{
-        devcon_t *devcon = devcon_search(devmap_handle);
+int block_get_nblocks(service_id_t service_id, aoff64_t *nblocks)
+{
+        devcon_t *devcon = devcon_search(service_id);
         assert(devcon);
         
@@ -841 +841 @@
 /** Read bytes directly from the device (bypass cache)
  * 
- * @param devmap_handle Device handle of the block device.
+ * @param service_id    Service ID of the block device.
  * @param abs_offset    Absolute offset in bytes where to start reading
  * @param bytes                 Number of bytes to read
@@ -848 +848 @@
  * @return              EOK on success or negative error code on failure.
  */
-int block_read_bytes_direct(devmap_handle_t devmap_handle, aoff64_t abs_offset,
+int block_read_bytes_direct(service_id_t service_id, aoff64_t abs_offset,
     size_t bytes, void *data)
 {
@@ -860 +860 @@
         size_t offset;
         
-        rc = block_get_bsize(devmap_handle, &phys_block_size);
+        rc = block_get_bsize(service_id, &phys_block_size);
         if (rc != EOK) {
                 return rc;
@@ -878 +878 @@
         }
         
-        rc = block_read_direct(devmap_handle, first_block, blocks, buffer);
+        rc = block_read_direct(service_id, first_block, blocks, buffer);
         if (rc != EOK) {
                 free(buffer);
@@ -912 +912 @@
                 printf("Error %d reading %zu blocks starting at block %" PRIuOFF64
                     " from device handle %" PRIun "\n", rc, cnt, ba,
-                    devcon->devmap_handle);
+                    devcon->service_id);
 #ifndef NDEBUG
                 stacktrace_print();
@@ -941 +941 @@
         if (rc != EOK) {
                 printf("Error %d writing %zu blocks starting at block %" PRIuOFF64
-                    " to device handle %" PRIun "\n", rc, cnt, ba, devcon->devmap_handle);
+                    " to device handle %" PRIun "\n", rc, cnt, ba, devcon->service_id);
 #ifndef NDEBUG
                 stacktrace_print();

uspace/lib/block/libblock.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2008 Jakub Jermar
- * Copyright (c) 2008 Martin Decky 
- * Copyright (c) 2011 Martin Sucha 
+ * Copyright (c) 2008 Martin Decky
+ * Copyright (c) 2011 Martin Sucha
  * All rights reserved.
  *
@@ -73 +73 @@
         /** Readers / Writer lock protecting the contents of the block. */
         fibril_rwlock_t contents_lock;
-        /** Handle of the device where the block resides. */
-        devmap_handle_t devmap_handle;
+        /** Service ID of service providing the block device. */
+        service_id_t service_id;
         /** Logical block address */
         aoff64_t lba;
@@ -97 +97 @@
 };
 
-extern int block_init(exch_mgmt_t, devmap_handle_t, size_t);
-extern void block_fini(devmap_handle_t);
+extern int block_init(exch_mgmt_t, service_id_t, size_t);
+extern void block_fini(service_id_t);
 
-extern int block_bb_read(devmap_handle_t, aoff64_t);
-extern void *block_bb_get(devmap_handle_t);
+extern int block_bb_read(service_id_t, aoff64_t);
+extern void *block_bb_get(service_id_t);
 
-extern int block_cache_init(devmap_handle_t, size_t, unsigned, enum cache_mode);
-extern int block_cache_fini(devmap_handle_t);
+extern int block_cache_init(service_id_t, size_t, unsigned, enum cache_mode);
+extern int block_cache_fini(service_id_t);
 
-extern int block_get(block_t **, devmap_handle_t, aoff64_t, int);
+extern int block_get(block_t **, service_id_t, aoff64_t, int);
 extern int block_put(block_t *);
 
-extern int block_seqread(devmap_handle_t, size_t *, size_t *, aoff64_t *, void *,
+extern int block_seqread(service_id_t, size_t *, size_t *, aoff64_t *, void *,
     size_t);
 
-extern int block_get_bsize(devmap_handle_t, size_t *);
-extern int block_get_nblocks(devmap_handle_t, aoff64_t *);
-extern int block_read_direct(devmap_handle_t, aoff64_t, size_t, void *);
-extern int block_read_bytes_direct(devmap_handle_t, aoff64_t, size_t, void *);
-extern int block_write_direct(devmap_handle_t, aoff64_t, size_t, const void *);
+extern int block_get_bsize(service_id_t, size_t *);
+extern int block_get_nblocks(service_id_t, aoff64_t *);
+extern int block_read_direct(service_id_t, aoff64_t, size_t, void *);
+extern int block_read_bytes_direct(service_id_t, aoff64_t, size_t, void *);
+extern int block_write_direct(service_id_t, aoff64_t, size_t, const void *);
 
 #endif

uspace/lib/c/Makefile

@@ -64 +64 @@
         generic/cap.c \
         generic/clipboard.c \
-        generic/devmap.c \
         generic/devman.c \
         generic/device/hw_res.c \
@@ -71 +70 @@
         generic/event.c \
         generic/errno.c \
+        generic/loc.c \
         generic/mem.c \
         generic/str.c \

uspace/lib/c/generic/devman.c

@@ -271 +271 @@
 }
 
-int devman_add_device_to_class(devman_handle_t devman_handle,
-    const char *class_name)
+int devman_add_device_to_category(devman_handle_t devman_handle,
+    const char *cat_name)
 {
         async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
         
         ipc_call_t answer;
-        aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CLASS,
+        aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CATEGORY,
             devman_handle, &answer);
-        sysarg_t retval = async_data_write_start(exch, class_name,
-            str_size(class_name));
+        sysarg_t retval = async_data_write_start(exch, cat_name,
+            str_size(cat_name));
         
         devman_exchange_end(exch);
@@ -308 +308 @@
 }
 
+/** Remove function from device.
+ *
+ * Request devman to remove function owned by this driver task.
+ * @param funh      Devman handle of the function
+ *
+ * @return EOK on success or negative error code.
+ */
+int devman_remove_function(devman_handle_t funh)
+{
+        async_exch_t *exch;
+        sysarg_t retval;
+        
+        exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
+        retval = async_req_1_0(exch, DEVMAN_REMOVE_FUNCTION, (sysarg_t) funh);
+        devman_exchange_end(exch);
+        
+        return (int) retval;
+}
+
 async_sess_t *devman_parent_device_connect(exch_mgmt_t mgmt,
     devman_handle_t handle, unsigned int flags)
@@ -333 +352 @@
                 exch = devman_exchange_begin(DEVMAN_CLIENT);
                 if (exch == NULL)
-                        return errno;
+                        return ENOMEM;
         }
         
@@ -364 +383 @@
 }
 
-int devman_device_get_handle_by_class(const char *classname,
-    const char *devname, devman_handle_t *handle, unsigned int flags)
-{
-        async_exch_t *exch;
-        
-        if (flags & IPC_FLAG_BLOCKING)
-                exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
-        else {
-                exch = devman_exchange_begin(DEVMAN_CLIENT);
-                if (exch == NULL)
-                        return errno;
-        }
-        
-        ipc_call_t answer;
-        aid_t req = async_send_1(exch, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
-            flags, &answer);
-        sysarg_t retval = async_data_write_start(exch, classname,
-            str_size(classname));
-        
-        if (retval != EOK) {
-                devman_exchange_end(exch);
-                async_wait_for(req, NULL);
-                return retval;
-        }
-        
-        retval = async_data_write_start(exch, devname,
-            str_size(devname));
-        
-        devman_exchange_end(exch);
-        
-        if (retval != EOK) {
-                async_wait_for(req, NULL);
-                return retval;
-        }
-        
-        async_wait_for(req, &retval);
-        
-        if (retval != EOK) {
-                if (handle != NULL)
-                        *handle = (devman_handle_t) -1;
-                
-                return retval;
-        }
-        
-        if (handle != NULL)
-                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
-        
-        return retval;
-}
-
 int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size)
 {
         async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
         if (exch == NULL)
-                return errno;
+                return ENOMEM;
         
         ipc_call_t answer;
@@ -463 +432 @@
 }
 
+int devman_fun_sid_to_handle(service_id_t sid, devman_handle_t *handle)
+{
+        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+        if (exch == NULL)
+                return ENOMEM;
+        
+        sysarg_t retval = async_req_1_1(exch, DEVMAN_FUN_SID_TO_HANDLE,
+            sid, handle);
+        
+        devman_exchange_end(exch);
+        return (int) retval;
+}
+
 /** @}
  */

uspace/lib/c/generic/io/io.c

@@ -45 +45 @@
 #include <vfs/vfs.h>
 #include <vfs/vfs_sess.h>
-#include <ipc/devmap.h>
+#include <ipc/loc.h>
 #include <adt/list.h>
 #include "../private/io.h"

uspace/lib/c/generic/vfs/vfs.c

@@ -51 +51 @@
 #include <assert.h>
 #include <str.h>
-#include <devmap.h>
+#include <loc.h>
 #include <ipc/vfs.h>
-#include <ipc/devmap.h>
+#include <ipc/loc.h>
 
 static FIBRIL_MUTEX_INITIALIZE(vfs_mutex);
@@ -142 +142 @@
 }
 
-int mount(const char *fs_name, const char *mp, const char *fqdn,
+int mount(const char *fs_name, const char *mp, const char *fqsn,
     const char *opts, unsigned int flags)
 {
         int null_id = -1;
-        char null[DEVMAP_NAME_MAXLEN];
-        
-        if (str_cmp(fqdn, "") == 0) {
+        char null[LOC_NAME_MAXLEN];
+        
+        if (str_cmp(fqsn, "") == 0) {
                 /* No device specified, create a fresh
                    null/%d device instead */
-                null_id = devmap_null_create();
+                null_id = loc_null_create();
                 
                 if (null_id == -1)
                         return ENOMEM;
                 
-                snprintf(null, DEVMAP_NAME_MAXLEN, "null/%d", null_id);
-                fqdn = null;
-        }
-        
-        devmap_handle_t devmap_handle;
-        int res = devmap_device_get_handle(fqdn, &devmap_handle, flags);
+                snprintf(null, LOC_NAME_MAXLEN, "null/%d", null_id);
+                fqsn = null;
+        }
+        
+        service_id_t service_id;
+        int res = loc_service_get_id(fqsn, &service_id, flags);
         if (res != EOK) {
                 if (null_id != -1)
-                        devmap_null_destroy(null_id);
+                        loc_null_destroy(null_id);
                 
                 return res;
@@ -173 +173 @@
         if (!mpa) {
                 if (null_id != -1)
-                        devmap_null_destroy(null_id);
+                        loc_null_destroy(null_id);
                 
                 return ENOMEM;
@@ -181 +181 @@
 
         sysarg_t rc_orig;
-        aid_t req = async_send_2(exch, VFS_IN_MOUNT, devmap_handle, flags, NULL);
+        aid_t req = async_send_2(exch, VFS_IN_MOUNT, service_id, flags, NULL);
         sysarg_t rc = async_data_write_start(exch, (void *) mpa, mpa_size);
         if (rc != EOK) {
@@ -189 +189 @@
                 
                 if (null_id != -1)
-                        devmap_null_destroy(null_id);
+                        loc_null_destroy(null_id);
                 
                 if (rc_orig == EOK)
@@ -204 +204 @@
                 
                 if (null_id != -1)
-                        devmap_null_destroy(null_id);
+                        loc_null_destroy(null_id);
                 
                 if (rc_orig == EOK)
@@ -219 +219 @@
                 
                 if (null_id != -1)
-                        devmap_null_destroy(null_id);
+                        loc_null_destroy(null_id);
                 
                 if (rc_orig == EOK)
@@ -235 +235 @@
                 
                 if (null_id != -1)
-                        devmap_null_destroy(null_id);
+                        loc_null_destroy(null_id);
                 
                 if (rc_orig == EOK)
@@ -248 +248 @@
         
         if ((rc != EOK) && (null_id != -1))
-                devmap_null_destroy(null_id);
+                loc_null_destroy(null_id);
         
         return (int) rc;
@@ -792 +792 @@
         }
         
-        if (!stat.device) {
+        if (!stat.service) {
                 errno = ENOENT;
                 return NULL;
         }
         
-        return devmap_device_connect(mgmt, stat.device, 0);
+        return loc_service_connect(mgmt, stat.service, 0);
 }
 

uspace/lib/c/include/devman.h

@@ -38 +38 @@
 
 #include <ipc/devman.h>
+#include <ipc/loc.h>
 #include <async.h>
 #include <bool.h>
@@ -48 +49 @@
 extern int devman_add_function(const char *, fun_type_t, match_id_list_t *,
     devman_handle_t, devman_handle_t *);
+extern int devman_remove_function(devman_handle_t);
 
 extern async_sess_t *devman_device_connect(exch_mgmt_t, devman_handle_t,
@@ -56 +58 @@
 extern int devman_device_get_handle(const char *, devman_handle_t *,
     unsigned int);
-extern int devman_device_get_handle_by_class(const char *, const char *,
-    devman_handle_t *, unsigned int);
 extern int devman_get_device_path(devman_handle_t, char *, size_t);
 
-extern int devman_add_device_to_class(devman_handle_t, const char *);
+extern int devman_add_device_to_category(devman_handle_t, const char *);
+extern int devman_fun_sid_to_handle(service_id_t, devman_handle_t *);
 
 #endif

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

@@ -130 +130 @@
         DEVMAN_CLIENT,
         DEVMAN_CONNECT_TO_DEVICE,
-        DEVMAN_CONNECT_FROM_DEVMAP,
+        DEVMAN_CONNECT_FROM_LOC,
         DEVMAN_CONNECT_TO_PARENTS_DEVICE
 } devman_interface_t;
@@ -138 +138 @@
         DEVMAN_ADD_FUNCTION,
         DEVMAN_ADD_MATCH_ID,
-        DEVMAN_ADD_DEVICE_TO_CLASS
-
+        DEVMAN_ADD_DEVICE_TO_CATEGORY,
+        DEVMAN_REMOVE_FUNCTION
 } driver_to_devman_t;
 
@@ -149 +149 @@
 typedef enum {
         DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
-        DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
-        DEVMAN_DEVICE_GET_DEVICE_PATH
+        DEVMAN_DEVICE_GET_DEVICE_PATH,
+        DEVMAN_FUN_SID_TO_HANDLE
 } client_to_devman_t;
 

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2007 Josef Cejka
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -27 +28 @@
  */
 
-/** @addtogroup devmap
+/** @addtogroup loc
  * @{
  */
 
-#ifndef LIBC_IPC_DEVMAP_H_
-#define LIBC_IPC_DEVMAP_H_
+#ifndef LIBC_IPC_LOC_H_
+#define LIBC_IPC_LOC_H_
 
 #include <ipc/common.h>
 
-#define DEVMAP_NAME_MAXLEN  255
+#define LOC_NAME_MAXLEN  255
 
-typedef sysarg_t devmap_handle_t;
+typedef sysarg_t service_id_t;
+typedef sysarg_t category_id_t;
 
 typedef enum {
-        DEV_HANDLE_NONE,
-        DEV_HANDLE_NAMESPACE,
-        DEV_HANDLE_DEVICE
-} devmap_handle_type_t;
+        LOC_OBJECT_NONE,
+        LOC_OBJECT_NAMESPACE,
+        LOC_OBJECT_SERVICE
+} loc_object_type_t;
 
 typedef enum {
-        DEVMAP_DRIVER_REGISTER = IPC_FIRST_USER_METHOD,
-        DEVMAP_DRIVER_UNREGISTER,
-        DEVMAP_DEVICE_REGISTER,
-        DEVMAP_DEVICE_UNREGISTER,
-        DEVMAP_DEVICE_GET_HANDLE,
-        DEVMAP_NAMESPACE_GET_HANDLE,
-        DEVMAP_HANDLE_PROBE,
-        DEVMAP_NULL_CREATE,
-        DEVMAP_NULL_DESTROY,
-        DEVMAP_GET_NAMESPACE_COUNT,
-        DEVMAP_GET_DEVICE_COUNT,
-        DEVMAP_GET_NAMESPACES,
-        DEVMAP_GET_DEVICES
-} devmap_request_t;
+        LOC_SERVER_REGISTER = IPC_FIRST_USER_METHOD,
+        LOC_SERVER_UNREGISTER,
+        LOC_SERVICE_ADD_TO_CAT,
+        LOC_SERVICE_REGISTER,
+        LOC_SERVICE_UNREGISTER,
+        LOC_SERVICE_GET_ID,
+        LOC_SERVICE_GET_NAME,
+        LOC_NAMESPACE_GET_ID,
+        LOC_CALLBACK_CREATE,
+        LOC_CATEGORY_GET_ID,
+        LOC_CATEGORY_GET_NAME,
+        LOC_CATEGORY_GET_SVCS,
+        LOC_ID_PROBE,
+        LOC_NULL_CREATE,
+        LOC_NULL_DESTROY,
+        LOC_GET_NAMESPACE_COUNT,
+        LOC_GET_SERVICE_COUNT,
+        LOC_GET_CATEGORIES,
+        LOC_GET_NAMESPACES,
+        LOC_GET_SERVICES
+} loc_request_t;
 
-/** Interface provided by devmap.
+typedef enum {
+        LOC_EVENT_CAT_CHANGE = IPC_FIRST_USER_METHOD
+} loc_event_t;
+
+/** Ports provided by location service.
  *
- * Every process that connects to devmap must ask one of following
- * interfaces otherwise connection will be refused.
+ * Every process that connects to loc must ask one of following
+ * ports, otherwise connection will be refused.
  *
  */
 typedef enum {
-        /** Connect as device driver */
-        DEVMAP_DRIVER = 1,
-        /** Connect as client */
-        DEVMAP_CLIENT,
+        /** Service supplier (server) port */
+        LOC_PORT_SUPPLIER = 1,
+        /** Service consumer (client) port */
+        LOC_PORT_CONSUMER,
         /** Create new connection to instance of device that
             is specified by second argument of call. */
-        DEVMAP_CONNECT_TO_DEVICE
-} devmap_interface_t;
+        LOC_CONNECT_TO_SERVICE
+} loc_interface_t;
 
 typedef struct {
-        devmap_handle_t handle;
-        char name[DEVMAP_NAME_MAXLEN + 1];
-} dev_desc_t;
+        service_id_t id;
+        char name[LOC_NAME_MAXLEN + 1];
+} loc_sdesc_t;
 
 #endif

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

@@ -45 +45 @@
         SERVICE_VIDEO      = FOURCC('v', 'i', 'd', ' '),
         SERVICE_VFS        = FOURCC('v', 'f', 's', ' '),
-        SERVICE_DEVMAP     = FOURCC('d', 'e', 'v', 'p'),
+        SERVICE_LOC        = FOURCC('l', 'o', 'c', ' '),
         SERVICE_DEVMAN     = FOURCC('d', 'e', 'v', 'n'),
         SERVICE_IRC        = FOURCC('i', 'r', 'c', ' '),

uspace/lib/c/include/loc.h

@@ -33 +33 @@
  */
 
-#ifndef LIBC_DEVMAP_H_
-#define LIBC_DEVMAP_H_
+#ifndef LIBC_LOC_H_
+#define LIBC_LOC_H_
 
-#include <ipc/devmap.h>
+#include <ipc/loc.h>
 #include <async.h>
 #include <bool.h>
 
-extern async_exch_t *devmap_exchange_begin_blocking(devmap_interface_t);
-extern async_exch_t *devmap_exchange_begin(devmap_interface_t);
-extern void devmap_exchange_end(async_exch_t *);
+typedef void (*loc_cat_change_cb_t)(void);
 
-extern int devmap_driver_register(const char *, async_client_conn_t);
-extern int devmap_device_register(const char *, devmap_handle_t *);
-extern int devmap_device_register_with_iface(const char *, devmap_handle_t *,
+extern async_exch_t *loc_exchange_begin_blocking(loc_interface_t);
+extern async_exch_t *loc_exchange_begin(loc_interface_t);
+extern void loc_exchange_end(async_exch_t *);
+
+extern int loc_server_register(const char *, async_client_conn_t);
+extern int loc_service_register(const char *, service_id_t *);
+extern int loc_service_register_with_iface(const char *, service_id_t *,
     sysarg_t);
+extern int loc_service_unregister(service_id_t);
+extern int loc_service_add_to_cat(service_id_t, category_id_t);
 
-extern int devmap_device_get_handle(const char *, devmap_handle_t *,
+extern int loc_service_get_id(const char *, service_id_t *,
     unsigned int);
-extern int devmap_namespace_get_handle(const char *, devmap_handle_t *,
+extern int loc_service_get_name(service_id_t, char **);
+extern int loc_namespace_get_id(const char *, service_id_t *,
     unsigned int);
-extern devmap_handle_type_t devmap_handle_probe(devmap_handle_t);
+extern int loc_category_get_id(const char *, category_id_t *,
+    unsigned int);
+extern int loc_category_get_name(category_id_t, char **);
+extern int loc_category_get_svcs(category_id_t, category_id_t **, size_t *);
+extern loc_object_type_t loc_id_probe(service_id_t);
 
-extern async_sess_t *devmap_device_connect(exch_mgmt_t, devmap_handle_t,
+extern async_sess_t *loc_service_connect(exch_mgmt_t, service_id_t,
     unsigned int);
 
-extern int devmap_null_create(void);
-extern void devmap_null_destroy(int);
+extern int loc_null_create(void);
+extern void loc_null_destroy(int);
 
-extern size_t devmap_count_namespaces(void);
-extern size_t devmap_count_devices(devmap_handle_t);
+extern size_t loc_count_namespaces(void);
+extern size_t loc_count_services(service_id_t);
 
-extern size_t devmap_get_namespaces(dev_desc_t **);
-extern size_t devmap_get_devices(devmap_handle_t, dev_desc_t **);
+extern size_t loc_get_namespaces(loc_sdesc_t **);
+extern size_t loc_get_services(service_id_t, loc_sdesc_t **);
+extern int loc_get_categories(category_id_t **, size_t *);
+extern int loc_register_cat_change_cb(loc_cat_change_cb_t);
+
 
 #endif

uspace/lib/c/include/sys/stat.h

@@ -39 +39 @@
 #include <bool.h>
 #include <ipc/vfs.h>
-#include <ipc/devmap.h>
+#include <ipc/loc.h>
 
 struct stat {
         fs_handle_t fs_handle;
-        devmap_handle_t devmap_handle;
+        service_id_t service_id;
         fs_index_t index;
         unsigned int lnkcnt;
@@ -49 +49 @@
         bool is_directory;
         aoff64_t size;
-        devmap_handle_t device;
+        service_id_t service;
 };
 

uspace/lib/c/include/vfs/vfs.h

@@ -38 +38 @@
 #include <sys/types.h>
 #include <ipc/vfs.h>
-#include <ipc/devmap.h>
+#include <ipc/loc.h>
 #include <stdio.h>
 #include <async.h>

uspace/lib/drv/generic/driver.c

@@ -582 +582 @@
 int ddf_fun_bind(ddf_fun_t *fun)
 {
+        assert(fun->bound == false);
         assert(fun->name != NULL);
         
@@ -598 +599 @@
 }
 
+/** Unbind a function node.
+ *
+ * Unbind the specified function from the system. This effectively makes
+ * the function invisible to the system.
+ *
+ * @param fun           Function to bind
+ * @return              EOK on success or negative error code
+ */
+int ddf_fun_unbind(ddf_fun_t *fun)
+{
+        int res;
+        
+        assert(fun->bound == true);
+        
+        add_to_functions_list(fun);
+        res = devman_remove_function(fun->handle);
+        if (res != EOK)
+                return res;
+
+        remove_from_functions_list(fun);
+        
+        fun->bound = false;
+        return EOK;
+}
+
 /** Add single match ID to inner function.
  *
@@ -635 +661 @@
 }
 
-/** Add exposed function to class.
+/** Add exposed function to category.
  *
  * Must only be called when the function is bound.
  */
-int ddf_fun_add_to_class(ddf_fun_t *fun, const char *class_name)
+int ddf_fun_add_to_category(ddf_fun_t *fun, const char *cat_name)
 {
         assert(fun->bound == true);
         assert(fun->ftype == fun_exposed);
         
-        return devman_add_device_to_class(fun->handle, class_name);
+        return devman_add_device_to_category(fun->handle, cat_name);
 }
 

uspace/lib/drv/include/ddf/driver.h

@@ -149 +149 @@
 extern void ddf_fun_destroy(ddf_fun_t *);
 extern int ddf_fun_bind(ddf_fun_t *);
+extern int ddf_fun_unbind(ddf_fun_t *);
 extern int ddf_fun_add_match_id(ddf_fun_t *, const char *, int);
 
-extern int ddf_fun_add_to_class(ddf_fun_t *, const char *);
+extern int ddf_fun_add_to_category(ddf_fun_t *, const char *);
 
 #endif

uspace/lib/ext2/libext2_filesystem.c

@@ -50 +50 @@
  * 
  * @param fs                    Pointer to ext2_filesystem_t to initialize
- * @param devmap_handle Device handle of the block device
- * 
- * @return              EOK on success or negative error code on failure
- */
-int ext2_filesystem_init(ext2_filesystem_t *fs, devmap_handle_t devmap_handle)
+ * @param service_id    Service ID of the block device
+ * 
+ * @return              EOK on success or negative error code on failure
+ */
+int ext2_filesystem_init(ext2_filesystem_t *fs, service_id_t service_id)
 {
         int rc;
@@ -60 +60 @@
         size_t block_size;
         
-        fs->device = devmap_handle;
+        fs->device = service_id;
         
         rc = block_init(EXCHANGE_SERIALIZE, fs->device, 2048);
@@ -80 +80 @@
         }
         
-        rc = block_cache_init(devmap_handle, block_size, 0, CACHE_MODE_WT);
+        rc = block_cache_init(service_id, block_size, 0, CACHE_MODE_WT);
         if (rc != EOK) {
                 block_fini(fs->device);

uspace/lib/ext2/libext2_filesystem.h

@@ -43 +43 @@
 
 typedef struct ext2_filesystem {
-        devmap_handle_t         device;
+        service_id_t            device;
         ext2_superblock_t *     superblock;
 } ext2_filesystem_t;
@@ -59 +59 @@
 #define EXT2_SUPPORTED_READ_ONLY_FEATURES 0
 
-extern int ext2_filesystem_init(ext2_filesystem_t *, devmap_handle_t);
+extern int ext2_filesystem_init(ext2_filesystem_t *, service_id_t);
 extern int ext2_filesystem_check_sanity(ext2_filesystem_t *);
 extern int ext2_filesystem_check_flags(ext2_filesystem_t *, bool *);

uspace/lib/ext2/libext2_superblock.c

@@ -321 +321 @@
 /** Read a superblock directly from device (i.e. no libblock cache)
  * 
- * @param devmap_handle Device handle of the block device.
+ * @param service_id    Service ID of the block device.
  * @param superblock    Pointer where to store pointer to new superblock
  * 
  * @return              EOK on success or negative error code on failure.
  */
-int ext2_superblock_read_direct(devmap_handle_t devmap_handle,
+int ext2_superblock_read_direct(service_id_t service_id,
     ext2_superblock_t **superblock)
 {
@@ -337 +337 @@
         }
         
-        rc = block_read_bytes_direct(devmap_handle, EXT2_SUPERBLOCK_OFFSET,
+        rc = block_read_bytes_direct(service_id, EXT2_SUPERBLOCK_OFFSET,
             EXT2_SUPERBLOCK_SIZE, data);
         if (rc != EOK) {

uspace/lib/ext2/libext2_superblock.h

@@ -110 +110 @@
 extern uint32_t ext2_superblock_get_features_read_only(ext2_superblock_t *);
 
-extern int ext2_superblock_read_direct(devmap_handle_t, ext2_superblock_t **);
+extern int ext2_superblock_read_direct(service_id_t, ext2_superblock_t **);
 extern int ext2_superblock_check_sanity(ext2_superblock_t *);
 

uspace/lib/fs/libfs.c

@@ -77 +77 @@
 static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
         char *opts;
         int rc;
@@ -91 +91 @@
         aoff64_t size;
         unsigned lnkcnt;
-        rc = vfs_out_ops->mounted(devmap_handle, opts, &index, &size, &lnkcnt);
+        rc = vfs_out_ops->mounted(service_id, opts, &index, &size, &lnkcnt);
 
         if (rc == EOK)
@@ -109 +109 @@
 static void vfs_out_unmounted(ipc_callid_t rid, ipc_call_t *req)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
         int rc; 
 
-        rc = vfs_out_ops->unmounted(devmap_handle);
+        rc = vfs_out_ops->unmounted(service_id);
 
         async_answer_0(rid, rc);
@@ -130 +130 @@
 static void vfs_out_read(ipc_callid_t rid, ipc_call_t *req)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
         aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req),
@@ -137 +137 @@
         int rc;
 
-        rc = vfs_out_ops->read(devmap_handle, index, pos, &rbytes);
+        rc = vfs_out_ops->read(service_id, index, pos, &rbytes);
 
         if (rc == EOK)
@@ -147 +147 @@
 static void vfs_out_write(ipc_callid_t rid, ipc_call_t *req)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
         aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req),
@@ -155 +155 @@
         int rc;
 
-        rc = vfs_out_ops->write(devmap_handle, index, pos, &wbytes, &nsize);
+        rc = vfs_out_ops->write(service_id, index, pos, &wbytes, &nsize);
 
         if (rc == EOK)
@@ -165 +165 @@
 static void vfs_out_truncate(ipc_callid_t rid, ipc_call_t *req)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
         aoff64_t size = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req),
@@ -171 +171 @@
         int rc;
 
-        rc = vfs_out_ops->truncate(devmap_handle, index, size);
+        rc = vfs_out_ops->truncate(service_id, index, size);
 
         async_answer_0(rid, rc);
@@ -178 +178 @@
 static void vfs_out_close(ipc_callid_t rid, ipc_call_t *req)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
         int rc;
 
-        rc = vfs_out_ops->close(devmap_handle, index);
+        rc = vfs_out_ops->close(service_id, index);
 
         async_answer_0(rid, rc);
@@ -189 +189 @@
 static void vfs_out_destroy(ipc_callid_t rid, ipc_call_t *req)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
         int rc;
 
-        rc = vfs_out_ops->destroy(devmap_handle, index);
+        rc = vfs_out_ops->destroy(service_id, index);
 
         async_answer_0(rid, rc);
@@ -210 +210 @@
 static void vfs_out_sync(ipc_callid_t rid, ipc_call_t *req)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
         int rc;
 
-        rc = vfs_out_ops->sync(devmap_handle, index);
+        rc = vfs_out_ops->sync(service_id, index);
 
         async_answer_0(rid, rc);
@@ -380 +380 @@
     ipc_call_t *req)
 {
-        devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
+        service_id_t mp_service_id = (service_id_t) IPC_GET_ARG1(*req);
         fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req);
         fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*req);
-        devmap_handle_t mr_devmap_handle = (devmap_handle_t) IPC_GET_ARG4(*req);
+        service_id_t mr_service_id = (service_id_t) IPC_GET_ARG4(*req);
         
         async_sess_t *mountee_sess = async_clone_receive(EXCHANGE_PARALLEL);
@@ -392 +392 @@
         
         fs_node_t *fn;
-        int res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index);
+        int res = ops->node_get(&fn, mp_service_id, mp_fs_index);
         if ((res != EOK) || (!fn)) {
                 async_hangup(mountee_sess);
@@ -422 +422 @@
         ipc_call_t answer;
         int rc = async_data_write_forward_1_1(exch, VFS_OUT_MOUNTED,
-            mr_devmap_handle, &answer);
+            mr_service_id, &answer);
         async_exchange_end(exch);
         
@@ -428 +428 @@
                 fn->mp_data.mp_active = true;
                 fn->mp_data.fs_handle = mr_fs_handle;
-                fn->mp_data.devmap_handle = mr_devmap_handle;
+                fn->mp_data.service_id = mr_service_id;
                 fn->mp_data.sess = mountee_sess;
         }
@@ -441 +441 @@
 void libfs_unmount(libfs_ops_t *ops, ipc_callid_t rid, ipc_call_t *req)
 {
-        devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
+        service_id_t mp_service_id = (service_id_t) IPC_GET_ARG1(*req);
         fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req);
         fs_node_t *fn;
         int res;
 
-        res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index);
+        res = ops->node_get(&fn, mp_service_id, mp_fs_index);
         if ((res != EOK) || (!fn)) {
                 async_answer_0(rid, combine_rc(res, ENOENT));
@@ -465 +465 @@
          */
         async_exch_t *exch = async_exchange_begin(fn->mp_data.sess);
-        res = async_req_1_0(exch, VFS_OUT_UNMOUNTED, fn->mp_data.devmap_handle);
+        res = async_req_1_0(exch, VFS_OUT_UNMOUNTED, fn->mp_data.service_id);
         async_exchange_end(exch);
 
@@ -475 +475 @@
                 fn->mp_data.mp_active = false;
                 fn->mp_data.fs_handle = 0;
-                fn->mp_data.devmap_handle = 0;
+                fn->mp_data.service_id = 0;
                 fn->mp_data.sess = NULL;
                 
@@ -510 +510 @@
         unsigned int last = IPC_GET_ARG2(*req);
         unsigned int next = first;
-        devmap_handle_t devmap_handle = IPC_GET_ARG3(*req);
+        service_id_t service_id = IPC_GET_ARG3(*req);
         int lflag = IPC_GET_ARG4(*req);
         fs_index_t index = IPC_GET_ARG5(*req);
@@ -524 +524 @@
         fs_node_t *tmp = NULL;
         
-        rc = ops->root_get(&cur, devmap_handle);
+        rc = ops->root_get(&cur, service_id);
         on_error(rc, goto out_with_answer);
         
@@ -530 +530 @@
                 async_exch_t *exch = async_exchange_begin(cur->mp_data.sess);
                 async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, last,
-                    cur->mp_data.devmap_handle, lflag, index,
+                    cur->mp_data.service_id, lflag, index,
                     IPC_FF_ROUTE_FROM_ME);
                 async_exchange_end(exch);
@@ -591 +591 @@
                         async_exch_t *exch = async_exchange_begin(tmp->mp_data.sess);
                         async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next,
-                            last, tmp->mp_data.devmap_handle, lflag, index,
+                            last, tmp->mp_data.service_id, lflag, index,
                             IPC_FF_ROUTE_FROM_ME);
                         async_exchange_end(exch);
@@ -620 +620 @@
                                 fs_node_t *fn;
                                 if (lflag & L_CREATE)
-                                        rc = ops->create(&fn, devmap_handle,
+                                        rc = ops->create(&fn, service_id,
                                             lflag);
                                 else
-                                        rc = ops->node_get(&fn, devmap_handle,
+                                        rc = ops->node_get(&fn, service_id,
                                             index);
                                 on_error(rc, goto out_with_answer);
@@ -638 +638 @@
                                                 aoff64_t size = ops->size_get(fn);
                                                 async_answer_5(rid, fs_handle,
-                                                    devmap_handle,
+                                                    service_id,
                                                     ops->index_get(fn),
                                                     LOWER32(size),
@@ -706 +706 @@
                         fs_node_t *fn;
                         if (lflag & L_CREATE)
-                                rc = ops->create(&fn, devmap_handle, lflag);
+                                rc = ops->create(&fn, service_id, lflag);
                         else
-                                rc = ops->node_get(&fn, devmap_handle, index);
+                                rc = ops->node_get(&fn, service_id, index);
                         on_error(rc, goto out_with_answer);
                         
@@ -722 +722 @@
                                         aoff64_t size = ops->size_get(fn);
                                         async_answer_5(rid, fs_handle,
-                                            devmap_handle,
+                                            service_id,
                                             ops->index_get(fn),
                                             LOWER32(size),
@@ -748 +748 @@
                 if (rc == EOK) {
                         aoff64_t size = ops->size_get(cur);
-                        async_answer_5(rid, fs_handle, devmap_handle,
+                        async_answer_5(rid, fs_handle, service_id,
                             ops->index_get(cur), LOWER32(size), UPPER32(size),
                             old_lnkcnt);
@@ -786 +786 @@
                 if (rc == EOK) {
                         aoff64_t size = ops->size_get(cur);
-                        async_answer_5(rid, fs_handle, devmap_handle,
+                        async_answer_5(rid, fs_handle, service_id,
                             ops->index_get(cur), LOWER32(size), UPPER32(size),
                             ops->lnkcnt_get(cur));
@@ -810 +810 @@
     ipc_call_t *request)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
         
         fs_node_t *fn;
-        int rc = ops->node_get(&fn, devmap_handle, index);
+        int rc = ops->node_get(&fn, service_id, index);
         on_error(rc, answer_and_return(rid, rc));
         
@@ -831 +831 @@
         
         stat.fs_handle = fs_handle;
-        stat.devmap_handle = devmap_handle;
+        stat.service_id = service_id;
         stat.index = index;
         stat.lnkcnt = ops->lnkcnt_get(fn);
@@ -837 +837 @@
         stat.is_directory = ops->is_directory(fn);
         stat.size = ops->size_get(fn);
-        stat.device = ops->device_get(fn);
+        stat.service = ops->device_get(fn);
         
         ops->node_put(fn);
@@ -856 +856 @@
     ipc_call_t *request)
 {
-        devmap_handle_t devmap_handle = IPC_GET_ARG1(*request);
+        service_id_t service_id = IPC_GET_ARG1(*request);
         fs_index_t index = IPC_GET_ARG2(*request);
         
         fs_node_t *fn;
-        int rc = ops->node_get(&fn, devmap_handle, index);
+        int rc = ops->node_get(&fn, service_id, index);
         on_error(rc, answer_and_return(rid, rc));
         

uspace/lib/fs/libfs.h

@@ -40 +40 @@
 #include <stdint.h>
 #include <async.h>
-#include <devmap.h>
+#include <loc.h>
 
 typedef struct {
-        int (* mounted)(devmap_handle_t, const char *, fs_index_t *, aoff64_t *,
+        int (* mounted)(service_id_t, const char *, fs_index_t *, aoff64_t *,
             unsigned *);
-        int (* unmounted)(devmap_handle_t);
-        int (* read)(devmap_handle_t, fs_index_t, aoff64_t, size_t *);
-        int (* write)(devmap_handle_t, fs_index_t, aoff64_t, size_t *,
+        int (* unmounted)(service_id_t);
+        int (* read)(service_id_t, fs_index_t, aoff64_t, size_t *);
+        int (* write)(service_id_t, fs_index_t, aoff64_t, size_t *,
             aoff64_t *);
-        int (* truncate)(devmap_handle_t, fs_index_t, aoff64_t);
-        int (* close)(devmap_handle_t, fs_index_t);
-        int (* destroy)(devmap_handle_t, fs_index_t);
-        int (* sync)(devmap_handle_t, fs_index_t);
+        int (* truncate)(service_id_t, fs_index_t, aoff64_t);
+        int (* close)(service_id_t, fs_index_t);
+        int (* destroy)(service_id_t, fs_index_t);
+        int (* sync)(service_id_t, fs_index_t);
 } vfs_out_ops_t;
 
@@ -59 +59 @@
         async_sess_t *sess;
         fs_handle_t fs_handle;
-        devmap_handle_t devmap_handle;
+        service_id_t service_id;
 } mp_data_t;
 
@@ -73 +73 @@
          * argument holds the output argument.
          */
-        int (* root_get)(fs_node_t **, devmap_handle_t);
+        int (* root_get)(fs_node_t **, service_id_t);
         int (* match)(fs_node_t **, fs_node_t *, const char *);
-        int (* node_get)(fs_node_t **, devmap_handle_t, fs_index_t);
+        int (* node_get)(fs_node_t **, service_id_t, fs_index_t);
         int (* node_open)(fs_node_t *);
         int (* node_put)(fs_node_t *);
-        int (* create)(fs_node_t **, devmap_handle_t, int);
+        int (* create)(fs_node_t **, service_id_t, int);
         int (* destroy)(fs_node_t *);
         int (* link)(fs_node_t *, fs_node_t *, const char *);
@@ -92 +92 @@
         bool (* is_directory)(fs_node_t *);
         bool (* is_file)(fs_node_t *);
-        devmap_handle_t (* device_get)(fs_node_t *);
+        service_id_t (* device_get)(fs_node_t *);
 } libfs_ops_t;
 

uspace/lib/usb/include/usb/hc.h

@@ -38 +38 @@
 #include <sys/types.h>
 #include <ipc/devman.h>
+#include <ipc/loc.h>
 #include <ddf/driver.h>
 #include <bool.h>
@@ -68 +69 @@
     devman_handle_t *);
 
-int usb_ddf_get_hc_handle_by_class(size_t, devman_handle_t *);
+int usb_ddf_get_hc_handle_by_sid(service_id_t, devman_handle_t *);
 
 

uspace/lib/usb/include/usb/usb.h

@@ -174 +174 @@
 } usb_packet_id;
 
-/** Class name for USB host controllers. */
-#define USB_HC_DDF_CLASS_NAME "usbhc"
+/** Category for USB host controllers. */
+#define USB_HC_CATEGORY "usbhc"
 
 #endif

uspace/lib/usb/src/hc.c

@@ -201 +201 @@
 /** Get host controller handle by its class index.
  *
- * @param class_index Class index for the host controller.
+ * @param sid Service ID of the HC function.
  * @param hc_handle Where to store the HC handle
  *      (can be NULL for existence test only).
  * @return Error code.
  */
-int usb_ddf_get_hc_handle_by_class(size_t class_index,
-    devman_handle_t *hc_handle)
-{
-        char *class_index_str;
-        devman_handle_t hc_handle_tmp;
+int usb_ddf_get_hc_handle_by_sid(service_id_t sid, devman_handle_t *hc_handle)
+{
+        devman_handle_t handle;
         int rc;
-
-        rc = asprintf(&class_index_str, "%zu", class_index);
-        if (rc < 0) {
-                return ENOMEM;
-        }
-        rc = devman_device_get_handle_by_class("usbhc", class_index_str,
-            &hc_handle_tmp, 0);
-        free(class_index_str);
-        if (rc != EOK) {
-                return rc;
-        }
-
-        if (hc_handle != NULL) {
-                *hc_handle = hc_handle_tmp;
-        }
-
-        return EOK;
+        
+        rc = devman_fun_sid_to_handle(sid, &handle);
+        if (hc_handle != NULL)
+                *hc_handle = handle;
+        
+        return rc;
 }
 

uspace/lib/usb/src/resolve.c

@@ -46 +46 @@
     devman_handle_t *out_hc_handle, usb_address_t *out_device_address)
 {
-        size_t class_index;
+        uint64_t sid;
         size_t address;
         int rc;
         char *ptr;
 
-        rc = str_size_t(path, &ptr, 10, false, &class_index);
+        rc = str_uint64(path, &ptr, 10, false, &sid);
         if (rc != EOK) {
                 return false;
@@ -64 +64 @@
                 return false;
         }
-        rc = usb_ddf_get_hc_handle_by_class(class_index, out_hc_handle);
+        rc = usb_ddf_get_hc_handle_by_sid(sid, out_hc_handle);
         if (rc != EOK) {
                 return false;