WebSVN – HelenOS – Diff – /branches/tracing/uspace/app/debug/main.c

 #include <udebug.h>
 #include <async.h>
 #include <string.h>
 #include "cmd.h"
+#include "cons.h"
 #include "include/arch.h"
 #include "fib_synch.h"
 #include "main.h"
 void thread_debug_start(unsigned thread_hash);
-#define INBUF_SIZE 64
+#define IN_BUF_SIZE 64
-char in_buf[INBUF_SIZE];
+static char in_buf[IN_BUF_SIZE];
 #define MAX_ARGC 10
 int cmd_argc;
 char *cmd_argv[MAX_ARGC + 1];   /* need one spare field for cmd_split() */
 breakpoint_t brk_list[MAX_BRKPTS];
 int lifted_brkpt;
 fcv_t go_cv;
-void read_line(char *buffer, int n)
-{
-    char c;
-    int i;
-    i = 0;
-    while (i < n - 1) {
-        c = getchar();
-        if (c == '\n') break;
-        if (c == '\b') {
-            if (i > 0) {
-                putchar('\b');
-                --i;
-            }
-            continue;
-        }
-        putchar(c);
-        buffer[i++] = c;
-    }
-    putchar('\n');
-    buffer[i] = '\0';
-}
 void command_split(char *cmd_str)
+{
     char *p = cmd_str;
     if (*p == '\0') {
         --cmp_len;
+    }
     if (num_found == 0) {
-        printf("Unknown command. Try one of:\n");
+        cons_printf("Unknown command. Try one of:\n");
         cmd_help(0, NULL);
         return;
+    }
     if (cmd_argc - 1 != cmd_table[idx_found].argc) {
-        printf("Command '%s' expects %d arguments\n",
+        cons_printf("Command '%s' expects %d arguments\n",
         cmd_table[idx_found].name, cmd_table[idx_found].argc);
         return;
+    }
     (*cmd_table[idx_found].proc)(cmd_argc, cmd_argv);
+}
+void thread_stop(void)
+{
+    cons_printf("[t] stopped\n");
+    fcv_wait(&go_cv);
+    cons_printf("[t] go\n");
+}
 /*
  * Called by a fibril (from arch code) when a breakpoint is hit.
  */
 void breakpoint_hit(void)
+{
+    cons_printf("breakpoint hit\n");
-    fcv_wait(&go_cv);
+    thread_stop();
+}
 int task_connect(int taskid)
+{
     int rc;
     unsigned evmask;
-    printf("ipc_connect_kbox(%d)... ", taskid);
+    cons_printf("ipc_connect_kbox(%d)... ", taskid);
     rc = ipc_connect_kbox(taskid);
-    printf("-> %d\n", rc);
+    cons_printf("-> %d\n", rc);
     app_phone = rc;
     if (rc < 0) return rc;
-    printf("udebug_begin()... ");
+    cons_printf("udebug_begin()... ");
     rc = udebug_begin(app_phone);
-    printf("-> %d\n", rc);
+    cons_printf("-> %d\n", rc);
     if (rc < 0) return rc;
     evmask = UDEBUG_EM_ALL & ~(UDEBUG_EM_SYSCALL_B | UDEBUG_EM_SYSCALL_E);
-    printf("udebug_set_evmask(0x%x)... ", evmask);
+    cons_printf("udebug_set_evmask(0x%x)... ", evmask);
     rc = udebug_set_evmask(app_phone, evmask);
-    printf("-> %d\n", rc);
+    cons_printf("-> %d\n", rc);
     if (rc < 0) return rc;
     return 0;
+}
     int rc;
     int tb_copied;
     int tb_needed;
     int i;
-    printf("send IPC_M_DEBUG_THREAD_READ message\n");
+    cons_printf("send IPC_M_DEBUG_THREAD_READ message\n");
     rc = udebug_thread_read(app_phone, (unsigned)thread_hash_buf,
         THBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);
-    printf("-> %d\n", rc);
+    cons_printf("-> %d\n", rc);
     if (rc < 0) return rc;
     n_threads = tb_copied / sizeof(unsigned);
-    printf("thread IDs:");
+    cons_printf("thread IDs:");
     for (i=0; i<n_threads; i++) {
-        printf(" %u", thread_hash_buf[i]);
+        cons_printf(" %u", thread_hash_buf[i]);
+    }
-    printf("\ntotal of %u threads\n", tb_needed/sizeof(unsigned));
+    cons_printf("\ntotal of %u threads\n", tb_needed/sizeof(unsigned));
     return 0;
+}
 void event_thread_b(unsigned hash)
+{
     async_serialize_start();
-    printf("new thread, hash 0x%x\n", hash);
+    cons_printf("new thread, hash 0x%x\n", hash);
     async_serialize_end();
     thread_debug_start(hash);
+}
 static void debug_event(thash_t thash, udebug_event_t ev_type, sysarg_t val0)
+{
     switch (ev_type) {
     case UDEBUG_EVENT_STOP:
-        printf("stop event\n");
+        cons_printf("stop event\n");
-        printf("waiting for resume\n");
+        cons_printf("waiting for resume\n");
         while (paused) {
             usleep(1000000);
             fibril_yield();
-            printf(".");
+            cons_printf(".");
+        }
-        printf("resumed\n");
+        cons_printf("resumed\n");
         break;
     case UDEBUG_EVENT_THREAD_B:
         event_thread_b(val0);
         break;
     case UDEBUG_EVENT_THREAD_E:
-        printf("thread 0x%x exited\n", val0);
+        cons_printf("thread 0x%x exited\n", val0);
         abort_debug = true;
         break;
     case UDEBUG_EVENT_BREAKPOINT:
         arch_event_breakpoint(thash);
         break;
     case UDEBUG_EVENT_TRAP:
         arch_event_trap(thash);
         break;
     default:
-        printf("unknown event type %d\n", ev_type);
+        cons_printf("unknown event type %d\n", ev_type);
         break;
+    }
+}
 void debug_loop(void *thread_hash_arg)
     unsigned val0, val1;
     thread_hash = (unsigned)thread_hash_arg;
     thread_id = next_thread_id++;
-    printf("debug_loop(%d)\n", thread_id);
+    cons_printf("debug_loop(%d)\n", thread_id);
     while (!abort_debug) {
-        printf("[t%d] go...\n", thread_id);
         /* Run thread until an event occurs */
         rc = udebug_go(app_phone, thread_hash,
             &ev_type, &val0, &val1);
-        printf("[t%d] stopped\n", thread_id);
         if (ev_type == UDEBUG_EVENT_FINISHED) {
-            printf("thread %u debugging finished\n", thread_id);
+            cons_printf("thread %u debugging finished\n", thread_id);
             break;
+        }
         if (rc >= 0) debug_event(thread_hash, ev_type, val0);
+    }
-    printf("debug_loop(%d) exiting\n", thread_id);
+    cons_printf("debug_loop(%d) exiting\n", thread_id);
+}
 void thread_debug_start(unsigned thread_hash)
+{
     fid_t fid;
     thash = thread_hash;
     fid = fibril_create(debug_loop, (void *)thread_hash);
     if (fid == 0) {
-        printf("Warning: Failed creating fibril\n");
+        cons_printf("Warning: Failed creating fibril\n");
+    }
     fibril_add_ready(fid);
+}
 void debug_active_task(void)
     int taskid;
     int i;
     int rc;
     int c;
-    printf("Breakpoint Debugger\n");
+    cons_printf("Breakpoint Debugger\n");
-    printf("Press 'c' to connect\n");
+    cons_printf("Press 'c' to connect\n");
     while ((i = getchar()) != 'c')
         putchar(i);
     taskid = 14;
     rc = task_connect(taskid);
     if (rc < 0) {
-        printf("Failed to connect to task %d\n", taskid);
+        cons_printf("Failed to connect to task %d\n", taskid);
         return;
+    }
-    printf("Connected to task %d\n", taskid);
+    cons_printf("Connected to task %d\n", taskid);
     rc = get_thread_list();
     if (rc < 0) {
-        printf("Failed to get thread list (error %d)\n", rc);
+        cons_printf("Failed to get thread list (error %d)\n", rc);
         return;
+    }
     abort_debug = false;
     for (i = 0; i < n_threads; i++) {
         thread_debug_start(thread_hash_buf[i]);
+    }
     while (!quit) {
-        printf("> ");
-        read_line(in_buf, INBUF_SIZE);
+        cons_read_line(in_buf, IN_BUF_SIZE);
         command_split(in_buf);
         if (cmd_argc == 0) continue;
         command_run();
+    }
-    printf("terminate debugging session...\n");
+    cons_printf("terminate debugging session...\n");
     abort_debug = true;
     udebug_end(app_phone);
     ipc_hangup(app_phone);
-    printf("done\n");
+    cons_printf("done\n");
     return;
+}
 static void main_init(void)
+{

Subversion Repositories HelenOS

(root)/branches/tracing/uspace/app/debug/main.c – Rev 2935 → 2936