source: mainline/uspace/app/trace/ipcp.c@ 503ffce

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 503ffce was 503ffce, checked in by Jakub Jermar <jakub@…>, 8 years ago

Return IPC_CALLID_* in call data instead of callid

Callid will be replaced by capability handles soon so the API needs
to be cleanup up and any flags passed together with callid must be
passed using some other way.
  • Property mode set to 100644
File size: 8.5 KB
Line 
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 <inttypes.h>
38#include <adt/hash_table.h>
39#include <abi/ipc/methods.h>
40#include <macros.h>
41#include "ipc_desc.h"
42#include "proto.h"
43#include "trace.h"
44#include "ipcp.h"
45
46#define IPCP_CALLID_SYNC 0
47
48typedef struct {
49 sysarg_t phone_hash;
50 ipc_call_t question;
51 oper_t *oper;
52
53 ipc_callid_t call_hash;
54
55 ht_link_t link;
56} pending_call_t;
57
58typedef struct {
59 int server;
60 proto_t *proto;
61} connection_t;
62
63#define MAX_PHONE 64
64connection_t connections[MAX_PHONE];
65int have_conn[MAX_PHONE];
66
67static hash_table_t pending_calls;
68
69/*
70 * Pseudo-protocols
71 */
72proto_t *proto_system; /**< Protocol describing system IPC methods. */
73proto_t *proto_unknown; /**< Protocol with no known methods. */
74
75
76static size_t pending_call_key_hash(void *key)
77{
78 ipc_callid_t *call_id = (ipc_callid_t *)key;
79 return *call_id;
80}
81
82static size_t pending_call_hash(const ht_link_t *item)
83{
84 pending_call_t *hs = hash_table_get_inst(item, pending_call_t, link);
85 return hs->call_hash;
86}
87
88static bool pending_call_key_equal(void *key, const ht_link_t *item)
89{
90 ipc_callid_t *call_id = (ipc_callid_t *)key;
91 pending_call_t *hs = hash_table_get_inst(item, pending_call_t, link);
92
93 return *call_id == hs->call_hash;
94}
95
96static hash_table_ops_t pending_call_ops = {
97 .hash = pending_call_hash,
98 .key_hash = pending_call_key_hash,
99 .key_equal = pending_call_key_equal,
100 .equal = NULL,
101 .remove_callback = NULL
102};
103
104
105void ipcp_connection_set(int phone, int server, proto_t *proto)
106{
107 if (phone <0 || phone >= MAX_PHONE) return;
108 connections[phone].server = server;
109 connections[phone].proto = proto;
110 have_conn[phone] = 1;
111}
112
113void ipcp_connection_clear(int phone)
114{
115 have_conn[phone] = 0;
116 connections[phone].server = 0;
117 connections[phone].proto = NULL;
118}
119
120static void ipc_m_print(proto_t *proto, sysarg_t method)
121{
122 oper_t *oper;
123
124 /* Try system methods first */
125 oper = proto_get_oper(proto_system, method);
126
127 if (oper == NULL && proto != NULL) {
128 /* Not a system method, try the user protocol. */
129 oper = proto_get_oper(proto, method);
130 }
131
132 if (oper != NULL) {
133 printf("%s (%" PRIun ")", oper->name, method);
134 return;
135 }
136
137 printf("%" PRIun, method);
138}
139
140void ipcp_init(void)
141{
142 val_type_t arg_def[OPER_MAX_ARGS] = {
143 V_INTEGER,
144 V_INTEGER,
145 V_INTEGER,
146 V_INTEGER,
147 V_INTEGER
148 };
149
150 /*
151 * Create a pseudo-protocol 'unknown' that has no known methods.
152 */
153 proto_unknown = proto_new("unknown");
154
155 /*
156 * Create a pseudo-protocol 'system' defining names of system IPC
157 * methods.
158 */
159 proto_system = proto_new("system");
160
161 for (size_t i = 0; i < ipc_methods_len; i++) {
162 oper_t *oper = oper_new(ipc_methods[i].name, OPER_MAX_ARGS,
163 arg_def, V_INTEGER, OPER_MAX_ARGS, arg_def);
164 proto_add_oper(proto_system, ipc_methods[i].number, oper);
165 }
166
167 bool ok = hash_table_create(&pending_calls, 0, 0, &pending_call_ops);
168 assert(ok);
169}
170
171void ipcp_cleanup(void)
172{
173 proto_delete(proto_system);
174 hash_table_destroy(&pending_calls);
175}
176
177void ipcp_call_out(int phone, ipc_call_t *call, ipc_callid_t hash)
178{
179 pending_call_t *pcall;
180 proto_t *proto;
181 oper_t *oper;
182 sysarg_t *args;
183 int i;
184
185 if (have_conn[phone]) proto = connections[phone].proto;
186 else proto = NULL;
187
188 args = call->args;
189
190 if ((display_mask & DM_IPC) != 0) {
191 printf("Call ID: %p, phone: %d, proto: %s, method: ",
192 (void *) hash, phone,
193 (proto ? proto->name : "n/a"));
194 ipc_m_print(proto, IPC_GET_IMETHOD(*call));
195 printf(" args: (%" PRIun ", %" PRIun ", %" PRIun ", "
196 "%" PRIun ", %" PRIun ")\n",
197 args[1], args[2], args[3], args[4], args[5]);
198 }
199
200
201 if ((display_mask & DM_USER) != 0) {
202
203 if (proto != NULL) {
204 oper = proto_get_oper(proto, IPC_GET_IMETHOD(*call));
205 } else {
206 oper = NULL;
207 }
208
209 if (oper != NULL) {
210
211 printf("%s(%d).%s", (proto ? proto->name : "n/a"),
212 phone, (oper ? oper->name : "unknown"));
213
214 putchar('(');
215 for (i = 1; i <= oper->argc; ++i) {
216 if (i > 1) printf(", ");
217 val_print(args[i], oper->arg_type[i - 1]);
218 }
219 putchar(')');
220
221 if (oper->rv_type == V_VOID && oper->respc == 0) {
222 /*
223 * No response data (typically the task will
224 * not be interested in the response).
225 * We will not display response.
226 */
227 putchar('.');
228 }
229
230 putchar('\n');
231 }
232 } else {
233 oper = NULL;
234 }
235
236 /* Store call in hash table for response matching */
237
238 pcall = malloc(sizeof(pending_call_t));
239 pcall->phone_hash = phone;
240 pcall->question = *call;
241 pcall->call_hash = hash;
242 pcall->oper = oper;
243
244 hash_table_insert(&pending_calls, &pcall->link);
245}
246
247static void parse_answer(ipc_callid_t hash, pending_call_t *pcall,
248 ipc_call_t *answer)
249{
250 sysarg_t phone;
251 sysarg_t method;
252 sysarg_t service;
253 sysarg_t retval;
254 proto_t *proto;
255 int cphone;
256
257 sysarg_t *resp;
258 oper_t *oper;
259 int i;
260
261 phone = pcall->phone_hash;
262 method = IPC_GET_IMETHOD(pcall->question);
263 retval = IPC_GET_RETVAL(*answer);
264
265 resp = answer->args;
266
267 if ((display_mask & DM_IPC) != 0) {
268 printf("Response to %p: retval=%" PRIdn ", args = (%" PRIun ", "
269 "%" PRIun ", %" PRIun ", %" PRIun ", %" PRIun ")\n",
270 (void *) hash, retval, IPC_GET_ARG1(*answer),
271 IPC_GET_ARG2(*answer), IPC_GET_ARG3(*answer),
272 IPC_GET_ARG4(*answer), IPC_GET_ARG5(*answer));
273 }
274
275 if ((display_mask & DM_USER) != 0) {
276 oper = pcall->oper;
277
278 if ((oper != NULL) &&
279 ((oper->rv_type != V_VOID) || (oper->respc > 0))) {
280 printf("->");
281
282 if (oper->rv_type != V_VOID) {
283 putchar(' ');
284 val_print(retval, oper->rv_type);
285 }
286
287 if (oper->respc > 0) {
288 putchar(' ');
289 putchar('(');
290 for (i = 1; i <= oper->respc; ++i) {
291 if (i > 1)
292 printf(", ");
293 val_print(resp[i], oper->resp_type[i - 1]);
294 }
295 putchar(')');
296 }
297
298 putchar('\n');
299 }
300 }
301
302 if ((phone == PHONE_NS) && (method == IPC_M_CONNECT_ME_TO) &&
303 (retval == 0)) {
304 /* Connected to a service (through NS) */
305 service = IPC_GET_ARG2(pcall->question);
306 proto = proto_get_by_srv(service);
307 if (proto == NULL)
308 proto = proto_unknown;
309
310 cphone = IPC_GET_ARG5(*answer);
311 if ((display_mask & DM_SYSTEM) != 0) {
312 printf("Registering connection (phone %d, protocol: %s)\n", cphone,
313 proto->name);
314 }
315
316 ipcp_connection_set(cphone, 0, proto);
317 }
318}
319
320void ipcp_call_in(ipc_call_t *call, ipc_callid_t hash)
321{
322 ht_link_t *item;
323 pending_call_t *pcall;
324
325 if ((call->flags & IPC_CALLID_ANSWERED) == 0 &&
326 hash != IPCP_CALLID_SYNC) {
327 /* Not a response */
328 if ((display_mask & DM_IPC) != 0) {
329 printf("Not a response (hash %p)\n", (void *) hash);
330 }
331 return;
332 }
333
334 item = hash_table_find(&pending_calls, &hash);
335 if (item == NULL)
336 return; /* No matching question found */
337
338 /*
339 * Response matched to question.
340 */
341
342 pcall = hash_table_get_inst(item, pending_call_t, link);
343 hash_table_remove(&pending_calls, &hash);
344
345 parse_answer(hash, pcall, call);
346 free(pcall);
347}
348
349void ipcp_call_sync(int phone, ipc_call_t *call, ipc_call_t *answer)
350{
351 ipcp_call_out(phone, call, IPCP_CALLID_SYNC);
352 ipcp_call_in(answer, IPCP_CALLID_SYNC);
353}
354
355void ipcp_hangup(int phone, int rc)
356{
357 if ((display_mask & DM_SYSTEM) != 0) {
358 printf("Hang phone %d up -> %d\n", phone, rc);
359 ipcp_connection_clear(phone);
360 }
361}
362
363/** @}
364 */
Note: See TracBrowser for help on using the repository browser.