void dse_f_free(void)
{
block_id blk;
boolean_t in_last_bmap, was_crit, was_hold_onto_crit;
cache_rec_ptr_t dummy_cr;
char util_buff[MAX_UTIL_LEN];
int4 bplmap, dummy_int, hint_mod_bplmap, hint_over_bplmap;
int4 lmap_bit, master_bit, nocrit_present, total_blks, util_len;
sm_uc_ptr_t lmap_base;
if (0 == cs_addrs->hdr->bplmap)
{ util_out_print("Cannot perform free block search: bplmap field of file header is zero.", TRUE);
return;
}
bplmap = cs_addrs->hdr->bplmap;
if (BADDSEBLK == (blk = dse_getblk("HINT", DSEBMLOK, DSEBLKNOCUR))) /* WARNING: assignment */
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 (-1 == master_bit)
{ 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, was_hold_onto_crit, nocrit_present, cs_addrs, gv_cur_region);
if(!(lmap_base = t_qread(master_bit * bplmap, &dummy_int, &dummy_cr)))
rts_error_csa(CSA_ARG(cs_addrs) 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 (-1 == lmap_bit)
{ 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, was_hold_onto_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, was_hold_onto_crit, nocrit_present, cs_addrs, gv_cur_region);
return;
}
/* This routine returns whether the free_blocks counter in the file-header is ok (TRUE) or not (FALSE).
* If not, it corrects it. This assumes cs_addrs, cs_data and gv_cur_region to point to the region of interest.
* It also assumes that the master-map is correct and finds out non-full local bitmaps and counts the number of
* free blocks in each of them and sums them up to determine the perceived correct free_blocks count.
* The reason why this is ok is that even if the master-map incorrectly reports a local bitmap as full, our new free_blocks
* count will effectively make the free space in that local-bitmap invisible and make a gdsfilext necessary and valid.
* A later mupip integ will scavenge that invisible space for us. The worst that can therefore happen is that we will transiently
* not be using up existing space. But we will always ensure that the free_blocks counter goes in sync with the master-map.
*/
boolean_t is_free_blks_ctr_ok(void)
{
boolean_t blk_used;
block_id bml, free_bit, free_bml, maxbitsthismap;
cache_rec_ptr_t cr;
int cycle;
sm_uc_ptr_t bmp;
unsigned int local_maps, total_blks, free_blocks;
error_def(ERR_DBBADFREEBLKCTR);
assert(&FILE_INFO(gv_cur_region)->s_addrs == cs_addrs && cs_addrs->hdr == cs_data && cs_addrs->now_crit);
total_blks = (dba_mm == cs_data->acc_meth) ? cs_addrs->total_blks : cs_addrs->ti->total_blks;
local_maps = DIVIDE_ROUND_UP(total_blks, BLKS_PER_LMAP);
for (free_blocks = 0, free_bml = 0; free_bml < local_maps; free_bml++)
{
bml = bmm_find_free((uint4)free_bml, (sm_uc_ptr_t)MM_ADDR(cs_data), local_maps);
if (bml < free_bml)
break;
free_bml = bml;
bml *= BLKS_PER_LMAP;
if (!(bmp = t_qread(bml, (sm_int_ptr_t)&cycle, &cr))
|| (BM_SIZE(BLKS_PER_LMAP) != ((blk_hdr_ptr_t)bmp)->bsiz)
|| (LCL_MAP_LEVL != ((blk_hdr_ptr_t)bmp)->levl))
{
assert(FALSE); /* In pro, we will simply skip counting this local bitmap. */
continue;
}
assert(free_bml <= (local_maps - 1));
maxbitsthismap = (free_bml != (local_maps - 1)) ? BLKS_PER_LMAP : total_blks - bml;
for (free_bit = 0; free_bit < maxbitsthismap; free_bit++)
{
free_bit = bm_find_blk(free_bit, (sm_uc_ptr_t)bmp + sizeof(blk_hdr), maxbitsthismap, &blk_used);
assert(NO_FREE_SPACE <= free_bit);
if (0 > free_bit)
break;
free_blocks++;
}
}
assert(cs_addrs->ti->free_blocks == free_blocks);
if (cs_addrs->ti->free_blocks != free_blocks)
{
send_msg(VARLSTCNT(6) ERR_DBBADFREEBLKCTR, 4, DB_LEN_STR(gv_cur_region), cs_addrs->ti->free_blocks, free_blocks);
cs_addrs->ti->free_blocks = free_blocks;
return FALSE;
}
return TRUE;
}
/* Finds a free block and adds information to update array and cw_set */
block_id swap_root_or_directory_block(int parent_blk_lvl, int child_blk_lvl, srch_hist *dir_hist_ptr, block_id child_blk_id,
sm_uc_ptr_t child_blk_ptr, kill_set *kill_set_list, trans_num curr_tn)
{
sgmnt_data_ptr_t csd;
sgmnt_addrs *csa;
node_local_ptr_t cnl;
srch_blk_status bmlhist, freeblkhist;
block_id hint_blk_num, free_blk_id, parent_blk_id;
boolean_t free_blk_recycled;
int4 master_bit, num_local_maps, free_bit, hint_bit, maxbitsthismap;
uint4 total_blks;
int blk_seg_cnt, blk_size;
sm_uc_ptr_t parent_blk_ptr, bn_ptr, saved_blk;
blk_segment *bs1, *bs_ptr;
int parent_blk_size, child_blk_size, bsiz;
int rec_size1, curr_offset, bpntr_end, hdr_len;
int tmp_cmpc;
cw_set_element *tmpcse;
jnl_buffer_ptr_t jbbp; /* jbbp is non-NULL only if before-image journaling */
unsigned short temp_ushort;
unsigned long temp_long;
unsigned char save_cw_set_depth;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
csd = cs_data;
csa = cs_addrs;
cnl = csa->nl;
blk_size = csd->blk_size;
/* Find a free/recycled block for new block location. */
hint_blk_num = 0;
total_blks = csa->ti->total_blks;
num_local_maps = DIVIDE_ROUND_UP(total_blks, BLKS_PER_LMAP);
master_bit = bmm_find_free((hint_blk_num / BLKS_PER_LMAP), csa->bmm, num_local_maps);
if ((NO_FREE_SPACE == master_bit))
{
t_abort(gv_cur_region, csa);
return ABORT_SWAP;
}
bmlhist.blk_num = (block_id)master_bit * BLKS_PER_LMAP;
if (NULL == (bmlhist.buffaddr = t_qread(bmlhist.blk_num, (sm_int_ptr_t)&bmlhist.cycle, &bmlhist.cr)))
{
assert(t_tries < CDB_STAGNATE);
t_retry((enum cdb_sc)rdfail_detail);
return RETRY_SWAP;
}
hint_bit = 0;
maxbitsthismap = (master_bit != (num_local_maps - 1)) ? BLKS_PER_LMAP : total_blks - bmlhist.blk_num;
free_bit = bm_find_blk(hint_bit, bmlhist.buffaddr + SIZEOF(blk_hdr), maxbitsthismap, &free_blk_recycled);
free_blk_id = bmlhist.blk_num + free_bit;
if (DIR_ROOT >= free_blk_id)
{ /* Bitmap block 0 and directory tree root block 1 should always be marked busy. */
assert(t_tries < CDB_STAGNATE);
t_retry(cdb_sc_badbitmap);
return RETRY_SWAP;
}
if (child_blk_id <= free_blk_id)
{ /* stop swapping root or DT blocks once the database is truncated well enough. A good heuristic for this is to check
* if the block is to be swapped into a higher block number and if so do not swap
*/
t_abort(gv_cur_region, csa);
return ABORT_SWAP;
}
/* ====== begin update array ======
* Four blocks get changed.
* 1. Free block becomes busy and gains the contents of child (root block/directory tree block)
* 2. Parent block in directory tree remains busy, but points to new root block location.
* 3. Free block's corresponding bitmap reflects above change.
* 4. Child block gets marked recycled in bitmap. (GVCST_BMP_MARK_FREE)
*/
parent_blk_ptr = dir_hist_ptr->h[parent_blk_lvl].buffaddr; /* parent_blk_lvl is 0 iff we're moving a gvt root block */
parent_blk_id = dir_hist_ptr->h[parent_blk_lvl].blk_num;
CHECK_AND_RESET_UPDATE_ARRAY;
if (free_blk_recycled)
{ /* Otherwise, it's a completely free block, in which case no need to read. */
freeblkhist.blk_num = (block_id)free_blk_id;
if (NULL == (freeblkhist.buffaddr = t_qread(free_blk_id, (sm_int_ptr_t)&freeblkhist.cycle, &freeblkhist.cr)))
{
assert(t_tries < CDB_STAGNATE);
t_retry((enum cdb_sc)rdfail_detail);
return RETRY_SWAP;
}
}
child_blk_size = ((blk_hdr_ptr_t)child_blk_ptr)->bsiz;
BLK_INIT(bs_ptr, bs1);
BLK_ADDR(saved_blk, child_blk_size, unsigned char);
memcpy(saved_blk, child_blk_ptr, child_blk_size);
BLK_SEG(bs_ptr, saved_blk + SIZEOF(blk_hdr), child_blk_size - SIZEOF(blk_hdr));
assert(blk_seg_cnt == child_blk_size);
if (!BLK_FINI(bs_ptr, bs1))
{
assert(t_tries < CDB_STAGNATE);
t_retry(cdb_sc_blkmod);
return RETRY_SWAP;
}
tmpcse = &cw_set[cw_set_depth];
(free_blk_recycled) ? BIT_SET_RECYCLED_AND_CLEAR_FREE(tmpcse->blk_prior_state)
: BIT_CLEAR_RECYCLED_AND_SET_FREE(tmpcse->blk_prior_state);
t_create(free_blk_id, (unsigned char *)bs1, 0, 0, child_blk_lvl);
tmpcse->mode = gds_t_acquired;
if (!free_blk_recycled || !cs_data->db_got_to_v5_once)
tmpcse->old_block = NULL;
else
{
tmpcse->old_block = freeblkhist.buffaddr;
tmpcse->cr = freeblkhist.cr;
tmpcse->cycle = freeblkhist.cycle;
jbbp = (JNL_ENABLED(csa) && csa->jnl_before_image) ? csa->jnl->jnl_buff : NULL;
if ((NULL != jbbp) && (((blk_hdr_ptr_t)tmpcse->old_block)->tn < jbbp->epoch_tn))
{
bsiz = ((blk_hdr_ptr_t)(tmpcse->old_block))->bsiz;
if (bsiz > blk_size)
{
assert(CDB_STAGNATE > t_tries);
t_retry(cdb_sc_lostbmlcr);
return RETRY_SWAP;
}
JNL_GET_CHECKSUM_ACQUIRED_BLK(tmpcse, csd, csa, tmpcse->old_block, bsiz);
}
}
/* 2. Parent block in directory tree remains busy, but points to new child block location. */
curr_offset = dir_hist_ptr->h[parent_blk_lvl].curr_rec.offset;
parent_blk_size = ((blk_hdr_ptr_t)parent_blk_ptr)->bsiz;
GET_RSIZ(rec_size1, (parent_blk_ptr + curr_offset));
if ((parent_blk_size < rec_size1 + curr_offset) || (BSTAR_REC_SIZE > rec_size1))
{
assert(t_tries < CDB_STAGNATE);
t_retry(cdb_sc_blkmod);
return RETRY_SWAP;
}
BLK_INIT(bs_ptr, bs1);
if (0 == parent_blk_lvl)
/* There can be collation stuff in the record value after the block pointer. See gvcst_root_search. */
hdr_len = SIZEOF(rec_hdr) + gv_altkey->end + 1 - EVAL_CMPC((rec_hdr_ptr_t)(parent_blk_ptr + curr_offset));
else
hdr_len = rec_size1 - SIZEOF(block_id);
bpntr_end = curr_offset + hdr_len + SIZEOF(block_id);
BLK_SEG(bs_ptr, parent_blk_ptr + SIZEOF(blk_hdr), curr_offset + hdr_len - SIZEOF(blk_hdr));
BLK_ADDR(bn_ptr, SIZEOF(block_id), unsigned char);
PUT_LONG(bn_ptr, free_blk_id);
BLK_SEG(bs_ptr, bn_ptr, SIZEOF(block_id));
BLK_SEG(bs_ptr, parent_blk_ptr + bpntr_end, parent_blk_size - bpntr_end);
assert(blk_seg_cnt == parent_blk_size);
if (!BLK_FINI(bs_ptr, bs1))
{
assert(t_tries < CDB_STAGNATE);
t_retry(cdb_sc_blkmod);
return RETRY_SWAP;
}
t_write(&dir_hist_ptr->h[parent_blk_lvl], (unsigned char *)bs1, 0, 0, parent_blk_lvl, FALSE, TRUE, GDS_WRITE_KILLTN);
/* To indicate later snapshot file writing process during fast_integ not to skip writing the block to snapshot file */
BIT_SET_DIR_TREE(cw_set[cw_set_depth-1].blk_prior_state);
/* 3. Free block's corresponding bitmap reflects above change. */
PUT_LONG(update_array_ptr, free_bit);
save_cw_set_depth = cw_set_depth; /* Bit maps go on end of cw_set (more fake acquired) */
assert(!cw_map_depth);
t_write_map(&bmlhist, (uchar_ptr_t)update_array_ptr, curr_tn, 1);
cw_map_depth = cw_set_depth;
cw_set_depth = save_cw_set_depth;
update_array_ptr += SIZEOF(block_id);
temp_long = 0;
PUT_LONG(update_array_ptr, temp_long);
update_array_ptr += SIZEOF(block_id);
assert(1 == cw_set[cw_map_depth - 1].reference_cnt);
/* 4. Child block gets marked recycled in bitmap. (GVCST_BMP_MARK_FREE) */
kill_set_list->blk[kill_set_list->used].flag = 0;
kill_set_list->blk[kill_set_list->used].level = 0;
kill_set_list->blk[kill_set_list->used++].block = child_blk_id;
return free_blk_id;
}
block_id bm_getfree(block_id orig_hint, boolean_t *blk_used, unsigned int cw_work, cw_set_element *cs, int *cw_depth_ptr)
{
cw_set_element *cs1;
sm_uc_ptr_t bmp;
block_id bml, hint, hint_cycled, hint_limit;
block_id_ptr_t b_ptr;
int cw_set_top, depth, lcnt;
unsigned int local_maps, map_size, n_decrements = 0, total_blks;
trans_num ctn;
int4 free_bit, offset;
uint4 space_needed;
uint4 status;
srch_blk_status blkhist;
total_blks = (dba_mm == cs_data->acc_meth) ? cs_addrs->total_blks : cs_addrs->ti->total_blks;
if (orig_hint >= total_blks) /* for TP, hint can be > total_blks */
orig_hint = 1;
hint = orig_hint;
hint_cycled = DIVIDE_ROUND_UP(total_blks, BLKS_PER_LMAP);
hint_limit = DIVIDE_ROUND_DOWN(orig_hint, BLKS_PER_LMAP);
local_maps = hint_cycled + 2; /* for (up to) 2 wraps */
for (lcnt = 0; lcnt <= local_maps; lcnt++)
{
bml = bmm_find_free(hint / BLKS_PER_LMAP, (sm_uc_ptr_t)MM_ADDR(cs_data), local_maps);
if ((NO_FREE_SPACE == bml) || (bml >= hint_cycled))
{ /* if no free space or might have looped to original map, extend */
if ((NO_FREE_SPACE != bml) && (hint_limit < hint_cycled))
{
hint_cycled = hint_limit;
hint = 1;
continue;
}
if (SS_NORMAL != (status = gdsfilext(cs_data->extension_size, total_blks)))
return (status);
if (dba_mm == cs_data->acc_meth)
return (FILE_EXTENDED);
hint = total_blks;
total_blks = cs_addrs->ti->total_blks;
hint_cycled = DIVIDE_ROUND_UP(total_blks, BLKS_PER_LMAP);
local_maps = hint_cycled + 2; /* for (up to) 2 wraps */
/*
* note that you can make an optimization of not going back over the whole database and going over
* only the extended section. but since it is very unlikely that a free block won't be found
* in the extended section and the fact that we are starting from the extended section in either
* approach and the fact that we have a GTMASSERT to check that we don't have a lot of
* free blocks while doing an extend and the fact that it is very easy to make the change to do
* a full-pass, the full-pass solution is currently being implemented
*/
lcnt = -1; /* allow it one extra pass to ensure that it can take advantage of the entension */
n_decrements++; /* used only for debugging purposes */
continue;
}
bml *= BLKS_PER_LMAP;
if (ROUND_DOWN2(hint, BLKS_PER_LMAP) != bml)
{ /* not within requested map */
if ((bml < hint) && (hint_cycled)) /* wrap? - second one should force an extend for sure */
hint_cycled = (hint_limit < hint_cycled) ? hint_limit: 0;
hint = bml + 1; /* start at beginning */
}
if (ROUND_DOWN2(total_blks, BLKS_PER_LMAP) == bml)
map_size = (total_blks - bml);
else
map_size = BLKS_PER_LMAP;
if (0 != dollar_tlevel)
{
depth = cw_work;
cw_set_top = *cw_depth_ptr;
if (depth < cw_set_top)
tp_get_cw(cs, cw_work, &cs1);
for (; depth < cw_set_top; depth++, cs1 = cs1->next_cw_set)
{ /* do tp front to back because list is more efficient than tp_get_cw and forward pointers exist */
if (bml == cs1->blk)
{
TRAVERSE_TO_LATEST_CSE(cs1);
break;
}
}
if (depth >= cw_set_top)
{
assert(cw_set_top == depth);
depth = 0;
}
} else
{
for (depth = *cw_depth_ptr - 1; depth >= cw_work; depth--)
{ /* do non-tp back to front, because of adjacency */
if (bml == (cs + depth)->blk)
{
cs1 = cs + depth;
break;
}
}
if (depth < cw_work)
{
assert(cw_work - 1 == depth);
depth = 0;
}
}
if (0 == depth)
{
ctn = cs_addrs->ti->curr_tn;
if (!(bmp = t_qread(bml, (sm_int_ptr_t)&blkhist.cycle, &blkhist.cr)))
return MAP_RD_FAIL;
if ((BM_SIZE(BLKS_PER_LMAP) != ((blk_hdr_ptr_t)bmp)->bsiz) || (LCL_MAP_LEVL != ((blk_hdr_ptr_t)bmp)->levl))
{
assert(CDB_STAGNATE > t_tries);
rdfail_detail = cdb_sc_badbitmap;
return MAP_RD_FAIL;
}
offset = 0;
} else
{
bmp = cs1->old_block;
b_ptr = (block_id_ptr_t)(cs1->upd_addr);
b_ptr += cs1->reference_cnt - 1;
offset = *b_ptr + 1;
}
if (offset < map_size)
{
free_bit = bm_find_blk(offset, (sm_uc_ptr_t)bmp + sizeof(blk_hdr), map_size, blk_used);
if (MAP_RD_FAIL == free_bit)
return MAP_RD_FAIL;
} else
free_bit = NO_FREE_SPACE;
if (NO_FREE_SPACE != free_bit)
break;
if ((hint = bml + BLKS_PER_LMAP) >= total_blks) /* if map is full, start at 1st blk in next map */
{ /* wrap - second one should force an extend for sure */
hint = 1;
if (hint_cycled)
hint_cycled = (hint_limit < hint_cycled) ? hint_limit: 0;
}
if ((0 == depth) && (FALSE != cs_addrs->now_crit)) /* if it's from the cw_set, its state is murky */
bit_clear(bml / BLKS_PER_LMAP, MM_ADDR(cs_data)); /* if crit, repair master map error */
}
/* If not in the final retry, it is possible that free_bit is >= map_size (e.g. if bitmap block gets recycled). */
if (map_size <= (uint4)free_bit && CDB_STAGNATE <= t_tries)
{ /* bad free bit */
assert((NO_FREE_SPACE == free_bit) && (lcnt > local_maps)); /* All maps full, should have extended */
GTMASSERT;
}
if (0 != depth)
{
b_ptr = (block_id_ptr_t)(cs1->upd_addr);
b_ptr += cs1->reference_cnt++;
*b_ptr = free_bit;
} else
{
space_needed = (BLKS_PER_LMAP + 1) * sizeof(block_id);
if (dollar_tlevel)
{
ENSURE_UPDATE_ARRAY_SPACE(space_needed); /* have brackets for "if" for macros */
}
BLK_ADDR(b_ptr, space_needed, block_id);
memset(b_ptr, 0, space_needed);
*b_ptr = free_bit;
blkhist.blk_num = bml;
blkhist.buffaddr = bmp; /* cycle and cr have already been assigned from t_qread */
t_write_map(&blkhist, (uchar_ptr_t)b_ptr, ctn, 1); /* last parameter 1 is what cs->reference_cnt gets set to */
}
return bml + free_bit;
}
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;
}