coregrind/m_syswrap/syswrap-arm64-linux.c

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- Platform-specific syscalls stuff.    syswrap-arm64-linux.c -----*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Valgrind, a dynamic binary instrumentation
   8    framework.
   9
  10    Copyright (C) 2013-2015 OpenWorks
  11       info@open-works.net
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation; either version 2 of the
  16    License, or (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful, but
  19    WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software
  25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  26    02111-1307, USA.
  27
  28    The GNU General Public License is contained in the file COPYING.
  29 */
  30
  31 #if defined(VGP_arm64_linux)
  32
  33 #include "pub_core_basics.h"
  34 #include "pub_core_vki.h"
  35 #include "pub_core_vkiscnums.h"
  36 #include "pub_core_threadstate.h"
  37 #include "pub_core_aspacemgr.h"
  38 #include "pub_core_libcbase.h"
  39 #include "pub_core_libcassert.h"
  40 #include "pub_core_libcprint.h"
  41 #include "pub_core_libcsignal.h"
  42 #include "pub_core_options.h"
  43 #include "pub_core_scheduler.h"
  44 #include "pub_core_sigframe.h"      // For VG_(sigframe_destroy)()
  45 #include "pub_core_syscall.h"
  46 #include "pub_core_syswrap.h"
  47 #include "pub_core_tooliface.h"
  48
  49 #include "priv_types_n_macros.h"
  50 #include "priv_syswrap-generic.h"   /* for decls of generic wrappers */
  51 #include "priv_syswrap-linux.h"     /* for decls of linux-ish wrappers */
  52
  53
  54 /* ---------------------------------------------------------------------
  55    clone() handling
  56    ------------------------------------------------------------------ */
  57
  58 /* Call f(arg1), but first switch stacks, using 'stack' as the new
  59    stack, and use 'retaddr' as f's return-to address.  Also, clear all
  60    the integer registers before entering f.*/
  61 __attribute__((noreturn))
  62 void ML_(call_on_new_stack_0_1) ( Addr stack,
  63                                   Addr retaddr,
  64                                   void (*f)(Word),
  65                                   Word arg1 );
  66 //    r0 = stack
  67 //    r1 = retaddr
  68 //    r2 = f
  69 //    r3 = arg1
  70 asm(
  71 ".text\n"
  72 ".globl vgModuleLocal_call_on_new_stack_0_1\n"
  73 "vgModuleLocal_call_on_new_stack_0_1:\n"
  74 "   mov    sp, x0\n\t" /* Stack pointer */
  75 "   mov    x30, x1\n\t" /* Return address (x30 is LR) */
  76 "   mov    x0, x3\n\t" /* First argument */
  77 "   mov    x9, x2\n\t" /* 'f': x9 won't be zeroed at start of f.  Oh well. */
  78 "   mov    x1, #0\n\t" /* Clear our GPRs */
  79 "   mov    x2, #0\n\t"
  80 "   mov    x3, #0\n\t"
  81 "   mov    x4, #0\n\t"
  82 "   mov    x5, #0\n\t"
  83 "   mov    x6, #0\n\t"
  84 "   mov    x7, #0\n\t"
  85 "   mov    x8, #0\n\t"
  86 /* don't zero out x9 */
  87 "   mov    x10, #0\n\t"
  88 "   mov    x11, #0\n\t"
  89 "   mov    x12, #0\n\t"
  90 "   mov    x13, #0\n\t"
  91 "   mov    x14, #0\n\t"
  92 "   mov    x15, #0\n\t"
  93 "   mov    x16, #0\n\t"
  94 "   mov    x17, #0\n\t"
  95 "   mov    x18, #0\n\t"
  96 "   mov    x19, #0\n\t"
  97 "   mov    x20, #0\n\t"
  98 "   mov    x21, #0\n\t"
  99 "   mov    x22, #0\n\t"
 100 "   mov    x23, #0\n\t"
 101 "   mov    x24, #0\n\t"
 102 "   mov    x25, #0\n\t"
 103 "   mov    x26, #0\n\t"
 104 "   mov    x27, #0\n\t"
 105 "   mov    x28, #0\n\t"
 106 "   mov    x29, sp\n\t" /* FP = SP, in the absence of better suggestions */
 107 "   br     x9\n\t"
 108 ".previous\n"
 109 );
 110
 111
 112 /*
 113         Perform a clone system call.  clone is strange because it has
 114         fork()-like return-twice semantics, so it needs special
 115         handling here.
 116
 117         Upon entry, we have:
 118
 119             Word (*fn)(void*)   in x0
 120             void*  child_stack  in x1
 121             int    flags        in x2
 122             void*  arg          in x3
 123             pid_t* child_tid    in x4
 124             pid_t* parent_tid   in x5
 125             void*  tls_ptr      in x6
 126
 127         System call requires:
 128
 129             int    $__NR_clone  in x8
 130             int    flags        in x0
 131             void*  child_stack  in x1
 132             pid_t* parent_tid   in x2
 133             void*  tls_ptr      in x3
 134             pid_t* child_tid    in x4
 135
 136         Returns a Long encoded in the linux-arm64 way, not a SysRes.
 137 */
 138 #define __NR_CLONE        VG_STRINGIFY(__NR_clone)
 139 #define __NR_EXIT         VG_STRINGIFY(__NR_exit)
 140
 141 // See priv_syswrap-linux.h for arg profile.
 142 asm(
 143 ".text\n"
 144 ".globl do_syscall_clone_arm64_linux\n"
 145 "do_syscall_clone_arm64_linux:\n"
 146         // set up child stack, temporarily preserving fn and arg
 147 "       sub    x1, x1, #16\n"       // make space on stack
 148 "       str    x3, [x1, #8]\n"      // save arg
 149 "       str    x0, [x1, #0]\n"      // save fn
 150
 151         // setup syscall
 152 "       mov    x8, #"__NR_CLONE"\n" // syscall number
 153 "       mov    x0, x2\n"            // syscall arg1: flags
 154 "       mov    x1, x1\n"            // syscall arg2: child_stack
 155 "       mov    x2, x5\n"            // syscall arg3: parent_tid
 156 "       mov    x3, x6\n"            // syscall arg4: tls_ptr
 157 "       mov    x4, x4\n"            // syscall arg5: child_tid
 158
 159 "       svc    0\n"                 // clone()
 160
 161 "       cmp    x0, #0\n"            // child if retval == 0
 162 "       bne    1f\n"
 163
 164         // CHILD - call thread function
 165 "       ldr    x1, [sp, #0]\n"      // pop fn
 166 "       ldr    x0, [sp, #8]\n"      // pop fn arg1: arg
 167 "       add    sp, sp, #16\n"
 168 "       blr    x1\n"                // call fn
 169
 170         // exit with result
 171 "       mov    x0, x0\n"            // arg1: return value from fn
 172 "       mov    x8, #"__NR_EXIT"\n"
 173
 174 "       svc    0\n"
 175
 176         // Exit returned?!
 177 "       .word 0xFFFFFFFF\n"
 178
 179 "1:\n"  // PARENT or ERROR.  x0 holds return value from the clone syscall.
 180 "       ret\n"
 181 ".previous\n"
 182 );
 183
 184 #undef __NR_CLONE
 185 #undef __NR_EXIT
 186
 187 // forward declaration
 188 static void setup_child ( ThreadArchState*, ThreadArchState* );
 189 static void assign_guest_tls(ThreadId ctid, Addr tlsptr);
 190 //ZZ static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr );
 191
 192 /* ---------------------------------------------------------------------
 193    More thread stuff
 194    ------------------------------------------------------------------ */
 195
 196 // ARM64 doesn't have any architecture specific thread stuff that
 197 // needs to be cleaned up
 198 void VG_(cleanup_thread) ( ThreadArchState* arch )
 199 {
 200 }
 201
 202 void setup_child ( /*OUT*/ ThreadArchState *child,
 203                    /*IN*/  ThreadArchState *parent )
 204 {
 205    child->vex = parent->vex;
 206    child->vex_shadow1 = parent->vex_shadow1;
 207    child->vex_shadow2 = parent->vex_shadow2;
 208 }
 209
 210 static void assign_guest_tls(ThreadId tid, Addr tlsptr)
 211 {
 212    VG_(threads)[tid].arch.vex.guest_TPIDR_EL0 = tlsptr;
 213 }
 214
 215 //ZZ /* Assigns tlsptr to the guest TPIDRURO.
 216 //ZZ    If needed for the specific hardware, really executes
 217 //ZZ    the set_tls syscall.
 218 //ZZ */
 219 //ZZ static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr )
 220 //ZZ {
 221 //ZZ    assign_guest_tls(tid, tlsptr);
 222 //ZZ #if defined(ANDROID_HARDWARE_emulator)
 223 //ZZ    /* Android emulator does not provide an hw tls register.
 224 //ZZ       So, the tls register is emulated by the kernel.
 225 //ZZ       This emulated value is set by the __NR_ARM_set_tls syscall.
 226 //ZZ       The emulated value must be read by the kernel helper function
 227 //ZZ       located at 0xffff0fe0.
 228 //ZZ
 229 //ZZ       The emulated tlsptr is located at 0xffff0ff0
 230 //ZZ       (so slightly after the kernel helper function).
 231 //ZZ       Note that applications are not supposed to read this directly.
 232 //ZZ
 233 //ZZ       For compatibility : if there is a hw tls register, the kernel
 234 //ZZ       will put at 0xffff0fe0 the instructions to read it, so
 235 //ZZ       as to have old applications calling the kernel helper
 236 //ZZ       working properly.
 237 //ZZ
 238 //ZZ       For having emulated guest TLS working correctly with
 239 //ZZ       Valgrind, it is needed to execute the syscall to set
 240 //ZZ       the emulated TLS value in addition to the assignment
 241 //ZZ       of TPIDRURO.
 242 //ZZ
 243 //ZZ       Note: the below means that if we need thread local storage
 244 //ZZ       for Valgrind host, then there will be a conflict between
 245 //ZZ       the need of the guest tls and of the host tls.
 246 //ZZ       If all the guest code would cleanly call 0xffff0fe0,
 247 //ZZ       then we might maybe intercept this. However, at least
 248 //ZZ       __libc_preinit reads directly 0xffff0ff0.
 249 //ZZ    */
 250 //ZZ    /* ??? might call the below if auxv->u.a_val & VKI_HWCAP_TLS ???
 251 //ZZ       Unclear if real hardware having tls hw register sets
 252 //ZZ       VKI_HWCAP_TLS. */
 253 //ZZ    return VG_(do_syscall1) (__NR_ARM_set_tls, tlsptr);
 254 //ZZ #else
 255 //ZZ    return VG_(mk_SysRes_Success)( 0 );
 256 //ZZ #endif
 257 //ZZ }
 258
 259 /* ---------------------------------------------------------------------
 260    PRE/POST wrappers for arm/Linux-specific syscalls
 261    ------------------------------------------------------------------ */
 262
 263 #define PRE(name)       DEFN_PRE_TEMPLATE(arm64_linux, name)
 264 #define POST(name)      DEFN_POST_TEMPLATE(arm64_linux, name)
 265
 266 /* Add prototypes for the wrappers declared here, so that gcc doesn't
 267    harass us for not having prototypes.  Really this is a kludge --
 268    the right thing to do is to make these wrappers 'static' since they
 269    aren't visible outside this file, but that requires even more macro
 270    magic. */
 271
 272 DECL_TEMPLATE(arm64_linux, sys_fadvise64);
 273 DECL_TEMPLATE(arm64_linux, sys_mmap);
 274 //ZZ DECL_TEMPLATE(arm_linux, sys_stat64);
 275 //ZZ DECL_TEMPLATE(arm_linux, sys_lstat64);
 276 //ZZ DECL_TEMPLATE(arm_linux, sys_fstatat64);
 277 //ZZ DECL_TEMPLATE(arm_linux, sys_fstat64);
 278 //ZZ DECL_TEMPLATE(arm_linux, sys_sigreturn);
 279 DECL_TEMPLATE(arm64_linux, sys_rt_sigreturn);
 280 //ZZ DECL_TEMPLATE(arm_linux, sys_sigsuspend);
 281 //ZZ DECL_TEMPLATE(arm_linux, sys_set_tls);
 282 //ZZ DECL_TEMPLATE(arm_linux, sys_cacheflush);
 283 //ZZ DECL_TEMPLATE(arm_linux, sys_ptrace);
 284
 285 //ZZ PRE(sys_mmap2)
 286 //ZZ {
 287 //ZZ    SysRes r;
 288 //ZZ
 289 //ZZ    // Exactly like old_mmap() except:
 290 //ZZ    //  - all 6 args are passed in regs, rather than in a memory-block.
 291 //ZZ    //  - the file offset is specified in pagesize units rather than bytes,
 292 //ZZ    //    so that it can be used for files bigger than 2^32 bytes.
 293 //ZZ    // pagesize or 4K-size units in offset?  For ppc32/64-linux, this is
 294 //ZZ    // 4K-sized.  Assert that the page size is 4K here for safety.
 295 //ZZ    vg_assert(VKI_PAGE_SIZE == 4096);
 296 //ZZ    PRINT("sys_mmap2 ( %#lx, %llu, %ld, %ld, %ld, %ld )",
 297 //ZZ          ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 );
 298 //ZZ    PRE_REG_READ6(long, "mmap2",
 299 //ZZ                  unsigned long, start, unsigned long, length,
 300 //ZZ                  unsigned long, prot,  unsigned long, flags,
 301 //ZZ                  unsigned long, fd,    unsigned long, offset);
 302 //ZZ
 303 //ZZ    r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5,
 304 //ZZ                                        4096 * (Off64T)ARG6 );
 305 //ZZ    SET_STATUS_from_SysRes(r);
 306 //ZZ }
 307
 308 // ARM64 FIXME is this correct?
 309 PRE(sys_fadvise64)
 310 {
 311    PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", SARG1, SARG2, ARG3, SARG4);
 312    PRE_REG_READ4(long, "fadvise64",
 313                  int, fd, vki_loff_t, offset, vki_size_t, len, int, advice);
 314 }
 315
 316 // ARM64 FIXME is this correct?
 317 PRE(sys_mmap)
 318 {
 319    SysRes r;
 320
 321    PRINT("sys_mmap ( %#lx, %lu, %lu, %#lx, %lu, %lu )",
 322          ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
 323    PRE_REG_READ6(long, "mmap",
 324                  unsigned long, start, unsigned long, length,
 325                  unsigned long, prot,  unsigned long, flags,
 326                  unsigned long, fd,    unsigned long, offset);
 327
 328    r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
 329    SET_STATUS_from_SysRes(r);
 330 }
 331
 332 //ZZ
 333 //ZZ // XXX: lstat64/fstat64/stat64 are generic, but not necessarily
 334 //ZZ // applicable to every architecture -- I think only to 32-bit archs.
 335 //ZZ // We're going to need something like linux/core_os32.h for such
 336 //ZZ // things, eventually, I think.  --njn
 337 //ZZ PRE(sys_lstat64)
 338 //ZZ {
 339 //ZZ    PRINT("sys_lstat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
 340 //ZZ    PRE_REG_READ2(long, "lstat64", char *, file_name, struct stat64 *, buf);
 341 //ZZ    PRE_MEM_RASCIIZ( "lstat64(file_name)", ARG1 );
 342 //ZZ    PRE_MEM_WRITE( "lstat64(buf)", ARG2, sizeof(struct vki_stat64) );
 343 //ZZ }
 344 //ZZ
 345 //ZZ POST(sys_lstat64)
 346 //ZZ {
 347 //ZZ    vg_assert(SUCCESS);
 348 //ZZ    if (RES == 0) {
 349 //ZZ       POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
 350 //ZZ    }
 351 //ZZ }
 352 //ZZ
 353 //ZZ PRE(sys_stat64)
 354 //ZZ {
 355 //ZZ    PRINT("sys_stat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
 356 //ZZ    PRE_REG_READ2(long, "stat64", char *, file_name, struct stat64 *, buf);
 357 //ZZ    PRE_MEM_RASCIIZ( "stat64(file_name)", ARG1 );
 358 //ZZ    PRE_MEM_WRITE( "stat64(buf)", ARG2, sizeof(struct vki_stat64) );
 359 //ZZ }
 360 //ZZ
 361 //ZZ POST(sys_stat64)
 362 //ZZ {
 363 //ZZ    POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
 364 //ZZ }
 365 //ZZ
 366 //ZZ PRE(sys_fstatat64)
 367 //ZZ {
 368 //ZZ    PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx )",ARG1,ARG2,(char*)ARG2,ARG3);
 369 //ZZ    PRE_REG_READ3(long, "fstatat64",
 370 //ZZ                  int, dfd, char *, file_name, struct stat64 *, buf);
 371 //ZZ    PRE_MEM_RASCIIZ( "fstatat64(file_name)", ARG2 );
 372 //ZZ    PRE_MEM_WRITE( "fstatat64(buf)", ARG3, sizeof(struct vki_stat64) );
 373 //ZZ }
 374 //ZZ
 375 //ZZ POST(sys_fstatat64)
 376 //ZZ {
 377 //ZZ    POST_MEM_WRITE( ARG3, sizeof(struct vki_stat64) );
 378 //ZZ }
 379 //ZZ
 380 //ZZ PRE(sys_fstat64)
 381 //ZZ {
 382 //ZZ    PRINT("sys_fstat64 ( %ld, %#lx )",ARG1,ARG2);
 383 //ZZ    PRE_REG_READ2(long, "fstat64", unsigned long, fd, struct stat64 *, buf);
 384 //ZZ    PRE_MEM_WRITE( "fstat64(buf)", ARG2, sizeof(struct vki_stat64) );
 385 //ZZ }
 386 //ZZ
 387 //ZZ POST(sys_fstat64)
 388 //ZZ {
 389 //ZZ    POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
 390 //ZZ }
 391
 392 //ZZ PRE(sys_sigreturn)
 393 //ZZ {
 394 //ZZ    /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
 395 //ZZ      an explanation of what follows. */
 396 //ZZ
 397 //ZZ    PRINT("sys_sigreturn ( )");
 398 //ZZ
 399 //ZZ    vg_assert(VG_(is_valid_tid)(tid));
 400 //ZZ    vg_assert(tid >= 1 && tid < VG_N_THREADS);
 401 //ZZ    vg_assert(VG_(is_running_thread)(tid));
 402 //ZZ
 403 //ZZ    /* Restore register state from frame and remove it */
 404 //ZZ    VG_(sigframe_destroy)(tid, False);
 405 //ZZ
 406 //ZZ    /* Tell the driver not to update the guest state with the "result",
 407 //ZZ       and set a bogus result to keep it happy. */
 408 //ZZ    *flags |= SfNoWriteResult;
 409 //ZZ    SET_STATUS_Success(0);
 410 //ZZ
 411 //ZZ    /* Check to see if any signals arose as a result of this. */
 412 //ZZ    *flags |= SfPollAfter;
 413 //ZZ }
 414
 415 PRE(sys_rt_sigreturn)
 416 {
 417   /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
 418       an explanation of what follows. */
 419
 420    PRINT("rt_sigreturn ( )");
 421
 422    vg_assert(VG_(is_valid_tid)(tid));
 423    vg_assert(tid >= 1 && tid < VG_N_THREADS);
 424    vg_assert(VG_(is_running_thread)(tid));
 425
 426    /* Restore register state from frame and remove it */
 427    VG_(sigframe_destroy)(tid, True);
 428
 429    /* Tell the driver not to update the guest state with the "result",
 430       and set a bogus result to keep it happy. */
 431    *flags |= SfNoWriteResult;
 432    SET_STATUS_Success(0);
 433
 434    /* Check to see if any signals arose as a result of this. */
 435    *flags |= SfPollAfter;
 436 }
 437
 438 //ZZ /* NB: clone of x86-linux version, and ppc32-linux has an almost
 439 //ZZ    identical one. */
 440 //ZZ PRE(sys_sigsuspend)
 441 //ZZ {
 442 //ZZ    /* The C library interface to sigsuspend just takes a pointer to
 443 //ZZ       a signal mask but this system call has three arguments - the first
 444 //ZZ       two don't appear to be used by the kernel and are always passed as
 445 //ZZ       zero by glibc and the third is the first word of the signal mask
 446 //ZZ       so only 32 signals are supported.
 447 //ZZ
 448 //ZZ       In fact glibc normally uses rt_sigsuspend if it is available as
 449 //ZZ       that takes a pointer to the signal mask so supports more signals.
 450 //ZZ     */
 451 //ZZ    *flags |= SfMayBlock;
 452 //ZZ    PRINT("sys_sigsuspend ( %ld, %ld, %ld )", ARG1,ARG2,ARG3 );
 453 //ZZ    PRE_REG_READ3(int, "sigsuspend",
 454 //ZZ                  int, history0, int, history1,
 455 //ZZ                  vki_old_sigset_t, mask);
 456 //ZZ }
 457 //ZZ
 458 //ZZ /* Very much ARM specific */
 459 //ZZ
 460 //ZZ PRE(sys_set_tls)
 461 //ZZ {
 462 //ZZ    PRINT("set_tls (%lx)",ARG1);
 463 //ZZ    PRE_REG_READ1(long, "set_tls", unsigned long, addr);
 464 //ZZ
 465 //ZZ    SET_STATUS_from_SysRes( sys_set_tls( tid, ARG1 ) );
 466 //ZZ }
 467 //ZZ
 468 //ZZ PRE(sys_cacheflush)
 469 //ZZ {
 470 //ZZ    PRINT("cacheflush (%lx, %#lx, %#lx)",ARG1,ARG2,ARG3);
 471 //ZZ    PRE_REG_READ3(long, "cacheflush", void*, addrlow,void*, addrhigh,int, flags);
 472 //ZZ    VG_(discard_translations)( (Addr)ARG1,
 473 //ZZ                               ((ULong)ARG2) - ((ULong)ARG1) + 1ULL/*paranoia*/,
 474 //ZZ                               "PRE(sys_cacheflush)" );
 475 //ZZ    SET_STATUS_Success(0);
 476 //ZZ }
 477 //ZZ
 478 //ZZ // ARG3 is only used for pointers into the traced process's address
 479 //ZZ // space and for offsets into the traced process's struct
 480 //ZZ // user_regs_struct. It is never a pointer into this process's memory
 481 //ZZ // space, and we should therefore not check anything it points to.
 482 //ZZ PRE(sys_ptrace)
 483 //ZZ {
 484 //ZZ    PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4);
 485 //ZZ    PRE_REG_READ4(int, "ptrace",
 486 //ZZ                  long, request, long, pid, long, addr, long, data);
 487 //ZZ    switch (ARG1) {
 488 //ZZ    case VKI_PTRACE_PEEKTEXT:
 489 //ZZ    case VKI_PTRACE_PEEKDATA:
 490 //ZZ    case VKI_PTRACE_PEEKUSR:
 491 //ZZ       PRE_MEM_WRITE( "ptrace(peek)", ARG4,
 492 //ZZ                 sizeof (long));
 493 //ZZ       break;
 494 //ZZ    case VKI_PTRACE_GETREGS:
 495 //ZZ       PRE_MEM_WRITE( "ptrace(getregs)", ARG4,
 496 //ZZ                 sizeof (struct vki_user_regs_struct));
 497 //ZZ       break;
 498 //ZZ    case VKI_PTRACE_GETFPREGS:
 499 //ZZ       PRE_MEM_WRITE( "ptrace(getfpregs)", ARG4,
 500 //ZZ                 sizeof (struct vki_user_fp));
 501 //ZZ       break;
 502 //ZZ    case VKI_PTRACE_GETWMMXREGS:
 503 //ZZ       PRE_MEM_WRITE( "ptrace(getwmmxregs)", ARG4,
 504 //ZZ                 VKI_IWMMXT_SIZE);
 505 //ZZ       break;
 506 //ZZ    case VKI_PTRACE_GETCRUNCHREGS:
 507 //ZZ       PRE_MEM_WRITE( "ptrace(getcrunchregs)", ARG4,
 508 //ZZ                 VKI_CRUNCH_SIZE);
 509 //ZZ       break;
 510 //ZZ    case VKI_PTRACE_GETVFPREGS:
 511 //ZZ       PRE_MEM_WRITE( "ptrace(getvfpregs)", ARG4,
 512 //ZZ                      sizeof (struct vki_user_vfp) );
 513 //ZZ       break;
 514 //ZZ    case VKI_PTRACE_GETHBPREGS:
 515 //ZZ       PRE_MEM_WRITE( "ptrace(gethbpregs)", ARG4,
 516 //ZZ                      sizeof (unsigned long) );
 517 //ZZ       break;
 518 //ZZ    case VKI_PTRACE_SETREGS:
 519 //ZZ       PRE_MEM_READ( "ptrace(setregs)", ARG4,
 520 //ZZ                 sizeof (struct vki_user_regs_struct));
 521 //ZZ       break;
 522 //ZZ    case VKI_PTRACE_SETFPREGS:
 523 //ZZ       PRE_MEM_READ( "ptrace(setfpregs)", ARG4,
 524 //ZZ                 sizeof (struct vki_user_fp));
 525 //ZZ       break;
 526 //ZZ    case VKI_PTRACE_SETWMMXREGS:
 527 //ZZ       PRE_MEM_READ( "ptrace(setwmmxregs)", ARG4,
 528 //ZZ                 VKI_IWMMXT_SIZE);
 529 //ZZ       break;
 530 //ZZ    case VKI_PTRACE_SETCRUNCHREGS:
 531 //ZZ       PRE_MEM_READ( "ptrace(setcrunchregs)", ARG4,
 532 //ZZ                 VKI_CRUNCH_SIZE);
 533 //ZZ       break;
 534 //ZZ    case VKI_PTRACE_SETVFPREGS:
 535 //ZZ       PRE_MEM_READ( "ptrace(setvfpregs)", ARG4,
 536 //ZZ                      sizeof (struct vki_user_vfp));
 537 //ZZ       break;
 538 //ZZ    case VKI_PTRACE_SETHBPREGS:
 539 //ZZ       PRE_MEM_READ( "ptrace(sethbpregs)", ARG4, sizeof(unsigned long));
 540 //ZZ       break;
 541 //ZZ    case VKI_PTRACE_GET_THREAD_AREA:
 542 //ZZ       PRE_MEM_WRITE( "ptrace(get_thread_area)", ARG4, sizeof(unsigned long));
 543 //ZZ       break;
 544 //ZZ    case VKI_PTRACE_GETEVENTMSG:
 545 //ZZ       PRE_MEM_WRITE( "ptrace(geteventmsg)", ARG4, sizeof(unsigned long));
 546 //ZZ       break;
 547 //ZZ    case VKI_PTRACE_GETSIGINFO:
 548 //ZZ       PRE_MEM_WRITE( "ptrace(getsiginfo)", ARG4, sizeof(vki_siginfo_t));
 549 //ZZ       break;
 550 //ZZ    case VKI_PTRACE_SETSIGINFO:
 551 //ZZ       PRE_MEM_READ( "ptrace(setsiginfo)", ARG4, sizeof(vki_siginfo_t));
 552 //ZZ       break;
 553 //ZZ    case VKI_PTRACE_GETREGSET:
 554 //ZZ       ML_(linux_PRE_getregset)(tid, ARG3, ARG4);
 555 //ZZ       break;
 556 //ZZ    case VKI_PTRACE_SETREGSET:
 557 //ZZ       ML_(linux_PRE_setregset)(tid, ARG3, ARG4);
 558 //ZZ       break;
 559 //ZZ    default:
 560 //ZZ       break;
 561 //ZZ    }
 562 //ZZ }
 563 //ZZ
 564 //ZZ POST(sys_ptrace)
 565 //ZZ {
 566 //ZZ    switch (ARG1) {
 567 //ZZ    case VKI_PTRACE_PEEKTEXT:
 568 //ZZ    case VKI_PTRACE_PEEKDATA:
 569 //ZZ    case VKI_PTRACE_PEEKUSR:
 570 //ZZ       POST_MEM_WRITE( ARG4, sizeof (long));
 571 //ZZ       break;
 572 //ZZ    case VKI_PTRACE_GETREGS:
 573 //ZZ       POST_MEM_WRITE( ARG4, sizeof (struct vki_user_regs_struct));
 574 //ZZ       break;
 575 //ZZ    case VKI_PTRACE_GETFPREGS:
 576 //ZZ       POST_MEM_WRITE( ARG4, sizeof (struct vki_user_fp));
 577 //ZZ       break;
 578 //ZZ    case VKI_PTRACE_GETWMMXREGS:
 579 //ZZ       POST_MEM_WRITE( ARG4, VKI_IWMMXT_SIZE);
 580 //ZZ       break;
 581 //ZZ    case VKI_PTRACE_GETCRUNCHREGS:
 582 //ZZ       POST_MEM_WRITE( ARG4, VKI_CRUNCH_SIZE);
 583 //ZZ       break;
 584 //ZZ    case VKI_PTRACE_GETVFPREGS:
 585 //ZZ       POST_MEM_WRITE( ARG4, sizeof(struct vki_user_vfp));
 586 //ZZ       break;
 587 //ZZ    case VKI_PTRACE_GET_THREAD_AREA:
 588 //ZZ    case VKI_PTRACE_GETHBPREGS:
 589 //ZZ    case VKI_PTRACE_GETEVENTMSG:
 590 //ZZ       POST_MEM_WRITE( ARG4, sizeof(unsigned long));
 591 //ZZ       break;
 592 //ZZ    case VKI_PTRACE_GETSIGINFO:
 593 //ZZ       /* XXX: This is a simplification. Different parts of the
 594 //ZZ        * siginfo_t are valid depending on the type of signal.
 595 //ZZ        */
 596 //ZZ       POST_MEM_WRITE( ARG4, sizeof(vki_siginfo_t));
 597 //ZZ       break;
 598 //ZZ    case VKI_PTRACE_GETREGSET:
 599 //ZZ       ML_(linux_POST_getregset)(tid, ARG3, ARG4);
 600 //ZZ       break;
 601 //ZZ    default:
 602 //ZZ       break;
 603 //ZZ    }
 604 //ZZ }
 605 //ZZ
 606 //ZZ #undef PRE
 607 //ZZ #undef POST
 608
 609 /* ---------------------------------------------------------------------
 610    The arm64/Linux syscall table
 611    ------------------------------------------------------------------ */
 612
 613 //ZZ #if 0
 614 //ZZ #define __NR_OABI_SYSCALL_BASE 0x900000
 615 //ZZ #else
 616 //ZZ #define __NR_OABI_SYSCALL_BASE 0x0
 617 //ZZ #endif
 618
 619 #define PLAX_(sysno, name)    WRAPPER_ENTRY_X_(arm64_linux, sysno, name)
 620 #define PLAXY(sysno, name)    WRAPPER_ENTRY_XY(arm64_linux, sysno, name)
 621
 622 // This table maps from __NR_xxx syscall numbers (from
 623 // linux/include/asm-arm/unistd.h) to the appropriate PRE/POST sys_foo()
 624 // wrappers on arm64 (as per sys_call_table in linux/arch/arm/kernel/entry.S).
 625 //
 626 // For those syscalls not handled by Valgrind, the annotation indicate its
 627 // arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/?
 628 // (unknown).
 629
 630 static SyscallTableEntry syscall_main_table[] = {
 631    LINXY(__NR_io_setup,          sys_io_setup),          // 0
 632    LINX_(__NR_io_destroy,        sys_io_destroy),        // 1
 633    LINX_(__NR_io_submit,         sys_io_submit),         // 2
 634    LINXY(__NR_io_cancel,         sys_io_cancel),         // 3
 635    LINXY(__NR_io_getevents,      sys_io_getevents),      // 4
 636    LINX_(__NR_setxattr,          sys_setxattr),          // 5
 637    LINX_(__NR_lsetxattr,         sys_lsetxattr),         // 6
 638    LINX_(__NR_fsetxattr,         sys_fsetxattr),         // 7
 639    LINXY(__NR_getxattr,          sys_getxattr),          // 8
 640    LINXY(__NR_lgetxattr,         sys_lgetxattr),         // 9
 641    LINXY(__NR_fgetxattr,         sys_fgetxattr),         // 10
 642    LINXY(__NR_listxattr,         sys_listxattr),         // 11
 643    LINXY(__NR_llistxattr,        sys_llistxattr),        // 12
 644    LINXY(__NR_flistxattr,        sys_flistxattr),        // 13
 645    LINX_(__NR_removexattr,       sys_removexattr),       // 14
 646    LINX_(__NR_lremovexattr,      sys_lremovexattr),      // 15
 647    LINX_(__NR_fremovexattr,      sys_fremovexattr),      // 16
 648    GENXY(__NR_getcwd,            sys_getcwd),            // 17
 649    LINXY(__NR_lookup_dcookie,    sys_lookup_dcookie),    // 18
 650    LINXY(__NR_eventfd2,          sys_eventfd2),          // 19
 651    LINXY(__NR_epoll_create1,     sys_epoll_create1),     // 20
 652    LINX_(__NR_epoll_ctl,         sys_epoll_ctl),         // 21
 653    LINXY(__NR_epoll_pwait,       sys_epoll_pwait),       // 22
 654    GENXY(__NR_dup,               sys_dup),               // 23
 655    LINXY(__NR_dup3,              sys_dup3),              // 24
 656    LINXY(__NR_fcntl,             sys_fcntl),             // 25
 657    LINXY(__NR_inotify_init1,     sys_inotify_init1),     // 26
 658    LINX_(__NR_inotify_add_watch, sys_inotify_add_watch), // 27
 659    LINX_(__NR_inotify_rm_watch,  sys_inotify_rm_watch),  // 28
 660    LINXY(__NR_ioctl,             sys_ioctl),             // 29
 661    LINX_(__NR_ioprio_set,        sys_ioprio_set),        // 30
 662    LINX_(__NR_ioprio_get,        sys_ioprio_get),        // 31
 663    GENX_(__NR_flock,             sys_flock),             // 32
 664    LINX_(__NR_mknodat,           sys_mknodat),           // 33
 665    LINX_(__NR_mkdirat,           sys_mkdirat),           // 34
 666    LINX_(__NR_unlinkat,          sys_unlinkat),          // 35
 667    LINX_(__NR_symlinkat,         sys_symlinkat),         // 36
 668    LINX_(__NR_linkat,            sys_linkat),            // 37
 669    LINX_(__NR_renameat,          sys_renameat),          // 38
 670    LINX_(__NR_umount2,           sys_umount),            // 39
 671    LINX_(__NR_mount,             sys_mount),             // 40
 672    LINX_(__NR_pivot_root,        sys_pivot_root),        // 41
 673    //   (__NR_nfsservctl,        sys_nfsservctl),        // 42
 674    GENXY(__NR_statfs,            sys_statfs),            // 43
 675    GENXY(__NR_fstatfs,           sys_fstatfs),           // 44
 676    GENX_(__NR_truncate,          sys_truncate),          // 45
 677    GENX_(__NR_ftruncate,         sys_ftruncate),         // 46
 678    LINX_(__NR_fallocate,         sys_fallocate),         // 47
 679    LINX_(__NR_faccessat,         sys_faccessat),         // 48
 680    GENX_(__NR_chdir,             sys_chdir),             // 49
 681    GENX_(__NR_fchdir,            sys_fchdir),            // 50
 682    GENX_(__NR_chroot,            sys_chroot),            // 51
 683    GENX_(__NR_fchmod,            sys_fchmod),            // 52
 684    LINX_(__NR_fchmodat,          sys_fchmodat),          // 53
 685    LINX_(__NR_fchownat,          sys_fchownat),          // 54
 686    GENX_(__NR_fchown,            sys_fchown),            // 55
 687    LINXY(__NR_openat,            sys_openat),            // 56
 688    GENXY(__NR_close,             sys_close),             // 57
 689    LINX_(__NR_vhangup,           sys_vhangup),           // 58
 690    LINXY(__NR_pipe2,             sys_pipe2),             // 59
 691    LINX_(__NR_quotactl,          sys_quotactl),          // 60
 692    GENXY(__NR_getdents64,        sys_getdents64),        // 61
 693    LINX_(__NR_lseek,             sys_lseek),             // 62
 694    GENXY(__NR_read,              sys_read),              // 63
 695    GENX_(__NR_write,             sys_write),             // 64
 696    GENXY(__NR_readv,             sys_readv),             // 65
 697    GENX_(__NR_writev,            sys_writev),            // 66
 698    GENXY(__NR_pread64,           sys_pread64),           // 67
 699    GENX_(__NR_pwrite64,          sys_pwrite64),          // 68
 700    LINXY(__NR_preadv,            sys_preadv),            // 69
 701    LINX_(__NR_pwritev,           sys_pwritev),           // 70
 702    LINXY(__NR_sendfile,          sys_sendfile),          // 71
 703    LINXY(__NR_pselect6,          sys_pselect6),          // 72
 704    LINXY(__NR_ppoll,             sys_ppoll),             // 73
 705    LINXY(__NR_signalfd4,         sys_signalfd4),         // 74
 706    LINX_(__NR_vmsplice,          sys_vmsplice),          // 75
 707    LINX_(__NR_splice,            sys_splice),            // 76
 708    LINX_(__NR_tee,               sys_tee),               // 77
 709    LINX_(__NR_readlinkat,        sys_readlinkat),        // 78
 710    LINXY(__NR_newfstatat,        sys_newfstatat),        // 79
 711    GENXY(__NR_fstat,             sys_newfstat),          // 80
 712    GENX_(__NR_sync,              sys_sync),              // 81
 713    GENX_(__NR_fsync,             sys_fsync),             // 82
 714    GENX_(__NR_fdatasync,         sys_fdatasync),         // 83
 715    LINX_(__NR_sync_file_range,   sys_sync_file_range),   // 84
 716    LINXY(__NR_timerfd_create,    sys_timerfd_create),    // 85
 717    LINXY(__NR_timerfd_settime,   sys_timerfd_settime),   // 86
 718    LINXY(__NR_timerfd_gettime,   sys_timerfd_gettime),   // 87
 719    LINX_(__NR_utimensat,         sys_utimensat),         // 88
 720    GENX_(__NR_acct,              sys_acct),              // 89
 721    LINXY(__NR_capget,            sys_capget),            // 90
 722    LINX_(__NR_capset,            sys_capset),            // 91
 723    LINX_(__NR_personality,       sys_personality),       // 92
 724    GENX_(__NR_exit,              sys_exit),              // 93
 725    LINX_(__NR_exit_group,        sys_exit_group),        // 94
 726    LINXY(__NR_waitid,            sys_waitid),            // 95
 727    LINX_(__NR_set_tid_address,   sys_set_tid_address),   // 96
 728    LINX_(__NR_unshare,           sys_unshare),           // 97
 729    LINXY(__NR_futex,             sys_futex),             // 98
 730    LINX_(__NR_set_robust_list,   sys_set_robust_list),   // 99
 731    LINXY(__NR_get_robust_list,   sys_get_robust_list),   // 100
 732    GENXY(__NR_nanosleep,         sys_nanosleep),         // 101
 733    GENXY(__NR_getitimer,         sys_getitimer),         // 102
 734    GENXY(__NR_setitimer,         sys_setitimer),         // 103
 735    GENX_(__NR_kexec_load,        sys_ni_syscall),        // 104
 736    LINX_(__NR_init_module,       sys_init_module),       // 105
 737    //   (__NR_delete_module,     sys_delete_module),     // 106
 738    LINXY(__NR_timer_create,      sys_timer_create),      // 107
 739    LINXY(__NR_timer_gettime,     sys_timer_gettime),     // 108
 740    LINX_(__NR_timer_getoverrun,  sys_timer_getoverrun),  // 109
 741    LINXY(__NR_timer_settime,     sys_timer_settime),     // 110
 742    LINX_(__NR_timer_delete,      sys_timer_delete),      // 111
 743    LINX_(__NR_clock_settime,     sys_clock_settime),     // 112
 744    LINXY(__NR_clock_gettime,     sys_clock_gettime),     // 113
 745    LINXY(__NR_clock_getres,      sys_clock_getres),      // 114
 746    LINXY(__NR_clock_nanosleep,   sys_clock_nanosleep),   // 115
 747    LINXY(__NR_syslog,            sys_syslog),            // 116
 748    //   (__NR_ptrace,            sys_ptrace),            // 117
 749    LINXY(__NR_sched_setparam,    sys_sched_setparam),    // 118
 750    LINX_(__NR_sched_setscheduler,sys_sched_setscheduler),// 119
 751    LINX_(__NR_sched_getscheduler,sys_sched_getscheduler),// 120
 752    LINXY(__NR_sched_getparam,    sys_sched_getparam),    // 121
 753    LINX_(__NR_sched_setaffinity, sys_sched_setaffinity), // 122
 754    LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 123
 755    LINX_(__NR_sched_yield,       sys_sched_yield),       // 124
 756    LINX_(__NR_sched_get_priority_max, sys_sched_get_priority_max),// 125
 757    LINX_(__NR_sched_get_priority_min, sys_sched_get_priority_min),// 126
 758    //   (__NR_sched_rr_get_interval,   sys_sched_rr_get_interval),// 127
 759    //   (__NR_restart_syscall,   sys_restart_syscall),   // 128
 760    GENX_(__NR_kill,              sys_kill),              // 129
 761    //   (__NR_tkill,             sys_tkill),             // 130
 762    LINX_(__NR_tgkill,            sys_tgkill),            // 131
 763    GENXY(__NR_sigaltstack,       sys_sigaltstack),       // 132
 764    LINX_(__NR_rt_sigsuspend,     sys_rt_sigsuspend),     // 133
 765    LINXY(__NR_rt_sigaction,      sys_rt_sigaction),      // 134
 766    LINXY(__NR_rt_sigprocmask,    sys_rt_sigprocmask),    // 135
 767    LINXY(__NR_rt_sigpending,     sys_rt_sigpending),     // 136
 768    LINXY(__NR_rt_sigtimedwait,   sys_rt_sigtimedwait),   // 137
 769    LINXY(__NR_rt_sigqueueinfo,   sys_rt_sigqueueinfo),   // 138
 770    PLAX_(__NR_rt_sigreturn,      sys_rt_sigreturn),      // 139
 771    GENX_(__NR_setpriority,       sys_setpriority),       // 140
 772    GENX_(__NR_getpriority,       sys_getpriority),       // 141
 773    //   (__NR_reboot,            sys_reboot),            // 142
 774    GENX_(__NR_setregid,          sys_setregid),          // 143
 775    GENX_(__NR_setgid,            sys_setgid),            // 144
 776    GENX_(__NR_setreuid,          sys_setreuid),          // 145
 777    GENX_(__NR_setuid,            sys_setuid),            // 146
 778    LINX_(__NR_setresuid,         sys_setresuid),         // 147
 779    LINXY(__NR_getresuid,         sys_getresuid),         // 148
 780    LINX_(__NR_setresgid,         sys_setresgid),         // 149
 781    LINXY(__NR_getresgid,         sys_getresgid),         // 150
 782    LINX_(__NR_setfsuid,          sys_setfsuid),          // 151
 783    LINX_(__NR_setfsgid,          sys_setfsgid),          // 152
 784    GENXY(__NR_times,             sys_times),             // 153
 785    GENX_(__NR_setpgid,           sys_setpgid),           // 154
 786    GENX_(__NR_getpgid,           sys_getpgid),           // 155
 787    GENX_(__NR_getsid,            sys_getsid),            // 156
 788    GENX_(__NR_setsid,            sys_setsid),            // 157
 789    GENXY(__NR_getgroups,         sys_getgroups),         // 158
 790    GENX_(__NR_setgroups,         sys_setgroups),         // 159
 791    GENXY(__NR_uname,             sys_newuname),          // 160
 792    //   (__NR_sethostname,       sys_sethostname),       // 161
 793    //   (__NR_setdomainname,     sys_setdomainname),     // 162
 794    GENXY(__NR_getrlimit,         sys_old_getrlimit),     // 163
 795    GENX_(__NR_setrlimit,         sys_setrlimit),         // 164
 796    GENXY(__NR_getrusage,         sys_getrusage),         // 165
 797    GENX_(__NR_umask,             sys_umask),             // 166
 798    LINXY(__NR_prctl,             sys_prctl),             // 167
 799    //   (__NR_getcpu,            sys_getcpu),            // 168
 800    GENXY(__NR_gettimeofday,      sys_gettimeofday),      // 169
 801    GENX_(__NR_settimeofday,      sys_settimeofday),      // 170
 802    LINXY(__NR_adjtimex,          sys_adjtimex),          // 171
 803    GENX_(__NR_getpid,            sys_getpid),            // 172
 804    GENX_(__NR_getppid,           sys_getppid),           // 173
 805    GENX_(__NR_getuid,            sys_getuid),            // 174
 806    GENX_(__NR_geteuid,           sys_geteuid),           // 175
 807    GENX_(__NR_getgid,            sys_getgid),            // 176
 808    GENX_(__NR_getegid,           sys_getegid),           // 177
 809    LINX_(__NR_gettid,            sys_gettid),            // 178
 810    LINXY(__NR_sysinfo,           sys_sysinfo),           // 179
 811    LINXY(__NR_mq_open,           sys_mq_open),           // 180
 812    LINX_(__NR_mq_unlink,         sys_mq_unlink),         // 181
 813    LINX_(__NR_mq_timedsend,      sys_mq_timedsend),      // 182
 814    LINXY(__NR_mq_timedreceive,   sys_mq_timedreceive),   // 183
 815    LINX_(__NR_mq_notify,         sys_mq_notify),         // 184
 816    LINXY(__NR_mq_getsetattr,     sys_mq_getsetattr),     // 185
 817    LINX_(__NR_msgget,            sys_msgget),            // 186
 818    LINXY(__NR_msgctl,            sys_msgctl),            // 187
 819    LINXY(__NR_msgrcv,            sys_msgrcv),            // 188
 820    LINX_(__NR_msgsnd,            sys_msgsnd),            // 189
 821    LINX_(__NR_semget,            sys_semget),            // 190
 822    LINXY(__NR_semctl,            sys_semctl),            // 191
 823    LINX_(__NR_semtimedop,        sys_semtimedop),        // 192
 824    LINX_(__NR_semop,             sys_semop),             // 193
 825    LINX_(__NR_shmget,            sys_shmget),            // 194
 826    LINXY(__NR_shmctl,            sys_shmctl),            // 195
 827    LINXY(__NR_shmat,             sys_shmat),             // 196
 828    LINXY(__NR_shmdt,             sys_shmdt),             // 197
 829    LINXY(__NR_socket,            sys_socket),            // 198
 830    LINXY(__NR_socketpair,        sys_socketpair),        // 199
 831    LINX_(__NR_bind,              sys_bind),              // 200
 832    LINX_(__NR_listen,            sys_listen),            // 201
 833    LINXY(__NR_accept,            sys_accept),            // 202
 834    LINX_(__NR_connect,           sys_connect),           // 203
 835    LINXY(__NR_getsockname,       sys_getsockname),       // 204
 836    LINXY(__NR_getpeername,       sys_getpeername),       // 205
 837    LINX_(__NR_sendto,            sys_sendto),            // 206
 838    LINXY(__NR_recvfrom,          sys_recvfrom),          // 207
 839    LINX_(__NR_setsockopt,        sys_setsockopt),        // 208
 840    LINXY(__NR_getsockopt,        sys_getsockopt),        // 209
 841    LINX_(__NR_shutdown,          sys_shutdown),          // 210
 842    LINX_(__NR_sendmsg,           sys_sendmsg),           // 211
 843    LINXY(__NR_recvmsg,           sys_recvmsg),           // 212
 844    LINX_(__NR_readahead,         sys_readahead),         // 213
 845    GENX_(__NR_brk,               sys_brk),               // 214
 846    GENXY(__NR_munmap,            sys_munmap),            // 215
 847    GENX_(__NR_mremap,            sys_mremap),            // 216
 848    LINX_(__NR_add_key,           sys_add_key),           // 217
 849    //   (__NR_request_key,       sys_request_key),       // 218
 850    LINXY(__NR_keyctl,            sys_keyctl),            // 219
 851    LINX_(__NR_clone,             sys_clone),             // 220
 852    GENX_(__NR_execve,            sys_execve),            // 221
 853    PLAX_(__NR_mmap,              sys_mmap),              // 222
 854    PLAX_(__NR_fadvise64,         sys_fadvise64),         // 223
 855    //   (__NR_swapon,            sys_swapon),            // 224
 856    //   (__NR_swapoff,           sys_swapoff),           // 225
 857    GENXY(__NR_mprotect,          sys_mprotect),          // 226
 858    GENX_(__NR_msync,             sys_msync),             // 227
 859    GENX_(__NR_mlock,             sys_mlock),             // 228
 860    GENX_(__NR_munlock,           sys_munlock),           // 229
 861    GENX_(__NR_mlockall,          sys_mlockall),          // 230
 862    LINX_(__NR_munlockall,        sys_munlockall),        // 231
 863    GENXY(__NR_mincore,           sys_mincore),           // 232
 864    GENX_(__NR_madvise,           sys_madvise),           // 233
 865    //   (__NR_remap_file_pages,  sys_remap_file_pages)   // 234
 866    LINX_(__NR_mbind,             sys_mbind),             // 235
 867    LINXY(__NR_get_mempolicy,     sys_get_mempolicy),     // 236
 868    LINX_(__NR_set_mempolicy,     sys_set_mempolicy),     // 237
 869    //   (__NR_migrate_pages,     sys_migrate_pages),     // 238
 870    //   (__NR_move_pages,        sys_move_pages),        // 239
 871    //   (__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo), // 240
 872    LINXY(__NR_perf_event_open,   sys_perf_event_open),   // 241
 873    LINXY(__NR_accept4,           sys_accept4),           // 242
 874    LINXY(__NR_recvmmsg,          sys_recvmmsg),          // 243
 875    GENXY(__NR_wait4,             sys_wait4),             // 260
 876    LINXY(__NR_prlimit64,         sys_prlimit64),         // 261
 877    //   (__NR_fanotify_init,     sys_fanotify_init),     // 262
 878    //   (__NR_fanotify_mark,     sys_fanotify_mark),     // 263
 879    LINXY(__NR_name_to_handle_at, sys_name_to_handle_at), // 264
 880    LINXY(__NR_open_by_handle_at, sys_open_by_handle_at), // 265
 881    //   (__NR_clock_adjtime,     sys_clock_adjtime),     // 266
 882    LINX_(__NR_syncfs,            sys_syncfs),            // 267
 883    //   (__NR_setns,             sys_ni_syscall),        // 268
 884    LINXY(__NR_sendmmsg,          sys_sendmmsg),          // 269
 885    LINXY(__NR_process_vm_readv,  sys_process_vm_readv),  // 270
 886    LINX_(__NR_process_vm_writev, sys_process_vm_writev), // 271
 887    //   (__NR_kcmp,              sys_kcmp),              // 272
 888    //   (__NR_finit_module,      sys_ni_syscall),        // 273
 889    //   (__NR_sched_setattr,     sys_ni_syscall),        // 274
 890    //   (__NR_sched_getattr,     sys_ni_syscall),        // 275
 891    LINX_(__NR_renameat2,         sys_renameat2),         // 276
 892    //   (__NR_seccomp,           sys_ni_syscall),        // 277
 893    LINXY(__NR_getrandom,         sys_getrandom),         // 278
 894    LINXY(__NR_memfd_create,      sys_memfd_create),      // 279
 895    //   (__NR_bpf,               sys_ni_syscall)         // 280
 896    //   (__NR_execveat,          sys_ni_syscall),        // 281
 897    //   (__NR_userfaultfd,       sys_ni_syscall),        // 282
 898    //   (__NR_membarrier,        sys_ni_syscall),        // 283
 899    //   (__NR_mlock2,            sys_ni_syscall),        // 284
 900    //   (__NR_copy_file_range,   sys_ni_syscall),        // 285
 901    //   (__NR_preadv2,           sys_ni_syscall),        // 286
 902    //   (__NR_pwritev2,          sys_ni_syscall),        // 287
 903    //   (__NR_pkey_mprotect,     sys_ni_syscall),        // 288
 904    //   (__NR_pkey_alloc,        sys_ni_syscall),        // 289
 905    //   (__NR_pkey_free,         sys_ni_syscall),        // 290
 906 };
 907
 908
 909 //ZZ /* These are not in the main table because there indexes are not small
 910 //ZZ    integers, but rather values close to one million.  So their
 911 //ZZ    inclusion would force the main table to be huge (about 8 MB). */
 912 //ZZ
 913 //ZZ static SyscallTableEntry ste___ARM_set_tls
 914 //ZZ    = { WRAPPER_PRE_NAME(arm_linux,sys_set_tls), NULL };
 915 //ZZ
 916 //ZZ static SyscallTableEntry ste___ARM_cacheflush
 917 //ZZ    = { WRAPPER_PRE_NAME(arm_linux,sys_cacheflush), NULL };
 918
 919 SyscallTableEntry* ML_(get_linux_syscall_entry) ( UInt sysno )
 920 {
 921    const UInt syscall_main_table_size
 922       = sizeof(syscall_main_table) / sizeof(syscall_main_table[0]);
 923
 924    /* Is it in the contiguous initial section of the table? */
 925    if (sysno < syscall_main_table_size) {
 926       SyscallTableEntry* sys = &syscall_main_table[sysno];
 927       if (sys->before == NULL)
 928          return NULL; /* no entry */
 929       else
 930          return sys;
 931    }
 932
 933 //ZZ    /* Check if it's one of the out-of-line entries. */
 934 //ZZ    switch (sysno) {
 935 //ZZ       case __NR_ARM_set_tls:    return &ste___ARM_set_tls;
 936 //ZZ       case __NR_ARM_cacheflush: return &ste___ARM_cacheflush;
 937 //ZZ       default: break;
 938 //ZZ    }
 939
 940    /* Can't find a wrapper */
 941    return NULL;
 942 }
 943
 944 #endif // defined(VGP_arm64_linux)
 945
 946 /*--------------------------------------------------------------------*/
 947 /*--- end                                    syswrap-arm64-linux.c ---*/
 948 /*--------------------------------------------------------------------*/