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