mi_check.c
上传用户:tsgydb
上传日期:2007-04-14
资源大小:10674k
文件大小:96k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /* Descript, check and repair of ISAM tables */
  14. #include "fulltext.h"
  15. #include <m_ctype.h>
  16. #include <stdarg.h>
  17. #include <getopt.h>
  18. #include <assert.h>
  19. #ifdef HAVE_SYS_VADVICE_H
  20. #include <sys/vadvise.h>
  21. #endif
  22. #ifdef HAVE_SYS_MMAN_H
  23. #include <sys/mman.h>
  24. #endif
  25. #ifndef USE_RAID
  26. #define my_raid_create(A,B,C,D,E,F,G) my_create(A,B,C,G)
  27. #define my_raid_delete(A,B,C) my_delete(A,B)
  28. #endif
  29. /* Functions defined in this file */
  30. static int check_k_link(MI_CHECK *param, MI_INFO *info,uint nr);
  31. static int chk_index(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
  32.      my_off_t page, uchar *buff, ha_rows *keys,
  33.      ha_checksum *key_checksum, uint level);
  34. static uint isam_key_length(MI_INFO *info,MI_KEYDEF *keyinfo);
  35. static ha_checksum calc_checksum(ha_rows count);
  36. static int writekeys(MI_INFO *info,byte *buff,my_off_t filepos);
  37. static int sort_one_index(MI_CHECK *param, MI_INFO *info,MI_KEYDEF *keyinfo,
  38.   my_off_t pagepos, File new_file);
  39. static int sort_key_read(SORT_INFO *sort_info,void *key);
  40. static int sort_get_next_record(SORT_INFO *sort_info);
  41. static int sort_key_cmp(SORT_INFO *sort_info, const void *a,const void *b);
  42. static int sort_key_write(SORT_INFO *sort_info, const void *a);
  43. static my_off_t get_record_for_key(MI_INFO *info,MI_KEYDEF *keyinfo,
  44. uchar *key);
  45. static int sort_insert_key(MI_CHECK *param, reg1 SORT_KEY_BLOCKS *key_block,
  46.    uchar *key, my_off_t prev_block);
  47. static int sort_delete_record(MI_CHECK *param);
  48. static int flush_pending_blocks(MI_CHECK *param);
  49. static SORT_KEY_BLOCKS *alloc_key_blocks(MI_CHECK *param, uint blocks,
  50.   uint buffer_length);
  51. static void update_key_parts(MI_KEYDEF *keyinfo,
  52.      ulong *rec_per_key_part,
  53.      ulonglong *unique,
  54.      ulonglong records);
  55. static ha_checksum mi_byte_checksum(const byte *buf, uint length);
  56. #ifdef __WIN__
  57. static double ulonglong2double(ulonglong value)
  58. {
  59.   longlong nr=(longlong) value;
  60.   if (nr >= 0)
  61.     return (double) nr;
  62.   return (18446744073709551616.0 + (double) nr);
  63. }
  64. #if SIZEOF_OFF_T > 4
  65. #define my_off_t2double(A) ulonglong2double(A)
  66. #else
  67. #define my_off_t2double(A) ((double) (A))
  68. #endif /* SIZEOF_OFF_T > 4 */
  69. #endif
  70. void myisamchk_init(MI_CHECK *param)
  71. {
  72.   bzero((gptr) param,sizeof(*param));
  73.   param->opt_follow_links=1;
  74.   param->keys_in_use= ~(ulonglong) 0;
  75.   param->search_after_block=HA_OFFSET_ERROR;
  76.   param->auto_increment_value= 0;
  77.   param->use_buffers=USE_BUFFER_INIT;
  78.   param->read_buffer_length=READ_BUFFER_INIT;
  79.   param->write_buffer_length=READ_BUFFER_INIT;
  80.   param->sort_buffer_length=SORT_BUFFER_INIT;
  81.   param->sort_key_blocks=BUFFERS_WHEN_SORTING;
  82.   param->tmpfile_createflag=O_RDWR | O_TRUNC | O_EXCL;
  83.   param->myf_rw=MYF(MY_NABP | MY_WME | MY_WAIT_IF_FULL);
  84.   param->sort_info.param=param;
  85.   param->start_check_pos=0;
  86. }
  87. /* Check the status flags for the table */
  88. int chk_status(MI_CHECK *param, register MI_INFO *info)
  89. {
  90.   MYISAM_SHARE *share=info->s;
  91.   if (mi_is_crashed_on_repair(info))
  92.     mi_check_print_warning(param,
  93.    "Table is marked as crashed and last repair failed");
  94.   else if (mi_is_crashed(info))
  95.     mi_check_print_warning(param,
  96.    "Table is marked as crashed");
  97.   if (share->state.open_count != (uint) (info->s->global_changed ? 1 : 0))
  98.   {
  99.     mi_check_print_warning(param,
  100.    "%d clients is using or hasn't closed the table properly",
  101.    share->state.open_count);
  102.   }
  103.   return 0;
  104. }
  105. /* Check delete links */
  106. int chk_del(MI_CHECK *param, register MI_INFO *info, uint test_flag)
  107. {
  108.   reg2 ha_rows i;
  109.   uint j,delete_link_length;
  110.   my_off_t empty,next_link,old_link;
  111.   char buff[22],buff2[22];
  112.   DBUG_ENTER("chk_del");
  113.   if (!(test_flag & T_SILENT))
  114.     puts("- check key delete-chain");
  115.   LINT_INIT(old_link);
  116.   param->record_checksum=0;
  117.   param->key_file_blocks=info->s->base.keystart;
  118.   for (j=0 ; j < info->s->state.header.max_block_size ; j++)
  119.     if (check_k_link(param,info,j))
  120.       goto wrong;
  121.   delete_link_length=((info->s->options & HA_OPTION_PACK_RECORD) ? 20 :
  122.       info->s->rec_reflength+1);
  123.   if (!(test_flag & T_SILENT))
  124.     puts("- check record delete-chain");
  125.   next_link=info->s->state.dellink;
  126.   if (info->state->del == 0)
  127.   {
  128.     if (test_flag & T_VERBOSE)
  129.     {
  130.       puts("No recordlinks");
  131.     }
  132.   }
  133.   else
  134.   {
  135.     if (test_flag & T_VERBOSE)
  136.       printf("Recordlinks:    ");
  137.     empty=0;
  138.     for (i= info->state->del ; i > 0L && next_link != HA_OFFSET_ERROR ; i--)
  139.     {
  140.       if (test_flag & T_VERBOSE)
  141. printf(" %9s",llstr(next_link,buff));
  142.       if (next_link >= info->state->data_file_length)
  143. goto wrong;
  144.       if (my_pread(info->dfile,(char*) buff,delete_link_length,
  145.    next_link,MYF(MY_NABP)))
  146.       {
  147. if (test_flag & T_VERBOSE) puts("");
  148. mi_check_print_error(param,"Can't read delete-link at filepos: %s",
  149.     llstr(next_link,buff));
  150. DBUG_RETURN(1);
  151.       }
  152.       if (*buff != '')
  153.       {
  154. if (test_flag & T_VERBOSE) puts("");
  155. mi_check_print_error(param,"Record at pos: %s is not remove-marked",
  156.     llstr(next_link,buff));
  157. goto wrong;
  158.       }
  159.       if (info->s->options & HA_OPTION_PACK_RECORD)
  160.       {
  161. my_off_t prev_link=mi_sizekorr(buff+12);
  162. if (empty && prev_link != old_link)
  163. {
  164.   if (test_flag & T_VERBOSE) puts("");
  165.   mi_check_print_error(param,"Deleted block at %s doesn't point back at previous delete link",llstr(next_link,buff2));
  166.   goto wrong;
  167. }
  168. old_link=next_link;
  169. next_link=mi_sizekorr(buff+4);
  170. empty+=mi_uint3korr(buff+1);
  171.       }
  172.       else
  173.       {
  174. param->record_checksum+=(ha_checksum) next_link;
  175. next_link=_mi_rec_pos(info->s,(uchar*) buff+1);
  176. empty+=info->s->base.pack_reclength;
  177.       }
  178.     }
  179.     if (empty != info->state->empty)
  180.     {
  181.       if (test_flag & T_VERBOSE) puts("");
  182.       mi_check_print_warning(param,
  183.      "Not used space is supposed to be: %s but is: %s",
  184.      llstr(info->state->empty,buff),
  185.      llstr(empty,buff2));
  186.       info->state->empty=empty;
  187.     }
  188.     if (i != 0 || next_link != HA_OFFSET_ERROR)
  189.       goto wrong;
  190.     if (test_flag & T_VERBOSE) puts("n");
  191.   }
  192.   DBUG_RETURN(0);
  193. wrong:
  194.   param->retry_without_quick=1; /* Don't use quick repair */
  195.   if (test_flag & T_VERBOSE) puts("");
  196.   mi_check_print_error(param,"record delete-link-chain corrupted");
  197.   DBUG_RETURN(1);
  198. } /* chk_del */
  199. /* Check delete links in index file */
  200. static int check_k_link(MI_CHECK *param, register MI_INFO *info, uint nr)
  201. {
  202.   my_off_t next_link;
  203.   uint block_size=(nr+1)*MI_KEY_BLOCK_LENGTH;
  204.   ha_rows records;
  205.   char llbuff[21],*buff;
  206.   DBUG_ENTER("check_k_link");
  207.   if (param->testflag & T_VERBOSE)
  208.     printf("block_size %4d:",block_size);
  209.   next_link=info->s->state.key_del[nr];
  210.   records= (ha_rows) (info->state->key_file_length / block_size);
  211.   while (next_link != HA_OFFSET_ERROR && records > 0)
  212.   {
  213.     if (param->testflag & T_VERBOSE)
  214.       printf("%16s",llstr(next_link,llbuff));
  215.     if (next_link > info->state->key_file_length ||
  216. next_link & (info->s->blocksize-1))
  217.       DBUG_RETURN(1);
  218.     if (!(buff=key_cache_read(info->s->kfile, next_link, (byte*) info->buff,
  219.       myisam_block_size, block_size, 1)))
  220.       DBUG_RETURN(1);
  221.     next_link=mi_sizekorr(buff);
  222.     records--;
  223.     param->key_file_blocks+=block_size;
  224.   }
  225.   if (param->testflag & T_VERBOSE)
  226.   {
  227.     if (next_link != HA_OFFSET_ERROR)
  228.       printf("%16sn",llstr(next_link,llbuff));
  229.     else
  230.       puts("");
  231.   }
  232.   DBUG_RETURN (next_link != HA_OFFSET_ERROR);
  233. } /* check_k_link */
  234. /* Kontrollerar storleken p} filerna */
  235. int chk_size(MI_CHECK *param, register MI_INFO *info)
  236. {
  237.   int error=0;
  238.   register my_off_t skr,size;
  239.   char buff[22],buff2[22];
  240.   DBUG_ENTER("chk_size");
  241.   if (!(param->testflag & T_SILENT)) puts("- check file-size");
  242.   flush_key_blocks(info->s->kfile, FLUSH_FORCE_WRITE); /* If called externally */
  243.   size=my_seek(info->s->kfile,0L,MY_SEEK_END,MYF(0));
  244.   if ((skr=(my_off_t) info->state->key_file_length) != size)
  245.   {
  246.     if (skr > size)
  247.     {
  248.       error=1;
  249.       mi_check_print_error(param,
  250.    "Size of indexfile is: %-8s        Should be: %s",
  251.    llstr(size,buff), llstr(skr,buff2));
  252.     }
  253.     else
  254.       mi_check_print_warning(param,
  255.      "Size of indexfile is: %-8s      Should be: %s",
  256.      llstr(size,buff), llstr(skr,buff2));
  257.   }
  258.   if (!(param->testflag & T_VERY_SILENT) &&
  259.       ! (info->s->options & HA_OPTION_COMPRESS_RECORD) &&
  260.       ulonglong2double(info->state->key_file_length) >
  261.       ulonglong2double(info->s->base.margin_key_file_length)*0.9)
  262.     mi_check_print_warning(param,"Keyfile is almost full, %10s of %10s used",
  263.    llstr(info->state->key_file_length,buff),
  264.    llstr(info->s->base.max_key_file_length-1,buff));
  265.   size=my_seek(info->dfile,0L,MY_SEEK_END,MYF(0));
  266.   skr=(my_off_t) info->state->data_file_length;
  267.   if (info->s->options & HA_OPTION_COMPRESS_RECORD)
  268.     skr+= MEMMAP_EXTRA_MARGIN;
  269. #ifdef USE_RELOC
  270.   if (info->data_file_type == STATIC_RECORD &&
  271.       skr < (my_off_t) info->s->base.reloc*info->s->base.min_pack_length)
  272.     skr=(my_off_t) info->s->base.reloc*info->s->base.min_pack_length;
  273. #endif
  274.   if (skr != size)
  275.   {
  276.     info->state->data_file_length=size; /* Skipp other errors */
  277.     if (skr > size && skr != size + MEMMAP_EXTRA_MARGIN)
  278.     {
  279.       error=1;
  280.       mi_check_print_error(param,"Size of datafile is: %-9s         Should be: %s",
  281.     llstr(size,buff), llstr(skr,buff2));
  282.       param->retry_without_quick=1; /* Don't use quick repair */
  283.     }
  284.     else
  285.     {
  286.       mi_check_print_warning(param,
  287.      "Size of datafile is: %-9s       Should be: %s",
  288.      llstr(size,buff), llstr(skr,buff2));
  289.     }
  290.   }
  291.   if (!(param->testflag & T_VERY_SILENT) &&
  292.       !(info->s->options & HA_OPTION_COMPRESS_RECORD) &&
  293.       ulonglong2double(info->state->data_file_length) >
  294.       (ulonglong2double(info->s->base.max_data_file_length)*0.9))
  295.     mi_check_print_warning(param, "Datafile is almost full, %10s of %10s used",
  296.    llstr(info->state->data_file_length,buff),
  297.    llstr(info->s->base.max_data_file_length-1,buff2));
  298.   DBUG_RETURN(error);
  299. } /* chk_size */
  300. /* Check keys */
  301. int chk_key(MI_CHECK *param, register MI_INFO *info)
  302. {
  303.   uint key,found_keys=0,full_text_keys=0,result=0;
  304.   ha_rows keys;
  305.   ha_checksum old_record_checksum,init_checksum;
  306.   my_off_t all_keydata,all_totaldata,key_totlength,length;
  307.   ulong   *rec_per_key_part;
  308.   MYISAM_SHARE *share=info->s;
  309.   MI_KEYDEF *keyinfo;
  310.   char buff[22],buff2[22];
  311.   DBUG_ENTER("chk_key");
  312.   if (!(param->testflag & T_SILENT)) puts("- check index reference");
  313.   all_keydata=all_totaldata=key_totlength=0;
  314.   old_record_checksum=0;
  315.   init_checksum=param->record_checksum;
  316.   if (!(share->options &
  317. (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)))
  318.     old_record_checksum=calc_checksum(info->state->records+info->state->del-1)*
  319.       share->base.pack_reclength;
  320.   rec_per_key_part= param->rec_per_key_part;
  321.   for (key= 0,keyinfo= &share->keyinfo[0]; key < share->base.keys ;
  322.        rec_per_key_part+=keyinfo->keysegs, key++, keyinfo++)
  323.   {
  324.     param->key_crc[key]=0;
  325.     if (!(((ulonglong) 1 << key) & share->state.key_map))
  326.     {
  327.       /* Remember old statistics for key */
  328.       memcpy((char*) rec_per_key_part,
  329.      (char*) share->state.rec_per_key_part+
  330.      (uint) (rec_per_key_part - param->rec_per_key_part),
  331.      keyinfo->keysegs*sizeof(*rec_per_key_part));
  332.       continue;
  333.     }
  334.     found_keys++;
  335.     param->record_checksum=init_checksum;
  336.     bzero((char*) &param->unique_count,sizeof(param->unique_count));
  337.     if ((!(param->testflag & T_SILENT)))
  338.       printf ("- check data record references index: %dn",key+1);
  339.     if (share->state.key_root[key] == HA_OFFSET_ERROR &&
  340. (info->state->records == 0 || keyinfo->flag & HA_FULLTEXT))
  341.       continue;
  342.     if (!_mi_fetch_keypage(info,keyinfo,share->state.key_root[key],info->buff,
  343.    0))
  344.     {
  345.       mi_check_print_error(param,"Can't read indexpage from filepos: %s",
  346.   llstr(share->state.key_root[key],buff));
  347.       if (!(param->testflag & T_INFO))
  348. DBUG_RETURN(-1);
  349.       result= -1;
  350.       continue;
  351.     }
  352.     param->key_file_blocks+=keyinfo->block_length;
  353.     keys=0;
  354.     param->keydata=param->totaldata=0;
  355.     param->key_blocks=0;
  356.     param->max_level=0;
  357.     if (chk_index(param,info,keyinfo,share->state.key_root[key],info->buff,
  358.   &keys, param->key_crc+key,1))
  359.       DBUG_RETURN(-1);
  360.     if(!(keyinfo->flag & HA_FULLTEXT))
  361.     {
  362.       if (keys != info->state->records)
  363.       {
  364. mi_check_print_error(param,"Found %s keys of %s",llstr(keys,buff),
  365.     llstr(info->state->records,buff2));
  366. if (!(param->testflag & T_INFO))
  367. DBUG_RETURN(-1);
  368. result= -1;
  369. continue;
  370.       }
  371.       if (found_keys - full_text_keys == 1 &&
  372.   ((share->options &
  373.     (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ||
  374.    (param->testflag & T_DONT_CHECK_CHECKSUM)))
  375. old_record_checksum=param->record_checksum;
  376.       else if (old_record_checksum != param->record_checksum)
  377.       {
  378. if (key)
  379.   mi_check_print_error(param,"Key %u doesn't point at same records that key 1",
  380.       key+1);
  381. else
  382.   mi_check_print_error(param,"Key 1 doesn't point at all records");
  383. if (!(param->testflag & T_INFO))
  384.   DBUG_RETURN(-1);
  385. result= -1;
  386. continue;
  387.       }
  388.     }
  389.     else
  390.       full_text_keys++;
  391.     /* Check that auto_increment key is bigger than max key value */
  392.     if ((uint) share->base.auto_key -1 == key)
  393.     {
  394.       ulonglong save_auto_value=info->s->state.auto_increment;
  395.       info->s->state.auto_increment=0;
  396.       info->lastinx=key;
  397.       _mi_read_key_record(info, 0L, info->rec_buff);
  398.       update_auto_increment(info, info->rec_buff);
  399.       if (info->s->state.auto_increment > save_auto_value)
  400.       {
  401. mi_check_print_warning(param,
  402.        "Auto-increment value: %s is smaller than max used value: %s",
  403.        llstr(save_auto_value,buff2),
  404.        llstr(info->s->state.auto_increment, buff));
  405.       }
  406.       if (param->testflag & T_AUTO_INC)
  407.       {
  408. set_if_bigger(info->s->state.auto_increment,
  409.       param->auto_increment_value);
  410.       }
  411.       else
  412. info->s->state.auto_increment=save_auto_value;
  413.     }
  414.     length=(my_off_t) isam_key_length(info,keyinfo)*keys + param->key_blocks*2;
  415.     if (param->testflag & T_INFO && param->totaldata != 0L && keys != 0L)
  416.       printf("Key: %2d:  Keyblocks used: %3d%%  Packed: %4d%%  Max levels: %2dn",
  417.      key+1,
  418.      (int) (my_off_t2double(param->keydata)*100.0/my_off_t2double(param->totaldata)),
  419.      (int) ((my_off_t2double(length) - my_off_t2double(param->keydata))*100.0/
  420.     my_off_t2double(length)),
  421.      param->max_level);
  422.     all_keydata+=param->keydata; all_totaldata+=param->totaldata; key_totlength+=length;
  423.     if (param->testflag & T_STATISTICS)
  424.       update_key_parts(keyinfo, rec_per_key_part, param->unique_count,
  425.        (ulonglong) info->state->records);
  426.   }
  427.   if (param->testflag & T_INFO)
  428.   {
  429.     if (all_totaldata != 0L && found_keys > 0)
  430.       printf("Total:    Keyblocks used: %3d%%  Packed: %4d%%nn",
  431.      (int) (my_off_t2double(all_keydata)*100.0/
  432.     my_off_t2double(all_totaldata)),
  433.      (int) ((my_off_t2double(key_totlength) -
  434.      my_off_t2double(all_keydata))*100.0/
  435.      my_off_t2double(key_totlength)));
  436.     else if (all_totaldata != 0L && share->state.key_map)
  437.       puts("");
  438.   }
  439.   if (param->key_file_blocks != info->state->key_file_length &&
  440.       param->keys_in_use != ~(ulonglong) 0)
  441.     mi_check_print_warning(param, "Some data are unreferenced in keyfile");
  442.   if (found_keys != full_text_keys)
  443.     param->record_checksum=old_record_checksum-init_checksum; /* Remove delete links */
  444.   else
  445.     param->record_checksum=0;
  446.   DBUG_RETURN(0);
  447. } /* chk_key */
  448. /* Check if index is ok */
  449. static int chk_index(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
  450.      my_off_t page, uchar *buff, ha_rows *keys,
  451.      ha_checksum *key_checksum, uint level)
  452. {
  453.   int flag;
  454.   uint used_length,comp_flag,nod_flag,key_length,not_used;
  455.   uchar key[MI_MAX_POSSIBLE_KEY_BUFF],*temp_buff,*keypos,*old_keypos,*endpos;
  456.   my_off_t next_page,record;
  457.   char llbuff[22],llbuff2[22];
  458.   DBUG_ENTER("chk_index");
  459.   DBUG_DUMP("buff",(byte*) buff,mi_getint(buff));
  460.   if (!(temp_buff=(uchar*) my_alloca((uint) keyinfo->block_length)))
  461.   {
  462.     mi_check_print_error(param,"Not Enough memory");
  463.     DBUG_RETURN(-1);
  464.   }
  465.   if (keyinfo->flag & HA_NOSAME)
  466.     comp_flag=SEARCH_FIND | SEARCH_UPDATE; /* Not real duplicates */
  467.   else
  468.     comp_flag=SEARCH_SAME; /* Keys in positionorder */
  469.   nod_flag=mi_test_if_nod(buff);
  470.   used_length=mi_getint(buff);
  471.   keypos=buff+2+nod_flag;
  472.   endpos=buff+used_length;
  473.   param->keydata+=used_length; param->totaldata+=keyinfo->block_length; /* INFO */
  474.   param->key_blocks++;
  475.   if (level > param->max_level)
  476.     param->max_level=level;
  477.   if (used_length > keyinfo->block_length)
  478.   {
  479.     mi_check_print_error(param,"Wrong pageinfo at page: %s",
  480.  llstr(page,llbuff));
  481.     goto err;
  482.   }
  483.   for ( ;; )
  484.   {
  485.     if (nod_flag)
  486.     {
  487.       next_page=_mi_kpos(nod_flag,keypos);
  488.       if (next_page > info->state->key_file_length ||
  489.   (nod_flag && (next_page & (info->s->blocksize -1))))
  490.       {
  491. my_off_t max_length=my_seek(info->s->kfile,0L,MY_SEEK_END,MYF(0));
  492. mi_check_print_error(param,"Wrong pagepointer: %s at page: %s",
  493.     llstr(next_page,llbuff),llstr(page,llbuff2));
  494. if (next_page+info->s->blocksize > max_length)
  495.   goto err;
  496. info->state->key_file_length=(max_length &
  497.       ~ (my_off_t) (info->s->blocksize-1));
  498.       }
  499.       if (!_mi_fetch_keypage(info,keyinfo,next_page,temp_buff,0))
  500.       {
  501. mi_check_print_error(param,"Can't read key from filepos: %s",llstr(next_page,llbuff));
  502. goto err;
  503.       }
  504.       param->key_file_blocks+=keyinfo->block_length;
  505.       if (chk_index(param,info,keyinfo,next_page,temp_buff,keys,key_checksum,
  506.     level+1))
  507. goto err;
  508.     }
  509.     old_keypos=keypos;
  510.     if (keypos >= endpos ||
  511. (key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&keypos,key)) == 0)
  512.       break;
  513.     if (keypos > endpos)
  514.     {
  515.       mi_check_print_error(param,"Wrong key block length at page: %s",llstr(page,llbuff));
  516.       goto err;
  517.     }
  518.     if ((*keys)++ &&
  519. (flag=_mi_key_cmp(keyinfo->seg,info->lastkey,key,key_length,
  520.   comp_flag, &not_used)) >=0)
  521.     {
  522.       DBUG_DUMP("old",(byte*) info->lastkey, info->lastkey_length);
  523.       DBUG_DUMP("new",(byte*) key, key_length);
  524.       DBUG_DUMP("new_in_page",(char*) old_keypos,(uint) (keypos-old_keypos));
  525.       if (comp_flag & SEARCH_FIND && flag == 0)
  526. mi_check_print_error(param,"Found duplicated key at page %s",llstr(page,llbuff));
  527.       else
  528. mi_check_print_error(param,"Key in wrong position at page %s",llstr(page,llbuff));
  529.       goto err;
  530.     }
  531.     if (param->testflag & T_STATISTICS)
  532.     {
  533.       if (*keys != 1L) /* not first_key */
  534.       {
  535. uint diff;
  536. _mi_key_cmp(keyinfo->seg,info->lastkey,key,USE_WHOLE_KEY,SEARCH_FIND,
  537.     &diff);
  538. param->unique_count[diff-1]++;
  539.       }
  540.     }
  541.     (*key_checksum)+= mi_byte_checksum((byte*) key,
  542.        key_length- info->s->rec_reflength);
  543.     memcpy((char*) info->lastkey,(char*) key,key_length);
  544.     info->lastkey_length=key_length;
  545.     record= _mi_dpos(info,0,key+key_length);
  546.     if (record >= info->state->data_file_length)
  547.     {
  548. #ifndef DBUG_OFF
  549.       char llbuff3[22];
  550. #endif
  551.       mi_check_print_error(param,"Found key at page %s that points to record outside datafile",llstr(page,llbuff));
  552.       DBUG_PRINT("test",("page: %s  record: %s  filelength: %s",
  553.  llstr(page,llbuff),llstr(record,llbuff2),
  554.  llstr(info->state->data_file_length,llbuff3)));
  555.       DBUG_DUMP("key",(byte*) info->lastkey,key_length);
  556.       DBUG_DUMP("new_in_page",(char*) old_keypos,(uint) (keypos-old_keypos));
  557.       goto err;
  558.     }
  559.     param->record_checksum+=(ha_checksum) record;
  560.   }
  561.   if (keypos != endpos)
  562.   {
  563.     mi_check_print_error(param,"Keyblock size at page %s is not correct.  Block length: %d  key length: %d",
  564.                 llstr(page,llbuff), used_length, (keypos - buff));
  565.     goto err;
  566.   }
  567.   my_afree((byte*) temp_buff);
  568.   DBUG_RETURN(0);
  569.  err:
  570.   my_afree((byte*) temp_buff);
  571.   DBUG_RETURN(1);
  572. } /* chk_index */
  573. /* Calculate a checksum of 1+2+3+4...N = N*(N+1)/2 without overflow */
  574. static ha_checksum calc_checksum(ha_rows count)
  575. {
  576.   ulonglong sum,a,b;
  577.   DBUG_ENTER("calc_checksum");
  578.   sum=0;
  579.   a=count; b=count+1;
  580.   if (a & 1)
  581.     b>>=1;
  582.   else
  583.     a>>=1;
  584.   while (b)
  585.   {
  586.     if (b & 1)
  587.       sum+=a;
  588.     a<<=1; b>>=1;
  589.   }
  590.   DBUG_PRINT("exit",("sum: %lx",(ulong) sum));
  591.   DBUG_RETURN((ha_checksum) sum);
  592. } /* calc_checksum */
  593. /* Calc length of key in normal isam */
  594. static uint isam_key_length(MI_INFO *info, register MI_KEYDEF *keyinfo)
  595. {
  596.   uint length;
  597.   MI_KEYSEG *keyseg;
  598.   DBUG_ENTER("isam_key_length");
  599.   length= info->s->rec_reflength;
  600.   for (keyseg=keyinfo->seg ; keyseg->type ; keyseg++)
  601.     length+= keyseg->length;
  602.   DBUG_PRINT("exit",("length: %d",length));
  603.   DBUG_RETURN(length);
  604. } /* key_length */
  605. /* Check that record-link is ok */
  606. int chk_data_link(MI_CHECK *param, MI_INFO *info,int extend)
  607. {
  608.   int error,got_error,flag;
  609.   uint key,left_length,b_type,field;
  610.   ha_rows records,del_blocks;
  611.   my_off_t used,empty,pos,splits,start_recpos,
  612.    del_length,link_used,start_block;
  613.   byte *record,*to;
  614.   char llbuff[22],llbuff2[22],llbuff3[22];
  615.   ha_checksum intern_record_checksum;
  616.   ha_checksum key_checksum[MI_MAX_POSSIBLE_KEY];
  617.   my_bool static_row_size;
  618.   MI_KEYDEF *keyinfo;
  619.   MI_BLOCK_INFO block_info;
  620.   DBUG_ENTER("chk_data_link");
  621.   if (!(param->testflag & T_SILENT))
  622.   {
  623.     if (extend)
  624.       puts("- check records and index references");
  625.     else
  626.       puts("- check record links");
  627.   }
  628.   if (!(record= (byte*) my_alloca(info->s->base.pack_reclength)))
  629.   {
  630.     mi_check_print_error(param,"Not Enough memory");
  631.     DBUG_RETURN(-1);
  632.   }
  633.   records=del_blocks=0;
  634.   used=link_used=splits=del_length=0;
  635.   intern_record_checksum=param->glob_crc=0;
  636.   LINT_INIT(left_length);  LINT_INIT(start_recpos);  LINT_INIT(to);
  637.   got_error=error=0;
  638.   empty=info->s->pack.header_length;
  639.   /* Check how to calculate checksum of rows */
  640.   static_row_size=1;
  641.   if (info->s->data_file_type == COMPRESSED_RECORD)
  642.   {
  643.     for (field=0 ; field < info->s->base.fields ; field++)
  644.     {
  645.       if (info->s->rec[field].base_type == FIELD_BLOB ||
  646.   info->s->rec[field].base_type == FIELD_VARCHAR)
  647.       {
  648. static_row_size=0;
  649. break;
  650.       }
  651.     }
  652.   }
  653.   pos=my_b_tell(&param->read_cache);
  654.   bzero((char*) key_checksum, info->s->base.keys * sizeof(key_checksum[0]));
  655.   while (pos < info->state->data_file_length)
  656.   {
  657.     switch (info->s->data_file_type) {
  658.     case STATIC_RECORD:
  659.       if (my_b_read(&param->read_cache,(byte*) record,
  660.     info->s->base.pack_reclength))
  661. goto err;
  662.       start_recpos=pos;
  663.       pos+=info->s->base.pack_reclength;
  664.       splits++;
  665.       if (*record == '')
  666.       {
  667. del_blocks++;
  668. del_length+=info->s->base.pack_reclength;
  669. continue; /* Record removed */
  670.       }
  671.       param->glob_crc+= mi_static_checksum(info,record);
  672.       used+=info->s->base.pack_reclength;
  673.       break;
  674.     case DYNAMIC_RECORD:
  675.       flag=block_info.second_read=0;
  676.       block_info.next_filepos=pos;
  677.       do
  678.       {
  679. if (_mi_read_cache(&param->read_cache,(byte*) block_info.header,
  680.    (start_block=block_info.next_filepos),
  681.    sizeof(block_info.header),
  682.    (flag ? 0 : READING_NEXT) | READING_HEADER))
  683.   goto err;
  684. if (start_block & (MI_DYN_ALIGN_SIZE-1))
  685. {
  686.   mi_check_print_error(param,"Wrong aligned block at %s",
  687.        llstr(start_block,llbuff));
  688.   goto err2;
  689. }
  690. b_type=_mi_get_block_info(&block_info,-1,start_block);
  691. if (b_type & (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
  692.       BLOCK_FATAL_ERROR))
  693. {
  694.   if (b_type & BLOCK_SYNC_ERROR)
  695.   {
  696.     if (flag)
  697.     {
  698.       mi_check_print_error(param,"Unexpected byte: %d at link: %s",
  699.   (int) block_info.header[0],
  700.   llstr(start_block,llbuff));
  701.       goto err2;
  702.     }
  703.     pos=block_info.filepos+block_info.block_len;
  704.     goto next;
  705.   }
  706.   if (b_type & BLOCK_DELETED)
  707.   {
  708.     if (block_info.block_len < info->s->base.min_block_length)
  709.     {
  710.       mi_check_print_error(param,
  711.    "Deleted block with impossible length %lu at %s",
  712.    block_info.block_len,llstr(pos,llbuff));
  713.       goto err2;
  714.     }
  715.     if ((block_info.next_filepos != HA_OFFSET_ERROR &&
  716.  block_info.next_filepos >= info->state->data_file_length) ||
  717. (block_info.prev_filepos != HA_OFFSET_ERROR &&
  718.  block_info.prev_filepos >= info->state->data_file_length))
  719.     {
  720.       mi_check_print_error(param,"Delete link points outside datafile at %s",
  721.   llstr(pos,llbuff));
  722.       goto err2;
  723.     }
  724.     del_blocks++;
  725.     del_length+=block_info.block_len;
  726.     pos=block_info.filepos+block_info.block_len;
  727.     splits++;
  728.     goto next;
  729.   }
  730.   mi_check_print_error(param,"Wrong bytesec: %d-%d-%d at linkstart: %s",
  731.       block_info.header[0],block_info.header[1],
  732.       block_info.header[2],
  733.       llstr(start_block,llbuff));
  734.   goto err2;
  735. }
  736. if (info->state->data_file_length < block_info.filepos+
  737.     block_info.block_len)
  738. {
  739.   mi_check_print_error(param,"Recordlink that points outside datafile at %s",
  740.       llstr(pos,llbuff));
  741.   got_error=1;
  742.   break;
  743. }
  744. splits++;
  745. if (!flag++) /* First block */
  746. {
  747.   start_recpos=pos;
  748.   pos=block_info.filepos+block_info.block_len;
  749.   if (block_info.rec_len > (uint) info->s->base.max_pack_length)
  750.   {
  751.     mi_check_print_error(param,"Found too long record (%d) at %s",
  752. block_info.rec_len,
  753. llstr(start_recpos,llbuff));
  754.     got_error=1;
  755.     break;
  756.   }
  757.   if (info->s->base.blobs)
  758.   {
  759.     if (!(to=mi_fix_rec_buff_for_blob(info,block_info.rec_len)))
  760.     {
  761.       mi_check_print_error(param,"Not enough memory for blob at %s",
  762.   llstr(start_recpos,llbuff));
  763.       got_error=1;
  764.       break;
  765.     }
  766.   }
  767.   else
  768.     to= info->rec_buff;
  769.   left_length=block_info.rec_len;
  770. }
  771. if (left_length < block_info.data_len)
  772. {
  773.   mi_check_print_error(param,"Found too long record at %s",
  774.       llstr(start_recpos,llbuff));
  775.   got_error=1; break;
  776. }
  777. if (_mi_read_cache(&param->read_cache,(byte*) to,block_info.filepos,
  778.    (uint) block_info.data_len,
  779.    flag == 1 ? READING_NEXT : 0))
  780.   goto err;
  781. to+=block_info.data_len;
  782. link_used+= block_info.filepos-start_block;
  783. used+= block_info.filepos - start_block + block_info.data_len;
  784. empty+=block_info.block_len-block_info.data_len;
  785. left_length-=block_info.data_len;
  786. if (left_length)
  787. {
  788.   if (b_type & BLOCK_LAST)
  789.   {
  790.     mi_check_print_error(param,"Record link to short for record at %s",
  791. llstr(start_recpos,llbuff));
  792.     got_error=1;
  793.     break;
  794.   }
  795.   if (info->state->data_file_length < block_info.next_filepos)
  796.   {
  797.     mi_check_print_error(param,"Found next-recordlink that points outside datafile at %s",
  798. llstr(block_info.filepos,llbuff));
  799.     got_error=1;
  800.     break;
  801.   }
  802. }
  803.       } while (left_length);
  804.       if (! got_error)
  805.       {
  806. if (_mi_rec_unpack(info,record,info->rec_buff,block_info.rec_len) ==
  807.     MY_FILE_ERROR)
  808. {
  809.   mi_check_print_error(param,"Found wrong record at %s", llstr(start_recpos,llbuff));
  810.   got_error=1;
  811. }
  812. else
  813. {
  814.   info->checksum=mi_checksum(info,record);
  815.   if (param->testflag & (T_EXTEND | T_MEDIUM | T_VERBOSE))
  816.   {
  817.     if (_mi_rec_check(info,record))
  818.     {
  819.       mi_check_print_error(param,"Found wrong packed record at %s",
  820.   llstr(start_recpos,llbuff));
  821.       got_error=1;
  822.     }
  823.   }
  824.   if (!got_error)
  825.     param->glob_crc+= info->checksum;
  826. }
  827.       }
  828.       else if (!flag)
  829. pos=block_info.filepos+block_info.block_len;
  830.       break;
  831.     case COMPRESSED_RECORD:
  832.       if (_mi_read_cache(&param->read_cache,(byte*) block_info.header, pos,
  833.  info->s->pack.ref_length, READING_NEXT))
  834. goto err;
  835.       start_recpos=pos;
  836.       splits++;
  837.       VOID(_mi_pack_get_block_info(info,&block_info, -1, start_recpos, NullS));
  838.       pos=block_info.filepos+block_info.rec_len;
  839.       if (block_info.rec_len < (uint) info->s->min_pack_length ||
  840.   block_info.rec_len > (uint) info->s->max_pack_length)
  841.       {
  842. mi_check_print_error(param,"Found block with wrong recordlength: %d at %s",
  843.     block_info.rec_len, llstr(start_recpos,llbuff));
  844. got_error=1;
  845. break;
  846.       }
  847.       if (_mi_read_cache(&param->read_cache,(byte*) info->rec_buff,
  848. block_info.filepos, block_info.rec_len, READING_NEXT))
  849. goto err;
  850.       if (_mi_pack_rec_unpack(info,record,info->rec_buff,block_info.rec_len))
  851.       {
  852. mi_check_print_error(param,"Found wrong record at %s", llstr(start_recpos,llbuff));
  853. got_error=1;
  854.       }
  855.       if (static_row_size)
  856. param->glob_crc+= mi_static_checksum(info,record);
  857.       else
  858. param->glob_crc+= mi_checksum(info,record);
  859.       link_used+= (block_info.filepos - start_recpos);
  860.       used+= (pos-start_recpos);
  861.     } /* switch */
  862.     if (! got_error)
  863.     {
  864.       intern_record_checksum+=(ha_checksum) start_recpos;
  865.       records++;
  866.       if (param->testflag & T_WRITE_LOOP && records % WRITE_COUNT == 0)
  867.       {
  868. printf("%sr", llstr(records,llbuff)); VOID(fflush(stdout));
  869.       }
  870.       /* Check if keys match the record */
  871.       for (key=0,keyinfo= info->s->keyinfo; key < info->s->base.keys;
  872.    key++,keyinfo++)
  873.       {
  874. if ((((ulonglong) 1 << key) & info->s->state.key_map))
  875. {
  876.   if(!(keyinfo->flag & HA_FULLTEXT))
  877.   {
  878.     uint key_length=_mi_make_key(info,key,info->lastkey,record,
  879.  start_recpos);
  880.     if (extend)
  881.     {
  882.       /* We don't need to lock the key tree here as we don't allow
  883.  concurrent threads when running myisamchk
  884.       */
  885.       if (_mi_search(info,keyinfo,info->lastkey,key_length,
  886.      SEARCH_SAME, info->s->state.key_root[key]))
  887.       {
  888. mi_check_print_error(param,"Record at: %10s  Can't find key for index: %2d",
  889.     llstr(start_recpos,llbuff),key+1);
  890. if (error++ > MAXERR || !(param->testflag & T_VERBOSE))
  891.   goto err2;
  892.       }
  893.     }
  894.     else
  895.       key_checksum[key]+=mi_byte_checksum((byte*) info->lastkey,
  896.   key_length);
  897.   }
  898. }
  899.       }
  900.     }
  901.     else
  902.     {
  903.       got_error=0;
  904.       if (error++ > MAXERR || !(param->testflag & T_VERBOSE))
  905. goto err2;
  906.     }
  907.   next:; /* Next record */
  908.   }
  909.   if (param->testflag & T_WRITE_LOOP)
  910.   {
  911.     VOID(fputs("          r",stdout)); VOID(fflush(stdout));
  912.   }
  913.   if (records != info->state->records)
  914.   {
  915.     mi_check_print_error(param,"Record-count is not ok; is %-10s   Should be: %s",
  916. llstr(records,llbuff), llstr(info->state->records,llbuff2));
  917.     error=1;
  918.   }
  919.   else if (param->record_checksum &&
  920.    param->record_checksum != intern_record_checksum)
  921.   {
  922.     mi_check_print_error(param,
  923.  "Keypointers and record positions doesn't match");
  924.     error=1;
  925.   }
  926.   else if (param->glob_crc != info->s->state.checksum &&
  927.    (info->s->options &
  928.     (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD)))
  929.   {
  930.     mi_check_print_warning(param,
  931.    "Record checksum is not the same as checksum stored in the index filen");
  932.     error=1;
  933.   }
  934.   else if (!extend)
  935.   {
  936.     for (key=0 ; key < info->s->base.keys;  key++)
  937.     {
  938.       if (key_checksum[key] != param->key_crc[key] &&
  939.           !(info->s->keyinfo[key].flag & HA_FULLTEXT))
  940.       {
  941. mi_check_print_error(param,"Checksum for key: %2d doesn't match checksum for records",
  942.     key+1);
  943. error=1;
  944.       }
  945.     }
  946.   }
  947.   if (used+empty+del_length != info->state->data_file_length)
  948.   {
  949.     mi_check_print_warning(param,
  950.    "Found %s record-data and %s unused data and %s deleted-data",
  951.    llstr(used,llbuff),llstr(empty,llbuff2),
  952.    llstr(del_length,llbuff3));
  953.     mi_check_print_warning(param,
  954.    "Total %s, Should be: %s",
  955.    llstr((used+empty+del_length),llbuff),
  956.    llstr(info->state->data_file_length,llbuff2));
  957.   }
  958.   if (del_blocks != info->state->del)
  959.   {
  960.     mi_check_print_warning(param,
  961.    "Found %10s deleted blocks       Should be: %s",
  962.    llstr(del_blocks,llbuff),
  963.    llstr(info->state->del,llbuff2));
  964.   }
  965.   if (splits != info->s->state.split)
  966.   {
  967.     mi_check_print_warning(param,
  968.    "Found %10s parts                Should be: %s parts",
  969.    llstr(splits,llbuff),
  970.    llstr(info->s->state.split,llbuff2));
  971.   }
  972.   if (param->testflag & T_INFO)
  973.   {
  974.     if (param->warning_printed || param->error_printed)
  975.       puts("");
  976.     if (used != 0 && ! param->error_printed)
  977.     {
  978.       printf("Records:%18s    M.recordlength:%9lu   Packed:%14.0f%%n",
  979.        llstr(records,llbuff), (long)((used-link_used)/records),
  980.      (info->s->base.blobs ? 0.0 :
  981.       (ulonglong2double((ulonglong) info->s->base.reclength*records)-
  982.        my_off_t2double(used))/
  983.       ulonglong2double((ulonglong) info->s->base.reclength*records)*100.0));
  984.       printf("Recordspace used:%9.0f%%   Empty space:%12d%%  Blocks/Record: %6.2fn",
  985.      (ulonglong2double(used-link_used)/ulonglong2double(used-link_used+empty)*100.0),
  986.      (!records ? 100 : (int) (ulonglong2double(del_length+empty)/
  987.       my_off_t2double(used)*100.0)),
  988.      ulonglong2double(splits - del_blocks) / records);
  989.     }
  990.     printf("Record blocks:%12s    Delete blocks:%10sn",
  991.    llstr(splits-del_blocks,llbuff),llstr(del_blocks,llbuff2));
  992.     printf("Record data:  %12s    Deleted data: %10sn",
  993.    llstr(used-link_used,llbuff),llstr(del_length,llbuff2));
  994.     printf("Lost space:   %12s    Linkdata:     %10sn",
  995.    llstr(empty,llbuff),llstr(link_used,llbuff2));
  996.   }
  997.   my_afree((gptr) record);
  998.   DBUG_RETURN (error);
  999.  err:
  1000.   mi_check_print_error(param,"got error: %d when reading datafile",my_errno);
  1001.  err2:
  1002.   my_afree((gptr) record);
  1003.   param->retry_without_quick=1;
  1004.   DBUG_RETURN(1);
  1005. } /* chk_data_link */
  1006. /* Recover old table by reading each record and writing all keys */
  1007. /* Save new datafile-name in temp_filename */
  1008. int mi_repair(MI_CHECK *param, register MI_INFO *info,
  1009.       my_string name, int rep_quick)
  1010. {
  1011.   int error,got_error;
  1012.   uint i;
  1013.   ha_rows start_records,new_header_length;
  1014.   my_off_t del;
  1015.   File new_file;
  1016.   MYISAM_SHARE *share=info->s;
  1017.   char llbuff[22],llbuff2[22];
  1018.   SORT_INFO *sort_info= &param->sort_info;
  1019.   DBUG_ENTER("mi_repair");
  1020.   start_records=info->state->records;
  1021.   new_header_length=(param->testflag & T_UNPACK) ? 0L :
  1022.     share->pack.header_length;
  1023.   got_error=1;
  1024.   new_file= -1;
  1025.   if (!(param->testflag & T_SILENT))
  1026.   {
  1027.     printf("- recovering (with keycache) MyISAM-table '%s'n",name);
  1028.     printf("Data records: %sn", llstr(info->state->records,llbuff));
  1029.   }
  1030.   if (!param->using_global_keycache)
  1031.     VOID(init_key_cache(param->use_buffers,NEAD_MEM));
  1032.   if (init_io_cache(&param->read_cache,info->dfile,
  1033.     (uint) param->read_buffer_length,
  1034.     READ_CACHE,share->pack.header_length,1,MYF(MY_WME)))
  1035.     goto err;
  1036.   if (!rep_quick)
  1037.     if (init_io_cache(&info->rec_cache,-1,(uint) param->write_buffer_length,
  1038.       WRITE_CACHE, new_header_length, 1,
  1039.       MYF(MY_WME | MY_WAIT_IF_FULL)))
  1040.       goto err;
  1041.   info->opt_flag|=WRITE_CACHE_USED;
  1042.   sort_info->start_recpos=0;
  1043.   sort_info->buff=0; sort_info->buff_length=0;
  1044.   if (!(sort_info->record=(byte*) my_malloc((uint) share->base.pack_reclength,
  1045.    MYF(0))))
  1046.   {
  1047.     mi_check_print_error(param,"Not enough memory for extra record");
  1048.     goto err;
  1049.   }
  1050.   if (!rep_quick)
  1051.   {
  1052.     if ((new_file=my_raid_create(fn_format(param->temp_filename,name,"",
  1053.    DATA_TMP_EXT,
  1054.    2+4),
  1055.  0,param->tmpfile_createflag,
  1056.  share->base.raid_type,
  1057.  share->base.raid_chunks,
  1058.  share->base.raid_chunksize,
  1059.  MYF(0))) < 0)
  1060.     {
  1061.       mi_check_print_error(param,"Can't create new tempfile: '%s'",
  1062.    param->temp_filename);
  1063.       goto err;
  1064.     }
  1065.     if (filecopy(param,new_file,info->dfile,0L,new_header_length,
  1066.  "datafile-header"))
  1067.       goto err;
  1068.     info->s->state.dellink= HA_OFFSET_ERROR;
  1069.     info->rec_cache.file=new_file;
  1070.     if (param->testflag & T_UNPACK)
  1071.     {
  1072.       share->options&= ~HA_OPTION_COMPRESS_RECORD;
  1073.       mi_int2store(share->state.header.options,share->options);
  1074.     }
  1075.   }
  1076.   sort_info->info=info;
  1077.   sort_info->pos=sort_info->max_pos=share->pack.header_length;
  1078.   sort_info->filepos=new_header_length;
  1079.   param->read_cache.end_of_file=sort_info->filelength=
  1080.     my_seek(info->dfile,0L,MY_SEEK_END,MYF(0));
  1081.   sort_info->dupp=0;
  1082.   sort_info->fix_datafile= (my_bool) (! rep_quick);
  1083.   sort_info->max_records= ~(ha_rows) 0;
  1084.   if ((sort_info->new_data_file_type=share->data_file_type) ==
  1085.       COMPRESSED_RECORD && param->testflag & T_UNPACK)
  1086.   {
  1087.     if (share->options & HA_OPTION_PACK_RECORD)
  1088.       sort_info->new_data_file_type = DYNAMIC_RECORD;
  1089.     else
  1090.       sort_info->new_data_file_type = STATIC_RECORD;
  1091.   }
  1092.   del=info->state->del;
  1093.   info->state->records=info->state->del=share->state.split=0;
  1094.   info->state->empty=0;
  1095.   if (sort_info->new_data_file_type != COMPRESSED_RECORD && !rep_quick)
  1096.     share->state.checksum=0;
  1097.   info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
  1098.   for (i=0 ; i < info->s->base.keys ; i++)
  1099.     share->state.key_root[i]= HA_OFFSET_ERROR;
  1100.   for (i=0 ; i < share->state.header.max_block_size ; i++)
  1101.     share->state.key_del[i]=  HA_OFFSET_ERROR;
  1102.   /* I think mi_repair and mi_repair_by_sort should do the same
  1103.      (according, e.g. to ha_myisam::repair), but as mi_repair doesn't
  1104.      touch key_map it cannot be used to T_CREATE_MISSING_KEYS.
  1105.      That is the next line for... (serg)
  1106.   */
  1107.   share->state.key_map= ((((ulonglong) 1L << share->base.keys)-1) &
  1108.  param->keys_in_use);
  1109.   info->state->key_file_length=share->base.keystart;
  1110.   lock_memory(param); /* Everything is alloced */
  1111.   while (!(error=sort_get_next_record(sort_info)))
  1112.   {
  1113.     if (writekeys(info,(byte*) sort_info->record,sort_info->filepos))
  1114.     {
  1115.       if (my_errno != HA_ERR_FOUND_DUPP_KEY) goto err;
  1116.       DBUG_DUMP("record",(byte*) sort_info->record,share->base.pack_reclength);
  1117.       mi_check_print_info(param,"Duplicate key %2d for record at %10s against new record at %10s",
  1118.   info->errkey+1,
  1119.   llstr(sort_info->start_recpos,llbuff),
  1120.   llstr(info->dupp_key_pos,llbuff2));
  1121.       if (param->testflag & T_VERBOSE)
  1122.       {
  1123. VOID(_mi_make_key(info,(uint) info->errkey,info->lastkey,
  1124.   sort_info->record,0L));
  1125. _mi_print_key(stdout,share->keyinfo[info->errkey].seg,info->lastkey,
  1126.       USE_WHOLE_KEY);
  1127.       }
  1128.       sort_info->dupp++;
  1129.       if (rep_quick == 1)
  1130.       {
  1131. param->error_printed=param->retry_without_quick=1;
  1132. goto err;
  1133.       }
  1134.       continue;
  1135.     }
  1136.     if (sort_write_record(sort_info))
  1137.       goto err;
  1138.   }
  1139.   if (error > 0 || write_data_suffix(param,info) ||
  1140.       flush_io_cache(&info->rec_cache) || param->read_cache.error < 0)
  1141.     goto err;
  1142.   if (param->testflag & T_WRITE_LOOP)
  1143.   {
  1144.     VOID(fputs("          r",stdout)); VOID(fflush(stdout));
  1145.   }
  1146.   if (my_chsize(share->kfile,info->state->key_file_length,MYF(0)))
  1147.   {
  1148.     mi_check_print_warning(param,
  1149.    "Can't change size of indexfile, error: %d",
  1150.    my_errno);
  1151.     goto err;
  1152.   }
  1153.   if (rep_quick && del+sort_info->dupp != info->state->del)
  1154.   {
  1155.     mi_check_print_error(param,"Couldn't fix table with quick recovery: Found wrong number of deleted records");
  1156.     mi_check_print_error(param,"Run recovery again without -q");
  1157.     got_error=1;
  1158.     param->retry_repair=param->retry_without_quick=1;
  1159.     goto err;
  1160.   }
  1161.   if (param->testflag & T_SAFE_REPAIR)
  1162.   {
  1163.     /* Don't repair if we loosed more than one row */
  1164.     if (info->state->records+1 < start_records)
  1165.     {
  1166.       info->state->records=start_records;
  1167.       got_error=1;
  1168.       goto err;
  1169.     }
  1170.   }
  1171.   if (!rep_quick)
  1172.   {
  1173.     my_close(info->dfile,MYF(0));
  1174.     info->dfile=new_file;
  1175.     info->state->data_file_length=sort_info->filepos;
  1176.     /* Only whole records */
  1177.     share->state.split=info->state->records+info->state->del;
  1178.     share->state.version=(ulong) time((time_t*) 0); /* Force reopen */
  1179.   }
  1180.   else
  1181.     info->state->data_file_length=sort_info->max_pos;
  1182.   if (!(param->testflag & T_SILENT))
  1183.   {
  1184.     if (start_records != info->state->records)
  1185.       printf("Data records: %sn", llstr(info->state->records,llbuff));
  1186.     if (sort_info->dupp)
  1187.       mi_check_print_warning(param,
  1188.      "%s records have been removed",
  1189.      llstr(sort_info->dupp,llbuff));
  1190.   }
  1191.   got_error=0;
  1192.   /* If invoked by external program that uses thr_lock */
  1193.   if (&share->state.state != info->state)
  1194.     memcpy( &share->state.state, info->state, sizeof(*info->state));
  1195. err:
  1196.   if (!got_error)
  1197.   {
  1198.     /* Replace the actual file with the temporary file */
  1199.     if (new_file >= 0)
  1200.     {
  1201.       my_close(new_file,MYF(0));
  1202.       info->dfile=new_file= -1;
  1203.       if (change_to_newfile(share->filename,MI_NAME_DEXT,
  1204.     DATA_TMP_EXT, share->base.raid_chunks,
  1205.     (param->testflag & T_BACKUP_DATA ?
  1206.      MYF(MY_REDEL_MAKE_BACKUP): MYF(0))) ||
  1207.   mi_open_datafile(info,share))
  1208. got_error=1;
  1209.     }
  1210.   }
  1211.   if (got_error)
  1212.   {
  1213.     if (! param->error_printed)
  1214.       mi_check_print_error(param,"%d for record at pos %s",my_errno,
  1215.   llstr(sort_info->start_recpos,llbuff));
  1216.     if (new_file >= 0)
  1217.     {
  1218.       VOID(my_close(new_file,MYF(0)));
  1219.       VOID(my_raid_delete(param->temp_filename,info->s->base.raid_chunks,
  1220.   MYF(MY_WME)));
  1221.     }
  1222.     mi_mark_crashed_on_repair(info);
  1223.   }
  1224.   if (sort_info->record)
  1225.     my_free(sort_info->record,MYF(0));
  1226.   my_free(sort_info->buff,MYF(MY_ALLOW_ZERO_PTR));
  1227.   VOID(end_io_cache(&param->read_cache));
  1228.   info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
  1229.   VOID(end_io_cache(&info->rec_cache));
  1230.   got_error|=flush_blocks(param,share->kfile);
  1231.   if (!got_error && param->testflag & T_UNPACK)
  1232.   {
  1233.     share->state.header.options[0]&= (uchar) ~HA_OPTION_COMPRESS_RECORD;
  1234.     share->pack.header_length=0;
  1235.     share->data_file_type=sort_info->new_data_file_type;
  1236.   }
  1237.   share->state.changed|= (STATE_NOT_OPTIMIZED_KEYS | STATE_NOT_SORTED_PAGES |
  1238.   STATE_NOT_ANALYZED);
  1239.   DBUG_RETURN(got_error);
  1240. }
  1241. /* Uppate keyfile when doing repair */
  1242. static int writekeys(register MI_INFO *info,byte *buff,my_off_t filepos)
  1243. {
  1244.   register uint i;
  1245.   uchar *key;
  1246.   DBUG_ENTER("writekeys");
  1247.   key=info->lastkey+info->s->base.max_key_length;
  1248.   for (i=0 ; i < info->s->base.keys ; i++)
  1249.   {
  1250.     if (((ulonglong) 1 << i) & info->s->state.key_map)
  1251.     {
  1252.       if (info->s->keyinfo[i].flag & HA_FULLTEXT )
  1253.       {
  1254.         if (_mi_ft_add(info,i,(char*) key,buff,filepos))  goto err;
  1255.       }
  1256.       else
  1257.       {
  1258. uint key_length=_mi_make_key(info,i,key,buff,filepos);
  1259. if (_mi_ck_write(info,i,key,key_length)) goto err;
  1260.       }
  1261.     }
  1262.   }
  1263.   DBUG_RETURN(0);
  1264.  err:
  1265.   if (my_errno == HA_ERR_FOUND_DUPP_KEY)
  1266.   {
  1267.     info->errkey=(int) i; /* This key was found */
  1268.     while ( i-- > 0 )
  1269.     {
  1270.       if (((ulonglong) 1 << i) & info->s->state.key_map)
  1271.       {
  1272. if (info->s->keyinfo[i].flag & HA_FULLTEXT)
  1273.         {
  1274.           if (_mi_ft_del(info,i,(char*) key,buff,filepos)) break;
  1275.         }
  1276.         else
  1277. {
  1278.   uint key_length=_mi_make_key(info,i,key,buff,filepos);
  1279.   if (_mi_ck_delete(info,i,key,key_length)) break;
  1280. }
  1281.       }
  1282.     }
  1283.   }
  1284.   DBUG_PRINT("error",("errno: %d",my_errno));
  1285.   DBUG_RETURN(-1);
  1286. } /* writekeys */
  1287. /* Change all key-pointers that points to a records */
  1288. int movepoint(register MI_INFO *info, byte *record, my_off_t oldpos,
  1289.       my_off_t newpos, uint prot_key)
  1290. {
  1291.   register uint i;
  1292.   uchar *key;
  1293.   uint key_length;
  1294.   DBUG_ENTER("movepoint");
  1295.   key=info->lastkey+info->s->base.max_key_length;
  1296.   for (i=0 ; i < info->s->base.keys; i++)
  1297.   {
  1298.     if (i != prot_key && (((ulonglong) 1 << i) & info->s->state.key_map))
  1299.     {
  1300.       key_length=_mi_make_key(info,i,key,record,oldpos);
  1301.       if (info->s->keyinfo[i].flag & HA_NOSAME)
  1302.       { /* Change pointer direct */
  1303. uint nod_flag;
  1304. MI_KEYDEF *keyinfo;
  1305. keyinfo=info->s->keyinfo+i;
  1306. if (_mi_search(info,keyinfo,key,USE_WHOLE_KEY,
  1307.        (uint) (SEARCH_SAME | SEARCH_SAVE_BUFF),
  1308.        info->s->state.key_root[i]))
  1309.   DBUG_RETURN(-1);
  1310. nod_flag=mi_test_if_nod(info->buff);
  1311. _mi_dpointer(info,info->int_keypos-nod_flag-
  1312.      info->s->rec_reflength,newpos);
  1313. if (_mi_write_keypage(info,keyinfo,info->last_keypage,info->buff))
  1314.   DBUG_RETURN(-1);
  1315.       }
  1316.       else
  1317.       { /* Change old key to new */
  1318. if (_mi_ck_delete(info,i,key,key_length))
  1319.   DBUG_RETURN(-1);
  1320. key_length=_mi_make_key(info,i,key,record,newpos);
  1321. if (_mi_ck_write(info,i,key,key_length))
  1322.   DBUG_RETURN(-1);
  1323.       }
  1324.     }
  1325.   }
  1326.   DBUG_RETURN(0);
  1327. } /* movepoint */
  1328. /* Tell system that we want all memory for our cache */
  1329. void lock_memory(MI_CHECK *param __attribute__((unused)))
  1330. {
  1331. #ifdef SUN_OS /* Key-cacheing thrases on sun 4.1 */
  1332.   if (param->opt_lock_memory)
  1333.   {
  1334.     int success = mlockall(MCL_CURRENT); /* or plock(DATLOCK); */
  1335.     if (geteuid() == 0 && success != 0)
  1336.       mi_check_print_warning(param,
  1337.      "Failed to lock memory. errno %d",my_errno);
  1338.   }
  1339. #endif
  1340. } /* lock_memory */
  1341. /* Flush all changed blocks to disk */
  1342. int flush_blocks(MI_CHECK *param, File file)
  1343. {
  1344.   if (flush_key_blocks(file,FLUSH_RELEASE))
  1345.   {
  1346.     mi_check_print_error(param,"%d when trying to write bufferts",my_errno);
  1347.     return(1);
  1348.   }
  1349.   if (!param->using_global_keycache)
  1350.     end_key_cache();
  1351.   return 0;
  1352. } /* flush_blocks */
  1353. /* Sort index for more efficent reads */
  1354. int mi_sort_index(MI_CHECK *param, register MI_INFO *info, my_string name)
  1355. {
  1356.   reg2 uint key;
  1357.   reg1 MI_KEYDEF *keyinfo;
  1358.   File new_file;
  1359.   my_off_t index_pos[MI_MAX_POSSIBLE_KEY];
  1360.   uint r_locks,w_locks;
  1361.   MYISAM_SHARE *share=info->s;
  1362.   MI_STATE_INFO old_state;
  1363.   DBUG_ENTER("sort_index");
  1364.   if (!(param->testflag & T_SILENT))
  1365.     printf("- Sorting index for MyISAM-table '%s'n",name);
  1366.   if ((new_file=my_create(fn_format(param->temp_filename,name,"",
  1367.     INDEX_TMP_EXT,2+4),
  1368.   0,param->tmpfile_createflag,MYF(0))) <= 0)
  1369.   {
  1370.     mi_check_print_error(param,"Can't create new tempfile: '%s'",
  1371.  param->temp_filename);
  1372.     DBUG_RETURN(-1);
  1373.   }
  1374.   if (filecopy(param, new_file,share->kfile,0L,
  1375.        (ulong) share->base.keystart, "headerblock"))
  1376.     goto err;
  1377.   param->new_file_pos=share->base.keystart;
  1378.   for (key= 0,keyinfo= &share->keyinfo[0]; key < share->base.keys ;
  1379.        key++,keyinfo++)
  1380.   {
  1381.     if (!(((ulonglong) 1 << key) & share->state.key_map))
  1382.       continue;
  1383.     if (share->state.key_root[key] != HA_OFFSET_ERROR)
  1384.     {
  1385.       index_pos[key]=param->new_file_pos; /* Write first block here */
  1386.       if (sort_one_index(param,info,keyinfo,share->state.key_root[key],
  1387.  new_file))
  1388. goto err;
  1389.     }
  1390.     else
  1391.       index_pos[key]= HA_OFFSET_ERROR; /* No blocks */
  1392.   }
  1393.   /* Flush key cache for this file if we are calling this outside myisamchk */
  1394.   flush_key_blocks(share->kfile, FLUSH_IGNORE_CHANGED);
  1395.   share->state.version=(ulong) time((time_t*) 0);
  1396.   old_state=share->state; /* save state if not stored */
  1397.   r_locks=share->r_locks; w_locks=share->w_locks;
  1398. /* Put same locks as old file */
  1399.   share->r_locks=share->w_locks=0;
  1400.   (void) _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
  1401.   VOID(my_close(share->kfile,MYF(MY_WME)));
  1402.   share->kfile = -1;
  1403.   VOID(my_close(new_file,MYF(MY_WME)));
  1404.   if (change_to_newfile(share->filename,MI_NAME_IEXT,INDEX_TMP_EXT,0,
  1405. MYF(0)) ||
  1406.       mi_open_keyfile(share))
  1407.     goto err2;
  1408.   info->lock_type=F_UNLCK; /* Force mi_readinfo to lock */
  1409.   _mi_readinfo(info,F_WRLCK,0); /* Will lock the table */
  1410.   info->lock_type=F_WRLCK;
  1411.   share->r_locks=r_locks; share->w_locks=w_locks;
  1412.   share->state=old_state; /* Restore old state */
  1413.   info->state->key_file_length=param->new_file_pos;
  1414.   info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
  1415.   for (key=0 ; key < info->s->base.keys ; key++)
  1416.     info->s->state.key_root[key]=index_pos[key];
  1417.   for (key=0 ; key < info->s->state.header.max_block_size ; key++)
  1418.     info->s->state.key_del[key]=  HA_OFFSET_ERROR;
  1419.   info->s->state.changed&= ~STATE_NOT_SORTED_PAGES;
  1420.   DBUG_RETURN(0);
  1421. err:
  1422.   VOID(my_close(new_file,MYF(MY_WME)));
  1423. err2:
  1424.   VOID(my_delete(param->temp_filename,MYF(MY_WME)));
  1425.   DBUG_RETURN(-1);
  1426. } /* sort_index */
  1427.  /* Sort records recursive using one index */
  1428. static int sort_one_index(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
  1429.   my_off_t pagepos, File new_file)
  1430. {
  1431.   uint length,nod_flag,used_length;
  1432.   uchar *buff,*keypos,*endpos;
  1433.   uchar key[MI_MAX_POSSIBLE_KEY_BUFF];
  1434.   my_off_t new_page_pos,next_page;
  1435.   char llbuff[22];
  1436.   DBUG_ENTER("sort_one_index");
  1437.   new_page_pos=param->new_file_pos;
  1438.   param->new_file_pos+=keyinfo->block_length;
  1439.   if (!(buff=(uchar*) my_alloca((uint) keyinfo->block_length)))
  1440.   {
  1441.     mi_check_print_error(param,"Not Enough memory");
  1442.     DBUG_RETURN(-1);
  1443.   }
  1444.   if (!_mi_fetch_keypage(info,keyinfo,pagepos,buff,0))
  1445.   {
  1446.     mi_check_print_error(param,"Can't read key block from filepos: %s",
  1447. llstr(pagepos,llbuff));
  1448.     goto err;
  1449.   }
  1450.   if ((nod_flag=mi_test_if_nod(buff)))
  1451.   {
  1452.     used_length=mi_getint(buff);
  1453.     keypos=buff+2+nod_flag;
  1454.     endpos=buff+used_length;
  1455.     for ( ;; )
  1456.     {
  1457.       if (nod_flag)
  1458.       {
  1459. next_page=_mi_kpos(nod_flag,keypos);
  1460. _mi_kpointer(info,keypos-nod_flag,param->new_file_pos); /* Save new pos */
  1461. if (sort_one_index(param,info,keyinfo,next_page, new_file))
  1462. {
  1463.   DBUG_PRINT("error",("From page: %ld, keyoffset: %d  used_length: %d",
  1464.       (ulong) pagepos, (int) (keypos - buff),
  1465.       (int) used_length));
  1466.   DBUG_DUMP("buff",(byte*) buff,used_length);
  1467.   goto err;
  1468. }
  1469.       }
  1470.       if (keypos >= endpos ||
  1471.   ((*keyinfo->get_key)(keyinfo,nod_flag,&keypos,key)) == 0)
  1472. break;
  1473. #ifdef EXTRA_DEBUG
  1474.       assert(keypos <= endpos);
  1475. #endif
  1476.     }
  1477.   }
  1478.   /* Fill block with zero and write it to the new index file */
  1479.   length=mi_getint(buff);
  1480.   bzero((byte*) buff+length,keyinfo->block_length-length);
  1481.   if (my_pwrite(new_file,(byte*) buff,(uint) keyinfo->block_length,
  1482. new_page_pos,MYF(MY_NABP | MY_WAIT_IF_FULL)))
  1483.   {
  1484.     mi_check_print_error(param,"Can't write indexblock, error: %d",my_errno);
  1485.     goto err;
  1486.   }
  1487.   my_afree((gptr) buff);
  1488.   DBUG_RETURN(0);
  1489. err:
  1490.   my_afree((gptr) buff);
  1491.   DBUG_RETURN(1);
  1492. } /* sort_one_index */
  1493. /* Change to use new file */
  1494. /* Copy stats from old file to new file, deletes orginal and */
  1495. /* changes new file name to old file name */
  1496. int change_to_newfile(const char * filename, const char * old_ext,
  1497.       const char * new_ext,
  1498.       uint raid_chunks __attribute__((unused)),
  1499.       myf MyFlags)
  1500. {
  1501.   char old_filename[FN_REFLEN],new_filename[FN_REFLEN];
  1502. #ifdef USE_RAID
  1503.   if (raid_chunks)
  1504.     return my_raid_redel(fn_format(old_filename,filename,"",old_ext,2+4),
  1505.  fn_format(new_filename,filename,"",new_ext,2+4),
  1506.  raid_chunks,
  1507.  MYF(MY_WME | MY_LINK_WARNING | MyFlags));
  1508. #endif
  1509.   return my_redel(fn_format(old_filename,filename,"",old_ext,2+4),
  1510.   fn_format(new_filename,filename,"",new_ext,2+4),
  1511.   MYF(MY_WME | MY_LINK_WARNING | MyFlags));
  1512. } /* change_to_newfile */
  1513. /* Locks a whole file */
  1514. /* Gives an error-message if file can't be locked */
  1515. int lock_file(MI_CHECK *param, File file, my_off_t start, int lock_type,
  1516.       const char *filetype, const char *filename)
  1517. {
  1518.   if (my_lock(file,lock_type,start,F_TO_EOF,
  1519.       param->testflag & T_WAIT_FOREVER ? MYF(MY_SEEK_NOT_DONE) :
  1520.       MYF(MY_SEEK_NOT_DONE |  MY_DONT_WAIT)))
  1521.   {
  1522.     mi_check_print_error(param," %d when locking %s '%s'",my_errno,filetype,filename);
  1523.     param->error_printed=2; /* Don't give that data is crashed */
  1524.     return 1;
  1525.   }
  1526.   return 0;
  1527. } /* lock_file */
  1528. /* Copy a block between two files */
  1529. int filecopy(MI_CHECK *param, File to,File from,my_off_t start,
  1530.      my_off_t length, const char *type)
  1531. {
  1532.   char tmp_buff[IO_SIZE],*buff;
  1533.   ulong buff_length;
  1534.   DBUG_ENTER("filecopy");
  1535.   buff_length=(ulong) min(param->write_buffer_length,length);
  1536.   if (!(buff=my_malloc(buff_length,MYF(0))))
  1537.   {
  1538.     buff=tmp_buff; buff_length=IO_SIZE;
  1539.   }
  1540.   VOID(my_seek(from,start,MY_SEEK_SET,MYF(0)));
  1541.   while (length > buff_length)
  1542.   {
  1543.     if (my_read(from,(byte*) buff,buff_length,MYF(MY_NABP)) ||
  1544. my_write(to,(byte*) buff,buff_length,param->myf_rw))
  1545.       goto err;
  1546.     length-= buff_length;
  1547.   }
  1548.   if (my_read(from,(byte*) buff,(uint) length,MYF(MY_NABP)) ||
  1549.       my_write(to,(byte*) buff,(uint) length,param->myf_rw))
  1550.     goto err;
  1551.   if (buff != tmp_buff)
  1552.     my_free(buff,MYF(0));
  1553.   DBUG_RETURN(0);
  1554. err:
  1555.   if (buff != tmp_buff)
  1556.     my_free(buff,MYF(0));
  1557.   mi_check_print_error(param,"Can't copy %s to tempfile, error %d",
  1558.        type,my_errno);
  1559.   DBUG_RETURN(1);
  1560. }
  1561. /* Fix table or given index using sorting */
  1562. /* saves new table in temp_filename */
  1563. int mi_repair_by_sort(MI_CHECK *param, register MI_INFO *info,
  1564.       const char * name, int rep_quick)
  1565. {
  1566.   int got_error;
  1567.   uint i;
  1568.   ulong length;
  1569.   ha_rows start_records;
  1570.   my_off_t new_header_length,del;
  1571.   File new_file;
  1572.   MI_SORT_PARAM sort_param;
  1573.   MYISAM_SHARE *share=info->s;
  1574.   ulong   *rec_per_key_part;
  1575.   char llbuff[22];
  1576.   SORT_INFO *sort_info= &param->sort_info;
  1577.   ulonglong key_map=share->state.key_map;
  1578.   DBUG_ENTER("mi_repair_by_sort");
  1579.   start_records=info->state->records;
  1580.   got_error=1;
  1581.   new_file= -1;
  1582.   new_header_length=(param->testflag & T_UNPACK) ? 0 :
  1583.     share->pack.header_length;
  1584.   if (!(param->testflag & T_SILENT))
  1585.   {
  1586.     printf("- recovering (with sort) MyISAM-table '%s'n",name);
  1587.     printf("Data records: %sn", llstr(start_records,llbuff));
  1588.   }
  1589.   /* Hmm, repair_by_sort uses find_all_keys, and find_all_keys strictly
  1590.      implies "one row - one key per keynr", while for ft_key one row/keynr
  1591.      can produce as many keys as the number of unique words in the text
  1592.      that's why I disabled repair_by_sort for ft-keys. (serg)
  1593.   */
  1594.   for (i=0 ; i < share->base.keys ; i++)
  1595.   {
  1596.     if ((((ulonglong) 1 << i) & key_map) && 
  1597. (share->keyinfo[i].flag & HA_FULLTEXT))
  1598.     {
  1599.       mi_check_print_error(param,
  1600.    "Can`t use repair_by_sort with FULLTEXT key");
  1601.       DBUG_RETURN(1);
  1602.     }
  1603.   }
  1604.   bzero((char*) sort_info,sizeof(*sort_info));
  1605.   if (!(sort_info->key_block=
  1606. alloc_key_blocks(param,
  1607.  (uint) param->sort_key_blocks,
  1608.  share->base.max_key_block_length))
  1609.       || init_io_cache(&param->read_cache,info->dfile,
  1610.        (uint) param->read_buffer_length,
  1611.        READ_CACHE,share->pack.header_length,1,MYF(MY_WME)) ||
  1612.       (! rep_quick &&
  1613.        init_io_cache(&info->rec_cache,info->dfile,
  1614.      (uint) param->write_buffer_length,
  1615.      WRITE_CACHE,new_header_length,1,
  1616.      MYF(MY_WME | MY_WAIT_IF_FULL) & param->myf_rw)))
  1617.     goto err;
  1618.   sort_info->key_block_end=sort_info->key_block+param->sort_key_blocks;
  1619.   info->opt_flag|=WRITE_CACHE_USED;
  1620.   info->rec_cache.file=info->dfile; /* for sort_delete_record */
  1621.   if (!(sort_info->record=(byte*) my_malloc((uint) share->base.pack_reclength,
  1622.    MYF(0))))
  1623.   {
  1624.     mi_check_print_error(param,"Not enough memory for extra record");
  1625.     goto err;
  1626.   }
  1627.   if (!rep_quick)
  1628.   {
  1629.     if ((new_file=my_raid_create(fn_format(param->temp_filename,name,"",
  1630.    DATA_TMP_EXT,
  1631.    2+4),
  1632.  0,param->tmpfile_createflag,
  1633.  share->base.raid_type,
  1634.  share->base.raid_chunks,
  1635.  share->base.raid_chunksize,
  1636.  MYF(0))) < 0)
  1637.     {
  1638.       mi_check_print_error(param,"Can't create new tempfile: '%s'",
  1639.    param->temp_filename);
  1640.       goto err;
  1641.     }
  1642.     if (filecopy(param, new_file,info->dfile,0L,new_header_length,
  1643.  "datafile-header"))
  1644.       goto err;
  1645.     if (param->testflag & T_UNPACK)
  1646.     {
  1647.       share->options&= ~HA_OPTION_COMPRESS_RECORD;
  1648.       mi_int2store(share->state.header.options,share->options);
  1649.     }
  1650.     share->state.dellink= HA_OFFSET_ERROR;
  1651.     info->rec_cache.file=new_file;
  1652.   }
  1653.   info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
  1654.   if (!(param->testflag & T_CREATE_MISSING_KEYS))
  1655.   {
  1656.     /*
  1657.       Flush key cache for this file if we are calling this outside
  1658.       myisamchk
  1659.     */
  1660.     flush_key_blocks(share->kfile, FLUSH_IGNORE_CHANGED);
  1661.     /* Clear the pointers to the given rows */
  1662.     for (i=0 ; i < share->base.keys ; i++)
  1663.       share->state.key_root[i]= HA_OFFSET_ERROR;
  1664.     for (i=0 ; i < share->state.header.max_block_size ; i++)
  1665.       share->state.key_del[i]=  HA_OFFSET_ERROR;
  1666.     info->state->key_file_length=share->base.keystart;
  1667.   }
  1668.   else
  1669.   {
  1670.     if (flush_key_blocks(share->kfile, FLUSH_FORCE_WRITE))
  1671.       goto err;
  1672.     key_map= ~key_map; /* Create the missing keys */
  1673.   }
  1674.   sort_info->info=info;
  1675.   sort_info->param = param;
  1676.   if ((sort_info->new_data_file_type=share->data_file_type) ==
  1677.       COMPRESSED_RECORD && param->testflag & T_UNPACK)
  1678.   {
  1679.     if (share->options & HA_OPTION_PACK_RECORD)
  1680.       sort_info->new_data_file_type = DYNAMIC_RECORD;
  1681.     else
  1682.       sort_info->new_data_file_type = STATIC_RECORD;
  1683.   }
  1684.   sort_info->filepos=new_header_length;
  1685.   sort_info->dupp=0;
  1686.   sort_info->buff=0;
  1687.   param->read_cache.end_of_file=sort_info->filelength=
  1688.     my_seek(param->read_cache.file,0L,MY_SEEK_END,MYF(0));
  1689.   if (share->data_file_type == DYNAMIC_RECORD)
  1690.     length=max(share->base.min_pack_length+1,share->base.min_block_length);
  1691.   else if (share->data_file_type == COMPRESSED_RECORD)
  1692.     length=share->base.min_block_length;
  1693.   else
  1694.     length=share->base.pack_reclength;
  1695.   sort_param.max_records=sort_info->max_records=
  1696.     ((param->testflag & T_TRUST_HEADER) ? info->state->records :
  1697.      (ha_rows) (sort_info->filelength/length+1));
  1698.   sort_param.key_cmp=sort_key_cmp;
  1699.   sort_param.key_write=sort_key_write;
  1700.   sort_param.key_read=sort_key_read;
  1701.   sort_param.lock_in_memory=lock_memory;
  1702.   sort_param.tmpdir=param->tmpdir;
  1703.   sort_param.myf_rw=param->myf_rw;
  1704.   sort_param.sort_info=sort_info;
  1705.   del=info->state->del;
  1706.   if (sort_info->new_data_file_type != COMPRESSED_RECORD &&
  1707.       ! rep_quick)
  1708.     share->state.checksum=0;
  1709.   rec_per_key_part= param->rec_per_key_part;
  1710.   for (sort_info->key=0 ; sort_info->key < share->base.keys ;
  1711.        rec_per_key_part+=sort_info->keyinfo->keysegs, sort_info->key++)
  1712.   {
  1713.     sort_info->keyinfo=share->keyinfo+sort_info->key;
  1714.     if (!(((ulonglong) 1 << sort_info->key) & key_map))
  1715.     {
  1716.       /* Remember old statistics for key */
  1717.       memcpy((char*) rec_per_key_part,
  1718.      (char*) share->state.rec_per_key_part+
  1719.      (uint) (rec_per_key_part - param->rec_per_key_part),
  1720.      sort_info->keyinfo->keysegs*sizeof(*rec_per_key_part));
  1721.       continue;
  1722.     }
  1723.     if ((!(param->testflag & T_SILENT)))
  1724.       printf ("- Fixing index %dn",sort_info->key+1);
  1725.     sort_info->max_pos=sort_info->pos=share->pack.header_length;
  1726.     sort_info->keyseg=sort_info->keyinfo->seg;
  1727.     sort_info->fix_datafile= (my_bool) (sort_info->key == 0 && ! rep_quick);
  1728.     bzero((char*) sort_info->unique,sizeof(sort_info->unique));
  1729.     sort_param.key_length=share->rec_reflength;
  1730.     for (i=0 ; sort_info->keyseg[i].type != HA_KEYTYPE_END; i++)
  1731.     {
  1732.       sort_param.key_length+=sort_info->keyseg[i].length;
  1733.       if (sort_info->keyseg[i].flag & HA_SPACE_PACK)
  1734. sort_param.key_length+=get_pack_length(sort_info->keyseg[i].length);
  1735.       if (sort_info->keyseg[i].flag & (HA_BLOB_PART | HA_VAR_LENGTH))
  1736. sort_param.key_length+=2 + test(sort_info->keyseg[i].length >= 127);
  1737.       if (sort_info->keyseg[i].flag & HA_NULL_PART)
  1738. sort_param.key_length++;
  1739.     }
  1740.     info->state->records=info->state->del=share->state.split=0;
  1741.     info->state->empty=0;
  1742.     if (_create_index_by_sort(&sort_param,
  1743.       (my_bool) (!(param->testflag & T_VERBOSE)),
  1744.       (uint) param->sort_buffer_length))
  1745.     {
  1746.       param->retry_repair=1;
  1747.       goto err;
  1748.     }
  1749.     /* Set for next loop */
  1750.     sort_param.max_records=sort_info->max_records=
  1751.       (ha_rows) info->state->records;
  1752.     if (param->testflag & T_STATISTICS)
  1753.       update_key_parts(sort_info->keyinfo, rec_per_key_part, sort_info->unique,
  1754.        (ulonglong) info->state->records);
  1755.     share->state.key_map|=(ulonglong) 1 << sort_info->key;
  1756.     if (sort_info->fix_datafile)
  1757.     {
  1758.       param->read_cache.end_of_file=sort_info->filepos;
  1759.       if (write_data_suffix(param,info) || end_io_cache(&info->rec_cache))
  1760. goto err;
  1761.       if (param->testflag & T_SAFE_REPAIR)
  1762.       {
  1763. /* Don't repair if we loosed more than one row */
  1764. if (info->state->records+1 < start_records)
  1765. {
  1766.   info->state->records=start_records;
  1767.   goto err;
  1768. }
  1769.       }
  1770.       share->state.state.data_file_length = info->state->data_file_length
  1771. = sort_info->filepos;
  1772.       /* Only whole records */
  1773.       share->state.split=info->state->records+info->state->del;
  1774.       share->state.version=(ulong) time((time_t*) 0);
  1775.       my_close(info->dfile,MYF(0));
  1776.       info->dfile=new_file;
  1777.       share->data_file_type=sort_info->new_data_file_type;
  1778.       share->pack.header_length=(ulong) new_header_length;
  1779.     }
  1780.     else
  1781.       info->state->data_file_length=sort_info->max_pos;
  1782.     if (flush_pending_blocks(param))
  1783.       goto err;
  1784.     param->read_cache.file=info->dfile; /* re-init read cache */
  1785.     reinit_io_cache(&param->read_cache,READ_CACHE,share->pack.header_length,1,
  1786.     1);
  1787.   }
  1788.   if (param->testflag & T_WRITE_LOOP)
  1789.   {
  1790.     VOID(fputs("          r",stdout)); VOID(fflush(stdout));
  1791.   }
  1792.   if (rep_quick && del+sort_info->dupp != info->state->del)
  1793.   {
  1794.     mi_check_print_error(param,"Couldn't fix table with quick recovery: Found wrong number of deleted records");
  1795.     mi_check_print_error(param,"Run recovery again without -q");
  1796.     got_error=1;
  1797.     param->retry_repair=param->retry_without_quick=1;
  1798.     goto err;
  1799.   }
  1800.   if (rep_quick != 1)
  1801.   {
  1802.     my_off_t skr=info->state->data_file_length+
  1803.       (share->options & HA_OPTION_COMPRESS_RECORD ?
  1804.        MEMMAP_EXTRA_MARGIN : 0);
  1805. #ifdef USE_RELOC
  1806.     if (share->data_file_type == STATIC_RECORD &&
  1807. skr < share->base.reloc*share->base.min_pack_length)
  1808.       skr=share->base.reloc*share->base.min_pack_length;
  1809. #endif
  1810.     if (skr != sort_info->filelength && !info->s->base.raid_type)
  1811.       if (my_chsize(info->dfile,skr,MYF(0)))
  1812. mi_check_print_warning(param,
  1813.        "Can't change size of datafile,  error: %d",
  1814.        my_errno);
  1815.   }
  1816.   if (my_chsize(share->kfile,info->state->key_file_length,MYF(0)))
  1817.     mi_check_print_warning(param,
  1818.    "Can't change size of indexfile, error: %d",
  1819.    my_errno);
  1820.   if (!(param->testflag & T_SILENT))
  1821.   {
  1822.     if (start_records != info->state->records)
  1823.       printf("Data records: %sn", llstr(info->state->records,llbuff));
  1824.     if (sort_info->dupp)
  1825.       mi_check_print_warning(param,
  1826.      "%s records have been removed",
  1827.      llstr(sort_info->dupp,llbuff));
  1828.   }
  1829.   got_error=0;
  1830.   if (&share->state.state != info->state)
  1831.     memcpy( &share->state.state, info->state, sizeof(*info->state));
  1832. err:
  1833.   got_error|= flush_blocks(param,share->kfile);
  1834.   VOID(end_io_cache(&info->rec_cache));
  1835.   if (!got_error)
  1836.   {
  1837.     /* Replace the actual file with the temporary file */
  1838.     if (new_file >= 0)
  1839.     {
  1840.       my_close(new_file,MYF(0));
  1841.       info->dfile=new_file= -1;
  1842.       if (change_to_newfile(share->filename,MI_NAME_DEXT,
  1843.     DATA_TMP_EXT, share->base.raid_chunks,
  1844.     (param->testflag & T_BACKUP_DATA ?
  1845.      MYF(MY_REDEL_MAKE_BACKUP): MYF(0))) ||
  1846.   mi_open_datafile(info,share))
  1847. got_error=1;
  1848.     }
  1849.   }
  1850.   if (got_error)
  1851.   {
  1852.     if (! param->error_printed)
  1853.       mi_check_print_error(param,"%d when fixing table",my_errno);
  1854.     if (new_file >= 0)
  1855.     {
  1856.       VOID(my_close(new_file,MYF(0)));
  1857.       VOID(my_raid_delete(param->temp_filename,share->base.raid_chunks,
  1858.   MYF(MY_WME)));
  1859.       if (info->dfile == new_file)
  1860. info->dfile= -1;
  1861.     }
  1862.     mi_mark_crashed_on_repair(info);
  1863.   }
  1864.   else if (key_map == share->state.key_map)
  1865.     share->state.changed&= ~STATE_NOT_OPTIMIZED_KEYS;
  1866.   share->state.changed|=STATE_NOT_SORTED_PAGES;
  1867.   my_free((gptr) sort_info->key_block,MYF(MY_ALLOW_ZERO_PTR));
  1868.   my_free(sort_info->record,MYF(MY_ALLOW_ZERO_PTR));
  1869.   my_free(sort_info->buff,MYF(MY_ALLOW_ZERO_PTR));
  1870.   VOID(end_io_cache(&param->read_cache));
  1871.   info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
  1872.   if (!got_error && (param->testflag & T_UNPACK))
  1873.   {
  1874.     share->state.header.options[0]&= (uchar) ~HA_OPTION_COMPRESS_RECORD;
  1875.     share->pack.header_length=0;
  1876.   }
  1877.   DBUG_RETURN(got_error);
  1878. }
  1879. /* Read next record and return next key */
  1880. static int sort_key_read(SORT_INFO *sort_info, void *key)
  1881. {
  1882.   int error;
  1883.   MI_INFO *info;
  1884.   DBUG_ENTER("sort_key_read");
  1885.   info=sort_info->info;
  1886.   if ((error=sort_get_next_record(sort_info)))
  1887.     DBUG_RETURN(error);
  1888.   if (info->state->records == sort_info->max_records)
  1889.   {
  1890.     mi_check_print_error(sort_info->param,
  1891.  "Found too many records; Can`t continue");
  1892.     DBUG_RETURN(1);
  1893.   }
  1894.   (void) _mi_make_key(info,sort_info->key,key,sort_info->record,
  1895.                       sort_info->filepos);
  1896.   DBUG_RETURN(sort_write_record(sort_info));
  1897. } /* sort_key_read */
  1898. /* Read next record from file using parameters in sort_info */
  1899. /* Return -1 if end of file, 0 if ok and > 0 if error */
  1900. static int sort_get_next_record(SORT_INFO *sort_info)
  1901. {
  1902.   int searching;
  1903.   uint found_record,b_type,left_length;
  1904.   my_off_t pos;
  1905.   byte *to;
  1906.   MI_BLOCK_INFO block_info;
  1907.   MI_INFO *info;
  1908.   MYISAM_SHARE *share;
  1909.   MI_CHECK *param=sort_info->param;
  1910.   char llbuff[22],llbuff2[22];
  1911.   DBUG_ENTER("sort_get_next_record");
  1912.   info=sort_info->info;
  1913.   share=info->s;
  1914.   switch (share->data_file_type) {
  1915.   case STATIC_RECORD:
  1916.     for (;;)
  1917.     {
  1918.       if (my_b_read(&param->read_cache,sort_info->record,
  1919.     share->base.pack_reclength))
  1920.       {
  1921. if (param->read_cache.error)
  1922.   param->out_flag |= O_DATA_LOST;
  1923. param->retry_repair=param->retry_without_quick=1;
  1924. DBUG_RETURN(-1);
  1925.       }
  1926.       sort_info->start_recpos=sort_info->pos;
  1927.       if (!sort_info->fix_datafile)
  1928. sort_info->filepos=sort_info->pos;
  1929.       sort_info->max_pos=(sort_info->pos+=share->base.pack_reclength);
  1930.       share->state.split++;
  1931.       if (*sort_info->record)
  1932. DBUG_RETURN(0);
  1933.       if (!sort_info->fix_datafile)
  1934.       {
  1935. info->state->del++;
  1936. info->state->empty+=share->base.pack_reclength;
  1937.       }
  1938.     }
  1939.   case DYNAMIC_RECORD:
  1940.     LINT_INIT(to);
  1941.     pos=sort_info->pos;
  1942.     searching=(sort_info->fix_datafile && (param->testflag & T_EXTEND));
  1943.     for (;;)
  1944.     {
  1945.       found_record=block_info.second_read= 0;
  1946.       left_length=1;
  1947.       if (searching)
  1948.       {
  1949. pos=MY_ALIGN(pos,MI_DYN_ALIGN_SIZE);
  1950. param->retry_without_quick=1;
  1951. sort_info->start_recpos=pos;   
  1952.       }
  1953.       do
  1954.       {
  1955. if (pos > sort_info->max_pos)
  1956.   sort_info->max_pos=pos;
  1957. if (pos & (MI_DYN_ALIGN_SIZE-1))
  1958. {
  1959.   if ((param->testflag & T_VERBOSE) || searching == 0)
  1960.     mi_check_print_info(param,"Wrong aligned block at %s",
  1961. llstr(pos,llbuff));
  1962.   if (searching)
  1963.     goto try_next;
  1964. }
  1965. if (found_record && pos == param->search_after_block)
  1966.   mi_check_print_info(param,"Block: %s used by record at %s",
  1967.      llstr(param->search_after_block,llbuff),
  1968.      llstr(sort_info->start_recpos,llbuff2));
  1969. if (_mi_read_cache(&param->read_cache,(byte*) block_info.header,pos,
  1970.    MI_BLOCK_INFO_HEADER_LENGTH,
  1971.    (! found_record ? READING_NEXT : 0) |
  1972.    READING_HEADER))
  1973. {
  1974.   if (found_record)
  1975.   {
  1976.     mi_check_print_info(param,
  1977. "Can't read whole record at %s (errno: %d)",
  1978. llstr(sort_info->start_recpos,llbuff),errno);
  1979.     goto try_next;
  1980.   }
  1981.   DBUG_RETURN(-1);
  1982. }
  1983. if (searching && ! sort_info->fix_datafile)
  1984. {
  1985.   param->error_printed=1;
  1986.   param->retry_repair=param->retry_without_quick=1;
  1987.   DBUG_RETURN(1); /* Something wrong with data */
  1988. }
  1989. if (((b_type=_mi_get_block_info(&block_info,-1,pos)) &
  1990.      (BLOCK_ERROR | BLOCK_FATAL_ERROR)) ||
  1991.     ((b_type & BLOCK_FIRST) &&
  1992.      (block_info.rec_len < (uint) share->base.min_pack_length ||
  1993.       block_info.rec_len > (uint) share->base.max_pack_length)))
  1994. {
  1995.   uint i;
  1996.   if (param->testflag & T_VERBOSE || searching == 0)
  1997.     mi_check_print_info(param,
  1998. "Wrong bytesec: %3d-%3d-%3d at %10s; Skipped",
  1999.        block_info.header[0],block_info.header[1],
  2000.        block_info.header[2],llstr(pos,llbuff));
  2001.   if (found_record)
  2002.     goto try_next;
  2003.   block_info.second_read=0;
  2004.   searching=1;
  2005.   /* Search after block in read header string */
  2006.   for (i=MI_DYN_ALIGN_SIZE ;
  2007.        i < MI_BLOCK_INFO_HEADER_LENGTH ;
  2008.        i+= MI_DYN_ALIGN_SIZE)
  2009.     if (block_info.header[i] >= 1 &&
  2010. block_info.header[i] <= MI_MAX_DYN_HEADER_BYTE)
  2011.       break;
  2012.   pos+=(ulong) i;
  2013.   sort_info->start_recpos=pos;   
  2014.   continue;
  2015. }
  2016. if (b_type & BLOCK_DELETED)
  2017. {
  2018.   bool error=0;
  2019.   if (block_info.block_len+ (uint) (block_info.filepos-pos) <
  2020.       share->base.min_block_length)
  2021.   {
  2022.     if (!searching)
  2023.       mi_check_print_info(param,
  2024.   "Deleted block with impossible length %u at %s",
  2025.   block_info.block_len,llstr(pos,llbuff));
  2026.     error=1;
  2027.   }
  2028.   else
  2029.   {
  2030.     if ((block_info.next_filepos != HA_OFFSET_ERROR &&
  2031.  block_info.next_filepos >=
  2032.  info->state->data_file_length) ||
  2033. (block_info.prev_filepos != HA_OFFSET_ERROR &&
  2034.  block_info.prev_filepos >= info->state->data_file_length))
  2035.     {
  2036.       if (!searching)
  2037. mi_check_print_info(param,
  2038.     "Delete link points outside datafile at %s",
  2039.     llstr(pos,llbuff));
  2040.       error=1;
  2041.     }
  2042.   }
  2043.   if (error)
  2044.   {
  2045.     if (found_record)
  2046.       goto try_next;
  2047.     searching=1;
  2048.     pos+= MI_DYN_ALIGN_SIZE;
  2049.     sort_info->start_recpos=pos;   
  2050.     block_info.second_read=0;
  2051.     continue;
  2052.   }
  2053. }
  2054. else
  2055. {
  2056.   if (block_info.block_len+ (uint) (block_info.filepos-pos) <
  2057.       share->base.min_block_length ||
  2058.       block_info.block_len > (uint) share->base.max_pack_length+
  2059.       MI_SPLIT_LENGTH)
  2060.   {
  2061.     if (!searching)
  2062.       mi_check_print_info(param,
  2063.   "Found block with impossible length %u at %s; Skipped",
  2064.   block_info.block_len+ (uint) (block_info.filepos-pos),
  2065.   llstr(pos,llbuff));
  2066.     if (found_record)
  2067.       goto try_next;
  2068.     searching=1;
  2069.     pos+= MI_DYN_ALIGN_SIZE;
  2070.     sort_info->start_recpos=pos;   
  2071.     block_info.second_read=0;
  2072.     continue;
  2073.   }
  2074. }
  2075. if (b_type & (BLOCK_DELETED | BLOCK_SYNC_ERROR))
  2076. {
  2077.   if (!sort_info->fix_datafile && (b_type & BLOCK_DELETED))
  2078.   {
  2079.     info->state->empty+=block_info.block_len;
  2080.     info->state->del++;
  2081.     share->state.split++;
  2082.   }
  2083.   if (found_record)
  2084.     goto try_next;
  2085.   if (searching)
  2086.   {
  2087.     pos+=MI_DYN_ALIGN_SIZE;
  2088.     sort_info->start_recpos=pos;
  2089.   }
  2090.   else
  2091.     pos=block_info.filepos+block_info.block_len;
  2092.   block_info.second_read=0;
  2093.   continue;
  2094. }
  2095. share->state.split++;
  2096. if (! found_record++)
  2097. {
  2098.   sort_info->find_length=left_length=block_info.rec_len;
  2099.   sort_info->start_recpos=pos;
  2100.   if (!sort_info->fix_datafile)
  2101.     sort_info->filepos=sort_info->start_recpos;
  2102.   if (sort_info->fix_datafile && (param->testflag & T_EXTEND))
  2103.     sort_info->pos=block_info.filepos+1;
  2104.   else
  2105.     sort_info->pos=block_info.filepos+block_info.block_len;
  2106.   if (share->base.blobs)
  2107.   {
  2108.     if (!(to=mi_fix_rec_buff_for_blob(info,block_info.rec_len)))
  2109.     {
  2110.       mi_check_print_error(param,"Not enough memory for blob at %s",
  2111.   llstr(sort_info->start_recpos,llbuff));
  2112.       DBUG_RETURN(1);
  2113.     }
  2114.   }
  2115.   else
  2116.     to= info->rec_buff;
  2117. }
  2118. if (left_length < block_info.data_len || ! block_info.data_len)
  2119. {
  2120.   mi_check_print_info(param,"Found block with too small length at %s; Skipped",
  2121.       llstr(sort_info->start_recpos,llbuff));
  2122.   goto try_next;
  2123. }
  2124. if (block_info.filepos + block_info.data_len >
  2125.     param->read_cache.end_of_file)
  2126. {
  2127.   mi_check_print_info(param,"Found block that points outside data file at %s",
  2128.       llstr(sort_info->start_recpos,llbuff));
  2129.   goto try_next;
  2130. }
  2131. if (_mi_read_cache(&param->read_cache,to,block_info.filepos,
  2132.    block_info.data_len,
  2133.    (found_record == 1 ? READING_NEXT : 0)))
  2134. {
  2135.   mi_check_print_info(param,
  2136.       "Read error for block at: %s (error: %d); Skipped",
  2137.       llstr(block_info.filepos,llbuff),my_errno);
  2138.   goto try_next;
  2139. }
  2140. left_length-=block_info.data_len;
  2141. to+=block_info.data_len;
  2142. pos=block_info.next_filepos;
  2143. if (pos == HA_OFFSET_ERROR && left_length)
  2144. {
  2145.   mi_check_print_info(param,"Wrong block with wrong total length starting at %s",
  2146.       llstr(sort_info->start_recpos,llbuff));
  2147.   goto try_next;
  2148. }
  2149. if (pos + MI_BLOCK_INFO_HEADER_LENGTH > param->read_cache.end_of_file)
  2150. {
  2151.   mi_check_print_info(param,"Found link that points at %s (outside data file) at %s",
  2152.       llstr(pos,llbuff2),
  2153.       llstr(sort_info->start_recpos,llbuff));
  2154.   goto try_next;
  2155. }
  2156.       } while (left_length);
  2157.       if (_mi_rec_unpack(info,sort_info->record,info->rec_buff,
  2158.  sort_info->find_length) != MY_FILE_ERROR)
  2159.       {
  2160. if (param->read_cache.error < 0)
  2161.   DBUG_RETURN(1);
  2162. if ((param->testflag & (T_EXTEND | T_REP)) || searching)
  2163. {
  2164.   if (info->s->calc_checksum)
  2165.     info->checksum=mi_checksum(info,sort_info->record);
  2166.   if (_mi_rec_check(info, sort_info->record))
  2167.   {
  2168.     mi_check_print_info(param,"Found wrong packed record at %s",
  2169. llstr(sort_info->start_recpos,llbuff));
  2170.     goto try_next;
  2171.   }
  2172. }
  2173. DBUG_RETURN(0);
  2174.       }
  2175.     try_next:
  2176.       pos=(sort_info->start_recpos+=MI_DYN_ALIGN_SIZE);
  2177.       searching=1;
  2178.     }
  2179.   case COMPRESSED_RECORD:
  2180.     for (searching=0 ;; searching=1, sort_info->pos++)
  2181.     {
  2182.       if (_mi_read_cache(&param->read_cache,(byte*) block_info.header,
  2183.  sort_info->pos,
  2184.  share->pack.ref_length,READING_NEXT))
  2185. DBUG_RETURN(-1);
  2186.       if (searching && ! sort_info->fix_datafile)
  2187.       {
  2188. param->error_printed=1;
  2189. param->retry_repair=param->retry_without_quick=1;
  2190. DBUG_RETURN(1); /* Something wrong with data */
  2191.       }
  2192.       sort_info->start_recpos=sort_info->pos;
  2193.       if (_mi_pack_get_block_info(info,&block_info,-1,sort_info->pos, NullS))
  2194. DBUG_RETURN(-1);
  2195.       if (!block_info.rec_len &&
  2196.   sort_info->pos + MEMMAP_EXTRA_MARGIN ==
  2197.   param->read_cache.end_of_file)
  2198. DBUG_RETURN(-1);
  2199.       if (block_info.rec_len < (uint) share->min_pack_length ||
  2200.   block_info.rec_len > (uint) share->max_pack_length)
  2201.       {
  2202. if (! searching)
  2203.   mi_check_print_info(param,"Found block with wrong recordlength: %d at %sn",
  2204.       block_info.rec_len,
  2205.       llstr(sort_info->pos,llbuff));
  2206. continue;
  2207.       }
  2208.       if (_mi_read_cache(&param->read_cache,(byte*) info->rec_buff,
  2209.  block_info.filepos, block_info.rec_len,
  2210.  READING_NEXT))
  2211.       {
  2212. if (! searching)
  2213.   mi_check_print_info(param,"Couldn't read whole record from %s",
  2214.       llstr(sort_info->pos,llbuff));
  2215. continue;
  2216.       }
  2217.       if (_mi_pack_rec_unpack(info,sort_info->record,info->rec_buff,
  2218.       block_info.rec_len))
  2219.       {
  2220. if (! searching)
  2221.   mi_check_print_info(param,"Found wrong record at %s",
  2222.       llstr(sort_info->pos,llbuff));
  2223. continue;
  2224.       }
  2225.       if (!sort_info->fix_datafile)
  2226. sort_info->filepos=sort_info->pos;
  2227.       sort_info->max_pos=(sort_info->pos=block_info.filepos+
  2228.  block_info.rec_len);
  2229.       share->state.split++;
  2230.       info->packed_length=block_info.rec_len;
  2231.       DBUG_RETURN(0);
  2232.     }
  2233.   }
  2234.   DBUG_RETURN(1); /* Impossible */
  2235. }
  2236. /* Write record to new file */
  2237. int sort_write_record(SORT_INFO *sort_info)
  2238. {
  2239.   int flag;
  2240.   uint length;
  2241.   ulong block_length,reclength;
  2242.   byte *from;
  2243.   byte block_buff[8];
  2244.   MI_INFO *info;
  2245.   MYISAM_SHARE *share;
  2246.   MI_CHECK *param=sort_info->param;
  2247.   DBUG_ENTER("sort_write_record");
  2248.   info=sort_info->info;
  2249.   share=info->s;
  2250.   if (sort_info->fix_datafile)
  2251.   {
  2252.     switch (sort_info->new_data_file_type) {
  2253.     case STATIC_RECORD:
  2254.       if (my_b_write(&info->rec_cache,sort_info->record,
  2255.      share->base.pack_reclength))
  2256.       {
  2257. mi_check_print_error(param,"%d when writing to datafile",my_errno);
  2258. DBUG_RETURN(1);
  2259.       }
  2260.       sort_info->filepos+=share->base.pack_reclength;
  2261.       info->s->state.checksum+=mi_static_checksum(info, sort_info->record);
  2262.       break;
  2263.     case DYNAMIC_RECORD:
  2264.       if (! info->blobs)
  2265. from=info->rec_buff;
  2266.       else
  2267.       {
  2268. /* must be sure that local buffer is big enough */
  2269. reclength=info->s->base.pack_reclength+
  2270.   _my_calc_total_blob_length(info,sort_info->record)+
  2271.   ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
  2272.   MI_DYN_DELETE_BLOCK_HEADER;
  2273. if (sort_info->buff_length < reclength)
  2274. {
  2275.   if (!(sort_info->buff=my_realloc(sort_info->buff, (uint) reclength,
  2276.    MYF(MY_FREE_ON_ERROR |
  2277.        MY_ALLOW_ZERO_PTR))))
  2278.     DBUG_RETURN(1);
  2279.   sort_info->buff_length=reclength;
  2280. }
  2281. from=sort_info->buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER);
  2282.       }
  2283.       info->checksum=mi_checksum(info,sort_info->record);
  2284.       reclength=_mi_rec_pack(info,from,sort_info->record);
  2285.       info->s->state.checksum+=info->checksum;
  2286.       block_length=reclength+ 3 +test(reclength > 65532L);
  2287.       if (block_length < share->base.min_block_length)
  2288. block_length=share->base.min_block_length;
  2289.       flag=0;
  2290.       info->update|=HA_STATE_WRITE_AT_END;
  2291.       block_length=MY_ALIGN(block_length,MI_DYN_ALIGN_SIZE);
  2292.       if (_mi_write_part_record(info,0L,block_length,HA_OFFSET_ERROR,
  2293. &from,&reclength,&flag))
  2294.       {
  2295. mi_check_print_error(param,"%d when writing to datafile",my_errno);
  2296. DBUG_RETURN(1);
  2297.       }
  2298.       sort_info->filepos+=block_length;
  2299.       break;
  2300.     case COMPRESSED_RECORD:
  2301.       reclength=info->packed_length;
  2302.       length=save_pack_length(block_buff,reclength);
  2303.       if (info->s->base.blobs)
  2304. length+=save_pack_length(block_buff+length,info->blob_length);
  2305.       if (my_b_write(&info->rec_cache,block_buff,length) ||
  2306.   my_b_write(&info->rec_cache,(byte*) info->rec_buff,reclength))
  2307.       {
  2308. mi_check_print_error(param,"%d when writing to datafile",my_errno);
  2309. DBUG_RETURN(1);
  2310.       }
  2311.       sort_info->filepos+=reclength+length;
  2312.       break;
  2313.     }
  2314.   }
  2315.   info->state->records++;
  2316.   if ((param->testflag & T_WRITE_LOOP) &&
  2317.       (info->state->records % WRITE_COUNT) == 0)
  2318.   {
  2319.     char llbuff[22];
  2320.     printf("%sr", llstr(info->state->records,llbuff)); VOID(fflush(stdout));
  2321.   }
  2322.   DBUG_RETURN(0);
  2323. } /* sort_write_record */
  2324. /* Compare two keys from _create_index_by_sort */
  2325. static int sort_key_cmp(SORT_INFO *sort_info, const void *a, const void *b)
  2326. {
  2327.   uint not_used;
  2328.   return (_mi_key_cmp(sort_info->keyseg,*((uchar**) a),*((uchar**) b),
  2329.       USE_WHOLE_KEY, SEARCH_SAME,&not_used));
  2330. } /* sort_key_cmp */
  2331. static int sort_key_write(SORT_INFO *sort_info, const void *a)
  2332. {
  2333.   uint diff_pos;
  2334.   char llbuff[22],llbuff2[22];
  2335.   MI_CHECK *param= sort_info->param;
  2336.   int cmp;
  2337.   if (sort_info->key_block->inited)
  2338.   {
  2339.     cmp=_mi_key_cmp(sort_info->keyseg,sort_info->key_block->lastkey,(uchar*) a,
  2340.     USE_WHOLE_KEY,SEARCH_FIND | SEARCH_UPDATE ,&diff_pos);
  2341.     sort_info->unique[diff_pos-1]++;
  2342.   }
  2343.   else
  2344.   {
  2345.     cmp= -1;
  2346.   }
  2347.   if ((sort_info->keyinfo->flag & HA_NOSAME) && cmp == 0)
  2348.   {
  2349.     sort_info->dupp++;
  2350.     sort_info->info->lastpos=get_record_for_key(sort_info->info,
  2351.        sort_info->keyinfo,
  2352.        (uchar*) a);
  2353.     mi_check_print_warning(param,
  2354.    "Duplicate key for record at %10s against record at %10s",
  2355.    llstr(sort_info->info->lastpos,llbuff),
  2356.    llstr(get_record_for_key(sort_info->info,
  2357.     sort_info->keyinfo,
  2358.     sort_info->key_block->
  2359.     lastkey),
  2360.  llbuff2));
  2361.     param->error_printed=param->retry_without_quick=1;
  2362.     if (sort_info->param->testflag & T_VERBOSE)
  2363.       _mi_print_key(stdout,sort_info->keyseg,(uchar*) a, USE_WHOLE_KEY);
  2364.     return (sort_delete_record(param));
  2365.   }
  2366. #ifndef DBUG_OFF
  2367.   if (cmp > 0)
  2368.   {
  2369.     mi_check_print_error(param,
  2370.  "Internal error: Keys are not in order from sort");
  2371.     return(1);
  2372.   }
  2373. #endif
  2374.   return (sort_insert_key(param,sort_info->key_block,(uchar*) a,
  2375.   HA_OFFSET_ERROR));
  2376. } /* sort_key_write */
  2377. /* get pointer to record from a key */
  2378. static my_off_t get_record_for_key(MI_INFO *info, MI_KEYDEF *keyinfo,
  2379.    uchar *key)
  2380. {
  2381.   return _mi_dpos(info,0,key+_mi_keylength(keyinfo,key));
  2382. } /* get_record_for_key */
  2383. /* Insert a key in sort-key-blocks */
  2384. static int sort_insert_key(MI_CHECK *param,
  2385.    register SORT_KEY_BLOCKS *key_block, uchar *key,
  2386.    my_off_t prev_block)
  2387. {
  2388.   uint a_length,t_length,nod_flag;
  2389.   my_off_t filepos,key_file_length;
  2390.   uchar *anc_buff,*lastkey;
  2391.   MI_KEY_PARAM s_temp;
  2392.   MI_INFO *info;
  2393.   SORT_INFO *sort_info= &param->sort_info;
  2394.   DBUG_ENTER("sort_insert_key");
  2395.   anc_buff=key_block->buff;
  2396.   info=sort_info->info;
  2397.   lastkey=key_block->lastkey;
  2398.   nod_flag= (key_block == sort_info->key_block ? 0 :
  2399.      sort_info->info->s->base.key_reflength);
  2400.   if (!key_block->inited)
  2401.   {
  2402.     key_block->inited=1;
  2403.     if (key_block == sort_info->key_block_end)
  2404.     {
  2405.       mi_check_print_error(param,"To many key-block-levels; Try increasing sort_key_blocks");
  2406.       DBUG_RETURN(1);
  2407.     }
  2408.     a_length=2+nod_flag;
  2409.     key_block->end_pos=anc_buff+2;
  2410.     lastkey=0; /* No previous key in block */
  2411.   }
  2412.   else
  2413.     a_length=mi_getint(anc_buff);
  2414. /* Save pointer to previous block */
  2415.   if (nod_flag)
  2416.     _mi_kpointer(info,key_block->end_pos,prev_block);
  2417.   t_length=(*sort_info->keyinfo->pack_key)(sort_info->keyinfo,nod_flag,
  2418.   (uchar*) 0,lastkey,lastkey,key,
  2419.   &s_temp);
  2420.   (*sort_info->keyinfo->store_key)(sort_info->keyinfo,
  2421.   key_block->end_pos+nod_flag,&s_temp);
  2422.   a_length+=t_length;
  2423.   mi_putint(anc_buff,a_length,nod_flag);
  2424.   key_block->end_pos+=t_length;
  2425.   if (a_length <= sort_info->keyinfo->block_length)
  2426.   {
  2427.     VOID(_mi_move_key(sort_info->keyinfo,key_block->lastkey,key));
  2428.     key_block->last_length=a_length-t_length;
  2429.     DBUG_RETURN(0);
  2430.   }
  2431. /* Fill block with end-zero and write filled block */
  2432.   mi_putint(anc_buff,key_block->last_length,nod_flag);
  2433.   bzero((byte*) anc_buff+key_block->last_length,
  2434. sort_info->keyinfo->block_length- key_block->last_length);
  2435.   key_file_length=info->state->key_file_length;
  2436.   if ((filepos=_mi_new(info,sort_info->keyinfo)) == HA_OFFSET_ERROR)
  2437.     DBUG_RETURN(1);
  2438.   /* If we read the page from the key cache, we have to write it back to it */
  2439.   if (key_file_length == info->state->key_file_length)
  2440.   {
  2441.     if (_mi_write_keypage(info, sort_info->keyinfo, filepos,
  2442.   anc_buff))
  2443.       DBUG_RETURN(1);
  2444.   }
  2445.   else if (my_pwrite(info->s->kfile,(byte*) anc_buff,
  2446.      (uint) sort_info->keyinfo->block_length,filepos,
  2447.      param->myf_rw))
  2448.     DBUG_RETURN(1);
  2449.   DBUG_DUMP("buff",(byte*) anc_buff,mi_getint(anc_buff));
  2450. /* Write separator-key to block in next level */
  2451.   if (sort_insert_key(param,key_block+1,key_block->lastkey,filepos))
  2452.     DBUG_RETURN(1);
  2453. /* clear old block and write new key in it */
  2454.   key_block->inited=0;
  2455.   DBUG_RETURN(sort_insert_key(param, key_block,key,prev_block));
  2456. } /* sort_insert_key */
  2457. /* Delete record when we found a duplicated key */
  2458. static int sort_delete_record(MI_CHECK *param)
  2459. {
  2460.   uint i;
  2461.   int old_file,error;
  2462.   uchar *key;
  2463.   MI_INFO *info;
  2464.   SORT_INFO *sort_info= &param->sort_info;
  2465.   DBUG_ENTER("sort_delete_record");
  2466.   if (param->opt_rep_quick == 1)
  2467.   {
  2468.     mi_check_print_error(param,
  2469.  "Quick-recover aborted; Run recovery without switch 'q' or with switch -qq");
  2470.     DBUG_RETURN(1);
  2471.   }
  2472.   info=sort_info->info;
  2473.   if (info->s->options & HA_OPTION_COMPRESS_RECORD)
  2474.   {
  2475.     mi_check_print_error(param,
  2476.  "Recover aborted; Can't run standard recovery on compressed tables with errors in data-file. Use switch 'myisamchk --safe-recover' to fix itn",stderr);;
  2477.     DBUG_RETURN(1);
  2478.   }
  2479.   old_file=info->dfile;
  2480.   info->dfile=info->rec_cache.file;
  2481.   if (sort_info->key)
  2482.   {
  2483.     key=info->lastkey+info->s->base.max_key_length;
  2484.     if ((error=(*info->s->read_rnd)(info,sort_info->record,info->lastpos,0)) &&
  2485. error != HA_ERR_RECORD_DELETED)
  2486.     {
  2487.       mi_check_print_error(param,"Can't read record to be removed");
  2488.       info->dfile=old_file;
  2489.       DBUG_RETURN(1);
  2490.     }
  2491.     for (i=0 ; i < sort_info->key ; i++)
  2492.     {
  2493.       uint key_length=_mi_make_key(info,i,key,sort_info->record,info->lastpos);
  2494.       if (_mi_ck_delete(info,i,key,key_length))
  2495.       {
  2496. mi_check_print_error(param,"Can't delete key %d from record to be removed",i+1);
  2497. info->dfile=old_file;
  2498. DBUG_RETURN(1);
  2499.       }
  2500.     }
  2501.     if (info->s->calc_checksum)
  2502.       info->s->state.checksum-=(*info->s->calc_checksum)(info,
  2503.  sort_info->record);
  2504.   }
  2505.   error=flush_io_cache(&info->rec_cache) || (*info->s->delete_record)(info);
  2506.   info->dfile=old_file; /* restore actual value */
  2507.   info->state->records--;
  2508.   DBUG_RETURN(error);
  2509. } /* sort_delete_record */
  2510. /* Fix all pending blocks and flush everything to disk */
  2511. static int flush_pending_blocks(MI_CHECK *param)
  2512. {
  2513.   uint nod_flag,length;
  2514.   my_off_t filepos,key_file_length;
  2515.   MI_INFO *info;
  2516.   SORT_KEY_BLOCKS *key_block;
  2517.   SORT_INFO *sort_info= &param->sort_info;
  2518.   DBUG_ENTER("flush_pending_blocks");
  2519.   filepos= HA_OFFSET_ERROR; /* if empty file */
  2520.   info=sort_info->info;
  2521.   nod_flag=0;
  2522.   for (key_block=sort_info->key_block ; key_block->inited ; key_block++)
  2523.   {
  2524.     key_block->inited=0;
  2525.     length=mi_getint(key_block->buff);
  2526.     if (nod_flag)
  2527.       _mi_kpointer(info,key_block->end_pos,filepos);
  2528.     key_file_length=info->state->key_file_length;
  2529.     bzero((byte*) key_block->buff+length,
  2530.   sort_info->keyinfo->block_length-length);
  2531.     if ((filepos=_mi_new(info,sort_info->keyinfo)) == HA_OFFSET_ERROR)
  2532.       DBUG_RETURN(1);
  2533.     /* If we read the page from the key cache, we have to write it back */
  2534.     if (key_file_length == info->state->key_file_length)
  2535.     {
  2536.       if (_mi_write_keypage(info, sort_info->keyinfo, filepos,
  2537.     key_block->buff))
  2538. DBUG_RETURN(1);
  2539.     }
  2540.     else if (my_pwrite(info->s->kfile,(byte*) key_block->buff,
  2541.        (uint) sort_info->keyinfo->block_length,filepos,
  2542.        param->myf_rw))
  2543.       DBUG_RETURN(1);
  2544.     DBUG_DUMP("buff",(byte*) key_block->buff,length);
  2545.     nod_flag=1;
  2546.   }
  2547.   info->s->state.key_root[sort_info->key]=filepos; /* Last is root for tree */
  2548.   DBUG_RETURN(0);
  2549. } /* flush_pending_blocks */
  2550. /* alloc space and pointers for key_blocks */
  2551. static SORT_KEY_BLOCKS *alloc_key_blocks(MI_CHECK *param, uint blocks,
  2552.                                          uint buffer_length)
  2553. {
  2554.   reg1 uint i;
  2555.   SORT_KEY_BLOCKS *block;
  2556.   DBUG_ENTER("alloc_key_blocks");
  2557.   if (!(block=(SORT_KEY_BLOCKS*) my_malloc((sizeof(SORT_KEY_BLOCKS)+
  2558.     buffer_length+IO_SIZE)*blocks,
  2559.    MYF(0))))
  2560.   {
  2561.     mi_check_print_error(param,"Not Enough memory for sort-key-blocks");
  2562.     return(0);
  2563.   }
  2564.   for (i=0 ; i < blocks ; i++)
  2565.   {
  2566.     block[i].inited=0;
  2567.     block[i].buff=(uchar*) (block+blocks)+(buffer_length+IO_SIZE)*i;
  2568.   }
  2569.   DBUG_RETURN(block);
  2570. } /* alloc_key_blocks */
  2571. /* Check if file is almost full */
  2572. int test_if_almost_full(MI_INFO *info)
  2573. {
  2574.   if (info->s->options & HA_OPTION_COMPRESS_RECORD)
  2575.     return 0;
  2576.   return (my_seek(info->s->kfile,0L,MY_SEEK_END,MYF(0))/10*9 >
  2577.   (my_off_t) (info->s->base.max_key_file_length) ||
  2578.   my_seek(info->dfile,0L,MY_SEEK_END,MYF(0))/10*9 >
  2579.   (my_off_t) info->s->base.max_data_file_length);
  2580. }
  2581. /* Recreate table with bigger more alloced record-data */
  2582. int recreate_table(MI_CHECK *param, MI_INFO **org_info, char *filename)
  2583. {
  2584.   int error;
  2585.   MI_INFO info;
  2586.   MYISAM_SHARE share;
  2587.   MI_KEYDEF *keyinfo,*key,*key_end;
  2588.   MI_KEYSEG *keysegs,*keyseg;
  2589.   MI_COLUMNDEF *recdef,*rec,*end;
  2590.   MI_UNIQUEDEF *uniquedef,*u_ptr,*u_end;
  2591.   MI_STATUS_INFO status_info;
  2592.   uint unpack,key_parts;
  2593.   ha_rows max_records;
  2594.   char name[FN_REFLEN];
  2595.   ulonglong file_length,tmp_length;
  2596.   MI_CREATE_INFO create_info;
  2597.   error=1; /* Default error */
  2598.   info= **org_info;
  2599.   status_info= (*org_info)->state[0];
  2600.   info.state= &status_info;
  2601.   share= *(*org_info)->s;
  2602.   unpack= (share.options & HA_OPTION_COMPRESS_RECORD) &&
  2603.     (param->testflag & T_UNPACK);
  2604.   if (!(keyinfo=(MI_KEYDEF*) my_alloca(sizeof(MI_KEYDEF)*share.base.keys)))
  2605.     return 0;
  2606.   memcpy((byte*) keyinfo,(byte*) share.keyinfo,
  2607.  (size_t) (sizeof(MI_KEYDEF)*share.base.keys));
  2608.   key_parts= share.base.all_key_parts;
  2609.   if (!(keysegs=(MI_KEYSEG*) my_alloca(sizeof(MI_KEYSEG)*
  2610.        (key_parts+share.base.keys))))
  2611.   {
  2612.     my_afree((gptr) keyinfo);
  2613.     return 1;
  2614.   }
  2615.   if (!(recdef=(MI_COLUMNDEF*)
  2616. my_alloca(sizeof(MI_COLUMNDEF)*(share.base.fields+1))))
  2617.   {
  2618.     my_afree((gptr) keyinfo);
  2619.     my_afree((gptr) keysegs);
  2620.     return 1;
  2621.   }
  2622.   if (!(uniquedef=(MI_UNIQUEDEF*)
  2623. my_alloca(sizeof(MI_UNIQUEDEF)*(share.state.header.uniques+1))))
  2624.   {
  2625.     my_afree((gptr) recdef);
  2626.     my_afree((gptr) keyinfo);
  2627.     my_afree((gptr) keysegs);
  2628.     return 1;
  2629.   }
  2630.   /* Copy the column definitions */
  2631.   memcpy((byte*) recdef,(byte*) share.rec,
  2632.  (size_t) (sizeof(MI_COLUMNDEF)*(share.base.fields+1)));
  2633.   for (rec=recdef,end=recdef+share.base.fields; rec != end ; rec++)
  2634.   {
  2635.     if (unpack && !(share.options & HA_OPTION_PACK_RECORD) &&
  2636. rec->type != FIELD_BLOB &&
  2637. rec->type != FIELD_VARCHAR &&
  2638. rec->type != FIELD_CHECK)
  2639.       rec->type=(int) FIELD_NORMAL;
  2640.   }
  2641.   /* Change the new key to point at the saved key segments */
  2642.   memcpy((byte*) keysegs,(byte*) share.keyparts,
  2643.  (size_t) (sizeof(MI_KEYSEG)*(key_parts+share.base.keys+
  2644.       share.state.header.uniques)));
  2645.   keyseg=keysegs;
  2646.   for (key=keyinfo,key_end=keyinfo+share.base.keys; key != key_end ; key++)
  2647.   {
  2648.     key->seg=keyseg;
  2649.     for (; keyseg->type ; keyseg++)
  2650.     {
  2651.       if (param->language)
  2652. keyseg->language=param->language; /* change language */
  2653.     }
  2654.     keyseg++; /* Skipp end pointer */
  2655.   }
  2656.   /* Copy the unique definitions and change them to point at the new key
  2657.      segments*/
  2658.   memcpy((byte*) uniquedef,(byte*) share.uniqueinfo,
  2659.  (size_t) (sizeof(MI_UNIQUEDEF)*(share.state.header.uniques)));
  2660.   for (u_ptr=uniquedef,u_end=uniquedef+share.state.header.uniques;
  2661.        u_ptr != u_end ; u_ptr++)
  2662.   {
  2663.     u_ptr->seg=keyseg;
  2664.     keyseg+=u_ptr->keysegs+1;
  2665.   }
  2666.   if (share.options & HA_OPTION_COMPRESS_RECORD)
  2667.     share.base.records=max_records=info.state->records;
  2668.   else if (share.base.min_pack_length)
  2669.     max_records=(ha_rows) (my_seek(info.dfile,0L,MY_SEEK_END,MYF(0)) /
  2670.    (ulong) share.base.min_pack_length);
  2671.   else
  2672.     max_records=0;
  2673.   unpack= (share.options & HA_OPTION_COMPRESS_RECORD) &&
  2674.     (param->testflag & T_UNPACK);
  2675.   share.options&= ~HA_OPTION_TEMP_COMPRESS_RECORD;
  2676.   file_length=(ulonglong) my_seek(info.dfile,0L,MY_SEEK_END,MYF(0));
  2677.   tmp_length= file_length+file_length/10;
  2678.   set_if_bigger(file_length,param->max_data_file_length);
  2679.   set_if_bigger(file_length,tmp_length);
  2680.   set_if_bigger(file_length,(ulonglong) share.base.max_data_file_length);
  2681.   VOID(mi_close(*org_info));
  2682.   bzero((char*) &create_info,sizeof(create_info));
  2683.   create_info.max_rows=max(max_records,share.base.records);
  2684.   create_info.reloc_rows=share.base.reloc;
  2685.   create_info.old_options=(share.options |
  2686.    (unpack ? HA_OPTION_TEMP_COMPRESS_RECORD : 0));
  2687.   create_info.data_file_length=file_length;
  2688.   create_info.auto_increment=share.state.auto_increment;
  2689.   create_info.raid_type=   share.base.raid_type;
  2690.   create_info.raid_chunks= share.base.raid_chunks;
  2691.   create_info.raid_chunksize= share.base.raid_chunksize;
  2692.   create_info.language = (param->language ? param->language :
  2693.   share.state.header.language);
  2694.   if (mi_create(fn_format(name,filename,"",MI_NAME_IEXT,
  2695.   4+ (param->opt_follow_links ? 16 : 0)),
  2696. share.base.keys - share.state.header.uniques,
  2697. keyinfo, share.base.fields, recdef,
  2698. share.state.header.uniques, uniquedef,
  2699. &create_info,
  2700. HA_DONT_TOUCH_DATA))
  2701.   {
  2702.     mi_check_print_error(param,"Got error %d when trying to recreate indexfile",my_errno);
  2703.     goto end;
  2704.   }
  2705.   *org_info=mi_open(name,O_RDWR,
  2706.     (param->testflag & T_WAIT_FOREVER) ? HA_OPEN_WAIT_IF_LOCKED :
  2707.     (param->testflag & T_DESCRIPT) ? HA_OPEN_IGNORE_IF_LOCKED :
  2708.     HA_OPEN_ABORT_IF_LOCKED);
  2709.   if (!*org_info)
  2710.   {
  2711.     mi_check_print_error(param,"Got error %d when trying to open re-created indexfile",
  2712. my_errno);
  2713.     goto end;
  2714.   }
  2715.   /* We are modifing */
  2716.   (*org_info)->s->options&= ~HA_OPTION_READ_ONLY_DATA;
  2717.   VOID(_mi_readinfo(*org_info,F_WRLCK,0));
  2718.   (*org_info)->state->records=info.state->records;
  2719.   if (share.state.create_time)
  2720.     (*org_info)->s->state.create_time=share.state.create_time;
  2721.   (*org_info)->s->state.unique=(*org_info)->this_unique=
  2722.     share.state.unique;
  2723.   (*org_info)->s->state.checksum=share.state.checksum;
  2724.   (*org_info)->state->del=info.state->del;
  2725.   (*org_info)->s->state.dellink=share.state.dellink;
  2726.   (*org_info)->state->empty=info.state->empty;
  2727.   (*org_info)->state->data_file_length=info.state->data_file_length;
  2728.   if (update_state_info(param,*org_info,UPDATE_TIME | UPDATE_STAT |
  2729. UPDATE_OPEN_COUNT))
  2730.     goto end;
  2731.   error=0;
  2732. end:
  2733.   my_afree((gptr) uniquedef);
  2734.   my_afree((gptr) keyinfo);
  2735.   my_afree((gptr) recdef);
  2736.   my_afree((gptr) keysegs);
  2737.   return error;
  2738. }
  2739. /* write suffix to data file if neaded */
  2740. int write_data_suffix(MI_CHECK *param, MI_INFO *info)
  2741. {
  2742.   if (info->s->options & HA_OPTION_COMPRESS_RECORD &&
  2743.       param->sort_info.fix_datafile)
  2744.   {
  2745.     char buff[MEMMAP_EXTRA_MARGIN];
  2746.     bzero(buff,sizeof(buff));
  2747.     if (my_b_write(&info->rec_cache,buff,sizeof(buff)))
  2748.     {
  2749.       mi_check_print_error(param,"%d when writing to datafile",my_errno);
  2750.       return 1;
  2751.     }
  2752.     param->read_cache.end_of_file+=sizeof(buff);
  2753.   }
  2754.   return 0;
  2755. }
  2756. /* Update state and myisamchk_time of indexfile */
  2757. int update_state_info(MI_CHECK *param, MI_INFO *info,uint update)
  2758. {
  2759.   MYISAM_SHARE *share=info->s;
  2760.   if (update & UPDATE_OPEN_COUNT)
  2761.   {
  2762.     share->state.open_count=0;
  2763.     share->global_changed=0;
  2764.   }
  2765.   if (update & UPDATE_STAT)
  2766.   {
  2767.     uint key_parts= mi_uint2korr(share->state.header.key_parts);
  2768.     share->state.rec_per_key_rows=info->state->records;
  2769.     memcpy((char*) share->state.rec_per_key_part,
  2770.    (char*) param->rec_per_key_part,
  2771.    sizeof(*param->rec_per_key_part)*key_parts);
  2772.     share->state.changed&= ~STATE_NOT_ANALYZED;
  2773.   }
  2774.   if (update & (UPDATE_STAT | UPDATE_SORT | UPDATE_TIME | UPDATE_AUTO_INC))
  2775.   {
  2776.     if (update & UPDATE_TIME)
  2777.     {
  2778.       share->state.check_time= (long) time((time_t*) 0);
  2779.       if (!share->state.create_time)
  2780. share->state.create_time=share->state.check_time;
  2781.     }
  2782.     if (mi_state_info_write(share->kfile,&share->state,1+2))
  2783.       goto err;
  2784.     share->changed=0;
  2785.   }
  2786.   { /* Force update of status */
  2787.     int error;
  2788.     uint r_locks=share->r_locks,w_locks=share->w_locks;
  2789.     share->r_locks=share->w_locks=0;
  2790.     error=_mi_writeinfo(info,WRITEINFO_NO_UNLOCK);
  2791.     share->r_locks=r_locks; share->w_locks=w_locks;
  2792.     if (!error)
  2793.       return 0;
  2794.   }
  2795. err:
  2796.   mi_check_print_error(param,"%d when updateing keyfile",my_errno);
  2797.   return 1;
  2798. }
  2799. /*
  2800.   Update auto increment value for a table
  2801.   When setting the 'repair_only' flag we only want to change the
  2802.   old auto_increment value if its wrong (smaller than some given key).
  2803.   The reason is that we shouldn't change the auto_increment value
  2804.   for a table without good reason when only doing a repair; If the
  2805.   user have inserted and deleted rows, the auto_increment value
  2806.   may be bigger than the biggest current row and this is ok.
  2807.   If repair_only is not set, we will update the flag to the value in
  2808.   param->auto_increment is bigger than the biggest key.
  2809. */
  2810. void update_auto_increment_key(MI_CHECK *param, MI_INFO *info,
  2811.        my_bool repair_only)
  2812. {
  2813.   if (!info->s->base.auto_key ||
  2814.       !(((ulonglong) 1 << (info->s->base.auto_key-1)
  2815.  & info->s->state.key_map)))
  2816.   {
  2817.     if (!(param->testflag & T_VERY_SILENT))
  2818.       mi_check_print_info(param,
  2819.   "Table: %s doesn't have an auto increment keyn",
  2820.   param->isam_file_name);
  2821.     return;
  2822.   }
  2823.   if (!(param->testflag & T_SILENT) &&
  2824.       !(param->testflag & (T_REP | T_REP_BY_SORT)))
  2825.     printf("Updating MyISAM file: %sn", param->isam_file_name);
  2826.   /* We have to use keyread here as a normal read uses info->rec_buff */
  2827.   mi_extra(info,HA_EXTRA_KEYREAD);
  2828.   if (mi_rlast(info,info->rec_buff, info->s->base.auto_key-1))
  2829.   {
  2830.     if (my_errno != HA_ERR_END_OF_FILE)
  2831.     {
  2832.       mi_extra(info,HA_EXTRA_NO_KEYREAD);
  2833.       mi_check_print_error(param,"%d when reading last record",my_errno);
  2834.       return;
  2835.     }
  2836.     if (!repair_only)
  2837.       info->s->state.auto_increment=param->auto_increment_value;
  2838.   }
  2839.   else
  2840.   {
  2841.     ulonglong auto_increment= (repair_only ? info->s->state.auto_increment :
  2842.        param->auto_increment_value);
  2843.     info->s->state.auto_increment=0;
  2844.     update_auto_increment(info,info->rec_buff);
  2845.     set_if_bigger(info->s->state.auto_increment,auto_increment);
  2846.   }
  2847.   mi_extra(info,HA_EXTRA_NO_KEYREAD);
  2848.   update_state_info(param, info, UPDATE_AUTO_INC);
  2849.   return;
  2850. }
  2851.     /* calculate unique keys for each part key */
  2852. static void update_key_parts(MI_KEYDEF *keyinfo,
  2853.      ulong *rec_per_key_part,
  2854.      ulonglong *unique,
  2855.      ulonglong records)
  2856. {
  2857.   ulonglong count=0,tmp;
  2858.   uint parts;
  2859.   for (parts=0 ; parts < keyinfo->keysegs  ; parts++)
  2860.   {
  2861.     count+=unique[parts];
  2862.     if (count == 0)
  2863.       tmp=records;
  2864.     else
  2865.       tmp= (records + (count+1)/2) / (count+1);
  2866.     if (tmp >= (ulonglong) ~(ulong) 0)
  2867.       tmp=(ulonglong) ~(ulong) 0;
  2868.     *rec_per_key_part=(ulong) tmp;
  2869.     rec_per_key_part++;
  2870.   }
  2871. }
  2872. ha_checksum mi_byte_checksum(const byte *buf, uint length)
  2873. {
  2874.   ha_checksum crc;
  2875.   const byte *end=buf+length;
  2876.   for (crc=0; buf != end; buf++)
  2877.     crc=((crc << 1) + *((uchar*) buf)) +
  2878.       test(crc & (((ha_checksum) 1) << (8*sizeof(ha_checksum)-1)));
  2879.   return crc;
  2880. }
  2881. /*
  2882.   Deactive all not unique index that can be recreated fast
  2883.   These include packed keys on which sorting will use more temporary
  2884.   space than the max allowed file length or for which the unpacked keys
  2885.   will take much more space than packed keys.
  2886.   Note that 'rows' may be zero for the case when we don't know how many
  2887.   rows we will put into the file.
  2888.  */
  2889. static my_bool mi_too_big_key_for_sort(MI_KEYDEF *key, ha_rows rows)
  2890. {
  2891.   return (key->flag & (HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY | HA_FULLTEXT) &&
  2892.   ((ulonglong) rows * key->maxlength >
  2893.    (ulonglong) myisam_max_temp_length ||
  2894.    (ulonglong) rows * (key->maxlength - key->minlength) / 2 >
  2895.    myisam_max_extra_temp_length ||
  2896.    (rows == 0 && (key->maxlength / key->minlength) > 2)));
  2897. }
  2898. void mi_disable_non_unique_index(MI_INFO *info, ha_rows rows)
  2899. {
  2900.   MYISAM_SHARE *share=info->s;
  2901.   uint i;
  2902.   if (!info->state->records) /* Don't do this if old rows */
  2903.   {
  2904.     MI_KEYDEF *key=share->keyinfo;
  2905.     for (i=0 ; i < share->base.keys ; i++,key++)
  2906.     {
  2907.       if (!(key->flag & HA_NOSAME) && ! mi_too_big_key_for_sort(key,rows) &&
  2908.   info->s->base.auto_key != i+1)
  2909.       {
  2910. share->state.key_map&= ~ ((ulonglong) 1 << i);
  2911. info->update|= HA_STATE_CHANGED;
  2912.       }
  2913.     }
  2914.   }
  2915. }
  2916. /*
  2917.   Return TRUE if we can use repair by sorting
  2918.   One can set the force argument to force to use sorting
  2919.   even if the temporary file would be quite big!
  2920. */
  2921. my_bool mi_test_if_sort_rep(MI_INFO *info, ha_rows rows, 
  2922.     my_bool force)
  2923. {
  2924.   MYISAM_SHARE *share=info->s;
  2925.   uint i;
  2926.   MI_KEYDEF *key=share->keyinfo;
  2927.   if (!share->state.key_map)
  2928.     return FALSE; /* Can't use sort */
  2929.   for (i=0 ; i < share->base.keys ; i++,key++)
  2930.   {
  2931. /* It's to disable repair_by_sort for ft-keys.
  2932.    Another solution would be to make ft-keys just too_big_key_for_sort,
  2933.    but then they won't be disabled by dectivate_non_unique_index
  2934.    and so they will be created at the first stage. As ft-key creation
  2935.    is very time-consuming process, it's better to leave it to repair stage
  2936.    but this repair shouldn't be repair_by_sort (serg)
  2937.  */
  2938.     if ((!force && mi_too_big_key_for_sort(key,rows)) ||
  2939. (key->flag & HA_FULLTEXT))
  2940.       return FALSE;
  2941.   }
  2942.   return TRUE;
  2943. }