Add arm64 support to linux_syscall_support.h

linux_syscall_support.h

 /* Copyright (c) 2005-2011, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 68 matching lines @@
  * Do not access these symbols from outside this file. They are not part
  * of the supported API.
  */
 #ifndef SYS_LINUX_SYSCALL_SUPPORT_H
 #define SYS_LINUX_SYSCALL_SUPPORT_H
 
 /* We currently only support x86-32, x86-64, ARM, MIPS, and PPC on Linux.
  * Porting to other related platforms should not be difficult.
  */
 #if (defined(__i386__) || defined(__x86_64__) || defined(__ARM_ARCH_3__) ||   \
-     defined(__mips__) || defined(__PPC__) || defined(__ARM_EABI__)) \
+     defined(__mips__) || defined(__PPC__) || defined(__ARM_EABI__) || \
+     defined(__aarch64__)) \
   && (defined(__linux) || defined(__ANDROID__))
 
 #ifndef SYS_CPLUSPLUS
 #ifdef __cplusplus
 /* Some system header files in older versions of gcc neglect to properly
  * handle being included from C++. As it appears to be harmless to have
  * multiple nested 'extern "C"' blocks, just add another one here.
  */
 extern "C" {
 #endif
 
 #include <errno.h>
 #include <fcntl.h>
+#include <sched.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <sys/ptrace.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/syscall.h>
@@ skipping 52 matching lines @@
 /* include/linux/dirent.h                                                    */
 struct kernel_dirent64 {
   unsigned long long d_ino;
   long long          d_off;
   unsigned short     d_reclen;
   unsigned char      d_type;
   char               d_name[256];
 };
 
 /* include/linux/dirent.h                                                    */
+#if defined(__aarch64__)
+// aarch64 only defines dirent64, just uses that for dirent too.
+#define kernel_dirent kernel_dirent64
+#else
 struct kernel_dirent {
   long               d_ino;
   long               d_off;
   unsigned short     d_reclen;
   char               d_name[256];
 };
+#endif
 
 /* include/linux/uio.h                                                       */
 struct kernel_iovec {
   void               *iov_base;
   unsigned long      iov_len;
 };
 
 /* include/linux/socket.h                                                    */
 struct kernel_msghdr {
   void               *msg_name;
@@ skipping 58 matching lines @@
   union {
     void             (*sa_handler_)(int);
     void             (*sa_sigaction_)(int, siginfo_t *, void *);
   };
   unsigned long      sa_mask;
   unsigned long      sa_flags;
   void               (*sa_restorer)(void);
 } __attribute__((packed,aligned(4)));
 #elif (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32)
   #define kernel_old_sigaction kernel_sigaction
+#elif defined(__aarch64__)
+  // No kernel_old_sigaction defined for arm64.
 #endif
 
 /* Some kernel functions (e.g. sigaction() in 2.6.23) require that the
  * exactly match the size of the signal set, even though the API was
  * intended to be extensible. We define our own KERNEL_NSIG to deal with
  * this.
  * Please note that glibc provides signals [1.._NSIG-1], whereas the
  * kernel (and this header) provides the range [1..KERNEL_NSIG]. The
  * actual number of signals is obviously the same, but the constants
  * differ by one.
  */
 #ifdef __mips__
 #define KERNEL_NSIG 128
 #else
 #define KERNEL_NSIG  64
 #endif
 
-/* include/asm-{arm,i386,mips,x86_64}/signal.h                               */
+/* include/asm-{arm,aarch64,i386,mips,x86_64}/signal.h                       */
 struct kernel_sigset_t {
   unsigned long sig[(KERNEL_NSIG + 8*sizeof(unsigned long) - 1)/
                     (8*sizeof(unsigned long))];
 };
 
 /* include/asm-{arm,i386,mips,x86_64,ppc}/signal.h                           */
 struct kernel_sigaction {
 #ifdef __mips__
   unsigned long      sa_flags;
   union {
@@ skipping 11 matching lines @@
   struct kernel_sigset_t sa_mask;
 #endif
 };
 
 /* include/linux/socket.h                                                    */
 struct kernel_sockaddr {
   unsigned short     sa_family;
   char               sa_data[14];
 };
 
-/* include/asm-{arm,i386,mips,ppc}/stat.h                                    */
+/* include/asm-{arm,aarch64,i386,mips,ppc}/stat.h                            */
 #ifdef __mips__
 #if _MIPS_SIM == _MIPS_SIM_ABI64
 struct kernel_stat {
 #else
 struct kernel_stat64 {
 #endif
   unsigned           st_dev;
   unsigned           __pad0[3];
   unsigned long long st_ino;
   unsigned           st_mode;
@@ skipping 52 matching lines @@
   unsigned           st_atime_;
   unsigned           st_atime_nsec_;
   unsigned           st_mtime_;
   unsigned           st_mtime_nsec_;
   unsigned           st_ctime_;
   unsigned           st_ctime_nsec_;
   unsigned long long st_ino;
 };
 #endif
 
-/* include/asm-{arm,i386,mips,x86_64,ppc}/stat.h                             */
+/* include/asm-{arm,aarch64,i386,mips,x86_64,ppc}/stat.h                     */
 #if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__)
 struct kernel_stat {
   /* The kernel headers suggest that st_dev and st_rdev should be 32bit
    * quantities encoding 12bit major and 20bit minor numbers in an interleaved
    * format. In reality, we do not see useful data in the top bits. So,
    * we'll leave the padding in here, until we find a better solution.
    */
   unsigned short     st_dev;
   short              pad1;
   unsigned           st_ino;
@@ skipping 73 matching lines @@
   long               st_atime_;
   long               st_atime_nsec_;
   long               st_mtime_;
   long               st_mtime_nsec_;
   long               st_ctime_;
   long               st_ctime_nsec_;
   int                st_blksize;
   int                st_blocks;
   int                st_pad4[14];
 };
+#elif defined(__aarch64__)
+struct kernel_stat {
+  unsigned long      st_dev;
+  unsigned long      st_ino;
+  unsigned int       st_mode;
+  unsigned int       st_nlink;
+  unsigned int       st_uid;
+  unsigned int       st_gid;
+  unsigned long      st_rdev;
+  unsigned long      __pad1;
+  long               st_size;
+  int                st_blksize;
+  int                __pad2;
+  long               st_blocks;
+  long               st_atime;

[Mark Seaborn, 2014/04/08 16:52:45]

All the other defs of st_[amc]time{,_nsec} have a trailing "_", which I think is
necessary to avoid conflicts with glibc's #defines of st_[amc]time.

[rmcilroy, 2014/04/09 12:37:07]

Done.

+  unsigned long      st_atime_nsec;
+  long               st_mtime;
+  unsigned long      st_mtime_nsec;
+  long               st_ctime;
+  unsigned long      st_ctime_nsec;
+  unsigned int       __unused4;
+  unsigned int       __unused5;
+};
 #endif
 
-/* include/asm-{arm,i386,mips,x86_64,ppc}/statfs.h                           */
+/* include/asm-{arm,aarch64,i386,mips,x86_64,ppc}/statfs.h                   */
 #ifdef __mips__
 #if _MIPS_SIM != _MIPS_SIM_ABI64
 struct kernel_statfs64 {
   unsigned long      f_type;
   unsigned long      f_bsize;
   unsigned long      f_frsize;
   unsigned long      __pad;
   unsigned long long f_blocks;
   unsigned long long f_bfree;
   unsigned long long f_files;
@@ skipping 64 matching lines @@
   struct { int val[2]; } f_fsid;
   unsigned long      f_namelen;
   unsigned long      f_frsize;
   unsigned long      f_spare[5];
 };
 #endif
 
 
 /* Definitions missing from the standard header files                        */
 #ifndef O_DIRECTORY
-#if defined(__ARM_ARCH_3__) || defined(__ARM_EABI__)
+#if defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) || defined(__aarch64__)
 #define O_DIRECTORY             0040000
 #else
 #define O_DIRECTORY             0200000
 #endif
 #endif
 #ifndef NT_PRXFPREG
 #define NT_PRXFPREG             0x46e62b7f
 #endif
 #ifndef PTRACE_GETFPXREGS
 #define PTRACE_GETFPXREGS       ((enum __ptrace_request)18)
@@ skipping 333 matching lines @@
 #ifndef __NR_ioprio_get
 #define __NR_ioprio_get         (__NR_SYSCALL_BASE + 315)
 #endif
 #ifndef __NR_move_pages
 #define __NR_move_pages         (__NR_SYSCALL_BASE + 344)
 #endif
 #ifndef __NR_getcpu
 #define __NR_getcpu             (__NR_SYSCALL_BASE + 345)
 #endif
 /* End of ARM 3/EABI definitions                                                */
+#elif defined(__aarch64__)
+#ifndef __NR_setxattr
+#define __NR_setxattr             5
+#endif
+#ifndef __NR_lsetxattr
+#define __NR_lsetxattr            6
+#endif
+#ifndef __NR_getxattr
+#define __NR_getxattr             8
+#endif
+#ifndef __NR_lgetxattr
+#define __NR_lgetxattr            9
+#endif
+#ifndef __NR_listxattr
+#define __NR_listxattr           11
+#endif
+#ifndef __NR_llistxattr
+#define __NR_llistxattr          12
+#endif
+#ifndef __NR_ioprio_set
+#define __NR_ioprio_set          30
+#endif
+#ifndef __NR_ioprio_get
+#define __NR_ioprio_get          31
+#endif
+#ifndef __NR_unlinkat
+#define __NR_unlinkat            35
+#endif
+#ifndef __NR_fallocate
+#define __NR_fallocate           47
+#endif
+#ifndef __NR_openat
+#define __NR_openat              56
+#endif
+#ifndef __NR_quotactl
+#define __NR_quotactl            60
+#endif
+#ifndef __NR_getdents64
+#define __NR_getdents64          61
+#endif
+#ifndef __NR_getdents
+#define __NR_getdents            __NR_getdents64
+#endif
+#ifndef __NR_pread64
+#define __NR_pread64             67
+#endif
+#ifndef __NR_pwrite64
+#define __NR_pwrite64            68
+#endif
+#ifndef __NR_ppoll
+#define __NR_ppoll               73
+#endif
+#ifndef __NR_readlinkat
+#define __NR_readlinkat          78
+#endif
+#ifndef __NR_newfstatat
+#define __NR_newfstatat          79
+#endif
+#ifndef __NR_set_tid_address
+#define __NR_set_tid_address     96
+#endif
+#ifndef __NR_futex
+#define __NR_futex               98
+#endif
+#ifndef __NR_clock_gettime
+#define __NR_clock_gettime      113
+#endif
+#ifndef __NR_clock_getres
+#define __NR_clock_getres       114
+#endif
+#ifndef __NR_sched_setaffinity
+#define __NR_sched_setaffinity  122
+#define __NR_sched_getaffinity  123
+#endif
+#ifndef __NR_tkill
+#define __NR_tkill              130
+#endif
+#ifndef __NR_setresuid
+#define __NR_setresuid          147
+#define __NR_getresuid          148
+#define __NR_setresgid          149
+#define __NR_getresgid          150
+#endif
+#ifndef __NR_gettid
+#define __NR_gettid             178
+#endif
+#ifndef __NR_readahead
+#define __NR_readahead          213
+#endif
+#ifndef __NR_fadvise64
+#define __NR_fadvise64          223
+#endif
+#ifndef __NR_move_pages
+#define __NR_move_pages         239
+#endif
+/* End of aarch64 definitions                                                */
 #elif defined(__x86_64__)
 #ifndef __NR_pread64
 #define __NR_pread64             17
 #endif
 #ifndef __NR_pwrite64
 #define __NR_pwrite64            18
 #endif
 #ifndef __NR_setresuid
 #define __NR_setresuid          117
 #define __NR_getresuid          118
@@ skipping 499 matching lines @@
   #elif defined(SYS_PREFIX) && SYS_PREFIX == 7
     #define LSS_NAME(name) sys7_##name
   #elif defined(SYS_PREFIX) && SYS_PREFIX == 8
     #define LSS_NAME(name) sys8_##name
   #elif defined(SYS_PREFIX) && SYS_PREFIX == 9
     #define LSS_NAME(name) sys9_##name
   #endif
 
   #undef  LSS_RETURN
   #if (defined(__i386__) || defined(__x86_64__) || defined(__ARM_ARCH_3__) \
-       || defined(__ARM_EABI__))
+       || defined(__ARM_EABI__) || defined(__aarch64__))
   /* Failing system calls return a negative result in the range of
    * -1..-4095. These are "errno" values with the sign inverted.
    */
   #define LSS_RETURN(type, res)                                               \
     do {                                                                      \
       if ((unsigned long)(res) >= (unsigned long)(-4095)) {                   \
         LSS_ERRNO = -(res);                                                   \
         res = -1;                                                             \
       }                                                                       \
       return (type) (res);                                                    \
@@ skipping 788 matching lines @@
       long __res;
       {
         register int   __flags __asm__("r0") = flags;
         register void *__stack __asm__("r1") = child_stack;
         register void *__ptid  __asm__("r2") = parent_tidptr;
         register void *__tls   __asm__("r3") = newtls;
         register int  *__ctid  __asm__("r4") = child_tidptr;
         __asm__ __volatile__(/* if (fn == NULL || child_stack == NULL)
                               *   return -EINVAL;
                               */
-#ifdef __thumb2__                            
+#ifdef __thumb2__
                              "push  {r7}\n"
-#endif                       
+#endif
                              "cmp   %2,#0\n"
                              "it    ne\n"
                              "cmpne %3,#0\n"
                              "it    eq\n"
                              "moveq %0,%1\n"
                              "beq   1f\n"
 
                              /* Push "arg" and "fn" onto the stack that will be
                               * used by the child.
                               */
@@ skipping 37 matching lines @@
                              "ldr   pc,[sp]\n"
                            #endif
 
                              /* Call _exit(%r0).
                               */
                              "mov r7, %10\n"
                              "swi 0x0\n"
                            "1:\n"
 #ifdef __thumb2__
                              "pop {r7}"
-#endif                       
+#endif
                              : "=r" (__res)
                              : "i"(-EINVAL),
                                "r"(fn), "r"(__stack), "r"(__flags), "r"(arg),
                                "r"(__ptid), "r"(__tls), "r"(__ctid),
                                "i"(__NR_clone), "i"(__NR_exit)
 #ifdef __thumb2__
                              : "cc", "lr", "memory");
 #else
                              : "cc", "r7", "lr", "memory");
 #endif
       }
       LSS_RETURN(int, __res);
     }
+  #elif defined(__aarch64__)
+    /* Most definitions of _syscallX() neglect to mark "memory" as being
+     * clobbered. This causes problems with compilers, that do a better job
+     * at optimizing across __asm__ calls.
+     * So, we just have to redefine all of the _syscallX() macros.
+     */
+    #undef LSS_REG
+    #define LSS_REG(r,a) register long __r##r __asm__("x"#r) = (long)a

[jbramley, 2014/04/15 10:16:42]

Something like int64_t would be better.

[rmcilroy, 2014/04/15 11:50:29]

Done.

+    #undef  LSS_BODY
+    #define LSS_BODY(type,name,args...)                                       \
+          register long __res_x0 __asm__("x0");                               \
+          long __res;                                                         \
+          __asm__ __volatile__ ("mov x8, %1\n"                                \
+                                "svc 0x0\n"                                   \
+                                : "=r"(__res_x0)                              \
+                                : "i"(__NR_##name) , ## args                  \
+                                : "x8", "x30", "memory");                     \

[jbramley, 2014/04/15 10:16:42]

The kernel preserves everything except x0, so x30 doesn't need to be in this
list.

[rmcilroy, 2014/04/15 11:50:29]

Done.

+          __res = __res_x0;                                                   \
+          LSS_RETURN(type, __res)
+    #undef _syscall0
+    #define _syscall0(type, name)                                             \
+      type LSS_NAME(name)(void) {                                             \
+        LSS_BODY(type, name);                                                 \
+      }
+    #undef _syscall1
+    #define _syscall1(type, name, type1, arg1)                                \
+      type LSS_NAME(name)(type1 arg1) {                                       \
+        LSS_REG(0, arg1); LSS_BODY(type, name, "r"(__r0));                    \
+      }
+    #undef _syscall2
+    #define _syscall2(type, name, type1, arg1, type2, arg2)                   \
+      type LSS_NAME(name)(type1 arg1, type2 arg2) {                           \
+        LSS_REG(0, arg1); LSS_REG(1, arg2);                                   \
+        LSS_BODY(type, name, "r"(__r0), "r"(__r1));                           \
+      }
+    #undef _syscall3
+    #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)      \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) {               \
+        LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3);                 \
+        LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2));                \
+      }
+    #undef _syscall4
+    #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)  \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {   \
+        LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3);                 \
+        LSS_REG(3, arg4);                                                     \
+        LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3));     \
+      }
+    #undef _syscall5
+    #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \
+                      type5,arg5)                                             \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
+                          type5 arg5) {                                       \
+        LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3);                 \
+        LSS_REG(3, arg4); LSS_REG(4, arg5);                                   \
+        LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3),      \
+                             "r"(__r4));                                      \
+      }
+    #undef _syscall6
+    #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \
+                      type5,arg5,type6,arg6)                                  \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
+                          type5 arg5, type6 arg6) {                           \
+        LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3);                 \
+        LSS_REG(3, arg4); LSS_REG(4, arg5); LSS_REG(5, arg6);                 \
+        LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3),      \
+                             "r"(__r4), "r"(__r5));                           \
+      }
+
+    LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack,
+                                   int flags, void *arg, int *parent_tidptr,
+                                   void *newtls, int *child_tidptr) {
+      long __res;

[jbramley, 2014/04/15 10:16:42]

Something like int64_t would be better.

[rmcilroy, 2014/04/15 11:50:29]

Done.

+      if (fn == NULL || child_stack == NULL) {
+        return -EINVAL;

[Mark Seaborn, 2014/04/08 16:52:45]

Shouldn't this be setting errno, as LSS_RETURN does?  This seems to be a bug in
the existing clone() implementations.

Rather than returning EINVAL or setting errno, you might just drop the NULL
checks, since they don't seem very useful.

[rmcilroy, 2014/04/09 12:37:07]

Good point - dropped the NULL checks.

+      }
+      {
+        register int   __flags __asm__("x0") = flags;

[jbramley, 2014/04/15 10:16:42]

`flags` is W-sized. Does this work? Perhaps make it a uint64_t to be safe.

[rmcilroy, 2014/04/15 11:50:29]

It does work, but I agree making flags uint64_t size is probably safer.

+        register void *__stack __asm__("x1") = child_stack;
+        register void *__ptid  __asm__("x2") = parent_tidptr;
+        register void *__tls   __asm__("x3") = newtls;
+        register int  *__ctid  __asm__("x4") = child_tidptr;
+        __asm__ __volatile__(/* Push "arg" and "fn" onto the stack that will be
+                              * used by the child.
+                              */
+                             "stp     %1, %4, [%2, #-16]!\n"

[jbramley, 2014/04/15 10:16:42]

Named assembly arguments would make this easier to follow.

[rmcilroy, 2014/04/15 11:50:29]

If you mean named registers, I'm not sure this would be much easier to follow
and I would prefer to keep this consistent with the other arches.

+
+                             /* %x0 = syscall(%x0 = flags,
+                              *               %x1 = child_stack,
+                              *               %x2 = parent_tidptr,
+                              *               %x3 = newtls,
+                              *               %x4 = child_tidptr)
+                              */
+                             "mov     x8, %8\n"
+                             "svc     0x0\n"
+
+                             /* if (%r0 != 0)
+                              *   return %r0;
+                              */
+                             "adds    %0, xzr, x0\n"

[jbramley, 2014/04/15 10:16:42]

You can use cbnz for this:

cbnz x0, 1f

[rmcilroy, 2014/04/15 11:50:29]

That wouldn't move x0 to __res though.

+                             "bne     1f\n"
+
+                             /* In the child, now. Call "fn(arg)".
+                              */
+                             "ldp     x1, x0, [sp], #16\n"
+                             "blr     x1\n"
+
+                             /* Call _exit(%r0).
+                              */
+                             "mov     x8, %9\n"
+                             "svc     0x0\n"
+                           "1:\n"
+                             : "=r" (__res)
+                             : "r"(fn), "r"(__stack), "r"(__flags), "r"(arg),
+                               "r"(__ptid), "r"(__tls), "r"(__ctid),
+                               "i"(__NR_clone), "i"(__NR_exit)
+                             : "cc", "x8", "x30", "memory");
+      }
+      LSS_RETURN(int, __res);
+    }
   #elif defined(__mips__)
     #undef LSS_REG
     #define LSS_REG(r,a) register unsigned long __r##r __asm__("$"#r) =       \
                                  (unsigned long)(a)
     #undef  LSS_BODY
     #define LSS_BODY(type,name,r7,...)                                        \
           register unsigned long __v0 __asm__("$2") = __NR_##name;            \
           __asm__ __volatile__ ("syscall\n"                                   \
                                 : "+r"(__v0), r7 (__r7)                       \
                                 : "0"(__v0), ##__VA_ARGS__                    \
@@ skipping 393 matching lines @@
   #define __NR__gettid __NR_gettid
   #define __NR__mremap __NR_mremap
   LSS_INLINE _syscall1(void *,  brk,             void *,      e)
   LSS_INLINE _syscall1(int,     chdir,           const char *,p)
   LSS_INLINE _syscall1(int,     close,           int,         f)
   LSS_INLINE _syscall2(int,     clock_getres,    int,         c,
                        struct kernel_timespec*, t)
   LSS_INLINE _syscall2(int,     clock_gettime,   int,         c,
                        struct kernel_timespec*, t)
   LSS_INLINE _syscall1(int,     dup,             int,         f)
-  LSS_INLINE _syscall2(int,     dup2,            int,         s,
-                       int,            d)
+  #if !defined(__aarch64__)
+    // The dup2 syscall has been deprecated on aarch64. We polyfill it below.
+    LSS_INLINE _syscall2(int,     dup2,            int,         s,
+                         int,            d)
+  #endif
   LSS_INLINE _syscall3(int,     execve,          const char*, f,
                        const char*const*,a,const char*const*, e)
   LSS_INLINE _syscall1(int,     _exit,           int,         e)
   LSS_INLINE _syscall1(int,     exit_group,      int,         e)
   LSS_INLINE _syscall3(int,     fcntl,           int,         f,
                        int,            c, long,   a)
-  LSS_INLINE _syscall0(pid_t,   fork)
+  #if !defined(__aarch64__)
+    // The fork syscall has been deprecated on aarch64. We polyfill it below.
+    LSS_INLINE _syscall0(pid_t,   fork)
+  #endif
   LSS_INLINE _syscall2(int,     fstat,           int,         f,
                       struct kernel_stat*,   b)
   LSS_INLINE _syscall2(int,     fstatfs,         int,         f,
                       struct kernel_statfs*, b)
   #if defined(__x86_64__)
     /* Need to make sure off_t isn't truncated to 32-bits under x32.  */
     LSS_INLINE int LSS_NAME(ftruncate)(int f, off_t l) {
       LSS_BODY(2, int, ftruncate, LSS_SYSCALL_ARG(f), (uint64_t)(l));
     }
   #else
     LSS_INLINE _syscall2(int, ftruncate,           int,         f,
                          off_t,          l)
   #endif
   LSS_INLINE _syscall4(int,     futex,           int*,        a,
                        int,            o, int,    v,
                       struct kernel_timespec*, t)
   LSS_INLINE _syscall3(int,     getdents,        int,         f,
-                      struct kernel_dirent*, d, int,    c)
+                       struct kernel_dirent*, d, int,    c)
   LSS_INLINE _syscall3(int,     getdents64,      int,         f,
                       struct kernel_dirent64*, d, int,    c)
   LSS_INLINE _syscall0(gid_t,   getegid)
   LSS_INLINE _syscall0(uid_t,   geteuid)
-  LSS_INLINE _syscall0(pid_t,   getpgrp)
+  #if !defined(__aarch64__)
+    // The getgprp syscall has been deprecated on aarch64.
+    LSS_INLINE _syscall0(pid_t,   getpgrp)
+  #endif
   LSS_INLINE _syscall0(pid_t,   getpid)
   LSS_INLINE _syscall0(pid_t,   getppid)
   LSS_INLINE _syscall2(int,     getpriority,     int,         a,
                        int,            b)
   LSS_INLINE _syscall3(int,     getresgid,       gid_t *,     r,
                        gid_t *,         e,       gid_t *,     s)
   LSS_INLINE _syscall3(int,     getresuid,       uid_t *,     r,
                        uid_t *,         e,       uid_t *,     s)
 #if !defined(__ARM_EABI__)
   LSS_INLINE _syscall2(int,     getrlimit,       int,         r,
@@ skipping 38 matching lines @@
   LSS_INLINE _syscall2(int,     munmap,          void*,       s,
                        size_t,         l)
   LSS_INLINE _syscall6(long,    move_pages,      pid_t,       p,
                        unsigned long,  n, void **,g, int *,   d,
                        int *,          s, int,    f)
   LSS_INLINE _syscall3(int,     mprotect,        const void *,a,
                        size_t,         l,        int,         p)
   LSS_INLINE _syscall5(void*,   _mremap,         void*,       o,
                        size_t,         os,       size_t,      ns,
                        unsigned long,  f, void *, a)
-  LSS_INLINE _syscall3(int,     open,            const char*, p,
-                       int,            f, int,    m)
-  LSS_INLINE _syscall3(int,     poll,           struct kernel_pollfd*, u,
-                       unsigned int,   n, int,    t)
+  #if !defined(__aarch64__)
+    // The open and poll syscalls have been deprecated on aarch64. We polyfill
+    // them below.
+    LSS_INLINE _syscall3(int,     open,            const char*, p,
+                         int,            f, int,    m)
+    LSS_INLINE _syscall3(int,     poll,           struct kernel_pollfd*, u,
+                         unsigned int,   n, int,    t)
+  #endif
   LSS_INLINE _syscall5(int,     prctl,           int,         option,
                        unsigned long,  arg2,
                        unsigned long,  arg3,
                        unsigned long,  arg4,
                        unsigned long,  arg5)
   LSS_INLINE _syscall4(long,    ptrace,          int,         r,
                        pid_t,          p, void *, a, void *, d)
   #if defined(__NR_quotactl)
     // Defined on x86_64 / i386 only
     LSS_INLINE _syscall4(int,  quotactl,  int,  cmd,  const char *, special,
                          int, id, caddr_t, addr)
   #endif
   LSS_INLINE _syscall3(ssize_t, read,            int,         f,
                        void *,         b, size_t, c)
-  LSS_INLINE _syscall3(int,     readlink,        const char*, p,
-                       char*,          b, size_t, s)
+  #if !defined(__aarch64__)
+    // The readlink syscall has been deprecated on aarch64. We polyfill below.
+    LSS_INLINE _syscall3(int,     readlink,        const char*, p,
+                         char*,          b, size_t, s)
+  #endif
   LSS_INLINE _syscall4(int,     rt_sigaction,    int,         s,
                        const struct kernel_sigaction*, a,
                        struct kernel_sigaction*, o, size_t,   c)
   LSS_INLINE _syscall2(int, rt_sigpending, struct kernel_sigset_t *, s,
                        size_t,         c)
   LSS_INLINE _syscall4(int, rt_sigprocmask,      int,         h,
                        const struct kernel_sigset_t*,  s,
                        struct kernel_sigset_t*,        o, size_t, c)
   LSS_INLINE _syscall2(int, rt_sigsuspend,
                        const struct kernel_sigset_t*, s,  size_t, c)
@@ skipping 14 matching lines @@
   LSS_INLINE _syscall3(int,     setresgid,       gid_t,       r,
                        gid_t,          e, gid_t,  s)
   LSS_INLINE _syscall3(int,     setresuid,       uid_t,       r,
                        uid_t,          e, uid_t,  s)
   LSS_INLINE _syscall2(int,     setrlimit,       int,         r,
                        const struct kernel_rlimit*, l)
   LSS_INLINE _syscall0(pid_t,    setsid)
   LSS_INLINE _syscall2(int,     sigaltstack,     const stack_t*, s,
                        const stack_t*, o)
   #if defined(__NR_sigreturn)
-  LSS_INLINE _syscall1(int,     sigreturn,       unsigned long, u)
+    LSS_INLINE _syscall1(int,     sigreturn,       unsigned long, u)
   #endif
-  LSS_INLINE _syscall2(int,     stat,            const char*, f,
-                      struct kernel_stat*,   b)
+  #if !defined(__aarch64__)
+    // The stat syscall has been deprecated on aarch64. We polyfill it below.
+    LSS_INLINE _syscall2(int,     stat,            const char*, f,
+                        struct kernel_stat*,   b)
+  #endif
   LSS_INLINE _syscall2(int,     statfs,          const char*, f,
                       struct kernel_statfs*, b)
   LSS_INLINE _syscall3(int,     tgkill,          pid_t,       p,
                        pid_t,          t, int,            s)
   LSS_INLINE _syscall2(int,     tkill,           pid_t,       p,
                        int,            s)
-  LSS_INLINE _syscall1(int,     unlink,           const char*, f)
+  #if !defined(__aarch64__)
+    // The unlink syscall has been deprecated on aarch64. We polyfill it below.
+    LSS_INLINE _syscall1(int,     unlink,           const char*, f)
+  #endif
   LSS_INLINE _syscall3(ssize_t, write,            int,        f,
                        const void *,   b, size_t, c)
   LSS_INLINE _syscall3(ssize_t, writev,           int,        f,
                        const struct kernel_iovec*, v, size_t, c)
   #if defined(__NR_getcpu)
     LSS_INLINE _syscall3(long, getcpu, unsigned *, cpu,
                          unsigned *, node, void *, unused)
   #endif
   #if defined(__x86_64__) ||                                                  \
      (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI32)
@@ skipping 88 matching lines @@
                                          const struct kernel_sigset_t *set,
                                          struct kernel_sigset_t *oldset) {
       return LSS_NAME(rt_sigprocmask)(how, set, oldset, (KERNEL_NSIG+7)/8);
     }
 
     LSS_INLINE int LSS_NAME(sigsuspend)(const struct kernel_sigset_t *set) {
       return LSS_NAME(rt_sigsuspend)(set, (KERNEL_NSIG+7)/8);
     }
   #endif
   #if defined(__x86_64__) || defined(__ARM_ARCH_3__) ||                       \
-      defined(__ARM_EABI__) ||                                             \
+      defined(__ARM_EABI__) || defined(__aarch64__) ||                        \
      (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI32)
     LSS_INLINE _syscall4(pid_t, wait4,            pid_t, p,
                          int*,                    s, int,       o,
                         struct kernel_rusage*,     r)
 
     LSS_INLINE pid_t LSS_NAME(waitpid)(pid_t pid, int *status, int options){
       return LSS_NAME(wait4)(pid, status, options, 0);
     }
   #endif
-  #if defined(__i386__) || defined(__x86_64__)
+  #if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__)
     LSS_INLINE _syscall4(int, openat, int, d, const char *, p, int, f, int, m)
     LSS_INLINE _syscall3(int, unlinkat, int, d, const char *, p, int, f)
   #endif
   #if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__)
     #define __NR__getresgid32 __NR_getresgid32
     #define __NR__getresuid32 __NR_getresuid32
     #define __NR__setfsgid32  __NR_setfsgid32
     #define __NR__setfsuid32  __NR_setfsuid32
     #define __NR__setresgid32 __NR_setresgid32
     #define __NR__setresuid32 __NR_setresuid32
@@ skipping 367 matching lines @@
 
     LSS_INLINE int LSS_NAME(socket)(int domain, int type, int protocol) {
       LSS_SC_BODY(3, int, 1, domain, type, protocol);
     }
 
     LSS_INLINE int LSS_NAME(socketpair)(int d, int type, int protocol,
                                         int sv[2]) {
       LSS_SC_BODY(4, int, 8, d, type, protocol, sv);
     }
   #endif
-  #if defined(__ARM_EABI__)
+  #if defined(__ARM_EABI__) || defined (__aarch64__)
     LSS_INLINE _syscall3(ssize_t, recvmsg, int, s, struct kernel_msghdr*, msg,
                          int, flags)
     LSS_INLINE _syscall3(ssize_t, sendmsg, int, s, const struct kernel_msghdr*,
                          msg, int, flags)
     LSS_INLINE _syscall6(ssize_t, sendto, int, s, const void*, buf, size_t,len,
                          int, flags, const struct kernel_sockaddr*, to,
                          unsigned int, tolen)
     LSS_INLINE _syscall2(int, shutdown, int, s, int, how)
     LSS_INLINE _syscall3(int, socket, int, domain, int, type, int, protocol)
     LSS_INLINE _syscall4(int, socketpair, int, d, int, type, int, protocol,
@@ skipping 70 matching lines @@
       if (__r7) {
         unsigned long __errnovalue = __v0;
         LSS_ERRNO = __errnovalue;
         return -1;
       } else {
         p[0] = __v0;
         p[1] = __v1;
         return 0;
       }
     }
-  #else
+  #elif !defined(__aarch64__)
+    // The unlink syscall has been deprecated on aarch64. We polyfill it below.
     LSS_INLINE _syscall1(int,     pipe,           int *, p)
   #endif
   /* TODO(csilvers): see if ppc can/should support this as well              */
   #if defined(__i386__) || defined(__ARM_ARCH_3__) ||                         \
       defined(__ARM_EABI__) ||                                             \
      (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI64)
     #define __NR__statfs64  __NR_statfs64
     #define __NR__fstatfs64 __NR_fstatfs64
     LSS_INLINE _syscall3(int, _statfs64,     const char*, p,
                          size_t, s,struct kernel_statfs64*, b)
@@ skipping 157 matching lines @@
       return LSS_NAME(_pwrite64)(fd, buf, count,
                                  LSS_LLARG_PAD o.arg[0], o.arg[1]);
     }
     LSS_INLINE int LSS_NAME(readahead)(int fd, loff_t off, int len) {
       union { loff_t off; unsigned arg[2]; } o = { off };
       return LSS_NAME(_readahead)(fd, LSS_LLARG_PAD o.arg[0], o.arg[1], len);
     }
   #endif
 #endif
 
+  #if defined(__aarch64__)

[Mark Seaborn, 2014/04/08 16:52:45]

All of this added block can be indented by 2 spaces fewer (it's not inside the
#if that the earlier code is in).

[rmcilroy, 2014/04/09 12:37:07]

Done.

+    LSS_INLINE _syscall3(int, dup3,  int, s, int, d, int, f)
+    LSS_INLINE _syscall6(void*, mmap, void*, addr, size_t, length, int, prot,
+                         int, flags, int, fd, off64_t, offset)

[Mark Seaborn, 2014/04/08 16:52:45]

You might need to change off64_t to int64_t (see the recent change r25), if
glibc defines the same typedefs on aarch64 as on x86-64.

[rmcilroy, 2014/04/09 12:37:07]

Looks like it does - updated to int64_t.

+    LSS_INLINE _syscall4(int, newfstatat, int, dirfd, const char*, pathname,
+                         struct kernel_stat*, buf, int, flags)
+    LSS_INLINE _syscall2(int, pipe2, int *, pipefd, int, flags)

[Mark Seaborn, 2014/04/08 16:52:45]

You've got a mix of "type *" and "type*" spacing styles here.  Can you make
these consistent in this added code?

[rmcilroy, 2014/04/09 12:37:07]

Done.

+    LSS_INLINE _syscall5(int, ppoll, struct kernel_pollfd*, u,
+                         unsigned int, n, const struct kernel_timespec*, t,
+                         const kernel_sigset_t*, sigmask, size_t, s)
+    LSS_INLINE _syscall4(int, readlinkat, int, d, const char *, p, char *, b,
+                         size_t, s)
+  #endif
+
+  /*
+   * Polyfills for deprecated syscalls.
+   */
+
+  #if defined(__aarch64__)
+    LSS_INLINE int LSS_NAME(dup2) (int s, int d) {

[Mark Seaborn, 2014/04/08 16:52:45]

Nit: remove space between ") (".  Same in some other cases below.

[rmcilroy, 2014/04/09 12:37:07]

Done.

+      return LSS_NAME(dup3)(s, d, 0);
+    }
+
+    LSS_INLINE int LSS_NAME(open)(const char* pathname, int flags, int mode) {

[Mark Seaborn, 2014/04/08 16:52:45]

Similar comment about "*" spacing.  Most of the existing code seems to use "type
*".

[rmcilroy, 2014/04/09 12:37:07]

Done.

+      return LSS_NAME(openat)(AT_FDCWD, pathname, flags, mode);
+    }
+
+    LSS_INLINE int LSS_NAME(unlink)(const char* pathname) {
+      return LSS_NAME(unlinkat)(AT_FDCWD, pathname, 0);
+    }
+
+    LSS_INLINE int LSS_NAME(readlink)(const char* pathname, char* buffer,
+                                      size_t size) {
+      return LSS_NAME(readlinkat)(AT_FDCWD, pathname, buffer, size);
+    }
+
+    LSS_INLINE pid_t LSS_NAME(pipe)(int* pipefd) {
+      return LSS_NAME(pipe2)(pipefd, 0);
+    }
+
+    LSS_INLINE int LSS_NAME(poll) (struct kernel_pollfd* fds, unsigned int nfds,
+                                   int timeout) {
+     struct kernel_timespec timeout_ts;
+     struct kernel_timespec* timeout_ts_p = NULL;
+
+      if (timeout >= 0) {
+        timeout_ts.tv_sec = timeout / 1000;
+        timeout_ts.tv_nsec = (timeout % 1000) * 1000000;
+        timeout_ts_p = &timeout_ts;
+      }
+      return LSS_NAME(ppoll) (fds, nfds, timeout_ts_p, NULL, 0);

[Mark Seaborn, 2014/04/08 16:52:45]

Shouldn't the last arg be NULL too, since it's a pointer?

[rmcilroy, 2014/04/09 12:37:07]

It's not a pointer, it's "size_t s" (the size of the sigmask).  This is an
additional argument on the raw syscall compared to the ppoll() library function
defined by glibc.

+    }
+
+    LSS_INLINE int LSS_NAME(stat) (const char *pathname,
+                                     struct kernel_stat *buf) {

[Mark Seaborn, 2014/04/08 16:52:45]

Nit: align arg to match "("

[rmcilroy, 2014/04/09 12:37:07]

Done.

+      return LSS_NAME(newfstatat) (AT_FDCWD, pathname, buf, 0);
+    }
+
+    LSS_INLINE pid_t LSS_NAME(fork)(void) {
+      // No fork syscall on aarch64 - implement by means of the clone syscall.
+      pid_t pid = LSS_NAME(getpid)();

[Mark Seaborn, 2014/04/08 16:52:45]

It's not obvious to me why you'd need this...

[rmcilroy, 2014/04/09 12:37:07]

See below

+
+      int flags = CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID | SIGCHLD;
+      void *child_stack = NULL;
+      void *parent_tidptr = NULL;
+      void *newtls = NULL;
+      void *child_tidptr = &pid;

[Mark Seaborn, 2014/04/08 16:52:45]

...or this, since you don't return pid, you return the result of clone().

[rmcilroy, 2014/04/09 12:37:07]

Yeah, this was for the CLONE_CHILD_SETTID and CLONE_CHILD_CLEARTID flags, which
messes with the tid pointed too by this argument in the child process.  GLibC
passes a pointer to the tid field in the thread's "struct pthread" data
structure, however, we can't really get at that structure out-with glibc, so we
wouldn't be able to update the right field anyway.  

I was originally passing the pid in-case it was important for clone to read the
value as well as update it, but it doesn't seem to and you are right - given
that it will change a local variable which I am not returning there doesn't seem
to be much reason to do this.   It seems to work fine without these flags or the
pointer, so I've removed them.

[Mark Seaborn, 2014/04/14 19:15:21]

Hmm, I see what you mean.  I suppose you got this from glibc code which does:

#define ARCH_FORK() \
  INLINE_SYSCALL (clone, 4,                                                   \
                  CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID | SIGCHLD, 0,     \
                  NULL, &THREAD_SELF->tid)

It might be worth adding a comment like "Note that this does not reset glibc's
cached view of the PID/TID, so some glibc interfaces might go wrong in the
forked subprocess".  Of course, this will be true when calling the fork()
syscall directly too, on other architectures.

[rmcilroy, 2014/04/15 09:18:48]

Yes exactly.  I added the comment.

+
+      LSS_REG(0, flags);
+      LSS_REG(1, child_stack);
+      LSS_REG(2, parent_tidptr);
+      LSS_REG(3, newtls);
+      LSS_REG(4, child_tidptr);
+      LSS_BODY(pid_t, clone, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3),
+               "r"(__r4));
+    }
+  #endif
+
 #ifdef __ANDROID__
   /* These restore the original values of these macros saved by the
    * corresponding #pragma push_macro near the top of this file. */
 # pragma pop_macro("stat64")
 # pragma pop_macro("fstat64")
 # pragma pop_macro("lstat64")
 #endif
 
 #if defined(__cplusplus) && !defined(SYS_CPLUSPLUS)
 }
 #endif
 
 #endif
 #endif