diff --git a/native/src/base/cxx_extern.rs b/native/src/base/cxx_extern.rs
index 2f845e45a..86f56a83e 100644
--- a/native/src/base/cxx_extern.rs
+++ b/native/src/base/cxx_extern.rs
@@ -1,4 +1,4 @@
-// Functions listed here are just to export to C++
+// Functions in this file are only for exporting to C++, DO NOT USE IN RUST
 
 use std::fmt::Write;
 use std::io;
@@ -7,6 +7,7 @@ use std::os::fd::{BorrowedFd, OwnedFd, RawFd};
 use cxx::private::c_char;
 use libc::mode_t;
 
+pub(crate) use crate::xwrap::*;
 use crate::{
     fd_path, map_fd, map_file, mkdirs, realpath, rm_rf, slice_from_ptr_mut, Directory, ResultExt,
     Utf8CStr,
diff --git a/native/src/base/files.rs b/native/src/base/files.rs
index 521094577..f107c3432 100644
--- a/native/src/base/files.rs
+++ b/native/src/base/files.rs
@@ -31,7 +31,7 @@ macro_rules! open_fd {
     };
 }
 
-pub unsafe fn readlink_unsafe(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
+pub(crate) unsafe fn readlink_unsafe(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
     let r = libc::readlink(path, buf.cast(), bufsz - 1);
     if r >= 0 {
         *buf.offset(r) = b'\0';
diff --git a/native/src/base/lib.rs b/native/src/base/lib.rs
index d2de004ea..10bbe67fb 100644
--- a/native/src/base/lib.rs
+++ b/native/src/base/lib.rs
@@ -8,7 +8,6 @@ use cxx_extern::*;
 pub use files::*;
 pub use logging::*;
 pub use misc::*;
-pub use xwrap::*;
 
 mod cxx_extern;
 mod files;
diff --git a/native/src/base/misc.rs b/native/src/base/misc.rs
index 4a529c6b6..716fa0f89 100644
--- a/native/src/base/misc.rs
+++ b/native/src/base/misc.rs
@@ -256,22 +256,10 @@ impl PartialEq<Utf8CStr> for str {
     }
 }
 
-pub fn ptr_to_str<'a, T>(ptr: *const T) -> &'a str {
-    if ptr.is_null() {
-        "(null)"
-    } else {
-        unsafe { CStr::from_ptr(ptr.cast()) }.to_str().unwrap_or("")
-    }
-}
-
 pub fn errno() -> &'static mut i32 {
     unsafe { &mut *libc::__errno() }
 }
 
-pub fn error_str() -> &'static str {
-    unsafe { ptr_to_str(libc::strerror(*errno())) }
-}
-
 // When len is 0, don't care whether buf is null or not
 #[inline]
 pub unsafe fn slice_from_ptr<'a, T>(buf: *const T, len: usize) -> &'a [T] {
diff --git a/native/src/base/xwrap.rs b/native/src/base/xwrap.rs
index 7cf30bee1..5ca25b27e 100644
--- a/native/src/base/xwrap.rs
+++ b/native/src/base/xwrap.rs
@@ -1,13 +1,32 @@
+// Functions in this file are only for exporting to C++, DO NOT USE IN RUST
+
+use std::ffi::CStr;
 use std::fmt::Write;
 use std::os::unix::io::RawFd;
 use std::ptr;
 
+use cfg_if::cfg_if;
 use libc::{
     c_char, c_uint, c_ulong, c_void, dev_t, mode_t, nfds_t, off_t, pollfd, sockaddr, socklen_t,
     ssize_t, SYS_dup3,
 };
 
-use crate::{cstr, errno, mkdirs, ptr_to_str, raw_cstr, ResultExt, Utf8CStr};
+use crate::{
+    cstr, errno, mkdirs, raw_cstr, readlink_unsafe, realpath, slice_from_ptr_mut, ResultExt,
+    Utf8CStr,
+};
+
+fn ptr_to_str<'a, T>(ptr: *const T) -> &'a str {
+    if ptr.is_null() {
+        "(null)"
+    } else {
+        unsafe { CStr::from_ptr(ptr.cast()) }.to_str().unwrap_or("")
+    }
+}
+
+fn error_str() -> &'static str {
+    unsafe { ptr_to_str(libc::strerror(*errno())) }
+}
 
 macro_rules! error_cxx {
     ($($args:tt)+) => {
@@ -19,117 +38,82 @@ macro_rules! perror {
     ($fmt:expr) => {
         $crate::log_with_formatter($crate::ffi::LogLevel::ErrorCxx, |w| {
             w.write_str($fmt)?;
-            w.write_fmt(format_args!(" failed with {}: {}", $crate::errno(), $crate::error_str()))
+            w.write_fmt(format_args!(" failed with {}: {}", $crate::errno(), error_str()))
         })
     };
     ($fmt:expr, $($args:tt)*) => {
         $crate::log_with_formatter($crate::ffi::LogLevel::ErrorCxx, |w| {
             w.write_fmt(format_args!($fmt, $($args)*))?;
-            w.write_fmt(format_args!(" failed with {}: {}", $crate::errno(), $crate::error_str()))
+            w.write_fmt(format_args!(" failed with {}: {}", $crate::errno(), error_str()))
         })
     };
 }
 
-mod unsafe_impl {
-    use std::fmt::Write;
+mod c_export {
     use std::os::unix::io::RawFd;
 
-    use cfg_if::cfg_if;
-    use libc::{c_char, nfds_t, off_t, pollfd};
-
-    use crate::{
-        ptr_to_str, readlink_unsafe, realpath, slice_from_ptr, slice_from_ptr_mut, ResultExt,
-        Utf8CStr,
-    };
+    use crate::{slice_from_ptr, slice_from_ptr_mut};
 
     #[no_mangle]
     unsafe extern "C" fn xwrite(fd: RawFd, buf: *const u8, bufsz: usize) -> isize {
         super::xwrite(fd, slice_from_ptr(buf, bufsz))
     }
 
-    #[no_mangle]
-    unsafe extern "C" fn xread(fd: RawFd, buf: *mut u8, bufsz: usize) -> isize {
-        super::xread(fd, slice_from_ptr_mut(buf, bufsz))
-    }
-
     #[no_mangle]
     unsafe extern "C" fn xxread(fd: RawFd, buf: *mut u8, bufsz: usize) -> isize {
         super::xxread(fd, slice_from_ptr_mut(buf, bufsz))
     }
-
-    #[no_mangle]
-    unsafe extern "C" fn xrealpath(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
-        match Utf8CStr::from_ptr(path) {
-            Ok(p) => realpath(p, slice_from_ptr_mut(buf, bufsz))
-                .log_cxx_with_msg(|w| w.write_fmt(format_args!("realpath {} failed", p)))
-                .map_or(-1, |v| v as isize),
-            Err(_) => -1,
-        }
-    }
-
-    #[no_mangle]
-    pub unsafe extern "C" fn xreadlink(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
-        let r = readlink_unsafe(path, buf, bufsz);
-        if r < 0 {
-            perror!("readlink");
-        }
-        r
-    }
-
-    #[no_mangle]
-    pub unsafe extern "C" fn xreadlinkat(
-        dirfd: RawFd,
-        path: *const c_char,
-        buf: *mut u8,
-        bufsz: usize,
-    ) -> isize {
-        // readlinkat() may fail on x86 platform, returning random value
-        // instead of number of bytes placed in buf (length of link)
-        cfg_if! {
-            if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] {
-                libc::memset(buf.cast(), 0, bufsz);
-                let r = libc::readlinkat(dirfd, path, buf.cast(), bufsz - 1);
-                if r < 0 {
-                    perror!("readlinkat {}", ptr_to_str(path))
-                }
-            } else {
-                let r = libc::readlinkat(dirfd, path, buf.cast(), bufsz - 1);
-                if r < 0 {
-                    perror!("readlinkat {}", ptr_to_str(path))
-                } else {
-                    *buf.offset(r) = b'\0';
-                }
-            }
-        }
-        r
-    }
-
-    #[no_mangle]
-    pub unsafe extern "C" fn xpoll(fds: *mut pollfd, nfds: nfds_t, timeout: i32) -> i32 {
-        let r = libc::poll(fds, nfds, timeout);
-        if r < 0 {
-            perror!("poll");
-        }
-        r
-    }
-
-    #[no_mangle]
-    pub unsafe extern "C" fn xsendfile(
-        out_fd: RawFd,
-        in_fd: RawFd,
-        offset: *mut off_t,
-        count: usize,
-    ) -> isize {
-        let r = libc::sendfile(out_fd, in_fd, offset, count);
-        if r < 0 {
-            perror!("sendfile");
-        }
-        r
-    }
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xfopen(path: *const c_char, mode: *const c_char) -> *mut libc::FILE {
+unsafe extern "C" fn xrealpath(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
+    match Utf8CStr::from_ptr(path) {
+        Ok(p) => realpath(p, slice_from_ptr_mut(buf, bufsz))
+            .log_cxx_with_msg(|w| w.write_fmt(format_args!("realpath {} failed", p)))
+            .map_or(-1, |v| v as isize),
+        Err(_) => -1,
+    }
+}
+
+#[no_mangle]
+unsafe extern "C" fn xreadlink(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
+    let r = readlink_unsafe(path, buf, bufsz);
+    if r < 0 {
+        perror!("readlink");
+    }
+    r
+}
+
+#[no_mangle]
+unsafe extern "C" fn xreadlinkat(
+    dirfd: RawFd,
+    path: *const c_char,
+    buf: *mut u8,
+    bufsz: usize,
+) -> isize {
+    // readlinkat() may fail on x86 platform, returning random value
+    // instead of number of bytes placed in buf (length of link)
+    cfg_if! {
+        if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] {
+            libc::memset(buf.cast(), 0, bufsz);
+            let r = libc::readlinkat(dirfd, path, buf.cast(), bufsz - 1);
+            if r < 0 {
+                perror!("readlinkat {}", ptr_to_str(path))
+            }
+        } else {
+            let r = libc::readlinkat(dirfd, path, buf.cast(), bufsz - 1);
+            if r < 0 {
+                perror!("readlinkat {}", ptr_to_str(path))
+            } else {
+                *buf.offset(r) = b'\0';
+            }
+        }
+    }
+    r
+}
+
+#[no_mangle]
+unsafe extern "C" fn xfopen(path: *const c_char, mode: *const c_char) -> *mut libc::FILE {
     let fp = libc::fopen(path, mode);
     if fp.is_null() {
         perror!("fopen {}", ptr_to_str(path));
@@ -138,7 +122,7 @@ pub unsafe extern "C" fn xfopen(path: *const c_char, mode: *const c_char) -> *mu
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xfdopen(fd: RawFd, mode: *const c_char) -> *mut libc::FILE {
+unsafe extern "C" fn xfdopen(fd: RawFd, mode: *const c_char) -> *mut libc::FILE {
     let fp = libc::fdopen(fd, mode);
     if fp.is_null() {
         perror!("fdopen");
@@ -147,7 +131,7 @@ pub unsafe extern "C" fn xfdopen(fd: RawFd, mode: *const c_char) -> *mut libc::F
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xopen(path: *const c_char, flags: i32, mode: mode_t) -> RawFd {
+unsafe extern "C" fn xopen(path: *const c_char, flags: i32, mode: mode_t) -> RawFd {
     let r = libc::open(path, flags, mode as c_uint);
     if r < 0 {
         perror!("open {}", ptr_to_str(path));
@@ -156,12 +140,7 @@ pub unsafe extern "C" fn xopen(path: *const c_char, flags: i32, mode: mode_t) ->
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xopenat(
-    dirfd: RawFd,
-    path: *const c_char,
-    flags: i32,
-    mode: mode_t,
-) -> RawFd {
+unsafe extern "C" fn xopenat(dirfd: RawFd, path: *const c_char, flags: i32, mode: mode_t) -> RawFd {
     let r = libc::openat(dirfd, path, flags, mode as c_uint);
     if r < 0 {
         perror!("openat {}", ptr_to_str(path));
@@ -170,7 +149,7 @@ pub unsafe extern "C" fn xopenat(
 }
 
 // Fully write data slice
-pub fn xwrite(fd: RawFd, data: &[u8]) -> isize {
+fn xwrite(fd: RawFd, data: &[u8]) -> isize {
     unsafe {
         let mut write_sz: usize = 0;
         let mut r: ssize_t;
@@ -198,9 +177,10 @@ pub fn xwrite(fd: RawFd, data: &[u8]) -> isize {
     }
 }
 
-pub fn xread(fd: RawFd, data: &mut [u8]) -> isize {
+#[no_mangle]
+unsafe extern "C" fn xread(fd: RawFd, buf: *mut c_void, bufsz: usize) -> isize {
     unsafe {
-        let r = libc::read(fd, data.as_mut_ptr().cast(), data.len());
+        let r = libc::read(fd, buf, bufsz);
         if r < 0 {
             perror!("read");
         }
@@ -209,7 +189,7 @@ pub fn xread(fd: RawFd, data: &mut [u8]) -> isize {
 }
 
 // Fully read size of data slice
-pub fn xxread(fd: RawFd, data: &mut [u8]) -> isize {
+fn xxread(fd: RawFd, data: &mut [u8]) -> isize {
     unsafe {
         let mut read_sz: usize = 0;
         let mut r: ssize_t;
@@ -238,7 +218,7 @@ pub fn xxread(fd: RawFd, data: &mut [u8]) -> isize {
 }
 
 #[no_mangle]
-pub extern "C" fn xlseek64(fd: RawFd, offset: i64, whence: i32) -> i64 {
+extern "C" fn xlseek64(fd: RawFd, offset: i64, whence: i32) -> i64 {
     unsafe {
         let r = libc::lseek64(fd, offset, whence);
         if r < 0 {
@@ -248,7 +228,7 @@ pub extern "C" fn xlseek64(fd: RawFd, offset: i64, whence: i32) -> i64 {
     }
 }
 
-pub fn xpipe2(fds: &mut [i32; 2], flags: i32) -> i32 {
+pub(crate) fn xpipe2(fds: &mut [i32; 2], flags: i32) -> i32 {
     unsafe {
         let r = libc::pipe2(fds.as_mut_ptr(), flags);
         if r < 0 {
@@ -259,7 +239,7 @@ pub fn xpipe2(fds: &mut [i32; 2], flags: i32) -> i32 {
 }
 
 #[no_mangle]
-pub extern "C" fn xsetns(fd: RawFd, nstype: i32) -> i32 {
+extern "C" fn xsetns(fd: RawFd, nstype: i32) -> i32 {
     unsafe {
         let r = libc::setns(fd, nstype);
         if r < 0 {
@@ -270,7 +250,7 @@ pub extern "C" fn xsetns(fd: RawFd, nstype: i32) -> i32 {
 }
 
 #[no_mangle]
-pub extern "C" fn xunshare(flags: i32) -> i32 {
+extern "C" fn xunshare(flags: i32) -> i32 {
     unsafe {
         let r = libc::unshare(flags);
         if r < 0 {
@@ -281,7 +261,7 @@ pub extern "C" fn xunshare(flags: i32) -> i32 {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xopendir(path: *const c_char) -> *mut libc::DIR {
+unsafe extern "C" fn xopendir(path: *const c_char) -> *mut libc::DIR {
     let dp = libc::opendir(path);
     if dp.is_null() {
         perror!("opendir {}", ptr_to_str(path));
@@ -290,7 +270,7 @@ pub unsafe extern "C" fn xopendir(path: *const c_char) -> *mut libc::DIR {
 }
 
 #[no_mangle]
-pub extern "C" fn xfdopendir(fd: RawFd) -> *mut libc::DIR {
+extern "C" fn xfdopendir(fd: RawFd) -> *mut libc::DIR {
     unsafe {
         let dp = libc::fdopendir(fd);
         if dp.is_null() {
@@ -301,7 +281,7 @@ pub extern "C" fn xfdopendir(fd: RawFd) -> *mut libc::DIR {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xreaddir(dirp: *mut libc::DIR) -> *mut libc::dirent {
+unsafe extern "C" fn xreaddir(dirp: *mut libc::DIR) -> *mut libc::dirent {
     *errno() = 0;
     loop {
         let e = libc::readdir(dirp);
@@ -321,7 +301,7 @@ pub unsafe extern "C" fn xreaddir(dirp: *mut libc::DIR) -> *mut libc::dirent {
 }
 
 #[no_mangle]
-pub extern "C" fn xsetsid() -> i32 {
+extern "C" fn xsetsid() -> i32 {
     unsafe {
         let r = libc::setsid();
         if r < 0 {
@@ -332,7 +312,7 @@ pub extern "C" fn xsetsid() -> i32 {
 }
 
 #[no_mangle]
-pub extern "C" fn xsocket(domain: i32, ty: i32, protocol: i32) -> RawFd {
+extern "C" fn xsocket(domain: i32, ty: i32, protocol: i32) -> RawFd {
     unsafe {
         let fd = libc::socket(domain, ty, protocol);
         if fd < 0 {
@@ -343,7 +323,7 @@ pub extern "C" fn xsocket(domain: i32, ty: i32, protocol: i32) -> RawFd {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xbind(socket: i32, address: *const sockaddr, len: socklen_t) -> i32 {
+unsafe extern "C" fn xbind(socket: i32, address: *const sockaddr, len: socklen_t) -> i32 {
     let r = libc::bind(socket, address, len);
     if r < 0 {
         perror!("bind");
@@ -352,7 +332,7 @@ pub unsafe extern "C" fn xbind(socket: i32, address: *const sockaddr, len: sockl
 }
 
 #[no_mangle]
-pub extern "C" fn xlisten(socket: i32, backlog: i32) -> i32 {
+extern "C" fn xlisten(socket: i32, backlog: i32) -> i32 {
     unsafe {
         let r = libc::listen(socket, backlog);
         if r < 0 {
@@ -363,7 +343,7 @@ pub extern "C" fn xlisten(socket: i32, backlog: i32) -> i32 {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xaccept4(
+unsafe extern "C" fn xaccept4(
     sockfd: RawFd,
     addr: *mut sockaddr,
     len: *mut socklen_t,
@@ -377,7 +357,7 @@ pub unsafe extern "C" fn xaccept4(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xsendmsg(fd: RawFd, msg: *const libc::msghdr, flags: i32) -> ssize_t {
+unsafe extern "C" fn xsendmsg(fd: RawFd, msg: *const libc::msghdr, flags: i32) -> ssize_t {
     let r = libc::sendmsg(fd, msg, flags);
     if r < 0 {
         perror!("sendmsg");
@@ -386,7 +366,7 @@ pub unsafe extern "C" fn xsendmsg(fd: RawFd, msg: *const libc::msghdr, flags: i3
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xrecvmsg(fd: RawFd, msg: *mut libc::msghdr, flags: i32) -> ssize_t {
+unsafe extern "C" fn xrecvmsg(fd: RawFd, msg: *mut libc::msghdr, flags: i32) -> ssize_t {
     let r = libc::recvmsg(fd, msg, flags);
     if r < 0 {
         perror!("recvmsg");
@@ -395,7 +375,7 @@ pub unsafe extern "C" fn xrecvmsg(fd: RawFd, msg: *mut libc::msghdr, flags: i32)
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xaccess(path: *const c_char, mode: i32) -> i32 {
+unsafe extern "C" fn xaccess(path: *const c_char, mode: i32) -> i32 {
     let r = libc::access(path, mode);
     if r < 0 {
         perror!("access {}", ptr_to_str(path));
@@ -404,12 +384,7 @@ pub unsafe extern "C" fn xaccess(path: *const c_char, mode: i32) -> i32 {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xfaccessat(
-    dirfd: RawFd,
-    path: *const c_char,
-    mode: i32,
-    flags: i32,
-) -> i32 {
+unsafe extern "C" fn xfaccessat(dirfd: RawFd, path: *const c_char, mode: i32, flags: i32) -> i32 {
     #[allow(unused_mut)]
     let mut r = libc::faccessat(dirfd, path, mode, flags);
     if r < 0 {
@@ -423,7 +398,7 @@ pub unsafe extern "C" fn xfaccessat(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xstat(path: *const c_char, buf: *mut libc::stat) -> i32 {
+unsafe extern "C" fn xstat(path: *const c_char, buf: *mut libc::stat) -> i32 {
     let r = libc::stat(path, buf);
     if r < 0 {
         perror!("stat {}", ptr_to_str(path));
@@ -432,7 +407,7 @@ pub unsafe extern "C" fn xstat(path: *const c_char, buf: *mut libc::stat) -> i32
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xlstat(path: *const c_char, buf: *mut libc::stat) -> i32 {
+unsafe extern "C" fn xlstat(path: *const c_char, buf: *mut libc::stat) -> i32 {
     let r = libc::lstat(path, buf);
     if r < 0 {
         perror!("lstat {}", ptr_to_str(path));
@@ -441,7 +416,7 @@ pub unsafe extern "C" fn xlstat(path: *const c_char, buf: *mut libc::stat) -> i3
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xfstat(fd: RawFd, buf: *mut libc::stat) -> i32 {
+unsafe extern "C" fn xfstat(fd: RawFd, buf: *mut libc::stat) -> i32 {
     let r = libc::fstat(fd, buf);
     if r < 0 {
         perror!("fstat");
@@ -450,7 +425,7 @@ pub unsafe extern "C" fn xfstat(fd: RawFd, buf: *mut libc::stat) -> i32 {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xfstatat(
+unsafe extern "C" fn xfstatat(
     dirfd: RawFd,
     path: *const c_char,
     buf: *mut libc::stat,
@@ -464,7 +439,7 @@ pub unsafe extern "C" fn xfstatat(
 }
 
 #[no_mangle]
-pub extern "C" fn xdup(oldfd: RawFd) -> RawFd {
+extern "C" fn xdup(oldfd: RawFd) -> RawFd {
     unsafe {
         let fd = libc::dup(oldfd);
         if fd < 0 {
@@ -475,7 +450,7 @@ pub extern "C" fn xdup(oldfd: RawFd) -> RawFd {
 }
 
 #[no_mangle]
-pub extern "C" fn xdup2(oldfd: RawFd, newfd: RawFd) -> RawFd {
+extern "C" fn xdup2(oldfd: RawFd, newfd: RawFd) -> RawFd {
     unsafe {
         let fd = libc::dup2(oldfd, newfd);
         if fd < 0 {
@@ -486,7 +461,7 @@ pub extern "C" fn xdup2(oldfd: RawFd, newfd: RawFd) -> RawFd {
 }
 
 #[no_mangle]
-pub extern "C" fn xdup3(oldfd: RawFd, newfd: RawFd, flags: i32) -> RawFd {
+extern "C" fn xdup3(oldfd: RawFd, newfd: RawFd, flags: i32) -> RawFd {
     unsafe {
         let fd = libc::syscall(SYS_dup3, oldfd, newfd, flags) as RawFd;
         if fd < 0 {
@@ -497,7 +472,7 @@ pub extern "C" fn xdup3(oldfd: RawFd, newfd: RawFd, flags: i32) -> RawFd {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xsymlink(target: *const c_char, linkpath: *const c_char) -> i32 {
+unsafe extern "C" fn xsymlink(target: *const c_char, linkpath: *const c_char) -> i32 {
     let r = libc::symlink(target, linkpath);
     if r < 0 {
         perror!("symlink {} -> {}", ptr_to_str(target), ptr_to_str(linkpath));
@@ -506,7 +481,7 @@ pub unsafe extern "C" fn xsymlink(target: *const c_char, linkpath: *const c_char
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xsymlinkat(
+unsafe extern "C" fn xsymlinkat(
     target: *const c_char,
     dirfd: RawFd,
     linkpath: *const c_char,
@@ -523,7 +498,7 @@ pub unsafe extern "C" fn xsymlinkat(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xlinkat(
+unsafe extern "C" fn xlinkat(
     olddirfd: RawFd,
     target: *const c_char,
     newdirfd: RawFd,
@@ -538,7 +513,7 @@ pub unsafe extern "C" fn xlinkat(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xmount(
+unsafe extern "C" fn xmount(
     src: *const c_char,
     target: *const c_char,
     fstype: *const c_char,
@@ -553,7 +528,7 @@ pub unsafe extern "C" fn xmount(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xumount(target: *const c_char) -> i32 {
+unsafe extern "C" fn xumount(target: *const c_char) -> i32 {
     let r = libc::umount(target);
     if r < 0 {
         perror!("umount {}", ptr_to_str(target));
@@ -562,7 +537,7 @@ pub unsafe extern "C" fn xumount(target: *const c_char) -> i32 {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xumount2(target: *const c_char, flags: i32) -> i32 {
+unsafe extern "C" fn xumount2(target: *const c_char, flags: i32) -> i32 {
     let r = libc::umount2(target, flags);
     if r < 0 {
         perror!("umount2 {}", ptr_to_str(target));
@@ -571,7 +546,7 @@ pub unsafe extern "C" fn xumount2(target: *const c_char, flags: i32) -> i32 {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xrename(oldname: *const c_char, newname: *const c_char) -> i32 {
+unsafe extern "C" fn xrename(oldname: *const c_char, newname: *const c_char) -> i32 {
     let r = libc::rename(oldname, newname);
     if r < 0 {
         perror!("rename {} -> {}", ptr_to_str(oldname), ptr_to_str(newname));
@@ -580,7 +555,7 @@ pub unsafe extern "C" fn xrename(oldname: *const c_char, newname: *const c_char)
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xmkdir(path: *const c_char, mode: mode_t) -> i32 {
+unsafe extern "C" fn xmkdir(path: *const c_char, mode: mode_t) -> i32 {
     let r = libc::mkdir(path, mode);
     if r < 0 && *errno() != libc::EEXIST {
         perror!("mkdir {}", ptr_to_str(path));
@@ -589,7 +564,7 @@ pub unsafe extern "C" fn xmkdir(path: *const c_char, mode: mode_t) -> i32 {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xmkdirs(path: *const c_char, mode: mode_t) -> i32 {
+unsafe extern "C" fn xmkdirs(path: *const c_char, mode: mode_t) -> i32 {
     match Utf8CStr::from_ptr(path) {
         Ok(p) => mkdirs(p, mode)
             .log_cxx_with_msg(|w| w.write_fmt(format_args!("mkdirs {} failed", p)))
@@ -599,7 +574,7 @@ pub unsafe extern "C" fn xmkdirs(path: *const c_char, mode: mode_t) -> i32 {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xmkdirat(dirfd: RawFd, path: *const c_char, mode: mode_t) -> i32 {
+unsafe extern "C" fn xmkdirat(dirfd: RawFd, path: *const c_char, mode: mode_t) -> i32 {
     let r = libc::mkdirat(dirfd, path, mode);
     if r < 0 && *errno() != libc::EEXIST {
         perror!("mkdirat {}", ptr_to_str(path));
@@ -607,16 +582,22 @@ pub unsafe extern "C" fn xmkdirat(dirfd: RawFd, path: *const c_char, mode: mode_
     r
 }
 
-#[inline]
-pub fn xsendfile(out_fd: RawFd, in_fd: RawFd, offset: Option<&mut off_t>, count: usize) -> isize {
-    unsafe {
-        let p = offset.map_or(ptr::null_mut(), |it| it);
-        unsafe_impl::xsendfile(out_fd, in_fd, p, count)
+#[no_mangle]
+unsafe extern "C" fn xsendfile(
+    out_fd: RawFd,
+    in_fd: RawFd,
+    offset: *mut off_t,
+    count: usize,
+) -> isize {
+    let r = libc::sendfile(out_fd, in_fd, offset, count);
+    if r < 0 {
+        perror!("sendfile");
     }
+    r
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xmmap(
+unsafe extern "C" fn xmmap(
     addr: *mut c_void,
     len: usize,
     prot: i32,
@@ -633,7 +614,7 @@ pub unsafe extern "C" fn xmmap(
 }
 
 #[no_mangle]
-pub extern "C" fn xfork() -> i32 {
+extern "C" fn xfork() -> i32 {
     unsafe {
         let r = libc::fork();
         if r < 0 {
@@ -643,13 +624,17 @@ pub extern "C" fn xfork() -> i32 {
     }
 }
 
-#[inline]
-pub fn xpoll(fds: &mut [pollfd], timeout: i32) -> i32 {
-    unsafe { unsafe_impl::xpoll(fds.as_mut_ptr(), fds.len() as nfds_t, timeout) }
+#[no_mangle]
+unsafe extern "C" fn xpoll(fds: *mut pollfd, nfds: nfds_t, timeout: i32) -> i32 {
+    let r = libc::poll(fds, nfds, timeout);
+    if r < 0 {
+        perror!("poll");
+    }
+    r
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn xmknod(pathname: *const c_char, mode: mode_t, dev: dev_t) -> i32 {
+unsafe extern "C" fn xmknod(pathname: *const c_char, mode: mode_t, dev: dev_t) -> i32 {
     let r = libc::mknod(pathname, mode, dev);
     if r < 0 {
         perror!("mknod {}", ptr_to_str(pathname));