source: mainline/kernel/generic/src/ipc/sysipc.c@ 741fd16

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 741fd16 was 741fd16, checked in by Jiri Svoboda <jirik.svoboda@…>, 17 years ago

Stoppability sections must be much smaller (design error). Also fix deadlock in udebug_stop(). Fix pause functionality in tracer.
  • Property mode set to 100644
File size: 24.5 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_PHONE_HUNGUP:
97 /* This message is meant only for the original recipient. */
98 return 0;
99 default:
100 return 1;
101 }
102}
103
104/** Decide if the message with this method is immutable on forward.
105 *
106 * - some system messages may be forwarded but their content cannot be altered
107 *
108 * @param method Method to be decided.
109 *
110 * @return Return 1 if the method is immutable on forward.
111 * Otherwise return 0.
112 */
113static inline int method_is_immutable(unative_t method)
114{
115 switch (method) {
116 case IPC_M_SHARE_OUT:
117 case IPC_M_SHARE_IN:
118 case IPC_M_DATA_WRITE:
119 case IPC_M_DATA_READ:
120 return 1;
121 break;
122 default:
123 return 0;
124 }
125}
126
127
128/***********************************************************************
129 * Functions that preprocess answer before sending it to the recepient.
130 ***********************************************************************/
131
132/** Decide if the caller (e.g. ipc_answer()) should save the old call contents
133 * for answer_preprocess().
134 *
135 * @param call Call structure to be decided.
136 *
137 * @return Return 1 if the old call contents should be saved.
138 * Return 0 otherwise.
139 */
140static inline int answer_need_old(call_t *call)
141{
142 switch (IPC_GET_METHOD(call->data)) {
143 case IPC_M_CONNECT_TO_ME:
144 case IPC_M_CONNECT_ME_TO:
145 case IPC_M_SHARE_OUT:
146 case IPC_M_SHARE_IN:
147 case IPC_M_DATA_WRITE:
148 case IPC_M_DATA_READ:
149 return 1;
150 default:
151 return 0;
152 }
153}
154
155/** Interpret process answer as control information.
156 *
157 * This function is called directly after sys_ipc_answer().
158 *
159 * @param answer Call structure with the answer.
160 * @param olddata Saved data of the request.
161 *
162 * @return Return 0 on success or an error code.
163 */
164static inline int answer_preprocess(call_t *answer, ipc_data_t *olddata)
165{
166 int phoneid;
167
168 if ((native_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {
169 /* In case of forward, hangup the forwared phone,
170 * not the originator
171 */
172 mutex_lock(&answer->data.phone->lock);
173 spinlock_lock(&TASK->answerbox.lock);
174 if (answer->data.phone->state == IPC_PHONE_CONNECTED) {
175 list_remove(&answer->data.phone->link);
176 answer->data.phone->state = IPC_PHONE_SLAMMED;
177 }
178 spinlock_unlock(&TASK->answerbox.lock);
179 mutex_unlock(&answer->data.phone->lock);
180 }
181
182 if (!olddata)
183 return 0;
184
185 if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
186 phoneid = IPC_GET_ARG5(*olddata);
187 if (IPC_GET_RETVAL(answer->data)) {
188 /* The connection was not accepted */
189 phone_dealloc(phoneid);
190 } else {
191 /* The connection was accepted */
192 phone_connect(phoneid, &answer->sender->answerbox);
193 /* Set 'phone hash' as arg5 of response */
194 IPC_SET_ARG5(answer->data,
195 (unative_t) &TASK->phones[phoneid]);
196 }
197 } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
198 /* If the users accepted call, connect */
199 if (!IPC_GET_RETVAL(answer->data)) {
200 ipc_phone_connect((phone_t *) IPC_GET_ARG5(*olddata),
201 &TASK->answerbox);
202 }
203 } else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_OUT) {
204 if (!IPC_GET_RETVAL(answer->data)) {
205 /* Accepted, handle as_area receipt */
206 ipl_t ipl;
207 int rc;
208 as_t *as;
209
210 ipl = interrupts_disable();
211 spinlock_lock(&answer->sender->lock);
212 as = answer->sender->as;
213 spinlock_unlock(&answer->sender->lock);
214 interrupts_restore(ipl);
215
216 rc = as_area_share(as, IPC_GET_ARG1(*olddata),
217 IPC_GET_ARG2(*olddata), AS,
218 IPC_GET_ARG1(answer->data), IPC_GET_ARG3(*olddata));
219 IPC_SET_RETVAL(answer->data, rc);
220 return rc;
221 }
222 } else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_IN) {
223 if (!IPC_GET_RETVAL(answer->data)) {
224 ipl_t ipl;
225 as_t *as;
226 int rc;
227
228 ipl = interrupts_disable();
229 spinlock_lock(&answer->sender->lock);
230 as = answer->sender->as;
231 spinlock_unlock(&answer->sender->lock);
232 interrupts_restore(ipl);
233
234 rc = as_area_share(AS, IPC_GET_ARG1(answer->data),
235 IPC_GET_ARG2(*olddata), as, IPC_GET_ARG1(*olddata),
236 IPC_GET_ARG2(answer->data));
237 IPC_SET_RETVAL(answer->data, rc);
238 }
239 } else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_READ) {
240 ASSERT(!answer->buffer);
241 if (!IPC_GET_RETVAL(answer->data)) {
242 /* The recipient agreed to send data. */
243 uintptr_t src = IPC_GET_ARG1(answer->data);
244 uintptr_t dst = IPC_GET_ARG1(*olddata);
245 size_t max_size = IPC_GET_ARG2(*olddata);
246 size_t size = IPC_GET_ARG2(answer->data);
247 if (size && size <= max_size) {
248 /*
249 * Copy the destination VA so that this piece of
250 * information is not lost.
251 */
252 IPC_SET_ARG1(answer->data, dst);
253
254 answer->buffer = malloc(size, 0);
255 int rc = copy_from_uspace(answer->buffer,
256 (void *) src, size);
257 if (rc) {
258 IPC_SET_RETVAL(answer->data, rc);
259 free(answer->buffer);
260 answer->buffer = NULL;
261 }
262 } else if (!size) {
263 IPC_SET_RETVAL(answer->data, EOK);
264 } else {
265 IPC_SET_RETVAL(answer->data, ELIMIT);
266 }
267 }
268 } else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_WRITE) {
269 ASSERT(answer->buffer);
270 if (!IPC_GET_RETVAL(answer->data)) {
271 /* The recipient agreed to receive data. */
272 int rc;
273 uintptr_t dst;
274 size_t size;
275 size_t max_size;
276
277 dst = (uintptr_t)IPC_GET_ARG1(answer->data);
278 size = (size_t)IPC_GET_ARG2(answer->data);
279 max_size = (size_t)IPC_GET_ARG2(*olddata);
280
281 if (size <= max_size) {
282 rc = copy_to_uspace((void *) dst,
283 answer->buffer, size);
284 if (rc)
285 IPC_SET_RETVAL(answer->data, rc);
286 } else {
287 IPC_SET_RETVAL(answer->data, ELIMIT);
288 }
289 }
290 free(answer->buffer);
291 answer->buffer = NULL;
292 }
293 return 0;
294}
295
296/** Called before the request is sent.
297 *
298 * @param call Call structure with the request.
299 * @param phone Phone that the call will be sent through.
300 *
301 * @return Return 0 on success, ELIMIT or EPERM on error.
302 */
303static int request_preprocess(call_t *call, phone_t *phone)
304{
305 int newphid;
306 size_t size;
307 uintptr_t src;
308 int rc;
309
310 switch (IPC_GET_METHOD(call->data)) {
311 case IPC_M_CONNECT_ME_TO:
312 newphid = phone_alloc();
313 if (newphid < 0)
314 return ELIMIT;
315 /* Set arg5 for server */
316 IPC_SET_ARG5(call->data, (unative_t) &TASK->phones[newphid]);
317 call->flags |= IPC_CALL_CONN_ME_TO;
318 call->priv = newphid;
319 break;
320 case IPC_M_SHARE_OUT:
321 size = as_area_get_size(IPC_GET_ARG1(call->data));
322 if (!size)
323 return EPERM;
324 IPC_SET_ARG2(call->data, size);
325 break;
326 case IPC_M_DATA_READ:
327 size = IPC_GET_ARG2(call->data);
328 if ((size <= 0 || (size > DATA_XFER_LIMIT)))
329 return ELIMIT;
330 break;
331 case IPC_M_DATA_WRITE:
332 src = IPC_GET_ARG1(call->data);
333 size = IPC_GET_ARG2(call->data);
334
335 if ((size <= 0) || (size > DATA_XFER_LIMIT))
336 return ELIMIT;
337
338 call->buffer = (uint8_t *) malloc(size, 0);
339 rc = copy_from_uspace(call->buffer, (void *) src, size);
340 if (rc != 0) {
341 free(call->buffer);
342 return rc;
343 }
344 break;
345#ifdef CONFIG_UDEBUG
346 case IPC_M_DEBUG_ALL:
347 return udebug_request_preprocess(call, phone);
348#endif
349 default:
350 break;
351 }
352 return 0;
353}
354
355/*******************************************************************************
356 * Functions called to process received call/answer before passing it to uspace.
357 *******************************************************************************/
358
359/** Do basic kernel processing of received call answer.
360 *
361 * @param call Call structure with the answer.
362 */
363static void process_answer(call_t *call)
364{
365 if (((native_t) IPC_GET_RETVAL(call->data) == EHANGUP) &&
366 (call->flags & IPC_CALL_FORWARDED))
367 IPC_SET_RETVAL(call->data, EFORWARD);
368
369 if (call->flags & IPC_CALL_CONN_ME_TO) {
370 if (IPC_GET_RETVAL(call->data))
371 phone_dealloc(call->priv);
372 else
373 IPC_SET_ARG5(call->data, call->priv);
374 }
375
376 if (call->buffer) {
377 /* This must be an affirmative answer to IPC_M_DATA_READ. */
378 /* or IPC_M_DEBUG_ALL/UDEBUG_M_MEM_READ... */
379 uintptr_t dst = IPC_GET_ARG1(call->data);
380 size_t size = IPC_GET_ARG2(call->data);
381 int rc = copy_to_uspace((void *) dst, call->buffer, size);
382 if (rc)
383 IPC_SET_RETVAL(call->data, rc);
384 free(call->buffer);
385 call->buffer = NULL;
386 }
387}
388
389/** Do basic kernel processing of received call request.
390 *
391 * @param box Destination answerbox structure.
392 * @param call Call structure with the request.
393 *
394 * @return Return 0 if the call should be passed to userspace.
395 * Return -1 if the call should be ignored.
396 */
397static int process_request(answerbox_t *box, call_t *call)
398{
399 int phoneid;
400
401 if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME) {
402 phoneid = phone_alloc();
403 if (phoneid < 0) { /* Failed to allocate phone */
404 IPC_SET_RETVAL(call->data, ELIMIT);
405 ipc_answer(box, call);
406 return -1;
407 }
408 IPC_SET_ARG5(call->data, phoneid);
409 }
410 switch (IPC_GET_METHOD(call->data)) {
411 case IPC_M_DEBUG_ALL:
412 return -1;
413 default:
414 break;
415 }
416 return 0;
417}
418
419/** Make a fast call over IPC, wait for reply and return to user.
420 *
421 * This function can handle only three arguments of payload, but is faster than
422 * the generic function (i.e. sys_ipc_call_sync_slow()).
423 *
424 * @param phoneid Phone handle for the call.
425 * @param method Method of the call.
426 * @param arg1 Service-defined payload argument.
427 * @param arg2 Service-defined payload argument.
428 * @param arg3 Service-defined payload argument.
429 * @param data Address of userspace structure where the reply call will
430 * be stored.
431 *
432 * @return Returns 0 on success.
433 * Return ENOENT if there is no such phone handle.
434 */
435unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
436 unative_t arg1, unative_t arg2, unative_t arg3, ipc_data_t *data)
437{
438 call_t call;
439 phone_t *phone;
440 int res;
441 int rc;
442
443 GET_CHECK_PHONE(phone, phoneid, return ENOENT);
444
445 ipc_call_static_init(&call);
446 IPC_SET_METHOD(call.data, method);
447 IPC_SET_ARG1(call.data, arg1);
448 IPC_SET_ARG2(call.data, arg2);
449 IPC_SET_ARG3(call.data, arg3);
450 /*
451 * To achieve deterministic behavior, zero out arguments that are beyond
452 * the limits of the fast version.
453 */
454 IPC_SET_ARG4(call.data, 0);
455 IPC_SET_ARG5(call.data, 0);
456
457 if (!(res = request_preprocess(&call, phone))) {
458#ifdef CONFIG_UDEBUG
459 udebug_stoppable_begin();
460#endif
461 rc = ipc_call_sync(phone, &call);
462#ifdef CONFIG_UDEBUG
463 udebug_stoppable_end();
464#endif
465 if (rc != EOK)
466 return rc;
467 process_answer(&call);
468
469 } else {
470 IPC_SET_RETVAL(call.data, res);
471 }
472 rc = STRUCT_TO_USPACE(&data->args, &call.data.args);
473 if (rc != 0)
474 return rc;
475
476 return 0;
477}
478
479/** Make a synchronous IPC call allowing to transmit the entire payload.
480 *
481 * @param phoneid Phone handle for the call.
482 * @param question Userspace address of call data with the request.
483 * @param reply Userspace address of call data where to store the
484 * answer.
485 *
486 * @return Zero on success or an error code.
487 */
488unative_t sys_ipc_call_sync_slow(unative_t phoneid, ipc_data_t *question,
489 ipc_data_t *reply)
490{
491 call_t call;
492 phone_t *phone;
493 int res;
494 int rc;
495
496 ipc_call_static_init(&call);
497 rc = copy_from_uspace(&call.data.args, &question->args,
498 sizeof(call.data.args));
499 if (rc != 0)
500 return (unative_t) rc;
501
502 GET_CHECK_PHONE(phone, phoneid, return ENOENT);
503
504 if (!(res = request_preprocess(&call, phone))) {
505#ifdef CONFIG_UDEBUG
506 udebug_stoppable_begin();
507#endif
508 rc = ipc_call_sync(phone, &call);
509#ifdef CONFIG_UDEBUG
510 udebug_stoppable_end();
511#endif
512 if (rc != EOK)
513 return rc;
514 process_answer(&call);
515 } else
516 IPC_SET_RETVAL(call.data, res);
517
518 rc = STRUCT_TO_USPACE(&reply->args, &call.data.args);
519 if (rc != 0)
520 return rc;
521
522 return 0;
523}
524
525/** Check that the task did not exceed the allowed limit of asynchronous calls.
526 *
527 * @return Return 0 if limit not reached or -1 if limit exceeded.
528 */
529static int check_call_limit(void)
530{
531 if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
532 atomic_dec(&TASK->active_calls);
533 return -1;
534 }
535 return 0;
536}
537
538/** Make a fast asynchronous call over IPC.
539 *
540 * This function can only handle four arguments of payload, but is faster than
541 * the generic function sys_ipc_call_async_slow().
542 *
543 * @param phoneid Phone handle for the call.
544 * @param method Method of the call.
545 * @param arg1 Service-defined payload argument.
546 * @param arg2 Service-defined payload argument.
547 * @param arg3 Service-defined payload argument.
548 * @param arg4 Service-defined payload argument.
549 *
550 * @return Return call hash on success.
551 * Return IPC_CALLRET_FATAL in case of a fatal error and
552 * IPC_CALLRET_TEMPORARY if there are too many pending
553 * asynchronous requests; answers should be handled first.
554 */
555unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
556 unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
557{
558 call_t *call;
559 phone_t *phone;
560 int res;
561
562 if (check_call_limit())
563 return IPC_CALLRET_TEMPORARY;
564
565 GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
566
567 call = ipc_call_alloc(0);
568 IPC_SET_METHOD(call->data, method);
569 IPC_SET_ARG1(call->data, arg1);
570 IPC_SET_ARG2(call->data, arg2);
571 IPC_SET_ARG3(call->data, arg3);
572 IPC_SET_ARG4(call->data, arg4);
573 /*
574 * To achieve deterministic behavior, zero out arguments that are beyond
575 * the limits of the fast version.
576 */
577 IPC_SET_ARG5(call->data, 0);
578
579 if (!(res = request_preprocess(call, phone)))
580 ipc_call(phone, call);
581 else
582 ipc_backsend_err(phone, call, res);
583
584 return (unative_t) call;
585}
586
587/** Make an asynchronous IPC call allowing to transmit the entire payload.
588 *
589 * @param phoneid Phone handle for the call.
590 * @param data Userspace address of call data with the request.
591 *
592 * @return See sys_ipc_call_async_fast().
593 */
594unative_t sys_ipc_call_async_slow(unative_t phoneid, ipc_data_t *data)
595{
596 call_t *call;
597 phone_t *phone;
598 int res;
599 int rc;
600
601 if (check_call_limit())
602 return IPC_CALLRET_TEMPORARY;
603
604 GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
605
606 call = ipc_call_alloc(0);
607 rc = copy_from_uspace(&call->data.args, &data->args,
608 sizeof(call->data.args));
609 if (rc != 0) {
610 ipc_call_free(call);
611 return (unative_t) rc;
612 }
613 if (!(res = request_preprocess(call, phone)))
614 ipc_call(phone, call);
615 else
616 ipc_backsend_err(phone, call, res);
617
618 return (unative_t) call;
619}
620
621/** Forward a received call to another destination.
622 *
623 * @param callid Hash of the call to forward.
624 * @param phoneid Phone handle to use for forwarding.
625 * @param method New method to use for the forwarded call.
626 * @param arg1 New value of the first argument for the forwarded call.
627 * @param arg2 New value of the second argument for the forwarded call.
628 * @param mode Flags that specify mode of the forward operation.
629 *
630 * @return Return 0 on succes, otherwise return an error code.
631 *
632 * In case the original method is a system method, ARG1, ARG2 and ARG3 are
633 * overwritten in the forwarded message with the new method and the new arg1 and
634 * arg2, respectively. Otherwise the METHOD, ARG1 and ARG2 are rewritten with
635 * the new method, arg1 and arg2, respectively. Also note there is a set of
636 * immutable methods, for which the new method and argument is not set and
637 * these values are ignored.
638 *
639 * Warning: When implementing support for changing additional payload
640 * arguments, make sure that ARG5 is not rewritten for certain
641 * system IPC
642 */
643unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
644 unative_t method, unative_t arg1, unative_t arg2, int mode)
645{
646 call_t *call;
647 phone_t *phone;
648
649 call = get_call(callid);
650 if (!call)
651 return ENOENT;
652
653 call->flags |= IPC_CALL_FORWARDED;
654
655 GET_CHECK_PHONE(phone, phoneid, {
656 IPC_SET_RETVAL(call->data, EFORWARD);
657 ipc_answer(&TASK->answerbox, call);
658 return ENOENT;
659 });
660
661 if (!method_is_forwardable(IPC_GET_METHOD(call->data))) {
662 IPC_SET_RETVAL(call->data, EFORWARD);
663 ipc_answer(&TASK->answerbox, call);
664 return EPERM;
665 }
666
667 /*
668 * Userspace is not allowed to change method of system methods on
669 * forward, allow changing ARG1, ARG2 and ARG3 by means of method,
670 * arg1 and arg2.
671 * If the method is immutable, don't change anything.
672 */
673 if (!method_is_immutable(IPC_GET_METHOD(call->data))) {
674 if (method_is_system(IPC_GET_METHOD(call->data))) {
675 if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
676 phone_dealloc(IPC_GET_ARG5(call->data));
677
678 IPC_SET_ARG1(call->data, method);
679 IPC_SET_ARG2(call->data, arg1);
680 IPC_SET_ARG3(call->data, arg2);
681 } else {
682 IPC_SET_METHOD(call->data, method);
683 IPC_SET_ARG1(call->data, arg1);
684 IPC_SET_ARG2(call->data, arg2);
685 }
686 }
687
688 return ipc_forward(call, phone, &TASK->answerbox, mode);
689}
690
691/** Answer an IPC call - fast version.
692 *
693 * This function can handle only two return arguments of payload, but is faster
694 * than the generic sys_ipc_answer().
695 *
696 * @param callid Hash of the call to be answered.
697 * @param retval Return value of the answer.
698 * @param arg1 Service-defined return value.
699 * @param arg2 Service-defined return value.
700 * @param arg3 Service-defined return value.
701 * @param arg4 Service-defined return value.
702 *
703 * @return Return 0 on success, otherwise return an error code.
704 */
705unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
706 unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
707{
708 call_t *call;
709 ipc_data_t saved_data;
710 int saveddata = 0;
711 int rc;
712
713 /* Do not answer notification callids */
714 if (callid & IPC_CALLID_NOTIFICATION)
715 return 0;
716
717 call = get_call(callid);
718 if (!call)
719 return ENOENT;
720
721 if (answer_need_old(call)) {
722 memcpy(&saved_data, &call->data, sizeof(call->data));
723 saveddata = 1;
724 }
725
726 IPC_SET_RETVAL(call->data, retval);
727 IPC_SET_ARG1(call->data, arg1);
728 IPC_SET_ARG2(call->data, arg2);
729 IPC_SET_ARG3(call->data, arg3);
730 IPC_SET_ARG4(call->data, arg4);
731 /*
732 * To achieve deterministic behavior, zero out arguments that are beyond
733 * the limits of the fast version.
734 */
735 IPC_SET_ARG5(call->data, 0);
736 rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
737
738 ipc_answer(&TASK->answerbox, call);
739 return rc;
740}
741
742/** Answer an IPC call.
743 *
744 * @param callid Hash of the call to be answered.
745 * @param data Userspace address of call data with the answer.
746 *
747 * @return Return 0 on success, otherwise return an error code.
748 */
749unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data)
750{
751 call_t *call;
752 ipc_data_t saved_data;
753 int saveddata = 0;
754 int rc;
755
756 /* Do not answer notification callids */
757 if (callid & IPC_CALLID_NOTIFICATION)
758 return 0;
759
760 call = get_call(callid);
761 if (!call)
762 return ENOENT;
763
764 if (answer_need_old(call)) {
765 memcpy(&saved_data, &call->data, sizeof(call->data));
766 saveddata = 1;
767 }
768 rc = copy_from_uspace(&call->data.args, &data->args,
769 sizeof(call->data.args));
770 if (rc != 0)
771 return rc;
772
773 rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
774
775 ipc_answer(&TASK->answerbox, call);
776
777 return rc;
778}
779
780/** Hang up a phone.
781 *
782 * @param Phone handle of the phone to be hung up.
783 *
784 * @return Return 0 on success or an error code.
785 */
786unative_t sys_ipc_hangup(int phoneid)
787{
788 phone_t *phone;
789
790 GET_CHECK_PHONE(phone, phoneid, return ENOENT);
791
792 if (ipc_phone_hangup(phone))
793 return -1;
794
795 return 0;
796}
797
798/** Wait for an incoming IPC call or an answer.
799 *
800 * @param calldata Pointer to buffer where the call/answer data is stored.
801 * @param usec Timeout. See waitq_sleep_timeout() for explanation.
802 * @param flags Select mode of sleep operation. See waitq_sleep_timeout()
803 * for explanation.
804 *
805 * @return Hash of the call.
806 * If IPC_CALLID_NOTIFICATION bit is set in the hash, the
807 * call is a notification. IPC_CALLID_ANSWERED denotes an
808 * answer.
809 */
810unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, int flags)
811{
812 call_t *call;
813
814restart:
815
816#ifdef CONFIG_UDEBUG
817 udebug_stoppable_begin();
818#endif
819 call = ipc_wait_for_call(&TASK->answerbox, usec,
820 flags | SYNCH_FLAGS_INTERRUPTIBLE);
821
822#ifdef CONFIG_UDEBUG
823 udebug_stoppable_end();
824#endif
825 if (!call)
826 return 0;
827
828 if (call->flags & IPC_CALL_NOTIF) {
829 ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
830
831 /* Set in_phone_hash to the interrupt counter */
832 call->data.phone = (void *) call->priv;
833
834 STRUCT_TO_USPACE(calldata, &call->data);
835
836 ipc_call_free(call);
837
838 return ((unative_t) call) | IPC_CALLID_NOTIFICATION;
839 }
840
841 if (call->flags & IPC_CALL_ANSWERED) {
842 process_answer(call);
843
844 ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
845
846 if (call->flags & IPC_CALL_DISCARD_ANSWER) {
847 ipc_call_free(call);
848 goto restart;
849 } else {
850 /*
851 * Decrement the counter of active calls only if the
852 * call is not an answer to IPC_M_PHONE_HUNGUP,
853 * which doesn't contribute to the counter.
854 */
855 atomic_dec(&TASK->active_calls);
856 }
857
858 STRUCT_TO_USPACE(&calldata->args, &call->data.args);
859 ipc_call_free(call);
860
861 return ((unative_t) call) | IPC_CALLID_ANSWERED;
862 }
863
864 if (process_request(&TASK->answerbox, call))
865 goto restart;
866
867 /* Include phone address('id') of the caller in the request,
868 * copy whole call->data, not only call->data.args */
869 if (STRUCT_TO_USPACE(calldata, &call->data)) {
870 return 0;
871 }
872 return (unative_t)call;
873}
874
875/** Connect an IRQ handler to a task.
876 *
877 * @param inr IRQ number.
878 * @param devno Device number.
879 * @param method Method to be associated with the notification.
880 * @param ucode Uspace pointer to the top-half pseudocode.
881 *
882 * @return EPERM or a return code returned by ipc_irq_register().
883 */
884unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
885 irq_code_t *ucode)
886{
887 if (!(cap_get(TASK) & CAP_IRQ_REG))
888 return EPERM;
889
890 return ipc_irq_register(&TASK->answerbox, inr, devno, method, ucode);
891}
892
893/** Disconnect an IRQ handler from a task.
894 *
895 * @param inr IRQ number.
896 * @param devno Device number.
897 *
898 * @return Zero on success or EPERM on error..
899 */
900unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
901{
902 if (!(cap_get(TASK) & CAP_IRQ_REG))
903 return EPERM;
904
905 ipc_irq_unregister(&TASK->answerbox, inr, devno);
906
907 return 0;
908}
909
910#include <console/console.h>
911
912/**
913 * Syscall connect to a task by id.
914 *
915 * @return Phone id on success, or negative error code.
916 */
917unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
918{
919#ifdef CONFIG_UDEBUG
920 sysarg64_t taskid_arg;
921 int rc;
922
923 rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
924 if (rc != 0)
925 return (unative_t) rc;
926
927 LOG("sys_ipc_connect_kbox(%" PRIu64 ")\n", taskid_arg.value);
928
929 return ipc_connect_kbox(taskid_arg.value);
930#else
931 return (unative_t) ENOTSUP;
932#endif
933}
934
935/** @}
936 */
Note: See TracBrowser for help on using the repository browser.