static pwr_tBoolean
checkQ (
pool_sHead *php,
pool_sQlink *item
)
{
pool_sQlink *link;
if (item == NULL) {
errh_Error("checkQ in pool: %s, item == NULL", php->gphp->name);
return NO;
}
if (item->self == pool_cNRef) {
errh_Error("checkQ in pool: %s, item->self == pool_cNRef, item: %u", php->gphp->name, item);
return NO;
}
link = pool_Address(NULL, php, item->self);
if (item != link) {
errh_Error("checkQ in pool: %s, item != pool_Address(NULL, php, item->self),\n item: %u != %u",
php->gphp->name, item, link);
return NO;
}
return YES;
#if 0
return item == pool_Address(NULL, php, item->self);
#endif
}
static pool_tRef findNode( ptree_sTable *tp,
void *key)
{
ptree_sNode *np;
pool_tRef nr;
int comp;
pwr_tStatus sts;
tp->g->nSearch++;
/* use sentinel */
memcpy( tp->g->keyOffset + (char *) tp->nullp, key, tp->g->keySize);
/* use key node for comparisons */
memcpy(tp->g->keyOffset + (char *) tp->keyp, key, tp->g->keySize);
for (nr = tp->g->root, np = (ptree_sNode *)pool_Address( &sts, tp->php, nr);;
np = pool_Address(&sts, tp->php, nr)) {
comp = tp->compareFunc(tp, tp->keyp, np);
if (comp == 0)
break;
else if (comp < 0)
nr = np->left;
else
nr = np->right;
}
return nr;
}
static pool_tRef maximumNode(ptree_sTable* tp, pool_tRef nr)
{
pwr_tStatus sts;
ptree_sNode* np = pool_Address(&sts, tp->php, nr);
for (; np->right != tp->g->null;
nr = np->right, np = pool_Address(&sts, tp->php, nr))
;
return nr;
}
static void ptreeCheck( ptree_sTable *tp,
pool_tRef nr, int *count, int *maxlevel,
int *hight, int level,
char *(*printKey)(ptree_sNode *))
{
int comp;
int hleft;
int hright;
ptree_sNode *np, *left, *right;
pwr_tStatus sts;
if (nr == tp->g->null) {
*hight = 0;
return;
}
if (level > *maxlevel)
*maxlevel = level;
np = pool_Address(&sts, tp->php, nr);
ptreeCheck(tp, np->left, count, maxlevel, &hleft, level+1, printKey);
if (np->left != tp->g->null) {
left = pool_Address(&sts, tp->php, np->left);
if (left->parent != nr) {
printf("leftLinkerror: Node key: %s not linked to parent key: %s\n",
printKey(left), printKey(np));
}
comp = tp->compareFunc(tp, np, left);
if (comp < 1) {
printf("leftLink sort error: Node key: %s not less than key: %s\n",
printKey(left), printKey(np));
}
}
(*count)++;
ptreeCheck(tp, np->right, count, maxlevel, &hright, level+1, printKey);
if (np->right != tp->g->null) {
right = pool_Address(&sts, tp->php, np->right);
if (right->parent != nr) {
printf("rightLinkerror: Node key: %s not linked to parent key: %s\n",
printKey(right), printKey(np));
}
comp = tp->compareFunc(tp, np, right);
if (comp > -1) {
printf("rightLink sort error: Node key: %s not greater than key: %s\n",
printKey(right), printKey(np));
}
}
if ((hright - hleft) != np->bal) {
printf("balerror key: %s, level: %d, hr: %d, hl: %d, bal: %d\n",
printKey(np), level, hright, hleft, np->bal);
}
*hight = (hright > hleft ? hright : hleft) + 1;
}
ptree_sTable* ptree_Create(pwr_tStatus* sts, pool_sHead* php, ptree_sTable* ttp,
ptree_sGtable* gttp,
int (*compareFunc)(ptree_sTable* tp, ptree_sNode* x, ptree_sNode* y))
{
ttp->php = php;
ttp->g = gttp;
ttp->nullp = pool_Address(sts, php, gttp->null);
ttp->keyp = pool_Address(sts, php, gttp->key);
ttp->compareFunc = compareFunc;
*sts = TREE__SUCCESS;
return ttp;
}
static pool_tRef allocNode( ptree_sTable *tp,
void *key)
{
pool_tRef nr;
ptree_sNode *np;
pool_tRef fr;
ptree_sNode *fp;
pool_tRef or;
ptree_sNode *op;
pool_tRef ar;
ptree_sAlloc *ap;
int i;
pwr_tStatus sts;
ptree_sGtable *gttp = tp->g;
nr = gttp->free;
if (nr == pool_cNRef) {
gttp->nMalloc++;
ar = pool_RefAlloc( &sts, tp->php, gttp->allocCount * gttp->recordSize +
sizeof(ptree_sAlloc));
ap = (ptree_sAlloc *) pool_Address( &sts, tp->php, ar);
ap->next = gttp->firstAlloc;
gttp->firstAlloc = ar;
nr = fr = (pool_tRef)( ((ptree_sAlloc *) ar) + 1);
np = fp = (ptree_sNode *)( ap + 1);
if (fr == pool_cNRef)
return fr;
fr = gttp->recordSize + fr;
fp = (ptree_sNode *) (gttp->recordSize + (char *) fp);
gttp->free = fr;
gttp->nFree += gttp->allocCount;
for (i = 1, op = fp, or = fr; i < gttp->allocCount - 1; i++) {
fp = (ptree_sNode *) (gttp->recordSize + (char *) fp);
fr = gttp->recordSize + fr;
op->right = fr;
op = fp;
}
}
else {
np = pool_Address( &sts, tp->php, gttp->free);
gttp->free = np->right;
}
gttp->nAlloc++;
gttp->nFree--;
np->left = np->right = np->parent = gttp->null;
if (key != NULL)
memcpy(gttp->keyOffset + (char *) np, key, gttp->keySize);
return nr;
}
static pwr_tBoolean
decodeObject (
pwr_tStatus *sts,
gdb_sObject *op,
gdb_sClass *cp,
co_eBO bo
)
{
char *p;
int i;
gdb_sAttribute *ap;
if (op->u.n.flags.b.bodyDecoded) return TRUE;
p = pool_Address(sts, gdbroot->rtdb, op->u.n.body);
if (p == NULL) return NO;
for (i = 0, ap = cp->attr; i < cp->acount; i++, ap++) {
if (ap->flags.b.state)
continue;
if (convFctn[pwr_Tix(ap->type)] == NULL)
continue;
if (!convFctn[pwr_Tix(ap->type)](p, ap, bo))
return NO;
}
op->u.n.flags.b.bodyDecoded = 1;
return TRUE;
}
static pool_tRef predecessorNode(ptree_sTable* tp, pool_tRef nr)
{
pwr_tStatus sts;
ptree_sNode* p;
pool_tRef pr;
ptree_sNode* np = pool_Address(&sts, tp->php, nr);
if (np->left != tp->g->null)
return maximumNode(tp, np->left);
for (pr = np->parent, p = pool_Address(&sts, tp->php, pr);
pr != tp->g->null && nr == p->left;
np = p, nr = pr, pr = p->parent, p = pool_Address(&sts, tp->php, pr))
;
return pr;
}
void ptree_Init( pool_sHead *php,
ptree_sGtable *gttp,
size_t keySize,
ptrdiff_t keyOffset,
size_t recordSize,
unsigned int allocCount)
{
pwr_tStatus sts;
ptree_sNode *nullp;
ptree_sTable t;
gttp->keySize = keySize;
gttp->keyOffset = keyOffset;
gttp->recordSize = recordSize;
gttp->allocCount = allocCount;
t.g = gttp;
t.php = php;
gttp->null = allocNode( &t, NULL);
gttp->key = allocNode( &t, NULL);
gttp->root = gttp->null;
nullp = pool_Address( &sts, php, gttp->null);
nullp->bal = 0;
nullp->left = gttp->null;
nullp->right = gttp->null;
nullp->parent = gttp->null;
}
static void ptreePrint( ptree_sTable *tp,
pool_tRef nr,
pool_tRef or,
pool_tRef oor,
int level,
void (*printNode)(ptree_sNode *, int))
{
pwr_tStatus sts;
ptree_sNode *np;
if ( nr == tp->g->null)
return;
if (level > tp->g->maxDepth)
tp->g->maxDepth = level;
np = pool_Address( &sts, tp->php, nr);
ptreePrint( tp, np->left, nr, np->parent, level+1, printNode);
printNode(np, level);
switch (np->bal) {
case 1:
tp->g->nHP++;
break;
case 0:
tp->g->nHZ++;
break;
case -1:
tp->g->nHN++;
break;
}
ptreePrint(tp, np->right, nr, np->parent, level+1, printNode);
}
pool_sQlink *
pool_QinsertSucc (
pwr_tStatus *sts,
pool_sHead *php,
pool_sQlink *item, /* Item to insert */
pool_sQlink *pred /* Insert after this element */
)
{
pool_sQlink *succ;
volatile pwr_tBoolean result;
result = checkInitQ(php, item);
pwr_Assert(result);
succ = pool_Address(NULL, php, pred->flink);
pwr_Assert(checkQ(php, succ));
pwr_Assert(checkQ(php, pred));
pwr_Assert(succ->blink == pred->self);
pwr_Assert(succ->self == pred->flink);
item->blink = pred->self;
item->flink = pred->flink;
pred->flink = succ->blink = item->self;
return succ;
}
pool_sQlink *
pool_QinsertPred (
pwr_tStatus *sts,
pool_sHead *php,
pool_sQlink *item, /* Item to insert */
pool_sQlink *succ /* Insert before this element */
)
{
pool_sQlink *pred;
volatile pwr_tBoolean result;
result = checkInitQ(php, item);
pwr_Assert(result);
pred = pool_Address(sts, php, succ->blink);
pwr_Assert(checkQ(php, succ));
pwr_Assert(checkQ(php, pred));
pwr_Assert(pred->flink == succ->self);
pwr_Assert(pred->self == succ->blink);
item->flink = succ->self;
item->blink = succ->blink;
succ->blink = pred->flink = item->self;
return pred;
}
pwr_tBoolean sanc_Subscribe(pwr_tStatus* sts, gdb_sObject* op)
{
gdb_sVolume* vp;
gdb_sNode* np;
if (sts != NULL)
*sts = 1;
gdb_AssumeLocked;
if (op->l.flags.b.isNative)
pwr_Return(NO, sts, SAN__NATIVE);
if (op->u.c.flags.m & (gdb_mCo_sancAdd | gdb_mCo_sancAct)) {
op->u.c.sanexp = 0;
return YES;
}
vp = pool_Address(NULL, gdbroot->pool, op->l.vr);
np = pool_Address(NULL, gdbroot->pool, vp->l.nr);
if (op->u.c.flags.b.sancRem) {
pool_Qremove(NULL, gdbroot->pool, &op->u.c.sanc_ll);
op->u.c.flags.b.sancRem = 0;
pwr_Assert(np->sancRem_lc != 0);
np->sancRem_lc--;
pool_QinsertPred(NULL, gdbroot->pool, &op->u.c.sanc_ll, &np->sancAct_lh);
op->u.c.flags.b.sancAct = 1;
np->sancAct_lc++;
return YES;
}
pwr_Assert(!pool_QisLinked(NULL, gdbroot->pool, &op->u.c.sanc_ll));
pool_QinsertPred(NULL, gdbroot->pool, &op->u.c.sanc_ll, &np->sancAdd_lh);
op->u.c.flags.b.sancAdd = 1;
memset(&op->l.al, 0, sizeof(op->l.al));
np->sancAdd_lc++;
++gdbroot->db->sancid.rix;
op->u.c.sanid = gdbroot->db->sancid;
op->u.c.sanexp = 0;
return YES;
}
void *ptree_Successor(pwr_tStatus *sts, ptree_sTable *tp, void *np)
{
pool_tRef nr = pool_Reference( sts, tp->php, np);
nr = successorNode( tp, nr);
if (nr == tp->g->null)
return NULL;
np = pool_Address( sts, tp->php, nr);
return np;
}
static void freeNode(ptree_sTable* tp, pool_tRef nr)
{
pwr_tStatus sts;
ptree_sNode* np = pool_Address(&sts, tp->php, nr);
memset(np, 0, tp->g->recordSize);
np->right = tp->g->free;
tp->g->free = nr;
tp->g->nFree++;
return;
}
void* ptree_Predecessor(pwr_tStatus* sts, ptree_sTable* tp, void* np)
{
pool_tRef nr = pool_Reference(sts, tp->php, np);
nr = predecessorNode(tp, nr);
if (nr == tp->g->null)
pwr_Return(NULL, sts, TREE__NOTFOUND);
np = pool_Address(sts, tp->php, nr);
pwr_Return(np, sts, TREE__FOUND);
}
void *ptree_Find( pwr_tStatus *sts, ptree_sTable *tp, void *key)
{
ptree_sNode *np;
pool_tRef nr;
nr = findNode(tp, key);
if (nr == tp->g->null)
pwr_Return(NULL, sts, TREE__NOTFOUND);
np = pool_Address( sts, tp->php, nr);
pwr_Return((void *)np, sts, TREE__FOUND);
}
void *ptree_Minimum(pwr_tStatus *sts, ptree_sTable*tp)
{
ptree_sNode *np;
pool_tRef nr;
nr = minimumNode(tp, tp->g->root);
if ( nr == tp->g->null)
pwr_Return(NULL, sts, TREE__NOTFOUND);
np = pool_Address(sts, tp->php, nr);
pwr_Return((void *)np, sts, TREE__FOUND);
}
hash_sTable *
hash_Create (
pwr_tStatus *sts,
pool_sHead *php,
hash_sTable *htp,
hash_sGtable *ghtp,
pwr_tBoolean (*comp_f) (const void *, void *), /* Key comparison routine */
pwr_tUInt32 (*xform_f) (const void *, size_t) /* Key transformation routine */
)
{
pwr_tUInt32 i;
pool_sQlink *lh;
memset(htp, 0, sizeof(*htp));
htp->php = php;
ghtp->inits++;
if (!ghtp->flags.b.created) {
ghtp->size = nextPrime(ghtp->size);
ghtp->table = pool_RefAlloc(sts, php, sizeof(hash_sEntry) * ghtp->size);
if (ghtp->table == pool_cNRef) return NULL;
htp->tp = pool_Address(sts, php, ghtp->table);
if (htp->tp == NULL) return NULL;
for (i = 0, lh = htp->tp; i < ghtp->size; i++, lh++)
pool_Qinit(sts, php, lh);
ghtp->flags.b.created = 1;
} else {
htp->tp = pool_Address(sts, php, ghtp->table);
}
htp->ghtp = ghtp;
htp->comp_f = comp_f;
htp->xform_f = xform_f;
pwr_Return(htp, sts, HASH__SUCCESS);
}
static void deleteTree( pwr_tStatus *sts, ptree_sTable *tp)
{
ptree_sAlloc *ap;
pool_tRef ar;
pool_tRef far;
if (tp == NULL) return;
for ( ar = tp->g->firstAlloc; ar != pool_cNRef;) {
far = ar;
ap = pool_Address( sts, tp->php, ar);
ar = ap->next;
pool_FreeReference( sts, tp->php, far);
}
}
pool_tRef
pool_ItemReference (
pwr_tStatus *sts,
pool_sHead *php,
void *p
)
{
pwr_tStatus lsts;
pool_sEntry *pep = entryPAdd(p, -sizeof(pool_sEntry));
if (p == pool_Address(&lsts, php, pep->next))
return pep->next;
return pool_Reference(sts, php, p);
}
pwr_tBoolean
dvol_DeleteObject (
pwr_tStatus *sts,
pwr_tObjid oid
)
{
static cvol_sNotify dm; /* Cannot be on the stack for VAXELN */
gdb_sObject *op;
gdb_sObject *p_op;
gdb_sVolume *vp;
gdb_AssumeLocked;
if (oid.oix == pwr_cNObjectIx)
pwr_Return(FALSE, sts, GDH__VOLDELETE);
op = vol_OidToObject(sts, oid, gdb_mLo_dynamic, vol_mTrans_none, cvol_eHint_none);
if (op == NULL) return FALSE;
if (op->g.flags.b.isParent && cdh_ObjidIsNotNull(op->g.soid))
pwr_Return(FALSE, sts, GDH__CHILDREN);
p_op = pool_Address(NULL, gdbroot->pool, op->l.por);
vp = pool_Address(NULL, gdbroot->pool, op->l.vr);
cvols_InitNotify(op, &dm, net_eMsg_deleteObject);
unadoptObject(sts, op, p_op, &dm);
vol_UnlinkObject(sts, vp, op, vol_mLink_delete);
cvols_Notify(&dm);
pwr_Return(TRUE, sts, GDH__SUCCESS);
}
pwr_tBoolean
pool_QisLinked (
pwr_tStatus *sts,
pool_sHead *php,
pool_sQlink *item
)
{
pool_sQlink *pred;
pool_sQlink *succ;
pwr_Assert(checkQ(php, item));
pred = pool_Address(sts, php, item->blink);
succ = pool_Address(sts, php, item->flink);
pwr_Assert(checkQ(php, succ));
pwr_Assert(checkQ(php, pred));
pwr_Assert(item->blink == pred->self);
pwr_Assert(item->flink == succ->self);
pwr_Assert(pred->flink == item->self);
pwr_Assert(succ->blink == item->self);
return item->flink != item->self;
}
static pwr_tBoolean
checkInitQ (
pool_sHead *php,
pool_sQlink *item
)
{
if (item->self == pool_cNRef) {
item->self = item->flink = item->blink = pool_Reference(NULL, php, item);
return (item->self != pool_cNRef);
} else {
return (item == pool_Address(NULL, php, item->self)) &&
(item->self == item->flink) &&
(item->self == item->blink);
}
}
static void ptreePrintInorder(
ptree_sTable* tp, pool_tRef nr, void (*printNode)(ptree_sNode*, pool_tRef))
{
pwr_tStatus sts;
if (nr == tp->g->null)
return;
ptree_sNode* np = pool_Address(&sts, tp->php, nr);
if (np->right != tp->g->null)
ptreePrintInorder(tp, np->right, printNode);
printNode(np, nr);
if (np->left != tp->g->null)
ptreePrintInorder(tp, np->left, printNode);
}
void cvolcm_TrimOld()
{
gdb_sTouchQ* oqp = &gdbroot->db->cacheOld;
gdb_sTouchQ* fqp = &gdbroot->db->cacheFree;
pool_sQlink* ol;
gdb_sObject* op;
gdb_sVolume* vp;
gdb_AssumeLocked;
while (fqp->lc < fqp->lc_min) {
ol = pool_Qpred(NULL, gdbroot->pool, &oqp->lh);
if (ol == &oqp->lh)
break;
op = pool_Qitem(ol, gdb_sObject, u.c.cache_ll);
vp = pool_Address(NULL, gdbroot->pool, op->l.vr);
cvol_FreeObject(NULL, vp, op, vol_mLink_cacheTrim);
}
}
void
subc_SetOld (
sub_sClient *cp
)
{
void *adrs;
cp->old = TRUE;
if (cp->userdata != pool_cNRef) {
adrs = pool_Address(NULL, gdbroot->rtdb, cp->userdata);
if (adrs != NULL) {
memset(adrs, 0, cp->usersize);
}
}
subc_RemoveFromMessage(cp);
}
void
cvolcm_DeleteObject (
qcom_sGet *get
)
{
pwr_tStatus sts;
gdb_sObject *op;
gdb_sObject *pop;
gdb_sObject *sop;
pwr_tObjid soid;
gdb_sVolume *vp;
net_sDeleteObject *dop = (net_sDeleteObject *) get->data;
gdb_AssumeUnlocked;
gdb_ScopeLock {
pop = hash_Search(&sts, gdbroot->oid_ht, &dop->par.oid);
op = hash_Search(&sts, gdbroot->oid_ht, &dop->notify.oid);
if (op != NULL) {
pwr_Assert(cdh_ObjidIsEqual(op->g.f.poid, dop->par.oid));
vp = pool_Address(NULL, gdbroot->pool, op->l.vr);
cvol_FreeObject(&sts, vp, op, vol_mLink_cacheDelete);
}
if (pop == NULL) break;
pop->g.soid = dop->par.soid;
if (cdh_ObjidIsNull(pop->g.soid)) {
pop->g.flags.b.isParent = 0;
}
soid = dop->par.oid;
soid.oix = dop->sib.blink;
sop = hash_Search(&sts, gdbroot->oid_ht, &soid);
if (sop != NULL)
sop->g.sib.flink = dop->sib.newflink;
soid.oix = dop->sib.flink;
sop = hash_Search(&sts, gdbroot->oid_ht, &soid);
if (sop != NULL)
sop->g.sib.blink = dop->sib.newblink;
} gdb_ScopeUnlock;
}
ivol_sBody *
ivol_GetBody (
pwr_tStatus *status,
pwr_tObjid oid,
ivol_sBody *lb
)
{
static ivol_sBody body;
pwr_dStatus(sts, status, GDH__SUCCESS);
if (lb == NULL) lb = &body;
lb->op = hash_Search(sts, gdbroot->oid_ht, &oid);
if ( !lb->op)
return 0;
lb->size = lb->op->g.size;
lb->body = pool_Address(NULL, gdbroot->rtdb, lb->op->u.n.body);
return lb;
}
void
subs_DeleteServer (
sub_sServer *sp
)
{
pwr_tStatus sts;
sub_sBuffer *bp;
gdb_sObject *op;
gdb_AssumeLocked;
bp = pool_Address(NULL, gdbroot->pool, sp->br);
/* Disconnect from buffer. If the number of servers connected
to the buffer reaches zero, the buffer gets disposed when
it times out the next time. */
pool_Qremove(NULL, gdbroot->pool, &sp->bufsubs_ll);
bp->bufsubs_lc -= 1;
bp->totsize -= sp->aref.Size;
/* Now give the subsrv entry back to the pool. */
pool_Qremove(NULL, gdbroot->pool, &sp->subs_ll);
gdbroot->db->subs_lc--;
pool_Qremove(NULL, gdbroot->pool, &sp->nodsubs_ll);
/* Remove from server table. */
hash_Remove(&sts, gdbroot->subs_ht, sp);
/* Decrement subcounter for referenced object */
op = vol_OidToObject(&sts, sp->aref.Objid, gdb_mLo_owned, vol_mTrans_alias, cvol_eHint_none);
if (op != NULL) {
op->u.n.subcount--;
}
pool_Free(NULL, gdbroot->pool, sp);
}
