1
2 /*--------------------------------------------------------------------*/
3 /*--- Platform-specific syscalls stuff. syswrap-arm64-linux.c -----*/
4 /*--------------------------------------------------------------------*/
5
6 /*
7 This file is part of Valgrind, a dynamic binary instrumentation
8 framework.
9
10 Copyright (C) 2013-2013 OpenWorks
11 info@open-works.net
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_arm64_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 //ZZ #include "pub_core_debuglog.h"
40 #include "pub_core_libcbase.h"
41 #include "pub_core_libcassert.h"
42 #include "pub_core_libcprint.h"
43 //ZZ #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 //ZZ #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 //ZZ #include "pub_core_transtab.h" // VG_(discard_translations)
54
55 #include "priv_types_n_macros.h"
56 #include "priv_syswrap-generic.h" /* for decls of generic wrappers */
57 #include "priv_syswrap-linux.h" /* for decls of linux-ish wrappers */
58 //ZZ #include "priv_syswrap-main.h"
59
60
61 /* ---------------------------------------------------------------------
62 clone() handling
63 ------------------------------------------------------------------ */
64
65 /* Call f(arg1), but first switch stacks, using 'stack' as the new
66 stack, and use 'retaddr' as f's return-to address. Also, clear all
67 the integer registers before entering f.*/
68 __attribute__((noreturn))
69 void ML_(call_on_new_stack_0_1) ( Addr stack,
70 Addr retaddr,
71 void (*f)(Word),
72 Word arg1 );
73 // r0 = stack
74 // r1 = retaddr
75 // r2 = f
76 // r3 = arg1
77 asm(
78 ".text\n"
79 ".globl vgModuleLocal_call_on_new_stack_0_1\n"
80 "vgModuleLocal_call_on_new_stack_0_1:\n"
81 " mov sp, x0\n\t" /* Stack pointer */
82 " mov x30, x1\n\t" /* Return address (x30 is LR) */
83 " mov x0, x3\n\t" /* First argument */
84 " mov x9, x2\n\t" /* 'f': x9 won't be zeroed at start of f. Oh well. */
85 " mov x1, #0\n\t" /* Clear our GPRs */
86 " mov x2, #0\n\t"
87 " mov x3, #0\n\t"
88 " mov x4, #0\n\t"
89 " mov x5, #0\n\t"
90 " mov x6, #0\n\t"
91 " mov x7, #0\n\t"
92 " mov x8, #0\n\t"
93 /* don't zero out x9 */
94 " mov x10, #0\n\t"
95 " mov x11, #0\n\t"
96 " mov x12, #0\n\t"
97 " mov x13, #0\n\t"
98 " mov x14, #0\n\t"
99 " mov x15, #0\n\t"
100 " mov x16, #0\n\t"
101 " mov x17, #0\n\t"
102 " mov x18, #0\n\t"
103 " mov x19, #0\n\t"
104 " mov x20, #0\n\t"
105 " mov x21, #0\n\t"
106 " mov x22, #0\n\t"
107 " mov x23, #0\n\t"
108 " mov x24, #0\n\t"
109 " mov x25, #0\n\t"
110 " mov x26, #0\n\t"
111 " mov x27, #0\n\t"
112 " mov x28, #0\n\t"
113 " mov x29, sp\n\t" /* FP = SP, in the absence of better suggestions */
114 " br x9\n\t"
115 ".previous\n"
116 );
117
118
119 /*
120 Perform a clone system call. clone is strange because it has
121 fork()-like return-twice semantics, so it needs special
122 handling here.
123
124 Upon entry, we have:
125
126 Word (*fn)(void*) in x0
127 void* child_stack in x1
128 int flags in x2
129 void* arg in x3
130 pid_t* child_tid in x4
131 pid_t* parent_tid in x5
132 void* tls_ptr in x6
133
134 System call requires:
135
136 int $__NR_clone in x8
137 int flags in x0
138 void* child_stack in x1
139 pid_t* parent_tid in x2
140 void* tls_ptr in x3
141 pid_t* child_tid in x4
142
143 Returns a Long encoded in the linux-arm64 way, not a SysRes.
144 */
145 #define __NR_CLONE VG_STRINGIFY(__NR_clone)
146 #define __NR_EXIT VG_STRINGIFY(__NR_exit)
147
148 extern
149 Long do_syscall_clone_arm64_linux ( Word (*fn)(void *),
150 void* child_stack,
151 Long flags,
152 void* arg,
153 Int* child_tid,
154 Int* parent_tid,
155 void* tls );
156 asm(
157 ".text\n"
158 ".globl do_syscall_clone_arm64_linux\n"
159 "do_syscall_clone_arm64_linux:\n"
160 // set up child stack, temporarily preserving fn and arg
161 " sub x1, x1, #16\n" // make space on stack
162 " str x3, [x1, #8]\n" // save arg
163 " str x0, [x1, #0]\n" // save fn
164
165 // setup syscall
166 " mov x8, #"__NR_CLONE"\n" // syscall number
167 " mov x0, x2\n" // syscall arg1: flags
168 " mov x1, x1\n" // syscall arg2: child_stack
169 " mov x2, x5\n" // syscall arg3: parent_tid
170 " mov x3, x6\n" // syscall arg4: tls_ptr
171 " mov x4, x4\n" // syscall arg5: child_tid
172
173 " svc 0\n" // clone()
174
175 " cmp x0, #0\n" // child if retval == 0
176 " bne 1f\n"
177
178 // CHILD - call thread function
179 " ldr x1, [sp, #0]\n" // pop fn
180 " ldr x0, [sp, #8]\n" // pop fn arg1: arg
181 " add sp, sp, #16\n"
182 " blr x1\n" // call fn
183
184 // exit with result
185 " mov x0, x0\n" // arg1: return value from fn
186 " mov x8, #"__NR_EXIT"\n"
187
188 " svc 0\n"
189
190 // Exit returned?!
191 " .word 0xFFFFFFFF\n"
192
193 "1:\n" // PARENT or ERROR. x0 holds return value from the clone syscall.
194 " ret\n"
195 ".previous\n"
196 );
197
198 #undef __NR_CLONE
199 #undef __NR_EXIT
200
201 // forward declaration
202 static void setup_child ( ThreadArchState*, ThreadArchState* );
203 static void assign_guest_tls(ThreadId ctid, Addr tlsptr);
204 //ZZ static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr );
205
206 /*
207 When a client clones, we need to keep track of the new thread. This means:
208 1. allocate a ThreadId+ThreadState+stack for the the thread
209
210 2. initialize the thread's new VCPU state
211
212 3. create the thread using the same args as the client requested,
213 but using the scheduler entrypoint for IP, and a separate stack
214 for SP.
215 */
do_clone(ThreadId ptid,ULong flags,Addr child_xsp,Int * parent_tidptr,Int * child_tidptr,Addr child_tls)216 static SysRes do_clone ( ThreadId ptid,
217 ULong flags,
218 Addr child_xsp,
219 Int* parent_tidptr,
220 Int* child_tidptr,
221 Addr child_tls )
222 {
223 const Bool debug = False;
224
225 ThreadId ctid = VG_(alloc_ThreadState)();
226 ThreadState* ptst = VG_(get_ThreadState)(ptid);
227 ThreadState* ctst = VG_(get_ThreadState)(ctid);
228 UWord* stack;
229 NSegment const* seg;
230 SysRes res;
231 ULong x0;
232 vki_sigset_t blockall, savedmask;
233
234 VG_(sigfillset)(&blockall);
235
236 vg_assert(VG_(is_running_thread)(ptid));
237 vg_assert(VG_(is_valid_tid)(ctid));
238
239 stack = (UWord*)ML_(allocstack)(ctid);
240 if (stack == NULL) {
241 res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
242 goto out;
243 }
244
245 /* Copy register state
246
247 Both parent and child return to the same place, and the code
248 following the clone syscall works out which is which, so we
249 don't need to worry about it.
250
251 The parent gets the child's new tid returned from clone, but the
252 child gets 0.
253
254 If the clone call specifies a NULL xsp for the new thread, then
255 it actually gets a copy of the parent's xsp.
256 */
257 setup_child( &ctst->arch, &ptst->arch );
258
259 /* Make sys_clone appear to have returned Success(0) in the
260 child. */
261 ctst->arch.vex.guest_X0 = 0;
262
263 if (child_xsp != 0)
264 ctst->arch.vex.guest_XSP = child_xsp;
265
266 ctst->os_state.parent = ptid;
267
268 /* inherit signal mask */
269 ctst->sig_mask = ptst->sig_mask;
270 ctst->tmp_sig_mask = ptst->sig_mask;
271
272 /* Start the child with its threadgroup being the same as the
273 parent's. This is so that any exit_group calls that happen
274 after the child is created but before it sets its
275 os_state.threadgroup field for real (in thread_wrapper in
276 syswrap-linux.c), really kill the new thread. a.k.a this avoids
277 a race condition in which the thread is unkillable (via
278 exit_group) because its threadgroup is not set. The race window
279 is probably only a few hundred or a few thousand cycles long.
280 See #226116. */
281 ctst->os_state.threadgroup = ptst->os_state.threadgroup;
282
283 /* We don't really know where the client stack is, because its
284 allocated by the client. The best we can do is look at the
285 memory mappings and try to derive some useful information. We
286 assume that xsp starts near its highest possible value, and can
287 only go down to the start of the mmaped segment. */
288 seg = VG_(am_find_nsegment)((Addr)child_xsp);
289 if (seg && seg->kind != SkResvn) {
290 ctst->client_stack_highest_word = (Addr)VG_PGROUNDUP(child_xsp);
291 ctst->client_stack_szB = ctst->client_stack_highest_word - seg->start;
292
293 VG_(register_stack)(seg->start, ctst->client_stack_highest_word);
294
295 if (debug)
296 VG_(printf)("tid %d: guessed client stack range %#lx-%#lx\n",
297 ctid, seg->start, VG_PGROUNDUP(child_xsp));
298 } else {
299 VG_(message)(
300 Vg_UserMsg,
301 "!? New thread %d starts with sp+%#lx) unmapped\n", ctid, child_xsp
302 );
303 ctst->client_stack_szB = 0;
304 }
305
306 /* Assume the clone will succeed, and tell any tool that wants to
307 know that this thread has come into existence. If the clone
308 fails, we'll send out a ll_exit notification for it at the out:
309 label below, to clean up. */
310 vg_assert(VG_(owns_BigLock_LL)(ptid));
311 VG_TRACK ( pre_thread_ll_create, ptid, ctid );
312
313 if (flags & VKI_CLONE_SETTLS) {
314 /* Just assign the tls pointer in the guest TPIDR_EL0. */
315 assign_guest_tls(ctid, child_tls);
316 }
317
318 flags &= ~VKI_CLONE_SETTLS;
319
320 /* start the thread with everything blocked */
321 VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
322
323 x0 = do_syscall_clone_arm64_linux(
324 ML_(start_thread_NORETURN), stack, flags, &VG_(threads)[ctid],
325 child_tidptr, parent_tidptr, NULL
326 );
327
328 res = VG_(mk_SysRes_arm64_linux)( x0 );
329
330 VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
331
332 out:
333 if (sr_isError(res)) {
334 /* clone failed */
335 VG_(cleanup_thread)(&ctst->arch);
336 ctst->status = VgTs_Empty;
337 /* oops. Better tell the tool the thread exited in a hurry :-) */
338 VG_TRACK( pre_thread_ll_exit, ctid );
339 }
340
341 return res;
342 }
343
344
345 /* ---------------------------------------------------------------------
346 More thread stuff
347 ------------------------------------------------------------------ */
348
349 // ARM64 doesn't have any architecture specific thread stuff that
350 // needs to be cleaned up
VG_(cleanup_thread)351 void VG_(cleanup_thread) ( ThreadArchState* arch )
352 {
353 }
354
setup_child(ThreadArchState * child,ThreadArchState * parent)355 void setup_child ( /*OUT*/ ThreadArchState *child,
356 /*IN*/ ThreadArchState *parent )
357 {
358 child->vex = parent->vex;
359 child->vex_shadow1 = parent->vex_shadow1;
360 child->vex_shadow2 = parent->vex_shadow2;
361 }
362
assign_guest_tls(ThreadId tid,Addr tlsptr)363 static void assign_guest_tls(ThreadId tid, Addr tlsptr)
364 {
365 VG_(threads)[tid].arch.vex.guest_TPIDR_EL0 = tlsptr;
366 }
367
368 //ZZ /* Assigns tlsptr to the guest TPIDRURO.
369 //ZZ If needed for the specific hardware, really executes
370 //ZZ the set_tls syscall.
371 //ZZ */
372 //ZZ static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr )
373 //ZZ {
374 //ZZ assign_guest_tls(tid, tlsptr);
375 //ZZ #if defined(ANDROID_HARDWARE_emulator)
376 //ZZ /* Android emulator does not provide an hw tls register.
377 //ZZ So, the tls register is emulated by the kernel.
378 //ZZ This emulated value is set by the __NR_ARM_set_tls syscall.
379 //ZZ The emulated value must be read by the kernel helper function
380 //ZZ located at 0xffff0fe0.
381 //ZZ
382 //ZZ The emulated tlsptr is located at 0xffff0ff0
383 //ZZ (so slightly after the kernel helper function).
384 //ZZ Note that applications are not supposed to read this directly.
385 //ZZ
386 //ZZ For compatibility : if there is a hw tls register, the kernel
387 //ZZ will put at 0xffff0fe0 the instructions to read it, so
388 //ZZ as to have old applications calling the kernel helper
389 //ZZ working properly.
390 //ZZ
391 //ZZ For having emulated guest TLS working correctly with
392 //ZZ Valgrind, it is needed to execute the syscall to set
393 //ZZ the emulated TLS value in addition to the assignment
394 //ZZ of TPIDRURO.
395 //ZZ
396 //ZZ Note: the below means that if we need thread local storage
397 //ZZ for Valgrind host, then there will be a conflict between
398 //ZZ the need of the guest tls and of the host tls.
399 //ZZ If all the guest code would cleanly call 0xffff0fe0,
400 //ZZ then we might maybe intercept this. However, at least
401 //ZZ __libc_preinit reads directly 0xffff0ff0.
402 //ZZ */
403 //ZZ /* ??? might call the below if auxv->u.a_val & VKI_HWCAP_TLS ???
404 //ZZ Unclear if real hardware having tls hw register sets
405 //ZZ VKI_HWCAP_TLS. */
406 //ZZ return VG_(do_syscall1) (__NR_ARM_set_tls, tlsptr);
407 //ZZ #else
408 //ZZ return VG_(mk_SysRes_Success)( 0 );
409 //ZZ #endif
410 //ZZ }
411
412 /* ---------------------------------------------------------------------
413 PRE/POST wrappers for arm/Linux-specific syscalls
414 ------------------------------------------------------------------ */
415
416 #define PRE(name) DEFN_PRE_TEMPLATE(arm64_linux, name)
417 #define POST(name) DEFN_POST_TEMPLATE(arm64_linux, name)
418
419 /* Add prototypes for the wrappers declared here, so that gcc doesn't
420 harass us for not having prototypes. Really this is a kludge --
421 the right thing to do is to make these wrappers 'static' since they
422 aren't visible outside this file, but that requires even more macro
423 magic. */
424
425 DECL_TEMPLATE(arm64_linux, sys_fadvise64);
426 DECL_TEMPLATE(arm64_linux, sys_mmap);
427 //ZZ DECL_TEMPLATE(arm_linux, sys_stat64);
428 //ZZ DECL_TEMPLATE(arm_linux, sys_lstat64);
429 //ZZ DECL_TEMPLATE(arm_linux, sys_fstatat64);
430 //ZZ DECL_TEMPLATE(arm_linux, sys_fstat64);
431 DECL_TEMPLATE(arm64_linux, sys_clone);
432 //ZZ DECL_TEMPLATE(arm_linux, sys_sigreturn);
433 DECL_TEMPLATE(arm64_linux, sys_rt_sigreturn);
434 //ZZ DECL_TEMPLATE(arm_linux, sys_sigsuspend);
435 //ZZ DECL_TEMPLATE(arm_linux, sys_set_tls);
436 //ZZ DECL_TEMPLATE(arm_linux, sys_cacheflush);
437 //ZZ DECL_TEMPLATE(arm_linux, sys_ptrace);
438
439 //ZZ PRE(sys_mmap2)
440 //ZZ {
441 //ZZ SysRes r;
442 //ZZ
443 //ZZ // Exactly like old_mmap() except:
444 //ZZ // - all 6 args are passed in regs, rather than in a memory-block.
445 //ZZ // - the file offset is specified in pagesize units rather than bytes,
446 //ZZ // so that it can be used for files bigger than 2^32 bytes.
447 //ZZ // pagesize or 4K-size units in offset? For ppc32/64-linux, this is
448 //ZZ // 4K-sized. Assert that the page size is 4K here for safety.
449 //ZZ vg_assert(VKI_PAGE_SIZE == 4096);
450 //ZZ PRINT("sys_mmap2 ( %#lx, %llu, %ld, %ld, %ld, %ld )",
451 //ZZ ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 );
452 //ZZ PRE_REG_READ6(long, "mmap2",
453 //ZZ unsigned long, start, unsigned long, length,
454 //ZZ unsigned long, prot, unsigned long, flags,
455 //ZZ unsigned long, fd, unsigned long, offset);
456 //ZZ
457 //ZZ r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5,
458 //ZZ 4096 * (Off64T)ARG6 );
459 //ZZ SET_STATUS_from_SysRes(r);
460 //ZZ }
461
462 // ARM64 FIXME is this correct?
PRE(sys_fadvise64)463 PRE(sys_fadvise64)
464 {
465 PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", ARG1,ARG2,ARG3,ARG4);
466 PRE_REG_READ4(long, "fadvise64",
467 int, fd, vki_loff_t, offset, vki_size_t, len, int, advice);
468 }
469
470 // ARM64 FIXME is this correct?
PRE(sys_mmap)471 PRE(sys_mmap)
472 {
473 SysRes r;
474
475 PRINT("sys_mmap ( %#lx, %llu, %ld, %ld, %d, %ld )",
476 ARG1, (ULong)ARG2, ARG3, ARG4, (Int)ARG5, ARG6 );
477 PRE_REG_READ6(long, "mmap",
478 unsigned long, start, unsigned long, length,
479 unsigned long, prot, unsigned long, flags,
480 unsigned long, fd, unsigned long, offset);
481
482 r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
483 SET_STATUS_from_SysRes(r);
484 }
485
486 //ZZ
487 //ZZ // XXX: lstat64/fstat64/stat64 are generic, but not necessarily
488 //ZZ // applicable to every architecture -- I think only to 32-bit archs.
489 //ZZ // We're going to need something like linux/core_os32.h for such
490 //ZZ // things, eventually, I think. --njn
491 //ZZ PRE(sys_lstat64)
492 //ZZ {
493 //ZZ PRINT("sys_lstat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
494 //ZZ PRE_REG_READ2(long, "lstat64", char *, file_name, struct stat64 *, buf);
495 //ZZ PRE_MEM_RASCIIZ( "lstat64(file_name)", ARG1 );
496 //ZZ PRE_MEM_WRITE( "lstat64(buf)", ARG2, sizeof(struct vki_stat64) );
497 //ZZ }
498 //ZZ
499 //ZZ POST(sys_lstat64)
500 //ZZ {
501 //ZZ vg_assert(SUCCESS);
502 //ZZ if (RES == 0) {
503 //ZZ POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
504 //ZZ }
505 //ZZ }
506 //ZZ
507 //ZZ PRE(sys_stat64)
508 //ZZ {
509 //ZZ PRINT("sys_stat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
510 //ZZ PRE_REG_READ2(long, "stat64", char *, file_name, struct stat64 *, buf);
511 //ZZ PRE_MEM_RASCIIZ( "stat64(file_name)", ARG1 );
512 //ZZ PRE_MEM_WRITE( "stat64(buf)", ARG2, sizeof(struct vki_stat64) );
513 //ZZ }
514 //ZZ
515 //ZZ POST(sys_stat64)
516 //ZZ {
517 //ZZ POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
518 //ZZ }
519 //ZZ
520 //ZZ PRE(sys_fstatat64)
521 //ZZ {
522 //ZZ PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx )",ARG1,ARG2,(char*)ARG2,ARG3);
523 //ZZ PRE_REG_READ3(long, "fstatat64",
524 //ZZ int, dfd, char *, file_name, struct stat64 *, buf);
525 //ZZ PRE_MEM_RASCIIZ( "fstatat64(file_name)", ARG2 );
526 //ZZ PRE_MEM_WRITE( "fstatat64(buf)", ARG3, sizeof(struct vki_stat64) );
527 //ZZ }
528 //ZZ
529 //ZZ POST(sys_fstatat64)
530 //ZZ {
531 //ZZ POST_MEM_WRITE( ARG3, sizeof(struct vki_stat64) );
532 //ZZ }
533 //ZZ
534 //ZZ PRE(sys_fstat64)
535 //ZZ {
536 //ZZ PRINT("sys_fstat64 ( %ld, %#lx )",ARG1,ARG2);
537 //ZZ PRE_REG_READ2(long, "fstat64", unsigned long, fd, struct stat64 *, buf);
538 //ZZ PRE_MEM_WRITE( "fstat64(buf)", ARG2, sizeof(struct vki_stat64) );
539 //ZZ }
540 //ZZ
541 //ZZ POST(sys_fstat64)
542 //ZZ {
543 //ZZ POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
544 //ZZ }
545
546 /* Aarch64 seems to use CONFIG_CLONE_BACKWARDS in the kernel. See:
547 http://dev.gentoo.org/~vapier/aarch64/linux-3.12.6.config
548 http://people.redhat.com/wcohen/aarch64/aarch64_config
549 from linux-3.10.5/kernel/fork.c
550 #ifdef CONFIG_CLONE_BACKWARDS
551 SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
552 int __user *, parent_tidptr,
553 int, tls_val,
554 int __user *, child_tidptr)
555 */
PRE(sys_clone)556 PRE(sys_clone)
557 {
558 UInt cloneflags;
559
560 PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
561 PRE_REG_READ5(int, "clone",
562 unsigned long, flags,
563 void *, child_stack,
564 int *, parent_tidptr,
565 void *, child_tls,
566 int *, child_tidptr);
567
568 if (ARG1 & VKI_CLONE_PARENT_SETTID) {
569 PRE_MEM_WRITE("clone(parent_tidptr)", ARG3, sizeof(Int));
570 if (!VG_(am_is_valid_for_client)(ARG3, sizeof(Int),
571 VKI_PROT_WRITE)) {
572 SET_STATUS_Failure( VKI_EFAULT );
573 return;
574 }
575 }
576 //ZZ if (ARG1 & VKI_CLONE_SETTLS) {
577 //ZZ PRE_MEM_READ("clone(tls_user_desc)", ARG4, sizeof(vki_modify_ldt_t));
578 //ZZ if (!VG_(am_is_valid_for_client)(ARG4, sizeof(vki_modify_ldt_t),
579 //ZZ VKI_PROT_READ)) {
580 //ZZ SET_STATUS_Failure( VKI_EFAULT );
581 //ZZ return;
582 //ZZ }
583 //ZZ }
584 if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
585 PRE_MEM_WRITE("clone(child_tidptr)", ARG5, sizeof(Int));
586 if (!VG_(am_is_valid_for_client)(ARG5, sizeof(Int),
587 VKI_PROT_WRITE)) {
588 SET_STATUS_Failure( VKI_EFAULT );
589 return;
590 }
591 }
592
593 cloneflags = ARG1;
594
595 if (!ML_(client_signal_OK)(ARG1 & VKI_CSIGNAL)) {
596 SET_STATUS_Failure( VKI_EINVAL );
597 return;
598 }
599
600 /* Only look at the flags we really care about */
601 switch (cloneflags & (VKI_CLONE_VM | VKI_CLONE_FS
602 | VKI_CLONE_FILES | VKI_CLONE_VFORK)) {
603 case VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES:
604 /* thread creation */
605 SET_STATUS_from_SysRes(
606 do_clone(tid,
607 ARG1, /* flags */
608 (Addr)ARG2, /* child SP */
609 (Int*)ARG3, /* parent_tidptr */
610 (Int*)ARG5, /* child_tidptr */
611 (Addr)ARG4)); /* tls_val */
612 break;
613
614 case VKI_CLONE_VFORK | VKI_CLONE_VM: /* vfork */
615 /* FALLTHROUGH - assume vfork == fork */
616 cloneflags &= ~(VKI_CLONE_VFORK | VKI_CLONE_VM);
617
618 case 0: /* plain fork */
619 SET_STATUS_from_SysRes(
620 ML_(do_fork_clone)(tid,
621 cloneflags, /* flags */
622 (Int*)ARG3, /* parent_tidptr */
623 (Int*)ARG5)); /* child_tidptr */
624 break;
625
626 default:
627 /* should we just ENOSYS? */
628 VG_(message)(Vg_UserMsg, "");
629 VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx", ARG1);
630 VG_(message)(Vg_UserMsg, "");
631 VG_(message)(Vg_UserMsg, "The only supported clone() uses are:");
632 VG_(message)(Vg_UserMsg, " - via a threads library (LinuxThreads or NPTL)");
633 VG_(message)(Vg_UserMsg, " - via the implementation of fork or vfork");
634 VG_(message)(Vg_UserMsg, " - for the Quadrics Elan3 user-space driver");
635 VG_(unimplemented)
636 ("Valgrind does not support general clone().");
637 }
638
639 if (SUCCESS) {
640 if (ARG1 & VKI_CLONE_PARENT_SETTID)
641 POST_MEM_WRITE(ARG3, sizeof(Int));
642 if (ARG1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
643 POST_MEM_WRITE(ARG5, sizeof(Int));
644
645 /* Thread creation was successful; let the child have the chance
646 to run */
647 *flags |= SfYieldAfter;
648 }
649 }
650
651 //ZZ PRE(sys_sigreturn)
652 //ZZ {
653 //ZZ /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
654 //ZZ an explanation of what follows. */
655 //ZZ
656 //ZZ PRINT("sys_sigreturn ( )");
657 //ZZ
658 //ZZ vg_assert(VG_(is_valid_tid)(tid));
659 //ZZ vg_assert(tid >= 1 && tid < VG_N_THREADS);
660 //ZZ vg_assert(VG_(is_running_thread)(tid));
661 //ZZ
662 //ZZ /* Restore register state from frame and remove it */
663 //ZZ VG_(sigframe_destroy)(tid, False);
664 //ZZ
665 //ZZ /* Tell the driver not to update the guest state with the "result",
666 //ZZ and set a bogus result to keep it happy. */
667 //ZZ *flags |= SfNoWriteResult;
668 //ZZ SET_STATUS_Success(0);
669 //ZZ
670 //ZZ /* Check to see if any signals arose as a result of this. */
671 //ZZ *flags |= SfPollAfter;
672 //ZZ }
673
PRE(sys_rt_sigreturn)674 PRE(sys_rt_sigreturn)
675 {
676 /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
677 an explanation of what follows. */
678
679 PRINT("rt_sigreturn ( )");
680
681 vg_assert(VG_(is_valid_tid)(tid));
682 vg_assert(tid >= 1 && tid < VG_N_THREADS);
683 vg_assert(VG_(is_running_thread)(tid));
684
685 /* Restore register state from frame and remove it */
686 VG_(sigframe_destroy)(tid, True);
687
688 /* Tell the driver not to update the guest state with the "result",
689 and set a bogus result to keep it happy. */
690 *flags |= SfNoWriteResult;
691 SET_STATUS_Success(0);
692
693 /* Check to see if any signals arose as a result of this. */
694 *flags |= SfPollAfter;
695 }
696
697 //ZZ /* NB: clone of x86-linux version, and ppc32-linux has an almost
698 //ZZ identical one. */
699 //ZZ PRE(sys_sigsuspend)
700 //ZZ {
701 //ZZ /* The C library interface to sigsuspend just takes a pointer to
702 //ZZ a signal mask but this system call has three arguments - the first
703 //ZZ two don't appear to be used by the kernel and are always passed as
704 //ZZ zero by glibc and the third is the first word of the signal mask
705 //ZZ so only 32 signals are supported.
706 //ZZ
707 //ZZ In fact glibc normally uses rt_sigsuspend if it is available as
708 //ZZ that takes a pointer to the signal mask so supports more signals.
709 //ZZ */
710 //ZZ *flags |= SfMayBlock;
711 //ZZ PRINT("sys_sigsuspend ( %ld, %ld, %ld )", ARG1,ARG2,ARG3 );
712 //ZZ PRE_REG_READ3(int, "sigsuspend",
713 //ZZ int, history0, int, history1,
714 //ZZ vki_old_sigset_t, mask);
715 //ZZ }
716 //ZZ
717 //ZZ /* Very much ARM specific */
718 //ZZ
719 //ZZ PRE(sys_set_tls)
720 //ZZ {
721 //ZZ PRINT("set_tls (%lx)",ARG1);
722 //ZZ PRE_REG_READ1(long, "set_tls", unsigned long, addr);
723 //ZZ
724 //ZZ SET_STATUS_from_SysRes( sys_set_tls( tid, ARG1 ) );
725 //ZZ }
726 //ZZ
727 //ZZ PRE(sys_cacheflush)
728 //ZZ {
729 //ZZ PRINT("cacheflush (%lx, %#lx, %#lx)",ARG1,ARG2,ARG3);
730 //ZZ PRE_REG_READ3(long, "cacheflush", void*, addrlow,void*, addrhigh,int, flags);
731 //ZZ VG_(discard_translations)( (Addr64)ARG1,
732 //ZZ ((ULong)ARG2) - ((ULong)ARG1) + 1ULL/*paranoia*/,
733 //ZZ "PRE(sys_cacheflush)" );
734 //ZZ SET_STATUS_Success(0);
735 //ZZ }
736 //ZZ
737 //ZZ // ARG3 is only used for pointers into the traced process's address
738 //ZZ // space and for offsets into the traced process's struct
739 //ZZ // user_regs_struct. It is never a pointer into this process's memory
740 //ZZ // space, and we should therefore not check anything it points to.
741 //ZZ PRE(sys_ptrace)
742 //ZZ {
743 //ZZ PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4);
744 //ZZ PRE_REG_READ4(int, "ptrace",
745 //ZZ long, request, long, pid, long, addr, long, data);
746 //ZZ switch (ARG1) {
747 //ZZ case VKI_PTRACE_PEEKTEXT:
748 //ZZ case VKI_PTRACE_PEEKDATA:
749 //ZZ case VKI_PTRACE_PEEKUSR:
750 //ZZ PRE_MEM_WRITE( "ptrace(peek)", ARG4,
751 //ZZ sizeof (long));
752 //ZZ break;
753 //ZZ case VKI_PTRACE_GETREGS:
754 //ZZ PRE_MEM_WRITE( "ptrace(getregs)", ARG4,
755 //ZZ sizeof (struct vki_user_regs_struct));
756 //ZZ break;
757 //ZZ case VKI_PTRACE_GETFPREGS:
758 //ZZ PRE_MEM_WRITE( "ptrace(getfpregs)", ARG4,
759 //ZZ sizeof (struct vki_user_fp));
760 //ZZ break;
761 //ZZ case VKI_PTRACE_GETWMMXREGS:
762 //ZZ PRE_MEM_WRITE( "ptrace(getwmmxregs)", ARG4,
763 //ZZ VKI_IWMMXT_SIZE);
764 //ZZ break;
765 //ZZ case VKI_PTRACE_GETCRUNCHREGS:
766 //ZZ PRE_MEM_WRITE( "ptrace(getcrunchregs)", ARG4,
767 //ZZ VKI_CRUNCH_SIZE);
768 //ZZ break;
769 //ZZ case VKI_PTRACE_GETVFPREGS:
770 //ZZ PRE_MEM_WRITE( "ptrace(getvfpregs)", ARG4,
771 //ZZ sizeof (struct vki_user_vfp) );
772 //ZZ break;
773 //ZZ case VKI_PTRACE_GETHBPREGS:
774 //ZZ PRE_MEM_WRITE( "ptrace(gethbpregs)", ARG4,
775 //ZZ sizeof (unsigned long) );
776 //ZZ break;
777 //ZZ case VKI_PTRACE_SETREGS:
778 //ZZ PRE_MEM_READ( "ptrace(setregs)", ARG4,
779 //ZZ sizeof (struct vki_user_regs_struct));
780 //ZZ break;
781 //ZZ case VKI_PTRACE_SETFPREGS:
782 //ZZ PRE_MEM_READ( "ptrace(setfpregs)", ARG4,
783 //ZZ sizeof (struct vki_user_fp));
784 //ZZ break;
785 //ZZ case VKI_PTRACE_SETWMMXREGS:
786 //ZZ PRE_MEM_READ( "ptrace(setwmmxregs)", ARG4,
787 //ZZ VKI_IWMMXT_SIZE);
788 //ZZ break;
789 //ZZ case VKI_PTRACE_SETCRUNCHREGS:
790 //ZZ PRE_MEM_READ( "ptrace(setcrunchregs)", ARG4,
791 //ZZ VKI_CRUNCH_SIZE);
792 //ZZ break;
793 //ZZ case VKI_PTRACE_SETVFPREGS:
794 //ZZ PRE_MEM_READ( "ptrace(setvfpregs)", ARG4,
795 //ZZ sizeof (struct vki_user_vfp));
796 //ZZ break;
797 //ZZ case VKI_PTRACE_SETHBPREGS:
798 //ZZ PRE_MEM_READ( "ptrace(sethbpregs)", ARG4, sizeof(unsigned long));
799 //ZZ break;
800 //ZZ case VKI_PTRACE_GET_THREAD_AREA:
801 //ZZ PRE_MEM_WRITE( "ptrace(get_thread_area)", ARG4, sizeof(unsigned long));
802 //ZZ break;
803 //ZZ case VKI_PTRACE_GETEVENTMSG:
804 //ZZ PRE_MEM_WRITE( "ptrace(geteventmsg)", ARG4, sizeof(unsigned long));
805 //ZZ break;
806 //ZZ case VKI_PTRACE_GETSIGINFO:
807 //ZZ PRE_MEM_WRITE( "ptrace(getsiginfo)", ARG4, sizeof(vki_siginfo_t));
808 //ZZ break;
809 //ZZ case VKI_PTRACE_SETSIGINFO:
810 //ZZ PRE_MEM_READ( "ptrace(setsiginfo)", ARG4, sizeof(vki_siginfo_t));
811 //ZZ break;
812 //ZZ case VKI_PTRACE_GETREGSET:
813 //ZZ ML_(linux_PRE_getregset)(tid, ARG3, ARG4);
814 //ZZ break;
815 //ZZ case VKI_PTRACE_SETREGSET:
816 //ZZ ML_(linux_PRE_setregset)(tid, ARG3, ARG4);
817 //ZZ break;
818 //ZZ default:
819 //ZZ break;
820 //ZZ }
821 //ZZ }
822 //ZZ
823 //ZZ POST(sys_ptrace)
824 //ZZ {
825 //ZZ switch (ARG1) {
826 //ZZ case VKI_PTRACE_PEEKTEXT:
827 //ZZ case VKI_PTRACE_PEEKDATA:
828 //ZZ case VKI_PTRACE_PEEKUSR:
829 //ZZ POST_MEM_WRITE( ARG4, sizeof (long));
830 //ZZ break;
831 //ZZ case VKI_PTRACE_GETREGS:
832 //ZZ POST_MEM_WRITE( ARG4, sizeof (struct vki_user_regs_struct));
833 //ZZ break;
834 //ZZ case VKI_PTRACE_GETFPREGS:
835 //ZZ POST_MEM_WRITE( ARG4, sizeof (struct vki_user_fp));
836 //ZZ break;
837 //ZZ case VKI_PTRACE_GETWMMXREGS:
838 //ZZ POST_MEM_WRITE( ARG4, VKI_IWMMXT_SIZE);
839 //ZZ break;
840 //ZZ case VKI_PTRACE_GETCRUNCHREGS:
841 //ZZ POST_MEM_WRITE( ARG4, VKI_CRUNCH_SIZE);
842 //ZZ break;
843 //ZZ case VKI_PTRACE_GETVFPREGS:
844 //ZZ POST_MEM_WRITE( ARG4, sizeof(struct vki_user_vfp));
845 //ZZ break;
846 //ZZ case VKI_PTRACE_GET_THREAD_AREA:
847 //ZZ case VKI_PTRACE_GETHBPREGS:
848 //ZZ case VKI_PTRACE_GETEVENTMSG:
849 //ZZ POST_MEM_WRITE( ARG4, sizeof(unsigned long));
850 //ZZ break;
851 //ZZ case VKI_PTRACE_GETSIGINFO:
852 //ZZ /* XXX: This is a simplification. Different parts of the
853 //ZZ * siginfo_t are valid depending on the type of signal.
854 //ZZ */
855 //ZZ POST_MEM_WRITE( ARG4, sizeof(vki_siginfo_t));
856 //ZZ break;
857 //ZZ case VKI_PTRACE_GETREGSET:
858 //ZZ ML_(linux_POST_getregset)(tid, ARG3, ARG4);
859 //ZZ break;
860 //ZZ default:
861 //ZZ break;
862 //ZZ }
863 //ZZ }
864 //ZZ
865 //ZZ #undef PRE
866 //ZZ #undef POST
867
868 /* ---------------------------------------------------------------------
869 The arm64/Linux syscall table
870 ------------------------------------------------------------------ */
871
872 //ZZ #if 0
873 //ZZ #define __NR_OABI_SYSCALL_BASE 0x900000
874 //ZZ #else
875 //ZZ #define __NR_OABI_SYSCALL_BASE 0x0
876 //ZZ #endif
877
878 #define PLAX_(sysno, name) WRAPPER_ENTRY_X_(arm64_linux, sysno, name)
879 #define PLAXY(sysno, name) WRAPPER_ENTRY_XY(arm64_linux, sysno, name)
880
881 // This table maps from __NR_xxx syscall numbers (from
882 // linux/include/asm-arm/unistd.h) to the appropriate PRE/POST sys_foo()
883 // wrappers on arm64 (as per sys_call_table in linux/arch/arm/kernel/entry.S).
884 //
885 // For those syscalls not handled by Valgrind, the annotation indicate its
886 // arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/?
887 // (unknown).
888
889 static SyscallTableEntry syscall_main_table[] = {
890 LINXY(__NR_getxattr, sys_getxattr), // 8
891 LINXY(__NR_lgetxattr, sys_lgetxattr), // 9
892 GENXY(__NR_getcwd, sys_getcwd), // 17
893 LINXY(__NR_eventfd2, sys_eventfd2), // 19
894 LINXY(__NR_epoll_create1, sys_epoll_create1), // 20
895 LINX_(__NR_epoll_ctl, sys_epoll_ctl), // 21
896 LINXY(__NR_epoll_pwait, sys_epoll_pwait), // 22
897 GENXY(__NR_dup, sys_dup), // 23
898 LINXY(__NR_dup3, sys_dup3), // 24
899
900 // FIXME IS THIS CORRECT?
901 LINXY(__NR3264_fcntl, sys_fcntl), // 25
902
903 LINXY(__NR_inotify_init1, sys_inotify_init1), // 26
904 LINX_(__NR_inotify_add_watch, sys_inotify_add_watch), // 27
905 LINX_(__NR_inotify_rm_watch, sys_inotify_rm_watch), // 28
906 LINXY(__NR_ioctl, sys_ioctl), // 29
907 LINX_(__NR_mkdirat, sys_mkdirat), // 34
908 LINX_(__NR_unlinkat, sys_unlinkat), // 35
909 LINX_(__NR_symlinkat, sys_symlinkat), // 36
910 LINX_(__NR_linkat, sys_linkat), // 37
911 LINX_(__NR_renameat, sys_renameat), // 38
912
913 // FIXME IS THIS CORRECT? it may well not be.
914 GENXY(__NR3264_statfs, sys_statfs), // 43
915 GENXY(__NR3264_fstatfs, sys_fstatfs), // 44
916
917 // FIXME IS THIS CORRECT? it may well not be.
918 GENX_(__NR3264_ftruncate, sys_ftruncate), // 46
919
920 LINX_(__NR_fallocate, sys_fallocate), // 47
921 LINX_(__NR_faccessat, sys_faccessat), // 48
922 GENX_(__NR_chdir, sys_chdir), // 49
923 GENX_(__NR_fchmod, sys_fchmod), // 52
924 LINX_(__NR_fchmodat, sys_fchmodat), // 53
925 LINX_(__NR_fchownat, sys_fchownat), // 54
926 LINXY(__NR_openat, sys_openat), // 56
927 GENXY(__NR_close, sys_close), // 57
928 LINXY(__NR_pipe2, sys_pipe2), // 59
929 LINX_(__NR_quotactl, sys_quotactl), // 60
930 GENXY(__NR_getdents64, sys_getdents64), // 61
931
932 // FIXME IS THIS CORRECT?
933 LINX_(__NR3264_lseek, sys_lseek), // 62
934
935 GENXY(__NR_read, sys_read), // 63
936 GENX_(__NR_write, sys_write), // 64
937 GENXY(__NR_readv, sys_readv), // 65
938 GENX_(__NR_writev, sys_writev), // 66
939 GENXY(__NR_pread64, sys_pread64), // 67
940 GENX_(__NR_pwrite64, sys_pwrite64), // 68
941 LINX_(__NR_pselect6, sys_pselect6), // 72
942 LINXY(__NR_ppoll, sys_ppoll), // 73
943 LINXY(__NR_signalfd4, sys_signalfd4), // 74
944 LINX_(__NR_readlinkat, sys_readlinkat), // 78
945
946 // FIXME IS THIS CORRECT?
947 LINXY(__NR3264_fstatat, sys_newfstatat), // 79
948 GENXY(__NR3264_fstat, sys_newfstat), // 80
949
950 LINX_(__NR_utimensat, sys_utimensat), // 88
951 GENX_(__NR_fsync, sys_fsync), // 82
952 LINXY(__NR_timerfd_create, sys_timerfd_create), // 85
953 LINXY(__NR_timerfd_settime, sys_timerfd_settime), // 86
954 LINXY(__NR_timerfd_gettime, sys_timerfd_gettime), // 87
955 LINXY(__NR_capget, sys_capget), // 90
956 LINX_(__NR_capset, sys_capset), // 91
957 GENX_(__NR_exit, sys_exit), // 93
958 LINX_(__NR_exit_group, sys_exit_group), // 94
959 LINX_(__NR_set_tid_address, sys_set_tid_address), // 96
960 LINXY(__NR_futex, sys_futex), // 98
961 LINX_(__NR_set_robust_list, sys_set_robust_list), // 99
962 GENXY(__NR_nanosleep, sys_nanosleep), // 101
963 GENXY(__NR_setitimer, sys_setitimer), // 103
964 LINXY(__NR_clock_gettime, sys_clock_gettime), // 113
965 LINXY(__NR_clock_getres, sys_clock_getres), // 114
966 LINXY(__NR_syslog, sys_syslog), // 116
967 LINX_(__NR_sched_setaffinity, sys_sched_setaffinity), // 122
968 LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 123
969 LINX_(__NR_sched_yield, sys_sched_yield), // 124
970 GENX_(__NR_kill, sys_kill), // 129
971 LINX_(__NR_tgkill, sys_tgkill), // 131
972 GENXY(__NR_sigaltstack, sys_sigaltstack), // 132
973 LINX_(__NR_rt_sigsuspend, sys_rt_sigsuspend), // 133
974 LINXY(__NR_rt_sigaction, sys_rt_sigaction), // 134
975 LINXY(__NR_rt_sigprocmask, sys_rt_sigprocmask), // 135
976 LINXY(__NR_rt_sigtimedwait, sys_rt_sigtimedwait), // 137
977 LINXY(__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo), // 138
978 PLAX_(__NR_rt_sigreturn, sys_rt_sigreturn), // 139
979 GENX_(__NR_setpriority, sys_setpriority), // 140
980 GENX_(__NR_getpriority, sys_getpriority), // 141
981 GENX_(__NR_setregid, sys_setregid), // 143
982 GENX_(__NR_setreuid, sys_setreuid), // 145
983 LINX_(__NR_setresuid, sys_setresuid), // 147
984 LINXY(__NR_getresuid, sys_getresuid), // 148
985 LINXY(__NR_getresgid, sys_getresgid), // 150
986 GENX_(__NR_setpgid, sys_setpgid), // 154
987 GENX_(__NR_getpgid, sys_getpgid), // 155
988 GENXY(__NR_uname, sys_newuname), // 160
989 GENXY(__NR_getrlimit, sys_old_getrlimit), // 163
990 GENX_(__NR_setrlimit, sys_setrlimit), // 164
991 GENXY(__NR_getrusage, sys_getrusage), // 165
992 GENX_(__NR_umask, sys_umask), // 166
993 LINXY(__NR_prctl, sys_prctl), // 167
994 GENXY(__NR_gettimeofday, sys_gettimeofday), // 169
995 GENX_(__NR_getpid, sys_getpid), // 172
996 GENX_(__NR_getppid, sys_getppid), // 173
997 GENX_(__NR_getuid, sys_getuid), // 174
998 GENX_(__NR_geteuid, sys_geteuid), // 175
999 GENX_(__NR_getgid, sys_getgid), // 176
1000 GENX_(__NR_getegid, sys_getegid), // 177
1001 LINX_(__NR_gettid, sys_gettid), // 178
1002 LINXY(__NR_sysinfo, sys_sysinfo), // 179
1003 LINXY(__NR_mq_open, sys_mq_open), // 180
1004 LINX_(__NR_mq_unlink, sys_mq_unlink), // 181
1005 LINX_(__NR_mq_timedsend, sys_mq_timedsend), // 182
1006 LINXY(__NR_mq_timedreceive, sys_mq_timedreceive), // 183
1007 LINX_(__NR_mq_notify, sys_mq_notify), // 184
1008 LINXY(__NR_mq_getsetattr, sys_mq_getsetattr), // 185
1009 LINX_(__NR_semget, sys_semget), // 190
1010 LINXY(__NR_semctl, sys_semctl), // 191
1011 LINX_(__NR_semtimedop, sys_semtimedop), // 192
1012 LINX_(__NR_semop, sys_semop), // 193
1013 LINX_(__NR_shmget, sys_shmget), // 194
1014 LINXY(__NR_shmctl, sys_shmctl), // 195
1015 LINXY(__NR_shmat, wrap_sys_shmat), // 196
1016 LINXY(__NR_shmdt, sys_shmdt), // 197
1017 LINXY(__NR_socket, sys_socket), // 198
1018 LINXY(__NR_socketpair, sys_socketpair), // 199
1019 LINX_(__NR_bind, sys_bind), // 200
1020 LINX_(__NR_listen, sys_listen), // 201
1021 LINXY(__NR_accept, sys_accept), // 202
1022 LINX_(__NR_connect, sys_connect), // 203
1023 LINXY(__NR_getsockname, sys_getsockname), // 204
1024 LINXY(__NR_getpeername, sys_getpeername), // 205
1025 LINX_(__NR_sendto, sys_sendto), // 206
1026 LINXY(__NR_recvfrom, sys_recvfrom), // 207
1027 LINX_(__NR_setsockopt, sys_setsockopt), // 208
1028 LINXY(__NR_getsockopt, sys_getsockopt), // 209
1029 LINX_(__NR_shutdown, sys_shutdown), // 210
1030 LINX_(__NR_sendmsg, sys_sendmsg), // 211
1031 LINXY(__NR_recvmsg, sys_recvmsg), // 212
1032 LINX_(__NR_readahead, sys_readahead), // 213
1033 GENX_(__NR_brk, sys_brk), // 214
1034 GENXY(__NR_munmap, sys_munmap), // 215
1035 GENX_(__NR_mremap, sys_mremap), // 216
1036 LINX_(__NR_add_key, sys_add_key), // 217
1037 LINXY(__NR_keyctl, sys_keyctl), // 219
1038 PLAX_(__NR_clone, sys_clone), // 220
1039 GENX_(__NR_execve, sys_execve), // 221
1040
1041 // FIXME IS THIS CORRECT?
1042 PLAX_(__NR3264_mmap, sys_mmap), // 222
1043 PLAX_(__NR3264_fadvise64, sys_fadvise64), // 223
1044
1045 GENXY(__NR_mprotect, sys_mprotect), // 226
1046 GENX_(__NR_msync, sys_msync), // 227
1047 GENX_(__NR_madvise, sys_madvise), // 233
1048 GENXY(__NR_wait4, sys_wait4), // 260
1049
1050 LINXY(__NR_process_vm_readv, sys_process_vm_readv), // 270
1051 LINX_(__NR_process_vm_writev, sys_process_vm_writev), // 271
1052
1053 // The numbers below are bogus. (See comment further down.)
1054 // When pulling entries above this line, change the numbers
1055 // to be correct.
1056
1057 //ZZ //zz // (restart_syscall) // 0
1058 //ZZ GENX_(__NR_fork, sys_fork), // 2
1059 //ZZ
1060 //ZZ GENXY(__NR_open, sys_open), // 5
1061 //ZZ // GENXY(__NR_waitpid, sys_waitpid), // 7
1062 //ZZ GENXY(__NR_creat, sys_creat), // 8
1063 //ZZ GENX_(__NR_link, sys_link), // 9
1064 //ZZ
1065 //ZZ GENX_(__NR_unlink, sys_unlink), // 10
1066 //ZZ GENXY(__NR_time, sys_time), // 13
1067 //ZZ GENX_(__NR_mknod, sys_mknod), // 14
1068 //ZZ
1069 //ZZ GENX_(__NR_chmod, sys_chmod), // 15
1070 //ZZ //zz LINX_(__NR_lchown, sys_lchown16), // 16
1071 //ZZ // GENX_(__NR_break, sys_ni_syscall), // 17
1072 //ZZ //zz // (__NR_oldstat, sys_stat), // 18 (obsolete)
1073 //ZZ LINX_(__NR_lseek, sys_lseek), // 19
1074 //ZZ
1075 //ZZ GENX_(__NR_getpid, sys_getpid), // 20
1076 //ZZ LINX_(__NR_mount, sys_mount), // 21
1077 //ZZ LINX_(__NR_umount, sys_oldumount), // 22
1078 //ZZ LINX_(__NR_setuid, sys_setuid16), // 23 ## P
1079 //ZZ LINX_(__NR_getuid, sys_getuid16), // 24 ## P
1080 //ZZ //zz
1081 //ZZ //zz // (__NR_stime, sys_stime), // 25 * (SVr4,SVID,X/OPEN)
1082 //ZZ PLAXY(__NR_ptrace, sys_ptrace), // 26
1083 //ZZ GENX_(__NR_alarm, sys_alarm), // 27
1084 //ZZ //zz // (__NR_oldfstat, sys_fstat), // 28 * L -- obsolete
1085 //ZZ GENX_(__NR_pause, sys_pause), // 29
1086 //ZZ
1087 //ZZ LINX_(__NR_utime, sys_utime), // 30
1088 //ZZ // GENX_(__NR_stty, sys_ni_syscall), // 31
1089 //ZZ // GENX_(__NR_gtty, sys_ni_syscall), // 32
1090 //ZZ GENX_(__NR_access, sys_access), // 33
1091 //ZZ GENX_(__NR_nice, sys_nice), // 34
1092 //ZZ
1093 //ZZ // GENX_(__NR_ftime, sys_ni_syscall), // 35
1094 //ZZ GENX_(__NR_sync, sys_sync), // 36
1095 //ZZ GENX_(__NR_rename, sys_rename), // 38
1096 //ZZ GENX_(__NR_mkdir, sys_mkdir), // 39
1097 //ZZ
1098 //ZZ GENX_(__NR_rmdir, sys_rmdir), // 40
1099 //ZZ LINXY(__NR_pipe, sys_pipe), // 42
1100 //ZZ GENXY(__NR_times, sys_times), // 43
1101 //ZZ // GENX_(__NR_prof, sys_ni_syscall), // 44
1102
1103 //ZZ LINX_(__NR_setgid, sys_setgid16), // 46
1104 //ZZ LINX_(__NR_getgid, sys_getgid16), // 47
1105 //ZZ //zz // (__NR_signal, sys_signal), // 48 */* (ANSI C)
1106 //ZZ LINX_(__NR_geteuid, sys_geteuid16), // 49
1107 //ZZ
1108 //ZZ LINX_(__NR_getegid, sys_getegid16), // 50
1109 //ZZ GENX_(__NR_acct, sys_acct), // 51
1110 //ZZ LINX_(__NR_umount2, sys_umount), // 52
1111 //ZZ // GENX_(__NR_lock, sys_ni_syscall), // 53
1112 //ZZ
1113 //ZZ LINXY(__NR_fcntl, sys_fcntl), // 55
1114 //ZZ // GENX_(__NR_mpx, sys_ni_syscall), // 56
1115 //ZZ // GENX_(__NR_ulimit, sys_ni_syscall), // 58
1116 //ZZ //zz // (__NR_oldolduname, sys_olduname), // 59 Linux -- obsolete
1117 //ZZ //zz
1118 //ZZ GENX_(__NR_chroot, sys_chroot), // 61
1119 //ZZ //zz // (__NR_ustat, sys_ustat) // 62 SVr4 -- deprecated
1120 //ZZ GENXY(__NR_dup2, sys_dup2), // 63
1121 //ZZ GENX_(__NR_getppid, sys_getppid), // 64
1122 //ZZ
1123 //ZZ GENX_(__NR_getpgrp, sys_getpgrp), // 65
1124 //ZZ GENX_(__NR_setsid, sys_setsid), // 66
1125 //ZZ LINXY(__NR_sigaction, sys_sigaction), // 67
1126 //ZZ //zz // (__NR_sgetmask, sys_sgetmask), // 68 */* (ANSI C)
1127 //ZZ //zz // (__NR_ssetmask, sys_ssetmask), // 69 */* (ANSI C)
1128 //ZZ //zz
1129 //ZZ LINX_(__NR_setreuid, sys_setreuid16), // 70
1130 //ZZ LINX_(__NR_setregid, sys_setregid16), // 71
1131 //ZZ PLAX_(__NR_sigsuspend, sys_sigsuspend), // 72
1132 //ZZ LINXY(__NR_sigpending, sys_sigpending), // 73
1133 //ZZ //zz // (__NR_sethostname, sys_sethostname), // 74 */*
1134 //ZZ //zz
1135 //ZZ GENXY(__NR_getrlimit, sys_old_getrlimit), // 76
1136 //ZZ GENX_(__NR_settimeofday, sys_settimeofday), // 79
1137 //ZZ
1138 //ZZ LINXY(__NR_getgroups, sys_getgroups16), // 80
1139 //ZZ LINX_(__NR_setgroups, sys_setgroups16), // 81
1140 //ZZ // PLAX_(__NR_select, old_select), // 82
1141 //ZZ GENX_(__NR_symlink, sys_symlink), // 83
1142 //ZZ //zz // (__NR_oldlstat, sys_lstat), // 84 -- obsolete
1143 //ZZ //zz
1144 //ZZ GENX_(__NR_readlink, sys_readlink), // 85
1145 //ZZ //zz // (__NR_uselib, sys_uselib), // 86 */Linux
1146 //ZZ //zz // (__NR_swapon, sys_swapon), // 87 */Linux
1147 //ZZ //zz // (__NR_reboot, sys_reboot), // 88 */Linux
1148 //ZZ //zz // (__NR_readdir, old_readdir), // 89 -- superseded
1149 //ZZ //zz
1150 //ZZ // _____(__NR_mmap, old_mmap), // 90
1151 //ZZ GENXY(__NR_munmap, sys_munmap), // 91
1152 //ZZ GENX_(__NR_truncate, sys_truncate), // 92
1153 //ZZ GENX_(__NR_ftruncate, sys_ftruncate), // 93
1154 //ZZ
1155 //ZZ LINX_(__NR_fchown, sys_fchown16), // 95
1156 //ZZ // GENX_(__NR_profil, sys_ni_syscall), // 98
1157 //ZZ GENXY(__NR_statfs, sys_statfs), // 99
1158 //ZZ
1159 //ZZ GENXY(__NR_fstatfs, sys_fstatfs), // 100
1160 //ZZ // LINX_(__NR_ioperm, sys_ioperm), // 101
1161 //ZZ LINXY(__NR_socketcall, sys_socketcall), // 102
1162 //ZZ
1163 //ZZ GENXY(__NR_getitimer, sys_getitimer), // 105
1164 //ZZ GENXY(__NR_stat, sys_newstat), // 106
1165 //ZZ GENXY(__NR_lstat, sys_newlstat), // 107
1166 //ZZ GENXY(__NR_fstat, sys_newfstat), // 108
1167 //ZZ //zz // (__NR_olduname, sys_uname), // 109 -- obsolete
1168 //ZZ //zz
1169 //ZZ // GENX_(__NR_iopl, sys_iopl), // 110
1170 //ZZ LINX_(__NR_vhangup, sys_vhangup), // 111
1171 //ZZ // GENX_(__NR_idle, sys_ni_syscall), // 112
1172 //ZZ // PLAXY(__NR_vm86old, sys_vm86old), // 113 __NR_syscall... weird
1173 //ZZ //zz
1174 //ZZ //zz // (__NR_swapoff, sys_swapoff), // 115 */Linux
1175 //ZZ // _____(__NR_ipc, sys_ipc), // 117
1176 //ZZ GENX_(__NR_fsync, sys_fsync), // 118
1177 //ZZ PLAX_(__NR_sigreturn, sys_sigreturn), // 119 ?/Linux
1178 //ZZ
1179 //ZZ //zz // (__NR_setdomainname, sys_setdomainname), // 121 */*(?)
1180 //ZZ // PLAX_(__NR_modify_ldt, sys_modify_ldt), // 123
1181 //ZZ //zz LINXY(__NR_adjtimex, sys_adjtimex), // 124
1182 //ZZ //zz
1183 //ZZ LINXY(__NR_sigprocmask, sys_sigprocmask), // 126
1184 //ZZ //zz // Nb: create_module() was removed 2.4-->2.6
1185 //ZZ // GENX_(__NR_create_module, sys_ni_syscall), // 127
1186 //ZZ LINX_(__NR_init_module, sys_init_module), // 128
1187 //ZZ LINX_(__NR_delete_module, sys_delete_module), // 129
1188 //ZZ //zz
1189 //ZZ //zz // Nb: get_kernel_syms() was removed 2.4-->2.6
1190 //ZZ // GENX_(__NR_get_kernel_syms, sys_ni_syscall), // 130
1191 //ZZ GENX_(__NR_getpgid, sys_getpgid), // 132
1192 //ZZ GENX_(__NR_fchdir, sys_fchdir), // 133
1193 //ZZ //zz // (__NR_bdflush, sys_bdflush), // 134 */Linux
1194 //ZZ //zz
1195 //ZZ //zz // (__NR_sysfs, sys_sysfs), // 135 SVr4
1196 //ZZ LINX_(__NR_personality, sys_personality), // 136
1197 //ZZ // GENX_(__NR_afs_syscall, sys_ni_syscall), // 137
1198 //ZZ LINX_(__NR_setfsuid, sys_setfsuid16), // 138
1199 //ZZ LINX_(__NR_setfsgid, sys_setfsgid16), // 139
1200 //ZZ
1201 //ZZ LINXY(__NR__llseek, sys_llseek), // 140
1202 //ZZ GENXY(__NR_getdents, sys_getdents), // 141
1203 //ZZ GENX_(__NR__newselect, sys_select), // 142
1204 //ZZ GENX_(__NR_flock, sys_flock), // 143
1205 //ZZ GENX_(__NR_msync, sys_msync), // 144
1206 //ZZ
1207 //ZZ GENX_(__NR_getsid, sys_getsid), // 147
1208 //ZZ GENX_(__NR_fdatasync, sys_fdatasync), // 148
1209 //ZZ LINXY(__NR__sysctl, sys_sysctl), // 149
1210 //ZZ
1211 //ZZ GENX_(__NR_mlock, sys_mlock), // 150
1212 //ZZ GENX_(__NR_munlock, sys_munlock), // 151
1213 //ZZ GENX_(__NR_mlockall, sys_mlockall), // 152
1214 //ZZ LINX_(__NR_munlockall, sys_munlockall), // 153
1215 //ZZ LINXY(__NR_sched_setparam, sys_sched_setparam), // 154
1216 //ZZ
1217 //ZZ LINXY(__NR_sched_getparam, sys_sched_getparam), // 155
1218 //ZZ LINX_(__NR_sched_setscheduler, sys_sched_setscheduler), // 156
1219 //ZZ LINX_(__NR_sched_getscheduler, sys_sched_getscheduler), // 157
1220 //ZZ LINX_(__NR_sched_get_priority_max, sys_sched_get_priority_max),// 159
1221 //ZZ
1222 //ZZ LINX_(__NR_sched_get_priority_min, sys_sched_get_priority_min),// 160
1223 //ZZ //zz //LINX?(__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 161 */*
1224 //ZZ LINX_(__NR_setresuid, sys_setresuid16), // 164
1225 //ZZ
1226 //ZZ LINXY(__NR_getresuid, sys_getresuid16), // 165
1227 //ZZ // PLAXY(__NR_vm86, sys_vm86), // 166 x86/Linux-only
1228 //ZZ // GENX_(__NR_query_module, sys_ni_syscall), // 167
1229 //ZZ GENXY(__NR_poll, sys_poll), // 168
1230 //ZZ //zz // (__NR_nfsservctl, sys_nfsservctl), // 169 */Linux
1231 //ZZ //zz
1232 //ZZ LINX_(__NR_setresgid, sys_setresgid16), // 170
1233 //ZZ LINXY(__NR_getresgid, sys_getresgid16), // 171
1234 //ZZ LINXY(__NR_prctl, sys_prctl), // 172
1235 //ZZ LINXY(__NR_rt_sigaction, sys_rt_sigaction), // 174
1236 //ZZ
1237 //ZZ LINXY(__NR_rt_sigpending, sys_rt_sigpending), // 176
1238 //ZZ LINXY(__NR_rt_sigtimedwait, sys_rt_sigtimedwait),// 177
1239 //ZZ
1240 //ZZ LINX_(__NR_chown, sys_chown16), // 182
1241 //ZZ
1242 //ZZ LINXY(__NR_sendfile, sys_sendfile), // 187
1243 //ZZ // GENXY(__NR_getpmsg, sys_getpmsg), // 188
1244 //ZZ // GENX_(__NR_putpmsg, sys_putpmsg), // 189
1245 //ZZ
1246 //ZZ // Nb: we treat vfork as fork
1247 //ZZ GENX_(__NR_vfork, sys_fork), // 190
1248 //ZZ GENXY(__NR_ugetrlimit, sys_getrlimit), // 191
1249 //ZZ GENX_(__NR_truncate64, sys_truncate64), // 193
1250 //ZZ GENX_(__NR_ftruncate64, sys_ftruncate64), // 194
1251 //ZZ
1252 //ZZ PLAXY(__NR_stat64, sys_stat64), // 195
1253 //ZZ PLAXY(__NR_lstat64, sys_lstat64), // 196
1254 //ZZ PLAXY(__NR_fstat64, sys_fstat64), // 197
1255 //ZZ GENX_(__NR_lchown32, sys_lchown), // 198
1256 //ZZ GENX_(__NR_getuid32, sys_getuid), // 199
1257 //ZZ
1258 //ZZ GENX_(__NR_getgid32, sys_getgid), // 200
1259 //ZZ GENX_(__NR_geteuid32, sys_geteuid), // 201
1260 //ZZ GENX_(__NR_getegid32, sys_getegid), // 202
1261 //ZZ GENX_(__NR_setreuid32, sys_setreuid), // 203
1262 //ZZ GENX_(__NR_setregid32, sys_setregid), // 204
1263 //ZZ
1264 //ZZ GENXY(__NR_getgroups32, sys_getgroups), // 205
1265 //ZZ GENX_(__NR_setgroups32, sys_setgroups), // 206
1266 //ZZ GENX_(__NR_fchown32, sys_fchown), // 207
1267 //ZZ LINX_(__NR_setresuid32, sys_setresuid), // 208
1268 //ZZ LINXY(__NR_getresuid32, sys_getresuid), // 209
1269 //ZZ
1270 //ZZ LINX_(__NR_setresgid32, sys_setresgid), // 210
1271 //ZZ LINXY(__NR_getresgid32, sys_getresgid), // 211
1272 //ZZ GENX_(__NR_chown32, sys_chown), // 212
1273 //ZZ GENX_(__NR_setuid32, sys_setuid), // 213
1274 //ZZ GENX_(__NR_setgid32, sys_setgid), // 214
1275 //ZZ
1276 //ZZ LINX_(__NR_setfsuid32, sys_setfsuid), // 215
1277 //ZZ LINX_(__NR_setfsgid32, sys_setfsgid), // 216
1278 //ZZ //zz // (__NR_pivot_root, sys_pivot_root), // 217 */Linux
1279 //ZZ GENXY(__NR_mincore, sys_mincore), // 218
1280 //ZZ
1281 //ZZ LINXY(__NR_fcntl64, sys_fcntl64), // 221
1282 //ZZ // GENX_(222, sys_ni_syscall), // 222
1283 //ZZ // PLAXY(223, sys_syscall223), // 223 // sys_bproc?
1284 //ZZ
1285 //ZZ LINX_(__NR_setxattr, sys_setxattr), // 226
1286 //ZZ LINX_(__NR_lsetxattr, sys_lsetxattr), // 227
1287 //ZZ LINX_(__NR_fsetxattr, sys_fsetxattr), // 228
1288 //ZZ
1289 //ZZ LINXY(__NR_fgetxattr, sys_fgetxattr), // 231
1290 //ZZ LINXY(__NR_listxattr, sys_listxattr), // 232
1291 //ZZ LINXY(__NR_llistxattr, sys_llistxattr), // 233
1292 //ZZ LINXY(__NR_flistxattr, sys_flistxattr), // 234
1293 //ZZ
1294 //ZZ LINX_(__NR_removexattr, sys_removexattr), // 235
1295 //ZZ LINX_(__NR_lremovexattr, sys_lremovexattr), // 236
1296 //ZZ LINX_(__NR_fremovexattr, sys_fremovexattr), // 237
1297 //ZZ LINXY(__NR_tkill, sys_tkill), // 238 */Linux
1298 //ZZ LINXY(__NR_sendfile64, sys_sendfile64), // 239
1299 //ZZ
1300 //ZZ LINXY(__NR_futex, sys_futex), // 240
1301 //ZZ LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 242
1302 //ZZ // PLAX_(__NR_set_thread_area, sys_set_thread_area), // 243
1303 //ZZ // PLAX_(__NR_get_thread_area, sys_get_thread_area), // 244
1304 //ZZ
1305 //ZZ LINXY(__NR_io_setup, sys_io_setup), // 245
1306 //ZZ LINX_(__NR_io_destroy, sys_io_destroy), // 246
1307 //ZZ LINXY(__NR_io_getevents, sys_io_getevents), // 247
1308 //ZZ LINX_(__NR_io_submit, sys_io_submit), // 248
1309 //ZZ LINXY(__NR_io_cancel, sys_io_cancel), // 249
1310 //ZZ
1311 //ZZ // LINX_(__NR_fadvise64, sys_fadvise64), // 250 */(Linux?)
1312 //ZZ GENX_(251, sys_ni_syscall), // 251
1313 //ZZ // GENXY(__NR_lookup_dcookie, sys_lookup_dcookie), // 253
1314 //ZZ LINXY(__NR_epoll_create, sys_epoll_create), // 254
1315 //ZZ
1316 //ZZ LINX_(__NR_epoll_ctl, sys_epoll_ctl), // 255
1317 //ZZ LINXY(__NR_epoll_wait, sys_epoll_wait), // 256
1318 //ZZ //zz // (__NR_remap_file_pages, sys_remap_file_pages), // 257 */Linux
1319 //ZZ LINX_(__NR_set_tid_address, sys_set_tid_address), // 258
1320 //ZZ LINXY(__NR_timer_create, sys_timer_create), // 259
1321 //ZZ
1322 //ZZ LINXY(__NR_timer_settime, sys_timer_settime), // (timer_create+1)
1323 //ZZ LINXY(__NR_timer_gettime, sys_timer_gettime), // (timer_create+2)
1324 //ZZ LINX_(__NR_timer_getoverrun, sys_timer_getoverrun),//(timer_create+3)
1325 //ZZ LINX_(__NR_timer_delete, sys_timer_delete), // (timer_create+4)
1326 //ZZ LINX_(__NR_clock_settime, sys_clock_settime), // (timer_create+5)
1327 //ZZ
1328 //ZZ LINXY(__NR_clock_getres, sys_clock_getres), // (timer_create+7)
1329 //ZZ LINXY(__NR_clock_nanosleep, sys_clock_nanosleep),// (timer_create+8) */*
1330 //ZZ GENXY(__NR_statfs64, sys_statfs64), // 268
1331 //ZZ GENXY(__NR_fstatfs64, sys_fstatfs64), // 269
1332 //ZZ
1333 //ZZ GENX_(__NR_utimes, sys_utimes), // 271
1334 //ZZ // LINX_(__NR_fadvise64_64, sys_fadvise64_64), // 272 */(Linux?)
1335 //ZZ GENX_(__NR_vserver, sys_ni_syscall), // 273
1336 //ZZ LINX_(__NR_mbind, sys_mbind), // 274 ?/?
1337 //ZZ
1338 //ZZ LINXY(__NR_get_mempolicy, sys_get_mempolicy), // 275 ?/?
1339 //ZZ LINX_(__NR_set_mempolicy, sys_set_mempolicy), // 276 ?/?
1340 //ZZ
1341 //ZZ LINXY(__NR_waitid, sys_waitid), // 280
1342 //ZZ
1343 //ZZ LINX_(__NR_send, sys_send),
1344 //ZZ LINXY(__NR_recv, sys_recv),
1345 //ZZ LINXY(__NR_recvfrom, sys_recvfrom), // 292
1346 //ZZ LINX_(__NR_semget, sys_semget), // 299
1347 //ZZ LINXY(__NR_semctl, sys_semctl), // 300
1348 //ZZ LINX_(__NR_msgget, sys_msgget),
1349 //ZZ LINX_(__NR_msgsnd, sys_msgsnd),
1350 //ZZ LINXY(__NR_msgrcv, sys_msgrcv),
1351 //ZZ LINXY(__NR_msgctl, sys_msgctl), // 304
1352 //ZZ
1353 //ZZ LINX_(__NR_request_key, sys_request_key), // 287
1354 //ZZ // LINX_(__NR_ioprio_set, sys_ioprio_set), // 289
1355 //ZZ
1356 //ZZ // LINX_(__NR_ioprio_get, sys_ioprio_get), // 290
1357 //ZZ LINX_(__NR_inotify_init, sys_inotify_init), // 291
1358 //ZZ // LINX_(__NR_migrate_pages, sys_migrate_pages), // 294
1359 //ZZ
1360 //ZZ LINX_(__NR_mknodat, sys_mknodat), // 297
1361 //ZZ LINX_(__NR_futimesat, sys_futimesat), // 326 on arm
1362 //ZZ
1363 //ZZ PLAXY(__NR_fstatat64, sys_fstatat64), // 300
1364 //ZZ LINX_(__NR_renameat, sys_renameat), // 302
1365 //ZZ LINX_(__NR_symlinkat, sys_symlinkat), // 304
1366 //ZZ
1367 //ZZ LINX_(__NR_shmget, sys_shmget), //307
1368 //ZZ // LINX_(__NR_pselect6, sys_pselect6), //
1369 //ZZ
1370 //ZZ // LINX_(__NR_unshare, sys_unshare), // 310
1371 //ZZ LINX_(__NR_set_robust_list, sys_set_robust_list), // 311
1372 //ZZ LINXY(__NR_get_robust_list, sys_get_robust_list), // 312
1373 //ZZ // LINX_(__NR_splice, sys_ni_syscall), // 313
1374 //ZZ // LINX_(__NR_sync_file_range, sys_sync_file_range), // 314
1375 //ZZ
1376 //ZZ // LINX_(__NR_tee, sys_ni_syscall), // 315
1377 //ZZ // LINX_(__NR_vmsplice, sys_ni_syscall), // 316
1378 //ZZ LINXY(__NR_move_pages, sys_move_pages), // 317
1379 //ZZ // LINX_(__NR_getcpu, sys_ni_syscall), // 318
1380 //ZZ
1381 //ZZ LINXY(__NR_signalfd, sys_signalfd), // 321
1382 //ZZ LINXY(__NR_eventfd, sys_eventfd), // 323
1383 //ZZ
1384 //ZZ
1385 //ZZ ///////////////
1386 //ZZ
1387 //ZZ // JRS 2010-Jan-03: I believe that all the numbers listed
1388 //ZZ // in comments in the table prior to this point (eg "// 326",
1389 //ZZ // etc) are bogus since it looks to me like they are copied
1390 //ZZ // verbatim from syswrap-x86-linux.c and they certainly do not
1391 //ZZ // correspond to what's in include/vki/vki-scnums-arm-linux.h.
1392 //ZZ // From here onwards, please ensure the numbers are correct.
1393 //ZZ
1394 //ZZ
1395 //ZZ LINXY(__NR_epoll_pwait, sys_epoll_pwait), // 346
1396 //ZZ
1397 //ZZ
1398 //ZZ LINXY(__NR_eventfd2, sys_eventfd2), // 356
1399 //ZZ LINXY(__NR_epoll_create1, sys_epoll_create1), // 357
1400 //ZZ LINXY(__NR_preadv, sys_preadv), // 361
1401 //ZZ LINX_(__NR_pwritev, sys_pwritev), // 362
1402 //ZZ LINXY(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo),// 363
1403 //ZZ LINXY(__NR_perf_event_open, sys_perf_event_open), // 364
1404 //ZZ
1405 //ZZ LINXY(__NR_accept4, sys_accept4), // 366
1406 //ZZ
1407 //ZZ LINXY(__NR_name_to_handle_at, sys_name_to_handle_at),// 370
1408 //ZZ LINXY(__NR_open_by_handle_at, sys_open_by_handle_at),// 371
1409 //ZZ LINXY(__NR_clock_adjtime, sys_clock_adjtime) // 372
1410 };
1411
1412
1413 //ZZ /* These are not in the main table because there indexes are not small
1414 //ZZ integers, but rather values close to one million. So their
1415 //ZZ inclusion would force the main table to be huge (about 8 MB). */
1416 //ZZ
1417 //ZZ static SyscallTableEntry ste___ARM_set_tls
1418 //ZZ = { WRAPPER_PRE_NAME(arm_linux,sys_set_tls), NULL };
1419 //ZZ
1420 //ZZ static SyscallTableEntry ste___ARM_cacheflush
1421 //ZZ = { WRAPPER_PRE_NAME(arm_linux,sys_cacheflush), NULL };
1422
ML_(get_linux_syscall_entry)1423 SyscallTableEntry* ML_(get_linux_syscall_entry) ( UInt sysno )
1424 {
1425 const UInt syscall_main_table_size
1426 = sizeof(syscall_main_table) / sizeof(syscall_main_table[0]);
1427
1428 /* Is it in the contiguous initial section of the table? */
1429 if (sysno < syscall_main_table_size) {
1430 SyscallTableEntry* sys = &syscall_main_table[sysno];
1431 if (sys->before == NULL)
1432 return NULL; /* no entry */
1433 else
1434 return sys;
1435 }
1436
1437 //ZZ /* Check if it's one of the out-of-line entries. */
1438 //ZZ switch (sysno) {
1439 //ZZ case __NR_ARM_set_tls: return &ste___ARM_set_tls;
1440 //ZZ case __NR_ARM_cacheflush: return &ste___ARM_cacheflush;
1441 //ZZ default: break;
1442 //ZZ }
1443
1444 /* Can't find a wrapper */
1445 return NULL;
1446 }
1447
1448 #endif // defined(VGP_arm64_linux)
1449
1450 /*--------------------------------------------------------------------*/
1451 /*--- end syswrap-arm64-linux.c ---*/
1452 /*--------------------------------------------------------------------*/
1453