← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_check.c

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_check.c
41
41
*/
42
42
 
43
43
#include "myisamdef.h"
44
 
#include <m_ctype.h>
45
44
#include <stdarg.h>
46
 
#include <my_getopt.h>
 
45
#include <mysys/my_getopt.h>
47
46
#ifdef HAVE_SYS_VADVISE_H
48
47
#include <sys/vadvise.h>
49
48
#endif
85
84
 
86
85
void myisamchk_init(MI_CHECK *param)
87
86
{
88
 
  bzero((uchar*) param,sizeof(*param));
 
87
  memset((uchar*) param, 0, sizeof(*param));
89
88
  param->opt_follow_links=1;
90
89
  param->keys_in_use= ~(uint64_t) 0;
91
90
  param->search_after_block=HA_OFFSET_ERROR;
441
440
 
442
441
    param->record_checksum=init_checksum;
443
442
    
444
 
    bzero((char*) &param->unique_count,sizeof(param->unique_count));
445
 
    bzero((char*) &param->notnull_count,sizeof(param->notnull_count));
 
443
    memset((char*) &param->unique_count, 0, sizeof(param->unique_count));
 
444
    memset((char*) &param->notnull_count, 0, sizeof(param->notnull_count));
446
445
 
447
446
    if ((!(param->testflag & T_SILENT)))
448
447
      printf ("- check data record references index: %d\n",key+1);
520
519
 
521
520
      /* Check that there isn't a row with auto_increment = 0 in the table */
522
521
      mi_extra(info,HA_EXTRA_KEYREAD,0);
523
 
      bzero(info->lastkey,keyinfo->seg->length);
 
522
      memset(info->lastkey, 0, keyinfo->seg->length);
524
523
      if (!mi_rkey(info, info->rec_buff, key, (const uchar*) info->lastkey,
525
524
                   (key_part_map)1, HA_READ_KEY_EXACT))
526
525
      {
925
924
  }
926
925
 
927
926
  pos=my_b_tell(&param->read_cache);
928
 
  bzero((char*) key_checksum, info->s->base.keys * sizeof(key_checksum[0]));
 
927
  memset((char*) key_checksum, 0, info->s->base.keys * sizeof(key_checksum[0]));
929
928
  while (pos < info->state->data_file_length)
930
929
  {
931
930
    if (*killed_ptr(param))
1451
1450
  SORT_INFO sort_info;
1452
1451
  MI_SORT_PARAM sort_param;
1453
1452
 
1454
 
  bzero((char *)&sort_info, sizeof(sort_info));
1455
 
  bzero((char *)&sort_param, sizeof(sort_param));
 
1453
  memset((char *)&sort_info, 0, sizeof(sort_info));
 
1454
  memset((char *)&sort_param, 0, sizeof(sort_param));
1456
1455
  start_records=info->state->records;
1457
1456
  new_header_length=(param->testflag & T_UNPACK) ? 0L :
1458
1457
    share->pack.header_length;
1478
1477
                    (uint) param->read_buffer_length,
1479
1478
                    READ_CACHE,share->pack.header_length,1,MYF(MY_WME)))
1480
1479
  {
1481
 
    bzero(&info->rec_cache,sizeof(info->rec_cache));
 
1480
    memset(&info->rec_cache, 0, sizeof(info->rec_cache));
1482
1481
    goto err;
1483
1482
  }
1484
1483
  if (!rep_quick)
1965
1964
 
1966
1965
  /* Fill block with zero and write it to the new index file */
1967
1966
  length=mi_getint(buff);
1968
 
  bzero((uchar*) buff+length,keyinfo->block_length-length);
 
1967
  memset((uchar*) buff+length, 0, keyinfo->block_length-length);
1969
1968
  if (my_pwrite(new_file,(uchar*) buff,(uint) keyinfo->block_length,
1970
1969
                new_page_pos,MYF(MY_NABP | MY_WAIT_IF_FULL)))
1971
1970
  {
2088
2087
  if (info->s->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))
2089
2088
    param->testflag|=T_CALC_CHECKSUM;
2090
2089
 
2091
 
  bzero((char*)&sort_info,sizeof(sort_info));
2092
 
  bzero((char *)&sort_param, sizeof(sort_param));
 
2090
  memset((char*)&sort_info, 0, sizeof(sort_info));
 
2091
  memset((char *)&sort_param, 0, sizeof(sort_param));
2093
2092
  if (!(sort_info.key_block=
2094
2093
        alloc_key_blocks(param,
2095
2094
                         (uint) param->sort_key_blocks,
2211
2210
      printf ("- Fixing index %d\n",sort_param.key+1);
2212
2211
    sort_param.max_pos=sort_param.pos=share->pack.header_length;
2213
2212
    keyseg=sort_param.seg;
2214
 
    bzero((char*) sort_param.unique,sizeof(sort_param.unique));
 
2213
    memset((char*) sort_param.unique, 0, sizeof(sort_param.unique));
2215
2214
    sort_param.key_length=share->rec_reflength;
2216
2215
    for (i=0 ; keyseg[i].type != HA_KEYTYPE_END; i++)
2217
2216
    {
2496
2495
      position 'new_header_length'.
2497
2496
    }
2498
2497
  */
2499
 
  bzero((char*)&sort_info,sizeof(sort_info));
 
2498
  memset((char*)&sort_info, 0, sizeof(sort_info));
2500
2499
  /* Initialize pthread structures before goto err. */
2501
2500
  pthread_mutex_init(&sort_info.mutex, MY_MUTEX_INIT_FAST);
2502
2501
  pthread_cond_init(&sort_info.cond, 0);
2920
2919
     _mi_make_key(info, sort_param->key, (uchar*) key,
2921
2920
                  sort_param->record, sort_param->filepos));
2922
2921
#ifdef HAVE_purify
2923
 
  bzero(key+sort_param->real_key_length,
2924
 
        (sort_param->key_length-sort_param->real_key_length));
 
2922
  memset(key+sort_param->real_key_length, 0,
 
2923
         (sort_param->key_length-sort_param->real_key_length));
2925
2924
#endif
2926
2925
  return(sort_write_record(sort_param));
2927
2926
} /* sort_key_read */
3625
3624
 
3626
3625
        /* Fill block with end-zero and write filled block */
3627
3626
  mi_putint(anc_buff,key_block->last_length,nod_flag);
3628
 
  bzero((uchar*) anc_buff+key_block->last_length,
3629
 
        keyinfo->block_length- key_block->last_length);
 
3627
  memset((uchar*) anc_buff+key_block->last_length, 0,
 
3628
         keyinfo->block_length- key_block->last_length);
3630
3629
  key_file_length=info->state->key_file_length;
3631
3630
  if ((filepos=_mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
3632
3631
    return(1);
3728
3727
    if (nod_flag)
3729
3728
      _mi_kpointer(info,key_block->end_pos,filepos);
3730
3729
    key_file_length=info->state->key_file_length;
3731
 
    bzero((uchar*) key_block->buff+length, keyinfo->block_length-length);
 
3730
    memset((uchar*) key_block->buff+length, 0, keyinfo->block_length-length);
3732
3731
    if ((filepos=_mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
3733
3732
      return(1);
3734
3733
 
3892
3891
  set_if_bigger(file_length,(uint64_t) share.base.max_data_file_length);
3893
3892
 
3894
3893
  VOID(mi_close(*org_info));
3895
 
  bzero((char*) &create_info,sizeof(create_info));
 
3894
  memset((char*) &create_info, 0, sizeof(create_info));
3896
3895
  create_info.max_rows=max(max_records,share.base.records);
3897
3896
  create_info.reloc_rows=share.base.reloc;
3898
3897
  create_info.old_options=(share.options |
3965
3964
  if (info->s->options & HA_OPTION_COMPRESS_RECORD && fix_datafile)
3966
3965
  {
3967
3966
    uchar buff[MEMMAP_EXTRA_MARGIN];
3968
 
    bzero(buff,sizeof(buff));
 
3967
    memset(buff, 0, sizeof(buff));
3969
3968
    if (my_b_write(&info->rec_cache,buff,sizeof(buff)))
3970
3969
    {
3971
3970
      mi_check_print_error(sort_info->param,