WebSVN – HelenOS – Diff – /trunk/uspace/srv/ns/ns.c


/*
 * Copyright (c) 2006 Ondrej Palkovsky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup ns
 * @{
 */
 
/**
 * @file  ns.c
 * @brief Naming service for HelenOS IPC.
 */
 
#include <ipc/ipc.h>
#include <ipc/services.h>
#include <ipc/ns.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <as.h>
#include <ddi.h>
#include <event.h>
#include <macros.h>
#include <sysinfo.h>
#include "ns.h"
#include "service.h"
#include "clonable.h"
#include "task.h"
 
static void *clockaddr = NULL;
static void *klogaddr = NULL;
 
static void get_as_area(ipc_callid_t callid, ipc_call_t *call, void *ph_addr,
    size_t pages, void **addr)
{
    if (ph_addr == NULL) {
        ipc_answer_0(callid, ENOENT);
        return;
    }
   
    if (*addr == NULL) {
        *addr = as_get_mappable_page(pages * PAGE_SIZE);
       
        if (*addr == NULL) {
            ipc_answer_0(callid, ENOENT);
            return;
        }
       
        if (physmem_map(ph_addr, *addr, pages,
            AS_AREA_READ | AS_AREA_CACHEABLE) != 0) {
            ipc_answer_0(callid, ENOENT);
            return;
        }
    }
   
    ipc_answer_2(callid, EOK, (ipcarg_t) *addr, AS_AREA_READ);
}
 
int main(int argc, char **argv)
{
    printf(NAME ": HelenOS IPC Naming Service\n");
   
    int rc = service_init();
    if (rc != EOK)
        return rc;
   
    rc = clonable_init();
    if (rc != EOK)
        return rc;
   
    rc = task_init();
    if (rc != EOK)
        return rc;
   
    printf(NAME ": Accepting connections\n");
   
    while (true) {
        process_pending_conn();
        process_pending_wait();
       
        ipc_call_t call;
        ipc_callid_t callid = ipc_wait_for_call(&call);
       
        task_id_t id;
        ipcarg_t retval;
       
        if (callid & IPC_CALLID_NOTIFICATION) {
            id = (task_id_t)
                MERGE_LOUP32(IPC_GET_ARG2(call), IPC_GET_ARG3(call));
            wait_notification((wait_type_t) IPC_GET_ARG1(call), id);
            continue;
        }
       
        switch (IPC_GET_METHOD(call)) {
        case IPC_M_SHARE_IN:
            switch (IPC_GET_ARG3(call)) {
            case SERVICE_MEM_REALTIME:
                get_as_area(callid, &call,
                    (void *) sysinfo_value("clock.faddr"),
                    1, &clockaddr);
                break;
            case SERVICE_MEM_KLOG:
                get_as_area(callid, &call,
                    (void *) sysinfo_value("klog.faddr"),
                    sysinfo_value("klog.pages"), &klogaddr);
                break;
            default:
                ipc_answer_0(callid, ENOENT);
            }
            continue;
        case IPC_M_PHONE_HUNGUP:
            retval = EOK;
            break;
        case IPC_M_CONNECT_TO_ME:
            /*
             * Server requests service registration.
             */
            if (service_clonable(IPC_GET_ARG1(call))) {
                register_clonable(IPC_GET_ARG1(call),
                    IPC_GET_ARG5(call), &call, callid);
                continue;
            } else {
                retval = register_service(IPC_GET_ARG1(call),
                    IPC_GET_ARG5(call), &call);
            }
            break;
        case IPC_M_CONNECT_ME_TO:
            /*
             * Client requests to be connected to a service.
             */
            if (service_clonable(IPC_GET_ARG1(call))) {
                connect_to_clonable(IPC_GET_ARG1(call),
                    &call, callid);
                continue;
            } else {
                connect_to_service(IPC_GET_ARG1(call), &call,
                    callid);
                continue;
            }
            break;
        case NS_PING:
            retval = EOK;
            break;
        case NS_TASK_WAIT:
            id = (task_id_t)
                MERGE_LOUP32(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
            wait_for_task(id, &call, callid);
            continue;
        default:
            retval = ENOENT;
            break;
        }
       
        if (!(callid & IPC_CALLID_NOTIFICATION))
            ipc_answer_0(callid, retval);
    }
   
    /* Not reached */
    return 0;
}
 
/**
 * @}
 */
 

Rev 4459	Rev 4496
1	/*	1	/*
2	* Copyright (c) 2006 Ondrej Palkovsky	2	* Copyright (c) 2006 Ondrej Palkovsky
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup ns	29	/** @addtogroup ns
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/**	33	/**
34	* @file ns.c	34	* @file ns.c
35	* @brief Naming service for HelenOS IPC.	35	* @brief Naming service for HelenOS IPC.
36	*/	36	*/
37		37
38	#include <ipc/ipc.h>	38	#include <ipc/ipc.h>
39	#include <ipc/services.h>	39	#include <ipc/services.h>
40	#include <ipc/ns.h>	40	#include <ipc/ns.h>
41	#include <unistd.h>	41	#include <unistd.h>
42	#include <stdio.h>	42	#include <stdio.h>
43	#include <errno.h>	43	#include <errno.h>
44	#include <as.h>	44	#include <as.h>
45	#include <ddi.h>	45	#include <ddi.h>
46	#include <event.h>	46	#include <event.h>
47	#include <macros.h>	47	#include <macros.h>
-		48	#include <sysinfo.h>
48	#include "ns.h"	49	#include "ns.h"
49	#include "service.h"	50	#include "service.h"
50	#include "clonable.h"	51	#include "clonable.h"
51	#include "task.h"	52	#include "task.h"
52		53
53	static void *clockaddr = NULL;	54	static void *clockaddr = NULL;
54	static void *klogaddr = NULL;	55	static void *klogaddr = NULL;
55		56
56	static void get_as_area(ipc_callid_t callid, ipc_call_t call, void ph_addr,	57	static void get_as_area(ipc_callid_t callid, ipc_call_t call, void ph_addr,
57	size_t pages, void **addr)	58	size_t pages, void **addr)
58	{	59	{
59	if (ph_addr == NULL) {	60	if (ph_addr == NULL) {
60	ipc_answer_0(callid, ENOENT);	61	ipc_answer_0(callid, ENOENT);
61	return;	62	return;
62	}	63	}
63		64
64	if (*addr == NULL) {	65	if (*addr == NULL) {
65	addr = as_get_mappable_page(pages PAGE_SIZE);	66	addr = as_get_mappable_page(pages PAGE_SIZE);
66		67
67	if (*addr == NULL) {	68	if (*addr == NULL) {
68	ipc_answer_0(callid, ENOENT);	69	ipc_answer_0(callid, ENOENT);
69	return;	70	return;
70	}	71	}
71		72
72	if (physmem_map(ph_addr, *addr, pages,	73	if (physmem_map(ph_addr, *addr, pages,
73	AS_AREA_READ \| AS_AREA_CACHEABLE) != 0) {	74	AS_AREA_READ \| AS_AREA_CACHEABLE) != 0) {
74	ipc_answer_0(callid, ENOENT);	75	ipc_answer_0(callid, ENOENT);
75	return;	76	return;
76	}	77	}
77	}	78	}
78		79
79	ipc_answer_2(callid, EOK, (ipcarg_t) *addr, AS_AREA_READ);	80	ipc_answer_2(callid, EOK, (ipcarg_t) *addr, AS_AREA_READ);
80	}	81	}
81		82
82	int main(int argc, char **argv)	83	int main(int argc, char **argv)
83	{	84	{
84	printf(NAME ": HelenOS IPC Naming Service\n");	85	printf(NAME ": HelenOS IPC Naming Service\n");
85		86
86	int rc = service_init();	87	int rc = service_init();
87	if (rc != EOK)	88	if (rc != EOK)
88	return rc;	89	return rc;
89		90
90	rc = clonable_init();	91	rc = clonable_init();
91	if (rc != EOK)	92	if (rc != EOK)
92	return rc;	93	return rc;
93		94
94	rc = task_init();	95	rc = task_init();
95	if (rc != EOK)	96	if (rc != EOK)
96	return rc;	97	return rc;
97		98
98	printf(NAME ": Accepting connections\n");	99	printf(NAME ": Accepting connections\n");
99		100
100	while (true) {	101	while (true) {
101	process_pending_conn();	102	process_pending_conn();
102	process_pending_wait();	103	process_pending_wait();
103		104
104	ipc_call_t call;	105	ipc_call_t call;
105	ipc_callid_t callid = ipc_wait_for_call(&call);	106	ipc_callid_t callid = ipc_wait_for_call(&call);
106		107
107	task_id_t id;	108	task_id_t id;
108	ipcarg_t retval;	109	ipcarg_t retval;
109		110
110	if (callid & IPC_CALLID_NOTIFICATION) {	111	if (callid & IPC_CALLID_NOTIFICATION) {
111	id = (task_id_t)	112	id = (task_id_t)
112	MERGE_LOUP32(IPC_GET_ARG2(call), IPC_GET_ARG3(call));	113	MERGE_LOUP32(IPC_GET_ARG2(call), IPC_GET_ARG3(call));
113	wait_notification((wait_type_t) IPC_GET_ARG1(call), id);	114	wait_notification((wait_type_t) IPC_GET_ARG1(call), id);
114	continue;	115	continue;
115	}	116	}
116		117
117	switch (IPC_GET_METHOD(call)) {	118	switch (IPC_GET_METHOD(call)) {
118	case IPC_M_SHARE_IN:	119	case IPC_M_SHARE_IN:
119	switch (IPC_GET_ARG3(call)) {	120	switch (IPC_GET_ARG3(call)) {
120	case SERVICE_MEM_REALTIME:	121	case SERVICE_MEM_REALTIME:
121	get_as_area(callid, &call,	122	get_as_area(callid, &call,
122	(void *) sysinfo_value("clock.faddr"),	123	(void *) sysinfo_value("clock.faddr"),
123	1, &clockaddr);	124	1, &clockaddr);
124	break;	125	break;
125	case SERVICE_MEM_KLOG:	126	case SERVICE_MEM_KLOG:
126	get_as_area(callid, &call,	127	get_as_area(callid, &call,
127	(void *) sysinfo_value("klog.faddr"),	128	(void *) sysinfo_value("klog.faddr"),
128	sysinfo_value("klog.pages"), &klogaddr);	129	sysinfo_value("klog.pages"), &klogaddr);
129	break;	130	break;
130	default:	131	default:
131	ipc_answer_0(callid, ENOENT);	132	ipc_answer_0(callid, ENOENT);
132	}	133	}
133	continue;	134	continue;
134	case IPC_M_PHONE_HUNGUP:	135	case IPC_M_PHONE_HUNGUP:
135	retval = EOK;	136	retval = EOK;
136	break;	137	break;
137	case IPC_M_CONNECT_TO_ME:	138	case IPC_M_CONNECT_TO_ME:
138	/*	139	/*
139	* Server requests service registration.	140	* Server requests service registration.
140	*/	141	*/
141	if (service_clonable(IPC_GET_ARG1(call))) {	142	if (service_clonable(IPC_GET_ARG1(call))) {
142	register_clonable(IPC_GET_ARG1(call),	143	register_clonable(IPC_GET_ARG1(call),
143	IPC_GET_ARG5(call), &call, callid);	144	IPC_GET_ARG5(call), &call, callid);
144	continue;	145	continue;
145	} else {	146	} else {
146	retval = register_service(IPC_GET_ARG1(call),	147	retval = register_service(IPC_GET_ARG1(call),
147	IPC_GET_ARG5(call), &call);	148	IPC_GET_ARG5(call), &call);
148	}	149	}
149	break;	150	break;
150	case IPC_M_CONNECT_ME_TO:	151	case IPC_M_CONNECT_ME_TO:
151	/*	152	/*
152	* Client requests to be connected to a service.	153	* Client requests to be connected to a service.
153	*/	154	*/
154	if (service_clonable(IPC_GET_ARG1(call))) {	155	if (service_clonable(IPC_GET_ARG1(call))) {
155	connect_to_clonable(IPC_GET_ARG1(call),	156	connect_to_clonable(IPC_GET_ARG1(call),
156	&call, callid);	157	&call, callid);
157	continue;	158	continue;
158	} else {	159	} else {
159	connect_to_service(IPC_GET_ARG1(call), &call,	160	connect_to_service(IPC_GET_ARG1(call), &call,
160	callid);	161	callid);
161	continue;	162	continue;
162	}	163	}
163	break;	164	break;
164	case NS_PING:	165	case NS_PING:
165	retval = EOK;	166	retval = EOK;
166	break;	167	break;
167	case NS_TASK_WAIT:	168	case NS_TASK_WAIT:
168	id = (task_id_t)	169	id = (task_id_t)
169	MERGE_LOUP32(IPC_GET_ARG1(call), IPC_GET_ARG2(call));	170	MERGE_LOUP32(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
170	wait_for_task(id, &call, callid);	171	wait_for_task(id, &call, callid);
171	continue;	172	continue;
172	default:	173	default:
173	retval = ENOENT;	174	retval = ENOENT;
174	break;	175	break;
175	}	176	}
176		177
177	if (!(callid & IPC_CALLID_NOTIFICATION))	178	if (!(callid & IPC_CALLID_NOTIFICATION))
178	ipc_answer_0(callid, retval);	179	ipc_answer_0(callid, retval);
179	}	180	}
180		181
181	/* Not reached */	182	/* Not reached */
182	return 0;	183	return 0;
183	}	184	}
184		185
185	/**	186	/**
186	* @}	187	* @}
187	*/	188	*/
188		189

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/ns/ns.c – Rev 4459 → 4496