Changeset 984a9ba in mainline for uspace/lib/graph/graph.c


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/graph/graph.c

    r76f566d r984a9ba  
    239239}
    240240
    241 static void vs_claim(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
     241static void vs_claim(visualizer_t *vs, ipc_call_t *icall)
    242242{
    243243        vs->client_side_handle = IPC_GET_ARG1(*icall);
    244244        errno_t rc = vs->ops.claim(vs);
    245         async_answer_0(icall_handle, rc);
    246 }
    247 
    248 static void vs_yield(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
     245        async_answer_0(icall, rc);
     246}
     247
     248static void vs_yield(visualizer_t *vs, ipc_call_t *icall)
    249249{
    250250        /* Deallocate resources for the current mode. */
    … …  
    266266                vs->mode_set = false;
    267267
    268         async_answer_0(icall_handle, rc);
    269 }
    270 
    271 static void vs_enumerate_modes(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
    272 {
    273         cap_call_handle_t chandle;
     268        async_answer_0(icall, rc);
     269}
     270
     271static void vs_enumerate_modes(visualizer_t *vs, ipc_call_t *icall)
     272{
    274273        size_t len;
    275274
    276         if (!async_data_read_receive(&chandle, &len)) {
    277                 async_answer_0(chandle, EREFUSED);
    278                 async_answer_0(icall_handle, EREFUSED);
     275        ipc_call_t call;
     276        if (!async_data_read_receive(&call, &len)) {
     277                async_answer_0(&call, EREFUSED);
     278                async_answer_0(icall, EREFUSED);
    279279                return;
    280280        }
    … …  
    287287                    list_get_instance(link, vslmode_list_element_t, link);
    288288
    289                 errno_t rc = async_data_read_finalize(chandle, &mode_elem->mode, len);
    290                 async_answer_0(icall_handle, rc);
     289                errno_t rc = async_data_read_finalize(&call, &mode_elem->mode, len);
     290                async_answer_0(icall, rc);
    291291        } else {
    292                 async_answer_0(chandle, ENOENT);
    293                 async_answer_0(icall_handle, ENOENT);
     292                async_answer_0(&call, ENOENT);
     293                async_answer_0(icall, ENOENT);
    294294        }
    295295
    … …  
    297297}
    298298
    299 static void vs_get_default_mode(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
    300 {
    301         cap_call_handle_t chandle;
     299static void vs_get_default_mode(visualizer_t *vs, ipc_call_t *icall)
     300{
     301        ipc_call_t call;
    302302        size_t len;
    303 
    304         if (!async_data_read_receive(&chandle, &len)) {
    305                 async_answer_0(chandle, EREFUSED);
    306                 async_answer_0(icall_handle, EREFUSED);
     303        if (!async_data_read_receive(&call, &len)) {
     304                async_answer_0(&call, EREFUSED);
     305                async_answer_0(icall, EREFUSED);
    307306                return;
    308307        }
    … …  
    319318
    320319        if (mode_elem != NULL) {
    321                 errno_t rc = async_data_read_finalize(chandle, &mode_elem->mode, len);
    322                 async_answer_0(icall_handle, rc);
     320                errno_t rc = async_data_read_finalize(&call, &mode_elem->mode, len);
     321                async_answer_0(icall, rc);
    323322        } else {
    324323                fibril_mutex_unlock(&vs->mode_mtx);
    325                 async_answer_0(chandle, ENOENT);
    326                 async_answer_0(icall_handle, ENOENT);
     324                async_answer_0(&call, ENOENT);
     325                async_answer_0(icall, ENOENT);
    327326        }
    328327
    … …  
    330329}
    331330
    332 static void vs_get_current_mode(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
    333 {
    334         cap_call_handle_t chandle;
     331static void vs_get_current_mode(visualizer_t *vs, ipc_call_t *icall)
     332{
     333        ipc_call_t call;
    335334        size_t len;
    336 
    337         if (!async_data_read_receive(&chandle, &len)) {
    338                 async_answer_0(chandle, EREFUSED);
    339                 async_answer_0(icall_handle, EREFUSED);
     335        if (!async_data_read_receive(&call, &len)) {
     336                async_answer_0(&call, EREFUSED);
     337                async_answer_0(icall, EREFUSED);
    340338                return;
    341339        }
    342340
    343341        if (vs->mode_set) {
    344                 errno_t rc = async_data_read_finalize(chandle, &vs->cur_mode, len);
    345                 async_answer_0(icall_handle, rc);
     342                errno_t rc = async_data_read_finalize(&call, &vs->cur_mode, len);
     343                async_answer_0(icall, rc);
    346344        } else {
    347                 async_answer_0(chandle, ENOENT);
    348                 async_answer_0(icall_handle, ENOENT);
    349         }
    350 }
    351 
    352 static void vs_get_mode(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
    353 {
    354         cap_call_handle_t chandle;
     345                async_answer_0(&call, ENOENT);
     346                async_answer_0(icall, ENOENT);
     347        }
     348}
     349
     350static void vs_get_mode(visualizer_t *vs, ipc_call_t *icall)
     351{
     352        ipc_call_t call;
    355353        size_t len;
    356 
    357         if (!async_data_read_receive(&chandle, &len)) {
    358                 async_answer_0(chandle, EREFUSED);
    359                 async_answer_0(icall_handle, EREFUSED);
     354        if (!async_data_read_receive(&call, &len)) {
     355                async_answer_0(&call, EREFUSED);
     356                async_answer_0(icall, EREFUSED);
    360357                return;
    361358        }
    … …  
    374371
    375372        if (mode_elem != NULL) {
    376                 errno_t rc = async_data_read_finalize(chandle, &mode_elem->mode, len);
    377                 async_answer_0(icall_handle, rc);
     373                errno_t rc = async_data_read_finalize(&call, &mode_elem->mode, len);
     374                async_answer_0(icall, rc);
    378375        } else {
    379                 async_answer_0(chandle, ENOENT);
    380                 async_answer_0(icall_handle, ENOENT);
     376                async_answer_0(&call, ENOENT);
     377                async_answer_0(icall, ENOENT);
    381378        }
    382379
    … …  
    384381}
    385382
    386 static void vs_set_mode(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
    387 {
    388         cap_call_handle_t chandle;
     383static void vs_set_mode(visualizer_t *vs, ipc_call_t *icall)
     384{
     385        ipc_call_t call;
    389386        size_t size;
    390387        unsigned int flags;
    391388
    392389        /* Retrieve the shared cell storage for the new mode. */
    393         if (!async_share_out_receive(&chandle, &size, &flags)) {
    394                 async_answer_0(chandle, EREFUSED);
    395                 async_answer_0(icall_handle, EREFUSED);
     390        if (!async_share_out_receive(&call, &size, &flags)) {
     391                async_answer_0(&call, EREFUSED);
     392                async_answer_0(icall, EREFUSED);
    396393                return;
    397394        }
    … …  
    414411        if (mode_elem == NULL) {
    415412                fibril_mutex_unlock(&vs->mode_mtx);
    416                 async_answer_0(chandle, ENOENT);
    417                 async_answer_0(icall_handle, ENOENT);
     413                async_answer_0(&call, ENOENT);
     414                async_answer_0(icall, ENOENT);
    418415                return;
    419416        }
    … …  
    425422        /* Check whether the mode is still up-to-date. */
    426423        if (new_mode.version != mode_version) {
    427                 async_answer_0(chandle, EINVAL);
    428                 async_answer_0(icall_handle, EINVAL);
     424                async_answer_0(&call, EINVAL);
     425                async_answer_0(icall, EINVAL);
    429426                return;
    430427        }
    431428
    432429        void *new_cell_storage;
    433         errno_t rc = async_share_out_finalize(chandle, &new_cell_storage);
     430        errno_t rc = async_share_out_finalize(&call, &new_cell_storage);
    434431        if ((rc != EOK) || (new_cell_storage == AS_MAP_FAILED)) {
    435                 async_answer_0(icall_handle, ENOMEM);
     432                async_answer_0(icall, ENOMEM);
    436433                return;
    437434        }
    … …  
    443440        if (rc != EOK) {
    444441                as_area_destroy(new_cell_storage);
    445                 async_answer_0(icall_handle, ENOMEM);
     442                async_answer_0(icall, ENOMEM);
    446443                return;
    447444        }
    … …  
    466463        vs->mode_set = true;
    467464
    468         async_answer_0(icall_handle, EOK);
    469 }
    470 
    471 static void vs_update_damaged_region(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
     465        async_answer_0(icall, EOK);
     466}
     467
     468static void vs_update_damaged_region(visualizer_t *vs, ipc_call_t *icall)
    472469{
    473470        sysarg_t x_offset = (IPC_GET_ARG5(*icall) >> 16);
    … …  
    478475            IPC_GET_ARG3(*icall), IPC_GET_ARG4(*icall),
    479476            x_offset, y_offset);
    480         async_answer_0(icall_handle, rc);
    481 }
    482 
    483 static void vs_suspend(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
     477        async_answer_0(icall, rc);
     478}
     479
     480static void vs_suspend(visualizer_t *vs, ipc_call_t *icall)
    484481{
    485482        errno_t rc = vs->ops.suspend(vs);
    486         async_answer_0(icall_handle, rc);
    487 }
    488 
    489 static void vs_wakeup(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
     483        async_answer_0(icall, rc);
     484}
     485
     486static void vs_wakeup(visualizer_t *vs, ipc_call_t *icall)
    490487{
    491488        errno_t rc = vs->ops.wakeup(vs);
    492         async_answer_0(icall_handle, rc);
    493 }
    494 
    495 void graph_visualizer_connection(visualizer_t *vs,
    496     cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    497 {
    498         ipc_call_t call;
    499         cap_call_handle_t chandle;
    500 
     489        async_answer_0(icall, rc);
     490}
     491
     492void graph_visualizer_connection(visualizer_t *vs, ipc_call_t *icall, void *arg)
     493{
    501494        /* Claim the visualizer. */
    502495        if (!cas(&vs->ref_cnt, 0, 1)) {
    503                 async_answer_0(icall_handle, ELIMIT);
     496                async_answer_0(icall, ELIMIT);
    504497                return;
    505498        }
    506499
    507500        /* Accept the connection. */
    508         async_answer_0(icall_handle, EOK);
     501        async_answer_0(icall, EOK);
    509502
    510503        /* Establish callback session. */
    511         chandle = async_get_call(&call);
     504        ipc_call_t call;
     505        async_get_call(&call);
    512506        vs->notif_sess = async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
    513507        if (vs->notif_sess != NULL)
    514                 async_answer_0(chandle, EOK);
     508                async_answer_0(&call, EOK);
    515509        else
    516                 async_answer_0(chandle, ELIMIT);
     510                async_answer_0(&call, ELIMIT);
    517511
    518512        /* Enter command loop. */
    519513        while (true) {
    520                 chandle = async_get_call(&call);
     514                async_get_call(&call);
    521515
    522516                if (!IPC_GET_IMETHOD(call)) {
    523                         async_answer_0(chandle, EINVAL);
     517                        async_answer_0(&call, EINVAL);
    524518                        break;
    525519                }
    … …  
    527521                switch (IPC_GET_IMETHOD(call)) {
    528522                case VISUALIZER_CLAIM:
    529                         vs_claim(vs, chandle, &call);
     523                        vs_claim(vs, &call);
    530524                        break;
    531525                case VISUALIZER_YIELD:
    532                         vs_yield(vs, chandle, &call);
     526                        vs_yield(vs, &call);
    533527                        goto terminate;
    534528                case VISUALIZER_ENUMERATE_MODES:
    535                         vs_enumerate_modes(vs, chandle, &call);
     529                        vs_enumerate_modes(vs, &call);
    536530                        break;
    537531                case VISUALIZER_GET_DEFAULT_MODE:
    538                         vs_get_default_mode(vs, chandle, &call);
     532                        vs_get_default_mode(vs, &call);
    539533                        break;
    540534                case VISUALIZER_GET_CURRENT_MODE:
    541                         vs_get_current_mode(vs, chandle, &call);
     535                        vs_get_current_mode(vs, &call);
    542536                        break;
    543537                case VISUALIZER_GET_MODE:
    544                         vs_get_mode(vs, chandle, &call);
     538                        vs_get_mode(vs, &call);
    545539                        break;
    546540                case VISUALIZER_SET_MODE:
    547                         vs_set_mode(vs, chandle, &call);
     541                        vs_set_mode(vs, &call);
    548542                        break;
    549543                case VISUALIZER_UPDATE_DAMAGED_REGION:
    550                         vs_update_damaged_region(vs, chandle, &call);
     544                        vs_update_damaged_region(vs, &call);
    551545                        break;
    552546                case VISUALIZER_SUSPEND:
    553                         vs_suspend(vs, chandle, &call);
     547                        vs_suspend(vs, &call);
    554548                        break;
    555549                case VISUALIZER_WAKE_UP:
    556                         vs_wakeup(vs, chandle, &call);
     550                        vs_wakeup(vs, &call);
    557551                        break;
    558552                default:
    559                         async_answer_0(chandle, EINVAL);
     553                        async_answer_0(&call, EINVAL);
    560554                        goto terminate;
    561555                }
    … …  
    568562}
    569563
    570 void graph_renderer_connection(renderer_t *rnd,
    571     cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     564void graph_renderer_connection(renderer_t *rnd, ipc_call_t *icall, void *arg)
    572565{
    573566        // TODO
    574 
    575         ipc_call_t call;
    576         cap_call_handle_t chandle;
    577567
    578568        /* Accept the connection. */
    579569        atomic_inc(&rnd->ref_cnt);
    580         async_answer_0(icall_handle, EOK);
     570        async_answer_0(icall, EOK);
    581571
    582572        /* Enter command loop. */
    583573        while (true) {
    584                 chandle = async_get_call(&call);
     574                ipc_call_t call;
     575                async_get_call(&call);
    585576
    586577                if (!IPC_GET_IMETHOD(call)) {
    587                         async_answer_0(chandle, EINVAL);
     578                        async_answer_0(&call, EINVAL);
    588579                        break;
    589580                }
    … …  
    591582                switch (IPC_GET_IMETHOD(call)) {
    592583                default:
    593                         async_answer_0(chandle, EINVAL);
     584                        async_answer_0(&call, EINVAL);
    594585                        goto terminate;
    595586                }
    … …  
    600591}
    601592
    602 void graph_client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     593void graph_client_connection(ipc_call_t *icall, void *arg)
    603594{
    604595        /* Find the visualizer or renderer with the given service ID. */
    … …  
    607598
    608599        if (vs != NULL)
    609                 graph_visualizer_connection(vs, icall_handle, icall, arg);
     600                graph_visualizer_connection(vs, icall, arg);
    610601        else if (rnd != NULL)
    611                 graph_renderer_connection(rnd, icall_handle, icall, arg);
     602                graph_renderer_connection(rnd, icall, arg);
    612603        else
    613                 async_answer_0(icall_handle, ENOENT);
     604                async_answer_0(icall, ENOENT);
    614605}
    615606
Note: See TracChangeset for help on using the changeset viewer.