← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_open.c

  • Committer: Brian Aker
  • Date: 2008-07-14 22:18:37 UTC
  • mfrom: (77.1.96 codestyle)
  • Revision ID: brian@tangent.org-20080714221837-oceoshx7fjkla9u3
Merge from Monty

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
22
#define get_next_element(to,pos,size) { memcpy((char*) to,pos,(size_t) size); \
72
72
  ulong rec_per_key_part[HA_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG];
73
73
  my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
74
74
  uint64_t max_key_file_length, max_data_file_length;
 
75
  DBUG_ENTER("mi_open");
75
76
 
76
77
  kfile= -1;
77
78
  lock_error=1;
78
79
  errpos=0;
79
80
  head_length=sizeof(share_buff.state.header);
80
 
  memset((uchar*) &info, 0, sizeof(info));
 
81
  bzero((uchar*) &info,sizeof(info));
81
82
 
82
83
  my_realpath(name_buff, fn_format(org_name,name,"",MI_NAME_IEXT,
83
84
                                   MY_UNPACK_FILENAME),MYF(0));
85
86
  if (!(old_info=test_if_reopen(name_buff)))
86
87
  {
87
88
    share= &share_buff;
88
 
    memset((uchar*) &share_buff, 0, sizeof(share_buff));
 
89
    bzero((uchar*) &share_buff,sizeof(share_buff));
89
90
    share_buff.state.rec_per_key_part=rec_per_key_part;
90
91
    share_buff.state.key_root=key_root;
91
92
    share_buff.state.key_del=key_del;
92
93
    share_buff.key_cache= multi_key_cache_search((uchar*) name_buff,
93
94
                                                 strlen(name_buff));
94
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
                    });
95
102
    if ((kfile=my_open(name_buff,(open_mode=O_RDWR) | O_SHARE,MYF(0))) < 0)
96
103
    {
97
104
      if ((errno != EROFS && errno != EACCES) ||
110
117
    if (memcmp((uchar*) share->state.header.file_version,
111
118
               (uchar*) myisam_file_magic, 4))
112
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);
113
123
      my_errno=HA_ERR_NOT_A_TABLE;
114
124
      goto err;
115
125
    }
121
131
          HA_OPTION_TMP_TABLE | HA_OPTION_DELAY_KEY_WRITE |
122
132
          HA_OPTION_RELIES_ON_SQL_LAYER))
123
133
    {
 
134
      DBUG_PRINT("error",("wrong options: 0x%lx", share->options));
124
135
      my_errno=HA_ERR_OLD_FILE;
125
136
      goto err;
126
137
    }
127
138
    if ((share->options & HA_OPTION_RELIES_ON_SQL_LAYER) &&
128
139
        ! (open_flags & HA_OPEN_FROM_SQL_LAYER))
129
140
    {
 
141
      DBUG_PRINT("error", ("table cannot be openned from non-sql layer"));
130
142
      my_errno= HA_ERR_UNSUPPORTED;
131
143
      goto err;
132
144
    }
161
173
    fulltext_keys= (uint) share->state.header.fulltext_keys;
162
174
    key_parts= mi_uint2korr(share->state.header.key_parts);
163
175
    unique_key_parts= mi_uint2korr(share->state.header.unique_key_parts);
 
176
    if (len != MI_STATE_INFO_SIZE)
 
177
    {
 
178
      DBUG_PRINT("warning",
 
179
                 ("saved_state_info_length: %d  state_info_length: %d",
 
180
                  len,MI_STATE_INFO_SIZE));
 
181
    }
164
182
    share->state_diff_length=len-MI_STATE_INFO_SIZE;
165
183
 
166
184
    mi_state_info_read(disk_cache, &share->state);
167
185
    len= mi_uint2korr(share->state.header.base_info_length);
 
186
    if (len != MI_BASE_INFO_SIZE)
 
187
    {
 
188
      DBUG_PRINT("warning",("saved_base_info_length: %d  base_info_length: %d",
 
189
                            len,MI_BASE_INFO_SIZE));
 
190
    }
168
191
    disk_pos= my_n_base_info_read(disk_cache + base_pos, &share->base);
169
192
    share->state.state_length=base_pos;
170
193
 
173
196
         ((open_flags & HA_OPEN_ABORT_IF_CRASHED) &&
174
197
          (share->state.open_count))))
175
198
    {
 
199
      DBUG_PRINT("error",("Table is marked as crashed. open_flags: %u  "
 
200
                          "changed: %u  open_count: %u",
 
201
                          open_flags, share->state.changed,
 
202
                          share->state.open_count));
176
203
      my_errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
177
204
                HA_ERR_CRASHED_ON_REPAIR : HA_ERR_CRASHED_ON_USAGE);
178
205
      goto err;
188
215
    if (share->base.max_key_length > MI_MAX_KEY_BUFF || keys > MI_MAX_KEY ||
189
216
        key_parts > MI_MAX_KEY * MI_MAX_KEY_SEG)
190
217
    {
 
218
      DBUG_PRINT("error",("Wrong key info:  Max_key_length: %d  keys: %d  key_parts: %d", share->base.max_key_length, keys, key_parts));
191
219
      my_errno=HA_ERR_UNSUPPORTED;
192
220
      goto err;
193
221
    }
207
235
#endif
208
236
    if (share->base.raid_type)
209
237
    {
 
238
      DBUG_PRINT("error",("Table uses RAID but we don't have RAID support"));
210
239
      my_errno=HA_ERR_UNSUPPORTED;
211
240
      goto err;
212
241
    }
391
420
      share->data_file_type = DYNAMIC_RECORD;
392
421
    my_afree(disk_cache);
393
422
    mi_setup_functions(share);
394
 
    share->is_log_table= false;
 
423
    share->is_log_table= FALSE;
395
424
    thr_lock_init(&share->lock);
396
425
    VOID(pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST));
397
426
    for (i=0; i<keys; i++)
507
536
 
508
537
  /* Allocate buffer for one record */
509
538
 
510
 
  /* prerequisites: memset(info, 0) && info->s=share; are met. */
 
539
  /* prerequisites: bzero(info) && info->s=share; are met. */
511
540
  if (!mi_alloc_rec_buff(&info, -1, &info.rec_buff))
512
541
    goto err;
513
 
  memset(info.rec_buff, 0, mi_get_rec_buff_len(&info, info.rec_buff));
 
542
  bzero(info.rec_buff, mi_get_rec_buff_len(&info, info.rec_buff));
514
543
 
515
544
  *m_info=info;
516
545
  thr_lock_data_init(&share->lock,&m_info->lock,(void*) m_info);
523
552
    intern_filename(name_buff,share->index_file_name);
524
553
    _myisam_log(MI_LOG_OPEN, m_info, (uchar*) name_buff, strlen(name_buff));
525
554
  }
526
 
  return(m_info);
 
555
  DBUG_RETURN(m_info);
527
556
 
528
557
err:
529
558
  save_errno=my_errno ? my_errno : HA_ERR_END_OF_FILE;
557
586
  }
558
587
  pthread_mutex_unlock(&THR_LOCK_myisam);
559
588
  my_errno=save_errno;
560
 
  return (NULL);
 
589
  DBUG_RETURN (NULL);
561
590
} /* mi_open */
562
591
 
563
592
 
564
593
uchar *mi_alloc_rec_buff(MI_INFO *info, ulong length, uchar **buf)
565
594
{
566
595
  uint extra;
567
 
  uint32_t old_length= 0;
 
596
  uint32 old_length= 0;
568
597
 
569
598
  if (! *buf || length > (old_length=mi_get_rec_buff_len(info, *buf)))
570
599
  {
591
620
    if (!(newptr=(uchar*) my_realloc((uchar*)newptr, length+extra+8,
592
621
                                     MYF(MY_ALLOW_ZERO_PTR))))
593
622
      return newptr;
594
 
    *((uint32_t *) newptr)= (uint32_t) length;
 
623
    *((uint32 *) newptr)= (uint32) length;
595
624
    *buf= newptr+(extra ?  MI_REC_BUFF_OFFSET : 0);
596
625
  }
597
626
  return *buf;
726
755
  uchar *ptr=buff;
727
756
  uint  i, keys= (uint) state->header.keys,
728
757
        key_blocks=state->header.max_block_size_index;
 
758
  DBUG_ENTER("mi_state_info_write");
729
759
 
730
 
  memcpy(ptr,&state->header,sizeof(state->header));
 
760
  memcpy_fixed(ptr,&state->header,sizeof(state->header));
731
761
  ptr+=sizeof(state->header);
732
762
 
733
763
  /* open_count must be first because of _mi_mark_file_changed ! */
776
806
  }
777
807
 
778
808
  if (pWrite & 1)
779
 
    return(my_pwrite(file, buff, (size_t) (ptr-buff), 0L,
 
809
    DBUG_RETURN(my_pwrite(file, buff, (size_t) (ptr-buff), 0L,
780
810
                          MYF(MY_NABP | MY_THREADSAFE)) != 0);
781
 
  return(my_write(file, buff, (size_t) (ptr-buff),
 
811
  DBUG_RETURN(my_write(file, buff, (size_t) (ptr-buff),
782
812
                       MYF(MY_NABP)) != 0);
783
813
}
784
814
 
786
816
uchar *mi_state_info_read(uchar *ptr, MI_STATE_INFO *state)
787
817
{
788
818
  uint i,keys,key_parts,key_blocks;
789
 
  memcpy(&state->header,ptr, sizeof(state->header));
 
819
  memcpy_fixed(&state->header,ptr, sizeof(state->header));
790
820
  ptr +=sizeof(state->header);
791
821
  keys=(uint) state->header.keys;
792
822
  key_parts=mi_uint2korr(state->header.key_parts);
889
919
  *ptr++= base->raid_type;
890
920
  mi_int2store(ptr,base->raid_chunks);                  ptr +=2;
891
921
  mi_int4store(ptr,base->raid_chunksize);               ptr +=4;
892
 
  memset(ptr, 0, 6);                                    ptr +=6; /* extra */
 
922
  bzero(ptr,6);                                         ptr +=6; /* extra */
893
923
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
894
924
}
895
925
 
1010
1040
   keyseg->null_pos     = mi_uint4korr(ptr);  ptr +=4;
1011
1041
   keyseg->charset=0;                           /* Will be filled in later */
1012
1042
   if (keyseg->null_bit)
1013
 
     keyseg->bit_pos= (uint16_t)(keyseg->null_pos + (keyseg->null_bit == 7));
 
1043
     keyseg->bit_pos= (uint16)(keyseg->null_pos + (keyseg->null_bit == 7));
1014
1044
   else
1015
1045
   {
1016
 
     keyseg->bit_pos= (uint16_t)keyseg->null_pos;
 
1046
     keyseg->bit_pos= (uint16)keyseg->null_pos;
1017
1047
     keyseg->null_pos= 0;
1018
1048
   }
1019
1049
   return ptr;
1063
1093
{
1064
1094
   recinfo->type=  mi_sint2korr(ptr);   ptr +=2;
1065
1095
   recinfo->length=mi_uint2korr(ptr);   ptr +=2;
1066
 
   recinfo->null_bit= (uint8_t) *ptr++;
 
1096
   recinfo->null_bit= (uint8) *ptr++;
1067
1097
   recinfo->null_pos=mi_uint2korr(ptr); ptr +=2;
1068
1098
   return ptr;
1069
1099
}