Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/loader.c

    r79ae36dd r6e84dc3  
    3535#include <ipc/loader.h>
    3636#include <ipc/services.h>
    37 #include <ns.h>
     37#include <ipc/ns.h>
    3838#include <libc.h>
    3939#include <task.h>
     
    4444#include <vfs/vfs.h>
    4545#include <loader/loader.h>
    46 #include "private/loader.h"
    4746
    4847/** Connect to a new program loader.
     
    6463loader_t *loader_connect(void)
    6564{
     65        int phone_id = service_connect_blocking(SERVICE_LOAD, 0, 0);
     66        if (phone_id < 0)
     67                return NULL;
     68       
    6669        loader_t *ldr = malloc(sizeof(loader_t));
    6770        if (ldr == NULL)
    6871                return NULL;
    6972       
    70         async_sess_t *sess =
    71             service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOAD, 0, 0);
    72         if (sess == NULL) {
    73                 free(ldr);
    74                 return NULL;
    75         }
    76        
    77         ldr->sess = sess;
     73        ldr->phone_id = phone_id;
    7874        return ldr;
    7975}
     
    9288{
    9389        /* Get task ID. */
    94         async_exch_t *exch = async_exchange_begin(ldr->sess);
    95        
    96         ipc_call_t answer;
    97         aid_t req = async_send_0(exch, LOADER_GET_TASKID, &answer);
    98         sysarg_t rc = async_data_read_start(exch, task_id, sizeof(task_id_t));
    99        
    100         async_exchange_end(exch);
    101        
    102         if (rc != EOK) {
    103                 async_wait_for(req, NULL);
    104                 return (int) rc;
    105         }
    106        
    107         async_wait_for(req, &rc);
    108         return (int) rc;
     90        ipc_call_t answer;
     91        aid_t req = async_send_0(ldr->phone_id, LOADER_GET_TASKID, &answer);
     92        int rc = async_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t));
     93        if (rc != EOK) {
     94                async_wait_for(req, NULL);
     95                return rc;
     96        }
     97       
     98        sysarg_t retval;
     99        async_wait_for(req, &retval);
     100        return (int) retval;
    109101}
    110102
     
    120112int loader_set_cwd(loader_t *ldr)
    121113{
    122         char *cwd = (char *) malloc(MAX_PATH_LEN + 1);
     114        char *cwd;
     115        size_t len;
     116
     117        cwd = (char *) malloc(MAX_PATH_LEN + 1);
    123118        if (!cwd)
    124119                return ENOMEM;
    125        
    126120        if (!getcwd(cwd, MAX_PATH_LEN + 1))
    127                 str_cpy(cwd, MAX_PATH_LEN + 1, "/");
    128        
    129         size_t len = str_length(cwd);
    130        
    131         async_exch_t *exch = async_exchange_begin(ldr->sess);
    132        
    133         ipc_call_t answer;
    134         aid_t req = async_send_0(exch, LOADER_SET_CWD, &answer);
    135         sysarg_t rc = async_data_write_start(exch, cwd, len);
    136        
    137         async_exchange_end(exch);
     121                str_cpy(cwd, MAX_PATH_LEN + 1, "/");
     122        len = str_length(cwd);
     123       
     124        ipc_call_t answer;
     125        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_CWD, &answer);
     126        int rc = async_data_write_start(ldr->phone_id, cwd, len);
    138127        free(cwd);
    139        
    140         if (rc != EOK) {
    141                 async_wait_for(req, NULL);
    142                 return (int) rc;
    143         }
    144        
    145         async_wait_for(req, &rc);
    146         return (int) rc;
     128        if (rc != EOK) {
     129                async_wait_for(req, NULL);
     130                return rc;
     131        }
     132       
     133        sysarg_t retval;
     134        async_wait_for(req, &retval);
     135        return (int) retval;
    147136}
    148137
     
    164153        char *pa = absolutize(path, &pa_len);
    165154        if (!pa)
    166                 return ENOMEM;
     155                return 0;
    167156       
    168157        /* Send program pathname */
    169         async_exch_t *exch = async_exchange_begin(ldr->sess);
    170        
    171         ipc_call_t answer;
    172         aid_t req = async_send_0(exch, LOADER_SET_PATHNAME, &answer);
    173         sysarg_t rc = async_data_write_start(exch, (void *) pa, pa_len);
    174        
    175         async_exchange_end(exch);
     158        ipc_call_t answer;
     159        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_PATHNAME, &answer);
     160        int rc = async_data_write_start(ldr->phone_id, (void *) pa, pa_len);
     161        if (rc != EOK) {
     162                free(pa);
     163                async_wait_for(req, NULL);
     164                return rc;
     165        }
     166       
    176167        free(pa);
    177168       
    178         if (rc != EOK) {
    179                 async_wait_for(req, NULL);
    180                 return (int) rc;
    181         }
    182        
    183         async_wait_for(req, &rc);
    184         return (int) rc;
     169        sysarg_t retval;
     170        async_wait_for(req, &retval);
     171        return (int) retval;
    185172}
    186173
     
    225212       
    226213        /* Send serialized arguments to the loader */
    227         async_exch_t *exch = async_exchange_begin(ldr->sess);
    228        
    229         ipc_call_t answer;
    230         aid_t req = async_send_0(exch, LOADER_SET_ARGS, &answer);
    231         sysarg_t rc = async_data_write_start(exch, (void *) arg_buf,
    232             buffer_size);
    233        
    234         async_exchange_end(exch);
     214        ipc_call_t answer;
     215        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_ARGS, &answer);
     216        sysarg_t rc = async_data_write_start(ldr->phone_id, (void *) arg_buf, buffer_size);
     217        if (rc != EOK) {
     218                async_wait_for(req, NULL);
     219                return rc;
     220        }
     221       
     222        async_wait_for(req, &rc);
     223        if (rc != EOK)
     224                return rc;
     225       
     226        /* Free temporary buffer */
    235227        free(arg_buf);
    236228       
    237         if (rc != EOK) {
    238                 async_wait_for(req, NULL);
    239                 return (int) rc;
    240         }
    241        
    242         async_wait_for(req, &rc);
    243         return (int) rc;
     229        return EOK;
    244230}
    245231
     
    280266       
    281267        /* Send serialized files to the loader */
    282         async_exch_t *exch = async_exchange_begin(ldr->sess);
    283        
    284         ipc_call_t answer;
    285         aid_t req = async_send_0(exch, LOADER_SET_FILES, &answer);
    286         sysarg_t rc = async_data_write_start(exch, (void *) files_buf,
     268        ipc_call_t answer;
     269        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_FILES, &answer);
     270        sysarg_t rc = async_data_write_start(ldr->phone_id, (void *) files_buf,
    287271            count * sizeof(fdi_node_t));
    288        
    289         async_exchange_end(exch);
     272        if (rc != EOK) {
     273                async_wait_for(req, NULL);
     274                return rc;
     275        }
     276       
     277        async_wait_for(req, &rc);
     278        if (rc != EOK)
     279                return rc;
     280       
     281        /* Free temporary buffer */
    290282        free(files_buf);
    291283       
    292         if (rc != EOK) {
    293                 async_wait_for(req, NULL);
    294                 return (int) rc;
    295         }
    296        
    297         async_wait_for(req, &rc);
    298         return (int) rc;
     284        return EOK;
    299285}
    300286
     
    311297int loader_load_program(loader_t *ldr)
    312298{
    313         async_exch_t *exch = async_exchange_begin(ldr->sess);
    314         int rc = async_req_0_0(exch, LOADER_LOAD);
    315         async_exchange_end(exch);
    316        
    317         return rc;
     299        return (int) async_req_0_0(ldr->phone_id, LOADER_LOAD);
    318300}
    319301
     
    324306 * the task and its thread is stopped.
    325307 *
    326  * After using this function, no further operations can be performed
    327  * on the loader structure and it is deallocated.
     308 * After using this function, no further operations must be performed
     309 * on the loader structure. It should be de-allocated using free().
    328310 *
    329311 * @param ldr Loader connection structure.
     
    334316int loader_run(loader_t *ldr)
    335317{
    336         async_exch_t *exch = async_exchange_begin(ldr->sess);
    337         int rc = async_req_0_0(exch, LOADER_RUN);
    338         async_exchange_end(exch);
    339        
     318        int rc = async_req_0_0(ldr->phone_id, LOADER_RUN);
    340319        if (rc != EOK)
    341320                return rc;
    342321       
    343         async_hangup(ldr->sess);
    344         free(ldr);
    345        
     322        async_hangup(ldr->phone_id);
     323        ldr->phone_id = 0;
    346324        return EOK;
    347325}
     
    349327/** Cancel the loader session.
    350328 *
    351  * Tell the loader not to load any program and terminate.
    352  * After using this function, no further operations can be performed
    353  * on the loader structure and it is deallocated.
     329 * Tells the loader not to load any program and terminate.
     330 * After using this function, no further operations must be performed
     331 * on the loader structure. It should be de-allocated using free().
    354332 *
    355333 * @param ldr Loader connection structure.
     
    360338void loader_abort(loader_t *ldr)
    361339{
    362         async_hangup(ldr->sess);
    363         free(ldr);
     340        async_hangup(ldr->phone_id);
     341        ldr->phone_id = 0;
    364342}
    365343
Note: See TracChangeset for help on using the changeset viewer.