Merge jamppa@bk-internal.mysql.com:/home/bk/mysql-maria

into  a88-113-38-195.elisa-laajakaista.fi:/home/my/bk/mysql-maria.prod


BUILD/SETUP.sh:
  Auto merged
sql/opt_range.cc:
  Auto merged
sql/sql_insert.cc:
  Auto merged
storage/maria/ha_maria.cc:
  Auto merged
storage/maria/ma_check.c:
  Auto merged
storage/maria/ma_create.c:
  Auto merged
storage/maria/ma_delete.c:
  Auto merged
storage/maria/ma_open.c:
  Auto merged
storage/maria/ma_update.c:
  Auto merged
storage/maria/ma_write.c:
  Auto merged
storage/maria/maria_chk.c:
  Auto merged
storage/maria/maria_def.h:
  Auto merged
storage/maria/ma_pagecache.c:
  Manual merge with maria tree.
storage/myisam/sort.c:
  Manual merge with maria tree.

BUILD/SETUP.sh

@@ -145,6 +145,7 @@ base_configs="--prefix=$prefix --enable-assembler "
 base_configs="$base_configs --with-extra-charsets=complex "
 base_configs="$base_configs --enable-thread-safe-client "
 base_configs="$base_configs --with-big-tables"
+base_configs="$base_configs --with-plugin-maria"
 
 if test -d "$path/../cmd-line-utils/readline"
 then

BUILD/compile-amd64-gprof-no-ndb

+#! /bin/sh
+path=`dirname $0`
+. "$path/SETUP.sh"
+extra_flags="$amd64_cflags -pg -g"
+extra_configs="$amd64_configs $max_no_ndb_configs --disable-shared $static_link"
+
+. "$path/FINISH.sh"

sql/opt_range.cc

@@ -2139,9 +2139,6 @@ int SQL_SELECT::test_quick_select(THD *thd, key_map keys_to_use,
   quick=0;
   needed_reg.clear_all();
   quick_keys.clear_all();
-  if ((specialflag & SPECIAL_SAFE_MODE) && ! force_quick_range ||
-      !limit)
-    DBUG_RETURN(0); /* purecov: inspected */
   if (keys_to_use.is_clear_all())
     DBUG_RETURN(0);
   records= head->file->stats.records;

sql/sql_insert.cc

@@ -3488,9 +3488,11 @@ select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
 
    /*
      If error during the CREATE SELECT we drop the table, so no need for
-     engines to do logging of insertions (optimization).
+     engines to do logging of insertions (optimization). We don't do it for
+     temporary tables (yet) as re-enabling causes an undesirable commit.
    */
-   if (ha_enable_transaction(thd, FALSE))
+  if (((thd->lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) == 0) &&
+      ha_enable_transaction(thd, FALSE))
     DBUG_RETURN(-1);
 
   if (!(table= create_table_from_items(thd, create_info, create_table,
@@ -3632,11 +3634,12 @@ bool select_create::send_eof()
       nevertheless.
     */
     if (!table->s->tmp_table)
+    {
+      ha_enable_transaction(thd, TRUE);
       ha_commit(thd);               // Can fail, but we proceed anyway
-
+    }
     table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
     table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
-    ha_enable_transaction(thd, TRUE);
     if (thd->extra_lock)
     {
       mysql_unlock_tables(thd, thd->extra_lock);
@@ -3659,6 +3662,9 @@ void select_create::abort()
   select_insert::abort();
   reenable_binlog(thd);
 
+  if (table && !table->s->tmp_table)
+    ha_enable_transaction(thd, TRUE);
+
   /*
     We roll back the statement, including truncating the transaction
     cache of the binary log, if the statement failed.
@@ -3675,8 +3681,6 @@ void select_create::abort()
   if (thd->current_stmt_binlog_row_based)
     ha_rollback_stmt(thd);
 
-  ha_enable_transaction(thd, TRUE);
-
   if (thd->extra_lock)
   {
     mysql_unlock_tables(thd, thd->extra_lock);

storage/maria/Makefile.am

@@ -62,7 +62,7 @@ noinst_HEADERS =	maria_def.h ma_rt_index.h ma_rt_key.h ma_rt_mbr.h \
 			ma_control_file.h ha_maria.h ma_blockrec.h \
 			ma_loghandler.h ma_loghandler_lsn.h ma_pagecache.h \
 			ma_checkpoint.h ma_recovery.h ma_commit.h \
-			trnman_public.h
+			trnman_public.h ma_check_standalone.h
 ma_test1_DEPENDENCIES=	$(LIBRARIES)
 ma_test1_LDADD=		@CLIENT_EXTRA_LDFLAGS@ libmaria.a \
                         $(top_builddir)/storage/myisam/libmyisam.a \

storage/maria/ha_maria.cc

@@ -2151,6 +2151,9 @@ int ha_maria::create(const char *name, register TABLE *table_arg,
       error;
       ?
     Why fool the user?
+    Shouldn't this test be pushed down to maria_create()? Because currently,
+    ma_test1 -T crashes: it creates a table with DYNAMIC_RECORD but has
+    born_transactional==1, which confuses some recovery-related code.
   */
 #endif
   create_info.transactional= (row_type == BLOCK_RECORD &&

storage/maria/ma_blockrec.h

@@ -193,3 +193,28 @@ my_bool _ma_apply_undo_row_delete(MARIA_HA *info, LSN undo_lsn,
                                   const uchar *header, size_t length);
 my_bool _ma_apply_undo_row_update(MARIA_HA *info, LSN undo_lsn,
                                   const uchar *header, size_t length);
+
+my_bool write_hook_for_redo(enum translog_record_type type,
+                            TRN *trn, MARIA_HA *tbl_info, LSN *lsn,
+                            void *hook_arg);
+my_bool write_hook_for_undo(enum translog_record_type type,
+                            TRN *trn, MARIA_HA *tbl_info, LSN *lsn,
+                            void *hook_arg);
+my_bool write_hook_for_redo_delete_all(enum translog_record_type type,
+                                       TRN *trn, MARIA_HA *tbl_info,
+                                       LSN *lsn, void *hook_arg);
+my_bool write_hook_for_undo_row_insert(enum translog_record_type type,
+                                       TRN *trn, MARIA_HA *tbl_info,
+                                       LSN *lsn, void *hook_arg);
+my_bool write_hook_for_undo_row_delete(enum translog_record_type type,
+                                       TRN *trn, MARIA_HA *tbl_info,
+                                       LSN *lsn, void *hook_arg);
+my_bool write_hook_for_undo_row_update(enum translog_record_type type,
+                                       TRN *trn, MARIA_HA *tbl_info,
+                                       LSN *lsn, void *hook_arg);
+my_bool write_hook_for_clr_end(enum translog_record_type type,
+                               TRN *trn, MARIA_HA *tbl_info, LSN *lsn,
+                               void *hook_arg);
+my_bool write_hook_for_file_id(enum translog_record_type type,
+                               TRN *trn, MARIA_HA *tbl_info, LSN *lsn,
+                               void *hook_arg);

storage/maria/ma_check.c

@@ -5603,11 +5603,10 @@ static int write_log_record_for_repair(const HA_CHECK *param, MARIA_HA *info)
       record).
     */
     LEX_STRING log_array[TRANSLOG_INTERNAL_PARTS + 1];
-    uchar log_data[LSN_STORE_SIZE];
+    uchar log_data[FILEID_STORE_SIZE + 4];
     LSN lsn;
-    compile_time_assert(LSN_STORE_SIZE >= (FILEID_STORE_SIZE + 4));
     log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    (char*) log_data;
-    log_array[TRANSLOG_INTERNAL_PARTS + 0].length= FILEID_STORE_SIZE + 4;
+    log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
     /*
       testflag gives an idea of what REPAIR did (in particular T_QUICK
       or not: did it touch the data file or not?).
@@ -5615,10 +5614,9 @@ static int write_log_record_for_repair(const HA_CHECK *param, MARIA_HA *info)
     int4store(log_data + FILEID_STORE_SIZE, param->testflag);
     if (unlikely(translog_write_record(&lsn, LOGREC_REDO_REPAIR_TABLE,
                                        &dummy_transaction_object, info,
-                                       log_array[TRANSLOG_INTERNAL_PARTS +
-                                                 0].length,
+                                       sizeof(log_data),
                                        sizeof(log_array)/sizeof(log_array[0]),
-                                       log_array, log_data) ||
+                                       log_array, log_data, NULL) ||
                  translog_flush(lsn)))
       return 1;
     /*

storage/maria/ma_check_standalone.h

+/* Copyright (C) 2007 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 */
+
+/*
+  All standalone programs which need to use functions from ma_check.c
+  (like maria_repair()) must define their version of _ma_killed_ptr()
+  and _ma_check_print_info|warning|error(). Indeed, linking with ma_check.o
+  brings in the dependencies of ma_check.o which are definitions of the above
+  functions; if the program does not define them then the ones of
+  ha_maria.o are used i.e. ha_maria.o is linked into the program, and this
+  brings dependencies of ha_maria.o on mysqld.o into the program's linking
+  which thus fails, as the program is not linked with mysqld.o.
+  This file contains the versions of these functions used by maria_chk and
+  maria_read_log.
+*/
+
+/*
+  Check if check/repair operation was killed by a signal
+*/
+
+static int not_killed= 0;
+
+volatile int *_ma_killed_ptr(HA_CHECK *param __attribute__((unused)))
+{
+  return &not_killed;			/* always NULL */
+}
+
+	/* print warnings and errors */
+	/* VARARGS */
+
+void _ma_check_print_info(HA_CHECK *param __attribute__((unused)),
+			 const char *fmt,...)
+{
+  va_list args;
+  DBUG_ENTER("_ma_check_print_info");
+  DBUG_PRINT("enter", ("format: %s", fmt));
+
+  va_start(args,fmt);
+  VOID(vfprintf(stdout, fmt, args));
+  VOID(fputc('\n',stdout));
+  va_end(args);
+  DBUG_VOID_RETURN;
+}
+
+/* VARARGS */
+
+void _ma_check_print_warning(HA_CHECK *param, const char *fmt,...)
+{
+  va_list args;
+  DBUG_ENTER("_ma_check_print_warning");
+  DBUG_PRINT("enter", ("format: %s", fmt));
+
+  fflush(stdout);
+  if (!param->warning_printed && !param->error_printed)
+  {
+    if (param->testflag & T_SILENT)
+      fprintf(stderr,"%s: MARIA file %s\n",my_progname_short,
+	      param->isam_file_name);
+    param->out_flag|= O_DATA_LOST;
+  }
+  param->warning_printed=1;
+  va_start(args,fmt);
+  fprintf(stderr,"%s: warning: ",my_progname_short);
+  VOID(vfprintf(stderr, fmt, args));
+  VOID(fputc('\n',stderr));
+  fflush(stderr);
+  va_end(args);
+  DBUG_VOID_RETURN;
+}
+
+/* VARARGS */
+
+void _ma_check_print_error(HA_CHECK *param, const char *fmt,...)
+{
+  va_list args;
+  DBUG_ENTER("_ma_check_print_error");
+  DBUG_PRINT("enter", ("format: %s", fmt));
+
+  fflush(stdout);
+  if (!param->warning_printed && !param->error_printed)
+  {
+    if (param->testflag & T_SILENT)
+      fprintf(stderr,"%s: MARIA file %s\n",my_progname_short,param->isam_file_name);
+    param->out_flag|= O_DATA_LOST;
+  }
+  param->error_printed|=1;
+  va_start(args,fmt);
+  fprintf(stderr,"%s: error: ",my_progname_short);
+  VOID(vfprintf(stderr, fmt, args));
+  VOID(fputc('\n',stderr));
+  fflush(stderr);
+  va_end(args);
+  DBUG_VOID_RETURN;
+}

storage/maria/ma_checkpoint.c

@@ -266,7 +266,7 @@ static int really_execute_checkpoint(void)
                                        &dummy_transaction_object, NULL,
                                        total_rec_length,
                                        sizeof(log_array)/sizeof(log_array[0]),
-                                       log_array, NULL) ||
+                                       log_array, NULL, NULL) ||
                  translog_flush(lsn)))
       goto err;
 
@@ -652,7 +652,7 @@ pthread_handler_t ma_checkpoint_background(void *arg __attribute__((unused)))
       break;
 #if 0 /* good for testing, to do a lot of checkpoints, finds a lot of bugs */
     pthread_mutex_unlock(&LOCK_checkpoint);
-    my_sleep(100000); // a tenth of a second
+    my_sleep(100000); /* a tenth of a second */
     pthread_mutex_lock(&LOCK_checkpoint);
 #else
     /* To have a killable sleep, we use timedwait like our SQL GET_LOCK() */
@@ -893,7 +893,7 @@ static int collect_tables(LEX_STRING *str, LSN checkpoint_start_log_horizon)
 
     filter_param.pages_covered_by_bitmap= share->bitmap.pages_covered;
     /* OS file descriptors are ints which we stored in 4 bytes */
-    compile_time_assert(sizeof(int) == 4);
+    compile_time_assert(sizeof(int) <= 4);
     pthread_mutex_lock(&share->intern_lock);
     /*
       Tables in a normal state have their two file descriptors open.

storage/maria/ma_commit.c

@@ -64,7 +64,7 @@ int ma_commit(TRN *trn)
   res= (translog_write_record(&commit_lsn, LOGREC_COMMIT,
                               trn, NULL, 0,
                               sizeof(log_array)/sizeof(log_array[0]),
-                              log_array, NULL) ||
+                              log_array, NULL, NULL) ||
         translog_flush(commit_lsn) ||
         trnman_commit_trn(trn));
   /*

storage/maria/ma_create.c

@@ -998,7 +998,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
                                        &dummy_transaction_object, NULL,
                                        total_rec_length,
                                        sizeof(log_array)/sizeof(log_array[0]),
-                                       log_array, NULL) ||
+                                       log_array, NULL, NULL) ||
                  translog_flush(lsn)))
       goto err;
     /*

storage/maria/ma_delete.c

@@ -44,10 +44,10 @@ int maria_delete(MARIA_HA *info,const uchar *record)
 	/* Test if record is in datafile */
 
   DBUG_EXECUTE_IF("maria_pretend_crashed_table_on_usage",
-                  maria_print_error(info->s, HA_ERR_CRASHED);
+                  maria_print_error(share, HA_ERR_CRASHED);
                   DBUG_RETURN(my_errno= HA_ERR_CRASHED););
   DBUG_EXECUTE_IF("my_error_test_undefined_error",
-                  maria_print_error(info->s, INT_MAX);
+                  maria_print_error(share, INT_MAX);
                   DBUG_RETURN(my_errno= INT_MAX););
   if (!(info->update & HA_STATE_AKTIV))
   {
@@ -70,17 +70,17 @@ int maria_delete(MARIA_HA *info,const uchar *record)
   old_key= info->lastkey2;
   for (i=0 ; i < share->base.keys ; i++ )
   {
-    if (maria_is_key_active(info->s->state.key_map, i))
+    if (maria_is_key_active(share->state.key_map, i))
     {
-      info->s->keyinfo[i].version++;
-      if (info->s->keyinfo[i].flag & HA_FULLTEXT )
+      share->keyinfo[i].version++;
+      if (share->keyinfo[i].flag & HA_FULLTEXT )
       {
         if (_ma_ft_del(info, i, old_key, record, info->cur_row.lastpos))
           goto err;
       }
       else
       {
-        if (info->s->keyinfo[i].ck_delete(info,i,old_key,
+        if (share->keyinfo[i].ck_delete(info,i,old_key,
 					  _ma_make_key(info, i, old_key,
 						       record,
 						       info->cur_row.lastpos)))
@@ -91,19 +91,20 @@ int maria_delete(MARIA_HA *info,const uchar *record)
     }
   }
 
-  if ((*share->delete_record)(info, record))
-    goto err;				/* Remove record from database */
-
+  if (share->calc_checksum)
+  {
     /*
       We can't use the row based checksum as this doesn't have enough
       precision.
     */
-  if (info->s->calc_checksum)
-  {
-    info->cur_row.checksum= (*info->s->calc_checksum)(info,record);
-    info->state->checksum-= info->cur_row.checksum;
+    info->cur_row.checksum= (*share->calc_checksum)(info, record);
   }
 
+  if ((*share->delete_record)(info, record))
+    goto err;				/* Remove record from database */
+
+  info->state->checksum+= - !share->now_transactional *
+    info->cur_row.checksum;
   info->update= HA_STATE_CHANGED+HA_STATE_DELETED+HA_STATE_ROW_CHANGED;
   info->state->records-= !share->now_transactional;
   share->state.changed|= STATE_NOT_OPTIMIZED_ROWS;
@@ -113,8 +114,8 @@ int maria_delete(MARIA_HA *info,const uchar *record)
   allow_break();			/* Allow SIGHUP & SIGINT */
   if (info->invalidator != 0)
   {
-    DBUG_PRINT("info", ("invalidator... '%s' (delete)", info->s->open_file_name));
-    (*info->invalidator)(info->s->open_file_name);
+    DBUG_PRINT("info", ("invalidator... '%s' (delete)", share->open_file_name));
+    (*info->invalidator)(share->open_file_name);
     info->invalidator=0;
   }
   DBUG_RETURN(0);
@@ -124,7 +125,7 @@ int maria_delete(MARIA_HA *info,const uchar *record)
   mi_sizestore(lastpos, info->cur_row.lastpos);
   if (save_errno != HA_ERR_RECORD_CHANGED)
   {
-    maria_print_error(info->s, HA_ERR_CRASHED);
+    maria_print_error(share, HA_ERR_CRASHED);
     maria_mark_crashed(info);		/* mark table crashed */
   }
   VOID(_ma_writeinfo(info,WRITEINFO_UPDATE_KEYFILE));
@@ -133,7 +134,7 @@ int maria_delete(MARIA_HA *info,const uchar *record)
   my_errno=save_errno;
   if (save_errno == HA_ERR_KEY_NOT_FOUND)
   {
-    maria_print_error(info->s, HA_ERR_CRASHED);
+    maria_print_error(share, HA_ERR_CRASHED);
     my_errno=HA_ERR_CRASHED;
   }
 

storage/maria/ma_delete_all.c

@@ -64,14 +64,15 @@ int maria_delete_all_rows(MARIA_HA *info)
     if (unlikely(translog_write_record(&lsn, LOGREC_REDO_DELETE_ALL,
                                        info->trn, info, 0,
                                        sizeof(log_array)/sizeof(log_array[0]),
-                                       log_array, log_data) ||
+                                       log_array, log_data, NULL) ||
                  translog_flush(lsn)))
       goto err;
   }
 
   /*
     For recovery it matters that this is called after writing the log record,
-    so that resetting state.records actually happens under log's mutex.
+    so that resetting state.records and state.checksum actually happens under
+    log's mutex.
   */
   _ma_reset_status(info);
 
@@ -147,10 +148,6 @@ void _ma_reset_status(MARIA_HA *info)
   info->state->key_file_length= share->base.keystart;
   info->state->data_file_length= 0;
   info->state->empty= info->state->key_empty= 0;
-  /**
-     @todo RECOVERY BUG
-     the line below must happen under log's mutex when writing the REDO
-  */
   info->state->checksum= 0;
 
   /* Drop the delete key chain. */

storage/maria/ma_delete_table.c

@@ -92,7 +92,7 @@ int maria_delete_table(const char *name)
                                        log_array[TRANSLOG_INTERNAL_PARTS +
                                                  0].length,
                                        sizeof(log_array)/sizeof(log_array[0]),
-                                       log_array, NULL) ||
+                                       log_array, NULL, NULL) ||
                  translog_flush(lsn)))
       DBUG_RETURN(1);
   }

storage/maria/ma_loghandler.h

@@ -48,6 +48,7 @@ typedef uint16 SHORT_TRANSACTION_ID;
 
 struct st_maria_info;
 
+/* Changing one of the "SIZE" below will break backward-compatibility! */
 /* Length of CRC at end of pages */
 #define CRC_LENGTH 4
 /* Size of file id in logs */
@@ -57,16 +58,23 @@ struct st_maria_info;
 /* Size of page ranges in log */
 #define PAGERANGE_STORE_SIZE ROW_EXTENT_COUNT_SIZE
 #define DIRPOS_STORE_SIZE 1
+#define CLR_TYPE_STORE_SIZE 1
+/* If table has live checksum we store its changes in UNDOs */
+#define HA_CHECKSUM_STORE_SIZE 4
 
 /* Store methods to match the above sizes */
 #define fileid_store(T,A) int2store(T,A)
 #define page_store(T,A)   int5store(T,A)
 #define dirpos_store(T,A) ((*(uchar*) (T)) = A)
 #define pagerange_store(T,A) int2store(T,A)
+#define clr_type_store(T,A) ((*(uchar*) (T)) = A)
+#define ha_checksum_store(T,A) int4store(T,A)
 #define fileid_korr(P) uint2korr(P)
 #define page_korr(P)   uint5korr(P)
 #define dirpos_korr(P) ((P)[0])
 #define pagerange_korr(P) uint2korr(P)
+#define clr_type_korr(P) ((P)[0])
+#define ha_checksum_korr(P) uint4korr(P)
 
 /*
   Length of disk drive sector size (we assume that writing it
@@ -182,10 +190,14 @@ typedef struct st_translog_scanner_data
   TRANSLOG_ADDRESS horizon;
   TRANSLOG_ADDRESS last_file_page;             /* Last page on in this file */
   uchar *page;                                  /* page content pointer */
+  /* direct link on the current page or NULL if not supported/requested */
+  PAGECACHE_BLOCK_LINK *direct_link;
   /* offset of the chunk in the page */
   translog_size_t page_offset;
   /* set horizon only once at init */
   my_bool fixed_horizon;
+  /* try to get direct link on the page if it is possible */
+  my_bool use_direct_link;
 } TRANSLOG_SCANNER_DATA;
 
 
@@ -226,7 +238,8 @@ translog_write_record(LSN *lsn, enum translog_record_type type,
                       struct st_transaction *trn,
                       struct st_maria_info *tbl_info,
                       translog_size_t rec_len, uint part_no,
-                      LEX_STRING *parts_data, uchar *store_share_id);
+                      LEX_STRING *parts_data, uchar *store_share_id,
+                      void *hook_arg);
 
 extern void translog_destroy();
 
@@ -245,7 +258,9 @@ extern my_bool translog_flush(LSN lsn);
 
 extern my_bool translog_init_scanner(LSN lsn,
 				     my_bool fixed_horizon,
-				     struct st_translog_scanner_data *scanner);
+				     struct st_translog_scanner_data *scanner,
+                                     my_bool use_direct_link);
+extern void translog_destroy_scanner(TRANSLOG_SCANNER_DATA *scanner);
 
 extern int translog_read_next_record_header(TRANSLOG_SCANNER_DATA *scanner,
                                             TRANSLOG_HEADER_BUFFER *buff);
@@ -293,12 +308,11 @@ struct st_translog_parts
 
 typedef my_bool(*prewrite_rec_hook) (enum translog_record_type type,
                                      TRN *trn, struct st_maria_info *tbl_info,
-                                     struct st_translog_parts *parts);
+                                     void *hook_arg);
 
 typedef my_bool(*inwrite_rec_hook) (enum translog_record_type type,
                                     TRN *trn, struct st_maria_info *tbl_info,
-                                    LSN *lsn,
-                                    struct st_translog_parts *parts);
+                                    LSN *lsn, void *hook_arg);
 
 typedef uint16(*read_rec_hook) (enum translog_record_type type,
                                 uint16 read_length, uchar *read_buff,

storage/maria/ma_open.c

@@ -58,7 +58,7 @@ if (pos > end_pos)             \
 ** In MySQL the server will handle version issues.
 ******************************************************************************/
 
-MARIA_HA *_ma_test_if_reopen(char *filename)
+MARIA_HA *_ma_test_if_reopen(const char *filename)
 {
   LIST *pos;
 
@@ -177,7 +177,7 @@ static MARIA_HA *maria_clone_internal(MARIA_SHARE *share, int mode,
     share->delay_key_write=1;
 
   info.state= &share->state.state;	/* Change global values by default */
-  if (!share->base.born_transactional)   /* but for transactional ones ... */
+  if (!share->base.born_transactional)   /* For transactional ones ... */
     info.trn= &dummy_transaction_object; /* ... force crash if no trn given */
   pthread_mutex_unlock(&share->intern_lock);
 
@@ -1002,7 +1002,9 @@ uint _ma_state_info_write(MARIA_SHARE *share, uint pWrite)
   if (pWrite & 4)
     pthread_mutex_lock(&share->intern_lock);
   else if (maria_multi_threaded)
+  {
     safe_mutex_assert_owner(&share->intern_lock);
+  }
   if (share->base.born_transactional && translog_inited &&
       !maria_in_recovery)
   {

storage/maria/ma_pagecache.h

@@ -73,8 +73,6 @@ enum pagecache_write_mode
   PAGECACHE_WRITE_DONE
 };
 
-typedef void *PAGECACHE_PAGE_LINK;
-
 /* file descriptor for Maria */
 typedef struct st_pagecache_file
 {
@@ -106,25 +104,22 @@ typedef my_bool (*pagecache_disk_read_validator)(uchar *page, uchar *data);
 
 typedef struct st_pagecache
 {
-  my_bool inited;
-  my_bool resize_in_flush;       /* true during flush of resize operation    */
-  my_bool can_be_used;           /* usage of cache for read/write is allowed */
-  uint shift;                    /* block size = 2 ^ shift                   */
   size_t mem_size;               /* specified size of the cache memory       */
-  uint32 block_size;             /* size of the page buffer of a cache block */
   ulong min_warm_blocks;         /* min number of warm blocks;               */
   ulong age_threshold;           /* age threshold for hot blocks             */
   ulonglong time;                /* total number of block link operations    */
-  uint hash_entries;             /* max number of entries in the hash table  */
-  int hash_links;                /* max number of hash links                 */
-  int hash_links_used;    /* number of hash links taken from free links pool */
-  int disk_blocks;               /* max number of blocks in the cache        */
+  ulong hash_entries;            /* max number of entries in the hash table  */
+  long hash_links;               /* max number of hash links                 */
+  long hash_links_used;   /* number of hash links taken from free links pool */
+  long disk_blocks;              /* max number of blocks in the cache        */
   ulong blocks_used;           /* maximum number of concurrently used blocks */
   ulong blocks_unused;           /* number of currently unused blocks        */
   ulong blocks_changed;          /* number of currently dirty blocks         */
   ulong warm_blocks;             /* number of blocks in warm sub-chain       */
   ulong cnt_for_resize_op;       /* counter to block resize operation        */
   ulong blocks_available;     /* number of blocks available in the LRU chain */
+  long blocks;                   /* max number of blocks in the cache        */
+  uint32 block_size;             /* size of the page buffer of a cache block */
   PAGECACHE_HASH_LINK **hash_root;/* arr. of entries into hash table buckets */
   PAGECACHE_HASH_LINK *hash_link_root;/* memory for hash table links         */
   PAGECACHE_HASH_LINK *free_hash_list;/* list of free hash links             */
@@ -159,17 +154,20 @@ typedef struct st_pagecache
   ulonglong global_cache_r_requests;/* number of read requests (read hits)   */
   ulonglong global_cache_read;      /* number of reads from files to cache   */
 
-  int blocks;                   /* max number of blocks in the cache        */
+  uint shift;                    /* block size = 2 ^ shift                   */
+  my_bool inited;
+  my_bool resize_in_flush;       /* true during flush of resize operation    */
+  my_bool can_be_used;           /* usage of cache for read/write is allowed */
   my_bool in_init;		/* Set to 1 in MySQL during init/resize     */
 } PAGECACHE;
 
 /* The default key cache */
 extern PAGECACHE dflt_pagecache_var, *dflt_pagecache;
 
-extern int init_pagecache(PAGECACHE *pagecache, size_t use_mem,
+extern ulong init_pagecache(PAGECACHE *pagecache, size_t use_mem,
                             uint division_limit, uint age_threshold,
                             uint block_size);
-extern int resize_pagecache(PAGECACHE *pagecache,
+extern ulong resize_pagecache(PAGECACHE *pagecache,
                               size_t use_mem, uint division_limit,
                               uint age_threshold);
 extern void change_pagecache_param(PAGECACHE *pagecache, uint division_limit,
@@ -185,7 +183,7 @@ extern uchar *pagecache_valid_read(PAGECACHE *pagecache,
                                   uchar *buff,
                                   enum pagecache_page_type type,
                                   enum pagecache_page_lock lock,
-                                  PAGECACHE_PAGE_LINK *link,
+                                  PAGECACHE_BLOCK_LINK **link,
                                   pagecache_disk_read_validator validator,
                                   uchar* validator_data);
 
@@ -205,7 +203,7 @@ extern my_bool pagecache_write_part(PAGECACHE *pagecache,
                                     enum pagecache_page_lock lock,
                                     enum pagecache_page_pin pin,
                                     enum pagecache_write_mode write_mode,
-                                    PAGECACHE_PAGE_LINK *link,
+                                    PAGECACHE_BLOCK_LINK **link,
                                     uint offset,
                                     uint size,
                                     pagecache_disk_read_validator validator,
@@ -218,7 +216,7 @@ extern void pagecache_unlock(PAGECACHE *pagecache,
                              LSN first_REDO_LSN_for_page,
                              LSN lsn);
 extern void pagecache_unlock_by_link(PAGECACHE *pagecache,
-                                     PAGECACHE_PAGE_LINK *link,
+                                     PAGECACHE_BLOCK_LINK *block,
                                      enum pagecache_page_lock lock,
                                      enum pagecache_page_pin pin,
                                      LSN first_REDO_LSN_for_page,
@@ -228,7 +226,7 @@ extern void pagecache_unpin(PAGECACHE *pagecache,
                             pgcache_page_no_t pageno,
                             LSN lsn);
 extern void pagecache_unpin_by_link(PAGECACHE *pagecache,
-                                    PAGECACHE_PAGE_LINK *link,
+                                    PAGECACHE_BLOCK_LINK *link,
                                     LSN lsn);
 extern int flush_pagecache_blocks(PAGECACHE *keycache,
                                   PAGECACHE_FILE *file,

storage/maria/ma_rename.c

@@ -85,7 +85,7 @@ int maria_rename(const char *old_name, const char *new_name)
                                        &dummy_transaction_object, NULL,
                                        old_name_len + new_name_len,
                                        sizeof(log_array)/sizeof(log_array[0]),
-                                       log_array, NULL) ||
+                                       log_array, NULL, NULL) ||
                  translog_flush(lsn)))
     {
       maria_close(info);

storage/maria/ma_update.c

@@ -27,11 +27,9 @@ int maria_update(register MARIA_HA *info, const uchar *oldrec, uchar *newrec)
   bool auto_key_changed=0;
   ulonglong changed;
   MARIA_SHARE *share=info->s;
-  ha_checksum old_checksum;
   DBUG_ENTER("maria_update");
   LINT_INIT(new_key);
   LINT_INIT(changed);
-  LINT_INIT(old_checksum);
 
   DBUG_EXECUTE_IF("maria_pretend_crashed_table_on_usage",
                   maria_print_error(info->s, HA_ERR_CRASHED);
@@ -59,16 +57,6 @@ int maria_update(register MARIA_HA *info, const uchar *oldrec, uchar *newrec)
     goto err_end;			/* Record has changed */
   }
 
-  if (share->calc_checksum)
-  {
-    /*
-      We can't use the row based checksum as this doesn't have enough
-      precision.
-    */
-    if (info->s->calc_checksum)
-      old_checksum= (*info->s->calc_checksum)(info, oldrec);
-  }
-
   /* Calculate and check all unique constraints */
   key_changed=0;
   for (i=0 ; i < share->state.header.uniques ; i++)
@@ -137,19 +125,23 @@ int maria_update(register MARIA_HA *info, const uchar *oldrec, uchar *newrec)
       }
     }
   }
-  /*
-    If we are running with external locking, we must update the index file
-    that something has changed.
-  */
-  if (changed || !my_disable_locking)
-    key_changed|= HA_STATE_CHANGED;
 
   if (share->calc_checksum)
   {
-    info->cur_row.checksum= (*share->calc_checksum)(info,newrec);
-    info->state->checksum+= (info->cur_row.checksum - old_checksum);
-    /* Store new checksum in index file header */
-    key_changed|= HA_STATE_CHANGED;
+    /*
+      We can't use the row based checksum as this doesn't have enough
+      precision (one byte, while the table's is more bytes).
+      At least _ma_check_unique() modifies the 'newrec' record, so checksum
+      has to be computed _after_ it. Nobody apparently modifies 'oldrec'.
+      We need to pass the old row's checksum down to (*update_record)(), we do
+      this via info->new_row.checksum (not intuitive but existing code
+      mandated that cur_row is the new row).
+      If (*update_record)() fails, table will be marked corrupted so no need
+      to revert the live checksum change.
+    */
+    info->state->checksum+= !share->now_transactional *
+      ((info->cur_row.checksum= (*share->calc_checksum)(info, newrec)) -
+       (info->new_row.checksum= (*share->calc_checksum)(info, oldrec)));
   }
   {
     /*
@@ -165,14 +157,9 @@ int maria_update(register MARIA_HA *info, const uchar *oldrec, uchar *newrec)
     org_delete_link= share->state.dellink;
     if ((*share->update_record)(info, pos, oldrec, newrec))
       goto err;
-    if (!key_changed &&
-	(memcmp((char*) &state, (char*) info->state, sizeof(state)) ||
-	 org_split != share->state.split ||
-	 org_delete_link != share->state.dellink))
-      key_changed|= HA_STATE_CHANGED;		/* Must update index file */
   }
   if (auto_key_changed)
-    set_if_bigger(info->s->state.auto_increment,
+    set_if_bigger(share->state.auto_increment,
                   ma_retrieve_auto_increment(info, newrec));
 
   /*
@@ -195,8 +182,8 @@ int maria_update(register MARIA_HA *info, const uchar *oldrec, uchar *newrec)
   allow_break();				/* Allow SIGHUP & SIGINT */
   if (info->invalidator != 0)
   {
-    DBUG_PRINT("info", ("invalidator... '%s' (update)", info->s->open_file_name));
-    (*info->invalidator)(info->s->open_file_name);
+    DBUG_PRINT("info", ("invalidator... '%s' (update)", share->open_file_name));
+    (*info->invalidator)(share->open_file_name);
     info->invalidator=0;
   }
   DBUG_RETURN(0);
@@ -232,7 +219,7 @@ int maria_update(register MARIA_HA *info, const uchar *oldrec, uchar *newrec)
   }
   else
   {
-    maria_print_error(info->s, HA_ERR_CRASHED);
+    maria_print_error(share, HA_ERR_CRASHED);
     maria_mark_crashed(info);
   }
   info->update= (HA_STATE_CHANGED | HA_STATE_AKTIV | HA_STATE_ROW_CHANGED |
@@ -243,7 +230,7 @@ int maria_update(register MARIA_HA *info, const uchar *oldrec, uchar *newrec)
   allow_break();				/* Allow SIGHUP & SIGINT */
   if (save_errno == HA_ERR_KEY_NOT_FOUND)
   {
-    maria_print_error(info->s, HA_ERR_CRASHED);
+    maria_print_error(share, HA_ERR_CRASHED);
     save_errno=HA_ERR_CRASHED;
   }
   DBUG_RETURN(my_errno=save_errno);

storage/maria/ma_write.c

@@ -162,10 +162,6 @@ int maria_write(MARIA_HA *info, uchar *record)
         rw_unlock(&share->key_root_lock[i]);
     }
   }
-  /**
-     @todo RECOVERY BUG
-     this += must happen under log's mutex when writing the UNDO
-  */
   if (share->calc_write_checksum)
     info->cur_row.checksum= (*share->calc_write_checksum)(info,record);
   if (filepos != HA_OFFSET_ERROR)
@@ -176,7 +172,8 @@ int maria_write(MARIA_HA *info, uchar *record)
        @todo when we enable multiple writers, we will have to protect
        'records' and 'checksum' somehow.
     */
-    info->state->checksum+= info->cur_row.checksum;
+    info->state->checksum+= !share->now_transactional *
+      info->cur_row.checksum;
   }
   if (share->base.auto_key)
     set_if_bigger(info->s->state.auto_increment,

storage/maria/maria_chk.c

@@ -154,7 +154,7 @@ int main(int argc, char **argv)
 
 enum options_mc {
   OPT_CHARSETS_DIR=256, OPT_SET_COLLATION,OPT_START_CHECK_POS,
-  OPT_CORRECT_CHECKSUM, OPT_KEY_BUFFER_SIZE,
+  OPT_CORRECT_CHECKSUM, OPT_PAGE_BUFFER_SIZE,
   OPT_KEY_CACHE_BLOCK_SIZE, OPT_MARIA_BLOCK_SIZE,
   OPT_READ_BUFFER_SIZE, OPT_WRITE_BUFFER_SIZE, OPT_SORT_BUFFER_SIZE,
   OPT_SORT_KEY_BLOCKS, OPT_DECODE_BITS, OPT_FT_MIN_WORD_LEN,
@@ -296,7 +296,7 @@ static struct my_option my_long_options[] =
   {"wait", 'w',
    "Wait if table is locked.",
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
-  { "key_buffer_size", OPT_KEY_BUFFER_SIZE, "",
+  { "page_buffer_size", OPT_PAGE_BUFFER_SIZE, "",
     (uchar**) &check_param.use_buffers, (uchar**) &check_param.use_buffers, 0,
     GET_ULONG, REQUIRED_ARG, (long) USE_BUFFER_INIT, (long) MALLOC_OVERHEAD,
     (long) ~0L, (long) MALLOC_OVERHEAD, (long) IO_SIZE, 0},
@@ -1758,84 +1758,4 @@ static int sort_record_index(MARIA_SORT_PARAM *sort_param,MARIA_HA *info,
 } /* sort_record_index */
 
 
-
-/*
-  Check if maria_chk was killed by a signal
-  This is overloaded by other programs that want to be able to abort
-  sorting
-*/
-
-static int not_killed= 0;
-
-volatile int *_ma_killed_ptr(HA_CHECK *param __attribute__((unused)))
-{
-  return &not_killed;			/* always NULL */
-}
-
-	/* print warnings and errors */
-	/* VARARGS */
-
-void _ma_check_print_info(HA_CHECK *param __attribute__((unused)),
-			 const char *fmt,...)
-{
-  va_list args;
-  DBUG_ENTER("_ma_check_print_info");
-  DBUG_PRINT("enter", ("format: %s", fmt));
-
-  va_start(args,fmt);
-  VOID(vfprintf(stdout, fmt, args));
-  VOID(fputc('\n',stdout));
-  va_end(args);
-  DBUG_VOID_RETURN;
-}
-
-/* VARARGS */
-
-void _ma_check_print_warning(HA_CHECK *param, const char *fmt,...)
-{
-  va_list args;
-  DBUG_ENTER("_ma_check_print_warning");
-  DBUG_PRINT("enter", ("format: %s", fmt));
-
-  fflush(stdout);
-  if (!param->warning_printed && !param->error_printed)
-  {
-    if (param->testflag & T_SILENT)
-      fprintf(stderr,"%s: MARIA file %s\n",my_progname_short,
-	      param->isam_file_name);
-    param->out_flag|= O_DATA_LOST;
-  }
-  param->warning_printed=1;
-  va_start(args,fmt);
-  fprintf(stderr,"%s: warning: ",my_progname_short);
-  VOID(vfprintf(stderr, fmt, args));
-  VOID(fputc('\n',stderr));
-  fflush(stderr);
-  va_end(args);
-  DBUG_VOID_RETURN;
-}
-
-/* VARARGS */
-
-void _ma_check_print_error(HA_CHECK *param, const char *fmt,...)
-{
-  va_list args;
-  DBUG_ENTER("_ma_check_print_error");
-  DBUG_PRINT("enter", ("format: %s", fmt));
-
-  fflush(stdout);
-  if (!param->warning_printed && !param->error_printed)
-  {
-    if (param->testflag & T_SILENT)
-      fprintf(stderr,"%s: MARIA file %s\n",my_progname_short,param->isam_file_name);
-    param->out_flag|= O_DATA_LOST;
-  }
-  param->error_printed|=1;
-  va_start(args,fmt);
-  fprintf(stderr,"%s: error: ",my_progname_short);
-  VOID(vfprintf(stderr, fmt, args));
-  VOID(fputc('\n',stderr));
-  fflush(stderr);
-  va_end(args);
-  DBUG_VOID_RETURN;
-}
+#include "ma_check_standalone.h"

storage/maria/maria_def.h

@@ -632,7 +632,7 @@ typedef struct st_maria_s_param
 /* Used to store reference to pinned page */
 typedef struct st_pinned_page
 {
-  PAGECACHE_PAGE_LINK link;
+  PAGECACHE_BLOCK_LINK *link;
   enum pagecache_page_lock unlock;
 } MARIA_PINNED_PAGE;
 
@@ -842,7 +842,7 @@ typedef struct st_maria_block_info
 #define UPDATE_AUTO_INC		8
 #define UPDATE_OPEN_COUNT	16
 
-#define USE_BUFFER_INIT		(((1024L*512L-MALLOC_OVERHEAD)/IO_SIZE)*IO_SIZE)
+#define USE_BUFFER_INIT		(((1024L*1024L*10-MALLOC_OVERHEAD)/8192)*8192)
 #define READ_BUFFER_INIT	(1024L*256L-MALLOC_OVERHEAD)
 #define SORT_BUFFER_INIT	(2048L*1024L-MALLOC_OVERHEAD)
 #define MIN_SORT_BUFFER		(4096-MALLOC_OVERHEAD)
@@ -906,7 +906,7 @@ my_bool _ma_check_status(void *param);
 void _ma_reset_status(MARIA_HA *maria);
 #include "ma_commit.h"
 
-extern MARIA_HA *_ma_test_if_reopen(char *filename);
+extern MARIA_HA *_ma_test_if_reopen(const char *filename);
 my_bool _ma_check_table_is_closed(const char *name, const char *where);
 int _ma_open_datafile(MARIA_HA *info, MARIA_SHARE *share, File file_to_dup);
 int _ma_open_keyfile(MARIA_SHARE *share);
@@ -923,7 +923,10 @@ C_MODE_START
 int _ma_flush_table_files(MARIA_HA *info, uint flush_data_or_index,
                           enum flush_type flush_type_for_data,
                           enum flush_type flush_type_for_index);
-/* Functions needed by _ma_check (are overrided in MySQL) */
+/*
+  Functions needed by _ma_check (are overridden in MySQL/ha_maria.cc).
+  See ma_check_standalone.h .
+*/
 volatile int *_ma_killed_ptr(HA_CHECK *param);
 void _ma_check_print_error _VARARGS((HA_CHECK *param, const char *fmt, ...));
 void _ma_check_print_warning _VARARGS((HA_CHECK *param, const char *fmt, ...));

storage/maria/maria_read_log.c

@@ -17,7 +17,6 @@
 #include "ma_recovery.h"
 #include <my_getopt.h>
 
-#define PCACHE_SIZE (1024*1024*10)
 #define LOG_FLAGS 0
 #define LOG_FILE_SIZE (1024L*1024L)
 
@@ -30,13 +29,16 @@ const char *default_dbug_option= "d:t:i:O,\\maria_read_log.trace";
 const char *default_dbug_option= "d:t:i:o,/tmp/maria_read_log.trace";
 #endif
 #endif /* DBUG_OFF */
-static my_bool opt_only_display, opt_display_and_apply;
+static my_bool opt_only_display, opt_apply, opt_apply_undo, opt_silent;
+static ulong opt_page_buffer_size;
+static const char *my_progname_short;
 
 int main(int argc, char **argv)
 {
   LSN lsn;
   char **default_argv;
   MY_INIT(argv[0]);
+  my_progname_short= my_progname+dirname_length(my_progname);
 
   load_defaults("my", load_default_groups, &argc, &argv);
   default_argv= argv;
@@ -63,7 +65,7 @@ int main(int argc, char **argv)
   }
   /* same page cache for log and data; assumes same page size... */
   DBUG_ASSERT(maria_block_size == TRANSLOG_PAGE_SIZE);
-  if (init_pagecache(maria_pagecache, PCACHE_SIZE, 0, 0,
+  if (init_pagecache(maria_pagecache, opt_page_buffer_size, 0, 0,
                      TRANSLOG_PAGE_SIZE) == 0)
   {
     fprintf(stderr, "Got error in init_pagecache() (errno: %d)\n", errno);
@@ -100,15 +102,15 @@ int main(int argc, char **argv)
           LSN_IN_PARTS(lsn));
 
   fprintf(stdout, "TRACE of the last maria_read_log\n");
-  if (maria_apply_log(lsn, opt_display_and_apply, stdout,
-                      opt_display_and_apply, FALSE))
+  if (maria_apply_log(lsn, opt_apply, opt_silent ? NULL : stdout,
+                      opt_apply_undo, FALSE))
     goto err;
-  fprintf(stdout, "%s: SUCCESS\n", my_progname);
+  fprintf(stdout, "%s: SUCCESS\n", my_progname_short);
 
   goto end;
 err:
   /* don't touch anything more, in case we hit a bug */
-  fprintf(stderr, "%s: FAILED\n", my_progname);
+  fprintf(stderr, "%s: FAILED\n", my_progname_short);
   exit(1);
 end:
   maria_end();
@@ -119,21 +121,37 @@ int main(int argc, char **argv)
 }
 
 
+#include "ma_check_standalone.h"
+
+
 static struct my_option my_long_options[] =
 {
+  {"apply", 'a',
+   "Apply log to tables. Will display a lot of information if not run with --silent",
+   (uchar **) &opt_apply, (uchar **) &opt_apply, 0,
+   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
+#ifndef DBUG_OFF
+  {"debug", '#', "Output debug log. Often the argument is 'd:t:o,filename'.",
+   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
+#endif
   {"help", '?', "Display this help and exit.",
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
   {"only-display", 'o', "display brief info about records's header",
    (uchar **) &opt_only_display, (uchar **) &opt_only_display, 0, GET_BOOL,
    NO_ARG,0, 0, 0, 0, 0, 0},
-  {"display-and-apply", 'a',
-   "like --only-display but displays more info and modifies tables",
-   (uchar **) &opt_display_and_apply, (uchar **) &opt_display_and_apply, 0,
+  { "page_buffer_size", 'P', "",
+    (uchar**) &opt_page_buffer_size, (uchar**) &opt_page_buffer_size, 0,
+    GET_ULONG, REQUIRED_ARG, (long) USE_BUFFER_INIT,
+    (long) MALLOC_OVERHEAD, (long) ~(ulong) 0, (long) MALLOC_OVERHEAD,
+    (long) IO_SIZE, 0},
+  {"silent", 's', "Print less information during apply/undo phase",
+   (uchar **) &opt_silent, (uchar **) &opt_silent, 0,
    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-#ifndef DBUG_OFF
-  {"debug", '#', "Output debug log. Often this is 'd:t:o,filename'.",
-   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
-#endif
+  {"undo", 'u', "Apply undos to tables. (disable with --disable-undo)",
+   (uchar **) &opt_apply_undo, (uchar **) &opt_apply_undo, 0,
+   GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
+  {"version", 'V', "Print version and exit.",
+   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
   { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
 };
 
@@ -141,8 +159,8 @@ static struct my_option my_long_options[] =
 
 static void print_version(void)
 {
-  VOID(printf("%s Ver 1.0 for %s on %s\n",
-              my_progname, SYSTEM_TYPE, MACHINE_TYPE));
+  VOID(printf("%s Ver 1.1 for %s on %s\n",
+              my_progname_short, SYSTEM_TYPE, MACHINE_TYPE));
   NETWARE_SET_SCREEN_MODE(1);
 }
 
@@ -156,7 +174,7 @@ static void usage(void)
 
   puts("Display and apply log records from a MARIA transaction log");
   puts("found in the current directory (for now)");
-  VOID(printf("\nUsage: %s OPTIONS\n", my_progname));
+  VOID(printf("\nUsage: %s OPTIONS\n", my_progname_short));
   puts("You need to use one of -o or -a");
   my_print_help(my_long_options);
   print_defaults("my", load_default_groups);
@@ -174,6 +192,9 @@ get_one_option(int optid __attribute__((unused)),
   case '?':
     usage();
     exit(0);
+  case 'V':
+    print_version();
+    exit(0);
 #ifndef DBUG_OFF
   case '#':
     DBUG_SET_INITIAL(argument ? argument : default_dbug_option);
@@ -187,12 +208,13 @@ static void get_options(int *argc,char ***argv)
 {
   int ho_error;
 
-  my_progname= argv[0][0];
-
   if ((ho_error=handle_options(argc, argv, my_long_options, get_one_option)))
     exit(ho_error);
 
-  if ((opt_only_display + opt_display_and_apply) != 1)
+  if (!opt_apply)
+    opt_apply_undo= FALSE;
+
+  if ((opt_only_display + opt_apply) != 1)
   {
     usage();
     exit(1);

storage/maria/unittest/ma_control_file-t.c

@@ -407,7 +407,7 @@ static void version()
 
 static my_bool
 get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
-	       char *argument)
+	       char *argument __attribute__((unused)))
 {
   switch(optid) {
   case 'V':

storage/maria/unittest/ma_test_loghandler-t.c

@@ -198,8 +198,8 @@ int main(int argc __attribute__((unused)), char *argv[])
   trn->first_undo_lsn= TRANSACTION_LOGGED_LONG_ID;
   if (translog_write_record(&lsn,
                             LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
-                            trn, NULL,
-                            6, TRANSLOG_INTERNAL_PARTS + 1, parts, NULL))
+                            trn, NULL, 6, TRANSLOG_INTERNAL_PARTS + 1,
+                            parts, NULL, NULL))
   {
     fprintf(stderr, "Can't write record #%lu\n", (ulong) 0);
     translog_destroy();
@@ -220,8 +220,8 @@ int main(int argc __attribute__((unused)), char *argv[])
       /* check auto-count feature */
       parts[TRANSLOG_INTERNAL_PARTS + 1].str= NULL;
       parts[TRANSLOG_INTERNAL_PARTS + 1].length= 0;
-      if (translog_write_record(&lsn, LOGREC_FIXED_RECORD_1LSN_EXAMPLE,
-                                trn, NULL, LSN_STORE_SIZE, 0, parts, NULL))
+      if (translog_write_record(&lsn, LOGREC_FIXED_RECORD_1LSN_EXAMPLE, trn,
+                                NULL, LSN_STORE_SIZE, 0, parts, NULL, NULL))
       {
         fprintf(stderr, "1 Can't write reference defore record #%lu\n",
                 (ulong) i);
@@ -241,7 +241,7 @@ int main(int argc __attribute__((unused)), char *argv[])
       if (translog_write_record(&lsn,
                                 LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE,
                                 trn, NULL, 0, TRANSLOG_INTERNAL_PARTS + 2,
-                                parts, NULL))
+                                parts, NULL, NULL))
       {
         fprintf(stderr, "1 Can't write var reference defore record #%lu\n",
                 (ulong) i);
@@ -259,8 +259,8 @@ int main(int argc __attribute__((unused)), char *argv[])
       parts[TRANSLOG_INTERNAL_PARTS + 0].length= 23;
       if (translog_write_record(&lsn,
                                 LOGREC_FIXED_RECORD_2LSN_EXAMPLE,
-                                trn, NULL,
-                                23, TRANSLOG_INTERNAL_PARTS + 1, parts, NULL))
+                                trn, NULL, 23, TRANSLOG_INTERNAL_PARTS + 1,
+                                parts, NULL, NULL))
       {
         fprintf(stderr, "0 Can't write reference defore record #%lu\n",
                 (ulong) i);
@@ -280,7 +280,8 @@ int main(int argc __attribute__((unused)), char *argv[])
       if (translog_write_record(&lsn,
                                 LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE,
                                 trn, NULL, 14 + rec_len,
-                                TRANSLOG_INTERNAL_PARTS + 2, parts, NULL))
+                                TRANSLOG_INTERNAL_PARTS + 2, parts, NULL,
+                                NULL))
       {
         fprintf(stderr, "0 Can't write var reference defore record #%lu\n",
                 (ulong) i);
@@ -297,7 +298,7 @@ int main(int argc __attribute__((unused)), char *argv[])
                               LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
                               trn, NULL, 6,
                               TRANSLOG_INTERNAL_PARTS + 1,
-                              parts, NULL))
+                              parts, NULL, NULL))
     {
       fprintf(stderr, "Can't write record #%lu\n", (ulong) i);
       translog_destroy();
@@ -316,7 +317,7 @@ int main(int argc __attribute__((unused)), char *argv[])
                               LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE,
                               trn, NULL, rec_len,
                               TRANSLOG_INTERNAL_PARTS + 1,
-                              parts, NULL))
+                              parts, NULL, NULL))
     {
       fprintf(stderr, "Can't write variable record #%lu\n", (ulong) i);
       translog_destroy();
@@ -363,7 +364,7 @@ int main(int argc __attribute__((unused)), char *argv[])
     read_ok(&rec);
     translog_free_record_header(&rec);
     lsn= first_lsn;
-    if (translog_init_scanner(first_lsn, 1, &scanner))
+    if (translog_init_scanner(first_lsn, 1, &scanner, 0))
     {
       fprintf(stderr, "scanner init failed\n");
       goto err;

storage/maria/unittest/ma_test_loghandler_first_lsn-t.c

@@ -106,7 +106,7 @@ int main(int argc __attribute__((unused)), char *argv[])
                             LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
                             &dummy_transaction_object, NULL, 6,
                             TRANSLOG_INTERNAL_PARTS + 1,
-                            parts, NULL))
+                            parts, NULL, NULL))
   {
     fprintf(stderr, "Can't write record #%lu\n", (ulong) 0);
     translog_destroy();

storage/maria/unittest/ma_test_loghandler_max_lsn-t.c

@@ -96,7 +96,7 @@ int main(int argc __attribute__((unused)), char *argv[])
                               LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
                               &dummy_transaction_object, NULL, 6,
                               TRANSLOG_INTERNAL_PARTS + 1,
-                              parts, NULL))
+                              parts, NULL, NULL))
     {
       fprintf(stderr, "Can't write record #%lu\n", (ulong) 0);
       translog_destroy();

storage/maria/unittest/ma_test_loghandler_multigroup-t.c

@@ -194,8 +194,8 @@ int main(int argc __attribute__((unused)), char *argv[])
   trn->short_id= 0;
   trn->first_undo_lsn= TRANSACTION_LOGGED_LONG_ID;
   if (translog_write_record(&lsn, LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
-                            trn, NULL,
-                            6, TRANSLOG_INTERNAL_PARTS + 1, parts, NULL))
+                            trn, NULL, 6, TRANSLOG_INTERNAL_PARTS + 1, parts,
+                            NULL, NULL))
   {
     fprintf(stderr, "Can't write record #%lu\n", (ulong) 0);
     translog_destroy();
@@ -214,10 +214,9 @@ int main(int argc __attribute__((unused)), char *argv[])
       parts[TRANSLOG_INTERNAL_PARTS + 0].length= LSN_STORE_SIZE;
       trn->short_id= i % 0xFFFF;
       if (translog_write_record(&lsn,
-                                LOGREC_FIXED_RECORD_1LSN_EXAMPLE,
-                                trn, NULL,
-                                LSN_STORE_SIZE,
-                                TRANSLOG_INTERNAL_PARTS + 1, parts, NULL))
+                                LOGREC_FIXED_RECORD_1LSN_EXAMPLE, trn, NULL,
+                                LSN_STORE_SIZE, TRANSLOG_INTERNAL_PARTS + 1,
+                                parts, NULL, NULL))
       {
         fprintf(stderr, "1 Can't write reference before record #%lu\n",
                 (ulong) i);
@@ -237,7 +236,7 @@ int main(int argc __attribute__((unused)), char *argv[])
                                 LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE,
                                 trn, NULL, LSN_STORE_SIZE + rec_len,
                                 TRANSLOG_INTERNAL_PARTS + 2,
-                                parts, NULL))
+                                parts, NULL, NULL))
       {
         fprintf(stderr, "1 Can't write var reference before record #%lu\n",
                 (ulong) i);
@@ -256,9 +255,8 @@ int main(int argc __attribute__((unused)), char *argv[])
       trn->short_id= i % 0xFFFF;
       if (translog_write_record(&lsn,
                                 LOGREC_FIXED_RECORD_2LSN_EXAMPLE,
-                                trn, NULL, 23,
-                                TRANSLOG_INTERNAL_PARTS + 1,
-                                parts, NULL))
+                                trn, NULL, 23, TRANSLOG_INTERNAL_PARTS + 1,
+                                parts, NULL, NULL))
       {
         fprintf(stderr, "0 Can't write reference before record #%lu\n",
                 (ulong) i);
@@ -279,7 +277,7 @@ int main(int argc __attribute__((unused)), char *argv[])
                                 LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE,
                                 trn, NULL, LSN_STORE_SIZE * 2 + rec_len,
                                 TRANSLOG_INTERNAL_PARTS + 2,
-                                parts, NULL))
+                                parts, NULL, NULL))
       {
         fprintf(stderr, "0 Can't write var reference before record #%lu\n",
                 (ulong) i);
@@ -296,7 +294,7 @@ int main(int argc __attribute__((unused)), char *argv[])
     if (translog_write_record(&lsn,
                               LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
                               trn, NULL, 6,
-                              TRANSLOG_INTERNAL_PARTS + 1, parts, NULL))
+                              TRANSLOG_INTERNAL_PARTS + 1, parts, NULL, NULL))
     {
       fprintf(stderr, "Can't write record #%lu\n", (ulong) i);
       translog_destroy();
@@ -314,7 +312,7 @@ int main(int argc __attribute__((unused)), char *argv[])
     if (translog_write_record(&lsn,
                               LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE,
                               trn, NULL, rec_len,
-                              TRANSLOG_INTERNAL_PARTS + 1, parts, NULL))
+                              TRANSLOG_INTERNAL_PARTS + 1, parts, NULL, NULL))
     {
       fprintf(stderr, "Can't write variable record #%lu\n", (ulong) i);
       translog_destroy();
@@ -378,7 +376,7 @@ int main(int argc __attribute__((unused)), char *argv[])
     ok(1, "read record");
     translog_free_record_header(&rec);
     lsn= first_lsn;
-    if (translog_init_scanner(first_lsn, 1, &scanner))
+    if (translog_init_scanner(first_lsn, 1, &scanner, 0))
     {
       fprintf(stderr, "scanner init failed\n");
       goto err;

storage/maria/unittest/ma_test_loghandler_multithread-t.c

@@ -138,7 +138,7 @@ void writer(int num)
     if (translog_write_record(&lsn,
                               LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
                               &trn, NULL, 6, TRANSLOG_INTERNAL_PARTS + 1,
-                              parts, NULL))
+                              parts, NULL, NULL))
     {
       fprintf(stderr, "Can't write LOGREC_FIXED_RECORD_0LSN_EXAMPLE record #%lu "
               "thread %i\n", (ulong) i, num);
@@ -155,7 +155,7 @@ void writer(int num)
                               LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE,
                               &trn, NULL,
                               len, TRANSLOG_INTERNAL_PARTS + 1,
-                              parts, NULL))
+                              parts, NULL, NULL))
     {
       fprintf(stderr, "Can't write variable record #%lu\n", (ulong) i);
       translog_destroy();
@@ -307,7 +307,7 @@ int main(int argc __attribute__((unused)),
                               LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
                               &dummy_transaction_object, NULL, 6,
                               TRANSLOG_INTERNAL_PARTS + 1,
-                              parts, NULL))
+                              parts, NULL, NULL))
     {
       fprintf(stderr, "Can't write the first record\n");
       translog_destroy();
@@ -373,7 +373,7 @@ int main(int argc __attribute__((unused)),
 
     bzero(indeces, sizeof(indeces));
 
-    if (translog_init_scanner(first_lsn, 1, &scanner))
+    if (translog_init_scanner(first_lsn, 1, &scanner, 0))
     {
       fprintf(stderr, "scanner init failed\n");
       goto err;

storage/maria/unittest/ma_test_loghandler_noflush-t.c

@@ -85,7 +85,7 @@ int main(int argc __attribute__((unused)), char *argv[])
                             LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
                             &dummy_transaction_object, NULL, 6,
                             TRANSLOG_INTERNAL_PARTS + 1,
-                            parts, NULL))
+                            parts, NULL, NULL))
   {
     fprintf(stderr, "Can't write record #%lu\n", (ulong) 0);
     translog_destroy();

storage/maria/unittest/ma_test_loghandler_pagecache-t.c

@@ -97,7 +97,7 @@ int main(int argc __attribute__((unused)), char *argv[])
                             LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
                             &dummy_transaction_object, NULL, 6,
                             TRANSLOG_INTERNAL_PARTS + 1,
-                            parts, NULL))
+                            parts, NULL, NULL))
   {
     fprintf(stderr, "Can't write record #%lu\n", (ulong) 0);
     translog_destroy();

storage/maria/unittest/ma_test_loghandler_purge-t.c

@@ -80,7 +80,7 @@ int main(int argc __attribute__((unused)), char *argv[])
                             LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
                             &dummy_transaction_object, NULL, 6,
                             TRANSLOG_INTERNAL_PARTS + 1,
-                            parts, NULL))
+                            parts, NULL, NULL))
   {
     fprintf(stderr, "Can't write record #%lu\n", (ulong) 0);
     translog_destroy();
@@ -102,7 +102,7 @@ int main(int argc __attribute__((unused)), char *argv[])
                               LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
                               &dummy_transaction_object, NULL, 6,
                               TRANSLOG_INTERNAL_PARTS + 1,
-                              parts, NULL))
+                              parts, NULL, NULL))
     {
       fprintf(stderr, "Can't write record #%lu\n", (ulong) 0);
       translog_destroy();
@@ -125,7 +125,7 @@ int main(int argc __attribute__((unused)), char *argv[])
   if (translog_write_record(&lsn,
 			    LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE,
 			    &dummy_transaction_object, NULL, LONG_BUFFER_SIZE,
-			    TRANSLOG_INTERNAL_PARTS + 1, parts, NULL))
+			    TRANSLOG_INTERNAL_PARTS + 1, parts, NULL, NULL))
   {
     fprintf(stderr, "Can't write variable record\n");
     translog_destroy();
@@ -150,7 +150,7 @@ int main(int argc __attribute__((unused)), char *argv[])
                             LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
                             &dummy_transaction_object, NULL, 6,
                             TRANSLOG_INTERNAL_PARTS + 1,
-                            parts, NULL))
+                            parts, NULL, NULL))
   {
     fprintf(stderr, "Can't write last record\n");
     translog_destroy();