Rev 1029 | Rev 1060 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 1029 | Rev 1040 | ||
---|---|---|---|
Line 38... | Line 38... | ||
38 | #include <print.h> |
38 | #include <print.h> |
39 | 39 | ||
40 | /* TODO: multi-threaded connect-to-me can cause race condition |
40 | /* TODO: multi-threaded connect-to-me can cause race condition |
41 | * on phone, add counter + thread_kill?? |
41 | * on phone, add counter + thread_kill?? |
42 | * |
42 | * |
43 | * - don't allow userspace app to send system messages |
- | |
44 | */ |
43 | */ |
45 | 44 | ||
- | 45 | /** Return true if the method is a system method */ |
|
- | 46 | static inline int is_system_method(__native method) |
|
- | 47 | { |
|
- | 48 | if (method <= IPC_M_LAST_SYSTEM) |
|
- | 49 | return 1; |
|
- | 50 | return 0; |
|
- | 51 | } |
|
- | 52 | ||
- | 53 | /** Return true if the message with this method is forwardable |
|
- | 54 | * |
|
- | 55 | * - some system messages may be forwarded, for some of them |
|
- | 56 | * it is useless |
|
- | 57 | */ |
|
- | 58 | static inline int is_forwardable(__native method) |
|
- | 59 | { |
|
- | 60 | return 1; |
|
- | 61 | } |
|
- | 62 | ||
- | 63 | /** Find call_t * in call table according to callid |
|
- | 64 | * |
|
- | 65 | * @return NULL on not found, otherwise pointer to call structure |
|
- | 66 | */ |
|
- | 67 | static inline call_t * get_call(__native callid) |
|
- | 68 | { |
|
- | 69 | /* TODO: Traverse list of dispatched calls and find one */ |
|
- | 70 | /* TODO: locking of call, ripping it from dispatched calls etc. */ |
|
- | 71 | return (call_t *) callid; |
|
- | 72 | } |
|
- | 73 | ||
46 | /** Return pointer to phone identified by phoneid or NULL if non-existent */ |
74 | /** Return pointer to phone identified by phoneid or NULL if non-existent */ |
47 | static phone_t * get_phone(__native phoneid) |
75 | static phone_t * get_phone(__native phoneid) |
48 | { |
76 | { |
49 | phone_t *phone; |
77 | phone_t *phone; |
50 | 78 | ||
Line 56... | Line 84... | ||
56 | return NULL; |
84 | return NULL; |
57 | return phone; |
85 | return phone; |
58 | } |
86 | } |
59 | 87 | ||
60 | /** Allocate new phone slot in current TASK structure */ |
88 | /** Allocate new phone slot in current TASK structure */ |
61 | static int phone_alloc(answerbox_t *callee) |
89 | static int phone_alloc(void) |
62 | { |
90 | { |
63 | int i; |
91 | int i; |
64 | 92 | ||
65 | spinlock_lock(&TASK->lock); |
93 | spinlock_lock(&TASK->lock); |
66 | 94 | ||
67 | for (i=0; i < IPC_MAX_PHONES; i++) { |
95 | for (i=0; i < IPC_MAX_PHONES; i++) { |
68 | if (!TASK->phones[i].callee) { |
96 | if (!TASK->phones[i].busy) { |
69 | TASK->phones[i].callee = callee; |
97 | TASK->phones[i].busy = 1; |
70 | break; |
98 | break; |
71 | } |
99 | } |
72 | } |
100 | } |
73 | spinlock_unlock(&TASK->lock); |
101 | spinlock_unlock(&TASK->lock); |
74 | 102 | ||
Line 80... | Line 108... | ||
80 | /** Disconnect phone */ |
108 | /** Disconnect phone */ |
81 | static void phone_dealloc(int phoneid) |
109 | static void phone_dealloc(int phoneid) |
82 | { |
110 | { |
83 | spinlock_lock(&TASK->lock); |
111 | spinlock_lock(&TASK->lock); |
84 | 112 | ||
85 | ASSERT(TASK->phones[phoneid].callee); |
113 | ASSERT(TASK->phones[phoneid].busy); |
86 | 114 | ||
- | 115 | if (TASK->phones[phoneid].callee) |
|
- | 116 | ipc_phone_destroy(&TASK->phones[phoneid]); |
|
- | 117 | ||
87 | TASK->phones[phoneid].callee = NULL; |
118 | TASK->phones[phoneid].busy = 0; |
88 | spinlock_unlock(&TASK->lock); |
119 | spinlock_unlock(&TASK->lock); |
89 | } |
120 | } |
90 | 121 | ||
- | 122 | static void phone_connect(int phoneid, answerbox_t *box) |
|
- | 123 | { |
|
- | 124 | phone_t *phone = &TASK->phones[phoneid]; |
|
- | 125 | ||
- | 126 | ipc_phone_connect(phone, box); |
|
- | 127 | } |
|
- | 128 | ||
91 | /****************************************************/ |
129 | /****************************************************/ |
92 | /* Functions that preprocess answer before sending |
130 | /* Functions that preprocess answer before sending |
93 | * it to the recepient |
131 | * it to the recepient |
94 | */ |
132 | */ |
95 | 133 | ||
Line 102... | Line 140... | ||
102 | return 1; |
140 | return 1; |
103 | return 0; |
141 | return 0; |
104 | } |
142 | } |
105 | 143 | ||
106 | /** Interpret process answer as control information */ |
144 | /** Interpret process answer as control information */ |
107 | static inline void answer_preprocess(call_t *answer, call_t *call) |
145 | static inline void answer_preprocess(call_t *answer, ipc_data_t *olddata) |
108 | { |
146 | { |
109 | int phoneid; |
147 | int phoneid; |
110 | 148 | ||
111 | if (IPC_GET_METHOD(call->data) == IPC_M_CONNECTTOME) { |
149 | if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECTTOME) { |
- | 150 | phoneid = IPC_GET_ARG3(*olddata); |
|
112 | if (IPC_GET_RETVAL(answer->data)) { |
151 | if (IPC_GET_RETVAL(answer->data)) { |
113 | /* The connection was not accepted */ |
152 | /* The connection was not accepted */ |
114 | /* TODO...race for multi-threaded process */ |
- | |
115 | phoneid = IPC_GET_ARG3(call->data); |
- | |
116 | phone_dealloc(phoneid); |
153 | phone_dealloc(phoneid); |
- | 154 | } else { |
|
- | 155 | /* The connection was accepted */ |
|
- | 156 | phone_connect(phoneid,&answer->sender->answerbox); |
|
117 | } |
157 | } |
118 | } |
158 | } |
119 | } |
159 | } |
120 | 160 | ||
121 | /****************************************************/ |
161 | /****************************************************/ |
Line 136... | Line 176... | ||
136 | static int process_request(answerbox_t *box,call_t *call) |
176 | static int process_request(answerbox_t *box,call_t *call) |
137 | { |
177 | { |
138 | int phoneid; |
178 | int phoneid; |
139 | 179 | ||
140 | if (IPC_GET_METHOD(call->data) == IPC_M_CONNECTTOME) { |
180 | if (IPC_GET_METHOD(call->data) == IPC_M_CONNECTTOME) { |
141 | phoneid = phone_alloc(&call->sender->answerbox); |
181 | phoneid = phone_alloc(); |
142 | if (phoneid < 0) { /* Failed to allocate phone */ |
182 | if (phoneid < 0) { /* Failed to allocate phone */ |
143 | IPC_SET_RETVAL(call->data, ELIMIT); |
183 | IPC_SET_RETVAL(call->data, ELIMIT); |
144 | ipc_answer(box,call); |
184 | ipc_answer(box,call); |
145 | return -1; |
185 | return -1; |
146 | } |
186 | } |
Line 160... | Line 200... | ||
160 | call_t call; |
200 | call_t call; |
161 | phone_t *phone; |
201 | phone_t *phone; |
162 | 202 | ||
163 | phone = get_phone(phoneid); |
203 | phone = get_phone(phoneid); |
164 | if (!phone) |
204 | if (!phone) |
165 | return IPC_CALLRET_FATAL; |
205 | return ENOENT; |
- | 206 | ||
- | 207 | if (is_system_method(method)) |
|
- | 208 | return EPERM; |
|
166 | 209 | ||
167 | ipc_call_init(&call); |
210 | ipc_call_init(&call); |
168 | IPC_SET_METHOD(call.data, method); |
211 | IPC_SET_METHOD(call.data, method); |
169 | IPC_SET_ARG1(call.data, arg1); |
212 | IPC_SET_ARG1(call.data, arg1); |
170 | 213 | ||
Line 182... | Line 225... | ||
182 | call_t call; |
225 | call_t call; |
183 | phone_t *phone; |
226 | phone_t *phone; |
184 | 227 | ||
185 | phone = get_phone(phoneid); |
228 | phone = get_phone(phoneid); |
186 | if (!phone) |
229 | if (!phone) |
187 | return IPC_CALLRET_FATAL; |
230 | return ENOENT; |
188 | 231 | ||
189 | ipc_call_init(&call); |
232 | ipc_call_init(&call); |
190 | copy_from_uspace(&call.data, question, sizeof(call.data)); |
233 | copy_from_uspace(&call.data, question, sizeof(call.data)); |
- | 234 | ||
- | 235 | if (is_system_method(IPC_GET_METHOD(call.data))) |
|
- | 236 | return EPERM; |
|
191 | 237 | ||
192 | ipc_call_sync(phone, &call); |
238 | ipc_call_sync(phone, &call); |
193 | 239 | ||
194 | copy_to_uspace(reply, &call.data, sizeof(call.data)); |
240 | copy_to_uspace(reply, &call.data, sizeof(call.data)); |
195 | 241 | ||
Line 222... | Line 268... | ||
222 | 268 | ||
223 | phone = get_phone(phoneid); |
269 | phone = get_phone(phoneid); |
224 | if (!phone) |
270 | if (!phone) |
225 | return IPC_CALLRET_FATAL; |
271 | return IPC_CALLRET_FATAL; |
226 | 272 | ||
- | 273 | if (is_system_method(method)) |
|
- | 274 | return IPC_CALLRET_FATAL; |
|
- | 275 | ||
227 | if (check_call_limit()) |
276 | if (check_call_limit()) |
228 | return IPC_CALLRET_TEMPORARY; |
277 | return IPC_CALLRET_TEMPORARY; |
229 | 278 | ||
230 | call = ipc_call_alloc(); |
279 | call = ipc_call_alloc(); |
231 | IPC_SET_METHOD(call->data, method); |
280 | IPC_SET_METHOD(call->data, method); |
Line 253... | Line 302... | ||
253 | if (check_call_limit()) |
302 | if (check_call_limit()) |
254 | return IPC_CALLRET_TEMPORARY; |
303 | return IPC_CALLRET_TEMPORARY; |
255 | 304 | ||
256 | call = ipc_call_alloc(); |
305 | call = ipc_call_alloc(); |
257 | copy_from_uspace(&call->data, data, sizeof(call->data)); |
306 | copy_from_uspace(&call->data, data, sizeof(call->data)); |
- | 307 | ||
- | 308 | if (is_system_method(IPC_GET_METHOD(call->data))) { |
|
- | 309 | ipc_call_free(call); |
|
- | 310 | return EPERM; |
|
- | 311 | } |
|
258 | 312 | ||
259 | ipc_call(phone, call); |
313 | ipc_call(phone, call); |
260 | 314 | ||
261 | return (__native) call; |
315 | return (__native) call; |
262 | } |
316 | } |
263 | 317 | ||
- | 318 | /** Forward received call to another destination |
|
- | 319 | * |
|
- | 320 | * The arg1 and arg2 are changed in the forwarded message |
|
- | 321 | */ |
|
- | 322 | __native sys_ipc_forward_fast(__native callid, __native phoneid, |
|
- | 323 | __native method, __native arg1) |
|
- | 324 | { |
|
- | 325 | call_t *call; |
|
- | 326 | phone_t *phone; |
|
- | 327 | ||
- | 328 | call = get_call(callid); |
|
- | 329 | if (!call) |
|
- | 330 | return ENOENT; |
|
- | 331 | ||
- | 332 | phone = get_phone(phoneid); |
|
- | 333 | if (!phone) { |
|
- | 334 | IPC_SET_RETVAL(call->data, EFORWARD); |
|
- | 335 | ipc_answer(&TASK->answerbox, call); |
|
- | 336 | return ENOENT; |
|
- | 337 | } |
|
- | 338 | ||
- | 339 | if (!is_forwardable(IPC_GET_METHOD(call->data))) { |
|
- | 340 | IPC_SET_RETVAL(call->data, EFORWARD); |
|
- | 341 | ipc_answer(&TASK->answerbox, call); |
|
- | 342 | return EPERM; |
|
- | 343 | } |
|
- | 344 | ||
- | 345 | /* Userspace is not allowed to change method of system methods |
|
- | 346 | * on forward, allow changing ARG1 and ARG2 by means of method and arg1 |
|
- | 347 | */ |
|
- | 348 | if (is_system_method(IPC_GET_METHOD(call->data))) { |
|
- | 349 | IPC_SET_ARG1(call->data, method); |
|
- | 350 | IPC_SET_ARG2(call->data, arg1); |
|
- | 351 | } else { |
|
- | 352 | IPC_SET_METHOD(call->data, method); |
|
- | 353 | IPC_SET_ARG1(call->data, arg1); |
|
- | 354 | } |
|
- | 355 | ||
- | 356 | ipc_forward(call, phone->callee, &TASK->answerbox); |
|
- | 357 | ||
- | 358 | return 0; |
|
- | 359 | } |
|
- | 360 | ||
264 | /** Send IPC answer */ |
361 | /** Send IPC answer */ |
265 | __native sys_ipc_answer_fast(__native callid, __native retval, |
362 | __native sys_ipc_answer_fast(__native callid, __native retval, |
266 | __native arg1, __native arg2) |
363 | __native arg1, __native arg2) |
267 | { |
364 | { |
268 | call_t *call; |
365 | call_t *call; |
269 | call_t saved_call; |
366 | ipc_data_t saved_data; |
270 | int preprocess = 0; |
367 | int preprocess = 0; |
271 | 368 | ||
272 | /* Check that the user is not sending us answer callid */ |
369 | call = get_call(callid); |
273 | ASSERT(! (callid & 1)); |
370 | if (!call) |
274 | /* TODO: Check that the callid is in the dispatch table */ |
- | |
275 | call = (call_t *) callid; |
371 | return ENOENT; |
276 | 372 | ||
277 | if (answer_will_preprocess(call)) { |
373 | if (answer_will_preprocess(call)) { |
278 | memcpy(&saved_call.data, &call->data, sizeof(call->data)); |
374 | memcpy(&saved_data, &call->data, sizeof(call->data)); |
279 | preprocess = 1; |
375 | preprocess = 1; |
280 | } |
376 | } |
281 | 377 | ||
282 | IPC_SET_RETVAL(call->data, retval); |
378 | IPC_SET_RETVAL(call->data, retval); |
283 | IPC_SET_ARG1(call->data, arg1); |
379 | IPC_SET_ARG1(call->data, arg1); |
284 | IPC_SET_ARG2(call->data, arg2); |
380 | IPC_SET_ARG2(call->data, arg2); |
- | 381 | ||
285 | if (preprocess) |
382 | if (preprocess) |
286 | answer_preprocess(call, &saved_call); |
383 | answer_preprocess(call, &saved_data); |
287 | 384 | ||
288 | ipc_answer(&TASK->answerbox, call); |
385 | ipc_answer(&TASK->answerbox, call); |
289 | return 0; |
386 | return 0; |
290 | } |
387 | } |
291 | 388 | ||
292 | /** Send IPC answer */ |
389 | /** Send IPC answer */ |
293 | inline __native sys_ipc_answer(__native callid, __native *data) |
390 | inline __native sys_ipc_answer(__native callid, __native *data) |
294 | { |
391 | { |
295 | call_t *call; |
392 | call_t *call; |
296 | call_t saved_call; |
393 | ipc_data_t saved_data; |
297 | int preprocess = 0; |
394 | int preprocess = 0; |
298 | 395 | ||
299 | /* Check that the user is not sending us answer callid */ |
396 | call = get_call(callid); |
300 | ASSERT(! (callid & 1)); |
397 | if (!call) |
301 | /* TODO: Check that the callid is in the dispatch table */ |
- | |
302 | call = (call_t *) callid; |
398 | return ENOENT; |
303 | 399 | ||
304 | if (answer_will_preprocess(call)) { |
400 | if (answer_will_preprocess(call)) { |
305 | memcpy(&saved_call.data, &call->data, sizeof(call->data)); |
401 | memcpy(&saved_data, &call->data, sizeof(call->data)); |
306 | preprocess = 1; |
402 | preprocess = 1; |
307 | } |
403 | } |
308 | copy_from_uspace(&call->data, data, sizeof(call->data)); |
404 | copy_from_uspace(&call->data, data, sizeof(call->data)); |
309 | 405 | ||
310 | if (preprocess) |
406 | if (preprocess) |
311 | answer_preprocess(call, &saved_call); |
407 | answer_preprocess(call, &saved_data); |
312 | 408 | ||
313 | ipc_answer(&TASK->answerbox, call); |
409 | ipc_answer(&TASK->answerbox, call); |
314 | 410 | ||
315 | return 0; |
411 | return 0; |
316 | } |
412 | } |
Line 325... | Line 421... | ||
325 | call_t call; |
421 | call_t call; |
326 | phone_t *phone; |
422 | phone_t *phone; |
327 | 423 | ||
328 | phone = get_phone(phoneid); |
424 | phone = get_phone(phoneid); |
329 | if (!phone) |
425 | if (!phone) |
330 | return IPC_CALLRET_FATAL; |
426 | return ENOENT; |
331 | 427 | ||
332 | ipc_call_init(&call); |
428 | ipc_call_init(&call); |
333 | IPC_SET_METHOD(call.data, IPC_M_CONNECTTOME); |
429 | IPC_SET_METHOD(call.data, IPC_M_CONNECTTOME); |
334 | IPC_SET_ARG1(call.data, arg1); |
430 | IPC_SET_ARG1(call.data, arg1); |
335 | IPC_SET_ARG2(call.data, arg2); |
431 | IPC_SET_ARG2(call.data, arg2); |
Line 341... | Line 437... | ||
341 | &phone->callee->task->taskid, |
437 | &phone->callee->task->taskid, |
342 | sizeof(TASK->taskid)); |
438 | sizeof(TASK->taskid)); |
343 | return IPC_GET_RETVAL(call.data); |
439 | return IPC_GET_RETVAL(call.data); |
344 | } |
440 | } |
345 | 441 | ||
- | 442 | /** Ask target process to connect me somewhere |
|
- | 443 | * |
|
- | 444 | * @return phoneid - on success, error otherwise |
|
- | 445 | */ |
|
- | 446 | __native sys_ipc_connect_me_to(__native phoneid, __native arg1, |
|
- | 447 | __native arg2) |
|
- | 448 | { |
|
- | 449 | call_t call; |
|
- | 450 | phone_t *phone; |
|
- | 451 | ||
- | 452 | phone = get_phone(phoneid); |
|
- | 453 | if (!phone) |
|
- | 454 | return ENOENT; |
|
- | 455 | ||
- | 456 | ipc_call_init(&call); |
|
- | 457 | IPC_SET_METHOD(call.data, IPC_M_CONNECTMETO); |
|
- | 458 | IPC_SET_ARG1(call.data, arg1); |
|
- | 459 | IPC_SET_ARG2(call.data, arg2); |
|
- | 460 | ||
- | 461 | ipc_call_sync(phone, &call); |
|
- | 462 | if (!IPC_GET_RETVAL(call.data)) { |
|
- | 463 | /* Everybody accepted, we should be connected by now */ |
|
- | 464 | } |
|
- | 465 | ||
- | 466 | return 0; |
|
- | 467 | } |
|
- | 468 | ||
346 | /** Wait for incoming ipc call or answer |
469 | /** Wait for incoming ipc call or answer |
347 | * |
470 | * |
348 | * Generic function - can serve either as inkernel or userspace call |
471 | * Generic function - can serve either as inkernel or userspace call |
349 | * - inside kernel does probably unnecessary copying of data (TODO) |
472 | * - inside kernel does probably unnecessary copying of data (TODO) |
350 | * |
473 | * |
Line 360... | Line 483... | ||
360 | { |
483 | { |
361 | call_t *call; |
484 | call_t *call; |
362 | 485 | ||
363 | restart: |
486 | restart: |
364 | call = ipc_wait_for_call(&TASK->answerbox, flags); |
487 | call = ipc_wait_for_call(&TASK->answerbox, flags); |
- | 488 | printf("Received call %P from sender: %P\n", call, call->sender); |
|
365 | 489 | ||
366 | if (call->flags & IPC_CALL_ANSWERED) { |
490 | if (call->flags & IPC_CALL_ANSWERED) { |
367 | if (process_answer(&TASK->answerbox, call)) |
491 | if (process_answer(&TASK->answerbox, call)) |
368 | goto restart; |
492 | goto restart; |
369 | 493 |