Changeset d9fae235 in mainline for uspace


Ignore:
Timestamp:
2010-04-17T01:28:38Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
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
Location:
uspace
Files:
38 edited

Legend:

Unmodified
Added
Removed

  • 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.