Changeset 80487bc5 in mainline

Timestamp:

2010-01-25T21:40:13Z (14 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

e515b21a

Parents:

0d21b53

Message:

Allow taskdump to read register state and extract PC, FP (not implemented for all arches).

Files:

• kernel/generic/include/udebug/udebug.h (modified) (3 diffs)
• kernel/generic/include/udebug/udebug_ops.h (modified) (1 diff)
• kernel/generic/src/udebug/udebug_ipc.c (modified) (2 diffs)
• kernel/generic/src/udebug/udebug_ops.c (modified) (2 diffs)
• uspace/app/taskdump/taskdump.c (modified) (4 diffs)
• uspace/lib/libc/arch/amd64/include/istate.h (added)
• uspace/lib/libc/arch/arm32/include/istate.h (added)
• uspace/lib/libc/arch/ia32/include/istate.h (added)
• uspace/lib/libc/arch/ia64/include/istate.h (added)
• uspace/lib/libc/arch/mips32/include/istate.h (added)
• uspace/lib/libc/arch/mips32eb/include/istate.h (added)
• uspace/lib/libc/arch/ppc32/include/istate.h (added)
• uspace/lib/libc/arch/sparc64/include/istate.h (added)
• uspace/lib/libc/generic/udebug.c (modified) (1 diff)
• uspace/lib/libc/include/udebug.h (modified) (1 diff)

kernel/generic/include/udebug/udebug.h

@@ -27 +27 @@
  */
 
-/** @addtogroup generic 
+/** @addtogroup generic
  * @{
  */
@@ -83 +83 @@
 UDEBUG_M_ARGS_READ,
 
+/** Read thread's userspace register state (istate_t).
+ *
+ * - ARG2 - thread identification
+ * - ARG3 - destination address in the caller's address space
+ *
+ * or, on error, retval will be
+ * - ENOENT - thread does not exist
+ * - EBUSY - register state not available
+ */
+UDEBUG_M_REGS_READ,
+
 /** Read the list of the debugged tasks's threads.
  *
@@ -122 +133 @@
 } udebug_method_t;
 
-                                
+
 typedef enum {
         UDEBUG_EVENT_FINISHED = 1,      /**< Debuging session has finished */

kernel/generic/include/udebug/udebug_ops.h

@@ -49 +49 @@
 int udebug_args_read(thread_t *t, void **buffer);
 
+int udebug_regs_read(thread_t *t, void **buffer);
+
 int udebug_mem_read(unative_t uspace_addr, size_t n, void **buffer);
 

kernel/generic/src/udebug/udebug_ipc.c

@@ -287 +287 @@
         ipc_answer(&TASK->kb.box, call);
 }
+
+/** Receive a REGS_READ call.
+ *
+ * Reads the thread's register state (istate structure).
+ */
+static void udebug_receive_regs_read(call_t *call)
+{
+        thread_t *t;
+        unative_t uspace_addr;
+        unative_t to_copy;
+        void *buffer;
+        int rc;
+
+        t = (thread_t *) IPC_GET_ARG2(call->data);
+
+        rc = udebug_regs_read(t, &buffer);
+        if (rc < 0) {
+                IPC_SET_RETVAL(call->data, rc);
+                ipc_answer(&TASK->kb.box, call);
+                return;
+        }
+
+        /*
+         * Make use of call->buffer to transfer data to caller's userspace
+         */
+
+        uspace_addr = IPC_GET_ARG3(call->data);
+        to_copy = sizeof(istate_t);
+
+        IPC_SET_RETVAL(call->data, 0);
+        /* ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
+           same code in process_answer() can be used 
+           (no way to distinguish method in answer) */
+        IPC_SET_ARG1(call->data, uspace_addr);
+        IPC_SET_ARG2(call->data, to_copy);
+
+        call->buffer = buffer;
+
+        ipc_answer(&TASK->kb.box, call);
+}
+
 
 /** Process an MEM_READ call.
@@ -374 +415 @@
                 udebug_receive_args_read(call);
                 break;
+        case UDEBUG_M_REGS_READ:
+                udebug_receive_regs_read(call);
+                break;
         case UDEBUG_M_MEM_READ:
                 udebug_receive_mem_read(call);

kernel/generic/src/udebug/udebug_ops.c

@@ -449 +449 @@
  * this function will fail with an EINVAL error code.
  *
- * @param buffer        The buffer for storing thread hashes.
+ * @param t             Thread where call arguments are to be read.
+ * @param buffer        Place to store pointer to new buffer.
+ * @return              EOK on success, ENOENT if @a t is invalid, EINVAL
+ *                      if thread state is not valid for this operation.
  */
 int udebug_args_read(thread_t *t, void **buffer)
@@ -481 +484 @@
 }
 
+/** Read the register state of the thread.
+ *
+ * The contents of the thread's istate structure are copied to a newly
+ * allocated buffer and a pointer to it is written to @a buffer. The size of
+ * the buffer will be sizeof(istate_t).
+ *
+ * Currently register state cannot be read if the thread is inside a system
+ * call (as opposed to an exception). This is an implementation limit.
+ *
+ * @param t             Thread whose state is to be read.
+ * @param buffer        Place to store pointer to new buffer.
+ * @return              EOK on success, ENOENT if @a t is invalid, EINVAL
+ *                      if thread is not in valid state, EBUSY if istate
+ *                      is not available.
+ */
+int udebug_regs_read(thread_t *t, void **buffer)
+{
+        istate_t *state, *state_buf;
+        int rc;
+
+        /* Prepare a buffer to hold the data. */
+        state_buf = malloc(sizeof(istate_t), 0);
+
+        /* On success, this will lock t->udebug.lock */
+        rc = _thread_op_begin(t, false);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        state = t->udebug.uspace_state;
+        if (state == NULL) {
+                _thread_op_end(t);
+                return EBUSY;
+        }
+
+        /* Copy to the allocated buffer */
+        memcpy(state_buf, state, sizeof(istate_t));
+
+        _thread_op_end(t);
+
+        *buffer = (void *) state_buf;
+        return 0;
+}
+
 /** Read the memory of the debugged task.
  *

uspace/app/taskdump/taskdump.c

@@ -41 +41 @@
 #include <task.h>
 #include <kernel/mm/as.h>
+#include <libarch/istate.h>
 #include <macros.h>
 #include <assert.h>
@@ -58 +59 @@
 static void print_syntax();
 static int threads_dump(void);
+static int thread_dump(uintptr_t thash);
 static int areas_dump(void);
 static int area_dump(as_area_info_t *area);
@@ -229 +231 @@
         for (i = 0; i < n_threads; i++) {
                 printf(" [%d] hash: 0x%lx\n", 1+i, thash_buf[i]);
+
+                thread_dump(thash_buf[i]);
         }
         putchar('\n');
@@ -291 +295 @@
 }
 
+static int thread_dump(uintptr_t thash)
+{
+        istate_t istate;
+        uintptr_t pc, fp;
+        int rc;
+
+        rc = udebug_regs_read(phoneid, thash, &istate);
+        if (rc < 0) {
+                printf("Failed reading registers (%d).\n", rc);
+                return EIO;
+        }
+
+        pc = istate_get_pc(&istate);
+        fp = istate_get_fp(&istate);
+
+        printf("Thread 0x%lx crashed at PC 0x%lx. FP 0x%lx\n", thash, pc, fp);
+        printf("Istate hexdump:\n");
+        hex_dump(0, &istate, (sizeof(istate_t) + 15) & ~15);
+
+        return EOK;
+}
+
 static int area_dump(as_area_info_t *area)
 {

uspace/lib/libc/generic/udebug.c

@@ -97 +97 @@
 }
 
+int udebug_regs_read(int phoneid, thash_t tid, void *buffer)
+{
+        return async_req_3_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_REGS_READ,
+            tid, (sysarg_t)buffer);
+}
+
 int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type,
     sysarg_t *val0, sysarg_t *val1)

uspace/lib/libc/include/udebug.h

@@ -51 +51 @@
 int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n);
 int udebug_args_read(int phoneid, thash_t tid, sysarg_t *buffer);
+int udebug_regs_read(int phoneid, thash_t tid, void *buffer);
 int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type,
         sysarg_t *val0, sysarg_t *val1);