Rev 1653 | Rev 1751 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
954 | 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. |
||
1653 | cejka | 27 | */ |
28 | |||
29 | /** @addtogroup libc |
||
30 | * @{ |
||
31 | * @} |
||
32 | */ |
||
33 | |||
34 | /** @addtogroup libcipc IPC |
||
35 | * @brief HelenOS uspace IPC |
||
36 | * @{ |
||
37 | * @ingroup libc |
||
38 | */ |
||
39 | /** @file |
||
954 | palkovsky | 40 | */ |
41 | |||
1352 | palkovsky | 42 | #include <ipc/ipc.h> |
954 | palkovsky | 43 | #include <libc.h> |
999 | palkovsky | 44 | #include <malloc.h> |
45 | #include <errno.h> |
||
1352 | palkovsky | 46 | #include <libadt/list.h> |
999 | palkovsky | 47 | #include <stdio.h> |
48 | #include <unistd.h> |
||
1350 | palkovsky | 49 | #include <futex.h> |
1365 | jermar | 50 | #include <kernel/synch/synch.h> |
1463 | palkovsky | 51 | #include <async.h> |
52 | #include <psthread.h> |
||
954 | palkovsky | 53 | |
999 | palkovsky | 54 | /** Structure used for keeping track of sent async msgs |
55 | * and queing unsent msgs |
||
56 | * |
||
57 | */ |
||
58 | typedef struct { |
||
59 | link_t list; |
||
60 | |||
61 | ipc_async_callback_t callback; |
||
62 | void *private; |
||
63 | union { |
||
64 | ipc_callid_t callid; |
||
65 | struct { |
||
1091 | palkovsky | 66 | ipc_call_t data; |
999 | palkovsky | 67 | int phoneid; |
68 | } msg; |
||
69 | }u; |
||
1463 | palkovsky | 70 | pstid_t ptid; /**< Thread waiting for sending this msg */ |
999 | palkovsky | 71 | } async_call_t; |
72 | |||
73 | LIST_INITIALIZE(dispatched_calls); |
||
74 | |||
1463 | palkovsky | 75 | /* queued_calls is protcted by async_futex, because if the |
76 | * call cannot be sent into kernel, async framework is used |
||
77 | * automatically |
||
78 | */ |
||
79 | LIST_INITIALIZE(queued_calls); /**< List of async calls that were not accepted |
||
80 | * by kernel */ |
||
81 | |||
1392 | palkovsky | 82 | static atomic_t ipc_futex = FUTEX_INITIALIZER; |
1350 | palkovsky | 83 | |
999 | palkovsky | 84 | int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1, |
85 | ipcarg_t *result) |
||
954 | palkovsky | 86 | { |
1091 | palkovsky | 87 | ipc_call_t resdata; |
966 | palkovsky | 88 | int callres; |
89 | |||
999 | palkovsky | 90 | callres = __SYSCALL4(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1, |
966 | palkovsky | 91 | (sysarg_t)&resdata); |
92 | if (callres) |
||
93 | return callres; |
||
94 | if (result) |
||
95 | *result = IPC_GET_ARG1(resdata); |
||
96 | return IPC_GET_RETVAL(resdata); |
||
954 | palkovsky | 97 | } |
98 | |||
999 | palkovsky | 99 | int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1, |
100 | ipcarg_t arg2, ipcarg_t arg3, |
||
101 | ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3) |
||
954 | palkovsky | 102 | { |
1091 | palkovsky | 103 | ipc_call_t data; |
966 | palkovsky | 104 | int callres; |
105 | |||
106 | IPC_SET_METHOD(data, method); |
||
107 | IPC_SET_ARG1(data, arg1); |
||
108 | IPC_SET_ARG2(data, arg2); |
||
109 | IPC_SET_ARG3(data, arg3); |
||
110 | |||
1006 | palkovsky | 111 | callres = __SYSCALL3(SYS_IPC_CALL_SYNC, phoneid, (sysarg_t)&data, |
112 | (sysarg_t)&data); |
||
966 | palkovsky | 113 | if (callres) |
114 | return callres; |
||
115 | |||
116 | if (result1) |
||
117 | *result1 = IPC_GET_ARG1(data); |
||
118 | if (result2) |
||
119 | *result2 = IPC_GET_ARG2(data); |
||
120 | if (result3) |
||
121 | *result3 = IPC_GET_ARG3(data); |
||
122 | return IPC_GET_RETVAL(data); |
||
123 | } |
||
124 | |||
999 | palkovsky | 125 | /** Syscall to send asynchronous message */ |
1091 | palkovsky | 126 | static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data) |
999 | palkovsky | 127 | { |
128 | return __SYSCALL2(SYS_IPC_CALL_ASYNC, phoneid, (sysarg_t)data); |
||
129 | } |
||
130 | |||
1489 | palkovsky | 131 | /** Prolog to ipc_async_send functions */ |
132 | static inline async_call_t *ipc_prepare_async(void *private, ipc_async_callback_t callback) |
||
966 | palkovsky | 133 | { |
999 | palkovsky | 134 | async_call_t *call; |
966 | palkovsky | 135 | |
999 | palkovsky | 136 | call = malloc(sizeof(*call)); |
137 | if (!call) { |
||
1443 | palkovsky | 138 | if (callback) |
139 | callback(private, ENOMEM, NULL); |
||
1489 | palkovsky | 140 | return NULL; |
999 | palkovsky | 141 | } |
1463 | palkovsky | 142 | call->callback = callback; |
143 | call->private = private; |
||
144 | |||
1489 | palkovsky | 145 | return call; |
146 | } |
||
147 | |||
148 | /** Epilogue of ipc_async_send functions */ |
||
1518 | palkovsky | 149 | static inline void ipc_finish_async(ipc_callid_t callid, int phoneid, |
150 | async_call_t *call, int can_preempt) |
||
1489 | palkovsky | 151 | { |
966 | palkovsky | 152 | if (callid == IPC_CALLRET_FATAL) { |
1463 | palkovsky | 153 | futex_up(&ipc_futex); |
966 | palkovsky | 154 | /* Call asynchronous handler with error code */ |
1489 | palkovsky | 155 | if (call->callback) |
156 | call->callback(call->private, ENOENT, NULL); |
||
999 | palkovsky | 157 | free(call); |
966 | palkovsky | 158 | return; |
159 | } |
||
999 | palkovsky | 160 | |
1463 | palkovsky | 161 | if (callid == IPC_CALLRET_TEMPORARY) { |
162 | futex_up(&ipc_futex); |
||
999 | palkovsky | 163 | |
164 | call->u.msg.phoneid = phoneid; |
||
1518 | palkovsky | 165 | |
1463 | palkovsky | 166 | futex_down(&async_futex); |
999 | palkovsky | 167 | list_append(&call->list, &queued_calls); |
1463 | palkovsky | 168 | |
1518 | palkovsky | 169 | if (can_preempt) { |
170 | call->ptid = psthread_get_id(); |
||
171 | psthread_schedule_next_adv(PS_TO_MANAGER); |
||
172 | /* Async futex unlocked by previous call */ |
||
173 | } else { |
||
174 | call->ptid = 0; |
||
175 | futex_up(&async_futex); |
||
176 | } |
||
966 | palkovsky | 177 | return; |
178 | } |
||
999 | palkovsky | 179 | call->u.callid = callid; |
180 | /* Add call to list of dispatched calls */ |
||
181 | list_append(&call->list, &dispatched_calls); |
||
1350 | palkovsky | 182 | futex_up(&ipc_futex); |
1489 | palkovsky | 183 | |
954 | palkovsky | 184 | } |
185 | |||
1489 | palkovsky | 186 | /** Send asynchronous message |
187 | * |
||
188 | * - if fatal error, call callback handler with proper error code |
||
189 | * - if message cannot be temporarily sent, add to queue |
||
190 | */ |
||
191 | void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1, |
||
192 | ipcarg_t arg2, void *private, |
||
1518 | palkovsky | 193 | ipc_async_callback_t callback, int can_preempt) |
1489 | palkovsky | 194 | { |
195 | async_call_t *call; |
||
196 | ipc_callid_t callid; |
||
966 | palkovsky | 197 | |
1489 | palkovsky | 198 | call = ipc_prepare_async(private, callback); |
199 | if (!call) |
||
200 | return; |
||
201 | |||
202 | /* We need to make sure that we get callid before |
||
203 | * another thread accesses the queue again */ |
||
204 | futex_down(&ipc_futex); |
||
205 | callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, arg2); |
||
206 | |||
207 | if (callid == IPC_CALLRET_TEMPORARY) { |
||
208 | IPC_SET_METHOD(call->u.msg.data, method); |
||
209 | IPC_SET_ARG1(call->u.msg.data, arg1); |
||
210 | IPC_SET_ARG2(call->u.msg.data, arg2); |
||
211 | } |
||
1518 | palkovsky | 212 | ipc_finish_async(callid, phoneid, call, can_preempt); |
1489 | palkovsky | 213 | } |
214 | |||
215 | /** Send asynchronous message |
||
216 | * |
||
217 | * - if fatal error, call callback handler with proper error code |
||
218 | * - if message cannot be temporarily sent, add to queue |
||
219 | */ |
||
220 | void ipc_call_async_3(int phoneid, ipcarg_t method, ipcarg_t arg1, |
||
221 | ipcarg_t arg2, ipcarg_t arg3, void *private, |
||
1518 | palkovsky | 222 | ipc_async_callback_t callback, int can_preempt) |
1489 | palkovsky | 223 | { |
224 | async_call_t *call; |
||
225 | ipc_callid_t callid; |
||
226 | |||
227 | call = ipc_prepare_async(private, callback); |
||
228 | if (!call) |
||
229 | return; |
||
230 | |||
231 | IPC_SET_METHOD(call->u.msg.data, method); |
||
232 | IPC_SET_ARG1(call->u.msg.data, arg1); |
||
233 | IPC_SET_ARG2(call->u.msg.data, arg2); |
||
234 | IPC_SET_ARG3(call->u.msg.data, arg3); |
||
235 | /* We need to make sure that we get callid before |
||
236 | * another thread accesses the queue again */ |
||
237 | futex_down(&ipc_futex); |
||
238 | callid = _ipc_call_async(phoneid, &call->u.msg.data); |
||
239 | |||
1518 | palkovsky | 240 | ipc_finish_async(callid, phoneid, call, can_preempt); |
1489 | palkovsky | 241 | } |
242 | |||
243 | |||
1343 | jermar | 244 | /** Send a fast answer to a received call. |
245 | * |
||
246 | * The fast answer makes use of passing retval and first two arguments in registers. |
||
247 | * If you need to return more, use the ipc_answer() instead. |
||
248 | * |
||
249 | * @param callid ID of the call being answered. |
||
250 | * @param retval Return value. |
||
251 | * @param arg1 First return argument. |
||
252 | * @param arg2 Second return argument. |
||
253 | * |
||
254 | * @return Zero on success or a value from @ref errno.h on failure. |
||
255 | */ |
||
256 | ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1, |
||
999 | palkovsky | 257 | ipcarg_t arg2) |
954 | palkovsky | 258 | { |
1330 | palkovsky | 259 | return __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2); |
954 | palkovsky | 260 | } |
261 | |||
1343 | jermar | 262 | /** Send a full answer to a received call. |
263 | * |
||
264 | * @param callid ID of the call being answered. |
||
265 | * @param call Call data. Must be already initialized by the responder. |
||
266 | * |
||
267 | * @return Zero on success or a value from @ref errno.h on failure. |
||
268 | */ |
||
269 | ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call) |
||
270 | { |
||
271 | return __SYSCALL2(SYS_IPC_ANSWER, callid, (sysarg_t) call); |
||
272 | } |
||
273 | |||
274 | |||
999 | palkovsky | 275 | /** Try to dispatch queed calls from async queue */ |
276 | static void try_dispatch_queued_calls(void) |
||
277 | { |
||
278 | async_call_t *call; |
||
279 | ipc_callid_t callid; |
||
280 | |||
1463 | palkovsky | 281 | /* TODO: integrate intelligently ipc_futex, so that it |
282 | * is locked during ipc_call_async, until it is added |
||
283 | * to dispatched_calls |
||
284 | */ |
||
285 | futex_down(&async_futex); |
||
999 | palkovsky | 286 | while (!list_empty(&queued_calls)) { |
287 | call = list_get_instance(queued_calls.next, async_call_t, |
||
288 | list); |
||
289 | |||
290 | callid = _ipc_call_async(call->u.msg.phoneid, |
||
291 | &call->u.msg.data); |
||
1463 | palkovsky | 292 | if (callid == IPC_CALLRET_TEMPORARY) { |
999 | palkovsky | 293 | break; |
1463 | palkovsky | 294 | } |
999 | palkovsky | 295 | list_remove(&call->list); |
1350 | palkovsky | 296 | |
1463 | palkovsky | 297 | futex_up(&async_futex); |
1518 | palkovsky | 298 | if (call->ptid) |
299 | psthread_add_ready(call->ptid); |
||
1463 | palkovsky | 300 | |
999 | palkovsky | 301 | if (callid == IPC_CALLRET_FATAL) { |
1443 | palkovsky | 302 | if (call->callback) |
303 | call->callback(call->private, ENOENT, NULL); |
||
999 | palkovsky | 304 | free(call); |
305 | } else { |
||
306 | call->u.callid = callid; |
||
1463 | palkovsky | 307 | futex_down(&ipc_futex); |
999 | palkovsky | 308 | list_append(&call->list, &dispatched_calls); |
1463 | palkovsky | 309 | futex_up(&ipc_futex); |
999 | palkovsky | 310 | } |
1463 | palkovsky | 311 | futex_down(&async_futex); |
999 | palkovsky | 312 | } |
1463 | palkovsky | 313 | futex_up(&async_futex); |
999 | palkovsky | 314 | } |
315 | |||
316 | /** Handle received answer |
||
317 | * |
||
318 | * TODO: Make it use hash table |
||
319 | * |
||
320 | * @param callid Callid (with first bit set) of the answered call |
||
321 | */ |
||
1091 | palkovsky | 322 | static void handle_answer(ipc_callid_t callid, ipc_call_t *data) |
999 | palkovsky | 323 | { |
324 | link_t *item; |
||
325 | async_call_t *call; |
||
326 | |||
327 | callid &= ~IPC_CALLID_ANSWERED; |
||
328 | |||
1350 | palkovsky | 329 | futex_down(&ipc_futex); |
999 | palkovsky | 330 | for (item = dispatched_calls.next; item != &dispatched_calls; |
331 | item = item->next) { |
||
332 | call = list_get_instance(item, async_call_t, list); |
||
333 | if (call->u.callid == callid) { |
||
334 | list_remove(&call->list); |
||
1350 | palkovsky | 335 | futex_up(&ipc_futex); |
1443 | palkovsky | 336 | if (call->callback) |
337 | call->callback(call->private, |
||
338 | IPC_GET_RETVAL(*data), |
||
339 | data); |
||
340 | free(call); |
||
999 | palkovsky | 341 | return; |
342 | } |
||
343 | } |
||
1350 | palkovsky | 344 | futex_up(&ipc_futex); |
999 | palkovsky | 345 | printf("Received unidentified answer: %P!!!\n", callid); |
346 | } |
||
347 | |||
348 | |||
1392 | palkovsky | 349 | /** One cycle of ipc wait for call call |
954 | palkovsky | 350 | * |
351 | * - dispatch ASYNC reoutines in the background |
||
1365 | jermar | 352 | * @param call Space where the message is stored |
1392 | palkovsky | 353 | * @param usec Timeout in microseconds |
354 | * @param flags Flags passed to SYS_IPC_WAIT (blocking, nonblocking) |
||
1365 | jermar | 355 | * @return Callid of the answer. |
954 | palkovsky | 356 | */ |
1392 | palkovsky | 357 | ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags) |
954 | palkovsky | 358 | { |
359 | ipc_callid_t callid; |
||
360 | |||
1392 | palkovsky | 361 | callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags); |
362 | /* Handle received answers */ |
||
1463 | palkovsky | 363 | if (callid & IPC_CALLID_ANSWERED) { |
1392 | palkovsky | 364 | handle_answer(callid, call); |
1463 | palkovsky | 365 | try_dispatch_queued_calls(); |
366 | } |
||
999 | palkovsky | 367 | |
954 | palkovsky | 368 | return callid; |
369 | } |
||
1028 | palkovsky | 370 | |
1365 | jermar | 371 | /** Wait some time for an IPC call. |
372 | * |
||
373 | * - dispatch ASYNC reoutines in the background |
||
1709 | jermar | 374 | * |
1365 | jermar | 375 | * @param call Space where the message is stored |
376 | * @param usec Timeout in microseconds. |
||
377 | * @return Callid of the answer. |
||
378 | */ |
||
379 | ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec) |
||
380 | { |
||
381 | ipc_callid_t callid; |
||
382 | |||
383 | do { |
||
1503 | jermar | 384 | callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE); |
1365 | jermar | 385 | } while (callid & IPC_CALLID_ANSWERED); |
386 | |||
387 | return callid; |
||
388 | } |
||
389 | |||
390 | /** Check if there is an IPC call waiting to be picked up. |
||
391 | * |
||
392 | * - dispatch ASYNC reoutines in the background |
||
1709 | jermar | 393 | * |
1365 | jermar | 394 | * @param call Space where the message is stored |
395 | * @return Callid of the answer. |
||
396 | */ |
||
397 | ipc_callid_t ipc_trywait_for_call(ipc_call_t *call) |
||
398 | { |
||
399 | ipc_callid_t callid; |
||
400 | |||
401 | do { |
||
1503 | jermar | 402 | callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING); |
1365 | jermar | 403 | } while (callid & IPC_CALLID_ANSWERED); |
404 | |||
405 | return callid; |
||
406 | } |
||
407 | |||
1091 | palkovsky | 408 | /** Ask destination to do a callback connection |
409 | * |
||
410 | * @return 0 - OK, error code |
||
411 | */ |
||
412 | int ipc_connect_to_me(int phoneid, int arg1, int arg2, ipcarg_t *phone) |
||
1028 | palkovsky | 413 | { |
1091 | palkovsky | 414 | return ipc_call_sync_3(phoneid, IPC_M_CONNECT_TO_ME, arg1, |
415 | arg2, 0, 0, 0, phone); |
||
1028 | palkovsky | 416 | } |
1061 | palkovsky | 417 | |
1091 | palkovsky | 418 | /** Ask through phone for a new connection to some service |
419 | * |
||
420 | * @return new phoneid - OK, error code |
||
421 | */ |
||
1061 | palkovsky | 422 | int ipc_connect_me_to(int phoneid, int arg1, int arg2) |
423 | { |
||
1092 | palkovsky | 424 | ipcarg_t newphid; |
1091 | palkovsky | 425 | int res; |
426 | |||
427 | res = ipc_call_sync_3(phoneid, IPC_M_CONNECT_ME_TO, arg1, |
||
428 | arg2, 0, 0, 0, &newphid); |
||
429 | if (res) |
||
430 | return res; |
||
431 | return newphid; |
||
1061 | palkovsky | 432 | } |
433 | |||
1089 | palkovsky | 434 | /* Hang up specified phone */ |
435 | int ipc_hangup(int phoneid) |
||
436 | { |
||
437 | return __SYSCALL1(SYS_IPC_HANGUP, phoneid); |
||
438 | } |
||
1259 | palkovsky | 439 | |
1282 | palkovsky | 440 | int ipc_register_irq(int irq, irq_code_t *ucode) |
1259 | palkovsky | 441 | { |
1282 | palkovsky | 442 | return __SYSCALL2(SYS_IPC_REGISTER_IRQ, irq, (sysarg_t) ucode); |
1259 | palkovsky | 443 | } |
444 | |||
445 | int ipc_unregister_irq(int irq) |
||
446 | { |
||
447 | return __SYSCALL1(SYS_IPC_UNREGISTER_IRQ, irq); |
||
448 | } |
||
1330 | palkovsky | 449 | |
1336 | jermar | 450 | int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method, ipcarg_t arg1) |
451 | { |
||
452 | return __SYSCALL4(SYS_IPC_FORWARD_FAST, callid, phoneid, method, arg1); |
||
453 | } |
||
454 | |||
1653 | cejka | 455 | |
456 | |||
457 | /** @} |
||
458 | */ |
||
459 | |||
460 |