source: mainline/kernel/generic/src/ipc/sysipc.c@ 27fd651

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

Add IPC_M_CONNECTION_CLONE and IPC_M_CONNECT_ME.
  • Property mode set to 100644
File size: 30.3 KB
Line 
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/** @addtogroup genericipc
30 * @{
31 */
32/** @file
33 */
34
35#include <arch.h>
36#include <proc/task.h>
37#include <proc/thread.h>
38#include <errno.h>
39#include <memstr.h>
40#include <debug.h>
41#include <ipc/ipc.h>
42#include <ipc/sysipc.h>
43#include <ipc/irq.h>
44#include <ipc/ipcrsc.h>
45#include <ipc/kbox.h>
46#include <udebug/udebug_ipc.h>
47#include <arch/interrupt.h>
48#include <syscall/copy.h>
49#include <security/cap.h>
50#include <mm/as.h>
51#include <print.h>
52
53/**
54 * Maximum buffer size allowed for IPC_M_DATA_WRITE and IPC_M_DATA_READ
55 * requests.
56 */
57#define DATA_XFER_LIMIT (64 * 1024)
58
59#define GET_CHECK_PHONE(phone, phoneid, err) \
60{ \
61 if (phoneid > IPC_MAX_PHONES) { \
62 err; \
63 } \
64 phone = &TASK->phones[phoneid]; \
65}
66
67#define STRUCT_TO_USPACE(dst, src) copy_to_uspace(dst, src, sizeof(*(src)))
68
69/** Decide if the method is a system method.
70 *
71 * @param method Method to be decided.
72 *
73 * @return Return 1 if the method is a system method.
74 * Otherwise return 0.
75 */
76static inline int method_is_system(unative_t method)
77{
78 if (method <= IPC_M_LAST_SYSTEM)
79 return 1;
80 return 0;
81}
82
83/** Decide if the message with this method is forwardable.
84 *
85 * - some system messages may be forwarded, for some of them
86 * it is useless
87 *
88 * @param method Method to be decided.
89 *
90 * @return Return 1 if the method is forwardable.
91 * Otherwise return 0.
92 */
93static inline int method_is_forwardable(unative_t method)
94{
95 switch (method) {
96 case IPC_M_CONNECTION_CLONE:
97 case IPC_M_CONNECT_ME:
98 case IPC_M_PHONE_HUNGUP:
99 /* This message is meant only for the original recipient. */
100 return 0;
101 default:
102 return 1;
103 }
104}
105
106/** Decide if the message with this method is immutable on forward.
107 *
108 * - some system messages may be forwarded but their content cannot be altered
109 *
110 * @param method Method to be decided.
111 *
112 * @return Return 1 if the method is immutable on forward.
113 * Otherwise return 0.
114 */
115static inline int method_is_immutable(unative_t method)
116{
117 switch (method) {
118 case IPC_M_SHARE_OUT:
119 case IPC_M_SHARE_IN:
120 case IPC_M_DATA_WRITE:
121 case IPC_M_DATA_READ:
122 return 1;
123 break;
124 default:
125 return 0;
126 }
127}
128
129
130/***********************************************************************
131 * Functions that preprocess answer before sending it to the recepient.
132 ***********************************************************************/
133
134/** Decide if the caller (e.g. ipc_answer()) should save the old call contents
135 * for answer_preprocess().
136 *
137 * @param call Call structure to be decided.
138 *
139 * @return Return 1 if the old call contents should be saved.
140 * Return 0 otherwise.
141 */
142static inline int answer_need_old(call_t *call)
143{
144 switch (IPC_GET_METHOD(call->data)) {
145 case IPC_M_CONNECTION_CLONE:
146 case IPC_M_CONNECT_ME:
147 case IPC_M_CONNECT_TO_ME:
148 case IPC_M_CONNECT_ME_TO:
149 case IPC_M_SHARE_OUT:
150 case IPC_M_SHARE_IN:
151 case IPC_M_DATA_WRITE:
152 case IPC_M_DATA_READ:
153 return 1;
154 default:
155 return 0;
156 }
157}
158
159/** Interpret process answer as control information.
160 *
161 * This function is called directly after sys_ipc_answer().
162 *
163 * @param answer Call structure with the answer.
164 * @param olddata Saved data of the request.
165 *
166 * @return Return 0 on success or an error code.
167 */
168static inline int answer_preprocess(call_t *answer, ipc_data_t *olddata)
169{
170 int phoneid;
171
172 if ((native_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {
173 /* In case of forward, hangup the forwared phone,
174 * not the originator
175 */
176 mutex_lock(&answer->data.phone->lock);
177 spinlock_lock(&TASK->answerbox.lock);
178 if (answer->data.phone->state == IPC_PHONE_CONNECTED) {
179 list_remove(&answer->data.phone->link);
180 answer->data.phone->state = IPC_PHONE_SLAMMED;
181 }
182 spinlock_unlock(&TASK->answerbox.lock);
183 mutex_unlock(&answer->data.phone->lock);
184 }
185
186 if (!olddata)
187 return 0;
188
189 if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECTION_CLONE) {
190 phoneid = IPC_GET_ARG1(*olddata);
191 phone_t *phone = &TASK->phones[phoneid];
192 if (IPC_GET_RETVAL(answer->data) != EOK) {
193 /*
194 * The recipient of the cloned phone rejected the offer.
195 * In this case, the connection was established at the
196 * request time and therefore we need to slam the phone.
197 * We don't merely hangup as that would result in
198 * sending IPC_M_HUNGUP to the third party on the
199 * other side of the cloned phone.
200 */
201 mutex_lock(&phone->lock);
202 if (phone->state == IPC_PHONE_CONNECTED) {
203 spinlock_lock(&phone->callee->lock);
204 list_remove(&phone->link);
205 phone->state = IPC_PHONE_SLAMMED;
206 spinlock_unlock(&phone->callee->lock);
207 }
208 mutex_unlock(&phone->lock);
209 }
210 } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME) {
211 phone_t *phone = (phone_t *)IPC_GET_ARG5(*olddata);
212 if (IPC_GET_RETVAL(answer->data) != EOK) {
213 /*
214 * The other party on the cloned phoned rejected our
215 * request for connection on the protocol level.
216 * We need to break the connection without sending
217 * IPC_M_HUNGUP back.
218 */
219 mutex_lock(&phone->lock);
220 if (phone->state == IPC_PHONE_CONNECTED) {
221 spinlock_lock(&phone->callee->lock);
222 list_remove(&phone->link);
223 phone->state = IPC_PHONE_SLAMMED;
224 spinlock_unlock(&phone->callee->lock);
225 }
226 mutex_unlock(&phone->lock);
227 }
228 } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
229 phoneid = IPC_GET_ARG5(*olddata);
230 if (IPC_GET_RETVAL(answer->data) != EOK) {
231 /* The connection was not accepted */
232 phone_dealloc(phoneid);
233 } else {
234 /* The connection was accepted */
235 phone_connect(phoneid, &answer->sender->answerbox);
236 /* Set 'phone hash' as arg5 of response */
237 IPC_SET_ARG5(answer->data,
238 (unative_t) &TASK->phones[phoneid]);
239 }
240 } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
241 /* If the users accepted call, connect */
242 if (IPC_GET_RETVAL(answer->data) == EOK) {
243 ipc_phone_connect((phone_t *) IPC_GET_ARG5(*olddata),
244 &TASK->answerbox);
245 }
246 } else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_OUT) {
247 if (!IPC_GET_RETVAL(answer->data)) {
248 /* Accepted, handle as_area receipt */
249 ipl_t ipl;
250 int rc;
251 as_t *as;
252
253 ipl = interrupts_disable();
254 spinlock_lock(&answer->sender->lock);
255 as = answer->sender->as;
256 spinlock_unlock(&answer->sender->lock);
257 interrupts_restore(ipl);
258
259 rc = as_area_share(as, IPC_GET_ARG1(*olddata),
260 IPC_GET_ARG2(*olddata), AS,
261 IPC_GET_ARG1(answer->data), IPC_GET_ARG3(*olddata));
262 IPC_SET_RETVAL(answer->data, rc);
263 return rc;
264 }
265 } else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_IN) {
266 if (!IPC_GET_RETVAL(answer->data)) {
267 ipl_t ipl;
268 as_t *as;
269 int rc;
270
271 ipl = interrupts_disable();
272 spinlock_lock(&answer->sender->lock);
273 as = answer->sender->as;
274 spinlock_unlock(&answer->sender->lock);
275 interrupts_restore(ipl);
276
277 rc = as_area_share(AS, IPC_GET_ARG1(answer->data),
278 IPC_GET_ARG2(*olddata), as, IPC_GET_ARG1(*olddata),
279 IPC_GET_ARG2(answer->data));
280 IPC_SET_RETVAL(answer->data, rc);
281 }
282 } else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_READ) {
283 ASSERT(!answer->buffer);
284 if (!IPC_GET_RETVAL(answer->data)) {
285 /* The recipient agreed to send data. */
286 uintptr_t src = IPC_GET_ARG1(answer->data);
287 uintptr_t dst = IPC_GET_ARG1(*olddata);
288 size_t max_size = IPC_GET_ARG2(*olddata);
289 size_t size = IPC_GET_ARG2(answer->data);
290 if (size && size <= max_size) {
291 /*
292 * Copy the destination VA so that this piece of
293 * information is not lost.
294 */
295 IPC_SET_ARG1(answer->data, dst);
296
297 answer->buffer = malloc(size, 0);
298 int rc = copy_from_uspace(answer->buffer,
299 (void *) src, size);
300 if (rc) {
301 IPC_SET_RETVAL(answer->data, rc);
302 free(answer->buffer);
303 answer->buffer = NULL;
304 }
305 } else if (!size) {
306 IPC_SET_RETVAL(answer->data, EOK);
307 } else {
308 IPC_SET_RETVAL(answer->data, ELIMIT);
309 }
310 }
311 } else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_WRITE) {
312 ASSERT(answer->buffer);
313 if (!IPC_GET_RETVAL(answer->data)) {
314 /* The recipient agreed to receive data. */
315 int rc;
316 uintptr_t dst;
317 size_t size;
318 size_t max_size;
319
320 dst = (uintptr_t)IPC_GET_ARG1(answer->data);
321 size = (size_t)IPC_GET_ARG2(answer->data);
322 max_size = (size_t)IPC_GET_ARG2(*olddata);
323
324 if (size <= max_size) {
325 rc = copy_to_uspace((void *) dst,
326 answer->buffer, size);
327 if (rc)
328 IPC_SET_RETVAL(answer->data, rc);
329 } else {
330 IPC_SET_RETVAL(answer->data, ELIMIT);
331 }
332 }
333 free(answer->buffer);
334 answer->buffer = NULL;
335 }
336 return 0;
337}
338
339/** Called before the request is sent.
340 *
341 * @param call Call structure with the request.
342 * @param phone Phone that the call will be sent through.
343 *
344 * @return Return 0 on success, ELIMIT or EPERM on error.
345 */
346static int request_preprocess(call_t *call, phone_t *phone)
347{
348 int newphid;
349 size_t size;
350 uintptr_t src;
351 int rc;
352
353 switch (IPC_GET_METHOD(call->data)) {
354 case IPC_M_CONNECTION_CLONE: {
355 phone_t *cloned_phone;
356 GET_CHECK_PHONE(cloned_phone, IPC_GET_ARG1(call->data),
357 return ENOENT);
358 if (cloned_phone < phone) {
359 mutex_lock(&cloned_phone->lock);
360 mutex_lock(&phone->lock);
361 } else {
362 mutex_lock(&phone->lock);
363 mutex_lock(&cloned_phone->lock);
364 }
365 if ((cloned_phone->state != IPC_PHONE_CONNECTED) ||
366 phone->state != IPC_PHONE_CONNECTED) {
367 mutex_unlock(&cloned_phone->lock);
368 mutex_unlock(&phone->lock);
369 return EINVAL;
370 }
371 /*
372 * We can be pretty sure now that both tasks exist and we are
373 * connected to them. As we continue to hold the phone locks,
374 * we are effectively preventing them from finishing their
375 * potential cleanup.
376 */
377 newphid = phone_alloc(phone->callee->task);
378 if (newphid < 0) {
379 mutex_unlock(&cloned_phone->lock);
380 mutex_unlock(&phone->lock);
381 return ELIMIT;
382 }
383 ipc_phone_connect(&phone->callee->task->phones[newphid],
384 cloned_phone->callee);
385 mutex_unlock(&cloned_phone->lock);
386 mutex_unlock(&phone->lock);
387 /* Set the new phone for the callee. */
388 IPC_SET_ARG1(call->data, newphid);
389 break;
390 }
391 case IPC_M_CONNECT_ME:
392 IPC_SET_ARG5(call->data, (unative_t) phone);
393 break;
394 case IPC_M_CONNECT_ME_TO:
395 newphid = phone_alloc(TASK);
396 if (newphid < 0)
397 return ELIMIT;
398 /* Set arg5 for server */
399 IPC_SET_ARG5(call->data, (unative_t) &TASK->phones[newphid]);
400 call->flags |= IPC_CALL_CONN_ME_TO;
401 call->priv = newphid;
402 break;
403 case IPC_M_SHARE_OUT:
404 size = as_area_get_size(IPC_GET_ARG1(call->data));
405 if (!size)
406 return EPERM;
407 IPC_SET_ARG2(call->data, size);
408 break;
409 case IPC_M_DATA_READ:
410 size = IPC_GET_ARG2(call->data);
411 if ((size <= 0 || (size > DATA_XFER_LIMIT)))
412 return ELIMIT;
413 break;
414 case IPC_M_DATA_WRITE:
415 src = IPC_GET_ARG1(call->data);
416 size = IPC_GET_ARG2(call->data);
417
418 if (size > DATA_XFER_LIMIT)
419 return ELIMIT;
420
421 call->buffer = (uint8_t *) malloc(size, 0);
422 rc = copy_from_uspace(call->buffer, (void *) src, size);
423 if (rc != 0) {
424 free(call->buffer);
425 return rc;
426 }
427 break;
428#ifdef CONFIG_UDEBUG
429 case IPC_M_DEBUG_ALL:
430 return udebug_request_preprocess(call, phone);
431#endif
432 default:
433 break;
434 }
435 return 0;
436}
437
438/*******************************************************************************
439 * Functions called to process received call/answer before passing it to uspace.
440 *******************************************************************************/
441
442/** Do basic kernel processing of received call answer.
443 *
444 * @param call Call structure with the answer.
445 */
446static void process_answer(call_t *call)
447{
448 if (((native_t) IPC_GET_RETVAL(call->data) == EHANGUP) &&
449 (call->flags & IPC_CALL_FORWARDED))
450 IPC_SET_RETVAL(call->data, EFORWARD);
451
452 if (call->flags & IPC_CALL_CONN_ME_TO) {
453 if (IPC_GET_RETVAL(call->data))
454 phone_dealloc(call->priv);
455 else
456 IPC_SET_ARG5(call->data, call->priv);
457 }
458
459 if (call->buffer) {
460 /* This must be an affirmative answer to IPC_M_DATA_READ. */
461 /* or IPC_M_DEBUG_ALL/UDEBUG_M_MEM_READ... */
462 uintptr_t dst = IPC_GET_ARG1(call->data);
463 size_t size = IPC_GET_ARG2(call->data);
464 int rc = copy_to_uspace((void *) dst, call->buffer, size);
465 if (rc)
466 IPC_SET_RETVAL(call->data, rc);
467 free(call->buffer);
468 call->buffer = NULL;
469 }
470}
471
472/** Do basic kernel processing of received call request.
473 *
474 * @param box Destination answerbox structure.
475 * @param call Call structure with the request.
476 *
477 * @return Return 0 if the call should be passed to userspace.
478 * Return -1 if the call should be ignored.
479 */
480static int process_request(answerbox_t *box, call_t *call)
481{
482 int phoneid;
483
484 if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME) {
485 phoneid = phone_alloc(TASK);
486 if (phoneid < 0) { /* Failed to allocate phone */
487 IPC_SET_RETVAL(call->data, ELIMIT);
488 ipc_answer(box, call);
489 return -1;
490 }
491 IPC_SET_ARG5(call->data, phoneid);
492 }
493 switch (IPC_GET_METHOD(call->data)) {
494 case IPC_M_DEBUG_ALL:
495 return -1;
496 default:
497 break;
498 }
499 return 0;
500}
501
502/** Make a fast call over IPC, wait for reply and return to user.
503 *
504 * This function can handle only three arguments of payload, but is faster than
505 * the generic function (i.e. sys_ipc_call_sync_slow()).
506 *
507 * @param phoneid Phone handle for the call.
508 * @param method Method of the call.
509 * @param arg1 Service-defined payload argument.
510 * @param arg2 Service-defined payload argument.
511 * @param arg3 Service-defined payload argument.
512 * @param data Address of userspace structure where the reply call will
513 * be stored.
514 *
515 * @return Returns 0 on success.
516 * Return ENOENT if there is no such phone handle.
517 */
518unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
519 unative_t arg1, unative_t arg2, unative_t arg3, ipc_data_t *data)
520{
521 call_t call;
522 phone_t *phone;
523 int res;
524 int rc;
525
526 GET_CHECK_PHONE(phone, phoneid, return ENOENT);
527
528 ipc_call_static_init(&call);
529 IPC_SET_METHOD(call.data, method);
530 IPC_SET_ARG1(call.data, arg1);
531 IPC_SET_ARG2(call.data, arg2);
532 IPC_SET_ARG3(call.data, arg3);
533 /*
534 * To achieve deterministic behavior, zero out arguments that are beyond
535 * the limits of the fast version.
536 */
537 IPC_SET_ARG4(call.data, 0);
538 IPC_SET_ARG5(call.data, 0);
539
540 if (!(res = request_preprocess(&call, phone))) {
541#ifdef CONFIG_UDEBUG
542 udebug_stoppable_begin();
543#endif
544 rc = ipc_call_sync(phone, &call);
545#ifdef CONFIG_UDEBUG
546 udebug_stoppable_end();
547#endif
548 if (rc != EOK)
549 return rc;
550 process_answer(&call);
551
552 } else {
553 IPC_SET_RETVAL(call.data, res);
554 }
555 rc = STRUCT_TO_USPACE(&data->args, &call.data.args);
556 if (rc != 0)
557 return rc;
558
559 return 0;
560}
561
562/** Make a synchronous IPC call allowing to transmit the entire payload.
563 *
564 * @param phoneid Phone handle for the call.
565 * @param question Userspace address of call data with the request.
566 * @param reply Userspace address of call data where to store the
567 * answer.
568 *
569 * @return Zero on success or an error code.
570 */
571unative_t sys_ipc_call_sync_slow(unative_t phoneid, ipc_data_t *question,
572 ipc_data_t *reply)
573{
574 call_t call;
575 phone_t *phone;
576 int res;
577 int rc;
578
579 ipc_call_static_init(&call);
580 rc = copy_from_uspace(&call.data.args, &question->args,
581 sizeof(call.data.args));
582 if (rc != 0)
583 return (unative_t) rc;
584
585 GET_CHECK_PHONE(phone, phoneid, return ENOENT);
586
587 if (!(res = request_preprocess(&call, phone))) {
588#ifdef CONFIG_UDEBUG
589 udebug_stoppable_begin();
590#endif
591 rc = ipc_call_sync(phone, &call);
592#ifdef CONFIG_UDEBUG
593 udebug_stoppable_end();
594#endif
595 if (rc != EOK)
596 return rc;
597 process_answer(&call);
598 } else
599 IPC_SET_RETVAL(call.data, res);
600
601 rc = STRUCT_TO_USPACE(&reply->args, &call.data.args);
602 if (rc != 0)
603 return rc;
604
605 return 0;
606}
607
608/** Check that the task did not exceed the allowed limit of asynchronous calls.
609 *
610 * @return Return 0 if limit not reached or -1 if limit exceeded.
611 */
612static int check_call_limit(void)
613{
614 if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
615 atomic_dec(&TASK->active_calls);
616 return -1;
617 }
618 return 0;
619}
620
621/** Make a fast asynchronous call over IPC.
622 *
623 * This function can only handle four arguments of payload, but is faster than
624 * the generic function sys_ipc_call_async_slow().
625 *
626 * @param phoneid Phone handle for the call.
627 * @param method Method of the call.
628 * @param arg1 Service-defined payload argument.
629 * @param arg2 Service-defined payload argument.
630 * @param arg3 Service-defined payload argument.
631 * @param arg4 Service-defined payload argument.
632 *
633 * @return Return call hash on success.
634 * Return IPC_CALLRET_FATAL in case of a fatal error and
635 * IPC_CALLRET_TEMPORARY if there are too many pending
636 * asynchronous requests; answers should be handled first.
637 */
638unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
639 unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
640{
641 call_t *call;
642 phone_t *phone;
643 int res;
644
645 if (check_call_limit())
646 return IPC_CALLRET_TEMPORARY;
647
648 GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
649
650 call = ipc_call_alloc(0);
651 IPC_SET_METHOD(call->data, method);
652 IPC_SET_ARG1(call->data, arg1);
653 IPC_SET_ARG2(call->data, arg2);
654 IPC_SET_ARG3(call->data, arg3);
655 IPC_SET_ARG4(call->data, arg4);
656 /*
657 * To achieve deterministic behavior, zero out arguments that are beyond
658 * the limits of the fast version.
659 */
660 IPC_SET_ARG5(call->data, 0);
661
662 if (!(res = request_preprocess(call, phone)))
663 ipc_call(phone, call);
664 else
665 ipc_backsend_err(phone, call, res);
666
667 return (unative_t) call;
668}
669
670/** Make an asynchronous IPC call allowing to transmit the entire payload.
671 *
672 * @param phoneid Phone handle for the call.
673 * @param data Userspace address of call data with the request.
674 *
675 * @return See sys_ipc_call_async_fast().
676 */
677unative_t sys_ipc_call_async_slow(unative_t phoneid, ipc_data_t *data)
678{
679 call_t *call;
680 phone_t *phone;
681 int res;
682 int rc;
683
684 if (check_call_limit())
685 return IPC_CALLRET_TEMPORARY;
686
687 GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
688
689 call = ipc_call_alloc(0);
690 rc = copy_from_uspace(&call->data.args, &data->args,
691 sizeof(call->data.args));
692 if (rc != 0) {
693 ipc_call_free(call);
694 return (unative_t) rc;
695 }
696 if (!(res = request_preprocess(call, phone)))
697 ipc_call(phone, call);
698 else
699 ipc_backsend_err(phone, call, res);
700
701 return (unative_t) call;
702}
703
704/** Forward a received call to another destination - common code for both the
705 * fast and the slow version.
706 *
707 * @param callid Hash of the call to forward.
708 * @param phoneid Phone handle to use for forwarding.
709 * @param method New method to use for the forwarded call.
710 * @param arg1 New value of the first argument for the forwarded call.
711 * @param arg2 New value of the second argument for the forwarded call.
712 * @param arg3 New value of the third argument for the forwarded call.
713 * @param arg4 New value of the fourth argument for the forwarded call.
714 * @param arg5 New value of the fifth argument for the forwarded call.
715 * @param mode Flags that specify mode of the forward operation.
716 * @param slow If true, arg3, arg4 and arg5 are considered. Otherwise
717 * the function considers only the fast version arguments:
718 * i.e. arg1 and arg2.
719 *
720 * @return Return 0 on succes, otherwise return an error code.
721 *
722 * Warning: Make sure that ARG5 is not rewritten for certain system IPC
723 */
724static unative_t sys_ipc_forward_common(unative_t callid, unative_t phoneid,
725 unative_t method, unative_t arg1, unative_t arg2, unative_t arg3,
726 unative_t arg4, unative_t arg5, int mode, bool slow)
727{
728 call_t *call;
729 phone_t *phone;
730
731 call = get_call(callid);
732 if (!call)
733 return ENOENT;
734
735 call->flags |= IPC_CALL_FORWARDED;
736
737 GET_CHECK_PHONE(phone, phoneid, {
738 IPC_SET_RETVAL(call->data, EFORWARD);
739 ipc_answer(&TASK->answerbox, call);
740 return ENOENT;
741 });
742
743 if (!method_is_forwardable(IPC_GET_METHOD(call->data))) {
744 IPC_SET_RETVAL(call->data, EFORWARD);
745 ipc_answer(&TASK->answerbox, call);
746 return EPERM;
747 }
748
749 /*
750 * Userspace is not allowed to change method of system methods on
751 * forward, allow changing ARG1, ARG2, ARG3 and ARG4 by means of method,
752 * arg1, arg2 and arg3.
753 * If the method is immutable, don't change anything.
754 */
755 if (!method_is_immutable(IPC_GET_METHOD(call->data))) {
756 if (method_is_system(IPC_GET_METHOD(call->data))) {
757 if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
758 phone_dealloc(IPC_GET_ARG5(call->data));
759
760 IPC_SET_ARG1(call->data, method);
761 IPC_SET_ARG2(call->data, arg1);
762 IPC_SET_ARG3(call->data, arg2);
763 if (slow) {
764 IPC_SET_ARG4(call->data, arg3);
765 /*
766 * For system methods we deliberately don't
767 * overwrite ARG5.
768 */
769 }
770 } else {
771 IPC_SET_METHOD(call->data, method);
772 IPC_SET_ARG1(call->data, arg1);
773 IPC_SET_ARG2(call->data, arg2);
774 if (slow) {
775 IPC_SET_ARG3(call->data, arg3);
776 IPC_SET_ARG4(call->data, arg4);
777 IPC_SET_ARG5(call->data, arg5);
778 }
779 }
780 }
781
782 return ipc_forward(call, phone, &TASK->answerbox, mode);
783}
784
785/** Forward a received call to another destination - fast version.
786 *
787 * @param callid Hash of the call to forward.
788 * @param phoneid Phone handle to use for forwarding.
789 * @param method New method to use for the forwarded call.
790 * @param arg1 New value of the first argument for the forwarded call.
791 * @param arg2 New value of the second argument for the forwarded call.
792 * @param mode Flags that specify mode of the forward operation.
793 *
794 * @return Return 0 on succes, otherwise return an error code.
795 *
796 * In case the original method is a system method, ARG1, ARG2 and ARG3 are
797 * overwritten in the forwarded message with the new method and the new
798 * arg1 and arg2, respectively. Otherwise the METHOD, ARG1 and ARG2 are
799 * rewritten with the new method, arg1 and arg2, respectively. Also note there
800 * is a set of immutable methods, for which the new method and arguments are not
801 * set and these values are ignored.
802 */
803unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
804 unative_t method, unative_t arg1, unative_t arg2, int mode)
805{
806 return sys_ipc_forward_common(callid, phoneid, method, arg1, arg2, 0, 0,
807 0, mode, false);
808}
809
810/** Forward a received call to another destination - slow version.
811 *
812 * @param callid Hash of the call to forward.
813 * @param phoneid Phone handle to use for forwarding.
814 * @param data Userspace address of the new IPC data.
815 * @param mode Flags that specify mode of the forward operation.
816 *
817 * @return Return 0 on succes, otherwise return an error code.
818 *
819 * This function is the slow verision of the sys_ipc_forward_fast interface.
820 * It can copy all five new arguments and the new method from the userspace.
821 * It naturally extends the functionality of the fast version. For system
822 * methods, it additionally stores the new value of arg3 to ARG4. For non-system
823 * methods, it additionally stores the new value of arg3, arg4 and arg5,
824 * respectively, to ARG3, ARG4 and ARG5, respectively.
825 */
826unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,
827 ipc_data_t *data, int mode)
828{
829 ipc_data_t newdata;
830 int rc;
831
832 rc = copy_from_uspace(&newdata.args, &data->args,
833 sizeof(newdata.args));
834 if (rc != 0)
835 return (unative_t) rc;
836
837 return sys_ipc_forward_common(callid, phoneid,
838 IPC_GET_METHOD(newdata), IPC_GET_ARG1(newdata),
839 IPC_GET_ARG2(newdata), IPC_GET_ARG3(newdata),
840 IPC_GET_ARG4(newdata), IPC_GET_ARG5(newdata), mode, true);
841}
842
843/** Answer an IPC call - fast version.
844 *
845 * This function can handle only two return arguments of payload, but is faster
846 * than the generic sys_ipc_answer().
847 *
848 * @param callid Hash of the call to be answered.
849 * @param retval Return value of the answer.
850 * @param arg1 Service-defined return value.
851 * @param arg2 Service-defined return value.
852 * @param arg3 Service-defined return value.
853 * @param arg4 Service-defined return value.
854 *
855 * @return Return 0 on success, otherwise return an error code.
856 */
857unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
858 unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
859{
860 call_t *call;
861 ipc_data_t saved_data;
862 int saveddata = 0;
863 int rc;
864
865 /* Do not answer notification callids */
866 if (callid & IPC_CALLID_NOTIFICATION)
867 return 0;
868
869 call = get_call(callid);
870 if (!call)
871 return ENOENT;
872
873 if (answer_need_old(call)) {
874 memcpy(&saved_data, &call->data, sizeof(call->data));
875 saveddata = 1;
876 }
877
878 IPC_SET_RETVAL(call->data, retval);
879 IPC_SET_ARG1(call->data, arg1);
880 IPC_SET_ARG2(call->data, arg2);
881 IPC_SET_ARG3(call->data, arg3);
882 IPC_SET_ARG4(call->data, arg4);
883 /*
884 * To achieve deterministic behavior, zero out arguments that are beyond
885 * the limits of the fast version.
886 */
887 IPC_SET_ARG5(call->data, 0);
888 rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
889
890 ipc_answer(&TASK->answerbox, call);
891 return rc;
892}
893
894/** Answer an IPC call.
895 *
896 * @param callid Hash of the call to be answered.
897 * @param data Userspace address of call data with the answer.
898 *
899 * @return Return 0 on success, otherwise return an error code.
900 */
901unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data)
902{
903 call_t *call;
904 ipc_data_t saved_data;
905 int saveddata = 0;
906 int rc;
907
908 /* Do not answer notification callids */
909 if (callid & IPC_CALLID_NOTIFICATION)
910 return 0;
911
912 call = get_call(callid);
913 if (!call)
914 return ENOENT;
915
916 if (answer_need_old(call)) {
917 memcpy(&saved_data, &call->data, sizeof(call->data));
918 saveddata = 1;
919 }
920 rc = copy_from_uspace(&call->data.args, &data->args,
921 sizeof(call->data.args));
922 if (rc != 0)
923 return rc;
924
925 rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
926
927 ipc_answer(&TASK->answerbox, call);
928
929 return rc;
930}
931
932/** Hang up a phone.
933 *
934 * @param Phone handle of the phone to be hung up.
935 *
936 * @return Return 0 on success or an error code.
937 */
938unative_t sys_ipc_hangup(int phoneid)
939{
940 phone_t *phone;
941
942 GET_CHECK_PHONE(phone, phoneid, return ENOENT);
943
944 if (ipc_phone_hangup(phone))
945 return -1;
946
947 return 0;
948}
949
950/** Wait for an incoming IPC call or an answer.
951 *
952 * @param calldata Pointer to buffer where the call/answer data is stored.
953 * @param usec Timeout. See waitq_sleep_timeout() for explanation.
954 * @param flags Select mode of sleep operation. See waitq_sleep_timeout()
955 * for explanation.
956 *
957 * @return Hash of the call.
958 * If IPC_CALLID_NOTIFICATION bit is set in the hash, the
959 * call is a notification. IPC_CALLID_ANSWERED denotes an
960 * answer.
961 */
962unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, int flags)
963{
964 call_t *call;
965
966restart:
967
968#ifdef CONFIG_UDEBUG
969 udebug_stoppable_begin();
970#endif
971 call = ipc_wait_for_call(&TASK->answerbox, usec,
972 flags | SYNCH_FLAGS_INTERRUPTIBLE);
973
974#ifdef CONFIG_UDEBUG
975 udebug_stoppable_end();
976#endif
977 if (!call)
978 return 0;
979
980 if (call->flags & IPC_CALL_NOTIF) {
981 ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
982
983 /* Set in_phone_hash to the interrupt counter */
984 call->data.phone = (void *) call->priv;
985
986 STRUCT_TO_USPACE(calldata, &call->data);
987
988 ipc_call_free(call);
989
990 return ((unative_t) call) | IPC_CALLID_NOTIFICATION;
991 }
992
993 if (call->flags & IPC_CALL_ANSWERED) {
994 process_answer(call);
995
996 ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
997
998 if (call->flags & IPC_CALL_DISCARD_ANSWER) {
999 ipc_call_free(call);
1000 goto restart;
1001 } else {
1002 /*
1003 * Decrement the counter of active calls only if the
1004 * call is not an answer to IPC_M_PHONE_HUNGUP,
1005 * which doesn't contribute to the counter.
1006 */
1007 atomic_dec(&TASK->active_calls);
1008 }
1009
1010 STRUCT_TO_USPACE(&calldata->args, &call->data.args);
1011 ipc_call_free(call);
1012
1013 return ((unative_t) call) | IPC_CALLID_ANSWERED;
1014 }
1015
1016 if (process_request(&TASK->answerbox, call))
1017 goto restart;
1018
1019 /* Include phone address('id') of the caller in the request,
1020 * copy whole call->data, not only call->data.args */
1021 if (STRUCT_TO_USPACE(calldata, &call->data)) {
1022 /*
1023 * The callee will not receive this call and no one else has
1024 * a chance to answer it. Reply with the EPARTY error code.
1025 */
1026 ipc_data_t saved_data;
1027 int saveddata = 0;
1028
1029 if (answer_need_old(call)) {
1030 memcpy(&saved_data, &call->data, sizeof(call->data));
1031 saveddata = 1;
1032 }
1033
1034 IPC_SET_RETVAL(call->data, EPARTY);
1035 (void) answer_preprocess(call, saveddata ? &saved_data : NULL);
1036 ipc_answer(&TASK->answerbox, call);
1037 return 0;
1038 }
1039 return (unative_t)call;
1040}
1041
1042/** Connect an IRQ handler to a task.
1043 *
1044 * @param inr IRQ number.
1045 * @param devno Device number.
1046 * @param method Method to be associated with the notification.
1047 * @param ucode Uspace pointer to the top-half pseudocode.
1048 *
1049 * @return EPERM or a return code returned by ipc_irq_register().
1050 */
1051unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
1052 irq_code_t *ucode)
1053{
1054 if (!(cap_get(TASK) & CAP_IRQ_REG))
1055 return EPERM;
1056
1057 return ipc_irq_register(&TASK->answerbox, inr, devno, method, ucode);
1058}
1059
1060/** Disconnect an IRQ handler from a task.
1061 *
1062 * @param inr IRQ number.
1063 * @param devno Device number.
1064 *
1065 * @return Zero on success or EPERM on error..
1066 */
1067unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
1068{
1069 if (!(cap_get(TASK) & CAP_IRQ_REG))
1070 return EPERM;
1071
1072 ipc_irq_unregister(&TASK->answerbox, inr, devno);
1073
1074 return 0;
1075}
1076
1077#include <console/console.h>
1078
1079/**
1080 * Syscall connect to a task by id.
1081 *
1082 * @return Phone id on success, or negative error code.
1083 */
1084unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
1085{
1086#ifdef CONFIG_UDEBUG
1087 sysarg64_t taskid_arg;
1088 int rc;
1089
1090 rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
1091 if (rc != 0)
1092 return (unative_t) rc;
1093
1094 LOG("sys_ipc_connect_kbox(%" PRIu64 ")\n", taskid_arg.value);
1095
1096 return ipc_connect_kbox(taskid_arg.value);
1097#else
1098 return (unative_t) ENOTSUP;
1099#endif
1100}
1101
1102/** @}
1103 */
Note: See TracBrowser for help on using the repository browser.