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