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