X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fbacktrace.c;h=a9fde5d3160f02e65d718e3ade93a8e11fe8de14;hb=6793d7dd32d1fa48d2ee395e240e1b7ff857912e;hp=45a3ce569971b3dd28911ff9f675189e7b85ab68;hpb=be7adb92bf0012ab07adac2943e73772dfad7911;p=sbcl.git diff --git a/src/runtime/backtrace.c b/src/runtime/backtrace.c index 45a3ce5..a9fde5d 100644 --- a/src/runtime/backtrace.c +++ b/src/runtime/backtrace.c @@ -22,6 +22,7 @@ #include "interrupt.h" #include "lispregs.h" #ifdef LISP_FEATURE_GENCGC +#include #include "arch.h" #include "gencgc-alloc-region.h" #include "genesis/compiled-debug-fun.h" @@ -33,9 +34,11 @@ #include "thread.h" #ifdef LISP_FEATURE_OS_PROVIDES_DLADDR +# ifndef __USE_GNU /* __USE_GNU needed if we want dladdr() and Dl_Info from glibc. */ -#define __USE_GNU -#include "dlfcn.h" +# define __USE_GNU +# endif +# include "dlfcn.h" #endif #if !(defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)) @@ -107,13 +110,13 @@ cs_valid_pointer_p(struct call_frame *pointer) { struct thread *thread=arch_os_get_current_thread(); return (((char *) thread->control_stack_start <= (char *) pointer) && - ((char *) pointer < (char *) current_control_stack_pointer)); + ((char *) pointer < (char *) access_control_stack_pointer(thread))); } static void call_info_from_lisp_state(struct call_info *info) { - info->frame = (struct call_frame *)current_control_frame_pointer; + info->frame = (struct call_frame *)access_control_frame_pointer(arch_os_get_current_thread()); info->interrupted = 0; info->code = NULL; info->lra = 0; @@ -164,7 +167,7 @@ previous_info(struct call_info *info) { struct call_frame *this_frame; struct thread *thread=arch_os_get_current_thread(); - int free; + int free_ici; if (!cs_valid_pointer_p(info->frame)) { printf("Bogus callee value (0x%08lx).\n", (unsigned long)info->frame); @@ -181,10 +184,10 @@ previous_info(struct call_info *info) if (info->lra == NIL) { /* We were interrupted. Find the correct signal context. */ - free = SymbolValue(FREE_INTERRUPT_CONTEXT_INDEX,thread)>>2; - while (free-- > 0) { + free_ici = fixnum_value(SymbolValue(FREE_INTERRUPT_CONTEXT_INDEX,thread)); + while (free_ici-- > 0) { os_context_t *context = - thread->interrupt_contexts[free]; + thread->interrupt_contexts[free_ici]; if ((struct call_frame *)(unsigned long) (*os_context_register_addr(context, reg_CFP)) == info->frame) { @@ -283,71 +286,59 @@ backtrace(int nframes) #else static int +altstack_pointer_p (void *p) { +#ifndef LISP_FEATURE_WIN32 + void* stack_start = ((void *)arch_os_get_current_thread()) + dynamic_values_bytes; + void* stack_end = stack_start + 32*SIGSTKSZ; + + return (p > stack_start && p <= stack_end); +#else + /* Win32 doesn't do altstack */ + return 0; +#endif +} + +static int stack_pointer_p (void *p) { - return (p < (void *) arch_os_get_current_thread()->control_stack_end - && p > (void *) &p - && (((unsigned long) p) & 3) == 0); + /* we are using sizeof(long) here, because that is the right value on both + * x86 and x86-64. (But note that false positives would not cause much harm + * given the heuristical nature of x86_call_context.) */ + unsigned long stack_alignment = sizeof(long); + + return (altstack_pointer_p(p) + || (p < (void *) arch_os_get_current_thread()->control_stack_end + && (p > (void *) &p || altstack_pointer_p(&p)) + && (((unsigned long) p) & (stack_alignment-1)) == 0)); } static int ra_pointer_p (void *ra) { + /* the check against 4096 is still a mystery to everyone interviewed about + * it, but recent changes to sb-sprof seem to suggest that such values + * do occur sometimes. */ return ((unsigned long) ra) > 4096 && !stack_pointer_p (ra); } static int x86_call_context (void *fp, void **ra, void **ocfp) { - void *lisp_ocfp; - void *lisp_ra; void *c_ocfp; void *c_ra; - int lisp_valid_p, c_valid_p; + int c_valid_p; if (!stack_pointer_p(fp)) return 0; c_ocfp = *((void **) fp); c_ra = *((void **) fp + 1); - lisp_ocfp = *((void **) fp - 1); - lisp_ra = *((void **) fp - 2); - lisp_valid_p = (lisp_ocfp > fp - && stack_pointer_p(lisp_ocfp) - && ra_pointer_p(lisp_ra)); c_valid_p = (c_ocfp > fp && stack_pointer_p(c_ocfp) && ra_pointer_p(c_ra)); - if (lisp_valid_p && c_valid_p) { - void *lisp_path_fp; - void *c_path_fp; - void *dummy; - - int lisp_path_p = x86_call_context(lisp_ocfp, &lisp_path_fp, &dummy); - int c_path_p = x86_call_context(c_ocfp, &c_path_fp, &dummy); - - if (lisp_path_p && c_path_p) { -#if defined __FreeBSD__ && __FreeBSD_version > 400000 - if (lisp_ocfp > c_ocfp) - *ra = lisp_ra, *ocfp = lisp_ocfp; - else - *ra = c_ra, *ocfp = c_ocfp; -#else - *ra = lisp_ra, *ocfp = lisp_ocfp; -#endif - } - else if (lisp_path_p) - *ra = lisp_ra, *ocfp = lisp_ocfp; - else if (c_path_p) - *ra = c_ra, *ocfp = c_ocfp; - else - return 0; - } - else if (lisp_valid_p) - *ra = lisp_ra, *ocfp = lisp_ocfp; - else if (c_valid_p) + if (c_valid_p) *ra = c_ra, *ocfp = c_ocfp; else return 0; @@ -383,7 +374,7 @@ debug_function_from_pc (struct code* code, void *pc) if (i == len) return ((struct compiled_debug_fun *) native_pointer(v->data[i - 1])); - if (offset >= fixnum_value(df->elsewhere_pc)) { + if (offset >= (unsigned long)fixnum_value(df->elsewhere_pc)) { struct compiled_debug_fun *p = ((struct compiled_debug_fun *) native_pointer(v->data[i + 1])); next_pc = fixnum_value(p->elsewhere_pc); @@ -398,6 +389,54 @@ debug_function_from_pc (struct code* code, void *pc) } static void +sbcl_putwc(wchar_t c, FILE *file) +{ +#ifdef LISP_FEATURE_OS_PROVIDES_PUTWC + putwc(c, file); +#else + if (c < 256) { + fputc(c, file); + } else { + fputc('?', file); + } +#endif +} + +static void +print_string (lispobj *object) +{ + int tag = widetag_of(*object); + struct vector *vector = (struct vector *) object; + +#define doit(TYPE) \ + do { \ + int i; \ + int n = fixnum_value(vector->length); \ + TYPE *data = (TYPE *) vector->data; \ + for (i = 0; i < n; i++) { \ + wchar_t c = (wchar_t) data[i]; \ + if (c == '\\' || c == '"') \ + putchar('\\'); \ + sbcl_putwc(c, stdout); \ + } \ + } while (0) + + switch (tag) { + case SIMPLE_BASE_STRING_WIDETAG: + doit(unsigned char); + break; +#ifdef SIMPLE_CHARACTER_STRING_WIDETAG + case SIMPLE_CHARACTER_STRING_WIDETAG: + doit(unsigned int); + break; +#endif + default: + printf("", tag); + } +#undef doit +} + +static void print_entry_name (lispobj name) { if (lowtag_of (name) == LIST_POINTER_LOWTAG) { @@ -412,33 +451,32 @@ print_entry_name (lispobj name) putchar(')'); } else if (lowtag_of(name) == OTHER_POINTER_LOWTAG) { lispobj *object = (lispobj *) native_pointer(name); - if (widetag_of(*object) == SYMBOL_HEADER_WIDETAG) { struct symbol *symbol = (struct symbol *) object; - struct vector *string; - if (symbol->package != NIL) { struct package *pkg = (struct package *) native_pointer(symbol->package); lispobj pkg_name = pkg->_name; - string = (struct vector *) native_pointer(pkg_name); - printf("%s::", (char *) string->data); + print_string(native_pointer(pkg_name)); + fputs("::", stdout); } - - object = (lispobj *) native_pointer(symbol->name); - string = (struct vector *) object; - printf("%s", (char *) string->data); + print_string(native_pointer(symbol->name)); } else if (widetag_of(*object) == SIMPLE_BASE_STRING_WIDETAG) { - struct vector *string = (struct vector *) object; - printf("\"%s\"", (char *) string->data); + putchar('"'); + print_string(object); + putchar('"'); #ifdef SIMPLE_CHARACTER_STRING_WIDETAG - } else if (widetag_of(*object) == SIMPLE_CHARACTER_STRING_WIDETAG) { - printf(""); /* FIXME */ + } else if (widetag_of(*object) == SIMPLE_CHARACTER_STRING_WIDETAG) { + putchar('"'); + print_string(object); + putchar('"'); #endif - } else + } else { printf("", (int) widetag_of(*object)); - } else + } + } else { printf("", (int) lowtag_of(name)); + } } static void @@ -457,18 +495,42 @@ print_entry_points (struct code *code) } void -backtrace(int nframes) +describe_thread_state(void) { - void *fp; - int i; - -#if defined(LISP_FEATURE_X86) - asm("movl %%ebp,%0" : "=g" (fp)); -#elif defined (LISP_FEATURE_X86_64) - asm("movq %%rbp,%0" : "=g" (fp)); -#else -#error "How did we get here?" + sigset_t mask; + struct thread *thread = arch_os_get_current_thread(); + struct interrupt_data *data = thread->interrupt_data; +#ifndef LISP_FEATURE_WIN32 + get_current_sigmask(&mask); + printf("Signal mask:\n"); + printf(" SIGALRM = %d\n", sigismember(&mask, SIGALRM)); + printf(" SIGINT = %d\n", sigismember(&mask, SIGINT)); + printf(" SIGPROF = %d\n", sigismember(&mask, SIGPROF)); +#ifdef SIG_STOP_FOR_GC + printf(" SIG_STOP_FOR_GC = %d\n", sigismember(&mask, SIG_STOP_FOR_GC)); +#endif +#endif + printf("Specials:\n"); + printf(" *GC-INHIBIT* = %s\n", (SymbolValue(GC_INHIBIT, thread) == T) ? "T" : "NIL"); + printf(" *GC-PENDING* = %s\n", + (SymbolValue(GC_PENDING, thread) == T) ? + "T" : ((SymbolValue(GC_PENDING, thread) == NIL) ? + "NIL" : ":IN-PROGRESS")); + printf(" *INTERRUPTS-ENABLED* = %s\n", (SymbolValue(INTERRUPTS_ENABLED, thread) == T) ? "T" : "NIL"); +#ifdef STOP_FOR_GC_PENDING + printf(" *STOP-FOR-GC-PENDING* = %s\n", (SymbolValue(STOP_FOR_GC_PENDING, thread) == T) ? "T" : "NIL"); #endif + printf("Pending handler = %p\n", data->pending_handler); +} + +/* This function has been split from backtrace() to enable Lisp + * backtraces from gdb with call backtrace_from_fp(...). Useful for + * example when debugging threading deadlocks. + */ +void +backtrace_from_fp(void *fp, int nframes) +{ + int i; for (i = 0; i < nframes; ++i) { lispobj *p; @@ -508,4 +570,20 @@ backtrace(int nframes) } } +void +backtrace(int nframes) +{ + void *fp; + +#if defined(LISP_FEATURE_X86) + asm("movl %%ebp,%0" : "=g" (fp)); +#elif defined (LISP_FEATURE_X86_64) + asm("movq %%rbp,%0" : "=g" (fp)); +#else +#error "How did we get here?" +#endif + + backtrace_from_fp(fp, nframes); +} + #endif