Merge branch 'net-dev'. See body of commit for details.
[akaros.git] / kern / src / syscall.c
index 569bd71..e5b270d 100644 (file)
@@ -1,10 +1,14 @@
 /* See COPYRIGHT for copyright information. */
 
+#ifdef __SHARC__
+#pragma nosharc
+#endif
+
 #ifdef __DEPUTY__
 #pragma nodeputy
 #endif
 
-
+#include <ros/common.h>
 #include <arch/types.h>
 #include <arch/arch.h>
 #include <arch/mmu.h>
@@ -62,6 +66,10 @@ static ssize_t sys_serial_read(env_t* e, char *DANGEROUS _buf, size_t len)
        #endif
 }
 
+//
+/* START OF REMOTE SYSTEMCALL SUPPORT SYSCALLS. THESE WILL GO AWAY AS THINGS MATURE */
+//
+
 static ssize_t sys_run_binary(env_t* e, void *binary_buf, void* arg, size_t len) {
        uint8_t* new_binary = kmalloc(len, 0);
        if(new_binary == NULL)
@@ -77,7 +85,8 @@ static ssize_t sys_run_binary(env_t* e, void *binary_buf, void* arg, size_t len)
        return 0;
 }
 
-// This is probably not a syscall we want. Its hacky. Here just for syscall stuff until get a stack.
+
+// This is not a syscall we want. Its hacky. Here just for syscall stuff until get a stack.
 static ssize_t sys_eth_write(env_t* e, const char *DANGEROUS buf, size_t len) 
 { 
        extern int eth_up;
@@ -108,23 +117,8 @@ static ssize_t sys_eth_write(env_t* e, const char *DANGEROUS buf, size_t len)
        else
                return -EINVAL;
 }
-/*
-static ssize_t sys_eth_write(env_t* e, const char *DANGEROUS buf, size_t len) 
-{ 
-       extern int eth_up;
-       
-       if (eth_up) {
-               
-               char *COUNT(len) _buf = user_mem_assert(e, buf, len, PTE_U);
-               
-               return(send_frame(buf, len));
-       }
-       return -EINVAL;
-}
-*/
 
-
-// This is probably not a syscall we want. Its hacky. Here just for syscall stuff until get a stack.
+// This is not a syscall we want. Its hacky. Here just for syscall stuff until get a stack.
 static ssize_t sys_eth_read(env_t* e, char *DANGEROUS buf, size_t len) 
 {
        extern int eth_up;
@@ -156,6 +150,10 @@ static ssize_t sys_eth_read(env_t* e, char *DANGEROUS buf, size_t len)
                return -EINVAL;
 }
 
+//
+/* END OF REMOTE SYSTEMCALL SUPPORT SYSCALLS. */
+//
+
 static ssize_t sys_shared_page_alloc(env_t* p1,
                                      void**DANGEROUS _addr, envid_t p2_id,
                                      int p1_flags, int p2_flags
@@ -415,8 +413,8 @@ static error_t sys_proc_run(struct proc *p, unsigned pid)
 
 // TODO: Build a dispatch table instead of switching on the syscallno
 // Dispatches to the correct kernel function, passing the arguments.
-intreg_t syscall(env_t* e, uint32_t syscallno, uint32_t a1, uint32_t a2,
-                 uint32_t a3, uint32_t a4, uint32_t a5)
+intreg_t syscall(env_t* e, uintreg_t syscallno, uintreg_t a1, uintreg_t a2,
+                 uintreg_t a3, uintreg_t a4, uintreg_t a5)
 {
        // Call the function corresponding to the 'syscallno' parameter.
        // Return any appropriate return value.
@@ -425,6 +423,9 @@ intreg_t syscall(env_t* e, uint32_t syscallno, uint32_t a1, uint32_t a2,
        //        " a2: %x\n    a3: %x\n    a4: %x\n    a5: %x\n",
        //        syscallno, a1, a2, a3, a4, a5);
 
+       // used if we need more args, like in mmap
+       int32_t _a4, _a5, _a6, *COUNT(3) args;
+
        assert(e); // should always have an env for every syscall
        //printk("Running syscall: %d\n", syscallno);
        if (INVALID_SYSCALL(syscallno))
@@ -434,13 +435,6 @@ intreg_t syscall(env_t* e, uint32_t syscallno, uint32_t a1, uint32_t a2,
                case SYS_null:
                        sys_null();
                        return ESUCCESS;
-               case SYS_run_binary:
-                       return sys_run_binary(e, (char *DANGEROUS)a1, 
-                                             (char* DANGEROUS)a2, (size_t)a3);
-               case SYS_eth_write:
-                       return sys_eth_write(e, (char *DANGEROUS)a1, (size_t)a2);
-               case SYS_eth_read:
-                       return sys_eth_read(e, (char *DANGEROUS)a1, (size_t)a2);        
                case SYS_cache_buster:
                        sys_cache_buster(e, a1, a2, a3);
                        return 0;
@@ -470,12 +464,32 @@ intreg_t syscall(env_t* e, uint32_t syscallno, uint32_t a1, uint32_t a2,
                        return sys_proc_create(e, (char *DANGEROUS)a1);
                case SYS_proc_run:
                        return sys_proc_run(e, (size_t)a1);
+               case SYS_mmap:
+                       // we only have 4 parameters from sysenter currently, need to copy
+                       // in the others.  if we stick with this, we can make a func for it.
+               args = user_mem_assert(e, (void*DANGEROUS)a4,
+                                              3*sizeof(_a4), PTE_USER_RW);
+                       _a4 = args[0];
+                       _a5 = args[1];
+                       _a6 = args[2];
+                       return (intreg_t) mmap(e, a1, a2, a3, _a4, _a5, _a6);
+               case SYS_brk:
+                       printk("brk not implemented yet\n");
+                       return -EINVAL;
 
        #ifdef __i386__
                case SYS_serial_write:
                        return sys_serial_write(e, (char *DANGEROUS)a1, (size_t)a2);
                case SYS_serial_read:
                        return sys_serial_read(e, (char *DANGEROUS)a1, (size_t)a2);
+                case SYS_run_binary:
+                        return sys_run_binary(e, (char *DANGEROUS)a1,
+                                              (char* DANGEROUS)a2, (size_t)a3);
+                case SYS_eth_write:
+                        return sys_eth_write(e, (char *DANGEROUS)a1, (size_t)a2);
+                case SYS_eth_read:
+                        return sys_eth_read(e, (char *DANGEROUS)a1, (size_t)a2);
+
        #endif
 
        #ifdef __sparc_v8__
@@ -516,8 +530,8 @@ intreg_t process_generic_syscalls(env_t* e, size_t max)
                        lcr3(e->env_cr3);
                }
                count++;
-               //printk("DEBUG PRE: sring->req_prod: %d, sring->rsp_prod: %d\n",\
-                          sysbr->sring->req_prod, sysbr->sring->rsp_prod);
+               //printk("DEBUG PRE: sring->req_prod: %d, sring->rsp_prod: %d\n",
+               //         sysbr->sring->req_prod, sysbr->sring->rsp_prod);
                // might want to think about 0-ing this out, if we aren't
                // going to explicitly fill in all fields
                syscall_rsp_t rsp;
@@ -529,8 +543,8 @@ intreg_t process_generic_syscalls(env_t* e, size_t max)
                // update our counter for what we've produced (assumes we went in order!)
                (sysbr->rsp_prod_pvt)++;
                RING_PUSH_RESPONSES(sysbr);
-               //printk("DEBUG POST: sring->req_prod: %d, sring->rsp_prod: %d\n",\
-                          sysbr->sring->req_prod, sysbr->sring->rsp_prod);
+               //printk("DEBUG POST: sring->req_prod: %d, sring->rsp_prod: %d\n",
+               //         sysbr->sring->req_prod, sysbr->sring->rsp_prod);
        }
        // load sane page tables (and don't rely on decref to do it for you).
        lcr3(boot_cr3);