PageRenderTime 36ms CodeModel.GetById 13ms app.highlight 19ms RepoModel.GetById 2ms app.codeStats 0ms

/contrib/bind9/lib/isc/backtrace.c

https://bitbucket.org/freebsd/freebsd-head/
C | 285 lines | 164 code | 43 blank | 78 comment | 56 complexity | 3df113da5abd7f40e442f386f9a9a0c9 MD5 | raw file
  1/*
  2 * Copyright (C) 2009  Internet Systems Consortium, Inc. ("ISC")
  3 *
  4 * Permission to use, copy, modify, and/or distribute this software for any
  5 * purpose with or without fee is hereby granted, provided that the above
  6 * copyright notice and this permission notice appear in all copies.
  7 *
  8 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  9 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 10 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
 11 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 12 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 13 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 14 * PERFORMANCE OF THIS SOFTWARE.
 15 */
 16
 17/* $Id: backtrace.c,v 1.3 2009/09/02 23:48:02 tbox Exp $ */
 18
 19/*! \file */
 20
 21#include "config.h"
 22
 23#include <string.h>
 24#include <stdlib.h>
 25#ifdef HAVE_LIBCTRACE
 26#include <execinfo.h>
 27#endif
 28
 29#include <isc/backtrace.h>
 30#include <isc/result.h>
 31#include <isc/util.h>
 32
 33#ifdef ISC_PLATFORM_USEBACKTRACE
 34/*
 35 * Getting a back trace of a running process is tricky and highly platform
 36 * dependent.  Our current approach is as follows:
 37 * 1. If the system library supports the "backtrace()" function, use it.
 38 * 2. Otherwise, if the compiler is gcc and the architecture is x86_64 or IA64,
 39 *    then use gcc's (hidden) Unwind_Backtrace() function.  Note that this
 40 *    function doesn't work for C programs on many other architectures.
 41 * 3. Otherwise, if the architecture x86 or x86_64, try to unwind the stack
 42 *    frame following frame pointers.  This assumes the executable binary
 43 *    compiled with frame pointers; this is not always true for x86_64 (rather,
 44 *    compiler optimizations often disable frame pointers).  The validation
 45 *    checks in getnextframeptr() hopefully rejects bogus values stored in
 46 *    the RBP register in such a case.  If the backtrace function itself crashes
 47 *    due to this problem, the whole package should be rebuilt with
 48 *    --disable-backtrace.
 49 */
 50#ifdef HAVE_LIBCTRACE
 51#define BACKTRACE_LIBC
 52#elif defined(__GNUC__) && (defined(__x86_64__) || defined(__ia64__))
 53#define BACKTRACE_GCC
 54#elif defined(__x86_64__) || defined(__i386__)
 55#define BACKTRACE_X86STACK
 56#else
 57#define BACKTRACE_DISABLED
 58#endif  /* HAVE_LIBCTRACE */
 59#else	/* !ISC_PLATFORM_USEBACKTRACE */
 60#define BACKTRACE_DISABLED
 61#endif	/* ISC_PLATFORM_USEBACKTRACE */
 62
 63#ifdef BACKTRACE_LIBC
 64isc_result_t
 65isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) {
 66	int n;
 67
 68	/*
 69	 * Validate the arguments: intentionally avoid using REQUIRE().
 70	 * See notes in backtrace.h.
 71	 */
 72	if (addrs == NULL || nframes == NULL)
 73		return (ISC_R_FAILURE);
 74
 75	/*
 76	 * backtrace(3) includes this function itself in the address array,
 77	 * which should be eliminated from the returned sequence.
 78	 */
 79	n = backtrace(addrs, maxaddrs);
 80	if (n < 2)
 81		return (ISC_R_NOTFOUND);
 82	n--;
 83	memmove(addrs, &addrs[1], sizeof(void *) * n);
 84	*nframes = n;
 85	return (ISC_R_SUCCESS);
 86}
 87#elif defined(BACKTRACE_GCC)
 88extern int _Unwind_Backtrace(void* fn, void* a);
 89extern void* _Unwind_GetIP(void* ctx);
 90
 91typedef struct {
 92	void **result;
 93	int max_depth;
 94	int skip_count;
 95	int count;
 96} trace_arg_t;
 97
 98static int
 99btcallback(void *uc, void *opq) {
100	trace_arg_t *arg = (trace_arg_t *)opq;
101
102	if (arg->skip_count > 0)
103		arg->skip_count--;
104	else
105		arg->result[arg->count++] = (void *)_Unwind_GetIP(uc);
106	if (arg->count == arg->max_depth)
107		return (5); /* _URC_END_OF_STACK */
108
109	return (0); /* _URC_NO_REASON */
110}
111
112isc_result_t
113isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) {
114	trace_arg_t arg;
115
116	/* Argument validation: see above. */
117	if (addrs == NULL || nframes == NULL)
118		return (ISC_R_FAILURE);
119
120	arg.skip_count = 1;
121	arg.result = addrs;
122	arg.max_depth = maxaddrs;
123	arg.count = 0;
124	_Unwind_Backtrace(btcallback, &arg);
125
126	*nframes = arg.count;
127
128	return (ISC_R_SUCCESS);
129}
130#elif defined(BACKTRACE_X86STACK)
131#ifdef __x86_64__
132static unsigned long
133getrbp() {
134	__asm("movq %rbp, %rax\n");
135}
136#endif
137
138static void **
139getnextframeptr(void **sp) {
140	void **newsp = (void **)*sp;
141
142	/*
143	 * Perform sanity check for the new frame pointer, derived from
144	 * google glog.  This can actually be bogus depending on compiler.
145	 */
146
147	/* prohibit the stack frames from growing downwards */
148	if (newsp <= sp)
149		return (NULL);
150
151	/* A heuristics to reject "too large" frame: this actually happened. */
152	if ((char *)newsp - (char *)sp > 100000)
153		return (NULL);
154
155	/*
156	 * Not sure if other checks used in glog are needed at this moment.
157	 * For our purposes we don't have to consider non-contiguous frames,
158	 * for example.
159	 */
160
161	return (newsp);
162}
163
164isc_result_t
165isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) {
166	int i = 0;
167	void **sp;
168
169	/* Argument validation: see above. */
170	if (addrs == NULL || nframes == NULL)
171		return (ISC_R_FAILURE);
172
173#ifdef __x86_64__
174	sp = (void **)getrbp();
175	if (sp == NULL)
176		return (ISC_R_NOTFOUND);
177	/*
178	 * sp is the frame ptr of this function itself due to the call to
179	 * getrbp(), so need to unwind one frame for consistency.
180	 */
181	sp = getnextframeptr(sp);
182#else
183	/*
184	 * i386: the frame pointer is stored 2 words below the address for the
185	 * first argument.  Note that the body of this function cannot be
186	 * inlined since it depends on the address of the function argument.
187	 */
188	sp = (void **)&addrs - 2;
189#endif
190
191	while (sp != NULL && i < maxaddrs) {
192		addrs[i++] = *(sp + 1);
193		sp = getnextframeptr(sp);
194	}
195
196	*nframes = i;
197
198	return (ISC_R_SUCCESS);
199}
200#elif defined(BACKTRACE_DISABLED)
201isc_result_t
202isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) {
203	/* Argument validation: see above. */
204	if (addrs == NULL || nframes == NULL)
205		return (ISC_R_FAILURE);
206
207	UNUSED(maxaddrs);
208
209	return (ISC_R_NOTIMPLEMENTED);
210}
211#endif
212
213isc_result_t
214isc_backtrace_getsymbolfromindex(int index, const void **addrp,
215				 const char **symbolp)
216{
217	REQUIRE(addrp != NULL && *addrp == NULL);
218	REQUIRE(symbolp != NULL && *symbolp == NULL);
219
220	if (index < 0 || index >= isc__backtrace_nsymbols)
221		return (ISC_R_RANGE);
222
223	*addrp = isc__backtrace_symtable[index].addr;
224	*symbolp = isc__backtrace_symtable[index].symbol;
225	return (ISC_R_SUCCESS);
226}
227
228static int
229symtbl_compare(const void *addr, const void *entryarg) {
230	const isc_backtrace_symmap_t *entry = entryarg;
231	const isc_backtrace_symmap_t *end =
232		&isc__backtrace_symtable[isc__backtrace_nsymbols - 1];
233
234	if (isc__backtrace_nsymbols == 1 || entry == end) {
235		if (addr >= entry->addr) {
236			/*
237			 * If addr is equal to or larger than that of the last
238			 * entry of the table, we cannot be sure if this is
239			 * within a valid range so we consider it valid.
240			 */
241			return (0);
242		}
243		return (-1);
244	}
245
246	/* entry + 1 is a valid entry from now on. */
247	if (addr < entry->addr)
248		return (-1);
249	else if (addr >= (entry + 1)->addr)
250		return (1);
251	return (0);
252}
253
254isc_result_t
255isc_backtrace_getsymbol(const void *addr, const char **symbolp,
256			unsigned long *offsetp)
257{
258	isc_result_t result = ISC_R_SUCCESS;
259	isc_backtrace_symmap_t *found;
260
261	/*
262	 * Validate the arguments: intentionally avoid using REQUIRE().
263	 * See notes in backtrace.h.
264	 */
265	if (symbolp == NULL || *symbolp != NULL || offsetp == NULL)
266		return (ISC_R_FAILURE);
267
268	if (isc__backtrace_nsymbols < 1)
269		return (ISC_R_NOTFOUND);
270
271	/*
272	 * Search the table for the entry that meets:
273	 * entry.addr <= addr < next_entry.addr.
274	 */
275	found = bsearch(addr, isc__backtrace_symtable, isc__backtrace_nsymbols,
276			sizeof(isc__backtrace_symtable[0]), symtbl_compare);
277	if (found == NULL)
278		result = ISC_R_NOTFOUND;
279	else {
280		*symbolp = found->symbol;
281		*offsetp = (const char *)addr - (char *)found->addr;
282	}
283
284	return (result);
285}