Changeset 827d73f in mainline for kernel/generic/src

Timestamp:

2010-02-12T14:09:22Z (15 years ago)

Author:

Lukas Mejdrech <lukasmejdrech@…>

Branches:

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

Children:

a70bda4

Parents:

918e9910 (diff), e70edd1 (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:

Merged the actual head

Location:

kernel/generic/src

Files:

• console/kconsole.c (modified) (1 diff)
• ddi/irq.c (modified) (2 diffs)
• debug/stacktrace.c (added)
• debug/symtab.c (modified) (4 diffs)
• interrupt/interrupt.c (modified) (2 diffs)
• ipc/ipc.c (modified) (6 diffs)
• mm/as.c (modified) (1 diff)
• udebug/udebug.c (modified) (3 diffs)
• udebug/udebug_ipc.c (modified) (6 diffs)
• udebug/udebug_ops.c (modified) (10 diffs)

kernel/generic/src/console/kconsole.c

@@ -543 +543 @@
                 if (str_lcmp(hlp->name, cmdline + start,
                     max(str_length(hlp->name),
-                    str_nlength(cmdline + start, (size_t) (end - start) - 1))) == 0) {
+                    str_nlength(cmdline + start, (size_t) (end - start)))) == 0) {
                         cmd = hlp;
                         break;

kernel/generic/src/ddi/irq.c

@@ -74 +74 @@
 #include <synch/spinlock.h>
 #include <console/console.h>
+#include <interrupt.h>
 #include <memstr.h>
 #include <arch.h>
@@ -169 +170 @@
         irq->inr = -1;
         irq->devno = -1;
+
+        irq_initialize_arch(irq);
 }
 

kernel/generic/src/debug/symtab.c

@@ -46 +46 @@
 /** Get name of a symbol that seems most likely to correspond to address.
  *
- * @param addr Address.
- * @param name Place to store pointer to the symbol name.
+ * @param addr          Address.
+ * @param name          Place to store pointer to the symbol name.
+ * @param offset        Place to store offset from the symbol address.
  *
  * @return Zero on success or negative error code, ENOENT if not found,
@@ -53 +54 @@
  *
  */
-int symtab_name_lookup(unative_t addr, char **name)
+int symtab_name_lookup(uintptr_t addr, char **name, uintptr_t *offset)
 {
 #ifdef CONFIG_SYMTAB
@@ -65 +66 @@
         if (addr >= uint64_t_le2host(symbol_table[i - 1].address_le)) {
                 *name = symbol_table[i - 1].symbol_name;
+                if (offset)
+                        *offset = addr -
+                            uint64_t_le2host(symbol_table[i - 1].address_le);
                 return EOK;
         }
@@ -88 +92 @@
  *
  */
-char *symtab_fmt_name_lookup(unative_t addr)
+char *symtab_fmt_name_lookup(uintptr_t addr)
 {
         char *name;
-        int rc = symtab_name_lookup(addr, &name);
+        int rc = symtab_name_lookup(addr, &name, NULL);
         
         switch (rc) {

kernel/generic/src/interrupt/interrupt.c

@@ -44 +44 @@
 #include <console/console.h>
 #include <console/cmd.h>
+#include <ipc/event.h>
+#include <synch/mutex.h>
+#include <time/delay.h>
+#include <macros.h>
 #include <panic.h>
 #include <print.h>
@@ -107 +111 @@
         fault_if_from_uspace(istate, "Unhandled exception %d.", n);
         panic("Unhandled exception %d.", n);
+}
+
+/** Terminate thread and task if exception came from userspace. */
+void fault_if_from_uspace(istate_t *istate, char *fmt, ...)
+{
+        task_t *task = TASK;
+        va_list args;
+
+        if (!istate_from_uspace(istate))
+                return;
+
+        printf("Task %s (%" PRIu64 ") killed due to an exception at "
+            "program counter %p.\n", task->name, task->taskid,
+            istate_get_pc(istate));
+
+        stack_trace_istate(istate);
+
+        printf("Kill message: ");
+        va_start(args, fmt);
+        vprintf(fmt, args);
+        va_end(args);
+        printf("\n");
+
+        /*
+         * Userspace can subscribe for FAULT events to take action
+         * whenever a thread faults. (E.g. take a dump, run a debugger).
+         * The notification is always available, but unless Udebug is enabled,
+         * that's all you get.
+         */
+        if (event_is_subscribed(EVENT_FAULT)) {
+                /* Notify the subscriber that a fault occurred. */
+                event_notify_3(EVENT_FAULT, LOWER32(TASK->taskid),
+                    UPPER32(TASK->taskid), (unative_t) THREAD);
+
+#ifdef CONFIG_UDEBUG
+                /* Wait for a debugging session. */
+                udebug_thread_fault();
+#endif
+        }
+
+        task_kill(task->taskid);
+        thread_exit();
 }
 

kernel/generic/src/ipc/ipc.c

@@ -212 +212 @@
  *
  * @param call          Call structure to be answered.
- */
-static void _ipc_answer_free_call(call_t *call)
+ * @param selflocked    If true, then TASK->answebox is locked.
+ */
+static void _ipc_answer_free_call(call_t *call, bool selflocked)
 {
         answerbox_t *callerbox = call->callerbox;
+        bool do_lock = ((!selflocked) || callerbox != (&TASK->answerbox));
 
         call->flags |= IPC_CALL_ANSWERED;
@@ -226 +228 @@
         }
 
-        spinlock_lock(&callerbox->lock);
+        if (do_lock)
+                spinlock_lock(&callerbox->lock);
         list_append(&call->link, &callerbox->answers);
-        spinlock_unlock(&callerbox->lock);
+        if (do_lock)
+                spinlock_unlock(&callerbox->lock);
         waitq_wakeup(&callerbox->wq, WAKEUP_FIRST);
 }
@@ -244 +248 @@
         spinlock_unlock(&box->lock);
         /* Send back answer */
-        _ipc_answer_free_call(call);
+        _ipc_answer_free_call(call, false);
 }
 
@@ -261 +265 @@
         atomic_inc(&phone->active_calls);
         IPC_SET_RETVAL(call->data, err);
-        _ipc_answer_free_call(call);
+        _ipc_answer_free_call(call, false);
 }
 
@@ -300 +304 @@
                 if (call->flags & IPC_CALL_FORWARDED) {
                         IPC_SET_RETVAL(call->data, EFORWARD);
-                        _ipc_answer_free_call(call);
+                        _ipc_answer_free_call(call, false);
                 } else {
                         if (phone->state == IPC_PHONE_HUNGUP)
@@ -455 +459 @@
 
                 IPC_SET_RETVAL(call->data, EHANGUP);
-                _ipc_answer_free_call(call);
+                _ipc_answer_free_call(call, true);
         }
 }

kernel/generic/src/mm/as.c

@@ -1920 +1920 @@
 }
 
+/** Get list of adress space areas.
+ *
+ * @param as            Address space.
+ * @param obuf          Place to save pointer to returned buffer.
+ * @param osize         Place to save size of returned buffer.
+ */
+void as_get_area_info(as_t *as, as_area_info_t **obuf, size_t *osize)
+{
+        ipl_t ipl;
+        size_t area_cnt, area_idx, i;
+        link_t *cur;
+
+        as_area_info_t *info;
+        size_t isize;
+
+        ipl = interrupts_disable();
+        mutex_lock(&as->lock);
+
+        /* First pass, count number of areas. */
+
+        area_cnt = 0;
+
+        for (cur = as->as_area_btree.leaf_head.next;
+            cur != &as->as_area_btree.leaf_head; cur = cur->next) {
+                btree_node_t *node;
+
+                node = list_get_instance(cur, btree_node_t, leaf_link);
+                area_cnt += node->keys;
+        }
+
+        isize = area_cnt * sizeof(as_area_info_t);
+        info = malloc(isize, 0);
+
+        /* Second pass, record data. */
+
+        area_idx = 0;
+
+        for (cur = as->as_area_btree.leaf_head.next;
+            cur != &as->as_area_btree.leaf_head; cur = cur->next) {
+                btree_node_t *node;
+
+                node = list_get_instance(cur, btree_node_t, leaf_link);
+
+                for (i = 0; i < node->keys; i++) {
+                        as_area_t *area = node->value[i];
+
+                        ASSERT(area_idx < area_cnt);
+                        mutex_lock(&area->lock);
+
+                        info[area_idx].start_addr = area->base;
+                        info[area_idx].size = FRAMES2SIZE(area->pages);
+                        info[area_idx].flags = area->flags;
+                        ++area_idx;
+
+                        mutex_unlock(&area->lock);
+                }
+        }
+
+        mutex_unlock(&as->lock);
+        interrupts_restore(ipl);
+
+        *obuf = info;
+        *osize = isize;
+}
+
+
 /** Print out information about address space.
  *

kernel/generic/src/udebug/udebug.c

@@ -69 +69 @@
         mutex_initialize(&ut->lock, MUTEX_PASSIVE);
         waitq_initialize(&ut->go_wq);
+        condvar_initialize(&ut->active_cv);
 
         ut->go_call = NULL;
@@ -446 +447 @@
                                 waitq_wakeup(&t->udebug.go_wq, WAKEUP_FIRST);
                         }
+                        mutex_unlock(&t->udebug.lock);
+                        condvar_broadcast(&t->udebug.active_cv);
+                } else {
+                        mutex_unlock(&t->udebug.lock);
                 }
-                mutex_unlock(&t->udebug.lock);
         }
 
@@ -456 +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

@@ -41 +41 @@
 #include <proc/task.h>
 #include <proc/thread.h>
+#include <mm/as.h>
 #include <arch.h>
 #include <errno.h>
@@ -165 +166 @@
 static void udebug_receive_thread_read(call_t *call)
 {
+        uintptr_t uspace_addr;
+        size_t buf_size;
+        void *buffer;
+        size_t copied, needed;
+        int rc;
+
+        uspace_addr = IPC_GET_ARG2(call->data); /* Destination address */
+        buf_size = IPC_GET_ARG3(call->data);    /* Dest. buffer size */
+
+        /*
+         * Read thread list. Variable n will be filled with actual number
+         * of threads times thread-id size.
+         */
+        rc = udebug_thread_read(&buffer, buf_size, &copied, &needed);
+        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
+         */
+
+        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, copied);
+        IPC_SET_ARG3(call->data, needed);
+        call->buffer = buffer;
+
+        ipc_answer(&TASK->kb.box, 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;
         unative_t to_copy;
-        unsigned total_bytes;
-        unsigned buf_size;
-        void *buffer;
-        size_t n;
-        int rc;
+        size_t data_size;
+        size_t buf_size;
+        void *data;
 
         uspace_addr = IPC_GET_ARG2(call->data); /* Destination address */
@@ -177 +220 @@
 
         /*
-         * Read thread list. Variable n will be filled with actual number
-         * of threads times thread-id size.
-         */
-        rc = udebug_thread_read(&buffer, buf_size, &n);
-        if (rc < 0) {
-                IPC_SET_RETVAL(call->data, rc);
-                ipc_answer(&TASK->kb.box, call);
-                return;
-        }
-
-        total_bytes = n;
-
-        /* Copy MAX(buf_size, total_bytes) bytes */
-
-        if (buf_size > total_bytes)
-                to_copy = total_bytes;
+         * Read task name.
+         */
+        udebug_name_read((char **) &data, &data_size);
+
+        /* Copy MAX(buf_size, data_size) bytes */
+
+        if (buf_size > data_size)
+                to_copy = data_size;
         else
                 to_copy = buf_size;
@@ -207 +242 @@
         IPC_SET_ARG2(call->data, to_copy);
 
-        IPC_SET_ARG3(call->data, total_bytes);
-        call->buffer = buffer;
-
-        ipc_answer(&TASK->kb.box, call);
-}
+        IPC_SET_ARG3(call->data, data_size);
+        call->buffer = data;
+
+        ipc_answer(&TASK->kb.box, call);
+}
+
+/** 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.
@@ -250 +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.
@@ -331 +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);
+                break;
         case UDEBUG_M_ARGS_READ:
                 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>
@@ -209 +210 @@
 
                 mutex_lock(&t->udebug.lock);
-                if ((t->flags & THREAD_FLAG_USPACE) != 0)
+                if ((t->flags & THREAD_FLAG_USPACE) != 0) {
                         t->udebug.active = true;
-                mutex_unlock(&t->udebug.lock);
+                        mutex_unlock(&t->udebug.lock);
+                        condvar_broadcast(&t->udebug.active_cv);
+                } else {
+                        mutex_unlock(&t->udebug.lock);
+                }
         }
 
@@ -355 +360 @@
  *
  * If the sequence is longer than @a buf_size bytes, only as much hashes
- * as can fit are copied. The number of thread hashes copied is stored
- * in @a n.
+ * as can fit are copied. The number of bytes copied is stored in @a stored.
+ * The total number of thread bytes that could have been saved had there been
+ * enough space is stored in @a needed.
  *
  * The rationale for having @a buf_size is that this function is only
@@ -364 +370 @@
  * @param buffer        The buffer for storing thread hashes.
  * @param buf_size      Buffer size in bytes.
- * @param n             The actual number of hashes copied will be stored here.
- */
-int udebug_thread_read(void **buffer, size_t buf_size, size_t *n)
+ * @param stored        The actual number of bytes copied will be stored here.
+ * @param needed        Total number of hashes that could have been saved.
+ */
+int udebug_thread_read(void **buffer, size_t buf_size, size_t *stored,
+    size_t *needed)
 {
         thread_t *t;
         link_t *cur;
         unative_t tid;
-        unsigned copied_ids;
+        size_t copied_ids;
+        size_t extra_ids;
         ipl_t ipl;
         unative_t *id_buffer;
@@ -380 +389 @@
 
         /* Allocate a buffer to hold thread IDs */
-        id_buffer = malloc(buf_size, 0);
+        id_buffer = malloc(buf_size + 1, 0);
 
         mutex_lock(&TASK->udebug.lock);
@@ -396 +405 @@
         max_ids = buf_size / sizeof(unative_t);
         copied_ids = 0;
+        extra_ids = 0;
 
         /* FIXME: make sure the thread isn't past debug shutdown... */
         for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
-                /* Do not write past end of buffer */
-                if (copied_ids >= max_ids) break;
-
                 t = list_get_instance(cur, thread_t, th_link);
 
@@ -409 +416 @@
 
                 /* Not interested in kernel threads. */
-                if ((flags & THREAD_FLAG_USPACE) != 0) {
+                if ((flags & THREAD_FLAG_USPACE) == 0)
+                        continue;
+
+                if (copied_ids < max_ids) {
                         /* Using thread struct pointer as identification hash */
                         tid = (unative_t) t;
                         id_buffer[copied_ids++] = tid;
+                } else {
+                        extra_ids++;
                 }
         }
@@ -422 +434 @@
 
         *buffer = id_buffer;
-        *n = copied_ids * sizeof(unative_t);
+        *stored = copied_ids * sizeof(unative_t);
+        *needed = (copied_ids + extra_ids) * sizeof(unative_t);
+
+        return 0;
+}
+
+/** 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;
@@ -437 +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)
@@ -469 +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.
  *