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