?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drd/tests: Fix remaining gcc 8 compiler warnings
[valgrind.git] / coregrind / m_syswrap / syswrap-mips32-linux.c
blob89cf126a7ba5e614634f1299f988727c2a09826c
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
226 VG_ (cleanup_thread) (ThreadArchState * arch) { }
227
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 ------------------------------------------------------------------ */
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
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 */
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
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
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
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
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
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
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
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
527 POST(sys_stat64)
528 {
529 POST_MEM_WRITE (ARG2, sizeof (struct vki_stat64));
530 }
531
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
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
560 POST(sys_fstatat64)
561 {
562 POST_MEM_WRITE (ARG3, sizeof (struct vki_stat64));
563 }
564
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
572 POST(sys_fstat64)
573 {
574 POST_MEM_WRITE (ARG2, sizeof (struct vki_stat64));
575 }
576
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
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
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 */
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
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
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
653 PRE(sys_prctl)
654 {
655 switch (ARG1) {
656 case VKI_PR_SET_FP_MODE:
657 {
658 VexArchInfo vai;
659 Int known_bits = VKI_PR_FP_MODE_FR | VKI_PR_FP_MODE_FRE;
660 VG_(machine_get_VexArchInfo)(NULL, &vai);
661 /* Reject unsupported modes */
662 if (ARG2 & ~known_bits) {
663 SET_STATUS_Failure(VKI_EOPNOTSUPP);
664 return;
665 }
666 if ((ARG2 & VKI_PR_FP_MODE_FR) && !VEX_MIPS_HOST_FP_MODE(vai.hwcaps)) {
667 SET_STATUS_Failure(VKI_EOPNOTSUPP);
668 return;
669 }
670 if ((ARG2 & VKI_PR_FP_MODE_FRE) && !VEX_MIPS_CPU_HAS_MIPSR6(vai.hwcaps)) {
671 SET_STATUS_Failure(VKI_EOPNOTSUPP);
672 return;
673 }
674 if (!(ARG2 & VKI_PR_FP_MODE_FR) && VEX_MIPS_CPU_HAS_MIPSR6(vai.hwcaps)) {
675 SET_STATUS_Failure(VKI_EOPNOTSUPP);
676 return;
677 }
678
679 if ((!(VG_(threads)[tid].arch.vex.guest_CP0_status &
680 MIPS_CP0_STATUS_FR) != !(ARG2 & VKI_PR_FP_MODE_FR)) ||
681 (!(VG_(threads)[tid].arch.vex.guest_CP0_Config5 &
682 MIPS_CONF5_FRE) != !(ARG2 & VKI_PR_FP_MODE_FRE))) {
683 ThreadId t;
684 for (t = 1; t < VG_N_THREADS; t++) {
685 if (VG_(threads)[t].status != VgTs_Empty) {
686 if (ARG2 & VKI_PR_FP_MODE_FRE) {
687 VG_(threads)[t].arch.vex.guest_CP0_Config5 |=
688 MIPS_CONF5_FRE;
689 } else {
690 VG_(threads)[t].arch.vex.guest_CP0_Config5 &=
691 ~MIPS_CONF5_FRE;
692 }
693 if (ARG2 & VKI_PR_FP_MODE_FR) {
694 VG_(threads)[t].arch.vex.guest_CP0_status |=
695 MIPS_CP0_STATUS_FR;
696 } else {
697 VG_(threads)[t].arch.vex.guest_CP0_status &=
698 ~MIPS_CP0_STATUS_FR;
699 }
700 }
701 /* Discard all translations */
702 VG_(discard_translations)(0, 0xfffffffful, "prctl(PR_SET_FP_MODE)");
703 }
704 SET_STATUS_Success(0);
705 }
706 break;
707 }
708 case VKI_PR_GET_FP_MODE:
709 {
710 UInt ret = 0;
711 if (VG_(threads)[tid].arch.vex.guest_CP0_status & MIPS_CP0_STATUS_FR)
712 ret |= VKI_PR_FP_MODE_FR;
713 if (VG_(threads)[tid].arch.vex.guest_CP0_Config5 & MIPS_CONF5_FRE)
714 ret |= VKI_PR_FP_MODE_FRE;
715 SET_STATUS_Success(ret);
716 break;
717 }
718 default:
719 WRAPPER_PRE_NAME(linux, sys_prctl)(tid, layout, arrghs, status, flags);
720 break;
721 }
722 }
723
724 POST(sys_prctl)
725 {
726 WRAPPER_POST_NAME(linux, sys_prctl)(tid, arrghs, status);
727 }
728
729 #undef PRE
730 #undef POST
731
732 /* ---------------------------------------------------------------------
733 The mips/Linux syscall table
734 ------------------------------------------------------------------ */
735 #define PLAX_(sysno, name) WRAPPER_ENTRY_X_(mips_linux, sysno, name)
736 #define PLAXY(sysno, name) WRAPPER_ENTRY_XY(mips_linux, sysno, name)
737
738 // This table maps from __NR_xxx syscall numbers (from
739 // linux/include/asm-mips/unistd.h) to the appropriate PRE/POST sys_foo()
740 // wrappers on mips (as per sys_call_table in linux/arch/mips/kernel/entry.S).
741 //
742
743 // For those syscalls not handled by Valgrind, the annotation indicate its
744 // arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/?
745 // (unknown).
746
747 static SyscallTableEntry syscall_main_table[] = {
748 //.. PLAXY (__NR_syscall, sys_syscall), // 0
749 GENX_ (__NR_exit, sys_exit), // 1
750 GENX_ (__NR_fork, sys_fork), // 2
751 GENXY (__NR_read, sys_read), // 3
752 GENX_ (__NR_write, sys_write), // 4
753 GENXY (__NR_open, sys_open), // 5
754 GENXY (__NR_close, sys_close), // 6
755 GENXY (__NR_waitpid, sys_waitpid), // 7
756 GENXY (__NR_creat, sys_creat), // 8
757 GENX_ (__NR_link, sys_link), // 9
758 GENX_ (__NR_unlink, sys_unlink), // 10
759 GENX_ (__NR_execve, sys_execve), // 11
760 GENX_ (__NR_chdir, sys_chdir), // 12
761 GENXY (__NR_time, sys_time), // 13
762 GENX_ (__NR_mknod, sys_mknod), // 14
763 GENX_ (__NR_chmod, sys_chmod), // 15
764 GENX_ (__NR_lchown, sys_lchown), // 16
765 //..
766 LINX_ (__NR_lseek, sys_lseek), // 19
767 GENX_ (__NR_getpid, sys_getpid), // 20
768 LINX_ (__NR_mount, sys_mount), // 21
769 LINX_ (__NR_umount, sys_oldumount), // 22
770 GENX_ (__NR_setuid, sys_setuid), // 23
771 GENX_ (__NR_getuid, sys_getuid), // 24
772 LINX_ (__NR_stime, sys_stime), // 25
773 PLAXY(__NR_ptrace, sys_ptrace), // 26
774 GENX_ (__NR_alarm, sys_alarm), // 27
775 //.. // (__NR_oldfstat, sys_fstat), // 28
776 GENX_ (__NR_pause, sys_pause), // 29
777 LINX_ (__NR_utime, sys_utime), // 30
778 //.. GENX_(__NR_stty, sys_ni_syscall), // 31
779 //.. GENX_(__NR_gtty, sys_ni_syscall), // 32
780 GENX_ (__NR_access, sys_access), // 33
781 //.. GENX_(__NR_nice, sys_nice), // 34
782 //.. GENX_(__NR_ftime, sys_ni_syscall), // 35
783 //.. GENX_(__NR_sync, sys_sync), // 36
784 GENX_ (__NR_kill, sys_kill), // 37
785 GENX_ (__NR_rename, sys_rename), // 38
786 GENX_ (__NR_mkdir, sys_mkdir), // 39
787 GENX_ (__NR_rmdir, sys_rmdir), // 40
788 GENXY (__NR_dup, sys_dup), // 41
789 PLAXY (__NR_pipe, sys_pipe), // 42
790 GENXY (__NR_times, sys_times), // 43
791 //.. GENX_(__NR_prof, sys_ni_syscall), // 44
792 GENX_ (__NR_brk, sys_brk), // 45
793 GENX_ (__NR_setgid, sys_setgid), // 46
794 GENX_ (__NR_getgid, sys_getgid), // 47
795 //.. // (__NR_signal, sys_signal), // 48
796 GENX_ (__NR_geteuid, sys_geteuid), // 49
797 GENX_ (__NR_getegid, sys_getegid), // 50
798 //.. GENX_(__NR_acct, sys_acct), // 51
799 LINX_ (__NR_umount2, sys_umount), // 52
800 //.. GENX_(__NR_lock, sys_ni_syscall), // 53
801 LINXY (__NR_ioctl, sys_ioctl), // 54
802 LINXY (__NR_fcntl, sys_fcntl), // 55
803 //.. GENX_(__NR_mpx, sys_ni_syscall), // 56
804 GENX_ (__NR_setpgid, sys_setpgid), // 57
805 //.. GENX_(__NR_ulimit, sys_ni_syscall), // 58
806 //.. // (__NR_oldolduname, sys_olduname), // 59
807 GENX_ (__NR_umask, sys_umask), // 60
808 GENX_ (__NR_chroot, sys_chroot), // 61
809 //.. // (__NR_ustat, sys_ustat) // 62
810 GENXY (__NR_dup2, sys_dup2), // 63
811 GENX_ (__NR_getppid, sys_getppid), // 64
812 GENX_ (__NR_getpgrp, sys_getpgrp), // 65
813 GENX_ (__NR_setsid, sys_setsid), // 66
814 LINXY (__NR_sigaction, sys_sigaction), // 67
815 //.. // (__NR_sgetmask, sys_sgetmask), // 68
816 //.. // (__NR_ssetmask, sys_ssetmask), // 69
817 GENX_ (__NR_setreuid, sys_setreuid), // 70
818 GENX_ (__NR_setregid, sys_setregid), // 71
819 // PLAX_(__NR_sigsuspend, sys_sigsuspend), // 72
820 LINXY (__NR_sigpending, sys_sigpending), // 73
821 //.. // (__NR_sethostname, sys_sethostname), // 74
822 GENX_ (__NR_setrlimit, sys_setrlimit), // 75
823 GENXY (__NR_getrlimit, sys_getrlimit), // 76
824 GENXY (__NR_getrusage, sys_getrusage), // 77
825 GENXY (__NR_gettimeofday, sys_gettimeofday), // 78
826 GENX_ (__NR_settimeofday, sys_settimeofday), // 79
827 GENXY (__NR_getgroups, sys_getgroups), // 80
828 GENX_ (__NR_setgroups, sys_setgroups), // 81
829 //.. PLAX_(__NR_select, old_select), // 82
830 GENX_ (__NR_symlink, sys_symlink), // 83
831 //.. // (__NR_oldlstat, sys_lstat), // 84
832 GENX_ (__NR_readlink, sys_readlink), // 85
833 //.. // (__NR_uselib, sys_uselib), // 86
834 //.. // (__NR_swapon, sys_swapon), // 87
835 //.. // (__NR_reboot, sys_reboot), // 88
836 //.. // (__NR_readdir, old_readdir), // 89
837 PLAX_ (__NR_mmap, sys_mmap), // 90
838 GENXY (__NR_munmap, sys_munmap), // 91
839 GENX_ (__NR_truncate, sys_truncate), // 92
840 GENX_ (__NR_ftruncate, sys_ftruncate), // 93
841 GENX_ (__NR_fchmod, sys_fchmod), // 94
842 GENX_ (__NR_fchown, sys_fchown), // 95
843 GENX_ (__NR_getpriority, sys_getpriority), // 96
844 GENX_ (__NR_setpriority, sys_setpriority), // 97
845 //.. GENX_(__NR_profil, sys_ni_syscall), // 98
846 GENXY (__NR_statfs, sys_statfs), // 99
847 GENXY (__NR_fstatfs, sys_fstatfs), // 100
848 //.. LINX_(__NR_ioperm, sys_ioperm), // 101
849 LINXY (__NR_socketcall, sys_socketcall), // 102
850 LINXY (__NR_syslog, sys_syslog), // 103
851 GENXY (__NR_setitimer, sys_setitimer), // 104
852 //.. GENXY(__NR_getitimer, sys_getitimer), // 105
853 GENXY (__NR_stat, sys_newstat), // 106
854 GENXY (__NR_lstat, sys_newlstat), // 107
855 GENXY (__NR_fstat, sys_newfstat), // 108
856 //.. // (__NR_olduname, sys_uname), // 109
857 //.. GENX_(__NR_iopl, sys_iopl), // 110
858 //.. LINX_(__NR_vhangup, sys_vhangup), // 111
859 //.. GENX_(__NR_idle, sys_ni_syscall), // 112
860 //.. // (__NR_vm86old, sys_vm86old), // 113
861 GENXY (__NR_wait4, sys_wait4), // 114
862 //.. // (__NR_swapoff, sys_swapoff), // 115
863 LINXY (__NR_sysinfo, sys_sysinfo), // 116
864 LINXY (__NR_ipc, sys_ipc), // 117
865 GENX_ (__NR_fsync, sys_fsync), // 118
866 PLAX_ (__NR_sigreturn, sys_sigreturn), // 119
867 LINX_ (__NR_clone, sys_clone), // 120
868 //.. // (__NR_setdomainname, sys_setdomainname), // 121
869 GENXY (__NR_uname, sys_newuname), // 122
870 //.. PLAX_(__NR_modify_ldt, sys_modify_ldt), // 123
871 //.. LINXY(__NR_adjtimex, sys_adjtimex), // 124
872 GENXY (__NR_mprotect, sys_mprotect), // 125
873 LINXY (__NR_sigprocmask, sys_sigprocmask), // 126
874 //.. GENX_(__NR_create_module, sys_ni_syscall), // 127
875 //.. GENX_(__NR_init_module, sys_init_module), // 128
876 //.. // (__NR_delete_module, sys_delete_module), // 129
877 //.. GENX_(__NR_get_kernel_syms, sys_ni_syscall), // 130
878 //.. LINX_(__NR_quotactl, sys_quotactl), // 131
879 GENX_ (__NR_getpgid, sys_getpgid), // 132
880 GENX_ (__NR_fchdir, sys_fchdir), // 133
881 //.. // (__NR_bdflush, sys_bdflush), // 134
882 //.. // (__NR_sysfs, sys_sysfs), // 135
883 LINX_ (__NR_personality, sys_personality), // 136
884 //.. GENX_(__NR_afs_syscall, sys_ni_syscall), // 137
885 LINX_ (__NR_setfsuid, sys_setfsuid), // 138
886 LINX_ (__NR_setfsgid, sys_setfsgid), // 139
887 LINXY (__NR__llseek, sys_llseek), // 140
888 GENXY (__NR_getdents, sys_getdents), // 141
889 GENX_ (__NR__newselect, sys_select), // 142
890 GENX_ (__NR_flock, sys_flock), // 143
891 GENX_ (__NR_msync, sys_msync), // 144
892 GENXY (__NR_readv, sys_readv), // 145
893 GENX_ (__NR_writev, sys_writev), // 146
894 PLAX_ (__NR_cacheflush, sys_cacheflush), // 147
895 GENX_ (__NR_getsid, sys_getsid), // 151
896 GENX_ (__NR_fdatasync, sys_fdatasync), // 152
897 LINXY (__NR__sysctl, sys_sysctl), // 153
898 GENX_ (__NR_mlock, sys_mlock), // 154
899 GENX_ (__NR_munlock, sys_munlock), // 155
900 GENX_ (__NR_mlockall, sys_mlockall), // 156
901 LINX_ (__NR_munlockall, sys_munlockall), // 157
902 //.. LINXY(__NR_sched_setparam, sys_sched_setparam), // 158
903 LINXY (__NR_sched_getparam, sys_sched_getparam), // 159
904 LINX_ (__NR_sched_setscheduler, sys_sched_setscheduler), // 160
905 LINX_ (__NR_sched_getscheduler, sys_sched_getscheduler), // 161
906 LINX_ (__NR_sched_yield, sys_sched_yield), // 162
907 LINX_ (__NR_sched_get_priority_max, sys_sched_get_priority_max), // 163
908 LINX_ (__NR_sched_get_priority_min, sys_sched_get_priority_min), // 164
909 //.. //LINX?(__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 165
910 GENXY (__NR_nanosleep, sys_nanosleep), // 166
911 GENX_ (__NR_mremap, sys_mremap), // 167
912 LINXY (__NR_accept, sys_accept), // 168
913 LINX_ (__NR_bind, sys_bind), // 169
914 LINX_ (__NR_connect, sys_connect), // 170
915 LINXY (__NR_getpeername, sys_getpeername), // 171
916 LINXY (__NR_getsockname, sys_getsockname), // 172
917 LINXY (__NR_getsockopt, sys_getsockopt), // 173
918 LINX_ (__NR_listen, sys_listen), // 174
919 LINXY (__NR_recv, sys_recv), // 175
920 LINXY (__NR_recvfrom, sys_recvfrom), // 176
921 LINXY (__NR_recvmsg, sys_recvmsg), // 177
922 LINX_ (__NR_send, sys_send), // 178
923 LINX_ (__NR_sendmsg, sys_sendmsg), // 179
924 LINX_ (__NR_sendto, sys_sendto), // 180
925 LINX_ (__NR_setsockopt, sys_setsockopt), // 181
926 LINX_ (__NR_shutdown, sys_shutdown), // 182
927 LINXY (__NR_socket, sys_socket), // 183
928 LINXY (__NR_socketpair, sys_socketpair), // 184
929 LINX_ (__NR_setresuid, sys_setresuid), // 185
930 LINXY (__NR_getresuid, sys_getresuid), // 186
931 //.. GENX_(__NR_query_module, sys_ni_syscall), // 187
932 GENXY (__NR_poll, sys_poll), // 188
933 //..
934 LINX_ (__NR_setresgid, sys_setresgid), // 190
935 LINXY (__NR_getresgid, sys_getresgid), // 191
936 PLAXY (__NR_prctl, sys_prctl), // 192
937 PLAX_ (__NR_rt_sigreturn, sys_rt_sigreturn), // 193
938 LINXY (__NR_rt_sigaction, sys_rt_sigaction), // 194
939 LINXY (__NR_rt_sigprocmask, sys_rt_sigprocmask), // 195
940 LINXY (__NR_rt_sigpending, sys_rt_sigpending), // 196
941 LINXY (__NR_rt_sigtimedwait, sys_rt_sigtimedwait), // 197
942 LINXY (__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo), // 198
943 LINX_ (__NR_rt_sigsuspend, sys_rt_sigsuspend), // 199
944 GENXY (__NR_pread64, sys_pread64), // 200
945 GENX_ (__NR_pwrite64, sys_pwrite64), // 201
946 GENX_ (__NR_chown, sys_chown), // 202
947 GENXY (__NR_getcwd, sys_getcwd), // 203
948 LINXY (__NR_capget, sys_capget), // 204
949 //.. LINX_(__NR_capset, sys_capset), // 205
950 GENXY (__NR_sigaltstack, sys_sigaltstack), // 206
951 LINXY (__NR_sendfile, sys_sendfile), // 207
952 //.. GENXY(__NR_getpmsg, sys_getpmsg), // 208
953 //.. GENX_(__NR_putpmsg, sys_putpmsg), // 209
954 PLAX_ (__NR_mmap2, sys_mmap2), // 210
955 // GENX_(__NR_truncate64, sys_truncate64), // 211
956 GENX_ (__NR_ftruncate64, sys_ftruncate64), // 212
957 PLAXY (__NR_stat64, sys_stat64), // 213
958 PLAXY (__NR_lstat64, sys_lstat64), // 214
959 PLAXY (__NR_fstat64, sys_fstat64), // 215
960 //..
961 GENXY (__NR_mincore, sys_mincore), // 217
962 GENX_ (__NR_madvise, sys_madvise), // 218
963 GENXY (__NR_getdents64, sys_getdents64), // 219
964 LINXY (__NR_fcntl64, sys_fcntl64), // 220
965 //..
966 LINX_ (__NR_gettid, sys_gettid), // 222
967 //..
968 LINXY (__NR_getxattr, sys_getxattr), // 227
969 LINXY (__NR_lgetxattr, sys_lgetxattr), // 228
970 LINXY (__NR_fgetxattr, sys_fgetxattr), // 229
971 LINXY (__NR_listxattr, sys_listxattr), // 230
972 LINXY (__NR_llistxattr, sys_llistxattr), // 231
973 LINXY (__NR_flistxattr, sys_flistxattr), // 232
974 LINX_ (__NR_removexattr, sys_removexattr), // 233
975 LINX_ (__NR_lremovexattr, sys_lremovexattr), // 234
976 LINX_ (__NR_fremovexattr, sys_fremovexattr), // 235
977 //..
978 LINXY (__NR_sendfile64, sys_sendfile64), // 237
979 LINXY (__NR_futex, sys_futex), // 238
980 LINX_ (__NR_sched_setaffinity, sys_sched_setaffinity), // 239
981 LINXY (__NR_sched_getaffinity, sys_sched_getaffinity), // 240
982 LINX_ (__NR_io_setup, sys_io_setup), // 241
983 LINX_ (__NR_io_destroy, sys_io_destroy), // 242
984 LINXY (__NR_io_getevents, sys_io_getevents), // 243
985 LINX_ (__NR_io_submit, sys_io_submit), // 244
986 LINXY (__NR_io_cancel, sys_io_cancel), // 245
987 LINX_ (__NR_exit_group, sys_exit_group), // 246
988 //..
989 LINXY (__NR_epoll_create, sys_epoll_create), // 248
990 LINX_ (__NR_epoll_ctl, sys_epoll_ctl), // 249
991 LINXY (__NR_epoll_wait, sys_epoll_wait), // 250
992 //..
993 LINX_ (__NR_set_tid_address, sys_set_tid_address), // 252
994 PLAX_ (__NR_fadvise64, sys_fadvise64), // 254
995 GENXY (__NR_statfs64, sys_statfs64), // 255
996 GENXY (__NR_fstatfs64, sys_fstatfs64), // 256
997 //..
998 LINXY (__NR_timer_create, sys_timer_create), // 257
999 LINXY (__NR_timer_settime, sys_timer_settime), // 258
1000 LINXY (__NR_timer_gettime, sys_timer_gettime), // 259
1001 LINX_ (__NR_timer_getoverrun, sys_timer_getoverrun), // 260
1002 LINX_ (__NR_timer_delete, sys_timer_delete), // 261
1003 LINX_ (__NR_clock_settime, sys_clock_settime), // 262
1004 LINXY (__NR_clock_gettime, sys_clock_gettime), // 263
1005 LINXY (__NR_clock_getres, sys_clock_getres), // 264
1006 LINXY (__NR_clock_nanosleep, sys_clock_nanosleep), // 265
1007 LINXY (__NR_tgkill, sys_tgkill), // 266
1008 //.. GENX_(__NR_utimes, sys_utimes), // 267
1009 LINXY (__NR_get_mempolicy, sys_get_mempolicy), // 269
1010 LINX_ (__NR_set_mempolicy, sys_set_mempolicy), // 270
1011 LINXY (__NR_mq_open, sys_mq_open), // 271
1012 LINX_ (__NR_mq_unlink, sys_mq_unlink), // 272
1013 LINX_ (__NR_mq_timedsend, sys_mq_timedsend), // 273
1014 LINXY (__NR_mq_timedreceive, sys_mq_timedreceive), // 274
1015 LINX_ (__NR_mq_notify, sys_mq_notify), // 275
1016 LINXY (__NR_mq_getsetattr, sys_mq_getsetattr), // 276
1017 LINX_ (__NR_inotify_init, sys_inotify_init), // 275
1018 LINX_ (__NR_inotify_add_watch, sys_inotify_add_watch), // 276
1019 LINX_ (__NR_inotify_rm_watch, sys_inotify_rm_watch), // 277
1020 //..
1021 PLAX_ (__NR_set_thread_area, sys_set_thread_area), // 283
1022 //..
1023 LINXY (__NR_openat, sys_openat), // 288
1024 LINX_ (__NR_mkdirat, sys_mkdirat), // 289
1025 LINX_ (__NR_mknodat, sys_mknodat), // 290
1026 LINX_ (__NR_fchownat, sys_fchownat), // 291
1027 LINX_ (__NR_futimesat, sys_futimesat), // 292
1028 PLAXY (__NR_fstatat64, sys_fstatat64), // 293
1029 LINX_ (__NR_unlinkat, sys_unlinkat), // 294
1030 LINX_ (__NR_renameat, sys_renameat), // 295
1031 LINX_ (__NR_linkat, sys_linkat), // 296
1032 LINX_ (__NR_symlinkat, sys_symlinkat), // 297
1033 LINX_ (__NR_readlinkat, sys_readlinkat), // 298
1034 LINX_ (__NR_fchmodat, sys_fchmodat), // 299
1035 LINX_ (__NR_faccessat, sys_faccessat), // 300
1036 LINXY (__NR_pselect6, sys_pselect6), // 301
1037 LINXY (__NR_ppoll, sys_ppoll), // 302
1038 //..
1039 LINX_ (__NR_set_robust_list, sys_set_robust_list), // 309
1040 LINXY (__NR_get_robust_list, sys_get_robust_list), // 310
1041 //..
1042 LINXY (__NR_epoll_pwait, sys_epoll_pwait), // 313
1043 //..
1044 LINX_ (__NR_utimensat, sys_utimensat), // 316
1045 //..
1046 LINX_ (__NR_fallocate, sys_fallocate), // 320
1047 LINXY (__NR_timerfd_create, sys_timerfd_create), // 321
1048 LINXY (__NR_timerfd_gettime, sys_timerfd_gettime), // 322
1049 LINXY (__NR_timerfd_settime, sys_timerfd_settime), // 323
1050 LINXY (__NR_signalfd4, sys_signalfd4), // 324
1051 LINXY (__NR_eventfd2, sys_eventfd2), // 325
1052 //..
1053 LINXY (__NR_pipe2, sys_pipe2), // 328
1054 LINXY (__NR_inotify_init1, sys_inotify_init1), // 329
1055 //..
1056 LINXY (__NR_prlimit64, sys_prlimit64), // 338
1057 //..
1058 LINXY (__NR_clock_adjtime, sys_clock_adjtime), // 341
1059 LINX_ (__NR_syncfs, sys_syncfs), // 342
1060 //..
1061 LINXY (__NR_process_vm_readv, sys_process_vm_readv), // 345
1062 LINX_ (__NR_process_vm_writev, sys_process_vm_writev), // 346
1063 //..
1064 LINXY(__NR_getrandom, sys_getrandom), // 353
1065 LINXY(__NR_memfd_create, sys_memfd_create), // 354
1066 //..
1067 LINX_(__NR_membarrier, sys_membarrier), // 358
1068 //..
1069 LINXY(__NR_statx, sys_statx) // 366
1070 };
1071
1072 SyscallTableEntry* ML_(get_linux_syscall_entry) (UInt sysno)
1073 {
1074 const UInt syscall_main_table_size
1075 = sizeof (syscall_main_table) / sizeof (syscall_main_table[0]);
1076 /* Is it in the contiguous initial section of the table? */
1077 if (sysno < syscall_main_table_size) {
1078 SyscallTableEntry * sys = &syscall_main_table[sysno];
1079 if (sys->before == NULL)
1080 return NULL; /* No entry. */
1081 else
1082 return sys;
1083 }
1084 /* Can't find a wrapper. */
1085 return NULL;
1086 }
1087
1088 #endif // defined(VGP_mips32_linux)
1089
1090 /*--------------------------------------------------------------------*/
1091 /*--- end syswrap-mips-linux.c ---*/
1092 /*--------------------------------------------------------------------*/
Instrumentation framework for detecting many memory management and threading bugs, and profile your programs in detail.