[Sanitizers] Add more standard compliant posix_memalign implementation for LSan.

[alekseyshl]

Summary

Add more standard compliant posix_memalign implementation for LSan and
use corresponding sanitizer's posix_memalign implenetations in allocation
wrappers on Mac.

lib/asan/asan_malloc_mac.cc

#define COMMON_MALLOC_MALLOC(size) \
   GET_STACK_TRACE_MALLOC; \
   void *p = asan_malloc(size, &stack)
 #define COMMON_MALLOC_REALLOC(ptr, size) \
   GET_STACK_TRACE_MALLOC; \
   void *p = asan_realloc(ptr, size, &stack);
 #define COMMON_MALLOC_CALLOC(count, size) \
   GET_STACK_TRACE_MALLOC; \
   void *p = asan_calloc(count, size, &stack);
+#define COMMON_MALLOC_POSIX_MEMALIGN(memptr, alignment, size) \
+  GET_STACK_TRACE_MALLOC; \
+  int res = asan_posix_memalign(memptr, alignment, size, &stack);
 #define COMMON_MALLOC_VALLOC(size) \
   GET_STACK_TRACE_MALLOC; \
   void *p = asan_memalign(GetPageSizeCached(), size, &stack, FROM_MALLOC);
 #define COMMON_MALLOC_FREE(ptr) \
   GET_STACK_TRACE_FREE; \
   asan_free(ptr, &stack, FROM_MALLOC);
 #define COMMON_MALLOC_SIZE(ptr) \
   uptr size = asan_mz_size(ptr);

lib/lsan/lsan_allocator.h

 };
 
 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 #endif
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 
 AllocatorCache *GetAllocatorCache();
 
+int lsan_posix_memalign(void **memptr, uptr alignment, uptr size,
+                        const StackTrace &stack);
 void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack);
 void *lsan_malloc(uptr size, const StackTrace &stack);
 void lsan_free(void *p);
 void *lsan_realloc(void *p, uptr size, const StackTrace &stack);
 void *lsan_calloc(uptr nmemb, uptr size, const StackTrace &stack);
 void *lsan_valloc(uptr size, const StackTrace &stack);
 uptr lsan_mz_size(const void *p);
 
 }  // namespace __lsan
 
 #endif  // LSAN_ALLOCATOR_H

lib/lsan/lsan_allocator.cc

 }
 
 uptr GetMallocUsableSize(const void *p) {
   ChunkMetadata *m = Metadata(p);
   if (!m) return 0;
   return m->requested_size;
 }
 
+int lsan_posix_memalign(void **memptr, uptr alignment, uptr size,
+                        const StackTrace &stack) {
+  if (UNLIKELY(!CheckPosixMemalignAlignment(alignment))) {
+    ReturnNullOrDieOnFailure::OnBadRequest();
+    return errno_EINVAL;
+  }
+  void *ptr = Allocate(stack, size, alignment, kAlwaysClearMemory);
+  if (UNLIKELY(!ptr))
+    // OOM error is already taken care of by Allocate.
+    return errno_ENOMEM;
+  CHECK(IsAligned((uptr)ptr, alignment));
+  *memptr = ptr;
+  return 0;
+}
+
 void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack) {
   if (UNLIKELY(!IsPowerOfTwo(alignment))) {
     errno = errno_EINVAL;
     return ReturnNullOrDieOnFailure::OnBadRequest();
   }
   return SetErrnoOnNull(Allocate(stack, size, alignment, kAlwaysClearMemory));
 }
 

lib/lsan/lsan_interceptors.cc

INTERCEPTOR(void*, realloc, void *q, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return lsan_realloc(q, size, stack);
 }
 
 INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
-  *memptr = lsan_memalign(alignment, size, stack);
-  // FIXME: Return ENOMEM if user requested more than max alloc size.
-  return 0;
+  return lsan_posix_memalign(memptr, alignment, size, stack);
 }
 
 INTERCEPTOR(void*, valloc, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return lsan_valloc(size, stack);
 }
 #endif

lib/lsan/lsan_malloc_mac.cc

#define COMMON_MALLOC_MALLOC(size) \
   GET_STACK_TRACE_MALLOC; \
   void *p = lsan_malloc(size, stack)
 #define COMMON_MALLOC_REALLOC(ptr, size) \
   GET_STACK_TRACE_MALLOC; \
   void *p = lsan_realloc(ptr, size, stack)
 #define COMMON_MALLOC_CALLOC(count, size) \
   GET_STACK_TRACE_MALLOC; \
   void *p = lsan_calloc(count, size, stack)
+#define COMMON_MALLOC_POSIX_MEMALIGN(memptr, alignment, size) \
+  GET_STACK_TRACE_MALLOC; \
+  int res = lsan_posix_memalign(memptr, alignment, size, stack)
 #define COMMON_MALLOC_VALLOC(size) \
   GET_STACK_TRACE_MALLOC; \
   void *p = lsan_valloc(size, stack)
 #define COMMON_MALLOC_FREE(ptr) \
   lsan_free(ptr)
 #define COMMON_MALLOC_SIZE(ptr) \
   uptr size = lsan_mz_size(ptr)
 #define COMMON_MALLOC_FILL_STATS(zone, stats)
 #define COMMON_MALLOC_REPORT_UNKNOWN_REALLOC(ptr, zone_ptr, zone_name) \
   (void)zone_name; \
   Report("mz_realloc(%p) -- attempting to realloc unallocated memory.\n", ptr);
 #define COMMON_MALLOC_NAMESPACE __lsan
 
 #include "sanitizer_common/sanitizer_malloc_mac.inc"
 
 #endif // SANITIZER_MAC

lib/sanitizer_common/sanitizer_malloc_mac.inc

 INTERCEPTOR(size_t, malloc_good_size, size_t size) {
   COMMON_MALLOC_ENTER();
   return sanitizer_zone.introspect->good_size(&sanitizer_zone, size);
 }
 
 INTERCEPTOR(int, posix_memalign, void **memptr, size_t alignment, size_t size) {
   COMMON_MALLOC_ENTER();
   CHECK(memptr);
-  COMMON_MALLOC_MEMALIGN(alignment, size);
-  if (p) {
-    *memptr = p;
-    return 0;
-  }
-  return -1;
+  COMMON_MALLOC_POSIX_MEMALIGN(memptr, alignment, size);
+  return res;
 }
 
 namespace {
 
 // TODO(glider): the __sanitizer_mz_* functions should be united with the Linux
 // wrappers, as they are basically copied from there.
 extern "C"
 SANITIZER_INTERFACE_ATTRIBUTE

lib/tsan/rtl/tsan_malloc_mac.cc

 // This file is a part of ThreadSanitizer (TSan), a race detector.
 //
 // Mac-specific malloc interception.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
 #if SANITIZER_MAC
 
+#include "sanitizer_common/sanitizer_errno.h"
 #include "tsan_interceptors.h"
 #include "tsan_stack_trace.h"
 
 using namespace __tsan;
 #define COMMON_MALLOC_ZONE_NAME "tsan"
 #define COMMON_MALLOC_ENTER()
 #define COMMON_MALLOC_SANITIZER_INITIALIZED (cur_thread()->is_inited)
 #define COMMON_MALLOC_FORCE_LOCK()
 #define COMMON_MALLOC_FORCE_UNLOCK()
 #define COMMON_MALLOC_MEMALIGN(alignment, size) \
   void *p =                                     \
       user_memalign(cur_thread(), StackTrace::GetCurrentPc(), alignment, size)
 #define COMMON_MALLOC_MALLOC(size)                             \
   if (cur_thread()->in_symbolizer) return InternalAlloc(size); \
   SCOPED_INTERCEPTOR_RAW(malloc, size);                        \
   void *p = user_alloc(thr, pc, size)
 #define COMMON_MALLOC_REALLOC(ptr, size)                              \
   if (cur_thread()->in_symbolizer) return InternalRealloc(ptr, size); \
   SCOPED_INTERCEPTOR_RAW(realloc, ptr, size);                         \
   void *p = user_realloc(thr, pc, ptr, size)
 #define COMMON_MALLOC_CALLOC(count, size)                              \
   if (cur_thread()->in_symbolizer) return InternalCalloc(count, size); \
   SCOPED_INTERCEPTOR_RAW(calloc, size, count);                         \
   void *p = user_calloc(thr, pc, size, count)
+#define COMMON_MALLOC_POSIX_MEMALIGN(memptr, alignment, size)      \
+  if (cur_thread()->in_symbolizer) {                               \
+    void *p = InternalAlloc(size, nullptr, alignment);             \
+    if (!p) return errno_ENOMEM;                                   \
+    *memptr = p;                                                   \
+    return 0;                                                      \
+  }                                                                \
+  SCOPED_INTERCEPTOR_RAW(posix_memalign, memptr, alignment, size); \
+  int res = user_posix_memalign(thr, pc, memptr, alignment, size);
 #define COMMON_MALLOC_VALLOC(size)                            \
   if (cur_thread()->in_symbolizer)                            \
     return InternalAlloc(size, nullptr, GetPageSizeCached()); \
   SCOPED_INTERCEPTOR_RAW(valloc, size);                       \
   void *p = user_valloc(thr, pc, size)
 #define COMMON_MALLOC_FREE(ptr)                              \
   if (cur_thread()->in_symbolizer) return InternalFree(ptr); \
   SCOPED_INTERCEPTOR_RAW(free, ptr);                         \