[scudo] Skip AllocAfterFork test on machines with low max_map_count

[cryptoad]

Summary

Reducing the number of iterations in that test with D111342 helped,
but the failure still occured flakily when the test is ran as part
of a large test suite.

Reducing further the number of iterations might not be good enough,
so we will skip the test if the max_map_count variable can be
read, and if lower than a given threshold.

[cryptoad]

... and remove local debugging line.

[leonardchan]

LGTM Thanks again for looking into this.

compiler-rt/lib/scudo/standalone/tests/wrappers_cpp_test.cpp

 //===-- wrappers_cpp_test.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 "memtag.h"
 #include "tests/scudo_unit_test.h"
 
 #include <atomic>
 #include <condition_variable>
+#include <fstream>
 #include <memory>
 #include <mutex>
 #include <thread>
 #include <vector>
 
 void operator delete(void *, size_t) noexcept;
 void operator delete[](void *, size_t) noexcept;
 
for (size_t I = 0U; I < sizeof(Threads) / sizeof(Threads[0]); I++)
     Cv.notify_all();
   }
   for (auto &T : Threads)
     T.join();
 }
 
 #if !SCUDO_FUCHSIA
 TEST(ScudoWrappersCppTest, AllocAfterFork) {
+  // This test can fail flakily when ran as a part of large number of
+  // other tests if the maxmimum number of mappings allowed is low.
+  // We tried to reduce the number of iterations of the loops with
+  // moderate success, so we will now skip this test under those
+  // circumstances.
+  if (SCUDO_LINUX) {
+    long MaxMapCount = 0;
+    // If the file can't be accessed, we proceed with the test.
+    std::ifstream Stream("/proc/sys/vm/max_map_count");
+    if (Stream.good()) {
+      Stream >> MaxMapCount;
+      if (MaxMapCount < 200000)
+        return;
+    }
+  }
+
   std::atomic_bool Stop;
 
   // Create threads that simply allocate and free different sizes.
   std::vector<std::thread *> Threads;
   for (size_t N = 0; N < 5; N++) {
     std::thread *T = new std::thread([&Stop] {
       while (!Stop) {
         for (size_t SizeLog = 3; SizeLog <= 20; SizeLog++) {
if ((Pid = fork()) == 0) {
       _exit(10);
     }
     EXPECT_NE(-1, Pid);
     int Status;
     EXPECT_EQ(Pid, waitpid(Pid, &Status, 0));
     EXPECT_FALSE(WIFSIGNALED(Status));
     EXPECT_EQ(10, WEXITSTATUS(Status));
   }
+  EXPECT_EQ(0, 1);
 
   printf("Waiting for threads to complete\n");
   Stop = true;
   for (auto Thread : Threads)
     Thread->join();
   Threads.clear();
 }
 #endif