void *
hash_Insert (
pwr_tStatus *sts,
hash_sTable *htp,
void *ip /* Address of item to be inserted. */
)
{
hash_sGtable *ghtp;
pool_sQlink *il;
pool_sQlink *bl; /* Address of bucket link. */
ghtp = htp->ghtp;
ghtp->inserts++;
il = findEntry(sts, &bl, htp, (char* )ip + ghtp->key_offset);
if (il != NULL) {
pwr_Return(NULL, sts, HASH__DUPLICATE);
} else {
if (bl->self == bl->flink) { /* This is an empty bucket. */
ghtp->used_buckets++;
if (ghtp->used_buckets > ghtp->max_used_buckets)
ghtp->max_used_buckets = ghtp->used_buckets;
}
il = (pool_sQlink *)((char *)ip + ghtp->link_offset);
il = pool_QinsertSucc(sts, htp->php, il, bl);
if (il == NULL) return NULL;
ghtp->entries++;
if (ghtp->entries > ghtp->max_entries)
ghtp->max_entries = ghtp->entries;
}
pwr_Return(ip, sts, HASH__SUCCESS);
}
void *
dbs_Address(pwr_tStatus *sts, const dbs_sVenv *vep, dbs_tRef r)
{
dbs_uRefBits bits;
if (r == dbs_cNref)
return NULL;
if (!vep->mp->flags.b.isMapped)
pwr_Return(NULL, sts, DBS__NOTMAPPED);
if (vep->index != 0) {
/*printf("index: %d, name %s\n", vep->index, vep->vp->name)*/;
}
bits.m = r;
if (bits.b.sect > dbs_eSect_)
pwr_Return(NULL, sts, DBS__BADSECT);
if (bits.b.offs >= vep->sect[bits.b.sect].size)
pwr_Return(NULL, sts, DBS__BADOFFS);
return (void *)(vep->base + vep->sect[bits.b.sect].offset + bits.b.offs);
}
gdb_sNode *
gdb_AddNode (
pwr_tStatus *sts,
pwr_tNodeId nid,
pwr_tBitMask flags
)
{
gdb_sNode *np;
gdb_AssumeLocked;
np = hash_Search(sts, gdbroot->nid_ht, &nid);
if (np != NULL) return np;
if (np != NULL) {
if (flags & gdb_mAdd_failIfAdded)
pwr_Return(NULL, sts, GDB__DUPLADD);
else
pwr_Return(np, sts, GDB__ALRADD);
}
np = pool_Alloc(sts, gdbroot->pool, sizeof(*np));
if (np == NULL) return NULL;
np->nid = nid;
np->buf_id = 1; /* Next available buffer id */
pool_Qinit(NULL, gdbroot->pool, &np->nid_htl);
pool_Qinit(NULL, gdbroot->pool, &np->nod_ll);
pool_Qinit(NULL, gdbroot->pool, &np->own_lh);
pool_Qinit(NULL, gdbroot->pool, &np->ccvol_lh);
pool_Qinit(NULL, gdbroot->pool, &np->nodms_lh);
pool_Qinit(NULL, gdbroot->pool, &np->nodmo_lh);
pool_Qinit(NULL, gdbroot->pool, &np->subc_lh);
pool_Qinit(NULL, gdbroot->pool, &np->nodsubs_lh);
pool_Qinit(NULL, gdbroot->pool, &np->nodsubb_lh);
pool_Qinit(NULL, gdbroot->pool, &np->sansAct_lh);
pool_Qinit(NULL, gdbroot->pool, &np->sansUpd_lh);
pool_Qinit(NULL, gdbroot->pool, &np->sancAdd_lh);
pool_Qinit(NULL, gdbroot->pool, &np->sancRem_lh);
pool_Qinit(NULL, gdbroot->pool, &np->sancAct_lh);
pool_Qinit(NULL, gdbroot->pool, &np->cacheNode.lh);
#if defined OS_ELN
np->cacheNode.lc_max = 100;
#else
np->cacheNode.lc_max = 200;
#endif
np->cacheNode.flags.b.cacheNode = 1;
np->cacheNode.next = pool_Reference(NULL, gdbroot->pool, &gdbroot->db->cacheCom);
np = hash_Insert(sts, gdbroot->nid_ht, np);
if (np == NULL) errh_Bugcheck(GDH__WEIRD, "adding new node");
pool_QinsertPred(NULL, gdbroot->pool, &np->nod_ll, &gdbroot->db->nod_lh);
return np;
}
void *
tree_Predecessor(pwr_tStatus *sts, tree_sTable *tp, void *np)
{
np = predecessorNode(tp, np);
if (np == tp->null) {
pwr_Return(NULL, sts, TREE__NOTFOUND);
} else {
pwr_Return(np, sts, TREE__FOUND);
}
}
static pool_sSegment *
newSegment (
pwr_tStatus *sts,
pool_sHead *php,
size_t size /* Requested size in pool_sEntry units */
)
{
pool_sGhead *gphp;
pool_sGsegment *gpsp;
pool_sSegment *psp;
sect_sHead *shp;
pwr_tBoolean created;
pwr_tUInt32 i;
char name[16];
if (size << pool_cOffsAlign > pool_cMaxSize)
pwr_Return(NULL, sts, POOL__TOOBIG);
gphp = php->gphp;
/* Find an empty slot */
for (i = 0; i < pool_cSegs; i++)
if (gphp->seg[i].generation == 0)
break;
if (i >= pool_cSegs)
pwr_Return(NULL, sts, POOL__NOSLOT);
gpsp = &gphp->seg[i];
psp = &php->seg[i];
/* Allocate the section */
segName(name, gphp->name, gphp->generation),
shp = sect_Alloc(sts, &created, &psp->sect, size << pool_cOffsAlign, name);
if (shp == NULL) return NULL;
if (!created) errh_Bugcheck(POOL__ALLREXIST, "");
gpsp->type = pool_eSegType_dynamic;
gpsp->size = size << (pool_cOffsAlign - pool_cOffsGranul);
gpsp->fragmax = gpsp->fragsize = size;
gpsp->generation = psp->generation = gphp->generation++;
gpsp->alloccnt = 0;
gpsp->fragcnt = gpsp->fragmaxcnt = 1;
psp->base = psp->sect.base;
psp->base->size = size;
psp->base->next = pool_cNOffset;
gpsp->freeroot.next = 0;
return psp;
}
void *
tree_Minimum(pwr_tStatus *sts, tree_sTable*tp)
{
tree_sNode *np;
np = minimumNode(tp, tp->root);
if (np == tp->null) {
pwr_Return(NULL, sts, TREE__NOTFOUND);
} else {
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);
}
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 *
tree_Find(pwr_tStatus *sts, tree_sTable *tp, void *key)
{
tree_sNode *np;
np = findNode(tp, key);
if (np == tp->null) {
pwr_Return(NULL, sts, TREE__NOTFOUND);
} else {
pwr_Return((void *)np, sts, TREE__FOUND);
}
}
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);
}
static tree_sTable *
createTree(
pwr_tStatus *sts,
size_t keySize,
ptrdiff_t keyOffset,
size_t recordSize,
unsigned int allocCount,
int (*compareFunc) (tree_sTable *tp, tree_sNode *x, tree_sNode *y))
{
tree_sTable *tp;
tp = (tree_sTable *) calloc(1, sizeof(*tp));
if (tp == NULL)
pwr_Return(NULL, sts, TREE__INSVIRMEM);
tp->keySize = keySize;
tp->keyOffset = keyOffset;
tp->recordSize = recordSize;
tp->allocCount = allocCount;
tp->compareFunc = compareFunc;
tp->null = allocNode(tp, NULL);
tp->key = allocNode(tp, NULL);
tp->root = tp->null;
tp->null->bal = 0;
tp->null->left = tp->null;
tp->null->right = tp->null;
tp->null->parent = tp->null;
return tp;
}
pwr_tBoolean
dbs_AlignedRead(pwr_tStatus *sts, void *buf, pwr_tUInt32 size, const dbs_sEnv *ep)
{
int offset;
*sts = DBS__SUCCESS;
if (fread(buf, size, 1, ep->f) == 0)
pwr_Return(NO, sts, errno_GetStatus());
if ((offset = dbs_dPadding(size)) > 0)
if(fseek(ep->f, offset, SEEK_CUR))
pwr_Return(NO, sts, errno_GetStatus());
return YES;
}
void *
hash_Remove (
pwr_tStatus *sts,
hash_sTable *htp,
void *ip /* Address of item to be removed. */
)
{
hash_sGtable *ghtp;
pool_sQlink *il;
pool_sQlink *bl;
ghtp = htp->ghtp;
ghtp->removes++;
il = findEntry(sts, &bl, htp, (char *)ip + ghtp->key_offset);
if (il == NULL) return NULL;
il = pool_Qremove(sts, htp->php, il);
if (il == NULL)
return NULL;
ghtp->entries--;
if (bl->flink == bl->self)
ghtp->used_buckets--;
pwr_Return(ip, sts, HASH__SUCCESS);
}
static tree_sTable *
cloneTree(pwr_tStatus *sts, tree_sTable *otp)
{
tree_sTable *ntp;
ntp = (tree_sTable *) calloc(1, sizeof(*ntp));
if (ntp == NULL)
pwr_Return(NULL, sts, TREE__INSVIRMEM);
ntp->keySize = otp->keySize;
ntp->keyOffset = otp->keyOffset;
ntp->recordSize = otp->recordSize;
ntp->allocCount = otp->allocCount;
ntp->null = allocNode(ntp, NULL);
ntp->compareFunc = otp->compareFunc;
ntp->key = allocNode(ntp, NULL);
ntp->null->bal = 0;
ntp->null->left = ntp->null;
ntp->null->right = ntp->null;
ntp->null->parent = ntp->null;
ntp->root = copyNodes(ntp, ntp->null, otp, otp->root);
ntp->nNode = otp->nNode;
return ntp;
}
gdb_sAliasServer *
gdb_AddAliasServer (
pwr_tStatus *sts,
pwr_tObjid soid,
pwr_tBitMask flags
)
{
gdb_sAliasServer *asp;
gdb_sObject *op = NULL;
gdb_AssumeLocked;
pwr_Assert(cdh_ObjidIsNotNull(soid));
asp = hash_Search(sts, gdbroot->as_ht, &soid);
if (asp != NULL) {
if (flags & gdb_mAdd_failIfAdded)
pwr_Return(NULL, sts, GDB__DUPLADD);
else
pwr_Return(asp, sts, GDB__ALRADD);
}
asp = pool_Alloc(sts, gdbroot->pool, sizeof(*asp));
if (asp == NULL) return NULL;
asp->oid = soid;
pool_Qinit(NULL, gdbroot->pool, &asp->as_htl);
pool_Qinit(NULL, gdbroot->pool, &asp->as_ll);
pool_Qinit(NULL, gdbroot->pool, &asp->cli_lh);
asp = hash_Insert(sts, gdbroot->as_ht, asp);
if (asp == NULL) errh_Bugcheck(GDH__WEIRD, "adding new alias server");
pool_QinsertPred(NULL, gdbroot->pool, &asp->as_ll, &gdbroot->db->as_lh);
op = hash_Search(sts, gdbroot->oid_ht, &soid);
if (op == NULL) errh_Bugcheck(GDH__WEIRD, "getting alias server object");
op->g.flags.b.isAliasServer = 1;
return asp;
}
/*_*
@aref cyclesup CycleSup
*/
lst_sEntry *
csup_Init (
pwr_tStatus *status,
pwr_tObjid tid,
float scanTime
)
{
lst_sEntry *lh;
pwr_tObjid cid;
pwr_tObjid pid;
csup_sObject *cp;
int tv_sec;
pwr_tFloat32 max_delay;
pwr_dStatus(sts, status, CSUP__SUCCESS);
lh = calloc(1, sizeof(*lh));
if (lh == NULL)
pwr_Return(NULL, sts, CSUP__INSVIRMEM);
lst_Init(NULL, lh, NULL);
for (
*sts = gdh_GetClassList(pwr_cClass_CycleSup, &cid);
ODD(*sts);
*sts = gdh_GetNextObject(cid, &cid)
) {
cp = calloc(1, sizeof(*cp));
cp->aref.Objid = cid;
*sts = gdh_DLRefObjectInfoAttrref(&cp->aref, (void**)&cp->o, &cp->dlid);
if (EVEN(*sts))
goto error;
if ( ODD(gdh_GetParent( cid, &pid)) && cdh_ObjidIsEqual( pid, tid))
cp->is_owner = 1;
lst_InsertSucc(NULL, lh, &cp->le, cp);
max_delay = cp->o->MaxDelay;
cp->o->DelayLimit.tv_sec = tv_sec = (int)max_delay;
cp->o->DelayLimit.tv_nsec = (int)((max_delay - (float)tv_sec + FLT_EPSILON) * 1.0e9);
// printf("maxdelay: %f, tv_sec: %d, tv_nsec: %d\n", cp->o->MaxDelay, cp->o->DelayLimit.tv_sec, cp->o->DelayLimit.tv_nsec);
errh_Info("maxdelay: %f, tv_sec: %d, tv_nsec: %d", cp->o->MaxDelay,
cp->o->DelayLimit.tv_sec, cp->o->DelayLimit.tv_nsec);
}
if (lst_IsEmpty(NULL, lh))
goto error;
return lh;
error:
csup_Exit(NULL, lh);
return NULL;
}
void *
tree_Insert(pwr_tStatus *sts, tree_sTable *tp, void *key)
{
tree_sNode *np;
tree_sNode *op;
np = findNode(tp, key);
if (np != tp->null)
pwr_Return((void *)np, sts, TREE__FOUND);
np = allocNode(tp, key);
if (np == NULL) return NULL;
op = insertNode(tp, np);
if (np == op) {
pwr_Return((void *)np, sts, TREE__INSERTED);
} else {
freeNode(tp, np);
pwr_Return(NULL, sts, TREE__ERROR);
}
}
gdb_sVolume *
gdb_AddVolume (
pwr_tStatus *sts,
pwr_tVolumeId vid,
pwr_tBitMask flags
)
{
gdb_sVolume *vp;
gdb_AssumeLocked;
vp = hash_Search(sts, gdbroot->vid_ht, &vid);
if (vp != NULL) {
if (flags & gdb_mAdd_failIfAdded)
pwr_Return(NULL, sts, GDB__DUPLADD);
else
pwr_Return(vp, sts, GDB__ALRADD);
}
vp = pool_Alloc(sts, gdbroot->pool, sizeof(*vp));
if (vp == NULL) return NULL;
vp->g.vid = vid;
vp->g.oid.vid = vid;
pool_Qinit(NULL, gdbroot->pool, &vp->l.vid_htl);
pool_Qinit(NULL, gdbroot->pool, &vp->l.vn_htl);
pool_Qinit(NULL, gdbroot->pool, &vp->l.vol_ll);
pool_Qinit(NULL, gdbroot->pool, &vp->l.own_ll);
pool_Qinit(NULL, gdbroot->pool, &vp->l.obj_lh);
pool_Qinit(NULL, gdbroot->pool, &vp->l.volms_lh);
hash_Insert(sts, gdbroot->vid_ht, vp);
vp->l.flags.b.inVidTable = 1;
pool_QinsertPred(sts, gdbroot->pool, &vp->l.vol_ll, &gdbroot->db->vol_lh);
vp->l.flags.b.inVolList = 1;
return vp;
}
gdb_sMountServer *
gdb_AddMountServer (
pwr_tStatus *sts,
pwr_tObjid soid,
pwr_tBitMask flags
)
{
gdb_sMountServer *msp;
gdb_AssumeLocked;
// pwr_Assert(cdh_ObjidIsNotNull(soid));
if (cdh_ObjidIsNull(soid)) return NULL;
msp = hash_Search(sts, gdbroot->ms_ht, &soid);
if (msp != NULL) {
if (flags & gdb_mAdd_failIfAdded)
pwr_Return(NULL, sts, GDB__DUPLADD);
else
pwr_Return(msp, sts, GDB__ALRADD);
}
msp = pool_Alloc(sts, gdbroot->pool, sizeof(*msp));
if (msp == NULL) return NULL;
msp->oid = soid;
pool_Qinit(NULL, gdbroot->pool, &msp->ms_htl);
pool_Qinit(NULL, gdbroot->pool, &msp->ms_ll);
pool_Qinit(NULL, gdbroot->pool, &msp->nodms_ll);
pool_Qinit(NULL, gdbroot->pool, &msp->volms_ll);
pool_Qinit(NULL, gdbroot->pool, &msp->cli_lh);
msp = hash_Insert(sts, gdbroot->ms_ht, msp);
if (msp == NULL) errh_Bugcheck(GDH__WEIRD, "adding new mount server");
pool_QinsertPred(NULL, gdbroot->pool, &msp->ms_ll, &gdbroot->db->ms_lh);
return msp;
}
static pwr_tBoolean
ConvertGet (
pwr_tStatus *sts,
qcom_sGet *get,
void *data
)
{
pwr_tStatus lsts;
XDR xdrs;
qdb_sNode *np;
tFuncXdr fXdr;
gdb_sNode *gnp;
pwr_tUInt32 netver;
if (get->type.b != net_cMsgClass)
pwr_Return(FALSE, sts, NET__XDRFAILED);
np = hash_Search(&lsts, &qdb->nid_ht, &get->sender.nid);
if (np == NULL) pwr_Return(FALSE, sts, lsts);
if ((int)get->type.s <= (int)net_eMsg__ || (int)get->type.s >= (int)net_eMsg_)
pwr_Return(FALSE, sts, NET__NOSUCHQCOMSUBT);
/* This is a simple way to fix the net_sGvolume difference between
* Neth version 7 and later. If this is needed for more messages
* then a generic solution must be implemented.
*/
fXdr = func_xdr[(int)get->type.s];
if (get->type.s == (qcom_eStype)net_eMsg_volumes) {
gdb_ScopeLock {
gnp = hash_Search(&lsts, gdbroot->nid_ht, &np->nid);
netver = gnp->netver;
} gdb_ScopeUnlock;
if (netver == 7) {
get->type.s = net_eMsg_volumes7;
fXdr = xdr_net_sVolumes7;
}
}
gdb_sClass *
gdb_AddClass (
pwr_tStatus *sts,
pwr_tClassId cid,
pwr_tBitMask flags
)
{
gdb_sClass *cp;
#if 0
pwr_Assert(cid != pwr_cNClassId);
#endif
gdb_AssumeLocked;
cp = hash_Search(sts, gdbroot->cid_ht, &cid);
if (cp != NULL) {
if (flags & gdb_mAdd_failIfAdded)
pwr_Return(NULL, sts, GDB__DUPLADD);
else
pwr_Return(cp, sts, GDB__ALRADD);
}
cp = pool_Alloc(sts, gdbroot->pool, sizeof(*cp));
if (cp == NULL) return NULL;
cp->cid = cid;
pool_Qinit(NULL, gdbroot->pool, &cp->cid_htl);
pool_Qinit(NULL, gdbroot->pool, &cp->cid_lh);
pool_Qinit(NULL, gdbroot->pool, &cp->class_ll);
cp = hash_Insert(sts, gdbroot->cid_ht, cp);
if (cp == NULL) errh_Bugcheck(GDH__WEIRD, "adding new class");
pool_QinsertPred(NULL, gdbroot->pool, &cp->class_ll, &gdbroot->db->class_lh);
return cp;
}
pool_tRef ptree_Insert(pwr_tStatus* sts, ptree_sTable* tp, void* key)
{
pool_tRef nr;
pool_tRef or ;
nr = findNode(tp, key);
if (nr != tp->g->null)
pwr_Return(nr, sts, TREE__FOUND);
nr = allocNode(tp, key);
if (nr == pool_cNRef)
pwr_Return(pool_cNRef, sts, TREE__ERROR);
or = insertNode(tp, nr);
if (nr == or) {
pwr_Return(nr, sts, TREE__INSERTED);
} else {
freeNode(tp, nr);
pwr_Return(pool_cNRef, sts, TREE__ERROR);
}
}
void *ptree_FindSuccessor(pwr_tStatus *sts, ptree_sTable *tp, void *key)
{
ptree_sNode *np;
pool_tRef nr;
nr = findNearNode(tp, key);
if ( tp->last == tp->g->null)
pwr_Return(NULL, sts, TREE__NOTFOUND);
if ( nr != tp->g->null)
nr = successorNode(tp, nr);
else if ( tp->lastComp < 0)
nr = tp->last;
else
nr = successorNode(tp, tp->last);
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);
}
gdb_sObject *
dvol_RenameObject (
pwr_tStatus *sts,
pwr_tObjid oid,
cdh_sParseName *pn
)
{
static cvol_sNotify rm; /* Cannot be on the stack for VAXELN */
gdb_sObject *op;
gdb_sObject *tmp_op;
gdb_AssumeLocked;
op = hash_Search(sts, gdbroot->oid_ht, &oid);
if (op == NULL) return NULL;
if (!op->l.flags.b.dynamic)
pwr_Return(NULL, sts, GDH__STATICVOL);
tmp_op = vol_FamilyToObject(sts, pn->object[0].name.orig, op->g.f.poid);
if (tmp_op != NULL && tmp_op != op)
pwr_Return(NULL, sts, GDH__DUPLNAME);
hash_Remove(sts, gdbroot->family_ht, op);
op->g.f.name = pn->object[0].name;
hash_Insert(sts, gdbroot->family_ht, op);
cvols_InitNotify(op, &rm, net_eMsg_renameObject);
rm.msg.r.f.name = op->g.f.name;
cvols_Notify(&rm);
pwr_Return(op, sts, GDH__SUCCESS);
}
void *
tree_FindSuccessor(pwr_tStatus *sts, tree_sTable *tp, void *key)
{
tree_sNode *np;
np = findNearNode(tp, key);
if (tp->last == tp->null)
pwr_Return(NULL, sts, TREE__NOTFOUND);
if (np != tp->null) {
np = successorNode(tp, np);
} else if (tp->lastComp < 0) {
np = tp->last;
} else {
np = successorNode(tp, tp->last);
}
if (np == tp->null) {
pwr_Return(NULL, sts, TREE__NOTFOUND);
} else {
pwr_Return((void *)np, sts, TREE__FOUND);
}
}
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
sect_Free (
pwr_tStatus *sts,
sect_sHead *shp
)
{
pwr_tStatus lsts;
if (!shp->flags.b.mapped)
pwr_Return(FALSE, sts, 4/*SECT__NOTMAPPED*/);
#if defined(OS_ELN)
ker$delete(&lsts, shp->area);
#elif defined(OS_VMS)
lsts = sys$deltva(shp->sectadr, NULL, 0);
#elif defined OS_POSIX
lsts = 1; /* TODO ? */
#endif
if (ODD(lsts))
shp->flags.b.mapped = 0;
pwr_Return(ODD(lsts), sts, lsts);
}
/** Fetches a cached class.
* If the class is not in the cache then it's fetched from the remote node
*
* @return NULL if an error or classes are equal else a pointer to the class
*/
gdb_sCclass *
cmvolc_GetCachedClass (
pwr_tStatus *sts,
const gdb_sNode *np,
const gdb_sVolume *vp,
mvol_sAttribute *ap,
pwr_tBoolean *equal, /**< set if classes are equal then NULL is returned */
pwr_tBoolean *fetched, /**< true if the class has been fected from the remote node */
gdb_sClass *cp
)
{
qcom_sQid tgt;
qcom_sPut put;
net_sGetCclass *smp; /* Send message. */
net_sGetCclassR *rmp = NULL; /* Receive message. */
gdb_sCcVolKey ccvKey;
gdb_sCclassKey ccKey;
gdb_sCclass *ccp;
gdb_sCclassVolume *ccvp;
int i;
pwr_tUInt32 size;
pwr_tUInt32 nextIdx = 0;
pwr_tUInt32 stopIdx;
gdb_sObject *cop;
pwr_tTime time;
gdb_AssumeLocked;
*equal = 0;
*fetched = 0;
/* Handle nodes that don't support cached classes */
if (!np->cclassSupport) {
*equal = 1;
if (cp == NULL) {
ap->op->u.c.flags.b.classChecked = 1;
ap->op->u.c.flags.b.classEqual = 1;
}
pwr_Return(NULL, sts, GDH__SUCCESS);
}
/** @todo Check vp->u.c.equalClasses first (when implemented) */
ccvKey.nid = np->nid;
if (cp == NULL)
ccvKey.vid = ap->op->g.cid >> 16; /* Class Id to Class Volume Id */
else
void *
hash_Search (
pwr_tStatus *sts,
hash_sTable *htp,
const void *key
)
{
pool_sQlink *il;
htp->ghtp->searchs++;
il = findEntry(sts, NULL, htp, key);
if (il == NULL) return NULL;
pwr_Return((char *)il - htp->ghtp->link_offset, sts, HASH__SUCCESS);
}
void *
pool_AllocNamedSegment (
pwr_tStatus *sts,
pool_sHead *php,
pwr_tUInt32 size,
char *name
)
{
int i;
pool_sGhead *gphp;
pool_sGsegment *gpsp;
pool_sSegment *psp;
gphp = php->gphp;
/* Find an empty slot */
for (i = 0; i < pool_cSegs; i++)
if (gphp->seg[i].generation == 0 ||
(gphp->seg[i].type == pool_eSegType_named &&
strcmp(name, gphp->seg[i].name) == 0))
break;
if (i >= pool_cSegs)
pwr_Return(NULL, sts, POOL__NOSLOT);
gpsp = &gphp->seg[i];
psp = &php->seg[i];
/* Allocate the section */
if (gpsp->generation == 0) {
psp = newSegment(sts, php, entryUnits(size));
if (psp == NULL) return NULL;
memset(psp->base, 0, size);
gpsp->type = pool_eSegType_named;
strncpy(gpsp->name, name, sizeof(gpsp->name) - 1);
gpsp->name[sizeof(gpsp->name) - 1] = '\0';
} else {
psp = ensureMapped(sts, php, psp);
if (psp == NULL) return NULL;
}
return psp->base;
}
