source: mainline/kernel/generic/src/ipc/sysipc.c@ 36d852c

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

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