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