diff options
Diffstat (limited to 'isam/open.c')
| -rw-r--r-- | isam/open.c | 455 |
1 files changed, 455 insertions, 0 deletions
diff --git a/isam/open.c b/isam/open.c new file mode 100644 index 00000000000..8a6e0eb5814 --- /dev/null +++ b/isam/open.c @@ -0,0 +1,455 @@ +/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* open a isam-database */ + +#include "isamdef.h" +#if defined(MSDOS) || defined(__WIN__) +#ifdef __WIN__ +#include <fcntl.h> +#else +#include <process.h> /* Prototype for getpid */ +#endif +#endif +#ifdef VMS +#include "static.c" +#endif + +static void setup_functions(ISAM_SHARE *info); +static void setup_key_functions(N_KEYDEF *keyinfo); + +#define get_next_element(to,pos,size) { memcpy((char*) to,pos,(size_t) size); \ + pos+=size;} + +/****************************************************************************** +** Return the shared struct if the table is already open. +** In MySQL the server will handle version issues. +******************************************************************************/ + +static N_INFO *test_if_reopen(char *filename) +{ + LIST *pos; + + for (pos=nisam_open_list ; pos ; pos=pos->next) + { + N_INFO *info=(N_INFO*) pos->data; + ISAM_SHARE *share=info->s; + if (!strcmp(share->filename,filename) && share->last_version) + return info; + } + return 0; +} + + +/****************************************************************************** + open a isam database. + By default exit with error if database is locked + if handle_locking & HA_OPEN_WAIT_IF_LOCKED then wait if database is locked + if handle_locking & HA_OPEN_IGNORE_IF_LOCKED then continue, but count-vars + in st_i_info may be wrong. count-vars are automaticly fixed after next + isam request. +******************************************************************************/ + + +N_INFO *nisam_open(const char *name, int mode, uint handle_locking) +{ + int lock_error,kfile,open_mode,save_errno; + uint i,j,len,errpos,head_length,base_pos,offset,info_length,extra; + char name_buff[FN_REFLEN],*disk_cache,*disk_pos; + N_INFO info,*m_info,*old_info; + ISAM_SHARE share_buff,*share; + DBUG_ENTER("nisam_open"); + + LINT_INIT(m_info); + kfile= -1; + lock_error=1; + errpos=0; + head_length=sizeof(share_buff.state.header); + bzero((byte*) &info,sizeof(info)); + + VOID(fn_format(name_buff,name,"",N_NAME_IEXT,4+16+32)); + pthread_mutex_lock(&THR_LOCK_isam); + if (!(old_info=test_if_reopen(name_buff))) + { + share= &share_buff; + bzero((gptr) &share_buff,sizeof(share_buff)); + + if ((kfile=my_open(name_buff,(open_mode=O_RDWR) | O_SHARE,MYF(0))) < 0) + { + if ((errno != EROFS && errno != EACCES) || + mode != O_RDONLY || + (kfile=my_open(name_buff,(open_mode=O_RDONLY) | O_SHARE,MYF(0))) < 0) + goto err; + } + errpos=1; + if (my_read(kfile,(char*) share->state.header.file_version,head_length, + MYF(MY_NABP))) + goto err; + + if (memcmp((byte*) share->state.header.file_version, + (byte*) nisam_file_magic, 3) || + share->state.header.file_version[3] == 0 || + (uchar) share->state.header.file_version[3] > 3) + { + DBUG_PRINT("error",("Wrong header in %s",name_buff)); + DBUG_DUMP("error_dump",(char*) share->state.header.file_version, + head_length); + my_errno=HA_ERR_CRASHED; + goto err; + } + if (uint2korr(share->state.header.options) & + ~(HA_OPTION_PACK_RECORD | HA_OPTION_PACK_KEYS | + HA_OPTION_COMPRESS_RECORD | HA_OPTION_READ_ONLY_DATA | + HA_OPTION_TEMP_COMPRESS_RECORD)) + { + DBUG_PRINT("error",("wrong options: 0x%lx", + uint2korr(share->state.header.options))); + my_errno=HA_ERR_OLD_FILE; + goto err; + } + info_length=uint2korr(share->state.header.header_length); + base_pos=uint2korr(share->state.header.base_pos); + if (!(disk_cache=(char*) my_alloca(info_length))) + { + my_errno=ENOMEM; + goto err; + } + errpos=2; + + VOID(my_seek(kfile,0L,MY_SEEK_SET,MYF(0))); +#ifndef NO_LOCKING + if (!(handle_locking & HA_OPEN_TMP_TABLE)) + { + if ((lock_error=my_lock(kfile,F_RDLCK,0L,F_TO_EOF, + MYF(handle_locking & HA_OPEN_WAIT_IF_LOCKED ? + 0 : MY_DONT_WAIT))) && + !(handle_locking & HA_OPEN_IGNORE_IF_LOCKED)) + goto err; + } +#endif + errpos=3; + if (my_read(kfile,disk_cache,info_length,MYF(MY_NABP))) + goto err; + len=uint2korr(share->state.header.state_info_length); + if (len != sizeof(N_STATE_INFO)) + { + DBUG_PRINT("warning", + ("saved_state_info_length: %d base_info_length: %d", + len,sizeof(N_STATE_INFO))); + } + if (len > sizeof(N_STATE_INFO)) + len=sizeof(N_STATE_INFO); + share->state_length=len; + memcpy(&share->state.header.file_version[0],disk_cache,(size_t) len); + len=uint2korr(share->state.header.base_info_length); + if (len != sizeof(N_BASE_INFO)) + { + DBUG_PRINT("warning",("saved_base_info_length: %d base_info_length: %d", + len,sizeof(N_BASE_INFO))); + if (len <= offsetof(N_BASE_INFO,sortkey)) + share->base.sortkey=(ushort) ~0; + } + memcpy((char*) (byte*) &share->base,disk_cache+base_pos, + (size_t) min(len,sizeof(N_BASE_INFO))); + disk_pos=disk_cache+base_pos+len; + share->base.options=uint2korr(share->state.header.options); + if (share->base.max_key_length > N_MAX_KEY_BUFF) + { + my_errno=HA_ERR_UNSUPPORTED; + goto err; + } + if (share->base.options & HA_OPTION_COMPRESS_RECORD) + share->base.max_key_length+=2; /* For safety */ + + if (!my_multi_malloc(MY_WME, + &share,sizeof(*share), + &share->keyinfo,share->base.keys*sizeof(N_KEYDEF), + &share->rec,(share->base.fields+1)*sizeof(N_RECINFO), + &share->blobs,sizeof(N_BLOB)*share->base.blobs, + &share->filename,strlen(name_buff)+1, + NullS)) + goto err; + errpos=4; + *share=share_buff; + strmov(share->filename,name_buff); + + /* Fix key in used if old nisam-database */ + if (share->state_length <= offsetof(N_STATE_INFO,keys)) + share->state.keys=share->base.keys; + + share->blocksize=min(IO_SIZE,nisam_block_size); + for (i=0 ; i < share->base.keys ; i++) + { + get_next_element(&share->keyinfo[i].base,disk_pos,sizeof(N_SAVE_KEYDEF)); + setup_key_functions(share->keyinfo+i); + set_if_smaller(share->blocksize,share->keyinfo[i].base.block_length); + for (j=0 ; j <= share->keyinfo[i].base.keysegs ; j++) + { + get_next_element(&share->keyinfo[i].seg[j],disk_pos, + sizeof(N_SAVE_KEYSEG)); + } + } + if (!share->blocksize) + { + my_errno=HA_ERR_CRASHED; + goto err; + } + + for (i=j=offset=0 ; i < share->base.fields ; i++) + { + get_next_element(&share->rec[i].base,disk_pos,sizeof(N_SAVE_RECINFO)); +#ifndef NOT_PACKED_DATABASES + share->rec[i].pack_type=0; + share->rec[i].huff_tree=0; +#endif + if (share->rec[i].base.type == (int) FIELD_BLOB) + { + share->blobs[j].pack_length=share->rec[i].base.length; + share->blobs[j].offset=offset; + j++; + offset+=sizeof(char*); + } + offset+=share->rec[i].base.length; + } + share->rec[i].base.type=(int) FIELD_LAST; + +#ifndef NO_LOCKING + if (! lock_error) + { + VOID(my_lock(kfile,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE))); + lock_error=1; /* Database unlocked */ + } +#endif + + if ((info.dfile=my_open(fn_format(name_buff,name,"",N_NAME_DEXT,2+4), + mode | O_SHARE, + MYF(MY_WME))) < 0) + goto err; + errpos=5; + + share->kfile=kfile; + share->mode=open_mode; + share->this_process=(ulong) getpid(); + share->rnd= (int) share->this_process; /* rnd-counter for splitts */ +#ifndef DBUG_OFF + share->rnd=0; /* To make things repeatable */ +#endif + share->last_process= share->state.process; + if (!(share->last_version=share->state.version)) + share->last_version=1; /* Safety */ + share->rec_reflength=share->base.rec_reflength; /* May be changed */ + + share->data_file_type=STATIC_RECORD; + if (share->base.options & HA_OPTION_COMPRESS_RECORD) + { + share->data_file_type = COMPRESSED_RECORD; + share->base.options|= HA_OPTION_READ_ONLY_DATA; + info.s=share; + if (_nisam_read_pack_info(&info, + (pbool) test(!(share->base.options & + (HA_OPTION_PACK_RECORD | + HA_OPTION_TEMP_COMPRESS_RECORD))))) + goto err; + } + else if (share->base.options & HA_OPTION_PACK_RECORD) + share->data_file_type = DYNAMIC_RECORD; + my_afree((gptr) disk_cache); + setup_functions(share); +#ifdef THREAD + thr_lock_init(&share->lock); + VOID(pthread_mutex_init(&share->intern_lock,NULL)); +#endif + } + else + { + share= old_info->s; + if (mode == O_RDWR && share->mode == O_RDONLY) + { + my_errno=EACCES; /* Can't open in write mode*/ + goto err; + } + if ((info.dfile=my_open(fn_format(name_buff,old_info->filename,"", + N_NAME_DEXT,2+4), + mode | O_SHARE,MYF(MY_WME))) < 0) + { + my_errno=errno; + goto err; + } + errpos=5; + } + + /* alloc and set up private structure parts */ + if (!my_multi_malloc(MY_WME, + &m_info,sizeof(N_INFO), + &info.blobs,sizeof(N_BLOB)*share->base.blobs, + &info.buff,(share->base.max_block*2+ + share->base.max_key_length), + &info.lastkey,share->base.max_key_length*3+1, + &info.filename,strlen(name)+1, + NullS)) + goto err; + errpos=6; + strmov(info.filename,name); + memcpy(info.blobs,share->blobs,sizeof(N_BLOB)*share->base.blobs); + + info.s=share; + info.lastpos= NI_POS_ERROR; + info.update= (short) (HA_STATE_NEXT_FOUND+HA_STATE_PREV_FOUND); + info.opt_flag=READ_CHECK_USED; + info.alloced_rec_buff_length=share->base.pack_reclength; + info.this_uniq= (ulong) info.dfile; /* Uniq number in process */ + info.this_loop=0; /* Update counter */ + info.last_uniq= share->state.uniq; + info.last_loop= share->state.loop; + info.options=share->base.options | + (mode == O_RDONLY ? HA_OPTION_READ_ONLY_DATA : 0); + info.lock_type=F_UNLCK; + info.errkey= -1; + pthread_mutex_lock(&share->intern_lock); + info.read_record=share->read_record; + share->reopen++; + if (share->base.options & HA_OPTION_READ_ONLY_DATA) + { + info.lock_type=F_RDLCK; + share->r_locks++; + info.this_uniq=share->state.uniq; /* Row checksum */ + } +#ifndef NO_LOCKING + if (handle_locking & HA_OPEN_TMP_TABLE) +#endif + { + share->w_locks++; /* We don't have to update status */ + info.lock_type=F_WRLCK; + } + pthread_mutex_unlock(&share->intern_lock); + + /* Allocate buffer for one record */ + + extra=0; + if (share->base.options & HA_OPTION_PACK_RECORD) + extra=ALIGN_SIZE(MAX_DYN_BLOCK_HEADER)+N_SPLITT_LENGTH+ + DYN_DELETE_BLOCK_HEADER; + if (!(info.rec_alloc=(byte*) my_malloc(share->base.pack_reclength+extra+ + 6, + MYF(MY_WME | MY_ZEROFILL)))) + goto err; + if (extra) + info.rec_buff=info.rec_alloc+ALIGN_SIZE(MAX_DYN_BLOCK_HEADER); + else + info.rec_buff=info.rec_alloc; + + *m_info=info; +#ifdef THREAD + thr_lock_data_init(&share->lock,&m_info->lock,NULL); +#endif + + m_info->open_list.data=(void*) m_info; + nisam_open_list=list_add(nisam_open_list,&m_info->open_list); + + pthread_mutex_unlock(&THR_LOCK_isam); + nisam_log_simple(LOG_OPEN,m_info,share->filename, + (uint) strlen(share->filename)); + DBUG_RETURN(m_info); + +err: + save_errno=my_errno ? my_errno : HA_ERR_END_OF_FILE; + switch (errpos) { + case 6: + my_free((gptr) m_info,MYF(0)); + /* fall through */ + case 5: + VOID(my_close(info.dfile,MYF(0))); + if (old_info) + break; /* Don't remove open table */ + /* fall through */ + case 4: + my_free((gptr) share,MYF(0)); + /* fall through */ + case 3: +#ifndef NO_LOCKING + if (! lock_error) + VOID(my_lock(kfile, F_UNLCK, 0L, F_TO_EOF, MYF(MY_SEEK_NOT_DONE))); +#endif + /* fall through */ + case 2: + my_afree((gptr) disk_cache); + /* fall through */ + case 1: + VOID(my_close(kfile,MYF(0))); + /* fall through */ + case 0: + default: + break; + } + pthread_mutex_unlock(&THR_LOCK_isam); + my_errno=save_errno; + DBUG_RETURN (NULL); +} /* nisam_open */ + + + /* Set up functions in structs */ + +static void setup_functions(register ISAM_SHARE *share) +{ + if (share->base.options & HA_OPTION_COMPRESS_RECORD) + { + share->read_record=_nisam_read_pack_record; + share->read_rnd=_nisam_read_rnd_pack_record; + } + else if (share->base.options & HA_OPTION_PACK_RECORD) + { + share->read_record=_nisam_read_dynamic_record; + share->read_rnd=_nisam_read_rnd_dynamic_record; + share->delete_record=_nisam_delete_dynamic_record; + share->compare_record=_nisam_cmp_dynamic_record; + if (share->base.blobs) + { + share->update_record=_nisam_update_blob_record; + share->write_record=_nisam_write_blob_record; + } + else + { + share->write_record=_nisam_write_dynamic_record; + share->update_record=_nisam_update_dynamic_record; + } + } + else + { + share->read_record=_nisam_read_static_record; + share->read_rnd=_nisam_read_rnd_static_record; + share->delete_record=_nisam_delete_static_record; + share->compare_record=_nisam_cmp_static_record; + share->update_record=_nisam_update_static_record; + share->write_record=_nisam_write_static_record; + } + return; +} + + +static void setup_key_functions(register N_KEYDEF *keyinfo) +{ + if (keyinfo->base.flag & (HA_PACK_KEY | HA_SPACE_PACK_USED)) + { + keyinfo->bin_search=_nisam_seq_search; + keyinfo->get_key=_nisam_get_key; + } + else + { + keyinfo->bin_search=_nisam_bin_search; + keyinfo->get_key=_nisam_get_static_key; + } + return; +} |