Changes in uspace/lib/c/generic/loc.c [2a09dcb:7d7f5e3] in mainline
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/c/generic/loc.c
r2a09dcb r7d7f5e3 1 1 /* 2 * Copyright (c) 2023 Jiri Svoboda 2 3 * Copyright (c) 2007 Josef Cejka 3 * Copyright (c) 2011 Jiri Svoboda4 4 * All rights reserved. 5 5 * … … 39 39 #include <stdbool.h> 40 40 41 static FIBRIL_MUTEX_INITIALIZE(loc_supp_block_mutex);42 41 static FIBRIL_MUTEX_INITIALIZE(loc_cons_block_mutex); 43 44 static FIBRIL_MUTEX_INITIALIZE(loc_supplier_mutex);45 42 static FIBRIL_MUTEX_INITIALIZE(loc_consumer_mutex); 46 43 … … 50 47 static void *cat_change_arg = NULL; 51 48 52 static async_sess_t *loc_supp_block_sess = NULL;53 49 static async_sess_t *loc_cons_block_sess = NULL; 54 55 static async_sess_t *loc_supplier_sess = NULL;56 50 static async_sess_t *loc_consumer_sess = NULL; 57 51 … … 108 102 if (!loc_callback_created) { 109 103 async_exch_t *exch = 110 loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);104 loc_exchange_begin_blocking(); 111 105 112 106 ipc_call_t answer; … … 135 129 /** Start an async exchange on the loc session (blocking). 136 130 * 137 * @param iface Location service interface to choose138 *139 131 * @return New exchange. 140 132 * 141 133 */ 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: 134 async_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 */ 161 async_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) 184 173 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); 229 176 } 230 177 … … 239 186 } 240 187 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 */ 194 errno_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); 245 211 246 212 ipc_call_t answer; … … 250 216 if (retval != EOK) { 251 217 async_forget(req); 252 loc_exchange_end(exch); 218 async_exchange_end(exch); 219 async_hangup(srv->sess); 220 free(srv); 253 221 return retval; 254 222 } … … 262 230 */ 263 231 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; 266 241 return retval; 267 242 } 268 243 244 /** Unregister server from loc. 245 * 246 * Unregister server and free server object. 247 * 248 * @param srv Server object 249 */ 250 void loc_server_unregister(loc_srv_t *srv) 251 { 252 async_hangup(srv->sess); 253 free(srv); 254 } 255 269 256 /** Register new service. 270 257 * 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 */ 263 errno_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); 279 267 ipc_call_t answer; 280 268 aid_t req = async_send_0(exch, LOC_SERVICE_REGISTER, &answer); … … 283 271 if (retval != EOK) { 284 272 async_forget(req); 285 loc_exchange_end(exch);273 async_exchange_end(exch); 286 274 return retval; 287 275 } … … 293 281 */ 294 282 async_wait_for(req, &retval); 295 loc_exchange_end(exch);283 async_exchange_end(exch); 296 284 297 285 if (retval != EOK) { … … 310 298 /** Unregister service. 311 299 * 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 */ 303 errno_t loc_service_unregister(loc_srv_t *srv, service_id_t sid) 315 304 { 316 305 async_exch_t *exch; 317 306 errno_t retval; 318 307 319 exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);308 exch = async_exchange_begin(srv->sess); 320 309 retval = async_req_1_0(exch, LOC_SERVICE_UNREGISTER, sid); 321 loc_exchange_end(exch);310 async_exchange_end(exch); 322 311 323 312 return (errno_t)retval; … … 330 319 331 320 if (flags & IPC_FLAG_BLOCKING) 332 exch = loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);321 exch = loc_exchange_begin_blocking(); 333 322 else { 334 exch = loc_exchange_begin( INTERFACE_LOC_CONSUMER);323 exch = loc_exchange_begin(); 335 324 if (exch == NULL) 336 325 return errno; … … 383 372 384 373 *name = NULL; 385 exch = loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);374 exch = loc_exchange_begin_blocking(); 386 375 387 376 ipc_call_t answer; … … 463 452 464 453 if (flags & IPC_FLAG_BLOCKING) 465 exch = loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);454 exch = loc_exchange_begin_blocking(); 466 455 else { 467 exch = loc_exchange_begin( INTERFACE_LOC_CONSUMER);456 exch = loc_exchange_begin(); 468 457 if (exch == NULL) 469 458 return errno; … … 512 501 513 502 if (flags & IPC_FLAG_BLOCKING) 514 exch = loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);503 exch = loc_exchange_begin_blocking(); 515 504 else { 516 exch = loc_exchange_begin( INTERFACE_LOC_CONSUMER);505 exch = loc_exchange_begin(); 517 506 if (exch == NULL) 518 507 return errno; … … 548 537 loc_object_type_t loc_id_probe(service_id_t handle) 549 538 { 550 async_exch_t *exch = loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);539 async_exch_t *exch = loc_exchange_begin_blocking(); 551 540 552 541 sysarg_t type; … … 579 568 int loc_null_create(void) 580 569 { 581 async_exch_t *exch = loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);570 async_exch_t *exch = loc_exchange_begin_blocking(); 582 571 583 572 sysarg_t null_id; … … 594 583 void loc_null_destroy(int null_id) 595 584 { 596 async_exch_t *exch = loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);585 async_exch_t *exch = loc_exchange_begin_blocking(); 597 586 async_req_1_0(exch, LOC_NULL_DESTROY, (sysarg_t) null_id); 598 587 loc_exchange_end(exch); … … 611 600 /** Add service to category. 612 601 * 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 */ 608 errno_t loc_service_add_to_cat(loc_srv_t *srv, service_id_t svc_id, 609 service_id_t cat_id) 618 610 { 619 611 async_exch_t *exch; 620 612 errno_t retval; 621 613 622 exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);614 exch = async_exchange_begin(srv->sess); 623 615 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); 625 617 626 618 return retval; … … 641 633 size_t loc_count_namespaces(void) 642 634 { 643 async_exch_t *exch = loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);635 async_exch_t *exch = loc_exchange_begin_blocking(); 644 636 size_t size = loc_count_namespaces_internal(exch); 645 637 loc_exchange_end(exch); … … 650 642 size_t loc_count_services(service_id_t ns_handle) 651 643 { 652 async_exch_t *exch = loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);644 async_exch_t *exch = loc_exchange_begin_blocking(); 653 645 size_t size = loc_count_services_internal(exch, ns_handle); 654 646 loc_exchange_end(exch); … … 661 653 /* Loop until read is succesful */ 662 654 while (true) { 663 async_exch_t *exch = loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);655 async_exch_t *exch = loc_exchange_begin_blocking(); 664 656 size_t count = loc_count_namespaces_internal(exch); 665 657 loc_exchange_end(exch); … … 672 664 return 0; 673 665 674 exch = loc_exchange_begin( INTERFACE_LOC_CONSUMER);666 exch = loc_exchange_begin(); 675 667 676 668 ipc_call_t answer; … … 710 702 /* Loop until read is succesful */ 711 703 while (true) { 712 async_exch_t *exch = loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);704 async_exch_t *exch = loc_exchange_begin_blocking(); 713 705 size_t count = loc_count_services_internal(exch, ns_handle); 714 706 loc_exchange_end(exch); … … 721 713 return 0; 722 714 723 exch = loc_exchange_begin( INTERFACE_LOC_CONSUMER);715 exch = loc_exchange_begin(); 724 716 725 717 ipc_call_t answer; … … 758 750 sysarg_t *id_buf, size_t buf_size, size_t *act_size) 759 751 { 760 async_exch_t *exch = loc_exchange_begin_blocking( INTERFACE_LOC_CONSUMER);752 async_exch_t *exch = loc_exchange_begin_blocking(); 761 753 762 754 ipc_call_t answer;
Note:
See TracChangeset
for help on using the changeset viewer.