Changes in / [2cc7f16:5608deba] in mainline

Files:

• abi/include/syscall.h (modified) (1 diff)
• boot/Makefile.common (modified) (1 diff)
• boot/arch/ia64/src/pal_asm.S (modified) (3 diffs)
• boot/arch/ia64/src/sal_asm.S (modified) (3 diffs)
• boot/grub.pc/stage2_eltorito (deleted)
• kernel/arch/ia64/include/asm.h (modified) (6 diffs)
• kernel/arch/ia64/src/ia64.c (modified) (1 diff)
• kernel/arch/ppc32/src/ppc32.c (modified) (1 diff)
• kernel/arch/sparc64/src/sun4u/sparc64.c (modified) (1 diff)
• kernel/arch/sparc64/src/sun4v/sparc64.c (modified) (1 diff)
• kernel/genarch/include/ofw/ofw_tree.h (modified) (1 diff)
• kernel/genarch/src/ofw/ofw_tree.c (modified) (13 diffs)
• kernel/generic/include/sysinfo/sysinfo.h (modified) (6 diffs)
• kernel/generic/src/ddi/ddi.c (modified) (1 diff)
• kernel/generic/src/lib/func.c (modified) (1 diff)
• kernel/generic/src/main/main.c (modified) (2 diffs)
• kernel/generic/src/mm/page.c (modified) (2 diffs)
• kernel/generic/src/syscall/syscall.c (modified) (1 diff)
• kernel/generic/src/sysinfo/stats.c (modified) (22 diffs)
• kernel/generic/src/sysinfo/sysinfo.c (modified) (22 diffs)
• uspace/Makefile (modified) (1 diff)
• uspace/app/mkexfat/Makefile (added)
• uspace/app/mkexfat/exfat.h (added)
• uspace/app/mkexfat/mkexfat.c (added)
• uspace/app/mkexfat/upcase.h (added)
• uspace/app/sysinfo/sysinfo.c (modified) (4 diffs)
• uspace/drv/bus/usb/uhci/transfer_list.c (modified) (4 diffs)
• uspace/drv/bus/usb/uhci/uhci_batch.c (modified) (1 diff)
• uspace/drv/char/ps2mouse/ps2mouse.c (modified) (1 diff)
• uspace/drv/infrastructure/root/root.c (modified) (4 diffs)
• uspace/lib/c/arch/ia64/include/ddi.h (modified) (7 diffs)
• uspace/lib/c/generic/str.c (modified) (1 diff)
• uspace/lib/c/generic/sysinfo.c (modified) (4 diffs)
• uspace/lib/c/include/str.h (modified) (1 diff)
• uspace/lib/c/include/sysinfo.h (modified) (1 diff)
• uspace/srv/fs/exfat/exfat_bitmap.c (modified) (13 diffs)
• uspace/srv/fs/exfat/exfat_bitmap.h (modified) (1 diff)
• uspace/srv/fs/exfat/exfat_dentry.c (modified) (1 diff)
• uspace/srv/fs/exfat/exfat_dentry.h (modified) (1 diff)
• uspace/srv/fs/exfat/exfat_directory.c (modified) (1 diff)
• uspace/srv/fs/exfat/exfat_fat.c (modified) (4 diffs)
• uspace/srv/fs/exfat/exfat_ops.c (modified) (6 diffs)
• uspace/srv/hid/input/include/sun.h (deleted)
• uspace/srv/hid/input/port/dummy.c (deleted)
• uspace/srv/hid/input/port/sgcn.c (deleted)
• uspace/srv/hid/input/port/sun.c (deleted)
• uspace/srv/hid/input/port/z8530.c (deleted)

abi/include/syscall.h

@@ -92 +92 @@
         SYS_IRQ_UNREGISTER,
         
+        SYS_SYSINFO_GET_KEYS_SIZE,
+        SYS_SYSINFO_GET_KEYS,
         SYS_SYSINFO_GET_VAL_TYPE,
         SYS_SYSINFO_GET_VALUE,

boot/Makefile.common

@@ -165 +165 @@
         $(USPACE_PATH)/app/locinfo/locinfo \
         $(USPACE_PATH)/app/mkfat/mkfat \
+        $(USPACE_PATH)/app/mkexfat/mkexfat \
         $(USPACE_PATH)/app/mkmfs/mkmfs \
         $(USPACE_PATH)/app/lsusb/lsusb \

boot/arch/ia64/src/pal_asm.S

@@ -32 +32 @@
 
 pal_static_call:
-        alloc loc0 = ar.pfs, 7, 5, 0, 0
+        alloc loc0 = ar.pfs, 7, 6, 0, 0
+
+        mov loc1 = psr ;;
+        mov psr.l = r0 ;;
+        srlz.i
+        srlz.d
         
-        mov loc1 = gp
-        mov loc2 = rp
+        mov loc2 = gp
+        mov loc3 = rp
         
-        addl loc3 = @gprel(pal_proc), gp
-        
+        addl loc4 = @gprel(pal_proc), gp
+
         mov r28 = in0
         mov r29 = in1
@@ -44 +49 @@
         mov r31 = in3 ;;
         
-        ld8 loc3 = [loc3]
-        movl loc4 = 0f ;;
+        ld8 loc4 = [loc4]
+        movl loc5 = 0f ;;
 
-        mov b6 = loc3
-        mov rp = loc4 ;;
+        mov b6 = loc4
+        mov rp = loc5 ;;
         br.cond.sptk.many b6
 
 0:
+        mov psr.l = loc1 ;;
+        srlz.i
+        srlz.d
+
         cmp.ne p7,p0 = 0, in4
         cmp.ne p8,p0 = 0, in5
@@ -60 +69 @@
 (p9)    st8 [in6] = r11
         
-        mov gp = loc1
-        mov rp = loc2 ;;
+        mov gp = loc2
+        mov rp = loc3 ;;
         
         mov ar.pfs = loc0

boot/arch/ia64/src/sal_asm.S

@@ -29 +29 @@
 .explicit
 
+#define STACK_SCRATCH_AREA      16
+#define STACK_IN8               (0 + STACK_SCRATCH_AREA)
+#define STACK_IN9               (8 + STACK_SCRATCH_AREA)
+#define STACK_IN10              (16 + STACK_SCRATCH_AREA)
+
 .global sal_call
 
@@ -39 +44 @@
 #
 sal_call:
-        alloc loc0 = ar.pfs, 11, 5, 8, 0
+        alloc loc0 = ar.pfs, 8, 8, 8, 0
         
+        adds sp = -STACK_SCRATCH_AREA, sp
+
         mov loc1 = gp
         mov loc2 = rp
@@ -57 +64 @@
         
         ld8 loc3 = [loc3]
-        ld8 gp = [loc4] ;;
+        ld8 gp = [loc4]
+
+        adds r14 = STACK_IN8 + STACK_SCRATCH_AREA, sp
+        adds r15 = STACK_IN9 + STACK_SCRATCH_AREA, sp
+        adds r16 = STACK_IN10 + STACK_SCRATCH_AREA, sp ;;
+
+        ld8 loc5 = [r14]
+        ld8 loc6 = [r15]
+        ld8 loc7 = [r16]
         
         mov b6 = loc3 ;;
         br.call.sptk.many rp = b6
         
-        cmp.ne p7,p0 = 0, in8
-        cmp.ne p8,p0 = 0, in9
-        cmp.ne p9,p0 = 0, in10 ;;
+        cmp.ne p7,p0 = 0, loc5 
+        cmp.ne p8,p0 = 0, loc6 
+        cmp.ne p9,p0 = 0, loc7 ;;
         
-(p7)    st8 [in8] = r9
-(p8)    st8 [in9] = r10
-(p9)    st8 [in10] = r11
+(p7)    st8 [loc5] = r9
+(p8)    st8 [loc6] = r10
+(p9)    st8 [loc7] = r11
         
         mov gp = loc1
-        mov rp = loc2 ;;
+        mov rp = loc2
+
+        adds sp = STACK_SCRATCH_AREA, sp ;;
         
         mov ar.pfs = loc0
         br.ret.sptk.many rp
+

kernel/arch/ia64/include/asm.h

@@ -61 +61 @@
         asm volatile (
                 "mf\n"
+                "mf.a\n"
                 ::: "memory"
         );
@@ -74 +75 @@
         asm volatile (
                 "mf\n"
+                "mf.a\n"
                 ::: "memory"
         );
@@ -87 +89 @@
         asm volatile (
                 "mf\n"
+                "mf.a\n"
                 ::: "memory"
         );
@@ -104 +107 @@
         else
                 v = *port;
+
+        asm volatile (
+                "mf.a\n"
+                ::: "memory"
+        );
         
         return v;
@@ -121 +129 @@
         else
                 v = *port;
+
+        asm volatile (
+                "mf.a\n"
+                ::: "memory"
+        );
         
         return v;
@@ -138 +151 @@
         else
                 v = *port;
+
+        asm volatile (
+                "mf.a\n"
+                ::: "memory"
+        );
 
         return v;

kernel/arch/ia64/src/ia64.c

@@ -144 +144 @@
 #endif
 #ifdef MACHINE_i460GX
-        platform = "i460GX";
+        platform = "pc";
 #endif
         sysinfo_set_item_data("platform", NULL, (void *) platform,

kernel/arch/ppc32/src/ppc32.c

@@ -173 +173 @@
                 ofw_tree_walk_by_device_type("display", display_register, NULL);
 #endif
+                /* Map OFW information into sysinfo */
+                ofw_sysinfo_map();
                 
                 /* Initialize IRQ routing */

kernel/arch/sparc64/src/sun4u/sparc64.c

@@ -94 +94 @@
 {
         if (config.cpu_active == 1) {
+                /* Map OFW information into sysinfo */
+                ofw_sysinfo_map();
+                
                 /*
                  * We have 2^11 different interrupt vectors.

kernel/arch/sparc64/src/sun4v/sparc64.c

@@ -92 +92 @@
 {
         if (config.cpu_active == 1) {
+                /* Map OFW information into sysinfo */
+                ofw_sysinfo_map();
+                
                 /*
                  * We have 2^11 different interrupt vectors.

kernel/genarch/include/ofw/ofw_tree.h

@@ -67 +67 @@
 
 extern void ofw_tree_init(ofw_tree_node_t *);
-extern void ofw_tree_print(void);
+extern void ofw_sysinfo_map(void);
 
 extern const char *ofw_tree_node_name(const ofw_tree_node_t *);

kernel/genarch/src/ofw/ofw_tree.c

@@ -38 +38 @@
 #include <genarch/ofw/ofw_tree.h>
 #include <mm/slab.h>
+#include <sysinfo/sysinfo.h>
 #include <memstr.h>
 #include <str.h>
@@ -65 +66 @@
     const char *name)
 {
-        size_t i;
-        
-        for (i = 0; i < node->properties; i++) {
+        for (size_t i = 0; i < node->properties; i++) {
                 if (str_cmp(node->property[i].name, name) == 0)
                         return &node->property[i];
@@ -104 +103 @@
     const char *name)
 {
-        ofw_tree_node_t *cur;
-        
         /*
          * Try to find the disambigued name.
          */
-        for (cur = node->child; cur; cur = cur->peer) {
+        for (ofw_tree_node_t *cur = node->child; cur; cur = cur->peer) {
                 if (str_cmp(cur->da_name, name) == 0)
                         return cur;
@@ -121 +118 @@
          * are not always fully-qualified.
          */
-        for (cur = node->child; cur; cur = cur->peer) {
+        for (ofw_tree_node_t *cur = node->child; cur; cur = cur->peer) {
                 if (str_cmp(ofw_tree_node_name(cur), name) == 0)
                         return cur;
@@ -141 +138 @@
     const char *dtype)
 {
-        ofw_tree_node_t *cur;
-        
-        for (cur = node->child; cur; cur = cur->peer) {
+        for (ofw_tree_node_t *cur = node->child; cur; cur = cur->peer) {
                 ofw_tree_property_t *prop =
                     ofw_tree_getprop(cur, "device_type");
@@ -172 +167 @@
     phandle handle)
 {
-        ofw_tree_node_t *cur;
-        
-        for (cur = root; cur; cur = cur->peer) {
+        for (ofw_tree_node_t *cur = root; cur; cur = cur->peer) {
                 if (cur->node_handle == handle)
                         return cur;
                 
                 if (cur->child) {
-                        ofw_tree_node_t *node
-                            = ofw_tree_find_node_by_handle(cur->child, handle);
+                        ofw_tree_node_t *node =
+                            ofw_tree_find_node_by_handle(cur->child, handle);
                         if (node)
                                 return node;
@@ -201 +194 @@
     const char *dtype)
 {
-        ofw_tree_node_t *cur;
-        
-        for (cur = node->peer; cur; cur = cur->peer) {
+        for (ofw_tree_node_t *cur = node->peer; cur; cur = cur->peer) {
                 ofw_tree_property_t *prop =
                     ofw_tree_getprop(cur, "device_type");
@@ -229 +220 @@
     const char *name)
 {
-        ofw_tree_node_t *cur;
-        
-        for (cur = node->peer; cur; cur = cur->peer) {
-                ofw_tree_property_t *prop
-                    = ofw_tree_getprop(cur, "name");
+        for (ofw_tree_node_t *cur = node->peer; cur; cur = cur->peer) {
+                ofw_tree_property_t *prop =
+                    ofw_tree_getprop(cur, "name");
                 
                 if ((!prop) || (!prop->value))
@@ -259 +248 @@
         
         ofw_tree_node_t *node = ofw_root;
-        size_t i;
         size_t j;
         
-        for (i = 1; (i < str_size(path)) && (node); i = j + 1) {
+        for (size_t i = 1; (i < str_size(path)) && (node); i = j + 1) {
                 for (j = i; (j < str_size(path)) && (path[j] != '/'); j++);
                 
@@ -294 +282 @@
     const char *dtype, ofw_tree_walker_t walker, void *arg)
 {
-        ofw_tree_node_t *cur;
-        
-        for (cur = node; cur; cur = cur->peer) {
+        for (ofw_tree_node_t *cur = node; cur; cur = cur->peer) {
                 ofw_tree_property_t *prop =
                     ofw_tree_getprop(cur, "device_type");
@@ -334 +320 @@
 }
 
-/** Print OpenFirmware device subtree rooted in a node.
+/** Get OpenFirmware node properties.
+ *
+ * @param item    Sysinfo item (unused).
+ * @param size    Size of the returned data.
+ * @param dry_run Do not get the data, just calculate the size.
+ * @param data    OpenFirmware node.
+ *
+ * @return Data containing a serialized dump of all node
+ *         properties. If the return value is not NULL, it
+ *         should be freed in the context of the sysinfo request.
+ *
+ */
+static void *ofw_sysinfo_properties(struct sysinfo_item *item, size_t *size,
+    bool dry_run, void *data)
+{
+        ofw_tree_node_t *node = (ofw_tree_node_t *) data;
+        
+        /* Compute serialized data size */
+        *size = 0;
+        for (size_t i = 0; i < node->properties; i++)
+                *size += str_size(node->property[i].name) + 1 +
+                    sizeof(node->property[i].size) + node->property[i].size;
+        
+        if (dry_run)
+                return NULL;
+        
+        void *dump = malloc(*size, FRAME_ATOMIC);
+        if (dump == NULL) {
+                *size = 0;
+                return NULL;
+        }
+        
+        /* Serialize the data */
+        size_t pos = 0;
+        for (size_t i = 0; i < node->properties; i++) {
+                /* Property name */
+                str_cpy(dump + pos, *size - pos, node->property[i].name);
+                pos += str_size(node->property[i].name) + 1;
+                
+                /* Value size */
+                memcpy(dump + pos, &node->property[i].size,
+                    sizeof(node->property[i].size));
+                pos += sizeof(node->property[i].size);
+                
+                /* Value */
+                memcpy(dump + pos, node->property[i].value,
+                    node->property[i].size);
+                pos += node->property[i].size;
+        }
+        
+        return ((void *) dump);
+}
+
+/** Map OpenFirmware device subtree rooted in a node into sysinfo.
  *
  * Child nodes are processed recursively and peer nodes are processed
@@ -343 +382 @@
  *
  */
-static void ofw_tree_node_print(ofw_tree_node_t *node, const char *path)
+static void ofw_tree_node_sysinfo(ofw_tree_node_t *node, const char *path)
 {
         char *cur_path = (char *) malloc(PATH_MAX_LEN, 0);
-        ofw_tree_node_t *cur;
-        
-        for (cur = node; cur; cur = cur->peer) {
-                if ((cur->parent) && (path)) {
-                        snprintf(cur_path, PATH_MAX_LEN, "%s/%s", path, cur->da_name);
-                        printf("%s\n", cur_path);
-                } else {
-                        snprintf(cur_path, PATH_MAX_LEN, "%s", cur->da_name);
-                        printf("/\n");
-                }
+        
+        for (ofw_tree_node_t *cur = node; cur; cur = cur->peer) {
+                if ((cur->parent) && (path))
+                        snprintf(cur_path, PATH_MAX_LEN, "%s.%s", path, cur->da_name);
+                else
+                        snprintf(cur_path, PATH_MAX_LEN, "firmware.%s", cur->da_name);
+                
+                sysinfo_set_item_gen_data(cur_path, NULL, ofw_sysinfo_properties,
+                    (void *) cur);
                 
                 if (cur->child)
-                        ofw_tree_node_print(cur->child, cur_path);
+                        ofw_tree_node_sysinfo(cur->child, cur_path);
         }
         
@@ -364 +402 @@
 }
 
-/** Print the structure of the OpenFirmware device tree. */
-void ofw_tree_print(void)
-{
-        ofw_tree_node_print(ofw_root, NULL);
+/** Map the OpenFirmware device tree into sysinfo. */
+void ofw_sysinfo_map(void)
+{
+        ofw_tree_node_sysinfo(ofw_root, NULL);
 }
 

kernel/generic/include/sysinfo/sysinfo.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2006 Jakub Vana
+ * Copyright (c) 2012 Martin Decky
  * All rights reserved.
  *
@@ -54 +55 @@
 struct sysinfo_item;
 
-/** Gerated numeric value function */
-typedef sysarg_t (*sysinfo_fn_val_t)(struct sysinfo_item *);
+/** Generated numeric value function */
+typedef sysarg_t (*sysinfo_fn_val_t)(struct sysinfo_item *, void *);
+
+/** Sysinfo generated numberic value data
+ *
+ */
+typedef struct {
+        sysinfo_fn_val_t fn;  /**< Generated value function */
+        void *data;           /**< Private data */
+} sysinfo_gen_val_data_t;
 
 /** Generated binary data function */
-typedef void *(*sysinfo_fn_data_t)(struct sysinfo_item *, size_t *, bool);
+typedef void *(*sysinfo_fn_data_t)(struct sysinfo_item *, size_t *, bool,
+    void *);
+
+/** Sysinfo generated binary data data
+ *
+ */
+typedef struct {
+        sysinfo_fn_data_t fn;  /**< Generated binary data function */
+        void *data;            /**< Private data */
+} sysinfo_gen_data_data_t;
 
 /** Sysinfo item binary data
@@ -72 +90 @@
  */
 typedef union {
-        sysarg_t val;               /**< Constant numberic value */
-        sysinfo_fn_val_t fn_val;    /**< Generated numeric value function */
-        sysinfo_fn_data_t fn_data;  /**< Generated binary data function */
-        sysinfo_data_t data;        /**< Constant binary data */
+        sysarg_t val;                      /**< Constant numberic value */
+        sysinfo_data_t data;               /**< Constant binary data */
+        sysinfo_gen_val_data_t gen_val;    /**< Generated numeric value function */
+        sysinfo_gen_data_data_t gen_data;  /**< Generated binary data function */
 } sysinfo_item_val_t;
 
@@ -95 +113 @@
 
 /** Generated subtree function */
-typedef sysinfo_return_t (*sysinfo_fn_subtree_t)(const char *, bool);
+typedef sysinfo_return_t (*sysinfo_fn_subtree_t)(const char *, bool, void *);
+
+/** Sysinfo generated subtree data
+ *
+ */
+typedef struct {
+        sysinfo_fn_subtree_t fn;  /**< Generated subtree function */
+        void *data;               /**< Private data */
+} sysinfo_gen_subtree_data_t;
 
 /** Sysinfo subtree (union)
@@ -101 +127 @@
  */
 typedef union {
-        struct sysinfo_item *table;     /**< Fixed subtree (list of subitems) */
-        sysinfo_fn_subtree_t get_data;  /**< Generated subtree function */
+        struct sysinfo_item *table;            /**< Fixed subtree (list of subitems) */
+        sysinfo_gen_subtree_data_t generator;  /**< Generated subtree */
 } sysinfo_subtree_t;
 
@@ -123 +149 @@
 extern void sysinfo_set_item_data(const char *, sysinfo_item_t **, void *,
     size_t);
-extern void sysinfo_set_item_fn_val(const char *, sysinfo_item_t **,
-    sysinfo_fn_val_t);
-extern void sysinfo_set_item_fn_data(const char *, sysinfo_item_t **,
-    sysinfo_fn_data_t);
+extern void sysinfo_set_item_gen_val(const char *, sysinfo_item_t **,
+    sysinfo_fn_val_t, void *);
+extern void sysinfo_set_item_gen_data(const char *, sysinfo_item_t **,
+    sysinfo_fn_data_t, void *);
 extern void sysinfo_set_item_undefined(const char *, sysinfo_item_t **);
 
 extern void sysinfo_set_subtree_fn(const char *, sysinfo_item_t **,
-    sysinfo_fn_subtree_t);
+    sysinfo_fn_subtree_t, void *);
 
 extern void sysinfo_init(void);
 extern void sysinfo_dump(sysinfo_item_t *);
 
+extern sysarg_t sys_sysinfo_get_keys_size(void *, size_t, void *);
+extern sysarg_t sys_sysinfo_get_keys(void *, size_t, void *, size_t, size_t *);
 extern sysarg_t sys_sysinfo_get_val_type(void *, size_t);
 extern sysarg_t sys_sysinfo_get_value(void *, size_t, void *);

kernel/generic/src/ddi/ddi.c

@@ -166 +166 @@
         }
         
-        if (zones.info[znum].flags & ZONE_FIRMWARE) {
-                /*
-                 * Frames are part of firmware
+        if (zones.info[znum].flags & (ZONE_FIRMWARE | ZONE_RESERVED)) {
+                /*
+                 * Frames are part of firmware or reserved zone
                  * -> allow mapping for privileged tasks.
                  */

kernel/generic/src/lib/func.c

@@ -53 +53 @@
 void halt()
 {
-#ifdef CONFIG_DEBUG
+#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE))
         bool rundebugger = false;
         

kernel/generic/src/main/main.c

@@ -221 +221 @@
         frame_init();
         slab_cache_init();
-        ra_init();      
+        ra_init();
         sysinfo_init();
         btree_init();
@@ -257 +257 @@
                 for (i = 0; i < init.cnt; i++)
                         LOG("init[%zu].addr=%p, init[%zu].size=%zu",
-                            i, (void *) init.tasks[i].addr, i, init.tasks[i].size);
+                            i, (void *) init.tasks[i].paddr, i, init.tasks[i].size);
         } else
                 printf("No init binaries found.\n");

kernel/generic/src/mm/page.c

@@ -168 +168 @@
 int page_find_mapping(uintptr_t virt, void **phys)
 {
-        mutex_lock(&AS->lock);
+        page_table_lock(AS, true);
         
         pte_t *pte = page_mapping_find(AS, virt, false);
         if ((!PTE_VALID(pte)) || (!PTE_PRESENT(pte))) {
-                mutex_unlock(&AS->lock);
+                page_table_unlock(AS, true);
                 return ENOENT;
         }
@@ -179 +179 @@
             (virt - ALIGN_DOWN(virt, PAGE_SIZE));
         
-        mutex_unlock(&AS->lock);
+        page_table_unlock(AS, true);
         
         return EOK;

kernel/generic/src/syscall/syscall.c

@@ -184 +184 @@
         
         /* Sysinfo syscalls. */
+        (syshandler_t) sys_sysinfo_get_keys_size,
+        (syshandler_t) sys_sysinfo_get_keys,
         (syshandler_t) sys_sysinfo_get_val_type,
         (syshandler_t) sys_sysinfo_get_value,

kernel/generic/src/sysinfo/stats.c

@@ -83 +83 @@
  *
  * @param item Sysinfo item (unused).
+ * @param data Unused.
  *
  * @return System uptime (in secords).
  *
  */
-static sysarg_t get_stats_uptime(struct sysinfo_item *item)
+static sysarg_t get_stats_uptime(struct sysinfo_item *item, void *data)
 {
         /* This doesn't have to be very accurate */
@@ -98 +99 @@
  * @param size    Size of the returned data.
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Data containing several stats_cpu_t structures.
@@ -104 +106 @@
  */
 static void *get_stats_cpus(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
+    bool dry_run, void *data)
 {
         *size = sizeof(stats_cpu_t) * config.cpu_count;
@@ -249 +251 @@
         ASSERT(interrupts_disabled());
         ASSERT(irq_spinlock_locked(&task->lock));
-
+        
         stats_task->task_id = task->taskid;
         str_cpy(stats_task->name, TASK_NAME_BUFLEN, task->name);
@@ -293 +295 @@
  * @param size    Size of the returned data.
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Data containing several stats_task_t structures.
@@ -299 +302 @@
  */
 static void *get_stats_tasks(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
+    bool dry_run, void *data)
 {
         /* Messing with task structures, avoid deadlock */
@@ -350 +353 @@
         ASSERT(interrupts_disabled());
         ASSERT(irq_spinlock_locked(&thread->lock));
-
+        
         stats_thread->thread_id = thread->tid;
         stats_thread->task_id = thread->task->taskid;
@@ -398 +401 @@
  * @param size    Size of the returned data.
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Data containing several stats_task_t structures.
@@ -404 +408 @@
  */
 static void *get_stats_threads(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
+    bool dry_run, void *data)
 {
         /* Messing with threads structures, avoid deadlock */
@@ -451 +455 @@
  * @param name    Task ID (string-encoded number).
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Sysinfo return holder. The type of the returned
@@ -460 +465 @@
  *
  */
-static sysinfo_return_t get_stats_task(const char *name, bool dry_run)
+static sysinfo_return_t get_stats_task(const char *name, bool dry_run,
+    void *data)
 {
         /* Initially no return value */
@@ -520 +526 @@
  * @param name    Thread ID (string-encoded number).
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Sysinfo return holder. The type of the returned
@@ -529 +536 @@
  *
  */
-static sysinfo_return_t get_stats_thread(const char *name, bool dry_run)
+static sysinfo_return_t get_stats_thread(const char *name, bool dry_run,
+    void *data)
 {
         /* Initially no return value */
@@ -586 +594 @@
  * @param size    Size of the returned data.
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Data containing several stats_exc_t structures.
@@ -592 +601 @@
  */
 static void *get_stats_exceptions(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
+    bool dry_run, void *data)
 {
         *size = sizeof(stats_exc_t) * IVT_ITEMS;
@@ -634 +643 @@
  * @param name    Exception number (string-encoded number).
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Sysinfo return holder. The type of the returned
@@ -643 +653 @@
  *
  */
-static sysinfo_return_t get_stats_exception(const char *name, bool dry_run)
+static sysinfo_return_t get_stats_exception(const char *name, bool dry_run,
+    void *data)
 {
         /* Initially no return value */
@@ -705 +716 @@
  * @param size    Size of the returned data.
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Data containing stats_physmem_t.
@@ -711 +723 @@
  */
 static void *get_stats_physmem(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
+    bool dry_run, void *data)
 {
         *size = sizeof(stats_physmem_t);
@@ -735 +747 @@
  * @param size    Size of the returned data.
  * @param dry_run Do not get the data, just calculate the size.
+ * @param data    Unused.
  *
  * @return Data several load_t values.
@@ -741 +754 @@
  */
 static void *get_stats_load(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
+    bool dry_run, void *data)
 {
         *size = sizeof(load_t) * LOAD_STEPS;
@@ -810 +823 @@
         mutex_initialize(&load_lock, MUTEX_PASSIVE);
         
-        sysinfo_set_item_fn_val("system.uptime", NULL, get_stats_uptime);
-        sysinfo_set_item_fn_data("system.cpus", NULL, get_stats_cpus);
-        sysinfo_set_item_fn_data("system.physmem", NULL, get_stats_physmem);
-        sysinfo_set_item_fn_data("system.load", NULL, get_stats_load);
-        sysinfo_set_item_fn_data("system.tasks", NULL, get_stats_tasks);
-        sysinfo_set_item_fn_data("system.threads", NULL, get_stats_threads);
-        sysinfo_set_item_fn_data("system.exceptions", NULL, get_stats_exceptions);
-        sysinfo_set_subtree_fn("system.tasks", NULL, get_stats_task);
-        sysinfo_set_subtree_fn("system.threads", NULL, get_stats_thread);
-        sysinfo_set_subtree_fn("system.exceptions", NULL, get_stats_exception);
+        sysinfo_set_item_gen_val("system.uptime", NULL, get_stats_uptime, NULL);
+        sysinfo_set_item_gen_data("system.cpus", NULL, get_stats_cpus, NULL);
+        sysinfo_set_item_gen_data("system.physmem", NULL, get_stats_physmem, NULL);
+        sysinfo_set_item_gen_data("system.load", NULL, get_stats_load, NULL);
+        sysinfo_set_item_gen_data("system.tasks", NULL, get_stats_tasks, NULL);
+        sysinfo_set_item_gen_data("system.threads", NULL, get_stats_threads, NULL);
+        sysinfo_set_item_gen_data("system.exceptions", NULL, get_stats_exceptions, NULL);
+        sysinfo_set_subtree_fn("system.tasks", NULL, get_stats_task, NULL);
+        sysinfo_set_subtree_fn("system.threads", NULL, get_stats_thread, NULL);
+        sysinfo_set_subtree_fn("system.exceptions", NULL, get_stats_exception, NULL);
 }
 

kernel/generic/src/sysinfo/sysinfo.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2006 Jakub Vana
+ * Copyright (c) 2012 Martin Decky
  * All rights reserved.
  *
@@ -99 +100 @@
             sizeof(sysinfo_item_t), 0, sysinfo_item_constructor,
             sysinfo_item_destructor, SLAB_CACHE_MAGDEFERRED);
-
+        
         mutex_initialize(&sysinfo_lock, MUTEX_ACTIVE);
 }
@@ -110 +111 @@
  * @param subtree Current sysinfo (sub)tree root item.
  * @param ret     If the return value is NULL, this argument
- *                can be either also NULL (i.e. no item was
+ *                can be set either to NULL (i.e. no item was
  *                found and no data was generated) or the
  *                original pointer is used to store the value
@@ -125 +126 @@
 {
         ASSERT(subtree != NULL);
-        ASSERT(ret != NULL);
         
         sysinfo_item_t *cur = subtree;
@@ -151 +151 @@
                         case SYSINFO_SUBTREE_FUNCTION:
                                 /* Get generated data */
-                                **ret = cur->subtree.get_data(name + i + 1, dry_run);
+                                if (ret != NULL)
+                                        **ret = cur->subtree.generator.fn(name + i + 1,
+                                            dry_run, cur->subtree.generator.data);
+                                
                                 return NULL;
                         default:
                                 /* Not found, no data generated */
-                                *ret = NULL;
+                                if (ret != NULL)
+                                        *ret = NULL;
+                                
                                 return NULL;
                         }
@@ -164 +169 @@
         
         /* Not found, no data generated */
-        *ret = NULL;
+        if (ret != NULL)
+                *ret = NULL;
+        
         return NULL;
 }
@@ -352 +359 @@
  *             a new root item (NULL for global sysinfo root).
  * @param fn   Numeric value generator function.
- *
- */
-void sysinfo_set_item_fn_val(const char *name, sysinfo_item_t **root,
-    sysinfo_fn_val_t fn)
+ * @param data Private data.
+ *
+ */
+void sysinfo_set_item_gen_val(const char *name, sysinfo_item_t **root,
+    sysinfo_fn_val_t fn, void *data)
 {
         /* Protect sysinfo tree consistency */
@@ -366 +374 @@
         if (item != NULL) {
                 item->val_type = SYSINFO_VAL_FUNCTION_VAL;
-                item->val.fn_val = fn;
+                item->val.gen_val.fn = fn;
+                item->val.gen_val.data = data;
         }
         
@@ -383 +392 @@
  *             a new root item (NULL for global sysinfo root).
  * @param fn   Binary data generator function.
- *
- */
-void sysinfo_set_item_fn_data(const char *name, sysinfo_item_t **root,
-    sysinfo_fn_data_t fn)
+ * @param data Private data.
+ *
+ */
+void sysinfo_set_item_gen_data(const char *name, sysinfo_item_t **root,
+    sysinfo_fn_data_t fn, void *data)
 {
         /* Protect sysinfo tree consistency */
@@ -397 +407 @@
         if (item != NULL) {
                 item->val_type = SYSINFO_VAL_FUNCTION_DATA;
-                item->val.fn_data = fn;
+                item->val.gen_data.fn = fn;
+                item->val.gen_data.data = data;
         }
         
@@ -431 +442 @@
  *             a new root item (NULL for global sysinfo root).
  * @param fn   Subtree generator function.
+ * @param data Private data to be passed to the generator.
  *
  */
 void sysinfo_set_subtree_fn(const char *name, sysinfo_item_t **root,
-    sysinfo_fn_subtree_t fn)
+    sysinfo_fn_subtree_t fn, void *data)
 {
         /* Protect sysinfo tree consistency */
@@ -448 +460 @@
         if ((item != NULL) && (item->subtree_type != SYSINFO_SUBTREE_TABLE)) {
                 item->subtree_type = SYSINFO_SUBTREE_FUNCTION;
-                item->subtree.get_data = fn;
+                item->subtree.generator.fn = fn;
+                item->subtree.generator.data = data;
         }
         
@@ -456 +469 @@
 /** Sysinfo dump indentation helper routine
  *
- * @param depth Number of indentation characters to print.
- *
- */
-NO_TRACE static void sysinfo_indent(unsigned int depth)
-{
-        unsigned int i;
-        for (i = 0; i < depth; i++)
-                printf("  ");
+ * @param depth Number of spaces to print.
+ *
+ */
+NO_TRACE static void sysinfo_indent(size_t spaces)
+{
+        for (size_t i = 0; i < spaces; i++)
+                printf(" ");
 }
 
@@ -470 +482 @@
  * Should be called with sysinfo_lock held.
  *
- * @param root  Root item of the current (sub)tree.
- * @param depth Current depth in the sysinfo tree.
- *
- */
-NO_TRACE static void sysinfo_dump_internal(sysinfo_item_t *root, unsigned int depth)
-{
-        sysinfo_item_t *cur = root;
-        
+ * @param root   Root item of the current (sub)tree.
+ * @param spaces Current indentation level.
+ *
+ */
+NO_TRACE static void sysinfo_dump_internal(sysinfo_item_t *root, size_t spaces)
+{
         /* Walk all siblings */
-        while (cur != NULL) {
-                sysinfo_indent(depth);
+        for (sysinfo_item_t *cur = root; cur; cur = cur->next) {
+                size_t length;
+                
+                if (spaces == 0) {
+                        printf("%s", cur->name);
+                        length = str_length(cur->name);
+                } else {
+                        sysinfo_indent(spaces);
+                        printf(".%s", cur->name);
+                        length = str_length(cur->name) + 1;
+                }
                 
                 sysarg_t val;
@@ -488 +507 @@
                 switch (cur->val_type) {
                 case SYSINFO_VAL_UNDEFINED:
-                        printf("+ %s\n", cur->name);
+                        printf(" [undefined]\n");
                         break;
                 case SYSINFO_VAL_VAL:
-                        printf("+ %s -> %" PRIun" (%#" PRIxn ")\n", cur->name,
-                            cur->val.val, cur->val.val);
+                        printf(" -> %" PRIun" (%#" PRIxn ")\n", cur->val.val,
+                            cur->val.val);
                         break;
                 case SYSINFO_VAL_DATA:
-                        printf("+ %s (%zu bytes)\n", cur->name,
-                            cur->val.data.size);
+                        printf(" (%zu bytes)\n", cur->val.data.size);
                         break;
                 case SYSINFO_VAL_FUNCTION_VAL:
-                        val = cur->val.fn_val(cur);
-                        printf("+ %s -> %" PRIun" (%#" PRIxn ") [generated]\n",
-                            cur->name, val, val);
+                        val = cur->val.gen_val.fn(cur, cur->val.gen_val.data);
+                        printf(" -> %" PRIun" (%#" PRIxn ") [generated]\n", val,
+                            val);
                         break;
                 case SYSINFO_VAL_FUNCTION_DATA:
                         /* N.B.: No data was actually returned (only a dry run) */
-                        (void) cur->val.fn_data(cur, &size, true);
-                        printf("+ %s (%zu bytes) [generated]\n", cur->name,
-                            size);
+                        (void) cur->val.gen_data.fn(cur, &size, true,
+                            cur->val.gen_data.data);
+                        printf(" (%zu bytes) [generated]\n", size);
                         break;
                 default:
@@ -518 +536 @@
                         break;
                 case SYSINFO_SUBTREE_TABLE:
-                        sysinfo_dump_internal(cur->subtree.table, depth + 1);
+                        sysinfo_dump_internal(cur->subtree.table, spaces + length);
                         break;
                 case SYSINFO_SUBTREE_FUNCTION:
-                        sysinfo_indent(depth + 1);
-                        printf("+ [generated subtree]\n");
+                        sysinfo_indent(spaces + length);
+                        printf("<generated subtree>\n");
                         break;
                 default:
-                        sysinfo_indent(depth + 1);
-                        printf("+ [unknown subtree]\n");
+                        sysinfo_indent(spaces + length);
+                        printf("<unknown subtree>\n");
                 }
-                
-                cur = cur->next;
         }
 }
@@ -594 +610 @@
                         break;
                 case SYSINFO_VAL_FUNCTION_VAL:
-                        ret.val = item->val.fn_val(item);
+                        ret.val = item->val.gen_val.fn(item, item->val.gen_val.data);
                         break;
                 case SYSINFO_VAL_FUNCTION_DATA:
-                        ret.data.data = item->val.fn_data(item, &ret.data.size,
-                            dry_run);
+                        ret.data.data = item->val.gen_data.fn(item, &ret.data.size,
+                            dry_run, item->val.gen_data.data);
                         break;
                 }
@@ -635 +651 @@
         ASSERT(path);
         
-        if ((copy_from_uspace(path, ptr, size + 1) == 0)
-            && (path[size] == 0)) {
+        if ((copy_from_uspace(path, ptr, size + 1) == 0) &&
+            (path[size] == 0)) {
                 /*
                  * Prevent other functions from messing with sysinfo while we
@@ -645 +661 @@
                 mutex_unlock(&sysinfo_lock);
         }
+        
         free(path);
         return ret;
+}
+
+/** Return sysinfo keys determined by name
+ *
+ * Should be called with sysinfo_lock held.
+ *
+ * @param name    Sysinfo path.
+ * @param root    Root item of the sysinfo (sub)tree.
+ *                If it is NULL then consider the global
+ *                sysinfo tree.
+ * @param dry_run Do not actually get any generated
+ *                binary data, just calculate the size.
+ *
+ * @return Item value (constant or generated).
+ *
+ */
+NO_TRACE static sysinfo_return_t sysinfo_get_keys(const char *name,
+    sysinfo_item_t **root, bool dry_run)
+{
+        if (root == NULL)
+                root = &global_root;
+        
+        sysinfo_item_t *subtree = NULL;
+        
+        if (name[0] != 0) {
+                /* Try to find the item */
+                sysinfo_item_t *item =
+                    sysinfo_find_item(name, *root, NULL, dry_run);
+                if ((item != NULL) &&
+                    (item->subtree_type == SYSINFO_SUBTREE_TABLE))
+                        subtree = item->subtree.table;
+        } else
+                subtree = *root;
+        
+        sysinfo_return_t ret;
+        
+        if (subtree != NULL) {
+                /*
+                 * Calculate the size of subkeys.
+                 */
+                size_t size = 0;
+                for (sysinfo_item_t *cur = subtree; cur; cur = cur->next)
+                        size += str_size(cur->name) + 1;
+                
+                if (dry_run) {
+                        ret.tag = SYSINFO_VAL_DATA;
+                        ret.data.data = NULL;
+                        ret.data.size = size;
+                } else {
+                        /* Allocate buffer for subkeys */
+                        char *names = (char *) malloc(size, FRAME_ATOMIC);
+                        if (names == NULL)
+                                return ret;
+                        
+                        size_t pos = 0;
+                        for (sysinfo_item_t *cur = subtree; cur; cur = cur->next) {
+                                str_cpy(names + pos, size - pos, cur->name);
+                                pos += str_size(cur->name) + 1;
+                        }
+                        
+                        /* Correct return value */
+                        ret.tag = SYSINFO_VAL_DATA;
+                        ret.data.data = (void *) names;
+                        ret.data.size = size;
+                }
+        } else {
+                /* No item in the fixed sysinfo tree */
+                ret.tag = SYSINFO_VAL_UNDEFINED;
+        }
+        
+        return ret;
+}
+
+/** Return sysinfo keys determined by name from user space
+ *
+ * The path string passed from the user space has to be properly
+ * null-terminated (the last passed character must be null).
+ *
+ * @param ptr     Sysinfo path in the user address space.
+ * @param size    Size of the path string.
+ * @param dry_run Do not actually get any generated
+ *                binary data, just calculate the size.
+ *
+ */
+NO_TRACE static sysinfo_return_t sysinfo_get_keys_uspace(void *ptr, size_t size,
+    bool dry_run)
+{
+        sysinfo_return_t ret;
+        ret.tag = SYSINFO_VAL_UNDEFINED;
+        
+        if (size > SYSINFO_MAX_PATH)
+                return ret;
+        
+        char *path = (char *) malloc(size + 1, 0);
+        ASSERT(path);
+        
+        if ((copy_from_uspace(path, ptr, size + 1) == 0) &&
+            (path[size] == 0)) {
+                /*
+                 * Prevent other functions from messing with sysinfo while we
+                 * are reading it.
+                 */
+                mutex_lock(&sysinfo_lock);
+                ret = sysinfo_get_keys(path, NULL, dry_run);
+                mutex_unlock(&sysinfo_lock);
+        }
+        
+        free(path);
+        return ret;
+}
+
+/** Get the sysinfo keys size (syscall)
+ *
+ * The path string passed from the user space has
+ * to be properly null-terminated (the last passed
+ * character must be null).
+ *
+ * @param path_ptr  Sysinfo path in the user address space.
+ * @param path_size Size of the path string.
+ * @param size_ptr  User space pointer where to store the
+ *                  keys size.
+ *
+ * @return Error code (EOK in case of no error).
+ *
+ */
+sysarg_t sys_sysinfo_get_keys_size(void *path_ptr, size_t path_size,
+    void *size_ptr)
+{
+        int rc;
+        
+        /*
+         * Get the keys.
+         *
+         * N.B.: There is no need to free any potential keys
+         * since we request a dry run.
+         */
+        sysinfo_return_t ret =
+            sysinfo_get_keys_uspace(path_ptr, path_size, true);
+        
+        /* Check return data tag */
+        if (ret.tag == SYSINFO_VAL_DATA)
+                rc = copy_to_uspace(size_ptr, &ret.data.size,
+                    sizeof(ret.data.size));
+        else
+                rc = EINVAL;
+        
+        return (sysarg_t) rc;
+}
+
+/** Get the sysinfo keys (syscall)
+ *
+ * The path string passed from the user space has
+ * to be properly null-terminated (the last passed
+ * character must be null).
+ *
+ * If the user space buffer size does not equal
+ * the actual size of the returned data, the data
+ * is truncated.
+ *
+ * The actual size of data returned is stored to
+ * size_ptr.
+ *
+ * @param path_ptr    Sysinfo path in the user address space.
+ * @param path_size   Size of the path string.
+ * @param buffer_ptr  User space pointer to the buffer where
+ *                    to store the binary data.
+ * @param buffer_size User space buffer size.
+ * @param size_ptr    User space pointer where to store the
+ *                    binary data size.
+ *
+ * @return Error code (EOK in case of no error).
+ *
+ */
+sysarg_t sys_sysinfo_get_keys(void *path_ptr, size_t path_size,
+    void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
+{
+        int rc;
+        
+        /* Get the keys */
+        sysinfo_return_t ret = sysinfo_get_keys_uspace(path_ptr, path_size,
+            false);
+        
+        /* Check return data tag */
+        if (ret.tag == SYSINFO_VAL_DATA) {
+                size_t size = min(ret.data.size, buffer_size);
+                rc = copy_to_uspace(buffer_ptr, ret.data.data, size);
+                if (rc == EOK)
+                        rc = copy_to_uspace(size_ptr, &size, sizeof(size));
+                
+                free(ret.data.data);
+        } else
+                rc = EINVAL;
+        
+        return (sysarg_t) rc;
 }
 
@@ -672 +883 @@
         
         /*
-         * Map generated value types to constant types (user space does not care
-         * whether the value is constant or generated).
+         * Map generated value types to constant types (user space does
+         * not care whether the value is constant or generated).
          */
         if (ret.tag == SYSINFO_VAL_FUNCTION_VAL)
@@ -701 +912 @@
 {
         int rc;
-
+        
         /*
          * Get the item.
          *
-         * N.B.: There is no need to free any potential generated binary data
-         * since we request a dry run.
+         * N.B.: There is no need to free any potential generated binary
+         * data since we request a dry run.
          */
         sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size, true);
@@ -741 +952 @@
          * Get the item.
          *
-         * N.B.: There is no need to free any potential generated binary data
-         * since we request a dry run.
+         * N.B.: There is no need to free any potential generated binary
+         * data since we request a dry run.
          */
         sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size, true);

uspace/Makefile

@@ -48 +48 @@
         app/lsusb \
         app/mkfat \
+        app/mkexfat \
         app/mkmfs \
         app/redir \

uspace/app/sysinfo/sysinfo.c

@@ -37 +37 @@
 #include <stdio.h>
 #include <sysinfo.h>
+#include <malloc.h>
 #include <sys/types.h>
 
-static int print_item_val(char *ipath);
-static int print_item_data(char *ipath);
-
-static void dump_bytes_hex(char *data, size_t size);
-static void dump_bytes_text(char *data, size_t size);
-
-static void print_syntax(void);
-
-int main(int argc, char *argv[])
-{
-        int rc;
-        char *ipath;
-        sysinfo_item_val_type_t tag;
-
-        if (argc != 2) {
-                print_syntax();
-                return 1;
-        }
-
-        ipath = argv[1];
-
-        tag = sysinfo_get_val_type(ipath);
-
-        /* Silence warning */
-        rc = EOK;
-
-        switch (tag) {
-        case SYSINFO_VAL_UNDEFINED:
-                printf("Error: Sysinfo item '%s' not defined.\n", ipath);
-                rc = 2;
-                break;
-        case SYSINFO_VAL_VAL:
-                rc = print_item_val(ipath);
-                break;
-        case SYSINFO_VAL_DATA:
-                rc = print_item_data(ipath);
-                break;
-        default:
-                printf("Error: Sysinfo item '%s' with unknown value type.\n",
-                    ipath);
-                rc = 2;
-                break;
-        }
-
-        return rc;
+static void dump_bytes_hex(char *data, size_t size)
+{
+        for (size_t i = 0; i < size; i++) {
+                if (i > 0)
+                        putchar(' ');
+                printf("0x%02x", (uint8_t) data[i]);
+        }
+}
+
+static void dump_bytes_text(char *data, size_t size)
+{
+        size_t offset = 0;
+        
+        while (offset < size) {
+                wchar_t c = str_decode(data, &offset, size);
+                printf("%lc", (wint_t) c);
+        }
 }
 
@@ -89 +62 @@
 {
         sysarg_t value;
-        int rc;
-
-        rc = sysinfo_get_value(ipath, &value);
+        int rc = sysinfo_get_value(ipath, &value);
         if (rc != EOK) {
                 printf("Error reading item '%s'.\n", ipath);
                 return rc;
         }
-
+        
         printf("%s -> %" PRIu64 " (0x%" PRIx64 ")\n", ipath,
             (uint64_t) value, (uint64_t) value);
-
+        
         return EOK;
 }
@@ -105 +76 @@
 static int print_item_data(char *ipath)
 {
-        void *data;
         size_t size;
-
-        data = sysinfo_get_data(ipath, &size);
+        void *data = sysinfo_get_data(ipath, &size);
         if (data == NULL) {
                 printf("Error reading item '%s'.\n", ipath);
                 return -1;
         }
-
+        
         printf("%s -> ", ipath);
         dump_bytes_hex(data, size);
@@ -119 +88 @@
         dump_bytes_text(data, size);
         fputs("')\n", stdout);
-
+        
         return EOK;
 }
 
-static void dump_bytes_hex(char *data, size_t size)
-{
-        size_t i;
-
-        for (i = 0; i < size; ++i) {
-                if (i > 0) putchar(' ');
-                printf("0x%02x", (uint8_t) data[i]);
-        }
-}
-
-static void dump_bytes_text(char *data, size_t size)
-{
-        wchar_t c;
-        size_t offset;
-
-        offset = 0;
-
-        while (offset < size) {
-                c = str_decode(data, &offset, size);
-                printf("%lc", (wint_t) c);
-        }
-}
-
-
-static void print_syntax(void)
-{
-        printf("Syntax: sysinfo <item_path>\n");
+static int print_item_property(char *ipath, char *iprop)
+{
+        size_t size;
+        void *data = sysinfo_get_property(ipath, iprop, &size);
+        if (data == NULL) {
+                printf("Error reading property '%s' of item '%s'.\n", iprop,
+                    ipath);
+                return -1;
+        }
+        
+        printf("%s property %s -> ", ipath, iprop);
+        dump_bytes_hex(data, size);
+        fputs(" ('", stdout);
+        dump_bytes_text(data, size);
+        fputs("')\n", stdout);
+        
+        return EOK;
+}
+
+static void print_spaces(size_t spaces)
+{
+        for (size_t i = 0; i < spaces; i++)
+                printf(" ");
+}
+
+static void print_keys(const char *path, size_t spaces)
+{
+        size_t size;
+        char *keys = sysinfo_get_keys(path, &size);
+        if ((keys == NULL) || (size == 0))
+                return;
+        
+        size_t pos = 0;
+        while (pos < size) {
+                /* Process each key with sanity checks */
+                size_t cur_size = str_nsize(keys + pos, size - pos);
+                if (keys[pos + cur_size] != 0)
+                        break;
+                
+                size_t path_size = str_size(path) + cur_size + 2;
+                char *cur_path = (char *) malloc(path_size);
+                if (cur_path == NULL)
+                        break;
+                
+                size_t length;
+                
+                if (path[0] != 0) {
+                        print_spaces(spaces);
+                        printf(".%s\n", keys + pos);
+                        length = str_length(keys + pos) + 1;
+                        
+                        snprintf(cur_path, path_size, "%s.%s", path, keys + pos);
+                } else {
+                        printf("%s\n", keys + pos);
+                        length = str_length(keys + pos);
+                        
+                        snprintf(cur_path, path_size, "%s", keys + pos);
+                }
+                
+                print_keys(cur_path, spaces + length);
+                
+                free(cur_path);
+                pos += cur_size + 1;
+        }
+        
+        free(keys);
+}
+
+int main(int argc, char *argv[])
+{
+        int rc = 0;
+        
+        if (argc < 2) {
+                /* Print keys */
+                print_keys("", 0);
+                return rc;
+        }
+        
+        char *ipath = argv[1];
+        
+        if (argc < 3) {
+                sysinfo_item_val_type_t tag = sysinfo_get_val_type(ipath);
+                
+                switch (tag) {
+                case SYSINFO_VAL_UNDEFINED:
+                        printf("Error: Sysinfo item '%s' not defined.\n", ipath);
+                        rc = 2;
+                        break;
+                case SYSINFO_VAL_VAL:
+                        rc = print_item_val(ipath);
+                        break;
+                case SYSINFO_VAL_DATA:
+                        rc = print_item_data(ipath);
+                        break;
+                default:
+                        printf("Error: Sysinfo item '%s' with unknown value type.\n",
+                            ipath);
+                        rc = 2;
+                        break;
+                }
+                
+                return rc;
+        }
+        
+        char *iprop = argv[2];
+        rc = print_item_property(ipath, iprop);
+        return rc;
 }
 

uspace/drv/bus/usb/uhci/transfer_list.c

@@ -110 +110 @@
         assert(instance);
         assert(uhci_batch);
-        usb_log_debug2("Queue %s: Adding batch(%p).\n", instance->name,
-            uhci_batch->usb_batch);
+        usb_log_debug2("Batch %p adding to queue %s.\n",
+            uhci_batch->usb_batch, instance->name);
 
         fibril_mutex_lock(&instance->guard);
@@ -139 +139 @@
         list_append(&uhci_batch->link, &instance->batch_list);
 
-        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " scheduled in queue %s.\n",
-            uhci_batch, USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch),
-            instance->name);
+        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT
+            " scheduled in queue %s.\n", uhci_batch->usb_batch,
+            USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch), instance->name);
         fibril_mutex_unlock(&instance->guard);
 }
@@ -205 +205 @@
         assert(fibril_mutex_is_locked(&instance->guard));
 
-        usb_log_debug2("Queue %s: removing batch(%p).\n",
-            instance->name, uhci_batch->usb_batch);
+        usb_log_debug2("Batch %p removing from queue %s.\n",
+            uhci_batch->usb_batch, instance->name);
 
         /* Assume I'm the first */
@@ -228 +228 @@
         list_remove(&uhci_batch->link);
         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " removed (%s) "
-            "from %s, next: %x.\n",
-            uhci_batch, USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch),
+            "from %s, next: %x.\n", uhci_batch->usb_batch,
+            USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch),
             qpos, instance->name, uhci_batch->qh->next);
 }

uspace/drv/bus/usb/uhci/uhci_batch.c

@@ -174 +174 @@
                         assert(uhci_batch->usb_batch->ep != NULL);
 
-                        usb_log_debug("Batch(%p) found error TD(%zu):%"
+                        usb_log_debug("Batch %p found error TD(%zu->%p):%"
                             PRIx32 ".\n", uhci_batch->usb_batch, i,
-                            uhci_batch->tds[i].status);
+                            &uhci_batch->tds[i], uhci_batch->tds[i].status);
                         td_print_status(&uhci_batch->tds[i]);
 

uspace/drv/char/ps2mouse/ps2mouse.c

@@ -80 +80 @@
         } \
         if (data != (value)) { \
-                ddf_msg(LVL_ERROR, "Failed testing byte: got %hhx vs. %hhx)", \
+                ddf_msg(LVL_DEBUG, "Failed testing byte: got %hhx vs. %hhx)", \
                     data, (value)); \
                 return EIO; \

uspace/drv/infrastructure/root/root.c

@@ -158 +158 @@
         if (asprintf(&match_id, PLATFORM_FUN_MATCH_ID_FMT, platform) == -1) {
                 ddf_msg(LVL_ERROR, "Memory allocation failed.");
-                return ENOMEM;
-        }
+                free(platform);
+                return ENOMEM;
+        }
+
+        free(platform);
 
         /* Add function. */
@@ -169 +172 @@
         if (fun == NULL) {
                 ddf_msg(LVL_ERROR, "Error creating function %s", name);
+                free(match_id);
                 return ENOMEM;
         }
@@ -176 +180 @@
                 ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
                     name);
+                free(match_id);
                 ddf_fun_destroy(fun);
                 return rc;
@@ -208 +213 @@
          * vital for the system.
          */
-        add_virtual_root_fun(dev);
+        (void) add_virtual_root_fun(dev);
 
         /* Register root device's children. */

uspace/lib/c/arch/ia64/include/ddi.h

@@ -62 +62 @@
 
         asm volatile ("mf\n" ::: "memory");
+        asm volatile ("mf.a\n" ::: "memory");
 }
 
@@ -76 +77 @@
 
         asm volatile ("mf\n" ::: "memory");
+        asm volatile ("mf.a\n" ::: "memory");
 }
 
@@ -90 +92 @@
 
         asm volatile ("mf\n" ::: "memory");
+        asm volatile ("mf.a\n" ::: "memory");
 }
 
@@ -106 +109 @@
                 v = *port;
         }
+
+        asm volatile ("mf.a\n" ::: "memory");
 
         return v;
@@ -125 +130 @@
         }
 
+        asm volatile ("mf.a\n" ::: "memory");
+
         return v;
 }
@@ -134 +141 @@
         asm volatile ("mf\n" ::: "memory");
 
-        if (port < (ioport32_t *) port) {
+        if (port < (ioport32_t *) IO_SPACE_BOUNDARY) {
                 uintptr_t prt = (uintptr_t) port;
 
@@ -143 +150 @@
         }
 
+        asm volatile ("mf.a\n" ::: "memory");
+
         return v;
 }

uspace/lib/c/generic/str.c

@@ -259 +259 @@
         
         return offset;
+}
+
+/** Get size of string with size limit.
+ *
+ * Get the number of bytes which are used by the string @a str
+ * (excluding the NULL-terminator), but no more than @max_size bytes.
+ *
+ * @param str      String to consider.
+ * @param max_size Maximum number of bytes to measure.
+ *
+ * @return Number of bytes used by the string
+ *
+ */
+size_t str_nsize(const char *str, size_t max_size)
+{
+        size_t size = 0;
+        
+        while ((*str++ != 0) && (size < max_size))
+                size++;
+        
+        return size;
+}
+
+/** Get size of wide string with size limit.
+ *
+ * Get the number of bytes which are used by the wide string @a str
+ * (excluding the NULL-terminator), but no more than @max_size bytes.
+ *
+ * @param str      Wide string to consider.
+ * @param max_size Maximum number of bytes to measure.
+ *
+ * @return Number of bytes used by the wide string
+ *
+ */
+size_t wstr_nsize(const wchar_t *str, size_t max_size)
+{
+        return (wstr_nlength(str, max_size) * sizeof(wchar_t));
 }
 

uspace/lib/c/generic/sysinfo.c

@@ -40 +40 @@
 #include <bool.h>
 
+/** Get sysinfo keys size
+ *
+ * @param path  Sysinfo path.
+ * @param value Pointer to store the keys size.
+ *
+ * @return EOK if the keys were successfully read.
+ *
+ */
+static int sysinfo_get_keys_size(const char *path, size_t *size)
+{
+        return (int) __SYSCALL3(SYS_SYSINFO_GET_KEYS_SIZE, (sysarg_t) path,
+            (sysarg_t) str_size(path), (sysarg_t) size);
+}
+
+/** Get sysinfo keys
+ *
+ * @param path  Sysinfo path.
+ * @param value Pointer to store the keys size.
+ *
+ * @return Keys read from sysinfo or NULL if the
+ *         sysinfo item has no subkeys.
+ *         The returned non-NULL pointer should be
+ *         freed by free().
+ *
+ */
+char *sysinfo_get_keys(const char *path, size_t *size)
+{
+        /*
+         * The size of the keys might change during time.
+         * Unfortunatelly we cannot allocate the buffer
+         * and transfer the keys as a single atomic operation.
+         */
+        
+        /* Get the keys size */
+        int ret = sysinfo_get_keys_size(path, size);
+        if ((ret != EOK) || (size == 0)) {
+                /*
+                 * Item with no subkeys.
+                 */
+                *size = 0;
+                return NULL;
+        }
+        
+        char *data = malloc(*size);
+        if (data == NULL) {
+                *size = 0;
+                return NULL;
+        }
+        
+        /* Get the data */
+        size_t sz;
+        ret = __SYSCALL5(SYS_SYSINFO_GET_KEYS, (sysarg_t) path,
+            (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size,
+            (sysarg_t) &sz);
+        if (ret == EOK) {
+                *size = sz;
+                return data;
+        }
+        
+        free(data);
+        *size = 0;
+        return NULL;
+}
+
 /** Get sysinfo item type
  *
@@ -70 +134 @@
 /** Get sysinfo binary data size
  *
- * @param path  Sysinfo path.
- * @param value Pointer to store the binary data size.
+ * @param path Sysinfo path.
+ * @param size Pointer to store the binary data size.
  *
  * @return EOK if the value was successfully read and
@@ -85 +149 @@
 /** Get sysinfo binary data
  *
- * @param path  Sysinfo path.
- * @param value Pointer to store the binary data size.
+ * @param path Sysinfo path.
+ * @param size Pointer to store the binary data size.
  *
  * @return Binary data read from sysinfo or NULL if the
@@ -134 +198 @@
 }
 
+/** Get sysinfo property
+ *
+ * @param path Sysinfo path.
+ * @param name Property name.
+ * @param size Pointer to store the binary data size.
+ *
+ * @return Property value read from sysinfo or NULL if the
+ *         sysinfo item value type is not binary data.
+ *         The returned non-NULL pointer should be
+ *         freed by free().
+ *
+ */
+void *sysinfo_get_property(const char *path, const char *name, size_t *size)
+{
+        size_t total_size;
+        void *data = sysinfo_get_data(path, &total_size);
+        if ((data == NULL) || (total_size == 0)) {
+                *size = 0;
+                return NULL;
+        }
+        
+        size_t pos = 0;
+        while (pos < total_size) {
+                /* Process each property with sanity checks */
+                size_t cur_size = str_nsize(data + pos, total_size - pos);
+                if (((char *) data)[pos + cur_size] != 0)
+                        break;
+                
+                bool found = (str_cmp(data + pos, name) == 0);
+                
+                pos += cur_size + 1;
+                if (pos >= total_size)
+                        break;
+                
+                /* Process value size */
+                size_t value_size;
+                memcpy(&value_size, data + pos, sizeof(value_size));
+                
+                pos += sizeof(value_size);
+                if ((pos >= total_size) || (pos + value_size > total_size))
+                        break;
+                
+                if (found) {
+                        void *value = malloc(value_size);
+                        if (value == NULL)
+                                break;
+                        
+                        memcpy(value, data + pos, value_size);
+                        free(data);
+                        
+                        *size = value_size;
+                        return value;
+                }
+                
+                pos += value_size;
+        }
+        
+        free(data);
+        
+        *size = 0;
+        return NULL;
+}
+
 /** @}
  */

uspace/lib/c/include/str.h

@@ -60 +60 @@
 extern size_t str_size(const char *str);
 extern size_t wstr_size(const wchar_t *str);
+
+extern size_t str_nsize(const char *str, size_t max_size);
+extern size_t wstr_nsize(const wchar_t *str, size_t max_size);
 
 extern size_t str_lsize(const char *str, size_t max_len);

uspace/lib/c/include/sysinfo.h

@@ -40 +40 @@
 #include <abi/sysinfo.h>
 
+extern char *sysinfo_get_keys(const char *, size_t *);
 extern sysinfo_item_val_type_t sysinfo_get_val_type(const char *);
 extern int sysinfo_get_value(const char *, sysarg_t *);
 extern void *sysinfo_get_data(const char *, size_t *);
+extern void *sysinfo_get_property(const char *, const char *, size_t *);
 
 #endif

uspace/srv/fs/exfat/exfat_bitmap.c

@@ -48 +48 @@
 
 
-int bitmap_is_free(exfat_bs_t *bs, service_id_t service_id, 
+int exfat_bitmap_is_free(exfat_bs_t *bs, service_id_t service_id, 
     exfat_cluster_t clst)
 {
@@ -89 +89 @@
 }
 
-int bitmap_set_cluster(exfat_bs_t *bs, service_id_t service_id, 
+int exfat_bitmap_set_cluster(exfat_bs_t *bs, service_id_t service_id, 
     exfat_cluster_t clst)
 {
@@ -124 +124 @@
 }
 
-int bitmap_clear_cluster(exfat_bs_t *bs, service_id_t service_id, 
+int exfat_bitmap_clear_cluster(exfat_bs_t *bs, service_id_t service_id, 
     exfat_cluster_t clst)
 {
@@ -160 +160 @@
 }
 
-int bitmap_set_clusters(exfat_bs_t *bs, service_id_t service_id, 
+int exfat_bitmap_set_clusters(exfat_bs_t *bs, service_id_t service_id, 
     exfat_cluster_t firstc, exfat_cluster_t count)
 {
@@ -168 +168 @@
 
         while (clst < firstc + count ) {
-                rc = bitmap_set_cluster(bs, service_id, clst);
+                rc = exfat_bitmap_set_cluster(bs, service_id, clst);
                 if (rc != EOK) {
                         if (clst - firstc > 0)
-                                (void) bitmap_clear_clusters(bs, service_id,
+                                (void) exfat_bitmap_clear_clusters(bs, service_id,
                                     firstc, clst - firstc);
                         return rc;
@@ -180 +180 @@
 }
 
-int bitmap_clear_clusters(exfat_bs_t *bs, service_id_t service_id, 
+int exfat_bitmap_clear_clusters(exfat_bs_t *bs, service_id_t service_id, 
     exfat_cluster_t firstc, exfat_cluster_t count)
 {
@@ -188 +188 @@
 
         while (clst < firstc + count) {
-                rc = bitmap_clear_cluster(bs, service_id, clst);
+                rc = exfat_bitmap_clear_cluster(bs, service_id, clst);
                 if (rc != EOK)
                         return rc;
@@ -196 +196 @@
 }
 
-int bitmap_alloc_clusters(exfat_bs_t *bs, service_id_t service_id, 
+int exfat_bitmap_alloc_clusters(exfat_bs_t *bs, service_id_t service_id, 
     exfat_cluster_t *firstc, exfat_cluster_t count)
 {
@@ -204 +204 @@
         while (startc < DATA_CNT(bs) + 2) {
                 endc = startc;
-                while (bitmap_is_free(bs, service_id, endc) == EOK) {
+                while (exfat_bitmap_is_free(bs, service_id, endc) == EOK) {
                         if ((endc - startc) + 1 == count) {
                                 *firstc = startc;
-                                return bitmap_set_clusters(bs, service_id, startc, count);
+                                return exfat_bitmap_set_clusters(bs, service_id, startc, count);
                         } else
                                 endc++;
@@ -217 +217 @@
 
 
-int bitmap_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep, 
+int exfat_bitmap_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep, 
     exfat_cluster_t count)
 {
         if (nodep->firstc == 0) {
-                return bitmap_alloc_clusters(bs, nodep->idx->service_id, 
+                return exfat_bitmap_alloc_clusters(bs, nodep->idx->service_id, 
                     &nodep->firstc, count);
         } else {
@@ -228 +228 @@
 
                 clst = lastc + 1;
-                while (bitmap_is_free(bs, nodep->idx->service_id, clst) == EOK) {
+                while (exfat_bitmap_is_free(bs, nodep->idx->service_id, clst) == EOK) {
                         if (clst - lastc == count){
-                                return bitmap_set_clusters(bs, nodep->idx->service_id, 
+                                return exfat_bitmap_set_clusters(bs, nodep->idx->service_id, 
                                     lastc + 1, count);
                         } else
@@ -240 +240 @@
 
 
-int bitmap_free_clusters(exfat_bs_t *bs, exfat_node_t *nodep, 
+int exfat_bitmap_free_clusters(exfat_bs_t *bs, exfat_node_t *nodep, 
     exfat_cluster_t count)
 {
@@ -247 +247 @@
         lastc -= count;
 
-        return bitmap_clear_clusters(bs, nodep->idx->service_id, lastc + 1, count);
-}
-
-
-int bitmap_replicate_clusters(exfat_bs_t *bs, exfat_node_t *nodep)
+        return exfat_bitmap_clear_clusters(bs, nodep->idx->service_id, lastc + 1, count);
+}
+
+
+int exfat_bitmap_replicate_clusters(exfat_bs_t *bs, exfat_node_t *nodep)
 {
         int rc;

uspace/srv/fs/exfat/exfat_bitmap.h

@@ -42 +42 @@
 struct exfat_bs;
 
-extern int bitmap_alloc_clusters(struct exfat_bs *, service_id_t, 
+extern int exfat_bitmap_alloc_clusters(struct exfat_bs *, service_id_t, 
     exfat_cluster_t *, exfat_cluster_t);
-extern int bitmap_append_clusters(struct exfat_bs *, struct exfat_node *, 
+extern int exfat_bitmap_append_clusters(struct exfat_bs *, struct exfat_node *, 
     exfat_cluster_t);
-extern int bitmap_free_clusters(struct exfat_bs *, struct exfat_node *, 
+extern int exfat_bitmap_free_clusters(struct exfat_bs *, struct exfat_node *, 
     exfat_cluster_t);
-extern int bitmap_replicate_clusters(struct exfat_bs *, struct exfat_node *); 
+extern int exfat_bitmap_replicate_clusters(struct exfat_bs *, struct exfat_node *); 
 
-extern int bitmap_is_free(struct exfat_bs *, service_id_t, exfat_cluster_t);
-extern int bitmap_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
-extern int bitmap_clear_cluster(struct exfat_bs *, service_id_t, 
+extern int exfat_bitmap_is_free(struct exfat_bs *, service_id_t, exfat_cluster_t);
+extern int exfat_bitmap_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
+extern int exfat_bitmap_clear_cluster(struct exfat_bs *, service_id_t, 
     exfat_cluster_t);
 
-extern int bitmap_set_clusters(struct exfat_bs *, service_id_t, 
+extern int exfat_bitmap_set_clusters(struct exfat_bs *, service_id_t, 
     exfat_cluster_t, exfat_cluster_t);
-extern int bitmap_clear_clusters(struct exfat_bs *, service_id_t, 
+extern int exfat_bitmap_clear_clusters(struct exfat_bs *, service_id_t, 
     exfat_cluster_t, exfat_cluster_t);
 

uspace/srv/fs/exfat/exfat_dentry.c

@@ -130 +130 @@
 }
 
-size_t utf16_length(const uint16_t *wstr)
+size_t exfat_utf16_length(const uint16_t *wstr)
 {
         size_t len = 0;

uspace/srv/fs/exfat/exfat_dentry.h

@@ -160 +160 @@
 extern bool exfat_valid_name(const char *);
 
-extern size_t utf16_length(const uint16_t *);
+extern size_t exfat_utf16_length(const uint16_t *);
 
 

uspace/srv/fs/exfat/exfat_directory.c

@@ -371 +371 @@
         ds.stream.valid_data_size = 0;
         ds.stream.data_size = 0;
-        ds.stream.name_size = utf16_length(wname);
+        ds.stream.name_size = exfat_utf16_length(wname);
         ds.stream.hash = host2uint16_t_le(exfat_name_hash(wname, uctable, 
             uctable_chars));

uspace/srv/fs/exfat/exfat_fat.c

@@ -314 +314 @@
             clst++) {
                 /* Need to rewrite because of multiple exfat_bitmap_get calls */
-                if (bitmap_is_free(bs, service_id, clst) == EOK) {
+                if (exfat_bitmap_is_free(bs, service_id, clst) == EOK) {
                         /*
                          * The cluster is free. Put it into our stack
@@ -325 +325 @@
                                 goto exit_error;
                         found++;
-                        rc = bitmap_set_cluster(bs, service_id, clst);
+                        rc = exfat_bitmap_set_cluster(bs, service_id, clst);
                         if (rc != EOK)
                                 goto exit_error;
@@ -346 +346 @@
         /* If something wrong - free the clusters */
         while (found--) {
-                (void) bitmap_clear_cluster(bs, service_id, lifo[found]);
+                (void) exfat_bitmap_clear_cluster(bs, service_id, lifo[found]);
                 (void) exfat_set_cluster(bs, service_id, lifo[found], 0);
         }
@@ -378 +378 @@
                 if (rc != EOK)
                         return rc;
-                rc = bitmap_clear_cluster(bs, service_id, firstc);
+                rc = exfat_bitmap_clear_cluster(bs, service_id, firstc);
                 if (rc != EOK)
                         return rc;

uspace/srv/fs/exfat/exfat_ops.c

@@ -405 +405 @@
 
         if (!nodep->fragmented) {
-                rc = bitmap_append_clusters(bs, nodep, clusters);
+                rc = exfat_bitmap_append_clusters(bs, nodep, clusters);
                 if (rc != ENOSPC)
                         return rc;
@@ -411 +411 @@
                         nodep->fragmented = true;
                         nodep->dirty = true;            /* need to sync node */
-                        rc = bitmap_replicate_clusters(bs, nodep);
+                        rc = exfat_bitmap_replicate_clusters(bs, nodep);
                         if (rc != EOK)
                                 return rc;
@@ -457 +457 @@
 
                 clsts = prev_clsts - new_clsts;
-                rc = bitmap_free_clusters(bs, nodep, clsts);
+                rc = exfat_bitmap_free_clusters(bs, nodep, clsts);
                 if (rc != EOK)
                         return rc;
@@ -704 +704 @@
                                 nodep->firstc);
                 else
-                        rc = bitmap_free_clusters(bs, nodep, 
+                        rc = exfat_bitmap_free_clusters(bs, nodep, 
                             ROUND_UP(nodep->size, BPC(bs)) / BPC(bs));
         } 
@@ -758 +758 @@
 
         fibril_mutex_unlock(&parentp->idx->lock);
-        if (rc != EOK)
-                return rc;
-
         fibril_mutex_lock(&childp->idx->lock);
-
 
         childp->idx->pfc = parentp->firstc;
@@ -1463 +1459 @@
         }
 
-        (void) exfat_node_put(fn);
+        int rc2 = exfat_node_put(fn);
+        if (rc == EOK && rc2 != EOK)
+                rc = rc2;
+
         return rc;
 }