Changeset fb7e5a9a in mainline

Timestamp:

2011-09-06T20:03:31Z (13 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

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

Children:

038b289, f7d6b30

Parents:

7a46bfe (diff), 7e9fce6 (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

Files:

• boot/Makefile.common (modified) (1 diff)
• tools/toolchain.sh (modified) (2 diffs)
• uspace/Makefile (modified) (1 diff)
• uspace/app/mkmfs/mkmfs.c (modified) (1 diff)
• uspace/drv/test/test1/test1.c (modified) (4 diffs)
• uspace/drv/test/test2/test2.c (modified) (8 diffs)
• uspace/lib/block/libblock.c (modified) (3 diffs)
• uspace/lib/block/libblock.h (modified) (3 diffs)
• uspace/lib/c/generic/str.c (modified) (1 diff)
• uspace/lib/c/include/ipc/devman.h (modified) (1 diff)
• uspace/lib/c/include/str.h (modified) (1 diff)
• uspace/lib/drv/generic/driver.c (modified) (2 diffs)
• uspace/lib/drv/include/ddf/driver.h (modified) (1 diff)
• uspace/lib/fs/libfs.c (modified) (1 diff)
• uspace/lib/fs/libfs.h (modified) (1 diff)
• uspace/srv/devman/devman.c (modified) (1 diff)
• uspace/srv/devman/devman.h (modified) (1 diff)
• uspace/srv/devman/main.c (modified) (7 diffs)
• uspace/srv/fs/cdfs/Makefile (added)
• uspace/srv/fs/cdfs/cdfs.c (added)
• uspace/srv/fs/cdfs/cdfs.h (added)
• uspace/srv/fs/cdfs/cdfs_endian.h (added)
• uspace/srv/fs/cdfs/cdfs_ops.c (added)
• uspace/srv/fs/cdfs/cdfs_ops.h (added)
• uspace/srv/fs/exfat/exfat_ops.c (modified) (3 diffs)
• uspace/srv/fs/ext2fs/ext2fs_ops.c (modified) (3 diffs)
• uspace/srv/fs/fat/fat_ops.c (modified) (3 diffs)
• uspace/srv/fs/locfs/locfs_ops.c (modified) (2 diffs)
• uspace/srv/fs/mfs/mfs_ops.c (modified) (3 diffs)
• uspace/srv/fs/tmpfs/tmpfs_ops.c (modified) (2 diffs)
• uspace/srv/loc/loc.c (modified) (1 diff)

boot/Makefile.common

@@ -103 +103 @@
         $(USPACE_PATH)/srv/fs/fat/fat \
         $(USPACE_PATH)/srv/fs/mfs/mfs \
+        $(USPACE_PATH)/srv/fs/cdfs/cdfs \
         $(USPACE_PATH)/srv/fs/exfat/exfat \
         $(USPACE_PATH)/srv/fs/ext2fs/ext2fs \

tools/toolchain.sh

@@ -53 +53 @@
 EOF
 
-BINUTILS_VERSION="2.21"
+BINUTILS_VERSION="2.21.1"
+BINUTILS_RELEASE="a"
 GCC_VERSION="4.6.1"
-GDB_VERSION="7.2"
+GDB_VERSION="7.3.1"
 
 BASEDIR="`pwd`"
-BINUTILS="binutils-${BINUTILS_VERSION}.tar.bz2"
+BINUTILS="binutils-${BINUTILS_VERSION}${BINUTILS_RELEASE}.tar.bz2"
 GCC_CORE="gcc-core-${GCC_VERSION}.tar.bz2"
 GCC_OBJC="gcc-objc-${GCC_VERSION}.tar.bz2"
@@ -273 +274 @@
         GDB_SOURCE="ftp://ftp.gnu.org/gnu/gdb/"
         
-        download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "c84c5acc9d266f1a7044b51c85a823f5"
+        download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "bde820eac53fa3a8d8696667418557ad"
         download_fetch "${GCC_SOURCE}" "${GCC_CORE}" "0c0e7e35d2215e19de9c97efba507553"
         download_fetch "${GCC_SOURCE}" "${GCC_OBJC}" "cbf0d4b701827922cf37ba6a4ace0079"
         download_fetch "${GCC_SOURCE}" "${GCC_CPP}" "0d75ca7ca35b1e7f252223f9d23a6ad1"
-        download_fetch "${GDB_SOURCE}" "${GDB}" "64260e6c56979ee750a01055f16091a5"
+        download_fetch "${GDB_SOURCE}" "${GDB}" "b89a5fac359c618dda97b88645ceab47"
 }
 

uspace/Makefile

@@ -82 +82 @@
         srv/fs/exfat \
         srv/fs/fat \
+        srv/fs/cdfs \
         srv/fs/tmpfs \
         srv/fs/mfs \

uspace/app/mkmfs/mkmfs.c

@@ -114 +114 @@
         int rc, c, opt_ind;
         char *device_name;
-        aoff64_t devblock_size;
+        size_t devblock_size;
 
         struct mfs_sb_info sb;

uspace/drv/test/test1/test1.c

@@ -42 +42 @@
 static int test1_add_device(ddf_dev_t *dev);
 static int test1_dev_remove(ddf_dev_t *dev);
+static int test1_dev_gone(ddf_dev_t *dev);
 static int test1_fun_online(ddf_fun_t *fun);
 static int test1_fun_offline(ddf_fun_t *fun);
@@ -48 +49 @@
         .add_device = &test1_add_device,
         .dev_remove = &test1_dev_remove,
+        .dev_gone = &test1_dev_gone,
         .fun_online = &test1_fun_online,
         .fun_offline = &test1_fun_offline
@@ -213 +215 @@
 }
 
+static int fun_unbind(ddf_fun_t *fun, const char *name)
+{
+        int rc;
+
+        ddf_msg(LVL_DEBUG, "fun_unbind(%p, '%s')", fun, name);
+        rc = ddf_fun_unbind(fun);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.", name);
+                return rc;
+        }
+
+        ddf_fun_destroy(fun);
+        return EOK;
+}
+
 static int test1_dev_remove(ddf_dev_t *dev)
 {
@@ -234 +251 @@
         if (test1->child != NULL) {
                 rc = fun_remove(test1->child, "child");
+                if (rc != EOK)
+                        return rc;
+        }
+
+        return EOK;
+}
+
+static int test1_dev_gone(ddf_dev_t *dev)
+{
+        test1_t *test1 = (test1_t *)dev->driver_data;
+        int rc;
+
+        ddf_msg(LVL_DEBUG, "test1_dev_remove(%p)", dev);
+
+        if (test1->fun_a != NULL) {
+                rc = fun_unbind(test1->fun_a, "a");
+                if (rc != EOK)
+                        return rc;
+        }
+
+        if (test1->clone != NULL) {
+                rc = fun_unbind(test1->clone, "clone");
+                if (rc != EOK)
+                        return rc;
+        }
+
+        if (test1->child != NULL) {
+                rc = fun_unbind(test1->child, "child");
                 if (rc != EOK)
                         return rc;

uspace/drv/test/test2/test2.c

@@ -42 +42 @@
 static int test2_add_device(ddf_dev_t *dev);
 static int test2_dev_remove(ddf_dev_t *dev);
+static int test2_dev_gone(ddf_dev_t *dev);
 static int test2_fun_online(ddf_fun_t *fun);
 static int test2_fun_offline(ddf_fun_t *fun);
@@ -48 +49 @@
         .add_device = &test2_add_device,
         .dev_remove = &test2_dev_remove,
+        .dev_gone = &test2_dev_gone,
         .fun_online = &test2_fun_online,
         .fun_offline = &test2_fun_offline
@@ -111 +113 @@
 }
 
-/** Add child devices after some sleep.
+/** Simulate plugging and surprise unplugging.
  *
  * @param arg Parent device structure (ddf_dev_t *).
  * @return Always EOK.
  */
-static int postponed_birth(void *arg)
+static int plug_unplug(void *arg)
 {
         test2_t *test2 = (test2_t *) arg;
@@ -144 +146 @@
         test2->fun_a = fun_a;
 
+        async_usleep(10000000);
+
+        ddf_msg(LVL_NOTE, "Unbinding function test1.");
+        ddf_fun_unbind(test2->test1);
+        async_usleep(1000000);
+        ddf_msg(LVL_NOTE, "Unbinding function child.");
+        ddf_fun_unbind(test2->child);
+
         return EOK;
 }
@@ -158 +168 @@
         }
 
+        rc = ddf_fun_unbind(fun);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.", name);
+                return rc;
+        }
+
+        ddf_fun_destroy(fun);
+        return EOK;
+}
+
+static int fun_unbind(ddf_fun_t *fun, const char *name)
+{
+        int rc;
+
+        ddf_msg(LVL_DEBUG, "fun_unbind(%p, '%s')", fun, name);
         rc = ddf_fun_unbind(fun);
         if (rc != EOK) {
@@ -184 +209 @@
 
         if (str_cmp(dev->name, "child") != 0) {
-                fid_t postpone = fibril_create(postponed_birth, test2);
+                fid_t postpone = fibril_create(plug_unplug, test2);
                 if (postpone == 0) {
                         ddf_msg(LVL_ERROR, "fibril_create() failed.");
@@ -232 +257 @@
 }
 
+static int test2_dev_gone(ddf_dev_t *dev)
+{
+        test2_t *test2 = (test2_t *)dev->driver_data;
+        int rc;
+
+        ddf_msg(LVL_DEBUG, "test2_dev_gone(%p)", dev);
+
+        if (test2->fun_a != NULL) {
+                rc = fun_unbind(test2->fun_a, "a");
+                if (rc != EOK)
+                        return rc;
+        }
+
+        if (test2->fun_err != NULL) {
+                rc = fun_unbind(test2->fun_err, "ERROR");
+                if (rc != EOK)
+                        return rc;
+        }
+
+        if (test2->child != NULL) {
+                rc = fun_unbind(test2->child, "child");
+                if (rc != EOK)
+                        return rc;
+        }
+
+        if (test2->test1 != NULL) {
+                rc = fun_unbind(test2->test1, "test1");
+                if (rc != EOK)
+                        return rc;
+        }
+
+        return EOK;
+}
+
 
 static int test2_fun_online(ddf_fun_t *fun)
@@ -248 +307 @@
 {
         printf(NAME ": HelenOS test2 virtual device driver\n");
-        ddf_log_init(NAME, LVL_ERROR);
+        ddf_log_init(NAME, LVL_NOTE);
         return ddf_driver_main(&test2_driver);
 }

uspace/lib/block/libblock.c

@@ -93 +93 @@
 static int get_block_size(async_sess_t *, size_t *);
 static int get_num_blocks(async_sess_t *, aoff64_t *);
-static int read_toc(async_sess_t *, uint8_t);
 static aoff64_t ba_ltop(devcon_t *, aoff64_t);
 
@@ -896 +895 @@
  * @param service_id Service ID of the block device.
  * @param session    Starting session.
- * @param data       Buffer to read TOC into.
- *
- * @return EOK on success.
- * @return Error code on failure.
- *
- */
-int block_get_toc(service_id_t service_id, uint8_t session, void *data)
+ *
+ * @return Allocated TOC structure.
+ * @return NULL on failure.
+ *
+ */
+toc_block_t *block_get_toc(service_id_t service_id, uint8_t session)
 {
         devcon_t *devcon = devcon_search(service_id);
         assert(devcon);
         
+        toc_block_t *toc = NULL;
+        
         fibril_mutex_lock(&devcon->comm_area_lock);
         
-        int rc = read_toc(devcon->sess, session);
-        if (rc == EOK)
-                memcpy(data, devcon->comm_area, devcon->pblock_size);
+        async_exch_t *exch = async_exchange_begin(devcon->sess);
+        int rc = async_req_1_0(exch, BD_READ_TOC, session);
+        async_exchange_end(exch);
+        
+        if (rc == EOK) {
+                toc = (toc_block_t *) malloc(sizeof(toc_block_t));
+                if (toc != NULL) {
+                        memset(toc, 0, sizeof(toc_block_t));
+                        memcpy(toc, devcon->comm_area,
+                            min(devcon->pblock_size, sizeof(toc_block_t)));
+                }
+        }
+        
         
         fibril_mutex_unlock(&devcon->comm_area_lock);
         
-        return rc;
+        return toc;
 }
 
@@ -1008 +1018 @@
 }
 
-/** Get TOC from block device. */
-static int read_toc(async_sess_t *sess, uint8_t session)
-{
-        async_exch_t *exch = async_exchange_begin(sess);
-        int rc = async_req_1_0(exch, BD_READ_TOC, session);
-        async_exchange_end(exch);
-
-        return rc;
-}
-
 /** Convert logical block address to physical block address. */
 static aoff64_t ba_ltop(devcon_t *devcon, aoff64_t lba)

uspace/lib/block/libblock.h

@@ -97 +97 @@
 };
 
+typedef struct {
+        uint16_t size;
+        uint8_t first_session;
+        uint8_t last_session;
+        
+        uint8_t res0;
+        uint8_t adr_ctrl;
+        uint8_t first_track;
+        uint8_t res1;
+        
+        uint32_t first_lba;
+} __attribute__((packed)) toc_block_t;
+
 extern int block_init(exch_mgmt_t, service_id_t, size_t);
 extern void block_fini(service_id_t);
@@ -114 +127 @@
 extern int block_get_bsize(service_id_t, size_t *);
 extern int block_get_nblocks(service_id_t, aoff64_t *);
-extern int block_get_toc(service_id_t, uint8_t, void *);
+extern toc_block_t *block_get_toc(service_id_t, uint8_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 *);
@@ -123 +136 @@
 /** @}
  */
-

uspace/lib/c/generic/str.c

@@ -1291 +1291 @@
 }
 
+/** Convert string to uint8_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+int str_uint8_t(const char *nptr, char **endptr, unsigned int base,
+    bool strict, uint8_t *result)
+{
+        assert(result != NULL);
+        
+        bool neg;
+        char *lendptr;
+        uint64_t res;
+        int ret = str_uint(nptr, &lendptr, base, &neg, &res);
+        
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+        
+        if (ret != EOK)
+                return ret;
+        
+        /* Do not allow negative values */
+        if (neg)
+                return EINVAL;
+        
+        /* Check whether we are at the end of
+           the string in strict mode */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+        
+        /* Check for overflow */
+        uint8_t _res = (uint8_t) res;
+        if (_res != res)
+                return EOVERFLOW;
+        
+        *result = _res;
+        
+        return EOK;
+}
+
+/** Convert string to uint16_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+int str_uint16_t(const char *nptr, char **endptr, unsigned int base,
+    bool strict, uint16_t *result)
+{
+        assert(result != NULL);
+        
+        bool neg;
+        char *lendptr;
+        uint64_t res;
+        int ret = str_uint(nptr, &lendptr, base, &neg, &res);
+        
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+        
+        if (ret != EOK)
+                return ret;
+        
+        /* Do not allow negative values */
+        if (neg)
+                return EINVAL;
+        
+        /* Check whether we are at the end of
+           the string in strict mode */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+        
+        /* Check for overflow */
+        uint16_t _res = (uint16_t) res;
+        if (_res != res)
+                return EOVERFLOW;
+        
+        *result = _res;
+        
+        return EOK;
+}
+
+/** Convert string to uint32_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+int str_uint32_t(const char *nptr, char **endptr, unsigned int base,
+    bool strict, uint32_t *result)
+{
+        assert(result != NULL);
+        
+        bool neg;
+        char *lendptr;
+        uint64_t res;
+        int ret = str_uint(nptr, &lendptr, base, &neg, &res);
+        
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+        
+        if (ret != EOK)
+                return ret;
+        
+        /* Do not allow negative values */
+        if (neg)
+                return EINVAL;
+        
+        /* Check whether we are at the end of
+           the string in strict mode */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+        
+        /* Check for overflow */
+        uint32_t _res = (uint32_t) res;
+        if (_res != res)
+                return EOVERFLOW;
+        
+        *result = _res;
+        
+        return EOK;
+}
+
 /** Convert string to uint64_t.
  *

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

@@ -147 +147 @@
         DRIVER_DEV_ADD = IPC_FIRST_USER_METHOD,
         DRIVER_DEV_REMOVE,
+        DRIVER_DEV_GONE,
         DRIVER_FUN_ONLINE,
         DRIVER_FUN_OFFLINE,
-
 } devman_to_driver_t;
 

uspace/lib/c/include/str.h

@@ -97 +97 @@
 extern char *str_ndup(const char *, size_t max_size);
 
+extern int str_uint8_t(const char *, char **, unsigned int, bool, uint8_t *);
+extern int str_uint16_t(const char *, char **, unsigned int, bool, uint16_t *);
+extern int str_uint32_t(const char *, char **, unsigned int, bool, uint32_t *);
 extern int str_uint64(const char *, char **, unsigned int, bool, uint64_t *);
 extern int str_size_t(const char *, char **, unsigned int, bool, size_t *);

uspace/lib/drv/generic/driver.c

@@ -333 +333 @@
 }
 
+static void driver_dev_gone(ipc_callid_t iid, ipc_call_t *icall)
+{
+        devman_handle_t devh;
+        ddf_dev_t *dev;
+        int rc;
+        
+        devh = IPC_GET_ARG1(*icall);
+        
+        fibril_mutex_lock(&devices_mutex);
+        dev = driver_get_device(devh);
+        if (dev != NULL)
+                dev_add_ref(dev);
+        fibril_mutex_unlock(&devices_mutex);
+        
+        if (dev == NULL) {
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        if (driver->driver_ops->dev_gone != NULL)
+                rc = driver->driver_ops->dev_gone(dev);
+        else
+                rc = ENOTSUP;
+        
+        if (rc == EOK)
+                dev_del_ref(dev);
+        
+        async_answer_0(iid, (sysarg_t) rc);
+}
+
 static void driver_fun_online(ipc_callid_t iid, ipc_call_t *icall)
 {
@@ -423 +453 @@
                 case DRIVER_DEV_REMOVE:
                         driver_dev_remove(callid, &call);
+                        break;
+                case DRIVER_DEV_GONE:
+                        driver_dev_gone(callid, &call);
                         break;
                 case DRIVER_FUN_ONLINE:

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

@@ -139 +139 @@
         /** Ask driver to remove a device */
         int (*dev_remove)(ddf_dev_t *);
+        /** Inform driver a device disappeared */
+        int (*dev_gone)(ddf_dev_t *);
         /** Ask driver to online a specific function */
         int (*fun_online)(ddf_fun_t *);

uspace/lib/fs/libfs.c

@@ -837 +837 @@
         stat.is_directory = ops->is_directory(fn);
         stat.size = ops->size_get(fn);
-        stat.service = ops->device_get(fn);
+        stat.service = ops->service_get(fn);
         
         ops->node_put(fn);

uspace/lib/fs/libfs.h

@@ -92 +92 @@
         bool (* is_directory)(fs_node_t *);
         bool (* is_file)(fs_node_t *);
-        service_id_t (* device_get)(fs_node_t *);
+        service_id_t (* service_get)(fs_node_t *);
 } libfs_ops_t;
 

uspace/srv/devman/devman.c

@@ -878 +878 @@
         
         return retval;
-
+}
+
+int driver_dev_gone(dev_tree_t *tree, dev_node_t *dev)
+{
+        async_exch_t *exch;
+        sysarg_t retval;
+        driver_t *drv;
+        devman_handle_t handle;
+        
+        assert(dev != NULL);
+        
+        log_msg(LVL_DEBUG, "driver_dev_gone(%p)", dev);
+        
+        fibril_rwlock_read_lock(&tree->rwlock);
+        drv = dev->drv;
+        handle = dev->handle;
+        fibril_rwlock_read_unlock(&tree->rwlock);
+        
+        exch = async_exchange_begin(drv->sess);
+        retval = async_req_1_0(exch, DRIVER_DEV_GONE, handle);
+        async_exchange_end(exch);
+        
+        return retval;
 }
 

uspace/srv/devman/devman.h

@@ -263 +263 @@
 extern bool start_driver(driver_t *);
 extern int driver_dev_remove(dev_tree_t *, dev_node_t *);
+extern int driver_dev_gone(dev_tree_t *, dev_node_t *);
 extern int driver_fun_online(dev_tree_t *, fun_node_t *);
 extern int driver_fun_offline(dev_tree_t *, fun_node_t *);

uspace/srv/devman/main.c

@@ -316 +316 @@
                 if (fun->child != NULL) {
                         dev_node_t *dev = fun->child;
+                        device_state_t dev_state;
                         
                         dev_add_ref(dev);
+                        dev_state = dev->state;
+                        
                         fibril_rwlock_write_unlock(&device_tree.rwlock);
-                        
+
                         /* If device is owned by driver, ask driver to give it up. */
-                        if (dev->state == DEVICE_USABLE) {
+                        if (dev_state == DEVICE_USABLE) {
                                 rc = driver_dev_remove(&device_tree, dev);
                                 if (rc != EOK) {
@@ -333 +336 @@
                         if (!list_empty(&dev->functions)) {
                                 fibril_rwlock_read_unlock(&device_tree.rwlock);
+                                dev_del_ref(dev);
                                 return EIO;
                         }
+                        
                         driver_t *driver = dev->drv;
                         fibril_rwlock_read_unlock(&device_tree.rwlock);
@@ -507 +512 @@
         fun_node_t *fun;
         int rc;
-
-        printf("devman_drv_fun_online()\n");
+        
+        log_msg(LVL_DEBUG, "devman_drv_fun_online()");
+        
         fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
         if (fun == NULL) {
@@ -526 +532 @@
         rc = online_function(fun);
         if (rc != EOK) {
-                printf("devman_drv_fun_online() online_fun->ERROR\n");
                 fun_del_ref(fun);
                 async_answer_0(iid, (sysarg_t) rc);
@@ -533 +538 @@
         
         fun_del_ref(fun);
-        printf("devman_drv_fun_online() online_fun->OK\n");
         
         async_answer_0(iid, (sysarg_t) EOK);
@@ -580 +584 @@
         int rc;
         
-        
         fun_node_t *fun = find_fun_node(&device_tree, fun_handle);
         if (fun == NULL) {
@@ -599 +602 @@
         
         if (fun->ftype == fun_inner) {
-                /* Handle possible descendants */
-                /* TODO - This is a surprise removal */
+                /* This is a surprise removal. Handle possible descendants */
                 if (fun->child != NULL) {
-                        log_msg(LVL_WARN, "devman_remove_function(): not handling "
-                            "descendants\n");
+                        dev_node_t *dev = fun->child;
+                        device_state_t dev_state;
+                        int gone_rc;
+                        
+                        dev_add_ref(dev);
+                        dev_state = dev->state;
+                        
+                        fibril_rwlock_write_unlock(&device_tree.rwlock);
+                        
+                        /* If device is owned by driver, inform driver it is gone. */
+                        if (dev_state == DEVICE_USABLE)
+                                gone_rc = driver_dev_gone(&device_tree, dev);
+                        else
+                                gone_rc = EOK;
+                        
+                        fibril_rwlock_read_lock(&device_tree.rwlock);
+                        
+                        /* Verify that driver succeeded and removed all functions */
+                        if (gone_rc != EOK || !list_empty(&dev->functions)) {
+                                log_msg(LVL_ERROR, "Driver did not remove "
+                                    "functions for device that is gone. "
+                                    "Device node is now defunct.");
+                                
+                                /*
+                                 * Not much we can do but mark the device
+                                 * node as having invalid state. This
+                                 * is a driver bug.
+                                 */
+                                dev->state = DEVICE_INVALID;
+                                fibril_rwlock_read_unlock(&device_tree.rwlock);
+                                dev_del_ref(dev);
+                                return;
+                        }
+                        
+                        driver_t *driver = dev->drv;
+                        fibril_rwlock_read_unlock(&device_tree.rwlock);
+                        
+                        if (driver)
+                                detach_driver(&device_tree, dev);
+                        
+                        fibril_rwlock_write_lock(&device_tree.rwlock);
+                        remove_dev_node(&device_tree, dev);
+                        
+                        /* Delete ref created when node was inserted */
+                        dev_del_ref(dev);
+                        /* Delete ref created by dev_add_ref(dev) above */
+                        dev_del_ref(dev);
                 }
         } else {

uspace/srv/fs/exfat/exfat_ops.c

@@ -87 +87 @@
 static bool exfat_is_directory(fs_node_t *);
 static bool exfat_is_file(fs_node_t *node);
-static service_id_t exfat_device_get(fs_node_t *node);
+static service_id_t exfat_service_get(fs_node_t *node);
 
 /*
@@ -898 +898 @@
 }
 
-service_id_t exfat_device_get(fs_node_t *node)
+service_id_t exfat_service_get(fs_node_t *node)
 {
         return 0;
@@ -921 +921 @@
         .is_directory = exfat_is_directory,
         .is_file = exfat_is_file,
-        .device_get = exfat_device_get
+        .service_get = exfat_service_get
 };
 

uspace/srv/fs/ext2fs/ext2fs_ops.c

@@ -112 +112 @@
 static bool ext2fs_is_directory(fs_node_t *);
 static bool ext2fs_is_file(fs_node_t *node);
-static service_id_t ext2fs_device_get(fs_node_t *node);
+static service_id_t ext2fs_service_get(fs_node_t *node);
 
 /*
@@ -557 +557 @@
 }
 
-service_id_t ext2fs_device_get(fs_node_t *fn)
+service_id_t ext2fs_service_get(fs_node_t *fn)
 {
         EXT2FS_DBG("");
@@ -581 +581 @@
         .is_directory = ext2fs_is_directory,
         .is_file = ext2fs_is_file,
-        .device_get = ext2fs_device_get
+        .service_get = ext2fs_service_get
 };
 

uspace/srv/fs/fat/fat_ops.c

@@ -90 +90 @@
 static bool fat_is_directory(fs_node_t *);
 static bool fat_is_file(fs_node_t *node);
-static service_id_t fat_device_get(fs_node_t *node);
+static service_id_t fat_service_get(fs_node_t *node);
 
 /*
@@ -838 +838 @@
 }
 
-service_id_t fat_device_get(fs_node_t *node)
+service_id_t fat_service_get(fs_node_t *node)
 {
         return 0;
@@ -860 +860 @@
         .is_directory = fat_is_directory,
         .is_file = fat_is_file,
-        .device_get = fat_device_get
+        .service_get = fat_service_get
 };
 

uspace/srv/fs/locfs/locfs_ops.c

@@ -418 +418 @@
 }
 
-static service_id_t locfs_device_get(fs_node_t *fn)
+static service_id_t locfs_service_get(fs_node_t *fn)
 {
         locfs_node_t *node = (locfs_node_t *) fn->data;
@@ -445 +445 @@
         .is_directory = locfs_is_directory,
         .is_file = locfs_is_file,
-        .device_get = locfs_device_get
+        .service_get = locfs_service_get
 };
 

uspace/srv/fs/mfs/mfs_ops.c

@@ -55 +55 @@
 static int mfs_has_children(bool *has_children, fs_node_t *fsnode);
 static int mfs_root_get(fs_node_t **rfn, service_id_t service_id);
-static service_id_t mfs_device_get(fs_node_t *fsnode);
+static service_id_t mfs_service_get(fs_node_t *fsnode);
 static aoff64_t mfs_size_get(fs_node_t *node);
 static int mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component);
@@ -81 +81 @@
         .size_get = mfs_size_get,
         .root_get = mfs_root_get,
-        .device_get = mfs_device_get,
+        .service_get = mfs_service_get,
         .is_directory = mfs_is_directory,
         .is_file = mfs_is_file,
@@ -325 +325 @@
 }
 
-service_id_t mfs_device_get(fs_node_t *fsnode)
+service_id_t mfs_service_get(fs_node_t *fsnode)
 {
         struct mfs_node *node = fsnode->data;

uspace/srv/fs/tmpfs/tmpfs_ops.c

@@ -114 +114 @@
 }
 
-static service_id_t tmpfs_device_get(fs_node_t *fn)
+static service_id_t tmpfs_service_get(fs_node_t *fn)
 {
         return 0;
@@ -136 +136 @@
         .is_directory = tmpfs_is_directory,
         .is_file = tmpfs_is_file,
-        .device_get = tmpfs_device_get
+        .service_get = tmpfs_service_get
 };
 

uspace/srv/loc/loc.c

@@ -1277 +1277 @@
         categ_dir_add_cat(&cdir, cat);
 
+        cat = category_new("test3");
+        categ_dir_add_cat(&cdir, cat);
+
         cat = category_new("usbhc");
         categ_dir_add_cat(&cdir, cat);
 
+        cat = category_new("virt-null");
+        categ_dir_add_cat(&cdir, cat);
+
         cat = category_new("virtual");
         categ_dir_add_cat(&cdir, cat);
+
 
         return true;