Changeset dec16a2 in mainline

Timestamp:

2010-04-18T16:52:47Z (14 years ago)

Author:

Martin Decky <martin@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

5c45ca8

Parents:

e535eeb

Message:

• sysinfo items "system.tasks" and "system.threads" now return complete statistics of all tasks and threads (statistics of individual tasks and threads can be still acquited from "system.tasks.#" and "system.threads.#")
• update user space functions accordingly
• cleanup top — it is fully functional again

Files:

• boot/Makefile.common (modified) (1 diff)
• kernel/generic/include/sysinfo/abi.h (modified) (2 diffs)
• kernel/generic/src/sysinfo/stats.c (modified) (4 diffs)
• uspace/app/tasks/tasks.c (modified) (4 diffs)
• uspace/app/top/Makefile (modified) (1 diff)
• uspace/app/top/ps.c (deleted)
• uspace/app/top/ps.h (deleted)
• uspace/app/top/screen.c (modified) (7 diffs)
• uspace/app/top/screen.h (modified) (2 diffs)
• uspace/app/top/top.c (modified) (3 diffs)
• uspace/app/top/top.h (modified) (4 diffs)
• uspace/lib/c/generic/stats.c (modified) (2 diffs)
• uspace/lib/c/include/stats.h (modified) (1 diff)

boot/Makefile.common

@@ -94 +94 @@
         $(USPACEDIR)/app/ping/ping \
         $(USPACEDIR)/app/stats/stats \
-        $(USPACEDIR)/app/tasks/tasks
-#       $(USPACEDIR)/app/top/top \
+        $(USPACEDIR)/app/tasks/tasks \
+        $(USPACEDIR)/app/top/top
 #       $(USPACEDIR)/app/dummy_load/dummy_load
 

kernel/generic/include/sysinfo/abi.h

@@ -99 +99 @@
  */
 typedef struct {
+        task_id_t task_id;            /**< Task ID */
         char name[TASK_NAME_BUFLEN];  /**< Task name (in kernel) */
         size_t virtmem;               /**< Size of VAS (bytes) */
@@ -111 +112 @@
  */
 typedef struct {
-        task_id_t task_id;
-        state_t state;
-        int priority;
-        uint64_t ucycles;
-        uint64_t kcycles;
-        bool on_cpu;
-        unsigned int cpu;
+        thread_id_t thread_id;  /**< Thread ID */
+        task_id_t task_id;      /**< Associated task ID */
+        state_t state;          /**< Thread state */
+        int priority;           /**< Thread priority */
+        uint64_t ucycles;       /**< Number of CPU cycles in user space */
+        uint64_t kcycles;       /**< Number of CPU cycles in kernel */
+        bool on_cpu;            /**< Associated with a CPU */
+        unsigned int cpu;       /**< Associated CPU ID (if on_cpu is true) */
 } stats_thread_t;
 

kernel/generic/src/sysinfo/stats.c

@@ -146 +146 @@
 }
 
-/** Gather tasks
- *
- * AVL task tree walker for gathering task IDs. Interrupts should
- * be already disabled while walking the tree.
- *
- * @param node AVL task tree node.
- * @param arg  Pointer to the iterator into the array of task IDs.
- *
- * @param Always true (continue the walk).
- *
- */
-static bool task_serialize_walker(avltree_node_t *node, void *arg)
-{
-        task_id_t **ids = (task_id_t **) arg;
-        task_t *task = avltree_get_instance(node, task_t, tasks_tree_node);
-        
-        /* Interrupts are already disabled */
-        spinlock_lock(&(task->lock));
-        
-        /* Record the ID and increment the iterator */
-        **ids = task->taskid;
-        (*ids)++;
-        
-        spinlock_unlock(&(task->lock));
-        
-        return true;
-}
-
-/** Get task IDs
- *
- * @param item    Sysinfo item (unused).
- * @param size    Size of the returned data.
- * @param dry_run Do not get the data, just calculate the size.
- *
- * @return Data containing task IDs of all tasks.
- *         If the return value is not NULL, it should be freed
- *         in the context of the sysinfo request.
- */
-static void *get_stats_tasks(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
-{
-        /* Messing with task structures, avoid deadlock */
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&tasks_lock);
-        
-        /* First walk the task tree to count the tasks */
-        size_t count = 0;
-        avltree_walk(&tasks_tree, avl_count_walker, (void *) &count);
-        
-        if (count == 0) {
-                /* No tasks found (strange) */
-                spinlock_unlock(&tasks_lock);
-                interrupts_restore(ipl);
-                
-                *size = 0;
-                return NULL;
-        }
-        
-        *size = sizeof(task_id_t) * count;
-        if (dry_run) {
-                spinlock_unlock(&tasks_lock);
-                interrupts_restore(ipl);
-                return NULL;
-        }
-        
-        task_id_t *task_ids = (task_id_t *) malloc(*size, FRAME_ATOMIC);
-        if (task_ids == NULL) {
-                /* No free space for allocation */
-                spinlock_unlock(&tasks_lock);
-                interrupts_restore(ipl);
-                
-                *size = 0;
-                return NULL;
-        }
-        
-        /* Walk tha task tree again to gather the IDs */
-        task_id_t *iterator = task_ids;
-        avltree_walk(&tasks_tree, task_serialize_walker, (void *) &iterator);
-        
-        spinlock_unlock(&tasks_lock);
-        interrupts_restore(ipl);
-        
-        return ((void *) task_ids);
-}
-
-/** Gather threads
- *
- * AVL three tree walker for gathering thread IDs. Interrupts should
- * be already disabled while walking the tree.
- *
- * @param node AVL thread tree node.
- * @param arg  Pointer to the iterator into the array of thread IDs.
- *
- * @param Always true (continue the walk).
- *
- */
-static bool thread_serialize_walker(avltree_node_t *node, void *arg)
-{
-        thread_id_t **ids = (thread_id_t **) arg;
-        thread_t *thread = avltree_get_instance(node, thread_t, threads_tree_node);
-        
-        /* Interrupts are already disabled */
-        spinlock_lock(&(thread->lock));
-        
-        /* Record the ID and increment the iterator */
-        **ids = thread->tid;
-        (*ids)++;
-        
-        spinlock_unlock(&(thread->lock));
-        
-        return true;
-}
-
-/** Get thread IDs
- *
- * @param item    Sysinfo item (unused).
- * @param size    Size of the returned data.
- * @param dry_run Do not get the data, just calculate the size.
- *
- * @return Data containing thread IDs of all threads.
- *         If the return value is not NULL, it should be freed
- *         in the context of the sysinfo request.
- */
-static void *get_stats_threads(struct sysinfo_item *item, size_t *size,
-    bool dry_run)
-{
-        /* Messing with threads structures, avoid deadlock */
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&threads_lock);
-        
-        /* First walk the thread tree to count the threads */
-        size_t count = 0;
-        avltree_walk(&threads_tree, avl_count_walker, (void *) &count);
-        
-        if (count == 0) {
-                /* No threads found (strange) */
-                spinlock_unlock(&threads_lock);
-                interrupts_restore(ipl);
-                
-                *size = 0;
-                return NULL;
-        }
-        
-        *size = sizeof(thread_id_t) * count;
-        if (dry_run) {
-                spinlock_unlock(&threads_lock);
-                interrupts_restore(ipl);
-                return NULL;
-        }
-        
-        thread_id_t *thread_ids = (thread_id_t *) malloc(*size, FRAME_ATOMIC);
-        if (thread_ids == NULL) {
-                /* No free space for allocation */
-                spinlock_unlock(&threads_lock);
-                interrupts_restore(ipl);
-                
-                *size = 0;
-                return NULL;
-        }
-        
-        /* Walk tha thread tree again to gather the IDs */
-        thread_id_t *iterator = thread_ids;
-        avltree_walk(&threads_tree, thread_serialize_walker, (void *) &iterator);
-        
-        spinlock_unlock(&threads_lock);
-        interrupts_restore(ipl);
-        
-        return ((void *) thread_ids);
-}
-
 /** Get the size of a virtual address space
  *
@@ -351 +181 @@
 }
 
+/* Produce task statistics
+ *
+ * Summarize task information into task statistics.
+ * Task lock should be held and interrupts disabled
+ * before executing this function.
+ *
+ * @param task       Task.
+ * @param stats_task Task statistics.
+ *
+ */
+static void produce_stats_task(task_t *task, stats_task_t *stats_task)
+{
+        stats_task->task_id = task->taskid;
+        str_cpy(stats_task->name, TASK_NAME_BUFLEN, task->name);
+        stats_task->virtmem = get_task_virtmem(task->as);
+        stats_task->threads = atomic_get(&task->refcount);
+        task_get_accounting(task, &(stats_task->ucycles),
+            &(stats_task->kcycles));
+        stats_task->ipc_info = task->ipc_info;
+}
+
+/** Gather statistics of all tasks
+ *
+ * AVL task tree walker for gathering task statistics. Interrupts should
+ * be already disabled while walking the tree.
+ *
+ * @param node AVL task tree node.
+ * @param arg  Pointer to the iterator into the array of stats_task_t.
+ *
+ * @param Always true (continue the walk).
+ *
+ */
+static bool task_serialize_walker(avltree_node_t *node, void *arg)
+{
+        stats_task_t **iterator = (stats_task_t **) arg;
+        task_t *task = avltree_get_instance(node, task_t, tasks_tree_node);
+        
+        /* Interrupts are already disabled */
+        spinlock_lock(&(task->lock));
+        
+        /* Record the statistics and increment the iterator */
+        produce_stats_task(task, *iterator);
+        (*iterator)++;
+        
+        spinlock_unlock(&(task->lock));
+        
+        return true;
+}
+
 /** Get task statistics
+ *
+ * @param item    Sysinfo item (unused).
+ * @param size    Size of the returned data.
+ * @param dry_run Do not get the data, just calculate the size.
+ *
+ * @return Data containing several stats_task_t structures.
+ *         If the return value is not NULL, it should be freed
+ *         in the context of the sysinfo request.
+ */
+static void *get_stats_tasks(struct sysinfo_item *item, size_t *size,
+    bool dry_run)
+{
+        /* Messing with task structures, avoid deadlock */
+        ipl_t ipl = interrupts_disable();
+        spinlock_lock(&tasks_lock);
+        
+        /* First walk the task tree to count the tasks */
+        size_t count = 0;
+        avltree_walk(&tasks_tree, avl_count_walker, (void *) &count);
+        
+        if (count == 0) {
+                /* No tasks found (strange) */
+                spinlock_unlock(&tasks_lock);
+                interrupts_restore(ipl);
+                
+                *size = 0;
+                return NULL;
+        }
+        
+        *size = sizeof(stats_task_t) * count;
+        if (dry_run) {
+                spinlock_unlock(&tasks_lock);
+                interrupts_restore(ipl);
+                return NULL;
+        }
+        
+        stats_task_t *stats_tasks = (stats_task_t *) malloc(*size, FRAME_ATOMIC);
+        if (stats_tasks == NULL) {
+                /* No free space for allocation */
+                spinlock_unlock(&tasks_lock);
+                interrupts_restore(ipl);
+                
+                *size = 0;
+                return NULL;
+        }
+        
+        /* Walk tha task tree again to gather the statistics */
+        stats_task_t *iterator = stats_tasks;
+        avltree_walk(&tasks_tree, task_serialize_walker, (void *) &iterator);
+        
+        spinlock_unlock(&tasks_lock);
+        interrupts_restore(ipl);
+        
+        return ((void *) stats_tasks);
+}
+
+/* Produce thread statistics
+ *
+ * Summarize thread information into thread statistics.
+ * Thread lock should be held and interrupts disabled
+ * before executing this function.
+ *
+ * @param thread       Thread.
+ * @param stats_thread Thread statistics.
+ *
+ */
+static void produce_stats_thread(thread_t *thread, stats_thread_t *stats_thread)
+{
+        stats_thread->thread_id = thread->tid;
+        stats_thread->task_id = thread->task->taskid;
+        stats_thread->state = thread->state;
+        stats_thread->priority = thread->priority;
+        stats_thread->ucycles = thread->ucycles;
+        stats_thread->kcycles = thread->kcycles;
+        
+        if (thread->cpu != NULL) {
+                stats_thread->on_cpu = true;
+                stats_thread->cpu = thread->cpu->id;
+        } else
+                stats_thread->on_cpu = false;
+}
+
+/** Gather statistics of all threads
+ *
+ * AVL three tree walker for gathering thread statistics. Interrupts should
+ * be already disabled while walking the tree.
+ *
+ * @param node AVL thread tree node.
+ * @param arg  Pointer to the iterator into the array of thread statistics.
+ *
+ * @param Always true (continue the walk).
+ *
+ */
+static bool thread_serialize_walker(avltree_node_t *node, void *arg)
+{
+        stats_thread_t **iterator = (stats_thread_t **) arg;
+        thread_t *thread = avltree_get_instance(node, thread_t, threads_tree_node);
+        
+        /* Interrupts are already disabled */
+        spinlock_lock(&(thread->lock));
+        
+        /* Record the statistics and increment the iterator */
+        produce_stats_thread(thread, *iterator);
+        (*iterator)++;
+        
+        spinlock_unlock(&(thread->lock));
+        
+        return true;
+}
+
+/** Get thread statistics
+ *
+ * @param item    Sysinfo item (unused).
+ * @param size    Size of the returned data.
+ * @param dry_run Do not get the data, just calculate the size.
+ *
+ * @return Data containing several stats_task_t structures.
+ *         If the return value is not NULL, it should be freed
+ *         in the context of the sysinfo request.
+ */
+static void *get_stats_threads(struct sysinfo_item *item, size_t *size,
+    bool dry_run)
+{
+        /* Messing with threads structures, avoid deadlock */
+        ipl_t ipl = interrupts_disable();
+        spinlock_lock(&threads_lock);
+        
+        /* First walk the thread tree to count the threads */
+        size_t count = 0;
+        avltree_walk(&threads_tree, avl_count_walker, (void *) &count);
+        
+        if (count == 0) {
+                /* No threads found (strange) */
+                spinlock_unlock(&threads_lock);
+                interrupts_restore(ipl);
+                
+                *size = 0;
+                return NULL;
+        }
+        
+        *size = sizeof(stats_thread_t) * count;
+        if (dry_run) {
+                spinlock_unlock(&threads_lock);
+                interrupts_restore(ipl);
+                return NULL;
+        }
+        
+        stats_thread_t *stats_threads = (stats_thread_t *) malloc(*size, FRAME_ATOMIC);
+        if (stats_threads == NULL) {
+                /* No free space for allocation */
+                spinlock_unlock(&threads_lock);
+                interrupts_restore(ipl);
+                
+                *size = 0;
+                return NULL;
+        }
+        
+        /* Walk tha thread tree again to gather the statistics */
+        stats_thread_t *iterator = stats_threads;
+        avltree_walk(&threads_tree, thread_serialize_walker, (void *) &iterator);
+        
+        spinlock_unlock(&threads_lock);
+        interrupts_restore(ipl);
+        
+        return ((void *) stats_threads);
+}
+
+/** Get a single task statistics
  *
  * Get statistics of a given task. The task ID is passed
@@ -416 +463 @@
                 spinlock_unlock(&tasks_lock);
                 
-                /* Copy task's statistics */
-                str_cpy(stats_task->name, TASK_NAME_BUFLEN, task->name);
-                stats_task->virtmem = get_task_virtmem(task->as);
-                stats_task->threads = atomic_get(&task->refcount);
-                task_get_accounting(task, &(stats_task->ucycles),
-                    &(stats_task->kcycles));
-                stats_task->ipc_info = task->ipc_info;
+                produce_stats_task(task, stats_task);
                 
                 spinlock_unlock(&task->lock);
@@ -492 +533 @@
                 ret.data.data = (void *) stats_thread;
                 ret.data.size = sizeof(stats_thread_t);
-        
+                
                 /* Hand-over-hand locking */
                 spinlock_lock(&thread->lock);
                 spinlock_unlock(&threads_lock);
                 
-                /* Copy thread's statistics */
-                stats_thread->task_id = thread->task->taskid;
-                stats_thread->state = thread->state;
-                stats_thread->priority = thread->priority;
-                stats_thread->ucycles = thread->ucycles;
-                stats_thread->kcycles = thread->kcycles;
-                
-                if (thread->cpu != NULL) {
-                        stats_thread->on_cpu = true;
-                        stats_thread->cpu = thread->cpu->id;
-                } else
-                        stats_thread->on_cpu = false;
+                produce_stats_thread(thread, stats_thread);
                 
                 spinlock_unlock(&thread->lock);

uspace/app/tasks/tasks.c

@@ -59 +59 @@
 {
         size_t count;
-        task_id_t *ids =
-            (task_id_t *) stats_get_tasks(&count);
-        
-        if (ids == NULL) {
+        stats_task_t *stats_tasks = stats_get_tasks(&count);
+        
+        if (stats_tasks == NULL) {
                 fprintf(stderr, "%s: Unable to get tasks\n", NAME);
                 return;
@@ -71 +70 @@
         size_t i;
         for (i = 0; i < count; i++) {
-                stats_task_t *stats_task = stats_get_task(ids[i]);
-                if (stats_task != NULL) {
-                        uint64_t virtmem, ucycles, kcycles;
-                        char vmsuffix, usuffix, ksuffix;
-                        
-                        order_suffix(stats_task->virtmem, &virtmem, &vmsuffix);
-                        order_suffix(stats_task->ucycles, &ucycles, &usuffix);
-                        order_suffix(stats_task->kcycles, &kcycles, &ksuffix);
-                        
-                        printf("%8" PRIu64 "%8u %8" PRIu64"%c %12"
-                            PRIu64 "%c %12" PRIu64 "%c %s\n", ids[i], stats_task->threads,
-                            virtmem, vmsuffix, ucycles, usuffix, kcycles, ksuffix,
-                            stats_task->name);
-                        
-                        free(stats_task);
-                } else
-                        printf("%8" PRIu64 "\n", ids[i]);
-        }
-        
-        free(ids);
+                uint64_t virtmem, ucycles, kcycles;
+                char vmsuffix, usuffix, ksuffix;
+                
+                order_suffix(stats_tasks[i].virtmem, &virtmem, &vmsuffix);
+                order_suffix(stats_tasks[i].ucycles, &ucycles, &usuffix);
+                order_suffix(stats_tasks[i].kcycles, &kcycles, &ksuffix);
+                
+                printf("%8" PRIu64 "%8u %8" PRIu64"%c %12"
+                    PRIu64 "%c %12" PRIu64 "%c %s\n", stats_tasks[i].task_id,
+                    stats_tasks[i].threads, virtmem, vmsuffix, ucycles, usuffix,
+                    kcycles, ksuffix, stats_tasks[i].name);
+        }
+        
+        free(stats_tasks);
 }
 
@@ -96 +89 @@
 {
         size_t count;
-        thread_id_t *ids =
-            (thread_id_t *) stats_get_threads(&count);
-        
-        if (ids == NULL) {
+        stats_thread_t *stats_threads = stats_get_threads(&count);
+        
+        if (stats_threads == NULL) {
                 fprintf(stderr, "%s: Unable to get threads\n", NAME);
                 return;
@@ -107 +99 @@
         size_t i;
         for (i = 0; i < count; i++) {
-                stats_thread_t *stats_thread = stats_get_thread(ids[i]);
-                if (stats_thread != NULL) {
-                        if ((all) || (stats_thread->task_id == task_id)) {
-                                uint64_t ucycles, kcycles;
-                                char usuffix, ksuffix;
-                                
-                                order_suffix(stats_thread->ucycles, &ucycles, &usuffix);
-                                order_suffix(stats_thread->kcycles, &kcycles, &ksuffix);
-                                
-                                if (stats_thread->on_cpu) {
-                                        printf("%8" PRIu64 " %-8s %4u %6d %12"
-                                            PRIu64"%c %12" PRIu64"%c\n", ids[i],
-                                            thread_get_state(stats_thread->state),
-                                            stats_thread->cpu, stats_thread->priority,
-                                            ucycles, usuffix, kcycles, ksuffix);
-                                } else {
-                                        printf("%8" PRIu64 " %-8s ---- %6d %12"
-                                            PRIu64"%c %12" PRIu64"%c\n", ids[i],
-                                            thread_get_state(stats_thread->state),
-                                            stats_thread->priority,
-                                            ucycles, usuffix, kcycles, ksuffix);
-                                }
+                if ((all) || (stats_threads[i].task_id == task_id)) {
+                        uint64_t ucycles, kcycles;
+                        char usuffix, ksuffix;
+                        
+                        order_suffix(stats_threads[i].ucycles, &ucycles, &usuffix);
+                        order_suffix(stats_threads[i].kcycles, &kcycles, &ksuffix);
+                        
+                        if (stats_threads[i].on_cpu) {
+                                printf("%8" PRIu64 " %-8s %4u %6d %12"
+                                    PRIu64"%c %12" PRIu64"%c\n", stats_threads[i].thread_id,
+                                    thread_get_state(stats_threads[i].state),
+                                    stats_threads[i].cpu, stats_threads[i].priority,
+                                    ucycles, usuffix, kcycles, ksuffix);
+                        } else {
+                                printf("%8" PRIu64 " %-8s ---- %6d %12"
+                                    PRIu64"%c %12" PRIu64"%c\n", stats_threads[i].thread_id,
+                                    thread_get_state(stats_threads[i].state),
+                                    stats_threads[i].priority,
+                                    ucycles, usuffix, kcycles, ksuffix);
                         }
-                        
-                        free(stats_thread);
-                } else if (all)
-                        printf("%8" PRIu64 "\n", ids[i]);
-        }
-        
-        free(ids);
+                }
+        }
+        
+        free(stats_threads);
 }
 

uspace/app/top/Makefile

@@ -29 +29 @@
 
 USPACE_PREFIX = ../..
-# BINARY = top
+BINARY = top
 
 SOURCES = \
         top.c \
         screen.c \
-        input.c \
-        ps.c
+        input.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/top/screen.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Stanislav Kozina
+ * Copyright (c) 2010 Martin Decky
  * All rights reserved.
  *
@@ -38 +39 @@
 #include <io/console.h>
 #include <vfs/vfs.h>
-#include <load.h>
-#include <kernel/ps/taskinfo.h>
-#include <ps.h>
+#include <stdarg.h>
+#include <stats.h>
+#include <inttypes.h>
 #include "screen.h"
 #include "top.h"
-#include "func.h"
-
-int rows;
-int colls;
-int up_rows;
-
-#define WHITE 0xf0f0f0
-#define BLACK 0x000000
-
-static void print_float(ps_float f, int precision)
-{
-        printf("%2u.", f.upper / f.lower);
-        int i;
-        unsigned int rest = (f.upper % f.lower) * 10;
-        for (i = 0; i < precision; ++i) {
-                printf("%d", rest / f.lower);
-                rest = (rest % f.lower) * 10;
-        }
-}
-
-static void resume_normal(void)
+
+#define WHITE  0xf0f0f0
+#define BLACK  0x000000
+
+static int rows;
+static int colls;
+static int up_rows;
+
+static void print_float(fixed_float ffloat, unsigned int precision)
+{
+        printf("%2" PRIu64 ".", ffloat.upper / ffloat.lower);
+        
+        unsigned int i;
+        uint64_t rest = (ffloat.upper % ffloat.lower) * 10;
+        for (i = 0; i < precision; i++) {
+                printf("%" PRIu64, rest / ffloat.lower);
+                rest = (rest % ffloat.lower) * 10;
+        }
+}
+
+static void screen_resume_normal(void)
 {
         fflush(stdout);
@@ -69 +70 @@
 }
 
+static void screen_moveto(int r, int c)
+{
+        fflush(stdout);
+        console_goto(fphone(stdout), c, r);
+}
+
+static void screen_clear(void)
+{
+        console_clear(fphone(stdout));
+        screen_moveto(0, 0);
+        up_rows = 0;
+        fflush(stdout);
+}
+
 void screen_init(void)
 {
+        console_cursor_visibility(fphone(stdout), 0);
+        screen_resume_normal();
+        screen_clear();
+        
         console_get_size(fphone(stdout), &colls, &rows);
-        up_rows = 0;
-        console_cursor_visibility(fphone(stdout), 0);
-        resume_normal();
-        clear_screen();
-}
-
-void clear_screen(void)
-{
-        console_clear(fphone(stdout));
-        moveto(0, 0);
-        up_rows = 0;
-        fflush(stdout);
-}
-
-void moveto(int r, int c)
-{
-        fflush(stdout);
-        console_goto(fphone(stdout), c, r);
+}
+
+void screen_done(void)
+{
+        screen_resume_normal();
+        screen_clear();
+        console_cursor_visibility(fphone(stdout), 1);
 }
 
 static inline void print_time(data_t *data)
 {
-        printf("%02d:%02d:%02d ", data->hours, data->minutes, data->seconds);
+        printf("%02lu:%02lu:%02lu ", data->hours, data->minutes, data->seconds);
 }
 
 static inline void print_uptime(data_t *data)
 {
-        printf("up %4d days, %02d:%02d:%02d, ", data->uptime_d, data->uptime_h,
-                data->uptime_m, data->uptime_s);
+        printf("up %u days, %02u:%02u:%02u, ", data->udays, data->uhours,
+            data->uminutes, data->useconds);
 }
 
 static inline void print_load(data_t *data)
 {
-        puts("load avarage: ");
-        print_load_fragment(data->load[0], 2);
-        puts(" ");
-        print_load_fragment(data->load[1], 2);
-        puts(" ");
-        print_load_fragment(data->load[2], 2);
-}
-
-static inline void print_taskstat(data_t *data)
-{
-        puts("Tasks: ");
-        printf("%4u total", data->task_count);
-}
-
-static inline void print_threadstat(data_t *data)
-{
+        printf("load avarage: ");
+        
+        size_t i;
+        for (i = 0; i < data->load_count; i++) {
+                stats_print_load_fragment(data->load[i], 2);
+                printf(" ");
+        }
+}
+
+static inline void print_task_summary(data_t *data)
+{
+        printf("tasks: %u total", data->tasks_count);
+}
+
+static inline void print_thread_summary(data_t *data)
+{
+        size_t total = 0;
+        size_t running = 0;
+        size_t ready = 0;
         size_t sleeping = 0;
-        size_t running = 0;
+        size_t lingering = 0;
+        size_t other = 0;
         size_t invalid = 0;
-        size_t other = 0;
-        size_t total = 0;
-        size_t i;
-        for (i = 0; i < data->thread_count; ++i) {
-                ++total;
-                switch (data->thread_infos[i].state) {
-                        case Invalid:
-                        case Lingering:
-                                ++invalid;
-                                break;
-                        case Running:
-                        case Ready:
-                                ++running;
-                                break;
-                        case Sleeping:
-                                ++sleeping;
-                                break;
-                        case Entering:
-                        case Exiting:
-                                ++other;
-                                break;
+        
+        
+        size_t i;
+        for (i = 0; i < data->threads_count; i++) {
+                total++;
+                
+                switch (data->threads[i].state) {
+                case Running:
+                        running++;
+                        break;
+                case Ready:
+                        ready++;
+                        break;
+                case Sleeping:
+                        sleeping++;
+                        break;
+                case Lingering:
+                        lingering++;
+                        break;
+                case Entering:
+                case Exiting:
+                        other++;
+                        break;
+                default:
+                        invalid++;
                 }
         }
-        printf("Threads: %5u total, %5u running, %5u sleeping, %5u invalid, %5u other",
-                total, running, sleeping, invalid, other);
-}
-
-static inline void print_cpuinfo(data_t *data)
-{
-        unsigned int i;
-        uspace_cpu_info_t *cpus = data->cpus;
-        for (i = 0; i < data->cpu_count; ++i) {
-                printf("Cpu%u (%4u Mhz): Busy ticks: %6llu, Idle Ticks: %6llu",
-                        i, (unsigned int)cpus[i].frequency_mhz, cpus[i].busy_ticks,
-                        cpus[i].idle_ticks);
+        
+        printf("threads: %u total, %u running, %u ready, %u sleeping, %u lingering, "
+            "%u other, %u invalid",
+            total, running, ready, sleeping, lingering, other, invalid);
+}
+
+static inline void print_cpu_info(data_t *data)
+{
+        size_t i;
+        for (i = 0; i < data->cpus_count; i++) {
+                printf("cpu%u (%4" PRIu16 " MHz): busy ticks: "
+                    "%" PRIu64 ", idle ticks: %" PRIu64,
+                    data->cpus[i].id, data->cpus[i].frequency_mhz,
+                    data->cpus[i].busy_ticks, data->cpus[i].idle_ticks);
                 printf(", idle: ");
-                print_float(data->cpu_perc[i].idle, 2);
-                puts("%, busy: ");
-                print_float(data->cpu_perc[i].busy, 2);
-                puts("%\n");
-                ++up_rows;
-        }
-}
-
-static inline void print_meminfo(data_t *data)
-{
-        uint64_t newsize;
-        char suffix;
-        order(data->mem_info.total, &newsize, &suffix);
-        printf("Mem: %8llu %c total", newsize, suffix);
-        order(data->mem_info.used, &newsize, &suffix);
-        printf(", %8llu %c used", newsize, suffix);
-        order(data->mem_info.free, &newsize, &suffix);
-        printf(", %8llu %c free", newsize, suffix);
+                print_float(data->cpus_perc[i].idle, 2);
+                printf("%%, busy: ");
+                print_float(data->cpus_perc[i].busy, 2);
+                
+                printf("%%\n");
+                up_rows++;
+        }
+}
+
+static inline void print_physmem_info(data_t *data)
+{
+        uint64_t total;
+        uint64_t unavail;
+        uint64_t used;
+        uint64_t free;
+        char total_suffix;
+        char unavail_suffix;
+        char used_suffix;
+        char free_suffix;
+        
+        order_suffix(data->physmem->total, &total, &total_suffix);
+        order_suffix(data->physmem->unavail, &unavail, &unavail_suffix);
+        order_suffix(data->physmem->used, &used, &used_suffix);
+        order_suffix(data->physmem->free, &free, &free_suffix);
+        
+        printf("memory: %" PRIu64 "%c total, %" PRIu64 "%c unavail, %"
+            PRIu64 "%c used, %" PRIu64 "%c free", total, total_suffix,
+            unavail, unavail_suffix, used, used_suffix, free, free_suffix);
 }
 
 static inline void print_tasks(data_t *data, int row)
 {
-        int i;
-        for (i = 0; i < (int)data->task_count; ++i) {
-                if (row + i > rows)
-                        return;
-                task_info_t *taskinfo = &data->taskinfos[i];
-                uint64_t mem;
-                char suffix;
-                order(taskinfo->virt_mem, &mem, &suffix);
-                printf("%8llu %8u %8llu%c ", taskinfo->taskid,
-                        taskinfo->thread_count, mem, suffix);
-                task_perc_t *taskperc = &data->task_perc[i];
-                puts("   ");
-                print_float(taskperc->mem, 2);
-                puts("%   ");
-                print_float(taskperc->ucycles, 2);
-                puts("%   ");
-                print_float(taskperc->kcycles, 2);
-                puts("% ");
-                printf("%s\n", taskinfo->name);
+        size_t i;
+        for (i = 0; i < data->tasks_count; i++, row++) {
+                if (row > rows)
+                        break;
+                
+                uint64_t virtmem;
+                char virtmem_suffix;
+                order_suffix(data->tasks[i].virtmem, &virtmem, &virtmem_suffix);
+                
+                printf("%8" PRIu64 " %8u %8" PRIu64 "%c ", data->tasks[i].task_id,
+                    data->tasks[i].threads, virtmem, virtmem_suffix);
+                printf("   ");
+                print_float(data->tasks_perc[i].virtmem, 2);
+                printf("%%   ");
+                print_float(data->tasks_perc[i].ucycles, 2);
+                printf("%%   ");
+                print_float(data->tasks_perc[i].kcycles, 2);
+                printf("%% %s\n", data->tasks[i].name);
         }
 }
@@ -208 +235 @@
         fflush(stdout);
         console_set_rgb_color(fphone(stdout), WHITE, BLACK);
+        
         printf("      ID  Threads      Mem      %%Mem %%uCycles %%kCycles  Name");
+        
         int i;
         for (i = 61; i < colls; ++i)
-                puts(" ");
+                printf(" ");
+        
         fflush(stdout);
         console_set_rgb_color(fphone(stdout), BLACK, WHITE);
@@ -220 +250 @@
         fflush(stdout);
         console_set_rgb_color(fphone(stdout), WHITE, BLACK);
+        
         printf("      ID Calls sent Calls recv Answs sent Answs recv  IRQn recv       Forw Name");
+        
         int i;
         for (i = 80; i < colls; ++i)
-                puts(" ");
+                printf(" ");
+        
         fflush(stdout);
         console_set_rgb_color(fphone(stdout), BLACK, WHITE);
@@ -230 +263 @@
 static inline void print_ipc(data_t *data, int row)
 {
-        int i;
-        for (i = 0; i < (int)data->task_count; ++i) {
-                if (row + i > rows)
-                        return;
-                task_info_t *taskinfo = &data->taskinfos[i];
-                task_ipc_info_t *ipcinfo = &taskinfo->ipc_info;
-                printf("%8llu ", taskinfo->taskid);
-                printf("%10llu %10llu %10llu %10llu %10llu %10llu ",
-                                ipcinfo->call_sent, ipcinfo->call_recieved,
-                                ipcinfo->answer_sent, ipcinfo->answer_recieved,
-                                ipcinfo->irq_notif_recieved, ipcinfo->forwarded);
-                printf("%s\n", taskinfo->name);
+        size_t i;
+        for (i = 0; i < data->tasks_count; i++, row++) {
+                if (row > rows)
+                        break;
+                
+                printf("%8" PRIu64 " %10" PRIu64 " %10" PRIu64 " %10" PRIu64
+                     " %10" PRIu64 " %10" PRIu64 " %10" PRIu64 " %s\n",
+                     data->tasks[i].task_id, data->tasks[i].ipc_info.call_sent,
+                     data->tasks[i].ipc_info.call_recieved,
+                     data->tasks[i].ipc_info.answer_sent,
+                     data->tasks[i].ipc_info.answer_recieved,
+                     data->tasks[i].ipc_info.irq_notif_recieved,
+                     data->tasks[i].ipc_info.forwarded, data->tasks[i].name);
         }
 }
@@ -247 +281 @@
 void print_data(data_t *data)
 {
-        clear_screen();
-        fflush(stdout);
+        screen_clear();
+        fflush(stdout);
+        
         printf("top - ");
         print_time(data);
         print_uptime(data);
         print_load(data);
-        puts("\n");
-        ++up_rows;
-        print_taskstat(data);
-        puts("\n");
-        ++up_rows;
-        print_threadstat(data);
-        puts("\n");
-        ++up_rows;
-        print_cpuinfo(data);
-        print_meminfo(data);
-        puts("\n");
-        ++up_rows;
-        puts("\n");
-        ++up_rows;
+        
+        printf("\n");
+        up_rows++;
+        
+        print_task_summary(data);
+        
+        printf("\n");
+        up_rows++;
+        
+        print_thread_summary(data);
+        
+        printf("\n");
+        up_rows++;
+        
+        print_cpu_info(data);
+        print_physmem_info(data);
+        
+        printf("\n");
+        up_rows++;
+        
+        /* Empty row for warnings */
+        printf("\n");
+        
         if (operation_type == OP_IPC) {
                 print_ipc_head();
-                puts("\n");
+                printf("\n");
                 print_ipc(data, up_rows);
         } else {
                 print_task_head();
-                puts("\n");
+                printf("\n");
                 print_tasks(data, up_rows);
         }
+        
+        fflush(stdout);
+}
+
+void print_warning(const char *fmt, ...)
+{
+        screen_moveto(up_rows, 0);
+        
+        va_list args;
+        va_start(args, fmt);
+        vprintf(fmt, args);
+        va_end(args);
+        
         fflush(stdout);
 }

uspace/app/top/screen.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2008 Stanislav Kozina
+ * Copyright (c) 2010 Stanislav Kozina
+ * Copyright (c) 2010 Martin Decky
  * All rights reserved.
  *
@@ -36 +37 @@
 #include "top.h"
 
-extern int rows;
-extern int colls;
-
 extern void screen_init(void);
-extern void clear_screen(void);
-extern void moveto(int r, int c);
-extern void print_data(data_t *data);
-
-extern int up_rows;
-#define PRINT_WARNING(message, ...) \
-do { \
-        moveto(up_rows - 1, 0); \
-        printf(message, ##__VA_ARGS__); \
-        fflush(stdout); \
-} while (0)
+extern void screen_done(void);
+extern void print_data(data_t *);
+extern void print_warning(const char *, ...);
 
 #endif

uspace/app/top/top.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Stanislav Kozina
+ * Copyright (c) 2010 Martin Decky
  * All rights reserved.
  *
@@ -38 +39 @@
 #include <stdlib.h>
 #include <unistd.h>
-#include <uptime.h>
 #include <task.h>
 #include <thread.h>
 #include <sys/time.h>
-#include <load.h>
-#include <ps.h>
 #include <arch/barrier.h>
+#include <errno.h>
 #include "screen.h"
 #include "input.h"
 #include "top.h"
-#include "ps.h"
-
-#define UPDATE_INTERVAL 1
-
-#define DAY 86400
-#define HOUR 3600
-#define MINUTE 60
+
+#define NAME  "top"
+
+#define UPDATE_INTERVAL  1
+
+#define DAY     86400
+#define HOUR    3600
+#define MINUTE  60
 
 int operation_type;
 
-static void read_data(data_t *target)
+static const char *read_data(data_t *target)
 {
-        /* Read current time */
+        /* Initialize data */
+        target->load = NULL;
+        target->cpus = NULL;
+        target->cpus_perc = NULL;
+        target->tasks = NULL;
+        target->tasks_perc = NULL;
+        target->threads = NULL;
+        target->physmem = NULL;
+        
+        /* Get current time */
         struct timeval time;
-        if (gettimeofday(&time, NULL) != 0) {
-                printf("Cannot get time of day!\n");
-                exit(1);
-        }
+        if (gettimeofday(&time, NULL) != EOK)
+                return "Cannot get time of day";
+        
         target->hours = (time.tv_sec % DAY) / HOUR;
         target->minutes = (time.tv_sec % HOUR) / MINUTE;
         target->seconds = time.tv_sec % MINUTE;
-
-        /* Read uptime */
-        uint64_t uptime;
-        get_uptime(&uptime);
-        target->uptime_d = uptime / DAY;
-        target->uptime_h = (uptime % DAY) / HOUR;
-        target->uptime_m = (uptime % HOUR) / MINUTE;
-        target->uptime_s = uptime % MINUTE;
-
-        /* Read load */
-        get_load(target->load);
-
-        /* Read task ids */
-        target->task_count = get_tasks(&target->taskinfos);
-
-        /* Read all threads */
-        target->thread_count = get_threads(&target->thread_infos);
-
-        /* Read cpu infos */
-        target->cpu_count = get_cpu_infos(&target->cpus);
-
-        /* Read mem info */
-        get_mem_info(&target->mem_info);
+        
+        /* Get uptime */
+        sysarg_t uptime = stats_get_uptime();
+        target->udays = uptime / DAY;
+        target->uhours = (uptime % DAY) / HOUR;
+        target->uminutes = (uptime % HOUR) / MINUTE;
+        target->useconds = uptime % MINUTE;
+        
+        /* Get load */
+        target->load = stats_get_load(&(target->load_count));
+        if (target->load == NULL)
+                return "Cannot get system load";
+        
+        /* Get CPUs */
+        target->cpus = stats_get_cpus(&(target->cpus_count));
+        if (target->cpus == NULL)
+                return "Cannot get CPUs";
+        
+        target->cpus_perc =
+            (perc_cpu_t *) calloc(target->cpus_count, sizeof(perc_cpu_t));
+        if (target->cpus_perc == NULL)
+                return "Not enough memory for CPU utilization";
+        
+        /* Get tasks */
+        target->tasks = stats_get_tasks(&(target->tasks_count));
+        if (target->tasks == NULL)
+                return "Cannot get tasks";
+        
+        target->tasks_perc =
+            (perc_task_t *) calloc(target->tasks_count, sizeof(perc_task_t));
+        if (target->tasks_perc == NULL)
+                return "Not enough memory for task utilization";
+        
+        /* Get threads */
+        target->threads = stats_get_threads(&(target->threads_count));
+        if (target->threads == NULL)
+                return "Cannot get threads";
+        
+        /* Get physical memory */
+        target->physmem = stats_get_physmem();
+        if (target->physmem == NULL)
+                return "Cannot get physical memory";
+        
+        return NULL;
 }
 
 /** Computes percentage differencies from old_data to new_data
  *
- * @param old_data      Pointer to old data strucutre.
- * @param new_data      Pointer to actual data where percetages are stored.
- *
- */
-static void compute_percentages(data_t *old_data, data_t *new_data)
+ * @param old_data Pointer to old data strucutre.
+ * @param new_data Pointer to actual data where percetages are stored.
+ *
+ */
+static const char *compute_percentages(data_t *old_data, data_t *new_data)
 {
-        /* Foreach cpu, compute total ticks and divide it between user and
-         * system */
-        unsigned int i;
-        new_data->cpu_perc = malloc(new_data->cpu_count * sizeof(cpu_perc_t));
-        for (i = 0; i < new_data->cpu_count; ++i) {
-                uint64_t idle = new_data->cpus[i].idle_ticks - old_data->cpus[i].idle_ticks;
-                uint64_t busy = new_data->cpus[i].busy_ticks - old_data->cpus[i].busy_ticks;
+        /* Allocate memory */
+        
+        uint64_t *ucycles_diff = calloc(new_data->tasks_count, sizeof(uint64_t));
+        if (ucycles_diff == NULL)
+                return "Not enough memory for user utilization";
+        
+        uint64_t *kcycles_diff = calloc(new_data->tasks_count, sizeof(uint64_t));
+        if (kcycles_diff == NULL) {
+                free(ucycles_diff);
+                return "Not enough memory for kernel utilization";
+        }
+        
+        /* For each CPU: Compute total ticks and divide it between
+           user and kernel */
+        
+        size_t i;
+        for (i = 0; i < new_data->cpus_count; i++) {
+                uint64_t idle =
+                    new_data->cpus[i].idle_ticks - old_data->cpus[i].idle_ticks;
+                uint64_t busy =
+                    new_data->cpus[i].busy_ticks - old_data->cpus[i].busy_ticks;
                 uint64_t sum = idle + busy;
-                FRACTION_TO_FLOAT(new_data->cpu_perc[i].idle, idle * 100, sum);
-                FRACTION_TO_FLOAT(new_data->cpu_perc[i].busy, busy * 100, sum);
-        }
-
+                
+                FRACTION_TO_FLOAT(new_data->cpus_perc[i].idle, idle * 100, sum);
+                FRACTION_TO_FLOAT(new_data->cpus_perc[i].busy, busy * 100, sum);
+        }
+        
         /* For all tasks compute sum and differencies of all cycles */
-        uint64_t mem_total = 1; /*< Must NOT be null! */
-        uint64_t ucycles_total = 1; /*< Must NOT be null! */
-        uint64_t kcycles_total = 1; /*< Must NOT be null! */
-        uint64_t *ucycles_diff = malloc(new_data->task_count * sizeof(uint64_t));
-        uint64_t *kcycles_diff = malloc(new_data->task_count * sizeof(uint64_t));
-        unsigned int j = 0;
-        for (i = 0; i < new_data->task_count; ++i) {
-                /* Jump over all death tasks */
-                while (old_data->taskinfos[j].taskid < new_data->taskinfos[i].taskid)
-                        ++j;
-                if (old_data->taskinfos[j].taskid > new_data->taskinfos[i].taskid) {
+        
+        uint64_t virtmem_total = 1;  /* Must NOT be zero */
+        uint64_t ucycles_total = 1;  /* Must NOT be zero */
+        uint64_t kcycles_total = 1;  /* Must NOT be zero */
+        
+        for (i = 0; i < new_data->tasks_count; i++) {
+                /* Match task with the previous instance */
+                
+                bool found = false;
+                size_t j;
+                for (j = 0; j < old_data->tasks_count; j++) {
+                        if (new_data->tasks[i].task_id == old_data->tasks[j].task_id) {
+                                found = true;
+                                break;
+                        }
+                }
+                
+                if (!found) {
                         /* This is newly borned task, ignore it */
                         ucycles_diff[i] = 0;
@@ -131 +182 @@
                         continue;
                 }
-                /* Now we now we have task with same id */
-                ucycles_diff[i] = new_data->taskinfos[i].ucycles - old_data->taskinfos[j].ucycles;
-                kcycles_diff[i] = new_data->taskinfos[i].kcycles - old_data->taskinfos[j].kcycles;
-
-                mem_total += new_data->taskinfos[i].virt_mem;
+                
+                ucycles_diff[i] =
+                    new_data->tasks[i].ucycles - old_data->tasks[j].ucycles;
+                kcycles_diff[i] =
+                    new_data->tasks[i].kcycles - old_data->tasks[j].kcycles;
+                
+                virtmem_total += new_data->tasks[i].virtmem;
                 ucycles_total += ucycles_diff[i];
                 kcycles_total += kcycles_diff[i];
         }
-
-        /* And now compute percental change */
-        new_data->task_perc = malloc(new_data->task_count * sizeof(task_perc_t));
-        for (i = 0; i < new_data->task_count; ++i) {
-                FRACTION_TO_FLOAT(new_data->task_perc[i].mem, new_data->taskinfos[i].virt_mem * 100, mem_total);
-                FRACTION_TO_FLOAT(new_data->task_perc[i].ucycles, ucycles_diff[i] * 100, ucycles_total);
-                FRACTION_TO_FLOAT(new_data->task_perc[i].kcycles, kcycles_diff[i] * 100, kcycles_total);
-        }
-
-        /* Wait until coprocessor finishes its work */
-        write_barrier();
-
-        /* And free temporary structures */
+        
+        /* For each task: Compute percential change */
+        
+        for (i = 0; i < new_data->tasks_count; i++) {
+                FRACTION_TO_FLOAT(new_data->tasks_perc[i].virtmem,
+                    new_data->tasks[i].virtmem * 100, virtmem_total);
+                FRACTION_TO_FLOAT(new_data->tasks_perc[i].ucycles,
+                    ucycles_diff[i] * 100, ucycles_total);
+                FRACTION_TO_FLOAT(new_data->tasks_perc[i].kcycles,
+                    kcycles_diff[i] * 100, kcycles_total);
+        }
+        
+        /* Cleanup */
+        
         free(ucycles_diff);
         free(kcycles_diff);
+        
+        return NULL;
 }
 
 static void free_data(data_t *target)
 {
-        free(target->taskinfos);
-        free(target->thread_infos);
-        free(target->cpus);
-        free(target->cpu_perc);
-        free(target->task_perc);
+        if (target->load != NULL)
+                free(target->load);
+        
+        if (target->cpus != NULL)
+                free(target->cpus);
+        
+        if (target->cpus_perc != NULL)
+                free(target->cpus_perc);
+        
+        if (target->tasks != NULL)
+                free(target->tasks);
+        
+        if (target->tasks_perc != NULL)
+                free(target->tasks_perc);
+        
+        if (target->threads != NULL)
+                free(target->threads);
+        
+        if (target->physmem != NULL)
+                free(target->physmem);
 }
-
-static inline void swap(data_t **first, data_t **second)
-{
-        data_t *temp;
-        temp = *first;
-        *first = *second;
-        *second = temp;
-}
-
-static data_t data[2];
 
 int main(int argc, char *argv[])
 {
-        data_t *data1 = &data[0];
-        data_t *data2 = &data[1];
+        data_t data;
+        data_t data_prev;
+        const char *ret = NULL;
+        
         screen_init();
-
-        /* Read initial stats */
         printf("Reading initial data...\n");
-        read_data(data1);
+        
+        if ((ret = read_data(&data_prev)) != NULL)
+                goto out;
+        
         /* Compute some rubbish to have initialised values */
-        compute_percentages(data1, data1);
-
-        /* And paint screen until death... */
+        if ((ret = compute_percentages(&data_prev, &data_prev)) != NULL)
+                goto out;
+        
+        /* And paint screen until death */
         operation_type = OP_TASKS;
         while (true) {
                 char c = tgetchar(UPDATE_INTERVAL);
                 if (c < 0) {
-                        read_data(data2);
-                        compute_percentages(data1, data2);
-                        free_data(data1);
-                        print_data(data2);
-                        swap(&data1, &data2);
+                        if ((ret = read_data(&data)) != NULL) {
+                                free_data(&data);
+                                goto out;
+                        }
+                        
+                        if ((ret = compute_percentages(&data_prev, &data)) != NULL) {
+                                free_data(&data);
+                                goto out;
+                        }
+                        
+                        print_data(&data);
+                        free_data(&data_prev);
+                        data_prev = data;
+                        
                         continue;
                 }
+                
                 switch (c) {
                         case 'q':
-                                clear_screen();
-                                return 0;
+                                goto out;
                         case 'i':
-                                PRINT_WARNING("Showing IPC statistics", c);
+                                print_warning("Showing IPC statistics");
                                 operation_type = OP_IPC;
                                 break;
                         case 't':
-                                PRINT_WARNING("Showing task stats", c);
+                                print_warning("Showing task statistics");
                                 operation_type = OP_TASKS;
                                 break;
                         default:
-                                PRINT_WARNING("Unknown command: %c", c);
+                                print_warning("Unknown command: %c", c);
                                 break;
                 }
-
-        }
-
-        free_data(data1);
-        free_data(data2);
+        }
+        
+out:
+        screen_done();
+        free_data(&data_prev);
+        
+        if (ret != NULL) {
+                fprintf(stderr, "%s: %s\n", NAME, ret);
+                return 1;
+        }
+        
         return 0;
 }

uspace/app/top/top.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2008 Stanislav Kozina
+ * Copyright (c) 2010 Stanislav Kozina
+ * Copyright (c) 2010 Martin Decky
  * All rights reserved.
  *
@@ -35 +36 @@
 
 #include <task.h>
-#include <kernel/ps/cpuinfo.h>
-#include <kernel/ps/taskinfo.h>
+#include <stats.h>
+#include <time.h>
 
 #define FRACTION_TO_FLOAT(float, a, b) { \
@@ -43 +44 @@
 }
 
-#define OP_TASKS 1
-#define OP_IPC 2
+#define OP_TASKS  1
+#define OP_IPC    2
+
 extern int operation_type;
 
@@ -50 +52 @@
         uint64_t upper;
         uint64_t lower;
-} ps_float;
+} fixed_float;
 
 typedef struct {
-        ps_float idle;
-        ps_float busy;
-} cpu_perc_t;
+        fixed_float idle;
+        fixed_float busy;
+} perc_cpu_t;
 
 typedef struct {
-        ps_float ucycles;
-        ps_float kcycles;
-        ps_float mem;
-} task_perc_t;
+        fixed_float ucycles;
+        fixed_float kcycles;
+        fixed_float virtmem;
+} perc_task_t;
 
 typedef struct {
-        unsigned int hours;
-        unsigned int minutes;
-        unsigned int seconds;
-
-        unsigned int uptime_d;
-        unsigned int uptime_h;
-        unsigned int uptime_m;
-        unsigned int uptime_s;
-
-        unsigned long load[3];
-
-        size_t task_count;
-        task_info_t *taskinfos;
-        task_perc_t *task_perc;
-
-        size_t thread_count;
-        thread_info_t *thread_infos;
-
-        unsigned int cpu_count;
-        uspace_cpu_info_t *cpus;
-        cpu_perc_t *cpu_perc;
-
-        uspace_mem_info_t mem_info;
+        time_t hours;
+        time_t minutes;
+        time_t seconds;
+        
+        sysarg_t udays;
+        sysarg_t uhours;
+        sysarg_t uminutes;
+        sysarg_t useconds;
+        
+        size_t load_count;
+        load_t *load;
+        
+        size_t cpus_count;
+        stats_cpu_t *cpus;
+        perc_cpu_t *cpus_perc;
+        
+        size_t tasks_count;
+        stats_task_t *tasks;
+        perc_task_t *tasks_perc;
+        
+        size_t threads_count;
+        stats_thread_t *threads;
+        
+        stats_physmem_t *physmem;
 } data_t;
 

uspace/lib/c/generic/stats.c

@@ -96 +96 @@
 }
 
-/** Get task IDs
- *
- * @param count Number of IDs returned.
- *
- * @return Array of IDs (task_id_t).
- *         If non-NULL then it should be eventually freed
- *         by free().
- *
- */
-task_id_t *stats_get_tasks(size_t *count)
-{
-        size_t size = 0;
-        task_id_t *ids =
-            (task_id_t *) sysinfo_get_data("system.tasks", &size);
-        
-        assert((size % sizeof(task_id_t)) == 0);
-        
-        *count = size / sizeof(task_id_t);
-        return ids;
+/** Get task statistics
+ *
+ * @param count Number of records returned.
+ *
+ * @return Array of stats_task_t structures.
+ *         If non-NULL then it should be eventually freed
+ *         by free().
+ *
+ */
+stats_task_t *stats_get_tasks(size_t *count)
+{
+        size_t size = 0;
+        stats_task_t *stats_tasks =
+            (stats_task_t *) sysinfo_get_data("system.tasks", &size);
+        
+        assert((size % sizeof(stats_task_t)) == 0);
+        
+        *count = size / sizeof(stats_task_t);
+        return stats_tasks;
 }
 
@@ -140 +140 @@
 }
 
-/** Get thread IDs
- *
- * @param count Number of IDs returned.
- *
- * @return Array of IDs (thread_id_t).
- *         If non-NULL then it should be eventually freed
- *         by free().
- *
- */
-thread_id_t *stats_get_threads(size_t *count)
-{
-        size_t size = 0;
-        thread_id_t *ids =
-            (thread_id_t *) sysinfo_get_data("system.threads", &size);
-        
-        assert((size % sizeof(thread_id_t)) == 0);
-        
-        *count = size / sizeof(thread_id_t);
-        return ids;
+/** Get thread statistics.
+ *
+ * @param count Number of records returned.
+ *
+ * @return Array of stats_thread_t structures.
+ *         If non-NULL then it should be eventually freed
+ *         by free().
+ *
+ */
+stats_thread_t *stats_get_threads(size_t *count)
+{
+        size_t size = 0;
+        stats_thread_t *stats_threads =
+            (stats_thread_t *) sysinfo_get_data("system.threads", &size);
+        
+        assert((size % sizeof(stats_thread_t)) == 0);
+        
+        *count = size / sizeof(stats_thread_t);
+        return stats_threads;
 }
 

uspace/lib/c/include/stats.h

@@ -47 +47 @@
 extern sysarg_t stats_get_uptime(void);
 
-extern task_id_t *stats_get_tasks(size_t *);
+extern stats_task_t *stats_get_tasks(size_t *);
 extern stats_task_t *stats_get_task(task_id_t);
 
-extern thread_id_t *stats_get_threads(size_t *);
+extern stats_thread_t *stats_get_threads(size_t *);
 extern stats_thread_t *stats_get_thread(thread_id_t);