1
2 /*--------------------------------------------------------------------*/
3 /*--- Platform-specific syscalls stuff. syswrap-s390x-linux.c ---*/
4 /*--------------------------------------------------------------------*/
5
6 /*
7 This file is part of Valgrind, a dynamic binary instrumentation
8 framework.
9
10 Copyright IBM Corp. 2010-2015
11
12 This program is free software; you can redistribute it and/or
13 modify it under the terms of the GNU General Public License as
14 published by the Free Software Foundation; either version 2 of the
15 License, or (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful, but
18 WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
25 02111-1307, USA.
26
27 The GNU General Public License is contained in the file COPYING.
28 */
29
30 /* Contributed by Christian Borntraeger */
31
32 #if defined(VGP_s390x_linux)
33
34 #include "pub_core_basics.h"
35 #include "pub_core_vki.h"
36 #include "pub_core_vkiscnums.h"
37 #include "pub_core_threadstate.h"
38 #include "pub_core_aspacemgr.h"
39 #include "pub_core_debuglog.h"
40 #include "pub_core_libcbase.h"
41 #include "pub_core_libcassert.h"
42 #include "pub_core_libcprint.h"
43 #include "pub_core_libcproc.h"
44 #include "pub_core_libcsignal.h"
45 #include "pub_core_mallocfree.h"
46 #include "pub_core_options.h"
47 #include "pub_core_scheduler.h"
48 #include "pub_core_sigframe.h" // For VG_(sigframe_destroy)()
49 #include "pub_core_signals.h"
50 #include "pub_core_syscall.h"
51 #include "pub_core_syswrap.h"
52 #include "pub_core_tooliface.h"
53
54 #include "priv_types_n_macros.h"
55 #include "priv_syswrap-generic.h" /* for decls of generic wrappers */
56 #include "priv_syswrap-linux.h" /* for decls of linux-ish wrappers */
57 #include "priv_syswrap-linux-variants.h" /* decls of linux variant wrappers */
58 #include "priv_syswrap-main.h"
59
60
61 /* ---------------------------------------------------------------------
62 clone() handling
63 ------------------------------------------------------------------ */
64
65 /* Call f(arg1), but first switch stacks, using 'stack' as the new
66 stack, and use 'retaddr' as f's return-to address. Also, clear all
67 the integer registers before entering f.
68 Thought: Why are we clearing the GPRs ? The callee pointed to by f
69 is a regular C function which will play by the ABI rules. So there is
70 no need to zero out the GPRs. If we assumed that f accesses registers at
71 will, then it would make sense to create a defined register state.
72 But then, why only for the GPRs and not the FPRs ? */
73 __attribute__((noreturn))
74 void ML_(call_on_new_stack_0_1) ( Addr stack,
75 Addr retaddr,
76 void (*f)(Word),
77 Word arg1 );
78 /* Upon entering this function we have the following setup:
79 r2 = stack
80 r3 = retaddr
81 r4 = f_desc
82 r5 = arg1
83 */
84 asm(
85 ".text\n"
86 ".align 4\n"
87 ".globl vgModuleLocal_call_on_new_stack_0_1\n"
88 ".type vgModuleLocal_call_on_new_stack_0_1, @function\n"
89 "vgModuleLocal_call_on_new_stack_0_1:\n"
90 " lgr %r15,%r2\n" // stack to r15
91 " lgr %r14,%r3\n" // retaddr to r14
92 " lgr %r2,%r5\n" // arg1 to r2
93 // zero all gprs to get a defined state
94 " lghi %r0,0\n"
95 " lghi %r1,0\n"
96 // r2 holds the argument for the callee
97 " lghi %r3,0\n"
98 // r4 holds the callee address
99 " lghi %r5,0\n"
100 " lghi %r6,0\n"
101 " lghi %r7,0\n"
102 " lghi %r8,0\n"
103 " lghi %r9,0\n"
104 " lghi %r10,0\n"
105 " lghi %r11,0\n"
106 " lghi %r12,0\n"
107 " lghi %r13,0\n"
108 // r14 holds the return address for the callee
109 // r15 is the stack pointer
110 " br %r4\n" // jump to f
111 ".previous\n"
112 );
113
114 /*
115 Perform a clone system call. clone is strange because it has
116 fork()-like return-twice semantics, so it needs special
117 handling here.
118
119 Upon entry, we have:
120 void* child_stack in r2
121 long flags in r3
122 int* parent_tid in r4
123 int* child_tid in r5
124 int* tls address in r6
125 Word (*fn)(void *) 160(r15)
126 void *arg 168(r15)
127
128 System call requires:
129 void* child_stack in r2 (sc arg1)
130 long flags in r3 (sc arg2)
131 int* parent_tid in r4 (sc arg3)
132 int* child_tid in r5 (sc arg4)
133 void* tlsaddr in r6 (sc arg5)
134
135 Returns a ULong encoded as: top half is %cr following syscall,
136 low half is syscall return value (r3).
137 */
138 #define __NR_CLONE VG_STRINGIFY(__NR_clone)
139 #define __NR_EXIT VG_STRINGIFY(__NR_exit)
140
141 extern
142 ULong do_syscall_clone_s390x_linux ( void *stack,
143 ULong flags,
144 Int *parent_tid,
145 Int *child_tid,
146 Addr tlsaddr,
147 Word (*fn)(void *),
148 void *arg);
149 asm(
150 " .text\n"
151 " .align 4\n"
152 ".globl do_syscall_clone_s390x_linux\n"
153 "do_syscall_clone_s390x_linux:\n"
154 " lg %r1, 160(%r15)\n" // save fn from parent stack into r1
155 " lg %r0, 168(%r15)\n" // save arg from parent stack into r0
156 " aghi %r2, -160\n" // create stack frame for child
157 // all syscall parameters are already in place (r2-r6)
158 " svc " __NR_CLONE"\n" // clone()
159 " ltgr %r2,%r2\n" // child if retval == 0
160 " jne 1f\n"
161
162 // CHILD - call thread function
163 " lgr %r2, %r0\n" // get arg from r0
164 " basr %r14,%r1\n" // call fn
165
166 // exit. The result is already in r2
167 " svc " __NR_EXIT"\n"
168
169 // Exit returned?!
170 " j +2\n"
171
172 "1:\n" // PARENT or ERROR
173 " br %r14\n"
174 ".previous\n"
175 );
176
177 #undef __NR_CLONE
178 #undef __NR_EXIT
179
VG_(cleanup_thread)180 void VG_(cleanup_thread) ( ThreadArchState* arch )
181 {
182 /* only used on x86 for descriptor tables */
183 }
184
setup_child(ThreadArchState * child,ThreadArchState * parent)185 static void setup_child ( /*OUT*/ ThreadArchState *child,
186 /*IN*/ ThreadArchState *parent )
187 {
188 /* We inherit our parent's guest state. */
189 child->vex = parent->vex;
190 child->vex_shadow1 = parent->vex_shadow1;
191 child->vex_shadow2 = parent->vex_shadow2;
192 }
193
194
195 /*
196 When a client clones, we need to keep track of the new thread. This means:
197 1. allocate a ThreadId+ThreadState+stack for the thread
198
199 2. initialize the thread's new VCPU state
200
201 3. create the thread using the same args as the client requested,
202 but using the scheduler entrypoint for IP, and a separate stack
203 for SP.
204 */
do_clone(ThreadId ptid,Addr sp,ULong flags,Int * parent_tidptr,Int * child_tidptr,Addr tlsaddr)205 static SysRes do_clone ( ThreadId ptid,
206 Addr sp, ULong flags,
207 Int *parent_tidptr,
208 Int *child_tidptr,
209 Addr tlsaddr)
210 {
211 static const Bool debug = False;
212
213 ThreadId ctid = VG_(alloc_ThreadState)();
214 ThreadState* ptst = VG_(get_ThreadState)(ptid);
215 ThreadState* ctst = VG_(get_ThreadState)(ctid);
216 UWord* stack;
217 SysRes res;
218 ULong r2;
219 vki_sigset_t blockall, savedmask;
220
221 VG_(sigfillset)(&blockall);
222
223 vg_assert(VG_(is_running_thread)(ptid));
224 vg_assert(VG_(is_valid_tid)(ctid));
225
226 stack = (UWord*)ML_(allocstack)(ctid);
227 if (stack == NULL) {
228 res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
229 goto out;
230 }
231
232 /* Copy register state
233
234 Both parent and child return to the same place, and the code
235 following the clone syscall works out which is which, so we
236 don't need to worry about it.
237
238 The parent gets the child's new tid returned from clone, but the
239 child gets 0.
240
241 If the clone call specifies a NULL sp for the new thread, then
242 it actually gets a copy of the parent's sp.
243 */
244 setup_child( &ctst->arch, &ptst->arch );
245
246 /* Make sys_clone appear to have returned Success(0) in the
247 child. */
248 ctst->arch.vex.guest_r2 = 0;
249
250 if (sp != 0)
251 ctst->arch.vex.guest_SP = sp;
252
253 ctst->os_state.parent = ptid;
254
255 /* inherit signal mask */
256 ctst->sig_mask = ptst->sig_mask;
257 ctst->tmp_sig_mask = ptst->sig_mask;
258
259 /* have the parents thread group */
260 ctst->os_state.threadgroup = ptst->os_state.threadgroup;
261
262 ML_(guess_and_register_stack) (sp, ctst);
263
264 /* Assume the clone will succeed, and tell any tool that wants to
265 know that this thread has come into existence. If the clone
266 fails, we'll send out a ll_exit notification for it at the out:
267 label below, to clean up. */
268 vg_assert(VG_(owns_BigLock_LL)(ptid));
269 VG_TRACK ( pre_thread_ll_create, ptid, ctid );
270
271 if (flags & VKI_CLONE_SETTLS) {
272 if (debug)
273 VG_(printf)("clone child has SETTLS: tls at %#lx\n", tlsaddr);
274 ctst->arch.vex.guest_a0 = (UInt) (tlsaddr >> 32);
275 ctst->arch.vex.guest_a1 = (UInt) tlsaddr;
276 }
277 flags &= ~VKI_CLONE_SETTLS;
278
279 /* start the thread with everything blocked */
280 VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
281
282 /* Create the new thread */
283 r2 = do_syscall_clone_s390x_linux(
284 stack, flags, parent_tidptr, child_tidptr, tlsaddr,
285 ML_(start_thread_NORETURN), &VG_(threads)[ctid]);
286
287 res = VG_(mk_SysRes_s390x_linux)( r2 );
288
289 VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
290
291 out:
292 if (sr_isError(res)) {
293 /* clone failed */
294 ctst->status = VgTs_Empty;
295 /* oops. Better tell the tool the thread exited in a hurry :-) */
296 VG_TRACK( pre_thread_ll_exit, ctid );
297 }
298
299 return res;
300
301 }
302
303
304
305 /* ---------------------------------------------------------------------
306 PRE/POST wrappers for s390x/Linux-specific syscalls
307 ------------------------------------------------------------------ */
308
309 #define PRE(name) DEFN_PRE_TEMPLATE(s390x_linux, name)
310 #define POST(name) DEFN_POST_TEMPLATE(s390x_linux, name)
311
312 /* Add prototypes for the wrappers declared here, so that gcc doesn't
313 harass us for not having prototypes. Really this is a kludge --
314 the right thing to do is to make these wrappers 'static' since they
315 aren't visible outside this file, but that requires even more macro
316 magic. */
317
318 DECL_TEMPLATE(s390x_linux, sys_ptrace);
319 DECL_TEMPLATE(s390x_linux, sys_mmap);
320 DECL_TEMPLATE(s390x_linux, sys_clone);
321 DECL_TEMPLATE(s390x_linux, sys_sigreturn);
322 DECL_TEMPLATE(s390x_linux, sys_rt_sigreturn);
323 DECL_TEMPLATE(s390x_linux, sys_fadvise64);
324
325 /* PEEK TEXT,DATA and USER are common to all architectures.
326 PEEKUSR_AREA and POKEUSR_AREA are special, having a memory area
327 containing the real addr, data, and len field pointed to by ARG3
328 instead of ARG4.
329 GETREGSET and SETREGSET use a struct iovec (pointed to by ARG4) for
330 the address and size of the user buffer. */
331
PRE(sys_ptrace)332 PRE(sys_ptrace)
333 {
334 PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", SARG1, SARG2, ARG3, ARG4);
335 PRE_REG_READ4(int, "ptrace",
336 long, request, long, pid, unsigned long, addr,
337 unsigned long, data);
338 switch (ARG1) {
339 case VKI_PTRACE_PEEKTEXT:
340 case VKI_PTRACE_PEEKDATA:
341 case VKI_PTRACE_PEEKUSR:
342 PRE_MEM_WRITE( "ptrace(peek)", ARG4,
343 sizeof (long));
344 break;
345 case VKI_PTRACE_GETEVENTMSG:
346 PRE_MEM_WRITE( "ptrace(geteventmsg)", ARG4, sizeof(unsigned long));
347 break;
348 case VKI_PTRACE_GETSIGINFO:
349 PRE_MEM_WRITE( "ptrace(getsiginfo)", ARG4, sizeof(vki_siginfo_t));
350 break;
351 case VKI_PTRACE_SETSIGINFO:
352 PRE_MEM_READ( "ptrace(setsiginfo)", ARG4, sizeof(vki_siginfo_t));
353 break;
354 case VKI_PTRACE_PEEKUSR_AREA:
355 {
356 vki_ptrace_area *pa;
357
358 /* Reads a part of the user area into memory at pa->process_addr */
359 pa = (vki_ptrace_area *) ARG3;
360 PRE_MEM_READ("ptrace(peekusrarea ptrace_area->len)",
361 (unsigned long) &pa->vki_len, sizeof(pa->vki_len));
362 PRE_MEM_READ("ptrace(peekusrarea ptrace_area->kernel_addr)",
363 (unsigned long) &pa->vki_kernel_addr, sizeof(pa->vki_kernel_addr));
364 PRE_MEM_READ("ptrace(peekusrarea ptrace_area->process_addr)",
365 (unsigned long) &pa->vki_process_addr, sizeof(pa->vki_process_addr));
366 PRE_MEM_WRITE("ptrace(peekusrarea *(ptrace_area->process_addr))",
367 pa->vki_process_addr, pa->vki_len);
368 break;
369 }
370 case VKI_PTRACE_POKEUSR_AREA:
371 {
372 vki_ptrace_area *pa;
373
374 /* Updates a part of the user area from memory at pa->process_addr */
375 pa = (vki_ptrace_area *) ARG3;
376 PRE_MEM_READ("ptrace(pokeusrarea ptrace_area->len)",
377 (unsigned long) &pa->vki_len, sizeof(pa->vki_len));
378 PRE_MEM_READ("ptrace(pokeusrarea ptrace_area->kernel_addr)",
379 (unsigned long) &pa->vki_kernel_addr,
380 sizeof(pa->vki_kernel_addr));
381 PRE_MEM_READ("ptrace(pokeusrarea ptrace_area->process_addr)",
382 (unsigned long) &pa->vki_process_addr,
383 sizeof(pa->vki_process_addr));
384 PRE_MEM_READ("ptrace(pokeusrarea *(ptrace_area->process_addr))",
385 pa->vki_process_addr, pa->vki_len);
386 break;
387 }
388 case VKI_PTRACE_GETREGSET:
389 ML_(linux_PRE_getregset)(tid, ARG3, ARG4);
390 break;
391 case VKI_PTRACE_SETREGSET:
392 ML_(linux_PRE_setregset)(tid, ARG3, ARG4);
393 break;
394 default:
395 break;
396 }
397 }
398
POST(sys_ptrace)399 POST(sys_ptrace)
400 {
401 switch (ARG1) {
402 case VKI_PTRACE_PEEKTEXT:
403 case VKI_PTRACE_PEEKDATA:
404 case VKI_PTRACE_PEEKUSR:
405 POST_MEM_WRITE( ARG4, sizeof (long));
406 break;
407 case VKI_PTRACE_GETEVENTMSG:
408 POST_MEM_WRITE( ARG4, sizeof(unsigned long));
409 break;
410 case VKI_PTRACE_GETSIGINFO:
411 /* XXX: This is a simplification. Different parts of the
412 * siginfo_t are valid depending on the type of signal.
413 */
414 POST_MEM_WRITE( ARG4, sizeof(vki_siginfo_t));
415 break;
416 case VKI_PTRACE_PEEKUSR_AREA:
417 {
418 vki_ptrace_area *pa;
419
420 pa = (vki_ptrace_area *) ARG3;
421 POST_MEM_WRITE(pa->vki_process_addr, pa->vki_len);
422 break;
423 }
424 case VKI_PTRACE_GETREGSET:
425 ML_(linux_POST_getregset)(tid, ARG3, ARG4);
426 break;
427 default:
428 break;
429 }
430 }
431
PRE(sys_mmap)432 PRE(sys_mmap)
433 {
434 UWord a0, a1, a2, a3, a4, a5;
435 SysRes r;
436
437 UWord* args = (UWord*)ARG1;
438 PRE_REG_READ1(long, "sys_mmap", struct mmap_arg_struct *, args);
439 PRE_MEM_READ( "sys_mmap(args)", (Addr) args, 6*sizeof(UWord) );
440
441 a0 = args[0];
442 a1 = args[1];
443 a2 = args[2];
444 a3 = args[3];
445 a4 = args[4];
446 a5 = args[5];
447
448 PRINT("sys_mmap ( %#lx, %lu, %ld, %ld, %ld, %ld )",
449 a0, a1, (Word)a2, (Word)a3, (Word)a4, (Word)a5 );
450
451 r = ML_(generic_PRE_sys_mmap)( tid, a0, a1, a2, a3, a4, (Off64T)a5 );
452 SET_STATUS_from_SysRes(r);
453 }
454
PRE(sys_clone)455 PRE(sys_clone)
456 {
457 UInt cloneflags;
458
459 PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4, ARG5);
460 PRE_REG_READ2(int, "clone",
461 void *, child_stack,
462 unsigned long, flags);
463
464 if (ARG2 & VKI_CLONE_PARENT_SETTID) {
465 if (VG_(tdict).track_pre_reg_read)
466 PRA3("clone(parent_tidptr)", int *, parent_tidptr);
467 PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
468 if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int),
469 VKI_PROT_WRITE)) {
470 SET_STATUS_Failure( VKI_EFAULT );
471 return;
472 }
473 }
474 if (ARG2 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
475 if (VG_(tdict).track_pre_reg_read)
476 PRA4("clone(child_tidptr)", int *, child_tidptr);
477 PRE_MEM_WRITE("clone(child_tidptr)", ARG4, sizeof(Int));
478 if (!VG_(am_is_valid_for_client)(ARG4, sizeof(Int),
479 VKI_PROT_WRITE)) {
480 SET_STATUS_Failure( VKI_EFAULT );
481 return;
482 }
483 }
484
485 /* The kernel simply copies reg6 (ARG5) into AR0 and AR1, no checks */
486 if (ARG2 & VKI_CLONE_SETTLS) {
487 if (VG_(tdict).track_pre_reg_read) {
488 PRA5("clone", Addr, tlsinfo);
489 }
490 }
491
492 cloneflags = ARG2;
493
494 if (!ML_(client_signal_OK)(ARG2 & VKI_CSIGNAL)) {
495 SET_STATUS_Failure( VKI_EINVAL );
496 return;
497 }
498
499 /* Only look at the flags we really care about */
500 switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
501 | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
502 case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
503 /* thread creation */
504 SET_STATUS_from_SysRes(
505 do_clone(tid,
506 (Addr)ARG1, /* child SP */
507 ARG2, /* flags */
508 (Int *)ARG3, /* parent_tidptr */
509 (Int *)ARG4, /* child_tidptr */
510 (Addr)ARG5)); /* tlsaddr */
511 break;
512
513 case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
514 /* FALLTHROUGH - assume vfork == fork */
515 cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
516
517 case 0: /* plain fork */
518 SET_STATUS_from_SysRes(
519 ML_(do_fork_clone)(tid,
520 cloneflags, /* flags */
521 (Int *)ARG3, /* parent_tidptr */
522 (Int *)ARG4)); /* child_tidptr */
523 break;
524
525 default:
526 /* should we just ENOSYS? */
527 VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG2);
528 VG_(message)(Vg_UserMsg, "\n");
529 VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
530 VG_(message)(Vg_UserMsg, " - via a threads library (NPTL)\n");
531 VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork\n");
532 VG_(unimplemented)
533 ("Valgrind does not support general clone().");
534 }
535
536 if (SUCCESS) {
537 if (ARG2 & VKI_CLONE_PARENT_SETTID)
538 POST_MEM_WRITE(ARG3, sizeof(Int));
539 if (ARG2 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
540 POST_MEM_WRITE(ARG4, sizeof(Int));
541
542 /* Thread creation was successful; let the child have the chance
543 to run */
544 *flags |= SfYieldAfter;
545 }
546 }
547
PRE(sys_sigreturn)548 PRE(sys_sigreturn)
549 {
550 ThreadState* tst;
551 PRINT("sys_sigreturn ( )");
552
553 vg_assert(VG_(is_valid_tid)(tid));
554 vg_assert(tid >= 1 && tid < VG_N_THREADS);
555 vg_assert(VG_(is_running_thread)(tid));
556
557 tst = VG_(get_ThreadState)(tid);
558
559 /* This is only so that the IA is (might be) useful to report if
560 something goes wrong in the sigreturn */
561 ML_(fixup_guest_state_to_restart_syscall)(&tst->arch);
562
563 /* Restore register state from frame and remove it */
564 VG_(sigframe_destroy)(tid, False);
565
566 /* Tell the driver not to update the guest state with the "result",
567 and set a bogus result to keep it happy. */
568 *flags |= SfNoWriteResult;
569 SET_STATUS_Success(0);
570
571 /* Check to see if any signals arose as a result of this. */
572 *flags |= SfPollAfter;
573 }
574
575
PRE(sys_rt_sigreturn)576 PRE(sys_rt_sigreturn)
577 {
578 /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
579 an explanation of what follows. */
580
581 ThreadState* tst;
582 PRINT("sys_rt_sigreturn ( )");
583
584 vg_assert(VG_(is_valid_tid)(tid));
585 vg_assert(tid >= 1 && tid < VG_N_THREADS);
586 vg_assert(VG_(is_running_thread)(tid));
587
588 tst = VG_(get_ThreadState)(tid);
589
590 /* This is only so that the IA is (might be) useful to report if
591 something goes wrong in the sigreturn */
592 ML_(fixup_guest_state_to_restart_syscall)(&tst->arch);
593
594 /* Restore register state from frame and remove it */
595 VG_(sigframe_destroy)(tid, True);
596
597 /* Tell the driver not to update the guest state with the "result",
598 and set a bogus result to keep it happy. */
599 *flags |= SfNoWriteResult;
600 SET_STATUS_Success(0);
601
602 /* Check to see if any signals arose as a result of this. */
603 *flags |= SfPollAfter;
604 }
605
606 /* we cant use the LINX_ version for 64 bit */
PRE(sys_fadvise64)607 PRE(sys_fadvise64)
608 {
609 PRINT("sys_fadvise64 ( %ld, %ld, %ld, %ld )", SARG1, SARG2, SARG3, SARG4);
610 PRE_REG_READ4(long, "fadvise64",
611 int, fd, vki_loff_t, offset, vki_loff_t, len, int, advice);
612 }
613
614 #undef PRE
615 #undef POST
616
617 /* ---------------------------------------------------------------------
618 The s390x/Linux syscall table
619 ------------------------------------------------------------------ */
620
621 /* Add an s390x-linux specific wrapper to a syscall table. */
622 #define PLAX_(sysno, name) WRAPPER_ENTRY_X_(s390x_linux, sysno, name)
623 #define PLAXY(sysno, name) WRAPPER_ENTRY_XY(s390x_linux, sysno, name)
624
625 // This table maps from __NR_xxx syscall numbers from
626 // linux/arch/s390/kernel/syscalls.S to the appropriate PRE/POST sys_foo()
627 // wrappers on s390x. There are several unused numbers, which are only
628 // defined on s390 (31bit mode) but no longer available on s390x (64 bit).
629 // For those syscalls not handled by Valgrind, the annotation indicate its
630 // arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/?
631 // (unknown).
632
633 static SyscallTableEntry syscall_table[] = {
634 GENX_(0, sys_ni_syscall), /* unimplemented (by the kernel) */ // 0
635 GENX_(__NR_exit, sys_exit), // 1
636 GENX_(__NR_fork, sys_fork), // 2
637 GENXY(__NR_read, sys_read), // 3
638 GENX_(__NR_write, sys_write), // 4
639
640 GENXY(__NR_open, sys_open), // 5
641 GENXY(__NR_close, sys_close), // 6
642 // ?????(__NR_restart_syscall, ), // 7
643 GENXY(__NR_creat, sys_creat), // 8
644 GENX_(__NR_link, sys_link), // 9
645
646 GENX_(__NR_unlink, sys_unlink), // 10
647 GENX_(__NR_execve, sys_execve), // 11
648 GENX_(__NR_chdir, sys_chdir), // 12
649 GENX_(13, sys_ni_syscall), /* unimplemented (by the kernel) */ // 13
650 GENX_(__NR_mknod, sys_mknod), // 14
651
652 GENX_(__NR_chmod, sys_chmod), // 15
653 GENX_(16, sys_ni_syscall), /* unimplemented (by the kernel) */ // 16
654 GENX_(17, sys_ni_syscall), /* unimplemented (by the kernel) */ // 17
655 GENX_(18, sys_ni_syscall), /* unimplemented (by the kernel) */ // 18
656 LINX_(__NR_lseek, sys_lseek), // 19
657
658 GENX_(__NR_getpid, sys_getpid), // 20
659 LINX_(__NR_mount, sys_mount), // 21
660 LINX_(__NR_umount, sys_oldumount), // 22
661 GENX_(23, sys_ni_syscall), /* unimplemented (by the kernel) */ // 23
662 GENX_(24, sys_ni_syscall), /* unimplemented (by the kernel) */ // 24
663
664 GENX_(25, sys_ni_syscall), /* unimplemented (by the kernel) */ // 25
665 PLAXY(__NR_ptrace, sys_ptrace), // 26
666 GENX_(__NR_alarm, sys_alarm), // 27
667 GENX_(28, sys_ni_syscall), /* unimplemented (by the kernel) */ // 28
668 GENX_(__NR_pause, sys_pause), // 29
669
670 LINX_(__NR_utime, sys_utime), // 30
671 GENX_(31, sys_ni_syscall), /* unimplemented (by the kernel) */ // 31
672 GENX_(32, sys_ni_syscall), /* unimplemented (by the kernel) */ // 32
673 GENX_(__NR_access, sys_access), // 33
674 GENX_(__NR_nice, sys_nice), // 34
675
676 GENX_(35, sys_ni_syscall), /* unimplemented (by the kernel) */ // 35
677 GENX_(__NR_sync, sys_sync), // 36
678 GENX_(__NR_kill, sys_kill), // 37
679 GENX_(__NR_rename, sys_rename), // 38
680 GENX_(__NR_mkdir, sys_mkdir), // 39
681
682 GENX_(__NR_rmdir, sys_rmdir), // 40
683 GENXY(__NR_dup, sys_dup), // 41
684 LINXY(__NR_pipe, sys_pipe), // 42
685 GENXY(__NR_times, sys_times), // 43
686 GENX_(44, sys_ni_syscall), /* unimplemented (by the kernel) */ // 44
687
688 GENX_(__NR_brk, sys_brk), // 45
689 GENX_(46, sys_ni_syscall), /* unimplemented (by the kernel) */ // 46
690 GENX_(47, sys_ni_syscall), /* unimplemented (by the kernel) */ // 47
691 // ?????(__NR_signal, ), // 48
692 GENX_(49, sys_ni_syscall), /* unimplemented (by the kernel) */ // 49
693
694 GENX_(50, sys_ni_syscall), /* unimplemented (by the kernel) */ // 50
695 GENX_(__NR_acct, sys_acct), // 51
696 LINX_(__NR_umount2, sys_umount), // 52
697 GENX_(53, sys_ni_syscall), /* unimplemented (by the kernel) */ // 53
698 LINXY(__NR_ioctl, sys_ioctl), // 54
699
700 LINXY(__NR_fcntl, sys_fcntl), // 55
701 GENX_(56, sys_ni_syscall), /* unimplemented (by the kernel) */ // 56
702 GENX_(__NR_setpgid, sys_setpgid), // 57
703 GENX_(58, sys_ni_syscall), /* unimplemented (by the kernel) */ // 58
704 GENX_(59, sys_ni_syscall), /* unimplemented (by the kernel) */ // 59
705
706 GENX_(__NR_umask, sys_umask), // 60
707 GENX_(__NR_chroot, sys_chroot), // 61
708 // ?????(__NR_ustat, sys_ustat), /* deprecated in favor of statfs */ // 62
709 GENXY(__NR_dup2, sys_dup2), // 63
710 GENX_(__NR_getppid, sys_getppid), // 64
711
712 GENX_(__NR_getpgrp, sys_getpgrp), // 65
713 GENX_(__NR_setsid, sys_setsid), // 66
714 // ?????(__NR_sigaction, ), /* userspace uses rt_sigaction */ // 67
715 GENX_(68, sys_ni_syscall), /* unimplemented (by the kernel) */ // 68
716 GENX_(69, sys_ni_syscall), /* unimplemented (by the kernel) */ // 69
717
718 GENX_(70, sys_ni_syscall), /* unimplemented (by the kernel) */ // 70
719 GENX_(71, sys_ni_syscall), /* unimplemented (by the kernel) */ // 71
720 // ?????(__NR_sigsuspend, ), // 72
721 // ?????(__NR_sigpending, ), // 73
722 // ?????(__NR_sethostname, ), // 74
723
724 GENX_(__NR_setrlimit, sys_setrlimit), // 75
725 GENXY(76, sys_getrlimit), /* see also 191 */ // 76
726 GENXY(__NR_getrusage, sys_getrusage), // 77
727 GENXY(__NR_gettimeofday, sys_gettimeofday), // 78
728 GENX_(__NR_settimeofday, sys_settimeofday), // 79
729
730 GENX_(80, sys_ni_syscall), /* unimplemented (by the kernel) */ // 80
731 GENX_(81, sys_ni_syscall), /* unimplemented (by the kernel) */ // 81
732 GENX_(82, sys_ni_syscall), /* unimplemented (by the kernel) */ // 82
733 GENX_(__NR_symlink, sys_symlink), // 83
734 GENX_(84, sys_ni_syscall), /* unimplemented (by the kernel) */ // 84
735
736 GENX_(__NR_readlink, sys_readlink), // 85
737 // ?????(__NR_uselib, ), // 86
738 // ?????(__NR_swapon, ), // 87
739 // ?????(__NR_reboot, ), // 88
740 GENX_(89, sys_ni_syscall), /* unimplemented (by the kernel) */ // 89
741
742 PLAX_(__NR_mmap, sys_mmap ), // 90
743 GENXY(__NR_munmap, sys_munmap), // 91
744 GENX_(__NR_truncate, sys_truncate), // 92
745 GENX_(__NR_ftruncate, sys_ftruncate), // 93
746 GENX_(__NR_fchmod, sys_fchmod), // 94
747
748 GENX_(95, sys_ni_syscall), /* unimplemented (by the kernel) */ // 95
749 GENX_(__NR_getpriority, sys_getpriority), // 96
750 GENX_(__NR_setpriority, sys_setpriority), // 97
751 GENX_(98, sys_ni_syscall), /* unimplemented (by the kernel) */ // 98
752 GENXY(__NR_statfs, sys_statfs), // 99
753
754 GENXY(__NR_fstatfs, sys_fstatfs), // 100
755 GENX_(101, sys_ni_syscall), /* unimplemented (by the kernel) */ // 101
756 LINXY(__NR_socketcall, sys_socketcall), // 102
757 LINXY(__NR_syslog, sys_syslog), // 103
758 GENXY(__NR_setitimer, sys_setitimer), // 104
759
760 GENXY(__NR_getitimer, sys_getitimer), // 105
761 GENXY(__NR_stat, sys_newstat), // 106
762 GENXY(__NR_lstat, sys_newlstat), // 107
763 GENXY(__NR_fstat, sys_newfstat), // 108
764 GENX_(109, sys_ni_syscall), /* unimplemented (by the kernel) */ // 109
765
766 LINXY(__NR_lookup_dcookie, sys_lookup_dcookie), // 110
767 LINX_(__NR_vhangup, sys_vhangup), // 111
768 GENX_(112, sys_ni_syscall), /* unimplemented (by the kernel) */ // 112
769 GENX_(113, sys_ni_syscall), /* unimplemented (by the kernel) */ // 113
770 GENXY(__NR_wait4, sys_wait4), // 114
771
772 // ?????(__NR_swapoff, ), // 115
773 LINXY(__NR_sysinfo, sys_sysinfo), // 116
774 LINXY(__NR_ipc, sys_ipc), // 117
775 GENX_(__NR_fsync, sys_fsync), // 118
776 PLAX_(__NR_sigreturn, sys_sigreturn), // 119
777
778 PLAX_(__NR_clone, sys_clone), // 120
779 // ?????(__NR_setdomainname, ), // 121
780 GENXY(__NR_uname, sys_newuname), // 122
781 GENX_(123, sys_ni_syscall), /* unimplemented (by the kernel) */ // 123
782 // ?????(__NR_adjtimex, ), // 124
783
784 GENXY(__NR_mprotect, sys_mprotect), // 125
785 // LINXY(__NR_sigprocmask, sys_sigprocmask), // 126
786 GENX_(127, sys_ni_syscall), /* unimplemented (by the kernel) */ // 127
787 LINX_(__NR_init_module, sys_init_module), // 128
788 LINX_(__NR_delete_module, sys_delete_module), // 129
789
790 GENX_(130, sys_ni_syscall), /* unimplemented (by the kernel) */ // 130
791 LINX_(__NR_quotactl, sys_quotactl), // 131
792 GENX_(__NR_getpgid, sys_getpgid), // 132
793 GENX_(__NR_fchdir, sys_fchdir), // 133
794 // ?????(__NR_bdflush, ), // 134
795
796 // ?????(__NR_sysfs, ), // 135
797 LINX_(__NR_personality, sys_personality), // 136
798 GENX_(137, sys_ni_syscall), /* unimplemented (by the kernel) */ // 137
799 GENX_(138, sys_ni_syscall), /* unimplemented (by the kernel) */ // 138
800 GENX_(139, sys_ni_syscall), /* unimplemented (by the kernel) */ // 139
801
802 // LINXY(__NR__llseek, sys_llseek), /* 64 bit --> lseek */ // 140
803 GENXY(__NR_getdents, sys_getdents), // 141
804 GENX_(__NR_select, sys_select), // 142
805 GENX_(__NR_flock, sys_flock), // 143
806 GENX_(__NR_msync, sys_msync), // 144
807
808 GENXY(__NR_readv, sys_readv), // 145
809 GENX_(__NR_writev, sys_writev), // 146
810 GENX_(__NR_getsid, sys_getsid), // 147
811 GENX_(__NR_fdatasync, sys_fdatasync), // 148
812 LINXY(__NR__sysctl, sys_sysctl), // 149
813
814 GENX_(__NR_mlock, sys_mlock), // 150
815 GENX_(__NR_munlock, sys_munlock), // 151
816 GENX_(__NR_mlockall, sys_mlockall), // 152
817 LINX_(__NR_munlockall, sys_munlockall), // 153
818 LINXY(__NR_sched_setparam, sys_sched_setparam), // 154
819
820 LINXY(__NR_sched_getparam, sys_sched_getparam), // 155
821 LINX_(__NR_sched_setscheduler, sys_sched_setscheduler), // 156
822 LINX_(__NR_sched_getscheduler, sys_sched_getscheduler), // 157
823 LINX_(__NR_sched_yield, sys_sched_yield), // 158
824 LINX_(__NR_sched_get_priority_max, sys_sched_get_priority_max), // 159
825
826 LINX_(__NR_sched_get_priority_min, sys_sched_get_priority_min), // 160
827 LINXY(__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 162
828 GENXY(__NR_nanosleep, sys_nanosleep), // 162
829 GENX_(__NR_mremap, sys_mremap), // 163
830 GENX_(164, sys_ni_syscall), /* unimplemented (by the kernel) */ // 164
831
832 GENX_(165, sys_ni_syscall), /* unimplemented (by the kernel) */ // 165
833 GENX_(166, sys_ni_syscall), /* unimplemented (by the kernel) */ // 166
834 GENX_(167, sys_ni_syscall), /* unimplemented (by the kernel) */ // 167
835 GENXY(__NR_poll, sys_poll), // 168
836 // ?????(__NR_nfsservctl, ), // 169
837
838 GENX_(170, sys_ni_syscall), /* unimplemented (by the kernel) */ // 170
839 GENX_(171, sys_ni_syscall), /* unimplemented (by the kernel) */ // 171
840 LINXY(__NR_prctl, sys_prctl), // 172
841 PLAX_(__NR_rt_sigreturn, sys_rt_sigreturn), // 173
842 LINXY(__NR_rt_sigaction, sys_rt_sigaction), // 174
843
844 LINXY(__NR_rt_sigprocmask, sys_rt_sigprocmask), // 175
845 LINXY(__NR_rt_sigpending, sys_rt_sigpending), // 176
846 LINXY(__NR_rt_sigtimedwait, sys_rt_sigtimedwait), // 177
847 LINXY(__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo), // 178
848 LINX_(__NR_rt_sigsuspend, sys_rt_sigsuspend), // 179
849
850 GENXY(__NR_pread64, sys_pread64), // 180
851 GENX_(__NR_pwrite64, sys_pwrite64), // 181
852 GENX_(182, sys_ni_syscall), /* unimplemented (by the kernel) */ // 182
853 GENXY(__NR_getcwd, sys_getcwd), // 183
854 LINXY(__NR_capget, sys_capget), // 184
855
856 LINX_(__NR_capset, sys_capset), // 185
857 GENXY(__NR_sigaltstack, sys_sigaltstack), // 186
858 LINXY(__NR_sendfile, sys_sendfile), // 187
859 GENX_(188, sys_ni_syscall), /* unimplemented (by the kernel) */ // 188
860 GENX_(189, sys_ni_syscall), /* unimplemented (by the kernel) */ // 189
861
862 GENX_(__NR_vfork, sys_fork), // 190
863 GENXY(__NR_getrlimit, sys_getrlimit), // 191
864 GENX_(192, sys_ni_syscall), /* not exported on 64bit*/ // 192
865 GENX_(193, sys_ni_syscall), /* unimplemented (by the kernel) */ // 193
866 GENX_(194, sys_ni_syscall), /* unimplemented (by the kernel) */ // 194
867
868 GENX_(195, sys_ni_syscall), /* unimplemented (by the kernel) */ // 195
869 GENX_(196, sys_ni_syscall), /* unimplemented (by the kernel) */ // 196
870 GENX_(197, sys_ni_syscall), /* unimplemented (by the kernel) */ // 197
871 GENX_(__NR_lchown, sys_lchown), // 198
872 GENX_(__NR_getuid, sys_getuid), // 199
873
874 GENX_(__NR_getgid, sys_getgid), // 200
875 GENX_(__NR_geteuid, sys_geteuid), // 201
876 GENX_(__NR_getegid, sys_getegid), // 202
877 GENX_(__NR_setreuid, sys_setreuid), // 203
878 GENX_(__NR_setregid, sys_setregid), // 204
879
880 GENXY(__NR_getgroups, sys_getgroups), // 205
881 GENX_(__NR_setgroups, sys_setgroups), // 206
882 GENX_(__NR_fchown, sys_fchown), // 207
883 LINX_(__NR_setresuid, sys_setresuid), // 208
884 LINXY(__NR_getresuid, sys_getresuid), // 209
885
886 LINX_(__NR_setresgid, sys_setresgid), // 210
887 LINXY(__NR_getresgid, sys_getresgid), // 211
888 GENX_(__NR_chown, sys_chown), // 212
889 GENX_(__NR_setuid, sys_setuid), // 213
890 GENX_(__NR_setgid, sys_setgid), // 214
891
892 LINX_(__NR_setfsuid, sys_setfsuid), // 215
893 LINX_(__NR_setfsgid, sys_setfsgid), // 216
894 LINX_(__NR_pivot_root, sys_pivot_root), // 217
895 GENXY(__NR_mincore, sys_mincore), // 218
896 GENX_(__NR_madvise, sys_madvise), // 219
897
898 GENXY(__NR_getdents64, sys_getdents64), // 220
899 GENX_(221, sys_ni_syscall), /* unimplemented (by the kernel) */ // 221
900 LINX_(__NR_readahead, sys_readahead), // 222
901 GENX_(223, sys_ni_syscall), /* unimplemented (by the kernel) */ // 223
902 LINX_(__NR_setxattr, sys_setxattr), // 224
903
904 LINX_(__NR_lsetxattr, sys_lsetxattr), // 225
905 LINX_(__NR_fsetxattr, sys_fsetxattr), // 226
906 LINXY(__NR_getxattr, sys_getxattr), // 227
907 LINXY(__NR_lgetxattr, sys_lgetxattr), // 228
908 LINXY(__NR_fgetxattr, sys_fgetxattr), // 229
909
910 LINXY(__NR_listxattr, sys_listxattr), // 230
911 LINXY(__NR_llistxattr, sys_llistxattr), // 231
912 LINXY(__NR_flistxattr, sys_flistxattr), // 232
913 LINX_(__NR_removexattr, sys_removexattr), // 233
914 LINX_(__NR_lremovexattr, sys_lremovexattr), // 234
915
916 LINX_(__NR_fremovexattr, sys_fremovexattr), // 235
917 LINX_(__NR_gettid, sys_gettid), // 236
918 LINXY(__NR_tkill, sys_tkill), // 237
919 LINXY(__NR_futex, sys_futex), // 238
920 LINX_(__NR_sched_setaffinity, sys_sched_setaffinity), // 239
921
922 LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 240
923 LINXY(__NR_tgkill, sys_tgkill), // 241
924 GENX_(242, sys_ni_syscall), /* unimplemented (by the kernel) */ // 242
925 LINXY(__NR_io_setup, sys_io_setup), // 243
926 LINX_(__NR_io_destroy, sys_io_destroy), // 244
927
928 LINXY(__NR_io_getevents, sys_io_getevents), // 245
929 LINX_(__NR_io_submit, sys_io_submit), // 246
930 LINXY(__NR_io_cancel, sys_io_cancel), // 247
931 LINX_(__NR_exit_group, sys_exit_group), // 248
932 LINXY(__NR_epoll_create, sys_epoll_create), // 249
933
934 LINX_(__NR_epoll_ctl, sys_epoll_ctl), // 250
935 LINXY(__NR_epoll_wait, sys_epoll_wait), // 251
936 LINX_(__NR_set_tid_address, sys_set_tid_address), // 252
937 PLAX_(__NR_fadvise64, sys_fadvise64), // 253
938 LINXY(__NR_timer_create, sys_timer_create), // 254
939
940 LINXY(__NR_timer_settime, sys_timer_settime), // 255
941 LINXY(__NR_timer_gettime, sys_timer_gettime), // 256
942 LINX_(__NR_timer_getoverrun, sys_timer_getoverrun), // 257
943 LINX_(__NR_timer_delete, sys_timer_delete), // 258
944 LINX_(__NR_clock_settime, sys_clock_settime), // 259
945
946 LINXY(__NR_clock_gettime, sys_clock_gettime), // 260
947 LINXY(__NR_clock_getres, sys_clock_getres), // 261
948 LINXY(__NR_clock_nanosleep, sys_clock_nanosleep), // 262
949 GENX_(263, sys_ni_syscall), /* unimplemented (by the kernel) */ // 263
950 GENX_(264, sys_ni_syscall), /* unimplemented (by the kernel) */ // 264
951
952 GENXY(__NR_statfs64, sys_statfs64), // 265
953 GENXY(__NR_fstatfs64, sys_fstatfs64), // 266
954 // ?????(__NR_remap_file_pages, ),
955 GENX_(268, sys_ni_syscall), /* unimplemented (by the kernel) */ // 268
956 GENX_(269, sys_ni_syscall), /* unimplemented (by the kernel) */ // 269
957
958 GENX_(270, sys_ni_syscall), /* unimplemented (by the kernel) */ // 270
959 LINXY(__NR_mq_open, sys_mq_open), // 271
960 LINX_(__NR_mq_unlink, sys_mq_unlink), // 272
961 LINX_(__NR_mq_timedsend, sys_mq_timedsend), // 273
962 LINXY(__NR_mq_timedreceive, sys_mq_timedreceive), // 274
963
964 LINX_(__NR_mq_notify, sys_mq_notify), // 275
965 LINXY(__NR_mq_getsetattr, sys_mq_getsetattr), // 276
966 // ?????(__NR_kexec_load, ),
967 LINX_(__NR_add_key, sys_add_key), // 278
968 LINX_(__NR_request_key, sys_request_key), // 279
969
970 LINXY(__NR_keyctl, sys_keyctl), // 280
971 LINXY(__NR_waitid, sys_waitid), // 281
972 LINX_(__NR_ioprio_set, sys_ioprio_set), // 282
973 LINX_(__NR_ioprio_get, sys_ioprio_get), // 283
974 LINX_(__NR_inotify_init, sys_inotify_init), // 284
975
976 LINX_(__NR_inotify_add_watch, sys_inotify_add_watch), // 285
977 LINX_(__NR_inotify_rm_watch, sys_inotify_rm_watch), // 286
978 GENX_(287, sys_ni_syscall), /* unimplemented (by the kernel) */ // 287
979 LINXY(__NR_openat, sys_openat), // 288
980 LINX_(__NR_mkdirat, sys_mkdirat), // 289
981
982 LINX_(__NR_mknodat, sys_mknodat), // 290
983 LINX_(__NR_fchownat, sys_fchownat), // 291
984 LINX_(__NR_futimesat, sys_futimesat), // 292
985 LINXY(__NR_newfstatat, sys_newfstatat), // 293
986 LINX_(__NR_unlinkat, sys_unlinkat), // 294
987
988 LINX_(__NR_renameat, sys_renameat), // 295
989 LINX_(__NR_linkat, sys_linkat), // 296
990 LINX_(__NR_symlinkat, sys_symlinkat), // 297
991 LINX_(__NR_readlinkat, sys_readlinkat), // 298
992 LINX_(__NR_fchmodat, sys_fchmodat), // 299
993
994 LINX_(__NR_faccessat, sys_faccessat), // 300
995 LINX_(__NR_pselect6, sys_pselect6), // 301
996 LINXY(__NR_ppoll, sys_ppoll), // 302
997 LINX_(__NR_unshare, sys_unshare), // 303
998 LINX_(__NR_set_robust_list, sys_set_robust_list), // 304
999
1000 LINXY(__NR_get_robust_list, sys_get_robust_list), // 305
1001 LINX_(__NR_splice, sys_splice), // 306
1002 LINX_(__NR_sync_file_range, sys_sync_file_range), // 307
1003 LINX_(__NR_tee, sys_tee), // 308
1004 LINXY(__NR_vmsplice, sys_vmsplice), // 309
1005
1006 GENX_(310, sys_ni_syscall), /* unimplemented (by the kernel) */ // 310
1007 LINXY(__NR_getcpu, sys_getcpu), // 311
1008 LINXY(__NR_epoll_pwait, sys_epoll_pwait), // 312
1009 GENX_(__NR_utimes, sys_utimes), // 313
1010 LINX_(__NR_fallocate, sys_fallocate), // 314
1011
1012 LINX_(__NR_utimensat, sys_utimensat), // 315
1013 LINXY(__NR_signalfd, sys_signalfd), // 316
1014 GENX_(317, sys_ni_syscall), /* unimplemented (by the kernel) */ // 317
1015 LINXY(__NR_eventfd, sys_eventfd), // 318
1016 LINXY(__NR_timerfd_create, sys_timerfd_create), // 319
1017
1018 LINXY(__NR_timerfd_settime, sys_timerfd_settime), // 320
1019 LINXY(__NR_timerfd_gettime, sys_timerfd_gettime), // 321
1020 LINXY(__NR_signalfd4, sys_signalfd4), // 322
1021 LINXY(__NR_eventfd2, sys_eventfd2), // 323
1022 LINXY(__NR_inotify_init1, sys_inotify_init1), // 324
1023
1024 LINXY(__NR_pipe2, sys_pipe2), // 325
1025 LINXY(__NR_dup3, sys_dup3), // 326
1026 LINXY(__NR_epoll_create1, sys_epoll_create1), // 327
1027 LINXY(__NR_preadv, sys_preadv), // 328
1028 LINX_(__NR_pwritev, sys_pwritev), // 329
1029
1030 LINXY(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo), // 330
1031 LINXY(__NR_perf_event_open, sys_perf_event_open), // 331
1032 LINXY(__NR_fanotify_init, sys_fanotify_init), // 332
1033 LINX_(__NR_fanotify_mark, sys_fanotify_mark), // 333
1034 LINXY(__NR_prlimit64, sys_prlimit64), // 334
1035
1036 LINXY(__NR_name_to_handle_at, sys_name_to_handle_at), // 335
1037 LINXY(__NR_open_by_handle_at, sys_open_by_handle_at), // 336
1038 LINXY(__NR_clock_adjtime, sys_clock_adjtime), // 337
1039 LINX_(__NR_syncfs, sys_syncfs), // 338
1040 // ?????(__NR_setns, ), // 339
1041
1042 LINXY(__NR_process_vm_readv, sys_process_vm_readv), // 340
1043 LINX_(__NR_process_vm_writev, sys_process_vm_writev), // 341
1044 // ?????(__NR_s390_runtime_instr, ), // 342
1045 LINX_(__NR_kcmp, sys_kcmp), // 343
1046 // ?????(__NR_finit_module, ), // 344
1047
1048 // ?????(__NR_sched_setattr, ), // 345
1049 // ?????(__NR_sched_getattr, ), // 346
1050 // ?????(__NR_renameat2, ), // 347
1051 // ?????(__NR_seccomp, ), // 348
1052 LINXY(__NR_getrandom, sys_getrandom), // 349
1053
1054 LINXY(__NR_memfd_create, sys_memfd_create) // 350
1055 };
1056
ML_(get_linux_syscall_entry)1057 SyscallTableEntry* ML_(get_linux_syscall_entry) ( UInt sysno )
1058 {
1059 const UInt syscall_table_size
1060 = sizeof(syscall_table) / sizeof(syscall_table[0]);
1061
1062 /* Is it in the contiguous initial section of the table? */
1063 if (sysno < syscall_table_size) {
1064 SyscallTableEntry* sys = &syscall_table[sysno];
1065 if (sys->before == NULL)
1066 return NULL; /* no entry */
1067 else
1068 return sys;
1069 }
1070
1071 /* Can't find a wrapper */
1072 return NULL;
1073 }
1074
1075 #endif
1076
1077 /*--------------------------------------------------------------------*/
1078 /*--- end ---*/
1079 /*--------------------------------------------------------------------*/
1080