Changeset 8565a42 in mainline for kernel/generic/src/sysinfo/sysinfo.c


Ignore:
Timestamp:
2018-03-02T20:34:50Z (7 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a1a81f69, d5e5fd1
Parents:
3061bc1 (diff), 34e1206 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)
git-committer:
GitHub <noreply@…> (2018-03-02 20:34:50)
Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r3061bc1 r8565a42  
    6464{
    6565        sysinfo_item_t *item = (sysinfo_item_t *) obj;
    66        
     66
    6767        item->name = NULL;
    6868        item->val_type = SYSINFO_VAL_UNDEFINED;
    … …  
    7070        item->subtree.table = NULL;
    7171        item->next = NULL;
    72        
     72
    7373        return EOK;
    7474}
    … …  
    8484{
    8585        sysinfo_item_t *item = (sysinfo_item_t *) obj;
    86        
     86
    8787        if (item->name != NULL)
    8888                free(item->name);
    89        
     89
    9090        return 0;
    9191}
    … …  
    101101            sizeof(sysinfo_item_t), 0, sysinfo_item_constructor,
    102102            sysinfo_item_destructor, SLAB_CACHE_MAGDEFERRED);
    103        
     103
    104104        mutex_initialize(&sysinfo_lock, MUTEX_ACTIVE);
    105105}
    … …  
    127127{
    128128        assert(subtree != NULL);
    129        
     129
    130130        sysinfo_item_t *cur = subtree;
    131        
     131
    132132        /* Walk all siblings */
    133133        while (cur != NULL) {
    134134                size_t i = 0;
    135                
     135
    136136                /* Compare name with path */
    137137                while ((cur->name[i] != 0) && (name[i] == cur->name[i]))
    138138                        i++;
    139                
     139
    140140                /* Check for perfect name and path match */
    141141                if ((name[i] == 0) && (cur->name[i] == 0))
    142142                        return cur;
    143                
     143
    144144                /* Partial match up to the delimiter */
    145145                if ((name[i] == '.') && (cur->name[i] == 0)) {
    … …  
    155155                                        **ret = cur->subtree.generator.fn(name + i + 1,
    156156                                            dry_run, cur->subtree.generator.data);
    157                                
     157
    158158                                return NULL;
    159159                        default:
    … …  
    161161                                if (ret != NULL)
    162162                                        *ret = NULL;
    163                                
     163
    164164                                return NULL;
    165165                        }
    166166                }
    167                
     167
    168168                cur = cur->next;
    169169        }
    170        
     170
    171171        /* Not found, no data generated */
    172172        if (ret != NULL)
    173173                *ret = NULL;
    174        
     174
    175175        return NULL;
    176176}
    … …  
    193193{
    194194        assert(psubtree != NULL);
    195        
     195
    196196        if (*psubtree == NULL) {
    197197                /* No parent */
    198                
     198
    199199                size_t i = 0;
    200                
     200
    201201                /* Find the first delimiter in name */
    202202                while ((name[i] != 0) && (name[i] != '.'))
    203203                        i++;
    204                
     204
    205205                *psubtree =
    206206                    (sysinfo_item_t *) slab_alloc(sysinfo_item_cache, 0);
    207207                assert(*psubtree);
    208                
     208
    209209                /* Fill in item name up to the delimiter */
    210210                (*psubtree)->name = str_ndup(name, i);
    211211                assert((*psubtree)->name);
    212                
     212
    213213                /* Create subtree items */
    214214                if (name[i] == '.') {
    … …  
    217217                            &((*psubtree)->subtree.table));
    218218                }
    219                
     219
    220220                /* No subtree needs to be created */
    221221                return *psubtree;
    222222        }
    223        
     223
    224224        sysinfo_item_t *cur = *psubtree;
    225        
     225
    226226        /* Walk all siblings */
    227227        while (cur != NULL) {
    228228                size_t i = 0;
    229                
     229
    230230                /* Compare name with path */
    231231                while ((cur->name[i] != 0) && (name[i] == cur->name[i]))
    232232                        i++;
    233                
     233
    234234                /* Check for perfect name and path match
    235235                 * -> item is already present.
    … …  
    237237                if ((name[i] == 0) && (cur->name[i] == 0))
    238238                        return cur;
    239                
     239
    240240                /* Partial match up to the delimiter */
    241241                if ((name[i] == '.') && (cur->name[i] == 0)) {
    … …  
    257257                        }
    258258                }
    259                
     259
    260260                /* No match and no more siblings to check
    261261                 * -> create a new sibling item.
    … …  
    266266                        while ((name[i] != 0) && (name[i] != '.'))
    267267                                i++;
    268                        
     268
    269269                        sysinfo_item_t *item =
    270270                            (sysinfo_item_t *) slab_alloc(sysinfo_item_cache, 0);
    271271                        assert(item);
    272                        
     272
    273273                        cur->next = item;
    274                        
     274
    275275                        /* Fill in item name up to the delimiter */
    276276                        item->name = str_ndup(name, i);
    277277                        assert(item->name);
    278                        
     278
    279279                        /* Create subtree items */
    280280                        if (name[i] == '.') {
    … …  
    283283                                    &(item->subtree.table));
    284284                        }
    285                        
     285
    286286                        /* No subtree needs to be created */
    287287                        return item;
    288288                }
    289                
     289
    290290                cur = cur->next;
    291291        }
    292        
     292
    293293        /* Unreachable */
    294294        assert(false);
    … …  
    309309        /* Protect sysinfo tree consistency */
    310310        mutex_lock(&sysinfo_lock);
    311        
     311
    312312        if (root == NULL)
    313313                root = &global_root;
    314        
     314
    315315        sysinfo_item_t *item = sysinfo_create_path(name, root);
    316316        if (item != NULL) {
    … …  
    318318                item->val.val = val;
    319319        }
    320        
     320
    321321        mutex_unlock(&sysinfo_lock);
    322322}
    … …  
    340340        /* Protect sysinfo tree consistency */
    341341        mutex_lock(&sysinfo_lock);
    342        
     342
    343343        if (root == NULL)
    344344                root = &global_root;
    345        
     345
    346346        sysinfo_item_t *item = sysinfo_create_path(name, root);
    347347        if (item != NULL) {
    … …  
    350350                item->val.data.size = size;
    351351        }
    352        
     352
    353353        mutex_unlock(&sysinfo_lock);
    354354}
    … …  
    368368        /* Protect sysinfo tree consistency */
    369369        mutex_lock(&sysinfo_lock);
    370        
     370
    371371        if (root == NULL)
    372372                root = &global_root;
    373        
     373
    374374        sysinfo_item_t *item = sysinfo_create_path(name, root);
    375375        if (item != NULL) {
    … …  
    378378                item->val.gen_val.data = data;
    379379        }
    380        
     380
    381381        mutex_unlock(&sysinfo_lock);
    382382}
    … …  
    401401        /* Protect sysinfo tree consistency */
    402402        mutex_lock(&sysinfo_lock);
    403        
     403
    404404        if (root == NULL)
    405405                root = &global_root;
    406        
     406
    407407        sysinfo_item_t *item = sysinfo_create_path(name, root);
    408408        if (item != NULL) {
    … …  
    411411                item->val.gen_data.data = data;
    412412        }
    413        
     413
    414414        mutex_unlock(&sysinfo_lock);
    415415}
    … …  
    426426        /* Protect sysinfo tree consistency */
    427427        mutex_lock(&sysinfo_lock);
    428        
     428
    429429        if (root == NULL)
    430430                root = &global_root;
    431        
     431
    432432        sysinfo_item_t *item = sysinfo_create_path(name, root);
    433433        if (item != NULL)
    434434                item->val_type = SYSINFO_VAL_UNDEFINED;
    435        
     435
    436436        mutex_unlock(&sysinfo_lock);
    437437}
    … …  
    451451        /* Protect sysinfo tree consistency */
    452452        mutex_lock(&sysinfo_lock);
    453        
     453
    454454        if (root == NULL)
    455455                root = &global_root;
    456        
     456
    457457        sysinfo_item_t *item = sysinfo_create_path(name, root);
    458        
     458
    459459        /* Change the type of the subtree only if it is not already
    460460           a fixed subtree */
    … …  
    464464                item->subtree.generator.data = data;
    465465        }
    466        
     466
    467467        mutex_unlock(&sysinfo_lock);
    468468}
    … …  
    492492        for (sysinfo_item_t *cur = root; cur; cur = cur->next) {
    493493                size_t length;
    494                
     494
    495495                if (spaces == 0) {
    496496                        printf("%s", cur->name);
    … …  
    501501                        length = str_length(cur->name) + 1;
    502502                }
    503                
     503
    504504                sysarg_t val;
    505505                size_t size;
    506                
     506
    507507                /* Display node value and type */
    508508                switch (cur->val_type) {
    … …  
    531531                        printf("+ %s [unknown]\n", cur->name);
    532532                }
    533                
     533
    534534                /* Recursivelly nest into the subtree */
    535535                switch (cur->subtree_type) {
    … …  
    562562           while we are dumping it */
    563563        mutex_lock(&sysinfo_lock);
    564        
     564
    565565        if (root == NULL)
    566566                sysinfo_dump_internal(global_root, 0);
    567567        else
    568568                sysinfo_dump_internal(root, 0);
    569        
     569
    570570        mutex_unlock(&sysinfo_lock);
    571571}
    … …  
    590590        if (root == NULL)
    591591                root = &global_root;
    592        
     592
    593593        /* Try to find the item or generate data */
    594594        sysinfo_return_t ret;
    … …  
    596596        sysinfo_item_t *item = sysinfo_find_item(name, *root, &ret_ptr,
    597597            dry_run);
    598        
     598
    599599        if (item != NULL) {
    600600                /* Item found in the fixed sysinfo tree */
    601                
     601
    602602                ret.tag = item->val_type;
    603603                switch (item->val_type) {
    … …  
    625625                }
    626626        }
    627        
     627
    628628        return ret;
    629629}
    … …  
    645645        sysinfo_return_t ret;
    646646        ret.tag = SYSINFO_VAL_UNDEFINED;
    647        
     647
    648648        if (size > SYSINFO_MAX_PATH)
    649649                return ret;
    650        
     650
    651651        char *path = (char *) malloc(size + 1, 0);
    652652        assert(path);
    653        
     653
    654654        if ((copy_from_uspace(path, ptr, size + 1) == 0) &&
    655655            (path[size] == 0)) {
    … …  
    662662                mutex_unlock(&sysinfo_lock);
    663663        }
    664        
     664
    665665        free(path);
    666666        return ret;
    … …  
    686686        if (root == NULL)
    687687                root = &global_root;
    688        
     688
    689689        sysinfo_item_t *subtree = NULL;
    690        
     690
    691691        if (name[0] != 0) {
    692692                /* Try to find the item */
    … …  
    698698        } else
    699699                subtree = *root;
    700        
     700
    701701        sysinfo_return_t ret;
    702702        ret.tag = SYSINFO_VAL_UNDEFINED;
    703        
     703
    704704        if (subtree != NULL) {
    705705                /*
    … …  
    709709                for (sysinfo_item_t *cur = subtree; cur; cur = cur->next)
    710710                        size += str_size(cur->name) + 1;
    711                
     711
    712712                if (dry_run) {
    713713                        ret.tag = SYSINFO_VAL_DATA;
    … …  
    719719                        if (names == NULL)
    720720                                return ret;
    721                        
     721
    722722                        size_t pos = 0;
    723723                        for (sysinfo_item_t *cur = subtree; cur; cur = cur->next) {
    … …  
    725725                                pos += str_size(cur->name) + 1;
    726726                        }
    727                        
     727
    728728                        /* Correct return value */
    729729                        ret.tag = SYSINFO_VAL_DATA;
    … …  
    732732                }
    733733        }
    734        
     734
    735735        return ret;
    736736}
    … …  
    754754        ret.data.data = NULL;
    755755        ret.data.size = 0;
    756        
     756
    757757        if (size > SYSINFO_MAX_PATH)
    758758                return ret;
    759        
     759
    760760        char *path = (char *) malloc(size + 1, 0);
    761761        assert(path);
    762        
     762
    763763        if ((copy_from_uspace(path, ptr, size + 1) == 0) &&
    764764            (path[size] == 0)) {
    … …  
    771771                mutex_unlock(&sysinfo_lock);
    772772        }
    773        
     773
    774774        free(path);
    775775        return ret;
    … …  
    794794{
    795795        errno_t rc;
    796        
     796
    797797        /*
    798798         * Get the keys.
    … …  
    803803        sysinfo_return_t ret =
    804804            sysinfo_get_keys_uspace(path_ptr, path_size, true);
    805        
     805
    806806        /* Check return data tag */
    807807        if (ret.tag == SYSINFO_VAL_DATA)
    … …  
    810810        else
    811811                rc = EINVAL;
    812        
     812
    813813        return (sys_errno_t) rc;
    814814}
    … …  
    842842{
    843843        errno_t rc;
    844        
     844
    845845        /* Get the keys */
    846846        sysinfo_return_t ret = sysinfo_get_keys_uspace(path_ptr, path_size,
    847847            false);
    848        
     848
    849849        /* Check return data tag */
    850850        if (ret.tag == SYSINFO_VAL_DATA) {
    … …  
    853853                if (rc == EOK)
    854854                        rc = copy_to_uspace(size_ptr, &size, sizeof(size));
    855                
     855
    856856                free(ret.data.data);
    857857        } else
    858858                rc = EINVAL;
    859        
     859
    860860        return (sys_errno_t) rc;
    861861}
    … …  
    882882         */
    883883        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size, true);
    884        
     884
    885885        /*
    886886         * Map generated value types to constant types (user space does
    … …  
    891891        else if (ret.tag == SYSINFO_VAL_FUNCTION_DATA)
    892892                ret.tag = SYSINFO_VAL_DATA;
    893        
     893
    894894        return (sysarg_t) ret.tag;
    895895}
    … …  
    913913{
    914914        errno_t rc;
    915        
     915
    916916        /*
    917917         * Get the item.
    … …  
    921921         */
    922922        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size, true);
    923        
     923
    924924        /* Only constant or generated numerical value is returned */
    925925        if ((ret.tag == SYSINFO_VAL_VAL) || (ret.tag == SYSINFO_VAL_FUNCTION_VAL))
    … …  
    927927        else
    928928                rc = EINVAL;
    929        
     929
    930930        return (sys_errno_t) rc;
    931931}
    … …  
    949949{
    950950        errno_t rc;
    951        
     951
    952952        /*
    953953         * Get the item.
    … …  
    957957         */
    958958        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size, true);
    959        
     959
    960960        /* Only the size of constant or generated binary data is considered */
    961961        if ((ret.tag == SYSINFO_VAL_DATA) || (ret.tag == SYSINFO_VAL_FUNCTION_DATA))
    … …  
    964964        else
    965965                rc = EINVAL;
    966        
     966
    967967        return (sys_errno_t) rc;
    968968}
    … …  
    999999{
    10001000        errno_t rc;
    1001        
     1001
    10021002        /* Get the item */
    10031003        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size,
    10041004            false);
    1005        
     1005
    10061006        /* Only constant or generated binary data is considered */
    10071007        if ((ret.tag == SYSINFO_VAL_DATA) ||
    … …  
    10131013        } else
    10141014                rc = EINVAL;
    1015        
     1015
    10161016        /* N.B.: The generated binary data should be freed */
    10171017        if ((ret.tag == SYSINFO_VAL_FUNCTION_DATA) && (ret.data.data != NULL))
    10181018                free(ret.data.data);
    1019        
     1019
    10201020        return (sys_errno_t) rc;
    10211021}
Note: See TracChangeset for help on using the changeset viewer.