Subversion Repositories HelenOS

Rev

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