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 mu_signal_process(char *command, int signal)
{
boolean_t pid_present, name_present;
int4 pid, length, status, item, outv;
char prc_nam[20];
unsigned short name_len;
$DESCRIPTOR(d_prc_nam,"");
memset(prc_nam, 0, SIZEOF(prc_nam));
pid_present = name_present = FALSE;
if (cli_present("id") == CLI_PRESENT)
{
if(!cli_get_hex("id", &pid))
return;
pid_present = TRUE;
}
if (cli_present("name") == CLI_PRESENT)
{
name_len = 20;
if (!cli_get_str("name", prc_nam, &name_len))
return;
if (prc_nam[name_len-1] == '"')
name_len--;
if (prc_nam[0] == '"')
{
d_prc_nam.dsc$a_pointer = &prc_nam[1];
name_len--;
} else
d_prc_nam.dsc$a_pointer = &prc_nam;
d_prc_nam.dsc$w_length = name_len;
name_present = TRUE;
}
if (!name_present)
{
if (SS$_NORMAL == send_signal(pid, signal))
SENDMSG_OUTPUT("", pid);
return;
}
item = JPI$_PID;
status = lib$getjpi(&item, 0, &d_prc_nam, &outv, 0, 0);
if (SS$_NORMAL != status)
{
rts_error(VARLSTCNT(1) status);
return;
}
if (!pid_present)
{
if (SS$_NORMAL == send_signal(outv, signal))
SENDMSG_OUTPUT(&prc_nam, outv);
return;
}
if (outv != pid)
{
util_out_print("ID !XL and NAME !AD are not the same process", FLUSH, pid, LEN_AND_STR(&prc_nam));
return;
}
if (SS$_NORMAL == send_signal(pid, signal))
SENDMSG_OUTPUT(&prc_nam, pid);
return;
}
void dse_integ(void)
{
block_id blk;
char util_buff[MAX_UTIL_LEN];
sm_uc_ptr_t bp;
int4 dummy_int, nocrit_present;
cache_rec_ptr_t dummy_cr;
int util_len;
bool was_crit;
error_def(ERR_DSEBLKRDFAIL);
if (CLI_PRESENT == cli_present("BLOCK"))
{
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;
}
memcpy(util_buff, "!/Checking integrity of block ", 30);
util_len = 30;
util_len += i2hex_nofill(patch_curr_blk, (uchar_ptr_t)&util_buff[util_len], 8);
memcpy(&util_buff[util_len], ":", 1);
util_len += 1;
util_buff[util_len] = 0;
util_out_print(util_buff, TRUE);
was_crit = cs_addrs->now_crit;
nocrit_present = (CLI_NEGATED == cli_present("CRIT"));
if (!was_crit)
{
if (nocrit_present)
cs_addrs->now_crit = TRUE;
else
grab_crit(gv_cur_region);
}
if (!(bp = t_qread(patch_curr_blk, &dummy_int, &dummy_cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
if (TRUE == cert_blk(gv_cur_region, patch_curr_blk, (blk_hdr_ptr_t)bp, 0))
util_out_print("!/ No errors detected.!/", TRUE);
else
util_out_print(NULL, TRUE);
if (!was_crit)
{
if (nocrit_present)
cs_addrs->now_crit = FALSE;
else
rel_crit(gv_cur_region);
}
return;
}
block_id dse_getblk(char *element, boolean_t nobml, boolean_t carry_curr)
{
block_id blk;
if (!cli_get_hex(element, (uint4 *)&blk))
blk = patch_curr_blk;
else
CLEAR_DSE_COMPRESS_KEY;
if ((blk < 0) || (blk >= cs_addrs->ti->total_blks))
{
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_BLKINVALID, 4, blk, DB_LEN_STR(gv_cur_region),
cs_addrs->ti->total_blks);
return BADDSEBLK;
}
if (nobml && IS_BITMAP_BLK(blk))
{
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_CANTBITMAP);
return BADDSEBLK;
}
if (carry_curr)
patch_curr_blk = blk;
return blk;
}
boolean_t dse_r_dmp(void)
{
block_id blk;
sm_uc_ptr_t bp, b_top, rp;
int4 count;
int4 dummy_int;
cache_rec_ptr_t dummy_cr;
short record, size;
boolean_t was_crit;
int4 nocrit_present;
error_def(ERR_DSEBLKRDFAIL);
error_def(ERR_CTRLC);
if (cli_present("BLOCK") == CLI_PRESENT)
{
uint4 tmp_blk;
if(!cli_get_hex("BLOCK", &tmp_blk))
return FALSE;
blk = (block_id)tmp_blk;
if (blk < 0 || blk >= cs_addrs->ti->total_blks || !(blk % cs_addrs->hdr->bplmap))
{
util_out_print("Error: invalid block number.", TRUE);
return FALSE;
}
patch_curr_blk = blk;
}
if (cli_present("COUNT") == CLI_PRESENT)
{
if (!cli_get_hex("COUNT", (uint4 *)&count))
return FALSE;
} else
count = 1;
was_crit = cs_addrs->now_crit;
nocrit_present = (CLI_NEGATED == cli_present("CRIT"));
DSE_GRAB_CRIT_AS_APPROPRIATE(was_crit, nocrit_present, cs_addrs, gv_cur_region);
if (!(bp = t_qread(patch_curr_blk, &dummy_int, &dummy_cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
if (((blk_hdr_ptr_t) bp)->bsiz > cs_addrs->hdr->blk_size)
b_top = bp + cs_addrs->hdr->blk_size;
else if (((blk_hdr_ptr_t) bp)->bsiz < SIZEOF(blk_hdr))
b_top = bp + SIZEOF(blk_hdr);
else
b_top = bp + ((blk_hdr_ptr_t) bp)->bsiz;
if (((blk_hdr_ptr_t) bp)->levl && patch_is_fdmp)
{
DSE_REL_CRIT_AS_APPROPRIATE(was_crit, nocrit_present, cs_addrs, gv_cur_region);
util_out_print("Error: cannot perform GLO/ZWR dump on index block.", TRUE);
return FALSE;
}
if (cli_present("RECORD") == CLI_PRESENT)
{
if (!(rp = skan_rnum (bp, FALSE)))
{
DSE_REL_CRIT_AS_APPROPRIATE(was_crit, nocrit_present, cs_addrs, gv_cur_region);
return FALSE;
}
} else if (!(rp = skan_offset (bp, FALSE)))
{
DSE_REL_CRIT_AS_APPROPRIATE(was_crit, nocrit_present, cs_addrs, gv_cur_region);
return FALSE;
}
util_out_print(0, TRUE);
for ( ; 0 < count; count--)
{
if (util_interrupt || !(rp = dump_record(rp, patch_curr_blk, bp, b_top)))
break;
patch_rec_counter += 1;
}
DSE_REL_CRIT_AS_APPROPRIATE(was_crit, nocrit_present, cs_addrs, gv_cur_region);
if (util_interrupt)
rts_error(VARLSTCNT(1) ERR_CTRLC);
else if (cli_present("HEADER") == CLI_NEGATED)
util_out_print(0, TRUE);
return TRUE;
}
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;
}
boolean_t dse_b_dmp(void)
{
int4 util_len, head, lmap_num, iter1, iter2, mapsize, bplmap, nocrit_present, dummy_int, count;
unsigned char util_buff[MAX_UTIL_LEN], mask;
boolean_t free, was_crit, invalid_bitmap = FALSE;
block_id blk;
sm_uc_ptr_t bp, b_top, rp, mb, dump_record(sm_uc_ptr_t rp, block_id blk, sm_uc_ptr_t bp, sm_uc_ptr_t b_top);
cache_rec_ptr_t dummy_cr;
error_def(ERR_DSEBLKRDFAIL);
error_def(ERR_CTRLC);
error_def(ERR_BITMAPSBAD);
head = cli_present("HEADER");
if (CLI_PRESENT == cli_present("BLOCK"))
{
if (!cli_get_hex("BLOCK", &blk))
return FALSE;
if (blk < 0 || blk >= cs_addrs->ti->total_blks)
{
util_out_print("Error: invalid block number.", TRUE);
return FALSE;
}
patch_curr_blk = blk;
} else
blk = patch_curr_blk;
if (CLI_PRESENT == cli_present("COUNT"))
{
if (!cli_get_hex("COUNT", &count))
return FALSE;
if (count < 1)
return FALSE;
} else
count = 1;
util_out_print(0, TRUE);
bplmap = cs_addrs->hdr->bplmap;
mapsize = BM_SIZE(bplmap);
patch_rec_counter = 1;
was_crit = cs_addrs->now_crit;
nocrit_present = (CLI_NEGATED == cli_present("CRIT"));
if (!was_crit)
{
if (nocrit_present)
cs_addrs->now_crit = TRUE;
else
grab_crit(gv_cur_region);
}
for ( ; ; )
{
if (blk / bplmap * bplmap != blk)
{
if(!(bp = t_qread(blk, &dummy_int, &dummy_cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
if (((blk_hdr_ptr_t) bp)->levl && patch_is_fdmp)
{
util_out_print("Error: cannot perform GLO/ZWR dump on index block.", TRUE);
if (!was_crit)
{
if (nocrit_present)
cs_addrs->now_crit = FALSE;
else
rel_crit(gv_cur_region);
}
return FALSE;
}
if (((blk_hdr_ptr_t) bp)->bsiz > cs_addrs->hdr->blk_size)
b_top = bp + cs_addrs->hdr->blk_size;
else if (((blk_hdr_ptr_t) bp)->bsiz < sizeof(blk_hdr))
b_top = bp + sizeof(blk_hdr);
else
b_top = bp + ((blk_hdr_ptr_t) bp)->bsiz;
if (CLI_NEGATED != head && !patch_is_fdmp)
{ memcpy(util_buff, "Block ", 6);
util_len = 6;
util_len += i2hex_nofill(blk, &util_buff[util_len], 8);
memcpy(&util_buff[util_len], " Size ", 8);
util_len += 8;
util_len += i2hex_nofill(((blk_hdr_ptr_t)bp)->bsiz, &util_buff[util_len], 4);
memcpy(&util_buff[util_len], " Level !UL TN ", 18);
util_len += 18;
util_len += i2hex_nofill(((blk_hdr_ptr_t)bp)->tn, &util_buff[util_len], 8);
memcpy(&util_buff[util_len], "!/", 2);
util_len += 2;
util_buff[util_len] = 0;
util_out_print(util_buff, TRUE, ((blk_hdr_ptr_t) bp)->levl );
}
rp = bp + sizeof(blk_hdr);
if (CLI_PRESENT != head && (!patch_is_fdmp || ((blk_hdr_ptr_t) bp)->levl == 0))
{
while (!util_interrupt && (rp = dump_record(rp, blk, bp, b_top)))
patch_rec_counter += 1;
}
if (util_interrupt)
{
if (!was_crit)
rel_crit(gv_cur_region);
rts_error(VARLSTCNT(1) ERR_CTRLC);
break;
}
if (CLI_NEGATED == head)
util_out_print(0, TRUE);
} else if (!patch_is_fdmp)
{
if(!(bp = t_qread(blk, &dummy_int, &dummy_cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
if (CLI_NEGATED != head)
{
if (bplmap == 0)
{
memcpy(util_buff, "Block ", 6);
util_len = 6;
util_len += i2hex_nofill(blk, &util_buff[util_len], 8);
memcpy(&util_buff[util_len], " Size ", 8);
util_len += 8;
util_len += i2hex_nofill(mapsize, &util_buff[util_len], 4);
memcpy(&util_buff[util_len], " Master Status: Cannot Determine (bplmap == 0)!/", 50);
util_len += 50;
util_buff[util_len] = 0;
util_out_print(util_buff, TRUE );
} else
{
mb = cs_addrs->bmm + blk / (8 * bplmap);
lmap_num = blk / bplmap;
mask = 1 << ( lmap_num - lmap_num / 8 * 8);
free = mask & *mb;
memcpy(util_buff, "Block ", 6);
util_len = 6;
util_len += i2hex_nofill(blk, &util_buff[util_len], 8);
memcpy(&util_buff[util_len], " Size ", 7);
util_len += 7;
util_len += i2hex_nofill(((blk_hdr_ptr_t)bp)->bsiz, &util_buff[util_len], 4);
memcpy(&util_buff[util_len], " Level !SB TN ", 16);
util_len += 16;
util_len += i2hex_nofill(((blk_hdr_ptr_t)bp)->tn, &util_buff[util_len], 8);
util_buff[util_len] = 0;
util_out_print(util_buff, FALSE, ((blk_hdr_ptr_t) bp)->levl );
util_len = 0;
memcpy(&util_buff[util_len], " Master Status: !AD!/",23);
util_len = 23;
util_buff[util_len] = 0;
util_out_print(util_buff, TRUE, free ? 10 : 4, free ? "Free Space" : "Full");
}
}
if (CLI_PRESENT != head)
{
util_out_print (" !_Low order High order", TRUE);
lmap_num = 0;
while (lmap_num < bplmap)
{ memcpy(util_buff, "Block ", 6);
util_len = 6;
i2hex_blkfill(blk + lmap_num, &util_buff[util_len], 8);
util_len += 8;
memcpy(&util_buff[util_len], ":!_| ", 6);
util_len += 6;
util_buff[util_len] = 0;
util_out_print (util_buff, FALSE);
for (iter1 = 0; iter1 < 4; iter1++)
{
for (iter2 = 0; iter2 < 8; iter2++)
{
mask = dse_lm_blk_free(lmap_num * BML_BITS_PER_BLK, bp + sizeof(blk_hdr));
if (!mask)
util_out_print ("!AD", FALSE, 1, BUSY_CHAR);
else if (BLK_FREE == mask)
util_out_print ("!AD", FALSE, 1, FREE_CHAR);
else if (BLK_RECYCLED == mask)
util_out_print ("!AD", FALSE, 1, REUSABLE_CHAR);
else {
invalid_bitmap = TRUE;
util_out_print ("!AD", FALSE, 1, CORRUPT_CHAR);
}
if (++lmap_num >= bplmap)
break;
}
util_out_print (" ", FALSE);
if (lmap_num >= bplmap)
break;
}
util_out_print ("|", TRUE);
if (util_interrupt)
{
if (!was_crit)
rel_crit(gv_cur_region);
rts_error(VARLSTCNT(1) ERR_CTRLC);
}
}
util_out_print("!/'!AD' == BUSY '!AD' == FREE '!AD' == REUSABLE '!AD' == CORRUPT!/",
TRUE,1, BUSY_CHAR, 1, FREE_CHAR, 1, REUSABLE_CHAR, 1, CORRUPT_CHAR);
if (invalid_bitmap)
rts_error(VARLSTCNT(1) ERR_BITMAPSBAD);
}
}
count--;
if (count <= 0 || util_interrupt)
break;
blk++;
if (blk >= cs_addrs->ti->total_blks)
blk = 0;
}
patch_curr_blk = blk;
if (!was_crit)
{
if (nocrit_present)
cs_addrs->now_crit = FALSE;
else
rel_crit(gv_cur_region);
}
return TRUE;
}
void dse_save(void)
{
block_id blk;
unsigned i, j, util_len;
unsigned short buff_len;
bool was_block, was_crit;
char buff[100], *ptr, util_buff[MAX_UTIL_LEN];
sm_uc_ptr_t bp;
int4 dummy_int, nocrit_present;
cache_rec_ptr_t dummy_cr;
error_def(ERR_DSEBLKRDFAIL);
memset(util_buff, 0, MAX_UTIL_LEN);
if (was_block = (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;
} else
blk = patch_curr_blk;
if (cli_present("LIST") == CLI_PRESENT)
{
if (was_block)
{
util_len = sizeof("!/Saved versions of block ");
memcpy(util_buff, "!/Saved versions of block ", util_len);
util_len += i2hex_nofill(blk, (uchar_ptr_t)&util_buff[util_len-1], 8);
util_buff[util_len-1] = 0;
util_out_print(util_buff, TRUE);
for (i = j = 0; i < patch_save_count; i++)
if (patch_save_set[i].blk == blk)
{
j++;
if (*patch_save_set[i].comment)
util_out_print("Version !UL Region !AD Comment: !AD!/", TRUE,
patch_save_set[i].ver, REG_LEN_STR(patch_save_set[i].region),
LEN_AND_STR(patch_save_set[i].comment));
else
util_out_print("Version !UL Region !AD!/", TRUE, patch_save_set[i].ver,
REG_LEN_STR(patch_save_set[i].region));
}
if (!j)
util_out_print("None.!/", TRUE);
return;
}
util_out_print("!/Save history:!/", TRUE);
for (i = j = 0; i < patch_save_count; i++)
{
util_len = sizeof("Block ");
memcpy(util_buff, "Block ", util_len);
util_len += i2hex_nofill(patch_save_set[i].blk, (uchar_ptr_t)&util_buff[util_len-1], 8);
util_buff[util_len-1] = 0;
util_out_print(util_buff, TRUE);
j++;
if (*patch_save_set[i].comment)
{
util_out_print("Version !UL Region !AD Comment: !AD!/", TRUE,
patch_save_set[i].ver, REG_LEN_STR(patch_save_set[i].region),
LEN_AND_STR(patch_save_set[i].comment));
} else
{
util_out_print("Version !UL Region !AD!/", TRUE, patch_save_set[i].ver,
REG_LEN_STR(patch_save_set[i].region));
}
}
if (!j)
util_out_print(" None.!/", TRUE);
return;
}
j = 1;
for (i = 0; i < patch_save_count; i++)
if (patch_save_set[i].blk == blk && patch_save_set[i].region == gv_cur_region
&& patch_save_set[i].ver >= j)
j = patch_save_set[i].ver + 1;
util_len = sizeof("!/Saving version !UL of block ");
memcpy(util_buff, "!/Saving version !UL of block ", util_len);
util_len += i2hex_nofill(blk, (uchar_ptr_t)&util_buff[util_len-1], 8);
util_buff[util_len-1] = 0;
util_out_print(util_buff, TRUE, j);
patch_save_set[patch_save_count].ver = j;
patch_save_set[patch_save_count].blk = blk;
patch_save_set[patch_save_count].region = gv_cur_region;
patch_save_set[patch_save_count].bp = (char *)malloc(cs_addrs->hdr->blk_size);
if (blk >= cs_addrs->ti->total_blks)
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
was_crit = cs_addrs->now_crit;
nocrit_present = (CLI_NEGATED == cli_present("CRIT"));
if (!was_crit)
{
if (nocrit_present)
cs_addrs->now_crit = TRUE;
else
grab_crit(gv_cur_region);
}
if (!(bp = t_qread(blk, &dummy_int, &dummy_cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
memcpy(patch_save_set[patch_save_count].bp, bp, cs_addrs->hdr->blk_size);
if (!was_crit)
{
if (nocrit_present)
cs_addrs->now_crit = FALSE;
else
rel_crit(gv_cur_region);
}
buff_len = sizeof(buff);
if ((cli_present("COMMENT") == CLI_PRESENT) && cli_get_str("COMMENT", buff, &buff_len))
{
ptr = &buff[buff_len];
*ptr = 0;
j = ptr - &buff[0] + 1;
patch_save_set[patch_save_count].comment = (char *)malloc(j);
memcpy(patch_save_set[patch_save_count].comment, &buff[0], j);
} else
patch_save_set[patch_save_count].comment = "";
patch_save_count++;
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_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 mu_reorg_upgrd_dwngrd(void)
{
blk_hdr new_hdr;
blk_segment *bs1, *bs_ptr;
block_id *blkid_ptr, curblk, curbmp, start_blk, stop_blk, start_bmp, last_bmp;
block_id startblk_input, stopblk_input;
boolean_t upgrade, downgrade, safejnl, nosafejnl, region, first_reorg_in_this_db_fmt, reorg_entiredb;
boolean_t startblk_specified, stopblk_specified, set_fully_upgraded, db_got_to_v5_once, mark_blk_free;
cache_rec_ptr_t cr;
char *bml_lcl_buff = NULL, *command, *reorg_command;
sm_uc_ptr_t bptr = NULL;
cw_set_element *cse;
enum cdb_sc cdb_status;
enum db_ver new_db_format, ondsk_blkver;
gd_region *reg;
int cycle;
int4 blk_seg_cnt, blk_size; /* needed for BLK_INIT,BLK_SEG and BLK_FINI macros */
int4 blocks_left, expected_blks2upgrd, actual_blks2upgrd, total_blks, free_blks;
int4 status, status1, mapsize, lcnt, bml_status;
reorg_stats_t reorg_stats;
sgmnt_addrs *csa;
sgmnt_data_ptr_t csd;
sm_uc_ptr_t blkBase, bml_sm_buff; /* shared memory pointer to the bitmap global buffer */
srch_hist alt_hist;
srch_blk_status *blkhist, bmlhist;
tp_region *rptr;
trans_num curr_tn;
unsigned char save_cw_set_depth;
uint4 lcl_update_trans;
region = (CLI_PRESENT == cli_present("REGION"));
upgrade = (CLI_PRESENT == cli_present("UPGRADE"));
downgrade = (CLI_PRESENT == cli_present("DOWNGRADE"));
assert(upgrade && !downgrade || !upgrade && downgrade);
command = upgrade ? "UPGRADE" : "DOWNGRADE";
reorg_command = upgrade ? "MUPIP REORG UPGRADE" : "MUPIP REORG DOWNGRADE";
reorg_entiredb = TRUE; /* unless STARTBLK or STOPBLK is specified we are going to {up,down}grade the entire database */
startblk_specified = FALSE;
assert(SIZEOF(block_id) == SIZEOF(uint4));
if ((CLI_PRESENT == cli_present("STARTBLK")) && (cli_get_hex("STARTBLK", (uint4 *)&startblk_input)))
{
reorg_entiredb = FALSE;
startblk_specified = TRUE;
}
stopblk_specified = FALSE;
assert(SIZEOF(block_id) == SIZEOF(uint4));
if ((CLI_PRESENT == cli_present("STOPBLK")) && (cli_get_hex("STOPBLK", (uint4 *)&stopblk_input)))
{
reorg_entiredb = FALSE;
stopblk_specified = TRUE;
}
mu_reorg_upgrd_dwngrd_in_prog = TRUE;
mu_reorg_nosafejnl = (CLI_NEGATED == cli_present("SAFEJNL")) ? TRUE : FALSE;
assert(region);
status = SS_NORMAL;
error_mupip = FALSE;
gvinit(); /* initialize gd_header (needed by the later call to mu_getlst) */
mu_getlst("REG_NAME", SIZEOF(tp_region)); /* get the parameter corresponding to REGION qualifier */
if (error_mupip)
{
util_out_print("!/MUPIP REORG !AD cannot proceed with above errors!/", TRUE, LEN_AND_STR(command));
mupip_exit(ERR_MUNOACTION);
}
assert(DBKEYSIZE(MAX_KEY_SZ) == gv_keysize); /* no need to invoke GVKEYSIZE_INIT_IF_NEEDED macro */
gv_target = targ_alloc(gv_keysize, NULL, NULL); /* t_begin needs this initialized */
gv_target_list = NULL;
memset(&alt_hist, 0, SIZEOF(alt_hist)); /* null-initialize history */
blkhist = &alt_hist.h[0];
for (rptr = grlist; NULL != rptr; rptr = rptr->fPtr)
{
if (mu_ctrly_occurred || mu_ctrlc_occurred)
break;
reg = rptr->reg;
util_out_print("!/Region !AD : MUPIP REORG !AD started", TRUE, REG_LEN_STR(reg), LEN_AND_STR(command));
if (reg_cmcheck(reg))
{
util_out_print("Region !AD : MUPIP REORG !AD cannot run across network",
TRUE, REG_LEN_STR(reg), LEN_AND_STR(command));
status = ERR_MUNOFINISH;
continue;
}
mu_reorg_process = TRUE; /* gvcst_init will use this value to use gtm_poollimit settings. */
gvcst_init(reg);
mu_reorg_process = FALSE;
assert(update_array != NULL);
/* access method stored in global directory and database file header might be different in which case
* the database setting prevails. therefore, the access method check can be done only after opening
* the database (i.e. after the gvcst_init)
*/
if (dba_bg != REG_ACC_METH(reg))
{
util_out_print("Region !AD : MUPIP REORG !AD cannot continue as access method is not BG",
TRUE, REG_LEN_STR(reg), LEN_AND_STR(command));
status = ERR_MUNOFINISH;
continue;
}
/* The mu_getlst call above uses insert_region to create the grlist, which ensures that duplicate regions mapping to
* the same db file correspond to only one grlist entry.
*/
assert(FALSE == reg->was_open);
TP_CHANGE_REG(reg); /* sets gv_cur_region, cs_addrs, cs_data */
csa = cs_addrs;
csd = cs_data;
blk_size = csd->blk_size; /* "blk_size" is used by the BLK_FINI macro */
if (reg->read_only)
{
gtm_putmsg_csa(CSA_ARG(csa) VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(reg));
status = ERR_MUNOFINISH;
continue;
}
assert(GDSVCURR == GDSV6); /* so we trip this assert in case GDSVCURR changes without a change to this module */
new_db_format = (upgrade ? GDSV6 : GDSV4);
grab_crit(reg);
curr_tn = csd->trans_hist.curr_tn;
/* set the desired db format in the file header to the appropriate version, increment transaction number */
status1 = desired_db_format_set(reg, new_db_format, reorg_command);
assert(csa->now_crit); /* desired_db_format_set() should not have released crit */
first_reorg_in_this_db_fmt = TRUE; /* with the current desired_db_format, this is the first reorg */
if (SS_NORMAL != status1)
{ /* "desired_db_format_set" would have printed appropriate error messages */
if (ERR_MUNOACTION != status1)
{ /* real error occurred while setting the db format. skip to next region */
status = ERR_MUNOFINISH;
rel_crit(reg);
continue;
}
util_out_print("Region !AD : Desired DB Format remains at !AD after !AD", TRUE, REG_LEN_STR(reg),
LEN_AND_STR(gtm_dbversion_table[new_db_format]), LEN_AND_STR(reorg_command));
if (csd->reorg_db_fmt_start_tn == csd->desired_db_format_tn)
first_reorg_in_this_db_fmt = FALSE;
} else
util_out_print("Region !AD : Desired DB Format set to !AD by !AD", TRUE, REG_LEN_STR(reg),
LEN_AND_STR(gtm_dbversion_table[new_db_format]), LEN_AND_STR(reorg_command));
assert(dba_bg == csd->acc_meth);
/* Check blks_to_upgrd counter to see if upgrade/downgrade is complete */
total_blks = csd->trans_hist.total_blks;
free_blks = csd->trans_hist.free_blocks;
actual_blks2upgrd = csd->blks_to_upgrd;
/* If MUPIP REORG UPGRADE and there is no block to upgrade in the database as indicated by BOTH
* "csd->blks_to_upgrd" and "csd->fully_upgraded", then we can skip processing.
* If MUPIP REORG UPGRADE and all non-free blocks need to be upgraded then again we can skip processing.
*/
if ((upgrade && (0 == actual_blks2upgrd) && csd->fully_upgraded)
|| (!upgrade && ((total_blks - free_blks) == actual_blks2upgrd)))
{
util_out_print("Region !AD : Blocks to Upgrade counter indicates no action needed for MUPIP REORG !AD",
TRUE, REG_LEN_STR(reg), LEN_AND_STR(command));
util_out_print("Region !AD : Total Blocks = [0x!XL] : Free Blocks = [0x!XL] : "
"Blocks to upgrade = [0x!XL]",
TRUE, REG_LEN_STR(reg), total_blks, free_blks, actual_blks2upgrd);
util_out_print("Region !AD : MUPIP REORG !AD finished!/", TRUE, REG_LEN_STR(reg), LEN_AND_STR(command));
rel_crit(reg);
continue;
}
stop_blk = total_blks;
if (stopblk_specified && stopblk_input <= stop_blk)
stop_blk = stopblk_input;
if (first_reorg_in_this_db_fmt)
{ /* Note down reorg start tn (in case we are interrupted, future reorg will know to resume) */
csd->reorg_db_fmt_start_tn = csd->desired_db_format_tn;
csd->reorg_upgrd_dwngrd_restart_block = 0;
start_blk = (startblk_specified ? startblk_input : 0);
} else
{ /* Either a concurrent MUPIP REORG of the same type ({up,down}grade) is currently running
* or a previously running REORG of the same type was interrupted (Ctrl-Ced).
* In either case resume processing from whatever restart block number is stored in fileheader
* the only exception is if "STARTBLK" was specified in the input in which use that unconditionally.
*/
start_blk = (startblk_specified ? startblk_input : csd->reorg_upgrd_dwngrd_restart_block);
}
if (start_blk > stop_blk)
start_blk = stop_blk;
mu_reorg_upgrd_dwngrd_start_tn = csd->reorg_db_fmt_start_tn;
/* Before releasing crit, flush the file-header and dirty buffers in cache to disk. This is because we are now
* going to read each GDS block directly from disk to determine if it needs to be upgraded/downgraded or not.
*/
if (!wcs_flu(WCSFLU_FLUSH_HDR)) /* wcs_flu assumes gv_cur_region is set (which it is in this routine) */
{
rel_crit(reg);
gtm_putmsg_csa(CSA_ARG(csa)
VARLSTCNT(6) ERR_BUFFLUFAILED, 4, LEN_AND_LIT("MUPIP REORG UPGRADE/DOWNGRADE"), DB_LEN_STR(reg));
status = ERR_MUNOFINISH;
continue;
}
rel_crit(reg);
/* Loop through entire database one GDS block at a time and upgrade/downgrade each of them */
status1 = SS_NORMAL;
start_bmp = ROUND_DOWN2(start_blk, BLKS_PER_LMAP);
last_bmp = ROUND_DOWN2(stop_blk - 1, BLKS_PER_LMAP);
curblk = start_blk; /* curblk is the block to be upgraded/downgraded */
util_out_print("Region !AD : Started processing from block number [0x!XL]", TRUE, REG_LEN_STR(reg), curblk);
if (NULL != bptr)
{ /* malloc/free "bptr" for each region as GDS block-size can be different */
free(bptr);
bptr = NULL;
}
memset(&reorg_stats, 0, SIZEOF(reorg_stats)); /* initialize statistics for this region */
for (curbmp = start_bmp; curbmp <= last_bmp; curbmp += BLKS_PER_LMAP)
{
if (mu_ctrly_occurred || mu_ctrlc_occurred)
{
status1 = ERR_MUNOFINISH;
break;
}
/* --------------------------------------------------------------
* Read in current bitmap block
* --------------------------------------------------------------
*/
assert(!csa->now_crit);
bml_sm_buff = t_qread(curbmp, (sm_int_ptr_t)&cycle, &cr); /* bring block into the cache outside of crit */
reorg_stats.blks_read_from_disk_bmp++;
grab_crit_encr_cycle_sync(reg); /* needed so t_qread does not return NULL below */
if (mu_reorg_upgrd_dwngrd_start_tn != csd->desired_db_format_tn)
{ /* csd->desired_db_format changed since reorg started. discontinue the reorg */
/* see later comment on "csd->reorg_upgrd_dwngrd_restart_block" for why the assignment
* of this field should be done only if a db format change did not occur.
*/
rel_crit(reg);
status1 = ERR_MUNOFINISH;
/* This "start_tn" check is redone after the for-loop and an error message is printed there */
break;
} else if (reorg_entiredb)
{ /* Change "csd->reorg_upgrd_dwngrd_restart_block" only if STARTBLK or STOPBLK was NOT specified */
assert(csd->reorg_upgrd_dwngrd_restart_block <= MAX(start_blk, curbmp));
csd->reorg_upgrd_dwngrd_restart_block = curbmp; /* previous blocks have been upgraded/downgraded */
}
/* Check blks_to_upgrd counter to see if upgrade/downgrade is complete.
* Repeat check done a few steps earlier outside of this for loop.
*/
total_blks = csd->trans_hist.total_blks;
free_blks = csd->trans_hist.free_blocks;
actual_blks2upgrd = csd->blks_to_upgrd;
if ((upgrade && (0 == actual_blks2upgrd) && csd->fully_upgraded)
|| (!upgrade && ((total_blks - free_blks) == actual_blks2upgrd)))
{
rel_crit(reg);
break;
}
bml_sm_buff = t_qread(curbmp, (sm_int_ptr_t)&cycle, &cr); /* now that in crit, note down stable buffer */
if (NULL == bml_sm_buff)
rts_error_csa(CSA_ARG(csa) VARLSTCNT(1) ERR_DSEBLKRDFAIL);
ondsk_blkver = cr->ondsk_blkver; /* note down db fmt on disk for bitmap block */
/* Take a copy of the shared memory bitmap buffer into process-private memory before releasing crit.
* We are interested in those blocks that are currently marked as USED in the bitmap.
* It is possible that once we release crit, concurrent updates change the bitmap state of those blocks.
* In that case, those updates will take care of doing the upgrade/downgrade of those blocks in the
* format currently set in csd->desired_db_format i.e. accomplishing MUPIP REORG UPGRADE/DOWNGRADE's job.
* If the desired_db_format changes concurrently, we will stop doing REORG UPGRADE/DOWNGRADE processing.
*/
if (NULL == bml_lcl_buff)
bml_lcl_buff = malloc(BM_SIZE(BLKS_PER_LMAP));
memcpy(bml_lcl_buff, (blk_hdr_ptr_t)bml_sm_buff, BM_SIZE(BLKS_PER_LMAP));
if (FALSE == cert_blk(reg, curbmp, (blk_hdr_ptr_t)bml_lcl_buff, 0, FALSE))
{ /* certify the block while holding crit as cert_blk uses fields from file-header (shared memory) */
assert(FALSE); /* in pro, skip ugprading/downgarding all blks in this unreliable local bitmap */
rel_crit(reg);
util_out_print("Region !AD : Bitmap Block [0x!XL] has integrity errors. Skipping this bitmap.",
TRUE, REG_LEN_STR(reg), curbmp);
status1 = ERR_MUNOFINISH;
continue;
}
rel_crit(reg);
/* ------------------------------------------------------------------------
* Upgrade/Downgrade all BUSY blocks in the current bitmap
* ------------------------------------------------------------------------
*/
curblk = (curbmp == start_bmp) ? start_blk : curbmp;
mapsize = (curbmp == last_bmp) ? (stop_blk - curbmp) : BLKS_PER_LMAP;
assert(0 != mapsize);
assert(mapsize <= BLKS_PER_LMAP);
db_got_to_v5_once = csd->db_got_to_v5_once;
for (lcnt = curblk - curbmp; lcnt < mapsize; lcnt++, curblk++)
{
if (mu_ctrly_occurred || mu_ctrlc_occurred)
{
status1 = ERR_MUNOFINISH;
goto stop_reorg_on_this_reg; /* goto needed because of nested FOR Loop */
}
GET_BM_STATUS(bml_lcl_buff, lcnt, bml_status);
assert(BLK_MAPINVALID != bml_status); /* cert_blk ran clean so we dont expect invalid entries */
if (BLK_FREE == bml_status)
{
reorg_stats.blks_skipped_free++;
continue;
}
/* MUPIP REORG UPGRADE/DOWNGRADE will convert USED & RECYCLED blocks */
if (db_got_to_v5_once || (BLK_RECYCLED != bml_status))
{ /* Do NOT read recycled V4 block from disk unless it is guaranteed NOT to be too full */
if (lcnt)
{ /* non-bitmap block */
/* read in block from disk into private buffer. dont pollute the cache yet */
if (NULL == bptr)
bptr = (sm_uc_ptr_t)malloc(blk_size);
status1 = dsk_read(curblk, bptr, &ondsk_blkver, FALSE);
/* dsk_read on curblk could return an error (DYNUPGRDFAIL) if curblk needs to be
* upgraded and if its block size was too big to allow the extra block-header space
* requirements for a dynamic upgrade. a MUPIP REORG DOWNGRADE should not error out
* in that case as the block is already in the downgraded format.
*/
if (SS_NORMAL != status1)
{
if (!upgrade && (ERR_DYNUPGRDFAIL == status1))
{
assert(GDSV4 == new_db_format);
ondsk_blkver = new_db_format;
} else
{
gtm_putmsg_csa(CSA_ARG(csa)
VARLSTCNT(5) ERR_DBFILERR, 2, DB_LEN_STR(reg), status1);
util_out_print("Region !AD : Error occurred while reading block "
"[0x!XL]", TRUE, REG_LEN_STR(reg), curblk);
status1 = ERR_MUNOFINISH;
goto stop_reorg_on_this_reg;/* goto needed due to nested FOR Loop */
}
}
reorg_stats.blks_read_from_disk_nonbmp++;
} /* else bitmap block has been read in crit earlier and ondsk_blkver appropriately set */
if (new_db_format == ondsk_blkver)
{
assert((SS_NORMAL == status1) || (!upgrade && (ERR_DYNUPGRDFAIL == status1)));
status1 = SS_NORMAL; /* treat DYNUPGRDFAIL as no error in case of downgrade */
reorg_stats.blks_skipped_newfmtindisk++;
continue; /* current disk version is identical to what is desired */
}
assert(SS_NORMAL == status1);
}
/* Begin non-TP transaction to upgrade/downgrade the block.
* The way we do that is by updating the block using a null update array.
* Any update to a block will trigger an automatic upgrade/downgrade of the block based on
* the current fileheader desired_db_format setting and we use that here.
*/
t_begin(ERR_MUREORGFAIL, UPDTRNS_DB_UPDATED_MASK);
for (; ;)
{
CHECK_AND_RESET_UPDATE_ARRAY; /* reset update_array_ptr to update_array */
curr_tn = csd->trans_hist.curr_tn;
db_got_to_v5_once = csd->db_got_to_v5_once;
if (db_got_to_v5_once || (BLK_RECYCLED != bml_status))
{
blkhist->cse = NULL; /* start afresh (do not use value from previous retry) */
blkBase = t_qread(curblk, (sm_int_ptr_t)&blkhist->cycle, &blkhist->cr);
if (NULL == blkBase)
{
t_retry((enum cdb_sc)rdfail_detail);
continue;
}
blkhist->blk_num = curblk;
blkhist->buffaddr = blkBase;
ondsk_blkver = blkhist->cr->ondsk_blkver;
new_hdr = *(blk_hdr_ptr_t)blkBase;
mu_reorg_upgrd_dwngrd_blktn = new_hdr.tn;
mark_blk_free = FALSE;
inctn_opcode = upgrade ? inctn_blkupgrd : inctn_blkdwngrd;
} else
{
mark_blk_free = TRUE;
inctn_opcode = inctn_blkmarkfree;
}
inctn_detail.blknum_struct.blknum = curblk;
/* t_end assumes that the history it is passed does not contain a bitmap block.
* for bitmap block, the history validation information is passed through cse instead.
* therefore we need to handle bitmap and non-bitmap cases separately.
*/
if (!lcnt)
{ /* Means a bitmap block.
* At this point we can do a "new_db_format != ondsk_blkver" check to determine
* if the block got converted since we did the dsk_read (see the non-bitmap case
* for a similar check done there), but in that case we will have a transaction
* which has read 1 bitmap block and is updating no block. "t_end" currently cannot
* handle this case as it expects any bitmap block that needs validation to also
* have a corresponding cse which will hold its history. Hence we avoid doing the
* new_db_format check. The only disadvantage of this is that we will end up
* modifying the bitmap block as part of this transaction (in an attempt to convert
* its ondsk_blkver) even though it is already in the right format. Since this
* overhead is going to be one per bitmap block and since the block is in the cache
* at this point, we should not lose much.
*/
assert(!mark_blk_free);
BLK_ADDR(blkid_ptr, SIZEOF(block_id), block_id);
*blkid_ptr = 0;
t_write_map(blkhist, (unsigned char *)blkid_ptr, curr_tn, 0);
assert(&alt_hist.h[0] == blkhist);
alt_hist.h[0].blk_num = 0; /* create empty history for bitmap block */
assert(update_trans);
} else
{ /* non-bitmap block. fill in history for validation in t_end */
assert(curblk); /* we should never come here for block 0 (bitmap) */
if (!mark_blk_free)
{
assert(blkhist->blk_num == curblk);
assert(blkhist->buffaddr == blkBase);
blkhist->tn = curr_tn;
alt_hist.h[1].blk_num = 0;
}
/* Also need to pass the bitmap as history to detect if any concurrent M-kill
* is freeing up the same USED block that we are trying to convert OR if any
* concurrent M-set is reusing the same RECYCLED block that we are trying to
* convert. Because of t_end currently not being able to validate a bitmap
* without that simultaneously having a cse, we need to create a cse for the
* bitmap that is used only for bitmap history validation, but should not be
* used to update the contents of the bitmap block in bg_update.
*/
bmlhist.buffaddr = t_qread(curbmp, (sm_int_ptr_t)&bmlhist.cycle, &bmlhist.cr);
if (NULL == bmlhist.buffaddr)
{
t_retry((enum cdb_sc)rdfail_detail);
continue;
}
bmlhist.blk_num = curbmp;
bmlhist.tn = curr_tn;
GET_BM_STATUS(bmlhist.buffaddr, lcnt, bml_status);
if (BLK_MAPINVALID == bml_status)
{
t_retry(cdb_sc_lostbmlcr);
continue;
}
if (!mark_blk_free)
{
if ((new_db_format != ondsk_blkver) && (BLK_FREE != bml_status))
{ /* block still needs to be converted. create cse */
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, blkBase + 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)blkBase)->levl, FALSE,
FALSE, GDS_WRITE_PLAIN);
/* The directory tree status for now is only used to determine
* whether writing the block to snapshot file (see t_end_sysops.c).
* For reorg upgrade/downgrade process, the block is updated in a
* sequential way without changing the gv_target. In this case, we
* assume the block is in directory tree so as to have it written to
* the snapshot file.
*/
BIT_SET_DIR_TREE(cw_set[cw_set_depth-1].blk_prior_state);
/* reset update_trans in case previous retry had set it to 0 */
update_trans = UPDTRNS_DB_UPDATED_MASK;
if (BLK_RECYCLED == bml_status)
{ /* If block that we are upgarding is RECYCLED, indicate to
* bg_update that blks_to_upgrd counter should NOT be
* touched in this case by setting "mode" to a special value
*/
assert(cw_set[cw_set_depth-1].mode == gds_t_write);
cw_set[cw_set_depth-1].mode = gds_t_write_recycled;
/* we SET block as NOT RECYCLED, otherwise, the mm_update()
* or bg_update_phase2 may skip writing it to snapshot file
* when its level is 0
*/
BIT_CLEAR_RECYCLED(cw_set[cw_set_depth-1].blk_prior_state);
}
} else
{ /* Block got converted by another process since we did the dsk_read.
* or this block became marked free in the bitmap.
* No need to update this block. just call t_end for validation of
* both the non-bitmap block as well as the bitmap block.
* Note down that this transaction is no longer updating any blocks.
*/
update_trans = 0;
}
/* Need to put bit maps on the end of the cw set for concurrency checking.
* We want to simulate t_write_map, except we want to update "cw_map_depth"
* instead of "cw_set_depth". Hence the save and restore logic below.
* This part of the code is similar to the one in mu_swap_blk.c
*/
save_cw_set_depth = cw_set_depth;
assert(!cw_map_depth);
t_write_map(&bmlhist, NULL, curr_tn, 0); /* will increment cw_set_depth */
cw_map_depth = cw_set_depth; /* set cw_map_depth to latest cw_set_depth */
cw_set_depth = save_cw_set_depth;/* restore cw_set_depth */
/* t_write_map simulation end */
} else
{
if (BLK_RECYCLED != bml_status)
{ /* Block was RECYCLED at beginning but no longer so. Retry */
t_retry(cdb_sc_bmlmod);
continue;
}
/* Mark recycled block as FREE in bitmap */
assert(lcnt == (curblk - curbmp));
assert(update_array_ptr == update_array);
*((block_id *)update_array_ptr) = lcnt;
update_array_ptr += SIZEOF(block_id);
/* the following assumes SIZEOF(block_id) == SIZEOF(int) */
assert(SIZEOF(block_id) == SIZEOF(int));
*(int *)update_array_ptr = 0;
t_write_map(&bmlhist, (unsigned char *)update_array, curr_tn, 0);
update_trans = UPDTRNS_DB_UPDATED_MASK;
}
}
assert(SIZEOF(lcl_update_trans) == SIZEOF(update_trans));
lcl_update_trans = update_trans; /* take a copy before t_end modifies it */
if ((trans_num)0 != t_end(&alt_hist, NULL, TN_NOT_SPECIFIED))
{ /* In case this is MM and t_end() remapped an extended database, reset csd */
assert(csd == cs_data);
if (!lcl_update_trans)
{
assert(lcnt);
assert(!mark_blk_free);
assert((new_db_format == ondsk_blkver) || (BLK_BUSY != bml_status));
if (BLK_BUSY != bml_status)
reorg_stats.blks_skipped_free++;
else
reorg_stats.blks_skipped_newfmtincache++;
} else if (!lcnt)
reorg_stats.blks_converted_bmp++;
else
reorg_stats.blks_converted_nonbmp++;
break;
}
assert(csd == cs_data);
}
}
}
stop_reorg_on_this_reg:
/* even though ctrl-c occurred, update file-header fields to store reorg's progress before exiting */
grab_crit(reg);
blocks_left = 0;
assert(csd->trans_hist.total_blks >= csd->blks_to_upgrd);
actual_blks2upgrd = csd->blks_to_upgrd;
total_blks = csd->trans_hist.total_blks;
free_blks = csd->trans_hist.free_blocks;
/* Care should be taken not to set "csd->reorg_upgrd_dwngrd_restart_block" in case of a concurrent db fmt
* change. This is because let us say we are doing REORG UPGRADE. A concurrent REORG DOWNGRADE would
* have reset "csd->reorg_upgrd_dwngrd_restart_block" field to 0 and if that reorg is interrupted by a
* Ctrl-C (before this reorg came here) it would have updated "csd->reorg_upgrd_dwngrd_restart_block" to
* a non-zero value indicating how many blocks from 0 have been downgraded. We should not reset this
* field to "curblk" as it will be mis-interpreted as the number of blocks that have been DOWNgraded.
*/
set_fully_upgraded = FALSE;
if (mu_reorg_upgrd_dwngrd_start_tn != csd->desired_db_format_tn)
{ /* csd->desired_db_format changed since reorg started. discontinue the reorg */
util_out_print("Region !AD : Desired DB Format changed during REORG. Stopping REORG.",
TRUE, REG_LEN_STR(reg));
status1 = ERR_MUNOFINISH;
} else if (reorg_entiredb)
{ /* Change "csd->reorg_upgrd_dwngrd_restart_block" only if STARTBLK or STOPBLK was NOT specified */
assert(csd->reorg_upgrd_dwngrd_restart_block <= curblk);
csd->reorg_upgrd_dwngrd_restart_block = curblk; /* blocks lesser than this have been upgraded/downgraded */
expected_blks2upgrd = upgrade ? 0 : (total_blks - free_blks);
blocks_left = upgrade ? actual_blks2upgrd : (expected_blks2upgrd - actual_blks2upgrd);
/* If this reorg command went through all blocks in the database, then it should have
* correctly concluded at this point whether the reorg is complete or not.
* If this reorg command started from where a previous incomplete reorg left
* (i.e. first_reorg_in_this_db_fmt is FALSE), it cannot determine if the initial
* GDS blocks that it skipped are completely {up,down}graded or not.
*/
assert((0 == blocks_left) || (SS_NORMAL != status1) || !first_reorg_in_this_db_fmt);
/* If this is a MUPIP REORG UPGRADE that did go through every block in the database (indicated by
* "reorg_entiredb" && "first_reorg_in_this_db_fmt") and the current count of "blks_to_upgrd" is
* 0 in the file-header and the desired_db_format did not change since the start of the REORG,
* we can be sure that the entire database has been upgraded. Set "csd->fully_upgraded" to TRUE.
*/
if ((SS_NORMAL == status1) && first_reorg_in_this_db_fmt && upgrade && (0 == actual_blks2upgrd))
{
csd->fully_upgraded = TRUE;
csd->db_got_to_v5_once = TRUE;
set_fully_upgraded = TRUE;
}
/* flush all changes noted down in the file-header */
if (!wcs_flu(WCSFLU_FLUSH_HDR)) /* wcs_flu assumes gv_cur_region is set (which it is in this routine) */
{
gtm_putmsg_csa(CSA_ARG(csa) VARLSTCNT(6) ERR_BUFFLUFAILED, 4,
LEN_AND_LIT("MUPIP REORG UPGRADE/DOWNGRADE"), DB_LEN_STR(reg));
status = ERR_MUNOFINISH;
rel_crit(reg);
continue;
}
}
curr_tn = csd->trans_hist.curr_tn;
rel_crit(reg);
util_out_print("Region !AD : Stopped processing at block number [0x!XL]", TRUE, REG_LEN_STR(reg), curblk);
/* Print statistics */
util_out_print("Region !AD : Statistics : Blocks Read From Disk (Bitmap) : 0x!XL",
TRUE, REG_LEN_STR(reg), reorg_stats.blks_read_from_disk_bmp);
util_out_print("Region !AD : Statistics : Blocks Skipped (Free) : 0x!XL",
TRUE, REG_LEN_STR(reg), reorg_stats.blks_skipped_free);
util_out_print("Region !AD : Statistics : Blocks Read From Disk (Non-Bitmap) : 0x!XL",
TRUE, REG_LEN_STR(reg), reorg_stats.blks_read_from_disk_nonbmp);
util_out_print("Region !AD : Statistics : Blocks Skipped (new fmt in disk) : 0x!XL",
TRUE, REG_LEN_STR(reg), reorg_stats.blks_skipped_newfmtindisk);
util_out_print("Region !AD : Statistics : Blocks Skipped (new fmt in cache) : 0x!XL",
TRUE, REG_LEN_STR(reg), reorg_stats.blks_skipped_newfmtincache);
util_out_print("Region !AD : Statistics : Blocks Converted (Bitmap) : 0x!XL",
TRUE, REG_LEN_STR(reg), reorg_stats.blks_converted_bmp);
util_out_print("Region !AD : Statistics : Blocks Converted (Non-Bitmap) : 0x!XL",
TRUE, REG_LEN_STR(reg), reorg_stats.blks_converted_nonbmp);
if (reorg_entiredb && (SS_NORMAL == status1) && (0 != blocks_left))
{ /* file-header counter does not match what reorg on the entire database expected to see */
gtm_putmsg_csa(CSA_ARG(csa) VARLSTCNT(4) ERR_DBBTUWRNG, 2, expected_blks2upgrd, actual_blks2upgrd);
util_out_print("Region !AD : Run MUPIP INTEG (without FAST qualifier) to fix the counter",
TRUE, REG_LEN_STR(reg));
status1 = ERR_MUNOFINISH;
} else
util_out_print("Region !AD : Total Blocks = [0x!XL] : Free Blocks = [0x!XL] : "
"Blocks to upgrade = [0x!XL]",
TRUE, REG_LEN_STR(reg), total_blks, free_blks, actual_blks2upgrd);
/* Issue success or failure message for this region */
if (SS_NORMAL == status1)
{ /* issue success only if REORG did not encounter any error in its processing */
if (set_fully_upgraded)
util_out_print("Region !AD : Database is now FULLY UPGRADED", TRUE, REG_LEN_STR(reg));
util_out_print("Region !AD : MUPIP REORG !AD finished!/", TRUE, REG_LEN_STR(reg), LEN_AND_STR(command));
send_msg_csa(CSA_ARG(csa) VARLSTCNT(7) ERR_MUREUPDWNGRDEND, 5, REG_LEN_STR(reg),
process_id, process_id, &curr_tn);
} else
{
assert(ERR_MUNOFINISH == status1);
assert((SS_NORMAL == status) || (ERR_MUNOFINISH == status));
util_out_print("Region !AD : MUPIP REORG !AD incomplete. See above messages.!/",
TRUE, REG_LEN_STR(reg), LEN_AND_STR(command));
status = status1;
}
}
if (NULL != bptr)
free(bptr);
if (NULL != bml_lcl_buff)
free(bml_lcl_buff);
if (mu_ctrly_occurred || mu_ctrlc_occurred)
{
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_REORGCTRLY);
status = ERR_MUNOFINISH;
}
mupip_exit(status);
}
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);
}
void mupip_backup(void)
{
bool journal;
char *tempdirname, *tempfilename, *ptr;
uint4 level, blk, status, ret;
unsigned short s_len, length, ntries;
int4 size, gds_ratio, buff_size, i, crit_counter;
uint4 ustatus;
size_t backup_buf_size;
trans_num tn;
backup_buff_ptr_t bptr;
static boolean_t once = TRUE;
backup_reg_list *rptr, *clnup_ptr;
boolean_t inc_since_inc , inc_since_rec, result, newjnlfiles, gotit,
newjnlfiles_specified, keep_prev_link, bkdbjnl_disable_specified, bkdbjnl_off_specified;
unsigned char since_buff[50];
jnl_create_info jnl_info;
file_control *fc;
char tempdir_trans_buffer[MAX_TRANS_NAME_LEN],
tempnam_prefix[MAX_FN_LEN], tempdir_full_buffer[MAX_FN_LEN + 1], jnl_file_name[JNL_NAME_SIZE];
char *jnl_str_ptr, rep_str[256], jnl_str[256], entry[256],
full_jnl_fn[JNL_NAME_SIZE], prev_jnl_fn[JNL_NAME_SIZE];
int ccnt, index, comparison, num, jnl_fstat;
mstr tempdir_log, tempdir_trans, *file, tempdir_full, filestr;
uint4 jnl_status, temp_file_name_len, tempdir_trans_len, trans_log_name_status;
#if defined(VMS)
struct FAB temp_fab;
struct NAM temp_nam;
struct XABPRO temp_xabpro;
short iosb[4];
char def_jnl_fn[MAX_FN_LEN];
GDS_INFO *gds_info;
char exp_file_name[MAX_FN_LEN];
uint4 exp_file_name_len;
#elif defined(UNIX)
struct stat stat_buf;
int fstat_res;
int sync_io_status;
boolean_t sync_io, sync_io_specified;
#else
# error UNSUPPORTED PLATFORM
#endif
boolean_t jnl_options[jnl_end_of_list] = {FALSE, FALSE, FALSE}, save_no_prev_link;
error_def(ERR_BACKUPCTRL);
error_def(ERR_MUPCLIERR);
error_def(ERR_FREEZECTRL);
error_def(ERR_DBRDONLY);
error_def(ERR_DBFILERR);
error_def(ERR_MUNOACTION);
error_def(ERR_MUNOFINISH);
error_def(ERR_BACKUP2MANYKILL);
error_def(ERR_MUSELFBKUP);
error_def(ERR_JNLNOCREATE);
error_def(ERR_JNLCREATE);
error_def(ERR_PREVJNLLINKCUT);
error_def(ERR_JNLSTATE);
error_def(ERR_FILEEXISTS);
error_def(ERR_JNLDISABLE);
error_def(ERR_FILEPARSE);
error_def(ERR_JNLFNF);
error_def(ERR_NOTRNDMACC);
/* ==================================== STEP 1. Initialization ======================================= */
ret = SS_NORMAL;
jnl_str_ptr = &jnl_str[0];
halt_ptr = grlist = NULL;
in_backup = TRUE;
inc_since_inc = inc_since_rec = file_backed_up = error_mupip = FALSE;
debug_mupip = (CLI_PRESENT == cli_present("DBG"));
mu_outofband_setup();
jnl_status = 0;
if (once)
{
gvinit();
once = FALSE;
}
/* ============================ STEP 2. Parse and construct grlist ================================== */
if (incremental = (CLI_PRESENT == cli_present("INCREMENTAL") || CLI_PRESENT == cli_present("BYTESTREAM")))
{
int4 temp_tn;
if (0 == cli_get_hex("TRANSACTION", &temp_tn))
{
temp_tn = 0;
s_len = sizeof(since_buff);
if (cli_get_str("SINCE", (char *)since_buff, &s_len))
{
lower_to_upper(since_buff, since_buff, s_len);
if ((0 == memcmp(since_buff, "INCREMENTAL", s_len))
|| (0 == memcmp(since_buff, "BYTESTREAM", s_len)))
inc_since_inc = TRUE;
else if (0 == memcmp(since_buff, "RECORD", s_len))
inc_since_rec = TRUE;
}
} else if (temp_tn < 1)
{
util_out_print("The minimum allowable transaction number is one.", TRUE);
mupip_exit(ERR_MUNOACTION);
}
tn = (trans_num)temp_tn;
}
online = (TRUE != cli_negated("ONLINE"));
record = (CLI_PRESENT == cli_present("RECORD"));
newjnlfiles_specified = FALSE;
newjnlfiles = TRUE; /* by default */
keep_prev_link = TRUE;
if (CLI_PRESENT == cli_present("NEWJNLFILES"))
{
newjnlfiles_specified = newjnlfiles = TRUE;
if (CLI_NEGATED == cli_present("NEWJNLFILES.PREVLINK"))
keep_prev_link = FALSE;
UNIX_ONLY(
sync_io_status = cli_present("NEWJNLFILES.SYNC_IO");
sync_io_specified = TRUE;
if (CLI_PRESENT == sync_io_status)
sync_io = TRUE;
else if (CLI_NEGATED == sync_io_status)
sync_io = FALSE;
else
sync_io_specified = FALSE;
)
} else if (CLI_NEGATED == cli_present("NEWJNLFILES"))
void dse_f_free(void)
{
block_id blk;
bool in_last_bmap;
char util_buff[MAX_UTIL_LEN];
sm_uc_ptr_t lmap_base;
int4 bplmap, total_blks;
int4 util_len, master_bit, lmap_bit, hint_over_bplmap, hint_mod_bplmap;
boolean_t was_crit;
int4 dummy_int, nocrit_present;
cache_rec_ptr_t dummy_cr;
error_def(ERR_DSEBLKRDFAIL);
if (cs_addrs->hdr->bplmap == 0)
{ util_out_print("Cannot perform free block search: bplmap field of file header is zero.", TRUE);
return;
}
bplmap = cs_addrs->hdr->bplmap;
if(!cli_get_hex("HINT", (uint4 *)&blk))
return;
if (blk < 0 || blk >= cs_addrs->ti->total_blks || (blk / bplmap * bplmap == blk))
{ util_out_print("Error: invalid block number.", TRUE);
return;
}
hint_over_bplmap = blk / bplmap;
master_bit = bmm_find_free(hint_over_bplmap, cs_addrs->bmm,
(cs_addrs->ti->total_blks + bplmap - 1)/ bplmap);
if (master_bit == -1)
{ util_out_print("Error: database full.", TRUE);
return;
}
in_last_bmap = (master_bit == (cs_addrs->ti->total_blks / bplmap));
was_crit = cs_addrs->now_crit;
nocrit_present = (CLI_NEGATED == cli_present("CRIT"));
DSE_GRAB_CRIT_AS_APPROPRIATE(was_crit, nocrit_present, cs_addrs, gv_cur_region);
if(!(lmap_base = t_qread(master_bit * bplmap, &dummy_int, &dummy_cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
if (master_bit == hint_over_bplmap)
hint_mod_bplmap = blk - blk / bplmap * bplmap;
else
hint_mod_bplmap = 0;
if (in_last_bmap)
total_blks = (cs_addrs->ti->total_blks - master_bit);
else
total_blks = bplmap;
lmap_bit = bml_find_free(hint_mod_bplmap, lmap_base + SIZEOF(blk_hdr), total_blks);
if (lmap_bit == -1)
{ memcpy(util_buff, "Error: bit map in block ", 24);
util_len = 24;
util_len += i2hex_nofill(master_bit * bplmap, (uchar_ptr_t)&util_buff[util_len], 8);
memcpy(&util_buff[util_len], " incorrectly marked free in master map.", 39);
util_len += 39;
util_buff[util_len] = 0;
util_out_print(util_buff, TRUE);
DSE_REL_CRIT_AS_APPROPRIATE(was_crit, nocrit_present, cs_addrs, gv_cur_region);
return;
}
memcpy(util_buff, "!/Next free block is ", 21);
util_len = 21;
util_len += i2hex_nofill(master_bit * bplmap + lmap_bit, (uchar_ptr_t)&util_buff[util_len], 8);
memcpy(&util_buff[util_len], ".!/", 3);
util_len += 3;
util_buff[util_len] = 0;
util_out_print(util_buff, TRUE);
DSE_REL_CRIT_AS_APPROPRIATE(was_crit, nocrit_present, cs_addrs, gv_cur_region);
return;
}
void dse_range(void)
{
char lower[256], targ_key[256], upper[256], util_buff[MAX_UTIL_LEN];
block_id from, to, blk, blk_child;
sm_uc_ptr_t bp, b_top, key_bot, key_top, key_top1, rp, r_top;
char level;
int4 dummy_int, nocrit_present;
cache_rec_ptr_t dummy_cr;
short int rsize, size, size1;
int cnt, dummy, lower_len, util_len, upper_len;
boolean_t busy_matters, free, got_lonely_star, index, low, lost, star, up, was_crit, was_hold_onto_crit;
if (cli_present("FROM") == CLI_PRESENT)
{
if (!cli_get_hex("FROM", (uint4 *)&from))
return;
if (from < 0 || from > cs_addrs->ti->total_blks
|| !(from % cs_addrs->hdr->bplmap))
{
util_out_print("Error: invalid block number.", TRUE);
return;
}
}
else
from = 1;
if (cli_present("TO") == CLI_PRESENT)
{
if(!cli_get_hex("TO", (uint4 *)&to))
return;
if (to < 0 || to > cs_addrs->ti->total_blks
|| !(to % cs_addrs->hdr->bplmap))
{
util_out_print("Error: invalid block number.", TRUE);
return;
}
}
else
to = cs_addrs->ti->total_blks - 1;
if (low = (cli_present("LOWER") == CLI_PRESENT))
{
if (!dse_getki(&lower[0], &lower_len, LIT_AND_LEN("LOWER")))
return;
}
if (up = (cli_present("UPPER") == CLI_PRESENT))
{
if (!dse_getki(&upper[0], &upper_len, LIT_AND_LEN("UPPER")))
return;
}
star = (cli_present("STAR") == CLI_PRESENT);
if (!low && !up && !star)
{
util_out_print("Must specify star, or a lower or upper key limit.", TRUE);
return;
}
index = (cli_present("INDEX") == CLI_PRESENT);
lost = (cli_present("LOST") == CLI_PRESENT);
dummy = cli_present("BUSY");
if (dummy == CLI_PRESENT)
{
busy_matters = TRUE;
free = FALSE;
}
else if (dummy == CLI_NEGATED)
busy_matters = free = TRUE;
else
busy_matters = free = FALSE;
patch_path[0] = get_dir_root();
cnt = 0;
was_crit = cs_addrs->now_crit;
nocrit_present = (CLI_NEGATED == cli_present("CRIT"));
DSE_GRAB_CRIT_AS_APPROPRIATE(was_crit, was_hold_onto_crit, nocrit_present, cs_addrs, gv_cur_region);
for (blk = from; blk <= to ;blk++)
{
if (util_interrupt)
{
DSE_REL_CRIT_AS_APPROPRIATE(was_crit, was_hold_onto_crit, nocrit_present, cs_addrs, gv_cur_region);
rts_error(VARLSTCNT(1) ERR_CTRLC);
break;
}
if (!(blk % cs_addrs->hdr->bplmap))
continue;
if (!(bp = t_qread(blk, &dummy_int, &dummy_cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
level = ((blk_hdr_ptr_t)bp)->levl;
if (index && (level == 0))
continue;
if (busy_matters && (free != dse_is_blk_free(blk, &dummy_int, &dummy_cr)))
continue;
if (((blk_hdr_ptr_t) bp)->bsiz > cs_addrs->hdr->blk_size)
b_top = bp + cs_addrs->hdr->blk_size;
else if (((blk_hdr_ptr_t) bp)->bsiz < SIZEOF(blk_hdr))
b_top = bp + SIZEOF(blk_hdr);
else
b_top = bp + ((blk_hdr_ptr_t) bp)->bsiz;
rp = bp + SIZEOF(blk_hdr);
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)
r_top = b_top;
got_lonely_star = FALSE;
if (((blk_hdr_ptr_t) bp)->levl)
{
key_top = r_top - SIZEOF(block_id);
if (star && (r_top == b_top))
got_lonely_star = TRUE;
} else
{
if (!up && !low)
continue;
for (key_top = rp + SIZEOF(rec_hdr); key_top < r_top ; )
if (!*key_top++ && !*key_top++)
break;
}
if (!got_lonely_star)
{
key_bot = rp + SIZEOF(rec_hdr);
size = key_top - key_bot;
if (size <= 0)
continue;
if (size > SIZEOF(targ_key))
size = SIZEOF(targ_key);
if (lost)
{
for (key_top1 = rp + SIZEOF(rec_hdr); key_top1 < r_top ; )
if (!*key_top1++)
break;
size1 = key_top1 - rp - SIZEOF(rec_hdr);
if (size1 > SIZEOF(targ_key))
size1 = SIZEOF(targ_key);
patch_find_root_search = TRUE;
patch_path_count = 1;
patch_find_blk = blk;
if (dse_is_blk_in(rp, r_top, size1))
continue;
}
if (low && memcmp(lower, key_bot, MIN(lower_len, size)) > 0)
continue;
if (up && memcmp(upper, key_bot, MIN(upper_len, size)) < 0)
continue;
} else
{
got_lonely_star = FALSE;
if (lost)
{
blk_child = *(block_id_ptr_t)key_top;
if (!(bp = t_qread(blk_child, &dummy_int, &dummy_cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
if (((blk_hdr_ptr_t) bp)->bsiz > cs_addrs->hdr->blk_size)
b_top = bp + cs_addrs->hdr->blk_size;
else if (((blk_hdr_ptr_t) bp)->bsiz < SIZEOF(blk_hdr))
b_top = bp + SIZEOF(blk_hdr);
else
b_top = bp + ((blk_hdr_ptr_t) bp)->bsiz;
rp = bp + SIZEOF(blk_hdr);
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)
r_top = b_top;
if (((blk_hdr_ptr_t) bp)->levl)
key_top = r_top - SIZEOF(block_id);
for (key_top1 = rp + SIZEOF(rec_hdr); key_top1 < r_top ; )
if (!*key_top1++)
break;
size1 = key_top1 - rp - SIZEOF(rec_hdr);
if (size1 > 0)
{
if (size1 > SIZEOF(targ_key))
size1 = SIZEOF(targ_key);
patch_find_root_search = TRUE;
patch_path_count = 1;
patch_find_blk = blk;
if (dse_is_blk_in(rp, r_top, size1))
continue;
}
}
}
if (!cnt++)
util_out_print("!/Blocks in the specified key range:", TRUE);
util_out_print("Block: !8XL Level: !2UL", TRUE, blk, level);
}
DSE_REL_CRIT_AS_APPROPRIATE(was_crit, was_hold_onto_crit, nocrit_present, cs_addrs, gv_cur_region);
if (cnt)
util_out_print("Found !UL blocks", TRUE, cnt);
else
util_out_print("None found.", TRUE);
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;
}
