Subversion Repositories HelenOS

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);

}