Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r2a09dcb r7d7f5e3  
    11/*
     2 * Copyright (c) 2023 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 sid  Service ID of new service
     261 *
     262 */
     263errno_t loc_service_register(loc_srv_t *srv, const char *fqsn,
     264    service_id_t *sid)
     265{
     266        async_exch_t *exch = async_exchange_begin(srv->sess);
    279267        ipc_call_t answer;
    280268        aid_t req = async_send_0(exch, LOC_SERVICE_REGISTER, &answer);
    … …  
    283271        if (retval != EOK) {
    284272                async_forget(req);
    285                 loc_exchange_end(exch);
     273                async_exchange_end(exch);
    286274                return retval;
    287275        }
    … …  
    293281         */
    294282        async_wait_for(req, &retval);
    295         loc_exchange_end(exch);
     283        async_exchange_end(exch);
    296284
    297285        if (retval != EOK) {
    … …  
    310298/** Unregister service.
    311299 *
    312  * @param sid   Service ID
    313  */
    314 errno_t loc_service_unregister(service_id_t sid)
     300 * @param srv Server object
     301 * @param sid Service ID
     302 */
     303errno_t loc_service_unregister(loc_srv_t *srv, service_id_t sid)
    315304{
    316305        async_exch_t *exch;
    317306        errno_t retval;
    318307
    319         exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
     308        exch = async_exchange_begin(srv->sess);
    320309        retval = async_req_1_0(exch, LOC_SERVICE_UNREGISTER, sid);
    321         loc_exchange_end(exch);
     310        async_exchange_end(exch);
    322311
    323312        return (errno_t)retval;
    … …  
    330319
    331320        if (flags & IPC_FLAG_BLOCKING)
    332                 exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     321                exch = loc_exchange_begin_blocking();
    333322        else {
    334                 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
     323                exch = loc_exchange_begin();
    335324                if (exch == NULL)
    336325                        return errno;
    … …  
    383372
    384373        *name = NULL;
    385         exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     374        exch = loc_exchange_begin_blocking();
    386375
    387376        ipc_call_t answer;
    … …  
    463452
    464453        if (flags & IPC_FLAG_BLOCKING)
    465                 exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     454                exch = loc_exchange_begin_blocking();
    466455        else {
    467                 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
     456                exch = loc_exchange_begin();
    468457                if (exch == NULL)
    469458                        return errno;
    … …  
    512501
    513502        if (flags & IPC_FLAG_BLOCKING)
    514                 exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     503                exch = loc_exchange_begin_blocking();
    515504        else {
    516                 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
     505                exch = loc_exchange_begin();
    517506                if (exch == NULL)
    518507                        return errno;
    … …  
    548537loc_object_type_t loc_id_probe(service_id_t handle)
    549538{
    550         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     539        async_exch_t *exch = loc_exchange_begin_blocking();
    551540
    552541        sysarg_t type;
    … …  
    579568int loc_null_create(void)
    580569{
    581         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     570        async_exch_t *exch = loc_exchange_begin_blocking();
    582571
    583572        sysarg_t null_id;
    … …  
    594583void loc_null_destroy(int null_id)
    595584{
    596         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     585        async_exch_t *exch = loc_exchange_begin_blocking();
    597586        async_req_1_0(exch, LOC_NULL_DESTROY, (sysarg_t) null_id);
    598587        loc_exchange_end(exch);
    … …  
    611600/** Add service to category.
    612601 *
    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)
     602 * @param srv    Server object
     603 * @param svc_id Service ID
     604 * @param cat_id Category ID
     605 *
     606 * @return EOK on success or an error code
     607 */
     608errno_t loc_service_add_to_cat(loc_srv_t *srv, service_id_t svc_id,
     609    service_id_t cat_id)
    618610{
    619611        async_exch_t *exch;
    620612        errno_t retval;
    621613
    622         exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
     614        exch = async_exchange_begin(srv->sess);
    623615        retval = async_req_2_0(exch, LOC_SERVICE_ADD_TO_CAT, svc_id, cat_id);
    624         loc_exchange_end(exch);
     616        async_exchange_end(exch);
    625617
    626618        return retval;
    … …  
    641633size_t loc_count_namespaces(void)
    642634{
    643         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     635        async_exch_t *exch = loc_exchange_begin_blocking();
    644636        size_t size = loc_count_namespaces_internal(exch);
    645637        loc_exchange_end(exch);
    … …  
    650642size_t loc_count_services(service_id_t ns_handle)
    651643{
    652         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     644        async_exch_t *exch = loc_exchange_begin_blocking();
    653645        size_t size = loc_count_services_internal(exch, ns_handle);
    654646        loc_exchange_end(exch);
    … …  
    661653        /* Loop until read is succesful */
    662654        while (true) {
    663                 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     655                async_exch_t *exch = loc_exchange_begin_blocking();
    664656                size_t count = loc_count_namespaces_internal(exch);
    665657                loc_exchange_end(exch);
    … …  
    672664                        return 0;
    673665
    674                 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
     666                exch = loc_exchange_begin();
    675667
    676668                ipc_call_t answer;
    … …  
    710702        /* Loop until read is succesful */
    711703        while (true) {
    712                 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     704                async_exch_t *exch = loc_exchange_begin_blocking();
    713705                size_t count = loc_count_services_internal(exch, ns_handle);
    714706                loc_exchange_end(exch);
    … …  
    721713                        return 0;
    722714
    723                 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
     715                exch = loc_exchange_begin();
    724716
    725717                ipc_call_t answer;
    … …  
    758750    sysarg_t *id_buf, size_t buf_size, size_t *act_size)
    759751{
    760         async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
     752        async_exch_t *exch = loc_exchange_begin_blocking();
    761753
    762754        ipc_call_t answer;
Note: See TracChangeset for help on using the changeset viewer.