[sanitizer] Use runtime checks instead of API level for Android logging

[cryptoad]

Summary

Recent Bionic have a slew of async_safe_* logging functions that are
basically the liblog ones but included within the libc. They have the advantage
of not allocating memory. async_safe_write_log does no formatting and is
likely the best candidate for logging.

Use a weak definition to try and use it. Also, avoid API level checks (as
the toolchain is compiled at a rather low API level) for __android_log_write
in favor of a weak definition as well.

Keep the fallback to syslog if nothing else was found.

I tried to overhaul the code block to only have a single #if SANITIZER_ANDROID
but I am not particularly attached to the form. LMKWYT.

[eugenis]

lib/sanitizer_common/sanitizer_linux_libcdep.cc

542

Please preserve the comment about syslog being broken pre-L. This is another reason why we prefer __android_log_write when both are available.

__android_log_write may not allocate memory, but it does call pthread_mutex_lock sometimes.

567

nullptr

[cryptoad]

Addressing review comments.

[cryptoad]

This seems to have made some tests on the Fugu device flaky:

• http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-android/builds/5028
• http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-android/builds/5029

[cryptoad]

Potential revert is here: https://reviews.llvm.org/D40138.

lib/sanitizer_common/sanitizer_linux_libcdep.cc

 #if SANITIZER_LINUX
 #include <sys/prctl.h>
 #endif
 
 #if SANITIZER_ANDROID
 #include <android/api-level.h>
 #endif
 
-#if SANITIZER_ANDROID && __ANDROID_API__ < 21
-#include <android/log.h>
-#endif
-
 #if !SANITIZER_ANDROID
 #include <elf.h>
 #include <unistd.h>
 #endif
 
 namespace __sanitizer {
 
 SANITIZER_WEAK_ATTRIBUTE int
while (!(*pos >= '0' && *pos <= '9') && *pos != 0)
     pos++;
   // Read the number.
   uptr rss = 0;
   while (*pos >= '0' && *pos <= '9')
     rss = rss * 10 + *pos++ - '0';
   return rss * GetPageSizeCached();
 }
 
-// 64-bit Android targets don't provide the deprecated __android_log_write.
-// Starting with the L release, syslog() works and is preferable to
-// __android_log_write.
 #if SANITIZER_LINUX
 
-#if SANITIZER_ANDROID
+# if SANITIZER_ANDROID
 static atomic_uint8_t android_log_initialized;
 
 void AndroidLogInit() {
   openlog(GetProcessName(), 0, LOG_USER);
   atomic_store(&android_log_initialized, 1, memory_order_release);
 }
 
 static bool ShouldLogAfterPrintf() {
   return atomic_load(&android_log_initialized, memory_order_acquire);
 }
-#else
-void AndroidLogInit() {}
-
-static bool ShouldLogAfterPrintf() { return true; }
-#endif  // SANITIZER_ANDROID
 
+extern "C" SANITIZER_WEAK_ATTRIBUTE
+int async_safe_write_log(int pri, const char* tag, const char* msg);
+extern "C" SANITIZER_WEAK_ATTRIBUTE
+int __android_log_write(int prio, const char* tag, const char* msg);
+
+// ANDROID_LOG_INFO is 4, but can't be resolved at runtime.
+#define SANITIZER_ANDROID_LOG_INFO 4
+
+// async_safe_write_log is basically __android_log_write but is only available
+// in recent versions of Bionic. __android_log_write was deprecated along the
+// way, so fallback to syslog if neither exists. The non-syslog alternatives
+// do not allocate memory and are preferable. Also syslog is broken pre-L, this
+// is another reason why we prefer __android_log_write if available.
 void WriteOneLineToSyslog(const char *s) {
-#if SANITIZER_ANDROID &&__ANDROID_API__ < 21
-  __android_log_write(ANDROID_LOG_INFO, NULL, s);
-#else
+  if (&async_safe_write_log) {
+    async_safe_write_log(SANITIZER_ANDROID_LOG_INFO, GetProcessName(), s);
+  } else if (&__android_log_write) {
+    __android_log_write(SANITIZER_ANDROID_LOG_INFO, nullptr, s);
+  } else {
     syslog(LOG_INFO, "%s", s);
-#endif
   }
-
-void LogMessageOnPrintf(const char *str) {
-  if (common_flags()->log_to_syslog && ShouldLogAfterPrintf())
-    WriteToSyslog(str);
 }
 
-#if SANITIZER_ANDROID
-extern "C" __attribute__((weak)) void android_set_abort_message(const char *);
+extern "C" SANITIZER_WEAK_ATTRIBUTE
+void android_set_abort_message(const char *);
+
 void SetAbortMessage(const char *str) {
-  if (&android_set_abort_message) android_set_abort_message(str);
+  if (&android_set_abort_message)
+    android_set_abort_message(str);
 }
-#else
+# else
+void AndroidLogInit() {}
+
+static bool ShouldLogAfterPrintf() { return true; }
+
+void WriteOneLineToSyslog(const char *s) { syslog(LOG_INFO, "%s", s); }
+
 void SetAbortMessage(const char *str) {}
-#endif
+# endif  // SANITIZER_ANDROID
+
+void LogMessageOnPrintf(const char *str) {
+  if (common_flags()->log_to_syslog && ShouldLogAfterPrintf())
+    WriteToSyslog(str);
+}
 
-#endif // SANITIZER_LINUX
+#endif  // SANITIZER_LINUX
 
 } // namespace __sanitizer
 
 #endif // SANITIZER_FREEBSD || SANITIZER_LINUX