Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 2849 → Rev 2850

/branches/tracing/uspace/app/sctrace/sctrace.c
18,6 → 18,7
 
#define TIDBUF_SIZE 64
unsigned threadid_buf[TIDBUF_SIZE];
unsigned n_threads;
 
int phoneid;
int abort_trace;
54,8 → 55,10
printf("-> %d\n", rc);
if (rc < 0) return rc;
 
n_threads = tb_copied / sizeof(unsigned);
 
printf("thread IDs:");
for (i=0; i<tb_copied / sizeof(unsigned); i++) {
for (i=0; i<n_threads; i++) {
printf(" %u", threadid_buf[i]);
}
printf("\ntotal of %u threads\n", tb_needed/sizeof(unsigned));
117,26 → 120,8
}
}
 
int keyboard_fibril(void *arg)
void trace_loop(void *thread_idx_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 hanging up phone\n");
ipc_hangup(phoneid);
printf("keyboard fibril exitting\n");
 
return EOK;
}
 
void trace_loop(void)
{
int rc;
unsigned sc_args[6];
unsigned copied;
144,34 → 129,31
unsigned sc_id;
int sc_rc;
int rv_type;
fid_t kb_fid;
unsigned thread_idx;
 
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);
thread_idx = (unsigned)thread_idx_arg;
printf("trace_loop(%d)\n", thread_idx);
 
while (!abort_trace) {
 
/* Run thread until a syscall is executed */
rc = debug_go(phoneid, threadid_buf[0],
rc = debug_go(phoneid, threadid_buf[thread_idx],
&ev_type, &sc_id, &sc_rc);
 
printf("rc = %d, ev_type=%d\n", rc, ev_type);
if (ev_type == UDEBUG_EVENT_FINISHED) {
printf("thread %u debugging finished\n", threadid_buf[0]);
printf("thread %u debugging finished\n", threadid_buf[thread_idx]);
break;
}
 
/* Read syscall arguments */
if (rc >= 0) {
rc = debug_args_read(phoneid, threadid_buf[0],
rc = debug_args_read(phoneid, threadid_buf[thread_idx],
sc_args);
}
 
printf("[%d] ", thread_idx);
 
/* Print syscall name, id and arguments */
if (rc >= 0) {
printf("%s", syscall_desc[sc_id].name);
189,7 → 171,7
}
}
 
printf("trace_loop() exiting\n");
printf("trace_loop(%d) exiting\n", thread_idx);
}
 
 
198,6 → 180,7
int taskid;
int i;
int rc;
fid_t fid;
 
printf("Syscall Tracer\n");
printf("Press 'c' to connect\n");
204,7 → 187,7
while ((i = getchar()) != 'c')
putchar(i);
 
taskid = 13;
taskid = 14;
rc = task_connect(taskid);
if (rc < 0) {
printf("Failed to connect to task %d\n", taskid);
219,15 → 202,23
return;
}
 
trace_loop();
/*
printf("press 'd' to disconnect\n");
while ((i = getchar()) != 'd')
putchar(i);
abort_trace = 0;
 
printf("call debug_end()\n");
for (i = 0; i < n_threads; i++) {
fid = fibril_create(trace_loop, (void *)0);
if (fid == 0) {
printf("Warning: Failed creating fibril\n");
}
fibril_add_ready(fid);
}
 
getchar();
 
printf("terminate debugging session...\n");
abort_trace = 1;
debug_end(phoneid);
*/
ipc_hangup(phoneid);
 
printf("done\n");
return;
}
/branches/tracing/uspace/app/tester/debug/debug1.c
1,114 → 1,30
#include <stdio.h>
#include <unistd.h>
#include <syscall.h>
#include <ipc/ipc.h>
#include <udebug.h>
#include <thread.h>
#include "../tester.h"
 
const char *syscall_name[] = {
"sys_io",
"sys_tls_set",
"sys_thread_create",
"sys_thread_exit",
"sys_thread_get_id",
"sys_task_get_id",
"sys_futex_sleep_timeout",
"sys_futex_wakeup",
"sys_as_area_create",
"sys_as_area_resize",
"sys_as_area_destroy",
"sys_ipc_call_sync_fast",
"sys_ipc_call_sync_slow",
"sys_ipc_call_async_fast",
"sys_ipc_call_async_slow",
"sys_ipc_answer_fast",
"sys_ipc_answer_slow",
"sys_ipc_forward_fast",
"sys_ipc_wait_for_call",
"sys_ipc_hangup",
"sys_ipc_register_irq",
"sys_ipc_unregister_irq",
"sys_cap_grant",
"sys_cap_revoke",
"sys_physmem_map",
"sys_iospace_enable",
"sys_preempt_control",
"sys_sysinfo_valid",
"sys_sysinfo_value",
"sys_debug_enable_console",
"sys_ipc_connect_task"
};
volatile int done;
 
#define TIDBUF_SIZE 64
void t_proc(void *arg)
{
printf("this is 'test' thread [wait for key]\n");
getchar();
done = 1;
}
 
char * test_debug1(bool quiet)
{
int taskid;
int rc;
int phoneid;
int i;
unsigned sc_args[6];
unsigned ipc_args[6];
unsigned copied;
unsigned ev_type;
unsigned sc_id;
int sc_rc;
unsigned threadid_buf[TIDBUF_SIZE];
int tb_copied, tb_needed;
thread_id_t tid;
 
done = 0;
 
printf("running debug1 test\n");
taskid = 12;
printf("ipc_connect_task(%d)...\n", taskid);
rc = ipc_connect_kbox(taskid);
printf("-> %d\n", rc);
phoneid = rc;
rc = thread_create(t_proc, NULL, "test", &tid);
 
printf("send IPC_M_DEBUG_BEGIN message\n");
rc = ipc_call_sync_1_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_BEGIN);
printf("-> %d\n", rc);
printf("(active) wait for thread 'test'\n");
while (!done) usleep(500000);
 
printf("send IPC_M_DEBUG_THREAD_READ message\n");
rc = ipc_call_sync_3_2(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_THREAD_READ,
(sysarg_t)threadid_buf, TIDBUF_SIZE*sizeof(unsigned),
&tb_copied, &tb_needed);
printf("-> %d\n", 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));
 
while (1) {
rc = ipc_call_sync_2_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_GO,
threadid_buf[0], &ev_type, &sc_id, &sc_rc);
if (rc >= 0) {
rc = ipc_call_sync_4_1(phoneid, IPC_M_DEBUG_ALL,
UDEBUG_M_ARGS_READ, threadid_buf[0], sc_args,
6 * sizeof(unsigned), &copied);
}
if (rc >= 0) {
printf("%s[%d](%u, %u, %u, %u, %u, %u) -> %d\n",
syscall_name[sc_id], sc_id,
sc_args[0], sc_args[1], sc_args[2],
sc_args[3], sc_args[4], sc_args[5],
sc_rc);
}
if (sc_id == SYS_IPC_CALL_ASYNC_SLOW) {
memset(ipc_args, 0, sizeof(ipc_args));
printf("read async call args..\n");
printf("dest=%u, ptr=%u, len=%u\n",
(sysarg_t)ipc_args, sc_args[1], sizeof(ipc_args));
rc = ipc_call_sync_4_0(phoneid, IPC_M_DEBUG_ALL,
UDEBUG_M_MEM_READ, (sysarg_t)ipc_args,
sc_args[1], sizeof(ipc_args));
printf("-> %d\n", rc);
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]);
}
}
 
printf("done\n");
return NULL;
}