add x32 ABI support

lss/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 85 matching lines @@
  * multiple nested 'extern "C"' blocks, just add another one here.
  */
 extern "C" {
 #endif
 
 #include <errno.h>
 #include <fcntl.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>
 #include <unistd.h>
 #include <linux/unistd.h>
 #include <endian.h>
 
@@ skipping 285 matching lines @@
   unsigned           st_atime_nsec_;
   unsigned           st_mtime_;
   unsigned           st_mtime_nsec_;
   unsigned           st_ctime_;
   unsigned           st_ctime_nsec_;
   unsigned           __unused4;
   unsigned           __unused5;
 };
 #elif defined(__x86_64__)
 struct kernel_stat {
-  unsigned long      st_dev;
-  unsigned long      st_ino;
-  unsigned long      st_nlink;
+  unsigned long long st_dev;

[Mark Seaborn, 2013/03/25 19:59:05]

Maybe use uint64_t/int64_t in this struct for brevity and to be explicit?

[vapier, 2013/03/25 20:21:08]

Done.

+  unsigned long long st_ino;
+  unsigned long long st_nlink;
   unsigned           st_mode;
   unsigned           st_uid;
   unsigned           st_gid;
   unsigned           __pad0;
-  unsigned long      st_rdev;
-  long               st_size;
-  long               st_blksize;
-  long               st_blocks;
-  unsigned long      st_atime_;
-  unsigned long      st_atime_nsec_;
-  unsigned long      st_mtime_;
-  unsigned long      st_mtime_nsec_;
-  unsigned long      st_ctime_;
-  unsigned long      st_ctime_nsec_;
-  long               __unused[3];
+  unsigned long long st_rdev;
+  long long          st_size;
+  long long          st_blksize;
+  long long          st_blocks;
+  unsigned long long st_atime_;
+  unsigned long long st_atime_nsec_;
+  unsigned long long st_mtime_;
+  unsigned long long st_mtime_nsec_;
+  unsigned long long st_ctime_;
+  unsigned long long st_ctime_nsec_;
+  long long          __unused[3];
 };
 #elif defined(__PPC__)
 struct kernel_stat {
   unsigned           st_dev;
   unsigned long      st_ino;      // ino_t
   unsigned long      st_mode;     // mode_t
   unsigned short     st_nlink;    // nlink_t
   unsigned           st_uid;      // uid_t
   unsigned           st_gid;      // gid_t
   unsigned           st_rdev;
@@ skipping 76 matching lines @@
   long               f_frsize;
   long               f_blocks;
   long               f_bfree;
   long               f_files;
   long               f_ffree;
   long               f_bavail;
   struct { int val[2]; } f_fsid;
   long               f_namelen;
   long               f_spare[6];
 };
-#else
+#elif !defined(__x86_64__)

[Mark Seaborn, 2013/03/25 19:59:05]

Using "!defined" to put the catch-all case first is a little odd.  How about
"#if defined(__x86_64__)" and swap this definition with the "#else" definition?

[vapier, 2013/03/25 20:21:08]

Done.

 struct kernel_statfs {
-  /* x86_64 actually defines all these fields as signed, whereas all other  */
-  /* platforms define them as unsigned. Leaving them at unsigned should not */
-  /* cause any problems.                                                    */
   unsigned long      f_type;
   unsigned long      f_bsize;
   unsigned long      f_blocks;
   unsigned long      f_bfree;
   unsigned long      f_bavail;
   unsigned long      f_files;
   unsigned long      f_ffree;
   struct { int val[2]; } f_fsid;
   unsigned long      f_namelen;
   unsigned long      f_frsize;
   unsigned long      f_spare[5];
 };
+#else
+struct kernel_statfs {
+  /* x86_64 actually defines all these fields as signed, whereas all other  */
+  /* platforms define them as unsigned. Leaving them at unsigned should not */
+  /* cause any problems.  Make sure these are 64-bit even on x32.           */

[Mark Seaborn, 2013/03/25 19:59:05]

Nit: you're mixing single-space and double-space sentence spacing in the same
paragraph

[vapier, 2013/03/25 20:21:08]

Done.

+  unsigned long long f_type;
+  unsigned long long f_bsize;
+  unsigned long long f_blocks;
+  unsigned long long f_bfree;
+  unsigned long long f_bavail;
+  unsigned long long f_files;
+  unsigned long long f_ffree;
+  struct { int val[2]; } f_fsid;
+  unsigned long long f_namelen;
+  unsigned long long f_frsize;
+  unsigned long long f_spare[5];
+};
 #endif
 
 
 /* Definitions missing from the standard header files                        */
 #ifndef O_DIRECTORY
 #if defined(__ARM_ARCH_3__) || defined(__ARM_EABI__)
 #define O_DIRECTORY             0040000
 #else
 #define O_DIRECTORY             0200000
 #endif
@@ skipping 1231 matching lines @@
               "test %%rcx, %%rcx\n"                                           \
               "jz   10001f\n"                                                 \
               "call *%%rcx\n"                                                 \
               "jmp  10002f\n"                                                 \
         "10001:syscall\n"                                                     \
         "10002:\n"
 
     #else
     #define LSS_ENTRYPOINT "syscall\n"
     #endif
+
+    /* The x32 ABI has 32 bit longs, but the syscall interface is 64 bit.
+     * We need to explicitly cast to an unsigned 64 bit type to avoid implicit
+     * sign extension.  We can't cast pointers directly because those are
+     * 32 bits, and gcc will dump ugly warnings about casting from a pointer
+     * to an integer of a different size.
+     */
+    #define LSS_SYSCALL_ARG(a) ((uint64_t)(uintptr_t)(a))
+    #define _LSS_RETURN(type, res, cast)                                      \
+      do {                                                                    \
+        if ((uint64_t)(res) >= (uint64_t)(-4095)) {                           \
+          LSS_ERRNO = -(res);                                                 \
+          res = -1;                                                           \
+        }                                                                     \
+        return (type)(cast)(res);                                             \
+      } while (0)
+    #undef LSS_RETURN
+    #define LSS_RETURN(type, res) _LSS_RETURN(type, res, uintptr_t)
+
     #undef  LSS_BODY
-    #define LSS_BODY(type,name, ...)                                          \
-          long __res;                                                         \
-          __asm__ __volatile__(LSS_ENTRYPOINT                                 \
-            : "=a" (__res) : "0" (__NR_##name),                               \
-            ##__VA_ARGS__ : "r11", "rcx", "memory");                          \
-          LSS_RETURN(type, __res)
+    #define _LSS_BODY(nr, type, name, cast, ...)                              \

[Mark Seaborn, 2013/03/25 19:59:05]

Maybe 'nr' -> 'arg_count', otherwise it looks like nr could be the syscall
number

[vapier, 2013/03/25 20:21:08]

i used nr to match the existing mips style that exists below

 #define LSS_BODY(nr, type, name, args...)

i can pick a diff name if you want

[Mark Seaborn, 2013/03/25 23:22:01]

Ah, I didn't realise there is existing code that uses this pattern.  Can you
comment the refactoring in the commit message to explain that it follows those
existing patterns?

[vapier, 2013/03/26 04:01:11]

Done.

+          long long __res;                                                    \
+          __asm__ __volatile__(LSS_BODY_ASM##nr LSS_ENTRYPOINT                \
+            : "=a" (__res)                                                    \
+            : "0" (__NR_##name) LSS_BODY_ARG##nr(__VA_ARGS__)                 \
+            : LSS_BODY_CLB##nr "r11", "rcx", "memory");                       \
+          _LSS_RETURN(type, __res, cast)
+    #define LSS_BODY(nr, type, name, args...) \
+      _LSS_BODY(nr, type, name, uintptr_t, ## args)
+
+    #define LSS_BODY_ASM0

[Mark Seaborn, 2013/03/25 19:59:05]

IIRC, there are some users of lss that #include linux_syscall_support.h multiple
times with different #define settings.

Yes...

$ git grep SYS_LINUX_SYSCALL_SUPPORT_
...
third_party/tcmalloc/chromium/src/base/linuxthreads.cc:    #undef 
SYS_LINUX_SYSCALL_SUPPORT_H
third_party/tcmalloc/chromium/src/base/linuxthreads.cc:      #undef 
SYS_LINUX_SYSCALL_SUPPORT_H

(Argh.)

This means that if you #define something new, you have to #undef it first to
avoid redefinition warnings.

[vapier, 2013/03/25 20:21:08]

i'll add the #undef, but i don't see how this can work

In file included from test-skel.h:11:0,
                 from lseek.c:1:
../lss/linux_syscall_support.h:166:8: error: redefinition of ‘struct
kernel_dirent64’
In file included from test-skel.h:9:0,
                 from lseek.c:1:
../lss/linux_syscall_support.h:166:8: note: originally defined here
...
../lss/linux_syscall_support.h:2715:1: error: redefinition of ‘sys_close’
In file included from test-skel.h:9:0,
                 from lseek.c:1:
../lss/linux_syscall_support.h:2715:1: note: previous definition of ‘sys_close’
was here

and those are just samples ... i see like ~100 redef errors

[Mark Seaborn, 2013/03/25 23:22:01]

Have a look at third_party/tcmalloc/chromium/src/base/linuxthreads.cc:

namespace {
  class SysCalls {
   public:
    #define SYS_CPLUSPLUS
    #define SYS_ERRNO     my_errno
    #define SYS_INLINE    inline
    #define SYS_PREFIX    -1
    #undef  SYS_LINUX_SYSCALL_SUPPORT_H
    #include "linux_syscall_support.h"
    SysCalls() : my_errno(0) { }
    int my_errno;
  };
}

This is inside a namespace+class, so the struct redefinitions aren't
redefinitions, only the preprocessor redefinitions are. :-)

[vapier, 2013/03/26 04:01:11]

sneaky

+    #define LSS_BODY_ASM1 LSS_BODY_ASM0
+    #define LSS_BODY_ASM2 LSS_BODY_ASM1
+    #define LSS_BODY_ASM3 LSS_BODY_ASM2
+    #define LSS_BODY_ASM4 LSS_BODY_ASM3 "movq %5,%%r10;"
+    #define LSS_BODY_ASM5 LSS_BODY_ASM4 "movq %6,%%r8;"
+    #define LSS_BODY_ASM6 LSS_BODY_ASM5 "movq %7,%%r9;"
+
+    #define LSS_BODY_CLB0
+    #define LSS_BODY_CLB1 LSS_BODY_CLB0
+    #define LSS_BODY_CLB2 LSS_BODY_CLB1
+    #define LSS_BODY_CLB3 LSS_BODY_CLB2
+    #define LSS_BODY_CLB4 LSS_BODY_CLB3 "r10",
+    #define LSS_BODY_CLB5 LSS_BODY_CLB4 "r8",
+    #define LSS_BODY_CLB6 LSS_BODY_CLB5 "r9",
+
+    #define LSS_BODY_ARG0()
+    #define LSS_BODY_ARG1(arg1) \
+      LSS_BODY_ARG0(), "D" (arg1)
+    #define LSS_BODY_ARG2(arg1, arg2) \
+      LSS_BODY_ARG1(arg1), "S" (arg2)
+    #define LSS_BODY_ARG3(arg1, arg2, arg3) \
+      LSS_BODY_ARG2(arg1, arg2), "d" (arg3)
+    #define LSS_BODY_ARG4(arg1, arg2, arg3, arg4) \
+      LSS_BODY_ARG3(arg1, arg2, arg3), "r" (arg4)
+    #define LSS_BODY_ARG5(arg1, arg2, arg3, arg4, arg5) \
+      LSS_BODY_ARG4(arg1, arg2, arg3, arg4), "r" (arg5)
+    #define LSS_BODY_ARG6(arg1, arg2, arg3, arg4, arg5, arg6) \
+      LSS_BODY_ARG5(arg1, arg2, arg3, arg4, arg5), "r" (arg6)
+
     #undef _syscall0
     #define _syscall0(type,name)                                              \
       type LSS_NAME(name)(void) {                                             \
-        LSS_BODY(type, name);                                                 \
+        LSS_BODY(0, type, name);                                              \
       }
     #undef _syscall1
     #define _syscall1(type,name,type1,arg1)                                   \
       type LSS_NAME(name)(type1 arg1) {                                       \
-        LSS_BODY(type, name, "D" ((long)(arg1)));                             \
+        LSS_BODY(1, type, name, LSS_SYSCALL_ARG(arg1));                       \
       }
     #undef _syscall2
     #define _syscall2(type,name,type1,arg1,type2,arg2)                        \
       type LSS_NAME(name)(type1 arg1, type2 arg2) {                           \
-        LSS_BODY(type, name, "D" ((long)(arg1)), "S" ((long)(arg2)));         \
+        LSS_BODY(2, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2));\
       }
     #undef _syscall3
     #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)             \
       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) {               \
-        LSS_BODY(type, name, "D" ((long)(arg1)), "S" ((long)(arg2)),          \
-                             "d" ((long)(arg3)));                             \
+        LSS_BODY(3, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2), \
+                                LSS_SYSCALL_ARG(arg3));                       \
       }
     #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) {   \
-          long __res;                                                         \
-          __asm__ __volatile__("movq %5,%%r10;" LSS_ENTRYPOINT :              \
-            "=a" (__res) : "0" (__NR_##name),                                 \
-            "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)),       \
-            "r" ((long)(arg4)) : "r10", "r11", "rcx", "memory");              \
-          LSS_RETURN(type, __res);                                            \
+        LSS_BODY(4, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2), \
+                                LSS_SYSCALL_ARG(arg3), LSS_SYSCALL_ARG(arg4));\
       }
     #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) {                                       \
-          long __res;                                                         \
-          __asm__ __volatile__("movq %5,%%r10; movq %6,%%r8;" LSS_ENTRYPOINT :\
-            "=a" (__res) : "0" (__NR_##name),                                 \
-            "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)),       \
-            "r" ((long)(arg4)), "r" ((long)(arg5)) :                          \
-            "r8", "r10", "r11", "rcx", "memory");                             \
-          LSS_RETURN(type, __res);                                            \
+        LSS_BODY(5, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2), \
+                                LSS_SYSCALL_ARG(arg3), LSS_SYSCALL_ARG(arg4), \
+                                LSS_SYSCALL_ARG(arg5));                       \
       }
     #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) {                           \
-          long __res;                                                         \
-          __asm__ __volatile__("movq %5,%%r10; movq %6,%%r8; movq %7,%%r9;"   \

[Mark Seaborn, 2013/03/25 19:59:05]

FWIW, I find this somewhat easier to understand than the new
more-heavily-macro-using version.  Though there is some duplication, there is
less for me to expand out in my head to check correctness of the inline asm.

Maybe you could define something like this, which omits the casts:

#define LSS_BODY4(type, name, arg1, arg2, arg3, arg4) \
          long __res;                                                         \
          __asm__ __volatile__("movq %5,%%r10;" LSS_ENTRYPOINT :              \
            "=a" (__res) : "0" (__NR_##name),                                 \
            "D" ((arg1)), "S" ((arg2)), "d" ((arg3)),                         \
            "r" ((arg4)) : "r10", "r11", "rcx", "memory");                    \
          LSS_RETURN(type, __res);                                            \

...
    #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_BODY4(type, name, LSS_SYSCALL_ARG(arg1), ......)                \
      }

What do you think?  If you want to keep the macroified version I will look at it
harder. :-)

[vapier, 2013/03/25 20:21:08]

i like the denser version myself because it's harder to have the different
variants fall out of sync.  this way, you fix it once in one place, and you're
done.  you don't have to worry about copying & pasting the same fix elsewhere. 
your suggestion would mitigate that somewhat compared to the code in the tree
right now, but mine goes all the way :).

-                               LSS_ENTRYPOINT :                               \
-            "=a" (__res) : "0" (__NR_##name),                                 \
-            "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)),       \
-            "r" ((long)(arg4)), "r" ((long)(arg5)), "r" ((long)(arg6)) :      \
-            "r8", "r9", "r10", "r11", "rcx", "memory");                       \
-          LSS_RETURN(type, __res);                                            \
+        LSS_BODY(6, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2), \
+                                LSS_SYSCALL_ARG(arg3), LSS_SYSCALL_ARG(arg4), \
+                                LSS_SYSCALL_ARG(arg5), LSS_SYSCALL_ARG(arg6));\
       }
     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;
+      long long __res;
       {
         __asm__ __volatile__(/* if (fn == NULL)
                               *   return -EINVAL;
                               */
                              "testq  %4,%4\n"
                              "jz     1f\n"
 
                              /* if (child_stack == NULL)
                               *   return -EINVAL;
                               */
@@ skipping 42 matching lines @@
                               */
                              "movq   %%rax,%%rdi\n"
                              "movq   %3,%%rax\n"
                              LSS_ENTRYPOINT
 
                              /* Return to parent.
                               */
                            "1:\n"
                              : "=a" (__res)
                              : "0"(-EINVAL), "i"(__NR_clone), "i"(__NR_exit),
-                               "r"(fn), "S"(child_stack), "D"(flags), "r"(arg),
-                               "d"(parent_tidptr), "r"(newtls),
-                               "r"(child_tidptr)
+                               "r"(LSS_SYSCALL_ARG(fn)),
+                               "S"(LSS_SYSCALL_ARG(child_stack)),
+                               "D"(LSS_SYSCALL_ARG(flags)),
+                               "r"(LSS_SYSCALL_ARG(arg)),
+                               "d"(LSS_SYSCALL_ARG(parent_tidptr)),
+                               "r"(LSS_SYSCALL_ARG(newtls)),
+                               "r"(LSS_SYSCALL_ARG(child_tidptr))
                              : "rsp", "memory", "r8", "r10", "r11", "rcx");
       }
       LSS_RETURN(int, __res);
     }
     LSS_INLINE _syscall2(int, arch_prctl, int, c, void *, a)
-    LSS_INLINE _syscall4(int, fadvise64, int, fd, loff_t, offset, loff_t, len,
-                         int,  advice)
+
+    /* Need to make sure off_t is passed as 64-bits even under x32.  */

[Mark Seaborn, 2013/03/25 19:59:05]

'loff_t' -- see later comment

[vapier, 2013/03/25 20:21:08]

Done.

+    int LSS_NAME(fadvise64)(int fd, loff_t offset, loff_t len, int advice) {
+      LSS_BODY(4, int, fadvise64, LSS_SYSCALL_ARG(fd), (uint64_t)(offset),
+                                  (uint64_t)(len), LSS_SYSCALL_ARG(advice));
+    }
 
     LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) {
       /* On x86-64, the kernel does not know how to return from
        * a signal handler. Instead, it relies on user space to provide a
        * restorer function that calls the rt_sigreturn() system call.
        * Unfortunately, we cannot just reference the glibc version of this
        * function, as glibc goes out of its way to make it inaccessible.
        */
-      void (*res)(void);
+      long long res;
       __asm__ __volatile__("call   2f\n"
                          "0:.align 16\n"
                          "1:movq   %1,%%rax\n"
                            LSS_ENTRYPOINT
                          "2:popq   %0\n"
                            "addq   $(1b-0b),%0\n"
                            : "=a" (res)
                            : "i"  (__NR_rt_sigreturn));
-      return res;
+      return (void (*)())(uintptr_t)res;
     }
   #elif defined(__ARM_ARCH_3__)
     /* 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__("r"#r) = (long)a
     #undef  LSS_BODY
@@ skipping 685 matching lines @@
                        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)
   LSS_INLINE _syscall2(int,     fstat,           int,         f,
                       struct kernel_stat*,   b)
   LSS_INLINE _syscall2(int,     fstatfs,         int,         f,
                       struct kernel_statfs*, b)
-  LSS_INLINE _syscall2(int, ftruncate,           int,         f,
-                       off_t,          l)
+  #if defined(__x86_64__)
+    /* Need to make sure off_t is passed as 64-bits even under x32.  */
+    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)
   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)
@@ skipping 28 matching lines @@
   LSS_INLINE _syscall3(ssize_t, llistxattr,      const char *,p,
                        char *,   l,              size_t,      s)
   LSS_INLINE _syscall3(int,     ioctl,           int,         d,
                        int,     r,               void *,      a)
   LSS_INLINE _syscall2(int,     ioprio_get,      int,         which,
                        int,     who)
   LSS_INLINE _syscall3(int,     ioprio_set,      int,         which,
                        int,     who,             int,         ioprio)
   LSS_INLINE _syscall2(int,     kill,            pid_t,       p,
                        int,            s)
-  LSS_INLINE _syscall3(off_t,   lseek,           int,         f,
-                       off_t,          o, int,    w)
+  #if defined(__x86_64__)
+    /* Need to make sure off_t is passed as 64-bits even under x32.  */
+    off_t LSS_NAME(lseek)(int f, off_t o, int w) {
+      _LSS_BODY(3, off_t, lseek, off_t, LSS_SYSCALL_ARG(f), (uint64_t)(o),
+                                        LSS_SYSCALL_ARG(w));
+    }
+  #else
+    LSS_INLINE _syscall3(off_t,   lseek,           int,         f,
+                         off_t,          o, int,    w)
+  #endif
   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)
@@ skipping 78 matching lines @@
                          int,                     f,
                          const struct kernel_sockaddr*, a, int, t)
     LSS_INLINE _syscall2(int, shutdown,           int,   s,
                          int,                     h)
     LSS_INLINE _syscall3(int, socket,             int,   d,
                          int,                     t, int,       p)
     LSS_INLINE _syscall4(int, socketpair,         int,   d,
                          int,                     t, int,       p, int*, s)
   #endif
   #if defined(__x86_64__)
-    LSS_INLINE _syscall4(int, fallocate, int, fd, int, mode,
-                         loff_t, offset, loff_t, len)
+    /* Need to make sure off_t is passed as 64-bits even under x32.  */

[Mark Seaborn, 2013/03/25 19:59:05]

'loff_t'

[vapier, 2013/03/25 20:21:08]

Done.

+    int LSS_NAME(fallocate)(int f, int mode, loff_t offset, loff_t len) {
+      LSS_BODY(4, int, fallocate, LSS_SYSCALL_ARG(f), LSS_SYSCALL_ARG(mode),
+                                  (uint64_t)(offset), (uint64_t)(len));
+    }
 
     LSS_INLINE int LSS_NAME(getresgid32)(gid_t *rgid,
                                          gid_t *egid,
                                          gid_t *sgid) {
       return LSS_NAME(getresgid)(rgid, egid, sgid);
     }
 
     LSS_INLINE int LSS_NAME(getresuid32)(uid_t *ruid,
                                          uid_t *euid,
                                          uid_t *suid) {
       return LSS_NAME(getresuid)(ruid, euid, suid);
     }
 
-    LSS_INLINE _syscall6(void*, mmap,              void*, s,
-                         size_t,                   l, int,               p,
-                         int,                      f, int,               d,
-                         __off64_t,                o)
+    /* Need to make sure off_t is passed as 64-bits even under x32.  */
+    void* LSS_NAME(mmap)(void *s, size_t l, int p, int f, int d, __off64_t o) {
+      LSS_BODY(6, void*, mmap, LSS_SYSCALL_ARG(s), LSS_SYSCALL_ARG(l),
+                               LSS_SYSCALL_ARG(p), LSS_SYSCALL_ARG(f),
+                               LSS_SYSCALL_ARG(d), (uint64_t)(o));
+    }
 
     LSS_INLINE _syscall4(int, newfstatat,         int,   d,
                          const char *,            p,
                         struct kernel_stat*,       b, int, f)
 
     LSS_INLINE int LSS_NAME(setfsgid32)(gid_t gid) {
       return LSS_NAME(setfsgid)(gid);
     }
 
     LSS_INLINE int LSS_NAME(setfsuid32)(uid_t uid) {
@@ skipping 623 matching lines @@
             ? 8192 : limit.rlim_cur;
 #endif
       }
       case _SC_PAGESIZE:
         return __getpagesize();
       default:
         LSS_ERRNO = ENOSYS;
         return -1;
     }
   }
-  #if defined(__x86_64__) ||                                                  \
-     (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI64)
+  #if defined(__x86_64__)
+    /* Need to make sure off_t is passed as 64-bits even under x32.  */

[Mark Seaborn, 2013/03/25 19:59:05]

You mean loff_t here, since that's what these syscalls use.

"even under x32" isn't quite right.  Maybe "Need to make sure off_t is passed as
64-bits.  Special-case this to avoid truncation on 32"?

[vapier, 2013/03/25 20:21:08]

Done.

+    ssize_t LSS_NAME(pread64)(int f, void *b, size_t c, loff_t o) {
+      LSS_BODY(4, ssize_t, pread64, LSS_SYSCALL_ARG(f), LSS_SYSCALL_ARG(b),
+                                    LSS_SYSCALL_ARG(c), (uint64_t)(o));
+    }
+
+    ssize_t LSS_NAME(pwrite64)(int f, const void *b, size_t c, loff_t o) {
+      LSS_BODY(4, ssize_t, pwrite64, LSS_SYSCALL_ARG(f), LSS_SYSCALL_ARG(b),
+                                     LSS_SYSCALL_ARG(c), (uint64_t)(o));
+    }
+
+    int LSS_NAME(readahead)(int f, loff_t o, unsigned c) {
+      LSS_BODY(3, int, readahead, LSS_SYSCALL_ARG(f), (uint64_t)(o),
+                                  LSS_SYSCALL_ARG(c));
+    }
+  #elif defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI64
     LSS_INLINE _syscall4(ssize_t, pread64,        int,         f,
                          void *,         b, size_t,   c,
                          loff_t,         o)
     LSS_INLINE _syscall4(ssize_t, pwrite64,       int,         f,
                          const void *,   b, size_t,   c,
                          loff_t,         o)
     LSS_INLINE _syscall3(int,     readahead,      int,         f,
                          loff_t,         o, unsigned, c)
   #else
     #define __NR__pread64   __NR_pread64
@@ skipping 56 matching lines @@
 # pragma pop_macro("fstat64")
 # pragma pop_macro("lstat64")
 #endif
 
 #if defined(__cplusplus) && !defined(SYS_CPLUSPLUS)
 }
 #endif
 
 #endif
 #endif