[scudo] Implement and enable MemMapLinux

[Chia-hungDuan]

Summary

Most of the implementations are copied from linux.cpp and we will be
keeping those memory functions in linux.cpp for a while until we are
able to switch to use MemMap completely.

The remaining part is SizeClassAllocator32 which hasn't been switched to
use MemMap interface

[Chia-hungDuan]

Slightly improve the semantic of MemMapLinux::remap()

[cferris]

compiler-rt/lib/scudo/standalone/mem_map_linux.cpp

38–39

Is this still necessary? I'm not sure if you need to make this compile on old versions of Android, but PR_SET_VMA and PR_SET_VMA_ANON_NAME are available from the bionic kernel headers.

If you need to make this work on older versions of Android, maybe this should be changed to see if PR_SET_VMA is defined.

140

What happens if reserving fails? Should this function return a bool so that caller can fail gracefully?

[Chia-hungDuan]

Address review comment

[Chia-hungDuan]

Update commit message

[cferris]

A few questions.

compiler-rt/lib/scudo/standalone/mem_map_linux.cpp

96

This is a bit confusing. Why is the MapBase being set to Addr + Size? During the unmap, it doesn't seem like this shoudl happen.

97

Another slightly confusing part, it seems like unmapping would increase the total capacity, not decrease it.

[Chia-hungDuan]

Add more comments

compiler-rt/lib/scudo/standalone/mem_map_linux.cpp

38–39

This is copied from the old file linux.cpp, I added a TODO to mark it and we can discuss the necessity later

96

The unamp() supports partial unmapping but the result pages still have to be contiguous. So we check if the unmap() is either aligned to the begin addr or end addr in MemMapBase::unamp().

So far, this is not used so it's more like a contract for future. Like blocks merging in secondary.

97

Added few comments here. Let me know if it explains more.

140

Done. The API has been changed to return boolean.

[cferris]

LGTM the new comments answered my questions.

compiler-rt/lib/scudo/standalone/CMakeLists.txt

set(SCUDO_HEADERS
   fuchsia.h
   internal_defs.h
   linux.h
   list.h
   local_cache.h
   memtag.h
   mem_map.h
   mem_map_base.h
+  mem_map_linux.h
   mutex.h
   options.h
   platform.h
   primary32.h
   primary64.h
   quarantine.h
   release.h
   report.h
set(SCUDO_SOURCES
   checksum.cpp
   common.cpp
   crc32_hw.cpp
   flags_parser.cpp
   flags.cpp
   fuchsia.cpp
   linux.cpp
   mem_map.cpp
+  mem_map_linux.cpp
   release.cpp
   report.cpp
   rss_limit_checker.cpp
   string_utils.cpp
   )
 
 # Enable the necessary instruction set for scudo_crc32.cpp, if available.
 # Newer compiler versions use -mcrc32 rather than -msse4.2.

compiler-rt/lib/scudo/standalone/mem_map.h

 #include "internal_defs.h"
 
 // TODO: This is only used for `MapPlatformData`. Remove these includes when we
 // have all three platform specific `MemMap` and `ReservedMap` implementations.
 #include "fuchsia.h"
 #include "linux.h"
 #include "trusty.h"
 
+#include "mem_map_linux.h"
+
 namespace scudo {
 
 // This will be deprecated when every allocator has been supported by each
 // platform's `MemMap` implementation.
 class DefaultMemMap final : public MemMapBase<DefaultMemMap> {
 public:
   constexpr DefaultMemMap() = default;
   DefaultMemMap(uptr Base, uptr Capacity)

 
 private:
   uptr MapBase = 0;
   uptr MapCapacity = 0;
   MapPlatformData Data = {};
 };
 
 #if SCUDO_LINUX
-using ReservedMapT = DefaultReservedMap;
+using ReservedMapT = ReservedMapLinux;
 using MemMapT = ReservedMapT::MemMapT;
 #elif SCUDO_FUCHSIA
 using ReservedMapT = DefaultReservedMap;
 using MemMapT = ReservedMapT::MemMapT;
 #elif SCUDO_TRUSTY
 using ReservedMapT = DefaultReservedMap;
 using MemMapT = ReservedMapT::MemMapT;
 #else
 #error                                                                         \
     "Unsupported platform, please implement the ReservedMap for your platform!"
 #endif
 
 } // namespace scudo
 
 #endif // SCUDO_MEM_MAP_H_

compiler-rt/lib/scudo/standalone/mem_map_linux.h

-//===-- mem_map.h -----------------------------------------------*- C++ -*-===//
+//===-- mem_map_linux.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SCUDO_MEM_MAP_H_
-#define SCUDO_MEM_MAP_H_
+#ifndef SCUDO_MEM_MAP_LINUX_H_
+#define SCUDO_MEM_MAP_LINUX_H_
 
-#include "mem_map_base.h"
+#include "platform.h"
 
-#include "common.h"
-#include "internal_defs.h"
+#if SCUDO_LINUX
 
-// TODO: This is only used for `MapPlatformData`. Remove these includes when we
-// have all three platform specific `MemMap` and `ReservedMap` implementations.
-#include "fuchsia.h"
-#include "linux.h"
-#include "trusty.h"
+#include "common.h"
+#include "mem_map_base.h"
 
 namespace scudo {
 
-// This will be deprecated when every allocator has been supported by each
-// platform's `MemMap` implementation.
-class DefaultMemMap final : public MemMapBase<DefaultMemMap> {
+class MemMapLinux final : public MemMapBase<MemMapLinux> {
 public:
-  constexpr DefaultMemMap() = default;
-  DefaultMemMap(uptr Base, uptr Capacity)
+  constexpr MemMapLinux() = default;
+  MemMapLinux(uptr Base, uptr Capacity)
       : MapBase(Base), MapCapacity(Capacity) {}
 
   // Impls for base functions.
   bool mapImpl(uptr Addr, uptr Size, const char *Name, uptr Flags = 0);
   void unmapImpl(uptr Addr, uptr Size, uptr Flags = 0);
   bool remapImpl(uptr Addr, uptr Size, const char *Name, uptr Flags = 0);
   void setMemoryPermissionImpl(uptr Addr, uptr Size, uptr Flags);
   void releasePagesToOSImpl(uptr From, uptr Size) {
     return releaseAndZeroPagesToOSImpl(From, Size);
   }
   void releaseAndZeroPagesToOSImpl(uptr From, uptr Size);
   uptr getMapBaseImpl() { return MapBase; }
   uptr getMapCapacityImpl() { return MapCapacity; }
 
-  void setMapPlatformData(MapPlatformData &NewData) { Data = NewData; }
-
 private:
   uptr MapBase = 0;
   uptr MapCapacity = 0;
-  MapPlatformData Data = {};
 };
 
 // This will be deprecated when every allocator has been supported by each
 // platform's `MemMap` implementation.
-class DefaultReservedMap final
-    : public ReservedMap<DefaultReservedMap, DefaultMemMap> {
+class ReservedMapLinux final
+    : public ReservedMap<ReservedMapLinux, MemMapLinux> {
 public:
   // The following threes are the Impls for function in `MemMapBase`.
   uptr getMapBaseImpl() { return MapBase; }
   uptr getMapCapacityImpl() { return MapCapacity; }
   void unmapImpl(uptr Addr, uptr Size, uptr Flags = 0);
 
   // These two are specific to `ReservedMap`.
   void reserveImpl(uptr Addr, uptr Size, const char *Name, uptr Flags = 0);
   MemMapT allocateImpl(uptr Addr, uptr Size);
 
 private:
   uptr MapBase = 0;
   uptr MapCapacity = 0;
-  MapPlatformData Data = {};
 };
 
-#if SCUDO_LINUX
-using ReservedMapT = DefaultReservedMap;
-using MemMapT = ReservedMapT::MemMapT;
-#elif SCUDO_FUCHSIA
-using ReservedMapT = DefaultReservedMap;
-using MemMapT = ReservedMapT::MemMapT;
-#elif SCUDO_TRUSTY
-using ReservedMapT = DefaultReservedMap;
-using MemMapT = ReservedMapT::MemMapT;
-#else
-#error                                                                         \
-    "Unsupported platform, please implement the ReservedMap for your platform!"
-#endif
-
 } // namespace scudo
 
-#endif // SCUDO_MEM_MAP_H_
+#endif // SCUDO_LINUX
+
+#endif // SCUDO_MEM_MAP_LINUX_H_

compiler-rt/lib/scudo/standalone/mem_map_linux.cpp

+//===-- mem_map_linux.cpp ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "platform.h"
+
+#if SCUDO_LINUX
+
+#include "mem_map_linux.h"
+
+#include "common.h"
+#include "internal_defs.h"
+#include "linux.h"
+#include "mutex.h"
+#include "string_utils.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/futex.h>
+#include <sched.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <time.h>
+#include <unistd.h>
+
+#if SCUDO_ANDROID
+#include <sys/prctl.h>
+// Definitions of prctl arguments to set a vma name in Android kernels.
+#define ANDROID_PR_SET_VMA 0x53564d41
+#define ANDROID_PR_SET_VMA_ANON_NAME 0
+#endif
+
+namespace scudo {
+
+static void *mmapWrapper(uptr Addr, uptr Size, const char *Name, uptr Flags) {
+  int MmapFlags = MAP_PRIVATE | MAP_ANONYMOUS;
+  int MmapProt;
+  if (Flags & MAP_NOACCESS) {
+    MmapFlags |= MAP_NORESERVE;
+    MmapProt = PROT_NONE;
+  } else {
+    MmapProt = PROT_READ | PROT_WRITE;
+  }
+#if defined(__aarch64__)
+#ifndef PROT_MTE
+#define PROT_MTE 0x20
+#endif
+  if (Flags & MAP_MEMTAG)
+    MmapProt |= PROT_MTE;
+#endif
+  if (Addr)
+    MmapFlags |= MAP_FIXED;
+  void *P =
+      mmap(reinterpret_cast<void *>(Addr), Size, MmapProt, MmapFlags, -1, 0);
+  if (P == MAP_FAILED) {
+    if (!(Flags & MAP_ALLOWNOMEM) || errno != ENOMEM)
+      dieOnMapUnmapError(errno == ENOMEM ? Size : 0);
+    return nullptr;
+  }
+#if SCUDO_ANDROID
+  if (Name)
+    prctl(ANDROID_PR_SET_VMA, ANDROID_PR_SET_VMA_ANON_NAME, P, Size, Name);
+#else
+  (void)Name;
+#endif
+
+  return P;
+}
+
+bool MemMapLinux::mapImpl(uptr Addr, uptr Size, const char *Name, uptr Flags) {
+  void *P = mmapWrapper(Addr, Size, Name, Flags);
+  if (P == nullptr)
+    return false;
+
+  MapBase = reinterpret_cast<uptr>(P);
+  MapCapacity = Size;
+  return true;
+}
+
+void MemMapLinux::unmapImpl(uptr Addr, uptr Size, UNUSED uptr Flags) {
+  if (Size == MapCapacity) {
+    MapBase = MapCapacity = 0;
+  } else {
+    if (MapBase == Addr)
+      MapBase = Addr + Size;
+    MapCapacity -= Size;
+  }
+
+  if (munmap(reinterpret_cast<void *>(Addr), Size) != 0)
+    dieOnMapUnmapError();
+}
+
+bool MemMapLinux::remapImpl(uptr Addr, uptr Size, const char *Name,
+                            uptr Flags) {
+  void *P = mmapWrapper(Addr, Size, Name, Flags);
+  if (reinterpret_cast<uptr>(P) != Addr)
+    dieOnMapUnmapError();
+  return true;
+}
+
+void MemMapLinux::setMemoryPermissionImpl(uptr Addr, uptr Size, uptr Flags) {
+  int Prot = (Flags & MAP_NOACCESS) ? PROT_NONE : (PROT_READ | PROT_WRITE);
+  if (mprotect(reinterpret_cast<void *>(Addr), Size, Prot) != 0)
+    dieOnMapUnmapError();
+}
+
+void MemMapLinux::releaseAndZeroPagesToOSImpl(uptr From, uptr Size) {
+  void *Addr = reinterpret_cast<void *>(From);
+
+  while (madvise(Addr, Size, MADV_DONTNEED) == -1 && errno == EAGAIN) {
+  }
+}
+
+void ReservedMapLinux::unmapImpl(uptr Addr, uptr Size, UNUSED uptr Flags) {
+  if (Size == MapCapacity) {
+    MapBase = MapCapacity = 0;
+  } else {
+    if (MapBase == Addr)
+      MapBase = Addr + Size;
+    MapCapacity -= Size;
+  }
+
+  if (munmap(reinterpret_cast<void *>(Addr), Size) != 0)
+    dieOnMapUnmapError();
+}
+
+void ReservedMapLinux::reserveImpl(uptr Addr, uptr Size, const char *Name,
+                                   uptr Flags) {
+  ReservedMapLinux::MemMapT MemMap;
+  if (!MemMap.map(Addr, Size, Name, Flags | MAP_NOACCESS))
+    return;
+
+  MapBase = MemMap.getMapBase();
+  MapCapacity = MemMap.getMapCapacity();
+}
+
+ReservedMapLinux::MemMapT ReservedMapLinux::allocateImpl(uptr Addr, uptr Size) {
+  return ReservedMapLinux::MemMapT(Addr, Size);
+}
+
+} // namespace scudo
+
+#endif // SCUDO_LINUX