void dse_chng_bhead(void)
{
blk_hdr new_hdr;
blk_segment *bs1, *bs_ptr;
block_id blk;
boolean_t chng_blk, ismap, was_hold_onto_crit;
int4 blk_seg_cnt, blk_size; /* needed for BLK_INIT,BLK_SEG and BLK_FINI macros */
int4 x;
sgmnt_addrs *csa;
sgmnt_data_ptr_t csd;
srch_blk_status blkhist;
trans_num tn;
uint4 mapsize;
csa = cs_addrs;
if (gv_cur_region->read_only)
rts_error_csa(CSA_ARG(csa) VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(gv_cur_region));
CHECK_AND_RESET_UPDATE_ARRAY; /* reset update_array_ptr to update_array */
chng_blk = FALSE;
if (BADDSEBLK == (blk = dse_getblk("BLOCK", DSEBMLOK, DSEBLKCUR))) /* WARNING: assignment */
return;
csd = csa->hdr;
assert(csd == cs_data);
blk_size = csd->blk_size;
ismap = IS_BITMAP_BLK(blk);
mapsize = BM_SIZE(csd->bplmap);
t_begin_crit(ERR_DSEFAIL);
blkhist.blk_num = blk;
if (!(blkhist.buffaddr = t_qread(blkhist.blk_num, &blkhist.cycle, &blkhist.cr)))
rts_error_csa(CSA_ARG(csa) VARLSTCNT(1) ERR_DSEBLKRDFAIL);
new_hdr = *(blk_hdr_ptr_t)blkhist.buffaddr;
if (CLI_PRESENT == cli_present("LEVEL"))
{
if (!cli_get_hex("LEVEL", (uint4 *)&x))
{
t_abort(gv_cur_region, csa);
return;
}
if (ismap && (unsigned char)x != LCL_MAP_LEVL)
{
util_out_print("Error: invalid level for a bit map block.", TRUE);
t_abort(gv_cur_region, csa);
return;
}
if (!ismap && (x < 0 || x > MAX_BT_DEPTH + 1))
{
util_out_print("Error: invalid level.", TRUE);
t_abort(gv_cur_region, csa);
return;
}
new_hdr.levl = (unsigned char)x;
chng_blk = TRUE;
if (new_hdr.bsiz < SIZEOF(blk_hdr))
new_hdr.bsiz = SIZEOF(blk_hdr);
if (new_hdr.bsiz > blk_size)
new_hdr.bsiz = blk_size;
}
if (CLI_PRESENT == cli_present("BSIZ"))
{
if (!cli_get_hex("BSIZ", (uint4 *)&x))
{
t_abort(gv_cur_region, csa);
return;
}
if (ismap && x != mapsize)
{
util_out_print("Error: invalid bsiz.", TRUE);
t_abort(gv_cur_region, csa);
return;
} else if (x < SIZEOF(blk_hdr) || x > blk_size)
{
util_out_print("Error: invalid bsiz.", TRUE);
t_abort(gv_cur_region, csa);
return;
}
chng_blk = TRUE;
new_hdr.bsiz = x;
}
if (!chng_blk)
t_abort(gv_cur_region, csa);
else
{
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, blkhist.buffaddr + SIZEOF(new_hdr), new_hdr.bsiz - SIZEOF(new_hdr));
if (!BLK_FINI(bs_ptr, bs1))
{
gtm_putmsg_csa(CSA_ARG(csa) VARLSTCNT(5) ERR_AIMGBLKFAIL, 3, blk, DB_LEN_STR(gv_cur_region));
t_abort(gv_cur_region, csa);
return;
}
t_write(&blkhist, (unsigned char *)bs1, 0, 0, new_hdr.levl, TRUE, FALSE, GDS_WRITE_KILLTN);
BUILD_AIMG_IF_JNL_ENABLED(csd, csa->ti->curr_tn);
t_end(&dummy_hist, NULL, TN_NOT_SPECIFIED);
}
if (CLI_PRESENT == cli_present("TN"))
{
if (!cli_get_hex64("TN", &tn))
return;
t_begin_crit(ERR_DSEFAIL);
CHECK_TN(csa, csd, csd->trans_hist.curr_tn); /* can issue rts_error TNTOOLARGE */
assert(csa->ti->early_tn == csa->ti->curr_tn);
if (NULL == (blkhist.buffaddr = t_qread(blkhist.blk_num, &blkhist.cycle, &blkhist.cr)))
{
gtm_putmsg_csa(CSA_ARG(csa) VARLSTCNT(1) ERR_DSEBLKRDFAIL);
t_abort(gv_cur_region, csa);
return;
}
if (new_hdr.bsiz < SIZEOF(blk_hdr))
new_hdr.bsiz = SIZEOF(blk_hdr);
if (new_hdr.bsiz > blk_size)
new_hdr.bsiz = blk_size;
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, blkhist.buffaddr + SIZEOF(new_hdr), new_hdr.bsiz - SIZEOF(new_hdr));
BLK_FINI(bs_ptr, bs1);
t_write(&blkhist, (unsigned char *)bs1, 0, 0,
((blk_hdr_ptr_t)blkhist.buffaddr)->levl, TRUE, FALSE, GDS_WRITE_KILLTN);
/* Pass the desired tn as argument to bg_update/mm_update below */
BUILD_AIMG_IF_JNL_ENABLED_AND_T_END_WITH_EFFECTIVE_TN(csa, csd, tn, &dummy_hist);
}
return;
}
void dse_chng_rhead(void)
{
block_id blk;
sm_uc_ptr_t bp, b_top, cp, rp;
boolean_t chng_rec;
rec_hdr new_rec;
uint4 x;
blk_segment *bs1, *bs_ptr;
int4 blk_seg_cnt, blk_size;
srch_blk_status blkhist;
error_def(ERR_DBRDONLY);
error_def(ERR_DSEBLKRDFAIL);
error_def(ERR_DSEFAIL);
if (gv_cur_region->read_only)
rts_error(VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(gv_cur_region));
CHECK_AND_RESET_UPDATE_ARRAY; /* reset update_array_ptr to update_array */
if (cli_present("BLOCK") == CLI_PRESENT)
{
if(!cli_get_hex("BLOCK", (uint4 *)&blk))
return;
patch_curr_blk = blk;
}
if (patch_curr_blk < 0 || patch_curr_blk >= cs_addrs->ti->total_blks || !(patch_curr_blk % cs_addrs->hdr->bplmap))
{
util_out_print("Error: invalid block number.", TRUE);
return;
}
t_begin_crit(ERR_DSEFAIL);
blkhist.blk_num = patch_curr_blk;
if (!(blkhist.buffaddr = t_qread(blkhist.blk_num, &blkhist.cycle, &blkhist.cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
bp = blkhist.buffaddr;
blk_size = cs_addrs->hdr->blk_size;
chng_rec = FALSE;
b_top = bp + ((blk_hdr_ptr_t)bp)->bsiz;
if (((blk_hdr_ptr_t)bp)->bsiz > blk_size || ((blk_hdr_ptr_t)bp)->bsiz < SIZEOF(blk_hdr))
chng_rec = TRUE; /* force rewrite to correct size */
if (cli_present("RECORD") == CLI_PRESENT)
{
if (!(rp = skan_rnum(bp, FALSE)))
{
t_abort(gv_cur_region, cs_addrs);
return;
}
} else if (!(rp = skan_offset(bp, FALSE)))
{
t_abort(gv_cur_region, cs_addrs);
return;
}
GET_SHORT(new_rec.rsiz, &((rec_hdr_ptr_t)rp)->rsiz);
new_rec.cmpc = ((rec_hdr_ptr_t)rp)->cmpc;
if (cli_present("CMPC") == CLI_PRESENT)
{
if (!cli_get_hex("CMPC", &x))
{
t_abort(gv_cur_region, cs_addrs);
return;
}
if (x > 0x7f)
{
util_out_print("Error: invalid cmpc.",TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
if (x > patch_comp_count)
util_out_print("Warning: specified compression count is larger than the current expanded key size.", TRUE);
new_rec.cmpc = x;
chng_rec = TRUE;
}
if (cli_present("RSIZ") == CLI_PRESENT)
{
if (!cli_get_hex("RSIZ", &x))
{
t_abort(gv_cur_region, cs_addrs);
return;
}
if (x < SIZEOF(rec_hdr) || x > blk_size)
{
util_out_print("Error: invalid rsiz.", TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
new_rec.rsiz = x;
chng_rec = TRUE;
}
if (chng_rec)
{
BLK_INIT(bs_ptr, bs1);
cp = bp;
cp += SIZEOF(blk_hdr);
if (chng_rec)
{
BLK_SEG(bs_ptr, cp, rp - cp);
BLK_SEG(bs_ptr, (uchar_ptr_t)&new_rec, SIZEOF(rec_hdr));
cp = rp + SIZEOF(rec_hdr);
}
if (b_top - cp)
BLK_SEG(bs_ptr, cp, b_top - cp);
if (!BLK_FINI(bs_ptr, bs1))
{
util_out_print("Error: bad blk build.", TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
t_write(&blkhist, (unsigned char *)bs1, 0, 0, ((blk_hdr_ptr_t)bp)->levl, TRUE, FALSE, GDS_WRITE_KILLTN);
BUILD_AIMG_IF_JNL_ENABLED(cs_data, non_tp_jfb_buff_ptr, cs_addrs->ti->curr_tn);
t_end(&dummy_hist, NULL, TN_NOT_SPECIFIED);
}
return;
}
void dse_maps(void)
{
block_id blk, bml_blk;
blk_segment *bs1, *bs_ptr;
int4 blk_seg_cnt, blk_size; /* needed for BLK_INIT, BLK_SEG and BLK_FINI macros */
sm_uc_ptr_t bp;
char util_buff[MAX_UTIL_LEN];
int4 bml_size, bml_list_size, blk_index, bml_index;
int4 total_blks, blks_in_bitmap;
int4 bplmap, dummy_int;
unsigned char *bml_list;
cache_rec_ptr_t cr, dummy_cr;
bt_rec_ptr_t btr;
int util_len;
uchar_ptr_t blk_ptr;
boolean_t was_crit;
uint4 jnl_status;
srch_blk_status blkhist;
jnl_private_control *jpc;
jnl_buffer_ptr_t jbp;
sgmnt_addrs *csa;
sgmnt_data_ptr_t csd;
if (CLI_PRESENT == cli_present("BUSY") || CLI_PRESENT == cli_present("FREE") ||
CLI_PRESENT == cli_present("MASTER") || CLI_PRESENT == cli_present("RESTORE_ALL"))
{
if (gv_cur_region->read_only)
rts_error(VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(gv_cur_region));
}
CHECK_AND_RESET_UPDATE_ARRAY; /* reset update_array_ptr to update_array */
csa = cs_addrs;
assert(&FILE_INFO(gv_cur_region)->s_addrs == csa);
was_crit = csa->now_crit;
if (csa->critical)
crash_count = csa->critical->crashcnt;
csd = csa->hdr;
bplmap = csd->bplmap;
if (CLI_PRESENT == cli_present("BLOCK"))
{
if (!cli_get_hex("BLOCK", (uint4 *)&blk))
return;
if (blk < 0 || blk >= csa->ti->total_blks)
{
util_out_print("Error: invalid block number.", TRUE);
return;
}
patch_curr_blk = blk;
}
else
blk = patch_curr_blk;
if (CLI_PRESENT == cli_present("FREE"))
{
if (0 == bplmap)
{
util_out_print("Cannot perform map updates: bplmap field of file header is zero.", TRUE);
return;
}
if (blk / bplmap * bplmap == blk)
{
util_out_print("Cannot perform action on a map block.", TRUE);
return;
}
bml_blk = blk / bplmap * bplmap;
bm_setmap(bml_blk, blk, FALSE);
return;
}
if (CLI_PRESENT == cli_present("BUSY"))
{
if (0 == bplmap)
{
util_out_print("Cannot perform map updates: bplmap field of file header is zero.", TRUE);
return;
}
if (blk / bplmap * bplmap == blk)
{
util_out_print("Cannot perform action on a map block.", TRUE);
return;
}
bml_blk = blk / bplmap * bplmap;
bm_setmap(bml_blk, blk, TRUE);
return;
}
blk_size = csd->blk_size;
if (CLI_PRESENT == cli_present("MASTER"))
{
if (0 == bplmap)
{
util_out_print("Cannot perform maps updates: bplmap field of file header is zero.", TRUE);
return;
}
if (!was_crit)
grab_crit(gv_cur_region);
bml_blk = blk / bplmap * bplmap;
if (dba_mm == csd->acc_meth)
bp = MM_BASE_ADDR(csa) + (off_t)bml_blk * blk_size;
else
{
assert(dba_bg == csd->acc_meth);
if (!(bp = t_qread(bml_blk, &dummy_int, &dummy_cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
}
if ((csa->ti->total_blks / bplmap) * bplmap == bml_blk)
total_blks = (csa->ti->total_blks - bml_blk);
else
total_blks = bplmap;
if (NO_FREE_SPACE == bml_find_free(0, bp + SIZEOF(blk_hdr), total_blks))
bit_clear(bml_blk / bplmap, csa->bmm);
else
bit_set(bml_blk / bplmap, csa->bmm);
if (bml_blk > csa->nl->highest_lbm_blk_changed)
csa->nl->highest_lbm_blk_changed = bml_blk;
if (!was_crit)
rel_crit(gv_cur_region);
return;
}
if (CLI_PRESENT == cli_present("RESTORE_ALL"))
{
if (0 == bplmap)
{
util_out_print("Cannot perform maps updates: bplmap field of file header is zero.", TRUE);
return;
}
total_blks = csa->ti->total_blks;
assert(ROUND_DOWN2(blk_size, 2 * SIZEOF(int4)) == blk_size);
bml_size = BM_SIZE(bplmap);
bml_list_size = (total_blks + bplmap - 1) / bplmap * bml_size;
bml_list = (unsigned char *)malloc(bml_list_size);
for (blk_index = 0, bml_index = 0; blk_index < total_blks; blk_index += bplmap, bml_index++)
bml_newmap((blk_hdr_ptr_t)(bml_list + bml_index * bml_size), bml_size, csa->ti->curr_tn);
if (!was_crit)
{
grab_crit(gv_cur_region);
csa->hold_onto_crit = TRUE; /* need to do this AFTER grab_crit */
}
blk = get_dir_root();
assert(blk < bplmap);
csa->ti->free_blocks = total_blks - DIVIDE_ROUND_UP(total_blks, bplmap);
bml_busy(blk, bml_list + SIZEOF(blk_hdr));
csa->ti->free_blocks = csa->ti->free_blocks - 1;
dse_m_rest(blk, bml_list, bml_size, &csa->ti->free_blocks, TRUE);
for (blk_index = 0, bml_index = 0; blk_index < total_blks; blk_index += bplmap, bml_index++)
{
t_begin_crit(ERR_DSEFAIL);
CHECK_TN(csa, csd, csd->trans_hist.curr_tn); /* can issue rts_error TNTOOLARGE */
CWS_RESET;
CHECK_AND_RESET_UPDATE_ARRAY; /* reset update_array_ptr to update_array */
assert(csa->ti->early_tn == csa->ti->curr_tn);
blk_ptr = bml_list + bml_index * bml_size;
blkhist.blk_num = blk_index;
if (!(blkhist.buffaddr = t_qread(blkhist.blk_num, &blkhist.cycle, &blkhist.cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, blk_ptr + SIZEOF(blk_hdr), bml_size - SIZEOF(blk_hdr));
BLK_FINI(bs_ptr, bs1);
t_write(&blkhist, (unsigned char *)bs1, 0, 0, LCL_MAP_LEVL, TRUE, FALSE, GDS_WRITE_KILLTN);
BUILD_AIMG_IF_JNL_ENABLED(csd, csa->ti->curr_tn);
t_end(&dummy_hist, NULL, csa->ti->curr_tn);
}
/* Fill in master map */
for (blk_index = 0, bml_index = 0; blk_index < total_blks; blk_index += bplmap, bml_index++)
{
blks_in_bitmap = (blk_index + bplmap <= total_blks) ? bplmap : total_blks - blk_index;
assert(1 < blks_in_bitmap); /* the last valid block in the database should never be a bitmap block */
if (NO_FREE_SPACE != bml_find_free(0, (bml_list + bml_index * bml_size) + SIZEOF(blk_hdr), blks_in_bitmap))
bit_set(blk_index / bplmap, csa->bmm);
else
bit_clear(blk_index / bplmap, csa->bmm);
if (blk_index > csa->nl->highest_lbm_blk_changed)
csa->nl->highest_lbm_blk_changed = blk_index;
}
if (!was_crit)
{
csa->hold_onto_crit = FALSE; /* need to do this before the rel_crit */
rel_crit(gv_cur_region);
}
if (unhandled_stale_timer_pop)
process_deferred_stale();
free(bml_list);
csd->kill_in_prog = csd->abandoned_kills = 0;
return;
}
MEMCPY_LIT(util_buff, "!/Block ");
util_len = SIZEOF("!/Block ") - 1;
util_len += i2hex_nofill(blk, (uchar_ptr_t)&util_buff[util_len], 8);
memcpy(&util_buff[util_len], " is marked !AD in its local bit map.!/",
SIZEOF(" is marked !AD in its local bit map.!/") - 1);
util_len += SIZEOF(" is marked !AD in its local bit map.!/") - 1;
util_buff[util_len] = 0;
if (!was_crit)
grab_crit(gv_cur_region);
util_out_print(util_buff, TRUE, 4, dse_is_blk_free(blk, &dummy_int, &dummy_cr) ? "free" : "busy");
if (!was_crit)
rel_crit(gv_cur_region);
return;
}
void dse_chng_bhead(void)
{
block_id blk;
int4 x;
trans_num tn;
cache_rec_ptr_t cr;
blk_hdr new_hdr;
blk_segment *bs1, *bs_ptr;
int4 blk_seg_cnt, blk_size; /* needed for BLK_INIT,BLK_SEG and BLK_FINI macros */
boolean_t ismap;
boolean_t chng_blk;
boolean_t was_crit;
boolean_t was_hold_onto_crit;
uint4 mapsize;
srch_blk_status blkhist;
sgmnt_addrs *csa;
sgmnt_data_ptr_t csd;
# ifdef GTM_CRYPT
int req_enc_blk_size;
int crypt_status;
blk_hdr_ptr_t bp, save_bp, save_old_block;
# endif
error_def(ERR_DSEBLKRDFAIL);
error_def(ERR_DSEFAIL);
error_def(ERR_DBRDONLY);
if (gv_cur_region->read_only)
rts_error(VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(gv_cur_region));
CHECK_AND_RESET_UPDATE_ARRAY; /* reset update_array_ptr to update_array */
chng_blk = FALSE;
csa = cs_addrs;
if (cli_present("BLOCK") == CLI_PRESENT)
{
if (!cli_get_hex("BLOCK", (uint4 *)&blk))
return;
if (blk < 0 || blk > csa->ti->total_blks)
{
util_out_print("Error: invalid block number.", TRUE);
return;
}
patch_curr_blk = blk;
}
csd = csa->hdr;
assert(csd == cs_data);
blk_size = csd->blk_size;
ismap = (patch_curr_blk / csd->bplmap * csd->bplmap == patch_curr_blk);
mapsize = BM_SIZE(csd->bplmap);
t_begin_crit(ERR_DSEFAIL);
blkhist.blk_num = patch_curr_blk;
if (!(blkhist.buffaddr = t_qread(blkhist.blk_num, &blkhist.cycle, &blkhist.cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
new_hdr = *(blk_hdr_ptr_t)blkhist.buffaddr;
if (cli_present("LEVEL") == CLI_PRESENT)
{
if (!cli_get_hex("LEVEL", (uint4 *)&x))
{
t_abort(gv_cur_region, csa);
return;
}
if (ismap && (unsigned char)x != LCL_MAP_LEVL)
{
util_out_print("Error: invalid level for a bit map block.", TRUE);
t_abort(gv_cur_region, csa);
return;
}
if (!ismap && (x < 0 || x > MAX_BT_DEPTH + 1))
{
util_out_print("Error: invalid level.", TRUE);
t_abort(gv_cur_region, csa);
return;
}
new_hdr.levl = (unsigned char)x;
chng_blk = TRUE;
if (new_hdr.bsiz < SIZEOF(blk_hdr))
new_hdr.bsiz = SIZEOF(blk_hdr);
if (new_hdr.bsiz > blk_size)
new_hdr.bsiz = blk_size;
}
if (cli_present("BSIZ") == CLI_PRESENT)
{
if (!cli_get_hex("BSIZ", (uint4 *)&x))
{
t_abort(gv_cur_region, csa);
return;
}
if (ismap && x != mapsize)
{
util_out_print("Error: invalid bsiz.", TRUE);
t_abort(gv_cur_region, csa);
return;
} else if (x < SIZEOF(blk_hdr) || x > blk_size)
{
util_out_print("Error: invalid bsiz.", TRUE);
t_abort(gv_cur_region, csa);
return;
}
chng_blk = TRUE;
new_hdr.bsiz = x;
}
if (!chng_blk)
t_abort(gv_cur_region, csa);
else
{
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, blkhist.buffaddr + SIZEOF(new_hdr), new_hdr.bsiz - SIZEOF(new_hdr));
if (!BLK_FINI(bs_ptr, bs1))
{
util_out_print("Error: bad block build.", TRUE);
t_abort(gv_cur_region, csa);
return;
}
t_write(&blkhist, (unsigned char *)bs1, 0, 0, new_hdr.levl, TRUE, FALSE, GDS_WRITE_KILLTN);
BUILD_AIMG_IF_JNL_ENABLED(csd, non_tp_jfb_buff_ptr, csa->ti->curr_tn);
t_end(&dummy_hist, NULL, TN_NOT_SPECIFIED);
}
if (cli_present("TN") == CLI_PRESENT)
{
if (!cli_get_hex64("TN", &tn))
return;
was_crit = csa->now_crit;
t_begin_crit(ERR_DSEFAIL);
CHECK_TN(csa, csd, csd->trans_hist.curr_tn); /* can issue rts_error TNTOOLARGE */
assert(csa->ti->early_tn == csa->ti->curr_tn);
if (NULL == (blkhist.buffaddr = t_qread(blkhist.blk_num, &blkhist.cycle, &blkhist.cr)))
{
util_out_print("Error: Unable to read buffer.", TRUE);
t_abort(gv_cur_region, csa);
return;
}
if (new_hdr.bsiz < SIZEOF(blk_hdr))
new_hdr.bsiz = SIZEOF(blk_hdr);
if (new_hdr.bsiz > blk_size)
new_hdr.bsiz = blk_size;
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, blkhist.buffaddr + SIZEOF(new_hdr), new_hdr.bsiz - SIZEOF(new_hdr));
BLK_FINI(bs_ptr, bs1);
t_write(&blkhist, (unsigned char *)bs1, 0, 0,
((blk_hdr_ptr_t)blkhist.buffaddr)->levl, TRUE, FALSE, GDS_WRITE_KILLTN);
/* Pass the desired tn as argument to bg_update/mm_update below */
BUILD_AIMG_IF_JNL_ENABLED(csd, non_tp_jfb_buff_ptr, tn);
was_hold_onto_crit = csa->hold_onto_crit;
csa->hold_onto_crit = TRUE;
t_end(&dummy_hist, NULL, tn);
# ifdef GTM_CRYPT
if (csd->is_encrypted && (tn < csa->ti->curr_tn))
{ /* BG and db encryption is enabled and the DSE update caused the block-header to potentially have a tn
* that is LESS than what it had before. At this point, the global buffer (corresponding to blkhist.blk_num)
* reflects the contents of the block AFTER the dse update (bg_update would have touched this) whereas
* the corresponding encryption global buffer reflects the contents of the block BEFORE the update.
* Normally wcs_wtstart takes care of propagating the tn update from the regular global buffer to the
* corresponding encryption buffer. But if before it gets a chance, let us say a process goes to t_end
* as part of a subsequent transaction and updates this same block. Since the blk-hdr-tn potentially
* decreased, it is possible that the PBLK writing check (comparing blk-hdr-tn with the epoch_tn) decides
* to write a PBLK for this block (even though a PBLK was already written for this block as part of a
* previous DSE CHANGE -BL -TN in the same epoch). In this case, since the db is encrypted, the logic
* will assume there were no updates to this block since the last time wcs_wtstart updated the encryption
* buffer and therefore use that to write the pblk, which is incorrect since it does not yet contain the
* tn update. The consequence of this is would be writing an older before-image PBLK) record to the
* journal file. To prevent this situation, we update the encryption buffer here (before releasing crit)
* using logic like that in wcs_wtstart to ensure it is in sync with the regular global buffer.
* Note:
* Although we use cw_set[0] to access the global buffer corresponding to the block number being updated,
* cw_set_depth at this point is 0 because t_end resets it. This is considered safe since cw_set is a
* static array (as opposed to malloc'ed memory) and hence is always available and valid until it gets
* overwritten by subsequent updates.
*/
bp = (blk_hdr_ptr_t)GDS_ANY_REL2ABS(csa, cw_set[0].cr->buffaddr);
DBG_ENSURE_PTR_IS_VALID_GLOBUFF(csa, csd, (sm_uc_ptr_t)bp);
save_bp = (blk_hdr_ptr_t)GDS_ANY_ENCRYPTGLOBUF(bp, csa);
DBG_ENSURE_PTR_IS_VALID_ENCTWINGLOBUFF(csa, csd, (sm_uc_ptr_t)save_bp);
assert((bp->bsiz <= csd->blk_size) && (bp->bsiz >= SIZEOF(*bp)));
req_enc_blk_size = MIN(csd->blk_size, bp->bsiz) - SIZEOF(*bp);
if (BLK_NEEDS_ENCRYPTION(bp->levl, req_enc_blk_size))
{
ASSERT_ENCRYPTION_INITIALIZED;
memcpy(save_bp, bp, SIZEOF(blk_hdr));
GTMCRYPT_ENCODE_FAST(csa->encr_key_handle, (char *)(bp + 1), req_enc_blk_size,
(char *)(save_bp + 1), crypt_status);
if (0 != crypt_status)
GC_GTM_PUTMSG(crypt_status, gv_cur_region->dyn.addr->fname);
} else
memcpy(save_bp, bp, bp->bsiz);
}
# endif
if (!was_hold_onto_crit)
csa->hold_onto_crit = FALSE;
if (!was_crit)
rel_crit(gv_cur_region);
if (unhandled_stale_timer_pop)
process_deferred_stale();
}
return;
}
void dse_rmrec(void)
{
block_id blk;
blk_segment *bs1, *bs_ptr;
int4 blk_seg_cnt, blk_size, count;
sm_uc_ptr_t bp;
uchar_ptr_t lbp, b_top, rp, r_top, key_top, rp_base;
char cc, comp_key[256], cc_base;
short int size, i, rsize;
cw_set_element *cse;
error_def(ERR_DSEFAIL);
error_def(ERR_DSEBLKRDFAIL);
error_def(ERR_DBRDONLY);
if (gv_cur_region->read_only)
rts_error(VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(gv_cur_region));
assert(update_array);
/* reset new block mechanism */
update_array_ptr = update_array;
if (cli_present("BLOCK") == CLI_PRESENT)
{
if(!cli_get_hex("BLOCK", &blk))
return;
if (blk < 0 || blk >= cs_addrs->ti->total_blks || !(blk % cs_addrs->hdr->bplmap))
{
util_out_print("Error: invalid block number.", TRUE);
return;
}
patch_curr_blk = blk;
}
if (cli_present("COUNT") == CLI_PRESENT)
{
if (!cli_get_hex("COUNT", &count) || count < 1)
return;
} else
count = 1;
t_begin_crit(ERR_DSEFAIL);
blk_size = cs_addrs->hdr->blk_size;
if(!(bp = t_qread(patch_curr_blk, &dummy_hist.h[0].cycle, &dummy_hist.h[0].cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
lbp = (uchar_ptr_t)malloc(blk_size);
memcpy(lbp, bp, blk_size);
if (((blk_hdr_ptr_t)lbp)->bsiz > cs_addrs->hdr->blk_size)
b_top = lbp + cs_addrs->hdr->blk_size;
else if (((blk_hdr_ptr_t)lbp)->bsiz < sizeof(blk_hdr))
b_top = lbp + sizeof(blk_hdr);
else
b_top = lbp + ((blk_hdr_ptr_t)lbp)->bsiz;
if (cli_present("RECORD") == CLI_PRESENT)
{
if (!(rp = rp_base = skan_rnum(lbp, FALSE)))
{
free(lbp);
t_abort(gv_cur_region, cs_addrs);
return;
}
} else if (!(rp = rp_base = skan_offset(lbp, FALSE)))
{
free(lbp);
t_abort(gv_cur_region, cs_addrs);
return;
}
memcpy(&comp_key[0], &patch_comp_key[0], sizeof(patch_comp_key));
cc_base = patch_comp_count;
for ( ; ; )
{
GET_SHORT(rsize, &((rec_hdr_ptr_t)rp)->rsiz);
if (rsize < sizeof(rec_hdr))
r_top = rp + sizeof(rec_hdr);
else
r_top = rp + rsize;
if (r_top >= b_top)
{
if (count)
{ if (((blk_hdr_ptr_t) lbp)->levl)
util_out_print("Warning: removed a star record from the end of this block.", TRUE);
((blk_hdr_ptr_t)lbp)->bsiz = rp_base - lbp;
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, (uchar_ptr_t)lbp + sizeof(blk_hdr),
(int)((blk_hdr_ptr_t)lbp)->bsiz - sizeof(blk_hdr));
if (!BLK_FINI(bs_ptr, bs1))
{
util_out_print("Error: bad blk build.",TRUE);
free(lbp);
t_abort(gv_cur_region, cs_addrs);
return;
}
t_write(patch_curr_blk, (unsigned char *)bs1, 0, 0, bp, ((blk_hdr_ptr_t)lbp)->levl, TRUE, FALSE);
BUILD_AIMG_IF_JNL_ENABLED(cs_addrs, cs_data, non_tp_jfb_buff_ptr, cse);
t_end(&dummy_hist, 0);
free(lbp);
return;
}
r_top = b_top;
}
if (((blk_hdr_ptr_t)lbp)->levl)
key_top = r_top - sizeof(block_id);
else
{
for (key_top = rp + sizeof(rec_hdr); key_top < r_top; )
if (!*key_top++ && !*key_top++)
break;
}
if (((rec_hdr_ptr_t)rp)->cmpc > patch_comp_count)
cc = patch_comp_count;
else
cc = ((rec_hdr_ptr_t)rp)->cmpc;
size = key_top - rp - sizeof(rec_hdr);
if (size < 0)
size = 0;
else if (size > sizeof(patch_comp_key) - 2)
size = sizeof(patch_comp_key) - 2;
memcpy(&patch_comp_key[cc], rp + sizeof(rec_hdr), size);
patch_comp_count = cc + size;
if (--count >= 0)
{
rp = r_top;
continue;
}
size = (patch_comp_count < cc_base) ? patch_comp_count : cc_base;
for (i = 0; i < size && patch_comp_key[i] == comp_key[i]; i++)
;
((rec_hdr_ptr_t)rp_base)->cmpc = i;
rsize = r_top - key_top + sizeof(rec_hdr) + patch_comp_count - i;
PUT_SHORT(&((rec_hdr_ptr_t)rp_base)->rsiz, rsize);
memcpy(rp_base + sizeof(rec_hdr), &patch_comp_key[i], patch_comp_count - i);
memcpy(rp_base + sizeof(rec_hdr) + patch_comp_count - i, key_top, b_top - key_top);
((blk_hdr_ptr_t)lbp)->bsiz = rp_base + rsize - lbp + b_top - r_top;
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, (uchar_ptr_t)lbp + sizeof(blk_hdr), ((blk_hdr_ptr_t)lbp)->bsiz - sizeof(blk_hdr));
if (!BLK_FINI(bs_ptr, bs1))
{
util_out_print("Error: bad blk build.", TRUE);
free(lbp);
t_abort(gv_cur_region, cs_addrs);
return;
}
t_write(patch_curr_blk, (unsigned char *)bs1, 0, 0, bp, ((blk_hdr_ptr_t)lbp)->levl, TRUE, FALSE);
BUILD_AIMG_IF_JNL_ENABLED(cs_addrs, cs_data, non_tp_jfb_buff_ptr, cse);
t_end(&dummy_hist, 0);
free(lbp);
return;
}
}
void dse_chng_bhead(void)
{
block_id blk;
block_id *blkid_ptr;
sgm_info *dummysi = NULL;
int4 x;
cache_rec_ptr_t cr;
uchar_ptr_t bp;
sm_uc_ptr_t blkBase;
blk_hdr new_hdr;
blk_segment *bs1, *bs_ptr;
cw_set_element *cse;
int4 blk_seg_cnt, blk_size; /* needed for BLK_INIT,BLK_SEG and BLK_FINI macros */
bool ismap;
bool chng_blk;
uint4 mapsize;
uint4 jnl_status;
error_def(ERR_DSEBLKRDFAIL);
error_def(ERR_DSEFAIL);
error_def(ERR_DBRDONLY);
if (gv_cur_region->read_only)
rts_error(VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(gv_cur_region));
assert(update_array);
/* reset new block mechanism */
update_array_ptr = update_array;
chng_blk = FALSE;
if (cli_present("BLOCK") == CLI_PRESENT)
{
if (!cli_get_hex("BLOCK",&blk))
return;
if (blk < 0 || blk > cs_addrs->ti->total_blks)
{ util_out_print("Error: invalid block number.",TRUE);
return;
}
patch_curr_blk = blk;
}
blk_size = cs_addrs->hdr->blk_size;
ismap = (patch_curr_blk / cs_addrs->hdr->bplmap * cs_addrs->hdr->bplmap == patch_curr_blk);
mapsize = BM_SIZE(cs_addrs->hdr->bplmap);
t_begin_crit (ERR_DSEFAIL);
if (!(bp = t_qread (patch_curr_blk,&dummy_hist.h[0].cycle,&dummy_hist.h[0].cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
new_hdr = *(blk_hdr_ptr_t)bp;
if (cli_present("LEVEL") == CLI_PRESENT)
{
if (!cli_get_num("LEVEL",&x))
{
t_abort(gv_cur_region, cs_addrs);
return;
}
if (ismap && (unsigned char)x != LCL_MAP_LEVL)
{
util_out_print("Error: invalid level for a bit map block.",TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
if (!ismap && (x < 0 || x > MAX_BT_DEPTH + 1))
{
util_out_print("Error: invalid level.",TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
new_hdr.levl = (unsigned char)x;
chng_blk = TRUE;
if (new_hdr.bsiz < sizeof(blk_hdr))
new_hdr.bsiz = sizeof(blk_hdr);
if (new_hdr.bsiz > blk_size)
new_hdr.bsiz = blk_size;
}
if (cli_present("BSIZ") == CLI_PRESENT)
{
if (!cli_get_hex("BSIZ",&x))
{
t_abort(gv_cur_region, cs_addrs);
return;
}
if (ismap && x != mapsize)
{
util_out_print("Error: invalid bsiz.",TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
else if (x < sizeof(blk_hdr) || x > blk_size)
{
util_out_print("Error: invalid bsiz.",TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
chng_blk = TRUE;
new_hdr.bsiz = x;
}
if (!chng_blk)
t_abort(gv_cur_region, cs_addrs);
else
{
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, bp + sizeof(new_hdr), new_hdr.bsiz - sizeof(new_hdr));
if (!BLK_FINI(bs_ptr, bs1))
{
util_out_print("Error: bad block build.",TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
t_write (patch_curr_blk, (unsigned char *)bs1, 0, 0, bp, new_hdr.levl, TRUE, FALSE);
BUILD_AIMG_IF_JNL_ENABLED(cs_addrs, cs_data, non_tp_jfb_buff_ptr, cse);
t_end(&dummy_hist, 0);
}
if (cli_present("TN") == CLI_PRESENT)
{
if (!cli_get_hex("TN",&x))
return;
t_begin_crit(ERR_DSEFAIL);
assert(cs_addrs->ti->early_tn == cs_addrs->ti->curr_tn);
cs_addrs->ti->early_tn++;
blkBase = t_qread(patch_curr_blk, &dummy_hist.h[0].cycle, &dummy_hist.h[0].cr);
if (NULL == blkBase)
{
rel_crit(gv_cur_region);
util_out_print("Error: Unable to read buffer.", TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
/* Create a null update array for a block */
if (ismap)
{
BLK_ADDR(blkid_ptr, sizeof(block_id), block_id);
*blkid_ptr = 0;
t_write_map(patch_curr_blk, blkBase, (unsigned char *)blkid_ptr, cs_addrs->ti->curr_tn);
cr_array_index = 0;
block_saved = FALSE;
} else
{
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, bp + sizeof(new_hdr), new_hdr.bsiz - sizeof(new_hdr));
BLK_FINI(bs_ptr, bs1);
t_write(patch_curr_blk, (unsigned char *)bs1, 0, 0, blkBase,
((blk_hdr_ptr_t)blkBase)->levl, TRUE, FALSE);
cr_array_index = 0;
block_saved = FALSE;
if (JNL_ENABLED(cs_data))
{
JNL_SHORT_TIME(jgbl.gbl_jrec_time); /* needed for jnl_put_jrt_pini() and jnl_write_aimg_rec() */
jnl_status = jnl_ensure_open();
if (0 == jnl_status)
{
cse = (cw_set_element *)(&cw_set[0]);
cse->new_buff = non_tp_jfb_buff_ptr;
gvcst_blk_build(cse, (uchar_ptr_t)cse->new_buff, x);
cse->done = TRUE;
if (0 == cs_addrs->jnl->pini_addr)
jnl_put_jrt_pini(cs_addrs);
jnl_write_aimg_rec(cs_addrs, cse->blk, (blk_hdr_ptr_t)cse->new_buff);
} else
rts_error(VARLSTCNT(6) jnl_status, 4, JNL_LEN_STR(cs_data), DB_LEN_STR(gv_cur_region));
}
}
/* Pass the desired tn "x" as argument to bg_update or mm_update */
if (dba_bg == cs_addrs->hdr->acc_meth)
bg_update(cw_set, cw_set + cw_set_depth, cs_addrs->ti->curr_tn, x, dummysi);
else
mm_update(cw_set, cw_set + cw_set_depth, cs_addrs->ti->curr_tn, x, dummysi);
cs_addrs->ti->curr_tn++;
assert(cs_addrs->ti->early_tn == cs_addrs->ti->curr_tn);
/* the following code is analogous to that in t_end and should be maintained in a similar fashion */
while (cr_array_index)
cr_array[--cr_array_index]->in_cw_set = FALSE;
rel_crit(gv_cur_region);
if (block_saved)
backup_buffer_flush(gv_cur_region);
UNIX_ONLY(
if (unhandled_stale_timer_pop)
process_deferred_stale();
)
wcs_timer_start(gv_cur_region, TRUE);
}
