source: mainline/uspace/srv/locsrv/locsrv.c@ 3b47db6

Last change on this file since 3b47db6 was 3b47db6, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 7 years ago

(optional) Remove EXIT_RC().
  • Property mode set to 100644
File size: 35.5 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/**
31 * @defgroup loc Location Service.
32 * @brief HelenOS location service.
33 * @{
34 */
35
36/** @file
37 */
38
39#include <ipc/services.h>
40#include <ns.h>
41#include <async.h>
42#include <stdio.h>
43#include <errno.h>
44#include <stdbool.h>
45#include <fibril_synch.h>
46#include <macros.h>
47#include <stdlib.h>
48#include <str.h>
49#include <str_error.h>
50#include <ipc/loc.h>
51#include <assert.h>
52
53#include "category.h"
54#include "locsrv.h"
55
56#define NAME "loc"
57#define NULL_SERVICES 256
58
59/** Callback session */
60typedef struct {
61 link_t cb_sess_list;
62 async_sess_t *sess;
63} cb_sess_t;
64
65LIST_INITIALIZE(services_list);
66LIST_INITIALIZE(namespaces_list);
67LIST_INITIALIZE(servers_list);
68
69/* Locking order:
70 * servers_list_mutex
71 * services_list_mutex
72 * (loc_server_t *)->services_mutex
73 * create_id_mutex
74 **/
75
76FIBRIL_MUTEX_INITIALIZE(services_list_mutex);
77static FIBRIL_CONDVAR_INITIALIZE(services_list_cv);
78static FIBRIL_MUTEX_INITIALIZE(servers_list_mutex);
79static FIBRIL_MUTEX_INITIALIZE(create_id_mutex);
80static FIBRIL_MUTEX_INITIALIZE(null_services_mutex);
81
82static service_id_t last_id = 0;
83static loc_service_t *null_services[NULL_SERVICES];
84
85/*
86 * Dummy list for null services. This is necessary so that null services can
87 * be used just as any other services, e.g. in loc_service_unregister_core().
88 */
89static LIST_INITIALIZE(dummy_null_services);
90
91/** Service directory ogranized by categories (yellow pages) */
92static categ_dir_t cdir;
93
94static FIBRIL_MUTEX_INITIALIZE(callback_sess_mutex);
95static LIST_INITIALIZE(callback_sess_list);
96
97service_id_t loc_create_id(void)
98{
99 /* TODO: allow reusing old ids after their unregistration
100 * and implement some version of LRU algorithm, avoid overflow
101 */
102
103 fibril_mutex_lock(&create_id_mutex);
104 last_id++;
105 fibril_mutex_unlock(&create_id_mutex);
106
107 return last_id;
108}
109
110/** Convert fully qualified service name to namespace and service name.
111 *
112 * A fully qualified service name can be either a plain service name
113 * (then the namespace is considered to be an empty string) or consist
114 * of two components separated by a slash. No more than one slash
115 * is allowed.
116 *
117 */
118static bool loc_fqsn_split(const char *fqsn, char **ns_name, char **name)
119{
120 size_t cnt = 0;
121 size_t slash_offset = 0;
122 size_t slash_after = 0;
123
124 size_t offset = 0;
125 size_t offset_prev = 0;
126 wchar_t c;
127
128 while ((c = str_decode(fqsn, &offset, STR_NO_LIMIT)) != 0) {
129 if (c == '/') {
130 cnt++;
131 slash_offset = offset_prev;
132 slash_after = offset;
133 }
134 offset_prev = offset;
135 }
136
137 /* More than one slash */
138 if (cnt > 1)
139 return false;
140
141 /* No slash -> namespace is empty */
142 if (cnt == 0) {
143 *ns_name = str_dup("");
144 if (*ns_name == NULL)
145 return false;
146
147 *name = str_dup(fqsn);
148 if (*name == NULL) {
149 free(*ns_name);
150 return false;
151 }
152
153 if (str_cmp(*name, "") == 0) {
154 free(*name);
155 free(*ns_name);
156 return false;
157 }
158
159 return true;
160 }
161
162 /* Exactly one slash */
163 *ns_name = str_ndup(fqsn, slash_offset);
164 if (*ns_name == NULL)
165 return false;
166
167 *name = str_dup(fqsn + slash_after);
168 if (*name == NULL) {
169 free(*ns_name);
170 return false;
171 }
172
173 if (str_cmp(*name, "") == 0) {
174 free(*name);
175 free(*ns_name);
176 return false;
177 }
178
179 return true;
180}
181
182/** Find namespace with given name. */
183static loc_namespace_t *loc_namespace_find_name(const char *name)
184{
185 assert(fibril_mutex_is_locked(&services_list_mutex));
186
187 list_foreach(namespaces_list, namespaces, loc_namespace_t, namespace) {
188 if (str_cmp(namespace->name, name) == 0)
189 return namespace;
190 }
191
192 return NULL;
193}
194
195/** Find namespace with given ID.
196 *
197 * @todo: use hash table
198 *
199 */
200static loc_namespace_t *loc_namespace_find_id(service_id_t id)
201{
202 assert(fibril_mutex_is_locked(&services_list_mutex));
203
204 list_foreach(namespaces_list, namespaces, loc_namespace_t, namespace) {
205 if (namespace->id == id)
206 return namespace;
207 }
208
209 return NULL;
210}
211
212/** Find service with given name. */
213static loc_service_t *loc_service_find_name(const char *ns_name,
214 const char *name)
215{
216 assert(fibril_mutex_is_locked(&services_list_mutex));
217
218 list_foreach(services_list, services, loc_service_t, service) {
219 if ((str_cmp(service->namespace->name, ns_name) == 0)
220 && (str_cmp(service->name, name) == 0))
221 return service;
222 }
223
224 return NULL;
225}
226
227/** Find service with given ID.
228 *
229 * @todo: use hash table
230 *
231 */
232static loc_service_t *loc_service_find_id(service_id_t id)
233{
234 assert(fibril_mutex_is_locked(&services_list_mutex));
235
236 list_foreach(services_list, services, loc_service_t, service) {
237 if (service->id == id)
238 return service;
239 }
240
241 return NULL;
242}
243
244/** Create a namespace (if not already present). */
245static loc_namespace_t *loc_namespace_create(const char *ns_name)
246{
247 loc_namespace_t *namespace;
248
249 assert(fibril_mutex_is_locked(&services_list_mutex));
250
251 namespace = loc_namespace_find_name(ns_name);
252 if (namespace != NULL)
253 return namespace;
254
255 namespace = (loc_namespace_t *) malloc(sizeof(loc_namespace_t));
256 if (namespace == NULL)
257 return NULL;
258
259 namespace->name = str_dup(ns_name);
260 if (namespace->name == NULL) {
261 free(namespace);
262 return NULL;
263 }
264
265 namespace->id = loc_create_id();
266 namespace->refcnt = 0;
267
268 /*
269 * Insert new namespace into list of registered namespaces
270 */
271 list_append(&(namespace->namespaces), &namespaces_list);
272
273 return namespace;
274}
275
276/** Destroy a namespace (if it is no longer needed). */
277static void loc_namespace_destroy(loc_namespace_t *namespace)
278{
279 assert(fibril_mutex_is_locked(&services_list_mutex));
280
281 if (namespace->refcnt == 0) {
282 list_remove(&(namespace->namespaces));
283
284 free(namespace->name);
285 free(namespace);
286 }
287}
288
289/** Increase namespace reference count by including service. */
290static void loc_namespace_addref(loc_namespace_t *namespace,
291 loc_service_t *service)
292{
293 assert(fibril_mutex_is_locked(&services_list_mutex));
294
295 service->namespace = namespace;
296 namespace->refcnt++;
297}
298
299/** Decrease namespace reference count. */
300static void loc_namespace_delref(loc_namespace_t *namespace)
301{
302 assert(fibril_mutex_is_locked(&services_list_mutex));
303
304 namespace->refcnt--;
305 loc_namespace_destroy(namespace);
306}
307
308/** Unregister service and free it. */
309static void loc_service_unregister_core(loc_service_t *service)
310{
311 assert(fibril_mutex_is_locked(&services_list_mutex));
312 assert(fibril_mutex_is_locked(&cdir.mutex));
313
314 loc_namespace_delref(service->namespace);
315 list_remove(&(service->services));
316 list_remove(&(service->server_services));
317
318 /* Remove service from all categories. */
319 while (!list_empty(&service->cat_memb)) {
320 link_t *link = list_first(&service->cat_memb);
321 svc_categ_t *memb = list_get_instance(link, svc_categ_t,
322 svc_link);
323 category_t *cat = memb->cat;
324
325 fibril_mutex_lock(&cat->mutex);
326 category_remove_service(memb);
327 fibril_mutex_unlock(&cat->mutex);
328 }
329
330 free(service->name);
331 free(service);
332}
333
334/**
335 * Read info about new server and add it into linked list of registered
336 * servers.
337 */
338static loc_server_t *loc_server_register(void)
339{
340 ipc_call_t icall;
341 ipc_callid_t iid = async_get_call(&icall);
342
343 if (IPC_GET_IMETHOD(icall) != LOC_SERVER_REGISTER) {
344 async_answer_0(iid, EREFUSED);
345 return NULL;
346 }
347
348 loc_server_t *server =
349 (loc_server_t *) malloc(sizeof(loc_server_t));
350 if (server == NULL) {
351 async_answer_0(iid, ENOMEM);
352 return NULL;
353 }
354
355 /*
356 * Get server name
357 */
358 errno_t rc = async_data_write_accept((void **) &server->name, true, 0,
359 LOC_NAME_MAXLEN, 0, NULL);
360 if (rc != EOK) {
361 free(server);
362 async_answer_0(iid, rc);
363 return NULL;
364 }
365
366 /*
367 * Create connection to the server
368 */
369 server->sess = async_callback_receive(EXCHANGE_SERIALIZE);
370 if (!server->sess) {
371 free(server->name);
372 free(server);
373 async_answer_0(iid, ENOTSUP);
374 return NULL;
375 }
376
377 /*
378 * Initialize mutex for list of services
379 * supplied by this server
380 */
381 fibril_mutex_initialize(&server->services_mutex);
382
383 /*
384 * Initialize list of supplied services
385 */
386 list_initialize(&server->services);
387 link_initialize(&server->servers);
388
389 fibril_mutex_lock(&servers_list_mutex);
390
391 /* TODO:
392 * Check that no server with name equal to
393 * server->name is registered
394 */
395
396 /*
397 * Insert new server into list of registered servers
398 */
399 list_append(&(server->servers), &servers_list);
400 fibril_mutex_unlock(&servers_list_mutex);
401
402 async_answer_0(iid, EOK);
403
404 return server;
405}
406
407/**
408 * Unregister server, unregister all its services and free server
409 * structure.
410 *
411 */
412static errno_t loc_server_unregister(loc_server_t *server)
413{
414 if (server == NULL)
415 return EEXIST;
416
417 fibril_mutex_lock(&servers_list_mutex);
418
419 if (server->sess)
420 async_hangup(server->sess);
421
422 /* Remove it from list of servers */
423 list_remove(&(server->servers));
424
425 /* Unregister all its services */
426 fibril_mutex_lock(&services_list_mutex);
427 fibril_mutex_lock(&server->services_mutex);
428 fibril_mutex_lock(&cdir.mutex);
429
430 while (!list_empty(&server->services)) {
431 loc_service_t *service = list_get_instance(
432 list_first(&server->services), loc_service_t,
433 server_services);
434 loc_service_unregister_core(service);
435 }
436
437 fibril_mutex_unlock(&cdir.mutex);
438 fibril_mutex_unlock(&server->services_mutex);
439 fibril_mutex_unlock(&services_list_mutex);
440 fibril_mutex_unlock(&servers_list_mutex);
441
442 /* Free name and server */
443 if (server->name != NULL)
444 free(server->name);
445
446 free(server);
447
448 loc_category_change_event();
449 return EOK;
450}
451
452/** Register service
453 *
454 */
455static void loc_service_register(ipc_callid_t iid, ipc_call_t *icall,
456 loc_server_t *server)
457{
458 if (server == NULL) {
459 async_answer_0(iid, EREFUSED);
460 return;
461 }
462
463 /* Create new service entry */
464 loc_service_t *service =
465 (loc_service_t *) malloc(sizeof(loc_service_t));
466 if (service == NULL) {
467 async_answer_0(iid, ENOMEM);
468 return;
469 }
470
471 /* Get fqsn */
472 char *fqsn;
473 errno_t rc = async_data_write_accept((void **) &fqsn, true, 0,
474 LOC_NAME_MAXLEN, 0, NULL);
475 if (rc != EOK) {
476 free(service);
477 async_answer_0(iid, rc);
478 return;
479 }
480
481 char *ns_name;
482 if (!loc_fqsn_split(fqsn, &ns_name, &service->name)) {
483 free(fqsn);
484 free(service);
485 async_answer_0(iid, EINVAL);
486 return;
487 }
488
489 free(fqsn);
490
491 fibril_mutex_lock(&services_list_mutex);
492
493 loc_namespace_t *namespace = loc_namespace_create(ns_name);
494 free(ns_name);
495 if (namespace == NULL) {
496 fibril_mutex_unlock(&services_list_mutex);
497 free(service->name);
498 free(service);
499 async_answer_0(iid, ENOMEM);
500 return;
501 }
502
503 link_initialize(&service->services);
504 link_initialize(&service->server_services);
505 list_initialize(&service->cat_memb);
506
507 /* Check that service is not already registered */
508 if (loc_service_find_name(namespace->name, service->name) != NULL) {
509 printf("%s: Service '%s/%s' already registered\n", NAME,
510 namespace->name, service->name);
511 loc_namespace_destroy(namespace);
512 fibril_mutex_unlock(&services_list_mutex);
513 free(service->name);
514 free(service);
515 async_answer_0(iid, EEXIST);
516 return;
517 }
518
519 /* Get unique service ID */
520 service->id = loc_create_id();
521
522 loc_namespace_addref(namespace, service);
523 service->server = server;
524
525 /* Insert service into list of all services */
526 list_append(&service->services, &services_list);
527
528 /* Insert service into list of services supplied by one server */
529 fibril_mutex_lock(&service->server->services_mutex);
530
531 list_append(&service->server_services, &service->server->services);
532
533 fibril_mutex_unlock(&service->server->services_mutex);
534 fibril_condvar_broadcast(&services_list_cv);
535 fibril_mutex_unlock(&services_list_mutex);
536
537 async_answer_1(iid, EOK, service->id);
538}
539
540/**
541 *
542 */
543static void loc_service_unregister(ipc_callid_t iid, ipc_call_t *icall,
544 loc_server_t *server)
545{
546 loc_service_t *svc;
547
548 fibril_mutex_lock(&services_list_mutex);
549 svc = loc_service_find_id(IPC_GET_ARG1(*icall));
550 if (svc == NULL) {
551 fibril_mutex_unlock(&services_list_mutex);
552 async_answer_0(iid, ENOENT);
553 return;
554 }
555
556 fibril_mutex_lock(&cdir.mutex);
557 loc_service_unregister_core(svc);
558 fibril_mutex_unlock(&cdir.mutex);
559 fibril_mutex_unlock(&services_list_mutex);
560
561 /*
562 * First send out all notifications and only then answer the request.
563 * Otherwise the current fibril might block and transitively wait for
564 * the completion of requests that are routed to it via an IPC loop.
565 */
566 loc_category_change_event();
567 async_answer_0(iid, EOK);
568}
569
570static void loc_category_get_name(ipc_callid_t iid, ipc_call_t *icall)
571{
572 ipc_callid_t callid;
573 size_t size;
574 size_t act_size;
575 category_t *cat;
576
577 if (!async_data_read_receive(&callid, &size)) {
578 async_answer_0(callid, EREFUSED);
579 async_answer_0(iid, EREFUSED);
580 return;
581 }
582
583 fibril_mutex_lock(&cdir.mutex);
584
585 cat = category_get(&cdir, IPC_GET_ARG1(*icall));
586 if (cat == NULL) {
587 fibril_mutex_unlock(&cdir.mutex);
588 async_answer_0(callid, ENOENT);
589 async_answer_0(iid, ENOENT);
590 return;
591 }
592
593 act_size = str_size(cat->name);
594 if (act_size > size) {
595 fibril_mutex_unlock(&cdir.mutex);
596 async_answer_0(callid, EOVERFLOW);
597 async_answer_0(iid, EOVERFLOW);
598 return;
599 }
600
601 errno_t retval = async_data_read_finalize(callid, cat->name,
602 min(size, act_size));
603
604 fibril_mutex_unlock(&cdir.mutex);
605
606 async_answer_0(iid, retval);
607}
608
609static void loc_service_get_name(ipc_callid_t iid, ipc_call_t *icall)
610{
611 ipc_callid_t callid;
612 size_t size;
613 size_t act_size;
614 loc_service_t *svc;
615 char *fqn;
616
617 if (!async_data_read_receive(&callid, &size)) {
618 async_answer_0(callid, EREFUSED);
619 async_answer_0(iid, EREFUSED);
620 return;
621 }
622
623 fibril_mutex_lock(&services_list_mutex);
624
625 svc = loc_service_find_id(IPC_GET_ARG1(*icall));
626 if (svc == NULL) {
627 fibril_mutex_unlock(&services_list_mutex);
628 async_answer_0(callid, ENOENT);
629 async_answer_0(iid, ENOENT);
630 return;
631 }
632
633 if (asprintf(&fqn, "%s/%s", svc->namespace->name, svc->name) < 0) {
634 fibril_mutex_unlock(&services_list_mutex);
635 async_answer_0(callid, ENOMEM);
636 async_answer_0(iid, ENOMEM);
637 return;
638 }
639
640 act_size = str_size(fqn);
641 if (act_size > size) {
642 free(fqn);
643 fibril_mutex_unlock(&services_list_mutex);
644 async_answer_0(callid, EOVERFLOW);
645 async_answer_0(iid, EOVERFLOW);
646 return;
647 }
648
649 errno_t retval = async_data_read_finalize(callid, fqn,
650 min(size, act_size));
651 free(fqn);
652
653 fibril_mutex_unlock(&services_list_mutex);
654
655 async_answer_0(iid, retval);
656}
657
658static void loc_service_get_server_name(ipc_callid_t iid, ipc_call_t *icall)
659{
660 ipc_callid_t callid;
661 size_t size;
662 size_t act_size;
663 loc_service_t *svc;
664
665 if (!async_data_read_receive(&callid, &size)) {
666 async_answer_0(callid, EREFUSED);
667 async_answer_0(iid, EREFUSED);
668 return;
669 }
670
671 fibril_mutex_lock(&services_list_mutex);
672
673 svc = loc_service_find_id(IPC_GET_ARG1(*icall));
674 if (svc == NULL) {
675 fibril_mutex_unlock(&services_list_mutex);
676 async_answer_0(callid, ENOENT);
677 async_answer_0(iid, ENOENT);
678 return;
679 }
680
681 if (svc->server == NULL) {
682 fibril_mutex_unlock(&services_list_mutex);
683 async_answer_0(callid, EINVAL);
684 async_answer_0(iid, EINVAL);
685 return;
686 }
687
688 act_size = str_size(svc->server->name);
689 if (act_size > size) {
690 fibril_mutex_unlock(&services_list_mutex);
691 async_answer_0(callid, EOVERFLOW);
692 async_answer_0(iid, EOVERFLOW);
693 return;
694 }
695
696 errno_t retval = async_data_read_finalize(callid, svc->server->name,
697 min(size, act_size));
698
699 fibril_mutex_unlock(&services_list_mutex);
700
701 async_answer_0(iid, retval);
702}
703
704/** Connect client to the service.
705 *
706 * Find server supplying requested service and forward
707 * the message to it.
708 *
709 */
710static void loc_forward(ipc_callid_t callid, ipc_call_t *call, void *arg)
711{
712 fibril_mutex_lock(&services_list_mutex);
713
714 /*
715 * Get ID from request
716 */
717 iface_t iface = IPC_GET_ARG1(*call);
718 service_id_t id = IPC_GET_ARG2(*call);
719 loc_service_t *svc = loc_service_find_id(id);
720
721 if ((svc == NULL) || (svc->server == NULL) || (!svc->server->sess)) {
722 fibril_mutex_unlock(&services_list_mutex);
723 async_answer_0(callid, ENOENT);
724 return;
725 }
726
727 async_exch_t *exch = async_exchange_begin(svc->server->sess);
728 async_forward_fast(callid, exch, iface, svc->id, 0, IPC_FF_NONE);
729 async_exchange_end(exch);
730
731 fibril_mutex_unlock(&services_list_mutex);
732}
733
734/** Find ID for service identified by name.
735 *
736 * In answer will be send EOK and service ID in arg1 or a error
737 * code from errno.h.
738 *
739 */
740static void loc_service_get_id(ipc_callid_t iid, ipc_call_t *icall)
741{
742 char *fqsn;
743
744 /* Get fqsn */
745 errno_t rc = async_data_write_accept((void **) &fqsn, true, 0,
746 LOC_NAME_MAXLEN, 0, NULL);
747 if (rc != EOK) {
748 async_answer_0(iid, rc);
749 return;
750 }
751
752 char *ns_name;
753 char *name;
754 if (!loc_fqsn_split(fqsn, &ns_name, &name)) {
755 free(fqsn);
756 async_answer_0(iid, EINVAL);
757 return;
758 }
759
760 free(fqsn);
761
762 fibril_mutex_lock(&services_list_mutex);
763 const loc_service_t *svc;
764
765recheck:
766
767 /*
768 * Find service name in the list of known services.
769 */
770 svc = loc_service_find_name(ns_name, name);
771
772 /*
773 * Device was not found.
774 */
775 if (svc == NULL) {
776 if (IPC_GET_ARG1(*icall) & IPC_FLAG_BLOCKING) {
777 /* Blocking lookup */
778 fibril_condvar_wait(&services_list_cv,
779 &services_list_mutex);
780 goto recheck;
781 }
782
783 async_answer_0(iid, ENOENT);
784 free(ns_name);
785 free(name);
786 fibril_mutex_unlock(&services_list_mutex);
787 return;
788 }
789
790 async_answer_1(iid, EOK, svc->id);
791
792 fibril_mutex_unlock(&services_list_mutex);
793 free(ns_name);
794 free(name);
795}
796
797/** Find ID for namespace identified by name.
798 *
799 * In answer will be send EOK and service ID in arg1 or a error
800 * code from errno.h.
801 *
802 */
803static void loc_namespace_get_id(ipc_callid_t iid, ipc_call_t *icall)
804{
805 char *name;
806
807 /* Get service name */
808 errno_t rc = async_data_write_accept((void **) &name, true, 0,
809 LOC_NAME_MAXLEN, 0, NULL);
810 if (rc != EOK) {
811 async_answer_0(iid, rc);
812 return;
813 }
814
815 fibril_mutex_lock(&services_list_mutex);
816 const loc_namespace_t *namespace;
817
818recheck:
819
820 /*
821 * Find namespace name in the list of known namespaces.
822 */
823 namespace = loc_namespace_find_name(name);
824
825 /*
826 * Namespace was not found.
827 */
828 if (namespace == NULL) {
829 if (IPC_GET_ARG1(*icall) & IPC_FLAG_BLOCKING) {
830 /* Blocking lookup */
831 fibril_condvar_wait(&services_list_cv,
832 &services_list_mutex);
833 goto recheck;
834 }
835
836 async_answer_0(iid, ENOENT);
837 free(name);
838 fibril_mutex_unlock(&services_list_mutex);
839 return;
840 }
841
842 async_answer_1(iid, EOK, namespace->id);
843
844 fibril_mutex_unlock(&services_list_mutex);
845 free(name);
846}
847
848/** Create callback connection.
849 *
850 * Create callback connection which will be used to send category change
851 * events.
852 *
853 * On success, answer will contain EOK errno_t retval.
854 * On failure, error code will be sent in retval.
855 *
856 */
857static void loc_callback_create(ipc_callid_t iid, ipc_call_t *icall)
858{
859 cb_sess_t *cb_sess = calloc(1, sizeof(cb_sess_t));
860 if (cb_sess == NULL) {
861 async_answer_0(iid, ENOMEM);
862 return;
863 }
864
865 async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
866 if (sess == NULL) {
867 free(cb_sess);
868 async_answer_0(iid, ENOMEM);
869 return;
870 }
871
872 cb_sess->sess = sess;
873 link_initialize(&cb_sess->cb_sess_list);
874
875 fibril_mutex_lock(&callback_sess_mutex);
876 list_append(&cb_sess->cb_sess_list, &callback_sess_list);
877 fibril_mutex_unlock(&callback_sess_mutex);
878
879 async_answer_0(iid, EOK);
880}
881
882void loc_category_change_event(void)
883{
884 fibril_mutex_lock(&callback_sess_mutex);
885
886 list_foreach(callback_sess_list, cb_sess_list, cb_sess_t, cb_sess) {
887 async_exch_t *exch = async_exchange_begin(cb_sess->sess);
888 async_msg_0(exch, LOC_EVENT_CAT_CHANGE);
889 async_exchange_end(exch);
890 }
891
892 fibril_mutex_unlock(&callback_sess_mutex);
893}
894
895/** Find ID for category specified by name.
896 *
897 * On success, answer will contain EOK errno_t retval and service ID in arg1.
898 * On failure, error code will be sent in retval.
899 *
900 */
901static void loc_category_get_id(ipc_callid_t iid, ipc_call_t *icall)
902{
903 char *name;
904 category_t *cat;
905
906 /* Get service name */
907 errno_t rc = async_data_write_accept((void **) &name, true, 0,
908 LOC_NAME_MAXLEN, 0, NULL);
909 if (rc != EOK) {
910 async_answer_0(iid, rc);
911 return;
912 }
913
914 fibril_mutex_lock(&cdir.mutex);
915
916 cat = category_find_by_name(&cdir, name);
917 if (cat == NULL) {
918 /* Category not found */
919 async_answer_0(iid, ENOENT);
920 goto cleanup;
921 }
922
923 async_answer_1(iid, EOK, cat->id);
924cleanup:
925 fibril_mutex_unlock(&cdir.mutex);
926 free(name);
927}
928
929static void loc_id_probe(ipc_callid_t iid, ipc_call_t *icall)
930{
931 fibril_mutex_lock(&services_list_mutex);
932
933 loc_namespace_t *namespace =
934 loc_namespace_find_id(IPC_GET_ARG1(*icall));
935 if (namespace == NULL) {
936 loc_service_t *svc =
937 loc_service_find_id(IPC_GET_ARG1(*icall));
938 if (svc == NULL)
939 async_answer_1(iid, EOK, LOC_OBJECT_NONE);
940 else
941 async_answer_1(iid, EOK, LOC_OBJECT_SERVICE);
942 } else
943 async_answer_1(iid, EOK, LOC_OBJECT_NAMESPACE);
944
945 fibril_mutex_unlock(&services_list_mutex);
946}
947
948static void loc_get_namespace_count(ipc_callid_t iid, ipc_call_t *icall)
949{
950 fibril_mutex_lock(&services_list_mutex);
951 async_answer_1(iid, EOK, list_count(&namespaces_list));
952 fibril_mutex_unlock(&services_list_mutex);
953}
954
955static void loc_get_service_count(ipc_callid_t iid, ipc_call_t *icall)
956{
957 fibril_mutex_lock(&services_list_mutex);
958
959 loc_namespace_t *namespace =
960 loc_namespace_find_id(IPC_GET_ARG1(*icall));
961 if (namespace == NULL)
962 async_answer_0(iid, EEXIST);
963 else
964 async_answer_1(iid, EOK, namespace->refcnt);
965
966 fibril_mutex_unlock(&services_list_mutex);
967}
968
969static void loc_get_categories(ipc_callid_t iid, ipc_call_t *icall)
970{
971 ipc_callid_t callid;
972 size_t size;
973 size_t act_size;
974 errno_t rc;
975
976 if (!async_data_read_receive(&callid, &size)) {
977 async_answer_0(callid, EREFUSED);
978 async_answer_0(iid, EREFUSED);
979 return;
980 }
981
982 category_id_t *id_buf = (category_id_t *) malloc(size);
983 if (id_buf == NULL) {
984 fibril_mutex_unlock(&cdir.mutex);
985 async_answer_0(callid, ENOMEM);
986 async_answer_0(iid, ENOMEM);
987 return;
988 }
989
990 fibril_mutex_lock(&cdir.mutex);
991
992 rc = categ_dir_get_categories(&cdir, id_buf, size, &act_size);
993 if (rc != EOK) {
994 fibril_mutex_unlock(&cdir.mutex);
995 async_answer_0(callid, rc);
996 async_answer_0(iid, rc);
997 return;
998 }
999
1000 fibril_mutex_unlock(&cdir.mutex);
1001
1002 errno_t retval = async_data_read_finalize(callid, id_buf, size);
1003 free(id_buf);
1004
1005 async_answer_1(iid, retval, act_size);
1006}
1007
1008static void loc_get_namespaces(ipc_callid_t iid, ipc_call_t *icall)
1009{
1010 ipc_callid_t callid;
1011 size_t size;
1012 if (!async_data_read_receive(&callid, &size)) {
1013 async_answer_0(callid, EREFUSED);
1014 async_answer_0(iid, EREFUSED);
1015 return;
1016 }
1017
1018 if ((size % sizeof(loc_sdesc_t)) != 0) {
1019 async_answer_0(callid, EINVAL);
1020 async_answer_0(iid, EINVAL);
1021 return;
1022 }
1023
1024 fibril_mutex_lock(&services_list_mutex);
1025
1026 size_t count = size / sizeof(loc_sdesc_t);
1027 if (count != list_count(&namespaces_list)) {
1028 fibril_mutex_unlock(&services_list_mutex);
1029 async_answer_0(callid, EOVERFLOW);
1030 async_answer_0(iid, EOVERFLOW);
1031 return;
1032 }
1033
1034 loc_sdesc_t *desc = (loc_sdesc_t *) malloc(size);
1035 if (desc == NULL) {
1036 fibril_mutex_unlock(&services_list_mutex);
1037 async_answer_0(callid, ENOMEM);
1038 async_answer_0(iid, ENOMEM);
1039 return;
1040 }
1041
1042 size_t pos = 0;
1043 list_foreach(namespaces_list, namespaces, loc_namespace_t, namespace) {
1044 desc[pos].id = namespace->id;
1045 str_cpy(desc[pos].name, LOC_NAME_MAXLEN, namespace->name);
1046 pos++;
1047 }
1048
1049 errno_t retval = async_data_read_finalize(callid, desc, size);
1050
1051 free(desc);
1052 fibril_mutex_unlock(&services_list_mutex);
1053
1054 async_answer_0(iid, retval);
1055}
1056
1057static void loc_get_services(ipc_callid_t iid, ipc_call_t *icall)
1058{
1059 /* FIXME: Use faster algorithm which can make better use
1060 of namespaces */
1061
1062 ipc_callid_t callid;
1063 size_t size;
1064 if (!async_data_read_receive(&callid, &size)) {
1065 async_answer_0(callid, EREFUSED);
1066 async_answer_0(iid, EREFUSED);
1067 return;
1068 }
1069
1070 if ((size % sizeof(loc_sdesc_t)) != 0) {
1071 async_answer_0(callid, EINVAL);
1072 async_answer_0(iid, EINVAL);
1073 return;
1074 }
1075
1076 fibril_mutex_lock(&services_list_mutex);
1077
1078 loc_namespace_t *namespace =
1079 loc_namespace_find_id(IPC_GET_ARG1(*icall));
1080 if (namespace == NULL) {
1081 fibril_mutex_unlock(&services_list_mutex);
1082 async_answer_0(callid, ENOENT);
1083 async_answer_0(iid, ENOENT);
1084 return;
1085 }
1086
1087 size_t count = size / sizeof(loc_sdesc_t);
1088 if (count != namespace->refcnt) {
1089 fibril_mutex_unlock(&services_list_mutex);
1090 async_answer_0(callid, EOVERFLOW);
1091 async_answer_0(iid, EOVERFLOW);
1092 return;
1093 }
1094
1095 loc_sdesc_t *desc = (loc_sdesc_t *) malloc(size);
1096 if (desc == NULL) {
1097 fibril_mutex_unlock(&services_list_mutex);
1098 async_answer_0(callid, ENOMEM);
1099 async_answer_0(iid, EREFUSED);
1100 return;
1101 }
1102
1103 size_t pos = 0;
1104 list_foreach(services_list, services, loc_service_t, service) {
1105 if (service->namespace == namespace) {
1106 desc[pos].id = service->id;
1107 str_cpy(desc[pos].name, LOC_NAME_MAXLEN, service->name);
1108 pos++;
1109 }
1110 }
1111
1112 errno_t retval = async_data_read_finalize(callid, desc, size);
1113
1114 free(desc);
1115 fibril_mutex_unlock(&services_list_mutex);
1116
1117 async_answer_0(iid, retval);
1118}
1119
1120static void loc_category_get_svcs(ipc_callid_t iid, ipc_call_t *icall)
1121{
1122 ipc_callid_t callid;
1123 size_t size;
1124 size_t act_size;
1125 errno_t rc;
1126
1127 if (!async_data_read_receive(&callid, &size)) {
1128 async_answer_0(callid, EREFUSED);
1129 async_answer_0(iid, EREFUSED);
1130 return;
1131 }
1132
1133 fibril_mutex_lock(&cdir.mutex);
1134
1135 category_t *cat = category_get(&cdir, IPC_GET_ARG1(*icall));
1136 if (cat == NULL) {
1137 fibril_mutex_unlock(&cdir.mutex);
1138 async_answer_0(callid, ENOENT);
1139 async_answer_0(iid, ENOENT);
1140 return;
1141 }
1142
1143 category_id_t *id_buf = (category_id_t *) malloc(size);
1144 if (id_buf == NULL) {
1145 fibril_mutex_unlock(&cdir.mutex);
1146 async_answer_0(callid, ENOMEM);
1147 async_answer_0(iid, ENOMEM);
1148 return;
1149 }
1150
1151 fibril_mutex_lock(&cat->mutex);
1152
1153 rc = category_get_services(cat, id_buf, size, &act_size);
1154 if (rc != EOK) {
1155 fibril_mutex_unlock(&cat->mutex);
1156 fibril_mutex_unlock(&cdir.mutex);
1157 async_answer_0(callid, rc);
1158 async_answer_0(iid, rc);
1159 return;
1160 }
1161
1162 fibril_mutex_unlock(&cat->mutex);
1163 fibril_mutex_unlock(&cdir.mutex);
1164
1165 errno_t retval = async_data_read_finalize(callid, id_buf, size);
1166 free(id_buf);
1167
1168 async_answer_1(iid, retval, act_size);
1169}
1170
1171
1172static void loc_null_create(ipc_callid_t iid, ipc_call_t *icall)
1173{
1174 fibril_mutex_lock(&null_services_mutex);
1175
1176 unsigned int i;
1177 bool fnd = false;
1178
1179 for (i = 0; i < NULL_SERVICES; i++) {
1180 if (null_services[i] == NULL) {
1181 fnd = true;
1182 break;
1183 }
1184 }
1185
1186 if (!fnd) {
1187 fibril_mutex_unlock(&null_services_mutex);
1188 async_answer_0(iid, ENOMEM);
1189 return;
1190 }
1191
1192 char null[LOC_NAME_MAXLEN];
1193 snprintf(null, LOC_NAME_MAXLEN, "%u", i);
1194
1195 char *dev_name = str_dup(null);
1196 if (dev_name == NULL) {
1197 fibril_mutex_unlock(&null_services_mutex);
1198 async_answer_0(iid, ENOMEM);
1199 return;
1200 }
1201
1202 loc_service_t *service =
1203 (loc_service_t *) malloc(sizeof(loc_service_t));
1204 if (service == NULL) {
1205 fibril_mutex_unlock(&null_services_mutex);
1206 async_answer_0(iid, ENOMEM);
1207 return;
1208 }
1209
1210 fibril_mutex_lock(&services_list_mutex);
1211
1212 loc_namespace_t *namespace = loc_namespace_create("null");
1213 if (namespace == NULL) {
1214 fibril_mutex_lock(&services_list_mutex);
1215 fibril_mutex_unlock(&null_services_mutex);
1216 async_answer_0(iid, ENOMEM);
1217 return;
1218 }
1219
1220 link_initialize(&service->services);
1221 link_initialize(&service->server_services);
1222 list_initialize(&service->cat_memb);
1223
1224 /* Get unique service ID */
1225 service->id = loc_create_id();
1226 service->server = NULL;
1227
1228 loc_namespace_addref(namespace, service);
1229 service->name = dev_name;
1230
1231 /*
1232 * Insert service into list of all services and into null services array.
1233 * Insert service into a dummy list of null server's services so that it
1234 * can be safely removed later.
1235 */
1236 list_append(&service->services, &services_list);
1237 list_append(&service->server_services, &dummy_null_services);
1238 null_services[i] = service;
1239
1240 fibril_mutex_unlock(&services_list_mutex);
1241 fibril_mutex_unlock(&null_services_mutex);
1242
1243 async_answer_1(iid, EOK, (sysarg_t) i);
1244}
1245
1246static void loc_null_destroy(ipc_callid_t iid, ipc_call_t *icall)
1247{
1248 sysarg_t i = IPC_GET_ARG1(*icall);
1249 if (i >= NULL_SERVICES) {
1250 async_answer_0(iid, ELIMIT);
1251 return;
1252 }
1253
1254 fibril_mutex_lock(&null_services_mutex);
1255
1256 if (null_services[i] == NULL) {
1257 fibril_mutex_unlock(&null_services_mutex);
1258 async_answer_0(iid, ENOENT);
1259 return;
1260 }
1261
1262 fibril_mutex_lock(&services_list_mutex);
1263 fibril_mutex_lock(&cdir.mutex);
1264 loc_service_unregister_core(null_services[i]);
1265 fibril_mutex_unlock(&cdir.mutex);
1266 fibril_mutex_unlock(&services_list_mutex);
1267
1268 null_services[i] = NULL;
1269
1270 fibril_mutex_unlock(&null_services_mutex);
1271 async_answer_0(iid, EOK);
1272}
1273
1274static void loc_service_add_to_cat(ipc_callid_t iid, ipc_call_t *icall)
1275{
1276 category_t *cat;
1277 loc_service_t *svc;
1278 catid_t cat_id;
1279 service_id_t svc_id;
1280 errno_t retval;
1281
1282 svc_id = IPC_GET_ARG1(*icall);
1283 cat_id = IPC_GET_ARG2(*icall);
1284
1285 fibril_mutex_lock(&services_list_mutex);
1286 fibril_mutex_lock(&cdir.mutex);
1287
1288 cat = category_get(&cdir, cat_id);
1289 svc = loc_service_find_id(svc_id);
1290
1291 if (cat == NULL || svc == NULL) {
1292 fibril_mutex_unlock(&cdir.mutex);
1293 fibril_mutex_unlock(&services_list_mutex);
1294 async_answer_0(iid, ENOENT);
1295 return;
1296 }
1297
1298 fibril_mutex_lock(&cat->mutex);
1299 retval = category_add_service(cat, svc);
1300
1301 fibril_mutex_unlock(&cat->mutex);
1302 fibril_mutex_unlock(&cdir.mutex);
1303 fibril_mutex_unlock(&services_list_mutex);
1304
1305 /*
1306 * First send out all notifications and only then answer the request.
1307 * Otherwise the current fibril might block and transitively wait for
1308 * the completion of requests that are routed to it via an IPC loop.
1309 */
1310 loc_category_change_event();
1311 async_answer_0(iid, retval);
1312}
1313
1314
1315/** Initialize location service.
1316 *
1317 *
1318 */
1319static bool loc_init(void)
1320{
1321 unsigned int i;
1322 category_t *cat;
1323
1324 for (i = 0; i < NULL_SERVICES; i++)
1325 null_services[i] = NULL;
1326
1327 categ_dir_init(&cdir);
1328
1329 cat = category_new("disk");
1330 categ_dir_add_cat(&cdir, cat);
1331
1332 cat = category_new("partition");
1333 categ_dir_add_cat(&cdir, cat);
1334
1335 cat = category_new("iplink");
1336 categ_dir_add_cat(&cdir, cat);
1337
1338 cat = category_new("keyboard");
1339 categ_dir_add_cat(&cdir, cat);
1340
1341 cat = category_new("mouse");
1342 categ_dir_add_cat(&cdir, cat);
1343
1344 cat = category_new("led");
1345 categ_dir_add_cat(&cdir, cat);
1346
1347 cat = category_new("serial");
1348 categ_dir_add_cat(&cdir, cat);
1349
1350 cat = category_new("console");
1351 categ_dir_add_cat(&cdir, cat);
1352
1353 cat = category_new("clock");
1354 categ_dir_add_cat(&cdir, cat);
1355
1356 cat = category_new("test3");
1357 categ_dir_add_cat(&cdir, cat);
1358
1359 cat = category_new("usbhc");
1360 categ_dir_add_cat(&cdir, cat);
1361
1362 cat = category_new("virt-null");
1363 categ_dir_add_cat(&cdir, cat);
1364
1365 cat = category_new("virtual");
1366 categ_dir_add_cat(&cdir, cat);
1367
1368 cat = category_new("nic");
1369 categ_dir_add_cat(&cdir, cat);
1370
1371 cat = category_new("ieee80211");
1372 categ_dir_add_cat(&cdir, cat);
1373
1374 cat = category_new("irc");
1375 categ_dir_add_cat(&cdir, cat);
1376
1377 cat = category_new("visualizer");
1378 categ_dir_add_cat(&cdir, cat);
1379
1380 cat = category_new("renderer");
1381 categ_dir_add_cat(&cdir, cat);
1382
1383 cat = category_new("audio-pcm");
1384 categ_dir_add_cat(&cdir, cat);
1385
1386 return true;
1387}
1388
1389/** Handle connection on supplier port.
1390 *
1391 */
1392static void loc_connection_supplier(ipc_callid_t iid, ipc_call_t *icall, void *arg)
1393{
1394 /* Accept connection */
1395 async_answer_0(iid, EOK);
1396
1397 loc_server_t *server = loc_server_register();
1398 if (server == NULL)
1399 return;
1400
1401 while (true) {
1402 ipc_call_t call;
1403 ipc_callid_t callid = async_get_call(&call);
1404
1405 if (!IPC_GET_IMETHOD(call))
1406 break;
1407
1408 switch (IPC_GET_IMETHOD(call)) {
1409 case LOC_SERVER_UNREGISTER:
1410 if (server == NULL)
1411 async_answer_0(callid, ENOENT);
1412 else
1413 async_answer_0(callid, EOK);
1414 break;
1415 case LOC_SERVICE_ADD_TO_CAT:
1416 /* Add service to category */
1417 loc_service_add_to_cat(callid, &call);
1418 break;
1419 case LOC_SERVICE_REGISTER:
1420 /* Register one service */
1421 loc_service_register(callid, &call, server);
1422 break;
1423 case LOC_SERVICE_UNREGISTER:
1424 /* Remove one service */
1425 loc_service_unregister(callid, &call, server);
1426 break;
1427 case LOC_SERVICE_GET_ID:
1428 loc_service_get_id(callid, &call);
1429 break;
1430 case LOC_NAMESPACE_GET_ID:
1431 loc_namespace_get_id(callid, &call);
1432 break;
1433 default:
1434 async_answer_0(callid, ENOENT);
1435 }
1436 }
1437
1438 if (server != NULL) {
1439 /*
1440 * Unregister the server and all its services.
1441 */
1442 loc_server_unregister(server);
1443 server = NULL;
1444 }
1445}
1446
1447/** Handle connection on consumer port.
1448 *
1449 */
1450static void loc_connection_consumer(ipc_callid_t iid, ipc_call_t *icall, void *arg)
1451{
1452 /* Accept connection */
1453 async_answer_0(iid, EOK);
1454
1455 while (true) {
1456 ipc_call_t call;
1457 ipc_callid_t callid = async_get_call(&call);
1458
1459 if (!IPC_GET_IMETHOD(call))
1460 break;
1461
1462 switch (IPC_GET_IMETHOD(call)) {
1463 case LOC_SERVICE_GET_ID:
1464 loc_service_get_id(callid, &call);
1465 break;
1466 case LOC_SERVICE_GET_NAME:
1467 loc_service_get_name(callid, &call);
1468 break;
1469 case LOC_SERVICE_GET_SERVER_NAME:
1470 loc_service_get_server_name(callid, &call);
1471 break;
1472 case LOC_NAMESPACE_GET_ID:
1473 loc_namespace_get_id(callid, &call);
1474 break;
1475 case LOC_CALLBACK_CREATE:
1476 loc_callback_create(callid, &call);
1477 break;
1478 case LOC_CATEGORY_GET_ID:
1479 loc_category_get_id(callid, &call);
1480 break;
1481 case LOC_CATEGORY_GET_NAME:
1482 loc_category_get_name(callid, &call);
1483 break;
1484 case LOC_CATEGORY_GET_SVCS:
1485 loc_category_get_svcs(callid, &call);
1486 break;
1487 case LOC_ID_PROBE:
1488 loc_id_probe(callid, &call);
1489 break;
1490 case LOC_NULL_CREATE:
1491 loc_null_create(callid, &call);
1492 break;
1493 case LOC_NULL_DESTROY:
1494 loc_null_destroy(callid, &call);
1495 break;
1496 case LOC_GET_NAMESPACE_COUNT:
1497 loc_get_namespace_count(callid, &call);
1498 break;
1499 case LOC_GET_SERVICE_COUNT:
1500 loc_get_service_count(callid, &call);
1501 break;
1502 case LOC_GET_CATEGORIES:
1503 loc_get_categories(callid, &call);
1504 break;
1505 case LOC_GET_NAMESPACES:
1506 loc_get_namespaces(callid, &call);
1507 break;
1508 case LOC_GET_SERVICES:
1509 loc_get_services(callid, &call);
1510 break;
1511 default:
1512 async_answer_0(callid, ENOENT);
1513 }
1514 }
1515}
1516
1517/**
1518 *
1519 */
1520int main(int argc, char *argv[])
1521{
1522 printf("%s: HelenOS Location Service\n", NAME);
1523
1524 if (!loc_init()) {
1525 printf("%s: Error while initializing service\n", NAME);
1526 return -1;
1527 }
1528
1529 port_id_t port;
1530 errno_t rc = async_create_port(INTERFACE_LOC_SUPPLIER,
1531 loc_connection_supplier, NULL, &port);
1532 if (rc != EOK) {
1533 printf("%s: Error while creating supplier port: %s\n", NAME, str_error(rc));
1534 return rc;
1535 }
1536
1537 rc = async_create_port(INTERFACE_LOC_CONSUMER,
1538 loc_connection_consumer, NULL, &port);
1539 if (rc != EOK) {
1540 printf("%s: Error while creating consumer port: %s\n", NAME, str_error(rc));
1541 return rc;
1542 }
1543
1544 /* Set a handler of incomming connections */
1545 async_set_fallback_port_handler(loc_forward, NULL);
1546
1547 /* Register location service at naming service */
1548 rc = service_register(SERVICE_LOC);
1549 if (rc != EOK) {
1550 printf("%s: Error while registering service: %s\n", NAME, str_error(rc));
1551 return rc;
1552 }
1553
1554 printf("%s: Accepting connections\n", NAME);
1555 async_manager();
1556
1557 /* Never reached */
1558 return 0;
1559}
1560
1561/**
1562 * @}
1563 */
Note: See TracBrowser for help on using the repository browser.