33,9 → 33,13 |
/** |
* @file |
* @brief Udebug operations. |
* |
* Udebug operations on tasks and threads are implemented here. The |
* functions defined here are called from the udebug_ipc module |
* when servicing udebug IPC messages. |
*/ |
|
#include <print.h> |
#include <debug.h> |
#include <proc/task.h> |
#include <proc/thread.h> |
#include <arch.h> |
65,6 → 69,9 |
* thread from leaving the debugging session, while relaxing from |
* the t->lock spinlock to the t->udebug.lock mutex. |
* |
* @param t Pointer, need not at all be valid. |
* @param having_go Required thread state. |
* |
* Returns EOK if all went well, or an error code otherwise. |
*/ |
static int _thread_op_begin(thread_t *t, bool having_go) |
146,14 → 153,25 |
return EOK; /* All went well */ |
} |
|
|
/** End debugging operation on a thread. */ |
static void _thread_op_end(thread_t *t) |
{ |
mutex_unlock(&t->udebug.lock); |
} |
|
/** |
* \return 0 (ok, but not done yet), 1 (done) or negative error code. |
/** Begin debugging the current task. |
* |
* Initiates a debugging session for the current task (and its threads). |
* When the debugging session has started a reply will be sent to the |
* UDEBUG_BEGIN call. This may happen immediately in this function if |
* all the threads in this task are stoppable at the moment and in this |
* case the function returns 1. |
* |
* Otherwise the function returns 0 and the reply will be sent as soon as |
* all the threads become stoppable (i.e. they can be considered stopped). |
* |
* @param call The BEGIN call we are servicing. |
* @return 0 (OK, but not done yet), 1 (done) or negative error code. |
*/ |
int udebug_begin(call_t *call) |
{ |
162,14 → 180,14 |
thread_t *t; |
link_t *cur; |
|
printf("udebug_begin()\n"); |
LOG("udebug_begin()\n"); |
|
mutex_lock(&TASK->udebug.lock); |
printf("debugging task %llu\n", TASK->taskid); |
LOG("debugging task %llu\n", TASK->taskid); |
|
if (TASK->udebug.dt_state != UDEBUG_TS_INACTIVE) { |
mutex_unlock(&TASK->udebug.lock); |
printf("udebug_begin(): busy error\n"); |
LOG("udebug_begin(): busy error\n"); |
|
return EBUSY; |
} |
199,20 → 217,25 |
|
mutex_unlock(&TASK->udebug.lock); |
|
printf("udebug_begin() done (%s)\n", |
LOG("udebug_begin() done (%s)\n", |
reply ? "reply" : "stoppability wait"); |
|
return reply; |
} |
|
/** Finish debugging the current task. |
* |
* Closes the debugging session for the current task. |
* @return Zero on success or negative error code. |
*/ |
int udebug_end(void) |
{ |
int rc; |
|
printf("udebug_end()\n"); |
LOG("udebug_end()\n"); |
|
mutex_lock(&TASK->udebug.lock); |
printf("task %llu\n", TASK->taskid); |
LOG("task %" PRIu64 "\n", TASK->taskid); |
|
rc = udebug_task_cleanup(TASK); |
|
221,17 → 244,22 |
return rc; |
} |
|
/** Set the event mask. |
* |
* Sets the event mask that determines which events are enabled. |
* |
* @param mask Or combination of events that should be enabled. |
* @return Zero on success or negative error code. |
*/ |
int udebug_set_evmask(udebug_evmask_t mask) |
{ |
printf("udebug_set_mask()\n"); |
LOG("udebug_set_mask()\n"); |
|
printf("debugging task %llu\n", TASK->taskid); |
|
mutex_lock(&TASK->udebug.lock); |
|
if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) { |
mutex_unlock(&TASK->udebug.lock); |
printf("udebug_set_mask(): not active debuging session\n"); |
LOG("udebug_set_mask(): not active debuging session\n"); |
|
return EINVAL; |
} |
243,13 → 271,19 |
return 0; |
} |
|
|
/** Give thread GO. |
* |
* Upon recieving a go message, the thread is given GO. Having GO |
* means the thread is allowed to execute userspace code (until |
* a debugging event or STOP occurs, at which point the thread loses GO. |
* |
* @param t The thread to operate on (unlocked and need not be valid). |
* @param call The GO call that we are servicing. |
*/ |
int udebug_go(thread_t *t, call_t *call) |
{ |
int rc; |
|
// printf("udebug_go()\n"); |
|
/* On success, this will lock t->udebug.lock */ |
rc = _thread_op_begin(t, false); |
if (rc != EOK) { |
270,11 → 304,19 |
return 0; |
} |
|
/** Stop a thread (i.e. take its GO away) |
* |
* Generates a STOP event as soon as the thread becomes stoppable (i.e. |
* can be considered stopped). |
* |
* @param t The thread to operate on (unlocked and need not be valid). |
* @param call The GO call that we are servicing. |
*/ |
int udebug_stop(thread_t *t, call_t *call) |
{ |
int rc; |
|
printf("udebug_stop()\n"); |
LOG("udebug_stop()\n"); |
mutex_lock(&TASK->udebug.lock); |
|
/* |
298,7 → 340,7 |
/* |
* Answer GO call |
*/ |
printf("udebug_stop - answering go call\n"); |
LOG("udebug_stop - answering go call\n"); |
|
/* Make sure nobody takes this call away from us */ |
call = t->udebug.go_call; |
306,7 → 348,7 |
|
IPC_SET_RETVAL(call->data, 0); |
IPC_SET_ARG1(call->data, UDEBUG_EVENT_STOP); |
printf("udebug_stop/ipc_answer\n"); |
LOG("udebug_stop/ipc_answer\n"); |
|
THREAD->udebug.cur_event = UDEBUG_EVENT_STOP; |
|
315,10 → 357,29 |
ipc_answer(&TASK->answerbox, call); |
mutex_unlock(&TASK->udebug.lock); |
|
printf("udebog_stop/done\n"); |
LOG("udebog_stop/done\n"); |
return 0; |
} |
|
/** Read the list of userspace threads in the current task. |
* |
* The list takes the form of a sequence of thread hashes (i.e. the pointers |
* to thread structures). A buffer of size @a buf_size is allocated and |
* a pointer to it written to @a buffer. The sequence of hashes is written |
* into this buffer. |
* |
* 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. |
* |
* The rationale for having @a buf_size is that this function is only |
* used for servicing the THREAD_READ message, which always specifies |
* a maximum size for the userspace buffer. |
* |
* @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) |
{ |
thread_t *t; |
330,7 → 391,7 |
int flags; |
size_t max_ids; |
|
printf("udebug_thread_read()\n"); |
LOG("udebug_thread_read()\n"); |
|
/* Allocate a buffer to hold thread IDs */ |
id_buffer = malloc(buf_size, 0); |
380,13 → 441,23 |
return 0; |
} |
|
/** Read the arguments of a system call. |
* |
* The arguments of the system call being being executed are copied |
* to an allocated buffer and a pointer to it is written to @a buffer. |
* The size of the buffer is exactly such that it can hold the maximum number |
* of system-call arguments. |
* |
* Unless the thread is currently blocked in a SYSCALL_B or SYSCALL_E event, |
* this function will fail with an EINVAL error code. |
* |
* @param buffer The buffer for storing thread hashes. |
*/ |
int udebug_args_read(thread_t *t, void **buffer) |
{ |
int rc; |
unative_t *arg_buffer; |
|
// printf("udebug_args_read()\n"); |
|
/* Prepare a buffer to hold the arguments */ |
arg_buffer = malloc(6 * sizeof(unative_t), 0); |
|
470,7 → 541,16 |
return 0; |
} |
|
|
/** Read the memory of the debugged task. |
* |
* Reads @a n bytes from the address space of the debugged task, starting |
* from @a uspace_addr. The bytes are copied into an allocated buffer |
* and a pointer to it is written into @a buffer. |
* |
* @param uspace_addr Address from where to start reading. |
* @param n Number of bytes to read. |
* @param buffer For storing a pointer to the allocated buffer. |
*/ |
int udebug_mem_read(unative_t uspace_addr, size_t n, void **buffer) |
{ |
void *data_buffer; |
486,8 → 566,6 |
|
data_buffer = malloc(n, 0); |
|
// printf("udebug_mem_read: src=%u, size=%u\n", uspace_addr, n); |
|
/* NOTE: this is not strictly from a syscall... but that shouldn't |
* be a problem */ |
rc = copy_from_uspace(data_buffer, (void *)uspace_addr, n); |