source: mainline/kernel/generic/src/ipc/sysipc.c@ 384c488

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 384c488 was 119c335, checked in by Jakub Jermar <jakub@…>, 17 years ago

Add comments documenting our treatment of the task's active call counter.
  • Property mode set to 100644
File size: 24.2 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 rc = ipc_call_sync(phone, &call);
459 if (rc != EOK)
460 return rc;
461 process_answer(&call);
462 } else {
463 IPC_SET_RETVAL(call.data, res);
464 }
465 rc = STRUCT_TO_USPACE(&data->args, &call.data.args);
466 if (rc != 0)
467 return rc;
468
469 return 0;
470}
471
472/** Make a synchronous IPC call allowing to transmit the entire payload.
473 *
474 * @param phoneid Phone handle for the call.
475 * @param question Userspace address of call data with the request.
476 * @param reply Userspace address of call data where to store the
477 * answer.
478 *
479 * @return Zero on success or an error code.
480 */
481unative_t sys_ipc_call_sync_slow(unative_t phoneid, ipc_data_t *question,
482 ipc_data_t *reply)
483{
484 call_t call;
485 phone_t *phone;
486 int res;
487 int rc;
488
489 ipc_call_static_init(&call);
490 rc = copy_from_uspace(&call.data.args, &question->args,
491 sizeof(call.data.args));
492 if (rc != 0)
493 return (unative_t) rc;
494
495 GET_CHECK_PHONE(phone, phoneid, return ENOENT);
496
497 if (!(res = request_preprocess(&call, phone))) {
498 rc = ipc_call_sync(phone, &call);
499 if (rc != EOK)
500 return rc;
501 process_answer(&call);
502 } else
503 IPC_SET_RETVAL(call.data, res);
504
505 rc = STRUCT_TO_USPACE(&reply->args, &call.data.args);
506 if (rc != 0)
507 return rc;
508
509 return 0;
510}
511
512/** Check that the task did not exceed the allowed limit of asynchronous calls.
513 *
514 * @return Return 0 if limit not reached or -1 if limit exceeded.
515 */
516static int check_call_limit(void)
517{
518 if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
519 atomic_dec(&TASK->active_calls);
520 return -1;
521 }
522 return 0;
523}
524
525/** Make a fast asynchronous call over IPC.
526 *
527 * This function can only handle four arguments of payload, but is faster than
528 * the generic function sys_ipc_call_async_slow().
529 *
530 * @param phoneid Phone handle for the call.
531 * @param method Method of the call.
532 * @param arg1 Service-defined payload argument.
533 * @param arg2 Service-defined payload argument.
534 * @param arg3 Service-defined payload argument.
535 * @param arg4 Service-defined payload argument.
536 *
537 * @return Return call hash on success.
538 * Return IPC_CALLRET_FATAL in case of a fatal error and
539 * IPC_CALLRET_TEMPORARY if there are too many pending
540 * asynchronous requests; answers should be handled first.
541 */
542unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
543 unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
544{
545 call_t *call;
546 phone_t *phone;
547 int res;
548
549 if (check_call_limit())
550 return IPC_CALLRET_TEMPORARY;
551
552 GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
553
554 call = ipc_call_alloc(0);
555 IPC_SET_METHOD(call->data, method);
556 IPC_SET_ARG1(call->data, arg1);
557 IPC_SET_ARG2(call->data, arg2);
558 IPC_SET_ARG3(call->data, arg3);
559 IPC_SET_ARG4(call->data, arg4);
560 /*
561 * To achieve deterministic behavior, zero out arguments that are beyond
562 * the limits of the fast version.
563 */
564 IPC_SET_ARG5(call->data, 0);
565
566 if (!(res = request_preprocess(call, phone)))
567 ipc_call(phone, call);
568 else
569 ipc_backsend_err(phone, call, res);
570
571 return (unative_t) call;
572}
573
574/** Make an asynchronous IPC call allowing to transmit the entire payload.
575 *
576 * @param phoneid Phone handle for the call.
577 * @param data Userspace address of call data with the request.
578 *
579 * @return See sys_ipc_call_async_fast().
580 */
581unative_t sys_ipc_call_async_slow(unative_t phoneid, ipc_data_t *data)
582{
583 call_t *call;
584 phone_t *phone;
585 int res;
586 int rc;
587
588 if (check_call_limit())
589 return IPC_CALLRET_TEMPORARY;
590
591 GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
592
593 call = ipc_call_alloc(0);
594 rc = copy_from_uspace(&call->data.args, &data->args,
595 sizeof(call->data.args));
596 if (rc != 0) {
597 ipc_call_free(call);
598 return (unative_t) rc;
599 }
600 if (!(res = request_preprocess(call, phone)))
601 ipc_call(phone, call);
602 else
603 ipc_backsend_err(phone, call, res);
604
605 return (unative_t) call;
606}
607
608/** Forward a received call to another destination.
609 *
610 * @param callid Hash of the call to forward.
611 * @param phoneid Phone handle to use for forwarding.
612 * @param method New method to use for the forwarded call.
613 * @param arg1 New value of the first argument for the forwarded call.
614 * @param arg2 New value of the second argument for the forwarded call.
615 * @param mode Flags that specify mode of the forward operation.
616 *
617 * @return Return 0 on succes, otherwise return an error code.
618 *
619 * In case the original method is a system method, ARG1, ARG2 and ARG3 are
620 * overwritten in the forwarded message with the new method and the new arg1 and
621 * arg2, respectively. Otherwise the METHOD, ARG1 and ARG2 are rewritten with
622 * the new method, arg1 and arg2, respectively. Also note there is a set of
623 * immutable methods, for which the new method and argument is not set and
624 * these values are ignored.
625 *
626 * Warning: When implementing support for changing additional payload
627 * arguments, make sure that ARG5 is not rewritten for certain
628 * system IPC
629 */
630unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
631 unative_t method, unative_t arg1, unative_t arg2, int mode)
632{
633 call_t *call;
634 phone_t *phone;
635
636 call = get_call(callid);
637 if (!call)
638 return ENOENT;
639
640 call->flags |= IPC_CALL_FORWARDED;
641
642 GET_CHECK_PHONE(phone, phoneid, {
643 IPC_SET_RETVAL(call->data, EFORWARD);
644 ipc_answer(&TASK->answerbox, call);
645 return ENOENT;
646 });
647
648 if (!method_is_forwardable(IPC_GET_METHOD(call->data))) {
649 IPC_SET_RETVAL(call->data, EFORWARD);
650 ipc_answer(&TASK->answerbox, call);
651 return EPERM;
652 }
653
654 /*
655 * Userspace is not allowed to change method of system methods on
656 * forward, allow changing ARG1, ARG2 and ARG3 by means of method,
657 * arg1 and arg2.
658 * If the method is immutable, don't change anything.
659 */
660 if (!method_is_immutable(IPC_GET_METHOD(call->data))) {
661 if (method_is_system(IPC_GET_METHOD(call->data))) {
662 if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
663 phone_dealloc(IPC_GET_ARG5(call->data));
664
665 IPC_SET_ARG1(call->data, method);
666 IPC_SET_ARG2(call->data, arg1);
667 IPC_SET_ARG3(call->data, arg2);
668 } else {
669 IPC_SET_METHOD(call->data, method);
670 IPC_SET_ARG1(call->data, arg1);
671 IPC_SET_ARG2(call->data, arg2);
672 }
673 }
674
675 return ipc_forward(call, phone, &TASK->answerbox, mode);
676}
677
678/** Answer an IPC call - fast version.
679 *
680 * This function can handle only two return arguments of payload, but is faster
681 * than the generic sys_ipc_answer().
682 *
683 * @param callid Hash of the call to be answered.
684 * @param retval Return value of the answer.
685 * @param arg1 Service-defined return value.
686 * @param arg2 Service-defined return value.
687 * @param arg3 Service-defined return value.
688 * @param arg4 Service-defined return value.
689 *
690 * @return Return 0 on success, otherwise return an error code.
691 */
692unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
693 unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
694{
695 call_t *call;
696 ipc_data_t saved_data;
697 int saveddata = 0;
698 int rc;
699
700 /* Do not answer notification callids */
701 if (callid & IPC_CALLID_NOTIFICATION)
702 return 0;
703
704 call = get_call(callid);
705 if (!call)
706 return ENOENT;
707
708 if (answer_need_old(call)) {
709 memcpy(&saved_data, &call->data, sizeof(call->data));
710 saveddata = 1;
711 }
712
713 IPC_SET_RETVAL(call->data, retval);
714 IPC_SET_ARG1(call->data, arg1);
715 IPC_SET_ARG2(call->data, arg2);
716 IPC_SET_ARG3(call->data, arg3);
717 IPC_SET_ARG4(call->data, arg4);
718 /*
719 * To achieve deterministic behavior, zero out arguments that are beyond
720 * the limits of the fast version.
721 */
722 IPC_SET_ARG5(call->data, 0);
723 rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
724
725 ipc_answer(&TASK->answerbox, call);
726 return rc;
727}
728
729/** Answer an IPC call.
730 *
731 * @param callid Hash of the call to be answered.
732 * @param data Userspace address of call data with the answer.
733 *
734 * @return Return 0 on success, otherwise return an error code.
735 */
736unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data)
737{
738 call_t *call;
739 ipc_data_t saved_data;
740 int saveddata = 0;
741 int rc;
742
743 /* Do not answer notification callids */
744 if (callid & IPC_CALLID_NOTIFICATION)
745 return 0;
746
747 call = get_call(callid);
748 if (!call)
749 return ENOENT;
750
751 if (answer_need_old(call)) {
752 memcpy(&saved_data, &call->data, sizeof(call->data));
753 saveddata = 1;
754 }
755 rc = copy_from_uspace(&call->data.args, &data->args,
756 sizeof(call->data.args));
757 if (rc != 0)
758 return rc;
759
760 rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
761
762 ipc_answer(&TASK->answerbox, call);
763
764 return rc;
765}
766
767/** Hang up a phone.
768 *
769 * @param Phone handle of the phone to be hung up.
770 *
771 * @return Return 0 on success or an error code.
772 */
773unative_t sys_ipc_hangup(int phoneid)
774{
775 phone_t *phone;
776
777 GET_CHECK_PHONE(phone, phoneid, return ENOENT);
778
779 if (ipc_phone_hangup(phone))
780 return -1;
781
782 return 0;
783}
784
785/** Wait for an incoming IPC call or an answer.
786 *
787 * @param calldata Pointer to buffer where the call/answer data is stored.
788 * @param usec Timeout. See waitq_sleep_timeout() for explanation.
789 * @param flags Select mode of sleep operation. See waitq_sleep_timeout()
790 * for explanation.
791 *
792 * @return Hash of the call.
793 * If IPC_CALLID_NOTIFICATION bit is set in the hash, the
794 * call is a notification. IPC_CALLID_ANSWERED denotes an
795 * answer.
796 */
797unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, int flags)
798{
799 call_t *call;
800
801restart:
802 call = ipc_wait_for_call(&TASK->answerbox, usec,
803 flags | SYNCH_FLAGS_INTERRUPTIBLE);
804 if (!call)
805 return 0;
806
807 if (call->flags & IPC_CALL_NOTIF) {
808 ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
809
810 /* Set in_phone_hash to the interrupt counter */
811 call->data.phone = (void *) call->priv;
812
813 STRUCT_TO_USPACE(calldata, &call->data);
814
815 ipc_call_free(call);
816
817 return ((unative_t) call) | IPC_CALLID_NOTIFICATION;
818 }
819
820 if (call->flags & IPC_CALL_ANSWERED) {
821 process_answer(call);
822
823 ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
824
825 if (call->flags & IPC_CALL_DISCARD_ANSWER) {
826 ipc_call_free(call);
827 goto restart;
828 } else {
829 /*
830 * Decrement the counter of active calls only if the
831 * call is not an answer to IPC_M_PHONE_HUNGUP,
832 * which doesn't contribute to the counter.
833 */
834 atomic_dec(&TASK->active_calls);
835 }
836
837 STRUCT_TO_USPACE(&calldata->args, &call->data.args);
838 ipc_call_free(call);
839
840 return ((unative_t) call) | IPC_CALLID_ANSWERED;
841 }
842
843 if (process_request(&TASK->answerbox, call))
844 goto restart;
845
846 /* Include phone address('id') of the caller in the request,
847 * copy whole call->data, not only call->data.args */
848 if (STRUCT_TO_USPACE(calldata, &call->data)) {
849 return 0;
850 }
851 return (unative_t)call;
852}
853
854/** Connect an IRQ handler to a task.
855 *
856 * @param inr IRQ number.
857 * @param devno Device number.
858 * @param method Method to be associated with the notification.
859 * @param ucode Uspace pointer to the top-half pseudocode.
860 *
861 * @return EPERM or a return code returned by ipc_irq_register().
862 */
863unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
864 irq_code_t *ucode)
865{
866 if (!(cap_get(TASK) & CAP_IRQ_REG))
867 return EPERM;
868
869 return ipc_irq_register(&TASK->answerbox, inr, devno, method, ucode);
870}
871
872/** Disconnect an IRQ handler from a task.
873 *
874 * @param inr IRQ number.
875 * @param devno Device number.
876 *
877 * @return Zero on success or EPERM on error..
878 */
879unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
880{
881 if (!(cap_get(TASK) & CAP_IRQ_REG))
882 return EPERM;
883
884 ipc_irq_unregister(&TASK->answerbox, inr, devno);
885
886 return 0;
887}
888
889#include <console/console.h>
890
891/**
892 * Syscall connect to a task by id.
893 *
894 * @return Phone id on success, or negative error code.
895 */
896unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
897{
898#ifdef CONFIG_UDEBUG
899 sysarg64_t taskid_arg;
900 int rc;
901
902 rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
903 if (rc != 0)
904 return (unative_t) rc;
905
906 LOG("sys_ipc_connect_kbox(%" PRIu64 ")\n", taskid_arg.value);
907
908 return ipc_connect_kbox(taskid_arg.value);
909#else
910 return (unative_t) ENOTSUP;
911#endif
912}
913
914/** @}
915 */
Note: See TracBrowser for help on using the repository browser.