Changeset f579760 in mainline

Timestamp:

2011-01-27T19:39:54Z (14 years ago)

Author:

Martin Decky <martin@…>

Branches:

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

Children:

ae0300b5

Parents:

875c629 (diff), caa8a94 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

• merge "tasks" and "stats" tools into one binary
• improve the printouts of various tools and kernel console commands

Files:

• boot/Makefile.common (modified) (1 diff)
• kernel/generic/include/ipc/ipc.h (modified) (2 diffs)
• kernel/generic/src/ipc/ipc.c (modified) (3 diffs)
• kernel/generic/src/proc/task.c (modified) (1 diff)
• kernel/generic/src/proc/thread.c (modified) (3 diffs)
• uspace/Makefile (modified) (1 diff)
• uspace/app/stats/stats.c (modified) (3 diffs)
• uspace/app/tasks/Makefile (deleted)
• uspace/app/tasks/tasks.c (deleted)
• uspace/app/top/screen.c (modified) (2 diffs)

boot/Makefile.common

@@ -139 +139 @@
         $(USPACE_PATH)/app/ping/ping \
         $(USPACE_PATH)/app/stats/stats \
-        $(USPACE_PATH)/app/tasks/tasks \
         $(USPACE_PATH)/app/top/top \
         $(USPACE_PATH)/app/sysinfo/sysinfo \

kernel/generic/include/ipc/ipc.h

@@ -338 +338 @@
          * The caller box is different from sender->answerbox
          * for synchronous calls.
-         *
          */
         answerbox_t *callerbox;
@@ -355 +354 @@
          * cases, we must keep it aside so that the answer is processed
          * correctly.
-         *
          */
         phone_t *caller_phone;

kernel/generic/src/ipc/ipc.c

@@ -690 +690 @@
         irq_spinlock_exchange(&tasks_lock, &task->lock);
         
-        /* Print opened phones & details */
-        printf("PHONE:\n");
+        printf("[phone id] [calls] [state\n");
         
         size_t i;
         for (i = 0; i < IPC_MAX_PHONES; i++) {
                 if (SYNCH_FAILED(mutex_trylock(&task->phones[i].lock))) {
-                        printf("%zu: mutex busy\n", i);
+                        printf("%-10zu (mutex busy)\n", i);
                         continue;
                 }
                 
                 if (task->phones[i].state != IPC_PHONE_FREE) {
-                        printf("%zu: ", i);
+                        printf("%-10zu %7" PRIun " ", i,
+                            atomic_get(&task->phones[i].active_calls));
                         
                         switch (task->phones[i].state) {
                         case IPC_PHONE_CONNECTING:
-                                printf("connecting ");
+                                printf("connecting");
                                 break;
                         case IPC_PHONE_CONNECTED:
-                                printf("connected to: %p (%" PRIu64 ") ",
-                                    task->phones[i].callee,
-                                    task->phones[i].callee->task->taskid);
+                                printf("connected to %" PRIu64 " (%s)",
+                                    task->phones[i].callee->task->taskid,
+                                    task->phones[i].callee->task->name);
                                 break;
                         case IPC_PHONE_SLAMMED:
-                                printf("slammed by: %p ", 
+                                printf("slammed by %p",
                                     task->phones[i].callee);
                                 break;
                         case IPC_PHONE_HUNGUP:
-                                printf("hung up - was: %p ", 
+                                printf("hung up by %p",
                                     task->phones[i].callee);
                                 break;
@@ -724 +724 @@
                         }
                         
-                        printf("active: %" PRIun "\n",
-                            atomic_get(&task->phones[i].active_calls));
+                        printf("\n");
                 }
                 
@@ -733 +732 @@
         irq_spinlock_lock(&task->answerbox.lock, false);
         
+#ifdef __32_BITS__
+        printf("[call id ] [method] [arg1] [arg2] [arg3] [arg4] [arg5]"
+            " [flags] [sender\n");
+#endif
+        
+#ifdef __64_BITS__
+        printf("[call id         ] [method] [arg1] [arg2] [arg3] [arg4]"
+            " [arg5] [flags] [sender\n");
+#endif
+        
         link_t *cur;
         
-        /* Print answerbox - calls */
-        printf("ABOX - CALLS:\n");
+        printf(" --- incomming calls ---\n");
         for (cur = task->answerbox.calls.next; cur != &task->answerbox.calls;
             cur = cur->next) {
                 call_t *call = list_get_instance(cur, call_t, link);
-                printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun 
-                    " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
-                    " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
-                    call->sender->taskid,
+                
+#ifdef __32_BITS__
+                printf("%10p ", call);
+#endif
+                
+#ifdef __64_BITS__
+                printf("%18p ", call);
+#endif
+                
+                printf("%-8" PRIun " %-6" PRIun " %-6" PRIun " %-6" PRIun
+                    " %-6" PRIun " %-6" PRIun " %-7x %" PRIu64 " (%s)\n",
                     IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data),
                     IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
                     IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
-                    call->flags);
-        }
-        
-        /* Print answerbox - dispatched calls */
-        printf("ABOX - DISPATCHED CALLS:\n");
+                    call->flags, call->sender->taskid, call->sender->name);
+        }
+        
+        printf(" --- dispatched calls ---\n");
         for (cur = task->answerbox.dispatched_calls.next;
             cur != &task->answerbox.dispatched_calls;
             cur = cur->next) {
                 call_t *call = list_get_instance(cur, call_t, link);
-                printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun
-                    " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
-                    " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
-                    call->sender->taskid,
+                
+#ifdef __32_BITS__
+                printf("%10p ", call);
+#endif
+                
+#ifdef __64_BITS__
+                printf("%18p ", call);
+#endif
+                
+                printf("%-8" PRIun " %-6" PRIun " %-6" PRIun " %-6" PRIun
+                    " %-6" PRIun " %-6" PRIun " %-7x %" PRIu64 " (%s)\n",
                     IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data),
                     IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
                     IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
-                    call->flags);
-        }
-        
-        /* Print answerbox - answers */
-        printf("ABOX - ANSWERS:\n");
+                    call->flags, call->sender->taskid, call->sender->name);
+        }
+        
+        printf(" --- outgoing answers ---\n");
         for (cur = task->answerbox.answers.next;
             cur != &task->answerbox.answers;
             cur = cur->next) {
                 call_t *call = list_get_instance(cur, call_t, link);
-                printf("Callid:%p M:%" PRIun " A1:%" PRIun " A2:%" PRIun
-                    " A3:%" PRIun " A4:%" PRIun " A5:%" PRIun " Flags:%x\n",
-                    call, IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data),
+                
+#ifdef __32_BITS__
+                printf("%10p ", call);
+#endif
+                
+#ifdef __64_BITS__
+                printf("%18p ", call);
+#endif
+                
+                printf("%-8" PRIun " %-6" PRIun " %-6" PRIun " %-6" PRIun
+                    " %-6" PRIun " %-6" PRIun " %-7x %" PRIu64 " (%s)\n",
+                    IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data),
                     IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
                     IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
-                    call->flags);
+                    call->flags, call->sender->taskid, call->sender->name);
         }
         

kernel/generic/src/proc/task.c

@@ -342 +342 @@
 sysarg_t sys_task_set_name(const char *uspace_name, size_t name_len)
 {
-        int rc;
         char namebuf[TASK_NAME_BUFLEN];
         
         /* Cap length of name and copy it from userspace. */
-        
         if (name_len > TASK_NAME_BUFLEN - 1)
                 name_len = TASK_NAME_BUFLEN - 1;
         
-        rc = copy_from_uspace(namebuf, uspace_name, name_len);
+        int rc = copy_from_uspace(namebuf, uspace_name, name_len);
         if (rc != 0)
                 return (sysarg_t) rc;
         
         namebuf[name_len] = '\0';
+        
+        /*
+         * As the task name is referenced also from the
+         * threads, lock the threads' lock for the course
+         * of the update.
+         */
+        
+        irq_spinlock_lock(&tasks_lock, true);
+        irq_spinlock_lock(&TASK->lock, false);
+        irq_spinlock_lock(&threads_lock, false);
+        
+        /* Set task name */
         str_cpy(TASK->name, TASK_NAME_BUFLEN, namebuf);
+        
+        irq_spinlock_unlock(&threads_lock, false);
+        irq_spinlock_unlock(&TASK->lock, false);
+        irq_spinlock_unlock(&tasks_lock, true);
         
         return EOK;

kernel/generic/src/proc/thread.c

@@ -591 +591 @@
         order_suffix(thread->kcycles, &kcycles, &ksuffix);
         
+        char *name;
+        if (str_cmp(thread->name, "uinit") == 0)
+                name = thread->task->name;
+        else
+                name = thread->name;
+        
 #ifdef __32_BITS__
         if (*additional)
-                printf("%-8" PRIu64" %10p %9" PRIu64 "%c %9" PRIu64 "%c ",
-                    thread->tid, thread->kstack, ucycles, usuffix,
-                    kcycles, ksuffix);
+                printf("%-8 %10p" PRIu64" %10p %9" PRIu64 "%c %9" PRIu64 "%c ",
+                    thread->tid, thread->thread_code, thread->kstack,
+                    ucycles, usuffix, kcycles, ksuffix);
         else
-                printf("%-8" PRIu64" %-14s %10p %-8s %10p %-5" PRIu32 " %10p\n",
-                    thread->tid, thread->name, thread, thread_states[thread->state],
+                printf("%-8" PRIu64" %-14s %10p %-8s %10p %-5" PRIu32 "\n",
+                    thread->tid, name, thread, thread_states[thread->state],
                     thread->task, thread->task->context, thread->thread_code);
 #endif
@@ -610 +616 @@
         else
                 printf("%-8" PRIu64" %-14s %18p %-8s %18p %-5" PRIu32 "\n",
-                    thread->tid, thread->name, thread, thread_states[thread->state],
+                    thread->tid, name, thread, thread_states[thread->state],
                     thread->task, thread->task->context);
 #endif
@@ -648 +654 @@
 #ifdef __32_BITS__
         if (additional)
-                printf("[id    ] [stack   ] [ucycles ] [kcycles ] [cpu]"
-                    " [waitqueue]\n");
+                printf("[id    ] [code    ] [stack   ] [ucycles ] [kcycles ]"
+                    " [cpu] [waitqueue]\n");
         else
                 printf("[id    ] [name        ] [address ] [state ] [task    ]"
-                    " [ctx] [code    ]\n");
+                    " [ctx]\n");
 #endif
         

uspace/Makefile

@@ -46 +46 @@
         app/stats \
         app/taskdump \
-        app/tasks \
         app/tester \
         app/tetris \

uspace/app/stats/stats.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Stanislav Kozina
+ * Copyright (c) 2010 Martin Decky
  * All rights reserved.
  *
@@ -36 +37 @@
 
 #include <stdio.h>
+#include <task.h>
+#include <thread.h>
 #include <stats.h>
-#include <sys/time.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <malloc.h>
 #include <inttypes.h>
-#include <malloc.h>
-
-#define NAME  "sysstat"
+#include <bool.h>
+#include <str.h>
+#include <arg_parse.h>
+
+#define NAME  "stats"
 
 #define DAY     86400
@@ -47 +54 @@
 #define MINUTE  60
 
-int main(int argc, char *argv[])
-{
-        struct timeval time;
-        if (gettimeofday(&time, NULL) != 0) {
-                fprintf(stderr, "%s: Cannot get time of day\n", NAME);
-                return -1;
-        }
-        
-        uint64_t sec = time.tv_sec;
-        printf("%02" PRIu64 ":%02" PRIu64 ":%02" PRIu64,
-            (sec % DAY) / HOUR, (sec % HOUR) / MINUTE, sec % MINUTE);
-        
+static void list_tasks(void)
+{
+        size_t count;
+        stats_task_t *stats_tasks = stats_get_tasks(&count);
+        
+        if (stats_tasks == NULL) {
+                fprintf(stderr, "%s: Unable to get tasks\n", NAME);
+                return;
+        }
+        
+        printf("[taskid] [thrds] [resident] [virtual] [ucycles]"
+            " [kcycles] [name\n");
+        
+        size_t i;
+        for (i = 0; i < count; i++) {
+                uint64_t resmem, virtmem, ucycles, kcycles;
+                char resmem_suffix, virtmem_suffix, usuffix, ksuffix;
+                
+                order_suffix(stats_tasks[i].resmem, &resmem, &resmem_suffix);
+                order_suffix(stats_tasks[i].virtmem, &virtmem, &virtmem_suffix);
+                order_suffix(stats_tasks[i].ucycles, &ucycles, &usuffix);
+                order_suffix(stats_tasks[i].kcycles, &kcycles, &ksuffix);
+                
+                printf("%-8" PRIu64 " %7zu %9" PRIu64 "%c %8" PRIu64 "%c"
+                    " %8" PRIu64 "%c %8" PRIu64 "%c %s\n",
+                    stats_tasks[i].task_id, stats_tasks[i].threads,
+                    resmem, resmem_suffix, virtmem, virtmem_suffix,
+                    ucycles, usuffix, kcycles, ksuffix, stats_tasks[i].name);
+        }
+        
+        free(stats_tasks);
+}
+
+static void list_threads(task_id_t task_id, bool all)
+{
+        size_t count;
+        stats_thread_t *stats_threads = stats_get_threads(&count);
+        
+        if (stats_threads == NULL) {
+                fprintf(stderr, "%s: Unable to get threads\n", NAME);
+                return;
+        }
+        
+        printf("[taskid] [threadid] [state ] [prio] [cpu ] [ucycles] [kcycles]\n");
+        
+        size_t i;
+        for (i = 0; i < count; i++) {
+                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);
+                        
+                        printf("%-8" PRIu64 " %-10" PRIu64 " %-8s %6d ",
+                            stats_threads[i].task_id, stats_threads[i].thread_id,
+                            thread_get_state(stats_threads[i].state),
+                            stats_threads[i].priority);
+                        
+                        if (stats_threads[i].on_cpu)
+                                printf("%6u ", stats_threads[i].cpu);
+                        else
+                                printf("(none) ");
+                        
+                        printf("%8" PRIu64"%c %8" PRIu64"%c\n",
+                            ucycles, usuffix, kcycles, ksuffix);
+                }
+        }
+        
+        free(stats_threads);
+}
+
+static void list_cpus(void)
+{
+        size_t count;
+        stats_cpu_t *cpus = stats_get_cpus(&count);
+        
+        if (cpus == NULL) {
+                fprintf(stderr, "%s: Unable to get CPU statistics\n", NAME);
+                return;
+        }
+        
+        printf("[id] [MHz     ] [busy cycles] [idle cycles]\n");
+        
+        size_t i;
+        for (i = 0; i < count; i++) {
+                printf("%-4u ", cpus[i].id);
+                if (cpus[i].active) {
+                        uint64_t bcycles, icycles;
+                        char bsuffix, isuffix;
+                        
+                        order_suffix(cpus[i].busy_cycles, &bcycles, &bsuffix);
+                        order_suffix(cpus[i].idle_cycles, &icycles, &isuffix);
+                        
+                        printf("%10" PRIu16 " %12" PRIu64 "%c %12" PRIu64 "%c\n",
+                            cpus[i].frequency_mhz, bcycles, bsuffix,
+                            icycles, isuffix);
+                } else
+                        printf("inactive\n");
+        }
+        
+        free(cpus);
+}
+
+static void print_load(void)
+{
+        size_t count;
+        load_t *load = stats_get_load(&count);
+        
+        if (load == NULL) {
+                fprintf(stderr, "%s: Unable to get load\n", NAME);
+                return;
+        }
+        
+        printf("%s: Load average: ", NAME);
+        
+        size_t i;
+        for (i = 0; i < count; i++) {
+                if (i > 0)
+                        printf(" ");
+                
+                stats_print_load_fragment(load[i], 2);
+        }
+        
+        printf("\n");
+        
+        free(load);
+}
+
+static void print_uptime(void)
+{
         sysarg_t uptime = stats_get_uptime();
-        printf(", up %" PRIun " days, %" PRIun " hours, "
-            "%" PRIun " minutes, %" PRIun " seconds",
+        printf("%s: Up %" PRIun " days, %" PRIun " hours, "
+            "%" PRIun " minutes, %" PRIun " seconds\n", NAME,
             uptime / DAY, (uptime % DAY) / HOUR,
             (uptime % HOUR) / MINUTE, uptime % MINUTE);
-        
-        size_t count;
-        load_t *load = stats_get_load(&count);
-        if (load != NULL) {
-                printf(", load average: ");
-                
-                size_t i;
-                for (i = 0; i < count; i++) {
-                        if (i > 0)
-                                printf(" ");
-                        
-                        stats_print_load_fragment(load[i], 2);
-                }
-                
-                free(load);
-        }
-        
-        printf("\n");
+}
+
+static void usage(const char *name)
+{
+        printf(
+            "Usage: %s [-t task_id] [-a] [-c] [-l] [-u]\n" \
+            "\n" \
+            "Options:\n" \
+            "\t-t task_id\n" \
+            "\t--task=task_id\n" \
+            "\t\tList threads of the given task\n" \
+            "\n" \
+            "\t-a\n" \
+            "\t--all\n" \
+            "\t\tList all threads\n" \
+            "\n" \
+            "\t-c\n" \
+            "\t--cpus\n" \
+            "\t\tList CPUs\n" \
+            "\n" \
+            "\t-l\n" \
+            "\t--load\n" \
+            "\t\tPrint system load\n" \
+            "\n" \
+            "\t-u\n" \
+            "\t--uptime\n" \
+            "\t\tPrint system uptime\n" \
+            "\n" \
+            "\t-h\n" \
+            "\t--help\n" \
+            "\t\tPrint this usage information\n"
+            "\n" \
+            "Without any options all tasks are listed\n",
+            name
+        );
+}
+
+int main(int argc, char *argv[])
+{
+        bool toggle_tasks = true;
+        bool toggle_threads = false;
+        bool toggle_all = false;
+        bool toggle_cpus = false;
+        bool toggle_load = false;
+        bool toggle_uptime = false;
+        
+        task_id_t task_id = 0;
+        
+        int i;
+        for (i = 1; i < argc; i++) {
+                int off;
+                
+                /* Usage */
+                if ((off = arg_parse_short_long(argv[i], "-h", "--help")) != -1) {
+                        usage(argv[0]);
+                        return 0;
+                }
+                
+                /* All threads */
+                if ((off = arg_parse_short_long(argv[i], "-a", "--all")) != -1) {
+                        toggle_tasks = false;
+                        toggle_threads = true;
+                        toggle_all = true;
+                        continue;
+                }
+                
+                /* CPUs */
+                if ((off = arg_parse_short_long(argv[i], "-c", "--cpus")) != -1) {
+                        toggle_tasks = false;
+                        toggle_cpus = true;
+                        continue;
+                }
+                
+                /* Threads */
+                if ((off = arg_parse_short_long(argv[i], "-t", "--task=")) != -1) {
+                        // TODO: Support for 64b range
+                        int tmp;
+                        int ret = arg_parse_int(argc, argv, &i, &tmp, off);
+                        if (ret != EOK) {
+                                printf("%s: Malformed task_id '%s'\n", NAME, argv[i]);
+                                return -1;
+                        }
+                        
+                        task_id = tmp;
+                        
+                        toggle_tasks = false;
+                        toggle_threads = true;
+                        continue;
+                }
+                
+                /* Load */
+                if ((off = arg_parse_short_long(argv[i], "-l", "--load")) != -1) {
+                        toggle_tasks = false;
+                        toggle_load = true;
+                        continue;
+                }
+                
+                /* Uptime */
+                if ((off = arg_parse_short_long(argv[i], "-u", "--uptime")) != -1) {
+                        toggle_tasks = false;
+                        toggle_uptime = true;
+                        continue;
+                }
+        }
+        
+        if (toggle_tasks)
+                list_tasks();
+        
+        if (toggle_threads)
+                list_threads(task_id, toggle_all);
+        
+        if (toggle_cpus)
+                list_cpus();
+        
+        if (toggle_load)
+                print_load();
+        
+        if (toggle_uptime)
+                print_uptime();
+        
         return 0;
 }

uspace/app/top/screen.c

@@ -274 +274 @@
 {
         screen_style_inverted();
-        printf("[taskid] [threads] [resident] [%%resi] [virtual] [%%virt]"
+        printf("[taskid] [thrds] [resident] [%%resi] [virtual] [%%virt]"
             " [%%user] [%%kern] [name");
         screen_newline();
@@ -303 +303 @@
                 order_suffix(task->virtmem, &virtmem, &virtmem_suffix);
                 
-                printf("%-8" PRIu64 " %9zu %9" PRIu64 "%c ",
+                printf("%-8" PRIu64 " %7zu %9" PRIu64 "%c ",
                     task->task_id, task->threads, resmem, resmem_suffix);
                 print_percent(perc->resmem, 2);