riscv
/
musl
mirror of https://git.musl-libc.org/git/musl
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

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.
rs-1.0
Rich Felker 15 years ago
parent
462dbfc207
commit
685e40bb09
26 changed files with 275 additions and 316 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      arch/i386/bits/fcntl.h
  2. 131
      arch/i386/bits/syscall.h
  3. 167
      arch/i386/syscall.h
  4. 7
      arch/x86_64/bits/fcntl.h
  5. 64
      arch/x86_64/bits/syscall.h
  6. 113
      arch/x86_64/syscall.h
  7. 18
      include/sys/syscall.h
  8. 5
      src/exit/_Exit.c
  9. 32
      src/internal/syscall.h
  10. 2
      src/signal/sigpending.c
  11. 2
      src/signal/sigsuspend.c
  12. 2
      src/signal/sigtimedwait.c
  13. 3
      src/thread/__lock.c
  14. 3
      src/thread/__timedwait.c
  15. 3
      src/thread/__wait.c
  16. 3
      src/thread/__wake.c
  17. 3
      src/thread/pthread_cancel.c
  18. 6
      src/thread/pthread_create.c
  19. 3
      src/thread/pthread_kill.c
  20. 3
      src/time/clock_nanosleep.c
  21. 3
      src/time/gettimeofday.c
  22. 3
      src/time/time.c
  23. 2
      src/unistd/ftruncate.c
  24. 2
      src/unistd/pread.c
  25. 2
      src/unistd/pwrite.c
  26. 2
      src/unistd/truncate.c

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

Write Preview
Loading…
Cancel
Save