Subversion Repositories HelenOS

Rev

Rev 2479 | Rev 2594 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2479 Rev 2588
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
 
38
 
39
#include <ipc/ipc.h>
39
#include <ipc/ipc.h>
40
#include <ipc/ns.h>
40
#include <ipc/ns.h>
41
#include <ipc/services.h>
41
#include <ipc/services.h>
42
#include <stdio.h>
42
#include <stdio.h>
43
#include <unistd.h>
43
#include <unistd.h>
44
#include <stdlib.h>
44
#include <stdlib.h>
45
#include <errno.h>
45
#include <errno.h>
46
#include <assert.h>
46
#include <assert.h>
47
#include <libadt/list.h>
47
#include <libadt/list.h>
48
#include <libadt/hash_table.h>
48
#include <libadt/hash_table.h>
49
#include <sysinfo.h>
49
#include <sysinfo.h>
50
#include <ddi.h>
50
#include <ddi.h>
51
#include <as.h>
51
#include <as.h>
52
 
52
 
53
#define NAME    "NS"
53
#define NAME    "NS"
54
 
54
 
55
#define NS_HASH_TABLE_CHAINS    20
55
#define NS_HASH_TABLE_CHAINS    20
56
 
56
 
57
static int register_service(ipcarg_t service, ipcarg_t phone, ipc_call_t *call);
57
static int register_service(ipcarg_t service, ipcarg_t phone, ipc_call_t *call);
58
static int connect_to_service(ipcarg_t service, ipc_call_t *call,
58
static int connect_to_service(ipcarg_t service, ipc_call_t *call,
59
    ipc_callid_t callid);
59
    ipc_callid_t callid);
60
 
60
 
61
/* Static functions implementing NS hash table operations. */
61
/* Static functions implementing NS hash table operations. */
62
static hash_index_t ns_hash(unsigned long *key);
62
static hash_index_t ns_hash(unsigned long *key);
63
static int ns_compare(unsigned long *key, hash_count_t keys, link_t *item);
63
static int ns_compare(unsigned long *key, hash_count_t keys, link_t *item);
64
static void ns_remove(link_t *item);
64
static void ns_remove(link_t *item);
65
 
65
 
66
/** Operations for NS hash table. */
66
/** Operations for NS hash table. */
67
static hash_table_operations_t ns_hash_table_ops = {
67
static hash_table_operations_t ns_hash_table_ops = {
68
    .hash = ns_hash,
68
    .hash = ns_hash,
69
    .compare = ns_compare,
69
    .compare = ns_compare,
70
    .remove_callback = ns_remove
70
    .remove_callback = ns_remove
71
};
71
};
72
 
72
 
73
/** NS hash table structure. */
73
/** NS hash table structure. */
74
static hash_table_t ns_hash_table;
74
static hash_table_t ns_hash_table;
75
 
75
 
76
/** NS hash table item. */
76
/** NS hash table item. */
77
typedef struct {
77
typedef struct {
78
    link_t link;
78
    link_t link;
79
    ipcarg_t service;       /**< Number of the service. */
79
    ipcarg_t service;       /**< Number of the service. */
80
    ipcarg_t phone;         /**< Phone registered with the service. */
80
    ipcarg_t phone;         /**< Phone registered with the service. */
81
    ipcarg_t in_phone_hash;     /**< Incoming phone hash. */
81
    ipcarg_t in_phone_hash;     /**< Incoming phone hash. */
82
} hashed_service_t;
82
} hashed_service_t;
83
 
83
 
84
static void *clockaddr = NULL;
84
static void *clockaddr = NULL;
85
static void *klogaddr = NULL;
85
static void *klogaddr = NULL;
86
 
86
 
87
static void get_as_area(ipc_callid_t callid, ipc_call_t *call, char *name,
87
static void get_as_area(ipc_callid_t callid, ipc_call_t *call, char *name,
88
    void **addr)
88
    void **addr)
89
{
89
{
90
    void *ph_addr;
90
    void *ph_addr;
91
 
91
 
92
    if (!*addr) {
92
    if (!*addr) {
93
        ph_addr = (void *) sysinfo_value(name);
93
        ph_addr = (void *) sysinfo_value(name);
94
        if (!ph_addr) {
94
        if (!ph_addr) {
95
            ipc_answer_fast(callid, ENOENT, 0, 0);
95
            ipc_answer_fast_0(callid, ENOENT);
96
            return;
96
            return;
97
        }
97
        }
98
        *addr = as_get_mappable_page(PAGE_SIZE);
98
        *addr = as_get_mappable_page(PAGE_SIZE);
-
 
99
        physmem_map(ph_addr, *addr, 1,
99
        physmem_map(ph_addr, *addr, 1, AS_AREA_READ | AS_AREA_CACHEABLE);
100
            AS_AREA_READ | AS_AREA_CACHEABLE);
100
    }
101
    }
101
    ipc_answer_fast(callid, 0, (ipcarg_t) *addr, AS_AREA_READ);
102
    ipc_answer_fast(callid, EOK, (ipcarg_t) *addr, AS_AREA_READ);
102
}
103
}
103
 
104
 
104
int main(int argc, char **argv)
105
int main(int argc, char **argv)
105
{
106
{
106
    ipc_call_t call;
107
    ipc_call_t call;
107
    ipc_callid_t callid;
108
    ipc_callid_t callid;
108
   
109
   
109
    ipcarg_t retval;
110
    ipcarg_t retval;
110
 
111
 
111
    if (!hash_table_create(&ns_hash_table, NS_HASH_TABLE_CHAINS, 3,
112
    if (!hash_table_create(&ns_hash_table, NS_HASH_TABLE_CHAINS, 3,
112
        &ns_hash_table_ops)) {
113
        &ns_hash_table_ops)) {
113
        return ENOMEM;
114
        return ENOMEM;
114
    }
115
    }
115
       
116
       
116
    while (1) {
117
    while (1) {
117
        callid = ipc_wait_for_call(&call);
118
        callid = ipc_wait_for_call(&call);
118
        switch (IPC_GET_METHOD(call)) {
119
        switch (IPC_GET_METHOD(call)) {
119
        case IPC_M_AS_AREA_RECV:
120
        case IPC_M_AS_AREA_RECV:
120
            switch (IPC_GET_ARG3(call)) {
121
            switch (IPC_GET_ARG3(call)) {
121
            case SERVICE_MEM_REALTIME:
122
            case SERVICE_MEM_REALTIME:
122
                get_as_area(callid, &call, "clock.faddr",
123
                get_as_area(callid, &call, "clock.faddr",
123
                    &clockaddr);
124
                    &clockaddr);
124
                break;
125
                break;
125
            case SERVICE_MEM_KLOG:
126
            case SERVICE_MEM_KLOG:
126
                get_as_area(callid, &call, "klog.faddr",
127
                get_as_area(callid, &call, "klog.faddr",
127
                    &klogaddr);
128
                    &klogaddr);
128
                break;
129
                break;
129
            default:
130
            default:
130
                ipc_answer_fast(callid, ENOENT, 0, 0);
131
                ipc_answer_fast_0(callid, ENOENT);
131
            }
132
            }
132
            continue;
133
            continue;
133
        case IPC_M_PHONE_HUNGUP:
134
        case IPC_M_PHONE_HUNGUP:
134
            retval = 0;
135
            retval = EOK;
135
            break;
136
            break;
136
        case IPC_M_CONNECT_TO_ME:
137
        case IPC_M_CONNECT_TO_ME:
137
            /*
138
            /*
138
             * Server requests service registration.
139
             * Server requests service registration.
139
             */
140
             */
140
            retval = register_service(IPC_GET_ARG1(call),
141
            retval = register_service(IPC_GET_ARG1(call),
141
                IPC_GET_ARG3(call), &call);
142
                IPC_GET_ARG3(call), &call);
142
            break;
143
            break;
143
        case IPC_M_CONNECT_ME_TO:
144
        case IPC_M_CONNECT_ME_TO:
144
            /*
145
            /*
145
             * Client requests to be connected to a service.
146
             * Client requests to be connected to a service.
146
             */
147
             */
147
            retval = connect_to_service(IPC_GET_ARG1(call), &call,
148
            retval = connect_to_service(IPC_GET_ARG1(call), &call,
148
                callid);
149
                callid);
149
            break;
150
            break;
150
        default:
151
        default:
151
            retval = ENOENT;
152
            retval = ENOENT;
152
            break;
153
            break;
153
        }
154
        }
154
        if (!(callid & IPC_CALLID_NOTIFICATION)) {
155
        if (!(callid & IPC_CALLID_NOTIFICATION)) {
155
            ipc_answer_fast(callid, retval, 0, 0);
156
            ipc_answer_fast_0(callid, retval);
156
        }
157
        }
157
    }
158
    }
158
}
159
}
159
 
160
 
160
/** Register service.
161
/** Register service.
161
 *
162
 *
162
 * @param service Service to be registered.
163
 * @param service Service to be registered.
163
 * @param phone Phone to be used for connections to the service.
164
 * @param phone Phone to be used for connections to the service.
164
 * @param call Pointer to call structure.
165
 * @param call Pointer to call structure.
165
 *
166
 *
166
 * @return Zero on success or a value from @ref errno.h.
167
 * @return Zero on success or a value from @ref errno.h.
167
 */
168
 */
168
int register_service(ipcarg_t service, ipcarg_t phone, ipc_call_t *call)
169
int register_service(ipcarg_t service, ipcarg_t phone, ipc_call_t *call)
169
{
170
{
170
    unsigned long keys[3] = {
171
    unsigned long keys[3] = {
171
        service,
172
        service,
172
        call->in_phone_hash,
173
        call->in_phone_hash,
173
        0
174
        0
174
    };
175
    };
175
    hashed_service_t *hs;
176
    hashed_service_t *hs;
176
           
177
           
177
    if (hash_table_find(&ns_hash_table, keys)) {
178
    if (hash_table_find(&ns_hash_table, keys)) {
178
        return EEXISTS;
179
        return EEXISTS;
179
    }
180
    }
180
           
181
           
181
    hs = (hashed_service_t *) malloc(sizeof(hashed_service_t));
182
    hs = (hashed_service_t *) malloc(sizeof(hashed_service_t));
182
    if (!hs) {
183
    if (!hs) {
183
        return ENOMEM;
184
        return ENOMEM;
184
    }
185
    }
185
           
186
           
186
    link_initialize(&hs->link);
187
    link_initialize(&hs->link);
187
    hs->service = service;
188
    hs->service = service;
188
    hs->phone = phone;
189
    hs->phone = phone;
189
    hs->in_phone_hash = call->in_phone_hash;
190
    hs->in_phone_hash = call->in_phone_hash;
190
    hash_table_insert(&ns_hash_table, keys, &hs->link);
191
    hash_table_insert(&ns_hash_table, keys, &hs->link);
191
           
192
           
192
    return 0;
193
    return 0;
193
}
194
}
194
 
195
 
195
/** Connect client to service.
196
/** Connect client to service.
196
 *
197
 *
197
 * @param service Service to be connected to.
198
 * @param service Service to be connected to.
198
 * @param call Pointer to call structure.
199
 * @param call Pointer to call structure.
199
 * @param callid Call ID of the request.
200
 * @param callid Call ID of the request.
200
 *
201
 *
201
 * @return Zero on success or a value from @ref errno.h.
202
 * @return Zero on success or a value from @ref errno.h.
202
 */
203
 */
203
int connect_to_service(ipcarg_t service, ipc_call_t *call, ipc_callid_t callid)
204
int connect_to_service(ipcarg_t service, ipc_call_t *call, ipc_callid_t callid)
204
{
205
{
205
    unsigned long keys[3] = { service, 0, 0 };
206
    unsigned long keys[3] = { service, 0, 0 };
206
    link_t *hlp;
207
    link_t *hlp;
207
    hashed_service_t *hs;
208
    hashed_service_t *hs;
208
           
209
           
209
    hlp = hash_table_find(&ns_hash_table, keys);
210
    hlp = hash_table_find(&ns_hash_table, keys);
210
    if (!hlp) {
211
    if (!hlp) {
211
        return ENOENT;
212
        return ENOENT;
212
    }
213
    }
213
    hs = hash_table_get_instance(hlp, hashed_service_t, link);
214
    hs = hash_table_get_instance(hlp, hashed_service_t, link);
214
    return ipc_forward_fast(callid, hs->phone, 0, 0);
215
    return ipc_forward_fast(callid, hs->phone, 0, 0);
215
}
216
}
216
 
217
 
217
/** Compute hash index into NS hash table.
218
/** Compute hash index into NS hash table.
218
 *
219
 *
219
 * @param key Pointer keys. However, only the first key (i.e. service number)
220
 * @param key Pointer keys. However, only the first key (i.e. service number)
220
 *        is used to compute the hash index.
221
 *        is used to compute the hash index.
221
 * @return Hash index corresponding to key[0].
222
 * @return Hash index corresponding to key[0].
222
 */
223
 */
223
hash_index_t ns_hash(unsigned long *key)
224
hash_index_t ns_hash(unsigned long *key)
224
{
225
{
225
    assert(key);
226
    assert(key);
226
    return *key % NS_HASH_TABLE_CHAINS;
227
    return *key % NS_HASH_TABLE_CHAINS;
227
}
228
}
228
 
229
 
229
/** Compare a key with hashed item.
230
/** Compare a key with hashed item.
230
 *
231
 *
231
 * This compare function always ignores the third key.
232
 * This compare function always ignores the third key.
232
 * It exists only to make it possible to remove records
233
 * It exists only to make it possible to remove records
233
 * originating from connection with key[1] in_phone_hash
234
 * originating from connection with key[1] in_phone_hash
234
 * value. Note that this is close to being classified
235
 * value. Note that this is close to being classified
235
 * as a nasty hack.
236
 * as a nasty hack.
236
 *
237
 *
237
 * @param key Array of keys.
238
 * @param key Array of keys.
238
 * @param keys Must be lesser or equal to 3.
239
 * @param keys Must be lesser or equal to 3.
239
 * @param item Pointer to a hash table item.
240
 * @param item Pointer to a hash table item.
240
 * @return Non-zero if the key matches the item, zero otherwise.
241
 * @return Non-zero if the key matches the item, zero otherwise.
241
 */
242
 */
242
int ns_compare(unsigned long key[], hash_count_t keys, link_t *item)
243
int ns_compare(unsigned long key[], hash_count_t keys, link_t *item)
243
{
244
{
244
    hashed_service_t *hs;
245
    hashed_service_t *hs;
245
 
246
 
246
    assert(key);
247
    assert(key);
247
    assert(keys <= 3);
248
    assert(keys <= 3);
248
    assert(item);
249
    assert(item);
249
   
250
   
250
    hs = hash_table_get_instance(item, hashed_service_t, link);
251
    hs = hash_table_get_instance(item, hashed_service_t, link);
251
   
252
   
252
    if (keys == 2)
253
    if (keys == 2)
253
        return key[1] == hs->in_phone_hash;
254
        return key[1] == hs->in_phone_hash;
254
    else
255
    else
255
        return key[0] == hs->service;
256
        return key[0] == hs->service;
256
}
257
}
257
 
258
 
258
/** Perform actions after removal of item from the hash table.
259
/** Perform actions after removal of item from the hash table.
259
 *
260
 *
260
 * @param item Item that was removed from the hash table.
261
 * @param item Item that was removed from the hash table.
261
 */
262
 */
262
void ns_remove(link_t *item)
263
void ns_remove(link_t *item)
263
{
264
{
264
    assert(item);
265
    assert(item);
265
    free(hash_table_get_instance(item, hashed_service_t, link));
266
    free(hash_table_get_instance(item, hashed_service_t, link));
266
}
267
}
267
 
268
 
268
/**
269
/**
269
 * @}
270
 * @}
270
 */
271
 */
271
 
272