← Back to branch summary

~martin-decky/helenos/rcu

« back to all changes in this revision

Viewing changes to uspace/app/trace/proto.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/app/trace/proto.c
 
1
/*
 
2
 * Copyright (c) 2008 Jiri Svoboda
 
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 trace
 
30
 * @{
 
31
 */
 
32
/** @file
 
33
 */
 
34
 
 
35
#include <stdio.h>
 
36
#include <stdlib.h>
 
37
#include <ipc/ipc.h>
 
38
#include <adt/hash_table.h>
 
39
 
 
40
#include "trace.h"
 
41
#include "proto.h"
 
42
 
 
43
#define SRV_PROTO_TABLE_CHAINS 32
 
44
#define METHOD_OPER_TABLE_CHAINS 32
 
45
 
 
46
hash_table_t srv_proto;
 
47
 
 
48
typedef struct {
 
49
        unsigned srv;
 
50
        proto_t *proto;
 
51
        link_t link;
 
52
} srv_proto_t;
 
53
 
 
54
typedef struct {
 
55
        ipcarg_t method;
 
56
        oper_t *oper;
 
57
        link_t link;
 
58
} method_oper_t;
 
59
 
 
60
static hash_index_t srv_proto_hash(unsigned long key[]);
 
61
static int srv_proto_compare(unsigned long key[], hash_count_t keys,
 
62
    link_t *item);
 
63
static void srv_proto_remove_callback(link_t *item);
 
64
 
 
65
hash_table_operations_t srv_proto_ops = {
 
66
        .hash = srv_proto_hash,
 
67
        .compare = srv_proto_compare,
 
68
        .remove_callback = srv_proto_remove_callback
 
69
};
 
70
 
 
71
static hash_index_t method_oper_hash(unsigned long key[]);
 
72
static int method_oper_compare(unsigned long key[], hash_count_t keys,
 
73
    link_t *item);
 
74
static void method_oper_remove_callback(link_t *item);
 
75
 
 
76
hash_table_operations_t method_oper_ops = {
 
77
        .hash = method_oper_hash,
 
78
        .compare = method_oper_compare,
 
79
        .remove_callback = method_oper_remove_callback
 
80
};
 
81
 
 
82
static hash_index_t srv_proto_hash(unsigned long key[])
 
83
{
 
84
        return key[0] % SRV_PROTO_TABLE_CHAINS;
 
85
}
 
86
 
 
87
static int srv_proto_compare(unsigned long key[], hash_count_t keys,
 
88
    link_t *item)
 
89
{
 
90
        srv_proto_t *sp;
 
91
 
 
92
        sp = hash_table_get_instance(item, srv_proto_t, link);
 
93
 
 
94
        return key[0] == sp->srv;
 
95
}
 
96
 
 
97
static void srv_proto_remove_callback(link_t *item)
 
98
{
 
99
}
 
100
 
 
101
static hash_index_t method_oper_hash(unsigned long key[])
 
102
{
 
103
        return key[0] % METHOD_OPER_TABLE_CHAINS;
 
104
}
 
105
 
 
106
static int method_oper_compare(unsigned long key[], hash_count_t keys,
 
107
    link_t *item)
 
108
{
 
109
        method_oper_t *mo;
 
110
 
 
111
        mo = hash_table_get_instance(item, method_oper_t, link);
 
112
 
 
113
        return key[0] == mo->method;
 
114
}
 
115
 
 
116
static void method_oper_remove_callback(link_t *item)
 
117
{
 
118
}
 
119
 
 
120
 
 
121
void proto_init(void)
 
122
{
 
123
        hash_table_create(&srv_proto, SRV_PROTO_TABLE_CHAINS, 1,
 
124
            &srv_proto_ops);
 
125
}
 
126
 
 
127
void proto_cleanup(void)
 
128
{
 
129
        hash_table_destroy(&srv_proto);
 
130
}
 
131
 
 
132
void proto_register(int srv, proto_t *proto)
 
133
{
 
134
        srv_proto_t *sp;
 
135
        unsigned long key;
 
136
 
 
137
        sp = malloc(sizeof(srv_proto_t));
 
138
        sp->srv = srv;
 
139
        sp->proto = proto;
 
140
        key = srv;
 
141
 
 
142
        hash_table_insert(&srv_proto, &key, &sp->link);
 
143
}
 
144
 
 
145
proto_t *proto_get_by_srv(int srv)
 
146
{
 
147
        unsigned long key;
 
148
        link_t *item;
 
149
        srv_proto_t *sp;
 
150
 
 
151
        key = srv;
 
152
        item = hash_table_find(&srv_proto, &key);
 
153
        if (item == NULL) return NULL;
 
154
 
 
155
        sp = hash_table_get_instance(item, srv_proto_t, link);
 
156
        return sp->proto;
 
157
}
 
158
 
 
159
static void proto_struct_init(proto_t *proto, char *name)
 
160
{
 
161
        proto->name = name;
 
162
        hash_table_create(&proto->method_oper, SRV_PROTO_TABLE_CHAINS, 1,
 
163
            &method_oper_ops);
 
164
}
 
165
 
 
166
proto_t *proto_new(char *name)
 
167
{
 
168
        proto_t *p;
 
169
 
 
170
        p = malloc(sizeof(proto_t));
 
171
        proto_struct_init(p, name);
 
172
 
 
173
        return p;
 
174
}
 
175
 
 
176
void proto_delete(proto_t *proto)
 
177
{
 
178
        free(proto);
 
179
}
 
180
 
 
181
void proto_add_oper(proto_t *proto, int method, oper_t *oper)
 
182
{
 
183
        method_oper_t *mo;
 
184
        unsigned long key;
 
185
 
 
186
        mo = malloc(sizeof(method_oper_t));
 
187
        mo->method = method;
 
188
        mo->oper = oper;
 
189
        key = method;
 
190
 
 
191
        hash_table_insert(&proto->method_oper, &key, &mo->link);        
 
192
}
 
193
 
 
194
oper_t *proto_get_oper(proto_t *proto, int method)
 
195
{
 
196
        unsigned long key;
 
197
        link_t *item;
 
198
        method_oper_t *mo;
 
199
 
 
200
        key = method;
 
201
        item = hash_table_find(&proto->method_oper, &key);
 
202
        if (item == NULL) return NULL;
 
203
 
 
204
        mo = hash_table_get_instance(item, method_oper_t, link);
 
205
        return mo->oper;
 
206
}
 
207
 
 
208
static void oper_struct_init(oper_t *oper, char *name)
 
209
{
 
210
        oper->name = name;
 
211
}
 
212
 
 
213
oper_t *oper_new(char *name, int argc, val_type_t *arg_types,
 
214
    val_type_t rv_type, int respc, val_type_t *resp_types)
 
215
{
 
216
        oper_t *o;
 
217
        int i;
 
218
 
 
219
        o = malloc(sizeof(oper_t));
 
220
        oper_struct_init(o, name);
 
221
 
 
222
        o->argc = argc;
 
223
        for (i = 0; i < argc; i++)
 
224
                o->arg_type[i] = arg_types[i];
 
225
 
 
226
        o->rv_type = rv_type;
 
227
 
 
228
        o->respc = respc;
 
229
        for (i = 0; i < respc; i++)
 
230
                o->resp_type[i] = resp_types[i];
 
231
 
 
232
        return o;
 
233
}
 
234
 
 
235
/** @}
 
236
 */