l4/pkg/valgrind/src/valgrind-3.6.0-svn/coregrind/m_syswrap/syswrap-ppc64-linux.c

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