[HWASAN] Add support for max_allocation_size_mb option

[kstoimenov]

Fixed pattern.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_allocator.cpp

175

Make sure that max_user_defined_malloc_size is <= kMaxAllowedMallocSize in Init and you don'y need to check them both here

180

Report should not use kMaxAllowedMallocSize if it failed on max_user_defined_malloc_size

[kstoimenov]

Changed to max_malloc_size.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_allocator.cpp

146

It's Init, we call it once, LIKELY/UNLIKEY no important here, I reccomend to remove them for redability
we need them in hot code only.

148–150

Use Min() instead of if

[kstoimenov]

Removed UNLIKELY and used Min.

compiler-rt/lib/hwasan/hwasan_allocator.cpp

enum {
   CHUNK_INVALID = 0,
   // The chunk is allocated and not yet freed.
   CHUNK_ALLOCATED = 1,
 };
 
 
 // Initialized in HwasanAllocatorInit, an never changed.
 static ALIGNED(16) u8 tail_magic[kShadowAlignment - 1];
+static uptr max_malloc_size;
 
 bool HwasanChunkView::IsAllocated() const {
   return metadata_ && metadata_->IsAllocated();
 }
 
 uptr HwasanChunkView::Beg() const {
   return block_;
 }

 void HwasanAllocatorInit() {
   atomic_store_relaxed(&hwasan_allocator_tagging_enabled,
                        !flags()->disable_allocator_tagging);
   SetAllocatorMayReturnNull(common_flags()->allocator_may_return_null);
   allocator.Init(common_flags()->allocator_release_to_os_interval_ms,
                  GetAliasRegionStart());
   for (uptr i = 0; i < sizeof(tail_magic); i++)
     tail_magic[i] = GetCurrentThread()->GenerateRandomTag();
+  if (common_flags()->max_allocation_size_mb) {
+    max_malloc_size = common_flags()->max_allocation_size_mb << 20;
+    max_malloc_size = Min(max_malloc_size, kMaxAllowedMallocSize);
+  } else {
+    max_malloc_size = kMaxAllowedMallocSize;
+  }
 }
 
 void HwasanAllocatorLock() { allocator.ForceLock(); }
 
 void HwasanAllocatorUnlock() { allocator.ForceUnlock(); }
 
 void AllocatorSwallowThreadLocalCache(AllocatorCache *cache) {
   allocator.SwallowCache(cache);
 }
 
 static uptr TaggedSize(uptr size) {
   if (!size) size = 1;
   uptr new_size = RoundUpTo(size, kShadowAlignment);
   CHECK_GE(new_size, size);
   return new_size;
 }
 
 static void *HwasanAllocate(StackTrace *stack, uptr orig_size, uptr alignment,
                             bool zeroise) {
   // Keep this consistent with LSAN and ASAN behavior.
   if (UNLIKELY(orig_size == 0))
     orig_size = 1;
-  if (UNLIKELY(orig_size > kMaxAllowedMallocSize)) {
+  if (UNLIKELY(orig_size > max_malloc_size)) {
     if (AllocatorMayReturnNull()) {
       Report("WARNING: HWAddressSanitizer failed to allocate 0x%zx bytes\n",
              orig_size);
       return nullptr;
     }
-    ReportAllocationSizeTooBig(orig_size, kMaxAllowedMallocSize, stack);
+    ReportAllocationSizeTooBig(orig_size, max_malloc_size, stack);
   }
   if (UNLIKELY(IsRssLimitExceeded())) {
     if (AllocatorMayReturnNull())
       return nullptr;
     ReportRssLimitExceeded(stack);
   }
 
   alignment = Max(alignment, kShadowAlignment);

compiler-rt/test/lsan/TestCases/realloc_too_big.c

 // RUN: %clang_lsan %s -o %t
 // RUN: %env_lsan_opts=allocator_may_return_null=1:max_allocation_size_mb=1:use_stacks=0 not %run %t 2>&1 | FileCheck %s
 
-// Fixme: remove once test passes with hwasan
-// UNSUPPORTED: hwasan
-
 /// Fails when only leak sanitizer is enabled
 // UNSUPPORTED: arm-linux, armhf-linux
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-// CHECK: {{Leak|Address}}Sanitizer failed to allocate 0x100001 bytes
+// CHECK: {{.*}}Sanitizer failed to allocate 0x100001 bytes
 
-// CHECK: {{Leak|Address}}Sanitizer: detected memory leaks
-// CHECK: {{Leak|Address}}Sanitizer: 9 byte(s) leaked in 1 allocation(s).
+// CHECK: {{.*}}Sanitizer: detected memory leaks
+// CHECK: {{.*}}Sanitizer: 9 byte(s) leaked in 1 allocation(s).
 
 int main() {
   char *p = malloc(9);
   fprintf(stderr, "nine: %p\n", p);
   assert(realloc(p, 0x100001) == NULL); // 1MiB+1
   p = 0;
 }