[hwasan] Increase max allocation size to 1Tb.

[eugenis]

Summary

2Gb is unreasonably low on devices with 12Gb RAM and more.

[eugenis]

This costs 4 bytes per allocation.
We could save some memory by splitting primary and secondary allocator metadata types, but that would require significant code refactoring.

[eugenis]

attribute((packed))

[eugenis]

.

[pcc]

Do we even need a limit at this level any more if the implementation supports up to 2^63 sizes? I guess any address-space imposed limit would be enforced by mmap failing when we go to make a large secondary allocation.

[eugenis]

replaced attribute((packed)) with split storage

[eugenis]

I think it's good to have a limit so that allocation attempts with obviously wrong sizes are rejected with a clear message.

[pcc]

LGTM

In D89750#2340467, @eugenis wrote:

I think it's good to have a limit so that allocation attempts with obviously wrong sizes are rejected with a clear message.

Okay, fair enough.

compiler-rt/lib/hwasan/hwasan_allocator.h

 #include "hwasan_poisoning.h"
 
 #if !defined(__aarch64__) && !defined(__x86_64__)
 #error Unsupported platform
 #endif
 
 namespace __hwasan {
 
-struct Metadata {
-  u32 requested_size : 31;  // sizes are < 2G.
-  u32 right_aligned  : 1;
+struct __attribute__((packed)) Metadata {
+  u64 requested_size : 63;
+  u64 right_aligned : 1;
   u32 alloc_context_id;
 };
 
 struct HwasanMapUnmapCallback {
   void OnMap(uptr p, uptr size) const { UpdateMemoryUsage(); }
   void OnUnmap(uptr p, uptr size) const {
     // We are about to unmap a chunk of user memory.
     // It can return as user-requested mmap() or another thread stack.
     // Make it accessible with zero-tagged pointer.
     TagMemory(p, size, 0);
   }
 };
 
-static const uptr kMaxAllowedMallocSize = 2UL << 30;  // 2G
+static const uptr kMaxAllowedMallocSize = 1UL << 40;  // 1T
 
 struct AP64 {
   static const uptr kSpaceBeg = ~0ULL;
   static const uptr kSpaceSize = 0x2000000000ULL;
   static const uptr kMetadataSize = sizeof(Metadata);
   typedef __sanitizer::VeryDenseSizeClassMap SizeClassMap;
   using AddressSpaceView = LocalAddressSpaceView;
   typedef HwasanMapUnmapCallback MapUnmapCallback;

compiler-rt/lib/hwasan/hwasan_allocator.cpp

 
 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);
   for (uptr i = 0; i < sizeof(tail_magic); i++)
     tail_magic[i] = GetCurrentThread()->GenerateRandomTag();
+  Printf("sssss %zu\n", sizeof(Metadata));
 }
 
 void AllocatorSwallowThreadLocalCache(AllocatorCache *cache) {
   allocator.SwallowCache(cache);
 }
 
 static uptr TaggedSize(uptr size) {
   if (!size) size = 1;

compiler-rt/test/hwasan/TestCases/allocator_returns_null.cpp

 
 #include "utils.h"
 
 int main(int argc, char **argv) {
   assert(argc == 2);
   const char *action = argv[1];
   untag_fprintf(stderr, "%s:\n", action);
 
-  static const size_t kMaxAllowedMallocSizePlusOne = (2UL << 30) + 1;
+  static const size_t kMaxAllowedMallocSizePlusOne = (1UL << 40) + 1;
 
   void *x = nullptr;
   if (!untag_strcmp(action, "malloc")) {
     x = malloc(kMaxAllowedMallocSizePlusOne);
   } else if (!untag_strcmp(action, "calloc")) {
     x = calloc((kMaxAllowedMallocSizePlusOne / 4) + 1, 4);
   } else if (!untag_strcmp(action, "calloc-overflow")) {
     volatile size_t kMaxSizeT = std::numeric_limits<size_t>::max();

compiler-rt/test/hwasan/TestCases/sizes.cpp

 int main(int argc, char **argv) {
   assert(argc <= 3);
   bool test_size_max = argc == 3 && !untag_strcmp(argv[2], "max");
 
   static const size_t kMaxAllowedMallocSize = 1ULL << 40;
   static const size_t kChunkHeaderSize = 16;
 
   size_t MallocSize = test_size_max ? std::numeric_limits<size_t>::max()
-                                    : kMaxAllowedMallocSize;
+                                    : (kMaxAllowedMallocSize + 1);
 
   if (!untag_strcmp(argv[1], "malloc")) {
     void *p = malloc(MallocSize);
     assert(!p);
     p = malloc(kMaxAllowedMallocSize - kChunkHeaderSize);
     assert(!p);
   } else if (!untag_strcmp(argv[1], "calloc")) {
     // Trigger an overflow in calloc.