pstack.c File Reference

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/ptrace.h>
#include <asm/ptrace.h>
#include <assert.h>
#include <fcntl.h>
#include <link.h>
#include <malloc.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <signal.h>
#include <pthread.h>
#include <limits.h>
#include <bfd.h>
#include "libiberty.h"
#include "pstack.h"
#include "budbg.h"
#include "bucomm.h"
#include "debug.h"
#include "linuxthreads.h"

Go to the source code of this file.

Data Structures
struct	debug_block_st
struct	debug_function_t
struct	debug_lineno_t
struct	debug_parameter_t
struct	pr_handle
struct	pr_stack
struct	signal_regs_t
struct	symbol_data_t
Defines
#define	MAXARGS   6
Typedefs
typedef debug_block_st	debug_block_t
Functions
static boolean	append_type (struct pr_handle *info, const char *s)
static int	compare_debug_function_t (const void *ap, const void *bp)
static int	compare_symbols (const void *ap, const void *bp)
static void	decode_symbol (symbol_data_t *symbol_data, const unsigned long addr, char *buf, const int bufsize)
int	fdprintf (int fd, const char *fmt,...)
int	fdputc (char c, int fd)
int	fdputs (const char *s, int fd)
static debug_function_t *	find_debug_function_t (symbol_data_t *symbol_data, const pid_t pid, const unsigned long fp, const unsigned long addr, char *buf, const int bufsize)
static void	indent (struct pr_handle *info)
static boolean	indent_type (struct pr_handle *info)
static bfd *	load_bfd (const int pid)
static int	my_crawl (int pid, symbol_data_t *symbol_data, int fout)
static int	my_ptrace (int request, int pid, int addr, int data)
static int	open_log_file (const pthread_t tid, const pid_t pid)
static void indent	PARAMS ((struct pr_handle *))
static char *	pop_type (struct pr_handle *info)
static boolean	pr_array_type (PTR p, bfd_signed_vma lower, bfd_signed_vma upper, boolean stringp)
static boolean	pr_bool_type (PTR p, unsigned int size)
static boolean	pr_class_baseclass (PTR p, bfd_vma bitpos, boolean virtual, enum debug_visibility visibility)
static boolean	pr_class_end_method (PTR p)
static boolean	pr_class_method_variant (PTR p, const char *physname, enum debug_visibility visibility, boolean constp, boolean volatilep, bfd_vma voffset, boolean context)
static boolean	pr_class_start_method (PTR p, const char *name)
static boolean	pr_class_static_member (PTR p, const char *name, const char *physname, enum debug_visibility visibility)
static boolean	pr_class_static_method_variant (PTR p, const char *physname, enum debug_visibility visibility, boolean constp, boolean volatilep)
static boolean	pr_complex_type (PTR p, unsigned int size)
static boolean	pr_const_type (PTR p)
static boolean	pr_empty_type (PTR p)
static boolean	pr_end_block (PTR p, bfd_vma addr)
static boolean	pr_end_class_type (PTR p)
static boolean	pr_end_function (PTR p)
static boolean	pr_end_struct_type (PTR p)
static boolean	pr_enum_type (PTR p, const char *tag, const char **names, bfd_signed_vma *values)
static boolean	pr_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
static boolean	pr_float_constant (PTR p, const char *name, double val)
static boolean	pr_float_type (PTR p, unsigned int size)
static boolean	pr_function_parameter (PTR p, const char *name, enum debug_parm_kind kind, bfd_vma val)
static boolean	pr_function_type (PTR p, int argcount, boolean varargs)
static boolean	pr_int_constant (PTR p, const char *name, bfd_vma val)
static boolean	pr_int_type (PTR p, unsigned int size, boolean unsignedp)
static boolean	pr_lineno (PTR p, const char *filename, unsigned long lineno, bfd_vma addr)
static boolean	pr_method_type (PTR p, boolean domain, int argcount, boolean varargs)
static boolean	pr_offset_type (PTR p)
static boolean	pr_pointer_type (PTR p)
static boolean	pr_range_type (PTR p, bfd_signed_vma lower, bfd_signed_vma upper)
static boolean	pr_reference_type (PTR p)
static boolean	pr_set_type (PTR p, boolean bitstringp)
static boolean	pr_start_block (PTR p, bfd_vma addr)
static boolean	pr_start_class_type (PTR p, const char *tag, unsigned int id, boolean structp, unsigned int size, boolean vptr, boolean ownvptr)
static boolean	pr_start_compilation_unit (PTR p, const char *filename)
static boolean	pr_start_function (PTR p, const char *name, boolean global)
static boolean	pr_start_source (PTR p, const char *filename)
static boolean	pr_start_struct_type (PTR p, const char *tag, unsigned int id, boolean structp, unsigned int size)
static boolean	pr_struct_field (PTR p, const char *name, bfd_vma bitpos, bfd_vma bitsize, enum debug_visibility visibility)
static boolean	pr_tag (PTR p, const char *name)
static boolean	pr_tag_type (PTR p, const char *name, unsigned int id, enum debug_type_kind kind)
static boolean	pr_typdef (PTR p, const char *name)
static boolean	pr_typed_constant (PTR p, const char *name, bfd_vma val)
static boolean	pr_typedef_type (PTR p, const char *name)
static boolean	pr_variable (PTR p, const char *name, enum debug_var_kind kind, bfd_vma val)
static boolean	pr_void_type (PTR p)
static boolean	pr_volatile_type (PTR p)
static boolean	prepend_type (struct pr_handle *info, const char *s)
static void	print_vma (bfd_vma vma, char *buf, boolean unsignedp, boolean hexp)
int	pstack_install_segv_action (const char *path_format_)
static boolean	push_type (struct pr_handle *info, const char *type)
static long	remove_useless_symbols (asymbol **symbols, long count)
static void	report_action (int signo, siginfo_t *siginfo, void *ptr)
static void	segv_action (int signo, siginfo_t *siginfo, void *ptr)
static void	show_regs (signal_regs_t *regs, int fd)
static boolean	substitute_type (struct pr_handle *info, const char *s)
Variables
static bfd *	abfd = 0
static PTR	dhandle = 0
static debug_function_t **	functions = 0
static int	functions_size = 0
static const char *	path_format = "stack-trace-on-segv-%d.txt"
static const struct debug_write_fns	pr_fns
signal_regs_t *	ptrace_regs = 0
static pid_t	segv_pid
static pthread_t	segv_tid
static int	sigreport = SIGUSR1
static long	sorted_symcount = 0
static asymbol **	sorted_syms = 0
static long	symcount = 0
static asymbol **	syms = 0

---

Define Documentation

#define MAXARGS   6

Definition at line 2162 of file pstack.c.

---

Typedef Documentation

typedef struct debug_block_st debug_block_t

---

Function Documentation

static boolean append_type (  struct pr_handle *  info, const char *  s )  [static]

Definition at line 389 of file pstack.c. References assert, len, NULL, and xrealloc(). Referenced by indent_type(), pr_array_type(), pr_class_baseclass(), pr_class_method_variant(), pr_class_static_member(), pr_class_static_method_variant(), pr_enum_type(), pr_fix_visibility(), pr_offset_type(), pr_range_type(), pr_set_type(), pr_start_class_type(), pr_start_struct_type(), pr_struct_field(), pr_tag_type(), and substitute_type(). { unsigned int len; if (s == NULL) return false; assert (info->stack != NULL); len = strlen (info->stack->type); info->stack->type = (char *) xrealloc (info->stack->type, len + strlen (s) + 1); strcpy (info->stack->type + len, s); return true; }

static int compare_debug_function_t (  const void *  ap, const void *  bp )  [static]

Definition at line 2491 of file pstack.c. References assert, debug_block_st::begin_addr, and debug_function_t::block. Referenced by pstack_install_segv_action(). { const debug_function_t *a = *(const debug_function_t **)ap; const debug_function_t *b = *(const debug_function_t **)bp; assert(a->block!=0); assert(b->block!=0); { const bfd_vma addr1 = a->block->begin_addr; const bfd_vma addr2 = b->block->begin_addr; if (addr1 > addr2) return 1; else if (addr2 > addr1) return -1; } return 0; }

static int compare_symbols (  const void *  ap, const void *  bp )  [static]

Definition at line 2475 of file pstack.c. Referenced by pstack_install_segv_action(). { const asymbol *a = *(const asymbol **)ap; const asymbol *b = *(const asymbol **)bp; if (bfd_asymbol_value (a) > bfd_asymbol_value (b)) return 1; else if (bfd_asymbol_value (a) < bfd_asymbol_value (b)) return -1; return 0; }

static void decode_symbol (  symbol_data_t *  symbol_data, const unsigned long  addr, char *  buf, const int  bufsize )  [static]

Definition at line 2178 of file pstack.c. References name, symbol_data_t::symcount, symcount, symbol_data_t::syms, syms, and top. Referenced by my_crawl(). { asymbol** syms = symbol_data->syms; const int symcount = symbol_data->symcount; int bottom = 0; int top = symcount - 1; int i; if (symcount==0) { sprintf(buf, "????"); return; } while (top>bottom+1) { i = (top+bottom) / 2; if (bfd_asymbol_value(syms[i])==addr) { sprintf(buf, "%s", syms[i]->name); return; } else if (bfd_asymbol_value(syms[i]) > addr) top = i; else bottom = i; } i = bottom; if (addr<bfd_asymbol_value(syms[i]) || addr>(syms[i]->section->vma+syms[i]->section->_cooked_size)) sprintf(buf, "????"); else sprintf(buf, "%s + 0x%lx", syms[i]->name, addr-bfd_asymbol_value(syms[i])); }

int fdprintf (  int  fd, const char *  fmt,   ... )

Definition at line 83 of file pstack.c. References vsnprintf, and write(). Referenced by my_crawl(), report_action(), segv_action(), and show_regs(). { char xbuf[2048];// FIXME: enough? va_list ap; int r; if (fd<0) return -1; va_start(ap, fmt); r = vsnprintf(xbuf, sizeof(xbuf), fmt, ap); va_end(ap); return write(fd, xbuf, r); }

int fdputc (  char  c, int  fd )

Definition at line 98 of file pstack.c. References write(). Referenced by my_crawl(). { if (fd<0) return -1; return write(fd, &c, sizeof(c)); }

int fdputs (  const char *  s, int  fd )

Definition at line 107 of file pstack.c. References write(). Referenced by my_crawl(). { if (fd<0) return -1; return write(fd, s, strlen(s)); }

static debug_function_t* find_debug_function_t (  symbol_data_t *  symbol_data, const pid_t  pid, const unsigned long  fp, const unsigned long  addr, char *  buf, const int  bufsize )  [static]

Definition at line 2215 of file pstack.c. References debug_lineno_t::addr, arg, debug_function_t::argc, debug_function_t::argv, assert, debug_block_st::begin_addr, debug_function_t::block, yaSSL::block, debug_block_st::end_addr, errno, f(), debug_function_t::filename, symbol_data_t::functions, symbol_data_t::functions_size, debug_lineno_t::lineno, lineno, debug_function_t::lines, debug_function_t::lines_count, my_ptrace(), debug_parameter_t::name, debug_function_t::name, NULL, debug_parameter_t::offset, symcount, syms, and top. Referenced by my_crawl(). : not used! */ { debug_function_t** syms = symbol_data->functions; debug_function_t* f = NULL; debug_block_t* block = NULL; debug_lineno_t* lineno = NULL; const int symcount = symbol_data->functions_size; int bottom = 0; int top = symcount - 1; int i; char* bufptr = buf; if (symcount==0) { sprintf(buf, "????"); return NULL; } while (top>bottom+1) { i = (top+bottom) / 2; if (syms[i]->block->begin_addr==addr) { f = syms[i]; break; } else if (syms[i]->block->begin_addr > addr) top = i; else if (syms[i]->block->end_addr >= addr) { f = syms[i]; break; } else bottom = i; } i = bottom; if (f!=0) block = f->block; else { block = syms[i]->block; if (block->begin_addr>=addr && block->end_addr<=addr) f = syms[i]; } if (f==0) sprintf(buf, "????"); else { /* * Do the backtrace the GDB way... */ unsigned long arg; /* assert(f->lines_count>0); */ if (f->lines_count>0) { lineno = &f->lines[f->lines_count-1]; for (i=1; i<f->lines_count; ++i) if (f->lines[i].addr>addr) { lineno = &f->lines[i-1]; break; } } bufptr[0] = 0; bufptr += sprintf(bufptr, "%s+0x%lx (", f->name, addr-block->begin_addr); for (i=0; i<f->argc; ++i) { bufptr += sprintf(bufptr, "%s = ", f->argv[i].name); /* FIXME: better parameter printing */ errno = 0; arg = my_ptrace(PTRACE_PEEKDATA, pid, fp+f->argv[i].offset, 0); assert(errno==0); bufptr += sprintf(bufptr, "0x%x", arg); if (i!=f->argc-1) bufptr += sprintf(bufptr, ", "); } if (lineno!=0) bufptr += sprintf(bufptr, ") at %s:%d", f->filename, lineno->lineno); } return f; }

static void indent (  struct pr_handle *  info  )  [static]

Definition at line 334 of file pstack.c. References TRACE_PUTC. Referenced by indent_type(), pr_end_block(), pr_lineno(), pr_start_block(), pr_start_function(), and pr_variable(). { unsigned int i; for (i = 0; i < info->indent; i++) TRACE_PUTC ((' ', info->f)); }

static boolean indent_type (  struct pr_handle *  info  )  [static]

Definition at line 457 of file pstack.c. References append_type(), and indent(). Referenced by pr_class_method_variant(), pr_class_static_member(), pr_class_static_method_variant(), pr_fix_visibility(), pr_start_class_type(), pr_start_struct_type(), and pr_struct_field(). { unsigned int i; for (i = 0; i < info->indent; i++) { if (! append_type (info, " ")) return false; } return true; }

static bfd* load_bfd (  const int  pid  )  [static]

Definition at line 2435 of file pstack.c. References abfd, assert, bfd_nonfatal(), filename, free, list_matching_formats(), and NULL. Referenced by pstack_install_segv_action(). { char filename[512]; bfd* abfd = 0; /* Get the contents from procfs. */ #if 1 sprintf(filename, "/proc/%d/exe", pid); #else sprintf(filename, "crashing"); #endif if ((abfd = bfd_openr (filename, 0))== NULL) bfd_nonfatal (filename); else { char** matching; assert(bfd_check_format(abfd, bfd_archive)!=true); /* * There is no indication in BFD documentation that it should be done. * God knows why... */ if (!bfd_check_format_matches (abfd, bfd_object, &matching)) { bfd_nonfatal (bfd_get_filename (abfd)); if (bfd_get_error () == bfd_error_file_ambiguously_recognized) { list_matching_formats (matching); free (matching); } } } return abfd; }

static int my_crawl (  int  pid, symbol_data_t *  symbol_data, int  fout )  [static]

Definition at line 2296 of file pstack.c. References arg, buf, decode_symbol(), errno, f(), fdprintf(), fdputc(), fdputs(), find_debug_function_t(), fp, MAXARGS, my_ptrace(), and perror(). Referenced by report_action(), and segv_action(). { unsigned long pc = 0; unsigned long fp = 0; unsigned long nextfp; unsigned long nargs; unsigned long i; unsigned long arg; char buf[8096]; // FIXME: enough? debug_function_t* f = 0; errno = 0; pc = my_ptrace(PTRACE_PEEKUSER, pid, EIP * 4, 0); if (!errno) fp = my_ptrace(PTRACE_PEEKUSER, pid, EBP * 4, 0); if (!errno) { #if 1 f = find_debug_function_t(symbol_data, pid, fp, pc, buf, sizeof(buf)); fdprintf(fout,"0x%08lx: %s", pc, buf); for ( ; !errno && fp; ) { nextfp = my_ptrace(PTRACE_PEEKDATA, pid, fp, 0); if (errno) break; if (f==0) { nargs = (nextfp - fp - 8) / 4; if (nargs > MAXARGS) nargs = MAXARGS; if (nargs > 0) { fdputs(" (", fout); for (i = 1; i <= nargs; i++) { arg = my_ptrace(PTRACE_PEEKDATA, pid, fp + 4 * (i + 1), 0); if (errno) break; fdprintf(fout,"%lx", arg); if (i < nargs) fdputs(", ", fout); } fdputc(')', fout); nargs = nextfp - fp - 8 - (4 * nargs); if (!errno && nargs > 0) fdprintf(fout," + %lx\n", nargs); else fdputc('\n', fout); } else fdputc('\n', fout); } else fdputc('\n', fout); if (errno || !nextfp) break; pc = my_ptrace(PTRACE_PEEKDATA, pid, fp + 4, 0); fp = nextfp; if (errno) break; f = find_debug_function_t(symbol_data, pid, fp, pc, buf, sizeof(buf)); fdprintf(fout,"0x%08lx: %s", pc, buf); } #else /* 1 */ decode_symbol(symbol_data, pc, buf, sizeof(buf)); fdprintf(fout,"0x%08lx: %s", pc, buf); for ( ; !errno && fp; ) { nextfp = my_ptrace(PTRACE_PEEKDATA, pid, fp, 0); if (errno) break; nargs = (nextfp - fp - 8) / 4; if (nargs > MAXARGS) nargs = MAXARGS; if (nargs > 0) { fputs(" (", fout); for (i = 1; i <= nargs; i++) { arg = my_ptrace(PTRACE_PEEKDATA, pid, fp + 4 * (i + 1), 0); if (errno) break; fdprintf(fout,"%lx", arg); if (i < nargs) fputs(", ", fout); } fdputc(')', fout); nargs = nextfp - fp - 8 - (4 * nargs); if (!errno && nargs > 0) fdprintf(fout," + %lx\n", nargs); else fdputc('\n', fout); } else fdputc('\n', fout); if (errno || !nextfp) break; pc = my_ptrace(PTRACE_PEEKDATA, pid, fp + 4, 0); fp = nextfp; if (errno) break; decode_symbol(symbol_data, pc, buf, sizeof(buf)); fdprintf(fout,"0x%08lx: %s", pc, buf); } #endif /* !1 */ } if (errno) perror("my_crawl"); return errno; }

static int my_ptrace (  int  request, int  pid, int  addr, int  data )  [static]

Definition at line 2136 of file pstack.c. References assert, signal_regs_t::ebp, signal_regs_t::eip, and errno. Referenced by find_debug_function_t(), and my_crawl(). { if (ptrace_regs==0) return ptrace(request, pid, addr, data); /* we are tracing ourselves! */ switch (request) { case PTRACE_ATTACH: return 0; case PTRACE_CONT: return 0; case PTRACE_DETACH: return 0; case PTRACE_PEEKUSER: switch (addr / 4) { case EIP: return ptrace_regs->eip; case EBP: return ptrace_regs->ebp; default: assert(0); } case PTRACE_PEEKTEXT: /* FALLTHROUGH */ case PTRACE_PEEKDATA: return *(int*)(addr); default: assert(0); } errno = 1; /* what to do here? */ return 1; /* failed?! */ }

static int open_log_file (  const pthread_t  tid, const pid_t  pid )  [static]

Definition at line 121 of file pstack.c. References open(), path_format, perror(), S_IRUSR, S_IWUSR, and snprintf. Referenced by report_action(), and segv_action(). { char fname[PATH_MAX]; int r; snprintf(fname, sizeof(fname), path_format, tid, pid); r = open(fname, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR); if (r<0) perror("open"); return r; }

static void indent PARAMS (  (struct pr_handle *)   )  [static]

static char* pop_type (  struct pr_handle *  info  )  [static]

Definition at line 474 of file pstack.c. References assert, free, pr_stack::next, NULL, and pr_stack::type. Referenced by pr_array_type(), pr_class_baseclass(), pr_class_method_variant(), pr_class_static_member(), pr_class_static_method_variant(), pr_function_parameter(), pr_function_type(), pr_method_type(), pr_offset_type(), pr_start_class_type(), pr_start_function(), pr_struct_field(), pr_tag(), pr_typdef(), pr_typed_constant(), and pr_variable(). { struct pr_stack *o; char *ret; assert (info->stack != NULL); o = info->stack; info->stack = o->next; ret = o->type; free (o); return ret; }

static boolean pr_array_type (  PTR  p, bfd_signed_vma  lower, bfd_signed_vma  upper, boolean  stringp )  [static]

Definition at line 837 of file pstack.c. References append_type(), info, NULL, pop_type(), print_vma(), and substitute_type(). { struct pr_handle *info = (struct pr_handle *) p; char *range_type; char abl[20], abu[20], ab[50]; range_type = pop_type (info); if (range_type == NULL) return false; if (lower == 0) { if (upper == -1) sprintf (ab, "|[]"); else { print_vma (upper + 1, abu, false, false); sprintf (ab, "|[%s]", abu); } } else { print_vma (lower, abl, false, false); print_vma (upper, abu, false, false); sprintf (ab, "|[%s:%s]", abl, abu); } if (! substitute_type (info, ab)) return false; if (strcmp (range_type, "int") != 0) { if (! append_type (info, ":") || ! append_type (info, range_type)) return false; } if (stringp) { if (! append_type (info, " /* string */")) return false; } return true; }

static boolean pr_bool_type (  PTR  p, unsigned int  size )  [static]

Definition at line 622 of file pstack.c. References info, and push_type(). { struct pr_handle *info = (struct pr_handle *) p; char ab[10]; sprintf (ab, "bool%d", size * 8); return push_type (info, ab); }

static boolean pr_class_baseclass (  PTR  p, bfd_vma  bitpos, boolean  virtual, enum debug_visibility  visibility )  [static]

Definition at line 1373 of file pstack.c. References append_type(), assert, DEBUG_VISIBILITY_PRIVATE, DEBUG_VISIBILITY_PROTECTED, DEBUG_VISIBILITY_PUBLIC, free, info, memcpy, n, pr_stack::next, NULL, pop_type(), prepend_type(), print_vma(), push_type(), pr_handle::stack, strchr(), substitute_type(), and xmalloc(). { struct pr_handle *info = (struct pr_handle *) p; char *t; const char *prefix; char ab[20]; char *s, *l, *n; assert (info->stack != NULL && info->stack->next != NULL); if (! substitute_type (info, "")) return false; t = pop_type (info); if (t == NULL) return false; if (strncmp (t, "class ", sizeof "class " - 1) == 0) t += sizeof "class " - 1; /* Push it back on to take advantage of the prepend_type and append_type routines. */ if (! push_type (info, t)) return false; if (virtual) { if (! prepend_type (info, "virtual ")) return false; } switch (visibility) { case DEBUG_VISIBILITY_PUBLIC: prefix = "public "; break; case DEBUG_VISIBILITY_PROTECTED: prefix = "protected "; break; case DEBUG_VISIBILITY_PRIVATE: prefix = "private "; break; default: prefix = "/* unknown visibility */ "; break; } if (! prepend_type (info, prefix)) return false; if (bitpos != 0) { print_vma (bitpos, ab, true, false); if (! append_type (info, " /* bitpos ") || ! append_type (info, ab) || ! append_type (info, " */")) return false; } /* Now the top of the stack is something like "public A / * bitpos 10 * /". The next element on the stack is something like "class xx { / * size 8 * /\n...". We want to substitute the top of the stack in before the {. */ s = strchr (info->stack->next->type, '{'); assert (s != NULL); --s; /* If there is already a ':', then we already have a baseclass, and we must append this one after a comma. */ for (l = info->stack->next->type; l != s; l++) if (*l == ':') break; if (! prepend_type (info, l == s ? " : " : ", ")) return false; t = pop_type (info); if (t == NULL) return false; n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1); memcpy (n, info->stack->type, s - info->stack->type); strcpy (n + (s - info->stack->type), t); strcat (n, s); free (info->stack->type); info->stack->type = n; free (t); return true; }

static boolean pr_class_end_method (  PTR  p  )  [static]

Definition at line 1625 of file pstack.c. References info, pr_stack::method, NULL, and pr_handle::stack. { struct pr_handle *info = (struct pr_handle *) p; info->stack->method = NULL; return true; }

static boolean pr_class_method_variant (  PTR  p, const char *  physname, enum debug_visibility  visibility, boolean  constp, boolean  volatilep, bfd_vma  voffset, boolean  context )  [static]

Definition at line 1486 of file pstack.c. References append_type(), assert, indent_type(), info, pr_stack::next, NULL, pop_type(), pr_fix_visibility(), print_vma(), pr_handle::stack, and substitute_type(