void
v_deadLineInstanceListRemoveInstance(
v_deadLineInstanceList list,
v_instance instance)
{
assert(C_TYPECHECK(list,v_deadLineInstanceList));
assert((instance->prev != NULL) && (instance->next != NULL));
assert(c_refCount(list) > 0);
assert(c_refCount(instance) > 0);
/* As the instance is removed, there is no need to update the lease.
* Updating the lease might trigger the leasemanager thread to determine
* the next expiry time. The next expiry time can also be determined on
* the next deadline check, which is more efficient as the administration
* might already have changed many times.
*/
v_instanceRemove(instance);
if (v_instanceAlone(v_instance(list))) { /* list has become empty */
if (list->deadlineLease != NULL) {
v_leaseManagerDeregister(list->leaseManager, list->deadlineLease);
c_free(list->deadlineLease);
list->deadlineLease = NULL;
}
}
}
c_object
c_checkType (
c_object o,
const c_char *name)
{
c_type type;
c_string str;
c_bool found = FALSE;
c_bool stop = FALSE;
if (o == NULL) {
return NULL;
}
c_assertValidDatabaseObject(o);
assert(c_refCount(o) > 0);
assert(name != NULL);
type = c__getType(o);
while (!found && !stop) {
str = c_metaObject(type)->name;
if (str == NULL) {
found = TRUE; /** assume TRUE **/
} else if (strcmp(str,name) != 0) {
switch (c_baseObject(type)->kind) {
case M_CLASS:
type = c_type(c_class(type)->extends);
if (type == NULL) {
if ((strcmp(str,"c_base") == 0) && (strcmp(name,"c_module") == 0)) {
found = TRUE;
}
stop = TRUE;
}
break;
case M_TYPEDEF:
type = c_typeDef(type)->alias;
if (type == NULL) {
stop = TRUE;
}
break;
default:
stop = TRUE;
}
} else {
found = TRUE;
}
}
if (!found) {
#ifndef NDEBUG
if(o != NULL){
str = c_metaObject(c__getType(o))->name;
OS_REPORT_2(OS_ERROR, "Database", 0,
"Type mismatch: object type is %s but %s was expected\n",
str,name);
}
#endif
return NULL;
}
return o;
}
static void
checkSample(
v_dataViewSample sample)
{
if (((v_dataViewInstance)(((v_readerSample)sample)->instance))->sampleCount != 0) {
v_readerSample readerSample = (v_readerSample)(v_dataViewSampleTemplate(sample)->sample);
v_dataViewSampleList sampleList = (v_dataViewSampleList)(sample);
REL_ASSERT(c_refCount(readerSample) > 0);
REL_ASSERT(C_TYPECHECK(readerSample, v_readerSample));
REL_ASSERT(c_refCount(sampleList) > 0);
if (sampleList->prev == NULL) {
REL_ASSERT(readerSample->viewSamples == sample);
} else {
REL_ASSERT(readerSample->viewSamples != sample);
}
}
}
void
v_dataReaderSampleFree(
v_dataReaderSample sample)
{
v_dataReaderInstance instance;
v_index index;
v_dataReader dataReader;
v_message message;
if (sample) {
assert(C_TYPECHECK(sample, v_dataReaderSample));
if (c_refCount(sample) == 1) {
/* Free the slave-samples as well */
instance = v_readerSample(sample)->instance;
index = v_index(instance->index);
dataReader = v_dataReader(index->reader);
if (!v_readerSampleTestState(sample,L_READ)) {
dataReader->notReadCount--;
}
#ifdef _SL_
if (dataReader->cachedSampleCount < 1000) {
message = v_dataReaderSampleMessage(sample);
c_free(message);
v_dataReaderSampleTemplate(sample)->message = NULL;
sample->prev = dataReader->cachedSample;
dataReader->cachedSample = sample;
dataReader->cachedSampleCount++;
#else
if (dataReader->cachedSample == NULL) {
dataReader->cachedSample = sample;
message = v_dataReaderSampleMessage(sample);
c_free(message);
v_dataReaderSampleTemplate(sample)->message = NULL;
#endif
} else {
c_free(sample);
}
} else {
c_free(sample);
}
}
}
void
v_dataReaderSampleRemoveFromLifespanAdmin(
v_dataReaderSample sample)
{
v_dataReaderInstance instance;
v_index index;
if (sample) {
assert(C_TYPECHECK(sample, v_dataReaderSample));
instance = v_readerSample(sample)->instance;
index = v_index(instance->index);
v_lifespanAdminRemove(v_dataReaderEntry(index->entry)->lifespanAdmin,
v_lifespanSample(sample));
}
}
/* put at end of list */
void
v_deadLineInstanceListInsertInstance(
v_deadLineInstanceList list,
v_instance instance)
{
v_instance head = v_instance(list);
v_kernel k;
v_result result;
assert(C_TYPECHECK(instance,v_instance));
assert(C_TYPECHECK(list,v_deadLineInstanceList));
assert(v_instanceAlone(instance));
assert(c_refCount(list) > 0);
assert(c_refCount(instance) > 0);
/* As the instance is put at the end of the list no need to update the
lease!
*/
v_instanceUpdate(instance); /* Updates instance checkTime */
v_instanceAppend(head,instance);
if (list->deadlineLease == NULL) {
if (c_timeCompare(list->leaseDuration, C_TIME_INFINITE) != C_EQ) {
k = v_objectKernel(list->leaseManager);
list->deadlineLease = v_leaseNew(k, list->leaseDuration);
if(list->deadlineLease)
{
result = v_leaseManagerRegister(
list->leaseManager,
list->deadlineLease,
list->actionId,
v_public(list->actionObject),
TRUE /* repeat lease if expired */);
if(result != V_RESULT_OK)
{
c_free(list->deadlineLease);
list->deadlineLease = NULL;
OS_REPORT_1(OS_ERROR, "v_deadLineInstanceList", 0,
"A fatal error was detected when trying to register the deadline lease."
"The result code was %d.", result);
}
}
}
}
}
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);
}
}
void
v_deadLineInstanceListUpdate(
v_deadLineInstanceList list,
v_instance instance)
{
assert(C_TYPECHECK(instance,v_instance));
assert(C_TYPECHECK(list,v_deadLineInstanceList));
assert(c_refCount(list) > 0);
assert(c_refCount(instance) > 0);
/* This will also place the current instance at the end of the list.
Again no need to update the lease, we can determine the next wake-up
as soon as the next deadlinecheck is performed.
*/
if (v_instanceAlone(instance)) {
v_deadLineInstanceListInsertInstance(list,instance);
} else {
v_instanceRemove(instance);
v_instanceUpdate(instance); /* Updates instance checkTime */
v_instanceAppend(v_instance(list), instance);
}
}
void
checkInstance(
v_dataViewInstance instance,
c_bool isNotEmpty)
{
int i = 0;
v_dataViewSample current;
v_dataViewSample next;
if (instance) {
if (!isNotEmpty) {
REL_ASSERT(instance->sampleCount == 0);
}
if (!v_reader(v_dataViewReader(instance->dataView))->qos->userKey.enable && isNotEmpty) {
REL_ASSERT(instance->sampleCount == 1);
}
REL_ASSERT(c_refCount(instance) > 0);
REL_ASSERT(C_TYPECHECK(instance, v_dataViewInstance));
next = NULL;
current = v_dataViewInstanceTemplate(instance)->sample;
while (current != NULL) {
if (!isNotEmpty) {
checkSample(current);
}
REL_ASSERT(current->next == next);
if (next != NULL) {
REL_ASSERT(next->prev == current);
}
next = current;
current = current->prev;
i++;
}
if (next != NULL) {
REL_ASSERT(next->prev == current);
}
if (isNotEmpty) {
REL_ASSERT(i == instance->sampleCount);
} else {
REL_ASSERT(i == 1);
}
}
}
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_result
v_deliveryWaitListFree(
v_deliveryWaitList _this)
{
v_deliveryWaitList found;
v_result result;
assert(C_TYPECHECK(_this,v_deliveryWaitList));
if (_this) {
/* lookup or create a writer specific admin.
*/
found = c_remove(v_deliveryGuard(_this->guard)->waitlists, _this, NULL, NULL);
assert(found == _this);
assert(c_refCount(found) == 2);
c_free(found);
c_free(_this);
result = V_RESULT_OK;
} else {
result = V_RESULT_ILL_PARAM;
}
return result;
}
v_writeResult
v_dataViewInstanceWrite (
v_dataViewInstance instance,
v_readerSample sample)
{
v_dataViewSample viewSample;
v_dataViewSample *prev;
v_dataViewSample next;
assert(C_TYPECHECK(instance,v_dataViewInstance));
assert(C_TYPECHECK(sample,v_readerSample));
CHECK_INSTANCE(instance);
viewSample = v_dataViewSampleNew(instance,sample);
if (viewSample) {
viewSample->next = NULL;
prev = &v_dataViewInstanceTemplate(instance)->sample;
next = NULL;
while (*prev) {
next = *prev;
prev = &(*prev)->prev;
}
*prev = viewSample;
viewSample->next = next;
v_readerSampleAddViewSample(sample,viewSample);
instance->sampleCount++;
assert(c_refCount(viewSample) == 1);
v_dataViewNotifyDataAvailable(v_dataView(instance->dataView), viewSample);
}
CHECK_INSTANCE(instance);
return V_WRITE_SUCCESS;
}
static d_storeResult
d_instanceInsert(
d_instance instance,
v_message msg,
d_groupInfo groupInfo,
d_sample toInsert)
{
d_sample sample;
d_sample oldest;
d_sample ptr;
v_state state;
c_equality equality;
v_topicQos topicQos;
assert(C_TYPECHECK(instance, d_instance));
assert(C_TYPECHECK(msg, v_message));
assert(C_TYPECHECK(groupInfo, d_groupInfo));
if (msg == NULL) {
return D_STORE_RESULT_ILL_PARAM;
}
topicQos = groupInfo->topic->qos;
if(toInsert){
sample = toInsert;
sample->instance = instance;
} else {
sample = d_groupInfoSampleNew(groupInfo, instance, msg);
}
if (!sample) {
return D_STORE_RESULT_OUT_OF_RESOURCES;
}
if (v_stateTest(instance->state, L_EMPTY)) {
assert(d_instanceGetHead(instance) == NULL);
assert(d_instanceGetTail(instance) == NULL);
assert(instance->count == 0);
d_instanceSetHead(instance,sample);
v_stateClear(instance->state, L_EMPTY);
} else {
assert(d_instanceGetHead(instance) != NULL);
assert(d_instanceGetTail(instance) != NULL);
assert(instance->count != 0);
if(topicQos->orderby.kind == V_ORDERBY_RECEPTIONTIME){
sample->older = d_instanceGetHead(instance);
d_instanceSetHead(instance, sample);
} else {
ptr = d_instanceGetHead(instance);
equality = v_timeCompare(msg->writeTime,
d_sampleGetMessage(ptr)->writeTime);
if (equality == C_LT) {
while (ptr->older != NULL) {
equality = v_timeCompare(msg->writeTime,
d_sampleGetMessage(ptr->older)->writeTime);
if (equality != C_LT) {
break;
}
ptr = ptr->older;
}
sample->newer = ptr;
sample->older = ptr->older;
ptr->older = c_keep(sample);
} else {
sample->older = d_instanceGetHead(instance);
d_instanceSetHead(instance,sample);
}
}
}
assert(c_refCount(sample) == 2);
if (sample->older != NULL) {
sample->older->newer = sample;
} else {
d_instanceSetTail(instance,sample);
}
sample->instance = instance;
state = v_nodeState(msg);
if (v_stateTest(state,L_DISPOSED)) {
instance->count++;
}
if (v_stateTest(state, L_WRITE)) {
if (topicQos->history.kind == V_HISTORY_KEEPALL
|| instance->messageCount < topicQos->history.depth) {
instance->count++;
instance->messageCount++;
} else {
ptr = NULL;
oldest = instance->oldest;
while (!v_messageStateTest(d_sampleGetMessage(oldest),L_WRITE)) {
instance->count--;
ptr = oldest;
oldest = oldest->newer;
}
if (v_messageStateTest(d_sampleGetMessage(oldest),L_DISPOSED)) {
instance->count--;
}
ptr = oldest;
oldest = oldest->newer;
while (!v_messageStateTest(d_sampleGetMessage(oldest),L_WRITE)) {
instance->count--;
ptr = oldest;
oldest = oldest->newer;
}
d_instanceSetTail(instance,oldest);
oldest->older = NULL;
ptr->newer = NULL;
while(ptr){
oldest = ptr->older;
ptr->older = NULL;
c_free(ptr);
ptr = oldest;
}
}
}
if (v_messageStateTest(d_sampleGetMessage(d_instanceGetHead(instance)), L_DISPOSED)) {
v_stateSet(instance->state, L_DISPOSED);
} else {
if (v_stateTest(instance->state, L_DISPOSED)) {
v_stateClear(instance->state, L_DISPOSED);
}
}
c_free(sample);
assert((instance->count == 0) == (d_instanceGetTail(instance) == NULL));
assert((instance->count == 0) == (d_instanceGetHead(instance) == NULL));
return D_STORE_RESULT_OK;
}
void
v_lifespanAdminRemove(
v_lifespanAdmin admin,
v_lifespanSample sample)
{
c_equality eq;
assert(C_TYPECHECK(admin,v_lifespanAdmin));
assert(C_TYPECHECK(sample,v_lifespanSample));
eq = c_timeCompare(sample->expiryTime, C_TIME_INFINITE);
if (eq == C_EQ) {
return; /* no insert, since sample never expires! */
}
CHECK_ADMIN(admin, sample);
if (sample == admin->head) {
assert(sample->prev == NULL);
if (sample == admin->tail) {
assert(c_refCount(sample) > 2);
assert(sample->next == NULL);
c_free(sample); /* free tail reference */
admin->head = NULL;
admin->tail = NULL;
} else {
assert(c_refCount(sample) > 1);
admin->head = sample->next; /* transfer refcount */
if (sample->next) {
sample->next = NULL;
admin->head->prev = NULL; /* or sample->next->prev = NULL */
}
}
c_free(sample); /* free head reference */
admin->sampleCount--;
} else {
if (sample == admin->tail) {
assert(sample->prev);
assert(c_refCount(sample) > 2); /* Both tail and next field from prev sample. */
assert(sample->next == NULL);
c_free(admin->tail);
admin->tail = c_keep(sample->prev);
sample->prev = NULL;
c_free(admin->tail->next); /* admin->tail->next == sample */
admin->tail->next = NULL;
admin->sampleCount--;
} else {
if ((sample->next != NULL) && (sample->prev != NULL)) {
assert(c_refCount(sample) > 1);
assert(admin->sampleCount > 0);
v_lifespanSample(sample->prev)->next = sample->next; /* transfer refcount */
sample->next->prev = sample->prev;
sample->next = NULL;
sample->prev = NULL;
c_free(sample);
admin->sampleCount--;
} /* else sample not in admin, so no removing needed */
}
}
CHECK_ADMIN(admin, sample);
}
void
v_cacheNodeRemove (
v_cacheNode node,
v_cacheKind kind)
{
struct v_cacheLink *nodeLink;
assert(C_TYPECHECK(node,v_cacheNode));
v_cacheNodeCheck(node);
switch (kind) {
case V_CACHE_OWNER:
nodeLink = &node->owner;
if (nodeLink->next != NULL) {
v_cacheNode(nodeLink->next)->owner.prev = nodeLink->prev;
}
if (nodeLink->prev != NULL) {
v_cacheNode(nodeLink->prev)->owner.next = nodeLink->next;
}
nodeLink->next = NULL;
nodeLink->prev = NULL;
v_cacheNodeCheck(node);
c_free(node);
break;
case V_CACHE_TARGETS:
nodeLink = &node->targets;
if (nodeLink->next != NULL) {
v_cacheNode(nodeLink->next)->targets.prev = nodeLink->prev;
}
if (nodeLink->prev != NULL) {
v_cacheNode(nodeLink->prev)->targets.next = nodeLink->next;
}
nodeLink->next = NULL;
nodeLink->prev = NULL;
v_cacheNodeCheck(node);
c_free(node);
break;
case V_CACHE_SOURCES:
v_cacheItem(node)->instance = NULL;
nodeLink = &node->sources;
if (nodeLink->next != NULL) {
v_cacheNode(nodeLink->next)->sources.prev = nodeLink->prev;
}
if (nodeLink->prev != NULL) {
v_cacheNode(nodeLink->prev)->sources.next = nodeLink->next;
}
nodeLink->next = NULL;
nodeLink->prev = NULL;
v_cacheNodeCheck(node);
c_free(node);
break;
case V_CACHE_ANY:
assert(c_refCount(node) > 1);
v_cacheNodeRemove(node,V_CACHE_OWNER);
v_cacheNodeRemove(node,V_CACHE_TARGETS);
break;
default:
break;
}
}
