Subversion Repositories HelenOS

Rev

Rev 3790 | Details | Compare with Previous | Last modification | View Log | RSS feed

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