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 stp_expand_array(void)
{
mstr **a;
int n;
n = stp_array_size;
stp_array_size += STP_MAXITEMS;
a = stp_array;
stp_array = (mstr **) malloc(stp_array_size * sizeof(mstr *));
longcpy((uchar_ptr_t)stp_array, (uchar_ptr_t)a, n * sizeof(mstr *));
free(a);
return;
}
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 zro_load (mstr *str)
{
unsigned toktyp, status;
mstr tok;
char *lp, *top;
zro_ent array[ZRO_MAX_ENTS], *op;
int oi, si, total_ents;
struct stat outbuf;
int stat_res;
char tranbuf[MAX_FBUFF + 1];
parse_blk pblk;
error_def (ERR_DIRONLY);
error_def (ERR_FILEPARSE);
error_def (ERR_FSEXP);
error_def (ERR_MAXARGCNT);
error_def (ERR_QUALEXP);
error_def (ERR_ZROSYNTAX);
error_def (ERR_NOLBRSRC);
error_def (ERR_INVZROENT);
lp = str->addr;
top = lp + str->len;
while (lp < top && *lp == ZRO_DEL)
lp++;
array[0].type = ZRO_TYPE_COUNT;
array[0].count = 0;
memset(&pblk, 0, sizeof(pblk));
pblk.buffer = tranbuf;
GETTOK;
if (toktyp == ZRO_EOL)
{
array[0].count = 1;
array[1].type = ZRO_TYPE_OBJECT;
array[1].str.len = 0;
array[2].type = ZRO_TYPE_COUNT;
array[2].count = 1;
array[3] = array[1];
array[3].type = ZRO_TYPE_SOURCE;
si = 4;
} else
{
for (oi = 1;;)
{
if (toktyp != ZRO_IDN)
rts_error(VARLSTCNT(5) ERR_ZROSYNTAX, 2, str->len, str->addr, ERR_FSEXP);
if (oi + 1 >= ZRO_MAX_ENTS)
rts_error(VARLSTCNT(7) ERR_ZROSYNTAX, 2, str->len, str->addr, ERR_MAXARGCNT, 1, ZRO_MAX_ENTS);
if (tok.len >= sizeof (tranbuf))
rts_error(VARLSTCNT(8) ERR_ZROSYNTAX, 2, str->len, str->addr, ERR_FILEPARSE, 2, tok.len, tok.addr);
pblk.buff_size = MAX_FBUFF;
pblk.fnb = 0;
status = parse_file(&tok, &pblk);
if (!(status & 1))
rts_error(VARLSTCNT(9) ERR_ZROSYNTAX, 2, str->len, str->addr,
ERR_FILEPARSE, 2, tok.len, tok.addr, status);
tranbuf[ pblk.b_esl ] = 0;
STAT_FILE(tranbuf, &outbuf, stat_res);
if (-1 == stat_res)
rts_error(VARLSTCNT(9) ERR_ZROSYNTAX, 2, str->len, str->addr, ERR_FILEPARSE, 2, tok.len, tok.addr,
errno);
if (S_ISREG(outbuf.st_mode))
{ /* regular file - a shared library file */
array[oi].shrlib = fgn_getpak(tranbuf, ERROR);
array[oi].type = ZRO_TYPE_OBJLIB;
si = oi + 1;
} else
{
if (!S_ISDIR(outbuf.st_mode))
rts_error(VARLSTCNT(8) ERR_ZROSYNTAX, 2, str->len, str->addr, ERR_INVZROENT, 2,
tok.len, tok.addr);
array[oi].type = ZRO_TYPE_OBJECT;
array[oi + 1].type = ZRO_TYPE_COUNT;
si = oi + 2;
}
array[0].count++;
array[oi].str = tok;
GETTOK;
if (toktyp == ZRO_LBR)
{
if (array[oi].type == ZRO_TYPE_OBJLIB)
rts_error(VARLSTCNT(5) ERR_ZROSYNTAX, 2, str->len, str->addr, ERR_NOLBRSRC);
GETTOK;
if (toktyp == ZRO_DEL)
GETTOK;
if (toktyp != ZRO_IDN && toktyp != ZRO_RBR)
rts_error(VARLSTCNT(5) ERR_ZROSYNTAX, 2, str->len, str->addr, ERR_QUALEXP);
array[oi + 1].count = 0;
for (;;)
{
if (toktyp == ZRO_RBR)
break;
if (toktyp != ZRO_IDN)
rts_error(VARLSTCNT(5) ERR_ZROSYNTAX, 2, str->len, str->addr, ERR_FSEXP);
if (si >= ZRO_MAX_ENTS)
rts_error(VARLSTCNT(7) ERR_ZROSYNTAX, 2, str->len, str->addr,
ERR_MAXARGCNT, 1, ZRO_MAX_ENTS);
if (tok.len >= sizeof (tranbuf))
rts_error(VARLSTCNT(8) ERR_ZROSYNTAX, 2, str->len, str->addr,
ERR_FILEPARSE, 2, tok.len, tok.addr);
pblk.buff_size = MAX_FBUFF;
pblk.fnb = 0;
status = parse_file(&tok, &pblk);
if (!(status & 1))
rts_error(VARLSTCNT(9) ERR_ZROSYNTAX, 2, str->len, str->addr,
ERR_FILEPARSE, 2, tok.len, tok.addr, status);
tranbuf[ pblk.b_esl ] = 0;
STAT_FILE(tranbuf, &outbuf, stat_res);
if (-1 == stat_res)
rts_error(VARLSTCNT(9) ERR_ZROSYNTAX, 2, str->len, str->addr,
ERR_FILEPARSE, 2, tok.len, tok.addr, errno);
if (!S_ISDIR(outbuf.st_mode))
rts_error(VARLSTCNT(8) ERR_ZROSYNTAX, 2, str->len, str->addr,
ERR_DIRONLY, 2, tok.len, tok.addr);
array[oi + 1].count++;
array[si].type = ZRO_TYPE_SOURCE;
array[si].str = tok;
si++;
GETTOK;
if (toktyp == ZRO_DEL)
GETTOK;
}
GETTOK;
} else
{
if ((array[oi].type != ZRO_TYPE_OBJLIB) && (toktyp == ZRO_DEL || toktyp == ZRO_EOL))
{
if (si >= ZRO_MAX_ENTS)
rts_error(VARLSTCNT(7) ERR_ZROSYNTAX, 2, str->len, str->addr,
ERR_MAXARGCNT, 1, ZRO_MAX_ENTS);
array[oi + 1].count = 1;
array[si] = array[oi];
array[si].type = ZRO_TYPE_SOURCE;
si++;
}
}
if (toktyp == ZRO_EOL)
break;
if (toktyp == ZRO_DEL)
GETTOK;
else
rts_error(VARLSTCNT(4) ERR_ZROSYNTAX, 2, str->len, str->addr);
oi = si;
}
}
total_ents = si;
if (zro_root)
{
assert (zro_root->type == ZRO_TYPE_COUNT);
oi = zro_root->count;
assert (oi);
for (op = zro_root + 1; oi-- > 0; )
{ /* release space held by translated entries */
assert (op->type == ZRO_TYPE_OBJECT || op->type == ZRO_TYPE_OBJLIB);
if (op->str.len)
free(op->str.addr);
if ((op++)->type == ZRO_TYPE_OBJLIB)
continue; /* i.e. no sources for shared library */
assert (op->type == ZRO_TYPE_COUNT);
si = (op++)->count;
for ( ; si-- > 0; op++)
{
assert (op->type == ZRO_TYPE_SOURCE);
if (op->str.len)
free(op->str.addr);
}
}
free (zro_root);
}
zro_root = (zro_ent *) malloc (total_ents * sizeof (zro_ent));
longcpy ((uchar_ptr_t)zro_root, (uchar_ptr_t)array, total_ents * sizeof (zro_ent));
assert (zro_root->type == ZRO_TYPE_COUNT);
oi = zro_root->count;
assert (oi);
for (op = zro_root + 1; oi-- > 0; )
{
assert (op->type == ZRO_TYPE_OBJECT || op->type == ZRO_TYPE_OBJLIB);
if (op->str.len)
{
pblk.buff_size = MAX_FBUFF;
pblk.fnb = 0;
status = parse_file(&op->str, &pblk);
if (!(status & 1))
rts_error(VARLSTCNT(9) ERR_ZROSYNTAX, 2, str->len, str->addr,
ERR_FILEPARSE, 2, op->str.len, op->str.addr, status);
op->str.addr = (char *)malloc(pblk.b_esl);
op->str.len = pblk.b_esl;
memcpy(op->str.addr, pblk.buffer, pblk.b_esl);
}
if ((op++)->type == ZRO_TYPE_OBJLIB)
continue;
assert (op->type == ZRO_TYPE_COUNT);
si = (op++)->count;
for ( ; si-- > 0; op++)
{
assert (op->type == ZRO_TYPE_SOURCE);
if (op->str.len)
{
pblk.buff_size = MAX_FBUFF;
pblk.fnb = 0;
status = parse_file(&op->str, &pblk);
if (!(status & 1))
rts_error(VARLSTCNT(9) ERR_ZROSYNTAX, 2, str->len, str->addr,
ERR_FILEPARSE, 2, op->str.len, op->str.addr, status);
op->str.addr = (char *)malloc(pblk.b_esl);
op->str.len = pblk.b_esl;
memcpy(op->str.addr, pblk.buffer, pblk.b_esl);
}
}
}
}
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);
}
