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