• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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