source: mainline/kernel/generic/src/ipc/sysipc.c@ 1b186ed

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

Move handling of IPC_M_CONNECT_ME_TO in process_answer() to its private
ops method.

  • Property mode set to 100644
File size: 21.7 KB
RevLine 
[2d5a54f3]1/*
[df4ed85]2 * Copyright (c) 2006 Ondrej Palkovsky
[2d5a54f3]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
[cc73a8a1]29/** @addtogroup genericipc
[b45c443]30 * @{
31 */
32/** @file
33 */
34
[2d5a54f3]35#include <arch.h>
36#include <errno.h>
37#include <memstr.h>
38#include <ipc/ipc.h>
[c0699467]39#include <abi/ipc/methods.h>
[2d5a54f3]40#include <ipc/sysipc.h>
[e8039a86]41#include <ipc/sysipc_ops.h>
[162f919]42#include <ipc/irq.h>
[4e49572]43#include <ipc/ipcrsc.h>
[fdd4898]44#include <ipc/event.h>
[e028660]45#include <ipc/kbox.h>
[057d21a]46#include <synch/waitq.h>
[5626277]47#include <arch/interrupt.h>
[e3c762cd]48#include <syscall/copy.h>
[2bb8648]49#include <security/cap.h>
[6b10dab]50#include <console/console.h>
[253f35a1]51#include <print.h>
[e2ab36f1]52#include <macros.h>
[2d5a54f3]53
[da1bafb]54#define STRUCT_TO_USPACE(dst, src) copy_to_uspace((dst), (src), sizeof(*(src)))
[7918fce]55
[228e490]56/** Decide if the interface and method is a system method.
[8b243f2]57 *
[228e490]58 * @param imethod Interface and method to be decided.
[da1bafb]59 *
[228e490]60 * @return True if the interface and method is a system
61 * interface and method.
[8b243f2]62 *
63 */
[228e490]64static inline bool method_is_system(sysarg_t imethod)
[2ba7810]65{
[228e490]66 if (imethod <= IPC_M_LAST_SYSTEM)
[da1bafb]67 return true;
68
69 return false;
[2ba7810]70}
71
[228e490]72/** Decide if the message with this interface and method is forwardable.
[2ba7810]73 *
[228e490]74 * Some system messages may be forwarded, for some of them
75 * it is useless.
[8b243f2]76 *
[228e490]77 * @param imethod Interface and method to be decided.
[da1bafb]78 *
[228e490]79 * @return True if the interface and method is forwardable.
[8b243f2]80 *
[2ba7810]81 */
[228e490]82static inline bool method_is_forwardable(sysarg_t imethod)
[2ba7810]83{
[228e490]84 switch (imethod) {
[2c0e5d2]85 case IPC_M_CONNECTION_CLONE:
[6aae539d]86 case IPC_M_CLONE_ESTABLISH:
[7918fce]87 case IPC_M_PHONE_HUNGUP:
88 /* This message is meant only for the original recipient. */
[da1bafb]89 return false;
[7918fce]90 default:
[da1bafb]91 return true;
[7918fce]92 }
[2ba7810]93}
94
[228e490]95/** Decide if the message with this interface and method is immutable on forward.
[0dc4258]96 *
[228e490]97 * Some system messages may be forwarded but their content cannot be altered.
[0dc4258]98 *
[228e490]99 * @param imethod Interface and method to be decided.
[da1bafb]100 *
[228e490]101 * @return True if the interface and method is immutable on forward.
[0dc4258]102 *
103 */
[228e490]104static inline bool method_is_immutable(sysarg_t imethod)
[0dc4258]105{
[228e490]106 switch (imethod) {
[27d293a]107 case IPC_M_SHARE_OUT:
108 case IPC_M_SHARE_IN:
[36d852c]109 case IPC_M_DATA_WRITE:
110 case IPC_M_DATA_READ:
[fdd4898]111 case IPC_M_STATE_CHANGE_AUTHORIZE:
[da1bafb]112 return true;
[0dc4258]113 default:
[da1bafb]114 return false;
[0dc4258]115 }
116}
117
[2d5a54f3]118
[8b243f2]119/***********************************************************************
120 * Functions that preprocess answer before sending it to the recepient.
121 ***********************************************************************/
122
123/** Decide if the caller (e.g. ipc_answer()) should save the old call contents
124 * for answer_preprocess().
125 *
[da1bafb]126 * @param call Call structure to be decided.
127 *
128 * @return true if the old call contents should be saved.
[8b243f2]129 *
[2d5a54f3]130 */
[da1bafb]131static inline bool answer_need_old(call_t *call)
[2d5a54f3]132{
[228e490]133 switch (IPC_GET_IMETHOD(call->data)) {
[2c0e5d2]134 case IPC_M_CONNECTION_CLONE:
[6aae539d]135 case IPC_M_CLONE_ESTABLISH:
[7918fce]136 case IPC_M_CONNECT_TO_ME:
137 case IPC_M_CONNECT_ME_TO:
[27d293a]138 case IPC_M_SHARE_OUT:
139 case IPC_M_SHARE_IN:
[36d852c]140 case IPC_M_DATA_WRITE:
141 case IPC_M_DATA_READ:
[fdd4898]142 case IPC_M_STATE_CHANGE_AUTHORIZE:
[da1bafb]143 return true;
[7918fce]144 default:
[da1bafb]145 return false;
[7918fce]146 }
[2d5a54f3]147}
148
[8b243f2]149/** Interpret process answer as control information.
150 *
151 * This function is called directly after sys_ipc_answer().
[46fc2f9]152 *
[da1bafb]153 * @param answer Call structure with the answer.
154 * @param olddata Saved data of the request.
155 *
[9956fad9]156 * @return Return EOK on success or a negative error code.
[8b243f2]157 *
[46fc2f9]158 */
[9956fad9]159static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
[2d5a54f3]160{
[9956fad9]161 int rc = EOK;
162
[2405bb5]163 spinlock_lock(&answer->forget_lock);
164 if (answer->forget) {
165 /*
166 * This is a forgotten call and answer->sender is not valid.
167 */
168 spinlock_unlock(&answer->forget_lock);
[e8039a86]169 /* TODO: cleanup? */
[2405bb5]170 return rc;
171 } else {
172 /*
173 * Hold the sender task so that it cannot suddenly disappear
174 * while we are working with it.
175 */
176 task_hold(answer->sender);
177 }
178 spinlock_unlock(&answer->forget_lock);
179
[6c441cf8]180 if ((native_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {
[ca687ad]181 /* In case of forward, hangup the forwared phone,
182 * not the originator
183 */
[ff48a15]184 mutex_lock(&answer->data.phone->lock);
[da1bafb]185 irq_spinlock_lock(&TASK->answerbox.lock, true);
[eb3d379]186 if (answer->data.phone->state == IPC_PHONE_CONNECTED) {
[c4e4507]187 list_remove(&answer->data.phone->link);
[eb3d379]188 answer->data.phone->state = IPC_PHONE_SLAMMED;
[ca687ad]189 }
[da1bafb]190 irq_spinlock_unlock(&TASK->answerbox.lock, true);
[ff48a15]191 mutex_unlock(&answer->data.phone->lock);
[9f22213]192 }
[da1bafb]193
[2405bb5]194 if (!olddata) {
195 task_release(answer->sender);
[9956fad9]196 return rc;
[2405bb5]197 }
[da1bafb]198
[e8039a86]199
[32e4643]200 sysipc_ops_t *ops = sysipc_ops_get(answer->request_method);
[e8039a86]201 if (ops->answer_preprocess)
202 rc = ops->answer_preprocess(answer, olddata);
[da1bafb]203
[2405bb5]204 task_release(answer->sender);
205
[9956fad9]206 return rc;
[2d5a54f3]207}
208
[8b243f2]209/** Called before the request is sent.
210 *
[da1bafb]211 * @param call Call structure with the request.
212 * @param phone Phone that the call will be sent through.
213 *
214 * @return Return 0 on success, ELIMIT or EPERM on error.
[7c7aae16]215 *
216 */
[9a1b20c]217static int request_preprocess(call_t *call, phone_t *phone)
[7c7aae16]218{
[924c2530]219 int rc = EOK;
220
[32e4643]221 call->request_method = IPC_GET_IMETHOD(call->data);
222
223 sysipc_ops_t *ops = sysipc_ops_get(call->request_method);
[e8039a86]224 if (ops->request_preprocess)
225 rc = ops->request_preprocess(call, phone);
[da1bafb]226
[924c2530]227 return rc;
[7c7aae16]228}
229
[8b243f2]230/*******************************************************************************
231 * Functions called to process received call/answer before passing it to uspace.
232 *******************************************************************************/
[2d5a54f3]233
[8b243f2]234/** Do basic kernel processing of received call answer.
235 *
[da1bafb]236 * @param call Call structure with the answer.
237 *
[8b243f2]238 */
[7c7aae16]239static void process_answer(call_t *call)
[2d5a54f3]240{
[6c441cf8]241 if (((native_t) IPC_GET_RETVAL(call->data) == EHANGUP) &&
[51ec40f]242 (call->flags & IPC_CALL_FORWARDED))
[9f22213]243 IPC_SET_RETVAL(call->data, EFORWARD);
[da1bafb]244
[a55d5f9f]245 if (call->buffer) {
[da1bafb]246 /*
247 * This must be an affirmative answer to IPC_M_DATA_READ
[79ae36dd]248 * or IPC_M_DEBUG/UDEBUG_M_MEM_READ...
[da1bafb]249 *
250 */
[a55d5f9f]251 uintptr_t dst = IPC_GET_ARG1(call->data);
252 size_t size = IPC_GET_ARG2(call->data);
253 int rc = copy_to_uspace((void *) dst, call->buffer, size);
254 if (rc)
255 IPC_SET_RETVAL(call->data, rc);
256 free(call->buffer);
257 call->buffer = NULL;
258 }
[32e4643]259
260 sysipc_ops_t *ops = sysipc_ops_get(call->request_method);
261 if (ops->answer_process)
262 (void) ops->answer_process(call);
[2d5a54f3]263}
264
[691d8d8]265
[8b243f2]266/** Do basic kernel processing of received call request.
267 *
[da1bafb]268 * @param box Destination answerbox structure.
269 * @param call Call structure with the request.
270 *
271 * @return 0 if the call should be passed to userspace.
272 * @return -1 if the call should be ignored.
[2d5a54f3]273 *
274 */
[51ec40f]275static int process_request(answerbox_t *box, call_t *call)
[2d5a54f3]276{
[691d8d8]277 int rc = EOK;
278
[32e4643]279 sysipc_ops_t *ops = sysipc_ops_get(call->request_method);
[e8039a86]280 if (ops->request_process)
281 rc = ops->request_process(call, box);
[da1bafb]282
[691d8d8]283 return rc;
[2d5a54f3]284}
285
[97d17fe]286/** Check that the task did not exceed the allowed limit of asynchronous calls
287 * made over a phone.
[2d5a54f3]288 *
[228e490]289 * @param phone Phone to check the limit against.
290 *
[da1bafb]291 * @return 0 if limit not reached or -1 if limit exceeded.
292 *
[2d5a54f3]293 */
[97d17fe]294static int check_call_limit(phone_t *phone)
[2d5a54f3]295{
[97d17fe]296 if (atomic_get(&phone->active_calls) >= IPC_MAX_ASYNC_CALLS)
[2d5a54f3]297 return -1;
[da1bafb]298
[2d5a54f3]299 return 0;
300}
301
[8b243f2]302/** Make a fast asynchronous call over IPC.
[2d5a54f3]303 *
[3209923]304 * This function can only handle four arguments of payload, but is faster than
305 * the generic function sys_ipc_call_async_slow().
[8b243f2]306 *
[da1bafb]307 * @param phoneid Phone handle for the call.
[228e490]308 * @param imethod Interface and method of the call.
[da1bafb]309 * @param arg1 Service-defined payload argument.
310 * @param arg2 Service-defined payload argument.
311 * @param arg3 Service-defined payload argument.
312 * @param arg4 Service-defined payload argument.
313 *
314 * @return Call hash on success.
315 * @return IPC_CALLRET_FATAL in case of a fatal error.
316 * @return IPC_CALLRET_TEMPORARY if there are too many pending
317 * asynchronous requests; answers should be handled first.
318 *
[2d5a54f3]319 */
[228e490]320sysarg_t sys_ipc_call_async_fast(sysarg_t phoneid, sysarg_t imethod,
[96b02eb9]321 sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
[2d5a54f3]322{
[da1bafb]323 phone_t *phone;
[c9fff17]324 if (phone_get(phoneid, &phone) != EOK)
325 return IPC_CALLRET_FATAL;
[228e490]326
[97d17fe]327 if (check_call_limit(phone))
328 return IPC_CALLRET_TEMPORARY;
[da1bafb]329
330 call_t *call = ipc_call_alloc(0);
[228e490]331 IPC_SET_IMETHOD(call->data, imethod);
[2d5a54f3]332 IPC_SET_ARG1(call->data, arg1);
333 IPC_SET_ARG2(call->data, arg2);
[3209923]334 IPC_SET_ARG3(call->data, arg3);
335 IPC_SET_ARG4(call->data, arg4);
[da1bafb]336
[8498915]337 /*
338 * To achieve deterministic behavior, zero out arguments that are beyond
339 * the limits of the fast version.
340 */
341 IPC_SET_ARG5(call->data, 0);
[da1bafb]342
343 int res = request_preprocess(call, phone);
344
345 if (!res)
[7c7aae16]346 ipc_call(phone, call);
347 else
348 ipc_backsend_err(phone, call, res);
[da1bafb]349
[96b02eb9]350 return (sysarg_t) call;
[2d5a54f3]351}
352
[8b243f2]353/** Make an asynchronous IPC call allowing to transmit the entire payload.
354 *
[da1bafb]355 * @param phoneid Phone handle for the call.
356 * @param data Userspace address of call data with the request.
357 *
358 * @return See sys_ipc_call_async_fast().
[2d5a54f3]359 *
360 */
[96b02eb9]361sysarg_t sys_ipc_call_async_slow(sysarg_t phoneid, ipc_data_t *data)
[2d5a54f3]362{
[da1bafb]363 phone_t *phone;
[c9fff17]364 if (phone_get(phoneid, &phone) != EOK)
365 return IPC_CALLRET_FATAL;
[4e49572]366
[97d17fe]367 if (check_call_limit(phone))
368 return IPC_CALLRET_TEMPORARY;
369
[da1bafb]370 call_t *call = ipc_call_alloc(0);
371 int rc = copy_from_uspace(&call->data.args, &data->args,
[51ec40f]372 sizeof(call->data.args));
[f58af46]373 if (rc != 0) {
374 ipc_call_free(call);
[96b02eb9]375 return (sysarg_t) rc;
[f58af46]376 }
[da1bafb]377
378 int res = request_preprocess(call, phone);
379
380 if (!res)
[7c7aae16]381 ipc_call(phone, call);
382 else
383 ipc_backsend_err(phone, call, res);
[da1bafb]384
[96b02eb9]385 return (sysarg_t) call;
[2d5a54f3]386}
387
[da1bafb]388/** Forward a received call to another destination
389 *
390 * Common code for both the fast and the slow version.
391 *
392 * @param callid Hash of the call to forward.
393 * @param phoneid Phone handle to use for forwarding.
[228e490]394 * @param imethod New interface and method to use for the forwarded call.
[da1bafb]395 * @param arg1 New value of the first argument for the forwarded call.
396 * @param arg2 New value of the second argument for the forwarded call.
397 * @param arg3 New value of the third argument for the forwarded call.
398 * @param arg4 New value of the fourth argument for the forwarded call.
399 * @param arg5 New value of the fifth argument for the forwarded call.
400 * @param mode Flags that specify mode of the forward operation.
401 * @param slow If true, arg3, arg4 and arg5 are considered. Otherwise
402 * the function considers only the fast version arguments:
403 * i.e. arg1 and arg2.
404 *
405 * @return 0 on succes, otherwise an error code.
406 *
407 * Warning: Make sure that ARG5 is not rewritten for certain system IPC
408 *
[2ba7810]409 */
[96b02eb9]410static sysarg_t sys_ipc_forward_common(sysarg_t callid, sysarg_t phoneid,
[228e490]411 sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
[96b02eb9]412 sysarg_t arg4, sysarg_t arg5, unsigned int mode, bool slow)
[2ba7810]413{
[da1bafb]414 call_t *call = get_call(callid);
[2ba7810]415 if (!call)
416 return ENOENT;
[48daf64]417
[9f22213]418 call->flags |= IPC_CALL_FORWARDED;
[da1bafb]419
420 phone_t *phone;
[c9fff17]421 if (phone_get(phoneid, &phone) != EOK) {
[2ba7810]422 IPC_SET_RETVAL(call->data, EFORWARD);
423 ipc_answer(&TASK->answerbox, call);
424 return ENOENT;
[c9fff17]425 }
[da1bafb]426
[228e490]427 if (!method_is_forwardable(IPC_GET_IMETHOD(call->data))) {
[2ba7810]428 IPC_SET_RETVAL(call->data, EFORWARD);
429 ipc_answer(&TASK->answerbox, call);
430 return EPERM;
431 }
[da1bafb]432
[0dc4258]433 /*
[4e5dabf]434 * User space is not allowed to change interface and method of system
[228e490]435 * methods on forward, allow changing ARG1, ARG2, ARG3 and ARG4 by
[4e5dabf]436 * means of imethod, arg1, arg2 and arg3.
[228e490]437 * If the interface and method is immutable, don't change anything.
[2ba7810]438 */
[228e490]439 if (!method_is_immutable(IPC_GET_IMETHOD(call->data))) {
440 if (method_is_system(IPC_GET_IMETHOD(call->data))) {
441 if (IPC_GET_IMETHOD(call->data) == IPC_M_CONNECT_TO_ME)
[b61d47d]442 phone_dealloc(IPC_GET_ARG5(call->data));
[da1bafb]443
[228e490]444 IPC_SET_ARG1(call->data, imethod);
[0dc4258]445 IPC_SET_ARG2(call->data, arg1);
[b61d47d]446 IPC_SET_ARG3(call->data, arg2);
[da1bafb]447
[4e5dabf]448 if (slow)
[48daf64]449 IPC_SET_ARG4(call->data, arg3);
[4e5dabf]450
451 /*
452 * For system methods we deliberately don't
453 * overwrite ARG5.
454 */
[0dc4258]455 } else {
[228e490]456 IPC_SET_IMETHOD(call->data, imethod);
[0dc4258]457 IPC_SET_ARG1(call->data, arg1);
[b61d47d]458 IPC_SET_ARG2(call->data, arg2);
[48daf64]459 if (slow) {
460 IPC_SET_ARG3(call->data, arg3);
461 IPC_SET_ARG4(call->data, arg4);
462 IPC_SET_ARG5(call->data, arg5);
463 }
[0dc4258]464 }
[2ba7810]465 }
[da1bafb]466
[d40a8ff]467 return ipc_forward(call, phone, &TASK->answerbox, mode);
[2ba7810]468}
469
[48daf64]470/** Forward a received call to another destination - fast version.
471 *
[228e490]472 * In case the original interface and method is a system method, ARG1, ARG2
473 * and ARG3 are overwritten in the forwarded message with the new method and
474 * the new arg1 and arg2, respectively. Otherwise the IMETHOD, ARG1 and ARG2
475 * are rewritten with the new interface and method, arg1 and arg2, respectively.
476 * Also note there is a set of immutable methods, for which the new method and
477 * arguments are not set and these values are ignored.
[da1bafb]478 *
479 * @param callid Hash of the call to forward.
480 * @param phoneid Phone handle to use for forwarding.
[228e490]481 * @param imethod New interface and method to use for the forwarded call.
[da1bafb]482 * @param arg1 New value of the first argument for the forwarded call.
483 * @param arg2 New value of the second argument for the forwarded call.
484 * @param mode Flags that specify mode of the forward operation.
485 *
486 * @return 0 on succes, otherwise an error code.
487 *
[48daf64]488 */
[96b02eb9]489sysarg_t sys_ipc_forward_fast(sysarg_t callid, sysarg_t phoneid,
[228e490]490 sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
[48daf64]491{
[228e490]492 return sys_ipc_forward_common(callid, phoneid, imethod, arg1, arg2, 0, 0,
[48daf64]493 0, mode, false);
494}
495
496/** Forward a received call to another destination - slow version.
497 *
498 * This function is the slow verision of the sys_ipc_forward_fast interface.
[228e490]499 * It can copy all five new arguments and the new interface and method from
500 * the userspace. It naturally extends the functionality of the fast version.
501 * For system methods, it additionally stores the new value of arg3 to ARG4.
502 * For non-system methods, it additionally stores the new value of arg3, arg4
503 * and arg5, respectively, to ARG3, ARG4 and ARG5, respectively.
[da1bafb]504 *
505 * @param callid Hash of the call to forward.
506 * @param phoneid Phone handle to use for forwarding.
507 * @param data Userspace address of the new IPC data.
508 * @param mode Flags that specify mode of the forward operation.
509 *
510 * @return 0 on succes, otherwise an error code.
511 *
[48daf64]512 */
[96b02eb9]513sysarg_t sys_ipc_forward_slow(sysarg_t callid, sysarg_t phoneid,
[da1bafb]514 ipc_data_t *data, unsigned int mode)
[48daf64]515{
516 ipc_data_t newdata;
[da1bafb]517 int rc = copy_from_uspace(&newdata.args, &data->args,
[48daf64]518 sizeof(newdata.args));
[da1bafb]519 if (rc != 0)
[96b02eb9]520 return (sysarg_t) rc;
[da1bafb]521
[48daf64]522 return sys_ipc_forward_common(callid, phoneid,
[228e490]523 IPC_GET_IMETHOD(newdata), IPC_GET_ARG1(newdata),
[48daf64]524 IPC_GET_ARG2(newdata), IPC_GET_ARG3(newdata),
525 IPC_GET_ARG4(newdata), IPC_GET_ARG5(newdata), mode, true);
526}
527
[8b243f2]528/** Answer an IPC call - fast version.
529 *
530 * This function can handle only two return arguments of payload, but is faster
531 * than the generic sys_ipc_answer().
532 *
[da1bafb]533 * @param callid Hash of the call to be answered.
534 * @param retval Return value of the answer.
535 * @param arg1 Service-defined return value.
536 * @param arg2 Service-defined return value.
537 * @param arg3 Service-defined return value.
538 * @param arg4 Service-defined return value.
539 *
540 * @return 0 on success, otherwise an error code.
[8b243f2]541 *
542 */
[96b02eb9]543sysarg_t sys_ipc_answer_fast(sysarg_t callid, sysarg_t retval,
544 sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
[2d5a54f3]545{
[897f2e76]546 /* Do not answer notification callids */
547 if (callid & IPC_CALLID_NOTIFICATION)
548 return 0;
[da1bafb]549
550 call_t *call = get_call(callid);
[2ba7810]551 if (!call)
552 return ENOENT;
[da1bafb]553
554 ipc_data_t saved_data;
555 bool saved;
556
[9f22213]557 if (answer_need_old(call)) {
[2ba7810]558 memcpy(&saved_data, &call->data, sizeof(call->data));
[da1bafb]559 saved = true;
560 } else
561 saved = false;
562
[2d5a54f3]563 IPC_SET_RETVAL(call->data, retval);
564 IPC_SET_ARG1(call->data, arg1);
565 IPC_SET_ARG2(call->data, arg2);
[b74959bd]566 IPC_SET_ARG3(call->data, arg3);
567 IPC_SET_ARG4(call->data, arg4);
[da1bafb]568
[8498915]569 /*
570 * To achieve deterministic behavior, zero out arguments that are beyond
571 * the limits of the fast version.
572 */
573 IPC_SET_ARG5(call->data, 0);
[da1bafb]574 int rc = answer_preprocess(call, saved ? &saved_data : NULL);
575
[2d5a54f3]576 ipc_answer(&TASK->answerbox, call);
[7c23af9]577 return rc;
[2d5a54f3]578}
579
[8b243f2]580/** Answer an IPC call.
581 *
[da1bafb]582 * @param callid Hash of the call to be answered.
583 * @param data Userspace address of call data with the answer.
584 *
585 * @return 0 on success, otherwise an error code.
[8b243f2]586 *
587 */
[96b02eb9]588sysarg_t sys_ipc_answer_slow(sysarg_t callid, ipc_data_t *data)
[2d5a54f3]589{
[897f2e76]590 /* Do not answer notification callids */
591 if (callid & IPC_CALLID_NOTIFICATION)
592 return 0;
[da1bafb]593
594 call_t *call = get_call(callid);
[2ba7810]595 if (!call)
596 return ENOENT;
[da1bafb]597
598 ipc_data_t saved_data;
599 bool saved;
600
[9f22213]601 if (answer_need_old(call)) {
[2ba7810]602 memcpy(&saved_data, &call->data, sizeof(call->data));
[da1bafb]603 saved = true;
604 } else
605 saved = false;
606
607 int rc = copy_from_uspace(&call->data.args, &data->args,
[51ec40f]608 sizeof(call->data.args));
[e3c762cd]609 if (rc != 0)
610 return rc;
[da1bafb]611
612 rc = answer_preprocess(call, saved ? &saved_data : NULL);
[2d5a54f3]613
614 ipc_answer(&TASK->answerbox, call);
[7c23af9]615 return rc;
[2d5a54f3]616}
617
[8b243f2]618/** Hang up a phone.
[2d5a54f3]619 *
[da1bafb]620 * @param Phone handle of the phone to be hung up.
621 *
622 * @return 0 on success or an error code.
[8b243f2]623 *
[fbcfd458]624 */
[96b02eb9]625sysarg_t sys_ipc_hangup(sysarg_t phoneid)
[fbcfd458]626{
627 phone_t *phone;
[da1bafb]628
[c9fff17]629 if (phone_get(phoneid, &phone) != EOK)
630 return ENOENT;
[da1bafb]631
[d8f7362]632 if (ipc_phone_hangup(phone))
[fbcfd458]633 return -1;
[da1bafb]634
[fbcfd458]635 return 0;
636}
637
[8b243f2]638/** Wait for an incoming IPC call or an answer.
[fbcfd458]639 *
[da1bafb]640 * @param calldata Pointer to buffer where the call/answer data is stored.
641 * @param usec Timeout. See waitq_sleep_timeout() for explanation.
642 * @param flags Select mode of sleep operation. See waitq_sleep_timeout()
643 * for explanation.
644 *
645 * @return Hash of the call.
646 * If IPC_CALLID_NOTIFICATION bit is set in the hash, the
647 * call is a notification. IPC_CALLID_ANSWERED denotes an
648 * answer.
[bd5a663]649 *
[2d5a54f3]650 */
[96b02eb9]651sysarg_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
[da1bafb]652 unsigned int flags)
[2d5a54f3]653{
654 call_t *call;
[da1bafb]655
[741fd16]656restart:
[da1bafb]657
[741fd16]658#ifdef CONFIG_UDEBUG
659 udebug_stoppable_begin();
[da1bafb]660#endif
661
[51ec40f]662 call = ipc_wait_for_call(&TASK->answerbox, usec,
663 flags | SYNCH_FLAGS_INTERRUPTIBLE);
[da1bafb]664
[741fd16]665#ifdef CONFIG_UDEBUG
666 udebug_stoppable_end();
667#endif
[da1bafb]668
[9f22213]669 if (!call)
670 return 0;
[da1bafb]671
[5626277]672 if (call->flags & IPC_CALL_NOTIF) {
[43752b6]673 /* Set in_phone_hash to the interrupt counter */
[0c1a5d8a]674 call->data.phone = (void *) call->priv;
[43752b6]675
676 STRUCT_TO_USPACE(calldata, &call->data);
[da1bafb]677
[5626277]678 ipc_call_free(call);
679
[96b02eb9]680 return ((sysarg_t) call) | IPC_CALLID_NOTIFICATION;
[5626277]681 }
[da1bafb]682
[2d5a54f3]683 if (call->flags & IPC_CALL_ANSWERED) {
[7c7aae16]684 process_answer(call);
[da1bafb]685
[fbcfd458]686 if (call->flags & IPC_CALL_DISCARD_ANSWER) {
687 ipc_call_free(call);
688 goto restart;
689 }
[da1bafb]690
[fbcfd458]691 STRUCT_TO_USPACE(&calldata->args, &call->data.args);
[2d5a54f3]692 ipc_call_free(call);
[da1bafb]693
[96b02eb9]694 return ((sysarg_t) call) | IPC_CALLID_ANSWERED;
[2d5a54f3]695 }
[da1bafb]696
[2d5a54f3]697 if (process_request(&TASK->answerbox, call))
698 goto restart;
[da1bafb]699
[7c7aae16]700 /* Include phone address('id') of the caller in the request,
701 * copy whole call->data, not only call->data.args */
[bd55bbb]702 if (STRUCT_TO_USPACE(calldata, &call->data)) {
[e06da7e]703 /*
704 * The callee will not receive this call and no one else has
705 * a chance to answer it. Reply with the EPARTY error code.
[b11ee88]706 */
[e06da7e]707 ipc_data_t saved_data;
[da1bafb]708 bool saved;
709
[e06da7e]710 if (answer_need_old(call)) {
711 memcpy(&saved_data, &call->data, sizeof(call->data));
[da1bafb]712 saved = true;
713 } else
714 saved = false;
[e06da7e]715
716 IPC_SET_RETVAL(call->data, EPARTY);
[da1bafb]717 (void) answer_preprocess(call, saved ? &saved_data : NULL);
[e06da7e]718 ipc_answer(&TASK->answerbox, call);
[bd55bbb]719 return 0;
720 }
[da1bafb]721
[96b02eb9]722 return (sysarg_t) call;
[2d5a54f3]723}
[5626277]724
[da1bafb]725/** Interrupt one thread from sys_ipc_wait_for_call().
726 *
727 */
[96b02eb9]728sysarg_t sys_ipc_poke(void)
[057d21a]729{
[da1bafb]730 waitq_unsleep(&TASK->answerbox.wq);
[057d21a]731 return EOK;
732}
733
[8b243f2]734/** Connect an IRQ handler to a task.
[2b017ba]735 *
[228e490]736 * @param inr IRQ number.
737 * @param devno Device number.
738 * @param imethod Interface and method to be associated with the notification.
739 * @param ucode Uspace pointer to the top-half pseudocode.
[da1bafb]740 *
741 * @return EPERM or a return code returned by ipc_irq_register().
[2b017ba]742 *
743 */
[f044e96]744sysarg_t sys_irq_register(inr_t inr, devno_t devno, sysarg_t imethod,
[51ec40f]745 irq_code_t *ucode)
[5626277]746{
[2bb8648]747 if (!(cap_get(TASK) & CAP_IRQ_REG))
748 return EPERM;
[da1bafb]749
[228e490]750 return ipc_irq_register(&TASK->answerbox, inr, devno, imethod, ucode);
[5626277]751}
752
[8b243f2]753/** Disconnect an IRQ handler from a task.
754 *
[da1bafb]755 * @param inr IRQ number.
756 * @param devno Device number.
757 *
758 * @return Zero on success or EPERM on error.
[2b017ba]759 *
760 */
[f044e96]761sysarg_t sys_irq_unregister(inr_t inr, devno_t devno)
[5626277]762{
[2bb8648]763 if (!(cap_get(TASK) & CAP_IRQ_REG))
764 return EPERM;
[da1bafb]765
[2b017ba]766 ipc_irq_unregister(&TASK->answerbox, inr, devno);
[da1bafb]767
[5626277]768 return 0;
769}
[b45c443]770
[6b10dab]771#ifdef __32_BITS__
[9a1b20c]772
[6b10dab]773/** Syscall connect to a task by ID (32 bits)
[da1bafb]774 *
775 * @return Phone id on success, or negative error code.
[9a1b20c]776 *
777 */
[6b10dab]778sysarg_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid)
[9a1b20c]779{
780#ifdef CONFIG_UDEBUG
[6b10dab]781 sysarg64_t taskid;
782 int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
[9a1b20c]783 if (rc != 0)
[96b02eb9]784 return (sysarg_t) rc;
[da1bafb]785
[6b10dab]786 return ipc_connect_kbox((task_id_t) taskid);
[9a1b20c]787#else
[96b02eb9]788 return (sysarg_t) ENOTSUP;
[9a1b20c]789#endif
790}
791
[6b10dab]792#endif /* __32_BITS__ */
793
794#ifdef __64_BITS__
795
796/** Syscall connect to a task by ID (64 bits)
797 *
798 * @return Phone id on success, or negative error code.
799 *
800 */
801sysarg_t sys_ipc_connect_kbox(sysarg_t taskid)
802{
803#ifdef CONFIG_UDEBUG
804 return ipc_connect_kbox((task_id_t) taskid);
805#else
806 return (sysarg_t) ENOTSUP;
807#endif
808}
809
810#endif /* __64_BITS__ */
811
[cc73a8a1]812/** @}
[b45c443]813 */
Note: See TracBrowser for help on using the repository browser.