Changes in / [ba54451:9f0318c] in mainline


Ignore:
Files:
2 added
13 edited

Legend:

Unmodified
Added
Removed

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

    rba54451 r9f0318c  
    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) */
    106107        size_t threads;               /**< Number of threads */
    107108        uint64_t ucycles;             /**< Number of CPU cycles in user space */

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

    rba54451 r9f0318c  
    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);
     150extern sysarg_t sys_sysinfo_get_data(void *, size_t, void *, size_t, size_t *);
    151151
    152152#endif

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

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

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

    rba54451 r9f0318c  
    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 here over and over again here.
     172         * having them calculated 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 */
     208static 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
    201261/* Produce task statistics
    202262 *
    … …  
    215275        str_cpy(stats_task->name, TASK_NAME_BUFLEN, task->name);
    216276        stats_task->virtmem = get_task_virtmem(task->as);
     277        stats_task->resmem = get_task_resmem(task->as);
    217278        stats_task->threads = atomic_get(&task->refcount);
    218279        task_get_accounting(task, &(stats_task->ucycles),

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

    rba54451 r9f0318c  
    4040#include <arch/asm.h>
    4141#include <errno.h>
     42#include <macros.h>
    4243
    4344/** Maximal sysinfo path length */
    … …  
    761762 * character must be null).
    762763 *
    763  * The user space buffer must be sized exactly according
    764  * to the size of the binary data, otherwise the request
    765  * fails.
     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.
    766773 *
    767774 * @param path_ptr    Sysinfo path in the user address space.
    … …  
    770777 *                    to store the binary data.
    771778 * @param buffer_size User space buffer size.
     779 * @param size_ptr    User space pointer where to store the
     780 *                    binary data size.
    772781 *
    773782 * @return Error code (EOK in case of no error).
    … …  
    775784 */
    776785sysarg_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,
    777     void *buffer_ptr, size_t buffer_size)
     786    void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
    778787{
    779788        int rc;
    780789       
    781790        /* Get the item */
    782         sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size, false);
    783 
     791        sysinfo_return_t ret = sysinfo_get_item_uspace(path_ptr, path_size,
     792            false);
     793       
    784794        /* Only constant or generated binary data is considered */
    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;
     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));
    792801        } else
    793802                rc = EINVAL;

  • uspace/app/tasks/tasks.c

    rba54451 r9f0318c  
    6666        }
    6767       
    68         printf("     ID  Threads      Mem       uCycles       kCycles   Name\n");
     68        printf(" Task ID  Threads      Mem       uCycles       kCycles   Name\n");
    6969       
    7070        size_t i;
    … …  
    9696        }
    9797       
    98         printf("    ID    State  CPU   Prio    [k]uCycles    [k]kcycles   Cycle fault\n");
     98        printf(" ThrID    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

    rba54451 r9f0318c  
    274274{
    275275        screen_style_inverted();
    276         printf("[taskid] [threads] [virtual] [%%virt] [%%user]"
    277             " [%%kernel] [name");
     276        printf("[taskid] [threads] [resident] [%%resi] [virtual] [%%virt]"
     277            " [%%user] [%%kern] [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               
    297301                uint64_t virtmem;
    298302                char virtmem_suffix;
    299303                order_suffix(task->virtmem, &virtmem, &virtmem_suffix);
    300304               
    301                 printf("%-8" PRIu64 " %9zu %8" PRIu64 "%c ", task->task_id,
    302                     task->threads, virtmem, virtmem_suffix);
     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);
    303309                print_percent(perc->virtmem, 2);
    304310                puts(" ");
    305311                print_percent(perc->ucycles, 2);
    306                 puts("   ");
     312                puts(" ");
    307313                print_percent(perc->kcycles, 2);
    308314                puts(" ");

  • uspace/app/top/top.c

    rba54451 r9f0318c  
    195195       
    196196        uint64_t virtmem_total = 0;
     197        uint64_t resmem_total = 0;
    197198        uint64_t ucycles_total = 0;
    198199        uint64_t kcycles_total = 0;
    … …  
    223224               
    224225                virtmem_total += new_data->tasks[i].virtmem;
     226                resmem_total += new_data->tasks[i].resmem;
    225227                ucycles_total += new_data->ucycles_diff[i];
    226228                kcycles_total += new_data->kcycles_diff[i];
    … …  
    232234                FRACTION_TO_FLOAT(new_data->tasks_perc[i].virtmem,
    233235                    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);
    234238                FRACTION_TO_FLOAT(new_data->tasks_perc[i].ucycles,
    235239                    new_data->ucycles_diff[i] * 100, ucycles_total);

  • uspace/app/top/top.h

    rba54451 r9f0318c  
    7777typedef struct {
    7878        fixed_float virtmem;
     79        fixed_float resmem;
    7980        fixed_float ucycles;
    8081        fixed_float kcycles;

  • uspace/app/trace/syscalls.c

    rba54451 r9f0318c  
    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",              4,      V_ERRNO },
     79    [SYS_SYSINFO_GET_DATA] = { "sysinfo_get_data",              5,      V_ERRNO },
    8080
    8181    [SYS_DEBUG_ENABLE_CONSOLE] = { "debug_enable_console", 0,   V_ERRNO },

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

    rba54451 r9f0318c  
    3636#include <stats.h>
    3737#include <sysinfo.h>
    38 #include <assert.h>
    3938#include <errno.h>
    4039#include <stdio.h>
    4140#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         assert((size % sizeof(stats_cpu_t)) == 0);
     73        if ((size % sizeof(stats_cpu_t)) != 0) {
     74                if (stats_cpus != NULL)
     75                        free(stats_cpus);
     76                *count = 0;
     77                return NULL;
     78        }
    7479       
    7580        *count = size / sizeof(stats_cpu_t);
    … …  
    9196            (stats_physmem_t *) sysinfo_get_data("system.physmem", &size);
    9297       
    93         assert((size == sizeof(stats_physmem_t)) || (size == 0));
     98        if (size != sizeof(stats_physmem_t)) {
     99                if (stats_physmem != NULL)
     100                        free(stats_physmem);
     101                return NULL;
     102        }
    94103       
    95104        return stats_physmem;
    … …  
    111120            (stats_task_t *) sysinfo_get_data("system.tasks", &size);
    112121       
    113         assert((size % sizeof(stats_task_t)) == 0);
     122        if ((size % sizeof(stats_task_t)) != 0) {
     123                if (stats_tasks != NULL)
     124                        free(stats_tasks);
     125                *count = 0;
     126                return NULL;
     127        }
    114128       
    115129        *count = size / sizeof(stats_task_t);
    … …  
    135149            (stats_task_t *) sysinfo_get_data(name, &size);
    136150       
    137         assert((size == sizeof(stats_task_t)) || (size == 0));
     151        if (size != sizeof(stats_task_t)) {
     152                if (stats_task != NULL)
     153                        free(stats_task);
     154                return NULL;
     155        }
    138156       
    139157        return stats_task;
    … …  
    155173            (stats_thread_t *) sysinfo_get_data("system.threads", &size);
    156174       
    157         assert((size % sizeof(stats_thread_t)) == 0);
     175        if ((size % sizeof(stats_thread_t)) != 0) {
     176                if (stats_threads != NULL)
     177                        free(stats_threads);
     178                *count = 0;
     179                return NULL;
     180        }
    158181       
    159182        *count = size / sizeof(stats_thread_t);
    … …  
    179202            (stats_thread_t *) sysinfo_get_data(name, &size);
    180203       
    181         assert((size == sizeof(stats_thread_t)) || (size == 0));
     204        if (size != sizeof(stats_thread_t)) {
     205                if (stats_thread != NULL)
     206                        free(stats_thread);
     207                return NULL;
     208        }
    182209       
    183210        return stats_thread;
    … …  
    199226            (stats_exc_t *) sysinfo_get_data("system.exceptions", &size);
    200227       
    201         assert((size % sizeof(stats_exc_t)) == 0);
     228        if ((size % sizeof(stats_exc_t)) != 0) {
     229                if (stats_exceptions != NULL)
     230                        free(stats_exceptions);
     231                *count = 0;
     232                return NULL;
     233        }
    202234       
    203235        *count = size / sizeof(stats_exc_t);
    … …  
    217249{
    218250        char name[SYSINFO_STATS_MAX_PATH];
    219         snprintf(name, SYSINFO_STATS_MAX_PATH, "system.exceptionss.%u", excn);
     251        snprintf(name, SYSINFO_STATS_MAX_PATH, "system.exceptions.%u", excn);
    220252       
    221253        size_t size = 0;
    … …  
    223255            (stats_exc_t *) sysinfo_get_data(name, &size);
    224256       
    225         assert((size == sizeof(stats_exc_t)) || (size == 0));
     257        if (size != sizeof(stats_exc_t)) {
     258                if (stats_exception != NULL)
     259                        free(stats_exception);
     260                return NULL;
     261        }
    226262       
    227263        return stats_exception;
    … …  
    243279            (load_t *) sysinfo_get_data("system.load", &size);
    244280       
    245         assert((size % sizeof(load_t)) == 0);
     281        if ((size % sizeof(load_t)) != 0) {
     282                if (load != NULL)
     283                        free(load);
     284                *count = 0;
     285                return NULL;
     286        }
    246287       
    247288        *count = size / sizeof(load_t);

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

    rba54451 r9f0318c  
    9696void *sysinfo_get_data(const char *path, size_t *size)
    9797{
    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.
     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         */
    101103       
    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                 }
     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;
    131113        }
    132114       
    133         if (data != NULL)
    134                 free(data);
     115        void *data = malloc(*size);
     116        if (data == NULL) {
     117                *size = 0;
     118                return NULL;
     119        }
    135120       
     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);
    136132        *size = 0;
    137133        return NULL;

  • uspace/lib/usb/Makefile

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