Introduce `sanitizer_malloc_introspect_t` for Darwin which is a sub-class of Darwin's `malloc_introspection_t` and use it when setting up the malloc zone.

[delcypher]

Summary

Currently sanitizer_malloc_introspection_t just adds a version field
which is used to version the allocator ABI. The current allocator ABI
version is returned by the new GetMallocZoneAllocatorEnumerationVersion() function.

The motivation behind this change is to allow external processes to
determine the allocator ABI of a sanitized process.

rdar://problem/45284065

[kubamracek]

Looks good. I assume the struct definition cannot be moved into the .inc file because we're going to need to access it from other places?

[delcypher]

@kubamracek

In D54045#1287762, @kubamracek wrote:

Looks good. I assume the struct definition cannot be moved into the .inc file because we're going to need to access it from other places?

You raise a good point. Right now (in my fork of compiler-rt) the header file exists because in my fork ASan actually subclasses sanitizer_malloc_introspection_t so that it can add its own fields. Due to the way this is implemented it means`sanitizer_malloc_introspection_t` needs to be in its own header file. However, ASan's sub class of sanitizer_malloc_introspection_t actually only contains two non-ASan specific fields (pointer to allocator and the size of the allocator). This means we could move those fields into sanitizer_malloc_introspection_t and remove the ASan specific sub class of sanitizer_malloc_introspection_t. If we do this we can move sanitizer_malloc_introspection_t into sanitizer_common/sanitizer_malloc_mac.inc. However we still need each sanitizer to initialise these fields because they could be different for each sanitizer. Right now initialising these fields is only important for ASan so for other sanitizers we could just leave these set to zero until we actually need to do something different.

What do you think?

[kubamracek]

Okay, let's initially remove the header file and just move the struct into the .inc file. We can always move it to a separate header later if needed.

[delcypher]

Move sanitizer_malloc_introspect_t out of a header file into the only source
file where it is actually used.

[delcypher]

@kubamracek

In D54045#1287866, @kubamracek wrote:

Okay, let's initially remove the header file and just move the struct into the .inc file. We can always move it to a separate header later if needed.

Done. Good to go now?

compiler-rt/trunk/lib/sanitizer_common/sanitizer_malloc_mac.inc

 
 #include "interception/interception.h"
 #include "sanitizer_common/sanitizer_mac.h"
 
 // Similar code is used in Google Perftools,
 // https://github.com/gperftools/gperftools.
 
 namespace __sanitizer {
+
 extern malloc_zone_t sanitizer_zone;
+
+struct sanitizer_malloc_introspection_t : public malloc_introspection_t {
+  // IMPORTANT: Do not change the order, alignment, or types of these fields to
+  // maintain binary compatibility. You should only add fields to this struct.
+
+  // Used to track changes to the allocator that will affect
+  // zone enumeration.
+  u64 allocator_enumeration_version;
+};
+
+u64 GetMallocZoneAllocatorEnumerationVersion() {
+  // This represents the current allocator ABI version.
+  // This field should be incremented every time the Allocator
+  // ABI changes in a way that breaks allocator enumeration.
+  return 0;
 }
 
+}  // namespace __sanitizer
+
 INTERCEPTOR(malloc_zone_t *, malloc_create_zone,
                              vm_size_t start_size, unsigned zone_flags) {
   COMMON_MALLOC_ENTER();
   uptr page_size = GetPageSizeCached();
   uptr allocated_size = RoundUpTo(sizeof(sanitizer_zone), page_size);
   COMMON_MALLOC_MEMALIGN(page_size, allocated_size);
   malloc_zone_t *new_zone = (malloc_zone_t *)p;
   internal_memcpy(new_zone, &sanitizer_zone, sizeof(sanitizer_zone));
boolean_t mi_zone_locked(malloc_zone_t *zone) {
   return false;
 }
 
 }  // unnamed namespace
 
 namespace COMMON_MALLOC_NAMESPACE {
 
 void InitMallocZoneFields() {
-  static malloc_introspection_t sanitizer_zone_introspection;
+  static sanitizer_malloc_introspection_t sanitizer_zone_introspection;
   // Ok to use internal_memset, these places are not performance-critical.
   internal_memset(&sanitizer_zone_introspection, 0,
                   sizeof(sanitizer_zone_introspection));
 
   sanitizer_zone_introspection.enumerator = &mi_enumerator;
   sanitizer_zone_introspection.good_size = &mi_good_size;
   sanitizer_zone_introspection.check = &mi_check;
   sanitizer_zone_introspection.print = &mi_print;
   sanitizer_zone_introspection.log = &mi_log;
   sanitizer_zone_introspection.force_lock = &mi_force_lock;
   sanitizer_zone_introspection.force_unlock = &mi_force_unlock;
   sanitizer_zone_introspection.statistics = &mi_statistics;
   sanitizer_zone_introspection.zone_locked = &mi_zone_locked;
 
+  // Set current allocator enumeration version.
+  sanitizer_zone_introspection.allocator_enumeration_version =
+      GetMallocZoneAllocatorEnumerationVersion();
+
   internal_memset(&sanitizer_zone, 0, sizeof(malloc_zone_t));
 
   // Use version 6 for OSX >= 10.6.
   sanitizer_zone.version = 6;
   sanitizer_zone.zone_name = COMMON_MALLOC_ZONE_NAME;
   sanitizer_zone.size = &__sanitizer_mz_size;
   sanitizer_zone.malloc = &__sanitizer_mz_malloc;
   sanitizer_zone.calloc = &__sanitizer_mz_calloc;