Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset d9fae235 in mainline


Ignore:
Timestamp:
2010-04-17T01:28:38Z (13 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial
Children:
9d6bfa5
Parents:
9256ad29
Message:

sysinfo overhaul

  • cleanup (nicer data structures, use of SLAB allocator)
  • add support for storing arbitrary binary data
  • properly reimplement non-constant values (generated by functions)
  • add support for non-constant subtrees (generated by functions)
  • syscall ABI change, libc API change
  • reflect changes in user code

libc: task_spawn() can now return error code

  • reflect change in user code, print error strings after failed task_spawn()

uspace cleanup

  • more use of string and other constants
  • more use of str_error()
  • unify error reporting in init
Files:
43 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/include/syscall/syscall.h

    r9256ad29 rd9fae235  
    8282        SYS_PREEMPT_CONTROL,
    8383       
    84         SYS_SYSINFO_VALID,
    85         SYS_SYSINFO_VALUE,
     84        SYS_SYSINFO_GET_TAG,
     85        SYS_SYSINFO_GET_VALUE,
     86        SYS_SYSINFO_GET_DATA_SIZE,
     87        SYS_SYSINFO_GET_DATA,
    8688       
    8789        SYS_DEBUG_ENABLE_CONSOLE,
  • kernel/generic/include/sysinfo/sysinfo.h

    r9256ad29 rd9fae235  
    4141extern bool fb_exported;
    4242
    43 typedef union sysinfo_item_val {
     43typedef enum {
     44        SYSINFO_VAL_UNDEFINED = 0,
     45        SYSINFO_VAL_VAL = 1,
     46        SYSINFO_VAL_DATA = 2,
     47        SYSINFO_VAL_FUNCTION_VAL = 3,
     48        SYSINFO_VAL_FUNCTION_DATA = 4
     49} sysinfo_item_val_type_t;
     50
     51typedef enum {
     52        SYSINFO_SUBTREE_NONE = 0,
     53        SYSINFO_SUBTREE_TABLE = 1,
     54        SYSINFO_SUBTREE_FUNCTION = 2
     55} sysinfo_subtree_type_t;
     56
     57struct sysinfo_item;
     58
     59typedef unative_t (*sysinfo_fn_val_t)(struct sysinfo_item *);
     60typedef void *(*sysinfo_fn_data_t)(struct sysinfo_item *, size_t *);
     61typedef struct sysinfo_item *(*sysinfo_fn_subtree_t)(const char *);
     62
     63typedef struct {
     64        void *data;
     65        size_t size;
     66} sysinfo_data_t;
     67
     68typedef union {
    4469        unative_t val;
    45         void *fn;
     70        sysinfo_fn_val_t fn_val;
     71        sysinfo_fn_data_t fn_data;
     72        sysinfo_data_t data;
    4673} sysinfo_item_val_t;
     74
     75typedef union {
     76        struct sysinfo_item *table;
     77        sysinfo_fn_subtree_t find_item;
     78} sysinfo_subtree_t;
    4779
    4880typedef struct sysinfo_item {
    4981        char *name;
     82       
     83        sysinfo_item_val_type_t val_type;
     84        sysinfo_item_val_t val;
     85       
     86        sysinfo_subtree_type_t subtree_type;
     87        sysinfo_subtree_t subtree;
     88       
     89        struct sysinfo_item *next;
     90} sysinfo_item_t;
     91
     92typedef struct {
     93        sysinfo_item_val_type_t tag;
    5094        union {
    5195                unative_t val;
    52                 void *fn;
    53         } val;
     96                sysinfo_data_t data;
     97        };
     98} sysinfo_return_t;
    5499
    55         union {
    56                 struct sysinfo_item *table;
    57                 void *fn;
    58         } subinfo;
     100extern void sysinfo_init(void);
    59101
    60         struct sysinfo_item *next;
    61         int val_type;
    62         int subinfo_type;
    63 } sysinfo_item_t;
     102extern void sysinfo_set_item_val(const char *, sysinfo_item_t **, unative_t);
     103extern void sysinfo_set_item_data(const char *, sysinfo_item_t **, void *,
     104    size_t);
     105extern void sysinfo_set_item_val_fn(const char *, sysinfo_item_t **,
     106    sysinfo_fn_val_t);
     107extern void sysinfo_set_item_data_fn(const char *, sysinfo_item_t **,
     108    sysinfo_fn_data_t);
     109extern void sysinfo_set_item_undefined(const char *, sysinfo_item_t **);
    64110
    65 #define SYSINFO_VAL_VAL        0
    66 #define SYSINFO_VAL_FUNCTION   1
    67 #define SYSINFO_VAL_UNDEFINED  U_SPECIAL
     111extern sysinfo_return_t sysinfo_get_item(const char *, sysinfo_item_t **);
     112extern void sysinfo_dump(sysinfo_item_t **, unsigned int);
    68113
    69 #define SYSINFO_SUBINFO_NONE      0
    70 #define SYSINFO_SUBINFO_TABLE     1
    71 #define SYSINFO_SUBINFO_FUNCTION  2
    72 
    73 typedef unative_t (*sysinfo_val_fn_t)(sysinfo_item_t *root);
    74 typedef unative_t (*sysinfo_subinfo_fn_t)(const char *subname);
    75 
    76 typedef struct sysinfo_rettype {
    77         unative_t val;
    78         unative_t valid;
    79 } sysinfo_rettype_t;
    80 
    81 void sysinfo_set_item_val(const char *name, sysinfo_item_t **root, unative_t val);
    82 void sysinfo_dump(sysinfo_item_t **root, int depth);
    83 void sysinfo_set_item_function(const char *name, sysinfo_item_t **root, sysinfo_val_fn_t fn);
    84 void sysinfo_set_item_undefined(const char *name, sysinfo_item_t **root);
    85 
    86 sysinfo_rettype_t sysinfo_get_val(const char *name, sysinfo_item_t **root);
    87 
    88 unative_t sys_sysinfo_valid(unative_t ptr, unative_t len);
    89 unative_t sys_sysinfo_value(unative_t ptr, unative_t len);
     114unative_t sys_sysinfo_get_tag(void *, size_t);
     115unative_t sys_sysinfo_get_value(void *, size_t, void *);
     116unative_t sys_sysinfo_get_data_size(void *, size_t, void *);
     117unative_t sys_sysinfo_get_data(void *, size_t, void *, size_t);
    90118
    91119#endif
  • kernel/generic/src/main/main.c

    r9256ad29 rd9fae235  
    8484#include <main/main.h>
    8585#include <ipc/event.h>
     86#include <sysinfo/sysinfo.h>
    8687
    8788/** Global configuration structure. */
     
    209210        /* Initialize at least 1 memory segment big enough for slab to work. */
    210211        LOG_EXEC(slab_cache_init());
     212        LOG_EXEC(sysinfo_init());
    211213        LOG_EXEC(btree_init());
    212214        LOG_EXEC(as_init());
  • kernel/generic/src/syscall/syscall.c

    r9256ad29 rd9fae235  
    153153       
    154154        /* Sysinfo syscalls */
    155         (syshandler_t) sys_sysinfo_valid,
    156         (syshandler_t) sys_sysinfo_value,
     155        (syshandler_t) sys_sysinfo_get_tag,
     156        (syshandler_t) sys_sysinfo_get_value,
     157        (syshandler_t) sys_sysinfo_get_data_size,
     158        (syshandler_t) sys_sysinfo_get_data,
    157159       
    158160        /* Debug calls */
  • kernel/generic/src/sysinfo/sysinfo.c

    r9256ad29 rd9fae235  
    3737#include <print.h>
    3838#include <syscall/copy.h>
     39#include <errno.h>
     40
     41#define SYSINFO_MAX_PATH  2048
    3942
    4043bool fb_exported = false;
    41 sysinfo_item_t *_root = NULL;
    42 
    43 static sysinfo_item_t *sysinfo_find_item(const char *name, sysinfo_item_t *subtree)
    44 {
    45         if (subtree == NULL)
    46                 return NULL;
    47        
    48         while (subtree != NULL) {
    49                 int i = 0;
    50                 char *a = (char *) name;
    51                 char *b = subtree->name;
    52                
    53                 while ((a[i] == b[i]) && (b[i]))
     44
     45static sysinfo_item_t *global_root = NULL;
     46static slab_cache_t *sysinfo_item_slab;
     47
     48static int sysinfo_item_constructor(void *obj, int kmflag)
     49{
     50        sysinfo_item_t *item = (sysinfo_item_t *) obj;
     51       
     52        item->name = NULL;
     53        item->val_type = SYSINFO_VAL_UNDEFINED;
     54        item->subtree_type = SYSINFO_SUBTREE_NONE;
     55        item->next = NULL;
     56       
     57        return 0;
     58}
     59
     60static int sysinfo_item_destructor(void *obj)
     61{
     62        sysinfo_item_t *item = (sysinfo_item_t *) obj;
     63       
     64        if (item->name != NULL)
     65                free(item->name);
     66       
     67        return 0;
     68}
     69
     70void sysinfo_init(void)
     71{
     72        sysinfo_item_slab = slab_cache_create("sysinfo_item_slab",
     73            sizeof(sysinfo_item_t), 0, sysinfo_item_constructor,
     74            sysinfo_item_destructor, SLAB_CACHE_MAGDEFERRED);
     75}
     76
     77static sysinfo_item_t *sysinfo_find_item(const char *name,
     78    sysinfo_item_t *subtree)
     79{
     80        sysinfo_item_t *cur = subtree;
     81       
     82        while (cur != NULL) {
     83                size_t i = 0;
     84               
     85                /* Compare name with path */
     86                while ((cur->name[i] != 0) && (name[i] == cur->name[i]))
    5487                        i++;
    5588               
    56                 if ((!a[i]) && (!b[i]))  /* Last name in path matches */
    57                         return subtree;
    58                
    59                 if ((a[i] == '.') && (!b[i])) { /* Middle name in path matches */
    60                         if (subtree->subinfo_type == SYSINFO_SUBINFO_TABLE)
    61                                 return sysinfo_find_item(a + i + 1, subtree->subinfo.table);
     89                /* Check for perfect name and path match */
     90                if ((name[i] == 0) && (cur->name[i] == 0))
     91                        return cur;
     92               
     93                /* Partial match up to the delimiter */
     94                if ((name[i] == '.') && (cur->name[i] == 0)) {
     95                        /* Look into the subtree */
     96                        switch (cur->subtree_type) {
     97                        case SYSINFO_SUBTREE_TABLE:
     98                                /* Recursively find in subtree */
     99                                return sysinfo_find_item(name + i + 1, cur->subtree.table);
     100                        case SYSINFO_SUBTREE_FUNCTION:
     101                                /* Get generated item */
     102                                return cur->subtree.find_item(name + i + 1);
     103                        default:
     104                                /* Not found */
     105                                return NULL;
     106                        }
     107                }
     108               
     109                cur = cur->next;
     110        }
     111       
     112        return NULL;
     113}
     114
     115static sysinfo_item_t *sysinfo_create_path(const char *name,
     116    sysinfo_item_t **psubtree)
     117{
     118        if (*psubtree == NULL) {
     119                /* No parent */
     120               
     121                size_t i = 0;
     122               
     123                /* Find the first delimiter in name */
     124                while ((name[i] != 0) && (name[i] != '.'))
     125                        i++;
     126               
     127                *psubtree =
     128                    (sysinfo_item_t *) slab_alloc(sysinfo_item_slab, 0);
     129                ASSERT(*psubtree);
     130               
     131                /* Fill in item name up to the delimiter */
     132                (*psubtree)->name = str_ndup(name, i);
     133                ASSERT((*psubtree)->name);
     134               
     135                /* Create subtree items */
     136                if (name[i] == '.') {
     137                        (*psubtree)->subtree_type = SYSINFO_SUBTREE_TABLE;
     138                        return sysinfo_create_path(name + i + 1,
     139                            &((*psubtree)->subtree.table));
     140                }
     141               
     142                /* No subtree needs to be created */
     143                return *psubtree;
     144        }
     145       
     146        sysinfo_item_t *cur = *psubtree;
     147       
     148        while (cur != NULL) {
     149                size_t i = 0;
     150               
     151                /* Compare name with path */
     152                while ((cur->name[i] != 0) && (name[i] == cur->name[i]))
     153                        i++;
     154               
     155                /* Check for perfect name and path match
     156                 * -> item is already present.
     157                 */
     158                if ((name[i] == 0) && (cur->name[i] == 0))
     159                        return cur;
     160               
     161                /* Partial match up to the delimiter */
     162                if ((name[i] == '.') && (cur->name[i] == 0)) {
     163                        switch (cur->subtree_type) {
     164                        case SYSINFO_SUBTREE_NONE:
     165                                /* No subtree yet, create one */
     166                                cur->subtree_type = SYSINFO_SUBTREE_TABLE;
     167                                return sysinfo_create_path(name + i + 1,
     168                                    &(cur->subtree.table));
     169                        case SYSINFO_SUBTREE_TABLE:
     170                                /* Subtree already created, add new sibling */
     171                                return sysinfo_create_path(name + i + 1,
     172                                    &(cur->subtree.table));
     173                        default:
     174                                /* Subtree items handled by a function, this
     175                                 * cannot be overriden.
     176                                 */
     177                                return NULL;
     178                        }
     179                }
     180               
     181                /* No match and no more siblings to check
     182                 * -> create a new sibling item.
     183                 */
     184                if (cur->next == NULL) {
     185                        /* Find the first delimiter in name */
     186                        i = 0;
     187                        while ((name[i] != 0) && (name[i] != '.'))
     188                                i++;
    62189                       
    63                         //if (subtree->subinfo_type == SYSINFO_SUBINFO_FUNCTION) /* Subinfo managed by subsystem */
    64                         //      return NULL;
     190                        sysinfo_item_t *item =
     191                            (sysinfo_item_t *) slab_alloc(sysinfo_item_slab, 0);
     192                        ASSERT(item);
    65193                       
    66                         return NULL; /* No subinfo */
    67                 }
    68                 /* No matches try next */
    69                 subtree = subtree->next;
    70         }
    71         return NULL;
    72 }
    73 
    74 static sysinfo_item_t *sysinfo_create_path(const char *name, sysinfo_item_t **psubtree)
    75 {
    76         sysinfo_item_t *subtree;
    77         subtree = *psubtree;
    78        
    79         if (subtree == NULL) {
    80                 sysinfo_item_t *item = malloc(sizeof(sysinfo_item_t), 0);
    81                 int i = 0, j;
     194                        cur->next = item;
    82195                       
    83                 ASSERT(item);
    84                 *psubtree = item;
    85                 item->next = NULL;
    86                 item->val_type = SYSINFO_VAL_UNDEFINED;
    87                 item->subinfo.table = NULL;
    88 
    89                 while (name[i] && (name[i] != '.'))
    90                         i++;
     196                        /* Fill in item name up to the delimiter */
     197                        item->name = str_ndup(name, i);
     198                        ASSERT(item->name);
    91199                       
    92                 item->name = malloc(i, 0);
    93                 ASSERT(item->name);
    94 
    95                 for (j = 0; j < i; j++)
    96                         item->name[j] = name[j];
    97                 item->name[j] = 0;
    98                        
    99                 if (name[i]) { /* =='.' */
    100                         item->subinfo_type = SYSINFO_SUBINFO_TABLE;
    101                         return sysinfo_create_path(name + i + 1, &(item->subinfo.table));
    102                 }
    103                 item->subinfo_type = SYSINFO_SUBINFO_NONE;
    104                 return item;
    105         }
    106 
    107         while (subtree != NULL) {
    108                 int i = 0, j;
    109                 char *a = (char *) name;
    110                 char *b = subtree->name;
    111                
    112                 while ((a[i] == b[i]) && (b[i]))
    113                         i++;
    114                
    115                 if ((!a[i]) && (!b[i])) /* Last name in path matches */
    116                         return subtree;
    117                
    118                 if ((a[i] == '.') && (!b[i])) { /* Middle name in path matches */
    119                         if (subtree->subinfo_type == SYSINFO_SUBINFO_TABLE)
    120                                 return sysinfo_create_path(a + i + 1, &(subtree->subinfo.table));
    121                        
    122                         if (subtree->subinfo_type == SYSINFO_SUBINFO_NONE) {
    123                                 subtree->subinfo_type = SYSINFO_SUBINFO_TABLE;
    124                                 return sysinfo_create_path(a + i + 1,&(subtree->subinfo.table));
     200                        /* Create subtree items */
     201                        if (name[i] == '.') {
     202                                item->subtree_type = SYSINFO_SUBTREE_TABLE;
     203                                return sysinfo_create_path(name + i + 1,
     204                                    &(item->subtree.table));
    125205                        }
    126206                       
    127                         //if (subtree->subinfo_type == SYSINFO_SUBINFO_FUNCTION) /* Subinfo managed by subsystem */
    128                         //      return NULL;
    129                        
    130                         return NULL;
    131                 }
    132                 /* No matches try next or create new*/
    133                 if (subtree->next == NULL) {
    134                         sysinfo_item_t *item = malloc(sizeof(sysinfo_item_t), 0);
    135                        
    136                         ASSERT(item);
    137                         subtree->next = item;
    138                         item->next = NULL;
    139                         item->val_type = SYSINFO_VAL_UNDEFINED;
    140                         item->subinfo.table = NULL;
    141 
    142                         i = 0;
    143                         while (name[i] && (name[i] != '.'))
    144                                 i++;
    145 
    146                         item->name = malloc(i, 0);
    147                         ASSERT(item->name);
    148                        
    149                         for (j = 0; j < i; j++)
    150                                 item->name[j] = name[j];
    151                        
    152                         item->name[j] = 0;
    153 
    154                         if(name[i]) { /* =='.' */
    155                                 item->subinfo_type = SYSINFO_SUBINFO_TABLE;
    156                                 return sysinfo_create_path(name + i + 1, &(item->subinfo.table));
    157                         }
    158                         item->subinfo_type = SYSINFO_SUBINFO_NONE;
     207                        /* No subtree needs to be created */
    159208                        return item;
    160                 } else
    161                         subtree = subtree->next;
    162         }
    163 
    164         panic("Not reached.");
     209                }
     210               
     211                /* Get next sibling */
     212                cur = cur->next;
     213        }
     214       
     215        /* Unreachable */
     216        ASSERT(false);
    165217        return NULL;
    166218}
    167219
    168 void sysinfo_set_item_val(const char *name, sysinfo_item_t **root, unative_t val)
    169 {
    170         if (root == NULL)
    171                 root = &_root;
    172        
    173         /* If already created create only returns pointer
    174            If not, create it */
     220void sysinfo_set_item_val(const char *name, sysinfo_item_t **root,
     221    unative_t val)
     222{
     223        if (root == NULL)
     224                root = &global_root;
     225       
    175226        sysinfo_item_t *item = sysinfo_create_path(name, root);
    176        
    177         if (item != NULL) { /* If in subsystem, unable to create or return so unable to set */
    178                 item->val.val = val;                   
     227        if (item != NULL) {
    179228                item->val_type = SYSINFO_VAL_VAL;
    180         }
    181 }
    182 
    183 void sysinfo_set_item_function(const char *name, sysinfo_item_t **root, sysinfo_val_fn_t fn)
    184 {
    185         if (root == NULL)
    186                 root = &_root;
    187        
    188         /* If already created create only returns pointer
    189            If not, create it */
     229                item->val.val = val;
     230        }
     231}
     232
     233void sysinfo_set_item_data(const char *name, sysinfo_item_t **root,
     234    void *data, size_t size)
     235{
     236        if (root == NULL)
     237                root = &global_root;
     238       
    190239        sysinfo_item_t *item = sysinfo_create_path(name, root);
    191        
    192         if (item != NULL) { /* If in subsystem, unable to create or return so  unable to set */
    193                 item->val.fn = fn;                   
    194                 item->val_type = SYSINFO_VAL_FUNCTION;
    195         }
    196 }
    197 
     240        if (item != NULL) {
     241                item->val_type = SYSINFO_VAL_DATA;
     242                item->val.data.data = data;
     243                item->val.data.size = size;
     244        }
     245}
     246
     247void sysinfo_set_item_val_fn(const char *name, sysinfo_item_t **root,
     248    sysinfo_fn_val_t fn)
     249{
     250        if (root == NULL)
     251                root = &global_root;
     252       
     253        sysinfo_item_t *item = sysinfo_create_path(name, root);
     254        if (item != NULL) {
     255                item->val_type = SYSINFO_VAL_FUNCTION_VAL;
     256                item->val.fn_val = fn;
     257        }
     258}
     259
     260void sysinfo_set_item_data_fn(const char *name, sysinfo_item_t **root,
     261    sysinfo_fn_data_t fn)
     262{
     263        if (root == NULL)
     264                root = &global_root;
     265       
     266        sysinfo_item_t *item = sysinfo_create_path(name, root);
     267        if (item != NULL) {
     268                item->val_type = SYSINFO_VAL_FUNCTION_DATA;
     269                item->val.fn_data = fn;
     270        }
     271}
    198272
    199273void sysinfo_set_item_undefined(const char *name, sysinfo_item_t **root)
    200274{
    201275        if (root == NULL)
    202                 root = &_root;
    203        
    204         /* If already created create only returns pointer
    205            If not, create it */
     276                root = &global_root;
     277       
    206278        sysinfo_item_t *item = sysinfo_create_path(name, root);
    207        
    208279        if (item != NULL)
    209280                item->val_type = SYSINFO_VAL_UNDEFINED;
    210281}
    211282
    212 
    213 void sysinfo_dump(sysinfo_item_t **proot, int depth)
    214 {
    215         sysinfo_item_t *root;
     283static void sysinfo_indent(unsigned int depth)
     284{
     285        unsigned int i;
     286        for (i = 0; i < depth; i++)
     287                printf("  ");
     288}
     289
     290void sysinfo_dump(sysinfo_item_t **proot, unsigned int depth)
     291{
    216292        if (proot == NULL)
    217                 proot = &_root;
    218        
    219         root = *proot;
    220        
    221         while (root != NULL) {
    222                 int i;
    223                 unative_t val = 0;
    224                 const char *vtype = NULL;
    225                
    226                
    227                 for (i = 0; i < depth; i++)
    228                         printf("  ");
    229                
    230                 switch (root->val_type) {
     293                proot = &global_root;
     294       
     295        sysinfo_item_t *cur = *proot;
     296       
     297        while (cur != NULL) {
     298                sysinfo_indent(depth);
     299               
     300                unative_t val;
     301                size_t size;
     302               
     303                switch (cur->val_type) {
    231304                case SYSINFO_VAL_UNDEFINED:
    232                         val = 0;
    233                         vtype = "UND";
     305                        printf("+ %s\n", cur->name);
    234306                        break;
    235307                case SYSINFO_VAL_VAL:
    236                         val = root->val.val;
    237                         vtype = "VAL";
    238                         break;
    239                 case SYSINFO_VAL_FUNCTION:
    240                         val = ((sysinfo_val_fn_t) (root->val.fn)) (root);
    241                         vtype = "FUN";
    242                         break;
    243                 }
    244                
    245                 printf("%s    %s val:%" PRIun "(%" PRIxn ") sub:%s\n", root->name, vtype, val,
    246                         val, (root->subinfo_type == SYSINFO_SUBINFO_NONE) ?
    247                         "NON" : ((root->subinfo_type == SYSINFO_SUBINFO_TABLE) ?
    248                         "TAB" : "FUN"));
    249                
    250                 if (root->subinfo_type == SYSINFO_SUBINFO_TABLE)
    251                         sysinfo_dump(&(root -> subinfo.table), depth + 1);
    252                
    253                 root = root->next;
    254         }
    255 }
    256 
    257 sysinfo_rettype_t sysinfo_get_val(const char *name, sysinfo_item_t **root)
    258 {
    259         // TODO: Implement Subsystem subinfo (by function implemented subinfo)
    260 
    261         sysinfo_rettype_t ret = {0, false};
    262 
    263         if (root == NULL)
    264                 root = &_root;
     308                        printf("+ %s -> %" PRIun" (%#" PRIxn ")\n", cur->name,
     309                            cur->val.val, cur->val.val);
     310                        break;
     311                case SYSINFO_VAL_DATA:
     312                        printf("+ %s (%" PRIs" bytes)\n", cur->name,
     313                            cur->val.data.size);
     314                        break;
     315                case SYSINFO_VAL_FUNCTION_VAL:
     316                        val = cur->val.fn_val(cur);
     317                        printf("+ %s -> %" PRIun" (%#" PRIxn ") [generated]\n",
     318                            cur->name, val, val);
     319                        break;
     320                case SYSINFO_VAL_FUNCTION_DATA:
     321                        cur->val.fn_data(cur, &size);
     322                        printf("+ %s (%" PRIs" bytes) [generated]\n", cur->name,
     323                            size);
     324                        break;
     325                default:
     326                        printf("+ %s [unknown]\n", cur->name);
     327                }
     328               
     329                switch (cur->subtree_type) {
     330                case SYSINFO_SUBTREE_NONE:
     331                        break;
     332                case SYSINFO_SUBTREE_TABLE:
     333                        sysinfo_dump(&(cur->subtree.table), depth + 1);
     334                        break;
     335                case SYSINFO_SUBTREE_FUNCTION:
     336                        sysinfo_indent(depth + 1);
     337                        printf("  [generated subtree]\n");
     338                        break;
     339                default:
     340                        sysinfo_indent(depth + 1);
     341                        printf("  [unknown subtree]\n");
     342                }
     343               
     344                cur = cur->next;
     345        }
     346}
     347
     348sysinfo_return_t sysinfo_get_item(const char *name, sysinfo_item_t **root)
     349{
     350        if (root == NULL)
     351                root = &global_root;
    265352       
    266353        sysinfo_item_t *item = sysinfo_find_item(name, *root);
     354        sysinfo_return_t ret;
    267355       
    268356        if (item != NULL) {
    269                 if (item->val_type == SYSINFO_VAL_UNDEFINED)
    270                         return ret;
    271                 else
    272                         ret.valid = true;
    273                
    274                 if (item->val_type == SYSINFO_VAL_VAL)
     357                switch (item->val_type) {
     358                case SYSINFO_VAL_UNDEFINED:
     359                        ret.tag = SYSINFO_VAL_UNDEFINED;
     360                        break;
     361                case SYSINFO_VAL_VAL:
     362                        ret.tag = SYSINFO_VAL_VAL;
    275363                        ret.val = item->val.val;
    276                 else
    277                         ret.val = ((sysinfo_val_fn_t) (item->val.fn)) (item);
    278         }
     364                        break;
     365                case SYSINFO_VAL_DATA:
     366                        ret.tag = SYSINFO_VAL_DATA;
     367                        ret.data = item->val.data;
     368                        break;
     369                case SYSINFO_VAL_FUNCTION_VAL:
     370                        ret.tag = SYSINFO_VAL_VAL;
     371                        ret.val = item->val.fn_val(item);
     372                        break;
     373                case SYSINFO_VAL_FUNCTION_DATA:
     374                        ret.tag = SYSINFO_VAL_DATA;
     375                        ret.data.data = item->val.fn_data(item, &ret.data.size);
     376                        break;
     377                }
     378        } else
     379                ret.tag = SYSINFO_VAL_UNDEFINED;
     380       
    279381        return ret;
    280382}
    281383
    282 #define SYSINFO_MAX_LEN 1024
    283 
    284 unative_t sys_sysinfo_valid(unative_t ptr, unative_t len)
    285 {
    286         char *str;
    287         sysinfo_rettype_t ret = {0, 0};
    288 
    289         if (len > SYSINFO_MAX_LEN)
    290                 return ret.valid;
    291         str = malloc(len + 1, 0);
    292        
    293         ASSERT(str);
    294         if (!((copy_from_uspace(str, (void *) ptr, len + 1)) || (str[len])))
    295                 ret = sysinfo_get_val(str, NULL);
    296        
    297         free(str);
    298         return ret.valid;
    299 }
    300 
    301 unative_t sys_sysinfo_value(unative_t ptr, unative_t len)
    302 {
    303         char *str;
    304         sysinfo_rettype_t ret = {0, 0};
    305        
    306         if (len > SYSINFO_MAX_LEN)
    307                 return ret.val;
    308         str = malloc(len + 1, 0);
    309        
    310         ASSERT(str);
    311         if (!((copy_from_uspace(str, (void *) ptr, len + 1)) || (str[len])))
    312                 ret = sysinfo_get_val(str, NULL);
    313        
    314         free(str);
    315         return ret.val;
     384static sysinfo_return_t sysinfo_get_item_uspace(void *ptr, size_t size)
     385{
     386        sysinfo_return_t ret;
     387        ret.tag = SYSINFO_VAL_UNDEFINED;
     388       
     389        if (size > SYSINFO_MAX_PATH)
     390                return ret;
     391       
     392        char *path = (char *) malloc(size + 1, 0);
     393        ASSERT(path);
     394       
     395        if ((copy_from_uspace(path, ptr, size + 1) == 0)
     396            && (path[size] == 0)) {
     397                ret = sysinfo_get_item(path, NULL);
     398                free(path);
     399        }
     400       
     401        return ret;
     402}
     403
     404unative_t sys_sysinfo_get_tag(void *path_ptr, size_t path_size)
     405{
     406        return (unative_t) sysinfo_get_item_uspace(path_ptr, path_size).tag;
     407}
     408
     409unative_t sys_sysinfo_get_value(void *path_ptr, size_t path_size,
     410    void *value_ptr)
     411{
     412        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size);
     413       
     414        if (ret.tag != SYSINFO_VAL_VAL)
     415                return (unative_t) EINVAL;
     416       
     417        return (unative_t) copy_to_uspace(value_ptr, &ret.val,
     418            sizeof(ret.val));
     419}
     420
     421unative_t sys_sysinfo_get_data_size(void *path_ptr, size_t path_size,
     422    void *size_ptr)
     423{
     424        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size);
     425       
     426        if (ret.tag != SYSINFO_VAL_DATA)
     427                return (unative_t) EINVAL;
     428       
     429        return (unative_t) copy_to_uspace(size_ptr, &ret.data.size,
     430            sizeof(ret.data.size));
     431}
     432
     433unative_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,
     434    void *buffer_ptr, size_t buffer_size)
     435{
     436        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size);
     437       
     438        if (ret.tag != SYSINFO_VAL_DATA)
     439                return (unative_t) EINVAL;
     440       
     441        if (ret.data.size != buffer_size)
     442                return ENOMEM;
     443       
     444        return (unative_t) copy_to_uspace(buffer_ptr, ret.data.data,
     445            ret.data.size);
    316446}
    317447
  • uspace/app/bdsh/exec.c

    r9256ad29 rd9fae235  
    121121        free(found);
    122122
    123         tid = task_spawn(tmp, (const char **) argv);
     123        tid = task_spawn(tmp, (const char **) argv, &retval);
    124124        free(tmp);
    125125
    126126        if (tid == 0) {
    127                 cli_error(CL_EEXEC, "%s: Cannot spawn `%s'", progname, cmd);
     127                cli_error(CL_EEXEC, "%s: Cannot spawn `%s' (%s)", progname, cmd,
     128                    str_error(retval));
    128129                return 1;
    129130        }
  • uspace/app/getterm/getterm.c

    r9256ad29 rd9fae235  
    4040#include <stdio.h>
    4141#include <task.h>
     42#include <str_error.h>
    4243#include "version.h"
     44
     45#define APP_NAME  "getterm"
    4346
    4447static void usage(void)
    4548{
    46         printf("Usage: getterm <terminal> <path>\n");
     49        printf("Usage: %s <terminal> <path>\n", APP_NAME);
    4750}
    4851
     
    7679        args[1] = NULL;
    7780       
    78         task_id_t id = task_spawn(fname, args);
     81        int err;
     82        task_id_t id = task_spawn(fname, args, &err);
    7983       
    8084        if (id == 0)
    81                 printf("Error spawning %s\n", fname);
     85                printf("%s: Error spawning %s (%s)\n", APP_NAME, fname,
     86                    str_error(err));
    8287       
    8388        return id;
  • uspace/app/init/init.c

    r9256ad29 rd9fae235  
    4848#include <str.h>
    4949#include <devmap.h>
     50#include <str_error.h>
    5051#include "init.h"
    5152
     53#define ROOT_DEVICE       "bd/initrd"
     54#define ROOT_MOUNT_POINT  "/"
     55
     56#define DEVFS_FS_TYPE      "devfs"
    5257#define DEVFS_MOUNT_POINT  "/dev"
     58
     59#define SCRATCH_FS_TYPE      "tmpfs"
     60#define SCRATCH_MOUNT_POINT  "/scratch"
     61
     62#define DATA_FS_TYPE      "fat"
     63#define DATA_DEVICE       "bd/disk0"
     64#define DATA_MOUNT_POINT  "/data"
    5365
    5466#define SRV_CONSOLE  "/srv/console"
     
    5769static void info_print(void)
    5870{
    59         printf(NAME ": HelenOS init\n");
     71        printf("%s: HelenOS init\n", NAME);
     72}
     73
     74static bool mount_report(const char *desc, const char *mntpt,
     75    const char *fstype, const char *dev, int rc)
     76{
     77        switch (rc) {
     78        case EOK:
     79                if (dev != NULL)
     80                        printf("%s: %s mounted on %s (%s at %s)\n", NAME, desc, mntpt,
     81                            fstype, dev);
     82                else
     83                        printf("%s: %s mounted on %s (%s)\n", NAME, desc, mntpt, fstype);
     84                break;
     85        case EBUSY:
     86                printf("%s: %s already mounted on %s\n", NAME, desc, mntpt);
     87                return false;
     88        case ELIMIT:
     89                printf("%s: %s limit exceeded\n", NAME, desc);
     90                return false;
     91        case ENOENT:
     92                printf("%s: %s unknown type (%s)\n", NAME, desc, fstype);
     93                return false;
     94        default:
     95                printf("%s: %s not mounted on %s (%s)\n", NAME, desc, mntpt,
     96                    str_error(rc));
     97                return false;
     98        }
     99       
     100        return true;
    60101}
    61102
     
    63104{
    64105        const char *opts = "";
    65         const char *root_dev = "bd/initrd";
    66106       
    67107        if (str_cmp(fstype, "tmpfs") == 0)
    68108                opts = "restore";
    69109       
    70         int rc = mount(fstype, "/", root_dev, opts, IPC_FLAG_BLOCKING);
    71        
    72         switch (rc) {
    73         case EOK:
    74                 printf(NAME ": Root filesystem mounted, %s at %s\n",
    75                     fstype, root_dev);
    76                 break;
    77         case EBUSY:
    78                 printf(NAME ": Root filesystem already mounted\n");
    79                 return false;
    80         case ELIMIT:
    81                 printf(NAME ": Unable to mount root filesystem\n");
    82                 return false;
    83         case ENOENT:
    84                 printf(NAME ": Unknown filesystem type (%s)\n", fstype);
    85                 return false;
    86         default:
    87                 printf(NAME ": Error mounting root filesystem (%d)\n", rc);
    88                 return false;
    89         }
    90        
    91         return true;
     110        int rc = mount(fstype, ROOT_MOUNT_POINT, ROOT_DEVICE, opts,
     111            IPC_FLAG_BLOCKING);
     112        return mount_report("Root filesystem", ROOT_MOUNT_POINT, fstype,
     113            ROOT_DEVICE, rc);
    92114}
    93115
    94116static bool mount_devfs(void)
    95117{
    96         int rc = mount("devfs", DEVFS_MOUNT_POINT, "", "", IPC_FLAG_BLOCKING);
    97        
    98         switch (rc) {
    99         case EOK:
    100                 printf(NAME ": Device filesystem mounted\n");
    101                 break;
    102         case EBUSY:
    103                 printf(NAME ": Device filesystem already mounted\n");
    104                 return false;
    105         case ELIMIT:
    106                 printf(NAME ": Unable to mount device filesystem\n");
    107                 return false;
    108         case ENOENT:
    109                 printf(NAME ": Unknown filesystem type (devfs)\n");
    110                 return false;
    111         default:
    112                 printf(NAME ": Error mounting device filesystem (%d)\n", rc);
    113                 return false;
    114         }
    115        
    116         return true;
     118        int rc = mount(DEVFS_FS_TYPE, DEVFS_MOUNT_POINT, "", "",
     119            IPC_FLAG_BLOCKING);
     120        return mount_report("Device filesystem", DEVFS_MOUNT_POINT, DEVFS_FS_TYPE,
     121            NULL, rc);
    117122}
    118123
     
    125130                return;
    126131       
    127         printf(NAME ": Spawning %s\n", fname);
     132        printf("%s: Spawning %s\n", NAME, fname);
    128133       
    129134        argv[0] = fname;
    130135        argv[1] = NULL;
    131136       
    132         if (!task_spawn(fname, argv))
    133                 printf(NAME ": Error spawning %s\n", fname);
     137        int err;
     138        if (!task_spawn(fname, argv, &err))
     139                printf("%s: Error spawning %s (%s)\n", NAME, fname,
     140                    str_error(err));
    134141}
    135142
     
    145152                return;
    146153       
    147         printf(NAME ": Starting %s\n", fname);
     154        printf("%s: Starting %s\n", NAME, fname);
    148155       
    149156        argv[0] = fname;
    150157        argv[1] = NULL;
    151158       
    152         id = task_spawn(fname, argv);
     159        id = task_spawn(fname, argv, &retval);
    153160        if (!id) {
    154                 printf(NAME ": Error spawning %s\n", fname);
     161                printf("%s: Error spawning %s (%s)\n", NAME, fname,
     162                    str_error(retval));
    155163                return;
    156164        }
    157 
     165       
    158166        rc = task_wait(id, &texit, &retval);
    159167        if (rc != EOK) {
    160                 printf(NAME ": Error waiting for %s\n", fname);
     168                printf("%s: Error waiting for %s (%s(\n", NAME, fname,
     169                    str_error(retval));
    161170                return;
    162171        }
    163 
     172       
    164173        if ((texit != TASK_EXIT_NORMAL) || (retval != 0)) {
    165                 printf(NAME ": Server %s failed to start (returned %d)\n",
    166                         fname, retval);
     174                printf("%s: Server %s failed to start (%s)\n", NAME,
     175                        fname, str_error(retval));
    167176        }
    168177}
     
    176185        snprintf(hid_in, DEVMAP_NAME_MAXLEN, "%s/%s", DEVFS_MOUNT_POINT, dev);
    177186       
    178         printf(NAME ": Spawning %s with %s\n", SRV_CONSOLE, hid_in);
     187        printf("%s: Spawning %s %s\n", NAME, SRV_CONSOLE, hid_in);
    179188       
    180189        /* Wait for the input device to be ready */
     
    187196                argv[2] = NULL;
    188197               
    189                 if (!task_spawn(SRV_CONSOLE, argv))
    190                         printf(NAME ": Error spawning %s with %s\n", SRV_CONSOLE, hid_in);
     198                if (!task_spawn(SRV_CONSOLE, argv, &rc))
     199                        printf("%s: Error spawning %s %s (%s)\n", NAME, SRV_CONSOLE,
     200                            hid_in, str_error(rc));
    191201        } else
    192                 printf(NAME ": Error waiting on %s\n", hid_in);
     202                printf("%s: Error waiting on %s (%s)\n", NAME, hid_in,
     203                    str_error(rc));
    193204}
    194205
     
    201212        snprintf(term, DEVMAP_NAME_MAXLEN, "%s/%s", DEVFS_MOUNT_POINT, dev);
    202213       
    203         printf(NAME ": Spawning %s with %s %s\n", APP_GETTERM, term, app);
     214        printf("%s: Spawning %s %s %s\n", NAME, APP_GETTERM, term, app);
    204215       
    205216        /* Wait for the terminal device to be ready */
     
    213224                argv[3] = NULL;
    214225               
    215                 if (!task_spawn(APP_GETTERM, argv))
    216                         printf(NAME ": Error spawning %s with %s %s\n", APP_GETTERM,
    217                             term, app);
     226                if (!task_spawn(APP_GETTERM, argv, &rc))
     227                        printf("%s: Error spawning %s %s %s (%s)\n", NAME, APP_GETTERM,
     228                            term, app, str_error(rc));
    218229        } else
    219                 printf(NAME ": Error waiting on %s\n", term);
    220 }
    221 
    222 static void mount_scratch(void)
    223 {
    224         int rc;
    225 
    226         printf("Trying to mount null/0 on /scratch... ");
    227         fflush(stdout);
    228 
    229         rc = mount("tmpfs", "/scratch", "null/0", "", 0);
    230         if (rc == EOK)
    231                 printf("OK\n");
    232         else
    233                 printf("Failed\n");
    234 }
    235 
    236 static void mount_data(void)
    237 {
    238         int rc;
    239 
    240         printf("Trying to mount bd/disk0 on /data... ");
    241         fflush(stdout);
    242 
    243         rc = mount("fat", "/data", "bd/disk0", "wtcache", 0);
    244         if (rc == EOK)
    245                 printf("OK\n");
    246         else
    247                 printf("Failed\n");
     230                printf("%s: Error waiting on %s (%s)\n", NAME, term,
     231                    str_error(rc));
     232}
     233
     234static bool mount_scratch(void)
     235{
     236        int rc = mount(SCRATCH_FS_TYPE, SCRATCH_MOUNT_POINT, "", "", 0);
     237        return mount_report("Scratch filesystem", SCRATCH_MOUNT_POINT,
     238            SCRATCH_FS_TYPE, NULL, rc);
     239}
     240
     241static bool mount_data(void)
     242{
     243        int rc = mount(DATA_FS_TYPE, DATA_MOUNT_POINT, DATA_DEVICE, "wtcache", 0);
     244        return mount_report("Data filesystem", DATA_MOUNT_POINT, DATA_FS_TYPE,
     245            DATA_DEVICE, rc);
    248246}
    249247
     
    253251       
    254252        if (!mount_root(STRING(RDFMT))) {
    255                 printf(NAME ": Exiting\n");
     253                printf("%s: Exiting\n", NAME);
    256254                return -1;
    257255        }
    258 
     256       
    259257        /* Make sure tmpfs is running. */
    260258        if (str_cmp(STRING(RDFMT), "tmpfs") != 0) {
     
    266264       
    267265        if (!mount_devfs()) {
    268                 printf(NAME ": Exiting\n");
     266                printf("%s: Exiting\n", NAME);
    269267                return -2;
    270268        }
    271 
     269       
    272270        mount_scratch();
    273271       
     
    278276        srv_start("/srv/adb_ms");
    279277        srv_start("/srv/char_ms");
    280 
     278       
    281279        spawn("/srv/fb");
    282280        spawn("/srv/kbd");
     
    284282       
    285283        spawn("/srv/clip");
    286 
     284       
    287285        /*
    288286         * Start these synchronously so that mount_data() can be
     
    295293        (void) srv_start;
    296294#endif
    297 
     295       
    298296#ifdef CONFIG_MOUNT_DATA
    299297        mount_data();
     
    301299        (void) mount_data;
    302300#endif
    303 
     301       
    304302        getterm("term/vc0", "/app/bdsh");
    305303        getterm("term/vc1", "/app/bdsh");
     
    309307        getterm("term/vc5", "/app/bdsh");
    310308        getterm("term/vc6", "/app/klog");
    311 
     309       
    312310        return 0;
    313311}
  • uspace/app/klog/klog.c

    r9256ad29 rd9fae235  
    6464int main(int argc, char *argv[])
    6565{
    66         size_t klog_pages = sysinfo_value("klog.pages");
     66        size_t klog_pages;
     67        if (sysinfo_get_value("klog.pages", &klog_pages) != EOK) {
     68                printf("%s: Error getting klog address\n", NAME);
     69                return -1;
     70        }
     71       
    6772        size_t klog_size = klog_pages * PAGE_SIZE;
    6873        klog_length = klog_size / sizeof(wchar_t);
     
    7075        klog = (wchar_t *) as_get_mappable_page(klog_size);
    7176        if (klog == NULL) {
    72                 printf(NAME ": Error allocating memory area\n");
     77                printf("%s: Error allocating memory area\n", NAME);
    7378                return -1;
    7479        }
     
    7782            klog_size, SERVICE_MEM_KLOG);
    7883        if (res != EOK) {
    79                 printf(NAME ": Error initializing memory area\n");
     84                printf("%s: Error initializing memory area\n", NAME);
    8085                return -1;
    8186        }
    8287       
    8388        if (event_subscribe(EVENT_KLOG, 0) != EOK) {
    84                 printf(NAME ": Error registering klog notifications\n");
     89                printf("%s: Error registering klog notifications\n", NAME);
    8590                return -1;
    8691        }
  • uspace/app/redir/redir.c

    r9256ad29 rd9fae235  
    4242#include <stdio.h>
    4343#include <task.h>
     44#include <str_error.h>
     45
     46#define NAME  "redir"
    4447
    4548static void usage(void)
    4649{
    47         printf("Usage: redir [-i <stdin>] [-o <stdout>] [-e <stderr>] -- <cmd> [args ...]\n");
     50        printf("Usage: %s [-i <stdin>] [-o <stdout>] [-e <stderr>] -- <cmd> [args ...]\n",
     51            NAME);
    4852}
    4953
     
    8488        args[argc] = NULL;
    8589       
    86         task_id_t id = task_spawn(argv[0], args);
     90        int err;
     91        task_id_t id = task_spawn(argv[0], args, &err);
    8792       
    8893        free(args);
    8994       
    9095        if (id == 0)
    91                 printf("Error spawning %s\n", argv[0]);
     96                printf("%s: Error spawning %s (%s)\n", NAME, argv[0],
     97                    str_error(err));
    9298       
    9399        return id;
  • uspace/app/sbi/src/os/helenos.c

    r9256ad29 rd9fae235  
    3535#include <task.h>
    3636#include <tinput.h>
     37#include <str_error.h>
    3738
    3839#include "os.h"
     
    154155        int retval;
    155156
    156         tid = task_spawn(cmd[0], (char const * const *) cmd);
     157        tid = task_spawn(cmd[0], (char const * const *) cmd, &retval);
    157158        if (tid == 0) {
    158                 printf("Error: Failed spawning '%s'.\n", cmd[0]);
     159                printf("Error: Failed spawning '%s' (%s).\n", cmd[0],
     160                    str_error(retval));
    159161                exit(1);
    160162        }
  • uspace/app/trace/syscalls.c

    r9256ad29 rd9fae235  
    7575    [SYS_PREEMPT_CONTROL] = { "preempt_control",        1,      V_ERRNO },
    7676
    77     [SYS_SYSINFO_VALID] = { "sysinfo_valid",            2,      V_HASH },
    78     [SYS_SYSINFO_VALUE] = { "sysinfo_value",            2,      V_HASH },
     77    [SYS_SYSINFO_GET_TAG] = { "sysinfo_get_tag",                2,      V_INTEGER },
     78    [SYS_SYSINFO_GET_VALUE] = { "sysinfo_get_value",            3,      V_ERRNO },
     79    [SYS_SYSINFO_GET_DATA_SIZE] = { "sysinfo_get_data_size",    3,      V_ERRNO },
     80    [SYS_SYSINFO_GET_DATA] = { "sysinfo_get_data",              4,      V_ERRNO },
     81
    7982    [SYS_DEBUG_ENABLE_CONSOLE] = { "debug_enable_console", 0,   V_ERRNO },
    8083    [SYS_IPC_CONNECT_KBOX] = { "ipc_connect_kbox",      1,      V_ERRNO }
  • uspace/lib/c/arch/ia64/src/ddi.c

    r9256ad29 rd9fae235  
    22#include <sysinfo.h>
    33
    4 uint64_t ia64_iospace_address=0;
    5 
     4uint64_t ia64_iospace_address = 0;
    65
    76uint64_t get_ia64_iospace_address(void)
    87{
    9 
    10         return sysinfo_value("ia64_iospace.address.virtual");
    11 
     8        sysarg_t addr;
     9        if (sysinfo_get_value("ia64_iospace.address.virtual", &addr) != 0)
     10                addr = 0;
     11       
     12        return addr;
    1213}
    1314
  • uspace/lib/c/generic/sysinfo.c

    r9256ad29 rd9fae235  
    3131 */
    3232/** @file
    33  */ 
     33 */
    3434
    3535#include <libc.h>
    3636#include <sysinfo.h>
    3737#include <str.h>
     38#include <errno.h>
     39#include <malloc.h>
     40#include <bool.h>
    3841
    39 sysarg_t sysinfo_value(const char *name)
     42sysinfo_item_tag_t sysinfo_get_tag(const char *path)
    4043{
    41         return __SYSCALL2(SYS_SYSINFO_VALUE, (sysarg_t) name,
    42             (sysarg_t) str_size(name));
     44        return (sysinfo_item_tag_t) __SYSCALL2(SYS_SYSINFO_GET_TAG,
     45            (sysarg_t) path, (sysarg_t) str_size(path));
     46}
     47
     48int sysinfo_get_value(const char *path, sysarg_t *value)
     49{
     50        return (int) __SYSCALL3(SYS_SYSINFO_GET_VALUE, (sysarg_t) path,
     51            (sysarg_t) str_size(path), (sysarg_t) value);
     52}
     53
     54static int sysinfo_get_data_size(const char *path, size_t *size)
     55{
     56        return (int) __SYSCALL3(SYS_SYSINFO_GET_DATA_SIZE, (sysarg_t) path,
     57            (sysarg_t) str_size(path), (sysarg_t) size);
     58}
     59
     60extern void *sysinfo_get_data(const char *path, size_t *size)
     61{
     62        while (true) {
     63                int ret = sysinfo_get_data_size(path, size);
     64                if (ret != EOK)
     65                        return NULL;
     66               
     67                void *data = malloc(*size);
     68                if (data == NULL)
     69                        return NULL;
     70               
     71                ret = __SYSCALL4(SYS_SYSINFO_GET_DATA, (sysarg_t) path,
     72                    (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size);
     73                if (ret == EOK)
     74                        return data;
     75               
     76                if (ret != ENOMEM)
     77                        return NULL;
     78               
     79                free(data);
     80        }
    4381}
    4482
  • uspace/lib/c/generic/task.c

    r9256ad29 rd9fae235  
    7070 * loader API.
    7171 *
    72  * @param path pathname of the binary to execute
    73  * @param argv command-line arguments
     72 * @param path Pathname of the binary to execute.
     73 * @param argv Command-line arguments.
     74 * @param err  If not NULL, the error value is stored here.
    7475 *
    7576 * @return ID of the newly created task or zero on error.
    7677 *
    7778 */
    78 task_id_t task_spawn(const char *path, const char *const args[])
     79task_id_t task_spawn(const char *path, const char *const args[], int *err)
    7980{
    8081        /* Connect to a program loader. */
    8182        loader_t *ldr = loader_connect();
    82         if (ldr == NULL)
     83        if (ldr == NULL) {
     84                if (err != NULL)
     85                        *err = EREFUSED;
     86               
    8387                return 0;
     88        }
    8489       
    8590        /* Get task ID. */
     
    143148        /* Success */
    144149        free(ldr);
     150       
     151        if (err != NULL)
     152                *err = EOK;
     153       
    145154        return task_id;
    146155       
     
    149158        loader_abort(ldr);
    150159        free(ldr);
     160       
     161        if (err != NULL)
     162                *err = rc;
    151163       
    152164        return 0;
  • uspace/lib/c/include/sysinfo.h

    r9256ad29 rd9fae235  
    3131 */
    3232/** @file
    33  */ 
     33 */
    3434
    3535#ifndef LIBC_SYSINFO_H_
     
    3737
    3838#include <libc.h>
    39 #include <sysinfo.h>
    40 #include <str.h>
    4139
    42 sysarg_t sysinfo_value(const char *name);
     40typedef enum {
     41        SYSINFO_VAL_UNDEFINED = 0,
     42        SYSINFO_VAL_VAL = 1,
     43        SYSINFO_VAL_DATA = 2
     44} sysinfo_item_tag_t;
     45
     46extern sysinfo_item_tag_t sysinfo_get_tag(const char *);
     47extern int sysinfo_get_value(const char *, sysarg_t *);
     48extern void *sysinfo_get_data(const char *, size_t *);
    4349
    4450#endif
  • uspace/lib/c/include/task.h

    r9256ad29 rd9fae235  
    4646
    4747extern task_id_t task_get_id(void);
    48 extern int task_set_name(const char *name);
    49 extern task_id_t task_spawn(const char *path, const char *const argv[]);
    50 extern int task_wait(task_id_t id, task_exit_t *texit, int *retval);
    51 extern int task_retval(int val);
    52 
     48extern int task_set_name(const char *);
     49extern task_id_t task_spawn(const char *, const char *const[], int *);
     50extern int task_wait(task_id_t id, task_exit_t *, int *);
     51extern int task_retval(int);
    5352
    5453#endif
  • uspace/lib/net/adt/module_map.c

    r9256ad29 rd9fae235  
    9494}
    9595
    96 task_id_t spawn(const char * fname){
    97         const char * argv[2];
     96task_id_t spawn(const char *fname)
     97{
     98        const char *argv[2];
    9899        task_id_t res;
    99 
     100       
    100101        argv[0] = fname;
    101102        argv[1] = NULL;
    102         res = task_spawn(fname, argv);
    103 
     103        res = task_spawn(fname, argv, NULL);
     104       
    104105        return res;
    105106}
  • uspace/srv/bd/rd/rd.c

    r9256ad29 rd9fae235  
    3232/** @addtogroup rd
    3333 * @{
    34  */ 
     34 */
    3535
    3636/**
    37  * @file        rd.c
    38  * @brief       Initial RAM disk for HelenOS.
     37 * @file rd.c
     38 * @brief Initial RAM disk for HelenOS.
    3939 */
    4040
     
    6161/** Pointer to the ramdisk's image */
    6262static void *rd_addr;
     63
    6364/** Size of the ramdisk */
    6465static size_t rd_size;
     
    7071static int rd_write_blocks(uint64_t ba, size_t cnt, const void *buf);
    7172
    72 /**
    73  * This rwlock protects the ramdisk's data.
     73/** This rwlock protects the ramdisk's data.
     74 *
    7475 * If we were to serve multiple requests (read + write or several writes)
    75  * concurrently (i.e. from two or more threads), each read and write needs to be
    76  * protected by this rwlock.
    77  */
     76 * concurrently (i.e. from two or more threads), each read and write needs to
     77 * be protected by this rwlock.
     78 *
     79 */
    7880fibril_rwlock_t rd_lock;
    7981
    8082/** Handle one connection to ramdisk.
    8183 *
    82  * @param iid           Hash of the request that opened the connection.
    83  * @param icall         Call data of the request that opened the connection.
     84 * @param iid   Hash of the request that opened the connection.
     85 * @param icall Call data of the request that opened the connection.
    8486 */
    8587static void rd_connection(ipc_callid_t iid, ipc_call_t *icall)
     
    9294        size_t cnt;
    9395        size_t comm_size;
    94 
     96       
    9597        /*
    9698         * Answer the first IPC_M_CONNECT_ME_TO call.
    9799         */
    98100        ipc_answer_0(iid, EOK);
    99 
     101       
    100102        /*
    101103         * Now we wait for the client to send us its communication as_area.
     
    108110                } else {
    109111                        ipc_answer_0(callid, EHANGUP);
    110                         return;         
     112                        return;
    111113                }
    112114        } else {
     
    178180                return ELIMIT;
    179181        }
    180 
     182       
    181183        fibril_rwlock_read_lock(&rd_lock);
    182184        memcpy(buf, rd_addr + ba * block_size, block_size * cnt);
    183185        fibril_rwlock_read_unlock(&rd_lock);
    184 
     186       
    185187        return EOK;
    186188}
     
    193195                return ELIMIT;
    194196        }
    195 
     197       
    196198        fibril_rwlock_write_lock(&rd_lock);
    197199        memcpy(rd_addr + ba * block_size, buf, block_size * cnt);
    198200        fibril_rwlock_write_unlock(&rd_lock);
    199 
     201       
    200202        return EOK;
    201203}
     
    204206static bool rd_init(void)
    205207{
    206         rd_size = sysinfo_value("rd.size");
    207         void *rd_ph_addr = (void *) sysinfo_value("rd.address.physical");
    208        
    209         if (rd_size == 0) {
    210                 printf(NAME ": No RAM disk found\n");
     208        int ret = sysinfo_get_value("rd.size", &rd_size);
     209        if ((ret != EOK) || (rd_size == 0)) {
     210                printf("%s: No RAM disk found\n", NAME);
     211                return false;
     212        }
     213       
     214        sysarg_t rd_ph_addr;
     215        ret = sysinfo_get_value("rd.address.physical", &rd_ph_addr);
     216        if ((ret != EOK) || (rd_ph_addr == 0)) {
     217                printf("%s: Invalid RAM disk physical address\n", NAME);
    211218                return false;
    212219        }
     
    215222       
    216223        int flags = AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE;
    217         int retval = physmem_map(rd_ph_addr, rd_addr,
     224        int retval = physmem_map((void *) rd_ph_addr, rd_addr,
    218225            ALIGN_UP(rd_size, PAGE_SIZE) >> PAGE_WIDTH, flags);
    219226       
    220227        if (retval < 0) {
    221                 printf(NAME ": Error mapping RAM disk\n");
    222                 return false;
    223         }
    224        
    225         printf(NAME ": Found RAM disk at %p, %d bytes\n", rd_ph_addr, rd_size);
     228                printf("%s: Error mapping RAM disk\n", NAME);
     229                return false;
     230        }
     231       
     232        printf("%s: Found RAM disk at %p, %d bytes\n", NAME, rd_ph_addr, rd_size);
    226233       
    227234        int rc = devmap_driver_register(NAME, rd_connection);
    228235        if (rc < 0) {
    229                 printf(NAME ": Unable to register driver (%d)\n", rc);
     236                printf("%s: Unable to register driver (%d)\n", NAME, rc);
    230237                return false;
    231238        }
     
    234241        if (devmap_device_register("bd/initrd", &dev_handle) != EOK) {
    235242                devmap_hangup_phone(DEVMAP_DRIVER);
    236                 printf(NAME ": Unable to register device\n");
     243                printf("%s: Unable to register device\n", NAME);
    237244                return false;
    238245        }
     
    245252int main(int argc, char **argv)
    246253{
    247         printf(NAME ": HelenOS RAM disk server\n");
     254        printf("%s: HelenOS RAM disk server\n", NAME);
    248255       
    249256        if (!rd_init())
    250257                return -1;
    251258       
    252         printf(NAME ": Accepting connections\n");
     259        printf("%s: Accepting connections\n", NAME);
    253260        async_manager();
    254261
  • uspace/srv/hid/fb/ega.c

    r9256ad29 rd9fae235  
    415415        void *ega_ph_addr;
    416416        size_t sz;
    417 
    418         ega_ph_addr = (void *) sysinfo_value("fb.address.physical");
    419         scr_width = sysinfo_value("fb.width");
    420         scr_height = sysinfo_value("fb.height");
    421 
    422         if (sysinfo_value("fb.blinking")) {
     417       
     418        sysarg_t paddr;
     419        if (sysinfo_get_value("fb.address.physical", &paddr) != EOK)
     420                return -1;
     421       
     422        sysarg_t width;
     423        if (sysinfo_get_value("fb.width", &width) != EOK)
     424                return -1;
     425       
     426        sysarg_t height;
     427        if (sysinfo_get_value("fb.width", &height) != EOK)
     428                return -1;
     429       
     430        sysarg_t blinking;
     431        if (sysinfo_get_value("fb.blinking", &blinking) != EOK)
     432                blinking = false;
     433       
     434        ega_ph_addr = (void *) paddr;
     435        scr_width = width;
     436        scr_height = height;
     437        if (blinking) {
    423438                ega_normal_color &= 0x77;
    424439                ega_inverted_color &= 0x77;
    425440        }
    426 
     441       
    427442        style = NORMAL_COLOR;
    428 
     443       
    429444        iospace_enable(task_get_id(), (void *) EGA_IO_BASE, 2);
    430 
     445       
    431446        sz = scr_width * scr_height * 2;
    432447        scr_addr = as_get_mappable_page(sz);
    433 
     448       
    434449        if (physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>
    435450            PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE) != 0)
  • uspace/srv/hid/fb/fb.c

    r9256ad29 rd9fae235  
    17561756        async_set_client_connection(fb_client_connection);
    17571757       
    1758         void *fb_ph_addr = (void *) sysinfo_value("fb.address.physical");
    1759         unsigned int fb_offset = sysinfo_value("fb.offset");
    1760         unsigned int fb_width = sysinfo_value("fb.width");
    1761         unsigned int fb_height = sysinfo_value("fb.height");
    1762         unsigned int fb_scanline = sysinfo_value("fb.scanline");
    1763         unsigned int fb_visual = sysinfo_value("fb.visual");
    1764 
    1765         unsigned int fbsize = fb_scanline * fb_height;
     1758        sysarg_t fb_ph_addr;
     1759        if (sysinfo_get_value("fb.address.physical", &fb_ph_addr) != EOK)
     1760                return -1;
     1761       
     1762        sysarg_t fb_offset;
     1763        if (sysinfo_get_value("fb.offset", &fb_offset) != EOK)
     1764                fb_offset = 0;
     1765       
     1766        sysarg_t fb_width;
     1767        if (sysinfo_get_value("fb.width", &fb_width) != EOK)
     1768                return -1;
     1769       
     1770        sysarg_t fb_height;
     1771        if (sysinfo_get_value("fb.height", &fb_height) != EOK)
     1772                return -1;
     1773       
     1774        sysarg_t fb_scanline;
     1775        if (sysinfo_get_value("fb.scanline", &fb_scanline) != EOK)
     1776                return -1;
     1777       
     1778        sysarg_t fb_visual;
     1779        if (sysinfo_get_value("fb.visual", &fb_visual) != EOK)
     1780                return -1;
     1781       
     1782        sysarg_t fbsize = fb_scanline * fb_height;
    17661783        void *fb_addr = as_get_mappable_page(fbsize);
    1767 
    1768         if (physmem_map(fb_ph_addr + fb_offset, fb_addr,
     1784       
     1785        if (physmem_map((void *) fb_ph_addr + fb_offset, fb_addr,
    17691786            ALIGN_UP(fbsize, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE) != 0)
    17701787                return -1;
    1771 
     1788       
    17721789        if (screen_init(fb_addr, fb_width, fb_height, fb_scanline, fb_visual))
    17731790                return 0;
    1774 
     1791       
    17751792        return -1;
    17761793}
  • uspace/srv/hid/fb/main.c

    r9256ad29 rd9fae235  
    6060int main(int argc, char *argv[])
    6161{
    62         printf(NAME ": HelenOS Framebuffer service\n");
     62        printf("%s: HelenOS Framebuffer service\n", NAME);
    6363       
    64         ipcarg_t phonead;
    6564        bool initialized = false;
     65        sysarg_t fb_present;
     66        sysarg_t fb_kind;
     67       
     68        if (sysinfo_get_value("fb", &fb_present) != EOK)
     69                fb_present = false;
     70       
     71        if (sysinfo_get_value("fb.kind", &fb_kind) != EOK) {
     72                printf("%s: Unable to detect framebuffer configuration\n", NAME);
     73                return -1;
     74        }
    6675       
    6776#ifdef FB_ENABLED
    68         if (sysinfo_value("fb.kind") == 1) {
     77        if ((!initialized) && (fb_kind == 1)) {
    6978                if (fb_init() == 0)
    7079                        initialized = true;
     
    7281#endif
    7382#ifdef EGA_ENABLED
    74         if ((!initialized) && (sysinfo_value("fb.kind") == 2)) {
     83        if ((!initialized) && (fb_kind == 2)) {
    7584                if (ega_init() == 0)
    7685                        initialized = true;
     
    7887#endif
    7988#ifdef MSIM_ENABLED
    80         if ((!initialized) && (sysinfo_value("fb.kind") == 3)) {
     89        if ((!initialized) && (fb_kind == 3)) {
    8190                if (msim_init() == 0)
    8291                        initialized = true;
     
    8493#endif
    8594#ifdef SGCN_ENABLED
    86         if ((!initialized) && (sysinfo_value("fb.kind") == 4)) {
     95        if ((!initialized) && (fb_kind == 4)) {
    8796                if (sgcn_init() == 0)
    8897                        initialized = true;
     
    9099#endif
    91100#ifdef NIAGARA_ENABLED
    92         if ((!initialized) && (sysinfo_value("fb.kind") == 5)) {
     101        if ((!initialized) && (fb_kind == 5)) {
    93102                if (niagara_init() == 0)
    94103                        initialized = true;
     
    96105#endif
    97106#ifdef SKI_ENABLED
    98         if ((!initialized) && (sysinfo_value("fb") != true)) {
     107        if ((!initialized) && (!fb_present)) {
    99108                if (ski_init() == 0)
    100109                        initialized = true;
     
    105114                return -1;
    106115       
     116        ipcarg_t phonead;
    107117        if (ipc_connect_to_me(PHONE_NS, SERVICE_VIDEO, 0, 0, &phonead) != 0)
    108118                return -1;
    109119       
    110         printf(NAME ": Accepting connections\n");
     120        printf("%s: Accepting connections\n", NAME);
    111121        async_manager();
    112122       
  • uspace/srv/hid/fb/msim.c

    r9256ad29 rd9fae235  
    2929
    3030/** @defgroup msimfb MSIM text console
    31  * @brief       HelenOS MSIM text console.
     31 * @brief HelenOS MSIM text console.
    3232 * @ingroup fbs
    3333 * @{
    34  */ 
     34 */
    3535/** @file
    3636 */
     
    4141#include <as.h>
    4242#include <ddi.h>
     43#include <errno.h>
    4344
    4445#include "serial_console.h"
     
    5758int msim_init(void)
    5859{
    59         void *phys_addr = (void *) sysinfo_value("fb.address.physical");
     60        sysarg_t phys_addr;
     61        if (sysinfo_get_value("fb.address.physical", &phys_addr) != EOK)
     62                return -1;
     63       
    6064        virt_addr = (char *) as_get_mappable_page(1);
    6165       
    62         if (physmem_map(phys_addr, virt_addr, 1, AS_AREA_READ | AS_AREA_WRITE) != 0)
     66        if (physmem_map((void *) phys_addr, virt_addr, 1,
     67            AS_AREA_READ | AS_AREA_WRITE) != 0)
    6368                return -1;
    6469       
     
    6974}
    7075
    71 /**
    72  * @}
     76/** @}
    7377 */
  • uspace/srv/hid/fb/niagara.c

    r9256ad29 rd9fae235  
    9191int niagara_init(void)
    9292{
     93        sysarg_t paddr;
     94        if (sysinfo_get_value("niagara.outbuf.address", &paddr) != EOK)
     95                return -1;
     96       
    9397        output_buffer_addr = (uintptr_t) as_get_mappable_page(PAGE_SIZE);
    94         int result = physmem_map(
    95                 (void *) sysinfo_value("niagara.outbuf.address"),
    96                 (void *) output_buffer_addr,
    97                 1, AS_AREA_READ | AS_AREA_WRITE);
     98        int result = physmem_map((void *) paddr,
     99            (void *) output_buffer_addr, 1,
     100            AS_AREA_READ | AS_AREA_WRITE);
    98101
    99102        if (result != 0) {
  • uspace/srv/hid/fb/sgcn.c

    r9256ad29 rd9fae235  
    122122int sgcn_init(void)
    123123{
    124         sram_virt_addr = (uintptr_t) as_get_mappable_page(sysinfo_value("sram.area.size"));
     124        sysarg_t sram_paddr;
     125        if (sysinfo_get_value("sram.address.physical", &sram_paddr) != EOK)
     126                return -1;
    125127       
    126         if (physmem_map((void *) sysinfo_value("sram.address.physical"),
    127             (void *) sram_virt_addr, sysinfo_value("sram.area.size") / PAGE_SIZE,
    128             AS_AREA_READ | AS_AREA_WRITE) != 0)
     128        sysarg_t sram_size;
     129        if (sysinfo_get_value("sram.area.size", &sram_size) != EOK)
     130                return -1;
     131       
     132        if (sysinfo_get_value("sram.buffer.offset", &sram_buffer_offset) != EOK)
     133                sram_buffer_offset = 0;
     134       
     135        sram_virt_addr = (uintptr_t) as_get_mappable_page(sram_size);
     136       
     137        if (physmem_map((void *) sram_paddr, (void *) sram_virt_addr,
     138            sram_size / PAGE_SIZE, AS_AREA_READ | AS_AREA_WRITE) != 0)
    129139                return -1;
    130140       
    131141        serial_console_init(sgcn_putc, WIDTH, HEIGHT);
    132        
    133         sram_buffer_offset = sysinfo_value("sram.buffer.offset");
    134142       
    135143        async_set_client_connection(serial_client_connection);
  • uspace/srv/hid/kbd/generic/kbd.c

    r9256ad29 rd9fae235  
    212212int main(int argc, char **argv)
    213213{
    214         printf(NAME ": HelenOS Keyboard service\n");
    215        
    216         if (sysinfo_value("kbd.cir.fhc") == 1)
     214        printf("%s: HelenOS Keyboard service\n", NAME);
     215       
     216        sysarg_t fhc;
     217        sysarg_t obio;
     218       
     219        if ((sysinfo_get_value("kbd.cir.fhc", &fhc) == EOK) && (fhc))
    217220                cir_service = SERVICE_FHC;
    218         else if (sysinfo_value("kbd.cir.obio") == 1)
     221        else if ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio))
    219222                cir_service = SERVICE_OBIO;
    220223       
     
    240243        int rc = devmap_driver_register(NAME, client_connection);
    241244        if (rc < 0) {
    242                 printf(NAME ": Unable to register driver (%d)\n", rc);
     245                printf("%s: Unable to register driver (%d)\n", NAME, rc);
    243246                return -1;
    244247        }
     
    249252        dev_handle_t dev_handle;
    250253        if (devmap_device_register(kbd, &dev_handle) != EOK) {
    251                 printf(NAME ": Unable to register device %s\n", kbd);
     254                printf("%s: Unable to register device %s\n", NAME, kbd);
    252255                return -1;
    253256        }
  • uspace/srv/hid/kbd/port/gxemul.c

    r9256ad29 rd9fae235  
    4141#include <kbd.h>
    4242#include <ddi.h>
     43#include <errno.h>
    4344
    4445static irq_cmd_t gxemul_cmds[] = {
     
    6364int kbd_port_init(void)
    6465{
     66        sysarg_t addr;
     67        if (sysinfo_get_value("kbd.address.virtual", &addr) != EOK)
     68                return -1;
     69       
     70        sysarg_t inr;
     71        if (sysinfo_get_value("kbd.inr", &inr) != EOK)
     72                return -1;
     73       
    6574        async_set_interrupt_received(gxemul_irq_handler);
    66         gxemul_cmds[0].addr = (void *) sysinfo_value("kbd.address.virtual");
    67         ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(),
    68             0, &gxemul_kbd);
     75        gxemul_cmds[0].addr = (void *) addr;
     76        ipc_register_irq(inr, device_assign_devno(), 0, &gxemul_kbd);
    6977        return 0;
    7078}
  • uspace/srv/hid/kbd/port/msim.c

    r9256ad29 rd9fae235  
    3030 * @ingroup  kbd
    3131 * @{
    32  */ 
     32 */
    3333/** @file
    34  * @brief       Msim keyboard port driver.
     34 * @brief Msim keyboard port driver.
    3535 */
    3636
     
    4141#include <kbd.h>
    4242#include <ddi.h>
     43#include <errno.h>
    4344
    4445irq_cmd_t msim_cmds[] = {
     
    6364int kbd_port_init(void)
    6465{
     66        sysarg_t vaddr;
     67        if (sysinfo_get_value("kbd.address.virtual", &vaddr) != EOK)
     68                return -1;
     69       
     70        sysarg_t inr;
     71        if (sysinfo_get_value("kbd.inr", &inr) != EOK)
     72                return -1;
     73       
     74        msim_cmds[0].addr = (void *) vaddr;
    6575        async_set_interrupt_received(msim_irq_handler);
    66         msim_cmds[0].addr = (void *) sysinfo_value("kbd.address.virtual");
    67         ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(),
    68             0, &msim_kbd);
     76        ipc_register_irq(inr, device_assign_devno(), 0, &msim_kbd);
     77       
    6978        return 0;
    7079}
  • uspace/srv/hid/kbd/port/niagara.c

    r9256ad29 rd9fae235  
    4444#include <thread.h>
    4545#include <bool.h>
     46#include <errno.h>
    4647
    47 #define POLL_INTERVAL           10000
     48#define POLL_INTERVAL  10000
    4849
    4950/**
     
    5758 * kernel/arch/sparc64/src/drivers/niagara.c.
    5859 */
    59 #define INPUT_BUFFER_SIZE       ((PAGE_SIZE) - 2 * 8)
     60#define INPUT_BUFFER_SIZE  ((PAGE_SIZE) - 2 * 8)
     61
    6062typedef volatile struct {
    6163        uint64_t write_ptr;
     
    7981int kbd_port_init(void)
    8082{
     83        sysarg_t paddr;
     84        if (sysinfo_get_value("niagara.inbuf.address", &paddr) != EOK)
     85                return -1;
     86       
    8187        input_buffer_addr = (uintptr_t) as_get_mappable_page(PAGE_SIZE);
    82         int result = physmem_map(
    83                 (void *) sysinfo_value("niagara.inbuf.address"),
    84                 (void *) input_buffer_addr,
    85                 1, AS_AREA_READ | AS_AREA_WRITE);
    86 
    87         if (result != 0) {
     88        int rc = physmem_map((void *) paddr, (void *) input_buffer_addr,
     89            1, AS_AREA_READ | AS_AREA_WRITE);
     90       
     91        if (rc != 0) {
    8892                printf("Niagara: uspace driver couldn't map physical memory: %d\n",
    89                         result);
    90         }
    91 
    92         input_buffer = (input_buffer_t) input_buffer_addr;
    93 
    94         thread_id_t tid;
    95         int rc;
    96 
    97         rc = thread_create(niagara_thread_impl, NULL, "kbd_poll", &tid);
    98         if (rc != 0) {
     93                    rc);
    9994                return rc;
    10095        }
     96       
     97        input_buffer = (input_buffer_t) input_buffer_addr;
     98       
     99        thread_id_t tid;
     100        rc = thread_create(niagara_thread_impl, NULL, "kbd_poll", &tid);
     101        if (rc != 0)
     102                return rc;
     103       
    101104        return 0;
    102105}
  • uspace/srv/hid/kbd/port/ns16550.c

    r9256ad29 rd9fae235  
    3030 * @ingroup  kbd
    3131 * @{
    32  */ 
     32 */
    3333/** @file
    34  * @brief       NS16550 port driver.
     34 * @brief NS16550 port driver.
    3535 */
    3636
     
    4343#include <sun.h>
    4444#include <ddi.h>
     45#include <errno.h>
    4546
    4647/* NS16550 registers */
    47 #define RBR_REG         0       /** Receiver Buffer Register. */
    48 #define IER_REG         1       /** Interrupt Enable Register. */
    49 #define IIR_REG         2       /** Interrupt Ident Register (read). */
    50 #define FCR_REG         2       /** FIFO control register (write). */
    51 #define LCR_REG         3       /** Line Control register. */
    52 #define MCR_REG         4       /** Modem Control Register. */
    53 #define LSR_REG         5       /** Line Status Register. */
     48#define RBR_REG  0  /** Receiver Buffer Register. */
     49#define IER_REG  1  /** Interrupt Enable Register. */
     50#define IIR_REG  2  /** Interrupt Ident Register (read). */
     51#define FCR_REG  2  /** FIFO control register (write). */
     52#define LCR_REG  3  /** Line Control register. */
     53#define MCR_REG  4  /** Modem Control Register. */
     54#define LSR_REG  5  /** Line Status Register. */
    5455
    55 #define LSR_DATA_READY  0x01
     56#define LSR_DATA_READY  0x01
    5657
    5758static irq_cmd_t ns16550_cmds[] = {
    5859        {
    5960                .cmd = CMD_PIO_READ_8,
    60                 .addr = (void *) 0,     /* will be patched in run-time */
     61                .addr = (void *) 0,     /* Will be patched in run-time */
    6162                .dstarg = 1
    6263        },
     
    7475        {
    7576                .cmd = CMD_PIO_READ_8,
    76                 .addr = (void *) 0,     /* will be patched in run-time */
     77                .addr = (void *) 0,     /* Will be patched in run-time */
    7778                .dstarg = 2
    7879        },
     
    9697        void *vaddr;
    9798
    98         async_set_interrupt_received(ns16550_irq_handler);
    99 
    100         ns16550_physical = sysinfo_value("kbd.address.physical");
    101         ns16550_kernel = sysinfo_value("kbd.address.kernel");
     99        if (sysinfo_get_value("kbd.address.physical", &ns16550_physical) != EOK)
     100                return -1;
     101       
     102        if (sysinfo_get_value("kbd.address.kernel", &ns16550_kernel) != EOK)
     103                return -1;
     104       
     105        sysarg_t inr;
     106        if (sysinfo_get_value("kbd.inr", &inr) != EOK)
     107                return -1;
     108       
    102109        ns16550_kbd.cmds[0].addr = (void *) (ns16550_kernel + LSR_REG);
    103110        ns16550_kbd.cmds[3].addr = (void *) (ns16550_kernel + RBR_REG);
    104         ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(),
    105             sysinfo_value("kbd.inr"), &ns16550_kbd);
     111       
     112        async_set_interrupt_received(ns16550_irq_handler);
     113        ipc_register_irq(inr, device_assign_devno(), inr, &ns16550_kbd);
     114       
    106115        return pio_enable((void *) ns16550_physical, 8, &vaddr);
    107116}
  • uspace/srv/hid/kbd/port/pl050.c

    r9256ad29 rd9fae235  
    8383int kbd_port_init(void)
    8484{
    85 
    86         pl050_kbd.cmds[0].addr = (void *) sysinfo_value("kbd.address.status");
    87         pl050_kbd.cmds[3].addr = (void *) sysinfo_value("kbd.address.data");
    88 
     85        if (sysinfo_get_value("kbd.address.status", &pl050_kbd.cmds[0].addr) != EOK)
     86                return -1;
     87       
     88        if (sysinfo_get_value("kbd.address.data", &pl050_kbd.cmds[3].addr) != EOK)
     89                return -1;
     90       
     91        sysarg_t inr;
     92        if (sysinfo_get_value("kbd.inr", &inr) != EOK)
     93                return -1;
     94       
    8995        async_set_interrupt_received(pl050_irq_handler);
    90 
    91         ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(), 0, &pl050_kbd);
    92 
     96        ipc_register_irq(inr, device_assign_devno(), 0, &pl050_kbd);
     97       
    9398        return 0;
    9499}
  • uspace/srv/hid/kbd/port/sgcn.c

    r9256ad29 rd9fae235  
    3030 * @ingroup  kbd
    3131 * @{
    32  */ 
     32 */
    3333/** @file
    34  * @brief       SGCN (Serengeti Console) keyboard port driver.
     34 * @brief SGCN (Serengeti Console) keyboard port driver.
    3535 */
    3636
     
    4444#include <thread.h>
    4545#include <bool.h>
     46#include <errno.h>
    4647
    47 #define POLL_INTERVAL           10000
     48#define POLL_INTERVAL  10000
    4849
    4950/**
    5051 * SGCN buffer header. It is placed at the very beginning of the SGCN
    51  * buffer. 
     52 * buffer.
    5253 */
    5354typedef struct {
     
    102103int kbd_port_init(void)
    103104{
    104         sram_virt_addr = (uintptr_t) as_get_mappable_page(sysinfo_value("sram.area.size"));
    105         if (physmem_map((void *) sysinfo_value("sram.address.physical"),
    106             (void *) sram_virt_addr, sysinfo_value("sram.area.size") / PAGE_SIZE,
    107             AS_AREA_READ | AS_AREA_WRITE) != 0) {
     105        sysarg_t sram_paddr;
     106        if (sysinfo_get_value("sram.address.physical", &sram_paddr) != EOK)
     107                return -1;
     108       
     109        sysarg_t sram_size;
     110        if (sysinfo_get_value("sram.area.size", &sram_size) != EOK)
     111                return -1;
     112       
     113        if (sysinfo_get_value("sram.buffer.offset", &sram_buffer_offset) != EOK)
     114                sram_buffer_offset = 0;
     115       
     116        sram_virt_addr = (uintptr_t) as_get_mappable_page(sram_size);
     117       
     118        if (physmem_map((void *) sram_paddr, (void *) sram_virt_addr,
     119            sram_size / PAGE_SIZE, AS_AREA_READ | AS_AREA_WRITE) != 0) {
    108120                printf("SGCN: uspace driver could not map physical memory.");
    109121                return -1;
    110122        }
    111123       
    112         sram_buffer_offset = sysinfo_value("sram.buffer.offset");
    113 
    114124        thread_id_t tid;
    115         int rc;
    116 
    117         rc = thread_create(sgcn_thread_impl, NULL, "kbd_poll", &tid);
    118         if (rc != 0) {
     125        int rc = thread_create(sgcn_thread_impl, NULL, "kbd_poll", &tid);
     126        if (rc != 0)
    119127                return rc;
    120         }
    121 
     128       
    122129        return 0;
    123130}
  • uspace/srv/hid/kbd/port/sun.c

    r9256ad29 rd9fae235  
    3939#include <sun.h>
    4040#include <sysinfo.h>
     41#include <errno.h>
     42#include <bool.h>
    4143
    4244/** Sun keyboard virtual port driver.
     
    5052int kbd_port_init(void)
    5153{
    52         if (sysinfo_value("kbd.type.z8530")) {
     54        sysarg_t z8530;
     55        if (sysinfo_get_value("kbd.type.z8530", &z8530) != EOK)
     56                z8530 = false;
     57       
     58        sysarg_t ns16550;
     59        if (sysinfo_get_value("kbd.type.ns16550", &ns16550) != EOK)
     60                ns16550 = false;
     61       
     62        if (z8530) {
    5363                if (z8530_port_init() == 0)
    5464                        return 0;
    5565        }
    5666       
    57         if (sysinfo_value("kbd.type.ns16550")) {
     67        if (ns16550) {
    5868                if (ns16550_port_init() == 0)
    5969                        return 0;
  • uspace/srv/hid/kbd/port/z8530.c

    r9256ad29 rd9fae235  
    3030 * @ingroup  kbd
    3131 * @{
    32  */ 
     32 */
    3333/** @file
    34  * @brief       Z8530 keyboard port driver.
     34 * @brief Z8530 keyboard port driver.
    3535 */
    3636
     
    4444#include <sys/types.h>
    4545#include <ddi.h>
     46#include <errno.h>
    4647
    47 #define CHAN_A_STATUS   4
    48 #define CHAN_A_DATA     6
     48#define CHAN_A_STATUS  4
     49#define CHAN_A_DATA    6
    4950
    50 #define RR0_RCA 1
     51#define RR0_RCA  1
    5152
    5253static irq_cmd_t z8530_cmds[] = {
    5354        {
    5455                .cmd = CMD_PIO_READ_8,
    55                 .addr = (void *) 0,     /* will be patched in run-time */
     56                .addr = (void *) 0,     /* Will be patched in run-time */
    5657                .dstarg = 1
    5758        },
     
    6970        {
    7071                .cmd = CMD_PIO_READ_8,
    71                 .addr = (void *) 0,     /* will be patched in run-time */
     72                .addr = (void *) 0,     /* Will be patched in run-time */
    7273                .dstarg = 2
    7374        },
     
    8687int z8530_port_init(void)
    8788{
     89        sysarg_t kaddr;
     90        if (sysinfo_get_value("kbd.address.kernel", &kaddr) != EOK)
     91                return -1;
     92       
     93        sysarg_t inr;
     94        if (sysinfo_get_value("kbd.inr", &inr) != EOK)
     95                return -1;
     96       
     97        z8530_cmds[0].addr = (void *) kaddr + CHAN_A_STATUS;
     98        z8530_cmds[3].addr = (void *) kaddr + CHAN_A_DATA;
     99       
    88100        async_set_interrupt_received(z8530_irq_handler);
    89         z8530_cmds[0].addr = (void *) sysinfo_value("kbd.address.kernel") +
    90             CHAN_A_STATUS;
    91         z8530_cmds[3].addr = (void *) sysinfo_value("kbd.address.kernel") +
    92             CHAN_A_DATA;
    93         ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(),
    94             sysinfo_value("kbd.inr"), &z8530_kbd);
     101        ipc_register_irq(inr, device_assign_devno(), inr, &z8530_kbd);
     102       
    95103        return 0;
    96104}
  • uspace/srv/hw/bus/cuda_adb/cuda_adb.c

    r9256ad29 rd9fae235  
    254254static int cuda_init(void)
    255255{
     256        if (sysinfo_get_value("cuda.address.physical", &(instance->cuda_physical)) != EOK)
     257                return -1;
     258       
     259        if (sysinfo_get_value("cuda.address.kernel", &(instance->cuda_kernel)) != EOK)
     260                return -1;
     261       
    256262        void *vaddr;
    257 
    258         instance->cuda_physical = sysinfo_value("cuda.address.physical");
    259         instance->cuda_kernel = sysinfo_value("cuda.address.kernel");
    260 
    261263        if (pio_enable((void *) instance->cuda_physical, sizeof(cuda_t), &vaddr) != 0)
    262264                return -1;
     265       
    263266        dev = vaddr;
    264267
  • uspace/srv/hw/char/i8042/i8042.c

    r9256ad29 rd9fae235  
    164164static int i8042_init(void)
    165165{
     166        if (sysinfo_get_value("i8042.address.physical", &i8042_physical) != EOK)
     167                return -1;
     168       
     169        if (sysinfo_get_value("i8042.address.kernel", &i8042_kernel) != EOK)
     170                return -1;
     171       
    166172        void *vaddr;
    167 
    168         i8042_physical = sysinfo_value("i8042.address.physical");
    169         i8042_kernel = sysinfo_value("i8042.address.kernel");
    170173        if (pio_enable((void *) i8042_physical, sizeof(i8042_t), &vaddr) != 0)
    171174                return -1;
     175       
    172176        i8042 = vaddr;
    173 
     177       
     178        sysarg_t inr_a;
     179        sysarg_t inr_b;
     180       
     181        if (sysinfo_get_value("i8042.inr_a", &inr_a) != EOK)
     182                return -1;
     183       
     184        if (sysinfo_get_value("i8042.inr_b", &inr_b) != EOK)
     185                return -1;
     186       
    174187        async_set_interrupt_received(i8042_irq_handler);
    175 
     188       
    176189        /* Disable kbd and aux */
    177190        wait_ready();
     
    186199        i8042_kbd.cmds[0].addr = (void *) &((i8042_t *) i8042_kernel)->status;
    187200        i8042_kbd.cmds[3].addr = (void *) &((i8042_t *) i8042_kernel)->data;
    188         ipc_register_irq(sysinfo_value("i8042.inr_a"), device_assign_devno(), 0, &i8042_kbd);
    189         ipc_register_irq(sysinfo_value("i8042.inr_b"), device_assign_devno(), 0, &i8042_kbd);
    190         printf("i8042: registered for interrupts %d and %d\n",
    191             sysinfo_value("i8042.inr_a"), sysinfo_value("i8042.inr_b"));
     201        ipc_register_irq(inr_a, device_assign_devno(), 0, &i8042_kbd);
     202        ipc_register_irq(inr_b, device_assign_devno(), 0, &i8042_kbd);
     203        printf("%s: registered for interrupts %d and %d\n", NAME, inr_a, inr_b);
    192204
    193205        wait_ready();
  • uspace/srv/hw/cir/fhc/fhc.c

    r9256ad29 rd9fae235  
    109109static bool fhc_init(void)
    110110{
    111         ipcarg_t phonead;
     111        sysarg_t paddr;
    112112
    113         fhc_uart_size = sysinfo_value("fhc.uart.size");
    114         fhc_uart_phys = (void *) sysinfo_value("fhc.uart.physical");
    115        
    116         if (!fhc_uart_size) {
     113        if ((sysinfo_get_value("fhc.uart.physical", &paddr) != EOK)
     114            || (sysinfo_get_value("fhc.uart.size", &fhc_uart_size) != EOK)) {
    117115                printf(NAME ": no FHC UART registers found\n");
    118116                return false;
    119117        }
    120 
     118       
     119        fhc_uart_phys = (void *) paddr;
    121120        fhc_uart_virt = as_get_mappable_page(fhc_uart_size);
    122121       
     
    132131        printf(NAME ": FHC UART registers at %p, %d bytes\n", fhc_uart_phys,
    133132            fhc_uart_size);
    134 
     133       
    135134        async_set_client_connection(fhc_connection);
     135        ipcarg_t phonead;
    136136        ipc_connect_to_me(PHONE_NS, SERVICE_FHC, 0, 0, &phonead);
    137137       
  • uspace/srv/hw/cir/obio/obio.c

    r9256ad29 rd9fae235  
    112112static bool obio_init(void)
    113113{
    114         ipcarg_t phonead;
    115 
    116         base_phys = (void *) sysinfo_value("obio.base.physical");
     114        sysarg_t paddr;
    117115       
    118         if (!base_phys) {
     116        if (sysinfo_get_value("obio.base.physical", &paddr) != EOK) {
    119117                printf(NAME ": no OBIO registers found\n");
    120118                return false;
    121119        }
    122 
     120       
     121        base_phys = (void *) paddr;
    123122        base_virt = as_get_mappable_page(OBIO_SIZE);
    124123       
     
    133132       
    134133        printf(NAME ": OBIO registers with base at %p\n", base_phys);
    135 
     134       
    136135        async_set_client_connection(obio_connection);
     136        ipcarg_t phonead;
    137137        ipc_connect_to_me(PHONE_NS, SERVICE_OBIO, 0, 0, &phonead);
    138138       
  • uspace/srv/net/cfg/ne2k.netif_nil_bundle

    r9256ad29 rd9fae235  
    77IL=ip
    88
    9 # sysinfo_value("netif.dp8390.inr")
    109IRQ=9
    1110IO=300
  • uspace/srv/net/cfg/ne2k.netif_standalone

    r9256ad29 rd9fae235  
    77IL=ip
    88
    9 # sysinfo_value("netif.dp8390.inr")
    109IRQ=9
    1110IO=300
  • uspace/srv/net/netstart/netstart.c

    r9256ad29 rd9fae235  
    4444#include <stdio.h>
    4545#include <task.h>
     46#include <str_error.h>
    4647#include <ipc/ipc.h>
    4748#include <ipc/services.h>
     
    7172        argv[1] = NULL;
    7273       
    73         if (task_spawn(path, argv) == 0) {
    74                 fprintf(stderr, "%s: Error spawning %s\n", NAME, path);
     74        int err;
     75        if (task_spawn(path, argv, &err) == 0) {
     76                fprintf(stderr, "%s: Error spawning %s (%s)\n", NAME, path,
     77                    str_error(err));
    7578                return false;
    7679        }
  • uspace/srv/ns/ns.c

    r9256ad29 rd9fae235  
    5555static void *klogaddr = NULL;
    5656
    57 static void get_as_area(ipc_callid_t callid, ipc_call_t *call, void *ph_addr,
     57static void get_as_area(ipc_callid_t callid, ipc_call_t *call, void *faddr,
    5858    size_t pages, void **addr)
    5959{
    60         if (ph_addr == NULL) {
     60        if ((faddr == NULL) || (pages == 0)) {
    6161                ipc_answer_0(callid, ENOENT);
    6262                return;
     
    7171                }
    7272               
    73                 if (physmem_map(ph_addr, *addr, pages,
     73                if (physmem_map(faddr, *addr, pages,
    7474                    AS_AREA_READ | AS_AREA_CACHEABLE) != 0) {
    7575                        ipc_answer_0(callid, ENOENT);
     
    8181}
    8282
     83static void setup_clock_area(ipc_callid_t callid, ipc_call_t *call, void **addr)
     84{
     85        uintptr_t faddr;
     86        int err = sysinfo_get_value("clock.faddr", &faddr);
     87       
     88        if (err != EOK)
     89                ipc_answer_0(callid, err);
     90       
     91        get_as_area(callid, call, (void *) faddr, 1, addr);
     92}
     93
     94static void setup_klog_area(ipc_callid_t callid, ipc_call_t *call, void **addr)
     95{
     96        uintptr_t faddr;
     97        int err = sysinfo_get_value("klog.faddr", &faddr);
     98       
     99        if (err != EOK)
     100                ipc_answer_0(callid, err);
     101       
     102        size_t pages;
     103        err = sysinfo_get_value("klog.pages", &pages);
     104       
     105        if (err != EOK)
     106                ipc_answer_0(callid, err);
     107       
     108        get_as_area(callid, call, (void *) faddr, pages, addr);
     109}
     110
    83111int main(int argc, char **argv)
    84112{
     
    97125                return rc;
    98126       
    99         printf(NAME ": Accepting connections\n");
     127        printf("%s: Accepting connections\n", NAME);
    100128       
    101129        while (true) {
     
    113141                        switch (IPC_GET_ARG3(call)) {
    114142                        case SERVICE_MEM_REALTIME:
    115                                 get_as_area(callid, &call,
    116                                     (void *) sysinfo_value("clock.faddr"),
    117                                     1, &clockaddr);
     143                                setup_clock_area(callid, &call, &clockaddr);
    118144                                break;
    119145                        case SERVICE_MEM_KLOG:
    120                                 get_as_area(callid, &call,
    121                                     (void *) sysinfo_value("klog.faddr"),
    122                                     sysinfo_value("klog.pages"), &klogaddr);
     146                                setup_klog_area(callid, &call, &klogaddr);
    123147                                break;
    124148                        default:
  • uspace/srv/taskmon/taskmon.c

    r9256ad29 rd9fae235  
    4444#include <macros.h>
    4545#include <errno.h>
     46#include <str_error.h>
    4647
    4748#define NAME  "taskmon"
     
    9697        }
    9798        putchar('\n');
    98 
    99         if (!task_spawn(fname, argv))
    100                 printf(NAME ": Error spawning taskdump.\n", fname);
     99       
     100        int err;
     101        if (!task_spawn(fname, argv, &err))
     102                printf("%s: Error spawning %s (%s).\n", NAME, fname,
     103                    str_error(err));
    101104}
    102105
Note: See TracChangeset for help on using the changeset viewer.