Changeset a35b458 in mainline for kernel/generic/src/sysinfo/stats.c


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r3061bc1 ra35b458  
    9999        if (dry_run)
    100100                return NULL;
    101        
     101
    102102        /* Assumption: config.cpu_count is constant */
    103103        stats_cpu_t *stats_cpus = (stats_cpu_t *) malloc(*size, FRAME_ATOMIC);
    … …  
    106106                return NULL;
    107107        }
    108        
     108
    109109        size_t i;
    110110        for (i = 0; i < config.cpu_count; i++) {
    111111                irq_spinlock_lock(&cpus[i].lock, true);
    112                
     112
    113113                stats_cpus[i].id = cpus[i].id;
    114114                stats_cpus[i].active = cpus[i].active;
    … …  
    116116                stats_cpus[i].busy_cycles = cpus[i].busy_cycles;
    117117                stats_cpus[i].idle_cycles = cpus[i].idle_cycles;
    118                
     118
    119119                irq_spinlock_unlock(&cpus[i].lock, true);
    120120        }
    121        
     121
    122122        return ((void *) stats_cpus);
    123123}
    … …  
    137137        size_t *count = (size_t *) arg;
    138138        (*count)++;
    139        
     139
    140140        return true;
    141141}
    … …  
    156156         * object, return inexact statistics by skipping the respective object.
    157157         */
    158        
     158
    159159        if (mutex_trylock(&as->lock) != EOK)
    160160                return 0;
    161        
     161
    162162        size_t pages = 0;
    163        
     163
    164164        /* Walk the B+ tree and count pages */
    165165        list_foreach(as->as_area_btree.leaf_list, leaf_link, btree_node_t,
    … …  
    168168                for (i = 0; i < node->keys; i++) {
    169169                        as_area_t *area = node->value[i];
    170                        
     170
    171171                        if (mutex_trylock(&area->lock) != EOK)
    172172                                continue;
    173                        
     173
    174174                        pages += area->pages;
    175175                        mutex_unlock(&area->lock);
    176176                }
    177177        }
    178        
     178
    179179        mutex_unlock(&as->lock);
    180        
     180
    181181        return (pages << PAGE_WIDTH);
    182182}
    … …  
    197197         * object, return inexact statistics by skipping the respective object.
    198198         */
    199        
     199
    200200        if (mutex_trylock(&as->lock) != EOK)
    201201                return 0;
    202        
     202
    203203        size_t pages = 0;
    204        
     204
    205205        /* Walk the B+ tree and count pages */
    206206        list_foreach(as->as_area_btree.leaf_list, leaf_link, btree_node_t, node) {
    … …  
    208208                for (i = 0; i < node->keys; i++) {
    209209                        as_area_t *area = node->value[i];
    210                        
     210
    211211                        if (mutex_trylock(&area->lock) != EOK)
    212212                                continue;
    213                        
     213
    214214                        pages += area->resident;
    215215                        mutex_unlock(&area->lock);
    216216                }
    217217        }
    218        
     218
    219219        mutex_unlock(&as->lock);
    220        
     220
    221221        return (pages << PAGE_WIDTH);
    222222}
    … …  
    234234        assert(interrupts_disabled());
    235235        assert(irq_spinlock_locked(&task->lock));
    236        
     236
    237237        stats_task->task_id = task->taskid;
    238238        str_cpy(stats_task->name, TASK_NAME_BUFLEN, task->name);
    … …  
    260260        stats_task_t **iterator = (stats_task_t **) arg;
    261261        task_t *task = avltree_get_instance(node, task_t, tasks_tree_node);
    262        
     262
    263263        /* Interrupts are already disabled */
    264264        irq_spinlock_lock(&(task->lock), false);
    265        
     265
    266266        /* Record the statistics and increment the iterator */
    267267        produce_stats_task(task, *iterator);
    268268        (*iterator)++;
    269        
     269
    270270        irq_spinlock_unlock(&(task->lock), false);
    271        
     271
    272272        return true;
    273273}
    … …  
    289289        /* Messing with task structures, avoid deadlock */
    290290        irq_spinlock_lock(&tasks_lock, true);
    291        
     291
    292292        /* First walk the task tree to count the tasks */
    293293        size_t count = 0;
    294294        avltree_walk(&tasks_tree, avl_count_walker, (void *) &count);
    295        
     295
    296296        if (count == 0) {
    297297                /* No tasks found (strange) */
    … …  
    300300                return NULL;
    301301        }
    302        
     302
    303303        *size = sizeof(stats_task_t) * count;
    304304        if (dry_run) {
    … …  
    306306                return NULL;
    307307        }
    308        
     308
    309309        stats_task_t *stats_tasks = (stats_task_t *) malloc(*size, FRAME_ATOMIC);
    310310        if (stats_tasks == NULL) {
    … …  
    314314                return NULL;
    315315        }
    316        
     316
    317317        /* Walk tha task tree again to gather the statistics */
    318318        stats_task_t *iterator = stats_tasks;
    319319        avltree_walk(&tasks_tree, task_serialize_walker, (void *) &iterator);
    320        
     320
    321321        irq_spinlock_unlock(&tasks_lock, true);
    322        
     322
    323323        return ((void *) stats_tasks);
    324324}
    … …  
    336336        assert(interrupts_disabled());
    337337        assert(irq_spinlock_locked(&thread->lock));
    338        
     338
    339339        stats_thread->thread_id = thread->tid;
    340340        stats_thread->task_id = thread->task->taskid;
    … …  
    343343        stats_thread->ucycles = thread->ucycles;
    344344        stats_thread->kcycles = thread->kcycles;
    345        
     345
    346346        if (thread->cpu != NULL) {
    347347                stats_thread->on_cpu = true;
    … …  
    366366        stats_thread_t **iterator = (stats_thread_t **) arg;
    367367        thread_t *thread = avltree_get_instance(node, thread_t, threads_tree_node);
    368        
     368
    369369        /* Interrupts are already disabled */
    370370        irq_spinlock_lock(&thread->lock, false);
    371        
     371
    372372        /* Record the statistics and increment the iterator */
    373373        produce_stats_thread(thread, *iterator);
    374374        (*iterator)++;
    375        
     375
    376376        irq_spinlock_unlock(&thread->lock, false);
    377        
     377
    378378        return true;
    379379}
    … …  
    395395        /* Messing with threads structures, avoid deadlock */
    396396        irq_spinlock_lock(&threads_lock, true);
    397        
     397
    398398        /* First walk the thread tree to count the threads */
    399399        size_t count = 0;
    400400        avltree_walk(&threads_tree, avl_count_walker, (void *) &count);
    401        
     401
    402402        if (count == 0) {
    403403                /* No threads found (strange) */
    … …  
    406406                return NULL;
    407407        }
    408        
     408
    409409        *size = sizeof(stats_thread_t) * count;
    410410        if (dry_run) {
    … …  
    412412                return NULL;
    413413        }
    414        
     414
    415415        stats_thread_t *stats_threads = (stats_thread_t *) malloc(*size, FRAME_ATOMIC);
    416416        if (stats_threads == NULL) {
    … …  
    420420                return NULL;
    421421        }
    422        
     422
    423423        /* Walk tha thread tree again to gather the statistics */
    424424        stats_thread_t *iterator = stats_threads;
    425425        avltree_walk(&threads_tree, thread_serialize_walker, (void *) &iterator);
    426        
     426
    427427        irq_spinlock_unlock(&threads_lock, true);
    428        
     428
    429429        return ((void *) stats_threads);
    430430}
    … …  
    454454        sysinfo_return_t ret;
    455455        ret.tag = SYSINFO_VAL_UNDEFINED;
    456        
     456
    457457        /* Parse the task ID */
    458458        task_id_t task_id;
    459459        if (str_uint64_t(name, NULL, 0, true, &task_id) != EOK)
    460460                return ret;
    461        
     461
    462462        /* Messing with task structures, avoid deadlock */
    463463        irq_spinlock_lock(&tasks_lock, true);
    464        
     464
    465465        task_t *task = task_find_by_id(task_id);
    466466        if (task == NULL) {
    … …  
    469469                return ret;
    470470        }
    471        
     471
    472472        if (dry_run) {
    473473                ret.tag = SYSINFO_VAL_FUNCTION_DATA;
    474474                ret.data.data = NULL;
    475475                ret.data.size = sizeof(stats_task_t);
    476                
     476
    477477                irq_spinlock_unlock(&tasks_lock, true);
    478478        } else {
    … …  
    484484                        return ret;
    485485                }
    486                
     486
    487487                /* Correct return value */
    488488                ret.tag = SYSINFO_VAL_FUNCTION_DATA;
    489489                ret.data.data = (void *) stats_task;
    490490                ret.data.size = sizeof(stats_task_t);
    491                
     491
    492492                /* Hand-over-hand locking */
    493493                irq_spinlock_exchange(&tasks_lock, &task->lock);
    494                
     494
    495495                produce_stats_task(task, stats_task);
    496                
     496
    497497                irq_spinlock_unlock(&task->lock, true);
    498498        }
    499        
     499
    500500        return ret;
    501501}
    … …  
    525525        sysinfo_return_t ret;
    526526        ret.tag = SYSINFO_VAL_UNDEFINED;
    527        
     527
    528528        /* Parse the thread ID */
    529529        thread_id_t thread_id;
    530530        if (str_uint64_t(name, NULL, 0, true, &thread_id) != EOK)
    531531                return ret;
    532        
     532
    533533        /* Messing with threads structures, avoid deadlock */
    534534        irq_spinlock_lock(&threads_lock, true);
    535        
     535
    536536        thread_t *thread = thread_find_by_id(thread_id);
    537537        if (thread == NULL) {
    … …  
    540540                return ret;
    541541        }
    542        
     542
    543543        if (dry_run) {
    544544                ret.tag = SYSINFO_VAL_FUNCTION_DATA;
    545545                ret.data.data = NULL;
    546546                ret.data.size = sizeof(stats_thread_t);
    547                
     547
    548548                irq_spinlock_unlock(&threads_lock, true);
    549549        } else {
    … …  
    555555                        return ret;
    556556                }
    557                
     557
    558558                /* Correct return value */
    559559                ret.tag = SYSINFO_VAL_FUNCTION_DATA;
    560560                ret.data.data = (void *) stats_thread;
    561561                ret.data.size = sizeof(stats_thread_t);
    562                
     562
    563563                /* Hand-over-hand locking */
    564564                irq_spinlock_exchange(&threads_lock, &thread->lock);
    565                
     565
    566566                produce_stats_thread(thread, stats_thread);
    567                
     567
    568568                irq_spinlock_unlock(&thread->lock, true);
    569569        }
    570        
     570
    571571        return ret;
    572572}
    … …  
    587587{
    588588        *size = sizeof(stats_exc_t) * IVT_ITEMS;
    589        
     589
    590590        if ((dry_run) || (IVT_ITEMS == 0))
    591591                return NULL;
    592        
     592
    593593        stats_exc_t *stats_exceptions =
    594594            (stats_exc_t *) malloc(*size, FRAME_ATOMIC);
    … …  
    598598                return NULL;
    599599        }
    600        
     600
    601601#if (IVT_ITEMS > 0)
    602602        /* Messing with exception table, avoid deadlock */
    603603        irq_spinlock_lock(&exctbl_lock, true);
    604        
     604
    605605        unsigned int i;
    606606        for (i = 0; i < IVT_ITEMS; i++) {
    … …  
    611611                stats_exceptions[i].count = exc_table[i].count;
    612612        }
    613        
     613
    614614        irq_spinlock_unlock(&exctbl_lock, true);
    615615#endif
    616        
     616
    617617        return ((void *) stats_exceptions);
    618618}
    … …  
    642642        sysinfo_return_t ret;
    643643        ret.tag = SYSINFO_VAL_UNDEFINED;
    644        
     644
    645645        /* Parse the exception number */
    646646        uint64_t excn;
    647647        if (str_uint64_t(name, NULL, 0, true, &excn) != EOK)
    648648                return ret;
    649        
     649
    650650#if (IVT_FIRST > 0)
    651651        if (excn < IVT_FIRST)
    652652                return ret;
    653653#endif
    654        
     654
    655655#if (IVT_ITEMS + IVT_FIRST == 0)
    656656        return ret;
    … …  
    659659                return ret;
    660660#endif
    661        
     661
    662662        if (dry_run) {
    663663                ret.tag = SYSINFO_VAL_FUNCTION_DATA;
    … …  
    667667                /* Update excn index for accessing exc_table */
    668668                excn -= IVT_FIRST;
    669                
     669
    670670                /* Allocate stats_exc_t structure */
    671671                stats_exc_t *stats_exception =
    … …  
    673673                if (stats_exception == NULL)
    674674                        return ret;
    675                
     675
    676676                /* Messing with exception table, avoid deadlock */
    677677                irq_spinlock_lock(&exctbl_lock, true);
    678                
     678
    679679                /* Correct return value */
    680680                ret.tag = SYSINFO_VAL_FUNCTION_DATA;
    681681                ret.data.data = (void *) stats_exception;
    682682                ret.data.size = sizeof(stats_exc_t);
    683                
     683
    684684                stats_exception->id = excn;
    685685                str_cpy(stats_exception->desc, EXC_NAME_BUFLEN, exc_table[excn].name);
    … …  
    687687                stats_exception->cycles = exc_table[excn].cycles;
    688688                stats_exception->count = exc_table[excn].count;
    689                
     689
    690690                irq_spinlock_unlock(&exctbl_lock, true);
    691691        }
    692        
     692
    693693        return ret;
    694694}
    … …  
    711711        if (dry_run)
    712712                return NULL;
    713        
     713
    714714        stats_physmem_t *stats_physmem =
    715715            (stats_physmem_t *) malloc(*size, FRAME_ATOMIC);
    … …  
    718718                return NULL;
    719719        }
    720        
     720
    721721        zones_stats(&(stats_physmem->total), &(stats_physmem->unavail),
    722722            &(stats_physmem->used), &(stats_physmem->free));
    723        
     723
    724724        return ((void *) stats_physmem);
    725725}
    … …  
    742742        if (dry_run)
    743743                return NULL;
    744        
     744
    745745        load_t *stats_load = (load_t *) malloc(*size, FRAME_ATOMIC);
    746746        if (stats_load == NULL) {
    … …  
    748748                return NULL;
    749749        }
    750        
     750
    751751        /* To always get consistent values acquire the mutex */
    752752        mutex_lock(&load_lock);
    753        
     753
    754754        unsigned int i;
    755755        for (i = 0; i < LOAD_STEPS; i++)
    756756                stats_load[i] = avenrdy[i] << LOAD_KERNEL_SHIFT;
    757        
     757
    758758        mutex_unlock(&load_lock);
    759        
     759
    760760        return ((void *) stats_load);
    761761}
    … …  
    768768        load *= exp;
    769769        load += (ready << LOAD_FIXED_SHIFT) * (LOAD_FIXED_1 - exp);
    770        
     770
    771771        return (load >> LOAD_FIXED_SHIFT);
    772772}
    … …  
    782782{
    783783        thread_detach(THREAD);
    784        
     784
    785785        while (true) {
    786786                atomic_count_t ready = atomic_get(&nrdy);
    787                
     787
    788788                /* Mutually exclude with get_stats_load() */
    789789                mutex_lock(&load_lock);
    790                
     790
    791791                unsigned int i;
    792792                for (i = 0; i < LOAD_STEPS; i++)
    793793                        avenrdy[i] = load_calc(avenrdy[i], load_exp[i], ready);
    794                
     794
    795795                mutex_unlock(&load_lock);
    796                
     796
    797797                thread_sleep(LOAD_INTERVAL);
    798798        }
    … …  
    805805{
    806806        mutex_initialize(&load_lock, MUTEX_PASSIVE);
    807        
     807
    808808        sysinfo_set_item_gen_data("system.cpus", NULL, get_stats_cpus, NULL);
    809809        sysinfo_set_item_gen_data("system.physmem", NULL, get_stats_physmem, NULL);
Note: See TracChangeset for help on using the changeset viewer.