Fixed mmap usage and (re)-implemented most parts of memory_posix.cc

src/xenia/base/memory_posix.cc

@@ -10,9 +10,11 @@
 #include "xenia/base/memory.h"
 
 #include <fcntl.h>
+#include <semaphore.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <cstddef>
+#include <mutex>
 
 #include "xenia/base/math.h"
 #include "xenia/base/platform.h"
@@ -81,12 +83,45 @@ uint32_t ToPosixProtectFlags(PageAccess access) {
 
 bool IsWritableExecutableMemorySupported() { return true; }
 
+struct MappedFileRange {
+  size_t region_begin;
+  size_t region_end;
+};
+
+std::vector<struct MappedFileRange> mapped_file_ranges;
+std::mutex g_mapped_file_ranges_mutex;
+
 void* AllocFixed(void* base_address, size_t length,
                  AllocationType allocation_type, PageAccess access) {
   // mmap does not support reserve / commit, so ignore allocation_type.
   uint32_t prot = ToPosixProtectFlags(access);
-  void* result = mmap(base_address, length, prot,
-                      MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS, -1, 0);
+
+  const size_t region_begin = (size_t)base_address;
+  const size_t region_end = (size_t)base_address + length;
+
+  std::lock_guard<std::mutex> guard(g_mapped_file_ranges_mutex);
+  for (const auto& mapped_range : mapped_file_ranges) {
+    // Check if the allocation is within this range...
+    if (region_begin >= mapped_range.region_begin &&
+        region_end <= mapped_range.region_end) {
+      bool should_protect = (((uint8_t)allocation_type & 2) == 2);
+
+      if (should_protect) {
+        if (Protect(base_address, length, access)) {
+          return base_address;
+        }
+      } else if ((((uint8_t)allocation_type & 1) == 1)) {
+        return base_address;
+      }
+    }
+  }
+
+  int flags = MAP_PRIVATE | MAP_ANONYMOUS;
+  if (base_address != nullptr) {
+    flags |= MAP_FIXED_NOREPLACE;
+  }
+  void* result = mmap(base_address, length, prot, flags, -1, 0);
+
   if (result == MAP_FAILED) {
     return nullptr;
   } else {
@@ -96,6 +131,17 @@ void* AllocFixed(void* base_address, size_t length,
 
 bool DeallocFixed(void* base_address, size_t length,
                   DeallocationType deallocation_type) {
+  const size_t region_begin = (size_t)base_address;
+  const size_t region_end = (size_t)base_address + length;
+
+  std::lock_guard<std::mutex> guard(g_mapped_file_ranges_mutex);
+  for (const auto& mapped_range : mapped_file_ranges) {
+    if (region_begin >= mapped_range.region_begin &&
+        region_end <= mapped_range.region_end) {
+      return Protect(base_address, length, PageAccess::kNoAccess);
+    }
+  }
+
   return munmap(base_address, length) == 0;
 }
 
@@ -178,12 +224,39 @@ void CloseFileMappingHandle(FileMappingHandle handle,
 void* MapFileView(FileMappingHandle handle, void* base_address, size_t length,
                   PageAccess access, size_t file_offset) {
   uint32_t prot = ToPosixProtectFlags(access);
-  return mmap64(base_address, length, prot, MAP_PRIVATE | MAP_ANONYMOUS, handle,
+
+  int flags = MAP_SHARED;
+  if (base_address != nullptr) {
+    flags |= MAP_FIXED_NOREPLACE;
+  }
+
+  void* result = mmap(base_address, length, prot, flags, handle,
                 file_offset);
+
+  if (result == MAP_FAILED) {
+    return nullptr;
+  } else {
+    std::lock_guard<std::mutex> guard(g_mapped_file_ranges_mutex);
+    mapped_file_ranges.push_back({(size_t)result, (size_t)result + length});
+    return result;
+  }
 }
 
 bool UnmapFileView(FileMappingHandle handle, void* base_address,
                    size_t length) {
+  std::lock_guard<std::mutex> guard(g_mapped_file_ranges_mutex);
+  for (auto mapped_range = mapped_file_ranges.begin();
+       mapped_range != mapped_file_ranges.end();) {
+    if (mapped_range->region_begin == (size_t)base_address &&
+        mapped_range->region_end == (size_t)base_address + length) {
+      mapped_file_ranges.erase(mapped_range);
+      return munmap(base_address, length) == 0;
+    } else {
+      mapped_range++;
+    }
+  }
+  // TODO: Implement partial file unmapping.
+  assert_always("Error: Partial unmapping of files not yet supported.");
   return munmap(base_address, length) == 0;
 }