void v_instanceUnregister ( v_instance instance, v_registration registration, c_time timestamp) { c_char* metaName; assert(C_TYPECHECK(instance, v_instance)); switch (v_objectKind(instance)) { case K_DATAREADERINSTANCE: v_dataReaderInstanceUnregister(v_dataReaderInstance(instance), registration, timestamp); break; default: metaName = c_metaName(c_metaObject(c_getType(instance))); OS_REPORT_1(OS_ERROR, "v_instanceUnregister",0, "Unknown instance type <%s>", metaName); c_free(metaName); break; } }
c_bool cmx_readerCopy( c_object o, c_voidp args) { sd_serializer ser; sd_serializedData data; struct cmx_readerArg *arg; v_dataReaderSample sample, prev; arg = (struct cmx_readerArg *)args; if(o != NULL){ sample = v_dataReaderSample(o); prev = sample->prev; sample->prev = NULL; ser = sd_serializerXMLNewTyped(c_getType(o)); data = sd_serializerSerialize(ser, o); arg->result = sd_serializerToString(ser, data); sd_serializedDataFree(data); sd_serializerFree(ser); sample->prev = prev; } return FALSE; }
v_actionResult cmx_readerReadCopy( c_object o, c_voidp args) { sd_serializer ser; sd_serializedData data; v_dataReaderSample sample, newer; struct cmx_readerArg *arg; v_actionResult result; result = 0; if(o != NULL){ sample = v_dataReaderSample(o); if(v_stateTest(v_readerSampleState(sample), L_READ)){ v_actionResultSet(result, V_PROCEED); } else { sample = v_dataReaderSample(o); newer = sample->newer; sample->newer = NULL; arg = (struct cmx_readerArg *)args; ser = sd_serializerXMLNewTyped(c_getType(o)); data = sd_serializerSerialize(ser, o); arg->result = sd_serializerToString(ser, data); sd_serializedDataFree(data); sd_serializerFree(ser); sample->newer = newer; } } return result; }
c_bool cmx_readerReadCopy( c_object o, c_voidp args) { sd_serializer ser; sd_serializedData data; v_dataReaderSample sample, prev; struct cmx_readerArg *arg; c_bool result; result = FALSE; if(o != NULL){ sample = v_dataReaderSample(o); if(v_stateTest(v_readerSampleState(sample), L_READ)){ result = TRUE; } else { sample = v_dataReaderSample(o); prev = sample->prev; sample->prev = NULL; arg = (struct cmx_readerArg *)args; ser = sd_serializerXMLNewTyped(c_getType(o)); data = sd_serializerSerialize(ser, o); arg->result = sd_serializerToString(ser, data); sd_serializedDataFree(data); sd_serializerFree(ser); sample->prev = prev; } } return result; }
static void printWalkHistory ( c_object o, c_iterActionArg arg) { c_type type; c_char *name, *ename; if (o) { type = c_getType(o); name = c_metaScopedName(c_metaObject(type)); printf("<0x%x> %s",(HEXVALUE)o,name); if (c_checkType(o, "v_entity") == o) { ename = v_entityName(o); if (ename != NULL) { printf(" /* %s */", ename); } } else if (c_checkType(o, "c_metaObject") == o) { ename = c_metaScopedName(o); if (ename != NULL) { printf(" /* %s */", ename); os_free(ename); } } printf("\n"); } else { printf("<0x0>\n"); } }
v_actionResult cmx_readerCopy( c_object o, c_voidp args) { sd_serializer ser; sd_serializedData data; struct cmx_readerArg *arg; v_dataReaderSample sample, older; v_actionResult result = 0; v_lifespanSample next; arg = (struct cmx_readerArg *)args; if(o != NULL){ sample = v_dataReaderSample(o); older = sample->older; next = sample->_parent._parent.next; sample->older = NULL; sample->_parent._parent.next = NULL; ser = sd_serializerXMLNewTyped(c_getType(o)); data = sd_serializerSerialize(ser, o); arg->result = sd_serializerToString(ser, data); sd_serializedDataFree(data); sd_serializerFree(ser); sample->older = older; sample->_parent._parent.next = next; } return result; }
void v_messageEOTExtFree ( v_messageEOTExt xmsg) { c_type xmsgType = c_getType (xmsg); memset (xmsg, 0, xmsgType->size); c_free (xmsg); }
static void toolAction ( d_storeMMFKernel kernel, c_voidp addr) { c_base base; c_type type; c_char *name; c_object o; c_address offset; c_long size; struct toolActionData actionData; actionData.fin = stdin; actionData.fout = stdout; actionData.depth = 0; actionData.stack = NULL; base = c_getBase(kernel); o = c_baseCheckPtr(base, addr); if (o) { type = c_getType(o); size = c_typeSize(type); if (o != addr) { offset = C_ADDRESS(addr) - C_ADDRESS(o); if (offset < (c_address)size) { printf("Warning: address is %lu bytes in %s " "object starting at 0x"PA_ADDRFMT"\n", offset, _METANAME(type), (os_address)o); OBJECT_PUSH(&actionData, o); tryPrintOffset(o,&actionData,offset); OBJECT_POP(&actionData); } else { printf("Warning: address is %lu bytes in " "memory starting at 0x"PA_ADDRFMT"\n", offset, (os_address)o); } } else { name = c_metaScopedName(c_metaObject(type)); printf("Object <0x"PA_ADDRFMT"> refCount=%d size=%d type is: <0x"PA_ADDRFMT"> %s\n", (os_address)o, c_refCount(o), size, (os_address)type, name); os_free(name); OBJECT_PUSH(&actionData, o); printType(type, &actionData); printf("\n"); OBJECT_POP(&actionData); } } else { printf("Address <0x"PA_ADDRFMT"> is not a Database Object\n", (os_address)addr); } }
v_message v_messageExtConvertFromExtType ( c_type msgType, v_messageExt xmsg) { c_type xmsgType = c_getType (xmsg); v_message vmsg; vmsg = c_new_s (msgType); if (vmsg) { v_messageExtConvertHeaderFromExt (vmsg, xmsg); memcpy (vmsg + 1, xmsg + 1, xmsgType->size - sizeof (*xmsg)); memset (xmsg, 0, xmsgType->size); c_free (xmsg); } return vmsg; }
static void printHistory ( c_iter history, c_long cursor) { c_type type; c_object o; c_char *name, *ename; o = c_iterObject(history,cursor-1); type = c_getType(o); name = c_metaScopedName(c_metaObject(type)); printf("<0x%x> %s",(HEXVALUE)o,name); if (c_checkType(o, "v_entity") == o) { ename = v_entityName(o); if (ename != NULL) { printf(" /* %s */", ename); } } printf("\n"); }
v_messageQos v_messageQos_copy ( v_messageQos src) { v_messageQos _this; c_ulong size; c_type type = NULL; size = c_arraySize(src); type = c_getType(src); _this = c_newArray((c_collectionType)type,size); if (_this) { memcpy(_this,src,size); } else { OS_REPORT(OS_CRITICAL, "v_messageQos_copy",V_RESULT_INTERNAL_ERROR, "Failed to allocate messageQos."); } return _this; }
static c_bool printCollectionAction( c_object o, c_voidp arg) { c_type type; toolActionData actionData = (toolActionData)arg; c_char *name; if (o != NULL) { type = c_getType(o); name = c_metaScopedName(c_metaObject(type)); iprintf("Object <0x%x> type is: <0x%x> %s\n", (HEXVALUE)o, (HEXVALUE)type, name); os_free(name); OBJECT_PUSH(actionData, o); printType(type, actionData); printf("\n"); OBJECT_POP(actionData); } return TRUE; }
static void printCollectionAction( c_metaObject mo, c_scopeWalkActionArg arg) { c_type type; c_object o = c_metaObject (mo); toolActionData actionData = (toolActionData)arg; c_char *name; if (o != NULL) { type = c_getType(o); name = c_metaScopedName(c_metaObject(type)); iprintf("Object <0x"PA_ADDRFMT"> refCount=%d type is: <0x"PA_ADDRFMT"> %s\n", (os_address)o, c_refCount(o), (os_address)type, name); os_free(name); OBJECT_PUSH(actionData, o); printType(type, actionData); printf("\n"); OBJECT_POP(actionData); } }
v_writeResult v_instanceWrite( v_instance instance, v_message message) { c_char *metaName; assert(C_TYPECHECK(instance, v_instance)); switch (v_objectKind(instance)) { case K_DATAREADERINSTANCE: return v_dataReaderInstanceWrite(v_dataReaderInstance(instance),message); default: metaName = c_metaName(c_metaObject(c_getType(instance))); OS_REPORT_1(OS_ERROR, "v_instanceWrite",0, "Unknown instance type <%s>", metaName); c_free(metaName); return V_WRITE_PRE_NOT_MET; } }
c_bool cmx_writerHistoryCopy( c_object sample, c_voidp args) { struct cmx_writerSnapshotArg* arg; sd_serializedData data; c_char* xml; arg = (struct cmx_writerSnapshotArg*)args; if(arg->serializer == NULL){ arg->serializer = sd_serializerXMLNewTyped(c_getType(sample)); } data = sd_serializerSerialize(arg->serializer, sample); xml = sd_serializerToString(arg->serializer, data); arg->snapshot->samples = c_iterInsert(arg->snapshot->samples, xml); sd_serializedDataFree(data); return TRUE; }
static void printCollection( c_collectionType type, toolActionData actionData) { c_long size, i, offset, esize; c_object o; c_voidp p; c_object arrayElement; c_type subtype; c_bool isRef; o = c_iterObject(actionData->stack, 0); switch (type->kind) { case C_ARRAY: case C_SEQUENCE: /* Walk over all entries */ switch (type->kind) { case C_ARRAY: if (type->maxSize == 0) { size = c_arraySize((c_array)o); } else { size = type->maxSize; } break; case C_SEQUENCE: size = c_arraySize((c_array)o); break; default: size = 0; assert(FALSE); break; } if (c_typeIsRef(type->subType)) { esize = sizeof(c_voidp); isRef = TRUE; } else { esize = type->subType->size; isRef = FALSE; } p = o; offset = 0; for (i=0; i<size; i++) { iprintf("Element (%d) Offset (%d)\n",i,offset); arrayElement = isRef ? *((c_object *)p) : (c_object) p; if (arrayElement != NULL) { OBJECT_PUSH(actionData, arrayElement); if (isRef) { subtype = c_getType(arrayElement); printType(subtype, actionData); } else { iprintf(" "); printType(type->subType, actionData); } printf("\n"); OBJECT_POP(actionData); } else { iprintf(" <0x0>\n"); } p = C_DISPLACE(p, esize); offset += esize; } break; case C_STRING: printf(" \"%s\"",(c_char *)o); break; case C_SET: case C_LIST: case C_BAG: case C_DICTIONARY: case C_QUERY: { if (o != NULL) { /* Walk over the elements */ c_walk(o, (c_action)printCollectionAction, actionData); if (c_count(o) == 0) { iprintf("<EMPTY>"); } } else { iprintf("<NULL>"); } } break; case C_SCOPE: c_scopeWalk(o, printCollectionAction, actionData); break; default: printf("Specified type <0x"PA_ADDRFMT"> is not a valid collection type\n", (os_address)type); break; } }
void cmx_readerSnapshotNewAction( v_entity e, c_voidp args) { v_dataReader reader; c_iter instances; v_dataReaderInstance instance; v_dataReaderSample sample, prev; v_query query; c_bool release; sd_serializer ser; sd_serializedData data; struct cmx_readerSnapshotArg* arg; release = FALSE; arg = (struct cmx_readerSnapshotArg*)args; reader = NULL; instances = NULL; ser = NULL; switch(v_object(e)->kind){ case K_DATAREADER: reader = v_dataReader(e); arg->success = TRUE; arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot))); v_observerLock(v_observer(reader)); if(reader->index->objects){ instances = c_select(reader->index->notEmptyList, 0); } break; case K_QUERY: case K_DATAREADERQUERY: query = v_query(e); reader = v_dataReader(v_querySource(query)); if(reader != NULL){ release = TRUE; arg->success = TRUE; arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot))); v_observerLock(v_observer(reader)); switch(v_object(query)->kind){ case K_DATAREADERQUERY: if(v_dataReaderQuery(query)->instanceQ){ instances = c_select((c_collection)(v_dataReaderQuery(query)->instanceQ), 0); } break; default: OS_REPORT_1(OS_ERROR, CM_XML_CONTEXT, 0, "cmx_readerSnapshotNewAction unknown kind (%d).", v_object(query)->kind); break; } } break; default: break; } if(arg->success == TRUE){ arg->snapshot->samples = c_iterNew(NULL); } if(instances != NULL){ instance = v_dataReaderInstance(c_iterTakeFirst(instances)); while(instance != NULL){ sample = c_keep(v_dataReaderInstanceHead(instance)); if(sample != NULL){ prev = sample->prev; sample->prev = NULL; if(ser == NULL){ ser = sd_serializerXMLNewTyped(c_getType(c_object(sample))); } data = sd_serializerSerialize(ser, c_object(sample)); arg->snapshot->samples = c_iterInsert(arg->snapshot->samples, sd_serializerToString(ser, data)); sd_serializedDataFree(data); sample->prev = prev; c_free(sample); } c_free(instance); instance = v_dataReaderInstance(c_iterTakeFirst(instances)); } c_iterFree(instances); } if(reader != NULL){ v_observerUnlock(v_observer(reader)); if(release == TRUE){ c_free(reader); } } if(ser != NULL){ sd_serializerFree(ser); } }
void v_serviceInit( v_service service, const c_char *name, const c_char *extStateName, v_serviceType serviceType, v_participantQos qos, c_bool enable) { c_char *typeName; os_duration lp = 300*OS_DURATION_SECOND; v_kernel kernel; v_serviceManager manager; assert(service != NULL); assert(serviceType != V_SERVICETYPE_NONE); assert(C_TYPECHECK(service, v_service)); assert(C_TYPECHECK(qos, v_participantQos)); assert(name != NULL); kernel = v_objectKernel(service); manager = v_getServiceManager(kernel); /* v_participantInit writes the DCPSParticipant and CMParticipant topics, but * it downcasts to v_service to extract serviceType, and hence needs it available. */ service->serviceType = serviceType; v_participantInit(v_participant(service), name, qos); if(enable) { (void)v_entityEnable(v_entity(service)); } service->state = v_serviceManagerRegister(manager, service, extStateName); service->lease = v_leaseMonotonicNew(kernel, lp); service->newGroups = NULL; if(service->lease) { v_result result; result = v_leaseManagerRegister( kernel->livelinessLM, service->lease, V_LEASEACTION_SERVICESTATE_EXPIRED, v_public(service->state), FALSE/*do not repeat */); if(result != V_RESULT_OK) { c_free(service->lease); service->lease = NULL; OS_REPORT(OS_FATAL, "v_service", result, "A fatal error was detected when trying to register the liveliness lease " "to the liveliness lease manager of the kernel. The result code was %d.", result); } } else { OS_REPORT(OS_FATAL, "v_service", V_RESULT_INTERNAL_ERROR, "Unable to create a liveliness lease! Most likely not enough shared " "memory available to complete the operation."); } if(service->lease)/* aka everything is ok so far */ { v_result result; c_iter participants; v_participant splicedParticipant; participants = v_resolveParticipants(kernel, V_SPLICED_NAME); assert(c_iterLength(participants) == 1 || 0 == strcmp(name, V_SPLICED_NAME)); splicedParticipant = v_participant(c_iterTakeFirst(participants)); if(splicedParticipant) { result = v_leaseManagerRegister( v_participant(service)->leaseManager, v_service(splicedParticipant)->lease, V_LEASEACTION_SERVICESTATE_EXPIRED, v_public(v_service(splicedParticipant)->state), FALSE /* only observing, do not repeat */); if(result != V_RESULT_OK) { c_free(service->lease); service->lease = NULL; OS_REPORT(OS_FATAL, "v_service", result, "A fatal error was detected when trying to register the spliced's liveliness lease " "to the lease manager of participant %p (%s). The result code was %d.", (void*)service, name, result); } c_free(splicedParticipant); } c_iterFree(participants); } if (service->state != NULL) { /* check if state has correct type */ typeName = c_metaScopedName(c_metaObject(c_getType(c_object(service->state)))); if (extStateName == NULL) { extStateName = VSERVICESTATE_NAME; } if (strcmp(typeName, extStateName) == 0) { /* Splicedaemon may not observer itself! */ if (strcmp(name, V_SPLICED_NAME) != 0) { v_serviceState splicedState; splicedState = v_serviceManagerGetServiceState(manager, V_SPLICED_NAME); (void)OSPL_ADD_OBSERVER(splicedState, service, V_EVENT_SERVICESTATE_CHANGED, NULL); } } else { OS_REPORT(OS_ERROR, "v_service", V_RESULT_ILL_PARAM, "Requested state type (%s) differs with existing state type (%s)", extStateName, typeName); c_free(service->state); service->state = NULL; } os_free(typeName); } }
void cmx_readerSnapshotNewAction( v_public p, c_voidp args) { v_dataReader reader; c_iter instances; v_dataReaderInstance instance; v_dataReaderSample sample; v_query query; c_bool release; sd_serializer ser; sd_serializedData data; struct cmx_readerSnapshotArg* arg; release = FALSE; arg = (struct cmx_readerSnapshotArg*)args; reader = NULL; instances = NULL; ser = NULL; switch(v_object(p)->kind){ case K_DATAREADER: reader = v_dataReader(p); arg->success = TRUE; arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot))); v_observerLock(v_observer(reader)); if(reader->index->objects){ instances = ospl_c_select(reader->index->notEmptyList, 0); } break; case K_QUERY: case K_DATAREADERQUERY: query = v_query(p); reader = v_dataReader(v_querySource(query)); if(reader != NULL){ release = TRUE; arg->success = TRUE; arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot))); v_observerLock(v_observer(reader)); switch(v_object(query)->kind){ case K_DATAREADERQUERY: if(v_dataReaderQuery(query)->instanceQ){ instances = ospl_c_select((c_collection)(v_dataReaderQuery(query)->instanceQ), 0); } break; default: OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "cmx_readerSnapshotNewAction unknown kind (%d).", v_object(query)->kind); break; } } break; default: break; } if(arg->success == TRUE){ arg->snapshot->samples = c_iterNew(NULL); } if(instances != NULL){ v_dataReaderSample sampleShallowCopy = NULL; instance = v_dataReaderInstance(c_iterTakeFirst(instances)); while(instance != NULL){ v_state ivState = instance->_parent._parent.state & (L_DISPOSED | L_NOWRITERS | L_NEW); sample = v_dataReaderInstanceOldest(instance); if (sample != NULL) { do { v_state state = ivState | ((sample->_parent.sampleState & (L_READ | L_LAZYREAD)) ? L_READ : 0); if (sampleShallowCopy == NULL) { sampleShallowCopy = c_new(c_getType(c_object(sample))); } memcpy(sampleShallowCopy, sample, c_typeSize(c_getType(sampleShallowCopy))); sampleShallowCopy->newer = NULL; sampleShallowCopy->_parent.sampleState &= ~(L_DISPOSED | L_NOWRITERS | L_NEW | L_READ | L_LAZYREAD); sampleShallowCopy->_parent.sampleState |= state; if(ser == NULL){ ser = sd_serializerXMLNewTyped(c_getType(c_object(sampleShallowCopy))); } data = sd_serializerSerialize(ser, c_object(sampleShallowCopy)); arg->snapshot->samples = c_iterInsert(arg->snapshot->samples, sd_serializerToString(ser, data)); sd_serializedDataFree(data); sample = sample->newer; } while (sample != NULL); } c_free(instance); instance = v_dataReaderInstance(c_iterTakeFirst(instances)); } c_iterFree(instances); if (sampleShallowCopy != NULL) { memset(sampleShallowCopy, 0, c_typeSize(c_getType(sampleShallowCopy))); c_free(sampleShallowCopy); } } if(reader != NULL){ v_observerUnlock(v_observer(reader)); if(release == TRUE){ c_free(reader); } } if(ser != NULL){ sd_serializerFree(ser); } }
void v_serviceInit( v_service service, v_serviceManager manager, const c_char *name, const c_char *extStateName, v_participantQos qos, v_statistics stats) { c_char *typeName; v_duration lp = {300, 0}; v_kernel kernel; assert(service != NULL); assert(C_TYPECHECK(service, v_service)); assert(C_TYPECHECK(qos, v_participantQos)); assert(name != NULL); kernel = v_objectKernel(service); v_participantInit(v_participant(service), name, qos, stats, TRUE); service->state = v_serviceManagerRegister(manager, service, extStateName); service->lease = v_leaseNew(kernel, lp); if(service->lease) { v_result result; result = v_leaseManagerRegister( kernel->livelinessLM, service->lease, V_LEASEACTION_SERVICESTATE_EXPIRED, v_public(service->state), FALSE/*do not repeat */); if(result != V_RESULT_OK) { c_free(service->lease); service->lease = NULL; OS_REPORT_1(OS_ERROR, "v_service", 0, "A fatal error was detected when trying to register the liveliness lease " "to the liveliness lease manager of the kernel. The result code was %d.", result); } } else { OS_REPORT(OS_ERROR, "v_service", 0, "Unable to create a liveliness lease! Most likely not enough shared " "memory available to complete the operation."); } if(service->lease)/* aka everything is ok so far */ { v_result result; c_iter participants; v_participant splicedParticipant; participants = v_resolveParticipants(kernel, V_SPLICED_NAME); assert(c_iterLength(participants) == 1 || 0 == strcmp(name, V_SPLICED_NAME)); splicedParticipant = v_participant(c_iterTakeFirst(participants)); if(splicedParticipant) { result = v_leaseManagerRegister( v_participant(service)->leaseManager, v_service(splicedParticipant)->lease, V_LEASEACTION_SERVICESTATE_EXPIRED, v_public(v_service(splicedParticipant)->state), FALSE /* only observing, do not repeat */); if(result != V_RESULT_OK) { c_free(service->lease); service->lease = NULL; OS_REPORT_3(OS_ERROR, "v_service", 0, "A fatal error was detected when trying to register the spliced's liveliness lease " "to the lease manager of participant %p (%s). The result code was %d.", service, name, result); } } c_iterFree(participants); } if (service->state != NULL) { /* check if state has correct type */ typeName = c_metaScopedName(c_metaObject(c_getType(c_object(service->state)))); if (extStateName == NULL) { extStateName = VSERVICESTATE_NAME; } if (strcmp(typeName, extStateName) == 0) { if (strcmp(name, V_SPLICED_NAME) != 0) { /* Splicedaemon may not observer itself! */ v_serviceWatchSplicedaemon(service); } } else { OS_REPORT_2(OS_ERROR, "v_service", 0, "Requested state type (%s) differs with existing state type (%s)", extStateName, typeName); c_free(service->state); service->state = NULL; } os_free(typeName); } }