Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/trace/trace.c

    r7e752b2 r1ccafee  
    4343#include <task.h>
    4444#include <mem.h>
    45 #include <str.h>
     45#include <string.h>
    4646#include <bool.h>
    4747#include <loader/loader.h>
     
    161161        if (rc < 0) {
    162162                printf("Error connecting\n");
    163                 printf("ipc_connect_task(%" PRIu64 ") -> %d ", task_id, rc);
     163                printf("ipc_connect_task(%" PRIdTASKID ") -> %d ", task_id, rc);
    164164                return rc;
    165165        }
     
    200200        printf("Threads:");
    201201        for (i = 0; i < n_threads; i++) {
    202                 printf(" [%d] (hash %p)", 1 + i, (void *) thread_hash_buf[i]);
    203         }
    204         printf("\ntotal of %zu threads\n", tb_needed / sizeof(uintptr_t));
     202                printf(" [%d] (hash %p)", 1+i, thread_hash_buf[i]);
     203        }
     204        printf("\ntotal of %u threads\n", tb_needed / sizeof(uintptr_t));
    205205
    206206        return 0;
     
    224224        case V_HASH:
    225225        case V_PTR:
    226                 printf("%p", (void *) val);
     226                printf("%p", val);
    227227                break;
    228228
     
    248248        case V_CHAR:
    249249                if (sval >= 0x20 && sval < 0x7f) {
    250                         printf("'%c'", (char) sval);
     250                        printf("'%c'", sval);
    251251                } else {
    252252                        switch (sval) {
     
    257257                        case '\t': printf("'\\t'"); break;
    258258                        case '\\': printf("'\\\\'"); break;
    259                         default: printf("'\\x%02" PRIxn "'", val); break;
     259                        default: printf("'\\x%02lX'", val); break;
    260260                        }
    261261                }
     
    277277
    278278        putchar('(');
    279         if (n > 0) printf("%" PRIun, sc_args[0]);
     279        if (n > 0) printf("%" PRIdSYSARG, sc_args[0]);
    280280        for (i = 1; i < n; i++) {
    281                 printf(", %" PRIun, sc_args[i]);
     281                printf(", %" PRIdSYSARG, sc_args[i]);
    282282        }
    283283        putchar(')');
     
    489489{
    490490        async_serialize_start();
    491         printf("New thread, hash %p\n", (void *) hash);
     491        printf("New thread, hash 0x%lx\n", hash);
    492492        async_serialize_end();
    493493
     
    510510        }
    511511
    512         printf("Start tracing thread [%u] (hash %p).\n",
    513             thread_id, (void *) thread_hash);
     512        printf("Start tracing thread [%d] (hash %p).\n", thread_id, thread_hash);
    514513
    515514        while (!abort_trace) {
     
    517516                fibril_mutex_lock(&state_lock);
    518517                if (paused) {
    519                         printf("Thread [%u] paused. Press R to resume.\n",
     518                        printf("Thread [%d] paused. Press R to resume.\n",
    520519                            thread_id);
    521520
     
    523522                                fibril_condvar_wait(&state_cv, &state_lock);
    524523
    525                         printf("Thread [%u] resumed.\n", thread_id);
     524                        printf("Thread [%d] resumed.\n", thread_id);
    526525                }
    527526                fibril_mutex_unlock(&state_lock);
     
    555554                                break;
    556555                        case UDEBUG_EVENT_THREAD_E:
    557                                 printf("Thread %" PRIun " exited.\n", val0);
     556                                printf("Thread %p exited.\n", val0);
    558557                                fibril_mutex_lock(&state_lock);
    559558                                abort_trace = true;
     
    586585}
    587586
    588 static loader_t *preload_task(const char *path, char **argv,
     587static loader_t *preload_task(const char *path, char *const argv[],
    589588    task_id_t *task_id)
    590589{
     
    592591        int rc;
    593592
    594         /* Spawn a program loader */
     593        /* Spawn a program loader */   
    595594        ldr = loader_connect();
    596595        if (ldr == NULL)
     
    608607
    609608        /* Send arguments */
    610         rc = loader_set_args(ldr, (const char **) argv);
     609        rc = loader_set_args(ldr, argv);
    611610        if (rc != EOK)
    612611                goto error;
     
    871870}
    872871
    873 static display_mask_t parse_display_mask(const char *text)
     872static display_mask_t parse_display_mask(char *text)
    874873{
    875874        display_mask_t dm;
    876         const char *c = text;
    877        
     875        char *c;
     876
     877        c = text;
     878
    878879        while (*c) {
    879880                switch (*c) {
    880                 case 't':
    881                         dm = dm | DM_THREAD;
    882                         break;
    883                 case 's':
    884                         dm = dm | DM_SYSCALL;
    885                         break;
    886                 case 'i':
    887                         dm = dm | DM_IPC;
    888                         break;
    889                 case 'p':
    890                         dm = dm | DM_SYSTEM | DM_USER;
    891                         break;
     881                case 't': dm = dm | DM_THREAD; break;
     882                case 's': dm = dm | DM_SYSCALL; break;
     883                case 'i': dm = dm | DM_IPC; break;
     884                case 'p': dm = dm | DM_SYSTEM | DM_USER; break;
    892885                default:
    893886                        printf("Unexpected event type '%c'.\n", *c);
    894887                        exit(1);
    895888                }
    896                
     889
    897890                ++c;
    898891        }
    899        
     892
    900893        return dm;
    901894}
     
    903896static int parse_args(int argc, char *argv[])
    904897{
     898        char *arg;
    905899        char *err_p;
    906900
    907901        task_id = 0;
    908902
    909         --argc;
    910         ++argv;
     903        --argc; ++argv;
    911904
    912905        while (argc > 0) {
    913                 char *arg = *argv;
     906                arg = *argv;
    914907                if (arg[0] == '+') {
    915908                        display_mask = parse_display_mask(&arg[1]);
     
    917910                        if (arg[1] == 't') {
    918911                                /* Trace an already running task */
    919                                 --argc;
    920                                 ++argv;
     912                                --argc; ++argv;
    921913                                task_id = strtol(*argv, &err_p, 10);
    922914                                task_ldr = NULL;
     
    928920                                }
    929921                        } else {
    930                                 printf("Uknown option '%c'\n", arg[0]);
     922                                printf("Uknown option '%s'\n", arg[0]);
    931923                                print_syntax();
    932924                                return -1;
     
    935927                        break;
    936928                }
    937                
    938                 --argc;
    939                 ++argv;
     929
     930                --argc; ++argv;
    940931        }
    941932
    942933        if (task_id != 0) {
    943                 if (argc == 0)
    944                         return 0;
     934                if (argc == 0) return 0;
    945935                printf("Extra arguments\n");
    946936                print_syntax();
     
    956946        /* Preload the specified program file. */
    957947        printf("Spawning '%s' with arguments:\n", *argv);
    958        
    959         char **cp = argv;
    960         while (*cp)
    961                 printf("'%s'\n", *cp++);
    962        
     948        {
     949                char **cp = argv;
     950                while (*cp) printf("'%s'\n", *cp++);
     951        }
    963952        task_ldr = preload_task(*argv, argv, &task_id);
    964953        task_wait_for = true;
     
    985974        rc = connect_task(task_id);
    986975        if (rc < 0) {
    987                 printf("Failed connecting to task %" PRIu64 ".\n", task_id);
     976                printf("Failed connecting to task %" PRIdTASKID ".\n", task_id);
    988977                return 1;
    989978        }
    990979
    991         printf("Connected to task %" PRIu64 ".\n", task_id);
     980        printf("Connected to task %" PRIdTASKID ".\n", task_id);
    992981
    993982        if (task_ldr != NULL)
Note: See TracChangeset for help on using the changeset viewer.