Subversion Repositories HelenOS

/** @addtogroup generic

 * @{

 */

/**

 * @file

 * @brief   Tdebug.

 */

#include <console/klog.h>

#include <proc/task.h>

#include <proc/thread.h>

#include <arch.h>

#include <errno.h>

#include <ipc/ipc.h>

#include <syscall/copy.h>

#include <udebug/udebug.h>

#include <udebug/udebug_ipc.h>

/**

 * Get and lock a phone's callee task.

 *

 * This will return a pointer to the task to which the phone

 * is connected. It will lock the task, making sure it exists.

 * (TODO: make sure the udebug-cleanup of the task hasn't

 * started yet)

 */

static task_t *get_lock_callee_task(phone_t *phone)

{

    answerbox_t *box;

    task_t *ta;

    task_id_t taskid;

    ipl_t ipl;

    ipl = interrupts_disable();

    spinlock_lock(&phone->lock);

    if (phone->state != IPC_PHONE_CONNECTED) {

        spinlock_unlock(&phone->lock);

        interrupts_restore(ipl);

        return NULL;

    }

    box = phone->callee;

    spinlock_lock(&box->lock);

    ta = box->task;

    taskid = ta->taskid;

    spinlock_unlock(&box->lock);

    spinlock_unlock(&phone->lock);

    /* Locking decoupled using taskid */

    spinlock_lock(&tasks_lock);

    ta = task_find_by_id(taskid);

    if (ta == NULL) {

        spinlock_unlock(&tasks_lock);

        interrupts_restore(ipl);

        return NULL;

    }

    spinlock_lock(&ta->lock);

    spinlock_unlock(&tasks_lock);

    interrupts_restore(ipl);

    return ta;

}

static int verify_thread(thread_t *t)

{

    /* Verify that 't' exists and belongs to task 'ta' */

    if (!thread_exists(t) || (t->task != ta)) {

        spinlock_unlock(&threads_lock);

        interrupts_restore(ipl);

        return ENOENT;

    }

    /* Verify that 't' is a userspace thread */

    if ((t->flags & THREAD_FLAG_USPACE) == 0) {

        /* It's not, deny its existence */

        return ENOENT;

    }

    if ((t->debug_active != true) || (t->debug_stop != true)) {

        /* Not in debugging session or already has GO */

        spinlock_unlock(&threads_lock);

        interrupts_restore(ipl);       

        return EBUSY;

    }

    return EOK;

}

static int udebug_rp_begin(call_t *call, phone_t *phone)

{

    task_t *ta;

    ipl_t ipl;

    int rc;

    thread_t *t;

    link_t *cur;

    klog_printf("debug_begin()");

    ipl = interrupts_disable();

    ta = get_lock_callee_task(phone);

    klog_printf("debugging task %llu", ta->taskid);

    if (ta->dt_state != UDEBUG_TS_INACTIVE) {

        spinlock_unlock(&ta->lock);

        interrupts_restore(ipl);

        klog_printf("debug_begin(): busy error");

        return EBUSY;

    }

    ta->dt_state = UDEBUG_TS_BEGINNING;

    ta->debug_begin_call = call;

    if (ta->not_stoppable_count == 0) {

        ta->dt_state = UDEBUG_TS_ACTIVE;

        ta->debug_begin_call = NULL;

        rc = 1; /* actually we need backsend with 0 retval */

    } else {

        rc = 0; /* no backsend */

    }

    /* Set debug_active on all of the task's userspace threads */

    for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {

        t = list_get_instance(cur, thread_t, th_link);

        spinlock_lock(&t->lock);

        if ((t->flags & THREAD_FLAG_USPACE) != 0)

            t->debug_active = true;

        spinlock_unlock(&t->lock);

    }

    spinlock_unlock(&ta->lock);

    interrupts_restore(ipl);

    klog_printf("debug_begin() done (%s)",

        rc ? "backsend" : "stoppability wait");

    return rc;

}

static int udebug_rp_end(call_t *call, phone_t *phone)

{

    task_t *ta;

    ipl_t ipl;

    thread_t *t;

    link_t *cur;

    klog_printf("udebug_rp_end()");

    ipl = interrupts_disable();

    ta = get_lock_callee_task(phone);

    klog_printf("task %llu", ta->taskid);

    if (ta->dt_state == UDEBUG_TS_BEGINNING &&

        ta->dt_state != UDEBUG_TS_ACTIVE) {

        spinlock_unlock(&ta->lock);

        interrupts_restore(ipl);

        klog_printf("udebug_rp_begin(): task not being debugged");

        return EINVAL;

    }

    /* Finish debugging of all userspace threads */

    for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {

        t = list_get_instance(cur, thread_t, th_link);

        spinlock_lock(&t->lock);

        /* Only process userspace threads */

        if ((t->flags & THREAD_FLAG_USPACE) != 0) {

            /* Prevent any further debug activity in thread */

            t->debug_active = false;

            /* Still has go? */

            if (t->debug_stop == false) {

                /*

                * Yes, so clear go. As debug_active == false,

                 * this doesn't affect anything.

                 */

                t->debug_stop = true;  

                /* Answer GO call */

                klog_printf("answer GO call with EVENT_FINISHED");

                IPC_SET_RETVAL(t->debug_go_call->data, 0);

                IPC_SET_ARG1(t->debug_go_call->data, UDEBUG_EVENT_FINISHED);

                ipc_answer(&ta->answerbox, t->debug_go_call);

            } else {

                /*

                 * Debug_stop is already at initial value.

                 * Yet this means the thread needs waking up.

                 */

                waitq_wakeup(&t->go_wq, WAKEUP_FIRST);

            }

        }

        spinlock_unlock(&t->lock);

    }

    ta->dt_state = UDEBUG_TS_INACTIVE;

    spinlock_unlock(&ta->lock);

    interrupts_restore(ipl);

    IPC_SET_RETVAL(call->data, 0);

    klog_printf("udebug_rp_end() done\n");

    return 1;

}

static int udebug_rp_go(call_t *call, phone_t *phone)

{

    thread_t *t;

    task_t *ta;

    ipl_t ipl;

    klog_printf("debug_go()");

    ta = get_lock_callee_task(phone);

    spinlock_unlock(&ta->lock);

    // TODO: don't lock ta

    t = (thread_t *) IPC_GET_ARG2(call->data);

    ipl = interrupts_disable();

    spinlock_lock(&threads_lock);

    t->debug_go_call = call;

    t->debug_stop = false;

    waitq_wakeup(&t->go_wq, WAKEUP_FIRST);

    spinlock_unlock(&threads_lock);

    interrupts_restore(ipl);

    return 0; /* no backsend */

}

static int udebug_rp_args_read(call_t *call, phone_t *phone)

{

    thread_t *t;

    task_t *ta;

    void *uspace_buffer;

    int rc;

    ipl_t ipl;

    unative_t buffer[6];

    klog_printf("debug_args_read()");

    ta = get_lock_callee_task(phone);

    klog_printf("task %llu", ta->taskid);

    spinlock_unlock(&ta->lock);

    t = (thread_t *) IPC_GET_ARG2(call->data);

    ipl = interrupts_disable();

    spinlock_lock(&threads_lock);

    /* Verify that thread t exists and may be operated on */

    rc = verify_thread(t);

    if (rc != EOK) {

        spinlock_unlock(&threads_lock);

        interrupts_restore(ipl);

        return rc;

    }

    //FIXME: additionally we need to verify that we are inside a syscall

    /* Copy to a local buffer before releasing the lock */

    memcpy(buffer, t->syscall_args, 6 * sizeof(unative_t));

    spinlock_unlock(&threads_lock);

    interrupts_restore(ipl);

    /* Now copy to userspace */

    uspace_buffer = (void *)IPC_GET_ARG3(call->data);

    rc = copy_to_uspace(uspace_buffer, buffer, 6 * sizeof(unative_t));

    if (rc != 0) {

        spinlock_unlock(&ta->lock);

        klog_printf("debug_args_read() - copy failed");

        return rc;

    }

    klog_printf("debug_args_read() done");

    return 1; /* actually need becksend with retval 0 */

}

static int udebug_rp_regs_read(call_t *call, phone_t *phone)

{

    thread_t *t;

    task_t *ta;

    void *uspace_buffer;

    unative_t to_copy;

    int rc;

    istate_t *state;

    istate_t state_copy;

    ipl_t ipl;

    klog_printf("debug_regs_read()");

    ta = get_lock_callee_task(phone);

    spinlock_unlock(&ta->lock);

    //FIXME: don't lock ta

    ipl = interrupts_disable();

    spinlock_lock(&threads_lock);

    t = (thread_t *) IPC_GET_ARG2(call->data);

    /* Verify that thread t exists and may be operated on */

    rc = verify_thread(t);

    if (rc != EOK) {

        spinlock_unlock(&threads_lock);

        interrupts_restore(ipl);

        return rc;

    }

    state = t->uspace_state;

    if (state == NULL) {

        spinlock_unlock(&threads_lock);

        interrupts_restore(ipl);

        klog_printf("debug_regs_read() - istate not available");

        return EBUSY;

    }

    /* Copy to a local buffer so that we can release the lock */

    memcpy(&state_copy, state, sizeof(state_copy));

    spinlock_unlock(&threads_lock);

    interrupts_restore(ipl);

    uspace_buffer = (void *)IPC_GET_ARG3(call->data);

    to_copy = IPC_GET_ARG4(call->data);

    if (to_copy > sizeof(istate_t)) to_copy = sizeof(istate_t);

    rc = copy_to_uspace(uspace_buffer, &state_copy, to_copy);

    if (rc != 0) {

        spinlock_unlock(&ta->lock);

        klog_printf("debug_regs_read() - copy failed");

        return rc;

    }

    IPC_SET_ARG1(call->data, to_copy);

    IPC_SET_ARG2(call->data, sizeof(istate_t));

    klog_printf("debug_regs_read() done");

    return 1; /* actually need becksend with retval 0 */

}

static int udebug_rp_regs_write(call_t *call, phone_t *phone)

{

    thread_t *t;

    task_t *ta;

    void *uspace_data;

    unative_t to_copy;

    int rc;

    istate_t *state;

    istate_t data_copy;

    ipl_t ipl;

    klog_printf("debug_regs_write()");

    /* First copy to a local buffer */

    uspace_data = (void *)IPC_GET_ARG3(call->data);

    to_copy = IPC_GET_ARG4(call->data);

    if (to_copy > sizeof(istate_t)) to_copy = sizeof(istate_t);

    rc = copy_from_uspace(&data_copy, uspace_data, to_copy);

    if (rc != 0) {

        klog_printf("debug_regs_write() - copy failed");

        return rc;

    }

    ta = get_lock_callee_task(phone);

    spinlock_unlock(&ta->lock);

    //FIXME: don't lock ta

    /* Now try to change the thread's uspace_state */

    ipl = interrupts_disable();

    spinlock_lock(&threads_lock);

    t = (thread_t *) IPC_GET_ARG2(call->data);

    /* Verify that thread t exists and may be operated on */

    rc = verify_thread(t);

    if (rc != EOK) {

        spinlock_unlock(&threads_lock);

        interrupts_restore(ipl);

        return rc;

    }

    state = t->uspace_state;

    if (state == NULL) {

        spinlock_unlock(&threads_lock);

        interrupts_restore(ipl);

        klog_printf("debug_regs_write() - istate not available");

        return EBUSY;

    }

    memcpy(t->uspace_state, &data_copy, sizeof(t->uspace_state));

    spinlock_unlock(&threads_lock);

    interrupts_restore(ipl);

    /* Set answer values */

    IPC_SET_ARG1(call->data, to_copy);

    IPC_SET_ARG2(call->data, sizeof(istate_t));

    klog_printf("debug_regs_write() done");

    return 1; /* actually need becksend with retval 0 */

}

static int udebug_rp_thread_read(call_t *call, phone_t *phone)

{

    thread_t *t;

    link_t *cur;

    task_t *ta;

    unative_t *uspace_buffer;

    unative_t to_copy;

    int rc;

    unsigned total_bytes;

    unsigned buf_size;

    unative_t tid;

    unsigned num_threads, copied_ids;

    ipl_t ipl;

    unative_t *buffer;

    int flags;

    klog_printf("debug_thread_read()");

    ipl = interrupts_disable();

    ta = get_lock_callee_task(phone);

    /* Verify task state */

    if (ta->dt_state != UDEBUG_TS_ACTIVE) {

        spinlock_unlock(&ta->lock);

        interrupts_restore(ipl);

        return EBUSY;

    }

    /* Count the threads first */

    num_threads = 0;

    for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {

        /* Count all threads, to be on the safe side */

        ++num_threads;

    }

    /* Allocate a buffer and copy down the threads' ids */

    buffer = malloc(num_threads * sizeof(unative_t), 0); // ???

    copied_ids = 0;

    for (cur = ta->th_head.next; cur != &ta->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);

        /* Not interested in kernel threads */

        if ((flags & THREAD_FLAG_USPACE) != 0) {

            /* Using thread struct pointer for identification */

            tid = (unative_t) t;

            buffer[copied_ids++] = tid;

        }

    }

    spinlock_unlock(&ta->lock);

    interrupts_restore(ipl);

    /* Now copy to userspace */

    uspace_buffer = (void *)IPC_GET_ARG2(call->data);

    buf_size = IPC_GET_ARG3(call->data);

    total_bytes = copied_ids * sizeof(unative_t);

    if (buf_size > total_bytes)

        to_copy = total_bytes;

    else

        to_copy = buf_size;

    rc = copy_to_uspace(uspace_buffer, buffer, to_copy);

    free(buffer);

    if (rc != 0) {

        klog_printf("debug_thread_read() - copy failed");

        return rc;

    }

    IPC_SET_ARG1(call->data, to_copy);

    IPC_SET_ARG2(call->data, total_bytes);

    klog_printf("debug_thread_read() done");

    return 1; /* actually need becksend with retval 0 */

}

static int udebug_rp_mem_write(call_t *call, phone_t *phone)

{

    void *uspace_data;

    unative_t to_copy;

    int rc;

    void *buffer;

    klog_printf("udebug_rp_mem_write()");

    uspace_data = (void *)IPC_GET_ARG2(call->data);

    to_copy = IPC_GET_ARG4(call->data);

    buffer = malloc(to_copy, 0); // ???

    rc = copy_from_uspace(buffer, uspace_data, to_copy);

    if (rc != 0) {

        klog_printf(" - copy failed");

        return rc;

    }

    call->buffer = buffer;

    klog_printf(" - done");

    return 1; /* actually need becksend with retval 0 */

}

int udebug_request_preprocess(call_t *call, phone_t *phone)

{

    int rc;

    switch (IPC_GET_ARG1(call->data)) {

    case UDEBUG_M_BEGIN:

        rc = udebug_rp_begin(call, phone);

        return rc;

    case UDEBUG_M_END:

        rc = udebug_rp_end(call, phone);

        return rc;

    case UDEBUG_M_GO:

        rc = udebug_rp_go(call, phone);

        return rc;

    case UDEBUG_M_ARGS_READ:

        rc = udebug_rp_args_read(call, phone);

        return rc;

    case UDEBUG_M_REGS_READ:

        rc = udebug_rp_regs_read(call, phone);

        return rc;

    case UDEBUG_M_REGS_WRITE:

        rc = udebug_rp_regs_write(call, phone);

        return rc;

    case UDEBUG_M_THREAD_READ:

        rc = udebug_rp_thread_read(call, phone);

        return rc;

    case UDEBUG_M_MEM_WRITE:

        rc = udebug_rp_mem_write(call, phone);

        return rc;

    default:

        break;

    }

    return 0;

}

static void udebug_receive_mem_read(call_t *call)

{

    unative_t uspace_dst;

    void *uspace_ptr;

    unsigned size;

    void *buffer;

    int rc;

    klog_printf("debug_mem_read()");

    uspace_dst = IPC_GET_ARG2(call->data);

    uspace_ptr = (void *)IPC_GET_ARG3(call->data);

    size = IPC_GET_ARG4(call->data);

    buffer = malloc(size, 0); // ???

    klog_printf("debug_mem_read: src=%u, size=%u", uspace_ptr, size);

    /* NOTE: this is not strictly from a syscall... but that shouldn't

     * be a problem */

    rc = copy_from_uspace(buffer, uspace_ptr, size);

    if (rc) {

        IPC_SET_RETVAL(call->data, rc);

        return;

    }

    klog_printf("first word: %u", *((unative_t *)buffer));

    IPC_SET_RETVAL(call->data, 0);

    /* Hack: ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that

       same code in process_answer() can be used

       (no way to distinguish method in answer) */

    IPC_SET_ARG1(call->data, uspace_dst);

    IPC_SET_ARG2(call->data, size);

    call->buffer = buffer;

    ipc_answer(&TASK->kernel_box, call);

}

static void udebug_receive_mem_write(call_t *call)

{

    void *uspace_dst;

    unsigned size;

    void *buffer;

    int rc;

    udebug_task_state_t dts;

    klog_printf("udebug_receive_mem_write()");

    /* Verify task state */

    spinlock_lock(&TASK->lock);

    dts = TASK->dt_state;

    spinlock_unlock(&TASK->lock);

    if (dts != UDEBUG_TS_ACTIVE) {

        IPC_SET_RETVAL(call->data, EBUSY);

        ipc_answer(&TASK->kernel_box, call);

        return;

    }

    uspace_dst = (void *)IPC_GET_ARG3(call->data);

    size = IPC_GET_ARG4(call->data);

    buffer = call->buffer;

    klog_printf("dst=%u, size=%u", uspace_dst, size);

    /* NOTE: this is not strictly from a syscall... but that shouldn't

     * be a problem */

    rc = copy_to_uspace(uspace_dst, buffer, size);

    if (rc) {

        IPC_SET_RETVAL(call->data, rc);

        ipc_answer(&TASK->kernel_box, call);

        return;

    }

    IPC_SET_RETVAL(call->data, 0);

    free(call->buffer);

    call->buffer = NULL;

    ipc_answer(&TASK->kernel_box, call);

}

/**

 * Handle a debug call received on the kernel answerbox.

 *

 * This is called by the kbox servicing thread.

 */

void udebug_call_receive(call_t *call)

{

    int debug_method;

    debug_method = IPC_GET_ARG1(call->data);

    switch (debug_method) {

    case UDEBUG_M_MEM_READ:

        udebug_receive_mem_read(call);

        break;

    case UDEBUG_M_MEM_WRITE:

        udebug_receive_mem_write(call);

        break;

    }

}

/** @}

 */