From 766e7c6b61b0207ada838fd31ede7aa2b9bfffef Mon Sep 17 00:00:00 2001 From: Juergen Ributzka Date: Wed, 4 Nov 2015 21:03:12 +0000 Subject: Revert "Reapply: [asan] On OS X, log reports to syslog and os_trace" Looks like this commit is deadlocking the ASAN tests on the green dragon bot (http://lab.llvm.org:8080/green/job/clang-stage1-cmake-RA/). git-svn-id: https://llvm.org/svn/llvm-project/compiler-rt/trunk@252076 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/sanitizer_common/sanitizer_common.cc | 34 ------------------ lib/sanitizer_common/sanitizer_common.h | 19 ++-------- lib/sanitizer_common/sanitizer_common_libcdep.cc | 27 +------------- lib/sanitizer_common/sanitizer_common_nolibc.cc | 4 +-- lib/sanitizer_common/sanitizer_flags.inc | 2 +- lib/sanitizer_common/sanitizer_linux_libcdep.cc | 24 +++++++++++-- lib/sanitizer_common/sanitizer_mac.cc | 41 ---------------------- lib/sanitizer_common/sanitizer_printf.cc | 2 +- .../tests/sanitizer_common_test.cc | 24 ------------- 9 files changed, 28 insertions(+), 149 deletions(-) (limited to 'lib/sanitizer_common') diff --git a/lib/sanitizer_common/sanitizer_common.cc b/lib/sanitizer_common/sanitizer_common.cc index db734d628..2fb88688d 100644 --- a/lib/sanitizer_common/sanitizer_common.cc +++ b/lib/sanitizer_common/sanitizer_common.cc @@ -295,40 +295,6 @@ void ReportErrorSummary(const char *error_type, const AddressInfo &info) { } #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); diff --git a/lib/sanitizer_common/sanitizer_common.h b/lib/sanitizer_common/sanitizer_common.h index 63c772bc4..bfd0d6e12 100644 --- a/lib/sanitizer_common/sanitizer_common.h +++ b/lib/sanitizer_common/sanitizer_common.h @@ -162,7 +162,6 @@ 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 *)); @@ -649,27 +648,13 @@ enum AndroidApiLevel { 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(); -bool ShouldLogAfterPrintf(); +void WriteToSyslog(const char *buffer); #else INLINE void AndroidLogInit() {} -INLINE bool ShouldLogAfterPrintf() { return false; } +INLINE void WriteToSyslog(const char *buffer) {} #endif #if SANITIZER_ANDROID diff --git a/lib/sanitizer_common/sanitizer_common_libcdep.cc b/lib/sanitizer_common/sanitizer_common_libcdep.cc index 9095002aa..1b65bced7 100644 --- a/lib/sanitizer_common/sanitizer_common_libcdep.cc +++ b/lib/sanitizer_common/sanitizer_common_libcdep.cc @@ -12,7 +12,6 @@ //===----------------------------------------------------------------------===// #include "sanitizer_common.h" -#include "sanitizer_allocator_internal.h" #include "sanitizer_flags.h" #include "sanitizer_stackdepot.h" #include "sanitizer_stacktrace.h" @@ -47,7 +46,6 @@ void SetSandboxingCallback(void (*f)()) { } void ReportErrorSummary(const char *error_type, StackTrace *stack) { -#if !SANITIZER_GO if (!common_flags()->print_summary) return; if (stack->size == 0) { @@ -60,7 +58,6 @@ void ReportErrorSummary(const char *error_type, StackTrace *stack) { SymbolizedStack *frame = Symbolizer::GetOrInit()->SymbolizePC(pc); ReportErrorSummary(error_type, frame->info); frame->ClearAll(); -#endif } static void (*SoftRssLimitExceededCallback)(bool exceeded); @@ -119,30 +116,8 @@ void BackgroundThread(void *arg) { } } -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 && \ - !SANITIZER_GO // Need to implement/test on other platforms. +#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; diff --git a/lib/sanitizer_common/sanitizer_common_nolibc.cc b/lib/sanitizer_common/sanitizer_common_nolibc.cc index 89c17e079..65d1e37f6 100644 --- a/lib/sanitizer_common/sanitizer_common_nolibc.cc +++ b/lib/sanitizer_common/sanitizer_common_nolibc.cc @@ -18,9 +18,9 @@ namespace __sanitizer { #if SANITIZER_LINUX -bool ShouldLogAfterPrintf() { return false; } -#endif void WriteToSyslog(const char *buffer) {} +#endif + void Abort() { internal__exit(1); } } // namespace __sanitizer diff --git a/lib/sanitizer_common/sanitizer_flags.inc b/lib/sanitizer_common/sanitizer_flags.inc index 3b685db5a..e742d8546 100644 --- a/lib/sanitizer_common/sanitizer_flags.inc +++ b/lib/sanitizer_common/sanitizer_flags.inc @@ -56,7 +56,7 @@ COMMON_FLAG( "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 || SANITIZER_MAC, + bool, log_to_syslog, SANITIZER_ANDROID, "Write all sanitizer output to syslog in addition to other means of " "logging.") COMMON_FLAG( diff --git a/lib/sanitizer_common/sanitizer_linux_libcdep.cc b/lib/sanitizer_common/sanitizer_linux_libcdep.cc index 0e2a33420..4b583bfa4 100644 --- a/lib/sanitizer_common/sanitizer_linux_libcdep.cc +++ b/lib/sanitizer_common/sanitizer_linux_libcdep.cc @@ -507,16 +507,16 @@ void AndroidLogInit() { atomic_store(&android_log_initialized, 1, memory_order_release); } -bool ShouldLogAfterPrintf() { +static bool IsSyslogAvailable() { return atomic_load(&android_log_initialized, memory_order_acquire); } #else void AndroidLogInit() {} -bool ShouldLogAfterPrintf() { return true; } +static bool IsSyslogAvailable() { return true; } #endif // SANITIZER_ANDROID -void WriteOneLineToSyslog(const char *s) { +static void WriteOneLineToSyslog(const char *s) { #if SANITIZER_ANDROID &&__ANDROID_API__ < 21 __android_log_write(ANDROID_LOG_INFO, NULL, s); #else @@ -524,6 +524,24 @@ void WriteOneLineToSyslog(const char *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 diff --git a/lib/sanitizer_common/sanitizer_mac.cc b/lib/sanitizer_common/sanitizer_mac.cc index 951a48a71..3151cf8b9 100644 --- a/lib/sanitizer_common/sanitizer_mac.cc +++ b/lib/sanitizer_common/sanitizer_mac.cc @@ -36,14 +36,12 @@ extern char **environ; #endif -#include #include #include #include #include #include #include -#include #include #include #include @@ -373,45 +371,6 @@ uptr GetRSS() { 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) { } diff --git a/lib/sanitizer_common/sanitizer_printf.cc b/lib/sanitizer_common/sanitizer_printf.cc index 2794e667e..5f4725ec1 100644 --- a/lib/sanitizer_common/sanitizer_printf.cc +++ b/lib/sanitizer_common/sanitizer_printf.cc @@ -278,7 +278,7 @@ static void SharedPrintfCode(bool append_pid, const char *format, # undef CHECK_NEEDED_LENGTH } RawWrite(buffer); - if (common_flags()->log_to_syslog && ShouldLogAfterPrintf()) + if (common_flags()->log_to_syslog) WriteToSyslog(buffer); CallPrintfAndReportCallback(buffer); // If we had mapped any memory, clean up. diff --git a/lib/sanitizer_common/tests/sanitizer_common_test.cc b/lib/sanitizer_common/tests/sanitizer_common_test.cc index 6fc308ad1..c1bb797db 100644 --- a/lib/sanitizer_common/tests/sanitizer_common_test.cc +++ b/lib/sanitizer_common/tests/sanitizer_common_test.cc @@ -208,30 +208,6 @@ TEST(SanitizerCommon, StripPathPrefix) { 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()); -- cgit v1.2.3