Rev 3603 | Rev 3747 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
3438 | svoboda | 1 | /* |
2 | * Copyright (c) 2008 Jiri Svoboda |
||
3 | * All rights reserved. |
||
4 | * |
||
5 | * Redistribution and use in source and binary forms, with or without |
||
6 | * modification, are permitted provided that the following conditions |
||
7 | * are met: |
||
8 | * |
||
9 | * - Redistributions of source code must retain the above copyright |
||
10 | * notice, this list of conditions and the following disclaimer. |
||
11 | * - Redistributions in binary form must reproduce the above copyright |
||
12 | * notice, this list of conditions and the following disclaimer in the |
||
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 |
||
15 | * derived from this software without specific prior written permission. |
||
16 | * |
||
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 |
||
19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
||
20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
||
21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
||
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 |
||
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 |
||
26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||
27 | */ |
||
28 | |||
29 | /** @addtogroup trace |
||
30 | * @{ |
||
31 | */ |
||
32 | /** @file |
||
33 | */ |
||
34 | |||
35 | #include <stdio.h> |
||
36 | #include <stdlib.h> |
||
37 | #include <unistd.h> |
||
38 | #include <ipc/ipc.h> |
||
39 | #include <fibril.h> |
||
40 | #include <errno.h> |
||
41 | #include <udebug.h> |
||
42 | #include <async.h> |
||
3447 | svoboda | 43 | #include <task.h> |
3470 | svoboda | 44 | #include <loader/loader.h> |
3438 | svoboda | 45 | |
3485 | jermar | 46 | #include <libc.h> |
47 | |||
3438 | svoboda | 48 | // Temporary: service and method names |
49 | #include "proto.h" |
||
50 | #include <ipc/services.h> |
||
51 | #include "../../srv/vfs/vfs.h" |
||
52 | #include "../../srv/console/console.h" |
||
53 | |||
54 | #include "syscalls.h" |
||
55 | #include "ipcp.h" |
||
56 | #include "errors.h" |
||
3444 | svoboda | 57 | #include "trace.h" |
3438 | svoboda | 58 | |
59 | #define THBUF_SIZE 64 |
||
3454 | svoboda | 60 | uintptr_t thread_hash_buf[THBUF_SIZE]; |
61 | int n_threads; |
||
3438 | svoboda | 62 | |
63 | int next_thread_id; |
||
64 | |||
65 | int phoneid; |
||
66 | int abort_trace; |
||
67 | |||
3454 | svoboda | 68 | uintptr_t thash; |
3438 | svoboda | 69 | volatile int paused; |
70 | |||
3454 | svoboda | 71 | void thread_trace_start(uintptr_t thread_hash); |
3438 | svoboda | 72 | |
73 | static proto_t *proto_console; |
||
3444 | svoboda | 74 | static task_id_t task_id; |
3470 | svoboda | 75 | static loader_t *task_ldr; |
3438 | svoboda | 76 | |
3444 | svoboda | 77 | /** Combination of events/data to print. */ |
78 | display_mask_t display_mask; |
||
79 | |||
3470 | svoboda | 80 | static int program_run_fibril(void *arg); |
81 | |||
82 | static void program_run(void) |
||
3438 | svoboda | 83 | { |
3470 | svoboda | 84 | fid_t fid; |
85 | |||
86 | fid = fibril_create(program_run_fibril, NULL); |
||
87 | if (fid == 0) { |
||
88 | printf("Error creating fibril\n"); |
||
89 | exit(1); |
||
90 | } |
||
91 | |||
92 | fibril_add_ready(fid); |
||
93 | } |
||
94 | |||
95 | static int program_run_fibril(void *arg) |
||
96 | { |
||
3438 | svoboda | 97 | int rc; |
98 | |||
3470 | svoboda | 99 | /* |
100 | * This must be done in background as it will block until |
||
101 | * we let the task reply to this call. |
||
102 | */ |
||
103 | rc = loader_run(task_ldr); |
||
104 | if (rc != 0) { |
||
105 | printf("Error running program\n"); |
||
106 | exit(1); |
||
107 | } |
||
108 | |||
109 | free(task_ldr); |
||
110 | task_ldr = NULL; |
||
111 | |||
112 | printf("program_run_fibril exiting\n"); |
||
113 | return 0; |
||
114 | } |
||
115 | |||
116 | |||
117 | static int connect_task(task_id_t task_id) |
||
118 | { |
||
119 | int rc; |
||
120 | |||
3438 | svoboda | 121 | rc = ipc_connect_kbox(task_id); |
3439 | svoboda | 122 | |
123 | if (rc == ENOTSUP) { |
||
124 | printf("You do not have userspace debugging support " |
||
125 | "compiled in the kernel.\n"); |
||
126 | printf("Compile kernel with 'Support for userspace debuggers' " |
||
127 | "(CONFIG_UDEBUG) enabled.\n"); |
||
3442 | svoboda | 128 | return rc; |
3439 | svoboda | 129 | } |
130 | |||
3442 | svoboda | 131 | if (rc < 0) { |
132 | printf("Error connecting\n"); |
||
133 | printf("ipc_connect_task(%lld) -> %d ", task_id, rc); |
||
134 | return rc; |
||
135 | } |
||
136 | |||
3438 | svoboda | 137 | phoneid = rc; |
138 | |||
139 | rc = udebug_begin(phoneid); |
||
3442 | svoboda | 140 | if (rc < 0) { |
141 | printf("udebug_begin() -> %d\n", rc); |
||
142 | return rc; |
||
143 | } |
||
3438 | svoboda | 144 | |
145 | rc = udebug_set_evmask(phoneid, UDEBUG_EM_ALL); |
||
3442 | svoboda | 146 | if (rc < 0) { |
147 | printf("udebug_set_evmask(0x%x) -> %d\n ", UDEBUG_EM_ALL, rc); |
||
148 | return rc; |
||
149 | } |
||
3438 | svoboda | 150 | |
151 | return 0; |
||
152 | } |
||
153 | |||
154 | static int get_thread_list(void) |
||
155 | { |
||
156 | int rc; |
||
157 | size_t tb_copied; |
||
158 | size_t tb_needed; |
||
159 | int i; |
||
160 | |||
161 | rc = udebug_thread_read(phoneid, thread_hash_buf, |
||
162 | THBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed); |
||
3442 | svoboda | 163 | if (rc < 0) { |
164 | printf("udebug_thread_read() -> %d\n", rc); |
||
165 | return rc; |
||
166 | } |
||
3438 | svoboda | 167 | |
3454 | svoboda | 168 | n_threads = tb_copied / sizeof(uintptr_t); |
3438 | svoboda | 169 | |
3442 | svoboda | 170 | printf("Threads:"); |
171 | for (i = 0; i < n_threads; i++) { |
||
3454 | svoboda | 172 | printf(" [%d] (hash 0x%lx)", 1+i, thread_hash_buf[i]); |
3438 | svoboda | 173 | } |
3454 | svoboda | 174 | printf("\ntotal of %u threads\n", tb_needed / sizeof(uintptr_t)); |
3438 | svoboda | 175 | |
176 | return 0; |
||
177 | } |
||
178 | |||
3455 | svoboda | 179 | void val_print(sysarg_t val, val_type_t v_type) |
3438 | svoboda | 180 | { |
3452 | svoboda | 181 | switch (v_type) { |
182 | case V_VOID: |
||
183 | printf("<void>"); |
||
184 | break; |
||
185 | |||
186 | case V_INTEGER: |
||
3455 | svoboda | 187 | printf("%ld", val); |
3452 | svoboda | 188 | break; |
189 | |||
190 | case V_HASH: |
||
3470 | svoboda | 191 | case V_PTR: |
3455 | svoboda | 192 | printf("0x%08lx", val); |
3452 | svoboda | 193 | break; |
194 | |||
195 | case V_ERRNO: |
||
196 | if (val >= -15 && val <= 0) { |
||
3455 | svoboda | 197 | printf("%ld %s (%s)", val, |
3452 | svoboda | 198 | err_desc[-val].name, |
199 | err_desc[-val].desc); |
||
3438 | svoboda | 200 | } else { |
3455 | svoboda | 201 | printf("%ld", val); |
3438 | svoboda | 202 | } |
3452 | svoboda | 203 | break; |
204 | case V_INT_ERRNO: |
||
205 | if (val >= -15 && val < 0) { |
||
3455 | svoboda | 206 | printf("%ld %s (%s)", val, |
3452 | svoboda | 207 | err_desc[-val].name, |
208 | err_desc[-val].desc); |
||
3438 | svoboda | 209 | } else { |
3455 | svoboda | 210 | printf("%ld", val); |
3438 | svoboda | 211 | } |
3452 | svoboda | 212 | break; |
213 | |||
214 | case V_CHAR: |
||
215 | if (val >= 0x20 && val < 0x7f) { |
||
216 | printf("'%c'", val); |
||
217 | } else { |
||
218 | switch (val) { |
||
219 | case '\a': printf("'\\a'"); break; |
||
220 | case '\b': printf("'\\b'"); break; |
||
221 | case '\n': printf("'\\n'"); break; |
||
222 | case '\r': printf("'\\r'"); break; |
||
223 | case '\t': printf("'\\t'"); break; |
||
224 | case '\\': printf("'\\\\'"); break; |
||
3455 | svoboda | 225 | default: printf("'\\x%02lX'", val); break; |
3452 | svoboda | 226 | } |
227 | } |
||
228 | break; |
||
3438 | svoboda | 229 | } |
3452 | svoboda | 230 | } |
231 | |||
232 | |||
3455 | svoboda | 233 | static void print_sc_retval(sysarg_t retval, val_type_t val_type) |
3452 | svoboda | 234 | { |
235 | printf(" -> "); |
||
236 | val_print(retval, val_type); |
||
3438 | svoboda | 237 | putchar('\n'); |
238 | } |
||
239 | |||
3454 | svoboda | 240 | static void print_sc_args(sysarg_t *sc_args, int n) |
3438 | svoboda | 241 | { |
242 | int i; |
||
243 | |||
244 | putchar('('); |
||
3454 | svoboda | 245 | if (n > 0) printf("%ld", sc_args[0]); |
3452 | svoboda | 246 | for (i = 1; i < n; i++) { |
3454 | svoboda | 247 | printf(", %ld", sc_args[i]); |
3438 | svoboda | 248 | } |
249 | putchar(')'); |
||
250 | } |
||
251 | |||
3454 | svoboda | 252 | static void sc_ipc_call_async_fast(sysarg_t *sc_args, sysarg_t sc_rc) |
3438 | svoboda | 253 | { |
254 | ipc_call_t call; |
||
3454 | svoboda | 255 | ipcarg_t phoneid; |
3438 | svoboda | 256 | |
257 | if (sc_rc == IPC_CALLRET_FATAL || sc_rc == IPC_CALLRET_TEMPORARY) |
||
258 | return; |
||
259 | |||
260 | phoneid = sc_args[0]; |
||
261 | |||
262 | IPC_SET_METHOD(call, sc_args[1]); |
||
263 | IPC_SET_ARG1(call, sc_args[2]); |
||
264 | IPC_SET_ARG2(call, sc_args[3]); |
||
265 | IPC_SET_ARG3(call, sc_args[4]); |
||
266 | IPC_SET_ARG4(call, sc_args[5]); |
||
267 | IPC_SET_ARG5(call, 0); |
||
268 | |||
269 | ipcp_call_out(phoneid, &call, sc_rc); |
||
270 | } |
||
271 | |||
3454 | svoboda | 272 | static void sc_ipc_call_async_slow(sysarg_t *sc_args, sysarg_t sc_rc) |
3438 | svoboda | 273 | { |
274 | ipc_call_t call; |
||
275 | int rc; |
||
276 | |||
277 | if (sc_rc == IPC_CALLRET_FATAL || sc_rc == IPC_CALLRET_TEMPORARY) |
||
278 | return; |
||
279 | |||
280 | memset(&call, 0, sizeof(call)); |
||
281 | rc = udebug_mem_read(phoneid, &call.args, sc_args[1], sizeof(call.args)); |
||
282 | |||
283 | if (rc >= 0) { |
||
284 | ipcp_call_out(sc_args[0], &call, sc_rc); |
||
285 | } |
||
286 | } |
||
287 | |||
3454 | svoboda | 288 | static void sc_ipc_call_sync_fast(sysarg_t *sc_args) |
3438 | svoboda | 289 | { |
290 | ipc_call_t question, reply; |
||
291 | int rc; |
||
292 | int phoneidx; |
||
293 | |||
294 | // printf("sc_ipc_call_sync_fast()\n"); |
||
295 | phoneidx = sc_args[0]; |
||
296 | |||
297 | IPC_SET_METHOD(question, sc_args[1]); |
||
298 | IPC_SET_ARG1(question, sc_args[2]); |
||
299 | IPC_SET_ARG2(question, sc_args[3]); |
||
300 | IPC_SET_ARG3(question, sc_args[4]); |
||
301 | IPC_SET_ARG4(question, 0); |
||
302 | IPC_SET_ARG5(question, 0); |
||
303 | |||
304 | // printf("memset\n"); |
||
305 | memset(&reply, 0, sizeof(reply)); |
||
306 | // printf("udebug_mem_read(phone=%d, buffer_ptr=%u, src_addr=%d, n=%d\n", |
||
307 | // phoneid, &reply.args, sc_args[5], sizeof(reply.args)); |
||
308 | rc = udebug_mem_read(phoneid, &reply.args, sc_args[5], sizeof(reply.args)); |
||
309 | // printf("dmr->%d\n", rc); |
||
310 | if (rc < 0) return; |
||
311 | |||
312 | // printf("call ipc_call_sync\n"); |
||
313 | ipcp_call_sync(phoneidx, &question, &reply); |
||
314 | } |
||
315 | |||
3454 | svoboda | 316 | static void sc_ipc_call_sync_slow(sysarg_t *sc_args) |
3438 | svoboda | 317 | { |
318 | ipc_call_t question, reply; |
||
319 | int rc; |
||
320 | |||
321 | memset(&question, 0, sizeof(question)); |
||
322 | rc = udebug_mem_read(phoneid, &question.args, sc_args[1], sizeof(question.args)); |
||
323 | printf("dmr->%d\n", rc); |
||
324 | if (rc < 0) return; |
||
325 | |||
326 | memset(&reply, 0, sizeof(reply)); |
||
327 | rc = udebug_mem_read(phoneid, &reply.args, sc_args[2], sizeof(reply.args)); |
||
328 | printf("dmr->%d\n", rc); |
||
329 | if (rc < 0) return; |
||
330 | |||
331 | ipcp_call_sync(sc_args[0], &question, &reply); |
||
332 | } |
||
333 | |||
3454 | svoboda | 334 | static void sc_ipc_wait(sysarg_t *sc_args, int sc_rc) |
3438 | svoboda | 335 | { |
336 | ipc_call_t call; |
||
337 | int rc; |
||
338 | |||
339 | if (sc_rc == 0) return; |
||
340 | |||
341 | memset(&call, 0, sizeof(call)); |
||
342 | rc = udebug_mem_read(phoneid, &call, sc_args[0], sizeof(call)); |
||
343 | // printf("udebug_mem_read(phone %d, dest %d, app-mem src %d, size %d -> %d\n", |
||
344 | // phoneid, (int)&call, sc_args[0], sizeof(call), rc); |
||
345 | |||
346 | if (rc >= 0) { |
||
347 | ipcp_call_in(&call, sc_rc); |
||
348 | } |
||
349 | } |
||
350 | |||
3454 | svoboda | 351 | static void event_syscall_b(unsigned thread_id, uintptr_t thread_hash, |
352 | unsigned sc_id, sysarg_t sc_rc) |
||
3438 | svoboda | 353 | { |
3454 | svoboda | 354 | sysarg_t sc_args[6]; |
3438 | svoboda | 355 | int rc; |
356 | |||
357 | /* Read syscall arguments */ |
||
358 | rc = udebug_args_read(phoneid, thread_hash, sc_args); |
||
359 | |||
360 | async_serialize_start(); |
||
361 | |||
362 | // printf("[%d] ", thread_id); |
||
363 | |||
364 | if (rc < 0) { |
||
365 | printf("error\n"); |
||
366 | async_serialize_end(); |
||
367 | return; |
||
368 | } |
||
369 | |||
3444 | svoboda | 370 | if ((display_mask & DM_SYSCALL) != 0) { |
371 | /* Print syscall name and arguments */ |
||
372 | printf("%s", syscall_desc[sc_id].name); |
||
373 | print_sc_args(sc_args, syscall_desc[sc_id].n_args); |
||
374 | } |
||
3438 | svoboda | 375 | |
376 | async_serialize_end(); |
||
377 | } |
||
378 | |||
3454 | svoboda | 379 | static void event_syscall_e(unsigned thread_id, uintptr_t thread_hash, |
380 | unsigned sc_id, sysarg_t sc_rc) |
||
3438 | svoboda | 381 | { |
3454 | svoboda | 382 | sysarg_t sc_args[6]; |
3438 | svoboda | 383 | int rv_type; |
384 | int rc; |
||
385 | |||
386 | /* Read syscall arguments */ |
||
387 | rc = udebug_args_read(phoneid, thread_hash, sc_args); |
||
388 | |||
389 | async_serialize_start(); |
||
390 | |||
391 | // printf("[%d] ", thread_id); |
||
392 | |||
393 | if (rc < 0) { |
||
394 | printf("error\n"); |
||
395 | async_serialize_end(); |
||
396 | return; |
||
397 | } |
||
398 | |||
3444 | svoboda | 399 | if ((display_mask & DM_SYSCALL) != 0) { |
400 | /* Print syscall return value */ |
||
401 | rv_type = syscall_desc[sc_id].rv_type; |
||
402 | print_sc_retval(sc_rc, rv_type); |
||
403 | } |
||
3438 | svoboda | 404 | |
405 | switch (sc_id) { |
||
406 | case SYS_IPC_CALL_ASYNC_FAST: |
||
407 | sc_ipc_call_async_fast(sc_args, sc_rc); |
||
408 | break; |
||
409 | case SYS_IPC_CALL_ASYNC_SLOW: |
||
410 | sc_ipc_call_async_slow(sc_args, sc_rc); |
||
411 | break; |
||
412 | case SYS_IPC_CALL_SYNC_FAST: |
||
413 | sc_ipc_call_sync_fast(sc_args); |
||
414 | break; |
||
415 | case SYS_IPC_CALL_SYNC_SLOW: |
||
416 | sc_ipc_call_sync_slow(sc_args); |
||
417 | break; |
||
418 | case SYS_IPC_WAIT: |
||
419 | sc_ipc_wait(sc_args, sc_rc); |
||
420 | break; |
||
421 | default: |
||
422 | break; |
||
423 | } |
||
424 | |||
425 | async_serialize_end(); |
||
426 | } |
||
427 | |||
3454 | svoboda | 428 | static void event_thread_b(uintptr_t hash) |
3438 | svoboda | 429 | { |
430 | async_serialize_start(); |
||
3454 | svoboda | 431 | printf("New thread, hash 0x%lx\n", hash); |
3438 | svoboda | 432 | async_serialize_end(); |
433 | |||
434 | thread_trace_start(hash); |
||
435 | } |
||
436 | |||
437 | static int trace_loop(void *thread_hash_arg) |
||
438 | { |
||
439 | int rc; |
||
440 | unsigned ev_type; |
||
3454 | svoboda | 441 | uintptr_t thread_hash; |
3438 | svoboda | 442 | unsigned thread_id; |
3454 | svoboda | 443 | sysarg_t val0, val1; |
3438 | svoboda | 444 | |
3454 | svoboda | 445 | thread_hash = (uintptr_t)thread_hash_arg; |
3438 | svoboda | 446 | thread_id = next_thread_id++; |
447 | |||
3605 | svoboda | 448 | printf("Start tracing thread [%d] (hash 0x%lx).\n", thread_id, thread_hash); |
3438 | svoboda | 449 | |
450 | while (!abort_trace) { |
||
451 | |||
3603 | svoboda | 452 | if (paused) { |
3605 | svoboda | 453 | printf("Press R to resume (and be patient).\n"); |
3603 | svoboda | 454 | while (paused) { |
455 | usleep(1000000); |
||
456 | fibril_yield(); |
||
457 | printf("."); |
||
458 | } |
||
459 | printf("Resumed\n"); |
||
460 | } |
||
461 | |||
3438 | svoboda | 462 | /* Run thread until an event occurs */ |
463 | rc = udebug_go(phoneid, thread_hash, |
||
464 | &ev_type, &val0, &val1); |
||
465 | |||
466 | // printf("rc = %d, ev_type=%d\n", rc, ev_type); |
||
467 | if (ev_type == UDEBUG_EVENT_FINISHED) { |
||
3442 | svoboda | 468 | /* Done tracing this thread */ |
3438 | svoboda | 469 | break; |
470 | } |
||
471 | |||
472 | if (rc >= 0) { |
||
473 | switch (ev_type) { |
||
474 | case UDEBUG_EVENT_SYSCALL_B: |
||
475 | event_syscall_b(thread_id, thread_hash, val0, (int)val1); |
||
476 | break; |
||
477 | case UDEBUG_EVENT_SYSCALL_E: |
||
478 | event_syscall_e(thread_id, thread_hash, val0, (int)val1); |
||
479 | break; |
||
480 | case UDEBUG_EVENT_STOP: |
||
3442 | svoboda | 481 | printf("Stop event\n"); |
3438 | svoboda | 482 | break; |
483 | case UDEBUG_EVENT_THREAD_B: |
||
484 | event_thread_b(val0); |
||
485 | break; |
||
486 | case UDEBUG_EVENT_THREAD_E: |
||
3605 | svoboda | 487 | printf("Thread 0x%lx exited.\n", val0); |
3438 | svoboda | 488 | abort_trace = 1; |
489 | break; |
||
490 | default: |
||
3605 | svoboda | 491 | printf("Unknown event type %d.\n", ev_type); |
3438 | svoboda | 492 | break; |
493 | } |
||
494 | } |
||
495 | |||
496 | } |
||
497 | |||
3605 | svoboda | 498 | printf("Finished tracing thread [%d].\n", thread_id); |
3438 | svoboda | 499 | return 0; |
500 | } |
||
501 | |||
3454 | svoboda | 502 | void thread_trace_start(uintptr_t thread_hash) |
3438 | svoboda | 503 | { |
504 | fid_t fid; |
||
505 | |||
506 | thash = thread_hash; |
||
507 | |||
508 | fid = fibril_create(trace_loop, (void *)thread_hash); |
||
509 | if (fid == 0) { |
||
510 | printf("Warning: Failed creating fibril\n"); |
||
511 | } |
||
512 | fibril_add_ready(fid); |
||
513 | } |
||
514 | |||
3470 | svoboda | 515 | static loader_t *preload_task(const char *path, char *const argv[], |
516 | task_id_t *task_id) |
||
3438 | svoboda | 517 | { |
3470 | svoboda | 518 | loader_t *ldr; |
519 | int rc; |
||
520 | |||
521 | /* Spawn a program loader */ |
||
3566 | svoboda | 522 | ldr = loader_spawn(path); |
3470 | svoboda | 523 | if (ldr == NULL) |
524 | return 0; |
||
525 | |||
526 | /* Get task ID. */ |
||
527 | rc = loader_get_task_id(ldr, task_id); |
||
528 | if (rc != EOK) |
||
529 | goto error; |
||
530 | |||
531 | /* Send program pathname */ |
||
532 | rc = loader_set_pathname(ldr, path); |
||
533 | if (rc != EOK) |
||
534 | goto error; |
||
535 | |||
536 | /* Send arguments */ |
||
537 | rc = loader_set_args(ldr, argv); |
||
538 | if (rc != EOK) |
||
539 | goto error; |
||
540 | |||
541 | /* Load the program. */ |
||
542 | rc = loader_load_program(ldr); |
||
543 | if (rc != EOK) |
||
544 | goto error; |
||
545 | |||
546 | /* Success */ |
||
547 | return ldr; |
||
548 | |||
549 | /* Error exit */ |
||
550 | error: |
||
551 | loader_abort(ldr); |
||
552 | free(ldr); |
||
553 | return NULL; |
||
554 | } |
||
555 | |||
556 | static void trace_task(task_id_t task_id) |
||
557 | { |
||
3438 | svoboda | 558 | int i; |
559 | int rc; |
||
560 | int c; |
||
561 | |||
562 | ipcp_init(); |
||
563 | |||
3442 | svoboda | 564 | /* |
565 | * User apps now typically have console on phone 3. |
||
566 | * (Phones 1 and 2 are used by the loader). |
||
567 | */ |
||
568 | ipcp_connection_set(3, 0, proto_console); |
||
569 | |||
3438 | svoboda | 570 | rc = get_thread_list(); |
571 | if (rc < 0) { |
||
572 | printf("Failed to get thread list (error %d)\n", rc); |
||
573 | return; |
||
574 | } |
||
575 | |||
576 | abort_trace = 0; |
||
577 | |||
578 | for (i = 0; i < n_threads; i++) { |
||
579 | thread_trace_start(thread_hash_buf[i]); |
||
580 | } |
||
581 | |||
582 | while(1) { |
||
583 | c = getchar(); |
||
584 | if (c == 'q') break; |
||
585 | if (c == 'p') { |
||
3603 | svoboda | 586 | printf("Pause...\n"); |
3438 | svoboda | 587 | paused = 1; |
588 | rc = udebug_stop(phoneid, thash); |
||
589 | printf("stop -> %d\n", rc); |
||
590 | } |
||
591 | if (c == 'r') { |
||
592 | paused = 0; |
||
3603 | svoboda | 593 | printf("Resume...\n"); |
3438 | svoboda | 594 | } |
595 | } |
||
596 | |||
3442 | svoboda | 597 | printf("\nTerminate debugging session...\n"); |
3438 | svoboda | 598 | abort_trace = 1; |
599 | udebug_end(phoneid); |
||
600 | ipc_hangup(phoneid); |
||
601 | |||
602 | ipcp_cleanup(); |
||
603 | |||
3442 | svoboda | 604 | printf("Done\n"); |
3438 | svoboda | 605 | return; |
606 | } |
||
607 | |||
608 | static void main_init(void) |
||
609 | { |
||
610 | proto_t *p; |
||
611 | oper_t *o; |
||
612 | |||
3452 | svoboda | 613 | val_type_t arg_def[OPER_MAX_ARGS] = { |
614 | V_INTEGER, |
||
615 | V_INTEGER, |
||
616 | V_INTEGER, |
||
617 | V_INTEGER, |
||
618 | V_INTEGER |
||
619 | }; |
||
620 | |||
621 | val_type_t resp_def[OPER_MAX_ARGS] = { |
||
622 | V_INTEGER, |
||
623 | V_INTEGER, |
||
624 | V_INTEGER, |
||
625 | V_INTEGER, |
||
626 | V_INTEGER |
||
627 | }; |
||
628 | |||
3438 | svoboda | 629 | next_thread_id = 1; |
630 | paused = 0; |
||
631 | |||
632 | proto_init(); |
||
633 | |||
634 | p = proto_new("vfs"); |
||
3452 | svoboda | 635 | o = oper_new("read", 1, arg_def, V_ERRNO, 1, resp_def); |
3438 | svoboda | 636 | proto_add_oper(p, VFS_READ, o); |
3452 | svoboda | 637 | o = oper_new("write", 1, arg_def, V_ERRNO, 1, resp_def); |
3438 | svoboda | 638 | proto_add_oper(p, VFS_WRITE, o); |
3452 | svoboda | 639 | o = oper_new("truncate", 5, arg_def, V_ERRNO, 0, resp_def); |
3438 | svoboda | 640 | proto_add_oper(p, VFS_TRUNCATE, o); |
3452 | svoboda | 641 | o = oper_new("mount", 2, arg_def, V_ERRNO, 0, resp_def); |
3438 | svoboda | 642 | proto_add_oper(p, VFS_MOUNT, o); |
3452 | svoboda | 643 | /* o = oper_new("unmount", 0, arg_def); |
644 | proto_add_oper(p, VFS_UNMOUNT, o);*/ |
||
3438 | svoboda | 645 | |
646 | proto_register(SERVICE_VFS, p); |
||
647 | |||
648 | p = proto_new("console"); |
||
3452 | svoboda | 649 | resp_def[0] = V_CHAR; |
650 | o = oper_new("getchar", 0, arg_def, V_INTEGER, 2, resp_def); |
||
3438 | svoboda | 651 | proto_add_oper(p, CONSOLE_GETCHAR, o); |
3452 | svoboda | 652 | |
653 | arg_def[0] = V_CHAR; |
||
654 | o = oper_new("putchar", 1, arg_def, V_VOID, 0, resp_def); |
||
3438 | svoboda | 655 | proto_add_oper(p, CONSOLE_PUTCHAR, o); |
3452 | svoboda | 656 | o = oper_new("clear", 0, arg_def, V_VOID, 0, resp_def); |
3438 | svoboda | 657 | proto_add_oper(p, CONSOLE_CLEAR, o); |
3452 | svoboda | 658 | |
659 | arg_def[0] = V_INTEGER; arg_def[1] = V_INTEGER; |
||
660 | o = oper_new("goto", 2, arg_def, V_VOID, 0, resp_def); |
||
3438 | svoboda | 661 | proto_add_oper(p, CONSOLE_GOTO, o); |
3452 | svoboda | 662 | |
663 | resp_def[0] = V_INTEGER; resp_def[1] = V_INTEGER; |
||
664 | o = oper_new("getsize", 0, arg_def, V_INTEGER, 2, resp_def); |
||
3438 | svoboda | 665 | proto_add_oper(p, CONSOLE_GETSIZE, o); |
3452 | svoboda | 666 | o = oper_new("flush", 0, arg_def, V_VOID, 0, resp_def); |
3438 | svoboda | 667 | proto_add_oper(p, CONSOLE_FLUSH, o); |
3452 | svoboda | 668 | |
669 | arg_def[0] = V_INTEGER; arg_def[1] = V_INTEGER; |
||
670 | o = oper_new("set_style", 2, arg_def, V_INTEGER, 0, resp_def); |
||
3438 | svoboda | 671 | proto_add_oper(p, CONSOLE_SET_STYLE, o); |
3452 | svoboda | 672 | o = oper_new("cursor_visibility", 1, arg_def, V_VOID, 0, resp_def); |
3438 | svoboda | 673 | proto_add_oper(p, CONSOLE_CURSOR_VISIBILITY, o); |
674 | |||
675 | proto_console = p; |
||
676 | proto_register(SERVICE_CONSOLE, p); |
||
677 | } |
||
678 | |||
679 | static void print_syntax() |
||
680 | { |
||
3447 | svoboda | 681 | printf("Syntax:\n"); |
682 | printf("\ttrace [+<events>] <executable> [<arg1> [...]]\n"); |
||
683 | printf("or\ttrace [+<events>] -t <task_id>\n"); |
||
3444 | svoboda | 684 | printf("Events: (default is +tp)\n"); |
685 | printf("\n"); |
||
686 | printf("\tt ... Thread creation and termination\n"); |
||
687 | printf("\ts ... System calls\n"); |
||
688 | printf("\ti ... Low-level IPC\n"); |
||
689 | printf("\tp ... Protocol level\n"); |
||
690 | printf("\n"); |
||
3447 | svoboda | 691 | printf("Examples:\n"); |
692 | printf("\ttrace +s /app/tetris\n"); |
||
693 | printf("\ttrace +tsip -t 12\n"); |
||
3438 | svoboda | 694 | } |
695 | |||
3444 | svoboda | 696 | static display_mask_t parse_display_mask(char *text) |
3438 | svoboda | 697 | { |
3444 | svoboda | 698 | display_mask_t dm; |
699 | char *c; |
||
700 | |||
701 | c = text; |
||
702 | |||
703 | while (*c) { |
||
704 | switch (*c) { |
||
705 | case 't': dm = dm | DM_THREAD; break; |
||
706 | case 's': dm = dm | DM_SYSCALL; break; |
||
707 | case 'i': dm = dm | DM_IPC; break; |
||
708 | case 'p': dm = dm | DM_SYSTEM | DM_USER; break; |
||
709 | default: |
||
3605 | svoboda | 710 | printf("Unexpected event type '%c'.\n", *c); |
3444 | svoboda | 711 | exit(1); |
712 | } |
||
713 | |||
714 | ++c; |
||
715 | } |
||
716 | |||
717 | return dm; |
||
718 | } |
||
719 | |||
720 | static int parse_args(int argc, char *argv[]) |
||
721 | { |
||
722 | char *arg; |
||
3438 | svoboda | 723 | char *err_p; |
724 | |||
3447 | svoboda | 725 | task_id = 0; |
726 | |||
3444 | svoboda | 727 | --argc; ++argv; |
728 | |||
3447 | svoboda | 729 | while (argc > 0) { |
3444 | svoboda | 730 | arg = *argv; |
731 | if (arg[0] == '+') { |
||
732 | display_mask = parse_display_mask(&arg[1]); |
||
3447 | svoboda | 733 | } else if (arg[0] == '-') { |
734 | if (arg[1] == 't') { |
||
735 | /* Trace an already running task */ |
||
736 | --argc; ++argv; |
||
737 | task_id = strtol(*argv, &err_p, 10); |
||
3470 | svoboda | 738 | task_ldr = NULL; |
3447 | svoboda | 739 | if (*err_p) { |
740 | printf("Task ID syntax error\n"); |
||
741 | print_syntax(); |
||
742 | return -1; |
||
743 | } |
||
744 | } else { |
||
745 | printf("Uknown option '%s'\n", arg[0]); |
||
746 | print_syntax(); |
||
747 | return -1; |
||
748 | } |
||
3444 | svoboda | 749 | } else { |
3447 | svoboda | 750 | break; |
3444 | svoboda | 751 | } |
752 | |||
753 | --argc; ++argv; |
||
754 | } |
||
755 | |||
3447 | svoboda | 756 | if (task_id != 0) { |
3454 | svoboda | 757 | if (argc == 0) return 0; |
3447 | svoboda | 758 | printf("Extra arguments\n"); |
3438 | svoboda | 759 | print_syntax(); |
3447 | svoboda | 760 | return -1; |
3438 | svoboda | 761 | } |
762 | |||
3447 | svoboda | 763 | if (argc < 1) { |
764 | printf("Missing argument\n"); |
||
3438 | svoboda | 765 | print_syntax(); |
3444 | svoboda | 766 | return -1; |
3438 | svoboda | 767 | } |
768 | |||
3470 | svoboda | 769 | /* Preload the specified program file. */ |
3447 | svoboda | 770 | printf("Spawning '%s' with arguments:\n", *argv); |
771 | { |
||
772 | char **cp = argv; |
||
773 | while (*cp) printf("'%s'\n", *cp++); |
||
774 | } |
||
3470 | svoboda | 775 | task_ldr = preload_task(*argv, argv, &task_id); |
3447 | svoboda | 776 | |
3444 | svoboda | 777 | return 0; |
778 | } |
||
779 | |||
780 | int main(int argc, char *argv[]) |
||
781 | { |
||
3470 | svoboda | 782 | int rc; |
783 | |||
3444 | svoboda | 784 | printf("System Call / IPC Tracer\n"); |
3605 | svoboda | 785 | printf("Controls: Q - Quit, P - Pause, R - Resume\n"); |
3444 | svoboda | 786 | |
787 | display_mask = DM_THREAD | DM_SYSTEM | DM_USER; |
||
788 | |||
789 | if (parse_args(argc, argv) < 0) |
||
790 | return 1; |
||
791 | |||
3438 | svoboda | 792 | main_init(); |
3444 | svoboda | 793 | |
3470 | svoboda | 794 | rc = connect_task(task_id); |
795 | if (rc < 0) { |
||
3605 | svoboda | 796 | printf("Failed connecting to task %lld.\n", task_id); |
3470 | svoboda | 797 | return 1; |
798 | } |
||
799 | |||
3605 | svoboda | 800 | printf("Connected to task %lld.\n", task_id); |
3470 | svoboda | 801 | |
802 | if (task_ldr != NULL) { |
||
803 | program_run(); |
||
804 | } |
||
805 | |||
806 | trace_task(task_id); |
||
807 | |||
3444 | svoboda | 808 | return 0; |
3438 | svoboda | 809 | } |
810 | |||
811 | /** @} |
||
812 | */ |