zenithsiz/ftmemsim-valgrind
1
0
Fork 0
mirror of https://github.com/Zenithsiz/ftmemsim-valgrind.git synced 2026-02-04 02:18:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Arch-abstraction:

Browse Source 
- Moved the system call table into x86-linux, since it's platform specific.

- Started moving the non-generic syscall wrappers into linux/syscalls.c and
  x86-linux/syscalls.c as appropriate.

- Added new coregrind/linux/ directory and some files in it.


git-svn-id: svn://svn.valgrind.org/valgrind/trunk@3034
This commit is contained in:
Nicholas Nethercote 2004-11-17 17:11:45 +00:00
parent 6e422fd573
commit d0ef8153b4
6 changed files with 872 additions and 872 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.core-AM_CPPFLAGS.am
View File

@ -1,5 +1,6 @@
add_includes = -I$(top_builddir)/coregrind -I$(top_srcdir)/coregrind \
-I$(top_srcdir)/coregrind/$(VG_ARCH) \
-I$(top_srcdir)/coregrind/$(VG_OS) \
-I$(top_srcdir)/coregrind/$(VG_PLATFORM) \
-I$(top_builddir)/include -I$(top_srcdir)/include \
-I$(top_srcdir)/include/$(VG_ARCH) \

1
configure.in
View File

@ -321,6 +321,7 @@ AC_OUTPUT(
coregrind/demangle/Makefile
coregrind/docs/Makefile
coregrind/x86/Makefile
coregrind/linux/Makefile
coregrind/x86-linux/Makefile
addrcheck/Makefile
addrcheck/tests/Makefile

7
coregrind/Makefile.am
View File

@ -1,7 +1,7 @@
include $(top_srcdir)/Makefile.all.am
include $(top_srcdir)/Makefile.core-AM_CPPFLAGS.am
SUBDIRS = $(VG_ARCH) $(VG_PLATFORM) demangle . docs
SUBDIRS = $(VG_ARCH) $(VG_OS) $(VG_PLATFORM) demangle . docs
AM_CPPFLAGS += -DVG_LIBDIR="\"$(valdir)"\" -I$(srcdir)/demangle \
-DKICKSTART_BASE=@KICKSTART_BASE@ \
@ -23,6 +23,7 @@ noinst_LIBRARIES = lib_replace_malloc.a
noinst_HEADERS = \
core.h \
core_asm.h \
syscall_wrappers.h \
ume.h \
vg_symtab2.h \
vg_symtypes.h \
@ -77,10 +78,12 @@ stage2_SOURCES = \
vg_translate.c \
vg_transtab.c
## libplatform.a must be before libarch.a and libos.a, it seems.
stage2_extra= \
demangle/libdemangle.a \
${VG_PLATFORM}/libplatform.a \
${VG_ARCH}/libarch.a \
${VG_PLATFORM}/libplatform.a
${VG_OS}/libos.a
## Test repeated in both arms of the if-then-else because older versions of
## automake don't seem to like having += within an if-then-else.

364
coregrind/core.h
View File

@ -86,6 +86,11 @@
#include "core_asm.h" // asm stuff
#include "tool.h" // tool stuff
#include "core_arch.h" // arch-specific stuff, eg. x86/core_arch.h
// Ugly: this is needed by linux/core_os.h
typedef struct _ThreadState ThreadState;
#include "core_os.h" // OS-specific stuff, eg. linux/core_os.h
#include "core_platform.h" // platform-specific stuff,
// eg. x86-linux/core_platform.h
@ -703,7 +708,7 @@ typedef
typedef struct ProxyLWP ProxyLWP;
typedef
//typedef
struct _ThreadState {
/* ThreadId == 0 (and hence vg_threads[0]) is NEVER USED.
The thread identity is simply the index in vg_threads[].
@ -849,8 +854,8 @@ typedef
/* Architecture-specific thread state */
arch_thread_t arch;
}
ThreadState;
};
//ThreadState;
/* The thread table. */
@ -1397,6 +1402,336 @@ extern void VG_(atfork)(vg_atfork_t pre, vg_atfork_t parent, vg_atfork_t child);
extern void VG_(init_preopened_fds) ( void );
extern void VG_(show_open_fds) ( void );
// Return true if address range entirely contained within client
// address space.
Bool VG_(valid_client_addr)(Addr start, SizeT size, ThreadId tid,
const Char *syscallname);
// Flags describing syscall wrappers
#define Special (1 << 0)
#define MayBlock (1 << 1)
#define NBRunInLWP (1 << 2) // non-blocking, but must run in LWP context
#define PostOnFail (1 << 3)
// For each generic ("gen") wrapper, we declare the pre-wrapper, the
// post-wrapper (which is actually not always needed), and the associated
// flags.
#define GEN_SYSCALL_WRAPPER(x) \
extern UInt VGA_(gen_##x##_flags); \
extern void VGA_(gen_##x##_before)(ThreadId tid, ThreadState *tst); \
extern void VGA_(gen_##x##_after) (ThreadId tid, ThreadState *tst)
// Generic (platform-independent) syscall wrappers. These are generally
// POSIX or something like that; those that are not POSIX are annotated
// with what standards they are part of, as stated in the Linux man pages.
// Unless otherwise indicated, all those here are generic across all
// architectures at least for Linux.
//
// Nb: This list may change over time... ones thought at first to be generic
// may turn out not to be, and so be moved into OS-specific or
// platform-specific files. If there's any doubt, I'm leaving them in here.
//
// Nb 2: if porting to a new OS, you should really check all these generic
// wrappers to make sure they match your OS, painful as it might be.
GEN_SYSCALL_WRAPPER(sys_ni_syscall); // * P -- unimplemented
GEN_SYSCALL_WRAPPER(sys_exit);
GEN_SYSCALL_WRAPPER(sys_fork);
GEN_SYSCALL_WRAPPER(sys_read);
GEN_SYSCALL_WRAPPER(sys_write);
GEN_SYSCALL_WRAPPER(sys_open);
GEN_SYSCALL_WRAPPER(sys_close);
GEN_SYSCALL_WRAPPER(sys_waitpid);
GEN_SYSCALL_WRAPPER(sys_creat);
GEN_SYSCALL_WRAPPER(sys_link);
GEN_SYSCALL_WRAPPER(sys_unlink);
GEN_SYSCALL_WRAPPER(sys_execve); // 11 (*??) P
GEN_SYSCALL_WRAPPER(sys_chdir);
GEN_SYSCALL_WRAPPER(sys_time);
GEN_SYSCALL_WRAPPER(sys_mknod);
GEN_SYSCALL_WRAPPER(sys_chmod);
GEN_SYSCALL_WRAPPER(sys_lseek);
GEN_SYSCALL_WRAPPER(sys_getpid);
GEN_SYSCALL_WRAPPER(sys_alarm);
GEN_SYSCALL_WRAPPER(sys_pause);
GEN_SYSCALL_WRAPPER(sys_utime);
GEN_SYSCALL_WRAPPER(sys_access);
GEN_SYSCALL_WRAPPER(sys_kill);
GEN_SYSCALL_WRAPPER(sys_rename);
GEN_SYSCALL_WRAPPER(sys_mkdir);
GEN_SYSCALL_WRAPPER(sys_rmdir);
GEN_SYSCALL_WRAPPER(sys_dup);
GEN_SYSCALL_WRAPPER(sys_times);
GEN_SYSCALL_WRAPPER(sys_fcntl); // POSIX (but complicated)
GEN_SYSCALL_WRAPPER(sys_setpgid);
GEN_SYSCALL_WRAPPER(sys_umask);
GEN_SYSCALL_WRAPPER(sys_dup2);
GEN_SYSCALL_WRAPPER(sys_getppid);
GEN_SYSCALL_WRAPPER(sys_getpgrp);
GEN_SYSCALL_WRAPPER(sys_setsid);
GEN_SYSCALL_WRAPPER(sys_munmap);
GEN_SYSCALL_WRAPPER(sys_truncate);
GEN_SYSCALL_WRAPPER(sys_ftruncate);
GEN_SYSCALL_WRAPPER(sys_fchmod);
GEN_SYSCALL_WRAPPER(sys_msync);
GEN_SYSCALL_WRAPPER(sys_readv);
GEN_SYSCALL_WRAPPER(sys_writev);
GEN_SYSCALL_WRAPPER(sys_getsid);
GEN_SYSCALL_WRAPPER(sys_fdatasync);
GEN_SYSCALL_WRAPPER(sys_mlock);
GEN_SYSCALL_WRAPPER(sys_munlock);
GEN_SYSCALL_WRAPPER(sys_mlockall);
GEN_SYSCALL_WRAPPER(sys_munlockall);
GEN_SYSCALL_WRAPPER(sys_sched_setparam);
GEN_SYSCALL_WRAPPER(sys_sched_getparam);
GEN_SYSCALL_WRAPPER(sys_sched_setscheduler);
GEN_SYSCALL_WRAPPER(sys_sched_getscheduler);
GEN_SYSCALL_WRAPPER(sys_sched_yield);
GEN_SYSCALL_WRAPPER(sys_sched_get_priority_max);
GEN_SYSCALL_WRAPPER(sys_sched_get_priority_min);
GEN_SYSCALL_WRAPPER(sys_nanosleep);
GEN_SYSCALL_WRAPPER(sys_mremap); // POSIX, but Linux arg order may be odd
GEN_SYSCALL_WRAPPER(sys_getuid);
GEN_SYSCALL_WRAPPER(sys_getgid);
GEN_SYSCALL_WRAPPER(sys_geteuid);
GEN_SYSCALL_WRAPPER(sys_getegid);
GEN_SYSCALL_WRAPPER(sys_fsync);
GEN_SYSCALL_WRAPPER(sys_wait4);
GEN_SYSCALL_WRAPPER(sys_mprotect);
GEN_SYSCALL_WRAPPER(sys_sigprocmask);
GEN_SYSCALL_WRAPPER(sys_timer_create); // Linux: varies across archs?
GEN_SYSCALL_WRAPPER(sys_timer_settime);
GEN_SYSCALL_WRAPPER(sys_timer_gettime);
GEN_SYSCALL_WRAPPER(sys_timer_getoverrun);
GEN_SYSCALL_WRAPPER(sys_timer_delete);
GEN_SYSCALL_WRAPPER(sys_clock_settime);
GEN_SYSCALL_WRAPPER(sys_clock_gettime);
GEN_SYSCALL_WRAPPER(sys_clock_getres);
GEN_SYSCALL_WRAPPER(sys_getcwd);
// These ones aren't POSIX, but are in some standard and look reasonably
// generic, and are the same for all architectures under Linux.
GEN_SYSCALL_WRAPPER(sys_nice); // SVr4, SVID EXT, AT&T, X/OPEN, BSD 4.3
GEN_SYSCALL_WRAPPER(sys_sync); // SVr4, SVID, X/OPEN, BSD 4.3
GEN_SYSCALL_WRAPPER(sys_brk); // 4.3BSD
GEN_SYSCALL_WRAPPER(sys_acct); // SVR4, non-POSIX
GEN_SYSCALL_WRAPPER(sys_chroot); // SVr4, SVID, 4.4BSD, X/OPEN
// These ones may be Linux specific... not sure. They use 16-bit gid_t and
// uid_t types. The similarly named (minus the "16" suffix) ones below use
// 32-bit versions of these types.
GEN_SYSCALL_WRAPPER(sys_setuid16); // ## P
GEN_SYSCALL_WRAPPER(sys_getuid16); // ## P
GEN_SYSCALL_WRAPPER(sys_setgid16); // ## SVr4,SVID
GEN_SYSCALL_WRAPPER(sys_getgid16); // ## P
GEN_SYSCALL_WRAPPER(sys_geteuid16); // ## P
GEN_SYSCALL_WRAPPER(sys_getegid16); // ## P
GEN_SYSCALL_WRAPPER(sys_setreuid16); // ## BSD4.3
GEN_SYSCALL_WRAPPER(sys_setregid16); // ## BSD4.3
GEN_SYSCALL_WRAPPER(sys_getgroups16); // ## P
GEN_SYSCALL_WRAPPER(sys_setgroups16); // ## SVr4, SVID, X/OPEN, 4.3BSD
GEN_SYSCALL_WRAPPER(sys_fchown16); // ## SVr4,BSD4.3
GEN_SYSCALL_WRAPPER(sys_chown16); // ## P
GEN_SYSCALL_WRAPPER(sys_setresuid16); // ## (non-standard)
GEN_SYSCALL_WRAPPER(sys_getresuid16); // ## L
GEN_SYSCALL_WRAPPER(sys_setresgid16); // ## (non-standard)
GEN_SYSCALL_WRAPPER(sys_getresgid16); // ## L
GEN_SYSCALL_WRAPPER(sys_setresuid); // * (non-standard)
GEN_SYSCALL_WRAPPER(sys_getresuid); // * L
GEN_SYSCALL_WRAPPER(sys_setresgid); // * (non-standard)
GEN_SYSCALL_WRAPPER(sys_getresgid); // * L
GEN_SYSCALL_WRAPPER(sys_ptrace); // (x86?) (almost-P)
// Some archs on Linux do not match the generic wrapper for sys_pipe().
GEN_SYSCALL_WRAPPER(sys_pipe);
GEN_SYSCALL_WRAPPER(sys_ioctl); // */x86 (various)
// May not be generic for every architecture under Linux.
GEN_SYSCALL_WRAPPER(sys_sigaction); // (x86) P
GEN_SYSCALL_WRAPPER(sys_sigsuspend); // POSIX, but LLL (proto varies across archs)
GEN_SYSCALL_WRAPPER(sys_sigpending);
GEN_SYSCALL_WRAPPER(sys_setrlimit); // SVr4, 4.3BSD
GEN_SYSCALL_WRAPPER(sys_old_getrlimit); // SVr4, 4.3BSD LLL?
GEN_SYSCALL_WRAPPER(sys_getrusage); // SVr4, 4.3BSD
GEN_SYSCALL_WRAPPER(sys_gettimeofday);
GEN_SYSCALL_WRAPPER(sys_settimeofday); // SVr4, 4.3BSD (non-POSIX)
GEN_SYSCALL_WRAPPER(old_select); // (x86) (4.4BSD) LLL
GEN_SYSCALL_WRAPPER(sys_symlink);
GEN_SYSCALL_WRAPPER(sys_readlink); // * (X/OPEN,4.4BSD)
GEN_SYSCALL_WRAPPER(old_mmap); // (x86) (P but not...)
GEN_SYSCALL_WRAPPER(sys_getpriority); // SVr4,4.4BSD
GEN_SYSCALL_WRAPPER(sys_setpriority); // SVr4,4.4BSD
GEN_SYSCALL_WRAPPER(sys_statfs); // * L?
GEN_SYSCALL_WRAPPER(sys_fstatfs); // * L?
// Linux's funny many-in-one socketcall is certainly not generic, but I
// didn't want to move it until necessary because it's big and has a lot of
// associated junk.
GEN_SYSCALL_WRAPPER(sys_socketcall);
GEN_SYSCALL_WRAPPER(sys_setitimer); // * (SVr4,4.4BSD)
GEN_SYSCALL_WRAPPER(sys_getitimer); // * (SVr4,4.4BSD)
// XXX: funny names...
GEN_SYSCALL_WRAPPER(sys_newstat); // * P
GEN_SYSCALL_WRAPPER(sys_newlstat); // *
GEN_SYSCALL_WRAPPER(sys_newfstat); // * P (SVr4,BSD4.3)
GEN_SYSCALL_WRAPPER(sys_iopl); // (x86/amd64) L
GEN_SYSCALL_WRAPPER(sys_ipc); // (x86) L
GEN_SYSCALL_WRAPPER(sys_clone); // (x86/Linux) TTT
GEN_SYSCALL_WRAPPER(sys_newuname); // * P
GEN_SYSCALL_WRAPPER(sys_init_module); // * L?
GEN_SYSCALL_WRAPPER(sys_quotactl); // * (?)
GEN_SYSCALL_WRAPPER(sys_getpgid);
GEN_SYSCALL_WRAPPER(sys_fchdir); // * (almost-P)
GEN_SYSCALL_WRAPPER(sys_getdents); // * (SVr4,SVID)
GEN_SYSCALL_WRAPPER(sys_select); // * (4.4BSD...)
GEN_SYSCALL_WRAPPER(sys_flock); // * (4.4BSD...)
GEN_SYSCALL_WRAPPER(sys_poll); // * (XPG4-UNIX)
GEN_SYSCALL_WRAPPER(sys_rt_sigaction); // (x86) ()
GEN_SYSCALL_WRAPPER(sys_rt_sigprocmask); // * ?
GEN_SYSCALL_WRAPPER(sys_rt_sigpending); // * ?
GEN_SYSCALL_WRAPPER(sys_rt_sigtimedwait); // * ?
GEN_SYSCALL_WRAPPER(sys_rt_sigqueueinfo); // * ?
GEN_SYSCALL_WRAPPER(sys_rt_sigsuspend); // () ()
GEN_SYSCALL_WRAPPER(sys_pread64); // * (Unix98?)
GEN_SYSCALL_WRAPPER(sys_pwrite64); // * (Unix98?)
GEN_SYSCALL_WRAPPER(sys_capget); // * L?
GEN_SYSCALL_WRAPPER(sys_capset); // * L?
GEN_SYSCALL_WRAPPER(sys_sigaltstack); // (x86) (XPG4-UNIX)
GEN_SYSCALL_WRAPPER(sys_sendfile); // * L
GEN_SYSCALL_WRAPPER(sys_getpmsg); // (?) (?)
GEN_SYSCALL_WRAPPER(sys_putpmsg); // (?) (?)
GEN_SYSCALL_WRAPPER(sys_getrlimit); // * (?)
GEN_SYSCALL_WRAPPER(sys_mmap2); // (x86?) P?
GEN_SYSCALL_WRAPPER(sys_truncate64); // %% (P?)
GEN_SYSCALL_WRAPPER(sys_ftruncate64); // %% (P?)
GEN_SYSCALL_WRAPPER(sys_stat64); // %% (?)
GEN_SYSCALL_WRAPPER(sys_lstat64); // %% (?)
GEN_SYSCALL_WRAPPER(sys_fstat64); // %% (?)
GEN_SYSCALL_WRAPPER(sys_lchown); // * (L?)
GEN_SYSCALL_WRAPPER(sys_setreuid); // * (BSD4.3)
GEN_SYSCALL_WRAPPER(sys_setregid); // * (BSD4.3)
GEN_SYSCALL_WRAPPER(sys_getgroups); // * P
GEN_SYSCALL_WRAPPER(sys_setgroups); // * almost-P
GEN_SYSCALL_WRAPPER(sys_fchown); // * (SVr4,BSD4.3)
GEN_SYSCALL_WRAPPER(sys_chown); // * P
GEN_SYSCALL_WRAPPER(sys_setuid); // *
GEN_SYSCALL_WRAPPER(sys_setgid); // * (SVr4,SVID)
GEN_SYSCALL_WRAPPER(sys_mincore); // * non-P?
GEN_SYSCALL_WRAPPER(sys_madvise); // * P
GEN_SYSCALL_WRAPPER(sys_getdents64); // * (SVr4,SVID?)
GEN_SYSCALL_WRAPPER(sys_fcntl64); // * P?
GEN_SYSCALL_WRAPPER(sys_setxattr); // * L?
GEN_SYSCALL_WRAPPER(sys_lsetxattr); // * L?
GEN_SYSCALL_WRAPPER(sys_fsetxattr); // * L?
GEN_SYSCALL_WRAPPER(sys_getxattr); // * L?
GEN_SYSCALL_WRAPPER(sys_lgetxattr); // * L?
GEN_SYSCALL_WRAPPER(sys_fgetxattr); // * L?
GEN_SYSCALL_WRAPPER(sys_listxattr); // * L?
GEN_SYSCALL_WRAPPER(sys_llistxattr); // * L?
GEN_SYSCALL_WRAPPER(sys_flistxattr); // * L?
GEN_SYSCALL_WRAPPER(sys_removexattr); // * L?
GEN_SYSCALL_WRAPPER(sys_lremovexattr); // * L?
GEN_SYSCALL_WRAPPER(sys_fremovexattr); // * L?
GEN_SYSCALL_WRAPPER(sys_sendfile64); // * L
GEN_SYSCALL_WRAPPER(sys_futex); // * L
GEN_SYSCALL_WRAPPER(sys_sched_setaffinity); // * L?
GEN_SYSCALL_WRAPPER(sys_sched_getaffinity); // * L?
GEN_SYSCALL_WRAPPER(sys_exit_group); // *
GEN_SYSCALL_WRAPPER(sys_lookup_dcookie); // (*/32/64) L
GEN_SYSCALL_WRAPPER(sys_epoll_create); // * L
GEN_SYSCALL_WRAPPER(sys_epoll_ctl); // * L
GEN_SYSCALL_WRAPPER(sys_epoll_wait); // * L
GEN_SYSCALL_WRAPPER(sys_set_tid_address); // * ?
GEN_SYSCALL_WRAPPER(sys_statfs64); // * (?)
GEN_SYSCALL_WRAPPER(sys_fstatfs64); // * (?)
GEN_SYSCALL_WRAPPER(sys_utimes); // * (4.3BSD)
GEN_SYSCALL_WRAPPER(sys_mq_open); // * P?
GEN_SYSCALL_WRAPPER(sys_mq_unlink); // * P?
GEN_SYSCALL_WRAPPER(sys_mq_timedsend); // * P?
GEN_SYSCALL_WRAPPER(sys_mq_timedreceive); // * P?
GEN_SYSCALL_WRAPPER(sys_mq_notify); // * P?
GEN_SYSCALL_WRAPPER(sys_mq_getsetattr); // * P?
#undef GEN_SYSCALL_WRAPPER
// Macros used in syscall wrappers
#define PRRSN \
SK_(pre_reg_read)(Vg_CoreSysCall, tid, "(syscallno)", \
R_SYSCALL_NUM, sizeof(UWord));
#define PRRAn(n,s,t,a) \
SK_(pre_reg_read)(Vg_CoreSysCall, tid, s"("#a")", \
R_SYSCALL_ARG##n, sizeof(t));
#define PRE_REG_READ0(tr, s) \
if (VG_(defined_pre_reg_read)()) { \
PRRSN; \
}
#define PRE_REG_READ1(tr, s, t1, a1) \
if (VG_(defined_pre_reg_read)()) { \
PRRSN; \
PRRAn(1,s,t1,a1); \
}
#define PRE_REG_READ2(tr, s, t1, a1, t2, a2) \
if (VG_(defined_pre_reg_read)()) { \
PRRSN; \
PRRAn(1,s,t1,a1); PRRAn(2,s,t2,a2); \
}
#define PRE_REG_READ3(tr, s, t1, a1, t2, a2, t3, a3) \
if (VG_(defined_pre_reg_read)()) { \
PRRSN; \
PRRAn(1,s,t1,a1); PRRAn(2,s,t2,a2); PRRAn(3,s,t3,a3); \
}
#define PRE_REG_READ4(tr, s, t1, a1, t2, a2, t3, a3, t4, a4) \
if (VG_(defined_pre_reg_read)()) { \
PRRSN; \
PRRAn(1,s,t1,a1); PRRAn(2,s,t2,a2); PRRAn(3,s,t3,a3); \
PRRAn(4,s,t4,a4); \
}
#define PRE_REG_READ5(tr, s, t1, a1, t2, a2, t3, a3, t4, a4, t5, a5) \
if (VG_(defined_pre_reg_read)()) { \
PRRSN; \
PRRAn(1,s,t1,a1); PRRAn(2,s,t2,a2); PRRAn(3,s,t3,a3); \
PRRAn(4,s,t4,a4); PRRAn(5,s,t5,a5); \
}
#define PRE_REG_READ6(tr, s, t1, a1, t2, a2, t3, a3, t4, a4, t5, a5, t6, a6) \
if (VG_(defined_pre_reg_read)()) { \
PRRSN; \
PRRAn(1,s,t1,a1); PRRAn(2,s,t2,a2); PRRAn(3,s,t3,a3); \
PRRAn(4,s,t4,a4); PRRAn(5,s,t5,a5); PRRAn(6,s,t6,a6); \
}
#define PRE_MEM_READ(zzname, zzaddr, zzlen) \
VG_TRACK( pre_mem_read, Vg_CoreSysCall, tid, zzname, zzaddr, zzlen)
#define PRE_MEM_RASCIIZ(zzname, zzaddr) \
VG_TRACK( pre_mem_read_asciiz, Vg_CoreSysCall, tid, zzname, zzaddr)
#define PRE_MEM_WRITE(zzname, zzaddr, zzlen) \
VG_TRACK( pre_mem_write, Vg_CoreSysCall, tid, zzname, zzaddr, zzlen)
#define POST_MEM_WRITE(zzaddr, zzlen) \
VG_TRACK( post_mem_write, zzaddr, zzlen)
/*--------------------------------------------------------------------*/
/*--- end vg_syscalls.c ---*/
/*--------------------------------------------------------------------*/
/* ---------------------------------------------------------------------
Exports of vg_transtab.c
------------------------------------------------------------------ */
@ -1558,8 +1893,29 @@ extern void VG_(user_assert_fail) ( const Char* expr, const Char* file,
// Platform-specific things defined in eg. x86/*.c
// ---------------------------------------------------------------------
struct SyscallTableEntry {
UInt *flags_ptr;
void (*before)(ThreadId tid, ThreadState *tst);
void (*after) (ThreadId tid, ThreadState *tst);
};
/* This table is the mapping from __NR_xxx syscall numbers to the PRE/POST
wrappers for the relevant syscalls used in the OS kernel for that number.
Note that the constant names don't always match the wrapper names in a
straightforward way. For example, on x86/Linux:
__NR_lchown --> sys_lchown16()
__NR_lchown32 --> sys_lchown()
__NR_select --> old_select()
__NR__newselect --> sys_select()
*/
extern const struct SyscallTableEntry VGA_(syscall_table)[];
extern const UInt VGA_(syscall_table_size);
extern const Addr vga_sys_before, vga_sys_restarted,
vga_sys_after, vga_sys_done;
vga_sys_after, vga_sys_done;
extern void VGA_(restart_syscall)(arch_thread_t* arch);

904
coregrind/vg_syscalls.c
View File

File diff suppressed because it is too large Load Diff

467
coregrind/x86-linux/syscalls.c
View File

@ -30,6 +30,7 @@
#include "core.h"
#include "syscall_wrappers.h"
/* We need our own copy of VG_(do_syscall)() to handle a special
race-condition. If we've got signals unblocked, and we take a
@ -169,6 +170,472 @@ void VGA_(restart_syscall)(arch_thread_t *arch)
}
}
/* ---------------------------------------------------------------------
PRE/POST wrappers for x86/Linux-specific syscalls
------------------------------------------------------------------ */
// Nb: See the comment above the generic PRE/POST wrappers in
// coregrind/vg_syscalls.c for notes about how they work.
#define PRE(x,f) \
static UInt x86_linux_##x##_flags = f; \
static void x86_linux_##x##_before(ThreadId tid, ThreadState *tst)
#define POST(x) \
static void x86_linux_##x##_after (ThreadId tid, ThreadState *tst)
#define SYSNO PLATFORM_SYSCALL_NUM(tst->arch) // in PRE(x)
#define res PLATFORM_SYSCALL_RET(tst->arch) // in POST(x)
#define arg1 PLATFORM_SYSCALL_ARG1(tst->arch)
#define arg2 PLATFORM_SYSCALL_ARG2(tst->arch)
#define arg3 PLATFORM_SYSCALL_ARG3(tst->arch)
#define arg4 PLATFORM_SYSCALL_ARG4(tst->arch)
#define arg5 PLATFORM_SYSCALL_ARG5(tst->arch)
#define arg6 PLATFORM_SYSCALL_ARG6(tst->arch)
#define set_result(val) PLATFORM_SET_SYSCALL_RESULT(tst->arch, (val))
#define PRINT(format, args...) \
if (VG_(clo_trace_syscalls)) \
VG_(printf)(format, ## args)
PRE(sys_modify_ldt, Special)
{
PRINT("sys_modify_ldt ( %d, %p, %d )", arg1,arg2,arg3);
PRE_REG_READ3(int, "modify_ldt", int, func, void *, ptr,
unsigned long, bytecount);
if (arg1 == 0) {
/* read the LDT into ptr */
PRE_MEM_WRITE( "modify_ldt(ptr)", arg2, arg3 );
}
if (arg1 == 1 || arg1 == 0x11) {
/* write the LDT with the entry pointed at by ptr */
PRE_MEM_READ( "modify_ldt(ptr)", arg2, sizeof(vki_modify_ldt_t) );
}
/* "do" the syscall ourselves; the kernel never sees it */
res = VG_(sys_modify_ldt)( tid, arg1, (void*)arg2, arg3 );
if (arg1 == 0 && !VG_(is_kerror)(res) && res > 0) {
POST_MEM_WRITE( arg2, res );
}
}
PRE(sys_set_thread_area, Special)
{
PRINT("sys_set_thread_area ( %p )", arg1);
PRE_REG_READ1(int, "set_thread_area", struct user_desc *, u_info)
PRE_MEM_READ( "set_thread_area(u_info)", arg1, sizeof(vki_modify_ldt_t) );
/* "do" the syscall ourselves; the kernel never sees it */
set_result( VG_(sys_set_thread_area)( tid, (void *)arg1 ) );
}
PRE(sys_get_thread_area, Special)
{
PRINT("sys_get_thread_area ( %p )", arg1);
PRE_REG_READ1(int, "get_thread_area", struct user_desc *, u_info)
PRE_MEM_WRITE( "get_thread_area(u_info)", arg1, sizeof(vki_modify_ldt_t) );
/* "do" the syscall ourselves; the kernel never sees it */
set_result( VG_(sys_get_thread_area)( tid, (void *)arg1 ) );
if (!VG_(is_kerror)(res)) {
POST_MEM_WRITE( arg1, sizeof(vki_modify_ldt_t) );
}
}
#undef PRE
#undef POST
/* ---------------------------------------------------------------------
The x86/Linux syscall table
------------------------------------------------------------------ */
// XXX: temporary: I've started labelled each entry with the target of its
// __NR_foo-->sys_foo() mapping, and the __NR_foo number (for x86), and
// properties of the sys_foo() function:
// '*' ones are Linux-generic (ie. present in
// linux-2.6.8.1/include/linux/syscalls.h); non-generic ones have an
// indication of which architecture they are specific to.
// "##" ones are Linux-generic, but within a "#ifdef CONFIG_UID16".
// "%%" ones are Linux-generic, but within a "#if BITS_PER_LONG == 32"
// 'P' ones are POSIX-generic, according to man pages.
// 'L' ones are Linux-specific, according to man pages.
// XXX: this does duplicate the vki_unistd.h file somewhat -- could make
// this table replace that somehow...
#define GENX_(const, name) \
[const] = { &VGA_(gen_##name##_flags), VGA_(gen_##name##_before), NULL }
#define GENXY(const, name) \
[const] = { &VGA_(gen_##name##_flags), VGA_(gen_##name##_before), \
VGA_(gen_##name##_after) }
#define LINX_(const, name) \
[const] = { &VGA_(linux_##name##_flags), VGA_(linux_##name##_before), NULL }
#define LINXY(const, name) \
[const] = { &VGA_(linux_##name##_flags), VGA_(linux_##name##_before), \
VGA_(linux_##name##_after) }
#define PLAX_(const, name) \
[const] = { &x86_linux_##name##_flags, x86_linux_##name##_before, NULL }
#define PLAXY(const, name) \
[const] = { &x86_linux_##name##_flags, x86_linux_##name##_before, \
x86_linux_##name##_after }
// This table maps from __NR_xxx syscall numbers to the appropriate
// PRE/POST sys_foo() wrappers on x86.
const struct SyscallTableEntry VGA_(syscall_table)[] = {
// (restart_syscall) // 0
GENX_(__NR_exit, sys_exit), // 1
GENXY(__NR_fork, sys_fork), // 2
GENXY(__NR_read, sys_read), // 3
GENX_(__NR_write, sys_write), // 4
GENXY(__NR_open, sys_open), // 5
GENXY(__NR_close, sys_close), // 6
GENXY(__NR_waitpid, sys_waitpid), // 7
GENXY(__NR_creat, sys_creat), // 8
GENX_(__NR_link, sys_link), // 9
GENX_(__NR_unlink, sys_unlink), // 10
GENX_(__NR_execve, sys_execve), // 11 (*??) P
GENX_(__NR_chdir, sys_chdir), // 12
GENXY(__NR_time, sys_time), // 13
GENX_(__NR_mknod, sys_mknod), // 14
GENX_(__NR_chmod, sys_chmod), // 15
// (__NR_lchown, sys_lchown16), // 16 ## P
GENX_(__NR_break, sys_ni_syscall), // 17 -- unimplemented
// (__NR_oldstat, sys_stat), // 18 * L -- obsolete
GENX_(__NR_lseek, sys_lseek), // 19
GENX_(__NR_getpid, sys_getpid), // 20
LINX_(__NR_mount, sys_mount), // 21
LINX_(__NR_umount, sys_oldumount), // 22
GENX_(__NR_setuid, sys_setuid16), // 23 ## P
GENX_(__NR_getuid, sys_getuid16), // 24 ## P
// (__NR_stime, sys_stime), // 25 * (SVr4,SVID,X/OPEN)
GENXY(__NR_ptrace, sys_ptrace), // 26 (x86?) (L?)
GENX_(__NR_alarm, sys_alarm), // 27 * P
// (__NR_oldfstat, sys_fstat), // 28 * L -- obsolete
GENX_(__NR_pause, sys_pause), // 29 * P
GENX_(__NR_utime, sys_utime), // 30 * P
GENX_(__NR_stty, sys_ni_syscall), // 31 -- unimplemented
GENX_(__NR_gtty, sys_ni_syscall), // 32 -- unimplemented
GENX_(__NR_access, sys_access), // 33 * P
GENX_(__NR_nice, sys_nice), // 34 * (almost P)
GENX_(__NR_ftime, sys_ni_syscall), // 35 -- unimplemented
GENX_(__NR_sync, sys_sync), // 36 * (almost P)
GENXY(__NR_kill, sys_kill), // 37
GENX_(__NR_rename, sys_rename), // 38
GENX_(__NR_mkdir, sys_mkdir), // 39
GENX_(__NR_rmdir, sys_rmdir), // 40
GENXY(__NR_dup, sys_dup), // 41
GENXY(__NR_pipe, sys_pipe), // 42 (x86) P
GENXY(__NR_times, sys_times), // 43
GENX_(__NR_prof, sys_ni_syscall), // 44 -- unimplemented
GENX_(__NR_brk, sys_brk), // 45 * non-P
GENX_(__NR_setgid, sys_setgid16), // 46 ## (SVr4,SVID)
GENX_(__NR_getgid, sys_getgid16), // 47 ## P
// (__NR_signal, sys_signal), // 48 * (ANSI C?)
GENX_(__NR_geteuid, sys_geteuid16), // 49 ## P
GENX_(__NR_getegid, sys_getegid16), // 50 ## (P16)
GENX_(__NR_acct, sys_acct), // 51 * (SVR4, non-POSIX)
LINX_(__NR_umount2, sys_umount), // 52
GENX_(__NR_lock, sys_ni_syscall), // 53 -- unimplemented
GENXY(__NR_ioctl, sys_ioctl), // 54 */x86 (varying)
GENXY(__NR_fcntl, sys_fcntl), // 55
GENX_(__NR_mpx, sys_ni_syscall), // 56 -- unimplemented
GENXY(__NR_setpgid, sys_setpgid), // 57 * P
GENX_(__NR_ulimit, sys_ni_syscall), // 58 -- unimplemented
// (__NR_oldolduname, sys_olduname), // 59 (?) L -- obsolete
GENX_(__NR_umask, sys_umask), // 60
GENX_(__NR_chroot, sys_chroot), // 61 * (almost P)
// (__NR_ustat, sys_ustat) // 62 * (SVr4) -- deprecated
GENXY(__NR_dup2, sys_dup2), // 63
GENX_(__NR_getppid, sys_getppid), // 64
GENX_(__NR_getpgrp, sys_getpgrp), // 65
GENX_(__NR_setsid, sys_setsid), // 66
GENXY(__NR_sigaction, sys_sigaction), // 67 (x86) P
// (__NR_sgetmask, sys_sgetmask), // 68 * (ANSI C)
// (__NR_ssetmask, sys_ssetmask), // 69 * (ANSI C)
GENX_(__NR_setreuid, sys_setreuid16), // 70 ## (BSD4.3)
GENX_(__NR_setregid, sys_setregid16), // 71 ## (BSD4.3)
GENX_(__NR_sigsuspend, sys_sigsuspend), // 72 () P
GENXY(__NR_sigpending, sys_sigpending), // 73 * P
// (__NR_sethostname, sys_sethostname), // 74 * (almost P)
GENX_(__NR_setrlimit, sys_setrlimit), // 75 * (SVr4,BSD4.3)
GENXY(__NR_getrlimit, sys_old_getrlimit), // 76 * (SVr4,BSD4.3)
GENXY(__NR_getrusage, sys_getrusage), // 77 * (SVr4,BSD4.3)
GENXY(__NR_gettimeofday, sys_gettimeofday), // 78 * P
GENX_(__NR_settimeofday, sys_settimeofday), // 79 * almost-P
GENXY(__NR_getgroups, sys_getgroups16), // 80 ## P
GENX_(__NR_setgroups, sys_setgroups16), // 81 ## almost-P
GENX_(__NR_select, old_select), // 82 (x86) (4.4BSD)
GENX_(__NR_symlink, sys_symlink), // 83 * P
// (__NR_oldlstat, sys_lstat), // 84 * L -- obsolete
GENXY(__NR_readlink, sys_readlink), // 85 * (X/OPEN,4.4BSD)
// (__NR_uselib, sys_uselib), // 86 * L
// (__NR_swapon, sys_swapon), // 87 * L
// (__NR_reboot, sys_reboot), // 88 * L
// (__NR_readdir, old_readdir), // 89 () L -- superseded
GENX_(__NR_mmap, old_mmap), // 90 (x86) (P but not...)
GENXY(__NR_munmap, sys_munmap), // 91
GENX_(__NR_truncate, sys_truncate), // 92
GENX_(__NR_ftruncate, sys_ftruncate), // 93
GENX_(__NR_fchmod, sys_fchmod), // 94
GENX_(__NR_fchown, sys_fchown16), // 95 ## (SVr4,BSD4.3)
GENX_(__NR_getpriority, sys_getpriority), // 96 * (SVr4,4.4BSD)
GENX_(__NR_setpriority, sys_setpriority), // 97 * (SVr4,4.4BSD)
GENX_(__NR_profil, sys_ni_syscall), // 98 -- unimplemented
GENXY(__NR_statfs, sys_statfs), // 99 * (P-ish)
GENXY(__NR_fstatfs, sys_fstatfs), // 100 * (P-ish)
LINX_(__NR_ioperm, sys_ioperm), // 101 * L
GENXY(__NR_socketcall, sys_socketcall), // 102 */Linux (?)
LINXY(__NR_syslog, sys_syslog), // 103
GENXY(__NR_setitimer, sys_setitimer), // 104 * (SVr4,4.4BSD)
GENXY(__NR_getitimer, sys_getitimer), // 105 * (SVr4,4.4BSD)
GENXY(__NR_stat, sys_newstat), // 106 * P
GENXY(__NR_lstat, sys_newlstat), // 107 *
GENXY(__NR_fstat, sys_newfstat), // 108 * P (SVr4,BSD4.3)
// (__NR_olduname, sys_uname), // 109 (?) L -- obsolete
GENX_(__NR_iopl, sys_iopl), // 110 (x86/amd64) L
LINX_(__NR_vhangup, sys_vhangup), // 111
GENX_(__NR_idle, sys_ni_syscall), // 112 -- unimplemented
// (__NR_vm86old, sys_vm86old), // 113 x86/Linux-only
GENXY(__NR_wait4, sys_wait4), // 114 * P
// (__NR_swapoff, sys_swapoff), // 115 */Linux
LINXY(__NR_sysinfo, sys_sysinfo), // 116
GENXY(__NR_ipc, sys_ipc), // 117 (x86) L
GENX_(__NR_fsync, sys_fsync), // 118
// (__NR_sigreturn, sys_sigreturn), // 119 () L
GENX_(__NR_clone, sys_clone), // 120 (x86) L
// (__NR_setdomainname, sys_setdomainname), // 121 * (non-P?)
GENXY(__NR_uname, sys_newuname), // 122 * P
PLAX_(__NR_modify_ldt, sys_modify_ldt), // 123 (x86,amd64) L
LINXY(__NR_adjtimex, sys_adjtimex), // 124 * L
GENXY(__NR_mprotect, sys_mprotect), // 125 * P
GENXY(__NR_sigprocmask, sys_sigprocmask), // 126 * P
// Nb: create_module() was removed 2.4-->2.6
GENX_(__NR_create_module, sys_ni_syscall), // 127 -- unimplemented
GENX_(__NR_init_module, sys_init_module), // 128 * L?
// (__NR_delete_module, sys_delete_module), // 129 () (L?)
// Nb: get_kernel_syms() was removed 2.4-->2.6
GENX_(__NR_get_kernel_syms, sys_ni_syscall), // 130 -- unimplemented
GENX_(__NR_quotactl, sys_quotactl), // 131 * (?)
GENX_(__NR_getpgid, sys_getpgid), // 132
GENX_(__NR_fchdir, sys_fchdir), // 133 * (almost-P)
// (__NR_bdflush, sys_bdflush), // 134 * L
// (__NR_sysfs, sys_sysfs), // 135 * (SVr4)
LINX_(__NR_personality, sys_personality), // 136
GENX_(__NR_afs_syscall, sys_ni_syscall), // 137 -- unimplemented
LINX_(__NR_setfsuid, sys_setfsuid16), // 138 ## L
LINX_(__NR_setfsgid, sys_setfsgid16), // 139 ## L
LINXY(__NR__llseek, sys_llseek), // 140
GENXY(__NR_getdents, sys_getdents), // 141 * (SVr4,SVID)
GENX_(__NR__newselect, sys_select), // 142 * (4.4BSD...)
GENX_(__NR_flock, sys_flock), // 143 * (4.4BSD...)
GENX_(__NR_msync, sys_msync), // 144 * P
GENXY(__NR_readv, sys_readv), // 145 * P
GENX_(__NR_writev, sys_writev), // 146 * P
GENX_(__NR_getsid, sys_getsid), // 147 * P
GENX_(__NR_fdatasync, sys_fdatasync), // 148 * P
LINXY(__NR__sysctl, sys_sysctl), // 149
GENX_(__NR_mlock, sys_mlock), // 150
GENX_(__NR_munlock, sys_munlock), // 151
GENX_(__NR_mlockall, sys_mlockall), // 152
GENX_(__NR_munlockall, sys_munlockall), // 153
GENXY(__NR_sched_setparam, sys_sched_setparam), // 154
GENXY(__NR_sched_getparam, sys_sched_getparam), // 155
GENX_(__NR_sched_setscheduler, sys_sched_setscheduler), // 156
GENX_(__NR_sched_getscheduler, sys_sched_getscheduler), // 157
GENX_(__NR_sched_yield, sys_sched_yield), // 158
GENX_(__NR_sched_get_priority_max, sys_sched_get_priority_max),// 159
GENX_(__NR_sched_get_priority_min, sys_sched_get_priority_min),// 160
// (__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 161 (gen)
GENXY(__NR_nanosleep, sys_nanosleep), // 162
GENX_(__NR_mremap, sys_mremap), // 163
GENX_(__NR_setresuid, sys_setresuid16), // 164
GENXY(__NR_getresuid, sys_getresuid16), // 165
// (__NR_vm86, sys_vm86), // 166 x86/Linux-only
GENX_(__NR_query_module, sys_ni_syscall), // 167 -- unimplemented
GENXY(__NR_poll, sys_poll), // 168 * (XPG4-UNIX)
// (__NR_nfsservctl, sys_nfsservctl), // 169 * L
GENX_(__NR_setresgid, sys_setresgid16), // 170
GENXY(__NR_getresgid, sys_getresgid16), // 171
LINX_(__NR_prctl, sys_prctl), // 172
// (__NR_rt_sigreturn, sys_rt_sigreturn), // 173 (x86) ()
GENXY(__NR_rt_sigaction, sys_rt_sigaction), // 174 (x86) ()
GENXY(__NR_rt_sigprocmask, sys_rt_sigprocmask), // 175 * ?
GENXY(__NR_rt_sigpending, sys_rt_sigpending), // 176 * ?
GENXY(__NR_rt_sigtimedwait, sys_rt_sigtimedwait),// 177 * ?
GENXY(__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo),// 178 * ?
GENX_(__NR_rt_sigsuspend, sys_rt_sigsuspend), // 179 () ()
GENXY(__NR_pread64, sys_pread64), // 180 * (Unix98?)
GENX_(__NR_pwrite64, sys_pwrite64), // 181 * (Unix98?)
GENX_(__NR_chown, sys_chown16), // 182 * P
GENXY(__NR_getcwd, sys_getcwd), // 183 * P
GENXY(__NR_capget, sys_capget), // 184 * L?
GENX_(__NR_capset, sys_capset), // 185 * L?
GENXY(__NR_sigaltstack, sys_sigaltstack), // 186 (x86) (XPG4-UNIX)
GENXY(__NR_sendfile, sys_sendfile), // 187 * L
GENXY(__NR_getpmsg, sys_getpmsg), // 188 (?) (?)
GENX_(__NR_putpmsg, sys_putpmsg), // 189 (?) (?)
// Nb: we convert vfork() to fork() in VG_(pre_syscall)().
// (__NR_vfork, sys_vfork), // 190 -- Valgrind avoids
GENXY(__NR_ugetrlimit, sys_getrlimit), // 191 * (?)
GENXY(__NR_mmap2, sys_mmap2), // 192 (x86?) P?
GENX_(__NR_truncate64, sys_truncate64), // 193 %% (P?)
GENX_(__NR_ftruncate64, sys_ftruncate64), // 194 %% (P?)
GENXY(__NR_stat64, sys_stat64), // 195 %% (?)
GENXY(__NR_lstat64, sys_lstat64), // 196 %% (?)
GENXY(__NR_fstat64, sys_fstat64), // 197 %% (?)
GENX_(__NR_lchown32, sys_lchown), // 198 * (L?)
GENX_(__NR_getuid32, sys_getuid), // 199
GENX_(__NR_getgid32, sys_getgid), // 200
GENX_(__NR_geteuid32, sys_geteuid), // 201
GENX_(__NR_getegid32, sys_getegid), // 202
GENX_(__NR_setreuid32, sys_setreuid), // 203 * (BSD4.3)
GENX_(__NR_setregid32, sys_setregid), // 204 * (BSD4.3)
GENXY(__NR_getgroups32, sys_getgroups), // 205 * P
GENX_(__NR_setgroups32, sys_setgroups), // 206 * almost-P
GENX_(__NR_fchown32, sys_fchown), // 207 * (SVr4,BSD4.3)
GENX_(__NR_setresuid32, sys_setresuid), // 208
GENXY(__NR_getresuid32, sys_getresuid), // 209
GENX_(__NR_setresgid32, sys_setresgid), // 210
GENXY(__NR_getresgid32, sys_getresgid), // 211
GENX_(__NR_chown32, sys_chown), // 212 * P
GENX_(__NR_setuid32, sys_setuid), // 213 *
GENX_(__NR_setgid32, sys_setgid), // 214 * (SVr4,SVID)
LINX_(__NR_setfsuid32, sys_setfsuid), // 215
LINX_(__NR_setfsgid32, sys_setfsgid), // 216
// (__NR_pivot_root, sys_pivot_root), // 217 */Linux
GENXY(__NR_mincore, sys_mincore), // 218 * non-P?
GENX_(__NR_madvise, sys_madvise), // 219 * P
GENXY(__NR_getdents64, sys_getdents64), // 220 * (SVr4,SVID?)
GENXY(__NR_fcntl64, sys_fcntl64), // 221 * P?
GENX_(222, sys_ni_syscall), // 222 -- reserved for TUX
GENX_(223, sys_ni_syscall), // 223 -- unused
// (__NR_gettid, sys_gettid), // 224 */Linux
// (__NR_readahead, sys_readahead), // 225 */(Linux?)
GENX_(__NR_setxattr, sys_setxattr), // 226 * L?
GENX_(__NR_lsetxattr, sys_lsetxattr), // 227 * L?
GENX_(__NR_fsetxattr, sys_fsetxattr), // 228 * L?
GENXY(__NR_getxattr, sys_getxattr), // 229 * L?
GENXY(__NR_lgetxattr, sys_lgetxattr), // 230 * L?
GENXY(__NR_fgetxattr, sys_fgetxattr), // 231 * L?
GENXY(__NR_listxattr, sys_listxattr), // 232 * L?
GENXY(__NR_llistxattr, sys_llistxattr), // 233 * L?
GENXY(__NR_flistxattr, sys_flistxattr), // 234 * L?
GENX_(__NR_removexattr, sys_removexattr), // 235 * L?
GENX_(__NR_lremovexattr, sys_lremovexattr), // 236 * L?
GENX_(__NR_fremovexattr, sys_fremovexattr), // 237 * L?
// (__NR_tkill, sys_tkill), // 238 */Linux
GENXY(__NR_sendfile64, sys_sendfile64), // 239 * L
GENXY(__NR_futex, sys_futex), // 240 * L
GENX_(__NR_sched_setaffinity, sys_sched_setaffinity), // 241 * L?
GENXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 242 * L?
PLAX_(__NR_set_thread_area, sys_set_thread_area), // 243
PLAX_(__NR_get_thread_area, sys_get_thread_area), // 244
LINX_(__NR_io_setup, sys_io_setup), // 245
LINX_(__NR_io_destroy, sys_io_destroy), // 246
LINXY(__NR_io_getevents, sys_io_getevents), // 247
LINX_(__NR_io_submit, sys_io_submit), // 248
LINXY(__NR_io_cancel, sys_io_cancel), // 249
// (__NR_fadvise64, sys_fadvise64), // 250 * ()
GENX_(251, sys_ni_syscall), // 251 -- unused
GENX_(__NR_exit_group, sys_exit_group), // 252 *
GENXY(__NR_lookup_dcookie, sys_lookup_dcookie), // 253 (*/32/64) L
GENXY(__NR_epoll_create, sys_epoll_create), // 254 * L
GENX_(__NR_epoll_ctl, sys_epoll_ctl), // 255 * L
GENXY(__NR_epoll_wait, sys_epoll_wait), // 256 * L
// (__NR_remap_file_pages, sys_remap_file_pages), // 257 * L
GENX_(__NR_set_tid_address, sys_set_tid_address), // 258 * ?
GENXY(__NR_timer_create, sys_timer_create), // 259 (?) P
GENXY(__NR_timer_settime, sys_timer_settime), // (timer_create+1) * P
GENXY(__NR_timer_gettime, sys_timer_gettime), // (timer_create+2) * P
GENX_(__NR_timer_getoverrun, sys_timer_getoverrun),//(timer_create+3) * P
GENX_(__NR_timer_delete, sys_timer_delete), // (timer_create+4) * P
GENX_(__NR_clock_settime, sys_clock_settime), // (timer_create+5) * P
GENXY(__NR_clock_gettime, sys_clock_gettime), // (timer_create+6) * P
GENXY(__NR_clock_getres, sys_clock_getres), // (timer_create+7) * P
// (__NR_clock_nanosleep, sys_clock_nanosleep),// (timer_create+8) * P
GENXY(__NR_statfs64, sys_statfs64), // 268 * (?)
GENXY(__NR_fstatfs64, sys_fstatfs64), // 269 * (?)
// (__NR_tgkill, sys_tgkill), // 270 */Linux
GENX_(__NR_utimes, sys_utimes), // 271 * (4.3BSD)
// (__NR_fadvise64_64, sys_fadvise64_64), // 272 */(Linux?)
GENX_(__NR_vserver, sys_ni_syscall), // 273 -- unimplemented
// (__NR_mbind, sys_mbind), // 274 ?/?
// (__NR_get_mempolicy, sys_get_mempolicy), // 275 ?/?
// (__NR_set_mempolicy, sys_set_mempolicy), // 276 ?/?
GENXY(__NR_mq_open, sys_mq_open), // 277 * P?
GENX_(__NR_mq_unlink, sys_mq_unlink), // (mq_open+1) * P?
GENX_(__NR_mq_timedsend, sys_mq_timedsend), // (mq_open+2) * P?
GENXY(__NR_mq_timedreceive, sys_mq_timedreceive),// (mq_open+3) * P?
GENX_(__NR_mq_notify, sys_mq_notify), // (mq_open+4) * P?
GENXY(__NR_mq_getsetattr, sys_mq_getsetattr), // (mq_open+5) * P?
GENX_(__NR_sys_kexec_load, sys_ni_syscall), // 283
};
const UInt VGA_(syscall_table_size) =
sizeof(VGA_(syscall_table)) / sizeof(VGA_(syscall_table)[0]);
#undef GENX_
#undef GENXY
/*--------------------------------------------------------------------*/
/*--- end ---*/
/*--------------------------------------------------------------------*/