Ignore:
File:
1 edited

Legend:

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

    ra53ed3a r9af1c61  
    6363#include "syscalls.h"
    6464#include "ipcp.h"
     65#include "errors.h"
    6566#include "trace.h"
    6667
     
    9394display_mask_t display_mask;
    9495
    95 static errno_t program_run_fibril(void *arg);
    96 static errno_t cev_fibril(void *arg);
     96static int program_run_fibril(void *arg);
     97static int cev_fibril(void *arg);
    9798
    9899static void program_run(void)
     
    122123}
    123124
    124 static errno_t program_run_fibril(void *arg)
    125 {
    126         errno_t rc;
     125static int program_run_fibril(void *arg)
     126{
     127        int rc;
    127128
    128129        /*
     
    131132         */
    132133        rc = loader_run(task_ldr);
    133         if (rc != EOK) {
     134        if (rc != 0) {
    134135                printf("Error running program\n");
    135136                exit(1);
     
    143144
    144145
    145 static errno_t connect_task(task_id_t task_id)
     146static int connect_task(task_id_t task_id)
    146147{
    147148        async_sess_t *ksess = async_connect_kbox(task_id);
     
    161162        }
    162163       
    163         errno_t rc = udebug_begin(ksess);
    164         if (rc != EOK) {
    165                 printf("udebug_begin() -> %s\n", str_error_name(rc));
     164        int rc = udebug_begin(ksess);
     165        if (rc < 0) {
     166                printf("udebug_begin() -> %d\n", rc);
    166167                return rc;
    167168        }
    168169       
    169170        rc = udebug_set_evmask(ksess, UDEBUG_EM_ALL);
    170         if (rc != EOK) {
    171                 printf("udebug_set_evmask(0x%x) -> %s\n ", UDEBUG_EM_ALL, str_error_name(rc));
     171        if (rc < 0) {
     172                printf("udebug_set_evmask(0x%x) -> %d\n ", UDEBUG_EM_ALL, rc);
    172173                return rc;
    173174        }
     
    177178}
    178179
    179 static errno_t get_thread_list(void)
    180 {
    181         errno_t rc;
     180static int get_thread_list(void)
     181{
     182        int rc;
    182183        size_t tb_copied;
    183184        size_t tb_needed;
     
    186187        rc = udebug_thread_read(sess, thread_hash_buf,
    187188                THBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);
    188         if (rc != EOK) {
    189                 printf("udebug_thread_read() -> %s\n", str_error_name(rc));
     189        if (rc < 0) {
     190                printf("udebug_thread_read() -> %d\n", rc);
    190191                return rc;
    191192        }
     
    225226                if (sval >= -15 && sval <= 0) {
    226227                        printf("%ld %s (%s)", sval,
    227                             str_error_name((errno_t) sval),
    228                             str_error((errno_t) sval));
     228                            err_desc[-sval].name,
     229                            err_desc[-sval].desc);
    229230                } else {
    230231                        printf("%ld", sval);
     
    234235                if (sval >= -15 && sval < 0) {
    235236                        printf("%ld %s (%s)", sval,
    236                             str_error_name((errno_t) sval),
    237                             str_error((errno_t) sval));
     237                            err_desc[-sval].name,
     238                            err_desc[-sval].desc);
    238239                } else {
    239240                        printf("%ld", sval);
     
    279280}
    280281
    281 static void sc_ipc_call_async_fast(sysarg_t *sc_args, errno_t sc_rc)
     282static void sc_ipc_call_async_fast(sysarg_t *sc_args, sysarg_t sc_rc)
    282283{
    283284        ipc_call_t call;
    284285        sysarg_t phoneid;
    285286       
    286         if (sc_rc != EOK)
     287        if (sc_rc != (sysarg_t) EOK)
    287288                return;
    288289
     
    296297        IPC_SET_ARG5(call, 0);
    297298
    298         ipcp_call_out(phoneid, &call, 0);
    299 }
    300 
    301 static void sc_ipc_call_async_slow(sysarg_t *sc_args, errno_t sc_rc)
     299        ipcp_call_out(phoneid, &call, sc_rc);
     300}
     301
     302static void sc_ipc_call_async_slow(sysarg_t *sc_args, sysarg_t sc_rc)
    302303{
    303304        ipc_call_t call;
    304         errno_t rc;
    305 
    306         if (sc_rc != EOK)
     305        int rc;
     306
     307        if (sc_rc != (sysarg_t) EOK)
    307308                return;
    308309
     
    310311        rc = udebug_mem_read(sess, &call.args, sc_args[1], sizeof(call.args));
    311312
    312         if (rc == EOK) {
    313                 ipcp_call_out(sc_args[0], &call, 0);
     313        if (rc >= 0) {
     314                ipcp_call_out(sc_args[0], &call, sc_rc);
    314315        }
    315316}
     
    318319{
    319320        ipc_call_t call;
    320         errno_t rc;
     321        int rc;
    321322
    322323        if (sc_rc == 0) return;
     
    325326        rc = udebug_mem_read(sess, &call, sc_args[0], sizeof(call));
    326327       
    327         if (rc == EOK)
     328        if (rc >= 0)
    328329                ipcp_call_in(&call, sc_rc);
    329330}
     
    333334{
    334335        sysarg_t sc_args[6];
    335         errno_t rc;
     336        int rc;
    336337
    337338        /* Read syscall arguments */
    338339        rc = udebug_args_read(sess, thread_hash, sc_args);
    339340
    340         if (rc != EOK) {
     341        if (rc < 0) {
    341342                printf("error\n");
    342343                return;
     
    361362        sysarg_t sc_args[6];
    362363        int rv_type;
    363         errno_t rc;
     364        int rc;
    364365
    365366        /* Read syscall arguments */
     
    368369//      printf("[%d] ", thread_id);
    369370
    370         if (rc != EOK) {
     371        if (rc < 0) {
    371372                printf("error\n");
    372373                return;
     
    384385        switch (sc_id) {
    385386        case SYS_IPC_CALL_ASYNC_FAST:
    386                 sc_ipc_call_async_fast(sc_args, (errno_t) sc_rc);
     387                sc_ipc_call_async_fast(sc_args, sc_rc);
    387388                break;
    388389        case SYS_IPC_CALL_ASYNC_SLOW:
    389                 sc_ipc_call_async_slow(sc_args, (errno_t) sc_rc);
     390                sc_ipc_call_async_slow(sc_args, sc_rc);
    390391                break;
    391392        case SYS_IPC_WAIT:
     
    403404}
    404405
    405 static errno_t trace_loop(void *thread_hash_arg)
    406 {
    407         errno_t rc;
     406static int trace_loop(void *thread_hash_arg)
     407{
     408        int rc;
    408409        unsigned ev_type;
    409410        uintptr_t thread_hash;
     
    445446                }
    446447
    447                 if (rc == EOK) {
     448                if (rc >= 0) {
    448449                        switch (ev_type) {
    449450                        case UDEBUG_EVENT_SYSCALL_B:
     
    498499{
    499500        loader_t *ldr;
    500         errno_t rc;
     501        int rc;
    501502
    502503        /* Spawn a program loader */
     
    566567}
    567568
    568 static errno_t cev_fibril(void *arg)
     569static int cev_fibril(void *arg)
    569570{
    570571        cons_event_t event;
     
    581582               
    582583                if (!console_get_event(console, &event))
    583                         return EINVAL;
     584                        return -1;
    584585               
    585586                if (event.type == CEV_KEY) {
     
    598599        bool done;
    599600        int i;
    600         errno_t rc;
     601        int rc;
    601602
    602603        ipcp_init();
    603604
    604605        rc = get_thread_list();
    605         if (rc != EOK) {
    606                 printf("Failed to get thread list (%s)\n", str_error(rc));
     606        if (rc < 0) {
     607                printf("Failed to get thread list (error %d)\n", rc);
    607608                return;
    608609        }
     
    643644                        rc = udebug_stop(sess, thash);
    644645                        if (rc != EOK)
    645                                 printf("Error: stop -> %s\n", str_error_name(rc));
     646                                printf("Error: stop -> %d\n", rc);
    646647                        break;
    647648                case KC_R:
     
    844845int main(int argc, char *argv[])
    845846{
    846         errno_t rc;
     847        int rc;
    847848        task_exit_t texit;
    848849        int retval;
     
    859860
    860861        rc = connect_task(task_id);
    861         if (rc != EOK) {
     862        if (rc < 0) {
    862863                printf("Failed connecting to task %" PRIu64 ".\n", task_id);
    863864                return 1;
Note: See TracChangeset for help on using the changeset viewer.