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