← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_open.c

Removed/replaced DBUG symbols and standardized TRUE/FALSE

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_open.c
16
16
/* open a isam-database */
17
17
 
18
18
#include "myisamdef.h"
19
 
#include <mystrings/m_ctype.h>
 
19
#include <m_ctype.h>
20
20
 
21
21
static void setup_key_functions(MI_KEYDEF *keyinfo);
22
 
#define get_next_element(to,pos,size) \
23
 
  do {                                \
24
 
    memcpy(to, pos, size);            \
25
 
    pos+=size;                        \
26
 
  } while (0)
 
22
#define get_next_element(to,pos,size) { memcpy((char*) to,pos,(size_t) size); \
 
23
                                        pos+=size;}
27
24
 
28
25
 
29
26
#define disk_pos_assert(pos, end_pos) \
62
59
  have an open count of 0.
63
60
******************************************************************************/
64
61
 
65
 
MI_INFO *mi_open(const char *name, int mode, uint32_t open_flags)
 
62
MI_INFO *mi_open(const char *name, int mode, uint open_flags)
66
63
{
67
64
  int lock_error,kfile,open_mode,save_errno,have_rtree=0;
68
 
  uint32_t i,j,len,errpos,head_length,base_pos,offset,info_length,keys,
 
65
  uint i,j,len,errpos,head_length,base_pos,offset,info_length,keys,
69
66
    key_parts,unique_key_parts,fulltext_keys,uniques;
70
67
  char name_buff[FN_REFLEN], org_name[FN_REFLEN], index_name[FN_REFLEN],
71
68
       data_name[FN_REFLEN];
72
 
  unsigned char *disk_cache= NULL;
73
 
  unsigned char *disk_pos, *end_pos;
 
69
  uchar *disk_cache, *disk_pos, *end_pos;
74
70
  MI_INFO info,*m_info,*old_info;
75
71
  MYISAM_SHARE share_buff,*share;
76
72
  ulong rec_per_key_part[HA_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG];
77
73
  my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
78
 
  uint64_t max_key_file_length, max_data_file_length;
 
74
  ulonglong max_key_file_length, max_data_file_length;
 
75
  DBUG_ENTER("mi_open");
79
76
 
80
77
  kfile= -1;
81
78
  lock_error=1;
82
79
  errpos=0;
83
80
  head_length=sizeof(share_buff.state.header);
84
 
  memset(&info, 0, sizeof(info));
 
81
  bzero((uchar*) &info,sizeof(info));
85
82
 
86
83
  my_realpath(name_buff, fn_format(org_name,name,"",MI_NAME_IEXT,
87
84
                                   MY_UNPACK_FILENAME),MYF(0));
89
86
  if (!(old_info=test_if_reopen(name_buff)))
90
87
  {
91
88
    share= &share_buff;
92
 
    memset(&share_buff, 0, sizeof(share_buff));
 
89
    bzero((uchar*) &share_buff,sizeof(share_buff));
93
90
    share_buff.state.rec_per_key_part=rec_per_key_part;
94
91
    share_buff.state.key_root=key_root;
95
92
    share_buff.state.key_del=key_del;
96
 
    share_buff.key_cache= multi_key_cache_search((unsigned char*) name_buff,
 
93
    share_buff.key_cache= multi_key_cache_search((uchar*) name_buff,
97
94
                                                 strlen(name_buff));
98
95
 
 
96
    DBUG_EXECUTE_IF("myisam_pretend_crashed_table_on_open",
 
97
                    if (strstr(name, "/t1"))
 
98
                    {
 
99
                      my_errno= HA_ERR_CRASHED;
 
100
                      goto err;
 
101
                    });
99
102
    if ((kfile=my_open(name_buff,(open_mode=O_RDWR) | O_SHARE,MYF(0))) < 0)
100
103
    {
101
104
      if ((errno != EROFS && errno != EACCES) ||
111
114
      my_errno= HA_ERR_NOT_A_TABLE;
112
115
      goto err;
113
116
    }
114
 
    if (memcmp(share->state.header.file_version, myisam_file_magic, 4))
 
117
    if (memcmp((uchar*) share->state.header.file_version,
 
118
               (uchar*) myisam_file_magic, 4))
115
119
    {
 
120
      DBUG_PRINT("error",("Wrong header in %s",name_buff));
 
121
      DBUG_DUMP("error_dump",(uchar*) share->state.header.file_version,
 
122
                head_length);
116
123
      my_errno=HA_ERR_NOT_A_TABLE;
117
124
      goto err;
118
125
    }
124
131
          HA_OPTION_TMP_TABLE | HA_OPTION_DELAY_KEY_WRITE |
125
132
          HA_OPTION_RELIES_ON_SQL_LAYER))
126
133
    {
 
134
      DBUG_PRINT("error",("wrong options: 0x%lx", share->options));
127
135
      my_errno=HA_ERR_OLD_FILE;
128
136
      goto err;
129
137
    }
130
138
    if ((share->options & HA_OPTION_RELIES_ON_SQL_LAYER) &&
131
139
        ! (open_flags & HA_OPEN_FROM_SQL_LAYER))
132
140
    {
 
141
      DBUG_PRINT("error", ("table cannot be openned from non-sql layer"));
133
142
      my_errno= HA_ERR_UNSUPPORTED;
134
143
      goto err;
135
144
    }
136
145
    /* Don't call realpath() if the name can't be a link */
137
146
    if (!strcmp(name_buff, org_name) ||
138
147
        my_readlink(index_name, org_name, MYF(0)) == -1)
139
 
      (void) my_stpcpy(index_name, org_name);
 
148
      (void) strmov(index_name, org_name);
140
149
    *strrchr(org_name, '.')= '\0';
141
150
    (void) fn_format(data_name,org_name,"",MI_NAME_DEXT,
142
151
                     MY_APPEND_EXT|MY_UNPACK_FILENAME|MY_RESOLVE_SYMLINKS);
143
152
 
144
153
    info_length=mi_uint2korr(share->state.header.header_length);
145
154
    base_pos=mi_uint2korr(share->state.header.base_pos);
146
 
    if (!(disk_cache= (unsigned char*) malloc(info_length+128)))
 
155
    if (!(disk_cache= (uchar*) my_alloca(info_length+128)))
147
156
    {
148
157
      my_errno=ENOMEM;
149
158
      goto err;
151
160
    end_pos=disk_cache+info_length;
152
161
    errpos=2;
153
162
 
154
 
    my_seek(kfile,0L,MY_SEEK_SET,MYF(0));
 
163
    VOID(my_seek(kfile,0L,MY_SEEK_SET,MYF(0)));
 
164
    if (!(open_flags & HA_OPEN_TMP_TABLE))
 
165
    {
 
166
      if ((lock_error=my_lock(kfile,F_RDLCK,0L,F_TO_EOF,
 
167
                              MYF(open_flags & HA_OPEN_WAIT_IF_LOCKED ?
 
168
                                  0 : MY_DONT_WAIT))) &&
 
169
          !(open_flags & HA_OPEN_IGNORE_IF_LOCKED))
 
170
        goto err;
 
171
    }
155
172
    errpos=3;
156
173
    if (my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
157
174
    {
164
181
    fulltext_keys= (uint) share->state.header.fulltext_keys;
165
182
    key_parts= mi_uint2korr(share->state.header.key_parts);
166
183
    unique_key_parts= mi_uint2korr(share->state.header.unique_key_parts);
 
184
    if (len != MI_STATE_INFO_SIZE)
 
185
    {
 
186
      DBUG_PRINT("warning",
 
187
                 ("saved_state_info_length: %d  state_info_length: %d",
 
188
                  len,MI_STATE_INFO_SIZE));
 
189
    }
167
190
    share->state_diff_length=len-MI_STATE_INFO_SIZE;
168
191
 
169
192
    mi_state_info_read(disk_cache, &share->state);
170
193
    len= mi_uint2korr(share->state.header.base_info_length);
 
194
    if (len != MI_BASE_INFO_SIZE)
 
195
    {
 
196
      DBUG_PRINT("warning",("saved_base_info_length: %d  base_info_length: %d",
 
197
                            len,MI_BASE_INFO_SIZE));
 
198
    }
171
199
    disk_pos= my_n_base_info_read(disk_cache + base_pos, &share->base);
172
200
    share->state.state_length=base_pos;
173
201
 
174
202
    if (!(open_flags & HA_OPEN_FOR_REPAIR) &&
175
203
        ((share->state.changed & STATE_CRASHED) ||
176
204
         ((open_flags & HA_OPEN_ABORT_IF_CRASHED) &&
177
 
          (share->state.open_count))))
 
205
          (my_disable_locking && share->state.open_count))))
178
206
    {
 
207
      DBUG_PRINT("error",("Table is marked as crashed. open_flags: %u  "
 
208
                          "changed: %u  open_count: %u  !locking: %d",
 
209
                          open_flags, share->state.changed,
 
210
                          share->state.open_count, my_disable_locking));
179
211
      my_errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
180
212
                HA_ERR_CRASHED_ON_REPAIR : HA_ERR_CRASHED_ON_USAGE);
181
213
      goto err;
191
223
    if (share->base.max_key_length > MI_MAX_KEY_BUFF || keys > MI_MAX_KEY ||
192
224
        key_parts > MI_MAX_KEY * MI_MAX_KEY_SEG)
193
225
    {
 
226
      DBUG_PRINT("error",("Wrong key info:  Max_key_length: %d  keys: %d  key_parts: %d", share->base.max_key_length, keys, key_parts));
194
227
      my_errno=HA_ERR_UNSUPPORTED;
195
228
      goto err;
196
229
    }
198
231
    /* Correct max_file_length based on length of sizeof(off_t) */
199
232
    max_data_file_length=
200
233
      (share->options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ?
201
 
      (((uint64_t) 1 << (share->base.rec_reflength*8))-1) :
 
234
      (((ulonglong) 1 << (share->base.rec_reflength*8))-1) :
202
235
      (mi_safe_mul(share->base.pack_reclength,
203
 
                   (uint64_t) 1 << (share->base.rec_reflength*8))-1);
 
236
                   (ulonglong) 1 << (share->base.rec_reflength*8))-1);
204
237
    max_key_file_length=
205
238
      mi_safe_mul(MI_MIN_KEY_BLOCK_LENGTH,
206
 
                  ((uint64_t) 1 << (share->base.key_reflength*8))-1);
 
239
                  ((ulonglong) 1 << (share->base.key_reflength*8))-1);
207
240
#if SIZEOF_OFF_T == 4
208
241
    set_if_smaller(max_data_file_length, INT_MAX32);
209
242
    set_if_smaller(max_key_file_length, INT_MAX32);
210
243
#endif
211
244
    if (share->base.raid_type)
212
245
    {
 
246
      DBUG_PRINT("error",("Table uses RAID but we don't have RAID support"));
213
247
      my_errno=HA_ERR_UNSUPPORTED;
214
248
      goto err;
215
249
    }
241
275
                         (share->state.header.max_block_size_index*sizeof(my_off_t)),
242
276
                         &share->key_root_lock,sizeof(rw_lock_t)*keys,
243
277
                         &share->mmap_lock,sizeof(rw_lock_t),
244
 
                         NULL))
 
278
                         NullS))
245
279
      goto err;
246
280
    errpos=4;
247
281
    *share=share_buff;
248
 
    memcpy(share->state.rec_per_key_part, rec_per_key_part,
249
 
           sizeof(long)*key_parts);
250
 
    memcpy(share->state.key_root, key_root,
251
 
           sizeof(my_off_t)*keys);
252
 
    memcpy(share->state.key_del, key_del,
253
 
           sizeof(my_off_t) * share->state.header.max_block_size_index);
254
 
    my_stpcpy(share->unique_file_name, name_buff);
 
282
    memcpy((char*) share->state.rec_per_key_part,
 
283
           (char*) rec_per_key_part, sizeof(long)*key_parts);
 
284
    memcpy((char*) share->state.key_root,
 
285
           (char*) key_root, sizeof(my_off_t)*keys);
 
286
    memcpy((char*) share->state.key_del,
 
287
           (char*) key_del, (sizeof(my_off_t) *
 
288
                             share->state.header.max_block_size_index));
 
289
    strmov(share->unique_file_name, name_buff);
255
290
    share->unique_name_length= strlen(name_buff);
256
 
    my_stpcpy(share->index_file_name,  index_name);
257
 
    my_stpcpy(share->data_file_name,   data_name);
 
291
    strmov(share->index_file_name,  index_name);
 
292
    strmov(share->data_file_name,   data_name);
258
293
 
259
 
    share->blocksize=cmin(IO_SIZE,myisam_block_size);
 
294
    share->blocksize=min(IO_SIZE,myisam_block_size);
260
295
    {
261
296
      HA_KEYSEG *pos=share->keyparts;
262
297
      for (i=0 ; i < keys ; i++)
357
392
 
358
393
    if (! lock_error)
359
394
    {
 
395
      VOID(my_lock(kfile,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE)));
360
396
      lock_error=1;                     /* Database unlocked */
361
397
    }
362
398
 
375
411
    share->base.margin_key_file_length=(share->base.max_key_file_length -
376
412
                                        (keys ? MI_INDEX_BLOCK_MARGIN *
377
413
                                         share->blocksize * keys : 0));
378
 
    share->blocksize=cmin(IO_SIZE,myisam_block_size);
 
414
    share->blocksize=min(IO_SIZE,myisam_block_size);
379
415
    share->data_file_type=STATIC_RECORD;
380
 
    if (share->options & HA_OPTION_PACK_RECORD)
 
416
    if (share->options & HA_OPTION_COMPRESS_RECORD)
 
417
    {
 
418
      share->data_file_type = COMPRESSED_RECORD;
 
419
      share->options|= HA_OPTION_READ_ONLY_DATA;
 
420
      info.s=share;
 
421
      if (_mi_read_pack_info(&info,
 
422
                             (pbool)
 
423
                             test(!(share->options &
 
424
                                    (HA_OPTION_PACK_RECORD |
 
425
                                     HA_OPTION_TEMP_COMPRESS_RECORD)))))
 
426
        goto err;
 
427
    }
 
428
    else if (share->options & HA_OPTION_PACK_RECORD)
381
429
      share->data_file_type = DYNAMIC_RECORD;
382
 
    free(disk_cache);
383
 
    disk_cache= NULL;
 
430
    my_afree(disk_cache);
384
431
    mi_setup_functions(share);
385
 
    share->is_log_table= false;
 
432
    share->is_log_table= FALSE;
386
433
    thr_lock_init(&share->lock);
387
 
    pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST);
 
434
    VOID(pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST));
388
435
    for (i=0; i<keys; i++)
389
 
      my_rwlock_init(&share->key_root_lock[i], NULL);
390
 
    my_rwlock_init(&share->mmap_lock, NULL);
 
436
      VOID(my_rwlock_init(&share->key_root_lock[i], NULL));
 
437
    VOID(my_rwlock_init(&share->mmap_lock, NULL));
391
438
    if (!thr_lock_inited)
392
439
    {
393
440
      /* Probably a single threaded program; Don't use concurrent inserts */
402
449
         (open_flags & HA_OPEN_TMP_TABLE) || have_rtree) ? 0 : 1;
403
450
      if (share->concurrent_insert)
404
451
      {
405
 
        share->lock.get_status= mi_get_status;
406
 
        share->lock.copy_status= mi_copy_status;
407
 
        share->lock.update_status= mi_update_status;
 
452
        share->lock.get_status=mi_get_status;
 
453
        share->lock.copy_status=mi_copy_status;
 
454
        share->lock.update_status=mi_update_status;
408
455
        share->lock.restore_status= mi_restore_status;
409
 
        share->lock.check_status= mi_check_status;
 
456
        share->lock.check_status=mi_check_status;
410
457
      }
411
458
    }
412
459
    /*
442
489
                       &info.first_mbr_key, share->base.max_key_length,
443
490
                       &info.filename,strlen(name)+1,
444
491
                       &info.rtree_recursion_state,have_rtree ? 1024 : 0,
445
 
                       NULL))
 
492
                       NullS))
446
493
    goto err;
447
494
  errpos=6;
448
495
 
449
496
  if (!have_rtree)
450
497
    info.rtree_recursion_state= NULL;
451
498
 
452
 
  my_stpcpy(info.filename,name);
 
499
  strmov(info.filename,name);
453
500
  memcpy(info.blobs,share->blobs,sizeof(MI_BLOB)*share->base.blobs);
454
501
  info.lastkey2=info.lastkey+share->base.max_key_length;
455
502
 
498
545
 
499
546
  /* Allocate buffer for one record */
500
547
 
501
 
  /* prerequisites: memset(info, 0) && info->s=share; are met. */
 
548
  /* prerequisites: bzero(info) && info->s=share; are met. */
502
549
  if (!mi_alloc_rec_buff(&info, -1, &info.rec_buff))
503
550
    goto err;
504
 
  memset(info.rec_buff, 0, mi_get_rec_buff_len(&info, info.rec_buff));
 
551
  bzero(info.rec_buff, mi_get_rec_buff_len(&info, info.rec_buff));
505
552
 
506
553
  *m_info=info;
507
554
  thr_lock_data_init(&share->lock,&m_info->lock,(void*) m_info);
509
556
  myisam_open_list=list_add(myisam_open_list,&m_info->open_list);
510
557
 
511
558
  pthread_mutex_unlock(&THR_LOCK_myisam);
512
 
  return(m_info);
 
559
  if (myisam_log_file >= 0)
 
560
  {
 
561
    intern_filename(name_buff,share->index_file_name);
 
562
    _myisam_log(MI_LOG_OPEN, m_info, (uchar*) name_buff, strlen(name_buff));
 
563
  }
 
564
  DBUG_RETURN(m_info);
513
565
 
514
566
err:
515
 
  if (disk_cache != NULL)
516
 
    free(disk_cache);
517
567
  save_errno=my_errno ? my_errno : HA_ERR_END_OF_FILE;
518
568
  if ((save_errno == HA_ERR_CRASHED) ||
519
569
      (save_errno == HA_ERR_CRASHED_ON_USAGE) ||
521
571
    mi_report_error(save_errno, name);
522
572
  switch (errpos) {
523
573
  case 6:
524
 
    free((unsigned char*) m_info);
 
574
    my_free((uchar*) m_info,MYF(0));
525
575
    /* fall through */
526
576
  case 5:
527
 
    my_close(info.dfile,MYF(0));
 
577
    VOID(my_close(info.dfile,MYF(0)));
528
578
    if (old_info)
529
579
      break;                                    /* Don't remove open table */
530
580
    /* fall through */
531
581
  case 4:
532
 
    free((unsigned char*) share);
 
582
    my_free((uchar*) share,MYF(0));
533
583
    /* fall through */
534
584
  case 3:
 
585
    if (! lock_error)
 
586
      VOID(my_lock(kfile, F_UNLCK, 0L, F_TO_EOF, MYF(MY_SEEK_NOT_DONE)));
 
587
    /* fall through */
 
588
  case 2:
 
589
    my_afree(disk_cache);
535
590
    /* fall through */
536
591
  case 1:
537
 
    my_close(kfile,MYF(0));
 
592
    VOID(my_close(kfile,MYF(0)));
538
593
    /* fall through */
539
594
  case 0:
540
595
  default:
542
597
  }
543
598
  pthread_mutex_unlock(&THR_LOCK_myisam);
544
599
  my_errno=save_errno;
545
 
  return (NULL);
 
600
  DBUG_RETURN (NULL);
546
601
} /* mi_open */
547
602
 
548
603
 
549
 
unsigned char *mi_alloc_rec_buff(MI_INFO *info, ulong length, unsigned char **buf)
 
604
uchar *mi_alloc_rec_buff(MI_INFO *info, ulong length, uchar **buf)
550
605
{
551
 
  uint32_t extra;
552
 
  uint32_t old_length= 0;
 
606
  uint extra;
 
607
  uint32 old_length= 0;
553
608
 
554
609
  if (! *buf || length > (old_length=mi_get_rec_buff_len(info, *buf)))
555
610
  {
556
 
    unsigned char *newptr = *buf;
 
611
    uchar *newptr = *buf;
557
612
 
558
613
    /* to simplify initial init of info->rec_buf in mi_open and mi_extra */
559
614
    if (length == (ulong) -1)
560
615
    {
561
616
      if (info->s->options & HA_OPTION_COMPRESS_RECORD)
562
 
        length= cmax(info->s->base.pack_reclength, info->s->max_pack_length);
 
617
        length= max(info->s->base.pack_reclength, info->s->max_pack_length);
563
618
      else
564
619
        length= info->s->base.pack_reclength;
565
 
      length= cmax(length, info->s->base.max_key_length);
 
620
      length= max(length, info->s->base.max_key_length);
566
621
      /* Avoid unnecessary realloc */
567
622
      if (newptr && length == old_length)
568
623
        return newptr;
573
628
            MI_REC_BUFF_OFFSET : 0);
574
629
    if (extra && newptr)
575
630
      newptr-= MI_REC_BUFF_OFFSET;
576
 
    if (!(newptr=(unsigned char*) my_realloc((unsigned char*)newptr, length+extra+8,
 
631
    if (!(newptr=(uchar*) my_realloc((uchar*)newptr, length+extra+8,
577
632
                                     MYF(MY_ALLOW_ZERO_PTR))))
578
633
      return newptr;
579
 
    *((uint32_t *) newptr)= (uint32_t) length;
 
634
    *((uint32 *) newptr)= (uint32) length;
580
635
    *buf= newptr+(extra ?  MI_REC_BUFF_OFFSET : 0);
581
636
  }
582
637
  return *buf;
583
638
}
584
639
 
585
640
 
586
 
uint64_t mi_safe_mul(uint64_t a, uint64_t b)
 
641
ulonglong mi_safe_mul(ulonglong a, ulonglong b)
587
642
{
588
 
  uint64_t max_val= ~ (uint64_t) 0;             /* my_off_t is unsigned */
 
643
  ulonglong max_val= ~ (ulonglong) 0;           /* my_off_t is unsigned */
589
644
 
590
645
  if (!a || max_val / a < b)
591
646
    return max_val;
596
651
 
597
652
void mi_setup_functions(register MYISAM_SHARE *share)
598
653
{
599
 
  if (share->options & HA_OPTION_PACK_RECORD)
 
654
  if (share->options & HA_OPTION_COMPRESS_RECORD)
 
655
  {
 
656
    share->read_record=_mi_read_pack_record;
 
657
    share->read_rnd=_mi_read_rnd_pack_record;
 
658
    if (!(share->options & HA_OPTION_TEMP_COMPRESS_RECORD))
 
659
      share->calc_checksum=0;                           /* No checksum */
 
660
    else if (share->options & HA_OPTION_PACK_RECORD)
 
661
      share->calc_checksum= mi_checksum;
 
662
    else
 
663
      share->calc_checksum= mi_static_checksum;
 
664
  }
 
665
  else if (share->options & HA_OPTION_PACK_RECORD)
600
666
  {
601
667
    share->read_record=_mi_read_dynamic_record;
602
668
    share->read_rnd=_mi_read_rnd_dynamic_record;
694
760
   Function to save and store the header in the index file (.MYI)
695
761
*/
696
762
 
697
 
uint32_t mi_state_info_write(File file, MI_STATE_INFO *state, uint32_t pWrite)
 
763
uint mi_state_info_write(File file, MI_STATE_INFO *state, uint pWrite)
698
764
{
699
 
  unsigned char  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
700
 
  unsigned char *ptr=buff;
 
765
  uchar  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
 
766
  uchar *ptr=buff;
701
767
  uint  i, keys= (uint) state->header.keys,
702
768
        key_blocks=state->header.max_block_size_index;
 
769
  DBUG_ENTER("mi_state_info_write");
703
770
 
704
 
  memcpy(ptr,&state->header,sizeof(state->header));
 
771
  memcpy_fixed(ptr,&state->header,sizeof(state->header));
705
772
  ptr+=sizeof(state->header);
706
773
 
707
774
  /* open_count must be first because of _mi_mark_file_changed ! */
708
775
  mi_int2store(ptr,state->open_count);          ptr +=2;
709
 
  *ptr++= (unsigned char)state->changed; *ptr++= state->sortkey;
 
776
  *ptr++= (uchar)state->changed; *ptr++= state->sortkey;
710
777
  mi_rowstore(ptr,state->state.records);        ptr +=8;
711
778
  mi_rowstore(ptr,state->state.del);            ptr +=8;
712
779
  mi_rowstore(ptr,state->split);                ptr +=8;
716
783
  mi_sizestore(ptr,state->state.empty);         ptr +=8;
717
784
  mi_sizestore(ptr,state->state.key_empty);     ptr +=8;
718
785
  mi_int8store(ptr,state->auto_increment);      ptr +=8;
719
 
  mi_int8store(ptr,(uint64_t) state->state.checksum);ptr +=8;
 
786
  mi_int8store(ptr,(ulonglong) state->state.checksum);ptr +=8;
720
787
  mi_int4store(ptr,state->process);             ptr +=4;
721
788
  mi_int4store(ptr,state->unique);              ptr +=4;
722
789
  mi_int4store(ptr,state->status);              ptr +=4;
734
801
  }
735
802
  if (pWrite & 2)                               /* From isamchk */
736
803
  {
737
 
    uint32_t key_parts= mi_uint2korr(state->header.key_parts);
 
804
    uint key_parts= mi_uint2korr(state->header.key_parts);
738
805
    mi_int4store(ptr,state->sec_index_changed); ptr +=4;
739
806
    mi_int4store(ptr,state->sec_index_used);    ptr +=4;
740
807
    mi_int4store(ptr,state->version);           ptr +=4;
741
808
    mi_int8store(ptr,state->key_map);           ptr +=8;
742
 
    mi_int8store(ptr,(uint64_t) state->create_time);    ptr +=8;
743
 
    mi_int8store(ptr,(uint64_t) state->recover_time);   ptr +=8;
744
 
    mi_int8store(ptr,(uint64_t) state->check_time);     ptr +=8;
 
809
    mi_int8store(ptr,(ulonglong) state->create_time);   ptr +=8;
 
810
    mi_int8store(ptr,(ulonglong) state->recover_time);  ptr +=8;
 
811
    mi_int8store(ptr,(ulonglong) state->check_time);    ptr +=8;
745
812
    mi_sizestore(ptr,state->rec_per_key_rows);  ptr+=8;
746
813
    for (i=0 ; i < key_parts ; i++)
747
814
    {
750
817
  }
751
818
 
752
819
  if (pWrite & 1)
753
 
    return(my_pwrite(file, buff, (size_t) (ptr-buff), 0L,
 
820
    DBUG_RETURN(my_pwrite(file, buff, (size_t) (ptr-buff), 0L,
754
821
                          MYF(MY_NABP | MY_THREADSAFE)) != 0);
755
 
  return(my_write(file, buff, (size_t) (ptr-buff),
 
822
  DBUG_RETURN(my_write(file, buff, (size_t) (ptr-buff),
756
823
                       MYF(MY_NABP)) != 0);
757
824
}
758
825
 
759
826
 
760
 
unsigned char *mi_state_info_read(unsigned char *ptr, MI_STATE_INFO *state)
 
827
uchar *mi_state_info_read(uchar *ptr, MI_STATE_INFO *state)
761
828
{
762
 
  uint32_t i,keys,key_parts,key_blocks;
763
 
  memcpy(&state->header,ptr, sizeof(state->header));
 
829
  uint i,keys,key_parts,key_blocks;
 
830
  memcpy_fixed(&state->header,ptr, sizeof(state->header));
764
831
  ptr +=sizeof(state->header);
765
832
  keys=(uint) state->header.keys;
766
833
  key_parts=mi_uint2korr(state->header.key_parts);
810
877
}
811
878
 
812
879
 
813
 
uint32_t mi_state_info_read_dsk(File file, MI_STATE_INFO *state, bool pRead)
 
880
uint mi_state_info_read_dsk(File file, MI_STATE_INFO *state, my_bool pRead)
814
881
{
815
 
  unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
 
882
  uchar buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
816
883
 
817
884
  if (!myisam_single_user)
818
885
  {
833
900
**  store and read of MI_BASE_INFO
834
901
****************************************************************************/
835
902
 
836
 
uint32_t mi_base_info_write(File file, MI_BASE_INFO *base)
 
903
uint mi_base_info_write(File file, MI_BASE_INFO *base)
837
904
{
838
 
  unsigned char buff[MI_BASE_INFO_SIZE], *ptr=buff;
 
905
  uchar buff[MI_BASE_INFO_SIZE], *ptr=buff;
839
906
 
840
907
  mi_sizestore(ptr,base->keystart);                     ptr +=8;
841
908
  mi_sizestore(ptr,base->max_data_file_length);         ptr +=8;
863
930
  *ptr++= base->raid_type;
864
931
  mi_int2store(ptr,base->raid_chunks);                  ptr +=2;
865
932
  mi_int4store(ptr,base->raid_chunksize);               ptr +=4;
866
 
  memset(ptr, 0, 6);                                    ptr +=6; /* extra */
 
933
  bzero(ptr,6);                                         ptr +=6; /* extra */
867
934
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
868
935
}
869
936
 
870
937
 
871
 
unsigned char *my_n_base_info_read(unsigned char *ptr, MI_BASE_INFO *base)
 
938
uchar *my_n_base_info_read(uchar *ptr, MI_BASE_INFO *base)
872
939
{
873
940
  base->keystart = mi_sizekorr(ptr);                    ptr +=8;
874
941
  base->max_data_file_length = mi_sizekorr(ptr);        ptr +=8;
912
979
  mi_keydef
913
980
---------------------------------------------------------------------------*/
914
981
 
915
 
uint32_t mi_keydef_write(File file, MI_KEYDEF *keydef)
 
982
uint mi_keydef_write(File file, MI_KEYDEF *keydef)
916
983
{
917
 
  unsigned char buff[MI_KEYDEF_SIZE];
918
 
  unsigned char *ptr=buff;
 
984
  uchar buff[MI_KEYDEF_SIZE];
 
985
  uchar *ptr=buff;
919
986
 
920
 
  *ptr++ = (unsigned char) keydef->keysegs;
 
987
  *ptr++ = (uchar) keydef->keysegs;
921
988
  *ptr++ = keydef->key_alg;                     /* Rtree or Btree */
922
989
  mi_int2store(ptr,keydef->flag);               ptr +=2;
923
990
  mi_int2store(ptr,keydef->block_length);       ptr +=2;
927
994
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
928
995
}
929
996
 
930
 
unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef)
 
997
uchar *mi_keydef_read(uchar *ptr, MI_KEYDEF *keydef)
931
998
{
932
999
   keydef->keysegs      = (uint) *ptr++;
933
1000
   keydef->key_alg      = *ptr++;               /* Rtree or Btree */
949
1016
 
950
1017
int mi_keyseg_write(File file, const HA_KEYSEG *keyseg)
951
1018
{
952
 
  unsigned char buff[HA_KEYSEG_SIZE];
953
 
  unsigned char *ptr=buff;
 
1019
  uchar buff[HA_KEYSEG_SIZE];
 
1020
  uchar *ptr=buff;
954
1021
  ulong pos;
955
1022
 
956
1023
  *ptr++= keyseg->type;
970
1037
}
971
1038
 
972
1039
 
973
 
unsigned char *mi_keyseg_read(unsigned char *ptr, HA_KEYSEG *keyseg)
 
1040
uchar *mi_keyseg_read(uchar *ptr, HA_KEYSEG *keyseg)
974
1041
{
975
1042
   keyseg->type         = *ptr++;
976
1043
   keyseg->language     = *ptr++;
984
1051
   keyseg->null_pos     = mi_uint4korr(ptr);  ptr +=4;
985
1052
   keyseg->charset=0;                           /* Will be filled in later */
986
1053
   if (keyseg->null_bit)
987
 
     keyseg->bit_pos= (uint16_t)(keyseg->null_pos + (keyseg->null_bit == 7));
 
1054
     keyseg->bit_pos= (uint16)(keyseg->null_pos + (keyseg->null_bit == 7));
988
1055
   else
989
1056
   {
990
 
     keyseg->bit_pos= (uint16_t)keyseg->null_pos;
 
1057
     keyseg->bit_pos= (uint16)keyseg->null_pos;
991
1058
     keyseg->null_pos= 0;
992
1059
   }
993
1060
   return ptr;
997
1064
  mi_uniquedef
998
1065
---------------------------------------------------------------------------*/
999
1066
 
1000
 
uint32_t mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
 
1067
uint mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
1001
1068
{
1002
 
  unsigned char buff[MI_UNIQUEDEF_SIZE];
1003
 
  unsigned char *ptr=buff;
 
1069
  uchar buff[MI_UNIQUEDEF_SIZE];
 
1070
  uchar *ptr=buff;
1004
1071
 
1005
1072
  mi_int2store(ptr,def->keysegs);               ptr+=2;
1006
 
  *ptr++=  (unsigned char) def->key;
1007
 
  *ptr++ = (unsigned char) def->null_are_equal;
 
1073
  *ptr++=  (uchar) def->key;
 
1074
  *ptr++ = (uchar) def->null_are_equal;
1008
1075
 
1009
1076
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1010
1077
}
1011
1078
 
1012
 
unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def)
 
1079
uchar *mi_uniquedef_read(uchar *ptr, MI_UNIQUEDEF *def)
1013
1080
{
1014
1081
   def->keysegs = mi_uint2korr(ptr);
1015
1082
   def->key     = ptr[2];
1021
1088
**  MI_COLUMNDEF
1022
1089
***************************************************************************/
1023
1090
 
1024
 
uint32_t mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
 
1091
uint mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
1025
1092
{
1026
 
  unsigned char buff[MI_COLUMNDEF_SIZE];
1027
 
  unsigned char *ptr=buff;
 
1093
  uchar buff[MI_COLUMNDEF_SIZE];
 
1094
  uchar *ptr=buff;
1028
1095
 
1029
1096
  mi_int2store(ptr,recinfo->type);      ptr +=2;
1030
1097
  mi_int2store(ptr,recinfo->length);    ptr +=2;
1033
1100
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1034
1101
}
1035
1102
 
1036
 
unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo)
 
1103
uchar *mi_recinfo_read(uchar *ptr, MI_COLUMNDEF *recinfo)
1037
1104
{
1038
1105
   recinfo->type=  mi_sint2korr(ptr);   ptr +=2;
1039
1106
   recinfo->length=mi_uint2korr(ptr);   ptr +=2;
1040
 
   recinfo->null_bit= (uint8_t) *ptr++;
 
1107
   recinfo->null_bit= (uint8) *ptr++;
1041
1108
   recinfo->null_pos=mi_uint2korr(ptr); ptr +=2;
1042
1109
   return ptr;
1043
1110
}