Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/trace/trace.c

    rffa2c8ef rf019cc07  
    3636#include <stdlib.h>
    3737#include <unistd.h>
     38#include <ipc/ipc.h>
    3839#include <fibril.h>
    3940#include <errno.h>
    … …  
    4243#include <task.h>
    4344#include <mem.h>
    44 #include <str.h>
     45#include <string.h>
    4546#include <bool.h>
    4647#include <loader/loader.h>
    4748#include <io/console.h>
    4849#include <io/keycode.h>
    49 #include <fibril_synch.h>
    50 #include <sys/types.h>
    51 #include <sys/typefmt.h>
     50#include <fibril_sync.h>
    5251
    5352#include <libc.h>
    … …  
    148147        int rc;
    149148
    150         rc = async_connect_kbox(task_id);
     149        rc = ipc_connect_kbox(task_id);
    151150
    152151        if (rc == ENOTSUP) {
    … …  
    160159        if (rc < 0) {
    161160                printf("Error connecting\n");
    162                 printf("ipc_connect_task(%" PRIu64 ") -> %d ", task_id, rc);
     161                printf("ipc_connect_task(%lld) -> %d ", task_id, rc);
    163162                return rc;
    164163        }
    … …  
    199198        printf("Threads:");
    200199        for (i = 0; i < n_threads; i++) {
    201                 printf(" [%d] (hash %p)", 1 + i, (void *) thread_hash_buf[i]);
    202         }
    203         printf("\ntotal of %zu threads\n", tb_needed / sizeof(uintptr_t));
     200                printf(" [%d] (hash 0x%lx)", 1+i, thread_hash_buf[i]);
     201        }
     202        printf("\ntotal of %u threads\n", tb_needed / sizeof(uintptr_t));
    204203
    205204        return 0;
    … …  
    223222        case V_HASH:
    224223        case V_PTR:
    225                 printf("%p", (void *) val);
     224                printf("0x%08lx", val);
    226225                break;
    227226
    … …  
    247246        case V_CHAR:
    248247                if (sval >= 0x20 && sval < 0x7f) {
    249                         printf("'%c'", (char) sval);
     248                        printf("'%c'", sval);
    250249                } else {
    251250                        switch (sval) {
    … …  
    256255                        case '\t': printf("'\\t'"); break;
    257256                        case '\\': printf("'\\\\'"); break;
    258                         default: printf("'\\x%02" PRIxn "'", val); break;
     257                        default: printf("'\\x%02lX'", val); break;
    259258                        }
    260259                }
    … …  
    276275
    277276        putchar('(');
    278         if (n > 0) printf("%" PRIun, sc_args[0]);
     277        if (n > 0) printf("%ld", sc_args[0]);
    279278        for (i = 1; i < n; i++) {
    280                 printf(", %" PRIun, sc_args[i]);
     279                printf(", %ld", sc_args[i]);
    281280        }
    282281        putchar(')');
    … …  
    286285{
    287286        ipc_call_t call;
    288         sysarg_t phoneid;
     287        ipcarg_t phoneid;
    289288       
    290289        if (sc_rc == (sysarg_t) IPC_CALLRET_FATAL ||
    … …  
    294293        phoneid = sc_args[0];
    295294
    296         IPC_SET_IMETHOD(call, sc_args[1]);
     295        IPC_SET_METHOD(call, sc_args[1]);
    297296        IPC_SET_ARG1(call, sc_args[2]);
    298297        IPC_SET_ARG2(call, sc_args[3]);
    … …  
    330329        phoneidx = sc_args[0];
    331330
    332         IPC_SET_IMETHOD(question, sc_args[1]);
     331        IPC_SET_METHOD(question, sc_args[1]);
    333332        IPC_SET_ARG1(question, sc_args[2]);
    334333        IPC_SET_ARG2(question, sc_args[3]);
    … …  
    488487{
    489488        async_serialize_start();
    490         printf("New thread, hash %p\n", (void *) hash);
     489        printf("New thread, hash 0x%lx\n", hash);
    491490        async_serialize_end();
    492491
    … …  
    509508        }
    510509
    511         printf("Start tracing thread [%u] (hash %p).\n",
    512             thread_id, (void *) thread_hash);
     510        printf("Start tracing thread [%d] (hash 0x%lx).\n", thread_id, thread_hash);
    513511
    514512        while (!abort_trace) {
    … …  
    516514                fibril_mutex_lock(&state_lock);
    517515                if (paused) {
    518                         printf("Thread [%u] paused. Press R to resume.\n",
     516                        printf("Thread [%d] paused. Press R to resume.\n",
    519517                            thread_id);
    520518
    … …  
    522520                                fibril_condvar_wait(&state_cv, &state_lock);
    523521
    524                         printf("Thread [%u] resumed.\n", thread_id);
     522                        printf("Thread [%d] resumed.\n", thread_id);
    525523                }
    526524                fibril_mutex_unlock(&state_lock);
    … …  
    554552                                break;
    555553                        case UDEBUG_EVENT_THREAD_E:
    556                                 printf("Thread %" PRIun " exited.\n", val0);
     554                                printf("Thread 0x%lx exited.\n", val0);
    557555                                fibril_mutex_lock(&state_lock);
    558556                                abort_trace = true;
    … …  
    585583}
    586584
    587 static loader_t *preload_task(const char *path, char **argv,
     585static loader_t *preload_task(const char *path, char *const argv[],
    588586    task_id_t *task_id)
    589587{
    … …  
    591589        int rc;
    592590
    593         /* Spawn a program loader */
     591        /* Spawn a program loader */   
    594592        ldr = loader_connect();
    595593        if (ldr == NULL)
    … …  
    607605
    608606        /* Send arguments */
    609         rc = loader_set_args(ldr, (const char **) argv);
     607        rc = loader_set_args(ldr, argv);
    610608        if (rc != EOK)
    611609                goto error;
    … …  
    744742        abort_trace = true;
    745743        udebug_end(phoneid);
    746         async_hangup(phoneid);
     744        ipc_hangup(phoneid);
    747745
    748746        ipcp_cleanup();
    … …  
    870868}
    871869
    872 static display_mask_t parse_display_mask(const char *text)
     870static display_mask_t parse_display_mask(char *text)
    873871{
    874872        display_mask_t dm;
    875         const char *c = text;
    876        
     873        char *c;
     874
     875        c = text;
     876
    877877        while (*c) {
    878878                switch (*c) {
    879                 case 't':
    880                         dm = dm | DM_THREAD;
    881                         break;
    882                 case 's':
    883                         dm = dm | DM_SYSCALL;
    884                         break;
    885                 case 'i':
    886                         dm = dm | DM_IPC;
    887                         break;
    888                 case 'p':
    889                         dm = dm | DM_SYSTEM | DM_USER;
    890                         break;
     879                case 't': dm = dm | DM_THREAD; break;
     880                case 's': dm = dm | DM_SYSCALL; break;
     881                case 'i': dm = dm | DM_IPC; break;
     882                case 'p': dm = dm | DM_SYSTEM | DM_USER; break;
    891883                default:
    892884                        printf("Unexpected event type '%c'.\n", *c);
    893885                        exit(1);
    894886                }
    895                
     887
    896888                ++c;
    897889        }
    898        
     890
    899891        return dm;
    900892}
    … …  
    902894static int parse_args(int argc, char *argv[])
    903895{
     896        char *arg;
    904897        char *err_p;
    905898
    906899        task_id = 0;
    907900
    908         --argc;
    909         ++argv;
     901        --argc; ++argv;
    910902
    911903        while (argc > 0) {
    912                 char *arg = *argv;
     904                arg = *argv;
    913905                if (arg[0] == '+') {
    914906                        display_mask = parse_display_mask(&arg[1]);
    … …  
    916908                        if (arg[1] == 't') {
    917909                                /* Trace an already running task */
    918                                 --argc;
    919                                 ++argv;
     910                                --argc; ++argv;
    920911                                task_id = strtol(*argv, &err_p, 10);
    921912                                task_ldr = NULL;
    … …  
    927918                                }
    928919                        } else {
    929                                 printf("Uknown option '%c'\n", arg[0]);
     920                                printf("Uknown option '%s'\n", arg[0]);
    930921                                print_syntax();
    931922                                return -1;
    … …  
    934925                        break;
    935926                }
    936                
    937                 --argc;
    938                 ++argv;
     927
     928                --argc; ++argv;
    939929        }
    940930
    941931        if (task_id != 0) {
    942                 if (argc == 0)
    943                         return 0;
     932                if (argc == 0) return 0;
    944933                printf("Extra arguments\n");
    945934                print_syntax();
    … …  
    955944        /* Preload the specified program file. */
    956945        printf("Spawning '%s' with arguments:\n", *argv);
    957        
    958         char **cp = argv;
    959         while (*cp)
    960                 printf("'%s'\n", *cp++);
    961        
     946        {
     947                char **cp = argv;
     948                while (*cp) printf("'%s'\n", *cp++);
     949        }
    962950        task_ldr = preload_task(*argv, argv, &task_id);
    963951        task_wait_for = true;
    … …  
    984972        rc = connect_task(task_id);
    985973        if (rc < 0) {
    986                 printf("Failed connecting to task %" PRIu64 ".\n", task_id);
     974                printf("Failed connecting to task %lld.\n", task_id);
    987975                return 1;
    988976        }
    989977
    990         printf("Connected to task %" PRIu64 ".\n", task_id);
     978        printf("Connected to task %lld.\n", task_id);
    991979
    992980        if (task_ldr != NULL)
Note: See TracChangeset for help on using the changeset viewer.