source: mainline/uspace/srv/locsrv/locsrv.c@ 901b302

ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 901b302 was 54593f3, checked in by Jiri Svoboda <jiri@…>, 3 years ago

Remove obsolete 'renderer' category
  • Property mode set to 100644
File size: 35.0 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 * @addtogroup locsrv
32 * @{
33 */
34
35/** @file
36 */
37
38#include <ipc/services.h>
39#include <ns.h>
40#include <async.h>
41#include <stdio.h>
42#include <errno.h>
43#include <stdbool.h>
44#include <fibril_synch.h>
45#include <macros.h>
46#include <stdlib.h>
47#include <str.h>
48#include <str_error.h>
49#include <ipc/loc.h>
50#include <assert.h>
51
52#include "category.h"
53#include "locsrv.h"
54
55#define NAME "loc"
56#define NULL_SERVICES 256
57
58/** Callback session */
59typedef struct {
60 link_t cb_sess_list;
61 async_sess_t *sess;
62} cb_sess_t;
63
64LIST_INITIALIZE(services_list);
65LIST_INITIALIZE(namespaces_list);
66LIST_INITIALIZE(servers_list);
67
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 /*
100 * TODO: allow reusing old ids after their unregistration
101 * and implement some version of LRU algorithm, avoid overflow
102 */
103
104 fibril_mutex_lock(&create_id_mutex);
105 last_id++;
106 fibril_mutex_unlock(&create_id_mutex);
107
108 return last_id;
109}
110
111/** Convert fully qualified service name to namespace and service name.
112 *
113 * A fully qualified service name can be either a plain service name
114 * (then the namespace is considered to be an empty string) or consist
115 * of two components separated by a slash. No more than one slash
116 * is allowed.
117 *
118 */
119static bool loc_fqsn_split(const char *fqsn, char **ns_name, char **name)
120{
121 size_t cnt = 0;
122 size_t slash_offset = 0;
123 size_t slash_after = 0;
124
125 size_t offset = 0;
126 size_t offset_prev = 0;
127 char32_t c;
128
129 while ((c = str_decode(fqsn, &offset, STR_NO_LIMIT)) != 0) {
130 if (c == '/') {
131 cnt++;
132 slash_offset = offset_prev;
133 slash_after = offset;
134 }
135 offset_prev = offset;
136 }
137
138 /* More than one slash */
139 if (cnt > 1)
140 return false;
141
142 /* No slash -> namespace is empty */
143 if (cnt == 0) {
144 *ns_name = str_dup("");
145 if (*ns_name == NULL)
146 return false;
147
148 *name = str_dup(fqsn);
149 if (*name == NULL) {
150 free(*ns_name);
151 return false;
152 }
153
154 if (str_cmp(*name, "") == 0) {
155 free(*name);
156 free(*ns_name);
157 return false;
158 }
159
160 return true;
161 }
162
163 /* Exactly one slash */
164 *ns_name = str_ndup(fqsn, slash_offset);
165 if (*ns_name == NULL)
166 return false;
167
168 *name = str_dup(fqsn + slash_after);
169 if (*name == NULL) {
170 free(*ns_name);
171 return false;
172 }
173
174 if (str_cmp(*name, "") == 0) {
175 free(*name);
176 free(*ns_name);
177 return false;
178 }
179
180 return true;
181}
182
183/** Find namespace with given name. */
184static loc_namespace_t *loc_namespace_find_name(const char *name)
185{
186 assert(fibril_mutex_is_locked(&services_list_mutex));
187
188 list_foreach(namespaces_list, namespaces, loc_namespace_t, namespace) {
189 if (str_cmp(namespace->name, name) == 0)
190 return namespace;
191 }
192
193 return NULL;
194}
195
196/** Find namespace with given ID.
197 *
198 * @todo: use hash table
199 *
200 */
201static loc_namespace_t *loc_namespace_find_id(service_id_t id)
202{
203 assert(fibril_mutex_is_locked(&services_list_mutex));
204
205 list_foreach(namespaces_list, namespaces, loc_namespace_t, namespace) {
206 if (namespace->id == id)
207 return namespace;
208 }
209
210 return NULL;
211}
212
213/** Find service with given name. */
214static loc_service_t *loc_service_find_name(const char *ns_name,
215 const char *name)
216{
217 assert(fibril_mutex_is_locked(&services_list_mutex));
218
219 list_foreach(services_list, services, loc_service_t, service) {
220 if ((str_cmp(service->namespace->name, ns_name) == 0) &&
221 (str_cmp(service->name, name) == 0))
222 return service;
223 }
224
225 return NULL;
226}
227
228/** Find service with given ID.
229 *
230 * @todo: use hash table
231 *
232 */
233static loc_service_t *loc_service_find_id(service_id_t id)
234{
235 assert(fibril_mutex_is_locked(&services_list_mutex));
236
237 list_foreach(services_list, services, loc_service_t, service) {
238 if (service->id == id)
239 return service;
240 }
241
242 return NULL;
243}
244
245/** Create a namespace (if not already present). */
246static loc_namespace_t *loc_namespace_create(const char *ns_name)
247{
248 loc_namespace_t *namespace;
249
250 assert(fibril_mutex_is_locked(&services_list_mutex));
251
252 namespace = loc_namespace_find_name(ns_name);
253 if (namespace != NULL)
254 return namespace;
255
256 namespace = (loc_namespace_t *) malloc(sizeof(loc_namespace_t));
257 if (namespace == NULL)
258 return NULL;
259
260 namespace->name = str_dup(ns_name);
261 if (namespace->name == NULL) {
262 free(namespace);
263 return NULL;
264 }
265
266 namespace->id = loc_create_id();
267 namespace->refcnt = 0;
268
269 /*
270 * Insert new namespace into list of registered namespaces
271 */
272 list_append(&(namespace->namespaces), &namespaces_list);
273
274 return namespace;
275}
276
277/** Destroy a namespace (if it is no longer needed). */
278static void loc_namespace_destroy(loc_namespace_t *namespace)
279{
280 assert(fibril_mutex_is_locked(&services_list_mutex));
281
282 if (namespace->refcnt == 0) {
283 list_remove(&(namespace->namespaces));
284
285 free(namespace->name);
286 free(namespace);
287 }
288}
289
290/** Increase namespace reference count by including service. */
291static void loc_namespace_addref(loc_namespace_t *namespace,
292 loc_service_t *service)
293{
294 assert(fibril_mutex_is_locked(&services_list_mutex));
295
296 service->namespace = namespace;
297 namespace->refcnt++;
298}
299
300/** Decrease namespace reference count. */
301static void loc_namespace_delref(loc_namespace_t *namespace)
302{
303 assert(fibril_mutex_is_locked(&services_list_mutex));
304
305 namespace->refcnt--;
306 loc_namespace_destroy(namespace);
307}
308
309/** Unregister service and free it. */
310static void loc_service_unregister_core(loc_service_t *service)
311{
312 assert(fibril_mutex_is_locked(&services_list_mutex));
313 assert(fibril_mutex_is_locked(&cdir.mutex));
314
315 loc_namespace_delref(service->namespace);
316 list_remove(&(service->services));
317 list_remove(&(service->server_services));
318
319 /* Remove service from all categories. */
320 while (!list_empty(&service->cat_memb)) {
321 link_t *link = list_first(&service->cat_memb);
322 svc_categ_t *memb = list_get_instance(link, svc_categ_t,
323 svc_link);
324 category_t *cat = memb->cat;
325
326 fibril_mutex_lock(&cat->mutex);
327 category_remove_service(memb);
328 fibril_mutex_unlock(&cat->mutex);
329 }
330
331 free(service->name);
332 free(service);
333}
334
335/**
336 * Read info about new server and add it into linked list of registered
337 * servers.
338 */
339static loc_server_t *loc_server_register(void)
340{
341 ipc_call_t icall;
342 async_get_call(&icall);
343
344 if (ipc_get_imethod(&icall) != LOC_SERVER_REGISTER) {
345 async_answer_0(&icall, EREFUSED);
346 return NULL;
347 }
348
349 loc_server_t *server =
350 (loc_server_t *) malloc(sizeof(loc_server_t));
351 if (server == NULL) {
352 async_answer_0(&icall, ENOMEM);
353 return NULL;
354 }
355
356 /*
357 * Get server name
358 */
359 errno_t rc = async_data_write_accept((void **) &server->name, true, 0,
360 LOC_NAME_MAXLEN, 0, NULL);
361 if (rc != EOK) {
362 free(server);
363 async_answer_0(&icall, rc);
364 return NULL;
365 }
366
367 /*
368 * Create connection to the server
369 */
370 server->sess = async_callback_receive(EXCHANGE_SERIALIZE);
371 if (!server->sess) {
372 free(server->name);
373 free(server);
374 async_answer_0(&icall, ENOTSUP);
375 return NULL;
376 }
377
378 /*
379 * Initialize mutex for list of services
380 * supplied by this server
381 */
382 fibril_mutex_initialize(&server->services_mutex);
383
384 /*
385 * Initialize list of supplied services
386 */
387 list_initialize(&server->services);
388 link_initialize(&server->servers);
389
390 fibril_mutex_lock(&servers_list_mutex);
391
392 /*
393 * TODO:
394 * Check that no server with name equal to
395 * server->name is registered
396 */
397
398 /*
399 * Insert new server into list of registered servers
400 */
401 list_append(&(server->servers), &servers_list);
402 fibril_mutex_unlock(&servers_list_mutex);
403
404 async_answer_0(&icall, EOK);
405
406 return server;
407}
408
409/**
410 * Unregister server, unregister all its services and free server
411 * structure.
412 *
413 */
414static errno_t loc_server_unregister(loc_server_t *server)
415{
416 if (server == NULL)
417 return EEXIST;
418
419 fibril_mutex_lock(&servers_list_mutex);
420
421 if (server->sess)
422 async_hangup(server->sess);
423
424 /* Remove it from list of servers */
425 list_remove(&(server->servers));
426
427 /* Unregister all its services */
428 fibril_mutex_lock(&services_list_mutex);
429 fibril_mutex_lock(&server->services_mutex);
430 fibril_mutex_lock(&cdir.mutex);
431
432 while (!list_empty(&server->services)) {
433 loc_service_t *service = list_get_instance(
434 list_first(&server->services), loc_service_t,
435 server_services);
436 loc_service_unregister_core(service);
437 }
438
439 fibril_mutex_unlock(&cdir.mutex);
440 fibril_mutex_unlock(&server->services_mutex);
441 fibril_mutex_unlock(&services_list_mutex);
442 fibril_mutex_unlock(&servers_list_mutex);
443
444 /* Free name and server */
445 if (server->name != NULL)
446 free(server->name);
447
448 free(server);
449
450 loc_category_change_event();
451 return EOK;
452}
453
454/** Register service
455 *
456 */
457static void loc_service_register(ipc_call_t *icall, loc_server_t *server)
458{
459 if (server == NULL) {
460 async_answer_0(icall, EREFUSED);
461 return;
462 }
463
464 /* Create new service entry */
465 loc_service_t *service =
466 (loc_service_t *) malloc(sizeof(loc_service_t));
467 if (service == NULL) {
468 async_answer_0(icall, ENOMEM);
469 return;
470 }
471
472 /* Get fqsn */
473 char *fqsn;
474 errno_t rc = async_data_write_accept((void **) &fqsn, true, 0,
475 LOC_NAME_MAXLEN, 0, NULL);
476 if (rc != EOK) {
477 free(service);
478 async_answer_0(icall, rc);
479 return;
480 }
481
482 char *ns_name;
483 if (!loc_fqsn_split(fqsn, &ns_name, &service->name)) {
484 free(fqsn);
485 free(service);
486 async_answer_0(icall, EINVAL);
487 return;
488 }
489
490 free(fqsn);
491
492 fibril_mutex_lock(&services_list_mutex);
493
494 loc_namespace_t *namespace = loc_namespace_create(ns_name);
495 free(ns_name);
496 if (namespace == NULL) {
497 fibril_mutex_unlock(&services_list_mutex);
498 free(service->name);
499 free(service);
500 async_answer_0(icall, ENOMEM);
501 return;
502 }
503
504 link_initialize(&service->services);
505 link_initialize(&service->server_services);
506 list_initialize(&service->cat_memb);
507
508 /* Check that service is not already registered */
509 if (loc_service_find_name(namespace->name, service->name) != NULL) {
510 printf("%s: Service '%s/%s' already registered\n", NAME,
511 namespace->name, service->name);
512 loc_namespace_destroy(namespace);
513 fibril_mutex_unlock(&services_list_mutex);
514 free(service->name);
515 free(service);
516 async_answer_0(icall, EEXIST);
517 return;
518 }
519
520 /* Get unique service ID */
521 service->id = loc_create_id();
522
523 loc_namespace_addref(namespace, service);
524 service->server = server;
525
526 /* Insert service into list of all services */
527 list_append(&service->services, &services_list);
528
529 /* Insert service into list of services supplied by one server */
530 fibril_mutex_lock(&service->server->services_mutex);
531
532 list_append(&service->server_services, &service->server->services);
533
534 fibril_mutex_unlock(&service->server->services_mutex);
535 fibril_condvar_broadcast(&services_list_cv);
536 fibril_mutex_unlock(&services_list_mutex);
537
538 async_answer_1(icall, EOK, service->id);
539}
540
541/**
542 *
543 */
544static void loc_service_unregister(ipc_call_t *icall, 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(icall, 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(icall, EOK);
568}
569
570static void loc_category_get_name(ipc_call_t *icall)
571{
572 ipc_call_t call;
573 size_t size;
574 size_t act_size;
575 category_t *cat;
576
577 if (!async_data_read_receive(&call, &size)) {
578 async_answer_0(&call, EREFUSED);
579 async_answer_0(icall, 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(&call, ENOENT);
589 async_answer_0(icall, 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(&call, EOVERFLOW);
597 async_answer_0(icall, EOVERFLOW);
598 return;
599 }
600
601 errno_t retval = async_data_read_finalize(&call, cat->name,
602 min(size, act_size));
603
604 fibril_mutex_unlock(&cdir.mutex);
605
606 async_answer_0(icall, retval);
607}
608
609static void loc_service_get_name(ipc_call_t *icall)
610{
611 ipc_call_t call;
612 size_t size;
613 size_t act_size;
614 loc_service_t *svc;
615 char *fqn;
616
617 if (!async_data_read_receive(&call, &size)) {
618 async_answer_0(&call, EREFUSED);
619 async_answer_0(icall, 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(&call, ENOENT);
629 async_answer_0(icall, 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(&call, ENOMEM);
636 async_answer_0(icall, 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(&call, EOVERFLOW);
645 async_answer_0(icall, EOVERFLOW);
646 return;
647 }
648
649 errno_t retval = async_data_read_finalize(&call, fqn,
650 min(size, act_size));
651 free(fqn);
652
653 fibril_mutex_unlock(&services_list_mutex);
654
655 async_answer_0(icall, retval);
656}
657
658static void loc_service_get_server_name(ipc_call_t *icall)
659{
660 ipc_call_t call;
661 size_t size;
662 size_t act_size;
663 loc_service_t *svc;
664
665 if (!async_data_read_receive(&call, &size)) {
666 async_answer_0(&call, EREFUSED);
667 async_answer_0(icall, 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(&call, ENOENT);
677 async_answer_0(icall, ENOENT);
678 return;
679 }
680
681 if (svc->server == NULL) {
682 fibril_mutex_unlock(&services_list_mutex);
683 async_answer_0(&call, EINVAL);
684 async_answer_0(icall, 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(&call, EOVERFLOW);
692 async_answer_0(icall, EOVERFLOW);
693 return;
694 }
695
696 errno_t retval = async_data_read_finalize(&call, svc->server->name,
697 min(size, act_size));
698
699 fibril_mutex_unlock(&services_list_mutex);
700
701 async_answer_0(icall, 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_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(call, ENOENT);
724 return;
725 }
726
727 async_exch_t *exch = async_exchange_begin(svc->server->sess);
728 async_forward_1(call, exch, iface, svc->id, 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_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(icall, 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(icall, 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(icall, ENOENT);
784 free(ns_name);
785 free(name);
786 fibril_mutex_unlock(&services_list_mutex);
787 return;
788 }
789
790 async_answer_1(icall, 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_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(icall, 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(icall, ENOENT);
837 free(name);
838 fibril_mutex_unlock(&services_list_mutex);
839 return;
840 }
841
842 async_answer_1(icall, 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_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(icall, 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(icall, 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(icall, 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_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(icall, 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(icall, ENOENT);
920 goto cleanup;
921 }
922
923 async_answer_1(icall, EOK, cat->id);
924cleanup:
925 fibril_mutex_unlock(&cdir.mutex);
926 free(name);
927}
928
929static void loc_id_probe(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(icall, EOK, LOC_OBJECT_NONE);
940 else
941 async_answer_1(icall, EOK, LOC_OBJECT_SERVICE);
942 } else
943 async_answer_1(icall, EOK, LOC_OBJECT_NAMESPACE);
944
945 fibril_mutex_unlock(&services_list_mutex);
946}
947
948static void loc_get_namespace_count(ipc_call_t *icall)
949{
950 fibril_mutex_lock(&services_list_mutex);
951 async_answer_1(icall, EOK, list_count(&namespaces_list));
952 fibril_mutex_unlock(&services_list_mutex);
953}
954
955static void loc_get_service_count(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(icall, EEXIST);
963 else
964 async_answer_1(icall, EOK, namespace->refcnt);
965
966 fibril_mutex_unlock(&services_list_mutex);
967}
968
969static void loc_get_categories(ipc_call_t *icall)
970{
971 ipc_call_t call;
972 size_t size;
973 size_t act_size;
974 errno_t rc;
975
976 if (!async_data_read_receive(&call, &size)) {
977 async_answer_0(&call, EREFUSED);
978 async_answer_0(icall, 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(&call, ENOMEM);
986 async_answer_0(icall, 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(&call, rc);
996 async_answer_0(icall, rc);
997 return;
998 }
999
1000 fibril_mutex_unlock(&cdir.mutex);
1001
1002 errno_t retval = async_data_read_finalize(&call, id_buf, size);
1003 free(id_buf);
1004
1005 async_answer_1(icall, retval, act_size);
1006}
1007
1008static void loc_get_namespaces(ipc_call_t *icall)
1009{
1010 ipc_call_t call;
1011 size_t size;
1012 if (!async_data_read_receive(&call, &size)) {
1013 async_answer_0(&call, EREFUSED);
1014 async_answer_0(icall, EREFUSED);
1015 return;
1016 }
1017
1018 if ((size % sizeof(loc_sdesc_t)) != 0) {
1019 async_answer_0(&call, EINVAL);
1020 async_answer_0(icall, 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(&call, EOVERFLOW);
1030 async_answer_0(icall, 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(&call, ENOMEM);
1038 async_answer_0(icall, 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(&call, desc, size);
1050
1051 free(desc);
1052 fibril_mutex_unlock(&services_list_mutex);
1053
1054 async_answer_0(icall, retval);
1055}
1056
1057static void loc_get_services(ipc_call_t *icall)
1058{
1059 /*
1060 * FIXME: Use faster algorithm which can make better use
1061 * of namespaces
1062 */
1063
1064 ipc_call_t call;
1065 size_t size;
1066 if (!async_data_read_receive(&call, &size)) {
1067 async_answer_0(&call, EREFUSED);
1068 async_answer_0(icall, EREFUSED);
1069 return;
1070 }
1071
1072 if ((size % sizeof(loc_sdesc_t)) != 0) {
1073 async_answer_0(&call, EINVAL);
1074 async_answer_0(icall, EINVAL);
1075 return;
1076 }
1077
1078 fibril_mutex_lock(&services_list_mutex);
1079
1080 loc_namespace_t *namespace =
1081 loc_namespace_find_id(ipc_get_arg1(icall));
1082 if (namespace == NULL) {
1083 fibril_mutex_unlock(&services_list_mutex);
1084 async_answer_0(&call, ENOENT);
1085 async_answer_0(icall, ENOENT);
1086 return;
1087 }
1088
1089 size_t count = size / sizeof(loc_sdesc_t);
1090 if (count != namespace->refcnt) {
1091 fibril_mutex_unlock(&services_list_mutex);
1092 async_answer_0(&call, EOVERFLOW);
1093 async_answer_0(icall, EOVERFLOW);
1094 return;
1095 }
1096
1097 loc_sdesc_t *desc = (loc_sdesc_t *) malloc(size);
1098 if (desc == NULL) {
1099 fibril_mutex_unlock(&services_list_mutex);
1100 async_answer_0(&call, ENOMEM);
1101 async_answer_0(icall, EREFUSED);
1102 return;
1103 }
1104
1105 size_t pos = 0;
1106 list_foreach(services_list, services, loc_service_t, service) {
1107 if (service->namespace == namespace) {
1108 desc[pos].id = service->id;
1109 str_cpy(desc[pos].name, LOC_NAME_MAXLEN, service->name);
1110 pos++;
1111 }
1112 }
1113
1114 errno_t retval = async_data_read_finalize(&call, desc, size);
1115
1116 free(desc);
1117 fibril_mutex_unlock(&services_list_mutex);
1118
1119 async_answer_0(icall, retval);
1120}
1121
1122static void loc_category_get_svcs(ipc_call_t *icall)
1123{
1124 ipc_call_t call;
1125 size_t size;
1126 size_t act_size;
1127 errno_t rc;
1128
1129 if (!async_data_read_receive(&call, &size)) {
1130 async_answer_0(&call, EREFUSED);
1131 async_answer_0(icall, EREFUSED);
1132 return;
1133 }
1134
1135 fibril_mutex_lock(&cdir.mutex);
1136
1137 category_t *cat = category_get(&cdir, ipc_get_arg1(icall));
1138 if (cat == NULL) {
1139 fibril_mutex_unlock(&cdir.mutex);
1140 async_answer_0(&call, ENOENT);
1141 async_answer_0(icall, ENOENT);
1142 return;
1143 }
1144
1145 category_id_t *id_buf = (category_id_t *) malloc(size);
1146 if (id_buf == NULL) {
1147 fibril_mutex_unlock(&cdir.mutex);
1148 async_answer_0(&call, ENOMEM);
1149 async_answer_0(icall, ENOMEM);
1150 return;
1151 }
1152
1153 fibril_mutex_lock(&cat->mutex);
1154
1155 rc = category_get_services(cat, id_buf, size, &act_size);
1156 if (rc != EOK) {
1157 fibril_mutex_unlock(&cat->mutex);
1158 fibril_mutex_unlock(&cdir.mutex);
1159 async_answer_0(&call, rc);
1160 async_answer_0(icall, rc);
1161 return;
1162 }
1163
1164 fibril_mutex_unlock(&cat->mutex);
1165 fibril_mutex_unlock(&cdir.mutex);
1166
1167 errno_t retval = async_data_read_finalize(&call, id_buf, size);
1168 free(id_buf);
1169
1170 async_answer_1(icall, retval, act_size);
1171}
1172
1173static void loc_null_create(ipc_call_t *icall)
1174{
1175 fibril_mutex_lock(&null_services_mutex);
1176
1177 unsigned int i;
1178 bool fnd = false;
1179
1180 for (i = 0; i < NULL_SERVICES; i++) {
1181 if (null_services[i] == NULL) {
1182 fnd = true;
1183 break;
1184 }
1185 }
1186
1187 if (!fnd) {
1188 fibril_mutex_unlock(&null_services_mutex);
1189 async_answer_0(icall, ENOMEM);
1190 return;
1191 }
1192
1193 char null[LOC_NAME_MAXLEN];
1194 snprintf(null, LOC_NAME_MAXLEN, "%u", i);
1195
1196 char *dev_name = str_dup(null);
1197 if (dev_name == NULL) {
1198 fibril_mutex_unlock(&null_services_mutex);
1199 async_answer_0(icall, ENOMEM);
1200 return;
1201 }
1202
1203 loc_service_t *service =
1204 (loc_service_t *) malloc(sizeof(loc_service_t));
1205 if (service == NULL) {
1206 fibril_mutex_unlock(&null_services_mutex);
1207 async_answer_0(icall, ENOMEM);
1208 return;
1209 }
1210
1211 fibril_mutex_lock(&services_list_mutex);
1212
1213 loc_namespace_t *namespace = loc_namespace_create("null");
1214 if (namespace == NULL) {
1215 fibril_mutex_lock(&services_list_mutex);
1216 fibril_mutex_unlock(&null_services_mutex);
1217 async_answer_0(icall, ENOMEM);
1218 return;
1219 }
1220
1221 link_initialize(&service->services);
1222 link_initialize(&service->server_services);
1223 list_initialize(&service->cat_memb);
1224
1225 /* Get unique service ID */
1226 service->id = loc_create_id();
1227 service->server = NULL;
1228
1229 loc_namespace_addref(namespace, service);
1230 service->name = dev_name;
1231
1232 /*
1233 * Insert service into list of all services and into null services array.
1234 * Insert service into a dummy list of null server's services so that it
1235 * can be safely removed later.
1236 */
1237 list_append(&service->services, &services_list);
1238 list_append(&service->server_services, &dummy_null_services);
1239 null_services[i] = service;
1240
1241 fibril_mutex_unlock(&services_list_mutex);
1242 fibril_mutex_unlock(&null_services_mutex);
1243
1244 async_answer_1(icall, EOK, (sysarg_t) i);
1245}
1246
1247static void loc_null_destroy(ipc_call_t *icall)
1248{
1249 sysarg_t i = ipc_get_arg1(icall);
1250 if (i >= NULL_SERVICES) {
1251 async_answer_0(icall, ELIMIT);
1252 return;
1253 }
1254
1255 fibril_mutex_lock(&null_services_mutex);
1256
1257 if (null_services[i] == NULL) {
1258 fibril_mutex_unlock(&null_services_mutex);
1259 async_answer_0(icall, ENOENT);
1260 return;
1261 }
1262
1263 fibril_mutex_lock(&services_list_mutex);
1264 fibril_mutex_lock(&cdir.mutex);
1265 loc_service_unregister_core(null_services[i]);
1266 fibril_mutex_unlock(&cdir.mutex);
1267 fibril_mutex_unlock(&services_list_mutex);
1268
1269 null_services[i] = NULL;
1270
1271 fibril_mutex_unlock(&null_services_mutex);
1272 async_answer_0(icall, EOK);
1273}
1274
1275static void loc_service_add_to_cat(ipc_call_t *icall)
1276{
1277 category_t *cat;
1278 loc_service_t *svc;
1279 catid_t cat_id;
1280 service_id_t svc_id;
1281 errno_t retval;
1282
1283 svc_id = ipc_get_arg1(icall);
1284 cat_id = ipc_get_arg2(icall);
1285
1286 fibril_mutex_lock(&services_list_mutex);
1287 fibril_mutex_lock(&cdir.mutex);
1288
1289 cat = category_get(&cdir, cat_id);
1290 svc = loc_service_find_id(svc_id);
1291
1292 if (cat == NULL || svc == NULL) {
1293 fibril_mutex_unlock(&cdir.mutex);
1294 fibril_mutex_unlock(&services_list_mutex);
1295 async_answer_0(icall, ENOENT);
1296 return;
1297 }
1298
1299 fibril_mutex_lock(&cat->mutex);
1300 retval = category_add_service(cat, svc);
1301
1302 fibril_mutex_unlock(&cat->mutex);
1303 fibril_mutex_unlock(&cdir.mutex);
1304 fibril_mutex_unlock(&services_list_mutex);
1305
1306 /*
1307 * First send out all notifications and only then answer the request.
1308 * Otherwise the current fibril might block and transitively wait for
1309 * the completion of requests that are routed to it via an IPC loop.
1310 */
1311 loc_category_change_event();
1312 async_answer_0(icall, retval);
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("usbdiag");
1360 categ_dir_add_cat(&cdir, cat);
1361
1362 cat = category_new("usbhc");
1363 categ_dir_add_cat(&cdir, cat);
1364
1365 cat = category_new("virt-null");
1366 categ_dir_add_cat(&cdir, cat);
1367
1368 cat = category_new("virtual");
1369 categ_dir_add_cat(&cdir, cat);
1370
1371 cat = category_new("nic");
1372 categ_dir_add_cat(&cdir, cat);
1373
1374 cat = category_new("ieee80211");
1375 categ_dir_add_cat(&cdir, cat);
1376
1377 cat = category_new("irc");
1378 categ_dir_add_cat(&cdir, cat);
1379
1380 cat = category_new("display-device");
1381 categ_dir_add_cat(&cdir, cat);
1382
1383 cat = category_new("audio-pcm");
1384 categ_dir_add_cat(&cdir, cat);
1385
1386 cat = category_new("printer-port");
1387 categ_dir_add_cat(&cdir, cat);
1388
1389 cat = category_new("pci");
1390 categ_dir_add_cat(&cdir, cat);
1391
1392 return true;
1393}
1394
1395/** Handle connection on supplier port.
1396 *
1397 */
1398static void loc_connection_supplier(ipc_call_t *icall, void *arg)
1399{
1400 /* Accept connection */
1401 async_accept_0(icall);
1402
1403 /*
1404 * Each connection begins by a LOC_SERVER_REGISTER, which precludes us
1405 * from using parallel exchanges.
1406 */
1407 static_assert((INTERFACE_LOC_SUPPLIER & IFACE_EXCHANGE_MASK) ==
1408 IFACE_EXCHANGE_SERIALIZE, "");
1409
1410 loc_server_t *server = loc_server_register();
1411 if (server == NULL)
1412 return;
1413
1414 while (true) {
1415 ipc_call_t call;
1416 async_get_call(&call);
1417
1418 if (!ipc_get_imethod(&call)) {
1419 async_answer_0(&call, EOK);
1420 break;
1421 }
1422
1423 switch (ipc_get_imethod(&call)) {
1424 case LOC_SERVER_UNREGISTER:
1425 if (server == NULL)
1426 async_answer_0(&call, ENOENT);
1427 else
1428 async_answer_0(&call, EOK);
1429 break;
1430 case LOC_SERVICE_ADD_TO_CAT:
1431 /* Add service to category */
1432 loc_service_add_to_cat(&call);
1433 break;
1434 case LOC_SERVICE_REGISTER:
1435 /* Register one service */
1436 loc_service_register(&call, server);
1437 break;
1438 case LOC_SERVICE_UNREGISTER:
1439 /* Remove one service */
1440 loc_service_unregister(&call, server);
1441 break;
1442 case LOC_SERVICE_GET_ID:
1443 loc_service_get_id(&call);
1444 break;
1445 case LOC_NAMESPACE_GET_ID:
1446 loc_namespace_get_id(&call);
1447 break;
1448 default:
1449 async_answer_0(&call, ENOENT);
1450 }
1451 }
1452
1453 if (server != NULL) {
1454 /*
1455 * Unregister the server and all its services.
1456 */
1457 loc_server_unregister(server);
1458 server = NULL;
1459 }
1460}
1461
1462/** Handle connection on consumer port.
1463 *
1464 */
1465static void loc_connection_consumer(ipc_call_t *icall, void *arg)
1466{
1467 /* Accept connection */
1468 async_accept_0(icall);
1469
1470 while (true) {
1471 ipc_call_t call;
1472 async_get_call(&call);
1473
1474 if (!ipc_get_imethod(&call)) {
1475 async_answer_0(&call, EOK);
1476 break;
1477 }
1478
1479 switch (ipc_get_imethod(&call)) {
1480 case LOC_SERVICE_GET_ID:
1481 loc_service_get_id(&call);
1482 break;
1483 case LOC_SERVICE_GET_NAME:
1484 loc_service_get_name(&call);
1485 break;
1486 case LOC_SERVICE_GET_SERVER_NAME:
1487 loc_service_get_server_name(&call);
1488 break;
1489 case LOC_NAMESPACE_GET_ID:
1490 loc_namespace_get_id(&call);
1491 break;
1492 case LOC_CALLBACK_CREATE:
1493 loc_callback_create(&call);
1494 break;
1495 case LOC_CATEGORY_GET_ID:
1496 loc_category_get_id(&call);
1497 break;
1498 case LOC_CATEGORY_GET_NAME:
1499 loc_category_get_name(&call);
1500 break;
1501 case LOC_CATEGORY_GET_SVCS:
1502 loc_category_get_svcs(&call);
1503 break;
1504 case LOC_ID_PROBE:
1505 loc_id_probe(&call);
1506 break;
1507 case LOC_NULL_CREATE:
1508 loc_null_create(&call);
1509 break;
1510 case LOC_NULL_DESTROY:
1511 loc_null_destroy(&call);
1512 break;
1513 case LOC_GET_NAMESPACE_COUNT:
1514 loc_get_namespace_count(&call);
1515 break;
1516 case LOC_GET_SERVICE_COUNT:
1517 loc_get_service_count(&call);
1518 break;
1519 case LOC_GET_CATEGORIES:
1520 loc_get_categories(&call);
1521 break;
1522 case LOC_GET_NAMESPACES:
1523 loc_get_namespaces(&call);
1524 break;
1525 case LOC_GET_SERVICES:
1526 loc_get_services(&call);
1527 break;
1528 default:
1529 async_answer_0(&call, ENOENT);
1530 }
1531 }
1532}
1533
1534/**
1535 *
1536 */
1537int main(int argc, char *argv[])
1538{
1539 printf("%s: HelenOS Location Service\n", NAME);
1540
1541 if (!loc_init()) {
1542 printf("%s: Error while initializing service\n", NAME);
1543 return -1;
1544 }
1545
1546 /* Register location service at naming service */
1547 errno_t rc = service_register(SERVICE_LOC, INTERFACE_LOC_SUPPLIER,
1548 loc_connection_supplier, NULL);
1549 if (rc != EOK) {
1550 printf("%s: Error while registering supplier service: %s\n", NAME, str_error(rc));
1551 return rc;
1552 }
1553
1554 rc = service_register(SERVICE_LOC, INTERFACE_LOC_CONSUMER,
1555 loc_connection_consumer, NULL);
1556 if (rc != EOK) {
1557 printf("%s: Error while registering consumer service: %s\n", NAME, str_error(rc));
1558 return rc;
1559 }
1560
1561 rc = service_register_broker(SERVICE_LOC, loc_forward, NULL);
1562 if (rc != EOK) {
1563 printf("%s: Error while registering broker service: %s\n", NAME, str_error(rc));
1564 return rc;
1565 }
1566
1567 printf("%s: Accepting connections\n", NAME);
1568 async_manager();
1569
1570 /* Never reached */
1571 return 0;
1572}
1573
1574/**
1575 * @}
1576 */
Note: See TracBrowser for help on using the repository browser.