← Back to branch summary

~galfy/helenos/bird-port-mainline

« back to all changes in this revision

Viewing changes to uspace/srv/ns/ns.c

  • Committer: Martin Decky
  • Date: 2009-08-04 11:19:19 UTC
  • Revision ID: martin@uranus.dsrg.hide.ms.mff.cuni.cz-20090804111919-evyclddlr3v5lhmp
Initial import

Show diffs side-by-side

added added

removed removed

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