Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/loader/main.c

    ra35b458 r77f0a1d  
    9090static bool connected = false;
    9191
    92 static void ldr_get_taskid(ipc_callid_t rid, ipc_call_t *request)
    93 {
    94         ipc_callid_t callid;
     92static void ldr_get_taskid(cap_call_handle_t req_handle, ipc_call_t *request)
     93{
     94        cap_call_handle_t chandle;
    9595        task_id_t task_id;
    9696        size_t len;
    … …  
    9898        task_id = task_get_id();
    9999
    100         if (!async_data_read_receive(&callid, &len)) {
    101                 async_answer_0(callid, EINVAL);
    102                 async_answer_0(rid, EINVAL);
     100        if (!async_data_read_receive(&chandle, &len)) {
     101                async_answer_0(chandle, EINVAL);
     102                async_answer_0(req_handle, EINVAL);
    103103                return;
    104104        }
    … …  
    107107                len = sizeof(task_id);
    108108
    109         async_data_read_finalize(callid, &task_id, len);
    110         async_answer_0(rid, EOK);
     109        async_data_read_finalize(chandle, &task_id, len);
     110        async_answer_0(req_handle, EOK);
    111111}
    112112
    113113/** Receive a call setting the current working directory.
    114114 *
    115  * @param rid
    116  * @param request
    117  */
    118 static void ldr_set_cwd(ipc_callid_t rid, ipc_call_t *request)
     115 * @param req_handle
     116 * @param request
     117 */
     118static void ldr_set_cwd(cap_call_handle_t req_handle, ipc_call_t *request)
    119119{
    120120        char *buf;
    … …  
    128128        }
    129129
    130         async_answer_0(rid, rc);
     130        async_answer_0(req_handle, rc);
    131131}
    132132
    133133/** Receive a call setting the program to execute.
    134134 *
    135  * @param rid
    136  * @param request
    137  */
    138 static void ldr_set_program(ipc_callid_t rid, ipc_call_t *request)
    139 {
    140         ipc_callid_t writeid;
     135 * @param req_handle
     136 * @param request
     137 */
     138static void ldr_set_program(cap_call_handle_t req_handle, ipc_call_t *request)
     139{
     140        cap_call_handle_t write_chandle;
    141141        size_t namesize;
    142         if (!async_data_write_receive(&writeid, &namesize)) {
    143                 async_answer_0(rid, EINVAL);
     142        if (!async_data_write_receive(&write_chandle, &namesize)) {
     143                async_answer_0(req_handle, EINVAL);
    144144                return;
    145145        }
    146146
    147147        char* name = malloc(namesize);
    148         errno_t rc = async_data_write_finalize(writeid, name, namesize);
     148        errno_t rc = async_data_write_finalize(write_chandle, name, namesize);
    149149        if (rc != EOK) {
    150                 async_answer_0(rid, EINVAL);
     150                async_answer_0(req_handle, EINVAL);
    151151                return;
    152152        }
    … …  
    155155        rc = vfs_receive_handle(true, &file);
    156156        if (rc != EOK) {
    157                 async_answer_0(rid, EINVAL);
     157                async_answer_0(req_handle, EINVAL);
    158158                return;
    159159        }
    … …  
    161161        progname = name;
    162162        program_fd = file;
    163         async_answer_0(rid, EOK);
     163        async_answer_0(req_handle, EOK);
    164164}
    165165
    166166/** Receive a call setting arguments of the program to execute.
    167167 *
    168  * @param rid
    169  * @param request
    170  */
    171 static void ldr_set_args(ipc_callid_t rid, ipc_call_t *request)
     168 * @param req_handle
     169 * @param request
     170 */
     171static void ldr_set_args(cap_call_handle_t req_handle, ipc_call_t *request)
    172172{
    173173        char *buf;
    … …  
    194194                if (_argv == NULL) {
    195195                        free(buf);
    196                         async_answer_0(rid, ENOMEM);
     196                        async_answer_0(req_handle, ENOMEM);
    197197                        return;
    198198                }
    … …  
    226226        }
    227227
    228         async_answer_0(rid, rc);
     228        async_answer_0(req_handle, rc);
    229229}
    230230
    231231/** Receive a call setting inbox files of the program to execute.
    232232 *
    233  * @param rid
    234  * @param request
    235  */
    236 static void ldr_add_inbox(ipc_callid_t rid, ipc_call_t *request)
     233 * @param req_handle
     234 * @param request
     235 */
     236static void ldr_add_inbox(cap_call_handle_t req_handle, ipc_call_t *request)
    237237{
    238238        if (inbox_entries == INBOX_MAX_ENTRIES) {
    239                 async_answer_0(rid, ERANGE);
    240                 return;
    241         }
    242 
    243         ipc_callid_t writeid;
     239                async_answer_0(req_handle, ERANGE);
     240                return;
     241        }
     242
     243        cap_call_handle_t write_chandle;
    244244        size_t namesize;
    245         if (!async_data_write_receive(&writeid, &namesize)) {
    246                 async_answer_0(rid, EINVAL);
     245        if (!async_data_write_receive(&write_chandle, &namesize)) {
     246                async_answer_0(req_handle, EINVAL);
    247247                return;
    248248        }
    249249
    250250        char* name = malloc(namesize);
    251         errno_t rc = async_data_write_finalize(writeid, name, namesize);
     251        errno_t rc = async_data_write_finalize(write_chandle, name, namesize);
    252252        if (rc != EOK) {
    253                 async_answer_0(rid, EINVAL);
     253                async_answer_0(req_handle, EINVAL);
    254254                return;
    255255        }
    … …  
    258258        rc = vfs_receive_handle(true, &file);
    259259        if (rc != EOK) {
    260                 async_answer_0(rid, EINVAL);
     260                async_answer_0(req_handle, EINVAL);
    261261                return;
    262262        }
    … …  
    272272        inbox[inbox_entries].file = file;
    273273        inbox_entries++;
    274         async_answer_0(rid, EOK);
     274        async_answer_0(req_handle, EOK);
    275275}
    276276
    277277/** Load the previously selected program.
    278278 *
    279  * @param rid
     279 * @param req_handle
    280280 * @param request
    281281 * @return 0 on success, !0 on error.
    282282 */
    283 static int ldr_load(ipc_callid_t rid, ipc_call_t *request)
     283static int ldr_load(cap_call_handle_t req_handle, ipc_call_t *request)
    284284{
    285285        int rc = elf_load(program_fd, &prog_info);
    286286        if (rc != EE_OK) {
    287287                DPRINTF("Failed to load executable for '%s'.\n", progname);
    288                 async_answer_0(rid, EINVAL);
     288                async_answer_0(req_handle, EINVAL);
    289289                return 1;
    290290        }
    … …  
    300300        pcb.inbox_entries = inbox_entries;
    301301
    302         async_answer_0(rid, EOK);
     302        async_answer_0(req_handle, EOK);
    303303        return 0;
    304304}
    … …  
    306306/** Run the previously loaded program.
    307307 *
    308  * @param rid
     308 * @param req_handle
    309309 * @param request
    310310 * @return 0 on success, !0 on error.
    311311 */
    312 static __attribute__((noreturn)) void ldr_run(ipc_callid_t rid,
     312static __attribute__((noreturn)) void ldr_run(cap_call_handle_t req_handle,
    313313    ipc_call_t *request)
    314314{
    … …  
    320320        /* Run program */
    321321        DPRINTF("Reply OK\n");
    322         async_answer_0(rid, EOK);
     322        async_answer_0(req_handle, EOK);
    323323        DPRINTF("Jump to entry point at %p\n", pcb.entry);
    324324        entry_point_jmp(prog_info.finfo.entry, &pcb);
    … …  
    332332 * to execute the loaded program).
    333333 */
    334 static void ldr_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     334static void ldr_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
     335    void *arg)
    335336{
    336337        /* Already have a connection? */
    337338        if (connected) {
    338                 async_answer_0(iid, ELIMIT);
     339                async_answer_0(icall_handle, ELIMIT);
    339340                return;
    340341        }
    … …  
    343344
    344345        /* Accept the connection */
    345         async_answer_0(iid, EOK);
     346        async_answer_0(icall_handle, EOK);
    346347
    347348        /* Ignore parameters, the connection is already open */
    … …  
    351352                errno_t retval;
    352353                ipc_call_t call;
    353                 ipc_callid_t callid = async_get_call(&call);
     354                cap_call_handle_t chandle = async_get_call(&call);
    354355
    355356                if (!IPC_GET_IMETHOD(call))
    … …  
    358359                switch (IPC_GET_IMETHOD(call)) {
    359360                case LOADER_GET_TASKID:
    360                         ldr_get_taskid(callid, &call);
     361                        ldr_get_taskid(chandle, &call);
    361362                        continue;
    362363                case LOADER_SET_CWD:
    363                         ldr_set_cwd(callid, &call);
     364                        ldr_set_cwd(chandle, &call);
    364365                        continue;
    365366                case LOADER_SET_PROGRAM:
    366                         ldr_set_program(callid, &call);
     367                        ldr_set_program(chandle, &call);
    367368                        continue;
    368369                case LOADER_SET_ARGS:
    369                         ldr_set_args(callid, &call);
     370                        ldr_set_args(chandle, &call);
    370371                        continue;
    371372                case LOADER_ADD_INBOX:
    372                         ldr_add_inbox(callid, &call);
     373                        ldr_add_inbox(chandle, &call);
    373374                        continue;
    374375                case LOADER_LOAD:
    375                         ldr_load(callid, &call);
     376                        ldr_load(chandle, &call);
    376377                        continue;
    377378                case LOADER_RUN:
    378                         ldr_run(callid, &call);
     379                        ldr_run(chandle, &call);
    379380                        /* Not reached */
    380381                default:
    … …  
    383384                }
    384385
    385                 async_answer_0(callid, retval);
     386                async_answer_0(chandle, retval);
    386387        }
    387388}
Note: See TracChangeset for help on using the changeset viewer.