Upstream android debug and log related files

base/debug/debugger_posix.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/debug/debugger.h"
 #include "build/build_config.h"
 
 #include <errno.h>
 #include <execinfo.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/param.h>
 #include <sys/stat.h>
-#if !defined(OS_NACL)
+#if !defined(OS_NACL) && !defined(OS_ANDROID)
 #include <sys/sysctl.h>
 #endif
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <string>
 #include <vector>
 
 #if defined(__GLIBCXX__)
 #include <cxxabi.h>
@@ skipping 10 matching lines @@
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/safe_strerror_posix.h"
 #include "base/string_piece.h"
 #include "base/stringprintf.h"
 
 #if defined(USE_SYMBOLIZE)
 #include "base/third_party/symbolize/symbolize.h"
 #endif
 
+#if defined(OS_ANDROID)
+#include <execinfo.h>
+#include "base/threading/platform_thread.h"
+#endif
+
 namespace base {
 namespace debug {
 
 bool SpawnDebuggerOnProcess(unsigned /* process_id */) {
   NOTIMPLEMENTED();
   return false;
 }
 
 #if defined(OS_MACOSX)
 
@@ skipping 30 matching lines @@
     being_debugged = false;
     return being_debugged;
   }
 
   // This process is being debugged if the P_TRACED flag is set.
   is_set = true;
   being_debugged = (info.kp_proc.p_flag & P_TRACED) != 0;
   return being_debugged;
 }
 
-#elif defined(OS_LINUX)
+#elif defined(OS_LINUX) || defined(OS_ANDROID)
 
 // We can look in /proc/self/status for TracerPid.  We are likely used in crash
 // handling, so we are careful not to use the heap or have side effects.
 // Another option that is common is to try to ptrace yourself, but then we
 // can't detach without forking(), and that's not so great.
 // static
 bool BeingDebugged() {
   int status_fd = open("/proc/self/status", O_RDONLY);
   if (status_fd == -1)
     return false;
@@ skipping 46 matching lines @@
 // | OS    | Dump on SIGTRAP | Dump on SIGABRT |
 // +-------+-----------------+-----------------+
 // | Linux |       N         |        Y        |
 // | Mac   |       Y         |        N        |
 // +-------+-----------------+-----------------+
 //
 // Thus we do the following:
 // Linux: Debug mode, send SIGTRAP; Release mode, send SIGABRT.
 // Mac: Always send SIGTRAP.
 
-#if defined(NDEBUG) && !defined(OS_MACOSX)
+#if defined(NDEBUG) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
 #define DEBUG_BREAK() abort()
 #elif defined(OS_NACL)
 // The NaCl verifier doesn't let use use int3.  For now, we call abort().  We
 // should ask for advice from some NaCl experts about the optimum thing here.
 // http://code.google.com/p/nativeclient/issues/detail?id=645
 #define DEBUG_BREAK() abort()
 #elif defined(ARCH_CPU_ARM_FAMILY)
+#if defined(OS_ANDROID)
+// Use GDB to set |go| to 1 to resume execution.
+#define DEBUG_BREAK() do { \
+  volatile int go = 0;             \
+  while (!go) { base::PlatformThread::Sleep(100); }   \
+} while (0)
+#else
+// ARM && !ANDROID
 #define DEBUG_BREAK() asm("bkpt 0")

[brettw, 2011/06/24 22:23:57]

Sorry I don't have much background in this. Why doesn't this generic ARM code
work on Android?

[michaelbai, 2011/06/24 23:30:44]

For this issue, I have to get it back to you later.

[John Grabowski, 2011/06/28 17:27:23]

In general, Android is Java based.  Android has a "helpful" process called
debuggerd to catch native signals on the general assumption that they are fatal
errors.  Although symptoms change from build to build, in general we've had
great difficulty continuing in a debugger once we stop from SIGINT triggered by
native code.  So we don't.

[brettw, 2011/06/29 16:42:28]

Can a comment be added to this effect?

[michaelbai, 2011/06/29 17:18:46]

Done.

+#endif
 #else
 #define DEBUG_BREAK() asm("int3")
 #endif
 
 void BreakDebugger() {
   DEBUG_BREAK();
 #if defined(NDEBUG)
   _exit(1);
 #endif
 }
 
 }  // namespace debug
 }  // namespace base