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)) 62void 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 70asm( 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 141extern 142Long do_syscall_clone_arm64_linux ( Word (*fn)(void *), 143 void* child_stack, 144 Long flags, 145 void* arg, 146 Int* child_tid, 147 Int* parent_tid, 148 void* tls ); 149asm( 150".text\n" 151".globl do_syscall_clone_arm64_linux\n" 152"do_syscall_clone_arm64_linux:\n" 153 // set up child stack, temporarily preserving fn and arg 154" sub x1, x1, #16\n" // make space on stack 155" str x3, [x1, #8]\n" // save arg 156" str x0, [x1, #0]\n" // save fn 157 158 // setup syscall 159" mov x8, #"__NR_CLONE"\n" // syscall number 160" mov x0, x2\n" // syscall arg1: flags 161" mov x1, x1\n" // syscall arg2: child_stack 162" mov x2, x5\n" // syscall arg3: parent_tid 163" mov x3, x6\n" // syscall arg4: tls_ptr 164" mov x4, x4\n" // syscall arg5: child_tid 165 166" svc 0\n" // clone() 167 168" cmp x0, #0\n" // child if retval == 0 169" bne 1f\n" 170 171 // CHILD - call thread function 172" ldr x1, [sp, #0]\n" // pop fn 173" ldr x0, [sp, #8]\n" // pop fn arg1: arg 174" add sp, sp, #16\n" 175" blr x1\n" // call fn 176 177 // exit with result 178" mov x0, x0\n" // arg1: return value from fn 179" mov x8, #"__NR_EXIT"\n" 180 181" svc 0\n" 182 183 // Exit returned?! 184" .word 0xFFFFFFFF\n" 185 186"1:\n" // PARENT or ERROR. x0 holds return value from the clone syscall. 187" ret\n" 188".previous\n" 189); 190 191#undef __NR_CLONE 192#undef __NR_EXIT 193 194// forward declaration 195static void setup_child ( ThreadArchState*, ThreadArchState* ); 196static void assign_guest_tls(ThreadId ctid, Addr tlsptr); 197//ZZ static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr ); 198 199/* 200 When a client clones, we need to keep track of the new thread. This means: 201 1. allocate a ThreadId+ThreadState+stack for the thread 202 203 2. initialize the thread's new VCPU state 204 205 3. create the thread using the same args as the client requested, 206 but using the scheduler entrypoint for IP, and a separate stack 207 for SP. 208 */ 209static SysRes do_clone ( ThreadId ptid, 210 ULong flags, 211 Addr child_xsp, 212 Int* parent_tidptr, 213 Int* child_tidptr, 214 Addr child_tls ) 215{ 216 ThreadId ctid = VG_(alloc_ThreadState)(); 217 ThreadState* ptst = VG_(get_ThreadState)(ptid); 218 ThreadState* ctst = VG_(get_ThreadState)(ctid); 219 UWord* stack; 220 SysRes res; 221 ULong x0; 222 vki_sigset_t blockall, savedmask; 223 224 VG_(sigfillset)(&blockall); 225 226 vg_assert(VG_(is_running_thread)(ptid)); 227 vg_assert(VG_(is_valid_tid)(ctid)); 228 229 stack = (UWord*)ML_(allocstack)(ctid); 230 if (stack == NULL) { 231 res = VG_(mk_SysRes_Error)( VKI_ENOMEM ); 232 goto out; 233 } 234 235 /* Copy register state 236 237 Both parent and child return to the same place, and the code 238 following the clone syscall works out which is which, so we 239 don't need to worry about it. 240 241 The parent gets the child's new tid returned from clone, but the 242 child gets 0. 243 244 If the clone call specifies a NULL xsp for the new thread, then 245 it actually gets a copy of the parent's xsp. 246 */ 247 setup_child( &ctst->arch, &ptst->arch ); 248 249 /* Make sys_clone appear to have returned Success(0) in the 250 child. */ 251 ctst->arch.vex.guest_X0 = 0; 252 253 if (child_xsp != 0) 254 ctst->arch.vex.guest_XSP = child_xsp; 255 256 ctst->os_state.parent = ptid; 257 258 /* inherit signal mask */ 259 ctst->sig_mask = ptst->sig_mask; 260 ctst->tmp_sig_mask = ptst->sig_mask; 261 262 /* Start the child with its threadgroup being the same as the 263 parent's. This is so that any exit_group calls that happen 264 after the child is created but before it sets its 265 os_state.threadgroup field for real (in thread_wrapper in 266 syswrap-linux.c), really kill the new thread. a.k.a this avoids 267 a race condition in which the thread is unkillable (via 268 exit_group) because its threadgroup is not set. The race window 269 is probably only a few hundred or a few thousand cycles long. 270 See #226116. */ 271 ctst->os_state.threadgroup = ptst->os_state.threadgroup; 272 273 ML_(guess_and_register_stack)(child_xsp, ctst); 274 275 /* Assume the clone will succeed, and tell any tool that wants to 276 know that this thread has come into existence. If the clone 277 fails, we'll send out a ll_exit notification for it at the out: 278 label below, to clean up. */ 279 vg_assert(VG_(owns_BigLock_LL)(ptid)); 280 VG_TRACK ( pre_thread_ll_create, ptid, ctid ); 281 282 if (flags & VKI_CLONE_SETTLS) { 283 /* Just assign the tls pointer in the guest TPIDR_EL0. */ 284 assign_guest_tls(ctid, child_tls); 285 } 286 287 flags &= ~VKI_CLONE_SETTLS; 288 289 /* start the thread with everything blocked */ 290 VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask); 291 292 x0 = do_syscall_clone_arm64_linux( 293 ML_(start_thread_NORETURN), stack, flags, &VG_(threads)[ctid], 294 child_tidptr, parent_tidptr, NULL 295 ); 296 297 res = VG_(mk_SysRes_arm64_linux)( x0 ); 298 299 VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL); 300 301 out: 302 if (sr_isError(res)) { 303 /* clone failed */ 304 VG_(cleanup_thread)(&ctst->arch); 305 ctst->status = VgTs_Empty; 306 /* oops. Better tell the tool the thread exited in a hurry :-) */ 307 VG_TRACK( pre_thread_ll_exit, ctid ); 308 } 309 310 return res; 311} 312 313 314/* --------------------------------------------------------------------- 315 More thread stuff 316 ------------------------------------------------------------------ */ 317 318// ARM64 doesn't have any architecture specific thread stuff that 319// needs to be cleaned up 320void VG_(cleanup_thread) ( ThreadArchState* arch ) 321{ 322} 323 324void setup_child ( /*OUT*/ ThreadArchState *child, 325 /*IN*/ ThreadArchState *parent ) 326{ 327 child->vex = parent->vex; 328 child->vex_shadow1 = parent->vex_shadow1; 329 child->vex_shadow2 = parent->vex_shadow2; 330} 331 332static void assign_guest_tls(ThreadId tid, Addr tlsptr) 333{ 334 VG_(threads)[tid].arch.vex.guest_TPIDR_EL0 = tlsptr; 335} 336 337//ZZ /* Assigns tlsptr to the guest TPIDRURO. 338//ZZ If needed for the specific hardware, really executes 339//ZZ the set_tls syscall. 340//ZZ */ 341//ZZ static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr ) 342//ZZ { 343//ZZ assign_guest_tls(tid, tlsptr); 344//ZZ #if defined(ANDROID_HARDWARE_emulator) 345//ZZ /* Android emulator does not provide an hw tls register. 346//ZZ So, the tls register is emulated by the kernel. 347//ZZ This emulated value is set by the __NR_ARM_set_tls syscall. 348//ZZ The emulated value must be read by the kernel helper function 349//ZZ located at 0xffff0fe0. 350//ZZ 351//ZZ The emulated tlsptr is located at 0xffff0ff0 352//ZZ (so slightly after the kernel helper function). 353//ZZ Note that applications are not supposed to read this directly. 354//ZZ 355//ZZ For compatibility : if there is a hw tls register, the kernel 356//ZZ will put at 0xffff0fe0 the instructions to read it, so 357//ZZ as to have old applications calling the kernel helper 358//ZZ working properly. 359//ZZ 360//ZZ For having emulated guest TLS working correctly with 361//ZZ Valgrind, it is needed to execute the syscall to set 362//ZZ the emulated TLS value in addition to the assignment 363//ZZ of TPIDRURO. 364//ZZ 365//ZZ Note: the below means that if we need thread local storage 366//ZZ for Valgrind host, then there will be a conflict between 367//ZZ the need of the guest tls and of the host tls. 368//ZZ If all the guest code would cleanly call 0xffff0fe0, 369//ZZ then we might maybe intercept this. However, at least 370//ZZ __libc_preinit reads directly 0xffff0ff0. 371//ZZ */ 372//ZZ /* ??? might call the below if auxv->u.a_val & VKI_HWCAP_TLS ??? 373//ZZ Unclear if real hardware having tls hw register sets 374//ZZ VKI_HWCAP_TLS. */ 375//ZZ return VG_(do_syscall1) (__NR_ARM_set_tls, tlsptr); 376//ZZ #else 377//ZZ return VG_(mk_SysRes_Success)( 0 ); 378//ZZ #endif 379//ZZ } 380 381/* --------------------------------------------------------------------- 382 PRE/POST wrappers for arm/Linux-specific syscalls 383 ------------------------------------------------------------------ */ 384 385#define PRE(name) DEFN_PRE_TEMPLATE(arm64_linux, name) 386#define POST(name) DEFN_POST_TEMPLATE(arm64_linux, name) 387 388/* Add prototypes for the wrappers declared here, so that gcc doesn't 389 harass us for not having prototypes. Really this is a kludge -- 390 the right thing to do is to make these wrappers 'static' since they 391 aren't visible outside this file, but that requires even more macro 392 magic. */ 393 394DECL_TEMPLATE(arm64_linux, sys_fadvise64); 395DECL_TEMPLATE(arm64_linux, sys_mmap); 396//ZZ DECL_TEMPLATE(arm_linux, sys_stat64); 397//ZZ DECL_TEMPLATE(arm_linux, sys_lstat64); 398//ZZ DECL_TEMPLATE(arm_linux, sys_fstatat64); 399//ZZ DECL_TEMPLATE(arm_linux, sys_fstat64); 400DECL_TEMPLATE(arm64_linux, sys_clone); 401//ZZ DECL_TEMPLATE(arm_linux, sys_sigreturn); 402DECL_TEMPLATE(arm64_linux, sys_rt_sigreturn); 403//ZZ DECL_TEMPLATE(arm_linux, sys_sigsuspend); 404//ZZ DECL_TEMPLATE(arm_linux, sys_set_tls); 405//ZZ DECL_TEMPLATE(arm_linux, sys_cacheflush); 406//ZZ DECL_TEMPLATE(arm_linux, sys_ptrace); 407 408//ZZ PRE(sys_mmap2) 409//ZZ { 410//ZZ SysRes r; 411//ZZ 412//ZZ // Exactly like old_mmap() except: 413//ZZ // - all 6 args are passed in regs, rather than in a memory-block. 414//ZZ // - the file offset is specified in pagesize units rather than bytes, 415//ZZ // so that it can be used for files bigger than 2^32 bytes. 416//ZZ // pagesize or 4K-size units in offset? For ppc32/64-linux, this is 417//ZZ // 4K-sized. Assert that the page size is 4K here for safety. 418//ZZ vg_assert(VKI_PAGE_SIZE == 4096); 419//ZZ PRINT("sys_mmap2 ( %#lx, %llu, %ld, %ld, %ld, %ld )", 420//ZZ ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 ); 421//ZZ PRE_REG_READ6(long, "mmap2", 422//ZZ unsigned long, start, unsigned long, length, 423//ZZ unsigned long, prot, unsigned long, flags, 424//ZZ unsigned long, fd, unsigned long, offset); 425//ZZ 426//ZZ r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5, 427//ZZ 4096 * (Off64T)ARG6 ); 428//ZZ SET_STATUS_from_SysRes(r); 429//ZZ } 430 431// ARM64 FIXME is this correct? 432PRE(sys_fadvise64) 433{ 434 PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", SARG1, SARG2, ARG3, SARG4); 435 PRE_REG_READ4(long, "fadvise64", 436 int, fd, vki_loff_t, offset, vki_size_t, len, int, advice); 437} 438 439// ARM64 FIXME is this correct? 440PRE(sys_mmap) 441{ 442 SysRes r; 443 444 PRINT("sys_mmap ( %#lx, %lu, %lu, %#lx, %lu, %lu )", 445 ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 ); 446 PRE_REG_READ6(long, "mmap", 447 unsigned long, start, unsigned long, length, 448 unsigned long, prot, unsigned long, flags, 449 unsigned long, fd, unsigned long, offset); 450 451 r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 ); 452 SET_STATUS_from_SysRes(r); 453} 454 455//ZZ 456//ZZ // XXX: lstat64/fstat64/stat64 are generic, but not necessarily 457//ZZ // applicable to every architecture -- I think only to 32-bit archs. 458//ZZ // We're going to need something like linux/core_os32.h for such 459//ZZ // things, eventually, I think. --njn 460//ZZ PRE(sys_lstat64) 461//ZZ { 462//ZZ PRINT("sys_lstat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2); 463//ZZ PRE_REG_READ2(long, "lstat64", char *, file_name, struct stat64 *, buf); 464//ZZ PRE_MEM_RASCIIZ( "lstat64(file_name)", ARG1 ); 465//ZZ PRE_MEM_WRITE( "lstat64(buf)", ARG2, sizeof(struct vki_stat64) ); 466//ZZ } 467//ZZ 468//ZZ POST(sys_lstat64) 469//ZZ { 470//ZZ vg_assert(SUCCESS); 471//ZZ if (RES == 0) { 472//ZZ POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) ); 473//ZZ } 474//ZZ } 475//ZZ 476//ZZ PRE(sys_stat64) 477//ZZ { 478//ZZ PRINT("sys_stat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2); 479//ZZ PRE_REG_READ2(long, "stat64", char *, file_name, struct stat64 *, buf); 480//ZZ PRE_MEM_RASCIIZ( "stat64(file_name)", ARG1 ); 481//ZZ PRE_MEM_WRITE( "stat64(buf)", ARG2, sizeof(struct vki_stat64) ); 482//ZZ } 483//ZZ 484//ZZ POST(sys_stat64) 485//ZZ { 486//ZZ POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) ); 487//ZZ } 488//ZZ 489//ZZ PRE(sys_fstatat64) 490//ZZ { 491//ZZ PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx )",ARG1,ARG2,(char*)ARG2,ARG3); 492//ZZ PRE_REG_READ3(long, "fstatat64", 493//ZZ int, dfd, char *, file_name, struct stat64 *, buf); 494//ZZ PRE_MEM_RASCIIZ( "fstatat64(file_name)", ARG2 ); 495//ZZ PRE_MEM_WRITE( "fstatat64(buf)", ARG3, sizeof(struct vki_stat64) ); 496//ZZ } 497//ZZ 498//ZZ POST(sys_fstatat64) 499//ZZ { 500//ZZ POST_MEM_WRITE( ARG3, sizeof(struct vki_stat64) ); 501//ZZ } 502//ZZ 503//ZZ PRE(sys_fstat64) 504//ZZ { 505//ZZ PRINT("sys_fstat64 ( %ld, %#lx )",ARG1,ARG2); 506//ZZ PRE_REG_READ2(long, "fstat64", unsigned long, fd, struct stat64 *, buf); 507//ZZ PRE_MEM_WRITE( "fstat64(buf)", ARG2, sizeof(struct vki_stat64) ); 508//ZZ } 509//ZZ 510//ZZ POST(sys_fstat64) 511//ZZ { 512//ZZ POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) ); 513//ZZ } 514 515/* Aarch64 seems to use CONFIG_CLONE_BACKWARDS in the kernel. See: 516 http://dev.gentoo.org/~vapier/aarch64/linux-3.12.6.config 517 http://people.redhat.com/wcohen/aarch64/aarch64_config 518 from linux-3.10.5/kernel/fork.c 519 #ifdef CONFIG_CLONE_BACKWARDS 520 SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp, 521 int __user *, parent_tidptr, 522 int, tls_val, 523 int __user *, child_tidptr) 524*/ 525PRE(sys_clone) 526{ 527 UInt cloneflags; 528 529 PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5); 530 PRE_REG_READ5(int, "clone", 531 unsigned long, flags, 532 void *, child_stack, 533 int *, parent_tidptr, 534 void *, child_tls, 535 int *, child_tidptr); 536 537 if (ARG1 & VKI_CLONE_PARENT_SETTID) { 538 PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int)); 539 if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int), 540 VKI_PROT_WRITE)) { 541 SET_STATUS_Failure( VKI_EFAULT ); 542 return; 543 } 544 } 545//ZZ if (ARG1 & VKI_CLONE_SETTLS) { 546//ZZ PRE_MEM_READ("clone(tls_user_desc)", ARG4, sizeof(vki_modify_ldt_t)); 547//ZZ if (!VG_(am_is_valid_for_client)(ARG4, sizeof(vki_modify_ldt_t), 548//ZZ VKI_PROT_READ)) { 549//ZZ SET_STATUS_Failure( VKI_EFAULT ); 550//ZZ return; 551//ZZ } 552//ZZ } 553 if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) { 554 PRE_MEM_WRITE("clone(child_tidptr)", ARG5, sizeof(Int)); 555 if (!VG_(am_is_valid_for_client)(ARG5, sizeof(Int), 556 VKI_PROT_WRITE)) { 557 SET_STATUS_Failure( VKI_EFAULT ); 558 return; 559 } 560 } 561 562 cloneflags = ARG1; 563 564 if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) { 565 SET_STATUS_Failure( VKI_EINVAL ); 566 return; 567 } 568 569 /* Only look at the flags we really care about */ 570 switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS 571 | VKI_CLONE_FILES | VKI_CLONE_VFORK)) { 572 case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES: 573 /* thread creation */ 574 SET_STATUS_from_SysRes( 575 do_clone(tid, 576 ARG1, /* flags */ 577 (Addr)ARG2, /* child SP */ 578 (Int*)ARG3, /* parent_tidptr */ 579 (Int*)ARG5, /* child_tidptr */ 580 (Addr)ARG4)); /* tls_val */ 581 break; 582 583 case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */ 584 /* FALLTHROUGH - assume vfork == fork */ 585 cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM); 586 587 case 0: /* plain fork */ 588 SET_STATUS_from_SysRes( 589 ML_(do_fork_clone)(tid, 590 cloneflags, /* flags */ 591 (Int*)ARG3, /* parent_tidptr */ 592 (Int*)ARG5)); /* child_tidptr */ 593 break; 594 595 default: 596 /* should we just ENOSYS? */ 597 VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG1); 598 VG_(message)(Vg_UserMsg, "\n"); 599 VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n"); 600 VG_(message)(Vg_UserMsg, " - via a threads library (LinuxThreads or NPTL)\n"); 601 VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork\n"); 602 VG_(message)(Vg_UserMsg, " - for the Quadrics Elan3 user-space driver\n"); 603 VG_(unimplemented) 604 ("Valgrind does not support general clone()."); 605 } 606 607 if (SUCCESS) { 608 if (ARG1 & VKI_CLONE_PARENT_SETTID) 609 POST_MEM_WRITE(ARG3, sizeof(Int)); 610 if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) 611 POST_MEM_WRITE(ARG5, sizeof(Int)); 612 613 /* Thread creation was successful; let the child have the chance 614 to run */ 615 *flags |= SfYieldAfter; 616 } 617} 618 619//ZZ PRE(sys_sigreturn) 620//ZZ { 621//ZZ /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for 622//ZZ an explanation of what follows. */ 623//ZZ 624//ZZ PRINT("sys_sigreturn ( )"); 625//ZZ 626//ZZ vg_assert(VG_(is_valid_tid)(tid)); 627//ZZ vg_assert(tid >= 1 && tid < VG_N_THREADS); 628//ZZ vg_assert(VG_(is_running_thread)(tid)); 629//ZZ 630//ZZ /* Restore register state from frame and remove it */ 631//ZZ VG_(sigframe_destroy)(tid, False); 632//ZZ 633//ZZ /* Tell the driver not to update the guest state with the "result", 634//ZZ and set a bogus result to keep it happy. */ 635//ZZ *flags |= SfNoWriteResult; 636//ZZ SET_STATUS_Success(0); 637//ZZ 638//ZZ /* Check to see if any signals arose as a result of this. */ 639//ZZ *flags |= SfPollAfter; 640//ZZ } 641 642PRE(sys_rt_sigreturn) 643{ 644 /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for 645 an explanation of what follows. */ 646 647 PRINT("rt_sigreturn ( )"); 648 649 vg_assert(VG_(is_valid_tid)(tid)); 650 vg_assert(tid >= 1 && tid < VG_N_THREADS); 651 vg_assert(VG_(is_running_thread)(tid)); 652 653 /* Restore register state from frame and remove it */ 654 VG_(sigframe_destroy)(tid, True); 655 656 /* Tell the driver not to update the guest state with the "result", 657 and set a bogus result to keep it happy. */ 658 *flags |= SfNoWriteResult; 659 SET_STATUS_Success(0); 660 661 /* Check to see if any signals arose as a result of this. */ 662 *flags |= SfPollAfter; 663} 664 665//ZZ /* NB: clone of x86-linux version, and ppc32-linux has an almost 666//ZZ identical one. */ 667//ZZ PRE(sys_sigsuspend) 668//ZZ { 669//ZZ /* The C library interface to sigsuspend just takes a pointer to 670//ZZ a signal mask but this system call has three arguments - the first 671//ZZ two don't appear to be used by the kernel and are always passed as 672//ZZ zero by glibc and the third is the first word of the signal mask 673//ZZ so only 32 signals are supported. 674//ZZ 675//ZZ In fact glibc normally uses rt_sigsuspend if it is available as 676//ZZ that takes a pointer to the signal mask so supports more signals. 677//ZZ */ 678//ZZ *flags |= SfMayBlock; 679//ZZ PRINT("sys_sigsuspend ( %ld, %ld, %ld )", ARG1,ARG2,ARG3 ); 680//ZZ PRE_REG_READ3(int, "sigsuspend", 681//ZZ int, history0, int, history1, 682//ZZ vki_old_sigset_t, mask); 683//ZZ } 684//ZZ 685//ZZ /* Very much ARM specific */ 686//ZZ 687//ZZ PRE(sys_set_tls) 688//ZZ { 689//ZZ PRINT("set_tls (%lx)",ARG1); 690//ZZ PRE_REG_READ1(long, "set_tls", unsigned long, addr); 691//ZZ 692//ZZ SET_STATUS_from_SysRes( sys_set_tls( tid, ARG1 ) ); 693//ZZ } 694//ZZ 695//ZZ PRE(sys_cacheflush) 696//ZZ { 697//ZZ PRINT("cacheflush (%lx, %#lx, %#lx)",ARG1,ARG2,ARG3); 698//ZZ PRE_REG_READ3(long, "cacheflush", void*, addrlow,void*, addrhigh,int, flags); 699//ZZ VG_(discard_translations)( (Addr)ARG1, 700//ZZ ((ULong)ARG2) - ((ULong)ARG1) + 1ULL/*paranoia*/, 701//ZZ "PRE(sys_cacheflush)" ); 702//ZZ SET_STATUS_Success(0); 703//ZZ } 704//ZZ 705//ZZ // ARG3 is only used for pointers into the traced process's address 706//ZZ // space and for offsets into the traced process's struct 707//ZZ // user_regs_struct. It is never a pointer into this process's memory 708//ZZ // space, and we should therefore not check anything it points to. 709//ZZ PRE(sys_ptrace) 710//ZZ { 711//ZZ PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4); 712//ZZ PRE_REG_READ4(int, "ptrace", 713//ZZ long, request, long, pid, long, addr, long, data); 714//ZZ switch (ARG1) { 715//ZZ case VKI_PTRACE_PEEKTEXT: 716//ZZ case VKI_PTRACE_PEEKDATA: 717//ZZ case VKI_PTRACE_PEEKUSR: 718//ZZ PRE_MEM_WRITE( "ptrace(peek)", ARG4, 719//ZZ sizeof (long)); 720//ZZ break; 721//ZZ case VKI_PTRACE_GETREGS: 722//ZZ PRE_MEM_WRITE( "ptrace(getregs)", ARG4, 723//ZZ sizeof (struct vki_user_regs_struct)); 724//ZZ break; 725//ZZ case VKI_PTRACE_GETFPREGS: 726//ZZ PRE_MEM_WRITE( "ptrace(getfpregs)", ARG4, 727//ZZ sizeof (struct vki_user_fp)); 728//ZZ break; 729//ZZ case VKI_PTRACE_GETWMMXREGS: 730//ZZ PRE_MEM_WRITE( "ptrace(getwmmxregs)", ARG4, 731//ZZ VKI_IWMMXT_SIZE); 732//ZZ break; 733//ZZ case VKI_PTRACE_GETCRUNCHREGS: 734//ZZ PRE_MEM_WRITE( "ptrace(getcrunchregs)", ARG4, 735//ZZ VKI_CRUNCH_SIZE); 736//ZZ break; 737//ZZ case VKI_PTRACE_GETVFPREGS: 738//ZZ PRE_MEM_WRITE( "ptrace(getvfpregs)", ARG4, 739//ZZ sizeof (struct vki_user_vfp) ); 740//ZZ break; 741//ZZ case VKI_PTRACE_GETHBPREGS: 742//ZZ PRE_MEM_WRITE( "ptrace(gethbpregs)", ARG4, 743//ZZ sizeof (unsigned long) ); 744//ZZ break; 745//ZZ case VKI_PTRACE_SETREGS: 746//ZZ PRE_MEM_READ( "ptrace(setregs)", ARG4, 747//ZZ sizeof (struct vki_user_regs_struct)); 748//ZZ break; 749//ZZ case VKI_PTRACE_SETFPREGS: 750//ZZ PRE_MEM_READ( "ptrace(setfpregs)", ARG4, 751//ZZ sizeof (struct vki_user_fp)); 752//ZZ break; 753//ZZ case VKI_PTRACE_SETWMMXREGS: 754//ZZ PRE_MEM_READ( "ptrace(setwmmxregs)", ARG4, 755//ZZ VKI_IWMMXT_SIZE); 756//ZZ break; 757//ZZ case VKI_PTRACE_SETCRUNCHREGS: 758//ZZ PRE_MEM_READ( "ptrace(setcrunchregs)", ARG4, 759//ZZ VKI_CRUNCH_SIZE); 760//ZZ break; 761//ZZ case VKI_PTRACE_SETVFPREGS: 762//ZZ PRE_MEM_READ( "ptrace(setvfpregs)", ARG4, 763//ZZ sizeof (struct vki_user_vfp)); 764//ZZ break; 765//ZZ case VKI_PTRACE_SETHBPREGS: 766//ZZ PRE_MEM_READ( "ptrace(sethbpregs)", ARG4, sizeof(unsigned long)); 767//ZZ break; 768//ZZ case VKI_PTRACE_GET_THREAD_AREA: 769//ZZ PRE_MEM_WRITE( "ptrace(get_thread_area)", ARG4, sizeof(unsigned long)); 770//ZZ break; 771//ZZ case VKI_PTRACE_GETEVENTMSG: 772//ZZ PRE_MEM_WRITE( "ptrace(geteventmsg)", ARG4, sizeof(unsigned long)); 773//ZZ break; 774//ZZ case VKI_PTRACE_GETSIGINFO: 775//ZZ PRE_MEM_WRITE( "ptrace(getsiginfo)", ARG4, sizeof(vki_siginfo_t)); 776//ZZ break; 777//ZZ case VKI_PTRACE_SETSIGINFO: 778//ZZ PRE_MEM_READ( "ptrace(setsiginfo)", ARG4, sizeof(vki_siginfo_t)); 779//ZZ break; 780//ZZ case VKI_PTRACE_GETREGSET: 781//ZZ ML_(linux_PRE_getregset)(tid, ARG3, ARG4); 782//ZZ break; 783//ZZ case VKI_PTRACE_SETREGSET: 784//ZZ ML_(linux_PRE_setregset)(tid, ARG3, ARG4); 785//ZZ break; 786//ZZ default: 787//ZZ break; 788//ZZ } 789//ZZ } 790//ZZ 791//ZZ POST(sys_ptrace) 792//ZZ { 793//ZZ switch (ARG1) { 794//ZZ case VKI_PTRACE_PEEKTEXT: 795//ZZ case VKI_PTRACE_PEEKDATA: 796//ZZ case VKI_PTRACE_PEEKUSR: 797//ZZ POST_MEM_WRITE( ARG4, sizeof (long)); 798//ZZ break; 799//ZZ case VKI_PTRACE_GETREGS: 800//ZZ POST_MEM_WRITE( ARG4, sizeof (struct vki_user_regs_struct)); 801//ZZ break; 802//ZZ case VKI_PTRACE_GETFPREGS: 803//ZZ POST_MEM_WRITE( ARG4, sizeof (struct vki_user_fp)); 804//ZZ break; 805//ZZ case VKI_PTRACE_GETWMMXREGS: 806//ZZ POST_MEM_WRITE( ARG4, VKI_IWMMXT_SIZE); 807//ZZ break; 808//ZZ case VKI_PTRACE_GETCRUNCHREGS: 809//ZZ POST_MEM_WRITE( ARG4, VKI_CRUNCH_SIZE); 810//ZZ break; 811//ZZ case VKI_PTRACE_GETVFPREGS: 812//ZZ POST_MEM_WRITE( ARG4, sizeof(struct vki_user_vfp)); 813//ZZ break; 814//ZZ case VKI_PTRACE_GET_THREAD_AREA: 815//ZZ case VKI_PTRACE_GETHBPREGS: 816//ZZ case VKI_PTRACE_GETEVENTMSG: 817//ZZ POST_MEM_WRITE( ARG4, sizeof(unsigned long)); 818//ZZ break; 819//ZZ case VKI_PTRACE_GETSIGINFO: 820//ZZ /* XXX: This is a simplification. Different parts of the 821//ZZ * siginfo_t are valid depending on the type of signal. 822//ZZ */ 823//ZZ POST_MEM_WRITE( ARG4, sizeof(vki_siginfo_t)); 824//ZZ break; 825//ZZ case VKI_PTRACE_GETREGSET: 826//ZZ ML_(linux_POST_getregset)(tid, ARG3, ARG4); 827//ZZ break; 828//ZZ default: 829//ZZ break; 830//ZZ } 831//ZZ } 832//ZZ 833//ZZ #undef PRE 834//ZZ #undef POST 835 836/* --------------------------------------------------------------------- 837 The arm64/Linux syscall table 838 ------------------------------------------------------------------ */ 839 840//ZZ #if 0 841//ZZ #define __NR_OABI_SYSCALL_BASE 0x900000 842//ZZ #else 843//ZZ #define __NR_OABI_SYSCALL_BASE 0x0 844//ZZ #endif 845 846#define PLAX_(sysno, name) WRAPPER_ENTRY_X_(arm64_linux, sysno, name) 847#define PLAXY(sysno, name) WRAPPER_ENTRY_XY(arm64_linux, sysno, name) 848 849// This table maps from __NR_xxx syscall numbers (from 850// linux/include/asm-arm/unistd.h) to the appropriate PRE/POST sys_foo() 851// wrappers on arm64 (as per sys_call_table in linux/arch/arm/kernel/entry.S). 852// 853// For those syscalls not handled by Valgrind, the annotation indicate its 854// arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/? 855// (unknown). 856 857static SyscallTableEntry syscall_main_table[] = { 858 LINX_(__NR_setxattr, sys_setxattr), // 5 859 LINX_(__NR_lsetxattr, sys_lsetxattr), // 6 860 LINX_(__NR_fsetxattr, sys_fsetxattr), // 7 861 LINXY(__NR_getxattr, sys_getxattr), // 8 862 LINXY(__NR_lgetxattr, sys_lgetxattr), // 9 863 LINXY(__NR_fgetxattr, sys_fgetxattr), // 10 864 LINXY(__NR_listxattr, sys_listxattr), // 11 865 LINXY(__NR_llistxattr, sys_llistxattr), // 12 866 LINXY(__NR_flistxattr, sys_flistxattr), // 13 867 LINX_(__NR_removexattr, sys_removexattr), // 14 868 LINX_(__NR_lremovexattr, sys_lremovexattr), // 15 869 LINX_(__NR_fremovexattr, sys_fremovexattr), // 16 870 GENXY(__NR_getcwd, sys_getcwd), // 17 871 LINXY(__NR_eventfd2, sys_eventfd2), // 19 872 LINXY(__NR_epoll_create1, sys_epoll_create1), // 20 873 LINX_(__NR_epoll_ctl, sys_epoll_ctl), // 21 874 LINXY(__NR_epoll_pwait, sys_epoll_pwait), // 22 875 GENXY(__NR_dup, sys_dup), // 23 876 LINXY(__NR_dup3, sys_dup3), // 24 877 878 // FIXME IS THIS CORRECT? 879 LINXY(__NR3264_fcntl, sys_fcntl), // 25 880 881 LINXY(__NR_inotify_init1, sys_inotify_init1), // 26 882 LINX_(__NR_inotify_add_watch, sys_inotify_add_watch), // 27 883 LINX_(__NR_inotify_rm_watch, sys_inotify_rm_watch), // 28 884 LINXY(__NR_ioctl, sys_ioctl), // 29 885 GENX_(__NR_flock, sys_flock), // 32 886 LINX_(__NR_mknodat, sys_mknodat), // 33 887 LINX_(__NR_mkdirat, sys_mkdirat), // 34 888 LINX_(__NR_unlinkat, sys_unlinkat), // 35 889 LINX_(__NR_symlinkat, sys_symlinkat), // 36 890 LINX_(__NR_linkat, sys_linkat), // 37 891 LINX_(__NR_renameat, sys_renameat), // 38 892 893 LINX_(__NR_umount2, sys_umount), // 39 894 LINX_(__NR_mount, sys_mount), // 40 895 896 // FIXME IS THIS CORRECT? it may well not be. 897 GENXY(__NR3264_statfs, sys_statfs), // 43 898 GENXY(__NR3264_fstatfs, sys_fstatfs), // 44 899 900 // FIXME IS THIS CORRECT? it may well not be. 901 GENX_(__NR3264_ftruncate, sys_ftruncate), // 46 902 903 LINX_(__NR_fallocate, sys_fallocate), // 47 904 LINX_(__NR_faccessat, sys_faccessat), // 48 905 GENX_(__NR_chdir, sys_chdir), // 49 906 GENX_(__NR_fchdir, sys_fchdir), // 50 907 GENX_(__NR_chroot, sys_chroot), // 51 908 GENX_(__NR_fchmod, sys_fchmod), // 52 909 LINX_(__NR_fchmodat, sys_fchmodat), // 53 910 LINX_(__NR_fchownat, sys_fchownat), // 54 911 GENX_(__NR_fchown, sys_fchown), // 55 912 LINXY(__NR_openat, sys_openat), // 56 913 GENXY(__NR_close, sys_close), // 57 914 LINXY(__NR_pipe2, sys_pipe2), // 59 915 LINX_(__NR_quotactl, sys_quotactl), // 60 916 GENXY(__NR_getdents64, sys_getdents64), // 61 917 918 // FIXME IS THIS CORRECT? 919 LINX_(__NR3264_lseek, sys_lseek), // 62 920 921 GENXY(__NR_read, sys_read), // 63 922 GENX_(__NR_write, sys_write), // 64 923 GENXY(__NR_readv, sys_readv), // 65 924 GENX_(__NR_writev, sys_writev), // 66 925 GENXY(__NR_pread64, sys_pread64), // 67 926 GENX_(__NR_pwrite64, sys_pwrite64), // 68 927 LINX_(__NR_pselect6, sys_pselect6), // 72 928 LINXY(__NR_ppoll, sys_ppoll), // 73 929 LINXY(__NR_signalfd4, sys_signalfd4), // 74 930 LINX_(__NR_readlinkat, sys_readlinkat), // 78 931 932 // FIXME IS THIS CORRECT? 933 LINXY(__NR3264_fstatat, sys_newfstatat), // 79 934 GENXY(__NR3264_fstat, sys_newfstat), // 80 935 936 LINX_(__NR_utimensat, sys_utimensat), // 88 937 GENX_(__NR_fsync, sys_fsync), // 82 938 GENX_(__NR_fdatasync, sys_fdatasync), // 83 939 LINXY(__NR_timerfd_create, sys_timerfd_create), // 85 940 LINXY(__NR_timerfd_settime, sys_timerfd_settime), // 86 941 LINXY(__NR_timerfd_gettime, sys_timerfd_gettime), // 87 942 LINXY(__NR_capget, sys_capget), // 90 943 GENX_(__NR_exit, sys_exit), // 93 944 LINX_(__NR_exit_group, sys_exit_group), // 94 945 LINX_(__NR_set_tid_address, sys_set_tid_address), // 96 946 LINXY(__NR_futex, sys_futex), // 98 947 LINX_(__NR_set_robust_list, sys_set_robust_list), // 99 948 GENXY(__NR_nanosleep, sys_nanosleep), // 101 949 GENXY(__NR_setitimer, sys_setitimer), // 103 950 LINXY(__NR_clock_gettime, sys_clock_gettime), // 113 951 LINXY(__NR_clock_getres, sys_clock_getres), // 114 952 LINXY(__NR_syslog, sys_syslog), // 116 953 LINX_(__NR_sched_setaffinity, sys_sched_setaffinity), // 122 954 LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 123 955 LINX_(__NR_sched_yield, sys_sched_yield), // 124 956 GENX_(__NR_kill, sys_kill), // 129 957 LINX_(__NR_tgkill, sys_tgkill), // 131 958 GENXY(__NR_sigaltstack, sys_sigaltstack), // 132 959 LINX_(__NR_rt_sigsuspend, sys_rt_sigsuspend), // 133 960 LINXY(__NR_rt_sigaction, sys_rt_sigaction), // 134 961 LINXY(__NR_rt_sigprocmask, sys_rt_sigprocmask), // 135 962 LINXY(__NR_rt_sigpending, sys_rt_sigpending), // 136 963 LINXY(__NR_rt_sigtimedwait, sys_rt_sigtimedwait), // 137 964 LINXY(__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo), // 138 965 PLAX_(__NR_rt_sigreturn, sys_rt_sigreturn), // 139 966 GENX_(__NR_setpriority, sys_setpriority), // 140 967 GENX_(__NR_getpriority, sys_getpriority), // 141 968 GENX_(__NR_setregid, sys_setregid), // 143 969 GENX_(__NR_setgid, sys_setgid), // 144 970 GENX_(__NR_setreuid, sys_setreuid), // 145 971 GENX_(__NR_setuid, sys_setuid), // 146 972 LINX_(__NR_setresuid, sys_setresuid), // 147 973 LINXY(__NR_getresuid, sys_getresuid), // 148 974 LINX_(__NR_setresgid, sys_setresgid), // 149 975 LINXY(__NR_getresgid, sys_getresgid), // 150 976 GENXY(__NR_times, sys_times), // 153 977 GENX_(__NR_setpgid, sys_setpgid), // 154 978 GENX_(__NR_getpgid, sys_getpgid), // 155 979 GENX_(__NR_getsid, sys_getsid), // 156 980 GENX_(__NR_setsid, sys_setsid), // 157 981 GENXY(__NR_getgroups, sys_getgroups), // 158 982 GENX_(__NR_setgroups, sys_setgroups), // 159 983 GENXY(__NR_uname, sys_newuname), // 160 984 GENXY(__NR_getrlimit, sys_old_getrlimit), // 163 985 GENX_(__NR_setrlimit, sys_setrlimit), // 164 986 GENXY(__NR_getrusage, sys_getrusage), // 165 987 GENX_(__NR_umask, sys_umask), // 166 988 LINXY(__NR_prctl, sys_prctl), // 167 989 GENXY(__NR_gettimeofday, sys_gettimeofday), // 169 990 GENX_(__NR_getpid, sys_getpid), // 172 991 GENX_(__NR_getppid, sys_getppid), // 173 992 GENX_(__NR_getuid, sys_getuid), // 174 993 GENX_(__NR_geteuid, sys_geteuid), // 175 994 GENX_(__NR_getgid, sys_getgid), // 176 995 GENX_(__NR_getegid, sys_getegid), // 177 996 LINX_(__NR_gettid, sys_gettid), // 178 997 LINXY(__NR_sysinfo, sys_sysinfo), // 179 998 LINXY(__NR_mq_open, sys_mq_open), // 180 999 LINX_(__NR_mq_unlink, sys_mq_unlink), // 181 1000 LINX_(__NR_mq_timedsend, sys_mq_timedsend), // 182 1001 LINXY(__NR_mq_timedreceive, sys_mq_timedreceive), // 183 1002 LINX_(__NR_mq_notify, sys_mq_notify), // 184 1003 LINXY(__NR_mq_getsetattr, sys_mq_getsetattr), // 185 1004 LINX_(__NR_msgget, sys_msgget), // 186 1005 LINXY(__NR_msgctl, sys_msgctl), // 187 1006 LINXY(__NR_msgrcv, sys_msgrcv), // 188 1007 LINX_(__NR_msgsnd, sys_msgsnd), // 189 1008 LINX_(__NR_semget, sys_semget), // 190 1009 LINXY(__NR_semctl, sys_semctl), // 191 1010 LINX_(__NR_semtimedop, sys_semtimedop), // 192 1011 LINX_(__NR_semop, sys_semop), // 193 1012 LINX_(__NR_shmget, sys_shmget), // 194 1013 LINXY(__NR_shmctl, sys_shmctl), // 195 1014 LINXY(__NR_shmat, wrap_sys_shmat), // 196 1015 LINXY(__NR_shmdt, sys_shmdt), // 197 1016 LINXY(__NR_socket, sys_socket), // 198 1017 LINXY(__NR_socketpair, sys_socketpair), // 199 1018 LINX_(__NR_bind, sys_bind), // 200 1019 LINX_(__NR_listen, sys_listen), // 201 1020 LINXY(__NR_accept, sys_accept), // 202 1021 LINX_(__NR_connect, sys_connect), // 203 1022 LINXY(__NR_getsockname, sys_getsockname), // 204 1023 LINXY(__NR_getpeername, sys_getpeername), // 205 1024 LINX_(__NR_sendto, sys_sendto), // 206 1025 LINXY(__NR_recvfrom, sys_recvfrom), // 207 1026 LINX_(__NR_setsockopt, sys_setsockopt), // 208 1027 LINXY(__NR_getsockopt, sys_getsockopt), // 209 1028 LINX_(__NR_shutdown, sys_shutdown), // 210 1029 LINX_(__NR_sendmsg, sys_sendmsg), // 211 1030 LINXY(__NR_recvmsg, sys_recvmsg), // 212 1031 LINX_(__NR_readahead, sys_readahead), // 213 1032 GENX_(__NR_brk, sys_brk), // 214 1033 GENXY(__NR_munmap, sys_munmap), // 215 1034 GENX_(__NR_mremap, sys_mremap), // 216 1035 LINX_(__NR_add_key, sys_add_key), // 217 1036 LINXY(__NR_keyctl, sys_keyctl), // 219 1037 PLAX_(__NR_clone, sys_clone), // 220 1038 GENX_(__NR_execve, sys_execve), // 221 1039 1040 // FIXME IS THIS CORRECT? 1041 PLAX_(__NR3264_mmap, sys_mmap), // 222 1042 PLAX_(__NR3264_fadvise64, sys_fadvise64), // 223 1043 1044 GENXY(__NR_mprotect, sys_mprotect), // 226 1045 GENX_(__NR_msync, sys_msync), // 227 1046 GENX_(__NR_mlock, sys_mlock), // 228 1047 GENX_(__NR_mlockall, sys_mlockall), // 230 1048 GENX_(__NR_madvise, sys_madvise), // 233 1049 LINX_(__NR_mbind, sys_mbind), // 235 1050 LINXY(__NR_get_mempolicy, sys_get_mempolicy), // 236 1051 LINX_(__NR_set_mempolicy, sys_set_mempolicy), // 237 1052 1053 LINXY(__NR_recvmmsg, sys_recvmmsg), // 243 1054 LINXY(__NR_accept4, sys_accept4), // 242 1055 1056 GENXY(__NR_wait4, sys_wait4), // 260 1057 1058 LINX_(__NR_syncfs, sys_syncfs), // 267 1059 1060 LINXY(__NR_sendmmsg, sys_sendmmsg), // 269 1061 LINXY(__NR_process_vm_readv, sys_process_vm_readv), // 270 1062 LINX_(__NR_process_vm_writev, sys_process_vm_writev), // 271 1063 LINXY(__NR_getrandom, sys_getrandom), // 278 1064 LINXY(__NR_memfd_create, sys_memfd_create), // 279 1065 1066// The numbers below are bogus. (See comment further down.) 1067// When pulling entries above this line, change the numbers 1068// to be correct. 1069 1070//ZZ //zz // (restart_syscall) // 0 1071//ZZ GENX_(__NR_fork, sys_fork), // 2 1072//ZZ 1073//ZZ GENXY(__NR_open, sys_open), // 5 1074//ZZ // GENXY(__NR_waitpid, sys_waitpid), // 7 1075//ZZ GENXY(__NR_creat, sys_creat), // 8 1076//ZZ GENX_(__NR_link, sys_link), // 9 1077//ZZ 1078//ZZ GENX_(__NR_unlink, sys_unlink), // 10 1079//ZZ GENXY(__NR_time, sys_time), // 13 1080//ZZ GENX_(__NR_mknod, sys_mknod), // 14 1081//ZZ 1082//ZZ GENX_(__NR_chmod, sys_chmod), // 15 1083//ZZ //zz LINX_(__NR_lchown, sys_lchown16), // 16 1084//ZZ // GENX_(__NR_break, sys_ni_syscall), // 17 1085//ZZ //zz // (__NR_oldstat, sys_stat), // 18 (obsolete) 1086//ZZ LINX_(__NR_lseek, sys_lseek), // 19 1087//ZZ 1088//ZZ GENX_(__NR_getpid, sys_getpid), // 20 1089//ZZ LINX_(__NR_umount, sys_oldumount), // 22 1090//ZZ LINX_(__NR_setuid, sys_setuid16), // 23 ## P 1091//ZZ LINX_(__NR_getuid, sys_getuid16), // 24 ## P 1092//ZZ //zz 1093//ZZ //zz // (__NR_stime, sys_stime), // 25 * (SVr4,SVID,X/OPEN) 1094//ZZ PLAXY(__NR_ptrace, sys_ptrace), // 26 1095//ZZ GENX_(__NR_alarm, sys_alarm), // 27 1096//ZZ //zz // (__NR_oldfstat, sys_fstat), // 28 * L -- obsolete 1097//ZZ GENX_(__NR_pause, sys_pause), // 29 1098//ZZ 1099//ZZ LINX_(__NR_utime, sys_utime), // 30 1100//ZZ // GENX_(__NR_stty, sys_ni_syscall), // 31 1101//ZZ // GENX_(__NR_gtty, sys_ni_syscall), // 32 1102//ZZ GENX_(__NR_access, sys_access), // 33 1103//ZZ GENX_(__NR_nice, sys_nice), // 34 1104//ZZ 1105//ZZ // GENX_(__NR_ftime, sys_ni_syscall), // 35 1106//ZZ GENX_(__NR_sync, sys_sync), // 36 1107//ZZ GENX_(__NR_rename, sys_rename), // 38 1108//ZZ GENX_(__NR_mkdir, sys_mkdir), // 39 1109//ZZ 1110//ZZ GENX_(__NR_rmdir, sys_rmdir), // 40 1111//ZZ LINXY(__NR_pipe, sys_pipe), // 42 1112//ZZ // GENX_(__NR_prof, sys_ni_syscall), // 44 1113 1114//ZZ LINX_(__NR_getgid, sys_getgid16), // 47 1115//ZZ //zz // (__NR_signal, sys_signal), // 48 */* (ANSI C) 1116//ZZ LINX_(__NR_geteuid, sys_geteuid16), // 49 1117//ZZ 1118//ZZ LINX_(__NR_getegid, sys_getegid16), // 50 1119//ZZ GENX_(__NR_acct, sys_acct), // 51 1120//ZZ // GENX_(__NR_lock, sys_ni_syscall), // 53 1121//ZZ 1122//ZZ LINXY(__NR_fcntl, sys_fcntl), // 55 1123//ZZ // GENX_(__NR_mpx, sys_ni_syscall), // 56 1124//ZZ // GENX_(__NR_ulimit, sys_ni_syscall), // 58 1125//ZZ //zz // (__NR_oldolduname, sys_olduname), // 59 Linux -- obsolete 1126//ZZ //zz 1127//ZZ //zz // (__NR_ustat, sys_ustat) // 62 SVr4 -- deprecated 1128//ZZ GENXY(__NR_dup2, sys_dup2), // 63 1129//ZZ GENX_(__NR_getppid, sys_getppid), // 64 1130//ZZ 1131//ZZ GENX_(__NR_getpgrp, sys_getpgrp), // 65 1132//ZZ LINXY(__NR_sigaction, sys_sigaction), // 67 1133//ZZ //zz // (__NR_sgetmask, sys_sgetmask), // 68 */* (ANSI C) 1134//ZZ //zz // (__NR_ssetmask, sys_ssetmask), // 69 */* (ANSI C) 1135//ZZ //zz 1136//ZZ PLAX_(__NR_sigsuspend, sys_sigsuspend), // 72 1137//ZZ LINXY(__NR_sigpending, sys_sigpending), // 73 1138//ZZ //zz // (__NR_sethostname, sys_sethostname), // 74 */* 1139//ZZ //zz 1140//ZZ GENXY(__NR_getrlimit, sys_old_getrlimit), // 76 1141//ZZ GENX_(__NR_settimeofday, sys_settimeofday), // 79 1142//ZZ 1143//ZZ LINXY(__NR_getgroups, sys_getgroups16), // 80 1144//ZZ LINX_(__NR_setgroups, sys_setgroups16), // 81 1145//ZZ // PLAX_(__NR_select, old_select), // 82 1146//ZZ GENX_(__NR_symlink, sys_symlink), // 83 1147//ZZ //zz // (__NR_oldlstat, sys_lstat), // 84 -- obsolete 1148//ZZ //zz 1149//ZZ GENX_(__NR_readlink, sys_readlink), // 85 1150//ZZ //zz // (__NR_uselib, sys_uselib), // 86 */Linux 1151//ZZ //zz // (__NR_swapon, sys_swapon), // 87 */Linux 1152//ZZ //zz // (__NR_reboot, sys_reboot), // 88 */Linux 1153//ZZ //zz // (__NR_readdir, old_readdir), // 89 -- superseded 1154//ZZ //zz 1155//ZZ // _____(__NR_mmap, old_mmap), // 90 1156//ZZ GENXY(__NR_munmap, sys_munmap), // 91 1157//ZZ GENX_(__NR_truncate, sys_truncate), // 92 1158//ZZ GENX_(__NR_ftruncate, sys_ftruncate), // 93 1159//ZZ 1160//ZZ LINX_(__NR_fchown, sys_fchown16), // 95 1161//ZZ // GENX_(__NR_profil, sys_ni_syscall), // 98 1162//ZZ GENXY(__NR_statfs, sys_statfs), // 99 1163//ZZ 1164//ZZ GENXY(__NR_fstatfs, sys_fstatfs), // 100 1165//ZZ // LINX_(__NR_ioperm, sys_ioperm), // 101 1166//ZZ LINXY(__NR_socketcall, sys_socketcall), // 102 1167//ZZ 1168//ZZ GENXY(__NR_getitimer, sys_getitimer), // 105 1169//ZZ GENXY(__NR_stat, sys_newstat), // 106 1170//ZZ GENXY(__NR_lstat, sys_newlstat), // 107 1171//ZZ GENXY(__NR_fstat, sys_newfstat), // 108 1172//ZZ //zz // (__NR_olduname, sys_uname), // 109 -- obsolete 1173//ZZ //zz 1174//ZZ // GENX_(__NR_iopl, sys_iopl), // 110 1175//ZZ LINX_(__NR_vhangup, sys_vhangup), // 111 1176//ZZ // GENX_(__NR_idle, sys_ni_syscall), // 112 1177//ZZ // PLAXY(__NR_vm86old, sys_vm86old), // 113 __NR_syscall... weird 1178//ZZ //zz 1179//ZZ //zz // (__NR_swapoff, sys_swapoff), // 115 */Linux 1180//ZZ // _____(__NR_ipc, sys_ipc), // 117 1181//ZZ GENX_(__NR_fsync, sys_fsync), // 118 1182//ZZ PLAX_(__NR_sigreturn, sys_sigreturn), // 119 ?/Linux 1183//ZZ 1184//ZZ //zz // (__NR_setdomainname, sys_setdomainname), // 121 */*(?) 1185//ZZ // PLAX_(__NR_modify_ldt, sys_modify_ldt), // 123 1186//ZZ //zz LINXY(__NR_adjtimex, sys_adjtimex), // 124 1187//ZZ //zz 1188//ZZ LINXY(__NR_sigprocmask, sys_sigprocmask), // 126 1189//ZZ //zz // Nb: create_module() was removed 2.4-->2.6 1190//ZZ // GENX_(__NR_create_module, sys_ni_syscall), // 127 1191//ZZ LINX_(__NR_init_module, sys_init_module), // 128 1192//ZZ LINX_(__NR_delete_module, sys_delete_module), // 129 1193//ZZ //zz 1194//ZZ //zz // Nb: get_kernel_syms() was removed 2.4-->2.6 1195//ZZ // GENX_(__NR_get_kernel_syms, sys_ni_syscall), // 130 1196//ZZ GENX_(__NR_getpgid, sys_getpgid), // 132 1197//ZZ //zz // (__NR_bdflush, sys_bdflush), // 134 */Linux 1198//ZZ //zz 1199//ZZ //zz // (__NR_sysfs, sys_sysfs), // 135 SVr4 1200//ZZ LINX_(__NR_personality, sys_personality), // 136 1201//ZZ // GENX_(__NR_afs_syscall, sys_ni_syscall), // 137 1202//ZZ LINX_(__NR_setfsuid, sys_setfsuid16), // 138 1203//ZZ LINX_(__NR_setfsgid, sys_setfsgid16), // 139 1204//ZZ 1205//ZZ LINXY(__NR__llseek, sys_llseek), // 140 1206//ZZ GENXY(__NR_getdents, sys_getdents), // 141 1207//ZZ GENX_(__NR__newselect, sys_select), // 142 1208//ZZ 1209//ZZ LINXY(__NR__sysctl, sys_sysctl), // 149 1210//ZZ 1211//ZZ GENX_(__NR_munlock, sys_munlock), // 151 1212//ZZ LINX_(__NR_munlockall, sys_munlockall), // 153 1213//ZZ LINXY(__NR_sched_setparam, sys_sched_setparam), // 154 1214//ZZ 1215//ZZ LINXY(__NR_sched_getparam, sys_sched_getparam), // 155 1216//ZZ LINX_(__NR_sched_setscheduler, sys_sched_setscheduler), // 156 1217//ZZ LINX_(__NR_sched_getscheduler, sys_sched_getscheduler), // 157 1218//ZZ LINX_(__NR_sched_get_priority_max, sys_sched_get_priority_max),// 159 1219//ZZ 1220//ZZ LINX_(__NR_sched_get_priority_min, sys_sched_get_priority_min),// 160 1221//ZZ //zz //LINX?(__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 161 */* 1222//ZZ LINX_(__NR_setresuid, sys_setresuid16), // 164 1223//ZZ 1224//ZZ LINXY(__NR_getresuid, sys_getresuid16), // 165 1225//ZZ // PLAXY(__NR_vm86, sys_vm86), // 166 x86/Linux-only 1226//ZZ // GENX_(__NR_query_module, sys_ni_syscall), // 167 1227//ZZ GENXY(__NR_poll, sys_poll), // 168 1228//ZZ //zz // (__NR_nfsservctl, sys_nfsservctl), // 169 */Linux 1229//ZZ //zz 1230//ZZ LINX_(__NR_setresgid, sys_setresgid16), // 170 1231//ZZ LINXY(__NR_getresgid, sys_getresgid16), // 171 1232//ZZ LINXY(__NR_prctl, sys_prctl), // 172 1233//ZZ LINXY(__NR_rt_sigaction, sys_rt_sigaction), // 174 1234//ZZ 1235//ZZ LINXY(__NR_rt_sigtimedwait, sys_rt_sigtimedwait),// 177 1236//ZZ 1237//ZZ LINX_(__NR_chown, sys_chown16), // 182 1238//ZZ 1239//ZZ LINX_(__NR_capset, sys_capset), // 185 1240//ZZ LINXY(__NR_sendfile, sys_sendfile), // 187 1241//ZZ // GENXY(__NR_getpmsg, sys_getpmsg), // 188 1242//ZZ // GENX_(__NR_putpmsg, sys_putpmsg), // 189 1243//ZZ 1244//ZZ // Nb: we treat vfork as fork 1245//ZZ GENX_(__NR_vfork, sys_fork), // 190 1246//ZZ GENXY(__NR_ugetrlimit, sys_getrlimit), // 191 1247//ZZ GENX_(__NR_truncate64, sys_truncate64), // 193 1248//ZZ GENX_(__NR_ftruncate64, sys_ftruncate64), // 194 1249//ZZ 1250//ZZ PLAXY(__NR_stat64, sys_stat64), // 195 1251//ZZ PLAXY(__NR_lstat64, sys_lstat64), // 196 1252//ZZ PLAXY(__NR_fstat64, sys_fstat64), // 197 1253//ZZ GENX_(__NR_lchown32, sys_lchown), // 198 1254//ZZ GENX_(__NR_getuid32, sys_getuid), // 199 1255//ZZ 1256//ZZ GENX_(__NR_getgid32, sys_getgid), // 200 1257//ZZ GENX_(__NR_geteuid32, sys_geteuid), // 201 1258//ZZ GENX_(__NR_getegid32, sys_getegid), // 202 1259//ZZ GENX_(__NR_setreuid32, sys_setreuid), // 203 1260//ZZ GENX_(__NR_setregid32, sys_setregid), // 204 1261//ZZ 1262//ZZ LINX_(__NR_setresuid32, sys_setresuid), // 208 1263//ZZ LINXY(__NR_getresuid32, sys_getresuid), // 209 1264//ZZ 1265//ZZ LINX_(__NR_setresgid32, sys_setresgid), // 210 1266//ZZ LINXY(__NR_getresgid32, sys_getresgid), // 211 1267//ZZ GENX_(__NR_chown32, sys_chown), // 212 1268//ZZ GENX_(__NR_setuid32, sys_setuid), // 213 1269//ZZ GENX_(__NR_setgid32, sys_setgid), // 214 1270//ZZ 1271//ZZ LINX_(__NR_setfsuid32, sys_setfsuid), // 215 1272//ZZ LINX_(__NR_setfsgid32, sys_setfsgid), // 216 1273//ZZ //zz // (__NR_pivot_root, sys_pivot_root), // 217 */Linux 1274//ZZ GENXY(__NR_mincore, sys_mincore), // 218 1275//ZZ 1276//ZZ LINXY(__NR_fcntl64, sys_fcntl64), // 221 1277//ZZ // GENX_(222, sys_ni_syscall), // 222 1278//ZZ // PLAXY(223, sys_syscall223), // 223 // sys_bproc? 1279//ZZ 1280//ZZ LINXY(__NR_tkill, sys_tkill), // 238 */Linux 1281//ZZ LINXY(__NR_sendfile64, sys_sendfile64), // 239 1282//ZZ 1283//ZZ LINXY(__NR_futex, sys_futex), // 240 1284//ZZ LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 242 1285//ZZ // PLAX_(__NR_set_thread_area, sys_set_thread_area), // 243 1286//ZZ // PLAX_(__NR_get_thread_area, sys_get_thread_area), // 244 1287//ZZ 1288//ZZ LINXY(__NR_io_setup, sys_io_setup), // 245 1289//ZZ LINX_(__NR_io_destroy, sys_io_destroy), // 246 1290//ZZ LINXY(__NR_io_getevents, sys_io_getevents), // 247 1291//ZZ LINX_(__NR_io_submit, sys_io_submit), // 248 1292//ZZ LINXY(__NR_io_cancel, sys_io_cancel), // 249 1293//ZZ 1294//ZZ // LINX_(__NR_fadvise64, sys_fadvise64), // 250 */(Linux?) 1295//ZZ GENX_(251, sys_ni_syscall), // 251 1296//ZZ // GENXY(__NR_lookup_dcookie, sys_lookup_dcookie), // 253 1297//ZZ LINXY(__NR_epoll_create, sys_epoll_create), // 254 1298//ZZ 1299//ZZ LINX_(__NR_epoll_ctl, sys_epoll_ctl), // 255 1300//ZZ LINXY(__NR_epoll_wait, sys_epoll_wait), // 256 1301//ZZ //zz // (__NR_remap_file_pages, sys_remap_file_pages), // 257 */Linux 1302//ZZ LINX_(__NR_set_tid_address, sys_set_tid_address), // 258 1303//ZZ LINXY(__NR_timer_create, sys_timer_create), // 259 1304//ZZ 1305//ZZ LINXY(__NR_timer_settime, sys_timer_settime), // (timer_create+1) 1306//ZZ LINXY(__NR_timer_gettime, sys_timer_gettime), // (timer_create+2) 1307//ZZ LINX_(__NR_timer_getoverrun, sys_timer_getoverrun),//(timer_create+3) 1308//ZZ LINX_(__NR_timer_delete, sys_timer_delete), // (timer_create+4) 1309//ZZ LINX_(__NR_clock_settime, sys_clock_settime), // (timer_create+5) 1310//ZZ 1311//ZZ LINXY(__NR_clock_getres, sys_clock_getres), // (timer_create+7) 1312//ZZ LINXY(__NR_clock_nanosleep, sys_clock_nanosleep),// (timer_create+8) */* 1313//ZZ GENXY(__NR_statfs64, sys_statfs64), // 268 1314//ZZ GENXY(__NR_fstatfs64, sys_fstatfs64), // 269 1315//ZZ 1316//ZZ GENX_(__NR_utimes, sys_utimes), // 271 1317//ZZ // LINX_(__NR_fadvise64_64, sys_fadvise64_64), // 272 */(Linux?) 1318//ZZ GENX_(__NR_vserver, sys_ni_syscall), // 273 1319//ZZ LINX_(__NR_mbind, sys_mbind), // 274 ?/? 1320//ZZ 1321//ZZ LINXY(__NR_get_mempolicy, sys_get_mempolicy), // 275 ?/? 1322//ZZ LINX_(__NR_set_mempolicy, sys_set_mempolicy), // 276 ?/? 1323//ZZ 1324//ZZ LINXY(__NR_waitid, sys_waitid), // 280 1325//ZZ 1326//ZZ LINX_(__NR_send, sys_send), 1327//ZZ LINXY(__NR_recv, sys_recv), 1328//ZZ LINXY(__NR_recvfrom, sys_recvfrom), // 292 1329//ZZ LINX_(__NR_semget, sys_semget), // 299 1330//ZZ LINXY(__NR_semctl, sys_semctl), // 300 1331//ZZ 1332//ZZ LINX_(__NR_request_key, sys_request_key), // 287 1333//ZZ // LINX_(__NR_ioprio_set, sys_ioprio_set), // 289 1334//ZZ 1335//ZZ // LINX_(__NR_ioprio_get, sys_ioprio_get), // 290 1336//ZZ LINX_(__NR_inotify_init, sys_inotify_init), // 291 1337//ZZ // LINX_(__NR_migrate_pages, sys_migrate_pages), // 294 1338//ZZ 1339//ZZ LINX_(__NR_futimesat, sys_futimesat), // 326 on arm 1340//ZZ 1341//ZZ PLAXY(__NR_fstatat64, sys_fstatat64), // 300 1342//ZZ LINX_(__NR_renameat, sys_renameat), // 302 1343//ZZ LINX_(__NR_symlinkat, sys_symlinkat), // 304 1344//ZZ 1345//ZZ LINX_(__NR_shmget, sys_shmget), //307 1346//ZZ // LINX_(__NR_pselect6, sys_pselect6), // 1347//ZZ 1348//ZZ // LINX_(__NR_unshare, sys_unshare), // 310 1349//ZZ LINX_(__NR_set_robust_list, sys_set_robust_list), // 311 1350//ZZ LINXY(__NR_get_robust_list, sys_get_robust_list), // 312 1351//ZZ // LINX_(__NR_splice, sys_ni_syscall), // 313 1352//ZZ // LINX_(__NR_sync_file_range, sys_sync_file_range), // 314 1353//ZZ 1354//ZZ // LINX_(__NR_tee, sys_ni_syscall), // 315 1355//ZZ // LINX_(__NR_vmsplice, sys_ni_syscall), // 316 1356//ZZ LINXY(__NR_move_pages, sys_move_pages), // 317 1357//ZZ // LINX_(__NR_getcpu, sys_ni_syscall), // 318 1358//ZZ 1359//ZZ LINXY(__NR_signalfd, sys_signalfd), // 321 1360//ZZ LINXY(__NR_eventfd, sys_eventfd), // 323 1361//ZZ 1362//ZZ 1363//ZZ /////////////// 1364//ZZ 1365//ZZ // JRS 2010-Jan-03: I believe that all the numbers listed 1366//ZZ // in comments in the table prior to this point (eg "// 326", 1367//ZZ // etc) are bogus since it looks to me like they are copied 1368//ZZ // verbatim from syswrap-x86-linux.c and they certainly do not 1369//ZZ // correspond to what's in include/vki/vki-scnums-arm-linux.h. 1370//ZZ // From here onwards, please ensure the numbers are correct. 1371//ZZ 1372//ZZ 1373//ZZ LINXY(__NR_epoll_pwait, sys_epoll_pwait), // 346 1374//ZZ 1375//ZZ 1376//ZZ LINXY(__NR_eventfd2, sys_eventfd2), // 356 1377//ZZ LINXY(__NR_epoll_create1, sys_epoll_create1), // 357 1378//ZZ LINXY(__NR_preadv, sys_preadv), // 361 1379//ZZ LINX_(__NR_pwritev, sys_pwritev), // 362 1380//ZZ LINXY(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo),// 363 1381//ZZ LINXY(__NR_perf_event_open, sys_perf_event_open), // 364 1382//ZZ 1383//ZZ LINXY(__NR_name_to_handle_at, sys_name_to_handle_at),// 370 1384//ZZ LINXY(__NR_open_by_handle_at, sys_open_by_handle_at),// 371 1385//ZZ LINXY(__NR_clock_adjtime, sys_clock_adjtime) // 372 1386}; 1387 1388 1389//ZZ /* These are not in the main table because there indexes are not small 1390//ZZ integers, but rather values close to one million. So their 1391//ZZ inclusion would force the main table to be huge (about 8 MB). */ 1392//ZZ 1393//ZZ static SyscallTableEntry ste___ARM_set_tls 1394//ZZ = { WRAPPER_PRE_NAME(arm_linux,sys_set_tls), NULL }; 1395//ZZ 1396//ZZ static SyscallTableEntry ste___ARM_cacheflush 1397//ZZ = { WRAPPER_PRE_NAME(arm_linux,sys_cacheflush), NULL }; 1398 1399SyscallTableEntry* ML_(get_linux_syscall_entry) ( UInt sysno ) 1400{ 1401 const UInt syscall_main_table_size 1402 = sizeof(syscall_main_table) / sizeof(syscall_main_table[0]); 1403 1404 /* Is it in the contiguous initial section of the table? */ 1405 if (sysno < syscall_main_table_size) { 1406 SyscallTableEntry* sys = &syscall_main_table[sysno]; 1407 if (sys->before == NULL) 1408 return NULL; /* no entry */ 1409 else 1410 return sys; 1411 } 1412 1413//ZZ /* Check if it's one of the out-of-line entries. */ 1414//ZZ switch (sysno) { 1415//ZZ case __NR_ARM_set_tls: return &ste___ARM_set_tls; 1416//ZZ case __NR_ARM_cacheflush: return &ste___ARM_cacheflush; 1417//ZZ default: break; 1418//ZZ } 1419 1420 /* Can't find a wrapper */ 1421 return NULL; 1422} 1423 1424#endif // defined(VGP_arm64_linux) 1425 1426/*--------------------------------------------------------------------*/ 1427/*--- end syswrap-arm64-linux.c ---*/ 1428/*--------------------------------------------------------------------*/ 1429