Changeset 14f8fd4 in mainline


Ignore:
Timestamp:
2012-03-15T22:52:33Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
bfb3d60
Parents:
43cd499 (diff), dbbba51c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Mainline changes with some extra USB fixes.

Files:
7 added
62 edited
12 moved

Legend:

Unmodified
Added
Removed

  • abi/include/syscall.h

    r43cd499 r14f8fd4  
    9292        SYS_IRQ_UNREGISTER,
    9393       
     94        SYS_SYSINFO_GET_KEYS_SIZE,
     95        SYS_SYSINFO_GET_KEYS,
    9496        SYS_SYSINFO_GET_VAL_TYPE,
    9597        SYS_SYSINFO_GET_VALUE,

  • boot/Makefile.common

    r43cd499 r14f8fd4  
    165165        $(USPACE_PATH)/app/locinfo/locinfo \
    166166        $(USPACE_PATH)/app/mkfat/mkfat \
     167        $(USPACE_PATH)/app/mkexfat/mkexfat \
    167168        $(USPACE_PATH)/app/mkmfs/mkmfs \
    168169        $(USPACE_PATH)/app/lsusb/lsusb \

  • kernel/arch/amd64/include/context.h

    r43cd499 r14f8fd4  
    3838#include <typedefs.h>
    3939
    40 /* According to ABI the stack MUST be aligned on
     40/*
     41 * According to ABI the stack MUST be aligned on
    4142 * 16-byte boundary. If it is not, the va_arg calling will
    4243 * panic sooner or later

  • kernel/arch/arm32/include/context.h

    r43cd499 r14f8fd4  
    2727 */
    2828
    29 /** @addtogroup arm32   
     29/** @addtogroup arm32
    3030 * @{
    3131 */

  • kernel/arch/ia64/include/context.h

    r43cd499 r14f8fd4  
    2727 */
    2828
    29 /** @addtogroup ia64   
     29/** @addtogroup ia64
    3030 * @{
    3131 */
    … …  
    4747 * One item is put onto the stack to support get_stack_base().
    4848 */
    49 #define SP_DELTA        (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
     49#define SP_DELTA  (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
    5050
    5151/* RSE stack starts at the bottom of memory stack, hence the division by 2. */
    52 #define context_set(c, _pc, stack, size)                                                                \
    53         do {                                                                                            \
    54                 (c)->pc = (uintptr_t) _pc;                                                              \
    55                 (c)->bsp = ((uintptr_t) stack) + ALIGN_UP((size / 2), REGISTER_STACK_ALIGNMENT);        \
    56                 (c)->ar_pfs &= PFM_MASK;                                                                \
    57                 (c)->sp = ((uintptr_t) stack) + ALIGN_UP((size / 2), STACK_ALIGNMENT) - SP_DELTA;       \
    58         } while (0);
     52#define context_set(c, _pc, stack, size) \
     53        do { \
     54                (c)->pc = (uintptr_t) _pc; \
     55                (c)->bsp = ((uintptr_t) stack) + ALIGN_UP((size / 2), REGISTER_STACK_ALIGNMENT); \
     56                (c)->ar_pfs &= PFM_MASK; \
     57                (c)->sp = ((uintptr_t) stack) + ALIGN_UP((size / 2), STACK_ALIGNMENT) - SP_DELTA; \
     58        } while (0)
    5959
    6060/*

  • kernel/arch/mips32/include/context.h

    r43cd499 r14f8fd4  
    4242 * Put one item onto the stack to support get_stack_base() and align it up.
    4343 */
    44 #define SP_DELTA  (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
     44#define SP_DELTA  (ABI_STACK_FRAME + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
    4545
    4646#ifndef __ASM__

  • kernel/arch/mips32/include/stack.h

    r43cd499 r14f8fd4  
    2727 */
    2828
    29 /** @addtogroup mips32 
     29/** @addtogroup mips32
    3030 * @{
    3131 */
    … …  
    3636#define KERN_mips32_STACK_H_
    3737
    38 #define STACK_ITEM_SIZE         4
    39 #define STACK_ALIGNMENT         8
     38#define STACK_ITEM_SIZE  4
     39#define STACK_ALIGNMENT  8
     40#define ABI_STACK_FRAME  32
    4041
    4142#endif

  • kernel/arch/mips32/src/start.S

    r43cd499 r14f8fd4  
    241241        /* $a1 contains physical address of bootinfo_t */
    242242        jal arch_pre_main
    243         nop
     243        addiu $sp, -ABI_STACK_FRAME
    244244       
    245245        j main_bsp
    … …  
    281281       
    282282        move $a1, $sp
     283        move $a0, $k0
    283284        jal exc_dispatch     /* exc_dispatch(excno, register_space) */
    284         move $a0, $k0
     285        addiu $sp, -ABI_STACK_FRAME
     286        addiu $sp, ABI_STACK_FRAME
    285287       
    286288        REGISTERS_LOAD $sp
    … …  
    323325        sw $t0, ISTATE_OFFSET_T0($sp)  /* save the 5th argument on the stack */
    324326        sw $t1, ISTATE_OFFSET_T1($sp)  /* save the 6th argument on the stack */
     327       
    325328        jal syscall_handler
    326329        sw $v0, ISTATE_OFFSET_V0($sp)  /* save the syscall number on the stack */
    … …  
    357360        move $sp, $k0
    358361       
     362        move $a0, $sp
    359363        jal tlb_refill
    360         move $a0, $sp
     364        addiu $sp, -ABI_STACK_FRAME
     365        addiu $sp, ABI_STACK_FRAME
    361366       
    362367        REGISTERS_LOAD $sp
    … …  
    366371cache_error_handler:
    367372        KERNEL_STACK_TO_K0
    368         sub $k0, ISTATE_SOFT_SIZE 
     373        sub $k0, ISTATE_SOFT_SIZE
    369374        REGISTERS_STORE_AND_EXC_RESET $k0
    370375        sw $sp, ISTATE_OFFSET_SP($k0)
    371376        move $sp, $k0
    372377       
     378        move $a0, $sp
    373379        jal cache_error
    374         move $a0, $sp
     380        addiu $sp, -ABI_STACK_FRAME
     381        addiu $sp, ABI_STACK_FRAME
    375382       
    376383        REGISTERS_LOAD $sp

  • kernel/arch/mips64/include/context.h

    r43cd499 r14f8fd4  
    4242 * Put one item onto the stack to support get_stack_base() and align it up.
    4343 */
    44 #define SP_DELTA  (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
     44#define SP_DELTA  (ABI_STACK_FRAME + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
    4545
    4646#ifndef __ASM__

  • kernel/arch/mips64/include/stack.h

    r43cd499 r14f8fd4  
    3838#define STACK_ITEM_SIZE  8
    3939#define STACK_ALIGNMENT  8
     40#define ABI_STACK_FRAME  64
    4041
    4142#endif

  • kernel/arch/mips64/src/start.S

    r43cd499 r14f8fd4  
    241241        /* $a1 contains physical address of bootinfo_t */
    242242        jal arch_pre_main
    243         nop
     243        addiu $sp, -ABI_STACK_FRAME
    244244       
    245245        j main_bsp
    … …  
    281281       
    282282        move $a1, $sp
     283        move $a0, $k0
    283284        jal exc_dispatch     /* exc_dispatch(excno, register_space) */
    284         move $a0, $k0
     285        addiu $sp, -ABI_STACK_FRAME
     286        addiu $sp, ABI_STACK_FRAME
    285287       
    286288        REGISTERS_LOAD $sp
    … …  
    323325        sw $t0, ISTATE_OFFSET_T0($sp)  /* save the 5th argument on the stack */
    324326        sw $t1, ISTATE_OFFSET_T1($sp)  /* save the 6th argument on the stack */
     327       
    325328        jal syscall_handler
    326329        sw $v0, ISTATE_OFFSET_V0($sp)  /* save the syscall number on the stack */
    … …  
    357360        move $sp, $k0
    358361       
     362        move $a0, $sp
    359363        jal tlb_refill
    360         move $a0, $sp
     364        addiu $sp, -ABI_STACK_FRAME
     365        addiu $sp, ABI_STACK_FRAME
    361366       
    362367        REGISTERS_LOAD $sp
    … …  
    366371cache_error_handler:
    367372        KERNEL_STACK_TO_K0
    368         sub $k0, ISTATE_SOFT_SIZE 
     373        sub $k0, ISTATE_SOFT_SIZE
    369374        REGISTERS_STORE_AND_EXC_RESET $k0
    370375        sw $sp, ISTATE_OFFSET_SP($k0)
    371376        move $sp, $k0
    372377       
     378        move $a0, $sp
    373379        jal cache_error
    374         move $a0, $sp
     380        addiu $sp, -ABI_STACK_FRAME
     381        addiu $sp, ABI_STACK_FRAME
    375382       
    376383        REGISTERS_LOAD $sp

  • kernel/arch/ppc32/src/ppc32.c

    r43cd499 r14f8fd4  
    173173                ofw_tree_walk_by_device_type("display", display_register, NULL);
    174174#endif
     175                /* Map OFW information into sysinfo */
     176                ofw_sysinfo_map();
    175177               
    176178                /* Initialize IRQ routing */

  • kernel/arch/sparc64/include/context.h

    r43cd499 r14f8fd4  
    2727 */
    2828
    29 /** @addtogroup sparc64 
     29/** @addtogroup sparc64
    3030 * @{
    3131 */
    … …  
    4040#include <align.h>
    4141
    42 #define SP_DELTA        (STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE)
     42#define SP_DELTA  (STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE)
    4343
    44 #define context_set(c, _pc, stack, size)                        \
    45         (c)->pc = ((uintptr_t) _pc) - 8;                        \
    46         (c)->sp = ((uintptr_t) stack) + ALIGN_UP((size),        \
    47                 STACK_ALIGNMENT) - (STACK_BIAS + SP_DELTA);     \
    48         (c)->fp = -STACK_BIAS
    49        
     44#define context_set(c, _pc, stack, size) \
     45        do { \
     46                (c)->pc = ((uintptr_t) _pc) - 8; \
     47                (c)->sp = ((uintptr_t) stack) + ALIGN_UP((size), \
     48                    STACK_ALIGNMENT) - (STACK_BIAS + SP_DELTA); \
     49                (c)->fp = -STACK_BIAS; \
     50        } while (0)
    5051
    5152/*

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

    r43cd499 r14f8fd4  
    9494{
    9595        if (config.cpu_active == 1) {
     96                /* Map OFW information into sysinfo */
     97                ofw_sysinfo_map();
     98               
    9699                /*
    97100                 * We have 2^11 different interrupt vectors.

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

    r43cd499 r14f8fd4  
    9292{
    9393        if (config.cpu_active == 1) {
     94                /* Map OFW information into sysinfo */
     95                ofw_sysinfo_map();
     96               
    9497                /*
    9598                 * We have 2^11 different interrupt vectors.

  • kernel/genarch/include/ofw/ofw_tree.h

    r43cd499 r14f8fd4  
    6767
    6868extern void ofw_tree_init(ofw_tree_node_t *);
    69 extern void ofw_tree_print(void);
     69extern void ofw_sysinfo_map(void);
    7070
    7171extern const char *ofw_tree_node_name(const ofw_tree_node_t *);

  • kernel/genarch/src/ofw/ofw_tree.c

    r43cd499 r14f8fd4  
    3838#include <genarch/ofw/ofw_tree.h>
    3939#include <mm/slab.h>
     40#include <sysinfo/sysinfo.h>
    4041#include <memstr.h>
    4142#include <str.h>
    … …  
    6566    const char *name)
    6667{
    67         size_t i;
    68        
    69         for (i = 0; i < node->properties; i++) {
     68        for (size_t i = 0; i < node->properties; i++) {
    7069                if (str_cmp(node->property[i].name, name) == 0)
    7170                        return &node->property[i];
    … …  
    104103    const char *name)
    105104{
    106         ofw_tree_node_t *cur;
    107        
    108105        /*
    109106         * Try to find the disambigued name.
    110107         */
    111         for (cur = node->child; cur; cur = cur->peer) {
     108        for (ofw_tree_node_t *cur = node->child; cur; cur = cur->peer) {
    112109                if (str_cmp(cur->da_name, name) == 0)
    113110                        return cur;
    … …  
    121118         * are not always fully-qualified.
    122119         */
    123         for (cur = node->child; cur; cur = cur->peer) {
     120        for (ofw_tree_node_t *cur = node->child; cur; cur = cur->peer) {
    124121                if (str_cmp(ofw_tree_node_name(cur), name) == 0)
    125122                        return cur;
    … …  
    141138    const char *dtype)
    142139{
    143         ofw_tree_node_t *cur;
    144        
    145         for (cur = node->child; cur; cur = cur->peer) {
     140        for (ofw_tree_node_t *cur = node->child; cur; cur = cur->peer) {
    146141                ofw_tree_property_t *prop =
    147142                    ofw_tree_getprop(cur, "device_type");
    … …  
    172167    phandle handle)
    173168{
    174         ofw_tree_node_t *cur;
    175        
    176         for (cur = root; cur; cur = cur->peer) {
     169        for (ofw_tree_node_t *cur = root; cur; cur = cur->peer) {
    177170                if (cur->node_handle == handle)
    178171                        return cur;
    179172               
    180173                if (cur->child) {
    181                         ofw_tree_node_t *node
    182                             = ofw_tree_find_node_by_handle(cur->child, handle);
     174                        ofw_tree_node_t *node =
     175                            ofw_tree_find_node_by_handle(cur->child, handle);
    183176                        if (node)
    184177                                return node;
    … …  
    201194    const char *dtype)
    202195{
    203         ofw_tree_node_t *cur;
    204        
    205         for (cur = node->peer; cur; cur = cur->peer) {
     196        for (ofw_tree_node_t *cur = node->peer; cur; cur = cur->peer) {
    206197                ofw_tree_property_t *prop =
    207198                    ofw_tree_getprop(cur, "device_type");
    … …  
    229220    const char *name)
    230221{
    231         ofw_tree_node_t *cur;
    232        
    233         for (cur = node->peer; cur; cur = cur->peer) {
    234                 ofw_tree_property_t *prop
    235                     = ofw_tree_getprop(cur, "name");
     222        for (ofw_tree_node_t *cur = node->peer; cur; cur = cur->peer) {
     223                ofw_tree_property_t *prop =
     224                    ofw_tree_getprop(cur, "name");
    236225               
    237226                if ((!prop) || (!prop->value))
    … …  
    259248       
    260249        ofw_tree_node_t *node = ofw_root;
    261         size_t i;
    262250        size_t j;
    263251       
    264         for (i = 1; (i < str_size(path)) && (node); i = j + 1) {
     252        for (size_t i = 1; (i < str_size(path)) && (node); i = j + 1) {
    265253                for (j = i; (j < str_size(path)) && (path[j] != '/'); j++);
    266254               
    … …  
    294282    const char *dtype, ofw_tree_walker_t walker, void *arg)
    295283{
    296         ofw_tree_node_t *cur;
    297        
    298         for (cur = node; cur; cur = cur->peer) {
     284        for (ofw_tree_node_t *cur = node; cur; cur = cur->peer) {
    299285                ofw_tree_property_t *prop =
    300286                    ofw_tree_getprop(cur, "device_type");
    … …  
    334320}
    335321
    336 /** Print OpenFirmware device subtree rooted in a node.
     322/** Get OpenFirmware node properties.
     323 *
     324 * @param item    Sysinfo item (unused).
     325 * @param size    Size of the returned data.
     326 * @param dry_run Do not get the data, just calculate the size.
     327 * @param data    OpenFirmware node.
     328 *
     329 * @return Data containing a serialized dump of all node
     330 *         properties. If the return value is not NULL, it
     331 *         should be freed in the context of the sysinfo request.
     332 *
     333 */
     334static void *ofw_sysinfo_properties(struct sysinfo_item *item, size_t *size,
     335    bool dry_run, void *data)
     336{
     337        ofw_tree_node_t *node = (ofw_tree_node_t *) data;
     338       
     339        /* Compute serialized data size */
     340        *size = 0;
     341        for (size_t i = 0; i < node->properties; i++)
     342                *size += str_size(node->property[i].name) + 1 +
     343                    sizeof(node->property[i].size) + node->property[i].size;
     344       
     345        if (dry_run)
     346                return NULL;
     347       
     348        void *dump = malloc(*size, FRAME_ATOMIC);
     349        if (dump == NULL) {
     350                *size = 0;
     351                return NULL;
     352        }
     353       
     354        /* Serialize the data */
     355        size_t pos = 0;
     356        for (size_t i = 0; i < node->properties; i++) {
     357                /* Property name */
     358                str_cpy(dump + pos, *size - pos, node->property[i].name);
     359                pos += str_size(node->property[i].name) + 1;
     360               
     361                /* Value size */
     362                memcpy(dump + pos, &node->property[i].size,
     363                    sizeof(node->property[i].size));
     364                pos += sizeof(node->property[i].size);
     365               
     366                /* Value */
     367                memcpy(dump + pos, node->property[i].value,
     368                    node->property[i].size);
     369                pos += node->property[i].size;
     370        }
     371       
     372        return ((void *) dump);
     373}
     374
     375/** Map OpenFirmware device subtree rooted in a node into sysinfo.
    337376 *
    338377 * Child nodes are processed recursively and peer nodes are processed
    … …  
    343382 *
    344383 */
    345 static void ofw_tree_node_print(ofw_tree_node_t *node, const char *path)
     384static void ofw_tree_node_sysinfo(ofw_tree_node_t *node, const char *path)
    346385{
    347386        char *cur_path = (char *) malloc(PATH_MAX_LEN, 0);
    348         ofw_tree_node_t *cur;
    349        
    350         for (cur = node; cur; cur = cur->peer) {
    351                 if ((cur->parent) && (path)) {
    352                         snprintf(cur_path, PATH_MAX_LEN, "%s/%s", path, cur->da_name);
    353                         printf("%s\n", cur_path);
    354                 } else {
    355                         snprintf(cur_path, PATH_MAX_LEN, "%s", cur->da_name);
    356                         printf("/\n");
    357                 }
     387       
     388        for (ofw_tree_node_t *cur = node; cur; cur = cur->peer) {
     389                if ((cur->parent) && (path))
     390                        snprintf(cur_path, PATH_MAX_LEN, "%s.%s", path, cur->da_name);
     391                else
     392                        snprintf(cur_path, PATH_MAX_LEN, "firmware.%s", cur->da_name);
     393               
     394                sysinfo_set_item_gen_data(cur_path, NULL, ofw_sysinfo_properties,
     395                    (void *) cur);
    358396               
    359397                if (cur->child)
    360                         ofw_tree_node_print(cur->child, cur_path);
     398                        ofw_tree_node_sysinfo(cur->child, cur_path);
    361399        }
    362400       
    … …  
    364402}
    365403
    366 /** Print the structure of the OpenFirmware device tree. */
    367 void ofw_tree_print(void)
    368 {
    369         ofw_tree_node_print(ofw_root, NULL);
     404/** Map the OpenFirmware device tree into sysinfo. */
     405void ofw_sysinfo_map(void)
     406{
     407        ofw_tree_node_sysinfo(ofw_root, NULL);
    370408}
    371409

  • kernel/generic/include/context.h

    r43cd499 r14f8fd4  
    4141
    4242#define context_set_generic(ctx, _pc, stack, size) \
    43         (ctx)->pc = (uintptr_t) (_pc); \
    44         (ctx)->sp = ((uintptr_t) (stack)) + (size) - SP_DELTA;
     43        do { \
     44                (ctx)->pc = (uintptr_t) (_pc); \
     45                (ctx)->sp = ((uintptr_t) (stack)) + (size) - SP_DELTA; \
     46        } while (0)
    4547
    4648extern int context_save_arch(context_t *ctx) __attribute__((returns_twice));

  • kernel/generic/include/sysinfo/sysinfo.h

    r43cd499 r14f8fd4  
    11/*
    22 * Copyright (c) 2006 Jakub Vana
     3 * Copyright (c) 2012 Martin Decky
    34 * All rights reserved.
    45 *
    … …  
    5455struct sysinfo_item;
    5556
    56 /** Gerated numeric value function */
    57 typedef sysarg_t (*sysinfo_fn_val_t)(struct sysinfo_item *);
     57/** Generated numeric value function */
     58typedef sysarg_t (*sysinfo_fn_val_t)(struct sysinfo_item *, void *);
     59
     60/** Sysinfo generated numberic value data
     61 *
     62 */
     63typedef struct {
     64        sysinfo_fn_val_t fn;  /**< Generated value function */
     65        void *data;           /**< Private data */
     66} sysinfo_gen_val_data_t;
    5867
    5968/** Generated binary data function */
    60 typedef void *(*sysinfo_fn_data_t)(struct sysinfo_item *, size_t *, bool);
     69typedef void *(*sysinfo_fn_data_t)(struct sysinfo_item *, size_t *, bool,
     70    void *);
     71
     72/** Sysinfo generated binary data data
     73 *
     74 */
     75typedef struct {
     76        sysinfo_fn_data_t fn;  /**< Generated binary data function */
     77        void *data;            /**< Private data */
     78} sysinfo_gen_data_data_t;
    6179
    6280/** Sysinfo item binary data
    … …  
    7290 */
    7391typedef union {
    74         sysarg_t val;               /**< Constant numberic value */
    75         sysinfo_fn_val_t fn_val;    /**< Generated numeric value function */
    76         sysinfo_fn_data_t fn_data;  /**< Generated binary data function */
    77         sysinfo_data_t data;        /**< Constant binary data */
     92        sysarg_t val;                      /**< Constant numberic value */
     93        sysinfo_data_t data;               /**< Constant binary data */
     94        sysinfo_gen_val_data_t gen_val;    /**< Generated numeric value function */
     95        sysinfo_gen_data_data_t gen_data;  /**< Generated binary data function */
    7896} sysinfo_item_val_t;
    7997
    … …  
    95113
    96114/** Generated subtree function */
    97 typedef sysinfo_return_t (*sysinfo_fn_subtree_t)(const char *, bool);
     115typedef sysinfo_return_t (*sysinfo_fn_subtree_t)(const char *, bool, void *);
     116
     117/** Sysinfo generated subtree data
     118 *
     119 */
     120typedef struct {
     121        sysinfo_fn_subtree_t fn;  /**< Generated subtree function */
     122        void *data;               /**< Private data */
     123} sysinfo_gen_subtree_data_t;
    98124
    99125/** Sysinfo subtree (union)
    … …  
    101127 */
    102128typedef union {
    103         struct sysinfo_item *table;     /**< Fixed subtree (list of subitems) */
    104         sysinfo_fn_subtree_t get_data;  /**< Generated subtree function */
     129        struct sysinfo_item *table;            /**< Fixed subtree (list of subitems) */
     130        sysinfo_gen_subtree_data_t generator;  /**< Generated subtree */
    105131} sysinfo_subtree_t;
    106132
    … …  
    123149extern void sysinfo_set_item_data(const char *, sysinfo_item_t **, void *,
    124150    size_t);
    125 extern void sysinfo_set_item_fn_val(const char *, sysinfo_item_t **,
    126     sysinfo_fn_val_t);
    127 extern void sysinfo_set_item_fn_data(const char *, sysinfo_item_t **,
    128     sysinfo_fn_data_t);
     151extern void sysinfo_set_item_gen_val(const char *, sysinfo_item_t **,
     152    sysinfo_fn_val_t, void *);
     153extern void sysinfo_set_item_gen_data(const char *, sysinfo_item_t **,
     154    sysinfo_fn_data_t, void *);
    129155extern void sysinfo_set_item_undefined(const char *, sysinfo_item_t **);
    130156
    131157extern void sysinfo_set_subtree_fn(const char *, sysinfo_item_t **,
    132     sysinfo_fn_subtree_t);
     158    sysinfo_fn_subtree_t, void *);
    133159
    134160extern void sysinfo_init(void);
    135161extern void sysinfo_dump(sysinfo_item_t *);
    136162
     163extern sysarg_t sys_sysinfo_get_keys_size(void *, size_t, void *);
     164extern sysarg_t sys_sysinfo_get_keys(void *, size_t, void *, size_t, size_t *);
    137165extern sysarg_t sys_sysinfo_get_val_type(void *, size_t);
    138166extern sysarg_t sys_sysinfo_get_value(void *, size_t, void *);

  • kernel/generic/src/main/main.c

    r43cd499 r14f8fd4  
    221221        frame_init();
    222222        slab_cache_init();
    223         ra_init();     
     223        ra_init();
    224224        sysinfo_init();
    225225        btree_init();

  • kernel/generic/src/mm/frame.c

    r43cd499 r14f8fd4  
    12701270/** Adjust bounds of physical memory region according to low/high memory split.
    12711271 *
    1272  * @param low[in]       If true, the adujstment is performed to make the region
     1272 * @param low[in]       If true, the adjustment is performed to make the region
    12731273 *                      fit in the low memory. Otherwise the adjustment is
    12741274 *                      performed to make the region fit in the high memory.
    … …  
    12821282bool frame_adjust_zone_bounds(bool low, uintptr_t *basep, size_t *sizep)
    12831283{
    1284         // FIXME: This might lead to overflow if the identity_size is too big
    1285         // but it is necessary if the PA identity_base > identity_size
    1286         const uintptr_t limit =
    1287             KA2PA(config.identity_base) + config.identity_size;
     1284        uintptr_t limit = KA2PA(config.identity_base) + config.identity_size;
    12881285
    12891286        if (low) {

  • kernel/generic/src/syscall/syscall.c

    r43cd499 r14f8fd4  
    184184       
    185185        /* Sysinfo syscalls. */
     186        (syshandler_t) sys_sysinfo_get_keys_size,
     187        (syshandler_t) sys_sysinfo_get_keys,
    186188        (syshandler_t) sys_sysinfo_get_val_type,
    187189        (syshandler_t) sys_sysinfo_get_value,

  • kernel/generic/src/sysinfo/stats.c

    r43cd499 r14f8fd4  
    8383 *
    8484 * @param item Sysinfo item (unused).
     85 * @param data Unused.
    8586 *
    8687 * @return System uptime (in secords).
    8788 *
    8889 */
    89 static sysarg_t get_stats_uptime(struct sysinfo_item *item)
     90static sysarg_t get_stats_uptime(struct sysinfo_item *item, void *data)
    9091{
    9192        /* This doesn't have to be very accurate */
    … …  
    9899 * @param size    Size of the returned data.
    99100 * @param dry_run Do not get the data, just calculate the size.
     101 * @param data    Unused.
    100102 *
    101103 * @return Data containing several stats_cpu_t structures.
    … …  
    104106 */
    105107static void *get_stats_cpus(struct sysinfo_item *item, size_t *size,
    106     bool dry_run)
     108    bool dry_run, void *data)
    107109{
    108110        *size = sizeof(stats_cpu_t) * config.cpu_count;
    … …  
    249251        ASSERT(interrupts_disabled());
    250252        ASSERT(irq_spinlock_locked(&task->lock));
    251 
     253       
    252254        stats_task->task_id = task->taskid;
    253255        str_cpy(stats_task->name, TASK_NAME_BUFLEN, task->name);
    … …  
    293295 * @param size    Size of the returned data.
    294296 * @param dry_run Do not get the data, just calculate the size.
     297 * @param data    Unused.
    295298 *
    296299 * @return Data containing several stats_task_t structures.
    … …  
    299302 */
    300303static void *get_stats_tasks(struct sysinfo_item *item, size_t *size,
    301     bool dry_run)
     304    bool dry_run, void *data)
    302305{
    303306        /* Messing with task structures, avoid deadlock */
    … …  
    350353        ASSERT(interrupts_disabled());
    351354        ASSERT(irq_spinlock_locked(&thread->lock));
    352 
     355       
    353356        stats_thread->thread_id = thread->tid;
    354357        stats_thread->task_id = thread->task->taskid;
    … …  
    398401 * @param size    Size of the returned data.
    399402 * @param dry_run Do not get the data, just calculate the size.
     403 * @param data    Unused.
    400404 *
    401405 * @return Data containing several stats_task_t structures.
    … …  
    404408 */
    405409static void *get_stats_threads(struct sysinfo_item *item, size_t *size,
    406     bool dry_run)
     410    bool dry_run, void *data)
    407411{
    408412        /* Messing with threads structures, avoid deadlock */
    … …  
    451455 * @param name    Task ID (string-encoded number).
    452456 * @param dry_run Do not get the data, just calculate the size.
     457 * @param data    Unused.
    453458 *
    454459 * @return Sysinfo return holder. The type of the returned
    … …  
    460465 *
    461466 */
    462 static sysinfo_return_t get_stats_task(const char *name, bool dry_run)
     467static sysinfo_return_t get_stats_task(const char *name, bool dry_run,
     468    void *data)
    463469{
    464470        /* Initially no return value */
    … …  
    520526 * @param name    Thread ID (string-encoded number).
    521527 * @param dry_run Do not get the data, just calculate the size.
     528 * @param data    Unused.
    522529 *
    523530 * @return Sysinfo return holder. The type of the returned
    … …  
    529536 *
    530537 */
    531 static sysinfo_return_t get_stats_thread(const char *name, bool dry_run)
     538static sysinfo_return_t get_stats_thread(const char *name, bool dry_run,
     539    void *data)
    532540{
    533541        /* Initially no return value */
    … …  
    586594 * @param size    Size of the returned data.
    587595 * @param dry_run Do not get the data, just calculate the size.
     596 * @param data    Unused.
    588597 *
    589598 * @return Data containing several stats_exc_t structures.
    … …  
    592601 */
    593602static void *get_stats_exceptions(struct sysinfo_item *item, size_t *size,
    594     bool dry_run)
     603    bool dry_run, void *data)
    595604{
    596605        *size = sizeof(stats_exc_t) * IVT_ITEMS;
    … …  
    634643 * @param name    Exception number (string-encoded number).
    635644 * @param dry_run Do not get the data, just calculate the size.
     645 * @param data    Unused.
    636646 *
    637647 * @return Sysinfo return holder. The type of the returned
    … …  
    643653 *
    644654 */
    645 static sysinfo_return_t get_stats_exception(const char *name, bool dry_run)
     655static sysinfo_return_t get_stats_exception(const char *name, bool dry_run,
     656    void *data)
    646657{
    647658        /* Initially no return value */
    … …  
    705716 * @param size    Size of the returned data.
    706717 * @param dry_run Do not get the data, just calculate the size.
     718 * @param data    Unused.
    707719 *
    708720 * @return Data containing stats_physmem_t.
    … …  
    711723 */
    712724static void *get_stats_physmem(struct sysinfo_item *item, size_t *size,
    713     bool dry_run)
     725    bool dry_run, void *data)
    714726{
    715727        *size = sizeof(stats_physmem_t);
    … …  
    735747 * @param size    Size of the returned data.
    736748 * @param dry_run Do not get the data, just calculate the size.
     749 * @param data    Unused.
    737750 *
    738751 * @return Data several load_t values.
    … …  
    741754 */
    742755static void *get_stats_load(struct sysinfo_item *item, size_t *size,
    743     bool dry_run)
     756    bool dry_run, void *data)
    744757{
    745758        *size = sizeof(load_t) * LOAD_STEPS;
    … …  
    810823        mutex_initialize(&load_lock, MUTEX_PASSIVE);
    811824       
    812         sysinfo_set_item_fn_val("system.uptime", NULL, get_stats_uptime);
    813         sysinfo_set_item_fn_data("system.cpus", NULL, get_stats_cpus);
    814         sysinfo_set_item_fn_data("system.physmem", NULL, get_stats_physmem);
    815         sysinfo_set_item_fn_data("system.load", NULL, get_stats_load);
    816         sysinfo_set_item_fn_data("system.tasks", NULL, get_stats_tasks);
    817         sysinfo_set_item_fn_data("system.threads", NULL, get_stats_threads);
    818         sysinfo_set_item_fn_data("system.exceptions", NULL, get_stats_exceptions);
    819         sysinfo_set_subtree_fn("system.tasks", NULL, get_stats_task);
    820         sysinfo_set_subtree_fn("system.threads", NULL, get_stats_thread);
    821         sysinfo_set_subtree_fn("system.exceptions", NULL, get_stats_exception);
     825        sysinfo_set_item_gen_val("system.uptime", NULL, get_stats_uptime, NULL);
     826        sysinfo_set_item_gen_data("system.cpus", NULL, get_stats_cpus, NULL);
     827        sysinfo_set_item_gen_data("system.physmem", NULL, get_stats_physmem, NULL);
     828        sysinfo_set_item_gen_data("system.load", NULL, get_stats_load, NULL);
     829        sysinfo_set_item_gen_data("system.tasks", NULL, get_stats_tasks, NULL);
     830        sysinfo_set_item_gen_data("system.threads", NULL, get_stats_threads, NULL);
     831        sysinfo_set_item_gen_data("system.exceptions", NULL, get_stats_exceptions, NULL);
     832        sysinfo_set_subtree_fn("system.tasks", NULL, get_stats_task, NULL);
     833        sysinfo_set_subtree_fn("system.threads", NULL, get_stats_thread, NULL);
     834        sysinfo_set_subtree_fn("system.exceptions", NULL, get_stats_exception, NULL);
    822835}
    823836

  • kernel/generic/src/sysinfo/sysinfo.c

    r43cd499 r14f8fd4  
    11/*
    22 * Copyright (c) 2006 Jakub Vana
     3 * Copyright (c) 2012 Martin Decky
    34 * All rights reserved.
    45 *
    … …  
    99100            sizeof(sysinfo_item_t), 0, sysinfo_item_constructor,
    100101            sysinfo_item_destructor, SLAB_CACHE_MAGDEFERRED);
    101 
     102       
    102103        mutex_initialize(&sysinfo_lock, MUTEX_ACTIVE);
    103104}
    … …  
    110111 * @param subtree Current sysinfo (sub)tree root item.
    111112 * @param ret     If the return value is NULL, this argument
    112  *                can be either also NULL (i.e. no item was
     113 *                can be set either to NULL (i.e. no item was
    113114 *                found and no data was generated) or the
    114115 *                original pointer is used to store the value
    … …  
    125126{
    126127        ASSERT(subtree != NULL);
    127         ASSERT(ret != NULL);
    128128       
    129129        sysinfo_item_t *cur = subtree;
    … …  
    151151                        case SYSINFO_SUBTREE_FUNCTION:
    152152                                /* Get generated data */
    153                                 **ret = cur->subtree.get_data(name + i + 1, dry_run);
     153                                if (ret != NULL)
     154                                        **ret = cur->subtree.generator.fn(name + i + 1,
     155                                            dry_run, cur->subtree.generator.data);
     156                               
    154157                                return NULL;
    155158                        default:
    156159                                /* Not found, no data generated */
    157                                 *ret = NULL;
     160                                if (ret != NULL)
     161                                        *ret = NULL;
     162                               
    158163                                return NULL;
    159164                        }
    … …  
    164169       
    165170        /* Not found, no data generated */
    166         *ret = NULL;
     171        if (ret != NULL)
     172                *ret = NULL;
     173       
    167174        return NULL;
    168175}
    … …  
    352359 *             a new root item (NULL for global sysinfo root).
    353360 * @param fn   Numeric value generator function.
    354  *
    355  */
    356 void sysinfo_set_item_fn_val(const char *name, sysinfo_item_t **root,
    357     sysinfo_fn_val_t fn)
     361 * @param data Private data.
     362 *
     363 */
     364void sysinfo_set_item_gen_val(const char *name, sysinfo_item_t **root,
     365    sysinfo_fn_val_t fn, void *data)
    358366{
    359367        /* Protect sysinfo tree consistency */
    … …  
    366374        if (item != NULL) {
    367375                item->val_type = SYSINFO_VAL_FUNCTION_VAL;
    368                 item->val.fn_val = fn;
     376                item->val.gen_val.fn = fn;
     377                item->val.gen_val.data = data;
    369378        }
    370379       
    … …  
    383392 *             a new root item (NULL for global sysinfo root).
    384393 * @param fn   Binary data generator function.
    385  *
    386  */
    387 void sysinfo_set_item_fn_data(const char *name, sysinfo_item_t **root,
    388     sysinfo_fn_data_t fn)
     394 * @param data Private data.
     395 *
     396 */
     397void sysinfo_set_item_gen_data(const char *name, sysinfo_item_t **root,
     398    sysinfo_fn_data_t fn, void *data)
    389399{
    390400        /* Protect sysinfo tree consistency */
    … …  
    397407        if (item != NULL) {
    398408                item->val_type = SYSINFO_VAL_FUNCTION_DATA;
    399                 item->val.fn_data = fn;
     409                item->val.gen_data.fn = fn;
     410                item->val.gen_data.data = data;
    400411        }
    401412       
    … …  
    431442 *             a new root item (NULL for global sysinfo root).
    432443 * @param fn   Subtree generator function.
     444 * @param data Private data to be passed to the generator.
    433445 *
    434446 */
    435447void sysinfo_set_subtree_fn(const char *name, sysinfo_item_t **root,
    436     sysinfo_fn_subtree_t fn)
     448    sysinfo_fn_subtree_t fn, void *data)
    437449{
    438450        /* Protect sysinfo tree consistency */
    … …  
    448460        if ((item != NULL) && (item->subtree_type != SYSINFO_SUBTREE_TABLE)) {
    449461                item->subtree_type = SYSINFO_SUBTREE_FUNCTION;
    450                 item->subtree.get_data = fn;
     462                item->subtree.generator.fn = fn;
     463                item->subtree.generator.data = data;
    451464        }
    452465       
    … …  
    456469/** Sysinfo dump indentation helper routine
    457470 *
    458  * @param depth Number of indentation characters to print.
    459  *
    460  */
    461 NO_TRACE static void sysinfo_indent(unsigned int depth)
    462 {
    463         unsigned int i;
    464         for (i = 0; i < depth; i++)
    465                 printf("  ");
     471 * @param depth Number of spaces to print.
     472 *
     473 */
     474NO_TRACE static void sysinfo_indent(size_t spaces)
     475{
     476        for (size_t i = 0; i < spaces; i++)
     477                printf(" ");
    466478}
    467479
    … …  
    470482 * Should be called with sysinfo_lock held.
    471483 *
    472  * @param root  Root item of the current (sub)tree.
    473  * @param depth Current depth in the sysinfo tree.
    474  *
    475  */
    476 NO_TRACE static void sysinfo_dump_internal(sysinfo_item_t *root, unsigned int depth)
    477 {
    478         sysinfo_item_t *cur = root;
    479        
     484 * @param root   Root item of the current (sub)tree.
     485 * @param spaces Current indentation level.
     486 *
     487 */
     488NO_TRACE static void sysinfo_dump_internal(sysinfo_item_t *root, size_t spaces)
     489{
    480490        /* Walk all siblings */
    481         while (cur != NULL) {
    482                 sysinfo_indent(depth);
     491        for (sysinfo_item_t *cur = root; cur; cur = cur->next) {
     492                size_t length;
     493               
     494                if (spaces == 0) {
     495                        printf("%s", cur->name);
     496                        length = str_length(cur->name);
     497                } else {
     498                        sysinfo_indent(spaces);
     499                        printf(".%s", cur->name);
     500                        length = str_length(cur->name) + 1;
     501                }
    483502               
    484503                sysarg_t val;
    … …  
    488507                switch (cur->val_type) {
    489508                case SYSINFO_VAL_UNDEFINED:
    490                         printf("+ %s\n", cur->name);
     509                        printf(" [undefined]\n");
    491510                        break;
    492511                case SYSINFO_VAL_VAL:
    493                         printf("+ %s -> %" PRIun" (%#" PRIxn ")\n", cur->name,
    494                             cur->val.val, cur->val.val);
     512                        printf(" -> %" PRIun" (%#" PRIxn ")\n", cur->val.val,
     513                            cur->val.val);
    495514                        break;
    496515                case SYSINFO_VAL_DATA:
    497                         printf("+ %s (%zu bytes)\n", cur->name,
    498                             cur->val.data.size);
     516                        printf(" (%zu bytes)\n", cur->val.data.size);
    499517                        break;
    500518                case SYSINFO_VAL_FUNCTION_VAL:
    501                         val = cur->val.fn_val(cur);
    502                         printf("+ %s -> %" PRIun" (%#" PRIxn ") [generated]\n",
    503                             cur->name, val, val);
     519                        val = cur->val.gen_val.fn(cur, cur->val.gen_val.data);
     520                        printf(" -> %" PRIun" (%#" PRIxn ") [generated]\n", val,
     521                            val);
    504522                        break;
    505523                case SYSINFO_VAL_FUNCTION_DATA:
    506524                        /* N.B.: No data was actually returned (only a dry run) */
    507                         (void) cur->val.fn_data(cur, &size, true);
    508                         printf("+ %s (%zu bytes) [generated]\n", cur->name,
    509                             size);
     525                        (void) cur->val.gen_data.fn(cur, &size, true,
     526                            cur->val.gen_data.data);
     527                        printf(" (%zu bytes) [generated]\n", size);
    510528                        break;
    511529                default:
    … …  
    518536                        break;
    519537                case SYSINFO_SUBTREE_TABLE:
    520                         sysinfo_dump_internal(cur->subtree.table, depth + 1);
     538                        sysinfo_dump_internal(cur->subtree.table, spaces + length);
    521539                        break;
    522540                case SYSINFO_SUBTREE_FUNCTION:
    523                         sysinfo_indent(depth + 1);
    524                         printf("+ [generated subtree]\n");
     541                        sysinfo_indent(spaces + length);
     542                        printf("<generated subtree>\n");
    525543                        break;
    526544                default:
    527                         sysinfo_indent(depth + 1);
    528                         printf("+ [unknown subtree]\n");
     545                        sysinfo_indent(spaces + length);
     546                        printf("<unknown subtree>\n");
    529547                }
    530                
    531                 cur = cur->next;
    532548        }
    533549}
    … …  
    594610                        break;
    595611                case SYSINFO_VAL_FUNCTION_VAL:
    596                         ret.val = item->val.fn_val(item);
     612                        ret.val = item->val.gen_val.fn(item, item->val.gen_val.data);
    597613                        break;
    598614                case SYSINFO_VAL_FUNCTION_DATA:
    599                         ret.data.data = item->val.fn_data(item, &ret.data.size,
    600                             dry_run);
     615                        ret.data.data = item->val.gen_data.fn(item, &ret.data.size,
     616                            dry_run, item->val.gen_data.data);
    601617                        break;
    602618                }
    … …  
    635651        ASSERT(path);
    636652       
    637         if ((copy_from_uspace(path, ptr, size + 1) == 0)
    638             && (path[size] == 0)) {
     653        if ((copy_from_uspace(path, ptr, size + 1) == 0) &&
     654            (path[size] == 0)) {
    639655                /*
    640656                 * Prevent other functions from messing with sysinfo while we
    … …  
    645661                mutex_unlock(&sysinfo_lock);
    646662        }
     663       
    647664        free(path);
    648665        return ret;
     666}
     667
     668/** Return sysinfo keys determined by name
     669 *
     670 * Should be called with sysinfo_lock held.
     671 *
     672 * @param name    Sysinfo path.
     673 * @param root    Root item of the sysinfo (sub)tree.
     674 *                If it is NULL then consider the global
     675 *                sysinfo tree.
     676 * @param dry_run Do not actually get any generated
     677 *                binary data, just calculate the size.
     678 *
     679 * @return Item value (constant or generated).
     680 *
     681 */
     682NO_TRACE static sysinfo_return_t sysinfo_get_keys(const char *name,
     683    sysinfo_item_t **root, bool dry_run)
     684{
     685        if (root == NULL)
     686                root = &global_root;
     687       
     688        sysinfo_item_t *subtree = NULL;
     689       
     690        if (name[0] != 0) {
     691                /* Try to find the item */
     692                sysinfo_item_t *item =
     693                    sysinfo_find_item(name, *root, NULL, dry_run);
     694                if ((item != NULL) &&
     695                    (item->subtree_type == SYSINFO_SUBTREE_TABLE))
     696                        subtree = item->subtree.table;
     697        } else
     698                subtree = *root;
     699       
     700        sysinfo_return_t ret;
     701       
     702        if (subtree != NULL) {
     703                /*
     704                 * Calculate the size of subkeys.
     705                 */
     706                size_t size = 0;
     707                for (sysinfo_item_t *cur = subtree; cur; cur = cur->next)
     708                        size += str_size(cur->name) + 1;
     709               
     710                if (dry_run) {
     711                        ret.tag = SYSINFO_VAL_DATA;
     712                        ret.data.data = NULL;
     713                        ret.data.size = size;
     714                } else {
     715                        /* Allocate buffer for subkeys */
     716                        char *names = (char *) malloc(size, FRAME_ATOMIC);
     717                        if (names == NULL)
     718                                return ret;
     719                       
     720                        size_t pos = 0;
     721                        for (sysinfo_item_t *cur = subtree; cur; cur = cur->next) {
     722                                str_cpy(names + pos, size - pos, cur->name);
     723                                pos += str_size(cur->name) + 1;
     724                        }
     725                       
     726                        /* Correct return value */
     727                        ret.tag = SYSINFO_VAL_DATA;
     728                        ret.data.data = (void *) names;
     729                        ret.data.size = size;
     730                }
     731        } else {
     732                /* No item in the fixed sysinfo tree */
     733                ret.tag = SYSINFO_VAL_UNDEFINED;
     734        }
     735       
     736        return ret;
     737}
     738
     739/** Return sysinfo keys determined by name from user space
     740 *
     741 * The path string passed from the user space has to be properly
     742 * null-terminated (the last passed character must be null).
     743 *
     744 * @param ptr     Sysinfo path in the user address space.
     745 * @param size    Size of the path string.
     746 * @param dry_run Do not actually get any generated
     747 *                binary data, just calculate the size.
     748 *
     749 */
     750NO_TRACE static sysinfo_return_t sysinfo_get_keys_uspace(void *ptr, size_t size,
     751    bool dry_run)
     752{
     753        sysinfo_return_t ret;
     754        ret.tag = SYSINFO_VAL_UNDEFINED;
     755       
     756        if (size > SYSINFO_MAX_PATH)
     757                return ret;
     758       
     759        char *path = (char *) malloc(size + 1, 0);
     760        ASSERT(path);
     761       
     762        if ((copy_from_uspace(path, ptr, size + 1) == 0) &&
     763            (path[size] == 0)) {
     764                /*
     765                 * Prevent other functions from messing with sysinfo while we
     766                 * are reading it.
     767                 */
     768                mutex_lock(&sysinfo_lock);
     769                ret = sysinfo_get_keys(path, NULL, dry_run);
     770                mutex_unlock(&sysinfo_lock);
     771        }
     772       
     773        free(path);
     774        return ret;
     775}
     776
     777/** Get the sysinfo keys size (syscall)
     778 *
     779 * The path string passed from the user space has
     780 * to be properly null-terminated (the last passed
     781 * character must be null).
     782 *
     783 * @param path_ptr  Sysinfo path in the user address space.
     784 * @param path_size Size of the path string.
     785 * @param size_ptr  User space pointer where to store the
     786 *                  keys size.
     787 *
     788 * @return Error code (EOK in case of no error).
     789 *
     790 */
     791sysarg_t sys_sysinfo_get_keys_size(void *path_ptr, size_t path_size,
     792    void *size_ptr)
     793{
     794        int rc;
     795       
     796        /*
     797         * Get the keys.
     798         *
     799         * N.B.: There is no need to free any potential keys
     800         * since we request a dry run.
     801         */
     802        sysinfo_return_t ret =
     803            sysinfo_get_keys_uspace(path_ptr, path_size, true);
     804       
     805        /* Check return data tag */
     806        if (ret.tag == SYSINFO_VAL_DATA)
     807                rc = copy_to_uspace(size_ptr, &ret.data.size,
     808                    sizeof(ret.data.size));
     809        else
     810                rc = EINVAL;
     811       
     812        return (sysarg_t) rc;
     813}
     814
     815/** Get the sysinfo keys (syscall)
     816 *
     817 * The path string passed from the user space has
     818 * to be properly null-terminated (the last passed
     819 * character must be null).
     820 *
     821 * If the user space buffer size does not equal
     822 * the actual size of the returned data, the data
     823 * is truncated.
     824 *
     825 * The actual size of data returned is stored to
     826 * size_ptr.
     827 *
     828 * @param path_ptr    Sysinfo path in the user address space.
     829 * @param path_size   Size of the path string.
     830 * @param buffer_ptr  User space pointer to the buffer where
     831 *                    to store the binary data.
     832 * @param buffer_size User space buffer size.
     833 * @param size_ptr    User space pointer where to store the
     834 *                    binary data size.
     835 *
     836 * @return Error code (EOK in case of no error).
     837 *
     838 */
     839sysarg_t sys_sysinfo_get_keys(void *path_ptr, size_t path_size,
     840    void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
     841{
     842        int rc;
     843       
     844        /* Get the keys */
     845        sysinfo_return_t ret = sysinfo_get_keys_uspace(path_ptr, path_size,
     846            false);
     847       
     848        /* Check return data tag */
     849        if (ret.tag == SYSINFO_VAL_DATA) {
     850                size_t size = min(ret.data.size, buffer_size);
     851                rc = copy_to_uspace(buffer_ptr, ret.data.data, size);
     852                if (rc == EOK)
     853                        rc = copy_to_uspace(size_ptr, &size, sizeof(size));
     854               
     855                free(ret.data.data);
     856        } else
     857                rc = EINVAL;
     858       
     859        return (sysarg_t) rc;
    649860}
    650861
    … …  
    672883       
    673884        /*
    674          * Map generated value types to constant types (user space does not care
    675          * whether the value is constant or generated).
     885         * Map generated value types to constant types (user space does
     886         * not care whether the value is constant or generated).
    676887         */
    677888        if (ret.tag == SYSINFO_VAL_FUNCTION_VAL)
    … …  
    701912{
    702913        int rc;
    703 
     914       
    704915        /*
    705916         * Get the item.
    706917         *
    707          * N.B.: There is no need to free any potential generated binary data
    708          * since we request a dry run.
     918         * N.B.: There is no need to free any potential generated binary
     919         * data since we request a dry run.
    709920         */
    710921        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size, true);
    … …  
    741952         * Get the item.
    742953         *
    743          * N.B.: There is no need to free any potential generated binary data
    744          * since we request a dry run.
     954         * N.B.: There is no need to free any potential generated binary
     955         * data since we request a dry run.
    745956         */
    746957        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size, true);

  • tools/toolchain.sh

    r43cd499 r14f8fd4  
    5353EOF
    5454
    55 BINUTILS_VERSION="2.21.1"
    56 BINUTILS_RELEASE="a"
    57 GCC_VERSION="4.6.2"
    58 GDB_VERSION="7.3.1"
     55BINUTILS_VERSION="2.22"
     56BINUTILS_RELEASE=""
     57GCC_VERSION="4.6.3"
     58GDB_VERSION="7.4"
    5959
    6060BASEDIR="`pwd`"
    … …  
    274274        GDB_SOURCE="ftp://ftp.gnu.org/gnu/gdb/"
    275275       
    276         download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "bde820eac53fa3a8d8696667418557ad"
    277         download_fetch "${GCC_SOURCE}" "${GCC_CORE}" "780f614ab18c7a9066dec6387d7490b2"
    278         download_fetch "${GCC_SOURCE}" "${GCC_OBJC}" "94043cc0d08394eddebed73f30ecad89"
    279         download_fetch "${GCC_SOURCE}" "${GCC_CPP}" "87ecd60431e41096419dd8a10f76e46b"
    280         download_fetch "${GDB_SOURCE}" "${GDB}" "b89a5fac359c618dda97b88645ceab47"
     276        download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "ee0f10756c84979622b992a4a61ea3f5"
     277        download_fetch "${GCC_SOURCE}" "${GCC_CORE}" "766091220c6a14fcaa2c06dd573e3758"
     278        download_fetch "${GCC_SOURCE}" "${GCC_OBJC}" "48ba23770c34b1cb468f72618b4452c5"
     279        download_fetch "${GCC_SOURCE}" "${GCC_CPP}" "37515158a0fb3d0800ec41a08c05e69e"
     280        download_fetch "${GDB_SOURCE}" "${GDB}" "95a9a8305fed4d30a30a6dc28ff9d060"
    281281}
    282282

  • uspace/Makefile

    r43cd499 r14f8fd4  
    4848        app/lsusb \
    4949        app/mkfat \
     50        app/mkexfat \
    5051        app/mkmfs \
    5152        app/redir \

  • uspace/app/sysinfo/sysinfo.c

    r43cd499 r14f8fd4  
    3737#include <stdio.h>
    3838#include <sysinfo.h>
     39#include <malloc.h>
    3940#include <sys/types.h>
    4041
    41 static int print_item_val(char *ipath);
    42 static int print_item_data(char *ipath);
    43 
    44 static void dump_bytes_hex(char *data, size_t size);
    45 static void dump_bytes_text(char *data, size_t size);
    46 
    47 static void print_syntax(void);
    48 
    49 int main(int argc, char *argv[])
    50 {
    51         int rc;
    52         char *ipath;
    53         sysinfo_item_val_type_t tag;
    54 
    55         if (argc != 2) {
    56                 print_syntax();
    57                 return 1;
    58         }
    59 
    60         ipath = argv[1];
    61 
    62         tag = sysinfo_get_val_type(ipath);
    63 
    64         /* Silence warning */
    65         rc = EOK;
    66 
    67         switch (tag) {
    68         case SYSINFO_VAL_UNDEFINED:
    69                 printf("Error: Sysinfo item '%s' not defined.\n", ipath);
    70                 rc = 2;
    71                 break;
    72         case SYSINFO_VAL_VAL:
    73                 rc = print_item_val(ipath);
    74                 break;
    75         case SYSINFO_VAL_DATA:
    76                 rc = print_item_data(ipath);
    77                 break;
    78         default:
    79                 printf("Error: Sysinfo item '%s' with unknown value type.\n",
    80                     ipath);
    81                 rc = 2;
    82                 break;
    83         }
    84 
    85         return rc;
     42static void dump_bytes_hex(char *data, size_t size)
     43{
     44        for (size_t i = 0; i < size; i++) {
     45                if (i > 0)
     46                        putchar(' ');
     47                printf("0x%02x", (uint8_t) data[i]);
     48        }
     49}
     50
     51static void dump_bytes_text(char *data, size_t size)
     52{
     53        size_t offset = 0;
     54       
     55        while (offset < size) {
     56                wchar_t c = str_decode(data, &offset, size);
     57                printf("%lc", (wint_t) c);
     58        }
    8659}
    8760
    … …  
    8962{
    9063        sysarg_t value;
    91         int rc;
    92 
    93         rc = sysinfo_get_value(ipath, &value);
     64        int rc = sysinfo_get_value(ipath, &value);
    9465        if (rc != EOK) {
    9566                printf("Error reading item '%s'.\n", ipath);
    9667                return rc;
    9768        }
    98 
     69       
    9970        printf("%s -> %" PRIu64 " (0x%" PRIx64 ")\n", ipath,
    10071            (uint64_t) value, (uint64_t) value);
    101 
     72       
    10273        return EOK;
    10374}
    … …  
    10576static int print_item_data(char *ipath)
    10677{
    107         void *data;
    10878        size_t size;
    109 
    110         data = sysinfo_get_data(ipath, &size);
     79        void *data = sysinfo_get_data(ipath, &size);
    11180        if (data == NULL) {
    11281                printf("Error reading item '%s'.\n", ipath);
    11382                return -1;
    11483        }
    115 
     84       
    11685        printf("%s -> ", ipath);
    11786        dump_bytes_hex(data, size);
    … …  
    11988        dump_bytes_text(data, size);
    12089        fputs("')\n", stdout);
    121 
     90       
    12291        return EOK;
    12392}
    12493
    125 static void dump_bytes_hex(char *data, size_t size)
    126 {
    127         size_t i;
    128 
    129         for (i = 0; i < size; ++i) {
    130                 if (i > 0) putchar(' ');
    131                 printf("0x%02x", (uint8_t) data[i]);
    132         }
    133 }
    134 
    135 static void dump_bytes_text(char *data, size_t size)
    136 {
    137         wchar_t c;
    138         size_t offset;
    139 
    140         offset = 0;
    141 
    142         while (offset < size) {
    143                 c = str_decode(data, &offset, size);
    144                 printf("%lc", (wint_t) c);
    145         }
    146 }
    147 
    148 
    149 static void print_syntax(void)
    150 {
    151         printf("Syntax: sysinfo <item_path>\n");
     94static int print_item_property(char *ipath, char *iprop)
     95{
     96        size_t size;
     97        void *data = sysinfo_get_property(ipath, iprop, &size);
     98        if (data == NULL) {
     99                printf("Error reading property '%s' of item '%s'.\n", iprop,
     100                    ipath);
     101                return -1;
     102        }
     103       
     104        printf("%s property %s -> ", ipath, iprop);
     105        dump_bytes_hex(data, size);
     106        fputs(" ('", stdout);
     107        dump_bytes_text(data, size);
     108        fputs("')\n", stdout);
     109       
     110        return EOK;
     111}
     112
     113static void print_spaces(size_t spaces)
     114{
     115        for (size_t i = 0; i < spaces; i++)
     116                printf(" ");
     117}
     118
     119static void print_keys(const char *path, size_t spaces)
     120{
     121        size_t size;
     122        char *keys = sysinfo_get_keys(path, &size);
     123        if ((keys == NULL) || (size == 0))
     124                return;
     125       
     126        size_t pos = 0;
     127        while (pos < size) {
     128                /* Process each key with sanity checks */
     129                size_t cur_size = str_nsize(keys + pos, size - pos);
     130                if (keys[pos + cur_size] != 0)
     131                        break;
     132               
     133                size_t path_size = str_size(path) + cur_size + 2;
     134                char *cur_path = (char *) malloc(path_size);
     135                if (cur_path == NULL)
     136                        break;
     137               
     138                size_t length;
     139               
     140                if (path[0] != 0) {
     141                        print_spaces(spaces);
     142                        printf(".%s\n", keys + pos);
     143                        length = str_length(keys + pos) + 1;
     144                       
     145                        snprintf(cur_path, path_size, "%s.%s", path, keys + pos);
     146                } else {
     147                        printf("%s\n", keys + pos);
     148                        length = str_length(keys + pos);
     149                       
     150                        snprintf(cur_path, path_size, "%s", keys + pos);
     151                }
     152               
     153                print_keys(cur_path, spaces + length);
     154               
     155                free(cur_path);
     156                pos += cur_size + 1;
     157        }
     158       
     159        free(keys);
     160}
     161
     162int main(int argc, char *argv[])
     163{
     164        int rc = 0;
     165       
     166        if (argc < 2) {
     167                /* Print keys */
     168                print_keys("", 0);
     169                return rc;
     170        }
     171       
     172        char *ipath = argv[1];
     173       
     174        if (argc < 3) {
     175                sysinfo_item_val_type_t tag = sysinfo_get_val_type(ipath);
     176               
     177                switch (tag) {
     178                case SYSINFO_VAL_UNDEFINED:
     179                        printf("Error: Sysinfo item '%s' not defined.\n", ipath);
     180                        rc = 2;
     181                        break;
     182                case SYSINFO_VAL_VAL:
     183                        rc = print_item_val(ipath);
     184                        break;
     185                case SYSINFO_VAL_DATA:
     186                        rc = print_item_data(ipath);
     187                        break;
     188                default:
     189                        printf("Error: Sysinfo item '%s' with unknown value type.\n",
     190                            ipath);
     191                        rc = 2;
     192                        break;
     193                }
     194               
     195                return rc;
     196        }
     197       
     198        char *iprop = argv[2];
     199        rc = print_item_property(ipath, iprop);
     200        return rc;
    152201}
    153202

  • uspace/drv/bus/usb/ehci/Makefile

    r43cd499 r14f8fd4  
    4343SOURCES = \
    4444        main.c \
    45         pci.c
     45        res.c
    4646
    4747include $(USPACE_PREFIX)/Makefile.common

  • uspace/drv/bus/usb/ehci/main.c

    r43cd499 r14f8fd4  
    4444#include <usb/host/hcd.h>
    4545
    46 #include "pci.h"
     46#include "res.h"
    4747
    4848#define NAME "ehci"
    … …  
    8181        int irq = 0;
    8282
    83         int ret = pci_get_my_registers(device, &reg_base, &reg_size, &irq);
     83        int ret = get_my_registers(device, &reg_base, &reg_size, &irq);
    8484        CHECK_RET_RETURN(ret,
    8585            "Failed to get memory addresses for %" PRIun ": %s.\n",
    … …  
    8888            reg_base, reg_size, irq);
    8989
    90         ret = pci_disable_legacy(device, reg_base, reg_size, irq);
     90        ret = disable_legacy(device, reg_base, reg_size);
    9191        CHECK_RET_RETURN(ret,
    9292            "Failed to disable legacy USB: %s.\n", str_error(ret));

  • uspace/drv/bus/usb/ehci/res.c

    r43cd499 r14f8fd4  
    3939#include <str_error.h>
    4040#include <assert.h>
    41 #include <as.h>
    4241#include <devman.h>
    4342#include <ddi.h>
    44 #include <libarch/ddi.h>
    45 #include <device/hw_res.h>
    46 
    4743#include <usb/debug.h>
    48 #include <pci_dev_iface.h>
    49 
    50 #include "pci.h"
    51 
    52 #define PAGE_SIZE_MASK 0xfffff000
     44#include <device/hw_res_parsed.h>
     45#include <device/pci.h>
     46
     47#include "res.h"
    5348
    5449#define HCC_PARAMS_OFFSET 0x8
    … …  
    7267#define WAIT_STEP 10
    7368
    74 #define PCI_READ(size) \
    75 do { \
    76         async_sess_t *parent_sess = \
    77             devman_parent_device_connect(EXCHANGE_SERIALIZE, dev->handle, \
    78             IPC_FLAG_BLOCKING); \
    79         if (!parent_sess) \
    80                 return ENOMEM; \
    81         \
    82         sysarg_t add = (sysarg_t) address; \
    83         sysarg_t val; \
    84         \
    85         async_exch_t *exch = async_exchange_begin(parent_sess); \
    86         \
    87         const int ret = \
    88             async_req_2_1(exch, DEV_IFACE_ID(PCI_DEV_IFACE), \
    89                 IPC_M_CONFIG_SPACE_READ_##size, add, &val); \
    90         \
    91         async_exchange_end(exch); \
    92         async_hangup(parent_sess); \
    93         \
    94         assert(value); \
    95         \
    96         *value = val; \
    97         return ret; \
    98 } while (0)
    99 
    100 static int pci_read32(const ddf_dev_t *dev, int address, uint32_t *value)
    101 {
    102         PCI_READ(32);
    103 }
    104 
    105 static int pci_read16(const ddf_dev_t *dev, int address, uint16_t *value)
    106 {
    107         PCI_READ(16);
    108 }
    109 
    110 static int pci_read8(const ddf_dev_t *dev, int address, uint8_t *value)
    111 {
    112         PCI_READ(8);
    113 }
    114 
    115 #define PCI_WRITE(size) \
    116 do { \
    117         async_sess_t *parent_sess = \
    118             devman_parent_device_connect(EXCHANGE_SERIALIZE, dev->handle, \
    119             IPC_FLAG_BLOCKING); \
    120         if (!parent_sess) \
    121                 return ENOMEM; \
    122         \
    123         sysarg_t add = (sysarg_t) address; \
    124         sysarg_t val = value; \
    125         \
    126         async_exch_t *exch = async_exchange_begin(parent_sess); \
    127         \
    128         const int ret = \
    129             async_req_3_0(exch, DEV_IFACE_ID(PCI_DEV_IFACE), \
    130                 IPC_M_CONFIG_SPACE_WRITE_##size, add, val); \
    131         \
    132         async_exchange_end(exch); \
    133         async_hangup(parent_sess); \
    134         \
    135         return ret; \
    136 } while(0)
    137 
    138 static int pci_write32(const ddf_dev_t *dev, int address, uint32_t value)
    139 {
    140         PCI_WRITE(32);
    141 }
    142 
    143 static int pci_write16(const ddf_dev_t *dev, int address, uint16_t value)
    144 {
    145         PCI_WRITE(16);
    146 }
    147 
    148 static int pci_write8(const ddf_dev_t *dev, int address, uint8_t value)
    149 {
    150         PCI_WRITE(8);
    151 }
    15269
    15370/** Get address of registers and IRQ for given device.
    … …  
    15976 * @return Error code.
    16077 */
    161 int pci_get_my_registers(const ddf_dev_t *dev,
     78int get_my_registers(const ddf_dev_t *dev,
    16279    uintptr_t *mem_reg_address, size_t *mem_reg_size, int *irq_no)
    16380{
    164         assert(dev != NULL);
     81        assert(dev);
    16582       
    166         async_sess_t *parent_sess =
    167             devman_parent_device_connect(EXCHANGE_SERIALIZE, dev->handle,
    168             IPC_FLAG_BLOCKING);
     83        async_sess_t *parent_sess = devman_parent_device_connect(
     84            EXCHANGE_SERIALIZE, dev->handle, IPC_FLAG_BLOCKING);
    16985        if (!parent_sess)
    17086                return ENOMEM;
    17187       
    172         hw_resource_list_t hw_resources;
    173         int rc = hw_res_get_resource_list(parent_sess, &hw_resources);
    174         if (rc != EOK) {
    175                 async_hangup(parent_sess);
    176                 return rc;
    177         }
    178        
    179         uintptr_t mem_address = 0;
    180         size_t mem_size = 0;
    181         bool mem_found = false;
    182        
    183         int irq = 0;
    184         bool irq_found = false;
    185        
    186         size_t i;
    187         for (i = 0; i < hw_resources.count; i++) {
    188                 hw_resource_t *res = &hw_resources.resources[i];
    189                 switch (res->type) {
    190                 case INTERRUPT:
    191                         irq = res->res.interrupt.irq;
    192                         irq_found = true;
    193                         usb_log_debug2("Found interrupt: %d.\n", irq);
    194                         break;
    195                 case MEM_RANGE:
    196                         if (res->res.mem_range.address != 0
    197                             && res->res.mem_range.size != 0 ) {
    198                                 mem_address = res->res.mem_range.address;
    199                                 mem_size = res->res.mem_range.size;
    200                                 usb_log_debug2("Found mem: %" PRIxn" %zu.\n",
    201                                     mem_address, mem_size);
    202                                 mem_found = true;
    203                         }
    204                 default:
    205                         break;
    206                 }
    207         }
    208        
    209         if (mem_found && irq_found) {
    210                 *mem_reg_address = mem_address;
    211                 *mem_reg_size = mem_size;
    212                 *irq_no = irq;
    213                 rc = EOK;
    214         } else {
    215                 rc = ENOENT;
    216         }
    217        
     88        hw_res_list_parsed_t hw_res;
     89        hw_res_list_parsed_init(&hw_res);
     90        const int ret = hw_res_get_list_parsed(parent_sess, &hw_res, 0);
    21891        async_hangup(parent_sess);
    219         return rc;
     92        if (ret != EOK) {
     93                return ret;
     94        }
     95
     96        if (hw_res.irqs.count != 1 || hw_res.mem_ranges.count != 1) {
     97                hw_res_list_parsed_clean(&hw_res);
     98                return ENOENT;
     99        }
     100
     101        if (mem_reg_address)
     102                *mem_reg_address = hw_res.mem_ranges.ranges[0].address;
     103        if (mem_reg_size)
     104                *mem_reg_size = hw_res.mem_ranges.ranges[0].size;
     105        if (irq_no)
     106                *irq_no = hw_res.irqs.irqs[0];
     107
     108        hw_res_list_parsed_clean(&hw_res);
     109        return EOK;
    220110}
    221111/*----------------------------------------------------------------------------*/
    … …  
    225115 * @return Error code.
    226116 */
    227 int pci_enable_interrupts(const ddf_dev_t *device)
     117int enable_interrupts(const ddf_dev_t *device)
    228118{
    229         async_sess_t *parent_sess =
    230             devman_parent_device_connect(EXCHANGE_SERIALIZE, device->handle,
    231             IPC_FLAG_BLOCKING);
     119        async_sess_t *parent_sess = devman_parent_device_connect(
     120            EXCHANGE_SERIALIZE, device->handle, IPC_FLAG_BLOCKING);
    232121        if (!parent_sess)
    233122                return ENOMEM;
    … …  
    239128}
    240129/*----------------------------------------------------------------------------*/
    241 /** Implements BIOS handoff routine as decribed in EHCI spec
    242  *
    243  * @param[in] device Device asking for interrupts
     130/** Implements BIOS hands-off routine as described in EHCI spec
     131 *
     132 * @param device EHCI device
     133 * @param eecp Value of EHCI Extended Capabilities pointer.
    244134 * @return Error code.
    245135 */
    246 int pci_disable_legacy(
    247     const ddf_dev_t *device, uintptr_t reg_base, size_t reg_size, int irq)
     136static int disable_extended_caps(const ddf_dev_t *device, unsigned eecp)
     137{
     138        /* nothing to do */
     139        if (eecp == 0)
     140                return EOK;
     141
     142        async_sess_t *parent_sess = devman_parent_device_connect(
     143            EXCHANGE_SERIALIZE, device->handle, IPC_FLAG_BLOCKING);
     144        if (!parent_sess)
     145                return ENOMEM;
     146
     147#define CHECK_RET_HANGUP_RETURN(ret, message...) \
     148        if (ret != EOK) { \
     149                usb_log_error(message); \
     150                async_hangup(parent_sess); \
     151                return ret; \
     152        } else (void)0
     153
     154        /* Read the first EEC. i.e. Legacy Support register */
     155        uint32_t usblegsup;
     156        int ret = pci_config_space_read_32(parent_sess,
     157            eecp + USBLEGSUP_OFFSET, &usblegsup);
     158        CHECK_RET_HANGUP_RETURN(ret,
     159            "Failed to read USBLEGSUP: %s.\n", str_error(ret));
     160        usb_log_debug("USBLEGSUP: %" PRIx32 ".\n", usblegsup);
     161
     162        /* Request control from firmware/BIOS by writing 1 to highest
     163         * byte. (OS Control semaphore)*/
     164        usb_log_debug("Requesting OS control.\n");
     165        ret = pci_config_space_write_8(parent_sess,
     166            eecp + USBLEGSUP_OFFSET + 3, 1);
     167        CHECK_RET_HANGUP_RETURN(ret, "Failed to request OS EHCI control: %s.\n",
     168            str_error(ret));
     169
     170        size_t wait = 0;
     171        /* Wait for BIOS to release control. */
     172        ret = pci_config_space_read_32(
     173            parent_sess, eecp + USBLEGSUP_OFFSET, &usblegsup);
     174        while ((wait < DEFAULT_WAIT) && (usblegsup & USBLEGSUP_BIOS_CONTROL)) {
     175                async_usleep(WAIT_STEP);
     176                ret = pci_config_space_read_32(parent_sess,
     177                    eecp + USBLEGSUP_OFFSET, &usblegsup);
     178                wait += WAIT_STEP;
     179        }
     180
     181        if ((usblegsup & USBLEGSUP_BIOS_CONTROL) == 0) {
     182                usb_log_info("BIOS released control after %zu usec.\n", wait);
     183                async_hangup(parent_sess);
     184                return EOK;
     185        }
     186
     187        /* BIOS failed to hand over control, this should not happen. */
     188        usb_log_warning( "BIOS failed to release control after "
     189            "%zu usecs, force it.\n", wait);
     190        ret = pci_config_space_write_32(parent_sess,
     191            eecp + USBLEGSUP_OFFSET, USBLEGSUP_OS_CONTROL);
     192        CHECK_RET_HANGUP_RETURN(ret, "Failed to force OS control: "
     193            "%s.\n", str_error(ret));
     194        /*
     195         * Check capability type here, value of 01h identifies the capability
     196         * as Legacy Support. This extended capability requires one additional
     197         * 32-bit register for control/status information and this register is
     198         * located at offset EECP+04h
     199         */
     200        if ((usblegsup & 0xff) == 1) {
     201                /* Read the second EEC Legacy Support and Control register */
     202                uint32_t usblegctlsts;
     203                ret = pci_config_space_read_32(parent_sess,
     204                    eecp + USBLEGCTLSTS_OFFSET, &usblegctlsts);
     205                CHECK_RET_HANGUP_RETURN(ret, "Failed to get USBLEGCTLSTS: %s.\n",
     206                    str_error(ret));
     207                usb_log_debug("USBLEGCTLSTS: %" PRIx32 ".\n", usblegctlsts);
     208                /*
     209                 * Zero SMI enables in legacy control register.
     210                 * It should prevent pre-OS code from
     211                 * interfering. NOTE: Three upper bits are WC
     212                 */
     213                ret = pci_config_space_write_32(parent_sess,
     214                    eecp + USBLEGCTLSTS_OFFSET, 0xe0000000);
     215                CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) zero USBLEGCTLSTS.\n", ret);
     216                udelay(10);
     217                ret = pci_config_space_read_32(parent_sess,
     218                    eecp + USBLEGCTLSTS_OFFSET, &usblegctlsts);
     219                CHECK_RET_HANGUP_RETURN(ret, "Failed to get USBLEGCTLSTS 2: %s.\n",
     220                    str_error(ret));
     221                usb_log_debug("Zeroed USBLEGCTLSTS: %" PRIx32 ".\n",
     222                    usblegctlsts);
     223        }
     224
     225        /* Read again Legacy Support register */
     226        ret = pci_config_space_read_32(parent_sess,
     227            eecp + USBLEGSUP_OFFSET, &usblegsup);
     228        CHECK_RET_HANGUP_RETURN(ret, "Failed to read USBLEGSUP: %s.\n",
     229            str_error(ret));
     230        usb_log_debug("USBLEGSUP: %" PRIx32 ".\n", usblegsup);
     231        async_hangup(parent_sess);
     232        return EOK;
     233#undef CHECK_RET_HANGUP_RETURN
     234}
     235
     236int disable_legacy(const ddf_dev_t *device, uintptr_t reg_base, size_t reg_size)
    248237{
    249238        assert(device);
    250         (void) pci_read16;
    251         (void) pci_read8;
    252         (void) pci_write16;
    253239
    254240#define CHECK_RET_RETURN(ret, message...) \
    … …  
    274260        usb_log_debug("Value of EECP: %x.\n", eecp);
    275261
    276         /* Read the first EEC. i.e. Legacy Support register */
    277         uint32_t usblegsup;
    278         ret = pci_read32(device, eecp + USBLEGSUP_OFFSET, &usblegsup);
    279         CHECK_RET_RETURN(ret, "Failed to read USBLEGSUP: %s.\n", str_error(ret));
    280         usb_log_debug("USBLEGSUP: %" PRIx32 ".\n", usblegsup);
    281 
    282         /* Request control from firmware/BIOS, by writing 1 to highest byte.
    283          * (OS Control semaphore)*/
    284         usb_log_debug("Requesting OS control.\n");
    285         ret = pci_write8(device, eecp + USBLEGSUP_OFFSET + 3, 1);
    286         CHECK_RET_RETURN(ret, "Failed to request OS EHCI control: %s.\n",
     262        ret = disable_extended_caps(device, eecp);
     263        CHECK_RET_RETURN(ret, "Failed to disable extended capabilities: %s.\n",
    287264            str_error(ret));
    288265
    289         size_t wait = 0;
    290         /* Wait for BIOS to release control. */
    291         ret = pci_read32(device, eecp + USBLEGSUP_OFFSET, &usblegsup);
    292         while ((wait < DEFAULT_WAIT) && (usblegsup & USBLEGSUP_BIOS_CONTROL)) {
    293                 async_usleep(WAIT_STEP);
    294                 ret = pci_read32(device, eecp + USBLEGSUP_OFFSET, &usblegsup);
    295                 wait += WAIT_STEP;
    296         }
    297 
    298 
    299         if ((usblegsup & USBLEGSUP_BIOS_CONTROL) == 0) {
    300                 usb_log_info("BIOS released control after %zu usec.\n", wait);
    301         } else {
    302                 /* BIOS failed to hand over control, this should not happen. */
    303                 usb_log_warning( "BIOS failed to release control after "
    304                     "%zu usecs, force it.\n", wait);
    305                 ret = pci_write32(device, eecp + USBLEGSUP_OFFSET,
    306                     USBLEGSUP_OS_CONTROL);
    307                 CHECK_RET_RETURN(ret, "Failed to force OS control: %s.\n",
    308                     str_error(ret));
    309                 /* Check capability type here, A value of 01h
    310                  * identifies the capability as Legacy Support.
    311                  * This extended capability requires one
    312                  * additional 32-bit register for control/status information,
    313                  * and this register is located at offset EECP+04h
    314                  * */
    315                 if ((usblegsup & 0xff) == 1) {
    316                         /* Read the second EEC
    317                          * Legacy Support and Control register */
    318                         uint32_t usblegctlsts;
    319                         ret = pci_read32(
    320                             device, eecp + USBLEGCTLSTS_OFFSET, &usblegctlsts);
    321                         CHECK_RET_RETURN(ret,
    322                             "Failed to get USBLEGCTLSTS: %s.\n", str_error(ret));
    323                         usb_log_debug("USBLEGCTLSTS: %" PRIx32 ".\n",
    324                             usblegctlsts);
    325                         /* Zero SMI enables in legacy control register.
    326                          * It should prevent pre-OS code from interfering. */
    327                         ret = pci_write32(device, eecp + USBLEGCTLSTS_OFFSET,
    328                             0xe0000000); /* three upper bits are WC */
    329                         CHECK_RET_RETURN(ret,
    330                             "Failed(%d) zero USBLEGCTLSTS.\n", ret);
    331                         udelay(10);
    332                         ret = pci_read32(
    333                             device, eecp + USBLEGCTLSTS_OFFSET, &usblegctlsts);
    334                         CHECK_RET_RETURN(ret,
    335                             "Failed to get USBLEGCTLSTS 2: %s.\n",
    336                             str_error(ret));
    337                         usb_log_debug("Zeroed USBLEGCTLSTS: %" PRIx32 ".\n",
    338                             usblegctlsts);
    339                 }
    340         }
    341 
    342 
    343         /* Read again Legacy Support register */
    344         ret = pci_read32(device, eecp + USBLEGSUP_OFFSET, &usblegsup);
    345         CHECK_RET_RETURN(ret, "Failed to read USBLEGSUP: %s.\n", str_error(ret));
    346         usb_log_debug("USBLEGSUP: %" PRIx32 ".\n", usblegsup);
     266#undef CHECK_RET_RETURN
    347267
    348268        /*
    349          * TURN OFF EHCI FOR NOW, DRIVER WILL REINITIALIZE IT
     269         * TURN OFF EHCI FOR NOW, DRIVER WILL REINITIALIZE IT IF NEEDED
    350270         */
    351271
    … …  
    384304
    385305        return ret;
    386 #undef CHECK_RET_RETURN
    387306}
    388307

  • uspace/drv/bus/usb/ehci/res.h

    r43cd499 r14f8fd4  
    3838#include <ddf/driver.h>
    3939
    40 int pci_get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *);
    41 int pci_enable_interrupts(const ddf_dev_t *);
    42 int pci_disable_legacy(const ddf_dev_t *, uintptr_t, size_t, int);
     40int get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *);
     41int enable_interrupts(const ddf_dev_t *);
     42int disable_legacy(const ddf_dev_t *, uintptr_t, size_t);
    4343
    4444#endif

  • uspace/drv/bus/usb/ohci/Makefile

    r43cd499 r14f8fd4  
    5050        ohci_batch.c \
    5151        ohci_endpoint.c \
    52         pci.c \
     52        res.c \
    5353        root_hub.c \
    5454        hw_struct/endpoint_descriptor.c \

  • uspace/drv/bus/usb/ohci/hw_struct/hcca.h

    r43cd499 r14f8fd4  
    4646        uint16_t pad1;
    4747        uint32_t done_head;
    48         uint32_t reserved[29];
    49 } __attribute__((packed, aligned)) hcca_t;
     48        uint32_t reserved[30];
     49} hcca_t;
    5050
    5151static inline void * hcca_get(void)

  • uspace/drv/bus/usb/ohci/ohci.c

    r43cd499 r14f8fd4  
    4242
    4343#include "ohci.h"
    44 #include "pci.h"
     44#include "res.h"
    4545#include "hc.h"
    4646
    … …  
    180180        int irq = 0;
    181181
    182         ret = pci_get_my_registers(device, &reg_base, &reg_size, &irq);
     182        ret = get_my_registers(device, &reg_base, &reg_size, &irq);
    183183        CHECK_RET_DEST_FREE_RETURN(ret,
    184184            "Failed to get register memory addresses for %" PRIun ": %s.\n",
    … …  
    211211        /* Try to enable interrupts */
    212212        bool interrupts = false;
    213         ret = pci_enable_interrupts(device);
     213        ret = enable_interrupts(device);
    214214        if (ret != EOK) {
    215215                usb_log_warning("Failed to enable interrupts: %s."

  • uspace/drv/bus/usb/ohci/res.c

    r43cd499 r14f8fd4  
    3838#include <errno.h>
    3939#include <assert.h>
    40 #include <as.h>
    4140#include <devman.h>
    42 #include <ddi.h>
    43 #include <libarch/ddi.h>
    4441#include <device/hw_res_parsed.h>
    4542
    4643#include <usb/debug.h>
    47 #include <pci_dev_iface.h>
    4844
    49 #include "pci.h"
     45#include "res.h"
    5046
    5147/** Get address of registers and IRQ for given device.
    … …  
    5753 * @return Error code.
    5854 */
    59 int pci_get_my_registers(ddf_dev_t *dev,
     55int get_my_registers(const ddf_dev_t *dev,
    6056    uintptr_t *mem_reg_address, size_t *mem_reg_size, int *irq_no)
    6157{
    … …  
    9894 * @return Error code.
    9995 */
    100 int pci_enable_interrupts(ddf_dev_t *device)
     96int enable_interrupts(const ddf_dev_t *device)
    10197{
    10298        async_sess_t *parent_sess =
    … …  
    106102                return ENOMEM;
    107103       
    108         bool enabled = hw_res_enable_interrupt(parent_sess);
     104        const bool enabled = hw_res_enable_interrupt(parent_sess);
    109105        async_hangup(parent_sess);
    110106       

  • uspace/drv/bus/usb/ohci/res.h

    r43cd499 r14f8fd4  
    3232 * PCI related functions needed by OHCI driver.
    3333 */
    34 #ifndef DRV_OHCI_PCI_H
    35 #define DRV_OHCI_PCI_H
     34#ifndef DRV_OHCI_RES_H
     35#define DRV_OHCI_RES_H
    3636
    3737#include <ddf/driver.h>
    3838
    39 int pci_get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
    40 int pci_enable_interrupts(ddf_dev_t *);
    41 int pci_disable_legacy(ddf_dev_t *);
     39int get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *);
     40int enable_interrupts(const ddf_dev_t *);
    4241
    4342#endif

  • uspace/drv/bus/usb/uhci/Makefile

    r43cd499 r14f8fd4  
    4444        hc.c \
    4545        main.c \
    46         pci.c \
     46        res.c \
    4747        root_hub.c \
    4848        transfer_list.c \

  • uspace/drv/bus/usb/uhci/res.c

    r43cd499 r14f8fd4  
    3939#include <devman.h>
    4040#include <device/hw_res_parsed.h>
     41#include <device/pci.h>
    4142
    42 #include <usb/debug.h>
    43 #include <pci_dev_iface.h>
    44 
    45 #include "pci.h"
     43#include "res.h"
    4644
    4745/** Get I/O address of registers and IRQ for given device.
    … …  
    5351 * @return Error code.
    5452 */
    55 int pci_get_my_registers(const ddf_dev_t *dev,
     53int get_my_registers(const ddf_dev_t *dev,
    5654    uintptr_t *io_reg_address, size_t *io_reg_size, int *irq_no)
    5755{
    5856        assert(dev);
    59         assert(io_reg_address);
    60         assert(io_reg_size);
    61         assert(irq_no);
    6257
    6358        async_sess_t *parent_sess =
    … …  
    9792 * @return Error code.
    9893 */
    99 int pci_enable_interrupts(const ddf_dev_t *device)
     94int enable_interrupts(const ddf_dev_t *device)
    10095{
    10196        async_sess_t *parent_sess =
    … …  
    116111 * @return Error code.
    117112 */
    118 int pci_disable_legacy(const ddf_dev_t *device)
     113int disable_legacy(const ddf_dev_t *device)
    119114{
    120115        assert(device);
    121116
    122         async_sess_t *parent_sess =
    123             devman_parent_device_connect(EXCHANGE_SERIALIZE, device->handle,
    124             IPC_FLAG_BLOCKING);
     117        async_sess_t *parent_sess = devman_parent_device_connect(
     118            EXCHANGE_SERIALIZE, device->handle, IPC_FLAG_BLOCKING);
    125119        if (!parent_sess)
    126120                return ENOMEM;
    127121
    128         /* See UHCI design guide for these values p.45,
    129          * write all WC bits in USB legacy register */
    130         const sysarg_t address = 0xc0;
    131         const sysarg_t value = 0xaf00;
     122        /* See UHCI design guide page 45 for these values.
     123         * Write all WC bits in USB legacy register */
     124        const int rc = pci_config_space_write_16(parent_sess, 0xc0, 0xaf00);
    132125
    133         async_exch_t *exch = async_exchange_begin(parent_sess);
    134 
    135         const int rc = async_req_3_0(exch, DEV_IFACE_ID(PCI_DEV_IFACE),
    136             IPC_M_CONFIG_SPACE_WRITE_16, address, value);
    137 
    138         async_exchange_end(exch);
    139126        async_hangup(parent_sess);
    140 
    141127        return rc;
    142128}

  • uspace/drv/bus/usb/uhci/res.h

    r43cd499 r14f8fd4  
    3838#include <ddf/driver.h>
    3939
    40 int pci_get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *);
    41 int pci_enable_interrupts(const ddf_dev_t *);
    42 int pci_disable_legacy(const ddf_dev_t *);
     40int get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *);
     41int enable_interrupts(const ddf_dev_t *);
     42int disable_legacy(const ddf_dev_t *);
    4343
    4444#endif

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

    r43cd499 r14f8fd4  
    4141
    4242#include "uhci.h"
    43 #include "pci.h"
    44 
     43
     44#include "res.h"
    4545#include "hc.h"
    4646#include "root_hub.h"
    … …  
    4949 * and USB root hub */
    5050typedef struct uhci {
    51         /** Pointer to DDF represenation of UHCI host controller */
     51        /** Pointer to DDF representation of UHCI host controller */
    5252        ddf_fun_t *hc_fun;
    53         /** Pointer to DDF represenation of UHCI root hub */
     53        /** Pointer to DDF representation of UHCI root hub */
    5454        ddf_fun_t *rh_fun;
    5555
    56         /** Internal driver's represenation of UHCI host controller */
     56        /** Internal driver's representation of UHCI host controller */
    5757        hc_t hc;
    58         /** Internal driver's represenation of UHCI root hub */
     58        /** Internal driver's representation of UHCI root hub */
    5959        rh_t rh;
    6060} uhci_t;
    … …  
    187187        int irq = 0;
    188188
    189         ret = pci_get_my_registers(device, &reg_base, &reg_size, &irq);
     189        ret = get_my_registers(device, &reg_base, &reg_size, &irq);
    190190        CHECK_RET_DEST_FREE_RETURN(ret,
    191191            "Failed to get I/O addresses for %" PRIun ": %s.\n",
    … …  
    194194            (void *) reg_base, reg_size, irq);
    195195
    196         ret = pci_disable_legacy(device);
     196        ret = disable_legacy(device);
    197197        CHECK_RET_DEST_FREE_RETURN(ret,
    198198            "Failed to disable legacy USB: %s.\n", str_error(ret));
    … …  
    220220
    221221        bool interrupts = false;
    222         ret = pci_enable_interrupts(device);
     222        ret = enable_interrupts(device);
    223223        if (ret != EOK) {
    224224                usb_log_warning("Failed to enable interrupts: %s."

  • uspace/lib/c/arch/amd64/include/fibril.h

    r43cd499 r14f8fd4  
    3838#include <sys/types.h>
    3939
    40 /* According to ABI the stack MUST be aligned on
     40/*
     41 * According to ABI the stack MUST be aligned on
    4142 * 16-byte boundary. If it is not, the va_arg calling will
    4243 * panic sooner or later
    4344 */
    44 #define SP_DELTA     16
     45#define SP_DELTA  16
    4546
    4647#define context_set(c, _pc, stack, size, ptls) \

  • uspace/lib/c/arch/arm32/include/fibril.h

    r43cd499 r14f8fd4  
    2727 */
    2828
    29 /** @addtogroup libcarm32       
     29/** @addtogroup libcarm32
    3030 * @{
    3131 */
    … …  
    4242
    4343/** Size of a stack item */
    44 #define STACK_ITEM_SIZE         4
     44#define STACK_ITEM_SIZE  4
    4545
    4646/** Stack alignment - see <a href="http://www.arm.com/support/faqdev/14269.html">ABI</a> for details */
    47 #define STACK_ALIGNMENT         8
     47#define STACK_ALIGNMENT  8
    4848
    49 #define SP_DELTA        (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
     49#define SP_DELTA  (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
    5050
    5151
    52 /** Sets data to the context. 
    53  * 
     52/** Sets data to the context.
     53 *
    5454 *  @param c     Context (#context_t).
    5555 *  @param _pc   Program counter.
    … …  
    6262                (c)->pc = (sysarg_t) (_pc); \
    6363                (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \
    64                 (c)->tls = ((sysarg_t)(ptls)) + sizeof(tcb_t) + ARM_TP_OFFSET; \
     64                (c)->tls = ((sysarg_t)(ptls)) + sizeof(tcb_t) + ARM_TP_OFFSET; \
    6565                (c)->fp = 0; \
    6666        } while (0)
    6767
    68 /** Fibril context. 
     68/** Fibril context.
    6969 *
    7070 *  Only registers preserved accross function calls are included. r9 is used
    … …  
    9191}
    9292
    93 
    9493#endif
    9594

  • uspace/lib/c/arch/ia32/include/fibril.h

    r43cd499 r14f8fd4  
    3838#include <sys/types.h>
    3939
    40 /* According to ABI the stack MUST be aligned on
     40/*
     41 * According to ABI the stack MUST be aligned on
    4142 * 16-byte boundary. If it is not, the va_arg calling will
    4243 * panic sooner or later

  • uspace/lib/c/arch/ia64/include/fibril.h

    r43cd499 r14f8fd4  
    2727 */
    2828
    29 /** @addtogroup libcia64       
     29/** @addtogroup libcia64
    3030 * @{
    3131 */
    … …  
    4545 * No need to allocate scratch area.
    4646 */
    47 #define SP_DELTA        (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
     47#define SP_DELTA  (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
    4848
    49 #define PFM_MASK        (~0x3fffffffff)
     49#define PFM_MASK  (~0x3fffffffff)
    5050
    51 #define PSTHREAD_INITIAL_STACK_PAGES_NO 2
     51#define PSTHREAD_INITIAL_STACK_PAGES_NO  2
     52
    5253/* Stack is divided into two equal parts (for memory stack and register stack). */
    53 #define PSTHREAD_INITIAL_STACK_DIVISION 2 
     54#define PSTHREAD_INITIAL_STACK_DIVISION  2
    5455
    55 #define context_set(c, _pc, stack, size, tls)                                                           \
    56         do {                                                                                            \
    57                 (c)->pc = (uint64_t) _pc;                                                               \
    58                 (c)->bsp = ((uint64_t) stack) + size / PSTHREAD_INITIAL_STACK_DIVISION;                                                         \
    59                 (c)->ar_pfs &= PFM_MASK;                                                                \
    60                 (c)->sp = ((uint64_t) stack) + ALIGN_UP((size / PSTHREAD_INITIAL_STACK_DIVISION), STACK_ALIGNMENT) - SP_DELTA;          \
    61                 (c)->tp = (uint64_t) tls;                                                               \
    62         } while (0);
    63        
     56#define context_set(c, _pc, stack, size, tls) \
     57        do { \
     58                (c)->pc = (uint64_t) _pc; \
     59                (c)->bsp = ((uint64_t) stack) + \
     60                    size / PSTHREAD_INITIAL_STACK_DIVISION; \
     61                (c)->ar_pfs &= PFM_MASK; \
     62                (c)->sp = ((uint64_t) stack) + \
     63                    ALIGN_UP((size / PSTHREAD_INITIAL_STACK_DIVISION), STACK_ALIGNMENT) - \
     64                    SP_DELTA; \
     65                (c)->tp = (uint64_t) tls; \
     66        } while (0)
    6467
    6568/*

  • uspace/lib/c/arch/mips32/Makefile.inc

    r43cd499 r14f8fd4  
    2828
    2929ARCH_SOURCES = \
    30         arch/$(UARCH)/src/entry.s \
    31         arch/$(UARCH)/src/entryjmp.s \
    32         arch/$(UARCH)/src/thread_entry.s \
     30        arch/$(UARCH)/src/entry.S \
     31        arch/$(UARCH)/src/entryjmp.S \
     32        arch/$(UARCH)/src/thread_entry.S \
    3333        arch/$(UARCH)/src/syscall.c \
    3434        arch/$(UARCH)/src/fibril.S \

  • uspace/lib/c/arch/mips32/include/atomic.h

    r43cd499 r14f8fd4  
    6767                "       ll %0, %1\n"
    6868                "       addu %0, %0, %3\n"      /* same as add, but never traps on overflow */
    69                 "       move %2, %0\n"
     69                "       move %2, %0\n"
    7070                "       sc %0, %1\n"
    7171                "       beq %0, %4, 1b\n"       /* if the atomic operation failed, try again */

  • uspace/lib/c/arch/mips32/include/config.h

    r43cd499 r14f8fd4  
    3636#define LIBC_mips32_CONFIG_H_
    3737
    38 #define PAGE_WIDTH      14
    39 #define PAGE_SIZE       (1 << PAGE_WIDTH)
     38#define PAGE_WIDTH  14
     39#define PAGE_SIZE   (1 << PAGE_WIDTH)
    4040
    4141#endif

  • uspace/lib/c/arch/mips32/include/faddr.h

    r43cd499 r14f8fd4  
    3838#include <libarch/types.h>
    3939
    40 #define FADDR(fptr)             ((uintptr_t) (fptr))
     40#define FADDR(fptr)  ((uintptr_t) (fptr))
    4141
    4242#endif

  • uspace/lib/c/arch/mips32/include/fibril.h

    r43cd499 r14f8fd4  
    3838
    3939#include <sys/types.h>
     40#include <libarch/stack.h>
     41#include <align.h>
    4042
    41 /* We define our own context_set, because we need to set
    42  * the TLS pointer to the tcb+0x7000
     43#define SP_DELTA  (ABI_STACK_FRAME + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
     44
     45/*
     46 * We define our own context_set, because we need to set
     47 * the TLS pointer to the tcb + 0x7000
    4348 *
    4449 * See tls_set in thread.h
    4550 */
    46 #define context_set(c, _pc, stack, size, ptls)                  \
    47         (c)->pc = (sysarg_t) (_pc);                             \
    48         (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA;     \
    49         (c)->tls = ((sysarg_t)(ptls)) + 0x7000 + sizeof(tcb_t);
    50 
    51 
    52 /* +16 is just for sure that the called function
    53  * have space to store it's arguments
    54  */
    55 #define SP_DELTA        (8+16)
     51#define context_set(c, _pc, stack, size, ptls) \
     52        do { \
     53                (c)->pc = (sysarg_t) (_pc); \
     54                (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \
     55                (c)->tls = ((sysarg_t)(ptls)) + 0x7000 + sizeof(tcb_t); \
     56        } while (0)
    5657
    5758typedef struct  {

  • uspace/lib/c/arch/mips32/src/entry.S

    r43cd499 r14f8fd4  
    2727#
    2828
     29#include <libarch/stack.h>
     30
    2931.text
    3032.section .init, "ax"
    … …  
    4143.ent __entry
    4244__entry:
    43         .frame $sp, 32, $31
    44         .cpload $25
     45        .frame $sp, ABI_STACK_FRAME, $ra
     46        .cpload $t9
    4547       
    46         # FIXME: Reflect exactly ABI specs here
     48        # Allocate the stack frame.
     49        addiu $sp, -ABI_STACK_FRAME
    4750       
    48         addiu $sp, -32
    49         .cprestore 16   # Allow PIC code
     51        # Allow PIC code
     52        .cprestore 16
    5053       
    51         # Pass pcb_ptr to __main() as the first argument. pcb_ptr is already
     54        # Pass pcb_ptr to __main() as the first argument. It is already
    5255        # in $a0. As the first argument is passed in $a0, no operation
    5356        # is needed.
    … …  
    5558        jal __main
    5659        nop
    57 .end
     60       
     61        #
     62        # Not reached.
     63        #
     64        addiu $sp, ABI_STACK_FRAME
     65.end __entry

  • uspace/lib/c/arch/mips32/src/entryjmp.S

    r43cd499 r14f8fd4  
    2727#
    2828
     29#include <libarch/stack.h>
     30
    2931.text
    3032.section .text
    … …  
    4143entry_point_jmp:
    4244        # tmp := entry_point
    43         move $25, $a0
     45        move $t9, $a0
    4446       
    4547        # Pass pcb to the entry point in $a0
    4648        move $a0, $a1
    47         jr $25
    48         nop
    49 .end
     49       
     50        jr $t9
     51        addiu $sp, -ABI_STACK_FRAME
     52        addiu $sp, ABI_STACK_FRAME
     53.end entry_point_jmp

  • uspace/lib/c/arch/mips32/src/fibril.S

    r43cd499 r14f8fd4  
    3333
    3434#include <libarch/context_offset.h>
    35        
     35
    3636.global context_save
    3737.global context_restore
    38        
     38
    3939context_save:
    4040        CONTEXT_SAVE_ARCH_CORE $a0
    41 
     41       
    4242        # context_save returns 1
    4343        j $ra
    44         li $v0, 1       
    45        
     44        li $v0, 1
     45
    4646context_restore:
    4747        CONTEXT_RESTORE_ARCH_CORE $a0
    48 
    49         # Just for the jump into first function, but one instruction
    50         # should not bother us
    51         move $t9, $ra   
     48       
     49        # Just for the jump into first function,
     50        # but one instruction should not bother us
     51        move $t9, $ra
     52       
    5253        # context_restore returns 0
    5354        j $ra
    54         xor $v0, $v0   
    55 
     55        xor $v0, $v0

  • uspace/lib/c/arch/mips32/src/syscall.c

    r43cd499 r14f8fd4  
    5757                  "r" (__mips_reg_t1),
    5858                  "r" (__mips_reg_v0)
    59                 : "%ra" /* We are a function call, although C does not
    60                          * know it */
     59                /*
     60                 * We are a function call, although C
     61                 * does not know it.
     62                 */
     63                : "%ra"
    6164        );
    6265       

  • uspace/lib/c/arch/mips32/src/thread_entry.S

    r43cd499 r14f8fd4  
    2727#
    2828
     29#include <libarch/stack.h>
     30
    2931.text
    3032
    … …  
    4042.ent __thread_entry
    4143__thread_entry:
    42         .frame $sp, 32, $31
    43         .cpload $25
     44        .frame $sp, ABI_STACK_FRAME, $ra
     45        .cpload $t9
    4446       
    4547        #
    4648        # v0 contains address of uarg.
    4749        #
    48         add $4, $2, 0
     50        add $a0, $v0, 0
    4951       
    50         addiu $sp, -32
     52        # Allocate the stack frame.
     53        addiu $sp, -ABI_STACK_FRAME
     54       
     55        # Allow PIC code
    5156        .cprestore 16
    5257       
    … …  
    5762        # Not reached.
    5863        #
     64        addiu $sp, ABI_STACK_FRAME
    5965.end __thread_entry

  • uspace/lib/c/arch/mips32eb/Makefile.inc

    r43cd499 r14f8fd4  
    2828
    2929ARCH_SOURCES = \
    30         arch/$(UARCH)/src/entry.s \
    31         arch/$(UARCH)/src/entryjmp.s \
    32         arch/$(UARCH)/src/thread_entry.s \
     30        arch/$(UARCH)/src/entry.S \
     31        arch/$(UARCH)/src/entryjmp.S \
     32        arch/$(UARCH)/src/thread_entry.S \
    3333        arch/$(UARCH)/src/syscall.c \
    3434        arch/$(UARCH)/src/fibril.S \

  • uspace/lib/c/arch/mips64/Makefile.inc

    r43cd499 r14f8fd4  
    2828
    2929ARCH_SOURCES = \
    30         arch/$(UARCH)/src/entry.s \
    31         arch/$(UARCH)/src/entryjmp.s \
    32         arch/$(UARCH)/src/thread_entry.s \
     30        arch/$(UARCH)/src/entry.S \
     31        arch/$(UARCH)/src/entryjmp.S \
     32        arch/$(UARCH)/src/thread_entry.S \
    3333        arch/$(UARCH)/src/syscall.c \
    3434        arch/$(UARCH)/src/fibril.S \

  • uspace/lib/c/arch/mips64/include/fibril.h

    r43cd499 r14f8fd4  
    3838
    3939#include <sys/types.h>
     40#include <libarch/stack.h>
     41#include <align.h>
    4042
    41 /* We define our own context_set, because we need to set
    42  * the TLS pointer to the tcb+0x7000
     43#define SP_DELTA  (ABI_STACK_FRAME + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
     44
     45/*
     46 * We define our own context_set, because we need to set
     47 * the TLS pointer to the tcb + 0x7000
    4348 *
    4449 * See tls_set in thread.h
    4550 */
    4651#define context_set(c, _pc, stack, size, ptls) \
    47         (c)->pc = (sysarg_t) (_pc); \
    48         (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \
    49         (c)->tls = ((sysarg_t)(ptls)) + 0x7000 + sizeof(tcb_t);
    50 
    51 /* +16 is just for sure that the called function
    52  * have space to store it's arguments
    53  */
    54 #define SP_DELTA  (8 + 16)
     52        do { \
     53                (c)->pc = (sysarg_t) (_pc); \
     54                (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \
     55                (c)->tls = ((sysarg_t)(ptls)) + 0x7000 + sizeof(tcb_t); \
     56        } while (0)
    5557
    5658typedef struct {

  • uspace/lib/c/arch/mips64/src/entry.S

    r43cd499 r14f8fd4  
    2727#
    2828
     29#include <libarch/stack.h>
     30
    2931.text
    3032.section .init, "ax"
    … …  
    4143.ent __entry
    4244__entry:
    43         .frame $sp, 32, $31
    44         .cpload $25
    45 
    46         # Mips o32 may store its arguments on stack, make space (16 bytes),
    47         # so that it could work with -O0
    48         # Make space additional 16 bytes for the stack frame
    49 
    50         addiu $sp, -32
    51         .cprestore 16   # Allow PIC code
    52 
    53         # Pass pcb_ptr to __main() as the first argument. pcb_ptr is already
     45        .frame $sp, ABI_STACK_FRAME, $ra
     46        .cpload $t9
     47       
     48        # Allocate the stack frame.
     49        addiu $sp, -ABI_STACK_FRAME
     50       
     51        # Allow PIC code
     52        .cprestore 16
     53       
     54        # Pass pcb_ptr to __main() as the first argument. It is already
    5455        # in $a0. As the first argument is passed in $a0, no operation
    5556        # is needed.
    56 
     57       
    5758        jal __main
    5859        nop
    59 .end
     60       
     61        #
     62        # Not reached.
     63        #
     64        addiu $sp, ABI_STACK_FRAME
     65.end __entry

  • uspace/lib/c/arch/mips64/src/entryjmp.S

    r43cd499 r14f8fd4  
    2727#
    2828
     29#include <libarch/stack.h>
     30
    2931.text
    3032.section .text
    … …  
    3436## void entry_point_jmp(void *entry_point, void *pcb);
    3537#
    36 # $a0 (=$4)     contains entry_point
    37 # $a1 (=$5)     contains pcb
     38# $a0 (=$4) contains entry_point
     39# $a1 (=$5) contains pcb
    3840#
    3941# Jump to program entry point
    … …  
    4143entry_point_jmp:
    4244        # tmp := entry_point
    43         move $25, $a0
    44 
     45        move $t9, $a0
     46       
    4547        # Pass pcb to the entry point in $a0
    4648        move $a0, $a1
    47         jr $25
    48         nop
    49 .end
     49       
     50        jr $t9
     51        addiu $sp, -ABI_STACK_FRAME
     52        addiu $sp, ABI_STACK_FRAME
     53.end entry_point_jmp

  • uspace/lib/c/arch/mips64/src/thread_entry.S

    r43cd499 r14f8fd4  
    2727#
    2828
     29#include <libarch/stack.h>
     30
    2931.text
    30        
     32
    3133.set noat
    3234.set noreorder
    3335.option pic2
    34        
     36
    3537.globl __thread_entry
    3638
    … …  
    4042.ent __thread_entry
    4143__thread_entry:
    42         .frame $sp, 32, $31
    43         .cpload $25
    44 
     44        .frame $sp, ABI_STACK_FRAME, $ra
     45        .cpload $t9
     46       
    4547        #
    4648        # v0 contains address of uarg.
    4749        #
    48         add $4, $2, 0
    49         # Mips o32 may store its arguments on stack, make space
    50         addiu $sp, -32
     50        add $a0, $v0, 0
     51       
     52        # Allocate the stack frame.
     53        addiu $sp, -ABI_STACK_FRAME
     54       
     55        # Allow PIC code
    5156        .cprestore 16
    5257       
    5358        jal __thread_main
    5459        nop
    55                
     60       
    5661        #
    5762        # Not reached.
    5863        #
     64        addiu $sp, ABI_STACK_FRAME
    5965.end __thread_entry

  • uspace/lib/c/arch/ppc32/include/fibril.h

    r43cd499 r14f8fd4  
    2727 */
    2828
    29 /** @addtogroup libcppc32       
     29/** @addtogroup libcppc32
    3030 * @{
    3131 */
    … …  
    3838#include <sys/types.h>
    3939
    40 /* We define our own context_set, because we need to set
    41  * the TLS pointer to the tcb+0x7000
     40#define SP_DELTA  16
     41
     42/*
     43 * We define our own context_set, because we need to set
     44 * the TLS pointer to the tcb + 0x7000
    4245 *
    4346 * See tls_set in thread.h
    4447 */
    45 #define context_set(c, _pc, stack, size, ptls)                  \
    46         (c)->pc = (sysarg_t) (_pc);                             \
    47         (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA;     \
    48         (c)->tls = ((sysarg_t) (ptls)) + 0x7000 + sizeof(tcb_t);
    49 
    50 #define SP_DELTA        16
     48#define context_set(c, _pc, stack, size, ptls) \
     49        do { \
     50                (c)->pc = (sysarg_t) (_pc); \
     51                (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \
     52                (c)->tls = ((sysarg_t) (ptls)) + 0x7000 + sizeof(tcb_t); \
     53        } while (0)
    5154
    5255typedef struct {

  • uspace/lib/c/arch/sparc64/include/fibril.h

    r43cd499 r14f8fd4  
    4040#include <align.h>
    4141
    42 #define SP_DELTA        (STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE)
     42#define SP_DELTA  (STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE)
    4343
    4444#define context_set(c, _pc, stack, size, ptls) \
    … …  
    5050                (c)->tp = (uint64_t) ptls; \
    5151        } while (0)
    52        
     52
    5353/*
    5454 * Save only registers that must be preserved across

  • uspace/lib/c/generic/str.c

    r43cd499 r14f8fd4  
    259259       
    260260        return offset;
     261}
     262
     263/** Get size of string with size limit.
     264 *
     265 * Get the number of bytes which are used by the string @a str
     266 * (excluding the NULL-terminator), but no more than @max_size bytes.
     267 *
     268 * @param str      String to consider.
     269 * @param max_size Maximum number of bytes to measure.
     270 *
     271 * @return Number of bytes used by the string
     272 *
     273 */
     274size_t str_nsize(const char *str, size_t max_size)
     275{
     276        size_t size = 0;
     277       
     278        while ((*str++ != 0) && (size < max_size))
     279                size++;
     280       
     281        return size;
     282}
     283
     284/** Get size of wide string with size limit.
     285 *
     286 * Get the number of bytes which are used by the wide string @a str
     287 * (excluding the NULL-terminator), but no more than @max_size bytes.
     288 *
     289 * @param str      Wide string to consider.
     290 * @param max_size Maximum number of bytes to measure.
     291 *
     292 * @return Number of bytes used by the wide string
     293 *
     294 */
     295size_t wstr_nsize(const wchar_t *str, size_t max_size)
     296{
     297        return (wstr_nlength(str, max_size) * sizeof(wchar_t));
    261298}
    262299

  • uspace/lib/c/generic/sysinfo.c

    r43cd499 r14f8fd4  
    4040#include <bool.h>
    4141
     42/** Get sysinfo keys size
     43 *
     44 * @param path  Sysinfo path.
     45 * @param value Pointer to store the keys size.
     46 *
     47 * @return EOK if the keys were successfully read.
     48 *
     49 */
     50static int sysinfo_get_keys_size(const char *path, size_t *size)
     51{
     52        return (int) __SYSCALL3(SYS_SYSINFO_GET_KEYS_SIZE, (sysarg_t) path,
     53            (sysarg_t) str_size(path), (sysarg_t) size);
     54}
     55
     56/** Get sysinfo keys
     57 *
     58 * @param path  Sysinfo path.
     59 * @param value Pointer to store the keys size.
     60 *
     61 * @return Keys read from sysinfo or NULL if the
     62 *         sysinfo item has no subkeys.
     63 *         The returned non-NULL pointer should be
     64 *         freed by free().
     65 *
     66 */
     67char *sysinfo_get_keys(const char *path, size_t *size)
     68{
     69        /*
     70         * The size of the keys might change during time.
     71         * Unfortunatelly we cannot allocate the buffer
     72         * and transfer the keys as a single atomic operation.
     73         */
     74       
     75        /* Get the keys size */
     76        int ret = sysinfo_get_keys_size(path, size);
     77        if ((ret != EOK) || (size == 0)) {
     78                /*
     79                 * Item with no subkeys.
     80                 */
     81                *size = 0;
     82                return NULL;
     83        }
     84       
     85        char *data = malloc(*size);
     86        if (data == NULL) {
     87                *size = 0;
     88                return NULL;
     89        }
     90       
     91        /* Get the data */
     92        size_t sz;
     93        ret = __SYSCALL5(SYS_SYSINFO_GET_KEYS, (sysarg_t) path,
     94            (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size,
     95            (sysarg_t) &sz);
     96        if (ret == EOK) {
     97                *size = sz;
     98                return data;
     99        }
     100       
     101        free(data);
     102        *size = 0;
     103        return NULL;
     104}
     105
    42106/** Get sysinfo item type
    43107 *
    … …  
    70134/** Get sysinfo binary data size
    71135 *
    72  * @param path  Sysinfo path.
    73  * @param value Pointer to store the binary data size.
     136 * @param path Sysinfo path.
     137 * @param size Pointer to store the binary data size.
    74138 *
    75139 * @return EOK if the value was successfully read and
    … …  
    85149/** Get sysinfo binary data
    86150 *
    87  * @param path  Sysinfo path.
    88  * @param value Pointer to store the binary data size.
     151 * @param path Sysinfo path.
     152 * @param size Pointer to store the binary data size.
    89153 *
    90154 * @return Binary data read from sysinfo or NULL if the
    … …  
    134198}
    135199
     200/** Get sysinfo property
     201 *
     202 * @param path Sysinfo path.
     203 * @param name Property name.
     204 * @param size Pointer to store the binary data size.
     205 *
     206 * @return Property value read from sysinfo or NULL if the
     207 *         sysinfo item value type is not binary data.
     208 *         The returned non-NULL pointer should be
     209 *         freed by free().
     210 *
     211 */
     212void *sysinfo_get_property(const char *path, const char *name, size_t *size)
     213{
     214        size_t total_size;
     215        void *data = sysinfo_get_data(path, &total_size);
     216        if ((data == NULL) || (total_size == 0)) {
     217                *size = 0;
     218                return NULL;
     219        }
     220       
     221        size_t pos = 0;
     222        while (pos < total_size) {
     223                /* Process each property with sanity checks */
     224                size_t cur_size = str_nsize(data + pos, total_size - pos);
     225                if (((char *) data)[pos + cur_size] != 0)
     226                        break;
     227               
     228                bool found = (str_cmp(data + pos, name) == 0);
     229               
     230                pos += cur_size + 1;
     231                if (pos >= total_size)
     232                        break;
     233               
     234                /* Process value size */
     235                size_t value_size;
     236                memcpy(&value_size, data + pos, sizeof(value_size));
     237               
     238                pos += sizeof(value_size);
     239                if ((pos >= total_size) || (pos + value_size > total_size))
     240                        break;
     241               
     242                if (found) {
     243                        void *value = malloc(value_size);
     244                        if (value == NULL)
     245                                break;
     246                       
     247                        memcpy(value, data + pos, value_size);
     248                        free(data);
     249                       
     250                        *size = value_size;
     251                        return value;
     252                }
     253               
     254                pos += value_size;
     255        }
     256       
     257        free(data);
     258       
     259        *size = 0;
     260        return NULL;
     261}
     262
    136263/** @}
    137264 */

  • uspace/lib/c/include/fibril.h

    r43cd499 r14f8fd4  
    4141
    4242#define context_set_generic(c, _pc, stack, size, ptls) \
    43         (c)->pc = (sysarg_t) (_pc); \
    44         (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \
    45         (c)->tls = (sysarg_t) (ptls);
     43        do { \
     44                (c)->pc = (sysarg_t) (_pc); \
     45                (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \
     46                (c)->tls = (sysarg_t) (ptls); \
     47        } while (0)
    4648
    4749#define FIBRIL_SERIALIZED  1

  • uspace/lib/c/include/str.h

    r43cd499 r14f8fd4  
    6060extern size_t str_size(const char *str);
    6161extern size_t wstr_size(const wchar_t *str);
     62
     63extern size_t str_nsize(const char *str, size_t max_size);
     64extern size_t wstr_nsize(const wchar_t *str, size_t max_size);
    6265
    6366extern size_t str_lsize(const char *str, size_t max_len);

  • uspace/lib/c/include/sysinfo.h

    r43cd499 r14f8fd4  
    4040#include <abi/sysinfo.h>
    4141
     42extern char *sysinfo_get_keys(const char *, size_t *);
    4243extern sysinfo_item_val_type_t sysinfo_get_val_type(const char *);
    4344extern int sysinfo_get_value(const char *, sysarg_t *);
    4445extern void *sysinfo_get_data(const char *, size_t *);
     46extern void *sysinfo_get_property(const char *, const char *, size_t *);
    4547
    4648#endif

  • uspace/srv/fs/exfat/exfat_bitmap.c

    r43cd499 r14f8fd4  
    4848
    4949
    50 int bitmap_is_free(exfat_bs_t *bs, service_id_t service_id,
     50int exfat_bitmap_is_free(exfat_bs_t *bs, service_id_t service_id,
    5151    exfat_cluster_t clst)
    5252{
    … …  
    8989}
    9090
    91 int bitmap_set_cluster(exfat_bs_t *bs, service_id_t service_id,
     91int exfat_bitmap_set_cluster(exfat_bs_t *bs, service_id_t service_id,
    9292    exfat_cluster_t clst)
    9393{
    … …  
    124124}
    125125
    126 int bitmap_clear_cluster(exfat_bs_t *bs, service_id_t service_id,
     126int exfat_bitmap_clear_cluster(exfat_bs_t *bs, service_id_t service_id,
    127127    exfat_cluster_t clst)
    128128{
    … …  
    160160}
    161161
    162 int bitmap_set_clusters(exfat_bs_t *bs, service_id_t service_id,
     162int exfat_bitmap_set_clusters(exfat_bs_t *bs, service_id_t service_id,
    163163    exfat_cluster_t firstc, exfat_cluster_t count)
    164164{
    … …  
    168168
    169169        while (clst < firstc + count ) {
    170                 rc = bitmap_set_cluster(bs, service_id, clst);
     170                rc = exfat_bitmap_set_cluster(bs, service_id, clst);
    171171                if (rc != EOK) {
    172172                        if (clst - firstc > 0)
    173                                 (void) bitmap_clear_clusters(bs, service_id,
     173                                (void) exfat_bitmap_clear_clusters(bs, service_id,
    174174                                    firstc, clst - firstc);
    175175                        return rc;
    … …  
    180180}
    181181
    182 int bitmap_clear_clusters(exfat_bs_t *bs, service_id_t service_id,
     182int exfat_bitmap_clear_clusters(exfat_bs_t *bs, service_id_t service_id,
    183183    exfat_cluster_t firstc, exfat_cluster_t count)
    184184{
    … …  
    188188
    189189        while (clst < firstc + count) {
    190                 rc = bitmap_clear_cluster(bs, service_id, clst);
     190                rc = exfat_bitmap_clear_cluster(bs, service_id, clst);
    191191                if (rc != EOK)
    192192                        return rc;
    … …  
    196196}
    197197
    198 int bitmap_alloc_clusters(exfat_bs_t *bs, service_id_t service_id,
     198int exfat_bitmap_alloc_clusters(exfat_bs_t *bs, service_id_t service_id,
    199199    exfat_cluster_t *firstc, exfat_cluster_t count)
    200200{
    … …  
    204204        while (startc < DATA_CNT(bs) + 2) {
    205205                endc = startc;
    206                 while (bitmap_is_free(bs, service_id, endc) == EOK) {
     206                while (exfat_bitmap_is_free(bs, service_id, endc) == EOK) {
    207207                        if ((endc - startc) + 1 == count) {
    208208                                *firstc = startc;
    209                                 return bitmap_set_clusters(bs, service_id, startc, count);
     209                                return exfat_bitmap_set_clusters(bs, service_id, startc, count);
    210210                        } else
    211211                                endc++;
    … …  
    217217
    218218
    219 int bitmap_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
     219int exfat_bitmap_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
    220220    exfat_cluster_t count)
    221221{
    222222        if (nodep->firstc == 0) {
    223                 return bitmap_alloc_clusters(bs, nodep->idx->service_id,
     223                return exfat_bitmap_alloc_clusters(bs, nodep->idx->service_id,
    224224                    &nodep->firstc, count);
    225225        } else {
    … …  
    228228
    229229                clst = lastc + 1;
    230                 while (bitmap_is_free(bs, nodep->idx->service_id, clst) == EOK) {
     230                while (exfat_bitmap_is_free(bs, nodep->idx->service_id, clst) == EOK) {
    231231                        if (clst - lastc == count){
    232                                 return bitmap_set_clusters(bs, nodep->idx->service_id,
     232                                return exfat_bitmap_set_clusters(bs, nodep->idx->service_id,
    233233                                    lastc + 1, count);
    234234                        } else
    … …  
    240240
    241241
    242 int bitmap_free_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
     242int exfat_bitmap_free_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
    243243    exfat_cluster_t count)
    244244{
    … …  
    247247        lastc -= count;
    248248
    249         return bitmap_clear_clusters(bs, nodep->idx->service_id, lastc + 1, count);
    250 }
    251 
    252 
    253 int bitmap_replicate_clusters(exfat_bs_t *bs, exfat_node_t *nodep)
     249        return exfat_bitmap_clear_clusters(bs, nodep->idx->service_id, lastc + 1, count);
     250}
     251
     252
     253int exfat_bitmap_replicate_clusters(exfat_bs_t *bs, exfat_node_t *nodep)
    254254{
    255255        int rc;

  • uspace/srv/fs/exfat/exfat_bitmap.h

    r43cd499 r14f8fd4  
    4242struct exfat_bs;
    4343
    44 extern int bitmap_alloc_clusters(struct exfat_bs *, service_id_t,
     44extern int exfat_bitmap_alloc_clusters(struct exfat_bs *, service_id_t,
    4545    exfat_cluster_t *, exfat_cluster_t);
    46 extern int bitmap_append_clusters(struct exfat_bs *, struct exfat_node *,
     46extern int exfat_bitmap_append_clusters(struct exfat_bs *, struct exfat_node *,
    4747    exfat_cluster_t);
    48 extern int bitmap_free_clusters(struct exfat_bs *, struct exfat_node *,
     48extern int exfat_bitmap_free_clusters(struct exfat_bs *, struct exfat_node *,
    4949    exfat_cluster_t);
    50 extern int bitmap_replicate_clusters(struct exfat_bs *, struct exfat_node *);
     50extern int exfat_bitmap_replicate_clusters(struct exfat_bs *, struct exfat_node *);
    5151
    52 extern int bitmap_is_free(struct exfat_bs *, service_id_t, exfat_cluster_t);
    53 extern int bitmap_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
    54 extern int bitmap_clear_cluster(struct exfat_bs *, service_id_t,
     52extern int exfat_bitmap_is_free(struct exfat_bs *, service_id_t, exfat_cluster_t);
     53extern int exfat_bitmap_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
     54extern int exfat_bitmap_clear_cluster(struct exfat_bs *, service_id_t,
    5555    exfat_cluster_t);
    5656
    57 extern int bitmap_set_clusters(struct exfat_bs *, service_id_t,
     57extern int exfat_bitmap_set_clusters(struct exfat_bs *, service_id_t,
    5858    exfat_cluster_t, exfat_cluster_t);
    59 extern int bitmap_clear_clusters(struct exfat_bs *, service_id_t,
     59extern int exfat_bitmap_clear_clusters(struct exfat_bs *, service_id_t,
    6060    exfat_cluster_t, exfat_cluster_t);
    6161

  • uspace/srv/fs/exfat/exfat_dentry.c

    r43cd499 r14f8fd4  
    130130}
    131131
    132 size_t utf16_length(const uint16_t *wstr)
     132size_t exfat_utf16_length(const uint16_t *wstr)
    133133{
    134134        size_t len = 0;

  • uspace/srv/fs/exfat/exfat_dentry.h

    r43cd499 r14f8fd4  
    160160extern bool exfat_valid_name(const char *);
    161161
    162 extern size_t utf16_length(const uint16_t *);
     162extern size_t exfat_utf16_length(const uint16_t *);
    163163
    164164

  • uspace/srv/fs/exfat/exfat_directory.c

    r43cd499 r14f8fd4  
    371371        ds.stream.valid_data_size = 0;
    372372        ds.stream.data_size = 0;
    373         ds.stream.name_size = utf16_length(wname);
     373        ds.stream.name_size = exfat_utf16_length(wname);
    374374        ds.stream.hash = host2uint16_t_le(exfat_name_hash(wname, uctable,
    375375            uctable_chars));

  • uspace/srv/fs/exfat/exfat_fat.c

    r43cd499 r14f8fd4  
    314314            clst++) {
    315315                /* Need to rewrite because of multiple exfat_bitmap_get calls */
    316                 if (bitmap_is_free(bs, service_id, clst) == EOK) {
     316                if (exfat_bitmap_is_free(bs, service_id, clst) == EOK) {
    317317                        /*
    318318                         * The cluster is free. Put it into our stack
    … …  
    325325                                goto exit_error;
    326326                        found++;
    327                         rc = bitmap_set_cluster(bs, service_id, clst);
     327                        rc = exfat_bitmap_set_cluster(bs, service_id, clst);
    328328                        if (rc != EOK)
    329329                                goto exit_error;
    … …  
    346346        /* If something wrong - free the clusters */
    347347        while (found--) {
    348                 (void) bitmap_clear_cluster(bs, service_id, lifo[found]);
     348                (void) exfat_bitmap_clear_cluster(bs, service_id, lifo[found]);
    349349                (void) exfat_set_cluster(bs, service_id, lifo[found], 0);
    350350        }
    … …  
    378378                if (rc != EOK)
    379379                        return rc;
    380                 rc = bitmap_clear_cluster(bs, service_id, firstc);
     380                rc = exfat_bitmap_clear_cluster(bs, service_id, firstc);
    381381                if (rc != EOK)
    382382                        return rc;

  • uspace/srv/fs/exfat/exfat_ops.c

    r43cd499 r14f8fd4  
    405405
    406406        if (!nodep->fragmented) {
    407                 rc = bitmap_append_clusters(bs, nodep, clusters);
     407                rc = exfat_bitmap_append_clusters(bs, nodep, clusters);
    408408                if (rc != ENOSPC)
    409409                        return rc;
    … …  
    411411                        nodep->fragmented = true;
    412412                        nodep->dirty = true;            /* need to sync node */
    413                         rc = bitmap_replicate_clusters(bs, nodep);
     413                        rc = exfat_bitmap_replicate_clusters(bs, nodep);
    414414                        if (rc != EOK)
    415415                                return rc;
    … …  
    457457
    458458                clsts = prev_clsts - new_clsts;
    459                 rc = bitmap_free_clusters(bs, nodep, clsts);
     459                rc = exfat_bitmap_free_clusters(bs, nodep, clsts);
    460460                if (rc != EOK)
    461461                        return rc;
    … …  
    704704                                nodep->firstc);
    705705                else
    706                         rc = bitmap_free_clusters(bs, nodep,
     706                        rc = exfat_bitmap_free_clusters(bs, nodep,
    707707                            ROUND_UP(nodep->size, BPC(bs)) / BPC(bs));
    708708        }
    … …  
    758758
    759759        fibril_mutex_unlock(&parentp->idx->lock);
    760         if (rc != EOK)
    761                 return rc;
    762 
    763760        fibril_mutex_lock(&childp->idx->lock);
    764 
    765761
    766762        childp->idx->pfc = parentp->firstc;
    … …  
    14631459        }
    14641460
    1465         (void) exfat_node_put(fn);
     1461        int rc2 = exfat_node_put(fn);
     1462        if (rc == EOK && rc2 != EOK)
     1463                rc = rc2;
     1464
    14661465        return rc;
    14671466}
Note: See TracChangeset for help on using the changeset viewer.