1 2 /*--------------------------------------------------------------------*/ 3 /*--- Platform-specific syscalls stuff. syswrap-ppc64-linux.c ---*/ 4 /*--------------------------------------------------------------------*/ 5 6 /* 7 This file is part of Valgrind, a dynamic binary instrumentation 8 framework. 9 10 Copyright (C) 2005-2013 Nicholas Nethercote <njn (at) valgrind.org> 11 Copyright (C) 2005-2013 Cerion Armour-Brown <cerion (at) open-works.co.uk> 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_ppc64_linux) 32 33 #include "pub_core_basics.h" 34 #include "pub_core_vki.h" 35 #include "pub_core_vkiscnums.h" 36 #include "pub_core_libcsetjmp.h" // to keep _threadstate.h happy 37 #include "pub_core_threadstate.h" 38 #include "pub_core_aspacemgr.h" 39 #include "pub_core_debuglog.h" 40 #include "pub_core_libcbase.h" 41 #include "pub_core_libcassert.h" 42 #include "pub_core_libcprint.h" 43 #include "pub_core_libcproc.h" 44 #include "pub_core_libcsignal.h" 45 #include "pub_core_options.h" 46 #include "pub_core_scheduler.h" 47 #include "pub_core_sigframe.h" // For VG_(sigframe_destroy)() 48 #include "pub_core_signals.h" 49 #include "pub_core_syscall.h" 50 #include "pub_core_syswrap.h" 51 #include "pub_core_tooliface.h" 52 #include "pub_core_stacks.h" // VG_(register_stack) 53 54 #include "priv_types_n_macros.h" 55 #include "priv_syswrap-generic.h" /* for decls of generic wrappers */ 56 #include "priv_syswrap-linux.h" /* for decls of linux-ish wrappers */ 57 #include "priv_syswrap-main.h" 58 59 60 /* --------------------------------------------------------------------- 61 clone() handling 62 ------------------------------------------------------------------ */ 63 64 /* Call f(arg1), but first switch stacks, using 'stack' as the new 65 stack, and use 'retaddr' as f's return-to address. Also, clear all 66 the integer registers before entering f.*/ 67 __attribute__((noreturn)) 68 void ML_(call_on_new_stack_0_1) ( Addr stack, 69 Addr retaddr, 70 void (*f_desc)(Word), 71 Word arg1 ); 72 // r3 = stack 73 // r4 = retaddr 74 // r5 = function descriptor 75 // r6 = arg1 76 /* On PPC64, a func ptr is represented by a TOC entry ptr. 77 This TOC entry contains three words; the first word is the function 78 address, the second word is the TOC ptr (r2), and the third word is 79 the static chain value. */ 80 asm( 81 " .align 2\n" 82 " .globl vgModuleLocal_call_on_new_stack_0_1\n" 83 " .section \".opd\",\"aw\"\n" 84 " .align 3\n" 85 "vgModuleLocal_call_on_new_stack_0_1:\n" 86 " .quad .vgModuleLocal_call_on_new_stack_0_1,.TOC.@tocbase,0\n" 87 " .previous\n" 88 " .type .vgModuleLocal_call_on_new_stack_0_1,@function\n" 89 " .globl .vgModuleLocal_call_on_new_stack_0_1\n" 90 ".vgModuleLocal_call_on_new_stack_0_1:\n" 91 " mr %r1,%r3\n\t" // stack to %sp 92 " mtlr %r4\n\t" // retaddr to %lr 93 " ld 5,0(5)\n\t" // load f_ptr from f_desc[0] 94 " mtctr %r5\n\t" // f_ptr to count reg 95 " mr %r3,%r6\n\t" // arg1 to %r3 96 " li 0,0\n\t" // zero all GP regs 97 " li 4,0\n\t" 98 " li 5,0\n\t" 99 " li 6,0\n\t" 100 " li 7,0\n\t" 101 " li 8,0\n\t" 102 " li 9,0\n\t" 103 " li 10,0\n\t" 104 " li 11,0\n\t" 105 " li 12,0\n\t" 106 " li 13,0\n\t" 107 " li 14,0\n\t" 108 " li 15,0\n\t" 109 " li 16,0\n\t" 110 " li 17,0\n\t" 111 " li 18,0\n\t" 112 " li 19,0\n\t" 113 " li 20,0\n\t" 114 " li 21,0\n\t" 115 " li 22,0\n\t" 116 " li 23,0\n\t" 117 " li 24,0\n\t" 118 " li 25,0\n\t" 119 " li 26,0\n\t" 120 " li 27,0\n\t" 121 " li 28,0\n\t" 122 " li 29,0\n\t" 123 " li 30,0\n\t" 124 " li 31,0\n\t" 125 " mtxer 0\n\t" // CAB: Need this? 126 " mtcr 0\n\t" // CAB: Need this? 127 " bctr\n\t" // jump to dst 128 " trap\n" // should never get here 129 ); 130 131 132 /* 133 Perform a clone system call. clone is strange because it has 134 fork()-like return-twice semantics, so it needs special 135 handling here. 136 137 Upon entry, we have: 138 139 word (fn)(void*) in r3 140 void* child_stack in r4 141 word flags in r5 142 void* arg in r6 143 pid_t* child_tid in r7 144 pid_t* parent_tid in r8 145 void* ??? in r9 146 147 Note: r3 contains fn desc ptr, not fn ptr -- p_fn = p_fn_desc[0] 148 System call requires: 149 150 int $__NR_clone in r0 (sc number) 151 int flags in r3 (sc arg1) 152 void* child_stack in r4 (sc arg2) 153 pid_t* parent_tid in r5 (sc arg3) 154 ?? child_tls in r6 (sc arg4) 155 pid_t* child_tid in r7 (sc arg5) 156 void* ??? in r8 (sc arg6) 157 158 Returns a ULong encoded as: top half is %cr following syscall, 159 low half is syscall return value (r3). 160 */ 161 #define __NR_CLONE VG_STRINGIFY(__NR_clone) 162 #define __NR_EXIT VG_STRINGIFY(__NR_exit) 163 164 extern 165 ULong do_syscall_clone_ppc64_linux ( Word (*fn)(void *), 166 void* stack, 167 Int flags, 168 void* arg, 169 Int* child_tid, 170 Int* parent_tid, 171 void/*vki_modify_ldt_t*/ * ); 172 asm( 173 " .align 2\n" 174 " .globl do_syscall_clone_ppc64_linux\n" 175 " .section \".opd\",\"aw\"\n" 176 " .align 3\n" 177 "do_syscall_clone_ppc64_linux:\n" 178 " .quad .do_syscall_clone_ppc64_linux,.TOC.@tocbase,0\n" 179 " .previous\n" 180 " .type .do_syscall_clone_ppc64_linux,@function\n" 181 " .globl .do_syscall_clone_ppc64_linux\n" 182 ".do_syscall_clone_ppc64_linux:\n" 183 " stdu 1,-64(1)\n" 184 " std 29,40(1)\n" 185 " std 30,48(1)\n" 186 " std 31,56(1)\n" 187 " mr 30,3\n" // preserve fn 188 " mr 31,6\n" // preserve arg 189 190 // setup child stack 191 " rldicr 4,4, 0,59\n" // trim sp to multiple of 16 bytes 192 // (r4 &= ~0xF) 193 " li 0,0\n" 194 " stdu 0,-32(4)\n" // make initial stack frame 195 " mr 29,4\n" // preserve sp 196 197 // setup syscall 198 " li 0,"__NR_CLONE"\n" // syscall number 199 " mr 3,5\n" // syscall arg1: flags 200 // r4 already setup // syscall arg2: child_stack 201 " mr 5,8\n" // syscall arg3: parent_tid 202 " mr 6,13\n" // syscall arg4: REAL THREAD tls 203 " mr 7,7\n" // syscall arg5: child_tid 204 " mr 8,8\n" // syscall arg6: ???? 205 " mr 9,9\n" // syscall arg7: ???? 206 207 " sc\n" // clone() 208 209 " mfcr 4\n" // CR now in low half r4 210 " sldi 4,4,32\n" // CR now in hi half r4 211 212 " sldi 3,3,32\n" 213 " srdi 3,3,32\n" // zero out hi half r3 214 215 " or 3,3,4\n" // r3 = CR : syscall-retval 216 " cmpwi 3,0\n" // child if retval == 0 (note, cmpw) 217 " bne 1f\n" // jump if !child 218 219 /* CHILD - call thread function */ 220 /* Note: 2.4 kernel doesn't set the child stack pointer, 221 so we do it here. 222 That does leave a small window for a signal to be delivered 223 on the wrong stack, unfortunately. */ 224 " mr 1,29\n" 225 " ld 30, 0(30)\n" // convert fn desc ptr to fn ptr 226 " mtctr 30\n" // ctr reg = fn 227 " mr 3,31\n" // r3 = arg 228 " bctrl\n" // call fn() 229 230 // exit with result 231 " li 0,"__NR_EXIT"\n" 232 " sc\n" 233 234 // Exit returned?! 235 " .long 0\n" 236 237 // PARENT or ERROR - return 238 "1: ld 29,40(1)\n" 239 " ld 30,48(1)\n" 240 " ld 31,56(1)\n" 241 " addi 1,1,64\n" 242 " blr\n" 243 ); 244 245 #undef __NR_CLONE 246 #undef __NR_EXIT 247 248 // forward declarations 249 static void setup_child ( ThreadArchState*, ThreadArchState* ); 250 251 /* 252 When a client clones, we need to keep track of the new thread. This means: 253 1. allocate a ThreadId+ThreadState+stack for the the thread 254 255 2. initialize the thread's new VCPU state 256 257 3. create the thread using the same args as the client requested, 258 but using the scheduler entrypoint for IP, and a separate stack 259 for SP. 260 */ 261 static SysRes do_clone ( ThreadId ptid, 262 UInt flags, Addr sp, 263 Int *parent_tidptr, 264 Int *child_tidptr, 265 Addr child_tls) 266 { 267 const Bool debug = False; 268 269 ThreadId ctid = VG_(alloc_ThreadState)(); 270 ThreadState* ptst = VG_(get_ThreadState)(ptid); 271 ThreadState* ctst = VG_(get_ThreadState)(ctid); 272 ULong word64; 273 UWord* stack; 274 NSegment const* seg; 275 SysRes res; 276 vki_sigset_t blockall, savedmask; 277 278 VG_(sigfillset)(&blockall); 279 280 vg_assert(VG_(is_running_thread)(ptid)); 281 vg_assert(VG_(is_valid_tid)(ctid)); 282 283 stack = (UWord*)ML_(allocstack)(ctid); 284 if (stack == NULL) { 285 res = VG_(mk_SysRes_Error)( VKI_ENOMEM ); 286 goto out; 287 } 288 289 //? /* make a stack frame */ 290 //? stack -= 16; 291 //? *(UWord *)stack = 0; 292 293 294 /* Copy register state 295 296 Both parent and child return to the same place, and the code 297 following the clone syscall works out which is which, so we 298 don't need to worry about it. 299 300 The parent gets the child's new tid returned from clone, but the 301 child gets 0. 302 303 If the clone call specifies a NULL SP for the new thread, then 304 it actually gets a copy of the parent's SP. 305 306 The child's TLS register (r2) gets set to the tlsaddr argument 307 if the CLONE_SETTLS flag is set. 308 */ 309 setup_child( &ctst->arch, &ptst->arch ); 310 311 /* Make sys_clone appear to have returned Success(0) in the 312 child. */ 313 { UInt old_cr = LibVEX_GuestPPC64_get_CR( &ctst->arch.vex ); 314 /* %r3 = 0 */ 315 ctst->arch.vex.guest_GPR3 = 0; 316 /* %cr0.so = 0 */ 317 LibVEX_GuestPPC64_put_CR( old_cr & ~(1<<28), &ctst->arch.vex ); 318 } 319 320 if (sp != 0) 321 ctst->arch.vex.guest_GPR1 = sp; 322 323 ctst->os_state.parent = ptid; 324 325 /* inherit signal mask */ 326 ctst->sig_mask = ptst->sig_mask; 327 ctst->tmp_sig_mask = ptst->sig_mask; 328 329 /* Start the child with its threadgroup being the same as the 330 parent's. This is so that any exit_group calls that happen 331 after the child is created but before it sets its 332 os_state.threadgroup field for real (in thread_wrapper in 333 syswrap-linux.c), really kill the new thread. a.k.a this avoids 334 a race condition in which the thread is unkillable (via 335 exit_group) because its threadgroup is not set. The race window 336 is probably only a few hundred or a few thousand cycles long. 337 See #226116. */ 338 ctst->os_state.threadgroup = ptst->os_state.threadgroup; 339 340 /* We don't really know where the client stack is, because its 341 allocated by the client. The best we can do is look at the 342 memory mappings and try to derive some useful information. We 343 assume that esp starts near its highest possible value, and can 344 only go down to the start of the mmaped segment. */ 345 seg = VG_(am_find_nsegment)(sp); 346 if (seg && seg->kind != SkResvn) { 347 ctst->client_stack_highest_word = (Addr)VG_PGROUNDUP(sp); 348 ctst->client_stack_szB = ctst->client_stack_highest_word - seg->start; 349 350 VG_(register_stack)(seg->start, ctst->client_stack_highest_word); 351 352 if (debug) 353 VG_(printf)("\ntid %d: guessed client stack range %#lx-%#lx\n", 354 ctid, seg->start, VG_PGROUNDUP(sp)); 355 } else { 356 VG_(message)(Vg_UserMsg, 357 "!? New thread %d starts with R1(%#lx) unmapped\n", 358 ctid, sp); 359 ctst->client_stack_szB = 0; 360 } 361 362 /* Assume the clone will succeed, and tell any tool that wants to 363 know that this thread has come into existence. If the clone 364 fails, we'll send out a ll_exit notification for it at the out: 365 label below, to clean up. */ 366 vg_assert(VG_(owns_BigLock_LL)(ptid)); 367 VG_TRACK ( pre_thread_ll_create, ptid, ctid ); 368 369 if (flags & VKI_CLONE_SETTLS) { 370 if (debug) 371 VG_(printf)("clone child has SETTLS: tls at %#lx\n", child_tls); 372 ctst->arch.vex.guest_GPR13 = child_tls; 373 } 374 375 flags &= ~VKI_CLONE_SETTLS; 376 377 /* start the thread with everything blocked */ 378 VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask); 379 380 /* Create the new thread */ 381 word64 = do_syscall_clone_ppc64_linux( 382 ML_(start_thread_NORETURN), 383 stack, flags, &VG_(threads)[ctid], 384 child_tidptr, parent_tidptr, NULL 385 ); 386 387 /* Low half word64 is syscall return value. Hi half is 388 the entire CR, from which we need to extract CR0.SO. */ 389 /* VG_(printf)("word64 = 0x%llx\n", word64); */ 390 res = VG_(mk_SysRes_ppc64_linux)( 391 /*val*/(UInt)(word64 & 0xFFFFFFFFULL), 392 /*errflag*/ (UInt)((word64 >> (32+28)) & 1) 393 ); 394 395 VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL); 396 397 out: 398 if (sr_isError(res)) { 399 /* clone failed */ 400 VG_(cleanup_thread)(&ctst->arch); 401 ctst->status = VgTs_Empty; 402 /* oops. Better tell the tool the thread exited in a hurry :-) */ 403 VG_TRACK( pre_thread_ll_exit, ctid ); 404 } 405 406 return res; 407 } 408 409 410 411 /* --------------------------------------------------------------------- 412 More thread stuff 413 ------------------------------------------------------------------ */ 414 415 void VG_(cleanup_thread) ( ThreadArchState* arch ) 416 { 417 } 418 419 void setup_child ( /*OUT*/ ThreadArchState *child, 420 /*IN*/ ThreadArchState *parent ) 421 { 422 /* We inherit our parent's guest state. */ 423 child->vex = parent->vex; 424 child->vex_shadow1 = parent->vex_shadow1; 425 child->vex_shadow2 = parent->vex_shadow2; 426 } 427 428 429 /* --------------------------------------------------------------------- 430 PRE/POST wrappers for ppc64/Linux-specific syscalls 431 ------------------------------------------------------------------ */ 432 433 #define PRE(name) DEFN_PRE_TEMPLATE(ppc64_linux, name) 434 #define POST(name) DEFN_POST_TEMPLATE(ppc64_linux, name) 435 436 /* Add prototypes for the wrappers declared here, so that gcc doesn't 437 harass us for not having prototypes. Really this is a kludge -- 438 the right thing to do is to make these wrappers 'static' since they 439 aren't visible outside this file, but that requires even more macro 440 magic. */ 441 442 DECL_TEMPLATE(ppc64_linux, sys_mmap); 443 //zz DECL_TEMPLATE(ppc64_linux, sys_mmap2); 444 //zz DECL_TEMPLATE(ppc64_linux, sys_stat64); 445 //zz DECL_TEMPLATE(ppc64_linux, sys_lstat64); 446 //zz DECL_TEMPLATE(ppc64_linux, sys_fstat64); 447 DECL_TEMPLATE(ppc64_linux, sys_clone); 448 //zz DECL_TEMPLATE(ppc64_linux, sys_sigreturn); 449 DECL_TEMPLATE(ppc64_linux, sys_rt_sigreturn); 450 DECL_TEMPLATE(ppc64_linux, sys_fadvise64); 451 452 PRE(sys_mmap) 453 { 454 SysRes r; 455 456 PRINT("sys_mmap ( %#lx, %llu, %ld, %ld, %ld, %ld )", 457 ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 ); 458 PRE_REG_READ6(long, "mmap", 459 unsigned long, start, unsigned long, length, 460 unsigned long, prot, unsigned long, flags, 461 unsigned long, fd, unsigned long, offset); 462 463 r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5, 464 (Off64T)ARG6 ); 465 SET_STATUS_from_SysRes(r); 466 } 467 468 //zz PRE(sys_mmap2) 469 //zz { 470 //zz SysRes r; 471 //zz 472 //zz // Exactly like old_mmap() except: 473 //zz // - the file offset is specified in 4K units rather than bytes, 474 //zz // so that it can be used for files bigger than 2^32 bytes. 475 //zz PRINT("sys_mmap2 ( %p, %llu, %d, %d, %d, %d )", 476 //zz ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 ); 477 //zz PRE_REG_READ6(long, "mmap2", 478 //zz unsigned long, start, unsigned long, length, 479 //zz unsigned long, prot, unsigned long, flags, 480 //zz unsigned long, fd, unsigned long, offset); 481 //zz 482 //zz r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5, 483 //zz 4096 * (Off64T)ARG6 ); 484 //zz SET_STATUS_from_SysRes(r); 485 //zz } 486 //zz 487 //zz // XXX: lstat64/fstat64/stat64 are generic, but not necessarily 488 //zz // applicable to every architecture -- I think only to 32-bit archs. 489 //zz // We're going to need something like linux/core_os32.h for such 490 //zz // things, eventually, I think. --njn 491 //zz PRE(sys_stat64) 492 //zz { 493 //zz PRINT("sys_stat64 ( %p, %p )",ARG1,ARG2); 494 //zz PRE_REG_READ2(long, "stat64", char *, file_name, struct stat64 *, buf); 495 //zz PRE_MEM_RASCIIZ( "stat64(file_name)", ARG1 ); 496 //zz PRE_MEM_WRITE( "stat64(buf)", ARG2, sizeof(struct vki_stat64) ); 497 //zz } 498 //zz 499 //zz POST(sys_stat64) 500 //zz { 501 //zz POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) ); 502 //zz } 503 //zz 504 //zz PRE(sys_lstat64) 505 //zz { 506 //zz PRINT("sys_lstat64 ( %p(%s), %p )",ARG1,ARG1,ARG2); 507 //zz PRE_REG_READ2(long, "lstat64", char *, file_name, struct stat64 *, buf); 508 //zz PRE_MEM_RASCIIZ( "lstat64(file_name)", ARG1 ); 509 //zz PRE_MEM_WRITE( "lstat64(buf)", ARG2, sizeof(struct vki_stat64) ); 510 //zz } 511 //zz 512 //zz POST(sys_lstat64) 513 //zz { 514 //zz vg_assert(SUCCESS); 515 //zz if (RES == 0) { 516 //zz POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) ); 517 //zz } 518 //zz } 519 //zz 520 //zz PRE(sys_fstat64) 521 //zz { 522 //zz PRINT("sys_fstat64 ( %d, %p )",ARG1,ARG2); 523 //zz PRE_REG_READ2(long, "fstat64", unsigned long, fd, struct stat64 *, buf); 524 //zz PRE_MEM_WRITE( "fstat64(buf)", ARG2, sizeof(struct vki_stat64) ); 525 //zz } 526 //zz 527 //zz POST(sys_fstat64) 528 //zz { 529 //zz POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) ); 530 //zz } 531 532 533 PRE(sys_clone) 534 { 535 UInt cloneflags; 536 537 PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5); 538 PRE_REG_READ5(int, "clone", 539 unsigned long, flags, 540 void *, child_stack, 541 int *, parent_tidptr, 542 void *, child_tls, 543 int *, child_tidptr); 544 545 if (ARG1 & VKI_CLONE_PARENT_SETTID) { 546 PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int)); 547 if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int), 548 VKI_PROT_WRITE)) { 549 SET_STATUS_Failure( VKI_EFAULT ); 550 return; 551 } 552 } 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)); /* child_tls */ 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_(unimplemented) 603 ("Valgrind does not support general clone()."); 604 } 605 606 if (SUCCESS) { 607 if (ARG1 & VKI_CLONE_PARENT_SETTID) 608 POST_MEM_WRITE(ARG3, sizeof(Int)); 609 if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) 610 POST_MEM_WRITE(ARG5, sizeof(Int)); 611 612 /* Thread creation was successful; let the child have the chance 613 to run */ 614 *flags |= SfYieldAfter; 615 } 616 } 617 618 PRE(sys_fadvise64) 619 { 620 PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", ARG1,ARG2,ARG3,ARG4); 621 PRE_REG_READ4(long, "fadvise64", 622 int, fd, vki_loff_t, offset, vki_size_t, len, int, advice); 623 } 624 625 PRE(sys_rt_sigreturn) 626 { 627 /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for 628 an explanation of what follows. */ 629 630 //ThreadState* tst; 631 PRINT("sys_rt_sigreturn ( )"); 632 633 vg_assert(VG_(is_valid_tid)(tid)); 634 vg_assert(tid >= 1 && tid < VG_N_THREADS); 635 vg_assert(VG_(is_running_thread)(tid)); 636 637 ///* Adjust esp to point to start of frame; skip back up over handler 638 // ret addr */ 639 //tst = VG_(get_ThreadState)(tid); 640 //tst->arch.vex.guest_ESP -= sizeof(Addr); 641 // Should we do something equivalent on ppc64-linux? Who knows. 642 643 ///* This is only so that the EIP is (might be) useful to report if 644 // something goes wrong in the sigreturn */ 645 //ML_(fixup_guest_state_to_restart_syscall)(&tst->arch); 646 // Should we do something equivalent on ppc64? Who knows. 647 648 /* Restore register state from frame and remove it */ 649 VG_(sigframe_destroy)(tid, True); 650 651 /* Tell the driver not to update the guest state with the "result", 652 and set a bogus result to keep it happy. */ 653 *flags |= SfNoWriteResult; 654 SET_STATUS_Success(0); 655 656 /* Check to see if any signals arose as a result of this. */ 657 *flags |= SfPollAfter; 658 } 659 660 #undef PRE 661 #undef POST 662 663 /* --------------------------------------------------------------------- 664 The ppc64/Linux syscall table 665 ------------------------------------------------------------------ */ 666 667 /* Add an ppc64-linux specific wrapper to a syscall table. */ 668 #define PLAX_(sysno, name) WRAPPER_ENTRY_X_(ppc64_linux, sysno, name) 669 #define PLAXY(sysno, name) WRAPPER_ENTRY_XY(ppc64_linux, sysno, name) 670 671 // This table maps from __NR_xxx syscall numbers (from 672 // linux/include/asm-ppc/unistd.h) to the appropriate PRE/POST sys_foo() 673 // wrappers on ppc64 (as per sys_call_table in linux/arch/ppc/kernel/entry.S). 674 // 675 // For those syscalls not handled by Valgrind, the annotation indicate its 676 // arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/? 677 // (unknown). 678 679 static SyscallTableEntry syscall_table[] = { 680 // _____(__NR_restart_syscall, sys_restart_syscall), // 0 681 GENX_(__NR_exit, sys_exit), // 1 682 GENX_(__NR_fork, sys_fork), // 2 683 GENXY(__NR_read, sys_read), // 3 684 GENX_(__NR_write, sys_write), // 4 685 686 GENXY(__NR_open, sys_open), // 5 687 GENXY(__NR_close, sys_close), // 6 688 GENXY(__NR_waitpid, sys_waitpid), // 7 689 GENXY(__NR_creat, sys_creat), // 8 690 GENX_(__NR_link, sys_link), // 9 691 692 GENX_(__NR_unlink, sys_unlink), // 10 693 GENX_(__NR_execve, sys_execve), // 11 694 GENX_(__NR_chdir, sys_chdir), // 12 695 GENXY(__NR_time, sys_time), // 13 696 GENX_(__NR_mknod, sys_mknod), // 14 697 698 GENX_(__NR_chmod, sys_chmod), // 15 699 GENX_(__NR_lchown, sys_lchown), // 16 700 // _____(__NR_break, sys_break), // 17 701 // _____(__NR_oldstat, sys_oldstat), // 18 702 LINX_(__NR_lseek, sys_lseek), // 19 703 704 GENX_(__NR_getpid, sys_getpid), // 20 705 LINX_(__NR_mount, sys_mount), // 21 706 // _____(__NR_umount, sys_umount), // 22 707 GENX_(__NR_setuid, sys_setuid), // 23 708 GENX_(__NR_getuid, sys_getuid), // 24 709 710 // _____(__NR_stime, sys_stime), // 25 711 // _____(__NR_ptrace, sys_ptrace), // 26 712 GENX_(__NR_alarm, sys_alarm), // 27 713 // _____(__NR_oldfstat, sys_oldfstat), // 28 714 GENX_(__NR_pause, sys_pause), // 29 715 716 LINX_(__NR_utime, sys_utime), // 30 717 // _____(__NR_stty, sys_stty), // 31 718 // _____(__NR_gtty, sys_gtty), // 32 719 GENX_(__NR_access, sys_access), // 33 720 // _____(__NR_nice, sys_nice), // 34 721 722 // _____(__NR_ftime, sys_ftime), // 35 723 // _____(__NR_sync, sys_sync), // 36 724 GENX_(__NR_kill, sys_kill), // 37 725 GENX_(__NR_rename, sys_rename), // 38 726 GENX_(__NR_mkdir, sys_mkdir), // 39 727 728 GENX_(__NR_rmdir, sys_rmdir), // 40 729 GENXY(__NR_dup, sys_dup), // 41 730 LINXY(__NR_pipe, sys_pipe), // 42 731 GENXY(__NR_times, sys_times), // 43 732 // _____(__NR_prof, sys_prof), // 44 733 734 GENX_(__NR_brk, sys_brk), // 45 735 GENX_(__NR_setgid, sys_setgid), // 46 736 GENX_(__NR_getgid, sys_getgid), // 47 737 // _____(__NR_signal, sys_signal), // 48 738 GENX_(__NR_geteuid, sys_geteuid), // 49 739 740 GENX_(__NR_getegid, sys_getegid), // 50 741 // _____(__NR_acct, sys_acct), // 51 742 LINX_(__NR_umount2, sys_umount), // 52 743 // _____(__NR_lock, sys_lock), // 53 744 LINXY(__NR_ioctl, sys_ioctl), // 54 745 746 LINXY(__NR_fcntl, sys_fcntl), // 55 747 // _____(__NR_mpx, sys_mpx), // 56 748 GENX_(__NR_setpgid, sys_setpgid), // 57 749 // _____(__NR_ulimit, sys_ulimit), // 58 750 // _____(__NR_oldolduname, sys_oldolduname), // 59 751 752 GENX_(__NR_umask, sys_umask), // 60 753 GENX_(__NR_chroot, sys_chroot), // 61 754 // _____(__NR_ustat, sys_ustat), // 62 755 GENXY(__NR_dup2, sys_dup2), // 63 756 GENX_(__NR_getppid, sys_getppid), // 64 757 758 GENX_(__NR_getpgrp, sys_getpgrp), // 65 759 GENX_(__NR_setsid, sys_setsid), // 66 760 // _____(__NR_sigaction, sys_sigaction), // 67 761 // _____(__NR_sgetmask, sys_sgetmask), // 68 762 // _____(__NR_ssetmask, sys_ssetmask), // 69 763 764 GENX_(__NR_setreuid, sys_setreuid), // 70 765 GENX_(__NR_setregid, sys_setregid), // 71 766 // _____(__NR_sigsuspend, sys_sigsuspend), // 72 767 // _____(__NR_sigpending, sys_sigpending), // 73 768 // _____(__NR_sethostname, sys_sethostname), // 74 769 770 GENX_(__NR_setrlimit, sys_setrlimit), // 75 771 // _____(__NR_getrlimit, sys_getrlimit), // 76 772 GENXY(__NR_getrusage, sys_getrusage), // 77 773 GENXY(__NR_gettimeofday, sys_gettimeofday), // 78 774 // _____(__NR_settimeofday, sys_settimeofday), // 79 775 776 GENXY(__NR_getgroups, sys_getgroups), // 80 777 GENX_(__NR_setgroups, sys_setgroups), // 81 778 // _____(__NR_select, sys_select), // 82 779 GENX_(__NR_symlink, sys_symlink), // 83 780 // _____(__NR_oldlstat, sys_oldlstat), // 84 781 782 GENX_(__NR_readlink, sys_readlink), // 85 783 // _____(__NR_uselib, sys_uselib), // 86 784 // _____(__NR_swapon, sys_swapon), // 87 785 // _____(__NR_reboot, sys_reboot), // 88 786 // _____(__NR_readdir, sys_readdir), // 89 787 788 PLAX_(__NR_mmap, sys_mmap), // 90 789 GENXY(__NR_munmap, sys_munmap), // 91 790 GENX_(__NR_truncate, sys_truncate), // 92 791 GENX_(__NR_ftruncate, sys_ftruncate), // 93 792 GENX_(__NR_fchmod, sys_fchmod), // 94 793 794 GENX_(__NR_fchown, sys_fchown), // 95 795 GENX_(__NR_getpriority, sys_getpriority), // 96 796 GENX_(__NR_setpriority, sys_setpriority), // 97 797 // _____(__NR_profil, sys_profil), // 98 798 GENXY(__NR_statfs, sys_statfs), // 99 799 800 GENXY(__NR_fstatfs, sys_fstatfs), // 100 801 // _____(__NR_ioperm, sys_ioperm), // 101 802 LINXY(__NR_socketcall, sys_socketcall), // 102 803 LINXY(__NR_syslog, sys_syslog), // 103 804 GENXY(__NR_setitimer, sys_setitimer), // 104 805 806 GENXY(__NR_getitimer, sys_getitimer), // 105 807 GENXY(__NR_stat, sys_newstat), // 106 808 GENXY(__NR_lstat, sys_newlstat), // 107 809 GENXY(__NR_fstat, sys_newfstat), // 108 810 // _____(__NR_olduname, sys_olduname), // 109 811 812 // _____(__NR_iopl, sys_iopl), // 110 813 LINX_(__NR_vhangup, sys_vhangup), // 111 814 // _____(__NR_idle, sys_idle), // 112 815 // _____(__NR_vm86, sys_vm86), // 113 816 GENXY(__NR_wait4, sys_wait4), // 114 817 818 // _____(__NR_swapoff, sys_swapoff), // 115 819 LINXY(__NR_sysinfo, sys_sysinfo), // 116 820 LINXY(__NR_ipc, sys_ipc), // 117 821 GENX_(__NR_fsync, sys_fsync), // 118 822 // _____(__NR_sigreturn, sys_sigreturn), // 119 823 824 PLAX_(__NR_clone, sys_clone), // 120 825 // _____(__NR_setdomainname, sys_setdomainname), // 121 826 GENXY(__NR_uname, sys_newuname), // 122 827 // _____(__NR_modify_ldt, sys_modify_ldt), // 123 828 LINXY(__NR_adjtimex, sys_adjtimex), // 124 829 830 GENXY(__NR_mprotect, sys_mprotect), // 125 831 // _____(__NR_sigprocmask, sys_sigprocmask), // 126 832 GENX_(__NR_create_module, sys_ni_syscall), // 127 833 LINX_(__NR_init_module, sys_init_module), // 128 834 LINX_(__NR_delete_module, sys_delete_module), // 129 835 836 // _____(__NR_get_kernel_syms, sys_get_kernel_syms), // 130 837 // _____(__NR_quotactl, sys_quotactl), // 131 838 GENX_(__NR_getpgid, sys_getpgid), // 132 839 GENX_(__NR_fchdir, sys_fchdir), // 133 840 // _____(__NR_bdflush, sys_bdflush), // 134 841 842 // _____(__NR_sysfs, sys_sysfs), // 135 843 LINX_(__NR_personality, sys_personality), // 136 844 // _____(__NR_afs_syscall, sys_afs_syscall), // 137 845 LINX_(__NR_setfsuid, sys_setfsuid), // 138 846 LINX_(__NR_setfsgid, sys_setfsgid), // 139 847 848 LINXY(__NR__llseek, sys_llseek), // 140 849 GENXY(__NR_getdents, sys_getdents), // 141 850 GENX_(__NR__newselect, sys_select), // 142 851 GENX_(__NR_flock, sys_flock), // 143 852 GENX_(__NR_msync, sys_msync), // 144 853 854 GENXY(__NR_readv, sys_readv), // 145 855 GENX_(__NR_writev, sys_writev), // 146 856 // _____(__NR_getsid, sys_getsid), // 147 857 GENX_(__NR_fdatasync, sys_fdatasync), // 148 858 LINXY(__NR__sysctl, sys_sysctl), // 149 859 860 GENX_(__NR_mlock, sys_mlock), // 150 861 GENX_(__NR_munlock, sys_munlock), // 151 862 GENX_(__NR_mlockall, sys_mlockall), // 152 863 LINX_(__NR_munlockall, sys_munlockall), // 153 864 LINXY(__NR_sched_setparam, sys_sched_setparam), // 154 865 866 LINXY(__NR_sched_getparam, sys_sched_getparam), // 155 867 LINX_(__NR_sched_setscheduler, sys_sched_setscheduler), // 156 868 LINX_(__NR_sched_getscheduler, sys_sched_getscheduler), // 157 869 LINX_(__NR_sched_yield, sys_sched_yield), // 158 870 LINX_(__NR_sched_get_priority_max, sys_sched_get_priority_max),// 159 871 872 LINX_(__NR_sched_get_priority_min, sys_sched_get_priority_min),// 160 873 LINXY(__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 161 874 GENXY(__NR_nanosleep, sys_nanosleep), // 162 875 GENX_(__NR_mremap, sys_mremap), // 163 876 LINX_(__NR_setresuid, sys_setresuid), // 164 877 878 LINXY(__NR_getresuid, sys_getresuid), // 165 879 // _____(__NR_query_module, sys_query_module), // 166 880 GENXY(__NR_poll, sys_poll), // 167 881 // _____(__NR_nfsservctl, sys_nfsservctl), // 168 882 LINX_(__NR_setresgid, sys_setresgid), // 169 883 884 LINXY(__NR_getresgid, sys_getresgid), // 170 885 LINXY(__NR_prctl, sys_prctl), // 171 886 PLAX_(__NR_rt_sigreturn, sys_rt_sigreturn), // 172 887 LINXY(__NR_rt_sigaction, sys_rt_sigaction), // 173 888 LINXY(__NR_rt_sigprocmask, sys_rt_sigprocmask), // 174 889 890 // _____(__NR_rt_sigpending, sys_rt_sigpending), // 175 891 LINXY(__NR_rt_sigtimedwait, sys_rt_sigtimedwait), // 176 892 LINXY(__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo), // 177 893 LINX_(__NR_rt_sigsuspend, sys_rt_sigsuspend), // 178 894 GENXY(__NR_pread64, sys_pread64), // 179 895 896 GENX_(__NR_pwrite64, sys_pwrite64), // 180 897 GENX_(__NR_chown, sys_chown), // 181 898 GENXY(__NR_getcwd, sys_getcwd), // 182 899 LINXY(__NR_capget, sys_capget), // 183 900 LINX_(__NR_capset, sys_capset), // 184 901 902 GENXY(__NR_sigaltstack, sys_sigaltstack), // 185 903 LINXY(__NR_sendfile, sys_sendfile), // 186 904 // _____(__NR_getpmsg, sys_getpmsg), // 187 905 // _____(__NR_putpmsg, sys_putpmsg), // 188 906 GENX_(__NR_vfork, sys_fork), // 189 treat as fork 907 908 GENXY(__NR_ugetrlimit, sys_getrlimit), // 190 909 LINX_(__NR_readahead, sys_readahead), // 191 910 // /* #define __NR_mmap2 192 32bit only */ 911 // /* #define __NR_truncate64 193 32bit only */ 912 // /* #define __NR_ftruncate64 194 32bit only */ 913 914 // /* #define __NR_stat64 195 32bit only */ 915 // /* #define __NR_lstat64 196 32bit only */ 916 // /* #define __NR_fstat64 197 32bit only */ 917 // _____(__NR_pciconfig_read, sys_pciconfig_read), // 198 918 // _____(__NR_pciconfig_write, sys_pciconfig_write), // 199 919 920 // _____(__NR_pciconfig_iobase, sys_pciconfig_iobase), // 200 921 // _____(__NR_multiplexer, sys_multiplexer), // 201 922 GENXY(__NR_getdents64, sys_getdents64), // 202 923 // _____(__NR_pivot_root, sys_pivot_root), // 203 924 LINXY(__NR_fcntl64, sys_fcntl64), // 204 !!!!?? 32bit only */ 925 926 GENX_(__NR_madvise, sys_madvise), // 205 927 // _____(__NR_mincore, sys_mincore), // 206 928 LINX_(__NR_gettid, sys_gettid), // 207 929 // _____(__NR_tkill, sys_tkill), // 208 930 LINX_(__NR_setxattr, sys_setxattr), // 209 931 932 LINX_(__NR_lsetxattr, sys_lsetxattr), // 210 933 LINX_(__NR_fsetxattr, sys_fsetxattr), // 211 934 LINXY(__NR_getxattr, sys_getxattr), // 212 935 LINXY(__NR_lgetxattr, sys_lgetxattr), // 213 936 LINXY(__NR_fgetxattr, sys_fgetxattr), // 214 937 LINXY(__NR_listxattr, sys_listxattr), // 215 938 LINXY(__NR_llistxattr, sys_llistxattr), // 216 939 LINXY(__NR_flistxattr, sys_flistxattr), // 217 940 LINX_(__NR_removexattr, sys_removexattr), // 218 941 LINX_(__NR_lremovexattr, sys_lremovexattr), // 219 942 LINX_(__NR_fremovexattr, sys_fremovexattr), // 220 943 944 LINXY(__NR_futex, sys_futex), // 221 945 LINX_(__NR_sched_setaffinity, sys_sched_setaffinity), // 222 946 LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 223 947 // /* 224 currently unused */ 948 949 // _____(__NR_tuxcall, sys_tuxcall), // 225 950 // /* #define __NR_sendfile64 226 32bit only */ 951 LINX_(__NR_io_setup, sys_io_setup), // 227 952 LINX_(__NR_io_destroy, sys_io_destroy), // 228 953 LINXY(__NR_io_getevents, sys_io_getevents), // 229 954 LINX_(__NR_io_submit, sys_io_submit), // 230 955 LINXY(__NR_io_cancel, sys_io_cancel), // 231 956 LINX_(__NR_set_tid_address, sys_set_tid_address), // 232 957 PLAX_(__NR_fadvise64, sys_fadvise64), // 233 958 LINX_(__NR_exit_group, sys_exit_group), // 234 959 960 // _____(__NR_lookup_dcookie, sys_lookup_dcookie), // 235 961 LINXY(__NR_epoll_create, sys_epoll_create), // 236 962 LINX_(__NR_epoll_ctl, sys_epoll_ctl), // 237 963 LINXY(__NR_epoll_wait, sys_epoll_wait), // 238 964 // _____(__NR_remap_file_pages, sys_remap_file_pages), // 239 965 966 LINXY(__NR_timer_create, sys_timer_create), // 240 967 LINXY(__NR_timer_settime, sys_timer_settime), // 241 968 LINXY(__NR_timer_gettime, sys_timer_gettime), // 242 969 LINX_(__NR_timer_getoverrun, sys_timer_getoverrun), // 243 970 LINX_(__NR_timer_delete, sys_timer_delete), // 244 971 LINX_(__NR_clock_settime, sys_clock_settime), // 245 972 LINXY(__NR_clock_gettime, sys_clock_gettime), // 246 973 LINXY(__NR_clock_getres, sys_clock_getres), // 247 974 LINXY(__NR_clock_nanosleep, sys_clock_nanosleep), // 248 975 976 // _____(__NR_swapcontext, sys_swapcontext), // 249 977 978 LINXY(__NR_tgkill, sys_tgkill), // 250 979 // _____(__NR_utimes, sys_utimes), // 251 980 // _____(__NR_statfs64, sys_statfs64), // 252 981 // _____(__NR_fstatfs64, sys_fstatfs64), // 253 982 // /* #define __NR_fadvise64_64 254 32bit only */ 983 984 // _____(__NR_rtas, sys_rtas), // 255 985 // /* Number 256 is reserved for sys_debug_setcontext */ 986 // /* Number 257 is reserved for vserver */ 987 // /* 258 currently unused */ 988 LINX_(__NR_mbind, sys_mbind), // 259 989 990 LINXY(__NR_get_mempolicy, sys_get_mempolicy), // 260 991 LINX_(__NR_set_mempolicy, sys_set_mempolicy), // 261 992 LINXY(__NR_mq_open, sys_mq_open), // 262 993 LINX_(__NR_mq_unlink, sys_mq_unlink), // 263 994 LINX_(__NR_mq_timedsend, sys_mq_timedsend), // 264 995 996 LINXY(__NR_mq_timedreceive, sys_mq_timedreceive), // 265 997 LINX_(__NR_mq_notify, sys_mq_notify), // 266 998 LINXY(__NR_mq_getsetattr, sys_mq_getsetattr), // 267 999 // _____(__NR_kexec_load, sys_kexec_load), // 268 1000 LINX_(__NR_add_key, sys_add_key), // 269 1001 1002 LINX_(__NR_request_key, sys_request_key), // 270 1003 LINXY(__NR_keyctl, sys_keyctl), // 271 1004 // _____(__NR_waitid, sys_waitid), // 272 1005 LINX_(__NR_ioprio_set, sys_ioprio_set), // 273 1006 LINX_(__NR_ioprio_get, sys_ioprio_get), // 274 1007 1008 LINX_(__NR_inotify_init, sys_inotify_init), // 275 1009 LINX_(__NR_inotify_add_watch, sys_inotify_add_watch), // 276 1010 LINX_(__NR_inotify_rm_watch, sys_inotify_rm_watch), // 277 1011 1012 LINX_(__NR_pselect6, sys_pselect6), // 280 1013 LINXY(__NR_ppoll, sys_ppoll), // 281 1014 1015 LINXY(__NR_openat, sys_openat), // 286 1016 LINX_(__NR_mkdirat, sys_mkdirat), // 287 1017 LINX_(__NR_mknodat, sys_mknodat), // 288 1018 LINX_(__NR_fchownat, sys_fchownat), // 289 1019 LINX_(__NR_futimesat, sys_futimesat), // 290 1020 LINXY(__NR_newfstatat, sys_newfstatat), // 291 1021 LINX_(__NR_unlinkat, sys_unlinkat), // 292 1022 LINX_(__NR_renameat, sys_renameat), // 293 1023 LINX_(__NR_linkat, sys_linkat), // 294 1024 LINX_(__NR_symlinkat, sys_symlinkat), // 295 1025 LINX_(__NR_readlinkat, sys_readlinkat), // 296 1026 LINX_(__NR_fchmodat, sys_fchmodat), // 297 1027 LINX_(__NR_faccessat, sys_faccessat), // 298 1028 LINX_(__NR_set_robust_list, sys_set_robust_list), // 299 1029 LINXY(__NR_get_robust_list, sys_get_robust_list), // 300 1030 LINXY(__NR_move_pages, sys_move_pages), // 301 1031 LINXY(__NR_getcpu, sys_getcpu), // 302 1032 LINXY(__NR_epoll_pwait, sys_epoll_pwait), // 303 1033 LINX_(__NR_utimensat, sys_utimensat), // 304 1034 LINXY(__NR_signalfd, sys_signalfd), // 305 1035 LINXY(__NR_timerfd_create, sys_timerfd_create), // 306 1036 LINXY(__NR_eventfd, sys_eventfd), // 307 1037 LINX_(__NR_sync_file_range2, sys_sync_file_range2), // 308 1038 LINX_(__NR_fallocate, sys_fallocate), // 309 1039 // LINXY(__NR_subpage_prot, sys_ni_syscall), // 310 1040 LINXY(__NR_timerfd_settime, sys_timerfd_settime), // 311 1041 LINXY(__NR_timerfd_gettime, sys_timerfd_gettime), // 312 1042 LINXY(__NR_signalfd4, sys_signalfd4), // 313 1043 LINXY(__NR_eventfd2, sys_eventfd2), // 314 1044 LINXY(__NR_epoll_create1, sys_epoll_create1), // 315 1045 LINXY(__NR_dup3, sys_dup3), // 316 1046 LINXY(__NR_pipe2, sys_pipe2), // 317 1047 LINXY(__NR_inotify_init1, sys_inotify_init1), // 318 1048 LINXY(__NR_perf_event_open, sys_perf_event_open), // 319 1049 LINXY(__NR_preadv, sys_preadv), // 320 1050 LINX_(__NR_pwritev, sys_pwritev), // 321 1051 LINXY(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo),// 322 1052 1053 LINXY(__NR_clock_adjtime, sys_clock_adjtime), // 347 1054 1055 LINXY(__NR_process_vm_readv, sys_process_vm_readv), // 351 1056 LINX_(__NR_process_vm_writev, sys_process_vm_writev) // 352 1057 }; 1058 1059 SyscallTableEntry* ML_(get_linux_syscall_entry) ( UInt sysno ) 1060 { 1061 const UInt syscall_table_size 1062 = sizeof(syscall_table) / sizeof(syscall_table[0]); 1063 1064 /* Is it in the contiguous initial section of the table? */ 1065 if (sysno < syscall_table_size) { 1066 SyscallTableEntry* sys = &syscall_table[sysno]; 1067 if (sys->before == NULL) 1068 return NULL; /* no entry */ 1069 else 1070 return sys; 1071 } 1072 1073 /* Can't find a wrapper */ 1074 return NULL; 1075 } 1076 1077 #endif // defined(VGP_ppc64_linux) 1078 1079 /*--------------------------------------------------------------------*/ 1080 /*--- end ---*/ 1081 /*--------------------------------------------------------------------*/ 1082
