Provide shim functions to backfill LFS64 ABI

Author: bossmc

src/unix/linux_like/linux/mod.rs

@@ -51,16 +51,12 @@ pub type iconv_t = *mut ::c_void;
 // linux/sctp.h
 pub type sctp_assoc_t = ::__s32;
 
-cfg_if! {
-    if #[cfg(not(target_env = "musl"))] {
-        #[cfg_attr(feature = "extra_traits", derive(Debug))]
-        pub enum fpos64_t {} // FIXME: fill this out with a struct
-        impl ::Copy for fpos64_t {}
-        impl ::Clone for fpos64_t {
-            fn clone(&self) -> fpos64_t {
-                *self
-            }
-        }
+#[cfg_attr(feature = "extra_traits", derive(Debug))]
+pub enum fpos64_t {} // FIXME: fill this out with a struct
+impl ::Copy for fpos64_t {}
+impl ::Clone for fpos64_t {
+    fn clone(&self) -> fpos64_t {
+        *self
     }
 }
 
@@ -684,16 +680,10 @@ s! {
     pub struct sctp_authinfo {
         pub auth_keynumber: ::__u16,
     }
-}
 
-cfg_if! {
-    if #[cfg(not(target_env = "musl"))] {
-        s! {
-            pub struct rlimit64 {
-                pub rlim_cur: rlim64_t,
-                pub rlim_max: rlim64_t,
-            }
-        }
+    pub struct rlimit64 {
+        pub rlim_cur: rlim64_t,
+        pub rlim_max: rlim64_t,
     }
 }
 
@@ -806,19 +796,13 @@ s_no_extra_traits! {
         pub tx_type: ::c_int,
         pub rx_filter: ::c_int,
     }
-}
 
-cfg_if! {
-    if #[cfg(not(target_env = "musl"))] {
-        s_no_extra_traits! {
-            pub struct dirent64 {
-                pub d_ino: ::ino64_t,
-                pub d_off: ::off64_t,
-                pub d_reclen: ::c_ushort,
-                pub d_type: ::c_uchar,
-                pub d_name: [::c_char; 256],
-            }
-        }
+    pub struct dirent64 {
+        pub d_ino: ::ino64_t,
+        pub d_off: ::off64_t,
+        pub d_reclen: ::c_ushort,
+        pub d_type: ::c_uchar,
+        pub d_name: [::c_char; 256],
     }
 }
 

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

@@ -184,22 +184,6 @@ s! {
         __pad1: ::c_ulong,
         __pad2: ::c_ulong,
     }
-
-    pub struct flock {
-        pub l_type: ::c_short,
-        pub l_whence: ::c_short,
-        pub l_start: ::off_t,
-        pub l_len: ::off_t,
-        pub l_pid: ::pid_t,
-    }
-
-    pub struct flock64 {
-        pub l_type: ::c_short,
-        pub l_whence: ::c_short,
-        pub l_start: ::off64_t,
-        pub l_len: ::off64_t,
-        pub l_pid: ::pid_t,
-    }
 }
 
 //pub const RLIM_INFINITY: ::rlim_t = !0;

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

@@ -173,22 +173,6 @@ s! {
         __unused5: ::c_ulong,
         __unused6: ::c_ulong,
     }
-
-    pub struct flock {
-        pub l_type: ::c_short,
-        pub l_whence: ::c_short,
-        pub l_start: ::off_t,
-        pub l_len: ::off_t,
-        pub l_pid: ::pid_t,
-    }
-
-    pub struct flock64 {
-        pub l_type: ::c_short,
-        pub l_whence: ::c_short,
-        pub l_start: ::off64_t,
-        pub l_len: ::off64_t,
-        pub l_pid: ::pid_t,
-    }
 }
 
 pub const SYS_read: ::c_long = 63;

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

@@ -0,0 +1,251 @@
+#[no_mangle]
+pub unsafe extern "C" fn creat64(path: *const ::c_char, mode: ::mode_t) -> ::c_int {
+    ::creat(path, mode)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fallocate64(
+    fd: ::c_int,
+    mode: ::c_int,
+    offset: ::off64_t,
+    len: ::off64_t,
+) -> ::c_int {
+    ::fallocate(fd, mode, offset, len)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fgetpos64(stream: *mut ::FILE, pos: *mut ::fpos64_t) -> ::c_int {
+    ::fgetpos(stream, pos.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fopen64(pathname: *const ::c_char, mode: *const ::c_char) -> *mut ::FILE {
+    ::fopen(pathname, mode)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn freopen64(
+    pathname: *const ::c_char,
+    mode: *const ::c_char,
+    stream: *mut ::FILE,
+) -> *mut ::FILE {
+    ::freopen(pathname, mode, stream)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fseeko64(
+    stream: *mut ::FILE,
+    offset: ::off64_t,
+    whence: ::c_int,
+) -> ::c_int {
+    ::fseeko(stream, offset, whence)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fsetpos64(stream: *mut ::FILE, pos: *const ::fpos64_t) -> ::c_int {
+    ::fsetpos(stream, pos.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fstat64(fildes: ::c_int, buf: *mut ::stat64) -> ::c_int {
+    ::fstat(fildes, buf.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fstatat64(
+    fd: ::c_int,
+    path: *const ::c_char,
+    buf: *mut ::stat64,
+    flag: ::c_int,
+) -> ::c_int {
+    ::fstatat(fd, path, buf.cast(), flag)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fstatfs64(fd: ::c_int, buf: *mut ::statfs64) -> ::c_int {
+    ::fstatfs(fd, buf.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fstatvfs64(fd: ::c_int, buf: *mut ::statvfs64) -> ::c_int {
+    ::fstatvfs(fd, buf.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn ftello64(stream: *mut ::FILE) -> ::off64_t {
+    ::ftello(stream)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn ftruncate64(fd: ::c_int, length: ::off64_t) -> ::c_int {
+    ::ftruncate(fd, length)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn getrlimit64(resource: ::c_int, rlim: *mut ::rlimit64) -> ::c_int {
+    ::getrlimit(resource, rlim.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn lseek64(fd: ::c_int, offset: ::off64_t, whence: ::c_int) -> ::off64_t {
+    ::lseek(fd, offset, whence)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn lstat64(path: *const ::c_char, buf: *mut ::stat64) -> ::c_int {
+    ::lstat(path, buf.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn mmap64(
+    addr: *mut ::c_void,
+    length: ::size_t,
+    prot: ::c_int,
+    flags: ::c_int,
+    fd: ::c_int,
+    offset: ::off64_t,
+) -> *mut ::c_void {
+    ::mmap(addr, length, prot, flags, fd, offset)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn open64(
+    pathname: *const ::c_char,
+    flags: ::c_int,
+    mode: ::mode_t,
+) -> ::c_int {
+    ::open(pathname, flags | ::O_LARGEFILE, mode)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn openat64(
+    dirfd: ::c_int,
+    pathname: *const ::c_char,
+    flags: ::c_int,
+    mode: ::mode_t,
+) -> ::c_int {
+    ::openat(dirfd, pathname, flags | ::O_LARGEFILE, mode)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn posix_fadvise64(
+    fd: ::c_int,
+    offset: ::off64_t,
+    len: ::off64_t,
+    advice: ::c_int,
+) -> ::c_int {
+    ::posix_fadvise(fd, offset, len, advice)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn posix_fallocate64(
+    fd: ::c_int,
+    offset: ::off64_t,
+    len: ::off64_t,
+) -> ::c_int {
+    ::posix_fallocate(fd, offset, len)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn pread64(
+    fd: ::c_int,
+    buf: *mut ::c_void,
+    count: ::size_t,
+    offset: ::off64_t,
+) -> ::ssize_t {
+    ::pread(fd, buf, count, offset)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn preadv64(
+    fd: ::c_int,
+    iov: *const ::iovec,
+    iovcnt: ::c_int,
+    offset: ::off64_t,
+) -> ::ssize_t {
+    ::preadv(fd, iov, iovcnt, offset)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn prlimit64(
+    pid: ::pid_t,
+    resource: ::c_int,
+    new_limit: *const ::rlimit64,
+    old_limit: *mut ::rlimit64,
+) -> ::c_int {
+    ::prlimit(pid, resource, new_limit.cast(), old_limit.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn pwrite64(
+    fd: ::c_int,
+    buf: *const ::c_void,
+    count: ::size_t,
+    offset: ::off64_t,
+) -> ::ssize_t {
+    ::pwrite(fd, buf, count, offset)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn pwritev64(
+    fd: ::c_int,
+    iov: *const ::iovec,
+    iovcnt: ::c_int,
+    offset: ::off64_t,
+) -> ::ssize_t {
+    ::pwritev(fd, iov, iovcnt, offset)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn readdir64(dirp: *mut ::DIR) -> *mut ::dirent64 {
+    ::readdir(dirp).cast()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn readdir64_r(
+    dirp: *mut ::DIR,
+    entry: *mut ::dirent64,
+    result: *mut *mut ::dirent64,
+) -> ::c_int {
+    ::readdir_r(dirp, entry.cast(), result.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sendfile64(
+    out_fd: ::c_int,
+    in_fd: ::c_int,
+    offset: *mut ::off64_t,
+    count: ::size_t,
+) -> ::ssize_t {
+    ::sendfile(out_fd, in_fd, offset, count)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn setrlimit64(resource: ::c_int, rlim: *const ::rlimit64) -> ::c_int {
+    ::setrlimit(resource, rlim.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn stat64(pathname: *const ::c_char, statbuf: *mut ::stat64) -> ::c_int {
+    ::stat(pathname, statbuf.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn statfs64(pathname: *const ::c_char, buf: *mut ::statfs64) -> ::c_int {
+    ::statfs(pathname, buf.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn statvfs64(path: *const ::c_char, buf: *mut ::statvfs64) -> ::c_int {
+    ::statvfs(path, buf.cast())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn tmpfile64() -> *mut ::FILE {
+    ::tmpfile()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn truncate64(path: *const ::c_char, length: ::off64_t) -> ::c_int {
+    ::truncate(path, length)
+}