~drizzle-trunk/drizzle/development

/* Copyright (C) 2000 MySQL AB

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/* Workaround for Bug#32082: VOID redefinition on Win results in compile errors*/

#define DONT_DEFINE_VOID 1

#include <my_global.h>

#include "stacktrace.h"

#include <signal.h>

#include <my_pthread.h>

#include <m_string.h>

#ifdef HAVE_STACKTRACE

#include <unistd.h>

#include <strings.h>

#if HAVE_EXECINFO_H

#include <execinfo.h>

#endif

#define PTR_SANE(p) ((p) && (char*)(p) >= heap_start && (char*)(p) <= heap_end)

char *heap_start;

void safe_print_str(const char* name, const char* val, int max_len)

{

  char *heap_end= (char*) sbrk(0);

  fprintf(stderr, "%s at %p ", name, val);

  if (!PTR_SANE(val))

  {

    fprintf(stderr, " is invalid pointer\n");

    return;

  }

  fprintf(stderr, "= ");

  for (; max_len && PTR_SANE(val) && *val; --max_len)

    fputc(*val++, stderr);

  fputc('\n', stderr);

}

#ifdef TARGET_OS_LINUX

#ifdef __i386__

#define SIGRETURN_FRAME_OFFSET 17

#endif

#ifdef __x86_64__

#define SIGRETURN_FRAME_OFFSET 23

#endif

#if defined(__alpha__) && defined(__GNUC__)

/*

  The only way to backtrace without a symbol table on alpha

  is to find stq fp,N(sp), and the first byte

  of the instruction opcode will give us the value of N. From this

  we can find where the old value of fp is stored

*/

#define MAX_INSTR_IN_FUNC  10000

inline uchar** find_prev_fp(uint32* pc, uchar** fp)

{

  int i;

  for (i = 0; i < MAX_INSTR_IN_FUNC; ++i,--pc)

  {

    uchar* p = (uchar*)pc;

    if (p[2] == 222 &&  p[3] == 35)

    {

      return (uchar**)((uchar*)fp - *(short int*)p);

    }

  }

  return 0;

}

inline uint32* find_prev_pc(uint32* pc, uchar** fp)

{

  int i;

  for (i = 0; i < MAX_INSTR_IN_FUNC; ++i,--pc)

  {

    char* p = (char*)pc;

    if (p[1] == 0 && p[2] == 94 &&  p[3] == -73)

    {

      uint32* prev_pc = (uint32*)*((fp+p[0]/sizeof(fp)));

      return prev_pc;

    }

  }

  return 0;

}

#endif /* defined(__alpha__) && defined(__GNUC__) */

#if BACKTRACE_DEMANGLE

static void my_demangle_symbols(char **addrs, int n)

{

  int status, i;

  char *begin, *end, *demangled;

  for (i= 0; i < n; i++)

  {

    demangled= NULL;

    begin= strchr(addrs[i], '(');

    end= begin ? strchr(begin, '+') : NULL;

    if (begin && end)

    {

      *begin++= *end++= '\0';

      demangled= my_demangle(begin, &status);

      if (!demangled || status)

      {

        demangled= NULL;

        begin[-1]= '(';

        end[-1]= '+';

      }

    }

    if (demangled)

      fprintf(stderr, "%s(%s+%s\n", addrs[i], demangled, end);

    else

      fprintf(stderr, "%s\n", addrs[i]);

  }

}

#endif

#if HAVE_BACKTRACE

static void backtrace_current_thread(void)

{

  void *addrs[128];

  char **strings= NULL;

  int n = backtrace(addrs, array_elements(addrs));

#if BACKTRACE_DEMANGLE

  if ((strings= backtrace_symbols(addrs, n)))

  {

    my_demangle_symbols(strings, n);

    free(strings);

  }

#endif

#if HAVE_BACKTRACE_SYMBOLS_FD

  if (!strings)

  {

    backtrace_symbols_fd(addrs, n, fileno(stderr));

  }

#endif

}

#endif

void  print_stacktrace(uchar* stack_bottom, ulong thread_stack)

{

#if HAVE_BACKTRACE

  backtrace_current_thread();

  return;

#endif

  uchar** fp;

  uint frame_count = 0, sigreturn_frame_count;

#if defined(__alpha__) && defined(__GNUC__)

  uint32* pc;

#endif

#ifdef __i386__

  __asm __volatile__ ("movl %%ebp,%0"

		      :"=r"(fp)

		      :"r"(fp));

#endif

#ifdef __x86_64__

  __asm __volatile__ ("movq %%rbp,%0"

		      :"=r"(fp)

		      :"r"(fp));

#endif

#if defined(__alpha__) && defined(__GNUC__) 

  __asm __volatile__ ("mov $30,%0"

		      :"=r"(fp)

		      :"r"(fp));

#endif

  if (!fp)

  {

    fprintf(stderr, "frame pointer is NULL, did you compile with\n\

-fomit-frame-pointer? Aborting backtrace!\n");

    return;

  }

  if (!stack_bottom || (uchar*) stack_bottom > (uchar*) &fp)

  {

    ulong tmp= min(0x10000,thread_stack);

    /* Assume that the stack starts at the previous even 65K */

    stack_bottom= (uchar*) (((ulong) &fp + tmp) &

			  ~(ulong) 0xFFFF);

    fprintf(stderr, "Cannot determine thread, fp=%p, backtrace may not be correct.\n", fp);

  }

  if (fp > (uchar**) stack_bottom ||

      fp < (uchar**) stack_bottom - thread_stack)

  {

    fprintf(stderr, "Bogus stack limit or frame pointer,\

 fp=%p, stack_bottom=%p, thread_stack=%ld, aborting backtrace.\n",

	    fp, stack_bottom, thread_stack);

    return;

  }

  fprintf(stderr, "Stack range sanity check OK, backtrace follows:\n");

#if defined(__alpha__) && defined(__GNUC__)

  fprintf(stderr, "Warning: Alpha stacks are difficult -\

 will be taking some wild guesses, stack trace may be incorrect or \

 terminate abruptly\n");

  /* On Alpha, we need to get pc */

  __asm __volatile__ ("bsr %0, do_next; do_next: "

		      :"=r"(pc)

		      :"r"(pc));

#endif  /* __alpha__ */

  /* We are 1 frame above signal frame with NPTL and 2 frames above with LT */

  sigreturn_frame_count = thd_lib_detected == THD_LIB_LT ? 2 : 1;

  while (fp < (uchar**) stack_bottom)

  {

#if defined(__i386__) || defined(__x86_64__)

    uchar** new_fp = (uchar**)*fp;

    fprintf(stderr, "%p\n", frame_count == sigreturn_frame_count ?

	    *(fp + SIGRETURN_FRAME_OFFSET) : *(fp + 1));

#endif /* defined(__386__)  || defined(__x86_64__) */

#if defined(__alpha__) && defined(__GNUC__)

    uchar** new_fp = find_prev_fp(pc, fp);

    if (frame_count == sigreturn_frame_count - 1)

    {

      new_fp += 90;

    }

    if (fp && pc)

    {

      pc = find_prev_pc(pc, fp);

      if (pc)

	fprintf(stderr, "%p\n", pc);

      else

      {

	fprintf(stderr, "Not smart enough to deal with the rest\

 of this stack\n");

	goto end;

      }

    }

    else

    {

      fprintf(stderr, "Not smart enough to deal with the rest of this stack\n");

      goto end;

    }

#endif /* defined(__alpha__) && defined(__GNUC__) */

    if (new_fp <= fp )

    {

      fprintf(stderr, "New value of fp=%p failed sanity check,\

 terminating stack trace!\n", new_fp);

      goto end;

    }

    fp = new_fp;

    ++frame_count;

  }

  fprintf(stderr, "Stack trace seems successful - bottom reached\n");

end:

  fprintf(stderr,

          "Please read http://dev.mysql.com/doc/refman/5.1/en/resolve-stack-dump.html\n"

          "and follow instructions on how to resolve the stack trace.\n"

          "Resolved stack trace is much more helpful in diagnosing the\n"

          "problem, so please do resolve it\n");

}

#endif /* TARGET_OS_LINUX */

#endif /* HAVE_STACKTRACE */

/* Produce a core for the thread */

void write_core(int sig)

{

  signal(sig, SIG_DFL);

#ifdef HAVE_gcov

  /*

    For GCOV build, crashing will prevent the writing of code coverage

    information from this process, causing gcov output to be incomplete.

    So we force the writing of coverage information here before terminating.

  */

  extern void __gcov_flush(void);

  __gcov_flush();

#endif

  pthread_kill(pthread_self(), sig);

#if defined(P_MYID) && !defined(SCO)

  /* On Solaris, the above kill is not enough */

  sigsend(P_PID,P_MYID,sig);

#endif

}