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-2012 Nicholas Nethercote <njn (at) valgrind.org> 11 Copyright (C) 2005-2012 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_socketcall); 443 DECL_TEMPLATE(ppc64_linux, sys_mmap); 444 //zz DECL_TEMPLATE(ppc64_linux, sys_mmap2); 445 //zz DECL_TEMPLATE(ppc64_linux, sys_stat64); 446 //zz DECL_TEMPLATE(ppc64_linux, sys_lstat64); 447 //zz DECL_TEMPLATE(ppc64_linux, sys_fstat64); 448 DECL_TEMPLATE(ppc64_linux, sys_ipc); 449 DECL_TEMPLATE(ppc64_linux, sys_clone); 450 //zz DECL_TEMPLATE(ppc64_linux, sys_sigreturn); 451 DECL_TEMPLATE(ppc64_linux, sys_rt_sigreturn); 452 DECL_TEMPLATE(ppc64_linux, sys_fadvise64); 453 454 PRE(sys_socketcall) 455 { 456 # define ARG2_0 (((UWord*)ARG2)[0]) 457 # define ARG2_1 (((UWord*)ARG2)[1]) 458 # define ARG2_2 (((UWord*)ARG2)[2]) 459 # define ARG2_3 (((UWord*)ARG2)[3]) 460 # define ARG2_4 (((UWord*)ARG2)[4]) 461 # define ARG2_5 (((UWord*)ARG2)[5]) 462 463 *flags |= SfMayBlock; 464 PRINT("sys_socketcall ( %ld, %#lx )",ARG1,ARG2); 465 PRE_REG_READ2(long, "socketcall", int, call, unsigned long *, args); 466 467 switch (ARG1 /* request */) { 468 469 case VKI_SYS_SOCKETPAIR: 470 /* int socketpair(int d, int type, int protocol, int sv[2]); */ 471 PRE_MEM_READ( "socketcall.socketpair(args)", ARG2, 4*sizeof(Addr) ); 472 ML_(generic_PRE_sys_socketpair)( tid, ARG2_0, ARG2_1, ARG2_2, ARG2_3 ); 473 break; 474 475 case VKI_SYS_SOCKET: 476 /* int socket(int domain, int type, int protocol); */ 477 PRE_MEM_READ( "socketcall.socket(args)", ARG2, 3*sizeof(Addr) ); 478 break; 479 480 case VKI_SYS_BIND: 481 /* int bind(int sockfd, struct sockaddr *my_addr, 482 int addrlen); */ 483 PRE_MEM_READ( "socketcall.bind(args)", ARG2, 3*sizeof(Addr) ); 484 ML_(generic_PRE_sys_bind)( tid, ARG2_0, ARG2_1, ARG2_2 ); 485 break; 486 487 case VKI_SYS_LISTEN: 488 /* int listen(int s, int backlog); */ 489 PRE_MEM_READ( "socketcall.listen(args)", ARG2, 2*sizeof(Addr) ); 490 break; 491 492 case VKI_SYS_ACCEPT: { 493 /* int accept(int s, struct sockaddr *addr, int *addrlen); */ 494 PRE_MEM_READ( "socketcall.accept(args)", ARG2, 3*sizeof(Addr) ); 495 ML_(generic_PRE_sys_accept)( tid, ARG2_0, ARG2_1, ARG2_2 ); 496 break; 497 } 498 499 case VKI_SYS_ACCEPT4: { 500 /* int accept4(int s, struct sockaddr *addr, int *addrlen, int flags); */ 501 PRE_MEM_READ( "socketcall.accept4(args)", ARG2, 4*sizeof(Addr) ); 502 ML_(generic_PRE_sys_accept)( tid, ARG2_0, ARG2_1, ARG2_2 ); 503 break; 504 } 505 506 case VKI_SYS_SENDTO: 507 /* int sendto(int s, const void *msg, int len, 508 unsigned int flags, 509 const struct sockaddr *to, int tolen); */ 510 PRE_MEM_READ( "socketcall.sendto(args)", ARG2, 6*sizeof(Addr) ); 511 ML_(generic_PRE_sys_sendto)( tid, ARG2_0, ARG2_1, ARG2_2, 512 ARG2_3, ARG2_4, ARG2_5 ); 513 break; 514 515 case VKI_SYS_SEND: 516 /* int send(int s, const void *msg, size_t len, int flags); */ 517 PRE_MEM_READ( "socketcall.send(args)", ARG2, 4*sizeof(Addr) ); 518 ML_(generic_PRE_sys_send)( tid, ARG2_0, ARG2_1, ARG2_2 ); 519 break; 520 521 case VKI_SYS_RECVFROM: 522 /* int recvfrom(int s, void *buf, int len, unsigned int flags, 523 struct sockaddr *from, int *fromlen); */ 524 PRE_MEM_READ( "socketcall.recvfrom(args)", ARG2, 6*sizeof(Addr) ); 525 ML_(generic_PRE_sys_recvfrom)( tid, ARG2_0, ARG2_1, ARG2_2, 526 ARG2_3, ARG2_4, ARG2_5 ); 527 break; 528 529 case VKI_SYS_RECV: 530 /* int recv(int s, void *buf, int len, unsigned int flags); */ 531 /* man 2 recv says: 532 The recv call is normally used only on a connected socket 533 (see connect(2)) and is identical to recvfrom with a NULL 534 from parameter. 535 */ 536 PRE_MEM_READ( "socketcall.recv(args)", ARG2, 4*sizeof(Addr) ); 537 ML_(generic_PRE_sys_recv)( tid, ARG2_0, ARG2_1, ARG2_2 ); 538 break; 539 540 case VKI_SYS_CONNECT: 541 /* int connect(int sockfd, 542 struct sockaddr *serv_addr, int addrlen ); */ 543 PRE_MEM_READ( "socketcall.connect(args)", ARG2, 3*sizeof(Addr) ); 544 ML_(generic_PRE_sys_connect)( tid, ARG2_0, ARG2_1, ARG2_2 ); 545 break; 546 547 case VKI_SYS_SETSOCKOPT: 548 /* int setsockopt(int s, int level, int optname, 549 const void *optval, int optlen); */ 550 PRE_MEM_READ( "socketcall.setsockopt(args)", ARG2, 5*sizeof(Addr) ); 551 ML_(generic_PRE_sys_setsockopt)( tid, ARG2_0, ARG2_1, ARG2_2, 552 ARG2_3, ARG2_4 ); 553 break; 554 555 case VKI_SYS_GETSOCKOPT: 556 /* int getsockopt(int s, int level, int optname, 557 void *optval, socklen_t *optlen); */ 558 PRE_MEM_READ( "socketcall.getsockopt(args)", ARG2, 5*sizeof(Addr) ); 559 ML_(linux_PRE_sys_getsockopt)( tid, ARG2_0, ARG2_1, ARG2_2, 560 ARG2_3, ARG2_4 ); 561 break; 562 563 case VKI_SYS_GETSOCKNAME: 564 /* int getsockname(int s, struct sockaddr* name, int* namelen) */ 565 PRE_MEM_READ( "socketcall.getsockname(args)", ARG2, 3*sizeof(Addr) ); 566 ML_(generic_PRE_sys_getsockname)( tid, ARG2_0, ARG2_1, ARG2_2 ); 567 break; 568 569 case VKI_SYS_GETPEERNAME: 570 /* int getpeername(int s, struct sockaddr* name, int* namelen) */ 571 PRE_MEM_READ( "socketcall.getpeername(args)", ARG2, 3*sizeof(Addr) ); 572 ML_(generic_PRE_sys_getpeername)( tid, ARG2_0, ARG2_1, ARG2_2 ); 573 break; 574 575 case VKI_SYS_SHUTDOWN: 576 /* int shutdown(int s, int how); */ 577 PRE_MEM_READ( "socketcall.shutdown(args)", ARG2, 2*sizeof(Addr) ); 578 break; 579 580 case VKI_SYS_SENDMSG: { 581 /* int sendmsg(int s, const struct msghdr *msg, int flags); */ 582 583 /* this causes warnings, and I don't get why. glibc bug? 584 * (after all it's glibc providing the arguments array) 585 PRE_MEM_READ( "socketcall.sendmsg(args)", ARG2, 3*sizeof(Addr) ); 586 */ 587 ML_(generic_PRE_sys_sendmsg)( tid, "msg", (struct vki_msghdr *)ARG2_1 ); 588 break; 589 } 590 591 case VKI_SYS_RECVMSG: { 592 /* int recvmsg(int s, struct msghdr *msg, int flags); */ 593 594 /* this causes warnings, and I don't get why. glibc bug? 595 * (after all it's glibc providing the arguments array) 596 PRE_MEM_READ("socketcall.recvmsg(args)", ARG2, 3*sizeof(Addr) ); 597 */ 598 ML_(generic_PRE_sys_recvmsg)( tid, "msg", (struct vki_msghdr *)ARG2_1 ); 599 break; 600 } 601 602 default: 603 VG_(message)(Vg_DebugMsg,"Warning: unhandled socketcall 0x%lx\n",ARG1); 604 SET_STATUS_Failure( VKI_EINVAL ); 605 break; 606 } 607 # undef ARG2_0 608 # undef ARG2_1 609 # undef ARG2_2 610 # undef ARG2_3 611 # undef ARG2_4 612 # undef ARG2_5 613 } 614 615 POST(sys_socketcall) 616 { 617 # define ARG2_0 (((UWord*)ARG2)[0]) 618 # define ARG2_1 (((UWord*)ARG2)[1]) 619 # define ARG2_2 (((UWord*)ARG2)[2]) 620 # define ARG2_3 (((UWord*)ARG2)[3]) 621 # define ARG2_4 (((UWord*)ARG2)[4]) 622 # define ARG2_5 (((UWord*)ARG2)[5]) 623 624 SysRes r; 625 vg_assert(SUCCESS); 626 switch (ARG1 /* request */) { 627 628 case VKI_SYS_SOCKETPAIR: 629 r = ML_(generic_POST_sys_socketpair)( 630 tid, VG_(mk_SysRes_Success)(RES), 631 ARG2_0, ARG2_1, ARG2_2, ARG2_3 632 ); 633 SET_STATUS_from_SysRes(r); 634 break; 635 636 case VKI_SYS_SOCKET: 637 r = ML_(generic_POST_sys_socket)( tid, VG_(mk_SysRes_Success)(RES) ); 638 SET_STATUS_from_SysRes(r); 639 break; 640 641 case VKI_SYS_BIND: 642 /* int bind(int sockfd, struct sockaddr *my_addr, 643 int addrlen); */ 644 break; 645 646 case VKI_SYS_LISTEN: 647 /* int listen(int s, int backlog); */ 648 break; 649 650 case VKI_SYS_ACCEPT: 651 case VKI_SYS_ACCEPT4: 652 /* int accept(int s, struct sockaddr *addr, int *addrlen); */ 653 /* int accept4(int s, struct sockaddr *addr, int *addrlen, int flags); */ 654 r = ML_(generic_POST_sys_accept)( tid, VG_(mk_SysRes_Success)(RES), 655 ARG2_0, ARG2_1, ARG2_2 ); 656 SET_STATUS_from_SysRes(r); 657 break; 658 659 case VKI_SYS_SENDTO: 660 break; 661 662 case VKI_SYS_SEND: 663 break; 664 665 case VKI_SYS_RECVFROM: 666 ML_(generic_POST_sys_recvfrom)( tid, VG_(mk_SysRes_Success)(RES), 667 ARG2_0, ARG2_1, ARG2_2, 668 ARG2_3, ARG2_4, ARG2_5 ); 669 break; 670 671 case VKI_SYS_RECV: 672 ML_(generic_POST_sys_recv)( tid, RES, ARG2_0, ARG2_1, ARG2_2 ); 673 break; 674 675 case VKI_SYS_CONNECT: 676 break; 677 678 case VKI_SYS_SETSOCKOPT: 679 break; 680 681 case VKI_SYS_GETSOCKOPT: 682 ML_(linux_POST_sys_getsockopt)( tid, VG_(mk_SysRes_Success)(RES), 683 ARG2_0, ARG2_1, 684 ARG2_2, ARG2_3, ARG2_4 ); 685 break; 686 687 case VKI_SYS_GETSOCKNAME: 688 ML_(generic_POST_sys_getsockname)( tid, VG_(mk_SysRes_Success)(RES), 689 ARG2_0, ARG2_1, ARG2_2 ); 690 break; 691 692 case VKI_SYS_GETPEERNAME: 693 ML_(generic_POST_sys_getpeername)( tid, VG_(mk_SysRes_Success)(RES), 694 ARG2_0, ARG2_1, ARG2_2 ); 695 break; 696 697 case VKI_SYS_SHUTDOWN: 698 break; 699 700 case VKI_SYS_SENDMSG: 701 break; 702 703 case VKI_SYS_RECVMSG: 704 ML_(generic_POST_sys_recvmsg)( tid, "msg", (struct vki_msghdr *)ARG2_1, RES ); 705 break; 706 707 default: 708 VG_(message)(Vg_DebugMsg,"FATAL: unhandled socketcall 0x%lx\n",ARG1); 709 VG_(core_panic)("... bye!\n"); 710 break; /*NOTREACHED*/ 711 } 712 # undef ARG2_0 713 # undef ARG2_1 714 # undef ARG2_2 715 # undef ARG2_3 716 # undef ARG2_4 717 # undef ARG2_5 718 } 719 720 PRE(sys_mmap) 721 { 722 SysRes r; 723 724 PRINT("sys_mmap ( %#lx, %llu, %ld, %ld, %ld, %ld )", 725 ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 ); 726 PRE_REG_READ6(long, "mmap", 727 unsigned long, start, unsigned long, length, 728 unsigned long, prot, unsigned long, flags, 729 unsigned long, fd, unsigned long, offset); 730 731 r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5, 732 (Off64T)ARG6 ); 733 SET_STATUS_from_SysRes(r); 734 } 735 736 //zz PRE(sys_mmap2) 737 //zz { 738 //zz SysRes r; 739 //zz 740 //zz // Exactly like old_mmap() except: 741 //zz // - the file offset is specified in 4K units rather than bytes, 742 //zz // so that it can be used for files bigger than 2^32 bytes. 743 //zz PRINT("sys_mmap2 ( %p, %llu, %d, %d, %d, %d )", 744 //zz ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 ); 745 //zz PRE_REG_READ6(long, "mmap2", 746 //zz unsigned long, start, unsigned long, length, 747 //zz unsigned long, prot, unsigned long, flags, 748 //zz unsigned long, fd, unsigned long, offset); 749 //zz 750 //zz r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5, 751 //zz 4096 * (Off64T)ARG6 ); 752 //zz SET_STATUS_from_SysRes(r); 753 //zz } 754 //zz 755 //zz // XXX: lstat64/fstat64/stat64 are generic, but not necessarily 756 //zz // applicable to every architecture -- I think only to 32-bit archs. 757 //zz // We're going to need something like linux/core_os32.h for such 758 //zz // things, eventually, I think. --njn 759 //zz PRE(sys_stat64) 760 //zz { 761 //zz PRINT("sys_stat64 ( %p, %p )",ARG1,ARG2); 762 //zz PRE_REG_READ2(long, "stat64", char *, file_name, struct stat64 *, buf); 763 //zz PRE_MEM_RASCIIZ( "stat64(file_name)", ARG1 ); 764 //zz PRE_MEM_WRITE( "stat64(buf)", ARG2, sizeof(struct vki_stat64) ); 765 //zz } 766 //zz 767 //zz POST(sys_stat64) 768 //zz { 769 //zz POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) ); 770 //zz } 771 //zz 772 //zz PRE(sys_lstat64) 773 //zz { 774 //zz PRINT("sys_lstat64 ( %p(%s), %p )",ARG1,ARG1,ARG2); 775 //zz PRE_REG_READ2(long, "lstat64", char *, file_name, struct stat64 *, buf); 776 //zz PRE_MEM_RASCIIZ( "lstat64(file_name)", ARG1 ); 777 //zz PRE_MEM_WRITE( "lstat64(buf)", ARG2, sizeof(struct vki_stat64) ); 778 //zz } 779 //zz 780 //zz POST(sys_lstat64) 781 //zz { 782 //zz vg_assert(SUCCESS); 783 //zz if (RES == 0) { 784 //zz POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) ); 785 //zz } 786 //zz } 787 //zz 788 //zz PRE(sys_fstat64) 789 //zz { 790 //zz PRINT("sys_fstat64 ( %d, %p )",ARG1,ARG2); 791 //zz PRE_REG_READ2(long, "fstat64", unsigned long, fd, struct stat64 *, buf); 792 //zz PRE_MEM_WRITE( "fstat64(buf)", ARG2, sizeof(struct vki_stat64) ); 793 //zz } 794 //zz 795 //zz POST(sys_fstat64) 796 //zz { 797 //zz POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) ); 798 //zz } 799 800 static Addr deref_Addr ( ThreadId tid, Addr a, Char* s ) 801 { 802 Addr* a_p = (Addr*)a; 803 PRE_MEM_READ( s, (Addr)a_p, sizeof(Addr) ); 804 return *a_p; 805 } 806 807 PRE(sys_ipc) 808 { 809 PRINT("sys_ipc ( %ld, %ld, %ld, %ld, %#lx, %ld )", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6); 810 // XXX: this is simplistic -- some args are not used in all circumstances. 811 PRE_REG_READ6(int, "ipc", 812 vki_uint, call, int, first, int, second, int, third, 813 void *, ptr, long, fifth) 814 815 switch (ARG1 /* call */) { 816 case VKI_SEMOP: 817 ML_(generic_PRE_sys_semop)( tid, ARG2, ARG5, ARG3 ); 818 *flags |= SfMayBlock; 819 break; 820 case VKI_SEMGET: 821 break; 822 case VKI_SEMCTL: 823 { 824 UWord arg = deref_Addr( tid, ARG5, "semctl(arg)" ); 825 ML_(generic_PRE_sys_semctl)( tid, ARG2, ARG3, ARG4, arg ); 826 break; 827 } 828 case VKI_SEMTIMEDOP: 829 ML_(generic_PRE_sys_semtimedop)( tid, ARG2, ARG5, ARG3, ARG6 ); 830 *flags |= SfMayBlock; 831 break; 832 case VKI_MSGSND: 833 ML_(linux_PRE_sys_msgsnd)( tid, ARG2, ARG5, ARG3, ARG4 ); 834 if ((ARG4 & VKI_IPC_NOWAIT) == 0) 835 *flags |= SfMayBlock; 836 break; 837 case VKI_MSGRCV: 838 { 839 Addr msgp; 840 Word msgtyp; 841 842 msgp = deref_Addr( tid, 843 (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgp), 844 "msgrcv(msgp)" ); 845 msgtyp = deref_Addr( tid, 846 (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgtyp), 847 "msgrcv(msgp)" ); 848 849 ML_(linux_PRE_sys_msgrcv)( tid, ARG2, msgp, ARG3, msgtyp, ARG4 ); 850 851 if ((ARG4 & VKI_IPC_NOWAIT) == 0) 852 *flags |= SfMayBlock; 853 break; 854 } 855 case VKI_MSGGET: 856 break; 857 case VKI_MSGCTL: 858 ML_(linux_PRE_sys_msgctl)( tid, ARG2, ARG3, ARG5 ); 859 break; 860 case VKI_SHMAT: 861 { 862 UWord w; 863 PRE_MEM_WRITE( "shmat(raddr)", ARG4, sizeof(Addr) ); 864 w = ML_(generic_PRE_sys_shmat)( tid, ARG2, ARG5, ARG3 ); 865 if (w == 0) 866 SET_STATUS_Failure( VKI_EINVAL ); 867 else 868 ARG5 = w; 869 break; 870 } 871 case VKI_SHMDT: 872 if (!ML_(generic_PRE_sys_shmdt)(tid, ARG5)) 873 SET_STATUS_Failure( VKI_EINVAL ); 874 break; 875 case VKI_SHMGET: 876 break; 877 case VKI_SHMCTL: /* IPCOP_shmctl */ 878 ML_(generic_PRE_sys_shmctl)( tid, ARG2, ARG3, ARG5 ); 879 break; 880 default: 881 VG_(message)(Vg_DebugMsg, "FATAL: unhandled syscall(ipc) %ld\n", ARG1 ); 882 VG_(core_panic)("... bye!\n"); 883 break; /*NOTREACHED*/ 884 } 885 } 886 887 POST(sys_ipc) 888 { 889 vg_assert(SUCCESS); 890 switch (ARG1 /* call */) { 891 case VKI_SEMOP: 892 case VKI_SEMGET: 893 break; 894 case VKI_SEMCTL: 895 { 896 UWord arg = deref_Addr( tid, ARG5, "semctl(arg)" ); 897 ML_(generic_PRE_sys_semctl)( tid, ARG2, ARG3, ARG4, arg ); 898 break; 899 } 900 case VKI_SEMTIMEDOP: 901 case VKI_MSGSND: 902 break; 903 case VKI_MSGRCV: 904 { 905 Addr msgp; 906 Word msgtyp; 907 908 msgp = deref_Addr( tid, 909 (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgp), 910 "msgrcv(msgp)" ); 911 msgtyp = deref_Addr( tid, 912 (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgtyp), 913 "msgrcv(msgp)" ); 914 915 ML_(linux_POST_sys_msgrcv)( tid, RES, ARG2, msgp, ARG3, msgtyp, ARG4 ); 916 break; 917 } 918 case VKI_MSGGET: 919 break; 920 case VKI_MSGCTL: 921 ML_(linux_POST_sys_msgctl)( tid, RES, ARG2, ARG3, ARG5 ); 922 break; 923 case VKI_SHMAT: 924 { 925 Addr addr; 926 927 /* force readability. before the syscall it is 928 * indeed uninitialized, as can be seen in 929 * glibc/sysdeps/unix/sysv/linux/shmat.c */ 930 POST_MEM_WRITE( ARG4, sizeof( Addr ) ); 931 932 addr = deref_Addr ( tid, ARG4, "shmat(addr)" ); 933 ML_(generic_POST_sys_shmat)( tid, addr, ARG2, ARG5, ARG3 ); 934 break; 935 } 936 case VKI_SHMDT: 937 ML_(generic_POST_sys_shmdt)( tid, RES, ARG5 ); 938 break; 939 case VKI_SHMGET: 940 break; 941 case VKI_SHMCTL: 942 ML_(generic_POST_sys_shmctl)( tid, RES, ARG2, ARG3, ARG5 ); 943 break; 944 default: 945 VG_(message)(Vg_DebugMsg, 946 "FATAL: unhandled syscall(ipc) %ld\n", 947 ARG1 ); 948 VG_(core_panic)("... bye!\n"); 949 break; /*NOTREACHED*/ 950 } 951 } 952 953 PRE(sys_clone) 954 { 955 UInt cloneflags; 956 957 PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5); 958 PRE_REG_READ5(int, "clone", 959 unsigned long, flags, 960 void *, child_stack, 961 int *, parent_tidptr, 962 void *, child_tls, 963 int *, child_tidptr); 964 965 if (ARG1 & VKI_CLONE_PARENT_SETTID) { 966 PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int)); 967 if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int), 968 VKI_PROT_WRITE)) { 969 SET_STATUS_Failure( VKI_EFAULT ); 970 return; 971 } 972 } 973 if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) { 974 PRE_MEM_WRITE("clone(child_tidptr)", ARG5, sizeof(Int)); 975 if (!VG_(am_is_valid_for_client)(ARG5, sizeof(Int), 976 VKI_PROT_WRITE)) { 977 SET_STATUS_Failure( VKI_EFAULT ); 978 return; 979 } 980 } 981 982 cloneflags = ARG1; 983 984 if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) { 985 SET_STATUS_Failure( VKI_EINVAL ); 986 return; 987 } 988 989 /* Only look at the flags we really care about */ 990 switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS 991 | VKI_CLONE_FILES | VKI_CLONE_VFORK)) { 992 case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES: 993 /* thread creation */ 994 SET_STATUS_from_SysRes( 995 do_clone(tid, 996 ARG1, /* flags */ 997 (Addr)ARG2, /* child SP */ 998 (Int *)ARG3, /* parent_tidptr */ 999 (Int *)ARG5, /* child_tidptr */ 1000 (Addr)ARG4)); /* child_tls */ 1001 break; 1002 1003 case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */ 1004 /* FALLTHROUGH - assume vfork == fork */ 1005 cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM); 1006 1007 case 0: /* plain fork */ 1008 SET_STATUS_from_SysRes( 1009 ML_(do_fork_clone)(tid, 1010 cloneflags, /* flags */ 1011 (Int *)ARG3, /* parent_tidptr */ 1012 (Int *)ARG5)); /* child_tidptr */ 1013 break; 1014 1015 default: 1016 /* should we just ENOSYS? */ 1017 VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG1); 1018 VG_(message)(Vg_UserMsg, "\n"); 1019 VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n"); 1020 VG_(message)(Vg_UserMsg, " - via a threads library (LinuxThreads or NPTL)\n"); 1021 VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork\n"); 1022 VG_(unimplemented) 1023 ("Valgrind does not support general clone()."); 1024 } 1025 1026 if (SUCCESS) { 1027 if (ARG1 & VKI_CLONE_PARENT_SETTID) 1028 POST_MEM_WRITE(ARG3, sizeof(Int)); 1029 if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) 1030 POST_MEM_WRITE(ARG5, sizeof(Int)); 1031 1032 /* Thread creation was successful; let the child have the chance 1033 to run */ 1034 *flags |= SfYieldAfter; 1035 } 1036 } 1037 1038 PRE(sys_fadvise64) 1039 { 1040 PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", ARG1,ARG2,ARG3,ARG4); 1041 PRE_REG_READ4(long, "fadvise64", 1042 int, fd, vki_loff_t, offset, vki_size_t, len, int, advice); 1043 } 1044 1045 PRE(sys_rt_sigreturn) 1046 { 1047 /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for 1048 an explanation of what follows. */ 1049 1050 //ThreadState* tst; 1051 PRINT("sys_rt_sigreturn ( )"); 1052 1053 vg_assert(VG_(is_valid_tid)(tid)); 1054 vg_assert(tid >= 1 && tid < VG_N_THREADS); 1055 vg_assert(VG_(is_running_thread)(tid)); 1056 1057 ///* Adjust esp to point to start of frame; skip back up over handler 1058 // ret addr */ 1059 //tst = VG_(get_ThreadState)(tid); 1060 //tst->arch.vex.guest_ESP -= sizeof(Addr); 1061 // Should we do something equivalent on ppc64-linux? Who knows. 1062 1063 ///* This is only so that the EIP is (might be) useful to report if 1064 // something goes wrong in the sigreturn */ 1065 //ML_(fixup_guest_state_to_restart_syscall)(&tst->arch); 1066 // Should we do something equivalent on ppc64? Who knows. 1067 1068 /* Restore register state from frame and remove it */ 1069 VG_(sigframe_destroy)(tid, True); 1070 1071 /* Tell the driver not to update the guest state with the "result", 1072 and set a bogus result to keep it happy. */ 1073 *flags |= SfNoWriteResult; 1074 SET_STATUS_Success(0); 1075 1076 /* Check to see if any signals arose as a result of this. */ 1077 *flags |= SfPollAfter; 1078 } 1079 1080 #undef PRE 1081 #undef POST 1082 1083 /* --------------------------------------------------------------------- 1084 The ppc64/Linux syscall table 1085 ------------------------------------------------------------------ */ 1086 1087 /* Add an ppc64-linux specific wrapper to a syscall table. */ 1088 #define PLAX_(sysno, name) WRAPPER_ENTRY_X_(ppc64_linux, sysno, name) 1089 #define PLAXY(sysno, name) WRAPPER_ENTRY_XY(ppc64_linux, sysno, name) 1090 1091 // This table maps from __NR_xxx syscall numbers (from 1092 // linux/include/asm-ppc/unistd.h) to the appropriate PRE/POST sys_foo() 1093 // wrappers on ppc64 (as per sys_call_table in linux/arch/ppc/kernel/entry.S). 1094 // 1095 // For those syscalls not handled by Valgrind, the annotation indicate its 1096 // arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/? 1097 // (unknown). 1098 1099 static SyscallTableEntry syscall_table[] = { 1100 // _____(__NR_restart_syscall, sys_restart_syscall), // 0 1101 GENX_(__NR_exit, sys_exit), // 1 1102 GENX_(__NR_fork, sys_fork), // 2 1103 GENXY(__NR_read, sys_read), // 3 1104 GENX_(__NR_write, sys_write), // 4 1105 1106 GENXY(__NR_open, sys_open), // 5 1107 GENXY(__NR_close, sys_close), // 6 1108 GENXY(__NR_waitpid, sys_waitpid), // 7 1109 GENXY(__NR_creat, sys_creat), // 8 1110 GENX_(__NR_link, sys_link), // 9 1111 1112 GENX_(__NR_unlink, sys_unlink), // 10 1113 GENX_(__NR_execve, sys_execve), // 11 1114 GENX_(__NR_chdir, sys_chdir), // 12 1115 GENXY(__NR_time, sys_time), // 13 1116 GENX_(__NR_mknod, sys_mknod), // 14 1117 1118 GENX_(__NR_chmod, sys_chmod), // 15 1119 GENX_(__NR_lchown, sys_lchown), // 16 1120 // _____(__NR_break, sys_break), // 17 1121 // _____(__NR_oldstat, sys_oldstat), // 18 1122 LINX_(__NR_lseek, sys_lseek), // 19 1123 1124 GENX_(__NR_getpid, sys_getpid), // 20 1125 LINX_(__NR_mount, sys_mount), // 21 1126 // _____(__NR_umount, sys_umount), // 22 1127 GENX_(__NR_setuid, sys_setuid), // 23 1128 GENX_(__NR_getuid, sys_getuid), // 24 1129 1130 // _____(__NR_stime, sys_stime), // 25 1131 // _____(__NR_ptrace, sys_ptrace), // 26 1132 GENX_(__NR_alarm, sys_alarm), // 27 1133 // _____(__NR_oldfstat, sys_oldfstat), // 28 1134 GENX_(__NR_pause, sys_pause), // 29 1135 1136 LINX_(__NR_utime, sys_utime), // 30 1137 // _____(__NR_stty, sys_stty), // 31 1138 // _____(__NR_gtty, sys_gtty), // 32 1139 GENX_(__NR_access, sys_access), // 33 1140 // _____(__NR_nice, sys_nice), // 34 1141 1142 // _____(__NR_ftime, sys_ftime), // 35 1143 // _____(__NR_sync, sys_sync), // 36 1144 GENX_(__NR_kill, sys_kill), // 37 1145 GENX_(__NR_rename, sys_rename), // 38 1146 GENX_(__NR_mkdir, sys_mkdir), // 39 1147 1148 GENX_(__NR_rmdir, sys_rmdir), // 40 1149 GENXY(__NR_dup, sys_dup), // 41 1150 LINXY(__NR_pipe, sys_pipe), // 42 1151 GENXY(__NR_times, sys_times), // 43 1152 // _____(__NR_prof, sys_prof), // 44 1153 1154 GENX_(__NR_brk, sys_brk), // 45 1155 GENX_(__NR_setgid, sys_setgid), // 46 1156 GENX_(__NR_getgid, sys_getgid), // 47 1157 // _____(__NR_signal, sys_signal), // 48 1158 GENX_(__NR_geteuid, sys_geteuid), // 49 1159 1160 GENX_(__NR_getegid, sys_getegid), // 50 1161 // _____(__NR_acct, sys_acct), // 51 1162 LINX_(__NR_umount2, sys_umount), // 52 1163 // _____(__NR_lock, sys_lock), // 53 1164 LINXY(__NR_ioctl, sys_ioctl), // 54 1165 1166 LINXY(__NR_fcntl, sys_fcntl), // 55 1167 // _____(__NR_mpx, sys_mpx), // 56 1168 GENX_(__NR_setpgid, sys_setpgid), // 57 1169 // _____(__NR_ulimit, sys_ulimit), // 58 1170 // _____(__NR_oldolduname, sys_oldolduname), // 59 1171 1172 GENX_(__NR_umask, sys_umask), // 60 1173 GENX_(__NR_chroot, sys_chroot), // 61 1174 // _____(__NR_ustat, sys_ustat), // 62 1175 GENXY(__NR_dup2, sys_dup2), // 63 1176 GENX_(__NR_getppid, sys_getppid), // 64 1177 1178 GENX_(__NR_getpgrp, sys_getpgrp), // 65 1179 GENX_(__NR_setsid, sys_setsid), // 66 1180 // _____(__NR_sigaction, sys_sigaction), // 67 1181 // _____(__NR_sgetmask, sys_sgetmask), // 68 1182 // _____(__NR_ssetmask, sys_ssetmask), // 69 1183 1184 GENX_(__NR_setreuid, sys_setreuid), // 70 1185 GENX_(__NR_setregid, sys_setregid), // 71 1186 // _____(__NR_sigsuspend, sys_sigsuspend), // 72 1187 // _____(__NR_sigpending, sys_sigpending), // 73 1188 // _____(__NR_sethostname, sys_sethostname), // 74 1189 1190 GENX_(__NR_setrlimit, sys_setrlimit), // 75 1191 // _____(__NR_getrlimit, sys_getrlimit), // 76 1192 GENXY(__NR_getrusage, sys_getrusage), // 77 1193 GENXY(__NR_gettimeofday, sys_gettimeofday), // 78 1194 // _____(__NR_settimeofday, sys_settimeofday), // 79 1195 1196 GENXY(__NR_getgroups, sys_getgroups), // 80 1197 GENX_(__NR_setgroups, sys_setgroups), // 81 1198 // _____(__NR_select, sys_select), // 82 1199 GENX_(__NR_symlink, sys_symlink), // 83 1200 // _____(__NR_oldlstat, sys_oldlstat), // 84 1201 1202 GENX_(__NR_readlink, sys_readlink), // 85 1203 // _____(__NR_uselib, sys_uselib), // 86 1204 // _____(__NR_swapon, sys_swapon), // 87 1205 // _____(__NR_reboot, sys_reboot), // 88 1206 // _____(__NR_readdir, sys_readdir), // 89 1207 1208 PLAX_(__NR_mmap, sys_mmap), // 90 1209 GENXY(__NR_munmap, sys_munmap), // 91 1210 GENX_(__NR_truncate, sys_truncate), // 92 1211 GENX_(__NR_ftruncate, sys_ftruncate), // 93 1212 GENX_(__NR_fchmod, sys_fchmod), // 94 1213 1214 GENX_(__NR_fchown, sys_fchown), // 95 1215 // _____(__NR_getpriority, sys_getpriority), // 96 1216 // _____(__NR_setpriority, sys_setpriority), // 97 1217 // _____(__NR_profil, sys_profil), // 98 1218 GENXY(__NR_statfs, sys_statfs), // 99 1219 1220 GENXY(__NR_fstatfs, sys_fstatfs), // 100 1221 // _____(__NR_ioperm, sys_ioperm), // 101 1222 PLAXY(__NR_socketcall, sys_socketcall), // 102 1223 LINXY(__NR_syslog, sys_syslog), // 103 1224 GENXY(__NR_setitimer, sys_setitimer), // 104 1225 1226 GENXY(__NR_getitimer, sys_getitimer), // 105 1227 GENXY(__NR_stat, sys_newstat), // 106 1228 GENXY(__NR_lstat, sys_newlstat), // 107 1229 GENXY(__NR_fstat, sys_newfstat), // 108 1230 // _____(__NR_olduname, sys_olduname), // 109 1231 1232 // _____(__NR_iopl, sys_iopl), // 110 1233 LINX_(__NR_vhangup, sys_vhangup), // 111 1234 // _____(__NR_idle, sys_idle), // 112 1235 // _____(__NR_vm86, sys_vm86), // 113 1236 GENXY(__NR_wait4, sys_wait4), // 114 1237 1238 // _____(__NR_swapoff, sys_swapoff), // 115 1239 LINXY(__NR_sysinfo, sys_sysinfo), // 116 1240 PLAXY(__NR_ipc, sys_ipc), // 117 1241 GENX_(__NR_fsync, sys_fsync), // 118 1242 // _____(__NR_sigreturn, sys_sigreturn), // 119 1243 1244 PLAX_(__NR_clone, sys_clone), // 120 1245 // _____(__NR_setdomainname, sys_setdomainname), // 121 1246 GENXY(__NR_uname, sys_newuname), // 122 1247 // _____(__NR_modify_ldt, sys_modify_ldt), // 123 1248 LINXY(__NR_adjtimex, sys_adjtimex), // 124 1249 1250 GENXY(__NR_mprotect, sys_mprotect), // 125 1251 // _____(__NR_sigprocmask, sys_sigprocmask), // 126 1252 GENX_(__NR_create_module, sys_ni_syscall), // 127 1253 LINX_(__NR_init_module, sys_init_module), // 128 1254 LINX_(__NR_delete_module, sys_delete_module), // 129 1255 1256 // _____(__NR_get_kernel_syms, sys_get_kernel_syms), // 130 1257 // _____(__NR_quotactl, sys_quotactl), // 131 1258 GENX_(__NR_getpgid, sys_getpgid), // 132 1259 GENX_(__NR_fchdir, sys_fchdir), // 133 1260 // _____(__NR_bdflush, sys_bdflush), // 134 1261 1262 // _____(__NR_sysfs, sys_sysfs), // 135 1263 LINX_(__NR_personality, sys_personality), // 136 1264 // _____(__NR_afs_syscall, sys_afs_syscall), // 137 1265 LINX_(__NR_setfsuid, sys_setfsuid), // 138 1266 LINX_(__NR_setfsgid, sys_setfsgid), // 139 1267 1268 LINXY(__NR__llseek, sys_llseek), // 140 1269 GENXY(__NR_getdents, sys_getdents), // 141 1270 GENX_(__NR__newselect, sys_select), // 142 1271 GENX_(__NR_flock, sys_flock), // 143 1272 GENX_(__NR_msync, sys_msync), // 144 1273 1274 GENXY(__NR_readv, sys_readv), // 145 1275 GENX_(__NR_writev, sys_writev), // 146 1276 // _____(__NR_getsid, sys_getsid), // 147 1277 GENX_(__NR_fdatasync, sys_fdatasync), // 148 1278 LINXY(__NR__sysctl, sys_sysctl), // 149 1279 1280 GENX_(__NR_mlock, sys_mlock), // 150 1281 GENX_(__NR_munlock, sys_munlock), // 151 1282 GENX_(__NR_mlockall, sys_mlockall), // 152 1283 LINX_(__NR_munlockall, sys_munlockall), // 153 1284 LINXY(__NR_sched_setparam, sys_sched_setparam), // 154 1285 1286 LINXY(__NR_sched_getparam, sys_sched_getparam), // 155 1287 LINX_(__NR_sched_setscheduler, sys_sched_setscheduler), // 156 1288 LINX_(__NR_sched_getscheduler, sys_sched_getscheduler), // 157 1289 LINX_(__NR_sched_yield, sys_sched_yield), // 158 1290 LINX_(__NR_sched_get_priority_max, sys_sched_get_priority_max),// 159 1291 1292 LINX_(__NR_sched_get_priority_min, sys_sched_get_priority_min),// 160 1293 LINXY(__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 161 1294 GENXY(__NR_nanosleep, sys_nanosleep), // 162 1295 GENX_(__NR_mremap, sys_mremap), // 163 1296 LINX_(__NR_setresuid, sys_setresuid), // 164 1297 1298 LINXY(__NR_getresuid, sys_getresuid), // 165 1299 // _____(__NR_query_module, sys_query_module), // 166 1300 GENXY(__NR_poll, sys_poll), // 167 1301 // _____(__NR_nfsservctl, sys_nfsservctl), // 168 1302 LINX_(__NR_setresgid, sys_setresgid), // 169 1303 1304 LINXY(__NR_getresgid, sys_getresgid), // 170 1305 // _____(__NR_prctl, sys_prctl), // 171 1306 PLAX_(__NR_rt_sigreturn, sys_rt_sigreturn), // 172 1307 LINXY(__NR_rt_sigaction, sys_rt_sigaction), // 173 1308 LINXY(__NR_rt_sigprocmask, sys_rt_sigprocmask), // 174 1309 1310 // _____(__NR_rt_sigpending, sys_rt_sigpending), // 175 1311 LINXY(__NR_rt_sigtimedwait, sys_rt_sigtimedwait), // 176 1312 LINXY(__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo), // 177 1313 // _____(__NR_rt_sigsuspend, sys_rt_sigsuspend), // 178 1314 GENXY(__NR_pread64, sys_pread64), // 179 1315 1316 GENX_(__NR_pwrite64, sys_pwrite64), // 180 1317 GENX_(__NR_chown, sys_chown), // 181 1318 GENXY(__NR_getcwd, sys_getcwd), // 182 1319 LINXY(__NR_capget, sys_capget), // 183 1320 LINX_(__NR_capset, sys_capset), // 184 1321 1322 GENXY(__NR_sigaltstack, sys_sigaltstack), // 185 1323 LINXY(__NR_sendfile, sys_sendfile), // 186 1324 // _____(__NR_getpmsg, sys_getpmsg), // 187 1325 // _____(__NR_putpmsg, sys_putpmsg), // 188 1326 GENX_(__NR_vfork, sys_fork), // 189 treat as fork 1327 1328 GENXY(__NR_ugetrlimit, sys_getrlimit), // 190 1329 LINX_(__NR_readahead, sys_readahead), // 191 1330 // /* #define __NR_mmap2 192 32bit only */ 1331 // /* #define __NR_truncate64 193 32bit only */ 1332 // /* #define __NR_ftruncate64 194 32bit only */ 1333 1334 // /* #define __NR_stat64 195 32bit only */ 1335 // /* #define __NR_lstat64 196 32bit only */ 1336 // /* #define __NR_fstat64 197 32bit only */ 1337 // _____(__NR_pciconfig_read, sys_pciconfig_read), // 198 1338 // _____(__NR_pciconfig_write, sys_pciconfig_write), // 199 1339 1340 // _____(__NR_pciconfig_iobase, sys_pciconfig_iobase), // 200 1341 // _____(__NR_multiplexer, sys_multiplexer), // 201 1342 GENXY(__NR_getdents64, sys_getdents64), // 202 1343 // _____(__NR_pivot_root, sys_pivot_root), // 203 1344 LINXY(__NR_fcntl64, sys_fcntl64), // 204 !!!!?? 32bit only */ 1345 1346 GENX_(__NR_madvise, sys_madvise), // 205 1347 // _____(__NR_mincore, sys_mincore), // 206 1348 LINX_(__NR_gettid, sys_gettid), // 207 1349 // _____(__NR_tkill, sys_tkill), // 208 1350 // _____(__NR_setxattr, sys_setxattr), // 209 1351 1352 // _____(__NR_lsetxattr, sys_lsetxattr), // 210 1353 // _____(__NR_fsetxattr, sys_fsetxattr), // 211 1354 LINXY(__NR_getxattr, sys_getxattr), // 212 1355 LINXY(__NR_lgetxattr, sys_lgetxattr), // 213 1356 LINXY(__NR_fgetxattr, sys_fgetxattr), // 214 1357 LINXY(__NR_listxattr, sys_listxattr), // 215 1358 LINXY(__NR_llistxattr, sys_llistxattr), // 216 1359 LINXY(__NR_flistxattr, sys_flistxattr), // 217 1360 LINX_(__NR_removexattr, sys_removexattr), // 218 1361 LINX_(__NR_lremovexattr, sys_lremovexattr), // 219 1362 LINX_(__NR_fremovexattr, sys_fremovexattr), // 220 1363 1364 LINXY(__NR_futex, sys_futex), // 221 1365 LINX_(__NR_sched_setaffinity, sys_sched_setaffinity), // 222 1366 LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 223 1367 // /* 224 currently unused */ 1368 1369 // _____(__NR_tuxcall, sys_tuxcall), // 225 1370 // /* #define __NR_sendfile64 226 32bit only */ 1371 LINX_(__NR_io_setup, sys_io_setup), // 227 1372 LINX_(__NR_io_destroy, sys_io_destroy), // 228 1373 LINXY(__NR_io_getevents, sys_io_getevents), // 229 1374 LINX_(__NR_io_submit, sys_io_submit), // 230 1375 LINXY(__NR_io_cancel, sys_io_cancel), // 231 1376 LINX_(__NR_set_tid_address, sys_set_tid_address), // 232 1377 PLAX_(__NR_fadvise64, sys_fadvise64), // 233 1378 LINX_(__NR_exit_group, sys_exit_group), // 234 1379 1380 // _____(__NR_lookup_dcookie, sys_lookup_dcookie), // 235 1381 LINXY(__NR_epoll_create, sys_epoll_create), // 236 1382 LINX_(__NR_epoll_ctl, sys_epoll_ctl), // 237 1383 LINXY(__NR_epoll_wait, sys_epoll_wait), // 238 1384 // _____(__NR_remap_file_pages, sys_remap_file_pages), // 239 1385 1386 LINXY(__NR_timer_create, sys_timer_create), // 240 1387 LINXY(__NR_timer_settime, sys_timer_settime), // 241 1388 LINXY(__NR_timer_gettime, sys_timer_gettime), // 242 1389 LINX_(__NR_timer_getoverrun, sys_timer_getoverrun), // 243 1390 LINX_(__NR_timer_delete, sys_timer_delete), // 244 1391 LINX_(__NR_clock_settime, sys_clock_settime), // 245 1392 LINXY(__NR_clock_gettime, sys_clock_gettime), // 246 1393 LINXY(__NR_clock_getres, sys_clock_getres), // 247 1394 LINXY(__NR_clock_nanosleep, sys_clock_nanosleep), // 248 1395 1396 // _____(__NR_swapcontext, sys_swapcontext), // 249 1397 1398 LINXY(__NR_tgkill, sys_tgkill), // 250 1399 // _____(__NR_utimes, sys_utimes), // 251 1400 // _____(__NR_statfs64, sys_statfs64), // 252 1401 // _____(__NR_fstatfs64, sys_fstatfs64), // 253 1402 // /* #define __NR_fadvise64_64 254 32bit only */ 1403 1404 // _____(__NR_rtas, sys_rtas), // 255 1405 // /* Number 256 is reserved for sys_debug_setcontext */ 1406 // /* Number 257 is reserved for vserver */ 1407 // /* 258 currently unused */ 1408 // _____(__NR_mbind, sys_mbind), // 259 1409 1410 // _____(__NR_get_mempolicy, sys_get_mempolicy), // 260 1411 // _____(__NR_set_mempolicy, sys_set_mempolicy), // 261 1412 LINXY(__NR_mq_open, sys_mq_open), // 262 1413 LINX_(__NR_mq_unlink, sys_mq_unlink), // 263 1414 LINX_(__NR_mq_timedsend, sys_mq_timedsend), // 264 1415 1416 LINXY(__NR_mq_timedreceive, sys_mq_timedreceive), // 265 1417 LINX_(__NR_mq_notify, sys_mq_notify), // 266 1418 LINXY(__NR_mq_getsetattr, sys_mq_getsetattr), // 267 1419 // _____(__NR_kexec_load, sys_kexec_load), // 268 1420 LINX_(__NR_add_key, sys_add_key), // 269 1421 1422 LINX_(__NR_request_key, sys_request_key), // 270 1423 LINXY(__NR_keyctl, sys_keyctl), // 271 1424 // _____(__NR_waitid, sys_waitid), // 272 1425 LINX_(__NR_ioprio_set, sys_ioprio_set), // 273 1426 LINX_(__NR_ioprio_get, sys_ioprio_get), // 274 1427 1428 LINX_(__NR_inotify_init, sys_inotify_init), // 275 1429 LINX_(__NR_inotify_add_watch, sys_inotify_add_watch), // 276 1430 LINX_(__NR_inotify_rm_watch, sys_inotify_rm_watch), // 277 1431 1432 LINX_(__NR_pselect6, sys_pselect6), // 280 1433 LINXY(__NR_ppoll, sys_ppoll), // 281 1434 1435 LINXY(__NR_openat, sys_openat), // 286 1436 LINX_(__NR_mkdirat, sys_mkdirat), // 287 1437 LINX_(__NR_mknodat, sys_mknodat), // 288 1438 LINX_(__NR_fchownat, sys_fchownat), // 289 1439 LINX_(__NR_futimesat, sys_futimesat), // 290 1440 LINXY(__NR_newfstatat, sys_newfstatat), // 291 1441 LINX_(__NR_unlinkat, sys_unlinkat), // 292 1442 LINX_(__NR_renameat, sys_renameat), // 293 1443 LINX_(__NR_linkat, sys_linkat), // 294 1444 LINX_(__NR_symlinkat, sys_symlinkat), // 295 1445 LINX_(__NR_readlinkat, sys_readlinkat), // 296 1446 LINX_(__NR_fchmodat, sys_fchmodat), // 297 1447 LINX_(__NR_faccessat, sys_faccessat), // 298 1448 LINX_(__NR_set_robust_list, sys_set_robust_list), // 299 1449 LINXY(__NR_get_robust_list, sys_get_robust_list), // 300 1450 LINXY(__NR_move_pages, sys_move_pages), // 301 1451 LINXY(__NR_getcpu, sys_getcpu), // 302 1452 LINXY(__NR_epoll_pwait, sys_epoll_pwait), // 303 1453 LINX_(__NR_utimensat, sys_utimensat), // 304 1454 LINXY(__NR_signalfd, sys_signalfd), // 305 1455 LINXY(__NR_timerfd_create, sys_timerfd_create), // 306 1456 LINX_(__NR_eventfd, sys_eventfd), // 307 1457 LINX_(__NR_sync_file_range2, sys_sync_file_range2), // 308 1458 LINX_(__NR_fallocate, sys_fallocate), // 309 1459 // LINXY(__NR_subpage_prot, sys_ni_syscall), // 310 1460 LINXY(__NR_timerfd_settime, sys_timerfd_settime), // 311 1461 LINXY(__NR_timerfd_gettime, sys_timerfd_gettime), // 312 1462 LINXY(__NR_signalfd4, sys_signalfd4), // 313 1463 LINX_(__NR_eventfd2, sys_eventfd2), // 314 1464 LINXY(__NR_epoll_create1, sys_epoll_create1), // 315 1465 LINXY(__NR_dup3, sys_dup3), // 316 1466 LINXY(__NR_pipe2, sys_pipe2), // 317 1467 LINXY(__NR_inotify_init1, sys_inotify_init1), // 318 1468 LINXY(__NR_perf_event_open, sys_perf_event_open), // 319 1469 LINXY(__NR_preadv, sys_preadv), // 320 1470 LINX_(__NR_pwritev, sys_pwritev), // 321 1471 LINXY(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo),// 322 1472 1473 LINXY(__NR_process_vm_readv, sys_process_vm_readv), // 351 1474 LINX_(__NR_process_vm_writev, sys_process_vm_writev) // 352 1475 }; 1476 1477 SyscallTableEntry* ML_(get_linux_syscall_entry) ( UInt sysno ) 1478 { 1479 const UInt syscall_table_size 1480 = sizeof(syscall_table) / sizeof(syscall_table[0]); 1481 1482 /* Is it in the contiguous initial section of the table? */ 1483 if (sysno < syscall_table_size) { 1484 SyscallTableEntry* sys = &syscall_table[sysno]; 1485 if (sys->before == NULL) 1486 return NULL; /* no entry */ 1487 else 1488 return sys; 1489 } 1490 1491 /* Can't find a wrapper */ 1492 return NULL; 1493 } 1494 1495 #endif // defined(VGP_ppc64_linux) 1496 1497 /*--------------------------------------------------------------------*/ 1498 /*--- end ---*/ 1499 /*--------------------------------------------------------------------*/ 1500
