GTTF: Make Linux stack dump signal handler async-signal safe.

base/debug/debugger_posix.cc

 // Copyright (c) 2012 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 <fcntl.h>
 #include <stdio.h>
@@ skipping 61 matching lines @@
     return false;
   return true;
 #endif
 }
 
 #if defined(OS_MACOSX) || defined(OS_BSD)
 
 // Based on Apple's recommended method as described in
 // http://developer.apple.com/qa/qa2004/qa1361.html
 bool BeingDebugged() {
+  // NOTE: This code MUST be async-signal safe (it's used by in-process
+  // stack dumping signal handler). NO malloc or stdio is allowed here.
+  // While some code used below may be async-signal unsafe, note how

[jar (doing other things), 2012/11/02 02:36:57]

Please be specific (don't ask me to find the offending code).

I didn't see any statics... so I'm missing what you mean by cached.

[Paweł Hajdan Jr., 2012/11/06 17:58:46]

Done.

+  // the result is cached. If this code is properly warmed-up early
+  // in the start-up process, it should be safe to use later.
+
   // If the process is sandboxed then we can't use the sysctl, so cache the
   // value.
   static bool is_set = false;
   static bool being_debugged = false;
 
-  if (is_set) {
+  if (is_set)
     return being_debugged;
-  }
 
   // Initialize mib, which tells sysctl what info we want.  In this case,
   // we're looking for information about a specific process ID.
   int mib[] = {
     CTL_KERN,
     KERN_PROC,
     KERN_PROC_PID,
     getpid()
 #if defined(OS_OPENBSD)
     , sizeof(struct kinfo_proc),
@@ skipping 34 matching lines @@
 }
 
 #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() {
+  // NOTE: This code MUST be async-signal safe (it's used by in-process
+  // stack dumping signal handler). NO malloc or stdio is allowed here.
+
   int status_fd = open("/proc/self/status", O_RDONLY);
   if (status_fd == -1)
     return false;
 
   // We assume our line will be in the first 1024 characters and that we can
   // read this much all at once.  In practice this will generally be true.
   // This simplifies and speeds up things considerably.
   char buf[1024];
 
   ssize_t num_read = HANDLE_EINTR(read(status_fd, buf, sizeof(buf)));
@@ skipping 68 matching lines @@
 // ARM && !ANDROID
 #define DEBUG_BREAK() asm("bkpt 0")
 #endif
 #elif defined(ARCH_CPU_MIPS_FAMILY)
 #define DEBUG_BREAK() asm("break 2")
 #else
 #define DEBUG_BREAK() asm("int3")
 #endif
 
 void BreakDebugger() {
+  // NOTE: This code MUST be async-signal safe (it's used by in-process
+  // stack dumping signal handler). NO malloc or stdio is allowed here.
+
   DEBUG_BREAK();
 #if defined(OS_ANDROID) && !defined(OFFICIAL_BUILD)
   // For Android development we always build release (debug builds are
   // unmanageably large), so the unofficial build is used for debugging. It is
   // helpful to be able to insert BreakDebugger() statements in the source,
   // attach the debugger, inspect the state of the program and then resume it by
   // setting the 'go' variable above.
 #elif defined(NDEBUG)
   // Terminate the program after signaling the debug break.
   _exit(1);
 #endif
 }
 
 }  // namespace debug
 }  // namespace base