Ignore:
Timestamp:
2018-07-05T09:34:09Z (6 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
63d46341
Parents:
76f566d
Message:

do not expose the call capability handler from the async framework

Keep the call capability handler encapsulated within the async framework
and do not expose it explicitly via its API. Use the pointer to
ipc_call_t as the sole object identifying an IPC call in the code that
uses the async framework.

This plugs a major leak in the abstraction and also simplifies both the
async framework (slightly) and all IPC servers.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/drv/generic/remote_usbhc.c

    r76f566d r984a9ba  
    227227}
    228228
    229 static void remote_usbhc_default_address_reservation(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    230 static void remote_usbhc_device_enumerate(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    231 static void remote_usbhc_device_remove(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    232 static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    233 static void remote_usbhc_unregister_endpoint(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    234 static void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call);
     229static void remote_usbhc_default_address_reservation(ddf_fun_t *, void *, ipc_call_t *);
     230static void remote_usbhc_device_enumerate(ddf_fun_t *, void *, ipc_call_t *);
     231static void remote_usbhc_device_remove(ddf_fun_t *, void *, ipc_call_t *);
     232static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, ipc_call_t *);
     233static void remote_usbhc_unregister_endpoint(ddf_fun_t *, void *, ipc_call_t *);
     234static void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, ipc_call_t *call);
    235235
    236236/** Remote USB interface operations. */
    … …  
    252252
    253253typedef struct {
    254         cap_call_handle_t caller;
     254        ipc_call_t call;
    255255        usbhc_iface_transfer_request_t request;
    256256} async_transaction_t;
    257257
    258258void remote_usbhc_default_address_reservation(ddf_fun_t *fun, void *iface,
    259     cap_call_handle_t chandle, ipc_call_t *call)
     259    ipc_call_t *call)
    260260{
    261261        const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
    262262
    263263        if (usbhc_iface->default_address_reservation == NULL) {
    264                 async_answer_0(chandle, ENOTSUP);
     264                async_answer_0(call, ENOTSUP);
    265265                return;
    266266        }
    … …  
    268268        const bool reserve = IPC_GET_ARG2(*call);
    269269        const errno_t ret = usbhc_iface->default_address_reservation(fun, reserve);
    270         async_answer_0(chandle, ret);
     270        async_answer_0(call, ret);
    271271}
    272272
    273273
    274274static void remote_usbhc_device_enumerate(ddf_fun_t *fun, void *iface,
    275     cap_call_handle_t chandle, ipc_call_t *call)
     275    ipc_call_t *call)
    276276{
    277277        const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
    278278
    279279        if (usbhc_iface->device_enumerate == NULL) {
    280                 async_answer_0(chandle, ENOTSUP);
     280                async_answer_0(call, ENOTSUP);
    281281                return;
    282282        }
    … …  
    285285        usb_speed_t speed = DEV_IPC_GET_ARG2(*call);
    286286        const errno_t ret = usbhc_iface->device_enumerate(fun, port, speed);
    287         async_answer_0(chandle, ret);
     287        async_answer_0(call, ret);
    288288}
    289289
    290290static void remote_usbhc_device_remove(ddf_fun_t *fun, void *iface,
    291     cap_call_handle_t chandle, ipc_call_t *call)
     291    ipc_call_t *call)
    292292{
    293293        const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
    294294
    295295        if (usbhc_iface->device_remove == NULL) {
    296                 async_answer_0(chandle, ENOTSUP);
     296                async_answer_0(call, ENOTSUP);
    297297                return;
    298298        }
    … …  
    300300        const unsigned port = DEV_IPC_GET_ARG1(*call);
    301301        const errno_t ret = usbhc_iface->device_remove(fun, port);
    302         async_answer_0(chandle, ret);
     302        async_answer_0(call, ret);
    303303}
    304304
    305305static void remote_usbhc_register_endpoint(ddf_fun_t *fun, void *iface,
    306     cap_call_handle_t chandle, ipc_call_t *call)
     306    ipc_call_t *call)
    307307{
    308308        assert(fun);
    … …  
    313313
    314314        if (!usbhc_iface->register_endpoint) {
    315                 async_answer_0(chandle, ENOTSUP);
     315                async_answer_0(call, ENOTSUP);
    316316                return;
    317317        }
    318318
    319319        usb_endpoint_descriptors_t ep_desc;
    320         cap_call_handle_t data_chandle;
     320        ipc_call_t data;
    321321        size_t len;
    322322
    323         if (!async_data_write_receive(&data_chandle, &len) ||
     323        if (!async_data_write_receive(&data, &len) ||
    324324            len != sizeof(ep_desc)) {
    325                 async_answer_0(chandle, EINVAL);
    326                 return;
    327         }
    328         async_data_write_finalize(data_chandle, &ep_desc, sizeof(ep_desc));
     325                async_answer_0(call, EINVAL);
     326                return;
     327        }
     328
     329        async_data_write_finalize(&data, &ep_desc, sizeof(ep_desc));
    329330
    330331        usb_pipe_desc_t pipe_desc;
    331332
    332333        const errno_t rc = usbhc_iface->register_endpoint(fun, &pipe_desc, &ep_desc);
    333         async_answer_0(chandle, rc);
    334 
    335         if (!async_data_read_receive(&data_chandle, &len) ||
     334        async_answer_0(call, rc);
     335
     336        if (!async_data_read_receive(&data, &len) ||
    336337            len != sizeof(pipe_desc)) {
    337338                return;
    338339        }
    339         async_data_read_finalize(data_chandle, &pipe_desc, sizeof(pipe_desc));
     340        async_data_read_finalize(&data, &pipe_desc, sizeof(pipe_desc));
    340341}
    341342
    342343static void remote_usbhc_unregister_endpoint(ddf_fun_t *fun, void *iface,
    343     cap_call_handle_t chandle, ipc_call_t *call)
     344    ipc_call_t *call)
    344345{
    345346        assert(fun);
    … …  
    350351
    351352        if (!usbhc_iface->unregister_endpoint) {
    352                 async_answer_0(chandle, ENOTSUP);
     353                async_answer_0(call, ENOTSUP);
    353354                return;
    354355        }
    355356
    356357        usb_pipe_desc_t pipe_desc;
    357         cap_call_handle_t data_chandle;
     358        ipc_call_t data;
    358359        size_t len;
    359360
    360         if (!async_data_write_receive(&data_chandle, &len) ||
     361        if (!async_data_write_receive(&data, &len) ||
    361362            len != sizeof(pipe_desc)) {
    362                 async_answer_0(chandle, EINVAL);
    363                 return;
    364         }
    365         async_data_write_finalize(data_chandle, &pipe_desc, sizeof(pipe_desc));
     363                async_answer_0(call, EINVAL);
     364                return;
     365        }
     366        async_data_write_finalize(&data, &pipe_desc, sizeof(pipe_desc));
    366367
    367368        const errno_t rc = usbhc_iface->unregister_endpoint(fun, &pipe_desc);
    368         async_answer_0(chandle, rc);
     369        async_answer_0(call, rc);
    369370}
    370371
    … …  
    381382}
    382383
    383 static async_transaction_t *async_transaction_create(cap_call_handle_t caller)
     384static async_transaction_t *async_transaction_create(ipc_call_t *call)
    384385{
    385386        async_transaction_t *trans = calloc(1, sizeof(async_transaction_t));
    386387
    387388        if (trans != NULL)
    388                 trans->caller = caller;
     389                trans->call = *call;
    389390
    390391        return trans;
    … …  
    394395{
    395396        async_transaction_t *trans = arg;
    396         const errno_t err = async_answer_1(trans->caller, error, transferred_size);
     397        const errno_t err = async_answer_1(&trans->call, error, transferred_size);
    397398        async_transaction_destroy(trans);
    398399        return err;
    … …  
    410411
    411412        errno_t err;
    412         cap_call_handle_t data_chandle;
     413        ipc_call_t data;
    413414        size_t size;
    414415        unsigned flags;
    415416
    416         if (!async_share_out_receive(&data_chandle, &size, &flags))
     417        if (!async_share_out_receive(&data, &size, &flags))
    417418                return EPARTY;
    418419
    419420        if (size < required_size || (flags & required_flags) != required_flags) {
    420                 async_answer_0(data_chandle, EINVAL);
     421                async_answer_0(&data, EINVAL);
    421422                return EINVAL;
    422423        }
    423424
    424         if ((err = async_share_out_finalize(data_chandle, &trans->request.buffer.virt)))
     425        if ((err = async_share_out_finalize(&data, &trans->request.buffer.virt)))
    425426                return err;
    426427
    … …  
    445446}
    446447
    447 void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
     448void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, ipc_call_t *call)
    448449{
    449450        assert(fun);
    … …  
    454455
    455456        if (!usbhc_iface->transfer) {
    456                 async_answer_0(chandle, ENOTSUP);
    457                 return;
    458         }
    459 
    460         async_transaction_t *trans = async_transaction_create(chandle);
     457                async_answer_0(call, ENOTSUP);
     458                return;
     459        }
     460
     461        async_transaction_t *trans =
     462            async_transaction_create(call);
    461463        if (trans == NULL) {
    462                 async_answer_0(chandle, ENOMEM);
     464                async_answer_0(call, ENOMEM);
    463465                return;
    464466        }
    … …  
    466468        errno_t err = EPARTY;
    467469
    468         cap_call_handle_t data_chandle;
     470        ipc_call_t data;
    469471        size_t len;
    470         if (!async_data_write_receive(&data_chandle, &len) ||
     472        if (!async_data_write_receive(&data, &len) ||
    471473            len != sizeof(trans->request)) {
    472                 async_answer_0(data_chandle, EINVAL);
     474                async_answer_0(&data, EINVAL);
    473475                goto err;
    474476        }
    475477
    476         if ((err = async_data_write_finalize(data_chandle,
     478        if ((err = async_data_write_finalize(&data,
    477479            &trans->request, sizeof(trans->request))))
    478480                goto err;
    … …  
    494496
    495497err:
    496         async_answer_0(chandle, err);
     498        async_answer_0(call, err);
    497499        async_transaction_destroy(trans);
    498500}
Note: See TracChangeset for help on using the changeset viewer.