WebSVN – HelenOS – Diff – /branches/tracing/uspace/app/sctrace/sctrace.c

 /** @addtogroup sctrace
  * @{
  */
 /** @file
  */
 #include <stdio.h>
 #include <unistd.h>
 #include <syscall.h>
 #include <ipc/ipc.h>
 #include <fibril.h>
 #include <errno.h>
 #include <udebug.h>
 #include <async.h>
 #include "syscalls.h"
 #include "errors.h"
 #include "debug_api.h"
 #define TIDBUF_SIZE 64
 unsigned threadid_buf[TIDBUF_SIZE];
 unsigned n_threads;
 int phoneid;
 int abort_trace;
 int task_connect(int taskid)
+{
     int rc;
     printf("ipc_connect_task(%d)...\n", taskid);
     rc = ipc_connect_kbox(taskid);
     printf("-> %d\n", rc);
     phoneid = rc;
     if (rc < 0) return rc;
     printf("debug_begin()\n");
     rc = debug_begin(phoneid);
     printf("-> %d\n", rc);
     if (rc < 0) return rc;
     return 0;
+}
 int get_thread_list(void)
+{
     int rc;
     int tb_copied;
     int tb_needed;
     int i;
     printf("send IPC_M_DEBUG_THREAD_READ message\n");
     rc = debug_thread_read(phoneid, (unsigned)threadid_buf,
         TIDBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);
     printf("-> %d\n", rc);
     if (rc < 0) return rc;
     n_threads = tb_copied / sizeof(unsigned);
     printf("thread IDs:");
     for (i=0; i<n_threads; i++) {
         printf(" %u", threadid_buf[i]);
+    }
     printf("\ntotal of %u threads\n", tb_needed/sizeof(unsigned));
     return 0;
+}
 void print_sc_retval(int retval, rv_type_t rv_type)
+{
     printf (" -> ");
     if (rv_type == RV_INTEGER) {
         printf("%d", retval);
     } else if (rv_type == RV_HASH) {
         printf("0x%08x", retval);
     } else if (rv_type == RV_ERRNO) {
         if (retval >= -15 && retval <= 0) {
             printf("%d %s (%s)", retval,
                 err_desc[retval].name,
                 err_desc[retval].desc);
         } else {
             printf("%d", retval);
+        }
     } else if (rv_type == RV_INT_ERRNO) {
         if (retval >= -15 && retval < 0) {
             printf("%d %s (%s)", retval,
                 err_desc[retval].name,
                 err_desc[retval].desc);
         } else {
             printf("%d", retval);
+        }
+    }
     putchar('\n');
+}
 void print_sc_args(unsigned *sc_args, int n)
+{
     int i;
     putchar('(');
     if (n > 0) printf("%d", sc_args[0]);
     for (i=1; i<n; i++) {
         printf(", %d", sc_args[i]);
+    }
     putchar(')');
+}
 void sc_ipc_call_async_slow(unsigned *sc_args)
+{
     unsigned ipc_args[6];
     int rc;
     memset(ipc_args, 0, sizeof(ipc_args));
     rc = debug_mem_read(phoneid, ipc_args, sc_args[1], sizeof(ipc_args));
     if (rc >= 0) {
         printf("args: (%u, %u, %u, %u, %u, %u)\n",
             ipc_args[0], ipc_args[1], ipc_args[2],
             ipc_args[3], ipc_args[4], ipc_args[5]);
+    }
+}
+void event_syscall(unsigned thread_idx, unsigned sc_id, int sc_rc)
+{
+    unsigned sc_args[6];
+    int rv_type;
+    int rc;
+    /* Read syscall arguments */
+    rc = debug_args_read(phoneid, threadid_buf[thread_idx], sc_args);
+    async_serialize_start();
+    printf("[%d] ", thread_idx);
+    if (rc < 0) {
+        printf("error\n");
+        async_serialize_end();
+        return;
+    }
+    /* Print syscall name, id and arguments */
+    printf("%s", syscall_desc[sc_id].name);
+    print_sc_args(sc_args, syscall_desc[sc_id].n_args);
+    rv_type = syscall_desc[sc_id].rv_type;
+    print_sc_retval(sc_rc, rv_type);
+    switch (sc_id) {
+    case SYS_IPC_CALL_ASYNC_SLOW:
+        sc_ipc_call_async_slow(sc_args);
+        break;
+    default:
+        break;
+    }
+    async_serialize_end();
+}
+void event_new_thread(unsigned hash)
+{
+    async_serialize_start();
+    printf("new thread, hash 0x%x\n", hash);
+    async_serialize_end();
+}
 void trace_loop(void *thread_idx_arg)
+{
     int rc;
-    unsigned sc_args[6];
-    unsigned copied;
     unsigned ev_type;
-    unsigned sc_id;
-    int sc_rc;
-    int rv_type;
     unsigned thread_idx;
+    unsigned val0, val1;
     thread_idx = (unsigned)thread_idx_arg;
     printf("trace_loop(%d)\n", thread_idx);
     while (!abort_trace) {
-        /* Run thread until a syscall is executed */
+        /* Run thread until an event occurs */
         rc = debug_go(phoneid, threadid_buf[thread_idx],
-            &ev_type, &sc_id, &sc_rc);
+            &ev_type, &val0, &val1);
         printf("rc = %d, ev_type=%d\n", rc, ev_type);
         if (ev_type == UDEBUG_EVENT_FINISHED) {
             printf("thread %u debugging finished\n", threadid_buf[thread_idx]);
             break;
+        }
-        /* Read syscall arguments */
-        if (rc >= 0) {
-            rc = debug_args_read(phoneid, threadid_buf[thread_idx],
-                sc_args);
-        }
-        async_serialize_start();
-        printf("[%d] ", thread_idx);
-        /* Print syscall name, id and arguments */
         if (rc >= 0) {
+            switch (ev_type) {
-            printf("%s", syscall_desc[sc_id].name);
+            case UDEBUG_EVENT_SYSCALL:
-            print_sc_args(sc_args, syscall_desc[sc_id].n_args);
+                event_syscall(thread_idx, val0, (int)val1);
+                break;
-            rv_type = syscall_desc[sc_id].rv_type;
+            case UDEBUG_EVENT_NEW_THREAD:
+                event_new_thread(val0);
+                break;
+            default:
-            print_sc_retval(sc_rc, rv_type);
+                printf("unknown event type %d\n", ev_type);
+                break;
+            }
+        }
-        async_serialize_end();
-        switch (sc_id) {
-        case SYS_IPC_CALL_ASYNC_SLOW:
-            sc_ipc_call_async_slow(sc_args);
-            break;
-        default:
-            break;
-        }
+    }
     printf("trace_loop(%d) exiting\n", thread_idx);
+}
 void trace_active_task(void)
+{
     int taskid;
     int i;
     int rc;
     fid_t fid;
     printf("Syscall Tracer\n");
     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);
         return;
+    }
     printf("Connected to task %d\n", taskid);
     rc = get_thread_list();
     if (rc < 0) {
         printf("Failed to get thread list (error %d)\n", rc);
         return;
+    }
     abort_trace = 0;
     for (i = 0; i < n_threads; i++) {
         fid = fibril_create(trace_loop, (void *)i);
         if (fid == 0) {
             printf("Warning: Failed creating fibril\n");
+        }
         fibril_add_ready(fid);
+    }
     getchar();
     printf("terminate debugging session...\n");
     abort_trace = 1;
     debug_end(phoneid);
     ipc_hangup(phoneid);
     printf("done\n");
     return;
+}
 int main(void)
+{
     while (1) {
         trace_active_task();
+    }
+}
 /** @}
  */

Subversion Repositories HelenOS

(root)/branches/tracing/uspace/app/sctrace/sctrace.c – Rev 2862 → 2867