Changeset 9dae191e in mainline for kernel


Ignore:
Timestamp:
2010-04-18T00:24:40Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a80687e5
Parents:
d8e3467
Message:

sysinfo API cleanup

  • better support for generated subtrees
  • synchronization
  • memory management (generated items cleanup)
  • simplier sysinfo_dump()

remove separate statistical syscalls, replace with virtual sysinfo items (some functionality is still missing)

  • naming consolidation
  • cleaner API
  • proper synchronization

minor renames

  • zone_print_list() → zones_print_list()
  • zone_busy_and_free() → zones_stats()
Location:
kernel
Files:
1 added
9 deleted
14 edited
2 moved

Legend:

Unmodified
Added
Removed

  • kernel/Makefile

    rd8e3467 r9dae191e  
    230230        generic/src/security/cap.c \
    231231        generic/src/sysinfo/sysinfo.c \
    232         generic/src/ps/ps.c \
    233         generic/src/ps/cpu.c \
    234         generic/src/ps/load.c \
    235         generic/src/ps/uptime.c \
    236         generic/src/ps/mem.c
     232        generic/src/sysinfo/stats.c
    237233
    238234## Kernel console support

  • kernel/generic/include/mm/frame.h

    rd8e3467 r9dae191e  
    169169extern bool zone_merge(size_t, size_t);
    170170extern void zone_merge_all(void);
    171 extern uint64_t zone_total_size(void);
    172 extern void zone_busy_and_free(uint64_t *out_busy, uint64_t *out_free);
     171extern uint64_t zones_total_size(void);
     172extern void zones_stats(uint64_t *, uint64_t *, uint64_t *, uint64_t *);
    173173
    174174/*
    175175 * Console functions
    176176 */
    177 extern void zone_print_list(void);
     177extern void zones_print_list(void);
    178178extern void zone_print_one(size_t);
    179179

  • kernel/generic/include/proc/task.h

    rd8e3467 r9dae191e  
    5656#include <ipc/kbox.h>
    5757#include <mm/as.h>
    58 
    59 #include <ps/taskinfo.h>
     58#include <sysinfo/abi.h>
    6059
    6160struct thread;
    … …  
    8180        task_id_t taskid;
    8281        /** Task security context. */
    83         context_id_t context;   
     82        context_id_t context;
    8483
    8584        /** Number of references (i.e. threads). */
    … …  
    8988
    9089        /** Task capabilities. */
    91         cap_t capabilities;     
     90        cap_t capabilities;
    9291
    9392        /* IPC stuff */
    9493        answerbox_t answerbox;  /**< Communication endpoint */
    9594        phone_t phones[IPC_MAX_PHONES];
    96         task_ipc_info_t ipc_info; /**< IPC statistics */
     95        stats_ipc_t ipc_info;  /**< IPC statistics */
    9796        /**
    9897         * Active asynchronous messages. It is used for limiting uspace to
    … …  
    120119        mutex_t futexes_lock;
    121120        /** B+tree of futexes referenced by this task. */
    122         btree_t futexes;       
     121        btree_t futexes;
    123122       
    124123        /** Accumulated accounting. */

  • kernel/generic/include/proc/thread.h

    rd8e3467 r9dae191e  
    6969#define THREAD_FLAG_NOATTACH    (1 << 3)
    7070
    71 /* We need state_t enum definition */
    72 #include <ps/taskinfo.h>
     71/** Thread states. */
     72typedef enum {
     73        /** It is an error, if thread is found in this state. */
     74        Invalid,
     75        /** State of a thread that is currently executing on some CPU. */
     76        Running,
     77        /** Thread in this state is waiting for an event. */
     78        Sleeping,
     79        /** State of threads in a run queue. */
     80        Ready,
     81        /** Threads are in this state before they are first readied. */
     82        Entering,
     83        /** After a thread calls thread_exit(), it is put into Exiting state. */
     84        Exiting,
     85        /** Threads that were not detached but exited are Lingering. */
     86        Lingering
     87} state_t;
    7388
    7489/** Thread structure. There is one per thread. */

  • kernel/generic/include/syscall/syscall.h

    rd8e3467 r9dae191e  
    7171        SYS_IPC_REGISTER_IRQ,
    7272        SYS_IPC_UNREGISTER_IRQ,
    73 
     73       
    7474        SYS_EVENT_SUBSCRIBE,
    7575       
    … …  
    8989        SYS_DEBUG_ENABLE_CONSOLE,
    9090        SYS_DEBUG_DISABLE_CONSOLE,
    91 
    92         SYS_PS_GET_CPU_INFO,
    93         SYS_PS_GET_MEM_INFO,
    94         SYS_PS_GET_TASKS,
    95         SYS_PS_GET_TASK_INFO,
    96         SYS_PS_GET_THREADS,
    97         SYS_PS_GET_UPTIME,
    98         SYS_PS_GET_LOAD,
    99 
     91       
    10092        SYS_IPC_CONNECT_KBOX,
    10193        SYSCALL_END

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

    rd8e3467 r9dae191e  
    11/*
    2  * Copyright (c) 2010 Stanislav Kozina
     2 * Copyright (c) 2010 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    3333 */
    3434
    35 #ifndef KERN_PS_CPU_H_
    36 #define KERN_PS_CPU_H_
     35#ifndef KERN_ABI_H_
     36#define KERN_ABI_H_
     37
     38#define LOAD_STEPS        3
     39#define TASK_NAME_BUFLEN  20
    3740
    3841typedef struct {
    … …  
    4144        uint64_t idle_ticks;
    4245        uint64_t busy_ticks;
    43 } uspace_cpu_info_t;
     46} stats_cpu_t;
     47
     48typedef struct {
     49        uint64_t total;
     50        uint64_t unavail;
     51        uint64_t used;
     52        uint64_t free;
     53} stats_physmem_t;
     54
     55typedef struct {
     56        uint64_t call_sent;
     57        uint64_t call_recieved;
     58        uint64_t answer_sent;
     59        uint64_t answer_recieved;
     60        uint64_t irq_notif_recieved;
     61        uint64_t forwarded;
     62} stats_ipc_t;
     63
     64typedef struct {
     65        char name[TASK_NAME_BUFLEN];
     66        size_t virtmem;
     67        size_t threads;
     68        uint64_t ucycles;
     69        uint64_t kcycles;
     70        stats_ipc_t ipc_info;
     71} stats_task_t;
     72
     73typedef uint32_t load_t;
    4474
    4575#endif

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

    rd8e3467 r9dae191e  
    11/*
    2  * Copyright (c) 2010 Stanislav Kozina
     2 * Copyright (c) 2010 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    3333 */
    3434
    35 #ifndef KERN_PS_UPTIME_H_
    36 #define KERN_PS_UPTIME_H_
     35#ifndef KERN_STATS_H_
     36#define KERN_STATS_H_
    3737
    38 extern int sys_ps_get_uptime(uint64_t *user_load);
     38extern void kload(void *arg);
     39extern void stats_init(void);
    3940
    4041#endif

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

    rd8e3467 r9dae191e  
    5959typedef unative_t (*sysinfo_fn_val_t)(struct sysinfo_item *);
    6060typedef void *(*sysinfo_fn_data_t)(struct sysinfo_item *, size_t *);
    61 typedef struct sysinfo_item *(*sysinfo_fn_subtree_t)(const char *);
    6261
    6362typedef struct {
    … …  
    7372} sysinfo_item_val_t;
    7473
     74typedef struct {
     75        sysinfo_item_val_type_t tag;
     76        union {
     77                unative_t val;
     78                sysinfo_data_t data;
     79        };
     80} sysinfo_return_t;
     81
     82typedef sysinfo_return_t (*sysinfo_fn_subtree_t)(const char *);
     83
    7584typedef union {
    7685        struct sysinfo_item *table;
    77         sysinfo_fn_subtree_t find_item;
     86        sysinfo_fn_subtree_t get_data;
    7887} sysinfo_subtree_t;
    7988
    … …  
    9099} sysinfo_item_t;
    91100
    92 typedef struct {
    93         sysinfo_item_val_type_t tag;
    94         union {
    95                 unative_t val;
    96                 sysinfo_data_t data;
    97         };
    98 } sysinfo_return_t;
    99 
    100 extern void sysinfo_init(void);
    101 
    102101extern void sysinfo_set_item_val(const char *, sysinfo_item_t **, unative_t);
    103102extern void sysinfo_set_item_data(const char *, sysinfo_item_t **, void *,
    104103    size_t);
    105 extern void sysinfo_set_item_val_fn(const char *, sysinfo_item_t **,
     104extern void sysinfo_set_item_fn_val(const char *, sysinfo_item_t **,
    106105    sysinfo_fn_val_t);
    107 extern void sysinfo_set_item_data_fn(const char *, sysinfo_item_t **,
     106extern void sysinfo_set_item_fn_data(const char *, sysinfo_item_t **,
    108107    sysinfo_fn_data_t);
    109108extern void sysinfo_set_item_undefined(const char *, sysinfo_item_t **);
    110109
    111 extern sysinfo_return_t sysinfo_get_item(const char *, sysinfo_item_t **);
    112 extern void sysinfo_dump(sysinfo_item_t **, unsigned int);
     110extern void sysinfo_set_subtree_fn(const char *, sysinfo_item_t **,
     111    sysinfo_fn_subtree_t);
     112
     113extern void sysinfo_init(void);
     114extern void sysinfo_dump(sysinfo_item_t *);
    113115
    114116unative_t sys_sysinfo_get_tag(void *, size_t);

  • kernel/generic/src/console/cmd.c

    rd8e3467 r9dae191e  
    886886int cmd_sysinfo(cmd_arg_t * argv)
    887887{
    888         sysinfo_dump(NULL, 0);
     888        sysinfo_dump(NULL);
    889889        return 1;
    890890}
    … …  
    935935int cmd_zones(cmd_arg_t * argv)
    936936{
    937         zone_print_list();
     937        zones_print_list();
    938938        return 1;
    939939}

  • kernel/generic/src/cpu/cpu.c

    rd8e3467 r9dae191e  
    7575                       
    7676                        cpus[i].id = i;
    77                         cpus[i].idle_ticks = 0;
    78                         cpus[i].busy_ticks = 0;
    7977                       
    8078                        spinlock_initialize(&cpus[i].lock, "cpu_t.lock");
    … …  
    9795        cpu_identify();
    9896        cpu_arch_init();
    99 
    100         sysinfo_set_item_val("cpu.count", NULL, config.cpu_count);
    10197}
    10298

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

    rd8e3467 r9dae191e  
    6767#include <debug.h>
    6868#include <str.h>
    69 #include <ps/load.h>
     69#include <sysinfo/stats.h>
    7070
    7171#ifdef CONFIG_SMP
    … …  
    123123                } else
    124124                        panic("Unable to create kmp thread.");
     125               
    125126                thread_join(thread);
    126127                thread_detach(thread);
    … …  
    151152        arch_post_smp_init();
    152153       
     154        /* Start thread computing system load */
     155        thread = thread_create(kload, NULL, TASK, 0, "kload", false);
     156        if (thread != NULL)
     157                thread_ready(thread);
     158        else
     159                printf("Unable to create kload thread\n");
     160       
    153161#ifdef CONFIG_KCONSOLE
    154162        if (stdin) {
    … …  
    164172#endif /* CONFIG_KCONSOLE */
    165173       
    166         /* Start thread computing system load */
    167         thread = thread_create(kload_thread, NULL, TASK, 0, "kload", false);
    168         if (thread != NULL)
    169                 thread_ready(thread);
    170         else
    171                 printf("Unable to create kload thread\n");
    172 
    173174        interrupts_enable();
    174175       

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

    rd8e3467 r9dae191e  
    8585#include <ipc/event.h>
    8686#include <sysinfo/sysinfo.h>
     87#include <sysinfo/stats.h>
    8788
    8889/** Global configuration structure. */
    … …  
    225226       
    226227        printf("Detected %" PRIs " CPU(s), %" PRIu64" MiB free memory\n",
    227             config.cpu_count, SIZE2MB(zone_total_size()));
     228            config.cpu_count, SIZE2MB(zones_total_size()));
    228229
    229230        LOG_EXEC(cpu_init());
    … …  
    249250        LOG_EXEC(event_init());
    250251        LOG_EXEC(klog_init());
     252        LOG_EXEC(stats_init());
    251253       
    252254        /*

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

    rd8e3467 r9dae191e  
    12021202
    12031203/** Return total size of all zones. */
    1204 uint64_t zone_total_size(void)
     1204uint64_t zones_total_size(void)
    12051205{
    12061206        ipl_t ipl = interrupts_disable();
    … …  
    12181218}
    12191219
    1220 void zone_busy_and_free(uint64_t *out_busy, uint64_t *out_free)
    1221 {
     1220void zones_stats(uint64_t *total, uint64_t *unavail, uint64_t *busy,
     1221    uint64_t *free)
     1222{
     1223        ASSERT(total != NULL);
     1224        ASSERT(unavail != NULL);
     1225        ASSERT(busy != NULL);
     1226        ASSERT(free != NULL);
     1227       
    12221228        ipl_t ipl = interrupts_disable();
    12231229        spinlock_lock(&zones.lock);
    1224 
    1225         uint64_t busy = 0, free = 0;
     1230       
     1231        *total = 0;
     1232        *unavail = 0;
     1233        *busy = 0;
     1234        *free = 0;
     1235       
    12261236        size_t i;
    12271237        for (i = 0; i < zones.count; i++) {
    1228                 bool available = zone_flags_available(zones.info[i].flags);
    1229                 /* Do not count reserved memory */
    1230                 if (available) {
    1231                         busy += (uint64_t) FRAMES2SIZE(zones.info[i].busy_count);
    1232                         free += (uint64_t) FRAMES2SIZE(zones.info[i].free_count);
    1233                 }
    1234         }
    1235 
     1238                *total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
     1239               
     1240                if (zone_flags_available(zones.info[i].flags)) {
     1241                        *busy += (uint64_t) FRAMES2SIZE(zones.info[i].busy_count);
     1242                        *free += (uint64_t) FRAMES2SIZE(zones.info[i].free_count);
     1243                } else
     1244                        *unavail += (uint64_t) FRAMES2SIZE(zones.info[i].count);
     1245        }
     1246       
    12361247        spinlock_unlock(&zones.lock);
    12371248        interrupts_restore(ipl);
    1238         *out_busy = busy;
    1239         *out_free = free;
    12401249}
    12411250
    12421251/** Prints list of zones. */
    1243 void zone_print_list(void)
     1252void zones_print_list(void)
    12441253{
    12451254#ifdef __32_BITS__

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

    rd8e3467 r9dae191e  
    5454#include <console/console.h>
    5555#include <udebug/udebug.h>
    56 #include <ps/ps.h>
    57 #include <ps/load.h>
    58 #include <ps/uptime.h>
    5956
    6057/** Dispatch system call */
    … …  
    147144        (syshandler_t) sys_ipc_register_irq,
    148145        (syshandler_t) sys_ipc_unregister_irq,
    149 
     146       
    150147        /* Event notification syscalls. */
    151148        (syshandler_t) sys_event_subscribe,
    … …  
    170167        (syshandler_t) sys_debug_enable_console,
    171168        (syshandler_t) sys_debug_disable_console,
    172 
    173         /* Ps calls */
    174         (syshandler_t) sys_ps_get_cpu_info,
    175         (syshandler_t) sys_ps_get_mem_info,
    176         (syshandler_t) sys_ps_get_tasks,
    177         (syshandler_t) sys_ps_get_task_info,
    178         (syshandler_t) sys_ps_get_threads,
    179         (syshandler_t) sys_ps_get_uptime,
    180         (syshandler_t) sys_ps_get_load,
    181169       
    182170        (syshandler_t) sys_ipc_connect_kbox

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

    rd8e3467 r9dae191e  
    3737#include <print.h>
    3838#include <syscall/copy.h>
     39#include <synch/spinlock.h>
    3940#include <errno.h>
    4041
    … …  
    4546static sysinfo_item_t *global_root = NULL;
    4647static slab_cache_t *sysinfo_item_slab;
     48
     49SPINLOCK_STATIC_INITIALIZE_NAME(sysinfo_lock, "sysinfo_lock");
    4750
    4851static int sysinfo_item_constructor(void *obj, int kmflag)
    … …  
    7679}
    7780
     81/** Recursively find item in sysinfo tree
     82 *
     83 * Should be called with interrupts disabled
     84 * and sysinfo_lock held.
     85 *
     86 */
    7887static sysinfo_item_t *sysinfo_find_item(const char *name,
    79     sysinfo_item_t *subtree)
    80 {
     88    sysinfo_item_t *subtree, sysinfo_return_t **ret)
     89{
     90        ASSERT(subtree != NULL);
     91        ASSERT(ret != NULL);
     92       
    8193        sysinfo_item_t *cur = subtree;
    8294       
    … …  
    98110                        case SYSINFO_SUBTREE_TABLE:
    99111                                /* Recursively find in subtree */
    100                                 return sysinfo_find_item(name + i + 1, cur->subtree.table);
     112                                return sysinfo_find_item(name + i + 1,
     113                                    cur->subtree.table, ret);
    101114                        case SYSINFO_SUBTREE_FUNCTION:
    102                                 /* Get generated item */
    103                                 return cur->subtree.find_item(name + i + 1);
     115                                /* Get generated data */
     116                                **ret = cur->subtree.get_data(name + i + 1);
     117                                return NULL;
    104118                        default:
    105119                                /* Not found */
     120                                *ret = NULL;
    106121                                return NULL;
    107122                        }
    … …  
    111126        }
    112127       
     128        *ret = NULL;
    113129        return NULL;
    114130}
    115131
     132/** Recursively create items in sysinfo tree
     133 *
     134 * Should be called with interrupts disabled
     135 * and sysinfo_lock held.
     136 *
     137 */
    116138static sysinfo_item_t *sysinfo_create_path(const char *name,
    117139    sysinfo_item_t **psubtree)
    … …  
    224246    unative_t val)
    225247{
     248        ipl_t ipl = interrupts_disable();
     249        spinlock_lock(&sysinfo_lock);
     250       
    226251        if (root == NULL)
    227252                root = &global_root;
    … …  
    232257                item->val.val = val;
    233258        }
     259       
     260        spinlock_unlock(&sysinfo_lock);
     261        interrupts_restore(ipl);
    234262}
    235263
    … …  
    237265    void *data, size_t size)
    238266{
     267        ipl_t ipl = interrupts_disable();
     268        spinlock_lock(&sysinfo_lock);
     269       
    239270        if (root == NULL)
    240271                root = &global_root;
    … …  
    246277                item->val.data.size = size;
    247278        }
    248 }
    249 
    250 void sysinfo_set_item_val_fn(const char *name, sysinfo_item_t **root,
     279       
     280        spinlock_unlock(&sysinfo_lock);
     281        interrupts_restore(ipl);
     282}
     283
     284void sysinfo_set_item_fn_val(const char *name, sysinfo_item_t **root,
    251285    sysinfo_fn_val_t fn)
    252286{
     287        ipl_t ipl = interrupts_disable();
     288        spinlock_lock(&sysinfo_lock);
     289       
    253290        if (root == NULL)
    254291                root = &global_root;
    … …  
    259296                item->val.fn_val = fn;
    260297        }
    261 }
    262 
    263 void sysinfo_set_item_data_fn(const char *name, sysinfo_item_t **root,
     298       
     299        spinlock_unlock(&sysinfo_lock);
     300        interrupts_restore(ipl);
     301}
     302
     303void sysinfo_set_item_fn_data(const char *name, sysinfo_item_t **root,
    264304    sysinfo_fn_data_t fn)
    265305{
     306        ipl_t ipl = interrupts_disable();
     307        spinlock_lock(&sysinfo_lock);
     308       
    266309        if (root == NULL)
    267310                root = &global_root;
    … …  
    272315                item->val.fn_data = fn;
    273316        }
     317       
     318        spinlock_unlock(&sysinfo_lock);
     319        interrupts_restore(ipl);
    274320}
    275321
    276322void sysinfo_set_item_undefined(const char *name, sysinfo_item_t **root)
    277323{
     324        ipl_t ipl = interrupts_disable();
     325        spinlock_lock(&sysinfo_lock);
     326       
    278327        if (root == NULL)
    279328                root = &global_root;
    … …  
    282331        if (item != NULL)
    283332                item->val_type = SYSINFO_VAL_UNDEFINED;
    284 }
    285 
     333       
     334        spinlock_unlock(&sysinfo_lock);
     335        interrupts_restore(ipl);
     336}
     337
     338void sysinfo_set_subtree_fn(const char *name, sysinfo_item_t **root,
     339    sysinfo_fn_subtree_t fn)
     340{
     341        ipl_t ipl = interrupts_disable();
     342        spinlock_lock(&sysinfo_lock);
     343       
     344        if (root == NULL)
     345                root = &global_root;
     346       
     347        sysinfo_item_t *item = sysinfo_create_path(name, root);
     348        if ((item != NULL) && (item->subtree_type != SYSINFO_SUBTREE_TABLE)) {
     349                item->subtree_type = SYSINFO_SUBTREE_FUNCTION;
     350                item->subtree.get_data = fn;
     351        }
     352       
     353        spinlock_unlock(&sysinfo_lock);
     354        interrupts_restore(ipl);
     355}
     356
     357/** Sysinfo dump indentation helper routine
     358 *
     359 */
    286360static void sysinfo_indent(unsigned int depth)
    287361{
    … …  
    291365}
    292366
    293 void sysinfo_dump(sysinfo_item_t **proot, unsigned int depth)
    294 {
    295         if (proot == NULL)
    296                 proot = &global_root;
    297        
    298         sysinfo_item_t *cur = *proot;
     367/** Dump the structure of sysinfo tree
     368 *
     369 * Should be called with interrupts disabled
     370 * and sysinfo_lock held. Because this routine
     371 * might take a reasonable long time to proceed,
     372 * having the spinlock held is not optimal, but
     373 * there is no better simple solution.
     374 *
     375 */
     376static void sysinfo_dump_internal(sysinfo_item_t *root, unsigned int depth)
     377{
     378        sysinfo_item_t *cur = root;
    299379       
    300380        while (cur != NULL) {
    … …  
    302382               
    303383                unative_t val;
     384                void *data;
    304385                size_t size;
    305386               
    … …  
    322403                        break;
    323404                case SYSINFO_VAL_FUNCTION_DATA:
    324                         cur->val.fn_data(cur, &size);
     405                        data = cur->val.fn_data(cur, &size);
     406                        if (data != NULL)
     407                                free(data);
     408                       
    325409                        printf("+ %s (%" PRIs" bytes) [generated]\n", cur->name,
    326410                            size);
    … …  
    334418                        break;
    335419                case SYSINFO_SUBTREE_TABLE:
    336                         sysinfo_dump(&(cur->subtree.table), depth + 1);
     420                        sysinfo_dump_internal(cur->subtree.table, depth + 1);
    337421                        break;
    338422                case SYSINFO_SUBTREE_FUNCTION:
    339423                        sysinfo_indent(depth + 1);
    340                         printf("  [generated subtree]\n");
     424                        printf("+ [generated subtree]\n");
    341425                        break;
    342426                default:
    343427                        sysinfo_indent(depth + 1);
    344                         printf("  [unknown subtree]\n");
     428                        printf("+ [unknown subtree]\n");
    345429                }
    346430               
    … …  
    349433}
    350434
    351 sysinfo_return_t sysinfo_get_item(const char *name, sysinfo_item_t **root)
     435void sysinfo_dump(sysinfo_item_t *root)
     436{
     437        ipl_t ipl = interrupts_disable();
     438        spinlock_lock(&sysinfo_lock);
     439       
     440        if (root == NULL)
     441                sysinfo_dump_internal(global_root, 0);
     442        else
     443                sysinfo_dump_internal(root, 0);
     444       
     445        spinlock_unlock(&sysinfo_lock);
     446        interrupts_restore(ipl);
     447}
     448
     449/** Return sysinfo item determined by name
     450 *
     451 * Should be called with interrupts disabled
     452 * and sysinfo_lock held.
     453 *
     454 */
     455static sysinfo_return_t sysinfo_get_item(const char *name, sysinfo_item_t **root)
    352456{
    353457        if (root == NULL)
    354458                root = &global_root;
    355459       
    356         sysinfo_item_t *item = sysinfo_find_item(name, *root);
    357460        sysinfo_return_t ret;
     461        sysinfo_return_t *ret_ptr = &ret;
     462        sysinfo_item_t *item = sysinfo_find_item(name, *root, &ret_ptr);
    358463       
    359464        if (item != NULL) {
     465                ret.tag = item->val_type;
    360466                switch (item->val_type) {
    361467                case SYSINFO_VAL_UNDEFINED:
     468                        break;
     469                case SYSINFO_VAL_VAL:
     470                        ret.val = item->val.val;
     471                        break;
     472                case SYSINFO_VAL_DATA:
     473                        ret.data = item->val.data;
     474                        break;
     475                case SYSINFO_VAL_FUNCTION_VAL:
     476                        ret.val = item->val.fn_val(item);
     477                        break;
     478                case SYSINFO_VAL_FUNCTION_DATA:
     479                        ret.data.data = item->val.fn_data(item, &ret.data.size);
     480                        break;
     481                }
     482        } else {
     483                if (ret_ptr == NULL)
    362484                        ret.tag = SYSINFO_VAL_UNDEFINED;
    363                         break;
    364                 case SYSINFO_VAL_VAL:
    365                         ret.tag = SYSINFO_VAL_VAL;
    366                         ret.val = item->val.val;
    367                         break;
    368                 case SYSINFO_VAL_DATA:
    369                         ret.tag = SYSINFO_VAL_DATA;
    370                         ret.data = item->val.data;
    371                         break;
    372                 case SYSINFO_VAL_FUNCTION_VAL:
    373                         ret.tag = SYSINFO_VAL_VAL;
    374                         ret.val = item->val.fn_val(item);
    375                         break;
    376                 case SYSINFO_VAL_FUNCTION_DATA:
    377                         ret.tag = SYSINFO_VAL_DATA;
    378                         ret.data.data = item->val.fn_data(item, &ret.data.size);
    379                         break;
    380                 }
    381         } else
    382                 ret.tag = SYSINFO_VAL_UNDEFINED;
     485        }
    383486       
    384487        return ret;
    385488}
    386489
     490/** Return sysinfo item determined by name from user space
     491 *
     492 * Should be called with interrupts disabled
     493 * and sysinfo_lock held.
     494 *
     495 */
    387496static sysinfo_return_t sysinfo_get_item_uspace(void *ptr, size_t size)
    388497{
    … …  
    397506       
    398507        if ((copy_from_uspace(path, ptr, size + 1) == 0)
    399             && (path[size] == 0)) {
     508            && (path[size] == 0))
    400509                ret = sysinfo_get_item(path, NULL);
    401                 free(path);
    402         }
    403        
     510       
     511        free(path);
    404512        return ret;
    405513}
    … …  
    407515unative_t sys_sysinfo_get_tag(void *path_ptr, size_t path_size)
    408516{
    409         return (unative_t) sysinfo_get_item_uspace(path_ptr, path_size).tag;
     517        ipl_t ipl = interrupts_disable();
     518        spinlock_lock(&sysinfo_lock);
     519       
     520        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size);
     521       
     522        if ((ret.tag == SYSINFO_VAL_FUNCTION_DATA) && (ret.data.data != NULL))
     523                free(ret.data.data);
     524       
     525        if (ret.tag == SYSINFO_VAL_FUNCTION_VAL)
     526                ret.tag = SYSINFO_VAL_VAL;
     527        else if (ret.tag == SYSINFO_VAL_FUNCTION_DATA)
     528                ret.tag = SYSINFO_VAL_DATA;
     529       
     530        spinlock_unlock(&sysinfo_lock);
     531        interrupts_restore(ipl);
     532       
     533        return (unative_t) ret.tag;
    410534}
    411535
    … …  
    413537    void *value_ptr)
    414538{
     539        ipl_t ipl = interrupts_disable();
     540        spinlock_lock(&sysinfo_lock);
     541       
    415542        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size);
    416        
    417         if (ret.tag != SYSINFO_VAL_VAL)
    418                 return (unative_t) EINVAL;
    419        
    420         return (unative_t) copy_to_uspace(value_ptr, &ret.val,
    421             sizeof(ret.val));
     543        int rc;
     544       
     545        if ((ret.tag == SYSINFO_VAL_VAL) || (ret.tag == SYSINFO_VAL_FUNCTION_VAL))
     546                rc = copy_to_uspace(value_ptr, &ret.val, sizeof(ret.val));
     547        else
     548                rc = EINVAL;
     549       
     550        if ((ret.tag == SYSINFO_VAL_FUNCTION_DATA) && (ret.data.data != NULL))
     551                free(ret.data.data);
     552       
     553        spinlock_unlock(&sysinfo_lock);
     554        interrupts_restore(ipl);
     555       
     556        return (unative_t) rc;
    422557}
    423558
    … …  
    425560    void *size_ptr)
    426561{
     562        ipl_t ipl = interrupts_disable();
     563        spinlock_lock(&sysinfo_lock);
     564       
    427565        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size);
    428        
    429         if (ret.tag != SYSINFO_VAL_DATA)
    430                 return (unative_t) EINVAL;
    431        
    432         return (unative_t) copy_to_uspace(size_ptr, &ret.data.size,
    433             sizeof(ret.data.size));
     566        int rc;
     567       
     568        if ((ret.tag == SYSINFO_VAL_DATA) || (ret.tag == SYSINFO_VAL_FUNCTION_DATA))
     569                rc = copy_to_uspace(size_ptr, &ret.data.size,
     570                    sizeof(ret.data.size));
     571        else
     572                rc = EINVAL;
     573       
     574        if ((ret.tag == SYSINFO_VAL_FUNCTION_DATA) && (ret.data.data != NULL))
     575                free(ret.data.data);
     576       
     577        spinlock_unlock(&sysinfo_lock);
     578        interrupts_restore(ipl);
     579       
     580        return (unative_t) rc;
    434581}
    435582
    … …  
    437584    void *buffer_ptr, size_t buffer_size)
    438585{
     586        ipl_t ipl = interrupts_disable();
     587        spinlock_lock(&sysinfo_lock);
     588       
    439589        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size);
    440        
    441         if (ret.tag != SYSINFO_VAL_DATA)
    442                 return (unative_t) EINVAL;
    443        
    444         if (ret.data.size != buffer_size)
    445                 return ENOMEM;
    446        
    447         return (unative_t) copy_to_uspace(buffer_ptr, ret.data.data,
    448             ret.data.size);
     590        int rc;
     591       
     592        if ((ret.tag == SYSINFO_VAL_DATA) || (ret.tag == SYSINFO_VAL_FUNCTION_DATA)) {
     593                if (ret.data.size == buffer_size)
     594                        rc = copy_to_uspace(buffer_ptr, ret.data.data,
     595                            ret.data.size);
     596                else
     597                        rc = ENOMEM;
     598        } else
     599                rc = EINVAL;
     600       
     601        if ((ret.tag == SYSINFO_VAL_FUNCTION_DATA) && (ret.data.data != NULL))
     602                free(ret.data.data);
     603       
     604        spinlock_unlock(&sysinfo_lock);
     605        interrupts_restore(ipl);
     606       
     607        return (unative_t) rc;
    449608}
    450609

  • kernel/generic/src/time/clock.c

    rd8e3467 r9dae191e  
    8686        uptime->seconds1 = 0;
    8787        uptime->seconds2 = 0;
    88         uptime->useconds = 0; 
     88        uptime->useconds = 0;
    8989
    9090        clock_parea.pbase = (uintptr_t) faddr;
Note: See TracChangeset for help on using the changeset viewer.