WebSVN – HelenOS – Diff – /branches/tracing/uspace/app/trace/proto.c


/*
 * Copyright (c) 2008 Jiri Svoboda
 * 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 trace
 * @{
 */
/** @file
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <ipc/ipc.h>
#include <libadt/hash_table.h>
 
#include "trace.h"
#include "proto.h"
 
#define SRV_PROTO_TABLE_CHAINS 32
#define METHOD_OPER_TABLE_CHAINS 32
 
hash_table_t srv_proto;
 
typedef struct {
    int srv;
    proto_t *proto;
    link_t link;
} srv_proto_t;
 
typedef struct {
    ipcarg_t method;
    oper_t *oper;
    link_t link;
} method_oper_t;
 
static hash_index_t srv_proto_hash(unsigned long key[]);
static int srv_proto_compare(unsigned long key[], hash_count_t keys,
    link_t *item);
static void srv_proto_remove_callback(link_t *item);
 
hash_table_operations_t srv_proto_ops = {
    .hash = srv_proto_hash,
    .compare = srv_proto_compare,
    .remove_callback = srv_proto_remove_callback
};
 
static hash_index_t method_oper_hash(unsigned long key[]);
static int method_oper_compare(unsigned long key[], hash_count_t keys,
    link_t *item);
static void method_oper_remove_callback(link_t *item);
 
hash_table_operations_t method_oper_ops = {
    .hash = method_oper_hash,
    .compare = method_oper_compare,
    .remove_callback = method_oper_remove_callback
};
 
static hash_index_t srv_proto_hash(unsigned long key[])
{
    return key[0] % SRV_PROTO_TABLE_CHAINS;
}
 
static int srv_proto_compare(unsigned long key[], hash_count_t keys,
    link_t *item)
{
    srv_proto_t *sp;
 
    sp = hash_table_get_instance(item, srv_proto_t, link);
 
    return key[0] == sp->srv;
}
 
static void srv_proto_remove_callback(link_t *item)
{
}
 
static hash_index_t method_oper_hash(unsigned long key[])
{
    return key[0] % METHOD_OPER_TABLE_CHAINS;
}
 
static int method_oper_compare(unsigned long key[], hash_count_t keys,
    link_t *item)
{
    method_oper_t *mo;
 
    mo = hash_table_get_instance(item, method_oper_t, link);
 
    return key[0] == mo->method;
}
 
static void method_oper_remove_callback(link_t *item)
{
}
 
 
void proto_init(void)
{
    hash_table_create(&srv_proto, SRV_PROTO_TABLE_CHAINS, 1,
        &srv_proto_ops);
}
 
void proto_cleanup(void)
{
    hash_table_destroy(&srv_proto);
}
 
void proto_register(int srv, proto_t *proto)
{
    srv_proto_t *sp;
    unsigned long key;
 
    sp = malloc(sizeof(srv_proto_t));
    sp->srv = srv;
    sp->proto = proto;
    key = srv;
 
    hash_table_insert(&srv_proto, &key, &sp->link);
}
 
proto_t *proto_get_by_srv(int srv)
{
    unsigned long key;
    link_t *item;
    srv_proto_t *sp;
 
    key = srv;
    item = hash_table_find(&srv_proto, &key);
    if (item == NULL) return NULL;
 
    sp = hash_table_get_instance(item, srv_proto_t, link);
    return sp->proto;
}
 
static void proto_struct_init(proto_t *proto, char *name)
{
    proto->name = name;
    hash_table_create(&proto->method_oper, SRV_PROTO_TABLE_CHAINS, 1,
        &method_oper_ops);
}
 
proto_t *proto_new(char *name)
{
    proto_t *p;
 
    p = malloc(sizeof(proto_t));
    proto_struct_init(p, name);
 
    return p;
}
 
void proto_delete(proto_t *proto)
{
    free(proto);
}
 
void proto_add_oper(proto_t *proto, int method, oper_t *oper)
{
    method_oper_t *mo;
    unsigned long key;
 
    mo = malloc(sizeof(method_oper_t));
    mo->method = method;
    mo->oper = oper;
    key = method;
 
    hash_table_insert(&proto->method_oper, &key, &mo->link);   
}
 
oper_t *proto_get_oper(proto_t *proto, int method)
{
    unsigned long key;
    link_t *item;
    method_oper_t *mo;
 
    key = method;
    item = hash_table_find(&proto->method_oper, &key);
    if (item == NULL) return NULL;
 
    mo = hash_table_get_instance(item, method_oper_t, link);
    return mo->oper;
}
 
static void oper_struct_init(oper_t *oper, char *name)
{
    oper->name = name;
}
 
oper_t *oper_new(char *name, int argc, val_type_t *arg_types,
    val_type_t rv_type, int respc, val_type_t *resp_types)
{
    oper_t *o;
    int i;
 
    o = malloc(sizeof(oper_t));
    oper_struct_init(o, name);
 
    o->argc = argc;
    for (i = 0; i < argc; i++)
        o->arg_type[i] = arg_types[i];
 
    o->rv_type = rv_type;
 
    o->respc = respc;
    for (i = 0; i < respc; i++)
        o->resp_type[i] = resp_types[i];
 
    return o;
}
 
/** @}
 */
 

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

Subversion Repositories HelenOS

(root)/branches/tracing/uspace/app/trace/proto.c – Rev 3435 → 3471