Merge desktop.sanja.is.com.ua:/home/bell/mysql/bk/mysql-maria

into  desktop.sanja.is.com.ua:/home/bell/mysql/bk/work-maria-callback


storage/maria/Makefile.am:
  Auto merged
storage/maria/ma_blockrec.c:
  Auto merged
storage/maria/ma_check.c:
  Auto merged
storage/maria/ma_create.c:
  Auto merged
storage/maria/ma_loghandler.h:
  Auto merged
storage/maria/ma_open.c:
  Auto merged
storage/maria/ma_page.c:
  Auto merged
storage/maria/ma_pagecache.c:
  Auto merged
storage/maria/maria_chk.c:
  Auto merged
storage/maria/maria_def.h:
  Auto merged
storage/maria/unittest/ma_test_loghandler-t.c:
  Auto merged
storage/maria/unittest/ma_test_loghandler_first_lsn-t.c:
  Auto merged
storage/maria/unittest/ma_test_loghandler_max_lsn-t.c:
  Auto merged
storage/maria/unittest/ma_test_loghandler_multigroup-t.c:
  Auto merged
storage/maria/unittest/ma_test_loghandler_multithread-t.c:
  Auto merged
storage/maria/unittest/ma_test_loghandler_noflush-t.c:
  Auto merged
storage/maria/unittest/ma_test_loghandler_pagecache-t.c:
  Auto merged
storage/maria/unittest/ma_test_loghandler_purge-t.c:
  Auto merged
storage/maria/ma_bitmap.c:
  Merge.
storage/maria/ma_loghandler.c:
  Merge.
storage/maria/unittest/Makefile.am:
  Merge.

storage/maria/Makefile.am

@@ -122,7 +122,8 @@ libmaria_a_SOURCES =	ma_init.c ma_open.c ma_extra.c ma_info.c ma_rkey.c \
 			ma_rt_index.c ma_rt_key.c ma_rt_mbr.c ma_rt_split.c \
 			ma_sp_key.c ma_control_file.c ma_loghandler.c \
 			ma_pagecache.c ma_pagecaches.c \
-			ma_checkpoint.c ma_recovery.c ma_commit.c
+			ma_checkpoint.c ma_recovery.c ma_commit.c \
+			ma_pagecrc.c
 CLEANFILES =		test?.MA? FT?.MA? isam.log ma_test_all ma_rt_test.MA? sp_test.MA?
 
 SUFFIXES = .sh

storage/maria/ma_bitmap.c

@@ -127,11 +127,6 @@
 #define FULL_HEAD_PAGE 4
 #define FULL_TAIL_PAGE 7
 
-/* If we don't have page checksum enabled, the bitmap page ends with this */
-uchar maria_bitmap_marker[4]=
-{(uchar) 255, (uchar) 255, (uchar) 255, (uchar) 254};
-uchar maria_normal_page_marker[4]=
-{(uchar) 255, (uchar) 255, (uchar) 255, (uchar) 255};
 /*#define WRONG_BITMAP_FLUSH 1*/ /*define only for provoking bugs*/
 #undef WRONG_BITMAP_FLUSH
 
@@ -147,6 +142,7 @@ static inline my_bool write_changed_bitmap(MARIA_SHARE *share,
 {
   DBUG_ENTER("write_changed_bitmap");
   DBUG_ASSERT(share->pagecache->block_size == bitmap->block_size);
+  DBUG_ASSERT(bitmap->file.write_callback != 0);
   DBUG_PRINT("info", ("bitmap->non_flushable: %u", bitmap->non_flushable));
   if ((bitmap->non_flushable == 0)
 #ifdef WRONG_BITMAP_FLUSH
@@ -223,7 +219,11 @@ my_bool _ma_bitmap_init(MARIA_SHARE *share, File file)
 
   bitmap->file.file= file;
   bitmap->block_size= share->block_size;
-  /* Size needs to be alligned on 6 */
+  pagecache_file_init(bitmap->file,  &maria_page_crc_check_bitmap,
+                      (share->options & HA_OPTION_PAGE_CHECKSUM ?
+                       &maria_page_crc_set_normal :
+                       &maria_page_filler_set_bitmap), share);
+  /* Size needs to be aligned on 6 */
   aligned_bit_blocks= (share->block_size - PAGE_SUFFIX_SIZE) / 6;
   bitmap->total_size= aligned_bit_blocks * 6;
   /*
@@ -438,8 +438,6 @@ void _ma_bitmap_delete_all(MARIA_SHARE *share)
   if (bitmap->map)                              /* Not in create */
   {
     bzero(bitmap->map, bitmap->block_size);
-    memcpy(bitmap->map + bitmap->block_size - sizeof(maria_bitmap_marker),
-           maria_bitmap_marker, sizeof(maria_bitmap_marker));
     bitmap->changed= 1;
     bitmap->page= 0;
     bitmap->used_size= bitmap->total_size;
@@ -764,8 +762,6 @@ static my_bool _ma_read_bitmap_page(MARIA_SHARE *share,
     */
     share->state.state.data_file_length= end_of_page;
     bzero(bitmap->map, bitmap->block_size);
-    memcpy(bitmap->map + bitmap->block_size - sizeof(maria_bitmap_marker),
-           maria_bitmap_marker, sizeof(maria_bitmap_marker));
     bitmap->used_size= 0;
 #ifndef DBUG_OFF
     memcpy(bitmap->map + bitmap->block_size, bitmap->map, bitmap->block_size);
@@ -775,9 +771,9 @@ static my_bool _ma_read_bitmap_page(MARIA_SHARE *share,
   bitmap->used_size= bitmap->total_size;
   DBUG_ASSERT(share->pagecache->block_size == bitmap->block_size);
   res= pagecache_read(share->pagecache,
-                       (PAGECACHE_FILE*)&bitmap->file, page, 0,
-                       (uchar*) bitmap->map,
-                       PAGECACHE_PLAIN_PAGE,
+                      &bitmap->file, page, 0,
+                      (uchar*) bitmap->map,
+                      PAGECACHE_PLAIN_PAGE,
                       PAGECACHE_LOCK_LEFT_UNLOCKED, 0) == NULL;
 
   /*
@@ -789,15 +785,6 @@ static my_bool _ma_read_bitmap_page(MARIA_SHARE *share,
     when running without any checksums.
   */
 
-  if (!res && !(share->options & HA_OPTION_PAGE_CHECKSUM) &&
-      !memcmp(bitmap->map + bitmap->block_size -
-              sizeof(maria_normal_page_marker),
-              maria_normal_page_marker,
-              sizeof(maria_normal_page_marker)))
-  {
-    res= 1;
-    my_errno= HA_ERR_WRONG_IN_RECORD;             /* File crashed */
-  }
 #ifndef DBUG_OFF
   if (!res)
     memcpy(bitmap->map + bitmap->block_size, bitmap->map, bitmap->block_size);
@@ -2478,17 +2465,18 @@ int _ma_bitmap_create_first(MARIA_SHARE *share)
 {
   uint block_size= share->bitmap.block_size;
   File file= share->bitmap.file.file;
-  char marker[sizeof(maria_bitmap_marker)];
+  char marker[CRC_SIZE];
 
-  if (share->options & HA_OPTION_PAGE_CHECKSUM)
-    bzero(marker, sizeof(marker));
-  else
-    bmove(marker, maria_bitmap_marker, sizeof(marker));
+  /*
+    Next write operation of the page will write correct CRC
+    if it is needed
+  */
+  int4store(marker, MARIA_NO_CRC_BITMAP_PAGE);
 
-  if (my_chsize(file, block_size - sizeof(maria_bitmap_marker),
+  if (my_chsize(file, block_size - sizeof(marker),
                 0, MYF(MY_WME)) ||
-      my_pwrite(file, marker, sizeof(maria_bitmap_marker),
-                block_size - sizeof(maria_bitmap_marker),
+      my_pwrite(file, marker, sizeof(marker),
+                block_size - sizeof(marker),
                 MYF(MY_NABP | MY_WME)))
     return 1;
   share->state.state.data_file_length= block_size;

storage/maria/ma_blockrec.c

@@ -1242,9 +1242,7 @@ static void make_empty_page(MARIA_HA *info, uchar *buff, uint page_type)
   buff[DIR_FREE_OFFSET]=  END_OF_DIR_FREE_LIST;
   int2store(buff + block_size - PAGE_SUFFIX_SIZE - DIR_ENTRY_SIZE,
             PAGE_HEADER_SIZE);
-  if (!(info->s->options & HA_OPTION_PAGE_CHECKSUM))
-    bfill(buff + block_size - KEYPAGE_CHECKSUM_SIZE,
-          KEYPAGE_CHECKSUM_SIZE, (uchar) 255);
+
   DBUG_VOID_RETURN;
 }
 
@@ -1555,10 +1553,6 @@ static my_bool write_full_pages(MARIA_HA *info,
             (data_size - copy_length) + PAGE_SUFFIX_SIZE);
 #endif
 
-    if (!(info->s->options & HA_OPTION_PAGE_CHECKSUM))
-      bfill(buff + block_size - KEYPAGE_CHECKSUM_SIZE,
-            KEYPAGE_CHECKSUM_SIZE, (uchar) 255);
-
     DBUG_ASSERT(share->pagecache->block_size == block_size);
     if (pagecache_write(share->pagecache,
                         &info->dfile, page, 0,

storage/maria/ma_check.c

@@ -2727,6 +2727,20 @@ err2:
 } /* maria_sort_index */
 
 
+/**
+  @brief put CRC on the page
+
+  @param buff            reference on the page buffer.
+  @param pos             position of the page in the file.
+  @param length          length of the page
+*/
+
+static void put_crc(char *buff, my_off_t pos, MARIA_SHARE *share)
+{
+  maria_page_crc_set_index(buff, pos / share->block_size, (uchar*) share);
+}
+
+
 	 /* Sort records recursive using one index */
 
 static int sort_one_index(HA_CHECK *param, MARIA_HA *info,
@@ -2804,6 +2818,7 @@ static int sort_one_index(HA_CHECK *param, MARIA_HA *info,
   /* Fill block with zero and write it to the new index file */
   length= _ma_get_page_used(share, buff);
   bzero((uchar*) buff+length,keyinfo->block_length-length);
+  put_crc(buff, new_page_pos, share);
   if (my_pwrite(new_file,(uchar*) buff,(uint) keyinfo->block_length,
 		new_page_pos,MYF(MY_NABP | MY_WAIT_IF_FULL)))
   {
@@ -4862,9 +4877,13 @@ static int sort_insert_key(MARIA_SORT_PARAM *sort_param,
                           DFLT_INIT_HITS, anc_buff))
       DBUG_RETURN(1);
   }
-  else if (my_pwrite(share->kfile.file, anc_buff,
-		     (uint) keyinfo->block_length,filepos, param->myf_rw))
-    DBUG_RETURN(1);
+  else
+  {
+    put_crc(anc_buff, filepos, share);
+    if (my_pwrite(share->kfile.file, anc_buff,
+                  (uint) keyinfo->block_length, filepos, param->myf_rw))
+      DBUG_RETURN(1);
+  }
   DBUG_DUMP("buff", anc_buff, _ma_get_page_used(share, anc_buff));
 
 	/* Write separator-key to block in next level */
@@ -4982,9 +5001,13 @@ int _ma_flush_pending_blocks(MARIA_SORT_PARAM *sort_param)
                             DFLT_INIT_HITS, key_block->buff))
 	DBUG_RETURN(1);
     }
-    else if (my_pwrite(info->s->kfile.file, key_block->buff,
-		       (uint) keyinfo->block_length,filepos, myf_rw))
+    else
+    {
+      put_crc(key_block->buff, filepos, info->s);
+      if (my_pwrite(info->s->kfile.file, key_block->buff,
+                    (uint) keyinfo->block_length,filepos, myf_rw))
       DBUG_RETURN(1);
+    }
     DBUG_DUMP("buff",key_block->buff,length);
     nod_flag=1;
   }
@@ -5571,6 +5594,14 @@ my_bool create_new_data_handle(MARIA_SORT_PARAM *param, File new_file)
     DBUG_RETURN(1);
 
   new_info= sort_info->new_info;
+  pagecache_file_init(new_info->s->bitmap.file, &maria_page_crc_check_bitmap,
+                      (new_info->s->options & HA_OPTION_PAGE_CHECKSUM ?
+                       &maria_page_crc_set_normal :
+                       &maria_page_filler_set_bitmap), new_info->s);
+  pagecache_file_init(new_info->dfile, &maria_page_crc_check_data,
+                      (new_info->s->options & HA_OPTION_PAGE_CHECKSUM ?
+                       &maria_page_crc_set_normal :
+                       &maria_page_filler_set_normal), new_info->s);
   change_data_file_descriptor(new_info, new_file);
   maria_lock_database(new_info, F_EXTRA_LCK);
   if ((sort_info->param->testflag & T_UNPACK) &&

storage/maria/ma_create.c

@@ -1049,6 +1049,10 @@ int maria_create(const char *name, enum data_file_type datafile_type,
       DROP+CREATE happened (applying REDOs to the wrong table).
     */
     share.kfile.file= file;
+    pagecache_file_init(share.kfile, &maria_page_crc_check_index,
+                        (share.options & HA_OPTION_PAGE_CHECKSUM ?
+                         &maria_page_crc_set_index :
+                         &maria_page_filler_set_normal), &share);
     if (_ma_update_create_rename_lsn_sub(&share, lsn, FALSE))
       goto err;
     my_free(log_data, MYF(0));
@@ -1241,6 +1245,10 @@ int _ma_initialize_data_file(MARIA_SHARE *share, File dfile)
   {
     share->bitmap.block_size= share->base.block_size;
     share->bitmap.file.file = dfile;
+    pagecache_file_init(share->bitmap.file, &maria_page_crc_check_bitmap,
+                        (share->options & HA_OPTION_PAGE_CHECKSUM ?
+                         &maria_page_crc_set_normal :
+                         &maria_page_filler_set_bitmap), share);
     return _ma_bitmap_create_first(share);
   }
   /*

storage/maria/ma_loghandler.h

@@ -59,7 +59,6 @@ struct st_maria_handler;
 /* Length of CRC at end of pages */
 #define ROW_EXTENT_PAGE_SIZE	5
 #define ROW_EXTENT_COUNT_SIZE   2
-#define CRC_LENGTH 4
 /* Size of file id in logs */
 #define FILEID_STORE_SIZE 2
 /* Size of page reference in log */

storage/maria/ma_open.c

@@ -151,6 +151,10 @@ static MARIA_HA *maria_clone_internal(MARIA_SHARE *share, int mode,
   info.errkey= -1;
   info.page_changed=1;
   info.keyread_buff= info.buff + share->base.max_key_block_length;
+  pagecache_file_init(info.dfile, &maria_page_crc_check_data,
+                      (share->options & HA_OPTION_PAGE_CHECKSUM ?
+                       &maria_page_crc_set_normal :
+                       &maria_page_filler_set_normal), share);
   bitmap_init(&info.changed_fields, changed_fields_bitmap,
               share->base.fields, 0);
   if ((*share->init)(&info))
@@ -714,6 +718,10 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
     errpos= 5;
 
     share->kfile.file= kfile;
+    pagecache_file_init(share->kfile, &maria_page_crc_check_index,
+                        (share->options & HA_OPTION_PAGE_CHECKSUM ?
+                         &maria_page_crc_set_index :
+                         &maria_page_filler_set_normal), share);
     share->this_process=(ulong) getpid();
     share->last_process= share->state.process;
     share->base.key_parts=key_parts;
@@ -1533,6 +1541,14 @@ int _ma_open_datafile(MARIA_HA *info, MARIA_SHARE *share,
   info->dfile.file= share->bitmap.file.file=
     my_open(share->data_file_name, share->mode | O_SHARE,
             MYF(MY_WME));
+  pagecache_file_init(share->bitmap.file, &maria_page_crc_check_bitmap,
+                      (share->options & HA_OPTION_PAGE_CHECKSUM ?
+                       &maria_page_crc_set_normal :
+                       &maria_page_filler_set_bitmap), share);
+  pagecache_file_init(info->dfile, &maria_page_crc_check_data,
+                      (share->options & HA_OPTION_PAGE_CHECKSUM ?
+                       &maria_page_crc_set_normal :
+                       &maria_page_filler_set_normal), share);
   return info->dfile.file >= 0 ? 0 : 1;
 }
 
@@ -1547,6 +1563,10 @@ int _ma_open_keyfile(MARIA_SHARE *share)
   share->kfile.file= my_open(share->unique_file_name,
                              share->mode | O_SHARE,
                              MYF(MY_WME));
+  pagecache_file_init(share->kfile, &maria_page_crc_check_index,
+                      (share->options & HA_OPTION_PAGE_CHECKSUM ?
+                       &maria_page_crc_set_index :
+                       &maria_page_filler_set_normal), share);
   pthread_mutex_unlock(&share->intern_lock);
   return (share->kfile.file < 0);
 }

storage/maria/ma_page.c

@@ -137,9 +137,6 @@ int _ma_write_keypage(register MARIA_HA *info,
   }
 #endif
   DBUG_ASSERT(share->pagecache->block_size == block_size);
-  if (!(share->options & HA_OPTION_PAGE_CHECKSUM))
-    bfill(buff + block_size - KEYPAGE_CHECKSUM_SIZE,
-          KEYPAGE_CHECKSUM_SIZE, (uchar) 255);
 
   res= pagecache_write(share->pagecache,
                        &share->kfile, page / block_size,
@@ -248,7 +245,7 @@ int _ma_dispose(register MARIA_HA *info, my_off_t pos, my_bool page_not_read)
                            lock_method, pin_method,
                            PAGECACHE_WRITE_DELAY, &page_link.link,
 			   LSN_IMPOSSIBLE,
-                           0, share->keypage_header+8, 0, 0))
+                           0, share->keypage_header + 8))
     result= 1;
 
 #ifdef IDENTICAL_PAGES_AFTER_RECOVERY

storage/maria/ma_pagecache.c

@@ -15,7 +15,7 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 /*
-  These functions handle page cacheing for Maria tables.
+  These functions handle page caching for Maria tables.
 
   One cache can handle many files.
   It must contain buffers of the same blocksize.
@@ -612,8 +612,18 @@ static uint pagecache_fwrite(PAGECACHE *pagecache,
     /* TODO: integrate with page format */
     lsn= lsn_korr(buffer + PAGE_LSN_OFFSET);
     DBUG_ASSERT(LSN_VALID(lsn));
-    translog_flush(lsn);
+    if (translog_flush(lsn))
+      DBUG_RETURN(1);
+  }
+  DBUG_PRINT("info", ("write_callback: 0x%lx  data: 0x%lx",
+                      (ulong) filedesc->write_callback,
+                      (ulong) filedesc->callback_data));
+  if ((filedesc->write_callback)(buffer, pageno, filedesc->callback_data))
+  {
+    DBUG_PRINT("error", ("write callback problem"));
+    DBUG_RETURN(1);
   }
+
   DBUG_RETURN(my_pwrite(filedesc->file, buffer, pagecache->block_size,
                         (pageno)<<(pagecache->shift), flags));
 }
@@ -2402,8 +2412,6 @@ retry:
       pagecache           pointer to a page cache data structure
       block               block to which buffer the data is to be read
       primary             <-> the current thread will read the data
-      validator           validator of read from the disk data
-      validator_data      pointer to the data need by the validator
 
   RETURN VALUE
     None
@@ -2417,9 +2425,7 @@ retry:
 
 static void read_block(PAGECACHE *pagecache,
                        PAGECACHE_BLOCK_LINK *block,
-                       my_bool primary,
-                       pagecache_disk_read_validator validator,
-                       uchar* validator_data)
+                       my_bool primary)
 {
 
   /* On entry cache_lock is locked */
@@ -2452,9 +2458,18 @@ static void read_block(PAGECACHE *pagecache,
     else
       block->status= PCBLOCK_READ;
 
-    if (validator != NULL &&
-        (*validator)(block->buffer, validator_data))
+    DBUG_PRINT("info", ("read_callback: 0x%lx  data: 0x%lx",
+                        (ulong) block->hash_link->file.read_callback,
+                        (ulong) block->hash_link->file.callback_data));
+    if ((*block->hash_link->file.read_callback)(block->buffer,
+                                                block->hash_link->pageno,
+                                                block->hash_link->
+                                                file.callback_data))
+    {
+      DBUG_PRINT("error", ("read callback problem"));
       block->status|= PCBLOCK_ERROR;
+    }
+
 
     DBUG_PRINT("read_block",
                ("primary request: new page in cache"));
@@ -2885,25 +2900,20 @@ void pagecache_unpin_by_link(PAGECACHE *pagecache,
 
 
 /*
-  Read a block of data from a cached file into a buffer;
+  @brief Read a block of data from a cached file into a buffer;
 
-  SYNOPSIS
-    pagecache_valid_read()
-    pagecache           pointer to a page cache data structure
-    file                handler for the file for the block of data to be read
-    pageno              number of the block of data in the file
-    level               determines the weight of the data
-    buff                buffer to where the data must be placed
-    type                type of the page
-    lock                lock change
-    link                link to the page if we pin it
-    validator           validator of read from the disk data
-    validator_data      pointer to the data need by the validator
+  @param pagecache      pointer to a page cache data structure
+  @param file           handler for the file for the block of data to be read
+  @param pageno         number of the block of data in the file
+  @param level          determines the weight of the data
+  @param buff           buffer to where the data must be placed
+  @param type           type of the page
+  @param lock           lock change
+  @param link           link to the page if we pin it
 
-  RETURN VALUE
-    Returns address from where the data is placed if successful, 0 - otherwise.
+  @return address from where the data is placed if successful, 0 - otherwise.
 
-    Pin will be chosen according to lock parameter (see lock_to_pin)
+  @note Pin will be chosen according to lock parameter (see lock_to_pin)
 */
 static enum pagecache_page_pin lock_to_pin[2][8]=
 {
@@ -2929,16 +2939,14 @@ static enum pagecache_page_pin lock_to_pin[2][8]=
   }
 };
 
-uchar *pagecache_valid_read(PAGECACHE *pagecache,
-                           PAGECACHE_FILE *file,
-                           pgcache_page_no_t pageno,
-                           uint level,
-                           uchar *buff,
-                           enum pagecache_page_type type,
-                           enum pagecache_page_lock lock,
-                           PAGECACHE_BLOCK_LINK **page_link,
-                           pagecache_disk_read_validator validator,
-                           uchar* validator_data)
+uchar *pagecache_read(PAGECACHE *pagecache,
+                      PAGECACHE_FILE *file,
+                      pgcache_page_no_t pageno,
+                      uint level,
+                      uchar *buff,
+                      enum pagecache_page_type type,
+                      enum pagecache_page_lock lock,
+                      PAGECACHE_BLOCK_LINK **page_link)
 {
   int error= 0;
   enum pagecache_page_pin pin= lock_to_pin[test(buff==0)][lock];
@@ -2995,8 +3003,7 @@ restart:
       DBUG_PRINT("info", ("read block 0x%lx", (ulong)block));
       /* The requested page is to be read into the block buffer */
       read_block(pagecache, block,
-                 (my_bool)(page_st == PAGE_TO_BE_READ),
-                 validator, validator_data);
+                 (my_bool)(page_st == PAGE_TO_BE_READ));
       DBUG_PRINT("info", ("read is done"));
     }
 
@@ -3313,9 +3320,7 @@ my_bool pagecache_write_part(PAGECACHE *pagecache,
                              enum pagecache_write_mode write_mode,
                              PAGECACHE_BLOCK_LINK **page_link,
                              LSN first_REDO_LSN_for_page,
-                             uint offset, uint size,
-                             pagecache_disk_read_validator validator,
-                             uchar* validator_data)
+                             uint offset, uint size)
 {
   PAGECACHE_BLOCK_LINK *block= NULL;
   PAGECACHE_BLOCK_LINK *fake_link;
@@ -3416,12 +3421,20 @@ restart:
           memcpy(block->buffer + offset, buff, size);
         block->status= PCBLOCK_READ;
         /*
-          The validator can change the page content (removing page
+          The read_callback can change the page content (removing page
           protection) so it have to be called
         */
-        if (validator != NULL &&
-            (*validator)(block->buffer, validator_data))
+        DBUG_PRINT("info", ("read_callback: 0x%lx  data: 0x%lx",
+                            (ulong) block->hash_link->file.read_callback,
+                            (ulong) block->hash_link->file.callback_data));
+        if ((*block->hash_link->file.read_callback)(block->buffer,
+                                                    block->hash_link->pageno,
+                                                    block->hash_link->
+                                                    file.callback_data))
+        {
+          DBUG_PRINT("error", ("read callback problem"));
           block->status|= PCBLOCK_ERROR;
+        }
         KEYCACHE_DBUG_PRINT("key_cache_insert",
                             ("Page injection"));
 #ifdef THREAD
@@ -3433,7 +3446,6 @@ restart:
     }
     else
     {
-      DBUG_ASSERT(validator == 0 && validator_data == 0);
       if (! (block->status & PCBLOCK_CHANGED))
           link_to_changed_list(pagecache, block);
 

storage/maria/ma_pagecache.h

@@ -74,15 +74,20 @@ enum pagecache_write_mode
   PAGECACHE_WRITE_DONE
 };
 
+/* page number for maria */
+typedef uint32 pgcache_page_no_t;
+
 /* file descriptor for Maria */
 typedef struct st_pagecache_file
 {
   File file;
+  my_bool (*read_callback)(uchar *page, pgcache_page_no_t offset,
+                           uchar *data);
+  my_bool (*write_callback)(uchar *page, pgcache_page_no_t offset,
+                            uchar *data);
+  uchar *callback_data;
 } PAGECACHE_FILE;
 
-/* page number for maria */
-typedef uint32 pgcache_page_no_t;
-
 /* declare structures that is used by  st_pagecache */
 
 struct st_pagecache_block_link;
@@ -94,8 +99,6 @@ typedef struct st_pagecache_hash_link PAGECACHE_HASH_LINK;
 
 #include <wqueue.h>
 
-typedef my_bool (*pagecache_disk_read_validator)(uchar *page, uchar *data);
-
 #define PAGECACHE_CHANGED_BLOCKS_HASH 128  /* must be power of 2 */
 #define PAGECACHE_PRIORITY_LOW 0
 #define PAGECACHE_PRIORITY_DEFAULT 3
@@ -192,26 +195,21 @@ extern ulong resize_pagecache(PAGECACHE *pagecache,
 extern void change_pagecache_param(PAGECACHE *pagecache, uint division_limit,
                                    uint age_threshold);
 
-#define pagecache_read(P,F,N,L,B,T,K,I) \
-  pagecache_valid_read(P,F,N,L,B,T,K,I,0,0)
-
-extern uchar *pagecache_valid_read(PAGECACHE *pagecache,
-                                  PAGECACHE_FILE *file,
-                                  pgcache_page_no_t pageno,
-                                  uint level,
-                                  uchar *buff,
-                                  enum pagecache_page_type type,
-                                  enum pagecache_page_lock lock,
-                                  PAGECACHE_BLOCK_LINK **link,
-                                  pagecache_disk_read_validator validator,
-                                  uchar* validator_data);
+extern uchar *pagecache_read(PAGECACHE *pagecache,
+                             PAGECACHE_FILE *file,
+                             pgcache_page_no_t pageno,
+                             uint level,
+                             uchar *buff,
+                             enum pagecache_page_type type,
+                             enum pagecache_page_lock lock,
+                             PAGECACHE_BLOCK_LINK **link);
 
 #define  pagecache_write(P,F,N,L,B,T,O,I,M,K,R) \
-   pagecache_write_part(P,F,N,L,B,T,O,I,M,K,R,0,(P)->block_size,0,0)
+   pagecache_write_part(P,F,N,L,B,T,O,I,M,K,R,0,(P)->block_size)
 
-#define  pagecache_inject(P,F,N,L,B,T,O,I,K,R,V,D) \
+#define  pagecache_inject(P,F,N,L,B,T,O,I,K,R) \
    pagecache_write_part(P,F,N,L,B,T,O,I,PAGECACHE_WRITE_DONE, \
-                        K,R,0,(P)->block_size,V,D)
+                        K,R,0,(P)->block_size)
 
 extern my_bool pagecache_write_part(PAGECACHE *pagecache,
                                     PAGECACHE_FILE *file,
@@ -225,9 +223,7 @@ extern my_bool pagecache_write_part(PAGECACHE *pagecache,
                                     PAGECACHE_BLOCK_LINK **link,
                                     LSN first_REDO_LSN_for_page,
                                     uint offset,
-                                    uint size,
-                                    pagecache_disk_read_validator validator,
-                                    uchar* validator_data);
+                                    uint size);
 extern void pagecache_unlock(PAGECACHE *pagecache,
                              PAGECACHE_FILE *file,
                              pgcache_page_no_t pageno,
@@ -261,6 +257,11 @@ extern void pagecache_unpin_by_link(PAGECACHE *pagecache,
 /* PCFLUSH_ERROR and PCFLUSH_PINNED. */
 #define PCFLUSH_PINNED_AND_ERROR (PCFLUSH_ERROR|PCFLUSH_PINNED)
 
+#define pagecache_file_init(F,RC,WC,D) \
+  do{ \
+    (F).read_callback= (RC); (F).write_callback= (WC); \
+    (F).callback_data= (uchar*)(D); \
+  } while(0)
 
 #define flush_pagecache_blocks(A,B,C)                   \
   flush_pagecache_blocks_with_filter(A,B,C,NULL,NULL)

storage/maria/ma_panic.c

@@ -99,12 +99,19 @@ int maria_panic(enum ha_panic_function flag)
       {					/* Open closed files */
 	char name_buff[FN_REFLEN];
 	if (info->s->kfile.file < 0)
+        {
+
 	  if ((info->s->kfile.file= my_open(fn_format(name_buff,
                                                       info->filename, "",
                                                       N_NAME_IEXT,4),
                                             info->mode,
                                             MYF(MY_WME))) < 0)
 	    error = my_errno;
+          pagecache_file_init(info->s->kfile, &maria_page_crc_check_index,
+                              (info->s->options & HA_OPTION_PAGE_CHECKSUM ?
+                               &maria_page_crc_set_index :
+                               &maria_page_filler_set_normal), info->s);
+        }
 	if (info->dfile.file < 0)
 	{
 	  if ((info->dfile.file= my_open(fn_format(name_buff, info->filename,
@@ -112,6 +119,10 @@ int maria_panic(enum ha_panic_function flag)
                                          info->mode,
                                          MYF(MY_WME))) < 0)
 	    error = my_errno;
+          pagecache_file_init(info->dfile, &maria_page_crc_check_data,
+                              (share->options & HA_OPTION_PAGE_CHECKSUM ?
+                               &maria_page_crc_set_normal:
+                               &maria_page_filler_set_normal), share);
 	  info->rec_cache.file= info->dfile.file;
 	}
       }

storage/maria/maria_chk.c

@@ -1670,6 +1670,10 @@ static int maria_sort_records(HA_CHECK *param,
   VOID(my_close(info->dfile.file, MYF(MY_WME)));
   param->out_flag|=O_NEW_DATA;			/* Data in new file */
   info->dfile.file= new_file;				/* Use new datafile */
+  pagecache_file_init(info->dfile, &maria_page_crc_check_data,
+                      (share->options & HA_OPTION_PAGE_CHECKSUM ?
+                       &maria_page_crc_set_normal :
+                       &maria_page_filler_set_normal), share);
   info->state->del=0;
   info->state->empty=0;
   share->state.dellink= HA_OFFSET_ERROR;

storage/maria/maria_def.h

@@ -44,7 +44,9 @@
 struct st_transaction;
 
 /* undef map from my_nosys; We need test-if-disk full */
-#undef my_write	
+#undef my_write
+
+#define CRC_SIZE 4
 
 typedef struct st_maria_status_info
 {
@@ -574,9 +576,19 @@ struct st_maria_handler
 #define _ma_store_keypage_flag(share,x,flag) x[(share)->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_FLAG_SIZE]= (flag)
 
 
+/*
+  TODO: write int4store_aligned as *((uint32 *) (T))= (uint32) (A) for
+  architectures where it is possible
+*/
+#define int4store_aligned(A,B) int4store((A),(B))
+
 #define maria_mark_crashed(x) do{(x)->s->state.changed|= STATE_CRASHED; \
     DBUG_PRINT("error", ("Marked table crashed"));                      \
   }while(0)
+#define maria_mark_crashed_share(x)                                     \
+  do{(x)->state.changed|= STATE_CRASHED;                                \
+    DBUG_PRINT("error", ("Marked table crashed"));                      \
+  }while(0)
 #define maria_mark_crashed_on_repair(x) do{(x)->s->state.changed|=      \
       STATE_CRASHED|STATE_CRASHED_ON_REPAIR;                            \
     (x)->update|= HA_STATE_CHANGED;                                     \
@@ -1040,4 +1052,27 @@ void _ma_tmp_disable_logging_for_table(MARIA_HA *info,
   { if (((S)->now_transactional= (S)->base.born_transactional))  \
       (S)->page_type= PAGECACHE_LSN_PAGE; }
 
+#define MARIA_NO_CRC_NORMAL_PAGE 0xffffffff
+#define MARIA_NO_CRC_BITMAP_PAGE 0xfffffffe
+extern my_bool maria_page_crc_set_index(uchar *page,
+                                        pgcache_page_no_t page_no,
+                                        uchar* data_ptr);
+extern my_bool maria_page_crc_set_normal(uchar *page,
+                                         pgcache_page_no_t page_no,
+                                         uchar* data_ptr);
+extern my_bool maria_page_crc_check_bitmap(uchar *page,
+                                           pgcache_page_no_t page_no,
+                                           uchar* data_ptr);
+extern my_bool maria_page_crc_check_data(uchar *page,
+                                           pgcache_page_no_t page_no,
+                                           uchar* data_ptr);
+extern my_bool maria_page_crc_check_index(uchar *page,
+                                           pgcache_page_no_t page_no,
+                                           uchar* data_ptr);
+extern my_bool maria_page_filler_set_bitmap(uchar *page,
+                                            pgcache_page_no_t page_no,
+                                            uchar* data_ptr);
+extern my_bool maria_page_filler_set_normal(uchar *page,
+                                            pgcache_page_no_t page_no,
+                                            uchar* data_ptr);
 extern PAGECACHE *maria_log_pagecache;

storage/maria/unittest/Makefile.am

@@ -47,7 +47,8 @@ noinst_PROGRAMS =	ma_control_file-t trnman-t lockman2-t \
 			ma_test_loghandler_first_lsn-t \
                         ma_test_loghandler_max_lsn-t \
                         ma_test_loghandler_purge-t \
-			ma_test_loghandler_readonly-t
+			ma_test_loghandler_readonly-t\
+                        ma_test_loghandler_nologs-t
 
 ma_test_loghandler_t_SOURCES = ma_test_loghandler-t.c ma_maria_log_cleanup.c ma_loghandler_examples.c
 ma_test_loghandler_multigroup_t_SOURCES = ma_test_loghandler_multigroup-t.c ma_maria_log_cleanup.c ma_loghandler_examples.c
@@ -61,6 +62,7 @@ ma_test_loghandler_max_lsn_t_SOURCES = ma_test_loghandler_max_lsn-t.c ma_maria_l
 ma_test_loghandler_purge_t_SOURCES = ma_test_loghandler_purge-t.c ma_maria_log_cleanup.c ma_loghandler_examples.c
 ma_test_loghandler_readonly_t_SOURCES = ma_test_loghandler_multigroup-t.c ma_maria_log_cleanup.c ma_loghandler_examples.c
 ma_test_loghandler_readonly_t_CPPFLAGS = -DREADONLY_TEST
+ma_test_loghandler_nologs_t_SOURCES = ma_test_loghandler_nologs-t.c ma_maria_log_cleanup.c ma_loghandler_examples.c
 
 ma_pagecache_single_src =	ma_pagecache_single.c test_file.c test_file.h
 ma_pagecache_consist_src =	ma_pagecache_consist.c test_file.c test_file.h

storage/maria/unittest/ma_maria_log_cleanup.c

@@ -37,9 +37,13 @@ my_bool maria_log_remove()
       if (fn_format(file_name, file,
                     maria_data_root, "", MYF(MY_WME)) == NullS ||
           my_delete(file_name, MYF(MY_WME)) != 0)
+      {
+        my_dirend(dirp);
         return 1;
+      }
     }
   }
+  my_dirend(dirp);
   return 0;
 }
 

storage/maria/unittest/ma_pagecache_consist.c

@@ -57,6 +57,18 @@ static uint flush_divider= 1000;
 #endif /*TEST_READERS*/
 #endif /*TEST_HIGH_CONCURENCY*/
 
+/**
+  @brief Dummy pagecache callback.
+*/
+
+static my_bool
+dummy_callback(__attribute__((unused)) uchar *page,
+               __attribute__((unused)) pgcache_page_no_t page_no,
+               __attribute__((unused)) uchar* data_ptr)
+{
+  return 0;
+}
+
 
 /*
   Get pseudo-random length of the field in (0;limit)
@@ -321,6 +333,7 @@ int main(int argc __attribute__((unused)),
 	    errno);
     exit(1);
   }
+  pagecache_file_init(file1, &dummy_callback, &dummy_callback, NULL);
   DBUG_PRINT("info", ("file1: %d", file1.file));
   if (chmod(file1_name, S_IRWXU | S_IRWXG | S_IRWXO) != 0)
   {

storage/maria/unittest/ma_pagecache_single.c

@@ -60,6 +60,19 @@ static struct file_desc  simple_delete_flush_test_file[]=
   { 0, 0}
 };
 
+/**
+  @brief Dummy pagecache callback.
+*/
+
+static my_bool
+dummy_callback(__attribute__((unused)) uchar *page,
+               __attribute__((unused)) pgcache_page_no_t page_no,
+               __attribute__((unused)) uchar* data_ptr)
+{
+  return 0;
+}
+
+
 
 /*
   Recreate and reopen a file for test
@@ -496,7 +509,6 @@ int main(int argc __attribute__((unused)),
 #endif
   DBUG_ENTER("main");
   DBUG_PRINT("info", ("Main thread: %s\n", my_thread_name()));
-
   if ((tmp_file= my_open(file2_name, O_CREAT | O_TRUNC | O_RDWR,
                          MYF(MY_WME))) < 0)
     exit(1);
@@ -508,6 +520,7 @@ int main(int argc __attribute__((unused)),
 	    errno);
     exit(1);
   }
+  pagecache_file_init(file1, &dummy_callback, &dummy_callback, NULL);
   my_close(tmp_file, MYF(0));
   my_delete(file2_name, MYF(0));
 

storage/maria/unittest/ma_test_loghandler-t.c

@@ -180,7 +180,6 @@ int main(int argc __attribute__((unused)), char *argv[])
                                LOG_FLAGS, 0, &translog_example_table_init))
   {
     fprintf(stderr, "Can't init loghandler (%d)\n", errno);
-    translog_destroy();
     exit(1);
   }
   /* Suppressing of automatic record writing */

storage/maria/unittest/ma_test_loghandler_first_lsn-t.c

@@ -70,7 +70,6 @@ int main(int argc __attribute__((unused)), char *argv[])
                                LOG_FLAGS, 0, &translog_example_table_init))
   {
     fprintf(stderr, "Can't init loghandler (%d)\n", errno);
-    translog_destroy();
     exit(1);
   }
   /* Suppressing of automatic record writing */

storage/maria/unittest/ma_test_loghandler_max_lsn-t.c

@@ -64,7 +64,6 @@ int main(int argc __attribute__((unused)), char *argv[])
                                LOG_FLAGS, 0, &translog_example_table_init))
   {
     fprintf(stderr, "Can't init loghandler (%d)\n", errno);
-    translog_destroy();
     exit(1);
   }
   /* Suppressing of automatic record writing */

storage/maria/unittest/ma_test_loghandler_multigroup-t.c

@@ -189,7 +189,6 @@ int main(int argc __attribute__((unused)), char *argv[])
                                0, 0, &translog_example_table_init))
   {
     fprintf(stderr, "Can't init loghandler (%d)\n", errno);
-    translog_destroy();
     exit(1);
   }
   /* Suppressing of automatic record writing */
@@ -354,7 +353,6 @@ int main(int argc __attribute__((unused)), char *argv[])
                                0, READONLY, &translog_example_table_init))
   {
     fprintf(stderr, "pass2: Can't init loghandler (%d)\n", errno);
-    translog_destroy();
     exit(1);
   }
 

storage/maria/unittest/ma_test_loghandler_multithread-t.c

@@ -287,7 +287,6 @@ int main(int argc __attribute__((unused)),
                                LOG_FLAGS, 0, &translog_example_table_init))
   {
     fprintf(stderr, "Can't init loghandler (%d)\n", errno);
-    translog_destroy();
     exit(1);
   }
   /* Suppressing of automatic record writing */

storage/maria/unittest/ma_test_loghandler_noflush-t.c

@@ -72,7 +72,6 @@ int main(int argc __attribute__((unused)), char *argv[])
                                LOG_FLAGS, 0, &translog_example_table_init))
   {
     fprintf(stderr, "Can't init loghandler (%d)\n", errno);
-    translog_destroy();
     exit(1);
   }
   /* Suppressing of automatic record writing */

storage/maria/unittest/ma_test_loghandler_pagecache-t.c

@@ -20,6 +20,19 @@ static char *first_translog_file= (char*)"maria_log.00000001";
 static char *file1_name= (char*)"page_cache_test_file_1";
 static PAGECACHE_FILE file1;
 
+/**
+  @brief Dummy pagecache callback.
+*/
+
+static my_bool
+dummy_callback(__attribute__((unused)) uchar *page,
+               __attribute__((unused)) pgcache_page_no_t page_no,
+               __attribute__((unused)) uchar* data_ptr)
+{
+  return 0;
+}
+
+
 int main(int argc __attribute__((unused)), char *argv[])
 {
   uint pagen;
@@ -72,7 +85,6 @@ int main(int argc __attribute__((unused)), char *argv[])
                                LOG_FLAGS, 0, &translog_example_table_init))
   {
     fprintf(stderr, "Can't init loghandler (%d)\n", errno);
-    translog_destroy();
     exit(1);
   }
   /* Suppressing of automatic record writing */
@@ -112,6 +124,7 @@ int main(int argc __attribute__((unused)), char *argv[])
 	    errno);
     exit(1);
   }
+  pagecache_file_init(file1, &dummy_callback, &dummy_callback, NULL);
   if (chmod(file1_name, S_IRWXU | S_IRWXG | S_IRWXO) != 0)
   {
     fprintf(stderr, "Got error during file1 chmod() (errno: %d)\n",

storage/maria/unittest/ma_test_loghandler_purge-t.c

@@ -67,7 +67,6 @@ int main(int argc __attribute__((unused)), char *argv[])
                                LOG_FLAGS, 0, &translog_example_table_init))
   {
     fprintf(stderr, "Can't init loghandler (%d)\n", errno);
-    translog_destroy();
     exit(1);
   }
   /* Suppressing of automatic record writing */

storage/maria/unittest/test_file.c

@@ -30,11 +30,6 @@ int test_file(PAGECACHE_FILE file, char *file_name,
   int step= 0;
   int res= 1;                                   /* ok */
 
-  if (my_sync(file.file, MYF(MY_WME | MY_IGNORE_BADFD)))
-  {
-    diag("Got error during syncing file\n");
-    exit(1);
-  }
   if ((stat= my_stat(file_name, &stat_buff, MYF(0))) == NULL)
   {
     diag("Can't stat() %s (errno: %d)\n", file_name, errno);