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;
}
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;
}
void dse_f_key(void)
{
block_id path[MAX_BT_DEPTH + 1], root_path[MAX_BT_DEPTH + 1];
int4 offset[MAX_BT_DEPTH + 1], root_offset[MAX_BT_DEPTH + 1], nocrit_present;
char targ_key[256], targ_key_root[256], *key_top, util_buff[MAX_UTIL_LEN];
int size, size_root, root_path_count, count, util_len;
bool found, was_crit;
if (!dse_getki(&targ_key[0],&size,LIT_AND_LEN("KEY")))
return;
patch_path_count = 1;
root_path[0] = get_dir_root();
for (key_top = &targ_key[0]; key_top <= &targ_key[256]; )
if (!*key_top++)
break;
size_root = key_top - &targ_key[0] + 1;
memcpy(&targ_key_root[0],&targ_key[0],size_root);
targ_key_root[size_root - 1] = targ_key_root[size_root] = 0;
patch_find_root_search = 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 (!dse_ksrch(root_path[0],&root_path[1],&root_offset[0],&targ_key_root[0],size_root))
{
util_out_print("!/Key not found, no root present.!/",TRUE);
if (!was_crit)
{
if (nocrit_present)
cs_addrs->now_crit = FALSE;
else
rel_crit(gv_cur_region);
}
return;
}
root_path_count = patch_path_count;
patch_path_count = 1;
path[0] = ksrch_root;
patch_find_root_search = FALSE;
if (!dse_ksrch(path[0],&path[1],&offset[0],&targ_key[0],size))
{ memcpy(util_buff,"!/Key not found, would be in block ",36);
util_len = 36;
util_len += i2hex_nofill(path[patch_path_count - 2], (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,FALSE);
patch_path_count -= 1;
}else
{ memcpy(util_buff,"!/Key found in block ",22);
util_len = 22;
util_len += i2hex_nofill(path[patch_path_count - 1], (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,FALSE);
}
util_out_print("!/ Directory path!/ Path--blk:off",TRUE);
for (count = 0; count < root_path_count ;count++)
{ memcpy(util_buff," ",1);
util_len = 1;
util_len += i2hex_nofill(root_path[count],(uchar_ptr_t)&util_buff[util_len], 8);
memcpy(&util_buff[util_len],":",1);
util_len += 1;
util_len += i2hex_nofill(root_offset[count],(uchar_ptr_t)&util_buff[util_len], 4);
memcpy(&util_buff[util_len],",",1);
util_len += 1;
util_buff[util_len] = 0;
util_out_print(util_buff,FALSE);
}
util_out_print("!/ Global tree path!/ Path--blk:off",TRUE);
if (patch_path_count)
{ for (count = 0; count < patch_path_count ;count++)
{ memcpy(util_buff," ",1);
util_len = 1;
util_len += i2hex_nofill(path[count],(uchar_ptr_t)&util_buff[util_len], 8);
memcpy(&util_buff[util_len],":",1);
util_len += 1;
util_len += i2hex_nofill(offset[count],(uchar_ptr_t)&util_buff[util_len], 4);
memcpy(&util_buff[util_len],",",1);
util_len += 1;
util_buff[util_len] = 0;
util_out_print(util_buff,FALSE);
}
util_out_print(0,TRUE);
}
else
{ memcpy(util_buff," ",1);
util_len = 1;
util_len += i2hex_nofill(root_path[count],(uchar_ptr_t)&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);
}
if (!was_crit)
{
if (nocrit_present)
cs_addrs->now_crit = FALSE;
else
rel_crit(gv_cur_region);
}
return;
}
sm_uc_ptr_t dump_record(sm_uc_ptr_t rp, block_id blk, sm_uc_ptr_t bp, sm_uc_ptr_t b_top)
{
sm_uc_ptr_t r_top, key_top, cptr0, cptr1;
char key_buf[MAX_KEY_SZ + 1], *temp_ptr, *temp_key, util_buff[MAX_UTIL_LEN];
unsigned char cc;
short int size;
int4 util_len, head;
int buf_len;
block_id blk_id;
if (rp >= b_top)
return NULL;
head = cli_present("HEADER");
GET_SHORT(size, &((rec_hdr_ptr_t)rp)->rsiz);
cc = ((rec_hdr_ptr_t)rp)->cmpc;
if ((CLI_NEGATED != head) && !patch_is_fdmp)
{
memcpy(util_buff, "Rec:", sizeof("Rec:") - 1);
util_len = sizeof("Rec:") - 1;
util_len += i2hex_nofill(patch_rec_counter, (uchar_ptr_t)&util_buff[util_len], 4);
memcpy(&util_buff[util_len], " Blk ", sizeof(" Blk ") - 1);
util_len += sizeof(" Blk ") - 1;
util_len += i2hex_nofill(blk, (uchar_ptr_t)&util_buff[util_len], 8);
memcpy(&util_buff[util_len], " Off ", sizeof(" Off ") - 1);
util_len += sizeof(" Off ") - 1;
util_len += i2hex_nofill(rp - bp, (uchar_ptr_t)&util_buff[util_len], 4);
memcpy(&util_buff[util_len], " Size ", sizeof(" Size ") - 1);
util_len += sizeof(" Size ") - 1;
util_len += i2hex_nofill(size, (uchar_ptr_t)&util_buff[util_len], 4);
memcpy(&util_buff[util_len], " Cmpc ", sizeof(" Cmpc ") - 1);
util_len += sizeof(" Cmpc ") - 1;
util_len += i2hex_nofill(cc, (uchar_ptr_t)&util_buff[util_len], 2);
memcpy(&util_buff[util_len], " ", sizeof(" ") - 1);
util_len += sizeof(" ") - 1;
util_buff[util_len] = 0;
util_out_print(util_buff, FALSE);
}
r_top = rp + size;
if (r_top > b_top)
r_top = b_top;
else if (r_top < rp + sizeof(rec_hdr))
r_top = rp + sizeof(rec_hdr);
if (cc > patch_comp_count)
cc = patch_comp_count;
if (((blk_hdr_ptr_t)bp)->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;
}
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;
patch_comp_key[patch_comp_count] = patch_comp_key[patch_comp_count + 1] = 0;
if (patch_is_fdmp)
{
if (dse_fdmp(key_top, r_top - key_top))
patch_fdmp_recs++;
} else
{
if (r_top - sizeof(block_id) >= key_top)
{
GET_LONG(blk_id, key_top);
if ((((blk_hdr_ptr_t)bp)->levl) || (blk_id <= cs_addrs->ti->total_blks))
{
memcpy(util_buff, "Ptr ", sizeof("Ptr ") - 1);
util_len = sizeof("Ptr ") - 1;
util_len += i2hex_nofill(blk_id, (uchar_ptr_t)&util_buff[util_len], sizeof(blk_id) * 2);
memcpy(&util_buff[util_len], " ", sizeof(" ") - 1);
util_len += sizeof(" ") - 1;
util_buff[util_len] = 0;
util_out_print(util_buff, FALSE);
}
}
util_out_print("Key ", FALSE);
if (r_top == b_top
&& ((blk_hdr_ptr_t)bp)->levl && !((rec_hdr_ptr_t)rp)->cmpc
&& r_top - rp == sizeof(rec_hdr) + sizeof(block_id))
util_out_print("*", FALSE);
else if (patch_comp_key[0])
{
util_out_print("^", FALSE);
RETRIEVE_ROOT_VAL(patch_comp_key, key_buf, temp_ptr, temp_key, buf_len);
INIT_ROOT_GVT(key_buf, buf_len, curr_gbl_root);
}
print_target((uchar_ptr_t)patch_comp_key);
util_out_print(0, TRUE);
if (CLI_PRESENT != head)
{
for (cptr0 = rp; cptr0 < r_top; cptr0 += 20)
{
if (util_interrupt)
{
/* return, rather than signal ERR_CTRLC so
* that the calling routine can deal with
* that signal and do the appropriate
* cleanup.
*/
return NULL;
}
util_len = 8;
i2hex_blkfill(cptr0 - bp, (uchar_ptr_t)util_buff, 8);
memcpy(&util_buff[util_len], " : |", sizeof(" : |") - 1 );
util_len += sizeof(" : |") - 1;
util_buff[util_len] = 0;
util_out_print(util_buff, FALSE);
for (cptr1 = cptr0; cptr1 < (cptr0 + 20); cptr1++)
{
if (wide_out)
{
if (cptr1 < r_top)
{
i2hex_blkfill(*(sm_uc_ptr_t)cptr1, (uchar_ptr_t)util_buff, 4);
util_buff[4] = 0;
util_out_print(util_buff, FALSE);
} else
util_out_print(" ", FALSE);
} else
{
if (cptr1 < r_top)
{
i2hex_blkfill(*(sm_uc_ptr_t)cptr1, (uchar_ptr_t)util_buff, 3);
util_buff[3] = 0;
util_out_print(util_buff, FALSE);
} else
util_out_print(" ", FALSE);
}
}
if (wide_out)
{
util_out_print("| |", FALSE);
for (cptr1 = cptr0; cptr1 < (cptr0 + 20); cptr1++)
{
if (cptr1 < r_top)
{
if (PRINTABLE(*(sm_uc_ptr_t)cptr1))
util_out_print("!AD", FALSE, 1, cptr1);
else
util_out_print(".", FALSE);
} else
util_out_print(" ", FALSE);
}
} else
{ util_out_print("|", TRUE);
util_out_print(" |", FALSE);
for (cptr1 = cptr0; cptr1 < (cptr0 + 20); cptr1++)
{
if (cptr1 < r_top)
{
if (PRINTABLE(*(sm_uc_ptr_t)cptr1))
util_out_print(" !AD", FALSE, 1, cptr1);
else
util_out_print(" .", FALSE);
}
else
util_out_print(" ", FALSE);
}
}
util_out_print("|", TRUE);
}
}
if (CLI_NEGATED != head)
util_out_print(0, TRUE);
}
return (r_top == b_top) ? NULL : r_top;
}
void dse_m_rest (
block_id blk, /* block number */
unsigned char *bml_list, /* start of local list of local bit maps */
int4 bml_size, /* size of each entry in *bml_list */
sm_vuint_ptr_t blks_ptr, /* total free blocks */
bool in_dir_tree)
{
sm_uc_ptr_t bp, b_top, rp, r_top, bml_ptr, np, ptr;
unsigned char util_buff[MAX_UTIL_LEN];
block_id next;
int util_len;
int4 dummy_int;
cache_rec_ptr_t dummy_cr;
int4 bml_index;
short level, rsize;
int4 bplmap;
error_def(ERR_DSEBLKRDFAIL);
if(!(bp = t_qread (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;
level = ((blk_hdr_ptr_t)bp)->levl;
bplmap = cs_addrs->hdr->bplmap;
for (rp = bp + sizeof (blk_hdr); rp < b_top ;rp = r_top)
{ if (in_dir_tree || level > 1) /* reread block because it may have been flushed from read */
{ if (!(np = t_qread(blk,&dummy_int,&dummy_cr))) /* cache due to LRU buffer scheme and reads in recursive */
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL); /* calls to dse_m_rest. */
if (np != bp)
{ b_top = np + (b_top - bp);
rp = np + (rp - bp);
r_top = np + (r_top - bp);
bp = np;
}
}
GET_SHORT(rsize,&((rec_hdr_ptr_t)rp)->rsiz);
r_top = rp + rsize;
if (r_top > b_top)
r_top = b_top;
if (r_top - rp < (sizeof (rec_hdr) + sizeof (block_id)))
break;
if (in_dir_tree && level == 0)
{
for (ptr = rp + sizeof(rec_hdr); ; )
{
if (*ptr++ == 0 && *ptr++ == 0)
break;
}
GET_LONG(next,ptr);
}
else
GET_LONG(next,r_top - sizeof (block_id));
if (next < 0 || next >= cs_addrs->ti->total_blks ||
(next / bplmap * bplmap == next))
{ memcpy(util_buff,"Invalid pointer in block ",25);
util_len = 25;
util_len += i2hex_nofill(blk, &util_buff[util_len], 8);
memcpy(&util_buff[util_len], " record offset ",15);
util_len += 15;
util_len += i2hex_nofill((int)(rp - bp), &util_buff[util_len], 4);
util_buff[util_len] = 0;
util_out_print((char*)util_buff,TRUE);
continue;
}
bml_index = next / bplmap;
bml_ptr = bml_list + bml_index * bml_size;
if (bml_busy(next - next / bplmap * bplmap, bml_ptr + sizeof(blk_hdr)))
{ *blks_ptr = *blks_ptr - 1;
if (((blk_hdr_ptr_t) bp)->levl > 1)
{ dse_m_rest (next, bml_list, bml_size, blks_ptr, in_dir_tree);
}
else if (in_dir_tree)
{ assert(((blk_hdr_ptr_t) bp)->levl == 0 || ((blk_hdr_ptr_t) bp)->levl == 1);
dse_m_rest (next, bml_list, bml_size, blks_ptr, ((blk_hdr_ptr_t)bp)->levl);
}
}
}
return;
}
void dse_exhaus(int4 pp, int4 op)
{
sm_uc_ptr_t bp, np, b_top, rp, r_top, nrp, nr_top, ptr;
char util_buff[MAX_UTIL_LEN];
block_id last;
short temp_short;
int count, util_len;
int4 dummy_int;
cache_rec_ptr_t dummy_cr;
global_dir_path *d_ptr, *temp;
error_def(ERR_DSEBLKRDFAIL);
error_def(ERR_CTRLC);
last = 0;
patch_path_count++;
if(!(bp = t_qread(patch_path[pp - 1],&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;
for (rp = bp + sizeof(blk_hdr); rp < b_top ;rp = r_top)
{
if (util_interrupt)
{
rts_error(VARLSTCNT(1) ERR_CTRLC);
break;
}
if (!(np = t_qread(patch_path[pp - 1],&dummy_int,&dummy_cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
if (np != bp)
{
b_top = np + (b_top - bp);
rp = np + (rp - bp);
r_top = np + (r_top - bp);
bp = np;
}
GET_SHORT(temp_short,&((rec_hdr_ptr_t) rp)->rsiz);
r_top = rp + temp_short;
if (r_top > b_top)
r_top = b_top;
if (r_top - rp < sizeof(block_id))
break;
if (((blk_hdr_ptr_t)bp)->levl)
GET_LONG(patch_path[pp],(r_top - sizeof(block_id)));
else
{
for (ptr = rp + sizeof(rec_hdr); ; )
{
if (*ptr++ == 0 && *ptr++ ==0)
break;
}
GET_LONG(patch_path[pp],ptr);
}
patch_offset[op] = rp - bp;
if (patch_path[pp] == patch_find_blk)
{
if (!patch_exh_found)
{
if (patch_find_sibs)
util_out_print("!/ Left siblings Right siblings",TRUE);
patch_exh_found = TRUE;
}
if (patch_find_sibs)
{
patch_left_sib = last;
if (r_top < b_top)
{
nrp = r_top;
GET_SHORT(temp_short,&((rec_hdr_ptr_t) rp)->rsiz);
nr_top = nrp + temp_short;
if (nr_top > b_top)
nr_top = b_top;
if (nr_top - nrp >= sizeof(block_id))
{
if (((blk_hdr_ptr_t)bp)->levl)
GET_LONG(patch_right_sib,(nr_top - sizeof(block_id)));
else
{
for (ptr = rp + sizeof(rec_hdr); ;)
{
if (*ptr++ == 0 && *ptr++ == 0)
break;
}
GET_LONG(patch_right_sib,ptr);
}
}
}
else
patch_right_sib = 0;
if (patch_left_sib)
{
memcpy(util_buff," ",1);
util_len = 1;
util_len += i2hex_nofill(patch_left_sib,(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,FALSE);
}else
util_out_print(" none ",FALSE);
if (patch_right_sib)
{
memcpy(util_buff," ",1);
util_len = 1;
util_len += i2hex_nofill(patch_right_sib,(uchar_ptr_t)&util_buff[util_len],8);
util_buff[util_len] = 0;
util_out_print(util_buff,FALSE);
}
else
util_out_print(" none",TRUE);
}
else /* !patch_find_sibs */
{
patch_path_count--;
util_out_print(" Directory path!/ Path--blk:off",TRUE);
if (!patch_find_root_search)
{
d_ptr = global_roots_head->link->dir_path;
while(d_ptr)
{
memcpy(util_buff," ",1);
util_len = 1;
util_len += i2hex_nofill(d_ptr->block,(uchar_ptr_t)&util_buff[util_len],8);
memcpy(&util_buff[util_len],":",1);
util_len += 1;
util_len += i2hex_nofill(d_ptr->offset,(uchar_ptr_t)&util_buff[util_len],4);
util_buff[util_len] = 0;
util_out_print(util_buff,FALSE);
temp = d_ptr;
d_ptr = d_ptr->next;
free(temp);
}
global_roots_head->link->dir_path = 0;
util_out_print("!/!/ Global paths!/ Path--blk:off",TRUE);
}
for (count = 0; count < patch_path_count ;count++)
{
memcpy(util_buff," ",1);
util_len = 1;
util_len += i2hex_nofill(patch_path[count],(uchar_ptr_t)&util_buff[util_len],8);
memcpy(&util_buff[util_len],":",1);
util_len += 1;
util_len += i2hex_nofill(patch_offset[count],(uchar_ptr_t)&util_buff[util_len],4);
util_buff[util_len] = 0;
util_out_print(util_buff,FALSE);
}
memcpy(util_buff," ",1);
util_len = 1;
util_len += i2hex_nofill(patch_path[count],(uchar_ptr_t)&util_buff[util_len],8);
util_buff[util_len] = 0;
util_out_print(util_buff,TRUE);
patch_path_count++;
}
}
if (patch_path[pp] > 0 && patch_path[pp] < cs_addrs->ti->total_blks
&& (patch_path[pp] % cs_addrs->hdr->bplmap))
if (((blk_hdr_ptr_t) bp)->levl > 1)
dse_exhaus(pp + 1,op + 1);
else if (((blk_hdr_ptr_t)bp)->levl == 1 && patch_find_root_search)
dse_find_roots(patch_path[pp]);
last = patch_path[pp];
}
patch_path_count--;
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 emit_jmp(uint4 branch_op, short **instp, int reg) /* Note that the 'reg' parameter is ignored */
{
assert (jmp_offset != 0);
force_32 = TRUE;
jmp_offset -= code_idx * SIZEOF(code_buf[0]); /* size of this particular instruction */
switch (cg_phase)
{
# ifdef DEBUG
case CGP_ASSEMBLY:
*obpt++ = 'x';
*obpt++ = '^';
*obpt++ = '0';
*obpt++ = 'x';
obpt += i2hex_nofill(jmp_offset, (uchar_ptr_t)obpt, 8);
*obpt++ = ',';
*obpt++ = ' ';
/***** WARNING - FALL THRU *****/
# endif
case CGP_ADDR_OPT:
case CGP_APPROX_ADDR:
case CGP_MACHINE:
assert (**instp == VXT_JMP);
*instp += 1;
assert (**instp == 1);
*instp += 1;
if (jmp_offset == 0)
{
/*code_buf[code_idx++] = I386_INS_NOP__; */
} else if (((jmp_offset - 2) >= -128 && (jmp_offset - 2) <= 127 &&
JMP_LONG_INST_SIZE != call_4lcldo_variant) && (force_32 == FALSE))
{
jmp_offset -= 2;
switch (branch_op)
{
case GENERIC_OPCODE_BEQ:
code_buf[code_idx++] = I386_INS_JZ_Jb;
break;
case GENERIC_OPCODE_BGE:
code_buf[code_idx++] = I386_INS_JNL_Jb;
break;
case GENERIC_OPCODE_BGT:
code_buf[code_idx++] = I386_INS_JNLE_Jb;
break;
case GENERIC_OPCODE_BLE:
code_buf[code_idx++] = I386_INS_JLE_Jb;
break;
case GENERIC_OPCODE_BLT:
code_buf[code_idx++] = I386_INS_JL_Jb;
break;
case GENERIC_OPCODE_BNE:
code_buf[code_idx++] = I386_INS_JNZ_Jb;
break;
case GENERIC_OPCODE_BR:
assert(0 == call_4lcldo_variant || BRB_INST_SIZE == call_4lcldo_variant);
code_buf[code_idx++] = I386_INS_JMP_Jb;
break;
default:
assertpro(FALSE);
break;
}
code_buf[code_idx++] = jmp_offset & 0xff;
} else
{
if (branch_op == GENERIC_OPCODE_BR)
{
assert(0 == call_4lcldo_variant || JMP_LONG_INST_SIZE == call_4lcldo_variant || force_32);
jmp_offset -= SIZEOF(int4) + 1;
code_buf[code_idx++] = I386_INS_JMP_Jv;
} else
{
jmp_offset -= SIZEOF(int4) + 2;
code_buf[code_idx++] = I386_INS_Two_Byte_Escape_Prefix;
switch (branch_op)
{
case GENERIC_OPCODE_BEQ:
code_buf[code_idx++] = I386_INS_JZ_Jv;
break;
case GENERIC_OPCODE_BGE:
code_buf[code_idx++] = I386_INS_JNL_Jv;
break;
case GENERIC_OPCODE_BGT:
code_buf[code_idx++] = I386_INS_JNLE_Jv;
break;
case GENERIC_OPCODE_BLE:
code_buf[code_idx++] = I386_INS_JLE_Jv;
break;
case GENERIC_OPCODE_BLT:
code_buf[code_idx++] = I386_INS_JL_Jv;
break;
case GENERIC_OPCODE_BNE:
code_buf[code_idx++] = I386_INS_JNZ_Jv;
break;
default:
assertpro(FALSE);
break;
}
}
*((int4 *)&code_buf[code_idx]) = jmp_offset;
code_idx += SIZEOF(int4);
}
}
force_32 = FALSE;
}
void mu_int_err(
int err,
boolean_t do_path,
boolean_t do_range,
unsigned char *bot,
int has_bot,
unsigned char *top,
int has_top,
unsigned int level)
{
int i, util_len;
unsigned char util_buff[MAX_UTIL_LEN];
unsigned char span_key[MAX_KEY_SZ + 1];
if (!mu_int_errknt)
util_out_print("!/Block:Offset Level", TRUE);
mu_int_errknt++;
mu_int_plen--;
util_len=0;
MEMCPY_LIT(&util_buff[util_len], NEWLINE);
util_len += SIZEOF(NEWLINE) - 1;
i2hex_blkfill(mu_int_path[mu_int_plen], &util_buff[util_len], BLOCK_WINDOW);
util_len += BLOCK_WINDOW;
MEMCPY_LIT(&util_buff[util_len], TEXT1); /* OFFSET_WINDOW + 1 spaces */
util_len += SIZEOF(TEXT3) - 1; /* Using TEXT1 to clear space? */
i2hex_nofill(mu_int_offset[mu_int_plen], (uchar_ptr_t)&util_buff[util_len], OFFSET_WINDOW);
util_len += OFFSET_WINDOW + 1;
i2hex_blkfill(level, (uchar_ptr_t)&util_buff[util_len], LEVEL_WINDOW);
util_len += LEVEL_WINDOW;
MEMCPY_LIT(&util_buff[util_len], TEXT2);
util_len += SIZEOF(TEXT2) - 1;
util_buff[util_len] = 0;
if(sndata->sn_type)
gtm_putmsg(VARLSTCNT(5) err, 3, LEN_AND_STR((char*)util_buff),
(SPAN_NODE == sndata->sn_type) ? (sndata->span_prev_blk + 2) : (sndata->span_blk_cnt));
else
gtm_putmsg(VARLSTCNT(4) err, 2, LEN_AND_STR((char*)util_buff));
if (do_path)
{
if (!master_dir)
{
util_out_print(" Directory Path: ", FALSE);
for (i = 0; trees->path[i + 1]; i++)
{
util_len = i2hex_nofill(trees->path[i], (uchar_ptr_t)util_buff, BLOCK_WINDOW);
MEMCPY_LIT(&util_buff[util_len], TEXT3);
util_len += SIZEOF(TEXT3) - 1;
util_len += i2hex_nofill(trees->offset[i], (uchar_ptr_t)&util_buff[util_len], OFFSET_WINDOW);
MEMCPY_LIT(&util_buff[util_len], TEXT4);
util_len += SIZEOF(TEXT4) - 1;
util_buff[util_len] = 0;
util_out_print((caddr_t)util_buff, FALSE);
}
util_len = i2hex_nofill(trees->path[i], (uchar_ptr_t)util_buff, BLOCK_WINDOW);
MEMCPY_LIT(&util_buff[util_len], TEXT3);
util_len += SIZEOF(TEXT3) - 1;
util_len += i2hex_nofill(trees->offset[i], (uchar_ptr_t)&util_buff[util_len], OFFSET_WINDOW);
util_buff[util_len] = 0;
util_out_print((caddr_t)util_buff, TRUE);
util_out_print(" Path: ", FALSE);
} else
util_out_print(" Directory Path: ", FALSE);
for (i = 0; i < mu_int_plen; i++)
{
util_len = i2hex_nofill(mu_int_path[i], (uchar_ptr_t)util_buff, BLOCK_WINDOW);
MEMCPY_LIT(&util_buff[util_len], TEXT3);
util_len += SIZEOF(TEXT3) - 1;
util_len += i2hex_nofill(mu_int_offset[i], (uchar_ptr_t)&util_buff[util_len], OFFSET_WINDOW);
MEMCPY_LIT(&util_buff[util_len], TEXT4);
util_len += SIZEOF(TEXT4) - 1;
util_buff[util_len] = 0;
util_out_print((caddr_t)util_buff, FALSE);
}
util_len = i2hex_nofill(mu_int_path[i], (uchar_ptr_t)util_buff, BLOCK_WINDOW);
MEMCPY_LIT(&util_buff[util_len], TEXT3);
util_len += SIZEOF(TEXT3) - 1;
util_len += i2hex_nofill(mu_int_offset[i], (uchar_ptr_t)&util_buff[util_len], OFFSET_WINDOW);
util_buff[util_len] = 0;
util_out_print((caddr_t)util_buff, TRUE);
}
if (do_range && mu_int_err_ranges)
{
util_out_print("Keys from ", FALSE);
if (has_bot)
{
util_out_print("^", FALSE);
/* in the case bot is the leftmost key of the gvtree, it needs a second null to be a properly terminated
* real key for print_target. since it is a simple set, we unconditionally do it for every key */
bot[has_bot] = 0;
print_target(bot);
} else
{
assert(master_dir); /* for a global variable tree, we better have a non-zero begin key */
util_out_print("^%", FALSE);
}
util_out_print(" to ", FALSE);
if (has_top)
{
util_out_print("^", FALSE);
print_target(top);
} else
util_out_print("the end", FALSE);
util_out_print(" are suspect.", TRUE);
}
if (!level && sndata->sn_type)
{
if (1 == sndata->sn_type)
util_out_print("Spanning Node ^", FALSE);
else
util_out_print("Spanning Node Chunk ^", FALSE);
/* in the case bot is the leftmost key of the gvtree, it needs a second null to be a properly terminated
* real key for print_target. since it is a simple set, we unconditionally do it for every key
*/
sndata->span_node_buf[sndata->key_len] = 0;
sndata->span_node_buf[sndata->key_len+1] = 0;
print_target(sndata->span_node_buf);
util_out_print(" is suspect.", TRUE);
}
return;
}
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;
}
sm_uc_ptr_t dump_record(sm_uc_ptr_t rp, block_id blk, sm_uc_ptr_t bp, sm_uc_ptr_t b_top)
{
sm_uc_ptr_t r_top, key_top, cptr0, cptr1, cptr_top, cptr_base = NULL, cptr_next = NULL;
char key_buf[MAX_KEY_SZ + 1], *temp_ptr, *temp_key, util_buff[MAX_UTIL_LEN];
char *prefix_str, *space_str, *dot_str, *format_str;
unsigned char cc;
short int size;
int4 util_len, head;
uint4 ch;
int buf_len, field_width,fastate, chwidth = 0;
ssize_t chlen;
block_id blk_id;
boolean_t rechdr_displayed = FALSE;
sgmnt_addrs *csa;
if (rp >= b_top)
return NULL;
head = cli_present("HEADER");
GET_SHORT(size, &((rec_hdr_ptr_t)rp)->rsiz);
cc = ((rec_hdr_ptr_t)rp)->cmpc;
if ((CLI_NEGATED != head) && !patch_is_fdmp)
{
MEMCPY_LIT(util_buff, "Rec:");
util_len = SIZEOF("Rec:") - 1;
util_len += i2hex_nofill(patch_rec_counter, (uchar_ptr_t)&util_buff[util_len], 4);
MEMCPY_LIT(&util_buff[util_len], " Blk ");
util_len += SIZEOF(" Blk ") - 1;
util_len += i2hex_nofill(blk, (uchar_ptr_t)&util_buff[util_len], 8);
MEMCPY_LIT(&util_buff[util_len], " Off ");
util_len += SIZEOF(" Off ") - 1;
util_len += i2hex_nofill((int)(rp - bp), (uchar_ptr_t)&util_buff[util_len], 4);
MEMCPY_LIT(&util_buff[util_len], " Size ");
util_len += SIZEOF(" Size ") - 1;
util_len += i2hex_nofill(size, (uchar_ptr_t)&util_buff[util_len], 4);
MEMCPY_LIT(&util_buff[util_len], " Cmpc ");
util_len += SIZEOF(" Cmpc ") - 1;
util_len += i2hex_nofill(cc, (uchar_ptr_t)&util_buff[util_len], 2);
MEMCPY_LIT(&util_buff[util_len], " ");
util_len += SIZEOF(" ") - 1;
util_buff[util_len] = 0;
util_out_print(util_buff, FALSE);
}
r_top = rp + size;
if (r_top > b_top)
r_top = b_top;
else if (r_top < rp + SIZEOF(rec_hdr))
r_top = rp + SIZEOF(rec_hdr);
if (cc > patch_comp_count)
cc = patch_comp_count;
if (((blk_hdr_ptr_t)bp)->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;
}
size = key_top - rp - SIZEOF(rec_hdr);
if (size > SIZEOF(patch_comp_key) - 2 - cc)
size = SIZEOF(patch_comp_key) - 2 - cc;
if (size < 0)
size = 0;
memcpy(&patch_comp_key[cc], rp + SIZEOF(rec_hdr), size);
patch_comp_count = cc + size;
patch_comp_key[patch_comp_count] = patch_comp_key[patch_comp_count + 1] = 0;
if (patch_is_fdmp)
{
if (dse_fdmp(key_top, (int)(r_top - key_top)))
patch_fdmp_recs++;
} else
{
if (r_top - SIZEOF(block_id) >= key_top)
{
GET_LONG(blk_id, key_top);
if ((((blk_hdr_ptr_t)bp)->levl) || (blk_id <= cs_addrs->ti->total_blks))
{
MEMCPY_LIT(util_buff, "Ptr ");
util_len = SIZEOF("Ptr ") - 1;
util_len += i2hex_nofill(blk_id, (uchar_ptr_t)&util_buff[util_len], SIZEOF(blk_id) * 2);
MEMCPY_LIT(&util_buff[util_len], " ");
util_len += SIZEOF(" ") - 1;
util_buff[util_len] = 0;
util_out_print(util_buff, FALSE);
}
}
util_out_print("Key ", FALSE);
if (r_top == b_top
&& ((blk_hdr_ptr_t)bp)->levl && !((rec_hdr_ptr_t)rp)->cmpc
&& r_top - rp == SIZEOF(rec_hdr) + SIZEOF(block_id))
util_out_print("*", FALSE);
else if (patch_comp_key[0])
{
util_out_print("^", FALSE);
csa = cs_addrs;
RETRIEVE_ROOT_VAL(patch_comp_key, key_buf, temp_ptr, temp_key, buf_len);
INIT_ROOT_GVT(key_buf, buf_len, curr_gbl_root);
}
print_target((uchar_ptr_t)patch_comp_key);
util_out_print(0, TRUE);
if (CLI_PRESENT != head)
{
prefix_str = " |";
if (wide_out)
{
format_str = " !AD";
dot_str = " .";
space_str = " ";
field_width = 4;
} else
{
format_str = " !AD";
dot_str = " .";
space_str = " ";
field_width = 3;
}
fastate = 0;
for (cptr0 = rp; cptr0 < r_top; cptr0 += NUM_BYTES_PER_LINE)
{
if (util_interrupt)
{ /* return, rather than signal ERR_CTRLC so that the calling routine
can deal with that signal and do the appropriate cleanup */
return NULL;
}
util_len = 8;
i2hex_blkfill((int)(cptr0 - bp), (uchar_ptr_t)util_buff, 8);
MEMCPY_LIT(&util_buff[util_len], " : |");
util_len += SIZEOF(" : |") - 1;
util_buff[util_len] = 0;
util_out_print(util_buff, FALSE);
/* Dump hexadecimal byte values */
for (cptr1 = cptr0; cptr1 < (cptr0 + NUM_BYTES_PER_LINE); cptr1++)
{
if (cptr1 < r_top)
{
i2hex_blkfill(*(sm_uc_ptr_t)cptr1, (uchar_ptr_t)util_buff, field_width);
util_buff[field_width] = 0;
util_out_print(util_buff, FALSE);
} else
util_out_print(space_str, FALSE);
}
util_out_print("|", TRUE);
util_out_print(prefix_str, FALSE);
/* Display character/wide-character glyphs */
for (cptr1 = cptr0, cptr_top = cptr0 + NUM_BYTES_PER_LINE; cptr1 < cptr_top; cptr1++)
{
if (!rechdr_displayed && (cptr1 == (rp + SIZEOF(rec_hdr))))
rechdr_displayed = TRUE;
assert(rechdr_displayed || (cptr1 < (rp + SIZEOF(rec_hdr))));
assert(!rechdr_displayed || (cptr1 >= (rp + SIZEOF(rec_hdr))));
switch (fastate)
{
case 0: /* prints single-byte characters or intepret
multi-byte characters */
if (cptr1 >= r_top)
util_out_print(space_str, FALSE);
else if (!gtm_utf8_mode || IS_ASCII(*cptr1) || !rechdr_displayed)
{ /* single-byte characters */
if (PRINTABLE(*(sm_uc_ptr_t)cptr1))
util_out_print(format_str, FALSE, 1, cptr1);
else
util_out_print(dot_str, FALSE);
}
#ifdef UNICODE_SUPPORTED
else { /* multi-byte characters */
cptr_next = UTF8_MBTOWC(cptr1, r_top, ch);
chlen = cptr_next - cptr1;
if (WEOF == ch || !U_ISPRINT(ch))
{ /* illegal or non-printable characters */
cptr1--;
fastate = 1;
} else
{ /* multi-byte printable characters */
cptr_base = cptr1;
chwidth = UTF8_WCWIDTH(ch);
assert(chwidth >= 0 && chwidth <= 2);
cptr1--;
fastate = 2;
}
}
#endif
break;
case 1: /* illegal or non-printable characters */
util_out_print(dot_str, FALSE);
if (--chlen <= 0)
fastate = 0;
break;
case 2: /* printable multi-byte characters */
if (chlen-- > 1) /* fill leading bytes with spaces */
util_out_print(space_str, FALSE);
else
{
util_out_print("!AD", FALSE, field_width - chwidth, space_str);
if (0 < chwidth)
util_out_print("!AD", FALSE, cptr_next - cptr_base, cptr_base);
fastate = 0;
}
break;
}
}
util_out_print("|", TRUE);
}
}
if (CLI_NEGATED != head)
util_out_print(0, TRUE);
}
return (r_top == b_top) ? NULL : r_top;
}
void dse_maps(void)
{
block_id blk, bml_blk;
blk_segment *bs1, *bs_ptr;
int4 blk_seg_cnt, blk_size; /* needed for BLK_INIT, BLK_SEG and BLK_FINI macros */
sm_uc_ptr_t bp;
char util_buff[MAX_UTIL_LEN];
int4 bml_size, bml_list_size, blk_index, bml_index;
int4 total_blks, blks_in_bitmap;
int4 bplmap, dummy_int;
unsigned char *bml_list;
cache_rec_ptr_t cr, dummy_cr;
bt_rec_ptr_t btr;
int util_len;
uchar_ptr_t blk_ptr;
boolean_t was_crit;
uint4 jnl_status;
srch_blk_status blkhist;
jnl_private_control *jpc;
jnl_buffer_ptr_t jbp;
sgmnt_addrs *csa;
sgmnt_data_ptr_t csd;
if (CLI_PRESENT == cli_present("BUSY") || CLI_PRESENT == cli_present("FREE") ||
CLI_PRESENT == cli_present("MASTER") || CLI_PRESENT == cli_present("RESTORE_ALL"))
{
if (gv_cur_region->read_only)
rts_error(VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(gv_cur_region));
}
CHECK_AND_RESET_UPDATE_ARRAY; /* reset update_array_ptr to update_array */
csa = cs_addrs;
assert(&FILE_INFO(gv_cur_region)->s_addrs == csa);
was_crit = csa->now_crit;
if (csa->critical)
crash_count = csa->critical->crashcnt;
csd = csa->hdr;
bplmap = csd->bplmap;
if (CLI_PRESENT == cli_present("BLOCK"))
{
if (!cli_get_hex("BLOCK", (uint4 *)&blk))
return;
if (blk < 0 || blk >= csa->ti->total_blks)
{
util_out_print("Error: invalid block number.", TRUE);
return;
}
patch_curr_blk = blk;
}
else
blk = patch_curr_blk;
if (CLI_PRESENT == cli_present("FREE"))
{
if (0 == bplmap)
{
util_out_print("Cannot perform map updates: bplmap field of file header is zero.", TRUE);
return;
}
if (blk / bplmap * bplmap == blk)
{
util_out_print("Cannot perform action on a map block.", TRUE);
return;
}
bml_blk = blk / bplmap * bplmap;
bm_setmap(bml_blk, blk, FALSE);
return;
}
if (CLI_PRESENT == cli_present("BUSY"))
{
if (0 == bplmap)
{
util_out_print("Cannot perform map updates: bplmap field of file header is zero.", TRUE);
return;
}
if (blk / bplmap * bplmap == blk)
{
util_out_print("Cannot perform action on a map block.", TRUE);
return;
}
bml_blk = blk / bplmap * bplmap;
bm_setmap(bml_blk, blk, TRUE);
return;
}
blk_size = csd->blk_size;
if (CLI_PRESENT == cli_present("MASTER"))
{
if (0 == bplmap)
{
util_out_print("Cannot perform maps updates: bplmap field of file header is zero.", TRUE);
return;
}
if (!was_crit)
grab_crit(gv_cur_region);
bml_blk = blk / bplmap * bplmap;
if (dba_mm == csd->acc_meth)
bp = MM_BASE_ADDR(csa) + (off_t)bml_blk * blk_size;
else
{
assert(dba_bg == csd->acc_meth);
if (!(bp = t_qread(bml_blk, &dummy_int, &dummy_cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
}
if ((csa->ti->total_blks / bplmap) * bplmap == bml_blk)
total_blks = (csa->ti->total_blks - bml_blk);
else
total_blks = bplmap;
if (NO_FREE_SPACE == bml_find_free(0, bp + SIZEOF(blk_hdr), total_blks))
bit_clear(bml_blk / bplmap, csa->bmm);
else
bit_set(bml_blk / bplmap, csa->bmm);
if (bml_blk > csa->nl->highest_lbm_blk_changed)
csa->nl->highest_lbm_blk_changed = bml_blk;
if (!was_crit)
rel_crit(gv_cur_region);
return;
}
if (CLI_PRESENT == cli_present("RESTORE_ALL"))
{
if (0 == bplmap)
{
util_out_print("Cannot perform maps updates: bplmap field of file header is zero.", TRUE);
return;
}
total_blks = csa->ti->total_blks;
assert(ROUND_DOWN2(blk_size, 2 * SIZEOF(int4)) == blk_size);
bml_size = BM_SIZE(bplmap);
bml_list_size = (total_blks + bplmap - 1) / bplmap * bml_size;
bml_list = (unsigned char *)malloc(bml_list_size);
for (blk_index = 0, bml_index = 0; blk_index < total_blks; blk_index += bplmap, bml_index++)
bml_newmap((blk_hdr_ptr_t)(bml_list + bml_index * bml_size), bml_size, csa->ti->curr_tn);
if (!was_crit)
{
grab_crit(gv_cur_region);
csa->hold_onto_crit = TRUE; /* need to do this AFTER grab_crit */
}
blk = get_dir_root();
assert(blk < bplmap);
csa->ti->free_blocks = total_blks - DIVIDE_ROUND_UP(total_blks, bplmap);
bml_busy(blk, bml_list + SIZEOF(blk_hdr));
csa->ti->free_blocks = csa->ti->free_blocks - 1;
dse_m_rest(blk, bml_list, bml_size, &csa->ti->free_blocks, TRUE);
for (blk_index = 0, bml_index = 0; blk_index < total_blks; blk_index += bplmap, bml_index++)
{
t_begin_crit(ERR_DSEFAIL);
CHECK_TN(csa, csd, csd->trans_hist.curr_tn); /* can issue rts_error TNTOOLARGE */
CWS_RESET;
CHECK_AND_RESET_UPDATE_ARRAY; /* reset update_array_ptr to update_array */
assert(csa->ti->early_tn == csa->ti->curr_tn);
blk_ptr = bml_list + bml_index * bml_size;
blkhist.blk_num = blk_index;
if (!(blkhist.buffaddr = t_qread(blkhist.blk_num, &blkhist.cycle, &blkhist.cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, blk_ptr + SIZEOF(blk_hdr), bml_size - SIZEOF(blk_hdr));
BLK_FINI(bs_ptr, bs1);
t_write(&blkhist, (unsigned char *)bs1, 0, 0, LCL_MAP_LEVL, TRUE, FALSE, GDS_WRITE_KILLTN);
BUILD_AIMG_IF_JNL_ENABLED(csd, csa->ti->curr_tn);
t_end(&dummy_hist, NULL, csa->ti->curr_tn);
}
/* Fill in master map */
for (blk_index = 0, bml_index = 0; blk_index < total_blks; blk_index += bplmap, bml_index++)
{
blks_in_bitmap = (blk_index + bplmap <= total_blks) ? bplmap : total_blks - blk_index;
assert(1 < blks_in_bitmap); /* the last valid block in the database should never be a bitmap block */
if (NO_FREE_SPACE != bml_find_free(0, (bml_list + bml_index * bml_size) + SIZEOF(blk_hdr), blks_in_bitmap))
bit_set(blk_index / bplmap, csa->bmm);
else
bit_clear(blk_index / bplmap, csa->bmm);
if (blk_index > csa->nl->highest_lbm_blk_changed)
csa->nl->highest_lbm_blk_changed = blk_index;
}
if (!was_crit)
{
csa->hold_onto_crit = FALSE; /* need to do this before the rel_crit */
rel_crit(gv_cur_region);
}
if (unhandled_stale_timer_pop)
process_deferred_stale();
free(bml_list);
csd->kill_in_prog = csd->abandoned_kills = 0;
return;
}
MEMCPY_LIT(util_buff, "!/Block ");
util_len = SIZEOF("!/Block ") - 1;
util_len += i2hex_nofill(blk, (uchar_ptr_t)&util_buff[util_len], 8);
memcpy(&util_buff[util_len], " is marked !AD in its local bit map.!/",
SIZEOF(" is marked !AD in its local bit map.!/") - 1);
util_len += SIZEOF(" is marked !AD in its local bit map.!/") - 1;
util_buff[util_len] = 0;
if (!was_crit)
grab_crit(gv_cur_region);
util_out_print(util_buff, TRUE, 4, dse_is_blk_free(blk, &dummy_int, &dummy_cr) ? "free" : "busy");
if (!was_crit)
rel_crit(gv_cur_region);
return;
}
void dse_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;
}