Index: abi/include/syscall.h =================================================================== --- abi/include/syscall.h (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ abi/include/syscall.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -92,4 +92,6 @@ SYS_IRQ_UNREGISTER, + SYS_SYSINFO_GET_KEYS_SIZE, + SYS_SYSINFO_GET_KEYS, SYS_SYSINFO_GET_VAL_TYPE, SYS_SYSINFO_GET_VALUE, Index: boot/Makefile.common =================================================================== --- boot/Makefile.common (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ boot/Makefile.common (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -165,4 +165,5 @@ $(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 \ Index: boot/arch/ia64/src/pal_asm.S =================================================================== --- boot/arch/ia64/src/pal_asm.S (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ boot/arch/ia64/src/pal_asm.S (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -32,11 +32,16 @@ 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,12 +49,16 @@ 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,6 +69,6 @@ (p9) st8 [in6] = r11 - mov gp = loc1 - mov rp = loc2 ;; + mov gp = loc2 + mov rp = loc3 ;; mov ar.pfs = loc0 Index: boot/arch/ia64/src/sal_asm.S =================================================================== --- boot/arch/ia64/src/sal_asm.S (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ boot/arch/ia64/src/sal_asm.S (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -29,4 +29,9 @@ .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,6 +44,8 @@ # 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,20 +64,31 @@ 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 + Index: kernel/arch/ia64/include/asm.h =================================================================== --- kernel/arch/ia64/include/asm.h (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/arch/ia64/include/asm.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -61,4 +61,5 @@ asm volatile ( "mf\n" + "mf.a\n" ::: "memory" ); @@ -74,4 +75,5 @@ asm volatile ( "mf\n" + "mf.a\n" ::: "memory" ); @@ -87,4 +89,5 @@ asm volatile ( "mf\n" + "mf.a\n" ::: "memory" ); @@ -104,4 +107,9 @@ else v = *port; + + asm volatile ( + "mf.a\n" + ::: "memory" + ); return v; @@ -121,4 +129,9 @@ else v = *port; + + asm volatile ( + "mf.a\n" + ::: "memory" + ); return v; @@ -138,4 +151,9 @@ else v = *port; + + asm volatile ( + "mf.a\n" + ::: "memory" + ); return v; Index: kernel/arch/ia64/src/ia64.c =================================================================== --- kernel/arch/ia64/src/ia64.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/arch/ia64/src/ia64.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -144,5 +144,5 @@ #endif #ifdef MACHINE_i460GX - platform = "i460GX"; + platform = "pc"; #endif sysinfo_set_item_data("platform", NULL, (void *) platform, Index: kernel/arch/ppc32/src/ppc32.c =================================================================== --- kernel/arch/ppc32/src/ppc32.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/arch/ppc32/src/ppc32.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -173,4 +173,6 @@ ofw_tree_walk_by_device_type("display", display_register, NULL); #endif + /* Map OFW information into sysinfo */ + ofw_sysinfo_map(); /* Initialize IRQ routing */ Index: kernel/arch/sparc64/src/sun4u/sparc64.c =================================================================== --- kernel/arch/sparc64/src/sun4u/sparc64.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/arch/sparc64/src/sun4u/sparc64.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -94,4 +94,7 @@ { if (config.cpu_active == 1) { + /* Map OFW information into sysinfo */ + ofw_sysinfo_map(); + /* * We have 2^11 different interrupt vectors. Index: kernel/arch/sparc64/src/sun4v/sparc64.c =================================================================== --- kernel/arch/sparc64/src/sun4v/sparc64.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/arch/sparc64/src/sun4v/sparc64.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -92,4 +92,7 @@ { if (config.cpu_active == 1) { + /* Map OFW information into sysinfo */ + ofw_sysinfo_map(); + /* * We have 2^11 different interrupt vectors. Index: kernel/genarch/include/ofw/ofw_tree.h =================================================================== --- kernel/genarch/include/ofw/ofw_tree.h (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/genarch/include/ofw/ofw_tree.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -67,5 +67,5 @@ 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 *); Index: kernel/genarch/src/ofw/ofw_tree.c =================================================================== --- kernel/genarch/src/ofw/ofw_tree.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/genarch/src/ofw/ofw_tree.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -38,4 +38,5 @@ #include #include +#include #include #include @@ -65,7 +66,5 @@ 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,10 +103,8 @@ 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,5 +118,5 @@ * 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,7 +138,5 @@ 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,13 +167,11 @@ 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,7 +194,5 @@ 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,9 +220,7 @@ 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,8 +248,7 @@ 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,7 +282,5 @@ 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,5 +320,58 @@ } -/** 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,20 +382,19 @@ * */ -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,8 +402,8 @@ } -/** 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); } Index: kernel/generic/include/sysinfo/sysinfo.h =================================================================== --- kernel/generic/include/sysinfo/sysinfo.h (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/generic/include/sysinfo/sysinfo.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -1,4 +1,5 @@ /* * Copyright (c) 2006 Jakub Vana + * Copyright (c) 2012 Martin Decky * All rights reserved. * @@ -54,9 +55,26 @@ 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,8 +90,8 @@ */ 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,5 +113,13 @@ /** 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,6 +127,6 @@ */ 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,16 +149,18 @@ 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 *); Index: kernel/generic/src/ddi/ddi.c =================================================================== --- kernel/generic/src/ddi/ddi.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/generic/src/ddi/ddi.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -166,7 +166,7 @@ } - 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. */ Index: kernel/generic/src/lib/func.c =================================================================== --- kernel/generic/src/lib/func.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/generic/src/lib/func.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -53,5 +53,5 @@ void halt() { -#ifdef CONFIG_DEBUG +#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE)) bool rundebugger = false; Index: kernel/generic/src/main/main.c =================================================================== --- kernel/generic/src/main/main.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/generic/src/main/main.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -221,5 +221,5 @@ frame_init(); slab_cache_init(); - ra_init(); + ra_init(); sysinfo_init(); btree_init(); @@ -257,5 +257,5 @@ 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"); Index: kernel/generic/src/mm/page.c =================================================================== --- kernel/generic/src/mm/page.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/generic/src/mm/page.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -168,9 +168,9 @@ 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,5 +179,5 @@ (virt - ALIGN_DOWN(virt, PAGE_SIZE)); - mutex_unlock(&AS->lock); + page_table_unlock(AS, true); return EOK; Index: kernel/generic/src/syscall/syscall.c =================================================================== --- kernel/generic/src/syscall/syscall.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/generic/src/syscall/syscall.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -184,4 +184,6 @@ /* 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, Index: kernel/generic/src/sysinfo/stats.c =================================================================== --- kernel/generic/src/sysinfo/stats.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/generic/src/sysinfo/stats.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -83,9 +83,10 @@ * * @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,4 +99,5 @@ * @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,5 +106,5 @@ */ 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,5 +251,5 @@ 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,4 +295,5 @@ * @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,5 +302,5 @@ */ 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,5 +353,5 @@ ASSERT(interrupts_disabled()); ASSERT(irq_spinlock_locked(&thread->lock)); - + stats_thread->thread_id = thread->tid; stats_thread->task_id = thread->task->taskid; @@ -398,4 +401,5 @@ * @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,5 +408,5 @@ */ 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,4 +455,5 @@ * @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,5 +465,6 @@ * */ -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,4 +526,5 @@ * @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,5 +536,6 @@ * */ -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,4 +594,5 @@ * @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,5 +601,5 @@ */ 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,4 +643,5 @@ * @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,5 +653,6 @@ * */ -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,4 +716,5 @@ * @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,5 +723,5 @@ */ 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,4 +747,5 @@ * @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,5 +754,5 @@ */ 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,14 +823,14 @@ 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); } Index: kernel/generic/src/sysinfo/sysinfo.c =================================================================== --- kernel/generic/src/sysinfo/sysinfo.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ kernel/generic/src/sysinfo/sysinfo.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -1,4 +1,5 @@ /* * Copyright (c) 2006 Jakub Vana + * Copyright (c) 2012 Martin Decky * All rights reserved. * @@ -99,5 +100,5 @@ sizeof(sysinfo_item_t), 0, sysinfo_item_constructor, sysinfo_item_destructor, SLAB_CACHE_MAGDEFERRED); - + mutex_initialize(&sysinfo_lock, MUTEX_ACTIVE); } @@ -110,5 +111,5 @@ * @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,5 +126,4 @@ { ASSERT(subtree != NULL); - ASSERT(ret != NULL); sysinfo_item_t *cur = subtree; @@ -151,9 +151,14 @@ 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,5 +169,7 @@ /* Not found, no data generated */ - *ret = NULL; + if (ret != NULL) + *ret = NULL; + return NULL; } @@ -352,8 +359,9 @@ * 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,5 +374,6 @@ 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,8 +392,9 @@ * 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,5 +407,6 @@ 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,8 +442,9 @@ * 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,5 +460,6 @@ 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,12 +469,11 @@ /** 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,15 +482,22 @@ * 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,24 +507,23 @@ 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,16 +536,14 @@ 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("\n"); break; default: - sysinfo_indent(depth + 1); - printf("+ [unknown subtree]\n"); + sysinfo_indent(spaces + length); + printf("\n"); } - - cur = cur->next; } } @@ -594,9 +610,9 @@ 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,6 +651,6 @@ 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,6 +661,201 @@ 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,6 +883,6 @@ /* - * 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,10 +912,10 @@ { 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,6 +952,6 @@ * 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); Index: uspace/Makefile =================================================================== --- uspace/Makefile (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/Makefile (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -48,4 +48,5 @@ app/lsusb \ app/mkfat \ + app/mkexfat \ app/mkmfs \ app/redir \ Index: uspace/app/mkexfat/Makefile =================================================================== --- uspace/app/mkexfat/Makefile (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) +++ uspace/app/mkexfat/Makefile (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -0,0 +1,37 @@ +# +# Copyright (c) 2012 Maurizio Lombardi +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBS = $(LIBBLOCK_PREFIX)/libblock.a +EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) +BINARY = mkexfat + +SOURCES = \ + mkexfat.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/mkexfat/exfat.h =================================================================== --- uspace/app/mkexfat/exfat.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) +++ uspace/app/mkexfat/exfat.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -0,0 +1,179 @@ +/* + * Copyright (c) 2008 Jakub Jermar + * Copyright (c) 2011 Oleg Romanenko + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup fs + * @{ + */ + +#include +#include +#include + +#define EXFAT_FILENAME_LEN 255 +#define EXFAT_NAME_PART_LEN 15 + +#define EXFAT_TYPE_UNUSED 0x00 +#define EXFAT_TYPE_USED 0x80 +#define EXFAT_TYPE_VOLLABEL 0x83 +#define EXFAT_TYPE_BITMAP 0x81 +#define EXFAT_TYPE_UCTABLE 0x82 +#define EXFAT_TYPE_GUID 0xA0 +#define EXFAT_TYPE_FILE 0x85 +#define EXFAT_TYPE_STREAM 0xC0 +#define EXFAT_TYPE_NAME 0xC1 + +#define EXFAT_ATTR_RDONLY 0x01 +#define EXFAT_ATTR_HIDDEN 0x02 +#define EXFAT_ATTR_SYSTEM 0x04 +#define EXFAT_ATTR_SUBDIR 0x10 +#define EXFAT_ATTR_ARCHIVE 0x20 + + +/* All dentry structs should have 31 byte size */ +typedef struct { + uint8_t size; + uint16_t label[11]; + uint8_t _reserved[8]; +} __attribute__ ((packed)) exfat_vollabel_dentry_t; + +typedef struct { + uint8_t flags; + uint8_t _reserved[18]; + uint32_t firstc; + uint64_t size; +} __attribute__ ((packed)) exfat_bitmap_dentry_t; + +typedef struct { + uint8_t _reserved1[3]; + uint32_t checksum; + uint8_t _reserved2[12]; + uint32_t firstc; + uint64_t size; +} __attribute__ ((packed)) exfat_uctable_dentry_t; + +typedef struct { + uint8_t count; /* Always zero */ + uint16_t checksum; + uint16_t flags; + uint8_t guid[16]; + uint8_t _reserved[10]; +} __attribute__ ((packed)) exfat_guid_dentry_t; + +typedef struct { + uint8_t count; + uint16_t checksum; + uint16_t attr; + uint8_t _reserved1[2]; + uint32_t ctime; + uint32_t mtime; + uint32_t atime; + uint8_t ctime_fine; + uint8_t mtime_fine; + uint8_t ctime_tz; + uint8_t mtime_tz; + uint8_t atime_tz; + uint8_t _reserved2[7]; +} __attribute__ ((packed)) exfat_file_dentry_t; + +typedef struct { + uint8_t flags; + uint8_t _reserved1[1]; + uint8_t name_size; + uint16_t hash; + uint8_t _reserved2[2]; + uint64_t valid_data_size; + uint8_t _reserved3[4]; + uint32_t firstc; + uint64_t data_size; +} __attribute__ ((packed)) exfat_stream_dentry_t; + +typedef struct { + uint8_t flags; + uint16_t name[EXFAT_NAME_PART_LEN]; +} __attribute__ ((packed)) exfat_name_dentry_t; + + +typedef struct { + uint8_t type; + union { + exfat_vollabel_dentry_t vollabel; + exfat_bitmap_dentry_t bitmap; + exfat_uctable_dentry_t uctable; + exfat_guid_dentry_t guid; + exfat_file_dentry_t file; + exfat_stream_dentry_t stream; + exfat_name_dentry_t name; + }; +} __attribute__ ((packed)) exfat_dentry_t; + + +typedef enum { + EXFAT_DENTRY_SKIP, + EXFAT_DENTRY_LAST, + EXFAT_DENTRY_FREE, + EXFAT_DENTRY_VOLLABEL, + EXFAT_DENTRY_BITMAP, + EXFAT_DENTRY_UCTABLE, + EXFAT_DENTRY_GUID, + EXFAT_DENTRY_FILE, + EXFAT_DENTRY_STREAM, + EXFAT_DENTRY_NAME +} exfat_dentry_clsf_t; + + +typedef struct exfat_bs { + uint8_t jump[3]; /* 0x00 jmp and nop instructions */ + uint8_t oem_name[8]; /* 0x03 "EXFAT " */ + uint8_t __reserved[53]; /* 0x0B always 0 */ + uint64_t volume_start; /* 0x40 partition first sector */ + uint64_t volume_count; /* 0x48 partition sectors count */ + uint32_t fat_sector_start; /* 0x50 FAT first sector */ + uint32_t fat_sector_count; /* 0x54 FAT sectors count */ + uint32_t data_start_sector; /* 0x58 Data region first cluster sector */ + uint32_t data_clusters; /* 0x5C total clusters count */ + uint32_t rootdir_cluster; /* 0x60 first cluster of the root dir */ + uint32_t volume_serial; /* 0x64 volume serial number */ + struct { /* 0x68 FS version */ + uint8_t minor; + uint8_t major; + } __attribute__ ((packed)) version; + uint16_t volume_flags; /* 0x6A volume state flags */ + uint8_t bytes_per_sector; /* 0x6C sector size as (1 << n) */ + uint8_t sec_per_cluster; /* 0x6D sectors per cluster as (1 << n) */ + uint8_t fat_count; /* 0x6E always 1 */ + uint8_t drive_no; /* 0x6F always 0x80 */ + uint8_t allocated_percent; /* 0x70 percentage of allocated space */ + uint8_t _reserved2[7]; /* 0x71 reserved */ + uint8_t bootcode[390]; /* Boot code */ + uint16_t signature; /* the value of 0xAA55 */ +} __attribute__((__packed__)) exfat_bs_t; + +/** + * @} + */ Index: uspace/app/mkexfat/mkexfat.c =================================================================== --- uspace/app/mkexfat/mkexfat.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) +++ uspace/app/mkexfat/mkexfat.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -0,0 +1,952 @@ +/* + * Copyright (c) 2012 Maurizio Lombardi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup fs + * @{ + */ + +/** + * @file mkexfat.c + * @brief Tool for creating new exFAT file systems. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "exfat.h" +#include "upcase.h" + +#define NAME "mkexfat" + +/** First sector of the FAT */ +#define FAT_SECTOR_START 128 + +/** First sector of the Main Extended Boot Region */ +#define EBS_SECTOR_START 1 + +/** First sector of the Main Extended Boot Region Backup */ +#define EBS_BACKUP_SECTOR_START 13 + +/** First sector of the Main Boot Sector */ +#define MBS_SECTOR 0 + +/** First sector of the Main Boot Sector Backup */ +#define MBS_BACKUP_SECTOR 12 + +/** VBR Checksum sector */ +#define VBR_CHECKSUM_SECTOR 11 + +/** VBR Backup Checksum sector */ +#define VBR_BACKUP_CHECKSUM_SECTOR 23 + +/** Size of the Main Extended Boot Region */ +#define EBS_SIZE 8 + +/** Divide and round up. */ +#define div_round_up(a, b) (((a) + (b) - 1) / (b)) + +/** The default size of each cluster is 4096 byte */ +#define DEFAULT_CLUSTER_SIZE 4096 + +/** Index of the first free cluster on the device */ +#define FIRST_FREE_CLUSTER 2 + +#define min(x, y) ((x) < (y) ? (x) : (y)) + +typedef struct exfat_cfg { + aoff64_t volume_start; + aoff64_t volume_count; + unsigned long fat_sector_count; + unsigned long data_start_sector; + unsigned long rootdir_cluster; + unsigned long upcase_table_cluster; + unsigned long bitmap_cluster; + unsigned long total_clusters; + unsigned long allocated_clusters; + size_t bitmap_size; + size_t sector_size; + size_t cluster_size; +} exfat_cfg_t; + + +static unsigned log2(unsigned n); + +static uint32_t +vbr_checksum_start(void const *octets, size_t nbytes); + +static void +vbr_checksum_update(void const *octets, size_t nbytes, uint32_t *checksum); + +static int +ebs_write(service_id_t service_id, exfat_cfg_t *cfg, + int base, uint32_t *chksum); + +static int +bitmap_write(service_id_t service_id, exfat_cfg_t *cfg); + +static uint32_t +upcase_table_checksum(void const *data, size_t nbytes); + +static struct option const long_options[] = { + {"help", no_argument, 0, 'h'}, + {"cluster-size", required_argument, 0, 'c'}, + {"fs-size", required_argument, 0, 's'}, +}; + +static void usage(void) +{ + printf("Usage: mkexfat [options] \n" + "-c, --cluster-size ## Specify the cluster size (Kb)\n" + "-s, --fs-size ## Specify the filesystem size (sectors)\n"); +} + +/** Initialize the exFAT params structure. + * + * @param cfg Pointer to the exFAT params structure to initialize. + */ +static void +cfg_params_initialize(exfat_cfg_t *cfg) +{ + unsigned long fat_bytes; + unsigned long fat_cls; + aoff64_t const volume_bytes = (cfg->volume_count - FAT_SECTOR_START) * + cfg->sector_size; + + if (cfg->cluster_size != 0) { + /* The user already choose the cluster size he wants */ + cfg->total_clusters = volume_bytes / cfg->cluster_size; + goto skip_cluster_size_set; + } + + cfg->total_clusters = volume_bytes / DEFAULT_CLUSTER_SIZE; + cfg->cluster_size = DEFAULT_CLUSTER_SIZE; + + /* Compute the required cluster size to index + * the entire storage device and to keep the FAT + * size less or equal to 64 Mb. + */ + while (cfg->total_clusters > 16000000ULL && + (cfg->cluster_size < 32 * 1024 * 1024)) { + + cfg->cluster_size <<= 1; + cfg->total_clusters = volume_bytes / cfg->cluster_size; + } + +skip_cluster_size_set: + + /* Compute the FAT size in sectors */ + fat_bytes = (cfg->total_clusters + 3) * sizeof(uint32_t); + cfg->fat_sector_count = div_round_up(fat_bytes, cfg->sector_size); + + /* Compute the number of the first data sector */ + cfg->data_start_sector = ROUND_UP(FAT_SECTOR_START + + cfg->fat_sector_count, cfg->cluster_size / cfg->sector_size); + + /* Subtract the FAT space from the total + * number of available clusters. + */ + fat_cls = div_round_up((cfg->data_start_sector - + FAT_SECTOR_START) * cfg->sector_size, + cfg->cluster_size); + if (fat_cls >= cfg->total_clusters) { + /* Insufficient disk space on device */ + cfg->total_clusters = 0; + return; + } + cfg->total_clusters -= fat_cls; + + /* Compute the bitmap size */ + cfg->bitmap_size = div_round_up(cfg->total_clusters, 8); + + /* Compute the number of clusters reserved to the bitmap */ + cfg->allocated_clusters = div_round_up(cfg->bitmap_size, + cfg->cluster_size); + + /* This account for the root directory */ + cfg->allocated_clusters++; + + /* Compute the number of clusters reserved to the upcase table */ + cfg->allocated_clusters += div_round_up(sizeof(upcase_table), + cfg->cluster_size); + + /* Will be set later */ + cfg->rootdir_cluster = 0; + + /* Bitmap always starts at the first free cluster */ + cfg->bitmap_cluster = FIRST_FREE_CLUSTER; + + /* The first sector of the partition is zero */ + cfg->volume_start = 0; +} + +/** Prints the exFAT structure values + * + * @param cfg Pointer to the exfat_cfg_t structure. + */ +static void +cfg_print_info(exfat_cfg_t *cfg) +{ + printf("Sector size: %lu\n", + (unsigned long) cfg->sector_size); + printf("Cluster size: %lu\n", + (unsigned long) cfg->cluster_size); + printf("FAT size in sectors: %lu\n", cfg->fat_sector_count); + printf("Data start sector: %lu\n", cfg->data_start_sector); + printf("Total num of clusters: %lu\n", cfg->total_clusters); + printf("Total used clusters: %lu\n", cfg->allocated_clusters); + printf("Bitmap size: %lu\n", (unsigned long) + div_round_up(cfg->bitmap_size, cfg->cluster_size)); + printf("Upcase table size: %lu\n", (unsigned long) + div_round_up(sizeof(upcase_table), cfg->cluster_size)); +} + +/** Initialize the Main Boot Sector fields. + * + * @param mbs Pointer to the Main Boot Sector structure. + * @param cfg Pointer to the exFAT configuration structure. + * @return Initial checksum value. + */ +static uint32_t +vbr_initialize(exfat_bs_t *mbs, exfat_cfg_t *cfg) +{ + /* Fill the structure with zeroes */ + memset(mbs, 0, sizeof(exfat_bs_t)); + + /* Init Jump Boot section */ + mbs->jump[0] = 0xEB; + mbs->jump[1] = 0x76; + mbs->jump[2] = 0x90; + + /* Set the filesystem name */ + memcpy(mbs->oem_name, "EXFAT ", sizeof(mbs->oem_name)); + + mbs->volume_start = host2uint64_t_le(cfg->volume_start); + mbs->volume_count = host2uint64_t_le(cfg->volume_count); + mbs->fat_sector_start = host2uint32_t_le(FAT_SECTOR_START); + mbs->fat_sector_count = host2uint32_t_le(cfg->fat_sector_count); + mbs->data_start_sector = host2uint32_t_le(cfg->data_start_sector); + + mbs->data_clusters = host2uint32_t_le(cfg->total_clusters); + + mbs->rootdir_cluster = host2uint32_t_le(cfg->rootdir_cluster); + mbs->volume_serial = host2uint32_t_le(0xe1028172); + mbs->version.major = 1; + mbs->version.minor = 0; + mbs->volume_flags = host2uint16_t_le(0); + mbs->bytes_per_sector = log2(cfg->sector_size); + mbs->sec_per_cluster = log2(cfg->cluster_size / cfg->sector_size); + + /* Maximum cluster size is 32 Mb */ + assert((mbs->bytes_per_sector + mbs->sec_per_cluster) <= 25); + + mbs->fat_count = 1; + mbs->drive_no = 0x80; + mbs->allocated_percent = 0; + mbs->signature = host2uint16_t_le(0xAA55); + + return vbr_checksum_start(mbs, sizeof(exfat_bs_t)); +} + +static int +bootsec_write(service_id_t service_id, exfat_cfg_t *cfg) +{ + exfat_bs_t mbs; + uint32_t vbr_checksum; + uint32_t *chksum_sector; + int rc; + unsigned idx; + + chksum_sector = calloc(cfg->sector_size, sizeof(uint8_t)); + if (!chksum_sector) + return ENOMEM; + + vbr_checksum = vbr_initialize(&mbs, cfg); + + /* Write the Main Boot Sector to disk */ + rc = block_write_direct(service_id, MBS_SECTOR, 1, &mbs); + if (rc != EOK) + goto exit; + + /* Write the Main extended boot sectors to disk */ + rc = ebs_write(service_id, cfg, EBS_SECTOR_START, &vbr_checksum); + if (rc != EOK) + goto exit; + + /* Write the Main Boot Sector backup to disk */ + rc = block_write_direct(service_id, MBS_BACKUP_SECTOR, 1, &mbs); + if (rc != EOK) + goto exit; + + /* Initialize the checksum sectors */ + for (idx = 0; idx < cfg->sector_size / sizeof(uint32_t); ++idx) + chksum_sector[idx] = host2uint32_t_le(vbr_checksum); + + /* Write the main checksum sector to disk */ + rc = block_write_direct(service_id, + VBR_CHECKSUM_SECTOR, 1, chksum_sector); + if (rc != EOK) + goto exit; + + /* Write the backup checksum sector to disk */ + rc = block_write_direct(service_id, + VBR_BACKUP_CHECKSUM_SECTOR, 1, chksum_sector); + if (rc != EOK) + goto exit; + + /* Write the Main extended boot sectors backup to disk */ + rc = ebs_write(service_id, cfg, + EBS_BACKUP_SECTOR_START, &vbr_checksum); + +exit: + free(chksum_sector); + return rc; +} + +/** Write the Main Extended Boot Sector to disk + * + * @param service_id The service id. + * @param cfg Pointer to the exFAT configuration structure. + * @param base Base sector of the EBS. + * @return EOK on success or a negative error code. + */ +static int +ebs_write(service_id_t service_id, exfat_cfg_t *cfg, int base, + uint32_t *chksum) +{ + uint32_t *ebs = calloc(cfg->sector_size, sizeof(uint8_t)); + int i, rc; + + if (!ebs) + return ENOMEM; + + ebs[cfg->sector_size / 4 - 1] = host2uint32_t_le(0xAA550000); + + for (i = 0; i < EBS_SIZE; ++i) { + vbr_checksum_update(ebs, cfg->sector_size, chksum); + + rc = block_write_direct(service_id, + i + base, 1, ebs); + + if (rc != EOK) + goto exit; + } + + /* The OEM record is not yet used + * by the official exFAT implementation, we'll fill + * it with zeroes. + */ + + memset(ebs, 0, cfg->sector_size); + vbr_checksum_update(ebs, cfg->sector_size, chksum); + + rc = block_write_direct(service_id, i++ + base, 1, ebs); + if (rc != EOK) + goto exit; + + /* The next sector is reserved, fill it with zeroes too */ + vbr_checksum_update(ebs, cfg->sector_size, chksum); + + rc = block_write_direct(service_id, i + base, 1, ebs); + if (rc != EOK) + goto exit; + +exit: + free(ebs); + return rc; +} + +/** Initialize the FAT table. + * + * @param service_id The service id. + * @param cfg Pointer to the exfat_cfg structure. + * @return EOK on success or a negative error code. + */ +static int +fat_initialize(service_id_t service_id, exfat_cfg_t *cfg) +{ + unsigned long i; + uint32_t *pfat; + int rc; + + pfat = calloc(cfg->sector_size, 1); + if (!pfat) + return ENOMEM; + + pfat[0] = host2uint32_t_le(0xFFFFFFF8); + pfat[1] = host2uint32_t_le(0xFFFFFFFF); + + rc = block_write_direct(service_id, FAT_SECTOR_START, 1, pfat); + if (rc != EOK) + goto error; + + pfat[0] = pfat[1] = 0; + + for (i = 1; i < cfg->fat_sector_count; ++i) { + rc = block_write_direct(service_id, + FAT_SECTOR_START + i, 1, pfat); + if (rc != EOK) + goto error; + } + +error: + free(pfat); + return rc; +} + +/** Allocate a given number of clusters and create a cluster chain. + * + * @param service_id The service id. + * @param cfg Pointer to the exfat configuration structure. + * @param cur_cls Cluster index from where to start the allocation. + * @param ncls Number of clusters to allocate. + * @return EOK on success or a negative error code. + */ +static int +fat_allocate_clusters(service_id_t service_id, exfat_cfg_t *cfg, + uint32_t cur_cls, unsigned long ncls) +{ + int rc; + unsigned const fat_entries = cfg->sector_size / sizeof(uint32_t); + aoff64_t fat_sec = cur_cls / fat_entries + FAT_SECTOR_START; + uint32_t *fat; + uint32_t next_cls = cur_cls; + + cur_cls %= fat_entries; + + fat = malloc(cfg->sector_size); + if (!fat) + return ENOMEM; + +loop: + rc = block_read_direct(service_id, fat_sec, 1, fat); + if (rc != EOK) + goto exit; + + assert(fat[cur_cls] == 0); + assert(ncls > 0); + + for (; cur_cls < fat_entries && ncls > 1; ++cur_cls, --ncls) + fat[cur_cls] = host2uint32_t_le(++next_cls); + + if (cur_cls == fat_entries) { + /* This sector is full, there are no more free entries, + * commit the changes to disk and restart from the next + * sector. + */ + rc = block_write_direct(service_id, fat_sec++, 1, fat); + if (rc != EOK) + goto exit; + cur_cls = 0; + goto loop; + } else if (ncls == 1) { + /* This is the last cluster of this chain, mark it + * with EOF. + */ + fat[cur_cls] = host2uint32_t_le(0xFFFFFFFF); + } + + rc = block_write_direct(service_id, fat_sec, 1, fat); + +exit: + free(fat); + return rc; +} + +/** Initialize the allocation bitmap. + * + * @param service_id The service id. + * @param cfg Pointer to the exfat configuration structure. + * @return EOK on success or a negative error code. + */ +static int +bitmap_write(service_id_t service_id, exfat_cfg_t *cfg) +{ + unsigned long i, sec; + unsigned long allocated_cls; + int rc = EOK; + bool need_reset = true; + + /* Bitmap size in sectors */ + size_t const bss = div_round_up(cfg->bitmap_size, cfg->sector_size); + + uint8_t *bitmap = malloc(cfg->sector_size); + if (!bitmap) + return ENOMEM; + + allocated_cls = cfg->allocated_clusters; + + for (sec = 0; sec < bss; ++sec) { + if (need_reset) { + need_reset = false; + memset(bitmap, 0, cfg->sector_size); + } + if (allocated_cls > 0) { + for (i = 0; i < allocated_cls; ++i) { + unsigned byte_idx = i / 8; + unsigned bit_idx = i % 8; + + if (byte_idx == cfg->sector_size) + break; + bitmap[byte_idx] |= 1 << bit_idx; + } + + allocated_cls -= i; + need_reset = true; + } + + rc = block_write_direct(service_id, + cfg->data_start_sector + sec, 1, bitmap); + if (rc != EOK) + goto exit; + } + +exit: + free(bitmap); + return rc; +} + +/** Write the upcase table to disk. */ +static int +upcase_table_write(service_id_t service_id, exfat_cfg_t *cfg) +{ + int rc = EOK; + aoff64_t start_sec, nsecs, i; + uint8_t *table_ptr; + uint8_t *buf; + size_t table_size = sizeof(upcase_table); + + buf = malloc(cfg->sector_size); + if (!buf) + return ENOENT; + + /* Compute the start sector of the upcase table */ + start_sec = cfg->data_start_sector; + start_sec += ((cfg->upcase_table_cluster - 2) * cfg->cluster_size) / + cfg->sector_size; + + /* Compute the number of sectors needed to store the table on disk */ + nsecs = div_round_up(sizeof(upcase_table), cfg->sector_size); + table_ptr = (uint8_t *) upcase_table; + + for (i = 0; i < nsecs; ++i, + table_ptr += min(table_size, cfg->sector_size), + table_size -= cfg->sector_size) { + + if (table_size < cfg->sector_size) { + /* Reset the content of the unused part + * of the last sector. + */ + memset(buf, 0, cfg->sector_size); + } + memcpy(buf, table_ptr, min(table_size, cfg->sector_size)); + + rc = block_write_direct(service_id, + start_sec + i, 1, buf); + if (rc != EOK) + goto exit; + } + +exit: + free(buf); + return rc; +} + +/** Initialize and write the root directory entries to disk. + * + * @param service_id The service id. + * @param cfg Pointer to the exFAT configuration structure. + * @return EOK on success or a negative error code. + */ +static int +root_dentries_write(service_id_t service_id, exfat_cfg_t *cfg) +{ + exfat_dentry_t *d; + aoff64_t rootdir_sec; + int rc; + uint8_t *data; + unsigned long i; + + data = calloc(cfg->sector_size, 1); + if (!data) + return ENOMEM; + + d = (exfat_dentry_t *) data; + + /* Initialize the volume label dentry */ + d->type = EXFAT_TYPE_VOLLABEL; + str_to_utf16(d->vollabel.label, 8, "HELENOS "); + d->vollabel.size = 8; + + d++; + + /* Initialize the allocation bitmap dentry */ + d->type = EXFAT_TYPE_BITMAP; + d->bitmap.flags = 0; /* First FAT */ + d->bitmap.firstc = host2uint32_t_le(cfg->bitmap_cluster); + d->bitmap.size = host2uint64_t_le(cfg->bitmap_size); + + d++; + + /* Initialize the upcase table dentry */ + d->type = EXFAT_TYPE_UCTABLE; + d->uctable.checksum = host2uint32_t_le(upcase_table_checksum( + upcase_table, sizeof(upcase_table))); + d->uctable.firstc = host2uint32_t_le(cfg->upcase_table_cluster); + d->uctable.size = host2uint64_t_le(sizeof(upcase_table)); + + /* Compute the number of the sector where the rootdir resides */ + + rootdir_sec = cfg->data_start_sector; + rootdir_sec += ((cfg->rootdir_cluster - 2) * cfg->cluster_size) / + cfg->sector_size; + + rc = block_write_direct(service_id, rootdir_sec, 1, data); + if (rc != EOK) + goto exit; + + /* Fill the content of the sectors not used by the + * root directory with zeroes. + */ + memset(data, 0, cfg->sector_size); + for (i = 1; i < cfg->cluster_size / cfg->sector_size; ++i) { + rc = block_write_direct(service_id, rootdir_sec + i, 1, data); + if (rc != EOK) + goto exit; + } + +exit: + free(data); + return rc; +} + +/** Given a number (n), returns the result of log2(n). + * + * It works only if n is a power of two. + */ +static unsigned +log2(unsigned n) +{ + unsigned r; + + for (r = 0;n >> r != 1; ++r); + + return r; +} + +/** Initialize the VBR checksum calculation */ +static uint32_t +vbr_checksum_start(void const *data, size_t nbytes) +{ + uint32_t checksum = 0; + size_t index; + uint8_t const *octets = (uint8_t *) data; + + for (index = 0; index < nbytes; ++index) { + if (index == 106 || index == 107 || index == 112) { + /* Skip volume_flags and allocated_percent fields */ + continue; + } + + checksum = ((checksum << 31) | (checksum >> 1)) + + octets[index]; + } + + return checksum; +} + +/** Update the VBR checksum */ +static void +vbr_checksum_update(void const *data, size_t nbytes, uint32_t *checksum) +{ + size_t index; + uint8_t const *octets = (uint8_t *) data; + + for (index = 0; index < nbytes; ++index) { + *checksum = ((*checksum << 31) | (*checksum >> 1)) + + octets[index]; + } +} + +/** Compute the checksum of the upcase table. + * + * @param data Pointer to the upcase table. + * @param nbytes size of the upcase table in bytes. + * @return Checksum value. + */ +static uint32_t +upcase_table_checksum(void const *data, size_t nbytes) +{ + size_t index; + uint32_t chksum = 0; + uint8_t const *octets = (uint8_t *) data; + + for (index = 0; index < nbytes; ++index) + chksum = ((chksum << 31) | (chksum >> 1)) + octets[index]; + + return chksum; +} + +/** Check if a given number is a power of two. + * + * @param n The number to check. + * @return true if n is a power of two, false otherwise. + */ +static bool +is_power_of_two(unsigned long n) +{ + if (n == 0) + return false; + + return (n & (n - 1)) == 0; +} + +int main (int argc, char **argv) +{ + exfat_cfg_t cfg; + uint32_t next_cls; + char *dev_path; + service_id_t service_id; + int rc, c, opt_ind; + aoff64_t user_fs_size = 0; + + if (argc < 2) { + printf(NAME ": Error, argument missing\n"); + usage(); + return 1; + } + + cfg.cluster_size = 0; + + for (c = 0, optind = 0, opt_ind = 0; c != -1;) { + c = getopt_long(argc, argv, "hs:c:", + long_options, &opt_ind); + switch (c) { + case 'h': + usage(); + return 0; + case 's': + user_fs_size = (aoff64_t) strtol(optarg, NULL, 10); + break; + + case 'c': + cfg.cluster_size = strtol(optarg, NULL, 10) * 1024; + if (cfg.cluster_size < 4096) { + printf(NAME ": Error, cluster size can't" + " be less than 4096 byte.\n"); + return 1; + } else if (cfg.cluster_size > 32 * 1024 * 1024) { + printf(NAME ": Error, cluster size can't" + " be greater than 32 Mb"); + return 1; + } + + if (!is_power_of_two(cfg.cluster_size)) { + printf(NAME ": Error, the size of the cluster" + " must be a power of two.\n"); + return 1; + } + break; + } + } + + argv += optind; + dev_path = *argv; + + if (!dev_path) { + printf(NAME ": Error, you must specify a valid block" + " device.\n"); + usage(); + return 1; + } + + printf("Device = %s\n", dev_path); + + rc = loc_service_get_id(dev_path, &service_id, 0); + if (rc != EOK) { + printf(NAME ": Error resolving device `%s'.\n", dev_path); + return 2; + } + + rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048); + if (rc != EOK) { + printf(NAME ": Error initializing libblock.\n"); + return 2; + } + + rc = block_get_bsize(service_id, &cfg.sector_size); + if (rc != EOK) { + printf(NAME ": Error determining device sector size.\n"); + return 2; + } + + user_fs_size *= cfg.sector_size; + if (user_fs_size > 0 && user_fs_size < 1024 * 1024) { + printf(NAME ": Error, fs size can't be less" + " than 1 Mb.\n"); + return 1; + } + + + if (cfg.sector_size > 4096) { + printf(NAME ": Error, sector size can't be greater" \ + " than 4096 bytes.\n"); + return 2; + } + + rc = block_get_nblocks(service_id, &cfg.volume_count); + if (rc != EOK) { + printf(NAME ": Warning, failed to obtain" \ + " block device size.\n"); + + if (user_fs_size == 0) { + printf(NAME ": You must specify the" \ + " filesystem size.\n"); + return 1; + } + } else { + printf("Block device has %" PRIuOFF64 " blocks.\n", + cfg.volume_count); + } + + if (user_fs_size != 0) { + if (user_fs_size > cfg.volume_count * cfg.sector_size) { + printf(NAME ": Error, the device is not big enough" + " to create a filesystem of" + " the specified size.\n"); + return 1; + } + + cfg.volume_count = user_fs_size / cfg.sector_size; + } + + cfg_params_initialize(&cfg); + cfg_print_info(&cfg); + + if (cfg.total_clusters <= cfg.allocated_clusters + 2) { + printf(NAME ": Error, insufficient disk space on device.\n"); + return 2; + } + + printf("Writing the allocation table.\n"); + + /* Initialize the FAT table */ + rc = fat_initialize(service_id, &cfg); + if (rc != EOK) { + printf(NAME ": Error, failed to write the FAT to disk\n"); + return 2; + } + + /* Allocate clusters for the bitmap */ + rc = fat_allocate_clusters(service_id, &cfg, cfg.bitmap_cluster, + div_round_up(cfg.bitmap_size, cfg.cluster_size)); + if (rc != EOK) { + printf(NAME ": Error, failed to allocate" \ + " clusters for bitmap.\n"); + return 2; + } + + next_cls = cfg.bitmap_cluster + + div_round_up(cfg.bitmap_size, cfg.cluster_size); + cfg.upcase_table_cluster = next_cls; + + /* Allocate clusters for the upcase table */ + rc = fat_allocate_clusters(service_id, &cfg, next_cls, + div_round_up(sizeof(upcase_table), cfg.cluster_size)); + if (rc != EOK) { + printf(NAME ":Error, failed to allocate clusters" \ + " for the upcase table.\n"); + return 2; + } + + next_cls += div_round_up(sizeof(upcase_table), cfg.cluster_size); + cfg.rootdir_cluster = next_cls; + + /* Allocate a cluster for the root directory entry */ + rc = fat_allocate_clusters(service_id, &cfg, next_cls, 1); + if (rc != EOK) { + printf(NAME ": Error, failed to allocate cluster" \ + " for the root dentry.\n"); + return 2; + } + + printf("Writing the allocation bitmap.\n"); + + /* Write the allocation bitmap to disk */ + rc = bitmap_write(service_id, &cfg); + if (rc != EOK) { + printf(NAME ": Error, failed to write the allocation" \ + " bitmap to disk.\n"); + return 2; + } + + printf("Writing the upcase table.\n"); + + /* Write the upcase table to disk */ + rc = upcase_table_write(service_id, &cfg); + if (rc != EOK) { + printf(NAME ": Error, failed to write the" \ + " upcase table to disk.\n"); + return 2; + } + + printf("Writing the root directory.\n"); + + rc = root_dentries_write(service_id, &cfg); + if (rc != EOK) { + printf(NAME ": Error, failed to write the root directory" \ + " entries to disk.\n"); + return 2; + } + + printf("Writing the boot sectors.\n"); + + rc = bootsec_write(service_id, &cfg); + if (rc != EOK) { + printf(NAME ": Error, failed to write the VBR to disk\n"); + return 2; + } + + printf("Success.\n"); + + return 0; +} + +/** + * @} + */ + Index: uspace/app/mkexfat/upcase.h =================================================================== --- uspace/app/mkexfat/upcase.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) +++ uspace/app/mkexfat/upcase.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -0,0 +1,2964 @@ +/* + * Copyright (c) 2012 Maurizio Lombardi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup fs + * @{ + */ + +#ifndef _UPCASE_H_ +#define _UPCASE_H_ + +/** Up-case unicode table */ +static uint8_t const upcase_table[] = { + 0x00, 0x00, + 0x01, 0x00, + 0x02, 0x00, + 0x03, 0x00, + 0x04, 0x00, + 0x05, 0x00, + 0x06, 0x00, + 0x07, 0x00, + 0x08, 0x00, + 0x09, 0x00, + 0x0a, 0x00, + 0x0b, 0x00, + 0x0c, 0x00, + 0x0d, 0x00, + 0x0e, 0x00, + 0x0f, 0x00, + 0x10, 0x00, + 0x11, 0x00, + 0x12, 0x00, + 0x13, 0x00, + 0x14, 0x00, + 0x15, 0x00, + 0x16, 0x00, + 0x17, 0x00, + 0x18, 0x00, + 0x19, 0x00, + 0x1a, 0x00, + 0x1b, 0x00, + 0x1c, 0x00, + 0x1d, 0x00, + 0x1e, 0x00, + 0x1f, 0x00, + 0x20, 0x00, + 0x21, 0x00, + 0x22, 0x00, + 0x23, 0x00, + 0x24, 0x00, + 0x25, 0x00, + 0x26, 0x00, + 0x27, 0x00, + 0x28, 0x00, + 0x29, 0x00, + 0x2a, 0x00, + 0x2b, 0x00, + 0x2c, 0x00, + 0x2d, 0x00, + 0x2e, 0x00, + 0x2f, 0x00, + 0x30, 0x00, + 0x31, 0x00, + 0x32, 0x00, + 0x33, 0x00, + 0x34, 0x00, + 0x35, 0x00, + 0x36, 0x00, + 0x37, 0x00, + 0x38, 0x00, + 0x39, 0x00, + 0x3a, 0x00, + 0x3b, 0x00, + 0x3c, 0x00, + 0x3d, 0x00, + 0x3e, 0x00, + 0x3f, 0x00, + 0x40, 0x00, + 0x41, 0x00, + 0x42, 0x00, + 0x43, 0x00, + 0x44, 0x00, + 0x45, 0x00, + 0x46, 0x00, + 0x47, 0x00, + 0x48, 0x00, + 0x49, 0x00, + 0x4a, 0x00, + 0x4b, 0x00, + 0x4c, 0x00, + 0x4d, 0x00, + 0x4e, 0x00, + 0x4f, 0x00, + 0x50, 0x00, + 0x51, 0x00, + 0x52, 0x00, + 0x53, 0x00, + 0x54, 0x00, + 0x55, 0x00, + 0x56, 0x00, + 0x57, 0x00, + 0x58, 0x00, + 0x59, 0x00, + 0x5a, 0x00, + 0x5b, 0x00, + 0x5c, 0x00, + 0x5d, 0x00, + 0x5e, 0x00, + 0x5f, 0x00, + 0x60, 0x00, + 0x41, 0x00, + 0x42, 0x00, + 0x43, 0x00, + 0x44, 0x00, + 0x45, 0x00, + 0x46, 0x00, + 0x47, 0x00, + 0x48, 0x00, + 0x49, 0x00, + 0x4a, 0x00, + 0x4b, 0x00, + 0x4c, 0x00, + 0x4d, 0x00, + 0x4e, 0x00, + 0x4f, 0x00, + 0x50, 0x00, + 0x51, 0x00, + 0x52, 0x00, + 0x53, 0x00, + 0x54, 0x00, + 0x55, 0x00, + 0x56, 0x00, + 0x57, 0x00, + 0x58, 0x00, + 0x59, 0x00, + 0x5a, 0x00, + 0x7b, 0x00, + 0x7c, 0x00, + 0x7d, 0x00, + 0x7e, 0x00, + 0x7f, 0x00, + 0x80, 0x00, + 0x81, 0x00, + 0x82, 0x00, + 0x83, 0x00, + 0x84, 0x00, + 0x85, 0x00, + 0x86, 0x00, + 0x87, 0x00, + 0x88, 0x00, + 0x89, 0x00, + 0x8a, 0x00, + 0x8b, 0x00, + 0x8c, 0x00, + 0x8d, 0x00, + 0x8e, 0x00, + 0x8f, 0x00, + 0x90, 0x00, + 0x91, 0x00, + 0x92, 0x00, + 0x93, 0x00, + 0x94, 0x00, + 0x95, 0x00, + 0x96, 0x00, + 0x97, 0x00, + 0x98, 0x00, + 0x99, 0x00, + 0x9a, 0x00, + 0x9b, 0x00, + 0x9c, 0x00, + 0x9d, 0x00, + 0x9e, 0x00, + 0x9f, 0x00, + 0xa0, 0x00, + 0xa1, 0x00, + 0xa2, 0x00, + 0xa3, 0x00, + 0xa4, 0x00, + 0xa5, 0x00, + 0xa6, 0x00, + 0xa7, 0x00, + 0xa8, 0x00, + 0xa9, 0x00, + 0xaa, 0x00, + 0xab, 0x00, + 0xac, 0x00, + 0xad, 0x00, + 0xae, 0x00, + 0xaf, 0x00, + 0xb0, 0x00, + 0xb1, 0x00, + 0xb2, 0x00, + 0xb3, 0x00, + 0xb4, 0x00, + 0xb5, 0x00, + 0xb6, 0x00, + 0xb7, 0x00, + 0xb8, 0x00, + 0xb9, 0x00, + 0xba, 0x00, + 0xbb, 0x00, + 0xbc, 0x00, + 0xbd, 0x00, + 0xbe, 0x00, + 0xbf, 0x00, + 0xc0, 0x00, + 0xc1, 0x00, + 0xc2, 0x00, + 0xc3, 0x00, + 0xc4, 0x00, + 0xc5, 0x00, + 0xc6, 0x00, + 0xc7, 0x00, + 0xc8, 0x00, + 0xc9, 0x00, + 0xca, 0x00, + 0xcb, 0x00, + 0xcc, 0x00, + 0xcd, 0x00, + 0xce, 0x00, + 0xcf, 0x00, + 0xd0, 0x00, + 0xd1, 0x00, + 0xd2, 0x00, + 0xd3, 0x00, + 0xd4, 0x00, + 0xd5, 0x00, + 0xd6, 0x00, + 0xd7, 0x00, + 0xd8, 0x00, + 0xd9, 0x00, + 0xda, 0x00, + 0xdb, 0x00, + 0xdc, 0x00, + 0xdd, 0x00, + 0xde, 0x00, + 0xdf, 0x00, + 0xc0, 0x00, + 0xc1, 0x00, + 0xc2, 0x00, + 0xc3, 0x00, + 0xc4, 0x00, + 0xc5, 0x00, + 0xc6, 0x00, + 0xc7, 0x00, + 0xc8, 0x00, + 0xc9, 0x00, + 0xca, 0x00, + 0xcb, 0x00, + 0xcc, 0x00, + 0xcd, 0x00, + 0xce, 0x00, + 0xcf, 0x00, + 0xd0, 0x00, + 0xd1, 0x00, + 0xd2, 0x00, + 0xd3, 0x00, + 0xd4, 0x00, + 0xd5, 0x00, + 0xd6, 0x00, + 0xf7, 0x00, + 0xd8, 0x00, + 0xd9, 0x00, + 0xda, 0x00, + 0xdb, 0x00, + 0xdc, 0x00, + 0xdd, 0x00, + 0xde, 0x00, + 0x78, 0x01, + 0x00, 0x01, + 0x00, 0x01, + 0x02, 0x01, + 0x02, 0x01, + 0x04, 0x01, + 0x04, 0x01, + 0x06, 0x01, + 0x06, 0x01, + 0x08, 0x01, + 0x08, 0x01, + 0x0a, 0x01, + 0x0a, 0x01, + 0x0c, 0x01, + 0x0c, 0x01, + 0x0e, 0x01, + 0x0e, 0x01, + 0x10, 0x01, + 0x10, 0x01, + 0x12, 0x01, + 0x12, 0x01, + 0x14, 0x01, + 0x14, 0x01, + 0x16, 0x01, + 0x16, 0x01, + 0x18, 0x01, + 0x18, 0x01, + 0x1a, 0x01, + 0x1a, 0x01, + 0x1c, 0x01, + 0x1c, 0x01, + 0x1e, 0x01, + 0x1e, 0x01, + 0x20, 0x01, + 0x20, 0x01, + 0x22, 0x01, + 0x22, 0x01, + 0x24, 0x01, + 0x24, 0x01, + 0x26, 0x01, + 0x26, 0x01, + 0x28, 0x01, + 0x28, 0x01, + 0x2a, 0x01, + 0x2a, 0x01, + 0x2c, 0x01, + 0x2c, 0x01, + 0x2e, 0x01, + 0x2e, 0x01, + 0x30, 0x01, + 0x31, 0x01, + 0x32, 0x01, + 0x32, 0x01, + 0x34, 0x01, + 0x34, 0x01, + 0x36, 0x01, + 0x36, 0x01, + 0x38, 0x01, + 0x39, 0x01, + 0x39, 0x01, + 0x3b, 0x01, + 0x3b, 0x01, + 0x3d, 0x01, + 0x3d, 0x01, + 0x3f, 0x01, + 0x3f, 0x01, + 0x41, 0x01, + 0x41, 0x01, + 0x43, 0x01, + 0x43, 0x01, + 0x45, 0x01, + 0x45, 0x01, + 0x47, 0x01, + 0x47, 0x01, + 0x49, 0x01, + 0x4a, 0x01, + 0x4a, 0x01, + 0x4c, 0x01, + 0x4c, 0x01, + 0x4e, 0x01, + 0x4e, 0x01, + 0x50, 0x01, + 0x50, 0x01, + 0x52, 0x01, + 0x52, 0x01, + 0x54, 0x01, + 0x54, 0x01, + 0x56, 0x01, + 0x56, 0x01, + 0x58, 0x01, + 0x58, 0x01, + 0x5a, 0x01, + 0x5a, 0x01, + 0x5c, 0x01, + 0x5c, 0x01, + 0x5e, 0x01, + 0x5e, 0x01, + 0x60, 0x01, + 0x60, 0x01, + 0x62, 0x01, + 0x62, 0x01, + 0x64, 0x01, + 0x64, 0x01, + 0x66, 0x01, + 0x66, 0x01, + 0x68, 0x01, + 0x68, 0x01, + 0x6a, 0x01, + 0x6a, 0x01, + 0x6c, 0x01, + 0x6c, 0x01, + 0x6e, 0x01, + 0x6e, 0x01, + 0x70, 0x01, + 0x70, 0x01, + 0x72, 0x01, + 0x72, 0x01, + 0x74, 0x01, + 0x74, 0x01, + 0x76, 0x01, + 0x76, 0x01, + 0x78, 0x01, + 0x79, 0x01, + 0x79, 0x01, + 0x7b, 0x01, + 0x7b, 0x01, + 0x7d, 0x01, + 0x7d, 0x01, + 0x7f, 0x01, + 0x43, 0x02, + 0x81, 0x01, + 0x82, 0x01, + 0x82, 0x01, + 0x84, 0x01, + 0x84, 0x01, + 0x86, 0x01, + 0x87, 0x01, + 0x87, 0x01, + 0x89, 0x01, + 0x8a, 0x01, + 0x8b, 0x01, + 0x8b, 0x01, + 0x8d, 0x01, + 0x8e, 0x01, + 0x8f, 0x01, + 0x90, 0x01, + 0x91, 0x01, + 0x91, 0x01, + 0x93, 0x01, + 0x94, 0x01, + 0xf6, 0x01, + 0x96, 0x01, + 0x97, 0x01, + 0x98, 0x01, + 0x98, 0x01, + 0x3d, 0x02, + 0x9b, 0x01, + 0x9c, 0x01, + 0x9d, 0x01, + 0x20, 0x02, + 0x9f, 0x01, + 0xa0, 0x01, + 0xa0, 0x01, + 0xa2, 0x01, + 0xa2, 0x01, + 0xa4, 0x01, + 0xa4, 0x01, + 0xa6, 0x01, + 0xa7, 0x01, + 0xa7, 0x01, + 0xa9, 0x01, + 0xaa, 0x01, + 0xab, 0x01, + 0xac, 0x01, + 0xac, 0x01, + 0xae, 0x01, + 0xaf, 0x01, + 0xaf, 0x01, + 0xb1, 0x01, + 0xb2, 0x01, + 0xb3, 0x01, + 0xb3, 0x01, + 0xb5, 0x01, + 0xb5, 0x01, + 0xb7, 0x01, + 0xb8, 0x01, + 0xb8, 0x01, + 0xba, 0x01, + 0xbb, 0x01, + 0xbc, 0x01, + 0xbc, 0x01, + 0xbe, 0x01, + 0xf7, 0x01, + 0xc0, 0x01, + 0xc1, 0x01, + 0xc2, 0x01, + 0xc3, 0x01, + 0xc4, 0x01, + 0xc5, 0x01, + 0xc4, 0x01, + 0xc7, 0x01, + 0xc8, 0x01, + 0xc7, 0x01, + 0xca, 0x01, + 0xcb, 0x01, + 0xca, 0x01, + 0xcd, 0x01, + 0xcd, 0x01, + 0xcf, 0x01, + 0xcf, 0x01, + 0xd1, 0x01, + 0xd1, 0x01, + 0xd3, 0x01, + 0xd3, 0x01, + 0xd5, 0x01, + 0xd5, 0x01, + 0xd7, 0x01, + 0xd7, 0x01, + 0xd9, 0x01, + 0xd9, 0x01, + 0xdb, 0x01, + 0xdb, 0x01, + 0x8e, 0x01, + 0xde, 0x01, + 0xde, 0x01, + 0xe0, 0x01, + 0xe0, 0x01, + 0xe2, 0x01, + 0xe2, 0x01, + 0xe4, 0x01, + 0xe4, 0x01, + 0xe6, 0x01, + 0xe6, 0x01, + 0xe8, 0x01, + 0xe8, 0x01, + 0xea, 0x01, + 0xea, 0x01, + 0xec, 0x01, + 0xec, 0x01, + 0xee, 0x01, + 0xee, 0x01, + 0xf0, 0x01, + 0xf1, 0x01, + 0xf2, 0x01, + 0xf1, 0x01, + 0xf4, 0x01, + 0xf4, 0x01, + 0xf6, 0x01, + 0xf7, 0x01, + 0xf8, 0x01, + 0xf8, 0x01, + 0xfa, 0x01, + 0xfa, 0x01, + 0xfc, 0x01, + 0xfc, 0x01, + 0xfe, 0x01, + 0xfe, 0x01, + 0x00, 0x02, + 0x00, 0x02, + 0x02, 0x02, + 0x02, 0x02, + 0x04, 0x02, + 0x04, 0x02, + 0x06, 0x02, + 0x06, 0x02, + 0x08, 0x02, + 0x08, 0x02, + 0x0a, 0x02, + 0x0a, 0x02, + 0x0c, 0x02, + 0x0c, 0x02, + 0x0e, 0x02, + 0x0e, 0x02, + 0x10, 0x02, + 0x10, 0x02, + 0x12, 0x02, + 0x12, 0x02, + 0x14, 0x02, + 0x14, 0x02, + 0x16, 0x02, + 0x16, 0x02, + 0x18, 0x02, + 0x18, 0x02, + 0x1a, 0x02, + 0x1a, 0x02, + 0x1c, 0x02, + 0x1c, 0x02, + 0x1e, 0x02, + 0x1e, 0x02, + 0x20, 0x02, + 0x21, 0x02, + 0x22, 0x02, + 0x22, 0x02, + 0x24, 0x02, + 0x24, 0x02, + 0x26, 0x02, + 0x26, 0x02, + 0x28, 0x02, + 0x28, 0x02, + 0x2a, 0x02, + 0x2a, 0x02, + 0x2c, 0x02, + 0x2c, 0x02, + 0x2e, 0x02, + 0x2e, 0x02, + 0x30, 0x02, + 0x30, 0x02, + 0x32, 0x02, + 0x32, 0x02, + 0x34, 0x02, + 0x35, 0x02, + 0x36, 0x02, + 0x37, 0x02, + 0x38, 0x02, + 0x39, 0x02, + 0x65, 0x2c, + 0x3b, 0x02, + 0x3b, 0x02, + 0x3d, 0x02, + 0x66, 0x2c, + 0x3f, 0x02, + 0x40, 0x02, + 0x41, 0x02, + 0x41, 0x02, + 0x43, 0x02, + 0x44, 0x02, + 0x45, 0x02, + 0x46, 0x02, + 0x46, 0x02, + 0x48, 0x02, + 0x48, 0x02, + 0x4a, 0x02, + 0x4a, 0x02, + 0x4c, 0x02, + 0x4c, 0x02, + 0x4e, 0x02, + 0x4e, 0x02, + 0x50, 0x02, + 0x51, 0x02, + 0x52, 0x02, + 0x81, 0x01, + 0x86, 0x01, + 0x55, 0x02, + 0x89, 0x01, + 0x8a, 0x01, + 0x58, 0x02, + 0x8f, 0x01, + 0x5a, 0x02, + 0x90, 0x01, + 0x5c, 0x02, + 0x5d, 0x02, + 0x5e, 0x02, + 0x5f, 0x02, + 0x93, 0x01, + 0x61, 0x02, + 0x62, 0x02, + 0x94, 0x01, + 0x64, 0x02, + 0x65, 0x02, + 0x66, 0x02, + 0x67, 0x02, + 0x97, 0x01, + 0x96, 0x01, + 0x6a, 0x02, + 0x62, 0x2c, + 0x6c, 0x02, + 0x6d, 0x02, + 0x6e, 0x02, + 0x9c, 0x01, + 0x70, 0x02, + 0x71, 0x02, + 0x9d, 0x01, + 0x73, 0x02, + 0x74, 0x02, + 0x9f, 0x01, + 0x76, 0x02, + 0x77, 0x02, + 0x78, 0x02, + 0x79, 0x02, + 0x7a, 0x02, + 0x7b, 0x02, + 0x7c, 0x02, + 0x64, 0x2c, + 0x7e, 0x02, + 0x7f, 0x02, + 0xa6, 0x01, + 0x81, 0x02, + 0x82, 0x02, + 0xa9, 0x01, + 0x84, 0x02, + 0x85, 0x02, + 0x86, 0x02, + 0x87, 0x02, + 0xae, 0x01, + 0x44, 0x02, + 0xb1, 0x01, + 0xb2, 0x01, + 0x45, 0x02, + 0x8d, 0x02, + 0x8e, 0x02, + 0x8f, 0x02, + 0x90, 0x02, + 0x91, 0x02, + 0xb7, 0x01, + 0x93, 0x02, + 0x94, 0x02, + 0x95, 0x02, + 0x96, 0x02, + 0x97, 0x02, + 0x98, 0x02, + 0x99, 0x02, + 0x9a, 0x02, + 0x9b, 0x02, + 0x9c, 0x02, + 0x9d, 0x02, + 0x9e, 0x02, + 0x9f, 0x02, + 0xa0, 0x02, + 0xa1, 0x02, + 0xa2, 0x02, + 0xa3, 0x02, + 0xa4, 0x02, + 0xa5, 0x02, + 0xa6, 0x02, + 0xa7, 0x02, + 0xa8, 0x02, + 0xa9, 0x02, + 0xaa, 0x02, + 0xab, 0x02, + 0xac, 0x02, + 0xad, 0x02, + 0xae, 0x02, + 0xaf, 0x02, + 0xb0, 0x02, + 0xb1, 0x02, + 0xb2, 0x02, + 0xb3, 0x02, + 0xb4, 0x02, + 0xb5, 0x02, + 0xb6, 0x02, + 0xb7, 0x02, + 0xb8, 0x02, + 0xb9, 0x02, + 0xba, 0x02, + 0xbb, 0x02, + 0xbc, 0x02, + 0xbd, 0x02, + 0xbe, 0x02, + 0xbf, 0x02, + 0xc0, 0x02, + 0xc1, 0x02, + 0xc2, 0x02, + 0xc3, 0x02, + 0xc4, 0x02, + 0xc5, 0x02, + 0xc6, 0x02, + 0xc7, 0x02, + 0xc8, 0x02, + 0xc9, 0x02, + 0xca, 0x02, + 0xcb, 0x02, + 0xcc, 0x02, + 0xcd, 0x02, + 0xce, 0x02, + 0xcf, 0x02, + 0xd0, 0x02, + 0xd1, 0x02, + 0xd2, 0x02, + 0xd3, 0x02, + 0xd4, 0x02, + 0xd5, 0x02, + 0xd6, 0x02, + 0xd7, 0x02, + 0xd8, 0x02, + 0xd9, 0x02, + 0xda, 0x02, + 0xdb, 0x02, + 0xdc, 0x02, + 0xdd, 0x02, + 0xde, 0x02, + 0xdf, 0x02, + 0xe0, 0x02, + 0xe1, 0x02, + 0xe2, 0x02, + 0xe3, 0x02, + 0xe4, 0x02, + 0xe5, 0x02, + 0xe6, 0x02, + 0xe7, 0x02, + 0xe8, 0x02, + 0xe9, 0x02, + 0xea, 0x02, + 0xeb, 0x02, + 0xec, 0x02, + 0xed, 0x02, + 0xee, 0x02, + 0xef, 0x02, + 0xf0, 0x02, + 0xf1, 0x02, + 0xf2, 0x02, + 0xf3, 0x02, + 0xf4, 0x02, + 0xf5, 0x02, + 0xf6, 0x02, + 0xf7, 0x02, + 0xf8, 0x02, + 0xf9, 0x02, + 0xfa, 0x02, + 0xfb, 0x02, + 0xfc, 0x02, + 0xfd, 0x02, + 0xfe, 0x02, + 0xff, 0x02, + 0x00, 0x03, + 0x01, 0x03, + 0x02, 0x03, + 0x03, 0x03, + 0x04, 0x03, + 0x05, 0x03, + 0x06, 0x03, + 0x07, 0x03, + 0x08, 0x03, + 0x09, 0x03, + 0x0a, 0x03, + 0x0b, 0x03, + 0x0c, 0x03, + 0x0d, 0x03, + 0x0e, 0x03, + 0x0f, 0x03, + 0x10, 0x03, + 0x11, 0x03, + 0x12, 0x03, + 0x13, 0x03, + 0x14, 0x03, + 0x15, 0x03, + 0x16, 0x03, + 0x17, 0x03, + 0x18, 0x03, + 0x19, 0x03, + 0x1a, 0x03, + 0x1b, 0x03, + 0x1c, 0x03, + 0x1d, 0x03, + 0x1e, 0x03, + 0x1f, 0x03, + 0x20, 0x03, + 0x21, 0x03, + 0x22, 0x03, + 0x23, 0x03, + 0x24, 0x03, + 0x25, 0x03, + 0x26, 0x03, + 0x27, 0x03, + 0x28, 0x03, + 0x29, 0x03, + 0x2a, 0x03, + 0x2b, 0x03, + 0x2c, 0x03, + 0x2d, 0x03, + 0x2e, 0x03, + 0x2f, 0x03, + 0x30, 0x03, + 0x31, 0x03, + 0x32, 0x03, + 0x33, 0x03, + 0x34, 0x03, + 0x35, 0x03, + 0x36, 0x03, + 0x37, 0x03, + 0x38, 0x03, + 0x39, 0x03, + 0x3a, 0x03, + 0x3b, 0x03, + 0x3c, 0x03, + 0x3d, 0x03, + 0x3e, 0x03, + 0x3f, 0x03, + 0x40, 0x03, + 0x41, 0x03, + 0x42, 0x03, + 0x43, 0x03, + 0x44, 0x03, + 0x45, 0x03, + 0x46, 0x03, + 0x47, 0x03, + 0x48, 0x03, + 0x49, 0x03, + 0x4a, 0x03, + 0x4b, 0x03, + 0x4c, 0x03, + 0x4d, 0x03, + 0x4e, 0x03, + 0x4f, 0x03, + 0x50, 0x03, + 0x51, 0x03, + 0x52, 0x03, + 0x53, 0x03, + 0x54, 0x03, + 0x55, 0x03, + 0x56, 0x03, + 0x57, 0x03, + 0x58, 0x03, + 0x59, 0x03, + 0x5a, 0x03, + 0x5b, 0x03, + 0x5c, 0x03, + 0x5d, 0x03, + 0x5e, 0x03, + 0x5f, 0x03, + 0x60, 0x03, + 0x61, 0x03, + 0x62, 0x03, + 0x63, 0x03, + 0x64, 0x03, + 0x65, 0x03, + 0x66, 0x03, + 0x67, 0x03, + 0x68, 0x03, + 0x69, 0x03, + 0x6a, 0x03, + 0x6b, 0x03, + 0x6c, 0x03, + 0x6d, 0x03, + 0x6e, 0x03, + 0x6f, 0x03, + 0x70, 0x03, + 0x71, 0x03, + 0x72, 0x03, + 0x73, 0x03, + 0x74, 0x03, + 0x75, 0x03, + 0x76, 0x03, + 0x77, 0x03, + 0x78, 0x03, + 0x79, 0x03, + 0x7a, 0x03, + 0xfd, 0x03, + 0xfe, 0x03, + 0xff, 0x03, + 0x7e, 0x03, + 0x7f, 0x03, + 0x80, 0x03, + 0x81, 0x03, + 0x82, 0x03, + 0x83, 0x03, + 0x84, 0x03, + 0x85, 0x03, + 0x86, 0x03, + 0x87, 0x03, + 0x88, 0x03, + 0x89, 0x03, + 0x8a, 0x03, + 0x8b, 0x03, + 0x8c, 0x03, + 0x8d, 0x03, + 0x8e, 0x03, + 0x8f, 0x03, + 0x90, 0x03, + 0x91, 0x03, + 0x92, 0x03, + 0x93, 0x03, + 0x94, 0x03, + 0x95, 0x03, + 0x96, 0x03, + 0x97, 0x03, + 0x98, 0x03, + 0x99, 0x03, + 0x9a, 0x03, + 0x9b, 0x03, + 0x9c, 0x03, + 0x9d, 0x03, + 0x9e, 0x03, + 0x9f, 0x03, + 0xa0, 0x03, + 0xa1, 0x03, + 0xa2, 0x03, + 0xa3, 0x03, + 0xa4, 0x03, + 0xa5, 0x03, + 0xa6, 0x03, + 0xa7, 0x03, + 0xa8, 0x03, + 0xa9, 0x03, + 0xaa, 0x03, + 0xab, 0x03, + 0x86, 0x03, + 0x88, 0x03, + 0x89, 0x03, + 0x8a, 0x03, + 0xb0, 0x03, + 0x91, 0x03, + 0x92, 0x03, + 0x93, 0x03, + 0x94, 0x03, + 0x95, 0x03, + 0x96, 0x03, + 0x97, 0x03, + 0x98, 0x03, + 0x99, 0x03, + 0x9a, 0x03, + 0x9b, 0x03, + 0x9c, 0x03, + 0x9d, 0x03, + 0x9e, 0x03, + 0x9f, 0x03, + 0xa0, 0x03, + 0xa1, 0x03, + 0xa3, 0x03, + 0xa3, 0x03, + 0xa4, 0x03, + 0xa5, 0x03, + 0xa6, 0x03, + 0xa7, 0x03, + 0xa8, 0x03, + 0xa9, 0x03, + 0xaa, 0x03, + 0xab, 0x03, + 0x8c, 0x03, + 0x8e, 0x03, + 0x8f, 0x03, + 0xcf, 0x03, + 0xd0, 0x03, + 0xd1, 0x03, + 0xd2, 0x03, + 0xd3, 0x03, + 0xd4, 0x03, + 0xd5, 0x03, + 0xd6, 0x03, + 0xd7, 0x03, + 0xd8, 0x03, + 0xd8, 0x03, + 0xda, 0x03, + 0xda, 0x03, + 0xdc, 0x03, + 0xdc, 0x03, + 0xde, 0x03, + 0xde, 0x03, + 0xe0, 0x03, + 0xe0, 0x03, + 0xe2, 0x03, + 0xe2, 0x03, + 0xe4, 0x03, + 0xe4, 0x03, + 0xe6, 0x03, + 0xe6, 0x03, + 0xe8, 0x03, + 0xe8, 0x03, + 0xea, 0x03, + 0xea, 0x03, + 0xec, 0x03, + 0xec, 0x03, + 0xee, 0x03, + 0xee, 0x03, + 0xf0, 0x03, + 0xf1, 0x03, + 0xf9, 0x03, + 0xf3, 0x03, + 0xf4, 0x03, + 0xf5, 0x03, + 0xf6, 0x03, + 0xf7, 0x03, + 0xf7, 0x03, + 0xf9, 0x03, + 0xfa, 0x03, + 0xfa, 0x03, + 0xfc, 0x03, + 0xfd, 0x03, + 0xfe, 0x03, + 0xff, 0x03, + 0x00, 0x04, + 0x01, 0x04, + 0x02, 0x04, + 0x03, 0x04, + 0x04, 0x04, + 0x05, 0x04, + 0x06, 0x04, + 0x07, 0x04, + 0x08, 0x04, + 0x09, 0x04, + 0x0a, 0x04, + 0x0b, 0x04, + 0x0c, 0x04, + 0x0d, 0x04, + 0x0e, 0x04, + 0x0f, 0x04, + 0x10, 0x04, + 0x11, 0x04, + 0x12, 0x04, + 0x13, 0x04, + 0x14, 0x04, + 0x15, 0x04, + 0x16, 0x04, + 0x17, 0x04, + 0x18, 0x04, + 0x19, 0x04, + 0x1a, 0x04, + 0x1b, 0x04, + 0x1c, 0x04, + 0x1d, 0x04, + 0x1e, 0x04, + 0x1f, 0x04, + 0x20, 0x04, + 0x21, 0x04, + 0x22, 0x04, + 0x23, 0x04, + 0x24, 0x04, + 0x25, 0x04, + 0x26, 0x04, + 0x27, 0x04, + 0x28, 0x04, + 0x29, 0x04, + 0x2a, 0x04, + 0x2b, 0x04, + 0x2c, 0x04, + 0x2d, 0x04, + 0x2e, 0x04, + 0x2f, 0x04, + 0x10, 0x04, + 0x11, 0x04, + 0x12, 0x04, + 0x13, 0x04, + 0x14, 0x04, + 0x15, 0x04, + 0x16, 0x04, + 0x17, 0x04, + 0x18, 0x04, + 0x19, 0x04, + 0x1a, 0x04, + 0x1b, 0x04, + 0x1c, 0x04, + 0x1d, 0x04, + 0x1e, 0x04, + 0x1f, 0x04, + 0x20, 0x04, + 0x21, 0x04, + 0x22, 0x04, + 0x23, 0x04, + 0x24, 0x04, + 0x25, 0x04, + 0x26, 0x04, + 0x27, 0x04, + 0x28, 0x04, + 0x29, 0x04, + 0x2a, 0x04, + 0x2b, 0x04, + 0x2c, 0x04, + 0x2d, 0x04, + 0x2e, 0x04, + 0x2f, 0x04, + 0x00, 0x04, + 0x01, 0x04, + 0x02, 0x04, + 0x03, 0x04, + 0x04, 0x04, + 0x05, 0x04, + 0x06, 0x04, + 0x07, 0x04, + 0x08, 0x04, + 0x09, 0x04, + 0x0a, 0x04, + 0x0b, 0x04, + 0x0c, 0x04, + 0x0d, 0x04, + 0x0e, 0x04, + 0x0f, 0x04, + 0x60, 0x04, + 0x60, 0x04, + 0x62, 0x04, + 0x62, 0x04, + 0x64, 0x04, + 0x64, 0x04, + 0x66, 0x04, + 0x66, 0x04, + 0x68, 0x04, + 0x68, 0x04, + 0x6a, 0x04, + 0x6a, 0x04, + 0x6c, 0x04, + 0x6c, 0x04, + 0x6e, 0x04, + 0x6e, 0x04, + 0x70, 0x04, + 0x70, 0x04, + 0x72, 0x04, + 0x72, 0x04, + 0x74, 0x04, + 0x74, 0x04, + 0x76, 0x04, + 0x76, 0x04, + 0x78, 0x04, + 0x78, 0x04, + 0x7a, 0x04, + 0x7a, 0x04, + 0x7c, 0x04, + 0x7c, 0x04, + 0x7e, 0x04, + 0x7e, 0x04, + 0x80, 0x04, + 0x80, 0x04, + 0x82, 0x04, + 0x83, 0x04, + 0x84, 0x04, + 0x85, 0x04, + 0x86, 0x04, + 0x87, 0x04, + 0x88, 0x04, + 0x89, 0x04, + 0x8a, 0x04, + 0x8a, 0x04, + 0x8c, 0x04, + 0x8c, 0x04, + 0x8e, 0x04, + 0x8e, 0x04, + 0x90, 0x04, + 0x90, 0x04, + 0x92, 0x04, + 0x92, 0x04, + 0x94, 0x04, + 0x94, 0x04, + 0x96, 0x04, + 0x96, 0x04, + 0x98, 0x04, + 0x98, 0x04, + 0x9a, 0x04, + 0x9a, 0x04, + 0x9c, 0x04, + 0x9c, 0x04, + 0x9e, 0x04, + 0x9e, 0x04, + 0xa0, 0x04, + 0xa0, 0x04, + 0xa2, 0x04, + 0xa2, 0x04, + 0xa4, 0x04, + 0xa4, 0x04, + 0xa6, 0x04, + 0xa6, 0x04, + 0xa8, 0x04, + 0xa8, 0x04, + 0xaa, 0x04, + 0xaa, 0x04, + 0xac, 0x04, + 0xac, 0x04, + 0xae, 0x04, + 0xae, 0x04, + 0xb0, 0x04, + 0xb0, 0x04, + 0xb2, 0x04, + 0xb2, 0x04, + 0xb4, 0x04, + 0xb4, 0x04, + 0xb6, 0x04, + 0xb6, 0x04, + 0xb8, 0x04, + 0xb8, 0x04, + 0xba, 0x04, + 0xba, 0x04, + 0xbc, 0x04, + 0xbc, 0x04, + 0xbe, 0x04, + 0xbe, 0x04, + 0xc0, 0x04, + 0xc1, 0x04, + 0xc1, 0x04, + 0xc3, 0x04, + 0xc3, 0x04, + 0xc5, 0x04, + 0xc5, 0x04, + 0xc7, 0x04, + 0xc7, 0x04, + 0xc9, 0x04, + 0xc9, 0x04, + 0xcb, 0x04, + 0xcb, 0x04, + 0xcd, 0x04, + 0xcd, 0x04, + 0xc0, 0x04, + 0xd0, 0x04, + 0xd0, 0x04, + 0xd2, 0x04, + 0xd2, 0x04, + 0xd4, 0x04, + 0xd4, 0x04, + 0xd6, 0x04, + 0xd6, 0x04, + 0xd8, 0x04, + 0xd8, 0x04, + 0xda, 0x04, + 0xda, 0x04, + 0xdc, 0x04, + 0xdc, 0x04, + 0xde, 0x04, + 0xde, 0x04, + 0xe0, 0x04, + 0xe0, 0x04, + 0xe2, 0x04, + 0xe2, 0x04, + 0xe4, 0x04, + 0xe4, 0x04, + 0xe6, 0x04, + 0xe6, 0x04, + 0xe8, 0x04, + 0xe8, 0x04, + 0xea, 0x04, + 0xea, 0x04, + 0xec, 0x04, + 0xec, 0x04, + 0xee, 0x04, + 0xee, 0x04, + 0xf0, 0x04, + 0xf0, 0x04, + 0xf2, 0x04, + 0xf2, 0x04, + 0xf4, 0x04, + 0xf4, 0x04, + 0xf6, 0x04, + 0xf6, 0x04, + 0xf8, 0x04, + 0xf8, 0x04, + 0xfa, 0x04, + 0xfa, 0x04, + 0xfc, 0x04, + 0xfc, 0x04, + 0xfe, 0x04, + 0xfe, 0x04, + 0x00, 0x05, + 0x00, 0x05, + 0x02, 0x05, + 0x02, 0x05, + 0x04, 0x05, + 0x04, 0x05, + 0x06, 0x05, + 0x06, 0x05, + 0x08, 0x05, + 0x08, 0x05, + 0x0a, 0x05, + 0x0a, 0x05, + 0x0c, 0x05, + 0x0c, 0x05, + 0x0e, 0x05, + 0x0e, 0x05, + 0x10, 0x05, + 0x10, 0x05, + 0x12, 0x05, + 0x12, 0x05, + 0x14, 0x05, + 0x15, 0x05, + 0x16, 0x05, + 0x17, 0x05, + 0x18, 0x05, + 0x19, 0x05, + 0x1a, 0x05, + 0x1b, 0x05, + 0x1c, 0x05, + 0x1d, 0x05, + 0x1e, 0x05, + 0x1f, 0x05, + 0x20, 0x05, + 0x21, 0x05, + 0x22, 0x05, + 0x23, 0x05, + 0x24, 0x05, + 0x25, 0x05, + 0x26, 0x05, + 0x27, 0x05, + 0x28, 0x05, + 0x29, 0x05, + 0x2a, 0x05, + 0x2b, 0x05, + 0x2c, 0x05, + 0x2d, 0x05, + 0x2e, 0x05, + 0x2f, 0x05, + 0x30, 0x05, + 0x31, 0x05, + 0x32, 0x05, + 0x33, 0x05, + 0x34, 0x05, + 0x35, 0x05, + 0x36, 0x05, + 0x37, 0x05, + 0x38, 0x05, + 0x39, 0x05, + 0x3a, 0x05, + 0x3b, 0x05, + 0x3c, 0x05, + 0x3d, 0x05, + 0x3e, 0x05, + 0x3f, 0x05, + 0x40, 0x05, + 0x41, 0x05, + 0x42, 0x05, + 0x43, 0x05, + 0x44, 0x05, + 0x45, 0x05, + 0x46, 0x05, + 0x47, 0x05, + 0x48, 0x05, + 0x49, 0x05, + 0x4a, 0x05, + 0x4b, 0x05, + 0x4c, 0x05, + 0x4d, 0x05, + 0x4e, 0x05, + 0x4f, 0x05, + 0x50, 0x05, + 0x51, 0x05, + 0x52, 0x05, + 0x53, 0x05, + 0x54, 0x05, + 0x55, 0x05, + 0x56, 0x05, + 0x57, 0x05, + 0x58, 0x05, + 0x59, 0x05, + 0x5a, 0x05, + 0x5b, 0x05, + 0x5c, 0x05, + 0x5d, 0x05, + 0x5e, 0x05, + 0x5f, 0x05, + 0x60, 0x05, + 0x31, 0x05, + 0x32, 0x05, + 0x33, 0x05, + 0x34, 0x05, + 0x35, 0x05, + 0x36, 0x05, + 0x37, 0x05, + 0x38, 0x05, + 0x39, 0x05, + 0x3a, 0x05, + 0x3b, 0x05, + 0x3c, 0x05, + 0x3d, 0x05, + 0x3e, 0x05, + 0x3f, 0x05, + 0x40, 0x05, + 0x41, 0x05, + 0x42, 0x05, + 0x43, 0x05, + 0x44, 0x05, + 0x45, 0x05, + 0x46, 0x05, + 0x47, 0x05, + 0x48, 0x05, + 0x49, 0x05, + 0x4a, 0x05, + 0x4b, 0x05, + 0x4c, 0x05, + 0x4d, 0x05, + 0x4e, 0x05, + 0x4f, 0x05, + 0x50, 0x05, + 0x51, 0x05, + 0x52, 0x05, + 0x53, 0x05, + 0x54, 0x05, + 0x55, 0x05, + 0x56, 0x05, + 0xff, 0xff, + 0xf6, 0x17, + 0x63, 0x2c, + 0x7e, 0x1d, + 0x7f, 0x1d, + 0x80, 0x1d, + 0x81, 0x1d, + 0x82, 0x1d, + 0x83, 0x1d, + 0x84, 0x1d, + 0x85, 0x1d, + 0x86, 0x1d, + 0x87, 0x1d, + 0x88, 0x1d, + 0x89, 0x1d, + 0x8a, 0x1d, + 0x8b, 0x1d, + 0x8c, 0x1d, + 0x8d, 0x1d, + 0x8e, 0x1d, + 0x8f, 0x1d, + 0x90, 0x1d, + 0x91, 0x1d, + 0x92, 0x1d, + 0x93, 0x1d, + 0x94, 0x1d, + 0x95, 0x1d, + 0x96, 0x1d, + 0x97, 0x1d, + 0x98, 0x1d, + 0x99, 0x1d, + 0x9a, 0x1d, + 0x9b, 0x1d, + 0x9c, 0x1d, + 0x9d, 0x1d, + 0x9e, 0x1d, + 0x9f, 0x1d, + 0xa0, 0x1d, + 0xa1, 0x1d, + 0xa2, 0x1d, + 0xa3, 0x1d, + 0xa4, 0x1d, + 0xa5, 0x1d, + 0xa6, 0x1d, + 0xa7, 0x1d, + 0xa8, 0x1d, + 0xa9, 0x1d, + 0xaa, 0x1d, + 0xab, 0x1d, + 0xac, 0x1d, + 0xad, 0x1d, + 0xae, 0x1d, + 0xaf, 0x1d, + 0xb0, 0x1d, + 0xb1, 0x1d, + 0xb2, 0x1d, + 0xb3, 0x1d, + 0xb4, 0x1d, + 0xb5, 0x1d, + 0xb6, 0x1d, + 0xb7, 0x1d, + 0xb8, 0x1d, + 0xb9, 0x1d, + 0xba, 0x1d, + 0xbb, 0x1d, + 0xbc, 0x1d, + 0xbd, 0x1d, + 0xbe, 0x1d, + 0xbf, 0x1d, + 0xc0, 0x1d, + 0xc1, 0x1d, + 0xc2, 0x1d, + 0xc3, 0x1d, + 0xc4, 0x1d, + 0xc5, 0x1d, + 0xc6, 0x1d, + 0xc7, 0x1d, + 0xc8, 0x1d, + 0xc9, 0x1d, + 0xca, 0x1d, + 0xcb, 0x1d, + 0xcc, 0x1d, + 0xcd, 0x1d, + 0xce, 0x1d, + 0xcf, 0x1d, + 0xd0, 0x1d, + 0xd1, 0x1d, + 0xd2, 0x1d, + 0xd3, 0x1d, + 0xd4, 0x1d, + 0xd5, 0x1d, + 0xd6, 0x1d, + 0xd7, 0x1d, + 0xd8, 0x1d, + 0xd9, 0x1d, + 0xda, 0x1d, + 0xdb, 0x1d, + 0xdc, 0x1d, + 0xdd, 0x1d, + 0xde, 0x1d, + 0xdf, 0x1d, + 0xe0, 0x1d, + 0xe1, 0x1d, + 0xe2, 0x1d, + 0xe3, 0x1d, + 0xe4, 0x1d, + 0xe5, 0x1d, + 0xe6, 0x1d, + 0xe7, 0x1d, + 0xe8, 0x1d, + 0xe9, 0x1d, + 0xea, 0x1d, + 0xeb, 0x1d, + 0xec, 0x1d, + 0xed, 0x1d, + 0xee, 0x1d, + 0xef, 0x1d, + 0xf0, 0x1d, + 0xf1, 0x1d, + 0xf2, 0x1d, + 0xf3, 0x1d, + 0xf4, 0x1d, + 0xf5, 0x1d, + 0xf6, 0x1d, + 0xf7, 0x1d, + 0xf8, 0x1d, + 0xf9, 0x1d, + 0xfa, 0x1d, + 0xfb, 0x1d, + 0xfc, 0x1d, + 0xfd, 0x1d, + 0xfe, 0x1d, + 0xff, 0x1d, + 0x00, 0x1e, + 0x00, 0x1e, + 0x02, 0x1e, + 0x02, 0x1e, + 0x04, 0x1e, + 0x04, 0x1e, + 0x06, 0x1e, + 0x06, 0x1e, + 0x08, 0x1e, + 0x08, 0x1e, + 0x0a, 0x1e, + 0x0a, 0x1e, + 0x0c, 0x1e, + 0x0c, 0x1e, + 0x0e, 0x1e, + 0x0e, 0x1e, + 0x10, 0x1e, + 0x10, 0x1e, + 0x12, 0x1e, + 0x12, 0x1e, + 0x14, 0x1e, + 0x14, 0x1e, + 0x16, 0x1e, + 0x16, 0x1e, + 0x18, 0x1e, + 0x18, 0x1e, + 0x1a, 0x1e, + 0x1a, 0x1e, + 0x1c, 0x1e, + 0x1c, 0x1e, + 0x1e, 0x1e, + 0x1e, 0x1e, + 0x20, 0x1e, + 0x20, 0x1e, + 0x22, 0x1e, + 0x22, 0x1e, + 0x24, 0x1e, + 0x24, 0x1e, + 0x26, 0x1e, + 0x26, 0x1e, + 0x28, 0x1e, + 0x28, 0x1e, + 0x2a, 0x1e, + 0x2a, 0x1e, + 0x2c, 0x1e, + 0x2c, 0x1e, + 0x2e, 0x1e, + 0x2e, 0x1e, + 0x30, 0x1e, + 0x30, 0x1e, + 0x32, 0x1e, + 0x32, 0x1e, + 0x34, 0x1e, + 0x34, 0x1e, + 0x36, 0x1e, + 0x36, 0x1e, + 0x38, 0x1e, + 0x38, 0x1e, + 0x3a, 0x1e, + 0x3a, 0x1e, + 0x3c, 0x1e, + 0x3c, 0x1e, + 0x3e, 0x1e, + 0x3e, 0x1e, + 0x40, 0x1e, + 0x40, 0x1e, + 0x42, 0x1e, + 0x42, 0x1e, + 0x44, 0x1e, + 0x44, 0x1e, + 0x46, 0x1e, + 0x46, 0x1e, + 0x48, 0x1e, + 0x48, 0x1e, + 0x4a, 0x1e, + 0x4a, 0x1e, + 0x4c, 0x1e, + 0x4c, 0x1e, + 0x4e, 0x1e, + 0x4e, 0x1e, + 0x50, 0x1e, + 0x50, 0x1e, + 0x52, 0x1e, + 0x52, 0x1e, + 0x54, 0x1e, + 0x54, 0x1e, + 0x56, 0x1e, + 0x56, 0x1e, + 0x58, 0x1e, + 0x58, 0x1e, + 0x5a, 0x1e, + 0x5a, 0x1e, + 0x5c, 0x1e, + 0x5c, 0x1e, + 0x5e, 0x1e, + 0x5e, 0x1e, + 0x60, 0x1e, + 0x60, 0x1e, + 0x62, 0x1e, + 0x62, 0x1e, + 0x64, 0x1e, + 0x64, 0x1e, + 0x66, 0x1e, + 0x66, 0x1e, + 0x68, 0x1e, + 0x68, 0x1e, + 0x6a, 0x1e, + 0x6a, 0x1e, + 0x6c, 0x1e, + 0x6c, 0x1e, + 0x6e, 0x1e, + 0x6e, 0x1e, + 0x70, 0x1e, + 0x70, 0x1e, + 0x72, 0x1e, + 0x72, 0x1e, + 0x74, 0x1e, + 0x74, 0x1e, + 0x76, 0x1e, + 0x76, 0x1e, + 0x78, 0x1e, + 0x78, 0x1e, + 0x7a, 0x1e, + 0x7a, 0x1e, + 0x7c, 0x1e, + 0x7c, 0x1e, + 0x7e, 0x1e, + 0x7e, 0x1e, + 0x80, 0x1e, + 0x80, 0x1e, + 0x82, 0x1e, + 0x82, 0x1e, + 0x84, 0x1e, + 0x84, 0x1e, + 0x86, 0x1e, + 0x86, 0x1e, + 0x88, 0x1e, + 0x88, 0x1e, + 0x8a, 0x1e, + 0x8a, 0x1e, + 0x8c, 0x1e, + 0x8c, 0x1e, + 0x8e, 0x1e, + 0x8e, 0x1e, + 0x90, 0x1e, + 0x90, 0x1e, + 0x92, 0x1e, + 0x92, 0x1e, + 0x94, 0x1e, + 0x94, 0x1e, + 0x96, 0x1e, + 0x97, 0x1e, + 0x98, 0x1e, + 0x99, 0x1e, + 0x9a, 0x1e, + 0x9b, 0x1e, + 0x9c, 0x1e, + 0x9d, 0x1e, + 0x9e, 0x1e, + 0x9f, 0x1e, + 0xa0, 0x1e, + 0xa0, 0x1e, + 0xa2, 0x1e, + 0xa2, 0x1e, + 0xa4, 0x1e, + 0xa4, 0x1e, + 0xa6, 0x1e, + 0xa6, 0x1e, + 0xa8, 0x1e, + 0xa8, 0x1e, + 0xaa, 0x1e, + 0xaa, 0x1e, + 0xac, 0x1e, + 0xac, 0x1e, + 0xae, 0x1e, + 0xae, 0x1e, + 0xb0, 0x1e, + 0xb0, 0x1e, + 0xb2, 0x1e, + 0xb2, 0x1e, + 0xb4, 0x1e, + 0xb4, 0x1e, + 0xb6, 0x1e, + 0xb6, 0x1e, + 0xb8, 0x1e, + 0xb8, 0x1e, + 0xba, 0x1e, + 0xba, 0x1e, + 0xbc, 0x1e, + 0xbc, 0x1e, + 0xbe, 0x1e, + 0xbe, 0x1e, + 0xc0, 0x1e, + 0xc0, 0x1e, + 0xc2, 0x1e, + 0xc2, 0x1e, + 0xc4, 0x1e, + 0xc4, 0x1e, + 0xc6, 0x1e, + 0xc6, 0x1e, + 0xc8, 0x1e, + 0xc8, 0x1e, + 0xca, 0x1e, + 0xca, 0x1e, + 0xcc, 0x1e, + 0xcc, 0x1e, + 0xce, 0x1e, + 0xce, 0x1e, + 0xd0, 0x1e, + 0xd0, 0x1e, + 0xd2, 0x1e, + 0xd2, 0x1e, + 0xd4, 0x1e, + 0xd4, 0x1e, + 0xd6, 0x1e, + 0xd6, 0x1e, + 0xd8, 0x1e, + 0xd8, 0x1e, + 0xda, 0x1e, + 0xda, 0x1e, + 0xdc, 0x1e, + 0xdc, 0x1e, + 0xde, 0x1e, + 0xde, 0x1e, + 0xe0, 0x1e, + 0xe0, 0x1e, + 0xe2, 0x1e, + 0xe2, 0x1e, + 0xe4, 0x1e, + 0xe4, 0x1e, + 0xe6, 0x1e, + 0xe6, 0x1e, + 0xe8, 0x1e, + 0xe8, 0x1e, + 0xea, 0x1e, + 0xea, 0x1e, + 0xec, 0x1e, + 0xec, 0x1e, + 0xee, 0x1e, + 0xee, 0x1e, + 0xf0, 0x1e, + 0xf0, 0x1e, + 0xf2, 0x1e, + 0xf2, 0x1e, + 0xf4, 0x1e, + 0xf4, 0x1e, + 0xf6, 0x1e, + 0xf6, 0x1e, + 0xf8, 0x1e, + 0xf8, 0x1e, + 0xfa, 0x1e, + 0xfb, 0x1e, + 0xfc, 0x1e, + 0xfd, 0x1e, + 0xfe, 0x1e, + 0xff, 0x1e, + 0x08, 0x1f, + 0x09, 0x1f, + 0x0a, 0x1f, + 0x0b, 0x1f, + 0x0c, 0x1f, + 0x0d, 0x1f, + 0x0e, 0x1f, + 0x0f, 0x1f, + 0x08, 0x1f, + 0x09, 0x1f, + 0x0a, 0x1f, + 0x0b, 0x1f, + 0x0c, 0x1f, + 0x0d, 0x1f, + 0x0e, 0x1f, + 0x0f, 0x1f, + 0x18, 0x1f, + 0x19, 0x1f, + 0x1a, 0x1f, + 0x1b, 0x1f, + 0x1c, 0x1f, + 0x1d, 0x1f, + 0x16, 0x1f, + 0x17, 0x1f, + 0x18, 0x1f, + 0x19, 0x1f, + 0x1a, 0x1f, + 0x1b, 0x1f, + 0x1c, 0x1f, + 0x1d, 0x1f, + 0x1e, 0x1f, + 0x1f, 0x1f, + 0x28, 0x1f, + 0x29, 0x1f, + 0x2a, 0x1f, + 0x2b, 0x1f, + 0x2c, 0x1f, + 0x2d, 0x1f, + 0x2e, 0x1f, + 0x2f, 0x1f, + 0x28, 0x1f, + 0x29, 0x1f, + 0x2a, 0x1f, + 0x2b, 0x1f, + 0x2c, 0x1f, + 0x2d, 0x1f, + 0x2e, 0x1f, + 0x2f, 0x1f, + 0x38, 0x1f, + 0x39, 0x1f, + 0x3a, 0x1f, + 0x3b, 0x1f, + 0x3c, 0x1f, + 0x3d, 0x1f, + 0x3e, 0x1f, + 0x3f, 0x1f, + 0x38, 0x1f, + 0x39, 0x1f, + 0x3a, 0x1f, + 0x3b, 0x1f, + 0x3c, 0x1f, + 0x3d, 0x1f, + 0x3e, 0x1f, + 0x3f, 0x1f, + 0x48, 0x1f, + 0x49, 0x1f, + 0x4a, 0x1f, + 0x4b, 0x1f, + 0x4c, 0x1f, + 0x4d, 0x1f, + 0x46, 0x1f, + 0x47, 0x1f, + 0x48, 0x1f, + 0x49, 0x1f, + 0x4a, 0x1f, + 0x4b, 0x1f, + 0x4c, 0x1f, + 0x4d, 0x1f, + 0x4e, 0x1f, + 0x4f, 0x1f, + 0x50, 0x1f, + 0x59, 0x1f, + 0x52, 0x1f, + 0x5b, 0x1f, + 0x54, 0x1f, + 0x5d, 0x1f, + 0x56, 0x1f, + 0x5f, 0x1f, + 0x58, 0x1f, + 0x59, 0x1f, + 0x5a, 0x1f, + 0x5b, 0x1f, + 0x5c, 0x1f, + 0x5d, 0x1f, + 0x5e, 0x1f, + 0x5f, 0x1f, + 0x68, 0x1f, + 0x69, 0x1f, + 0x6a, 0x1f, + 0x6b, 0x1f, + 0x6c, 0x1f, + 0x6d, 0x1f, + 0x6e, 0x1f, + 0x6f, 0x1f, + 0x68, 0x1f, + 0x69, 0x1f, + 0x6a, 0x1f, + 0x6b, 0x1f, + 0x6c, 0x1f, + 0x6d, 0x1f, + 0x6e, 0x1f, + 0x6f, 0x1f, + 0xba, 0x1f, + 0xbb, 0x1f, + 0xc8, 0x1f, + 0xc9, 0x1f, + 0xca, 0x1f, + 0xcb, 0x1f, + 0xda, 0x1f, + 0xdb, 0x1f, + 0xf8, 0x1f, + 0xf9, 0x1f, + 0xea, 0x1f, + 0xeb, 0x1f, + 0xfa, 0x1f, + 0xfb, 0x1f, + 0x7e, 0x1f, + 0x7f, 0x1f, + 0x88, 0x1f, + 0x89, 0x1f, + 0x8a, 0x1f, + 0x8b, 0x1f, + 0x8c, 0x1f, + 0x8d, 0x1f, + 0x8e, 0x1f, + 0x8f, 0x1f, + 0x88, 0x1f, + 0x89, 0x1f, + 0x8a, 0x1f, + 0x8b, 0x1f, + 0x8c, 0x1f, + 0x8d, 0x1f, + 0x8e, 0x1f, + 0x8f, 0x1f, + 0x98, 0x1f, + 0x99, 0x1f, + 0x9a, 0x1f, + 0x9b, 0x1f, + 0x9c, 0x1f, + 0x9d, 0x1f, + 0x9e, 0x1f, + 0x9f, 0x1f, + 0x98, 0x1f, + 0x99, 0x1f, + 0x9a, 0x1f, + 0x9b, 0x1f, + 0x9c, 0x1f, + 0x9d, 0x1f, + 0x9e, 0x1f, + 0x9f, 0x1f, + 0xa8, 0x1f, + 0xa9, 0x1f, + 0xaa, 0x1f, + 0xab, 0x1f, + 0xac, 0x1f, + 0xad, 0x1f, + 0xae, 0x1f, + 0xaf, 0x1f, + 0xa8, 0x1f, + 0xa9, 0x1f, + 0xaa, 0x1f, + 0xab, 0x1f, + 0xac, 0x1f, + 0xad, 0x1f, + 0xae, 0x1f, + 0xaf, 0x1f, + 0xb8, 0x1f, + 0xb9, 0x1f, + 0xb2, 0x1f, + 0xbc, 0x1f, + 0xb4, 0x1f, + 0xb5, 0x1f, + 0xb6, 0x1f, + 0xb7, 0x1f, + 0xb8, 0x1f, + 0xb9, 0x1f, + 0xba, 0x1f, + 0xbb, 0x1f, + 0xbc, 0x1f, + 0xbd, 0x1f, + 0xbe, 0x1f, + 0xbf, 0x1f, + 0xc0, 0x1f, + 0xc1, 0x1f, + 0xc2, 0x1f, + 0xc3, 0x1f, + 0xc4, 0x1f, + 0xc5, 0x1f, + 0xc6, 0x1f, + 0xc7, 0x1f, + 0xc8, 0x1f, + 0xc9, 0x1f, + 0xca, 0x1f, + 0xcb, 0x1f, + 0xc3, 0x1f, + 0xcd, 0x1f, + 0xce, 0x1f, + 0xcf, 0x1f, + 0xd8, 0x1f, + 0xd9, 0x1f, + 0xd2, 0x1f, + 0xd3, 0x1f, + 0xd4, 0x1f, + 0xd5, 0x1f, + 0xd6, 0x1f, + 0xd7, 0x1f, + 0xd8, 0x1f, + 0xd9, 0x1f, + 0xda, 0x1f, + 0xdb, 0x1f, + 0xdc, 0x1f, + 0xdd, 0x1f, + 0xde, 0x1f, + 0xdf, 0x1f, + 0xe8, 0x1f, + 0xe9, 0x1f, + 0xe2, 0x1f, + 0xe3, 0x1f, + 0xe4, 0x1f, + 0xec, 0x1f, + 0xe6, 0x1f, + 0xe7, 0x1f, + 0xe8, 0x1f, + 0xe9, 0x1f, + 0xea, 0x1f, + 0xeb, 0x1f, + 0xec, 0x1f, + 0xed, 0x1f, + 0xee, 0x1f, + 0xef, 0x1f, + 0xf0, 0x1f, + 0xf1, 0x1f, + 0xf2, 0x1f, + 0xf3, 0x1f, + 0xf4, 0x1f, + 0xf5, 0x1f, + 0xf6, 0x1f, + 0xf7, 0x1f, + 0xf8, 0x1f, + 0xf9, 0x1f, + 0xfa, 0x1f, + 0xfb, 0x1f, + 0xf3, 0x1f, + 0xfd, 0x1f, + 0xfe, 0x1f, + 0xff, 0x1f, + 0x00, 0x20, + 0x01, 0x20, + 0x02, 0x20, + 0x03, 0x20, + 0x04, 0x20, + 0x05, 0x20, + 0x06, 0x20, + 0x07, 0x20, + 0x08, 0x20, + 0x09, 0x20, + 0x0a, 0x20, + 0x0b, 0x20, + 0x0c, 0x20, + 0x0d, 0x20, + 0x0e, 0x20, + 0x0f, 0x20, + 0x10, 0x20, + 0x11, 0x20, + 0x12, 0x20, + 0x13, 0x20, + 0x14, 0x20, + 0x15, 0x20, + 0x16, 0x20, + 0x17, 0x20, + 0x18, 0x20, + 0x19, 0x20, + 0x1a, 0x20, + 0x1b, 0x20, + 0x1c, 0x20, + 0x1d, 0x20, + 0x1e, 0x20, + 0x1f, 0x20, + 0x20, 0x20, + 0x21, 0x20, + 0x22, 0x20, + 0x23, 0x20, + 0x24, 0x20, + 0x25, 0x20, + 0x26, 0x20, + 0x27, 0x20, + 0x28, 0x20, + 0x29, 0x20, + 0x2a, 0x20, + 0x2b, 0x20, + 0x2c, 0x20, + 0x2d, 0x20, + 0x2e, 0x20, + 0x2f, 0x20, + 0x30, 0x20, + 0x31, 0x20, + 0x32, 0x20, + 0x33, 0x20, + 0x34, 0x20, + 0x35, 0x20, + 0x36, 0x20, + 0x37, 0x20, + 0x38, 0x20, + 0x39, 0x20, + 0x3a, 0x20, + 0x3b, 0x20, + 0x3c, 0x20, + 0x3d, 0x20, + 0x3e, 0x20, + 0x3f, 0x20, + 0x40, 0x20, + 0x41, 0x20, + 0x42, 0x20, + 0x43, 0x20, + 0x44, 0x20, + 0x45, 0x20, + 0x46, 0x20, + 0x47, 0x20, + 0x48, 0x20, + 0x49, 0x20, + 0x4a, 0x20, + 0x4b, 0x20, + 0x4c, 0x20, + 0x4d, 0x20, + 0x4e, 0x20, + 0x4f, 0x20, + 0x50, 0x20, + 0x51, 0x20, + 0x52, 0x20, + 0x53, 0x20, + 0x54, 0x20, + 0x55, 0x20, + 0x56, 0x20, + 0x57, 0x20, + 0x58, 0x20, + 0x59, 0x20, + 0x5a, 0x20, + 0x5b, 0x20, + 0x5c, 0x20, + 0x5d, 0x20, + 0x5e, 0x20, + 0x5f, 0x20, + 0x60, 0x20, + 0x61, 0x20, + 0x62, 0x20, + 0x63, 0x20, + 0x64, 0x20, + 0x65, 0x20, + 0x66, 0x20, + 0x67, 0x20, + 0x68, 0x20, + 0x69, 0x20, + 0x6a, 0x20, + 0x6b, 0x20, + 0x6c, 0x20, + 0x6d, 0x20, + 0x6e, 0x20, + 0x6f, 0x20, + 0x70, 0x20, + 0x71, 0x20, + 0x72, 0x20, + 0x73, 0x20, + 0x74, 0x20, + 0x75, 0x20, + 0x76, 0x20, + 0x77, 0x20, + 0x78, 0x20, + 0x79, 0x20, + 0x7a, 0x20, + 0x7b, 0x20, + 0x7c, 0x20, + 0x7d, 0x20, + 0x7e, 0x20, + 0x7f, 0x20, + 0x80, 0x20, + 0x81, 0x20, + 0x82, 0x20, + 0x83, 0x20, + 0x84, 0x20, + 0x85, 0x20, + 0x86, 0x20, + 0x87, 0x20, + 0x88, 0x20, + 0x89, 0x20, + 0x8a, 0x20, + 0x8b, 0x20, + 0x8c, 0x20, + 0x8d, 0x20, + 0x8e, 0x20, + 0x8f, 0x20, + 0x90, 0x20, + 0x91, 0x20, + 0x92, 0x20, + 0x93, 0x20, + 0x94, 0x20, + 0x95, 0x20, + 0x96, 0x20, + 0x97, 0x20, + 0x98, 0x20, + 0x99, 0x20, + 0x9a, 0x20, + 0x9b, 0x20, + 0x9c, 0x20, + 0x9d, 0x20, + 0x9e, 0x20, + 0x9f, 0x20, + 0xa0, 0x20, + 0xa1, 0x20, + 0xa2, 0x20, + 0xa3, 0x20, + 0xa4, 0x20, + 0xa5, 0x20, + 0xa6, 0x20, + 0xa7, 0x20, + 0xa8, 0x20, + 0xa9, 0x20, + 0xaa, 0x20, + 0xab, 0x20, + 0xac, 0x20, + 0xad, 0x20, + 0xae, 0x20, + 0xaf, 0x20, + 0xb0, 0x20, + 0xb1, 0x20, + 0xb2, 0x20, + 0xb3, 0x20, + 0xb4, 0x20, + 0xb5, 0x20, + 0xb6, 0x20, + 0xb7, 0x20, + 0xb8, 0x20, + 0xb9, 0x20, + 0xba, 0x20, + 0xbb, 0x20, + 0xbc, 0x20, + 0xbd, 0x20, + 0xbe, 0x20, + 0xbf, 0x20, + 0xc0, 0x20, + 0xc1, 0x20, + 0xc2, 0x20, + 0xc3, 0x20, + 0xc4, 0x20, + 0xc5, 0x20, + 0xc6, 0x20, + 0xc7, 0x20, + 0xc8, 0x20, + 0xc9, 0x20, + 0xca, 0x20, + 0xcb, 0x20, + 0xcc, 0x20, + 0xcd, 0x20, + 0xce, 0x20, + 0xcf, 0x20, + 0xd0, 0x20, + 0xd1, 0x20, + 0xd2, 0x20, + 0xd3, 0x20, + 0xd4, 0x20, + 0xd5, 0x20, + 0xd6, 0x20, + 0xd7, 0x20, + 0xd8, 0x20, + 0xd9, 0x20, + 0xda, 0x20, + 0xdb, 0x20, + 0xdc, 0x20, + 0xdd, 0x20, + 0xde, 0x20, + 0xdf, 0x20, + 0xe0, 0x20, + 0xe1, 0x20, + 0xe2, 0x20, + 0xe3, 0x20, + 0xe4, 0x20, + 0xe5, 0x20, + 0xe6, 0x20, + 0xe7, 0x20, + 0xe8, 0x20, + 0xe9, 0x20, + 0xea, 0x20, + 0xeb, 0x20, + 0xec, 0x20, + 0xed, 0x20, + 0xee, 0x20, + 0xef, 0x20, + 0xf0, 0x20, + 0xf1, 0x20, + 0xf2, 0x20, + 0xf3, 0x20, + 0xf4, 0x20, + 0xf5, 0x20, + 0xf6, 0x20, + 0xf7, 0x20, + 0xf8, 0x20, + 0xf9, 0x20, + 0xfa, 0x20, + 0xfb, 0x20, + 0xfc, 0x20, + 0xfd, 0x20, + 0xfe, 0x20, + 0xff, 0x20, + 0x00, 0x21, + 0x01, 0x21, + 0x02, 0x21, + 0x03, 0x21, + 0x04, 0x21, + 0x05, 0x21, + 0x06, 0x21, + 0x07, 0x21, + 0x08, 0x21, + 0x09, 0x21, + 0x0a, 0x21, + 0x0b, 0x21, + 0x0c, 0x21, + 0x0d, 0x21, + 0x0e, 0x21, + 0x0f, 0x21, + 0x10, 0x21, + 0x11, 0x21, + 0x12, 0x21, + 0x13, 0x21, + 0x14, 0x21, + 0x15, 0x21, + 0x16, 0x21, + 0x17, 0x21, + 0x18, 0x21, + 0x19, 0x21, + 0x1a, 0x21, + 0x1b, 0x21, + 0x1c, 0x21, + 0x1d, 0x21, + 0x1e, 0x21, + 0x1f, 0x21, + 0x20, 0x21, + 0x21, 0x21, + 0x22, 0x21, + 0x23, 0x21, + 0x24, 0x21, + 0x25, 0x21, + 0x26, 0x21, + 0x27, 0x21, + 0x28, 0x21, + 0x29, 0x21, + 0x2a, 0x21, + 0x2b, 0x21, + 0x2c, 0x21, + 0x2d, 0x21, + 0x2e, 0x21, + 0x2f, 0x21, + 0x30, 0x21, + 0x31, 0x21, + 0x32, 0x21, + 0x33, 0x21, + 0x34, 0x21, + 0x35, 0x21, + 0x36, 0x21, + 0x37, 0x21, + 0x38, 0x21, + 0x39, 0x21, + 0x3a, 0x21, + 0x3b, 0x21, + 0x3c, 0x21, + 0x3d, 0x21, + 0x3e, 0x21, + 0x3f, 0x21, + 0x40, 0x21, + 0x41, 0x21, + 0x42, 0x21, + 0x43, 0x21, + 0x44, 0x21, + 0x45, 0x21, + 0x46, 0x21, + 0x47, 0x21, + 0x48, 0x21, + 0x49, 0x21, + 0x4a, 0x21, + 0x4b, 0x21, + 0x4c, 0x21, + 0x4d, 0x21, + 0x32, 0x21, + 0x4f, 0x21, + 0x50, 0x21, + 0x51, 0x21, + 0x52, 0x21, + 0x53, 0x21, + 0x54, 0x21, + 0x55, 0x21, + 0x56, 0x21, + 0x57, 0x21, + 0x58, 0x21, + 0x59, 0x21, + 0x5a, 0x21, + 0x5b, 0x21, + 0x5c, 0x21, + 0x5d, 0x21, + 0x5e, 0x21, + 0x5f, 0x21, + 0x60, 0x21, + 0x61, 0x21, + 0x62, 0x21, + 0x63, 0x21, + 0x64, 0x21, + 0x65, 0x21, + 0x66, 0x21, + 0x67, 0x21, + 0x68, 0x21, + 0x69, 0x21, + 0x6a, 0x21, + 0x6b, 0x21, + 0x6c, 0x21, + 0x6d, 0x21, + 0x6e, 0x21, + 0x6f, 0x21, + 0x60, 0x21, + 0x61, 0x21, + 0x62, 0x21, + 0x63, 0x21, + 0x64, 0x21, + 0x65, 0x21, + 0x66, 0x21, + 0x67, 0x21, + 0x68, 0x21, + 0x69, 0x21, + 0x6a, 0x21, + 0x6b, 0x21, + 0x6c, 0x21, + 0x6d, 0x21, + 0x6e, 0x21, + 0x6f, 0x21, + 0x80, 0x21, + 0x81, 0x21, + 0x82, 0x21, + 0x83, 0x21, + 0x83, 0x21, + 0xff, 0xff, + 0x4b, 0x03, + 0xb6, 0x24, + 0xb7, 0x24, + 0xb8, 0x24, + 0xb9, 0x24, + 0xba, 0x24, + 0xbb, 0x24, + 0xbc, 0x24, + 0xbd, 0x24, + 0xbe, 0x24, + 0xbf, 0x24, + 0xc0, 0x24, + 0xc1, 0x24, + 0xc2, 0x24, + 0xc3, 0x24, + 0xc4, 0x24, + 0xc5, 0x24, + 0xc6, 0x24, + 0xc7, 0x24, + 0xc8, 0x24, + 0xc9, 0x24, + 0xca, 0x24, + 0xcb, 0x24, + 0xcc, 0x24, + 0xcd, 0x24, + 0xce, 0x24, + 0xcf, 0x24, + 0xff, 0xff, + 0x46, 0x07, + 0x00, 0x2c, + 0x01, 0x2c, + 0x02, 0x2c, + 0x03, 0x2c, + 0x04, 0x2c, + 0x05, 0x2c, + 0x06, 0x2c, + 0x07, 0x2c, + 0x08, 0x2c, + 0x09, 0x2c, + 0x0a, 0x2c, + 0x0b, 0x2c, + 0x0c, 0x2c, + 0x0d, 0x2c, + 0x0e, 0x2c, + 0x0f, 0x2c, + 0x10, 0x2c, + 0x11, 0x2c, + 0x12, 0x2c, + 0x13, 0x2c, + 0x14, 0x2c, + 0x15, 0x2c, + 0x16, 0x2c, + 0x17, 0x2c, + 0x18, 0x2c, + 0x19, 0x2c, + 0x1a, 0x2c, + 0x1b, 0x2c, + 0x1c, 0x2c, + 0x1d, 0x2c, + 0x1e, 0x2c, + 0x1f, 0x2c, + 0x20, 0x2c, + 0x21, 0x2c, + 0x22, 0x2c, + 0x23, 0x2c, + 0x24, 0x2c, + 0x25, 0x2c, + 0x26, 0x2c, + 0x27, 0x2c, + 0x28, 0x2c, + 0x29, 0x2c, + 0x2a, 0x2c, + 0x2b, 0x2c, + 0x2c, 0x2c, + 0x2d, 0x2c, + 0x2e, 0x2c, + 0x5f, 0x2c, + 0x60, 0x2c, + 0x60, 0x2c, + 0x62, 0x2c, + 0x63, 0x2c, + 0x64, 0x2c, + 0x65, 0x2c, + 0x66, 0x2c, + 0x67, 0x2c, + 0x67, 0x2c, + 0x69, 0x2c, + 0x69, 0x2c, + 0x6b, 0x2c, + 0x6b, 0x2c, + 0x6d, 0x2c, + 0x6e, 0x2c, + 0x6f, 0x2c, + 0x70, 0x2c, + 0x71, 0x2c, + 0x72, 0x2c, + 0x73, 0x2c, + 0x74, 0x2c, + 0x75, 0x2c, + 0x75, 0x2c, + 0x77, 0x2c, + 0x78, 0x2c, + 0x79, 0x2c, + 0x7a, 0x2c, + 0x7b, 0x2c, + 0x7c, 0x2c, + 0x7d, 0x2c, + 0x7e, 0x2c, + 0x7f, 0x2c, + 0x80, 0x2c, + 0x80, 0x2c, + 0x82, 0x2c, + 0x82, 0x2c, + 0x84, 0x2c, + 0x84, 0x2c, + 0x86, 0x2c, + 0x86, 0x2c, + 0x88, 0x2c, + 0x88, 0x2c, + 0x8a, 0x2c, + 0x8a, 0x2c, + 0x8c, 0x2c, + 0x8c, 0x2c, + 0x8e, 0x2c, + 0x8e, 0x2c, + 0x90, 0x2c, + 0x90, 0x2c, + 0x92, 0x2c, + 0x92, 0x2c, + 0x94, 0x2c, + 0x94, 0x2c, + 0x96, 0x2c, + 0x96, 0x2c, + 0x98, 0x2c, + 0x98, 0x2c, + 0x9a, 0x2c, + 0x9a, 0x2c, + 0x9c, 0x2c, + 0x9c, 0x2c, + 0x9e, 0x2c, + 0x9e, 0x2c, + 0xa0, 0x2c, + 0xa0, 0x2c, + 0xa2, 0x2c, + 0xa2, 0x2c, + 0xa4, 0x2c, + 0xa4, 0x2c, + 0xa6, 0x2c, + 0xa6, 0x2c, + 0xa8, 0x2c, + 0xa8, 0x2c, + 0xaa, 0x2c, + 0xaa, 0x2c, + 0xac, 0x2c, + 0xac, 0x2c, + 0xae, 0x2c, + 0xae, 0x2c, + 0xb0, 0x2c, + 0xb0, 0x2c, + 0xb2, 0x2c, + 0xb2, 0x2c, + 0xb4, 0x2c, + 0xb4, 0x2c, + 0xb6, 0x2c, + 0xb6, 0x2c, + 0xb8, 0x2c, + 0xb8, 0x2c, + 0xba, 0x2c, + 0xba, 0x2c, + 0xbc, 0x2c, + 0xbc, 0x2c, + 0xbe, 0x2c, + 0xbe, 0x2c, + 0xc0, 0x2c, + 0xc0, 0x2c, + 0xc2, 0x2c, + 0xc2, 0x2c, + 0xc4, 0x2c, + 0xc4, 0x2c, + 0xc6, 0x2c, + 0xc6, 0x2c, + 0xc8, 0x2c, + 0xc8, 0x2c, + 0xca, 0x2c, + 0xca, 0x2c, + 0xcc, 0x2c, + 0xcc, 0x2c, + 0xce, 0x2c, + 0xce, 0x2c, + 0xd0, 0x2c, + 0xd0, 0x2c, + 0xd2, 0x2c, + 0xd2, 0x2c, + 0xd4, 0x2c, + 0xd4, 0x2c, + 0xd6, 0x2c, + 0xd6, 0x2c, + 0xd8, 0x2c, + 0xd8, 0x2c, + 0xda, 0x2c, + 0xda, 0x2c, + 0xdc, 0x2c, + 0xdc, 0x2c, + 0xde, 0x2c, + 0xde, 0x2c, + 0xe0, 0x2c, + 0xe0, 0x2c, + 0xe2, 0x2c, + 0xe2, 0x2c, + 0xe4, 0x2c, + 0xe5, 0x2c, + 0xe6, 0x2c, + 0xe7, 0x2c, + 0xe8, 0x2c, + 0xe9, 0x2c, + 0xea, 0x2c, + 0xeb, 0x2c, + 0xec, 0x2c, + 0xed, 0x2c, + 0xee, 0x2c, + 0xef, 0x2c, + 0xf0, 0x2c, + 0xf1, 0x2c, + 0xf2, 0x2c, + 0xf3, 0x2c, + 0xf4, 0x2c, + 0xf5, 0x2c, + 0xf6, 0x2c, + 0xf7, 0x2c, + 0xf8, 0x2c, + 0xf9, 0x2c, + 0xfa, 0x2c, + 0xfb, 0x2c, + 0xfc, 0x2c, + 0xfd, 0x2c, + 0xfe, 0x2c, + 0xff, 0x2c, + 0xa0, 0x10, + 0xa1, 0x10, + 0xa2, 0x10, + 0xa3, 0x10, + 0xa4, 0x10, + 0xa5, 0x10, + 0xa6, 0x10, + 0xa7, 0x10, + 0xa8, 0x10, + 0xa9, 0x10, + 0xaa, 0x10, + 0xab, 0x10, + 0xac, 0x10, + 0xad, 0x10, + 0xae, 0x10, + 0xaf, 0x10, + 0xb0, 0x10, + 0xb1, 0x10, + 0xb2, 0x10, + 0xb3, 0x10, + 0xb4, 0x10, + 0xb5, 0x10, + 0xb6, 0x10, + 0xb7, 0x10, + 0xb8, 0x10, + 0xb9, 0x10, + 0xba, 0x10, + 0xbb, 0x10, + 0xbc, 0x10, + 0xbd, 0x10, + 0xbe, 0x10, + 0xbf, 0x10, + 0xc0, 0x10, + 0xc1, 0x10, + 0xc2, 0x10, + 0xc3, 0x10, + 0xc4, 0x10, + 0xc5, 0x10, + 0xff, 0xff, + 0x1b, 0xd2, + 0x21, 0xff, + 0x22, 0xff, + 0x23, 0xff, + 0x24, 0xff, + 0x25, 0xff, + 0x26, 0xff, + 0x27, 0xff, + 0x28, 0xff, + 0x29, 0xff, + 0x2a, 0xff, + 0x2b, 0xff, + 0x2c, 0xff, + 0x2d, 0xff, + 0x2e, 0xff, + 0x2f, 0xff, + 0x30, 0xff, + 0x31, 0xff, + 0x32, 0xff, + 0x33, 0xff, + 0x34, 0xff, + 0x35, 0xff, + 0x36, 0xff, + 0x37, 0xff, + 0x38, 0xff, + 0x39, 0xff, + 0x3a, 0xff, + 0x5b, 0xff, + 0x5c, 0xff, + 0x5d, 0xff, + 0x5e, 0xff, + 0x5f, 0xff, + 0x60, 0xff, + 0x61, 0xff, + 0x62, 0xff, + 0x63, 0xff, + 0x64, 0xff, + 0x65, 0xff, + 0x66, 0xff, + 0x67, 0xff, + 0x68, 0xff, + 0x69, 0xff, + 0x6a, 0xff, + 0x6b, 0xff, + 0x6c, 0xff, + 0x6d, 0xff, + 0x6e, 0xff, + 0x6f, 0xff, + 0x70, 0xff, + 0x71, 0xff, + 0x72, 0xff, + 0x73, 0xff, + 0x74, 0xff, + 0x75, 0xff, + 0x76, 0xff, + 0x77, 0xff, + 0x78, 0xff, + 0x79, 0xff, + 0x7a, 0xff, + 0x7b, 0xff, + 0x7c, 0xff, + 0x7d, 0xff, + 0x7e, 0xff, + 0x7f, 0xff, + 0x80, 0xff, + 0x81, 0xff, + 0x82, 0xff, + 0x83, 0xff, + 0x84, 0xff, + 0x85, 0xff, + 0x86, 0xff, + 0x87, 0xff, + 0x88, 0xff, + 0x89, 0xff, + 0x8a, 0xff, + 0x8b, 0xff, + 0x8c, 0xff, + 0x8d, 0xff, + 0x8e, 0xff, + 0x8f, 0xff, + 0x90, 0xff, + 0x91, 0xff, + 0x92, 0xff, + 0x93, 0xff, + 0x94, 0xff, + 0x95, 0xff, + 0x96, 0xff, + 0x97, 0xff, + 0x98, 0xff, + 0x99, 0xff, + 0x9a, 0xff, + 0x9b, 0xff, + 0x9c, 0xff, + 0x9d, 0xff, + 0x9e, 0xff, + 0x9f, 0xff, + 0xa0, 0xff, + 0xa1, 0xff, + 0xa2, 0xff, + 0xa3, 0xff, + 0xa4, 0xff, + 0xa5, 0xff, + 0xa6, 0xff, + 0xa7, 0xff, + 0xa8, 0xff, + 0xa9, 0xff, + 0xaa, 0xff, + 0xab, 0xff, + 0xac, 0xff, + 0xad, 0xff, + 0xae, 0xff, + 0xaf, 0xff, + 0xb0, 0xff, + 0xb1, 0xff, + 0xb2, 0xff, + 0xb3, 0xff, + 0xb4, 0xff, + 0xb5, 0xff, + 0xb6, 0xff, + 0xb7, 0xff, + 0xb8, 0xff, + 0xb9, 0xff, + 0xba, 0xff, + 0xbb, 0xff, + 0xbc, 0xff, + 0xbd, 0xff, + 0xbe, 0xff, + 0xbf, 0xff, + 0xc0, 0xff, + 0xc1, 0xff, + 0xc2, 0xff, + 0xc3, 0xff, + 0xc4, 0xff, + 0xc5, 0xff, + 0xc6, 0xff, + 0xc7, 0xff, + 0xc8, 0xff, + 0xc9, 0xff, + 0xca, 0xff, + 0xcb, 0xff, + 0xcc, 0xff, + 0xcd, 0xff, + 0xce, 0xff, + 0xcf, 0xff, + 0xd0, 0xff, + 0xd1, 0xff, + 0xd2, 0xff, + 0xd3, 0xff, + 0xd4, 0xff, + 0xd5, 0xff, + 0xd6, 0xff, + 0xd7, 0xff, + 0xd8, 0xff, + 0xd9, 0xff, + 0xda, 0xff, + 0xdb, 0xff, + 0xdc, 0xff, + 0xdd, 0xff, + 0xde, 0xff, + 0xdf, 0xff, + 0xe0, 0xff, + 0xe1, 0xff, + 0xe2, 0xff, + 0xe3, 0xff, + 0xe4, 0xff, + 0xe5, 0xff, + 0xe6, 0xff, + 0xe7, 0xff, + 0xe8, 0xff, + 0xe9, 0xff, + 0xea, 0xff, + 0xeb, 0xff, + 0xec, 0xff, + 0xed, 0xff, + 0xee, 0xff, + 0xef, 0xff, + 0xf0, 0xff, + 0xf1, 0xff, + 0xf2, 0xff, + 0xf3, 0xff, + 0xf4, 0xff, + 0xf5, 0xff, + 0xf6, 0xff, + 0xf7, 0xff, + 0xf8, 0xff, + 0xf9, 0xff, + 0xfa, 0xff, + 0xfb, 0xff, + 0xfc, 0xff, + 0xfd, 0xff, + 0xfe, 0xff, + 0xff, 0xff +}; + +#endif + +/** + * @} + */ + + Index: uspace/app/sysinfo/sysinfo.c =================================================================== --- uspace/app/sysinfo/sysinfo.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/app/sysinfo/sysinfo.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -37,51 +37,24 @@ #include #include +#include #include -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,15 +62,13 @@ { 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,13 +76,11 @@ 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,35 +88,115 @@ 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 \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; } Index: uspace/drv/bus/usb/uhci/transfer_list.c =================================================================== --- uspace/drv/bus/usb/uhci/transfer_list.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/drv/bus/usb/uhci/transfer_list.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -110,6 +110,6 @@ 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,7 +139,7 @@ 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,6 +205,6 @@ 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,6 +228,6 @@ 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); } Index: uspace/drv/bus/usb/uhci/uhci_batch.c =================================================================== --- uspace/drv/bus/usb/uhci/uhci_batch.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/drv/bus/usb/uhci/uhci_batch.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -174,7 +174,7 @@ 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]); Index: uspace/drv/char/ps2mouse/ps2mouse.c =================================================================== --- uspace/drv/char/ps2mouse/ps2mouse.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/drv/char/ps2mouse/ps2mouse.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -80,5 +80,5 @@ } \ 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; \ Index: uspace/drv/infrastructure/root/root.c =================================================================== --- uspace/drv/infrastructure/root/root.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/drv/infrastructure/root/root.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -158,6 +158,9 @@ 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,4 +172,5 @@ if (fun == NULL) { ddf_msg(LVL_ERROR, "Error creating function %s", name); + free(match_id); return ENOMEM; } @@ -176,4 +180,5 @@ ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s", name); + free(match_id); ddf_fun_destroy(fun); return rc; @@ -208,5 +213,5 @@ * vital for the system. */ - add_virtual_root_fun(dev); + (void) add_virtual_root_fun(dev); /* Register root device's children. */ Index: uspace/lib/c/arch/ia64/include/ddi.h =================================================================== --- uspace/lib/c/arch/ia64/include/ddi.h (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/lib/c/arch/ia64/include/ddi.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -62,4 +62,5 @@ asm volatile ("mf\n" ::: "memory"); + asm volatile ("mf.a\n" ::: "memory"); } @@ -76,4 +77,5 @@ asm volatile ("mf\n" ::: "memory"); + asm volatile ("mf.a\n" ::: "memory"); } @@ -90,4 +92,5 @@ asm volatile ("mf\n" ::: "memory"); + asm volatile ("mf.a\n" ::: "memory"); } @@ -106,4 +109,6 @@ v = *port; } + + asm volatile ("mf.a\n" ::: "memory"); return v; @@ -125,4 +130,6 @@ } + asm volatile ("mf.a\n" ::: "memory"); + return v; } @@ -134,5 +141,5 @@ asm volatile ("mf\n" ::: "memory"); - if (port < (ioport32_t *) port) { + if (port < (ioport32_t *) IO_SPACE_BOUNDARY) { uintptr_t prt = (uintptr_t) port; @@ -143,4 +150,6 @@ } + asm volatile ("mf.a\n" ::: "memory"); + return v; } Index: uspace/lib/c/generic/str.c =================================================================== --- uspace/lib/c/generic/str.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/lib/c/generic/str.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -259,4 +259,41 @@ 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)); } Index: uspace/lib/c/generic/sysinfo.c =================================================================== --- uspace/lib/c/generic/sysinfo.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/lib/c/generic/sysinfo.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -40,4 +40,68 @@ #include +/** 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,6 +134,6 @@ /** 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,6 +149,6 @@ /** 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,4 +198,67 @@ } +/** 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; +} + /** @} */ Index: uspace/lib/c/include/str.h =================================================================== --- uspace/lib/c/include/str.h (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/lib/c/include/str.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -60,4 +60,7 @@ 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); Index: uspace/lib/c/include/sysinfo.h =================================================================== --- uspace/lib/c/include/sysinfo.h (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/lib/c/include/sysinfo.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -40,7 +40,9 @@ #include +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 Index: uspace/srv/fs/exfat/exfat_bitmap.c =================================================================== --- uspace/srv/fs/exfat/exfat_bitmap.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/srv/fs/exfat/exfat_bitmap.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -48,5 +48,5 @@ -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,5 +89,5 @@ } -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,5 +124,5 @@ } -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,5 +160,5 @@ } -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,8 +168,8 @@ 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,5 +180,5 @@ } -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,5 +188,5 @@ 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,5 +196,5 @@ } -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,8 +204,8 @@ 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,9 +217,9 @@ -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,7 +228,7 @@ 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,5 +240,5 @@ -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,9 +247,9 @@ 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; Index: uspace/srv/fs/exfat/exfat_bitmap.h =================================================================== --- uspace/srv/fs/exfat/exfat_bitmap.h (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/srv/fs/exfat/exfat_bitmap.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -42,20 +42,20 @@ 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); Index: uspace/srv/fs/exfat/exfat_dentry.c =================================================================== --- uspace/srv/fs/exfat/exfat_dentry.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/srv/fs/exfat/exfat_dentry.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -130,5 +130,5 @@ } -size_t utf16_length(const uint16_t *wstr) +size_t exfat_utf16_length(const uint16_t *wstr) { size_t len = 0; Index: uspace/srv/fs/exfat/exfat_dentry.h =================================================================== --- uspace/srv/fs/exfat/exfat_dentry.h (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/srv/fs/exfat/exfat_dentry.h (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -160,5 +160,5 @@ extern bool exfat_valid_name(const char *); -extern size_t utf16_length(const uint16_t *); +extern size_t exfat_utf16_length(const uint16_t *); Index: uspace/srv/fs/exfat/exfat_directory.c =================================================================== --- uspace/srv/fs/exfat/exfat_directory.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/srv/fs/exfat/exfat_directory.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -371,5 +371,5 @@ 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)); Index: uspace/srv/fs/exfat/exfat_fat.c =================================================================== --- uspace/srv/fs/exfat/exfat_fat.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/srv/fs/exfat/exfat_fat.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -314,5 +314,5 @@ 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,5 +325,5 @@ 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,5 +346,5 @@ /* 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,5 +378,5 @@ 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; Index: uspace/srv/fs/exfat/exfat_ops.c =================================================================== --- uspace/srv/fs/exfat/exfat_ops.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ uspace/srv/fs/exfat/exfat_ops.c (revision 5608deba7eb0e64a3c351320a342d3e00f43eecb) @@ -405,5 +405,5 @@ if (!nodep->fragmented) { - rc = bitmap_append_clusters(bs, nodep, clusters); + rc = exfat_bitmap_append_clusters(bs, nodep, clusters); if (rc != ENOSPC) return rc; @@ -411,5 +411,5 @@ 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,5 +457,5 @@ 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,5 +704,5 @@ 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,9 +758,5 @@ fibril_mutex_unlock(&parentp->idx->lock); - if (rc != EOK) - return rc; - fibril_mutex_lock(&childp->idx->lock); - childp->idx->pfc = parentp->firstc; @@ -1463,5 +1459,8 @@ } - (void) exfat_node_put(fn); + int rc2 = exfat_node_put(fn); + if (rc == EOK && rc2 != EOK) + rc = rc2; + return rc; } Index: pace/srv/hid/input/include/sun.h =================================================================== --- uspace/srv/hid/input/include/sun.h (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ (revision ) @@ -1,47 +1,0 @@ -/* - * Copyright (c) 2009 Martin Decky - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup kbdgen generic - * @brief Sun keyboard virtual port driver. - * @ingroup kbd - * @{ - */ -/** @file - */ - -#ifndef KBD_SUN_H_ -#define KBD_SUN_H_ - -extern int ns16550_port_init(void); -extern int z8530_port_init(void); - -#endif - -/** - * @} - */ Index: pace/srv/hid/input/port/dummy.c =================================================================== --- uspace/srv/hid/input/port/dummy.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ (revision ) @@ -1,59 +1,0 @@ -/* - * Copyright (c) 2009 Jiri Svoboda - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup kbd_port - * @brief Dummy keyboard port driver. - * @ingroup kbd - * @{ - */ -/** @file - */ - -#include -#include - -int kbd_port_init(void) -{ - return 0; -} - -void kbd_port_yield(void) -{ -} - -void kbd_port_reclaim(void) -{ -} - -void kbd_port_write(uint8_t data) -{ - (void) data; -} - -/** @} -*/ Index: pace/srv/hid/input/port/sgcn.c =================================================================== --- uspace/srv/hid/input/port/sgcn.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ (revision ) @@ -1,188 +1,0 @@ -/* - * Copyright (c) 2008 Pavel Rimsky - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup kbd_port - * @ingroup kbd - * @{ - */ -/** @file - * @brief SGCN (Serengeti Console) keyboard port driver. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define POLL_INTERVAL 10000 - -/** - * SGCN buffer header. It is placed at the very beginning of the SGCN - * buffer. - */ -typedef struct { - /** hard-wired to "CON" */ - char magic[4]; - - /** we don't need this */ - char unused[8]; - - /** offset within the SGCN buffer of the input buffer start */ - uint32_t in_begin; - - /** offset within the SGCN buffer of the input buffer end */ - uint32_t in_end; - - /** offset within the SGCN buffer of the input buffer read pointer */ - uint32_t in_rdptr; - - /** offset within the SGCN buffer of the input buffer write pointer */ - uint32_t in_wrptr; -} __attribute__ ((packed)) sgcn_buffer_header_t; - -/* - * Returns a pointer to the object of a given type which is placed at the given - * offset from the console buffer beginning. - */ -#define SGCN_BUFFER(type, offset) \ - ((type *) (sram_virt_addr + sram_buffer_offset + (offset))) - -/** Returns a pointer to the console buffer header. */ -#define SGCN_BUFFER_HEADER (SGCN_BUFFER(sgcn_buffer_header_t, 0)) - -/** - * Virtual address mapped to SRAM. - */ -static uintptr_t sram_virt_addr; - -/** - * SGCN buffer offset within SGCN. - */ -static uintptr_t sram_buffer_offset; - -/* polling thread */ -static void sgcn_thread_impl(void *arg); - -static volatile bool polling_disabled = false; - -/** - * Initializes the SGCN driver. - * Maps the physical memory (SRAM) and creates the polling thread. - */ -int kbd_port_init(void) -{ - sysarg_t sram_paddr; - if (sysinfo_get_value("sram.address.physical", &sram_paddr) != EOK) - return -1; - - sysarg_t sram_size; - if (sysinfo_get_value("sram.area.size", &sram_size) != EOK) - return -1; - - if (sysinfo_get_value("sram.buffer.offset", &sram_buffer_offset) != EOK) - sram_buffer_offset = 0; - - sram_virt_addr = (uintptr_t) as_get_mappable_page(sram_size); - - if (physmem_map((void *) sram_paddr, (void *) sram_virt_addr, - sram_size / PAGE_SIZE, AS_AREA_READ | AS_AREA_WRITE) != 0) { - printf("SGCN: uspace driver could not map physical memory."); - return -1; - } - - thread_id_t tid; - int rc = thread_create(sgcn_thread_impl, NULL, "kbd_poll", &tid); - if (rc != 0) - return rc; - - return 0; -} - -void kbd_port_yield(void) -{ - polling_disabled = true; -} - -void kbd_port_reclaim(void) -{ - polling_disabled = false; -} - -void kbd_port_write(uint8_t data) -{ - (void) data; -} - -/** - * Handler of the "key pressed" event. Reads codes of all the pressed keys from - * the buffer. - */ -static void sgcn_key_pressed(void) -{ - char c; - - uint32_t begin = SGCN_BUFFER_HEADER->in_begin; - uint32_t end = SGCN_BUFFER_HEADER->in_end; - uint32_t size = end - begin; - - volatile char *buf_ptr = (volatile char *) - SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr); - volatile uint32_t *in_wrptr_ptr = &(SGCN_BUFFER_HEADER->in_wrptr); - volatile uint32_t *in_rdptr_ptr = &(SGCN_BUFFER_HEADER->in_rdptr); - - while (*in_rdptr_ptr != *in_wrptr_ptr) { - c = *buf_ptr; - *in_rdptr_ptr = (((*in_rdptr_ptr) - begin + 1) % size) + begin; - buf_ptr = (volatile char *) - SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr); - kbd_push_scancode(c); - } -} - -/** - * Thread to poll SGCN for keypresses. - */ -static void sgcn_thread_impl(void *arg) -{ - (void) arg; - - while (1) { - if (polling_disabled == false) - sgcn_key_pressed(); - usleep(POLL_INTERVAL); - } -} - -/** @} - */ Index: pace/srv/hid/input/port/sun.c =================================================================== --- uspace/srv/hid/input/port/sun.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ (revision ) @@ -1,89 +1,0 @@ -/* - * Copyright (c) 2009 Martin Decky - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup kbd_port - * @ingroup kbd - * @{ - */ -/** @file - * @brief Sun keyboard virtual port driver. - */ - -#include -#include -#include -#include -#include -#include - -/** Sun keyboard virtual port driver. - * - * This is a virtual port driver which can use - * both ns16550_port_init and z8530_port_init - * according to the information passed from the - * kernel. This is just a temporal hack. - * - */ -int kbd_port_init(void) -{ - sysarg_t z8530; - if (sysinfo_get_value("kbd.type.z8530", &z8530) != EOK) - z8530 = false; - - sysarg_t ns16550; - if (sysinfo_get_value("kbd.type.ns16550", &ns16550) != EOK) - ns16550 = false; - - if (z8530) { - if (z8530_port_init() == 0) - return 0; - } - - if (ns16550) { - if (ns16550_port_init() == 0) - return 0; - } - - return -1; -} - -void kbd_port_yield(void) -{ -} - -void kbd_port_reclaim(void) -{ -} - -void kbd_port_write(uint8_t data) -{ - (void) data; -} - -/** @} -*/ Index: pace/srv/hid/input/port/z8530.c =================================================================== --- uspace/srv/hid/input/port/z8530.c (revision 2cc7f1601bf37a38c6fbe566c6f941f3ffef337e) +++ (revision ) @@ -1,116 +1,0 @@ -/* - * Copyright (c) 2006 Martin Decky - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup kbd_port - * @ingroup kbd - * @{ - */ -/** @file - * @brief Z8530 keyboard port driver. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define CHAN_A_STATUS 4 -#define CHAN_A_DATA 6 - -#define RR0_RCA 1 - -static irq_cmd_t z8530_cmds[] = { - { - .cmd = CMD_PIO_READ_8, - .addr = (void *) 0, /* Will be patched in run-time */ - .dstarg = 1 - }, - { - .cmd = CMD_BTEST, - .value = RR0_RCA, - .srcarg = 1, - .dstarg = 3 - }, - { - .cmd = CMD_PREDICATE, - .value = 2, - .srcarg = 3 - }, - { - .cmd = CMD_PIO_READ_8, - .addr = (void *) 0, /* Will be patched in run-time */ - .dstarg = 2 - }, - { - .cmd = CMD_ACCEPT - } -}; - -irq_code_t z8530_kbd = { - sizeof(z8530_cmds) / sizeof(irq_cmd_t), - z8530_cmds -}; - -static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call); - -int z8530_port_init(void) -{ - sysarg_t kaddr; - if (sysinfo_get_value("kbd.address.kernel", &kaddr) != EOK) - return -1; - - sysarg_t inr; - if (sysinfo_get_value("kbd.inr", &inr) != EOK) - return -1; - - z8530_cmds[0].addr = (void *) kaddr + CHAN_A_STATUS; - z8530_cmds[3].addr = (void *) kaddr + CHAN_A_DATA; - - async_set_interrupt_received(z8530_irq_handler); - register_irq(inr, device_assign_devno(), inr, &z8530_kbd); - - return 0; -} - -static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call) -{ - int scan_code = IPC_GET_ARG2(*call); - kbd_push_scancode(scan_code); - - if (irc_service) - async_msg_1(irc_phone, IRC_CLEAR_INTERRUPT, - IPC_GET_IMETHOD(*call)); -} - -/** @} - */