Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 95faa4d in mainline


Ignore:
Timestamp:
2018-06-07T17:00:31Z (3 years ago)
Author:
Jiří Zárevúcky <jiri.zarevucky@…>
Parents:
9c16c36
git-author:
Jiří Zárevúcky <jiri.zarevucky@…> (2018-06-07 16:59:42)
git-committer:
Jiří Zárevúcky <jiri.zarevucky@…> (2018-06-07 17:00:31)
Message:

Convert a bit of devman.

Location:
uspace/lib/c
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/async/client.c

    r9c16c36 r95faa4d  
    13491349    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    13501350{
     1351        assert(call);
    13511352        memset(call, 0, sizeof(*call));
     1353        list_initialize(&call->fragments);
     1354
     1355        if (!sess) {
     1356                call->rc = ENOENT;
     1357                return;
     1358        }
    13521359
    13531360        call->exch = async_exchange_begin(sess);
     
    15031510        data->finalizer = finalizer;
    15041511
    1505         if (!call->exch)
    1506                 call->rc = ENOENT;
    1507 
    15081512        if (call->rc)
    15091513                return;
     1514
     1515        if (!call->exch) {
     1516                call->rc = ENOENT;
     1517                return;
     1518        }
    15101519
    15111520        data->msgid = async_send_fast(call->exch, imethod,
     
    16061615}
    16071616
     1617void async_call_connect_to_me(async_call_t *call, async_call_data_t *data,
     1618        sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
     1619{
     1620        async_call_method(call, data, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3, 0);
     1621}
     1622
    16081623// TODO: connect me to, connect to me, vfs handle, etc.
    16091624
  • uspace/lib/c/generic/devman.c

    r9c16c36 r95faa4d  
    6969}
    7070
    71 /** Start an async exchange on the devman session (blocking).
    72  *
    73  * @param iface Device manager interface to choose
    74  *
    75  * @return New exchange.
    76  *
    77  */
    78 async_exch_t *devman_exchange_begin_blocking(iface_t iface)
     71static async_sess_t *devman_session_blocking(iface_t iface)
    7972{
    8073        switch (iface) {
     
    9790                    &devman_driver_sess);
    9891
    99                 return async_exchange_begin(devman_driver_block_sess);
     92                return devman_driver_block_sess;
    10093        case INTERFACE_DDF_CLIENT:
    10194                fibril_mutex_lock(&devman_client_block_mutex);
     
    116109                    &devman_client_sess);
    117110
    118                 return async_exchange_begin(devman_client_block_sess);
     111                return devman_client_block_sess;
    119112        default:
    120113                return NULL;
     
    122115}
    123116
    124 /** Start an async exchange on the devman session.
     117/** Start an async exchange on the devman session (blocking).
    125118 *
    126119 * @param iface Device manager interface to choose
     
    129122 *
    130123 */
    131 async_exch_t *devman_exchange_begin(iface_t iface)
     124async_exch_t *devman_exchange_begin_blocking(iface_t iface)
     125{
     126        async_sess_t *sess = devman_session_blocking(iface);
     127        if (!sess)
     128                return NULL;
     129        return async_exchange_begin(sess);
     130}
     131
     132static async_sess_t *devman_session(iface_t iface)
    132133{
    133134        switch (iface) {
     
    145146                        return NULL;
    146147
    147                 return async_exchange_begin(devman_driver_sess);
     148                return devman_driver_sess;
    148149        case INTERFACE_DDF_CLIENT:
    149150                fibril_mutex_lock(&devman_client_mutex);
     
    159160                        return NULL;
    160161
    161                 return async_exchange_begin(devman_client_sess);
     162                return devman_client_sess;
    162163        default:
    163164                return NULL;
     
    165166}
    166167
     168/** Start an async exchange on the devman session.
     169 *
     170 * @param iface Device manager interface to choose
     171 *
     172 * @return New exchange.
     173 *
     174 */
     175async_exch_t *devman_exchange_begin(iface_t iface)
     176{
     177        async_sess_t *sess = devman_session(iface);
     178        if (!sess)
     179                return NULL;
     180        return async_exchange_begin(sess);
     181}
     182
    167183/** Finish an async exchange on the devman session.
    168184 *
     
    178194errno_t devman_driver_register(const char *name)
    179195{
    180         async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    181 
    182         ipc_call_t answer;
    183         aid_t req = async_send_2(exch, DEVMAN_DRIVER_REGISTER, 0, 0, &answer);
    184         errno_t retval = async_data_write_start(exch, name, str_size(name));
    185 
    186         devman_exchange_end(exch);
    187 
    188         if (retval != EOK) {
    189                 async_forget(req);
    190                 return retval;
    191         }
    192 
    193         exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
    194         async_connect_to_me(exch, 0, 0, 0);
    195         devman_exchange_end(exch);
    196 
    197         async_wait_for(req, &retval);
    198         return retval;
     196        async_sess_t *sess = devman_session_blocking(INTERFACE_DDF_DRIVER);
     197
     198        async_call_t call;
     199        async_call_data_t write, connect;
     200
     201        async_call_begin(&call, sess, DEVMAN_DRIVER_REGISTER, 0, 0, 0, 0);
     202        async_call_write(&call, &write, name, str_size(name), NULL);
     203        async_call_connect_to_me(&call, &connect, 0, 0, 0);
     204
     205        return async_call_finish(&call);
    199206}
    200207
     
    217224{
    218225        unsigned long match_count = list_count(&match_ids->ids);
    219         async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    220 
    221         ipc_call_t answer;
    222         aid_t req = async_send_3(exch, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype,
    223             devh, match_count, &answer);
    224         errno_t retval = async_data_write_start(exch, name, str_size(name));
    225         if (retval != EOK) {
    226                 devman_exchange_end(exch);
    227                 async_forget(req);
    228                 return retval;
    229         }
     226
     227        async_sess_t *sess = devman_session_blocking(INTERFACE_DDF_DRIVER);
     228
     229        async_call_t call;
     230        async_call_data_t write1, method_n, write_n;
     231
     232        async_call_begin(&call, sess, DEVMAN_ADD_FUNCTION,
     233            (sysarg_t) ftype, devh, match_count, 0);
     234
     235        async_call_write(&call, &write1, name, str_size(name), NULL);
    230236
    231237        list_foreach(match_ids->ids, link, match_id_t, match_id) {
    232                 ipc_call_t answer2;
    233                 aid_t req2 = async_send_1(exch, DEVMAN_ADD_MATCH_ID,
    234                     match_id->score, &answer2);
    235                 retval = async_data_write_start(exch, match_id->id,
    236                     str_size(match_id->id));
    237                 if (retval != EOK) {
    238                         devman_exchange_end(exch);
    239                         async_forget(req2);
    240                         async_forget(req);
    241                         return retval;
     238                async_call_method(&call, &method_n, DEVMAN_ADD_MATCH_ID,
     239                    match_id->score, 0, 0, 0);
     240
     241                async_call_write(&call, &write_n,
     242                    match_id->id, str_size(match_id->id), NULL);
     243
     244                /* Wait so that we can recycle `method_n` and `write_n`. */
     245                (void) async_call_wait(&call);
     246        }
     247
     248        errno_t rc = async_call_finish(&call);
     249
     250        if (funh) {
     251                if (rc == EOK) {
     252                        *funh = (devman_handle_t)
     253                            IPC_GET_ARG1(call.initial.answer);
     254                } else {
     255                        *funh = -1;
    242256                }
    243 
    244                 async_wait_for(req2, &retval);
    245                 if (retval != EOK) {
    246                         devman_exchange_end(exch);
    247                         async_forget(req);
    248                         return retval;
    249                 }
    250         }
    251 
    252         devman_exchange_end(exch);
    253 
    254         async_wait_for(req, &retval);
    255         if (retval == EOK) {
    256                 if (funh != NULL)
    257                         *funh = (int) IPC_GET_ARG1(answer);
    258         } else {
    259                 if (funh != NULL)
    260                         *funh = -1;
    261         }
    262 
    263         return retval;
     257        }
     258
     259        return rc;
    264260}
    265261
     
    267263    const char *cat_name)
    268264{
    269         async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    270 
    271         ipc_call_t answer;
    272         aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CATEGORY,
    273             devman_handle, &answer);
    274         errno_t retval = async_data_write_start(exch, cat_name,
    275             str_size(cat_name));
    276 
    277         devman_exchange_end(exch);
    278 
    279         if (retval != EOK) {
    280                 async_forget(req);
    281                 return retval;
    282         }
    283 
    284         async_wait_for(req, &retval);
    285         return retval;
     265        async_sess_t *sess = devman_session_blocking(INTERFACE_DDF_DRIVER);
     266
     267        async_call_t call;
     268        async_call_data_t write;
     269
     270        async_call_begin(&call, sess, DEVMAN_ADD_DEVICE_TO_CATEGORY, devman_handle, 0, 0, 0);
     271        async_call_write(&call, &write, cat_name, str_size(cat_name), NULL);
     272        return async_call_finish(&call);
    286273}
    287274
     
    309296errno_t devman_remove_function(devman_handle_t funh)
    310297{
    311         async_exch_t *exch;
    312         errno_t retval;
    313 
    314         exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    315         retval = async_req_1_0(exch, DEVMAN_REMOVE_FUNCTION, (sysarg_t) funh);
    316         devman_exchange_end(exch);
    317 
    318         return retval;
     298        async_sess_t *sess = devman_session_blocking(INTERFACE_DDF_DRIVER);
     299
     300        async_call_t call;
     301        async_call_begin(&call, sess, DEVMAN_REMOVE_FUNCTION, funh, 0, 0, 0);
     302        return async_call_finish(&call);
    319303}
    320304
    321305errno_t devman_drv_fun_online(devman_handle_t funh)
    322306{
    323         async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
    324         if (exch == NULL)
    325                 return ENOMEM;
    326 
    327         errno_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_ONLINE, funh);
    328 
    329         devman_exchange_end(exch);
    330         return retval;
     307        async_sess_t *sess = devman_session_blocking(INTERFACE_DDF_DRIVER);
     308
     309        async_call_t call;
     310        async_call_begin(&call, sess, DEVMAN_DRV_FUN_ONLINE, funh, 0, 0, 0);
     311        return async_call_finish(&call);
    331312}
    332313
    333314errno_t devman_drv_fun_offline(devman_handle_t funh)
    334315{
    335         async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
    336         if (exch == NULL)
    337                 return ENOMEM;
    338 
    339         errno_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_OFFLINE, funh);
    340 
    341         devman_exchange_end(exch);
    342         return retval;
     316        async_sess_t *sess = devman_session_blocking(INTERFACE_DDF_DRIVER);
     317
     318        async_call_t call;
     319        async_call_begin(&call, sess, DEVMAN_DRV_FUN_OFFLINE, funh, 0, 0, 0);
     320        return async_call_finish(&call);
    343321}
    344322
     
    361339    unsigned int flags)
    362340{
    363         async_exch_t *exch;
     341        async_sess_t *sess;
     342        async_call_t call;
     343        async_call_data_t write;
    364344
    365345        if (flags & IPC_FLAG_BLOCKING)
    366                 exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
    367         else {
    368                 exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
    369                 if (exch == NULL)
    370                         return ENOMEM;
    371         }
    372 
    373         ipc_call_t answer;
    374         aid_t req = async_send_2(exch, DEVMAN_DEVICE_GET_HANDLE, flags, 0,
    375             &answer);
    376         errno_t retval = async_data_write_start(exch, pathname,
    377             str_size(pathname));
    378 
    379         devman_exchange_end(exch);
    380 
    381         if (retval != EOK) {
    382                 async_forget(req);
    383                 return retval;
    384         }
    385 
    386         async_wait_for(req, &retval);
    387 
    388         if (retval != EOK) {
     346                sess = devman_session_blocking(INTERFACE_DDF_CLIENT);
     347        else
     348                sess = devman_session(INTERFACE_DDF_CLIENT);
     349
     350        async_call_begin(&call, sess, DEVMAN_DEVICE_GET_HANDLE, flags, 0, 0, 0);
     351        async_call_write(&call, &write, pathname, str_size(pathname), NULL);
     352        errno_t rc = async_call_finish(&call);
     353
     354        if (rc != EOK) {
    389355                if (handle != NULL)
    390356                        *handle = (devman_handle_t) -1;
    391357
    392                 return retval;
     358                return rc;
    393359        }
    394360
    395361        if (handle != NULL)
    396                 *handle = (devman_handle_t) IPC_GET_ARG1(answer);
    397 
    398         return retval;
     362                *handle = (devman_handle_t) IPC_GET_ARG1(call.initial.answer);
     363
     364        return EOK;
    399365}
    400366
     
    402368    sysarg_t arg2, sysarg_t *r1, char *buf, size_t buf_size)
    403369{
    404         async_exch_t *exch;
    405         ipc_call_t dreply;
     370        async_call_t call;
     371        async_call_data_t read;
    406372        size_t act_size;
    407         errno_t dretval;
    408 
    409         exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
    410 
    411         ipc_call_t answer;
    412         aid_t req = async_send_2(exch, method, arg1, arg2, &answer);
    413         aid_t dreq = async_data_read(exch, buf, buf_size - 1, &dreply);
    414         async_wait_for(dreq, &dretval);
    415 
    416         devman_exchange_end(exch);
    417 
    418         if (dretval != EOK) {
    419                 async_forget(req);
    420                 return dretval;
    421         }
    422 
    423         errno_t retval;
    424         async_wait_for(req, &retval);
    425 
    426         if (retval != EOK) {
    427                 return retval;
    428         }
     373
     374        async_sess_t *sess = devman_session_blocking(INTERFACE_DDF_CLIENT);
     375
     376        async_call_begin(&call, sess, method, arg1, arg2, 0, 0);
     377        async_call_read(&call, &read, buf, buf_size - 1, &act_size);
     378        errno_t rc = async_call_finish(&call);
     379        if (rc != EOK)
     380                return rc;
    429381
    430382        if (r1 != NULL)
    431                 *r1 = IPC_GET_ARG1(answer);
    432         act_size = IPC_GET_ARG2(dreply);
     383                *r1 = IPC_GET_ARG1(call.initial.answer);
     384
    433385        assert(act_size <= buf_size - 1);
    434386        buf[act_size] = '\0';
    435 
    436387        return EOK;
    437388}
     
    472423errno_t devman_fun_online(devman_handle_t funh)
    473424{
    474         async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
    475         if (exch == NULL)
    476                 return ENOMEM;
    477 
    478         errno_t retval = async_req_1_0(exch, DEVMAN_FUN_ONLINE, funh);
    479 
    480         devman_exchange_end(exch);
    481         return retval;
     425        async_sess_t *sess = devman_session(INTERFACE_DDF_CLIENT);
     426
     427        async_call_t call;
     428        async_call_begin(&call, sess, DEVMAN_FUN_ONLINE, funh, 0, 0, 0);
     429        return async_call_finish(&call);
    482430}
    483431
    484432errno_t devman_fun_offline(devman_handle_t funh)
    485433{
    486         async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
    487         if (exch == NULL)
    488                 return ENOMEM;
    489 
    490         errno_t retval = async_req_1_0(exch, DEVMAN_FUN_OFFLINE, funh);
    491 
    492         devman_exchange_end(exch);
    493         return retval;
     434        async_sess_t *sess = devman_session(INTERFACE_DDF_CLIENT);
     435
     436        async_call_t call;
     437        async_call_begin(&call, sess, DEVMAN_FUN_OFFLINE, funh, 0, 0, 0);
     438        return async_call_finish(&call);
    494439}
    495440
     
    497442    devman_handle_t *handle_buf, size_t buf_size, size_t *act_size)
    498443{
    499         async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
    500 
    501         ipc_call_t answer;
    502         aid_t req = async_send_1(exch, method, arg1, &answer);
    503         errno_t rc = async_data_read_start(exch, handle_buf, buf_size);
    504 
    505         devman_exchange_end(exch);
    506 
    507         if (rc != EOK) {
    508                 async_forget(req);
    509                 return rc;
    510         }
    511 
    512         errno_t retval;
    513         async_wait_for(req, &retval);
    514 
    515         if (retval != EOK) {
    516                 return retval;
    517         }
    518 
    519         *act_size = IPC_GET_ARG1(answer);
     444        async_sess_t *sess = devman_session_blocking(INTERFACE_DDF_CLIENT);
     445
     446        async_call_t call;
     447        async_call_data_t read;
     448
     449        async_call_begin(&call, sess, method, arg1, 0, 0, 0);
     450        async_call_read(&call, &read, handle_buf, buf_size, NULL);
     451        errno_t rc = async_call_finish(&call);
     452        if (rc != EOK)
     453                return rc;
     454
     455        *act_size = IPC_GET_ARG1(call.initial.answer);
    520456        return EOK;
    521457}
     
    576512errno_t devman_fun_get_child(devman_handle_t funh, devman_handle_t *devh)
    577513{
    578         async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
    579         if (exch == NULL)
    580                 return ENOMEM;
    581 
    582         errno_t retval = async_req_1_1(exch, DEVMAN_FUN_GET_CHILD,
    583             funh, devh);
    584 
    585         devman_exchange_end(exch);
    586         return retval;
     514        async_sess_t *sess = devman_session(INTERFACE_DDF_CLIENT);
     515
     516        async_call_t call;
     517        async_call_begin(&call, sess, DEVMAN_FUN_GET_CHILD, funh, 0, 0, 0);
     518        errno_t rc = async_call_finish(&call);
     519        if (rc != EOK)
     520                return rc;
     521
     522        *devh = (devman_handle_t) IPC_GET_ARG1(call.initial.answer);
     523        return EOK;
    587524}
    588525
     
    596533errno_t devman_dev_get_parent(devman_handle_t devh, devman_handle_t *funh)
    597534{
    598         async_exch_t *exch = devman_exchange_begin(INTERFACE_DDF_CLIENT);
    599         if (exch == NULL)
    600                 return ENOMEM;
    601 
    602         errno_t retval = async_req_1_1(exch, DEVMAN_DEV_GET_PARENT,
    603             devh, funh);
    604 
    605         devman_exchange_end(exch);
    606         return retval;
     535        async_sess_t *sess = devman_session(INTERFACE_DDF_CLIENT);
     536
     537        async_call_t call;
     538        async_call_begin(&call, sess, DEVMAN_DEV_GET_PARENT, devh, 0, 0, 0);
     539        errno_t rc = async_call_finish(&call);
     540        if (rc != EOK)
     541                return rc;
     542
     543        *funh = (devman_handle_t) IPC_GET_ARG1(call.initial.answer);
     544        return EOK;
    607545}
    608546
  • uspace/lib/c/include/async.h

    r9c16c36 r95faa4d  
    550550    void *, unsigned int);
    551551
     552extern void async_call_connect_to_me(async_call_t *, async_call_data_t *,
     553    sysarg_t, sysarg_t, sysarg_t);
     554
    552555// TODO: connect me to, connect to me, vfs handle, etc.
    553556
Note: See TracChangeset for help on using the changeset viewer.