?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tests/vg_regtest: Always evaluate prerequisite expressions with sh
[valgrind.git] / coregrind / m_syswrap / syswrap-ppc64-linux.c
blob5799b08a71955d6bb2621e989fbde8af2492a18b
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_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 */
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
515 void VG_(cleanup_thread) ( ThreadArchState* arch )
516 {
517 }
518
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
552 PRE(sys_mmap)
553 {
554 SysRes r;
555
556 PRINT("sys_mmap ( %#lx, %llu, %ld, %ld, %ld, %ld )",
557 ARG1, (ULong)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
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
718 PRE(sys_fadvise64)
719 {
720 PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", ARG1,ARG2,ARG3,ARG4);
721 PRE_REG_READ4(long, "fadvise64",
722 int, fd, vki_loff_t, offset, vki_size_t, len, int, advice);
723 }
724
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
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 /*--------------------------------------------------------------------*/
Instrumentation framework for detecting many memory management and threading bugs, and profile your programs in detail.