source: mainline/uspace/app/trace/trace.c@ 395df52

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 395df52 was 582a0b8, checked in by Jakub Jermar <jakub@…>, 8 years ago

Remove unistd.h

  • Rename usleep() and sleep() to thread_usleep() and thread_sleep() and move to thread.[hc].
  • Include stddef.h in order to provide NULL.
  • Move getpagesize() to libposix.
  • Sync uspace/dist/src/c/demos with originals.
  • Property mode set to 100644
File size: 18.3 KB
Line 
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 <fibril.h>
38#include <errno.h>
39#include <udebug.h>
40#include <async.h>
41#include <task.h>
42#include <mem.h>
43#include <str.h>
44#include <stdbool.h>
45#include <loader/loader.h>
46#include <io/console.h>
47#include <io/keycode.h>
48#include <fibril_synch.h>
49#include <sys/types.h>
50#include <sys/typefmt.h>
51#include <vfs/vfs.h>
52
53#include <libc.h>
54
55/* Temporary: service and method names */
56#include "proto.h"
57#include <ipc/services.h>
58#include <ipc/vfs.h>
59#include <ipc/console.h>
60
61#include "syscalls.h"
62#include "ipcp.h"
63#include "errors.h"
64#include "trace.h"
65
66#define THBUF_SIZE 64
67uintptr_t thread_hash_buf[THBUF_SIZE];
68int n_threads;
69
70int next_thread_id;
71
72ipc_call_t thread_ipc_req[THBUF_SIZE];
73
74async_sess_t *sess;
75bool abort_trace;
76
77uintptr_t thash;
78static bool paused;
79static fibril_condvar_t state_cv;
80static fibril_mutex_t state_lock;
81
82static bool cev_valid;
83static kbd_event_t cev;
84
85void thread_trace_start(uintptr_t thread_hash);
86
87static task_id_t task_id;
88static loader_t *task_ldr;
89static bool task_wait_for;
90
91/** Combination of events/data to print. */
92display_mask_t display_mask;
93
94static int program_run_fibril(void *arg);
95static int cev_fibril(void *arg);
96
97static void program_run(void)
98{
99 fid_t fid;
100
101 fid = fibril_create(program_run_fibril, NULL);
102 if (fid == 0) {
103 printf("Error creating fibril\n");
104 exit(1);
105 }
106
107 fibril_add_ready(fid);
108}
109
110static void cev_fibril_start(void)
111{
112 fid_t fid;
113
114 fid = fibril_create(cev_fibril, NULL);
115 if (fid == 0) {
116 printf("Error creating fibril\n");
117 exit(1);
118 }
119
120 fibril_add_ready(fid);
121}
122
123static int program_run_fibril(void *arg)
124{
125 int rc;
126
127 /*
128 * This must be done in background as it will block until
129 * we let the task reply to this call.
130 */
131 rc = loader_run(task_ldr);
132 if (rc != 0) {
133 printf("Error running program\n");
134 exit(1);
135 }
136
137 task_ldr = NULL;
138
139 printf("program_run_fibril exiting\n");
140 return 0;
141}
142
143
144static int connect_task(task_id_t task_id)
145{
146 async_sess_t *ksess = async_connect_kbox(task_id);
147
148 if (!ksess) {
149 if (errno == ENOTSUP) {
150 printf("You do not have userspace debugging support "
151 "compiled in the kernel.\n");
152 printf("Compile kernel with 'Support for userspace debuggers' "
153 "(CONFIG_UDEBUG) enabled.\n");
154 return errno;
155 }
156
157 printf("Error connecting\n");
158 printf("ipc_connect_task(%" PRIu64 ") -> %d ", task_id, errno);
159 return errno;
160 }
161
162 int rc = udebug_begin(ksess);
163 if (rc < 0) {
164 printf("udebug_begin() -> %d\n", rc);
165 return rc;
166 }
167
168 rc = udebug_set_evmask(ksess, UDEBUG_EM_ALL);
169 if (rc < 0) {
170 printf("udebug_set_evmask(0x%x) -> %d\n ", UDEBUG_EM_ALL, rc);
171 return rc;
172 }
173
174 sess = ksess;
175 return 0;
176}
177
178static int get_thread_list(void)
179{
180 int rc;
181 size_t tb_copied;
182 size_t tb_needed;
183 int i;
184
185 rc = udebug_thread_read(sess, thread_hash_buf,
186 THBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);
187 if (rc < 0) {
188 printf("udebug_thread_read() -> %d\n", rc);
189 return rc;
190 }
191
192 n_threads = tb_copied / sizeof(uintptr_t);
193
194 printf("Threads:");
195 for (i = 0; i < n_threads; i++) {
196 printf(" [%d] (hash %p)", 1 + i, (void *) thread_hash_buf[i]);
197 }
198 printf("\ntotal of %zu threads\n", tb_needed / sizeof(uintptr_t));
199
200 return 0;
201}
202
203void val_print(sysarg_t val, val_type_t v_type)
204{
205 long sval;
206
207 sval = (long) val;
208
209 switch (v_type) {
210 case V_VOID:
211 printf("<void>");
212 break;
213
214 case V_INTEGER:
215 printf("%ld", sval);
216 break;
217
218 case V_HASH:
219 case V_PTR:
220 printf("%p", (void *) val);
221 break;
222
223 case V_ERRNO:
224 if (sval >= -15 && sval <= 0) {
225 printf("%ld %s (%s)", sval,
226 err_desc[-sval].name,
227 err_desc[-sval].desc);
228 } else {
229 printf("%ld", sval);
230 }
231 break;
232 case V_INT_ERRNO:
233 if (sval >= -15 && sval < 0) {
234 printf("%ld %s (%s)", sval,
235 err_desc[-sval].name,
236 err_desc[-sval].desc);
237 } else {
238 printf("%ld", sval);
239 }
240 break;
241
242 case V_CHAR:
243 if (sval >= 0x20 && sval < 0x7f) {
244 printf("'%c'", (char) sval);
245 } else {
246 switch (sval) {
247 case '\a': printf("'\\a'"); break;
248 case '\b': printf("'\\b'"); break;
249 case '\n': printf("'\\n'"); break;
250 case '\r': printf("'\\r'"); break;
251 case '\t': printf("'\\t'"); break;
252 case '\\': printf("'\\\\'"); break;
253 default: printf("'\\x%02" PRIxn "'", val); break;
254 }
255 }
256 break;
257 }
258}
259
260
261static void print_sc_retval(sysarg_t retval, val_type_t val_type)
262{
263 printf(" -> ");
264 val_print(retval, val_type);
265 putchar('\n');
266}
267
268static void print_sc_args(sysarg_t *sc_args, int n)
269{
270 int i;
271
272 putchar('(');
273 if (n > 0) printf("%" PRIun, sc_args[0]);
274 for (i = 1; i < n; i++) {
275 printf(", %" PRIun, sc_args[i]);
276 }
277 putchar(')');
278}
279
280static void sc_ipc_call_async_fast(sysarg_t *sc_args, sysarg_t sc_rc)
281{
282 ipc_call_t call;
283 sysarg_t phoneid;
284
285 if (sc_rc == (sysarg_t) IPC_CALLRET_FATAL ||
286 sc_rc == (sysarg_t) IPC_CALLRET_TEMPORARY)
287 return;
288
289 phoneid = sc_args[0];
290
291 IPC_SET_IMETHOD(call, sc_args[1]);
292 IPC_SET_ARG1(call, sc_args[2]);
293 IPC_SET_ARG2(call, sc_args[3]);
294 IPC_SET_ARG3(call, sc_args[4]);
295 IPC_SET_ARG4(call, sc_args[5]);
296 IPC_SET_ARG5(call, 0);
297
298 ipcp_call_out(phoneid, &call, sc_rc);
299}
300
301static void sc_ipc_call_async_slow(sysarg_t *sc_args, sysarg_t sc_rc)
302{
303 ipc_call_t call;
304 int rc;
305
306 if (sc_rc == (sysarg_t) IPC_CALLRET_FATAL ||
307 sc_rc == (sysarg_t) IPC_CALLRET_TEMPORARY)
308 return;
309
310 memset(&call, 0, sizeof(call));
311 rc = udebug_mem_read(sess, &call.args, sc_args[1], sizeof(call.args));
312
313 if (rc >= 0) {
314 ipcp_call_out(sc_args[0], &call, sc_rc);
315 }
316}
317
318static void sc_ipc_wait(sysarg_t *sc_args, int sc_rc)
319{
320 ipc_call_t call;
321 int rc;
322
323 if (sc_rc == 0) return;
324
325 memset(&call, 0, sizeof(call));
326 rc = udebug_mem_read(sess, &call, sc_args[0], sizeof(call));
327
328 if (rc >= 0)
329 ipcp_call_in(&call, sc_rc);
330}
331
332static void event_syscall_b(unsigned thread_id, uintptr_t thread_hash,
333 unsigned sc_id, sysarg_t sc_rc)
334{
335 sysarg_t sc_args[6];
336 int rc;
337
338 /* Read syscall arguments */
339 rc = udebug_args_read(sess, thread_hash, sc_args);
340
341 if (rc < 0) {
342 printf("error\n");
343 return;
344 }
345
346 if ((display_mask & DM_SYSCALL) != 0) {
347 /* Print syscall name and arguments */
348 if (syscall_desc_defined(sc_id)) {
349 printf("%s", syscall_desc[sc_id].name);
350 print_sc_args(sc_args, syscall_desc[sc_id].n_args);
351 }
352 else {
353 printf("unknown_syscall<%d>", sc_id);
354 print_sc_args(sc_args, 6);
355 }
356 }
357}
358
359static void event_syscall_e(unsigned thread_id, uintptr_t thread_hash,
360 unsigned sc_id, sysarg_t sc_rc)
361{
362 sysarg_t sc_args[6];
363 int rv_type;
364 int rc;
365
366 /* Read syscall arguments */
367 rc = udebug_args_read(sess, thread_hash, sc_args);
368
369// printf("[%d] ", thread_id);
370
371 if (rc < 0) {
372 printf("error\n");
373 return;
374 }
375
376 if ((display_mask & DM_SYSCALL) != 0) {
377 /* Print syscall return value */
378 if (syscall_desc_defined(sc_id))
379 rv_type = syscall_desc[sc_id].rv_type;
380 else
381 rv_type = V_PTR;
382 print_sc_retval(sc_rc, rv_type);
383 }
384
385 switch (sc_id) {
386 case SYS_IPC_CALL_ASYNC_FAST:
387 sc_ipc_call_async_fast(sc_args, sc_rc);
388 break;
389 case SYS_IPC_CALL_ASYNC_SLOW:
390 sc_ipc_call_async_slow(sc_args, sc_rc);
391 break;
392 case SYS_IPC_WAIT:
393 sc_ipc_wait(sc_args, sc_rc);
394 break;
395 default:
396 break;
397 }
398}
399
400static void event_thread_b(uintptr_t hash)
401{
402 printf("New thread, hash %p\n", (void *) hash);
403 thread_trace_start(hash);
404}
405
406static int trace_loop(void *thread_hash_arg)
407{
408 int rc;
409 unsigned ev_type;
410 uintptr_t thread_hash;
411 unsigned thread_id;
412 sysarg_t val0, val1;
413
414 thread_hash = (uintptr_t)thread_hash_arg;
415 thread_id = next_thread_id++;
416 if (thread_id >= THBUF_SIZE) {
417 printf("Too many threads.\n");
418 return ELIMIT;
419 }
420
421 printf("Start tracing thread [%u] (hash %p).\n",
422 thread_id, (void *) thread_hash);
423
424 while (!abort_trace) {
425
426 fibril_mutex_lock(&state_lock);
427 if (paused) {
428 printf("Thread [%u] paused. Press R to resume.\n",
429 thread_id);
430
431 while (paused)
432 fibril_condvar_wait(&state_cv, &state_lock);
433
434 printf("Thread [%u] resumed.\n", thread_id);
435 }
436 fibril_mutex_unlock(&state_lock);
437
438 /* Run thread until an event occurs */
439 rc = udebug_go(sess, thread_hash,
440 &ev_type, &val0, &val1);
441
442// printf("rc = %d, ev_type=%d\n", rc, ev_type);
443 if (ev_type == UDEBUG_EVENT_FINISHED) {
444 /* Done tracing this thread */
445 break;
446 }
447
448 if (rc >= 0) {
449 switch (ev_type) {
450 case UDEBUG_EVENT_SYSCALL_B:
451 event_syscall_b(thread_id, thread_hash, val0, (int)val1);
452 break;
453 case UDEBUG_EVENT_SYSCALL_E:
454 event_syscall_e(thread_id, thread_hash, val0, (int)val1);
455 break;
456 case UDEBUG_EVENT_STOP:
457 printf("Stop event\n");
458 fibril_mutex_lock(&state_lock);
459 paused = true;
460 fibril_mutex_unlock(&state_lock);
461 break;
462 case UDEBUG_EVENT_THREAD_B:
463 event_thread_b(val0);
464 break;
465 case UDEBUG_EVENT_THREAD_E:
466 printf("Thread %" PRIun " exited.\n", val0);
467 fibril_mutex_lock(&state_lock);
468 abort_trace = true;
469 fibril_condvar_broadcast(&state_cv);
470 fibril_mutex_unlock(&state_lock);
471 break;
472 default:
473 printf("Unknown event type %d.\n", ev_type);
474 break;
475 }
476 }
477
478 }
479
480 printf("Finished tracing thread [%d].\n", thread_id);
481 return 0;
482}
483
484void thread_trace_start(uintptr_t thread_hash)
485{
486 fid_t fid;
487
488 thash = thread_hash;
489
490 fid = fibril_create(trace_loop, (void *)thread_hash);
491 if (fid == 0) {
492 printf("Warning: Failed creating fibril\n");
493 }
494 fibril_add_ready(fid);
495}
496
497static loader_t *preload_task(const char *path, char **argv,
498 task_id_t *task_id)
499{
500 loader_t *ldr;
501 int rc;
502
503 /* Spawn a program loader */
504 ldr = loader_connect();
505 if (ldr == NULL)
506 return NULL;
507
508 /* Get task ID. */
509 rc = loader_get_task_id(ldr, task_id);
510 if (rc != EOK)
511 goto error;
512
513 /* Send program. */
514 rc = loader_set_program_path(ldr, path);
515 if (rc != EOK)
516 goto error;
517
518 /* Send arguments */
519 rc = loader_set_args(ldr, (const char **) argv);
520 if (rc != EOK)
521 goto error;
522
523 /* Send default files */
524 int fd_root;
525 int fd_stdin;
526 int fd_stdout;
527 int fd_stderr;
528
529 fd_root = vfs_root();
530 if (fd_root >= 0) {
531 rc = loader_add_inbox(ldr, "root", fd_root);
532 vfs_put(fd_root);
533 if (rc != EOK)
534 goto error;
535 }
536
537 if ((stdin != NULL) && (vfs_fhandle(stdin, &fd_stdin) == EOK)) {
538 rc = loader_add_inbox(ldr, "stdin", fd_stdin);
539 if (rc != EOK)
540 goto error;
541 }
542
543 if ((stdout != NULL) && (vfs_fhandle(stdout, &fd_stdout) == EOK)) {
544 rc = loader_add_inbox(ldr, "stdout", fd_stdout);
545 if (rc != EOK)
546 goto error;
547 }
548
549 if ((stderr != NULL) && (vfs_fhandle(stderr, &fd_stderr) == EOK)) {
550 rc = loader_add_inbox(ldr, "stderr", fd_stderr);
551 if (rc != EOK)
552 goto error;
553 }
554
555 /* Load the program. */
556 rc = loader_load_program(ldr);
557 if (rc != EOK)
558 goto error;
559
560 /* Success */
561 return ldr;
562
563 /* Error exit */
564error:
565 loader_abort(ldr);
566 return NULL;
567}
568
569static int cev_fibril(void *arg)
570{
571 cons_event_t event;
572
573 (void) arg;
574
575 console_ctrl_t *console = console_init(stdin, stdout);
576
577 while (true) {
578 fibril_mutex_lock(&state_lock);
579 while (cev_valid)
580 fibril_condvar_wait(&state_cv, &state_lock);
581 fibril_mutex_unlock(&state_lock);
582
583 if (!console_get_event(console, &event))
584 return -1;
585
586 if (event.type == CEV_KEY) {
587 fibril_mutex_lock(&state_lock);
588 cev = event.ev.key;
589 cev_valid = true;
590 fibril_condvar_broadcast(&state_cv);
591 fibril_mutex_unlock(&state_lock);
592 }
593 }
594}
595
596static void trace_task(task_id_t task_id)
597{
598 kbd_event_t ev;
599 bool done;
600 int i;
601 int rc;
602
603 ipcp_init();
604
605 rc = get_thread_list();
606 if (rc < 0) {
607 printf("Failed to get thread list (error %d)\n", rc);
608 return;
609 }
610
611 abort_trace = false;
612
613 for (i = 0; i < n_threads; i++) {
614 thread_trace_start(thread_hash_buf[i]);
615 }
616
617 done = false;
618
619 while (!done) {
620 fibril_mutex_lock(&state_lock);
621 while (!cev_valid && !abort_trace)
622 fibril_condvar_wait(&state_cv, &state_lock);
623 fibril_mutex_unlock(&state_lock);
624
625 ev = cev;
626
627 fibril_mutex_lock(&state_lock);
628 cev_valid = false;
629 fibril_condvar_broadcast(&state_cv);
630 fibril_mutex_unlock(&state_lock);
631
632 if (abort_trace)
633 break;
634
635 if (ev.type != KEY_PRESS)
636 continue;
637
638 switch (ev.key) {
639 case KC_Q:
640 done = true;
641 break;
642 case KC_P:
643 printf("Pause...\n");
644 rc = udebug_stop(sess, thash);
645 if (rc != EOK)
646 printf("Error: stop -> %d\n", rc);
647 break;
648 case KC_R:
649 fibril_mutex_lock(&state_lock);
650 paused = false;
651 fibril_condvar_broadcast(&state_cv);
652 fibril_mutex_unlock(&state_lock);
653 printf("Resume...\n");
654 break;
655 default:
656 break;
657 }
658 }
659
660 printf("\nTerminate debugging session...\n");
661 abort_trace = true;
662 udebug_end(sess);
663 async_hangup(sess);
664
665 ipcp_cleanup();
666
667 printf("Done\n");
668 return;
669}
670
671static void main_init(void)
672{
673 proto_t *p;
674 oper_t *o;
675
676 val_type_t arg_def[OPER_MAX_ARGS] = {
677 V_INTEGER,
678 V_INTEGER,
679 V_INTEGER,
680 V_INTEGER,
681 V_INTEGER
682 };
683
684 val_type_t resp_def[OPER_MAX_ARGS] = {
685 V_INTEGER,
686 V_INTEGER,
687 V_INTEGER,
688 V_INTEGER,
689 V_INTEGER
690 };
691
692 next_thread_id = 1;
693 paused = false;
694 cev_valid = false;
695
696 fibril_mutex_initialize(&state_lock);
697 fibril_condvar_initialize(&state_cv);
698
699 proto_init();
700
701 p = proto_new("vfs");
702 o = oper_new("read", 3, arg_def, V_ERRNO, 1, resp_def);
703 proto_add_oper(p, VFS_IN_READ, o);
704 o = oper_new("write", 3, arg_def, V_ERRNO, 1, resp_def);
705 proto_add_oper(p, VFS_IN_WRITE, o);
706 o = oper_new("vfs_resize", 5, arg_def, V_ERRNO, 0, resp_def);
707 proto_add_oper(p, VFS_IN_RESIZE, o);
708 o = oper_new("vfs_stat", 1, arg_def, V_ERRNO, 0, resp_def);
709 proto_add_oper(p, VFS_IN_STAT, o);
710 o = oper_new("vfs_put", 1, arg_def, V_ERRNO, 0, resp_def);
711 proto_add_oper(p, VFS_IN_PUT, o);
712 o = oper_new("vfs_mount", 2, arg_def, V_ERRNO, 0, resp_def);
713 proto_add_oper(p, VFS_IN_MOUNT, o);
714/* o = oper_new("unmount", 0, arg_def);
715 proto_add_oper(p, VFS_IN_UNMOUNT, o);*/
716 o = oper_new("vfs_sync", 1, arg_def, V_ERRNO, 0, resp_def);
717 proto_add_oper(p, VFS_IN_SYNC, o);
718 o = oper_new("rename", 0, arg_def, V_ERRNO, 0, resp_def);
719 proto_add_oper(p, VFS_IN_RENAME, o);
720 o = oper_new("vfs_statfs", 0, arg_def, V_ERRNO, 0, resp_def);
721 proto_add_oper(p, VFS_IN_STATFS, o);
722 o = oper_new("vfs_walk", 2, arg_def, V_INT_ERRNO, 0, resp_def);
723 proto_add_oper(p, VFS_IN_WALK, o);
724 o = oper_new("vfs_open", 2, arg_def, V_ERRNO, 0, resp_def);
725 proto_add_oper(p, VFS_IN_OPEN, o);
726 o = oper_new("vfs_unlink", 3, arg_def, V_ERRNO, 0, resp_def);
727 proto_add_oper(p, VFS_IN_UNLINK, o);
728
729 proto_register(SERVICE_VFS, p);
730}
731
732static void print_syntax(void)
733{
734 printf("Syntax:\n");
735 printf("\ttrace [+<events>] <executable> [<arg1> [...]]\n");
736 printf("or\ttrace [+<events>] -t <task_id>\n");
737 printf("Events: (default is +tp)\n");
738 printf("\n");
739 printf("\tt ... Thread creation and termination\n");
740 printf("\ts ... System calls\n");
741 printf("\ti ... Low-level IPC\n");
742 printf("\tp ... Protocol level\n");
743 printf("\n");
744 printf("Examples:\n");
745 printf("\ttrace +s /app/tetris\n");
746 printf("\ttrace +tsip -t 12\n");
747}
748
749static display_mask_t parse_display_mask(const char *text)
750{
751 display_mask_t dm = 0;
752 const char *c = text;
753
754 while (*c) {
755 switch (*c) {
756 case 't':
757 dm = dm | DM_THREAD;
758 break;
759 case 's':
760 dm = dm | DM_SYSCALL;
761 break;
762 case 'i':
763 dm = dm | DM_IPC;
764 break;
765 case 'p':
766 dm = dm | DM_SYSTEM | DM_USER;
767 break;
768 default:
769 printf("Unexpected event type '%c'.\n", *c);
770 exit(1);
771 }
772
773 ++c;
774 }
775
776 return dm;
777}
778
779static int parse_args(int argc, char *argv[])
780{
781 char *err_p;
782
783 task_id = 0;
784
785 --argc;
786 ++argv;
787
788 while (argc > 0) {
789 char *arg = *argv;
790 if (arg[0] == '+') {
791 display_mask = parse_display_mask(&arg[1]);
792 } else if (arg[0] == '-') {
793 if (arg[1] == 't') {
794 /* Trace an already running task */
795 --argc;
796 ++argv;
797 task_id = strtol(*argv, &err_p, 10);
798 task_ldr = NULL;
799 task_wait_for = false;
800 if (*err_p) {
801 printf("Task ID syntax error\n");
802 print_syntax();
803 return -1;
804 }
805 } else {
806 printf("Uknown option '%c'\n", arg[0]);
807 print_syntax();
808 return -1;
809 }
810 } else {
811 break;
812 }
813
814 --argc;
815 ++argv;
816 }
817
818 if (task_id != 0) {
819 if (argc == 0)
820 return 0;
821 printf("Extra arguments\n");
822 print_syntax();
823 return -1;
824 }
825
826 if (argc < 1) {
827 printf("Missing argument\n");
828 print_syntax();
829 return -1;
830 }
831
832 /* Preload the specified program file. */
833 printf("Spawning '%s' with arguments:\n", *argv);
834
835 char **cp = argv;
836 while (*cp)
837 printf("'%s'\n", *cp++);
838
839 task_ldr = preload_task(*argv, argv, &task_id);
840 task_wait_for = true;
841
842 return 0;
843}
844
845int main(int argc, char *argv[])
846{
847 int rc;
848 task_exit_t texit;
849 int retval;
850
851 printf("System Call / IPC Tracer\n");
852 printf("Controls: Q - Quit, P - Pause, R - Resume\n");
853
854 display_mask = DM_THREAD | DM_SYSTEM | DM_USER;
855
856 if (parse_args(argc, argv) < 0)
857 return 1;
858
859 main_init();
860
861 rc = connect_task(task_id);
862 if (rc < 0) {
863 printf("Failed connecting to task %" PRIu64 ".\n", task_id);
864 return 1;
865 }
866
867 printf("Connected to task %" PRIu64 ".\n", task_id);
868
869 if (task_ldr != NULL)
870 program_run();
871
872 cev_fibril_start();
873 trace_task(task_id);
874
875 if (task_wait_for) {
876 printf("Waiting for task to exit.\n");
877
878 rc = task_wait_task_id(task_id, &texit, &retval);
879 if (rc != EOK) {
880 printf("Failed waiting for task.\n");
881 return -1;
882 }
883
884 if (texit == TASK_EXIT_NORMAL) {
885 printf("Task exited normally, return value %d.\n",
886 retval);
887 } else {
888 printf("Task exited unexpectedly.\n");
889 }
890 }
891
892 return 0;
893}
894
895/** @}
896 */
Note: See TracBrowser for help on using the repository browser.