Subversion Repositories HelenOS

/*
 * Copyright (C) 2006 Jakub Vana
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup generic 
 * @{
 */
/** @file
 */

#include <sysinfo/sysinfo.h>
#include <mm/slab.h>
#include <print.h>
#include <syscall/copy.h>

sysinfo_item_t *_root = NULL;


static sysinfo_item_t *sysinfo_find_item(const char *name, sysinfo_item_t *subtree)
{
    if (subtree == NULL)
        return NULL;
    
    while (subtree != NULL) {
        int i = 0;
        char *a = (char *) name;
        char *b = subtree->name;
        
        while ((a[i] == b[i]) && (b[i]))
            i++;
        
        if ((!a[i]) && (!b[i]))  /* Last name in path matches */
            return subtree;
        
        if ((a[i] == '.') && (!b[i])) { /* Middle name in path matches */
            if (subtree->subinfo_type == SYSINFO_SUBINFO_TABLE)
                return sysinfo_find_item(a + i + 1, subtree->subinfo.table);
            
            //if (subtree->subinfo_type == SYSINFO_SUBINFO_FUNCTION) /* Subinfo managed by subsystem */
            //  return NULL; 
            
            return NULL; /* No subinfo */
        }
        /* No matches try next */
        subtree = subtree->next;
        i = 0;
    }
    return NULL;
}

static sysinfo_item_t *sysinfo_create_path(const char *name, sysinfo_item_t **psubtree)
{
    sysinfo_item_t *subtree;
    subtree = *psubtree;
    
    if (subtree == NULL) {
        sysinfo_item_t *item = malloc(sizeof(sysinfo_item_t), 0);
        int i = 0, j;
            
        ASSERT(item);
        *psubtree = item;
        item->next = NULL;
        item->val_type = SYSINFO_VAL_UNDEFINED;
        item->subinfo.table = NULL;

        while (name[i] && (name[i] != '.'))
            i++;
            
        item->name = malloc(i, 0);
        ASSERT(item->name);

        for (j = 0; j < i; j++)
            item->name[j] = name[j];
        item->name[j] = 0;
            
        if (name[i]) { /* =='.' */
            item->subinfo_type = SYSINFO_SUBINFO_TABLE;
            return sysinfo_create_path(name + i + 1, &(item->subinfo.table));
        }
        item->subinfo_type = SYSINFO_SUBINFO_NONE;
        return item;
    }

    while (subtree != NULL) {
        int i = 0, j;
        char *a = (char *) name;
        char *b = subtree->name;
        
        while ((a[i] == b[i]) && (b[i]))
            i++;
        
        if ((!a[i]) && (!b[i])) /* Last name in path matches */
            return subtree;
        
        if ((a[i] == '.') && (!b[i])) { /* Middle name in path matches */
            if (subtree->subinfo_type == SYSINFO_SUBINFO_TABLE)
                return sysinfo_create_path(a + i + 1, &(subtree->subinfo.table));
            
            if (subtree->subinfo_type == SYSINFO_SUBINFO_NONE) {
                subtree->subinfo_type = SYSINFO_SUBINFO_TABLE;
                return sysinfo_create_path(a + i + 1,&(subtree->subinfo.table));
            }
            
            //if (subtree->subinfo_type == SYSINFO_SUBINFO_FUNCTION) /* Subinfo managed by subsystem */
            //  return NULL; 
            
            return NULL;
        }
        /* No matches try next or create new*/
        if (subtree->next == NULL) {
            sysinfo_item_t *item = malloc(sizeof(sysinfo_item_t), 0);
            
            ASSERT(item);
            subtree->next = item;
            item->next = NULL;
            item->val_type = SYSINFO_VAL_UNDEFINED;
            item->subinfo.table = NULL;

            i = 0;
            while (name[i] && (name[i] != '.'))
                i++;

            item->name = malloc(i, 0);
            ASSERT(item->name);
            
            for (j = 0; j < i; j++)
                item->name[j] = name[j];
            
            item->name[j] = 0;

            if(name[i]) { /* =='.' */
                item->subinfo_type = SYSINFO_SUBINFO_TABLE;
                return sysinfo_create_path(name + i + 1, &(item->subinfo.table));
            }
            item->subinfo_type = SYSINFO_SUBINFO_NONE;
            return item;
        } else {
            subtree = subtree->next;
            i = 0;
        }   
    }
    panic("Not reached\n");
    return NULL;
}

void sysinfo_set_item_val(const char *name, sysinfo_item_t **root, unative_t val)
{
    if (root == NULL)
        root = &_root;
    
    /* If already created create only returns pointer 
       If not, create it */
    sysinfo_item_t *item = sysinfo_create_path(name, root);
    
    if (item != NULL) { /* If in subsystem, unable to create or return so unable to set */
        item->val.val=val;                   
        item->val_type = SYSINFO_VAL_VAL;
    }
}

void sysinfo_set_item_function(const char *name, sysinfo_item_t **root, sysinfo_val_fn_t fn)
{
    if (root == NULL)
        root = &_root;
    
    /* If already created create only returns pointer 
       If not, create it */
    sysinfo_item_t *item = sysinfo_create_path(name, root);
    
    if (item != NULL) { /* If in subsystem, unable to create or return so  unable to set */
        item->val.fn=fn;                   
        item->val_type = SYSINFO_VAL_FUNCTION;
    }
}


void sysinfo_set_item_undefined(const char *name, sysinfo_item_t **root)
{
    if (root == NULL)
        root = &_root;
    
    /* If already created create only returns pointer 
       If not, create it */
    sysinfo_item_t *item = sysinfo_create_path(name, root);
    
    if (item != NULL)
        item->val_type = SYSINFO_VAL_UNDEFINED;
}


void sysinfo_dump(sysinfo_item_t **proot, int depth)
{
    sysinfo_item_t *root;
    if (proot == NULL)
        proot = &_root;
    
    root = *proot;
    
    while (root != NULL) {
        int i;
        unative_t val = 0;
        char *vtype = NULL;
        
        
        for (i = 0; i < depth; i++)
            printf("  ");
        
        switch (root->val_type) {
            case SYSINFO_VAL_UNDEFINED:
                val = 0;
                vtype = "UND";
                break;
            case SYSINFO_VAL_VAL:
                val = root->val.val;
                vtype = "VAL";
                break;
            case SYSINFO_VAL_FUNCTION:
                val = ((sysinfo_val_fn_t) (root->val.fn)) (root);
                vtype = "FUN";
                break;
        }
        
        printf("%s    %s val:%d(%x) sub:%s\n", root->name, vtype, val, val, (root->subinfo_type == SYSINFO_SUBINFO_NONE) ? "NON" : ((root->subinfo_type == SYSINFO_SUBINFO_TABLE) ? "TAB" : "FUN"));
        
        if (root->subinfo_type == SYSINFO_SUBINFO_TABLE)
            sysinfo_dump(&(root -> subinfo.table), depth + 1);
        
        root = root->next;
    }
}

sysinfo_rettype_t sysinfo_get_val(const char *name, sysinfo_item_t **root)
{
    // TODO: Implement Subsystem subinfo (by function implemented subinfo)

    sysinfo_rettype_t ret = {0, false};

    if (root == NULL)
        root = &_root;
    
    sysinfo_item_t *item = sysinfo_find_item(name, *root);
    
    if (item != NULL) {
        if (item->val_type == SYSINFO_VAL_UNDEFINED) 
            return ret;
        else
            ret.valid = true;
        
        if (item->val_type == SYSINFO_VAL_VAL)
            ret.val = item->val.val;
        else
            ret.val = ((sysinfo_val_fn_t) (item->val.fn)) (item);
    }
    return ret;
}

unative_t sys_sysinfo_valid(unative_t ptr, unative_t len)
{
    char *str;
    sysinfo_rettype_t ret = {0, 0};
    str = malloc(len + 1, 0);
    
    ASSERT(str);
    if (!((copy_from_uspace(str, (void *) ptr, len + 1)) || (str[len])))
        ret = sysinfo_get_val(str, NULL);
    
    free(str);
    return ret.valid;
}

unative_t sys_sysinfo_value(unative_t ptr, unative_t len)
{
    char *str;
    sysinfo_rettype_t ret = {0, 0};
    str = malloc(len + 1, 0);
    
    ASSERT(str);
    if (!((copy_from_uspace(str, (void *) ptr, len + 1)) || (str[len]))) 
        ret = sysinfo_get_val(str, NULL);
    
    free(str);
    return ret.val;
}

/** @}
 */