WebSVN – HelenOS-historic – Diff – /kernel/trunk/generic/src/sysinfo/sysinfo.c


/*
 * 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, __native 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;
        __native 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;
}
 
__native sys_sysinfo_valid(__native ptr, __native 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;
}
 
__native sys_sysinfo_value(__native ptr, __native 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;
}
 
/** @}
 */
 
 

Rev 1735	Rev 1757
1	/*	1	/*
2	* Copyright (C) 2006 Jakub Vana	2	* Copyright (C) 2006 Jakub Vana
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup generic	29	/** @addtogroup generic
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include <sysinfo/sysinfo.h>	35	#include <sysinfo/sysinfo.h>
36	#include <mm/slab.h>	36	#include <mm/slab.h>
37	#include <print.h>	37	#include <print.h>
38	#include <syscall/copy.h>	38	#include <syscall/copy.h>
39		39
40	sysinfo_item_t *_root = NULL;	40	sysinfo_item_t *_root = NULL;
41		41
42		42
43	static sysinfo_item_t sysinfo_find_item(const char name, sysinfo_item_t *subtree)	43	static sysinfo_item_t sysinfo_find_item(const char name, sysinfo_item_t *subtree)
44	{	44	{
45	if (subtree == NULL)	45	if (subtree == NULL)
46	return NULL;	46	return NULL;
47		47
48	while (subtree != NULL) {	48	while (subtree != NULL) {
49	int i = 0;	49	int i = 0;
50	char a = (char ) name;	50	char a = (char ) name;
51	char *b = subtree->name;	51	char *b = subtree->name;
52		52
53	while ((a[i] == b[i]) && (b[i]))	53	while ((a[i] == b[i]) && (b[i]))
54	i++;	54	i++;
55		55
56	if ((!a[i]) && (!b[i])) /* Last name in path matches */	56	if ((!a[i]) && (!b[i])) /* Last name in path matches */
57	return subtree;	57	return subtree;
58		58
59	if ((a[i] == '.') && (!b[i])) { /* Middle name in path matches */	59	if ((a[i] == '.') && (!b[i])) { /* Middle name in path matches */
60	if (subtree->subinfo_type == SYSINFO_SUBINFO_TABLE)	60	if (subtree->subinfo_type == SYSINFO_SUBINFO_TABLE)
61	return sysinfo_find_item(a + i + 1, subtree->subinfo.table);	61	return sysinfo_find_item(a + i + 1, subtree->subinfo.table);
62		62
63	//if (subtree->subinfo_type == SYSINFO_SUBINFO_FUNCTION) /* Subinfo managed by subsystem */	63	//if (subtree->subinfo_type == SYSINFO_SUBINFO_FUNCTION) /* Subinfo managed by subsystem */
64	// return NULL;	64	// return NULL;
65		65
66	return NULL; /* No subinfo */	66	return NULL; /* No subinfo */
67	}	67	}
68	/* No matches try next */	68	/* No matches try next */
69	subtree = subtree->next;	69	subtree = subtree->next;
70	i = 0;	70	i = 0;
71	}	71	}
72	return NULL;	72	return NULL;
73	}	73	}
74		74
75	static sysinfo_item_t sysinfo_create_path(const char name, sysinfo_item_t **psubtree)	75	static sysinfo_item_t sysinfo_create_path(const char name, sysinfo_item_t **psubtree)
76	{	76	{
77	sysinfo_item_t *subtree;	77	sysinfo_item_t *subtree;
78	subtree = *psubtree;	78	subtree = *psubtree;
79		79
80	if (subtree == NULL) {	80	if (subtree == NULL) {
81	sysinfo_item_t *item = malloc(sizeof(sysinfo_item_t), 0);	81	sysinfo_item_t *item = malloc(sizeof(sysinfo_item_t), 0);
82	int i = 0, j;	82	int i = 0, j;
83		83
84	ASSERT(item);	84	ASSERT(item);
85	*psubtree = item;	85	*psubtree = item;
86	item->next = NULL;	86	item->next = NULL;
87	item->val_type = SYSINFO_VAL_UNDEFINED;	87	item->val_type = SYSINFO_VAL_UNDEFINED;
88	item->subinfo.table = NULL;	88	item->subinfo.table = NULL;
89		89
90	while (name[i] && (name[i] != '.'))	90	while (name[i] && (name[i] != '.'))
91	i++;	91	i++;
92		92
93	item->name = malloc(i, 0);	93	item->name = malloc(i, 0);
94	ASSERT(item->name);	94	ASSERT(item->name);
95		95
96	for (j = 0; j < i; j++)	96	for (j = 0; j < i; j++)
97	item->name[j] = name[j];	97	item->name[j] = name[j];
98	item->name[j] = 0;	98	item->name[j] = 0;
99		99
100	if (name[i]) { /* =='.' */	100	if (name[i]) { /* =='.' */
101	item->subinfo_type = SYSINFO_SUBINFO_TABLE;	101	item->subinfo_type = SYSINFO_SUBINFO_TABLE;
102	return sysinfo_create_path(name + i + 1, &(item->subinfo.table));	102	return sysinfo_create_path(name + i + 1, &(item->subinfo.table));
103	}	103	}
104	item->subinfo_type = SYSINFO_SUBINFO_NONE;	104	item->subinfo_type = SYSINFO_SUBINFO_NONE;
105	return item;	105	return item;
106	}	106	}
107		107
108	while (subtree != NULL) {	108	while (subtree != NULL) {
109	int i = 0, j;	109	int i = 0, j;
110	char a = (char ) name;	110	char a = (char ) name;
111	char *b = subtree->name;	111	char *b = subtree->name;
112		112
113	while ((a[i] == b[i]) && (b[i]))	113	while ((a[i] == b[i]) && (b[i]))
114	i++;	114	i++;
115		115
116	if ((!a[i]) && (!b[i])) /* Last name in path matches */	116	if ((!a[i]) && (!b[i])) /* Last name in path matches */
117	return subtree;	117	return subtree;
118		118
119	if ((a[i] == '.') && (!b[i])) { /* Middle name in path matches */	119	if ((a[i] == '.') && (!b[i])) { /* Middle name in path matches */
120	if (subtree->subinfo_type == SYSINFO_SUBINFO_TABLE)	120	if (subtree->subinfo_type == SYSINFO_SUBINFO_TABLE)
121	return sysinfo_create_path(a + i + 1, &(subtree->subinfo.table));	121	return sysinfo_create_path(a + i + 1, &(subtree->subinfo.table));
122		122
123	if (subtree->subinfo_type == SYSINFO_SUBINFO_NONE) {	123	if (subtree->subinfo_type == SYSINFO_SUBINFO_NONE) {
124	subtree->subinfo_type = SYSINFO_SUBINFO_TABLE;	124	subtree->subinfo_type = SYSINFO_SUBINFO_TABLE;
125	return sysinfo_create_path(a + i + 1,&(subtree->subinfo.table));	125	return sysinfo_create_path(a + i + 1,&(subtree->subinfo.table));
126	}	126	}
127		127
128	//if (subtree->subinfo_type == SYSINFO_SUBINFO_FUNCTION) /* Subinfo managed by subsystem */	128	//if (subtree->subinfo_type == SYSINFO_SUBINFO_FUNCTION) /* Subinfo managed by subsystem */
129	// return NULL;	129	// return NULL;
130		130
131	return NULL;	131	return NULL;
132	}	132	}
133	/* No matches try next or create new*/	133	/* No matches try next or create new*/
134	if (subtree->next == NULL) {	134	if (subtree->next == NULL) {
135	sysinfo_item_t *item = malloc(sizeof(sysinfo_item_t), 0);	135	sysinfo_item_t *item = malloc(sizeof(sysinfo_item_t), 0);
136		136
137	ASSERT(item);	137	ASSERT(item);
138	subtree->next = item;	138	subtree->next = item;
139	item->next = NULL;	139	item->next = NULL;
140	item->val_type = SYSINFO_VAL_UNDEFINED;	140	item->val_type = SYSINFO_VAL_UNDEFINED;
141	item->subinfo.table = NULL;	141	item->subinfo.table = NULL;
142		142
143	i = 0;	143	i = 0;
144	while (name[i] && (name[i] != '.'))	144	while (name[i] && (name[i] != '.'))
145	i++;	145	i++;
146		146
147	item->name = malloc(i, 0);	147	item->name = malloc(i, 0);
148	ASSERT(item->name);	148	ASSERT(item->name);
149		149
150	for (j = 0; j < i; j++)	150	for (j = 0; j < i; j++)
151	item->name[j] = name[j];	151	item->name[j] = name[j];
152		152
153	item->name[j] = 0;	153	item->name[j] = 0;
154		154
155	if(name[i]) { /* =='.' */	155	if(name[i]) { /* =='.' */
156	item->subinfo_type = SYSINFO_SUBINFO_TABLE;	156	item->subinfo_type = SYSINFO_SUBINFO_TABLE;
157	return sysinfo_create_path(name + i + 1, &(item->subinfo.table));	157	return sysinfo_create_path(name + i + 1, &(item->subinfo.table));
158	}	158	}
159	item->subinfo_type = SYSINFO_SUBINFO_NONE;	159	item->subinfo_type = SYSINFO_SUBINFO_NONE;
160	return item;	160	return item;
161	} else {	161	} else {
162	subtree = subtree->next;	162	subtree = subtree->next;
163	i = 0;	163	i = 0;
164	}	164	}
165	}	165	}
166	panic("Not reached\n");	166	panic("Not reached\n");
167	return NULL;	167	return NULL;
168	}	168	}
169		169
170	void sysinfo_set_item_val(const char name, sysinfo_item_t *root, __native val)	170	void sysinfo_set_item_val(const char name, sysinfo_item_t *root, __native val)
171	{	171	{
172	if (root == NULL)	172	if (root == NULL)
173	root = &_root;	173	root = &_root;
174		174
175	/* If already created create only returns pointer	175	/* If already created create only returns pointer
176	If not, create it */	176	If not, create it */
177	sysinfo_item_t *item = sysinfo_create_path(name, root);	177	sysinfo_item_t *item = sysinfo_create_path(name, root);
178		178
179	if (item != NULL) { /* If in subsystem, unable to create or return so unable to set */	179	if (item != NULL) { /* If in subsystem, unable to create or return so unable to set */
180	item->val.val=val;	180	item->val.val=val;
181	item->val_type = SYSINFO_VAL_VAL;	181	item->val_type = SYSINFO_VAL_VAL;
182	}	182	}
183	}	183	}
184		184
185	void sysinfo_set_item_function(const char name, sysinfo_item_t *root, sysinfo_val_fn_t fn)	185	void sysinfo_set_item_function(const char name, sysinfo_item_t *root, sysinfo_val_fn_t fn)
186	{	186	{
187	if (root == NULL)	187	if (root == NULL)
188	root = &_root;	188	root = &_root;
189		189
190	/* If already created create only returns pointer	190	/* If already created create only returns pointer
191	If not, create it */	191	If not, create it */
192	sysinfo_item_t *item = sysinfo_create_path(name, root);	192	sysinfo_item_t *item = sysinfo_create_path(name, root);
193		193
194	if (item != NULL) { /* If in subsystem, unable to create or return so unable to set */	194	if (item != NULL) { /* If in subsystem, unable to create or return so unable to set */
195	item->val.fn=fn;	195	item->val.fn=fn;
196	item->val_type = SYSINFO_VAL_FUNCTION;	196	item->val_type = SYSINFO_VAL_FUNCTION;
197	}	197	}
198	}	198	}
199		199
200		200
201	void sysinfo_set_item_undefined(const char name, sysinfo_item_t *root)	201	void sysinfo_set_item_undefined(const char name, sysinfo_item_t *root)
202	{	202	{
203	if (root == NULL)	203	if (root == NULL)
204	root = &_root;	204	root = &_root;
205		205
206	/* If already created create only returns pointer	206	/* If already created create only returns pointer
207	If not, create it */	207	If not, create it */
208	sysinfo_item_t *item = sysinfo_create_path(name, root);	208	sysinfo_item_t *item = sysinfo_create_path(name, root);
209		209
210	if (item != NULL)	210	if (item != NULL)
211	item->val_type = SYSINFO_VAL_UNDEFINED;	211	item->val_type = SYSINFO_VAL_UNDEFINED;
212	}	212	}
213		213
214		214
215	void sysinfo_dump(sysinfo_item_t **proot, int depth)	215	void sysinfo_dump(sysinfo_item_t **proot, int depth)
216	{	216	{
217	sysinfo_item_t *root;	217	sysinfo_item_t *root;
218	if (proot == NULL)	218	if (proot == NULL)
219	proot = &_root;	219	proot = &_root;
220		220
221	root = *proot;	221	root = *proot;
222		222
223	while (root != NULL) {	223	while (root != NULL) {
224	int i;	224	int i;
225	__native val = 0;	225	__native val = 0;
226	char *vtype = NULL;	226	char *vtype = NULL;
227		227
228		228
229	for (i = 0; i < depth; i++)	229	for (i = 0; i < depth; i++)
230	printf(" ");	230	printf(" ");
231		231
232	switch (root->val_type) {	232	switch (root->val_type) {
233	case SYSINFO_VAL_UNDEFINED:	233	case SYSINFO_VAL_UNDEFINED:
234	val = 0;	234	val = 0;
235	vtype = "UND";	235	vtype = "UND";
236	break;	236	break;
237	case SYSINFO_VAL_VAL:	237	case SYSINFO_VAL_VAL:
238	val = root->val.val;	238	val = root->val.val;
239	vtype = "VAL";	239	vtype = "VAL";
240	break;	240	break;
241	case SYSINFO_VAL_FUNCTION:	241	case SYSINFO_VAL_FUNCTION:
242	val = ((sysinfo_val_fn_t) (root->val.fn)) (root);	242	val = ((sysinfo_val_fn_t) (root->val.fn)) (root);
243	vtype = "FUN";	243	vtype = "FUN";
244	break;	244	break;
245	}	245	}
246		246
247	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"));	247	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"));
248		248
249	if (root->subinfo_type == SYSINFO_SUBINFO_TABLE)	249	if (root->subinfo_type == SYSINFO_SUBINFO_TABLE)
250	sysinfo_dump(&(root -> subinfo.table), depth + 1);	250	sysinfo_dump(&(root -> subinfo.table), depth + 1);
251		251
252	root = root->next;	252	root = root->next;
253	}	253	}
254	}	254	}
255		255
256	sysinfo_rettype_t sysinfo_get_val(const char name, sysinfo_item_t *root)	256	sysinfo_rettype_t sysinfo_get_val(const char name, sysinfo_item_t *root)
257	{	257	{
258	// TODO: Implement Subsystem subinfo (by function implemented subinfo)	258	// TODO: Implement Subsystem subinfo (by function implemented subinfo)
259		259
260	sysinfo_rettype_t ret = {0, false};	260	sysinfo_rettype_t ret = {0, false};
261		261
262	if (root == NULL)	262	if (root == NULL)
263	root = &_root;	263	root = &_root;
264		264
265	sysinfo_item_t item = sysinfo_find_item(name, root);	265	sysinfo_item_t item = sysinfo_find_item(name, root);
266		266
267	if (item != NULL) {	267	if (item != NULL) {
268	if (item->val_type == SYSINFO_VAL_UNDEFINED)	268	if (item->val_type == SYSINFO_VAL_UNDEFINED)
269	return ret;	269	return ret;
270	else	270	else
271	ret.valid = true;	271	ret.valid = true;
272		272
273	if (item->val_type == SYSINFO_VAL_VAL)	273	if (item->val_type == SYSINFO_VAL_VAL)
274	ret.val = item->val.val;	274	ret.val = item->val.val;
275	else	275	else
276	ret.val = ((sysinfo_val_fn_t) (item->val.fn)) (item);	276	ret.val = ((sysinfo_val_fn_t) (item->val.fn)) (item);
277	}	277	}
278	return ret;	278	return ret;
279	}	279	}
280		280
281	__native sys_sysinfo_valid(__native ptr, __native len)	281	__native sys_sysinfo_valid(__native ptr, __native len)
282	{	282	{
283	char *str;	283	char *str;
284	sysinfo_rettype_t ret = {0, 0};	284	sysinfo_rettype_t ret = {0, 0};
285	str = malloc(len + 1, 0);	285	str = malloc(len + 1, 0);
286		286
287	ASSERT(str);	287	ASSERT(str);
288	if (!((copy_from_uspace(str, (void *) ptr, len + 1)) \|\| (str[len])))	288	if (!((copy_from_uspace(str, (void *) ptr, len + 1)) \|\| (str[len])))
289	ret = sysinfo_get_val(str, NULL);	289	ret = sysinfo_get_val(str, NULL);
290		290
291	free(str);	291	free(str);
292	return ret.valid;	292	return ret.valid;
293	}	293	}
294		294
295	__native sys_sysinfo_value(__native ptr, __native len)	295	__native sys_sysinfo_value(__native ptr, __native len)
296	{	296	{
297	char *str;	297	char *str;
298	sysinfo_rettype_t ret = {0, 0};	298	sysinfo_rettype_t ret = {0, 0};
299	str = malloc(len + 1, 0);	299	str = malloc(len + 1, 0);
300		300
301	ASSERT(str);	301	ASSERT(str);
302	if (!((copy_from_uspace(str, (void *) ptr, len + 1)) \|\| (str[len])))	302	if (!((copy_from_uspace(str, (void *) ptr, len + 1)) \|\| (str[len])))
303	ret = sysinfo_get_val(str, NULL);	303	ret = sysinfo_get_val(str, NULL);
304		304
305	free(str);	305	free(str);
306	return ret.val;	306	return ret.val;
307	}	307	}
308		308
309	/** @}	309	/** @}
310	*/	310	*/
311		-
312		311

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/sysinfo/sysinfo.c – Rev 1735 → 1757