[scudo] Enabled MAP_ALLOWNOMEM for all platforms

[ahomescu]

Summary

Back-ported from https://r.android.com/2591905.

[ahomescu]

Rebased.

[ahomescu]

Ran clang-format manually.

[Chia-hungDuan]

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

115

Can we add this to Flags at the prologue of the function instead? Like

Flags |= MAP_ALLOWNOMEM;

Maybe we can move MAP_RESIZABLE as well

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

53 ↗

(On Diff #534770)

Can we do this in a dependent patch?

[ahomescu]

Resolved comments.

[ahomescu]

Rebased.

[ahomescu]

Ran clang-format.

[Chia-hungDuan]

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

108–110

We should add this flag for all platforms

[ahomescu]

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

108–110

Would that need extra testing? I wasn't sure if it was safe to make that change.

[Chia-hungDuan]

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

108–110

It's fine to just add them. Other platforms have the logic implemented

[Chia-hungDuan]

Same as D155144, please update both commit message and the title here so that we won't be confused while review these changes

[ahomescu]

Enabled MAP_ALLOWNOMEM for all platforms.

[Chia-hungDuan]

Will merge this by tomorrow

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

public:
   void getStats(UNUSED ScopedString *Str) {
     Str->append("Secondary Cache Disabled\n");
   }
 };
 
 static const uptr MaxUnusedCachePages = 4U;
 
 template <typename Config>
-void mapSecondary(Options Options, uptr CommitBase, uptr CommitSize,
+bool mapSecondary(Options Options, uptr CommitBase, uptr CommitSize,
                   uptr AllocPos, uptr Flags, MemMapT &MemMap) {
+  Flags |= MAP_RESIZABLE;
+  Flags |= MAP_ALLOWNOMEM;
+
   const uptr MaxUnusedCacheBytes = MaxUnusedCachePages * getPageSizeCached();
   if (useMemoryTagging<Config>(Options) && CommitSize > MaxUnusedCacheBytes) {
     const uptr UntaggedPos = Max(AllocPos, CommitBase + MaxUnusedCacheBytes);
-    MemMap.remap(CommitBase, UntaggedPos - CommitBase, "scudo:secondary",
-                 MAP_RESIZABLE | MAP_MEMTAG | Flags);
+    return MemMap.remap(CommitBase, UntaggedPos - CommitBase, "scudo:secondary",
+                        MAP_MEMTAG | Flags) &&
            MemMap.remap(UntaggedPos, CommitBase + CommitSize - UntaggedPos,
-                 "scudo:secondary", MAP_RESIZABLE | Flags);
+                        "scudo:secondary", Flags);
   } else {
     const uptr RemapFlags =
-        MAP_RESIZABLE | (useMemoryTagging<Config>(Options) ? MAP_MEMTAG : 0) |
-        Flags;
-    MemMap.remap(CommitBase, CommitSize, "scudo:secondary", RemapFlags);
+        (useMemoryTagging<Config>(Options) ? MAP_MEMTAG : 0) | Flags;
+    return MemMap.remap(CommitBase, CommitSize, "scudo:secondary", RemapFlags);
   }
 }
 
 // Template specialization to avoid producing zero-length array
 template <typename T, size_t Size> class NonZeroLengthArray {
 public:
   T &operator[](uptr Idx) { return values[Idx]; }
 
bool retrieve(Options Options, uptr Size, uptr Alignment,
     uptr NewBlockBegin = reinterpret_cast<uptr>(*H + 1);
     if (useMemoryTagging<Config>(Options)) {
       if (*Zeroed) {
         storeTags(LargeBlock::addHeaderTag<Config>(Entry.CommitBase),
                   NewBlockBegin);
       } else if (Entry.BlockBegin < NewBlockBegin) {
         storeTags(Entry.BlockBegin, NewBlockBegin);
       } else {
-        storeTags(untagPointer(NewBlockBegin),
-                  untagPointer(Entry.BlockBegin));
+        storeTags(untagPointer(NewBlockBegin), untagPointer(Entry.BlockBegin));
       }
     }
     (*H)->CommitBase = Entry.CommitBase;
     (*H)->CommitSize = Entry.CommitSize;
     (*H)->MemMap = Entry.MemMap;
     return true;
   }
 
if (UNLIKELY(Alignment >= PageSize)) {
     if (SCUDO_WORDSIZE == 32U && NewMapEnd != MapEnd) {
       MemMap.unmap(NewMapEnd, MapEnd - NewMapEnd);
       MapEnd = NewMapEnd;
     }
   }
 
   const uptr CommitSize = MapEnd - PageSize - CommitBase;
   const uptr AllocPos = roundDown(CommitBase + CommitSize - Size, Alignment);
-  mapSecondary<Config>(Options, CommitBase, CommitSize, AllocPos, 0, MemMap);
+  if (!mapSecondary<Config>(Options, CommitBase, CommitSize, AllocPos, 0,
+                            MemMap)) {
+    MemMap.unmap(MemMap.getBase(), MemMap.getCapacity());
+    return nullptr;
+  }
   const uptr HeaderPos =
       AllocPos - Chunk::getHeaderSize() - LargeBlock::getHeaderSize();
   LargeBlock::Header *H = reinterpret_cast<LargeBlock::Header *>(
       LargeBlock::addHeaderTag<Config>(HeaderPos));
   if (useMemoryTagging<Config>(Options))
     storeTags(LargeBlock::addHeaderTag<Config>(CommitBase),
               reinterpret_cast<uptr>(H + 1));
   H->CommitBase = CommitBase;