__ros_syscall -> __ros_syscall_noerrno (XCC)
authorBarret Rhoden <brho@cs.berkeley.edu>
Sun, 4 Aug 2013 01:14:37 +0000 (18:14 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Sun, 4 Aug 2013 01:14:37 +0000 (18:14 -0700)
The *errno_loc parameter was never used by anyone, and this func was
left over from when __ros_syscall_errno() called __ros_syscall() under
the hood.

Since everyone who calls this wants no errno, I just removed it.

Rebuild your cross compiler.  (Copy over the changed files, or just make
clean first).

kern/include/ros/procinfo.h
tools/compilers/gcc-glibc/glibc-2.14.1-ros/sysdeps/ros/Versions
tools/compilers/gcc-glibc/glibc-2.14.1-ros/sysdeps/ros/i386/tls.h
tools/compilers/gcc-glibc/glibc-2.14.1-ros/sysdeps/ros/sbrk.c
tools/compilers/gcc-glibc/glibc-2.14.1-ros/sysdeps/ros/sys/syscall.h
tools/compilers/gcc-glibc/glibc-2.14.1-ros/sysdeps/ros/syscall.c

index dff1a03..b618c4f 100644 (file)
@@ -118,7 +118,7 @@ static inline uint32_t __get_vcoreid_from_procinfo(void)
        do {
                cmb();
                old_seq = __procinfo.coremap_seqctr;
-               kpcoreid = __ros_syscall(SYS_getpcoreid, 0, 0, 0, 0, 0, 0, NULL);
+               kpcoreid = __ros_syscall_noerrno(SYS_getpcoreid, 0, 0, 0, 0, 0, 0);
                if (!__procinfo.pcoremap[kpcoreid].valid)
                        continue;
                kvcoreid = __procinfo.pcoremap[kpcoreid].vcoreid;
index 1ae2ca8..dea6ad4 100644 (file)
@@ -5,7 +5,7 @@ libc {
     ros_syscall_sync;
     __ros_scp_syscall_blockon;
     __ros_scp_simple_evq;
-    __ros_syscall;
+    __ros_syscall_noerrno;
     __ros_syscall_errno;
 
     set_tls_desc;
index 724661a..08ef9ac 100644 (file)
@@ -465,7 +465,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, 0, NULL);
+  int core_id = __ros_syscall_noerrno(SYS_getvcoreid, 0, 0, 0, 0, 0, 0);
 
   /* Bug with this whole idea (TODO: (TLSV))*/
   if(__procdata.ldt == NULL)
@@ -475,14 +475,16 @@ static const char* tls_init_tp(void* thrdescr)
        /* Can't directly call mmap because it tries to set errno, and errno doesn't
         * exist yet (it relies on tls, and we are currently in the process of
         * setting it up...) */
-       void *ldt = (void*)__ros_syscall(SYS_mmap, 0, sz, PROT_READ | PROT_WRITE,
-                                        MAP_ANONYMOUS | MAP_POPULATE, -1, 0, NULL);
+       void *ldt = (void*)__ros_syscall_noerrno(SYS_mmap, 0, sz,
+                                                PROT_READ | PROT_WRITE,
+                                                MAP_ANONYMOUS | MAP_POPULATE,
+                                                -1, 0);
     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, 0, NULL);
+       __ros_syscall_noerrno(SYS_getpid, 0, 0, 0, 0, 0, 0);
   }
 
   __set_tls_desc(thrdescr, core_id);
index 3e9bc82..68bc770 100644 (file)
@@ -47,9 +47,11 @@ __internal_setbrk (uintptr_t addr)
     if(real_new_brk > BRK_END)
       return -1;
        // calling mmap directly to avoid referencing errno before it is initialized.
-    if ((void*)__ros_syscall(SYS_mmap, (void*)real_brk, real_new_brk-real_brk,
-             PROT_READ | PROT_WRITE | PROT_EXEC,
-             MAP_FIXED | MAP_ANONYMOUS, -1, 0, NULL) != (void*)real_brk)
+    if ((void*)__ros_syscall_noerrno(SYS_mmap, (void*)real_brk,
+                                        real_new_brk-real_brk,
+                                        PROT_READ | PROT_WRITE | PROT_EXEC,
+                                        MAP_FIXED | MAP_ANONYMOUS,
+                                        -1, 0) != (void*)real_brk)
       return -1;
   }
   else if(real_new_brk < real_brk)
index 3c8f648..b929f72 100644 (file)
@@ -25,10 +25,10 @@ extern "C" {
 /* Issue a single syscall and block into the 2LS until it completes */
 void ros_syscall_sync(struct syscall *sysc);
 
-/* Raw syscall, user-provided errno (send in 0 if you don't want it).  This is
- * usually used by code that can't handle errno (TLS). */
-long __ros_syscall(unsigned int _num, long _a0, long _a1, long _a2, long _a3,
-                   long _a4, long _a5, int *errno_loc);
+/* Raw syscall, ignores errors.  Usually used by code that can't handle errno
+ * (TLS). */
+long __ros_syscall_noerrno(unsigned int _num, long _a0, long _a1, long _a2,
+                           long _a3, long _a4, long _a5);
 
 /* This version knows about errno and will handle it. */
 long __ros_syscall_errno(unsigned int _num, long _a0, long _a1, long _a2,
@@ -37,7 +37,7 @@ long __ros_syscall_errno(unsigned int _num, long _a0, long _a1, long _a2,
 /* Bypass PLT when invoked from within libc */
 #ifdef libc_hidden_proto
 libc_hidden_proto(ros_syscall_sync)
-libc_hidden_proto(__ros_syscall)
+libc_hidden_proto(__ros_syscall_noerrno)
 libc_hidden_proto(__ros_syscall_errno)
 #endif
 
index 8459826..e127228 100644 (file)
@@ -75,13 +75,13 @@ void __ros_scp_syscall_blockon(struct syscall *sysc)
        if (register_evq(sysc, &__ros_scp_simple_evq)) {
                /* Sending false for now - we want to signal proc code that we want to
                 * wait (piggybacking on the MCP meaning of this variable) */
-               __ros_syscall(SYS_yield, FALSE, 0, 0, 0, 0, 0, 0);
+               __ros_syscall_noerrno(SYS_yield, FALSE, 0, 0, 0, 0, 0);
        }
        /* Manually doing an enable_notifs for VC 0 */
        __procdata.vcore_preempt_data[0].notif_disabled = FALSE;
        wrmb(); /* need to read after the write that enabled notifs */
        if (__procdata.vcore_preempt_data[0].notif_pending)
-               __ros_syscall(SYS_self_notify, 0, EV_NONE, 0, TRUE, 0, 0, 0);
+               __ros_syscall_noerrno(SYS_self_notify, 0, EV_NONE, 0, TRUE, 0, 0);
 }
 
 /* Function pointer for the blockon function.  MCPs need to switch to the parlib
@@ -128,16 +128,14 @@ __ros_syscall_inline(unsigned int _num, long _a0, long _a1, long _a2, long _a3,
        return sysc;
 }
 
-long __ros_syscall(unsigned int _num, long _a0, long _a1, long _a2, long _a3,
-                   long _a4, long _a5, int *errno_loc)
+long __ros_syscall_noerrno(unsigned int _num, long _a0, long _a1, long _a2,
+                           long _a3, long _a4, long _a5)
 {
        struct syscall sysc = __ros_syscall_inline(_num, _a0, _a1, _a2, _a3,
                                                   _a4, _a5);
-       if (__builtin_expect(errno_loc && sysc.err, 0))
-               *errno_loc = sysc.err;
        return sysc.retval;
 }
-libc_hidden_def(__ros_syscall)
+libc_hidden_def(__ros_syscall_noerrno)
 
 /* This version knows about errno and will handle it. */
 long __ros_syscall_errno(unsigned int _num, long _a0, long _a1, long _a2,