258 lines
9.8 KiB
C
258 lines
9.8 KiB
C
/****************************************************************
|
|
* *
|
|
* Copyright 2001, 2013 Fidelity Information Services, Inc *
|
|
* *
|
|
* This source code contains the intellectual property *
|
|
* of its copyright holder(s), and is made available *
|
|
* under a license. If you do not know the terms of *
|
|
* the license, please stop and do not read further. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
#include "mdef.h"
|
|
|
|
#include <math.h> /* needed for handling of epoch_interval */
|
|
#include "gtm_time.h"
|
|
|
|
#include "gtm_string.h"
|
|
#include "gdsroot.h"
|
|
#include "gdsbt.h"
|
|
#include "gtm_facility.h"
|
|
#include "fileinfo.h"
|
|
#include "gdsdbver.h"
|
|
#include "gdsfhead.h"
|
|
#include "gdsblk.h" /* needed for gdsblkops.h */
|
|
#include "gdscc.h" /* needed for CDB_CW_SET_SIZE macro in gdsblkops.h */
|
|
#include "min_max.h" /* needed for gdsblkops.h and MIN,MAX usage in this module */
|
|
#include "gdsblkops.h"
|
|
#include "filestruct.h"
|
|
#include "timers.h"
|
|
#include "mlkdef.h"
|
|
#include "collseq.h"
|
|
#include "iosp.h"
|
|
#include "jnl.h"
|
|
#include "gdsbml.h"
|
|
#include "mutex.h"
|
|
#include "mupip_exit.h"
|
|
#include "mucblkini.h"
|
|
#include "mucregini.h"
|
|
#include "gtmmsg.h"
|
|
#include "gtm_file_stat.h"
|
|
#include "lockconst.h"
|
|
#include "wcs_phase2_commit_wait.h"
|
|
|
|
#define WCR_SIZE_PER_BUF 0
|
|
#define BLK_SIZE (((gd_segment*)gv_cur_region->dyn.addr)->blk_size)
|
|
|
|
GBLREF gd_region *gv_cur_region;
|
|
GBLREF sgmnt_data_ptr_t cs_data;
|
|
GBLREF sgmnt_addrs *cs_addrs;
|
|
|
|
error_def(ERR_COLLATIONUNDEF);
|
|
error_def(ERR_COLLTYPVERSION);
|
|
error_def(ERR_DBFILERR);
|
|
error_def(ERR_FILEPARSE);
|
|
error_def(ERR_GVIS);
|
|
error_def(ERR_MUNOACTION);
|
|
error_def(ERR_TEXT);
|
|
|
|
void mucregini(int4 blk_init_size)
|
|
{
|
|
int4 status;
|
|
int4 i;
|
|
th_index_ptr_t th;
|
|
collseq *csp;
|
|
uint4 ustatus;
|
|
mstr jnlfile, jnldef, tmpjnlfile;
|
|
time_t ctime;
|
|
|
|
MEMCPY_LIT(cs_data->label, GDS_LABEL);
|
|
cs_data->desired_db_format = GDSVCURR;
|
|
cs_data->fully_upgraded = TRUE;
|
|
cs_data->db_got_to_v5_once = TRUE; /* no V4 format blocks that are non-upgradeable */
|
|
cs_data->minor_dbver = GDSMVCURR;
|
|
cs_data->certified_for_upgrade_to = GDSVCURR;
|
|
cs_data->creation_db_ver = GDSVCURR;
|
|
cs_data->creation_mdb_ver = GDSMVCURR;
|
|
cs_data->master_map_len = MASTER_MAP_SIZE_DFLT;
|
|
cs_data->bplmap = BLKS_PER_LMAP;
|
|
assert(BLK_SIZE <= MAX_DB_BLK_SIZE);
|
|
cs_data->blk_size = BLK_SIZE;
|
|
i = cs_data->trans_hist.total_blks;
|
|
cs_data->trans_hist.free_blocks = i - DIVIDE_ROUND_UP(i, BLKS_PER_LMAP) - 2;
|
|
cs_data->max_rec_size = gv_cur_region->max_rec_size;
|
|
cs_data->max_key_size = gv_cur_region->max_key_size;
|
|
cs_data->null_subs = gv_cur_region->null_subs;
|
|
cs_data->std_null_coll = gv_cur_region->std_null_coll;
|
|
#ifdef UNIX
|
|
cs_data->freeze_on_fail = gv_cur_region->freeze_on_fail;
|
|
cs_data->mumps_can_bypass = gv_cur_region->mumps_can_bypass;
|
|
#endif
|
|
cs_data->reserved_bytes = gv_cur_region->dyn.addr->reserved_bytes;
|
|
cs_data->clustered = FALSE;
|
|
cs_data->file_corrupt = 0;
|
|
if (gv_cur_region->dyn.addr->lock_space)
|
|
cs_data->lock_space_size = gv_cur_region->dyn.addr->lock_space * OS_PAGELET_SIZE;
|
|
else
|
|
cs_data->lock_space_size = DEF_LOCK_SIZE;
|
|
NUM_CRIT_ENTRY(cs_data) = DEFAULT_NUM_CRIT_ENTRY;
|
|
cs_data->staleness[0] = -300000000; /* staleness timer = 30 seconds */
|
|
cs_data->staleness[1] = -1;
|
|
cs_data->ccp_quantum_interval[0] = -20000000; /* 2 sec */
|
|
cs_data->ccp_quantum_interval[1] = -1;
|
|
cs_data->ccp_response_interval[0] = -600000000; /* 1 min */
|
|
cs_data->ccp_response_interval[1] = -1;
|
|
cs_data->ccp_tick_interval[0] = -1000000; /* 1/10 sec */
|
|
cs_data->ccp_tick_interval[1] = -1;
|
|
cs_data->last_com_backup = 1;
|
|
cs_data->last_inc_backup = 1;
|
|
cs_data->last_rec_backup = 1;
|
|
cs_data->defer_time = gv_cur_region->dyn.addr->defer_time;
|
|
cs_data->jnl_alq = gv_cur_region->jnl_alq;
|
|
if (cs_data->jnl_state && !cs_data->jnl_alq)
|
|
cs_data->jnl_alq = JNL_ALLOC_DEF;
|
|
cs_data->jnl_deq = gv_cur_region->jnl_deq;
|
|
cs_data->jnl_before_image = gv_cur_region->jnl_before_image;
|
|
cs_data->jnl_state = gv_cur_region->jnl_state;
|
|
cs_data->epoch_interval = JNL_ALLOWED(cs_data) ? DEFAULT_EPOCH_INTERVAL : 0;
|
|
cs_data->alignsize = JNL_ALLOWED(cs_data) ? (DISK_BLOCK_SIZE * JNL_DEF_ALIGNSIZE) : 0;
|
|
ROUND_UP_JNL_BUFF_SIZE(cs_data->jnl_buffer_size, gv_cur_region->jnl_buffer_size, cs_data);
|
|
#ifdef UNIX
|
|
if (JNL_ALLOWED(cs_data))
|
|
{
|
|
if (cs_data->jnl_alq + cs_data->jnl_deq > gv_cur_region->jnl_autoswitchlimit)
|
|
{
|
|
cs_data->autoswitchlimit = gv_cur_region->jnl_autoswitchlimit;
|
|
cs_data->jnl_alq = cs_data->autoswitchlimit;
|
|
} else
|
|
cs_data->autoswitchlimit = ALIGNED_ROUND_DOWN(gv_cur_region->jnl_autoswitchlimit,
|
|
cs_data->jnl_alq, cs_data->jnl_deq);
|
|
}
|
|
else
|
|
cs_data->autoswitchlimit = 0;
|
|
assert(!(MAX_IO_BLOCK_SIZE % DISK_BLOCK_SIZE));
|
|
if (cs_data->jnl_alq + cs_data->jnl_deq > cs_data->autoswitchlimit)
|
|
cs_data->jnl_alq = cs_data->autoswitchlimit;
|
|
#else
|
|
cs_data->autoswitchlimit = JNL_ALLOWED(cs_data) ? ALIGNED_ROUND_DOWN(JNL_ALLOC_MAX, cs_data->jnl_alq, cs_data->jnl_deq) : 0;
|
|
#endif
|
|
if (!cs_data->jnl_buffer_size)
|
|
ROUND_UP_JNL_BUFF_SIZE(cs_data->jnl_buffer_size, JNL_BUFFER_DEF, cs_data);
|
|
if (JNL_ALLOWED(cs_data))
|
|
if (cs_data->jnl_buffer_size < JNL_BUFF_PORT_MIN(cs_data))
|
|
{
|
|
ROUND_UP_MIN_JNL_BUFF_SIZE(cs_data->jnl_buffer_size, cs_data);
|
|
} else if (cs_data->jnl_buffer_size > JNL_BUFFER_MAX)
|
|
{
|
|
ROUND_DOWN_MAX_JNL_BUFF_SIZE(cs_data->jnl_buffer_size, cs_data);
|
|
}
|
|
cs_data->def_coll = gv_cur_region->def_coll;
|
|
if (cs_data->def_coll)
|
|
{
|
|
if (csp = ready_collseq((int)(cs_data->def_coll)))
|
|
{
|
|
cs_data->def_coll_ver = (csp->version)(cs_data->def_coll);
|
|
if (!do_verify(csp, cs_data->def_coll, cs_data->def_coll_ver))
|
|
{
|
|
gtm_putmsg(VARLSTCNT(4) ERR_COLLTYPVERSION, 2, cs_data->def_coll, cs_data->def_coll_ver);
|
|
mupip_exit(ERR_MUNOACTION);
|
|
}
|
|
} else
|
|
{
|
|
gtm_putmsg(VARLSTCNT(3) ERR_COLLATIONUNDEF, 1, cs_data->def_coll);
|
|
mupip_exit(ERR_MUNOACTION);
|
|
}
|
|
}
|
|
/* mupip_set_journal() relies on cs_data->jnl_file_len being 0 if cs_data->jnl_state is jnl_notallowed.
|
|
* Note that even though gv_cur_region->jnl_state is jnl_notallowed, gv_cur_region->jnl_file_len can be non-zero
|
|
*/
|
|
cs_data->jnl_file_len = JNL_ALLOWED(cs_data) ? gv_cur_region->jnl_file_len : 0;
|
|
cs_data->reg_seqno = 1;
|
|
VMS_ONLY(
|
|
cs_data->resync_seqno = 1;
|
|
cs_data->old_resync_seqno = 1;
|
|
cs_data->resync_tn = 1;
|
|
)
|
|
UNIX_ONLY(
|
|
/* zqgblmod_seqno is initialized to 0 at db creation time (to ensure that $ZQGBLMOD will unconditionally return
|
|
* the safe value of TRUE by default). This default value of 0 is also relied upon by the source server logic
|
|
* when updating this as part of a fetchresync rollback. Initialize zqgblmod_tn to 0 to correspond to the seqno.
|
|
*/
|
|
cs_data->zqgblmod_seqno = 0;
|
|
cs_data->zqgblmod_tn = 0;
|
|
assert(!cs_data->multi_site_open);
|
|
cs_data->multi_site_open = TRUE;
|
|
)
|
|
cs_data->repl_state = repl_closed; /* default */
|
|
if (cs_data->jnl_file_len)
|
|
{
|
|
tmpjnlfile.addr = (char *)cs_data->jnl_file_name;
|
|
tmpjnlfile.len = SIZEOF(cs_data->jnl_file_name);
|
|
jnlfile.addr = (char *)gv_cur_region->jnl_file_name;
|
|
jnlfile.len = gv_cur_region->jnl_file_len;
|
|
jnldef.addr = JNL_EXT_DEF;
|
|
jnldef.len = SIZEOF(JNL_EXT_DEF) - 1;
|
|
if (FILE_STAT_ERROR == gtm_file_stat(&jnlfile, &jnldef, &tmpjnlfile, TRUE, &ustatus))
|
|
{
|
|
gtm_putmsg(VARLSTCNT(5) ERR_FILEPARSE, 2, JNL_LEN_STR(gv_cur_region), ustatus);
|
|
mupip_exit(ERR_MUNOACTION);
|
|
}
|
|
cs_data->jnl_file_len = tmpjnlfile.len;
|
|
}
|
|
cs_data->reserved_for_upd = UPD_RESERVED_AREA;
|
|
cs_data->avg_blks_per_100gbl = AVG_BLKS_PER_100_GBL;
|
|
cs_data->pre_read_trigger_factor = PRE_READ_TRIGGER_FACTOR;
|
|
cs_data->writer_trigger_factor = UPD_WRITER_TRIGGER_FACTOR;
|
|
cs_data->db_trigger_cycle = 0;
|
|
cs_addrs->hdr = cs_data;
|
|
cs_addrs->ti = &cs_data->trans_hist;
|
|
th = cs_addrs->ti;
|
|
th->lock_sequence = 0;
|
|
th->ccp_jnl_filesize = 0;
|
|
cs_data->max_bts = GTM64_ONLY(GTM64_WC_MAX_BUFFS) NON_GTM64_ONLY(WC_MAX_BUFFS);
|
|
cs_data->n_bts = BT_FACTOR(gv_cur_region->dyn.addr->global_buffers);
|
|
cs_data->bt_buckets = getprime(cs_data->n_bts);
|
|
|
|
cs_data->n_wrt_per_flu = 7;
|
|
cs_data->flush_trigger = FLUSH_FACTOR(cs_data->n_bts);
|
|
|
|
cs_data->max_update_array_size = cs_data->max_non_bm_update_array_size
|
|
= (int4)ROUND_UP2(MAX_NON_BITMAP_UPDATE_ARRAY_SIZE(cs_data), UPDATE_ARRAY_ALIGN_SIZE);
|
|
cs_data->max_update_array_size += (int4)ROUND_UP2(MAX_BITMAP_UPDATE_ARRAY_SIZE, UPDATE_ARRAY_ALIGN_SIZE);
|
|
/* bt_malloc(cs_addrs) Done by db_init at file open time -- not needed here */
|
|
if (dba_bg == gv_cur_region->dyn.addr->acc_meth)
|
|
cs_data->flush_time[0] = TIM_FLU_MOD_BG;
|
|
else
|
|
cs_data->flush_time[0] = TIM_FLU_MOD_MM;
|
|
cs_data->flush_time[1] = -1;
|
|
cs_data->yield_lmt = DEFAULT_YIELD_LIMIT;
|
|
cs_data->mutex_spin_parms.mutex_hard_spin_count = MUTEX_HARD_SPIN_COUNT;
|
|
cs_data->mutex_spin_parms.mutex_sleep_spin_count = MUTEX_SLEEP_SPIN_COUNT;
|
|
cs_data->mutex_spin_parms.mutex_spin_sleep_mask = MUTEX_SPIN_SLEEP_MASK;
|
|
cs_data->wcs_phase2_commit_wait_spincnt = WCS_PHASE2_COMMIT_DEFAULT_SPINCNT;
|
|
time(&ctime);
|
|
assert(SIZEOF(ctime) >= SIZEOF(int4));
|
|
cs_data->creation_time4 = (int4)ctime; /* Need only lower order 4-bytes of current time (in case system time is 8-bytes) */
|
|
cs_addrs->bmm = MM_ADDR(cs_data);
|
|
bmm_init();
|
|
for (i = 0; i < blk_init_size ; i += cs_data->bplmap)
|
|
{ status = bml_init(i);
|
|
if (status != SS_NORMAL)
|
|
{
|
|
gtm_putmsg(VARLSTCNT(5) ERR_DBFILERR, 2, gv_cur_region->dyn.addr->fname_len,
|
|
gv_cur_region->dyn.addr->fname, status);
|
|
mupip_exit(ERR_MUNOACTION);
|
|
}
|
|
}
|
|
mucblkini();
|
|
th->mm_tn = 0;
|
|
th->early_tn = 1;
|
|
th->curr_tn = 1; /* in order to use INCREMENT_CURR_TN macro here, the logic has to be made complicated.
|
|
* this is because the macro relies on max_tn/max_tn_warn being set and that does not happen
|
|
* until a few lines later. hence keeping it simple here by doing a plain assignment of curr_tn.
|
|
*/
|
|
cs_data->max_tn = MAX_TN_V6;
|
|
SET_TN_WARN(cs_data, cs_data->max_tn_warn);
|
|
SET_LATCH_GLOBAL(&cs_data->next_upgrd_warn.time_latch, LOCK_AVAILABLE);
|
|
}
|