[asan] On OS X, log reports to syslog and os_trace (version 2)

[zaks.anna]

Summary

When ASan currently detects a bug, by default it will only print out the text of the report to stderr. This patch changes this behavior and writes the full text of the report to syslog before we terminate the process. It also calls os_trace (Activity Tracing available on OS X and iOS) with a message saying that the report is available in syslog. This is useful, because this message will be shown in the crash log.

For this to work, the patch makes sure we store the full report into error_message_buffer unconditionally, and it also strips out ANSI escape sequences from the report (they are used when producing colored reports).

This is the second version of the patch that addresses several concerns raised in http://reviews.llvm.org/D11981

• Added a unit test for removal of color sequences
• Moved the logic to sanitizer_common, instead of ASan so that all other tools could use error report logging. (Note, that this introduced some ugliness due to the specifics of os_trace, which only allows us to log literal strings and I think it's important to log the name of the tool that produced the report there.)
• Refactored the Android specific WriteToSyslog logic to make it reusable by other platforms.
• Added a lock to AppendToErrorMessageBuffer.
• Made sure the logging is off for testing. The code will get executed by abort_on_error.cc test that runs with the default options.

I've initially tried to log to syslog during printing, which is done on Android right now. The advantage is that if we crash during error reporting or the produced error does not go through ScopedInErrorReport, we would still get a (partial) message in the syslog. However, that solution is very problematic on OS X. One issue is that the logging routine uses GCD, which may spawn a new thread on its behalf. In many cases, the reporting logic locks threadRegistry, which leads to deadlocks.

[filcab]

Looks good, but wait on another LGTM.
Minor comments above.

lib/asan/asan_report.cc

48

I'd prefer this to have "mutex" or "lock" (or a variation of one) in the name.

lib/sanitizer_common/sanitizer_mac.cc

408

Can we verify any/some of these things (e.g: someone was holding the mutex and called us) with some CHECK() calls?

lib/sanitizer_common/sanitizer_printf.cc

282

It's not really testing Android, it's something more general.
Both rephrasing or removing the comment are ok for me.

test/ubsan/lit.common.cfg

45

Extra ':'.

[glider]

lib/asan/asan_report.cc

48

Which variables does this mutex protect?
I suspect |error_message_buffer| belongs to those, therefore you need to acquire this mutex every time you access |error_message_buffer|.
I also suggest you declare the mutex next to error_message_xxx declarations (and change the name as proposed by Filipe)

lib/sanitizer_common/sanitizer_common_libcdep.cc

15

Please keep the includes sorted alphabetically.

lib/sanitizer_common/sanitizer_mac.cc

385

I think the spelling outside Xcode must be "AddressSanitizer" (ditto for other sanitizers).
Kostya, WDYT?

[kcc]

lib/sanitizer_common/sanitizer_mac.cc

385

The tool name is certainly "AddressSanitizer" w/o spaces,
but that this is a Mac-only code, so I don't have strong opinion here.
On non-Mac-specific code -- no spaces please.

[eugenis]

lib/sanitizer_common/sanitizer_common.cc

322

a shorter way to do the same:

if (s ! = z) *z = *s;
z++;
s++;

}

lib/sanitizer_common/sanitizer_common.h

659

We already have knowledge of the current sanitizer: SanitizerToolName. Could you either dispatch on that, or use it directly?

lib/sanitizer_common/tests/sanitizer_common_test.cc

221

Please test 2 ansi sequencies with nothing in between.

test/asan/lit.cfg

39

This way log_to_syslog is completely untested. How bad is it? Is there a way to tune this down, but still exercise the logging code?

[zaks.anna]

lib/sanitizer_common/sanitizer_common.h

659

One of the APIs we use only allows string literals (for privacy reasons).

Dispatching on the string literal instead of the enum feels bad.

Also, how does this global SanitizerToolName works when we have more than one sanitizer on at the same time? I think UBSan and ASan are not mutually exclusive. It might not matter which tool failed in some cases; however, when a tool reports an error, differentiating between the two might be useful. One way of doing that would be to have the error reporting APIs take the tool name as a parameter.

In most cases, SanitizerToolName is used in calls to Report() when reporting an internal error. It would be useful to log the internal errors to syslog on OS X as well (at least that should be the long term goal).

Any further opinions on this?

lib/sanitizer_common/sanitizer_common_libcdep.cc

15

They are sorted. sanitizer-common.h is "the module header" for this cc file.

lib/sanitizer_common/sanitizer_mac.cc

408

It would be good to check if there is a lock on threadRegestry; however, I don't know if we can access that from a utility in sanitizer_common without passing it in explicitly.

test/asan/lit.cfg

39

The code will get executed by abort_on_error.cc test that runs with the default options.

[eugenis]

lib/sanitizer_common/sanitizer_common.h

659

I don't like 2 things about this: duplication between SanitizerType and SanitizerToolName, and the fact the SanitizerType list is incomplete and looks arbitrary.

Maybe extend the list to include, at least, all possible values of SanitizerToolName, and define a global instance of that to replace SanitizerToolName? With a static list of pretty tool names indexed by SanitizerType.

Also, how does this global SanitizerToolName works when we have more than one sanitizer on at the same time?

There is always a "main sanitizer" which provides the name to be used in reports. In the case of asan+ubsan the main sanitizer is asan. We never really saw this as a problem. After all, the report contains a type string like "use-after-free" which clearly tells the user what it is about.

[zaks.anna]

lib/sanitizer_common/sanitizer_common.h

659

I agree about the duplication.

Maybe extend the list to include, at least, all possible values of SanitizerToolName, and define a global instance of that to
replace SanitizerToolName? With a static list of pretty tool names indexed by SanitizerType.

In the solution you propose above, we would also replace uses of SanitizerToolName by a call to a function that dispatches on the enum and returns the name. This function would be implemented in sanitizer_common and would have to know about all sanitizers, correct?

I can do this as a separate patch.

After all, the report contains a type string like "use-after-free" which clearly tells the user what it is about.

I do no think it is true of every user and every error message. Also, this is not friendly to (hypothetical but likely) post processing scripts that check the syslog trying to detect and categorize the failures.

Another issue that is Mac-specific is that the cash report might only have the messages from os_trace, which will not include the rest of the message. Calling out which tool failed there is valuable.

[zaks.anna]

Address all outstanding review comments.

[zaks.anna]

lib/sanitizer_common/sanitizer_common.h

659

Using the SanitizerToolName in this patch; we can follow up with a different solution later as discussed.

[samsonov]

lib/asan/asan_report.cc

48

Agree. Note that currently there is a race between setting error_report_callback from __asan_set_error_report_callback and invoking it when the report is printed. We may use this mutex to fix the problem.

lib/sanitizer_common/sanitizer_common.cc

310

s = internal_strchrnul(s, 'm');

lib/sanitizer_common/tests/sanitizer_common_test.cc

212

s/0/nullptr

227

indentation went off

[zaks.anna]

Address Alexey's comments. (I think now I've got the synchronization right.)

[samsonov]

Looks reasonable to me. I'm kind of worried about the increased probability of deadlock inside runtime (e.g. if we decide to call AppendToErrorMessageBuffer when executing user-provided error report callback), but I don't see a good way to deal with this.

lib/asan/asan_report.cc

34

This should be error_message_buf_mutex(LINKER_INITIALIZED);

674

You can just add a scope and BlockingMutexLock here.

lib/sanitizer_common/sanitizer_mac.cc

379

const char *kNameMapping[][2] = {
{"AddressSanitizer", "Address Sanitizer"},
{"ThreadSanitizer", "Thread Sanitizer"},
...
};

and then a loop, would probably reduce duplication. Also, add some kind of comment about why you want space.

[zaks.anna]

lib/asan/asan_report.cc

674

Report calls Print, which might call AppendToErrorMessageBuffer resulting in double locking.

lib/sanitizer_common/sanitizer_mac.cc

379

The main issue here is not the space but that the os_trace API does not work with anything but the string literal constants (for privacy reasons).

[zaks.anna]

lib/asan/asan_report.cc

674

Oh, "add a scope". OK. Will do.

[zaks.anna]

Addressed additional comments from Alexey.

[glider]

lib/sanitizer_common/sanitizer_mac.cc

378

There's a name clash between this parameter and the global variable.

399

Any idea about the conditions under which the logging calls pthread_create?
Maybe we can warm up the logging subsystem when initializing ASan?
Will it help to create actual asl clients using asl_open()?

[zaks.anna]

lib/sanitizer_common/sanitizer_mac.cc

378

The variable is a static from another file, so technically there is no clash, but I can rename the parameter to buffer.

399

asl_log relies on libdispatch, for example, it calls dispatch_once. We cannot control when GCD will spawn a new thread. The deadlocks are unpredictable, they often happen when the client code uses GCD.

asl_open should be used if we want to log from multiple threads without locking:
"A client handle may only be safely shared amongst multiple threads if the application uses locks or some synchronization strategy to ensure single-threaded access."

LogFullErrorReport is only called behind a lock right now. However, I could add another lock just to protect logging to syslog. Ex: maybe we could lock before calling WriteToSyslog below and check the lock in WriteOneLineToSyslog. This way we will future proof the code.

[zaks.anna]

Adding a new diff, where the variable is renamed and an extra lock is added to guard calls to ask_log.

All outstanding issues have been resolved.

[glider]

LGTM

lib/sanitizer_common/sanitizer_common_libcdep.cc

15

I think there should be a newline between them then.

[zaks.anna]

In r253688.

lib/asan/asan_report.cc

 
 namespace __asan {
 
 // -------------------- User-specified callbacks ----------------- {{{1
 static void (*error_report_callback)(const char*);
 static char *error_message_buffer = nullptr;
 static uptr error_message_buffer_pos = 0;
 static uptr error_message_buffer_size = 0;
+static BlockingMutex error_message_buf_mutex(LINKER_INITIALIZED);
 
 struct ReportData {
   uptr pc;
   uptr sp;
   uptr bp;
   uptr addr;
   bool is_write;
   uptr access_size;
   const char *description;
 };
 
 static bool report_happened = false;
 static ReportData report_data = {};
 
 void AppendToErrorMessageBuffer(const char *buffer) {
-  if (error_message_buffer) {
-    uptr length = internal_strlen(buffer);
-    CHECK_GE(error_message_buffer_size, error_message_buffer_pos);
-    uptr remaining = error_message_buffer_size - error_message_buffer_pos;
-    internal_strncpy(error_message_buffer + error_message_buffer_pos,
-                     buffer, remaining);
-    error_message_buffer[error_message_buffer_size - 1] = '\0';
-    // FIXME: reallocate the buffer instead of truncating the message.
-    error_message_buffer_pos += Min(remaining, length);
-  }
-}
+  BlockingMutexLock l(&error_message_buf_mutex);
+  if (!error_message_buffer) {
+    error_message_buffer_size = 1 << 16;
+    error_message_buffer =
+      (char*)MmapOrDie(error_message_buffer_size, __func__);
+    error_message_buffer_pos = 0;
+  }
 
 // ---------------------- Decorator ------------------------------ {{{1
 class Decorator: public __sanitizer::SanitizerCommonDecorator {
  public:
   Decorator() : SanitizerCommonDecorator() { }
   const char *Access()     { return Blue(); }
   const char *EndAccess()  { return Default(); }
   const char *Location()   { return Green(); }
public:
   NORETURN ~ScopedInErrorReport() {
     // Make sure the current thread is announced.
     DescribeThread(GetCurrentThread());
     // We may want to grab this lock again when printing stats.
     asanThreadRegistry().Unlock();
     // Print memory stats.
     if (flags()->print_stats)
       __asan_print_accumulated_stats();
+    {
+      BlockingMutexLock l(&error_message_buf_mutex);
+      LogFullErrorReport(error_message_buffer);
+
       if (error_report_callback) {
         error_report_callback(error_message_buffer);
       }
+    }
     Report("ABORTING\n");
     Die();
   }
 };
 
 void ReportStackOverflow(const SignalContext &sig) {
   ScopedInErrorReport in_report;
   Decorator d;
void __asan_report_error(uptr pc, uptr bp, uptr sp, uptr addr, int is_write,
   stack.Print();
 
   DescribeAddress(addr, access_size, bug_descr);
   ReportErrorSummary(bug_descr, &stack);
   PrintShadowMemoryForAddress(addr);
 }
 
 void NOINLINE __asan_set_error_report_callback(void (*callback)(const char*)) {
+  BlockingMutexLock l(&error_message_buf_mutex);
   error_report_callback = callback;
-  if (callback) {
-    error_message_buffer_size = 1 << 16;
-    error_message_buffer =
-        (char*)MmapOrDie(error_message_buffer_size, __func__);
-    error_message_buffer_pos = 0;
-  }
 }
 
 void __asan_describe_address(uptr addr) {
   // Thread registry must be locked while we're describing an address.
   asanThreadRegistry().Lock();
   DescribeAddress(addr, 1, "");
   asanThreadRegistry().Unlock();
 }

lib/asan/tests/asan_test_main.cc

 #include "sanitizer_common/sanitizer_platform.h"
 
 // Default ASAN_OPTIONS for the unit tests. Let's turn symbolication off to
 // speed up testing (unit tests don't use it anyway).
 extern "C" const char* __asan_default_options() {
 #if SANITIZER_MAC
   // On Darwin, we default to `abort_on_error=1`, which would make tests run
   // much slower. Let's override this and run lit tests with 'abort_on_error=0'.
-  return "symbolize=false:abort_on_error=0";
+  // Also, make sure we do not overwhelm the syslog while testing.
+  return "symbolize=false:abort_on_error=0:log_to_syslog=0";
 #else
   return "symbolize=false";
 #endif
 }
 
 int main(int argc, char **argv) {
   testing::GTEST_FLAG(death_test_style) = "threadsafe";
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }

lib/sanitizer_common/sanitizer_common.h

 typedef void (*LowLevelAllocateCallback)(uptr ptr, uptr size);
 // Allows to register tool-specific callbacks for LowLevelAllocator.
 // Passing NULL removes the callback.
 void SetLowLevelAllocateCallback(LowLevelAllocateCallback callback);
 
 // IO
 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 *));
 #define VReport(level, ...)                                              \
   do {                                                                   \
     if ((uptr)Verbosity() >= (level)) Report(__VA_ARGS__); \
   } while (0)
 #define VPrintf(level, ...)                                              \

 
 enum AndroidApiLevel {
   ANDROID_NOT_ANDROID = 0,
   ANDROID_KITKAT = 19,
   ANDROID_LOLLIPOP_MR1 = 22,
   ANDROID_POST_LOLLIPOP = 23
 };
 
+void WriteToSyslog(const char *buffer);
+
+#if SANITIZER_MAC
+void LogFullErrorReport(const char *error_message_buffer);
+#else
+INLINE void LogFullErrorReport(const char *error_message_buffer) {}
+#endif
+
+#if SANITIZER_LINUX || SANITIZER_MAC
+void WriteOneLineToSyslog(const char *s);
+#else
+INLINE void WriteOneLineToSyslog(const char *s) {}
+#endif
+
 #if SANITIZER_LINUX
 // Initialize Android logging. Any writes before this are silently lost.
 void AndroidLogInit();
-void WriteToSyslog(const char *buffer);
+bool ShouldLogAfterPrintf();
 #else
 INLINE void AndroidLogInit() {}
-INLINE void WriteToSyslog(const char *buffer) {}
+INLINE bool ShouldLogAfterPrintf() { return false; }
 #endif
 
 #if SANITIZER_ANDROID
 void GetExtraActivationFlags(char *buf, uptr size);
 void SanitizerInitializeUnwinder();
 AndroidApiLevel AndroidGetApiLevel();
 #else
 INLINE void AndroidLogWrite(const char *buffer_unused) {}

lib/sanitizer_common/sanitizer_common.cc

void ReportErrorSummary(const char *error_type, const AddressInfo &info) {
   InternalScopedString buff(kMaxSummaryLength);
   buff.append("%s ", error_type);
   RenderFrame(&buff, "%L %F", 0, info, common_flags()->symbolize_vs_style,
               common_flags()->strip_path_prefix);
   ReportErrorSummary(buff.data());
 }
 #endif
 
+// Removes the ANSI escape sequences from the input string (in-place).
+void RemoveANSIEscapeSequencesFromString(char *str) {
+  if (!str)
+    return;
+
+  // We are going to remove the escape sequences in place.
+  char *s = str;
+  char *z = str;
+  while (*s != '\0') {
+    CHECK_GE(s, z);
+    // Skip over ANSI escape sequences with pointer 's'.
+    if (*s == '\033' && *(s + 1) == '[') {
+      s = internal_strchrnul(s, 'm');
+      if (*s == '\0') {
+        break;
+      }
+      s++;
+      continue;
+    }
+    // 's' now points at a character we want to keep. Copy over the buffer
+    // content if the escape sequence has been perviously skipped andadvance
+    // both pointers.
+    if (s != z)
+      *z = *s;
+
+    // If we have not seen an escape sequence, just advance both pointers.
+    z++;
+    s++;
+  }
+
+  // Null terminate the string.
+  *z = '\0';
+}
+
 void LoadedModule::set(const char *module_name, uptr base_address) {
   clear();
   full_name_ = internal_strdup(module_name);
   base_address_ = base_address;
 }
 
 void LoadedModule::clear() {
   InternalFree(full_name_);

lib/sanitizer_common/sanitizer_common_libcdep.cc

 //===-- sanitizer_common_libcdep.cc ---------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common.h"
+#include "sanitizer_allocator_internal.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_stackdepot.h"
 #include "sanitizer_stacktrace.h"
 #include "sanitizer_symbolizer.h"
 
 #if SANITIZER_POSIX
 #include "sanitizer_posix.h"
 #endif
if (soft_rss_limit_mb) {
         reached_soft_rss_limit = false;
         if (SoftRssLimitExceededCallback)
           SoftRssLimitExceededCallback(false);
       }
     }
   }
 }
 
+void WriteToSyslog(const char *buffer) {
+  char *copy = internal_strdup(buffer);
+  char *p = copy;
+  char *q;
+
+  // Remove color sequences since syslogs cannot print them.
+  RemoveANSIEscapeSequencesFromString(copy);
+
+  // Print one line at a time.
+  // syslog, at least on Android, has an implicit message length limit.
+  do {
+    q = internal_strchr(p, '\n');
+    if (q)
+      *q = '\0';
+    WriteOneLineToSyslog(p);
+    if (q)
+      p = q + 1;
+  } while (q);
+  InternalFree(copy);
+}
+
 void MaybeStartBackgroudThread() {
 #if SANITIZER_LINUX  // Need to implement/test on other platforms.
   // Start the background thread if one of the rss limits is given.
   if (!common_flags()->hard_rss_limit_mb &&
       !common_flags()->soft_rss_limit_mb) return;
   if (!&real_pthread_create) return;  // Can't spawn the thread anyway.
   internal_start_thread(BackgroundThread, nullptr);
 #endif

lib/sanitizer_common/sanitizer_flags.inc

COMMON_FLAG(
     const char *, log_path, "stderr",
     "Write logs to \"log_path.pid\". The special values are \"stdout\" and "
     "\"stderr\". The default is \"stderr\".")
 COMMON_FLAG(
     bool, log_exe_name, false,
     "Mention name of executable when reporting error and "
     "append executable name to logs (as in \"log_path.exe_name.pid\").")
 COMMON_FLAG(
-    bool, log_to_syslog, SANITIZER_ANDROID,
+    bool, log_to_syslog, SANITIZER_ANDROID || SANITIZER_MAC,
     "Write all sanitizer output to syslog in addition to other means of "
     "logging.")
 COMMON_FLAG(
     int, verbosity, 0,
     "Verbosity level (0 - silent, 1 - a bit of output, 2+ - more output).")
 COMMON_FLAG(bool, detect_leaks, true, "Enable memory leak detection.")
 COMMON_FLAG(
     bool, leak_check_at_exit, true,

lib/sanitizer_common/sanitizer_linux_libcdep.cc

 
 #if SANITIZER_ANDROID
 static atomic_uint8_t android_log_initialized;
 
 void AndroidLogInit() {
   atomic_store(&android_log_initialized, 1, memory_order_release);
 }
 
-static bool IsSyslogAvailable() {
+bool ShouldLogAfterPrintf() {
   return atomic_load(&android_log_initialized, memory_order_acquire);
 }
 #else
 void AndroidLogInit() {}
 
-static bool IsSyslogAvailable() { return true; }
+bool ShouldLogAfterPrintf() { return true; }
 #endif  // SANITIZER_ANDROID
 
-static void WriteOneLineToSyslog(const char *s) {
+void WriteOneLineToSyslog(const char *s) {
 #if SANITIZER_ANDROID &&__ANDROID_API__ < 21
   __android_log_write(ANDROID_LOG_INFO, NULL, s);
 #else
   syslog(LOG_INFO, "%s", s);
 #endif
 }
 
-void WriteToSyslog(const char *buffer) {
-  if (!IsSyslogAvailable())
-    return;
-  char *copy = internal_strdup(buffer);
-  char *p = copy;
-  char *q;
-  // syslog, at least on Android, has an implicit message length limit.
-  // Print one line at a time.
-  do {
-    q = internal_strchr(p, '\n');
-    if (q)
-      *q = '\0';
-    WriteOneLineToSyslog(p);
-    if (q)
-      p = q + 1;
-  } while (q);
-  InternalFree(copy);
-}
 #endif // SANITIZER_LINUX
 
 } // namespace __sanitizer
 
 #endif // SANITIZER_FREEBSD || SANITIZER_LINUX

lib/sanitizer_common/sanitizer_mac.cc

 #include "sanitizer_procmaps.h"
 
 #if !SANITIZER_IOS
 #include <crt_externs.h>  // for _NSGetEnviron
 #else
 extern char **environ;
 #endif
 
+#include <asl.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <libkern/OSAtomic.h>
 #include <mach-o/dyld.h>
 #include <mach/mach.h>
+#include <os/trace.h>
 #include <pthread.h>
 #include <sched.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
kern_return_t result =
       task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &count);
   if (UNLIKELY(result != KERN_SUCCESS)) {
     Report("Cannot get task info. Error: %d\n", result);
     Die();
   }
   return info.resident_size;
 }
 
+static BlockingMutex syslog_lock(LINKER_INITIALIZED);
+
+void WriteOneLineToSyslog(const char *s) {
+  syslog_lock.CheckLocked();
+  asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", s);
+}
+
+void LogFullErrorReport(const char *buffer) {
+  // Log with os_trace. This will make it into the crash log.
+  if (GetMacosVersion() >= MACOS_VERSION_MAVERICKS) {
+    // os_trace requires the message (format parameter) to be a string literal.
+    if (internal_strncmp(SanitizerToolName, "AddressSanitizer",
+                         sizeof("AddressSanitizer") - 1) == 0)
+      os_trace("Address Sanitizer reported a failure.");
+    else if (internal_strncmp(SanitizerToolName, "UndefinedBehaviorSanitizer",
+                              sizeof("UndefinedBehaviorSanitizer") - 1) == 0)
+      os_trace("Undefined Behavior Sanitizer reported a failure.");
+    else if (internal_strncmp(SanitizerToolName, "ThreadSanitizer",
+                              sizeof("ThreadSanitizer") - 1) == 0)
+      os_trace("Thread Sanitizer reported a failure.");
+    else
+      os_trace("Sanitizer tool reported a failure.");
+
+    if (common_flags()->log_to_syslog)
+      os_trace("Consult syslog for more information.");
+  }
+
+  // Log to syslog.
+  // The logging on OS X may call pthread_create so we need the threading
+  // environment to be fully initialized. Also, this should never be called when
+  // holding the thread registry lock since that may result in a deadlock. If
+  // the reporting thread holds the thread registry mutex, and asl_log waits
+  // for GCD to dispatch a new thread, the process will deadlock, because the
+  // pthread_create wrapper needs to acquire the lock as well.
+  BlockingMutexLock l(&syslog_lock);
+  if (common_flags()->log_to_syslog)
+    WriteToSyslog(buffer);
+}
+
 void *internal_start_thread(void (*func)(void *arg), void *arg) { return 0; }
 void internal_join_thread(void *th) { }
 
 void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
   ucontext_t *ucontext = (ucontext_t*)context;
 # if defined(__aarch64__)
   *pc = ucontext->uc_mcontext->__ss.__pc;
 #   if defined(__IPHONE_8_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_8_0

lib/sanitizer_common/sanitizer_printf.cc

#   define CHECK_NEEDED_LENGTH \
     needed_length += VSNPrintf(buffer + needed_length,
                                buffer_size - needed_length, format, args);
     CHECK_NEEDED_LENGTH
     // If the message fit into the buffer, print it and exit.
     break;
 #   undef CHECK_NEEDED_LENGTH
   }
   RawWrite(buffer);
-  if (common_flags()->log_to_syslog)
+  if (common_flags()->log_to_syslog && ShouldLogAfterPrintf())
     WriteToSyslog(buffer);
   CallPrintfAndReportCallback(buffer);
   // If we had mapped any memory, clean up.
   if (buffer != local_buffer)
     UnmapOrDie((void *)buffer, buffer_size);
   va_end(args2);
 }
 
 FORMAT(1, 2)

lib/sanitizer_common/tests/sanitizer_common_test.cc

TEST(SanitizerCommon, StripPathPrefix) {
   EXPECT_EQ(0, StripPathPrefix(0, "prefix"));
   EXPECT_STREQ("foo", StripPathPrefix("foo", 0));
   EXPECT_STREQ("dir/file.cc",
                StripPathPrefix("/usr/lib/dir/file.cc", "/usr/lib/"));
   EXPECT_STREQ("/file.cc", StripPathPrefix("/usr/myroot/file.cc", "/myroot"));
   EXPECT_STREQ("file.h", StripPathPrefix("/usr/lib/./file.h", "/usr/lib/"));
 }
 
+TEST(SanitizerCommon, RemoveANSIEscapeSequencesFromString) {
+  RemoveANSIEscapeSequencesFromString(nullptr);
+  const char *buffs[22] = {
+    "Default",                                "Default",
+    "\033[95mLight magenta",                  "Light magenta",
+    "\033[30mBlack\033[32mGreen\033[90mGray", "BlackGreenGray",
+    "\033[106mLight cyan \033[107mWhite ",    "Light cyan White ",
+    "\033[31mHello\033[0m World",             "Hello World",
+    "\033[38;5;82mHello \033[38;5;198mWorld", "Hello World",
+    "123[653456789012",                       "123[653456789012",
+    "Normal \033[5mBlink \033[25mNormal",     "Normal Blink Normal",
+    "\033[106m\033[107m",                     "",
+    "",                                       "",
+    " ",                                      " ",
+  };
+
+  for (size_t i = 0; i < ARRAY_SIZE(buffs); i+=2) {
+    char *buffer_copy = internal_strdup(buffs[i]);
+    RemoveANSIEscapeSequencesFromString(buffer_copy);
+    EXPECT_STREQ(buffer_copy, buffs[i+1]);
+    InternalFree(buffer_copy);
+  }
+}
+
 TEST(SanitizerCommon, InternalScopedString) {
   InternalScopedString str(10);
   EXPECT_EQ(0U, str.length());
   EXPECT_STREQ("", str.data());
 
   str.append("foo");
   EXPECT_EQ(3U, str.length());
   EXPECT_STREQ("foo", str.data());

test/asan/lit.cfg

 # Setup config name.
 config.name = 'AddressSanitizer' + config.name_suffix
 
 # Platform-specific default ASAN_OPTIONS for lit tests.
 default_asan_opts = ''
 if config.host_os == 'Darwin':
   # On Darwin, we default to `abort_on_error=1`, which would make tests run
   # much slower. Let's override this and run lit tests with 'abort_on_error=0'.
+  # Also, make sure we do not overwhelm the syslog while testing.
   default_asan_opts = 'abort_on_error=0'
+  default_asan_opts += ':log_to_syslog=0'
 if default_asan_opts:
   config.environment['ASAN_OPTIONS'] = default_asan_opts
   default_asan_opts += ':'
 config.substitutions.append(('%env_asan_opts=',
                              'env ASAN_OPTIONS=' + default_asan_opts))
 
 # Setup source root.
 config.test_source_root = os.path.dirname(__file__)

test/ubsan/lit.common.cfg

 else:
   lit_config.fatal("Unknown UBSan test mode: %r" % ubsan_lit_test_mode)
 
 # Platform-specific default for lit tests.
 if config.host_os == 'Darwin':
   # On Darwin, we default to `abort_on_error=1`, which would make tests run
   # much slower. Let's override this and run lit tests with 'abort_on_error=0'.
   default_ubsan_opts += ['abort_on_error=0']
+  default_ubsan_opts += ['log_to_syslog=0']
 default_ubsan_opts_str = ':'.join(default_ubsan_opts)
 if default_ubsan_opts_str:
   config.environment['UBSAN_OPTIONS'] = default_ubsan_opts_str
   default_ubsan_opts_str += ':'
 # Substitution to setup UBSAN_OPTIONS in portable way.
 config.substitutions.append(('%env_ubsan_opts=',
                              'env UBSAN_OPTIONS=' + default_ubsan_opts_str))