Merge oleksandr-byelkins-powerbook-g4-15.local:/Users/bell/mysql/bk/mysql-maria

into  oleksandr-byelkins-powerbook-g4-15.local:/Users/bell/mysql/bk/work-maria-wrn


storage/maria/ma_blockrec.c:
  Auto merged
storage/maria/ma_check.c:
  Auto merged
storage/maria/ma_control_file.c:
  Auto merged
storage/maria/ma_key_recover.c:
  Auto merged
storage/maria/ma_page.c:
  Auto merged
storage/maria/ma_pagecache.c:
  Auto merged
storage/maria/ma_recovery.c:
  Auto merged

include/maria.h

@@ -360,7 +360,7 @@ typedef struct st_maria_sort_param
   uchar *rec_buff;
   void *wordlist, *wordptr;
   MEM_ROOT wordroot;
-  char *record;
+  uchar *record;
   MY_TMPDIR *tmpdir;
 
   /* 

storage/maria/ma_bitmap.c

@@ -2532,7 +2532,7 @@ int _ma_bitmap_create_first(MARIA_SHARE *share)
 {
   uint block_size= share->bitmap.block_size;
   File file= share->bitmap.file.file;
-  char marker[CRC_SIZE];
+  uchar marker[CRC_SIZE];
 
   /*
     Next write operation of the page will write correct CRC

storage/maria/ma_blockrec.c

@@ -1198,7 +1198,7 @@ static void calc_record_size(MARIA_HA *info, const uchar *record,
       break;
     case FIELD_SKIP_ENDSPACE:                   /* CHAR */
     {
-      const char *pos, *end;
+      const uchar *pos, *end;
       for (pos= record + column->offset, end= pos + column->length;
            end > pos && end[-1] == ' '; end--)
         ;
@@ -2240,7 +2240,7 @@ static my_bool free_full_pages(MARIA_HA *info, MARIA_ROW *row)
     pagerange_store(log_data + FILEID_STORE_SIZE, extents_count);
     log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    (char*) log_data;
     log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
-    log_array[TRANSLOG_INTERNAL_PARTS + 1].str=    compact_extent_info;
+    log_array[TRANSLOG_INTERNAL_PARTS + 1].str=    (char*) compact_extent_info;
     log_array[TRANSLOG_INTERNAL_PARTS + 1].length= extents_length;
     res= translog_write_record(&lsn, LOGREC_REDO_FREE_BLOCKS, info->trn,
                                info,
@@ -3094,7 +3094,7 @@ static my_bool write_block_record(MARIA_HA *info,
         log_array[TRANSLOG_INTERNAL_PARTS + 0].length+= (2 +
                                                          PAGERANGE_STORE_SIZE);
         info->log_row_parts[TRANSLOG_INTERNAL_PARTS+1].str=
-          info->cur_row.extents;
+          (char *) info->cur_row.extents;
         info->log_row_parts[TRANSLOG_INTERNAL_PARTS+1].length=
           extents_length= info->cur_row.extents_count * ROW_EXTENT_SIZE;
 
@@ -3975,7 +3975,7 @@ my_bool _ma_delete_block_record(MARIA_HA *info, const uchar *record)
                           info->log_row_parts[TRANSLOG_INTERNAL_PARTS +
                                               0].length);
     info->log_row_parts[TRANSLOG_INTERNAL_PARTS+1].str=
-      info->cur_row.extents;
+      (char *) info->cur_row.extents;
     info->log_row_parts[TRANSLOG_INTERNAL_PARTS+1].length=
       extents_length= info->cur_row.extents_count * ROW_EXTENT_SIZE;
 
@@ -5236,7 +5236,7 @@ static size_t fill_insert_undo_parts(MARIA_HA *info, const uchar *record,
   log_parts++;
 
   /* Stored bitmap over packed (zero length or all-zero fields) */
-  log_parts->str=    info->cur_row.empty_bits;
+  log_parts->str=    (char *) info->cur_row.empty_bits;
   log_parts->length= share->base.pack_bytes;
   row_length+=       log_parts->length;
   log_parts++;
@@ -5244,7 +5244,7 @@ static size_t fill_insert_undo_parts(MARIA_HA *info, const uchar *record,
   if (share->base.max_field_lengths)
   {
     /* Store length of all not empty char, varchar and blob fields */
-    log_parts->str=      field_lengths-2;
+    log_parts->str=      (char *) field_lengths - 2;
     log_parts->length=   info->cur_row.field_lengths_length+2;
     int2store(log_parts->str, info->cur_row.field_lengths_length);
     row_length+= log_parts->length;
@@ -5256,8 +5256,8 @@ static size_t fill_insert_undo_parts(MARIA_HA *info, const uchar *record,
     /*
       Store total blob length to make buffer allocation easier during UNDO
      */
-    log_parts->str=      info->length_buff;
-    log_parts->length=   (uint) (ma_store_length(log_parts->str,
+    log_parts->str=      (char *) info->length_buff;
+    log_parts->length=   (uint) (ma_store_length((uchar *) log_parts->str,
                                                  info->cur_row.blob_length) -
                                  (uchar*) log_parts->str);
     row_length+=          log_parts->length;
@@ -5561,7 +5561,7 @@ static size_t fill_update_undo_parts(MARIA_HA *info, const uchar *oldrec,
   start_log_parts->str=  ((char*)
                           (start_field_data -
                            ma_calc_length_for_store_length(field_lengths)));
-  ma_store_length(start_log_parts->str, field_lengths);
+  ma_store_length((uchar *) start_log_parts->str, field_lengths);
   start_log_parts->length= (size_t) ((char*) field_data -
                                      start_log_parts->str);
   row_length+= start_log_parts->length;

storage/maria/ma_check.c

@@ -227,7 +227,7 @@ int maria_chk_del(HA_CHECK *param, register MARIA_HA *info,
       else
       {
 	param->record_checksum+=(ha_checksum) next_link;
-	next_link= _ma_rec_pos(info, buff+1);
+	next_link= _ma_rec_pos(info, (uchar *) buff + 1);
 	empty+=share->base.pack_reclength;
       }
     }
@@ -926,7 +926,7 @@ static int chk_index(HA_CHECK *param, MARIA_HA *info, MARIA_KEYDEF *keyinfo,
 			 llstr(page,llbuff),llstr(record,llbuff2),
 			 llstr(info->state->data_file_length,llbuff3)));
       DBUG_DUMP("key",(uchar*) key,key_length);
-      DBUG_DUMP("new_in_page",(char*) old_keypos,(uint) (keypos-old_keypos));
+      DBUG_DUMP("new_in_page", old_keypos, (uint) (keypos-old_keypos));
       goto err;
     }
     param->record_checksum+= (ha_checksum) record;
@@ -2311,8 +2311,9 @@ int maria_repair(HA_CHECK *param, register MARIA_HA *info,
       goto err;
   }
 
-  if (!(sort_param.record=(uchar*) my_malloc((uint) share->base.pack_reclength,
-					   MYF(0))) ||
+  if (!(sort_param.record= (uchar *) my_malloc((uint)
+                                               share->base.pack_reclength,
+                                               MYF(0))) ||
       _ma_alloc_buffer(&sort_param.rec_buff, &sort_param.rec_buff_size,
                        share->base.default_rec_buff_size))
   {
@@ -2370,7 +2371,7 @@ int maria_repair(HA_CHECK *param, register MARIA_HA *info,
       if (param->testflag & T_VERBOSE)
       {
 	VOID(_ma_make_key(info,(uint) info->errkey,info->lastkey,
-			  sort_param.record,0L));
+                          sort_param.record,0L));
 	_ma_print_key(stdout,share->keyinfo[info->errkey].seg,info->lastkey,
 		      USE_WHOLE_KEY);
       }
@@ -2833,7 +2834,7 @@ int maria_sort_index(HA_CHECK *param, register MARIA_HA *info, char *name)
   @param length          length of the page
 */
 
-static void put_crc(char *buff, my_off_t pos, MARIA_SHARE *share)
+static void put_crc(uchar *buff, my_off_t pos, MARIA_SHARE *share)
 {
   maria_page_crc_set_index(buff, (pgcache_page_no_t) (pos / share->block_size),
                            (uchar*) share);
@@ -3322,7 +3323,7 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
   }
 
   if (!(sort_param.record=(uchar*) my_malloc((uint) share->base.pack_reclength,
-					   MYF(0))) ||
+                                          MYF(0))) ||
       _ma_alloc_buffer(&sort_param.rec_buff, &sort_param.rec_buff_size,
                        share->base.default_rec_buff_size))
   {
@@ -3910,7 +3911,7 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
     sort_param[i].max_pos=sort_param[i].pos=share->pack.header_length;
 
     sort_param[i].record= (((uchar *)(sort_param+share->base.keys))+
-			   (share->base.pack_reclength * i));
+                          (share->base.pack_reclength * i));
     if (_ma_alloc_buffer(&sort_param[i].rec_buff, &sort_param[i].rec_buff_size,
                          share->base.default_rec_buff_size))
     {
@@ -4857,7 +4858,7 @@ int _ma_sort_write_record(MARIA_SORT_PARAM *sort_param)
 	    DBUG_RETURN(1);
 	  sort_info->buff_length=reclength;
 	}
-	from=sort_info->buff+ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER);
+	from= (uchar *) sort_info->buff+ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER);
       }
       /* We can use info->checksum here as only one thread calls this */
       info->cur_row.checksum= (*share->calc_check_checksum)(info,

storage/maria/ma_control_file.c

@@ -472,11 +472,11 @@ int ma_control_file_write_and_force(const LSN checkpoint_lsn, uint32 logno,
 
   /* Checksum is stored first */
   compile_time_assert(CF_CHECKSUM_OFFSET == 0);
-  sum= my_checksum(0, buffer + CF_CHECKSUM_SIZE,
+  sum= my_checksum(0, (const uchar *) buffer + CF_CHECKSUM_SIZE,
                    cf_changeable_size - CF_CHECKSUM_SIZE);
   int4store(buffer, sum);
 
-  if (my_pwrite(control_file_fd, buffer, cf_changeable_size,
+  if (my_pwrite(control_file_fd, (uchar *) buffer, cf_changeable_size,
                 cf_create_time_size, MYF(MY_FNABP |  MY_WME)) ||
       my_sync(control_file_fd, MYF(MY_WME)))
     DBUG_RETURN(1);

storage/maria/ma_create.c

@@ -1013,7 +1013,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
     /* we store the end-zero, for Recovery to just pass it to my_create() */
     log_array[TRANSLOG_INTERNAL_PARTS + 0].length=
       strlen(log_array[TRANSLOG_INTERNAL_PARTS + 0].str) + 1;
-    log_array[TRANSLOG_INTERNAL_PARTS + 1].str= log_data;
+    log_array[TRANSLOG_INTERNAL_PARTS + 1].str= (char *) log_data;
     /* symlink description is also needed for re-creation by Recovery: */
     log_array[TRANSLOG_INTERNAL_PARTS + 2].str= (char *)
       (ci->data_file_name ? ci->data_file_name : empty_string);
@@ -1333,7 +1333,7 @@ int _ma_update_state_lsns(MARIA_SHARE *share, LSN lsn, my_bool do_sync,
 int _ma_update_state_lsns_sub(MARIA_SHARE *share, LSN lsn, my_bool do_sync,
                               my_bool update_create_rename_lsn)
 {
-  char buf[LSN_STORE_SIZE * 3], *ptr;
+  uchar buf[LSN_STORE_SIZE * 3], *ptr;
   File file= share->kfile.file;
   DBUG_ASSERT(file >= 0);
   for (ptr= buf; ptr < (buf + sizeof(buf)); ptr+= LSN_STORE_SIZE)

storage/maria/ma_delete.c

@@ -1403,7 +1403,7 @@ static my_bool _ma_log_delete(MARIA_HA *info, my_off_t page, uchar *buff,
     int2store(log_pos+1, changed_length);
     log_pos+= 3;
     translog_parts= 2;
-    log_array[TRANSLOG_INTERNAL_PARTS + 1].str=    buff + offset;
+    log_array[TRANSLOG_INTERNAL_PARTS + 1].str=    (char *) buff + offset;
     log_array[TRANSLOG_INTERNAL_PARTS + 1].length= changed_length;
   }
 
@@ -1416,7 +1416,7 @@ static my_bool _ma_log_delete(MARIA_HA *info, my_off_t page, uchar *buff,
     int2store(log_pos+1, page_length);
     int4store(log_pos+3, crc);
 
-    log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].str=    log_pos;
+    log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].str= (char *) log_pos;
     log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].length= 7;
     changed_length+= 7;
     translog_parts++;

storage/maria/ma_ft_boolean_search.c

@@ -214,7 +214,7 @@ static int ftb_query_add_word(MYSQL_FTPARSER_PARAM *param,
       if (! ftb_param->up_quot) break;
       phrase_word= (FT_WORD *)alloc_root(&ftb_param->ftb->mem_root, sizeof(FT_WORD));
       tmp_element= (LIST *)alloc_root(&ftb_param->ftb->mem_root, sizeof(LIST));
-      phrase_word->pos= word;
+      phrase_word->pos= (uchar *) word;
       phrase_word->len= word_len;
       tmp_element->data= (void *)phrase_word;
       ftb_param->ftbe->phrase= list_add(ftb_param->ftbe->phrase, tmp_element);
@@ -240,7 +240,7 @@ static int ftb_query_add_word(MYSQL_FTPARSER_PARAM *param,
       if (info->yesno > 0) ftbe->up->ythresh++;
       ftb_param->ftbe= ftbe;
       ftb_param->depth++;
-      ftb_param->up_quot= info->quot;
+      ftb_param->up_quot= (uchar *) info->quot;
       break;
     case FT_TOKEN_RIGHT_PAREN:
       if (ftb_param->ftbe->document)
@@ -280,8 +280,8 @@ static int ftb_parse_query_internal(MYSQL_FTPARSER_PARAM *param,
 
   info.prev= ' ';
   info.quot= 0;
-  while (maria_ft_get_word(cs, start, end, &w, &info))
-    param->mysql_add_word(param, w.pos, w.len, &info);
+  while (maria_ft_get_word(cs, start, (uchar *) end, &w, &info))
+    param->mysql_add_word(param, (char *) w.pos, w.len, &info);
   return(0);
 }
 
@@ -308,7 +308,7 @@ static int _ftb_parse_query(FTB *ftb, uchar *query, uint len,
   param->mysql_add_word= ftb_query_add_word;
   param->mysql_ftparam= (void *)&ftb_param;
   param->cs= ftb->charset;
-  param->doc= query;
+  param->doc= (char *) query;
   param->length= len;
   param->flags= 0;
   param->mode= MYSQL_FTPARSER_FULL_BOOLEAN_INFO;
@@ -585,7 +585,7 @@ static int ftb_phrase_add_word(MYSQL_FTPARSER_PARAM *param,
   MY_FTB_PHRASE_PARAM *phrase_param= param->mysql_ftparam;
   FT_WORD *w= (FT_WORD *)phrase_param->document->data;
   LIST *phrase, *document;
-  w->pos= word;
+  w->pos= (uchar *) word;
   w->len= word_len;
   phrase_param->document= phrase_param->document->prev;
   if (phrase_param->phrase_length > phrase_param->document_length)
@@ -617,9 +617,9 @@ static int ftb_check_phrase_internal(MYSQL_FTPARSER_PARAM *param,
   MY_FTB_PHRASE_PARAM *phrase_param= param->mysql_ftparam;
   const char *docend= document + len;
   while (maria_ft_simple_get_word(phrase_param->cs, (uchar**) &document,
-                                  docend, &word, FALSE))
+                                  (const uchar *) docend, &word, FALSE))
   {
-    param->mysql_add_word(param, word.pos, word.len, 0);
+    param->mysql_add_word(param, (char *) word.pos, word.len, 0);
     if (phrase_param->match)
       break;
   }
@@ -663,7 +663,7 @@ static int _ftb_check_phrase(FTB *ftb, const uchar *document, uint len,
   param->mysql_add_word= ftb_phrase_add_word;
   param->mysql_ftparam= (void *)&ftb_param;
   param->cs= ftb->charset;
-  param->doc= (uchar *)document;
+  param->doc= (char *)document;
   param->length= len;
   param->flags= 0;
   param->mode= MYSQL_FTPARSER_WITH_STOPWORDS;
@@ -808,10 +808,11 @@ int maria_ft_boolean_read_next(FT_INFO *ftb, char *record)
       /* Clear all states, except that the table was updated */
       info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
 
-      if (!(*info->read_record)(info, record, curdoc))
+      if (!(*info->read_record)(info, (uchar *) record, curdoc))
       {
         info->update|= HA_STATE_AKTIV;          /* Record is read */
-        if (ftb->with_scan && maria_ft_boolean_find_relevance(ftb,record,0)==0)
+        if (ftb->with_scan &&
+            maria_ft_boolean_find_relevance(ftb, (uchar *) record, 0)==0)
             continue; /* no match */
         my_errno=0;
         goto err;
@@ -876,8 +877,9 @@ static int ftb_find_relevance_parse(MYSQL_FTPARSER_PARAM *param,
   FT_INFO *ftb= ftb_param->ftb;
   char *end= doc + len;
   FT_WORD w;
-  while (maria_ft_simple_get_word(ftb->charset, (uchar**) &doc, end, &w, TRUE))
-    param->mysql_add_word(param, w.pos, w.len, 0);
+  while (maria_ft_simple_get_word(ftb->charset, (uchar**) &doc,
+                                  (const uchar *) end, &w, TRUE))
+    param->mysql_add_word(param, (char *) w.pos, w.len, 0);
   return(0);
 }
 
@@ -934,7 +936,7 @@ float maria_ft_boolean_find_relevance(FT_INFO *ftb, uchar *record, uint length)
   {
     if (!ftsi.pos)
       continue;
-    param->doc= (uchar *)ftsi.pos;
+    param->doc= (char *)ftsi.pos;
     param->length= ftsi.len;
     if (unlikely(parser->parse(param)))
       return 0;

storage/maria/ma_ft_nlq_search.c

@@ -83,7 +83,7 @@ static int walk_and_match(FT_WORD *word, uint32 count, ALL_IN_ONE *aio)
 
   word->weight=LWS_FOR_QUERY;
 
-  keylen= _ma_ft_make_key(info,aio->keynr,(char*) keybuff,word,0);
+  keylen= _ma_ft_make_key(info, aio->keynr, keybuff, word, 0);
   keylen-=HA_FT_WLEN;
   doc_cnt=0;
 
@@ -319,7 +319,7 @@ int maria_ft_nlq_read_next(FT_INFO *handler, char *record)
   info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
 
   info->cur_row.lastpos= handler->doc[handler->curdoc].dpos;
-  if (!(*info->read_record)(info, record, info->cur_row.lastpos))
+  if (!(*info->read_record)(info, (uchar *) record, info->cur_row.lastpos))
   {
     info->update|= HA_STATE_AKTIV;		/* Record is read */
     return 0;

storage/maria/ma_ft_parser.c

@@ -85,7 +85,7 @@ my_bool maria_ft_boolean_check_syntax_string(const uchar *str)
   uint i, j;
 
   if (!str ||
-      (strlen(str)+1 != sizeof(ft_boolean_syntax)) ||
+      (strlen((char *) str) + 1 != sizeof(ft_boolean_syntax)) ||
       (str[0] != ' ' && str[1] != ' '))
     return 1;
   for (i=0; i<sizeof(ft_boolean_syntax); i++)
@@ -129,7 +129,7 @@ uchar maria_ft_get_word(CHARSET_INFO *cs, uchar **start, uchar *end,
         break;
       if (*doc == FTB_RQUOT && param->quot)
       {
-        param->quot=doc;
+        param->quot= (char *) doc;
         *start=doc+1;
         param->type= FT_TOKEN_RIGHT_PAREN;
         goto ret;
@@ -140,7 +140,7 @@ uchar maria_ft_get_word(CHARSET_INFO *cs, uchar **start, uchar *end,
         {
           /* param->prev=' '; */
           *start=doc+1;
-          if (*doc == FTB_LQUOT) param->quot=*start;
+          if (*doc == FTB_LQUOT) param->quot= (char *) *start;
           param->type= (*doc == FTB_RBR ? FT_TOKEN_RIGHT_PAREN : FT_TOKEN_LEFT_PAREN);
           goto ret;
         }
@@ -175,7 +175,8 @@ uchar maria_ft_get_word(CHARSET_INFO *cs, uchar **start, uchar *end,
     if ((param->trunc=(doc<end && *doc == FTB_TRUNC)))
       doc++;
 
-    if (((length >= ft_min_word_len && !is_stopword(word->pos, word->len))
+    if (((length >= ft_min_word_len && !is_stopword((char *) word->pos,
+                                                    word->len))
          || param->trunc) && length < ft_max_word_len)
     {
       *start=doc;
@@ -191,7 +192,7 @@ uchar maria_ft_get_word(CHARSET_INFO *cs, uchar **start, uchar *end,
   }
   if (param->quot)
   {
-    param->quot=*start=doc;
+    param->quot= (char *)(*start= doc);
     param->type= 3; /* FT_RBR */
     goto ret;
   }
@@ -235,7 +236,7 @@ uchar maria_ft_simple_get_word(CHARSET_INFO *cs, uchar **start,
 
     if (skip_stopwords == FALSE ||
         (length >= ft_min_word_len && length < ft_max_word_len &&
-         !is_stopword(word->pos, word->len)))
+         !is_stopword((char *) word->pos, word->len)))
     {
       *start= doc;
       DBUG_RETURN(1);
@@ -271,7 +272,7 @@ static int maria_ft_add_word(MYSQL_FTPARSER_PARAM *param,
     w.pos= ptr;
   }
   else
-    w.pos= word;
+    w.pos= (uchar *) word;
   w.len= word_len;
   if (!tree_insert(wtree, &w, 0, wtree->custom_arg))
   {
@@ -293,7 +294,7 @@ static int maria_ft_parse_internal(MYSQL_FTPARSER_PARAM *param,
   DBUG_ENTER("maria_ft_parse_internal");
 
   while (maria_ft_simple_get_word(wtree->custom_arg, &doc, end, &w, TRUE))
-    if (param->mysql_add_word(param, w.pos, w.len, 0))
+    if (param->mysql_add_word(param, (char *) w.pos, w.len, 0))
       DBUG_RETURN(1);
   DBUG_RETURN(0);
 }
@@ -313,7 +314,7 @@ int maria_ft_parse(TREE *wtree, uchar *doc, int doclen,
   param->mysql_add_word= maria_ft_add_word;
   param->mysql_ftparam= &my_param;
   param->cs= wtree->custom_arg;
-  param->doc= doc;
+  param->doc= (char *) doc;
   param->length= doclen;
   param->mode= MYSQL_FTPARSER_SIMPLE_MODE;
   DBUG_RETURN(parser->parse(param));

storage/maria/ma_key_recover.c

@@ -340,7 +340,7 @@ my_bool _ma_log_prefix(MARIA_HA *info, my_off_t page,
   }
 
   translog_parts= 1;
-  log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    log_data;
+  log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    (char *)log_data;
   log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
                                                          log_data);
   if (changed_length)
@@ -360,7 +360,7 @@ my_bool _ma_log_prefix(MARIA_HA *info, my_off_t page,
     int2store(log_pos+1, page_length);
     int4store(log_pos+3, crc);
 
-    log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].str=    log_pos;
+    log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].str= (char *)log_pos;
     log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].length= 7;
     changed_length+= 7;
     translog_parts++;
@@ -419,7 +419,7 @@ my_bool _ma_log_suffix(MARIA_HA *info, my_off_t page,
     extra_length= (uint) diff;
   }
 
-  log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    log_data;
+  log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    (char *) log_data;
   log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
                                                          log_data);
 
@@ -431,7 +431,7 @@ my_bool _ma_log_suffix(MARIA_HA *info, my_off_t page,
     int2store(log_pos+1, new_length);
     int4store(log_pos+3, crc);
 
-    log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].str=    log_pos;
+    log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].str= (char *) log_pos;
     log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].length= 7;
     extra_length+= 7;
     translog_parts++;
@@ -531,10 +531,10 @@ my_bool _ma_log_add(MARIA_HA *info, my_off_t page, uchar *buff,
   log_pos+= 3;
   translog_parts= 2;
 
-  log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    log_data;
+  log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    (char *) log_data;
   log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
                                                          log_data);
-  log_array[TRANSLOG_INTERNAL_PARTS + 1].str=    key_pos;
+  log_array[TRANSLOG_INTERNAL_PARTS + 1].str=    (char *) key_pos;
   log_array[TRANSLOG_INTERNAL_PARTS + 1].length= changed_length;
 
 #ifdef EXTRA_DEBUG_KEY_CHANGES
@@ -549,7 +549,7 @@ my_bool _ma_log_add(MARIA_HA *info, my_off_t page, uchar *buff,
     int2store(log_pos+1, new_length);
     int4store(log_pos+3, crc);
 
-    log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].str=    log_pos;
+    log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].str= (char *) log_pos;
     log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].length= 7;
     changed_length+= 7;
     translog_parts++;

storage/maria/ma_open.c

@@ -258,7 +258,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
   MARIA_HA info,*m_info,*old_info;
   MARIA_SHARE share_buff,*share;
   double rec_per_key_part[HA_MAX_POSSIBLE_KEY*HA_MAX_KEY_SEG];
-  long   nulls_per_key_part[HA_MAX_POSSIBLE_KEY*HA_MAX_KEY_SEG];
+  ulong  nulls_per_key_part[HA_MAX_POSSIBLE_KEY*HA_MAX_KEY_SEG];
   my_off_t key_root[HA_MAX_POSSIBLE_KEY];
   ulonglong max_key_file_length, max_data_file_length;
   File data_file= -1;
@@ -311,7 +311,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
 	       (uchar*) maria_file_magic, 4))
     {
       DBUG_PRINT("error",("Wrong header in %s",name_buff));
-      DBUG_DUMP("error_dump",(char*) share->state.header.file_version,
+      DBUG_DUMP("error_dump", share->state.header.file_version,
 		head_length);
       my_errno=HA_ERR_NOT_A_TABLE;
       goto err;

storage/maria/ma_page.c

@@ -70,7 +70,7 @@ uchar *_ma_fetch_keypage(register MARIA_HA *info,
       DBUG_PRINT("error",("page %lu had wrong page length: %u  keynr: %u",
                           (ulong) (pos / block_size), page_size,
                           _ma_get_keynr(share, tmp)));
-      DBUG_DUMP("page", (char*) tmp, page_size);
+      DBUG_DUMP("page", tmp, page_size);
       info->last_keypage = HA_OFFSET_ERROR;
       maria_print_error(share, HA_ERR_CRASHED);
       my_errno= HA_ERR_CRASHED;

storage/maria/ma_pagecache.c

@@ -3668,7 +3668,7 @@ my_bool pagecache_write_part(PAGECACHE *pagecache,
     pagecache->global_cache_write++;
     if (offset != 0 || size != pagecache->block_size)
     {
-      char *page_buffer= alloca(pagecache->block_size);
+      uchar *page_buffer= (uchar *) alloca(pagecache->block_size);
       if ((error= pagecache_fread(pagecache, file,
                                   page_buffer,
                                   pageno,
@@ -3680,7 +3680,7 @@ my_bool pagecache_write_part(PAGECACHE *pagecache,
         error= 1;
         goto end;
       }
-      memcpy(page_buffer + offset, buff, size);
+      memcpy((char *)page_buffer + offset, buff, size);
       buff= page_buffer;
     }
     if (pagecache_fwrite(pagecache, file, (uchar*) buff, pageno, type,

storage/maria/ma_recovery.c

@@ -709,7 +709,7 @@ prototype_redo_exec_hook(REDO_CREATE_TABLE)
   kfile_header= (uchar *)ptr;
   ptr+= kfile_size_before_extension;
   /* set header lsns */
-  ptr2= kfile_header + sizeof(info->s->state.header) +
+  ptr2= (char *) kfile_header + sizeof(info->s->state.header) +
     MARIA_FILE_CREATE_RENAME_LSN_OFFSET;
   for (i= 0; i<3; i++)
   {

storage/maria/ma_rt_test.c

@@ -28,9 +28,9 @@
 #define KEYALG HA_KEY_ALG_RTREE
 
 static int read_with_pos(MARIA_HA * file, int silent);
-static void create_record(char *record,uint rownr);
-static void create_record1(char *record,uint rownr);
-static void print_record(char * record,my_off_t offs,const char * tail);
+static void create_record(uchar *record,uint rownr);
+static void create_record1(uchar *record,uint rownr);
+static void print_record(uchar * record,my_off_t offs,const char * tail);
 static  int run_test(const char *filename);
 
 static double rt_data[]=
@@ -109,8 +109,8 @@ static int run_test(const char *filename)
   int i;
   int error;
   int row_count=0;
-  char record[MAX_REC_LENGTH];
-  char read_record[MAX_REC_LENGTH];
+  uchar record[MAX_REC_LENGTH];
+  uchar read_record[MAX_REC_LENGTH];
   int upd= 10;
   ha_rows hrows;
 
@@ -347,7 +347,7 @@ static int read_with_pos (MARIA_HA * file,int silent)
 {
   int error;
   int i;
-  char read_record[MAX_REC_LENGTH];
+  uchar read_record[MAX_REC_LENGTH];
 
   if (!silent)
     printf("- Reading rows with position\n");
@@ -390,12 +390,12 @@ static void bprint_record(char * record,
 #endif
 
 
-static void print_record(char * record,
+static void print_record(uchar *record,
 			 my_off_t offs __attribute__((unused)),
 			 const char * tail)
 {
   int i;
-  char * pos;
+  uchar *pos;
   double c;
 
   printf("     rec=(%d)",(unsigned char)record[0]);
@@ -412,10 +412,10 @@ static void print_record(char * record,
 
 
 
-static void create_record1(char *record,uint rownr)
+static void create_record1(uchar *record, uint rownr)
 {
    int i;
-   char * pos;
+   uchar *pos;
    double c=rownr+10;
 
    bzero((char*) record,MAX_REC_LENGTH);
@@ -454,10 +454,10 @@ static void create_record0(char *record,uint rownr)
 
 #endif
 
-static void create_record(char *record,uint rownr)
+static void create_record(uchar *record, uint rownr)
 {
    int i;
-   char *pos;
+   uchar *pos;
    double *data= rt_data+rownr*4;
    record[0]=0x01; /* DEL marker */
    for ( pos=record+1, i=0; i<ndims*2; i++)

storage/maria/ma_search.c

@@ -220,7 +220,7 @@ int _ma_bin_search(MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
                     (uchar*) key, key_len, comp_flag, not_used);
   if (flag < 0)
     start++;                    /* point at next, bigger key */
-  *ret_pos= (char*) (page+(uint) start*totlength);
+  *ret_pos= (page + (uint) start * totlength);
   *last_key= end == save_end;
   DBUG_PRINT("exit",("flag: %d  keypos: %d",flag,start));
   DBUG_RETURN(flag);
@@ -874,7 +874,7 @@ uint _ma_get_pack_key(register MARIA_KEYDEF *keyinfo, uint nod_flag,
 	    DBUG_PRINT("error",
                        ("Found too long null packed key: %u of %u at 0x%lx",
                         length, keyseg->length, (long) *page_pos));
-	    DBUG_DUMP("key",(char*) *page_pos,16);
+	    DBUG_DUMP("key", *page_pos, 16);
             maria_print_error(keyinfo->share, HA_ERR_CRASHED);
 	    my_errno=HA_ERR_CRASHED;
 	    return 0;
@@ -931,7 +931,7 @@ uint _ma_get_pack_key(register MARIA_KEYDEF *keyinfo, uint nod_flag,
       {
         DBUG_PRINT("error",("Found too long packed key: %u of %u at 0x%lx",
                             length, keyseg->length, (long) *page_pos));
-        DBUG_DUMP("key",(char*) *page_pos,16);
+        DBUG_DUMP("key", *page_pos, 16);
         maria_print_error(keyinfo->share, HA_ERR_CRASHED);
         my_errno=HA_ERR_CRASHED;
         return 0;                               /* Error */
@@ -1003,7 +1003,7 @@ uint _ma_get_binary_pack_key(register MARIA_KEYDEF *keyinfo, uint nod_flag,
       DBUG_PRINT("error",
                  ("Found too long binary packed key: %u of %u at 0x%lx",
                   length, keyinfo->maxlength, (long) *page_pos));
-      DBUG_DUMP("key",(char*) *page_pos,16);
+      DBUG_DUMP("key", *page_pos, 16);
       maria_print_error(keyinfo->share, HA_ERR_CRASHED);
       my_errno=HA_ERR_CRASHED;
       DBUG_RETURN(0);                                 /* Wrong key */

storage/maria/ma_write.c

@@ -1680,7 +1680,7 @@ static my_bool _ma_log_new(MARIA_HA *info, my_off_t page, uchar *buff,
   log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
 
   page_length-= LSN_STORE_SIZE;
-  log_array[TRANSLOG_INTERNAL_PARTS + 1].str=    buff + LSN_STORE_SIZE;
+  log_array[TRANSLOG_INTERNAL_PARTS + 1].str= (char *) buff + LSN_STORE_SIZE;
   log_array[TRANSLOG_INTERNAL_PARTS + 1].length= page_length;
 
   if (translog_write_record(&lsn, LOGREC_REDO_INDEX_NEW_PAGE,
@@ -1721,7 +1721,7 @@ static my_bool _ma_log_change(MARIA_HA *info, my_off_t page, uchar *buff,
 
   log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    (char*) log_data;
   log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
-  log_array[TRANSLOG_INTERNAL_PARTS + 1].str=    buff + offset;
+  log_array[TRANSLOG_INTERNAL_PARTS + 1].str=    (char *) buff + offset;
   log_array[TRANSLOG_INTERNAL_PARTS + 1].length= length;
 
   if (translog_write_record(&lsn, LOGREC_REDO_INDEX,
@@ -1851,7 +1851,7 @@ static my_bool _ma_log_split(MARIA_HA *info, my_off_t page, uchar *buff,
     extra_length+= data_length;
   }
 
-  log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    log_data;
+  log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    (char *) log_data;
   log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
                                                          log_data);
   DBUG_RETURN(translog_write_record(&lsn, LOGREC_REDO_INDEX,
@@ -1954,7 +1954,7 @@ static my_bool _ma_log_del_prefix(MARIA_HA *info, my_off_t page, uchar *buff,
     translog_parts= 2;
     extra_length= key_length;
   }
-  log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    log_data;
+  log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    (char *) log_data;
   log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
                                                          log_data);
   DBUG_RETURN(translog_write_record(&lsn, LOGREC_REDO_INDEX,
@@ -2026,7 +2026,7 @@ static my_bool _ma_log_key_middle(MARIA_HA *info, my_off_t page, uchar *buff,
   int2store(log_pos+3, data_changed_first);
   log_pos+= 5;
 
-  log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    log_data;
+  log_array[TRANSLOG_INTERNAL_PARTS + 0].str=    (char *) log_data;
   log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
                                                          log_data);
   log_array[TRANSLOG_INTERNAL_PARTS + 1].str=    ((char*) buff +

storage/maria/unittest/ma_control_file-t.c

@@ -305,7 +305,7 @@ static int test_binary_content()
     future change/breakage.
   */
 
-  char buffer[45];
+  uchar buffer[45];
   RET_ERR_UNLESS((fd= my_open(file_name,
                           O_BINARY | O_RDWR,
                           MYF(MY_WME))) >= 0);
@@ -373,7 +373,7 @@ static int test_bad_magic_string()
 
 static int test_bad_checksum()
 {
-  char buffer[4];
+  uchar buffer[4];
   int fd;
 
   RET_ERR_UNLESS(create_or_open_file() == CONTROL_FILE_OK);
@@ -421,7 +421,7 @@ static int test_future_size()
   */
   uint32 sum;
   int fd;
-  char buffer[CF_CREATE_TIME_TOTAL_SIZE + CF_CHANGEABLE_TOTAL_SIZE + 2];
+  uchar buffer[CF_CREATE_TIME_TOTAL_SIZE + CF_CHANGEABLE_TOTAL_SIZE + 2];
   RET_ERR_UNLESS((fd= my_open(file_name,
                           O_BINARY | O_RDWR,
                           MYF(MY_WME))) >= 0);
@@ -463,7 +463,7 @@ static int test_future_size()
 
 static int test_bad_hchecksum()
 {
-  char buffer[4];
+  uchar buffer[4];
   int fd;
 
   RET_ERR_UNLESS(create_or_open_file() == CONTROL_FILE_OK);
@@ -490,7 +490,7 @@ static int test_bad_hchecksum()
 
 static int test_bad_size()
 {
-  char buffer[]=
+  uchar buffer[]=
     "123456789012345678901234567890123456789012345678901234567890123456";
   int fd, i;
 

storage/maria/unittest/ma_pagecache_consist.c

@@ -223,7 +223,7 @@ void reader(int num)
   for (i= 0; i < number_of_tests; i++)
   {
     uint page= get_len(number_of_pages);
-    pagecache_read(&pagecache, &file1, page, 3, (char*)buffr,
+    pagecache_read(&pagecache, &file1, page, 3, buffr,
                    PAGECACHE_PLAIN_PAGE,
                    PAGECACHE_LOCK_LEFT_UNLOCKED,
                    0);
@@ -243,13 +243,13 @@ void writer(int num)
   {
     uint end;
     uint page= get_len(number_of_pages);
-    pagecache_read(&pagecache, &file1, page, 3, (char*)buffr,
+    pagecache_read(&pagecache, &file1, page, 3, buffr,
                    PAGECACHE_PLAIN_PAGE,
                    PAGECACHE_LOCK_WRITE,
                    0);
     end= check_page(buffr, page * PAGE_SIZE, 1, page, num);
     put_rec(buffr, end, get_len(record_length_limit), num);
-    pagecache_write(&pagecache, &file1, page, 3, (char*)buffr,
+    pagecache_write(&pagecache, &file1, page, 3, buffr,
                     PAGECACHE_PLAIN_PAGE,
                     PAGECACHE_LOCK_WRITE_UNLOCK,
                     PAGECACHE_UNPIN,
@@ -347,7 +347,7 @@ int main(int argc __attribute__((unused)),
   DBUG_PRINT("info", ("file1: %d", file1.file));
   if (my_chmod(file1_name, S_IRWXU | S_IRWXG | S_IRWXO, MYF(MY_WME)))
     exit(1);
-  my_pwrite(file1.file, "test file", 9, 0, MYF(0));
+  my_pwrite(file1.file, (const uchar *)"test file", 9, 0, MYF(0));
 
   if ((error= pthread_cond_init(&COND_thread_count, NULL)))
   {
@@ -394,7 +394,7 @@ int main(int argc __attribute__((unused)),
     memset(buffr, '\0', PAGE_SIZE);
     for (i= 0; i < number_of_pages; i++)
     {
-      pagecache_write(&pagecache, &file1, i, 3, (char*)buffr,
+      pagecache_write(&pagecache, &file1, i, 3, buffr,
                       PAGECACHE_PLAIN_PAGE,
                       PAGECACHE_LOCK_LEFT_UNLOCKED,
                       PAGECACHE_PIN_LEFT_UNPINNED,

storage/maria/unittest/ma_pagecache_single.c

@@ -140,13 +140,13 @@ int simple_read_write_test()
   int res;
   DBUG_ENTER("simple_read_write_test");
   bfill(buffw, PAGE_SIZE, '\1');
-  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 0, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_LEFT_UNLOCKED,
                   PAGECACHE_PIN_LEFT_UNPINNED,
                   PAGECACHE_WRITE_DELAY,
                   0, LSN_IMPOSSIBLE);
-  pagecache_read(&pagecache, &file1, 0, 3, (char*)buffr,
+  pagecache_read(&pagecache, &file1, 0, 3, buffr,
                  PAGECACHE_PLAIN_PAGE,
                  PAGECACHE_LOCK_LEFT_UNLOCKED,
                  0);
@@ -181,7 +181,7 @@ int simple_read_change_write_read_test()
 
   /* prepare the file */
   bfill(buffw, PAGE_SIZE, '\1');
-  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 0, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_LEFT_UNLOCKED,
                   PAGECACHE_PIN_LEFT_UNPINNED,
@@ -193,19 +193,19 @@ int simple_read_change_write_read_test()
     exit(1);
   }
   /* test */
-  pagecache_read(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_read(&pagecache, &file1, 0, 3, buffw,
                  PAGECACHE_PLAIN_PAGE,
                  PAGECACHE_LOCK_WRITE,
                  0);
   bfill(buffw, PAGE_SIZE/2, '\65');
-  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 0, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_WRITE_UNLOCK,
                   PAGECACHE_UNPIN,
                   PAGECACHE_WRITE_DELAY,
                   0, LSN_IMPOSSIBLE);
 
-  pagecache_read(&pagecache, &file1, 0, 3, (char*)buffr,
+  pagecache_read(&pagecache, &file1, 0, 3, buffr,
                  PAGECACHE_PLAIN_PAGE,
                  PAGECACHE_LOCK_LEFT_UNLOCKED,
                  0);
@@ -244,7 +244,7 @@ int simple_pin_test()
   DBUG_ENTER("simple_pin_test");
   /* prepare the file */
   bfill(buffw, PAGE_SIZE, '\1');
-  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 0, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_LEFT_UNLOCKED,
                   PAGECACHE_PIN_LEFT_UNPINNED,
@@ -256,18 +256,18 @@ int simple_pin_test()
     diag("Got error during flushing pagecache\n");
     exit(1);
   }
-  pagecache_read(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_read(&pagecache, &file1, 0, 3, buffw,
                  PAGECACHE_PLAIN_PAGE,
                  PAGECACHE_LOCK_WRITE,
                  0);
-  pagecache_write(&pagecache, &file1, 1, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 1, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_LEFT_UNLOCKED,
                   PAGECACHE_PIN_LEFT_UNPINNED,
                   PAGECACHE_WRITE_DELAY,
                   0, LSN_IMPOSSIBLE);
   bfill(buffw + PAGE_SIZE/2, PAGE_SIZE/2, ((unsigned char) 129));
-  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 0, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_WRITE_TO_READ,
                   PAGECACHE_PIN_LEFT_PINNED,
@@ -319,7 +319,7 @@ int simple_pin_no_lock_test()
   DBUG_ENTER("simple_pin_no_lock_test");
   /* prepare the file */
   bfill(buffw, PAGE_SIZE, '\4');
-  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 0, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_LEFT_UNLOCKED,
                   PAGECACHE_PIN_LEFT_UNPINNED,
@@ -332,7 +332,7 @@ int simple_pin_no_lock_test()
     exit(1);
   }
   bfill(buffw, PAGE_SIZE, '\5');
-  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 0, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_LEFT_UNLOCKED,
                   PAGECACHE_PIN,
@@ -368,7 +368,7 @@ int simple_pin_no_lock_test()
      "Simple pin (no lock) page result file 2");
 
   bfill(buffw, PAGE_SIZE, '\6');
-  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 0, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_WRITE,
                   PAGECACHE_PIN,
@@ -415,7 +415,7 @@ int simple_delete_forget_test()
   DBUG_ENTER("simple_delete_forget_test");
   /* prepare the file */
   bfill(buffw, PAGE_SIZE, '\1');
-  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 0, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_LEFT_UNLOCKED,
                   PAGECACHE_PIN_LEFT_UNPINNED,
@@ -424,7 +424,7 @@ int simple_delete_forget_test()
   flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
   /* test */
   bfill(buffw, PAGE_SIZE, '\2');
-  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 0, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_LEFT_UNLOCKED,
                   PAGECACHE_PIN_LEFT_UNPINNED,
@@ -458,7 +458,7 @@ int simple_delete_flush_test()
   DBUG_ENTER("simple_delete_flush_test");
   /* prepare the file */
   bfill(buffw, PAGE_SIZE, '\1');
-  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 0, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_WRITE,
                   PAGECACHE_PIN,
@@ -467,7 +467,7 @@ int simple_delete_flush_test()
   flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
   /* test */
   bfill(buffw, PAGE_SIZE, '\2');
-  pagecache_write(&pagecache, &file1, 0, 3, (char*)buffw,
+  pagecache_write(&pagecache, &file1, 0, 3, buffw,
                   PAGECACHE_PLAIN_PAGE,
                   PAGECACHE_LOCK_LEFT_WRITELOCKED,
                   PAGECACHE_PIN_LEFT_PINNED,
@@ -511,7 +511,7 @@ int simple_big_test()
     bfill(buffw, PAGE_SIZE, (unsigned char) (i & 0xff));
     desc[i].length= PAGE_SIZE;
     desc[i].content= (i & 0xff);
-    pagecache_write(&pagecache, &file1, i, 3, (char*)buffw,
+    pagecache_write(&pagecache, &file1, i, 3, buffw,
                     PAGECACHE_PLAIN_PAGE,
                     PAGECACHE_LOCK_LEFT_UNLOCKED,
                     PAGECACHE_PIN_LEFT_UNPINNED,
@@ -525,7 +525,7 @@ int simple_big_test()
   for (i= 0; i < PCACHE_SIZE/(PAGE_SIZE/2); i++)
   {
     int j;
-    pagecache_read(&pagecache, &file1, i, 3, (char*)buffr,
+    pagecache_read(&pagecache, &file1, i, 3, buffr,
                    PAGECACHE_PLAIN_PAGE,
                    PAGECACHE_LOCK_LEFT_UNLOCKED,
                    0);
@@ -545,7 +545,7 @@ int simple_big_test()
   {
     int j, page;
     page= rand() % (PCACHE_SIZE/(PAGE_SIZE/2));
-    pagecache_read(&pagecache, &file1, page, 3, (char*)buffr,
+    pagecache_read(&pagecache, &file1, page, 3, buffr,
                    PAGECACHE_PLAIN_PAGE,
                    PAGECACHE_LOCK_LEFT_UNLOCKED,
                    0);
@@ -665,7 +665,7 @@ int main(int argc __attribute__((unused)),
   DBUG_PRINT("info", ("file1: %d", file1.file));
   if (my_chmod(file1_name, S_IRWXU | S_IRWXG | S_IRWXO, MYF(MY_WME)))
     exit(1);
-  my_pwrite(file1.file, "test file", 9, 0, MYF(MY_WME));
+  my_pwrite(file1.file, (const uchar*)"test file", 9, 0, MYF(MY_WME));
 
   if ((error= pthread_cond_init(&COND_thread_count, NULL)))
   {

storage/maria/unittest/ma_test_loghandler_pagecache-t.c

@@ -145,7 +145,7 @@ int main(int argc __attribute__((unused)), char *argv[])
 
     bzero(page, PCACHE_PAGE);
     lsn_store(page, lsn);
-    pagecache_write(&pagecache, &file1, 0, 3, (char*)page,
+    pagecache_write(&pagecache, &file1, 0, 3, page,
                     PAGECACHE_LSN_PAGE,
                     PAGECACHE_LOCK_LEFT_UNLOCKED,
                     PAGECACHE_PIN_LEFT_UNPINNED,

storage/maria/unittest/test_file.c

@@ -74,7 +74,7 @@ int test_file(PAGECACHE_FILE file, char *file_name,
   my_seek(file.file, 0, SEEK_SET, MYF(MY_WME));
   while (desc[step].length != 0)
   {
-    if (my_read(file.file, (char*)buffr, desc[step].length, MYF(0)) !=
+    if (my_read(file.file, buffr, desc[step].length, MYF(0)) !=
         desc[step].length)
     {
       diag("Can't read %u bytes from %s (file: %d  errno: %d)\n",