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))
81 void 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
87 asm (
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.
148 asm (
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
215 static SysRes sys_set_tls (ThreadId tid, Addr tlsptr);
216 static 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 ????!!!!???
225 void
VG_(cleanup_thread)226 VG_ (cleanup_thread) (ThreadArchState * arch) { }
227
sys_set_tls(ThreadId tid,Addr tlsptr)228 SysRes 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 ------------------------------------------------------------------ */
notify_core_of_mmap(Addr a,SizeT len,UInt prot,UInt flags,Int fd,Off64T offset)237 static 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
notify_tool_of_mmap(Addr a,SizeT len,UInt prot,ULong di_handle)254 static 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 */
mips_PRE_sys_mmap(ThreadId tid,UWord arg1,UWord arg2,UWord arg3,UWord arg4,UWord arg5,Off64T arg6)275 static 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);
401 DECL_TEMPLATE (mips_linux, sys_mmap);
402 DECL_TEMPLATE (mips_linux, sys_mmap2);
403 DECL_TEMPLATE (mips_linux, sys_stat64);
404 DECL_TEMPLATE (mips_linux, sys_lstat64);
405 DECL_TEMPLATE (mips_linux, sys_fadvise64);
406 DECL_TEMPLATE (mips_linux, sys_fstatat64);
407 DECL_TEMPLATE (mips_linux, sys_fstat64);
408 DECL_TEMPLATE (mips_linux, sys_sigreturn);
409 DECL_TEMPLATE (mips_linux, sys_rt_sigreturn);
410 DECL_TEMPLATE (mips_linux, sys_cacheflush);
411 DECL_TEMPLATE (mips_linux, sys_set_thread_area);
412 DECL_TEMPLATE (mips_linux, sys_pipe);
413 DECL_TEMPLATE (mips_linux, sys_prctl);
414 DECL_TEMPLATE (mips_linux, sys_ptrace);
415
PRE(sys_mmap2)416 PRE(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
PRE(sys_mmap)432 PRE(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
PRE(sys_ptrace)443 PRE(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
POST(sys_ptrace)472 POST(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
PRE(sys_lstat64)502 PRE(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
POST(sys_lstat64)510 POST(sys_lstat64)
511 {
512 vg_assert (SUCCESS);
513 if (RES == 0)
514 {
515 POST_MEM_WRITE (ARG2, sizeof (struct vki_stat64));
516 }
517 }
518
PRE(sys_stat64)519 PRE(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
POST(sys_stat64)527 POST(sys_stat64)
528 {
529 POST_MEM_WRITE (ARG2, sizeof (struct vki_stat64));
530 }
531
PRE(sys_fadvise64)532 PRE(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
PRE(sys_fstatat64)548 PRE(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
POST(sys_fstatat64)560 POST(sys_fstatat64)
561 {
562 POST_MEM_WRITE (ARG3, sizeof (struct vki_stat64));
563 }
564
PRE(sys_fstat64)565 PRE(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
POST(sys_fstat64)572 POST(sys_fstat64)
573 {
574 POST_MEM_WRITE (ARG2, sizeof (struct vki_stat64));
575 }
576
PRE(sys_sigreturn)577 PRE(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
PRE(sys_rt_sigreturn)592 PRE(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
PRE(sys_set_thread_area)608 PRE(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 */
PRE(sys_cacheflush)616 PRE(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
PRE(sys_pipe)626 PRE(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
POST(sys_pipe)633 POST(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
PRE(sys_prctl)653 PRE(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
POST(sys_prctl)699 POST(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
722 static 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
ML_(get_linux_syscall_entry)1043 SyscallTableEntry* 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