Subversion Repositories HelenOS

Rev

Rev 3435 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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