[hwasan] Implement error report callback.

[eugenis]

Summary

Similar to __asan_set_error_report_callback, pass the entire report to a
user provided callback function.

[eugenis]

You can notice that this change is moving SetAbortMessage call out from under error_message_lock_.
I'm not sure why exactly I'm doing this, other than the fact that ASan does it this way.
This will allow Printf() from within the callback, which is quite unlikely to happen, but I guess possible in verbose mode or something like that.
All of this is still under the wider error_report_lock_, so a hwasan error in the callback will result in the "nested bug" message and an immediate exit.

[eugenis]

remove unnecessary copy

[eugenis]

It's actually not necessary to copy the error message as long as error_message_ptr_ is reset under the lock.

[hctim]

In D91825#2406724, @eugenis wrote:

You can notice that this change is moving SetAbortMessage call out from under error_message_lock_
I'm not sure why exactly I'm doing this, other than the fact that ASan does it this way.
All of this is still under the wider error_report_lock_, so a hwasan error in the callback will result in the "nested bug" message and an immediate exit.

Isn't that why ASan is doing it? HWASan error in the cb if it's still locked would result in deadlock.

Possible to add a test just to double check this? Seems like a plausible scenario to tag-mismatch in the callback.

[hctim]

In D91825#2406767, @hctim wrote:

Isn't that why ASan is doing it? HWASan error in the cb if it's still locked would result in deadlock.

Possible to add a test just to double check this? Seems like a plausible scenario to tag-mismatch in the callback.

Scratch that, just saw the global ScopedErrorReportLock

[pcc]

LGTM

compiler-rt/include/sanitizer/hwasan_interface.h

#endif
 
   // Print one-line report about the memory usage of the current process.
   void __hwasan_print_memory_usage();
 
   /* Returns the offset of the first byte in the memory range that can not be
    * accessed through the pointer in x, or -1 if the whole range is good. */
   intptr_t __hwasan_test_shadow(const volatile void *x, size_t size);
 
+  /* Sets the callback function to be called during HWASan error reporting. */
+  void __hwasan_set_error_report_callback(void (*callback)(const char *));
+
   int __sanitizer_posix_memalign(void **memptr, size_t alignment, size_t size);
   void * __sanitizer_memalign(size_t alignment, size_t size);
   void * __sanitizer_aligned_alloc(size_t alignment, size_t size);
   void * __sanitizer___libc_memalign(size_t alignment, size_t size);
   void * __sanitizer_valloc(size_t size);
   void * __sanitizer_pvalloc(size_t size);
   void __sanitizer_free(void *ptr);
   void __sanitizer_cfree(void *ptr);

compiler-rt/lib/hwasan/hwasan_interface_internal.h

 void * __sanitizer_malloc(uptr size);
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void *__hwasan_memcpy(void *dst, const void *src, uptr size);
 SANITIZER_INTERFACE_ATTRIBUTE
 void *__hwasan_memset(void *s, int c, uptr n);
 SANITIZER_INTERFACE_ATTRIBUTE
 void *__hwasan_memmove(void *dest, const void *src, uptr n);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __hwasan_set_error_report_callback(void (*callback)(const char *));
 }  // extern "C"
 
 #endif  // HWASAN_INTERFACE_INTERNAL_H

compiler-rt/lib/hwasan/hwasan_report.cpp

  public:
   ScopedReport(bool fatal = false) : error_message_(1), fatal(fatal) {
     BlockingMutexLock lock(&error_message_lock_);
     error_message_ptr_ = fatal ? &error_message_ : nullptr;
     ++hwasan_report_count;
   }
 
   ~ScopedReport() {
+    void (*report_cb)(const char *);
     {
       BlockingMutexLock lock(&error_message_lock_);
-      if (fatal)
-        SetAbortMessage(error_message_.data());
+      report_cb = error_report_callback_;
       error_message_ptr_ = nullptr;
     }
+    if (report_cb)
+      report_cb(error_message_.data());
+    if (fatal)
+      SetAbortMessage(error_message_.data());
     if (common_flags()->print_module_map >= 2 ||
         (fatal && common_flags()->print_module_map))
       DumpProcessMap();
     if (fatal)
       Die();
   }
 
   static void MaybeAppendToErrorMessage(const char *msg) {
     BlockingMutexLock lock(&error_message_lock_);
     if (!error_message_ptr_)
       return;
     uptr len = internal_strlen(msg);
     uptr old_size = error_message_ptr_->size();
     error_message_ptr_->resize(old_size + len);
     // overwrite old trailing '\0', keep new trailing '\0' untouched.
     internal_memcpy(&(*error_message_ptr_)[old_size - 1], msg, len);
   }
+
+  static void SetErrorReportCallback(void (*callback)(const char *)) {
+    BlockingMutexLock lock(&error_message_lock_);
+    error_report_callback_ = callback;
+  }
+
  private:
   ScopedErrorReportLock error_report_lock_;
   InternalMmapVector<char> error_message_;
   bool fatal;
 
   static InternalMmapVector<char> *error_message_ptr_;
   static BlockingMutex error_message_lock_;
+  static void (*error_report_callback_)(const char *);
 };
 
 InternalMmapVector<char> *ScopedReport::error_message_ptr_;
 BlockingMutex ScopedReport::error_message_lock_;
+void (*ScopedReport::error_report_callback_)(const char *);
 
 // If there is an active ScopedReport, append to its error message.
 void AppendToErrorMessageBuffer(const char *buffer) {
   ScopedReport::MaybeAppendToErrorMessage(buffer);
 }
 
 static StackTrace GetStackTraceFromId(u32 id) {
   CHECK(id);
Printf("    x20 %016llx  x21 %016llx  x22 %016llx  x23 %016llx\n",
        frame[20], frame[21], frame[22], frame[23]);
   Printf("    x24 %016llx  x25 %016llx  x26 %016llx  x27 %016llx\n",
        frame[24], frame[25], frame[26], frame[27]);
   Printf("    x28 %016llx  x29 %016llx  x30 %016llx\n",
        frame[28], frame[29], frame[30]);
 }
 
 }  // namespace __hwasan
+
+void __hwasan_set_error_report_callback(void (*callback)(const char *)) {
+  __hwasan::ScopedReport::SetErrorReportCallback(callback);
+}

compiler-rt/test/hwasan/TestCases/set-error-report-callback.cpp

+// RUN: %clangxx_hwasan %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <sanitizer/hwasan_interface.h>
+
+#include "utils.h"
+
+__attribute__((no_sanitize("hwaddress"))) extern "C" void callback(const char *msg) {
+  untag_fprintf(stderr, "== error start\n%s\n== error end\n", msg);
+}
+
+int main() {
+  __hwasan_enable_allocator_tagging();
+  __hwasan_set_error_report_callback(&callback);
+  char *volatile p = (char *)malloc(16);
+  p[16] = 1;
+  free(p);
+  // CHECK: ERROR: HWAddressSanitizer:
+  // CHECK: WRITE of size 1 at
+  // CHECK: allocated here:
+  // CHECK: Memory tags around the buggy address
+
+  // CHECK: == error start
+  // CHECK: ERROR: HWAddressSanitizer:
+  // CHECK: WRITE of size 1 at
+  // CHECK: allocated here:
+  // CHECK: Memory tags around the buggy address
+  // CHECK: == error end
+}