pwr_tStatus
wb_dbs::writeSectOid()
{
sOentry *oep;
char o[dbs_dAlign(sizeof(dbs_sOid))];
dbs_sOid *op = (dbs_sOid*)o;
if (m_sect[dbs_eSect_oid].size == 0)
return LDH__SUCCESS;
if (fseek(m_fp, m_sect[dbs_eSect_oid].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
memset(o, 0, sizeof(o));
oep = (sOentry*)tree_Minimum(NULL, m_oid_th);
while (oep != NULL) {
op->oid = oep->o.oid;
op->ref = oep->ref;
if (fwrite(o, sizeof(o), 1, m_fp) < 1)
return LDH__FILEWRITE;
oep = (sOentry*)tree_Successor(NULL, m_oid_th, (tree_sNode*)oep);
}
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_oid].offset + m_sect[dbs_eSect_oid].size));
return LDH__SUCCESS;
}
pwr_tStatus
wb_dbs::writeSectName()
{
sNentry *nep;
if (m_sect[dbs_eSect_name].size == 0)
return LDH__SUCCESS;
if (fseek(m_fp, m_sect[dbs_eSect_name].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
nep = (sNentry*)tree_Minimum(NULL, m_name_th);
while (nep != NULL) {
nep->n.ref = nep->oep->ref;
if (fwrite(&nep->n, dbs_dAlign(sizeof(nep->n)), 1, m_fp) < 1)
return LDH__FILEWRITE;
nep = (sNentry*)tree_Successor(NULL, m_name_th, (tree_sNode*)nep);
}
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_name].offset + m_sect[dbs_eSect_name].size));
return LDH__SUCCESS;
}
pwr_tStatus
wb_dbs::writeSectVolref(size_t size)
{
pwr_tStatus sts;
if (fseek(m_fp, m_sect[dbs_eSect_volref].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
// Search trhough all found volumes and get their volrefs
sVentry *vep;
vep = (sVentry*)tree_Minimum(&sts, m_vol_th);
while (vep) {
if (vep->env.file.cookie == 0) {
printf(" volume not found: %d\n", vep->v.vid);
} else {
vep->v.offset = dbs_dAlign(size);
size += vep->v.size = dbs_dAlign(vep->v.size);
char v[dbs_dAlign(sizeof(dbs_sVolRef))];
dbs_sVolRef *vp = (dbs_sVolRef*)v;
*vp = vep->v;
if (fwrite(v, sizeof(v), 1, m_fp) < 1)
return LDH__FILEWRITE;
}
vep = (sVentry*)tree_Successor(&sts, m_vol_th, vep);
}
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_volref].offset + m_sect[dbs_eSect_volref].size));
return LDH__SUCCESS;
}
pwr_tStatus
wb_dbs::writeReferencedVolumes()
{
pwr_tStatus sts;
// Search trhough all found volumes and get their volrefs
sVentry *vep;
vep = (sVentry*)tree_Minimum(&sts, m_vol_th);
while (vep) {
if (vep->env.file.cookie == 0) {
printf(" volume not found: %d\n", vep->v.vid);
} else {
if (fseek(m_fp, vep->v.offset, SEEK_SET) != 0)
return LDH__FILEPOS;
if (fseek(vep->env.f, 0, SEEK_SET) != 0)
return LDH__FILEPOS;
sts = copyFile(vep->env.f, m_fp, vep->env.file.size);
if (EVEN(sts))
return LDH__FILEWRITE;
assert(ftell(m_fp) == (long)(vep->v.offset + vep->env.file.size));
}
vep = (sVentry*)tree_Successor(&sts, m_vol_th, vep);
}
return LDH__SUCCESS;
}
void
wb_dbs::buildSectName()
{
sNentry *nep;
/* allocate space for all name entries in name section*/
nep = (sNentry*)tree_Minimum(NULL, m_name_th);
while (nep != NULL) {
nep->ref = dbs_dMakeRef(dbs_eSect_name, m_sect[dbs_eSect_name].size);
m_sect[dbs_eSect_name].size += dbs_dAlign(sizeof(dbs_sName));
m_nNameObjects++;
nep = (sNentry*)tree_Successor(NULL, m_name_th, (tree_sNode*)nep);
}
nep = (sNentry*)tree_Minimum(NULL, m_name_th);
if (nep != NULL) {
m_volume.name_bt.start = nep->ref;
nep = (sNentry*)tree_Maximum(NULL, m_name_th);
m_volume.name_bt.end = nep->ref;
m_volume.name_bt.rsize = dbs_dAlign(sizeof(dbs_sName));
}
}
main () {
pwr_tStatus sts;
tree_sTable *nodes;
qini_sNode *nep;
qini_sNode *me = NULL;
char *s;
FILE *f;
char my_name[80];
int len = sizeof(my_name);
int errors;
gethostname(my_name, len);
if ((s = strchr(my_name, '.')) != NULL)
*s = '\0';
printf("-- Starting QCOM on node: %s\n", my_name);
f = fopen("sys$login:ld_hosts_001.dat", "r");
if (f == NULL) {
perror("sys$login:ld_hosts_001.dat");
exit(1);
}
nodes = tree_CreateTable(sizeof(pwr_tNodeId), offsetof(qini_sNode, nid),
sizeof(qini_sNode), 10, tree_eComp_nid, NULL);
errors = qini_ParseFile(f, nodes);
if (errors != 0) {
printf("** %d errors where found, qcom will not be started!\n", errors);
exit(1);
}
for (
nep = tree_Minimum(nodes);
nep != NULL;
nep = tree_Successor(nodes, nep)
) {
printf("%s %d %d %d %d\n", nep->name, nep->nid, nep->naddr, nep->port,
nep->connect);
if (strcmp(my_name, nep->name) == 0) {
printf("-- My nid is: %d\n", nep->nid);
me = nep;
}
}
if (me == NULL) {
printf("** Could not find myself!\n");
exit(1);
}
qini_BuildDb(&sts, nodes, me, NULL, 1);
qdb->g->log.m = 7;
sleep(20000000);
}
void
wb_dbs::buildSectOid()
{
sOentry *oep;
oep = (sOentry*)tree_Minimum(NULL, m_oid_th);
while (oep != NULL) {
oep->oidref = dbs_dMakeRef(dbs_eSect_oid, m_sect[dbs_eSect_oid].size);
m_sect[dbs_eSect_oid].size += dbs_dAlign(sizeof(dbs_sOid));
oep = (sOentry*)tree_Successor(NULL, m_oid_th, (tree_sNode*)oep);
}
oep = (sOentry*)tree_Minimum(NULL, m_oid_th);
if (oep != NULL) {
m_volume.oid_bt.start = oep->oidref;
oep = (sOentry*)tree_Maximum(NULL, m_oid_th);
m_volume.oid_bt.end = oep->oidref;
m_volume.oid_bt.rsize = dbs_dAlign(sizeof(dbs_sOid));
}
}
void
wb_dbs::buildSectClass()
{
pwr_tStatus sts;
sCentry *cep;
dbs_tRef ref;
dbs_sQlink *o_lh;
dbs_sQlink *o_ll;
sOentry *oep;
/* allocate space for all name entries in name section*/
cep = (sCentry*)tree_Minimum(NULL, m_class_th);
while (cep != NULL) {
ref = cep->ref = dbs_dMakeRef(dbs_eSect_class, m_sect[dbs_eSect_class].size);
m_sect[dbs_eSect_class].size += dbs_dAlign(sizeof(dbs_sClass));
dbs_Qinit(&sts, &cep->c.o_lh, ref + offsetof(dbs_sClass, o_lh));
// Link all object instances to this class
o_lh = o_ll = &cep->c.o_lh;
for (oep = cep->o_lh; oep != 0; oep = oep->o_ll) {
cep->c.nObjects++;
m_nClassObjects++;
dbs_Qinsert(&sts, o_ll, &oep->o.o_ll, o_lh);
o_ll = &oep->o.o_ll;
}
cep = (sCentry*)tree_Successor(NULL, m_class_th, (tree_sNode*)cep);
}
cep = (sCentry*)tree_Minimum(NULL, m_class_th);
if (cep != NULL) {
m_volume.class_bt.start = cep->ref;
cep = (sCentry*)tree_Maximum(NULL, m_class_th);
m_volume.class_bt.end = cep->ref;
m_volume.class_bt.rsize = dbs_dAlign(sizeof(dbs_sClass));
}
}
pwr_tStatus
wb_dbs::writeSectClass()
{
sCentry *cep;
if (m_sect[dbs_eSect_class].size == 0)
return LDH__SUCCESS;
if (fseek(m_fp, m_sect[dbs_eSect_class].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
cep = (sCentry*)tree_Minimum(NULL, m_class_th);
while (cep != NULL) {
if (fwrite(&cep->c, dbs_dAlign(sizeof(cep->c)), 1, m_fp) < 1)
return LDH__FILEWRITE;
cep = (sCentry*)tree_Successor(NULL, m_class_th, (tree_sNode*)cep);
}
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_class].offset + m_sect[dbs_eSect_class].size));
return LDH__SUCCESS;
}
int
qini_ParseFile (
FILE *f,
tree_sTable *ntp,
int *warnings,
int *errors,
int *fatals
)
{
pwr_tStatus sts = 1;
int n;
char *s;
char buffer[256];
int error = 0;
char name[80];
char s_nid[80];
char s_naddr[80];
char s_port[80];
char s_connection[80];
char s_min_resend_time[80];
char s_max_resend_time[80];
pwr_tNodeId nid;
struct in_addr naddr;
qini_sNode *nep;
struct arpreq arpreq;
while ((s = fgets(buffer, sizeof(buffer) - 1, f)) != NULL) {
if (*s == '#' || *s == '!') {
s++;
continue;
}
n = sscanf(s, "%s %s %s %s %s %s %s", name, s_nid, s_naddr, s_port, s_connection,
s_min_resend_time, s_max_resend_time);
if (n < 3) {
errh_Error("error in line, <wrong number of arguments>, skip to next line.\n>> %s", s);
(*errors)++;
continue;
}
sts = cdh_StringToVolumeId(s_nid, (pwr_tVolumeId *)&nid);
if (EVEN(sts)) {
errh_Error("error in line, <node identity>, skip to next line.\n>> %s", s);
(*errors)++;
continue;
}
sts = net_StringToAddr( s_naddr, &naddr);
if ( EVEN(sts)) {
errh_Error("error in line, <network address>, skip to next line.\n>> %s", s);
(*errors)++;
continue;
}
#if 0
naddr.s_addr = inet_network(s_naddr);
#if defined(OS_VMS)
if (naddr.s_addr == (in_addr_t)-1) {
#else
if (naddr.s_addr == (unsigned int)-1) {
#endif
/* Try name instead */
struct addrinfo hints;
struct addrinfo *res;
int err;
memset((void*)&hints, 0, sizeof(hints));
hints.ai_socktype = SOCK_STREAM;
err = getaddrinfo(s_naddr, 0, &hints, &res);
if ( err < 0) {
errh_Error("error in line, <network address>, skip to next line.\n>> %s", s);
(*errors)++;
continue;
}
switch ( res->ai_family) {
case AF_INET:
// memcpy( &naddr.s_addr, (char *)&res->ai_addr->sa_data + 2, 4);
memcpy( &naddr.s_addr, &((struct sock_addr_in *)res->ai_addr)->sin_addr, 4);
naddr.s_addr = ntohl( naddr.s_addr);
break;
case AF_INET6:
break;
}
freeaddrinfo( res);
}
#endif
nep = tree_Find(&sts, ntp, &nid);
if (nep != NULL) {
errh_Warning("node is allready defined: %s, skip to next line", s);
(*warnings)++;
continue;
} else {
nep = tree_Insert(&sts, ntp, &nid);
}
strcpy(nep->name, name);
nep->naddr.s_addr = htonl(naddr.s_addr);
if (n > 3) nep->port = htons(atoi(s_port));
if (n > 4) nep->connection = atoi(s_connection);
if (n > 5) nep->min_resend_time = atoi(s_min_resend_time);
if (n > 6) nep->max_resend_time = atoi(s_max_resend_time);
memset(&arpreq, 0, sizeof(arpreq));
memcpy(&arpreq.arp_pa.sa_data, &naddr, sizeof(naddr));
inet_GetArpEntry(&sts, 0, &arpreq);
}
return error;
}
pwr_tBoolean
qini_BuildDb (
pwr_tStatus *sts,
tree_sTable *nodes,
qini_sNode *me,
#if 0 /* change when new class NetConfig is deined */
pwr_sNetConfig *cp,
#else
void *cp,
#endif
qcom_tBus bus
)
{
qdb_sInit init;
qdb_sNode *np;
qini_sNode *nep;
void *p;
qdb_sAppl *ap;
memset(&init, 0, sizeof(init));
init.nid = me->nid;
init.bus = bus;
init.nodes = nodes->nNode;
#if 0 /* change when new class NetConfig is deined */
init.queues = cp->Queues;
init.applications = cp->Applications;
init.sbufs = cp->SmallCount;
init.mbufs = cp->MediumCount;
init.lbufs = cp->LargeCount;
init.size_sbuf = cp->SmallSize;
init.size_mbuf = cp->MediumSize;
init.size_lbuf = cp->LargeSize;
#endif
p = qdb_CreateDb(sts, &init);
if (p == NULL) return NO;
qdb_ScopeLock {
for (nep = tree_Minimum(sts, nodes); nep != NULL; nep = tree_Successor(sts, nodes, nep)) {
np = addNode(nep);
}
ap = qdb_AddAppl(NULL, YES);
qdb->exportque = addQueue(NULL, qdb_cIexport, "export", qdb_eQue_private, qdb_mQue_system);
addQueue(ap, qcom_cInetEvent, "netEvent", qdb_eQue_forward, qdb_mQue_system);
addQueue(ap, qcom_cIapplEvent, "applEvent", qdb_eQue_forward, qdb_mQue_system);
addQueue(ap, qcom_cImhAllHandlers, "allHandlers", qdb_eQue_forward, qdb_mQue_broadcast);
addQueue(ap, qcom_cImhAllOutunits, "allOutunits", qdb_eQue_forward, qdb_mQue_broadcast);
addQueue(ap, qcom_cIhdServer, "hdServer", qdb_eQue_forward, qdb_mQue_broadcast);
addQueue(ap, qcom_cIhdClient, "hdClient", qdb_eQue_forward, qdb_mQue_broadcast);
#if !defined OS_CYGWIN
addQueue(NULL, qcom_cInacp, "nacp", qdb_eQue_private, qdb_mQue_system);
#endif
addQueue(ap, qcom_cIini, "ini", qdb_eQue_forward, qdb_mQue_system | qdb_mQue_event);
} qdb_ScopeUnlock;
return (YES);
}
void wb_crrgen::write(pwr_tStatus* rsts)
{
pwr_tStatus sts;
char type_char = '\0';
pwr_tAttrRef prev_target;
pwr_tFileName fname;
memset(&prev_target, 0, sizeof(prev_target));
sprintf(fname, "$pwrp_load/rtt_crr_%s.dat", vldh_VolumeIdToStr(m_sp->vid()));
dcli_translate_filename(fname, fname);
std::ofstream fps(fname);
if (!fps) {
*rsts = LDH__FILEOPEN;
return;
}
sCrr* crr = (sCrr*)tree_Minimum(&sts, m_signal_th);
while (crr) {
wb_attribute a_target = m_sp->attribute(&crr->key.target);
wb_object o = m_sp->object(crr->key.reference.Objid);
if (!a_target) {
if (crr->key.target.Objid.vid == crr->key.reference.Objid.vid)
printf("** Undefined reference in: %s\n",
o.longName().name(
cdh_mName_volume | cdh_mName_path | cdh_mName_attribute));
else
printf("-- External reference in: %s\n",
o.longName().name(
cdh_mName_volume | cdh_mName_path | cdh_mName_attribute));
crr = (sCrr*)tree_Successor(&sts, m_signal_th, crr);
continue;
}
wb_cdef cdef = m_sp->cdef(o.cid());
if (!(crr->key.target.Objid.vid == prev_target.Objid.vid
&& crr->key.target.Objid.oix == prev_target.Objid.oix
&& crr->key.target.Offset == prev_target.Offset
&& crr->key.target.Size == prev_target.Size))
fps << a_target.longName().name(
cdh_mName_volume | cdh_mName_path | cdh_mName_attribute)
<< '\n';
switch (crr->key.type) {
case crrgen_eType_Write:
type_char = 'W';
break;
case crrgen_eType_Read:
type_char = 'R';
break;
case crrgen_eType_Ref:
type_char = '>';
break;
default:;
}
fps << " " << type_char << " "
<< o.longName().name(cdh_mName_path | cdh_mName_attribute) << " "
<< cdef.name() << '\n';
memcpy(&prev_target, &crr->key.target, sizeof(prev_target));
crr = (sCrr*)tree_Successor(&sts, m_signal_th, crr);
}
fps.close();
// Signal list
sprintf(fname, "$pwrp_load/rtt_crrs_%s.dat", vldh_VolumeIdToStr(m_sp->vid()));
dcli_translate_filename(fname, fname);
std::ofstream fpsl(fname);
if (!fps) {
*rsts = LDH__FILEOPEN;
return;
}
pwr_tCid siglist[] = { pwr_cClass_Di, pwr_cClass_Do, pwr_cClass_Dv,
pwr_cClass_Ai, pwr_cClass_Ao, pwr_cClass_Av, pwr_cClass_Ii, pwr_cClass_Io,
pwr_cClass_Iv, pwr_cClass_Co, pwr_cClass_Sv, pwr_cClass_ATv,
pwr_cClass_DTv };
for (int i = 0; i < int(sizeof(siglist) / sizeof(siglist[0])); i++) {
pwr_tAttrRef aref;
for (m_sp->aref(siglist[i], &aref); m_sp->oddSts();
m_sp->nextAref(siglist[i], &aref, &aref)) {
wb_object o = m_sp->object(aref.Objid);
if (!o)
continue;
// Skip if in LibHier
bool in_libhier = false;
for (wb_object p = o.parent(); p; p = p.parent()) {
if (p.cid() == pwr_eClass_LibHier) {
in_libhier = true;
break;
}
}
if (in_libhier)
continue;
wb_attribute a = m_sp->attribute(&aref);
if (!a)
continue;
fpsl << a.longName().name(
cdh_mName_path | cdh_mName_object | cdh_mName_attribute)
<< '\n';
}
}
fpsl.close();
sprintf(fname, "$pwrp_load/rtt_crro_%s.dat", vldh_VolumeIdToStr(m_sp->vid()));
dcli_translate_filename(fname, fname);
std::ofstream fpo(fname);
if (!fpo) {
*rsts = LDH__FILEOPEN;
return;
}
memset(&prev_target, 0, sizeof(prev_target));
crr = (sCrr*)tree_Minimum(&sts, m_object_th);
while (crr) {
wb_attribute a_target = m_sp->attribute(&crr->key.target);
wb_object o = m_sp->object(crr->key.reference.Objid);
if (!a_target) {
if (crr->key.target.Objid.vid == crr->key.reference.Objid.vid)
printf("** Undefined reference in: %s\n",
o.longName().name(
cdh_mName_volume | cdh_mName_path | cdh_mName_attribute));
else
printf("-- External reference in: %s\n",
o.longName().name(
cdh_mName_volume | cdh_mName_path | cdh_mName_attribute));
crr = (sCrr*)tree_Successor(&sts, m_object_th, crr);
continue;
}
wb_cdef cdef = m_sp->cdef(o.cid());
if (!(crr->key.target.Objid.vid == prev_target.Objid.vid
&& crr->key.target.Objid.oix == prev_target.Objid.oix
&& crr->key.target.Offset == prev_target.Offset
&& crr->key.target.Size == prev_target.Size))
fpo << a_target.longName().name(
cdh_mName_volume | cdh_mName_path | cdh_mName_attribute)
<< '\n';
switch (crr->key.type) {
case crrgen_eType_Write:
type_char = 'W';
break;
case crrgen_eType_Read:
type_char = 'R';
break;
case crrgen_eType_Ref:
type_char = '>';
break;
default:;
}
fpo << " " << type_char << " "
<< o.longName().name(cdh_mName_path | cdh_mName_attribute) << " "
<< cdef.name() << '\n';
memcpy(&prev_target, &crr->key.target, sizeof(prev_target));
crr = (sCrr*)tree_Successor(&sts, m_object_th, crr);
}
fpo.close();
*rsts = 1;
}
int main( int argc, char *argv[])
{
pwr_tStatus sts;
if (argc <= 1) exit(0);
printf("open database> %s\n", argv[1]);
oid_th = tree_CreateTable(&sts, sizeof(pwr_tOid), offsetof(sOentry, o.oid), sizeof(sOentry), 1000, tree_Comp_oid);
try {
wb_db *db = new wb_db();
db->open(argv[1]);
check(db);
db->close();
}
catch (DbException &e) {
printf("Exception: %s\n", e.what());
}
for (sOentry *oep = (sOentry *)tree_Minimum(&sts, oid_th); oep != NULL; oep = (sOentry *)tree_Successor(&sts, oid_th, oep)) {
if (!oep->flags.b.inOhead) printf("[%d] not in ohead\n", oep->o.oid.oix);
if (!oep->flags.b.inName) printf("[%d] not in name\n", oep->o.oid.oix);
if (!oep->flags.b.inClass) printf("[%d] not in class\n", oep->o.oid.oix);
if (!oep->flags.b.inRbody && oep->o.body[0].size != 0) printf("[%d] not in rbody\n", oep->o.oid.oix);
if (!oep->flags.b.inDbody && oep->o.body[1].size != 0) printf("[%d] not in dbody\n", oep->o.oid.oix);
//if (oep->flags.b.inRbody && oep->o.body[0].size == 0) printf("[%d] in rbody\n", oep->o.oid.oix);
//if (oep->flags.b.inDbody && oep->o.body[1].size == 0) printf("[%d] in dbody\n", oep->o.oid.oix);
if (!oep->flags.b.pOk) {
#if 1
if (oep->poep != NULL && oep->poep->flags.b.inOhead) {
oep->flags.b.pOk = 1;
} else {
printf("[%d] pNok %s\n", oep->o.oid.oix, oep->o.name);
}
#else
printf("[%d] pNok %s\n", oep->o.oid.oix, oep->o.name);
#endif
}
if (!oep->flags.b.bOk) printf("[%d] bNok\n", oep->o.oid.oix);
if (!oep->flags.b.aOk) printf("[%d] aNok\n", oep->o.oid.oix);
if (!oep->flags.b.fOk) printf("[%d] fNok\n", oep->o.oid.oix);
if (!oep->flags.b.lOk) printf("[%d] lNok\n", oep->o.oid.oix);
}
}
void
subc_CancelList (
pool_sQlink *lh
)
{
qcom_sQid tgt;
#if 0
tree_sTable *remove;
sRemove *rep;
gdb_sNode *np;
#endif
pwr_tNodeId nid;
pwr_tSubid sid;
sub_sClient *cp;
pool_sQlink *cl;
gdb_AssumeLocked;
tgt.qix = net_cProcHandler;
#if 0
remove = tree_CreateTable(sizeof(pwr_tNodeId), offsetof(sRemove, nid),
sizeof(sRemove), 10, tree_eComp_nid, NULL);
#endif
for (cl = pool_Qsucc(NULL, gdbroot->pool, lh); cl != lh;) {
cp = pool_Qitem(cl, sub_sClient, subc_ll);
cl = pool_Qsucc(NULL, gdbroot->pool, cl);
cancelTimeoutWatch(cp);
/* Get rid of the client, make it invalid for other references
that might happen when we are unlocked
But first: save nid and sid which we need further down. */
nid = cp->nid;
sid = cp->sid;
deleteClient(cp);
#if 0
if (nid != pwr_cNNodeId) {
rep = tree_Insert(remove, &nid);
if (rep == NULL) errh_Bugcheck(GDH__WEIRD, "");
if (rep->msg == NULL) {
np = hash_Search(NULL, gdbroot->nid_ht, &nid);
if (np == NULL) errh_Bugcheck(GDH__WEIRD, "");
rep->cnt = net_cSubMaxRemove;
rep->msg = malloc(sizeof(net_sSubRemove) + sizeof(rep->msg->sid[0]) * rep->cnt);
rep->msg->count = 0;
}
rep->msg->sid[rep->msg->count++] = sid;
if (rep->msg->count >= net_cSubMaxRemove) {
tgt.nid = rep->nid;
gdb_Unlock;
net_Put(NULL, &tgt, rep->msg, net_eMsg_subRemove, 0, pwr_Offset(rep->msg, sid[rep->msg->count]), 0);
gdb_Lock;
rep->msg->count = 0;
}
} /* Remote */
#endif
} /* For all clients in list */
#if 0
/* Now send all unsent messages. */
gdb_Unlock;
for (rep = tree_Minimum(remove); rep != NULL; rep = tree_Successor(remove, rep)) {
if (rep->msg != NULL) {
if (rep->msg->count > 0) {
tgt.nid = rep->nid;
net_Put(NULL, &tgt, rep->msg, net_eMsg_subRemove, 0, pwr_Offset(rep->msg, sid[rep->msg->count]), 0);
}
free(rep->msg);
}
}
gdb_Lock;
tree_DeleteTable(remove);
#endif
}
void
subc_ActivateList (
pool_sQlink *lh,
pwr_tObjid oid
)
{
pwr_tStatus sts;
tree_sTable *add;
#if 0
tree_sTable *remove;
sRemove *rep;
#endif
net_sSubSpec *specp;
qcom_sQid tgt;
pool_sQlink *my_lh;
pwr_tUInt32 my_subc_lc;
gdb_sNode *np;
gdb_sNode *old_np;
sub_sClient *cp;
pool_sQlink *cl;
sAdd *aep;
/* Test each client. If existing object, fill in nid field
and move the client to the appropriate nodes's subc_lh list. Turn
on timeouts. Put request in subadd message buffer.
We must do it all in one pass, since a user can come in during
a cache query for a later subcli and cancel the subscription
for an earlier subcli. */
add = tree_CreateTable(&sts, sizeof(pwr_tNodeId), offsetof(sAdd, nid),
sizeof(sAdd), 10, tree_Comp_nid);
#if 0
remove = tree_CreateTable(&sts, sizeof(pwr_tNodeId), offsetof(sRemove, nid),
sizeof(sRemove), 10, tree_eComp_nid);
#endif
/* Move all objects to a new, temporary root */
my_lh = pool_Qalloc(NULL, gdbroot->pool);
my_subc_lc = 0;
for (cl = pool_Qsucc(NULL, gdbroot->pool, lh); cl != lh;) {
cp = pool_Qitem(cl, sub_sClient, subc_ll);
cl = pool_Qsucc(NULL, gdbroot->pool, cl);
if (cdh_ObjidIsNull(oid) || cdh_ObjidIsEqual(oid, cp->aref.Objid)) {
pool_Qremove(NULL, gdbroot->pool, &cp->subc_ll);
pool_QinsertPred(NULL, gdbroot->pool, &cp->subc_ll, my_lh);
my_subc_lc++;
}
}
/* Now start testing clients from 'my_lh', and move them to other lists
Make sure the clients are still there after the test. */
for (cl = pool_Qsucc(NULL, gdbroot->pool, my_lh); cl != my_lh; ) {
cp = pool_Qitem(cl, sub_sClient, subc_ll);
cl = pool_Qsucc(NULL, gdbroot->pool, cl);
np = testClient(&sts, cp);
/* If an error is returned the client doesn't exist anymore. Some
other user removed it while TestSubcli had the database unlocked.
Just go on with the next client... */
if (np == NULL) continue;
/* Move the client to the list for the node where the object resides.
nid = pwr_cNNodeId is used for all objects we don't know. */
old_np = hash_Search(&sts, gdbroot->nid_ht, &cp->nid);
if (old_np == NULL) errh_Bugcheck(GDH__WEIRD, "");
pool_Qremove(NULL, gdbroot->pool, &cp->subc_ll);
old_np->subc_lc--;
pool_QinsertPred(NULL, gdbroot->pool, &cp->subc_ll, &np->subc_lh);
np->subc_lc++;
cp->nid = np->nid;
/* If the object's nid changed, then take the appropriate actions. */
if (np != old_np) {
if (np->nid != pwr_cNNodeId) { /* Object is known. */
activateTimeoutWatch(cp);
aep = tree_Insert(&sts, add, &np->nid);
if (aep == NULL) errh_Bugcheck(GDH__WEIRD, "");
if (aep->msg == NULL) {
aep->cnt = MIN(my_subc_lc, net_cSubMaxAdd);
aep->msg = malloc(sizeof(net_sSubAdd) + sizeof(net_sSubSpec) * aep->cnt);
aep->msg->count = 0;
} /* If there was no message allocated */
specp = &aep->msg->spec[aep->msg->count];
specp->sid = cp->sid;
specp->dt = cp->dt;
specp->sub_by_name = cp->sub_by_name;
specp->aref = cp->cclass != pool_cNRef ? cp->raref : cp->aref;
if (++aep->msg->count >= aep->cnt) {
/* The message buffer is full and must be sent. */
tgt = np->handler;
pwr_Assert(tgt.nid != pwr_cNNodeId);
gdb_Unlock;
net_Put(NULL, &tgt, aep->msg, net_eMsg_subAdd, 0, pwr_Offset(aep->msg, spec[aep->msg->count]), 0);
gdb_Lock;
aep->msg->count = 0;
}
} else { /* The object became unknown... */
cancelTimeoutWatch(cp);
subc_SetOld(cp); /* Data gets old immediately */
#if 0
/** @todo Maybe we should unlock the cached class? */
if (cp->cclass != pwr_cNRefId) {
ccp = pool_Address(NULL, gdbroot->pool, cp->cclass);
if (ccp == NULL) errh_Bugcheck(GDH__WEIRD, "Cached class address");
cmvolc_UnlockClass(NULL, ccp);
cp->cclass = pwr_cNRefId;
}
#endif
#if 0
if (old_np->nid != pwr_cNNodeId) {
rep = tree_Insert(&sts, remove, &old_np->nid);
if (rep == NULL) errh_Bugcheck(GDH__WEIRD, "");
if (rep->msg == NULL) {
rep->nid = old_np->nid;
rep->cnt = MIN(my_subc_lc, net_cSubMaxRemove);
rep->msg = malloc(sizeof(net_sSubRemove) + sizeof(rep->msg->sid[0]) * rep->cnt);
rep->msg->count = 0;
}
rep->msg->sid[rep->msg->count++] = cp->sid;
if (rep->msg->count >= net_cSubMaxRemove) {
np = hash_Search(&sts, gdbroot->nid_ht, &old_np->nid);
if (np == NULL) errh_Bugcheck(sts, "");
tgt.nid = rep->nid;
pwr_Assert(tgt.nid != pwr_cNNodeId);
gdb_Unlock;
net_Put(NULL, &tgt, rep->msg, net_eMsg_subRemove, 0, pwr_Offset(rep->msg, sid[rep->msg->count]), 0);
gdb_Lock;
rep->msg->count = 0;
}
}
#endif
}
}
}
pool_Free(NULL, gdbroot->pool, my_lh);
/* Now walk through the addmsg & remmsg and send all unsent messages. */
gdb_Unlock;
#if 0
for (rep = tree_Minimum(remove); rep != NULL; rep = tree_Successor(remove, rep)) {
if (rep->msg != NULL) {
if (rep->msg->count > 0) {
tgt.nid = rep->nid;
pwr_Assert(tgt.nid != pwr_cNNodeId);
net_Put(NULL, &tgt, rep->msg, net_eMsg_subRemove, 0, pwr_Offset(rep->msg, sid[rep->msg->count]), 0);
}
free(rep->msg);
}
}
#endif
for (aep = tree_Minimum(&sts, add); aep != NULL; aep = tree_Successor(&sts, add, aep)) {
if (aep->msg != NULL) {
if (aep->msg->count > 0) {
np = hash_Search(&sts, gdbroot->nid_ht, &aep->nid);
if (np == NULL) errh_Bugcheck(GDH__WEIRD, "");
tgt = np->handler;
pwr_Assert(tgt.nid != pwr_cNNodeId);
net_Put(NULL, &tgt, aep->msg, net_eMsg_subAdd, 0, pwr_Offset(aep->msg, spec[aep->msg->count]), 0);
}
free(aep->msg);
}
}
gdb_Lock;
tree_DeleteTable(&sts, add);
#if 0
tree_DeleteTable(remove);
#endif
}
pwr_tStatus
wb_dbs::prepareSectVolref()
{
char v[dbs_dAlign(sizeof(dbs_sVolRef))];
dbs_sVolRef *vp = (dbs_sVolRef*)v;
cdh_uTid cid;
sCentry *cep;
pwr_tStatus sts;
pwr_tUInt32 dvVersion;
if (fseek(m_fp, m_sect[dbs_eSect_volref].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
memset(v, 0, sizeof(v));
cid.pwr = pwr_cNCid;
cep = (sCentry*)tree_FindSuccessor(&sts, m_class_th, &cid.pwr);
while (cep) {
cdh_uVid vid;
vid.pwr = pwr_cNVid;
cid.pwr = cep->c.cid;
vid.v.vid_0 = cid.c.vid_0;
vid.v.vid_1 = cid.c.vid_1;
if (vid.pwr != m_volume.vid) {
wb_mvrep *mvrep = m_v->merep()->volume(&sts, vid.pwr);
if ( EVEN(sts)) throw wb_error_str("Metavolume not found");
dvVersion = getDvVersion( mvrep);
sVentry *vep;
vep = (sVentry*)tree_Insert(&sts, m_vol_th, &vid.pwr);
if (sts == TREE__INSERTED) {
/* was inserted now */
dbs_Open(&sts, &vep->env, mvrep->fileName());
strcpy(vep->v.name, mvrep->name());
vep->v.cid = mvrep->cid();
if ( m_volume.cid == pwr_eClass_DetachedClassVolume) {
vep->v.time.tv_sec = dvVersion;
vep->v.time.tv_nsec = 0;
}
else
vep->v.time = vep->env.file.time;
vep->v.size = vep->env.file.size;
vep->v.offset = 0;
int i = 0;
while ((vp = dbs_VolRef(&sts, i, (dbs_sVolRef *)v, &vep->env)) != NULL) {
sVentry *nvep;
i++;
nvep = (sVentry*)tree_Insert(&sts, m_vol_th, &vp->vid);
if (sts == TREE__INSERTED) {
wb_mvrep *nmvrep = m_v->merep()->volume(&sts, vp->vid);
if ( EVEN(sts)) {
printf( "** Classvolume %s referenced but not loaded\n", vp->name);
throw wb_error_str("Metavolume not loaded");
}
dvVersion = getDvVersion( mvrep);
dbs_Open(&sts, &nvep->env, nmvrep->fileName());
strcpy(nvep->v.name, vp->name);
nvep->v.cid = vp->cid;
if ( m_volume.cid == pwr_eClass_DetachedClassVolume) {
nvep->v.time.tv_sec = dvVersion;
nvep->v.time.tv_nsec = 0;
}
else
nvep->v.time = vp->time;
// nvep->v.dvVersion = vp->dvVersion;
nvep->v.size = vp->size;
nvep->v.offset = 0;
}
}
}
}
vid.pwr++;
cid.pwr = pwr_cNCid;
cid.c.vid_0 = vid.v.vid_0;
cid.c.vid_1 = vid.v.vid_1;
cep = (sCentry*)tree_FindSuccessor(&sts, m_class_th, &cid.pwr);
}
// Search trhough all found volumes and get their volrefs
int nVolume = 0;
sVentry *vep;
vep = (sVentry*)tree_Minimum(&sts, m_vol_th);
while (vep) {
if (vep->env.file.cookie == 0) {
printf(" volume not found: %d\n", vep->v.vid);
} else {
nVolume++;
m_sect[dbs_eSect_volref].size += sizeof(v);
}
vep = (sVentry*)tree_Successor(&sts, m_vol_th, vep);
}
return LDH__SUCCESS;
}
static pwr_tStatus start( ini_sContext *cp)
{
pwr_tStatus sts;
char console[80];
qini_sNode *nep;
qcom_sAid aid;
int fd;
if ( strcmp( cp->console, "") == 0)
strcpy( console, "/dev/console");
else
strcpy( console, cp->console);
if ((fd = open(console, O_APPEND | O_WRONLY)) == -1)
errl_Init(NULL, ini_errl_cb, cp);
else {
close(fd);
errl_Init(console, ini_errl_cb, cp);
}
errh_Init("pwr_ini", errh_eAnix_ini);
if ( cp->flags.b.interactive)
errh_Interactive();
ini_CheckContext(&sts, cp);
ini_ReadBootFile(&sts, cp);
ini_ReadNodeFile(&sts, cp);
for (nep = tree_Minimum(&sts, cp->nid_t); nep != NULL; nep = tree_Successor(&sts, cp->nid_t, nep)) {
if ( strcmp( cp->nodename, nep->name) == 0) {
cp->me = nep;
break;
}
}
if (cp->me == NULL) {
errh_LogFatal(&cp->log, "Cannot find my own node in %s\n", cp->nodefile.name);
exit(QCOM__WEIRD);
}
if (!checkErrors(cp))
exit(0);
/* Logfile is always $pwrp_log/pwr.log from V4.0.0 and handled by Linux log rotation */
char fname[256];
sprintf(fname, "$pwrp_log/pwr_%s.log", cp->nodename);
dcli_translate_filename(fname, fname);
errl_SetFile(fname);
errh_LogInfo(&cp->log, "Setting log file to: %s", fname);
// ini_SetSystemStatus( cp, PWR__STARTUP);
errh_SetStatus( PWR__STARTUP);
qini_BuildDb(&sts, cp->nid_t, cp->me, NULL, cp->busid);
ini_ProcTable(&sts, cp);
ini_ProcIter(&sts, cp, proc_mProcess_system, ini_ProcStart);
ini_ProcIter(&sts, cp, proc_mProcess_system, ini_ProcPrio);
ini_ProcIter(&sts, cp, proc_mProcess_user, ini_ProcStart);
ini_ProcIter(&sts, cp, proc_mProcess_user, ini_ProcPrio);
qcom_Init(&sts, &aid, "pwr_sev_init");
if (EVEN(sts)) {
errh_LogFatal(&cp->log, "qcom_Init, %m", sts);
exit(sts);
}
qcom_CreateQ(&sts, &cp->eventQ, NULL, "iniEvent");
if (EVEN(sts)) {
errh_LogFatal(&cp->log, "qcom_CreateQ, %m", sts);
exit(sts);
}
// ini_SetSystemStatus( cp, PWR__RUNNING);
errh_SetStatus( PWR__SRUN);
return sts;
}
