Changes in / [9f0318c:ba54451] in mainline


Ignore:
Files:
2 deleted
13 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/sysinfo/abi.h

    r9f0318c rba54451  
    104104        char name[TASK_NAME_BUFLEN];  /**< Task name (in kernel) */
    105105        size_t virtmem;               /**< Size of VAS (bytes) */
    106         size_t resmem;                /**< Size of resident (used) memory (bytes) */
    107106        size_t threads;               /**< Number of threads */
    108107        uint64_t ucycles;             /**< Number of CPU cycles in user space */

  • kernel/generic/include/sysinfo/sysinfo.h

    r9f0318c rba54451  
    148148extern sysarg_t sys_sysinfo_get_value(void *, size_t, void *);
    149149extern sysarg_t sys_sysinfo_get_data_size(void *, size_t, void *);
    150 extern sysarg_t sys_sysinfo_get_data(void *, size_t, void *, size_t, size_t *);
     150extern sysarg_t sys_sysinfo_get_data(void *, size_t, void *, size_t);
    151151
    152152#endif

  • kernel/generic/src/mm/backend_phys.c

    r9f0318c rba54451  
    8181        page_mapping_insert(AS, addr, base + (addr - area->base),
    8282            as_area_get_flags(area));
    83        
    84         if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
    85                 panic("Cannot insert used space.");
     83        if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
     84                panic("Cannot insert used space.");
    8685
    8786        return AS_PF_OK;

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

    r9f0318c rba54451  
    170170         * Note that it may be infinitely better to let the address space
    171171         * management code compute these statistics as it proceeds instead of
    172          * having them calculated over and over again here.
     172         * having them calculated here over and over again here.
    173173         */
    174174
    … …  
    199199}
    200200
    201 /** Get the resident (used) size of a virtual address space
    202  *
    203  * @param as Address space.
    204  *
    205  * @return Size of the resident (used) virtual address space (bytes).
    206  *
    207  */
    208 static size_t get_task_resmem(as_t *as)
    209 {
    210         size_t result = 0;
    211        
    212         /*
    213          * We are holding some spinlocks here and therefore are not allowed to
    214          * block. Only attempt to lock the address space and address space area
    215          * mutexes conditionally. If it is not possible to lock either object,
    216          * allow the statistics to be inexact by skipping the respective object.
    217          *
    218          * Note that it may be infinitely better to let the address space
    219          * management code compute these statistics as it proceeds instead of
    220          * having them calculated over and over again here.
    221          */
    222        
    223         if (SYNCH_FAILED(mutex_trylock(&as->lock)))
    224                 return result * PAGE_SIZE;
    225        
    226         /* Walk the B+ tree of AS areas */
    227         link_t *cur;
    228         for (cur = as->as_area_btree.leaf_head.next;
    229             cur != &as->as_area_btree.leaf_head; cur = cur->next) {
    230                 btree_node_t *node =
    231                     list_get_instance(cur, btree_node_t, leaf_link);
    232                
    233                 unsigned int i;
    234                 for (i = 0; i < node->keys; i++) {
    235                         as_area_t *area = node->value[i];
    236                        
    237                         if (SYNCH_FAILED(mutex_trylock(&area->lock)))
    238                                 continue;
    239                        
    240                         /* Walk the B+ tree of resident pages */
    241                         link_t *rcur;
    242                         for (rcur = area->used_space.leaf_head.next;
    243                             rcur != &area->used_space.leaf_head; rcur = rcur->next) {
    244                                 btree_node_t *rnode =
    245                                     list_get_instance(rcur, btree_node_t, leaf_link);
    246                                
    247                                 unsigned int j;
    248                                 for (j = 0; j < rnode->keys; j++)
    249                                         result += (size_t) rnode->value[i];
    250                         }
    251                        
    252                         mutex_unlock(&area->lock);
    253                 }
    254         }
    255        
    256         mutex_unlock(&as->lock);
    257        
    258         return result * PAGE_SIZE;
    259 }
    260 
    261201/* Produce task statistics
    262202 *
    … …  
    275215        str_cpy(stats_task->name, TASK_NAME_BUFLEN, task->name);
    276216        stats_task->virtmem = get_task_virtmem(task->as);
    277         stats_task->resmem = get_task_resmem(task->as);
    278217        stats_task->threads = atomic_get(&task->refcount);
    279218        task_get_accounting(task, &(stats_task->ucycles),

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

    r9f0318c rba54451  
    4040#include <arch/asm.h>
    4141#include <errno.h>
    42 #include <macros.h>
    4342
    4443/** Maximal sysinfo path length */
    … …  
    762761 * character must be null).
    763762 *
    764  * If the user space buffer size does not equal
    765  * the actual size of the returned data, the data
    766  * is truncated. Whether this is actually a fatal
    767  * error or the data can be still interpreted as valid
    768  * depends on the nature of the data and has to be
    769  * decided by the user space.
    770  *
    771  * The actual size of data returned is stored to
    772  * size_ptr.
     763 * The user space buffer must be sized exactly according
     764 * to the size of the binary data, otherwise the request
     765 * fails.
    773766 *
    774767 * @param path_ptr    Sysinfo path in the user address space.
    … …  
    777770 *                    to store the binary data.
    778771 * @param buffer_size User space buffer size.
    779  * @param size_ptr    User space pointer where to store the
    780  *                    binary data size.
    781772 *
    782773 * @return Error code (EOK in case of no error).
    … …  
    784775 */
    785776sysarg_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,
    786     void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
     777    void *buffer_ptr, size_t buffer_size)
    787778{
    788779        int rc;
    789780       
    790781        /* Get the item */
    791         sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size,
    792             false);
    793        
     782        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size, false);
     783
    794784        /* Only constant or generated binary data is considered */
    795         if ((ret.tag == SYSINFO_VAL_DATA) ||
    796             (ret.tag == SYSINFO_VAL_FUNCTION_DATA)) {
    797                 size_t size = min(ret.data.size, buffer_size);
    798                 rc = copy_to_uspace(buffer_ptr, ret.data.data, size);
    799                 if (rc == EOK)
    800                         rc = copy_to_uspace(size_ptr, &size, sizeof(size));
     785        if ((ret.tag == SYSINFO_VAL_DATA) || (ret.tag == SYSINFO_VAL_FUNCTION_DATA)) {
     786                /* Check destination buffer size */
     787                if (ret.data.size == buffer_size)
     788                        rc = copy_to_uspace(buffer_ptr, ret.data.data,
     789                            ret.data.size);
     790                else
     791                        rc = ENOMEM;
    801792        } else
    802793                rc = EINVAL;

  • uspace/app/tasks/tasks.c

    r9f0318c rba54451  
    6666        }
    6767       
    68         printf(" Task ID  Threads      Mem       uCycles       kCycles   Name\n");
     68        printf("     ID  Threads      Mem       uCycles       kCycles   Name\n");
    6969       
    7070        size_t i;
    … …  
    9696        }
    9797       
    98         printf(" ThrID    State  CPU   Prio    [k]uCycles    [k]kcycles   Cycle fault\n");
     98        printf("    ID    State  CPU   Prio    [k]uCycles    [k]kcycles   Cycle fault\n");
    9999        size_t i;
    100100        for (i = 0; i < count; i++) {

  • uspace/app/top/screen.c

    r9f0318c rba54451  
    274274{
    275275        screen_style_inverted();
    276         printf("[taskid] [threads] [resident] [%%resi] [virtual] [%%virt]"
    277             " [%%user] [%%kern] [name");
     276        printf("[taskid] [threads] [virtual] [%%virt] [%%user]"
     277            " [%%kernel] [name");
    278278        screen_newline();
    279279        screen_style_normal();
    … …  
    295295                perc_task_t *perc = data->tasks_perc + data->tasks_map[i];
    296296               
    297                 uint64_t resmem;
    298                 char resmem_suffix;
    299                 order_suffix(task->resmem, &resmem, &resmem_suffix);
    300                
    301297                uint64_t virtmem;
    302298                char virtmem_suffix;
    303299                order_suffix(task->virtmem, &virtmem, &virtmem_suffix);
    304300               
    305                 printf("%-8" PRIu64 " %9zu %9" PRIu64 "%c ",
    306                     task->task_id, task->threads, resmem, resmem_suffix);
    307                 print_percent(perc->resmem, 2);
    308                 printf(" %8" PRIu64 "%c ", virtmem, virtmem_suffix);
     301                printf("%-8" PRIu64 " %9zu %8" PRIu64 "%c ", task->task_id,
     302                    task->threads, virtmem, virtmem_suffix);
    309303                print_percent(perc->virtmem, 2);
    310304                puts(" ");
    311305                print_percent(perc->ucycles, 2);
    312                 puts(" ");
     306                puts("   ");
    313307                print_percent(perc->kcycles, 2);
    314308                puts(" ");

  • uspace/app/top/top.c

    r9f0318c rba54451  
    195195       
    196196        uint64_t virtmem_total = 0;
    197         uint64_t resmem_total = 0;
    198197        uint64_t ucycles_total = 0;
    199198        uint64_t kcycles_total = 0;
    … …  
    224223               
    225224                virtmem_total += new_data->tasks[i].virtmem;
    226                 resmem_total += new_data->tasks[i].resmem;
    227225                ucycles_total += new_data->ucycles_diff[i];
    228226                kcycles_total += new_data->kcycles_diff[i];
    … …  
    234232                FRACTION_TO_FLOAT(new_data->tasks_perc[i].virtmem,
    235233                    new_data->tasks[i].virtmem * 100, virtmem_total);
    236                 FRACTION_TO_FLOAT(new_data->tasks_perc[i].resmem,
    237                     new_data->tasks[i].resmem * 100, resmem_total);
    238234                FRACTION_TO_FLOAT(new_data->tasks_perc[i].ucycles,
    239235                    new_data->ucycles_diff[i] * 100, ucycles_total);

  • uspace/app/top/top.h

    r9f0318c rba54451  
    7777typedef struct {
    7878        fixed_float virtmem;
    79         fixed_float resmem;
    8079        fixed_float ucycles;
    8180        fixed_float kcycles;

  • uspace/app/trace/syscalls.c

    r9f0318c rba54451  
    7777    [SYS_SYSINFO_GET_VALUE] = { "sysinfo_get_value",            3,      V_ERRNO },
    7878    [SYS_SYSINFO_GET_DATA_SIZE] = { "sysinfo_get_data_size",    3,      V_ERRNO },
    79     [SYS_SYSINFO_GET_DATA] = { "sysinfo_get_data",              5,      V_ERRNO },
     79    [SYS_SYSINFO_GET_DATA] = { "sysinfo_get_data",              4,      V_ERRNO },
    8080
    8181    [SYS_DEBUG_ENABLE_CONSOLE] = { "debug_enable_console", 0,   V_ERRNO },

  • uspace/lib/c/generic/stats.c

    r9f0318c rba54451  
    3636#include <stats.h>
    3737#include <sysinfo.h>
     38#include <assert.h>
    3839#include <errno.h>
    3940#include <stdio.h>
    4041#include <inttypes.h>
    41 #include <malloc.h>
    4242
    4343#define SYSINFO_STATS_MAX_PATH  64
    … …  
    7171            (stats_cpu_t *) sysinfo_get_data("system.cpus", &size);
    7272       
    73         if ((size % sizeof(stats_cpu_t)) != 0) {
    74                 if (stats_cpus != NULL)
    75                         free(stats_cpus);
    76                 *count = 0;
    77                 return NULL;
    78         }
     73        assert((size % sizeof(stats_cpu_t)) == 0);
    7974       
    8075        *count = size / sizeof(stats_cpu_t);
    … …  
    9691            (stats_physmem_t *) sysinfo_get_data("system.physmem", &size);
    9792       
    98         if (size != sizeof(stats_physmem_t)) {
    99                 if (stats_physmem != NULL)
    100                         free(stats_physmem);
    101                 return NULL;
    102         }
     93        assert((size == sizeof(stats_physmem_t)) || (size == 0));
    10394       
    10495        return stats_physmem;
    … …  
    120111            (stats_task_t *) sysinfo_get_data("system.tasks", &size);
    121112       
    122         if ((size % sizeof(stats_task_t)) != 0) {
    123                 if (stats_tasks != NULL)
    124                         free(stats_tasks);
    125                 *count = 0;
    126                 return NULL;
    127         }
     113        assert((size % sizeof(stats_task_t)) == 0);
    128114       
    129115        *count = size / sizeof(stats_task_t);
    … …  
    149135            (stats_task_t *) sysinfo_get_data(name, &size);
    150136       
    151         if (size != sizeof(stats_task_t)) {
    152                 if (stats_task != NULL)
    153                         free(stats_task);
    154                 return NULL;
    155         }
     137        assert((size == sizeof(stats_task_t)) || (size == 0));
    156138       
    157139        return stats_task;
    … …  
    173155            (stats_thread_t *) sysinfo_get_data("system.threads", &size);
    174156       
    175         if ((size % sizeof(stats_thread_t)) != 0) {
    176                 if (stats_threads != NULL)
    177                         free(stats_threads);
    178                 *count = 0;
    179                 return NULL;
    180         }
     157        assert((size % sizeof(stats_thread_t)) == 0);
    181158       
    182159        *count = size / sizeof(stats_thread_t);
    … …  
    202179            (stats_thread_t *) sysinfo_get_data(name, &size);
    203180       
    204         if (size != sizeof(stats_thread_t)) {
    205                 if (stats_thread != NULL)
    206                         free(stats_thread);
    207                 return NULL;
    208         }
     181        assert((size == sizeof(stats_thread_t)) || (size == 0));
    209182       
    210183        return stats_thread;
    … …  
    226199            (stats_exc_t *) sysinfo_get_data("system.exceptions", &size);
    227200       
    228         if ((size % sizeof(stats_exc_t)) != 0) {
    229                 if (stats_exceptions != NULL)
    230                         free(stats_exceptions);
    231                 *count = 0;
    232                 return NULL;
    233         }
     201        assert((size % sizeof(stats_exc_t)) == 0);
    234202       
    235203        *count = size / sizeof(stats_exc_t);
    … …  
    249217{
    250218        char name[SYSINFO_STATS_MAX_PATH];
    251         snprintf(name, SYSINFO_STATS_MAX_PATH, "system.exceptions.%u", excn);
     219        snprintf(name, SYSINFO_STATS_MAX_PATH, "system.exceptionss.%u", excn);
    252220       
    253221        size_t size = 0;
    … …  
    255223            (stats_exc_t *) sysinfo_get_data(name, &size);
    256224       
    257         if (size != sizeof(stats_exc_t)) {
    258                 if (stats_exception != NULL)
    259                         free(stats_exception);
    260                 return NULL;
    261         }
     225        assert((size == sizeof(stats_exc_t)) || (size == 0));
    262226       
    263227        return stats_exception;
    … …  
    279243            (load_t *) sysinfo_get_data("system.load", &size);
    280244       
    281         if ((size % sizeof(load_t)) != 0) {
    282                 if (load != NULL)
    283                         free(load);
    284                 *count = 0;
    285                 return NULL;
    286         }
     245        assert((size % sizeof(load_t)) == 0);
    287246       
    288247        *count = size / sizeof(load_t);

  • uspace/lib/c/generic/sysinfo.c

    r9f0318c rba54451  
    9696void *sysinfo_get_data(const char *path, size_t *size)
    9797{
    98         /*
    99          * The binary data size might change during time.
    100          * Unfortunatelly we cannot allocate the buffer
    101          * and transfer the data as a single atomic operation.
    102          */
     98        /* The binary data size might change during time.
     99           Unfortunatelly we cannot allocate the buffer
     100           and transfer the data as a single atomic operation.
    103101       
    104         /* Get the binary data size */
    105         int ret = sysinfo_get_data_size(path, size);
    106         if ((ret != EOK) || (size == 0)) {
    107                 /*
    108                  * Not a binary data item
    109                  * or an empty item.
    110                  */
    111                 *size = 0;
    112                 return NULL;
     102           Let's hope that the number of iterations is bounded
     103           in common cases. */
     104       
     105        void *data = NULL;
     106       
     107        while (true) {
     108                /* Get the binary data size */
     109                int ret = sysinfo_get_data_size(path, size);
     110                if ((ret != EOK) || (size == 0)) {
     111                        /* Not a binary data item
     112                           or an empty item */
     113                        break;
     114                }
     115               
     116                data = realloc(data, *size);
     117                if (data == NULL)
     118                        break;
     119               
     120                /* Get the data */
     121                ret = __SYSCALL4(SYS_SYSINFO_GET_DATA, (sysarg_t) path,
     122                    (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size);
     123                if (ret == EOK)
     124                        return data;
     125               
     126                if (ret != ENOMEM) {
     127                        /* The failure to get the data was not caused
     128                           by wrong buffer size */
     129                        break;
     130                }
    113131        }
    114132       
    115         void *data = malloc(*size);
    116         if (data == NULL) {
    117                 *size = 0;
    118                 return NULL;
    119         }
     133        if (data != NULL)
     134                free(data);
    120135       
    121         /* Get the data */
    122         size_t sz;
    123         ret = __SYSCALL5(SYS_SYSINFO_GET_DATA, (sysarg_t) path,
    124             (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size,
    125             (sysarg_t) &sz);
    126         if (ret == EOK) {
    127                 *size = sz;
    128                 return data;
    129         }
    130        
    131         free(data);
    132136        *size = 0;
    133137        return NULL;

  • uspace/lib/usb/Makefile

    r9f0318c rba54451  
    4747        src/usb.c \
    4848        src/usbdrvreq.c \
    49         src/usbdrv.c \
    50         src/usbmem.c
     49        src/usbdrv.c
    5150
    5251include $(USPACE_PREFIX)/Makefile.common
Note: See TracChangeset for help on using the changeset viewer.