Index: kernel/generic/include/ipc/ipc.h =================================================================== --- kernel/generic/include/ipc/ipc.h (revision 27526e87a5c2020cd438d3e19be5de74210bc73d) +++ kernel/generic/include/ipc/ipc.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) @@ -195,4 +195,10 @@ */ #define IPC_M_DATA_READ 7 + +/** Debug the recipient. + * - ARG1 - specifies the debug method (from udebug_method_t) + * - other arguments are specific to the debug method + */ +#define IPC_M_DEBUG_ALL 8 /* Well-known methods */ @@ -308,4 +314,6 @@ extern void ipc_backsend_err(phone_t *, call_t *, unative_t); extern void ipc_print_task(task_id_t); +extern void ipc_answerbox_slam_phones(answerbox_t *, bool); +extern void ipc_cleanup_call_list(link_t *); extern answerbox_t *ipc_phone_0; Index: kernel/generic/include/ipc/ipc_kbox.h =================================================================== --- kernel/generic/include/ipc/ipc_kbox.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) +++ kernel/generic/include/ipc/ipc_kbox.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2008 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#ifndef KERN_IPC_KBOX_H_ +#define KERN_IPC_KBOX_H_ + +#include + +extern int ipc_connect_kbox(task_id_t); +extern void ipc_kbox_cleanup(void); + +#endif + +/** @} + */ Index: kernel/generic/include/ipc/sysipc.h =================================================================== --- kernel/generic/include/ipc/sysipc.h (revision 27526e87a5c2020cd438d3e19be5de74210bc73d) +++ kernel/generic/include/ipc/sysipc.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) @@ -58,4 +58,5 @@ irq_code_t *ucode); unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno); +unative_t sys_ipc_connect_kbox(sysarg64_t *task_id); #endif Index: kernel/generic/include/proc/task.h =================================================================== --- kernel/generic/include/proc/task.h (revision 27526e87a5c2020cd438d3e19be5de74210bc73d) +++ kernel/generic/include/proc/task.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) @@ -53,4 +53,5 @@ #include #include +#include struct thread; @@ -94,4 +95,18 @@ */ atomic_t active_calls; + +#ifdef CONFIG_UDEBUG + /** Debugging stuff */ + udebug_task_t udebug; + + /** Kernel answerbox */ + answerbox_t kernel_box; + /** Thread used to service kernel answerbox */ + struct thread *kb_thread; + /** Kbox thread creation vs. begin of cleanup mutual exclusion */ + mutex_t kb_cleanup_lock; + /** True if cleanup of kbox has already started */ + bool kb_finished; +#endif /** Architecture specific task data. */ Index: kernel/generic/include/proc/thread.h =================================================================== --- kernel/generic/include/proc/thread.h (revision 27526e87a5c2020cd438d3e19be5de74210bc73d) +++ kernel/generic/include/proc/thread.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) @@ -47,4 +47,5 @@ #include #include +#include #define THREAD_STACK_SIZE STACK_SIZE @@ -204,4 +205,10 @@ /** Thread's kernel stack. */ uint8_t *kstack; + +#ifdef CONFIG_UDEBUG + /** Debugging stuff */ + udebug_thread_t udebug; +#endif + } thread_t; Index: kernel/generic/include/syscall/syscall.h =================================================================== --- kernel/generic/include/syscall/syscall.h (revision 27526e87a5c2020cd438d3e19be5de74210bc73d) +++ kernel/generic/include/syscall/syscall.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) @@ -79,4 +79,5 @@ SYS_DEBUG_ENABLE_CONSOLE, + SYS_IPC_CONNECT_KBOX, SYSCALL_END } syscall_t; Index: kernel/generic/include/udebug/udebug.h =================================================================== --- kernel/generic/include/udebug/udebug.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) +++ kernel/generic/include/udebug/udebug.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) @@ -0,0 +1,218 @@ +/* + * Copyright (c) 2008 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup generic + * @{ + */ +/** @file + */ + +#ifndef KERN_UDEBUG_H_ +#define KERN_UDEBUG_H_ + +#include + +typedef enum { /* udebug_method_t */ + +/** Start debugging the recipient. + * Causes all threads in the receiving task to stop. When they + * are all stoped, an answer with retval 0 is generated. + */ +UDEBUG_M_BEGIN = 1, + +/** Finish debugging the recipient. + * Answers all pending GO and GUARD messages. + */ +UDEBUG_M_END, + +/** Set which events should be captured. + */ +UDEBUG_M_SET_EVMASK, + +/** Make sure the debugged task is still there. + * This message is answered when the debugged task dies + * or the debugging session ends. + */ +UDEBUG_M_GUARD, + +/** Run a thread until a debugging event occurs. + * This message is answered when the thread stops + * in a debugging event. + * + * - ARG2 - id of the thread to run + */ +UDEBUG_M_GO, + +/** Stop a thread being debugged. + * Creates a special STOP event in the thread, causing + * it to answer a pending GO message (if any). + */ +UDEBUG_M_STOP, + +/** Read arguments of a syscall. + * + * - ARG2 - thread identification + * - ARG3 - destination address in the caller's address space + * + */ +UDEBUG_M_ARGS_READ, + +/** Read the list of the debugged tasks's threads. + * + * - ARG2 - destination address in the caller's address space + * - ARG3 - size of receiving buffer in bytes + * + * The kernel fills the buffer with a series of sysarg_t values + * (thread ids). On answer, the kernel will set: + * + * - ARG2 - number of bytes that were actually copied + * - ARG3 - number of bytes of the complete data + * + */ +UDEBUG_M_THREAD_READ, + +/** Read the debugged tasks's memory. + * + * - ARG2 - destination address in the caller's address space + * - ARG3 - source address in the recipient's address space + * - ARG4 - size of receiving buffer in bytes + * + */ +UDEBUG_M_MEM_READ, + +} udebug_method_t; + + +typedef enum { + UDEBUG_EVENT_FINISHED = 1, /**< Debuging session has finished */ + UDEBUG_EVENT_STOP, /**< Stopped on DEBUG_STOP request */ + UDEBUG_EVENT_SYSCALL_B, /**< Before beginning syscall execution */ + UDEBUG_EVENT_SYSCALL_E, /**< After finishing syscall execution */ + UDEBUG_EVENT_THREAD_B, /**< The task created a new thread */ + UDEBUG_EVENT_THREAD_E /**< A thread exited */ +} udebug_event_t; + +#define UDEBUG_EVMASK(event) (1 << ((event) - 1)) + +typedef enum { + UDEBUG_EM_FINISHED = UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED), + UDEBUG_EM_STOP = UDEBUG_EVMASK(UDEBUG_EVENT_STOP), + UDEBUG_EM_SYSCALL_B = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B), + UDEBUG_EM_SYSCALL_E = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E), + UDEBUG_EM_THREAD_B = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B), + UDEBUG_EM_THREAD_E = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E), + UDEBUG_EM_ALL = + UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED) | + UDEBUG_EVMASK(UDEBUG_EVENT_STOP) | + UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B) | + UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E) | + UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B) | + UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E) +} udebug_evmask_t; + +#ifdef KERNEL + +#include +#include +#include + +typedef enum { + /** Task is not being debugged */ + UDEBUG_TS_INACTIVE, + /** BEGIN operation in progress (waiting for threads to stop) */ + UDEBUG_TS_BEGINNING, + /** Debugger fully connected */ + UDEBUG_TS_ACTIVE, + /** Task is shutting down, no more debug activities allowed */ + UDEBUG_TS_SHUTDOWN +} udebug_task_state_t; + +/** Debugging part of task_t structure. + */ +typedef struct { + /** Synchronize debug ops on this task / access to this structure */ + mutex_t lock; + char *lock_owner; + + udebug_task_state_t dt_state; + call_t *begin_call; + int not_stoppable_count; + struct task *debugger; + udebug_evmask_t evmask; +} udebug_task_t; + +/** Debugging part of thread_t structure. + */ +typedef struct { + /** + * Prevent deadlock with udebug_before_thread_runs() in interrupt + * handler, without actually disabling interrupts. + * ==0 means "unlocked", >0 means "locked" + */ + atomic_t int_lock; + + /** Synchronize debug ops on this thread / access to this structure */ + mutex_t lock; + + waitq_t go_wq; + call_t *go_call; + unative_t syscall_args[6]; + + /** What type of event are we stopped in or 0 if none */ + udebug_event_t cur_event; + bool stop; + bool stoppable; + bool debug_active; /**< In a debugging session */ +} udebug_thread_t; + +struct task; +struct thread; + +void udebug_task_init(udebug_task_t *ut); +void udebug_thread_initialize(udebug_thread_t *ut); + +void udebug_syscall_event(unative_t a1, unative_t a2, unative_t a3, + unative_t a4, unative_t a5, unative_t a6, unative_t id, unative_t rc, + bool end_variant); + +void udebug_thread_b_event(struct thread *t); +void udebug_thread_e_event(void); + +void udebug_stoppable_begin(void); +void udebug_stoppable_end(void); + +void udebug_before_thread_runs(void); + +int udebug_task_cleanup(struct task *ta); + +#endif + +#endif + +/** @} + */ Index: kernel/generic/include/udebug/udebug_ipc.h =================================================================== --- kernel/generic/include/udebug/udebug_ipc.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) +++ kernel/generic/include/udebug/udebug_ipc.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2008 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup generic + * @{ + */ +/** @file + */ + +#ifndef KERN_UDEBUG_IPC_H_ +#define KERN_UDEBUG_IPC_H_ + +#include + +int udebug_request_preprocess(call_t *call, phone_t *phone); +void udebug_call_receive(call_t *call); + + +#endif + +/** @} + */ Index: kernel/generic/include/udebug/udebug_ops.h =================================================================== --- kernel/generic/include/udebug/udebug_ops.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) +++ kernel/generic/include/udebug/udebug_ops.h (revision 164385528bfca082a12eee5e01b23c2c9a74acc5) @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2008 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup generic + * @{ + */ +/** @file + */ + +#ifndef KERN_UDEBUG_OPS_H_ +#define KERN_UDEBUG_OPS_H_ + +#include + +int udebug_begin(call_t *call); +int udebug_end(void); +int udebug_set_evmask(udebug_evmask_t mask); + +int udebug_go(thread_t *t, call_t *call); +int udebug_stop(thread_t *t, call_t *call); + +int udebug_thread_read(void **buffer, size_t buf_size, size_t *n); +int udebug_args_read(thread_t *t, void **buffer); + +int udebug_mem_read(unative_t uspace_addr, size_t n, void **buffer); + +#endif + +/** @} + */