void mu_swap_root(glist *gl_ptr, int *root_swap_statistic_ptr)
{
sgmnt_data_ptr_t csd;
sgmnt_addrs *csa;
node_local_ptr_t cnl;
srch_hist *dir_hist_ptr, *gvt_hist_ptr;
gv_namehead *save_targ;
block_id root_blk_id, child_blk_id, free_blk_id;
sm_uc_ptr_t root_blk_ptr, child_blk_ptr;
kill_set kill_set_list;
trans_num curr_tn, ret_tn;
int level, root_blk_lvl;
block_id save_root;
boolean_t tn_aborted;
unsigned int lcl_t_tries;
enum cdb_sc status;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(mu_reorg_process);
gv_target = gl_ptr->gvt;
gv_target->root = 0; /* reset root so we recompute it in DO_OP_GVNAME below */
gv_target->clue.end = 0; /* reset clue since reorg action on later globals might have invalidated it */
reorg_gv_target->gvname.var_name = gv_target->gvname.var_name; /* needed by SAVE_ROOTSRCH_ENTRY_STATE */
dir_hist_ptr = gv_target->alt_hist;
gvt_hist_ptr = &(gv_target->hist);
inctn_opcode = inctn_invalid_op;
DO_OP_GVNAME(gl_ptr);
/* sets gv_target/gv_currkey/gv_cur_region/cs_addrs/cs_data to correspond to <globalname,reg> in gl_ptr */
csa = cs_addrs;
cnl = csa->nl;
csd = cs_data; /* Be careful to keep csd up to date. With MM, cs_data can change, and
* dereferencing an older copy can result in a SIG-11.
*/
if (gv_cur_region->read_only)
return; /* Cannot proceed for read-only data files */
if (0 == gv_target->root)
{ /* Global does not exist (online rollback). No problem. */
gtm_putmsg_csa(CSA_ARG(csa) VARLSTCNT(4) ERR_GBLNOEXIST, 2, GNAME(gl_ptr).len, GNAME(gl_ptr).addr);
return;
}
if (dba_mm == csd->acc_meth)
/* return for now without doing any swapping operation because later mu_truncate
* is going to issue the MUTRUNCNOTBG message.
*/
return;
SET_GV_ALTKEY_TO_GBLNAME_FROM_GV_CURRKEY; /* set up gv_altkey to be just the gblname */
/* ------------ Swap root block of global variable tree --------- */
t_begin(ERR_MUREORGFAIL, UPDTRNS_DB_UPDATED_MASK);
for (;;)
{
curr_tn = csa->ti->curr_tn;
kill_set_list.used = 0;
save_root = gv_target->root;
gv_target->root = csa->dir_tree->root;
gv_target->clue.end = 0;
if (cdb_sc_normal != (status = gvcst_search(gv_altkey, dir_hist_ptr)))
{ /* Assign directory tree path to dir_hist_ptr */
assert(t_tries < CDB_STAGNATE);
gv_target->root = save_root;
t_retry(status);
continue;
}
gv_target->root = save_root;
gv_target->clue.end = 0;
if (cdb_sc_normal != (gvcst_search(gv_currkey, NULL)))
{ /* Assign global variable tree path to gvt_hist_ptr */
assert(t_tries < CDB_STAGNATE);
t_retry(status);
continue;
}
/* We've already search the directory tree in op_gvname/t_retry and obtained gv_target->root.
* Should restart with gvtrootmod2 if they don't agree. gvcst_root_search is the final arbiter.
* Really need that for debug info and also should assert(gv_currkey is global name).
*/
root_blk_lvl = gvt_hist_ptr->depth;
assert(root_blk_lvl > 0);
root_blk_ptr = gvt_hist_ptr->h[root_blk_lvl].buffaddr;
root_blk_id = gvt_hist_ptr->h[root_blk_lvl].blk_num;
assert((CDB_STAGNATE > t_tries) || (gv_target->root == gvt_hist_ptr->h[root_blk_lvl].blk_num));
free_blk_id = swap_root_or_directory_block(0, root_blk_lvl, dir_hist_ptr, root_blk_id,
root_blk_ptr, &kill_set_list, curr_tn);
if (RETRY_SWAP == free_blk_id)
continue;
else if (ABORT_SWAP == free_blk_id)
break;
update_trans = UPDTRNS_DB_UPDATED_MASK;
inctn_opcode = inctn_mu_reorg;
assert(1 == kill_set_list.used);
need_kip_incr = TRUE;
if (!csa->now_crit)
WAIT_ON_INHIBIT_KILLS(cnl, MAXWAIT2KILL);
DEBUG_ONLY(lcl_t_tries = t_tries);
TREF(in_mu_swap_root_state) = MUSWP_INCR_ROOT_CYCLE;
assert(!TREF(in_gvcst_redo_root_search));
if ((trans_num)0 == (ret_tn = t_end(gvt_hist_ptr, dir_hist_ptr, TN_NOT_SPECIFIED)))
{
TREF(in_mu_swap_root_state) = MUSWP_NONE;
need_kip_incr = FALSE;
assert(NULL == kip_csa);
ABORT_TRANS_IF_GBL_EXIST_NOMORE(lcl_t_tries, tn_aborted);
if (tn_aborted)
{ /* It is not an error if the global (that once existed) doesn't exist anymore (due to ROLLBACK) */
gtm_putmsg_csa(CSA_ARG(csa) VARLSTCNT(4) ERR_GBLNOEXIST, 2, GNAME(gl_ptr).len, GNAME(gl_ptr).addr);
return;
}
continue;
}
TREF(in_mu_swap_root_state) = MUSWP_NONE;
/* Note that this particular process's csa->root_search_cycle is now behind cnl->root_search_cycle.
* This forces a cdb_sc_gvtrootmod2 restart in gvcst_bmp_mark_free below.
*/
assert(cnl->root_search_cycle > csa->root_search_cycle);
gvcst_kill_sort(&kill_set_list);
GVCST_BMP_MARK_FREE(&kill_set_list, ret_tn, inctn_mu_reorg, inctn_bmp_mark_free_mu_reorg, inctn_opcode, csa);
DECR_KIP(csd, csa, kip_csa);
*root_swap_statistic_ptr += 1;
break;
}
/* ------------ Swap blocks in branch of directory tree --------- */
for (level = 0; level <= MAX_BT_DEPTH; level++)
{
t_begin(ERR_MUREORGFAIL, UPDTRNS_DB_UPDATED_MASK);
for (;;)
{
curr_tn = csa->ti->curr_tn;
kill_set_list.used = 0;
save_root = gv_target->root;
gv_target->root = csa->dir_tree->root;
gv_target->clue.end = 0;
if (cdb_sc_normal != (status = gvcst_search(gv_altkey, dir_hist_ptr)))
{ /* assign branch path of directory tree into dir_hist_ptr */
assert(t_tries < CDB_STAGNATE);
gv_target->root = save_root;
t_retry(status);
continue;
}
gv_target->root = save_root;
gv_target->clue.end = 0;
if (level >= dir_hist_ptr->depth)
{ /* done */
t_abort(gv_cur_region, csa);
return;
}
child_blk_ptr = dir_hist_ptr->h[level].buffaddr;
child_blk_id = dir_hist_ptr->h[level].blk_num;
assert(csa->dir_tree->root != child_blk_id);
free_blk_id = swap_root_or_directory_block(level + 1, level, dir_hist_ptr, child_blk_id,
child_blk_ptr, &kill_set_list, curr_tn);
if (level == 0)
/* set level as 1 to mark this kill set is for level-0 block in directory tree.
* The kill-set level later will be used in gvcst_bmp_markfree to assign a special value to
* cw_set_element, which will be eventually used by t_end to write the block to snapshot
*/
kill_set_list.blk[kill_set_list.used - 1].level = 1;
if (RETRY_SWAP == free_blk_id)
continue;
else if (ABORT_SWAP == free_blk_id)
break;
update_trans = UPDTRNS_DB_UPDATED_MASK;
inctn_opcode = inctn_mu_reorg;
assert(1 == kill_set_list.used);
need_kip_incr = TRUE;
if (!csa->now_crit)
WAIT_ON_INHIBIT_KILLS(cnl, MAXWAIT2KILL);
DEBUG_ONLY(lcl_t_tries = t_tries);
TREF(in_mu_swap_root_state) = MUSWP_DIRECTORY_SWAP;
if ((trans_num)0 == (ret_tn = t_end(dir_hist_ptr, NULL, TN_NOT_SPECIFIED)))
{
TREF(in_mu_swap_root_state) = MUSWP_NONE;
need_kip_incr = FALSE;
assert(NULL == kip_csa);
continue;
}
TREF(in_mu_swap_root_state) = MUSWP_NONE;
gvcst_kill_sort(&kill_set_list);
TREF(in_mu_swap_root_state) = MUSWP_FREE_BLK;
GVCST_BMP_MARK_FREE(&kill_set_list, ret_tn, inctn_mu_reorg, inctn_bmp_mark_free_mu_reorg,
inctn_opcode, csa);
TREF(in_mu_swap_root_state) = MUSWP_NONE;
DECR_KIP(csd, csa, kip_csa);
break;
}
}
return;
}
/****************************************************************
Input Parameter:
gn = Global name
exclude_glist_ptr = list of globals in EXCLUDE option
index_fill_factor = index blocks' fill factor
data_fill_factor = data blocks' fill factor
Input/Output Parameter:
resume = resume flag
reorg_op = What operations to do (coalesce or, swap or, split) [Default is all]
[Only for debugging]
****************************************************************/
boolean_t mu_reorg(mval *gn, glist *exclude_glist_ptr, boolean_t *resume, int index_fill_factor, int data_fill_factor, int reorg_op)
{
boolean_t end_of_tree = FALSE, complete_merge, detailed_log;
int rec_size;
/*
*
* "level" is the level of the working block.
* "pre_order_successor_level" is pre_order successor level except in the case
* where we are in a left-most descent of the tree
* in which case pre_order_successor_level will be the maximum height of that subtree
* until we reach the leaf level block .
* In other words, pre_order_successor_level and level variable controls the iterative pre-order traversal.
* We start reorg from the (root_level - 1) to 0. That is, level = pre_order_successor_level:-1:0.
*/
int pre_order_successor_level, level;
static block_id dest_blk_id = 0;
int tkeysize;
int blks_killed, blks_processed, blks_reused, blks_coalesced, blks_split, blks_swapped,
count, file_extended, lvls_reduced;
int d_max_fill, i_max_fill, blk_size, cur_blk_size, max_fill, toler, d_toler, i_toler;
int cnt1, cnt2;
kill_set kill_set_list;
sm_uc_ptr_t rPtr1;
enum cdb_sc status;
srch_hist *rtsib_hist;
jnl_buffer_ptr_t jbp;
trans_num ret_tn;
error_def(ERR_MUREORGFAIL);
error_def(ERR_DBRDONLY);
error_def(ERR_GBLNOEXIST);
error_def(ERR_MAXBTLEVEL);
t_err = ERR_MUREORGFAIL;
kill_set_tail = &kill_set_list;
/* Initialization for current global */
op_gvname(VARLSTCNT(1) gn);
/* Cannot proceed for read-only data files */
if (gv_cur_region->read_only)
{
gtm_putmsg(VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(gv_cur_region));
return FALSE;
}
dest_blk_id = cs_addrs->reorg_last_dest;
inctn_opcode = inctn_mu_reorg;
/* If resume option is present, then reorg_restart_key should be not null.
* Skip all globals until we are in the region for that global.
* Get the reorg_restart_key and reorg_restart_block from database header and restart from there.
*/
if (*resume && 0 != cs_data->reorg_restart_key[0])
{
/* resume from last key reorged in GVT */
GET_KEY_LEN(tkeysize, &cs_data->reorg_restart_key[0]);
memcpy(gv_currkey->base, cs_data->reorg_restart_key, tkeysize);
gv_currkey->end = tkeysize - 1;
dest_blk_id = cs_data->reorg_restart_block;
if (0 == memcmp(cs_data->reorg_restart_key, gn->str.addr, gn->str.len))
/* Going to resume from current global, so it resumed and make it false */
*resume = FALSE;
} else
{
/* start from the left most leaf */
memcpy(&gv_currkey->base[0], gn->str.addr, gn->str.len);
gv_currkey->base[gn->str.len] = gv_currkey->base[gn->str.len + 1] = 0;
gv_currkey->end = gn->str.len + 1;
}
if (*resume)
{
util_out_print("REORG cannot be resumed from this point, Skipping this global...", FLUSH);
memcpy(&gv_currkey->base[0], gn->str.addr, gn->str.len);
gv_currkey->base[gn->str.len] = gv_currkey->base[gn->str.len + 1] = 0;
gv_currkey->end = gn->str.len + 1;
return TRUE;
}
memcpy(&gv_currkey_next_reorg->base[0], &gv_currkey->base[0], gv_currkey->end + 1);
gv_currkey_next_reorg->end = gv_currkey->end;
if (2 > dest_blk_id)
dest_blk_id = 2; /* we know that first block is bitmap and next one is directory tree root */
file_extended = cs_data->trans_hist.total_blks;
blk_size = cs_data->blk_size;
d_max_fill = (double)data_fill_factor * blk_size / 100.0 - cs_data->reserved_bytes;
i_max_fill = (double)index_fill_factor * blk_size / 100.0 - cs_data->reserved_bytes;
d_toler = (double) DATA_FILL_TOLERANCE * blk_size / 100.0;
i_toler = (double) INDEX_FILL_TOLERANCE * blk_size / 100.0;
blks_killed = blks_processed = blks_reused = lvls_reduced = blks_coalesced = blks_split = blks_swapped = 0;
pre_order_successor_level = level = MAX_BT_DEPTH + 1; /* Just some high value to initialize */
/* --- more detailed debugging information --- */
if (detailed_log = reorg_op & DETAIL)
util_out_print("STARTING to work on global ^!AD from region !AD", TRUE,
gn->str.len, gn->str.addr, REG_LEN_STR(gv_cur_region));
/* In each iteration of MAIN loop, a working block is processed for a GVT */
for (; ;) /* ================ START MAIN LOOP ================ */
{
/* If right sibling is completely merged with the working block, do not swap the working block
* with its final destination block. Continue trying next right sibling. Swap only at the end.
*/
complete_merge = TRUE;
while(complete_merge) /* === START WHILE COMPLETE_MERGE === */
{
if (mu_ctrlc_occurred || mu_ctrly_occurred)
{
cs_data->reorg_restart_block = dest_blk_id;
memcpy(&cs_data->reorg_restart_key[0], &gv_currkey->base[0], gv_currkey->end + 1);
return FALSE;
}
complete_merge = FALSE;
blks_processed++;
t_begin(ERR_MUREORGFAIL, UPDTRNS_DB_UPDATED_MASK);
/* Folllowing for loop is to handle concurrency retry for split/coalesce */
for (; ;) /* === SPLIT-COALESCE LOOP STARTS === */
{
gv_target->clue.end = 0;
/* search gv_currkey and get the result in gv_target */
if ((status = gvcst_search(gv_currkey, NULL)) != cdb_sc_normal)
{
assert(CDB_STAGNATE > t_tries);
t_retry(status);
continue;
} else if (gv_currkey->end + 1 != gv_target->hist.h[0].curr_rec.match)
{
if (SIZEOF(blk_hdr) == ((blk_hdr_ptr_t)gv_target->hist.h[0].buffaddr)->bsiz
&& 1 == gv_target->hist.depth)
{
if (cs_addrs->now_crit)
{
t_abort(gv_cur_region, cs_addrs); /* do crit and other cleanup */
gtm_putmsg(VARLSTCNT(4) ERR_GBLNOEXIST, 2, gn->str.len, gn->str.addr);
reorg_finish(dest_blk_id, blks_processed, blks_killed, blks_reused,
file_extended, lvls_reduced,
blks_coalesced, blks_split, blks_swapped);
return TRUE; /* It is not an error that global was killed */
} else
{
assert(CDB_STAGNATE > t_tries);
t_retry(status);
continue;
}
}
}
if (gv_target->hist.depth <= level)
{
/* Will come here
* 1) first iteration of the for loop (since level == MAX_BT_DEPTH + 1) or,
* 2) tree depth decreased for mu_reduce_level or, M-kill
*/
pre_order_successor_level = gv_target->hist.depth - 1;
if (MAX_BT_DEPTH + 1 != level)
{
/* break the loop when tree depth decreased (case 2) */
level = pre_order_successor_level;
break;
}
level = pre_order_successor_level;
}
max_fill = (0 == level)? d_max_fill : i_max_fill;
toler = (0 == level)? d_toler:i_toler;
cur_blk_size = ((blk_hdr_ptr_t)(gv_target->hist.h[level].buffaddr))->bsiz;
if (cur_blk_size > max_fill + toler && 0 == (reorg_op & NOSPLIT)) /* SPLIT BLOCK */
{
cnt1 = cnt2 = 0;
/* history of current working block is in gv_target */
status = mu_split(level, i_max_fill, d_max_fill, &cnt1, &cnt2);
if (cdb_sc_maxlvl == status)
{
gtm_putmsg(VARLSTCNT(4) ERR_MAXBTLEVEL, 2, gn->str.len, gn->str.addr);
reorg_finish(dest_blk_id, blks_processed, blks_killed, blks_reused,
file_extended, lvls_reduced, blks_coalesced, blks_split, blks_swapped);
return FALSE;
} else if (cdb_sc_normal == status)
{
if ((trans_num)0 == (ret_tn = t_end(&(gv_target->hist), NULL, TN_NOT_SPECIFIED)))
{
need_kip_incr = FALSE;
continue;
}
if (detailed_log)
log_detailed_log("SPL", &(gv_target->hist), NULL, level, NULL, ret_tn);
blks_reused += cnt1;
lvls_reduced -= cnt2;
blks_split++;
break;
} else if (cdb_sc_oprnotneeded == status)
{ /* undo any update_array/cw_set changes and DROP THRU to mu_clsce */
cw_set_depth = 0;
CHECK_AND_RESET_UPDATE_ARRAY; /* reset update_array_ptr to update_array */
assert(0 == cw_map_depth); /* mu_swap_blk (that changes cw_map_depth) comes later */
} else
{
assert(CDB_STAGNATE > t_tries);
t_retry(status);
continue;
}
} /* end if SPLIT BLOCK */
/* We are here because, mu_split() was not called or, split was not done or, not required */
rtsib_hist = gv_target->alt_hist;
status = gvcst_rtsib(rtsib_hist, level);
if (cdb_sc_normal != status && cdb_sc_endtree != status)
{
assert(CDB_STAGNATE > t_tries);
t_retry(status);
continue;
}
if (cdb_sc_endtree == status)
{
if (0 == level)
end_of_tree = TRUE;
break;
} else if (0 == level)
pre_order_successor_level = rtsib_hist->depth - 1;
/* COALESCE WITH RTSIB */
kill_set_list.used = 0;
if (cur_blk_size < max_fill - toler && 0 == (reorg_op & NOCOALESCE))
{
/* histories are sent in &gv_target->hist and gv_target->alt_hist */
status = mu_clsce(level, i_max_fill, d_max_fill, &kill_set_list, &complete_merge);
if (cdb_sc_normal == status)
{
if (level) /* delete lower elements of array, t_end might confuse */
{
memmove(&rtsib_hist->h[0], &rtsib_hist->h[level],
SIZEOF(srch_blk_status)*(rtsib_hist->depth - level + 2));
rtsib_hist->depth = rtsib_hist->depth - level;
}
if (0 < kill_set_list.used) /* increase kill_in_prog */
{
need_kip_incr = TRUE;
if (!cs_addrs->now_crit) /* Do not sleep while holding crit */
WAIT_ON_INHIBIT_KILLS(cs_addrs->nl, MAXWAIT2KILL);
}
if ((trans_num)0 == (ret_tn = t_end(&(gv_target->hist), rtsib_hist,
TN_NOT_SPECIFIED)))
{
need_kip_incr = FALSE;
assert(NULL == kip_csa);
if (level)
{ /* reinitialize level member in rtsib_hist srch_blk_status' */
for (count = 0; count < MAX_BT_DEPTH; count++)
rtsib_hist->h[count].level = count;
}
continue;
}
if (level)
{ /* reinitialize level member in rtsib_hist srch_blk_status' */
for (count = 0; count < MAX_BT_DEPTH; count++)
rtsib_hist->h[count].level = count;
}
if (detailed_log)
log_detailed_log("CLS", &(gv_target->hist), rtsib_hist, level,
NULL, ret_tn);
assert(0 < kill_set_list.used || (NULL == kip_csa));
if (0 < kill_set_list.used) /* decrease kill_in_prog */
{
gvcst_kill_sort(&kill_set_list);
GVCST_BMP_MARK_FREE(&kill_set_list, ret_tn, inctn_mu_reorg,
inctn_bmp_mark_free_mu_reorg, inctn_opcode, cs_addrs)
DECR_KIP(cs_data, cs_addrs, kip_csa);
if (detailed_log)
log_detailed_log("KIL", &(gv_target->hist), NULL, level,
&kill_set_list, ret_tn);
blks_killed += kill_set_list.used;
}
blks_coalesced++;
break;
} else if (cdb_sc_oprnotneeded == status)
{ /* undo any update_array/cw_set changes and DROP THRU to t_end */
cw_set_depth = 0;
CHECK_AND_RESET_UPDATE_ARRAY; /* reset update_array_ptr to update_array */
assert(0 == cw_map_depth); /* mu_swap_blk (that changes cw_map_depth) comes later */
} else
{
assert(CDB_STAGNATE > t_tries);
t_retry(status);
continue;
}
} /* end if try coalesce */
if (0 == level)
{
/* Note: In data block level:
* if split is successful or,
* if coalesce is successful without a complete merge of rtsib,
* then gv_currkey_next_reorg is already set from the called function.
* if split or, coalesce do a retry or,
* if coalesce is successful with a complete merge then
* gv_currkey will not be changed.
* If split or, coalesce is not successful or, not needed then
* here gv_currkey_next_reorg will be set from right sibling
*/
cw_set_depth = cw_map_depth = 0;
GET_KEY_LEN(tkeysize, rtsib_hist->h[0].buffaddr + SIZEOF(blk_hdr) + SIZEOF(rec_hdr));
if (2 < tkeysize && MAX_KEY_SZ >= tkeysize)
{
memcpy(&(gv_currkey_next_reorg->base[0]), rtsib_hist->h[0].buffaddr
+ SIZEOF(blk_hdr) +SIZEOF(rec_hdr), tkeysize);
gv_currkey_next_reorg->end = tkeysize - 1;
inctn_opcode = inctn_invalid_op; /* temporary reset; satisfy an assert in t_end() */
assert(UPDTRNS_DB_UPDATED_MASK == update_trans);
update_trans = 0; /* tell t_end, this is no longer an update transaction */
if ((trans_num)0 == (ret_tn = t_end(rtsib_hist, NULL, TN_NOT_SPECIFIED)))
{
need_kip_incr = FALSE;
inctn_opcode = inctn_mu_reorg; /* reset inctn_opcode to its default */
update_trans = UPDTRNS_DB_UPDATED_MASK;/* reset update_trans to old value */
assert(NULL == kip_csa);
continue;
}
/* There is no need to reset update_trans in case of a successful "t_end" call.
* This is because before the next call to "t_end" we should have a call to
* "t_begin" which will reset update_trans anyways.
*/
inctn_opcode = inctn_mu_reorg; /* reset inctn_opcode to its default */
if (detailed_log)
log_detailed_log("NOU", rtsib_hist, NULL, level, NULL, ret_tn);
} else
{
assert(CDB_STAGNATE > t_tries);
t_retry(status);
continue;
}
} /* end if (0 == level) */
break;
}/* === SPLIT-COALESCE LOOP END === */
t_abort(gv_cur_region, cs_addrs); /* do crit and other cleanup */
}/* === START WHILE COMPLETE_MERGE === */
if (mu_ctrlc_occurred || mu_ctrly_occurred)
{
cs_data->reorg_restart_block = dest_blk_id;
memcpy(&cs_data->reorg_restart_key[0], &gv_currkey->base[0], gv_currkey->end+1);
return FALSE;
}
/* Now swap the working block */
if (0 == (reorg_op & NOSWAP))
{
t_begin(ERR_MUREORGFAIL, UPDTRNS_DB_UPDATED_MASK);
/* Following loop is to handle concurrency retry for swap */
for (; ;) /* === START OF SWAP LOOP === */
{
kill_set_list.used = 0;
gv_target->clue.end = 0;
/* search gv_currkey and get the result in gv_target */
if ((status = gvcst_search(gv_currkey, NULL)) != cdb_sc_normal)
{
assert(CDB_STAGNATE > t_tries);
t_retry(status);
continue;
} else if (gv_currkey->end + 1 != gv_target->hist.h[0].curr_rec.match)
{
if (SIZEOF(blk_hdr) == ((blk_hdr_ptr_t)gv_target->hist.h[0].buffaddr)->bsiz
&& 1 == gv_target->hist.depth)
{
if (cs_addrs->now_crit)
{
t_abort(gv_cur_region, cs_addrs); /* do crit and other cleanup */
gtm_putmsg(VARLSTCNT(4) ERR_GBLNOEXIST, 2, gn->str.len, gn->str.addr);
reorg_finish(dest_blk_id, blks_processed, blks_killed, blks_reused,
file_extended, lvls_reduced,
blks_coalesced, blks_split, blks_swapped);
return TRUE; /* It is not an error that global was killed */
} else
{
assert(CDB_STAGNATE > t_tries);
t_retry(status);
continue;
}
}
}
if (gv_target->hist.depth <= level)
break;
/* swap working block with appropriate dest_blk_id block.
Historys are sent as gv_target->hist and reorg_gv_target->hist */
mu_reorg_in_swap_blk = TRUE;
status = mu_swap_blk(level, &dest_blk_id, &kill_set_list, exclude_glist_ptr);
mu_reorg_in_swap_blk = FALSE;
if (cdb_sc_oprnotneeded == status)
{
if (cs_data->trans_hist.total_blks <= dest_blk_id)
{
util_out_print("REORG may be incomplete for this global.", TRUE);
reorg_finish(dest_blk_id, blks_processed, blks_killed, blks_reused,
file_extended, lvls_reduced, blks_coalesced, blks_split, blks_swapped);
return TRUE;
}
} else if (cdb_sc_normal == status)
{
if (0 < kill_set_list.used)
{
need_kip_incr = TRUE;
if (!cs_addrs->now_crit) /* Do not sleep while holding crit */
WAIT_ON_INHIBIT_KILLS(cs_addrs->nl, MAXWAIT2KILL);
/* second history not needed, because,
we are reusing a free block, which does not need history */
if ((trans_num)0 == (ret_tn = t_end(&(gv_target->hist), NULL, TN_NOT_SPECIFIED)))
{
need_kip_incr = FALSE;
assert(NULL == kip_csa);
DECR_BLK_NUM(dest_blk_id);
continue;
}
if (detailed_log)
log_detailed_log("SWA", &(gv_target->hist), NULL, level, NULL, ret_tn);
gvcst_kill_sort(&kill_set_list);
GVCST_BMP_MARK_FREE(&kill_set_list, ret_tn, inctn_mu_reorg,
inctn_bmp_mark_free_mu_reorg, inctn_opcode, cs_addrs)
DECR_KIP(cs_data, cs_addrs, kip_csa);
if (detailed_log)
log_detailed_log("KIL", &(gv_target->hist), NULL, level,
&kill_set_list, ret_tn);
blks_reused += kill_set_list.used;
blks_killed += kill_set_list.used;
}
/* gv_target->hist is for working block's history, and
reorg_gv_target->hist is for destinition block's history.
Note: gv_target and reorg_gv_target can be part of different GVT. */
else if ((trans_num)0 == (ret_tn = t_end(&(gv_target->hist), &(reorg_gv_target->hist),
TN_NOT_SPECIFIED)))
{
need_kip_incr = FALSE;
assert(NULL == kip_csa);
DECR_BLK_NUM(dest_blk_id);
continue;
}
if ((0 >= kill_set_list.used) && detailed_log)
log_detailed_log("SWA", &(gv_target->hist), &(reorg_gv_target->hist),
level, NULL, ret_tn);
blks_swapped++;
if (reorg_op & SWAPHIST)
util_out_print("Dest !SL From !SL", TRUE, dest_blk_id,
gv_target->hist.h[level].blk_num);
} else
{
assert(CDB_STAGNATE > t_tries);
t_retry(status);
continue;
}
break;
} /* === END OF SWAP LOOP === */
t_abort(gv_cur_region, cs_addrs); /* do crit and other cleanup */
}
if (mu_ctrlc_occurred || mu_ctrly_occurred)
{
cs_data->reorg_restart_block = dest_blk_id;
memcpy(&cs_data->reorg_restart_key[0], &gv_currkey->base[0], gv_currkey->end + 1);
return FALSE;
}
if (end_of_tree)
break;
if (0 < level)
level--; /* Order of reorg is root towards leaf */
else
{
level = pre_order_successor_level;
memcpy(&gv_currkey->base[0], &gv_currkey_next_reorg->base[0], gv_currkey_next_reorg->end + 1);
gv_currkey->end = gv_currkey_next_reorg->end;
cs_data->reorg_restart_block = dest_blk_id;
memcpy(&cs_data->reorg_restart_key[0], &gv_currkey->base[0], gv_currkey->end + 1);
}
} /* ================ END MAIN LOOP ================ */
/* =========== START REDUCE LEVEL ============== */
memcpy(&gv_currkey->base[0], gn->str.addr, gn->str.len);
gv_currkey->base[gn->str.len] = gv_currkey->base[gn->str.len + 1] = 0;
gv_currkey->end = gn->str.len + 1;
for (;;) /* Reduce level continues until it fails to reduce */
{
t_begin(ERR_MUREORGFAIL, UPDTRNS_DB_UPDATED_MASK);
cnt1 = 0;
for (; ;) /* main reduce level loop starts */
{
kill_set_list.used = 0;
gv_target->clue.end = 0;
/* search gv_currkey and get the result in gv_target */
if ((status = gvcst_search(gv_currkey, NULL)) != cdb_sc_normal)
{
assert(CDB_STAGNATE > t_tries);
t_retry(status);
continue;
} else if (gv_currkey->end + 1 != gv_target->hist.h[0].curr_rec.match)
{
if (SIZEOF(blk_hdr) == ((blk_hdr_ptr_t)gv_target->hist.h[0].buffaddr)->bsiz
&& 1 == gv_target->hist.depth)
{
if (cs_addrs->now_crit)
{
t_abort(gv_cur_region, cs_addrs); /* do crit and other cleanup */
gtm_putmsg(VARLSTCNT(4) ERR_GBLNOEXIST, 2, gn->str.len, gn->str.addr);
reorg_finish(dest_blk_id, blks_processed, blks_killed, blks_reused,
file_extended, lvls_reduced, blks_coalesced, blks_split, blks_swapped);
return TRUE; /* It is not an error that global was killed */
} else
{
assert(CDB_STAGNATE > t_tries);
t_retry(status);
continue;
}
}
}
if (gv_target->hist.depth <= level)
break;
/* History is passed in gv_target->hist */
status = mu_reduce_level(&kill_set_list);
if (cdb_sc_oprnotneeded != status && cdb_sc_normal != status)
{
assert(CDB_STAGNATE > t_tries);
t_retry(status);
continue;
} else if (cdb_sc_normal == status)
{
assert(0 < kill_set_list.used);
need_kip_incr = TRUE;
if (!cs_addrs->now_crit) /* Do not sleep while holding crit */
WAIT_ON_INHIBIT_KILLS(cs_addrs->nl, MAXWAIT2KILL);
if ((trans_num)0 == (ret_tn = t_end(&(gv_target->hist), NULL, TN_NOT_SPECIFIED)))
{
need_kip_incr = FALSE;
assert(NULL == kip_csa);
continue;
}
if (detailed_log)
log_detailed_log("RDL", &(gv_target->hist), NULL, level, NULL, ret_tn);
gvcst_kill_sort(&kill_set_list);
GVCST_BMP_MARK_FREE(&kill_set_list, ret_tn, inctn_mu_reorg,
inctn_bmp_mark_free_mu_reorg, inctn_opcode, cs_addrs)
DECR_KIP(cs_data, cs_addrs, kip_csa);
if (detailed_log)
log_detailed_log("KIL", &(gv_target->hist), NULL, level, &kill_set_list, ret_tn);
blks_reused += kill_set_list.used;
blks_killed += kill_set_list.used;
cnt1 = 1;
lvls_reduced++;
}
break;
} /* main reduce level loop ends */
t_abort(gv_cur_region, cs_addrs); /* do crit and other cleanup */
if (0 == cnt1)
break;
}
/* =========== END REDUCE LEVEL ===========*/
reorg_finish(dest_blk_id, blks_processed, blks_killed, blks_reused,
file_extended, lvls_reduced, blks_coalesced, blks_split, blks_swapped);
return TRUE;
} /* end mu_reorg() */
