Merge work:/home/bk/mysql into donna.mysql.fi:/home/my/bk/mysql

Docs/manual.texi:
  Auto merged

Docs/manual.texi

@@ -43451,18 +43451,23 @@ your actual @strong{MySQL} server either way. Free of charge. See
 Created by Laurent Bossavit of NetDIVE.
 @strong{NOTE:} Doesn't work with Access2!
 
-@item @uref{http://www.mysql.com/Downloads/Contrib/msql2mysqlWrapper-1.0.tgz, /msql2mysqlWrapper 1.0}
+@item @uref{http://www.mysql.com/Downloads/Contrib/mdb2sql.bas, mdb2sql.bas}
+Converter from Access97 to @strong{MySQL} by Moshe Gurvich.
+
+@item @uref{http://www.mysql.com/Downloads/Contrib/msql2mysqlWrapper-1.0.tgz, msql2mysqlWrapper 1.0}
 A C wrapper from @code{mSQL} to @strong{MySQL}. By @email{alfred@@sb.net}
 
 @item @uref{http://www.mysql.com/Downloads/Contrib/sqlconv.pl, sqlconv.pl}
-A simple script that can be used to copy fields from one @strong{MySQL} table to
-another in bulk. Basically, you can run @code{mysqldump} and pipe it to
+A simple script that can be used to copy fields from one @strong{MySQL} table
+to another in bulk. Basically, you can run @code{mysqldump} and pipe it to
 the @code{sqlconv.pl} script. The script will parse through the
 @code{mysqldump} output and will rearrange the fields so they can be
 inserted into a new table. An example is when you want to create a new
 table for a different site you are working on, but the table is just a
 bit different (that is - fields in different order, etc.).
 By Steve Shreeve.
+@item @uref{http://www.mysql.com/Downloads/Contrib/oracledump, oracledump}
+Perl program to convert Oracle databases to @strong{MySQL}. By Johan Andersson.
 @end itemize
 
 @appendixsec Using MySQL with Other Products

bdb/dist/Makefile.in

@@ -997,3 +997,6 @@ strerror@o@: $(srcdir)/clib/strerror.c
 	$(CC) $(CFLAGS) $?
 vsnprintf@o@: $(srcdir)/clib/vsnprintf.c
 	$(CC) $(CFLAGS) $?
+
+# Don't update the files from bitkeeper
+%::SCCS/s.%

mysys/mf_keycache.c

@@ -232,7 +232,7 @@ static inline void link_file_to_changed(SEC_LINK *next)
 }
 
 
-#ifndef DBUG_OFF
+#if !defined(DBUG_OFF) && !defined(EXTRA_DEBUG)
 #define DBUG_OFF				/* This should work */
 #endif
 

sql/Makefile.am

@@ -54,7 +54,8 @@ noinst_HEADERS =	item.h item_func.h item_sum.h item_cmpfunc.h \
 			ha_gemini.h opt_range.h opt_ft.h \
 			sql_select.h structs.h table.h sql_udf.h hash_filo.h\
 			lex.h lex_symbol.h sql_acl.h sql_crypt.h md5.h \
-                        log_event.h mini_client.h sql_repl.h slave.h
+                        log_event.h mini_client.h sql_repl.h slave.h \
+			stacktrace.h
 mysqld_SOURCES =	sql_lex.cc \
 			item.cc item_sum.cc item_buff.cc item_func.cc \
 			item_cmpfunc.cc item_strfunc.cc item_timefunc.cc \
@@ -67,17 +68,19 @@ mysqld_SOURCES =	sql_lex.cc \
 			sql_base.cc table.cc sql_select.cc sql_insert.cc \
 			sql_update.cc sql_delete.cc \
 			procedure.cc item_uniq.cc sql_test.cc \
-			log.cc init.cc derror.cc sql_acl.cc unireg.cc \
+			log.cc log_event.cc init.cc derror.cc sql_acl.cc \
+			unireg.cc \
 			time.cc opt_range.cc opt_sum.cc opt_ft.cc \
 		   	records.cc filesort.cc handler.cc \
-		        ha_isam.cc ha_isammrg.cc ha_heap.cc \
-			ha_myisam.cc ha_myisammrg.cc ha_berkeley.cc \
-	                ha_innobase.cc ha_gemini.cc \
+		        ha_heap.cc ha_myisam.cc ha_myisammrg.cc \
+	                ha_berkeley.cc ha_innobase.cc ha_gemini.cc \
+			ha_isam.cc ha_isammrg.cc \
 			sql_db.cc sql_table.cc sql_rename.cc sql_crypt.cc \
 			sql_load.cc mf_iocache.cc field_conv.cc sql_show.cc \
 			sql_udf.cc sql_analyse.cc sql_analyse.h sql_cache.cc \
 			slave.cc sql_repl.cc \
-			md5.c log_event.cc mini_client.cc mini_client_errors.c
+			mini_client.cc mini_client_errors.c \
+			md5.c stacktrace.c
 gen_lex_hash_SOURCES =	gen_lex_hash.cc
 gen_lex_hash_LDADD =	$(LDADD) $(CXXLDFLAGS)
 mysqlbinlog_SOURCES =   mysqlbinlog.cc mini_client.cc net_serv.cc \

sql/stacktrace.c

+/* 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; either version 2 of the License, or
+   (at your option) any later version.
+
+   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 */
+
+#include <global.h>
+#include "stacktrace.h"
+#include <signal.h>
+
+#ifdef HAVE_STACKTRACE
+#include <unistd.h>
+
+#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 HAVE_LINUXTHREADS
+#define SIGRETURN_FRAME_COUNT  1
+
+#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__) */
+
+
+void  print_stacktrace(gptr stack_bottom, ulong thread_stack)
+{
+  uchar** fp;
+  uint frame_count = 0;
+#if defined(__alpha__) && defined(__GNUC__)
+  uint32* pc;
+#endif
+  LINT_INIT(fp);
+
+  fprintf(stderr,"\
+Attempting backtrace. You can use the following information to find out\n\
+where mysqld died. If you see no messages after this, something went\n\
+terribly wrong...\n");
+#ifdef __i386__  
+  __asm __volatile__ ("movl %%ebp,%0"
+		      :"=r"(fp)
+		      :"r"(fp));
+  if (!fp)
+  {
+    fprintf(stderr, "frame pointer (ebp) is NULL, did you compile with\n\
+-fomit-frame-pointer? Aborting backtrace!\n");
+    return;
+  }
+#endif
+#if defined(__alpha__) && defined(__GNUC__) 
+  __asm __volatile__ ("mov $15,%0"
+		      :"=r"(fp)
+		      :"r"(fp));
+  if (!fp)
+  {
+    fprintf(stderr, "frame pointer (fp) is NULL, did you compile with\n\
+-fomit-frame-pointer? Aborting backtrace!\n");
+    return;
+  }
+#endif /* __alpha__ */
+  
+  if (!stack_bottom)
+  {
+    ulong tmp= min(0x10000,thread_stack);
+    /* Assume that the stack starts at the previous even 65K */
+    stack_bottom= (gptr) (((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__ */
+  
+  while (fp < (uchar**) stack_bottom)
+  {
+#ifdef __i386__    
+    uchar** new_fp = (uchar**)*fp;
+    fprintf(stderr, "%p\n", frame_count == SIGRETURN_FRAME_COUNT ?
+	    *(fp+17) : *(fp+1));
+#endif /* __386__ */
+
+#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://www.mysql.com/doc/U/s/Using_stack_trace.html and follow instructions on how to resolve the stack trace. Resolved\n\
+stack trace is much more helpful in diagnosing the problem, so please do \n\
+resolve it\n");
+}
+#endif /* HAVE_LINUXTHREADS */
+#endif /* HAVE_STACKTRACE */
+
+/* Produce a core for the thread */
+
+#ifdef HAVE_WRITE_CORE
+void write_core(int sig)
+{
+  signal(sig, SIG_DFL);
+  if (fork() != 0) exit(1);			// Abort main program
+  // Core will be written at exit
+}
+#endif /* HAVE_WRITE_CORE */

sql/stacktrace.h

+/* 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; either version 2 of the License, or
+   (at your option) any later version.
+
+   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 */
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#ifdef HAVE_LINUXTHREADS
+#if defined(HAVE_STACKTRACE) || (defined (__i386__) || (defined(__alpha__) && defined(__GNUC__)))
+#undef HAVE_STACKTRACE
+#define HAVE_STACKTRACE
+
+extern char* __bss_start;
+extern char* heap_start;
+
+#define init_stacktrace() { heap_start = (char*) &__bss_start; }
+void print_stacktrace(gptr stack_bottom, ulong thread_stack);
+void safe_print_str(const char* name, const char* val, int max_len);
+#endif /* (defined (__i386__) || (defined(__alpha__) && defined(__GNUC__))) */
+
+#define HAVE_WRITE_CORE
+void write_core(int sig);
+#endif /* HAVE_LINUXTHREADS */
+
+/* Define empty prototypes for functions that are not implemented */
+#ifndef HAVE_STACKTRACE
+#define init_stacktrace() {}
+#define print_stacktrace(A,B) {}
+#define safe_print_str(A,B,C) {}
+#endif /* HAVE_STACKTRACE */
+
+#ifndef HAVE_WRITE_CORE
+#define write_core(A) {}
+#endif
+
+#ifdef	__cplusplus
+}
+#endif