[Sanitizers] [Bug 24151] Generalize type of offset in internal_mmap

[mohit.bhakkad]

Summary

Using u64 as type for offset changes its value, changing starting address for map in file.
This patch solves Bug 24151, which raises issue while mapping file in mips32.

[mohit.bhakkad]

choosing a more apt data type

[dsanders]

Added Hans since this patch fixes the remaining asan failure in the 3.7 release.

[kcc]

LGTM

[dsanders]

The x86 build failed with:

projects/compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep.cc:318: undefined reference to `__sanitizer::MapWritableFileToMemory(void*, unsigned long, int, unsigned long)'
clang: error: linker command failed with exit code 1 (use -v to see invocation)

OFF_T is unsigned long long on this host.

I've therefore changed the definition in sanitizer_common.h to fix the build. Also, in anticipation of the windows build failing on the same issue I've changed the one in sanitizer_win.cc too.

I'm currently running check-all and I intend to commit on Mohit's behalf if that passes.

Hans+Kostya: Is this ok to merge to the release branch once it's committed?

[hans]

In D11588#215496, @dsanders wrote:

I'm currently running check-all and I intend to commit on Mohit's behalf if that passes.

Hans+Kostya: Is this ok to merge to the release branch once it's committed?

If everything works an Kostya is happy, I'm ok with merging.

[kcc]

Yep, feel free to merge if the tests pass.

[dsanders]

Great. Committed in r243686.

I had to make one more trivial change to make the tests pass. buildgo.sh failed because the printf's have a format/type mismatch. There's no portable way to print OFF_T so I'm casting to long long and using %lld

compiler-rt/trunk/lib/sanitizer_common/sanitizer_common.h

 // Returns true if file was successfully opened and read.
 bool ReadFileToBuffer(const char *file_name, char **buff, uptr *buff_size,
                       uptr *read_len, uptr max_len = 1 << 26,
                       error_t *errno_p = nullptr);
 // Maps given file to virtual memory, and returns pointer to it
 // (or NULL if mapping fails). Stores the size of mmaped region
 // in '*buff_size'.
 void *MapFileToMemory(const char *file_name, uptr *buff_size);
-void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, uptr offset);
+void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset);
 
 bool IsAccessibleMemoryRange(uptr beg, uptr size);
 
 // Error report formatting.
 const char *StripPathPrefix(const char *filepath,
                             const char *strip_file_prefix);
 // Strip the directories from the module name.
 const char *StripModuleName(const char *module);

compiler-rt/trunk/lib/sanitizer_common/sanitizer_linux.cc

 #if SANITIZER_LINUX && defined(__x86_64__)
 #include "sanitizer_syscall_linux_x86_64.inc"
 #else
 #include "sanitizer_syscall_generic.inc"
 #endif
 
 // --------------- sanitizer_libc.h
 uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
-                   u64 offset) {
+                   OFF_T offset) {
 #if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
   return internal_syscall(SYSCALL(mmap), (uptr)addr, length, prot, flags, fd,
                           offset);
 #else
   // mmap2 specifies file offset in 4096-byte units.
   CHECK(IsAligned(offset, 4096));
   return internal_syscall(SYSCALL(mmap2), addr, length, prot, flags, fd,
                           offset / 4096);

compiler-rt/trunk/lib/sanitizer_common/sanitizer_posix.h

 uptr internal_open(const char *filename, int flags, u32 mode);
 uptr internal_close(fd_t fd);
 
 uptr internal_read(fd_t fd, void *buf, uptr count);
 uptr internal_write(fd_t fd, const void *buf, uptr count);
 
 // Memory
 uptr internal_mmap(void *addr, uptr length, int prot, int flags,
-                   int fd, u64 offset);
+                   int fd, OFF_T offset);
 uptr internal_munmap(void *addr, uptr length);
 int internal_mprotect(void *addr, uptr length, int prot);
 
 // OS
 uptr internal_filesize(fd_t fd);  // -1 on error.
 uptr internal_stat(const char *path, void *buf);
 uptr internal_lstat(const char *path, void *buf);
 uptr internal_fstat(fd_t fd, void *buf);

compiler-rt/trunk/lib/sanitizer_common/sanitizer_posix.cc

void *MapFileToMemory(const char *file_name, uptr *buff_size) {
   uptr fsize = internal_filesize(fd);
   CHECK_NE(fsize, (uptr)-1);
   CHECK_GT(fsize, 0);
   *buff_size = RoundUpTo(fsize, GetPageSizeCached());
   uptr map = internal_mmap(0, *buff_size, PROT_READ, MAP_PRIVATE, fd, 0);
   return internal_iserror(map) ? 0 : (void *)map;
 }
 
-void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, uptr offset) {
+void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset) {
   uptr flags = MAP_SHARED;
   if (addr) flags |= MAP_FIXED;
   uptr p = internal_mmap(addr, size, PROT_READ | PROT_WRITE, flags, fd, offset);
   int mmap_errno = 0;
   if (internal_iserror(p, &mmap_errno)) {
-    Printf("could not map writable file (%d, %zu, %zu): %zd, errno: %d\n",
-           fd, offset, size, p, mmap_errno);
+    Printf("could not map writable file (%d, %lld, %zu): %zd, errno: %d\n",
+           fd, (long long)offset, size, p, mmap_errno);
     return 0;
   }
   return (void *)p;
 }
 
 static inline bool IntervalsAreSeparate(uptr start1, uptr end1,
                                         uptr start2, uptr end2) {
   CHECK(start1 <= end1);

compiler-rt/trunk/lib/sanitizer_common/sanitizer_win.cc

bool MemoryRangeIsAvailable(uptr range_start, uptr range_end) {
   return mbi.Protect == PAGE_NOACCESS &&
          (uptr)mbi.BaseAddress + mbi.RegionSize >= range_end;
 }
 
 void *MapFileToMemory(const char *file_name, uptr *buff_size) {
   UNIMPLEMENTED();
 }
 
-void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, uptr offset) {
+void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset) {
   UNIMPLEMENTED();
 }
 
 static const int kMaxEnvNameLength = 128;
 static const DWORD kMaxEnvValueLength = 32767;
 
 namespace {