Esempio n. 1
0
}

#undef PRE
#undef POST

/* ---------------------------------------------------------------------
   The mips64/Linux syscall table
   ------------------------------------------------------------------ */

/* Add an mips64-linux specific wrapper to a syscall table. */
#define PLAX_(sysno, name)    WRAPPER_ENTRY_X_(mips_linux, sysno, name)
#define PLAXY(sysno, name)    WRAPPER_ENTRY_XY(mips_linux, sysno, name)

static SyscallTableEntry syscall_main_table[] = {
   GENXY (__NR_read, sys_read),  /* 5000 */
   GENX_ (__NR_write, sys_write),
   GENXY (__NR_open, sys_open),
   GENXY (__NR_close, sys_close),
   GENXY (__NR_stat, sys_newstat),
   GENXY (__NR_fstat, sys_newfstat),
   GENXY (__NR_lstat, sys_newlstat),
   GENXY (__NR_poll, sys_poll),
   LINX_ (__NR_lseek, sys_lseek),
   PLAX_ (__NR_mmap, sys_mmap),
   GENXY (__NR_mprotect, sys_mprotect),
   GENXY (__NR_munmap, sys_munmap),
   GENX_ (__NR_brk, sys_brk),
   LINXY (__NR_rt_sigaction, sys_rt_sigaction),
   LINXY (__NR_rt_sigprocmask, sys_rt_sigprocmask),
   LINXY (__NR_ioctl, sys_ioctl),
   LINXY (__NR_eventfd2, sys_eventfd2),
  LINXY(__NR_lookup_dcookie,    sys_lookup_dcookie),       // 18
  LINX_(__NR_eventfd2,          sys_eventfd2),             // 19
  LINXY(__NR_epoll_create1,     sys_epoll_create1),        // 20
  LINX_(__NR_epoll_ctl,         sys_epoll_ctl),            // 21
  LINXY(__NR_epoll_pwait,       sys_epoll_pwait),          // 22
  GENXY(__NR_dup,               sys_dup),                  // 23
  GENXY(__NR_dup2,              sys_dup2),                 // 23
  LINXY(__NR_dup3,              sys_dup3),                 // 24
  LINXY(__NR_fcntl,             sys_fcntl),                // 25
  LINXY(__NR_inotify_init1,     sys_inotify_init1),        // 26
  LINX_(__NR_inotify_add_watch, sys_inotify_add_watch),    // 27
  LINX_(__NR_inotify_rm_watch,  sys_inotify_rm_watch),     // 28
  LINXY(__NR_ioctl,             sys_ioctl),                // 29
  LINX_(__NR_ioprio_set,        sys_ioprio_set),           // 30
  LINX_(__NR_ioprio_get,        sys_ioprio_get),           // 31
  GENX_(__NR_flock,             sys_flock),                // 32
  LINX_(__NR_mknodat,           sys_mknodat),              // 33
  LINX_(__NR_mkdirat,           sys_mkdirat),              // 34
  LINX_(__NR_unlinkat,          sys_unlinkat),             // 35
  LINX_(__NR_symlinkat,         sys_symlinkat),            // 36
  LINX_(__NR_linkat,            sys_linkat),               // 37
  LINX_(__NR_renameat,          sys_renameat),             // 38
  LINX_(__NR_umount2,           sys_umount),               // 39
  LINX_(__NR_mount,             sys_mount),                // 40

  GENXY(__NR_statfs,            sys_statfs),               // 43
  GENXY(__NR_fstatfs,           sys_fstatfs),              // 44
  GENX_(__NR_truncate,          sys_truncate),             // 45
  GENX_(__NR_ftruncate,         sys_ftruncate),            // 46
  LINX_(__NR_fallocate,         sys_fallocate),            // 47
  LINX_(__NR_faccessat,         sys_faccessat),            // 48
#endif

#define PLAX_(sysno, name)    WRAPPER_ENTRY_X_(arm_linux, sysno, name) 
#define PLAXY(sysno, name)    WRAPPER_ENTRY_XY(arm_linux, sysno, name)

// This table maps from __NR_xxx syscall numbers (from
// linux/include/asm-arm/unistd.h) to the appropriate PRE/POST sys_foo()
// wrappers on arm (as per sys_call_table in linux/arch/arm/kernel/entry.S).
//
// For those syscalls not handled by Valgrind, the annotation indicate its
// arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/?
// (unknown).

static SyscallTableEntry syscall_main_table[] = {
//zz    //   (restart_syscall)                             // 0
   GENX_(__NR_exit,              sys_exit),           // 1
   GENX_(__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
   GENX_(__NR_chdir,             sys_chdir),          // 12
   GENXY(__NR_time,              sys_time),           // 13
   GENX_(__NR_mknod,             sys_mknod),          // 14
/* Add an amd64-linux specific wrapper to a syscall table. */
#define PLAX_(const, name)    WRAPPER_ENTRY_X_(amd64_linux, const, name) 
#define PLAXY(const, name)    WRAPPER_ENTRY_XY(amd64_linux, const, name) 

// This table maps from __NR_xxx syscall numbers (from
// linux/include/asm-x86_64/unistd.h) to the appropriate PRE/POST sys_foo()
// wrappers on AMD64 (as per sys_call_table in
// linux/arch/x86_64/kernel/entry.S).
//
// When implementing these wrappers, you need to work out if the wrapper is
// generic, Linux-only (but arch-independent), or AMD64/Linux only.

const SyscallTableEntry ML_(syscall_table)[] = {
   GENXY(__NR_read,              sys_read),           // 0 
   GENX_(__NR_write,             sys_write),          // 1 
   GENXY(__NR_open,              sys_open),           // 2 
   GENXY(__NR_close,             sys_close),          // 3 
   GENXY(__NR_stat,              sys_newstat),        // 4 

   GENXY(__NR_fstat,             sys_newfstat),       // 5 
   GENXY(__NR_lstat,             sys_newlstat),       // 6 
   GENXY(__NR_poll,              sys_poll),           // 7 
   LINX_(__NR_lseek,             sys_lseek),          // 8 
   PLAX_(__NR_mmap,              sys_mmap),           // 9 

   GENXY(__NR_mprotect,          sys_mprotect),       // 10 
   GENXY(__NR_munmap,            sys_munmap),         // 11 
   GENX_(__NR_brk,               sys_brk),            // 12 
   LINXY(__NR_rt_sigaction,      sys_rt_sigaction),   // 13 
   LINXY(__NR_rt_sigprocmask,    sys_rt_sigprocmask), // 14 
/* Add an ppc32-linux specific wrapper to a syscall table. */
#define PLAX_(sysno, name)    WRAPPER_ENTRY_X_(ppc32_linux, sysno, name) 
#define PLAXY(sysno, name)    WRAPPER_ENTRY_XY(ppc32_linux, sysno, name)

// This table maps from __NR_xxx syscall numbers (from
// linux/include/asm-ppc/unistd.h) to the appropriate PRE/POST sys_foo()
// wrappers on ppc32 (as per sys_call_table in linux/arch/ppc/kernel/entry.S).
//
// For those syscalls not handled by Valgrind, the annotation indicate its
// arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/?
// (unknown).

static SyscallTableEntry syscall_table[] = {
//..   (restart_syscall)                                      // 0
   GENX_(__NR_exit,              sys_exit),              // 1
   GENX_(__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
   GENX_(__NR_chdir,             sys_chdir),             // 12
   GENXY(__NR_time,              sys_time),              // 13
   GENX_(__NR_mknod,             sys_mknod),             // 14