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-2012 Nicholas Nethercote <njn@valgrind.org>
11 Copyright (C) 2005-2012 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 */
do_clone(ThreadId ptid,UInt flags,Addr sp,Int * parent_tidptr,Int * child_tidptr,Addr child_tls)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 NSegment const* seg;
248 SysRes res;
249 vki_sigset_t blockall, savedmask;
250
251 VG_(sigfillset)(&blockall);
252
253 vg_assert(VG_(is_running_thread)(ptid));
254 vg_assert(VG_(is_valid_tid)(ctid));
255
256 stack = (UWord*)ML_(allocstack)(ctid);
257 if (stack == NULL) {
258 res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
259 goto out;
260 }
261
262 //? /* make a stack frame */
263 //? stack -= 16;
264 //? *(UWord *)stack = 0;
265
266
267 /* Copy register state
268
269 Both parent and child return to the same place, and the code
270 following the clone syscall works out which is which, so we
271 don't need to worry about it.
272
273 The parent gets the child's new tid returned from clone, but the
274 child gets 0.
275
276 If the clone call specifies a NULL SP for the new thread, then
277 it actually gets a copy of the parent's SP.
278
279 The child's TLS register (r2) gets set to the tlsaddr argument
280 if the CLONE_SETTLS flag is set.
281 */
282 setup_child( &ctst->arch, &ptst->arch );
283
284 /* Make sys_clone appear to have returned Success(0) in the
285 child. */
286 { UInt old_cr = LibVEX_GuestPPC32_get_CR( &ctst->arch.vex );
287 /* %r3 = 0 */
288 ctst->arch.vex.guest_GPR3 = 0;
289 /* %cr0.so = 0 */
290 LibVEX_GuestPPC32_put_CR( old_cr & ~(1<<28), &ctst->arch.vex );
291 }
292
293 if (sp != 0)
294 ctst->arch.vex.guest_GPR1 = sp;
295
296 ctst->os_state.parent = ptid;
297
298 /* inherit signal mask */
299 ctst->sig_mask = ptst->sig_mask;
300 ctst->tmp_sig_mask = ptst->sig_mask;
301
302 /* Start the child with its threadgroup being the same as the
303 parent's. This is so that any exit_group calls that happen
304 after the child is created but before it sets its
305 os_state.threadgroup field for real (in thread_wrapper in
306 syswrap-linux.c), really kill the new thread. a.k.a this avoids
307 a race condition in which the thread is unkillable (via
308 exit_group) because its threadgroup is not set. The race window
309 is probably only a few hundred or a few thousand cycles long.
310 See #226116. */
311 ctst->os_state.threadgroup = ptst->os_state.threadgroup;
312
313 /* We don't really know where the client stack is, because its
314 allocated by the client. The best we can do is look at the
315 memory mappings and try to derive some useful information. We
316 assume that esp starts near its highest possible value, and can
317 only go down to the start of the mmaped segment. */
318 seg = VG_(am_find_nsegment)(sp);
319 if (seg && seg->kind != SkResvn) {
320 ctst->client_stack_highest_word = (Addr)VG_PGROUNDUP(sp);
321 ctst->client_stack_szB = ctst->client_stack_highest_word - seg->start;
322
323 VG_(register_stack)(seg->start, ctst->client_stack_highest_word);
324
325 if (debug)
326 VG_(printf)("\ntid %d: guessed client stack range %#lx-%#lx\n",
327 ctid, seg->start, VG_PGROUNDUP(sp));
328 } else {
329 VG_(message)(Vg_UserMsg,
330 "!? New thread %d starts with R1(%#lx) unmapped\n",
331 ctid, sp);
332 ctst->client_stack_szB = 0;
333 }
334
335 /* Assume the clone will succeed, and tell any tool that wants to
336 know that this thread has come into existence. If the clone
337 fails, we'll send out a ll_exit notification for it at the out:
338 label below, to clean up. */
339 vg_assert(VG_(owns_BigLock_LL)(ptid));
340 VG_TRACK ( pre_thread_ll_create, ptid, ctid );
341
342 if (flags & VKI_CLONE_SETTLS) {
343 if (debug)
344 VG_(printf)("clone child has SETTLS: tls at %#lx\n", child_tls);
345 ctst->arch.vex.guest_GPR2 = child_tls;
346 }
347
348 flags &= ~VKI_CLONE_SETTLS;
349
350 /* start the thread with everything blocked */
351 VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
352
353 /* Create the new thread */
354 word64 = do_syscall_clone_ppc32_linux(
355 ML_(start_thread_NORETURN), stack, flags, &VG_(threads)[ctid],
356 child_tidptr, parent_tidptr, NULL
357 );
358 /* High half word64 is syscall return value. Low half is
359 the entire CR, from which we need to extract CR0.SO. */
360 /* VG_(printf)("word64 = 0x%llx\n", word64); */
361 res = VG_(mk_SysRes_ppc32_linux)(
362 /*val*/(UInt)(word64 >> 32),
363 /*errflag*/ (((UInt)word64) >> 28) & 1
364 );
365
366 VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
367
368 out:
369 if (sr_isError(res)) {
370 /* clone failed */
371 VG_(cleanup_thread)(&ctst->arch);
372 ctst->status = VgTs_Empty;
373 /* oops. Better tell the tool the thread exited in a hurry :-) */
374 VG_TRACK( pre_thread_ll_exit, ctid );
375 }
376
377 return res;
378 }
379
380
381
382 /* ---------------------------------------------------------------------
383 More thread stuff
384 ------------------------------------------------------------------ */
385
VG_(cleanup_thread)386 void VG_(cleanup_thread) ( ThreadArchState* arch )
387 {
388 }
389
setup_child(ThreadArchState * child,ThreadArchState * parent)390 void setup_child ( /*OUT*/ ThreadArchState *child,
391 /*IN*/ ThreadArchState *parent )
392 {
393 /* We inherit our parent's guest state. */
394 child->vex = parent->vex;
395 child->vex_shadow1 = parent->vex_shadow1;
396 child->vex_shadow2 = parent->vex_shadow2;
397 }
398
399
400 /* ---------------------------------------------------------------------
401 PRE/POST wrappers for ppc32/Linux-specific syscalls
402 ------------------------------------------------------------------ */
403
404 #define PRE(name) DEFN_PRE_TEMPLATE(ppc32_linux, name)
405 #define POST(name) DEFN_POST_TEMPLATE(ppc32_linux, name)
406
407 /* Add prototypes for the wrappers declared here, so that gcc doesn't
408 harass us for not having prototypes. Really this is a kludge --
409 the right thing to do is to make these wrappers 'static' since they
410 aren't visible outside this file, but that requires even more macro
411 magic. */
412
413 DECL_TEMPLATE(ppc32_linux, sys_socketcall);
414 DECL_TEMPLATE(ppc32_linux, sys_mmap);
415 DECL_TEMPLATE(ppc32_linux, sys_mmap2);
416 DECL_TEMPLATE(ppc32_linux, sys_stat64);
417 DECL_TEMPLATE(ppc32_linux, sys_lstat64);
418 DECL_TEMPLATE(ppc32_linux, sys_fstatat64);
419 DECL_TEMPLATE(ppc32_linux, sys_fstat64);
420 DECL_TEMPLATE(ppc32_linux, sys_ipc);
421 DECL_TEMPLATE(ppc32_linux, sys_clone);
422 DECL_TEMPLATE(ppc32_linux, sys_sigreturn);
423 DECL_TEMPLATE(ppc32_linux, sys_rt_sigreturn);
424 DECL_TEMPLATE(ppc32_linux, sys_sigsuspend);
425 DECL_TEMPLATE(ppc32_linux, sys_spu_create);
426 DECL_TEMPLATE(ppc32_linux, sys_spu_run);
427
PRE(sys_socketcall)428 PRE(sys_socketcall)
429 {
430 # define ARG2_0 (((UWord*)ARG2)[0])
431 # define ARG2_1 (((UWord*)ARG2)[1])
432 # define ARG2_2 (((UWord*)ARG2)[2])
433 # define ARG2_3 (((UWord*)ARG2)[3])
434 # define ARG2_4 (((UWord*)ARG2)[4])
435 # define ARG2_5 (((UWord*)ARG2)[5])
436
437 *flags |= SfMayBlock;
438 PRINT("sys_socketcall ( %ld, %#lx )",ARG1,ARG2);
439 PRE_REG_READ2(long, "socketcall", int, call, unsigned long *, args);
440
441 switch (ARG1 /* request */) {
442
443 case VKI_SYS_SOCKETPAIR:
444 /* int socketpair(int d, int type, int protocol, int sv[2]); */
445 PRE_MEM_READ( "socketcall.socketpair(args)", ARG2, 4*sizeof(Addr) );
446 ML_(generic_PRE_sys_socketpair)( tid, ARG2_0, ARG2_1, ARG2_2, ARG2_3 );
447 break;
448
449 case VKI_SYS_SOCKET:
450 /* int socket(int domain, int type, int protocol); */
451 PRE_MEM_READ( "socketcall.socket(args)", ARG2, 3*sizeof(Addr) );
452 break;
453
454 case VKI_SYS_BIND:
455 /* int bind(int sockfd, struct sockaddr *my_addr,
456 int addrlen); */
457 PRE_MEM_READ( "socketcall.bind(args)", ARG2, 3*sizeof(Addr) );
458 ML_(generic_PRE_sys_bind)( tid, ARG2_0, ARG2_1, ARG2_2 );
459 break;
460
461 case VKI_SYS_LISTEN:
462 /* int listen(int s, int backlog); */
463 PRE_MEM_READ( "socketcall.listen(args)", ARG2, 2*sizeof(Addr) );
464 break;
465
466 case VKI_SYS_ACCEPT: {
467 /* int accept(int s, struct sockaddr *addr, int *addrlen); */
468 PRE_MEM_READ( "socketcall.accept(args)", ARG2, 3*sizeof(Addr) );
469 ML_(generic_PRE_sys_accept)( tid, ARG2_0, ARG2_1, ARG2_2 );
470 break;
471 }
472
473 case VKI_SYS_ACCEPT4: {
474 /* int accept(int s, struct sockaddr *addr, int *addrlen, int args); */
475 PRE_MEM_READ( "socketcall.accept4(args)", ARG2, 4*sizeof(Addr) );
476 ML_(generic_PRE_sys_accept)( tid, ARG2_0, ARG2_1, ARG2_2 );
477 break;
478 }
479
480 case VKI_SYS_SENDTO:
481 /* int sendto(int s, const void *msg, int len,
482 unsigned int flags,
483 const struct sockaddr *to, int tolen); */
484 PRE_MEM_READ( "socketcall.sendto(args)", ARG2, 6*sizeof(Addr) );
485 ML_(generic_PRE_sys_sendto)( tid, ARG2_0, ARG2_1, ARG2_2,
486 ARG2_3, ARG2_4, ARG2_5 );
487 break;
488
489 case VKI_SYS_SEND:
490 /* int send(int s, const void *msg, size_t len, int flags); */
491 PRE_MEM_READ( "socketcall.send(args)", ARG2, 4*sizeof(Addr) );
492 ML_(generic_PRE_sys_send)( tid, ARG2_0, ARG2_1, ARG2_2 );
493 break;
494
495 case VKI_SYS_RECVFROM:
496 /* int recvfrom(int s, void *buf, int len, unsigned int flags,
497 struct sockaddr *from, int *fromlen); */
498 PRE_MEM_READ( "socketcall.recvfrom(args)", ARG2, 6*sizeof(Addr) );
499 ML_(generic_PRE_sys_recvfrom)( tid, ARG2_0, ARG2_1, ARG2_2,
500 ARG2_3, ARG2_4, ARG2_5 );
501 break;
502
503 case VKI_SYS_RECV:
504 /* int recv(int s, void *buf, int len, unsigned int flags); */
505 /* man 2 recv says:
506 The recv call is normally used only on a connected socket
507 (see connect(2)) and is identical to recvfrom with a NULL
508 from parameter.
509 */
510 PRE_MEM_READ( "socketcall.recv(args)", ARG2, 4*sizeof(Addr) );
511 ML_(generic_PRE_sys_recv)( tid, ARG2_0, ARG2_1, ARG2_2 );
512 break;
513
514 case VKI_SYS_CONNECT:
515 /* int connect(int sockfd,
516 struct sockaddr *serv_addr, int addrlen ); */
517 PRE_MEM_READ( "socketcall.connect(args)", ARG2, 3*sizeof(Addr) );
518 ML_(generic_PRE_sys_connect)( tid, ARG2_0, ARG2_1, ARG2_2 );
519 break;
520
521 case VKI_SYS_SETSOCKOPT:
522 /* int setsockopt(int s, int level, int optname,
523 const void *optval, int optlen); */
524 PRE_MEM_READ( "socketcall.setsockopt(args)", ARG2, 5*sizeof(Addr) );
525 ML_(generic_PRE_sys_setsockopt)( tid, ARG2_0, ARG2_1, ARG2_2,
526 ARG2_3, ARG2_4 );
527 break;
528
529 case VKI_SYS_GETSOCKOPT:
530 /* int getsockopt(int s, int level, int optname,
531 void *optval, socklen_t *optlen); */
532 PRE_MEM_READ( "socketcall.getsockopt(args)", ARG2, 5*sizeof(Addr) );
533 ML_(linux_PRE_sys_getsockopt)( tid, ARG2_0, ARG2_1, ARG2_2,
534 ARG2_3, ARG2_4 );
535 break;
536
537 case VKI_SYS_GETSOCKNAME:
538 /* int getsockname(int s, struct sockaddr* name, int* namelen) */
539 PRE_MEM_READ( "socketcall.getsockname(args)", ARG2, 3*sizeof(Addr) );
540 ML_(generic_PRE_sys_getsockname)( tid, ARG2_0, ARG2_1, ARG2_2 );
541 break;
542
543 case VKI_SYS_GETPEERNAME:
544 /* int getpeername(int s, struct sockaddr* name, int* namelen) */
545 PRE_MEM_READ( "socketcall.getpeername(args)", ARG2, 3*sizeof(Addr) );
546 ML_(generic_PRE_sys_getpeername)( tid, ARG2_0, ARG2_1, ARG2_2 );
547 break;
548
549 case VKI_SYS_SHUTDOWN:
550 /* int shutdown(int s, int how); */
551 PRE_MEM_READ( "socketcall.shutdown(args)", ARG2, 2*sizeof(Addr) );
552 break;
553
554 case VKI_SYS_SENDMSG: {
555 /* int sendmsg(int s, const struct msghdr *msg, int flags); */
556
557 /* this causes warnings, and I don't get why. glibc bug?
558 * (after all it's glibc providing the arguments array)
559 PRE_MEM_READ( "socketcall.sendmsg(args)", ARG2, 3*sizeof(Addr) );
560 */
561 ML_(generic_PRE_sys_sendmsg)( tid, "msg", (struct vki_msghdr *)ARG2_1 );
562 break;
563 }
564
565 case VKI_SYS_RECVMSG: {
566 /* int recvmsg(int s, struct msghdr *msg, int flags); */
567
568 /* this causes warnings, and I don't get why. glibc bug?
569 * (after all it's glibc providing the arguments array)
570 PRE_MEM_READ("socketcall.recvmsg(args)", ARG2, 3*sizeof(Addr) );
571 */
572 ML_(generic_PRE_sys_recvmsg)( tid, "msg", (struct vki_msghdr *)ARG2_1 );
573 break;
574 }
575
576 default:
577 VG_(message)(Vg_DebugMsg,"Warning: unhandled socketcall 0x%lx\n",ARG1);
578 SET_STATUS_Failure( VKI_EINVAL );
579 break;
580 }
581 # undef ARG2_0
582 # undef ARG2_1
583 # undef ARG2_2
584 # undef ARG2_3
585 # undef ARG2_4
586 # undef ARG2_5
587 }
588
POST(sys_socketcall)589 POST(sys_socketcall)
590 {
591 # define ARG2_0 (((UWord*)ARG2)[0])
592 # define ARG2_1 (((UWord*)ARG2)[1])
593 # define ARG2_2 (((UWord*)ARG2)[2])
594 # define ARG2_3 (((UWord*)ARG2)[3])
595 # define ARG2_4 (((UWord*)ARG2)[4])
596 # define ARG2_5 (((UWord*)ARG2)[5])
597
598 SysRes r;
599 vg_assert(SUCCESS);
600 switch (ARG1 /* request */) {
601
602 case VKI_SYS_SOCKETPAIR:
603 r = ML_(generic_POST_sys_socketpair)(
604 tid, VG_(mk_SysRes_Success)(RES),
605 ARG2_0, ARG2_1, ARG2_2, ARG2_3
606 );
607 SET_STATUS_from_SysRes(r);
608 break;
609
610 case VKI_SYS_SOCKET:
611 r = ML_(generic_POST_sys_socket)( tid, VG_(mk_SysRes_Success)(RES) );
612 SET_STATUS_from_SysRes(r);
613 break;
614
615 case VKI_SYS_BIND:
616 /* int bind(int sockfd, struct sockaddr *my_addr,
617 int addrlen); */
618 break;
619
620 case VKI_SYS_LISTEN:
621 /* int listen(int s, int backlog); */
622 break;
623
624 case VKI_SYS_ACCEPT:
625 case VKI_SYS_ACCEPT4:
626 /* int accept(int s, struct sockaddr *addr, int *addrlen); */
627 r = ML_(generic_POST_sys_accept)( tid, VG_(mk_SysRes_Success)(RES),
628 ARG2_0, ARG2_1, ARG2_2 );
629 SET_STATUS_from_SysRes(r);
630 break;
631
632 case VKI_SYS_SENDTO:
633 break;
634
635 case VKI_SYS_SEND:
636 break;
637
638 case VKI_SYS_RECVFROM:
639 ML_(generic_POST_sys_recvfrom)( tid, VG_(mk_SysRes_Success)(RES),
640 ARG2_0, ARG2_1, ARG2_2,
641 ARG2_3, ARG2_4, ARG2_5 );
642 break;
643
644 case VKI_SYS_RECV:
645 ML_(generic_POST_sys_recv)( tid, RES, ARG2_0, ARG2_1, ARG2_2 );
646 break;
647
648 case VKI_SYS_CONNECT:
649 break;
650
651 case VKI_SYS_SETSOCKOPT:
652 break;
653
654 case VKI_SYS_GETSOCKOPT:
655 ML_(linux_POST_sys_getsockopt)( tid, VG_(mk_SysRes_Success)(RES),
656 ARG2_0, ARG2_1,
657 ARG2_2, ARG2_3, ARG2_4 );
658 break;
659
660 case VKI_SYS_GETSOCKNAME:
661 ML_(generic_POST_sys_getsockname)( tid, VG_(mk_SysRes_Success)(RES),
662 ARG2_0, ARG2_1, ARG2_2 );
663 break;
664
665 case VKI_SYS_GETPEERNAME:
666 ML_(generic_POST_sys_getpeername)( tid, VG_(mk_SysRes_Success)(RES),
667 ARG2_0, ARG2_1, ARG2_2 );
668 break;
669
670 case VKI_SYS_SHUTDOWN:
671 break;
672
673 case VKI_SYS_SENDMSG:
674 break;
675
676 case VKI_SYS_RECVMSG:
677 ML_(generic_POST_sys_recvmsg)( tid, "msg", (struct vki_msghdr *)ARG2_1, RES );
678 break;
679
680 default:
681 VG_(message)(Vg_DebugMsg,"FATAL: unhandled socketcall 0x%lx\n",ARG1);
682 VG_(core_panic)("... bye!\n");
683 break; /*NOTREACHED*/
684 }
685 # undef ARG2_0
686 # undef ARG2_1
687 # undef ARG2_2
688 # undef ARG2_3
689 # undef ARG2_4
690 # undef ARG2_5
691 }
692
PRE(sys_mmap)693 PRE(sys_mmap)
694 {
695 SysRes r;
696
697 PRINT("sys_mmap ( %#lx, %llu, %ld, %ld, %ld, %ld )",
698 ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 );
699 PRE_REG_READ6(long, "mmap",
700 unsigned long, start, unsigned long, length,
701 unsigned long, prot, unsigned long, flags,
702 unsigned long, fd, unsigned long, offset);
703
704 r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5,
705 (Off64T)ARG6 );
706 SET_STATUS_from_SysRes(r);
707 }
708
PRE(sys_mmap2)709 PRE(sys_mmap2)
710 {
711 SysRes r;
712
713 // Exactly like old_mmap() except:
714 // - the file offset is specified in 4K units rather than bytes,
715 // so that it can be used for files bigger than 2^32 bytes.
716 PRINT("sys_mmap2 ( %#lx, %llu, %ld, %ld, %ld, %ld )",
717 ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 );
718 PRE_REG_READ6(long, "mmap2",
719 unsigned long, start, unsigned long, length,
720 unsigned long, prot, unsigned long, flags,
721 unsigned long, fd, unsigned long, offset);
722
723 r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5,
724 4096 * (Off64T)ARG6 );
725 SET_STATUS_from_SysRes(r);
726 }
727
728 // XXX: lstat64/fstat64/stat64 are generic, but not necessarily
729 // applicable to every architecture -- I think only to 32-bit archs.
730 // We're going to need something like linux/core_os32.h for such
731 // things, eventually, I think. --njn
PRE(sys_stat64)732 PRE(sys_stat64)
733 {
734 PRINT("sys_stat64 ( %#lx, %#lx )",ARG1,ARG2);
735 PRE_REG_READ2(long, "stat64", char *, file_name, struct stat64 *, buf);
736 PRE_MEM_RASCIIZ( "stat64(file_name)", ARG1 );
737 PRE_MEM_WRITE( "stat64(buf)", ARG2, sizeof(struct vki_stat64) );
738 }
739
POST(sys_stat64)740 POST(sys_stat64)
741 {
742 POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
743 }
744
PRE(sys_lstat64)745 PRE(sys_lstat64)
746 {
747 PRINT("sys_lstat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
748 PRE_REG_READ2(long, "lstat64", char *, file_name, struct stat64 *, buf);
749 PRE_MEM_RASCIIZ( "lstat64(file_name)", ARG1 );
750 PRE_MEM_WRITE( "lstat64(buf)", ARG2, sizeof(struct vki_stat64) );
751 }
752
POST(sys_lstat64)753 POST(sys_lstat64)
754 {
755 vg_assert(SUCCESS);
756 if (RES == 0) {
757 POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
758 }
759 }
760
PRE(sys_fstatat64)761 PRE(sys_fstatat64)
762 {
763 PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx )",ARG1,ARG2,(char*)ARG2,ARG3);
764 PRE_REG_READ3(long, "fstatat64",
765 int, dfd, char *, file_name, struct stat64 *, buf);
766 PRE_MEM_RASCIIZ( "fstatat64(file_name)", ARG2 );
767 PRE_MEM_WRITE( "fstatat64(buf)", ARG3, sizeof(struct vki_stat64) );
768 }
769
POST(sys_fstatat64)770 POST(sys_fstatat64)
771 {
772 POST_MEM_WRITE( ARG3, sizeof(struct vki_stat64) );
773 }
774
PRE(sys_fstat64)775 PRE(sys_fstat64)
776 {
777 PRINT("sys_fstat64 ( %ld, %#lx )",ARG1,ARG2);
778 PRE_REG_READ2(long, "fstat64", unsigned long, fd, struct stat64 *, buf);
779 PRE_MEM_WRITE( "fstat64(buf)", ARG2, sizeof(struct vki_stat64) );
780 }
781
POST(sys_fstat64)782 POST(sys_fstat64)
783 {
784 POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
785 }
786
deref_Addr(ThreadId tid,Addr a,Char * s)787 static Addr deref_Addr ( ThreadId tid, Addr a, Char* s )
788 {
789 Addr* a_p = (Addr*)a;
790 PRE_MEM_READ( s, (Addr)a_p, sizeof(Addr) );
791 return *a_p;
792 }
793
PRE(sys_ipc)794 PRE(sys_ipc)
795 {
796 PRINT("sys_ipc ( %ld, %ld, %ld, %ld, %#lx, %ld )", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
797 // XXX: this is simplistic -- some args are not used in all circumstances.
798 PRE_REG_READ6(int, "ipc",
799 vki_uint, call, int, first, int, second, int, third,
800 void *, ptr, long, fifth)
801
802 switch (ARG1 /* call */) {
803 case VKI_SEMOP:
804 ML_(generic_PRE_sys_semop)( tid, ARG2, ARG5, ARG3 );
805 *flags |= SfMayBlock;
806 break;
807 case VKI_SEMGET:
808 break;
809 case VKI_SEMCTL:
810 {
811 UWord arg = deref_Addr( tid, ARG5, "semctl(arg)" );
812 ML_(generic_PRE_sys_semctl)( tid, ARG2, ARG3, ARG4, arg );
813 break;
814 }
815 case VKI_SEMTIMEDOP:
816 ML_(generic_PRE_sys_semtimedop)( tid, ARG2, ARG5, ARG3, ARG6 );
817 *flags |= SfMayBlock;
818 break;
819 case VKI_MSGSND:
820 ML_(linux_PRE_sys_msgsnd)( tid, ARG2, ARG5, ARG3, ARG4 );
821 if ((ARG4 & VKI_IPC_NOWAIT) == 0)
822 *flags |= SfMayBlock;
823 break;
824 case VKI_MSGRCV:
825 {
826 Addr msgp;
827 Word msgtyp;
828
829 msgp = deref_Addr( tid,
830 (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgp),
831 "msgrcv(msgp)" );
832 msgtyp = deref_Addr( tid,
833 (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgtyp),
834 "msgrcv(msgp)" );
835
836 ML_(linux_PRE_sys_msgrcv)( tid, ARG2, msgp, ARG3, msgtyp, ARG4 );
837
838 if ((ARG4 & VKI_IPC_NOWAIT) == 0)
839 *flags |= SfMayBlock;
840 break;
841 }
842 case VKI_MSGGET:
843 break;
844 case VKI_MSGCTL:
845 ML_(linux_PRE_sys_msgctl)( tid, ARG2, ARG3, ARG5 );
846 break;
847 case VKI_SHMAT:
848 {
849 UWord w;
850 PRE_MEM_WRITE( "shmat(raddr)", ARG4, sizeof(Addr) );
851 w = ML_(generic_PRE_sys_shmat)( tid, ARG2, ARG5, ARG3 );
852 if (w == 0)
853 SET_STATUS_Failure( VKI_EINVAL );
854 else
855 ARG5 = w;
856 break;
857 }
858 case VKI_SHMDT:
859 if (!ML_(generic_PRE_sys_shmdt)(tid, ARG5))
860 SET_STATUS_Failure( VKI_EINVAL );
861 break;
862 case VKI_SHMGET:
863 break;
864 case VKI_SHMCTL: /* IPCOP_shmctl */
865 ML_(generic_PRE_sys_shmctl)( tid, ARG2, ARG3, ARG5 );
866 break;
867 default:
868 VG_(message)(Vg_DebugMsg, "FATAL: unhandled syscall(ipc) %ld\n", ARG1 );
869 VG_(core_panic)("... bye!\n");
870 break; /*NOTREACHED*/
871 }
872 }
873
POST(sys_ipc)874 POST(sys_ipc)
875 {
876 vg_assert(SUCCESS);
877 switch (ARG1 /* call */) {
878 case VKI_SEMOP:
879 case VKI_SEMGET:
880 break;
881 case VKI_SEMCTL:
882 {
883 UWord arg = deref_Addr( tid, ARG5, "semctl(arg)" );
884 ML_(generic_PRE_sys_semctl)( tid, ARG2, ARG3, ARG4, arg );
885 break;
886 }
887 case VKI_SEMTIMEDOP:
888 case VKI_MSGSND:
889 break;
890 case VKI_MSGRCV:
891 {
892 Addr msgp;
893 Word msgtyp;
894
895 msgp = deref_Addr( tid,
896 (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgp),
897 "msgrcv(msgp)" );
898 msgtyp = deref_Addr( tid,
899 (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgtyp),
900 "msgrcv(msgp)" );
901
902 ML_(linux_POST_sys_msgrcv)( tid, RES, ARG2, msgp, ARG3, msgtyp, ARG4 );
903 break;
904 }
905 case VKI_MSGGET:
906 break;
907 case VKI_MSGCTL:
908 ML_(linux_POST_sys_msgctl)( tid, RES, ARG2, ARG3, ARG5 );
909 break;
910 case VKI_SHMAT:
911 {
912 Addr addr;
913
914 /* force readability. before the syscall it is
915 * indeed uninitialized, as can be seen in
916 * glibc/sysdeps/unix/sysv/linux/shmat.c */
917 POST_MEM_WRITE( ARG4, sizeof( Addr ) );
918
919 addr = deref_Addr ( tid, ARG4, "shmat(addr)" );
920 ML_(generic_POST_sys_shmat)( tid, addr, ARG2, ARG5, ARG3 );
921 break;
922 }
923 case VKI_SHMDT:
924 ML_(generic_POST_sys_shmdt)( tid, RES, ARG5 );
925 break;
926 case VKI_SHMGET:
927 break;
928 case VKI_SHMCTL:
929 ML_(generic_POST_sys_shmctl)( tid, RES, ARG2, ARG3, ARG5 );
930 break;
931 default:
932 VG_(message)(Vg_DebugMsg,
933 "FATAL: unhandled syscall(ipc) %ld\n",
934 ARG1 );
935 VG_(core_panic)("... bye!\n");
936 break; /*NOTREACHED*/
937 }
938 }
939
940
941
942
943 //.. PRE(old_select, MayBlock)
944 //.. {
945 //.. /* struct sel_arg_struct {
946 //.. unsigned long n;
947 //.. fd_set *inp, *outp, *exp;
948 //.. struct timeval *tvp;
949 //.. };
950 //.. */
951 //.. PRE_REG_READ1(long, "old_select", struct sel_arg_struct *, args);
952 //.. PRE_MEM_READ( "old_select(args)", ARG1, 5*sizeof(UWord) );
953 //..
954 //.. {
955 //.. UInt* arg_struct = (UInt*)ARG1;
956 //.. UInt a1, a2, a3, a4, a5;
957 //..
958 //.. a1 = arg_struct[0];
959 //.. a2 = arg_struct[1];
960 //.. a3 = arg_struct[2];
961 //.. a4 = arg_struct[3];
962 //.. a5 = arg_struct[4];
963 //..
964 //.. PRINT("old_select ( %d, %p, %p, %p, %p )", a1,a2,a3,a4,a5);
965 //.. if (a2 != (Addr)NULL)
966 //.. PRE_MEM_READ( "old_select(readfds)", a2, a1/8 /* __FD_SETSIZE/8 */ );
967 //.. if (a3 != (Addr)NULL)
968 //.. PRE_MEM_READ( "old_select(writefds)", a3, a1/8 /* __FD_SETSIZE/8 */ );
969 //.. if (a4 != (Addr)NULL)
970 //.. PRE_MEM_READ( "old_select(exceptfds)", a4, a1/8 /* __FD_SETSIZE/8 */ );
971 //.. if (a5 != (Addr)NULL)
972 //.. PRE_MEM_READ( "old_select(timeout)", a5, sizeof(struct vki_timeval) );
973 //.. }
974 //.. }
975
PRE(sys_clone)976 PRE(sys_clone)
977 {
978 UInt cloneflags;
979
980 PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
981 PRE_REG_READ5(int, "clone",
982 unsigned long, flags,
983 void *, child_stack,
984 int *, parent_tidptr,
985 void *, child_tls,
986 int *, child_tidptr);
987
988 if (ARG1 & VKI_CLONE_PARENT_SETTID) {
989 PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
990 if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int),
991 VKI_PROT_WRITE)) {
992 SET_STATUS_Failure( VKI_EFAULT );
993 return;
994 }
995 }
996 if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
997 PRE_MEM_WRITE("clone(child_tidptr)", ARG5, sizeof(Int));
998 if (!VG_(am_is_valid_for_client)(ARG5, sizeof(Int),
999 VKI_PROT_WRITE)) {
1000 SET_STATUS_Failure( VKI_EFAULT );
1001 return;
1002 }
1003 }
1004
1005 cloneflags = ARG1;
1006
1007 if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) {
1008 SET_STATUS_Failure( VKI_EINVAL );
1009 return;
1010 }
1011
1012 /* Only look at the flags we really care about */
1013 switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
1014 | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
1015 case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
1016 /* thread creation */
1017 SET_STATUS_from_SysRes(
1018 do_clone(tid,
1019 ARG1, /* flags */
1020 (Addr)ARG2, /* child SP */
1021 (Int *)ARG3, /* parent_tidptr */
1022 (Int *)ARG5, /* child_tidptr */
1023 (Addr)ARG4)); /* child_tls */
1024 break;
1025
1026 case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
1027 /* FALLTHROUGH - assume vfork == fork */
1028 cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
1029
1030 case 0: /* plain fork */
1031 SET_STATUS_from_SysRes(
1032 ML_(do_fork_clone)(tid,
1033 cloneflags, /* flags */
1034 (Int *)ARG3, /* parent_tidptr */
1035 (Int *)ARG5)); /* child_tidptr */
1036 break;
1037
1038 default:
1039 /* should we just ENOSYS? */
1040 VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG1);
1041 VG_(message)(Vg_UserMsg, "\n");
1042 VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
1043 VG_(message)(Vg_UserMsg, " - via a threads library (LinuxThreads or NPTL)\n");
1044 VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork\n");
1045 VG_(unimplemented)
1046 ("Valgrind does not support general clone().");
1047 }
1048
1049 if (SUCCESS) {
1050 if (ARG1 & VKI_CLONE_PARENT_SETTID)
1051 POST_MEM_WRITE(ARG3, sizeof(Int));
1052 if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
1053 POST_MEM_WRITE(ARG5, sizeof(Int));
1054
1055 /* Thread creation was successful; let the child have the chance
1056 to run */
1057 *flags |= SfYieldAfter;
1058 }
1059 }
1060
PRE(sys_sigreturn)1061 PRE(sys_sigreturn)
1062 {
1063 /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
1064 an explanation of what follows. */
1065
1066 //ThreadState* tst;
1067 PRINT("sys_sigreturn ( )");
1068
1069 vg_assert(VG_(is_valid_tid)(tid));
1070 vg_assert(tid >= 1 && tid < VG_N_THREADS);
1071 vg_assert(VG_(is_running_thread)(tid));
1072
1073 ///* Adjust esp to point to start of frame; skip back up over
1074 // sigreturn sequence's "popl %eax" and handler ret addr */
1075 //tst = VG_(get_ThreadState)(tid);
1076 //tst->arch.vex.guest_ESP -= sizeof(Addr)+sizeof(Word);
1077 // Should we do something equivalent on ppc32? Who knows.
1078
1079 ///* This is only so that the EIP is (might be) useful to report if
1080 // something goes wrong in the sigreturn */
1081 //ML_(fixup_guest_state_to_restart_syscall)(&tst->arch);
1082 // Should we do something equivalent on ppc32? Who knows.
1083
1084 /* Restore register state from frame and remove it */
1085 VG_(sigframe_destroy)(tid, False);
1086
1087 /* Tell the driver not to update the guest state with the "result",
1088 and set a bogus result to keep it happy. */
1089 *flags |= SfNoWriteResult;
1090 SET_STATUS_Success(0);
1091
1092 /* Check to see if any signals arose as a result of this. */
1093 *flags |= SfPollAfter;
1094 }
1095
PRE(sys_rt_sigreturn)1096 PRE(sys_rt_sigreturn)
1097 {
1098 /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
1099 an explanation of what follows. */
1100
1101 //ThreadState* tst;
1102 PRINT("rt_sigreturn ( )");
1103
1104 vg_assert(VG_(is_valid_tid)(tid));
1105 vg_assert(tid >= 1 && tid < VG_N_THREADS);
1106 vg_assert(VG_(is_running_thread)(tid));
1107
1108 ///* Adjust esp to point to start of frame; skip back up over handler
1109 // ret addr */
1110 //tst = VG_(get_ThreadState)(tid);
1111 //tst->arch.vex.guest_ESP -= sizeof(Addr);
1112 // Should we do something equivalent on ppc32? Who knows.
1113
1114 ///* This is only so that the EIP is (might be) useful to report if
1115 // something goes wrong in the sigreturn */
1116 //ML_(fixup_guest_state_to_restart_syscall)(&tst->arch);
1117 // Should we do something equivalent on ppc32? Who knows.
1118
1119 /* Restore register state from frame and remove it */
1120 VG_(sigframe_destroy)(tid, True);
1121
1122 /* Tell the driver not to update the guest state with the "result",
1123 and set a bogus result to keep it happy. */
1124 *flags |= SfNoWriteResult;
1125 SET_STATUS_Success(0);
1126
1127 /* Check to see if any signals arose as a result of this. */
1128 *flags |= SfPollAfter;
1129 }
1130
1131
1132 //.. PRE(sys_modify_ldt, Special)
1133 //.. {
1134 //.. PRINT("sys_modify_ldt ( %d, %p, %d )", ARG1,ARG2,ARG3);
1135 //.. PRE_REG_READ3(int, "modify_ldt", int, func, void *, ptr,
1136 //.. unsigned long, bytecount);
1137 //..
1138 //.. if (ARG1 == 0) {
1139 //.. /* read the LDT into ptr */
1140 //.. PRE_MEM_WRITE( "modify_ldt(ptr)", ARG2, ARG3 );
1141 //.. }
1142 //.. if (ARG1 == 1 || ARG1 == 0x11) {
1143 //.. /* write the LDT with the entry pointed at by ptr */
1144 //.. PRE_MEM_READ( "modify_ldt(ptr)", ARG2, sizeof(vki_modify_ldt_t) );
1145 //.. }
1146 //.. /* "do" the syscall ourselves; the kernel never sees it */
1147 //.. SET_RESULT( VG_(sys_modify_ldt)( tid, ARG1, (void*)ARG2, ARG3 ) );
1148 //..
1149 //.. if (ARG1 == 0 && !VG_(is_kerror)(RES) && RES > 0) {
1150 //.. POST_MEM_WRITE( ARG2, RES );
1151 //.. }
1152 //.. }
1153
1154 //.. PRE(sys_set_thread_area, Special)
1155 //.. {
1156 //.. PRINT("sys_set_thread_area ( %p )", ARG1);
1157 //.. PRE_REG_READ1(int, "set_thread_area", struct user_desc *, u_info)
1158 //.. PRE_MEM_READ( "set_thread_area(u_info)", ARG1, sizeof(vki_modify_ldt_t) );
1159 //..
1160 //.. /* "do" the syscall ourselves; the kernel never sees it */
1161 //.. SET_RESULT( VG_(sys_set_thread_area)( tid, (void *)ARG1 ) );
1162 //.. }
1163
1164 //.. PRE(sys_get_thread_area, Special)
1165 //.. {
1166 //.. PRINT("sys_get_thread_area ( %p )", ARG1);
1167 //.. PRE_REG_READ1(int, "get_thread_area", struct user_desc *, u_info)
1168 //.. PRE_MEM_WRITE( "get_thread_area(u_info)", ARG1, sizeof(vki_modify_ldt_t) );
1169 //..
1170 //.. /* "do" the syscall ourselves; the kernel never sees it */
1171 //.. SET_RESULT( VG_(sys_get_thread_area)( tid, (void *)ARG1 ) );
1172 //..
1173 //.. if (!VG_(is_kerror)(RES)) {
1174 //.. POST_MEM_WRITE( ARG1, sizeof(vki_modify_ldt_t) );
1175 //.. }
1176 //.. }
1177
1178 //.. // Parts of this are ppc32-specific, but the *PEEK* cases are generic.
1179 //.. // XXX: Why is the memory pointed to by ARG3 never checked?
1180 //.. PRE(sys_ptrace, 0)
1181 //.. {
1182 //.. PRINT("sys_ptrace ( %d, %d, %p, %p )", ARG1,ARG2,ARG3,ARG4);
1183 //.. PRE_REG_READ4(int, "ptrace",
1184 //.. long, request, long, pid, long, addr, long, data);
1185 //.. switch (ARG1) {
1186 //.. case VKI_PTRACE_PEEKTEXT:
1187 //.. case VKI_PTRACE_PEEKDATA:
1188 //.. case VKI_PTRACE_PEEKUSR:
1189 //.. PRE_MEM_WRITE( "ptrace(peek)", ARG4,
1190 //.. sizeof (long));
1191 //.. break;
1192 //.. case VKI_PTRACE_GETREGS:
1193 //.. PRE_MEM_WRITE( "ptrace(getregs)", ARG4,
1194 //.. sizeof (struct vki_user_regs_struct));
1195 //.. break;
1196 //.. case VKI_PTRACE_GETFPREGS:
1197 //.. PRE_MEM_WRITE( "ptrace(getfpregs)", ARG4,
1198 //.. sizeof (struct vki_user_i387_struct));
1199 //.. break;
1200 //.. case VKI_PTRACE_GETFPXREGS:
1201 //.. PRE_MEM_WRITE( "ptrace(getfpxregs)", ARG4,
1202 //.. sizeof(struct vki_user_fxsr_struct) );
1203 //.. break;
1204 //.. case VKI_PTRACE_SETREGS:
1205 //.. PRE_MEM_READ( "ptrace(setregs)", ARG4,
1206 //.. sizeof (struct vki_user_regs_struct));
1207 //.. break;
1208 //.. case VKI_PTRACE_SETFPREGS:
1209 //.. PRE_MEM_READ( "ptrace(setfpregs)", ARG4,
1210 //.. sizeof (struct vki_user_i387_struct));
1211 //.. break;
1212 //.. case VKI_PTRACE_SETFPXREGS:
1213 //.. PRE_MEM_READ( "ptrace(setfpxregs)", ARG4,
1214 //.. sizeof(struct vki_user_fxsr_struct) );
1215 //.. break;
1216 //.. default:
1217 //.. break;
1218 //.. }
1219 //.. }
1220
1221 //.. POST(sys_ptrace)
1222 //.. {
1223 //.. switch (ARG1) {
1224 //.. case VKI_PTRACE_PEEKTEXT:
1225 //.. case VKI_PTRACE_PEEKDATA:
1226 //.. case VKI_PTRACE_PEEKUSR:
1227 //.. POST_MEM_WRITE( ARG4, sizeof (long));
1228 //.. break;
1229 //.. case VKI_PTRACE_GETREGS:
1230 //.. POST_MEM_WRITE( ARG4, sizeof (struct vki_user_regs_struct));
1231 //.. break;
1232 //.. case VKI_PTRACE_GETFPREGS:
1233 //.. POST_MEM_WRITE( ARG4, sizeof (struct vki_user_i387_struct));
1234 //.. break;
1235 //.. case VKI_PTRACE_GETFPXREGS:
1236 //.. POST_MEM_WRITE( ARG4, sizeof(struct vki_user_fxsr_struct) );
1237 //.. break;
1238 //.. default:
1239 //.. break;
1240 //.. }
1241 //.. }
1242
1243 //.. // XXX: this duplicates a function in coregrind/vg_syscalls.c, yuk
1244 //.. static Addr deref_Addr ( ThreadId tid, Addr a, Char* s )
1245 //.. {
1246 //.. Addr* a_p = (Addr*)a;
1247 //.. PRE_MEM_READ( s, (Addr)a_p, sizeof(Addr) );
1248 //.. return *a_p;
1249 //.. }
1250
1251 //.. // XXX: should use the constants here (eg. SHMAT), not the numbers directly!
1252 //.. PRE(sys_ipc, 0)
1253 //.. {
1254 //.. PRINT("sys_ipc ( %d, %d, %d, %d, %p, %d )", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
1255 //.. // XXX: this is simplistic -- some args are not used in all circumstances.
1256 //.. PRE_REG_READ6(int, "ipc",
1257 //.. vki_uint, call, int, first, int, second, int, third,
1258 //.. void *, ptr, long, fifth)
1259 //..
1260 //.. switch (ARG1 /* call */) {
1261 //.. case VKI_SEMOP:
1262 //.. ML_(generic_PRE_sys_semop)( tid, ARG2, ARG5, ARG3 );
1263 //.. /* tst->sys_flags |= MayBlock; */
1264 //.. break;
1265 //.. case VKI_SEMGET:
1266 //.. break;
1267 //.. case VKI_SEMCTL:
1268 //.. {
1269 //.. UWord arg = deref_Addr( tid, ARG5, "semctl(arg)" );
1270 //.. ML_(generic_PRE_sys_semctl)( tid, ARG2, ARG3, ARG4, arg );
1271 //.. break;
1272 //.. }
1273 //.. case VKI_SEMTIMEDOP:
1274 //.. ML_(generic_PRE_sys_semtimedop)( tid, ARG2, ARG5, ARG3, ARG6 );
1275 //.. /* tst->sys_flags |= MayBlock; */
1276 //.. break;
1277 //.. case VKI_MSGSND:
1278 //.. ML_(linux_PRE_sys_msgsnd)( tid, ARG2, ARG5, ARG3, ARG4 );
1279 //.. /* if ((ARG4 & VKI_IPC_NOWAIT) == 0)
1280 //.. tst->sys_flags |= MayBlock;
1281 //.. */
1282 //.. break;
1283 //.. case VKI_MSGRCV:
1284 //.. {
1285 //.. Addr msgp;
1286 //.. Word msgtyp;
1287 //..
1288 //.. msgp = deref_Addr( tid,
1289 //.. (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgp),
1290 //.. "msgrcv(msgp)" );
1291 //.. msgtyp = deref_Addr( tid,
1292 //.. (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgtyp),
1293 //.. "msgrcv(msgp)" );
1294 //..
1295 //.. ML_(linux_PRE_sys_msgrcv)( tid, ARG2, msgp, ARG3, msgtyp, ARG4 );
1296 //..
1297 //.. /* if ((ARG4 & VKI_IPC_NOWAIT) == 0)
1298 //.. tst->sys_flags |= MayBlock;
1299 //.. */
1300 //.. break;
1301 //.. }
1302 //.. case VKI_MSGGET:
1303 //.. break;
1304 //.. case VKI_MSGCTL:
1305 //.. ML_(linux_PRE_sys_msgctl)( tid, ARG2, ARG3, ARG5 );
1306 //.. break;
1307 //.. case VKI_SHMAT:
1308 //.. PRE_MEM_WRITE( "shmat(raddr)", ARG4, sizeof(Addr) );
1309 //.. ARG5 = ML_(generic_PRE_sys_shmat)( tid, ARG2, ARG5, ARG3 );
1310 //.. if (ARG5 == 0)
1311 //.. SET_RESULT( -VKI_EINVAL );
1312 //.. break;
1313 //.. case VKI_SHMDT:
1314 //.. if (!ML_(generic_PRE_sys_shmdt)(tid, ARG5))
1315 //.. SET_RESULT( -VKI_EINVAL );
1316 //.. break;
1317 //.. case VKI_SHMGET:
1318 //.. break;
1319 //.. case VKI_SHMCTL: /* IPCOP_shmctl */
1320 //.. ML_(generic_PRE_sys_shmctl)( tid, ARG2, ARG3, ARG5 );
1321 //.. break;
1322 //.. default:
1323 //.. VG_(message)(Vg_DebugMsg, "FATAL: unhandled syscall(ipc) %d", ARG1 );
1324 //.. VG_(core_panic)("... bye!\n");
1325 //.. break; /*NOTREACHED*/
1326 //.. }
1327 //.. }
1328
1329 //.. POST(sys_ipc)
1330 //.. {
1331 //.. switch (ARG1 /* call */) {
1332 //.. case VKI_SEMOP:
1333 //.. case VKI_SEMGET:
1334 //.. break;
1335 //.. case VKI_SEMCTL:
1336 //.. {
1337 //.. UWord arg = deref_Addr( tid, ARG5, "semctl(arg)" );
1338 //.. ML_(generic_PRE_sys_semctl)( tid, ARG2, ARG3, ARG4, arg );
1339 //.. break;
1340 //.. }
1341 //.. case VKI_SEMTIMEDOP:
1342 //.. case VKI_MSGSND:
1343 //.. break;
1344 //.. case VKI_MSGRCV:
1345 //.. {
1346 //.. Addr msgp;
1347 //.. Word msgtyp;
1348 //..
1349 //.. msgp = deref_Addr( tid,
1350 //.. (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgp),
1351 //.. "msgrcv(msgp)" );
1352 //.. msgtyp = deref_Addr( tid,
1353 //.. (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgtyp),
1354 //.. "msgrcv(msgp)" );
1355 //..
1356 //.. ML_(linux_POST_sys_msgrcv)( tid, RES, ARG2, msgp, ARG3, msgtyp, ARG4 );
1357 //.. break;
1358 //.. }
1359 //.. case VKI_MSGGET:
1360 //.. break;
1361 //.. case VKI_MSGCTL:
1362 //.. ML_(linux_POST_sys_msgctl)( tid, RES, ARG2, ARG3, ARG5 );
1363 //.. break;
1364 //.. case VKI_SHMAT:
1365 //.. {
1366 //.. Addr addr;
1367 //..
1368 //.. /* force readability. before the syscall it is
1369 //.. * indeed uninitialized, as can be seen in
1370 //.. * glibc/sysdeps/unix/sysv/linux/shmat.c */
1371 //.. POST_MEM_WRITE( ARG4, sizeof( Addr ) );
1372 //..
1373 //.. addr = deref_Addr ( tid, ARG4, "shmat(addr)" );
1374 //.. if ( addr > 0 ) {
1375 //.. ML_(generic_POST_sys_shmat)( tid, addr, ARG2, ARG5, ARG3 );
1376 //.. }
1377 //.. break;
1378 //.. }
1379 //.. case VKI_SHMDT:
1380 //.. ML_(generic_POST_sys_shmdt)( tid, RES, ARG5 );
1381 //.. break;
1382 //.. case VKI_SHMGET:
1383 //.. break;
1384 //.. case VKI_SHMCTL:
1385 //.. ML_(generic_POST_sys_shmctl)( tid, RES, ARG2, ARG3, ARG5 );
1386 //.. break;
1387 //.. default:
1388 //.. VG_(message)(Vg_DebugMsg,
1389 //.. "FATAL: unhandled syscall(ipc) %d",
1390 //.. ARG1 );
1391 //.. VG_(core_panic)("... bye!\n");
1392 //.. break; /*NOTREACHED*/
1393 //.. }
1394 //.. }
1395
1396 /* NB: This is an almost identical clone of versions for x86-linux and
1397 arm-linux, which are themselves literally identical. */
PRE(sys_sigsuspend)1398 PRE(sys_sigsuspend)
1399 {
1400 /* The C library interface to sigsuspend just takes a pointer to
1401 a signal mask but this system call only takes the first word of
1402 the signal mask as an argument so only 32 signals are supported.
1403
1404 In fact glibc normally uses rt_sigsuspend if it is available as
1405 that takes a pointer to the signal mask so supports more signals.
1406 */
1407 *flags |= SfMayBlock;
1408 PRINT("sys_sigsuspend ( %ld )", ARG1 );
1409 PRE_REG_READ1(int, "sigsuspend", vki_old_sigset_t, mask);
1410 }
1411
PRE(sys_spu_create)1412 PRE(sys_spu_create)
1413 {
1414 PRE_MEM_RASCIIZ("stat64(filename)", ARG1);
1415 }
POST(sys_spu_create)1416 POST(sys_spu_create)
1417 {
1418 vg_assert(SUCCESS);
1419 }
1420
PRE(sys_spu_run)1421 PRE(sys_spu_run)
1422 {
1423 *flags |= SfMayBlock;
1424 if (ARG2 != 0)
1425 PRE_MEM_WRITE("npc", ARG2, sizeof(unsigned int));
1426 PRE_MEM_READ("event", ARG3, sizeof(unsigned int));
1427 }
POST(sys_spu_run)1428 POST(sys_spu_run)
1429 {
1430 if (ARG2 != 0)
1431 POST_MEM_WRITE(ARG2, sizeof(unsigned int));
1432 }
1433
1434 #undef PRE
1435 #undef POST
1436
1437 /* ---------------------------------------------------------------------
1438 The ppc32/Linux syscall table
1439 ------------------------------------------------------------------ */
1440
1441 /* Add an ppc32-linux specific wrapper to a syscall table. */
1442 #define PLAX_(sysno, name) WRAPPER_ENTRY_X_(ppc32_linux, sysno, name)
1443 #define PLAXY(sysno, name) WRAPPER_ENTRY_XY(ppc32_linux, sysno, name)
1444
1445 // This table maps from __NR_xxx syscall numbers (from
1446 // linux/include/asm-ppc/unistd.h) to the appropriate PRE/POST sys_foo()
1447 // wrappers on ppc32 (as per sys_call_table in linux/arch/ppc/kernel/entry.S).
1448 //
1449 // For those syscalls not handled by Valgrind, the annotation indicate its
1450 // arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/?
1451 // (unknown).
1452
1453 static SyscallTableEntry syscall_table[] = {
1454 //.. (restart_syscall) // 0
1455 GENX_(__NR_exit, sys_exit), // 1
1456 GENX_(__NR_fork, sys_fork), // 2
1457 GENXY(__NR_read, sys_read), // 3
1458 GENX_(__NR_write, sys_write), // 4
1459
1460 GENXY(__NR_open, sys_open), // 5
1461 GENXY(__NR_close, sys_close), // 6
1462 GENXY(__NR_waitpid, sys_waitpid), // 7
1463 GENXY(__NR_creat, sys_creat), // 8
1464 GENX_(__NR_link, sys_link), // 9
1465
1466 GENX_(__NR_unlink, sys_unlink), // 10
1467 GENX_(__NR_execve, sys_execve), // 11
1468 GENX_(__NR_chdir, sys_chdir), // 12
1469 GENXY(__NR_time, sys_time), // 13
1470 GENX_(__NR_mknod, sys_mknod), // 14
1471 //..
1472 GENX_(__NR_chmod, sys_chmod), // 15
1473 GENX_(__NR_lchown, sys_lchown), // 16 ## P
1474 //.. GENX_(__NR_break, sys_ni_syscall), // 17
1475 //.. // (__NR_oldstat, sys_stat), // 18 (obsolete)
1476 LINX_(__NR_lseek, sys_lseek), // 19
1477 //..
1478 GENX_(__NR_getpid, sys_getpid), // 20
1479 LINX_(__NR_mount, sys_mount), // 21
1480 LINX_(__NR_umount, sys_oldumount), // 22
1481 GENX_(__NR_setuid, sys_setuid), // 23 ## P
1482 GENX_(__NR_getuid, sys_getuid), // 24 ## P
1483 //..
1484 //.. // (__NR_stime, sys_stime), // 25 * (SVr4,SVID,X/OPEN)
1485 //.. PLAXY(__NR_ptrace, sys_ptrace), // 26
1486 GENX_(__NR_alarm, sys_alarm), // 27
1487 //.. // (__NR_oldfstat, sys_fstat), // 28 * L -- obsolete
1488 GENX_(__NR_pause, sys_pause), // 29
1489 //..
1490 LINX_(__NR_utime, sys_utime), // 30
1491 //.. GENX_(__NR_stty, sys_ni_syscall), // 31
1492 //.. GENX_(__NR_gtty, sys_ni_syscall), // 32
1493 GENX_(__NR_access, sys_access), // 33
1494 //.. GENX_(__NR_nice, sys_nice), // 34
1495 //..
1496 //.. GENX_(__NR_ftime, sys_ni_syscall), // 35
1497 //.. GENX_(__NR_sync, sys_sync), // 36
1498 GENX_(__NR_kill, sys_kill), // 37
1499 GENX_(__NR_rename, sys_rename), // 38
1500 GENX_(__NR_mkdir, sys_mkdir), // 39
1501
1502 GENX_(__NR_rmdir, sys_rmdir), // 40
1503 GENXY(__NR_dup, sys_dup), // 41
1504 LINXY(__NR_pipe, sys_pipe), // 42
1505 GENXY(__NR_times, sys_times), // 43
1506 //.. GENX_(__NR_prof, sys_ni_syscall), // 44
1507 //..
1508 GENX_(__NR_brk, sys_brk), // 45
1509 GENX_(__NR_setgid, sys_setgid), // 46
1510 GENX_(__NR_getgid, sys_getgid), // 47
1511 //.. // (__NR_signal, sys_signal), // 48 */* (ANSI C)
1512 GENX_(__NR_geteuid, sys_geteuid), // 49
1513
1514 GENX_(__NR_getegid, sys_getegid), // 50
1515 //.. GENX_(__NR_acct, sys_acct), // 51
1516 LINX_(__NR_umount2, sys_umount), // 52
1517 //.. GENX_(__NR_lock, sys_ni_syscall), // 53
1518 LINXY(__NR_ioctl, sys_ioctl), // 54
1519 //..
1520 LINXY(__NR_fcntl, sys_fcntl), // 55
1521 //.. GENX_(__NR_mpx, sys_ni_syscall), // 56
1522 GENX_(__NR_setpgid, sys_setpgid), // 57
1523 //.. GENX_(__NR_ulimit, sys_ni_syscall), // 58
1524 //.. // (__NR_oldolduname, sys_olduname), // 59 Linux -- obsolete
1525
1526 GENX_(__NR_umask, sys_umask), // 60
1527 GENX_(__NR_chroot, sys_chroot), // 61
1528 //.. // (__NR_ustat, sys_ustat) // 62 SVr4 -- deprecated
1529 GENXY(__NR_dup2, sys_dup2), // 63
1530 GENX_(__NR_getppid, sys_getppid), // 64
1531
1532 GENX_(__NR_getpgrp, sys_getpgrp), // 65
1533 GENX_(__NR_setsid, sys_setsid), // 66
1534 LINXY(__NR_sigaction, sys_sigaction), // 67
1535 //.. // (__NR_sgetmask, sys_sgetmask), // 68 */* (ANSI C)
1536 //.. // (__NR_ssetmask, sys_ssetmask), // 69 */* (ANSI C)
1537 //..
1538 GENX_(__NR_setreuid, sys_setreuid), // 70
1539 GENX_(__NR_setregid, sys_setregid), // 71
1540 PLAX_(__NR_sigsuspend, sys_sigsuspend), // 72
1541 LINXY(__NR_sigpending, sys_sigpending), // 73
1542 //.. // (__NR_sethostname, sys_sethostname), // 74 */*
1543 //..
1544 GENX_(__NR_setrlimit, sys_setrlimit), // 75
1545 //.. GENXY(__NR_getrlimit, sys_old_getrlimit), // 76
1546 GENXY(__NR_getrusage, sys_getrusage), // 77
1547 GENXY(__NR_gettimeofday, sys_gettimeofday), // 78
1548 //.. GENX_(__NR_settimeofday, sys_settimeofday), // 79
1549 //..
1550 GENXY(__NR_getgroups, sys_getgroups), // 80
1551 GENX_(__NR_setgroups, sys_setgroups), // 81
1552 //.. PLAX_(__NR_select, old_select), // 82
1553 GENX_(__NR_symlink, sys_symlink), // 83
1554 //.. // (__NR_oldlstat, sys_lstat), // 84 -- obsolete
1555 //..
1556 GENX_(__NR_readlink, sys_readlink), // 85
1557 //.. // (__NR_uselib, sys_uselib), // 86 */Linux
1558 //.. // (__NR_swapon, sys_swapon), // 87 */Linux
1559 //.. // (__NR_reboot, sys_reboot), // 88 */Linux
1560 //.. // (__NR_readdir, old_readdir), // 89 -- superseded
1561
1562 PLAX_(__NR_mmap, sys_mmap), // 90
1563 GENXY(__NR_munmap, sys_munmap), // 91
1564 GENX_(__NR_truncate, sys_truncate), // 92
1565 GENX_(__NR_ftruncate, sys_ftruncate), // 93
1566 GENX_(__NR_fchmod, sys_fchmod), // 94
1567
1568 GENX_(__NR_fchown, sys_fchown), // 95
1569 GENX_(__NR_getpriority, sys_getpriority), // 96
1570 GENX_(__NR_setpriority, sys_setpriority), // 97
1571 //.. GENX_(__NR_profil, sys_ni_syscall), // 98
1572 GENXY(__NR_statfs, sys_statfs), // 99
1573 //..
1574 GENXY(__NR_fstatfs, sys_fstatfs), // 100
1575 //.. LINX_(__NR_ioperm, sys_ioperm), // 101
1576 PLAXY(__NR_socketcall, sys_socketcall), // 102
1577 LINXY(__NR_syslog, sys_syslog), // 103
1578 GENXY(__NR_setitimer, sys_setitimer), // 104
1579
1580 GENXY(__NR_getitimer, sys_getitimer), // 105
1581 GENXY(__NR_stat, sys_newstat), // 106
1582 GENXY(__NR_lstat, sys_newlstat), // 107
1583 GENXY(__NR_fstat, sys_newfstat), // 108
1584 //.. // (__NR_olduname, sys_uname), // 109 -- obsolete
1585 //..
1586 //.. GENX_(__NR_iopl, sys_iopl), // 110
1587 LINX_(__NR_vhangup, sys_vhangup), // 111
1588 //.. GENX_(__NR_idle, sys_ni_syscall), // 112
1589 //.. // (__NR_vm86old, sys_vm86old), // 113 x86/Linux-only
1590 GENXY(__NR_wait4, sys_wait4), // 114
1591 //..
1592 //.. // (__NR_swapoff, sys_swapoff), // 115 */Linux
1593 LINXY(__NR_sysinfo, sys_sysinfo), // 116
1594 PLAXY(__NR_ipc, sys_ipc), // 117
1595 GENX_(__NR_fsync, sys_fsync), // 118
1596 PLAX_(__NR_sigreturn, sys_sigreturn), // 119 ?/Linux
1597 //..
1598 PLAX_(__NR_clone, sys_clone), // 120
1599 //.. // (__NR_setdomainname, sys_setdomainname), // 121 */*(?)
1600 GENXY(__NR_uname, sys_newuname), // 122
1601 //.. PLAX_(__NR_modify_ldt, sys_modify_ldt), // 123
1602 LINXY(__NR_adjtimex, sys_adjtimex), // 124
1603
1604 GENXY(__NR_mprotect, sys_mprotect), // 125
1605 LINXY(__NR_sigprocmask, sys_sigprocmask), // 126
1606 GENX_(__NR_create_module, sys_ni_syscall), // 127
1607 LINX_(__NR_init_module, sys_init_module), // 128
1608 LINX_(__NR_delete_module, sys_delete_module), // 129
1609 //..
1610 //.. // Nb: get_kernel_syms() was removed 2.4-->2.6
1611 //.. GENX_(__NR_get_kernel_syms, sys_ni_syscall), // 130
1612 //.. LINX_(__NR_quotactl, sys_quotactl), // 131
1613 GENX_(__NR_getpgid, sys_getpgid), // 132
1614 GENX_(__NR_fchdir, sys_fchdir), // 133
1615 //.. // (__NR_bdflush, sys_bdflush), // 134 */Linux
1616 //..
1617 //.. // (__NR_sysfs, sys_sysfs), // 135 SVr4
1618 LINX_(__NR_personality, sys_personality), // 136
1619 //.. GENX_(__NR_afs_syscall, sys_ni_syscall), // 137
1620 LINX_(__NR_setfsuid, sys_setfsuid), // 138
1621 LINX_(__NR_setfsgid, sys_setfsgid), // 139
1622
1623 LINXY(__NR__llseek, sys_llseek), // 140
1624 GENXY(__NR_getdents, sys_getdents), // 141
1625 GENX_(__NR__newselect, sys_select), // 142
1626 GENX_(__NR_flock, sys_flock), // 143
1627 GENX_(__NR_msync, sys_msync), // 144
1628 //..
1629 GENXY(__NR_readv, sys_readv), // 145
1630 GENX_(__NR_writev, sys_writev), // 146
1631 GENX_(__NR_getsid, sys_getsid), // 147
1632 GENX_(__NR_fdatasync, sys_fdatasync), // 148
1633 LINXY(__NR__sysctl, sys_sysctl), // 149
1634 //..
1635 GENX_(__NR_mlock, sys_mlock), // 150
1636 GENX_(__NR_munlock, sys_munlock), // 151
1637 GENX_(__NR_mlockall, sys_mlockall), // 152
1638 LINX_(__NR_munlockall, sys_munlockall), // 153
1639 LINXY(__NR_sched_setparam, sys_sched_setparam), // 154
1640 //..
1641 LINXY(__NR_sched_getparam, sys_sched_getparam), // 155
1642 LINX_(__NR_sched_setscheduler, sys_sched_setscheduler), // 156
1643 LINX_(__NR_sched_getscheduler, sys_sched_getscheduler), // 157
1644 LINX_(__NR_sched_yield, sys_sched_yield), // 158
1645 LINX_(__NR_sched_get_priority_max, sys_sched_get_priority_max),// 159
1646
1647 LINX_(__NR_sched_get_priority_min, sys_sched_get_priority_min),// 160
1648 LINXY(__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 161
1649 GENXY(__NR_nanosleep, sys_nanosleep), // 162
1650 GENX_(__NR_mremap, sys_mremap), // 163
1651 LINX_(__NR_setresuid, sys_setresuid), // 164
1652
1653 LINXY(__NR_getresuid, sys_getresuid), // 165
1654
1655 //.. GENX_(__NR_query_module, sys_ni_syscall), // 166
1656 GENXY(__NR_poll, sys_poll), // 167
1657 //.. // (__NR_nfsservctl, sys_nfsservctl), // 168 */Linux
1658 //..
1659 LINX_(__NR_setresgid, sys_setresgid), // 169
1660 LINXY(__NR_getresgid, sys_getresgid), // 170
1661 LINXY(__NR_prctl, sys_prctl), // 171
1662 PLAX_(__NR_rt_sigreturn, sys_rt_sigreturn), // 172
1663 LINXY(__NR_rt_sigaction, sys_rt_sigaction), // 173
1664
1665 LINXY(__NR_rt_sigprocmask, sys_rt_sigprocmask), // 174
1666 LINXY(__NR_rt_sigpending, sys_rt_sigpending), // 175
1667 LINXY(__NR_rt_sigtimedwait, sys_rt_sigtimedwait), // 176
1668 LINXY(__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo), // 177
1669 LINX_(__NR_rt_sigsuspend, sys_rt_sigsuspend), // 178
1670
1671 GENXY(__NR_pread64, sys_pread64), // 179
1672 GENX_(__NR_pwrite64, sys_pwrite64), // 180
1673 GENX_(__NR_chown, sys_chown), // 181
1674 GENXY(__NR_getcwd, sys_getcwd), // 182
1675 LINXY(__NR_capget, sys_capget), // 183
1676 LINX_(__NR_capset, sys_capset), // 184
1677 GENXY(__NR_sigaltstack, sys_sigaltstack), // 185
1678 LINXY(__NR_sendfile, sys_sendfile), // 186
1679 //.. GENXY(__NR_getpmsg, sys_getpmsg), // 187
1680 //.. GENX_(__NR_putpmsg, sys_putpmsg), // 188
1681
1682 // Nb: we treat vfork as fork
1683 GENX_(__NR_vfork, sys_fork), // 189
1684 GENXY(__NR_ugetrlimit, sys_getrlimit), // 190
1685 LINX_(__NR_readahead, sys_readahead), // 191 */Linux
1686 PLAX_(__NR_mmap2, sys_mmap2), // 192
1687 GENX_(__NR_truncate64, sys_truncate64), // 193
1688 GENX_(__NR_ftruncate64, sys_ftruncate64), // 194
1689 //..
1690
1691 PLAXY(__NR_stat64, sys_stat64), // 195
1692 PLAXY(__NR_lstat64, sys_lstat64), // 196
1693 PLAXY(__NR_fstat64, sys_fstat64), // 197
1694
1695 // __NR_pciconfig_read // 198
1696 // __NR_pciconfig_write // 199
1697 // __NR_pciconfig_iobase // 200
1698 // __NR_multiplexer // 201
1699
1700 GENXY(__NR_getdents64, sys_getdents64), // 202
1701 //.. // (__NR_pivot_root, sys_pivot_root), // 203 */Linux
1702 LINXY(__NR_fcntl64, sys_fcntl64), // 204
1703 GENX_(__NR_madvise, sys_madvise), // 205
1704 GENXY(__NR_mincore, sys_mincore), // 206
1705 LINX_(__NR_gettid, sys_gettid), // 207
1706 //.. LINX_(__NR_tkill, sys_tkill), // 208 */Linux
1707 //.. LINX_(__NR_setxattr, sys_setxattr), // 209
1708 //.. LINX_(__NR_lsetxattr, sys_lsetxattr), // 210
1709 //.. LINX_(__NR_fsetxattr, sys_fsetxattr), // 211
1710 LINXY(__NR_getxattr, sys_getxattr), // 212
1711 LINXY(__NR_lgetxattr, sys_lgetxattr), // 213
1712 LINXY(__NR_fgetxattr, sys_fgetxattr), // 214
1713 LINXY(__NR_listxattr, sys_listxattr), // 215
1714 LINXY(__NR_llistxattr, sys_llistxattr), // 216
1715 LINXY(__NR_flistxattr, sys_flistxattr), // 217
1716 LINX_(__NR_removexattr, sys_removexattr), // 218
1717 LINX_(__NR_lremovexattr, sys_lremovexattr), // 219
1718 LINX_(__NR_fremovexattr, sys_fremovexattr), // 220
1719
1720 LINXY(__NR_futex, sys_futex), // 221
1721 LINX_(__NR_sched_setaffinity, sys_sched_setaffinity), // 222
1722 LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 223
1723 /* 224 currently unused */
1724
1725 // __NR_tuxcall // 225
1726
1727 LINXY(__NR_sendfile64, sys_sendfile64), // 226
1728 //..
1729 LINX_(__NR_io_setup, sys_io_setup), // 227
1730 LINX_(__NR_io_destroy, sys_io_destroy), // 228
1731 LINXY(__NR_io_getevents, sys_io_getevents), // 229
1732 LINX_(__NR_io_submit, sys_io_submit), // 230
1733 LINXY(__NR_io_cancel, sys_io_cancel), // 231
1734 //..
1735 LINX_(__NR_set_tid_address, sys_set_tid_address), // 232
1736
1737 LINX_(__NR_fadvise64, sys_fadvise64), // 233 */(Linux?)
1738 LINX_(__NR_exit_group, sys_exit_group), // 234
1739 //.. GENXY(__NR_lookup_dcookie, sys_lookup_dcookie), // 235
1740 LINXY(__NR_epoll_create, sys_epoll_create), // 236
1741 LINX_(__NR_epoll_ctl, sys_epoll_ctl), // 237
1742 LINXY(__NR_epoll_wait, sys_epoll_wait), // 238
1743
1744 //.. // (__NR_remap_file_pages, sys_remap_file_pages), // 239 */Linux
1745 LINXY(__NR_timer_create, sys_timer_create), // 240
1746 LINXY(__NR_timer_settime, sys_timer_settime), // 241
1747 LINXY(__NR_timer_gettime, sys_timer_gettime), // 242
1748 LINX_(__NR_timer_getoverrun, sys_timer_getoverrun), // 243
1749 LINX_(__NR_timer_delete, sys_timer_delete), // 244
1750 LINX_(__NR_clock_settime, sys_clock_settime), // 245
1751 LINXY(__NR_clock_gettime, sys_clock_gettime), // 246
1752 LINXY(__NR_clock_getres, sys_clock_getres), // 247
1753 LINXY(__NR_clock_nanosleep, sys_clock_nanosleep), // 248
1754
1755 // __NR_swapcontext // 249
1756
1757 LINXY(__NR_tgkill, sys_tgkill), // 250 */Linux
1758 //.. GENX_(__NR_utimes, sys_utimes), // 251
1759 GENXY(__NR_statfs64, sys_statfs64), // 252
1760 GENXY(__NR_fstatfs64, sys_fstatfs64), // 253
1761 LINX_(__NR_fadvise64_64, sys_fadvise64_64), // 254 */(Linux?)
1762
1763 // __NR_rtas // 255
1764
1765 /* Number 256 is reserved for sys_debug_setcontext */
1766 /* Number 257 is reserved for vserver */
1767 /* Number 258 is reserved for new sys_remap_file_pages */
1768 /* Number 259 is reserved for new sys_mbind */
1769 LINXY(__NR_get_mempolicy, sys_get_mempolicy), // 260
1770 LINX_(__NR_set_mempolicy, sys_set_mempolicy), // 261
1771
1772 LINXY(__NR_mq_open, sys_mq_open), // 262
1773 LINX_(__NR_mq_unlink, sys_mq_unlink), // 263
1774 LINX_(__NR_mq_timedsend, sys_mq_timedsend), // 264
1775 LINXY(__NR_mq_timedreceive, sys_mq_timedreceive), // 265
1776 LINX_(__NR_mq_notify, sys_mq_notify), // 266
1777 LINXY(__NR_mq_getsetattr, sys_mq_getsetattr), // 267
1778 // __NR_kexec_load // 268
1779
1780 /* Number 269 is reserved for sys_add_key */
1781 /* Number 270 is reserved for sys_request_key */
1782 /* Number 271 is reserved for sys_keyctl */
1783 /* Number 272 is reserved for sys_waitid */
1784 LINX_(__NR_ioprio_set, sys_ioprio_set), // 273
1785 LINX_(__NR_ioprio_get, sys_ioprio_get), // 274
1786
1787 LINX_(__NR_inotify_init, sys_inotify_init), // 275
1788 LINX_(__NR_inotify_add_watch, sys_inotify_add_watch), // 276
1789 LINX_(__NR_inotify_rm_watch, sys_inotify_rm_watch), // 277
1790 PLAXY(__NR_spu_run, sys_spu_run), // 278
1791 PLAX_(__NR_spu_create, sys_spu_create), // 279
1792
1793 LINX_(__NR_pselect6, sys_pselect6), // 280
1794 LINXY(__NR_ppoll, sys_ppoll), // 281
1795
1796 LINXY(__NR_openat, sys_openat), // 286
1797 LINX_(__NR_mkdirat, sys_mkdirat), // 287
1798 LINX_(__NR_mknodat, sys_mknodat), // 288
1799 LINX_(__NR_fchownat, sys_fchownat), // 289
1800 LINX_(__NR_futimesat, sys_futimesat), // 290
1801 PLAXY(__NR_fstatat64, sys_fstatat64), // 291
1802 LINX_(__NR_unlinkat, sys_unlinkat), // 292
1803 LINX_(__NR_renameat, sys_renameat), // 293
1804 LINX_(__NR_linkat, sys_linkat), // 294
1805 LINX_(__NR_symlinkat, sys_symlinkat), // 295
1806 LINX_(__NR_readlinkat, sys_readlinkat), // 296
1807 LINX_(__NR_fchmodat, sys_fchmodat), // 297
1808 LINX_(__NR_faccessat, sys_faccessat), // 298
1809 LINX_(__NR_set_robust_list, sys_set_robust_list), // 299
1810 LINXY(__NR_get_robust_list, sys_get_robust_list), // 300
1811 LINXY(__NR_move_pages, sys_move_pages), // 301
1812 LINXY(__NR_getcpu, sys_getcpu), // 302
1813 LINXY(__NR_epoll_pwait, sys_epoll_pwait), // 303
1814 LINX_(__NR_utimensat, sys_utimensat), // 304
1815 LINXY(__NR_signalfd, sys_signalfd), // 305
1816 LINXY(__NR_timerfd_create, sys_timerfd_create), // 306
1817 LINX_(__NR_eventfd, sys_eventfd), // 307
1818 LINX_(__NR_sync_file_range2, sys_sync_file_range2), // 308
1819 LINX_(__NR_fallocate, sys_fallocate), // 309
1820 // LINXY(__NR_subpage_prot, sys_ni_syscall), // 310
1821 LINXY(__NR_timerfd_settime, sys_timerfd_settime), // 311
1822 LINXY(__NR_timerfd_gettime, sys_timerfd_gettime), // 312
1823 LINXY(__NR_signalfd4, sys_signalfd4), // 313
1824 LINX_(__NR_eventfd2, sys_eventfd2), // 314
1825 LINXY(__NR_epoll_create1, sys_epoll_create1), // 315
1826 LINXY(__NR_dup3, sys_dup3), // 316
1827 LINXY(__NR_pipe2, sys_pipe2), // 317
1828 LINXY(__NR_inotify_init1, sys_inotify_init1), // 318
1829 LINXY(__NR_perf_event_open, sys_perf_event_open), // 319
1830 LINXY(__NR_preadv, sys_preadv), // 320
1831 LINX_(__NR_pwritev, sys_pwritev), // 321
1832 LINXY(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo),// 322
1833
1834 LINXY(__NR_process_vm_readv, sys_process_vm_readv), // 351
1835 LINX_(__NR_process_vm_writev, sys_process_vm_writev) // 352
1836 };
1837
ML_(get_linux_syscall_entry)1838 SyscallTableEntry* ML_(get_linux_syscall_entry) ( UInt sysno )
1839 {
1840 const UInt syscall_table_size
1841 = sizeof(syscall_table) / sizeof(syscall_table[0]);
1842
1843 /* Is it in the contiguous initial section of the table? */
1844 if (sysno < syscall_table_size) {
1845 SyscallTableEntry* sys = &syscall_table[sysno];
1846 if (sys->before == NULL)
1847 return NULL; /* no entry */
1848 else
1849 return sys;
1850 }
1851
1852 /* Can't find a wrapper */
1853 return NULL;
1854 }
1855
1856 #endif // defined(VGP_ppc32_linux)
1857
1858 /*--------------------------------------------------------------------*/
1859 /*--- end ---*/
1860 /*--------------------------------------------------------------------*/
1861