Syscalls now can take six arguments (XCC)
authorBarret Rhoden <brho@cs.berkeley.edu>
Fri, 12 Nov 2010 05:56:43 +0000 (21:56 -0800)
committerKevin Klues <klueska@cs.berkeley.edu>
Thu, 3 Nov 2011 00:35:56 +0000 (17:35 -0700)
Rebuild your cross compiler.

This also cleans up argument naming.  Specifically, we 0-index the
syscall arguments, like good little C programmers.

If someone feels productive, they can make variants (or macro magic) to
cut down on the number of arguments getting passed around for syscalls
that we know only need a few args (in userspace).

46 files changed:
kern/arch/i686/ros/syscall.h
kern/arch/sparc/ros/syscall.h
kern/include/ros/syscall.h
kern/include/syscall.h
kern/src/arsc.c
kern/src/syscall.c
tests/syscall_speed.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/_exit.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/access.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/chdir.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/chmod.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/close.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/execve.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/fcntl.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/fork.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/fxstat.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/getcwd.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/gettimeofday.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/i386/tls.h
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/kill.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/link.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/lseek.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/lxstat.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/mkdir.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/mmap.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/mprotect.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/munmap.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/open.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/read.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/readlink.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/rmdir.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/sched_yield.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/setgid.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/setuid.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/symlink.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/syscall.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/tcgetattr.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/tcsetattr.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/umask.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/unlink.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/waitpid.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/write.c
tools/compilers/gcc-glibc/glibc-2.11.1-ros/sysdeps/ros/xstat.c
user/include/sparc/vcore.h
user/include/vcore.h
user/parlib/syscall.c

index ed01c31..587ef98 100644 (file)
@@ -7,8 +7,7 @@
 
 #include <ros/arch/bits/syscall.h>
 
-static inline long __ros_arch_syscall(long _a0, long _a1, long _a2, long _a3,
-                                      long _a4, long _a5)
+static inline long __ros_arch_syscall(long _a0, long _a1)
 {
        #ifdef __CONFIG_SYSCALL_TRAP__
                return __syscall_trap(_a0, _a1);
index b902b66..9c581f7 100644 (file)
@@ -6,24 +6,19 @@
 #include <errno.h>
 
 static inline long __attribute__((always_inline))
-__ros_arch_syscall(long _num, long _a0, long _a1, long _a2, long _a3, long _a4)
+__ros_arch_syscall(long _num, long _a0)
 {
+       /* The args are slightly ghetto, but I don't want to fuck with sparc too
+        * much. */
        register long num asm("g1") = _num;
-       register long a0 asm("o0") = _a0, a1 asm("o1") = _a1;
-       register long a2 asm("o2") = _a2, a3 asm("o3") = _a3;
-       register long a4 asm("o4") = _a4;
+       register long a0 asm("o0") = _a0, a1 asm("o1") = 0;
+       register long a2 asm("o2") = 0,   a3 asm("o3") = 0;
+       register long a4 asm("o4") = 0;
 
        asm volatile("ta 8" : "=r"(a0),"=r"(a1)
                     : "r"(num),"0"(a0),"1"(a1),"r"(a2),"r"(a3),"r"(a4));
 
-       // TODO: gut errno
-       // move a1, a2 into regular variables so they're volatile across
-       // procedure calls (of which errno is one)
-       long ret = a0, err = a1;
-       if(err != 0)
-               errno = err;
-
-        return ret;
+       return ret;
 }
 
 #endif /* ifndef ROS_KERNEL */
index b4de63a..abb4d06 100644 (file)
@@ -23,11 +23,12 @@ struct syscall {
 
 #ifndef ROS_KERNEL
 
+/* TODO: make variants of __ros_syscall() based on the number of args (0 - 6) */
 /* These are simple synchronous system calls, built on top of the kernel's async
  * interface.  This version makes no assumptions about errno.  You usually don't
  * want this. */
-static inline long __ros_syscall(long _num, long _a0, long _a1, long _a2,
-                                 long _a3, long _a4, int *errno_loc)
+static inline long __ros_syscall(unsigned int _num, long _a0, long _a1, long _a2,
+                                 long _a3, long _a4, long _a5, int *errno_loc)
 {
        int num_started;
        struct syscall sysc = {0};
@@ -37,8 +38,8 @@ static inline long __ros_syscall(long _num, long _a0, long _a1, long _a2,
        sysc.arg2 = _a2;
        sysc.arg3 = _a3;
        sysc.arg4 = _a4;
-       // TODO: arg5
-       num_started = __ros_arch_syscall(&sysc, 1, 0, 0, 0, 0);
+       sysc.arg5 = _a5;
+       num_started = __ros_arch_syscall(&sysc, 1);
        while (!(sysc.flags & SC_DONE))
                cpu_relax();
        if (errno_loc)
@@ -49,16 +50,16 @@ static inline long __ros_syscall(long _num, long _a0, long _a1, long _a2,
 #include <errno.h>
 
 /* This version knows about errno and will handle it. */
-static inline long __ros_syscall_errno(long _num, long _a0, long _a1, long _a2,
-                                       long _a3, long _a4)
+static inline long __ros_syscall_errno(unsigned int _num, long _a0, long _a1,
+                                       long _a2, long _a3, long _a4, long _a5)
 {
-       return __ros_syscall(_num, _a0, _a1, _a2, _a3, _a4, &errno);
+       return __ros_syscall(_num, _a0, _a1, _a2, _a3, _a4, _a5, &errno);
 }
 
 /* Convenience wrapper for __ros_syscall */
-#define ros_syscall(which,a0,a1,a2,a3,a4) \
+#define ros_syscall(which, a0, a1, a2, a3, a4, a5) \
    __ros_syscall_errno(which, (long)(a0), (long)(a1), (long)(a2), (long)(a3), \
-                       (long)(a4))
+                       (long)(a4), (long)(a5))
 
 #endif /* ifndef ROS_KERNEL */
 
index 4f989ed..0ca7a37 100644 (file)
@@ -20,6 +20,7 @@
 struct systrace_record {
        uint64_t                timestamp;
        uintreg_t               syscallno;
+       uintreg_t               arg0;
        uintreg_t               arg1;
        uintreg_t               arg2;
        uintreg_t               arg3;
@@ -32,7 +33,7 @@ struct systrace_record {
 
 /* Syscall table */
 typedef intreg_t (*syscall_t)(struct proc *, uintreg_t, uintreg_t, uintreg_t,
-                              uintreg_t, uintreg_t);
+                              uintreg_t, uintreg_t, uintreg_t);
 struct sys_table_entry {
        syscall_t call;
        char *name;
@@ -40,8 +41,8 @@ struct sys_table_entry {
 const static struct sys_table_entry syscall_table[];
 /* Syscall invocation */
 void prep_syscalls(struct proc *p, struct syscall *sysc, unsigned int nr_calls);
-intreg_t syscall(struct proc *p, uintreg_t num, uintreg_t a1, uintreg_t a2,
-                 uintreg_t a3, uintreg_t a4, uintreg_t a5);
+intreg_t syscall(struct proc *p, uintreg_t sc_num, uintreg_t a0, uintreg_t a1,
+                 uintreg_t a2, uintreg_t a3, uintreg_t a4, uintreg_t a5);
 void run_local_syscall(void);
 void set_errno(int errno);
 
index 6550b24..5c1a98e 100644 (file)
@@ -29,7 +29,7 @@ spinlock_t arsc_proc_lock = SPINLOCK_INITIALIZER;
 intreg_t inline syscall_async(struct proc *p, syscall_req_t *call)
 {
        return syscall(p, call->num, call->args[0], call->args[1],
-                      call->args[2], call->args[3], call->args[4]);
+                      call->args[2], call->args[3], call->args[4], call->args[5]);
 }
 
 intreg_t sys_init_arsc(struct proc *p)
index c64ff86..06119a2 100644 (file)
@@ -1346,7 +1346,7 @@ const static struct sys_table_entry syscall_table[] = {
  * 
  * This syscall function is used by both local syscall and arsc, and should
  * remain oblivious of the caller. */
-intreg_t syscall(struct proc *p, uintreg_t syscallno, uintreg_t a1,
+intreg_t syscall(struct proc *p, uintreg_t sc_num, uintreg_t a0, uintreg_t a1,
                  uintreg_t a2, uintreg_t a3, uintreg_t a4, uintreg_t a5)
 {
        const int max_syscall = sizeof(syscall_table)/sizeof(syscall_table[0]);
@@ -1358,8 +1358,8 @@ intreg_t syscall(struct proc *p, uintreg_t syscallno, uintreg_t a1,
                        vcoreid = proc_get_vcoreid(p, coreid);
                        if (systrace_flags & SYSTRACE_LOUD) {
                                printk("[%16llu] Syscall %3d (%12s):(%08p, %08p, %08p, %08p, "
-                                      "%08p) proc: %d core: %d vcore: %d\n", read_tsc(),
-                                      syscallno, syscall_table[syscallno].name, a1, a2, a3,
+                                      "%08p, %08p) proc: %d core: %d vcore: %d\n", read_tsc(),
+                                      sc_num, syscall_table[sc_num].name, a0, a1, a2, a3,
                                       a4, a5, p->pid, coreid, vcoreid);
                        } else {
                                struct systrace_record *trace;
@@ -1370,7 +1370,8 @@ intreg_t syscall(struct proc *p, uintreg_t syscallno, uintreg_t a1,
                                } while (!atomic_comp_swap(&systrace_bufidx, idx, new_idx));
                                trace = &systrace_buffer[idx];
                                trace->timestamp = read_tsc();
-                               trace->syscallno = syscallno;
+                               trace->syscallno = sc_num;
+                               trace->arg0 = a0;
                                trace->arg1 = a1;
                                trace->arg2 = a2;
                                trace->arg3 = a3;
@@ -1382,14 +1383,10 @@ intreg_t syscall(struct proc *p, uintreg_t syscallno, uintreg_t a1,
                        }
                }
        }
-       //printk("Incoming syscall on core: %d number: %d\n    a1: %x\n   "
-       //       " a2: %x\n    a3: %x\n    a4: %x\n    a5: %x\n", core_id(),
-       //       syscallno, a1, a2, a3, a4, a5);
+       if (sc_num > max_syscall || syscall_table[sc_num].call == NULL)
+               panic("Invalid syscall number %d for proc %x!", sc_num, *p);
 
-       if (syscallno > max_syscall || syscall_table[syscallno].call == NULL)
-               panic("Invalid syscall number %d for proc %x!", syscallno, *p);
-
-       return syscall_table[syscallno].call(p, a1, a2, a3, a4, a5);
+       return syscall_table[sc_num].call(p, a0, a1, a2, a3, a4, a5);
 }
 
 /* A process can trap and call this function, which will set up the core to
@@ -1428,9 +1425,8 @@ void run_local_syscall(void)
        pcpui->nr_calls--;                              /* one less to do */
        (*pcpui->tf_retval_loc)++;              /* one more started */
        pcpui->errno_loc = &sysc->err;
-       /* TODO: arg5 */
        sysc->retval = syscall(pcpui->cur_proc, sysc->num, sysc->arg0, sysc->arg1,
-                              sysc->arg2, sysc->arg3, sysc->arg4);
+                              sysc->arg2, sysc->arg3, sysc->arg4, sysc->arg5);
        sysc->flags |= SC_DONE;
        /* regardless of whether the call blocked or not, we smp_idle().  If it was
         * the last call, it'll return to the process.  If there are more, it will
@@ -1523,11 +1519,12 @@ void systrace_print(bool all, struct proc *p)
         * timestamp and loop around.  Careful of concurrent writes. */
        for (int i = 0; i < systrace_bufsize; i++)
                if (systrace_buffer[i].timestamp)
-                       printk("[%16llu] Syscall %3d (%12s):(%08p, %08p, %08p, %08p, "
+                       printk("[%16llu] Syscall %3d (%12s):(%08p, %08p, %08p, %08p, %08p,"
                               "%08p) proc: %d core: %d vcore: %d\n",
                               systrace_buffer[i].timestamp,
                               systrace_buffer[i].syscallno,
                               syscall_table[systrace_buffer[i].syscallno].name,
+                              systrace_buffer[i].arg0,
                               systrace_buffer[i].arg1,
                               systrace_buffer[i].arg2,
                               systrace_buffer[i].arg3,
index 5c55299..082de60 100644 (file)
@@ -8,7 +8,7 @@ int main()
 
        long long tsc0 = read_tsc();
        for(int i = 0; i < N; i++)
-               ros_syscall(SYS_null,0,0,0,0,0);
+               ros_syscall(SYS_null, 0, 0, 0, 0, 0, 0);
        long long tsc1 = read_tsc();
 
        printf("tsc0 = %lld\n",tsc0);
index e85a801..61885f0 100644 (file)
@@ -27,7 +27,7 @@ void
 _exit (status)
      int status;
 {
-  ros_syscall(SYS_proc_destroy,getpid(),0,0,0,0);
+  ros_syscall(SYS_proc_destroy,getpid(),0,0,0,0,0);
   #ifdef ABORT_INSTRUCTION
   ABORT_INSTRUCTION;
   #endif
index 138a553..5daf419 100644 (file)
@@ -32,6 +32,6 @@ __access (const char* file, int type)
     return -1;
   }
 
-  return ros_syscall(SYS_access, file, strlen(file), type, 0, 0);
+  return ros_syscall(SYS_access, file, strlen(file), type, 0, 0, 0);
 }
 weak_alias (__access, access)
index 0d3c82b..e770160 100644 (file)
@@ -33,6 +33,6 @@ __chdir (path)
     return -1;
   }
 
-  return ros_syscall(SYS_chdir, path, strlen(path), 0, 0, 0);
+  return ros_syscall(SYS_chdir, path, strlen(path), 0, 0, 0, 0);
 }
 weak_alias (__chdir, chdir)
index 2e450ca..eacb5a8 100644 (file)
@@ -33,6 +33,6 @@ __chmod (const char* file, mode_t mode)
     return -1;
   }
 
-  return ros_syscall(SYS_chmod, file, strlen(file), mode, 0, 0);
+  return ros_syscall(SYS_chmod, file, strlen(file), mode, 0, 0, 0);
 }
 weak_alias (__chmod, chmod)
index 9fa472f..fb403ee 100644 (file)
@@ -26,7 +26,7 @@
 int
 __close (int fd)
 {
-  return ros_syscall(SYS_close,fd,0,0,0,0);
+  return ros_syscall(SYS_close, fd, 0, 0, 0, 0, 0);
 }
 libc_hidden_def (__close)
 weak_alias (__close, close)
index 5bf4c32..e7f2949 100644 (file)
@@ -41,7 +41,7 @@ __execve (path, argv, envp)
     return -1;
   }
 
-  int ret = ros_syscall(SYS_exec, path, strlen(path), (uintptr_t)&pi, 0, 0);
+  int ret = ros_syscall(SYS_exec, path, strlen(path), (uintptr_t)&pi, 0, 0, 0);
 
   // if we got here, then exec better have failed...
   assert(ret == -1);
index 48b4ca9..25fdf43 100644 (file)
@@ -38,7 +38,7 @@ __fcntl(int fd, int cmd, ...)
     case F_SETFD:
     case F_GETFL:
     case F_SETFL:
-      return ros_syscall(SYS_fcntl,fd,cmd,arg,0,0);
+      return ros_syscall(SYS_fcntl, fd, cmd, arg, 0, 0, 0);
     default:
       errno = ENOSYS;
       return -1;
index 8553464..265195b 100644 (file)
@@ -46,7 +46,7 @@ __fork ()
     child_list = tmp;
   }
 
-  ret = ros_syscall(SYS_fork,0,0,0,0,0);
+  ret = ros_syscall(SYS_fork, 0, 0, 0, 0, 0, 0);
   if(ret > 0)
     child_list[child_list_size++] = ret;
 
index ca386f1..c3f2ee8 100644 (file)
@@ -45,7 +45,7 @@ __fxstat (int vers, int fd, struct stat *buf)
     }
 
   
-  int ret = (int)ros_syscall(SYS_fstat, fd, buf, 0, 0, 0);
+  int ret = (int)ros_syscall(SYS_fstat, fd, buf, 0, 0, 0, 0);
   return ret;
 }
 stub_warning (fstat)
index d33e700..8f25114 100644 (file)
@@ -49,7 +49,7 @@ __getcwd (char *buf, size_t size)
     allocated = 1;
   }
 
-  int ret = ros_syscall(SYS_getcwd,buf,size,0,0,0);
+  int ret = ros_syscall(SYS_getcwd, buf, size, 0, 0, 0, 0);
 
   if(ret == -1 && allocated)
   {
index 6ffdc56..fa8f382 100644 (file)
@@ -30,7 +30,7 @@ __gettimeofday (tv, tz)
      struct timeval *tv;
      struct timezone *tz;
 {
-  return ros_syscall(SYS_gettimeofday,tv,0,0,0,0);
+  return ros_syscall(SYS_gettimeofday, tv, 0, 0, 0, 0, 0);
 }
 INTDEF(__gettimeofday)
 weak_alias (__gettimeofday, gettimeofday)
index 3f01a16..0a9b0bb 100644 (file)
@@ -440,7 +440,7 @@ static const char* tls_init_tp(void* thrdescr)
 
   //TODO: think about how to avoid this. Probably add a field to the 
   // rthreads struct that we manually fill in in _start(). 
-  int core_id = __ros_syscall(SYS_getvcoreid, 0, 0, 0, 0, 0, NULL);
+  int core_id = __ros_syscall(SYS_getvcoreid, 0, 0, 0, 0, 0, 0, NULL);
 
   /* Bug with this whole idea (TODO: (TLSV))*/
   if(__procdata.ldt == NULL)
@@ -452,13 +452,13 @@ static const char* tls_init_tp(void* thrdescr)
     // it up...)
     intreg_t params[3] = { MAP_ANONYMOUS | MAP_POPULATE, -1, 0 };
        void *ldt = (void*)__ros_syscall(SYS_mmap, 0, sz, PROT_READ | PROT_WRITE,
-                                        (long)params, 0, NULL);
+                                        (long)params, 0, 0, NULL);
     if (ldt == MAP_FAILED)
       return "tls couldn't allocate memory\n";
 
     __procdata.ldt = ldt;
     // force kernel crossing
-       __ros_syscall(SYS_getpid, 0, 0, 0, 0, 0, NULL);
+       __ros_syscall(SYS_getpid, 0, 0, 0, 0, 0, 0, NULL);
   }
 
   // Build the segment
index 59f03f7..d42b3c9 100644 (file)
@@ -31,6 +31,6 @@ __kill (int pid, int sig)
     errno = ENOSYS;
     return -1;
   }
-  return ros_syscall(SYS_proc_destroy,pid,0,0,0,0);
+  return ros_syscall(SYS_proc_destroy, pid, 0, 0, 0, 0, 0);
 }
 weak_alias (__kill, kill)
index 71ffad4..f48f423 100644 (file)
@@ -34,6 +34,6 @@ __link (from, to)
     return -1;
   }
 
-  return ros_syscall(SYS_link, from, strlen(from), to, strlen(to), 0);
+  return ros_syscall(SYS_link, from, strlen(from), to, strlen(to), 0, 0);
 }
 weak_alias (__link, link)
index ccfe1f6..92abade 100644 (file)
@@ -6,7 +6,7 @@
 off_t
 __libc_lseek (int fd, off_t offset, int whence)
 {
-  return ros_syscall(SYS_lseek,fd,offset,whence,0,0);
+  return ros_syscall(SYS_lseek, fd, offset, whence, 0, 0, 0);
 }
 
 weak_alias (__libc_lseek, __lseek)
index 601b679..cada0d8 100644 (file)
@@ -35,7 +35,7 @@ __lxstat (int vers, const char *file, struct stat *buf)
     return -1;
   }
 
-  int ret = (int)ros_syscall(SYS_lstat, file, strlen(file), buf, 0, 0);
+  int ret = (int)ros_syscall(SYS_lstat, file, strlen(file), buf, 0, 0, 0);
   return ret;
 }
 hidden_def (__lxstat)
index a68c5d7..deb6805 100644 (file)
@@ -34,6 +34,6 @@ __mkdir (path, mode)
       __set_errno (EINVAL);
       return -1;
     }
-  return ros_syscall(SYS_mkdir, path, strlen(path), mode, 0, 0);
+  return ros_syscall(SYS_mkdir, path, strlen(path), mode, 0, 0, 0);
 }
 weak_alias (__mkdir, mkdir)
index 44eeeef..96ed3af 100644 (file)
@@ -42,7 +42,7 @@ __mmap (__ptr_t addr, size_t len, int prot, int flags, int fd, off_t offset)
   offset /= PGSIZE;
 
   volatile int args[3] = {flags,fd,offset};
-  return (__ptr_t)ros_syscall(SYS_mmap,addr,len,prot,args,0);
+  return (__ptr_t)ros_syscall(SYS_mmap, addr, len, prot, args, 0, 0);
 }
 
 weak_alias (__mmap, mmap)
index 46bceac..c05c92c 100644 (file)
@@ -28,6 +28,6 @@
 int
 __mprotect (__ptr_t addr, size_t len, int prot)
 {
-  return ros_syscall(SYS_mprotect,addr,len,prot,0,0);
+  return ros_syscall(SYS_mprotect, addr, len, prot, 0, 0, 0);
 }
 weak_alias (__mprotect, mprotect)
index e9f66fb..4e65bd0 100644 (file)
@@ -27,6 +27,6 @@
 int
 __munmap (__ptr_t addr, size_t len)
 {
-  return ros_syscall(SYS_munmap,addr,len,0,0,0);
+  return ros_syscall(SYS_munmap, addr, len, 0, 0, 0, 0);
 }
 weak_alias (__munmap, munmap)
index 1b381ac..e2bf26c 100644 (file)
@@ -45,7 +45,7 @@ __libc_open (const char* file, int oflag, ...)
       va_end(arg);
     }
 
-  return ros_syscall(SYS_open, file, strlen(file), oflag, mode, 0);
+  return ros_syscall(SYS_open, file, strlen(file), oflag, mode, 0, 0);
 }
 libc_hidden_def (__libc_open)
 weak_alias (__libc_open, __open)
index 5169020..96d3683 100644 (file)
@@ -26,7 +26,7 @@
 ssize_t
 __libc_read (int fd, void *buf, size_t nbytes)
 {
-  return ros_syscall(SYS_read,fd,buf,nbytes,0,0);
+  return ros_syscall(SYS_read, fd, buf, nbytes, 0, 0, 0);
 }
 libc_hidden_def (__libc_read)
 
index e1a85a9..c9cf9da 100644 (file)
@@ -30,6 +30,6 @@ __readlink (path, buf, len)
      char *buf;
      size_t len;
 {
-  return ros_syscall(SYS_readlink, path, strlen(path), buf, len, 0);
+  return ros_syscall(SYS_readlink, path, strlen(path), buf, len, 0, 0);
 }
 weak_alias (__readlink, readlink)
index 7485493..ad7d4e8 100644 (file)
@@ -33,6 +33,6 @@ __rmdir (path)
       return -1;
     }
 
-  return ros_syscall(SYS_rmdir, path, strlen(path), 0, 0, 0);
+  return ros_syscall(SYS_rmdir, path, strlen(path), 0, 0, 0, 0);
 }
 weak_alias (__rmdir, rmdir)
index a510050..d7c466e 100644 (file)
@@ -24,7 +24,7 @@
 int
 __sched_yield (void)
 {
-  return ros_syscall(SYS_yield,0,0,0,0,0);
+  return ros_syscall(SYS_yield, 0, 0, 0, 0, 0, 0);
 }
 libc_hidden_def (__sched_yield)
 weak_alias (__sched_yield, sched_yield)
index 051d3e5..49332be 100644 (file)
@@ -29,6 +29,6 @@ int
 __setgid (gid)
      gid_t gid;
 {
-  return ros_syscall(SYS_setgid, gid, 0, 0, 0, 0);
+  return ros_syscall(SYS_setgid, gid, 0, 0, 0, 0, 0);
 }
 weak_alias (__setgid, setgid)
index 103d431..0f8d7d0 100644 (file)
@@ -29,6 +29,6 @@ int
 __setuid (uid)
      uid_t uid;
 {
-  return ros_syscall(SYS_setuid, uid, 0, 0, 0, 0);
+  return ros_syscall(SYS_setuid, uid, 0, 0, 0, 0, 0);
 }
 weak_alias (__setuid, setuid)
index 8c5f325..8822ff3 100644 (file)
@@ -33,6 +33,6 @@ __symlink (from, to)
       __set_errno (EINVAL);
       return -1;
     }
-  return ros_syscall(SYS_symlink, from, strlen(from), to, strlen(to), 0);
+  return ros_syscall(SYS_symlink, from, strlen(from), to, strlen(to), 0, 0);
 }
 weak_alias (__symlink, symlink)
index 54725b5..ebdd17f 100644 (file)
@@ -32,8 +32,9 @@ syscall(long int num, ...)
   long int a2 = va_arg(vl,long int);
   long int a3 = va_arg(vl,long int);
   long int a4 = va_arg(vl,long int);
+  long int a5 = va_arg(vl,long int);
   va_end(vl);
 
-  return ros_syscall(num,a0,a1,a2,a3,a4);
+  return ros_syscall(num, a0, a1, a2, a3, a4, a5);
 }
 
index 95b7e62..397980b 100644 (file)
@@ -25,6 +25,6 @@
 int
 __tcgetattr (int fd, struct termios* termios_p)
 {
-  return ros_syscall(SYS_tcgetattr,fd,termios_p,0,0,0);
+  return ros_syscall(SYS_tcgetattr, fd, termios_p, 0, 0, 0, 0);
 }
 weak_alias (__tcgetattr, tcgetattr)
index c63bde9..0ad900e 100644 (file)
@@ -25,6 +25,6 @@
 int
 tcsetattr (int fd, int optional_actions, const struct termios *termios_p)
 {
-  return ros_syscall(SYS_tcsetattr,fd,optional_actions,termios_p,0,0);
+  return ros_syscall(SYS_tcsetattr, fd, optional_actions, termios_p, 0, 0, 0);
 }
 libc_hidden_def (tcsetattr)
index 24923c8..341af2b 100644 (file)
@@ -25,6 +25,6 @@
 mode_t
 __umask (mode_t mask)
 {
-  return ros_syscall(SYS_umask,mask,0,0,0,0);
+  return ros_syscall(SYS_umask, mask, 0, 0, 0, 0, 0);
 }
 weak_alias (__umask, umask)
index 393877b..5ed30b9 100644 (file)
@@ -33,6 +33,6 @@ __unlink (name)
     return -1;
   }
 
-  return ros_syscall(SYS_unlink, name, strlen(name), 0, 0, 0);
+  return ros_syscall(SYS_unlink, name, strlen(name), 0, 0, 0, 0);
 }
 weak_alias (__unlink, unlink)
index 52f3956..b829445 100644 (file)
@@ -60,7 +60,7 @@ __libc_waitpid (pid_t pid, int *stat_loc, int options)
     {
       if(pid == -1 || child_list[i] == pid)
       {
-        ret = ros_syscall(SYS_trywait,child_list[i],stat_loc,0,0,0);
+        ret = ros_syscall(SYS_trywait, child_list[i], stat_loc, 0, 0, 0, 0);
         if(ret == 0)
         {
           ret = child_list[i];
index 823136f..61790af 100644 (file)
@@ -26,7 +26,7 @@
 ssize_t
 __libc_write (int fd, const void *buf, size_t nbytes)
 {
-  return ros_syscall(SYS_write,fd,buf,nbytes,0,0);
+  return ros_syscall(SYS_write, fd, buf, nbytes, 0, 0, 0);
 }
 libc_hidden_def (__libc_write)
 
index 4785248..8a8885d 100644 (file)
@@ -34,7 +34,7 @@ __xstat (int vers, const char *file, struct stat *buf)
     return -1;
   }
 
-  int ret = (int)ros_syscall(SYS_stat, file, strlen(file), buf, 0, 0);
+  int ret = (int)ros_syscall(SYS_stat, file, strlen(file), buf, 0, 0, 0);
   return ret;
 }
 hidden_def (__xstat)
index c54281a..d73cfeb 100644 (file)
@@ -58,7 +58,7 @@ static inline void pop_ros_tf(struct user_trapframe *tf, uint32_t vcoreid)
 
        vcpd->notif_enabled = true;
        if(vcpd->notif_pending)
-               ros_syscall(SYS_self_notify,vcoreid,0,0,0,0);
+               ros_syscall(SYS_self_notify, vcoreid, 0, 0, 0, 0, 0);
 
        // tell the kernel to load the new trapframe
        asm volatile ("mov %0, %%o0; ta 4" : : "r"(tf) : "memory");
index 9bcc48a..e9fb15f 100644 (file)
@@ -17,7 +17,7 @@ extern "C" {
 #include <stdlib.h>
 #include <unistd.h>
 #undef exit
-#define exit(status) ros_syscall(SYS_proc_destroy,getpid(),status,0,0,0)
+#define exit(status) ros_syscall(SYS_proc_destroy, getpid(), status, 0, 0, 0, 0)
 /*****************************************************************************/
 
 #define LOG2_MAX_VCORES 6
index fded922..43d5acb 100644 (file)
@@ -4,32 +4,32 @@
 
 int sys_proc_destroy(int pid, int exitcode)
 {
-       return ros_syscall(SYS_proc_destroy, pid, exitcode, 0, 0, 0);
+       return ros_syscall(SYS_proc_destroy, pid, exitcode, 0, 0, 0, 0);
 }
 
 int sys_getpid(void)
 {
-        return ros_syscall(SYS_getpid, 0, 0, 0, 0, 0);
+        return ros_syscall(SYS_getpid, 0, 0, 0, 0, 0, 0);
 }
 
 size_t sys_getcpuid(void)
 {
-        return ros_syscall(SYS_getcpuid, 0, 0, 0, 0, 0);
+        return ros_syscall(SYS_getcpuid, 0, 0, 0, 0, 0, 0);
 }
 
 ssize_t sys_cputs(const uint8_t *s, size_t len)
 {
-    return ros_syscall(SYS_cputs, s,  len, 0, 0, 0);
+    return ros_syscall(SYS_cputs, s,  len, 0, 0, 0, 0);
 }
 
 uint16_t sys_cgetc(void)
 {
-    return ros_syscall(SYS_cgetc, 0, 0, 0, 0, 0);
+    return ros_syscall(SYS_cgetc, 0, 0, 0, 0, 0, 0);
 }
 
 int sys_null(void)
 {
-    return ros_syscall(SYS_null, 0, 0, 0, 0, 0);
+    return ros_syscall(SYS_null, 0, 0, 0, 0, 0, 0);
 }
 
 ssize_t sys_shared_page_alloc(void** addr, pid_t p2, 
@@ -37,24 +37,24 @@ ssize_t sys_shared_page_alloc(void** addr, pid_t p2,
                              ) 
 {
        return ros_syscall(SYS_shared_page_alloc, addr, 
-                      p2, p1_flags, p2_flags, 0);
+                      p2, p1_flags, p2_flags, 0, 0);
 }
 
 ssize_t sys_shared_page_free(void* addr, pid_t p2) 
 {
-       return ros_syscall(SYS_shared_page_free, addr, p2, 0,0,0);
+       return ros_syscall(SYS_shared_page_free, addr, p2, 0, 0, 0, 0);
 }
 
 //Write a buffer over the serial port
 ssize_t sys_serial_write(void* buf, size_t len) 
 {
-       return ros_syscall(SYS_serial_write, buf, len, 0, 0, 0);
+       return ros_syscall(SYS_serial_write, buf, len, 0, 0, 0, 0);
 }
 
 //Read a buffer over the serial port
 ssize_t sys_serial_read(void* buf, size_t len) 
 {
-       return ros_syscall(SYS_serial_read, buf, len, 0, 0, 0);
+       return ros_syscall(SYS_serial_read, buf, len, 0, 0, 0, 0);
 }
 
 //Write a buffer over ethernet
@@ -63,7 +63,7 @@ ssize_t sys_eth_write(void* buf, size_t len)
        if (len == 0)
                return 0;
        
-       return ros_syscall(SYS_eth_write, buf, len, 0, 0, 0);
+       return ros_syscall(SYS_eth_write, buf, len, 0, 0, 0, 0);
 }
 
 //Read a buffer via ethernet
@@ -72,23 +72,23 @@ ssize_t sys_eth_read(void* buf, size_t len)
        if (len == 0)
                return 0;
                
-       return ros_syscall(SYS_eth_read, buf, len, 0, 0, 0);
+       return ros_syscall(SYS_eth_read, buf, len, 0, 0, 0, 0);
 }
 
 /* Request resources from the kernel.  Flags in ros/resource.h. */
 ssize_t sys_resource_req(int type, size_t amt_max, size_t amt_min, uint32_t flags)
 {
-       return ros_syscall(SYS_resource_req, type, amt_max, amt_min, flags, 0);
+       return ros_syscall(SYS_resource_req, type, amt_max, amt_min, flags, 0, 0);
 }
 
 void sys_reboot(void)
 {
-       ros_syscall(SYS_reboot,0,0,0,0,0);
+       ros_syscall(SYS_reboot, 0, 0, 0, 0, 0, 0);
 }
 
 void sys_yield(bool being_nice)
 {
-       ros_syscall(SYS_yield, being_nice, 0, 0, 0, 0);
+       ros_syscall(SYS_yield, being_nice, 0, 0, 0, 0, 0);
 }
 
 int sys_proc_create(char *path, size_t path_l, char *argv[], char *envp[])
@@ -98,12 +98,12 @@ int sys_proc_create(char *path, size_t path_l, char *argv[], char *envp[])
                errno = ENOMEM;
                return -1;
        }
-       return ros_syscall(SYS_proc_create, path, path_l, &pi, 0, 0);
+       return ros_syscall(SYS_proc_create, path, path_l, &pi, 0, 0, 0);
 }
 
 int sys_proc_run(int pid)
 {
-       return ros_syscall(SYS_proc_run, pid, 0, 0, 0, 0);
+       return ros_syscall(SYS_proc_run, pid, 0, 0, 0, 0, 0);
 }
 
 /* We need to do some hackery to pass 6 arguments.  Arg4 pts to the real arg4,
@@ -123,26 +123,26 @@ void *CT(length) sys_mmap(void *SNT addr, size_t length, int prot, int flags,
        extra_args._offset = offset;
        // TODO: deputy bitches about this
        return (void*CT(length))TC(ros_syscall(SYS_mmap, addr, length,
-                                              prot, &extra_args, 0));
+                                              prot, &extra_args, 0, 0));
 }
 
 int sys_notify(int pid, unsigned int notif, struct notif_event *ne)
 {
-       return ros_syscall(SYS_notify, pid, notif, ne, 0, 0);
+       return ros_syscall(SYS_notify, pid, notif, ne, 0, 0, 0);
 }
 
 int sys_self_notify(uint32_t vcoreid, unsigned int notif,
                     struct notif_event *ne)
 {
-       return ros_syscall(SYS_self_notify, vcoreid, notif, ne, 0, 0);
+       return ros_syscall(SYS_self_notify, vcoreid, notif, ne, 0, 0, 0);
 }
 
 int sys_halt_core(unsigned int usec)
 {
-       return ros_syscall(SYS_halt_core, usec, 0, 0, 0, 0);
+       return ros_syscall(SYS_halt_core, usec, 0, 0, 0, 0, 0);
 }
 
 int sys_init_arsc()
 {
-       return ros_syscall(SYS_init_arsc, 0, 0, 0, 0, 0);
+       return ros_syscall(SYS_init_arsc, 0, 0, 0, 0, 0, 0);
 }