[scudo] Fix bad request handling when allocator has not been initialized

Summary:
In a few functions (`scudoMemalign` and the like), we would call
`ScudoAllocator::FailureHandler::OnBadRequest` if the parameters didn't check
out. The issue is that if the allocator had not been initialized (eg: if this
is the first heap related function called), we would use variables like
`allocator_may_return_null` and `exitcode` that still had their default value
(as opposed to the one set by the user or the initialization path).

To solve this, we introduce `handleBadRequest` that will call `initThreadMaybe`,
allowing the options to be correctly initialized.

Unfortunately, the tests were passing because `exitcode` was still 0, so the
results looked like success. Change those tests to do what they were supposed
to.

Reviewers: alekseyshl

Reviewed By: alekseyshl

Subscribers: llvm-commits

Differential Revision: https://reviews.llvm.org/D37853

llvm-svn: 313294

compiler-rt/lib/scudo/scudo_allocator.cpp

@@ -620,6 +620,11 @@ struct ScudoAllocator {
     BackendAllocator.getStats(stats);
     return stats[StatType];
   }
+
+  void *handleBadRequest() {
+    initThreadMaybe();
+    return FailureHandler::OnBadRequest();
+  }
 };
 
 static ScudoAllocator Instance(LINKER_INITIALIZED);
@@ -677,7 +682,7 @@ void *scudoPvalloc(uptr Size) {
   uptr PageSize = GetPageSizeCached();
   if (UNLIKELY(CheckForPvallocOverflow(Size, PageSize))) {
     errno = errno_ENOMEM;
-    return ScudoAllocator::FailureHandler::OnBadRequest();
+    return Instance.handleBadRequest();
   }
   // pvalloc(0) should allocate one page.
   Size = Size ? RoundUpTo(Size, PageSize) : PageSize;
@@ -687,14 +692,14 @@ void *scudoPvalloc(uptr Size) {
 void *scudoMemalign(uptr Alignment, uptr Size) {
   if (UNLIKELY(!IsPowerOfTwo(Alignment))) {
     errno = errno_EINVAL;
-    return ScudoAllocator::FailureHandler::OnBadRequest();
+    return Instance.handleBadRequest();
   }
   return SetErrnoOnNull(Instance.allocate(Size, Alignment, FromMemalign));
 }
 
 int scudoPosixMemalign(void **MemPtr, uptr Alignment, uptr Size) {
   if (UNLIKELY(!CheckPosixMemalignAlignment(Alignment))) {
-    ScudoAllocator::FailureHandler::OnBadRequest();
+    Instance.handleBadRequest();
     return errno_EINVAL;
   }
   void *Ptr = Instance.allocate(Size, Alignment, FromMemalign);
@@ -707,7 +712,7 @@ int scudoPosixMemalign(void **MemPtr, uptr Alignment, uptr Size) {
 void *scudoAlignedAlloc(uptr Alignment, uptr Size) {
   if (UNLIKELY(!CheckAlignedAllocAlignmentAndSize(Alignment, Size))) {
     errno = errno_EINVAL;
-    return ScudoAllocator::FailureHandler::OnBadRequest();
+    return Instance.handleBadRequest();
   }
   return SetErrnoOnNull(Instance.allocate(Size, Alignment, FromMalloc));
 }

compiler-rt/test/scudo/memalign.cpp

@@ -1,6 +1,7 @@
 // RUN: %clang_scudo %s -o %t
-// RUN: %run %t valid   2>&1
-// RUN: %run %t invalid 2>&1
+// RUN:                                               %run %t valid   2>&1
+// RUN:                                           not %run %t invalid 2>&1
+// RUN: SCUDO_OPTIONS=allocator_may_return_null=1     %run %t invalid 2>&1
 
 // Tests that the various aligned allocation functions work as intended. Also
 // tests for the condition where the alignment is not a power of 2.

compiler-rt/test/scudo/valloc.cpp

@@ -1,6 +1,7 @@
 // RUN: %clang_scudo %s -o %t
-// RUN: %run %t valid   2>&1
-// RUN: %run %t invalid 2>&1
+// RUN:                                               %run %t valid   2>&1
+// RUN:                                           not %run %t invalid 2>&1
+// RUN: SCUDO_OPTIONS=allocator_may_return_null=1     %run %t invalid 2>&1
 
 // Tests that valloc and pvalloc work as intended.