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