database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

Removed MARIA_BASE min_row_length (duplicate of min_block_length)

Browse Source 
Cleanup of recent code changes in dbug and my_thr_init
Added name for each safe_mutex (for better DBUG and error reporting)
Fixed that sort_info.max_records is calculated correctly. This fixed a bug in maria_chk
Removed duplicate printing of mutex address in dbug log


dbug/dbug.c:
  Cleanup of recent code changes
include/my_pthread.h:
  Added name for each safe_mutex (for better DBUG and error reporting)
mysys/my_thr_init.c:
  Cleanup of recent code changes
mysys/thr_mutex.c:
  Added name for each safe_mutex (for better DBUG and error reporting)
mysys/wqueue.c:
  Removed some mutex printing (as it's done now when we take mutex)
storage/maria/Makefile.am:
  Fixed that 'make tags' works with xemacs
storage/maria/ma_blockrec.c:
  base.min_row_length -> base.min_block_length
  (As they where basicly the same variable)
storage/maria/ma_check.c:
  Moved more common stuff to initialize_variables_for_repair
  Fixed that sort_info.max_records is calculated correctly. This fixed a bug in maria_chk
storage/maria/ma_create.c:
  More comments
  Fixed that min_pack_length is calculated more correctly
  Removed duplicate variable base.min_row_length
storage/maria/ma_loghandler.c:
  Removed duplicate printing of mutex address
storage/maria/ma_open.c:
  Removed base.min_row_length
storage/maria/ma_packrec.c:
  Removed not anymore needed code
  (One should not change any .base variables as this will affect repair with unpack)
storage/maria/maria_def.h:
  Removed base.min_row_length
This commit is contained in:
unknown
2007-12-12 23:57:28 +02:00
parent e8b0bb4769
commit 8224c76fbd
13 changed files with 181 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
dbug/dbug.c
View File

@ -330,8 +330,7 @@ static pthread_mutex_t THR_LOCK_dbug;
static CODE_STATE *code_state(void)
{
CODE_STATE *cs=0;
my_bool error;
CODE_STATE *cs, **cs_ptr;
if (!init_done)
{
@ -342,7 +341,9 @@ static CODE_STATE *code_state(void)
init_done=TRUE;
}
if (!(cs= (CODE_STATE*) my_thread_var_get_dbug(&error)) && !error)
if (!(cs_ptr= (CODE_STATE**) my_thread_var_dbug()))
return 0; /* Thread not initialised */
if (!(cs= *cs_ptr))
{
cs=(CODE_STATE*) DbugMalloc(sizeof(*cs));
bzero((uchar*) cs,sizeof(*cs));
@ -350,7 +351,7 @@ static CODE_STATE *code_state(void)
cs->func="?func";
cs->file="?file";
cs->stack=&init_settings;
my_thread_var_set_dbug((void*) cs);
*cs_ptr= cs;
}
return cs;
}

9
include/my_pthread.h
View File

@ -446,7 +446,7 @@ int my_pthread_mutex_trylock(pthread_mutex_t *mutex);
typedef struct st_safe_mutex_t
{
pthread_mutex_t global,mutex;
const char *file;
const char *file, *name;
uint line,count;
pthread_t thread;
#ifdef SAFE_MUTEX_DETECT_DESTROY
@ -471,7 +471,7 @@ typedef struct st_safe_mutex_info_t
#endif /* SAFE_MUTEX_DETECT_DESTROY */
int safe_mutex_init(safe_mutex_t *mp, const pthread_mutexattr_t *attr,
const char *file, uint line);
const char *file, uint line, const char *name);
int safe_mutex_lock(safe_mutex_t *mp,const char *file, uint line);
int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line);
int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint line);
@ -494,7 +494,7 @@ void safe_mutex_end(FILE *file);
#undef pthread_cond_wait
#undef pthread_cond_timedwait
#undef pthread_mutex_trylock
#define pthread_mutex_init(A,B) safe_mutex_init((A),(B),__FILE__,__LINE__)
#define pthread_mutex_init(A,B) safe_mutex_init((A),(B),__FILE__,__LINE__,#A)
#define pthread_mutex_lock(A) safe_mutex_lock((A),__FILE__,__LINE__)
#define pthread_mutex_unlock(A) safe_mutex_unlock((A),__FILE__,__LINE__)
#define pthread_mutex_destroy(A) safe_mutex_destroy((A),__FILE__,__LINE__)
@ -680,8 +680,7 @@ struct st_my_thread_var
};
extern struct st_my_thread_var *_my_thread_var(void) __attribute__ ((const));
extern void *my_thread_var_get_dbug(my_bool *error);
extern void my_thread_var_set_dbug(void *dbug);
extern void **my_thread_var_dbug();
extern uint my_thread_end_wait_time;
#define my_thread_var (_my_thread_var())
#define my_errno my_thread_var->thr_errno

20
mysys/my_thr_init.c
View File

@ -386,27 +386,13 @@ struct st_my_thread_var *_my_thread_var(void)
}
#ifndef DBUG_OFF
/* Return pointer to DBUG for holding current state */
extern void *my_thread_var_get_dbug(my_bool *error)
extern void **my_thread_var_dbug()
{
struct st_my_thread_var *tmp=
my_pthread_getspecific(struct st_my_thread_var*,THR_KEY_mysys);
my_bool tmp_error;
if (!error)
error= &tmp_error;
if (tmp)
{
*error= 0;
return tmp->dbug;
}
*error= 1; /* no THR_KEY_mysys */
return (void*) 0;
}
extern void my_thread_var_set_dbug(void *dbug)
{
struct st_my_thread_var *tmp= _my_thread_var();
tmp->dbug= dbug;
return tmp ? &tmp->dbug : 0;
}
#endif

90
mysys/thr_mutex.c
View File

@ -54,7 +54,7 @@ void safe_mutex_global_init(void)
int safe_mutex_init(safe_mutex_t *mp,
const pthread_mutexattr_t *attr __attribute__((unused)),
const char *file,
uint line)
uint line, const char *name)
{
bzero((char*) mp,sizeof(*mp));
pthread_mutex_init(&mp->global,MY_MUTEX_INIT_ERRCHK);
@ -62,6 +62,8 @@ int safe_mutex_init(safe_mutex_t *mp,
/* Mark that mutex is initialized */
mp->file= file;
mp->line= line;
/* Skip the very common '&' prefix from the autogenerated name */
mp->name= name[0] == '&' ? name + 1 : name;
#ifdef SAFE_MUTEX_DETECT_DESTROY
/*
@ -94,10 +96,8 @@ int safe_mutex_init(safe_mutex_t *mp,
int safe_mutex_lock(safe_mutex_t *mp,const char *file, uint line)
{
int error;
#ifndef DBUG_OFF
if (my_thread_var_get_dbug((my_bool*) 0))
DBUG_PRINT("mutex", ("0x%lx locking", (ulong) mp));
#endif
DBUG_PRINT("mutex", ("%s (0x%lx) locking", mp->name ? mp->name : "Null",
(ulong) mp));
if (!mp->file)
{
fprintf(stderr,
@ -110,8 +110,8 @@ int safe_mutex_lock(safe_mutex_t *mp,const char *file, uint line)
pthread_mutex_lock(&mp->global);
if (mp->count > 0 && pthread_equal(pthread_self(),mp->thread))
{
fprintf(stderr,"safe_mutex: Trying to lock mutex at %s, line %d, when the mutex was already locked at %s, line %d in thread %s\n",
file,line,mp->file, mp->line, my_thread_name());
fprintf(stderr,"safe_mutex: Trying to lock mutex %s at %s, line %d, when the mutex was already locked at %s, line %d in thread %s\n",
mp->name, file,line,mp->file, mp->line, my_thread_name());
fflush(stderr);
abort();
}
@ -119,26 +119,23 @@ int safe_mutex_lock(safe_mutex_t *mp,const char *file, uint line)
error=pthread_mutex_lock(&mp->mutex);
if (error || (error=pthread_mutex_lock(&mp->global)))
{
fprintf(stderr,"Got error %d when trying to lock mutex at %s, line %d\n",
error, file, line);
fprintf(stderr,"Got error %d when trying to lock mutex %s at %s, line %d\n",
error, mp->name, file, line);
fflush(stderr);
abort();
}
mp->thread= pthread_self();
if (mp->count++)
{
fprintf(stderr,"safe_mutex: Error in thread libray: Got mutex at %s, \
line %d more than 1 time\n", file,line);
fprintf(stderr,"safe_mutex: Error in thread libray: Got mutex %s at %s, "
"line %d more than 1 time\n", mp->name, file,line);
fflush(stderr);
abort();
}
mp->file= file;
mp->line=line;
mp->line= line;
pthread_mutex_unlock(&mp->global);
#ifndef DBUG_OFF
if (my_thread_var_get_dbug((my_bool*) 0))
DBUG_PRINT("mutex", ("0x%lx locked", (ulong) mp));
#endif
DBUG_PRINT("mutex", ("%s (0x%lx) locked", mp->name, (ulong) mp));
return error;
}
@ -146,22 +143,22 @@ line %d more than 1 time\n", file,line);
int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line)
{
int error;
#ifndef DBUG_OFF
if (my_thread_var_get_dbug((my_bool*) 0))
DBUG_PRINT("mutex", ("0x%lx unlocking", (ulong) mp));
#endif
DBUG_PRINT("mutex", ("%s (0x%lx) unlocking", mp->name, (ulong) mp));
pthread_mutex_lock(&mp->global);
if (mp->count == 0)
{
fprintf(stderr,"safe_mutex: Trying to unlock mutex that wasn't locked at %s, line %d\n Last used at %s, line: %d\n",
file,line,mp->file ? mp->file : "",mp->line);
fprintf(stderr,"safe_mutex: Trying to unlock mutex %s that wasn't locked at %s, line %d\n"
"Last used at %s, line: %d\n",
mp->name ? mp->name : "Null", file, line,
mp->file ? mp->file : "Null", mp->line);
fflush(stderr);
abort();
}
if (!pthread_equal(pthread_self(),mp->thread))
{
fprintf(stderr,"safe_mutex: Trying to unlock mutex at %s, line %d that was locked by another thread at: %s, line: %d\n",
file,line,mp->file,mp->line);
fprintf(stderr,"safe_mutex: Trying to unlock mutex %s at %s, line %d that was locked by "
"another thread at: %s, line: %d\n",
mp->name, file, line, mp->file, mp->line);
fflush(stderr);
abort();
}
@ -174,7 +171,8 @@ int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line)
error=pthread_mutex_unlock(&mp->mutex);
if (error)
{
fprintf(stderr,"safe_mutex: Got error: %d (%d) when trying to unlock mutex at %s, line %d\n", error, errno, file, line);
fprintf(stderr,"safe_mutex: Got error: %d (%d) when trying to unlock mutex %s at %s, "
"line %d\n", error, errno, mp->name, file, line);
fflush(stderr);
abort();
}
@ -191,22 +189,24 @@ int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp, const char *file,
pthread_mutex_lock(&mp->global);
if (mp->count == 0)
{
fprintf(stderr,"safe_mutex: Trying to cond_wait on a unlocked mutex at %s, line %d\n",file,line);
fprintf(stderr,"safe_mutex: Trying to cond_wait on a unlocked mutex %s at %s, line %d\n",
mp->name ? mp->name : "Null", file, line);
fflush(stderr);
abort();
}
if (!pthread_equal(pthread_self(),mp->thread))
{
fprintf(stderr,"safe_mutex: Trying to cond_wait on a mutex at %s, line %d that was locked by another thread at: %s, line: %d\n",
file,line,mp->file,mp->line);
fprintf(stderr,"safe_mutex: Trying to cond_wait on a mutex %s at %s, line %d that was "
"locked by another thread at: %s, line: %d\n",
mp->name, file, line, mp->file, mp->line);
fflush(stderr);
abort();
}
if (mp->count-- != 1)
{
fprintf(stderr,"safe_mutex: Count was %d on locked mutex at %s, line %d\n",
mp->count+1, file, line);
fprintf(stderr,"safe_mutex: Count was %d on locked mutex %s at %s, line %d\n",
mp->count+1, mp->name, file, line);
fflush(stderr);
abort();
}
@ -215,7 +215,8 @@ int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp, const char *file,
pthread_mutex_lock(&mp->global);
if (error)
{
fprintf(stderr,"safe_mutex: Got error: %d (%d) when doing a safe_mutex_wait at %s, line %d\n", error, errno, file, line);
fprintf(stderr,"safe_mutex: Got error: %d (%d) when doing a safe_mutex_wait on %s at %s, "
"line %d\n", error, errno, mp->name, file, line);
fflush(stderr);
abort();
}
@ -223,8 +224,8 @@ int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp, const char *file,
if (mp->count++)
{
fprintf(stderr,
"safe_mutex: Count was %d in thread 0x%lx when locking mutex at %s, line %d\n",
mp->count-1, my_thread_dbug_id(), file, line);
"safe_mutex: Count was %d in thread 0x%lx when locking mutex %s at %s, line %d\n",
mp->count-1, my_thread_dbug_id(), mp->name, file, line);
fflush(stderr);
abort();
}
@ -243,7 +244,8 @@ int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,
pthread_mutex_lock(&mp->global);
if (mp->count != 1 || !pthread_equal(pthread_self(),mp->thread))
{
fprintf(stderr,"safe_mutex: Trying to cond_wait at %s, line %d on a not hold mutex\n",file,line);
fprintf(stderr,"safe_mutex: Trying to cond_wait at %s, line %d on a not hold mutex %s\n",
file, line, mp->name ? mp->name : "Null");
fflush(stderr);
abort();
}
@ -253,7 +255,10 @@ int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,
#ifdef EXTRA_DEBUG
if (error && (error != EINTR && error != ETIMEDOUT && error != ETIME))
{
fprintf(stderr,"safe_mutex: Got error: %d (%d) when doing a safe_mutex_timedwait at %s, line %d\n", error, errno, file, line);
fprintf(stderr,
"safe_mutex: Got error: %d (%d) when doing a safe_mutex_timedwait on %s at %s, "
"line %d\n",
error, errno, mp->name, file, line);
}
#endif
pthread_mutex_lock(&mp->global);
@ -261,8 +266,10 @@ int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,
if (mp->count++)
{
fprintf(stderr,
"safe_mutex: Count was %d in thread 0x%lx when locking mutex at %s, line %d (error: %d (%d))\n",
mp->count-1, my_thread_dbug_id(), file, line, error, error);
"safe_mutex: Count was %d in thread 0x%lx when locking mutex %s at %s, line %d "
"(error: %d (%d))\n",
mp->count-1, my_thread_dbug_id(), mp->name, file, line,
error, error);
fflush(stderr);
abort();
}
@ -286,8 +293,9 @@ int safe_mutex_destroy(safe_mutex_t *mp, const char *file, uint line)
}
if (mp->count != 0)
{
fprintf(stderr,"safe_mutex: Trying to destroy a mutex that was locked at %s, line %d at %s, line %d\n",
mp->file,mp->line, file, line);
fprintf(stderr,"safe_mutex: Trying to destroy a mutex %s that was locked at %s, "
"line %d at %s, line %d\n",
mp->name, mp->file, mp->line, file, line);
fflush(stderr);
abort();
}
@ -359,8 +367,8 @@ void safe_mutex_end(FILE *file __attribute__((unused)))
struct st_safe_mutex_info_t *ptr;
for (ptr= safe_mutex_root ; ptr ; ptr= ptr->next)
{
fprintf(file, "\tMutex initiated at line %4u in '%s'\n",
ptr->init_line, ptr->init_file);
fprintf(file, "\tMutex %s initiated at line %4u in '%s'\n",
ptr->name, ptr->init_line, ptr->init_file);
(void) fflush(file);
}
}

10
mysys/wqueue.c
View File

@ -147,18 +147,20 @@ void wqueue_release_queue(WQUEUE *wqueue)
*/
void wqueue_add_and_wait(WQUEUE *wqueue,
struct st_my_thread_var *thread, pthread_mutex_t *lock)
struct st_my_thread_var *thread,
pthread_mutex_t *lock)
{
DBUG_ENTER("wqueue_add_and_wait");
DBUG_PRINT("enter", ("thread ox%lxcond 0x%lx, mutex 0x%lx",
DBUG_PRINT("enter",
("thread: 0x%lx cond: 0x%lx mutex: 0x%lx",
(ulong) thread, (ulong) &thread->suspend, (ulong) lock));
wqueue_add_to_queue(wqueue, thread);
do
{
DBUG_PRINT("info", ("wait... cond 0x%lx, mutex 0x%lx",
DBUG_PRINT("info", ("wait... cond: 0x%lx mutex: 0x%lx",
(ulong) &thread->suspend, (ulong) lock));
pthread_cond_wait(&thread->suspend, lock);
DBUG_PRINT("info", ("wait done cond 0x%lx, mutex 0x%lx, next 0x%lx",
DBUG_PRINT("info", ("wait done cond: 0x%lx mutex: 0x%lx next: 0x%lx",
(ulong) &thread->suspend, (ulong) lock,
(ulong) thread->next));
}

3
storage/maria/Makefile.am
View File

@ -169,5 +169,8 @@ SUFFIXES = .sh
@CHMOD@ +x $@-t
@MV@ $@-t $@
tags:
etags *.h *.c *.cc
# Don't update the files from bitkeeper
%::SCCS/s.%

21
storage/maria/ma_blockrec.c
View File

@ -1060,8 +1060,8 @@ static void calc_record_size(MARIA_HA *info, const uchar *record,
row->normal_length +
row->char_length + row->varchar_length);
row->total_length= (row->head_length + row->blob_length);
if (row->total_length < share->base.min_row_length)
row->total_length= share->base.min_row_length;
if (row->total_length < share->base.min_block_length)
row->total_length= share->base.min_block_length;
DBUG_PRINT("exit", ("head_length: %lu total_length: %lu",
(ulong) row->head_length, (ulong) row->total_length));
DBUG_VOID_RETURN;
@ -2085,12 +2085,13 @@ static my_bool write_block_record(MARIA_HA *info,
uint length= (uint) (data - row_pos->data);
DBUG_PRINT("info", ("Used head length on page: %u", length));
DBUG_ASSERT(data <= end_of_data);
if (length < info->s->base.min_row_length)
if (length < info->s->base.min_block_length)
{
uint diff_length= info->s->base.min_row_length - length;
/* Extend row to be of size min_block_length */
uint diff_length= info->s->base.min_block_length - length;
bzero(data, diff_length);
data+= diff_length;
length= info->s->base.min_row_length;
length= info->s->base.min_block_length;
}
int2store(row_pos->dir + 2, length);
/* update empty space at start of block */
@ -3541,7 +3542,7 @@ static my_bool read_long_data(MARIA_HA *info, uchar *to, ulong length,
Fields are never split in middle. This means that if length > rest-of-data
we should start reading from the next extent. The reason we may have
data left on the page is that if the fixed part of the row was less than
min_row_length the head block was extended to min_row_length.
min_block_length the head block was extended to min_block_length.
This may change in the future, which is why we have the loop written
the way it's written.
@ -3872,11 +3873,11 @@ int _ma_read_block_record2(MARIA_HA *info, uchar *record,
DBUG_PRINT("info", ("Row read"));
/*
data should normally point to end_of_date. The only exception is if
the row is very short in which case we allocated 'min_row_length' data
the row is very short in which case we allocated 'min_block_length' data
for allowing the row to expand.
*/
if (data != end_of_data && (uint) (end_of_data - start_of_data) >
info->s->base.min_row_length)
info->s->base.min_block_length)
goto err;
}
@ -5794,8 +5795,8 @@ my_bool _ma_apply_undo_row_delete(MARIA_HA *info, LSN undo_lsn,
row.normal_length +
row.char_length + row.varchar_length);
row.total_length= (row.head_length + row.blob_length);
if (row.total_length < share->base.min_row_length)
row.total_length= share->base.min_row_length;
if (row.total_length < share->base.min_block_length)
row.total_length= share->base.min_block_length;
/* Row is now up to date. Time to insert the record */

138
storage/maria/ma_check.c
View File

@ -2049,24 +2049,26 @@ int maria_chk_data_link(HA_CHECK *param, MARIA_HA *info,int extend)
@brief Initialize variables for repair
*/
static void initialize_variables_for_repair(HA_CHECK *param,
static int initialize_variables_for_repair(HA_CHECK *param,
MARIA_SORT_INFO *sort_info,
MARIA_SORT_PARAM *sort_param,
MARIA_HA *info,
uint rep_quick)
{
bzero((char *) sort_info, sizeof(*sort_info));
bzero((char *) sort_param, sizeof(*sort_param));
MARIA_SHARE *share= info->s;
bzero((char*) sort_info, sizeof(*sort_info));
bzero((char*) sort_param, sizeof(*sort_param));
param->testflag|= T_REP; /* for easy checking */
if (info->s->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))
if (share->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))
param->testflag|= T_CALC_CHECKSUM;
param->glob_crc= 0;
if (rep_quick)
param->testflag|= T_QUICK;
else
param->testflag&= ~T_QUICK;
param->org_key_map= info->s->state.key_map;
param->org_key_map= share->state.key_map;
sort_param->sort_info= sort_info;
sort_param->fix_datafile= (my_bool) (! rep_quick);
@ -2074,11 +2076,38 @@ static void initialize_variables_for_repair(HA_CHECK *param,
sort_info->info= sort_info->new_info= info;
sort_info->param= param;
set_data_file_type(sort_info, info->s);
sort_info->org_data_file_type= info->s->data_file_type;
sort_info->org_data_file_type= share->data_file_type;
bzero(&info->rec_cache, sizeof(info->rec_cache));
info->rec_cache.file= info->dfile.file;
info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
/* calculate max_records */
/*
The physical size of the data file is sometimes used during repair (see
sort_info.filelength further below); We need to flush to have it exact.
We flush the state because our maria_open(HA_OPEN_COPY) will want to read
it from disk. Index file will be recreated.
*/
if (_ma_flush_table_files(info, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
FLUSH_FORCE_WRITE,
(param->testflag & T_CREATE_MISSING_KEYS) ?
FLUSH_FORCE_WRITE : FLUSH_IGNORE_CHANGED) ||
(share->changed && _ma_state_info_write(share, 1|2|4)))
return(1);
sort_info->filelength= my_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0));
if ((param->testflag & T_CREATE_MISSING_KEYS) ||
sort_info->org_data_file_type == COMPRESSED_RECORD)
sort_info->max_records= info->state->records;
else
{
ulong rec_length;
rec_length= max(share->base.min_pack_length,
share->base.min_block_length);
sort_info->max_records= (ha_rows) (sort_info->filelength / rec_length);
}
return 0;
}
@ -2107,7 +2136,7 @@ static void initialize_variables_for_repair(HA_CHECK *param,
int maria_repair(HA_CHECK *param, register MARIA_HA *info,
char *name, uint rep_quick)
{
int error, got_error= 1;
int error, got_error;
uint i;
ha_rows start_records,new_header_length;
my_off_t del;
@ -2122,30 +2151,22 @@ int maria_repair(HA_CHECK *param, register MARIA_HA *info,
MY_SYNC_DIR : 0);
DBUG_ENTER("maria_repair");
initialize_variables_for_repair(param, &sort_info, &sort_param, info,
rep_quick);
start_records=info->state->records;
new_header_length= ((param->testflag & T_UNPACK) ? 0L :
share->pack.header_length);
got_error= 1;
new_file= -1;
start_records= info->state->records;
if (!(param->testflag & T_SILENT))
{
printf("- recovering (with keycache) MARIA-table '%s'\n",name);
printf("Data records: %s\n", llstr(info->state->records,llbuff));
printf("Data records: %s\n", llstr(start_records, llbuff));
}
/*
The physical size of the data file is sometimes used during repair (see
sort_info.filelength further below); we need to flush to have it exact.
We flush the state because our maria_open(HA_OPEN_COPY) will want to read
it from disk. Index file will be recreated.
*/
if (_ma_flush_table_files(info, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
FLUSH_FORCE_WRITE, FLUSH_IGNORE_CHANGED) ||
_ma_state_info_write(share, 1|2|4))
if (initialize_variables_for_repair(param, &sort_info, &sort_param, info,
rep_quick))
goto err;
new_header_length= ((param->testflag & T_UNPACK) ? 0L :
share->pack.header_length);
if (!rep_quick)
{
/* Get real path for data file */
@ -2216,8 +2237,7 @@ int maria_repair(HA_CHECK *param, register MARIA_HA *info,
sort_param.read_cache=param->read_cache;
sort_param.pos=sort_param.max_pos=share->pack.header_length;
sort_param.filepos=new_header_length;
param->read_cache.end_of_file= sort_info.filelength=
my_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0));
param->read_cache.end_of_file= sort_info.filelength;
sort_param.master=1;
sort_info.max_records= ~(ha_rows) 0;
@ -2881,7 +2901,6 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
{
int got_error;
uint i;
ulong length;
ha_rows start_records;
my_off_t new_header_length, org_header_length, del;
File new_file;
@ -2897,29 +2916,23 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
my_bool scan_inited= 0;
DBUG_ENTER("maria_repair_by_sort");
start_records= info->state->records;
initialize_variables_for_repair(param, &sort_info, &sort_param, info,
rep_quick);
got_error=1;
got_error= 1;
new_file= -1;
org_header_length= share->pack.header_length;
new_header_length= (param->testflag & T_UNPACK) ? 0 : org_header_length;
sort_param.filepos= new_header_length;
start_records= info->state->records;
if (!(param->testflag & T_SILENT))
{
printf("- recovering (with sort) MARIA-table '%s'\n",name);
printf("Data records: %s\n", llstr(start_records,llbuff));
}
/* Flushing of keys is done later */
if (_ma_flush_table_files(info, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
FLUSH_FORCE_WRITE,
(param->testflag & T_CREATE_MISSING_KEYS) ?
FLUSH_FORCE_WRITE : FLUSH_IGNORE_CHANGED) ||
_ma_state_info_write(share, 1|2|4))
if (initialize_variables_for_repair(param, &sort_info, &sort_param, info,
rep_quick))
goto err;
org_header_length= share->pack.header_length;
new_header_length= (param->testflag & T_UNPACK) ? 0 : org_header_length;
sort_param.filepos= new_header_length;
if (!rep_quick)
{
/* Get real path for data file */
@ -2998,21 +3011,10 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
else
key_map= ~key_map; /* Create the missing keys */
param->read_cache.end_of_file= sort_info.filelength=
my_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0));
param->read_cache.end_of_file= sort_info.filelength;
sort_param.wordlist=NULL;
init_alloc_root(&sort_param.wordroot, FTPARSER_MEMROOT_ALLOC_SIZE, 0);
if (sort_info.org_data_file_type == DYNAMIC_RECORD)
length=max(share->base.min_pack_length+1,share->base.min_block_length);
else if (sort_info.org_data_file_type == COMPRESSED_RECORD)
length=share->base.min_block_length;
else
length=share->base.pack_reclength;
sort_info.max_records=
((param->testflag & T_CREATE_MISSING_KEYS) ? info->state->records :
(ha_rows) (sort_info.filelength/length+1));
sort_param.key_cmp=sort_key_cmp;
sort_param.lock_in_memory=maria_lock_memory;
sort_param.tmpdir=param->tmpdir;
@ -3352,7 +3354,6 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
#else
int got_error;
uint i,key, total_key_length, istep;
ulong rec_length;
ha_rows start_records;
my_off_t new_header_length,del;
File new_file;
@ -3370,24 +3371,22 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
MY_SYNC_DIR : 0;
DBUG_ENTER("maria_repair_parallel");
initialize_variables_for_repair(param, &sort_info, &tmp_sort_param, info,
rep_quick);
start_records=info->state->records;
got_error=1;
got_error= 1;
new_file= -1;
new_header_length=(param->testflag & T_UNPACK) ? 0 :
share->pack.header_length;
start_records= info->state->records;
if (!(param->testflag & T_SILENT))
{
printf("- parallel recovering (with sort) MARIA-table '%s'\n",name);
printf("Data records: %s\n", llstr(start_records,llbuff));
printf("Data records: %s\n", llstr(start_records, llbuff));
}
if (_ma_flush_table_files(info, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
FLUSH_FORCE_WRITE, FLUSH_IGNORE_CHANGED))
if (initialize_variables_for_repair(param, &sort_info, &tmp_sort_param, info,
rep_quick))
goto err;
new_header_length= ((param->testflag & T_UNPACK) ? 0 :
share->pack.header_length);
/*
Quick repair (not touching data file, rebuilding indexes):
{
@ -3489,15 +3488,8 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
key_map= ~key_map; /* Create the missing keys */
}
param->read_cache.end_of_file= sort_info.filelength=
my_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0));
param->read_cache.end_of_file= sort_info.filelength;
if (sort_info.org_data_file_type == DYNAMIC_RECORD)
rec_length=max(share->base.min_pack_length+1,share->base.min_block_length);
else if (sort_info.org_data_file_type == COMPRESSED_RECORD)
rec_length=share->base.min_block_length;
else
rec_length=share->base.pack_reclength;
/*
+1 below is required hack for parallel repair mode.
The info->state->records value, that is compared later
@ -3510,9 +3502,7 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
May be sort_info.max_records shold be always set to max value in
parallel mode.
*/
sort_info.max_records=
((param->testflag & T_CREATE_MISSING_KEYS) ? info->state->records + 1:
(ha_rows) (sort_info.filelength/rec_length+1));
sort_info.max_records++;
del=info->state->del;

18
storage/maria/ma_create.c
View File

@ -205,7 +205,10 @@ int maria_create(const char *name, enum data_file_type datafile_type,
if (!column->null_bit)
min_pack_length+= column->length;
else
{
/* Only BLOCK_RECORD skips NULL fields for all field values */
not_block_record_extra_length+= column->length;
}
column->empty_pos= 0;
column->empty_bit= 0;
}
@ -237,11 +240,13 @@ int maria_create(const char *name, enum data_file_type datafile_type,
/* We can't use checksum with static length rows */
flags&= ~HA_CREATE_CHECKSUM;
options&= ~HA_OPTION_CHECKSUM;
min_pack_length+= varchar_length;
min_pack_length= reclength;
packed= 0;
}
if (datafile_type != BLOCK_RECORD)
else if (datafile_type != BLOCK_RECORD)
min_pack_length+= not_block_record_extra_length;
else
min_pack_length+= 5; /* Min row overhead */
if ((packed & 7) == 1)
{
@ -311,7 +316,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
extra_header_size= TRANS_MAX_FIXED_HEADER_SIZE;
DBUG_PRINT("info",("creating a transactional table"));
}
share.base.min_row_length= (extra_header_size + share.base.null_bytes +
share.base.min_block_length= (extra_header_size + share.base.null_bytes +
pack_bytes);
if (!ci->data_file_length && ci->max_rows)
{
@ -731,9 +736,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
sync_dir= MY_SYNC_DIR;
}
if (datafile_type == BLOCK_RECORD)
share.base.min_block_length= share.base.min_row_length;
else
if (datafile_type == DYNAMIC_RECORD)
{
share.base.min_block_length=
(share.base.pack_reclength+3 < MARIA_EXTEND_BLOCK_LENGTH &&
@ -741,6 +744,9 @@ int maria_create(const char *name, enum data_file_type datafile_type,
max(share.base.pack_reclength,MARIA_MIN_BLOCK_LENGTH) :
MARIA_EXTEND_BLOCK_LENGTH;
}
else if (datafile_type == STATIC_RECORD)
share.base.min_block_length= share.base.pack_reclength;
if (! (flags & HA_DONT_TOUCH_DATA))
share.state.create_time= (long) time((time_t*) 0);

48
storage/maria/ma_loghandler.c
View File

@ -1251,14 +1251,13 @@ static my_bool translog_create_new_file()
#ifndef DBUG_OFF
static my_bool translog_buffer_lock(struct st_translog_buffer *buffer)
{
int res;
my_bool res;
DBUG_ENTER("translog_buffer_lock");
DBUG_PRINT("enter",
("Lock buffer #%u: (0x%lx) mutex: 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer,
(ulong) &buffer->mutex));
("Lock buffer #%u: (0x%lx)", (uint) buffer->buffer_no,
(ulong) buffer));
res= (pthread_mutex_lock(&buffer->mutex) != 0);
DBUG_RETURN(test(res));
DBUG_RETURN(res);
}
#else
#define translog_buffer_lock(B) \
@ -1281,17 +1280,12 @@ static my_bool translog_buffer_lock(struct st_translog_buffer *buffer)
#ifndef DBUG_OFF
static my_bool translog_buffer_unlock(struct st_translog_buffer *buffer)
{
int res;
my_bool res;
DBUG_ENTER("translog_buffer_unlock");
DBUG_PRINT("enter", ("Unlock buffer... #%u (0x%lx) "
"mutex: 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer,
(ulong) &buffer->mutex));
DBUG_PRINT("enter", ("Unlock buffer... #%u (0x%lx)",
(uint) buffer->buffer_no, (ulong) buffer));
res= (pthread_mutex_unlock(&buffer->mutex) != 0);
DBUG_PRINT("exit", ("Unlocked buffer... #%u: 0x%lx mutex: 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer,
(ulong) &buffer->mutex));
DBUG_RETURN(res);
}
#else
@ -1550,19 +1544,13 @@ static void translog_wait_for_writers(struct st_translog_buffer *buffer)
while (buffer->copy_to_buffer_in_progress)
{
DBUG_PRINT("info", ("wait for writers... "
"buffer: #%u 0x%lx "
"mutex: 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer,
(ulong) &buffer->mutex));
DBUG_PRINT("info", ("wait for writers... buffer: #%u 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer));
DBUG_ASSERT(buffer->file != -1);
wqueue_add_and_wait(&buffer->waiting_filling_buffer, thread,
&buffer->mutex);
DBUG_PRINT("info", ("wait for writers done "
"buffer: #%u 0x%lx "
"mutex: 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer,
(ulong) &buffer->mutex));
DBUG_PRINT("info", ("wait for writers done buffer: #%u 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer));
}
DBUG_VOID_RETURN;
@ -1595,18 +1583,12 @@ static void translog_wait_for_buffer_free(struct st_translog_buffer *buffer)
while (buffer->file != -1)
{
DBUG_PRINT("info", ("wait for writers... "
"buffer: #%u 0x%lx "
"mutex: 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer,
(ulong) &buffer->mutex));
DBUG_PRINT("info", ("wait for writers... buffer: #%u 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer));
wqueue_add_and_wait(&buffer->waiting_filling_buffer, thread,
&buffer->mutex);
DBUG_PRINT("info", ("wait for writers done. "
"buffer: #%u 0x%lx "
"mutex: 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer,
(ulong) &buffer->mutex));
DBUG_PRINT("info", ("wait for writers done. buffer: #%u 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer));
}
DBUG_ASSERT(buffer->copy_to_buffer_in_progress == 0);
DBUG_VOID_RETURN;

6
storage/maria/ma_open.c
View File

@ -495,7 +495,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags)
strmov(share->data_file_name, data_name);
strmov(share->open_file_name, name);
share->block_size= share->base.block_size;
share->block_size= share->base.block_size; /* Convenience */
{
HA_KEYSEG *pos=share->keyparts;
for (i=0 ; i < keys ; i++)
@ -1287,7 +1287,7 @@ uint _ma_base_info_write(File file, MARIA_BASE_INFO *base)
mi_int2store(ptr,base->null_bytes); ptr+= 2;
mi_int2store(ptr,base->original_null_bytes); ptr+= 2;
mi_int2store(ptr,base->field_offsets); ptr+= 2;
mi_int2store(ptr,base->min_row_length); ptr+= 2;
mi_int2store(ptr,0); ptr+= 2; /* reserved */
mi_int2store(ptr,base->block_size); ptr+= 2;
*ptr++= base->rec_reflength;
*ptr++= base->key_reflength;
@ -1330,7 +1330,7 @@ static uchar *_ma_base_info_read(uchar *ptr, MARIA_BASE_INFO *base)
base->null_bytes= mi_uint2korr(ptr); ptr+= 2;
base->original_null_bytes= mi_uint2korr(ptr); ptr+= 2;
base->field_offsets= mi_uint2korr(ptr); ptr+= 2;
base->min_row_length= mi_uint2korr(ptr); ptr+= 2;
ptr+= 2;
base->block_size= mi_uint2korr(ptr); ptr+= 2;
base->rec_reflength= *ptr++;

3
storage/maria/ma_packrec.c
View File

@ -209,9 +209,6 @@ static my_bool _ma_read_pack_info(MARIA_SHARE *share, File file,
diff_length=(int) rec_reflength - (int) share->base.rec_reflength;
if (fix_keys)
share->rec_reflength=rec_reflength;
share->base.min_block_length=share->min_pack_length+1;
if (share->min_pack_length > 254)
share->base.min_block_length+=2;
DBUG_PRINT("info", ("fixed header length: %u", HEAD_LENGTH));
DBUG_PRINT("info", ("total header length: %lu", share->pack.header_length));
DBUG_PRINT("info", ("pack file version: %u", share->pack.version));

1
storage/maria/maria_def.h
View File

@ -174,7 +174,6 @@ typedef struct st_ma_base_info
uint extra_alloc_bytes;
uint extra_alloc_procent;
uint is_nulls_extended; /* 1 if new null bytes */
uint min_row_length; /* Min possible length of a row */
uint default_row_flag; /* 0 or ROW_FLAG_NULLS_EXTENDED */
uint block_size;
/* Size of initial record buffer */