1 2/*--------------------------------------------------------------------*/ 3/*--- Platform-specific syscalls stuff. syswrap-mips32-linux.c ----*/ 4/*--------------------------------------------------------------------*/ 5 6/* 7 This file is part of Valgrind, a dynamic binary instrumentation 8 framework. 9 10 Copyright (C) 2010-2017 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_mips32_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 "priv_syswrap-generic.h" 68 69#include "config.h" 70 71#include <errno.h> 72 73/* --------------------------------------------------------------------- 74 clone() handling 75 ------------------------------------------------------------------ */ 76/* Call f(arg1), but first switch stacks, using 'stack' as the new 77 stack, and use 'retaddr' as f's return-to address. Also, clear all 78 the integer registers before entering f.*/ 79 80__attribute__ ((noreturn)) 81void ML_ (call_on_new_stack_0_1) (Addr stack, Addr retaddr, 82 void (*f) (Word), Word arg1); 83// a0 = stack 84// a1 = retaddr 85// a2 = f 86// a3 = arg1 87asm ( 88".text\n" 89".globl vgModuleLocal_call_on_new_stack_0_1\n" 90"vgModuleLocal_call_on_new_stack_0_1:\n" 91" move $29, $4\n\t" // stack to %sp 92" move $31, $5\n\t" // retaddr to $ra 93" move $25, $6\n\t" // f to t9/$25 94" move $4, $7\n\t" // arg1 to $a0 95" li $2, 0\n\t" // zero all GP regs 96" li $3, 0\n\t" 97" li $5, 0\n\t" 98" li $6, 0\n\t" 99" li $7, 0\n\t" 100" li $12, 0\n\t" 101" li $13, 0\n\t" 102" li $14, 0\n\t" 103" li $15, 0\n\t" 104" li $16, 0\n\t" 105" li $17, 0\n\t" 106" li $18, 0\n\t" 107" li $19, 0\n\t" 108" li $20, 0\n\t" 109" li $21, 0\n\t" 110" li $22, 0\n\t" 111" li $23, 0\n\t" 112" li $24, 0\n\t" 113" jr $25\n\t" // jump to dst 114" break 0x7\n" // should never get here 115".previous\n" 116); 117 118/* 119 Perform a clone system call. clone is strange because it has 120 fork()-like return-twice semantics, so it needs special 121 handling here. 122 Upon entry, we have: 123 int (fn)(void*) in $a0 0 124 void* child_stack in $a1 4 125 int flags in $a2 8 126 void* arg in $a3 12 127 pid_t* child_tid in stack 16 128 pid_t* parent_tid in stack 20 129 void* tls_ptr in stack 24 130 131 System call requires: 132 int $__NR_clone in $v0 133 int flags in $a0 0 134 void* child_stack in $a1 4 135 pid_t* parent_tid in $a2 8 136 void* tls_ptr in $a3 12 137 pid_t* child_tid in stack 16 138 139 int clone(int (*fn)(void *arg), void *child_stack, int flags, void *arg, 140 void *parent_tidptr, void *tls, void *child_tidptr) 141 142 Returns an Int encoded in the linux-mips way, not a SysRes. 143 */ 144#define __NR_CLONE VG_STRINGIFY(__NR_clone) 145#define __NR_EXIT VG_STRINGIFY(__NR_exit) 146 147// See priv_syswrap-linux.h for arg profile. 148asm ( 149".text\n" 150" .globl do_syscall_clone_mips_linux\n" 151" do_syscall_clone_mips_linux:\n" 152" subu $29,$29,32\n\t" 153" sw $31, 0($29)\n\t" 154" sw $2, 4($29)\n\t" 155" sw $3, 8($29)\n\t" 156" sw $30, 12($29)\n\t" 157" sw $28, 28($29)\n\t" 158 /* set up child stack with function and arg */ 159 /* syscall arg 2 child_stack is already in a1 */ 160" subu $5, $5, 32\n\t" /* make space on stack */ 161" sw $4, 0($5)\n\t" /* fn */ 162" sw $7, 4($5)\n\t" /* fn arg */ 163" sw $6, 8($5)\n\t" 164 /* get other args to clone */ 165 166" move $4, $a2\n\t" /* a0 = flags */ 167" lw $6, 52($29)\n\t" /* a2 = parent_tid */ 168" lw $7, 48($29)\n\t" /* a3 = child_tid */ 169" sw $7, 16($29)\n\t" /* 16(sp) = child_tid */ 170" lw $7, 56($29)\n\t" /* a3 = tls_ptr */ 171 /* do the system call */ 172 173" li $2, " __NR_CLONE "\n\t" /* __NR_clone */ 174" syscall\n\t" 175" nop\n\t" 176 177" bnez $7, .Lerror\n\t" 178" nop\n\t" 179" beqz $2, .Lstart\n\t" 180" nop\n\t" 181 182" lw $31, 0($sp)\n\t" 183" nop\n\t" 184" lw $30, 12($sp)\n\t" 185" nop\n\t" 186" addu $29,$29,32\n\t" /* free stack */ 187" nop\n\t" 188" jr $31\n\t" 189" nop\n\t" 190 191".Lerror:\n\t" 192" li $31, 5\n\t" 193" jr $31\n\t" 194" nop\n\t" 195 196".Lstart:\n\t" 197" lw $4, 4($29)\n\t" 198" nop\n\t" 199" lw $25, 0($29)\n\t" 200" nop\n\t" 201" jalr $25\n\t" 202" nop\n\t" 203 204" move $4, $2\n\t" /* retval from fn is in $v0 */ 205" li $2, " __NR_EXIT "\n\t" /* NR_exit */ 206" syscall\n\t" 207" nop\n\t" 208" .previous\n" 209); 210 211#undef __NR_CLONE 212#undef __NR_EXIT 213 214// forward declarations 215static SysRes sys_set_tls (ThreadId tid, Addr tlsptr); 216static SysRes mips_PRE_sys_mmap (ThreadId tid, 217 UWord arg1, UWord arg2, UWord arg3, 218 UWord arg4, UWord arg5, Off64T arg6); 219/* --------------------------------------------------------------------- 220 More thread stuff 221 ------------------------------------------------------------------ */ 222 223// MIPS doesn't have any architecture specific thread stuff that 224// needs to be cleaned up da li ????!!!!??? 225void 226VG_ (cleanup_thread) (ThreadArchState * arch) { } 227 228SysRes sys_set_tls ( ThreadId tid, Addr tlsptr ) 229{ 230 VG_(threads)[tid].arch.vex.guest_ULR = tlsptr; 231 return VG_(mk_SysRes_Success)( 0 ); 232} 233 234/* --------------------------------------------------------------------- 235 mips handler for mmap and mmap2 236 ------------------------------------------------------------------ */ 237static void notify_core_of_mmap(Addr a, SizeT len, UInt prot, 238 UInt flags, Int fd, Off64T offset) 239{ 240 Bool d; 241 242 /* 'a' is the return value from a real kernel mmap, hence: */ 243 vg_assert(VG_IS_PAGE_ALIGNED(a)); 244 /* whereas len is whatever the syscall supplied. So: */ 245 len = VG_PGROUNDUP(len); 246 247 d = VG_(am_notify_client_mmap)( a, len, prot, flags, fd, offset ); 248 249 if (d) 250 VG_(discard_translations)( a, (ULong)len, 251 "notify_core_of_mmap" ); 252} 253 254static void notify_tool_of_mmap(Addr a, SizeT len, UInt prot, ULong di_handle) 255{ 256 Bool rr, ww, xx; 257 258 /* 'a' is the return value from a real kernel mmap, hence: */ 259 vg_assert(VG_IS_PAGE_ALIGNED(a)); 260 /* whereas len is whatever the syscall supplied. So: */ 261 len = VG_PGROUNDUP(len); 262 263 rr = toBool(prot & VKI_PROT_READ); 264 ww = toBool(prot & VKI_PROT_WRITE); 265 xx = toBool(prot & VKI_PROT_EXEC); 266 267 VG_TRACK( new_mem_mmap, a, len, rr, ww, xx, di_handle ); 268} 269 270/* Based on ML_(generic_PRE_sys_mmap) from syswrap-generic.c. 271 If we are trying to do mmap with VKI_MAP_SHARED flag we need to align the 272 start address on VKI_SHMLBA like we did in 273 VG_(am_mmap_file_float_valgrind_flags) 274 */ 275static SysRes mips_PRE_sys_mmap(ThreadId tid, 276 UWord arg1, UWord arg2, UWord arg3, 277 UWord arg4, UWord arg5, Off64T arg6) 278{ 279 Addr advised; 280 SysRes sres; 281 MapRequest mreq; 282 Bool mreq_ok; 283 284 if (arg2 == 0) { 285 /* SuSV3 says: If len is zero, mmap() shall fail and no mapping 286 shall be established. */ 287 return VG_(mk_SysRes_Error)( VKI_EINVAL ); 288 } 289 290 if (!VG_IS_PAGE_ALIGNED(arg1)) { 291 /* zap any misaligned addresses. */ 292 /* SuSV3 says misaligned addresses only cause the MAP_FIXED case 293 to fail. Here, we catch them all. */ 294 return VG_(mk_SysRes_Error)( VKI_EINVAL ); 295 } 296 297 if (!VG_IS_PAGE_ALIGNED(arg6)) { 298 /* zap any misaligned offsets. */ 299 /* SuSV3 says: The off argument is constrained to be aligned and 300 sized according to the value returned by sysconf() when 301 passed _SC_PAGESIZE or _SC_PAGE_SIZE. */ 302 return VG_(mk_SysRes_Error)( VKI_EINVAL ); 303 } 304 305 /* Figure out what kind of allocation constraints there are 306 (fixed/hint/any), and ask aspacem what we should do. */ 307 mreq.start = arg1; 308 mreq.len = arg2; 309 if (arg4 & VKI_MAP_FIXED) { 310 mreq.rkind = MFixed; 311 } else 312 if (arg1 != 0) { 313 mreq.rkind = MHint; 314 } else { 315 mreq.rkind = MAny; 316 } 317 318 if ((VKI_SHMLBA > VKI_PAGE_SIZE) && (VKI_MAP_SHARED & arg4) 319 && !(VKI_MAP_FIXED & arg4)) 320 mreq.len = arg2 + VKI_SHMLBA - VKI_PAGE_SIZE; 321 322 /* Enquire ... */ 323 advised = VG_(am_get_advisory)( &mreq, True/*client*/, &mreq_ok ); 324 325 if ((VKI_SHMLBA > VKI_PAGE_SIZE) && (VKI_MAP_SHARED & arg4) 326 && !(VKI_MAP_FIXED & arg4)) 327 advised = VG_ROUNDUP(advised, VKI_SHMLBA); 328 329 if (!mreq_ok) { 330 /* Our request was bounced, so we'd better fail. */ 331 return VG_(mk_SysRes_Error)( VKI_EINVAL ); 332 } 333 334 /* Otherwise we're OK (so far). Install aspacem's choice of 335 address, and let the mmap go through. */ 336 sres = VG_(am_do_mmap_NO_NOTIFY)(advised, arg2, arg3, 337 arg4 | VKI_MAP_FIXED, 338 arg5, arg6); 339 340 /* A refinement: it may be that the kernel refused aspacem's choice 341 of address. If we were originally asked for a hinted mapping, 342 there is still a last chance: try again at any address. 343 Hence: */ 344 if (mreq.rkind == MHint && sr_isError(sres)) { 345 mreq.start = 0; 346 mreq.len = arg2; 347 mreq.rkind = MAny; 348 advised = VG_(am_get_advisory)( &mreq, True/*client*/, &mreq_ok ); 349 if (!mreq_ok) { 350 /* Our request was bounced, so we'd better fail. */ 351 return VG_(mk_SysRes_Error)( VKI_EINVAL ); 352 } 353 /* and try again with the kernel */ 354 sres = VG_(am_do_mmap_NO_NOTIFY)(advised, arg2, arg3, 355 arg4 | VKI_MAP_FIXED, 356 arg5, arg6); 357 } 358 359 if (!sr_isError(sres)) { 360 ULong di_handle; 361 /* Notify aspacem. */ 362 notify_core_of_mmap( 363 (Addr)sr_Res(sres), /* addr kernel actually assigned */ 364 arg2, /* length */ 365 arg3, /* prot */ 366 arg4, /* the original flags value */ 367 arg5, /* fd */ 368 arg6 /* offset */ 369 ); 370 /* Load symbols? */ 371 di_handle = VG_(di_notify_mmap)( (Addr)sr_Res(sres), 372 False/*allow_SkFileV*/, (Int)arg5 ); 373 /* Notify the tool. */ 374 notify_tool_of_mmap( 375 (Addr)sr_Res(sres), /* addr kernel actually assigned */ 376 arg2, /* length */ 377 arg3, /* prot */ 378 di_handle /* so the tool can refer to the read debuginfo later, 379 if it wants. */ 380 ); 381 } 382 383 /* Stay sane */ 384 if (!sr_isError(sres) && (arg4 & VKI_MAP_FIXED)) 385 vg_assert(sr_Res(sres) == arg1); 386 387 return sres; 388} 389/* --------------------------------------------------------------------- 390 PRE/POST wrappers for mips/Linux-specific syscalls 391 ------------------------------------------------------------------ */ 392#define PRE(name) DEFN_PRE_TEMPLATE(mips_linux, name) 393#define POST(name) DEFN_POST_TEMPLATE(mips_linux, name) 394 395/* Add prototypes for the wrappers declared here, so that gcc doesn't 396 harass us for not having prototypes. Really this is a kludge -- 397 the right thing to do is to make these wrappers 'static' since they 398 aren't visible outside this file, but that requires even more macro 399 magic. */ 400//DECL_TEMPLATE (mips_linux, sys_syscall); 401DECL_TEMPLATE (mips_linux, sys_mmap); 402DECL_TEMPLATE (mips_linux, sys_mmap2); 403DECL_TEMPLATE (mips_linux, sys_stat64); 404DECL_TEMPLATE (mips_linux, sys_lstat64); 405DECL_TEMPLATE (mips_linux, sys_fadvise64); 406DECL_TEMPLATE (mips_linux, sys_fstatat64); 407DECL_TEMPLATE (mips_linux, sys_fstat64); 408DECL_TEMPLATE (mips_linux, sys_sigreturn); 409DECL_TEMPLATE (mips_linux, sys_rt_sigreturn); 410DECL_TEMPLATE (mips_linux, sys_cacheflush); 411DECL_TEMPLATE (mips_linux, sys_set_thread_area); 412DECL_TEMPLATE (mips_linux, sys_pipe); 413DECL_TEMPLATE (mips_linux, sys_prctl); 414DECL_TEMPLATE (mips_linux, sys_ptrace); 415 416PRE(sys_mmap2) 417{ 418 /* Exactly like sys_mmap() except the file offset is specified in 4096 byte 419 units rather than bytes, so that it can be used for files bigger than 420 2^32 bytes. */ 421 SysRes r; 422 PRINT("sys_mmap2 ( %#lx, %lu, %lu, %lu, %lu, %lu )", 423 ARG1, ARG2, SARG3, SARG4, SARG5, SARG6); 424 PRE_REG_READ6(long, "mmap2", unsigned long, start, unsigned long, length, 425 unsigned long, prot, unsigned long, flags, 426 unsigned long, fd, unsigned long, offset); 427 r = mips_PRE_sys_mmap(tid, ARG1, ARG2, ARG3, ARG4, ARG5, 428 4096 * (Off64T) ARG6); 429 SET_STATUS_from_SysRes(r); 430} 431 432PRE(sys_mmap) 433{ 434 SysRes r; 435 PRINT("sys_mmap ( %#lx, %lu, %ld, %ld, %ld, %lu )", 436 ARG1, ARG2, SARG3, SARG4, SARG5, ARG6); 437 PRE_REG_READ6(long, "mmap", unsigned long, start, vki_size_t, length, 438 int, prot, int, flags, int, fd, unsigned long, offset); 439 r = mips_PRE_sys_mmap(tid, ARG1, ARG2, ARG3, ARG4, ARG5, (Off64T) ARG6); 440 SET_STATUS_from_SysRes(r); 441} 442 443PRE(sys_ptrace) 444{ 445 PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", SARG1, SARG2, ARG3, ARG4); 446 PRE_REG_READ4(int, "ptrace", 447 long, request, long, pid, unsigned long, addr, 448 unsigned long, data); 449 switch (ARG1) { 450 case VKI_PTRACE_PEEKTEXT: 451 case VKI_PTRACE_PEEKDATA: 452 case VKI_PTRACE_PEEKUSR: 453 PRE_MEM_WRITE("ptrace(peek)", ARG4, sizeof(long)); 454 break; 455 case VKI_PTRACE_GETEVENTMSG: 456 PRE_MEM_WRITE("ptrace(geteventmsg)", ARG4, sizeof(unsigned long)); 457 break; 458 case VKI_PTRACE_GETSIGINFO: 459 PRE_MEM_WRITE("ptrace(getsiginfo)", ARG4, sizeof(vki_siginfo_t)); 460 break; 461 case VKI_PTRACE_SETSIGINFO: 462 PRE_MEM_READ("ptrace(setsiginfo)", ARG4, sizeof(vki_siginfo_t)); 463 break; 464 case VKI_PTRACE_GETREGSET: 465 ML_(linux_PRE_getregset)(tid, ARG3, ARG4); 466 break; 467 default: 468 break; 469 } 470} 471 472POST(sys_ptrace) 473{ 474 switch (ARG1) { 475 case VKI_PTRACE_TRACEME: 476 ML_(linux_POST_traceme)(tid); 477 break; 478 case VKI_PTRACE_PEEKTEXT: 479 case VKI_PTRACE_PEEKDATA: 480 case VKI_PTRACE_PEEKUSR: 481 POST_MEM_WRITE (ARG4, sizeof(long)); 482 break; 483 case VKI_PTRACE_GETEVENTMSG: 484 POST_MEM_WRITE (ARG4, sizeof(unsigned long)); 485 break; 486 case VKI_PTRACE_GETSIGINFO: 487 POST_MEM_WRITE (ARG4, sizeof(vki_siginfo_t)); 488 break; 489 case VKI_PTRACE_GETREGSET: 490 ML_(linux_POST_getregset)(tid, ARG3, ARG4); 491 break; 492 default: 493 break; 494 } 495} 496 497// XXX: lstat64/fstat64/stat64 are generic, but not necessarily 498// applicable to every architecture -- I think only to 32-bit archs. 499// We're going to need something like linux/core_os32.h for such 500// things, eventually, I think. --njn 501 502PRE(sys_lstat64) 503{ 504 PRINT ("sys_lstat64 ( %#lx(%s), %#lx )", ARG1, (HChar *) ARG1, ARG2); 505 PRE_REG_READ2 (long, "lstat64", char *, file_name, struct stat64 *, buf); 506 PRE_MEM_RASCIIZ ("lstat64(file_name)", ARG1); 507 PRE_MEM_WRITE ("lstat64(buf)", ARG2, sizeof (struct vki_stat64)); 508} 509 510POST(sys_lstat64) 511{ 512 vg_assert (SUCCESS); 513 if (RES == 0) 514 { 515 POST_MEM_WRITE (ARG2, sizeof (struct vki_stat64)); 516 } 517} 518 519PRE(sys_stat64) 520{ 521 PRINT ("sys_stat64 ( %#lx(%s), %#lx )", ARG1, (HChar *) ARG1, ARG2); 522 PRE_REG_READ2 (long, "stat64", char *, file_name, struct stat64 *, buf); 523 PRE_MEM_RASCIIZ ("stat64(file_name)", ARG1); 524 PRE_MEM_WRITE ("stat64(buf)", ARG2, sizeof (struct vki_stat64)); 525} 526 527POST(sys_stat64) 528{ 529 POST_MEM_WRITE (ARG2, sizeof (struct vki_stat64)); 530} 531 532PRE(sys_fadvise64) 533{ 534 PRINT("sys_fadvise64 ( %ld, %llu, %llu, %ld )", 535 SARG1, MERGE64(ARG3,ARG4), MERGE64(ARG5, ARG6), SARG7); 536 537 if (VG_(tdict).track_pre_reg_read) { 538 PRRSN; 539 PRA1("fadvise64", int, fd); 540 PRA3("fadvise64", vki_u32, MERGE64_FIRST(offset)); 541 PRA4("fadvise64", vki_u32, MERGE64_SECOND(offset)); 542 PRA5("fadvise64", vki_u32, MERGE64_FIRST(len)); 543 PRA6("fadvise64", vki_u32, MERGE64_SECOND(len)); 544 PRA7("fadvise64", int, advice); 545 } 546} 547 548PRE(sys_fstatat64) 549{ 550 // ARG4 = int flags; Flags are or'ed together, therefore writing them 551 // as a hex constant is more meaningful. 552 PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx, %#lx )", 553 SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4); 554 PRE_REG_READ4(long, "fstatat64", 555 int, dfd, char *, file_name, struct stat64 *, buf, int, flags); 556 PRE_MEM_RASCIIZ ("fstatat64(file_name)", ARG2); 557 PRE_MEM_WRITE ("fstatat64(buf)", ARG3, sizeof (struct vki_stat64)); 558} 559 560POST(sys_fstatat64) 561{ 562 POST_MEM_WRITE (ARG3, sizeof (struct vki_stat64)); 563} 564 565PRE(sys_fstat64) 566{ 567 PRINT ("sys_fstat64 ( %lu, %#lx )", SARG1, ARG2); 568 PRE_REG_READ2 (long, "fstat64", unsigned long, fd, struct stat64 *, buf); 569 PRE_MEM_WRITE ("fstat64(buf)", ARG2, sizeof (struct vki_stat64)); 570} 571 572POST(sys_fstat64) 573{ 574 POST_MEM_WRITE (ARG2, sizeof (struct vki_stat64)); 575} 576 577PRE(sys_sigreturn) 578{ 579 PRINT ("sys_sigreturn ( )"); 580 vg_assert (VG_ (is_valid_tid) (tid)); 581 vg_assert (tid >= 1 && tid < VG_N_THREADS); 582 vg_assert (VG_ (is_running_thread) (tid)); 583 VG_ (sigframe_destroy) (tid, False); 584 /* Tell the driver not to update the guest state with the "result", 585 and set a bogus result to keep it happy. */ 586 *flags |= SfNoWriteResult; 587 SET_STATUS_Success (0); 588 /* Check to see if any signals arose as a result of this. */ 589 *flags |= SfPollAfter; 590} 591 592PRE(sys_rt_sigreturn) 593{ 594 PRINT ("rt_sigreturn ( )"); 595 vg_assert (VG_ (is_valid_tid) (tid)); 596 vg_assert (tid >= 1 && tid < VG_N_THREADS); 597 vg_assert (VG_ (is_running_thread) (tid)); 598 /* Restore register state from frame and remove it */ 599 VG_ (sigframe_destroy) (tid, True); 600 /* Tell the driver not to update the guest state with the "result", 601 and set a bogus result to keep it happy. */ 602 *flags |= SfNoWriteResult; 603 SET_STATUS_Success (0); 604 /* Check to see if any signals arose as a result of this. */ 605 *flags |= SfPollAfter; 606} 607 608PRE(sys_set_thread_area) 609{ 610 PRINT ("set_thread_area (%lx)", ARG1); 611 PRE_REG_READ1(long, "set_thread_area", unsigned long, addr); 612 SET_STATUS_from_SysRes( sys_set_tls( tid, ARG1 ) ); 613} 614 615/* Very much MIPS specific */ 616PRE(sys_cacheflush) 617{ 618 PRINT ("cacheflush (%lx, %ld, %ld)", ARG1, SARG2, SARG3); 619 PRE_REG_READ3(long, "cacheflush", unsigned long, addr, 620 int, nbytes, int, cache); 621 VG_ (discard_translations) ((Addr)ARG1, (ULong) ARG2, 622 "PRE(sys_cacheflush)"); 623 SET_STATUS_Success (0); 624} 625 626PRE(sys_pipe) 627{ 628 PRINT("sys_pipe ( %#lx )", ARG1); 629 PRE_REG_READ1(int, "pipe", int *, filedes); 630 PRE_MEM_WRITE( "pipe(filedes)", ARG1, 2*sizeof(int) ); 631} 632 633POST(sys_pipe) 634{ 635 Int p0, p1; 636 vg_assert(SUCCESS); 637 p0 = RES; 638 p1 = sr_ResEx(status->sres); 639 640 if (!ML_(fd_allowed)(p0, "pipe", tid, True) || 641 !ML_(fd_allowed)(p1, "pipe", tid, True)) { 642 VG_(close)(p0); 643 VG_(close)(p1); 644 SET_STATUS_Failure( VKI_EMFILE ); 645 } else { 646 if (VG_(clo_track_fds)) { 647 ML_(record_fd_open_nameless)(tid, p0); 648 ML_(record_fd_open_nameless)(tid, p1); 649 } 650 } 651} 652 653PRE(sys_prctl) 654{ 655 switch (ARG1) { 656 case VKI_PR_SET_FP_MODE: 657 { 658 VexArchInfo vai; 659 VG_(machine_get_VexArchInfo)(NULL, &vai); 660 /* Reject unsupported modes */ 661 if ((ARG2 & ~VKI_PR_FP_MODE_FR) || 662 ((ARG2 & VKI_PR_FP_MODE_FR) && 663 !VEX_MIPS_HOST_FP_MODE(vai.hwcaps))) { 664 SET_STATUS_Failure(VKI_EOPNOTSUPP); 665 } else { 666 if (!(VG_(threads)[tid].arch.vex.guest_CP0_status & 667 MIPS_CP0_STATUS_FR) != !(ARG2 & VKI_PR_FP_MODE_FR)) { 668 ThreadId t; 669 for (t = 1; t < VG_N_THREADS; t++) { 670 if (VG_(threads)[t].status != VgTs_Empty) { 671 if (ARG2 & VKI_PR_FP_MODE_FR) { 672 VG_(threads)[t].arch.vex.guest_CP0_status |= 673 MIPS_CP0_STATUS_FR; 674 } else { 675 VG_(threads)[t].arch.vex.guest_CP0_status &= 676 ~MIPS_CP0_STATUS_FR; 677 } 678 } 679 } 680 /* Discard all translations */ 681 VG_(discard_translations)(0, 0xfffffffful, "prctl(PR_SET_FP_MODE)"); 682 } 683 SET_STATUS_Success(0); 684 } 685 break; 686 } 687 case VKI_PR_GET_FP_MODE: 688 if (VG_(threads)[tid].arch.vex.guest_CP0_status & MIPS_CP0_STATUS_FR) 689 SET_STATUS_Success(VKI_PR_FP_MODE_FR); 690 else 691 SET_STATUS_Success(0); 692 break; 693 default: 694 WRAPPER_PRE_NAME(linux, sys_prctl)(tid, layout, arrghs, status, flags); 695 break; 696 } 697} 698 699POST(sys_prctl) 700{ 701 WRAPPER_POST_NAME(linux, sys_prctl)(tid, arrghs, status); 702} 703 704#undef PRE 705#undef POST 706 707/* --------------------------------------------------------------------- 708 The mips/Linux syscall table 709 ------------------------------------------------------------------ */ 710#define PLAX_(sysno, name) WRAPPER_ENTRY_X_(mips_linux, sysno, name) 711#define PLAXY(sysno, name) WRAPPER_ENTRY_XY(mips_linux, sysno, name) 712 713// This table maps from __NR_xxx syscall numbers (from 714// linux/include/asm-mips/unistd.h) to the appropriate PRE/POST sys_foo() 715// wrappers on mips (as per sys_call_table in linux/arch/mips/kernel/entry.S). 716// 717 718// For those syscalls not handled by Valgrind, the annotation indicate its 719// arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/? 720// (unknown). 721 722static SyscallTableEntry syscall_main_table[] = { 723 //.. PLAXY (__NR_syscall, sys_syscall), // 0 724 GENX_ (__NR_exit, sys_exit), // 1 725 GENX_ (__NR_fork, sys_fork), // 2 726 GENXY (__NR_read, sys_read), // 3 727 GENX_ (__NR_write, sys_write), // 4 728 GENXY (__NR_open, sys_open), // 5 729 GENXY (__NR_close, sys_close), // 6 730 GENXY (__NR_waitpid, sys_waitpid), // 7 731 GENXY (__NR_creat, sys_creat), // 8 732 GENX_ (__NR_link, sys_link), // 9 733 GENX_ (__NR_unlink, sys_unlink), // 10 734 GENX_ (__NR_execve, sys_execve), // 11 735 GENX_ (__NR_chdir, sys_chdir), // 12 736 GENXY (__NR_time, sys_time), // 13 737 GENX_ (__NR_mknod, sys_mknod), // 14 738 GENX_ (__NR_chmod, sys_chmod), // 15 739 GENX_ (__NR_lchown, sys_lchown), // 16 740 //.. 741 LINX_ (__NR_lseek, sys_lseek), // 19 742 GENX_ (__NR_getpid, sys_getpid), // 20 743 LINX_ (__NR_mount, sys_mount), // 21 744 LINX_ (__NR_umount, sys_oldumount), // 22 745 GENX_ (__NR_setuid, sys_setuid), // 23 746 GENX_ (__NR_getuid, sys_getuid), // 24 747 LINX_ (__NR_stime, sys_stime), // 25 748 PLAXY(__NR_ptrace, sys_ptrace), // 26 749 GENX_ (__NR_alarm, sys_alarm), // 27 750 //.. // (__NR_oldfstat, sys_fstat), // 28 751 GENX_ (__NR_pause, sys_pause), // 29 752 LINX_ (__NR_utime, sys_utime), // 30 753 //.. GENX_(__NR_stty, sys_ni_syscall), // 31 754 //.. GENX_(__NR_gtty, sys_ni_syscall), // 32 755 GENX_ (__NR_access, sys_access), // 33 756 //.. GENX_(__NR_nice, sys_nice), // 34 757 //.. GENX_(__NR_ftime, sys_ni_syscall), // 35 758 //.. GENX_(__NR_sync, sys_sync), // 36 759 GENX_ (__NR_kill, sys_kill), // 37 760 GENX_ (__NR_rename, sys_rename), // 38 761 GENX_ (__NR_mkdir, sys_mkdir), // 39 762 GENX_ (__NR_rmdir, sys_rmdir), // 40 763 GENXY (__NR_dup, sys_dup), // 41 764 PLAXY (__NR_pipe, sys_pipe), // 42 765 GENXY (__NR_times, sys_times), // 43 766 //.. GENX_(__NR_prof, sys_ni_syscall), // 44 767 GENX_ (__NR_brk, sys_brk), // 45 768 GENX_ (__NR_setgid, sys_setgid), // 46 769 GENX_ (__NR_getgid, sys_getgid), // 47 770 //.. // (__NR_signal, sys_signal), // 48 771 GENX_ (__NR_geteuid, sys_geteuid), // 49 772 GENX_ (__NR_getegid, sys_getegid), // 50 773 //.. GENX_(__NR_acct, sys_acct), // 51 774 LINX_ (__NR_umount2, sys_umount), // 52 775 //.. GENX_(__NR_lock, sys_ni_syscall), // 53 776 LINXY (__NR_ioctl, sys_ioctl), // 54 777 LINXY (__NR_fcntl, sys_fcntl), // 55 778 //.. GENX_(__NR_mpx, sys_ni_syscall), // 56 779 GENX_ (__NR_setpgid, sys_setpgid), // 57 780 //.. GENX_(__NR_ulimit, sys_ni_syscall), // 58 781 //.. // (__NR_oldolduname, sys_olduname), // 59 782 GENX_ (__NR_umask, sys_umask), // 60 783 GENX_ (__NR_chroot, sys_chroot), // 61 784 //.. // (__NR_ustat, sys_ustat) // 62 785 GENXY (__NR_dup2, sys_dup2), // 63 786 GENX_ (__NR_getppid, sys_getppid), // 64 787 GENX_ (__NR_getpgrp, sys_getpgrp), // 65 788 GENX_ (__NR_setsid, sys_setsid), // 66 789 LINXY (__NR_sigaction, sys_sigaction), // 67 790 //.. // (__NR_sgetmask, sys_sgetmask), // 68 791 //.. // (__NR_ssetmask, sys_ssetmask), // 69 792 GENX_ (__NR_setreuid, sys_setreuid), // 70 793 GENX_ (__NR_setregid, sys_setregid), // 71 794 // PLAX_(__NR_sigsuspend, sys_sigsuspend), // 72 795 LINXY (__NR_sigpending, sys_sigpending), // 73 796 //.. // (__NR_sethostname, sys_sethostname), // 74 797 GENX_ (__NR_setrlimit, sys_setrlimit), // 75 798 GENXY (__NR_getrlimit, sys_getrlimit), // 76 799 GENXY (__NR_getrusage, sys_getrusage), // 77 800 GENXY (__NR_gettimeofday, sys_gettimeofday), // 78 801 GENX_ (__NR_settimeofday, sys_settimeofday), // 79 802 GENXY (__NR_getgroups, sys_getgroups), // 80 803 GENX_ (__NR_setgroups, sys_setgroups), // 81 804 //.. PLAX_(__NR_select, old_select), // 82 805 GENX_ (__NR_symlink, sys_symlink), // 83 806 //.. // (__NR_oldlstat, sys_lstat), // 84 807 GENX_ (__NR_readlink, sys_readlink), // 85 808 //.. // (__NR_uselib, sys_uselib), // 86 809 //.. // (__NR_swapon, sys_swapon), // 87 810 //.. // (__NR_reboot, sys_reboot), // 88 811 //.. // (__NR_readdir, old_readdir), // 89 812 PLAX_ (__NR_mmap, sys_mmap), // 90 813 GENXY (__NR_munmap, sys_munmap), // 91 814 GENX_ (__NR_truncate, sys_truncate), // 92 815 GENX_ (__NR_ftruncate, sys_ftruncate), // 93 816 GENX_ (__NR_fchmod, sys_fchmod), // 94 817 GENX_ (__NR_fchown, sys_fchown), // 95 818 GENX_ (__NR_getpriority, sys_getpriority), // 96 819 GENX_ (__NR_setpriority, sys_setpriority), // 97 820 //.. GENX_(__NR_profil, sys_ni_syscall), // 98 821 GENXY (__NR_statfs, sys_statfs), // 99 822 GENXY (__NR_fstatfs, sys_fstatfs), // 100 823 //.. LINX_(__NR_ioperm, sys_ioperm), // 101 824 LINXY (__NR_socketcall, sys_socketcall), // 102 825 LINXY (__NR_syslog, sys_syslog), // 103 826 GENXY (__NR_setitimer, sys_setitimer), // 104 827 //.. GENXY(__NR_getitimer, sys_getitimer), // 105 828 GENXY (__NR_stat, sys_newstat), // 106 829 GENXY (__NR_lstat, sys_newlstat), // 107 830 GENXY (__NR_fstat, sys_newfstat), // 108 831 //.. // (__NR_olduname, sys_uname), // 109 832 //.. GENX_(__NR_iopl, sys_iopl), // 110 833 //.. LINX_(__NR_vhangup, sys_vhangup), // 111 834 //.. GENX_(__NR_idle, sys_ni_syscall), // 112 835 //.. // (__NR_vm86old, sys_vm86old), // 113 836 GENXY (__NR_wait4, sys_wait4), // 114 837 //.. // (__NR_swapoff, sys_swapoff), // 115 838 LINXY (__NR_sysinfo, sys_sysinfo), // 116 839 LINXY (__NR_ipc, sys_ipc), // 117 840 GENX_ (__NR_fsync, sys_fsync), // 118 841 PLAX_ (__NR_sigreturn, sys_sigreturn), // 119 842 LINX_ (__NR_clone, sys_clone), // 120 843 //.. // (__NR_setdomainname, sys_setdomainname), // 121 844 GENXY (__NR_uname, sys_newuname), // 122 845 //.. PLAX_(__NR_modify_ldt, sys_modify_ldt), // 123 846 //.. LINXY(__NR_adjtimex, sys_adjtimex), // 124 847 GENXY (__NR_mprotect, sys_mprotect), // 125 848 LINXY (__NR_sigprocmask, sys_sigprocmask), // 126 849 //.. GENX_(__NR_create_module, sys_ni_syscall), // 127 850 //.. GENX_(__NR_init_module, sys_init_module), // 128 851 //.. // (__NR_delete_module, sys_delete_module), // 129 852 //.. GENX_(__NR_get_kernel_syms, sys_ni_syscall), // 130 853 //.. LINX_(__NR_quotactl, sys_quotactl), // 131 854 GENX_ (__NR_getpgid, sys_getpgid), // 132 855 GENX_ (__NR_fchdir, sys_fchdir), // 133 856 //.. // (__NR_bdflush, sys_bdflush), // 134 857 //.. // (__NR_sysfs, sys_sysfs), // 135 858 LINX_ (__NR_personality, sys_personality), // 136 859 //.. GENX_(__NR_afs_syscall, sys_ni_syscall), // 137 860 LINX_ (__NR_setfsuid, sys_setfsuid), // 138 861 LINX_ (__NR_setfsgid, sys_setfsgid), // 139 862 LINXY (__NR__llseek, sys_llseek), // 140 863 GENXY (__NR_getdents, sys_getdents), // 141 864 GENX_ (__NR__newselect, sys_select), // 142 865 GENX_ (__NR_flock, sys_flock), // 143 866 GENX_ (__NR_msync, sys_msync), // 144 867 GENXY (__NR_readv, sys_readv), // 145 868 GENX_ (__NR_writev, sys_writev), // 146 869 PLAX_ (__NR_cacheflush, sys_cacheflush), // 147 870 GENX_ (__NR_getsid, sys_getsid), // 151 871 GENX_ (__NR_fdatasync, sys_fdatasync), // 152 872 LINXY (__NR__sysctl, sys_sysctl), // 153 873 GENX_ (__NR_mlock, sys_mlock), // 154 874 GENX_ (__NR_munlock, sys_munlock), // 155 875 GENX_ (__NR_mlockall, sys_mlockall), // 156 876 LINX_ (__NR_munlockall, sys_munlockall), // 157 877 //.. LINXY(__NR_sched_setparam, sys_sched_setparam), // 158 878 LINXY (__NR_sched_getparam, sys_sched_getparam), // 159 879 LINX_ (__NR_sched_setscheduler, sys_sched_setscheduler), // 160 880 LINX_ (__NR_sched_getscheduler, sys_sched_getscheduler), // 161 881 LINX_ (__NR_sched_yield, sys_sched_yield), // 162 882 LINX_ (__NR_sched_get_priority_max, sys_sched_get_priority_max), // 163 883 LINX_ (__NR_sched_get_priority_min, sys_sched_get_priority_min), // 164 884 //.. //LINX?(__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 165 885 GENXY (__NR_nanosleep, sys_nanosleep), // 166 886 GENX_ (__NR_mremap, sys_mremap), // 167 887 LINXY (__NR_accept, sys_accept), // 168 888 LINX_ (__NR_bind, sys_bind), // 169 889 LINX_ (__NR_connect, sys_connect), // 170 890 LINXY (__NR_getpeername, sys_getpeername), // 171 891 LINXY (__NR_getsockname, sys_getsockname), // 172 892 LINXY (__NR_getsockopt, sys_getsockopt), // 173 893 LINX_ (__NR_listen, sys_listen), // 174 894 LINXY (__NR_recv, sys_recv), // 175 895 LINXY (__NR_recvfrom, sys_recvfrom), // 176 896 LINXY (__NR_recvmsg, sys_recvmsg), // 177 897 LINX_ (__NR_send, sys_send), // 178 898 LINX_ (__NR_sendmsg, sys_sendmsg), // 179 899 LINX_ (__NR_sendto, sys_sendto), // 180 900 LINX_ (__NR_setsockopt, sys_setsockopt), // 181 901 LINX_ (__NR_shutdown, sys_shutdown), // 182 902 LINXY (__NR_socket, sys_socket), // 183 903 LINXY (__NR_socketpair, sys_socketpair), // 184 904 LINX_ (__NR_setresuid, sys_setresuid), // 185 905 LINXY (__NR_getresuid, sys_getresuid), // 186 906 //.. GENX_(__NR_query_module, sys_ni_syscall), // 187 907 GENXY (__NR_poll, sys_poll), // 188 908 //.. 909 LINX_ (__NR_setresgid, sys_setresgid), // 190 910 LINXY (__NR_getresgid, sys_getresgid), // 191 911 PLAXY (__NR_prctl, sys_prctl), // 192 912 PLAX_ (__NR_rt_sigreturn, sys_rt_sigreturn), // 193 913 LINXY (__NR_rt_sigaction, sys_rt_sigaction), // 194 914 LINXY (__NR_rt_sigprocmask, sys_rt_sigprocmask), // 195 915 LINXY (__NR_rt_sigpending, sys_rt_sigpending), // 196 916 LINXY (__NR_rt_sigtimedwait, sys_rt_sigtimedwait), // 197 917 LINXY (__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo), // 198 918 LINX_ (__NR_rt_sigsuspend, sys_rt_sigsuspend), // 199 919 GENXY (__NR_pread64, sys_pread64), // 200 920 GENX_ (__NR_pwrite64, sys_pwrite64), // 201 921 GENX_ (__NR_chown, sys_chown), // 202 922 GENXY (__NR_getcwd, sys_getcwd), // 203 923 LINXY (__NR_capget, sys_capget), // 204 924 //.. LINX_(__NR_capset, sys_capset), // 205 925 GENXY (__NR_sigaltstack, sys_sigaltstack), // 206 926 LINXY (__NR_sendfile, sys_sendfile), // 207 927 //.. GENXY(__NR_getpmsg, sys_getpmsg), // 208 928 //.. GENX_(__NR_putpmsg, sys_putpmsg), // 209 929 PLAX_ (__NR_mmap2, sys_mmap2), // 210 930 // GENX_(__NR_truncate64, sys_truncate64), // 211 931 GENX_ (__NR_ftruncate64, sys_ftruncate64), // 212 932 PLAXY (__NR_stat64, sys_stat64), // 213 933 PLAXY (__NR_lstat64, sys_lstat64), // 214 934 PLAXY (__NR_fstat64, sys_fstat64), // 215 935 //.. 936 GENXY (__NR_mincore, sys_mincore), // 217 937 GENX_ (__NR_madvise, sys_madvise), // 218 938 GENXY (__NR_getdents64, sys_getdents64), // 219 939 LINXY (__NR_fcntl64, sys_fcntl64), // 220 940 //.. 941 LINX_ (__NR_gettid, sys_gettid), // 222 942 //.. 943 LINXY (__NR_getxattr, sys_getxattr), // 227 944 LINXY (__NR_lgetxattr, sys_lgetxattr), // 228 945 LINXY (__NR_fgetxattr, sys_fgetxattr), // 229 946 LINXY (__NR_listxattr, sys_listxattr), // 230 947 LINXY (__NR_llistxattr, sys_llistxattr), // 231 948 LINXY (__NR_flistxattr, sys_flistxattr), // 232 949 LINX_ (__NR_removexattr, sys_removexattr), // 233 950 LINX_ (__NR_lremovexattr, sys_lremovexattr), // 234 951 LINX_ (__NR_fremovexattr, sys_fremovexattr), // 235 952 //.. 953 LINXY (__NR_sendfile64, sys_sendfile64), // 237 954 LINXY (__NR_futex, sys_futex), // 238 955 LINX_ (__NR_sched_setaffinity, sys_sched_setaffinity), // 239 956 LINXY (__NR_sched_getaffinity, sys_sched_getaffinity), // 240 957 LINX_ (__NR_io_setup, sys_io_setup), // 241 958 LINX_ (__NR_io_destroy, sys_io_destroy), // 242 959 LINXY (__NR_io_getevents, sys_io_getevents), // 243 960 LINX_ (__NR_io_submit, sys_io_submit), // 244 961 LINXY (__NR_io_cancel, sys_io_cancel), // 245 962 LINX_ (__NR_exit_group, sys_exit_group), // 246 963 //.. 964 LINXY (__NR_epoll_create, sys_epoll_create), // 248 965 LINX_ (__NR_epoll_ctl, sys_epoll_ctl), // 249 966 LINXY (__NR_epoll_wait, sys_epoll_wait), // 250 967 //.. 968 LINX_ (__NR_set_tid_address, sys_set_tid_address), // 252 969 PLAX_ (__NR_fadvise64, sys_fadvise64), // 254 970 GENXY (__NR_statfs64, sys_statfs64), // 255 971 GENXY (__NR_fstatfs64, sys_fstatfs64), // 256 972 //.. 973 LINXY (__NR_timer_create, sys_timer_create), // 257 974 LINXY (__NR_timer_settime, sys_timer_settime), // 258 975 LINXY (__NR_timer_gettime, sys_timer_gettime), // 259 976 LINX_ (__NR_timer_getoverrun, sys_timer_getoverrun), // 260 977 LINX_ (__NR_timer_delete, sys_timer_delete), // 261 978 LINX_ (__NR_clock_settime, sys_clock_settime), // 262 979 LINXY (__NR_clock_gettime, sys_clock_gettime), // 263 980 LINXY (__NR_clock_getres, sys_clock_getres), // 264 981 LINXY (__NR_clock_nanosleep, sys_clock_nanosleep), // 265 982 LINXY (__NR_tgkill, sys_tgkill), // 266 983 //.. GENX_(__NR_utimes, sys_utimes), // 267 984 LINXY (__NR_get_mempolicy, sys_get_mempolicy), // 269 985 LINX_ (__NR_set_mempolicy, sys_set_mempolicy), // 270 986 LINXY (__NR_mq_open, sys_mq_open), // 271 987 LINX_ (__NR_mq_unlink, sys_mq_unlink), // 272 988 LINX_ (__NR_mq_timedsend, sys_mq_timedsend), // 273 989 LINXY (__NR_mq_timedreceive, sys_mq_timedreceive), // 274 990 LINX_ (__NR_mq_notify, sys_mq_notify), // 275 991 LINXY (__NR_mq_getsetattr, sys_mq_getsetattr), // 276 992 LINX_ (__NR_inotify_init, sys_inotify_init), // 275 993 LINX_ (__NR_inotify_add_watch, sys_inotify_add_watch), // 276 994 LINX_ (__NR_inotify_rm_watch, sys_inotify_rm_watch), // 277 995 //.. 996 PLAX_ (__NR_set_thread_area, sys_set_thread_area), // 283 997 //.. 998 LINXY (__NR_openat, sys_openat), // 288 999 LINX_ (__NR_mkdirat, sys_mkdirat), // 289 1000 LINX_ (__NR_mknodat, sys_mknodat), // 290 1001 LINX_ (__NR_fchownat, sys_fchownat), // 291 1002 LINX_ (__NR_futimesat, sys_futimesat), // 292 1003 PLAXY (__NR_fstatat64, sys_fstatat64), // 293 1004 LINX_ (__NR_unlinkat, sys_unlinkat), // 294 1005 LINX_ (__NR_renameat, sys_renameat), // 295 1006 LINX_ (__NR_linkat, sys_linkat), // 296 1007 LINX_ (__NR_symlinkat, sys_symlinkat), // 297 1008 LINX_ (__NR_readlinkat, sys_readlinkat), // 298 1009 LINX_ (__NR_fchmodat, sys_fchmodat), // 299 1010 LINX_ (__NR_faccessat, sys_faccessat), // 300 1011 LINXY (__NR_pselect6, sys_pselect6), // 301 1012 LINXY (__NR_ppoll, sys_ppoll), // 302 1013 //.. 1014 LINX_ (__NR_set_robust_list, sys_set_robust_list), // 309 1015 LINXY (__NR_get_robust_list, sys_get_robust_list), // 310 1016 //.. 1017 LINXY (__NR_epoll_pwait, sys_epoll_pwait), // 313 1018 //.. 1019 LINX_ (__NR_utimensat, sys_utimensat), // 316 1020 //.. 1021 LINX_ (__NR_fallocate, sys_fallocate), // 320 1022 LINXY (__NR_timerfd_create, sys_timerfd_create), // 321 1023 LINXY (__NR_timerfd_gettime, sys_timerfd_gettime), // 322 1024 LINXY (__NR_timerfd_settime, sys_timerfd_settime), // 323 1025 LINXY (__NR_signalfd4, sys_signalfd4), // 324 1026 LINXY (__NR_eventfd2, sys_eventfd2), // 325 1027 //.. 1028 LINXY (__NR_pipe2, sys_pipe2), // 328 1029 LINXY (__NR_inotify_init1, sys_inotify_init1), // 329 1030 //.. 1031 LINXY (__NR_prlimit64, sys_prlimit64), // 338 1032 //.. 1033 LINXY (__NR_clock_adjtime, sys_clock_adjtime), // 341 1034 LINX_ (__NR_syncfs, sys_syncfs), // 342 1035 //.. 1036 LINXY (__NR_process_vm_readv, sys_process_vm_readv), // 345 1037 LINX_ (__NR_process_vm_writev, sys_process_vm_writev), // 346 1038 //.. 1039 LINXY(__NR_getrandom, sys_getrandom), // 353 1040 LINXY(__NR_memfd_create, sys_memfd_create) // 354 1041}; 1042 1043SyscallTableEntry* ML_(get_linux_syscall_entry) (UInt sysno) 1044{ 1045 const UInt syscall_main_table_size 1046 = sizeof (syscall_main_table) / sizeof (syscall_main_table[0]); 1047 /* Is it in the contiguous initial section of the table? */ 1048 if (sysno < syscall_main_table_size) { 1049 SyscallTableEntry * sys = &syscall_main_table[sysno]; 1050 if (sys->before == NULL) 1051 return NULL; /* No entry. */ 1052 else 1053 return sys; 1054 } 1055 /* Can't find a wrapper. */ 1056 return NULL; 1057} 1058 1059#endif // defined(VGP_mips32_linux) 1060 1061/*--------------------------------------------------------------------*/ 1062/*--- end syswrap-mips-linux.c ---*/ 1063/*--------------------------------------------------------------------*/ 1064