[scudo] Rework dieOnMapUnmapError

[cryptoad]

Summary

Said function had a few shortfalls:

• didn't set an abort message on Android
• was logged on several lines
• didn't provide extra information like the size requested if OOM'ing

This improves the function to address those points.

[hctim]

LGTM

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

void unmap(void *Addr, uptr Size, uptr Flags = 0,
            MapPlatformData *Data = nullptr);
 
 void setMemoryPermission(uptr Addr, uptr Size, uptr Flags,
                          MapPlatformData *Data = nullptr);
 
 void releasePagesToOS(uptr BaseAddress, uptr Offset, uptr Size,
                       MapPlatformData *Data = nullptr);
 
-// Internal map & unmap fatal error. This must not call map().
-void NORETURN dieOnMapUnmapError(bool OutOfMemory = false);
+// Internal map & unmap fatal error. This must not call map(). SizeIfOOM shall
+// hold the requested size on an out-of-memory error, 0 otherwise.
+void NORETURN dieOnMapUnmapError(uptr SizeIfOOM = 0);
 
 // Logging related functions.
 
 void setAbortMessage(const char *Message);
 
 struct BlockInfo {
   uptr BlockBegin;
   uptr BlockSize;

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

 //===-- common.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 "common.h"
 #include "atomic_helpers.h"
+#include "string_utils.h"
 
 namespace scudo {
 
 uptr PageSizeCached;
 uptr getPageSize();
 
 uptr getPageSizeSlow() {
   PageSizeCached = getPageSize();
   CHECK_NE(PageSizeCached, 0);
   return PageSizeCached;
 }
 
 // Fatal internal map() or unmap() error (potentially OOM related).
-void NORETURN dieOnMapUnmapError(bool OutOfMemory) {
-  outputRaw("Scudo ERROR: internal map or unmap failure");
-  if (OutOfMemory)
-    outputRaw(" (OOM)");
-  outputRaw("\n");
+void NORETURN dieOnMapUnmapError(uptr SizeIfOOM) {
+  char Error[128] = "Scudo ERROR: internal map or unmap failure\n";
+  if (SizeIfOOM) {
+    formatString(
+        Error, sizeof(Error),
+        "Scudo ERROR: internal map failure (NO MEMORY) requesting %zuKB\n",
+        SizeIfOOM >> 10);
+  }
+  outputRaw(Error);
+  setAbortMessage(Error);
   die();
 }
 
 } // namespace scudo

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

static void *allocateVmar(uptr Size, MapPlatformData *Data, bool AllowNoMem) {
   DCHECK_EQ(Data->Vmar, ZX_HANDLE_INVALID);
 
   const zx_status_t Status = _zx_vmar_allocate(
       _zx_vmar_root_self(),
       ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC, 0,
       Size, &Data->Vmar, &Data->VmarBase);
   if (UNLIKELY(Status != ZX_OK)) {
     if (Status != ZX_ERR_NO_MEMORY || !AllowNoMem)
-      dieOnMapUnmapError(Status == ZX_ERR_NO_MEMORY);
+      dieOnMapUnmapError(Status == ZX_ERR_NO_MEMORY ? Size : 0);
     return nullptr;
   }
   return reinterpret_cast<void *>(Data->VmarBase);
 }
 
 void *map(void *Addr, uptr Size, const char *Name, uptr Flags,
           MapPlatformData *Data) {
   DCHECK_EQ(Size % getPageSizeCached(), 0);
if (Data && Data->Vmo != ZX_HANDLE_INVALID) {
     // If a Vmo was specified, it's a resize operation.
     CHECK(Addr);
     DCHECK(Flags & MAP_RESIZABLE);
     Vmo = Data->Vmo;
     VmoSize = Data->VmoSize;
     Status = _zx_vmo_set_size(Vmo, VmoSize + Size);
     if (Status != ZX_OK) {
       if (Status != ZX_ERR_NO_MEMORY || !AllowNoMem)
-        dieOnMapUnmapError(Status == ZX_ERR_NO_MEMORY);
+        dieOnMapUnmapError(Status == ZX_ERR_NO_MEMORY ? Size : 0);
       return nullptr;
     }
   } else {
     // Otherwise, create a Vmo and set its name.
     Status = _zx_vmo_create(Size, ZX_VMO_RESIZABLE, &Vmo);
     if (UNLIKELY(Status != ZX_OK)) {
       if (Status != ZX_ERR_NO_MEMORY || !AllowNoMem)
-        dieOnMapUnmapError(Status == ZX_ERR_NO_MEMORY);
+        dieOnMapUnmapError(Status == ZX_ERR_NO_MEMORY ? Size : 0);
       return nullptr;
     }
     _zx_object_set_property(Vmo, ZX_PROP_NAME, Name, strlen(Name));
   }
 
   uintptr_t P;
   zx_vm_option_t MapFlags =
       ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_ALLOW_FAULTS;
if (Data->Vmo == ZX_HANDLE_INVALID)
       Data->Vmo = Vmo;
     else
       DCHECK_EQ(Data->Vmo, Vmo);
   } else {
     CHECK_EQ(_zx_handle_close(Vmo), ZX_OK);
   }
   if (UNLIKELY(Status != ZX_OK)) {
     if (Status != ZX_ERR_NO_MEMORY || !AllowNoMem)
-      dieOnMapUnmapError(Status == ZX_ERR_NO_MEMORY);
+      dieOnMapUnmapError(Status == ZX_ERR_NO_MEMORY ? Size : 0);
     return nullptr;
   }
   if (Data)
     Data->VmoSize += Size;
 
   return reinterpret_cast<void *>(P);
 }
 

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

#endif
   if (Addr) {
     // Currently no scenario for a noaccess mapping with a fixed address.
     DCHECK_EQ(Flags & MAP_NOACCESS, 0);
     MmapFlags |= MAP_FIXED;
   }
   void *P = mmap(Addr, Size, MmapProt, MmapFlags, -1, 0);
   if (P == MAP_FAILED) {
     if (!(Flags & MAP_ALLOWNOMEM) || errno != ENOMEM)
-      dieOnMapUnmapError(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);
 #endif
   return P;
 }
 
 void unmap(void *Addr, uptr Size, UNUSED uptr Flags,
            UNUSED MapPlatformData *Data) {
   if (munmap(Addr, Size) != 0)
     dieOnMapUnmapError();
 }
 
 void setMemoryPermission(uptr Addr, uptr Size, uptr Flags,
                          UNUSED MapPlatformData *Data) {
   int Prot = (Flags & MAP_NOACCESS) ? PROT_NONE : (PROT_READ | PROT_WRITE);
   if (mprotect(reinterpret_cast<void *>(Addr), Size, Prot) != 0)
     dieOnMapUnmapError();
 }
 
 static bool madviseNeedsMemset() {
-  uptr Size = getPageSizeCached();
-  char *P = (char *)mmap(0, Size, PROT_READ | PROT_WRITE,
-                         MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  const uptr Size = getPageSizeCached();
+  char *P = reinterpret_cast<char *>(mmap(0, Size, PROT_READ | PROT_WRITE,
+                                          MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
   if (!P)
-    dieOnMapUnmapError(errno == ENOMEM);
+    dieOnMapUnmapError(errno == ENOMEM ? Size : 0);
   *P = 1;
   while (madvise(P, Size, MADV_DONTNEED) == -1 && errno == EAGAIN) {
   }
-  bool R = (*P != 0);
+  const bool R = (*P != 0);
   if (munmap(P, Size) != 0)
     dieOnMapUnmapError();
   return R;
 }
 
 static bool madviseNeedsMemsetCached() {
   static atomic_u8 Cache;
   enum State : u8 { Unknown = 0, Yes = 1, No = 2 };

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

public:
   void append(const char *Format, ...);
   void output() const { outputRaw(String.data()); }
 
 private:
   Vector<char> String;
   uptr Length;
 };
 
+int formatString(char *Buffer, uptr BufferLength, const char *Format, ...);
 void Printf(const char *Format, ...);
 
 } // namespace scudo
 
 #endif // SCUDO_STRING_UTILS_H_

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

static int appendPointer(char **Buffer, const char *BufferEnd, u64 ptr_value) {
   int Res = 0;
   Res += appendString(Buffer, BufferEnd, 0, -1, "0x");
   Res += appendUnsigned(Buffer, BufferEnd, ptr_value, 16,
                         SCUDO_POINTER_FORMAT_LENGTH, /*PadWithZero=*/true,
                         /*Upper=*/false);
   return Res;
 }
 
-int formatString(char *Buffer, uptr BufferLength, const char *Format,
+static int formatString(char *Buffer, uptr BufferLength, const char *Format,
                         va_list Args) {
   static const char *PrintfFormatsHelp =
       "Supported formatString formats: %([0-9]*)?(z|ll)?{d,u,x,X}; %p; "
       "%[-]([0-9]*)?(\\.\\*)?s; %c\n";
   RAW_CHECK(Format);
   RAW_CHECK(BufferLength > 0);
   const char *BufferEnd = &Buffer[BufferLength - 1];
   const char *Cur = Format;
   int Res = 0;
for (; *Cur; Cur++) {
     }
     }
   }
   RAW_CHECK(Buffer <= BufferEnd);
   appendChar(&Buffer, BufferEnd + 1, '\0');
   return Res;
 }
 
+int formatString(char *Buffer, uptr BufferLength, const char *Format, ...) {
+  va_list Args;
+  va_start(Args, Format);
+  int Res = formatString(Buffer, BufferLength, Format, Args);
+  va_end(Args);
+  return Res;
+}
+
 void ScopedString::append(const char *Format, va_list Args) {
   DCHECK_LT(Length, String.size());
   va_list ArgsCopy;
   va_copy(ArgsCopy, Args);
   // formatString doesn't currently support a null buffer or zero buffer length,
   // so in order to get the resulting formatted string length, we use a one-char
   // buffer.
   char C[1];