void sansm_Add(qcom_sGet* get)
{
gdb_sObject* op;
gdb_sNode* np;
san_sServer* sp;
int i;
net_sSanAdd* ap = get->data;
gdb_AssumeUnlocked;
gdb_ScopeLock
{
np = hash_Search(NULL, gdbroot->nid_ht, &ap->hdr.nid);
if (np == NULL)
break;
for (i = 0; i < ap->count; i++) {
op = hash_Search(NULL, gdbroot->oid_ht, &ap->sane[i].oid);
if (op == NULL || !op->l.flags.b.isOwned)
continue;
sp = addServer(NULL, np, op, &ap->sane[i]);
if (sp == NULL)
continue;
}
}
gdb_ScopeUnlock;
}
void sansm_Remove(qcom_sGet* get)
{
gdb_sNode* np;
san_sServer* sp;
int i;
net_sSanRemove* rp = get->data;
int old_cnt;
gdb_AssumeUnlocked;
gdb_ScopeLock
{
np = hash_Search(NULL, gdbroot->nid_ht, &rp->hdr.nid);
if (np == NULL)
break;
old_cnt = np->sansAct_lc;
for (i = 0; i < rp->count; i++) {
sp = hash_Search(NULL, gdbroot->sans_ht, &rp->sid[i]);
if (sp == NULL)
continue;
removeServer(np, sp);
}
}
gdb_ScopeUnlock;
}
void
sancm_Update (
qcom_sGet *get
)
{
gdb_sObject *op;
int i;
int error;
net_sSanUpdate *up = get->data;
gdb_AssumeUnlocked;
gdb_ScopeLock {
error = 0;
if (0) errh_Info("sancm_Update, recieved %d", up->count);
for (i = 0; i < up->count; i++) {
op = hash_Search(NULL, gdbroot->oid_ht, &up->data[i].sane.oid);
if (op == NULL || cdh_RefIdIsNotEqual(op->u.c.sanid, up->data[i].sane.sid)) {
error++;
continue;
}
up->data[i].sane.sid.rix = 0; /* Sid is ok! */
vol_UpdateAlarm(NULL, op, up->data[i].al);
}
/* Send remove for errors. */
if (error > 0) {
net_sSanRemove *rp;
int size = sizeof(net_sSanRemove) + (error - 1) * sizeof(rp->sid[0]);
int i;
gdb_sNode *np = hash_Search(NULL, gdbroot->nid_ht, &up->hdr.nid);
qcom_sQid tgt;
tgt.nid = np->nid;
tgt.qix = net_cProcHandler;
rp = calloc(1, size);
if (rp != NULL) {
rp->count = error;
for (i = 0; i < up->count; i++) {
if (up->data[i].sane.sid.rix == 0) continue;
rp->sid[--error] = up->data[i].sane.sid;
}
gdb_Unlock;
errh_Info("sancm_Update, sent removed count %d", rp->count);
net_Put(NULL, &tgt, rp, net_eMsg_sanRemove, 0, size, 0);
gdb_Lock;
free(rp);
}
}
} gdb_ScopeUnlock;
}
void
cvolsm_GetObjectInfo (
qcom_sGet *get
)
{
pwr_tStatus sts;
mvol_sAttribute Attribute;
mvol_sAttribute *ap;
int size;
net_sGetObjectInfoR *rmp;
void *p = NULL;
net_sGetObjectInfo *mp = get->data;
qcom_sPut put;
gdb_sNode *np;
cdh_uTypeId cid;
gdb_sClass *cp;
gdb_AssumeUnlocked;
size = mp->aref.Size + sizeof(net_sGetObjectInfoR) - sizeof(rmp->info);
size = (size + 3) & ~3; /* Size up to nearest multiple of 4. */
rmp = net_Alloc(&sts, &put, size, net_eMsg_getObjectInfoR);
if (EVEN(sts)) return;
gdb_ScopeLock {
np = hash_Search(NULL, gdbroot->nid_ht, &get->sender.nid);
pwr_Assert(np != NULL);
memset( &Attribute, 0, sizeof(Attribute));
ap = vol_ArefToAttribute(&sts, &Attribute, &mp->aref, gdb_mLo_owned, vol_mTrans_alias);
if (ap == NULL || ap->op == NULL) break;
p = vol_AttributeToAddress(&sts, ap);
} gdb_ScopeUnlock;
if (p != NULL) {
size = mp->aref.Size;
cid.pwr = mp->aref.Body;
cid.c.bix = 0; /* To get the class id. */
cp = hash_Search(&sts, gdbroot->cid_ht, &cid.pwr);
if (cp != NULL)
ndc_ConvertData(&sts, np, cp, &mp->aref, rmp->info, p, (pwr_tUInt32 *)&size, ndc_eOp_encode, mp->aref.Offset, 0);
}
rmp->aref = mp->aref;
rmp->sts = sts;
rmp->size = mp->aref.Size;
net_Reply(&sts, get, &put, 0);
}
gdb_sMountedOn *
cvolsm_AddMountedOn (
pwr_tStatus *sts,
pwr_tVolumeId vid,
gdb_sNode *np
)
{
gdb_sMountedOn *mop;
gdb_sVolume *vp;
gdb_AssumeLocked;
vp = hash_Search(sts, gdbroot->vid_ht, &vid);
if (vp == NULL) return NULL; /* !!! Todo !!! error handling. */
mop = (gdb_sMountedOn *) pool_Alloc(NULL, gdbroot->pool, sizeof(*mop));
mop->nid = np->nid;
mop->nr = pool_Reference(NULL, gdbroot->pool, np);
mop->vid = vid;
mop->vr = pool_Reference(NULL, gdbroot->pool, vp);
pool_QinsertSucc(NULL, gdbroot->pool, &mop->nodmo_ll, &np->nodmo_lh);
pool_QinsertSucc(NULL, gdbroot->pool, &mop->volmo_ll, &vp->u.n.volmo_lh);
return mop;
}
void
Count (
pwr_tBoolean receive,
pwr_tNodeId nid,
qcom_sType *type
)
{
pwr_tStatus sts;
gdb_sNode *np = hash_Search(&sts, gdbroot->nid_ht, &nid);
int msgtype = type->s;
if (type->b != net_cMsgClass)
return;
if (np == NULL)
return;
if ((msgtype >= net_eMsg_) || (msgtype <= net_eMsg__)) {
if (msgtype != net_eMsg_volumes7)
return;
msgtype = net_eMsg_volumes;
}
if (receive)
np->rxmsg[msgtype]++;
else
np->txmsg[msgtype]++;
}
static gdb_sNode *
node (
net_sMessage *mp
)
{
pwr_tStatus sts;
gdb_sNode *np;
if (mp->nid == pwr_cNNodeId) {
errh_Error("Message from pwr_cNNodeId received");
return NULL;
}
gdb_ScopeLock {
np = hash_Search(&sts, gdbroot->nid_ht, &mp->nid);
} gdb_ScopeUnlock;
if (np == NULL) {
errh_Error("Message about unknown node: (%s) received\n",
cdh_NodeIdToString(NULL, mp->nid, 0, 0));
return NULL;
}
return np;
}
/**
* Adds a remote class volume.
*/
void cvolcm_AddClassVolume(
pwr_tStatus* sts, gdb_sNode* np, const net_sGvolume* vp)
{
gdb_sCclassVolume *ccvp, *rp;
gdb_sVolume* cvp;
gdb_AssumeLocked;
pwr_Assert(vp != NULL);
ccvp = pool_Alloc(sts, gdbroot->pool, sizeof(*ccvp));
if (ccvp == NULL)
return;
ccvp->key.nid = vp->nid;
ccvp->key.vid = vp->vid;
ccvp->time = net_NetTimeToTime(&vp->time);
cvp = hash_Search(sts, gdbroot->vid_ht, &vp->vid);
if (cvp == NULL) /* This volume doesn't exist locally, but we may create it
later on */
ccvp->equalClasses = 0;
else {
pwr_tTime t = net_NetTimeToTime(&cvp->g.time);
ccvp->equalClasses = time_Acomp(&ccvp->time, &t) == 0 ? 1 : 0;
}
rp = hash_Insert(sts, gdbroot->ccvol_ht, ccvp);
if (rp == NULL) { /* This was previously a bugcheck but obviously can occur */
pool_Free(NULL, gdbroot->pool, ccvp);
return;
}
pool_QinsertPred(NULL, gdbroot->pool, &ccvp->ccvol_ll, &np->ccvol_lh);
}
void cvolcm_ExternVolumeFlush(gdb_sNode* np)
{
pool_sQlink* vl;
gdb_sVolume* vp;
pool_sQlink* ol;
gdb_sObject* op;
gdb_sMountServer* msp;
pwr_tStatus sts;
// Flush local node
gdb_AssumeLocked;
for (vl = pool_Qsucc(NULL, gdbroot->pool, &np->own_lh); vl != &np->own_lh;
vl = pool_Qsucc(NULL, gdbroot->pool, vl)) {
vp = pool_Qitem(vl, gdb_sVolume, l.own_ll);
pwr_Assert(vp->l.flags.b.isCached);
if (vp->l.flags.b.isCached) {
for (ol = pool_Qsucc(NULL, gdbroot->pool, &vp->l.obj_lh);
ol != &vp->l.obj_lh;
ol = pool_Qsucc(NULL, gdbroot->pool, &vp->l.obj_lh)) {
op = pool_Qitem(ol, gdb_sObject, l.obj_ll);
if (op->l.flags.b.isMountServer) {
msp = (gdb_sMountServer*)hash_Search(
&sts, gdbroot->ms_ht, &op->g.oid);
if (msp == NULL)
errh_Bugcheck(sts, "mount server inconsitency");
msp->msor = pool_cNRef;
pool_Qremove(NULL, gdbroot->pool, &msp->nodms_ll);
/* Todo !!! Clear alarm and blocklevel in all mount clients. */
}
cvol_FlushObject(op);
}
}
}
}
static void
flushNodes (void)
{
pwr_tStatus sts;
pwr_tNodeId nid;
qcom_sNode node;
gdb_sNode* np;
gdb_AssumeUnlocked;
for (nid = qcom_cNNid; qcom_NextNode(&sts, &node, nid); nid = node.nid) {
gdb_ScopeLock {
np = hash_Search(&sts, gdbroot->nid_ht, &node.nid);
} gdb_ScopeUnlock;
if (np == NULL)
continue;
if (np == gdbroot->my_node || np == gdbroot->no_node)
continue;
if (node.flags.b.connected) {
sendFlush(np);
#if 0
sendVolumes(np, pool_cNRef);
#endif
}
}
}
static san_sServer* addServer(
pwr_tStatus* sts, gdb_sNode* np, gdb_sObject* op, net_sSanEntry* ep)
{
san_sServer* sp;
sp = hash_Search(NULL, gdbroot->sans_ht, &ep->sid);
if (sp != NULL)
return sp;
sp = pool_Alloc(sts, gdbroot->pool, sizeof(san_sServer));
if (sp == NULL)
return NULL;
sp->sane = *ep;
sp = hash_Insert(sts, gdbroot->sans_ht, sp);
if (sp == NULL)
return NULL;
/* To do !!!! This is a pool leak !!!!!! */
if (gdbroot->is_tmon)
sp->op = op;
pool_QinsertPred(NULL, gdbroot->pool, &sp->sansAct_ll, &np->sansAct_lh);
sp->flags.b.sansAct = 1;
np->sansAct_lc++;
np->sans_gen++;
return checkServer(np, sp);
}
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;
}
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;
}
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;
}
static void lockMountServers(gdb_sNode* np)
{
pwr_tStatus sts;
pool_sQlink* msl;
pool_sQlink* vl;
gdb_sVolume* vp;
gdb_sMountServer* msp;
gdb_sObject* op;
gdb_AssumeLocked;
for (vl = pool_Qsucc(NULL, gdbroot->pool, &np->own_lh); vl != &np->own_lh;
vl = pool_Qsucc(NULL, gdbroot->pool, vl)) {
vp = pool_Qitem(vl, gdb_sVolume, l.own_ll);
if (vl->self == vl->flink) {
/* Connection lost and volume removed from own list */
errh_Error("Volume not owned any more, %s", vp->g.name.orig);
return;
}
if (!vp->l.flags.b.isConnected) {
/* !!! Todo !!! How do we make this known ? */
errh_Error("Volume not connected, %s", vp->g.name.orig);
continue;
}
for (msl = pool_Qsucc(NULL, gdbroot->pool, &vp->l.volms_lh);
msl != &vp->l.volms_lh; msl = pool_Qsucc(NULL, gdbroot->pool, msl)) {
msp = pool_Qitem(msl, gdb_sMountServer, volms_ll);
op = hash_Search(&sts, gdbroot->oid_ht, &msp->oid);
if (op == NULL) {
op = cvolc_OidToObject(
&sts, vp, msp->oid, vol_mTrans_none, cvol_eHint_none);
if (op == NULL) {
errh_Error("Can't fetch the mount server's object, %s",
cdh_ObjidToString(msp->oid, 0));
/* !!! Todo !!! How do we make this error known ? */
continue;
}
}
msp->msor = pool_ItemReference(NULL, gdbroot->pool, op);
op->l.flags.b.isMountServer = 1;
if (msp->nodms_ll.self == msp->nodms_ll.flink
&& msp->nodms_ll.self == msp->nodms_ll.blink)
pool_QinsertPred(NULL, gdbroot->pool, &msp->nodms_ll, &np->nodms_lh);
/* if (0)
errh_Info("Locking object %s", op->g.f.name.orig); */
cvolc_LockObject(&sts, op);
}
}
}
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;
}
}
void cvolcm_CreateObject(qcom_sGet* get)
{
pwr_tStatus sts;
gdb_sObject* op;
gdb_sObject* pop;
gdb_sObject* sop;
pwr_tObjid soid;
net_sCreateObject* cop = (net_sCreateObject*)get->data;
gdb_AssumeUnlocked;
gdb_ScopeLock
{
op = hash_Search(&sts, gdbroot->oid_ht, &cop->notify.oid);
if (op != NULL)
errh_Bugcheck(GDH__WEIRD, "cvolcm_CreateObject: object already exists");
pop = hash_Search(&sts, gdbroot->oid_ht, &cop->par.oid);
if (pop == NULL)
break;
pop->g.soid = cop->par.soid;
pop->g.flags.b.isParent = 1;
soid = cop->par.oid;
soid.oix = cop->sib.blink;
sop = hash_Search(&sts, gdbroot->oid_ht, &soid);
if (sop != NULL)
sop->g.sib.flink = cop->sib.newflink;
soid.oix = cop->sib.flink;
sop = hash_Search(&sts, gdbroot->oid_ht, &soid);
if (sop != NULL)
sop->g.sib.blink = cop->sib.newblink;
}
gdb_ScopeUnlock;
}
static pwr_tBoolean
ConvertPut (
pwr_tStatus *sts,
qcom_sQid *qid,
qcom_sPut *put,
void *data
)
{
pwr_tStatus lsts;
XDR xdrs;
qdb_sNode *np;
tFuncXdr fXdr;
pwr_tNid nid;
if (put->type.b != net_cMsgClass)
pwr_Return(FALSE, sts, NET__XDRFAILED);
// Remove sid
nid = qid->nid & 0xffffff;
np = hash_Search(&lsts, &qdb->nid_ht, &nid);
if (np == NULL) pwr_Return(FALSE, sts, lsts);
/* 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.
*/
if (put->type.s == (qcom_eStype)net_eMsg_volumes7) {
put->type.s = net_eMsg_volumes;
fXdr = xdr_net_sVolumes7;
}
else {
if ((int)put->type.s <= (int)net_eMsg__ || (int)put->type.s >= (int)net_eMsg_)
pwr_Return(FALSE, sts, NET__NOSUCHQCOMSUBT);
fXdr = func_xdr[(int)put->type.s];
}
if (np == qdb->my_node || np->bo == qdb->my_node->bo) {
if (put->data != data) memcpy(put->data, data, put->size);
pwr_Return(TRUE, sts, NET__SUCCESS);
}
xdrmem_create(&xdrs, (char *) put->data, put->size, XDR_ENCODE);
if(!(fXdr)(&xdrs, (char *) data))
pwr_Return(FALSE, sts, NET__XDRFAILED);
pwr_Return(TRUE, sts, NET__SUCCESS);
}
void
cvolcm_FlushVolume (
pwr_tStatus *sts,
gdb_sVolume *vp
)
{
pool_sQlink *ol;
gdb_sObject *op;
gdb_sMountServer *msp;
gdb_AssumeLocked;
for (
ol = pool_Qsucc(NULL, gdbroot->pool, &vp->l.obj_lh);
ol != &vp->l.obj_lh;
ol = pool_Qsucc(NULL, gdbroot->pool, &vp->l.obj_lh)
) {
op = pool_Qitem(ol, gdb_sObject, l.obj_ll);
if (op->l.flags.b.isMountServer) {
msp = hash_Search(sts, gdbroot->ms_ht, &op->g.oid);
if (msp == NULL) errh_Bugcheck(*sts, "mount server inconsitency");
msp->msor = pool_cNRef;
pool_Qremove(NULL, gdbroot->pool, &msp->nodms_ll);
/* Todo !!! Clear alarm and blocklevel in all mount clients. */
}
cvol_FlushObject(op);
}
pwr_Assert(vp->l.flags.b.inOwnList);
pool_Qremove(NULL, gdbroot->pool, &vp->l.own_ll);
vp->l.flags.b.inOwnList = 0;
vp->g.nid = pwr_cNNodeId;
pwr_Assert(pool_QisEmpty(NULL, gdbroot->pool, &vp->u.c.cacheLock.lh));
pwr_Assert(vp->u.c.cacheLock.lc == 0);
pwr_Assert(pool_QisEmpty(NULL, gdbroot->pool, &vp->u.c.cacheVol.lh));
pwr_Assert(vp->u.c.cacheVol.lc == 0);
vp->l.flags.b.isConnected = 0;
vp->l.flags.b.isCached = 0;
vp->l.flags.b.netCached = 0;
vp->l.flags.b.remote = 0;
}
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;
}
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;
}
void
dl_Cancel (
pwr_tStatus *sts,
pwr_tDlid dlid
)
{
dl_sLink *dp;
gdb_sObject *op;
cdh_uRefId rid;
gdb_AssumeLocked;
rid.pwr = dlid;
if (rid.r.vid_3 != cdh_eVid3_dlid) {
pwr_Status(sts, GDH__DLID);
return;
}
dp = hash_Search(sts, gdbroot->subc_ht, &dlid);
if (dp == NULL) {
pwr_Status(sts, GDH__DLID);
return;
}
dp = hash_Remove(sts, gdbroot->subc_ht, dp);
if (dp == NULL) errh_Bugcheck(GDH__WEIRD, "hash_Remove");
pool_Qremove(NULL, gdbroot->pool, &dp->dl_ll);
gdbroot->db->dl_lc--;
op = pool_Address(NULL, gdbroot->pool, dp->opr);
if (op == NULL) errh_Bugcheck(GDH__WEIRD, "direct link inconsitency");
gdb_UnlockObject(sts, op);
pool_Free(NULL, gdbroot->pool, dp);
return;
}
static void
deleteClient (
sub_sClient *cp
)
{
pwr_tStatus sts;
gdb_sNode *np;
gdb_AssumeLocked;
cancelTimeoutWatch(cp);
subc_RemoveFromMessage(cp);
hash_Remove(&sts, gdbroot->subc_ht, cp);
if (EVEN(sts)) errh_Bugcheck(sts, "remove client from hash table");
np = hash_Search(&sts, gdbroot->nid_ht, &cp->nid);
if (np == NULL) errh_Bugcheck(sts, "node not found");
pool_Qremove(&sts, gdbroot->pool, &cp->subc_ll);
np->subc_lc--;
if (cp->userdata != pool_cNRef) {
pool_FreeReference(NULL, gdbroot->rtdb, cp->userdata);
}
if (cp->cclass != pool_cNRef) {
gdb_sCclass *ccp;
ccp = pool_Address(NULL, gdbroot->pool, cp->cclass);
if (ccp == NULL) errh_Bugcheck(GDH__WEIRD, "cached class address");
cmvolc_UnlockClass(NULL, ccp);
cp->cclass = pool_cNRef;
}
pool_Free(NULL, gdbroot->pool, cp);
}
static gdb_sObject *
loadObject (
pwr_tStatus *sts,
gdb_sVolume *vp,
char *name,
pwr_tObjid oid,
pwr_tClassId cid,
int size,
pwr_tObjid poid,
pwr_tBitMask flags,
pwr_tObjid soid
)
{
gdb_sObject *op;
pwr_Assert(hash_Search(NULL, gdbroot->oid_ht, &oid) == NULL);
op = gdb_AddObject(sts, name, oid, cid, size, poid, flags, soid);
if (op == NULL) return NULL;
op->u.n.flags.b.systemCreated = 1;
return vol_LinkObject(sts, vp, op, vol_mLink_load);
}
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;
}
void
cvolsm_OidToObject (
qcom_sGet *get
)
{
pwr_tStatus sts;
gdb_sObject *op;
net_sOidToObject *mp = get->data;
gdb_AssumeUnlocked;
gdb_ScopeLock {
op = hash_Search(&sts, gdbroot->oid_ht, &mp->oid);
if (op == NULL || !op->l.flags.b.isOwned) {
respondError(get, pwr_cNObjid, GDH__NOSUCHOBJ);
} else {
respondObject(get, op, mp->lcount, mp->rcount);
}
} gdb_ScopeUnlock;
}
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);
}
static void nodeUp(net_sNodeUp* mp)
{
pwr_tStatus sts;
gdb_sNode* np;
np = hash_Search(&sts, gdbroot->nid_ht, &mp->nid);
if (np == NULL) {
errh_Error("Message about unknown node: (%s) received\n",
cdh_NodeIdToString(NULL, mp->nid, 0, 0));
return;
}
errh_Info("Up, link to node %s (%s)", np->name,
cdh_NodeIdToString(NULL, mp->nid, 0, 0));
gdb_ScopeLock
{
lockMountServers(np);
subc_ActivateList(&np->subc_lh, pwr_cNObjid);
subc_ActivateList(&gdbroot->no_node->subc_lh, pwr_cNObjid);
sanc_SubscribeMountServers(&sts, np);
}
gdb_ScopeUnlock;
}
/**
* Adds a remote class volume.
*/
void
cvolcm_AddClassVolume(
pwr_tStatus *sts,
gdb_sNode *np,
const net_sGvolume *vp
)
{
gdb_sCclassVolume *ccvp;
gdb_sVolume *cvp;
gdb_AssumeLocked;
pwr_Assert(vp != NULL);
ccvp = pool_Alloc(sts, gdbroot->pool, sizeof(*ccvp));
if (ccvp == NULL) return;
ccvp->key.nid = vp->nid;
ccvp->key.vid = vp->vid;
ccvp->time = net_NetTimeToTime(&vp->time);
cvp = hash_Search(sts, gdbroot->vid_ht, &vp->vid);
if (cvp == NULL) /* This volume doesn't exist locally, but we may create it later on */
ccvp->equalClasses = 0;
else {
pwr_tTime t = net_NetTimeToTime( &cvp->g.time);
ccvp->equalClasses = time_Acomp(&ccvp->time, &t) == 0 ? 1 : 0;
}
ccvp = hash_Insert(sts, gdbroot->ccvol_ht, ccvp);
if (ccvp == NULL) errh_Bugcheck(GDH__WEIRD, "adding cached class volume");
pool_QinsertPred(NULL, gdbroot->pool, &ccvp->ccvol_ll, &np->ccvol_lh);
}
