char gtcmtr_lke_showrep(struct CLB *lnk, show_request *sreq)
{
gd_region *cur_region;
sgmnt_addrs *cs_adr;
mlk_ctldata *lke_ctl;
ssize_t ls_len;
mstr dnode;
show_reply srep;
uint4 status;
boolean_t was_crit;
cur_region = gv_cur_region = gtcm_find_region(curr_entry, sreq->rnum)->reghead->reg;
if (dba_bg == cur_region->dyn.addr->acc_meth || dba_mm == cur_region->dyn.addr->acc_meth)
{
cs_adr = &FILE_INFO(cur_region)->s_addrs;
ls_len = cs_adr->lock_addrs[1] - cs_adr->lock_addrs[0];
lke_ctl = (mlk_ctldata *)malloc(ls_len);
/* Prevent any modification of the lock space while we make a local copy of it */
if (cs_adr->critical != NULL)
crash_count = cs_adr->critical->crashcnt;
was_crit = cs_adr->now_crit;
if (!was_crit)
grab_crit(cur_region);
longcpy((uchar_ptr_t)lke_ctl, cs_adr->lock_addrs[0], ls_len);
if (!was_crit)
rel_crit(cur_region);
util_cm_print(lnk, 0, NULL, RESET);
dnode.len = sreq->nodelength;
dnode.addr = sreq->node;
if (lke_ctl->blkroot != 0)
(void)lke_showtree(lnk, (mlk_shrblk_ptr_t)R2A(lke_ctl->blkroot), sreq->all, sreq->wait, sreq->pid, dnode,
FALSE, NULL);
free(lke_ctl);
}
srep.code = CMMS_U_LKESHOW;
lnk->cbl = SIZEOF(srep.code);
lnk->ast = NULL;
#ifndef vinu_marker
assert(0 == offsetof(show_reply, code));
lnk->mbf = (unsigned char *)&srep; /* no need since lnk->mbf can be re-used. vinu 06/27/01 */
status = cmi_write(lnk);
if (CMI_ERROR(status))
{ /* This routine is a server routine; not sure why it does error processing similar to a client. vinu 06/27/01 */
((link_info *)(lnk->usr))->neterr = TRUE;
gvcmz_error(CMMS_U_LKESHOW, status);
} else
lnk->mbf = (unsigned char *)sreq; /* don't restore if lnk->mbf isn't modified. vinu 06/27/01 */
#else
/* server calls to cmi_* should do error processing as a callback. vinu 06/27/01 */
*lnk->mbf = srep.code;
cmi_write(lnk);
#endif
return CM_READ;
}
void lke_show(void)
{
bool locks, all = TRUE, wait = TRUE, interactive = FALSE, match = FALSE, memory = TRUE, nocrit = TRUE;
boolean_t exact = FALSE, was_crit;
int4 pid;
size_t ls_len;
int n;
char regbuf[MAX_RN_LEN], nodebuf[32], one_lockbuf[MAX_KEY_SZ];
mlk_ctldata_ptr_t ctl;
mstr reg, node, one_lock;
int shr_sub_len = 0;
float ls_free = 0; /* Free space in bottleneck subspace */
/* Get all command parameters */
reg.addr = regbuf;
reg.len = SIZEOF(regbuf);
node.addr = nodebuf;
node.len = SIZEOF(nodebuf);
one_lock.addr = one_lockbuf;
one_lock.len = SIZEOF(one_lockbuf);
if (lke_getcli(&all, &wait, &interactive, &pid, ®, &node, &one_lock, &memory, &nocrit, &exact) == 0)
return;
/* Search all regions specified on the command line */
for (gv_cur_region = gd_header->regions, n = 0; n != gd_header->n_regions; ++gv_cur_region, ++n)
{
/* If region matches and is open */
if ((reg.len == 0 ||
gv_cur_region->rname_len == reg.len && memcmp(gv_cur_region->rname, reg.addr, reg.len) == 0) &&
gv_cur_region->open)
{
match = TRUE;
util_out_print("!/!AD!/", NOFLUSH, REG_LEN_STR(gv_cur_region));
/* If distributed database, the region is located on another node */
if (gv_cur_region->dyn.addr->acc_meth == dba_cm)
{
# if defined(LKE_WORKS_OK_WITH_CM)
/* Obtain lock info from the remote node */
locks = gtcmtr_lke_showreq(gv_cur_region->dyn.addr->cm_blk, gv_cur_region->cmx_regnum,
all, wait, pid, &node);
# else
gtm_putmsg(VARLSTCNT(10) ERR_UNIMPLOP, 0, ERR_TEXT, 2,
LEN_AND_LIT("GT.CM region - locks must be displayed on the local node"),
ERR_TEXT, 2, REG_LEN_STR(gv_cur_region));
continue;
# endif
} else if (gv_cur_region->dyn.addr->acc_meth == dba_bg || gv_cur_region->dyn.addr->acc_meth == dba_mm)
{ /* Local region */
cs_addrs = &FILE_INFO(gv_cur_region)->s_addrs;
ls_len = (size_t)(cs_addrs->lock_addrs[1] - cs_addrs->lock_addrs[0]);
ctl = (mlk_ctldata_ptr_t)malloc(ls_len);
/* Prevent any modification of the lock space while we make a local copy of it */
if (cs_addrs->critical != NULL)
crash_count = cs_addrs->critical->crashcnt;
was_crit = cs_addrs->now_crit;
if (!nocrit && !was_crit)
grab_crit(gv_cur_region);
longcpy((uchar_ptr_t)ctl, (uchar_ptr_t)cs_addrs->lock_addrs[0], ls_len);
assert((ctl->max_blkcnt > 0) && (ctl->max_prccnt > 0) && ((ctl->subtop - ctl->subbase) > 0));
if (!nocrit && !was_crit)
rel_crit(gv_cur_region);
shr_sub_len = 0;
locks = ctl->blkroot == 0 ?
FALSE:
lke_showtree(NULL, (mlk_shrblk_ptr_t)R2A(ctl->blkroot), all, wait, pid,
one_lock, memory, &shr_sub_len);
/* lock space usage consists of: control_block + nodes(locks) + processes + substrings */
/* any of those subspaces can be bottleneck.
* Therefore we will report the subspace which is running out.
*/
ls_free = MIN(((float)ctl->blkcnt) / ctl->max_blkcnt, ((float)ctl->prccnt) / ctl->max_prccnt);
ls_free = MIN(1-(((float)shr_sub_len) / (ctl->subtop - ctl->subbase)), ls_free);
ls_free *= 100; /* Scale to [0-100] range. (couldn't do this inside util_out_print) */
if (ls_free < 1) /* No memory? Notify user. */
gtm_putmsg(VARLSTCNT(4) ERR_LOCKSPACEFULL, 2, DB_LEN_STR(gv_cur_region));
if (ls_free < 1 || memory)
{
if (ctl->subtop > ctl->subfree)
gtm_putmsg(VARLSTCNT(10) ERR_LOCKSPACEINFO, 8, REG_LEN_STR(gv_cur_region),
(ctl->max_prccnt - ctl->prccnt), ctl->max_prccnt,
(ctl->max_blkcnt - ctl->blkcnt), ctl->max_blkcnt, LEN_AND_LIT(" not "));
else
gtm_putmsg(VARLSTCNT(10) ERR_LOCKSPACEINFO, 8, REG_LEN_STR(gv_cur_region),
(ctl->max_prccnt - ctl->prccnt), ctl->max_prccnt,
(ctl->max_blkcnt - ctl->blkcnt), ctl->max_blkcnt, LEN_AND_LIT(" "));
}
free(ctl);
} else
{
gtm_putmsg(VARLSTCNT(2) ERR_BADREGION, 0);
locks = TRUE;
}
if (!locks)
{
gtm_putmsg(VARLSTCNT(4) ERR_NOLOCKMATCH, 2, REG_LEN_STR(gv_cur_region));
}
assert((ls_free <= 100) && (ls_free >= 0));
gtm_putmsg(VARLSTCNT(4) ERR_LOCKSPACEUSE, 2, ((int)ls_free),
cs_addrs->hdr->lock_space_size/OS_PAGELET_SIZE);
}
}
if (!match && reg.len != 0)
rts_error(VARLSTCNT(4) ERR_NOREGION, 2, reg.len, reg.addr);
}
void lke_show(void)
{
bool locks, all = TRUE, wait = TRUE, interactive = FALSE, match = FALSE, memory = TRUE, nocrit = TRUE;
boolean_t exact = FALSE, was_crit;
int4 pid;
size_t ls_len;
int n;
char regbuf[MAX_RN_LEN], nodebuf[32], one_lockbuf[MAX_KEY_SZ];
mlk_ctldata_ptr_t ctl;
mstr reg, node, one_lock;
error_def(ERR_UNIMPLOP);
error_def(ERR_TEXT);
/* Get all command parameters */
reg.addr = regbuf;
reg.len = SIZEOF(regbuf);
node.addr = nodebuf;
node.len = SIZEOF(nodebuf);
one_lock.addr = one_lockbuf;
one_lock.len = SIZEOF(one_lockbuf);
if (lke_getcli(&all, &wait, &interactive, &pid, ®, &node, &one_lock, &memory, &nocrit, &exact) == 0)
return;
/* Search all regions specified on the command line */
for (gv_cur_region = gd_header->regions, n = 0; n != gd_header->n_regions; ++gv_cur_region, ++n)
{
/* If region matches and is open */
if ((reg.len == 0 ||
gv_cur_region->rname_len == reg.len && memcmp(gv_cur_region->rname, reg.addr, reg.len) == 0) &&
gv_cur_region->open)
{
match = TRUE;
util_out_print("!/!AD!/", NOFLUSH, REG_LEN_STR(gv_cur_region));
/* If distributed database, the region is located on another node */
if (gv_cur_region->dyn.addr->acc_meth == dba_cm)
{
# if defined(LKE_WORKS_OK_WITH_CM)
/* Obtain lock info from the remote node */
locks = gtcmtr_lke_showreq(gv_cur_region->dyn.addr->cm_blk, gv_cur_region->cmx_regnum,
all, wait, pid, &node);
# else
gtm_putmsg(VARLSTCNT(10) ERR_UNIMPLOP, 0, ERR_TEXT, 2,
LEN_AND_LIT("GT.CM region - locks must be displayed on the local node"),
ERR_TEXT, 2, REG_LEN_STR(gv_cur_region));
continue;
# endif
} else if (gv_cur_region->dyn.addr->acc_meth == dba_bg || gv_cur_region->dyn.addr->acc_meth == dba_mm)
{ /* Local region */
cs_addrs = &FILE_INFO(gv_cur_region)->s_addrs;
ls_len = (size_t)(cs_addrs->lock_addrs[1] - cs_addrs->lock_addrs[0]);
ctl = (mlk_ctldata_ptr_t)malloc(ls_len);
/* Prevent any modification of the lock space while we make a local copy of it */
if (cs_addrs->critical != NULL)
crash_count = cs_addrs->critical->crashcnt;
was_crit = cs_addrs->now_crit;
if (!nocrit && !was_crit)
grab_crit(gv_cur_region);
longcpy((uchar_ptr_t)ctl, (uchar_ptr_t)cs_addrs->lock_addrs[0], ls_len);
if (!nocrit && !was_crit)
rel_crit(gv_cur_region);
locks = ctl->blkroot == 0 ?
FALSE:
lke_showtree(NULL, (mlk_shrblk_ptr_t)R2A(ctl->blkroot), all, wait, pid,
one_lock, memory);
free(ctl);
} else
{
util_out_print(NULL, RESET);
util_out_print("Region is not BG, MM, or CM", FLUSH);
locks = TRUE;
}
if (!locks)
{
util_out_print(NULL, RESET);
util_out_print("No locks were found in !AD", FLUSH, REG_LEN_STR(gv_cur_region));
}
}
}
if (!match && reg.len != 0)
rts_error(VARLSTCNT(4) ERR_NOREGION, 2, reg.len, reg.addr);
}
