WebSVN – HelenOS – Diff – /branches/tracing/uspace/app/debug/main.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 debug
 * @{
 */
/** @file
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <libarch/syscall.h>
#include <ipc/ipc.h>
#include <fibril.h>
#include <loader/loader.h>
#include <errno.h>
#include <udebug.h>
#include <async.h>
#include <string.h>
 
#include "cmd.h"
#include "cons.h"
#include "dthread.h"
#include "breakpoint.h"
#include "include/arch.h"
#include "main.h"
 
void thread_debug_start(unsigned thread_hash);
 
#define IN_BUF_SIZE 64
static char in_buf[IN_BUF_SIZE];
 
#define MAX_ARGC 10
int cmd_argc;
char *cmd_argv[MAX_ARGC + 1];   /* need one spare field for cmd_split() */
 
 
int next_thread_id;
 
int app_phone;
volatile bool abort_debug;
 
volatile int paused;
 
static task_id_t task_id;
static loader_t *task_ldr;
 
static int program_run_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 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;
 
    return 0;
}
 
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;
 
    /* 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 void command_split(char *cmd_str)
{
    char *p = cmd_str;
 
    if (*p == '\0') {
        cmd_argc = 0;
        return;
    }
 
    cmd_argc = 1;
    cmd_argv[0] = p;
 
    while (*p != '\0') {
        if (*p == ' ') {
            cmd_argv[cmd_argc++] = p + 1;
            *p = '\0';
        }
        ++p;
    }
}
 
static void command_run(void)
{
    int i;
    int cmp_len;
    int len;
 
    int idx_found;
    int num_found;
 
    len = str_length(cmd_argv[0]);
    cmp_len = 1;
 
    /* Silence warnings */
    num_found = 0;
    idx_found = 0;
 
    while (cmp_len <= len + 1) {
 
        num_found = 0;
        i = 0;
        while (cmd_table[i].name != NULL) {
            if (str_lcmp(cmd_table[i].name, cmd_argv[0], cmp_len) == 0) {
                idx_found = i;
                ++num_found;
            }
            ++i;
        }
 
        if (num_found < 2) break;
 
        ++cmp_len;
    }
 
    if (num_found == 0) {
        cons_printf("Unknown command. Try one of:\n");
        cmd_help(0, NULL);
        return;
    }
 
    if (cmd_argc - 1 != cmd_table[idx_found].argc) {
        cons_printf("Command '%s' expects %d arguments\n",
        cmd_table[idx_found].name, cmd_table[idx_found].argc);
        return;
    }
 
    (*cmd_table[idx_found].proc)(cmd_argc, cmd_argv);
}
 
static void thread_stop(void)
{
    dthread_t *dt;
    uintptr_t pc;
 
    dt = dthread_get();
    pc = dthread_get_pc(dt);
    cons_printf("[thread %d] stopped at 0x%lx\n", dt->id, pc);
    dthread_stop_me();
    cons_printf("[thread %d] go\n", dt->id);
}
 
/*
 * Called by a fibril (from arch code) when a breakpoint is hit.
 */
void breakpoint_hit(breakpoint_t *b)
{
    dthread_t *dt;
 
    dt = dthread_get();
    cons_printf("Thread %d hit breakpoint %d at 0x%lx\n",
        dt->id, b->id, b->addr);
    thread_stop();
}
 
/*
 * Called by a fibril (from arch code) when a single instruction
 * in singlestep is executed
 */
void singlestep_hit(void)
{
    cons_printf("singlestep hit\n");
    thread_stop();
}
 
static int connect_task(task_id_t task_id)
{
    int rc;
    unsigned evmask;
 
    cons_printf("ipc_connect_kbox(%;;d)... ", task_id);
    rc = ipc_connect_kbox(task_id);
    cons_printf("-> %d\n", rc);
    app_phone = rc;
    if (rc < 0) return rc;
 
    cons_printf("udebug_begin()... ");
    rc = udebug_begin(app_phone);
    cons_printf("-> %d\n", rc);
    if (rc < 0) return rc;
 
    evmask = UDEBUG_EM_ALL & ~(UDEBUG_EM_SYSCALL_B | UDEBUG_EM_SYSCALL_E);
    cons_printf("udebug_set_evmask(0x%x)... ", evmask);
    rc = udebug_set_evmask(app_phone, evmask);
    cons_printf("-> %d\n", rc);
    if (rc < 0) return rc;
 
    return 0;
}
 
#define THASH_BUF_INIT_LENGTH 32
 
static int get_thread_list(thash_t **thash_buf_ptr, int *n)
{
    int rc;
    size_t tb_copied;
    size_t tb_needed;
    int i;
    size_t tb_size;
    thash_t *thash_buf;
 
    tb_size = THASH_BUF_INIT_LENGTH * sizeof(thash_t);
    thash_buf = malloc(tb_size);
 
    rc = udebug_thread_read(app_phone, thash_buf,
        tb_size, &tb_copied, &tb_needed);
    if (rc < 0) return rc;
 
    if (tb_needed > tb_size) {
        /* Larger buffer needed  */
 
        free(thash_buf);
 
        tb_size = tb_needed;
        thash_buf = malloc(tb_size);
 
        if (!thash_buf) {
            printf("malloc failed\n");
            exit(1);
        }
 
        /* Try again */
       
        rc = udebug_thread_read(app_phone, thash_buf,
            tb_size, &tb_copied, &tb_needed);
 
        if (rc < 0) return rc;
    }
 
    *n = tb_copied / sizeof(thash_t);
 
    cons_printf("thread hashes:");
 
    for (i = 0; i < *n; ++i) {
        cons_printf("0x%x\n", thash_buf[i]);
    }
 
    cons_printf("Total of %u threads\n", *n);
 
    *thash_buf_ptr = thash_buf;
 
    return 0;
}
 
static void event_thread_b(unsigned hash)
{
    async_serialize_start();
    cons_printf("new thread, hash 0x%x\n", hash);
    async_serialize_end();
 
    thread_debug_start(hash);
}
 
static void debug_event(thash_t thash, udebug_event_t ev_type, sysarg_t val0)
{
    switch (ev_type) {
    case UDEBUG_EVENT_STOP:
        cons_printf("stop event\n");
        thread_stop();
        break;
    case UDEBUG_EVENT_THREAD_B:
        event_thread_b(val0);
        break;
    case UDEBUG_EVENT_THREAD_E:
        cons_printf("thread 0x%x exited\n", val0);
        abort_debug = true;
        break;
    case UDEBUG_EVENT_BREAKPOINT:
        arch_event_breakpoint(thash);
        break;
    case UDEBUG_EVENT_TRAP:
        arch_event_trap(dthread_get());
        break;
    default:
        cons_printf("unknown event type %d\n", ev_type);
        break;
    }
}
 
static int debug_loop(void *dt_arg)
{
    int rc;
    udebug_event_t ev_type;
    unsigned val0, val1;
    dthread_t *dt;
 
    dt = (dthread_t *)dt_arg;
 
    cons_printf("debug_loop(%d)\n", dt->id);
 
    while (!abort_debug) {
 
        /* Run thread until an event occurs */
        rc = udebug_go(app_phone, dt->hash, &ev_type, &val0, &val1);
 
        if (ev_type == UDEBUG_EVENT_FINISHED) {
            cons_printf("thread %u debugging finished\n", dt->id);
            break;
        }
        if (rc >= 0) debug_event(dt->hash, ev_type, val0);
    }
 
    cons_printf("debug_loop(%d) exiting\n", dt->id);
    return 0;
}
 
void thread_debug_start(unsigned thash)
{
    fid_t fid;
    dthread_t *dt;
 
    dt = dthread_new(thash);
 
    fid = fibril_create(debug_loop, (void *)dt);
    if (fid == 0) {
        cons_printf("Warning: Failed creating fibril\n");
    }
    dt->fid = fid;
 
    fibril_add_ready(fid);
}
 
static void debug_task(task_id_t task_id)
{
    int i;
    int rc;
 
    thash_t *thash_buffer;
    int n_threads;
 
    rc = get_thread_list(&thash_buffer, &n_threads);
    if (rc < 0) {
        cons_printf("Failed to get thread list\n", rc);
        return;
    }
 
    abort_debug = false;
 
    for (i = 0; i < n_threads; i++) {
        thread_debug_start(thash_buffer[i]);
    }
 
    while (!quit) {
        cons_read_line(in_buf, IN_BUF_SIZE);
        command_split(in_buf);
        if (cmd_argc == 0) continue;
 
        command_run();
    }
 
    cons_printf("terminate debugging session...\n");
    abort_debug = true;
    udebug_end(app_phone);
    ipc_hangup(app_phone);
 
    cons_printf("done\n");
    return;
}
 
static void main_init(void)
{
    next_thread_id = 1;
    paused = 0;
   
    list_initialize(&dthreads);
    breakpoint_init();
    cwt = NULL;
}
 
static void print_syntax()
{
    printf("Syntax:\n");
    printf("\tdebug <executable> [<arg1> [...]]\n");
    printf("or\tdebug -t <task_id>\n");
}
 
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] == '-') {
            if (arg[1] == 't') {
                /* Trace an already running task */
                --argc; ++argv;
                task_id = strtol(*argv, &err_p, 10);
                task_ldr = NULL;
                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);
 
    return 0;
}
 
int main(int argc, char *argv[])
{
    int rc;
 
    cons_printf("Breakpoint Debugger\n");
 
    main_init();
 
    if (parse_args(argc, argv) < 0)
        return 1;
 
    rc = connect_task(task_id);
    if (rc < 0) {
        printf("Failed connecting to task %lld\n", task_id);
        return 1;
    }
 
    cons_printf("Connected to task %lld\n", task_id);
 
    if (task_ldr != NULL) {
        program_run();
    }
 
    debug_task(task_id);
 
    return 0;
}
 
/** @}
 */
 

Rev 4377	Rev 4380
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 debug	29	/** @addtogroup debug
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 <libarch/syscall.h>	38	#include <libarch/syscall.h>
39	#include <ipc/ipc.h>	39	#include <ipc/ipc.h>
40	#include <fibril.h>	40	#include <fibril.h>
41	#include <loader/loader.h>	41	#include <loader/loader.h>
42	#include <errno.h>	42	#include <errno.h>
43	#include <udebug.h>	43	#include <udebug.h>
44	#include <async.h>	44	#include <async.h>
45	#include <string.h>	45	#include <string.h>
46		46
47	#include "cmd.h"	47	#include "cmd.h"
48	#include "cons.h"	48	#include "cons.h"
49	#include "dthread.h"	49	#include "dthread.h"
50	#include "breakpoint.h"	50	#include "breakpoint.h"
51	#include "include/arch.h"	51	#include "include/arch.h"
52	#include "main.h"	52	#include "main.h"
53		53
54	void thread_debug_start(unsigned thread_hash);	54	void thread_debug_start(unsigned thread_hash);
55		55
56	#define IN_BUF_SIZE 64	56	#define IN_BUF_SIZE 64
57	static char in_buf[IN_BUF_SIZE];	57	static char in_buf[IN_BUF_SIZE];
58		58
59	#define MAX_ARGC 10	59	#define MAX_ARGC 10
60	int cmd_argc;	60	int cmd_argc;
61	char cmd_argv[MAX_ARGC + 1]; / need one spare field for cmd_split() */	61	char cmd_argv[MAX_ARGC + 1]; / need one spare field for cmd_split() */
62		62
63		63
64	int next_thread_id;	64	int next_thread_id;
65		65
66	int app_phone;	66	int app_phone;
67	volatile bool abort_debug;	67	volatile bool abort_debug;
68		68
69	volatile int paused;	69	volatile int paused;
70		70
71	static task_id_t task_id;	71	static task_id_t task_id;
72	static loader_t *task_ldr;	72	static loader_t *task_ldr;
73		73
74	static int program_run_fibril(void *arg);	74	static int program_run_fibril(void *arg);
75		75
76	static void program_run(void)	76	static void program_run(void)
77	{	77	{
78	fid_t fid;	78	fid_t fid;
79		79
80	fid = fibril_create(program_run_fibril, NULL);	80	fid = fibril_create(program_run_fibril, NULL);
81	if (fid == 0) {	81	if (fid == 0) {
82	printf("Error creating fibril\n");	82	printf("Error creating fibril\n");
83	exit(1);	83	exit(1);
84	}	84	}
85		85
86	fibril_add_ready(fid);	86	fibril_add_ready(fid);
87	}	87	}
88		88
89	static int program_run_fibril(void *arg)	89	static int program_run_fibril(void *arg)
90	{	90	{
91	int rc;	91	int rc;
92		92
93	/*	93	/*
94	* This must be done in background as it will block until	94	* This must be done in background as it will block until
95	* we let the task reply to this call.	95	* we let the task reply to this call.
96	*/	96	*/
97	rc = loader_run(task_ldr);	97	rc = loader_run(task_ldr);
98	if (rc != 0) {	98	if (rc != 0) {
99	printf("Error running program\n");	99	printf("Error running program\n");
100	exit(1);	100	exit(1);
101	}	101	}
102		102
103	free(task_ldr);	103	free(task_ldr);
104	task_ldr = NULL;	104	task_ldr = NULL;
105		105
106	return 0;	106	return 0;
107	}	107	}
108		108
109	static loader_t preload_task(const char path, char *const argv[],	109	static loader_t preload_task(const char path, char *const argv[],
110	task_id_t *task_id)	110	task_id_t *task_id)
111	{	111	{
112	loader_t *ldr;	112	loader_t *ldr;
113	int rc;	113	int rc;
114		114
115	/* Spawn a program loader */	115	/* Spawn a program loader */
116	ldr = loader_spawn(path);	116	ldr = loader_connect();
117	if (ldr == NULL)	117	if (ldr == NULL)
118	return 0;	118	return 0;
119		119
120	/* Get task ID. */	120	/* Get task ID. */
121	rc = loader_get_task_id(ldr, task_id);	121	rc = loader_get_task_id(ldr, task_id);
122	if (rc != EOK)	122	if (rc != EOK)
123	goto error;	123	goto error;
124		124
125	/* Send program pathname */	125	/* Send program pathname */
126	rc = loader_set_pathname(ldr, path);	126	rc = loader_set_pathname(ldr, path);
127	if (rc != EOK)	127	if (rc != EOK)
128	goto error;	128	goto error;
129		129
130	/* Send arguments */	130	/* Send arguments */
131	rc = loader_set_args(ldr, argv);	131	rc = loader_set_args(ldr, argv);
132	if (rc != EOK)	132	if (rc != EOK)
133	goto error;	133	goto error;
134		134
135	/* Load the program. */	135	/* Load the program. */
136	rc = loader_load_program(ldr);	136	rc = loader_load_program(ldr);
137	if (rc != EOK)	137	if (rc != EOK)
138	goto error;	138	goto error;
139		139
140	/* Success */	140	/* Success */
141	return ldr;	141	return ldr;
142		142
143	/* Error exit */	143	/* Error exit */
144	error:	144	error:
145	loader_abort(ldr);	145	loader_abort(ldr);
146	free(ldr);	146	free(ldr);
147	return NULL;	147	return NULL;
148	}	148	}
149		149
150		150
151	static void command_split(char *cmd_str)	151	static void command_split(char *cmd_str)
152	{	152	{
153	char *p = cmd_str;	153	char *p = cmd_str;
154		154
155	if (*p == '\0') {	155	if (*p == '\0') {
156	cmd_argc = 0;	156	cmd_argc = 0;
157	return;	157	return;
158	}	158	}
159		159
160	cmd_argc = 1;	160	cmd_argc = 1;
161	cmd_argv[0] = p;	161	cmd_argv[0] = p;
162		162
163	while (*p != '\0') {	163	while (*p != '\0') {
164	if (*p == ' ') {	164	if (*p == ' ') {
165	cmd_argv[cmd_argc++] = p + 1;	165	cmd_argv[cmd_argc++] = p + 1;
166	*p = '\0';	166	*p = '\0';
167	}	167	}
168	++p;	168	++p;
169	}	169	}
170	}	170	}
171		171
172	static void command_run(void)	172	static void command_run(void)
173	{	173	{
174	int i;	174	int i;
175	int cmp_len;	175	int cmp_len;
176	int len;	176	int len;
177		177
178	int idx_found;	178	int idx_found;
179	int num_found;	179	int num_found;
180		180
181	len = str_length(cmd_argv[0]);	181	len = str_length(cmd_argv[0]);
182	cmp_len = 1;	182	cmp_len = 1;
183		183
184	/* Silence warnings */	184	/* Silence warnings */
185	num_found = 0;	185	num_found = 0;
186	idx_found = 0;	186	idx_found = 0;
187		187
188	while (cmp_len <= len + 1) {	188	while (cmp_len <= len + 1) {
189		189
190	num_found = 0;	190	num_found = 0;
191	i = 0;	191	i = 0;
192	while (cmd_table[i].name != NULL) {	192	while (cmd_table[i].name != NULL) {
193	if (str_lcmp(cmd_table[i].name, cmd_argv[0], cmp_len) == 0) {	193	if (str_lcmp(cmd_table[i].name, cmd_argv[0], cmp_len) == 0) {
194	idx_found = i;	194	idx_found = i;
195	++num_found;	195	++num_found;
196	}	196	}
197	++i;	197	++i;
198	}	198	}
199		199
200	if (num_found < 2) break;	200	if (num_found < 2) break;
201		201
202	++cmp_len;	202	++cmp_len;
203	}	203	}
204		204
205	if (num_found == 0) {	205	if (num_found == 0) {
206	cons_printf("Unknown command. Try one of:\n");	206	cons_printf("Unknown command. Try one of:\n");
207	cmd_help(0, NULL);	207	cmd_help(0, NULL);
208	return;	208	return;
209	}	209	}
210		210
211	if (cmd_argc - 1 != cmd_table[idx_found].argc) {	211	if (cmd_argc - 1 != cmd_table[idx_found].argc) {
212	cons_printf("Command '%s' expects %d arguments\n",	212	cons_printf("Command '%s' expects %d arguments\n",
213	cmd_table[idx_found].name, cmd_table[idx_found].argc);	213	cmd_table[idx_found].name, cmd_table[idx_found].argc);
214	return;	214	return;
215	}	215	}
216		216
217	(*cmd_table[idx_found].proc)(cmd_argc, cmd_argv);	217	(*cmd_table[idx_found].proc)(cmd_argc, cmd_argv);
218	}	218	}
219		219
220	static void thread_stop(void)	220	static void thread_stop(void)
221	{	221	{
222	dthread_t *dt;	222	dthread_t *dt;
223	uintptr_t pc;	223	uintptr_t pc;
224		224
225	dt = dthread_get();	225	dt = dthread_get();
226	pc = dthread_get_pc(dt);	226	pc = dthread_get_pc(dt);
227	cons_printf("[thread %d] stopped at 0x%lx\n", dt->id, pc);	227	cons_printf("[thread %d] stopped at 0x%lx\n", dt->id, pc);
228	dthread_stop_me();	228	dthread_stop_me();
229	cons_printf("[thread %d] go\n", dt->id);	229	cons_printf("[thread %d] go\n", dt->id);
230	}	230	}
231		231
232	/*	232	/*
233	* Called by a fibril (from arch code) when a breakpoint is hit.	233	* Called by a fibril (from arch code) when a breakpoint is hit.
234	*/	234	*/
235	void breakpoint_hit(breakpoint_t *b)	235	void breakpoint_hit(breakpoint_t *b)
236	{	236	{
237	dthread_t *dt;	237	dthread_t *dt;
238		238
239	dt = dthread_get();	239	dt = dthread_get();
240	cons_printf("Thread %d hit breakpoint %d at 0x%lx\n",	240	cons_printf("Thread %d hit breakpoint %d at 0x%lx\n",
241	dt->id, b->id, b->addr);	241	dt->id, b->id, b->addr);
242	thread_stop();	242	thread_stop();
243	}	243	}
244		244
245	/*	245	/*
246	* Called by a fibril (from arch code) when a single instruction	246	* Called by a fibril (from arch code) when a single instruction
247	* in singlestep is executed	247	* in singlestep is executed
248	*/	248	*/
249	void singlestep_hit(void)	249	void singlestep_hit(void)
250	{	250	{
251	cons_printf("singlestep hit\n");	251	cons_printf("singlestep hit\n");
252	thread_stop();	252	thread_stop();
253	}	253	}
254		254
255	static int connect_task(task_id_t task_id)	255	static int connect_task(task_id_t task_id)
256	{	256	{
257	int rc;	257	int rc;
258	unsigned evmask;	258	unsigned evmask;
259		259
260	cons_printf("ipc_connect_kbox(%;;d)... ", task_id);	260	cons_printf("ipc_connect_kbox(%;;d)... ", task_id);
261	rc = ipc_connect_kbox(task_id);	261	rc = ipc_connect_kbox(task_id);
262	cons_printf("-> %d\n", rc);	262	cons_printf("-> %d\n", rc);
263	app_phone = rc;	263	app_phone = rc;
264	if (rc < 0) return rc;	264	if (rc < 0) return rc;
265		265
266	cons_printf("udebug_begin()... ");	266	cons_printf("udebug_begin()... ");
267	rc = udebug_begin(app_phone);	267	rc = udebug_begin(app_phone);
268	cons_printf("-> %d\n", rc);	268	cons_printf("-> %d\n", rc);
269	if (rc < 0) return rc;	269	if (rc < 0) return rc;
270		270
271	evmask = UDEBUG_EM_ALL & ~(UDEBUG_EM_SYSCALL_B \| UDEBUG_EM_SYSCALL_E);	271	evmask = UDEBUG_EM_ALL & ~(UDEBUG_EM_SYSCALL_B \| UDEBUG_EM_SYSCALL_E);
272	cons_printf("udebug_set_evmask(0x%x)... ", evmask);	272	cons_printf("udebug_set_evmask(0x%x)... ", evmask);
273	rc = udebug_set_evmask(app_phone, evmask);	273	rc = udebug_set_evmask(app_phone, evmask);
274	cons_printf("-> %d\n", rc);	274	cons_printf("-> %d\n", rc);
275	if (rc < 0) return rc;	275	if (rc < 0) return rc;
276		276
277	return 0;	277	return 0;
278	}	278	}
279		279
280	#define THASH_BUF_INIT_LENGTH 32	280	#define THASH_BUF_INIT_LENGTH 32
281		281
282	static int get_thread_list(thash_t *thash_buf_ptr, int n)	282	static int get_thread_list(thash_t *thash_buf_ptr, int n)
283	{	283	{
284	int rc;	284	int rc;
285	size_t tb_copied;	285	size_t tb_copied;
286	size_t tb_needed;	286	size_t tb_needed;
287	int i;	287	int i;
288	size_t tb_size;	288	size_t tb_size;
289	thash_t *thash_buf;	289	thash_t *thash_buf;
290		290
291	tb_size = THASH_BUF_INIT_LENGTH * sizeof(thash_t);	291	tb_size = THASH_BUF_INIT_LENGTH * sizeof(thash_t);
292	thash_buf = malloc(tb_size);	292	thash_buf = malloc(tb_size);
293		293
294	rc = udebug_thread_read(app_phone, thash_buf,	294	rc = udebug_thread_read(app_phone, thash_buf,
295	tb_size, &tb_copied, &tb_needed);	295	tb_size, &tb_copied, &tb_needed);
296	if (rc < 0) return rc;	296	if (rc < 0) return rc;
297		297
298	if (tb_needed > tb_size) {	298	if (tb_needed > tb_size) {
299	/* Larger buffer needed */	299	/* Larger buffer needed */
300		300
301	free(thash_buf);	301	free(thash_buf);
302		302
303	tb_size = tb_needed;	303	tb_size = tb_needed;
304	thash_buf = malloc(tb_size);	304	thash_buf = malloc(tb_size);
305		305
306	if (!thash_buf) {	306	if (!thash_buf) {
307	printf("malloc failed\n");	307	printf("malloc failed\n");
308	exit(1);	308	exit(1);
309	}	309	}
310		310
311	/* Try again */	311	/* Try again */
312		312
313	rc = udebug_thread_read(app_phone, thash_buf,	313	rc = udebug_thread_read(app_phone, thash_buf,
314	tb_size, &tb_copied, &tb_needed);	314	tb_size, &tb_copied, &tb_needed);
315		315
316	if (rc < 0) return rc;	316	if (rc < 0) return rc;
317	}	317	}
318		318
319	*n = tb_copied / sizeof(thash_t);	319	*n = tb_copied / sizeof(thash_t);
320		320
321	cons_printf("thread hashes:");	321	cons_printf("thread hashes:");
322		322
323	for (i = 0; i < *n; ++i) {	323	for (i = 0; i < *n; ++i) {
324	cons_printf("0x%x\n", thash_buf[i]);	324	cons_printf("0x%x\n", thash_buf[i]);
325	}	325	}
326		326
327	cons_printf("Total of %u threads\n", *n);	327	cons_printf("Total of %u threads\n", *n);
328		328
329	*thash_buf_ptr = thash_buf;	329	*thash_buf_ptr = thash_buf;
330		330
331	return 0;	331	return 0;
332	}	332	}
333		333
334	static void event_thread_b(unsigned hash)	334	static void event_thread_b(unsigned hash)
335	{	335	{
336	async_serialize_start();	336	async_serialize_start();
337	cons_printf("new thread, hash 0x%x\n", hash);	337	cons_printf("new thread, hash 0x%x\n", hash);
338	async_serialize_end();	338	async_serialize_end();
339		339
340	thread_debug_start(hash);	340	thread_debug_start(hash);
341	}	341	}
342		342
343	static void debug_event(thash_t thash, udebug_event_t ev_type, sysarg_t val0)	343	static void debug_event(thash_t thash, udebug_event_t ev_type, sysarg_t val0)
344	{	344	{
345	switch (ev_type) {	345	switch (ev_type) {
346	case UDEBUG_EVENT_STOP:	346	case UDEBUG_EVENT_STOP:
347	cons_printf("stop event\n");	347	cons_printf("stop event\n");
348	thread_stop();	348	thread_stop();
349	break;	349	break;
350	case UDEBUG_EVENT_THREAD_B:	350	case UDEBUG_EVENT_THREAD_B:
351	event_thread_b(val0);	351	event_thread_b(val0);
352	break;	352	break;
353	case UDEBUG_EVENT_THREAD_E:	353	case UDEBUG_EVENT_THREAD_E:
354	cons_printf("thread 0x%x exited\n", val0);	354	cons_printf("thread 0x%x exited\n", val0);
355	abort_debug = true;	355	abort_debug = true;
356	break;	356	break;
357	case UDEBUG_EVENT_BREAKPOINT:	357	case UDEBUG_EVENT_BREAKPOINT:
358	arch_event_breakpoint(thash);	358	arch_event_breakpoint(thash);
359	break;	359	break;
360	case UDEBUG_EVENT_TRAP:	360	case UDEBUG_EVENT_TRAP:
361	arch_event_trap(dthread_get());	361	arch_event_trap(dthread_get());
362	break;	362	break;
363	default:	363	default:
364	cons_printf("unknown event type %d\n", ev_type);	364	cons_printf("unknown event type %d\n", ev_type);
365	break;	365	break;
366	}	366	}
367	}	367	}
368		368
369	static int debug_loop(void *dt_arg)	369	static int debug_loop(void *dt_arg)
370	{	370	{
371	int rc;	371	int rc;
372	udebug_event_t ev_type;	372	udebug_event_t ev_type;
373	unsigned val0, val1;	373	unsigned val0, val1;
374	dthread_t *dt;	374	dthread_t *dt;
375		375
376	dt = (dthread_t *)dt_arg;	376	dt = (dthread_t *)dt_arg;
377		377
378	cons_printf("debug_loop(%d)\n", dt->id);	378	cons_printf("debug_loop(%d)\n", dt->id);
379		379
380	while (!abort_debug) {	380	while (!abort_debug) {
381		381
382	/* Run thread until an event occurs */	382	/* Run thread until an event occurs */
383	rc = udebug_go(app_phone, dt->hash, &ev_type, &val0, &val1);	383	rc = udebug_go(app_phone, dt->hash, &ev_type, &val0, &val1);
384		384
385	if (ev_type == UDEBUG_EVENT_FINISHED) {	385	if (ev_type == UDEBUG_EVENT_FINISHED) {
386	cons_printf("thread %u debugging finished\n", dt->id);	386	cons_printf("thread %u debugging finished\n", dt->id);
387	break;	387	break;
388	}	388	}
389	if (rc >= 0) debug_event(dt->hash, ev_type, val0);	389	if (rc >= 0) debug_event(dt->hash, ev_type, val0);
390	}	390	}
391		391
392	cons_printf("debug_loop(%d) exiting\n", dt->id);	392	cons_printf("debug_loop(%d) exiting\n", dt->id);
393	return 0;	393	return 0;
394	}	394	}
395		395
396	void thread_debug_start(unsigned thash)	396	void thread_debug_start(unsigned thash)
397	{	397	{
398	fid_t fid;	398	fid_t fid;
399	dthread_t *dt;	399	dthread_t *dt;
400		400
401	dt = dthread_new(thash);	401	dt = dthread_new(thash);
402		402
403	fid = fibril_create(debug_loop, (void *)dt);	403	fid = fibril_create(debug_loop, (void *)dt);
404	if (fid == 0) {	404	if (fid == 0) {
405	cons_printf("Warning: Failed creating fibril\n");	405	cons_printf("Warning: Failed creating fibril\n");
406	}	406	}
407	dt->fid = fid;	407	dt->fid = fid;
408		408
409	fibril_add_ready(fid);	409	fibril_add_ready(fid);
410	}	410	}
411		411
412	static void debug_task(task_id_t task_id)	412	static void debug_task(task_id_t task_id)
413	{	413	{
414	int i;	414	int i;
415	int rc;	415	int rc;
416		416
417	thash_t *thash_buffer;	417	thash_t *thash_buffer;
418	int n_threads;	418	int n_threads;
419		419
420	rc = get_thread_list(&thash_buffer, &n_threads);	420	rc = get_thread_list(&thash_buffer, &n_threads);
421	if (rc < 0) {	421	if (rc < 0) {
422	cons_printf("Failed to get thread list\n", rc);	422	cons_printf("Failed to get thread list\n", rc);
423	return;	423	return;
424	}	424	}
425		425
426	abort_debug = false;	426	abort_debug = false;
427		427
428	for (i = 0; i < n_threads; i++) {	428	for (i = 0; i < n_threads; i++) {
429	thread_debug_start(thash_buffer[i]);	429	thread_debug_start(thash_buffer[i]);
430	}	430	}
431		431
432	while (!quit) {	432	while (!quit) {
433	cons_read_line(in_buf, IN_BUF_SIZE);	433	cons_read_line(in_buf, IN_BUF_SIZE);
434	command_split(in_buf);	434	command_split(in_buf);
435	if (cmd_argc == 0) continue;	435	if (cmd_argc == 0) continue;
436		436
437	command_run();	437	command_run();
438	}	438	}
439		439
440	cons_printf("terminate debugging session...\n");	440	cons_printf("terminate debugging session...\n");
441	abort_debug = true;	441	abort_debug = true;
442	udebug_end(app_phone);	442	udebug_end(app_phone);
443	ipc_hangup(app_phone);	443	ipc_hangup(app_phone);
444		444
445	cons_printf("done\n");	445	cons_printf("done\n");
446	return;	446	return;
447	}	447	}
448		448
449	static void main_init(void)	449	static void main_init(void)
450	{	450	{
451	next_thread_id = 1;	451	next_thread_id = 1;
452	paused = 0;	452	paused = 0;
453		453
454	list_initialize(&dthreads);	454	list_initialize(&dthreads);
455	breakpoint_init();	455	breakpoint_init();
456	cwt = NULL;	456	cwt = NULL;
457	}	457	}
458		458
459	static void print_syntax()	459	static void print_syntax()
460	{	460	{
461	printf("Syntax:\n");	461	printf("Syntax:\n");
462	printf("\tdebug <executable> [<arg1> [...]]\n");	462	printf("\tdebug <executable> [<arg1> [...]]\n");
463	printf("or\tdebug -t <task_id>\n");	463	printf("or\tdebug -t <task_id>\n");
464	}	464	}
465		465
466	static int parse_args(int argc, char *argv[])	466	static int parse_args(int argc, char *argv[])
467	{	467	{
468	char *arg;	468	char *arg;
469	char *err_p;	469	char *err_p;
470		470
471	task_id = 0;	471	task_id = 0;
472		472
473	--argc; ++argv;	473	--argc; ++argv;
474		474
475	while (argc > 0) {	475	while (argc > 0) {
476	arg = *argv;	476	arg = *argv;
477	if (arg[0] == '-') {	477	if (arg[0] == '-') {
478	if (arg[1] == 't') {	478	if (arg[1] == 't') {
479	/* Trace an already running task */	479	/* Trace an already running task */
480	--argc; ++argv;	480	--argc; ++argv;
481	task_id = strtol(*argv, &err_p, 10);	481	task_id = strtol(*argv, &err_p, 10);
482	task_ldr = NULL;	482	task_ldr = NULL;
483	if (*err_p) {	483	if (*err_p) {
484	printf("Task ID syntax error\n");	484	printf("Task ID syntax error\n");
485	print_syntax();	485	print_syntax();
486	return -1;	486	return -1;
487	}	487	}
488	} else {	488	} else {
489	printf("Uknown option '%s'\n", arg[0]);	489	printf("Uknown option '%s'\n", arg[0]);
490	print_syntax();	490	print_syntax();
491	return -1;	491	return -1;
492	}	492	}
493	} else {	493	} else {
494	break;	494	break;
495	}	495	}
496		496
497	--argc; ++argv;	497	--argc; ++argv;
498	}	498	}
499		499
500	if (task_id != 0) {	500	if (task_id != 0) {

Subversion Repositories HelenOS

(root)/branches/tracing/uspace/app/debug/main.c @ 3597 – Rev 4377 → 4380