syscall overhaul part two - unify public and internal syscall interface

with this patch, the syscallN() functions are no longer needed; a
variadic syscall() macro allows syscalls with anywhere from 0 to 6
arguments to be made with a single macro name. also, manually casting
each non-integer argument with (long) is no longer necessary; the
casts are hidden in the macros.

some source files which depended on being able to define the old macro
SYSCALL_RETURNS_ERRNO have been modified to directly use __syscall()
instead of syscall(). references to SYSCALL_SIGSET_SIZE and SYSCALL_LL
have also been changed.

x86_64 has not been tested, and may need a follow-up commit to fix any
minor bugs/oversights.

diff --git a/arch/i386/bits/fcntl.h b/arch/i386/bits/fcntl.h
index 802c3d14c15bd0a882298785730addfbe66e8f85..61382eefe22b5d11c1533f8895bfed83b4474ac6 100644 (file)
--- a/arch/i386/bits/fcntl.h
+++ b/arch/i386/bits/fcntl.h
@@ -14,12 +14,15 @@
 #define O_NOFOLLOW  0400000
 #define O_CLOEXEC  02000000
 
-#ifdef _GNU_SOURCE
-#define O_NDELAY O_NONBLOCK
+/* Extensions, but in the reserved namespace, so OK */
 #define O_ASYNC      020000
 #define O_DIRECT     040000
+#define O_LARGEFILE 0100000
 #define O_NOATIME  01000000
+#define O_NDELAY O_NONBLOCK
 #define F_DUPFD_CLOEXEC 1030
+
+#ifdef _GNU_SOURCE
 #define FAPPENT O_APPEND
 #define FFSYNC O_FSYNC
 #define FASYNC O_ASYNC

diff --git a/arch/i386/bits/syscall.h b/arch/i386/bits/syscall.h
index b38f09e9f6c2d3022c8364dacf3402a7937d0de0..f8429b2750a827aee405e63c95257de9650c4d43 100644 (file)
--- a/arch/i386/bits/syscall.h
+++ b/arch/i386/bits/syscall.h
@@ -1,3 +1,130 @@
+#define __SYSCALL_LL(x) \
+((union { long long ll; long l[2]; }){ .ll = x }).l[0], \
+((union { long long ll; long l[2]; }){ .ll = x }).l[1]
+
+static inline long __syscall0(long n)
+{
+       unsigned long ret;
+       __asm__ __volatile__ ("int $128" : "=a"(ret) : "a"(n) : "memory");
+       return __syscall_ret(ret);
+}
+
+#ifndef __PIC__
+
+static inline long __syscall1(long n, long a1)
+{
+       unsigned long ret;
+       __asm__ __volatile__ ("int $128" : "=a"(ret) : "a"(n), "b"(a1) : "memory");
+       return ret;
+}
+
+static inline long __syscall2(long n, long a1, long a2)
+{
+       unsigned long ret;
+       __asm__ __volatile__ ("int $128" : "=a"(ret) : "a"(n), "b"(a1), "c"(a2) : "memory");
+       return ret;
+}
+
+static inline long __syscall3(long n, long a1, long a2, long a3)
+{
+       unsigned long ret;
+       __asm__ __volatile__ ("int $128" : "=a"(ret) : "a"(n), "b"(a1), "c"(a2), "d"(a3) : "memory");
+       return ret;
+}
+
+static inline long __syscall4(long n, long a1, long a2, long a3, long a4)
+{
+       unsigned long ret;
+       __asm__ __volatile__ ("int $128" : "=a"(ret) : "a"(n), "b"(a1), "c"(a2), "d"(a3), "S"(a4) : "memory");
+       return ret;
+}
+
+static inline long __syscall5(long n, long a1, long a2, long a3, long a4, long a5)
+{
+       unsigned long ret;
+       __asm__ __volatile__ ("int $128" : "=a"(ret) : "a"(n), "b"(a1), "c"(a2), "d"(a3), "S"(a4), "D"(a5) : "memory");
+       return ret;
+}
+
+static inline long __syscall6(long n, long a1, long a2, long a3, long a4, long a5, long a6)
+{
+       unsigned long ret;
+       __asm__ __volatile__ ("pushl %7 ; pushl %%ebp ; mov 4(%%esp),%%ebp ; int $128 ; popl %%ebp ; popl %%ecx"
+               : "=a"(ret) : "a"(n), "b"(a1), "c"(a2), "d"(a3), "S"(a4), "D"(a5), "g"(a6) : "memory");
+       return ret;
+}
+
+#else
+
+static inline long __syscall1(long n, long a1)
+{
+       unsigned long ret;
+       __asm__ __volatile__ ("xchg %2,%%ebx ; int $128 ; xchg %2,%%ebx"
+               : "=a"(ret) : "a"(n), "r"(a1) : "memory");
+       return ret;
+}
+
+static inline long __syscall2(long n, long a1, long a2)
+{
+       unsigned long ret;
+       __asm__ __volatile__ ("xchg %2,%%ebx ; int $128 ; xchg %2,%%ebx"
+               : "=a"(ret) : "a"(n), "r"(a1), "c"(a2) : "memory");
+       return ret;
+}
+
+static inline long __syscall3(long n, long a1, long a2, long a3)
+{
+       unsigned long ret;
+       __asm__ __volatile__ ("xchg %2,%%ebx ; int $128 ; xchg %2,%%ebx"
+               : "=a"(ret) : "a"(n), "r"(a1), "c"(a2), "d"(a3) : "memory");
+       return ret;
+}
+
+static inline long __syscall4(long n, long a1, long a2, long a3, long a4)
+{
+       unsigned long ret;
+       __asm__ __volatile__ ("xchg %2,%%ebx ; int $128 ; xchg %2,%%ebx"
+               : "=a"(ret) : "a"(n), "r"(a1), "c"(a2), "d"(a3), "S"(a4) : "memory");
+       return ret;
+}
+
+static inline long __syscall5(long n, long a1, long a2, long a3, long a4, long a5)
+{
+       unsigned long ret;
+       __asm__ __volatile__ ("pushl %2 ; pushl %%ebx ; mov 4(%%esp),%%ebx ; int $128 ; popl %%ebx ; popl %%ecx"
+               : "=a"(ret) : "a"(n), "g"(a1), "c"(a2), "d"(a3), "S"(a4), "D"(a5) : "memory");
+       return ret;
+}
+
+static inline long __syscall6(long n, long a1, long a2, long a3, long a4, long a5, long a6)
+{
+       return (__syscall)(n, a1, a2, a3, a4, a5, a6);
+}
+
+#endif
+
+
+#define __SC_socket      1
+#define __SC_bind        2
+#define __SC_connect     3
+#define __SC_listen      4
+#define __SC_accept      5
+#define __SC_getsockname 6
+#define __SC_getpeername 7
+#define __SC_socketpair  8
+#define __SC_send        9
+#define __SC_recv        10
+#define __SC_sendto      11
+#define __SC_recvfrom    12
+#define __SC_shutdown    13
+#define __SC_setsockopt  14
+#define __SC_getsockopt  15
+#define __SC_sendmsg     16
+#define __SC_recvmsg     17
+
+#define __socketcall(nm, a, b, c, d, e, f) syscall(SYS_socketcall, __SC_##nm, \
+    ((long [6]){ (long)a, (long)b, (long)c, (long)d, (long)e, (long)f }))
+
 #define __NR_restart_syscall      0
 #define __NR_exit                1
 #define __NR_fork                2
@@ -376,6 +503,7 @@
 
 
 /* fixup legacy 32-bit-vs-lfs64 junk */
+#undef __NR_fcntl
 #undef __NR_getdents
 #undef __NR_ftruncate
 #undef __NR_truncate
@@ -384,6 +512,7 @@
 #undef __NR_lstat
 #undef __NR_statfs
 #undef __NR_fstatfs
+#define __NR_fcntl __NR_fcntl64
 #define __NR_getdents __NR_getdents64
 #define __NR_ftruncate __NR_ftruncate64
 #define __NR_truncate __NR_truncate64
@@ -783,6 +912,7 @@
 
 
 /* fixup legacy 32-bit-vs-lfs64 junk */
+#undef SYS_fcntl
 #undef SYS_getdents
 #undef SYS_ftruncate
 #undef SYS_truncate
@@ -791,6 +921,7 @@
 #undef SYS_lstat
 #undef SYS_statfs
 #undef SYS_fstatfs
+#define SYS_fcntl SYS_fcntl64
 #define SYS_getdents SYS_getdents64
 #define SYS_ftruncate SYS_ftruncate64
 #define SYS_truncate SYS_truncate64

diff --git a/arch/i386/syscall.h b/arch/i386/syscall.h
deleted file mode 100644 (file)
index cd3c516..0000000
--- a/arch/i386/syscall.h
+++ /dev/null
@@ -1,167 +0,0 @@
-#ifndef _SYSCALL_H
-#define _SYSCALL_H
-
-#include <sys/syscall.h>
-
-#define SYSCALL_LL(x) \
-((union { long long ll; long l[2]; }){ .ll = x }).l[0], \
-((union { long long ll; long l[2]; }){ .ll = x }).l[1]
-
-#define SYSCALL_SIGSET_SIZE 8
-
-#if defined(SYSCALL_NORETURN)
-static inline long __syscall_ret(unsigned long r)
-{
-       for(;;);
-       return 0;
-}
-#elif defined(SYSCALL_RETURN_ERRNO)
-static inline long __syscall_ret(unsigned long r)
-{
-       return -r;
-}
-#else
-extern long __syscall_ret(unsigned long);
-#endif
-
-static inline long syscall0(long n)
-{
-       unsigned long ret;
-       __asm__ __volatile__ ("int $128" : "=a"(ret) : "a"(n) : "memory");
-       return __syscall_ret(ret);
-}
-
-#ifndef __PIC__
-
-static inline long syscall1(long n, long a1)
-{
-       unsigned long ret;
-       __asm__ __volatile__ ("int $128" : "=a"(ret) : "a"(n), "b"(a1) : "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall2(long n, long a1, long a2)
-{
-       unsigned long ret;
-       __asm__ __volatile__ ("int $128" : "=a"(ret) : "a"(n), "b"(a1), "c"(a2) : "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall3(long n, long a1, long a2, long a3)
-{
-       unsigned long ret;
-       __asm__ __volatile__ ("int $128" : "=a"(ret) : "a"(n), "b"(a1), "c"(a2), "d"(a3) : "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall4(long n, long a1, long a2, long a3, long a4)
-{
-       unsigned long ret;
-       __asm__ __volatile__ ("int $128" : "=a"(ret) : "a"(n), "b"(a1), "c"(a2), "d"(a3), "S"(a4) : "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall5(long n, long a1, long a2, long a3, long a4, long a5)
-{
-       unsigned long ret;
-       __asm__ __volatile__ ("int $128" : "=a"(ret) : "a"(n), "b"(a1), "c"(a2), "d"(a3), "S"(a4), "D"(a5) : "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall6(long n, long a1, long a2, long a3, long a4, long a5, long a6)
-{
-       unsigned long ret;
-       __asm__ __volatile__ ("pushl %%ebp ; mov %%eax,%%ebp ; movl %1,%%eax ; int $128 ; popl %%ebp"
-               : "=a"(ret) : "i"(n), "b"(a1), "c"(a2), "d"(a3), "S"(a4), "D"(a5), "a"(a6) : "memory");
-       return __syscall_ret(ret);
-}
-
-#else
-
-static inline long syscall1(long n, long a1)
-{
-       unsigned long ret;
-       __asm__ __volatile__ ("xchg %2,%%ebx ; int $128 ; xchg %2,%%ebx"
-               : "=a"(ret) : "a"(n), "r"(a1) : "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall2(long n, long a1, long a2)
-{
-       unsigned long ret;
-       __asm__ __volatile__ ("xchg %2,%%ebx ; int $128 ; xchg %2,%%ebx"
-               : "=a"(ret) : "a"(n), "r"(a1), "c"(a2) : "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall3(long n, long a1, long a2, long a3)
-{
-       unsigned long ret;
-       __asm__ __volatile__ ("xchg %2,%%ebx ; int $128 ; xchg %2,%%ebx"
-               : "=a"(ret) : "a"(n), "r"(a1), "c"(a2), "d"(a3) : "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall4(long n, long a1, long a2, long a3, long a4)
-{
-       unsigned long ret;
-       __asm__ __volatile__ ("xchg %2,%%ebx ; int $128 ; xchg %2,%%ebx"
-               : "=a"(ret) : "a"(n), "r"(a1), "c"(a2), "d"(a3), "S"(a4) : "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall5(long n, long a1, long a2, long a3, long a4, long a5)
-{
-       unsigned long ret;
-       __asm__ __volatile__ ("pushl %%ebx ; mov %%eax,%%ebx ; movl %1,%%eax ; int $128 ; popl %%ebx"
-               : "=a"(ret) : "i"(n), "a"(a1), "c"(a2), "d"(a3), "S"(a4), "D"(a5) : "memory");
-       return __syscall_ret(ret);
-}
-
-#define syscall6(n,a1,a2,a3,a4,a5,a6) __syscall((n),(a1),(a2),(a3),(a4),(a5),(a6))
-
-#endif
-
-#define __SC_socket      1
-#define __SC_bind        2
-#define __SC_connect     3
-#define __SC_listen      4
-#define __SC_accept      5
-#define __SC_getsockname 6
-#define __SC_getpeername 7
-#define __SC_socketpair  8
-#define __SC_send        9
-#define __SC_recv        10
-#define __SC_sendto      11
-#define __SC_recvfrom    12
-#define __SC_shutdown    13
-#define __SC_setsockopt  14
-#define __SC_getsockopt  15
-#define __SC_sendmsg     16
-#define __SC_recvmsg     17
-
-
-#define socketcall(nm, a, b, c, d, e, f) syscall2(__NR_socketcall, __SC_##nm, \
-    (long)(long [6]){ (long)a, (long)b, (long)c, (long)d, (long)e, (long)f })
-
-
-#undef O_LARGEFILE
-#define O_LARGEFILE 0100000
-
-/* the following are needed for iso c functions to use */
-#define __syscall_open(filename, flags, mode) syscall3(__NR_open, (long)(filename), (flags)|O_LARGEFILE, (mode))
-#define __syscall_read(fd, buf, len)          syscall3(__NR_read, (fd), (long)(buf), (len))
-#define __syscall_write(fd, buf, len)         syscall3(__NR_write, (fd), (long)(buf), (len))
-#define __syscall_close(fd)                   syscall1(__NR_close, (fd))
-#define __syscall_fcntl(fd, cmd, arg)         syscall3(__NR_fcntl64, (fd), (cmd), (long)(arg))
-#define __syscall_dup2(old, new)              syscall2(__NR_dup2, (old), (new))
-#define __syscall_unlink(path)                syscall1(__NR_unlink, (long)(path))
-#define __syscall_getpid()                    syscall0(__NR_getpid)
-#define __syscall_kill(pid,sig)               syscall2(__NR_kill, (pid), (sig))
-#define __syscall_sigaction(sig,new,old)      syscall4(__NR_rt_sigaction, (sig), (long)(new), (long)(old), SYSCALL_SIGSET_SIZE)
-#define __syscall_ioctl(fd,ioc,arg)           syscall3(__NR_ioctl, (fd), (ioc), (long)(arg))
-#define __syscall_exit(code)                  syscall1(__NR_exit, code)
-
-long __syscall(long, ...);
-
-#endif

diff --git a/arch/x86_64/bits/fcntl.h b/arch/x86_64/bits/fcntl.h
index 802c3d14c15bd0a882298785730addfbe66e8f85..2487a308eda43b7b6e1785592e01b99e67c941bd 100644 (file)
--- a/arch/x86_64/bits/fcntl.h
+++ b/arch/x86_64/bits/fcntl.h
@@ -14,12 +14,15 @@
 #define O_NOFOLLOW  0400000
 #define O_CLOEXEC  02000000
 
-#ifdef _GNU_SOURCE
-#define O_NDELAY O_NONBLOCK
+/* Extensions, but in the reserved namespace, so OK */
 #define O_ASYNC      020000
 #define O_DIRECT     040000
+#define O_LARGEFILE       0
 #define O_NOATIME  01000000
+#define O_NDELAY O_NONBLOCK
 #define F_DUPFD_CLOEXEC 1030
+
+#ifdef _GNU_SOURCE
 #define FAPPENT O_APPEND
 #define FFSYNC O_FSYNC
 #define FASYNC O_ASYNC

diff --git a/arch/x86_64/bits/syscall.h b/arch/x86_64/bits/syscall.h
index ca75019dac2ba9a171fab1139315098574862b9a..c6f12230e9e4bd58cef9d54eeef50e90e822fac6 100644 (file)
--- a/arch/x86_64/bits/syscall.h
+++ b/arch/x86_64/bits/syscall.h
@@ -1,3 +1,67 @@
+#define __SYSCALL_LL(x) (x)
+
+static inline long __syscall0(long __n)
+{
+       unsigned long __ret;
+       __asm__ __volatile__ ("syscall" : "=a"(__ret) : "a"(__n) : "rcx", "r11", "memory");
+       return __ret;
+}
+
+static inline long __syscall1(long __n, long __a1)
+{
+       unsigned long __ret;
+       __asm__ __volatile__ ("syscall" : "=a"(__ret) : "a"(__n), "D"(__a1) : "rcx", "r11", "memory");
+       return __ret;
+}
+
+static inline long __syscall2(long __n, long __a1, long __a2)
+{
+       unsigned long __ret;
+       __asm__ __volatile__ ("syscall" : "=a"(__ret) : "a"(__n), "D"(__a1), "S"(__a2)
+                                                 : "rcx", "r11", "memory");
+       return __ret;
+}
+
+static inline long __syscall3(long __n, long __a1, long __a2, long __a3)
+{
+       unsigned long __ret;
+       __asm__ __volatile__ ("syscall" : "=a"(__ret) : "a"(__n), "D"(__a1), "S"(__a2),
+                                                 "d"(__a3) : "rcx", "r11", "memory");
+       return __ret;
+}
+
+static inline long __syscall4(long __n, long __a1, long __a2, long __a3, long __a4)
+{
+       unsigned long __ret;
+       register long __r10 __asm__("r10") = __a4;
+       __asm__ __volatile__ ("syscall" : "=a"(__ret) : "a"(__n), "D"(__a1), "S"(__a2),
+                                                 "d"(__a3), "r"(__r10): "rcx", "r11", "memory");
+       return __ret;
+}
+
+static inline long __syscall5(long __n, long __a1, long __a2, long __a3, long __a4, long __a5)
+{
+       unsigned long __ret;
+       register long __r10 __asm__("r10") = __a4;
+       register long__ r8 __asm__("r8") = __a5;
+       __asm__ __volatile__ ("syscall" : "=a"(__ret) : "a"(__n), "D"(__a1), "S"(__a2),
+                                                 "d"(__a3), "r"(__r10), "r"(__r8) : "rcx", "r11", "memory");
+       return __ret;
+}
+
+static inline long __syscall6(long __n, long __a1, long __a2, long __a3, long __a4, long __a5, long __a6)
+{
+       unsigned long __ret;
+       register long __r10 __asm__("r10") = __a4;
+       register long __r8 __asm__("r8") = __a5;
+       register long __r9 __asm__("r9") = __a6;
+       __asm__ __volatile__ ("syscall" : "=a"(__ret) : "a"(__n), "D"(__a1), "S"(__a2),
+                                                 "d"(__a3), "r"(__r10), "r"(__r8), "r"(__r9) : "rcx", "r11", "memory");
+       return __ret;
+}
+
+#define __socketcall(nm, a, b, c, d, e, f) syscall(__NR_##nm, a, b, c, d, e, f)
+
 #define __NR_read                              0
 #define __NR_write                             1
 #define __NR_open                              2

diff --git a/arch/x86_64/syscall.h b/arch/x86_64/syscall.h
deleted file mode 100644 (file)
index 9f22e6b..0000000
--- a/arch/x86_64/syscall.h
+++ /dev/null
@@ -1,113 +0,0 @@
-#ifndef _SYSCALL_H
-#define _SYSCALL_H
-
-#include <sys/syscall.h>
-
-#define SYSCALL_LL(x) x, 0
-#define SYSCALL_SIGSET_SIZE 8
-
-#if defined(SYSCALL_NORETURN)
-static inline long __syscall_ret(unsigned long r)
-{
-       for(;;);
-       return 0;
-}
-#elif defined(SYSCALL_RETURN_ERRNO)
-static inline long __syscall_ret(unsigned long r)
-{
-       return -r;
-}
-#else
-extern long __syscall_ret(unsigned long);
-#endif
-
-// 64: di,  si,  dx,  r10, r8,  r9
-// 32: ebx, ecx, edx, esi, edi, ebp
-
-#define SYSCALL "syscall"
-
-static inline long syscall0(long n)
-{
-       unsigned long ret;
-       __asm__ __volatile__ (SYSCALL : "=a"(ret) : "a"(n) : "rcx", "r11", "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall1(long n, long a1)
-{
-       unsigned long ret;
-       __asm__ __volatile__ (SYSCALL : "=a"(ret) : "a"(n), "D"(a1) : "rcx", "r11", "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall2(long n, long a1, long a2)
-{
-       unsigned long ret;
-       __asm__ __volatile__ (SYSCALL : "=a"(ret) : "a"(n), "D"(a1), "S"(a2)
-                                                 : "rcx", "r11", "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall3(long n, long a1, long a2, long a3)
-{
-       unsigned long ret;
-       __asm__ __volatile__ (SYSCALL : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
-                                                 "d"(a3) : "rcx", "r11", "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall4(long n, long a1, long a2, long a3, long a4)
-{
-       unsigned long ret;
-       register long r10 __asm__("r10") = a4;
-       __asm__ __volatile__ (SYSCALL : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
-                                                 "d"(a3), "r"(r10): "rcx", "r11", "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall5(long n, long a1, long a2, long a3, long a4,
-                                                       long a5)
-{
-       unsigned long ret;
-       register long r10 __asm__("r10") = a4;
-       register long r8 __asm__("r8") = a5;
-       __asm__ __volatile__ (SYSCALL : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
-                                                 "d"(a3), "r"(r10), "r"(r8) : "rcx", "r11", "memory");
-       return __syscall_ret(ret);
-}
-
-static inline long syscall6(long n, long a1, long a2, long a3, long a4,
-                                                       long a5, long a6)
-{
-       unsigned long ret;
-       register long r10 __asm__("r10") = a4;
-       register long r8 __asm__("r8") = a5;
-       register long r9 __asm__("r9") = a6;
-       __asm__ __volatile__ (SYSCALL : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
-                                                 "d"(a3), "r"(r10), "r"(r8), "r"(r9) : "rcx", "r11", "memory");
-       return __syscall_ret(ret);
-}
-
-#undef O_LARGEFILE
-#define O_LARGEFILE 0100000
-
-#define socketcall(nm, a, b, c, d, e, f) syscall6(__NR_##nm, \
-    (long)a, (long)b, (long)c, (long)d, (long)e, (long)f)
-
-/* the following are needed for iso c functions to use */
-#define __syscall_open(filename, flags, mode) syscall3(__NR_open, (long)(filename), (flags)|O_LARGEFILE, (mode))
-#define __syscall_read(fd, buf, len)          syscall3(__NR_read, (fd), (long)(buf), (len))
-#define __syscall_write(fd, buf, len)         syscall3(__NR_write, (fd), (long)(buf), (len))
-#define __syscall_close(fd)                   syscall1(__NR_close, (fd))
-#define __syscall_fcntl(fd, cmd, arg)         syscall3(__NR_fcntl, (fd), (cmd), (long)(arg))
-#define __syscall_dup2(old, new)              syscall2(__NR_dup2, (old), (new))
-#define __syscall_unlink(path)                syscall1(__NR_unlink, (long)(path))
-#define __syscall_getpid()                    syscall0(__NR_getpid)
-#define __syscall_kill(pid,sig)               syscall2(__NR_kill, (pid), (sig))
-#define __syscall_sigaction(sig,new,old)      syscall4(__NR_rt_sigaction, (sig), (long)(new), (long)(old), SYSCALL_SIGSET_SIZE)
-#define __syscall_ioctl(fd,ioc,arg)           syscall3(__NR_ioctl, (fd), (ioc), (long)(arg))
-#define __syscall_exit(code)                  syscall1(__NR_exit, code)
-
-long __syscall(long, ...);
-
-#endif

diff --git a/include/sys/syscall.h b/include/sys/syscall.h
index a8fec678bfee4a93db4217e8a1f7c21381b078b9..c86135a3a12d364ea941cdc3c5240e0a4970742b 100644 (file)
--- a/include/sys/syscall.h
+++ b/include/sys/syscall.h
@@ -4,11 +4,27 @@
 extern "C" {
 #endif
 
+long __syscall_ret(long);
+long __syscall(long, ...);
+long syscall(long, ...);
 
 #include <bits/syscall.h>
 
-long syscall(long, ...);
+#define __syscall1(n,a) __syscall1(n,(long)(a))
+#define __syscall2(n,a,b) __syscall2(n,(long)(a),(long)(b))
+#define __syscall3(n,a,b,c) __syscall3(n,(long)(a),(long)(b),(long)(c))
+#define __syscall4(n,a,b,c,d) __syscall4(n,(long)(a),(long)(b),(long)(c),(long)(d))
+#define __syscall5(n,a,b,c,d,e) __syscall5(n,(long)(a),(long)(b),(long)(c),(long)(d),(long)(e))
+#define __syscall6(n,a,b,c,d,e,f) __syscall6(n,(long)(a),(long)(b),(long)(c),(long)(d),(long)(e),(long)(f))
+
+#define __SYSCALL_NARGS_X(a,b,c,d,e,f,g,n,...) n
+#define __SYSCALL_NARGS(...) __SYSCALL_NARGS_X(__VA_ARGS__,6,5,4,3,2,1,0)
+#define __SYSCALL_CONCAT_X(a,b) a##b
+#define __SYSCALL_CONCAT(a,b) __SYSCALL_CONCAT_X(a,b)
+#define __SYSCALL_DISP(b,...) __SYSCALL_CONCAT(b,__SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__)
 
+#define __syscall(...) __SYSCALL_DISP(__syscall,__VA_ARGS__)
+#define syscall(...) __syscall_ret(__syscall(__VA_ARGS__))
 
 #ifdef __cplusplus
 }

diff --git a/src/exit/_Exit.c b/src/exit/_Exit.c
index 8ef85a8f206e94e7aea091b69320082652c88c3a..d18b6183c48f1f1fa99db62fac0ea57d1f97679e 100644 (file)
--- a/src/exit/_Exit.c
+++ b/src/exit/_Exit.c
@@ -1,9 +1,8 @@
 #include <stdlib.h>
-#define SYSCALL_NORETURN
 #include "syscall.h"
 
 void _Exit(int ec)
 {
-       syscall1(__NR_exit_group, ec);
-       syscall1(__NR_exit, ec);
+       __syscall(__NR_exit_group, ec);
+       __syscall(__NR_exit, ec);
 }

diff --git a/src/internal/syscall.h b/src/internal/syscall.h
new file mode 100644 (file)
index 0000000..819aafe
--- /dev/null
+++ b/src/internal/syscall.h
@@ -0,0 +1,32 @@
+#ifndef _SYSCALL_H
+#define _SYSCALL_H
+
+/* This header is mostly useless leftover wrapper cruft */
+
+#include <sys/syscall.h>
+
+#define syscall0 syscall
+#define syscall1 syscall
+#define syscall2 syscall
+#define syscall3 syscall
+#define syscall4 syscall
+#define syscall5 syscall
+#define syscall6 syscall
+
+#define socketcall __socketcall
+
+/* the following are needed for iso c functions to use */
+#define __syscall_open(filename, flags, mode) syscall(__NR_open, (filename), (flags)|0100000, (mode))
+#define __syscall_read(fd, buf, len)          syscall(__NR_read, (fd), (buf), (len))
+#define __syscall_write(fd, buf, len)         syscall(__NR_write, (fd), (buf), (len))
+#define __syscall_close(fd)                   syscall(__NR_close, (fd))
+#define __syscall_fcntl(fd, cmd, arg)         syscall(__NR_fcntl, (fd), (cmd), (arg))
+#define __syscall_dup2(old, new)              syscall(__NR_dup2, (old), (new))
+#define __syscall_unlink(path)                syscall(__NR_unlink, (path))
+#define __syscall_getpid()                    syscall(__NR_getpid)
+#define __syscall_kill(pid,sig)               syscall(__NR_kill, (pid), (sig))
+#define __syscall_sigaction(sig,new,old)      syscall(__NR_rt_sigaction, (sig), (new), (old), 8)
+#define __syscall_ioctl(fd,ioc,arg)           syscall(__NR_ioctl, (fd), (ioc), (arg))
+#define __syscall_exit(code)                  syscall(__NR_exit, code)
+
+#endif

diff --git a/src/signal/sigpending.c b/src/signal/sigpending.c
index 7deda256bda61399576f768e9abdb1883b659b55..496025a7f70693b354c494e04a6ee16bb6c1ccca 100644 (file)
--- a/src/signal/sigpending.c
+++ b/src/signal/sigpending.c
@@ -3,5 +3,5 @@
 
 int sigpending(sigset_t *set)
 {
-       return syscall2(__NR_rt_sigpending, (long)set, SYSCALL_SIGSET_SIZE);
+       return syscall(__NR_rt_sigpending, set, 8);
 }

diff --git a/src/signal/sigsuspend.c b/src/signal/sigsuspend.c
index 0806288ce5754a164a355525d9677f893ca43ff8..6c13fce139459171366585118f5ea5c306e3ab73 100644 (file)
--- a/src/signal/sigsuspend.c
+++ b/src/signal/sigsuspend.c
@@ -6,7 +6,7 @@ int sigsuspend(const sigset_t *mask)
 {
        int ret;
        CANCELPT_BEGIN;
-       ret = syscall2(__NR_rt_sigsuspend, (long)mask, SYSCALL_SIGSET_SIZE);
+       ret = syscall(__NR_rt_sigsuspend, mask, 8);
        CANCELPT_END;
        return ret;
 }

diff --git a/src/signal/sigtimedwait.c b/src/signal/sigtimedwait.c
index 93f31a713964809cb46f1dfdc3520157881b40e6..a0edaaf353a94aee7d5da4d44f12827bb454aa12 100644 (file)
--- a/src/signal/sigtimedwait.c
+++ b/src/signal/sigtimedwait.c
@@ -8,7 +8,7 @@ int sigtimedwait(const sigset_t *mask, siginfo_t *si, const struct timespec *tim
        int ret;
        CANCELPT_BEGIN;
        do {
-               ret = syscall4(__NR_rt_sigtimedwait, (long)mask, (long)si, (long)timeout, SYSCALL_SIGSET_SIZE);
+               ret = syscall(__NR_rt_sigtimedwait, mask, si, timeout, 8);
        } while (ret<0 && errno==EINTR);
        CANCELPT_END;
        return ret;

diff --git a/src/thread/__lock.c b/src/thread/__lock.c
index 557c6a62329e856537f4e7fe69e4e447bbd0c1f3..21cb71a84cf9b7c94789319c880aee2b30710d07 100644 (file)
--- a/src/thread/__lock.c
+++ b/src/thread/__lock.c
@@ -1,4 +1,3 @@
-#define SYSCALL_RETURN_ERRNO
 #include "pthread_impl.h"
 
 void __lock(volatile int *l)
@@ -8,5 +7,5 @@ void __lock(volatile int *l)
         * assignment to optimize non-pathological code with no contention. */
        while (a_xchg(l, 1))
                if (spins) spins--, a_spin();
-               else syscall0(__NR_sched_yield);
+               else __syscall(__NR_sched_yield);
 }

diff --git a/src/thread/__timedwait.c b/src/thread/__timedwait.c
index 988eb70ddf93294417442ed9878b7101cf5994d4..b38ea9901ad5080383059b8e4606271262e51797 100644 (file)
--- a/src/thread/__timedwait.c
+++ b/src/thread/__timedwait.c
@@ -1,7 +1,6 @@
 #include <time.h>
 #include <errno.h>
 #include "futex.h"
-#define SYSCALL_RETURN_ERRNO
 #include "syscall.h"
 #include <stdio.h>
 int __timedwait(volatile int *addr, int val, clockid_t clk, const struct timespec *at, int priv)
@@ -18,7 +17,7 @@ int __timedwait(volatile int *addr, int val, clockid_t clk, const struct timespe
                if (to.tv_sec < 0) return ETIMEDOUT;
        }
        if (priv) priv = 128; priv=0;
-       r = syscall4(__NR_futex, (long)addr, FUTEX_WAIT | priv, val, at ? (long)&to : 0);
+       r = __syscall(__NR_futex, (long)addr, FUTEX_WAIT | priv, val, at ? (long)&to : 0);
        if (r == ETIMEDOUT) return r;
        return 0;
 }

diff --git a/src/thread/__wait.c b/src/thread/__wait.c
index 8c249cd3538114feea460831b8aaaf8e7cf8daed..b0969bb2c879223013603f19b3adc5c4250b1966 100644 (file)
--- a/src/thread/__wait.c
+++ b/src/thread/__wait.c
@@ -1,4 +1,3 @@
-#define SYSCALL_RETURN_ERRNO
 #include "pthread_impl.h"
 
 void __wait(volatile int *addr, volatile int *waiters, int val, int priv)
@@ -11,6 +10,6 @@ void __wait(volatile int *addr, volatile int *waiters, int val, int priv)
        }
        if (waiters) a_inc(waiters);
        while (*addr==val)
-               syscall4(__NR_futex, (long)addr, FUTEX_WAIT|priv, val, 0);
+               __syscall(__NR_futex, (long)addr, FUTEX_WAIT|priv, val, 0);
        if (waiters) a_dec(waiters);
 }

diff --git a/src/thread/__wake.c b/src/thread/__wake.c
index 048ddcc01c699c32ed2edec91c092a54a655e89f..6f2f894abf8e26e18a0ba1daed06d79a886bc2e8 100644 (file)
--- a/src/thread/__wake.c
+++ b/src/thread/__wake.c
@@ -1,9 +1,8 @@
-#define SYSCALL_RETURN_ERRNO
 #include "pthread_impl.h"
 
 void __wake(volatile int *addr, int cnt, int priv)
 {
        if (priv) priv = 128; priv=0;
        if (cnt<0) cnt = INT_MAX;
-       syscall3(__NR_futex, (long)addr, FUTEX_WAKE | priv, cnt);
+       __syscall(__NR_futex, (long)addr, FUTEX_WAKE | priv, cnt);
 }

diff --git a/src/thread/pthread_cancel.c b/src/thread/pthread_cancel.c
index 9397ffe94812e59e845836afedb853bd472211a7..9f7829e6d87ab5a4d5837a61429bb27828982328 100644 (file)
--- a/src/thread/pthread_cancel.c
+++ b/src/thread/pthread_cancel.c
@@ -1,7 +1,6 @@
-#define SYSCALL_RETURN_ERRNO
 #include "pthread_impl.h"
 
 int pthread_cancel(pthread_t t)
 {
-       return syscall3(__NR_tgkill, t->pid, t->tid, SIGCANCEL);
+       return pthread_kill(t, SIGCANCEL);
 }

diff --git a/src/thread/pthread_create.c b/src/thread/pthread_create.c
index fccfa1914bc8febfb161e61fc577a34b79cda37b..3716f75a1d76103a4dbfb6820d90164973065a33 100644 (file)
--- a/src/thread/pthread_create.c
+++ b/src/thread/pthread_create.c
@@ -32,7 +32,7 @@ void __pthread_unwind_next(struct __ptcb *cb)
                exit(0);
 
        if (self->detached && self->map_base) {
-               syscall4(__NR_rt_sigprocmask, SIG_BLOCK, (long)(uint64_t[1]){-1},0,8);
+               syscall(__NR_rt_sigprocmask, SIG_BLOCK, (long)(uint64_t[1]){-1},0,8);
                __unmapself(self->map_base, self->map_size);
        }
 
@@ -91,7 +91,7 @@ static void rsyscall_handler(int sig, siginfo_t *si, void *ctx)
                return;
        }
 
-       if (__syscall(rs.nr, rs.arg[0], rs.arg[1], rs.arg[2],
+       if (syscall(rs.nr, rs.arg[0], rs.arg[1], rs.arg[2],
                rs.arg[3], rs.arg[4], rs.arg[5]) < 0 && !rs.err) rs.err=errno;
 
        a_inc(&rs.cnt);
@@ -140,7 +140,7 @@ static int rsyscall(int nr, long a, long b, long c, long d, long e, long f)
        while((i=rs.cnt)) __wait(&rs.cnt, 0, i, 1);
 
        if (rs.err) errno = rs.err, ret = -1;
-       else ret = __syscall(nr, a, b, c, d, e, f);
+       else ret = syscall(nr, a, b, c, d, e, f);
 
        UNLOCK(&rs.lock);
        return ret;

diff --git a/src/thread/pthread_kill.c b/src/thread/pthread_kill.c
index 9d85fa5b497fb06afcabf9d1258cc8e446b3dabd..6448d978d1257a0f3fd07a4454b116317b26015e 100644 (file)
--- a/src/thread/pthread_kill.c
+++ b/src/thread/pthread_kill.c
@@ -1,7 +1,6 @@
-#define SYSCALL_RETURN_ERRNO
 #include "pthread_impl.h"
 
 int pthread_kill(pthread_t t, int sig)
 {
-       return syscall3(__NR_tgkill, t->pid, t->tid, sig);
+       return __syscall(__NR_tgkill, t->pid, t->tid, sig);
 }

diff --git a/src/time/clock_nanosleep.c b/src/time/clock_nanosleep.c
index ffb9a8af0efb144df2915a4edb71bfd703997739..c777c179ba8a7dbfb18be040740522012df6bde7 100644 (file)
--- a/src/time/clock_nanosleep.c
+++ b/src/time/clock_nanosleep.c
@@ -1,4 +1,3 @@
-#define SYSCALL_RETURN_ERRNO
 #include <time.h>
 #include "syscall.h"
 #include "libc.h"
@@ -7,7 +6,7 @@ int clock_nanosleep(clockid_t clk, int flags, const struct timespec *req, struct
 {
        int ret;
        CANCELPT_BEGIN;
-       ret = syscall4(__NR_clock_nanosleep, clk, flags, (long)req, (long)rem);
+       ret = __syscall(__NR_clock_nanosleep, clk, flags, req, rem);
        CANCELPT_END;
        return ret;
 }

diff --git a/src/time/gettimeofday.c b/src/time/gettimeofday.c
index 2b8a287d36bd25fe5949ac23a09fbfb8526ec441..521b4d576811fef4376b10f9de6d0e47fcd7d108 100644 (file)
--- a/src/time/gettimeofday.c
+++ b/src/time/gettimeofday.c
@@ -1,9 +1,8 @@
-#define SYSCALL_RETURN_ERRNO
 #include <sys/time.h>
 #include "syscall.h"
 
 int gettimeofday(struct timeval *tv, void *tz)
 {
-       syscall2(__NR_gettimeofday, (long)tv, 0);
+       __syscall(__NR_gettimeofday, tv, 0);
        return 0;
 }

diff --git a/src/time/time.c b/src/time/time.c
index 3457dade75090e6ab2864e96d6c1bd3addd5b057..2d2cfd44329a28b019ea836690c128d098443d47 100644 (file)
--- a/src/time/time.c
+++ b/src/time/time.c
@@ -1,4 +1,3 @@
-#define SYSCALL_RETURN_ERRNO
 #include <time.h>
 #include <sys/time.h>
 #include "syscall.h"
@@ -6,7 +5,7 @@
 time_t time(time_t *t)
 {
        struct timeval tv;
-       syscall2(__NR_gettimeofday, (long)&tv, 0);
+       __syscall(__NR_gettimeofday, &tv, 0);
        if (t) *t = tv.tv_sec;
        return tv.tv_sec;
 }

diff --git a/src/unistd/ftruncate.c b/src/unistd/ftruncate.c
index db5da84470897aa58148140b1e0e46620ba53eba..f57ea12036fd2591462c547d6030f711df2c2b58 100644 (file)
--- a/src/unistd/ftruncate.c
+++ b/src/unistd/ftruncate.c
@@ -4,7 +4,7 @@
 
 int ftruncate(int fd, off_t length)
 {
-       return syscall3(__NR_ftruncate, fd, SYSCALL_LL(length));
+       return syscall(__NR_ftruncate, fd, __SYSCALL_LL(length));
 }
 
 LFS64(ftruncate);

diff --git a/src/unistd/pread.c b/src/unistd/pread.c
index 534215acf31b986fe36ec1445469021b60818428..16320e2cdde0f5f43129dbd56fb342c92b61d0f7 100644 (file)
--- a/src/unistd/pread.c
+++ b/src/unistd/pread.c
@@ -6,7 +6,7 @@ ssize_t pread(int fd, void *buf, size_t size, off_t ofs)
 {
        ssize_t r;
        CANCELPT_BEGIN;
-       r = syscall5(__NR_pread, fd, (long)buf, size, SYSCALL_LL(ofs));
+       r = syscall(__NR_pread, fd, buf, size, __SYSCALL_LL(ofs));
        CANCELPT_END;
        return r;
 }

diff --git a/src/unistd/pwrite.c b/src/unistd/pwrite.c
index 56ed6b4c47d71c8a144398f19fa03b25ba948596..c4d3aff557234b1bf434c31106cb25344067dba0 100644 (file)
--- a/src/unistd/pwrite.c
+++ b/src/unistd/pwrite.c
@@ -6,7 +6,7 @@ ssize_t pwrite(int fd, const void *buf, size_t size, off_t ofs)
 {
        ssize_t r;
        CANCELPT_BEGIN;
-       r = syscall5(__NR_pwrite, fd, (long)buf, size, SYSCALL_LL(ofs));
+       r = syscall(__NR_pwrite, fd, buf, size, __SYSCALL_LL(ofs));
        CANCELPT_END;
        return r;
 }

diff --git a/src/unistd/truncate.c b/src/unistd/truncate.c
index 322349d2aeebe0e38a512334f3f51f710d7c1fc8..3edacd12dd922f6c43ade722a7ed1e842ad787f6 100644 (file)
--- a/src/unistd/truncate.c
+++ b/src/unistd/truncate.c
@@ -4,7 +4,7 @@
 
 int truncate(const char *path, off_t length)
 {
-       return syscall3(__NR_truncate, (long)path, SYSCALL_LL(length));
+       return syscall(__NR_truncate, path, __SYSCALL_LL(length));
 }
 
 LFS64(truncate);