Changeset 84876aa4 in mainline for uspace/app


Ignore:
Timestamp:
2019-11-15T13:46:34Z (6 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
ecb7828
Parents:
b093a62 (diff), d548fc0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge master into gfx

Mainly to get XCW fixes

Location:
uspace/app
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/bdsh/cmds/modules/ls/ls.c

    rb093a62 r84876aa4  
    4242#include <vfs/vfs.h>
    4343#include <str.h>
    44 #include <cap.h>
     44#include <capa.h>
    4545
    4646#include "ls.h"
    … …  
    106106                }
    107107
    108                 cap_spec_t cap;
    109                 cap_from_blocks(de->s.size, 1, &cap);
    110                 cap_simplify(&cap);
     108                capa_spec_t capa;
     109                capa_from_blocks(de->s.size, 1, &capa);
     110                capa_simplify(&capa);
    111111
    112112                char *rptr;
    113                 errno_t rc = cap_format(&cap, &rptr);
     113                errno_t rc = capa_format(&capa, &rptr);
    114114                if (rc != EOK) {
    115115                        return rc;

  • uspace/app/df/df.c

    rb093a62 r84876aa4  
    3535 */
    3636
    37 #include <cap.h>
     37#include <capa.h>
    3838#include <stdbool.h>
    3939#include <stdio.h>
    … …  
    124124static errno_t size_to_human_readable(uint64_t nblocks, size_t block_size, char **rptr)
    125125{
    126         cap_spec_t cap;
    127 
    128         cap_from_blocks(nblocks, block_size, &cap);
    129         cap_simplify(&cap);
    130         return cap_format(&cap, rptr);
     126        capa_spec_t capa;
     127
     128        capa_from_blocks(nblocks, block_size, &capa);
     129        capa_simplify(&capa);
     130        return capa_format(&capa, rptr);
    131131}
    132132

  • uspace/app/fdisk/fdisk.c

    rb093a62 r84876aa4  
    3434 */
    3535
    36 #include <cap.h>
     36#include <capa.h>
    3737#include <errno.h>
    3838#include <fdisk.h>
    … …  
    136136        nchoice_t *choice = NULL;
    137137        char *svcname = NULL;
    138         cap_spec_t cap;
     138        capa_spec_t capa;
    139139        fdisk_dev_info_t *sdev;
    140         char *scap = NULL;
     140        char *scapa = NULL;
    141141        char *dtext = NULL;
    142142        service_id_t svcid;
    … …  
    177177                }
    178178
    179                 rc = fdisk_dev_info_capacity(info, &cap);
     179                rc = fdisk_dev_info_capacity(info, &capa);
    180180                if (rc != EOK) {
    181181                        printf("Error getting device capacity "
    … …  
    185185                }
    186186
    187                 cap_simplify(&cap);
    188 
    189                 rc = cap_format(&cap, &scap);
     187                capa_simplify(&capa);
     188
     189                rc = capa_format(&capa, &scapa);
    190190                if (rc != EOK) {
    191191                        assert(rc == ENOMEM);
    … …  
    194194                }
    195195
    196                 int ret = asprintf(&dtext, "%s (%s)", svcname, scap);
     196                int ret = asprintf(&dtext, "%s (%s)", svcname, scapa);
    197197                if (ret < 0) {
    198198                        rc = ENOMEM;
    … …  
    203203                free(svcname);
    204204                svcname = NULL;
    205                 free(scap);
    206                 scap = NULL;
     205                free(scapa);
     206                scapa = NULL;
    207207
    208208                rc = nchoice_add(choice, dtext, info, 0);
    … …  
    261261        free(dtext);
    262262        free(svcname);
    263         free(scap);
     263        free(scapa);
    264264        return rc;
    265265}
    … …  
    432432        errno_t rc;
    433433        fdisk_part_spec_t pspec;
    434         cap_spec_t cap;
    435         cap_spec_t mcap;
     434        capa_spec_t capa;
     435        capa_spec_t mcapa;
    436436        vol_label_supp_t vlsupp;
    437437        vol_fstype_t fstype = 0;
    438438        tinput_t *tinput = NULL;
    439439        fdisk_spc_t spc;
    440         char *scap;
    441         char *smcap = NULL;
     440        char *scapa;
     441        char *smcapa = NULL;
    442442        char *label = NULL;
    443443        char *mountp = NULL;
    … …  
    448448                spc = spc_pri;
    449449
    450         rc = fdisk_part_get_max_avail(dev, spc, &mcap);
     450        rc = fdisk_part_get_max_avail(dev, spc, &mcapa);
    451451        if (rc != EOK) {
    452452                rc = EIO;
    … …  
    454454        }
    455455
    456         cap_simplify(&mcap);
    457 
    458         rc = cap_format(&mcap, &smcap);
     456        capa_simplify(&mcapa);
     457
     458        rc = capa_format(&mcapa, &smcapa);
    459459        if (rc != EOK) {
    460460                rc = ENOMEM;
    … …  
    474474        while (true) {
    475475                printf("Enter capacity of new partition.\n");
    476                 rc = tinput_read_i(tinput, smcap, &scap);
     476                rc = tinput_read_i(tinput, smcapa, &scapa);
    477477                if (rc != EOK)
    478478                        goto error;
    479479
    480                 rc = cap_parse(scap, &cap);
     480                rc = capa_parse(scapa, &capa);
    481481                if (rc == EOK)
    482482                        break;
    … …  
    485485        tinput_destroy(tinput);
    486486        tinput = NULL;
    487         free(smcap);
    488         smcap = NULL;
     487        free(smcapa);
     488        smcapa = NULL;
    489489
    490490        if (pkind != lpk_extended) {
    … …  
    545545
    546546        fdisk_pspec_init(&pspec);
    547         pspec.capacity = cap;
     547        pspec.capacity = capa;
    548548        pspec.pkind = pkind;
    549549        pspec.fstype = fstype;
    … …  
    561561        return EOK;
    562562error:
    563         free(smcap);
     563        free(smcapa);
    564564        free(label);
    565565        free(mountp);
    … …  
    581581        fdisk_part_t *part;
    582582        fdisk_part_info_t pinfo;
    583         char *scap = NULL;
     583        char *scapa = NULL;
    584584        char *spkind = NULL;
    585585        char *sfstype = NULL;
    … …  
    596596                }
    597597
    598                 cap_simplify(&pinfo.capacity);
    599 
    600                 rc = cap_format(&pinfo.capacity, &scap);
     598                capa_simplify(&pinfo.capacity);
     599
     600                rc = capa_format(&pinfo.capacity, &scapa);
    601601                if (rc != EOK) {
    602602                        printf("Out of memory.\n");
    … …  
    623623
    624624                        int ret = asprintf(&sdesc, "%s %s, %s, %s", label,
    625                             scap, spkind, sfstype);
     625                            scapa, spkind, sfstype);
    626626                        if (ret < 0) {
    627627                                rc = ENOMEM;
    … …  
    630630
    631631                } else {
    632                         int ret = asprintf(&sdesc, "%s, %s", scap, spkind);
     632                        int ret = asprintf(&sdesc, "%s, %s", scapa, spkind);
    633633                        if (ret < 0) {
    634634                                rc = ENOMEM;
    … …  
    644644                }
    645645
    646                 free(scap);
    647                 scap = NULL;
     646                free(scapa);
     647                scapa = NULL;
    648648                free(spkind);
    649649                spkind = NULL;
    … …  
    658658        return EOK;
    659659error:
    660         free(scap);
     660        free(scapa);
    661661        free(spkind);
    662662        free(sfstype);
    … …  
    907907        fdisk_part_t *part;
    908908        fdisk_part_info_t pinfo;
    909         cap_spec_t cap;
    910         cap_spec_t mcap;
     909        capa_spec_t capa;
     910        capa_spec_t mcapa;
    911911        fdisk_dev_flags_t dflags;
    912912        char *sltype = NULL;
    913         char *sdcap = NULL;
    914         char *scap = NULL;
    915         char *smcap = NULL;
     913        char *sdcapa = NULL;
     914        char *scapa = NULL;
     915        char *smcapa = NULL;
    916916        char *sfstype = NULL;
    917917        char *svcname = NULL;
    … …  
    936936        }
    937937
    938         rc = fdisk_dev_capacity(dev, &cap);
     938        rc = fdisk_dev_capacity(dev, &capa);
    939939        if (rc != EOK) {
    940940                printf("Error getting device capacity.\n");
    … …  
    942942        }
    943943
    944         cap_simplify(&cap);
    945 
    946         rc = cap_format(&cap, &sdcap);
     944        capa_simplify(&capa);
     945
     946        rc = capa_format(&capa, &sdcapa);
    947947        if (rc != EOK) {
    948948                printf("Out of memory.\n");
    … …  
    958958        fdisk_dev_get_flags(dev, &dflags);
    959959
    960         printf("Device: %s (%s)\n", svcname, sdcap);
    961         free(sdcap);
    962         sdcap = NULL;
     960        printf("Device: %s (%s)\n", svcname, sdcapa);
     961        free(sdcapa);
     962        sdcapa = NULL;
    963963
    964964        rc = fdisk_label_get_info(dev, &linfo);
    … …  
    996996                }
    997997
    998                 cap_simplify(&pinfo.capacity);
    999 
    1000                 rc = cap_format(&pinfo.capacity, &scap);
     998                capa_simplify(&pinfo.capacity);
     999
     1000                rc = capa_format(&pinfo.capacity, &scapa);
    10011001                if (rc != EOK) {
    10021002                        printf("Out of memory.\n");
    … …  
    10161016
    10171017                if (linfo.ltype == lt_none)
    1018                         printf("Entire disk: %s %s", label, scap);
     1018                        printf("Entire disk: %s %s", label, scapa);
    10191019                else
    1020                         printf("Partition %d: %s %s", npart, label, scap);
     1020                        printf("Partition %d: %s %s", npart, label, scapa);
    10211021
    10221022                if ((linfo.flags & lf_ext_supp) != 0) {
    … …  
    10371037                printf("\n");
    10381038
    1039                 free(scap);
    1040                 scap = NULL;
     1039                free(scapa);
     1040                scapa = NULL;
    10411041                free(sfstype);
    10421042                sfstype = NULL;
    … …  
    10471047        /* Display available space */
    10481048        if ((linfo.flags & lf_can_create_pri) != 0) {
    1049                 rc = fdisk_part_get_max_avail(dev, spc_pri, &mcap);
     1049                rc = fdisk_part_get_max_avail(dev, spc_pri, &mcapa);
    10501050                if (rc != EOK) {
    10511051                        rc = EIO;
    … …  
    10531053                }
    10541054
    1055                 cap_simplify(&mcap);
    1056 
    1057                 rc = cap_format(&mcap, &smcap);
     1055                capa_simplify(&mcapa);
     1056
     1057                rc = capa_format(&mcapa, &smcapa);
    10581058                if (rc != EOK) {
    10591059                        rc = ENOMEM;
    … …  
    10621062
    10631063                if ((linfo.flags & lf_ext_supp) != 0)
    1064                         printf("Maximum free primary block: %s\n", smcap);
     1064                        printf("Maximum free primary block: %s\n", smcapa);
    10651065                else
    1066                         printf("Maximum free block: %s\n", smcap);
    1067 
    1068                 free(smcap);
    1069                 smcap = NULL;
    1070 
    1071                 rc = fdisk_part_get_tot_avail(dev, spc_pri, &mcap);
     1066                        printf("Maximum free block: %s\n", smcapa);
     1067
     1068                free(smcapa);
     1069                smcapa = NULL;
     1070
     1071                rc = fdisk_part_get_tot_avail(dev, spc_pri, &mcapa);
    10721072                if (rc != EOK) {
    10731073                        rc = EIO;
    … …  
    10751075                }
    10761076
    1077                 cap_simplify(&mcap);
    1078 
    1079                 rc = cap_format(&mcap, &smcap);
     1077                capa_simplify(&mcapa);
     1078
     1079                rc = capa_format(&mcapa, &smcapa);
    10801080                if (rc != EOK) {
    10811081                        rc = ENOMEM;
    … …  
    10841084
    10851085                if ((linfo.flags & lf_ext_supp) != 0)
    1086                         printf("Total free primary space: %s\n", smcap);
     1086                        printf("Total free primary space: %s\n", smcapa);
    10871087                else
    1088                         printf("Total free space: %s\n", smcap);
    1089 
    1090                 free(smcap);
    1091                 smcap = NULL;
     1088                        printf("Total free space: %s\n", smcapa);
     1089
     1090                free(smcapa);
     1091                smcapa = NULL;
    10921092        }
    10931093
    10941094        /* Display available space */
    10951095        if ((linfo.flags & lf_can_create_log) != 0) {
    1096                 rc = fdisk_part_get_max_avail(dev, spc_log, &mcap);
     1096                rc = fdisk_part_get_max_avail(dev, spc_log, &mcapa);
    10971097                if (rc != EOK) {
    10981098                        rc = EIO;
    … …  
    11001100                }
    11011101
    1102                 cap_simplify(&mcap);
    1103 
    1104                 rc = cap_format(&mcap, &smcap);
     1102                capa_simplify(&mcapa);
     1103
     1104                rc = capa_format(&mcapa, &smcapa);
    11051105                if (rc != EOK) {
    11061106                        rc = ENOMEM;
    … …  
    11081108                }
    11091109
    1110                 printf("Maximum free logical block: %s\n", smcap);
    1111                 free(smcap);
    1112                 smcap = NULL;
    1113 
    1114                 rc = fdisk_part_get_tot_avail(dev, spc_log, &mcap);
     1110                printf("Maximum free logical block: %s\n", smcapa);
     1111                free(smcapa);
     1112                smcapa = NULL;
     1113
     1114                rc = fdisk_part_get_tot_avail(dev, spc_log, &mcapa);
    11151115                if (rc != EOK) {
    11161116                        rc = EIO;
    … …  
    11181118                }
    11191119
    1120                 cap_simplify(&mcap);
    1121 
    1122                 rc = cap_format(&mcap, &smcap);
     1120                capa_simplify(&mcapa);
     1121
     1122                rc = capa_format(&mcapa, &smcapa);
    11231123                if (rc != EOK) {
    11241124                        rc = ENOMEM;
    … …  
    11261126                }
    11271127
    1128                 printf("Total free logical space: %s\n", smcap);
    1129                 free(smcap);
    1130                 smcap = NULL;
     1128                printf("Total free logical space: %s\n", smcapa);
     1129                free(smcapa);
     1130                smcapa = NULL;
    11311131        }
    11321132
    … …  
    12791279        return EOK;
    12801280error:
    1281         free(sdcap);
    1282         free(scap);
    1283         free(smcap);
     1281        free(sdcapa);
     1282        free(scapa);
     1283        free(smcapa);
    12841284        free(sfstype);
    12851285        free(svcname);

  • uspace/app/sysinst/sysinst.c

    rb093a62 r84876aa4  
    3838#include <block.h>
    3939#include <byteorder.h>
    40 #include <cap.h>
     40#include <capa.h>
    4141#include <errno.h>
    4242#include <fdisk.h>
    … …  
    9898        fdisk_part_spec_t pspec;
    9999        fdisk_part_info_t pinfo;
    100         cap_spec_t cap;
     100        capa_spec_t capa;
    101101        service_id_t sid;
    102102        errno_t rc;
    … …  
    137137        printf("sysinst_label_dev(): create partition\n");
    138138
    139         rc = fdisk_part_get_max_avail(fdev, spc_pri, &cap);
     139        rc = fdisk_part_get_max_avail(fdev, spc_pri, &capa);
    140140        if (rc != EOK) {
    141141                printf("Error getting available capacity: %s.\n", str_error(rc));
    … …  
    144144
    145145        fdisk_pspec_init(&pspec);
    146         pspec.capacity = cap;
     146        pspec.capacity = capa;
    147147        pspec.pkind = lpk_primary;
    148148        pspec.fstype = fs_ext4; /* Cannot be changed without modifying core.img */

  • uspace/app/trace/syscalls.c

    rb093a62 r84876aa4  
    3838
    3939const sc_desc_t syscall_desc[] = {
     40        /* System management syscalls. */
    4041        [SYS_KIO] = { "kio", 3, V_INT_ERRNO },
    4142
     43        /* Thread and task related syscalls. */
    4244        [SYS_THREAD_CREATE] = { "thread_create", 3, V_ERRNO },
    4345        [SYS_THREAD_EXIT] = { "thread_exit", 1, V_ERRNO },
    4446        [SYS_THREAD_GET_ID] = { "thread_get_id", 1, V_ERRNO },
     47        [SYS_THREAD_USLEEP] = { "thread_usleep", 1, V_ERRNO },
     48        [SYS_THREAD_UDELAY] = { "thread_udelay", 1, V_ERRNO },
    4549
    4650        [SYS_TASK_GET_ID] = { "task_get_id", 1, V_ERRNO },
    4751        [SYS_TASK_SET_NAME] = { "task_set_name", 2, V_ERRNO },
     52        [SYS_TASK_KILL] = { "task_kill", 1, V_ERRNO },
     53        [SYS_TASK_EXIT] = { "task_exit", 1, V_ERRNO },
     54        [SYS_PROGRAM_SPAWN_LOADER] = { "program_spawn_loader", 2, V_ERRNO },
    4855
     56        /* Synchronization related syscalls. */
     57        [SYS_WAITQ_CREATE] = { "waitq_create", 1, V_ERRNO },
     58        [SYS_WAITQ_SLEEP] = { "waitq_sleep", 3, V_ERRNO },
     59        [SYS_WAITQ_WAKEUP] = { "waitq_wakeup", 1, V_ERRNO },
     60        [SYS_WAITQ_DESTROY] = { "waitq_destroy", 1, V_ERRNO },
     61        [SYS_SMC_COHERENCE] = { "smc_coherence", 2, V_ERRNO },
     62
     63        /* Address space related syscalls. */
    4964        [SYS_AS_AREA_CREATE] = { "as_area_create", 5, V_ERRNO },
    5065        [SYS_AS_AREA_RESIZE] = { "as_area_resize", 3, V_ERRNO },
     66        [SYS_AS_AREA_CHANGE_FLAGS] = { "as_area_change_flags", 2, V_ERRNO },
     67        [SYS_AS_AREA_GET_INFO] = { "as_area_get_info", 2, V_ERRNO },
    5168        [SYS_AS_AREA_DESTROY] = { "as_area_destroy", 1, V_ERRNO },
    5269
     70        /* Page mapping related syscalls. */
     71        [SYS_PAGE_FIND_MAPPING] = { "page_find_mapping", 2, V_ERRNO },
     72
     73        /* IPC related syscalls. */
    5374        [SYS_IPC_CALL_ASYNC_FAST] = { "ipc_call_async_fast", 6, V_HASH },
    5475        [SYS_IPC_CALL_ASYNC_SLOW] = { "ipc_call_async_slow", 3, V_HASH },
    55 
    5676        [SYS_IPC_ANSWER_FAST] = { "ipc_answer_fast", 6, V_ERRNO },
    5777        [SYS_IPC_ANSWER_SLOW] = { "ipc_answer_slow", 2, V_ERRNO },
    … …  
    6181        [SYS_IPC_POKE] = { "ipc_poke", 0, V_ERRNO },
    6282        [SYS_IPC_HANGUP] = { "ipc_hangup", 1, V_ERRNO },
     83        [SYS_IPC_CONNECT_KBOX] = { "ipc_connect_kbox", 2, V_ERRNO },
    6384
     85        /* Event notification syscalls. */
    6486        [SYS_IPC_EVENT_SUBSCRIBE] = { "ipc_event_subscribe", 2, V_ERRNO },
    6587        [SYS_IPC_EVENT_UNSUBSCRIBE] = { "ipc_event_unsubscribe", 1, V_ERRNO },
    6688        [SYS_IPC_EVENT_UNMASK] = { "ipc_event_unmask", 1, V_ERRNO },
    6789
     90        /* Permission related syscalls. */
    6891        [SYS_PERM_GRANT] = { "perm_grant", 2, V_ERRNO },
    6992        [SYS_PERM_REVOKE] = { "perm_revoke", 2, V_ERRNO },
     93
     94        /* DDI related syscalls. */
    7095        [SYS_PHYSMEM_MAP] = { "physmem_map", 4, V_ERRNO },
     96        [SYS_PHYSMEM_UNMAP] = { "physmem_unmap", 1, V_ERRNO },
     97        [SYS_DMAMEM_MAP] = { "dmamem_map", 6, V_ERRNO },
     98        [SYS_DMAMEM_UNMAP] = { "dmamem_unmap", 3, V_ERRNO },
    7199        [SYS_IOSPACE_ENABLE] = { "iospace_enable", 1, V_ERRNO },
     100        [SYS_IOSPACE_DISABLE] = { "iospace_disable", 1, V_ERRNO },
    72101
    73102        [SYS_IPC_IRQ_SUBSCRIBE] = { "ipc_irq_subscribe", 4, V_ERRNO },
    74103        [SYS_IPC_IRQ_UNSUBSCRIBE] = { "ipc_irq_unsubscribe", 2, V_ERRNO },
    75104
     105        /* Sysinfo syscalls. */
     106        [SYS_SYSINFO_GET_KEYS_SIZE] = { "sysinfo_get_keys_size", 3, V_ERRNO },
     107        [SYS_SYSINFO_GET_KEYS] = { "sysinfo_get_keys", 5, V_ERRNO },
    76108        [SYS_SYSINFO_GET_VAL_TYPE] = { "sysinfo_get_val_type", 2, V_INTEGER },
    77109        [SYS_SYSINFO_GET_VALUE] = { "sysinfo_get_value", 3, V_ERRNO },
    … …  
    79111        [SYS_SYSINFO_GET_DATA] = { "sysinfo_get_data", 5, V_ERRNO },
    80112
     113        /* Kernel console syscalls. */
    81114        [SYS_DEBUG_CONSOLE] = { "debug_console", 0, V_ERRNO },
    82         [SYS_IPC_CONNECT_KBOX] = { "ipc_connect_kbox", 1, V_ERRNO }
     115
     116        [SYS_KLOG] = { "klog", 5, V_ERRNO }
    83117};
    84118

  • uspace/app/trace/trace.c

    rb093a62 r84876aa4  
    4747#include <mem.h>
    4848#include <str.h>
    49 #include <loader/loader.h>
    5049#include <io/console.h>
    5150#include <io/keycode.h>
    … …  
    8685void thread_trace_start(uintptr_t thread_hash);
    8786
     87static char *cmd_path;
     88static char **cmd_args;
     89
    8890static task_id_t task_id;
    89 static loader_t *task_ldr;
     91static task_wait_t task_w;
    9092static bool task_wait_for;
    9193
    … …  
    9395display_mask_t display_mask;
    9496
    95 static errno_t program_run_fibril(void *arg);
    9697static errno_t cev_fibril(void *arg);
    97 
    98 static void program_run(void)
    99 {
    100         fid_t fid;
    101 
    102         fid = fibril_create(program_run_fibril, NULL);
    103         if (fid == 0) {
    104                 printf("Error creating fibril\n");
    105                 exit(1);
    106         }
    107 
    108         fibril_add_ready(fid);
    109 }
    11098
    11199static void cev_fibril_start(void)
    … …  
    122110}
    123111
    124 static errno_t program_run_fibril(void *arg)
    125 {
    126         errno_t rc;
    127 
    128         /*
    129          * This must be done in background as it will block until
    130          * we let the task reply to this call.
    131          */
    132         rc = loader_run(task_ldr);
     112static errno_t program_run(void)
     113{
     114        errno_t rc;
     115
     116        rc = task_spawnv_debug(&task_id, &task_w, cmd_path,
     117            (const char *const *)cmd_args, &sess);
     118
     119        if (rc == ENOTSUP) {
     120                printf("You do not have userspace debugging support "
     121                    "compiled in the kernel.\n");
     122                printf("Compile kernel with 'Support for userspace debuggers' "
     123                    "(CONFIG_UDEBUG) enabled.\n");
     124        }
     125
    133126        if (rc != EOK) {
    134                 printf("Error running program\n");
    135                 exit(1);
    136         }
    137 
    138         task_ldr = NULL;
    139 
    140         printf("program_run_fibril exiting\n");
    141         return 0;
     127                printf("Error running program (%s)\n", str_error_name(rc));
     128                return rc;
     129        }
     130
     131        return EOK;
    142132}
    143133
    144134static errno_t connect_task(task_id_t task_id)
    145135{
    146         async_sess_t *ksess = async_connect_kbox(task_id);
    147 
    148         if (!ksess) {
    149                 if (errno == ENOTSUP) {
    150                         printf("You do not have userspace debugging support "
    151                             "compiled in the kernel.\n");
    152                         printf("Compile kernel with 'Support for userspace debuggers' "
    153                             "(CONFIG_UDEBUG) enabled.\n");
    154                         return errno;
    155                 }
    156 
    157                 printf("Error connecting\n");
    158                 printf("ipc_connect_task(%" PRIu64 ") -> %s ", task_id, str_error_name(errno));
    159                 return errno;
    160         }
    161 
    162         errno_t rc = udebug_begin(ksess);
    163         if (rc != EOK) {
    164                 printf("udebug_begin() -> %s\n", str_error_name(rc));
    165                 return rc;
    166         }
    167 
    168         rc = udebug_set_evmask(ksess, UDEBUG_EM_ALL);
     136        errno_t rc;
     137        bool debug_started = false;
     138        bool wait_set_up = false;
     139
     140        if (sess == NULL) {
     141                sess = async_connect_kbox(task_id);
     142                if (sess == NULL) {
     143                        printf("Error connecting to task %" PRIu64 ".\n",
     144                            task_id);
     145                        rc = EIO;
     146                        goto error;
     147                }
     148
     149                rc = udebug_begin(sess);
     150                if (rc != EOK) {
     151                        printf("Error starting debug session.\n");
     152                        goto error;
     153                }
     154
     155                debug_started = true;
     156
     157                rc = task_setup_wait(task_id, &task_w);
     158                if (rc != EOK) {
     159                        printf("Error setting up wait for task termination.\n");
     160                        goto error;
     161                }
     162
     163                wait_set_up = true;
     164        }
     165
     166        rc = udebug_set_evmask(sess, UDEBUG_EM_ALL);
    169167        if (rc != EOK) {
    170168                printf("udebug_set_evmask(0x%x) -> %s\n ", UDEBUG_EM_ALL, str_error_name(rc));
    … …  
    172170        }
    173171
    174         sess = ksess;
    175         return 0;
     172        return EOK;
     173error:
     174        if (wait_set_up)
     175                task_cancel_wait(&task_w);
     176        if (debug_started)
     177                udebug_end(sess);
     178        if (sess != NULL)
     179                async_hangup(sess);
     180        return rc;
    176181}
    177182
    … …  
    198203        printf("\ntotal of %zu threads\n", tb_needed / sizeof(uintptr_t));
    199204
    200         return 0;
     205        return EOK;
    201206}
    202207
    … …  
    488493
    489494        printf("Finished tracing thread [%d].\n", thread_id);
    490         return 0;
     495        return EOK;
    491496}
    492497
    … …  
    502507        }
    503508        fibril_add_ready(fid);
    504 }
    505 
    506 static loader_t *preload_task(const char *path, char **argv,
    507     task_id_t *task_id)
    508 {
    509         loader_t *ldr;
    510         errno_t rc;
    511 
    512         /* Spawn a program loader */
    513         ldr = loader_connect();
    514         if (ldr == NULL)
    515                 return NULL;
    516 
    517         /* Get task ID. */
    518         rc = loader_get_task_id(ldr, task_id);
    519         if (rc != EOK)
    520                 goto error;
    521 
    522         /* Send program. */
    523         rc = loader_set_program_path(ldr, path);
    524         if (rc != EOK)
    525                 goto error;
    526 
    527         /* Send arguments */
    528         rc = loader_set_args(ldr, (const char **) argv);
    529         if (rc != EOK)
    530                 goto error;
    531 
    532         /* Send default files */
    533         int fd_root;
    534         int fd_stdin;
    535         int fd_stdout;
    536         int fd_stderr;
    537 
    538         fd_root = vfs_root();
    539         if (fd_root >= 0) {
    540                 rc = loader_add_inbox(ldr, "root", fd_root);
    541                 vfs_put(fd_root);
    542                 if (rc != EOK)
    543                         goto error;
    544         }
    545 
    546         if ((stdin != NULL) && (vfs_fhandle(stdin, &fd_stdin) == EOK)) {
    547                 rc = loader_add_inbox(ldr, "stdin", fd_stdin);
    548                 if (rc != EOK)
    549                         goto error;
    550         }
    551 
    552         if ((stdout != NULL) && (vfs_fhandle(stdout, &fd_stdout) == EOK)) {
    553                 rc = loader_add_inbox(ldr, "stdout", fd_stdout);
    554                 if (rc != EOK)
    555                         goto error;
    556         }
    557 
    558         if ((stderr != NULL) && (vfs_fhandle(stderr, &fd_stderr) == EOK)) {
    559                 rc = loader_add_inbox(ldr, "stderr", fd_stderr);
    560                 if (rc != EOK)
    561                         goto error;
    562         }
    563 
    564         /* Load the program. */
    565         rc = loader_load_program(ldr);
    566         if (rc != EOK)
    567                 goto error;
    568 
    569         /* Success */
    570         return ldr;
    571 
    572         /* Error exit */
    573 error:
    574         loader_abort(ldr);
    575         return NULL;
    576509}
    577510
    … …  
    807740                                ++argv;
    808741                                task_id = strtol(*argv, &err_p, 10);
    809                                 task_ldr = NULL;
    810742                                task_wait_for = false;
    811743                                if (*err_p) {
    … …  
    848780                printf("'%s'\n", *cp++);
    849781
    850         task_ldr = preload_task(*argv, argv, &task_id);
     782        cmd_path = *argv;
     783        cmd_args = argv;
    851784        task_wait_for = true;
    852785
    … …  
    869802
    870803        main_init();
     804
     805        if (cmd_path != NULL)
     806                program_run();
    871807
    872808        rc = connect_task(task_id);
    … …  
    878814        printf("Connected to task %" PRIu64 ".\n", task_id);
    879815
    880         if (task_ldr != NULL)
    881                 program_run();
    882 
    883816        cev_fibril_start();
    884817        trace_task(task_id);
    … …  
    887820                printf("Waiting for task to exit.\n");
    888821
    889                 rc = task_wait_task_id(task_id, &texit, &retval);
     822                rc = task_wait(&task_w, &texit, &retval);
    890823                if (rc != EOK) {
    891824                        printf("Failed waiting for task.\n");
Note: See TracChangeset for help on using the changeset viewer.