RepoMirrors/musl
1
0
Fork 0
mirror of git://git.musl-libc.org/musl synced 2025-02-18 20:06:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

syscall overhaul part two - unify public and internal syscall interface

Browse Source 
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.
This commit is contained in:
Rich Felker 2011-03-19 21:36:10 -04:00
parent 462dbfc207
commit 685e40bb09
26 changed files with 275 additions and 316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
arch/i386/bits/fcntl.h
View File

@ -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

131
arch/i386/bits/syscall.h
View File

@ -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

167
arch/i386/syscall.h
View File

@ -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

7
arch/x86_64/bits/fcntl.h
View File

@ -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

64
arch/x86_64/bits/syscall.h
View File

@ -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

113
arch/x86_64/syscall.h
View File

@ -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

18
include/sys/syscall.h
View File

@ -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
}

5
src/exit/_Exit.c
View File

@ -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);
}

32
src/internal/syscall.h Normal file
View File

@ -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

2
src/signal/sigpending.c
View File

@ -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);
}

2
src/signal/sigsuspend.c
View File

@ -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;
}

2
src/signal/sigtimedwait.c
View File

@ -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;

3
src/thread/__lock.c
View File

@ -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);
}

3
src/thread/__timedwait.c
View File

@ -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;
}

3
src/thread/__wait.c
View File

@ -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);
}

3
src/thread/__wake.c
View File

@ -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);
}

3
src/thread/pthread_cancel.c
View File

@ -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);
}

6
src/thread/pthread_create.c
View File

@ -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;

3
src/thread/pthread_kill.c
View File

@ -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);
}

3
src/time/clock_nanosleep.c
View File

@ -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;
}

3
src/time/gettimeofday.c
View File

@ -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;
}

3
src/time/time.c
View File

@ -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;
}

2
src/unistd/ftruncate.c
View File

@ -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);

2
src/unistd/pread.c
View File

@ -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;
}

2
src/unistd/pwrite.c
View File

@ -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;
}

2
src/unistd/truncate.c
View File

@ -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);