void
rw_lock_create_func(
/*================*/
rw_lock_t* lock, /* in: pointer to memory */
char* cfile_name, /* in: file name where created */
ulint cline) /* in: file line where created */
{
/* If this is the very first time a synchronization
object is created, then the following call initializes
the sync system. */
mutex_create(rw_lock_get_mutex(lock));
mutex_set_level(rw_lock_get_mutex(lock), SYNC_NO_ORDER_CHECK);
lock->mutex.cfile_name = cfile_name;
lock->mutex.cline = cline;
rw_lock_set_waiters(lock, 0);
rw_lock_set_writer(lock, RW_LOCK_NOT_LOCKED);
lock->writer_count = 0;
rw_lock_set_reader_count(lock, 0);
lock->writer_is_wait_ex = FALSE;
UT_LIST_INIT(lock->debug_list);
lock->magic_n = RW_LOCK_MAGIC_N;
lock->level = SYNC_LEVEL_NONE;
lock->cfile_name = cfile_name;
lock->cline = cline;
lock->last_s_file_name = "not yet reserved";
lock->last_x_file_name = "not yet reserved";
lock->last_s_line = 0;
lock->last_x_line = 0;
mutex_enter(&rw_lock_list_mutex);
UT_LIST_ADD_FIRST(list, rw_lock_list, lock);
mutex_exit(&rw_lock_list_mutex);
}
void
hash_create_mutexes(
/*================*/
hash_table_t* table, /* in: hash table */
ulint n_mutexes, /* in: number of mutexes, must be a
power of 2 */
ulint sync_level) /* in: latching order level of the
mutexes: used in the debug version */
{
ulint i;
ut_a(n_mutexes == ut_2_power_up(n_mutexes));
table->mutexes = mem_alloc(n_mutexes * sizeof(mutex_t));
for (i = 0; i < n_mutexes; i++) {
mutex_create(table->mutexes + i);
mutex_set_level(table->mutexes + i, sync_level);
}
table->n_mutexes = n_mutexes;
}
/***************************************************************************
Creates and initializes a rollback segment object. The values for the
fields are read from the header. The object is inserted to the rseg
list of the trx system object and a pointer is inserted in the rseg
array in the trx system object. */
static
trx_rseg_t*
trx_rseg_mem_create(
/*================*/
/* out, own: rollback segment object */
ulint id, /* in: rollback segment id */
ulint space, /* in: space where the segment placed */
ulint page_no, /* in: page number of the segment header */
mtr_t* mtr) /* in: mtr */
{
trx_rsegf_t* rseg_header;
trx_rseg_t* rseg;
trx_ulogf_t* undo_log_hdr;
fil_addr_t node_addr;
ulint sum_of_undo_sizes;
ulint len;
#ifdef UNIV_SYNC_DEBUG
ut_ad(mutex_own(&kernel_mutex));
#endif /* UNIV_SYNC_DEBUG */
rseg = mem_alloc(sizeof(trx_rseg_t));
rseg->id = id;
rseg->space = space;
rseg->page_no = page_no;
mutex_create(&(rseg->mutex));
mutex_set_level(&(rseg->mutex), SYNC_RSEG);
UT_LIST_ADD_LAST(rseg_list, trx_sys->rseg_list, rseg);
trx_sys_set_nth_rseg(trx_sys, id, rseg);
rseg_header = trx_rsegf_get_new(space, page_no, mtr);
rseg->max_size = mtr_read_ulint(rseg_header + TRX_RSEG_MAX_SIZE,
MLOG_4BYTES, mtr);
/* Initialize the undo log lists according to the rseg header */
sum_of_undo_sizes = trx_undo_lists_init(rseg);
rseg->curr_size = mtr_read_ulint(rseg_header + TRX_RSEG_HISTORY_SIZE,
MLOG_4BYTES, mtr)
+ 1 + sum_of_undo_sizes;
len = flst_get_len(rseg_header + TRX_RSEG_HISTORY, mtr);
if (len > 0) {
trx_sys->rseg_history_len += len;
node_addr = trx_purge_get_log_from_hist(
flst_get_last(rseg_header + TRX_RSEG_HISTORY,
mtr));
rseg->last_page_no = node_addr.page;
rseg->last_offset = node_addr.boffset;
undo_log_hdr = trx_undo_page_get(rseg->space, node_addr.page,
mtr)
+ node_addr.boffset;
rseg->last_trx_no = mtr_read_dulint(
undo_log_hdr + TRX_UNDO_TRX_NO, mtr);
rseg->last_del_marks = mtr_read_ulint(
undo_log_hdr + TRX_UNDO_DEL_MARKS,
MLOG_2BYTES, mtr);
} else {
rseg->last_page_no = FIL_NULL;
}
return(rseg);
}
