WebSVN – HelenOS – Diff – /branches/sparc/kernel/generic/src/ipc/sysipc.c

 #include <print.h>
 #include <arch.h>
 #include <proc/thread.h>
-/* TODO: multi-threaded connect-to-me can cause race condition
- * on phone, add counter + thread_kill??
- *
- */
 #define GET_CHECK_PHONE(phone,phoneid,err) { \
       if (phoneid > IPC_MAX_PHONES) { err; } \
       phone = &TASK->phones[phoneid]; \
+}
+#define STRUCT_TO_USPACE(dst,src) copy_to_uspace(dst,src,sizeof(*src))
 /** Return true if the method is a system method */
 static inline int is_system_method(__native method)
+{
     if (method <= IPC_M_LAST_SYSTEM)
  * - some system messages may be forwarded, for some of them
  *   it is useless
  */
 static inline int is_forwardable(__native method)
+{
+    if (method == IPC_M_PHONE_HUNGUP)
+        return 0; /* This message is meant only for the receiver */
     return 1;
+}
 /****************************************************/
 /* Functions that preprocess answer before sending
 /** Return true if the caller (ipc_answer) should save
  * the old call contents and call answer_preprocess
  */
 static inline int answer_will_preprocess(call_t *call)
+{
-    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECTTOME)
+    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
         return 1;
-    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECTMETO)
+    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_ME_TO)
         return 1;
     return 0;
+}
 /** Interpret process answer as control information */
 static inline void answer_preprocess(call_t *answer, ipc_data_t *olddata)
+{
     int phoneid;
-    if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECTTOME) {
+    if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
         phoneid = IPC_GET_ARG3(*olddata);
         if (IPC_GET_RETVAL(answer->data)) {
             /* The connection was not accepted */
             phone_dealloc(phoneid);
         } else {
             /* The connection was accepted */
             phone_connect(phoneid,&answer->sender->answerbox);
+        }
-    } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECTMETO) {
+    } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
         /* If the users accepted call, connect */
         if (!IPC_GET_RETVAL(answer->data)) {
             ipc_phone_connect((phone_t *)IPC_GET_ARG3(*olddata),
                       &TASK->answerbox);
+        }
  */
 static int process_request(answerbox_t *box,call_t *call)
+{
     int phoneid;
-    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECTTOME) {
+    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME) {
         phoneid = phone_alloc();
         if (phoneid < 0) { /* Failed to allocate phone */
             IPC_SET_RETVAL(call->data, ELIMIT);
             ipc_answer(box,call);
             return -1;
+ *
  * @return Call identification, returns -1 on fatal error,
            -2 on 'Too many async request, handle answers first
  */
 __native sys_ipc_call_sync_fast(__native phoneid, __native method,
-                __native arg1, __native *data)
+                __native arg1, ipc_data_t *data)
+{
     call_t call;
     phone_t *phone;
     if (is_system_method(method))
     IPC_SET_METHOD(call.data, method);
     IPC_SET_ARG1(call.data, arg1);
     ipc_call_sync(phone, &call);
-    copy_to_uspace(data, &call.data, sizeof(call.data));
+    STRUCT_TO_USPACE(&data->args, &call.data.args);
     return 0;
+}
 /** Synchronous IPC call allowing to send whole message */
-__native sys_ipc_call_sync(__native phoneid, __native *question,
+__native sys_ipc_call_sync(__native phoneid, ipc_data_t *question,
-               __native *reply)
+               ipc_data_t *reply)
+{
     call_t call;
     phone_t *phone;
     ipc_call_static_init(&call);
-    copy_from_uspace(&call.data, question, sizeof(call.data));
+    copy_from_uspace(&call.data.args, &question->args, sizeof(call.data.args));
     if (is_system_method(IPC_GET_METHOD(call.data)))
         return EPERM;
     GET_CHECK_PHONE(phone, phoneid, return ENOENT);
     ipc_call_sync(phone, &call);
-    copy_to_uspace(reply, &call.data, sizeof(call.data));
+    STRUCT_TO_USPACE(&reply->args, &call.data.args);
     return 0;
+}
 /** Check that the task did not exceed allowed limit
 /** Synchronous IPC call allowing to send whole message
+ *
  * @return The same as sys_ipc_call_async
  */
-__native sys_ipc_call_async(__native phoneid, __native *data)
+__native sys_ipc_call_async(__native phoneid, ipc_data_t *data)
+{
     call_t *call;
     phone_t *phone;
     if (check_call_limit())
         return IPC_CALLRET_TEMPORARY;
     GET_CHECK_PHONE(phone, phoneid, return ENOENT);
     call = ipc_call_alloc();
-    copy_from_uspace(&call->data, data, sizeof(call->data));
+    copy_from_uspace(&call->data.args, &data->args, sizeof(call->data.args));
     if (is_system_method(IPC_GET_METHOD(call->data))) {
         ipc_call_free(call);
         return EPERM;
+    }
     ipc_answer(&TASK->answerbox, call);
     return 0;
+}
 /** Send IPC answer */
-inline __native sys_ipc_answer(__native callid, __native *data)
+__native sys_ipc_answer(__native callid, ipc_data_t *data)
+{
     call_t *call;
     ipc_data_t saved_data;
     int preprocess = 0;
     if (answer_will_preprocess(call)) {
         memcpy(&saved_data, &call->data, sizeof(call->data));
         preprocess = 1;
+    }
-    copy_from_uspace(&call->data, data, sizeof(call->data));
+    copy_from_uspace(&call->data.args, &data->args,
+             sizeof(call->data.args));
     if (preprocess)
         answer_preprocess(call, &saved_data);
     ipc_answer(&TASK->answerbox, call);
+{
     call_t call;
     phone_t *phone;
     ipc_call_static_init(&call);
-    IPC_SET_METHOD(call.data, IPC_M_CONNECTTOME);
+    IPC_SET_METHOD(call.data, IPC_M_CONNECT_TO_ME);
     IPC_SET_ARG1(call.data, arg1);
     IPC_SET_ARG2(call.data, arg2);
     GET_CHECK_PHONE(phone, phoneid, return ENOENT);
     ipc_call_sync(phone, &call);
     if (!IPC_GET_RETVAL(call.data) && taskid)
-        copy_to_uspace(taskid,
-                   &phone->callee->task->taskid,
+        STRUCT_TO_USPACE(taskid, &phone->callee->task->taskid);
-                   sizeof(TASK->taskid));
     return IPC_GET_RETVAL(call.data);
+}
 /** Ask target process to connect me somewhere
     newphid = phone_alloc();
     if (newphid < 0)
         return ELIMIT;
     ipc_call_static_init(&call);
-    IPC_SET_METHOD(call.data, IPC_M_CONNECTMETO);
+    IPC_SET_METHOD(call.data, IPC_M_CONNECT_ME_TO);
     IPC_SET_ARG1(call.data, arg1);
     IPC_SET_ARG2(call.data, arg2);
     IPC_SET_ARG3(call.data, (__native)&TASK->phones[newphid]);
     ipc_call_sync(phone, &call);
+    }
     return newphid;
+}
-/** Wait for incoming ipc call or answer
+/** Hang up the phone
+ *
- * Generic function - can serve either as inkernel or userspace call
- * - inside kernel does probably unnecessary copying of data (TODO)
+ *
+ *
+ */
+__native sys_ipc_hangup(int phoneid)
+{
- * @param result
+    phone_t *phone;
+    GET_CHECK_PHONE(phone, phoneid, return ENOENT);
+    if (ipc_phone_hangup(phone))
+        return -1;
+    return 0;
+}
+/** Wait for incoming ipc call or answer
+ *
+ * @param calldata Pointer to buffer where the call/answer data is stored
+ * @param taskid On 'CONNECT_ME_TO' call it is filled with 'taskid' of
- * @param taskid
+ *               the caller.
  * @param flags
  * @return Callid, if callid & 1, then the call is answer
  */
-inline __native sys_ipc_wait_for_call(ipc_data_t *calldata,
+__native sys_ipc_wait_for_call(ipc_data_t *calldata, task_id_t *taskid,
-                      task_id_t *taskid,
-                      __native flags)
+                   __native flags)
+{
     call_t *call;
 restart:
     if (call->flags & IPC_CALL_ANSWERED) {
         if (process_answer(&TASK->answerbox, call))
             goto restart;
-        copy_to_uspace(calldata, &call->data, sizeof(call->data));
-        atomic_dec(&TASK->active_calls);
         ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
+        atomic_dec(&TASK->active_calls);
+        if (call->flags & IPC_CALL_DISCARD_ANSWER) {
+            ipc_call_free(call);
+            goto restart;
+        }
+        STRUCT_TO_USPACE(&calldata->args, &call->data.args);
         ipc_call_free(call);
         return ((__native)call) | IPC_CALLID_ANSWERED;
+    }
     if (process_request(&TASK->answerbox, call))
         goto restart;
+    /* Include phone address('id') of the caller in the request */
-    copy_to_uspace(calldata, &call->data, sizeof(call->data));
+    STRUCT_TO_USPACE(calldata, &call->data);
+    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_ME_TO)
-    copy_to_uspace(taskid, (void *)&TASK->taskid, sizeof(TASK->taskid));
+        STRUCT_TO_USPACE(taskid, &TASK->taskid);
     return (__native)call;
+}

Subversion Repositories HelenOS

(root)/branches/sparc/kernel/generic/src/ipc/sysipc.c @ 3863 – Rev 1084 → 1086