• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 
2 /*--------------------------------------------------------------------*/
3 /*--- Platform-specific syscalls stuff.      syswrap-ppc64-linux.c ---*/
4 /*--------------------------------------------------------------------*/
5 
6 /*
7    This file is part of Valgrind, a dynamic binary instrumentation
8    framework.
9 
10    Copyright (C) 2005-2015 Nicholas Nethercote <njn@valgrind.org>
11    Copyright (C) 2005-2015 Cerion Armour-Brown <cerion@open-works.co.uk>
12 
13    This program is free software; you can redistribute it and/or
14    modify it under the terms of the GNU General Public License as
15    published by the Free Software Foundation; either version 2 of the
16    License, or (at your option) any later version.
17 
18    This program is distributed in the hope that it will be useful, but
19    WITHOUT ANY WARRANTY; without even the implied warranty of
20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21    General Public License for more details.
22 
23    You should have received a copy of the GNU General Public License
24    along with this program; if not, write to the Free Software
25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26    02111-1307, USA.
27 
28    The GNU General Public License is contained in the file COPYING.
29 */
30 
31 #if defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux)
32 
33 #include "pub_core_basics.h"
34 #include "pub_core_vki.h"
35 #include "pub_core_vkiscnums.h"
36 #include "pub_core_threadstate.h"
37 #include "pub_core_aspacemgr.h"
38 #include "pub_core_debuglog.h"
39 #include "pub_core_libcbase.h"
40 #include "pub_core_libcassert.h"
41 #include "pub_core_libcprint.h"
42 #include "pub_core_libcproc.h"
43 #include "pub_core_libcsignal.h"
44 #include "pub_core_options.h"
45 #include "pub_core_scheduler.h"
46 #include "pub_core_sigframe.h"      // For VG_(sigframe_destroy)()
47 #include "pub_core_signals.h"
48 #include "pub_core_syscall.h"
49 #include "pub_core_syswrap.h"
50 #include "pub_core_tooliface.h"
51 
52 #include "priv_types_n_macros.h"
53 #include "priv_syswrap-generic.h"   /* for decls of generic wrappers */
54 #include "priv_syswrap-linux.h"     /* for decls of linux-ish wrappers */
55 #include "priv_syswrap-main.h"
56 
57 
58 /* ---------------------------------------------------------------------
59    clone() handling
60    ------------------------------------------------------------------ */
61 
62 /* Call f(arg1), but first switch stacks, using 'stack' as the new
63    stack, and use 'retaddr' as f's return-to address.  Also, clear all
64    the integer registers before entering f.*/
65 __attribute__((noreturn))
66 void ML_(call_on_new_stack_0_1) ( Addr stack,
67                                   Addr retaddr,
68                                   void (*f_desc)(Word),
69                                   Word arg1 );
70 //    r3 = stack
71 //    r4 = retaddr
72 //    r5 = function descriptor
73 //    r6 = arg1
74 /* On PPC64, a func ptr is represented by a TOC entry ptr.
75    This TOC entry contains three words; the first word is the function
76    address, the second word is the TOC ptr (r2), and the third word is
77    the static chain value. */
78 asm(
79 #if defined(VGP_ppc64be_linux)
80 "   .align   2\n"
81 "   .globl   vgModuleLocal_call_on_new_stack_0_1\n"
82 "   .section \".opd\",\"aw\"\n"
83 "   .align   3\n"
84 "vgModuleLocal_call_on_new_stack_0_1:\n"
85 "   .quad    .vgModuleLocal_call_on_new_stack_0_1,.TOC.@tocbase,0\n"
86 "   .previous\n"
87 "   .type    .vgModuleLocal_call_on_new_stack_0_1,@function\n"
88 "   .globl   .vgModuleLocal_call_on_new_stack_0_1\n"
89 ".vgModuleLocal_call_on_new_stack_0_1:\n"
90 "   mr    %r1,%r3\n\t"     // stack to %sp
91 "   mtlr  %r4\n\t"         // retaddr to %lr
92 "   ld 5,0(5)\n\t"         // load f_ptr from f_desc[0]
93 "   mtctr %r5\n\t"         // f_ptr to count reg
94 "   mr %r3,%r6\n\t"        // arg1 to %r3
95 "   li 0,0\n\t"            // zero all GP regs
96 "   li 4,0\n\t"
97 "   li 5,0\n\t"
98 "   li 6,0\n\t"
99 "   li 7,0\n\t"
100 "   li 8,0\n\t"
101 "   li 9,0\n\t"
102 "   li 10,0\n\t"
103 "   li 11,0\n\t"
104 "   li 12,0\n\t"
105 "   li 13,0\n\t"
106 "   li 14,0\n\t"
107 "   li 15,0\n\t"
108 "   li 16,0\n\t"
109 "   li 17,0\n\t"
110 "   li 18,0\n\t"
111 "   li 19,0\n\t"
112 "   li 20,0\n\t"
113 "   li 21,0\n\t"
114 "   li 22,0\n\t"
115 "   li 23,0\n\t"
116 "   li 24,0\n\t"
117 "   li 25,0\n\t"
118 "   li 26,0\n\t"
119 "   li 27,0\n\t"
120 "   li 28,0\n\t"
121 "   li 29,0\n\t"
122 "   li 30,0\n\t"
123 "   li 31,0\n\t"
124 "   mtxer 0\n\t"           // CAB: Need this?
125 "   mtcr 0\n\t"            // CAB: Need this?
126 "   bctr\n\t"              // jump to dst
127 "   trap\n"                // should never get here
128 #else
129 //  ppc64le_linux
130 "   .align   2\n"
131 "   .globl   vgModuleLocal_call_on_new_stack_0_1\n"
132 "vgModuleLocal_call_on_new_stack_0_1:\n"
133 "   .type    .vgModuleLocal_call_on_new_stack_0_1,@function\n"
134 "#if _CALL_ELF == 2 \n"
135 "0: addis        2,12,.TOC.-0b@ha\n"
136 "   addi         2,2,.TOC.-0b@l\n"
137 "#endif\n"
138 ".localentry vgModuleLocal_call_on_new_stack_0_1, .-vgModuleLocal_call_on_new_stack_0_1\n"
139 "   mr    %r1,%r3\n\t"     // stack to %sp
140 "   mtlr  %r4\n\t"         // retaddr to %lr
141 "   mtctr %r5\n\t"         // f_ptr to count reg
142 "   mr %r3,%r6\n\t"        // arg1 to %r3
143 "   li 0,0\n\t"            // zero all GP regs
144 "   li 4,0\n\t"
145 "   li 5,0\n\t"
146 "   li 6,0\n\t"
147 "   li 7,0\n\t"
148 "   li 8,0\n\t"
149 "   li 9,0\n\t"
150 "   li 10,0\n\t"
151 "   li 11,0\n\t"
152 "   li 12,0\n\t"
153 "   li 13,0\n\t"
154 "   li 14,0\n\t"
155 "   li 15,0\n\t"
156 "   li 16,0\n\t"
157 "   li 17,0\n\t"
158 "   li 18,0\n\t"
159 "   li 19,0\n\t"
160 "   li 20,0\n\t"
161 "   li 21,0\n\t"
162 "   li 22,0\n\t"
163 "   li 23,0\n\t"
164 "   li 24,0\n\t"
165 "   li 25,0\n\t"
166 "   li 26,0\n\t"
167 "   li 27,0\n\t"
168 "   li 28,0\n\t"
169 "   li 29,0\n\t"
170 "   li 30,0\n\t"
171 "   li 31,0\n\t"
172 "   mtxer 0\n\t"           // CAB: Need this?
173 "   mtcr 0\n\t"            // CAB: Need this?
174 "   bctr\n\t"              // jump to dst
175 "   trap\n"                // should never get here
176 #endif
177 );
178 
179 
180 /*
181         Perform a clone system call.  clone is strange because it has
182         fork()-like return-twice semantics, so it needs special
183         handling here.
184 
185         Upon entry, we have:
186 
187             word (fn)(void*)    in r3
188             void* child_stack   in r4
189             word flags          in r5
190             void* arg           in r6
191             pid_t* child_tid    in r7
192             pid_t* parent_tid   in r8
193             void* ???           in r9
194 
195         Note: r3 contains fn desc ptr, not fn ptr -- p_fn = p_fn_desc[0]
196         System call requires:
197 
198             int    $__NR_clone  in r0  (sc number)
199             int    flags        in r3  (sc arg1)
200             void*  child_stack  in r4  (sc arg2)
201             pid_t* parent_tid   in r5  (sc arg3)
202             ??     child_tls    in r6  (sc arg4)
203             pid_t* child_tid    in r7  (sc arg5)
204             void*  ???          in r8  (sc arg6)
205 
206         Returns a ULong encoded as: top half is %cr following syscall,
207         low half is syscall return value (r3).
208  */
209 #define __NR_CLONE        VG_STRINGIFY(__NR_clone)
210 #define __NR_EXIT         VG_STRINGIFY(__NR_exit)
211 
212 extern
213 ULong do_syscall_clone_ppc64_linux ( Word (*fn)(void *),
214                                      void* stack,
215                                      Int   flags,
216                                      void* arg,
217                                      Int*  child_tid,
218                                      Int*  parent_tid,
219                                      void/*vki_modify_ldt_t*/ * );
220 asm(
221 #if defined(VGP_ppc64be_linux)
222 "   .align   2\n"
223 "   .globl   do_syscall_clone_ppc64_linux\n"
224 "   .section \".opd\",\"aw\"\n"
225 "   .align   3\n"
226 "do_syscall_clone_ppc64_linux:\n"
227 "   .quad    .do_syscall_clone_ppc64_linux,.TOC.@tocbase,0\n"
228 "   .previous\n"
229 "   .type    .do_syscall_clone_ppc64_linux,@function\n"
230 "   .globl   .do_syscall_clone_ppc64_linux\n"
231 ".do_syscall_clone_ppc64_linux:\n"
232 "       stdu    1,-64(1)\n"
233 "       std     29,40(1)\n"
234 "       std     30,48(1)\n"
235 "       std     31,56(1)\n"
236 "       mr      30,3\n"              // preserve fn
237 "       mr      31,6\n"              // preserve arg
238 
239         // setup child stack
240 "       rldicr  4,4, 0,59\n"         // trim sp to multiple of 16 bytes
241                                      // (r4 &= ~0xF)
242 "       li      0,0\n"
243 "       stdu    0,-32(4)\n"          // make initial stack frame
244 "       mr      29,4\n"              // preserve sp
245 
246         // setup syscall
247 "       li      0,"__NR_CLONE"\n"    // syscall number
248 "       mr      3,5\n"               // syscall arg1: flags
249         // r4 already setup          // syscall arg2: child_stack
250 "       mr      5,8\n"               // syscall arg3: parent_tid
251 "       mr      6,13\n"              // syscall arg4: REAL THREAD tls
252 "       mr      7,7\n"               // syscall arg5: child_tid
253 "       mr      8,8\n"               // syscall arg6: ????
254 "       mr      9,9\n"               // syscall arg7: ????
255 
256 "       sc\n"                        // clone()
257 
258 "       mfcr    4\n"                 // CR now in low half r4
259 "       sldi    4,4,32\n"            // CR now in hi half r4
260 
261 "       sldi    3,3,32\n"
262 "       srdi    3,3,32\n"            // zero out hi half r3
263 
264 "       or      3,3,4\n"             // r3 = CR : syscall-retval
265 "       cmpwi   3,0\n"               // child if retval == 0 (note, cmpw)
266 "       bne     1f\n"                // jump if !child
267 
268         /* CHILD - call thread function */
269         /* Note: 2.4 kernel doesn't set the child stack pointer,
270            so we do it here.
271            That does leave a small window for a signal to be delivered
272            on the wrong stack, unfortunately. */
273 "       mr      1,29\n"
274 "       ld      30, 0(30)\n"         // convert fn desc ptr to fn ptr
275 "       mtctr   30\n"                // ctr reg = fn
276 "       mr      3,31\n"              // r3 = arg
277 "       bctrl\n"                     // call fn()
278 
279         // exit with result
280 "       li      0,"__NR_EXIT"\n"
281 "       sc\n"
282 
283         // Exit returned?!
284 "       .long   0\n"
285 
286         // PARENT or ERROR - return
287 "1:     ld      29,40(1)\n"
288 "       ld      30,48(1)\n"
289 "       ld      31,56(1)\n"
290 "       addi    1,1,64\n"
291 "       blr\n"
292 #else
293 "   .align   2\n"
294 "   .globl   do_syscall_clone_ppc64_linux\n"
295 "   .type    do_syscall_clone_ppc64_linux,@function\n"
296 "do_syscall_clone_ppc64_linux:\n"
297 "   .globl   .do_syscall_clone_ppc64_linux\n"
298 ".do_syscall_clone_ppc64_linux:\n"
299 "#if _CALL_ELF == 2 \n"
300 "0:     addis        2,12,.TOC.-0b@ha \n"
301 "       addi         2,2,.TOC.-0b@l \n"
302 "#endif \n"
303 "   .localentry  do_syscall_clone_ppc64_linux, .-do_syscall_clone_ppc64_linux \n"
304 "       stdu    1,-64(1)\n"
305 "       std     29,40(1)\n"
306 "       std     30,48(1)\n"
307 "       std     31,56(1)\n"
308 "       mr      30,3\n"              // preserve fn
309 "       mr      31,6\n"              // preserve arg
310 
311         // setup child stack
312 "       rldicr  4,4, 0,59\n"         // trim sp to multiple of 16 bytes
313                                      // (r4 &= ~0xF)
314 "       li      0,0\n"
315 "       stdu    0,-32(4)\n"          // make initial stack frame
316 "       mr      29,4\n"              // preserve sp
317 
318         // setup syscall
319 "       li      0,"__NR_CLONE"\n"    // syscall number
320 "       mr      3,5\n"               // syscall arg1: flags
321         // r4 already setup          // syscall arg2: child_stack
322 "       mr      5,8\n"               // syscall arg3: parent_tid
323 "       mr      6,13\n"              // syscall arg4: REAL THREAD tls
324 "       mr      7,7\n"               // syscall arg5: child_tid
325 "       mr      8,8\n"               // syscall arg6: ????
326 "       mr      9,9\n"               // syscall arg7: ????
327 
328 "       sc\n"                        // clone()
329 
330 "       mfcr    4\n"                 // CR now in low half r4
331 "       sldi    4,4,32\n"            // CR now in hi half r4
332 
333 "       sldi    3,3,32\n"
334 "       srdi    3,3,32\n"            // zero out hi half r3
335 
336 "       or      3,3,4\n"             // r3 = CR : syscall-retval
337 "       cmpwi   3,0\n"               // child if retval == 0 (note, cmpw)
338 "       bne     1f\n"                // jump if !child
339 
340         /* CHILD - call thread function */
341         /* Note: 2.4 kernel doesn't set the child stack pointer,
342            so we do it here.
343            That does leave a small window for a signal to be delivered
344            on the wrong stack, unfortunately. */
345 "       mr      1,29\n"
346 "       mtctr   30\n"                // ctr reg = fn
347 "       mr      3,31\n"              // r3 = arg
348 "       bctrl\n"                     // call fn()
349 
350         // exit with result
351 "       li      0,"__NR_EXIT"\n"
352 "       sc\n"
353 
354         // Exit returned?!
355 "       .long   0\n"
356 
357         // PARENT or ERROR - return
358 "1:     ld      29,40(1)\n"
359 "       ld      30,48(1)\n"
360 "       ld      31,56(1)\n"
361 "       addi    1,1,64\n"
362 "       blr\n"
363 #endif
364 );
365 
366 #undef __NR_CLONE
367 #undef __NR_EXIT
368 
369 // forward declarations
370 static void setup_child ( ThreadArchState*, ThreadArchState* );
371 
372 /*
373    When a client clones, we need to keep track of the new thread.  This means:
374    1. allocate a ThreadId+ThreadState+stack for the thread
375 
376    2. initialize the thread's new VCPU state
377 
378    3. create the thread using the same args as the client requested,
379    but using the scheduler entrypoint for IP, and a separate stack
380    for SP.
381  */
do_clone(ThreadId ptid,UInt flags,Addr sp,Int * parent_tidptr,Int * child_tidptr,Addr child_tls)382 static SysRes do_clone ( ThreadId ptid,
383                          UInt flags, Addr sp,
384                          Int *parent_tidptr,
385                          Int *child_tidptr,
386                          Addr child_tls)
387 {
388    const Bool debug = False;
389 
390    ThreadId     ctid = VG_(alloc_ThreadState)();
391    ThreadState* ptst = VG_(get_ThreadState)(ptid);
392    ThreadState* ctst = VG_(get_ThreadState)(ctid);
393    ULong        word64;
394    UWord*       stack;
395    SysRes       res;
396    vki_sigset_t blockall, savedmask;
397 
398    VG_(sigfillset)(&blockall);
399 
400    vg_assert(VG_(is_running_thread)(ptid));
401    vg_assert(VG_(is_valid_tid)(ctid));
402 
403    stack = (UWord*)ML_(allocstack)(ctid);
404    if (stack == NULL) {
405       res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
406       goto out;
407    }
408 
409 //?   /* make a stack frame */
410 //?   stack -= 16;
411 //?   *(UWord *)stack = 0;
412 
413 
414    /* Copy register state
415 
416       Both parent and child return to the same place, and the code
417       following the clone syscall works out which is which, so we
418       don't need to worry about it.
419 
420       The parent gets the child's new tid returned from clone, but the
421       child gets 0.
422 
423       If the clone call specifies a NULL SP for the new thread, then
424       it actually gets a copy of the parent's SP.
425 
426       The child's TLS register (r2) gets set to the tlsaddr argument
427       if the CLONE_SETTLS flag is set.
428    */
429    setup_child( &ctst->arch, &ptst->arch );
430 
431    /* Make sys_clone appear to have returned Success(0) in the
432       child. */
433    { UInt old_cr = LibVEX_GuestPPC64_get_CR( &ctst->arch.vex );
434      /* %r3 = 0 */
435      ctst->arch.vex.guest_GPR3 = 0;
436      /* %cr0.so = 0 */
437      LibVEX_GuestPPC64_put_CR( old_cr & ~(1<<28), &ctst->arch.vex );
438    }
439 
440    if (sp != 0)
441       ctst->arch.vex.guest_GPR1 = sp;
442 
443    ctst->os_state.parent = ptid;
444 
445    /* inherit signal mask */
446    ctst->sig_mask = ptst->sig_mask;
447    ctst->tmp_sig_mask = ptst->sig_mask;
448 
449    /* Start the child with its threadgroup being the same as the
450       parent's.  This is so that any exit_group calls that happen
451       after the child is created but before it sets its
452       os_state.threadgroup field for real (in thread_wrapper in
453       syswrap-linux.c), really kill the new thread.  a.k.a this avoids
454       a race condition in which the thread is unkillable (via
455       exit_group) because its threadgroup is not set.  The race window
456       is probably only a few hundred or a few thousand cycles long.
457       See #226116. */
458    ctst->os_state.threadgroup = ptst->os_state.threadgroup;
459 
460    ML_(guess_and_register_stack) (sp, ctst);
461 
462    /* Assume the clone will succeed, and tell any tool that wants to
463       know that this thread has come into existence.  If the clone
464       fails, we'll send out a ll_exit notification for it at the out:
465       label below, to clean up. */
466    vg_assert(VG_(owns_BigLock_LL)(ptid));
467    VG_TRACK ( pre_thread_ll_create, ptid, ctid );
468 
469    if (flags & VKI_CLONE_SETTLS) {
470       if (debug)
471          VG_(printf)("clone child has SETTLS: tls at %#lx\n", child_tls);
472       ctst->arch.vex.guest_GPR13 = child_tls;
473    }
474 
475    flags &= ~VKI_CLONE_SETTLS;
476 
477    /* start the thread with everything blocked */
478    VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
479 
480    /* Create the new thread */
481    word64 = do_syscall_clone_ppc64_linux(
482                ML_(start_thread_NORETURN),
483                stack, flags, &VG_(threads)[ctid],
484                child_tidptr, parent_tidptr, NULL
485             );
486 
487    /* Low half word64 is syscall return value.  Hi half is
488       the entire CR, from which we need to extract CR0.SO. */
489    /* VG_(printf)("word64 = 0x%llx\n", word64); */
490    res = VG_(mk_SysRes_ppc64_linux)(
491             /*val*/(UInt)(word64 & 0xFFFFFFFFULL),
492             /*errflag*/ (UInt)((word64 >> (32+28)) & 1)
493          );
494 
495    VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
496 
497   out:
498    if (sr_isError(res)) {
499       /* clone failed */
500       VG_(cleanup_thread)(&ctst->arch);
501       ctst->status = VgTs_Empty;
502       /* oops.  Better tell the tool the thread exited in a hurry :-) */
503       VG_TRACK( pre_thread_ll_exit, ctid );
504    }
505 
506    return res;
507 }
508 
509 
510 
511 /* ---------------------------------------------------------------------
512    More thread stuff
513    ------------------------------------------------------------------ */
514 
VG_(cleanup_thread)515 void VG_(cleanup_thread) ( ThreadArchState* arch )
516 {
517 }
518 
setup_child(ThreadArchState * child,ThreadArchState * parent)519 void setup_child ( /*OUT*/ ThreadArchState *child,
520                    /*IN*/  ThreadArchState *parent )
521 {
522    /* We inherit our parent's guest state. */
523    child->vex = parent->vex;
524    child->vex_shadow1 = parent->vex_shadow1;
525    child->vex_shadow2 = parent->vex_shadow2;
526 }
527 
528 
529 /* ---------------------------------------------------------------------
530    PRE/POST wrappers for ppc64/Linux-specific syscalls
531    ------------------------------------------------------------------ */
532 
533 #define PRE(name)       DEFN_PRE_TEMPLATE(ppc64_linux, name)
534 #define POST(name)      DEFN_POST_TEMPLATE(ppc64_linux, name)
535 
536 /* Add prototypes for the wrappers declared here, so that gcc doesn't
537    harass us for not having prototypes.  Really this is a kludge --
538    the right thing to do is to make these wrappers 'static' since they
539    aren't visible outside this file, but that requires even more macro
540    magic. */
541 
542 DECL_TEMPLATE(ppc64_linux, sys_mmap);
543 //zz DECL_TEMPLATE(ppc64_linux, sys_mmap2);
544 //zz DECL_TEMPLATE(ppc64_linux, sys_stat64);
545 //zz DECL_TEMPLATE(ppc64_linux, sys_lstat64);
546 //zz DECL_TEMPLATE(ppc64_linux, sys_fstat64);
547 DECL_TEMPLATE(ppc64_linux, sys_clone);
548 //zz DECL_TEMPLATE(ppc64_linux, sys_sigreturn);
549 DECL_TEMPLATE(ppc64_linux, sys_rt_sigreturn);
550 DECL_TEMPLATE(ppc64_linux, sys_fadvise64);
551 
PRE(sys_mmap)552 PRE(sys_mmap)
553 {
554    SysRes r;
555 
556    PRINT("sys_mmap ( %#lx, %lu, %lu, %lu, %lu, %lu )",
557          ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
558    PRE_REG_READ6(long, "mmap",
559                  unsigned long, start, unsigned long, length,
560                  unsigned long, prot,  unsigned long, flags,
561                  unsigned long, fd,    unsigned long, offset);
562 
563    r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5,
564                                        (Off64T)ARG6 );
565    SET_STATUS_from_SysRes(r);
566 }
567 
568 //zz PRE(sys_mmap2)
569 //zz {
570 //zz    SysRes r;
571 //zz
572 //zz    // Exactly like old_mmap() except:
573 //zz    //  - the file offset is specified in 4K units rather than bytes,
574 //zz    //    so that it can be used for files bigger than 2^32 bytes.
575 //zz    PRINT("sys_mmap2 ( %p, %llu, %d, %d, %d, %d )",
576 //zz          ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 );
577 //zz    PRE_REG_READ6(long, "mmap2",
578 //zz                  unsigned long, start, unsigned long, length,
579 //zz                  unsigned long, prot,  unsigned long, flags,
580 //zz                  unsigned long, fd,    unsigned long, offset);
581 //zz
582 //zz    r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5,
583 //zz                                        4096 * (Off64T)ARG6 );
584 //zz    SET_STATUS_from_SysRes(r);
585 //zz }
586 //zz
587 //zz // XXX: lstat64/fstat64/stat64 are generic, but not necessarily
588 //zz // applicable to every architecture -- I think only to 32-bit archs.
589 //zz // We're going to need something like linux/core_os32.h for such
590 //zz // things, eventually, I think.  --njn
591 //zz PRE(sys_stat64)
592 //zz {
593 //zz    PRINT("sys_stat64 ( %p, %p )",ARG1,ARG2);
594 //zz    PRE_REG_READ2(long, "stat64", char *, file_name, struct stat64 *, buf);
595 //zz    PRE_MEM_RASCIIZ( "stat64(file_name)", ARG1 );
596 //zz    PRE_MEM_WRITE( "stat64(buf)", ARG2, sizeof(struct vki_stat64) );
597 //zz }
598 //zz
599 //zz POST(sys_stat64)
600 //zz {
601 //zz    POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
602 //zz }
603 //zz
604 //zz PRE(sys_lstat64)
605 //zz {
606 //zz    PRINT("sys_lstat64 ( %p(%s), %p )",ARG1,ARG1,ARG2);
607 //zz    PRE_REG_READ2(long, "lstat64", char *, file_name, struct stat64 *, buf);
608 //zz    PRE_MEM_RASCIIZ( "lstat64(file_name)", ARG1 );
609 //zz    PRE_MEM_WRITE( "lstat64(buf)", ARG2, sizeof(struct vki_stat64) );
610 //zz }
611 //zz
612 //zz POST(sys_lstat64)
613 //zz {
614 //zz    vg_assert(SUCCESS);
615 //zz    if (RES == 0) {
616 //zz       POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
617 //zz    }
618 //zz }
619 //zz
620 //zz PRE(sys_fstat64)
621 //zz {
622 //zz   PRINT("sys_fstat64 ( %d, %p )",ARG1,ARG2);
623 //zz   PRE_REG_READ2(long, "fstat64", unsigned long, fd, struct stat64 *, buf);
624 //zz   PRE_MEM_WRITE( "fstat64(buf)", ARG2, sizeof(struct vki_stat64) );
625 //zz }
626 //zz
627 //zz POST(sys_fstat64)
628 //zz {
629 //zz   POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
630 //zz }
631 
632 
PRE(sys_clone)633 PRE(sys_clone)
634 {
635    UInt cloneflags;
636 
637    PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
638    PRE_REG_READ5(int, "clone",
639                  unsigned long, flags,
640                  void *,        child_stack,
641                  int *,         parent_tidptr,
642                  void *,        child_tls,
643                  int *,         child_tidptr);
644 
645    if (ARG1 & VKI_CLONE_PARENT_SETTID) {
646       PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
647       if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int),
648                                              VKI_PROT_WRITE)) {
649          SET_STATUS_Failure( VKI_EFAULT );
650          return;
651       }
652    }
653    if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
654       PRE_MEM_WRITE("clone(child_tidptr)", ARG5, sizeof(Int));
655       if (!VG_(am_is_valid_for_client)(ARG5, sizeof(Int),
656                                              VKI_PROT_WRITE)) {
657          SET_STATUS_Failure( VKI_EFAULT );
658          return;
659       }
660    }
661 
662    cloneflags = ARG1;
663 
664    if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) {
665       SET_STATUS_Failure( VKI_EINVAL );
666       return;
667    }
668 
669    /* Only look at the flags we really care about */
670    switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
671                          | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
672    case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
673       /* thread creation */
674       SET_STATUS_from_SysRes(
675          do_clone(tid,
676                   ARG1,         /* flags */
677                   (Addr)ARG2,   /* child SP */
678                   (Int *)ARG3,  /* parent_tidptr */
679                   (Int *)ARG5,  /* child_tidptr */
680                   (Addr)ARG4)); /* child_tls */
681       break;
682 
683    case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
684       /* FALLTHROUGH - assume vfork == fork */
685       cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
686 
687    case 0: /* plain fork */
688       SET_STATUS_from_SysRes(
689          ML_(do_fork_clone)(tid,
690                        cloneflags,      /* flags */
691                        (Int *)ARG3,     /* parent_tidptr */
692                        (Int *)ARG5));   /* child_tidptr */
693       break;
694 
695    default:
696       /* should we just ENOSYS? */
697       VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG1);
698       VG_(message)(Vg_UserMsg, "\n");
699       VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
700       VG_(message)(Vg_UserMsg, " - via a threads library (LinuxThreads or NPTL)\n");
701       VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork\n");
702       VG_(unimplemented)
703          ("Valgrind does not support general clone().");
704    }
705 
706    if (SUCCESS) {
707       if (ARG1 & VKI_CLONE_PARENT_SETTID)
708          POST_MEM_WRITE(ARG3, sizeof(Int));
709       if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
710          POST_MEM_WRITE(ARG5, sizeof(Int));
711 
712       /* Thread creation was successful; let the child have the chance
713          to run */
714       *flags |= SfYieldAfter;
715    }
716 }
717 
PRE(sys_fadvise64)718 PRE(sys_fadvise64)
719 {
720    PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )",  SARG1, SARG2, SARG3, SARG4);
721    PRE_REG_READ4(long, "fadvise64",
722                  int, fd, vki_loff_t, offset, vki_size_t, len, int, advice);
723 }
724 
PRE(sys_rt_sigreturn)725 PRE(sys_rt_sigreturn)
726 {
727    /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
728       an explanation of what follows. */
729 
730    //ThreadState* tst;
731    PRINT("sys_rt_sigreturn ( )");
732 
733    vg_assert(VG_(is_valid_tid)(tid));
734    vg_assert(tid >= 1 && tid < VG_N_THREADS);
735    vg_assert(VG_(is_running_thread)(tid));
736 
737    ///* Adjust esp to point to start of frame; skip back up over handler
738    //   ret addr */
739    //tst = VG_(get_ThreadState)(tid);
740    //tst->arch.vex.guest_ESP -= sizeof(Addr);
741    // Should we do something equivalent on ppc64-linux?  Who knows.
742 
743    ///* This is only so that the EIP is (might be) useful to report if
744    //   something goes wrong in the sigreturn */
745    //ML_(fixup_guest_state_to_restart_syscall)(&tst->arch);
746    // Should we do something equivalent on ppc64?  Who knows.
747 
748    /* Restore register state from frame and remove it */
749    VG_(sigframe_destroy)(tid, True);
750 
751    /* Tell the driver not to update the guest state with the "result",
752       and set a bogus result to keep it happy. */
753    *flags |= SfNoWriteResult;
754    SET_STATUS_Success(0);
755 
756    /* Check to see if any signals arose as a result of this. */
757    *flags |= SfPollAfter;
758 }
759 
760 #undef PRE
761 #undef POST
762 
763 /* ---------------------------------------------------------------------
764    The ppc64/Linux syscall table
765    ------------------------------------------------------------------ */
766 
767 /* Add an ppc64-linux specific wrapper to a syscall table. */
768 #define PLAX_(sysno, name)    WRAPPER_ENTRY_X_(ppc64_linux, sysno, name)
769 #define PLAXY(sysno, name)    WRAPPER_ENTRY_XY(ppc64_linux, sysno, name)
770 
771 // This table maps from __NR_xxx syscall numbers (from
772 // linux/include/asm-ppc/unistd.h) to the appropriate PRE/POST sys_foo()
773 // wrappers on ppc64 (as per sys_call_table in linux/arch/ppc/kernel/entry.S).
774 //
775 // For those syscalls not handled by Valgrind, the annotation indicate its
776 // arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/?
777 // (unknown).
778 
779 static SyscallTableEntry syscall_table[] = {
780 // _____(__NR_restart_syscall,   sys_restart_syscall),    //   0
781    GENX_(__NR_exit,              sys_exit),               //   1
782    GENX_(__NR_fork,              sys_fork),               //   2
783    GENXY(__NR_read,              sys_read),               //   3
784    GENX_(__NR_write,             sys_write),              //   4
785 
786    GENXY(__NR_open,              sys_open),               //   5
787    GENXY(__NR_close,             sys_close),              //   6
788    GENXY(__NR_waitpid,           sys_waitpid),            //   7
789    GENXY(__NR_creat,             sys_creat),              //   8
790    GENX_(__NR_link,              sys_link),               //   9
791 
792    GENX_(__NR_unlink,            sys_unlink),             //  10
793    GENX_(__NR_execve,            sys_execve),             //  11
794    GENX_(__NR_chdir,             sys_chdir),              //  12
795    GENXY(__NR_time,              sys_time),               //  13
796    GENX_(__NR_mknod,             sys_mknod),              //  14
797 
798    GENX_(__NR_chmod,             sys_chmod),              //  15
799    GENX_(__NR_lchown,            sys_lchown),             //  16
800 // _____(__NR_break,             sys_break),              //  17
801 // _____(__NR_oldstat,           sys_oldstat),            //  18
802    LINX_(__NR_lseek,             sys_lseek),              //  19
803 
804    GENX_(__NR_getpid,            sys_getpid),             //  20
805    LINX_(__NR_mount,             sys_mount),              //  21
806 // _____(__NR_umount,            sys_umount),             //  22
807    GENX_(__NR_setuid,            sys_setuid),             //  23
808    GENX_(__NR_getuid,            sys_getuid),             //  24
809 
810 // _____(__NR_stime,             sys_stime),              //  25
811 // When ptrace is supported, memcheck/tests/linux/getregset should be enabled
812 // _____(__NR_ptrace,            sys_ptrace),             //  26
813    GENX_(__NR_alarm,             sys_alarm),              //  27
814 // _____(__NR_oldfstat,          sys_oldfstat),           //  28
815    GENX_(__NR_pause,             sys_pause),              //  29
816 
817    LINX_(__NR_utime,             sys_utime),              //  30
818 // _____(__NR_stty,              sys_stty),               //  31
819 // _____(__NR_gtty,              sys_gtty),               //  32
820    GENX_(__NR_access,            sys_access),             //  33
821 // _____(__NR_nice,              sys_nice),               //  34
822 
823 // _____(__NR_ftime,             sys_ftime),              //  35
824 // _____(__NR_sync,              sys_sync),               //  36
825    GENX_(__NR_kill,              sys_kill),               //  37
826    GENX_(__NR_rename,            sys_rename),             //  38
827    GENX_(__NR_mkdir,             sys_mkdir),              //  39
828 
829    GENX_(__NR_rmdir,             sys_rmdir),              //  40
830    GENXY(__NR_dup,               sys_dup),                //  41
831    LINXY(__NR_pipe,              sys_pipe),               //  42
832    GENXY(__NR_times,             sys_times),              //  43
833 // _____(__NR_prof,              sys_prof),               //  44
834 
835    GENX_(__NR_brk,               sys_brk),                //  45
836    GENX_(__NR_setgid,            sys_setgid),             //  46
837    GENX_(__NR_getgid,            sys_getgid),             //  47
838 // _____(__NR_signal,            sys_signal),             //  48
839    GENX_(__NR_geteuid,           sys_geteuid),            //  49
840 
841    GENX_(__NR_getegid,           sys_getegid),            //  50
842 // _____(__NR_acct,              sys_acct),               //  51
843    LINX_(__NR_umount2,           sys_umount),             //  52
844 // _____(__NR_lock,              sys_lock),               //  53
845    LINXY(__NR_ioctl,             sys_ioctl),              //  54
846 
847    LINXY(__NR_fcntl,             sys_fcntl),              //  55
848 // _____(__NR_mpx,               sys_mpx),                //  56
849    GENX_(__NR_setpgid,           sys_setpgid),            //  57
850 // _____(__NR_ulimit,            sys_ulimit),             //  58
851 // _____(__NR_oldolduname,       sys_oldolduname),        //  59
852 
853    GENX_(__NR_umask,             sys_umask),              //  60
854    GENX_(__NR_chroot,            sys_chroot),             //  61
855 // _____(__NR_ustat,             sys_ustat),              //  62
856    GENXY(__NR_dup2,              sys_dup2),               //  63
857    GENX_(__NR_getppid,           sys_getppid),            //  64
858 
859    GENX_(__NR_getpgrp,           sys_getpgrp),            //  65
860    GENX_(__NR_setsid,            sys_setsid),             //  66
861 // _____(__NR_sigaction,         sys_sigaction),          //  67
862 // _____(__NR_sgetmask,          sys_sgetmask),           //  68
863 // _____(__NR_ssetmask,          sys_ssetmask),           //  69
864 
865    GENX_(__NR_setreuid,          sys_setreuid),           //  70
866    GENX_(__NR_setregid,          sys_setregid),           //  71
867 // _____(__NR_sigsuspend,        sys_sigsuspend),         //  72
868 // _____(__NR_sigpending,        sys_sigpending),         //  73
869 // _____(__NR_sethostname,       sys_sethostname),        //  74
870 
871    GENX_(__NR_setrlimit,         sys_setrlimit),          //  75
872 // _____(__NR_getrlimit,         sys_getrlimit),          //  76
873    GENXY(__NR_getrusage,         sys_getrusage),          //  77
874    GENXY(__NR_gettimeofday,      sys_gettimeofday),       //  78
875 // _____(__NR_settimeofday,      sys_settimeofday),       //  79
876 
877    GENXY(__NR_getgroups,         sys_getgroups),          //  80
878    GENX_(__NR_setgroups,         sys_setgroups),          //  81
879 // _____(__NR_select,            sys_select),             //  82
880    GENX_(__NR_symlink,           sys_symlink),            //  83
881 // _____(__NR_oldlstat,          sys_oldlstat),           //  84
882 
883    GENX_(__NR_readlink,          sys_readlink),           //  85
884 // _____(__NR_uselib,            sys_uselib),             //  86
885 // _____(__NR_swapon,            sys_swapon),             //  87
886 // _____(__NR_reboot,            sys_reboot),             //  88
887 // _____(__NR_readdir,           sys_readdir),            //  89
888 
889    PLAX_(__NR_mmap,              sys_mmap),               //  90
890    GENXY(__NR_munmap,            sys_munmap),             //  91
891    GENX_(__NR_truncate,          sys_truncate),           //  92
892    GENX_(__NR_ftruncate,         sys_ftruncate),          //  93
893    GENX_(__NR_fchmod,            sys_fchmod),             //  94
894 
895    GENX_(__NR_fchown,            sys_fchown),             //  95
896    GENX_(__NR_getpriority,       sys_getpriority),        //  96
897    GENX_(__NR_setpriority,       sys_setpriority),        //  97
898 // _____(__NR_profil,            sys_profil),             //  98
899    GENXY(__NR_statfs,            sys_statfs),             //  99
900 
901    GENXY(__NR_fstatfs,           sys_fstatfs),            // 100
902 // _____(__NR_ioperm,            sys_ioperm),             // 101
903    LINXY(__NR_socketcall,        sys_socketcall),         // 102
904    LINXY(__NR_syslog,            sys_syslog),             // 103
905    GENXY(__NR_setitimer,         sys_setitimer),          // 104
906 
907    GENXY(__NR_getitimer,         sys_getitimer),          // 105
908    GENXY(__NR_stat,              sys_newstat),            // 106
909    GENXY(__NR_lstat,             sys_newlstat),           // 107
910    GENXY(__NR_fstat,             sys_newfstat),           // 108
911 // _____(__NR_olduname,          sys_olduname),           // 109
912 
913 // _____(__NR_iopl,              sys_iopl),               // 110
914    LINX_(__NR_vhangup,           sys_vhangup),            // 111
915 // _____(__NR_idle,              sys_idle),               // 112
916 // _____(__NR_vm86,              sys_vm86),               // 113
917    GENXY(__NR_wait4,             sys_wait4),              // 114
918 
919 // _____(__NR_swapoff,           sys_swapoff),            // 115
920    LINXY(__NR_sysinfo,           sys_sysinfo),            // 116
921    LINXY(__NR_ipc,               sys_ipc),                // 117
922    GENX_(__NR_fsync,             sys_fsync),              // 118
923 // _____(__NR_sigreturn,         sys_sigreturn),          // 119
924 
925    PLAX_(__NR_clone,             sys_clone),              // 120
926 // _____(__NR_setdomainname,     sys_setdomainname),      // 121
927    GENXY(__NR_uname,             sys_newuname),           // 122
928 // _____(__NR_modify_ldt,        sys_modify_ldt),         // 123
929    LINXY(__NR_adjtimex,          sys_adjtimex),           // 124
930 
931    GENXY(__NR_mprotect,          sys_mprotect),           // 125
932 // _____(__NR_sigprocmask,       sys_sigprocmask),        // 126
933    GENX_(__NR_create_module,     sys_ni_syscall),         // 127
934    LINX_(__NR_init_module,       sys_init_module),        // 128
935    LINX_(__NR_delete_module,     sys_delete_module),      // 129
936 
937 // _____(__NR_get_kernel_syms,   sys_get_kernel_syms),    // 130
938 // _____(__NR_quotactl,          sys_quotactl),           // 131
939    GENX_(__NR_getpgid,           sys_getpgid),            // 132
940    GENX_(__NR_fchdir,            sys_fchdir),             // 133
941 // _____(__NR_bdflush,           sys_bdflush),            // 134
942 
943 // _____(__NR_sysfs,             sys_sysfs),              // 135
944    LINX_(__NR_personality,       sys_personality),        // 136
945 // _____(__NR_afs_syscall,       sys_afs_syscall),        // 137
946    LINX_(__NR_setfsuid,          sys_setfsuid),           // 138
947    LINX_(__NR_setfsgid,          sys_setfsgid),           // 139
948 
949    LINXY(__NR__llseek,           sys_llseek),             // 140
950    GENXY(__NR_getdents,          sys_getdents),           // 141
951    GENX_(__NR__newselect,        sys_select),             // 142
952    GENX_(__NR_flock,             sys_flock),              // 143
953    GENX_(__NR_msync,             sys_msync),              // 144
954 
955    GENXY(__NR_readv,             sys_readv),              // 145
956    GENX_(__NR_writev,            sys_writev),             // 146
957 // _____(__NR_getsid,            sys_getsid),             // 147
958    GENX_(__NR_fdatasync,         sys_fdatasync),          // 148
959    LINXY(__NR__sysctl,           sys_sysctl),             // 149
960 
961    GENX_(__NR_mlock,             sys_mlock),              // 150
962    GENX_(__NR_munlock,           sys_munlock),            // 151
963    GENX_(__NR_mlockall,          sys_mlockall),           // 152
964    LINX_(__NR_munlockall,        sys_munlockall),         // 153
965    LINXY(__NR_sched_setparam,    sys_sched_setparam),     // 154
966 
967    LINXY(__NR_sched_getparam,         sys_sched_getparam),        // 155
968    LINX_(__NR_sched_setscheduler,     sys_sched_setscheduler),    // 156
969    LINX_(__NR_sched_getscheduler,     sys_sched_getscheduler),    // 157
970    LINX_(__NR_sched_yield,            sys_sched_yield),           // 158
971    LINX_(__NR_sched_get_priority_max, sys_sched_get_priority_max),// 159
972 
973    LINX_(__NR_sched_get_priority_min, sys_sched_get_priority_min),// 160
974    LINXY(__NR_sched_rr_get_interval,  sys_sched_rr_get_interval), // 161
975    GENXY(__NR_nanosleep,         sys_nanosleep),          // 162
976    GENX_(__NR_mremap,            sys_mremap),             // 163
977    LINX_(__NR_setresuid,         sys_setresuid),          // 164
978 
979    LINXY(__NR_getresuid,         sys_getresuid),          // 165
980 // _____(__NR_query_module,      sys_query_module),       // 166
981    GENXY(__NR_poll,              sys_poll),               // 167
982 // _____(__NR_nfsservctl,        sys_nfsservctl),         // 168
983    LINX_(__NR_setresgid,         sys_setresgid),          // 169
984 
985    LINXY(__NR_getresgid,         sys_getresgid),          // 170
986    LINXY(__NR_prctl,             sys_prctl),              // 171
987    PLAX_(__NR_rt_sigreturn,      sys_rt_sigreturn),       // 172
988    LINXY(__NR_rt_sigaction,      sys_rt_sigaction),       // 173
989    LINXY(__NR_rt_sigprocmask,    sys_rt_sigprocmask),     // 174
990 
991    LINXY(__NR_rt_sigpending,     sys_rt_sigpending),      // 175
992    LINXY(__NR_rt_sigtimedwait,   sys_rt_sigtimedwait),    // 176
993    LINXY(__NR_rt_sigqueueinfo,   sys_rt_sigqueueinfo),    // 177
994    LINX_(__NR_rt_sigsuspend,     sys_rt_sigsuspend),      // 178
995    GENXY(__NR_pread64,           sys_pread64),            // 179
996 
997    GENX_(__NR_pwrite64,          sys_pwrite64),           // 180
998    GENX_(__NR_chown,             sys_chown),              // 181
999    GENXY(__NR_getcwd,            sys_getcwd),             // 182
1000    LINXY(__NR_capget,            sys_capget),             // 183
1001    LINX_(__NR_capset,            sys_capset),             // 184
1002 
1003    GENXY(__NR_sigaltstack,       sys_sigaltstack),        // 185
1004    LINXY(__NR_sendfile,          sys_sendfile),           // 186
1005 // _____(__NR_getpmsg,           sys_getpmsg),            // 187
1006 // _____(__NR_putpmsg,           sys_putpmsg),            // 188
1007    GENX_(__NR_vfork,             sys_fork),               // 189 treat as fork
1008 
1009    GENXY(__NR_ugetrlimit,        sys_getrlimit),          // 190
1010    LINX_(__NR_readahead,         sys_readahead),          // 191
1011 // /* #define __NR_mmap2           192     32bit only */
1012 // /* #define __NR_truncate64      193     32bit only */
1013 // /* #define __NR_ftruncate64     194     32bit only */
1014 
1015 // /* #define __NR_stat64          195     32bit only */
1016 // /* #define __NR_lstat64         196     32bit only */
1017 // /* #define __NR_fstat64         197     32bit only */
1018 // _____(__NR_pciconfig_read,    sys_pciconfig_read),     // 198
1019 // _____(__NR_pciconfig_write,   sys_pciconfig_write),    // 199
1020 
1021 // _____(__NR_pciconfig_iobase,  sys_pciconfig_iobase),   // 200
1022 // _____(__NR_multiplexer,       sys_multiplexer),        // 201
1023    GENXY(__NR_getdents64,        sys_getdents64),         // 202
1024    LINX_(__NR_pivot_root,        sys_pivot_root),         // 203
1025    LINXY(__NR_fcntl64,           sys_fcntl64),            // 204 !!!!?? 32bit only */
1026 
1027    GENX_(__NR_madvise,           sys_madvise),            // 205
1028 // _____(__NR_mincore,           sys_mincore),            // 206
1029    LINX_(__NR_gettid,            sys_gettid),             // 207
1030 // _____(__NR_tkill,             sys_tkill),              // 208
1031    LINX_(__NR_setxattr,          sys_setxattr),           // 209
1032 
1033    LINX_(__NR_lsetxattr,         sys_lsetxattr),          // 210
1034    LINX_(__NR_fsetxattr,         sys_fsetxattr),          // 211
1035    LINXY(__NR_getxattr,          sys_getxattr),           // 212
1036    LINXY(__NR_lgetxattr,         sys_lgetxattr),          // 213
1037    LINXY(__NR_fgetxattr,         sys_fgetxattr),          // 214
1038    LINXY(__NR_listxattr,         sys_listxattr),          // 215
1039    LINXY(__NR_llistxattr,        sys_llistxattr),         // 216
1040    LINXY(__NR_flistxattr,        sys_flistxattr),         // 217
1041    LINX_(__NR_removexattr,       sys_removexattr),        // 218
1042    LINX_(__NR_lremovexattr,      sys_lremovexattr),       // 219
1043    LINX_(__NR_fremovexattr,      sys_fremovexattr),       // 220
1044 
1045    LINXY(__NR_futex,             sys_futex),              // 221
1046    LINX_(__NR_sched_setaffinity, sys_sched_setaffinity),  // 222
1047    LINXY(__NR_sched_getaffinity, sys_sched_getaffinity),  // 223
1048 // /* 224 currently unused */
1049 
1050 // _____(__NR_tuxcall,           sys_tuxcall),            // 225
1051 // /* #define __NR_sendfile64      226     32bit only */
1052    LINX_(__NR_io_setup,          sys_io_setup),           // 227
1053    LINX_(__NR_io_destroy,        sys_io_destroy),         // 228
1054    LINXY(__NR_io_getevents,      sys_io_getevents),       // 229
1055    LINX_(__NR_io_submit,         sys_io_submit),          // 230
1056    LINXY(__NR_io_cancel,         sys_io_cancel),          // 231
1057    LINX_(__NR_set_tid_address,   sys_set_tid_address),    // 232
1058    PLAX_(__NR_fadvise64,         sys_fadvise64),          // 233
1059    LINX_(__NR_exit_group,        sys_exit_group),         // 234
1060 
1061 // _____(__NR_lookup_dcookie,    sys_lookup_dcookie),     // 235
1062    LINXY(__NR_epoll_create,      sys_epoll_create),       // 236
1063    LINX_(__NR_epoll_ctl,         sys_epoll_ctl),          // 237
1064    LINXY(__NR_epoll_wait,        sys_epoll_wait),         // 238
1065 // _____(__NR_remap_file_pages,  sys_remap_file_pages),   // 239
1066 
1067    LINXY(__NR_timer_create,      sys_timer_create),       // 240
1068    LINXY(__NR_timer_settime,     sys_timer_settime),      // 241
1069    LINXY(__NR_timer_gettime,     sys_timer_gettime),      // 242
1070    LINX_(__NR_timer_getoverrun,  sys_timer_getoverrun),   // 243
1071    LINX_(__NR_timer_delete,      sys_timer_delete),       // 244
1072    LINX_(__NR_clock_settime,     sys_clock_settime),      // 245
1073    LINXY(__NR_clock_gettime,     sys_clock_gettime),      // 246
1074    LINXY(__NR_clock_getres,      sys_clock_getres),       // 247
1075    LINXY(__NR_clock_nanosleep,   sys_clock_nanosleep),    // 248
1076 
1077 // _____(__NR_swapcontext,       sys_swapcontext),        // 249
1078 
1079    LINXY(__NR_tgkill,            sys_tgkill),             // 250
1080 // _____(__NR_utimes,            sys_utimes),             // 251
1081 // _____(__NR_statfs64,          sys_statfs64),           // 252
1082 // _____(__NR_fstatfs64,         sys_fstatfs64),          // 253
1083 // /* #define __NR_fadvise64_64    254     32bit only */
1084 
1085 // _____(__NR_rtas,              sys_rtas),               // 255
1086 // /* Number 256 is reserved for sys_debug_setcontext */
1087 // /* Number 257 is reserved for vserver */
1088 // /* 258 currently unused */
1089    LINX_(__NR_mbind,             sys_mbind),              // 259
1090 
1091    LINXY(__NR_get_mempolicy,     sys_get_mempolicy),      // 260
1092    LINX_(__NR_set_mempolicy,     sys_set_mempolicy),      // 261
1093    LINXY(__NR_mq_open,           sys_mq_open),            // 262
1094    LINX_(__NR_mq_unlink,         sys_mq_unlink),          // 263
1095    LINX_(__NR_mq_timedsend,      sys_mq_timedsend),       // 264
1096 
1097    LINXY(__NR_mq_timedreceive,   sys_mq_timedreceive),    // 265
1098    LINX_(__NR_mq_notify,         sys_mq_notify),          // 266
1099    LINXY(__NR_mq_getsetattr,     sys_mq_getsetattr),      // 267
1100 // _____(__NR_kexec_load,        sys_kexec_load),         // 268
1101    LINX_(__NR_add_key,           sys_add_key),            // 269
1102 
1103    LINX_(__NR_request_key,       sys_request_key),        // 270
1104    LINXY(__NR_keyctl,            sys_keyctl),             // 271
1105 // _____(__NR_waitid,            sys_waitid),             // 272
1106    LINX_(__NR_ioprio_set,        sys_ioprio_set),         // 273
1107    LINX_(__NR_ioprio_get,        sys_ioprio_get),         // 274
1108 
1109    LINX_(__NR_inotify_init,  sys_inotify_init),           // 275
1110    LINX_(__NR_inotify_add_watch,  sys_inotify_add_watch), // 276
1111    LINX_(__NR_inotify_rm_watch,   sys_inotify_rm_watch),  // 277
1112 
1113    LINX_(__NR_pselect6,          sys_pselect6),           // 280
1114    LINXY(__NR_ppoll,             sys_ppoll),              // 281
1115 
1116    LINXY(__NR_openat,            sys_openat),             // 286
1117    LINX_(__NR_mkdirat,           sys_mkdirat),            // 287
1118    LINX_(__NR_mknodat,           sys_mknodat),            // 288
1119    LINX_(__NR_fchownat,          sys_fchownat),           // 289
1120    LINX_(__NR_futimesat,         sys_futimesat),          // 290
1121    LINXY(__NR_newfstatat,        sys_newfstatat),         // 291
1122    LINX_(__NR_unlinkat,          sys_unlinkat),           // 292
1123    LINX_(__NR_renameat,          sys_renameat),           // 293
1124    LINX_(__NR_linkat,            sys_linkat),             // 294
1125    LINX_(__NR_symlinkat,         sys_symlinkat),          // 295
1126    LINX_(__NR_readlinkat,        sys_readlinkat),         // 296
1127    LINX_(__NR_fchmodat,          sys_fchmodat),           // 297
1128    LINX_(__NR_faccessat,         sys_faccessat),          // 298
1129    LINX_(__NR_set_robust_list,   sys_set_robust_list),    // 299
1130    LINXY(__NR_get_robust_list,   sys_get_robust_list),    // 300
1131    LINXY(__NR_move_pages,        sys_move_pages),        // 301
1132    LINXY(__NR_getcpu,            sys_getcpu),            // 302
1133    LINXY(__NR_epoll_pwait,       sys_epoll_pwait),       // 303
1134    LINX_(__NR_utimensat,         sys_utimensat),         // 304
1135    LINXY(__NR_signalfd,          sys_signalfd),          // 305
1136    LINXY(__NR_timerfd_create,    sys_timerfd_create),    // 306
1137    LINXY(__NR_eventfd,           sys_eventfd),           // 307
1138    LINX_(__NR_sync_file_range2,  sys_sync_file_range2),  // 308
1139    LINX_(__NR_fallocate,         sys_fallocate),         // 309
1140 //   LINXY(__NR_subpage_prot,       sys_ni_syscall),       // 310
1141    LINXY(__NR_timerfd_settime,   sys_timerfd_settime),  // 311
1142    LINXY(__NR_timerfd_gettime,   sys_timerfd_gettime),  // 312
1143    LINXY(__NR_signalfd4,         sys_signalfd4),        // 313
1144    LINXY(__NR_eventfd2,          sys_eventfd2),         // 314
1145    LINXY(__NR_epoll_create1,     sys_epoll_create1),    // 315
1146    LINXY(__NR_dup3,              sys_dup3),             // 316
1147    LINXY(__NR_pipe2,             sys_pipe2),            // 317
1148    LINXY(__NR_inotify_init1,     sys_inotify_init1),    // 318
1149    LINXY(__NR_perf_event_open,   sys_perf_event_open),  // 319
1150    LINXY(__NR_preadv,            sys_preadv),           // 320
1151    LINX_(__NR_pwritev,           sys_pwritev),          // 321
1152    LINXY(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo),// 322
1153 
1154    LINXY(__NR_recvmmsg,          sys_recvmmsg),         // 343
1155    LINXY(__NR_accept4,           sys_accept4),          // 344
1156 
1157    LINXY(__NR_clock_adjtime,     sys_clock_adjtime),    // 347
1158    LINX_(__NR_syncfs,            sys_syncfs),           // 348
1159    LINXY(__NR_sendmmsg,          sys_sendmmsg),         // 349
1160 
1161    LINXY(__NR_process_vm_readv,  sys_process_vm_readv), // 351
1162    LINX_(__NR_process_vm_writev, sys_process_vm_writev),// 352
1163 
1164    LINXY(__NR_getrandom,         sys_getrandom),        // 359
1165    LINXY(__NR_memfd_create,      sys_memfd_create)      // 360
1166 };
1167 
ML_(get_linux_syscall_entry)1168 SyscallTableEntry* ML_(get_linux_syscall_entry) ( UInt sysno )
1169 {
1170    const UInt syscall_table_size
1171       = sizeof(syscall_table) / sizeof(syscall_table[0]);
1172 
1173    /* Is it in the contiguous initial section of the table? */
1174    if (sysno < syscall_table_size) {
1175       SyscallTableEntry* sys = &syscall_table[sysno];
1176       if (sys->before == NULL)
1177          return NULL; /* no entry */
1178       else
1179          return sys;
1180    }
1181 
1182    /* Can't find a wrapper */
1183    return NULL;
1184 }
1185 
1186 #endif // defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux)
1187 
1188 /*--------------------------------------------------------------------*/
1189 /*--- end                                                          ---*/
1190 /*--------------------------------------------------------------------*/
1191