Changeset 2d5a54f3 in mainline for generic/src/syscall/syscall.c


Ignore:
Timestamp:
2006-03-16T00:25:50Z (19 years ago)
Author:
Ondrej Palkovsky <ondrap@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2fb49101
Parents:
c23502d
Message:

Implemented callback IPC call (connect_to_me).

File:
1 edited

Legend:

Unmodified
Added
Removed

  • generic/src/syscall/syscall.c

    rc23502d r2d5a54f3  
    3232#include <print.h>
    3333#include <putchar.h>
    34 #include <ipc/ipc.h>
    3534#include <errno.h>
    3635#include <proc/task.h>
    3736#include <arch.h>
    3837#include <debug.h>
     38#include <ipc/sysipc.h>
    3939
    4040static __native sys_ctl(void) {
    … …  
    5757}
    5858
    59 static phone_t * get_phone(__native phoneid)
    60 {
    61         phone_t *phone;
    62 
    63         if (phoneid >= IPC_MAX_PHONES)
    64                 return NULL;
    65 
    66         phone = &TASK->phones[phoneid];
    67         if (!phone->callee)
    68                 return NULL;
    69         return phone;
    70 }
    71 
    72 /** Send a call over IPC, wait for reply, return to user
    73  *
    74  * @return Call identification, returns -1 on fatal error,
    75            -2 on 'Too many async request, handle answers first
    76  */
    77 static __native sys_ipc_call_sync_fast(__native phoneid, __native method,
    78                                        __native arg1, __native *data)
    79 {
    80         call_t call;
    81         phone_t *phone;
    82         /* Special answerbox for synchronous messages */
    83 
    84         phone = get_phone(phoneid);
    85         if (!phone)
    86                 return IPC_CALLRET_FATAL;
    87 
    88         ipc_call_init(&call);
    89         IPC_SET_METHOD(call.data, method);
    90         IPC_SET_ARG1(call.data, arg1);
    91        
    92         ipc_call_sync(phone, &call);
    93 
    94         copy_to_uspace(data, &call.data, sizeof(call.data));
    95 
    96         return 0;
    97 }
    98 
    99 /** Synchronous IPC call allowing to send whole message */
    100 static __native sys_ipc_call_sync(__native phoneid, __native *question,
    101                                   __native *reply)
    102 {
    103         call_t call;
    104         phone_t *phone;
    105         /* Special answerbox for synchronous messages */
    106 
    107         phone = get_phone(phoneid);
    108         if (!phone)
    109                 return IPC_CALLRET_FATAL;
    110 
    111         ipc_call_init(&call);
    112         copy_from_uspace(&call.data, question, sizeof(call.data));
    113        
    114         ipc_call_sync(phone, &call);
    115 
    116         copy_to_uspace(reply, &call.data, sizeof(call.data));
    117 
    118         return 0;
    119 }
    120 
    121 /** Check that the task did not exceed allowed limit
    122  *
    123  * @return 0 - Limit OK,   -1 - limit exceeded
    124  */
    125 static int check_call_limit(void)
    126 {
    127         if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
    128                 atomic_dec(&TASK->active_calls);
    129                 return -1;
    130         }
    131         return 0;
    132 }
    133 
    134 /** Send an asynchronous call over ipc
    135  *
    136  * @return Call identification, returns -1 on fatal error,
    137            -2 on 'Too many async request, handle answers first
    138  */
    139 static __native sys_ipc_call_async_fast(__native phoneid, __native method,
    140                                         __native arg1, __native arg2)
    141 {
    142         call_t *call;
    143         phone_t *phone;
    144 
    145         phone = get_phone(phoneid);
    146         if (!phone)
    147                 return IPC_CALLRET_FATAL;
    148 
    149         if (check_call_limit())
    150                 return IPC_CALLRET_TEMPORARY;
    151 
    152         call = ipc_call_alloc();
    153         IPC_SET_METHOD(call->data, method);
    154         IPC_SET_ARG1(call->data, arg1);
    155         IPC_SET_ARG2(call->data, arg2);
    156 
    157         ipc_call(phone, call);
    158 
    159         return (__native) call;
    160 }
    161 
    162 /** Synchronous IPC call allowing to send whole message
    163  *
    164  * @return The same as sys_ipc_call_async
    165  */
    166 static __native sys_ipc_call_async(__native phoneid, __native *data)
    167 {
    168         call_t *call;
    169         phone_t *phone;
    170 
    171         phone = get_phone(phoneid);
    172         if (!phone)
    173                 return IPC_CALLRET_FATAL;
    174 
    175         if (check_call_limit())
    176                 return IPC_CALLRET_TEMPORARY;
    177 
    178         call = ipc_call_alloc();
    179         copy_from_uspace(&call->data, data, sizeof(call->data));
    180        
    181         ipc_call(phone, call);
    182 
    183         return (__native) call;
    184 }
    185 
    186 
    187 /** Send IPC answer */
    188 static __native sys_ipc_answer_fast(__native callid, __native retval,
    189                                     __native arg1, __native arg2)
    190 {
    191         call_t *call;
    192 
    193         /* Check that the user is not sending us answer callid */
    194         ASSERT(! (callid & 1));
    195         /* TODO: Check that the callid is in the dispatch table */
    196         call = (call_t *) callid;
    197 
    198         IPC_SET_RETVAL(call->data, retval);
    199         IPC_SET_ARG1(call->data, arg1);
    200         IPC_SET_ARG2(call->data, arg2);
    201 
    202         ipc_answer(&TASK->answerbox, call);
    203         return 0;
    204 }
    205 
    206 /** Send IPC answer */
    207 static __native sys_ipc_answer(__native callid, __native *data)
    208 {
    209         call_t *call;
    210 
    211         /* Check that the user is not sending us answer callid */
    212         ASSERT(! (callid & 1));
    213         /* TODO: Check that the callid is in the dispatch table */
    214         call = (call_t *) callid;
    215         copy_from_uspace(&call->data, data, sizeof(call->data));
    216         ipc_answer(&TASK->answerbox, call);
    217 
    218         return 0;
    219 }
    220 
    221 /** Wait for incoming ipc call or answer
    222  *
    223  * @param result
    224  * @param flags
    225  * @return Callid, if callid & 1, then the call is answer
    226  */
    227 static __native sys_ipc_wait_for_call(__native *calldata, task_id_t *taskid,
    228                                       __native flags)
    229 {
    230         call_t *call;
    231        
    232         call = ipc_wait_for_call(&TASK->answerbox, flags);
    233 
    234         copy_to_uspace(calldata, &call->data, sizeof(call->data));
    235 
    236         if (call->flags & IPC_CALL_ANSWERED) {
    237                 ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
    238                 ipc_call_free(call);
    239                 atomic_dec(&TASK->active_calls);
    240                 return ((__native)call) | IPC_CALLID_ANSWERED;
    241         }
    242         copy_to_uspace(taskid, (void *)&TASK->taskid, sizeof(TASK->taskid));
    243         return (__native)call;
    244 }
    24559
    24660static __native sys_mremap(void *address, size_t size, unsigned long flags)
    … …  
    25973        sys_ipc_answer_fast,
    26074        sys_ipc_answer,
    261         sys_ipc_wait_for_call
     75        sys_ipc_wait_for_call,
     76        sys_ipc_connect_to_me
    26277};
Note: See TracChangeset for help on using the changeset viewer.