[hwasan] Fix allocator alignment.

[eugenis]

Summary

Fix hwasan allocator not respecting the requested alignment when it is
higher than a page, but still within primary (i.e. [2048, 65536]).

[cryptoad]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_primary64.h

78–82

Since we had the discussion, I understand the need to be aligned, but maybe a comment to clarify why for later readers?

compiler-rt/lib/sanitizer_common/sanitizer_common.cpp

328

Maybe a safe guard check that align is a power of 2?
With SizeClassMap::kMaxSize it's the case, but if it's used somewhere else, it might slip through.

[eugenis]

address comments

[eugenis]

One more CHECK + fix a broken test.

compiler-rt/lib/sanitizer_common/sanitizer_allocator_primary64.h

public:
   }
 
   void Init(s32 release_to_os_interval_ms) {
     uptr TotalSpaceSize = kSpaceSize + AdditionalSize();
     if (kUsingConstantSpaceBeg) {
       CHECK_EQ(kSpaceBeg, address_range.Init(TotalSpaceSize,
                                              PrimaryAllocatorName, kSpaceBeg));
     } else {
-      NonConstSpaceBeg = address_range.Init(TotalSpaceSize,
-                                            PrimaryAllocatorName);
+      // Combined allocator expects that an 2^N allocation is always aligned to
+      // 2^N. For this to work, the start of the space needs to be aligned as
+      // high as the largest size class (which also needs to be a power of 2).
+      NonConstSpaceBeg = address_range.InitAligned(
+          TotalSpaceSize, SizeClassMap::kMaxSize, PrimaryAllocatorName);
       CHECK_NE(NonConstSpaceBeg, ~(uptr)0);
     }
     SetReleaseToOSIntervalMs(release_to_os_interval_ms);
     MapWithCallbackOrDie(SpaceEnd(), AdditionalSize(),
                          "SizeClassAllocator: region info");
     // Check that the RegionInfo array is aligned on the CacheLine size.
     DCHECK_EQ(SpaceEnd() % kCacheLineSize, 0);
   }

compiler-rt/lib/sanitizer_common/sanitizer_common.h

 // Check if the built VMA size matches the runtime one.
 void CheckVMASize();
 void RunMallocHooks(const void *ptr, uptr size);
 void RunFreeHooks(const void *ptr);
 
 class ReservedAddressRange {
  public:
   uptr Init(uptr size, const char *name = nullptr, uptr fixed_addr = 0);
+  uptr InitAligned(uptr size, uptr align, const char *name = nullptr);
   uptr Map(uptr fixed_addr, uptr size, const char *name = nullptr);
   uptr MapOrDie(uptr fixed_addr, uptr size, const char *name = nullptr);
   void Unmap(uptr addr, uptr size);
   void *base() const { return base_; }
   uptr size() const { return size_; }
 
  private:
   void* base_;

compiler-rt/lib/sanitizer_common/sanitizer_common.cpp

if (MFHooks[i].malloc_hook == nullptr) {
       MFHooks[i].malloc_hook = malloc_hook;
       MFHooks[i].free_hook = free_hook;
       return i + 1;
     }
   }
   return 0;
 }
 
+uptr ReservedAddressRange::InitAligned(uptr size, uptr align,
+                                       const char *name) {
+  CHECK(IsPowerOfTwo(align));
+  if (align <= GetPageSizeCached())
+    return Init(size, name);
+  uptr start = Init(size + align, name);
+  start += align - (start & (align - 1));
+  return start;
+}
+
 } // namespace __sanitizer
 
 using namespace __sanitizer;
 
 extern "C" {
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_report_error_summary,
                              const char *error_summary) {
   Printf("%s\n", error_summary);

compiler-rt/test/hwasan/TestCases/malloc-align.c

+// Test malloc alignment.
+// RUN: %clang_hwasan -mllvm -hwasan-globals=0 %s -o %t
+// RUN: %run %t
+
+#include <assert.h>
+#include <sanitizer/allocator_interface.h>
+#include <sanitizer/hwasan_interface.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static const size_t sizes[] = {
+    1, 3, 7, 8, 9, 16, 17, 31, 32, 33,
+    63, 64, 65, 127, 128, 129, 511, 512, 513, 2047,
+    2048, 2049, 65535, 65536, 65537, 1048575, 1048576, 1048577};
+static const size_t alignments[] = {8, 16, 64, 256, 1024, 4096, 65536, 131072};
+
+__attribute__((no_sanitize("hwaddress"))) int main() {
+  for (unsigned i = 0; i < sizeof(sizes) / sizeof(*sizes); ++i) {
+    for (unsigned j = 0; j < sizeof(alignments) / sizeof(*alignments); ++j) {
+      size_t size = sizes[i];
+      size_t alignment = alignments[j];
+      fprintf(stderr, "size %zu, alignment %zu (0x%zx)\n", size, alignment,
+              alignment);
+      const int cnt = 10;
+      void *ptrs[cnt];
+      for (int k = 0; k < cnt; ++k) {
+        int res = posix_memalign(&ptrs[k], alignment, size);
+        assert(res == 0);
+        fprintf(stderr, "... addr 0x%zx\n", (size_t)ptrs[k]);
+        assert(((size_t)ptrs[k] & (alignment - 1)) == 0);
+      }
+      for (int k = 0; k < cnt; ++k)
+        free(ptrs[k]);
+    }
+  }
+  return 0;
+}