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