Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/trace/trace.c

    rf019cc07 rffa2c8ef  
    3636#include <stdlib.h>
    3737#include <unistd.h>
    38 #include <ipc/ipc.h>
    3938#include <fibril.h>
    4039#include <errno.h>
    … …  
    4342#include <task.h>
    4443#include <mem.h>
    45 #include <string.h>
     44#include <str.h>
    4645#include <bool.h>
    4746#include <loader/loader.h>
    4847#include <io/console.h>
    4948#include <io/keycode.h>
    50 #include <fibril_sync.h>
     49#include <fibril_synch.h>
     50#include <sys/types.h>
     51#include <sys/typefmt.h>
    5152
    5253#include <libc.h>
    … …  
    147148        int rc;
    148149
    149         rc = ipc_connect_kbox(task_id);
     150        rc = async_connect_kbox(task_id);
    150151
    151152        if (rc == ENOTSUP) {
    … …  
    159160        if (rc < 0) {
    160161                printf("Error connecting\n");
    161                 printf("ipc_connect_task(%lld) -> %d ", task_id, rc);
     162                printf("ipc_connect_task(%" PRIu64 ") -> %d ", task_id, rc);
    162163                return rc;
    163164        }
    … …  
    198199        printf("Threads:");
    199200        for (i = 0; i < n_threads; i++) {
    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));
     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));
    203204
    204205        return 0;
    … …  
    222223        case V_HASH:
    223224        case V_PTR:
    224                 printf("0x%08lx", val);
     225                printf("%p", (void *) val);
    225226                break;
    226227
    … …  
    246247        case V_CHAR:
    247248                if (sval >= 0x20 && sval < 0x7f) {
    248                         printf("'%c'", sval);
     249                        printf("'%c'", (char) sval);
    249250                } else {
    250251                        switch (sval) {
    … …  
    255256                        case '\t': printf("'\\t'"); break;
    256257                        case '\\': printf("'\\\\'"); break;
    257                         default: printf("'\\x%02lX'", val); break;
     258                        default: printf("'\\x%02" PRIxn "'", val); break;
    258259                        }
    259260                }
    … …  
    275276
    276277        putchar('(');
    277         if (n > 0) printf("%ld", sc_args[0]);
     278        if (n > 0) printf("%" PRIun, sc_args[0]);
    278279        for (i = 1; i < n; i++) {
    279                 printf(", %ld", sc_args[i]);
     280                printf(", %" PRIun, sc_args[i]);
    280281        }
    281282        putchar(')');
    … …  
    285286{
    286287        ipc_call_t call;
    287         ipcarg_t phoneid;
     288        sysarg_t phoneid;
    288289       
    289290        if (sc_rc == (sysarg_t) IPC_CALLRET_FATAL ||
    … …  
    293294        phoneid = sc_args[0];
    294295
    295         IPC_SET_METHOD(call, sc_args[1]);
     296        IPC_SET_IMETHOD(call, sc_args[1]);
    296297        IPC_SET_ARG1(call, sc_args[2]);
    297298        IPC_SET_ARG2(call, sc_args[3]);
    … …  
    329330        phoneidx = sc_args[0];
    330331
    331         IPC_SET_METHOD(question, sc_args[1]);
     332        IPC_SET_IMETHOD(question, sc_args[1]);
    332333        IPC_SET_ARG1(question, sc_args[2]);
    333334        IPC_SET_ARG2(question, sc_args[3]);
    … …  
    487488{
    488489        async_serialize_start();
    489         printf("New thread, hash 0x%lx\n", hash);
     490        printf("New thread, hash %p\n", (void *) hash);
    490491        async_serialize_end();
    491492
    … …  
    508509        }
    509510
    510         printf("Start tracing thread [%d] (hash 0x%lx).\n", thread_id, thread_hash);
     511        printf("Start tracing thread [%u] (hash %p).\n",
     512            thread_id, (void *) thread_hash);
    511513
    512514        while (!abort_trace) {
    … …  
    514516                fibril_mutex_lock(&state_lock);
    515517                if (paused) {
    516                         printf("Thread [%d] paused. Press R to resume.\n",
     518                        printf("Thread [%u] paused. Press R to resume.\n",
    517519                            thread_id);
    518520
    … …  
    520522                                fibril_condvar_wait(&state_cv, &state_lock);
    521523
    522                         printf("Thread [%d] resumed.\n", thread_id);
     524                        printf("Thread [%u] resumed.\n", thread_id);
    523525                }
    524526                fibril_mutex_unlock(&state_lock);
    … …  
    552554                                break;
    553555                        case UDEBUG_EVENT_THREAD_E:
    554                                 printf("Thread 0x%lx exited.\n", val0);
     556                                printf("Thread %" PRIun " exited.\n", val0);
    555557                                fibril_mutex_lock(&state_lock);
    556558                                abort_trace = true;
    … …  
    583585}
    584586
    585 static loader_t *preload_task(const char *path, char *const argv[],
     587static loader_t *preload_task(const char *path, char **argv,
    586588    task_id_t *task_id)
    587589{
    … …  
    589591        int rc;
    590592
    591         /* Spawn a program loader */   
     593        /* Spawn a program loader */
    592594        ldr = loader_connect();
    593595        if (ldr == NULL)
    … …  
    605607
    606608        /* Send arguments */
    607         rc = loader_set_args(ldr, argv);
     609        rc = loader_set_args(ldr, (const char **) argv);
    608610        if (rc != EOK)
    609611                goto error;
    … …  
    742744        abort_trace = true;
    743745        udebug_end(phoneid);
    744         ipc_hangup(phoneid);
     746        async_hangup(phoneid);
    745747
    746748        ipcp_cleanup();
    … …  
    868870}
    869871
    870 static display_mask_t parse_display_mask(char *text)
     872static display_mask_t parse_display_mask(const char *text)
    871873{
    872874        display_mask_t dm;
    873         char *c;
    874 
    875         c = text;
    876 
     875        const char *c = text;
     876       
    877877        while (*c) {
    878878                switch (*c) {
    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;
     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;
    883891                default:
    884892                        printf("Unexpected event type '%c'.\n", *c);
    885893                        exit(1);
    886894                }
    887 
     895               
    888896                ++c;
    889897        }
    890 
     898       
    891899        return dm;
    892900}
    … …  
    894902static int parse_args(int argc, char *argv[])
    895903{
    896         char *arg;
    897904        char *err_p;
    898905
    899906        task_id = 0;
    900907
    901         --argc; ++argv;
     908        --argc;
     909        ++argv;
    902910
    903911        while (argc > 0) {
    904                 arg = *argv;
     912                char *arg = *argv;
    905913                if (arg[0] == '+') {
    906914                        display_mask = parse_display_mask(&arg[1]);
    … …  
    908916                        if (arg[1] == 't') {
    909917                                /* Trace an already running task */
    910                                 --argc; ++argv;
     918                                --argc;
     919                                ++argv;
    911920                                task_id = strtol(*argv, &err_p, 10);
    912921                                task_ldr = NULL;
    … …  
    918927                                }
    919928                        } else {
    920                                 printf("Uknown option '%s'\n", arg[0]);
     929                                printf("Uknown option '%c'\n", arg[0]);
    921930                                print_syntax();
    922931                                return -1;
    … …  
    925934                        break;
    926935                }
    927 
    928                 --argc; ++argv;
     936               
     937                --argc;
     938                ++argv;
    929939        }
    930940
    931941        if (task_id != 0) {
    932                 if (argc == 0) return 0;
     942                if (argc == 0)
     943                        return 0;
    933944                printf("Extra arguments\n");
    934945                print_syntax();
    … …  
    944955        /* Preload the specified program file. */
    945956        printf("Spawning '%s' with arguments:\n", *argv);
    946         {
    947                 char **cp = argv;
    948                 while (*cp) printf("'%s'\n", *cp++);
    949         }
     957       
     958        char **cp = argv;
     959        while (*cp)
     960                printf("'%s'\n", *cp++);
     961       
    950962        task_ldr = preload_task(*argv, argv, &task_id);
    951963        task_wait_for = true;
    … …  
    972984        rc = connect_task(task_id);
    973985        if (rc < 0) {
    974                 printf("Failed connecting to task %lld.\n", task_id);
     986                printf("Failed connecting to task %" PRIu64 ".\n", task_id);
    975987                return 1;
    976988        }
    977989
    978         printf("Connected to task %lld.\n", task_id);
     990        printf("Connected to task %" PRIu64 ".\n", task_id);
    979991
    980992        if (task_ldr != NULL)
Note: See TracChangeset for help on using the changeset viewer.