WebSVN – HelenOS – Diff – /branches/tracing/uspace/app/trace/trace.c


/** @addtogroup sctrace
 * @{
 */
/** @file
 */
 
#include <stdio.h>
#include <unistd.h>
#include <syscall.h>
#include <ipc/ipc.h>
#include <fibril.h>
#include <errno.h>
 
#include "syscalls.h"
#include "errors.h"
#include "debug_api.h"
 
#define TIDBUF_SIZE 64
unsigned threadid_buf[TIDBUF_SIZE];
 
int phoneid;
int abort_trace;
 
int task_connect(int taskid)
{
    int rc;
 
    printf("ipc_connect_task(%d)...\n", taskid);
    rc = ipc_connect_kbox(taskid);
    printf("-> %d\n", rc);
    phoneid = rc;
    if (rc < 0) return rc;
 
    printf("debug_begin()\n");
    rc = debug_begin(phoneid);
    printf("-> %d\n", rc);
    if (rc < 0) return rc;
 
    return 0;
}
 
int get_thread_list(void)
{
    int rc;
    int tb_copied;
    int tb_needed;
    int i;
 
 
    printf("send IPC_M_DEBUG_THREAD_READ message\n");
    rc = debug_thread_read(phoneid, (unsigned)threadid_buf,
        TIDBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);
    printf("-> %d\n", rc);
    if (rc < 0) return rc;
 
    printf("thread IDs:");
    for (i=0; i<tb_copied / sizeof(unsigned); i++) {
        printf(" %u", threadid_buf[i]);
    }
    printf("\ntotal of %u threads\n", tb_needed/sizeof(unsigned));
 
    return 0;
}
 
void print_sc_retval(int retval, rv_type_t rv_type)
{
    printf (" -> ");
    if (rv_type == RV_INTEGER) {
        printf("%d", retval);
    } else if (rv_type == RV_HASH) {
        printf("0x%08x", retval);
    } else if (rv_type == RV_ERRNO) {
        if (retval >= -15 && retval <= 0) {
            printf("%d %s (%s)", retval,
                err_desc[retval].name,
                err_desc[retval].desc);
        } else {
            printf("%d", retval);
        }
    } else if (rv_type == RV_INT_ERRNO) {
        if (retval >= -15 && retval < 0) {
            printf("%d %s (%s)", retval,
                err_desc[retval].name,
                err_desc[retval].desc);
        } else {
            printf("%d", retval);
        }
    }
    putchar('\n');
}
 
void print_sc_args(unsigned *sc_args, int n)
{
    int i;
 
    putchar('(');
    if (n > 0) printf("%d", sc_args[0]);
    for (i=1; i<n; i++) {
        printf(", %d", sc_args[i]);
    }
    putchar(')');
}
 
void sc_ipc_call_async_slow(unsigned *sc_args)
{
    unsigned ipc_args[6];
    int rc;
 
    memset(ipc_args, 0, sizeof(ipc_args));
    rc = debug_mem_read(phoneid, ipc_args, sc_args[1], sizeof(ipc_args));
 
    if (rc >= 0) {
        printf("args: (%u, %u, %u, %u, %u, %u)\n",
            ipc_args[0], ipc_args[1], ipc_args[2],
            ipc_args[3], ipc_args[4], ipc_args[5]);
    }
}
 
int keyboard_fibril(void *arg)
{
    (void)arg;
 
    printf("keyboard fibril started\n");
 
    getchar();
    printf("keyboard fibril setting abort_trace\n");
    abort_trace = 1;
    printf("keyboard fibril sending debug_end()\n");
    debug_end(phoneid);
    printf("keyboard fibril exitting\n");
 
    return EOK;
}
 
void trace_loop(void)
{
    int rc;
    unsigned sc_args[6];
    unsigned copied;
    unsigned ev_type;
    unsigned sc_id;
    int sc_rc;
    int rv_type;
    fid_t kb_fid;
 
    abort_trace = 0;
    kb_fid = fibril_create(keyboard_fibril, NULL);
    if (kb_fid == 0) {
        printf("Failed creating keyboard fibril\n");
        return;
    }
    fibril_add_ready(kb_fid);
 
    while (!abort_trace) {
 
 
        /* Run thread until a syscall is executed */
        rc = debug_go(phoneid, threadid_buf[0],
            &ev_type, &sc_id, &sc_rc);
 
        /* Read syscall arguments */
        if (rc >= 0) {
            rc = debug_args_read(phoneid, threadid_buf[0],
                sc_args);
        }
 
        /* Print syscall name, id and arguments */
        if (rc >= 0) {
            printf("%s", syscall_desc[sc_id].name);
            print_sc_args(sc_args, syscall_desc[sc_id].n_args);
            rv_type = syscall_desc[sc_id].rv_type;
            print_sc_retval(sc_rc, rv_type);
        }
 
        switch (sc_id) {
        case SYS_IPC_CALL_ASYNC_SLOW:
            sc_ipc_call_async_slow(sc_args);
            break;
        default:
            break;
        }
    }
 
    printf("trace_loop() exiting\n");
}
 
 
void trace_active_task(void)
{
    int taskid;
    int i;
    int rc;
 
    printf("Syscall Tracer\n");
    printf("Press 'c' to connect\n");
    while ((i = getchar()) != 'c')
        putchar(i);
 
    taskid = 13;
    rc = task_connect(taskid);
    if (rc < 0) {
        printf("Failed to connect to task %d\n", taskid);
        return;
    }
 
    printf("Connected to task %d\n", taskid);
 
    rc = get_thread_list();
    if (rc < 0) {
        printf("Failed to get thread list (error %d)\n", rc);
        return;
    }
 
    trace_loop();
/*
    printf("press 'd' to disconnect\n");
    while ((i = getchar()) != 'd')
        putchar(i);
 
    printf("call debug_end()\n");
    debug_end(phoneid);
*/
    printf("done\n");
    return;
}
 
int main(void)
{
    while (1) {
        trace_active_task();
    }
}
 
/** @}
 */
 

Rev 2832	Rev 2835
1	/** @addtogroup sctrace	1	/** @addtogroup sctrace
2	* @{	2	* @{
3	*/	3	*/
4	/** @file	4	/** @file
5	*/	5	*/
6		6
7	#include <stdio.h>	7	#include <stdio.h>
8	#include <unistd.h>	8	#include <unistd.h>
9	#include <syscall.h>	9	#include <syscall.h>
10	#include <ipc/ipc.h>	10	#include <ipc/ipc.h>
11	#include <udebug.h>	11	#include <fibril.h>
-		12	#include <errno.h>
12		13
13	#include "syscalls.h"	14	#include "syscalls.h"
14	#include "errors.h"	15	#include "errors.h"
15	#include "debug_api.h"	16	#include "debug_api.h"
16		17
17	#define TIDBUF_SIZE 64	18	#define TIDBUF_SIZE 64
18	unsigned threadid_buf[TIDBUF_SIZE];	19	unsigned threadid_buf[TIDBUF_SIZE];
19		20
20	int phoneid;	21	int phoneid;
-		22	int abort_trace;
21		23
22	int task_connect(int taskid)	24	int task_connect(int taskid)
23	{	25	{
24	int rc;	26	int rc;
25		27
26	printf("ipc_connect_task(%d)...\n", taskid);	28	printf("ipc_connect_task(%d)...\n", taskid);
27	rc = ipc_connect_kbox(taskid);	29	rc = ipc_connect_kbox(taskid);
28	printf("-> %d\n", rc);	30	printf("-> %d\n", rc);
29	phoneid = rc;	31	phoneid = rc;
30	if (rc < 0) return rc;	32	if (rc < 0) return rc;
31		33
32	printf("debug_begin()\n");	34	printf("debug_begin()\n");
33	rc = debug_begin(phoneid);	35	rc = debug_begin(phoneid);
34	printf("-> %d\n", rc);	36	printf("-> %d\n", rc);
35	if (rc < 0) return rc;	37	if (rc < 0) return rc;
36		38
37	return 0;	39	return 0;
38	}	40	}
39		41
40	int get_thread_list(void)	42	int get_thread_list(void)
41	{	43	{
42	int rc;	44	int rc;
43	int tb_copied;	45	int tb_copied;
44	int tb_needed;	46	int tb_needed;
45	int i;	47	int i;
46		48
47		49
48	printf("send IPC_M_DEBUG_THREAD_READ message\n");	50	printf("send IPC_M_DEBUG_THREAD_READ message\n");
49	rc = debug_thread_read(phoneid, (unsigned)threadid_buf,	51	rc = debug_thread_read(phoneid, (unsigned)threadid_buf,
50	TIDBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);	52	TIDBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);
51	printf("-> %d\n", rc);	53	printf("-> %d\n", rc);
52	if (rc < 0) return rc;	54	if (rc < 0) return rc;
53		55
54	printf("thread IDs:");	56	printf("thread IDs:");
55	for (i=0; i<tb_copied / sizeof(unsigned); i++) {	57	for (i=0; i<tb_copied / sizeof(unsigned); i++) {
56	printf(" %u", threadid_buf[i]);	58	printf(" %u", threadid_buf[i]);
57	}	59	}
58	printf("\ntotal of %u threads\n", tb_needed/sizeof(unsigned));	60	printf("\ntotal of %u threads\n", tb_needed/sizeof(unsigned));
59		61
60	return 0;	62	return 0;
61	}	63	}
62		64
63	void print_sc_retval(int retval, rv_type_t rv_type)	65	void print_sc_retval(int retval, rv_type_t rv_type)
64	{	66	{
65	printf (" -> ");	67	printf (" -> ");
66	if (rv_type == RV_INTEGER) {	68	if (rv_type == RV_INTEGER) {
67	printf("%d", retval);	69	printf("%d", retval);
68	} else if (rv_type == RV_HASH) {	70	} else if (rv_type == RV_HASH) {
69	printf("0x%08x", retval);	71	printf("0x%08x", retval);
70	} else if (rv_type == RV_ERRNO) {	72	} else if (rv_type == RV_ERRNO) {
71	if (retval >= -15 && retval <= 0) {	73	if (retval >= -15 && retval <= 0) {
72	printf("%d %s (%s)", retval,	74	printf("%d %s (%s)", retval,
73	err_desc[retval].name,	75	err_desc[retval].name,
74	err_desc[retval].desc);	76	err_desc[retval].desc);
75	} else {	77	} else {
76	printf("%d", retval);	78	printf("%d", retval);
77	}	79	}
78	} else if (rv_type == RV_INT_ERRNO) {	80	} else if (rv_type == RV_INT_ERRNO) {
79	if (retval >= -15 && retval < 0) {	81	if (retval >= -15 && retval < 0) {
80	printf("%d %s (%s)", retval,	82	printf("%d %s (%s)", retval,
81	err_desc[retval].name,	83	err_desc[retval].name,
82	err_desc[retval].desc);	84	err_desc[retval].desc);
83	} else {	85	} else {
84	printf("%d", retval);	86	printf("%d", retval);
85	}	87	}
86	}	88	}
87	putchar('\n');	89	putchar('\n');
88	}	90	}
89		91
90	void print_sc_args(unsigned *sc_args, int n)	92	void print_sc_args(unsigned *sc_args, int n)
91	{	93	{
92	int i;	94	int i;
93		95
94	putchar('(');	96	putchar('(');
95	if (n > 0) printf("%d", sc_args[0]);	97	if (n > 0) printf("%d", sc_args[0]);
96	for (i=1; i<n; i++) {	98	for (i=1; i<n; i++) {
97	printf(", %d", sc_args[i]);	99	printf(", %d", sc_args[i]);
98	}	100	}
99	putchar(')');	101	putchar(')');
100	}	102	}
101		103
102	void sc_ipc_call_async_slow(unsigned *sc_args)	104	void sc_ipc_call_async_slow(unsigned *sc_args)
103	{	105	{
104	unsigned ipc_args[6];	106	unsigned ipc_args[6];
105	int rc;	107	int rc;
106		108
107	memset(ipc_args, 0, sizeof(ipc_args));	109	memset(ipc_args, 0, sizeof(ipc_args));
108	rc = debug_mem_read(phoneid, ipc_args, sc_args[1], sizeof(ipc_args));	110	rc = debug_mem_read(phoneid, ipc_args, sc_args[1], sizeof(ipc_args));
109		111
110	if (rc >= 0) {	112	if (rc >= 0) {
111	printf("args: (%u, %u, %u, %u, %u, %u)\n",	113	printf("args: (%u, %u, %u, %u, %u, %u)\n",
112	ipc_args[0], ipc_args[1], ipc_args[2],	114	ipc_args[0], ipc_args[1], ipc_args[2],
113	ipc_args[3], ipc_args[4], ipc_args[5]);	115	ipc_args[3], ipc_args[4], ipc_args[5]);
114	}	116	}
115	}	117	}
116		118
-		119	int keyboard_fibril(void *arg)
-		120	{
-		121	(void)arg;
-		122
-		123	printf("keyboard fibril started\n");
-		124
-		125	getchar();
-		126	printf("keyboard fibril setting abort_trace\n");
-		127	abort_trace = 1;
-		128	printf("keyboard fibril sending debug_end()\n");
-		129	debug_end(phoneid);
-		130	printf("keyboard fibril exitting\n");
-		131
-		132	return EOK;
-		133	}
-		134
117	void trace_loop(void)	135	void trace_loop(void)
118	{	136	{
119	int rc;	137	int rc;
120	unsigned sc_args[6];	138	unsigned sc_args[6];
121	unsigned copied;	139	unsigned copied;
122	unsigned ev_type;	140	unsigned ev_type;
123	unsigned sc_id;	141	unsigned sc_id;
124	int sc_rc;	142	int sc_rc;
125	int rv_type;	143	int rv_type;
-		144	fid_t kb_fid;
-		145
-		146	abort_trace = 0;
-		147	kb_fid = fibril_create(keyboard_fibril, NULL);
-		148	if (kb_fid == 0) {
-		149	printf("Failed creating keyboard fibril\n");
-		150	return;
-		151	}
-		152	fibril_add_ready(kb_fid);
-		153
-		154	while (!abort_trace) {
126		155
127	while (1) {	-
128	/* Run thread until a syscall is executed */	156	/* Run thread until a syscall is executed */
129	rc = debug_go(phoneid, threadid_buf[0],	157	rc = debug_go(phoneid, threadid_buf[0],
130	&ev_type, &sc_id, &sc_rc);	158	&ev_type, &sc_id, &sc_rc);
131		159
132	/* Read syscall arguments */	160	/* Read syscall arguments */
133	if (rc >= 0) {	161	if (rc >= 0) {
134	rc = debug_args_read(phoneid, threadid_buf[0],	162	rc = debug_args_read(phoneid, threadid_buf[0],
135	sc_args);	163	sc_args);
136	}	164	}
137		165
138	/* Print syscall name, id and arguments */	166	/* Print syscall name, id and arguments */
139	if (rc >= 0) {	167	if (rc >= 0) {
140	printf("%s", syscall_desc[sc_id].name);	168	printf("%s", syscall_desc[sc_id].name);
141	print_sc_args(sc_args, syscall_desc[sc_id].n_args);	169	print_sc_args(sc_args, syscall_desc[sc_id].n_args);
142	rv_type = syscall_desc[sc_id].rv_type;	170	rv_type = syscall_desc[sc_id].rv_type;
143	print_sc_retval(sc_rc, rv_type);	171	print_sc_retval(sc_rc, rv_type);
144	}	172	}
145		173
146	switch (sc_id) {	174	switch (sc_id) {
147	case SYS_IPC_CALL_ASYNC_SLOW:	175	case SYS_IPC_CALL_ASYNC_SLOW:
148	sc_ipc_call_async_slow(sc_args);	176	sc_ipc_call_async_slow(sc_args);
149	break;	177	break;
150	default:	178	default:
151	break;	179	break;
152	}	180	}
153	}	181	}
-		182
-		183	printf("trace_loop() exiting\n");
154	}	184	}
155		185
156		186
157	void trace_active_task(void)	187	void trace_active_task(void)
158	{	188	{
159	int taskid;	189	int taskid;
160	int i;	190	int i;
161	int rc;	191	int rc;
162		192
163	printf("Syscall Tracer\n");	193	printf("Syscall Tracer\n");
164	printf("Press 'c' to connect\n");	194	printf("Press 'c' to connect\n");
165	while ((i = getchar()) != 'c')	195	while ((i = getchar()) != 'c')
166	putchar(i);	196	putchar(i);
167		197
168	taskid = 13;	198	taskid = 13;
169	rc = task_connect(taskid);	199	rc = task_connect(taskid);
170	if (rc < 0) {	200	if (rc < 0) {
171	printf("Failed to connect to task %d\n", taskid);	201	printf("Failed to connect to task %d\n", taskid);
172	return;	202	return;
173	}	203	}
174		204
175	printf("Connected to task %d\n", taskid);	205	printf("Connected to task %d\n", taskid);
176		206
177	rc = get_thread_list();	207	rc = get_thread_list();
178	if (rc < 0) {	208	if (rc < 0) {
179	printf("Failed to get thread list (error %d)\n", rc);	209	printf("Failed to get thread list (error %d)\n", rc);
180	return;	210	return;
181	}	211	}
182		212
183	trace_loop();	213	trace_loop();
-		214	/*
-		215	printf("press 'd' to disconnect\n");
-		216	while ((i = getchar()) != 'd')
-		217	putchar(i);
184		218
-		219	printf("call debug_end()\n");
-		220	debug_end(phoneid);
-		221	*/
185	printf("done\n");	222	printf("done\n");
186	return;	223	return;
187	}	224	}
188		225
189	int main(void)	226	int main(void)
190	{	227	{
-		228	while (1) {
191	trace_active_task();	229	trace_active_task();
-		230	}
192	}	231	}
193		232
194	/** @}	233	/** @}
195	*/	234	*/
196		235

Subversion Repositories HelenOS

(root)/branches/tracing/uspace/app/trace/trace.c @ 3622 – Rev 2832 → 2835