source: mainline/uspace/lib/c/generic/loc.c@ 3061bc1

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 3061bc1 was b7fd2a0, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 7 years ago

Use errno_t in all uspace and kernel code.

Change type of every variable, parameter and return value that holds an
<errno.h> constant to either errno_t (the usual case), or sys_errno_t
(some places in kernel). This is for the purpose of self-documentation,
as well as for type-checking with a bit of type definition hackery.

Although this is a massive commit, it is a simple text replacement, and thus
is very easy to verify. Simply do the following:

`
git checkout <this commit's hash>
git reset HEAD
git add .
tools/srepl '\berrno_t\b' int
git add .
tools/srepl '\bsys_errno_t\b' sysarg_t
git reset
git diff
`

While this doesn't ensure that the replacements are correct, it does ensure
that the commit doesn't do anything except those replacements. Since errno_t
is typedef'd to int in the usual case (and sys_errno_t to sysarg_t), even if
incorrect, this commit cannot change behavior.
  • Property mode set to 100644
File size: 19.9 KB
Line 
1/*
2 * Copyright (c) 2007 Josef Cejka
3 * Copyright (c) 2011 Jiri Svoboda
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include <str.h>
31#include <ipc/services.h>
32#include <ns.h>
33#include <ipc/loc.h>
34#include <loc.h>
35#include <fibril_synch.h>
36#include <async.h>
37#include <errno.h>
38#include <stdlib.h>
39#include <stdbool.h>
40
41static FIBRIL_MUTEX_INITIALIZE(loc_supp_block_mutex);
42static FIBRIL_MUTEX_INITIALIZE(loc_cons_block_mutex);
43
44static FIBRIL_MUTEX_INITIALIZE(loc_supplier_mutex);
45static FIBRIL_MUTEX_INITIALIZE(loc_consumer_mutex);
46
47static FIBRIL_MUTEX_INITIALIZE(loc_callback_mutex);
48static bool loc_callback_created = false;
49static loc_cat_change_cb_t cat_change_cb = NULL;
50
51static async_sess_t *loc_supp_block_sess = NULL;
52static async_sess_t *loc_cons_block_sess = NULL;
53
54static async_sess_t *loc_supplier_sess = NULL;
55static async_sess_t *loc_consumer_sess = NULL;
56
57static void loc_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
58{
59 while (true) {
60 ipc_call_t call;
61 ipc_callid_t callid = async_get_call(&call);
62
63 if (!IPC_GET_IMETHOD(call)) {
64 /* TODO: Handle hangup */
65 return;
66 }
67
68 switch (IPC_GET_IMETHOD(call)) {
69 case LOC_EVENT_CAT_CHANGE:
70 fibril_mutex_lock(&loc_callback_mutex);
71 loc_cat_change_cb_t cb_fun = cat_change_cb;
72 fibril_mutex_unlock(&loc_callback_mutex);
73
74 async_answer_0(callid, EOK);
75
76 if (cb_fun != NULL)
77 (*cb_fun)();
78
79 break;
80 default:
81 async_answer_0(callid, ENOTSUP);
82 }
83 }
84}
85
86
87static void clone_session(fibril_mutex_t *mtx, async_sess_t *src,
88 async_sess_t **dst)
89{
90 fibril_mutex_lock(mtx);
91
92 if ((*dst == NULL) && (src != NULL))
93 *dst = src;
94
95 fibril_mutex_unlock(mtx);
96}
97
98/** Create callback
99 *
100 * Must be called with loc_callback_mutex locked.
101 *
102 * @return EOK on success.
103 *
104 */
105static errno_t loc_callback_create(void)
106{
107 if (!loc_callback_created) {
108 async_exch_t *exch =
109 loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
110
111 ipc_call_t answer;
112 aid_t req = async_send_0(exch, LOC_CALLBACK_CREATE, &answer);
113
114 port_id_t port;
115 errno_t rc = async_create_callback_port(exch, INTERFACE_LOC_CB, 0, 0,
116 loc_cb_conn, NULL, &port);
117
118 loc_exchange_end(exch);
119
120 if (rc != EOK)
121 return rc;
122
123 errno_t retval;
124 async_wait_for(req, &retval);
125 if (retval != EOK)
126 return retval;
127
128 loc_callback_created = true;
129 }
130
131 return EOK;
132}
133
134/** Start an async exchange on the loc session (blocking).
135 *
136 * @param iface Location service interface to choose
137 *
138 * @return New exchange.
139 *
140 */
141async_exch_t *loc_exchange_begin_blocking(iface_t iface)
142{
143 switch (iface) {
144 case INTERFACE_LOC_SUPPLIER:
145 fibril_mutex_lock(&loc_supp_block_mutex);
146
147 while (loc_supp_block_sess == NULL) {
148 clone_session(&loc_supplier_mutex, loc_supplier_sess,
149 &loc_supp_block_sess);
150
151 if (loc_supp_block_sess == NULL)
152 loc_supp_block_sess =
153 service_connect_blocking(SERVICE_LOC,
154 INTERFACE_LOC_SUPPLIER, 0);
155 }
156
157 fibril_mutex_unlock(&loc_supp_block_mutex);
158
159 clone_session(&loc_supplier_mutex, loc_supp_block_sess,
160 &loc_supplier_sess);
161
162 return async_exchange_begin(loc_supp_block_sess);
163 case INTERFACE_LOC_CONSUMER:
164 fibril_mutex_lock(&loc_cons_block_mutex);
165
166 while (loc_cons_block_sess == NULL) {
167 clone_session(&loc_consumer_mutex, loc_consumer_sess,
168 &loc_cons_block_sess);
169
170 if (loc_cons_block_sess == NULL)
171 loc_cons_block_sess =
172 service_connect_blocking(SERVICE_LOC,
173 INTERFACE_LOC_CONSUMER, 0);
174 }
175
176 fibril_mutex_unlock(&loc_cons_block_mutex);
177
178 clone_session(&loc_consumer_mutex, loc_cons_block_sess,
179 &loc_consumer_sess);
180
181 return async_exchange_begin(loc_cons_block_sess);
182 default:
183 return NULL;
184 }
185}
186
187/** Start an async exchange on the loc session.
188 *
189 * @param iface Location service interface to choose
190 *
191 * @return New exchange.
192 *
193 */
194async_exch_t *loc_exchange_begin(iface_t iface)
195{
196 switch (iface) {
197 case INTERFACE_LOC_SUPPLIER:
198 fibril_mutex_lock(&loc_supplier_mutex);
199
200 if (loc_supplier_sess == NULL)
201 loc_supplier_sess =
202 service_connect(SERVICE_LOC,
203 INTERFACE_LOC_SUPPLIER, 0);
204
205 fibril_mutex_unlock(&loc_supplier_mutex);
206
207 if (loc_supplier_sess == NULL)
208 return NULL;
209
210 return async_exchange_begin(loc_supplier_sess);
211 case INTERFACE_LOC_CONSUMER:
212 fibril_mutex_lock(&loc_consumer_mutex);
213
214 if (loc_consumer_sess == NULL)
215 loc_consumer_sess =
216 service_connect(SERVICE_LOC,
217 INTERFACE_LOC_CONSUMER, 0);
218
219 fibril_mutex_unlock(&loc_consumer_mutex);
220
221 if (loc_consumer_sess == NULL)
222 return NULL;
223
224 return async_exchange_begin(loc_consumer_sess);
225 default:
226 return NULL;
227 }
228}
229
230/** Finish an async exchange on the loc session.
231 *
232 * @param exch Exchange to be finished.
233 *
234 */
235void loc_exchange_end(async_exch_t *exch)
236{
237 async_exchange_end(exch);
238}
239
240/** Register new driver with loc. */
241errno_t loc_server_register(const char *name)
242{
243 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
244
245 ipc_call_t answer;
246 aid_t req = async_send_2(exch, LOC_SERVER_REGISTER, 0, 0, &answer);
247 errno_t retval = async_data_write_start(exch, name, str_size(name));
248
249 if (retval != EOK) {
250 async_forget(req);
251 loc_exchange_end(exch);
252 return retval;
253 }
254
255 async_connect_to_me(exch, 0, 0, 0);
256
257 /*
258 * First wait for the answer and then end the exchange. The opposite
259 * order is generally wrong because it may lead to a deadlock under
260 * certain circumstances.
261 */
262 async_wait_for(req, &retval);
263 loc_exchange_end(exch);
264
265 return retval;
266}
267
268/** Register new service.
269 *
270 * @param fqsn Fully qualified service name
271 * @param[out] sid Service ID of new service
272 *
273 */
274errno_t loc_service_register(const char *fqsn, service_id_t *sid)
275{
276 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
277
278 ipc_call_t answer;
279 aid_t req = async_send_0(exch, LOC_SERVICE_REGISTER, &answer);
280 errno_t retval = async_data_write_start(exch, fqsn, str_size(fqsn));
281
282 if (retval != EOK) {
283 async_forget(req);
284 loc_exchange_end(exch);
285 return retval;
286 }
287
288 /*
289 * First wait for the answer and then end the exchange. The opposite
290 * order is generally wrong because it may lead to a deadlock under
291 * certain circumstances.
292 */
293 async_wait_for(req, &retval);
294 loc_exchange_end(exch);
295
296 if (retval != EOK) {
297 if (sid != NULL)
298 *sid = -1;
299
300 return retval;
301 }
302
303 if (sid != NULL)
304 *sid = (service_id_t) IPC_GET_ARG1(answer);
305
306 return retval;
307}
308
309/** Unregister service.
310 *
311 * @param sid Service ID
312 */
313errno_t loc_service_unregister(service_id_t sid)
314{
315 async_exch_t *exch;
316 errno_t retval;
317
318 exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
319 retval = async_req_1_0(exch, LOC_SERVICE_UNREGISTER, sid);
320 loc_exchange_end(exch);
321
322 return (errno_t)retval;
323}
324
325errno_t loc_service_get_id(const char *fqdn, service_id_t *handle,
326 unsigned int flags)
327{
328 async_exch_t *exch;
329
330 if (flags & IPC_FLAG_BLOCKING)
331 exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
332 else {
333 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
334 if (exch == NULL)
335 return errno;
336 }
337
338 ipc_call_t answer;
339 aid_t req = async_send_2(exch, LOC_SERVICE_GET_ID, flags, 0,
340 &answer);
341 errno_t retval = async_data_write_start(exch, fqdn, str_size(fqdn));
342
343 loc_exchange_end(exch);
344
345 if (retval != EOK) {
346 async_forget(req);
347 return retval;
348 }
349
350 async_wait_for(req, &retval);
351
352 if (retval != EOK) {
353 if (handle != NULL)
354 *handle = (service_id_t) -1;
355
356 return retval;
357 }
358
359 if (handle != NULL)
360 *handle = (service_id_t) IPC_GET_ARG1(answer);
361
362 return retval;
363}
364
365/** Get object name.
366 *
367 * Provided ID of an object, return its name.
368 *
369 * @param method IPC method
370 * @param id Object ID
371 * @param name Place to store pointer to new string. Caller should
372 * free it using free().
373 * @return EOK on success or an error code
374 */
375static errno_t loc_get_name_internal(sysarg_t method, sysarg_t id, char **name)
376{
377 async_exch_t *exch;
378 char name_buf[LOC_NAME_MAXLEN + 1];
379 ipc_call_t dreply;
380 size_t act_size;
381 errno_t dretval;
382
383 *name = NULL;
384 exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
385
386 ipc_call_t answer;
387 aid_t req = async_send_1(exch, method, id, &answer);
388 aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN,
389 &dreply);
390 async_wait_for(dreq, &dretval);
391
392 loc_exchange_end(exch);
393
394 if (dretval != EOK) {
395 async_forget(req);
396 return dretval;
397 }
398
399 errno_t retval;
400 async_wait_for(req, &retval);
401
402 if (retval != EOK)
403 return retval;
404
405 act_size = IPC_GET_ARG2(dreply);
406 assert(act_size <= LOC_NAME_MAXLEN);
407 name_buf[act_size] = '\0';
408
409 *name = str_dup(name_buf);
410 if (*name == NULL)
411 return ENOMEM;
412
413 return EOK;
414}
415
416/** Get category name.
417 *
418 * Provided ID of a service, return its name.
419 *
420 * @param cat_id Category ID
421 * @param name Place to store pointer to new string. Caller should
422 * free it using free().
423 * @return EOK on success or an error code
424 */
425errno_t loc_category_get_name(category_id_t cat_id, char **name)
426{
427 return loc_get_name_internal(LOC_CATEGORY_GET_NAME, cat_id, name);
428}
429
430/** Get service name.
431 *
432 * Provided ID of a service, return its name.
433 *
434 * @param svc_id Service ID
435 * @param name Place to store pointer to new string. Caller should
436 * free it using free().
437 * @return EOK on success or an error code
438 */
439errno_t loc_service_get_name(service_id_t svc_id, char **name)
440{
441 return loc_get_name_internal(LOC_SERVICE_GET_NAME, svc_id, name);
442}
443
444/** Get service server name.
445 *
446 * Provided ID of a service, return the name of its server.
447 *
448 * @param svc_id Service ID
449 * @param name Place to store pointer to new string. Caller should
450 * free it using free().
451 * @return EOK on success or an error code
452 */
453errno_t loc_service_get_server_name(service_id_t svc_id, char **name)
454{
455 return loc_get_name_internal(LOC_SERVICE_GET_SERVER_NAME, svc_id, name);
456}
457
458errno_t loc_namespace_get_id(const char *name, service_id_t *handle,
459 unsigned int flags)
460{
461 async_exch_t *exch;
462
463 if (flags & IPC_FLAG_BLOCKING)
464 exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
465 else {
466 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
467 if (exch == NULL)
468 return errno;
469 }
470
471 ipc_call_t answer;
472 aid_t req = async_send_2(exch, LOC_NAMESPACE_GET_ID, flags, 0,
473 &answer);
474 errno_t retval = async_data_write_start(exch, name, str_size(name));
475
476 loc_exchange_end(exch);
477
478 if (retval != EOK) {
479 async_forget(req);
480 return retval;
481 }
482
483 async_wait_for(req, &retval);
484
485 if (retval != EOK) {
486 if (handle != NULL)
487 *handle = (service_id_t) -1;
488
489 return retval;
490 }
491
492 if (handle != NULL)
493 *handle = (service_id_t) IPC_GET_ARG1(answer);
494
495 return retval;
496}
497
498/** Get category ID.
499 *
500 * Provided name of a category, return its ID.
501 *
502 * @param name Category name
503 * @param cat_id Place to store ID
504 * @param flags IPC_FLAG_BLOCKING to wait for location service to start
505 * @return EOK on success or an error code
506 */
507errno_t loc_category_get_id(const char *name, category_id_t *cat_id,
508 unsigned int flags)
509{
510 async_exch_t *exch;
511
512 if (flags & IPC_FLAG_BLOCKING)
513 exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
514 else {
515 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
516 if (exch == NULL)
517 return errno;
518 }
519
520 ipc_call_t answer;
521 aid_t req = async_send_0(exch, LOC_CATEGORY_GET_ID,
522 &answer);
523 errno_t retval = async_data_write_start(exch, name, str_size(name));
524
525 loc_exchange_end(exch);
526
527 if (retval != EOK) {
528 async_forget(req);
529 return retval;
530 }
531
532 async_wait_for(req, &retval);
533
534 if (retval != EOK) {
535 if (cat_id != NULL)
536 *cat_id = (category_id_t) -1;
537
538 return retval;
539 }
540
541 if (cat_id != NULL)
542 *cat_id = (category_id_t) IPC_GET_ARG1(answer);
543
544 return retval;
545}
546
547
548loc_object_type_t loc_id_probe(service_id_t handle)
549{
550 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
551
552 sysarg_t type;
553 errno_t retval = async_req_1_1(exch, LOC_ID_PROBE, handle, &type);
554
555 loc_exchange_end(exch);
556
557 if (retval != EOK)
558 return LOC_OBJECT_NONE;
559
560 return (loc_object_type_t) type;
561}
562
563async_sess_t *loc_service_connect(service_id_t handle, iface_t iface,
564 unsigned int flags)
565{
566 async_sess_t *sess;
567
568 if (flags & IPC_FLAG_BLOCKING)
569 sess = service_connect_blocking(SERVICE_LOC, iface, handle);
570 else
571 sess = service_connect(SERVICE_LOC, iface, handle);
572
573 return sess;
574}
575
576/**
577 * @return ID of a new NULL device, or -1 if failed.
578 */
579int loc_null_create(void)
580{
581 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
582
583 sysarg_t null_id;
584 errno_t retval = async_req_0_1(exch, LOC_NULL_CREATE, &null_id);
585
586 loc_exchange_end(exch);
587
588 if (retval != EOK)
589 return -1;
590
591 return (int) null_id;
592}
593
594void loc_null_destroy(int null_id)
595{
596 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
597 async_req_1_0(exch, LOC_NULL_DESTROY, (sysarg_t) null_id);
598 loc_exchange_end(exch);
599}
600
601static size_t loc_count_namespaces_internal(async_exch_t *exch)
602{
603 sysarg_t count;
604 errno_t retval = async_req_0_1(exch, LOC_GET_NAMESPACE_COUNT, &count);
605 if (retval != EOK)
606 return 0;
607
608 return count;
609}
610
611/** Add service to category.
612 *
613 * @param svc_id Service ID
614 * @param cat_id Category ID
615 * @return EOK on success or an error code
616 */
617errno_t loc_service_add_to_cat(service_id_t svc_id, service_id_t cat_id)
618{
619 async_exch_t *exch;
620 errno_t retval;
621
622 exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
623 retval = async_req_2_0(exch, LOC_SERVICE_ADD_TO_CAT, svc_id, cat_id);
624 loc_exchange_end(exch);
625
626 return retval;
627}
628
629static size_t loc_count_services_internal(async_exch_t *exch,
630 service_id_t ns_handle)
631{
632 sysarg_t count;
633 errno_t retval = async_req_1_1(exch, LOC_GET_SERVICE_COUNT, ns_handle,
634 &count);
635 if (retval != EOK)
636 return 0;
637
638 return count;
639}
640
641size_t loc_count_namespaces(void)
642{
643 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
644 size_t size = loc_count_namespaces_internal(exch);
645 loc_exchange_end(exch);
646
647 return size;
648}
649
650size_t loc_count_services(service_id_t ns_handle)
651{
652 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
653 size_t size = loc_count_services_internal(exch, ns_handle);
654 loc_exchange_end(exch);
655
656 return size;
657}
658
659size_t loc_get_namespaces(loc_sdesc_t **data)
660{
661 /* Loop until read is succesful */
662 while (true) {
663 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
664 size_t count = loc_count_namespaces_internal(exch);
665 loc_exchange_end(exch);
666
667 if (count == 0)
668 return 0;
669
670 loc_sdesc_t *devs = (loc_sdesc_t *) calloc(count, sizeof(loc_sdesc_t));
671 if (devs == NULL)
672 return 0;
673
674 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
675
676 ipc_call_t answer;
677 aid_t req = async_send_0(exch, LOC_GET_NAMESPACES, &answer);
678 errno_t rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t));
679
680 loc_exchange_end(exch);
681
682 if (rc == EOVERFLOW) {
683 /*
684 * Number of namespaces has changed since
685 * the last call of LOC_GET_NAMESPACE_COUNT
686 */
687 free(devs);
688 continue;
689 }
690
691 if (rc != EOK) {
692 async_forget(req);
693 free(devs);
694 return 0;
695 }
696
697 errno_t retval;
698 async_wait_for(req, &retval);
699
700 if (retval != EOK)
701 return 0;
702
703 *data = devs;
704 return count;
705 }
706}
707
708size_t loc_get_services(service_id_t ns_handle, loc_sdesc_t **data)
709{
710 /* Loop until read is succesful */
711 while (true) {
712 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
713 size_t count = loc_count_services_internal(exch, ns_handle);
714 loc_exchange_end(exch);
715
716 if (count == 0)
717 return 0;
718
719 loc_sdesc_t *devs = (loc_sdesc_t *) calloc(count, sizeof(loc_sdesc_t));
720 if (devs == NULL)
721 return 0;
722
723 exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
724
725 ipc_call_t answer;
726 aid_t req = async_send_1(exch, LOC_GET_SERVICES, ns_handle, &answer);
727 errno_t rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t));
728
729 loc_exchange_end(exch);
730
731 if (rc == EOVERFLOW) {
732 /*
733 * Number of services has changed since
734 * the last call of LOC_GET_SERVICE_COUNT
735 */
736 free(devs);
737 continue;
738 }
739
740 if (rc != EOK) {
741 async_forget(req);
742 free(devs);
743 return 0;
744 }
745
746 errno_t retval;
747 async_wait_for(req, &retval);
748
749 if (retval != EOK)
750 return 0;
751
752 *data = devs;
753 return count;
754 }
755}
756
757static errno_t loc_category_get_ids_once(sysarg_t method, sysarg_t arg1,
758 sysarg_t *id_buf, size_t buf_size, size_t *act_size)
759{
760 async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
761
762 ipc_call_t answer;
763 aid_t req = async_send_1(exch, method, arg1, &answer);
764 errno_t rc = async_data_read_start(exch, id_buf, buf_size);
765
766 loc_exchange_end(exch);
767
768 if (rc != EOK) {
769 async_forget(req);
770 return rc;
771 }
772
773 errno_t retval;
774 async_wait_for(req, &retval);
775
776 if (retval != EOK) {
777 return retval;
778 }
779
780 *act_size = IPC_GET_ARG1(answer);
781 return EOK;
782}
783
784/** Get list of IDs.
785 *
786 * Returns an allocated array of service IDs.
787 *
788 * @param method IPC method
789 * @param arg1 IPC argument 1
790 * @param data Place to store pointer to array of IDs
791 * @param count Place to store number of IDs
792 * @return EOK on success or an error code
793 */
794static errno_t loc_get_ids_internal(sysarg_t method, sysarg_t arg1,
795 sysarg_t **data, size_t *count)
796{
797 *data = NULL;
798 *count = 0;
799
800 size_t act_size = 0;
801 errno_t rc = loc_category_get_ids_once(method, arg1, NULL, 0,
802 &act_size);
803 if (rc != EOK)
804 return rc;
805
806 size_t alloc_size = act_size;
807 service_id_t *ids = malloc(alloc_size);
808 if (ids == NULL)
809 return ENOMEM;
810
811 while (true) {
812 rc = loc_category_get_ids_once(method, arg1, ids, alloc_size,
813 &act_size);
814 if (rc != EOK)
815 return rc;
816
817 if (act_size <= alloc_size)
818 break;
819
820 alloc_size = act_size;
821 ids = realloc(ids, alloc_size);
822 if (ids == NULL)
823 return ENOMEM;
824 }
825
826 *count = act_size / sizeof(category_id_t);
827 *data = ids;
828 return EOK;
829}
830
831/** Get list of services in category.
832 *
833 * Returns an allocated array of service IDs.
834 *
835 * @param cat_id Category ID
836 * @param data Place to store pointer to array of IDs
837 * @param count Place to store number of IDs
838 * @return EOK on success or an error code
839 */
840errno_t loc_category_get_svcs(category_id_t cat_id, service_id_t **data,
841 size_t *count)
842{
843 return loc_get_ids_internal(LOC_CATEGORY_GET_SVCS, cat_id,
844 data, count);
845}
846
847/** Get list of categories.
848 *
849 * Returns an allocated array of category IDs.
850 *
851 * @param data Place to store pointer to array of IDs
852 * @param count Place to store number of IDs
853 * @return EOK on success or an error code
854 */
855errno_t loc_get_categories(category_id_t **data, size_t *count)
856{
857 return loc_get_ids_internal(LOC_GET_CATEGORIES, 0,
858 data, count);
859}
860
861errno_t loc_register_cat_change_cb(loc_cat_change_cb_t cb_fun)
862{
863 fibril_mutex_lock(&loc_callback_mutex);
864 if (loc_callback_create() != EOK) {
865 fibril_mutex_unlock(&loc_callback_mutex);
866 return EIO;
867 }
868
869 cat_change_cb = cb_fun;
870 fibril_mutex_unlock(&loc_callback_mutex);
871
872 return EOK;
873}
Note: See TracBrowser for help on using the repository browser.