void sptrace_clear(PsmPartition trace) { PsmAddress traceHeaderAddress; TraceHeader *trh; PsmAddress elt; PsmAddress nextElt; PsmAddress itemAddress; TraceItem *item; if (!trace) return; traceHeaderAddress = psm_get_root(trace); trh = (TraceHeader *) psp(trace, traceHeaderAddress); CHKVOID(trh); for (elt = sm_list_first(trace, trh->log); elt; elt = nextElt) { nextElt = sm_list_next(trace, elt); itemAddress = sm_list_data(trace, elt); item = (TraceItem *) psp(trace, itemAddress); CHKVOID(item); if (item->opType == OP_ALLOCATE || item->opType == OP_FREE) { if (item->refOpNbr == 0) { continue; /* Not matched. */ } /* Delete matched activity from log. */ psm_free(trace, itemAddress); CHKVOID(sm_list_delete(trace, elt, NULL, NULL) == 0); } } }
void removeEmbargo(IonNode *node, uvast neighborNodeNbr) { PsmPartition ionwm = getIonwm(); PsmAddress elt; PsmAddress addr; Embargo *embargo; CHKVOID(node); for (elt = sm_list_first(ionwm, node->embargoes); elt; elt = sm_list_next(ionwm, elt)) { addr = sm_list_data(ionwm, elt); embargo = (Embargo *) psp(ionwm, addr); CHKVOID(embargo); if (embargo->nodeNbr < neighborNodeNbr) { continue; } if (embargo->nodeNbr > neighborNodeNbr) { return; /* Embargo not found. */ } break; /* Found the embargo to remove. */ } if (elt == 0) { return; /* Embargo not found. */ } oK(sm_list_delete(ionwm, elt, NULL, NULL)); psm_free(ionwm, addr); }
void dtn2_destroyDirective(FwdDirective *directive) { Sdr sdr = getIonsdr(); CHKVOID(directive); if (directive->action == fwd) { CHKVOID(sdr_begin_xn(sdr)); sdr_free(sdr, directive->eid); if (sdr_end_xn(sdr) < 0) { putErrmsg("Can't destroy directive EID.", NULL); } return; } if (directive->action == xmit) { if (directive->destDuctName) { CHKVOID(sdr_begin_xn(sdr)); sdr_free(sdr, directive->destDuctName); if (sdr_end_xn(sdr) < 0) { putErrmsg("Can't destroy destDuctName.", NULL); } } } }
void dtn2_findPlan(char *nodeNm, Object *planAddr, Object *eltp) { Sdr sdr = getIonsdr(); char nodeName[SDRSTRING_BUFSZ]; Object elt; /* This function finds the Dtn2Plan for the specified * node, if any. */ CHKVOID(ionLocked()); CHKVOID(nodeNm && planAddr && eltp); *eltp = 0; if (filterNodeName(nodeName, nodeNm) < 0) { return; } elt = locatePlan(nodeName, NULL); if (elt == 0) { return; } *planAddr = sdr_list_data(sdr, elt); *eltp = elt; }
void Lyst_delete(char *file, int line, LystElt elt) { Lyst list; if (elt == NULL) { return; } list = elt->lyst; CHKVOID(list); CHKVOID(list->length > 0); if (list->delete_cb != NULL) list->delete_cb(elt,list->delete_arg); /* update previous pointers */ if (elt->prev != NULL) elt->prev->next = elt->next; else list->first = elt->next; /* update following pointers */ if (elt->next != NULL) elt->next->prev = elt->prev; else list->last = elt->prev; /* free memory associated with this element */ lyst__elt_clear(elt); /* just in case user accesses later... */ lyst__free(file, line, list->alloc_idx, (char *) elt); list->length -= 1; }
void sm_list_unwedge(PsmPartition partition, PsmAddress list, int interval) { SmList *listBuffer; CHKVOID(partition); listBuffer = (SmList *) psp(partition, list); CHKVOID(listBuffer); sm_SemUnwedge(listBuffer->lock, interval); }
void sm_rbt_unwedge(PsmPartition partition, PsmAddress rbt, int interval) { SmRbt *rbtPtr; CHKVOID(partition); CHKVOID(rbt); rbtPtr = (SmRbt *) psp(partition, rbt); CHKVOID(rbtPtr); sm_SemUnwedge(rbtPtr->lock, interval); }
void lyst_delete_get(Lyst list, LystCallback *fn, void **arg) { if (list != NULL) { CHKVOID(fn); CHKVOID(arg); *fn = list->delete_cb; *arg = list->delete_arg; } }
void lyst_insert_get(Lyst list, LystCallback *fn, void **arg) { if (list != NULL) { CHKVOID(fn); CHKVOID(arg); *fn = list->insert_cb; *arg = list->insert_arg; } }
void Sm_rbt_clear(char *file, int line, PsmPartition partition, PsmAddress rbt, SmRbtDeleteFn deleteFn, void *arg) { SmRbt *rbtPtr; CHKVOID(partition); CHKVOID(rbt); rbtPtr = (SmRbt *) psp(partition, rbt); oK(lockSmrbt(rbtPtr)); destroyRbtNodes(file, line, partition, rbtPtr, deleteFn, arg); unlockSmrbt(rbtPtr); }
void dtn2_findRule(char *nodeNm, char *demux, Dtn2Plan *plan, Object *ruleAddr, Object *eltp) { Sdr sdr = getIonsdr(); char nodeName[SDRSTRING_BUFSZ]; Object elt; OBJ_POINTER(Dtn2Plan, planPtr); /* This function finds the Dtn2Rule for the specified * demux token, for the specified destination node, if * any. */ CHKVOID(ionLocked()); CHKVOID(ruleAddr); CHKVOID(eltp); *eltp = 0; if (plan == NULL) { if (nodeNm == NULL) { return; } if (filterNodeName(nodeName, nodeNm) < 0) { return; } elt = locatePlan(nodeName, NULL); if (elt == 0) { return; } GET_OBJ_POINTER(sdr, Dtn2Plan, planPtr, sdr_list_data(sdr, elt)); plan = planPtr; } elt = locateRule(plan, demux, NULL); if (elt == 0) { return; } *ruleAddr = sdr_list_data(sdr, elt); *eltp = elt; }
void bp_release_delivery(BpDelivery *dlvBuffer, int releasePayload) { Sdr sdr = getIonsdr(); CHKVOID(dlvBuffer); if (dlvBuffer->result == BpPayloadPresent) { if (dlvBuffer->bundleSourceEid) { MRELEASE(dlvBuffer->bundleSourceEid); dlvBuffer->bundleSourceEid = NULL; } if (releasePayload) { if (dlvBuffer->adu) { sdr_begin_xn(sdr); zco_destroy_reference(sdr, dlvBuffer->adu); if (sdr_end_xn(sdr) < 0) { putErrmsg("Failed releasing delivery.", NULL); } dlvBuffer->adu = 0; } } } }
static void executeList(int tokenCount, char **tokens) { Sdr sdr = getIonsdr(); PsmPartition ionwm = getIonwm(); IonVdb *vdb = getIonVdb(); PsmAddress elt; PsmAddress addr; char buffer[RFX_NOTE_LEN]; if (tokenCount < 2) { printText("List what?"); return; } if (strcmp(tokens[1], "contact") == 0) { CHKVOID(sdr_begin_xn(sdr)); for (elt = sm_rbt_first(ionwm, vdb->contactIndex); elt; elt = sm_rbt_next(ionwm, elt)) { addr = sm_rbt_data(ionwm, elt); rfx_print_contact(addr, buffer); printText(buffer); } sdr_exit_xn(sdr); return; } if (strcmp(tokens[1], "range") == 0) { CHKVOID(sdr_begin_xn(sdr)); for (elt = sm_rbt_first(ionwm, vdb->rangeIndex); elt; elt = sm_rbt_next(ionwm, elt)) { addr = sm_rbt_data(ionwm, elt); rfx_print_range(addr, buffer); printText(buffer); } sdr_exit_xn(sdr); return; } SYNTAX_ERROR; }
void sm_rbt_user_data_set(PsmPartition partition, PsmAddress rbt, PsmAddress data) { SmRbt *rbtPtr; CHKVOID(partition); CHKVOID(rbt); rbtPtr = (SmRbt *) psp(partition, rbt); CHKVOID(rbtPtr); if (lockSmrbt(rbtPtr) == ERROR) { return; } rbtPtr->userData = data; unlockSmrbt(rbtPtr); }
void sdrnm_state_get(SdrnmState *state) { Sdr sdr = getIonsdr(); SdrUsageSummary usage; CHKVOID(state); CHKVOID(sdr_begin_xn(sdr)); sdr_usage(sdr, &usage); state->smallPoolSize = usage.smallPoolSize; state->smallPoolFree = usage.smallPoolFree; state->smallPoolAllocated = usage.smallPoolAllocated; state->largePoolSize = usage.largePoolSize; state->largePoolFree = usage.largePoolFree; state->largePoolAllocated = usage.largePoolAllocated; state->unusedSize = usage.unusedSize; sdr_exit_xn(sdr); }
void psm_erase(PsmPartition partition) { PartitionMap *map; CHKVOID(partition); map = (PartitionMap *) (partition->space); psm_unmanage(partition); /* Locks partition. */ map->status = 0; }
void psm_relax(PsmPartition partition) { PartitionMap *map; CHKVOID(partition); map = (PartitionMap *) (partition->space); lockPartition(map); map->desperate = 0; unlockPartition(map); }
void writeTimestampUTC(time_t timestamp, char *timestampBuffer) { struct tm ts; CHKVOID(timestampBuffer); gmtime_r(×tamp, &ts); isprintf(timestampBuffer, 20, timestampOutFormat, ts.tm_year + 1900, ts.tm_mon + 1, ts.tm_mday, ts.tm_hour, ts.tm_min, ts.tm_sec); }
void psm_erase_root(PsmPartition partition) { PartitionMap *map; CHKVOID(partition); map = (PartitionMap *) (partition->space); lockPartition(map); map->directory = 0; unlockPartition(map); }
void Sm_rbt_destroy(char *file, int line, PsmPartition partition, PsmAddress rbt, SmRbtDeleteFn deleteFn, void *arg) { SmRbt *rbtPtr; CHKVOID(partition); CHKVOID(rbt); rbtPtr = (SmRbt *) psp(partition, rbt); oK(lockSmrbt(rbtPtr)); destroyRbtNodes(file, line, partition, rbtPtr, deleteFn, arg); /* Now destroy the tree itself. */ sm_SemDelete(rbtPtr->lock); /* just in case user mistakenly accesses later... */ eraseTree(rbtPtr); Psm_free(file, line, partition, rbt); }
void ionVacate(int size) { Sdr ionsdr = _ionsdr(NULL); Object iondbObject = _iondbObject(NULL); IonDB iondbBuf; CHKVOID(ionLocked()); CHKVOID(size >= 0); sdr_stage(ionsdr, (char *) &iondbBuf, iondbObject, sizeof(IonDB)); if (size > iondbBuf.currentOccupancy) /* Underflow. */ { iondbBuf.currentOccupancy = 0; } else { iondbBuf.currentOccupancy -= size; } sdr_write(ionsdr, iondbObject, (char *) &iondbBuf, sizeof(IonDB)); }
void ionOccupy(int size) { Sdr ionsdr = _ionsdr(NULL); Object iondbObject = _iondbObject(NULL); IonDB iondbBuf; CHKVOID(ionLocked()); CHKVOID(size >= 0); sdr_stage(ionsdr, (char *) &iondbBuf, iondbObject, sizeof(IonDB)); if (iondbBuf.currentOccupancy + size < 0)/* Overflow. */ { iondbBuf.currentOccupancy = iondbBuf.occupancyCeiling; } else { iondbBuf.currentOccupancy += size; } sdr_write(ionsdr, iondbObject, (char *) &iondbBuf, sizeof(IonDB)); }
void sptrace_log_free(PsmPartition trace, unsigned long addr, char *fileName, int lineNbr) { PsmAddress elt; TraceItem *item; TraceItem *refitem; if (!trace) return; logEvent(trace, OP_FREE, addr, -1, NULL, fileName, lineNbr, &elt); if (elt) /* Event was logged. */ { item = (TraceItem *) psp(trace, sm_list_data(trace, elt)); /* Find matching allocation, close it out. */ elt = sm_list_prev(trace, elt); while (elt) { refitem = (TraceItem *) psp(trace, sm_list_data(trace, elt)); CHKVOID(refitem); if (refitem->objectAddress != item->objectAddress) { elt = sm_list_prev(trace, elt); continue; } /* Found match. */ switch (refitem->opType) { case OP_MEMO: /* Ignore it. */ elt = sm_list_prev(trace, elt); continue; case OP_FREE: /* Duplicate free. */ return; } /* Found most recent open allocation. */ item->refTaskId = refitem->taskId; item->refFileName = refitem->fileName; item->refLineNbr = refitem->lineNbr; item->refOpNbr = refitem->opNbr; item->objectSize = refitem->objectSize; refitem->refTaskId = item->taskId; refitem->refFileName = item->fileName; refitem->refLineNbr = item->lineNbr; refitem->refOpNbr = item->opNbr; return; } } }
static void lockPartition(PartitionMap *map) { int selfTask; pthread_t selfThread; CHKVOID(map->status == MANAGED); selfTask = sm_TaskIdSelf(); selfThread = pthread_self(); if (map->ownerTask == selfTask && pthread_equal(map->ownerThread, selfThread)) { map->depth++; return; } CHKVOID(map->semaphore != -1); oK(sm_SemTake(map->semaphore)); map->ownerThread = selfThread; map->ownerTask = selfTask; map->depth = 1; }
void inferUtcDelta(char *correctUtcTimeStamp) { IonVdb *ionvdb = getIonVdb(); time_t correctUtcTime = readTimestampUTC(correctUtcTimeStamp, 0); time_t clocktime = getUTCTime() + ionvdb->deltaFromUTC; int delta = clocktime - correctUtcTime; char buffer[80]; CHKVOID(setDeltaFromUTC(delta) == 0); sprintf(buffer, "[i] Delta from UTC revised, is now %d.", delta); writeMemo(buffer); }
static void executeInfo(int tokenCount, char **tokens) { Sdr sdr = getIonsdr(); ImcDB imcdb; if (tokenCount != 2) { SYNTAX_ERROR; return; } CHKVOID(sdr_begin_xn(sdr)); sdr_read(getIonsdr(), (char *) &imcdb, getImcDbObject(), sizeof(ImcDB)); printKin(strtouvast(tokens[1]), imcdb.parent); sdr_exit_xn(sdr); }
void ltpei_discard_extensions(Lyst extensions) { LystElt elt; LtpExtensionInbound *ext; CHKVOID(extensions); while ((elt = lyst_first(extensions)) != NULL) { ext = (LtpExtensionInbound *) lyst_data(elt); if (ext->value) { MRELEASE(ext->value); } MRELEASE(ext); lyst_delete(elt); } lyst_destroy(extensions); }
void psm_unmanage(PsmPartition partition) { PartitionMap *map; CHKVOID(partition); map = (PartitionMap *) (partition->space); if (map->status == MANAGED) { /* Wait for partition to be no longer in use; unmanage. */ sm_SemTake(map->semaphore); sm_SemDelete(map->semaphore); map->status = INITIALIZED; } /* Destroy space management structure if necessary. */ if (partition->freeNeeded) { free(partition); } }
void listCustodianInfo(void (*printer)(const char *)) { Object custodianLElt; Object custodianAddr; SdrAcsPendingCust custodian; char buffer[1024]; CHKVOID(sdr_begin_xn(acsSdr)); for(custodianLElt = sdr_list_first(acsSdr, acsConstants->pendingCusts); custodianLElt; custodianLElt = sdr_list_next(acsSdr, custodianLElt)) { custodianAddr = sdr_list_data(acsSdr, custodianLElt); sdr_peek(acsSdr, custodian, custodianAddr); snprintf(buffer, sizeof(buffer), "%.*s\tDelay: %lu Size: %lu", MAX_EID_LEN, custodian.eid, custodian.acsDelay, custodian.acsSize); printer(buffer); } oK(sdr_end_xn(acsSdr)); }
void bp_untrack(Object bundleObj, Object trackingElt) { Sdr sdr = getIonsdr(); OBJ_POINTER(Bundle, bundle); Object elt; CHKVOID(bundleObj && trackingElt); sdr_begin_xn(sdr); GET_OBJ_POINTER(sdr, Bundle, bundle, bundleObj); if (bundle->trackingElts == 0) { sdr_exit_xn(sdr); return; } for (elt = sdr_list_first(sdr, bundle->trackingElts); elt; elt = sdr_list_next(sdr, elt)) { if (sdr_list_data(sdr, elt) == trackingElt) { break; } } if (elt == 0) /* Not found. */ { sdr_exit_xn(sdr); return; } sdr_list_delete(sdr, elt, NULL, NULL); if (sdr_end_xn(sdr) < 0) { putErrmsg("Failed removing bundle tracking elt.", NULL); } }