Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r897fd8f1 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.