Use off_t instead of off64_t for musl compatibility.

rocallahan · rocallahan · commit c5f1eccc7ca0 · 2025-08-16T19:03:02.000+12:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -72,7 +72,7 @@ configure_file(
   ${CMAKE_BINARY_DIR}/extra_version_string.h
 )
 
-set(FLAGS_COMMON "-D__USE_LARGEFILE64 -pthread")
+set(FLAGS_COMMON "-D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -pthread")
 set(supports32bit true)
 set(x86ish false)
 set(has_syscallbuf false)
diff --git a/src/AddressSpace.cc b/src/AddressSpace.cc
@@ -815,7 +815,7 @@ static void add_range(set<MemoryRange>& ranges, const MemoryRange& range) {
 
 KernelMapping AddressSpace::map(Task* t, remote_ptr<void> addr,
                                 size_t num_bytes, int prot, int flags,
-                                off64_t offset_bytes, const string& fsname,
+                                off_t offset_bytes, const string& fsname,
                                 dev_t device, ino_t inode,
                                 unique_ptr<struct stat> mapped_file_stat,
                                 const KernelMapping* recorded_map,
@@ -1633,7 +1633,7 @@ static bool is_adjacent_mapping(const KernelMapping& mleft,
     return false;
   }
   if (mleft.is_real_device() &&
-      mleft.file_offset_bytes() + off64_t(mleft.size()) !=
+      mleft.file_offset_bytes() + off_t(mleft.size()) !=
           mright.file_offset_bytes()) {
     return false;
   }
diff --git a/src/AddressSpace.h b/src/AddressSpace.h
@@ -63,7 +63,7 @@ class KernelMapping : public MemoryRange {
   KernelMapping() : device_(0), inode_(0), prot_(0), flags_(0), offset(0) {}
   KernelMapping(remote_ptr<void> start, remote_ptr<void> end,
                 const std::string& fsname, dev_t device, ino_t inode, int prot,
-                int flags, off64_t offset = 0)
+                int flags, off_t offset = 0)
       : MemoryRange(start, end),
         fsname_(fsname),
         device_(device),
@@ -441,7 +441,7 @@ class AddressSpace : public HasTaskSet {
    */
   KernelMapping map(
       Task* t, remote_ptr<void> addr, size_t num_bytes, int prot, int flags,
-      off64_t offset_bytes, const std::string& fsname,
+      off_t offset_bytes, const std::string& fsname,
       dev_t device = KernelMapping::NO_DEVICE,
       ino_t inode = KernelMapping::NO_INODE,
       std::unique_ptr<struct stat> mapped_file_stat = nullptr,
diff --git a/src/AutoRemoteSyscalls.cc b/src/AutoRemoteSyscalls.cc
@@ -917,7 +917,7 @@ void AutoRemoteSyscalls::finish_direct_mmap(
                                int prot, int flags,
                                const string& backing_file_name,
                                int backing_file_open_flags,
-                               off64_t backing_offset_bytes,
+                               off_t backing_offset_bytes,
                                struct stat& real_file, string& real_file_name) {
   int fd;
 
diff --git a/src/AutoRemoteSyscalls.h b/src/AutoRemoteSyscalls.h
@@ -278,7 +278,7 @@ class AutoRemoteSyscalls {
                           int prot, int flags,
                           const std::string& backing_file_name,
                           int backing_file_open_flags,
-                          off64_t backing_offset_bytes,
+                          off_t backing_offset_bytes,
                           struct stat& real_file, std::string& real_file_name);
 
   // Calling this with allow_death false is DEPRECATED.
diff --git a/src/CompressedReader.cc b/src/CompressedReader.cc
@@ -1,7 +1,5 @@
 /* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */
 
-#define _LARGEFILE64_SOURCE
-
 #include "CompressedReader.h"
 
 #include <brotli/decode.h>
diff --git a/src/CompressedWriter.cc b/src/CompressedWriter.cc
@@ -1,7 +1,5 @@
 /* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */
 
-#define _LARGEFILE64_SOURCE
-
 #include "CompressedWriter.h"
 
 #include <brotli/encode.h>
diff --git a/src/kernel_abi.h b/src/kernel_abi.h
@@ -1357,7 +1357,8 @@ struct BaseArch : public wordsize,
   };
   RR_VERIFY_TYPE_EXPLICIT(struct ::statfs, statfs_t);
 
-  struct statfs64_t {
+  /* Don't align for the 64-bit values on 32-bit x86 */
+  struct __attribute__((packed)) statfs64_t {
     __statfs_word f_type;
     __statfs_word f_bsize;
     uint64_t f_blocks;
diff --git a/src/record_syscall.cc b/src/record_syscall.cc
@@ -6019,8 +6019,8 @@ static void process_execve(RecordTask* t, TaskSyscallState& syscall_state) {
                                               TraceWriter::EXEC_MAPPING) ==
         TraceWriter::RECORD_IN_TRACE) {
       if (st.st_size > 0) {
-        off64_t end = (off64_t)st.st_size - km.file_offset_bytes();
-        t->record_remote(km.start(), min(end, (off64_t)km.size()));
+        off_t end = (off_t)st.st_size - km.file_offset_bytes();
+        t->record_remote(km.start(), min(end, (off_t)km.size()));
       } else {
         // st_size is not valid. Some device files are mmappable but have zero
         // size. We also take this path if there's no file at all (vdso etc).
@@ -6122,7 +6122,7 @@ static vector<WriteHole> find_holes(RecordTask* t, int desc, uint64_t offset, ui
   uint64_t file_start = offset;
   uint64_t file_end = offset + size;
   while (offset < file_end) {
-    off64_t r = lseek(fd, offset, SEEK_HOLE);
+    off_t r = lseek(fd, offset, SEEK_HOLE);
     if (r < 0) {
       // SEEK_HOLE not supported?
       return ret;
@@ -6198,7 +6198,7 @@ static void check_outside_mappings(const KernelMapping& tracee_km, const RecordS
 }
 
 static void process_mmap(RecordTask* t, size_t length, int prot, int flags,
-                         int fd, off64_t offset) {
+                         int fd, off_t offset) {
   if (t->regs().syscall_failed()) {
     // We purely emulate failed mmaps.
     return;
@@ -6266,8 +6266,8 @@ static void process_mmap(RecordTask* t, size_t length, int prot, int flags,
                                             TraceWriter::SYSCALL_MAPPING,
                                             !monitor_this_fd) ==
       TraceWriter::RECORD_IN_TRACE) {
-    off64_t end = (off64_t)st.st_size - km.file_offset_bytes();
-    off64_t nbytes = min(end, (off64_t)km.size());
+    off_t end = (off_t)st.st_size - km.file_offset_bytes();
+    off_t nbytes = min(end, (off_t)km.size());
     vector<WriteHole> holes = find_holes(t, fd, km.file_offset_bytes(), (uint64_t)nbytes);
     ssize_t nread = t->record_remote_fallible(addr, nbytes, holes);
     if (!adjusted_size && nread != nbytes) {
@@ -6376,10 +6376,10 @@ static void process_mremap(RecordTask* t, remote_ptr<void> old_addr,
   if (t->trace_writer().write_mapped_region(t, km, st, km.fsname(),
                                             vector<TraceRemoteFd>()) ==
       TraceWriter::RECORD_IN_TRACE) {
-    off64_t end = max<off64_t>(st.st_size - km.file_offset_bytes(), 0);
+    off_t end = max<off_t>(st.st_size - km.file_offset_bytes(), 0);
     // Allow failure; the underlying file may have true zero size, in which
     // case this may try to record unmapped memory.
-    t->record_remote_fallible(km.start(), min(end, (off64_t)km.size()));
+    t->record_remote_fallible(km.start(), min(end, (off_t)km.size()));
   }
 
   // If the original mapping was monitored, we'll continue monitoring it
diff --git a/src/replay_syscall.cc b/src/replay_syscall.cc
@@ -598,7 +598,7 @@ static void write_mapped_data(ReplayTask* t,
 
 static void finish_private_mmap(ReplayTask* t, AutoRemoteSyscalls& remote,
                                 remote_ptr<void> rec_addr, size_t length,
-                                int prot, int flags, off64_t offset_bytes,
+                                int prot, int flags, off_t offset_bytes,
                                 const KernelMapping& km,
                                 TraceReader::MappedData& data) {
   LOG(debug) << "  finishing private mmap of " << km.fsname();
@@ -622,7 +622,7 @@ static void finish_private_mmap(ReplayTask* t, AutoRemoteSyscalls& remote,
 static void finish_shared_mmap(ReplayTask* t, AutoRemoteSyscalls& remote,
                                remote_ptr<void> rec_addr, size_t length,
                                int prot, int flags, const vector<TraceRemoteFd>& fds,
-                               off64_t offset_bytes,
+                               off_t offset_bytes,
                                const KernelMapping& km,
                                TraceReader::MappedData& data) {
   // Ensure there's a virtual file for the file that was mapped
@@ -680,7 +680,7 @@ static void finish_shared_mmap(ReplayTask* t, AutoRemoteSyscalls& remote,
 
 static void process_mmap(ReplayTask* t, const TraceFrame& trace_frame,
                          size_t length, int prot, int flags, int fd,
-                         off64_t offset_bytes, ReplayTraceStep* step) {
+                         off_t offset_bytes, ReplayTraceStep* step) {
   step->action = TSTEP_RETIRE;
 
   {
diff --git a/src/syscalls.py b/src/syscalls.py
@@ -1128,7 +1128,7 @@ def __init__(self, **kwargs):
 # gettid() returns the caller's thread ID (TID).
 gettid = EmulatedSyscall(x86=224, x64=186, generic=178)
 
-#  ssize_t readahead(int fd, off64_t offset, size_t count);
+#  ssize_t readahead(int fd, off_t offset, size_t count);
 #
 # readahead() populates the page cache with data from a file so that
 # subsequent reads from that file will not block on disk I/O.  The fd
@@ -1169,7 +1169,7 @@ def __init__(self, **kwargs):
 fremovexattr = EmulatedSyscall(x86=237, x64=199, generic=16)
 tkill = EmulatedSyscall(x86=238, x64=200, generic=130)
 
-# ssize_t sendfile64 (int __out_fd, int __in_fd, __off64_t *__offset, size_t
+# ssize_t sendfile64 (int __out_fd, int __in_fd, __off_t *__offset, size_t
 #__count);
 #
 # Send up to COUNT bytes from file associated with IN_FD starting at
diff --git a/src/test/detach_state.c b/src/test/detach_state.c
@@ -54,7 +54,7 @@ int main(int argc, char **argv) {
         volatile uintptr_t stackval = 0;
         int fd = open("/proc/self/mem", O_RDWR);
         test_assert(fd >= 0);
-        test_assert(sizeof(stackval) == pwrite64(fd, &newval, sizeof(stackval), (off64_t)(uintptr_t)&stackval));
+        test_assert(sizeof(stackval) == pwrite64(fd, &newval, sizeof(stackval), (off_t)(uintptr_t)&stackval));
         test_assert(stackval == 1);
 
         // Check that rlimits survive
@@ -82,7 +82,7 @@ int main(int argc, char **argv) {
         do_rdtsc();
 
         newval = 2;
-        test_assert(sizeof(stackval) == pwrite64(fd, &newval, sizeof(stackval), (off64_t)(uintptr_t)&stackval));
+        test_assert(sizeof(stackval) == pwrite64(fd, &newval, sizeof(stackval), (off_t)(uintptr_t)&stackval));
         test_assert(stackval == 2);
 
         // Validate that rr reset the scheduler affinity mask.
diff --git a/src/test/large_hole.c b/src/test/large_hole.c
@@ -4,7 +4,7 @@
 
 int main(void) {
 #ifdef __x86_64__
-  off64_t size = ((off64_t)100)*1024*1024*1024;
+  off_t size = ((off_t)100)*1024*1024*1024;
   char* p;
   int fd = open("big", O_RDWR | O_TRUNC | O_CREAT, 0700);
   test_assert(pwrite64(fd, "x", 1, size) == 1);
diff --git a/src/test/proc_mem.c b/src/test/proc_mem.c
@@ -131,15 +131,15 @@ static void do_test(int (*opener)(int)) {
   fd = opener(child);
   test_assert(fd >= 0);
   test_assert(sizeof(COOKIE) ==
-              pwrite(fd, &COOKIE, sizeof(COOKIE), (off_t)&cookie1));
+              pwrite(fd, &COOKIE, sizeof(COOKIE), (uintptr_t)&cookie1));
 
   iov[0].iov_base = (char*)&COOKIE;
   iov[0].iov_len = 2;
   iov[1].iov_base = (char*)&COOKIE + 2;
   iov[1].iov_len = 2;
-  test_assert(sizeof(COOKIE) == pwritev(fd, iov, 2, (off_t)&cookie2));
+  test_assert(sizeof(COOKIE) == pwritev(fd, iov, 2, (uintptr_t)&cookie2));
 
-  lseek(fd, (off_t)&cookie3, SEEK_SET);
+  lseek(fd, (uintptr_t)&cookie3, SEEK_SET);
   test_assert(sizeof(COOKIE) == write(fd, &COOKIE, sizeof(COOKIE)));
 
   test_assert(1 == write(pipe_fds[1], "x", 1));
diff --git a/src/test/ptrace_breakpoint.c b/src/test/ptrace_breakpoint.c
@@ -43,9 +43,9 @@ int main(void) {
   test_assert(status == ((SIGSTOP << 8) | 0x7f));
 
   test_assert(bkpt_size ==
-    pread(mem_fd, saved_bytes, bkpt_size, (off_t)breakpoint));
+    pread(mem_fd, saved_bytes, bkpt_size, (uintptr_t)breakpoint));
   test_assert(bkpt_size ==
-    pwrite(mem_fd, breakpoint_instruction, bkpt_size, (off_t)breakpoint));
+    pwrite(mem_fd, breakpoint_instruction, bkpt_size, (uintptr_t)breakpoint));
 
   test_assert(1 == write(pipe_fds[1], "x", 1));
   test_assert(0 == ptrace(PTRACE_CONT, child, NULL, (void*)0));
@@ -54,7 +54,7 @@ int main(void) {
   ptrace_getregs(child, &regs);
   test_assert((char*)regs.IP == (char*)breakpoint + ip_after_breakpoint ? bkpt_size : 0);
 
-  test_assert(bkpt_size == pwrite(mem_fd, saved_bytes, bkpt_size, (off_t)breakpoint));
+  test_assert(bkpt_size == pwrite(mem_fd, saved_bytes, bkpt_size, (uintptr_t)breakpoint));
   if (ip_after_breakpoint) {
     regs.IP -= bkpt_size;
   }
diff --git a/src/test/statfs.c b/src/test/statfs.c
@@ -7,14 +7,14 @@
 static void dump_statfs(const char* label, const struct statfs* s) {
   atomic_printf("%s: {\n"
                 "    type:0x%lx, bsize:%ld, \n"
-                "    blocks:%ld, bfree:%ld, bavail:%ld,\n"
-                "    files:%lu, ffree:%lu,\n"
+                "    blocks:%lld, bfree:%lld, bavail:%lld,\n"
+                "    files:%llu, ffree:%llu,\n"
                 "    fsid: { %d, %d },\n"
                 "    namelen:%ld, frsize:%ld,\n"
                 "    flags:0x%lx\n"
                 "}\n",
-                label, (long)s->f_type, (long)s->f_bsize, s->f_blocks,
-                s->f_bfree, s->f_bavail, s->f_files, s->f_ffree,
+                label, (long)s->f_type, (long)s->f_bsize, (long long)s->f_blocks,
+                (long long)s->f_bfree, (long long)s->f_bavail, (unsigned long long)s->f_files, (unsigned long long)s->f_ffree,
                 s->f_fsid.__val[0], s->f_fsid.__val[1], (long)s->f_namelen,
                 (long)s->f_frsize, (long)s->f_flags);
 }
diff --git a/src/util.cc b/src/util.cc
@@ -2223,7 +2223,7 @@ void write_all(int fd, const void* buf, size_t size) {
   }
 }
 
-ssize_t pwrite_all_fallible(int fd, const void* buf, size_t size, off64_t offset) {
+ssize_t pwrite_all_fallible(int fd, const void* buf, size_t size, off_t offset) {
   ssize_t written = 0;
   while (size > 0) {
     ssize_t ret = ::pwrite64(fd, buf, size, offset);
diff --git a/src/util.h b/src/util.h
@@ -534,7 +534,7 @@ uint32_t crc32(uint32_t crc, unsigned char* buf, size_t len);
 void write_all(int fd, const void* buf, size_t size);
 
 /* Like pwrite64(2) but we try to write all bytes by looping on short writes. */
-ssize_t pwrite_all_fallible(int fd, const void* buf, size_t size, off64_t offset);
+ssize_t pwrite_all_fallible(int fd, const void* buf, size_t size, off_t offset);
 
 /* Returns true if |path| is an accessible directory. Returns false if there
  * was an error.

Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ configure_file(`
`72`	`72`	`${CMAKE_BINARY_DIR}/extra_version_string.h`
`73`	`73`	`)`
`74`	`74`
`75`		`-set(FLAGS_COMMON "-D__USE_LARGEFILE64 -pthread")`
	`75`	`+set(FLAGS_COMMON "-D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -pthread")`
`76`	`76`	`set(supports32bit true)`
`77`	`77`	`set(x86ish false)`
`78`	`78`	`set(has_syscallbuf false)`