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