coregrind/m_syswrap/syswrap-mips64-linux.c

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- Platform-specific syscalls stuff.    syswrap-mips64-linux.c ----*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Valgrind, a dynamic binary instrumentation
   8    framework.
   9
  10    Copyright (C) 2010-2013 RT-RK
  11       mips-valgrind@rt-rk.com
  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_mips64_linux)
  32 #include "pub_core_basics.h"
  33 #include "pub_core_vki.h"
  34 #include "pub_core_vkiscnums.h"
  35 #include "pub_core_threadstate.h"
  36 #include "pub_core_aspacemgr.h"
  37 #include "pub_core_debuglog.h"
  38 #include "pub_core_libcbase.h"
  39 #include "pub_core_libcassert.h"
  40 #include "pub_core_libcprint.h"
  41 #include "pub_core_libcproc.h"
  42 #include "pub_core_libcsignal.h"
  43 #include "pub_core_options.h"
  44 #include "pub_core_scheduler.h"
  45 #include "pub_core_sigframe.h"     /* For VG_(sigframe_destroy)() */
  46 #include "pub_core_signals.h"
  47 #include "pub_core_syscall.h"
  48 #include "pub_core_syswrap.h"
  49 #include "pub_core_tooliface.h"
  50 #include "pub_core_transtab.h"     /* VG_(discard_translations) */
  51 #include "priv_types_n_macros.h"
  52 #include "priv_syswrap-generic.h"  /* for decls of generic wrappers */
  53 #include "priv_syswrap-linux.h"    /* for decls of linux-ish wrappers */
  54 #include "priv_syswrap-main.h"
  55
  56 #include "pub_core_debuginfo.h"    /* VG_(di_notify_*) */
  57 #include "pub_core_xarray.h"
  58 #include "pub_core_clientstate.h"  /* VG_(brk_base), VG_(brk_limit) */
  59 #include "pub_core_errormgr.h"
  60 #include "pub_core_gdbserver.h"    /* VG_(gdbserver) */
  61 #include "pub_core_libcfile.h"
  62 #include "pub_core_machine.h"      /* VG_(get_SP) */
  63 #include "pub_core_mallocfree.h"
  64 #include "pub_core_stacktrace.h"   /* For VG_(get_and_pp_StackTrace)() */
  65 #include "pub_core_ume.h"
  66
  67 #include "config.h"
  68
  69 #include <errno.h>
  70
  71 /* ---------------------------------------------------------------------
  72                              clone() handling
  73    ------------------------------------------------------------------ */
  74
  75 /* Call f(arg1), but first switch stacks, using 'stack' as the new stack, and
  76    use 'retaddr' as f's return-to address. Also, clear all the integer registers
  77    before entering f. */
  78 __attribute__ ((noreturn))
  79 void ML_(call_on_new_stack_0_1) ( Addr stack,             /* $4 - $a0 */
  80                                   Addr retaddr,           /* $5 - $a1 */
  81                                   void (*f_desc) (Word),  /* $6 - $a2 */
  82                                   Word arg1 );            /* $7 - $a3 */
  83 asm (
  84 ".text\n"
  85 ".globl vgModuleLocal_call_on_new_stack_0_1\n"
  86 "vgModuleLocal_call_on_new_stack_0_1:\n"
  87 "   move $29, $4\n"  /* set stack */
  88 "   move $4,  $7\n"  /* arg1 to $4 */
  89 "   move $25, $6\n"
  90 "   move $31, $5\n"  /* retaddr to $ra */
  91 "   jr $25\n"        /* jump to f */
  92 "   break 0x7\n"     /* should never get here */
  93 ".previous\n"
  94 );
  95
  96 /* Perform a clone system call.  clone is strange because it has fork()-like
  97    return-twice semantics, so it needs special handling here.
  98
  99    Upon entry, we have:
 100
 101       word (fn)(void*)    in a0 = 4
 102       void* child_stack   in a1 = 5
 103       word flags          in a2 = 6
 104       void* arg           in a3 = 7
 105       pid_t* parent_tid   in a4 = 8
 106       void* tls           in a5 = 9
 107       pid_t* child_tid    in a6 = 10
 108
 109    System call requires:
 110
 111       int    $__NR_clone  in v0
 112       int    flags        in a0 = 4
 113       void*  child_stack  in a1 = 5
 114       pid_t* parent_tid   in a2 = 6
 115       void*  tls_ptr      in a3 = 7
 116       pid_t* child_tid    in a4 = 8 */
 117
 118 #define __NR_CLONE        __NR_clone
 119 #define __NR_EXIT         __NR_exit
 120
 121 ULong do_syscall_clone_mips64_linux ( Word (*fn) (void *),  /* a0 - 4 */
 122                                       void* stack,          /* a1 - 5 */
 123                                       Int   flags,          /* a2 - 6 */
 124                                       void* arg,            /* a3 - 7 */
 125                                       Int*  parent_tid,     /* a4 - 8 */
 126                                       void* /* Int tls */,  /* a5 - 9 */
 127                                       Int*  child_tid );    /* a6 - 10 */
 128
 129 asm(
 130 ".text\n"
 131 ".set noreorder\n"
 132 ".set nomacro\n"
 133 ".globl do_syscall_clone_mips64_linux\n"
 134 "do_syscall_clone_mips64_linux:\n"
 135 "   daddiu $29, $29, -32\n"
 136 "   sd $31, 0($29)\n"
 137 "   sd $30, 8($29)\n"
 138 "   sd $28, 16($29)\n"
 139
 140 "   daddiu  $5, $5, -32\n"
 141 "   sd $4, 0($5)\n"   /* fn */
 142 "   sd $7, 8($5)\n"   /* arg */
 143 "   sd $6, 16($5)\n"  /* flags */
 144
 145 /* 1. arg for syscalls */
 146 "   move $4, $6\n"   /* flags */
 147 "   move $6, $8\n"   /* parent */
 148 "   move $7, $a5\n"  /* tls */
 149 "   move $8, $a6\n"  /* child */
 150
 151 /* 2. do a syscall to clone */
 152 "   li  $2, 5055\n"  /* syscall num for clone */
 153 "   syscall\n"
 154
 155 /* 3. See if we are a child, call fn and after that exit */
 156 "   bnez $7, p_or_error\n"
 157 "   nop\n"
 158
 159 "   bnez $2, p_or_error\n"
 160 "   nop\n"
 161
 162 "   ld $25,0($29)\n"
 163 "   jalr $25\n"
 164 "   ld $4,8($29)\n"
 165
 166 "   move $4, $2\n\t"  /* retval from fn is in $v0 */
 167 "   li $2, 5058\n\t"  /* NR_exit */
 168 "   syscall\n\t"
 169 "   nop\n\t"
 170 /* 4. If we are parent or error, just return to caller */
 171 "   p_or_error:\n"
 172 "   ld $31, 0($29)\n"
 173 "   ld $30, 8($29)\n"
 174 "   ld $28, 16($29)\n"
 175 "   jr $31\n"
 176 "   daddi $29,$29, 32\n"
 177 ".previous\n"
 178 );
 179
 180 #undef __NR_CLONE
 181 #undef __NR_EXIT
 182
 183 /* forward declarations */
 184 static void setup_child ( ThreadArchState *, ThreadArchState *);
 185 static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr);
 186
 187 /* When a client clones, we need to keep track of the new thread. This means:
 188    1. allocate a ThreadId+ThreadState+stack for the thread
 189
 190    2. initialize the thread's new VCPU state
 191
 192    3. create the thread using the same args as the client requested, but using
 193       the scheduler entrypoint for IP, and a separate stack for SP. */
 194 static SysRes do_clone ( ThreadId ptid,
 195                          UInt flags, Addr sp,
 196                          Int* parent_tidptr,
 197                          Int* child_tidptr,
 198                          Addr child_tls )
 199 {
 200    const Bool debug = False;
 201    ThreadId ctid = VG_ (alloc_ThreadState) ();
 202    ThreadState * ptst = VG_ (get_ThreadState) (ptid);
 203    ThreadState * ctst = VG_ (get_ThreadState) (ctid);
 204    UInt ret = 0;
 205    UWord * stack;
 206    SysRes res;
 207    vki_sigset_t blockall, savedmask;
 208
 209    VG_(sigfillset)(&blockall);
 210    vg_assert(VG_(is_running_thread)(ptid));
 211    vg_assert(VG_(is_valid_tid)(ctid));
 212    stack = (UWord *)ML_(allocstack)(ctid);
 213    if (stack == NULL) {
 214       res = VG_(mk_SysRes_Error)(VKI_ENOMEM);
 215       goto out;
 216    }
 217    setup_child(&ctst->arch, &ptst->arch);
 218
 219    /* on MIPS we need to set V0 and A3 to zero */
 220    ctst->arch.vex.guest_r2 = 0;
 221    ctst->arch.vex.guest_r7 = 0;
 222    if (sp != 0)
 223       ctst->arch.vex.guest_r29 = sp;
 224
 225    ctst->os_state.parent = ptid;
 226    ctst->sig_mask = ptst->sig_mask;
 227    ctst->tmp_sig_mask = ptst->sig_mask;
 228
 229    ctst->os_state.threadgroup = ptst->os_state.threadgroup;
 230
 231    ML_(guess_and_register_stack) (sp, ctst);
 232
 233    VG_TRACK(pre_thread_ll_create, ptid, ctid);
 234    if (flags & VKI_CLONE_SETTLS) {
 235        if (debug)
 236          VG_(printf)("clone child has SETTLS: tls at %#lx\n", child_tls);
 237        res = sys_set_tls(ctid, child_tls);
 238        if (sr_isError(res))
 239           goto out;
 240        ctst->arch.vex.guest_r27 = child_tls;
 241    }
 242
 243    flags &= ~VKI_CLONE_SETTLS;
 244    VG_ (sigprocmask) (VKI_SIG_SETMASK, &blockall, &savedmask);
 245    /* Create the new thread */
 246    ret = do_syscall_clone_mips64_linux(ML_(start_thread_NORETURN),
 247                                        stack, flags, &VG_(threads)[ctid],
 248                                        parent_tidptr, NULL /*child_tls*/,
 249                                        child_tidptr);
 250    if (debug)
 251      VG_(printf)("ret: 0x%x\n", ret);
 252
 253    res = VG_(mk_SysRes_mips64_linux)( /* val */ ret, 0, /* errflag */ 0);
 254
 255    VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
 256
 257    out:
 258    if (sr_isError (res)) {
 259       VG_ (cleanup_thread) (&ctst->arch);
 260       ctst->status = VgTs_Empty;
 261       VG_TRACK (pre_thread_ll_exit, ctid);
 262    }
 263    ptst->arch.vex.guest_r2 = 0;
 264
 265    return res;
 266 }
 267
 268 /* ---------------------------------------------------------------------
 269                           More thread stuff
 270    ------------------------------------------------------------------ */
 271 void VG_(cleanup_thread) ( ThreadArchState * arch ) { };
 272
 273 void setup_child ( /* OUT */ ThreadArchState * child,
 274                    /* IN  */ ThreadArchState * parent )
 275 {
 276    /* We inherit our parent's guest state. */
 277    child->vex = parent->vex;
 278    child->vex_shadow1 = parent->vex_shadow1;
 279    child->vex_shadow2 = parent->vex_shadow2;
 280 }
 281
 282 SysRes sys_set_tls ( ThreadId tid, Addr tlsptr )
 283 {
 284    VG_(threads)[tid].arch.vex.guest_ULR = tlsptr;
 285    return VG_(mk_SysRes_Success)( 0 );
 286 }
 287
 288 /* ---------------------------------------------------------------------
 289            PRE/POST wrappers for mips/Linux-specific syscalls
 290    ------------------------------------------------------------------ */
 291
 292 #define PRE(name)       DEFN_PRE_TEMPLATE(mips_linux, name)
 293 #define POST(name)      DEFN_POST_TEMPLATE(mips_linux, name)
 294
 295 /* Add prototypes for the wrappers declared here, so that gcc doesn't harass us
 296    for not having prototypes. Really this is a kludge -- the right thing to do
 297    is to make these wrappers 'static' since they aren't visible outside this
 298    file, but that requires even more macro magic. */
 299
 300 DECL_TEMPLATE (mips_linux, sys_set_thread_area);
 301 DECL_TEMPLATE (mips_linux, sys_clone);
 302 DECL_TEMPLATE (mips_linux, sys_tee);
 303 DECL_TEMPLATE (mips_linux, sys_splice);
 304 DECL_TEMPLATE (mips_linux, sys_vmsplice);
 305 DECL_TEMPLATE (mips_linux, sys_ustat);
 306 DECL_TEMPLATE (mips_linux, sys_sysfs);
 307 DECL_TEMPLATE (mips_linux, sys_swapon);
 308 DECL_TEMPLATE (mips_linux, sys_swapoff);
 309 DECL_TEMPLATE (mips_linux, sys_setdomainname);
 310 DECL_TEMPLATE (mips_linux, sys_sethostname);
 311 DECL_TEMPLATE (mips_linux, sys_reboot);
 312 DECL_TEMPLATE (mips_linux, sys_cacheflush);
 313 DECL_TEMPLATE (mips_linux, sys_sched_rr_get_interval);
 314 DECL_TEMPLATE (mips_linux, sys_unshare);
 315 DECL_TEMPLATE (mips_linux, sys_arch_prctl);
 316 DECL_TEMPLATE (mips_linux, sys_ptrace);
 317 DECL_TEMPLATE (mips_linux, sys_mmap);
 318 DECL_TEMPLATE (mips_linux, sys_rt_sigreturn);
 319 DECL_TEMPLATE (mips_linux, sys_pipe);
 320
 321 PRE(sys_tee)
 322 {
 323    PRINT("sys_tee ( %ld, %ld, %ld, %ld )", ARG1, ARG2, ARG3, ARG4);
 324    PRE_REG_READ4(long, "sys_tee", int, fdin, int, fdout, vki_size_t, len,
 325                  int, flags);
 326 }
 327
 328 PRE(sys_splice)
 329 {
 330    PRINT("sys_splice ( %ld, %ld, %ld, %ld, %ld, %ld )", ARG1, ARG2, ARG3,
 331                                                         ARG4, ARG5, ARG6);
 332
 333    PRE_REG_READ6(long, "sys_splice", int, fdin, vki_loff_t, sizein, int,
 334                  fdout, vki_loff_t, sizeout, vki_size_t, len, int, flags);
 335 }
 336
 337 PRE(sys_vmsplice)
 338 {
 339    PRINT("sys_vmsplice ( %ld, %ld, %ld, %ld )", ARG1, ARG2, ARG3, ARG4);
 340    PRE_REG_READ4(long, "sys_vmsplice", int, fdin, struct vki_iovec *, v,
 341                  vki_size_t, len, int, flags);
 342 }
 343
 344 PRE(sys_unshare)
 345 {
 346    PRINT("sys_unshare ( %ld )", ARG1);
 347    PRE_REG_READ1(long, "sys_unshare", int, flags);
 348 }
 349
 350 PRE(sys_sched_rr_get_interval)
 351 {
 352    PRINT("sys_sched_rr_get_interval ( %ld, %#lx)", ARG1, ARG2);
 353    PRE_REG_READ2(long, "sched_rr_get_interval", int, flags,
 354                  struct timespec *, timer);
 355    *flags |= SfMayBlock;
 356 }
 357
 358 PRE(sys_ustat)
 359 {
 360    PRINT("sys_ustat ( %ld, %#lx)", ARG1, ARG2);
 361    PRE_REG_READ2(long, "ustat", int, flags, const void *, path);
 362 }
 363
 364 PRE(sys_swapon)
 365 {
 366    PRINT("sys_swapon ( %#lx, %ld )", ARG1, ARG2);
 367    PRE_REG_READ2(long, "swapon", const void *, path, int, flags);
 368 }
 369
 370 PRE(sys_swapoff)
 371 {
 372    PRINT("sys_swapoff ( %#lx )", ARG1);
 373    PRE_REG_READ1(long, "swapoff", const void *, path);
 374 }
 375
 376 PRE(sys_sysfs)
 377 {
 378    PRINT("sys_sysfs ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
 379    PRE_REG_READ3(long, "sysfs", int, flags, int, desc, const void *, path);
 380 }
 381
 382 /* Very much MIPS specific */
 383 PRE(sys_cacheflush)
 384 {
 385    PRINT("cacheflush (%lx, %lx, %lx)", ARG1, ARG2, ARG3);
 386    PRE_REG_READ3(long, "cacheflush", unsigned long, addr,
 387                  int, nbytes, int, cache);
 388    VG_ (discard_translations) ((Addr)ARG1, (ULong) ARG2,
 389                                "PRE(sys_cacheflush)");
 390    SET_STATUS_Success(0);
 391 }
 392
 393 PRE(sys_reboot)
 394 {
 395    PRINT("sys_reboot ( %ld )", ARG1);
 396    PRE_REG_READ1(int, "reboot", int, flags);
 397    *flags |= SfMayBlock;
 398 }
 399
 400 PRE(sys_setdomainname)
 401 {
 402    PRINT ("sys_setdomainname ( %#lx, %ld )", ARG1, ARG2);
 403    PRE_REG_READ2 (long, "setdomainname", const void *, name, int, len);
 404 }
 405
 406 PRE(sys_sethostname)
 407 {
 408    PRINT ("sys_sethostname ( %ld, %ld )", ARG1, ARG2);
 409    PRE_REG_READ2 (long, "sethostname", const void *, name, int, len);
 410 }
 411
 412 PRE(sys_ptrace)
 413 {
 414    PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", ARG1, ARG2, ARG3, ARG4);
 415    PRE_REG_READ4(int, "ptrace", long, request, long, pid, long, addr,
 416                  long, data);
 417    switch (ARG1) {
 418       case VKI_PTRACE_PEEKTEXT:
 419       case VKI_PTRACE_PEEKDATA:
 420       case VKI_PTRACE_PEEKUSR:
 421          PRE_MEM_WRITE("ptrace(peek)", ARG4, sizeof(long));
 422          break;
 423       case VKI_PTRACE_GETEVENTMSG:
 424          PRE_MEM_WRITE("ptrace(geteventmsg)", ARG4, sizeof(unsigned long));
 425          break;
 426       case VKI_PTRACE_GETSIGINFO:
 427          PRE_MEM_WRITE("ptrace(getsiginfo)", ARG4, sizeof(vki_siginfo_t));
 428          break;
 429       case VKI_PTRACE_SETSIGINFO:
 430          PRE_MEM_READ("ptrace(setsiginfo)", ARG4, sizeof(vki_siginfo_t));
 431          break;
 432       case VKI_PTRACE_GETREGSET:
 433          ML_(linux_PRE_getregset)(tid, ARG3, ARG4);
 434          break;
 435       default:
 436         break;
 437    }
 438 }
 439
 440 POST(sys_ptrace)
 441 {
 442    switch (ARG1) {
 443       case VKI_PTRACE_PEEKTEXT:
 444       case VKI_PTRACE_PEEKDATA:
 445       case VKI_PTRACE_PEEKUSR:
 446          POST_MEM_WRITE (ARG4, sizeof(long));
 447          break;
 448       case VKI_PTRACE_GETEVENTMSG:
 449          POST_MEM_WRITE (ARG4, sizeof(unsigned long));
 450       break;
 451       case VKI_PTRACE_GETSIGINFO:
 452          POST_MEM_WRITE (ARG4, sizeof(vki_siginfo_t));
 453          break;
 454       case VKI_PTRACE_GETREGSET:
 455          ML_(linux_POST_getregset)(tid, ARG3, ARG4);
 456          break;
 457       default:
 458       break;
 459    }
 460 }
 461
 462 PRE (sys_mmap)
 463 {
 464    SysRes r;
 465    PRINT("sys_mmap ( %#lx, %llu, %lu, %lu, %lu, %ld )", ARG1, (ULong)ARG2,
 466                                                         ARG3, ARG4, ARG5, ARG6);
 467    PRE_REG_READ6(long, "mmap", unsigned long, start, vki_size_t, length,
 468                  int, prot, int, flags, int, fd, unsigned long, offset);
 469    r = ML_(generic_PRE_sys_mmap)(tid, ARG1, ARG2, ARG3, ARG4, ARG5,
 470                                  (Off64T) ARG6);
 471    SET_STATUS_from_SysRes(r);
 472 }
 473
 474 PRE(sys_clone)
 475 {
 476    Bool badarg = False;
 477    UInt cloneflags;
 478    PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )", ARG1, ARG2, ARG3,
 479                                                       ARG4, ARG5);
 480    PRE_REG_READ2(int, "clone", unsigned long, flags, void *, child_stack);
 481    if (ARG1 & VKI_CLONE_PARENT_SETTID) {
 482       if (VG_(tdict).track_pre_reg_read) {
 483          PRA3("clone", int *, parent_tidptr);
 484       }
 485       PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
 486       if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int), VKI_PROT_WRITE)) {
 487          badarg = True;
 488       }
 489    }
 490    if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
 491       if (VG_(tdict).track_pre_reg_read) {
 492          PRA5("clone", int *, child_tidptr);
 493       }
 494       PRE_MEM_WRITE("clone(child_tidptr)", ARG5, sizeof (Int));
 495       if (!VG_(am_is_valid_for_client)(ARG5, sizeof (Int), VKI_PROT_WRITE))
 496          badarg = True;
 497    }
 498    if (badarg) {
 499       SET_STATUS_Failure(VKI_EFAULT);
 500       return;
 501    }
 502    cloneflags = ARG1;
 503    if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) {
 504       SET_STATUS_Failure(VKI_EINVAL);
 505       return;
 506    }
 507    /* Only look at the flags we really care about */
 508    switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
 509            |VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
 510       case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
 511          /* thread creation */
 512          SET_STATUS_from_SysRes(do_clone(tid,
 513                                          ARG1,          /* flags */
 514                                          (Addr)ARG2,    /* child SP */
 515                                          (Int *)ARG3,   /* parent_tidptr */
 516                                          (Int *)ARG5,   /* child_tidptr */
 517                                          (Addr)ARG4));  /* child_tls */
 518          break;
 519
 520       case VKI_CLONE_VFORK | VKI_CLONE_VM:  /* vfork */
 521          /* FALLTHROUGH - assume vfork == fork */
 522          cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
 523       case 0:  /* plain fork */
 524          SET_STATUS_from_SysRes(ML_(do_fork_clone)(tid,
 525                                 cloneflags,     /* flags */
 526                                 (Int *)ARG3,    /* parent_tidptr */
 527                                 (Int *)ARG5));  /* child_tidptr */
 528          break;
 529
 530       default:
 531          /* should we just ENOSYS? */
 532          VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG1);
 533          VG_(message)(Vg_UserMsg, "\n");
 534          VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
 535          VG_(message)(Vg_UserMsg,
 536                        " - via a threads library (LinuxThreads or NPTL)\n");
 537          VG_(message)(Vg_UserMsg,
 538                        " - via the implementation of fork or vfork\n");
 539          VG_(unimplemented)("Valgrind does not support general clone().");
 540    }
 541    if (SUCCESS) {
 542       if (ARG1 & VKI_CLONE_PARENT_SETTID)
 543          POST_MEM_WRITE(ARG3, sizeof(Int));
 544       if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
 545          POST_MEM_WRITE(ARG5, sizeof(Int));
 546       /* Thread creation was successful; let the child have the chance to run */
 547       *flags |= SfYieldAfter;
 548    }
 549 }
 550
 551 PRE(sys_rt_sigreturn)
 552 {
 553    /* See comments on PRE(sys_rt_sigreturn) in syswrap-s390x-linux.c for
 554       an explanation of what follows. */
 555    ThreadState* tst;
 556    PRINT("sys_rt_sigreturn ( )");
 557
 558    vg_assert(VG_(is_valid_tid)(tid));
 559    vg_assert(tid >= 1 && tid < VG_N_THREADS);
 560    vg_assert(VG_(is_running_thread)(tid));
 561
 562    tst = VG_(get_ThreadState)(tid);
 563
 564    /* This is only so that the IA is (might be) useful to report if
 565       something goes wrong in the sigreturn */
 566    ML_(fixup_guest_state_to_restart_syscall)(&tst->arch);
 567
 568    /* Restore register state from frame and remove it */
 569    VG_(sigframe_destroy)(tid, True);
 570
 571    /* Tell the driver not to update the guest state with the "result",
 572       and set a bogus result to keep it happy. */
 573    *flags |= SfNoWriteResult;
 574    SET_STATUS_Success(0);
 575
 576    /* Check to see if any signals arose as a result of this. */
 577    *flags |= SfPollAfter;
 578 }
 579
 580 PRE(sys_set_thread_area)
 581 {
 582    PRINT("set_thread_area (%lx)", ARG1);
 583    PRE_REG_READ1(long, "set_thread_area", unsigned long, addr);
 584    SET_STATUS_from_SysRes(sys_set_tls(tid, ARG1));
 585 }
 586
 587 PRE(sys_pipe)
 588 {
 589    PRINT("sys_pipe ( %#lx )", ARG1);
 590    PRE_REG_READ1(int, "pipe", int *, filedes);
 591    PRE_MEM_WRITE( "pipe(filedes)", ARG1, 2*sizeof(int) );
 592 }
 593
 594 POST(sys_pipe)
 595 {
 596    Int p0, p1;
 597    vg_assert(SUCCESS);
 598    p0 = RES;
 599    p1 = sr_ResEx(status->sres);
 600
 601    if (!ML_(fd_allowed)(p0, "pipe", tid, True) ||
 602        !ML_(fd_allowed)(p1, "pipe", tid, True)) {
 603       VG_(close)(p0);
 604       VG_(close)(p1);
 605       SET_STATUS_Failure( VKI_EMFILE );
 606    } else {
 607       if (VG_(clo_track_fds)) {
 608          ML_(record_fd_open_nameless)(tid, p0);
 609          ML_(record_fd_open_nameless)(tid, p1);
 610       }
 611    }
 612 }
 613
 614 #undef PRE
 615 #undef POST
 616
 617 /* ---------------------------------------------------------------------
 618    The mips64/Linux syscall table
 619    ------------------------------------------------------------------ */
 620
 621 /* Add an mips64-linux specific wrapper to a syscall table. */
 622 #define PLAX_(sysno, name)    WRAPPER_ENTRY_X_(mips_linux, sysno, name)
 623 #define PLAXY(sysno, name)    WRAPPER_ENTRY_XY(mips_linux, sysno, name)
 624
 625 static SyscallTableEntry syscall_main_table[] = {
 626    GENXY (__NR_read, sys_read),  /* 5000 */
 627    GENX_ (__NR_write, sys_write),
 628    GENXY (__NR_open, sys_open),
 629    GENXY (__NR_close, sys_close),
 630    GENXY (__NR_stat, sys_newstat),
 631    GENXY (__NR_fstat, sys_newfstat),
 632    GENXY (__NR_lstat, sys_newlstat),
 633    GENXY (__NR_poll, sys_poll),
 634    LINX_ (__NR_lseek, sys_lseek),
 635    PLAX_ (__NR_mmap, sys_mmap),
 636    GENXY (__NR_mprotect, sys_mprotect),
 637    GENXY (__NR_munmap, sys_munmap),
 638    GENX_ (__NR_brk, sys_brk),
 639    LINXY (__NR_rt_sigaction, sys_rt_sigaction),
 640    LINXY (__NR_rt_sigprocmask, sys_rt_sigprocmask),
 641    LINXY (__NR_ioctl, sys_ioctl),
 642    LINXY (__NR_eventfd2, sys_eventfd2),
 643    LINXY (__NR_signalfd4, sys_signalfd4),
 644    GENXY (__NR_pread64, sys_pread64),
 645    GENX_ (__NR_pwrite64, sys_pwrite64),
 646    GENXY (__NR_readv, sys_readv),
 647    GENX_ (__NR_writev, sys_writev),
 648    GENX_ (__NR_access, sys_access),
 649    PLAXY (__NR_pipe, sys_pipe),
 650    LINXY (__NR_pipe2, sys_pipe2),
 651    GENX_ (__NR__newselect,sys_select),
 652    LINX_ (__NR_sched_yield, sys_sched_yield),
 653    GENX_ (__NR_mremap, sys_mremap),
 654    GENX_ (__NR_msync, sys_msync),
 655    GENXY (__NR_mincore, sys_mincore),
 656    GENX_ (__NR_madvise, sys_madvise),
 657    LINX_ (__NR_shmget, sys_shmget),
 658    LINXY (__NR_shmat, wrap_sys_shmat),
 659    LINXY (__NR_shmctl, sys_shmctl),
 660    GENXY (__NR_dup, sys_dup),
 661    GENXY (__NR_dup2, sys_dup2),
 662    LINXY (__NR_dup3, sys_dup3),
 663    GENX_ (__NR_pause, sys_pause),
 664    GENXY (__NR_nanosleep, sys_nanosleep),
 665    GENXY (__NR_getitimer, sys_getitimer),
 666    GENXY (__NR_setitimer, sys_setitimer),
 667    GENX_ (__NR_alarm, sys_alarm),
 668    GENX_ (__NR_getpid, sys_getpid),
 669    /* LINX_(__NR_fallocate,sys_fallocate), */
 670    LINXY (__NR_sendfile, sys_sendfile),
 671    LINXY (__NR_socket, sys_socket),
 672    LINX_ (__NR_connect, sys_connect),
 673    LINXY (__NR_accept, sys_accept),
 674    LINXY (__NR_accept4, sys_accept4),
 675    LINX_ (__NR_sendto, sys_sendto),
 676    LINXY (__NR_recvfrom, sys_recvfrom),
 677    LINX_ (__NR_sendmsg, sys_sendmsg),
 678    LINXY (__NR_recvmsg, sys_recvmsg),
 679    LINX_ (__NR_shutdown, sys_shutdown),
 680    LINX_ (__NR_bind, sys_bind),
 681    LINX_ (__NR_listen, sys_listen),
 682    LINXY (__NR_getsockname, sys_getsockname),
 683    LINXY (__NR_getpeername, sys_getpeername),
 684    LINXY (__NR_socketpair, sys_socketpair),
 685    LINX_ (__NR_setsockopt, sys_setsockopt),
 686    LINXY (__NR_getsockopt, sys_getsockopt),
 687    PLAX_ (__NR_clone, sys_clone),
 688    GENX_ (__NR_fork, sys_fork),
 689    GENX_ (__NR_execve, sys_execve),
 690    GENX_ (__NR_exit, sys_exit),
 691    GENXY (__NR_wait4, sys_wait4),
 692    GENX_ (__NR_kill, sys_kill),
 693    GENXY (__NR_uname, sys_newuname),
 694    LINX_ (__NR_semget, sys_semget),
 695    LINX_ (__NR_semop, sys_semop),
 696    LINXY (__NR_semctl, sys_semctl),
 697    LINXY (__NR_shmdt, sys_shmdt),
 698    LINX_ (__NR_msgget, sys_msgget),
 699    LINX_ (__NR_msgsnd, sys_msgsnd),
 700    LINXY (__NR_msgrcv, sys_msgrcv),
 701    LINXY (__NR_msgctl, sys_msgctl),
 702    LINXY (__NR_fcntl, sys_fcntl),
 703    GENX_ (__NR_flock, sys_flock),
 704    GENX_ (__NR_fsync, sys_fsync),
 705    GENX_ (__NR_fdatasync, sys_fdatasync),
 706    GENX_ (__NR_truncate, sys_truncate),
 707    GENX_ (__NR_ftruncate, sys_ftruncate),
 708    GENXY (__NR_getdents, sys_getdents),
 709    GENXY (__NR_getcwd, sys_getcwd),
 710    GENX_ (__NR_chdir, sys_chdir),
 711    GENX_ (__NR_fchdir, sys_fchdir),
 712    GENX_ (__NR_rename, sys_rename),
 713    GENX_ (__NR_mkdir, sys_mkdir),
 714    GENX_ (__NR_rmdir, sys_rmdir),
 715    GENXY (__NR_creat, sys_creat),
 716    GENX_ (__NR_link, sys_link),
 717    GENX_ (__NR_unlink, sys_unlink),
 718    GENX_ (__NR_symlink, sys_symlink),
 719    GENX_ (__NR_readlink, sys_readlink),
 720    GENX_ (__NR_chmod, sys_chmod),
 721    GENX_ (__NR_fchmod, sys_fchmod),
 722    GENX_ (__NR_chown, sys_chown),
 723    GENX_ (__NR_fchown, sys_fchown),
 724    GENX_ (__NR_lchown, sys_lchown),
 725    GENX_ (__NR_umask, sys_umask),
 726    GENXY (__NR_gettimeofday, sys_gettimeofday),
 727    GENXY (__NR_getrlimit, sys_getrlimit),
 728    GENXY (__NR_getrusage, sys_getrusage),
 729    LINXY (__NR_sysinfo, sys_sysinfo),
 730    GENXY (__NR_times, sys_times),
 731    PLAXY (__NR_ptrace, sys_ptrace),
 732    GENX_ (__NR_getuid, sys_getuid),
 733    LINXY (__NR_syslog, sys_syslog),
 734    GENX_ (__NR_getgid, sys_getgid),
 735    GENX_ (__NR_setuid, sys_setuid),
 736    GENX_ (__NR_setgid, sys_setgid),
 737    GENX_ (__NR_geteuid, sys_geteuid),
 738    GENX_ (__NR_getegid, sys_getegid),
 739    GENX_ (__NR_setpgid, sys_setpgid),
 740    GENX_ (__NR_getppid, sys_getppid),
 741    GENX_ (__NR_getpgrp, sys_getpgrp),
 742    GENX_ (__NR_setsid, sys_setsid),
 743    GENX_ (__NR_setreuid, sys_setreuid),
 744    GENX_ (__NR_setregid, sys_setregid),
 745    GENXY (__NR_getgroups, sys_getgroups),
 746    GENX_ (__NR_setgroups, sys_setgroups),
 747    LINX_ (__NR_setresuid, sys_setresuid),
 748    LINXY (__NR_getresuid, sys_getresuid),
 749    LINX_ (__NR_setresgid, sys_setresgid),
 750    LINXY (__NR_getresgid, sys_getresgid),
 751    GENX_ (__NR_getpgid, sys_getpgid),
 752    LINX_ (__NR_setfsuid, sys_setfsuid),
 753    LINX_ (__NR_setfsgid, sys_setfsgid),
 754    GENX_ (__NR_getsid, sys_getsid),
 755    LINXY (__NR_capget, sys_capget),
 756    LINX_ (__NR_capset, sys_capset),
 757    LINXY (__NR_rt_sigpending, sys_rt_sigpending),
 758    LINXY (__NR_rt_sigtimedwait, sys_rt_sigtimedwait),
 759    LINXY (__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo),
 760    LINX_ (__NR_rt_sigsuspend, sys_rt_sigsuspend),
 761    GENXY (__NR_sigaltstack, sys_sigaltstack),
 762    LINX_ (__NR_utime, sys_utime),
 763    GENX_ (__NR_mknod, sys_mknod),
 764    LINX_ (__NR_personality, sys_personality),
 765    PLAX_ (__NR_ustat, sys_ustat),
 766    GENXY (__NR_statfs, sys_statfs),
 767    GENXY (__NR_fstatfs, sys_fstatfs),
 768    PLAX_ (__NR_sysfs, sys_sysfs),
 769    GENX_ (__NR_getpriority, sys_getpriority),
 770    GENX_ (__NR_setpriority, sys_setpriority),
 771    LINXY (__NR_sched_setparam, sys_sched_setparam),
 772    LINXY (__NR_sched_getparam, sys_sched_getparam),
 773    LINX_ (__NR_sched_setscheduler, sys_sched_setscheduler),
 774    LINX_ (__NR_sched_getscheduler, sys_sched_getscheduler),
 775    LINX_ (__NR_sched_get_priority_max, sys_sched_get_priority_max),
 776    LINX_ (__NR_sched_get_priority_min, sys_sched_get_priority_min),
 777    PLAX_ (__NR_sched_rr_get_interval, sys_sched_rr_get_interval),
 778    GENX_ (__NR_mlock, sys_mlock),
 779    GENX_ (__NR_munlock, sys_munlock),
 780    GENX_ (__NR_mlockall, sys_mlockall),
 781    LINX_ (__NR_munlockall, sys_munlockall),
 782    LINX_ (__NR_vhangup, sys_vhangup),
 783    LINX_ (__NR_pivot_root,sys_pivot_root),
 784    LINXY (__NR__sysctl, sys_sysctl),
 785    LINXY (__NR_prctl, sys_prctl),
 786    LINXY (__NR_adjtimex, sys_adjtimex),
 787    GENX_ (__NR_setrlimit, sys_setrlimit),
 788    GENX_ (__NR_chroot, sys_chroot),
 789    GENX_ (__NR_sync, sys_sync),
 790    GENX_ (__NR_acct, sys_acct),
 791    GENX_ (__NR_settimeofday, sys_settimeofday),
 792    LINX_ (__NR_mount, sys_mount),
 793    LINX_ (__NR_umount2, sys_umount),
 794    PLAX_ (__NR_swapon, sys_swapon),
 795    PLAX_ (__NR_swapoff, sys_swapoff),
 796    PLAX_ (__NR_reboot, sys_reboot),
 797    PLAX_ (__NR_sethostname, sys_sethostname),
 798    PLAX_ (__NR_setdomainname, sys_setdomainname),
 799    GENX_ (__NR_create_module, sys_ni_syscall),
 800    LINX_ (__NR_init_module, sys_init_module),
 801    LINX_ (__NR_delete_module, sys_delete_module),
 802    GENX_ (__NR_get_kernel_syms, sys_ni_syscall),
 803    GENX_ (__NR_query_module, sys_ni_syscall),
 804    LINX_ (__NR_quotactl, sys_quotactl),
 805    /* GENX_(__NR_nfsservctl,sys_nfsservctl), */
 806    GENXY (__NR_getpmsg, sys_getpmsg),
 807    GENX_ (__NR_putpmsg, sys_putpmsg),
 808    GENX_ (__NR_afs_syscall, sys_ni_syscall),
 809    /* GENX_(__NR_reserved177,sys_reserved177), */
 810    LINX_ (__NR_gettid, sys_gettid),
 811    /* GENX_(__NR_readahead,sys_readahead), */
 812    LINX_ (__NR_setxattr, sys_setxattr),
 813    LINX_ (__NR_lsetxattr, sys_lsetxattr),
 814    LINX_ (__NR_fsetxattr, sys_fsetxattr),
 815    LINXY (__NR_getxattr, sys_getxattr),
 816    LINXY (__NR_lgetxattr, sys_lgetxattr),
 817    LINXY (__NR_fgetxattr, sys_fgetxattr),
 818    LINXY (__NR_listxattr, sys_listxattr),
 819    LINXY (__NR_llistxattr, sys_llistxattr),
 820    LINXY (__NR_flistxattr, sys_flistxattr),
 821    LINX_ (__NR_removexattr, sys_removexattr),
 822    LINX_ (__NR_lremovexattr, sys_lremovexattr),
 823    LINX_ (__NR_fremovexattr, sys_fremovexattr),
 824    LINXY (__NR_tkill, sys_tkill),
 825    /* GENX_(__NR_reserved193,sys_reserved193), */
 826    LINXY (__NR_futex, sys_futex),
 827    LINX_ (__NR_sched_setaffinity, sys_sched_setaffinity),
 828    LINXY (__NR_sched_getaffinity, sys_sched_getaffinity),
 829    PLAX_ (__NR_cacheflush, sys_cacheflush),
 830    LINXY (__NR_io_setup, sys_io_setup),
 831    LINX_ (__NR_io_destroy, sys_io_destroy),
 832    LINXY (__NR_io_getevents, sys_io_getevents),
 833    LINX_ (__NR_io_submit, sys_io_submit),
 834    LINXY (__NR_io_cancel, sys_io_cancel),
 835    LINX_ (__NR_exit_group, sys_exit_group),
 836    /* LINXY (__NR_lookup_dcookie, sys_lookup_dcookie), */
 837    LINXY (__NR_epoll_create, sys_epoll_create),
 838    LINXY (__NR_epoll_create1, sys_epoll_create1),
 839    LINX_ (__NR_epoll_ctl, sys_epoll_ctl),
 840    LINXY (__NR_epoll_wait, sys_epoll_wait),
 841    PLAX_(__NR_rt_sigreturn,sys_rt_sigreturn),
 842    /* LINXY(__NR_fcntl64,sys_fcntl64), */
 843    LINX_ (__NR_set_tid_address, sys_set_tid_address),
 844    LINX_ (__NR_semtimedop, sys_semtimedop),
 845    LINX_ (__NR_fadvise64, sys_fadvise64),
 846    LINXY (__NR_timer_create, sys_timer_create),
 847    LINXY (__NR_timer_settime, sys_timer_settime),
 848    LINXY (__NR_timer_gettime, sys_timer_gettime),
 849    LINX_ (__NR_timer_getoverrun, sys_timer_getoverrun),
 850    LINX_ (__NR_timer_delete, sys_timer_delete),
 851    LINX_ (__NR_clock_settime, sys_clock_settime),
 852    LINXY (__NR_clock_gettime, sys_clock_gettime),
 853    LINXY (__NR_clock_getres, sys_clock_getres),
 854    LINXY (__NR_clock_nanosleep, sys_clock_nanosleep),
 855    LINX_ (__NR_tgkill, sys_tgkill),
 856    GENX_ (__NR_utimes, sys_utimes),
 857    LINX_ (__NR_mbind, sys_mbind),
 858    LINXY (__NR_get_mempolicy, sys_get_mempolicy),
 859    LINX_ (__NR_set_mempolicy, sys_set_mempolicy),
 860    LINXY (__NR_mq_open, sys_mq_open),
 861    LINX_ (__NR_mq_unlink, sys_mq_unlink),
 862    LINX_ (__NR_mq_timedsend, sys_mq_timedsend),
 863    LINXY (__NR_mq_timedreceive, sys_mq_timedreceive),
 864    LINX_ (__NR_mq_notify, sys_mq_notify),
 865    LINXY (__NR_mq_getsetattr, sys_mq_getsetattr),
 866    GENX_ (__NR_vserver, sys_ni_syscall),
 867    LINXY (__NR_waitid, sys_waitid),
 868    LINX_ (__NR_add_key, sys_add_key),
 869    LINX_ (__NR_request_key, sys_request_key),
 870    LINXY (__NR_keyctl, sys_keyctl),
 871    PLAX_ (__NR_set_thread_area, sys_set_thread_area),
 872    LINX_ (__NR_inotify_init, sys_inotify_init),
 873    LINX_ (__NR_inotify_add_watch, sys_inotify_add_watch),
 874    LINX_ (__NR_inotify_rm_watch, sys_inotify_rm_watch),
 875    LINXY (__NR_openat, sys_openat),
 876    LINX_ (__NR_mkdirat, sys_mkdirat),
 877    LINX_ (__NR_mknodat, sys_mknodat),
 878    LINX_ (__NR_fchownat, sys_fchownat),
 879    LINX_ (__NR_futimesat, sys_futimesat),
 880    LINX_ (__NR_unlinkat, sys_unlinkat),
 881    LINX_ (__NR_renameat, sys_renameat),
 882    LINX_ (__NR_linkat, sys_linkat),
 883    LINX_ (__NR_symlinkat, sys_symlinkat),
 884    LINX_ (__NR_readlinkat, sys_readlinkat),
 885    LINX_ (__NR_fchmodat, sys_fchmodat),
 886    LINX_ (__NR_faccessat, sys_faccessat),
 887    LINX_ (__NR_pselect6, sys_pselect6),
 888    LINXY (__NR_ppoll, sys_ppoll),
 889    PLAX_ (__NR_unshare, sys_unshare),
 890    PLAX_ (__NR_splice, sys_splice),
 891    LINX_ (__NR_sync_file_range, sys_sync_file_range),
 892    PLAX_ (__NR_tee, sys_tee),
 893    PLAX_ (__NR_vmsplice, sys_vmsplice),
 894    LINX_ (__NR_set_robust_list, sys_set_robust_list),
 895    LINXY (__NR_get_robust_list, sys_get_robust_list),
 896    LINXY (__NR_epoll_pwait, sys_epoll_pwait),
 897    LINX_ (__NR_ioprio_set, sys_ioprio_set),
 898    LINX_ (__NR_ioprio_get, sys_ioprio_get),
 899    LINX_ (__NR_utimensat, sys_utimensat),
 900    LINXY (__NR_signalfd, sys_signalfd),
 901    LINXY (__NR_eventfd, sys_eventfd),
 902    LINX_ (__NR_fallocate, sys_fallocate),
 903    LINXY (__NR_timerfd_create, sys_timerfd_create),
 904    LINXY (__NR_timerfd_gettime, sys_timerfd_gettime),
 905    LINXY (__NR_timerfd_settime, sys_timerfd_settime),
 906    LINXY (__NR_newfstatat, sys_newfstatat),
 907    LINXY (__NR_prlimit64, sys_prlimit64),
 908    LINXY (__NR_clock_adjtime, sys_clock_adjtime),
 909    LINXY (__NR_process_vm_readv, sys_process_vm_readv),
 910    LINX_ (__NR_process_vm_writev, sys_process_vm_writev),
 911    LINXY(__NR_getrandom, sys_getrandom),
 912    LINXY(__NR_memfd_create, sys_memfd_create),
 913    LINX_(__NR_syncfs, sys_syncfs)
 914 };
 915
 916 SyscallTableEntry * ML_(get_linux_syscall_entry) ( UInt sysno )
 917 {
 918    const UInt syscall_main_table_size
 919       = sizeof(syscall_main_table) / sizeof(syscall_main_table[0]);
 920
 921    if (sysno < syscall_main_table_size) {
 922       SyscallTableEntry * sys = &syscall_main_table[sysno];
 923       if (sys->before == NULL)
 924          return NULL;  /* no entry */
 925       else
 926          return sys;
 927    }
 928    /* Can't find a wrapper */
 929    return NULL;
 930 }
 931
 932 #endif  /* defined(VGP_mips64_linux) */
 933
 934 /*--------------------------------------------------------------------*/
 935 /*--- end                                   syswrap-mips64-linux.c ---*/
 936 /*--------------------------------------------------------------------*/