Changeset 6d9c49a in mainline for generic

Timestamp:

2006-03-13T19:39:30Z (20 years ago)

Author:

Ondrej Palkovsky <ondrap@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

45d6add

Parents:

78a95d6f

Message:

Added kernel IPC functionality.

Location:

generic

Files:

• include/errno.h (added)
• include/ipc/ipc.h (added)
• include/mm/page.h (modified) (2 diffs)
• include/proc/task.h (modified) (2 diffs)
• include/syscall/syscall.h (modified) (1 diff)
• src/ipc/ipc.c (added)
• src/main/kinit.c (modified) (1 diff)
• src/main/main.c (modified) (2 diffs)
• src/proc/task.c (modified) (2 diffs)
• src/syscall/syscall.c (modified) (3 diffs)

generic/include/mm/page.h

@@ -33 +33 @@
 #include <arch/types.h>
 #include <typedefs.h>
+#include <memstr.h>
 
 #define PAGE_CACHEABLE_SHIFT            0
@@ -60 +61 @@
 #define PAGE_GLOBAL             (1<<PAGE_GLOBAL_SHIFT)
 
+
+/* TODO - check that userspace is OK, platform specific functions etc */
+static inline void copy_to_uspace(void *dst, void *src, count_t cnt)
+{
+        memcpy(dst, src, cnt);
+} 
+
+static inline void copy_to_kernel(void *dst, void *src, count_t cnt)
+{
+        memcpy(dst, src, cnt);
+}
+
 /** Operations to manipulate page mappings. */
 struct page_mapping_operations {

generic/include/proc/task.h

@@ -33 +33 @@
 #include <synch/spinlock.h>
 #include <adt/list.h>
+#include <ipc/ipc.h>
 
 /** Task structure. */
@@ -40 +41 @@
         link_t tasks_link;      /**< Link to other tasks within the system. */
         as_t *as;               /**< Address space. */
+        answerbox_t answerbox;  /**< Communication endpoint */
+        phone_t phones[IPC_MAX_PHONES];
 };
 

generic/include/syscall/syscall.h

@@ -30 +30 @@
 #define __SYSCALL_H__
 
-#include <typedefs.h>
-
 typedef enum {
         SYS_CTL = 0,
         SYS_IO  = 1,
+        SYS_IPC_CALL = 2,
+        SYS_IPC_ANSWER = 3,
+        SYS_IPC_WAIT = 4,
         SYSCALL_END
 } syscall_t;
 
-typedef int (*syshandler_t)();
+#ifdef KERNEL
 
-extern int sys_ctl(void);
-extern int sys_io(int fd, const void *buf, size_t count);
+#include <arch/types.h>
+#include <typedefs.h>
+
+typedef __native (*syshandler_t)();
 
 extern syshandler_t syscall_table[SYSCALL_END];
 
 #endif
+
+#endif

generic/src/main/kinit.c

@@ -139 +139 @@
         interrupts_enable();
 
+        ipc_create_phonecompany();
+
         if (config.init_size > 0) {
                 /*

generic/src/main/main.c

@@ -55 +55 @@
 #include <arch/faddr.h>
 #include <typedefs.h>
+#include <ipc/ipc.h>
 
 #ifdef CONFIG_SMP
@@ -191 +192 @@
         if (config.init_size > 0)
                 printf("config.init_addr=%P, config.init_size=%d\n", config.init_addr, config.init_size);
-
+        
+        ipc_init();
         /*
          * Create kernel task.

generic/src/proc/task.c

@@ -36 +36 @@
 #include <panic.h>
 #include <adt/list.h>
+#include <ipc/ipc.h>
+#include <memstr.h>
 
 SPINLOCK_INITIALIZE(tasks_lock);
@@ -71 +73 @@
         list_initialize(&ta->tasks_link);
         ta->as = as;
+
+        ipc_answerbox_init(&ta->answerbox);
+        memsetb((__address)&ta->phones, sizeof(ta->phones[0])*IPC_MAX_PHONES, 0);
+        if (ipc_central_box)
+                ipc_phone_init(&ta->phones[0], ipc_central_box);
         
         ipl = interrupts_disable();

generic/src/syscall/syscall.c

@@ -31 +31 @@
 #include <print.h>
 #include <putchar.h>
+#include <ipc/ipc.h>
+#include <errno.h>
+#include <proc/task.h>
+#include <arch.h>
+#include <debug.h>
 
-int sys_ctl(void) {
+static __native sys_ctl(void) {
         printf("Thread finished\n");
         thread_exit();
@@ -39 +44 @@
 }
 
-int sys_io(int fd, const void * buf, size_t count) {
+static __native sys_io(int fd, const void * buf, size_t count) {
         
         // TODO: buf sanity checks and a lot of other stuff ...
@@ -51 +56 @@
 }
 
+/** Send a call over syscall
+ *
+ * @return Call identification, returns -1 on fatal error, 
+           -2 on 'Too many async request, handle answers first
+ */
+static __native sys_ipc_call(__native phoneid, __native arg1, __native arg2)
+{
+        call_t *call;
+        phone_t *phone;
+
+        if (phoneid >= IPC_MAX_PHONES)
+                return -ENOENT;
+
+        phone = &TASK->phones[phoneid];
+        if (!phone->callee)
+                return -ENOENT;
+
+
+        /* TODO: Check that we did not exceed system imposed maximum
+         * of asynchrnously sent messages
+         * - the userspace should be able to handle it correctly
+         */
+        call = ipc_call_alloc();
+        call->data[0] = arg1;
+        call->data[1] = arg2;
+        ipc_call(phone, call);
+
+        return (__native) call;
+}
+
+/** Send IPC answer */
+static __native sys_ipc_answer(__native callid, __native arg1, __native arg2)
+{
+        call_t *call;
+
+        /* Check that the user is not sending us answer callid */
+        ASSERT(! (callid & 1));
+        /* TODO: Check that the callid is in the dispatch table */
+        call = (call_t *) callid;
+
+        call->data[0] = arg1;
+        call->data[1] = arg2;
+
+        ipc_answer(&TASK->answerbox, call);
+        return 0;
+}
+
+/** Wait for incoming ipc call or answer
+ *
+ * @param result 
+ * @param flags
+ * @return Callid, if callid & 1, then the call is answer
+ */
+static __native sys_ipc_wait_for_call(__native *calldata, __native flags)
+{
+        call_t *call;
+        
+        call = ipc_wait_for_call(&TASK->answerbox, flags);
+        copy_to_uspace(calldata, &call->data, sizeof(__native) * IPC_CALL_LEN);
+
+        if (call->flags & IPC_CALL_ANSWERED)
+                return ((__native)call) | 1;
+        return (__native)call;
+}
+
+
 syshandler_t syscall_table[SYSCALL_END] = {
         sys_ctl,
-        sys_io
+        sys_io,
+        sys_ipc_call,
+        sys_ipc_answer,
+        sys_ipc_wait_for_call
 };