Add Logging API Callback for All *SAN Passes

[Ben0mega]

Summary

Intercept all *SAN printf calls and provide the resulting string to a user-provided callback. This can be used to extract error messages and log them appropriately.

[kubamracek]

Can you please reupload with more context (-U9999 or similar when creating the diff)?

Can we also get a testcase that actually uses this feature? It looks like the change in error_report_callback.cc doesn't really check that the callback is called, how many times it's called or that the strings are what's expected.

[kcc]

Don't we already have something like this in another form?

[Ben0mega]

@kcc: I am hoping that this work is duplicated and I can use something else - I am more than open to another, existing API.

@kubamracek : I am not sure how to reupload with context - I have a raw diff - but I will work on that (and the test case).

[Ben0mega]

More context.

[kubamracek]

We have WriteOneLineToSyslog, but I guess it's used on Android only?

[cryptoad]

It seems that the existing weak OnPrint could fulfill the purpose of an application defined "callback" .
Right now it's not be used by any of the sanitizers, and having a weak function & 8 callbacks serving the same purpose seems overkill.

[Ben0mega]

It seems that the existing weak OnPrint could fulfill the purpose of an application defined "callback" .

That looks like it would be perfect for my needs - thank you!

include/sanitizer/common_interface_defs.h

#endif
   // that the tools may call to bypass the sandbox.
   void __sanitizer_sandbox_on_notify(__sanitizer_sandbox_arguments *args);
 
   // This function is called by the tool when it has just finished reporting
   // an error. 'error_summary' is a one-line string that summarizes
   // the error message. This function can be overridden by the client.
   void __sanitizer_report_error_summary(const char *error_summary);
 
+  // This function is called by the user to provide a callback
+  // for all messages produced by the sanitizer.  The callback
+  // receives the error message.  This function should not be overriden.
+  void __sanitizer_report_message_callback(void (*callback)(const char*));
+
   // Some of the sanitizers (e.g. asan/tsan) may miss bugs that happen
   // in unaligned loads/stores. In order to find such bugs reliably one needs
   // to replace plain unaligned loads/stores with these calls.
   uint16_t __sanitizer_unaligned_load16(const void *p);
   uint32_t __sanitizer_unaligned_load32(const void *p);
   uint64_t __sanitizer_unaligned_load64(const void *p);
   void __sanitizer_unaligned_store16(void *p, uint16_t x);
   void __sanitizer_unaligned_store32(void *p, uint32_t x);

lib/asan/asan_interface.inc

 INTERFACE_FUNCTION(__sanitizer_ptr_sub)
 INTERFACE_FUNCTION(__sanitizer_start_switch_fiber)
 INTERFACE_FUNCTION(__sanitizer_unaligned_load16)
 INTERFACE_FUNCTION(__sanitizer_unaligned_load32)
 INTERFACE_FUNCTION(__sanitizer_unaligned_load64)
 INTERFACE_FUNCTION(__sanitizer_unaligned_store16)
 INTERFACE_FUNCTION(__sanitizer_unaligned_store32)
 INTERFACE_FUNCTION(__sanitizer_unaligned_store64)
+INTERFACE_FUNCTION(__sanitizer_report_message_callback)
 INTERFACE_WEAK_FUNCTION(__asan_default_options)
 INTERFACE_WEAK_FUNCTION(__asan_default_suppressions)
 INTERFACE_WEAK_FUNCTION(__asan_on_error)

lib/asan/asan_rtl.cc

static void AsanInitInternal() {
   InitializeHighMemEnd();
 
   // Make sure we are not statically linked.
   AsanDoesNotSupportStaticLinkage();
 
   // Install tool-specific callbacks in sanitizer_common.
   AddDieCallback(AsanDie);
   SetCheckFailedCallback(AsanCheckFailed);
-  SetPrintfAndReportCallback(AppendToErrorMessageBuffer);
+  AddPrintfAndReportCallback(AppendToErrorMessageBuffer);
 
   __sanitizer_set_report_path(common_flags()->log_path);
 
   __asan_option_detect_stack_use_after_return =
       flags()->detect_stack_use_after_return;
 
   // Re-exec ourselves if we need to set additional env or command line args.
   MaybeReexec();

lib/sanitizer_common/sanitizer_common.h

 
 // IO
 void CatastrophicErrorWrite(const char *buffer, uptr length);
 void RawWrite(const char *buffer);
 bool ColorizeReports();
 void RemoveANSIEscapeSequencesFromString(char *buffer);
 void Printf(const char *format, ...);
 void Report(const char *format, ...);
-void SetPrintfAndReportCallback(void (*callback)(const char *));
+void AddPrintfAndReportCallback(void (*callback)(const char *));
 #define VReport(level, ...)                                              \
   do {                                                                   \
     if ((uptr)Verbosity() >= (level)) Report(__VA_ARGS__); \
   } while (0)
 #define VPrintf(level, ...)                                              \
   do {                                                                   \
     if ((uptr)Verbosity() >= (level)) Printf(__VA_ARGS__); \
   } while (0)

lib/sanitizer_common/sanitizer_common.cc

 
 extern "C" {
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_report_error_summary,
                              const char *error_summary) {
   Printf("%s\n", error_summary);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_report_message_callback(void (*callback)(const char*)){
+  AddPrintfAndReportCallback(callback);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_set_death_callback(void (*callback)(void)) {
   SetUserDieCallback(callback);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 int __sanitizer_install_malloc_and_free_hooks(void (*malloc_hook)(const void *,
                                                                   uptr),
                                               void (*free_hook)(const void *)) {
   return InstallMallocFreeHooks(malloc_hook, free_hook);
 }
 } // extern "C"

lib/sanitizer_common/sanitizer_common_interface.inc

 //===----------------------------------------------------------------------===//
 INTERFACE_FUNCTION(__sanitizer_annotate_contiguous_container)
 INTERFACE_FUNCTION(__sanitizer_contiguous_container_find_bad_address)
 INTERFACE_FUNCTION(__sanitizer_set_death_callback)
 INTERFACE_FUNCTION(__sanitizer_set_report_path)
 INTERFACE_FUNCTION(__sanitizer_set_report_fd)
 INTERFACE_FUNCTION(__sanitizer_verify_contiguous_container)
 INTERFACE_WEAK_FUNCTION(__sanitizer_report_error_summary)
+INTERFACE_WEAK_FUNCTION(__sanitizer_report_message_callback)
 INTERFACE_WEAK_FUNCTION(__sanitizer_sandbox_on_notify)
 // Sanitizer weak hooks
 INTERFACE_WEAK_FUNCTION(__sanitizer_weak_hook_memcmp)
 INTERFACE_WEAK_FUNCTION(__sanitizer_weak_hook_strcmp)
 INTERFACE_WEAK_FUNCTION(__sanitizer_weak_hook_strncmp)
 INTERFACE_WEAK_FUNCTION(__sanitizer_weak_hook_strstr)
 // Stacktrace interface.
 INTERFACE_FUNCTION(__sanitizer_get_module_and_offset_for_pc)

lib/sanitizer_common/sanitizer_printf.cc

switch (*cur) {
       }
     }
   }
   RAW_CHECK(buff <= buff_end);
   AppendChar(&buff, buff_end + 1, '\0');
   return result;
 }
 
-static void (*PrintfAndReportCallback)(const char *);
-void SetPrintfAndReportCallback(void (*callback)(const char *)) {
-  PrintfAndReportCallback = callback;
+#define MAX_PRINTF_AND_REPORT_CALLBACKS 8
+static void (*PrintfAndReportCallbacks[MAX_PRINTF_AND_REPORT_CALLBACKS])(const char *);
+static int PrintfAndReportCallbacksSize = 0;
+
+void AddPrintfAndReportCallback(void (*callback)(const char *)) {
+  CHECK(callback);
+  CHECK_LT(PrintfAndReportCallbacksSize, MAX_PRINTF_AND_REPORT_CALLBACKS);
+  CHECK(!PrintfAndReportCallbacks[PrintfAndReportCallbacksSize]);
+
+  PrintfAndReportCallbacks[PrintfAndReportCallbacksSize] = callback;
+  PrintfAndReportCallbacksSize++;
 }
 
 // Can be overriden in frontend.
 #if SANITIZER_GO && defined(TSAN_EXTERNAL_HOOKS)
 // Implementation must be defined in frontend.
 extern "C" void OnPrint(const char *str);
 #else
 SANITIZER_INTERFACE_WEAK_DEF(void, OnPrint, const char *str) {
   (void)str;
 }
 #endif
 
 static void CallPrintfAndReportCallback(const char *str) {
   OnPrint(str);
-  if (PrintfAndReportCallback)
-    PrintfAndReportCallback(str);
+  for (int i = 0; i < PrintfAndReportCallbacksSize; ++i)
+    PrintfAndReportCallbacks[i](str);
 }
 
 static void NOINLINE SharedPrintfCodeNoBuffer(bool append_pid,
                                               char *local_buffer,
                                               int buffer_size,
                                               const char *format,
                                               va_list args) {
   va_list args2;

test/asan/TestCases/error_report_callback.cc

 // RUN: %clangxx_asan -O0 %s -o %t
 // RUN: not %run %t 0 2>&1 | FileCheck %s
 
 #include <sanitizer/asan_interface.h>
 #include <stdio.h>
 
 static void ErrorReportCallbackOneToZ(const char *report) {
   fprintf(stderr, "ABCDEF%sGHIJKL", report);
   fflush(stderr);
 }
 
 int main(int argc, char **argv) {
   __asan_set_error_report_callback(ErrorReportCallbackOneToZ);
+  __sanitizer_report_message_callback(ErrorReportCallbackOneToZ);
   __asan_report_error(
       (void *)__builtin_extract_return_addr(__builtin_return_address(0)), 0, 0,
       0, true, 1);
   // CHECK: ABCDEF
   // CHECK: ERROR: AddressSanitizer
   // CHECK: GHIJKL
   return 0;
 }