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-2012 RT-RK 11 mips-valgrind (at) 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_libcsetjmp.h" // to keep _threadstate.h happy 36 #include "pub_core_threadstate.h" 37 #include "pub_core_aspacemgr.h" 38 #include "pub_core_debuglog.h" 39 #include "pub_core_libcbase.h" 40 #include "pub_core_libcassert.h" 41 #include "pub_core_libcprint.h" 42 #include "pub_core_libcproc.h" 43 #include "pub_core_libcsignal.h" 44 #include "pub_core_options.h" 45 #include "pub_core_scheduler.h" 46 #include "pub_core_sigframe.h" // For VG_(sigframe_destroy)() 47 #include "pub_core_signals.h" 48 #include "pub_core_syscall.h" 49 #include "pub_core_syswrap.h" 50 #include "pub_core_tooliface.h" 51 #include "pub_core_stacks.h" // VG_(register_stack) 52 #include "pub_core_transtab.h" // VG_(discard_translations) 53 #include "priv_types_n_macros.h" 54 #include "priv_syswrap-generic.h" /* for decls of generic wrappers */ 55 #include "priv_syswrap-linux.h" /* for decls of linux-ish wrappers */ 56 #include "priv_syswrap-main.h" 57 58 #include "pub_core_debuginfo.h" // VG_(di_notify_*) 59 #include "pub_core_xarray.h" 60 #include "pub_core_clientstate.h" // VG_(brk_base), VG_(brk_limit) 61 #include "pub_core_errormgr.h" 62 #include "pub_tool_gdbserver.h" // VG_(gdbserver) 63 #include "pub_core_libcfile.h" 64 #include "pub_core_machine.h" // VG_(get_SP) 65 #include "pub_core_mallocfree.h" 66 #include "pub_core_stacktrace.h" // For VG_(get_and_pp_StackTrace)() 67 #include "pub_core_ume.h" 68 69 #include "priv_syswrap-generic.h" 70 71 #include "config.h" 72 73 #include <errno.h> 74 75 /* --------------------------------------------------------------------- 76 clone() handling 77 ------------------------------------------------------------------ */ 78 /* Call f(arg1), but first switch stacks, using 'stack' as the new 79 stack, and use 'retaddr' as f's return-to address. Also, clear all 80 the integer registers before entering f.*/ 81 82 __attribute__ ((noreturn)) 83 void ML_ (call_on_new_stack_0_1) (Addr stack, Addr retaddr, 84 void (*f) (Word), Word arg1); 85 // a0 = stack 86 // a1 = retaddr 87 // a2 = f 88 // a3 = arg1 89 asm ( 90 ".text\n" 91 ".globl vgModuleLocal_call_on_new_stack_0_1\n" 92 "vgModuleLocal_call_on_new_stack_0_1:\n" 93 " move $29, $4\n\t" // stack to %sp 94 " move $25, $6\n\t" // f to t9/$25 95 " move $4, $7\n\t" // arg1 to $a0 96 " li $2, 0\n\t" // zero all GP regs 97 " li $3, 0\n\t" 98 " li $5, 0\n\t" 99 " li $6, 0\n\t" 100 " li $7, 0\n\t" 101 102 " li $12, 0\n\t" 103 " li $13, 0\n\t" 104 " li $14, 0\n\t" 105 " li $15, 0\n\t" 106 " li $16, 0\n\t" 107 " li $17, 0\n\t" 108 " li $18, 0\n\t" 109 " li $19, 0\n\t" 110 " li $20, 0\n\t" 111 " li $21, 0\n\t" 112 " li $22, 0\n\t" 113 " li $23, 0\n\t" 114 " li $24, 0\n\t" 115 " jr $25\n\t" // jump to dst 116 " break 0x7\n" // should never get here 117 ".previous\n" 118 ); 119 120 /* 121 Perform a clone system call. clone is strange because it has 122 fork()-like return-twice semantics, so it needs special 123 handling here. 124 Upon entry, we have: 125 int (fn)(void*) in $a0 0 126 void* child_stack in $a1 4 127 int flags in $a2 8 128 void* arg in $a3 12 129 pid_t* child_tid in stack 16 130 pid_t* parent_tid in stack 20 131 void* tls_ptr in stack 24 132 133 System call requires: 134 int $__NR_clone in $v0 135 int flags in $a0 0 136 void* child_stack in $a1 4 137 pid_t* parent_tid in $a2 8 138 void* tls_ptr in $a3 12 139 pid_t* child_tid in stack 16 140 141 int clone(int (*fn)(void *arg), void *child_stack, int flags, void *arg, 142 void *parent_tidptr, void *tls, void *child_tidptr) 143 144 Returns an Int encoded in the linux-mips way, not a SysRes. 145 */ 146 #define __NR_CLONE VG_STRINGIFY(__NR_clone) 147 #define __NR_EXIT VG_STRINGIFY(__NR_exit) 148 149 //extern 150 UInt do_syscall_clone_mips_linux (Word (*fn) (void *), //a0 0 32 151 void *stack, //a1 4 36 152 Int flags, //a2 8 40 153 void *arg, //a3 12 44 154 Int * child_tid, //stack 16 48 155 Int * parent_tid, //stack 20 52 156 Int tls); //stack 24 56 157 asm ( 158 ".text\n" 159 " .globl do_syscall_clone_mips_linux\n" 160 " do_syscall_clone_mips_linux:\n" 161 " subu $29,$29,32\n\t" 162 " sw $31, 0($29)\n\t" 163 " sw $2, 4($29)\n\t" 164 " sw $3, 8($29)\n\t" 165 " sw $30, 12($29)\n\t" 166 " sw $28, 28($29)\n\t" 167 /* set up child stack with function and arg */ 168 /* syscall arg 2 child_stack is already in a1 */ 169 " subu $5, $5, 32\n\t" /* make space on stack */ 170 " sw $4, 0($5)\n\t" /* fn */ 171 " sw $7, 4($5)\n\t" /* fn arg */ 172 " sw $6, 8($5)\n\t" 173 /* get other args to clone */ 174 175 " move $4, $a2\n\t" /* a0 = flags */ 176 " lw $6, 52($29)\n\t" /* a2 = parent_tid */ 177 " lw $7, 48($29)\n\t" /* a3 = child_tid */ 178 " sw $7, 16($29)\n\t" /* 16(sp) = child_tid */ 179 " lw $7, 56($29)\n\t" /* a3 = tls_ptr */ 180 /* do the system call */ 181 182 " li $2, " __NR_CLONE "\n\t" /* __NR_clone */ 183 " syscall\n\t" 184 " nop\n\t" 185 186 " bnez $7, .Lerror\n\t" 187 " nop\n\t" 188 " beqz $2, .Lstart\n\t" 189 " nop\n\t" 190 191 " lw $31, 0($sp)\n\t" 192 " nop\n\t" 193 " lw $30, 12($sp)\n\t" 194 " nop\n\t" 195 " addu $29,$29,32\n\t" /* free stack */ 196 " nop\n\t" 197 " jr $31\n\t" 198 " nop\n\t" 199 200 ".Lerror:\n\t" 201 " li $31, 5\n\t" 202 " jr $31\n\t" 203 " nop\n\t" 204 205 ".Lstart:\n\t" 206 " lw $4, 4($29)\n\t" 207 " nop\n\t" 208 " lw $25, 0($29)\n\t" 209 " nop\n\t" 210 " jalr $25\n\t" 211 " nop\n\t" 212 213 " move $4, $2\n\t" /* retval from fn is in $v0 */ 214 " li $2, " __NR_EXIT "\n\t" /* NR_exit */ 215 " syscall\n\t" 216 " nop\n\t" 217 " .previous\n" 218 ); 219 220 #undef __NR_CLONE 221 #undef __NR_EXIT 222 223 // forward declarations 224 225 static void setup_child (ThreadArchState *, ThreadArchState *); 226 static SysRes sys_set_tls (ThreadId tid, Addr tlsptr); 227 /* 228 When a client clones, we need to keep track of the new thread. This means: 229 1. allocate a ThreadId+ThreadState+stack for the the thread 230 2. initialize the thread's new VCPU state 231 3. create the thread using the same args as the client requested, 232 but using the scheduler entrypoint for IP, and a separate stack 233 for SP. 234 */ 235 236 static SysRes do_clone (ThreadId ptid, 237 UInt flags, Addr sp, 238 Int * parent_tidptr, 239 Int * child_tidptr, 240 Addr child_tls) 241 { 242 const Bool debug = False; 243 ThreadId ctid = VG_ (alloc_ThreadState) (); 244 ThreadState * ptst = VG_ (get_ThreadState) (ptid); 245 ThreadState * ctst = VG_ (get_ThreadState) (ctid); 246 UInt ret = 0; 247 UWord * stack; 248 NSegment const *seg; 249 SysRes res; 250 vki_sigset_t blockall, savedmask; 251 252 VG_ (sigfillset) (&blockall); 253 vg_assert (VG_ (is_running_thread) (ptid)); 254 vg_assert (VG_ (is_valid_tid) (ctid)); 255 stack = (UWord *) ML_ (allocstack) (ctid); 256 if (stack == NULL) { 257 res = VG_ (mk_SysRes_Error) (VKI_ENOMEM); 258 goto out; 259 } 260 setup_child (&ctst->arch, &ptst->arch); 261 262 /* on MIPS we need to set V0 and A3 to zero */ 263 ctst->arch.vex.guest_r2 = 0; 264 ctst->arch.vex.guest_r7 = 0; 265 if (sp != 0) 266 ctst->arch.vex.guest_r29 = sp; 267 268 ctst->os_state.parent = ptid; 269 ctst->sig_mask = ptst->sig_mask; 270 ctst->tmp_sig_mask = ptst->sig_mask; 271 272 /* Start the child with its threadgroup being the same as the 273 parent's. This is so that any exit_group calls that happen 274 after the child is created but before it sets its 275 os_state.threadgroup field for real (in thread_wrapper in 276 syswrap-linux.c), really kill the new thread. a.k.a this avoids 277 a race condition in which the thread is unkillable (via 278 exit_group) because its threadgroup is not set. The race window 279 is probably only a few hundred or a few thousand cycles long. 280 See #226116. */ 281 282 ctst->os_state.threadgroup = ptst->os_state.threadgroup; 283 seg = VG_ (am_find_nsegment) ((Addr) sp); 284 285 if (seg && seg->kind != SkResvn) { 286 ctst->client_stack_highest_word = (Addr) VG_PGROUNDUP (sp); 287 ctst->client_stack_szB = ctst->client_stack_highest_word - seg->start; 288 VG_ (register_stack) (seg->start, ctst->client_stack_highest_word); 289 if (debug) 290 VG_ (printf) ("tid %d: guessed client stack range %#lx-%#lx\n", 291 292 ctid, seg->start, VG_PGROUNDUP (sp)); 293 } else { 294 VG_ (message) (Vg_UserMsg, 295 "!? New thread %d starts with sp+%#lx) unmapped\n", 296 ctid, sp); 297 ctst->client_stack_szB = 0; 298 } 299 300 VG_TRACK (pre_thread_ll_create, ptid, ctid); 301 if (flags & VKI_CLONE_SETTLS) { 302 if (debug) 303 VG_(printf)("clone child has SETTLS: tls at %#lx\n", child_tls); 304 ctst->arch.vex.guest_r27 = child_tls; 305 res = sys_set_tls(ctid, child_tls); 306 if (sr_isError(res)) 307 goto out; 308 ctst->arch.vex.guest_r27 = child_tls; 309 } 310 311 flags &= ~VKI_CLONE_SETTLS; 312 VG_ (sigprocmask) (VKI_SIG_SETMASK, &blockall, &savedmask); 313 /* Create the new thread */ 314 ret = do_syscall_clone_mips_linux (ML_ (start_thread_NORETURN), 315 stack, flags, &VG_ (threads)[ctid], 316 child_tidptr, parent_tidptr, 317 0 /*child_tls*/); 318 319 /* High half word64 is syscall return value. Low half is 320 the entire CR, from which we need to extract CR0.SO. */ 321 if (debug) 322 VG_(printf)("ret: 0x%x\n", ret); 323 324 res = VG_ (mk_SysRes_mips32_linux) (/*val */ ret, 0, /*errflag */ 0); 325 326 VG_ (sigprocmask) (VKI_SIG_SETMASK, &savedmask, NULL); 327 328 out: 329 if (sr_isError (res)) { 330 VG_(cleanup_thread) (&ctst->arch); 331 ctst->status = VgTs_Empty; 332 VG_TRACK (pre_thread_ll_exit, ctid); 333 } 334 ptst->arch.vex.guest_r2 = 0; 335 336 return res; 337 } 338 339 /* --------------------------------------------------------------------- 340 More thread stuff 341 ------------------------------------------------------------------ */ 342 343 // MIPS doesn't have any architecture specific thread stuff that 344 // needs to be cleaned up da li ????!!!!??? 345 void 346 VG_ (cleanup_thread) (ThreadArchState * arch) { } 347 348 void 349 setup_child ( /*OUT*/ ThreadArchState * child, 350 /*IN*/ ThreadArchState * parent) 351 { 352 /* We inherit our parent's guest state. */ 353 child->vex = parent->vex; 354 child->vex_shadow1 = parent->vex_shadow1; 355 child->vex_shadow2 = parent->vex_shadow2; 356 } 357 358 SysRes sys_set_tls ( ThreadId tid, Addr tlsptr ) 359 { 360 VG_(threads)[tid].arch.vex.guest_ULR = tlsptr; 361 return VG_(mk_SysRes_Success)( 0 ); 362 } 363 364 /* --------------------------------------------------------------------- 365 PRE/POST wrappers for mips/Linux-specific syscalls 366 ------------------------------------------------------------------ */ 367 #define PRE(name) DEFN_PRE_TEMPLATE(mips_linux, name) 368 #define POST(name) DEFN_POST_TEMPLATE(mips_linux, name) 369 370 /* Add prototypes for the wrappers declared here, so that gcc doesn't 371 harass us for not having prototypes. Really this is a kludge -- 372 the right thing to do is to make these wrappers 'static' since they 373 aren't visible outside this file, but that requires even more macro 374 magic. */ 375 //DECL_TEMPLATE (mips_linux, sys_syscall); 376 DECL_TEMPLATE (mips_linux, sys_socketcall); 377 DECL_TEMPLATE (mips_linux, sys_socket); 378 DECL_TEMPLATE (mips_linux, sys_setsockopt); 379 DECL_TEMPLATE (mips_linux, sys_getsockopt); 380 DECL_TEMPLATE (mips_linux, sys_connect); 381 DECL_TEMPLATE (mips_linux, sys_accept); 382 DECL_TEMPLATE (mips_linux, sys_sendto); 383 DECL_TEMPLATE (mips_linux, sys_recvfrom); 384 DECL_TEMPLATE (mips_linux, sys_ipc); 385 DECL_TEMPLATE (mips_linux, sys_semget); 386 DECL_TEMPLATE (mips_linux, sys_semop); 387 DECL_TEMPLATE (mips_linux, sys_semctl); 388 DECL_TEMPLATE (mips_linux, sys_semtimedop); 389 DECL_TEMPLATE (mips_linux, sys_shmget); 390 DECL_TEMPLATE (mips_linux, sys_shmdt); 391 DECL_TEMPLATE (mips_linux, sys_shmctl); 392 DECL_TEMPLATE (mips_linux, sys_sendmsg); 393 DECL_TEMPLATE (mips_linux, sys_recvmsg); 394 DECL_TEMPLATE (mips_linux, sys_msgget); 395 DECL_TEMPLATE (mips_linux, sys_msgrcv); 396 DECL_TEMPLATE (mips_linux, sys_msgsnd); 397 DECL_TEMPLATE (mips_linux, sys_msgctl); 398 DECL_TEMPLATE (mips_linux, sys_shutdown); 399 DECL_TEMPLATE (mips_linux, sys_bind); 400 DECL_TEMPLATE (mips_linux, sys_listen); 401 DECL_TEMPLATE (mips_linux, sys_getsockname); 402 DECL_TEMPLATE (mips_linux, sys_getpeername); 403 DECL_TEMPLATE (mips_linux, sys_socketpair); 404 DECL_TEMPLATE (mips_linux, sys_send); 405 DECL_TEMPLATE (mips_linux, sys_recv); 406 DECL_TEMPLATE (mips_linux, sys_mmap); 407 DECL_TEMPLATE (mips_linux, sys_mmap2); 408 DECL_TEMPLATE (mips_linux, sys_stat64); 409 DECL_TEMPLATE (mips_linux, sys_lstat64); 410 DECL_TEMPLATE (mips_linux, sys_fstatat64); 411 DECL_TEMPLATE (mips_linux, sys_fstat64); 412 DECL_TEMPLATE (mips_linux, sys_clone); 413 DECL_TEMPLATE (mips_linux, sys_sigreturn); 414 DECL_TEMPLATE (mips_linux, sys_rt_sigreturn); 415 DECL_TEMPLATE (mips_linux, sys_cacheflush); 416 DECL_TEMPLATE (mips_linux, sys_set_thread_area); 417 DECL_TEMPLATE (mips_linux, sys_pipe); 418 419 PRE (sys_socketcall) 420 { 421 # define ARG2_0 (((UWord*)ARG2)[0]) 422 # define ARG2_1 (((UWord*)ARG2)[1]) 423 # define ARG2_2 (((UWord*)ARG2)[2]) 424 # define ARG2_3 (((UWord*)ARG2)[3]) 425 # define ARG2_4 (((UWord*)ARG2)[4]) 426 # define ARG2_5 (((UWord*)ARG2)[5]) 427 *flags |= SfMayBlock; 428 PRINT ("sys_socketcall ( %ld, %#lx )", ARG1, ARG2); 429 PRE_REG_READ2 (long, "socketcall", int, call, unsigned long *, args); 430 switch (ARG1 /* request */ ) 431 { 432 case VKI_SYS_SOCKETPAIR: 433 /* int socketpair(int d, int type, int protocol, int sv[2]); */ 434 PRE_MEM_READ ("socketcall.socketpair(args)", ARG2, 435 4 * sizeof (Addr)); 436 ML_ (generic_PRE_sys_socketpair) (tid, ARG2_0, ARG2_1, ARG2_2, ARG2_3); 437 break; 438 case VKI_SYS_SOCKET: 439 /* int socket(int domain, int type, int protocol); */ 440 PRE_MEM_READ ("socketcall.socket(args)", ARG2, 3 * sizeof (Addr)); 441 break; 442 case VKI_SYS_BIND: 443 /* int bind(int sockfd, struct sockaddr *my_addr, 444 int addrlen); */ 445 PRE_MEM_READ ("socketcall.bind(args)", ARG2, 3 * sizeof (Addr)); 446 ML_ (generic_PRE_sys_bind) (tid, ARG2_0, ARG2_1, ARG2_2); 447 break; 448 case VKI_SYS_LISTEN: 449 /* int listen(int s, int backlog); */ 450 PRE_MEM_READ ("socketcall.listen(args)", ARG2, 2 * sizeof (Addr)); 451 break; 452 case VKI_SYS_ACCEPT: 453 { 454 /* int accept(int s, struct sockaddr *addr, int *addrlen); */ 455 PRE_MEM_READ ("socketcall.accept(args)", ARG2, 3 * sizeof (Addr)); 456 ML_ (generic_PRE_sys_accept) (tid, ARG2_0, ARG2_1, ARG2_2); 457 break; 458 } 459 case VKI_SYS_SENDTO: 460 /* int sendto(int s, const void *msg, int len, 461 unsigned int flags, 462 const struct sockaddr *to, int tolen); */ 463 PRE_MEM_READ ("socketcall.sendto(args)", ARG2, 6 * sizeof (Addr)); 464 ML_ (generic_PRE_sys_sendto) (tid, ARG2_0, ARG2_1, ARG2_2, ARG2_3, 465 ARG2_4, ARG2_5); 466 break; 467 case VKI_SYS_SEND: 468 /* int send(int s, const void *msg, size_t len, int flags); */ 469 PRE_MEM_READ ("socketcall.send(args)", ARG2, 4 * sizeof (Addr)); 470 ML_ (generic_PRE_sys_send) (tid, ARG2_0, ARG2_1, ARG2_2); 471 break; 472 case VKI_SYS_RECVFROM: 473 /* int recvfrom(int s, void *buf, int len, unsigned int flags, 474 struct sockaddr *from, int *fromlen); */ 475 PRE_MEM_READ ("socketcall.recvfrom(args)", ARG2, 6 * sizeof (Addr)); 476 ML_ (generic_PRE_sys_recvfrom) (tid, ARG2_0, ARG2_1, ARG2_2, 477 ARG2_3, ARG2_4, ARG2_5); 478 break; 479 case VKI_SYS_RECV: 480 /* int recv(int s, void *buf, int len, unsigned int flags); */ 481 /* man 2 recv says: 482 The recv call is normally used only on a connected socket 483 (see connect(2)) and is identical to recvfrom with a NULL 484 from parameter. 485 */ 486 PRE_MEM_READ ("socketcall.recv(args)", ARG2, 4 * sizeof (Addr)); 487 ML_ (generic_PRE_sys_recv) (tid, ARG2_0, ARG2_1, ARG2_2); 488 break; 489 case VKI_SYS_CONNECT: 490 /* int connect(int sockfd, 491 struct sockaddr *serv_addr, int addrlen ); */ 492 PRE_MEM_READ ("socketcall.connect(args)", ARG2, 3 * sizeof (Addr)); 493 ML_ (generic_PRE_sys_connect) (tid, ARG2_0, ARG2_1, ARG2_2); 494 break; 495 case VKI_SYS_SETSOCKOPT: 496 /* int setsockopt(int s, int level, int optname, 497 const void *optval, int optlen); */ 498 PRE_MEM_READ ("socketcall.setsockopt(args)", ARG2, 5 * sizeof (Addr)); 499 ML_ (generic_PRE_sys_setsockopt) (tid, ARG2_0, ARG2_1, ARG2_2, 500 ARG2_3, ARG2_4); 501 break; 502 case VKI_SYS_GETSOCKOPT: 503 /* int getsockopt(int s, int level, int optname, 504 void *optval, socklen_t *optlen); */ 505 PRE_MEM_READ ("socketcall.getsockopt(args)", ARG2, 5 * sizeof (Addr)); 506 ML_ (linux_PRE_sys_getsockopt) (tid, ARG2_0, ARG2_1, ARG2_2, ARG2_3, ARG2_4); 507 break; 508 case VKI_SYS_GETSOCKNAME: 509 /* int getsockname(int s, struct sockaddr* name, int* namelen) */ 510 PRE_MEM_READ ("socketcall.getsockname(args)", ARG2, 3 * sizeof (Addr)); 511 ML_ (generic_PRE_sys_getsockname) (tid, ARG2_0, ARG2_1, ARG2_2); 512 break; 513 case VKI_SYS_GETPEERNAME: 514 /* int getpeername(int s, struct sockaddr* name, int* namelen) */ 515 PRE_MEM_READ ("socketcall.getpeername(args)", ARG2, 3 * sizeof (Addr)); 516 ML_ (generic_PRE_sys_getpeername) (tid, ARG2_0, ARG2_1, ARG2_2); 517 break; 518 case VKI_SYS_SHUTDOWN: 519 /* int shutdown(int s, int how); */ 520 PRE_MEM_READ ("socketcall.shutdown(args)", ARG2, 2 * sizeof (Addr)); 521 break; 522 case VKI_SYS_SENDMSG: 523 { 524 /* int sendmsg(int s, const struct msghdr *msg, int flags); */ 525 /* this causes warnings, and I don't get why. glibc bug? 526 * (after all it's glibc providing the arguments array) 527 PRE_MEM_READ( "socketcall.sendmsg(args)", ARG2, 3*sizeof(Addr) ); 528 */ 529 ML_ (generic_PRE_sys_sendmsg) (tid, (UChar *)ARG2_0, (struct vki_msghdr *)ARG2_1); 530 break; 531 } 532 case VKI_SYS_RECVMSG: 533 { 534 /* int recvmsg(int s, struct msghdr *msg, int flags); */ 535 /* this causes warnings, and I don't get why. glibc bug? 536 * (after all it's glibc providing the arguments array) 537 PRE_MEM_READ("socketcall.recvmsg(args)", ARG2, 3*sizeof(Addr) ); 538 */ 539 ML_ (generic_PRE_sys_recvmsg) (tid, (UChar *)ARG2_0, 540 (struct vki_msghdr *)ARG2_1); 541 break; 542 } 543 default: 544 VG_ (message) (Vg_DebugMsg, "Warning: unhandled socketcall 0x%lx", ARG1); 545 SET_STATUS_Failure (VKI_EINVAL); 546 break; 547 } 548 # undef ARG2_0 549 # undef ARG2_1 550 # undef ARG2_2 551 # undef ARG2_3 552 # undef ARG2_4 553 # undef ARG2_5 554 } 555 556 POST (sys_socketcall) 557 { 558 # define ARG2_0 (((UWord*)ARG2)[0]) 559 # define ARG2_1 (((UWord*)ARG2)[1]) 560 # define ARG2_2 (((UWord*)ARG2)[2]) 561 # define ARG2_3 (((UWord*)ARG2)[3]) 562 # define ARG2_4 (((UWord*)ARG2)[4]) 563 # define ARG2_5 (((UWord*)ARG2)[5]) 564 SysRes r; 565 vg_assert (SUCCESS); 566 switch (ARG1 /* request */ ) 567 { 568 case VKI_SYS_SOCKETPAIR: 569 r = ML_ (generic_POST_sys_socketpair) ( tid, 570 VG_ (mk_SysRes_Success) (RES), 571 ARG2_0, ARG2_1, ARG2_2, ARG2_3); 572 SET_STATUS_from_SysRes (r); 573 break; 574 case VKI_SYS_SOCKET: 575 r = ML_ (generic_POST_sys_socket) (tid, VG_ (mk_SysRes_Success) (RES)); 576 SET_STATUS_from_SysRes (r); 577 break; 578 case VKI_SYS_BIND: 579 /* int bind(int sockfd, struct sockaddr *my_addr, int addrlen); */ 580 break; 581 case VKI_SYS_LISTEN: 582 /* int listen(int s, int backlog); */ 583 break; 584 case VKI_SYS_ACCEPT: 585 /* int accept(int s, struct sockaddr *addr, int *addrlen); */ 586 r = ML_ (generic_POST_sys_accept) (tid, VG_ (mk_SysRes_Success) (RES), 587 ARG2_0, ARG2_1, ARG2_2); 588 SET_STATUS_from_SysRes (r); 589 break; 590 case VKI_SYS_SENDTO: 591 break; 592 case VKI_SYS_SEND: 593 break; 594 case VKI_SYS_RECVFROM: 595 ML_ (generic_POST_sys_recvfrom) (tid, VG_ (mk_SysRes_Success) (RES), 596 ARG2_0, ARG2_1, ARG2_2, ARG2_3, 597 ARG2_4, ARG2_5); 598 break; 599 case VKI_SYS_RECV: 600 ML_ (generic_POST_sys_recv) (tid, RES, ARG2_0, ARG2_1, ARG2_2); 601 break; 602 case VKI_SYS_CONNECT: 603 break; 604 case VKI_SYS_SETSOCKOPT: 605 break; 606 case VKI_SYS_GETSOCKOPT: 607 ML_ (linux_POST_sys_getsockopt) (tid, VG_ (mk_SysRes_Success) (RES), 608 ARG2_0, ARG2_1, ARG2_2, 609 ARG2_3, ARG2_4); 610 break; 611 case VKI_SYS_GETSOCKNAME: 612 ML_ (generic_POST_sys_getsockname) (tid, VG_ (mk_SysRes_Success) (RES), 613 ARG2_0, ARG2_1, ARG2_2); 614 break; 615 case VKI_SYS_GETPEERNAME: 616 ML_ (generic_POST_sys_getpeername) (tid, VG_ (mk_SysRes_Success) (RES), 617 ARG2_0, ARG2_1, ARG2_2); 618 break; 619 case VKI_SYS_SHUTDOWN: 620 break; 621 case VKI_SYS_SENDMSG: 622 break; 623 case VKI_SYS_RECVMSG: 624 ML_(generic_PRE_sys_recvmsg)( tid, "msg", (struct vki_msghdr *)ARG2_1 ); 625 break; 626 default: 627 VG_ (message) (Vg_DebugMsg, "FATAL: unhandled socketcall 0x%lx", ARG1); 628 VG_ (core_panic) ("... bye!\n"); 629 break; 630 /*NOTREACHED*/ 631 } 632 # undef ARG2_0 633 # undef ARG2_1 634 # undef ARG2_2 635 # undef ARG2_3 636 # undef ARG2_4 637 # undef ARG2_5 638 } 639 640 PRE (sys_socket) 641 { 642 PRINT ("sys_socket ( %ld, %ld, %ld )", ARG1, ARG2, ARG3); 643 PRE_REG_READ3 (long, "socket", int, domain, int, type, int, protocol); 644 } 645 646 POST (sys_socket) 647 { 648 SysRes r; 649 vg_assert (SUCCESS); 650 r = ML_ (generic_POST_sys_socket) (tid, VG_ (mk_SysRes_Success) (RES)); 651 SET_STATUS_from_SysRes (r); 652 } 653 654 PRE (sys_setsockopt) 655 { 656 PRINT ("sys_setsockopt ( %ld, %ld, %ld, %#lx, %ld )", ARG1, ARG2, ARG3, 657 ARG4, ARG5); 658 PRE_REG_READ5 (long, "setsockopt", int, s, int, level, int, optname, 659 const void *, optval, int, optlen); 660 ML_ (generic_PRE_sys_setsockopt) (tid, ARG1, ARG2, ARG3, ARG4, ARG5); 661 } 662 663 PRE (sys_getsockopt) 664 { 665 PRINT ("sys_getsockopt ( %ld, %ld, %ld, %#lx, %#lx )", ARG1, ARG2, ARG3, 666 ARG4, ARG5); 667 PRE_REG_READ5 (long, "getsockopt", int, s, int, level, int, optname, 668 void *, optval, int, *optlen); 669 ML_ (linux_PRE_sys_getsockopt) (tid, ARG1, ARG2, ARG3, ARG4, ARG5); 670 } 671 672 POST (sys_getsockopt) 673 { 674 vg_assert (SUCCESS); 675 ML_ (linux_POST_sys_getsockopt) (tid, VG_ (mk_SysRes_Success) (RES), 676 ARG1, ARG2, ARG3, ARG4, ARG5); 677 } 678 679 PRE(sys_connect) 680 { 681 *flags |= SfMayBlock; 682 PRINT("sys_connect ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3); 683 PRE_REG_READ3(long, "connect", 684 int, sockfd, struct sockaddr *, serv_addr, int, addrlen); 685 ML_(generic_PRE_sys_connect)(tid, ARG1,ARG2,ARG3); 686 } 687 688 PRE (sys_accept) 689 { 690 *flags |= SfMayBlock; 691 PRINT ("sys_accept ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3); 692 PRE_REG_READ3 (long, "accept", int, s, struct sockaddr *, addr, int, 693 *addrlen); 694 ML_ (generic_PRE_sys_accept) (tid, ARG1, ARG2, ARG3); 695 } 696 697 POST (sys_accept) 698 { 699 SysRes r; 700 vg_assert (SUCCESS); 701 r = 702 ML_ (generic_POST_sys_accept) (tid, VG_ (mk_SysRes_Success) (RES), 703 ARG1, ARG2, ARG3); 704 SET_STATUS_from_SysRes (r); 705 } 706 707 PRE (sys_sendto) 708 { 709 *flags |= SfMayBlock; 710 PRINT ("sys_sendto ( %ld, %#lx, %ld, %lu, %#lx, %ld )", ARG1, ARG2, ARG3, 711 ARG4, ARG5, ARG6); 712 PRE_REG_READ6 (long, "sendto", int, s, const void *, msg, int, len, 713 unsigned int, flags, const struct sockaddr *, to, int, 714 tolen); 715 ML_ (generic_PRE_sys_sendto) (tid, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6); 716 } 717 718 PRE (sys_recvfrom) 719 { 720 *flags |= SfMayBlock; 721 PRINT ("sys_recvfrom ( %ld, %#lx, %ld, %lu, %#lx, %#lx )", ARG1, ARG2, 722 ARG3, ARG4, ARG5, ARG6); 723 PRE_REG_READ6 (long, "recvfrom", int, s, void *, buf, int, len, 724 unsigned int, flags, 725 struct sockaddr *, from, int *, fromlen); 726 ML_ (generic_PRE_sys_recvfrom) (tid, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6); 727 } 728 729 POST (sys_recvfrom) 730 { 731 vg_assert (SUCCESS); 732 ML_ (generic_POST_sys_recvfrom) (tid, VG_ (mk_SysRes_Success) (RES), 733 ARG1, ARG2, ARG3, ARG4, ARG5, ARG6); 734 } 735 736 PRE(sys_sendmsg) 737 { 738 *flags |= SfMayBlock; 739 PRINT("sys_sendmsg ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3); 740 PRE_REG_READ3(long, "sendmsg", 741 int, s, const struct msghdr *, msg, int, flags); 742 ML_(generic_PRE_sys_sendmsg)(tid, "msg", (struct vki_msghdr *)ARG2); 743 } 744 745 PRE(sys_recvmsg) 746 { 747 *flags |= SfMayBlock; 748 PRINT("sys_recvmsg ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3); 749 PRE_REG_READ3(long, "recvmsg", int, s, struct msghdr *, msg, int, flags); 750 ML_(generic_PRE_sys_recvmsg)(tid, "msg", (struct vki_msghdr *)ARG2); 751 } 752 POST(sys_recvmsg) 753 { 754 ML_(generic_POST_sys_recvmsg)(tid, "msg", (struct vki_msghdr *)ARG2, RES); 755 } 756 757 PRE (sys_semget) 758 { 759 PRINT ("sys_semget ( %ld, %ld, %ld )", ARG1, ARG2, ARG3); 760 PRE_REG_READ3 (long, "semget", vki_key_t, key, int, nsems, int, semflg); 761 } 762 763 PRE (sys_semop) 764 { 765 *flags |= SfMayBlock; 766 PRINT ("sys_semop ( %ld, %#lx, %lu )", ARG1, ARG2, ARG3); 767 PRE_REG_READ3 (long, "semop", int, semid, struct sembuf *, sops, 768 unsigned, nsoops); 769 ML_ (generic_PRE_sys_semop) (tid, ARG1, ARG2, ARG3); 770 } 771 772 PRE (sys_semctl) 773 { 774 switch (ARG3 & ~VKI_IPC_64) 775 { 776 case VKI_IPC_INFO: 777 case VKI_SEM_INFO: 778 PRINT ("sys_semctl ( %ld, %ld, %ld, %#lx )", ARG1, ARG2, ARG3, ARG4); 779 PRE_REG_READ4 (long, "semctl", 780 int, semid, int, semnum, int, cmd, 781 struct seminfo *, arg); 782 break; 783 case VKI_IPC_STAT: 784 case VKI_SEM_STAT: 785 case VKI_IPC_SET: 786 PRINT ("sys_semctl ( %ld, %ld, %ld, %#lx )", ARG1, ARG2, ARG3, ARG4); 787 PRE_REG_READ4 (long, "semctl", int, semid, int, semnum, int, cmd, 788 struct semid_ds *, arg); 789 break; 790 case VKI_GETALL: 791 case VKI_SETALL: 792 PRINT ("sys_semctl ( %ld, %ld, %ld, %#lx )", ARG1, ARG2, ARG3, ARG4); 793 PRE_REG_READ4 (long, "semctl", int, semid, int, semnum, int, cmd, 794 unsigned short *, arg); 795 break; 796 default: 797 PRINT ("sys_semctl ( %ld, %ld, %ld )", ARG1, ARG2, ARG3); 798 PRE_REG_READ3 (long, "semctl", int, semid, int, semnum, int, cmd); 799 break; 800 } 801 ML_ (generic_PRE_sys_semctl) (tid, ARG1, ARG2, ARG3, ARG4); 802 } 803 804 POST (sys_semctl) 805 { 806 ML_ (generic_POST_sys_semctl) (tid, RES, ARG1, ARG2, ARG3, ARG4); 807 } 808 809 PRE (sys_semtimedop) 810 { 811 *flags |= SfMayBlock; 812 PRINT ("sys_semtimedop ( %ld, %#lx, %lu, %#lx )", ARG1, ARG2, ARG3, ARG4); 813 PRE_REG_READ4 (long, "semtimedop", int, semid, struct sembuf *, sops, 814 unsigned, nsoops, 815 struct timespec *, timeout); 816 ML_ (generic_PRE_sys_semtimedop) (tid, ARG1, ARG2, ARG3, ARG4); 817 } 818 819 PRE (sys_msgget) 820 { 821 PRINT ("sys_msgget ( %ld, %ld )", ARG1, ARG2); 822 PRE_REG_READ2 (long, "msgget", vki_key_t, key, int, msgflg); 823 } 824 825 PRE (sys_msgsnd) 826 { 827 PRINT ("sys_msgsnd ( %ld, %#lx, %ld, %ld )", ARG1, ARG2, ARG3, ARG4); 828 PRE_REG_READ4 (long, "msgsnd", int, msqid, struct msgbuf *, msgp, 829 vki_size_t, msgsz, int, msgflg); 830 ML_ (linux_PRE_sys_msgsnd) (tid, ARG1, ARG2, ARG3, ARG4); 831 if ((ARG4 & VKI_IPC_NOWAIT) == 0) 832 *flags |= SfMayBlock; 833 } 834 835 PRE (sys_msgrcv) 836 { 837 PRINT ("sys_msgrcv ( %ld, %#lx, %ld, %ld, %ld )", ARG1, ARG2, ARG3, ARG4, 838 ARG5); 839 PRE_REG_READ5 (long, "msgrcv", int, msqid, struct msgbuf *, msgp, 840 vki_size_t, msgsz, long, msgytp, int, msgflg); 841 ML_ (linux_PRE_sys_msgrcv) (tid, ARG1, ARG2, ARG3, ARG4, ARG5); 842 if ((ARG4 & VKI_IPC_NOWAIT) == 0) 843 *flags |= SfMayBlock; 844 } 845 846 POST (sys_msgrcv) 847 { 848 ML_ (linux_POST_sys_msgrcv) (tid, RES, ARG1, ARG2, ARG3, ARG4, ARG5); 849 } 850 851 PRE (sys_msgctl) 852 { 853 PRINT ("sys_msgctl ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3); 854 PRE_REG_READ3 (long, "msgctl", int, msqid, int, cmd, struct msqid_ds *, buf); 855 ML_ (linux_PRE_sys_msgctl) (tid, ARG1, ARG2, ARG3); 856 } 857 858 POST (sys_msgctl) 859 { 860 ML_ (linux_POST_sys_msgctl) (tid, RES, ARG1, ARG2, ARG3); 861 } 862 863 PRE (sys_shmget) 864 { 865 PRINT ("sys_shmget ( %ld, %ld, %ld )", ARG1, ARG2, ARG3); 866 PRE_REG_READ3 (long, "shmget", vki_key_t, key, vki_size_t, size, int, 867 shmflg); 868 } 869 870 PRE (sys_shmdt) 871 { 872 PRINT ("sys_shmdt ( %#lx )", ARG1); 873 PRE_REG_READ1 (long, "shmdt", const void *, shmaddr); 874 if (!ML_ (generic_PRE_sys_shmdt) (tid, ARG1)) 875 SET_STATUS_Failure (VKI_EINVAL); 876 } 877 878 POST (sys_shmdt) 879 880 { 881 ML_ (generic_POST_sys_shmdt) (tid, RES, ARG1); 882 } 883 884 PRE (sys_shmctl) 885 { 886 PRINT ("sys_shmctl ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3); 887 PRE_REG_READ3 (long, "shmctl", int, shmid, int, cmd, struct shmid_ds *, buf); 888 ML_ (generic_PRE_sys_shmctl) (tid, ARG1, ARG2, ARG3); 889 } 890 891 POST (sys_shmctl) 892 { 893 ML_ (generic_POST_sys_shmctl) (tid, RES, ARG1, ARG2, ARG3); 894 } 895 896 PRE (sys_shutdown) 897 { 898 *flags |= SfMayBlock; 899 PRINT ("sys_shutdown ( %ld, %ld )", ARG1, ARG2); 900 PRE_REG_READ2 (int, "shutdown", int, s, int, how); 901 } 902 903 PRE (sys_bind) 904 { 905 PRINT ("sys_bind ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3); 906 PRE_REG_READ3 (long, "bind", int, sockfd, struct sockaddr *, my_addr, 907 int, addrlen); 908 ML_ (generic_PRE_sys_bind) (tid, ARG1, ARG2, ARG3); 909 } 910 911 PRE (sys_listen) 912 { 913 PRINT ("sys_listen ( %ld, %ld )", ARG1, ARG2); 914 PRE_REG_READ2 (long, "listen", int, s, int, backlog); 915 } 916 917 PRE (sys_getsockname) 918 { 919 PRINT ("sys_getsockname ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3); 920 PRE_REG_READ3 (long, "getsockname", int, s, struct sockaddr *, name, 921 int *, namelen); 922 ML_ (generic_PRE_sys_getsockname) (tid, ARG1, ARG2, ARG3); 923 } 924 925 POST (sys_getsockname) 926 { 927 vg_assert (SUCCESS); 928 ML_ (generic_POST_sys_getsockname) (tid, VG_ (mk_SysRes_Success) (RES), 929 ARG1, ARG2, ARG3); 930 } 931 932 PRE (sys_getpeername) 933 { 934 PRINT ("sys_getpeername ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3); 935 PRE_REG_READ3 (long, "getpeername", int, s, struct sockaddr *, name, 936 int *, namelen); 937 ML_ (generic_PRE_sys_getpeername) (tid, ARG1, ARG2, ARG3); 938 } 939 940 POST (sys_getpeername) 941 { 942 vg_assert (SUCCESS); 943 ML_ (generic_POST_sys_getpeername) (tid, VG_ (mk_SysRes_Success) (RES), 944 ARG1, ARG2, ARG3); 945 } 946 947 PRE (sys_socketpair) 948 { 949 PRINT ("sys_socketpair ( %ld, %ld, %ld, %#lx )", ARG1, ARG2, ARG3, ARG4); 950 PRE_REG_READ4 (long, "socketpair", int, d, int, type, int, 951 protocol, int *, sv); 952 ML_ (generic_PRE_sys_socketpair) (tid, ARG1, ARG2, ARG3, ARG4); 953 } 954 955 POST (sys_socketpair) 956 { 957 vg_assert (SUCCESS); 958 ML_ (generic_POST_sys_socketpair) (tid, VG_ (mk_SysRes_Success) (RES), 959 ARG1, ARG2, ARG3, ARG4); 960 } 961 962 PRE (sys_send) 963 { 964 *flags |= SfMayBlock; 965 PRINT ("sys_send ( %ld, %#lx, %ld, %lu )", ARG1, ARG2, ARG3, ARG4); 966 PRE_REG_READ4 (long, "send", int, s, const void *, msg, int, len, 967 unsigned int, flags); 968 ML_ (generic_PRE_sys_send) (tid, ARG1, ARG2, ARG3); 969 } 970 971 PRE (sys_recv) 972 { 973 *flags |= SfMayBlock; 974 PRINT ("sys_recv ( %ld, %#lx, %ld, %lu )", ARG1, ARG2, ARG3, ARG4); 975 PRE_REG_READ4 (long, "recv", int, s, void *, buf, int, len, 976 unsigned int, flags); 977 ML_ (generic_PRE_sys_recv) (tid, ARG1, ARG2, ARG3); 978 } 979 980 POST (sys_recv) 981 { 982 ML_ (generic_POST_sys_recv) (tid, RES, ARG1, ARG2, ARG3); 983 } 984 985 PRE (sys_mmap2) 986 { 987 SysRes r; 988 // Exactly like old_mmap() except: 989 // - all 6 args are passed in regs, rather than in a memory-block. 990 // - the file offset is specified in pagesize units rather than bytes, 991 // so that it can be used for files bigger than 2^32 bytes. 992 // pagesize or 4K-size units in offset? 993 vg_assert (VKI_PAGE_SIZE == 4096 || VKI_PAGE_SIZE == 4096 * 4 994 || VKI_PAGE_SIZE == 4096 * 16); 995 PRINT ("sys_mmap2 ( %#lx, %llu, %ld, %ld, %ld, %ld )", ARG1, (ULong) ARG2, 996 ARG3, ARG4, 997 ARG5, ARG6); 998 PRE_REG_READ6 (long, "mmap2", unsigned long, start, unsigned long, length, 999 unsigned long, prot, unsigned long, flags, 1000 unsigned long, fd, unsigned long, offset); 1001 r = 1002 ML_ (generic_PRE_sys_mmap) (tid, ARG1, ARG2, ARG3, ARG4, ARG5, 1003 VKI_PAGE_SIZE * (Off64T) ARG6); 1004 SET_STATUS_from_SysRes (r); 1005 } 1006 1007 PRE (sys_mmap) 1008 { 1009 SysRes r; 1010 //vg_assert(VKI_PAGE_SIZE == 4096); 1011 PRINT ("sys_mmap ( %#lx, %llu, %lu, %lu, %lu, %ld )", ARG1, (ULong) ARG2, 1012 ARG3, ARG4, ARG5, ARG6); 1013 PRE_REG_READ6 (long, "mmap", unsigned long, start, vki_size_t, length, 1014 int, prot, int, flags, int, fd, unsigned long, offset); 1015 r = 1016 ML_ (generic_PRE_sys_mmap) (tid, ARG1, ARG2, ARG3, ARG4, ARG5, 1017 (Off64T) ARG6); 1018 SET_STATUS_from_SysRes (r); 1019 } 1020 1021 // XXX: lstat64/fstat64/stat64 are generic, but not necessarily 1022 // applicable to every architecture -- I think only to 32-bit archs. 1023 // We're going to need something like linux/core_os32.h for such 1024 // things, eventually, I think. --njn 1025 1026 PRE (sys_lstat64) 1027 { 1028 PRINT ("sys_lstat64 ( %#lx(%s), %#lx )", ARG1, (char *) ARG1, ARG2); 1029 PRE_REG_READ2 (long, "lstat64", char *, file_name, struct stat64 *, buf); 1030 PRE_MEM_RASCIIZ ("lstat64(file_name)", ARG1); 1031 PRE_MEM_WRITE ("lstat64(buf)", ARG2, sizeof (struct vki_stat64)); 1032 } 1033 1034 POST (sys_lstat64) 1035 { 1036 vg_assert (SUCCESS); 1037 if (RES == 0) 1038 { 1039 POST_MEM_WRITE (ARG2, sizeof (struct vki_stat64)); 1040 } 1041 } 1042 1043 PRE (sys_stat64) 1044 { 1045 PRINT ("sys_stat64 ( %#lx(%s), %#lx )", ARG1, (char *) ARG1, ARG2); 1046 PRE_REG_READ2 (long, "stat64", char *, file_name, struct stat64 *, buf); 1047 PRE_MEM_RASCIIZ ("stat64(file_name)", ARG1); 1048 PRE_MEM_WRITE ("stat64(buf)", ARG2, sizeof (struct vki_stat64)); 1049 } 1050 1051 POST (sys_stat64) 1052 { 1053 POST_MEM_WRITE (ARG2, sizeof (struct vki_stat64)); 1054 } 1055 1056 PRE (sys_fstatat64) 1057 { 1058 PRINT ("sys_fstatat64 ( %ld, %#lx(%s), %#lx )", ARG1, ARG2, (char *) ARG2, 1059 ARG3); 1060 PRE_REG_READ3 (long, "fstatat64", int, dfd, char *, file_name, 1061 struct stat64 *, buf); 1062 PRE_MEM_RASCIIZ ("fstatat64(file_name)", ARG2); 1063 PRE_MEM_WRITE ("fstatat64(buf)", ARG3, sizeof (struct vki_stat64)); 1064 } 1065 1066 POST (sys_fstatat64) 1067 { 1068 POST_MEM_WRITE (ARG3, sizeof (struct vki_stat64)); 1069 } 1070 1071 PRE (sys_fstat64) 1072 { 1073 PRINT ("sys_fstat64 ( %ld, %#lx )", ARG1, ARG2); 1074 PRE_REG_READ2 (long, "fstat64", unsigned long, fd, struct stat64 *, buf); 1075 PRE_MEM_WRITE ("fstat64(buf)", ARG2, sizeof (struct vki_stat64)); 1076 } 1077 1078 POST (sys_fstat64) 1079 { 1080 POST_MEM_WRITE (ARG2, sizeof (struct vki_stat64)); 1081 } 1082 1083 static Addr 1084 deref_Addr (ThreadId tid, Addr a, Char * s) 1085 { 1086 Addr * a_p = (Addr *) a; 1087 PRE_MEM_READ (s, (Addr) a_p, sizeof (Addr)); 1088 return *a_p; 1089 } 1090 1091 PRE (sys_ipc) 1092 { 1093 PRINT ("sys_ipc ( %ld, %ld, %ld, %ld, %#lx, %ld )", ARG1, ARG2, ARG3, 1094 ARG4, ARG5, ARG6); 1095 // XXX: this is simplistic -- some args are not used in all circumstances. 1096 PRE_REG_READ6 (int, "ipc", vki_uint, call, int, first, int, second, int, 1097 third, void *, ptr, long, fifth) 1098 switch (ARG1 /* call */ ) 1099 { 1100 case VKI_SEMOP: 1101 ML_ (generic_PRE_sys_semop) (tid, ARG2, ARG5, ARG3); 1102 *flags |= SfMayBlock; 1103 break; 1104 case VKI_SEMGET: 1105 break; 1106 case VKI_SEMCTL: 1107 { 1108 UWord arg = deref_Addr (tid, ARG5, "semctl(arg)"); 1109 ML_ (generic_PRE_sys_semctl) (tid, ARG2, ARG3, ARG4, arg); 1110 break; 1111 } 1112 case VKI_SEMTIMEDOP: 1113 ML_ (generic_PRE_sys_semtimedop) (tid, ARG2, ARG5, ARG3, ARG6); 1114 *flags |= SfMayBlock; 1115 break; 1116 case VKI_MSGSND: 1117 ML_ (linux_PRE_sys_msgsnd) (tid, ARG2, ARG5, ARG3, ARG4); 1118 if ((ARG4 & VKI_IPC_NOWAIT) == 0) 1119 *flags |= SfMayBlock; 1120 break; 1121 case VKI_MSGRCV: 1122 { 1123 Addr msgp; 1124 Word msgtyp; 1125 msgp = deref_Addr (tid, 1126 (Addr)(&((struct vki_ipc_kludge *)ARG5)->msgp), 1127 "msgrcv(msgp)"); 1128 msgtyp = deref_Addr (tid, 1129 (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgtyp), 1130 "msgrcv(msgp)"); 1131 ML_ (linux_PRE_sys_msgrcv) (tid, ARG2, msgp, ARG3, msgtyp, ARG4); 1132 if ((ARG4 & VKI_IPC_NOWAIT) == 0) 1133 *flags |= SfMayBlock; 1134 break; 1135 } 1136 case VKI_MSGGET: 1137 break; 1138 case VKI_MSGCTL: 1139 ML_ (linux_PRE_sys_msgctl) (tid, ARG2, ARG3, ARG5); 1140 break; 1141 case VKI_SHMAT: 1142 { 1143 PRE_MEM_WRITE ("shmat(raddr)", ARG4, sizeof (Addr)); 1144 break; 1145 } 1146 case VKI_SHMDT: 1147 if (!ML_ (generic_PRE_sys_shmdt) (tid, ARG5)) 1148 SET_STATUS_Failure (VKI_EINVAL); 1149 break; 1150 case VKI_SHMGET: 1151 break; 1152 case VKI_SHMCTL: /* IPCOP_shmctl */ 1153 ML_ (generic_PRE_sys_shmctl) (tid, ARG2, ARG3, ARG5); 1154 break; 1155 default: 1156 VG_ (message) (Vg_DebugMsg, "FATAL: unhandled syscall(ipc) %ld\n", 1157 ARG1); 1158 VG_ (core_panic) ("... bye!\n"); 1159 break; 1160 /*NOTREACHED*/ 1161 } 1162 } 1163 1164 POST (sys_ipc) 1165 { 1166 vg_assert (SUCCESS); 1167 switch (ARG1 /* call */ ) 1168 { 1169 case VKI_SEMOP: 1170 case VKI_SEMGET: 1171 break; 1172 case VKI_SEMCTL: 1173 { 1174 UWord arg = deref_Addr (tid, ARG5, "semctl(arg)"); 1175 ML_ (generic_PRE_sys_semctl) (tid, ARG2, ARG3, ARG4, arg); 1176 break; 1177 } 1178 case VKI_SEMTIMEDOP: 1179 case VKI_MSGSND: 1180 break; 1181 case VKI_MSGRCV: 1182 { 1183 Addr msgp; 1184 Word msgtyp; 1185 msgp = deref_Addr (tid, (Addr) (&((struct vki_ipc_kludge *) 1186 ARG5)->msgp), 1187 "msgrcv(msgp)"); 1188 msgtyp = deref_Addr (tid, 1189 (Addr) (&((struct vki_ipc_kludge *) ARG5)->msgtyp), 1190 "msgrcv(msgp)"); 1191 ML_ (linux_POST_sys_msgrcv)(tid, RES, ARG2, msgp, ARG3, msgtyp, ARG4); 1192 break; 1193 } 1194 case VKI_MSGGET: 1195 break; 1196 case VKI_MSGCTL: 1197 ML_ (linux_POST_sys_msgctl) (tid, RES, ARG2, ARG3, ARG5); 1198 break; 1199 case VKI_SHMAT: 1200 { 1201 Addr addr; 1202 /* force readability. before the syscall it is 1203 * indeed uninitialized, as can be seen in 1204 * glibc/sysdeps/unix/sysv/linux/shmat.c */ 1205 POST_MEM_WRITE (ARG4, sizeof (Addr)); 1206 addr = deref_Addr (tid, ARG4, "shmat(addr)"); 1207 ML_ (generic_POST_sys_shmat) (tid, addr, ARG2, ARG5, ARG3); 1208 break; 1209 } 1210 case VKI_SHMDT: 1211 ML_ (generic_POST_sys_shmdt) (tid, RES, ARG5); 1212 break; 1213 case VKI_SHMGET: 1214 break; 1215 case VKI_SHMCTL: 1216 ML_ (generic_POST_sys_shmctl) (tid, RES, ARG2, ARG3, ARG5); 1217 break; 1218 default: 1219 VG_ (message) (Vg_DebugMsg, "FATAL: unhandled syscall(ipc) %ld\n", 1220 ARG1); 1221 VG_ (core_panic) ("... bye!\n"); 1222 break; 1223 /*NOTREACHED*/ 1224 } 1225 } 1226 1227 PRE (sys_clone) 1228 { 1229 Bool badarg = False; 1230 UInt cloneflags; 1231 PRINT ("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )", ARG1, ARG2, ARG3, 1232 ARG4, ARG5); 1233 PRE_REG_READ2 (int, "clone", unsigned long, flags, void *, child_stack); 1234 if (ARG1 & VKI_CLONE_PARENT_SETTID) 1235 { 1236 if (VG_ (tdict).track_pre_reg_read) 1237 { 1238 PRA3 ("clone", int *, parent_tidptr); 1239 } 1240 PRE_MEM_WRITE ("clone(parent_tidptr)", ARG3, sizeof (Int)); 1241 if (!VG_ (am_is_valid_for_client)(ARG3, sizeof (Int), VKI_PROT_WRITE)) 1242 { 1243 badarg = True; 1244 } 1245 } 1246 if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) 1247 { 1248 if (VG_ (tdict).track_pre_reg_read) 1249 { 1250 PRA5 ("clone", int *, child_tidptr); 1251 } 1252 PRE_MEM_WRITE ("clone(child_tidptr)", ARG5, sizeof (Int)); 1253 if (!VG_ (am_is_valid_for_client)(ARG5, sizeof (Int), VKI_PROT_WRITE)) 1254 { 1255 badarg = True; 1256 } 1257 } 1258 if (badarg) 1259 { 1260 SET_STATUS_Failure (VKI_EFAULT); 1261 return; 1262 } 1263 cloneflags = ARG1; 1264 if (!ML_ (client_signal_OK) (ARG1 & VKI_CSIGNAL)) 1265 { 1266 SET_STATUS_Failure (VKI_EINVAL); 1267 return; 1268 } 1269 /* Only look at the flags we really care about */ 1270 switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS 1271 |VKI_CLONE_FILES | VKI_CLONE_VFORK)) 1272 { 1273 case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES: 1274 /* thread creation */ 1275 PRINT ("sys_clone1 ( %#lx, %#lx, %#lx, %#lx, %#lx )", 1276 ARG1, ARG2, ARG3, ARG4, ARG5); 1277 SET_STATUS_from_SysRes (do_clone (tid, 1278 ARG1, /* flags */ 1279 (Addr) ARG2, /* child SP */ 1280 (Int *) ARG3, /* parent_tidptr */ 1281 (Int *) ARG5, /* child_tidptr */ 1282 (Addr) ARG4)); /* child_tls */ 1283 1284 break; 1285 case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */ 1286 /* FALLTHROUGH - assume vfork == fork */ 1287 cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM); 1288 case 0: /* plain fork */ 1289 SET_STATUS_from_SysRes (ML_ (do_fork_clone) (tid, 1290 cloneflags, /* flags */ 1291 (Int *) ARG3, /* parent_tidptr */ 1292 (Int *) ARG5)); /* child_tidptr */ 1293 break; 1294 default: 1295 /* should we just ENOSYS? */ 1296 VG_ (message) (Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG1); 1297 VG_ (message) (Vg_UserMsg, "\n"); 1298 VG_ (message) (Vg_UserMsg, "The only supported clone() uses are:\n"); 1299 VG_ (message) (Vg_UserMsg, 1300 " - via a threads library (LinuxThreads or NPTL)\n"); 1301 VG_ (message) (Vg_UserMsg, 1302 " - via the implementation of fork or vfork\n"); 1303 VG_ (unimplemented)("Valgrind does not support general clone()."); 1304 } 1305 if (SUCCESS) 1306 { 1307 if (ARG1 & VKI_CLONE_PARENT_SETTID) 1308 POST_MEM_WRITE (ARG3, sizeof (Int)); 1309 if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) 1310 POST_MEM_WRITE (ARG5, sizeof (Int)); 1311 /* Thread creation was successful; let the child have the chance 1312 * to run */ 1313 *flags |= SfYieldAfter; 1314 } 1315 } 1316 1317 PRE (sys_sigreturn) 1318 { 1319 ThreadState * tst; 1320 PRINT ("sys_sigreturn ( )"); 1321 vg_assert (VG_ (is_valid_tid) (tid)); 1322 vg_assert (tid >= 1 && tid < VG_N_THREADS); 1323 vg_assert (VG_ (is_running_thread) (tid)); 1324 tst = VG_ (get_ThreadState) (tid); 1325 VG_ (sigframe_destroy) (tid, False); 1326 /* Tell the driver not to update the guest state with the "result", 1327 and set a bogus result to keep it happy. */ 1328 *flags |= SfNoWriteResult; 1329 SET_STATUS_Success (0); 1330 /* Check to see if any signals arose as a result of this. */ 1331 *flags |= SfPollAfter; 1332 } 1333 1334 PRE (sys_rt_sigreturn) 1335 { 1336 PRINT ("rt_sigreturn ( )"); 1337 vg_assert (VG_ (is_valid_tid) (tid)); 1338 vg_assert (tid >= 1 && tid < VG_N_THREADS); 1339 vg_assert (VG_ (is_running_thread) (tid)); 1340 /* Restore register state from frame and remove it */ 1341 VG_ (sigframe_destroy) (tid, True); 1342 /* Tell the driver not to update the guest state with the "result", 1343 and set a bogus result to keep it happy. */ 1344 *flags |= SfNoWriteResult; 1345 SET_STATUS_Success (0); 1346 /* Check to see if any signals arose as a result of this. */ 1347 *flags |= SfPollAfter; 1348 } 1349 1350 PRE (sys_set_thread_area) 1351 { 1352 PRINT ("set_thread_area (%lx)", ARG1); 1353 PRE_REG_READ1(long, "set_thread_area", unsigned long, addr); 1354 SET_STATUS_from_SysRes( sys_set_tls( tid, ARG1 ) ); 1355 } 1356 1357 /* Very much MIPS specific */ 1358 PRE (sys_cacheflush) 1359 { 1360 PRINT ("cacheflush (%lx, %#lx, %#lx)", ARG1, ARG2, ARG3); 1361 PRE_REG_READ3 (long, "cacheflush", void *, addrlow, void *, addrhigh, int, 1362 flags); 1363 VG_ (discard_translations) ((Addr64) ARG1, ((ULong) ARG2) - ((ULong) ARG1) + 1364 1ULL /*paranoia */ , "PRE(sys_cacheflush)"); 1365 SET_STATUS_Success (0); 1366 } 1367 1368 PRE(sys_pipe) 1369 { 1370 PRINT("sys_pipe ( %#lx )", ARG1); 1371 PRE_REG_READ1(int, "pipe", int *, filedes); 1372 PRE_MEM_WRITE( "pipe(filedes)", ARG1, 2*sizeof(int) ); 1373 } 1374 1375 POST(sys_pipe) 1376 { 1377 Int p0, p1; 1378 vg_assert(SUCCESS); 1379 p0 = RES; 1380 p1 = sr_ResEx(status->sres); 1381 1382 if (!ML_(fd_allowed)(p0, "pipe", tid, True) || 1383 !ML_(fd_allowed)(p1, "pipe", tid, True)) { 1384 VG_(close)(p0); 1385 VG_(close)(p1); 1386 SET_STATUS_Failure( VKI_EMFILE ); 1387 } else { 1388 if (VG_(clo_track_fds)) { 1389 ML_(record_fd_open_nameless)(tid, p0); 1390 ML_(record_fd_open_nameless)(tid, p1); 1391 } 1392 } 1393 } 1394 1395 #undef PRE 1396 #undef POST 1397 1398 /* --------------------------------------------------------------------- 1399 The mips/Linux syscall table 1400 ------------------------------------------------------------------ */ 1401 #define PLAX_(sysno, name) WRAPPER_ENTRY_X_(mips_linux, sysno, name) 1402 #define PLAXY(sysno, name) WRAPPER_ENTRY_XY(mips_linux, sysno, name) 1403 1404 // This table maps from __NR_xxx syscall numbers (from 1405 // linux/include/asm-mips/unistd.h) to the appropriate PRE/POST sys_foo() 1406 // wrappers on mips (as per sys_call_table in linux/arch/mips/kernel/entry.S). 1407 // 1408 1409 // For those syscalls not handled by Valgrind, the annotation indicate its 1410 // arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/? 1411 // (unknown). 1412 1413 static SyscallTableEntry syscall_main_table[] = { 1414 //PLAXY (__NR_syscall, sys_syscall), // 0 1415 GENX_ (__NR_exit, sys_exit), // 1 1416 GENX_ (__NR_fork, sys_fork), // 2 1417 GENXY (__NR_read, sys_read), // 3 1418 GENX_ (__NR_write, sys_write), // 4 1419 GENXY (__NR_open, sys_open), // 5 1420 GENXY (__NR_close, sys_close), // 6 1421 GENXY (__NR_waitpid, sys_waitpid), // 7 1422 GENXY (__NR_creat, sys_creat), // 8 1423 GENX_ (__NR_link, sys_link), // 9 1424 GENX_ (__NR_unlink, sys_unlink), // 10 1425 GENX_ (__NR_execve, sys_execve), // 11 1426 GENX_ (__NR_chdir, sys_chdir), // 12 1427 GENXY (__NR_time, sys_time), // 13 1428 GENX_ (__NR_mknod, sys_mknod), // 14 1429 GENX_ (__NR_chmod, sys_chmod), // 15 1430 GENX_ (__NR_lchown, sys_lchown), // 16 1431 LINX_ (__NR_lseek, sys_lseek), // 19 1432 GENX_ (__NR_getpid, sys_getpid), // 20 1433 LINX_ (__NR_mount, sys_mount), // 21 1434 LINX_ (__NR_umount, sys_oldumount), // 22 1435 GENX_ (__NR_setuid, sys_setuid), // 23 ## P 1436 GENX_ (__NR_getuid, sys_getuid), // 24 ## P 1437 //.. // (__NR_stime, sys_stime), 1438 //.. PLAXY(__NR_ptrace, sys_ptrace), // 26 1439 GENX_ (__NR_alarm, sys_alarm), // 27 1440 //.. // (__NR_oldfstat, sys_fstat), 1441 GENX_ (__NR_pause, sys_pause), // 29 1442 LINX_ (__NR_utime, sys_utime), // 30 1443 //.. GENX_(__NR_stty, sys_ni_syscall), // 31 1444 //.. GENX_(__NR_gtty, sys_ni_syscall), // 32 1445 GENX_ (__NR_access, sys_access), // 33 1446 //.. GENX_(__NR_nice, sys_nice), // 34 1447 //.. GENX_(__NR_ftime, sys_ni_syscall), // 35 1448 //.. GENX_(__NR_sync, sys_sync), // 36 1449 GENX_ (__NR_kill, sys_kill), // 37 1450 GENX_ (__NR_rename, sys_rename), // 38 1451 GENX_ (__NR_mkdir, sys_mkdir), // 39 1452 GENX_ (__NR_rmdir, sys_rmdir), // 40 1453 GENXY (__NR_dup, sys_dup), // 41 1454 PLAXY (__NR_pipe, sys_pipe), // 42 1455 GENXY (__NR_times, sys_times), // 43 1456 //.. GENX_(__NR_prof, sys_ni_syscall), // 44 1457 //.. 1458 GENX_ (__NR_brk, sys_brk), // 45 1459 GENX_ (__NR_setgid, sys_setgid), // 46 1460 GENX_ (__NR_getgid, sys_getgid), // 47 1461 //.. // (__NR_signal, sys_signal), // 48 */* (ANSI C) 1462 GENX_ (__NR_geteuid, sys_geteuid), // 49 1463 GENX_ (__NR_getegid, sys_getegid), // 50 1464 //.. GENX_(__NR_acct, sys_acct), // 51 1465 LINX_ (__NR_umount2, sys_umount), // 52 1466 //.. GENX_(__NR_lock, sys_ni_syscall), // 53 1467 LINXY (__NR_ioctl, sys_ioctl), // 54 1468 LINXY (__NR_fcntl, sys_fcntl), // 55 1469 //.. GENX_(__NR_mpx, sys_ni_syscall), // 56 1470 GENX_ (__NR_setpgid, sys_setpgid), // 57 1471 //.. GENX_(__NR_ulimit, sys_ni_syscall), // 58 1472 //.. // (__NR_oldolduname, sys_olduname), // 59 1473 GENX_ (__NR_umask, sys_umask), // 60 1474 GENX_ (__NR_chroot, sys_chroot), // 61 1475 //.. // (__NR_ustat, sys_ustat) // 62 SVr4 -- deprecated 1476 GENXY (__NR_dup2, sys_dup2), // 63 1477 GENX_ (__NR_getppid, sys_getppid), // 64 1478 GENX_ (__NR_getpgrp, sys_getpgrp), // 65 1479 GENX_ (__NR_setsid, sys_setsid), // 66 1480 // PLAXY(__NR_sigaction, sys_sigaction), // 67 1481 //.. // (__NR_sgetmask, sys_sgetmask), // 68 */* (ANSI C) 1482 //.. // (__NR_ssetmask, sys_ssetmask), // 69 */* (ANSI C) 1483 //.. 1484 GENX_ (__NR_setreuid, sys_setreuid), // 70 1485 GENX_ (__NR_setregid, sys_setregid), // 71 1486 // PLAX_(__NR_sigsuspend, sys_sigsuspend), // 72 1487 LINXY (__NR_sigpending, sys_sigpending), // 73 1488 //.. // (__NR_sethostname, sys_sethostname), // 74 */* 1489 //.. 1490 GENX_ (__NR_setrlimit, sys_setrlimit), // 75 1491 //.. GENXY(__NR_getrlimit, sys_old_getrlimit), // 76 1492 GENXY (__NR_getrusage, sys_getrusage), // 77 1493 GENXY (__NR_gettimeofday, sys_gettimeofday), // 78 1494 //.. GENX_(__NR_settimeofday, sys_settimeofday), // 79 1495 //.. 1496 GENXY (__NR_getgroups, sys_getgroups), // 80 1497 GENX_ (__NR_setgroups, sys_setgroups), // 81 1498 //.. PLAX_(__NR_select, old_select), // 82 1499 GENX_ (__NR_symlink, sys_symlink), // 83 1500 //.. // (__NR_oldlstat, sys_lstat), // 84 -- obsolete 1501 //.. 1502 GENX_ (__NR_readlink, sys_readlink), // 85 1503 //.. // (__NR_uselib, sys_uselib), // 86 */Linux 1504 //.. // (__NR_swapon, sys_swapon), // 87 */Linux 1505 //.. // (__NR_reboot, sys_reboot), // 88 */Linux 1506 //.. // (__NR_readdir, old_readdir), // 89 -- superseded 1507 PLAX_ (__NR_mmap, sys_mmap), // 90 1508 GENXY (__NR_munmap, sys_munmap), // 91 1509 GENX_ (__NR_truncate, sys_truncate), // 92 1510 GENX_ (__NR_ftruncate, sys_ftruncate), // 93 1511 GENX_ (__NR_fchmod, sys_fchmod), // 94 1512 GENX_ (__NR_fchown, sys_fchown), // 95 1513 GENX_ (__NR_getpriority, sys_getpriority), // 96 1514 GENX_ (__NR_setpriority, sys_setpriority), // 97 1515 //.. GENX_(__NR_profil, sys_ni_syscall), // 98 1516 GENXY (__NR_statfs, sys_statfs), // 99 1517 //.. 1518 GENXY (__NR_fstatfs, sys_fstatfs), // 100 1519 //.. LINX_(__NR_ioperm, sys_ioperm), // 101 1520 PLAXY (__NR_socketcall, sys_socketcall), // 102 1521 LINXY (__NR_syslog, sys_syslog), // 103 1522 GENXY (__NR_setitimer, sys_setitimer), // 104 1523 //.. 1524 //.. GENXY(__NR_getitimer, sys_getitimer), // 105 1525 GENXY (__NR_stat, sys_newstat), // 106 1526 GENXY (__NR_lstat, sys_newlstat), // 107 1527 GENXY (__NR_fstat, sys_newfstat), // 108 1528 //.. // (__NR_olduname, sys_uname), // 109 -- obsolete 1529 //.. 1530 //.. GENX_(__NR_iopl, sys_iopl), // 110 1531 //.. LINX_(__NR_vhangup, sys_vhangup), // 111 1532 //.. GENX_(__NR_idle, sys_ni_syscall), // 112 1533 //.. // (__NR_vm86old, sys_vm86old), // 113 x86/Linux-only 1534 GENXY (__NR_wait4, sys_wait4), // 114 1535 //.. 1536 //.. // (__NR_swapoff, sys_swapoff), // 115 */Linux 1537 LINXY (__NR_sysinfo, sys_sysinfo), // 116 1538 PLAXY (__NR_ipc, sys_ipc), // 117 1539 GENX_ (__NR_fsync, sys_fsync), // 118 1540 PLAX_ (__NR_sigreturn, sys_sigreturn), // 119 ?/Linux 1541 //.. 1542 PLAX_ (__NR_clone, sys_clone), // 120 1543 //.. // (__NR_setdomainname, sys_setdomainname), // 121 */*(?) 1544 GENXY (__NR_uname, sys_newuname), // 122 1545 //.. PLAX_(__NR_modify_ldt, sys_modify_ldt), // 123 1546 //.. LINXY(__NR_adjtimex, sys_adjtimex), // 124 1547 //.. 1548 GENXY (__NR_mprotect, sys_mprotect), // 125 1549 LINXY (__NR_sigprocmask, sys_sigprocmask), // 126 1550 //.. // Nb: create_module() was removed 2.4-->2.6 1551 //.. GENX_(__NR_create_module, sys_ni_syscall), // 127 1552 //.. GENX_(__NR_init_module, sys_init_module), // 128 1553 //.. // (__NR_delete_module, sys_delete_module), // 129 (*/Linux)? 1554 //.. 1555 //.. // Nb: get_kernel_syms() was removed 2.4-->2.6 1556 //.. GENX_(__NR_get_kernel_syms, sys_ni_syscall), // 130 1557 //.. LINX_(__NR_quotactl, sys_quotactl), // 131 1558 GENX_ (__NR_getpgid, sys_getpgid), // 132 1559 GENX_ (__NR_fchdir, sys_fchdir), // 133 1560 //.. // (__NR_bdflush, sys_bdflush), // 134 */Linux 1561 //.. 1562 //.. // (__NR_sysfs, sys_sysfs), // 135 SVr4 1563 LINX_ (__NR_personality, sys_personality), // 136 1564 //.. GENX_(__NR_afs_syscall, sys_ni_syscall), // 137 1565 LINX_ (__NR_setfsuid, sys_setfsuid), // 138 1566 LINX_ (__NR_setfsgid, sys_setfsgid), // 139 1567 LINXY (__NR__llseek, sys_llseek), // 140 1568 GENXY (__NR_getdents, sys_getdents), // 141 1569 GENX_ (__NR__newselect, sys_select), // 142 1570 GENX_ (__NR_flock, sys_flock), // 143 1571 GENX_ (__NR_msync, sys_msync), // 144 1572 //.. 1573 GENXY (__NR_readv, sys_readv), // 145 1574 GENX_ (__NR_writev, sys_writev), // 146 1575 PLAX_ (__NR_cacheflush, sys_cacheflush), // 147 1576 GENX_ (__NR_getsid, sys_getsid), // 151 1577 GENX_ (__NR_fdatasync, sys_fdatasync), // 152 1578 LINXY (__NR__sysctl, sys_sysctl), // 153 1579 //.. 1580 GENX_ (__NR_mlock, sys_mlock), // 154 1581 GENX_ (__NR_munlock, sys_munlock), // 155 1582 GENX_ (__NR_mlockall, sys_mlockall), // 156 1583 LINX_ (__NR_munlockall, sys_munlockall), // 157 1584 //.. LINXY(__NR_sched_setparam, sys_sched_setparam), // 158 1585 //.. 1586 LINXY (__NR_sched_getparam, sys_sched_getparam), // 159 1587 LINX_ (__NR_sched_setscheduler, sys_sched_setscheduler), // 160 1588 LINX_ (__NR_sched_getscheduler, sys_sched_getscheduler), // 161 1589 LINX_ (__NR_sched_yield, sys_sched_yield), // 162 1590 LINX_ (__NR_sched_get_priority_max, sys_sched_get_priority_max), // 163 1591 LINX_ (__NR_sched_get_priority_min, sys_sched_get_priority_min), // 164 1592 //.. //LINX?(__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 165 */* 1593 GENXY (__NR_nanosleep, sys_nanosleep), // 166 1594 GENX_ (__NR_mremap, sys_mremap), // 167 1595 PLAXY (__NR_accept, sys_accept), // 168 1596 PLAX_ (__NR_bind, sys_bind), // 169 1597 PLAX_ (__NR_connect, sys_connect), // 170 1598 PLAXY (__NR_getpeername, sys_getpeername), // 171 1599 PLAXY (__NR_getsockname, sys_getsockname), // 172 1600 PLAXY (__NR_getsockopt, sys_getsockopt), // 173 1601 PLAX_ (__NR_listen, sys_listen), // 174 1602 PLAXY (__NR_recv, sys_recv), // 175 1603 PLAXY (__NR_recvfrom, sys_recvfrom), // 176 1604 PLAXY (__NR_recvmsg, sys_recvmsg), // 177 1605 PLAX_ (__NR_send, sys_send), // 178 1606 PLAX_ (__NR_sendmsg, sys_sendmsg), // 179 1607 PLAX_ (__NR_sendto, sys_sendto), // 180 1608 PLAX_ (__NR_setsockopt, sys_setsockopt), // 181 1609 PLAXY (__NR_socket, sys_socket), // 183 1610 PLAXY (__NR_socketpair, sys_socketpair), // 184 1611 LINX_ (__NR_setresuid, sys_setresuid), // 185 1612 LINXY (__NR_getresuid, sys_getresuid), // 186 1613 //.. GENX_(__NR_query_module, sys_ni_syscall), // 1614 GENXY (__NR_poll, sys_poll), // 188 1615 //.. // (__NR_nfsservctl, sys_nfsservctl), // 168 */Linux 1616 //.. 1617 LINX_ (__NR_setresgid, sys_setresgid), // 190 1618 LINXY (__NR_getresgid, sys_getresgid), // 191 1619 LINXY (__NR_prctl, sys_prctl), // 192 1620 PLAX_ (__NR_rt_sigreturn, sys_rt_sigreturn), // 193 1621 LINXY (__NR_rt_sigaction, sys_rt_sigaction), // 194 1622 LINXY (__NR_rt_sigprocmask, sys_rt_sigprocmask), // 195 1623 LINXY (__NR_rt_sigpending, sys_rt_sigpending), // 196 1624 LINXY (__NR_rt_sigtimedwait, sys_rt_sigtimedwait), // 197 1625 LINXY (__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo), // 198 1626 LINX_ (__NR_rt_sigsuspend, sys_rt_sigsuspend), // 199 1627 GENXY (__NR_pread64, sys_pread64), // 200 1628 GENX_ (__NR_pwrite64, sys_pwrite64), // 201 1629 GENX_ (__NR_chown, sys_chown), // 202 1630 GENXY (__NR_getcwd, sys_getcwd), // 203 1631 LINXY (__NR_capget, sys_capget), // 204 1632 //.. 1633 //.. LINX_(__NR_capset, sys_capset), // 205 1634 GENXY (__NR_sigaltstack, sys_sigaltstack), // 206 1635 LINXY (__NR_sendfile, sys_sendfile), // 207 1636 //.. GENXY(__NR_getpmsg, sys_getpmsg), // 208 1637 //.. GENX_(__NR_putpmsg, sys_putpmsg), // 209 1638 // Nb: we treat vfork as fork 1639 // GENX_(__NR_vfork, sys_fork), // 1640 GENXY (__NR_getrlimit, sys_getrlimit), // 76 1641 //__NR_readahead // 191 ppc/Linux only? 1642 PLAX_ (__NR_mmap2, sys_mmap2), // 210 1643 // GENX_(__NR_truncate64, sys_truncate64), // 211 1644 GENX_ (__NR_ftruncate64, sys_ftruncate64), // 212 1645 //.. 1646 PLAXY (__NR_stat64, sys_stat64), // 213 1647 PLAXY (__NR_lstat64, sys_lstat64), // 214 1648 PLAXY (__NR_fstat64, sys_fstat64), // 215 1649 GENXY (__NR_getdents64, sys_getdents64), // 219 1650 //.. // (__NR_pivot_root, sys_pivot_root), // 1651 LINXY (__NR_fcntl64, sys_fcntl64), // 220 1652 GENX_ (__NR_madvise, sys_madvise), // 218 1653 GENXY (__NR_mincore, sys_mincore), // 217 1654 LINX_ (__NR_gettid, sys_gettid), // 222 1655 //.. LINX_(__NR_tkill, sys_tkill), // 208 */Linux 1656 //.. LINX_(__NR_setxattr, sys_setxattr), // 209 1657 //.. LINX_(__NR_lsetxattr, sys_lsetxattr), // 210 1658 //.. LINX_(__NR_fsetxattr, sys_fsetxattr), // 211 1659 LINXY (__NR_getxattr, sys_getxattr), // 227 1660 LINXY (__NR_lgetxattr, sys_lgetxattr), // 228 1661 LINXY (__NR_fgetxattr, sys_fgetxattr), // 229 1662 LINXY (__NR_listxattr, sys_listxattr), // 230 1663 LINXY (__NR_llistxattr, sys_llistxattr), // 231 1664 LINXY (__NR_flistxattr, sys_flistxattr), // 232 1665 LINX_ (__NR_removexattr, sys_removexattr), // 233 1666 LINX_ (__NR_lremovexattr, sys_lremovexattr), // 234 1667 LINX_ (__NR_fremovexattr, sys_fremovexattr), // 235 1668 LINXY (__NR_futex, sys_futex), // 238 1669 LINX_ (__NR_sched_setaffinity, sys_sched_setaffinity), // 239 1670 LINXY (__NR_sched_getaffinity, sys_sched_getaffinity), // 240 1671 /* 224 currently unused */ 1672 // __NR_tuxcall // 1673 LINXY (__NR_sendfile64, sys_sendfile64), // 237 1674 //.. 1675 LINX_ (__NR_io_setup, sys_io_setup), // 241 1676 LINX_ (__NR_io_destroy, sys_io_destroy), // 242 1677 LINXY (__NR_io_getevents, sys_io_getevents), // 243 1678 LINX_ (__NR_io_submit, sys_io_submit), // 244 1679 LINXY (__NR_io_cancel, sys_io_cancel), // 245 1680 //.. 1681 LINX_ (__NR_set_tid_address, sys_set_tid_address), // 252 1682 LINX_ (__NR_fadvise64, sys_fadvise64), // 254 1683 LINX_ (__NR_exit_group, sys_exit_group), // 246 1684 //.. GENXY(__NR_lookup_dcookie, sys_lookup_dcookie), // 247 1685 LINXY (__NR_epoll_create, sys_epoll_create), // 248 1686 LINX_ (__NR_epoll_ctl, sys_epoll_ctl), // 249 1687 LINXY (__NR_epoll_wait, sys_epoll_wait), // 250 1688 //.. // (__NR_remap_file_pages, sys_remap_file_pages), // 239 */Linux 1689 LINXY (__NR_timer_create, sys_timer_create), // 257 1690 LINXY (__NR_timer_settime, sys_timer_settime), // 258 1691 LINXY (__NR_timer_gettime, sys_timer_gettime), // 259 1692 LINX_ (__NR_timer_getoverrun, sys_timer_getoverrun), // 260 1693 LINX_ (__NR_timer_delete, sys_timer_delete), // 261 1694 LINX_ (__NR_clock_settime, sys_clock_settime), // 262 1695 LINXY (__NR_clock_gettime, sys_clock_gettime), // 263 1696 LINXY (__NR_clock_getres, sys_clock_getres), // 264 1697 LINXY (__NR_clock_nanosleep, sys_clock_nanosleep), // 265 1698 // __NR_swapcontext // 1699 LINXY (__NR_tgkill, sys_tgkill), // 266 */Linux 1700 //.. GENX_(__NR_utimes, sys_utimes), // 267 1701 GENXY (__NR_statfs64, sys_statfs64), // 255 1702 GENXY (__NR_fstatfs64, sys_fstatfs64), // 256 1703 LINXY (__NR_get_mempolicy, sys_get_mempolicy), // 269 1704 LINX_ (__NR_set_mempolicy, sys_set_mempolicy), // 270 1705 LINXY (__NR_mq_open, sys_mq_open), // 271 1706 LINX_ (__NR_mq_unlink, sys_mq_unlink), // 272 1707 LINX_ (__NR_mq_timedsend, sys_mq_timedsend), // 273 1708 LINXY (__NR_mq_timedreceive, sys_mq_timedreceive), // 274 1709 LINX_ (__NR_mq_notify, sys_mq_notify), // 275 1710 LINXY (__NR_mq_getsetattr, sys_mq_getsetattr), // 276 1711 // __NR_kexec_load // 1712 LINX_ (__NR_inotify_init, sys_inotify_init), // 275 1713 LINX_ (__NR_inotify_add_watch, sys_inotify_add_watch), // 276 1714 LINX_ (__NR_inotify_rm_watch, sys_inotify_rm_watch), // 277 1715 PLAX_ (__NR_set_thread_area, sys_set_thread_area), // 283 1716 LINXY (__NR_openat, sys_openat), // 288 1717 LINX_ (__NR_mkdirat, sys_mkdirat), // 289 1718 LINX_ (__NR_mknodat, sys_mknodat), // 290 1719 LINX_ (__NR_fchownat, sys_fchownat), // 291 1720 LINX_ (__NR_futimesat, sys_futimesat), // 292 1721 PLAXY (__NR_fstatat64, sys_fstatat64), // 293 1722 LINX_ (__NR_unlinkat, sys_unlinkat), // 294 1723 LINX_ (__NR_renameat, sys_renameat), // 295 1724 LINX_ (__NR_linkat, sys_linkat), // 296 1725 LINX_ (__NR_symlinkat, sys_symlinkat), // 297 1726 LINX_ (__NR_readlinkat, sys_readlinkat), // 298 1727 LINX_ (__NR_fchmodat, sys_fchmodat), // 299 1728 LINX_ (__NR_faccessat, sys_faccessat), // 300 1729 LINXY (__NR_ppoll, sys_ppoll), // 302 1730 LINX_ (__NR_set_robust_list, sys_set_robust_list), // 309 1731 LINXY (__NR_get_robust_list, sys_get_robust_list), // 310 1732 LINXY (__NR_epoll_pwait, sys_epoll_pwait), // 313 1733 LINX_ (__NR_utimensat, sys_utimensat), // 316 1734 LINX_ (__NR_fallocate, sys_fallocate), // 320 1735 LINXY (__NR_timerfd_create, sys_timerfd_create), // 321 1736 LINXY (__NR_timerfd_gettime, sys_timerfd_gettime), // 322 1737 LINXY (__NR_timerfd_settime, sys_timerfd_settime), // 323 1738 LINXY (__NR_signalfd4, sys_signalfd4), // 324 1739 LINX_ (__NR_eventfd2, sys_eventfd2), // 325 1740 LINXY (__NR_pipe2, sys_pipe2), // 328 1741 LINXY (__NR_inotify_init1, sys_inotify_init1), // 329 1742 LINXY (__NR_prlimit64, sys_prlimit64) // 338 1743 }; 1744 1745 SyscallTableEntry* ML_(get_linux_syscall_entry) (UInt sysno) 1746 { 1747 const UInt syscall_main_table_size 1748 = sizeof (syscall_main_table) / sizeof (syscall_main_table[0]); 1749 /* Is it in the contiguous initial section of the table? */ 1750 if (sysno < syscall_main_table_size) 1751 { 1752 SyscallTableEntry * sys = &syscall_main_table[sysno]; 1753 if (sys->before == NULL) 1754 return NULL; /* no entry */ 1755 else 1756 return sys; 1757 } 1758 /* Can't find a wrapper */ 1759 return NULL; 1760 } 1761 1762 #endif // defined(VGP_mips32_linux) 1763 1764 /*--------------------------------------------------------------------*/ 1765 /*--- end syswrap-mips-linux.c ---*/ 1766 /*--------------------------------------------------------------------*/ 1767
