[TSan] Add interceptors for mach_vm_[de]allocate

[yln]

Summary

I verified that the test is red without the interceptors.

rdar://40334350

[yln]

Fix warning in test.

[kubamracek]

compiler-rt/lib/tsan/rtl/tsan_interceptors.cpp

748–749

is this related? or just a co-incidental change?

compiler-rt/lib/tsan/rtl/tsan_interceptors_mach_vm.cpp

42–45

This is copied from mmap, right? Can it be extracted into a common function instead?

58–62

ditto here

[yln]

compiler-rt/lib/tsan/rtl/tsan_interceptors.cpp

748–749

Related. It took me a while to understand what it is doing, so I left a comment.

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

1) addr=0, flags=... -> kernel picks address, best most portable option
2) addr=0x123, flags=... -> kernel picks address, 'addr' is treated as a hint, no guarantees
3) addr=0x123, flag=MAP_FIXED -> mmap fails if allocation cannot be placed at 'addr'

This function ensures that we never call the real mmap with an addr that points into the shadow. For 2) it discards the hint, for 3) we return with failure without forwarding to the real mmap.

vm_mach_allocate only has cases 1) and 3). I named the function intersects_with_shadow

compiler-rt/lib/tsan/rtl/tsan_interceptors_mach_vm.cpp

42–45

I tried extracting a function and then parameterizing it for most of the interceptor, but that turned messy really quickly. I can certainly do it for the above 4 lines.

[yln]

Extract UnmapShadow and MemoryRangeImitateWriteOrResetRange
helper functions to reduce code duplication.

[kubamracek]

Looks good to me. @dvyukov ?

[yln]

@dvyukov, do you want to weigh in here?

[yln]

*ping*
Any comments before I ask Kuba to waive this through?

[vitalybuka]

compiler-rt/lib/tsan/rtl/tsan_interceptors_mach_vm.cpp

35

maybe drop {} on one-liners for consistency

[yln]

Drop {} on one-liners for consistency.

compiler-rt/lib/tsan/CMakeLists.txt

 
 set(TSAN_CXX_SOURCES
   rtl/tsan_new_delete.cpp
   )
 
 if(APPLE)
   list(APPEND TSAN_SOURCES
     rtl/tsan_interceptors_mac.cpp
+    rtl/tsan_interceptors_mach_vm.cpp
     rtl/tsan_platform_mac.cpp
     rtl/tsan_platform_posix.cpp
     )
 elseif(UNIX)
   # Assume Linux
   list(APPEND TSAN_SOURCES
     rtl/tsan_platform_linux.cpp
     rtl/tsan_platform_posix.cpp

compiler-rt/lib/tsan/rtl/tsan_interceptors.cpp

 }
 
 TSAN_INTERCEPTOR(char*, strdup, const char *str) {
   SCOPED_TSAN_INTERCEPTOR(strdup, str);
   // strdup will call malloc, so no instrumentation is required here.
   return REAL(strdup)(str);
 }
 
+// Zero out addr if it points into shadow memory and was provided as a hint
+// only, i.e., MAP_FIXED is not set.
 static bool fix_mmap_addr(void **addr, long_t sz, int flags) {
   if (*addr) {
     if (!IsAppMem((uptr)*addr) || !IsAppMem((uptr)*addr + sz - 1)) {
       if (flags & MAP_FIXED) {
         errno = errno_EINVAL;
         return false;
       } else {
         *addr = 0;

compiler-rt/lib/tsan/rtl/tsan_interceptors_mach_vm.cpp

+//===-- tsan_interceptors_mach_vm.cpp -------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Interceptors for mach_vm_* user space memory routines on Darwin.
+//===----------------------------------------------------------------------===//
+
+#include "interception/interception.h"
+#include "tsan_interceptors.h"
+#include "tsan_platform.h"
+
+#include <mach/mach.h>
+
+namespace __tsan {
+
+static bool intersects_with_shadow(mach_vm_address_t *address,
+                                   mach_vm_size_t size, int flags) {
+  // VM_FLAGS_FIXED is 0x0, so we have to test for VM_FLAGS_ANYWHERE.
+  if (flags & VM_FLAGS_ANYWHERE) return false;
+  uptr ptr = *address;
+  return !IsAppMem(ptr) || !IsAppMem(ptr + size - 1);
+}
+
+// Also see mmap_interceptor in tsan_interceptors.cpp.
+TSAN_INTERCEPTOR(kern_return_t, mach_vm_allocate, vm_map_t target,
+                 mach_vm_address_t *address, mach_vm_size_t size, int flags) {
+  SCOPED_TSAN_INTERCEPTOR(mach_vm_allocate, target, address, size, flags);
+  if (target != mach_task_self()) {
+    return REAL(mach_vm_allocate)(target, address, size, flags);
+  }
+  if (intersects_with_shadow(address, size, flags)) {
+    return KERN_NO_SPACE;
+  }
+  kern_return_t res = REAL(mach_vm_allocate)(target, address, size, flags);
+  if (res == KERN_SUCCESS) {
+    if (thr->ignore_reads_and_writes == 0)
+      MemoryRangeImitateWrite(thr, pc, *address, size);
+    else
+      MemoryResetRange(thr, pc, *address, size);
+  }
+  return res;
+}
+
+// Also see TSAN_INTERCEPTOR(int, munmap, ...) in tsan_interceptors.cpp.
+TSAN_INTERCEPTOR(kern_return_t, mach_vm_deallocate, vm_map_t target,
+                 mach_vm_address_t address, mach_vm_size_t size) {
+  SCOPED_TSAN_INTERCEPTOR(mach_vm_deallocate, target, address, size);
+  if (target != mach_task_self()) {
+    return REAL(mach_vm_deallocate)(target, address, size);
+  }
+  if (size != 0) {
+    // If size == 0, mach_vm_deallocate will return KERN_SUCCESS and does not
+    // deallocate any memory.
+    DontNeedShadowFor(address, size);
+    ScopedGlobalProcessor sgp;
+    ctx->metamap.ResetRange(thr->proc(), address, size);
+  }
+  return REAL(mach_vm_deallocate)(target, address, size);
+}
+
+}  // namespace __tsan

compiler-rt/test/tsan/Darwin/mach_vm_allocate.c

+// Test that mach_vm_[de]allocate resets shadow memory status.
+//
+// RUN: %clang_tsan %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
+
+#include <mach/mach.h>
+#include <mach/mach_vm.h>
+#include <pthread.h>
+#include <assert.h>
+#include <stdio.h>
+
+#include "../test.h"
+
+void AnnotateIgnoreReadsBegin(const char *f, int l);
+void AnnotateIgnoreReadsEnd(const char *f, int l);
+void AnnotateIgnoreWritesBegin(const char *f, int l);
+void AnnotateIgnoreWritesEnd(const char *f, int l);
+
+static int *global_ptr;
+const mach_vm_size_t alloc_size = sizeof(int);
+
+static int *alloc() {
+  mach_vm_address_t addr;
+  kern_return_t res =
+      mach_vm_allocate(mach_task_self(), &addr, alloc_size, VM_FLAGS_ANYWHERE);
+  assert(res == KERN_SUCCESS);
+  return (int *)addr;
+}
+
+static void alloc_fixed(int *ptr) {
+  mach_vm_address_t addr = (mach_vm_address_t)ptr;
+  kern_return_t res =
+      mach_vm_allocate(mach_task_self(), &addr, alloc_size, VM_FLAGS_FIXED);
+  assert(res == KERN_SUCCESS);
+}
+
+static void dealloc(int *ptr) {
+  kern_return_t res =
+      mach_vm_deallocate(mach_task_self(), (mach_vm_address_t)ptr, alloc_size);
+  assert(res == KERN_SUCCESS);
+}
+
+static void *Thread(void *arg) {
+  *global_ptr = 7;  // Assignment 1
+
+  // We want to test that TSan does not report a race between the two
+  // assignments to global_ptr when memory is re-allocated here. The calls to
+  // the API itself are racy though, so ignore them.
+  AnnotateIgnoreWritesBegin(__FILE__, __LINE__);
+  dealloc(global_ptr);
+  alloc_fixed(global_ptr);
+  AnnotateIgnoreWritesEnd(__FILE__, __LINE__);
+
+  barrier_wait(&barrier);
+  return NULL;;
+}
+
+int main(int argc, const char *argv[]) {
+  barrier_init(&barrier, 2);
+  global_ptr = alloc();
+  pthread_t t;
+  pthread_create(&t, NULL, Thread, NULL);
+
+  barrier_wait(&barrier);
+  *global_ptr = 8;  // Assignment 2
+
+  pthread_join(t, NULL);
+  dealloc(global_ptr);
+  printf("Done.\n");
+  return 0;
+}
+
+// CHECK: Done.