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-2013 OpenWorks 11 info (at) 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 extern 142 Long 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 ); 149 asm( 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 195 static void setup_child ( ThreadArchState*, ThreadArchState* ); 196 static 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 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 */ 209 static 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 320 void VG_(cleanup_thread) ( ThreadArchState* arch ) 321 { 322 } 323 324 void 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 332 static 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 394 DECL_TEMPLATE(arm64_linux, sys_fadvise64); 395 DECL_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); 400 DECL_TEMPLATE(arm64_linux, sys_clone); 401 //ZZ DECL_TEMPLATE(arm_linux, sys_sigreturn); 402 DECL_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? 432 PRE(sys_fadvise64) 433 { 434 PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", ARG1,ARG2,ARG3,ARG4); 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? 440 PRE(sys_mmap) 441 { 442 SysRes r; 443 444 PRINT("sys_mmap ( %#lx, %llu, %ld, %ld, %d, %ld )", 445 ARG1, (ULong)ARG2, ARG3, ARG4, (Int)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 */ 525 PRE(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 642 PRE(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 857 static SyscallTableEntry syscall_main_table[] = { 858 LINXY(__NR_getxattr, sys_getxattr), // 8 859 LINXY(__NR_lgetxattr, sys_lgetxattr), // 9 860 GENXY(__NR_getcwd, sys_getcwd), // 17 861 LINXY(__NR_eventfd2, sys_eventfd2), // 19 862 LINXY(__NR_epoll_create1, sys_epoll_create1), // 20 863 LINX_(__NR_epoll_ctl, sys_epoll_ctl), // 21 864 LINXY(__NR_epoll_pwait, sys_epoll_pwait), // 22 865 GENXY(__NR_dup, sys_dup), // 23 866 LINXY(__NR_dup3, sys_dup3), // 24 867 868 // FIXME IS THIS CORRECT? 869 LINXY(__NR3264_fcntl, sys_fcntl), // 25 870 871 LINXY(__NR_inotify_init1, sys_inotify_init1), // 26 872 LINX_(__NR_inotify_add_watch, sys_inotify_add_watch), // 27 873 LINX_(__NR_inotify_rm_watch, sys_inotify_rm_watch), // 28 874 LINXY(__NR_ioctl, sys_ioctl), // 29 875 GENX_(__NR_flock, sys_flock), // 32 876 LINX_(__NR_mknodat, sys_mknodat), // 33 877 LINX_(__NR_mkdirat, sys_mkdirat), // 34 878 LINX_(__NR_unlinkat, sys_unlinkat), // 35 879 LINX_(__NR_symlinkat, sys_symlinkat), // 36 880 LINX_(__NR_linkat, sys_linkat), // 37 881 LINX_(__NR_renameat, sys_renameat), // 38 882 883 LINX_(__NR_umount2, sys_umount), // 39 884 LINX_(__NR_mount, sys_mount), // 40 885 886 // FIXME IS THIS CORRECT? it may well not be. 887 GENXY(__NR3264_statfs, sys_statfs), // 43 888 GENXY(__NR3264_fstatfs, sys_fstatfs), // 44 889 890 // FIXME IS THIS CORRECT? it may well not be. 891 GENX_(__NR3264_ftruncate, sys_ftruncate), // 46 892 893 LINX_(__NR_fallocate, sys_fallocate), // 47 894 LINX_(__NR_faccessat, sys_faccessat), // 48 895 GENX_(__NR_chdir, sys_chdir), // 49 896 GENX_(__NR_fchdir, sys_fchdir), // 50 897 GENX_(__NR_chroot, sys_chroot), // 51 898 GENX_(__NR_fchmod, sys_fchmod), // 52 899 LINX_(__NR_fchmodat, sys_fchmodat), // 53 900 LINX_(__NR_fchownat, sys_fchownat), // 54 901 GENX_(__NR_fchown, sys_fchown), // 55 902 LINXY(__NR_openat, sys_openat), // 56 903 GENXY(__NR_close, sys_close), // 57 904 LINXY(__NR_pipe2, sys_pipe2), // 59 905 LINX_(__NR_quotactl, sys_quotactl), // 60 906 GENXY(__NR_getdents64, sys_getdents64), // 61 907 908 // FIXME IS THIS CORRECT? 909 LINX_(__NR3264_lseek, sys_lseek), // 62 910 911 GENXY(__NR_read, sys_read), // 63 912 GENX_(__NR_write, sys_write), // 64 913 GENXY(__NR_readv, sys_readv), // 65 914 GENX_(__NR_writev, sys_writev), // 66 915 GENXY(__NR_pread64, sys_pread64), // 67 916 GENX_(__NR_pwrite64, sys_pwrite64), // 68 917 LINX_(__NR_pselect6, sys_pselect6), // 72 918 LINXY(__NR_ppoll, sys_ppoll), // 73 919 LINXY(__NR_signalfd4, sys_signalfd4), // 74 920 LINX_(__NR_readlinkat, sys_readlinkat), // 78 921 922 // FIXME IS THIS CORRECT? 923 LINXY(__NR3264_fstatat, sys_newfstatat), // 79 924 GENXY(__NR3264_fstat, sys_newfstat), // 80 925 926 LINX_(__NR_utimensat, sys_utimensat), // 88 927 GENX_(__NR_fsync, sys_fsync), // 82 928 GENX_(__NR_fdatasync, sys_fdatasync), // 83 929 LINXY(__NR_timerfd_create, sys_timerfd_create), // 85 930 LINXY(__NR_timerfd_settime, sys_timerfd_settime), // 86 931 LINXY(__NR_timerfd_gettime, sys_timerfd_gettime), // 87 932 LINXY(__NR_capget, sys_capget), // 90 933 GENX_(__NR_exit, sys_exit), // 93 934 LINX_(__NR_exit_group, sys_exit_group), // 94 935 LINX_(__NR_set_tid_address, sys_set_tid_address), // 96 936 LINXY(__NR_futex, sys_futex), // 98 937 LINX_(__NR_set_robust_list, sys_set_robust_list), // 99 938 GENXY(__NR_nanosleep, sys_nanosleep), // 101 939 GENXY(__NR_setitimer, sys_setitimer), // 103 940 LINXY(__NR_clock_gettime, sys_clock_gettime), // 113 941 LINXY(__NR_clock_getres, sys_clock_getres), // 114 942 LINXY(__NR_syslog, sys_syslog), // 116 943 LINX_(__NR_sched_setaffinity, sys_sched_setaffinity), // 122 944 LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 123 945 LINX_(__NR_sched_yield, sys_sched_yield), // 124 946 GENX_(__NR_kill, sys_kill), // 129 947 LINX_(__NR_tgkill, sys_tgkill), // 131 948 GENXY(__NR_sigaltstack, sys_sigaltstack), // 132 949 LINX_(__NR_rt_sigsuspend, sys_rt_sigsuspend), // 133 950 LINXY(__NR_rt_sigaction, sys_rt_sigaction), // 134 951 LINXY(__NR_rt_sigprocmask, sys_rt_sigprocmask), // 135 952 LINXY(__NR_rt_sigtimedwait, sys_rt_sigtimedwait), // 137 953 LINXY(__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo), // 138 954 PLAX_(__NR_rt_sigreturn, sys_rt_sigreturn), // 139 955 GENX_(__NR_setpriority, sys_setpriority), // 140 956 GENX_(__NR_getpriority, sys_getpriority), // 141 957 GENX_(__NR_setregid, sys_setregid), // 143 958 GENX_(__NR_setgid, sys_setgid), // 144 959 GENX_(__NR_setreuid, sys_setreuid), // 145 960 LINX_(__NR_setresuid, sys_setresuid), // 147 961 LINXY(__NR_getresuid, sys_getresuid), // 148 962 LINXY(__NR_getresgid, sys_getresgid), // 150 963 GENXY(__NR_times, sys_times), // 153 964 GENX_(__NR_setpgid, sys_setpgid), // 154 965 GENX_(__NR_getpgid, sys_getpgid), // 155 966 GENX_(__NR_getsid, sys_getsid), // 156 967 GENX_(__NR_setsid, sys_setsid), // 157 968 GENXY(__NR_getgroups, sys_getgroups), // 158 969 GENX_(__NR_setgroups, sys_setgroups), // 159 970 GENXY(__NR_uname, sys_newuname), // 160 971 GENXY(__NR_getrlimit, sys_old_getrlimit), // 163 972 GENX_(__NR_setrlimit, sys_setrlimit), // 164 973 GENXY(__NR_getrusage, sys_getrusage), // 165 974 GENX_(__NR_umask, sys_umask), // 166 975 LINXY(__NR_prctl, sys_prctl), // 167 976 GENXY(__NR_gettimeofday, sys_gettimeofday), // 169 977 GENX_(__NR_getpid, sys_getpid), // 172 978 GENX_(__NR_getppid, sys_getppid), // 173 979 GENX_(__NR_getuid, sys_getuid), // 174 980 GENX_(__NR_geteuid, sys_geteuid), // 175 981 GENX_(__NR_getgid, sys_getgid), // 176 982 GENX_(__NR_getegid, sys_getegid), // 177 983 LINX_(__NR_gettid, sys_gettid), // 178 984 LINXY(__NR_sysinfo, sys_sysinfo), // 179 985 LINXY(__NR_mq_open, sys_mq_open), // 180 986 LINX_(__NR_mq_unlink, sys_mq_unlink), // 181 987 LINX_(__NR_mq_timedsend, sys_mq_timedsend), // 182 988 LINXY(__NR_mq_timedreceive, sys_mq_timedreceive), // 183 989 LINX_(__NR_mq_notify, sys_mq_notify), // 184 990 LINXY(__NR_mq_getsetattr, sys_mq_getsetattr), // 185 991 LINX_(__NR_msgget, sys_msgget), // 186 992 LINXY(__NR_msgctl, sys_msgctl), // 187 993 LINXY(__NR_msgrcv, sys_msgrcv), // 188 994 LINX_(__NR_msgsnd, sys_msgsnd), // 189 995 LINX_(__NR_semget, sys_semget), // 190 996 LINXY(__NR_semctl, sys_semctl), // 191 997 LINX_(__NR_semtimedop, sys_semtimedop), // 192 998 LINX_(__NR_semop, sys_semop), // 193 999 LINX_(__NR_shmget, sys_shmget), // 194 1000 LINXY(__NR_shmctl, sys_shmctl), // 195 1001 LINXY(__NR_shmat, wrap_sys_shmat), // 196 1002 LINXY(__NR_shmdt, sys_shmdt), // 197 1003 LINXY(__NR_socket, sys_socket), // 198 1004 LINXY(__NR_socketpair, sys_socketpair), // 199 1005 LINX_(__NR_bind, sys_bind), // 200 1006 LINX_(__NR_listen, sys_listen), // 201 1007 LINXY(__NR_accept, sys_accept), // 202 1008 LINX_(__NR_connect, sys_connect), // 203 1009 LINXY(__NR_getsockname, sys_getsockname), // 204 1010 LINXY(__NR_getpeername, sys_getpeername), // 205 1011 LINX_(__NR_sendto, sys_sendto), // 206 1012 LINXY(__NR_recvfrom, sys_recvfrom), // 207 1013 LINX_(__NR_setsockopt, sys_setsockopt), // 208 1014 LINXY(__NR_getsockopt, sys_getsockopt), // 209 1015 LINX_(__NR_shutdown, sys_shutdown), // 210 1016 LINX_(__NR_sendmsg, sys_sendmsg), // 211 1017 LINXY(__NR_recvmsg, sys_recvmsg), // 212 1018 LINX_(__NR_readahead, sys_readahead), // 213 1019 GENX_(__NR_brk, sys_brk), // 214 1020 GENXY(__NR_munmap, sys_munmap), // 215 1021 GENX_(__NR_mremap, sys_mremap), // 216 1022 LINX_(__NR_add_key, sys_add_key), // 217 1023 LINXY(__NR_keyctl, sys_keyctl), // 219 1024 PLAX_(__NR_clone, sys_clone), // 220 1025 GENX_(__NR_execve, sys_execve), // 221 1026 1027 // FIXME IS THIS CORRECT? 1028 PLAX_(__NR3264_mmap, sys_mmap), // 222 1029 PLAX_(__NR3264_fadvise64, sys_fadvise64), // 223 1030 1031 GENXY(__NR_mprotect, sys_mprotect), // 226 1032 GENX_(__NR_msync, sys_msync), // 227 1033 GENX_(__NR_mlock, sys_mlock), // 228 1034 GENX_(__NR_mlockall, sys_mlockall), // 230 1035 GENX_(__NR_madvise, sys_madvise), // 233 1036 LINX_(__NR_mbind, sys_mbind), // 235 1037 LINXY(__NR_get_mempolicy, sys_get_mempolicy), // 236 1038 LINX_(__NR_set_mempolicy, sys_set_mempolicy), // 237 1039 1040 LINXY(__NR_recvmmsg, sys_recvmmsg), // 243 1041 LINXY(__NR_accept4, sys_accept4), // 242 1042 1043 GENXY(__NR_wait4, sys_wait4), // 260 1044 1045 LINX_(__NR_syncfs, sys_syncfs), // 267 1046 1047 LINXY(__NR_sendmmsg, sys_sendmmsg), // 269 1048 LINXY(__NR_process_vm_readv, sys_process_vm_readv), // 270 1049 LINX_(__NR_process_vm_writev, sys_process_vm_writev), // 271 1050 LINXY(__NR_getrandom, sys_getrandom), // 278 1051 LINXY(__NR_memfd_create, sys_memfd_create), // 279 1052 1053 // The numbers below are bogus. (See comment further down.) 1054 // When pulling entries above this line, change the numbers 1055 // to be correct. 1056 1057 //ZZ //zz // (restart_syscall) // 0 1058 //ZZ GENX_(__NR_fork, sys_fork), // 2 1059 //ZZ 1060 //ZZ GENXY(__NR_open, sys_open), // 5 1061 //ZZ // GENXY(__NR_waitpid, sys_waitpid), // 7 1062 //ZZ GENXY(__NR_creat, sys_creat), // 8 1063 //ZZ GENX_(__NR_link, sys_link), // 9 1064 //ZZ 1065 //ZZ GENX_(__NR_unlink, sys_unlink), // 10 1066 //ZZ GENXY(__NR_time, sys_time), // 13 1067 //ZZ GENX_(__NR_mknod, sys_mknod), // 14 1068 //ZZ 1069 //ZZ GENX_(__NR_chmod, sys_chmod), // 15 1070 //ZZ //zz LINX_(__NR_lchown, sys_lchown16), // 16 1071 //ZZ // GENX_(__NR_break, sys_ni_syscall), // 17 1072 //ZZ //zz // (__NR_oldstat, sys_stat), // 18 (obsolete) 1073 //ZZ LINX_(__NR_lseek, sys_lseek), // 19 1074 //ZZ 1075 //ZZ GENX_(__NR_getpid, sys_getpid), // 20 1076 //ZZ LINX_(__NR_umount, sys_oldumount), // 22 1077 //ZZ LINX_(__NR_setuid, sys_setuid16), // 23 ## P 1078 //ZZ LINX_(__NR_getuid, sys_getuid16), // 24 ## P 1079 //ZZ //zz 1080 //ZZ //zz // (__NR_stime, sys_stime), // 25 * (SVr4,SVID,X/OPEN) 1081 //ZZ PLAXY(__NR_ptrace, sys_ptrace), // 26 1082 //ZZ GENX_(__NR_alarm, sys_alarm), // 27 1083 //ZZ //zz // (__NR_oldfstat, sys_fstat), // 28 * L -- obsolete 1084 //ZZ GENX_(__NR_pause, sys_pause), // 29 1085 //ZZ 1086 //ZZ LINX_(__NR_utime, sys_utime), // 30 1087 //ZZ // GENX_(__NR_stty, sys_ni_syscall), // 31 1088 //ZZ // GENX_(__NR_gtty, sys_ni_syscall), // 32 1089 //ZZ GENX_(__NR_access, sys_access), // 33 1090 //ZZ GENX_(__NR_nice, sys_nice), // 34 1091 //ZZ 1092 //ZZ // GENX_(__NR_ftime, sys_ni_syscall), // 35 1093 //ZZ GENX_(__NR_sync, sys_sync), // 36 1094 //ZZ GENX_(__NR_rename, sys_rename), // 38 1095 //ZZ GENX_(__NR_mkdir, sys_mkdir), // 39 1096 //ZZ 1097 //ZZ GENX_(__NR_rmdir, sys_rmdir), // 40 1098 //ZZ LINXY(__NR_pipe, sys_pipe), // 42 1099 //ZZ // GENX_(__NR_prof, sys_ni_syscall), // 44 1100 1101 //ZZ LINX_(__NR_getgid, sys_getgid16), // 47 1102 //ZZ //zz // (__NR_signal, sys_signal), // 48 */* (ANSI C) 1103 //ZZ LINX_(__NR_geteuid, sys_geteuid16), // 49 1104 //ZZ 1105 //ZZ LINX_(__NR_getegid, sys_getegid16), // 50 1106 //ZZ GENX_(__NR_acct, sys_acct), // 51 1107 //ZZ // GENX_(__NR_lock, sys_ni_syscall), // 53 1108 //ZZ 1109 //ZZ LINXY(__NR_fcntl, sys_fcntl), // 55 1110 //ZZ // GENX_(__NR_mpx, sys_ni_syscall), // 56 1111 //ZZ // GENX_(__NR_ulimit, sys_ni_syscall), // 58 1112 //ZZ //zz // (__NR_oldolduname, sys_olduname), // 59 Linux -- obsolete 1113 //ZZ //zz 1114 //ZZ //zz // (__NR_ustat, sys_ustat) // 62 SVr4 -- deprecated 1115 //ZZ GENXY(__NR_dup2, sys_dup2), // 63 1116 //ZZ GENX_(__NR_getppid, sys_getppid), // 64 1117 //ZZ 1118 //ZZ GENX_(__NR_getpgrp, sys_getpgrp), // 65 1119 //ZZ LINXY(__NR_sigaction, sys_sigaction), // 67 1120 //ZZ //zz // (__NR_sgetmask, sys_sgetmask), // 68 */* (ANSI C) 1121 //ZZ //zz // (__NR_ssetmask, sys_ssetmask), // 69 */* (ANSI C) 1122 //ZZ //zz 1123 //ZZ PLAX_(__NR_sigsuspend, sys_sigsuspend), // 72 1124 //ZZ LINXY(__NR_sigpending, sys_sigpending), // 73 1125 //ZZ //zz // (__NR_sethostname, sys_sethostname), // 74 */* 1126 //ZZ //zz 1127 //ZZ GENXY(__NR_getrlimit, sys_old_getrlimit), // 76 1128 //ZZ GENX_(__NR_settimeofday, sys_settimeofday), // 79 1129 //ZZ 1130 //ZZ LINXY(__NR_getgroups, sys_getgroups16), // 80 1131 //ZZ LINX_(__NR_setgroups, sys_setgroups16), // 81 1132 //ZZ // PLAX_(__NR_select, old_select), // 82 1133 //ZZ GENX_(__NR_symlink, sys_symlink), // 83 1134 //ZZ //zz // (__NR_oldlstat, sys_lstat), // 84 -- obsolete 1135 //ZZ //zz 1136 //ZZ GENX_(__NR_readlink, sys_readlink), // 85 1137 //ZZ //zz // (__NR_uselib, sys_uselib), // 86 */Linux 1138 //ZZ //zz // (__NR_swapon, sys_swapon), // 87 */Linux 1139 //ZZ //zz // (__NR_reboot, sys_reboot), // 88 */Linux 1140 //ZZ //zz // (__NR_readdir, old_readdir), // 89 -- superseded 1141 //ZZ //zz 1142 //ZZ // _____(__NR_mmap, old_mmap), // 90 1143 //ZZ GENXY(__NR_munmap, sys_munmap), // 91 1144 //ZZ GENX_(__NR_truncate, sys_truncate), // 92 1145 //ZZ GENX_(__NR_ftruncate, sys_ftruncate), // 93 1146 //ZZ 1147 //ZZ LINX_(__NR_fchown, sys_fchown16), // 95 1148 //ZZ // GENX_(__NR_profil, sys_ni_syscall), // 98 1149 //ZZ GENXY(__NR_statfs, sys_statfs), // 99 1150 //ZZ 1151 //ZZ GENXY(__NR_fstatfs, sys_fstatfs), // 100 1152 //ZZ // LINX_(__NR_ioperm, sys_ioperm), // 101 1153 //ZZ LINXY(__NR_socketcall, sys_socketcall), // 102 1154 //ZZ 1155 //ZZ GENXY(__NR_getitimer, sys_getitimer), // 105 1156 //ZZ GENXY(__NR_stat, sys_newstat), // 106 1157 //ZZ GENXY(__NR_lstat, sys_newlstat), // 107 1158 //ZZ GENXY(__NR_fstat, sys_newfstat), // 108 1159 //ZZ //zz // (__NR_olduname, sys_uname), // 109 -- obsolete 1160 //ZZ //zz 1161 //ZZ // GENX_(__NR_iopl, sys_iopl), // 110 1162 //ZZ LINX_(__NR_vhangup, sys_vhangup), // 111 1163 //ZZ // GENX_(__NR_idle, sys_ni_syscall), // 112 1164 //ZZ // PLAXY(__NR_vm86old, sys_vm86old), // 113 __NR_syscall... weird 1165 //ZZ //zz 1166 //ZZ //zz // (__NR_swapoff, sys_swapoff), // 115 */Linux 1167 //ZZ // _____(__NR_ipc, sys_ipc), // 117 1168 //ZZ GENX_(__NR_fsync, sys_fsync), // 118 1169 //ZZ PLAX_(__NR_sigreturn, sys_sigreturn), // 119 ?/Linux 1170 //ZZ 1171 //ZZ //zz // (__NR_setdomainname, sys_setdomainname), // 121 */*(?) 1172 //ZZ // PLAX_(__NR_modify_ldt, sys_modify_ldt), // 123 1173 //ZZ //zz LINXY(__NR_adjtimex, sys_adjtimex), // 124 1174 //ZZ //zz 1175 //ZZ LINXY(__NR_sigprocmask, sys_sigprocmask), // 126 1176 //ZZ //zz // Nb: create_module() was removed 2.4-->2.6 1177 //ZZ // GENX_(__NR_create_module, sys_ni_syscall), // 127 1178 //ZZ LINX_(__NR_init_module, sys_init_module), // 128 1179 //ZZ LINX_(__NR_delete_module, sys_delete_module), // 129 1180 //ZZ //zz 1181 //ZZ //zz // Nb: get_kernel_syms() was removed 2.4-->2.6 1182 //ZZ // GENX_(__NR_get_kernel_syms, sys_ni_syscall), // 130 1183 //ZZ GENX_(__NR_getpgid, sys_getpgid), // 132 1184 //ZZ //zz // (__NR_bdflush, sys_bdflush), // 134 */Linux 1185 //ZZ //zz 1186 //ZZ //zz // (__NR_sysfs, sys_sysfs), // 135 SVr4 1187 //ZZ LINX_(__NR_personality, sys_personality), // 136 1188 //ZZ // GENX_(__NR_afs_syscall, sys_ni_syscall), // 137 1189 //ZZ LINX_(__NR_setfsuid, sys_setfsuid16), // 138 1190 //ZZ LINX_(__NR_setfsgid, sys_setfsgid16), // 139 1191 //ZZ 1192 //ZZ LINXY(__NR__llseek, sys_llseek), // 140 1193 //ZZ GENXY(__NR_getdents, sys_getdents), // 141 1194 //ZZ GENX_(__NR__newselect, sys_select), // 142 1195 //ZZ 1196 //ZZ LINXY(__NR__sysctl, sys_sysctl), // 149 1197 //ZZ 1198 //ZZ GENX_(__NR_munlock, sys_munlock), // 151 1199 //ZZ LINX_(__NR_munlockall, sys_munlockall), // 153 1200 //ZZ LINXY(__NR_sched_setparam, sys_sched_setparam), // 154 1201 //ZZ 1202 //ZZ LINXY(__NR_sched_getparam, sys_sched_getparam), // 155 1203 //ZZ LINX_(__NR_sched_setscheduler, sys_sched_setscheduler), // 156 1204 //ZZ LINX_(__NR_sched_getscheduler, sys_sched_getscheduler), // 157 1205 //ZZ LINX_(__NR_sched_get_priority_max, sys_sched_get_priority_max),// 159 1206 //ZZ 1207 //ZZ LINX_(__NR_sched_get_priority_min, sys_sched_get_priority_min),// 160 1208 //ZZ //zz //LINX?(__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 161 */* 1209 //ZZ LINX_(__NR_setresuid, sys_setresuid16), // 164 1210 //ZZ 1211 //ZZ LINXY(__NR_getresuid, sys_getresuid16), // 165 1212 //ZZ // PLAXY(__NR_vm86, sys_vm86), // 166 x86/Linux-only 1213 //ZZ // GENX_(__NR_query_module, sys_ni_syscall), // 167 1214 //ZZ GENXY(__NR_poll, sys_poll), // 168 1215 //ZZ //zz // (__NR_nfsservctl, sys_nfsservctl), // 169 */Linux 1216 //ZZ //zz 1217 //ZZ LINX_(__NR_setresgid, sys_setresgid16), // 170 1218 //ZZ LINXY(__NR_getresgid, sys_getresgid16), // 171 1219 //ZZ LINXY(__NR_prctl, sys_prctl), // 172 1220 //ZZ LINXY(__NR_rt_sigaction, sys_rt_sigaction), // 174 1221 //ZZ 1222 //ZZ LINXY(__NR_rt_sigpending, sys_rt_sigpending), // 176 1223 //ZZ LINXY(__NR_rt_sigtimedwait, sys_rt_sigtimedwait),// 177 1224 //ZZ 1225 //ZZ LINX_(__NR_chown, sys_chown16), // 182 1226 //ZZ 1227 //ZZ LINX_(__NR_capset, sys_capset), // 185 1228 //ZZ LINXY(__NR_sendfile, sys_sendfile), // 187 1229 //ZZ // GENXY(__NR_getpmsg, sys_getpmsg), // 188 1230 //ZZ // GENX_(__NR_putpmsg, sys_putpmsg), // 189 1231 //ZZ 1232 //ZZ // Nb: we treat vfork as fork 1233 //ZZ GENX_(__NR_vfork, sys_fork), // 190 1234 //ZZ GENXY(__NR_ugetrlimit, sys_getrlimit), // 191 1235 //ZZ GENX_(__NR_truncate64, sys_truncate64), // 193 1236 //ZZ GENX_(__NR_ftruncate64, sys_ftruncate64), // 194 1237 //ZZ 1238 //ZZ PLAXY(__NR_stat64, sys_stat64), // 195 1239 //ZZ PLAXY(__NR_lstat64, sys_lstat64), // 196 1240 //ZZ PLAXY(__NR_fstat64, sys_fstat64), // 197 1241 //ZZ GENX_(__NR_lchown32, sys_lchown), // 198 1242 //ZZ GENX_(__NR_getuid32, sys_getuid), // 199 1243 //ZZ 1244 //ZZ GENX_(__NR_getgid32, sys_getgid), // 200 1245 //ZZ GENX_(__NR_geteuid32, sys_geteuid), // 201 1246 //ZZ GENX_(__NR_getegid32, sys_getegid), // 202 1247 //ZZ GENX_(__NR_setreuid32, sys_setreuid), // 203 1248 //ZZ GENX_(__NR_setregid32, sys_setregid), // 204 1249 //ZZ 1250 //ZZ LINX_(__NR_setresuid32, sys_setresuid), // 208 1251 //ZZ LINXY(__NR_getresuid32, sys_getresuid), // 209 1252 //ZZ 1253 //ZZ LINX_(__NR_setresgid32, sys_setresgid), // 210 1254 //ZZ LINXY(__NR_getresgid32, sys_getresgid), // 211 1255 //ZZ GENX_(__NR_chown32, sys_chown), // 212 1256 //ZZ GENX_(__NR_setuid32, sys_setuid), // 213 1257 //ZZ GENX_(__NR_setgid32, sys_setgid), // 214 1258 //ZZ 1259 //ZZ LINX_(__NR_setfsuid32, sys_setfsuid), // 215 1260 //ZZ LINX_(__NR_setfsgid32, sys_setfsgid), // 216 1261 //ZZ //zz // (__NR_pivot_root, sys_pivot_root), // 217 */Linux 1262 //ZZ GENXY(__NR_mincore, sys_mincore), // 218 1263 //ZZ 1264 //ZZ LINXY(__NR_fcntl64, sys_fcntl64), // 221 1265 //ZZ // GENX_(222, sys_ni_syscall), // 222 1266 //ZZ // PLAXY(223, sys_syscall223), // 223 // sys_bproc? 1267 //ZZ 1268 //ZZ LINX_(__NR_setxattr, sys_setxattr), // 226 1269 //ZZ LINX_(__NR_lsetxattr, sys_lsetxattr), // 227 1270 //ZZ LINX_(__NR_fsetxattr, sys_fsetxattr), // 228 1271 //ZZ 1272 //ZZ LINXY(__NR_fgetxattr, sys_fgetxattr), // 231 1273 //ZZ LINXY(__NR_listxattr, sys_listxattr), // 232 1274 //ZZ LINXY(__NR_llistxattr, sys_llistxattr), // 233 1275 //ZZ LINXY(__NR_flistxattr, sys_flistxattr), // 234 1276 //ZZ 1277 //ZZ LINX_(__NR_removexattr, sys_removexattr), // 235 1278 //ZZ LINX_(__NR_lremovexattr, sys_lremovexattr), // 236 1279 //ZZ LINX_(__NR_fremovexattr, sys_fremovexattr), // 237 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 1399 SyscallTableEntry* 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
