diff --git a/src/file_traits.rs b/src/file_traits.rs
index 3177acc..f747956 100644
--- a/src/file_traits.rs
+++ b/src/file_traits.rs
@@ -10,7 +10,7 @@ use std::os::unix::io::{AsFd, AsRawFd};
 use vm_memory::VolatileSlice;
 
 use crate::oslib;
-use libc::{c_int, c_void, off64_t, preadv64, size_t};
+use libc::{c_int, c_void, off_t, preadv, size_t};
 use vm_memory::bitmap::BitmapSlice;
 
 /// A trait for setting the size of a file.
@@ -87,11 +87,11 @@ macro_rules! volatile_impl {
                 // Safe because only bytes inside the buffers are accessed and the kernel is
                 // expected to handle arbitrary memory for I/O.
                 let ret = unsafe {
-                    preadv64(
+                    preadv(
                         self.as_raw_fd(),
                         &iovecs[0],
                         iovecs.len() as c_int,
-                        offset as off64_t,
+                        offset as off_t,
                     )
                 };
 
diff --git a/src/filesystem.rs b/src/filesystem.rs
index 6daf0d6..b87fce7 100644
--- a/src/filesystem.rs
+++ b/src/filesystem.rs
@@ -892,9 +892,9 @@ pub trait FileSystem {
     }
 
     /// Get information about the file system.
-    fn statfs(&self, ctx: Context, inode: Self::Inode) -> io::Result<libc::statvfs64> {
+    fn statfs(&self, ctx: Context, inode: Self::Inode) -> io::Result<libc::statvfs> {
         // Safe because we are zero-initializing a struct with only POD fields.
-        let mut st: libc::statvfs64 = unsafe { mem::zeroed() };
+        let mut st: libc::statvfs = unsafe { mem::zeroed() };
 
         // This matches the behavior of libfuse as it returns these values if the
         // filesystem doesn't implement this method.
diff --git a/src/fuse.rs b/src/fuse.rs
index e2d83a7..7c75b35 100644
--- a/src/fuse.rs
+++ b/src/fuse.rs
@@ -635,8 +635,8 @@ pub struct Kstatfs {
 }
 unsafe impl ByteValued for Kstatfs {}
 
-impl From<libc::statvfs64> for Kstatfs {
-    fn from(st: libc::statvfs64) -> Self {
+impl From<libc::statvfs> for Kstatfs {
+    fn from(st: libc::statvfs) -> Self {
         Kstatfs {
             blocks: st.f_blocks,
             bfree: st.f_bfree,
diff --git a/src/passthrough/mod.rs b/src/passthrough/mod.rs
index 9a82c56..5b4cc55 100644
--- a/src/passthrough/mod.rs
+++ b/src/passthrough/mod.rs
@@ -1201,7 +1201,7 @@ impl FileSystem for PassthroughFs {
         self.sup_group_extension.store(false, Ordering::Relaxed);
     }
 
-    fn statfs(&self, _ctx: Context, inode: Inode) -> io::Result<libc::statvfs64> {
+    fn statfs(&self, _ctx: Context, inode: Inode) -> io::Result<libc::statvfs> {
         let data = self
             .inodes
             .read()
@@ -1211,10 +1211,10 @@ impl FileSystem for PassthroughFs {
             .ok_or_else(ebadf)?;
 
         let inode_file = data.get_file()?;
-        let mut out = MaybeUninit::<libc::statvfs64>::zeroed();
+        let mut out = MaybeUninit::<libc::statvfs>::zeroed();
 
         // Safe because this will only modify `out` and we check the return value.
-        let res = unsafe { libc::fstatvfs64(inode_file.as_raw_fd(), out.as_mut_ptr()) };
+        let res = unsafe { libc::fstatvfs(inode_file.as_raw_fd(), out.as_mut_ptr()) };
         if res == 0 {
             // Safe because the kernel guarantees that `out` has been initialized.
             Ok(unsafe { out.assume_init() })
@@ -2339,7 +2339,7 @@ impl FileSystem for PassthroughFs {
         let fd = data.file.write().unwrap().as_raw_fd();
         // Safe because this doesn't modify any memory and we check the return value.
         let res = unsafe {
-            libc::fallocate64(
+            libc::fallocate(
                 fd,
                 mode as libc::c_int,
                 offset as libc::off64_t,
diff --git a/src/read_dir.rs b/src/read_dir.rs
index e2b2e89..a40a2a1 100644
--- a/src/read_dir.rs
+++ b/src/read_dir.rs
@@ -31,7 +31,7 @@ pub struct ReadDir<P> {
 impl<P: DerefMut<Target = [u8]>> ReadDir<P> {
     pub fn new<D: AsRawFd>(dir: &D, offset: libc::off64_t, mut buf: P) -> io::Result<Self> {
         // Safe because this doesn't modify any memory and we check the return value.
-        let res = unsafe { libc::lseek64(dir.as_raw_fd(), offset, libc::SEEK_SET) };
+        let res = unsafe { libc::lseek(dir.as_raw_fd(), offset, libc::SEEK_SET) };
         if res < 0 {
             return Err(io::Error::last_os_error());
         }
