Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
955 palkovsky 1
/*
2
 * Copyright (C) 2006 Ondrej Palkovsky
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
/* Lock ordering
30
 *
31
 * First the answerbox, then the phone
32
 */
33
 
1040 palkovsky 34
#include <synch/spinlock.h>
35
#include <synch/waitq.h>
955 palkovsky 36
#include <ipc/ipc.h>
37
#include <errno.h>
38
#include <mm/slab.h>
39
#include <arch.h>
40
#include <proc/task.h>
41
#include <memstr.h>
42
#include <debug.h>
43
 
44
#include <print.h>
45
#include <proc/thread.h>
46
 
965 palkovsky 47
/* Open channel that is assigned automatically to new tasks */
48
answerbox_t *ipc_phone_0 = NULL;
955 palkovsky 49
 
50
static slab_cache_t *ipc_call_slab;
51
 
1084 palkovsky 52
/* Initialize new call */
53
static void _ipc_call_init(call_t *call)
54
{
55
    memsetb((__address)call, sizeof(*call), 0);
56
    call->callerbox = &TASK->answerbox;
57
    call->sender = TASK;
58
}
59
 
955 palkovsky 60
/** Allocate & initialize call structure
61
 *
62
 * The call is initialized, so that the reply will be directed
63
 * to TASK->answerbox
64
 */
65
call_t * ipc_call_alloc(void)
66
{
67
    call_t *call;
68
 
69
    call = slab_alloc(ipc_call_slab, 0);
1084 palkovsky 70
    _ipc_call_init(call);
955 palkovsky 71
 
72
    return call;
73
}
74
 
965 palkovsky 75
/** Initialize allocated call */
1084 palkovsky 76
void ipc_call_static_init(call_t *call)
965 palkovsky 77
{
1084 palkovsky 78
    _ipc_call_init(call);
79
    call->flags |= IPC_CALL_STATIC_ALLOC;
965 palkovsky 80
}
81
 
955 palkovsky 82
/** Deallocate call stracuture */
83
void ipc_call_free(call_t *call)
84
{
85
    slab_free(ipc_call_slab, call);
86
}
87
 
88
/** Initialize answerbox structure
89
 */
90
void ipc_answerbox_init(answerbox_t *box)
91
{
1040 palkovsky 92
    spinlock_initialize(&box->lock, "ipc_box_lock");
93
    waitq_initialize(&box->wq);
955 palkovsky 94
    list_initialize(&box->connected_phones);
95
    list_initialize(&box->calls);
96
    list_initialize(&box->dispatched_calls);
97
    list_initialize(&box->answers);
1027 palkovsky 98
    box->task = TASK;
955 palkovsky 99
}
100
 
1040 palkovsky 101
/** Connect phone to answerbox */
102
void ipc_phone_connect(phone_t *phone, answerbox_t *box)
955 palkovsky 103
{
1084 palkovsky 104
    spinlock_lock(&phone->lock);
105
 
1040 palkovsky 106
    ASSERT(!phone->callee);
107
    phone->busy = 1;
955 palkovsky 108
    phone->callee = box;
965 palkovsky 109
 
1040 palkovsky 110
    spinlock_lock(&box->lock);
955 palkovsky 111
    list_append(&phone->list, &box->connected_phones);
1040 palkovsky 112
    spinlock_unlock(&box->lock);
1084 palkovsky 113
 
114
    spinlock_unlock(&phone->lock);
955 palkovsky 115
}
116
 
1040 palkovsky 117
/** Initialize phone structure and connect phone to naswerbox
118
 */
119
void ipc_phone_init(phone_t *phone)
120
{
121
    spinlock_initialize(&phone->lock, "phone_lock");
122
    phone->callee = NULL;
123
    phone->busy = 0;
124
}
125
 
1084 palkovsky 126
/** Disconnect phone from answerbox
127
 *
128
 * It is allowed to call disconnect on already disconnected phone\
129
 */
955 palkovsky 130
void ipc_phone_destroy(phone_t *phone)
131
{
132
    answerbox_t *box = phone->callee;
133
 
134
    ASSERT(box);
135
 
1084 palkovsky 136
    spinlock_lock(&phone->lock);
1040 palkovsky 137
    spinlock_lock(&box->lock);
1084 palkovsky 138
 
139
    if (phone->callee) {
140
        list_remove(&phone->list);
141
        phone->callee = NULL;
142
    }
143
 
1040 palkovsky 144
    spinlock_unlock(&box->lock);
1084 palkovsky 145
    spinlock_unlock(&phone->lock);
955 palkovsky 146
}
147
 
959 palkovsky 148
/** Helper function to facilitate synchronous calls */
149
void ipc_call_sync(phone_t *phone, call_t *request)
150
{
151
    answerbox_t sync_box;
955 palkovsky 152
 
959 palkovsky 153
    ipc_answerbox_init(&sync_box);
154
 
155
    /* We will receive data on special box */
156
    request->callerbox = &sync_box;
157
 
158
    ipc_call(phone, request);
159
    ipc_wait_for_call(&sync_box, 0);
160
}
161
 
1084 palkovsky 162
/** Answer message that was not dispatched and is not entered in
163
 * any queue
164
 */
165
static void _ipc_answer_free_call(call_t *call)
166
{
167
    answerbox_t *callerbox = call->callerbox;
168
 
169
    call->flags &= ~IPC_CALL_DISPATCHED;
170
    call->flags |= IPC_CALL_ANSWERED;
171
 
172
    spinlock_lock(&callerbox->lock);
173
    list_append(&call->list, &callerbox->answers);
174
    spinlock_unlock(&callerbox->lock);
175
    waitq_wakeup(&callerbox->wq, 0);
176
}
177
 
178
/** Answer message, that is in callee queue
179
 *
180
 * @param box Answerbox that is answering the message
181
 * @param call Modified request that is being sent back
182
 */
183
void ipc_answer(answerbox_t *box, call_t *call)
184
{
185
    /* Remove from active box */
186
    spinlock_lock(&box->lock);
187
    list_remove(&call->list);
188
    spinlock_unlock(&box->lock);
189
    /* Send back answer */
190
    _ipc_answer_free_call(call);
191
}
192
 
959 palkovsky 193
/** Send a asynchronous request using phone to answerbox
955 palkovsky 194
 *
195
 * @param phone Phone connected to answerbox
196
 * @param request Request to be sent
197
 */
1040 palkovsky 198
void ipc_call(phone_t *phone, call_t *call)
955 palkovsky 199
{
1084 palkovsky 200
    answerbox_t *box;
955 palkovsky 201
 
1084 palkovsky 202
    spinlock_lock(&phone->lock);
203
    box = phone->callee;
204
    if (!box) {
205
        /* Trying to send over disconnected phone */
206
        IPC_SET_RETVAL(call->data, ENOENT);
207
        _ipc_answer_free_call(call);
208
        return;
209
    }
955 palkovsky 210
 
1040 palkovsky 211
    spinlock_lock(&box->lock);
212
    list_append(&call->list, &box->calls);
213
    spinlock_unlock(&box->lock);
214
    waitq_wakeup(&box->wq, 0);
1084 palkovsky 215
 
216
    spinlock_unlock(&phone->lock);
955 palkovsky 217
}
218
 
1040 palkovsky 219
/** Forwards call from one answerbox to a new one
220
 *
221
 * @param request Request to be forwarded
222
 * @param newbox Target answerbox
223
 * @param oldbox Old answerbox
224
 */
1084 palkovsky 225
void ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox)
1040 palkovsky 226
{
227
    spinlock_lock(&oldbox->lock);
228
    list_remove(&call->list);
229
    spinlock_unlock(&oldbox->lock);
230
 
1084 palkovsky 231
    ipc_call(newphone, call);
1040 palkovsky 232
}
233
 
955 palkovsky 234
 
235
/** Wait for phone call
236
 *
237
 * @return Recived message address
238
 * - to distinguish between call and answer, look at call->flags
239
 */
240
call_t * ipc_wait_for_call(answerbox_t *box, int flags)
241
{
242
    call_t *request;
243
 
1040 palkovsky 244
    spinlock_lock(&box->lock);
965 palkovsky 245
    while (1) {
246
        if (!list_empty(&box->answers)) {
247
            /* Handle asynchronous answers */
248
            request = list_get_instance(box->answers.next, call_t, list);
249
            list_remove(&request->list);
250
        } else if (!list_empty(&box->calls)) {
251
            /* Handle requests */
252
            request = list_get_instance(box->calls.next, call_t, list);
253
            list_remove(&request->list);
254
            /* Append request to dispatch queue */
255
            list_append(&request->list, &box->dispatched_calls);
1050 palkovsky 256
            request->flags |= IPC_CALL_DISPATCHED;
965 palkovsky 257
        } else {
258
            if (!(flags & IPC_WAIT_NONBLOCKING)) {
980 palkovsky 259
                /* Wait for event to appear */
1040 palkovsky 260
                spinlock_unlock(&box->lock);
261
                waitq_sleep(&box->wq);
262
                spinlock_lock(&box->lock);
965 palkovsky 263
                continue;
264
            }
265
            request = NULL;
266
        }
267
        break;
955 palkovsky 268
    }
1040 palkovsky 269
    spinlock_unlock(&box->lock);
955 palkovsky 270
    return request;
271
}
272
 
273
/** Initilize ipc subsystem */
274
void ipc_init(void)
275
{
276
    ipc_call_slab = slab_cache_create("ipc_call",
277
                      sizeof(call_t),
278
                      0,
279
                      NULL, NULL, 0);
280
}
1072 palkovsky 281
 
282
/** Cleans up all IPC communication of the given task
283
 *
284
 *
285
 */
286
void ipc_cleanup(task_t *task)
287
{
288
    /* Cancel all calls in my dispatch queue */
289
 
290
}