Index: kernel/generic/src/udebug/udebug_ops.c =================================================================== --- kernel/generic/src/udebug/udebug_ops.c (revision 19f857a3b361739b06d4f547174ae4ac1b99c651) +++ kernel/generic/src/udebug/udebug_ops.c (revision be3f94cc9353d7054d4a674904c7150a2206f504) @@ -33,5 +33,5 @@ /** * @file - * @brief Udebug operations. + * @brief Udebug operations. * * Udebug operations on tasks and threads are implemented here. The @@ -39,5 +39,5 @@ * when servicing udebug IPC messages. */ - + #include #include @@ -53,6 +53,5 @@ #include -/** - * Prepare a thread for a debugging operation. +/** Prepare a thread for a debugging operation. * * Simply put, return thread t with t->udebug.lock held, @@ -73,89 +72,84 @@ * the t->lock spinlock to the t->udebug.lock mutex. * - * @param t Pointer, need not at all be valid. - * @param being_go Required thread state. + * @param thread Pointer, need not at all be valid. + * @param being_go Required thread state. * * Returns EOK if all went well, or an error code otherwise. - */ -static int _thread_op_begin(thread_t *t, bool being_go) -{ - ipl_t ipl; - - mutex_lock(&TASK->udebug.lock); - + * + */ +static int _thread_op_begin(thread_t *thread, bool being_go) +{ + mutex_lock(&TASK->udebug.lock); + /* thread_exists() must be called with threads_lock held */ - ipl = interrupts_disable(); - spinlock_lock(&threads_lock); - - if (!thread_exists(t)) { - spinlock_unlock(&threads_lock); - interrupts_restore(ipl); + irq_spinlock_lock(&threads_lock, true); + + if (!thread_exists(thread)) { + irq_spinlock_unlock(&threads_lock, true); mutex_unlock(&TASK->udebug.lock); return ENOENT; } - - /* t->lock is enough to ensure the thread's existence */ - spinlock_lock(&t->lock); - spinlock_unlock(&threads_lock); - - /* Verify that 't' is a userspace thread. */ - if ((t->flags & THREAD_FLAG_USPACE) == 0) { + + /* thread->lock is enough to ensure the thread's existence */ + irq_spinlock_exchange(&threads_lock, &thread->lock); + + /* Verify that 'thread' is a userspace thread. */ + if ((thread->flags & THREAD_FLAG_USPACE) == 0) { /* It's not, deny its existence */ - spinlock_unlock(&t->lock); - interrupts_restore(ipl); + irq_spinlock_unlock(&thread->lock, true); mutex_unlock(&TASK->udebug.lock); return ENOENT; } - + /* Verify debugging state. */ - if (t->udebug.active != true) { + if (thread->udebug.active != true) { /* Not in debugging session or undesired GO state */ - spinlock_unlock(&t->lock); - interrupts_restore(ipl); + irq_spinlock_unlock(&thread->lock, true); mutex_unlock(&TASK->udebug.lock); return ENOENT; } - + /* * Since the thread has active == true, TASK->udebug.lock * is enough to ensure its existence and that active remains * true. + * */ - spinlock_unlock(&t->lock); - interrupts_restore(ipl); - + irq_spinlock_unlock(&thread->lock, true); + /* Only mutex TASK->udebug.lock left. */ /* Now verify that the thread belongs to the current task. */ - if (t->task != TASK) { + if (thread->task != TASK) { /* No such thread belonging this task*/ mutex_unlock(&TASK->udebug.lock); return ENOENT; } - + /* * Now we need to grab the thread's debug lock for synchronization * of the threads stoppability/stop state. + * */ - mutex_lock(&t->udebug.lock); - + mutex_lock(&thread->udebug.lock); + /* The big task mutex is no longer needed. */ mutex_unlock(&TASK->udebug.lock); - - if (t->udebug.go != being_go) { + + if (thread->udebug.go != being_go) { /* Not in debugging session or undesired GO state. */ - mutex_unlock(&t->udebug.lock); + mutex_unlock(&thread->udebug.lock); return EINVAL; } - - /* Only t->udebug.lock left. */ - - return EOK; /* All went well. */ + + /* Only thread->udebug.lock left. */ + + return EOK; /* All went well. */ } /** End debugging operation on a thread. */ -static void _thread_op_end(thread_t *t) -{ - mutex_unlock(&t->udebug.lock); +static void _thread_op_end(thread_t *thread) +{ + mutex_unlock(&thread->udebug.lock); } @@ -171,49 +165,48 @@ * 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. + * @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) { - int reply; - - thread_t *t; - link_t *cur; - - LOG("Debugging task %llu", TASK->taskid); - mutex_lock(&TASK->udebug.lock); - + LOG("Debugging task %" PRIu64, TASK->taskid); + + mutex_lock(&TASK->udebug.lock); + if (TASK->udebug.dt_state != UDEBUG_TS_INACTIVE) { mutex_unlock(&TASK->udebug.lock); return EBUSY; } - + TASK->udebug.dt_state = UDEBUG_TS_BEGINNING; TASK->udebug.begin_call = call; TASK->udebug.debugger = call->sender; - + + int reply; + if (TASK->udebug.not_stoppable_count == 0) { TASK->udebug.dt_state = UDEBUG_TS_ACTIVE; TASK->udebug.begin_call = NULL; - reply = 1; /* immediate reply */ - } else { - reply = 0; /* no reply */ - } + reply = 1; /* immediate reply */ + } else + reply = 0; /* no reply */ /* Set udebug.active on all of the task's userspace threads. */ - + + link_t *cur; for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) { - t = list_get_instance(cur, thread_t, th_link); - - mutex_lock(&t->udebug.lock); - if ((t->flags & THREAD_FLAG_USPACE) != 0) { - t->udebug.active = true; - mutex_unlock(&t->udebug.lock); - condvar_broadcast(&t->udebug.active_cv); - } else { - mutex_unlock(&t->udebug.lock); - } - } - + thread_t *thread = list_get_instance(cur, thread_t, th_link); + + mutex_lock(&thread->udebug.lock); + if ((thread->flags & THREAD_FLAG_USPACE) != 0) { + thread->udebug.active = true; + mutex_unlock(&thread->udebug.lock); + condvar_broadcast(&thread->udebug.active_cv); + } else + mutex_unlock(&thread->udebug.lock); + } + mutex_unlock(&TASK->udebug.lock); return reply; @@ -223,16 +216,16 @@ * * Closes the debugging session for the current task. + * * @return Zero on success or negative error code. + * */ int udebug_end(void) { - int rc; - LOG("Task %" PRIu64, TASK->taskid); - - mutex_lock(&TASK->udebug.lock); - rc = udebug_task_cleanup(TASK); - mutex_unlock(&TASK->udebug.lock); - + + mutex_lock(&TASK->udebug.lock); + int rc = udebug_task_cleanup(TASK); + mutex_unlock(&TASK->udebug.lock); + return rc; } @@ -242,21 +235,23 @@ * 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. + * @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) { LOG("mask = 0x%x", mask); - - mutex_lock(&TASK->udebug.lock); - + + mutex_lock(&TASK->udebug.lock); + if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) { mutex_unlock(&TASK->udebug.lock); return EINVAL; } - + TASK->udebug.evmask = mask; mutex_unlock(&TASK->udebug.lock); - + return 0; } @@ -268,28 +263,27 @@ * 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; - - /* On success, this will lock t->udebug.lock. */ - rc = _thread_op_begin(t, false); - if (rc != EOK) { + * @param thread 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 *thread, call_t *call) +{ + /* On success, this will lock thread->udebug.lock. */ + int rc = _thread_op_begin(thread, false); + if (rc != EOK) return rc; - } - - t->udebug.go_call = call; - t->udebug.go = true; - t->udebug.cur_event = 0; /* none */ - + + thread->udebug.go_call = call; + thread->udebug.go = true; + thread->udebug.cur_event = 0; /* none */ + /* - * Neither t's lock nor threads_lock may be held during wakeup. + * Neither thread's lock nor threads_lock may be held during wakeup. + * */ - waitq_wakeup(&t->udebug.go_wq, WAKEUP_FIRST); - - _thread_op_end(t); - + waitq_wakeup(&thread->udebug.go_wq, WAKEUP_FIRST); + + _thread_op_end(thread); + return 0; } @@ -300,50 +294,50 @@ * 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; - + * @param thread 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 *thread, call_t *call) +{ LOG("udebug_stop()"); - + /* - * On success, this will lock t->udebug.lock. Note that this makes sure - * the thread is not stopped. + * On success, this will lock thread->udebug.lock. Note that this + * makes sure the thread is not stopped. + * */ - rc = _thread_op_begin(t, true); - if (rc != EOK) { + int rc = _thread_op_begin(thread, true); + if (rc != EOK) return rc; - } - + /* Take GO away from the thread. */ - t->udebug.go = false; - - if (t->udebug.stoppable != true) { + thread->udebug.go = false; + + if (thread->udebug.stoppable != true) { /* Answer will be sent when the thread becomes stoppable. */ - _thread_op_end(t); + _thread_op_end(thread); return 0; } - + /* * Answer GO call. + * */ - + /* Make sure nobody takes this call away from us. */ - call = t->udebug.go_call; - t->udebug.go_call = NULL; - + call = thread->udebug.go_call; + thread->udebug.go_call = NULL; + IPC_SET_RETVAL(call->data, 0); IPC_SET_ARG1(call->data, UDEBUG_EVENT_STOP); - + THREAD->udebug.cur_event = UDEBUG_EVENT_STOP; - - _thread_op_end(t); - + + _thread_op_end(thread); + mutex_lock(&TASK->udebug.lock); ipc_answer(&TASK->answerbox, call); mutex_unlock(&TASK->udebug.lock); - + return 0; } @@ -365,29 +359,20 @@ * a maximum size for the userspace buffer. * - * @param buffer The buffer for storing thread hashes. - * @param buf_size Buffer size in bytes. - * @param stored The actual number of bytes copied will be stored here. - * @param needed Total number of hashes that could have been saved. + * @param buffer The buffer for storing thread hashes. + * @param buf_size Buffer size in bytes. + * @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; - size_t copied_ids; - size_t extra_ids; - ipl_t ipl; - unative_t *id_buffer; - int flags; - size_t max_ids; - LOG("udebug_thread_read()"); - + /* Allocate a buffer to hold thread IDs */ - id_buffer = malloc(buf_size + 1, 0); - - mutex_lock(&TASK->udebug.lock); - + unative_t *id_buffer = malloc(buf_size + 1, 0); + + mutex_lock(&TASK->udebug.lock); + /* Verify task state */ if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) { @@ -395,43 +380,41 @@ return EINVAL; } - - ipl = interrupts_disable(); - spinlock_lock(&TASK->lock); + + irq_spinlock_lock(&TASK->lock, true); + /* Copy down the thread IDs */ - - max_ids = buf_size / sizeof(unative_t); - copied_ids = 0; - extra_ids = 0; - + + size_t max_ids = buf_size / sizeof(unative_t); + size_t copied_ids = 0; + size_t extra_ids = 0; + /* FIXME: make sure the thread isn't past debug shutdown... */ + link_t *cur; for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) { - t = list_get_instance(cur, thread_t, th_link); - - spinlock_lock(&t->lock); - flags = t->flags; - spinlock_unlock(&t->lock); - + thread_t *thread = list_get_instance(cur, thread_t, th_link); + + irq_spinlock_lock(&thread->lock, false); + int flags = thread->flags; + irq_spinlock_unlock(&thread->lock, false); + /* Not interested in kernel threads. */ 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 { + id_buffer[copied_ids++] = (unative_t) thread; + } else extra_ids++; - } - } - - spinlock_unlock(&TASK->lock); - interrupts_restore(ipl); - - mutex_unlock(&TASK->udebug.lock); - + } + + irq_spinlock_unlock(&TASK->lock, true); + + mutex_unlock(&TASK->udebug.lock); + *buffer = id_buffer; *stored = copied_ids * sizeof(unative_t); *needed = (copied_ids + extra_ids) * sizeof(unative_t); - + return 0; } @@ -442,19 +425,19 @@ * 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. + * @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; + size_t name_size = str_size(TASK->name) + 1; + *data = malloc(name_size, 0); *data_size = name_size; - + memcpy(*data, TASK->name, name_size); - + return 0; } @@ -470,35 +453,33 @@ * this function will fail with an EINVAL error code. * - * @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) -{ - int rc; - unative_t *arg_buffer; - + * @param thread 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 *thread, void **buffer) +{ /* Prepare a buffer to hold the arguments. */ - arg_buffer = malloc(6 * sizeof(unative_t), 0); - + unative_t *arg_buffer = malloc(6 * sizeof(unative_t), 0); + /* On success, this will lock t->udebug.lock. */ - rc = _thread_op_begin(t, false); - if (rc != EOK) { + int rc = _thread_op_begin(thread, false); + if (rc != EOK) return rc; - } - + /* Additionally we need to verify that we are inside a syscall. */ - if (t->udebug.cur_event != UDEBUG_EVENT_SYSCALL_B && - t->udebug.cur_event != UDEBUG_EVENT_SYSCALL_E) { - _thread_op_end(t); + if ((thread->udebug.cur_event != UDEBUG_EVENT_SYSCALL_B) && + (thread->udebug.cur_event != UDEBUG_EVENT_SYSCALL_E)) { + _thread_op_end(thread); return EINVAL; } - + /* Copy to a local buffer before releasing the lock. */ - memcpy(arg_buffer, t->udebug.syscall_args, 6 * sizeof(unative_t)); - - _thread_op_end(t); - + memcpy(arg_buffer, thread->udebug.syscall_args, 6 * sizeof(unative_t)); + + _thread_op_end(thread); + *buffer = arg_buffer; return 0; @@ -514,35 +495,33 @@ * 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; - + * @param thread 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 *thread, void **buffer) +{ /* Prepare a buffer to hold the data. */ - state_buf = malloc(sizeof(istate_t), 0); - + istate_t *state_buf = malloc(sizeof(istate_t), 0); + /* On success, this will lock t->udebug.lock */ - rc = _thread_op_begin(t, false); - if (rc != EOK) { + int rc = _thread_op_begin(thread, false); + if (rc != EOK) return rc; - } - - state = t->udebug.uspace_state; + + istate_t *state = thread->udebug.uspace_state; if (state == NULL) { - _thread_op_end(t); + _thread_op_end(thread); return EBUSY; } - + /* Copy to the allocated buffer */ memcpy(state_buf, state, sizeof(istate_t)); - - _thread_op_end(t); - + + _thread_op_end(thread); + *buffer = (void *) state_buf; return 0; @@ -555,30 +534,32 @@ * 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. + * @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; - int rc; - /* Verify task state */ mutex_lock(&TASK->udebug.lock); - + if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) { mutex_unlock(&TASK->udebug.lock); return EBUSY; } - - data_buffer = malloc(n, 0); - - /* 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); - mutex_unlock(&TASK->udebug.lock); - - if (rc != 0) return rc; - + + void *data_buffer = malloc(n, 0); + + /* + * NOTE: this is not strictly from a syscall... but that shouldn't + * be a problem + * + */ + int rc = copy_from_uspace(data_buffer, (void *) uspace_addr, n); + mutex_unlock(&TASK->udebug.lock); + + if (rc != 0) + return rc; + *buffer = data_buffer; return 0;