← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_check.c

  • Committer: Brian Aker
  • Date: 2009-01-07 09:27:07 UTC
  • Revision ID: brian@tangent.org-20090107092707-bn67qpdllfcyh3j9
Removing dead field translator code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_check.c
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/* Describe, check and repair of MyISAM tables */
17
17
 
40
40
  only. And it is sufficient to calculate the checksum once only.
41
41
*/
42
42
 
43
 
#include "myisam_priv.h"
44
 
#include "drizzled/internal/m_string.h"
 
43
#include "myisamdef.h"
 
44
#include <mystrings/m_string.h>
45
45
#include <stdarg.h>
 
46
#include <mysys/my_getopt.h>
46
47
#ifdef HAVE_SYS_VADVISE_H
47
48
#include <sys/vadvise.h>
48
49
#endif
53
54
#include <sys/mman.h>
54
55
#endif
55
56
#include <drizzled/util/test.h>
56
 
#include "drizzled/error.h"
57
 
 
58
 
#include <algorithm>
59
 
 
60
 
using namespace std;
61
 
using namespace drizzled;
62
 
using namespace drizzled::internal;
63
 
 
64
 
 
65
 
#define my_off_t2double(A)  ((double) (my_off_t) (A))
 
57
 
66
58
 
67
59
/* Functions defined in this file */
68
60
 
74
66
static ha_checksum calc_checksum(ha_rows count);
75
67
static int writekeys(MI_SORT_PARAM *sort_param);
76
68
static int sort_one_index(MI_CHECK *param, MI_INFO *info,MI_KEYDEF *keyinfo,
77
 
                          my_off_t pagepos, int new_file);
78
 
int sort_key_read(MI_SORT_PARAM *sort_param,void *key);
79
 
int sort_get_next_record(MI_SORT_PARAM *sort_param);
80
 
int sort_key_cmp(MI_SORT_PARAM *sort_param, const void *a,const void *b);
81
 
int sort_key_write(MI_SORT_PARAM *sort_param, const void *a);
82
 
my_off_t get_record_for_key(MI_INFO *info,MI_KEYDEF *keyinfo,
83
 
                            unsigned char *key);
84
 
int sort_insert_key(MI_SORT_PARAM  *sort_param,
85
 
                    register SORT_KEY_BLOCKS *key_block,
86
 
                    unsigned char *key, my_off_t prev_block);
87
 
int sort_delete_record(MI_SORT_PARAM *sort_param);
88
 
 
 
69
                          my_off_t pagepos, File new_file);
 
70
static int sort_key_read(MI_SORT_PARAM *sort_param,void *key);
 
71
static int sort_get_next_record(MI_SORT_PARAM *sort_param);
 
72
static int sort_key_cmp(MI_SORT_PARAM *sort_param, const void *a,const void *b);
 
73
static int sort_key_write(MI_SORT_PARAM *sort_param, const void *a);
 
74
static my_off_t get_record_for_key(MI_INFO *info,MI_KEYDEF *keyinfo,
 
75
                                unsigned char *key);
 
76
static int sort_insert_key(MI_SORT_PARAM  *sort_param,
 
77
                           register SORT_KEY_BLOCKS *key_block,
 
78
                           unsigned char *key, my_off_t prev_block);
 
79
static int sort_delete_record(MI_SORT_PARAM *sort_param);
89
80
/*static int flush_pending_blocks(MI_CHECK *param);*/
90
81
static SORT_KEY_BLOCKS  *alloc_key_blocks(MI_CHECK *param, uint32_t blocks,
91
82
                                          uint32_t buffer_length);
258
249
  unsigned char *buff;
259
250
 
260
251
  if (param->testflag & T_VERBOSE)
261
 
    printf("block_size %4u:", block_size);
 
252
    printf("block_size %4u:", block_size); /* purecov: tested */
262
253
 
263
254
  next_link=info->s->state.key_del[nr];
264
255
  records= (ha_rows) (info->state->key_file_length / block_size);
272
263
    /* Key blocks must lay within the key file length entirely. */
273
264
    if (next_link + block_size > info->state->key_file_length)
274
265
    {
 
266
      /* purecov: begin tested */
275
267
      mi_check_print_error(param, "Invalid key block position: %s  "
276
268
                           "key block size: %u  file_length: %s",
277
269
                           llstr(next_link, llbuff), block_size,
278
270
                           llstr(info->state->key_file_length, llbuff2));
279
271
      return(1);
 
272
      /* purecov: end */
280
273
    }
281
274
 
282
275
    /* Key blocks must be aligned at MI_MIN_KEY_BLOCK_LENGTH. */
283
276
    if (next_link & (MI_MIN_KEY_BLOCK_LENGTH - 1))
284
277
    {
 
278
      /* purecov: begin tested */
285
279
      mi_check_print_error(param, "Mis-aligned key block: %s  "
286
280
                           "minimum key block length: %u",
287
281
                           llstr(next_link, llbuff), MI_MIN_KEY_BLOCK_LENGTH);
288
282
      return(1);
 
283
      /* purecov: end */
289
284
    }
290
285
 
291
286
    /*
293
288
      If the key cache block size is smaller than block_size, we can so
294
289
      avoid unecessary eviction of cache block.
295
290
    */
296
 
    if (!(buff=key_cache_read(info->s->getKeyCache(),
 
291
    if (!(buff=key_cache_read(info->s->key_cache,
297
292
                              info->s->kfile, next_link, DFLT_INIT_HITS,
298
293
                              (unsigned char*) info->buff, MI_MIN_KEY_BLOCK_LENGTH,
299
294
                              MI_MIN_KEY_BLOCK_LENGTH, 1)))
300
295
    {
 
296
      /* purecov: begin tested */
301
297
      mi_check_print_error(param, "key cache read error for block: %s",
302
298
                           llstr(next_link,llbuff));
303
299
      return(1);
 
300
      /* purecov: end */
304
301
    }
305
302
    next_link=mi_sizekorr(buff);
306
303
    records--;
328
325
  if (!(param->testflag & T_SILENT)) puts("- check file-size");
329
326
 
330
327
  /* The following is needed if called externally (not from myisamchk) */
331
 
  flush_key_blocks(info->s->getKeyCache(),
 
328
  flush_key_blocks(info->s->key_cache,
332
329
                   info->s->kfile, FLUSH_FORCE_WRITE);
333
330
 
334
331
  size= lseek(info->s->kfile, 0, SEEK_END);
459
456
                  llstr(share->state.key_root[key],buff));
460
457
      if (!(param->testflag & T_INFO))
461
458
        return(-1);
462
 
      result= UINT32_MAX;
 
459
      result= -1;
463
460
      continue;
464
461
    }
465
462
    param->key_file_blocks+=keyinfo->block_length;
478
475
                    llstr(info->state->records,buff2));
479
476
        if (!(param->testflag & T_INFO))
480
477
        return(-1);
481
 
        result= UINT32_MAX;
 
478
        result= -1;
482
479
        continue;
483
480
      }
484
481
      if (found_keys - full_text_keys == 1 &&
495
492
          mi_check_print_error(param,"Key 1 doesn't point at all records");
496
493
        if (!(param->testflag & T_INFO))
497
494
          return(-1);
498
 
        result= UINT32_MAX;
 
495
        result= -1;
499
496
        continue;
500
497
      }
501
498
    }
585
582
  /* Key blocks must lay within the key file length entirely. */
586
583
  if (page + keyinfo->block_length > info->state->key_file_length)
587
584
  {
 
585
    /* purecov: begin tested */
588
586
    /* Give it a chance to fit in the real file size. */
589
587
    my_off_t max_length= lseek(info->s->kfile, 0, SEEK_END);
590
588
    mi_check_print_error(param, "Invalid key block position: %s  "
596
594
    /* Fix the remebered key file length. */
597
595
    info->state->key_file_length= (max_length &
598
596
                                   ~ (my_off_t) (keyinfo->block_length - 1));
 
597
    /* purecov: end */
599
598
  }
600
599
 
601
600
  /* Key blocks must be aligned at MI_MIN_KEY_BLOCK_LENGTH. */
602
601
  if (page & (MI_MIN_KEY_BLOCK_LENGTH - 1))
603
602
  {
 
603
    /* purecov: begin tested */
604
604
    mi_check_print_error(param, "Mis-aligned key block: %s  "
605
605
                         "minimum key block length: %u",
606
606
                         llstr(page, llbuff), MI_MIN_KEY_BLOCK_LENGTH);
607
607
    goto err;
 
608
    /* purecov: end */
608
609
  }
609
610
 
610
611
  if (!_mi_fetch_keypage(info,keyinfo,page, DFLT_INIT_HITS,buff,0))
619
620
 
620
621
  return(0);
621
622
 
 
623
  /* purecov: begin tested */
622
624
err:
623
625
  return(1);
 
626
  /* purecov: end */
624
627
}
625
628
 
626
629
 
894
897
      puts("- check record links");
895
898
  }
896
899
 
897
 
  if (!mi_alloc_rec_buff(info, SIZE_MAX, &record))
 
900
  if (!mi_alloc_rec_buff(info, -1, &record))
898
901
  {
899
902
    mi_check_print_error(param,"Not enough memory for record");
900
903
    return(-1);
1186
1189
  }
1187
1190
  else if (param->glob_crc != info->state->checksum &&
1188
1191
           (info->s->options &
1189
 
            (HA_OPTION_COMPRESS_RECORD)))
 
1192
            (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD)))
1190
1193
  {
1191
1194
    mi_check_print_warning(param,
1192
1195
                           "Record checksum is not the same as checksum stored in the index file\n");
1265
1268
  free(mi_get_rec_buff_ptr(info, record));
1266
1269
  return (error);
1267
1270
 err:
1268
 
  mi_check_print_error(param,"got error: %d when reading datafile at record: %s",errno, llstr(records,llbuff));
 
1271
  mi_check_print_error(param,"got error: %d when reading datafile at record: %s",my_errno, llstr(records,llbuff));
1269
1272
 err2:
1270
1273
  free(mi_get_rec_buff_ptr(info, record));
1271
1274
  param->testflag|=T_RETRY_WITHOUT_QUICK;
1313
1316
 
1314
1317
    However, there is an exception. Sometimes MySQL disables non-unique
1315
1318
    indexes when the table is empty (e.g. when copying a table in
1316
 
    drizzled::alter_table()). When enabling the non-unique indexes, they
 
1319
    mysql_alter_table()). When enabling the non-unique indexes, they
1317
1320
    are still empty. So there is no index block that can be lost. This
1318
1321
    optimization is implemented in this function.
1319
1322
 
1362
1365
        Flush dirty blocks of this index file from key cache and remove
1363
1366
        all blocks of this index file from key cache.
1364
1367
      */
1365
 
      error= flush_key_blocks(share->getKeyCache(), share->kfile,
 
1368
      error= flush_key_blocks(share->key_cache, share->kfile,
1366
1369
                              FLUSH_FORCE_WRITE);
1367
1370
      goto end;
1368
1371
    }
1375
1378
  }
1376
1379
 
1377
1380
  /* Remove all key blocks of this index file from key cache. */
1378
 
  if ((error= flush_key_blocks(share->getKeyCache(), share->kfile,
 
1381
  if ((error= flush_key_blocks(share->key_cache, share->kfile,
1379
1382
                               FLUSH_IGNORE_CHANGED)))
1380
 
    goto end;
 
1383
    goto end; /* purecov: inspected */
1381
1384
 
1382
1385
  /* Clear index root block pointers. */
1383
1386
  for (i= 0; i < share->base.keys; i++)
1406
1409
  int error,got_error;
1407
1410
  ha_rows start_records,new_header_length;
1408
1411
  my_off_t del;
1409
 
  int new_file;
 
1412
  File new_file;
1410
1413
  MYISAM_SHARE *share=info->s;
1411
1414
  char llbuff[22],llbuff2[22];
1412
1415
  SORT_INFO sort_info;
1428
1431
  }
1429
1432
  param->testflag|=T_REP; /* for easy checking */
1430
1433
 
1431
 
  if (info->s->options & (HA_OPTION_COMPRESS_RECORD))
 
1434
  if (info->s->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))
1432
1435
    param->testflag|=T_CALC_CHECKSUM;
1433
1436
 
1434
1437
  if (!param->using_global_keycache)
1435
 
    assert(0);
 
1438
    init_key_cache(dflt_key_cache, param->key_cache_block_size,
 
1439
                   param->use_buffers, 0, 0);
1436
1440
 
1437
 
  if (param->read_cache.init_io_cache(info->dfile, (uint) param->read_buffer_length, READ_CACHE,share->pack.header_length,1,MYF(MY_WME)))
 
1441
  if (init_io_cache(&param->read_cache,info->dfile,
 
1442
                    (uint) param->read_buffer_length,
 
1443
                    READ_CACHE,share->pack.header_length,1,MYF(MY_WME)))
1438
1444
  {
1439
1445
    memset(&info->rec_cache, 0, sizeof(info->rec_cache));
1440
1446
    goto err;
1441
1447
  }
1442
 
  if (not rep_quick)
1443
 
  {
1444
 
    if (info->rec_cache.init_io_cache(-1, (uint) param->write_buffer_length, WRITE_CACHE, new_header_length, 1, MYF(MY_WME | MY_WAIT_IF_FULL)))
1445
 
    {
 
1448
  if (!rep_quick)
 
1449
    if (init_io_cache(&info->rec_cache,-1,(uint) param->write_buffer_length,
 
1450
                      WRITE_CACHE, new_header_length, 1,
 
1451
                      MYF(MY_WME | MY_WAIT_IF_FULL)))
1446
1452
      goto err;
1447
 
    }
1448
 
  }
1449
1453
  info->opt_flag|=WRITE_CACHE_USED;
1450
 
  if (!mi_alloc_rec_buff(info, SIZE_MAX, &sort_param.record) ||
1451
 
      !mi_alloc_rec_buff(info, SIZE_MAX, &sort_param.rec_buff))
 
1454
  if (!mi_alloc_rec_buff(info, -1, &sort_param.record) ||
 
1455
      !mi_alloc_rec_buff(info, -1, &sort_param.rec_buff))
1452
1456
  {
1453
1457
    mi_check_print_error(param, "Not enough memory for extra record");
1454
1458
    goto err;
1457
1461
  if (!rep_quick)
1458
1462
  {
1459
1463
    /* Get real path for data file */
1460
 
    if ((new_file=my_create(internal::fn_format(param->temp_filename,
 
1464
    if ((new_file=my_create(fn_format(param->temp_filename,
1461
1465
                                      share->data_file_name, "",
1462
1466
                                      DATA_TMP_EXT, 2+4),
1463
1467
                            0,param->tmpfile_createflag,
1513
1517
  {
1514
1518
    if (writekeys(&sort_param))
1515
1519
    {
1516
 
      if (errno != HA_ERR_FOUND_DUPP_KEY)
 
1520
      if (my_errno != HA_ERR_FOUND_DUPP_KEY)
1517
1521
        goto err;
1518
1522
      mi_check_print_info(param,"Duplicate key %2d for record at %10s against new record at %10s",
1519
1523
                          info->errkey+1,
1548
1552
  {
1549
1553
    mi_check_print_warning(param,
1550
1554
                           "Can't change size of indexfile, error: %d",
1551
 
                           errno);
 
1555
                           my_errno);
1552
1556
    goto err;
1553
1557
  }
1554
1558
 
1574
1578
 
1575
1579
  if (!rep_quick)
1576
1580
  {
1577
 
    internal::my_close(info->dfile,MYF(0));
 
1581
    my_close(info->dfile,MYF(0));
1578
1582
    info->dfile=new_file;
1579
1583
    info->state->data_file_length=sort_param.filepos;
1580
1584
    share->state.version=(ulong) time((time_t*) 0);     /* Force reopen */
1607
1611
    /* Replace the actual file with the temporary file */
1608
1612
    if (new_file >= 0)
1609
1613
    {
1610
 
      internal::my_close(new_file,MYF(0));
 
1614
      my_close(new_file,MYF(0));
1611
1615
      info->dfile=new_file= -1;
1612
1616
      if (change_to_newfile(share->data_file_name,MI_NAME_DEXT,
1613
1617
                            DATA_TMP_EXT, share->base.raid_chunks,
1620
1624
  if (got_error)
1621
1625
  {
1622
1626
    if (! param->error_printed)
1623
 
      mi_check_print_error(param,"%d for record at pos %s",errno,
 
1627
      mi_check_print_error(param,"%d for record at pos %s",my_errno,
1624
1628
                  llstr(sort_param.start_recpos,llbuff));
1625
1629
    if (new_file >= 0)
1626
1630
    {
1627
 
      internal::my_close(new_file,MYF(0));
 
1631
      my_close(new_file,MYF(0));
1628
1632
      my_delete(param->temp_filename, MYF(MY_WME));
1629
1633
      info->rec_cache.file=-1; /* don't flush data to new_file, it's closed */
1630
1634
    }
1641
1645
  rec_buff_ptr= NULL;
1642
1646
 
1643
1647
  free(sort_info.buff);
1644
 
  param->read_cache.end_io_cache();
 
1648
  end_io_cache(&param->read_cache);
1645
1649
  info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
1646
 
  info->rec_cache.end_io_cache();
1647
 
  got_error|= flush_blocks(param, share->getKeyCache(), share->kfile);
1648
 
  if (not got_error && param->testflag & T_UNPACK)
 
1650
  end_io_cache(&info->rec_cache);
 
1651
  got_error|=flush_blocks(param, share->key_cache, share->kfile);
 
1652
  if (!got_error && param->testflag & T_UNPACK)
1649
1653
  {
1650
1654
    share->state.header.options[0]&= (unsigned char) ~HA_OPTION_COMPRESS_RECORD;
1651
1655
    share->pack.header_length=0;
1682
1686
  return(0);
1683
1687
 
1684
1688
 err:
1685
 
  if (errno == HA_ERR_FOUND_DUPP_KEY)
 
1689
  if (my_errno == HA_ERR_FOUND_DUPP_KEY)
1686
1690
  {
1687
1691
    info->errkey=(int) i;                       /* This key was found */
1688
1692
    while ( i-- > 0 )
1751
1755
 
1752
1756
        /* Tell system that we want all memory for our cache */
1753
1757
 
1754
 
void lock_memory(MI_CHECK *)
 
1758
void lock_memory(MI_CHECK *param __attribute__((unused)))
1755
1759
{
 
1760
#ifdef SUN_OS                           /* Key-cacheing thrases on sun 4.1 */
 
1761
  if (param->opt_lock_memory)
 
1762
  {
 
1763
    int success = mlockall(MCL_CURRENT);        /* or plock(DATLOCK); */
 
1764
    if (geteuid() == 0 && success != 0)
 
1765
      mi_check_print_warning(param,
 
1766
                             "Failed to lock memory. errno %d",my_errno);
 
1767
  }
 
1768
#endif
1756
1769
} /* lock_memory */
1757
1770
 
1758
1771
 
1759
1772
        /* Flush all changed blocks to disk */
1760
1773
 
1761
 
int flush_blocks(MI_CHECK *param, KEY_CACHE *key_cache, int file)
 
1774
int flush_blocks(MI_CHECK *param, KEY_CACHE *key_cache, File file)
1762
1775
{
1763
1776
  if (flush_key_blocks(key_cache, file, FLUSH_RELEASE))
1764
1777
  {
1765
 
    mi_check_print_error(param,"%d when trying to write bufferts",errno);
 
1778
    mi_check_print_error(param,"%d when trying to write bufferts",my_errno);
1766
1779
    return(1);
1767
1780
  }
1768
1781
  if (!param->using_global_keycache)
1777
1790
{
1778
1791
  register uint32_t key;
1779
1792
  register MI_KEYDEF *keyinfo;
1780
 
  int new_file;
 
1793
  File new_file;
1781
1794
  my_off_t index_pos[HA_MAX_POSSIBLE_KEY];
1782
1795
  uint32_t r_locks,w_locks;
1783
1796
  int old_lock;
1792
1805
    printf("- Sorting index for MyISAM-table '%s'\n",name);
1793
1806
 
1794
1807
  /* Get real path for index file */
1795
 
  internal::fn_format(param->temp_filename,name,"", MI_NAME_IEXT,2+4+32);
1796
 
  if ((new_file=my_create(internal::fn_format(param->temp_filename,param->temp_filename,
 
1808
  fn_format(param->temp_filename,name,"", MI_NAME_IEXT,2+4+32);
 
1809
  if ((new_file=my_create(fn_format(param->temp_filename,param->temp_filename,
1797
1810
                                    "", INDEX_TMP_EXT,2+4),
1798
1811
                          0,param->tmpfile_createflag,MYF(0))) <= 0)
1799
1812
  {
1824
1837
  }
1825
1838
 
1826
1839
  /* Flush key cache for this file if we are calling this outside myisamchk */
1827
 
  flush_key_blocks(share->getKeyCache(), share->kfile, FLUSH_IGNORE_CHANGED);
 
1840
  flush_key_blocks(share->key_cache,share->kfile, FLUSH_IGNORE_CHANGED);
1828
1841
 
1829
1842
  share->state.version=(ulong) time((time_t*) 0);
1830
1843
  old_state= share->state;                      /* save state if not stored */
1835
1848
        /* Put same locks as old file */
1836
1849
  share->r_locks= share->w_locks= share->tot_locks= 0;
1837
1850
  (void) _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
1838
 
  internal::my_close(share->kfile,MYF(MY_WME));
 
1851
  my_close(share->kfile,MYF(MY_WME));
1839
1852
  share->kfile = -1;
1840
 
  internal::my_close(new_file,MYF(MY_WME));
 
1853
  my_close(new_file,MYF(MY_WME));
1841
1854
  if (change_to_newfile(share->index_file_name,MI_NAME_IEXT,INDEX_TMP_EXT,0,
1842
1855
                        MYF(0)) ||
1843
1856
      mi_open_keyfile(share))
1861
1874
  return(0);
1862
1875
 
1863
1876
err:
1864
 
  internal::my_close(new_file,MYF(MY_WME));
 
1877
  my_close(new_file,MYF(MY_WME));
1865
1878
err2:
1866
1879
  my_delete(param->temp_filename,MYF(MY_WME));
1867
1880
  return(-1);
1871
1884
         /* Sort records recursive using one index */
1872
1885
 
1873
1886
static int sort_one_index(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
1874
 
                          my_off_t pagepos, int new_file)
 
1887
                          my_off_t pagepos, File new_file)
1875
1888
{
1876
1889
  uint32_t length,nod_flag,used_length, key_length;
1877
1890
  unsigned char *buff,*keypos,*endpos;
1922
1935
  if (my_pwrite(new_file,(unsigned char*) buff,(uint) keyinfo->block_length,
1923
1936
                new_page_pos,MYF(MY_NABP | MY_WAIT_IF_FULL)))
1924
1937
  {
1925
 
    mi_check_print_error(param,"Can't write indexblock, error: %d",errno);
 
1938
    mi_check_print_error(param,"Can't write indexblock, error: %d",my_errno);
1926
1939
    goto err;
1927
1940
  }
1928
1941
  free(buff);
1944
1957
 
1945
1958
int change_to_newfile(const char * filename, const char * old_ext,
1946
1959
                      const char * new_ext,
1947
 
                      uint32_t raid_chunks,
 
1960
                      uint32_t raid_chunks __attribute__((unused)),
1948
1961
                      myf MyFlags)
1949
1962
{
1950
 
  (void)raid_chunks;
1951
1963
  char old_filename[FN_REFLEN],new_filename[FN_REFLEN];
1952
1964
  /* Get real path to filename */
1953
 
  (void) internal::fn_format(old_filename,filename,"",old_ext,2+4+32);
 
1965
  (void) fn_format(old_filename,filename,"",old_ext,2+4+32);
1954
1966
  return my_redel(old_filename,
1955
 
                  internal::fn_format(new_filename,old_filename,"",new_ext,2+4),
 
1967
                  fn_format(new_filename,old_filename,"",new_ext,2+4),
1956
1968
                  MYF(MY_WME | MY_LINK_WARNING | MyFlags));
1957
1969
} /* change_to_newfile */
1958
1970
 
1960
1972
 
1961
1973
        /* Copy a block between two files */
1962
1974
 
1963
 
int filecopy(MI_CHECK *param, int to,int from,my_off_t start,
 
1975
int filecopy(MI_CHECK *param, File to,File from,my_off_t start,
1964
1976
             my_off_t length, const char *type)
1965
1977
{
1966
1978
  char tmp_buff[IO_SIZE],*buff;
1967
1979
  ulong buff_length;
1968
1980
 
1969
 
  buff_length=(ulong) min(param->write_buffer_length, (size_t)length);
1970
 
  if (!(buff=(char *)malloc(buff_length)))
 
1981
  buff_length=(ulong) cmin(param->write_buffer_length,length);
 
1982
  if (!(buff=malloc(buff_length)))
1971
1983
  {
1972
1984
    buff=tmp_buff; buff_length=IO_SIZE;
1973
1985
  }
1990
2002
  if (buff != tmp_buff)
1991
2003
    free(buff);
1992
2004
  mi_check_print_error(param,"Can't copy %s to tempfile, error %d",
1993
 
                       type,errno);
 
2005
                       type,my_errno);
1994
2006
  return(1);
1995
2007
}
1996
2008
 
2018
2030
  ulong length;
2019
2031
  ha_rows start_records;
2020
2032
  my_off_t new_header_length,del;
2021
 
  int new_file;
 
2033
  File new_file;
2022
2034
  MI_SORT_PARAM sort_param;
2023
2035
  MYISAM_SHARE *share=info->s;
2024
2036
  HA_KEYSEG *keyseg;
2039
2051
  }
2040
2052
  param->testflag|=T_REP; /* for easy checking */
2041
2053
 
2042
 
  if (info->s->options & (HA_OPTION_COMPRESS_RECORD))
 
2054
  if (info->s->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))
2043
2055
    param->testflag|=T_CALC_CHECKSUM;
2044
2056
 
2045
2057
  memset(&sort_info, 0, sizeof(sort_info));
2046
2058
  memset(&sort_param, 0, sizeof(sort_param));
2047
2059
  if (!(sort_info.key_block=
2048
 
        alloc_key_blocks(param, (uint) param->sort_key_blocks, share->base.max_key_block_length))
2049
 
      || param->read_cache.init_io_cache(info->dfile, (uint) param->read_buffer_length, READ_CACHE,share->pack.header_length,1,MYF(MY_WME))
2050
 
      || (! rep_quick && info->rec_cache.init_io_cache(info->dfile, (uint) param->write_buffer_length, WRITE_CACHE,new_header_length,1, MYF(MY_WME | MY_WAIT_IF_FULL) & param->myf_rw)))
2051
 
  {
 
2060
        alloc_key_blocks(param,
 
2061
                         (uint) param->sort_key_blocks,
 
2062
                         share->base.max_key_block_length))
 
2063
      || init_io_cache(&param->read_cache,info->dfile,
 
2064
                       (uint) param->read_buffer_length,
 
2065
                       READ_CACHE,share->pack.header_length,1,MYF(MY_WME)) ||
 
2066
      (! rep_quick &&
 
2067
       init_io_cache(&info->rec_cache,info->dfile,
 
2068
                     (uint) param->write_buffer_length,
 
2069
                     WRITE_CACHE,new_header_length,1,
 
2070
                     MYF(MY_WME | MY_WAIT_IF_FULL) & param->myf_rw)))
2052
2071
    goto err;
2053
 
  }
2054
2072
  sort_info.key_block_end=sort_info.key_block+param->sort_key_blocks;
2055
2073
  info->opt_flag|=WRITE_CACHE_USED;
2056
2074
  info->rec_cache.file=info->dfile;             /* for sort_delete_record */
2057
2075
 
2058
 
  if (!mi_alloc_rec_buff(info, SIZE_MAX, &sort_param.record) ||
2059
 
      !mi_alloc_rec_buff(info, SIZE_MAX, &sort_param.rec_buff))
 
2076
  if (!mi_alloc_rec_buff(info, -1, &sort_param.record) ||
 
2077
      !mi_alloc_rec_buff(info, -1, &sort_param.rec_buff))
2060
2078
  {
2061
2079
    mi_check_print_error(param, "Not enough memory for extra record");
2062
2080
    goto err;
2064
2082
  if (!rep_quick)
2065
2083
  {
2066
2084
    /* Get real path for data file */
2067
 
    if ((new_file=my_create(internal::fn_format(param->temp_filename,
 
2085
    if ((new_file=my_create(fn_format(param->temp_filename,
2068
2086
                                      share->data_file_name, "",
2069
2087
                                      DATA_TMP_EXT, 2+4),
2070
2088
                            0,param->tmpfile_createflag,
2111
2129
  sort_param.wordlist=NULL;
2112
2130
 
2113
2131
  if (share->data_file_type == DYNAMIC_RECORD)
2114
 
    length=max(share->base.min_pack_length+1,share->base.min_block_length);
 
2132
    length=cmax(share->base.min_pack_length+1,share->base.min_block_length);
2115
2133
  else if (share->data_file_type == COMPRESSED_RECORD)
2116
2134
    length=share->base.min_block_length;
2117
2135
  else
2185
2203
    }
2186
2204
    /* No need to calculate checksum again. */
2187
2205
    sort_param.calc_checksum= 0;
2188
 
    sort_param.wordroot.free_root(MYF(0));
 
2206
    free_root(&sort_param.wordroot, MYF(0));
2189
2207
 
2190
2208
    /* Set for next loop */
2191
2209
    sort_info.max_records= (ha_rows) info->state->records;
2201
2219
    if (sort_param.fix_datafile)
2202
2220
    {
2203
2221
      param->read_cache.end_of_file=sort_param.filepos;
2204
 
      if (write_data_suffix(&sort_info, 1) || info->rec_cache.end_io_cache())
2205
 
      {
 
2222
      if (write_data_suffix(&sort_info,1) || end_io_cache(&info->rec_cache))
2206
2223
        goto err;
2207
 
      }
2208
2224
      if (param->testflag & T_SAFE_REPAIR)
2209
2225
      {
2210
2226
        /* Don't repair if we loosed more than one row */
2218
2234
        sort_param.filepos;
2219
2235
      /* Only whole records */
2220
2236
      share->state.version=(ulong) time((time_t*) 0);
2221
 
      internal::my_close(info->dfile,MYF(0));
 
2237
      my_close(info->dfile,MYF(0));
2222
2238
      info->dfile=new_file;
2223
2239
      share->data_file_type=sort_info.new_data_file_type;
2224
2240
      share->pack.header_length=(ulong) new_header_length;
2228
2244
      info->state->data_file_length=sort_param.max_pos;
2229
2245
 
2230
2246
    param->read_cache.file=info->dfile;         /* re-init read cache */
2231
 
    param->read_cache.reinit_io_cache(READ_CACHE,share->pack.header_length, 1,1);
 
2247
    reinit_io_cache(&param->read_cache,READ_CACHE,share->pack.header_length,
 
2248
                    1,1);
2232
2249
  }
2233
2250
 
2234
2251
  if (param->testflag & T_WRITE_LOOP)
2260
2277
      if (ftruncate(info->dfile, skr))
2261
2278
        mi_check_print_warning(param,
2262
2279
                               "Can't change size of datafile,  error: %d",
2263
 
                               errno);
 
2280
                               my_errno);
2264
2281
  }
2265
2282
  if (param->testflag & T_CALC_CHECKSUM)
2266
2283
    info->state->checksum=param->glob_crc;
2268
2285
  if (ftruncate(share->kfile, info->state->key_file_length))
2269
2286
    mi_check_print_warning(param,
2270
2287
                           "Can't change size of indexfile, error: %d",
2271
 
                           errno);
 
2288
                           my_errno);
2272
2289
 
2273
2290
  if (!(param->testflag & T_SILENT))
2274
2291
  {
2285
2302
    memcpy( &share->state.state, info->state, sizeof(*info->state));
2286
2303
 
2287
2304
err:
2288
 
  got_error|= flush_blocks(param, share->getKeyCache(), share->kfile);
2289
 
  info->rec_cache.end_io_cache();
 
2305
  got_error|= flush_blocks(param, share->key_cache, share->kfile);
 
2306
  end_io_cache(&info->rec_cache);
2290
2307
  if (!got_error)
2291
2308
  {
2292
2309
    /* Replace the actual file with the temporary file */
2293
2310
    if (new_file >= 0)
2294
2311
    {
2295
 
      internal::my_close(new_file,MYF(0));
 
2312
      my_close(new_file,MYF(0));
2296
2313
      info->dfile=new_file= -1;
2297
2314
      if (change_to_newfile(share->data_file_name,MI_NAME_DEXT,
2298
2315
                            DATA_TMP_EXT, share->base.raid_chunks,
2305
2322
  if (got_error)
2306
2323
  {
2307
2324
    if (! param->error_printed)
2308
 
      mi_check_print_error(param,"%d when fixing table",errno);
 
2325
      mi_check_print_error(param,"%d when fixing table",my_errno);
2309
2326
    if (new_file >= 0)
2310
2327
    {
2311
 
      internal::my_close(new_file,MYF(0));
 
2328
      my_close(new_file,MYF(0));
2312
2329
      my_delete(param->temp_filename, MYF(MY_WME));
2313
2330
      if (info->dfile == new_file)
2314
2331
        info->dfile= -1;
2330
2347
 
2331
2348
  free((unsigned char*) sort_info.key_block);
2332
2349
  free(sort_info.buff);
2333
 
  param->read_cache.end_io_cache();
 
2350
  end_io_cache(&param->read_cache);
 
2351
  info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
 
2352
  if (!got_error && (param->testflag & T_UNPACK))
 
2353
  {
 
2354
    share->state.header.options[0]&= (unsigned char) ~HA_OPTION_COMPRESS_RECORD;
 
2355
    share->pack.header_length=0;
 
2356
  }
 
2357
  return(got_error);
 
2358
}
 
2359
 
 
2360
/*
 
2361
  Threaded repair of table using sorting
 
2362
 
 
2363
  SYNOPSIS
 
2364
    mi_repair_parallel()
 
2365
    param               Repair parameters
 
2366
    info                MyISAM handler to repair
 
2367
    name                Name of table (for warnings)
 
2368
    rep_quick           set to <> 0 if we should not change data file
 
2369
 
 
2370
  DESCRIPTION
 
2371
    Same as mi_repair_by_sort but do it multithreaded
 
2372
    Each key is handled by a separate thread.
 
2373
    TODO: make a number of threads a parameter
 
2374
 
 
2375
    In parallel repair we use one thread per index. There are two modes:
 
2376
 
 
2377
    Quick
 
2378
 
 
2379
      Only the indexes are rebuilt. All threads share a read buffer.
 
2380
      Every thread that needs fresh data in the buffer enters the shared
 
2381
      cache lock. The last thread joining the lock reads the buffer from
 
2382
      the data file and wakes all other threads.
 
2383
 
 
2384
    Non-quick
 
2385
 
 
2386
      The data file is rebuilt and all indexes are rebuilt to point to
 
2387
      the new record positions. One thread is the master thread. It
 
2388
      reads from the old data file and writes to the new data file. It
 
2389
      also creates one of the indexes. The other threads read from a
 
2390
      buffer which is filled by the master. If they need fresh data,
 
2391
      they enter the shared cache lock. If the masters write buffer is
 
2392
      full, it flushes it to the new data file and enters the shared
 
2393
      cache lock too. When all threads joined in the lock, the master
 
2394
      copies its write buffer to the read buffer for the other threads
 
2395
      and wakes them.
 
2396
 
 
2397
  RESULT
 
2398
    0   ok
 
2399
    <>0 Error
 
2400
*/
 
2401
 
 
2402
int mi_repair_parallel(MI_CHECK *param, register MI_INFO *info,
 
2403
                        const char * name, int rep_quick)
 
2404
{
 
2405
  int got_error;
 
2406
  uint32_t i,key, total_key_length, istep;
 
2407
  ulong rec_length;
 
2408
  ha_rows start_records;
 
2409
  my_off_t new_header_length,del;
 
2410
  File new_file;
 
2411
  MI_SORT_PARAM *sort_param=0;
 
2412
  MYISAM_SHARE *share=info->s;
 
2413
  ulong   *rec_per_key_part;
 
2414
  HA_KEYSEG *keyseg;
 
2415
  char llbuff[22];
 
2416
  IO_CACHE new_data_cache; /* For non-quick repair. */
 
2417
  IO_CACHE_SHARE io_share;
 
2418
  SORT_INFO sort_info;
 
2419
  uint64_t key_map= 0;
 
2420
  pthread_attr_t thr_attr;
 
2421
  ulong max_pack_reclength;
 
2422
 
 
2423
  start_records=info->state->records;
 
2424
  got_error=1;
 
2425
  new_file= -1;
 
2426
  new_header_length=(param->testflag & T_UNPACK) ? 0 :
 
2427
    share->pack.header_length;
 
2428
  if (!(param->testflag & T_SILENT))
 
2429
  {
 
2430
    printf("- parallel recovering (with sort) MyISAM-table '%s'\n",name);
 
2431
    printf("Data records: %s\n", llstr(start_records,llbuff));
 
2432
  }
 
2433
  param->testflag|=T_REP; /* for easy checking */
 
2434
 
 
2435
  if (info->s->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))
 
2436
    param->testflag|=T_CALC_CHECKSUM;
 
2437
 
 
2438
  /*
 
2439
    Quick repair (not touching data file, rebuilding indexes):
 
2440
    {
 
2441
      Read  cache is (MI_CHECK *param)->read_cache using info->dfile.
 
2442
    }
 
2443
 
 
2444
    Non-quick repair (rebuilding data file and indexes):
 
2445
    {
 
2446
      Master thread:
 
2447
 
 
2448
        Read  cache is (MI_CHECK *param)->read_cache using info->dfile.
 
2449
        Write cache is (MI_INFO   *info)->rec_cache  using new_file.
 
2450
 
 
2451
      Slave threads:
 
2452
 
 
2453
        Read  cache is new_data_cache synced to master rec_cache.
 
2454
 
 
2455
      The final assignment of the filedescriptor for rec_cache is done
 
2456
      after the cache creation.
 
2457
 
 
2458
      Don't check file size on new_data_cache, as the resulting file size
 
2459
      is not known yet.
 
2460
 
 
2461
      As rec_cache and new_data_cache are synced, write_buffer_length is
 
2462
      used for the read cache 'new_data_cache'. Both start at the same
 
2463
      position 'new_header_length'.
 
2464
    }
 
2465
  */
 
2466
  memset(&sort_info, 0, sizeof(sort_info));
 
2467
  /* Initialize pthread structures before goto err. */
 
2468
  pthread_mutex_init(&sort_info.mutex, MY_MUTEX_INIT_FAST);
 
2469
  pthread_cond_init(&sort_info.cond, 0);
 
2470
 
 
2471
  if (!(sort_info.key_block=
 
2472
        alloc_key_blocks(param, (uint) param->sort_key_blocks,
 
2473
                         share->base.max_key_block_length)) ||
 
2474
      init_io_cache(&param->read_cache, info->dfile,
 
2475
                    (uint) param->read_buffer_length,
 
2476
                    READ_CACHE, share->pack.header_length, 1, MYF(MY_WME)) ||
 
2477
      (!rep_quick &&
 
2478
       (init_io_cache(&info->rec_cache, info->dfile,
 
2479
                      (uint) param->write_buffer_length,
 
2480
                      WRITE_CACHE, new_header_length, 1,
 
2481
                      MYF(MY_WME | MY_WAIT_IF_FULL) & param->myf_rw) ||
 
2482
        init_io_cache(&new_data_cache, -1,
 
2483
                      (uint) param->write_buffer_length,
 
2484
                      READ_CACHE, new_header_length, 1,
 
2485
                      MYF(MY_WME | MY_DONT_CHECK_FILESIZE)))))
 
2486
    goto err;
 
2487
  sort_info.key_block_end=sort_info.key_block+param->sort_key_blocks;
 
2488
  info->opt_flag|=WRITE_CACHE_USED;
 
2489
  info->rec_cache.file=info->dfile;         /* for sort_delete_record */
 
2490
 
 
2491
  if (!rep_quick)
 
2492
  {
 
2493
    /* Get real path for data file */
 
2494
    if ((new_file=my_create(fn_format(param->temp_filename,
 
2495
                                      share->data_file_name, "",
 
2496
                                      DATA_TMP_EXT,
 
2497
                                      2+4),
 
2498
                            0,param->tmpfile_createflag,
 
2499
                            MYF(0))) < 0)
 
2500
    {
 
2501
      mi_check_print_error(param,"Can't create new tempfile: '%s'",
 
2502
                           param->temp_filename);
 
2503
      goto err;
 
2504
    }
 
2505
    if (new_header_length &&
 
2506
        filecopy(param, new_file,info->dfile,0L,new_header_length,
 
2507
                 "datafile-header"))
 
2508
      goto err;
 
2509
    if (param->testflag & T_UNPACK)
 
2510
    {
 
2511
      share->options&= ~HA_OPTION_COMPRESS_RECORD;
 
2512
      mi_int2store(share->state.header.options,share->options);
 
2513
    }
 
2514
    share->state.dellink= HA_OFFSET_ERROR;
 
2515
    info->rec_cache.file=new_file;
 
2516
  }
 
2517
 
 
2518
  info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
 
2519
 
 
2520
  /* Optionally drop indexes and optionally modify the key_map. */
 
2521
  mi_drop_all_indexes(param, info, false);
 
2522
  key_map= share->state.key_map;
 
2523
  if (param->testflag & T_CREATE_MISSING_KEYS)
 
2524
  {
 
2525
    /* Invert the copied key_map to recreate all disabled indexes. */
 
2526
    key_map= ~key_map;
 
2527
  }
 
2528
 
 
2529
  sort_info.info=info;
 
2530
  sort_info.param = param;
 
2531
 
 
2532
  set_data_file_type(&sort_info, share);
 
2533
  sort_info.dupp=0;
 
2534
  sort_info.buff=0;
 
2535
  param->read_cache.end_of_file=sort_info.filelength=
 
2536
    lseek(param->read_cache.file,0L,SEEK_END);
 
2537
 
 
2538
  if (share->data_file_type == DYNAMIC_RECORD)
 
2539
    rec_length=cmax(share->base.min_pack_length+1,share->base.min_block_length);
 
2540
  else if (share->data_file_type == COMPRESSED_RECORD)
 
2541
    rec_length=share->base.min_block_length;
 
2542
  else
 
2543
    rec_length=share->base.pack_reclength;
 
2544
  /*
 
2545
    +1 below is required hack for parallel repair mode.
 
2546
    The info->state->records value, that is compared later
 
2547
    to sort_info.max_records and cannot exceed it, is
 
2548
    increased in sort_key_write. In mi_repair_by_sort, sort_key_write
 
2549
    is called after sort_key_read, where the comparison is performed,
 
2550
    but in parallel mode master thread can call sort_key_write
 
2551
    before some other repair thread calls sort_key_read.
 
2552
    Furthermore I'm not even sure +1 would be enough.
 
2553
    May be sort_info.max_records shold be always set to max value in
 
2554
    parallel mode.
 
2555
  */
 
2556
  sort_info.max_records=
 
2557
    ((param->testflag & T_CREATE_MISSING_KEYS) ? info->state->records + 1:
 
2558
     (ha_rows) (sort_info.filelength/rec_length+1));
 
2559
 
 
2560
  del=info->state->del;
 
2561
  param->glob_crc=0;
 
2562
  /* for compressed tables */
 
2563
  max_pack_reclength= share->base.pack_reclength;
 
2564
  if (share->options & HA_OPTION_COMPRESS_RECORD)
 
2565
    set_if_bigger(max_pack_reclength, share->max_pack_length);
 
2566
  if (!(sort_param=(MI_SORT_PARAM *)
 
2567
        malloc(share->base.keys *
 
2568
               (sizeof(MI_SORT_PARAM) + max_pack_reclength))))
 
2569
  {
 
2570
    mi_check_print_error(param,"Not enough memory for key!");
 
2571
    goto err;
 
2572
  }
 
2573
  memset(sort_param, 0, share->base.keys *
 
2574
                        (sizeof(MI_SORT_PARAM) + max_pack_reclength));
 
2575
  total_key_length=0;
 
2576
  rec_per_key_part= param->rec_per_key_part;
 
2577
  info->state->records=info->state->del=share->state.split=0;
 
2578
  info->state->empty=0;
 
2579
 
 
2580
  for (i=key=0, istep=1 ; key < share->base.keys ;
 
2581
       rec_per_key_part+=sort_param[i].keyinfo->keysegs, i+=istep, key++)
 
2582
  {
 
2583
    sort_param[i].key=key;
 
2584
    sort_param[i].keyinfo=share->keyinfo+key;
 
2585
    sort_param[i].seg=sort_param[i].keyinfo->seg;
 
2586
    /*
 
2587
      Skip this index if it is marked disabled in the copied
 
2588
      (and possibly inverted) key_map.
 
2589
    */
 
2590
    if (! mi_is_key_active(key_map, key))
 
2591
    {
 
2592
      /* Remember old statistics for key */
 
2593
      assert(rec_per_key_part >= param->rec_per_key_part);
 
2594
      memcpy(rec_per_key_part,
 
2595
             (share->state.rec_per_key_part +
 
2596
              (rec_per_key_part - param->rec_per_key_part)),
 
2597
             sort_param[i].keyinfo->keysegs*sizeof(*rec_per_key_part));
 
2598
      istep=0;
 
2599
      continue;
 
2600
    }
 
2601
    istep=1;
 
2602
    if ((!(param->testflag & T_SILENT)))
 
2603
      printf ("- Fixing index %d\n",key+1);
 
2604
    {
 
2605
      sort_param[i].key_read=sort_key_read;
 
2606
      sort_param[i].key_write=sort_key_write;
 
2607
    }
 
2608
    sort_param[i].key_cmp=sort_key_cmp;
 
2609
    sort_param[i].lock_in_memory=lock_memory;
 
2610
    sort_param[i].sort_info=&sort_info;
 
2611
    sort_param[i].master=0;
 
2612
    sort_param[i].fix_datafile=0;
 
2613
    sort_param[i].calc_checksum= 0;
 
2614
 
 
2615
    sort_param[i].filepos=new_header_length;
 
2616
    sort_param[i].max_pos=sort_param[i].pos=share->pack.header_length;
 
2617
 
 
2618
    sort_param[i].record= (((unsigned char *)(sort_param+share->base.keys))+
 
2619
                           (max_pack_reclength * i));
 
2620
    if (!mi_alloc_rec_buff(info, -1, &sort_param[i].rec_buff))
 
2621
    {
 
2622
      mi_check_print_error(param,"Not enough memory!");
 
2623
      goto err;
 
2624
    }
 
2625
 
 
2626
    sort_param[i].key_length=share->rec_reflength;
 
2627
    for (keyseg=sort_param[i].seg; keyseg->type != HA_KEYTYPE_END;
 
2628
         keyseg++)
 
2629
    {
 
2630
      sort_param[i].key_length+=keyseg->length;
 
2631
      if (keyseg->flag & HA_SPACE_PACK)
 
2632
        sort_param[i].key_length+=get_pack_length(keyseg->length);
 
2633
      if (keyseg->flag & (HA_BLOB_PART | HA_VAR_LENGTH_PART))
 
2634
        sort_param[i].key_length+=2 + test(keyseg->length >= 127);
 
2635
      if (keyseg->flag & HA_NULL_PART)
 
2636
        sort_param[i].key_length++;
 
2637
    }
 
2638
    total_key_length+=sort_param[i].key_length;
 
2639
  }
 
2640
  sort_info.total_keys=i;
 
2641
  sort_param[0].master= 1;
 
2642
  sort_param[0].fix_datafile= (bool)(! rep_quick);
 
2643
  sort_param[0].calc_checksum= test(param->testflag & T_CALC_CHECKSUM);
 
2644
 
 
2645
  sort_info.got_error=0;
 
2646
  pthread_mutex_lock(&sort_info.mutex);
 
2647
 
 
2648
  /*
 
2649
    Initialize the I/O cache share for use with the read caches and, in
 
2650
    case of non-quick repair, the write cache. When all threads join on
 
2651
    the cache lock, the writer copies the write cache contents to the
 
2652
    read caches.
 
2653
  */
 
2654
  if (i > 1)
 
2655
  {
 
2656
    if (rep_quick)
 
2657
      init_io_cache_share(&param->read_cache, &io_share, NULL, i);
 
2658
    else
 
2659
      init_io_cache_share(&new_data_cache, &io_share, &info->rec_cache, i);
 
2660
  }
 
2661
  else
 
2662
    io_share.total_threads= 0; /* share not used */
 
2663
 
 
2664
  (void) pthread_attr_init(&thr_attr);
 
2665
  (void) pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
 
2666
 
 
2667
  for (i=0 ; i < sort_info.total_keys ; i++)
 
2668
  {
 
2669
    /*
 
2670
      Copy the properly initialized IO_CACHE structure so that every
 
2671
      thread has its own copy. In quick mode param->read_cache is shared
 
2672
      for use by all threads. In non-quick mode all threads but the
 
2673
      first copy the shared new_data_cache, which is synchronized to the
 
2674
      write cache of the first thread. The first thread copies
 
2675
      param->read_cache, which is not shared.
 
2676
    */
 
2677
    sort_param[i].read_cache= ((rep_quick || !i) ? param->read_cache :
 
2678
                               new_data_cache);
 
2679
 
 
2680
    /*
 
2681
      two approaches: the same amount of memory for each thread
 
2682
      or the memory for the same number of keys for each thread...
 
2683
      In the second one all the threads will fill their sort_buffers
 
2684
      (and call write_keys) at the same time, putting more stress on i/o.
 
2685
    */
 
2686
    sort_param[i].sortbuff_size=
 
2687
#ifndef USING_SECOND_APPROACH
 
2688
      param->sort_buffer_length/sort_info.total_keys;
 
2689
#else
 
2690
      param->sort_buffer_length*sort_param[i].key_length/total_key_length;
 
2691
#endif
 
2692
    if (pthread_create(&sort_param[i].thr, &thr_attr,
 
2693
                       thr_find_all_keys,
 
2694
                       (void *) (sort_param+i)))
 
2695
    {
 
2696
      mi_check_print_error(param,"Cannot start a repair thread");
 
2697
      /* Cleanup: Detach from the share. Avoid others to be blocked. */
 
2698
      if (io_share.total_threads)
 
2699
        remove_io_thread(&sort_param[i].read_cache);
 
2700
      sort_info.got_error=1;
 
2701
    }
 
2702
    else
 
2703
      sort_info.threads_running++;
 
2704
  }
 
2705
  (void) pthread_attr_destroy(&thr_attr);
 
2706
 
 
2707
  /* waiting for all threads to finish */
 
2708
  while (sort_info.threads_running)
 
2709
    pthread_cond_wait(&sort_info.cond, &sort_info.mutex);
 
2710
  pthread_mutex_unlock(&sort_info.mutex);
 
2711
 
 
2712
  if ((got_error= thr_write_keys(sort_param)))
 
2713
  {
 
2714
    param->retry_repair=1;
 
2715
    goto err;
 
2716
  }
 
2717
  got_error=1;                          /* Assume the following may go wrong */
 
2718
 
 
2719
  if (sort_param[0].fix_datafile)
 
2720
  {
 
2721
    /*
 
2722
      Append some nuls to the end of a memory mapped file. Destroy the
 
2723
      write cache. The master thread did already detach from the share
 
2724
      by remove_io_thread() in sort.c:thr_find_all_keys().
 
2725
    */
 
2726
    if (write_data_suffix(&sort_info,1) || end_io_cache(&info->rec_cache))
 
2727
      goto err;
 
2728
    if (param->testflag & T_SAFE_REPAIR)
 
2729
    {
 
2730
      /* Don't repair if we loosed more than one row */
 
2731
      if (info->state->records+1 < start_records)
 
2732
      {
 
2733
        info->state->records=start_records;
 
2734
        goto err;
 
2735
      }
 
2736
    }
 
2737
    share->state.state.data_file_length= info->state->data_file_length=
 
2738
      sort_param->filepos;
 
2739
    /* Only whole records */
 
2740
    share->state.version=(ulong) time((time_t*) 0);
 
2741
 
 
2742
    /*
 
2743
      Exchange the data file descriptor of the table, so that we use the
 
2744
      new file from now on.
 
2745
     */
 
2746
    my_close(info->dfile,MYF(0));
 
2747
    info->dfile=new_file;
 
2748
 
 
2749
    share->data_file_type=sort_info.new_data_file_type;
 
2750
    share->pack.header_length=(ulong) new_header_length;
 
2751
  }
 
2752
  else
 
2753
    info->state->data_file_length=sort_param->max_pos;
 
2754
 
 
2755
  if (rep_quick && del+sort_info.dupp != info->state->del)
 
2756
  {
 
2757
    mi_check_print_error(param,"Couldn't fix table with quick recovery: Found wrong number of deleted records");
 
2758
    mi_check_print_error(param,"Run recovery again without -q");
 
2759
    param->retry_repair=1;
 
2760
    param->testflag|=T_RETRY_WITHOUT_QUICK;
 
2761
    goto err;
 
2762
  }
 
2763
 
 
2764
  if (rep_quick & T_FORCE_UNIQUENESS)
 
2765
  {
 
2766
    my_off_t skr=info->state->data_file_length+
 
2767
      (share->options & HA_OPTION_COMPRESS_RECORD ?
 
2768
       MEMMAP_EXTRA_MARGIN : 0);
 
2769
#ifdef USE_RELOC
 
2770
    if (share->data_file_type == STATIC_RECORD &&
 
2771
        skr < share->base.reloc*share->base.min_pack_length)
 
2772
      skr=share->base.reloc*share->base.min_pack_length;
 
2773
#endif
 
2774
    if (skr != sort_info.filelength && !info->s->base.raid_type)
 
2775
      if (ftruncate(info->dfile, skr))
 
2776
        mi_check_print_warning(param,
 
2777
                               "Can't change size of datafile,  error: %d",
 
2778
                               my_errno);
 
2779
  }
 
2780
  if (param->testflag & T_CALC_CHECKSUM)
 
2781
    info->state->checksum=param->glob_crc;
 
2782
 
 
2783
  if (ftruncate(share->kfile, info->state->key_file_length))
 
2784
    mi_check_print_warning(param,
 
2785
                           "Can't change size of indexfile, error: %d", my_errno);
 
2786
 
 
2787
  if (!(param->testflag & T_SILENT))
 
2788
  {
 
2789
    if (start_records != info->state->records)
 
2790
      printf("Data records: %s\n", llstr(info->state->records,llbuff));
 
2791
    if (sort_info.dupp)
 
2792
      mi_check_print_warning(param,
 
2793
                             "%s records have been removed",
 
2794
                             llstr(sort_info.dupp,llbuff));
 
2795
  }
 
2796
  got_error=0;
 
2797
 
 
2798
  if (&share->state.state != info->state)
 
2799
    memcpy(&share->state.state, info->state, sizeof(*info->state));
 
2800
 
 
2801
err:
 
2802
  got_error|= flush_blocks(param, share->key_cache, share->kfile);
 
2803
  /*
 
2804
    Destroy the write cache. The master thread did already detach from
 
2805
    the share by remove_io_thread() or it was not yet started (if the
 
2806
    error happend before creating the thread).
 
2807
  */
 
2808
  end_io_cache(&info->rec_cache);
 
2809
  /*
 
2810
    Destroy the new data cache in case of non-quick repair. All slave
 
2811
    threads did either detach from the share by remove_io_thread()
 
2812
    already or they were not yet started (if the error happend before
 
2813
    creating the threads).
 
2814
  */
 
2815
  if (!rep_quick)
 
2816
    end_io_cache(&new_data_cache);
 
2817
  if (!got_error)
 
2818
  {
 
2819
    /* Replace the actual file with the temporary file */
 
2820
    if (new_file >= 0)
 
2821
    {
 
2822
      my_close(new_file,MYF(0));
 
2823
      info->dfile=new_file= -1;
 
2824
      if (change_to_newfile(share->data_file_name,MI_NAME_DEXT,
 
2825
                            DATA_TMP_EXT, share->base.raid_chunks,
 
2826
                            (param->testflag & T_BACKUP_DATA ?
 
2827
                             MYF(MY_REDEL_MAKE_BACKUP): MYF(0))) ||
 
2828
          mi_open_datafile(info,share,-1))
 
2829
        got_error=1;
 
2830
    }
 
2831
  }
 
2832
  if (got_error)
 
2833
  {
 
2834
    if (! param->error_printed)
 
2835
      mi_check_print_error(param,"%d when fixing table",my_errno);
 
2836
    if (new_file >= 0)
 
2837
    {
 
2838
      my_close(new_file,MYF(0));
 
2839
      my_delete(param->temp_filename, MYF(MY_WME));
 
2840
      if (info->dfile == new_file)
 
2841
        info->dfile= -1;
 
2842
    }
 
2843
    mi_mark_crashed_on_repair(info);
 
2844
  }
 
2845
  else if (key_map == share->state.key_map)
 
2846
    share->state.changed&= ~STATE_NOT_OPTIMIZED_KEYS;
 
2847
  share->state.changed|=STATE_NOT_SORTED_PAGES;
 
2848
 
 
2849
  pthread_cond_destroy (&sort_info.cond);
 
2850
  pthread_mutex_destroy(&sort_info.mutex);
 
2851
 
 
2852
  free((unsigned char*) sort_info.key_block);
 
2853
  free((unsigned char*) sort_param);
 
2854
  free(sort_info.buff);
 
2855
  end_io_cache(&param->read_cache);
2334
2856
  info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
2335
2857
  if (!got_error && (param->testflag & T_UNPACK))
2336
2858
  {
2342
2864
 
2343
2865
        /* Read next record and return next key */
2344
2866
 
2345
 
int sort_key_read(MI_SORT_PARAM *sort_param, void *key)
 
2867
static int sort_key_read(MI_SORT_PARAM *sort_param, void *key)
2346
2868
{
2347
2869
  int error;
2348
2870
  SORT_INFO *sort_info=sort_param->sort_info;
2361
2883
    (info->s->rec_reflength+
2362
2884
     _mi_make_key(info, sort_param->key, (unsigned char*) key,
2363
2885
                  sort_param->record, sort_param->filepos));
2364
 
#ifdef HAVE_VALGRIND
2365
 
  memset((unsigned char *)key+sort_param->real_key_length, 0,
 
2886
#ifdef HAVE_purify
 
2887
  memset(key+sort_param->real_key_length, 0,
2366
2888
         (sort_param->key_length-sort_param->real_key_length));
2367
2889
#endif
2368
2890
  return(sort_write_record(sort_param));
2400
2922
    > 0         error
2401
2923
*/
2402
2924
 
2403
 
int sort_get_next_record(MI_SORT_PARAM *sort_param)
 
2925
static int sort_get_next_record(MI_SORT_PARAM *sort_param)
2404
2926
{
2405
2927
  int searching;
2406
2928
  int parallel_flag;
2690
3212
        {
2691
3213
          mi_check_print_info(param,
2692
3214
                              "Read error for block at: %s (error: %d); Skipped",
2693
 
                              llstr(block_info.filepos,llbuff),errno);
 
3215
                              llstr(block_info.filepos,llbuff),my_errno);
2694
3216
          goto try_next;
2695
3217
        }
2696
3218
        left_length-=block_info.data_len;
2783
3305
      if (my_b_write(&info->rec_cache,sort_param->record,
2784
3306
                     share->base.pack_reclength))
2785
3307
      {
2786
 
        mi_check_print_error(param,"%d when writing to datafile",errno);
 
3308
        mi_check_print_error(param,"%d when writing to datafile",my_errno);
2787
3309
        return(1);
2788
3310
      }
2789
3311
      sort_param->filepos+=share->base.pack_reclength;
2807
3329
          if(tmpptr)
2808
3330
          {
2809
3331
            sort_info->buff_length=reclength;
2810
 
            sort_info->buff= (unsigned char *)tmpptr;
 
3332
            sort_info->buff= tmpptr;
2811
3333
          }
2812
3334
          else
2813
3335
          {
2837
3359
                                  sort_param->filepos+block_length,
2838
3360
                                  &from,&reclength,&flag))
2839
3361
        {
2840
 
          mi_check_print_error(param,"%d when writing to datafile",errno);
 
3362
          mi_check_print_error(param,"%d when writing to datafile",my_errno);
2841
3363
          return(1);
2842
3364
        }
2843
3365
        sort_param->filepos+=block_length;
2867
3389
 
2868
3390
        /* Compare two keys from _create_index_by_sort */
2869
3391
 
2870
 
int sort_key_cmp(MI_SORT_PARAM *sort_param, const void *a, const void *b)
 
3392
static int sort_key_cmp(MI_SORT_PARAM *sort_param, const void *a,
 
3393
                        const void *b)
2871
3394
{
2872
3395
  uint32_t not_used[2];
2873
3396
  return (ha_key_cmp(sort_param->seg, *((unsigned char* const *) a), *((unsigned char* const *) b),
2875
3398
} /* sort_key_cmp */
2876
3399
 
2877
3400
 
2878
 
int sort_key_write(MI_SORT_PARAM *sort_param, const void *a)
 
3401
static int sort_key_write(MI_SORT_PARAM *sort_param, const void *a)
2879
3402
{
2880
3403
  uint32_t diff_pos[2];
2881
3404
  char llbuff[22],llbuff2[22];
2932
3455
 
2933
3456
        /* get pointer to record from a key */
2934
3457
 
2935
 
my_off_t get_record_for_key(MI_INFO *info, MI_KEYDEF *keyinfo,
2936
 
                            unsigned char *key) {
 
3458
static my_off_t get_record_for_key(MI_INFO *info, MI_KEYDEF *keyinfo,
 
3459
                                   unsigned char *key)
 
3460
{
2937
3461
  return _mi_dpos(info,0,key+_mi_keylength(keyinfo,key));
2938
3462
} /* get_record_for_key */
2939
3463
 
2940
3464
 
2941
3465
        /* Insert a key in sort-key-blocks */
2942
3466
 
2943
 
int sort_insert_key(MI_SORT_PARAM *sort_param,
2944
 
                    register SORT_KEY_BLOCKS *key_block, unsigned char *key,
2945
 
                    my_off_t prev_block)
 
3467
static int sort_insert_key(MI_SORT_PARAM *sort_param,
 
3468
                           register SORT_KEY_BLOCKS *key_block, unsigned char *key,
 
3469
                           my_off_t prev_block)
2946
3470
{
2947
3471
  uint32_t a_length,t_length,nod_flag;
2948
3472
  my_off_t filepos,key_file_length;
3022
3546
 
3023
3547
        /* Delete record when we found a duplicated key */
3024
3548
 
3025
 
int sort_delete_record(MI_SORT_PARAM *sort_param)
 
3549
static int sort_delete_record(MI_SORT_PARAM *sort_param)
3026
3550
{
3027
3551
  uint32_t i;
3028
3552
  int old_file,error;
3152
3676
         (my_off_t) info->s->base.max_data_file_length;
3153
3677
}
3154
3678
 
 
3679
        /* Recreate table with bigger more alloced record-data */
 
3680
 
 
3681
int recreate_table(MI_CHECK *param, MI_INFO **org_info, char *filename)
 
3682
{
 
3683
  int error;
 
3684
  MI_INFO info;
 
3685
  MYISAM_SHARE share;
 
3686
  MI_KEYDEF *keyinfo,*key,*key_end;
 
3687
  HA_KEYSEG *keysegs,*keyseg;
 
3688
  MI_COLUMNDEF *recdef,*rec,*end;
 
3689
  MI_UNIQUEDEF *uniquedef,*u_ptr,*u_end;
 
3690
  MI_STATUS_INFO status_info;
 
3691
  uint32_t unpack,key_parts;
 
3692
  ha_rows max_records;
 
3693
  uint64_t file_length,tmp_length;
 
3694
  MI_CREATE_INFO create_info;
 
3695
 
 
3696
  error=1;                                      /* Default error */
 
3697
  info= **org_info;
 
3698
  status_info= (*org_info)->state[0];
 
3699
  info.state= &status_info;
 
3700
  share= *(*org_info)->s;
 
3701
  unpack= (share.options & HA_OPTION_COMPRESS_RECORD) &&
 
3702
    (param->testflag & T_UNPACK);
 
3703
  if (!(keyinfo=(MI_KEYDEF*) malloc(sizeof(MI_KEYDEF)*share.base.keys)))
 
3704
    return(0);
 
3705
  memcpy(keyinfo,share.keyinfo,sizeof(MI_KEYDEF)*share.base.keys);
 
3706
 
 
3707
  key_parts= share.base.all_key_parts;
 
3708
  if (!(keysegs=(HA_KEYSEG*) malloc(sizeof(HA_KEYSEG)*
 
3709
                                    (key_parts+share.base.keys))))
 
3710
  {
 
3711
    free(keyinfo);
 
3712
    return(1);
 
3713
  }
 
3714
  if (!(recdef=(MI_COLUMNDEF*)
 
3715
        malloc(sizeof(MI_COLUMNDEF)*(share.base.fields+1))))
 
3716
  {
 
3717
    free(keyinfo);
 
3718
    free(keysegs);
 
3719
    return(1);
 
3720
  }
 
3721
  if (!(uniquedef=(MI_UNIQUEDEF*)
 
3722
        malloc(sizeof(MI_UNIQUEDEF)*(share.state.header.uniques+1))))
 
3723
  {
 
3724
    free(recdef);
 
3725
    free(keyinfo);
 
3726
    free(keysegs);
 
3727
    return(1);
 
3728
  }
 
3729
 
 
3730
  /* Copy the column definitions */
 
3731
  memcpy(recdef, share.rec, sizeof(MI_COLUMNDEF)*(share.base.fields+1));
 
3732
  for (rec=recdef,end=recdef+share.base.fields; rec != end ; rec++)
 
3733
  {
 
3734
    if (unpack && !(share.options & HA_OPTION_PACK_RECORD) &&
 
3735
        rec->type != FIELD_BLOB &&
 
3736
        rec->type != FIELD_VARCHAR &&
 
3737
        rec->type != FIELD_CHECK)
 
3738
      rec->type=(int) FIELD_NORMAL;
 
3739
  }
 
3740
 
 
3741
  /* Change the new key to point at the saved key segments */
 
3742
  memcpy(keysegs,share.keyparts,
 
3743
         sizeof(HA_KEYSEG)*(key_parts+share.base.keys+
 
3744
                            share.state.header.uniques));
 
3745
  keyseg=keysegs;
 
3746
  for (key=keyinfo,key_end=keyinfo+share.base.keys; key != key_end ; key++)
 
3747
  {
 
3748
    key->seg=keyseg;
 
3749
    for (; keyseg->type ; keyseg++)
 
3750
    {
 
3751
      if (param->language)
 
3752
        keyseg->language=param->language;       /* change language */
 
3753
    }
 
3754
    keyseg++;                                   /* Skip end pointer */
 
3755
  }
 
3756
 
 
3757
  /* Copy the unique definitions and change them to point at the new key
 
3758
     segments*/
 
3759
  memcpy(uniquedef,share.uniqueinfo,
 
3760
         sizeof(MI_UNIQUEDEF)*(share.state.header.uniques));
 
3761
  for (u_ptr=uniquedef,u_end=uniquedef+share.state.header.uniques;
 
3762
       u_ptr != u_end ; u_ptr++)
 
3763
  {
 
3764
    u_ptr->seg=keyseg;
 
3765
    keyseg+=u_ptr->keysegs+1;
 
3766
  }
 
3767
  if (share.options & HA_OPTION_COMPRESS_RECORD)
 
3768
    share.base.records=max_records=info.state->records;
 
3769
  else if (share.base.min_pack_length)
 
3770
    max_records=(ha_rows) (lseek(info.dfile,0L,SEEK_END) /
 
3771
                           (ulong) share.base.min_pack_length);
 
3772
  else
 
3773
    max_records=0;
 
3774
  unpack= (share.options & HA_OPTION_COMPRESS_RECORD) &&
 
3775
    (param->testflag & T_UNPACK);
 
3776
  share.options&= ~HA_OPTION_TEMP_COMPRESS_RECORD;
 
3777
 
 
3778
  file_length=(uint64_t) lseek(info.dfile,0L,SEEK_END);
 
3779
  tmp_length= file_length+file_length/10;
 
3780
  set_if_bigger(file_length,param->max_data_file_length);
 
3781
  set_if_bigger(file_length,tmp_length);
 
3782
  set_if_bigger(file_length,(uint64_t) share.base.max_data_file_length);
 
3783
 
 
3784
  mi_close(*org_info);
 
3785
  memset(&create_info, 0, sizeof(create_info));
 
3786
  create_info.max_rows=cmax(max_records,share.base.records);
 
3787
  create_info.reloc_rows=share.base.reloc;
 
3788
  create_info.old_options=(share.options |
 
3789
                           (unpack ? HA_OPTION_TEMP_COMPRESS_RECORD : 0));
 
3790
 
 
3791
  create_info.data_file_length=file_length;
 
3792
  create_info.auto_increment=share.state.auto_increment;
 
3793
  create_info.language = (param->language ? param->language :
 
3794
                          share.state.header.language);
 
3795
  create_info.key_file_length=  status_info.key_file_length;
 
3796
  /*
 
3797
    Allow for creating an auto_increment key. This has an effect only if
 
3798
    an auto_increment key exists in the original table.
 
3799
  */
 
3800
  create_info.with_auto_increment= true;
 
3801
  /* We don't have to handle symlinks here because we are using
 
3802
     HA_DONT_TOUCH_DATA */
 
3803
  if (mi_create(filename,
 
3804
                share.base.keys - share.state.header.uniques,
 
3805
                keyinfo, share.base.fields, recdef,
 
3806
                share.state.header.uniques, uniquedef,
 
3807
                &create_info,
 
3808
                HA_DONT_TOUCH_DATA))
 
3809
  {
 
3810
    mi_check_print_error(param,"Got error %d when trying to recreate indexfile",my_errno);
 
3811
    goto end;
 
3812
  }
 
3813
  *org_info=mi_open(filename,O_RDWR,
 
3814
                    (param->testflag & T_WAIT_FOREVER) ? HA_OPEN_WAIT_IF_LOCKED :
 
3815
                    (param->testflag & T_DESCRIPT) ? HA_OPEN_IGNORE_IF_LOCKED :
 
3816
                    HA_OPEN_ABORT_IF_LOCKED);
 
3817
  if (!*org_info)
 
3818
  {
 
3819
    mi_check_print_error(param,"Got error %d when trying to open re-created indexfile",
 
3820
                my_errno);
 
3821
    goto end;
 
3822
  }
 
3823
  /* We are modifing */
 
3824
  (*org_info)->s->options&= ~HA_OPTION_READ_ONLY_DATA;
 
3825
  _mi_readinfo(*org_info,F_WRLCK,0);
 
3826
  (*org_info)->state->records=info.state->records;
 
3827
  if (share.state.create_time)
 
3828
    (*org_info)->s->state.create_time=share.state.create_time;
 
3829
  (*org_info)->s->state.unique=(*org_info)->this_unique=
 
3830
    share.state.unique;
 
3831
  (*org_info)->state->checksum=info.state->checksum;
 
3832
  (*org_info)->state->del=info.state->del;
 
3833
  (*org_info)->s->state.dellink=share.state.dellink;
 
3834
  (*org_info)->state->empty=info.state->empty;
 
3835
  (*org_info)->state->data_file_length=info.state->data_file_length;
 
3836
  if (update_state_info(param,*org_info,UPDATE_TIME | UPDATE_STAT |
 
3837
                        UPDATE_OPEN_COUNT))
 
3838
    goto end;
 
3839
  error=0;
 
3840
end:
 
3841
  free(uniquedef);
 
3842
  free(keyinfo);
 
3843
  free(recdef);
 
3844
  free(keysegs);
 
3845
  return(error);
 
3846
}
 
3847
 
3155
3848
 
3156
3849
        /* write suffix to data file if neaded */
3157
3850
 
3166
3859
    if (my_b_write(&info->rec_cache,buff,sizeof(buff)))
3167
3860
    {
3168
3861
      mi_check_print_error(sort_info->param,
3169
 
                           "%d when writing to datafile",errno);
 
3862
                           "%d when writing to datafile",my_errno);
3170
3863
      return 1;
3171
3864
    }
3172
3865
    sort_info->param->read_cache.end_of_file+=sizeof(buff);
3231
3924
      return 0;
3232
3925
  }
3233
3926
err:
3234
 
  mi_check_print_error(param,"%d when updating keyfile",errno);
 
3927
  mi_check_print_error(param,"%d when updating keyfile",my_errno);
3235
3928
  return 1;
3236
3929
}
3237
3930
 
3269
3962
    We have to use an allocated buffer instead of info->rec_buff as
3270
3963
    _mi_put_key_in_record() may use info->rec_buff
3271
3964
  */
3272
 
  if (!mi_alloc_rec_buff(info, SIZE_MAX, &record))
 
3965
  if (!mi_alloc_rec_buff(info, -1, &record))
3273
3966
  {
3274
3967
    mi_check_print_error(param,"Not enough memory for extra record");
3275
3968
    return;
3278
3971
  mi_extra(info,HA_EXTRA_KEYREAD,0);
3279
3972
  if (mi_rlast(info, record, info->s->base.auto_key-1))
3280
3973
  {
3281
 
    if (errno != HA_ERR_END_OF_FILE)
 
3974
    if (my_errno != HA_ERR_END_OF_FILE)
3282
3975
    {
3283
3976
      mi_extra(info,HA_EXTRA_NO_KEYREAD,0);
3284
3977
      free(mi_get_rec_buff_ptr(info, record));
3285
 
      mi_check_print_error(param,"%d when reading last record",errno);
 
3978
      mi_check_print_error(param,"%d when reading last record",my_errno);
3286
3979
      return;
3287
3980
    }
3288
3981
    if (!repair_only)
3386
4079
      for some weird keys (e.g. FULLTEXT) tmp can be <1 here.
3387
4080
      let's ensure it is not
3388
4081
    */
3389
 
    if (tmp < 1)
3390
 
      tmp= 1;
 
4082
    set_if_bigger(tmp,1);
3391
4083
    if (tmp >= (uint64_t) ~(ulong) 0)
3392
4084
      tmp=(uint64_t) ~(ulong) 0;
3393
4085
 
3412
4104
  uint32_t key_maxlength=key->maxlength;
3413
4105
  return (key->flag & (HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY) &&
3414
4106
          ((uint64_t) rows * key_maxlength >
3415
 
           (uint64_t) MAX_FILE_SIZE));
 
4107
           (uint64_t) myisam_max_temp_length));
3416
4108
}
3417
4109
 
3418
4110
/*