Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/loc.c

    r2a09dcb rca48672  
    11/*
     2 * Copyright (c) 2025 Jiri Svoboda
    23 * Copyright (c) 2007 Josef Cejka
    3  * Copyright (c) 2011 Jiri Svoboda
    44 * All rights reserved.
    55 *
    … …  
    3939#include <stdbool.h>
    4040
    41 static FIBRIL_MUTEX_INITIALIZE(loc_supp_block_mutex);
    4241static FIBRIL_MUTEX_INITIALIZE(loc_cons_block_mutex);
    43 
    44 static FIBRIL_MUTEX_INITIALIZE(loc_supplier_mutex);
    4542static FIBRIL_MUTEX_INITIALIZE(loc_consumer_mutex);
    4643
    … …  
    5047static void *cat_change_arg = NULL;
    5148
    52 static async_sess_t *loc_supp_block_sess = NULL;
    5349static async_sess_t *loc_cons_block_sess = NULL;
    54 
    55 static async_sess_t *loc_supplier_sess = NULL;
    5650static async_sess_t *loc_consumer_sess = NULL;
    5751
    … …  
    108102        if (!loc_callback_created) {
    109103                async_exch_t *exch =
    110                     loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     104                    loc_exchange_begin_blocking();
    111105
    112106                ipc_call_t answer;
    … …  
    135129/** Start an async exchange on the loc session (blocking).
    136130 *
    137  * @param iface Location service interface to choose
    138  *
    139131 * @return New exchange.
    140132 *
    141133 */
    142 async_exch_t *loc_exchange_begin_blocking(iface_t iface)
    143 {
    144         switch (iface) {
    145         case INTERFACE_LOC_SUPPLIER:
    146                 fibril_mutex_lock(&loc_supp_block_mutex);
    147 
    148                 while (loc_supp_block_sess == NULL) {
    149                         clone_session(&loc_supplier_mutex, loc_supplier_sess,
    150                             &loc_supp_block_sess);
    151 
    152                         if (loc_supp_block_sess == NULL)
    153                                 loc_supp_block_sess =
    154                                     service_connect_blocking(SERVICE_LOC,
    155                                     INTERFACE_LOC_SUPPLIER, 0, NULL);
    156                 }
    157 
    158                 fibril_mutex_unlock(&loc_supp_block_mutex);
    159 
    160                 clone_session(&loc_supplier_mutex, loc_supp_block_sess,
    161                     &loc_supplier_sess);
    162 
    163                 return async_exchange_begin(loc_supp_block_sess);
    164         case INTERFACE_LOC_CONSUMER:
    165                 fibril_mutex_lock(&loc_cons_block_mutex);
    166 
    167                 while (loc_cons_block_sess == NULL) {
    168                         clone_session(&loc_consumer_mutex, loc_consumer_sess,
    169                             &loc_cons_block_sess);
    170 
    171                         if (loc_cons_block_sess == NULL)
    172                                 loc_cons_block_sess =
    173                                     service_connect_blocking(SERVICE_LOC,
    174                                     INTERFACE_LOC_CONSUMER, 0, NULL);
    175                 }
    176 
    177                 fibril_mutex_unlock(&loc_cons_block_mutex);
    178 
    179                 clone_session(&loc_consumer_mutex, loc_cons_block_sess,
    180                     &loc_consumer_sess);
    181 
    182                 return async_exchange_begin(loc_cons_block_sess);
    183         default:
     134async_exch_t *loc_exchange_begin_blocking(void)
     135{
     136        fibril_mutex_lock(&loc_cons_block_mutex);
     137
     138        while (loc_cons_block_sess == NULL) {
     139                clone_session(&loc_consumer_mutex, loc_consumer_sess,
     140                    &loc_cons_block_sess);
     141
     142                if (loc_cons_block_sess == NULL)
     143                        loc_cons_block_sess =
     144                            service_connect_blocking(SERVICE_LOC,
     145                            INTERFACE_LOC_CONSUMER, 0, NULL);
     146        }
     147
     148        fibril_mutex_unlock(&loc_cons_block_mutex);
     149
     150        clone_session(&loc_consumer_mutex, loc_cons_block_sess,
     151            &loc_consumer_sess);
     152
     153        return async_exchange_begin(loc_cons_block_sess);
     154}
     155
     156/** Start an async exchange on the loc session.
     157 *
     158 * @return New exchange.
     159 *
     160 */
     161async_exch_t *loc_exchange_begin(void)
     162{
     163        fibril_mutex_lock(&loc_consumer_mutex);
     164
     165        if (loc_consumer_sess == NULL)
     166                loc_consumer_sess =
     167                    service_connect(SERVICE_LOC,
     168                    INTERFACE_LOC_CONSUMER, 0, NULL);
     169
     170        fibril_mutex_unlock(&loc_consumer_mutex);
     171
     172        if (loc_consumer_sess == NULL)
    184173                return NULL;
    185         }
    186 }
    187 
    188 /** Start an async exchange on the loc session.
    189  *
    190  * @param iface Location service interface to choose
    191  *
    192  * @return New exchange.
    193  *
    194  */
    195 async_exch_t *loc_exchange_begin(iface_t iface)
    196 {
    197         switch (iface) {
    198         case INTERFACE_LOC_SUPPLIER:
    199                 fibril_mutex_lock(&loc_supplier_mutex);
    200 
    201                 if (loc_supplier_sess == NULL)
    202                         loc_supplier_sess =
    203                             service_connect(SERVICE_LOC,
    204                             INTERFACE_LOC_SUPPLIER, 0, NULL);
    205 
    206                 fibril_mutex_unlock(&loc_supplier_mutex);
    207 
    208                 if (loc_supplier_sess == NULL)
    209                         return NULL;
    210 
    211                 return async_exchange_begin(loc_supplier_sess);
    212         case INTERFACE_LOC_CONSUMER:
    213                 fibril_mutex_lock(&loc_consumer_mutex);
    214 
    215                 if (loc_consumer_sess == NULL)
    216                         loc_consumer_sess =
    217                             service_connect(SERVICE_LOC,
    218                             INTERFACE_LOC_CONSUMER, 0, NULL);
    219 
    220                 fibril_mutex_unlock(&loc_consumer_mutex);
    221 
    222                 if (loc_consumer_sess == NULL)
    223                         return NULL;
    224 
    225                 return async_exchange_begin(loc_consumer_sess);
    226         default:
    227                 return NULL;
    228         }
     174
     175        return async_exchange_begin(loc_consumer_sess);
    229176}
    230177
    … …  
    239186}
    240187
    241 /** Register new server with loc. */
    242 errno_t loc_server_register(const char *name)
    243 {
    244         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
     188/** Register new server with loc.
     189 *
     190 * @param name Server name
     191 * @param rsrv Place to store new server object on success
     192 * @return EOK on succes or an error code
     193 */
     194errno_t loc_server_register(const char *name, loc_srv_t **rsrv)
     195{
     196        async_exch_t *exch;
     197        loc_srv_t *srv;
     198
     199        srv = calloc(1, sizeof(loc_srv_t));
     200        if (srv == NULL)
     201                return ENOMEM;
     202
     203        srv->sess = service_connect_blocking(SERVICE_LOC,
     204            INTERFACE_LOC_SUPPLIER, 0, NULL);
     205        if (srv->sess == NULL) {
     206                free(srv);
     207                return ENOMEM;
     208        }
     209
     210        exch = async_exchange_begin(srv->sess);
    245211
    246212        ipc_call_t answer;
    … …  
    250216        if (retval != EOK) {
    251217                async_forget(req);
    252                 loc_exchange_end(exch);
     218                async_exchange_end(exch);
     219                async_hangup(srv->sess);
     220                free(srv);
    253221                return retval;
    254222        }
    … …  
    262230         */
    263231        async_wait_for(req, &retval);
    264         loc_exchange_end(exch);
    265 
     232        async_exchange_end(exch);
     233
     234        if (retval != EOK) {
     235                async_hangup(srv->sess);
     236                free(srv);
     237                return retval;
     238        }
     239
     240        *rsrv = srv;
    266241        return retval;
    267242}
    268243
     244/** Unregister server from loc.
     245 *
     246 * Unregister server and free server object.
     247 *
     248 * @param srv Server object
     249 */
     250void loc_server_unregister(loc_srv_t *srv)
     251{
     252        async_hangup(srv->sess);
     253        free(srv);
     254}
     255
    269256/** Register new service.
    270257 *
    271  * @param      fqsn  Fully qualified service name
    272  * @param[out] sid   Service ID of new service
    273  *
    274  */
    275 errno_t loc_service_register(const char *fqsn, service_id_t *sid)
    276 {
    277         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    278 
     258 * @param srv Server object
     259 * @param fqsn Fully qualified service name
     260 * @param portid ID of port providing the service
     261 * @param sid  Service ID of new service
     262 *
     263 */
     264errno_t loc_service_register(loc_srv_t *srv, const char *fqsn,
     265    port_id_t portid, service_id_t *sid)
     266{
     267        async_exch_t *exch = async_exchange_begin(srv->sess);
    279268        ipc_call_t answer;
    280         aid_t req = async_send_0(exch, LOC_SERVICE_REGISTER, &answer);
     269        aid_t req = async_send_1(exch, LOC_SERVICE_REGISTER, portid, &answer);
    281270        errno_t retval = async_data_write_start(exch, fqsn, str_size(fqsn));
    282271
    283272        if (retval != EOK) {
    284273                async_forget(req);
    285                 loc_exchange_end(exch);
     274                async_exchange_end(exch);
    286275                return retval;
    287276        }
    … …  
    293282         */
    294283        async_wait_for(req, &retval);
    295         loc_exchange_end(exch);
     284        async_exchange_end(exch);
    296285
    297286        if (retval != EOK) {
    … …  
    310299/** Unregister service.
    311300 *
    312  * @param sid   Service ID
    313  */
    314 errno_t loc_service_unregister(service_id_t sid)
     301 * @param srv Server object
     302 * @param sid Service ID
     303 */
     304errno_t loc_service_unregister(loc_srv_t *srv, service_id_t sid)
    315305{
    316306        async_exch_t *exch;
    317307        errno_t retval;
    318308
    319         exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
     309        exch = async_exchange_begin(srv->sess);
    320310        retval = async_req_1_0(exch, LOC_SERVICE_UNREGISTER, sid);
    321         loc_exchange_end(exch);
     311        async_exchange_end(exch);
    322312
    323313        return (errno_t)retval;
    … …  
    330320
    331321        if (flags & IPC_FLAG_BLOCKING)
    332                 exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     322                exch = loc_exchange_begin_blocking();
    333323        else {
    334                 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
     324                exch = loc_exchange_begin();
    335325                if (exch == NULL)
    336326                        return errno;
    … …  
    383373
    384374        *name = NULL;
    385         exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     375        exch = loc_exchange_begin_blocking();
    386376
    387377        ipc_call_t answer;
    … …  
    463453
    464454        if (flags & IPC_FLAG_BLOCKING)
    465                 exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     455                exch = loc_exchange_begin_blocking();
    466456        else {
    467                 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
     457                exch = loc_exchange_begin();
    468458                if (exch == NULL)
    469459                        return errno;
    … …  
    512502
    513503        if (flags & IPC_FLAG_BLOCKING)
    514                 exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     504                exch = loc_exchange_begin_blocking();
    515505        else {
    516                 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
     506                exch = loc_exchange_begin();
    517507                if (exch == NULL)
    518508                        return errno;
    … …  
    548538loc_object_type_t loc_id_probe(service_id_t handle)
    549539{
    550         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     540        async_exch_t *exch = loc_exchange_begin_blocking();
    551541
    552542        sysarg_t type;
    … …  
    579569int loc_null_create(void)
    580570{
    581         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     571        async_exch_t *exch = loc_exchange_begin_blocking();
    582572
    583573        sysarg_t null_id;
    … …  
    594584void loc_null_destroy(int null_id)
    595585{
    596         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     586        async_exch_t *exch = loc_exchange_begin_blocking();
    597587        async_req_1_0(exch, LOC_NULL_DESTROY, (sysarg_t) null_id);
    598588        loc_exchange_end(exch);
    … …  
    611601/** Add service to category.
    612602 *
    613  * @param svc_id        Service ID
    614  * @param cat_id        Category ID
    615  * @return              EOK on success or an error code
    616  */
    617 errno_t loc_service_add_to_cat(service_id_t svc_id, service_id_t cat_id)
     603 * @param srv    Server object
     604 * @param svc_id Service ID
     605 * @param cat_id Category ID
     606 *
     607 * @return EOK on success or an error code
     608 */
     609errno_t loc_service_add_to_cat(loc_srv_t *srv, service_id_t svc_id,
     610    service_id_t cat_id)
    618611{
    619612        async_exch_t *exch;
    620613        errno_t retval;
    621614
    622         exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
     615        exch = async_exchange_begin(srv->sess);
    623616        retval = async_req_2_0(exch, LOC_SERVICE_ADD_TO_CAT, svc_id, cat_id);
    624         loc_exchange_end(exch);
     617        async_exchange_end(exch);
    625618
    626619        return retval;
    … …  
    641634size_t loc_count_namespaces(void)
    642635{
    643         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     636        async_exch_t *exch = loc_exchange_begin_blocking();
    644637        size_t size = loc_count_namespaces_internal(exch);
    645638        loc_exchange_end(exch);
    … …  
    650643size_t loc_count_services(service_id_t ns_handle)
    651644{
    652         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     645        async_exch_t *exch = loc_exchange_begin_blocking();
    653646        size_t size = loc_count_services_internal(exch, ns_handle);
    654647        loc_exchange_end(exch);
    … …  
    661654        /* Loop until read is succesful */
    662655        while (true) {
    663                 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     656                async_exch_t *exch = loc_exchange_begin_blocking();
    664657                size_t count = loc_count_namespaces_internal(exch);
    665658                loc_exchange_end(exch);
    … …  
    672665                        return 0;
    673666
    674                 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
     667                exch = loc_exchange_begin();
    675668
    676669                ipc_call_t answer;
    … …  
    710703        /* Loop until read is succesful */
    711704        while (true) {
    712                 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     705                async_exch_t *exch = loc_exchange_begin_blocking();
    713706                size_t count = loc_count_services_internal(exch, ns_handle);
    714707                loc_exchange_end(exch);
    … …  
    721714                        return 0;
    722715
    723                 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
     716                exch = loc_exchange_begin();
    724717
    725718                ipc_call_t answer;
    … …  
    758751    sysarg_t *id_buf, size_t buf_size, size_t *act_size)
    759752{
    760         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     753        async_exch_t *exch = loc_exchange_begin_blocking();
    761754
    762755        ipc_call_t answer;
Note: See TracChangeset for help on using the changeset viewer.