debugger_posix.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "base/debug/debugger.h"
6#include "build/build_config.h"
7
8#include <errno.h>
9#include <fcntl.h>
10#include <stdio.h>
11#include <stdlib.h>
12#include <sys/param.h>
13#include <sys/stat.h>
14#include <sys/types.h>
15#include <unistd.h>
16
17#include <string>
18#include <vector>
19
20#if !defined(OS_ANDROID) && !defined(OS_NACL)
21#include <execinfo.h>
22#endif
23
24#if defined(__GLIBCXX__)
25#include <cxxabi.h>
26#endif
27
28#if defined(OS_MACOSX)
29#include <AvailabilityMacros.h>
30#endif
31
32#if defined(OS_MACOSX) || defined(OS_BSD)
33#include <sys/sysctl.h>
34#endif
35
36#if defined(OS_FREEBSD)
37#include <sys/user.h>
38#endif
39
40#include <ostream>
41
42#include "base/basictypes.h"
43#include "base/logging.h"
44#include "base/memory/scoped_ptr.h"
45#include "base/posix/eintr_wrapper.h"
46#include "base/safe_strerror_posix.h"
47#include "base/stringprintf.h"
48#include "base/strings/string_piece.h"
49
50#if defined(USE_SYMBOLIZE)
51#include "base/third_party/symbolize/symbolize.h"
52#endif
53
54#if defined(OS_ANDROID)
55#include "base/threading/platform_thread.h"
56#endif
57
58namespace base {
59namespace debug {
60
61bool SpawnDebuggerOnProcess(unsigned process_id) {
62#if OS_ANDROID || OS_NACL
63  NOTIMPLEMENTED();
64  return false;
65#else
66  const std::string debug_cmd =
67      StringPrintf("xterm -e 'gdb --pid=%u' &", process_id);
68  LOG(WARNING) << "Starting debugger on pid " << process_id
69               << " with command `" << debug_cmd << "`";
70  int ret = system(debug_cmd.c_str());
71  if (ret == -1)
72    return false;
73  return true;
74#endif
75}
76
77#if defined(OS_MACOSX) || defined(OS_BSD)
78
79// Based on Apple's recommended method as described in
80// http://developer.apple.com/qa/qa2004/qa1361.html
81bool BeingDebugged() {
82  // NOTE: This code MUST be async-signal safe (it's used by in-process
83  // stack dumping signal handler). NO malloc or stdio is allowed here.
84  //
85  // While some code used below may be async-signal unsafe, note how
86  // the result is cached (see |is_set| and |being_debugged| static variables
87  // right below). If this code is properly warmed-up early
88  // in the start-up process, it should be safe to use later.
89
90  // If the process is sandboxed then we can't use the sysctl, so cache the
91  // value.
92  static bool is_set = false;
93  static bool being_debugged = false;
94
95  if (is_set)
96    return being_debugged;
97
98  // Initialize mib, which tells sysctl what info we want.  In this case,
99  // we're looking for information about a specific process ID.
100  int mib[] = {
101    CTL_KERN,
102    KERN_PROC,
103    KERN_PROC_PID,
104    getpid()
105#if defined(OS_OPENBSD)
106    , sizeof(struct kinfo_proc),
107    0
108#endif
109  };
110
111  // Caution: struct kinfo_proc is marked __APPLE_API_UNSTABLE.  The source and
112  // binary interfaces may change.
113  struct kinfo_proc info;
114  size_t info_size = sizeof(info);
115
116#if defined(OS_OPENBSD)
117  if (sysctl(mib, arraysize(mib), NULL, &info_size, NULL, 0) < 0)
118    return -1;
119
120  mib[5] = (info_size / sizeof(struct kinfo_proc));
121#endif
122
123  int sysctl_result = sysctl(mib, arraysize(mib), &info, &info_size, NULL, 0);
124  DCHECK_EQ(sysctl_result, 0);
125  if (sysctl_result != 0) {
126    is_set = true;
127    being_debugged = false;
128    return being_debugged;
129  }
130
131  // This process is being debugged if the P_TRACED flag is set.
132  is_set = true;
133#if defined(OS_FREEBSD)
134  being_debugged = (info.ki_flag & P_TRACED) != 0;
135#elif defined(OS_BSD)
136  being_debugged = (info.p_flag & P_TRACED) != 0;
137#else
138  being_debugged = (info.kp_proc.p_flag & P_TRACED) != 0;
139#endif
140  return being_debugged;
141}
142
143#elif defined(OS_LINUX) || defined(OS_ANDROID)
144
145// We can look in /proc/self/status for TracerPid.  We are likely used in crash
146// handling, so we are careful not to use the heap or have side effects.
147// Another option that is common is to try to ptrace yourself, but then we
148// can't detach without forking(), and that's not so great.
149// static
150bool BeingDebugged() {
151  // NOTE: This code MUST be async-signal safe (it's used by in-process
152  // stack dumping signal handler). NO malloc or stdio is allowed here.
153
154  int status_fd = open("/proc/self/status", O_RDONLY);
155  if (status_fd == -1)
156    return false;
157
158  // We assume our line will be in the first 1024 characters and that we can
159  // read this much all at once.  In practice this will generally be true.
160  // This simplifies and speeds up things considerably.
161  char buf[1024];
162
163  ssize_t num_read = HANDLE_EINTR(read(status_fd, buf, sizeof(buf)));
164  if (HANDLE_EINTR(close(status_fd)) < 0)
165    return false;
166
167  if (num_read <= 0)
168    return false;
169
170  StringPiece status(buf, num_read);
171  StringPiece tracer("TracerPid:\t");
172
173  StringPiece::size_type pid_index = status.find(tracer);
174  if (pid_index == StringPiece::npos)
175    return false;
176
177  // Our pid is 0 without a debugger, assume this for any pid starting with 0.
178  pid_index += tracer.size();
179  return pid_index < status.size() && status[pid_index] != '0';
180}
181
182#else
183
184bool BeingDebugged() {
185  NOTIMPLEMENTED();
186  return false;
187}
188
189#endif
190
191// We want to break into the debugger in Debug mode, and cause a crash dump in
192// Release mode. Breakpad behaves as follows:
193//
194// +-------+-----------------+-----------------+
195// | OS    | Dump on SIGTRAP | Dump on SIGABRT |
196// +-------+-----------------+-----------------+
197// | Linux |       N         |        Y        |
198// | Mac   |       Y         |        N        |
199// +-------+-----------------+-----------------+
200//
201// Thus we do the following:
202// Linux: Debug mode, send SIGTRAP; Release mode, send SIGABRT.
203// Mac: Always send SIGTRAP.
204
205#if defined(NDEBUG) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
206#define DEBUG_BREAK() abort()
207#elif defined(OS_NACL)
208// The NaCl verifier doesn't let use use int3.  For now, we call abort().  We
209// should ask for advice from some NaCl experts about the optimum thing here.
210// http://code.google.com/p/nativeclient/issues/detail?id=645
211#define DEBUG_BREAK() abort()
212#elif defined(OS_ANDROID)
213// Though Android has a "helpful" process called debuggerd to catch native
214// signals on the general assumption that they are fatal errors. If no debugger
215// is attached, we call abort since Breakpad needs SIGABRT to create a dump.
216// When debugger is attached, for ARM platform the bkpt instruction appears
217// to cause SIGBUS which is trapped by debuggerd, and we've had great
218// difficulty continuing in a debugger once we stop from SIG triggered by native
219// code, use GDB to set |go| to 1 to resume execution; for X86 platform, use
220// "int3" to setup breakpiont and raise SIGTRAP.
221namespace {
222void DebugBreak() {
223  if (!BeingDebugged()) {
224    abort();
225  } else {
226#if defined(ARCH_CPU_X86_FAMILY)
227    asm("int3");
228#else
229    volatile int go = 0;
230    while (!go) {
231      base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
232    }
233#endif
234  }
235}
236}  // namespace
237#define DEBUG_BREAK() DebugBreak()
238#elif defined(ARCH_CPU_ARM_FAMILY)
239// ARM && !ANDROID
240#define DEBUG_BREAK() asm("bkpt 0")
241#elif defined(ARCH_CPU_MIPS_FAMILY)
242#define DEBUG_BREAK() asm("break 2")
243#else
244#define DEBUG_BREAK() asm("int3")
245#endif
246
247void BreakDebugger() {
248  // NOTE: This code MUST be async-signal safe (it's used by in-process
249  // stack dumping signal handler). NO malloc or stdio is allowed here.
250
251  DEBUG_BREAK();
252#if defined(OS_ANDROID) && !defined(OFFICIAL_BUILD)
253  // For Android development we always build release (debug builds are
254  // unmanageably large), so the unofficial build is used for debugging. It is
255  // helpful to be able to insert BreakDebugger() statements in the source,
256  // attach the debugger, inspect the state of the program and then resume it by
257  // setting the 'go' variable above.
258#elif defined(NDEBUG)
259  // Terminate the program after signaling the debug break.
260  _exit(1);
261#endif
262}
263
264}  // namespace debug
265}  // namespace base
266