WebSVN – HelenOS – Diff – /trunk/uspace/app/trace/trace.c


/*
 * Copyright (c) 2008 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup trace
 * @{
 */
/** @file
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ipc/ipc.h>
#include <fibril.h>
#include <errno.h>
#include <udebug.h>
#include <async.h>
#include <task.h>
#include <mem.h>
#include <string.h>
#include <bool.h>
#include <loader/loader.h>
#include <io/console.h>
#include <io/keycode.h>
#include <fibril_sync.h>
 
#include <libc.h>
 
// Temporary: service and method names
#include "proto.h"
#include <ipc/services.h>
#include "../../srv/vfs/vfs.h"
#include <ipc/console.h>
 
#include "syscalls.h"
#include "ipcp.h"
#include "errors.h"
#include "trace.h"
 
#define THBUF_SIZE 64
uintptr_t thread_hash_buf[THBUF_SIZE];
int n_threads;
 
int next_thread_id;
 
ipc_call_t thread_ipc_req[THBUF_SIZE];
 
int phoneid;
bool abort_trace;
 
uintptr_t thash;
static bool paused;
static fibril_condvar_t state_cv;
static fibril_mutex_t state_lock;
 
static bool cev_valid;
static console_event_t cev;
 
void thread_trace_start(uintptr_t thread_hash);
 
static proto_t *proto_console;
static task_id_t task_id;
static loader_t *task_ldr;
static bool task_wait_for;
 
/** Combination of events/data to print. */
display_mask_t display_mask;
 
static int program_run_fibril(void *arg);
static int cev_fibril(void *arg);
 
static void program_run(void)
{
    fid_t fid;
 
    fid = fibril_create(program_run_fibril, NULL);
    if (fid == 0) {
        printf("Error creating fibril\n");
        exit(1);
    }
 
    fibril_add_ready(fid);
}
 
static void cev_fibril_start(void)
{
    fid_t fid;
 
    fid = fibril_create(cev_fibril, NULL);
    if (fid == 0) {
        printf("Error creating fibril\n");
        exit(1);
    }
 
    fibril_add_ready(fid);
}
 
static int program_run_fibril(void *arg)
{
    int rc;
 
    /*
     * This must be done in background as it will block until
     * we let the task reply to this call.
     */
    rc = loader_run(task_ldr);
    if (rc != 0) {
        printf("Error running program\n");
        exit(1);
    }
 
    free(task_ldr);
    task_ldr = NULL;
 
    printf("program_run_fibril exiting\n");
    return 0;
}
 
 
static int connect_task(task_id_t task_id)
{
    int rc;
 
    rc = ipc_connect_kbox(task_id);
 
    if (rc == ENOTSUP) {
        printf("You do not have userspace debugging support "
            "compiled in the kernel.\n");
        printf("Compile kernel with 'Support for userspace debuggers' "
            "(CONFIG_UDEBUG) enabled.\n");
        return rc;
    }
 
    if (rc < 0) {
        printf("Error connecting\n");
        printf("ipc_connect_task(%lld) -> %d ", task_id, rc);
        return rc;
    }
 
    phoneid = rc;
 
    rc = udebug_begin(phoneid);
    if (rc < 0) {
        printf("udebug_begin() -> %d\n", rc);
        return rc;
    }
 
    rc = udebug_set_evmask(phoneid, UDEBUG_EM_ALL);
    if (rc < 0) {
        printf("udebug_set_evmask(0x%x) -> %d\n ", UDEBUG_EM_ALL, rc);
        return rc;
    }
 
    return 0;
}
 
static int get_thread_list(void)
{
    int rc;
    size_t tb_copied;
    size_t tb_needed;
    int i;
 
    rc = udebug_thread_read(phoneid, thread_hash_buf,
        THBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);
    if (rc < 0) {
        printf("udebug_thread_read() -> %d\n", rc);
        return rc;
    }
 
    n_threads = tb_copied / sizeof(uintptr_t);
 
    printf("Threads:");
    for (i = 0; i < n_threads; i++) {
        printf(" [%d] (hash 0x%lx)", 1+i, thread_hash_buf[i]);
    }
    printf("\ntotal of %u threads\n", tb_needed / sizeof(uintptr_t));
 
    return 0;
}
 
void val_print(sysarg_t val, val_type_t v_type)
{
    switch (v_type) {
    case V_VOID:
        printf("<void>");
        break;
 
    case V_INTEGER:
        printf("%ld", val);
        break;
 
    case V_HASH:
    case V_PTR:
        printf("0x%08lx", val);
        break;
 
    case V_ERRNO:
        if (val >= -15 && val <= 0) {
            printf("%ld %s (%s)", val,
                err_desc[-val].name,
                err_desc[-val].desc);
        } else {
            printf("%ld", val);
        }
        break;
    case V_INT_ERRNO:
        if (val >= -15 && val < 0) {
            printf("%ld %s (%s)", val,
                err_desc[-val].name,
                err_desc[-val].desc);
        } else {
            printf("%ld", val);
        }
        break;
 
    case V_CHAR:
        if (val >= 0x20 && val < 0x7f) {
            printf("'%c'", val);
        } else {
            switch (val) {
            case '\a': printf("'\\a'"); break;
            case '\b': printf("'\\b'"); break;
            case '\n': printf("'\\n'"); break;
            case '\r': printf("'\\r'"); break;
            case '\t': printf("'\\t'"); break;
            case '\\': printf("'\\\\'"); break;
            default: printf("'\\x%02lX'", val); break;
            }
        }
        break;
    }
}
 
 
static void print_sc_retval(sysarg_t retval, val_type_t val_type)
{
    printf(" -> ");
    val_print(retval, val_type);
    putchar('\n');
}
 
static void print_sc_args(sysarg_t *sc_args, int n)
{
    int i;
 
    putchar('(');
    if (n > 0) printf("%ld", sc_args[0]);
    for (i = 1; i < n; i++) {
        printf(", %ld", sc_args[i]);
    }
    putchar(')');
}
 
static void sc_ipc_call_async_fast(sysarg_t *sc_args, sysarg_t sc_rc)
{
    ipc_call_t call;
    ipcarg_t phoneid;
   
    if (sc_rc == IPC_CALLRET_FATAL || sc_rc == IPC_CALLRET_TEMPORARY)
        return;
 
    phoneid = sc_args[0];
 
    IPC_SET_METHOD(call, sc_args[1]);
    IPC_SET_ARG1(call, sc_args[2]);
    IPC_SET_ARG2(call, sc_args[3]);
    IPC_SET_ARG3(call, sc_args[4]);
    IPC_SET_ARG4(call, sc_args[5]);
    IPC_SET_ARG5(call, 0);
 
    ipcp_call_out(phoneid, &call, sc_rc);
}
 
static void sc_ipc_call_async_slow(sysarg_t *sc_args, sysarg_t sc_rc)
{
    ipc_call_t call;
    int rc;
 
    if (sc_rc == IPC_CALLRET_FATAL || sc_rc == IPC_CALLRET_TEMPORARY)
        return;
 
    memset(&call, 0, sizeof(call));
    rc = udebug_mem_read(phoneid, &call.args, sc_args[1], sizeof(call.args));
 
    if (rc >= 0) {
        ipcp_call_out(sc_args[0], &call, sc_rc);
    }
}
 
static void sc_ipc_call_sync_fast(sysarg_t *sc_args)
{
    ipc_call_t question, reply;
    int rc;
    int phoneidx;
 
//  printf("sc_ipc_call_sync_fast()\n");
    phoneidx = sc_args[0];
 
    IPC_SET_METHOD(question, sc_args[1]);
    IPC_SET_ARG1(question, sc_args[2]);
    IPC_SET_ARG2(question, sc_args[3]);
    IPC_SET_ARG3(question, sc_args[4]);
    IPC_SET_ARG4(question, 0);
    IPC_SET_ARG5(question, 0);
 
//  printf("memset\n");
    memset(&reply, 0, sizeof(reply));
//  printf("udebug_mem_read(phone=%d, buffer_ptr=%u, src_addr=%d, n=%d\n",
//      phoneid, &reply.args, sc_args[5], sizeof(reply.args));
    rc = udebug_mem_read(phoneid, &reply.args, sc_args[5], sizeof(reply.args));
//  printf("dmr->%d\n", rc);
    if (rc < 0) return;
 
//  printf("call ipc_call_sync\n");
    ipcp_call_sync(phoneidx, &question, &reply);
}
 
static void sc_ipc_call_sync_slow_b(unsigned thread_id, sysarg_t *sc_args)
{
    ipc_call_t question, reply;
    int rc;
 
    memset(&question, 0, sizeof(question));
    rc = udebug_mem_read(phoneid, &question.args, sc_args[1], sizeof(question.args));
    if (rc < 0) {
        printf("Error: mem_read->%d\n", rc);
        return;
    }
 
    thread_ipc_req[thread_id] = question;
}
 
static void sc_ipc_call_sync_slow_e(unsigned thread_id, sysarg_t *sc_args)
{
    ipc_call_t question, reply;
    int rc;
 
    memset(&reply, 0, sizeof(reply));
    rc = udebug_mem_read(phoneid, &reply.args, sc_args[2], sizeof(reply.args));
    if (rc < 0) {
        printf("Error: mem_read->%d\n", rc);
        return;
    }
 
    ipcp_call_sync(sc_args[0], &thread_ipc_req[thread_id], &reply);
}
 
static void sc_ipc_wait(sysarg_t *sc_args, int sc_rc)
{
    ipc_call_t call;
    int rc;
 
    if (sc_rc == 0) return;
 
    memset(&call, 0, sizeof(call));
    rc = udebug_mem_read(phoneid, &call, sc_args[0], sizeof(call));
//  printf("udebug_mem_read(phone %d, dest %d, app-mem src %d, size %d -> %d\n",
//      phoneid, (int)&call, sc_args[0], sizeof(call), rc);
 
    if (rc >= 0) {
        ipcp_call_in(&call, sc_rc);
    }
}
 
static void event_syscall_b(unsigned thread_id, uintptr_t thread_hash,
    unsigned sc_id, sysarg_t sc_rc)
{
    sysarg_t sc_args[6];
    int rc;
 
    /* Read syscall arguments */
    rc = udebug_args_read(phoneid, thread_hash, sc_args);
 
    async_serialize_start();
 
//  printf("[%d] ", thread_id);
 
    if (rc < 0) {
        printf("error\n");
        async_serialize_end();
        return;
    }
 
    if ((display_mask & DM_SYSCALL) != 0) {
        /* Print syscall name and arguments */
        printf("%s", syscall_desc[sc_id].name);
        print_sc_args(sc_args, syscall_desc[sc_id].n_args);
    }
 
    switch (sc_id) {
    case SYS_IPC_CALL_SYNC_SLOW:
        sc_ipc_call_sync_slow_b(thread_id, sc_args);
        break;
    default:
        break;
    }
 
    async_serialize_end();
}
 
static void event_syscall_e(unsigned thread_id, uintptr_t thread_hash,
    unsigned sc_id, sysarg_t sc_rc)
{
    sysarg_t sc_args[6];
    int rv_type;
    int rc;
 
    /* Read syscall arguments */
    rc = udebug_args_read(phoneid, thread_hash, sc_args);
 
    async_serialize_start();
 
//  printf("[%d] ", thread_id);
 
    if (rc < 0) {
        printf("error\n");
        async_serialize_end();
        return;
    }
 
    if ((display_mask & DM_SYSCALL) != 0) {
        /* Print syscall return value */
        rv_type = syscall_desc[sc_id].rv_type;
        print_sc_retval(sc_rc, rv_type);
    }
 
    switch (sc_id) {
    case SYS_IPC_CALL_ASYNC_FAST:
        sc_ipc_call_async_fast(sc_args, sc_rc);
        break;
    case SYS_IPC_CALL_ASYNC_SLOW:
        sc_ipc_call_async_slow(sc_args, sc_rc);
        break;
    case SYS_IPC_CALL_SYNC_FAST:
        sc_ipc_call_sync_fast(sc_args);
        break;
    case SYS_IPC_CALL_SYNC_SLOW:
        sc_ipc_call_sync_slow_e(thread_id, sc_args);
        break;
    case SYS_IPC_WAIT:
        sc_ipc_wait(sc_args, sc_rc);
        break;
    default:
        break;
    }
 
    async_serialize_end();
}
 
static void event_thread_b(uintptr_t hash)
{
    async_serialize_start();
    printf("New thread, hash 0x%lx\n", hash);
    async_serialize_end();
 
    thread_trace_start(hash);
}
 
static int trace_loop(void *thread_hash_arg)
{
    int rc;
    unsigned ev_type;
    uintptr_t thread_hash;
    unsigned thread_id;
    sysarg_t val0, val1;
 
    thread_hash = (uintptr_t)thread_hash_arg;
    thread_id = next_thread_id++;
    if (thread_id >= THBUF_SIZE) {
        printf("Too many threads.\n");
        return ELIMIT;
    }
 
    printf("Start tracing thread [%d] (hash 0x%lx).\n", thread_id, thread_hash);
 
    while (!abort_trace) {
 
        fibril_mutex_lock(&state_lock);
        if (paused) {
            printf("Thread [%d] paused. Press R to resume.\n",
                thread_id);
 
            while (paused)
                fibril_condvar_wait(&state_cv, &state_lock);
 
            printf("Thread [%d] resumed.\n", thread_id);
        }
        fibril_mutex_unlock(&state_lock);
 
        /* Run thread until an event occurs */
        rc = udebug_go(phoneid, thread_hash,
            &ev_type, &val0, &val1);
 
//      printf("rc = %d, ev_type=%d\n", rc, ev_type);
        if (ev_type == UDEBUG_EVENT_FINISHED) {
            /* Done tracing this thread */
            break;
        }
 
        if (rc >= 0) {
            switch (ev_type) {
            case UDEBUG_EVENT_SYSCALL_B:
                event_syscall_b(thread_id, thread_hash, val0, (int)val1);
                break;
            case UDEBUG_EVENT_SYSCALL_E:
                event_syscall_e(thread_id, thread_hash, val0, (int)val1);
                break;
            case UDEBUG_EVENT_STOP:
                printf("Stop event\n");
                fibril_mutex_lock(&state_lock);
                paused = true;
                fibril_mutex_unlock(&state_lock);
                break;
            case UDEBUG_EVENT_THREAD_B:
                event_thread_b(val0);
                break;
            case UDEBUG_EVENT_THREAD_E:
                printf("Thread 0x%lx exited.\n", val0);
                fibril_mutex_lock(&state_lock);
                abort_trace = true;
                fibril_condvar_broadcast(&state_cv);
                fibril_mutex_unlock(&state_lock);
                break;
            default:
                printf("Unknown event type %d.\n", ev_type);
                break;
            }
        }
 
    }
 
    printf("Finished tracing thread [%d].\n", thread_id);
    return 0;
}
 
void thread_trace_start(uintptr_t thread_hash)
{
    fid_t fid;
 
    thash = thread_hash;
 
    fid = fibril_create(trace_loop, (void *)thread_hash);
    if (fid == 0) {
        printf("Warning: Failed creating fibril\n");
    }
    fibril_add_ready(fid);
}
 
static loader_t *preload_task(const char *path, char *const argv[],
    task_id_t *task_id)
{
    loader_t *ldr;
    int rc;
 
    /* Spawn a program loader */   
    ldr = loader_connect();
    if (ldr == NULL)
        return 0;
 
    /* Get task ID. */
    rc = loader_get_task_id(ldr, task_id);
    if (rc != EOK)
        goto error;
 
    /* Send program pathname */
    rc = loader_set_pathname(ldr, path);
    if (rc != EOK)
        goto error;
 
    /* Send arguments */
    rc = loader_set_args(ldr, argv);
    if (rc != EOK)
        goto error;
 
    /* Send default files */
    fdi_node_t *files[4];
    fdi_node_t stdin_node;
    fdi_node_t stdout_node;
    fdi_node_t stderr_node;
   
    if ((stdin != NULL) && (fnode(stdin, &stdin_node) == EOK))
        files[0] = &stdin_node;
    else
        files[0] = NULL;
   
    if ((stdout != NULL) && (fnode(stdout, &stdout_node) == EOK))
        files[1] = &stdout_node;
    else
        files[1] = NULL;
   
    if ((stderr != NULL) && (fnode(stderr, &stderr_node) == EOK))
        files[2] = &stderr_node;
    else
        files[2] = NULL;
   
    files[3] = NULL;
   
    rc = loader_set_files(ldr, files);
    if (rc != EOK)
        goto error;
 
    /* Load the program. */
    rc = loader_load_program(ldr);
    if (rc != EOK)
        goto error;
 
    /* Success */
    return ldr;
 
    /* Error exit */
error:
    loader_abort(ldr);
    free(ldr);
    return NULL;
}
 
static int cev_fibril(void *arg)
{
    (void) arg;
 
    while (true) {
        fibril_mutex_lock(&state_lock);
        while (cev_valid)
            fibril_condvar_wait(&state_cv, &state_lock);
        fibril_mutex_unlock(&state_lock);
 
        if (!console_get_event(fphone(stdin), &cev))
            return -1;
 
        fibril_mutex_lock(&state_lock);
        cev_valid = true;
        fibril_condvar_broadcast(&state_cv);
        fibril_mutex_unlock(&state_lock);      
    }
}
 
static void trace_task(task_id_t task_id)
{
    console_event_t ev;
    bool done;
    int i;
    int rc;
 
    ipcp_init();
 
    /*
     * User apps now typically have console on phone 3.
     * (Phones 1 and 2 are used by the loader).
     */
    ipcp_connection_set(3, 0, proto_console);
 
    rc = get_thread_list();
    if (rc < 0) {
        printf("Failed to get thread list (error %d)\n", rc);
        return;
    }
 
    abort_trace = false;
 
    for (i = 0; i < n_threads; i++) {
        thread_trace_start(thread_hash_buf[i]);
    }
 
    done = false;
 
    while (!done) {
        fibril_mutex_lock(&state_lock);
        while (!cev_valid && !abort_trace)
            fibril_condvar_wait(&state_cv, &state_lock);
        fibril_mutex_unlock(&state_lock);
 
        ev = cev;
 
        fibril_mutex_lock(&state_lock);
        cev_valid = false;
        fibril_condvar_broadcast(&state_cv);
        fibril_mutex_unlock(&state_lock);
 
        if (abort_trace)
            break;
 
        if (ev.type != KEY_PRESS)
            continue;
 
        switch (ev.key) {
        case KC_Q:
            done = true;
            break;
        case KC_P:
            printf("Pause...\n");
            rc = udebug_stop(phoneid, thash);
            if (rc != EOK)
                printf("Error: stop -> %d\n", rc);
            break;
        case KC_R:
            fibril_mutex_lock(&state_lock);
            paused = false;
            fibril_condvar_broadcast(&state_cv);
            fibril_mutex_unlock(&state_lock);
            printf("Resume...\n");
            break;
        }
    }
 
    printf("\nTerminate debugging session...\n");
    abort_trace = true;
    udebug_end(phoneid);
    ipc_hangup(phoneid);
 
    ipcp_cleanup();
 
    printf("Done\n");
    return;
}
 
static void main_init(void)
{
    proto_t *p;
    oper_t *o;
 
    val_type_t arg_def[OPER_MAX_ARGS] = {
        V_INTEGER,
        V_INTEGER,
        V_INTEGER,
        V_INTEGER,
        V_INTEGER      
    };
 
    val_type_t resp_def[OPER_MAX_ARGS] = {
        V_INTEGER,
        V_INTEGER,
        V_INTEGER,
        V_INTEGER,
        V_INTEGER
    };
 
    next_thread_id = 1;
    paused = false;
    cev_valid = false;
 
    fibril_mutex_initialize(&state_lock);
    fibril_condvar_initialize(&state_cv);
 
    proto_init();
 
    p = proto_new("vfs");
    o = oper_new("open", 2, arg_def, V_INT_ERRNO, 0, resp_def);
    proto_add_oper(p, VFS_IN_OPEN, o);
    o = oper_new("open_node", 4, arg_def, V_INT_ERRNO, 0, resp_def);
    proto_add_oper(p, VFS_IN_OPEN_NODE, o);
    o = oper_new("read", 1, arg_def, V_ERRNO, 1, resp_def);
    proto_add_oper(p, VFS_IN_READ, o);
    o = oper_new("write", 1, arg_def, V_ERRNO, 1, resp_def);
    proto_add_oper(p, VFS_IN_WRITE, o);
    o = oper_new("seek", 3, arg_def, V_ERRNO, 0, resp_def);
    proto_add_oper(p, VFS_IN_SEEK, o);
    o = oper_new("truncate", 5, arg_def, V_ERRNO, 0, resp_def);
    proto_add_oper(p, VFS_IN_TRUNCATE, o);
    o = oper_new("fstat", 1, arg_def, V_ERRNO, 0, resp_def);
    proto_add_oper(p, VFS_IN_FSTAT, o);
    o = oper_new("close", 1, arg_def, V_ERRNO, 0, resp_def);
    proto_add_oper(p, VFS_IN_CLOSE, o);
    o = oper_new("mount", 2, arg_def, V_ERRNO, 0, resp_def);
    proto_add_oper(p, VFS_IN_MOUNT, o);
/*  o = oper_new("unmount", 0, arg_def);
    proto_add_oper(p, VFS_IN_UNMOUNT, o);*/
 
 
 
 
    o = oper_new("sync", 1, arg_def, V_ERRNO, 0, resp_def);
    proto_add_oper(p, VFS_IN_SYNC, o);
    o = oper_new("mkdir", 1, arg_def, V_ERRNO, 0, resp_def);
    proto_add_oper(p, VFS_IN_MKDIR, o);
    o = oper_new("unlink", 0, arg_def, V_ERRNO, 0, resp_def);
    proto_add_oper(p, VFS_IN_UNLINK, o);
    o = oper_new("rename", 0, arg_def, V_ERRNO, 0, resp_def);
    proto_add_oper(p, VFS_IN_RENAME, o);
    o = oper_new("stat", 0, arg_def, V_ERRNO, 0, resp_def);
    proto_add_oper(p, VFS_IN_STAT, o);
 
    proto_register(SERVICE_VFS, p);
 
    p = proto_new("console");
 
    o = oper_new("write", 1, arg_def, V_ERRNO, 1, resp_def);
    proto_add_oper(p, VFS_IN_WRITE, o);
 
    resp_def[0] = V_INTEGER; resp_def[1] = V_INTEGER;
    resp_def[2] = V_INTEGER; resp_def[3] = V_CHAR;
    o = oper_new("getkey", 0, arg_def, V_ERRNO, 4, resp_def);
 
    arg_def[0] = V_CHAR;
    o = oper_new("clear", 0, arg_def, V_VOID, 0, resp_def);
    proto_add_oper(p, CONSOLE_CLEAR, o);
 
    arg_def[0] = V_INTEGER; arg_def[1] = V_INTEGER;
    o = oper_new("goto", 2, arg_def, V_VOID, 0, resp_def);
    proto_add_oper(p, CONSOLE_GOTO, o);
 
    resp_def[0] = V_INTEGER; resp_def[1] = V_INTEGER;
    o = oper_new("getsize", 0, arg_def, V_INTEGER, 2, resp_def);
    proto_add_oper(p, CONSOLE_GET_SIZE, o);
 
    arg_def[0] = V_INTEGER;
    o = oper_new("set_style", 1, arg_def, V_VOID, 0, resp_def);
    proto_add_oper(p, CONSOLE_SET_STYLE, o);
    arg_def[0] = V_INTEGER; arg_def[1] = V_INTEGER; arg_def[2] = V_INTEGER;
    o = oper_new("set_color", 3, arg_def, V_VOID, 0, resp_def);
    proto_add_oper(p, CONSOLE_SET_COLOR, o);
    arg_def[0] = V_INTEGER; arg_def[1] = V_INTEGER;
    o = oper_new("set_rgb_color", 2, arg_def, V_VOID, 0, resp_def);
    proto_add_oper(p, CONSOLE_SET_RGB_COLOR, o);
    o = oper_new("cursor_visibility", 1, arg_def, V_VOID, 0, resp_def);
    proto_add_oper(p, CONSOLE_CURSOR_VISIBILITY, o);
 
    proto_console = p;
    proto_register(SERVICE_CONSOLE, p);
}
 
static void print_syntax()
{
    printf("Syntax:\n");
    printf("\ttrace [+<events>] <executable> [<arg1> [...]]\n");
    printf("or\ttrace [+<events>] -t <task_id>\n");
    printf("Events: (default is +tp)\n");
    printf("\n");
    printf("\tt ... Thread creation and termination\n");
    printf("\ts ... System calls\n");
    printf("\ti ... Low-level IPC\n");
    printf("\tp ... Protocol level\n");
    printf("\n");
    printf("Examples:\n");
    printf("\ttrace +s /app/tetris\n");
    printf("\ttrace +tsip -t 12\n");
}
 
static display_mask_t parse_display_mask(char *text)
{
    display_mask_t dm;
    char *c;
 
    c = text;
 
    while (*c) {
        switch (*c) {
        case 't': dm = dm | DM_THREAD; break;
        case 's': dm = dm | DM_SYSCALL; break;
        case 'i': dm = dm | DM_IPC; break;
        case 'p': dm = dm | DM_SYSTEM | DM_USER; break;
        default:
            printf("Unexpected event type '%c'.\n", *c);
            exit(1);
        }
 
        ++c;
    }
 
    return dm;
}
 
static int parse_args(int argc, char *argv[])
{
    char *arg;
    char *err_p;
 
    task_id = 0;
 
    --argc; ++argv;
 
    while (argc > 0) {
        arg = *argv;
        if (arg[0] == '+') {
            display_mask = parse_display_mask(&arg[1]);
        } else if (arg[0] == '-') {
            if (arg[1] == 't') {
                /* Trace an already running task */
                --argc; ++argv;
                task_id = strtol(*argv, &err_p, 10);
                task_ldr = NULL;
                task_wait_for = false;
                if (*err_p) {
                    printf("Task ID syntax error\n");
                    print_syntax();
                    return -1;
                }
            } else {
                printf("Uknown option '%s'\n", arg[0]);
                print_syntax();
                return -1;
            }
        } else {
            break;
        }
 
        --argc; ++argv;
    }
 
    if (task_id != 0) {
        if (argc == 0) return 0;
        printf("Extra arguments\n");
        print_syntax();
        return -1;
    }
 
    if (argc < 1) {
        printf("Missing argument\n");
        print_syntax();
        return -1;
    }
 
    /* Preload the specified program file. */
    printf("Spawning '%s' with arguments:\n", *argv);
    {
        char **cp = argv;
        while (*cp) printf("'%s'\n", *cp++);
    }
    task_ldr = preload_task(*argv, argv, &task_id);
    task_wait_for = true;
 
    return 0;
}
 
int main(int argc, char *argv[])
{
    int rc;
    task_exit_t texit;
    int retval;
 
    printf("System Call / IPC Tracer\n");
    printf("Controls: Q - Quit, P - Pause, R - Resume\n");
 
    display_mask = DM_THREAD | DM_SYSTEM | DM_USER;
 
    if (parse_args(argc, argv) < 0)
        return 1;
 
    main_init();
 
    rc = connect_task(task_id);
    if (rc < 0) {
        printf("Failed connecting to task %lld.\n", task_id);
        return 1;
    }
 
    printf("Connected to task %lld.\n", task_id);
 
    if (task_ldr != NULL)
        program_run();
 
    cev_fibril_start();
    trace_task(task_id);
 
    if (task_wait_for) {
        printf("Waiting for task to exit.\n");
 
        rc = task_wait(task_id, &texit, &retval);
        if (rc != EOK) {
            printf("Failed waiting for task.\n");
            return -1;
        }
 
        if (texit == TASK_EXIT_NORMAL) {
            printf("Task exited normally, return value %d.\n",
                retval);
        } else {
            printf("Task exited unexpectedly.\n");
        }
    }
 
    return 0;
}
 
/** @}
 */
 

Rev 4660	Rev 4661
1	/*	1	/*
2	* Copyright (c) 2008 Jiri Svoboda	2	* Copyright (c) 2008 Jiri Svoboda
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup trace	29	/** @addtogroup trace
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include <stdio.h>	35	#include <stdio.h>
36	#include <stdlib.h>	36	#include <stdlib.h>
37	#include <unistd.h>	37	#include <unistd.h>
38	#include <ipc/ipc.h>	38	#include <ipc/ipc.h>
39	#include <fibril.h>	39	#include <fibril.h>
40	#include <errno.h>	40	#include <errno.h>
41	#include <udebug.h>	41	#include <udebug.h>
42	#include <async.h>	42	#include <async.h>
43	#include <task.h>	43	#include <task.h>
44	#include <mem.h>	44	#include <mem.h>
45	#include <string.h>	45	#include <string.h>
46	#include <bool.h>	46	#include <bool.h>
47	#include <loader/loader.h>	47	#include <loader/loader.h>
48	#include <io/console.h>	48	#include <io/console.h>
49	#include <io/keycode.h>	49	#include <io/keycode.h>
50	#include <fibril_sync.h>	50	#include <fibril_sync.h>
51		51
52	#include <libc.h>	52	#include <libc.h>
53		53
54	// Temporary: service and method names	54	// Temporary: service and method names
55	#include "proto.h"	55	#include "proto.h"
56	#include <ipc/services.h>	56	#include <ipc/services.h>
57	#include "../../srv/vfs/vfs.h"	57	#include "../../srv/vfs/vfs.h"
58	#include <ipc/console.h>	58	#include <ipc/console.h>
59		59
60	#include "syscalls.h"	60	#include "syscalls.h"
61	#include "ipcp.h"	61	#include "ipcp.h"
62	#include "errors.h"	62	#include "errors.h"
63	#include "trace.h"	63	#include "trace.h"
64		64
65	#define THBUF_SIZE 64	65	#define THBUF_SIZE 64
66	uintptr_t thread_hash_buf[THBUF_SIZE];	66	uintptr_t thread_hash_buf[THBUF_SIZE];
67	int n_threads;	67	int n_threads;
68		68
69	int next_thread_id;	69	int next_thread_id;
70		70
71	ipc_call_t thread_ipc_req[THBUF_SIZE];	71	ipc_call_t thread_ipc_req[THBUF_SIZE];
72		72
73	int phoneid;	73	int phoneid;
74	bool abort_trace;	74	bool abort_trace;
75		75
76	uintptr_t thash;	76	uintptr_t thash;
77	static bool paused;	77	static bool paused;
78	static fibril_condvar_t state_cv;	78	static fibril_condvar_t state_cv;
79	static fibril_mutex_t state_lock;	79	static fibril_mutex_t state_lock;
80		80
81	static bool cev_valid;	81	static bool cev_valid;
82	static console_event_t cev;	82	static console_event_t cev;
83		83
84	void thread_trace_start(uintptr_t thread_hash);	84	void thread_trace_start(uintptr_t thread_hash);
85		85
86	static proto_t *proto_console;	86	static proto_t *proto_console;
87	static task_id_t task_id;	87	static task_id_t task_id;
88	static loader_t *task_ldr;	88	static loader_t *task_ldr;
89	static bool task_wait_for;	89	static bool task_wait_for;
90		90
91	/** Combination of events/data to print. */	91	/** Combination of events/data to print. */
92	display_mask_t display_mask;	92	display_mask_t display_mask;
93		93
94	static int program_run_fibril(void *arg);	94	static int program_run_fibril(void *arg);
95	static int cev_fibril(void *arg);	95	static int cev_fibril(void *arg);
96		96
97	static void program_run(void)	97	static void program_run(void)
98	{	98	{
99	fid_t fid;	99	fid_t fid;
100		100
101	fid = fibril_create(program_run_fibril, NULL);	101	fid = fibril_create(program_run_fibril, NULL);
102	if (fid == 0) {	102	if (fid == 0) {
103	printf("Error creating fibril\n");	103	printf("Error creating fibril\n");
104	exit(1);	104	exit(1);
105	}	105	}
106		106
107	fibril_add_ready(fid);	107	fibril_add_ready(fid);
108	}	108	}
109		109
110	static void cev_fibril_start(void)	110	static void cev_fibril_start(void)
111	{	111	{
112	fid_t fid;	112	fid_t fid;
113		113
114	fid = fibril_create(cev_fibril, NULL);	114	fid = fibril_create(cev_fibril, NULL);
115	if (fid == 0) {	115	if (fid == 0) {
116	printf("Error creating fibril\n");	116	printf("Error creating fibril\n");
117	exit(1);	117	exit(1);
118	}	118	}
119		119
120	fibril_add_ready(fid);	120	fibril_add_ready(fid);
121	}	121	}
122		122
123	static int program_run_fibril(void *arg)	123	static int program_run_fibril(void *arg)
124	{	124	{
125	int rc;	125	int rc;
126		126
127	/*	127	/*
128	* This must be done in background as it will block until	128	* This must be done in background as it will block until
129	* we let the task reply to this call.	129	* we let the task reply to this call.
130	*/	130	*/
131	rc = loader_run(task_ldr);	131	rc = loader_run(task_ldr);
132	if (rc != 0) {	132	if (rc != 0) {
133	printf("Error running program\n");	133	printf("Error running program\n");
134	exit(1);	134	exit(1);
135	}	135	}
136		136
137	free(task_ldr);	137	free(task_ldr);
138	task_ldr = NULL;	138	task_ldr = NULL;
139		139
140	printf("program_run_fibril exiting\n");	140	printf("program_run_fibril exiting\n");
141	return 0;	141	return 0;
142	}	142	}
143		143
144		144
145	static int connect_task(task_id_t task_id)	145	static int connect_task(task_id_t task_id)
146	{	146	{
147	int rc;	147	int rc;
148		148
149	rc = ipc_connect_kbox(task_id);	149	rc = ipc_connect_kbox(task_id);
150		150
151	if (rc == ENOTSUP) {	151	if (rc == ENOTSUP) {
152	printf("You do not have userspace debugging support "	152	printf("You do not have userspace debugging support "
153	"compiled in the kernel.\n");	153	"compiled in the kernel.\n");
154	printf("Compile kernel with 'Support for userspace debuggers' "	154	printf("Compile kernel with 'Support for userspace debuggers' "
155	"(CONFIG_UDEBUG) enabled.\n");	155	"(CONFIG_UDEBUG) enabled.\n");
156	return rc;	156	return rc;
157	}	157	}
158		158
159	if (rc < 0) {	159	if (rc < 0) {
160	printf("Error connecting\n");	160	printf("Error connecting\n");
161	printf("ipc_connect_task(%lld) -> %d ", task_id, rc);	161	printf("ipc_connect_task(%lld) -> %d ", task_id, rc);
162	return rc;	162	return rc;
163	}	163	}
164		164
165	phoneid = rc;	165	phoneid = rc;
166		166
167	rc = udebug_begin(phoneid);	167	rc = udebug_begin(phoneid);
168	if (rc < 0) {	168	if (rc < 0) {
169	printf("udebug_begin() -> %d\n", rc);	169	printf("udebug_begin() -> %d\n", rc);
170	return rc;	170	return rc;
171	}	171	}
172		172
173	rc = udebug_set_evmask(phoneid, UDEBUG_EM_ALL);	173	rc = udebug_set_evmask(phoneid, UDEBUG_EM_ALL);
174	if (rc < 0) {	174	if (rc < 0) {
175	printf("udebug_set_evmask(0x%x) -> %d\n ", UDEBUG_EM_ALL, rc);	175	printf("udebug_set_evmask(0x%x) -> %d\n ", UDEBUG_EM_ALL, rc);
176	return rc;	176	return rc;
177	}	177	}
178		178
179	return 0;	179	return 0;
180	}	180	}
181		181
182	static int get_thread_list(void)	182	static int get_thread_list(void)
183	{	183	{
184	int rc;	184	int rc;
185	size_t tb_copied;	185	size_t tb_copied;
186	size_t tb_needed;	186	size_t tb_needed;
187	int i;	187	int i;
188		188
189	rc = udebug_thread_read(phoneid, thread_hash_buf,	189	rc = udebug_thread_read(phoneid, thread_hash_buf,
190	THBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);	190	THBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);
191	if (rc < 0) {	191	if (rc < 0) {
192	printf("udebug_thread_read() -> %d\n", rc);	192	printf("udebug_thread_read() -> %d\n", rc);
193	return rc;	193	return rc;
194	}	194	}
195		195
196	n_threads = tb_copied / sizeof(uintptr_t);	196	n_threads = tb_copied / sizeof(uintptr_t);
197		197
198	printf("Threads:");	198	printf("Threads:");
199	for (i = 0; i < n_threads; i++) {	199	for (i = 0; i < n_threads; i++) {
200	printf(" [%d] (hash 0x%lx)", 1+i, thread_hash_buf[i]);	200	printf(" [%d] (hash 0x%lx)", 1+i, thread_hash_buf[i]);
201	}	201	}
202	printf("\ntotal of %u threads\n", tb_needed / sizeof(uintptr_t));	202	printf("\ntotal of %u threads\n", tb_needed / sizeof(uintptr_t));
203		203
204	return 0;	204	return 0;
205	}	205	}
206		206
207	void val_print(sysarg_t val, val_type_t v_type)	207	void val_print(sysarg_t val, val_type_t v_type)
208	{	208	{
209	switch (v_type) {	209	switch (v_type) {
210	case V_VOID:	210	case V_VOID:
211	printf("<void>");	211	printf("<void>");
212	break;	212	break;
213		213
214	case V_INTEGER:	214	case V_INTEGER:
215	printf("%ld", val);	215	printf("%ld", val);
216	break;	216	break;
217		217
218	case V_HASH:	218	case V_HASH:
219	case V_PTR:	219	case V_PTR:
220	printf("0x%08lx", val);	220	printf("0x%08lx", val);
221	break;	221	break;
222		222
223	case V_ERRNO:	223	case V_ERRNO:
224	if (val >= -15 && val <= 0) {	224	if (val >= -15 && val <= 0) {
225	printf("%ld %s (%s)", val,	225	printf("%ld %s (%s)", val,
226	err_desc[-val].name,	226	err_desc[-val].name,
227	err_desc[-val].desc);	227	err_desc[-val].desc);
228	} else {	228	} else {
229	printf("%ld", val);	229	printf("%ld", val);
230	}	230	}
231	break;	231	break;
232	case V_INT_ERRNO:	232	case V_INT_ERRNO:
233	if (val >= -15 && val < 0) {	233	if (val >= -15 && val < 0) {
234	printf("%ld %s (%s)", val,	234	printf("%ld %s (%s)", val,
235	err_desc[-val].name,	235	err_desc[-val].name,
236	err_desc[-val].desc);	236	err_desc[-val].desc);
237	} else {	237	} else {
238	printf("%ld", val);	238	printf("%ld", val);
239	}	239	}
240	break;	240	break;
241		241
242	case V_CHAR:	242	case V_CHAR:
243	if (val >= 0x20 && val < 0x7f) {	243	if (val >= 0x20 && val < 0x7f) {
244	printf("'%c'", val);	244	printf("'%c'", val);
245	} else {	245	} else {
246	switch (val) {	246	switch (val) {
247	case '\a': printf("'\\a'"); break;	247	case '\a': printf("'\\a'"); break;
248	case '\b': printf("'\\b'"); break;	248	case '\b': printf("'\\b'"); break;
249	case '\n': printf("'\\n'"); break;	249	case '\n': printf("'\\n'"); break;
250	case '\r': printf("'\\r'"); break;	250	case '\r': printf("'\\r'"); break;
251	case '\t': printf("'\\t'"); break;	251	case '\t': printf("'\\t'"); break;
252	case '\\': printf("'\\\\'"); break;	252	case '\\': printf("'\\\\'"); break;
253	default: printf("'\\x%02lX'", val); break;	253	default: printf("'\\x%02lX'", val); break;
254	}	254	}
255	}	255	}
256	break;	256	break;
257	}	257	}
258	}	258	}
259		259
260		260
261	static void print_sc_retval(sysarg_t retval, val_type_t val_type)	261	static void print_sc_retval(sysarg_t retval, val_type_t val_type)
262	{	262	{
263	printf(" -> ");	263	printf(" -> ");
264	val_print(retval, val_type);	264	val_print(retval, val_type);
265	putchar('\n');	265	putchar('\n');
266	}	266	}
267		267
268	static void print_sc_args(sysarg_t *sc_args, int n)	268	static void print_sc_args(sysarg_t *sc_args, int n)
269	{	269	{
270	int i;	270	int i;
271		271
272	putchar('(');	272	putchar('(');
273	if (n > 0) printf("%ld", sc_args[0]);	273	if (n > 0) printf("%ld", sc_args[0]);
274	for (i = 1; i < n; i++) {	274	for (i = 1; i < n; i++) {
275	printf(", %ld", sc_args[i]);	275	printf(", %ld", sc_args[i]);
276	}	276	}
277	putchar(')');	277	putchar(')');
278	}	278	}
279		279
280	static void sc_ipc_call_async_fast(sysarg_t *sc_args, sysarg_t sc_rc)	280	static void sc_ipc_call_async_fast(sysarg_t *sc_args, sysarg_t sc_rc)
281	{	281	{
282	ipc_call_t call;	282	ipc_call_t call;
283	ipcarg_t phoneid;	283	ipcarg_t phoneid;
284		284
285	if (sc_rc == IPC_CALLRET_FATAL \|\| sc_rc == IPC_CALLRET_TEMPORARY)	285	if (sc_rc == IPC_CALLRET_FATAL \|\| sc_rc == IPC_CALLRET_TEMPORARY)
286	return;	286	return;
287		287
288	phoneid = sc_args[0];	288	phoneid = sc_args[0];
289		289
290	IPC_SET_METHOD(call, sc_args[1]);	290	IPC_SET_METHOD(call, sc_args[1]);
291	IPC_SET_ARG1(call, sc_args[2]);	291	IPC_SET_ARG1(call, sc_args[2]);
292	IPC_SET_ARG2(call, sc_args[3]);	292	IPC_SET_ARG2(call, sc_args[3]);
293	IPC_SET_ARG3(call, sc_args[4]);	293	IPC_SET_ARG3(call, sc_args[4]);
294	IPC_SET_ARG4(call, sc_args[5]);	294	IPC_SET_ARG4(call, sc_args[5]);
295	IPC_SET_ARG5(call, 0);	295	IPC_SET_ARG5(call, 0);
296		296
297	ipcp_call_out(phoneid, &call, sc_rc);	297	ipcp_call_out(phoneid, &call, sc_rc);
298	}	298	}
299		299
300	static void sc_ipc_call_async_slow(sysarg_t *sc_args, sysarg_t sc_rc)	300	static void sc_ipc_call_async_slow(sysarg_t *sc_args, sysarg_t sc_rc)
301	{	301	{
302	ipc_call_t call;	302	ipc_call_t call;
303	int rc;	303	int rc;
304		304
305	if (sc_rc == IPC_CALLRET_FATAL \|\| sc_rc == IPC_CALLRET_TEMPORARY)	305	if (sc_rc == IPC_CALLRET_FATAL \|\| sc_rc == IPC_CALLRET_TEMPORARY)
306	return;	306	return;
307		307
308	memset(&call, 0, sizeof(call));	308	memset(&call, 0, sizeof(call));
309	rc = udebug_mem_read(phoneid, &call.args, sc_args[1], sizeof(call.args));	309	rc = udebug_mem_read(phoneid, &call.args, sc_args[1], sizeof(call.args));
310		310
311	if (rc >= 0) {	311	if (rc >= 0) {
312	ipcp_call_out(sc_args[0], &call, sc_rc);	312	ipcp_call_out(sc_args[0], &call, sc_rc);
313	}	313	}
314	}	314	}
315		315
316	static void sc_ipc_call_sync_fast(sysarg_t *sc_args)	316	static void sc_ipc_call_sync_fast(sysarg_t *sc_args)
317	{	317	{
318	ipc_call_t question, reply;	318	ipc_call_t question, reply;
319	int rc;	319	int rc;
320	int phoneidx;	320	int phoneidx;
321		321
322	// printf("sc_ipc_call_sync_fast()\n");	322	// printf("sc_ipc_call_sync_fast()\n");
323	phoneidx = sc_args[0];	323	phoneidx = sc_args[0];
324		324
325	IPC_SET_METHOD(question, sc_args[1]);	325	IPC_SET_METHOD(question, sc_args[1]);
326	IPC_SET_ARG1(question, sc_args[2]);	326	IPC_SET_ARG1(question, sc_args[2]);
327	IPC_SET_ARG2(question, sc_args[3]);	327	IPC_SET_ARG2(question, sc_args[3]);
328	IPC_SET_ARG3(question, sc_args[4]);	328	IPC_SET_ARG3(question, sc_args[4]);
329	IPC_SET_ARG4(question, 0);	329	IPC_SET_ARG4(question, 0);
330	IPC_SET_ARG5(question, 0);	330	IPC_SET_ARG5(question, 0);
331		331
332	// printf("memset\n");	332	// printf("memset\n");
333	memset(&reply, 0, sizeof(reply));	333	memset(&reply, 0, sizeof(reply));
334	// printf("udebug_mem_read(phone=%d, buffer_ptr=%u, src_addr=%d, n=%d\n",	334	// printf("udebug_mem_read(phone=%d, buffer_ptr=%u, src_addr=%d, n=%d\n",
335	// phoneid, &reply.args, sc_args[5], sizeof(reply.args));	335	// phoneid, &reply.args, sc_args[5], sizeof(reply.args));
336	rc = udebug_mem_read(phoneid, &reply.args, sc_args[5], sizeof(reply.args));	336	rc = udebug_mem_read(phoneid, &reply.args, sc_args[5], sizeof(reply.args));
337	// printf("dmr->%d\n", rc);	337	// printf("dmr->%d\n", rc);
338	if (rc < 0) return;	338	if (rc < 0) return;
339		339
340	// printf("call ipc_call_sync\n");	340	// printf("call ipc_call_sync\n");
341	ipcp_call_sync(phoneidx, &question, &reply);	341	ipcp_call_sync(phoneidx, &question, &reply);
342	}	342	}
343		343
344	static void sc_ipc_call_sync_slow_b(unsigned thread_id, sysarg_t *sc_args)	344	static void sc_ipc_call_sync_slow_b(unsigned thread_id, sysarg_t *sc_args)
345	{	345	{
346	ipc_call_t question, reply;	346	ipc_call_t question, reply;
347	int rc;	347	int rc;
348		348
349	memset(&question, 0, sizeof(question));	349	memset(&question, 0, sizeof(question));
350	rc = udebug_mem_read(phoneid, &question.args, sc_args[1], sizeof(question.args));	350	rc = udebug_mem_read(phoneid, &question.args, sc_args[1], sizeof(question.args));
351	if (rc < 0) {	351	if (rc < 0) {
352	printf("Error: mem_read->%d\n", rc);	352	printf("Error: mem_read->%d\n", rc);
353	return;	353	return;
354	}	354	}
355		355
356	thread_ipc_req[thread_id] = question;	356	thread_ipc_req[thread_id] = question;
357	}	357	}
358		358
359	static void sc_ipc_call_sync_slow_e(unsigned thread_id, sysarg_t *sc_args)	359	static void sc_ipc_call_sync_slow_e(unsigned thread_id, sysarg_t *sc_args)
360	{	360	{
361	ipc_call_t question, reply;	361	ipc_call_t question, reply;
362	int rc;	362	int rc;
363		363
364	memset(&reply, 0, sizeof(reply));	364	memset(&reply, 0, sizeof(reply));
365	rc = udebug_mem_read(phoneid, &reply.args, sc_args[2], sizeof(reply.args));	365	rc = udebug_mem_read(phoneid, &reply.args, sc_args[2], sizeof(reply.args));
366	if (rc < 0) {	366	if (rc < 0) {
367	printf("Error: mem_read->%d\n", rc);	367	printf("Error: mem_read->%d\n", rc);
368	return;	368	return;
369	}	369	}
370		370
371	ipcp_call_sync(sc_args[0], &thread_ipc_req[thread_id], &reply);	371	ipcp_call_sync(sc_args[0], &thread_ipc_req[thread_id], &reply);
372	}	372	}
373		373
374	static void sc_ipc_wait(sysarg_t *sc_args, int sc_rc)	374	static void sc_ipc_wait(sysarg_t *sc_args, int sc_rc)
375	{	375	{
376	ipc_call_t call;	376	ipc_call_t call;
377	int rc;	377	int rc;
378		378
379	if (sc_rc == 0) return;	379	if (sc_rc == 0) return;
380		380
381	memset(&call, 0, sizeof(call));	381	memset(&call, 0, sizeof(call));
382	rc = udebug_mem_read(phoneid, &call, sc_args[0], sizeof(call));	382	rc = udebug_mem_read(phoneid, &call, sc_args[0], sizeof(call));
383	// printf("udebug_mem_read(phone %d, dest %d, app-mem src %d, size %d -> %d\n",	383	// printf("udebug_mem_read(phone %d, dest %d, app-mem src %d, size %d -> %d\n",
384	// phoneid, (int)&call, sc_args[0], sizeof(call), rc);	384	// phoneid, (int)&call, sc_args[0], sizeof(call), rc);
385		385
386	if (rc >= 0) {	386	if (rc >= 0) {
387	ipcp_call_in(&call, sc_rc);	387	ipcp_call_in(&call, sc_rc);
388	}	388	}
389	}	389	}
390		390
391	static void event_syscall_b(unsigned thread_id, uintptr_t thread_hash,	391	static void event_syscall_b(unsigned thread_id, uintptr_t thread_hash,
392	unsigned sc_id, sysarg_t sc_rc)	392	unsigned sc_id, sysarg_t sc_rc)
393	{	393	{
394	sysarg_t sc_args[6];	394	sysarg_t sc_args[6];
395	int rc;	395	int rc;
396		396
397	/* Read syscall arguments */	397	/* Read syscall arguments */
398	rc = udebug_args_read(phoneid, thread_hash, sc_args);	398	rc = udebug_args_read(phoneid, thread_hash, sc_args);
399		399
400	async_serialize_start();	400	async_serialize_start();
401		401
402	// printf("[%d] ", thread_id);	402	// printf("[%d] ", thread_id);
403		403
404	if (rc < 0) {	404	if (rc < 0) {
405	printf("error\n");	405	printf("error\n");
406	async_serialize_end();	406	async_serialize_end();
407	return;	407	return;
408	}	408	}
409		409
410	if ((display_mask & DM_SYSCALL) != 0) {	410	if ((display_mask & DM_SYSCALL) != 0) {
411	/* Print syscall name and arguments */	411	/* Print syscall name and arguments */
412	printf("%s", syscall_desc[sc_id].name);	412	printf("%s", syscall_desc[sc_id].name);
413	print_sc_args(sc_args, syscall_desc[sc_id].n_args);	413	print_sc_args(sc_args, syscall_desc[sc_id].n_args);
414	}	414	}
415		415
416	switch (sc_id) {	416	switch (sc_id) {
417	case SYS_IPC_CALL_SYNC_SLOW:	417	case SYS_IPC_CALL_SYNC_SLOW:
418	sc_ipc_call_sync_slow_b(thread_id, sc_args);	418	sc_ipc_call_sync_slow_b(thread_id, sc_args);
419	break;	419	break;
420	default:	420	default:
421	break;	421	break;
422	}	422	}
423		423
424	async_serialize_end();	424	async_serialize_end();
425	}	425	}
426		426
427	static void event_syscall_e(unsigned thread_id, uintptr_t thread_hash,	427	static void event_syscall_e(unsigned thread_id, uintptr_t thread_hash,
428	unsigned sc_id, sysarg_t sc_rc)	428	unsigned sc_id, sysarg_t sc_rc)
429	{	429	{
430	sysarg_t sc_args[6];	430	sysarg_t sc_args[6];
431	int rv_type;	431	int rv_type;
432	int rc;	432	int rc;
433		433
434	/* Read syscall arguments */	434	/* Read syscall arguments */
435	rc = udebug_args_read(phoneid, thread_hash, sc_args);	435	rc = udebug_args_read(phoneid, thread_hash, sc_args);
436		436
437	async_serialize_start();	437	async_serialize_start();
438		438
439	// printf("[%d] ", thread_id);	439	// printf("[%d] ", thread_id);
440		440
441	if (rc < 0) {	441	if (rc < 0) {
442	printf("error\n");	442	printf("error\n");
443	async_serialize_end();	443	async_serialize_end();
444	return;	444	return;
445	}	445	}
446		446
447	if ((display_mask & DM_SYSCALL) != 0) {	447	if ((display_mask & DM_SYSCALL) != 0) {
448	/* Print syscall return value */	448	/* Print syscall return value */
449	rv_type = syscall_desc[sc_id].rv_type;	449	rv_type = syscall_desc[sc_id].rv_type;
450	print_sc_retval(sc_rc, rv_type);	450	print_sc_retval(sc_rc, rv_type);
451	}	451	}
452		452
453	switch (sc_id) {	453	switch (sc_id) {
454	case SYS_IPC_CALL_ASYNC_FAST:	454	case SYS_IPC_CALL_ASYNC_FAST:
455	sc_ipc_call_async_fast(sc_args, sc_rc);	455	sc_ipc_call_async_fast(sc_args, sc_rc);
456	break;	456	break;
457	case SYS_IPC_CALL_ASYNC_SLOW:	457	case SYS_IPC_CALL_ASYNC_SLOW:
458	sc_ipc_call_async_slow(sc_args, sc_rc);	458	sc_ipc_call_async_slow(sc_args, sc_rc);
459	break;	459	break;
460	case SYS_IPC_CALL_SYNC_FAST:	460	case SYS_IPC_CALL_SYNC_FAST:
461	sc_ipc_call_sync_fast(sc_args);	461	sc_ipc_call_sync_fast(sc_args);
462	break;	462	break;
463	case SYS_IPC_CALL_SYNC_SLOW:	463	case SYS_IPC_CALL_SYNC_SLOW:
464	sc_ipc_call_sync_slow_e(thread_id, sc_args);	464	sc_ipc_call_sync_slow_e(thread_id, sc_args);
465	break;	465	break;
466	case SYS_IPC_WAIT:	466	case SYS_IPC_WAIT:
467	sc_ipc_wait(sc_args, sc_rc);	467	sc_ipc_wait(sc_args, sc_rc);
468	break;	468	break;
469	default:	469	default:
470	break;	470	break;
471	}	471	}
472		472
473	async_serialize_end();	473	async_serialize_end();
474	}	474	}
475		475
476	static void event_thread_b(uintptr_t hash)	476	static void event_thread_b(uintptr_t hash)
477	{	477	{
478	async_serialize_start();	478	async_serialize_start();
479	printf("New thread, hash 0x%lx\n", hash);	479	printf("New thread, hash 0x%lx\n", hash);
480	async_serialize_end();	480	async_serialize_end();
481		481
482	thread_trace_start(hash);	482	thread_trace_start(hash);
483	}	483	}
484		484
485	static int trace_loop(void *thread_hash_arg)	485	static int trace_loop(void *thread_hash_arg)
486	{	486	{
487	int rc;	487	int rc;
488	unsigned ev_type;	488	unsigned ev_type;
489	uintptr_t thread_hash;	489	uintptr_t thread_hash;
490	unsigned thread_id;	490	unsigned thread_id;
491	sysarg_t val0, val1;	491	sysarg_t val0, val1;
492		492
493	thread_hash = (uintptr_t)thread_hash_arg;	493	thread_hash = (uintptr_t)thread_hash_arg;
494	thread_id = next_thread_id++;	494	thread_id = next_thread_id++;
495	if (thread_id >= THBUF_SIZE) {	495	if (thread_id >= THBUF_SIZE) {
496	printf("Too many threads.\n");	496	printf("Too many threads.\n");
497	return ELIMIT;	497	return ELIMIT;
498	}	498	}
499		499
500	printf("Start tracing thread [%d] (hash 0x%lx).\n", thread_id, thread_hash);	500	printf("Start tracing thread [%d] (hash 0x%lx).\n", thread_id, thread_hash);

Subversion Repositories HelenOS

(root)/trunk/uspace/app/trace/trace.c – Rev 4660 → 4661