Changeset 2314381 in mainline for kernel/generic/src/udebug

Timestamp:

2010-01-26T22:49:26Z (16 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

bca408b

Parents:

bb0d3d24 (diff), 3698e44 (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 jsvoboda/helenos/taskdump: Taskdump now prints stack traces, even with symbolic names.

Location:

kernel/generic/src/udebug

Files:

• udebug.c (modified) (1 diff)
• udebug_ipc.c (modified) (6 diffs)
• udebug_ops.c (modified) (4 diffs)

kernel/generic/src/udebug/udebug.c

@@ -460 +460 @@
 }
 
+/** Wait for debugger to handle a fault in this thread.
+ *
+ * When a thread faults and someone is subscribed to the FAULT kernel event,
+ * this function is called to wait for a debugging session to give userspace
+ * a chance to examine the faulting thead/task. When the debugging session
+ * is over, this function returns (so that thread/task cleanup can continue).
+ */
+void udebug_thread_fault(void)
+{
+        udebug_stoppable_begin();
+
+        /* Wait until a debugger attends to us. */
+        mutex_lock(&THREAD->udebug.lock);
+        while (!THREAD->udebug.active)
+                condvar_wait(&THREAD->udebug.active_cv, &THREAD->udebug.lock);
+        mutex_unlock(&THREAD->udebug.lock);
+
+        /* Make sure the debugging session is over before proceeding. */
+        mutex_lock(&THREAD->udebug.lock);
+        while (THREAD->udebug.active)
+                condvar_wait(&THREAD->udebug.active_cv, &THREAD->udebug.lock);
+        mutex_unlock(&THREAD->udebug.lock);
+
+        udebug_stoppable_end();
+}
 
 /** @}

kernel/generic/src/udebug/udebug_ipc.c

@@ -202 +202 @@
 }
 
-/** Process an AREAS_READ call.
- *
- * Returns a list of address space areas in the current task, as an array
- * of as_area_info_t structures.
- *
- * @param call  The call structure.
- */
-static void udebug_receive_areas_read(call_t *call)
+/** Process a NAME_READ call.
+ *
+ * Returns a string containing the name of the task.
+ *
+ * @param call  The call structure.
+ */
+static void udebug_receive_name_read(call_t *call)
 {
         unative_t uspace_addr;
@@ -221 +220 @@
 
         /*
-         * Read area list.
-         */
-        as_get_area_info(AS, (as_area_info_t **) &data, &data_size);
+         * Read task name.
+         */
+        udebug_name_read((char **) &data, &data_size);
 
         /* Copy MAX(buf_size, data_size) bytes */
@@ -249 +248 @@
 }
 
+/** Process an AREAS_READ call.
+ *
+ * Returns a list of address space areas in the current task, as an array
+ * of as_area_info_t structures.
+ *
+ * @param call  The call structure.
+ */
+static void udebug_receive_areas_read(call_t *call)
+{
+        unative_t uspace_addr;
+        unative_t to_copy;
+        size_t data_size;
+        size_t buf_size;
+        void *data;
+
+        uspace_addr = IPC_GET_ARG2(call->data); /* Destination address */
+        buf_size = IPC_GET_ARG3(call->data);    /* Dest. buffer size */
+
+        /*
+         * Read area list.
+         */
+        as_get_area_info(AS, (as_area_info_t **) &data, &data_size);
+
+        /* Copy MAX(buf_size, data_size) bytes */
+
+        if (buf_size > data_size)
+                to_copy = data_size;
+        else
+                to_copy = buf_size;
+
+        /*
+         * Make use of call->buffer to transfer data to caller's userspace
+         */
+
+        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);
+
+        IPC_SET_ARG3(call->data, data_size);
+        call->buffer = data;
+
+        ipc_answer(&TASK->kb.box, call);
+}
+
 
 /** Process an ARGS_READ call.
@@ -287 +333 @@
         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.
@@ -368 +455 @@
                 udebug_receive_thread_read(call);
                 break;
+        case UDEBUG_M_NAME_READ:
+                udebug_receive_name_read(call);
+                break;
         case UDEBUG_M_AREAS_READ:
                 udebug_receive_areas_read(call);
@@ -374 +464 @@
                 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

@@ -46 +46 @@
 #include <errno.h>
 #include <print.h>
+#include <string.h>
 #include <syscall/copy.h>
 #include <ipc/ipc.h>
@@ -439 +440 @@
 }
 
+/** Read task name.
+ *
+ * Returns task name as non-terminated string in a newly allocated buffer.
+ * Also returns the size of the data.
+ *
+ * @param data          Place to store pointer to newly allocated block.
+ * @param data_size     Place to store size of the data.
+ *
+ * @returns             EOK.
+ */
+int udebug_name_read(char **data, size_t *data_size)
+{
+        size_t name_size;
+
+        name_size = str_size(TASK->name) + 1;
+        *data = malloc(name_size, 0);
+        *data_size = name_size;
+
+        memcpy(*data, TASK->name, name_size);
+
+        return 0;
+}
+
 /** Read the arguments of a system call.
  *
@@ -449 +473 @@
  * 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 +508 @@
 }
 
+/** 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.
  *