开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mi_open.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：33k
源码类别：

MySQL数据库

开发平台：

Visual C++

mi_open.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* open a isam-database */
  19. #include "fulltext.h"
  20. #include <m_ctype.h>
  22. #if defined(MSDOS) || defined(__WIN__)
  23. #ifdef __WIN__
  24. #include <fcntl.h>
  25. #else
  26. #include <process.h> /* Prototype for getpid */
  27. #endif
  28. #endif
  29. #ifdef VMS
  30. #include "static.c"
  31. #endif
  33. static void setup_functions(MYISAM_SHARE *info);
  34. static void setup_key_functions(MI_KEYDEF *keyinfo);
  35. #define get_next_element(to,pos,size) { memcpy((char*) to,pos,(size_t) size); 
  36. pos+=size;}
  39. /******************************************************************************
  40. ** Return the shared struct if the table is already open.
  41. ** In MySQL the server will handle version issues.
  42. ******************************************************************************/
  44. static MI_INFO *test_if_reopen(char *filename)
  45. {
  46.   LIST *pos;
  48.   for (pos=myisam_open_list ; pos ; pos=pos->next)
  49.   {
  50.     MI_INFO *info=(MI_INFO*) pos->data;
  51.     MYISAM_SHARE *share=info->s;
  52.     if (!strcmp(share->filename,filename) && share->last_version)
  53.       return info;
  54.   }
  55.   return 0;
  56. }
  59. /******************************************************************************
  60.   open a MyISAM database.
  61.   See my_base.h for the handle_locking argument
  62.   if handle_locking and HA_OPEN_ABORT_IF_CRASHED then abort if the table
  63.   is marked crashed or if we are not using locking and the table doesn't
  64.   have an open count of 0.
  65. ******************************************************************************/
  67. MI_INFO *mi_open(const char *name, int mode, uint open_flags)
  68. {
  69.   int lock_error,kfile,open_mode,save_errno;
  70.   uint i,j,len,errpos,head_length,base_pos,offset,info_length,extra,keys,
  71.     key_parts,unique_key_parts,tmp_length,uniques;
  72.   char name_buff[FN_REFLEN],*disk_cache,*disk_pos;
  73.   MI_INFO info,*m_info,*old_info;
  74.   MYISAM_SHARE share_buff,*share;
  75.   ulong rec_per_key_part[MI_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG];
  76.   my_off_t key_root[MI_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
  77.   ulonglong max_key_file_length, max_data_file_length;
  78.   DBUG_ENTER("mi_open");
  80.   LINT_INIT(m_info);
  81.   kfile= -1;
  82.   lock_error=1;
  83.   errpos=0;
  84.   head_length=sizeof(share_buff.state.header);
  85.   bzero((byte*) &info,sizeof(info));
  87.   VOID(fn_format(name_buff,name,"",MI_NAME_IEXT,4+16+32));
  88.   pthread_mutex_lock(&THR_LOCK_myisam);
  89.   if (!(old_info=test_if_reopen(name_buff)))
  90.   {
  91.     share= &share_buff;
  92.     bzero((gptr) &share_buff,sizeof(share_buff));
  93.     share_buff.state.rec_per_key_part=rec_per_key_part;
  94.     share_buff.state.key_root=key_root;
  95.     share_buff.state.key_del=key_del;
  97.     if ((kfile=my_open(name_buff,(open_mode=O_RDWR) | O_SHARE,MYF(0))) < 0)
  98.     {
  99.       if ((errno != EROFS && errno != EACCES) ||
  100.   mode != O_RDONLY ||
  101.   (kfile=my_open(name_buff,(open_mode=O_RDONLY) | O_SHARE,MYF(0))) < 0)
  102. goto err;
  103.     }
  104.     share->mode=open_mode;
  105.     errpos=1;
  106.     if (my_read(kfile,(char*) share->state.header.file_version,head_length,
  107. MYF(MY_NABP)))
  108.       goto err;
  110.     if (memcmp((byte*) share->state.header.file_version,
  111.        (byte*) myisam_file_magic, 4))
  112.     {
  113.       DBUG_PRINT("error",("Wrong header in %s",name_buff));
  114.       DBUG_DUMP("error_dump",(char*) share->state.header.file_version,
  115. head_length);
  116.       my_errno=HA_ERR_CRASHED;
  117.       goto err;
  118.     }
  119.     share->options= mi_uint2korr(share->state.header.options);
  120.     if (share->options &
  121. ~(HA_OPTION_PACK_RECORD | HA_OPTION_PACK_KEYS |
  122.   HA_OPTION_COMPRESS_RECORD | HA_OPTION_READ_ONLY_DATA |
  123.   HA_OPTION_TEMP_COMPRESS_RECORD | HA_OPTION_CHECKSUM |
  124.   HA_OPTION_TMP_TABLE | HA_OPTION_DELAY_KEY_WRITE))
  125.     {
  126.       DBUG_PRINT("error",("wrong options: 0x%lx",
  127.   share->options));
  128.       my_errno=HA_ERR_OLD_FILE;
  129.       goto err;
  130.     }
  131.     info_length=mi_uint2korr(share->state.header.header_length);
  132.     base_pos=mi_uint2korr(share->state.header.base_pos);
  133.     if (!(disk_cache=(char*) my_alloca(info_length)))
  134.     {
  135.       my_errno=ENOMEM;
  136.       goto err;
  137.     }
  138.     errpos=2;
  140.     VOID(my_seek(kfile,0L,MY_SEEK_SET,MYF(0)));
  141.     if (!(open_flags & HA_OPEN_TMP_TABLE))
  142.     {
  143.       if ((lock_error=my_lock(kfile,F_RDLCK,0L,F_TO_EOF,
  144.       MYF(open_flags & HA_OPEN_WAIT_IF_LOCKED ?
  145.   0 : MY_DONT_WAIT))) &&
  146.   !(open_flags & HA_OPEN_IGNORE_IF_LOCKED))
  147. goto err;
  148.     }
  149.     errpos=3;
  150.     if (my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
  151.       goto err;
  152.     len=mi_uint2korr(share->state.header.state_info_length);
  153.     keys=    (uint) share->state.header.keys;
  154.     uniques= (uint) share->state.header.uniques;
  155.     key_parts= mi_uint2korr(share->state.header.key_parts);
  156.     unique_key_parts= mi_uint2korr(share->state.header.unique_key_parts);
  157.     tmp_length=(MI_STATE_INFO_SIZE + keys * MI_STATE_KEY_SIZE +
  158. key_parts*MI_STATE_KEYSEG_SIZE +
  159. share->state.header.max_block_size*MI_STATE_KEYBLOCK_SIZE);
  160.     if (len != MI_STATE_INFO_SIZE)
  161.     {
  162.       DBUG_PRINT("warning",
  163.  ("saved_state_info_length: %d  state_info_length: %d",
  164.   len,MI_STATE_INFO_SIZE));
  165.     }
  166.     share->state_diff_length=len-MI_STATE_INFO_SIZE;
  168.     mi_state_info_read(disk_cache, &share->state);
  169.     len= mi_uint2korr(share->state.header.base_info_length);
  170.     if (len != MI_BASE_INFO_SIZE)
  171.     {
  172.       DBUG_PRINT("warning",("saved_base_info_length: %d  base_info_length: %d",
  173.     len,MI_BASE_INFO_SIZE))
  174.     }
  175.     disk_pos=my_n_base_info_read(disk_cache+base_pos, &share->base);
  176.     share->state.state_length=base_pos;
  178.     if (!(open_flags & HA_OPEN_FOR_REPAIR) &&
  179. ((share->state.changed & STATE_CRASHED) ||
  180.  ((open_flags & HA_OPEN_ABORT_IF_CRASHED) &&
  181.   (my_disable_locking && share->state.open_count))))
  182.     {
  183.       DBUG_PRINT("error",("Table is marked as crashed"));
  184.       my_errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
  185. HA_ERR_CRASHED_ON_REPAIR : HA_ERR_CRASHED_ON_USAGE);
  186.       goto err;
  187.     }
  189.     /* sanity check */
  190.     if (share->base.keystart > 65535 || share->base.rec_reflength > 8)
  191.     {
  192.       my_errno=HA_ERR_CRASHED;
  193.       goto err;
  194.     }
  196.     if (share->base.max_key_length > MI_MAX_KEY_BUFF || keys > MI_MAX_KEY ||
  197. key_parts >= MI_MAX_KEY * MI_MAX_KEY_SEG)
  198.     {
  199.       DBUG_PRINT("error",("Wrong key info:  Max_key_length: %d  keys: %d  key_parts: %d", share->base.max_key_length, keys, key_parts));
  200.       my_errno=HA_ERR_UNSUPPORTED;
  201.       goto err;
  202.     }
  204.     /* Correct max_file_length based on length of sizeof_t */
  205.     max_data_file_length=
  206.       (share->options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ?
  207.       (((ulonglong) 1 << (share->base.rec_reflength*8))-1) :
  208.       (mi_safe_mul(share->base.reclength,
  209.    (ulonglong) 1 << (share->base.rec_reflength*8))-1);
  210.     max_key_file_length=
  211.       mi_safe_mul(MI_KEY_BLOCK_LENGTH,
  212.   ((ulonglong) 1 << (share->base.key_reflength*8))-1);
  213. #if SIZEOF_OFF_T == 4
  214.     set_if_smaller(max_data_file_length, INT_MAX32);
  215.     set_if_smaller(max_key_file_length, INT_MAX32);
  216. #endif
  217. #if USE_RAID && SYSTEM_SIZEOF_OFF_T == 4
  218.     set_if_smaller(max_key_file_length, INT_MAX32);
  219.     if (!share->base.raid_type)
  220.     {
  221.       set_if_smaller(max_data_file_length, INT_MAX32);
  222.     }
  223.     else
  224.     {
  225.       set_if_smaller(max_data_file_length,
  226.      (ulonglong) share->base.raid_chunks << 31);
  227.     }
  228. #elif !defined(USE_RAID)
  229.     if (share->base.raid_type)
  230.     {
  231.       DBUG_PRINT("error",("Table uses RAID but we don't have RAID support"));
  232.       my_errno=HA_ERR_UNSUPPORTED;
  233.       goto err;
  234.     }
  235. #endif
  236.     share->base.max_data_file_length=(my_off_t) max_data_file_length;
  237.     share->base.max_key_file_length=(my_off_t) max_key_file_length;
  239.     if (share->options & HA_OPTION_COMPRESS_RECORD)
  240.       share->base.max_key_length+=2; /* For safety */
  242.     if (!my_multi_malloc(MY_WME,
  243.  &share,sizeof(*share),
  244.  &share->state.rec_per_key_part,sizeof(long)*key_parts,
  245.  &share->keyinfo,keys*sizeof(MI_KEYDEF),
  246.  &share->uniqueinfo,uniques*sizeof(MI_UNIQUEDEF),
  247.  &share->keyparts,
  248.  (key_parts+unique_key_parts+keys+uniques) *
  249.  sizeof(MI_KEYSEG),
  250.  &share->rec,
  251.  (share->base.fields+1)*sizeof(MI_COLUMNDEF),
  252.  &share->blobs,sizeof(MI_BLOB)*share->base.blobs,
  253.  &share->filename,strlen(name_buff)+1,
  254.  &share->state.key_root,keys*sizeof(my_off_t),
  255.  &share->state.key_del,
  256.  (share->state.header.max_block_size*sizeof(my_off_t)),
  257. #ifdef THREAD
  258.  &share->key_root_lock,sizeof(rw_lock_t)*keys,
  259. #endif
  260.  NullS))
  261.       goto err;
  262.     errpos=4;
  263.     *share=share_buff;
  264.     memcpy((char*) share->state.rec_per_key_part,
  265.    (char*) rec_per_key_part, sizeof(long)*key_parts);
  266.     memcpy((char*) share->state.key_root,
  267.    (char*) key_root, sizeof(my_off_t)*keys);
  268.     memcpy((char*) share->state.key_del,
  269.    (char*) key_del, (sizeof(my_off_t) *
  270.      share->state.header.max_block_size));
  271.     strmov(share->filename,name_buff);
  273.     share->blocksize=min(IO_SIZE,myisam_block_size);
  274.     {
  275.       MI_KEYSEG *pos=share->keyparts;
  276.       for (i=0 ; i < keys ; i++)
  277.       {
  278. disk_pos=mi_keydef_read(disk_pos, &share->keyinfo[i]);
  279. set_if_smaller(share->blocksize,share->keyinfo[i].block_length);
  280. share->keyinfo[i].seg=pos;
  281. for (j=0 ; j < share->keyinfo[i].keysegs; j++,pos++)
  282. {
  283.   disk_pos=mi_keyseg_read(disk_pos, pos);
  284.   if (pos->type == HA_KEYTYPE_TEXT || pos->type == HA_KEYTYPE_VARTEXT)
  285.   {
  286.     if (!pos->language)
  287.       pos->charset=default_charset_info;
  288.     else if (!(pos->charset= get_charset(pos->language, MYF(MY_WME))))
  289.     {
  290.       my_errno=HA_ERR_UNKNOWN_CHARSET;
  291.       goto err;
  292.     }
  293.   }
  294. }
  295. if (share->keyinfo[i].flag & HA_FULLTEXT)     /* SerG */
  296. {
  297.   share->keyinfo[i].seg=pos-FT_SEGS;     /* SerG */
  298.   share->fulltext_index=1;
  299. }
  300. share->keyinfo[i].end=pos;
  301. pos->type=HA_KEYTYPE_END; /* End */
  302. pos->length=share->base.rec_reflength;
  303. pos->null_bit=0;
  304. pos++;
  305.       }
  306.       for (i=0 ; i < uniques ; i++)
  307.       {
  308. disk_pos=mi_uniquedef_read(disk_pos, &share->uniqueinfo[i]);
  309. share->uniqueinfo[i].seg=pos;
  310. for (j=0 ; j < share->uniqueinfo[i].keysegs; j++,pos++)
  311. {
  312.   disk_pos=mi_keyseg_read(disk_pos, pos);
  313.   if (pos->type == HA_KEYTYPE_TEXT || pos->type == HA_KEYTYPE_VARTEXT)
  314.   {
  315.     if (!pos->language)
  316.       pos->charset=default_charset_info;
  317.     else if (!(pos->charset= get_charset(pos->language, MYF(MY_WME))))
  318.     {
  319.       my_errno=HA_ERR_UNKNOWN_CHARSET;
  320.       goto err;
  321.     }
  322.   }
  323. }
  324. share->uniqueinfo[i].end=pos;
  325. pos->type=HA_KEYTYPE_END; /* End */
  326. pos->null_bit=0;
  327. pos++;
  328.       }
  329.     }
  330.     for (i=0 ; i < keys ; i++)
  331.       setup_key_functions(share->keyinfo+i);
  333.     for (i=j=offset=0 ; i < share->base.fields ; i++)
  334.     {
  335.       disk_pos=mi_recinfo_read(disk_pos,&share->rec[i]);
  336.       share->rec[i].pack_type=0;
  337.       share->rec[i].huff_tree=0;
  338.       share->rec[i].offset=offset;
  339.       if (share->rec[i].type == (int) FIELD_BLOB)
  340.       {
  341. share->blobs[j].pack_length=
  342.   share->rec[i].length-mi_portable_sizeof_char_ptr;;
  343. share->blobs[j].offset=offset;
  344. j++;
  345.       }
  346.       offset+=share->rec[i].length;
  347.     }
  348.     share->rec[i].type=(int) FIELD_LAST; /* End marker */
  350.     if (! lock_error)
  351.     {
  352.       VOID(my_lock(kfile,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE)));
  353.       lock_error=1; /* Database unlocked */
  354.     }
  356.     if (mi_open_datafile(&info, share))
  357.       goto err;
  358.     errpos=5;
  360.     share->kfile=kfile;
  361.     share->this_process=(ulong) getpid();
  362.     share->rnd= (int)  share->this_process; /* rnd-counter for splits */
  363. #ifndef DBUG_OFF
  364.     share->rnd=0; /* To make things repeatable */
  365. #endif
  366.     share->last_process= share->state.process;
  367.     share->base.key_parts=key_parts;
  368.     share->base.all_key_parts=key_parts+unique_key_parts;
  369.     if (!(share->last_version=share->state.version))
  370.       share->last_version=1; /* Safety */
  371.     share->rec_reflength=share->base.rec_reflength; /* May be changed */
  372.     share->base.margin_key_file_length=(share->base.max_key_file_length -
  373. (keys ? MI_INDEX_BLOCK_MARGIN *
  374.  share->blocksize * keys : 0));
  375.     share->blocksize=min(IO_SIZE,myisam_block_size);
  377.     share->data_file_type=STATIC_RECORD;
  378.     if (share->options & HA_OPTION_COMPRESS_RECORD)
  379.     {
  380.       share->data_file_type = COMPRESSED_RECORD;
  381.       share->options|= HA_OPTION_READ_ONLY_DATA;
  382.       info.s=share;
  383.       if (_mi_read_pack_info(&info,
  384.      (pbool)
  385.      test(!(share->options &
  386.     (HA_OPTION_PACK_RECORD |
  387.      HA_OPTION_TEMP_COMPRESS_RECORD)))))
  388. goto err;
  389.     }
  390.     else if (share->options & HA_OPTION_PACK_RECORD)
  391.       share->data_file_type = DYNAMIC_RECORD;
  392.     my_afree((gptr) disk_cache);
  393.     setup_functions(share);
  394. #ifdef THREAD
  395.     thr_lock_init(&share->lock);
  396.     VOID(pthread_mutex_init(&share->intern_lock,NULL));
  397.     for (i=0; i<keys; i++)
  398.       VOID(my_rwlock_init(&share->key_root_lock[i], NULL));
  399.     if (!thr_lock_inited)
  400.     {
  401.       /* Probably a single threaded program; Don't use concurrent inserts */
  402.       myisam_concurrent_insert=0;
  403.     }
  404.     else if (myisam_concurrent_insert)
  405.     {
  406.       share->concurrent_insert=
  407. ((share->options & (HA_OPTION_READ_ONLY_DATA | HA_OPTION_TMP_TABLE |
  408.    HA_OPTION_COMPRESS_RECORD |
  409.    HA_OPTION_TEMP_COMPRESS_RECORD)) ||
  410.  (open_flags & HA_OPEN_TMP_TABLE)) ? 0 : 1;
  411.       if (share->concurrent_insert)
  412.       {
  413. share->lock.get_status=mi_get_status;
  414. share->lock.copy_status=mi_copy_status;
  415. share->lock.update_status=mi_update_status;
  416. share->lock.check_status=mi_check_status;
  417.       }
  418.     }
  419. #endif
  420.   }
  421.   else
  422.   {
  423.     share= old_info->s;
  424.     if (mode == O_RDWR && share->mode == O_RDONLY)
  425.     {
  426.       my_errno=EACCES; /* Can't open in write mode */
  427.       goto err;
  428.     }
  429.     if (mi_open_datafile(&info, share))
  430.       goto err;
  431.     errpos=5;
  432.   }
  434.   /* alloc and set up private structure parts */
  435.   if (!my_multi_malloc(MY_WME,
  436.        &m_info,sizeof(MI_INFO),
  437.        &info.blobs,sizeof(MI_BLOB)*share->base.blobs,
  438.        &info.buff,(share->base.max_key_block_length*2+
  439.    share->base.max_key_length),
  440.        &info.lastkey,share->base.max_key_length*3+1,
  441.        &info.filename,strlen(name)+1,
  442.        NullS))
  443.     goto err;
  444.   errpos=6;
  446.   strmov(info.filename,name);
  447.   memcpy(info.blobs,share->blobs,sizeof(MI_BLOB)*share->base.blobs);
  448.   info.lastkey2=info.lastkey+share->base.max_key_length;
  450.   info.s=share;
  451.   info.lastpos= HA_OFFSET_ERROR;
  452.   info.update= (short) (HA_STATE_NEXT_FOUND+HA_STATE_PREV_FOUND);
  453.   info.opt_flag=READ_CHECK_USED;
  454.   info.this_unique= (ulong) info.dfile; /* Uniq number in process */
  455.   if (share->data_file_type == COMPRESSED_RECORD)
  456.     info.this_unique= share->state.unique;
  457.   info.this_loop=0; /* Update counter */
  458.   info.last_unique= share->state.unique;
  459.   info.last_loop=   share->state.update_count;
  460.   if (mode == O_RDONLY)
  461.     share->options|=HA_OPTION_READ_ONLY_DATA;
  462.   info.lock_type=F_UNLCK;
  463.   info.quick_mode=0;
  464.   info.errkey= -1;
  465.   info.page_changed=1;
  466.   pthread_mutex_lock(&share->intern_lock);
  467.   info.read_record=share->read_record;
  468.   share->reopen++;
  469.   share->write_flag=MYF(MY_NABP | MY_WAIT_IF_FULL);
  470.   if (share->options & HA_OPTION_READ_ONLY_DATA)
  471.   {
  472.     info.lock_type=F_RDLCK;
  473.     share->r_locks++;
  474.   }
  475.   if ((open_flags & HA_OPEN_TMP_TABLE) ||
  476.       (share->options & HA_OPTION_TMP_TABLE))
  477.   {
  478.     share->temporary=share->delay_key_write=1;
  479.     share->write_flag=MYF(MY_NABP);
  480.     share->w_locks++; /* We don't have to update status */
  481.     info.lock_type=F_WRLCK;
  482.   }
  483.   if (((open_flags & HA_OPEN_DELAY_KEY_WRITE) ||
  484.       (share->options & HA_OPTION_DELAY_KEY_WRITE)) &&
  485.       myisam_delay_key_write)
  486.     share->delay_key_write=1;
  487.   info.state= &share->state.state; /* Change global values by default */
  488.   pthread_mutex_unlock(&share->intern_lock);
  490.   /* Allocate buffer for one record */
  492.   extra=0;
  493.   if (share->options & HA_OPTION_PACK_RECORD)
  494.     extra=ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
  495.       MI_DYN_DELETE_BLOCK_HEADER;
  497.   tmp_length=max(share->base.pack_reclength,share->base.max_key_length);
  498.   info.alloced_rec_buff_length=tmp_length;
  499.   if (!(info.rec_alloc=(byte*) my_malloc(tmp_length+extra+8,
  500.  MYF(MY_WME | MY_ZEROFILL))))
  501.     goto err;
  502.   if (extra)
  503.     info.rec_buff=info.rec_alloc+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER);
  504.   else
  505.     info.rec_buff=info.rec_alloc;
  507.   *m_info=info;
  508. #ifdef THREAD
  509.   thr_lock_data_init(&share->lock,&m_info->lock,(void*) m_info);
  510. #endif
  511.   m_info->open_list.data=(void*) m_info;
  512.   myisam_open_list=list_add(myisam_open_list,&m_info->open_list);
  514.   pthread_mutex_unlock(&THR_LOCK_myisam);
  515.   if (myisam_log_file >= 0)
  516.   {
  517.     intern_filename(name_buff,share->filename);
  518.     _myisam_log(MI_LOG_OPEN,m_info,name_buff,(uint) strlen(name_buff));
  519.   }
  520.   DBUG_RETURN(m_info);
  522. err:
  523.   save_errno=my_errno ? my_errno : HA_ERR_END_OF_FILE;
  524.   switch (errpos) {
  525.   case 6:
  526.     my_free((gptr) m_info,MYF(0));
  527.     /* fall through */
  528.   case 5:
  529.     VOID(my_close(info.dfile,MYF(0)));
  530.     if (old_info)
  531.       break; /* Don't remove open table */
  532.     /* fall through */
  533.   case 4:
  534.     my_free((gptr) share,MYF(0));
  535.     /* fall through */
  536.   case 3:
  537.     if (! lock_error)
  538.       VOID(my_lock(kfile, F_UNLCK, 0L, F_TO_EOF, MYF(MY_SEEK_NOT_DONE)));
  539.     /* fall through */
  540.   case 2:
  541.     my_afree((gptr) disk_cache);
  542.     /* fall through */
  543.   case 1:
  544.     VOID(my_close(kfile,MYF(0)));
  545.     /* fall through */
  546.   case 0:
  547.   default:
  548.     break;
  549.   }
  550.   pthread_mutex_unlock(&THR_LOCK_myisam);
  551.   my_errno=save_errno;
  552.   DBUG_RETURN (NULL);
  553. } /* mi_open */
  556. ulonglong mi_safe_mul(ulonglong a, ulonglong b)
  557. {
  558.   ulonglong max_val= ~ (ulonglong) 0; /* my_off_t is unsigned */
  560.   if (!a || max_val / a < b)
  561.     return max_val;
  562.   return a*b;
  563. }
  565. /* Set up functions in structs */
  567. static void setup_functions(register MYISAM_SHARE *share)
  568. {
  569.   if (share->options & HA_OPTION_COMPRESS_RECORD)
  570.   {
  571.     share->read_record=_mi_read_pack_record;
  572.     share->read_rnd=_mi_read_rnd_pack_record;
  573.     if (!(share->options & HA_OPTION_TEMP_COMPRESS_RECORD))
  574.       share->calc_checksum=0; /* No checksum */
  575.     else if (share->options & HA_OPTION_PACK_RECORD)
  576.       share->calc_checksum= mi_checksum;
  577.     else
  578.       share->calc_checksum= mi_static_checksum;
  579.   }
  580.   else if (share->options & HA_OPTION_PACK_RECORD)
  581.   {
  582.     share->read_record=_mi_read_dynamic_record;
  583.     share->read_rnd=_mi_read_rnd_dynamic_record;
  584.     share->delete_record=_mi_delete_dynamic_record;
  585.     share->compare_record=_mi_cmp_dynamic_record;
  586.     share->compare_unique=_mi_cmp_dynamic_unique;
  587.     share->calc_checksum= mi_checksum;
  589.     if (share->base.blobs)
  590.     {
  591.       share->update_record=_mi_update_blob_record;
  592.       share->write_record=_mi_write_blob_record;
  593.     }
  594.     else
  595.     {
  596.       share->write_record=_mi_write_dynamic_record;
  597.       share->update_record=_mi_update_dynamic_record;
  598.     }
  599.   }
  600.   else
  601.   {
  602.     share->read_record=_mi_read_static_record;
  603.     share->read_rnd=_mi_read_rnd_static_record;
  604.     share->delete_record=_mi_delete_static_record;
  605.     share->compare_record=_mi_cmp_static_record;
  606.     share->update_record=_mi_update_static_record;
  607.     share->write_record=_mi_write_static_record;
  608.     share->compare_unique=_mi_cmp_static_unique;
  609.     share->calc_checksum= mi_static_checksum;
  610.   }
  611.   if (!(share->options & HA_OPTION_CHECKSUM))
  612.     share->calc_checksum=0;
  613.   return;
  614. }
  617. static void setup_key_functions(register MI_KEYDEF *keyinfo)
  618. {
  619.   if (keyinfo->flag & HA_BINARY_PACK_KEY)
  620.   { /* Simple prefix compression */
  621.     keyinfo->bin_search=_mi_seq_search;
  622.     keyinfo->get_key=_mi_get_binary_pack_key;
  623.     keyinfo->pack_key=_mi_calc_bin_pack_key_length;
  624.     keyinfo->store_key=_mi_store_bin_pack_key;
  625.   }
  626.   else if (keyinfo->flag & HA_VAR_LENGTH_KEY)
  627.   {
  628.     keyinfo->bin_search=_mi_seq_search;
  629.     keyinfo->get_key= _mi_get_pack_key;
  630.     if (keyinfo->seg[0].flag & HA_PACK_KEY)
  631.     { /* Prefix compression */
  632.       keyinfo->pack_key=_mi_calc_var_pack_key_length;
  633.       keyinfo->store_key=_mi_store_var_pack_key;
  634.     }
  635.     else
  636.     {
  637.       keyinfo->pack_key=_mi_calc_var_key_length; /* Variable length key */
  638.       keyinfo->store_key=_mi_store_static_key;
  639.     }
  640.   }
  641.   else
  642.   {
  643.     keyinfo->bin_search=_mi_bin_search;
  644.     keyinfo->get_key=_mi_get_static_key;
  645.     keyinfo->pack_key=_mi_calc_static_key_length;
  646.     keyinfo->store_key=_mi_store_static_key;
  647.   }
  648.   return;
  649. }
  652. /***************************************************************************
  653. ** Function to save and store the header in the index file (.MSI)
  654. ***************************************************************************/
  656. uint mi_state_info_write(File file, MI_STATE_INFO *state, uint pWrite)
  657. {
  658.   uchar  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
  659.   uchar *ptr=buff;
  660.   uint i, keys= (uint) state->header.keys,
  661. key_blocks=state->header.max_block_size;
  663.   memcpy_fixed(ptr,&state->header,sizeof(state->header));
  664.   ptr+=sizeof(state->header);
  666.   /* open_count must be first because of _mi_mark_file_changed ! */
  667.   mi_int2store(ptr,state->open_count); ptr +=2;
  668.   *ptr++= (uchar)state->changed; *ptr++= state->sortkey;
  669.   mi_rowstore(ptr,state->state.records); ptr +=8;
  670.   mi_rowstore(ptr,state->state.del); ptr +=8;
  671.   mi_rowstore(ptr,state->split); ptr +=8;
  672.   mi_sizestore(ptr,state->dellink); ptr +=8;
  673.   mi_sizestore(ptr,state->state.key_file_length); ptr +=8;
  674.   mi_sizestore(ptr,state->state.data_file_length); ptr +=8;
  675.   mi_sizestore(ptr,state->state.empty); ptr +=8;
  676.   mi_sizestore(ptr,state->state.key_empty); ptr +=8;
  677.   mi_int8store(ptr,state->auto_increment); ptr +=8;
  678.   mi_int8store(ptr,(ulonglong) state->checksum);ptr +=8;
  679.   mi_int4store(ptr,state->process); ptr +=4;
  680.   mi_int4store(ptr,state->unique); ptr +=4;
  681.   mi_int4store(ptr,state->status); ptr +=4;
  682.   mi_int4store(ptr,state->update_count); ptr +=4;
  684.   ptr+=state->state_diff_length;
  686.   for (i=0; i < keys; i++)
  687.   {
  688.     mi_sizestore(ptr,state->key_root[i]); ptr +=8;
  689.   }
  690.   for (i=0; i < key_blocks; i++)
  691.   {
  692.     mi_sizestore(ptr,state->key_del[i]); ptr +=8;
  693.   }
  694.   if (pWrite & 2) /* From isamchk */
  695.   {
  696.     uint key_parts= mi_uint2korr(state->header.key_parts);
  697.     mi_int4store(ptr,state->sec_index_changed); ptr +=4;
  698.     mi_int4store(ptr,state->sec_index_used); ptr +=4;
  699.     mi_int4store(ptr,state->version); ptr +=4;
  700.     mi_int8store(ptr,state->key_map); ptr +=8;
  701.     mi_int8store(ptr,(ulonglong) state->create_time); ptr +=8;
  702.     mi_int8store(ptr,(ulonglong) state->recover_time); ptr +=8;
  703.     mi_int8store(ptr,(ulonglong) state->check_time); ptr +=8;
  704.     mi_sizestore(ptr,state->rec_per_key_rows); ptr+=8;
  705.     for (i=0 ; i < key_parts ; i++)
  706.     {
  707.       mi_int4store(ptr,state->rec_per_key_part[i]);  ptr+=4;
  708.     }
  709.   }
  711.   if (pWrite & 1)
  712.      return my_pwrite(file,(char*) buff, (uint) (ptr-buff), 0L,
  713.       MYF(MY_NABP | MY_THREADSAFE));
  714.   else
  715.     return my_write(file,  (char*) buff, (uint) (ptr-buff), MYF(MY_NABP));
  716. }
  719. char *mi_state_info_read(char *ptr, MI_STATE_INFO *state)
  720. {
  721.   uint i,keys,key_parts,key_blocks;
  722.   memcpy_fixed(&state->header,ptr, sizeof(state->header));
  723.   ptr +=sizeof(state->header);
  724.   keys=(uint) state->header.keys;
  725.   key_parts=mi_uint2korr(state->header.key_parts);
  726.   key_blocks=state->header.max_block_size;
  728.   state->open_count = mi_uint2korr(ptr); ptr +=2;
  729.   state->changed= (bool) *ptr++;
  730.   state->sortkey = (uint) *ptr++;
  731.   state->state.records= mi_rowkorr(ptr); ptr +=8;
  732.   state->state.del = mi_rowkorr(ptr); ptr +=8;
  733.   state->split = mi_rowkorr(ptr); ptr +=8;
  734.   state->dellink= mi_sizekorr(ptr); ptr +=8;
  735.   state->state.key_file_length = mi_sizekorr(ptr); ptr +=8;
  736.   state->state.data_file_length= mi_sizekorr(ptr); ptr +=8;
  737.   state->state.empty = mi_sizekorr(ptr); ptr +=8;
  738.   state->state.key_empty= mi_sizekorr(ptr); ptr +=8;
  739.   state->auto_increment=mi_uint8korr(ptr); ptr +=8;
  740.   state->checksum=(ha_checksum) mi_uint8korr(ptr); ptr +=8;
  741.   state->process= mi_uint4korr(ptr); ptr +=4;
  742.   state->unique = mi_uint4korr(ptr); ptr +=4;
  743.   state->status = mi_uint4korr(ptr); ptr +=4;
  744.   state->update_count=mi_uint4korr(ptr); ptr +=4;
  746.   for (i=0; i < keys; i++)
  747.   {
  748.     state->key_root[i]= mi_sizekorr(ptr); ptr +=8;
  749.   }
  750.   for (i=0; i < key_blocks; i++)
  751.   {
  752.     state->key_del[i] = mi_sizekorr(ptr); ptr +=8;
  753.   }
  754.   ptr+= state->state_diff_length;
  755.   state->sec_index_changed = mi_uint4korr(ptr); ptr +=4;
  756.   state->sec_index_used =    mi_uint4korr(ptr); ptr +=4;
  757.   state->version     = mi_uint4korr(ptr); ptr +=4;
  758.   state->key_map     = mi_uint8korr(ptr); ptr +=8;
  759.   state->create_time = (time_t) mi_sizekorr(ptr); ptr +=8;
  760.   state->recover_time =(time_t) mi_sizekorr(ptr); ptr +=8;
  761.   state->check_time =  (time_t) mi_sizekorr(ptr); ptr +=8;
  762.   state->rec_per_key_rows=mi_sizekorr(ptr); ptr +=8;
  763.   for (i=0 ; i < key_parts ; i++)
  764.   {
  765.     state->rec_per_key_part[i]= mi_uint4korr(ptr); ptr+=4;
  766.   }
  767.   return ptr;
  768. }
  771. uint mi_state_info_read_dsk(File file, MI_STATE_INFO *state, my_bool pRead)
  772. {
  773.   char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
  775.   if (pRead)
  776.   {
  777.     if (my_pread(file, buff, state->state_length,0L, MYF(MY_NABP)))
  778.       return (MY_FILE_ERROR);
  779.   }
  780.   else if (my_read(file, buff, state->state_length,MYF(MY_NABP)))
  781.     return (MY_FILE_ERROR);
  782.   mi_state_info_read(buff, state);
  783.   return 0;
  784. }
  787. /****************************************************************************
  788. **  store and read of MI_BASE_INFO
  789. ****************************************************************************/
  791. uint mi_base_info_write(File file, MI_BASE_INFO *base)
  792. {
  793.   uchar buff[MI_BASE_INFO_SIZE], *ptr=buff;
  795.   mi_sizestore(ptr,base->keystart); ptr +=8;
  796.   mi_sizestore(ptr,base->max_data_file_length); ptr +=8;
  797.   mi_sizestore(ptr,base->max_key_file_length); ptr +=8;
  798.   mi_rowstore(ptr,base->records); ptr +=8;
  799.   mi_rowstore(ptr,base->reloc); ptr +=8;
  800.   mi_int4store(ptr,base->mean_row_length); ptr +=4;
  801.   mi_int4store(ptr,base->reclength); ptr +=4;
  802.   mi_int4store(ptr,base->pack_reclength); ptr +=4;
  803.   mi_int4store(ptr,base->min_pack_length); ptr +=4;
  804.   mi_int4store(ptr,base->max_pack_length); ptr +=4;
  805.   mi_int4store(ptr,base->min_block_length); ptr +=4;
  806.   mi_int4store(ptr,base->fields); ptr +=4;
  807.   mi_int4store(ptr,base->pack_fields); ptr +=4;
  808.   *ptr++=base->rec_reflength;
  809.   *ptr++=base->key_reflength;
  810.   *ptr++=base->keys;
  811.   *ptr++=base->auto_key;
  812.   mi_int2store(ptr,base->pack_bits); ptr +=2;
  813.   mi_int2store(ptr,base->blobs); ptr +=2;
  814.   mi_int2store(ptr,base->max_key_block_length); ptr +=2;
  815.   mi_int2store(ptr,base->max_key_length); ptr +=2;
  816.   mi_int2store(ptr,base->extra_alloc_bytes); ptr +=2;
  817.   *ptr++= base->extra_alloc_procent;
  818.   *ptr++= base->raid_type;
  819.   mi_int2store(ptr,base->raid_chunks); ptr +=2;
  820.   mi_int4store(ptr,base->raid_chunksize); ptr +=4;
  821.   bzero(ptr,6); ptr +=6; /* extra */
  822.   return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP));
  823. }
  826. char *my_n_base_info_read(char *ptr, MI_BASE_INFO *base)
  827. {
  828.   base->keystart = mi_sizekorr(ptr); ptr +=8;
  829.   base->max_data_file_length = mi_sizekorr(ptr); ptr +=8;
  830.   base->max_key_file_length = mi_sizekorr(ptr); ptr +=8;
  831.   base->records =  (ha_rows) mi_sizekorr(ptr); ptr +=8;
  832.   base->reloc = (ha_rows) mi_sizekorr(ptr); ptr +=8;
  833.   base->mean_row_length = mi_uint4korr(ptr); ptr +=4;
  834.   base->reclength = mi_uint4korr(ptr); ptr +=4;
  835.   base->pack_reclength = mi_uint4korr(ptr); ptr +=4;
  836.   base->min_pack_length = mi_uint4korr(ptr); ptr +=4;
  837.   base->max_pack_length = mi_uint4korr(ptr); ptr +=4;
  838.   base->min_block_length = mi_uint4korr(ptr); ptr +=4;
  839.   base->fields = mi_uint4korr(ptr); ptr +=4;
  840.   base->pack_fields = mi_uint4korr(ptr); ptr +=4;
  842.   base->rec_reflength = *ptr++;
  843.   base->key_reflength = *ptr++;
  844.   base->keys= *ptr++;
  845.   base->auto_key= *ptr++;
  846.   base->pack_bits = mi_uint2korr(ptr); ptr +=2;
  847.   base->blobs = mi_uint2korr(ptr); ptr +=2;
  848.   base->max_key_block_length= mi_uint2korr(ptr); ptr +=2;
  849.   base->max_key_length = mi_uint2korr(ptr); ptr +=2;
  850.   base->extra_alloc_bytes = mi_uint2korr(ptr); ptr +=2;
  851.   base->extra_alloc_procent = *ptr++;
  852.   base->raid_type= *ptr++;
  853.   base->raid_chunks= mi_uint2korr(ptr); ptr +=2;
  854.   base->raid_chunksize= mi_uint4korr(ptr); ptr +=4;
  855.   /* TO BE REMOVED: Fix for old RAID files */
  856.   if (base->raid_type == 0)
  857.   {
  858.     base->raid_chunks=0;
  859.     base->raid_chunksize=0;
  860.   }
  862.   ptr+=6;
  863.   return ptr;
  864. }
  866. /*--------------------------------------------------------------------------
  867.   mi_keydef
  868. ---------------------------------------------------------------------------*/
  870. uint mi_keydef_write(File file, MI_KEYDEF *keydef)
  871. {
  872.   uchar buff[MI_KEYDEF_SIZE];
  873.   uchar *ptr=buff;
  875.   *ptr++ = (uchar) keydef->keysegs;
  876.   *ptr++ = 0; /* not used */
  877.   mi_int2store(ptr,keydef->flag); ptr +=2;
  878.   mi_int2store(ptr,keydef->block_length); ptr +=2;
  879.   mi_int2store(ptr,keydef->keylength); ptr +=2;
  880.   mi_int2store(ptr,keydef->minlength); ptr +=2;
  881.   mi_int2store(ptr,keydef->maxlength); ptr +=2;
  882.   return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP));
  883. }
  885. char *mi_keydef_read(char *ptr, MI_KEYDEF *keydef)
  886. {
  887.    keydef->keysegs = (uint) *ptr++;
  888.    ptr++;
  889.    keydef->flag = mi_uint2korr(ptr); ptr +=2;
  890.    keydef->block_length = mi_uint2korr(ptr); ptr +=2;
  891.    keydef->keylength = mi_uint2korr(ptr); ptr +=2;
  892.    keydef->minlength = mi_uint2korr(ptr); ptr +=2;
  893.    keydef->maxlength = mi_uint2korr(ptr); ptr +=2;
  894.    keydef->block_size = keydef->block_length/MI_KEY_BLOCK_LENGTH-1;
  895.    keydef->underflow_block_length=keydef->block_length/3;
  896.    keydef->version = 0; /* Not saved */
  897.    return ptr;
  898. }
  900. /***************************************************************************
  901. **  mi_keyseg
  902. ***************************************************************************/
  904. int mi_keyseg_write(File file, const MI_KEYSEG *keyseg)
  905. {
  906.   uchar buff[MI_KEYSEG_SIZE];
  907.   uchar *ptr=buff;
  909.   *ptr++ =keyseg->type;
  910.   *ptr++ =keyseg->language;
  911.   *ptr++ =keyseg->null_bit;
  912.   *ptr++ =keyseg->bit_start;
  913.   *ptr++ =keyseg->bit_end;
  914.   *ptr++ =0; /* Not used */
  915.   mi_int2store(ptr,keyseg->flag); ptr+=2;
  916.   mi_int2store(ptr,keyseg->length); ptr+=2;
  917.   mi_int4store(ptr,keyseg->start); ptr+=4;
  918.   mi_int4store(ptr,keyseg->null_pos); ptr+=4;
  920.   return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP));
  921. }
  924. char *mi_keyseg_read(char *ptr, MI_KEYSEG *keyseg)
  925. {
  926.    keyseg->type = *ptr++;
  927.    keyseg->language = *ptr++;
  928.    keyseg->null_bit = *ptr++;
  929.    keyseg->bit_start = *ptr++;
  930.    keyseg->bit_end = *ptr++;
  931.    ptr++;
  932.    keyseg->flag = mi_uint2korr(ptr);  ptr +=2;
  933.    keyseg->length = mi_uint2korr(ptr);  ptr +=2;
  934.    keyseg->start = mi_uint4korr(ptr);  ptr +=4;
  935.    keyseg->null_pos = mi_uint4korr(ptr);  ptr +=4;
  936.    keyseg->charset=0; /* Will be filled in later */
  937.    return ptr;
  938. }
  940. /*--------------------------------------------------------------------------
  941.   mi_uniquedef
  942. ---------------------------------------------------------------------------*/
  944. uint mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
  945. {
  946.   uchar buff[MI_UNIQUEDEF_SIZE];
  947.   uchar *ptr=buff;
  949.   mi_int2store(ptr,def->keysegs); ptr+=2;
  950.   *ptr++=  (uchar) def->key;
  951.   *ptr++ = (uchar) def->null_are_equal;
  953.   return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP));
  954. }
  956. char *mi_uniquedef_read(char *ptr, MI_UNIQUEDEF *def)
  957. {
  958.    def->keysegs = mi_uint2korr(ptr);
  959.    def->key = ptr[2];
  960.    def->null_are_equal=ptr[3];
  961.    return ptr+4; /* 1 extra byte */
  962. }
  964. /***************************************************************************
  965. **  MI_COLUMNDEF
  966. ***************************************************************************/
  968. uint mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
  969. {
  970.   uchar buff[MI_COLUMNDEF_SIZE];
  971.   uchar *ptr=buff;
  973.   mi_int2store(ptr,recinfo->type); ptr +=2;
  974.   mi_int2store(ptr,recinfo->length); ptr +=2;
  975.   *ptr++ = recinfo->null_bit;
  976.   mi_int2store(ptr,recinfo->null_pos); ptr+= 2;
  977.   return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP));
  978. }
  980. char *mi_recinfo_read(char *ptr, MI_COLUMNDEF *recinfo)
  981. {
  982.    recinfo->type=  mi_sint2korr(ptr); ptr +=2;
  983.    recinfo->length=mi_uint2korr(ptr); ptr +=2;
  984.    recinfo->null_bit= (uint8) *ptr++;
  985.    recinfo->null_pos=mi_uint2korr(ptr); ptr +=2;
  986.    return ptr;
  987. }
  989. /**************************************************************************
  990.  ** Help functions for recover
  991.  *************************************************************************/
  993. int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share)
  994. {
  995.   char name_buff[FN_REFLEN];
  996.   (void) fn_format(name_buff, share->filename,"",MI_NAME_DEXT, 2+4);
  998. #ifdef USE_RAID
  999.   if (share->base.raid_type)
  1000.   {
  1001.     if ((info->dfile=my_raid_open(name_buff,
  1002.   share->mode | O_SHARE,
  1003.   share->base.raid_type,
  1004.   share->base.raid_chunks,
  1005.   share->base.raid_chunksize,
  1006.   MYF(MY_WME | MY_RAID))) < 0)
  1007.       return 1;
  1008.   }
  1009.   else
  1010. #endif
  1011.     if ((info->dfile=my_open(name_buff, share->mode | O_SHARE,
  1012.      MYF(MY_WME))) < 0)
  1013.       return 1;
  1014.   return 0;
  1015. }
  1018. int mi_open_keyfile(MYISAM_SHARE *share)
  1019. {
  1020.   if ((share->kfile=my_open(share->filename, share->mode | O_SHARE,
  1021.     MYF(MY_WME))) < 0)
  1022.     return 1;
  1023.   return 0;
  1024. }