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; }