Alias all LFS64 symbols to their non-LFS64 counterparts on musl

Author: bossmc

src/unix/linux_like/linux/mod.rs

@@ -3764,20 +3764,29 @@ extern "C" {
     pub fn mprotect(addr: *mut ::c_void, len: ::size_t, prot: ::c_int) -> ::c_int;
     pub fn __errno_location() -> *mut ::c_int;
 
+    #[cfg(not(target_env = "musl"))]
     pub fn fopen64(filename: *const c_char, mode: *const c_char) -> *mut ::FILE;
+    #[cfg(not(target_env = "musl"))]
     pub fn freopen64(
         filename: *const c_char,
         mode: *const c_char,
         file: *mut ::FILE,
     ) -> *mut ::FILE;
+    #[cfg(not(target_env = "musl"))]
     pub fn tmpfile64() -> *mut ::FILE;
+    #[cfg(not(target_env = "musl"))]
     pub fn fgetpos64(stream: *mut ::FILE, ptr: *mut fpos64_t) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn fsetpos64(stream: *mut ::FILE, ptr: *const fpos64_t) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn fseeko64(stream: *mut ::FILE, offset: ::off64_t, whence: ::c_int) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn ftello64(stream: *mut ::FILE) -> ::off64_t;
     pub fn fallocate(fd: ::c_int, mode: ::c_int, offset: ::off_t, len: ::off_t) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn fallocate64(fd: ::c_int, mode: ::c_int, offset: ::off64_t, len: ::off64_t) -> ::c_int;
     pub fn posix_fallocate(fd: ::c_int, offset: ::off_t, len: ::off_t) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn posix_fallocate64(fd: ::c_int, offset: ::off64_t, len: ::off64_t) -> ::c_int;
     pub fn readahead(fd: ::c_int, offset: ::off64_t, count: ::size_t) -> ::ssize_t;
     pub fn getxattr(
@@ -4095,6 +4104,7 @@ extern "C" {
         offset: *mut off_t,
         count: ::size_t,
     ) -> ::ssize_t;
+    #[cfg(not(target_env = "musl"))]
     pub fn sendfile64(
         out_fd: ::c_int,
         in_fd: ::c_int,

src/unix/linux_like/linux/musl/mod.rs

@@ -301,7 +301,7 @@ s_no_extra_traits! {
         pub ut_exit: __exit_status,
 
         //#[cfg(target_endian = "little")]
-        pub ut_session: ::c_long,
+        pub ut_session: ::c_int,
         //#[cfg(target_endian = "little")]
         //__ut_pad2: ::c_long,
 
@@ -756,6 +756,35 @@ extern "C" {
     pub fn malloc_usable_size(ptr: *mut ::c_void) -> ::size_t;
 }
 
+pub use tmpfile as tmpfile64;
+pub use fallocate as fallocate64;
+pub use fgetpos as fgetpos64;
+pub use fopen as fopen64;
+pub use freopen as freopen64;
+pub use fseeko as fseeko64;
+pub use fsetpos as fsetpos64;
+pub use ftello as ftello64;
+pub use posix_fallocate as posix_fallocate64;
+pub use sendfile as sendfile64;
+pub use statfs as statfs64;
+pub use fstatfs as fstatfs64;
+pub use statvfs as statvfs64;
+pub use fstatvfs as fstatvfs64;
+pub use creat as creat64;
+pub use fstat as fstat64;
+pub use fstatat as fstatat64;
+pub use ftruncate as ftruncate64;
+pub use lseek as lseek64;
+pub use lstat as lstat64;
+pub use open as open64;
+pub use openat as openat64;
+pub use pread as pread64;
+pub use pwrite as pwrite64;
+pub use readdir as readdir64;
+pub use readdir_r as readdir64_r;
+pub use stat as stat64;
+pub use truncate as truncate64;
+
 cfg_if! {
     if #[cfg(any(target_arch = "x86_64",
                  target_arch = "aarch64",

src/unix/linux_like/mod.rs

@@ -1645,10 +1645,14 @@ extern "C" {
     pub fn setgroups(ngroups: ::size_t, ptr: *const ::gid_t) -> ::c_int;
     pub fn pipe2(fds: *mut ::c_int, flags: ::c_int) -> ::c_int;
     pub fn statfs(path: *const ::c_char, buf: *mut statfs) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn statfs64(path: *const ::c_char, buf: *mut statfs64) -> ::c_int;
     pub fn fstatfs(fd: ::c_int, buf: *mut statfs) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn fstatfs64(fd: ::c_int, buf: *mut statfs64) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn statvfs64(path: *const ::c_char, buf: *mut statvfs64) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn fstatvfs64(fd: ::c_int, buf: *mut statvfs64) -> ::c_int;
     pub fn memrchr(cx: *const ::c_void, c: ::c_int, n: ::size_t) -> *mut ::c_void;
 
@@ -1670,16 +1674,22 @@ extern "C" {
     pub fn freelocale(loc: ::locale_t);
     pub fn newlocale(mask: ::c_int, locale: *const ::c_char, base: ::locale_t) -> ::locale_t;
     pub fn uselocale(loc: ::locale_t) -> ::locale_t;
+    #[cfg(not(target_env = "musl"))]
     pub fn creat64(path: *const c_char, mode: mode_t) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn fstat64(fildes: ::c_int, buf: *mut stat64) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn fstatat64(
         dirfd: ::c_int,
         pathname: *const c_char,
         buf: *mut stat64,
         flags: ::c_int,
     ) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn ftruncate64(fd: ::c_int, length: off64_t) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn lseek64(fd: ::c_int, offset: off64_t, whence: ::c_int) -> off64_t;
+    #[cfg(not(target_env = "musl"))]
     pub fn lstat64(path: *const c_char, buf: *mut stat64) -> ::c_int;
     pub fn mmap64(
         addr: *mut ::c_void,
@@ -1689,22 +1699,30 @@ extern "C" {
         fd: ::c_int,
         offset: off64_t,
     ) -> *mut ::c_void;
+    #[cfg(not(target_env = "musl"))]
     pub fn open64(path: *const c_char, oflag: ::c_int, ...) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn openat64(fd: ::c_int, path: *const c_char, oflag: ::c_int, ...) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn pread64(fd: ::c_int, buf: *mut ::c_void, count: ::size_t, offset: off64_t) -> ::ssize_t;
+    #[cfg(not(target_env = "musl"))]
     pub fn pwrite64(
         fd: ::c_int,
         buf: *const ::c_void,
         count: ::size_t,
         offset: off64_t,
     ) -> ::ssize_t;
+    #[cfg(not(target_env = "musl"))]
     pub fn readdir64(dirp: *mut ::DIR) -> *mut ::dirent64;
+    #[cfg(not(target_env = "musl"))]
     pub fn readdir64_r(
         dirp: *mut ::DIR,
         entry: *mut ::dirent64,
         result: *mut *mut ::dirent64,
     ) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn stat64(path: *const c_char, buf: *mut stat64) -> ::c_int;
+    #[cfg(not(target_env = "musl"))]
     pub fn truncate64(path: *const c_char, length: off64_t) -> ::c_int;
 
     pub fn mknodat(