| 0,0 → 1,310 |
|---|
| /* |
| * 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; |
| } |
| |
| /** @} |
| */ |