| 503,5 → 503,155 |
|---|
| return 0; |
| } |
| |
| int udebug_thread_get_thread_struct(thread_t *t, void **buffer) |
| { |
| ipl_t ipl = interrupts_disable(); |
| |
| void *data_buffer = (void *)malloc(sizeof(thread_t), 0); |
| |
| memcpy(data_buffer, (void *)t, sizeof(thread_t)); |
| |
| *buffer = data_buffer; |
| |
| interrupts_restore(ipl); |
| |
| return (0); |
| } |
| |
| int udebug_task_get_memory_areas(void **buffer, size_t buf_size, size_t *n) |
| { |
| link_t *cur; |
| ipl_t ipl; |
| unative_t *areas_buffer; |
| size_t max_index; |
| |
| as_print(TASK->as); |
| |
| areas_buffer = malloc(buf_size, 0); |
| |
| mutex_lock(&TASK->udebug.lock); |
| |
| /* Verify task state */ |
| if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) { |
| mutex_unlock(&TASK->udebug.lock); |
| return EINVAL; |
| } |
| |
| ipl = interrupts_disable(); |
| spinlock_lock(&TASK->lock); |
| |
| max_index = buf_size / sizeof(unative_t); |
| as_t *as = TASK->as; |
| |
| mutex_lock(&as->lock); |
| |
| /* print out info about address space areas */ |
| unsigned int index = 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); |
| |
| unsigned int i; |
| for (i = 0; i < node->keys; i++) { |
| if (index >= max_index) |
| break; |
| |
| as_area_t *area = node->value[i]; |
| |
| mutex_lock(&area->lock); |
| areas_buffer[index++] = area->base; |
| areas_buffer[index++] = area->base + FRAMES2SIZE(area->pages); |
| mutex_unlock(&area->lock); |
| } |
| } |
| |
| mutex_unlock(&as->lock); |
| |
| spinlock_unlock(&TASK->lock); |
| interrupts_restore(ipl); |
| |
| mutex_unlock(&TASK->udebug.lock); |
| |
| *buffer = areas_buffer; |
| *n = (index) * sizeof(unative_t); |
| |
| return 0; |
| |
| } |
| |
| int udebug_copy_kstack(void *kstack, void **buffer, size_t n) |
| { |
| ipl_t ipl = interrupts_disable(); |
| |
| void *data_buffer = malloc(n, 0); |
| |
| memcpy(data_buffer, (void *)kstack, n); |
| |
| *buffer = data_buffer; |
| |
| interrupts_restore(ipl); |
| |
| return 0; |
| } |
| |
| int udebug_restore_thread_struct(void *buffer, thread_t *t_old) |
| { |
| ipl_t ipl = interrupts_disable(); |
| |
| thread_t *t_new = (thread_t *)buffer; |
| |
| t_old->thread_code = t_new->thread_code; |
| |
| printf("old sp: %p, new sp: %p\n", t_old->saved_context.sp, t_new->saved_context.sp); |
| printf("old kstack: %p, new kstack: %p\n", t_old->kstack, t_new->kstack); |
| |
| t_old->saved_context = t_new->saved_context; |
| t_old->saved_context.sp = (uintptr_t)t_old->kstack + ((uintptr_t)t_new->saved_context.sp - (uintptr_t)t_new->kstack); |
| |
| t_old->sleep_timeout_context = t_new->sleep_timeout_context; |
| t_old->sleep_timeout = t_new->sleep_timeout; |
| t_old->timeout_pending = t_new->timeout_pending; |
| |
| t_old->in_copy_from_uspace = t_new->in_copy_from_uspace; |
| t_old->in_copy_to_uspace = t_new->in_copy_to_uspace; |
| |
| t_old->interrupted = t_new->interrupted; |
| |
| t_old->call_me = t_new->call_me; |
| t_old->call_me_with = t_new->call_me_with; |
| |
| t_old->udebug.go_call = t_new->udebug.go_call; |
| |
| interrupts_restore(ipl); |
| |
| return (0); |
| } |
| |
| int udebug_mem_write(void *buffer, void *start, size_t n) |
| { |
| ipl_t ipl = interrupts_disable(); |
| |
| if (((unsigned) start & 0x80000000) == 0) |
| copy_to_uspace(start, buffer, n); |
| |
| interrupts_restore(ipl); |
| |
| return (0); |
| } |
| |
| int udebug_restore_kstack(void *buffer, size_t size, thread_t *t) |
| { |
| ipl_t ipl = interrupts_disable(); |
| |
| memcpy(t->kstack + sizeof(the_t), buffer + sizeof(the_t), size - sizeof(the_t)); |
| |
| interrupts_restore(ipl); |
| |
| return (0); |
| } |
| |
| |
| /** @} |
| */ |