Changeset 984a9ba in mainline for uspace/srv/locsrv/locsrv.c


Ignore:
Timestamp:
2018-07-05T09:34:09Z (7 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/srv/locsrv/locsrv.c

    r76f566d r984a9ba  
    341341{
    342342        ipc_call_t icall;
    343         cap_call_handle_t icall_handle = async_get_call(&icall);
     343        async_get_call(&icall);
    344344
    345345        if (IPC_GET_IMETHOD(icall) != LOC_SERVER_REGISTER) {
    346                 async_answer_0(icall_handle, EREFUSED);
     346                async_answer_0(&icall, EREFUSED);
    347347                return NULL;
    348348        }
    … …  
    351351            (loc_server_t *) malloc(sizeof(loc_server_t));
    352352        if (server == NULL) {
    353                 async_answer_0(icall_handle, ENOMEM);
     353                async_answer_0(&icall, ENOMEM);
    354354                return NULL;
    355355        }
    … …  
    362362        if (rc != EOK) {
    363363                free(server);
    364                 async_answer_0(icall_handle, rc);
     364                async_answer_0(&icall, rc);
    365365                return NULL;
    366366        }
    … …  
    373373                free(server->name);
    374374                free(server);
    375                 async_answer_0(icall_handle, ENOTSUP);
     375                async_answer_0(&icall, ENOTSUP);
    376376                return NULL;
    377377        }
    … …  
    403403        fibril_mutex_unlock(&servers_list_mutex);
    404404
    405         async_answer_0(icall_handle, EOK);
     405        async_answer_0(&icall, EOK);
    406406
    407407        return server;
    … …  
    456456 *
    457457 */
    458 static void loc_service_register(cap_call_handle_t icall_handle, ipc_call_t *icall,
    459     loc_server_t *server)
     458static void loc_service_register(ipc_call_t *icall, loc_server_t *server)
    460459{
    461460        if (server == NULL) {
    462                 async_answer_0(icall_handle, EREFUSED);
     461                async_answer_0(icall, EREFUSED);
    463462                return;
    464463        }
    … …  
    468467            (loc_service_t *) malloc(sizeof(loc_service_t));
    469468        if (service == NULL) {
    470                 async_answer_0(icall_handle, ENOMEM);
     469                async_answer_0(icall, ENOMEM);
    471470                return;
    472471        }
    … …  
    478477        if (rc != EOK) {
    479478                free(service);
    480                 async_answer_0(icall_handle, rc);
     479                async_answer_0(icall, rc);
    481480                return;
    482481        }
    … …  
    486485                free(fqsn);
    487486                free(service);
    488                 async_answer_0(icall_handle, EINVAL);
     487                async_answer_0(icall, EINVAL);
    489488                return;
    490489        }
    … …  
    500499                free(service->name);
    501500                free(service);
    502                 async_answer_0(icall_handle, ENOMEM);
     501                async_answer_0(icall, ENOMEM);
    503502                return;
    504503        }
    … …  
    516515                free(service->name);
    517516                free(service);
    518                 async_answer_0(icall_handle, EEXIST);
     517                async_answer_0(icall, EEXIST);
    519518                return;
    520519        }
    … …  
    538537        fibril_mutex_unlock(&services_list_mutex);
    539538
    540         async_answer_1(icall_handle, EOK, service->id);
     539        async_answer_1(icall, EOK, service->id);
    541540}
    542541
    … …  
    544543 *
    545544 */
    546 static void loc_service_unregister(cap_call_handle_t icall_handle, ipc_call_t *icall,
    547     loc_server_t *server)
     545static void loc_service_unregister(ipc_call_t *icall, loc_server_t *server)
    548546{
    549547        loc_service_t *svc;
    … …  
    553551        if (svc == NULL) {
    554552                fibril_mutex_unlock(&services_list_mutex);
    555                 async_answer_0(icall_handle, ENOENT);
     553                async_answer_0(icall, ENOENT);
    556554                return;
    557555        }
    … …  
    568566         */
    569567        loc_category_change_event();
    570         async_answer_0(icall_handle, EOK);
    571 }
    572 
    573 static void loc_category_get_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
    574 {
    575         cap_call_handle_t chandle;
     568        async_answer_0(icall, EOK);
     569}
     570
     571static void loc_category_get_name(ipc_call_t *icall)
     572{
     573        ipc_call_t call;
    576574        size_t size;
    577575        size_t act_size;
    578576        category_t *cat;
    579577
    580         if (!async_data_read_receive(&chandle, &size)) {
    581                 async_answer_0(chandle, EREFUSED);
    582                 async_answer_0(icall_handle, EREFUSED);
     578        if (!async_data_read_receive(&call, &size)) {
     579                async_answer_0(&call, EREFUSED);
     580                async_answer_0(icall, EREFUSED);
    583581                return;
    584582        }
    … …  
    589587        if (cat == NULL) {
    590588                fibril_mutex_unlock(&cdir.mutex);
    591                 async_answer_0(chandle, ENOENT);
    592                 async_answer_0(icall_handle, ENOENT);
     589                async_answer_0(&call, ENOENT);
     590                async_answer_0(icall, ENOENT);
    593591                return;
    594592        }
    … …  
    597595        if (act_size > size) {
    598596                fibril_mutex_unlock(&cdir.mutex);
    599                 async_answer_0(chandle, EOVERFLOW);
    600                 async_answer_0(icall_handle, EOVERFLOW);
    601                 return;
    602         }
    603 
    604         errno_t retval = async_data_read_finalize(chandle, cat->name,
     597                async_answer_0(&call, EOVERFLOW);
     598                async_answer_0(icall, EOVERFLOW);
     599                return;
     600        }
     601
     602        errno_t retval = async_data_read_finalize(&call, cat->name,
    605603            min(size, act_size));
    606604
    607605        fibril_mutex_unlock(&cdir.mutex);
    608606
    609         async_answer_0(icall_handle, retval);
    610 }
    611 
    612 static void loc_service_get_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
    613 {
    614         cap_call_handle_t chandle;
     607        async_answer_0(icall, retval);
     608}
     609
     610static void loc_service_get_name(ipc_call_t *icall)
     611{
     612        ipc_call_t call;
    615613        size_t size;
    616614        size_t act_size;
    … …  
    618616        char *fqn;
    619617
    620         if (!async_data_read_receive(&chandle, &size)) {
    621                 async_answer_0(chandle, EREFUSED);
    622                 async_answer_0(icall_handle, EREFUSED);
     618        if (!async_data_read_receive(&call, &size)) {
     619                async_answer_0(&call, EREFUSED);
     620                async_answer_0(icall, EREFUSED);
    623621                return;
    624622        }
    … …  
    629627        if (svc == NULL) {
    630628                fibril_mutex_unlock(&services_list_mutex);
    631                 async_answer_0(chandle, ENOENT);
    632                 async_answer_0(icall_handle, ENOENT);
     629                async_answer_0(&call, ENOENT);
     630                async_answer_0(icall, ENOENT);
    633631                return;
    634632        }
    … …  
    636634        if (asprintf(&fqn, "%s/%s", svc->namespace->name, svc->name) < 0) {
    637635                fibril_mutex_unlock(&services_list_mutex);
    638                 async_answer_0(chandle, ENOMEM);
    639                 async_answer_0(icall_handle, ENOMEM);
     636                async_answer_0(&call, ENOMEM);
     637                async_answer_0(icall, ENOMEM);
    640638                return;
    641639        }
    … …  
    645643                free(fqn);
    646644                fibril_mutex_unlock(&services_list_mutex);
    647                 async_answer_0(chandle, EOVERFLOW);
    648                 async_answer_0(icall_handle, EOVERFLOW);
    649                 return;
    650         }
    651 
    652         errno_t retval = async_data_read_finalize(chandle, fqn,
     645                async_answer_0(&call, EOVERFLOW);
     646                async_answer_0(icall, EOVERFLOW);
     647                return;
     648        }
     649
     650        errno_t retval = async_data_read_finalize(&call, fqn,
    653651            min(size, act_size));
    654652        free(fqn);
    … …  
    656654        fibril_mutex_unlock(&services_list_mutex);
    657655
    658         async_answer_0(icall_handle, retval);
    659 }
    660 
    661 static void loc_service_get_server_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
    662 {
    663         cap_call_handle_t chandle;
     656        async_answer_0(icall, retval);
     657}
     658
     659static void loc_service_get_server_name(ipc_call_t *icall)
     660{
     661        ipc_call_t call;
    664662        size_t size;
    665663        size_t act_size;
    666664        loc_service_t *svc;
    667665
    668         if (!async_data_read_receive(&chandle, &size)) {
    669                 async_answer_0(chandle, EREFUSED);
    670                 async_answer_0(icall_handle, EREFUSED);
     666        if (!async_data_read_receive(&call, &size)) {
     667                async_answer_0(&call, EREFUSED);
     668                async_answer_0(icall, EREFUSED);
    671669                return;
    672670        }
    … …  
    677675        if (svc == NULL) {
    678676                fibril_mutex_unlock(&services_list_mutex);
    679                 async_answer_0(chandle, ENOENT);
    680                 async_answer_0(icall_handle, ENOENT);
     677                async_answer_0(&call, ENOENT);
     678                async_answer_0(icall, ENOENT);
    681679                return;
    682680        }
    … …  
    684682        if (svc->server == NULL) {
    685683                fibril_mutex_unlock(&services_list_mutex);
    686                 async_answer_0(chandle, EINVAL);
    687                 async_answer_0(icall_handle, EINVAL);
     684                async_answer_0(&call, EINVAL);
     685                async_answer_0(icall, EINVAL);
    688686                return;
    689687        }
    … …  
    692690        if (act_size > size) {
    693691                fibril_mutex_unlock(&services_list_mutex);
    694                 async_answer_0(chandle, EOVERFLOW);
    695                 async_answer_0(icall_handle, EOVERFLOW);
    696                 return;
    697         }
    698 
    699         errno_t retval = async_data_read_finalize(chandle, svc->server->name,
     692                async_answer_0(&call, EOVERFLOW);
     693                async_answer_0(icall, EOVERFLOW);
     694                return;
     695        }
     696
     697        errno_t retval = async_data_read_finalize(&call, svc->server->name,
    700698            min(size, act_size));
    701699
    702700        fibril_mutex_unlock(&services_list_mutex);
    703701
    704         async_answer_0(icall_handle, retval);
     702        async_answer_0(icall, retval);
    705703}
    706704
    … …  
    711709 *
    712710 */
    713 static void loc_forward(cap_call_handle_t chandle, ipc_call_t *call, void *arg)
     711static void loc_forward(ipc_call_t *call, void *arg)
    714712{
    715713        fibril_mutex_lock(&services_list_mutex);
    … …  
    724722        if ((svc == NULL) || (svc->server == NULL) || (!svc->server->sess)) {
    725723                fibril_mutex_unlock(&services_list_mutex);
    726                 async_answer_0(chandle, ENOENT);
     724                async_answer_0(call, ENOENT);
    727725                return;
    728726        }
    729727
    730728        async_exch_t *exch = async_exchange_begin(svc->server->sess);
    731         async_forward_fast(chandle, exch, iface, svc->id, 0, IPC_FF_NONE);
     729        async_forward_fast(call, exch, iface, svc->id, 0, IPC_FF_NONE);
    732730        async_exchange_end(exch);
    733731
    … …  
    741739 *
    742740 */
    743 static void loc_service_get_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
     741static void loc_service_get_id(ipc_call_t *icall)
    744742{
    745743        char *fqsn;
    … …  
    749747            LOC_NAME_MAXLEN, 0, NULL);
    750748        if (rc != EOK) {
    751                 async_answer_0(icall_handle, rc);
     749                async_answer_0(icall, rc);
    752750                return;
    753751        }
    … …  
    757755        if (!loc_fqsn_split(fqsn, &ns_name, &name)) {
    758756                free(fqsn);
    759                 async_answer_0(icall_handle, EINVAL);
     757                async_answer_0(icall, EINVAL);
    760758                return;
    761759        }
    … …  
    784782                }
    785783
    786                 async_answer_0(icall_handle, ENOENT);
     784                async_answer_0(icall, ENOENT);
    787785                free(ns_name);
    788786                free(name);
    … …  
    791789        }
    792790
    793         async_answer_1(icall_handle, EOK, svc->id);
     791        async_answer_1(icall, EOK, svc->id);
    794792
    795793        fibril_mutex_unlock(&services_list_mutex);
    … …  
    804802 *
    805803 */
    806 static void loc_namespace_get_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
     804static void loc_namespace_get_id(ipc_call_t *icall)
    807805{
    808806        char *name;
    … …  
    812810            LOC_NAME_MAXLEN, 0, NULL);
    813811        if (rc != EOK) {
    814                 async_answer_0(icall_handle, rc);
     812                async_answer_0(icall, rc);
    815813                return;
    816814        }
    … …  
    837835                }
    838836
    839                 async_answer_0(icall_handle, ENOENT);
     837                async_answer_0(icall, ENOENT);
    840838                free(name);
    841839                fibril_mutex_unlock(&services_list_mutex);
    … …  
    843841        }
    844842
    845         async_answer_1(icall_handle, EOK, namespace->id);
     843        async_answer_1(icall, EOK, namespace->id);
    846844
    847845        fibril_mutex_unlock(&services_list_mutex);
    … …  
    858856 *
    859857 */
    860 static void loc_callback_create(cap_call_handle_t icall_handle, ipc_call_t *icall)
     858static void loc_callback_create(ipc_call_t *icall)
    861859{
    862860        cb_sess_t *cb_sess = calloc(1, sizeof(cb_sess_t));
    863861        if (cb_sess == NULL) {
    864                 async_answer_0(icall_handle, ENOMEM);
     862                async_answer_0(icall, ENOMEM);
    865863                return;
    866864        }
    … …  
    869867        if (sess == NULL) {
    870868                free(cb_sess);
    871                 async_answer_0(icall_handle, ENOMEM);
     869                async_answer_0(icall, ENOMEM);
    872870                return;
    873871        }
    … …  
    880878        fibril_mutex_unlock(&callback_sess_mutex);
    881879
    882         async_answer_0(icall_handle, EOK);
     880        async_answer_0(icall, EOK);
    883881}
    884882
    … …  
    902900 *
    903901 */
    904 static void loc_category_get_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
     902static void loc_category_get_id(ipc_call_t *icall)
    905903{
    906904        char *name;
    … …  
    911909            LOC_NAME_MAXLEN, 0, NULL);
    912910        if (rc != EOK) {
    913                 async_answer_0(icall_handle, rc);
     911                async_answer_0(icall, rc);
    914912                return;
    915913        }
    … …  
    920918        if (cat == NULL) {
    921919                /* Category not found */
    922                 async_answer_0(icall_handle, ENOENT);
     920                async_answer_0(icall, ENOENT);
    923921                goto cleanup;
    924922        }
    925923
    926         async_answer_1(icall_handle, EOK, cat->id);
     924        async_answer_1(icall, EOK, cat->id);
    927925cleanup:
    928926        fibril_mutex_unlock(&cdir.mutex);
    … …  
    930928}
    931929
    932 static void loc_id_probe(cap_call_handle_t icall_handle, ipc_call_t *icall)
     930static void loc_id_probe(ipc_call_t *icall)
    933931{
    934932        fibril_mutex_lock(&services_list_mutex);
    … …  
    940938                    loc_service_find_id(IPC_GET_ARG1(*icall));
    941939                if (svc == NULL)
    942                         async_answer_1(icall_handle, EOK, LOC_OBJECT_NONE);
     940                        async_answer_1(icall, EOK, LOC_OBJECT_NONE);
    943941                else
    944                         async_answer_1(icall_handle, EOK, LOC_OBJECT_SERVICE);
     942                        async_answer_1(icall, EOK, LOC_OBJECT_SERVICE);
    945943        } else
    946                 async_answer_1(icall_handle, EOK, LOC_OBJECT_NAMESPACE);
     944                async_answer_1(icall, EOK, LOC_OBJECT_NAMESPACE);
    947945
    948946        fibril_mutex_unlock(&services_list_mutex);
    949947}
    950948
    951 static void loc_get_namespace_count(cap_call_handle_t icall_handle, ipc_call_t *icall)
     949static void loc_get_namespace_count(ipc_call_t *icall)
    952950{
    953951        fibril_mutex_lock(&services_list_mutex);
    954         async_answer_1(icall_handle, EOK, list_count(&namespaces_list));
     952        async_answer_1(icall, EOK, list_count(&namespaces_list));
    955953        fibril_mutex_unlock(&services_list_mutex);
    956954}
    957955
    958 static void loc_get_service_count(cap_call_handle_t icall_handle, ipc_call_t *icall)
     956static void loc_get_service_count(ipc_call_t *icall)
    959957{
    960958        fibril_mutex_lock(&services_list_mutex);
    … …  
    963961            loc_namespace_find_id(IPC_GET_ARG1(*icall));
    964962        if (namespace == NULL)
    965                 async_answer_0(icall_handle, EEXIST);
     963                async_answer_0(icall, EEXIST);
    966964        else
    967                 async_answer_1(icall_handle, EOK, namespace->refcnt);
     965                async_answer_1(icall, EOK, namespace->refcnt);
    968966
    969967        fibril_mutex_unlock(&services_list_mutex);
    970968}
    971969
    972 static void loc_get_categories(cap_call_handle_t icall_handle, ipc_call_t *icall)
    973 {
    974         cap_call_handle_t chandle;
     970static void loc_get_categories(ipc_call_t *icall)
     971{
     972        ipc_call_t call;
    975973        size_t size;
    976974        size_t act_size;
    977975        errno_t rc;
    978976
    979         if (!async_data_read_receive(&chandle, &size)) {
    980                 async_answer_0(chandle, EREFUSED);
    981                 async_answer_0(icall_handle, EREFUSED);
     977        if (!async_data_read_receive(&call, &size)) {
     978                async_answer_0(&call, EREFUSED);
     979                async_answer_0(icall, EREFUSED);
    982980                return;
    983981        }
    … …  
    986984        if (id_buf == NULL) {
    987985                fibril_mutex_unlock(&cdir.mutex);
    988                 async_answer_0(chandle, ENOMEM);
    989                 async_answer_0(icall_handle, ENOMEM);
     986                async_answer_0(&call, ENOMEM);
     987                async_answer_0(icall, ENOMEM);
    990988                return;
    991989        }
    … …  
    996994        if (rc != EOK) {
    997995                fibril_mutex_unlock(&cdir.mutex);
    998                 async_answer_0(chandle, rc);
    999                 async_answer_0(icall_handle, rc);
     996                async_answer_0(&call, rc);
     997                async_answer_0(icall, rc);
    1000998                return;
    1001999        }
    … …  
    10031001        fibril_mutex_unlock(&cdir.mutex);
    10041002
    1005         errno_t retval = async_data_read_finalize(chandle, id_buf, size);
     1003        errno_t retval = async_data_read_finalize(&call, id_buf, size);
    10061004        free(id_buf);
    10071005
    1008         async_answer_1(icall_handle, retval, act_size);
    1009 }
    1010 
    1011 static void loc_get_namespaces(cap_call_handle_t icall_handle, ipc_call_t *icall)
    1012 {
    1013         cap_call_handle_t chandle;
     1006        async_answer_1(icall, retval, act_size);
     1007}
     1008
     1009static void loc_get_namespaces(ipc_call_t *icall)
     1010{
     1011        ipc_call_t call;
    10141012        size_t size;
    1015         if (!async_data_read_receive(&chandle, &size)) {
    1016                 async_answer_0(chandle, EREFUSED);
    1017                 async_answer_0(icall_handle, EREFUSED);
     1013        if (!async_data_read_receive(&call, &size)) {
     1014                async_answer_0(&call, EREFUSED);
     1015                async_answer_0(icall, EREFUSED);
    10181016                return;
    10191017        }
    10201018
    10211019        if ((size % sizeof(loc_sdesc_t)) != 0) {
    1022                 async_answer_0(chandle, EINVAL);
    1023                 async_answer_0(icall_handle, EINVAL);
     1020                async_answer_0(&call, EINVAL);
     1021                async_answer_0(icall, EINVAL);
    10241022                return;
    10251023        }
    … …  
    10301028        if (count != list_count(&namespaces_list)) {
    10311029                fibril_mutex_unlock(&services_list_mutex);
    1032                 async_answer_0(chandle, EOVERFLOW);
    1033                 async_answer_0(icall_handle, EOVERFLOW);
     1030                async_answer_0(&call, EOVERFLOW);
     1031                async_answer_0(icall, EOVERFLOW);
    10341032                return;
    10351033        }
    … …  
    10381036        if (desc == NULL) {
    10391037                fibril_mutex_unlock(&services_list_mutex);
    1040                 async_answer_0(chandle, ENOMEM);
    1041                 async_answer_0(icall_handle, ENOMEM);
     1038                async_answer_0(&call, ENOMEM);
     1039                async_answer_0(icall, ENOMEM);
    10421040                return;
    10431041        }
    … …  
    10501048        }
    10511049
    1052         errno_t retval = async_data_read_finalize(chandle, desc, size);
     1050        errno_t retval = async_data_read_finalize(&call, desc, size);
    10531051
    10541052        free(desc);
    10551053        fibril_mutex_unlock(&services_list_mutex);
    10561054
    1057         async_answer_0(icall_handle, retval);
    1058 }
    1059 
    1060 static void loc_get_services(cap_call_handle_t icall_handle, ipc_call_t *icall)
     1055        async_answer_0(icall, retval);
     1056}
     1057
     1058static void loc_get_services(ipc_call_t *icall)
    10611059{
    10621060        /*
    … …  
    10651063         */
    10661064
    1067         cap_call_handle_t chandle;
     1065        ipc_call_t call;
    10681066        size_t size;
    1069         if (!async_data_read_receive(&chandle, &size)) {
    1070                 async_answer_0(chandle, EREFUSED);
    1071                 async_answer_0(icall_handle, EREFUSED);
     1067        if (!async_data_read_receive(&call, &size)) {
     1068                async_answer_0(&call, EREFUSED);
     1069                async_answer_0(icall, EREFUSED);
    10721070                return;
    10731071        }
    10741072
    10751073        if ((size % sizeof(loc_sdesc_t)) != 0) {
    1076                 async_answer_0(chandle, EINVAL);
    1077                 async_answer_0(icall_handle, EINVAL);
     1074                async_answer_0(&call, EINVAL);
     1075                async_answer_0(icall, EINVAL);
    10781076                return;
    10791077        }
    … …  
    10851083        if (namespace == NULL) {
    10861084                fibril_mutex_unlock(&services_list_mutex);
    1087                 async_answer_0(chandle, ENOENT);
    1088                 async_answer_0(icall_handle, ENOENT);
     1085                async_answer_0(&call, ENOENT);
     1086                async_answer_0(icall, ENOENT);
    10891087                return;
    10901088        }
    … …  
    10931091        if (count != namespace->refcnt) {
    10941092                fibril_mutex_unlock(&services_list_mutex);
    1095                 async_answer_0(chandle, EOVERFLOW);
    1096                 async_answer_0(icall_handle, EOVERFLOW);
     1093                async_answer_0(&call, EOVERFLOW);
     1094                async_answer_0(icall, EOVERFLOW);
    10971095                return;
    10981096        }
    … …  
    11011099        if (desc == NULL) {
    11021100                fibril_mutex_unlock(&services_list_mutex);
    1103                 async_answer_0(chandle, ENOMEM);
    1104                 async_answer_0(icall_handle, EREFUSED);
     1101                async_answer_0(&call, ENOMEM);
     1102                async_answer_0(icall, EREFUSED);
    11051103                return;
    11061104        }
    … …  
    11151113        }
    11161114
    1117         errno_t retval = async_data_read_finalize(chandle, desc, size);
     1115        errno_t retval = async_data_read_finalize(&call, desc, size);
    11181116
    11191117        free(desc);
    11201118        fibril_mutex_unlock(&services_list_mutex);
    11211119
    1122         async_answer_0(icall_handle, retval);
    1123 }
    1124 
    1125 static void loc_category_get_svcs(cap_call_handle_t icall_handle, ipc_call_t *icall)
    1126 {
    1127         cap_call_handle_t chandle;
     1120        async_answer_0(icall, retval);
     1121}
     1122
     1123static void loc_category_get_svcs(ipc_call_t *icall)
     1124{
     1125        ipc_call_t call;
    11281126        size_t size;
    11291127        size_t act_size;
    11301128        errno_t rc;
    11311129
    1132         if (!async_data_read_receive(&chandle, &size)) {
    1133                 async_answer_0(chandle, EREFUSED);
    1134                 async_answer_0(icall_handle, EREFUSED);
     1130        if (!async_data_read_receive(&call, &size)) {
     1131                async_answer_0(&call, EREFUSED);
     1132                async_answer_0(icall, EREFUSED);
    11351133                return;
    11361134        }
    … …  
    11411139        if (cat == NULL) {
    11421140                fibril_mutex_unlock(&cdir.mutex);
    1143                 async_answer_0(chandle, ENOENT);
    1144                 async_answer_0(icall_handle, ENOENT);
     1141                async_answer_0(&call, ENOENT);
     1142                async_answer_0(icall, ENOENT);
    11451143                return;
    11461144        }
    … …  
    11491147        if (id_buf == NULL) {
    11501148                fibril_mutex_unlock(&cdir.mutex);
    1151                 async_answer_0(chandle, ENOMEM);
    1152                 async_answer_0(icall_handle, ENOMEM);
     1149                async_answer_0(&call, ENOMEM);
     1150                async_answer_0(icall, ENOMEM);
    11531151                return;
    11541152        }
    … …  
    11601158                fibril_mutex_unlock(&cat->mutex);
    11611159                fibril_mutex_unlock(&cdir.mutex);
    1162                 async_answer_0(chandle, rc);
    1163                 async_answer_0(icall_handle, rc);
     1160                async_answer_0(&call, rc);
     1161                async_answer_0(icall, rc);
    11641162                return;
    11651163        }
    … …  
    11681166        fibril_mutex_unlock(&cdir.mutex);
    11691167
    1170         errno_t retval = async_data_read_finalize(chandle, id_buf, size);
     1168        errno_t retval = async_data_read_finalize(&call, id_buf, size);
    11711169        free(id_buf);
    11721170
    1173         async_answer_1(icall_handle, retval, act_size);
    1174 }
    1175 
    1176 
    1177 static void loc_null_create(cap_call_handle_t icall_handle, ipc_call_t *icall)
     1171        async_answer_1(icall, retval, act_size);
     1172}
     1173
     1174
     1175static void loc_null_create(ipc_call_t *icall)
    11781176{
    11791177        fibril_mutex_lock(&null_services_mutex);
    … …  
    11911189        if (!fnd) {
    11921190                fibril_mutex_unlock(&null_services_mutex);
    1193                 async_answer_0(icall_handle, ENOMEM);
     1191                async_answer_0(icall, ENOMEM);
    11941192                return;
    11951193        }
    … …  
    12011199        if (dev_name == NULL) {
    12021200                fibril_mutex_unlock(&null_services_mutex);
    1203                 async_answer_0(icall_handle, ENOMEM);
     1201                async_answer_0(icall, ENOMEM);
    12041202                return;
    12051203        }
    … …  
    12091207        if (service == NULL) {
    12101208                fibril_mutex_unlock(&null_services_mutex);
    1211                 async_answer_0(icall_handle, ENOMEM);
     1209                async_answer_0(icall, ENOMEM);
    12121210                return;
    12131211        }
    … …  
    12191217                fibril_mutex_lock(&services_list_mutex);
    12201218                fibril_mutex_unlock(&null_services_mutex);
    1221                 async_answer_0(icall_handle, ENOMEM);
     1219                async_answer_0(icall, ENOMEM);
    12221220                return;
    12231221        }
    … …  
    12461244        fibril_mutex_unlock(&null_services_mutex);
    12471245
    1248         async_answer_1(icall_handle, EOK, (sysarg_t) i);
    1249 }
    1250 
    1251 static void loc_null_destroy(cap_call_handle_t icall_handle, ipc_call_t *icall)
     1246        async_answer_1(icall, EOK, (sysarg_t) i);
     1247}
     1248
     1249static void loc_null_destroy(ipc_call_t *icall)
    12521250{
    12531251        sysarg_t i = IPC_GET_ARG1(*icall);
    12541252        if (i >= NULL_SERVICES) {
    1255                 async_answer_0(icall_handle, ELIMIT);
     1253                async_answer_0(icall, ELIMIT);
    12561254                return;
    12571255        }
    … …  
    12611259        if (null_services[i] == NULL) {
    12621260                fibril_mutex_unlock(&null_services_mutex);
    1263                 async_answer_0(icall_handle, ENOENT);
     1261                async_answer_0(icall, ENOENT);
    12641262                return;
    12651263        }
    … …  
    12741272
    12751273        fibril_mutex_unlock(&null_services_mutex);
    1276         async_answer_0(icall_handle, EOK);
    1277 }
    1278 
    1279 static void loc_service_add_to_cat(cap_call_handle_t icall_handle, ipc_call_t *icall)
     1274        async_answer_0(icall, EOK);
     1275}
     1276
     1277static void loc_service_add_to_cat(ipc_call_t *icall)
    12801278{
    12811279        category_t *cat;
    … …  
    12971295                fibril_mutex_unlock(&cdir.mutex);
    12981296                fibril_mutex_unlock(&services_list_mutex);
    1299                 async_answer_0(icall_handle, ENOENT);
     1297                async_answer_0(icall, ENOENT);
    13001298                return;
    13011299        }
    … …  
    13141312         */
    13151313        loc_category_change_event();
    1316         async_answer_0(icall_handle, retval);
     1314        async_answer_0(icall, retval);
    13171315}
    13181316
    … …  
    13981396 *
    13991397 */
    1400 static void loc_connection_supplier(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     1398static void loc_connection_supplier(ipc_call_t *icall, void *arg)
    14011399{
    14021400        /* Accept connection */
    1403         async_answer_0(icall_handle, EOK);
     1401        async_answer_0(icall, EOK);
    14041402
    14051403        loc_server_t *server = loc_server_register();
    … …  
    14091407        while (true) {
    14101408                ipc_call_t call;
    1411                 cap_call_handle_t chandle = async_get_call(&call);
     1409                async_get_call(&call);
    14121410
    14131411                if (!IPC_GET_IMETHOD(call))
    … …  
    14171415                case LOC_SERVER_UNREGISTER:
    14181416                        if (server == NULL)
    1419                                 async_answer_0(chandle, ENOENT);
     1417                                async_answer_0(&call, ENOENT);
    14201418                        else
    1421                                 async_answer_0(chandle, EOK);
     1419                                async_answer_0(&call, EOK);
    14221420                        break;
    14231421                case LOC_SERVICE_ADD_TO_CAT:
    14241422                        /* Add service to category */
    1425                         loc_service_add_to_cat(chandle, &call);
     1423                        loc_service_add_to_cat(&call);
    14261424                        break;
    14271425                case LOC_SERVICE_REGISTER:
    14281426                        /* Register one service */
    1429                         loc_service_register(chandle, &call, server);
     1427                        loc_service_register(&call, server);
    14301428                        break;
    14311429                case LOC_SERVICE_UNREGISTER:
    14321430                        /* Remove one service */
    1433                         loc_service_unregister(chandle, &call, server);
     1431                        loc_service_unregister(&call, server);
    14341432                        break;
    14351433                case LOC_SERVICE_GET_ID:
    1436                         loc_service_get_id(chandle, &call);
     1434                        loc_service_get_id(&call);
    14371435                        break;
    14381436                case LOC_NAMESPACE_GET_ID:
    1439                         loc_namespace_get_id(chandle, &call);
     1437                        loc_namespace_get_id(&call);
    14401438                        break;
    14411439                default:
    1442                         async_answer_0(chandle, ENOENT);
     1440                        async_answer_0(&call, ENOENT);
    14431441                }
    14441442        }
    … …  
    14561454 *
    14571455 */
    1458 static void loc_connection_consumer(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     1456static void loc_connection_consumer(ipc_call_t *icall, void *arg)
    14591457{
    14601458        /* Accept connection */
    1461         async_answer_0(icall_handle, EOK);
     1459        async_answer_0(icall, EOK);
    14621460
    14631461        while (true) {
    14641462                ipc_call_t call;
    1465                 cap_call_handle_t chandle = async_get_call(&call);
     1463                async_get_call(&call);
    14661464
    14671465                if (!IPC_GET_IMETHOD(call))
    … …  
    14701468                switch (IPC_GET_IMETHOD(call)) {
    14711469                case LOC_SERVICE_GET_ID:
    1472                         loc_service_get_id(chandle, &call);
     1470                        loc_service_get_id(&call);
    14731471                        break;
    14741472                case LOC_SERVICE_GET_NAME:
    1475                         loc_service_get_name(chandle, &call);
     1473                        loc_service_get_name(&call);
    14761474                        break;
    14771475                case LOC_SERVICE_GET_SERVER_NAME:
    1478                         loc_service_get_server_name(chandle, &call);
     1476                        loc_service_get_server_name(&call);
    14791477                        break;
    14801478                case LOC_NAMESPACE_GET_ID:
    1481                         loc_namespace_get_id(chandle, &call);
     1479                        loc_namespace_get_id(&call);
    14821480                        break;
    14831481                case LOC_CALLBACK_CREATE:
    1484                         loc_callback_create(chandle, &call);
     1482                        loc_callback_create(&call);
    14851483                        break;
    14861484                case LOC_CATEGORY_GET_ID:
    1487                         loc_category_get_id(chandle, &call);
     1485                        loc_category_get_id(&call);
    14881486                        break;
    14891487                case LOC_CATEGORY_GET_NAME:
    1490                         loc_category_get_name(chandle, &call);
     1488                        loc_category_get_name(&call);
    14911489                        break;
    14921490                case LOC_CATEGORY_GET_SVCS:
    1493                         loc_category_get_svcs(chandle, &call);
     1491                        loc_category_get_svcs(&call);
    14941492                        break;
    14951493                case LOC_ID_PROBE:
    1496                         loc_id_probe(chandle, &call);
     1494                        loc_id_probe(&call);
    14971495                        break;
    14981496                case LOC_NULL_CREATE:
    1499                         loc_null_create(chandle, &call);
     1497                        loc_null_create(&call);
    15001498                        break;
    15011499                case LOC_NULL_DESTROY:
    1502                         loc_null_destroy(chandle, &call);
     1500                        loc_null_destroy(&call);
    15031501                        break;
    15041502                case LOC_GET_NAMESPACE_COUNT:
    1505                         loc_get_namespace_count(chandle, &call);
     1503                        loc_get_namespace_count(&call);
    15061504                        break;
    15071505                case LOC_GET_SERVICE_COUNT:
    1508                         loc_get_service_count(chandle, &call);
     1506                        loc_get_service_count(&call);
    15091507                        break;
    15101508                case LOC_GET_CATEGORIES:
    1511                         loc_get_categories(chandle, &call);
     1509                        loc_get_categories(&call);
    15121510                        break;
    15131511                case LOC_GET_NAMESPACES:
    1514                         loc_get_namespaces(chandle, &call);
     1512                        loc_get_namespaces(&call);
    15151513                        break;
    15161514                case LOC_GET_SERVICES:
    1517                         loc_get_services(chandle, &call);
     1515                        loc_get_services(&call);
    15181516                        break;
    15191517                default:
    1520                         async_answer_0(chandle, ENOENT);
     1518                        async_answer_0(&call, ENOENT);
    15211519                }
    15221520        }
Note: See TracChangeset for help on using the changeset viewer.