void mupcli_get_offset_size_value(uint4 *offset, uint4 *size, gtm_uint64_t *value, boolean_t *value_present)
{
error_def(ERR_MUPCLIERR);
error_def(ERR_SIZENOTVALID8);
if (!cli_get_hex("OFFSET", offset))
rts_error(VARLSTCNT(1) ERR_MUPCLIERR);
if (!cli_get_hex("SIZE", size))
rts_error(VARLSTCNT(1) ERR_MUPCLIERR);
if (!((sizeof(char) == *size) || (sizeof(short) == *size) || (sizeof(int4) == *size) || (sizeof(gtm_int64_t) == *size)))
rts_error(VARLSTCNT(1) ERR_SIZENOTVALID8);
if (0 > (int4)*size)
{
util_out_print("Error: SIZE specified cannot be negative", TRUE);
rts_error(VARLSTCNT(1) ERR_MUPCLIERR);
}
if (0 != (*offset % *size))
{
util_out_print("Error: OFFSET [0x!XL] should be a multiple of Size [!UL]", TRUE, *offset, *size);
rts_error(VARLSTCNT(1) ERR_MUPCLIERR);
}
if (CLI_PRESENT == cli_present("VALUE"))
{
*value_present = TRUE;
if (!cli_get_hex64("VALUE", value))
rts_error(VARLSTCNT(1) ERR_MUPCLIERR);
} else
*value_present = FALSE;
}
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_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;
}
