Fix usage with musl libc.

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 1824 matching lines @@
                            : "esp", "memory", "ecx", "edx", "esi", "edi");
       LSS_RETURN(int, __res);
     }
 
     #define __NR__fadvise64_64 __NR_fadvise64_64
     LSS_INLINE _syscall6(int, _fadvise64_64, int, fd,
                          unsigned, offset_lo, unsigned, offset_hi,
                          unsigned, len_lo, unsigned, len_hi,
                          int, advice)
 
-    LSS_INLINE int LSS_NAME(fadvise64)(int fd, loff_t offset,
-                                       loff_t len, int advice) {
+    LSS_INLINE int LSS_NAME(fadvise64)(int fd, int64_t offset,
+                                       int64_t len, int advice) {
       return LSS_NAME(_fadvise64_64)(fd,
                                      (unsigned)offset, (unsigned)(offset >>32),
                                      (unsigned)len, (unsigned)(len >> 32),
                                      advice);
     }
 
     #define __NR__fallocate __NR_fallocate
     LSS_INLINE _syscall6(int, _fallocate, int, fd,
                          int, mode,
                          unsigned, offset_lo, unsigned, offset_hi,
                          unsigned, len_lo, unsigned, len_hi)
 
     LSS_INLINE int LSS_NAME(fallocate)(int fd, int mode,
-                                       loff_t offset, loff_t len) {
-      union { loff_t off; unsigned w[2]; } o = { offset }, l = { len };
+                                       int64_t offset, int64_t len) {
+      union { int64_t off; unsigned w[2]; } o = { offset }, l = { len };
       return LSS_NAME(_fallocate)(fd, mode, o.w[0], o.w[1], l.w[0], l.w[1]);
     }
 
     LSS_INLINE _syscall1(int, set_thread_area, void *, u)
     LSS_INLINE _syscall1(int, get_thread_area, void *, u)
 
     LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) {
       /* On i386, 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.
@@ skipping 270 matching lines @@
                                "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)
 
-    /* Need to make sure loff_t isn't truncated to 32-bits under x32.  */
-    LSS_INLINE int LSS_NAME(fadvise64)(int fd, loff_t offset, loff_t len,
+    /* Need to make sure int_t isn't truncated to 32-bits under x32.  */
+    LSS_INLINE int LSS_NAME(fadvise64)(int fd, int64_t offset, int64_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
@@ skipping 1020 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__)
-    /* Need to make sure loff_t isn't truncated to 32-bits under x32.  */
-    LSS_INLINE int LSS_NAME(fallocate)(int f, int mode, loff_t offset,
-                                       loff_t len) {
+    /* Need to make sure int64_t isn't truncated to 32-bits under x32.  */
+    LSS_INLINE int LSS_NAME(fallocate)(int f, int mode, int64_t offset,
+                                       int64_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);
     }
 
@@ skipping 239 matching lines @@
      (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) || defined(__PPC__)
     #define __NR__sigaction   __NR_sigaction
     #define __NR__sigpending  __NR_sigpending
     #define __NR__sigprocmask __NR_sigprocmask
     #define __NR__sigsuspend  __NR_sigsuspend
     #define __NR__socketcall  __NR_socketcall
     LSS_INLINE _syscall2(int, fstat64,             int, f,
                          struct kernel_stat64 *, b)
     LSS_INLINE _syscall5(int, _llseek,     uint, fd,
                          unsigned long, hi, unsigned long, lo,
-                         loff_t *, res, uint, wh)
+                         int64_t *, res, uint, wh)
 #if !defined(__ARM_EABI__)
     LSS_INLINE _syscall1(void*, mmap,              void*, a)
 #endif
     LSS_INLINE _syscall6(void*, mmap2,             void*, s,
                          size_t,                   l, int,               p,
                          int,                      f, int,               d,
                          off_t,                o)
     LSS_INLINE _syscall3(int,   _sigaction,        int,   s,
                          const struct kernel_old_sigaction*,  a,
                          struct kernel_old_sigaction*,        o)
@@ skipping 388 matching lines @@
 #endif
       }
       case _SC_PAGESIZE:
         return __getpagesize();
       default:
         LSS_ERRNO = ENOSYS;
         return -1;
     }
   }
   #if defined(__x86_64__)
-    /* Need to make sure loff_t isn't truncated to 32-bits under x32.  */
-    LSS_INLINE ssize_t LSS_NAME(pread64)(int f, void *b, size_t c, loff_t o) {
+    /* Need to make sure int64_t isn't truncated to 32-bits under x32.  */
+    LSS_INLINE ssize_t LSS_NAME(pread64)(int f, void *b, size_t c, int64_t o) {
       LSS_BODY(4, ssize_t, pread64, LSS_SYSCALL_ARG(f), LSS_SYSCALL_ARG(b),
                                     LSS_SYSCALL_ARG(c), (uint64_t)(o));
     }
 
     LSS_INLINE ssize_t LSS_NAME(pwrite64)(int f, const void *b, size_t c,
-                                          loff_t o) {
+                                          int64_t o) {
       LSS_BODY(4, ssize_t, pwrite64, LSS_SYSCALL_ARG(f), LSS_SYSCALL_ARG(b),
                                      LSS_SYSCALL_ARG(c), (uint64_t)(o));
     }
 
-    LSS_INLINE int LSS_NAME(readahead)(int f, loff_t o, unsigned c) {
+    LSS_INLINE int LSS_NAME(readahead)(int f, int64_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)
+                         int64_t,         o)
     LSS_INLINE _syscall4(ssize_t, pwrite64,       int,         f,
                          const void *,   b, size_t,   c,
-                         loff_t,         o)
+                         int64_t,         o)
     LSS_INLINE _syscall3(int,     readahead,      int,         f,
-                         loff_t,         o, unsigned, c)
+                         int64_t,         o, unsigned, c)
     LSS_INLINE _syscall6(void *, mmap, void *, addr, size_t, length, int, prot,
                          int, flags, int, fd, int64_t, offset)
   #else
     #define __NR__pread64   __NR_pread64
     #define __NR__pwrite64  __NR_pwrite64
     #define __NR__readahead __NR_readahead
     #if defined(__ARM_EABI__) || defined(__mips__)
       /* On ARM and MIPS, a 64-bit parameter has to be in an even-odd register
        * pair. Hence these calls ignore their fourth argument (r3) so that their
        * fifth and sixth make such a pair (r4,r5).
@@ skipping 18 matching lines @@
                            long, o2)
       LSS_INLINE _syscall4(int, _readahead,          int,         f,
                            unsigned,       o1, unsigned, o2, size_t, c)
     #endif
     /* We force 64bit-wide parameters onto the stack, then access each
      * 32-bit component individually. This guarantees that we build the
      * correct parameters independent of the native byte-order of the
      * underlying architecture.
      */
     LSS_INLINE ssize_t LSS_NAME(pread64)(int fd, void *buf, size_t count,
-                                         loff_t off) {
-      union { loff_t off; unsigned arg[2]; } o = { off };
+                                         int64_t off) {
+      union { int64_t off; unsigned arg[2]; } o = { off };
       return LSS_NAME(_pread64)(fd, buf, count,
                                 LSS_LLARG_PAD o.arg[0], o.arg[1]);
     }
     LSS_INLINE ssize_t LSS_NAME(pwrite64)(int fd, const void *buf,
-                                          size_t count, loff_t off) {
-      union { loff_t off; unsigned arg[2]; } o = { off };
+                                          size_t count, int64_t off) {
+      union { int64_t off; unsigned arg[2]; } o = { off };
       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 };
+    LSS_INLINE int LSS_NAME(readahead)(int fd, int64_t off, int len) {
+      union { int64_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__)
   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, int64_t, offset)
   LSS_INLINE _syscall4(int, newfstatat, int, dirfd, const char *, pathname,
@@ skipping 77 matching lines @@
 # pragma pop_macro("fstat64")
 # pragma pop_macro("lstat64")
 #endif
 
 #if defined(__cplusplus) && !defined(SYS_CPLUSPLUS)
 }
 #endif
 
 #endif
 #endif