cmx_readerSnapshot
cmx_readerSnapshotLookup(
const c_char* snapshot)
{
c_char* copy;
c_char* temp;
cmx_readerSnapshot s;
os_mutex m;
s = NULL;
if(snapshot != NULL){
copy = (c_char*)(os_malloc(strlen(snapshot) + 1));
os_strcpy(copy, snapshot);
temp = strtok((c_char*)copy, "</>"); /*<readerSnapshot>*/
temp = strtok(NULL, "</>"); /*<id>*/
temp = strtok(NULL, "</>"); /*... the pointer*/
if(temp != NULL){
sscanf(temp, PA_ADDRFMT, (c_address *)(&s));
m = cmx_getReaderSnapshotMutex();
os_mutexLock(&m);
if(c_iterContains(readerSnapshots, s) == FALSE){
s = NULL;
}
os_mutexUnlock(&m);
}
os_free(copy);
}
return s;
}
c_bool
u_readerContainsQuery(
u_reader _this,
u_query query)
{
c_bool found = FALSE;
os_result r;
if (_this && query) {
if(u_entityOwner(u_entity(_this))) {
r = os_mutexLock(&_this->mutex);
if (r == os_resultSuccess) {
found = c_iterContains(_this->queries,query);
os_mutexUnlock(&_this->mutex);
} else {
OS_REPORT(OS_WARNING,
"u_readerContainsQuery",0,
"Failed to lock Reader.");
}
}
} else {
OS_REPORT(OS_WARNING,
"u_readerRemoveQuery",0,
"Illegal parameter.");
}
return found;
}
static c_bool
walkProperty(
c_metaObject object,
c_metaWalkActionArg actionArg)
{
toolActionData actionData = (toolActionData)actionArg;
c_object o;
c_voidp addr;
o = c_iterObject(actionData->stack, 0);
if (c_baseObjectKind(object) == M_ATTRIBUTE) {
addr = C_DISPLACE(o, (c_address)c_property(object)->offset);
if (c_typeIsRef(c_property(object)->type)) {
addr = *(c_voidp *)addr;
if (c_baseObjectKind(c_property(object)->type) == M_COLLECTION) {
if (addr) {
if (c_iterContains(actionData->stack, addr)) {
printf("Ignore cyclic reference 0x"PA_ADDRFMT"\n",
(os_address)addr);
} else {
OBJECT_PUSH(actionData, addr);
iprintf("%s ",_METANAME(object));
printType(c_property(object)->type, actionData);
OBJECT_POP(actionData);
}
} else {
iprintf(" %s <0x"PA_ADDRFMT">", _METANAME(object), (os_address)addr);
}
} else {
iprintf(" %s <0x"PA_ADDRFMT">", _METANAME(object), (os_address)addr);
if (addr) {
/* Section for code to print additional type specific info. */
if (c_property(object)->type == v_topic_t) {
printf(" /* topic name is: %s */", v_topicName(addr));
}
if (c_property(object)->type == v_partition_t) {
printf(" /* Partition: %s */", v_partitionName(addr));
}
if (c_property(object)->type == c_type_t(c_getBase(object))) {
printf(" /* Type: %s */", _METANAME(c_type(addr)));
}
}
}
printf("\n");
} else {
OBJECT_PUSH(actionData, addr);
iprintf("%s ",_METANAME(object));
printType(c_property(object)->type, actionData);
printf("\n");
OBJECT_POP(actionData);
}
}
return TRUE;
}
c_bool
d_waitsetDetach(
d_waitset waitset,
d_waitsetEntity we)
{
u_result ur;
c_bool result = FALSE;
int i;
d_waitsetHelper helper;
helper = NULL;
assert(d_objectIsValid(d_object(waitset), D_WAITSET) == TRUE);
assert(d_objectIsValid(d_object(we), D_WAITSET_ENTITY) == TRUE);
if(waitset && we){
d_lockLock(d_lock(waitset));
if(c_iterContains(waitset->entities, we) == TRUE) {
if(waitset->runToCompletion == TRUE){
ur = u_waitsetDetach(waitset->uwaitset, u_entity(we->dispatcher));
} else {
for(i=0; i<c_iterLength(waitset->threads) && !helper; i++){
helper = d_waitsetHelper(c_iterObject(waitset->threads, i));
if(helper->entity != we){
helper = NULL;
}
}
assert(helper);
c_iterTake(waitset->threads, helper);
helper->terminate = TRUE;
u_waitsetNotify(helper->userWaitset, NULL);
os_threadWaitExit(helper->tid, NULL);
ur = u_waitsetDetach(helper->userWaitset, u_entity(we->dispatcher));
u_waitsetFree(helper->userWaitset);
os_free(helper);
}
if(ur == U_RESULT_OK) {
c_iterTake(waitset->entities, we);
we->waitset = NULL;
result = TRUE;
}
}
d_lockUnlock(d_lock(waitset));
}
return result;
}
c_bool
u_subscriberContainsReader(
u_subscriber _this,
u_reader reader)
{
c_bool found = FALSE;
u_result result;
result = u_entityLock(u_entity(_this));
if (result == U_RESULT_OK) {
found = c_iterContains(_this->readers,reader);
u_entityUnlock(u_entity(_this));
} else {
OS_REPORT(OS_WARNING,
"u_subscriberContainsReader",0,
"Failed to lock Subscriber.");
}
return found;
}
static c_bool
updatePartitions(
c_object o,
c_voidp arg)
{
v_partition d = v_partition(o);
struct updatePartitionsArg *a = (struct updatePartitionsArg *)arg;
if (c_iterContains(*(a->addPartitions), (void *)d)) {
c_iterTake(*(a->addPartitions), (void *)d);
/* remove since we already know the partition */
c_free(d);
} else {
/* add to remove list, we are no longer interested */
*(a->removePartitions) = c_iterInsert(*(a->removePartitions), c_keep(d));
}
return TRUE; /* never break the walk */
}
jni_result
jni_deleteTopic(
jni_participant p,
jni_topic top)
{
jni_result r;
c_bool found;
if((top == NULL) || (p == NULL)){
r = JNI_RESULT_BAD_PARAMETER;
}
else if(p->topics == NULL){
r = JNI_RESULT_PRECONDITION_NOT_MET;
}
else if( (jni_topicDescription(top)->participant) != p ){
r = JNI_RESULT_PRECONDITION_NOT_MET;
}
else if(!(jni_participantMayTopicBeDeleted(p, jni_topicDescription(top)->name))){
r = JNI_RESULT_PRECONDITION_NOT_MET;
}
else{
found = c_iterContains(p->topics, top);
if(!found){
r = JNI_RESULT_PRECONDITION_NOT_MET;
}
else{
r = jni_topicFree(top);
if(r == JNI_RESULT_OK){
c_iterTake(p->topics, top);
}
}
}
return r;
}
c_bool
d_waitsetAttach(
d_waitset waitset,
d_waitsetEntity we)
{
c_bool result = FALSE;
u_result ur;
os_result osr;
d_waitsetHelper helper;
c_ulong mask;
d_admin admin;
d_durability durability;
assert(d_objectIsValid(d_object(waitset), D_WAITSET) == TRUE);
assert(d_objectIsValid(d_object(we), D_WAITSET_ENTITY) == TRUE);
if(waitset && we){
d_lockLock(d_lock(waitset));
if(!we->waitset) {
if(c_iterContains(waitset->entities, we) == FALSE) {
waitset->entities = c_iterInsert(waitset->entities, we);
if(waitset->runToCompletion == TRUE){
ur = u_waitsetAttach(waitset->uwaitset, u_entity(we->dispatcher),
(c_voidp)we->dispatcher);
if(ur == U_RESULT_OK) {
we->waitset = waitset;
result = TRUE;
}
} else {
admin = d_subscriberGetAdmin(waitset->subscriber);
durability = d_adminGetDurability(admin);
helper = os_malloc(C_SIZEOF(d_waitsetHelper));
helper->waitset = waitset;
helper->entity = we;
helper->terminate = FALSE;
helper->tid = OS_THREAD_ID_NONE;
helper->userWaitset = u_waitsetNew(u_participant(d_durabilityGetService(durability)));
mask = V_EVENT_DATA_AVAILABLE;
mask |= V_EVENT_NEW_GROUP;
mask |= V_EVENT_HISTORY_DELETE;
mask |= V_EVENT_HISTORY_REQUEST;
mask |= V_EVENT_PERSISTENT_SNAPSHOT;
mask |= V_EVENT_TRIGGER;
u_waitsetSetEventMask(helper->userWaitset, mask);
ur = u_waitsetAttach(helper->userWaitset, u_entity(we->dispatcher),
(c_voidp)we->dispatcher);
if(ur != U_RESULT_OK) {
assert(FALSE);
} else {
result = TRUE;
}
if(result){
waitset->threads = c_iterInsert(waitset->threads, helper);
osr = os_threadCreate(&(helper->tid), we->name, &(we->attr),
d_waitsetEventHandler, helper);
if(osr != os_resultSuccess){
c_iterTake(waitset->threads, helper);
u_waitsetDetach(helper->userWaitset, u_entity(we->dispatcher));
u_waitsetFree(helper->userWaitset);
os_free(helper);
result = FALSE;
}
} else {
u_waitsetFree(helper->userWaitset);
os_free(helper);
}
}
}
}
d_lockUnlock(d_lock(waitset));
}
return result;
}