int
rf_ConfigureAccessTrace(RF_ShutdownList_t **listp)
{
int rc;
numTracesSoFar = accessTraceBufCount = rf_stopCollectingTraces = 0;
if (rf_accessTraceBufSize) {
RF_Malloc(access_tracebuf, rf_accessTraceBufSize *
sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
accessTraceBufCount = 0;
}
traceCount = 0;
numTracesSoFar = 0;
rc = rf_mutex_init(&rf_tracing_mutex);
if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n",
__FILE__, __LINE__, rc);
}
rc = rf_ShutdownCreate(listp, rf_ShutdownAccessTrace, NULL);
if (rc) {
RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
" rc=%d.\n", __FILE__, __LINE__, rc);
if (rf_accessTraceBufSize) {
RF_Free(access_tracebuf, rf_accessTraceBufSize *
sizeof(RF_AccTraceEntry_t));
rf_mutex_destroy(&rf_tracing_mutex);
}
}
return (rc);
}
void
rf_ShutdownAccessTrace(void *ignored)
{
if (rf_accessTraceBufSize) {
if (accessTraceBufCount)
rf_FlushAccessTraceBuf();
RF_Free(access_tracebuf, rf_accessTraceBufSize *
sizeof(RF_AccTraceEntry_t));
}
rf_mutex_destroy(&rf_tracing_mutex);
}
void
rf_ShutdownAllocList(void *ignored)
{
RF_AllocListElem_t *p, *pt;
for (p = al_free_list; p;) {
pt = p;
p = p->next;
DO_FREE(pt, sizeof(*pt));
}
rf_mutex_destroy(&alist_mutex);
/*
* printf("Alloclist: Free list hit count %lu (%lu %%) miss count %lu"
* " (%lu %%).\n", fl_hit_count,
* (100*fl_hit_count)/(fl_hit_count+fl_miss_count),
* fl_miss_count, (100*fl_miss_count)/(fl_hit_count+fl_miss_count));
*/
}
int
rf_init_mcpair(RF_MCPair_t *t)
{
int rc;
rc = rf_mutex_init(&t->mutex);
if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n",
__FILE__, __LINE__, rc);
return (rc);
}
rc = rf_cond_init(&t->cond);
if (rc) {
RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n",
__FILE__, __LINE__, rc);
rf_mutex_destroy(&t->mutex);
return (rc);
}
return (0);
}
int
rf_ConfigureAllocList(RF_ShutdownList_t **listp)
{
int rc;
rc = rf_mutex_init(&alist_mutex);
if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n",
__FILE__, __LINE__, rc);
return (rc);
}
al_free_list = NULL;
fl_hit_count = fl_miss_count = al_free_list_count = 0;
rc = rf_ShutdownCreate(listp, rf_ShutdownAllocList, NULL);
if (rc) {
RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
" rc=%d.\n", __FILE__, __LINE__, rc);
rf_mutex_destroy(&alist_mutex);
return (rc);
}
return (0);
}
/*
* This function is really just for debugging user-level stuff: it
* frees up all memory, other RAIDframe resources which might otherwise
* be kept around. This is used with systems like "sentinel" to detect
* memory leaks.
*/
int
rf_UnbootRaidframe()
{
int rc;
RF_LOCK_MUTEX(configureMutex);
if (configureCount) {
RF_UNLOCK_MUTEX(configureMutex);
return (EBUSY);
}
raidframe_booted = 0;
RF_UNLOCK_MUTEX(configureMutex);
rc = rf_mutex_destroy(&configureMutex);
if (rc) {
RF_ERRORMSG3("Unable to destroy mutex file %s line %d rc=%d\n", __FILE__,
__LINE__, rc);
RF_PANIC();
}
#if RF_DEBUG_ATOMIC > 0
rf_atent_shutdown();
#endif /* RF_DEBUG_ATOMIC > 0 */
return (0);
}
void
rf_FreeReconMap(RF_ReconMap_t *mapPtr)
{
RF_ReconMapListElem_t *p, *q;
RF_ReconUnitCount_t numRUs;
RF_ReconUnitNum_t i;
numRUs = mapPtr->sectorsInDisk / mapPtr->sectorsPerReconUnit;
if (mapPtr->sectorsInDisk % mapPtr->sectorsPerReconUnit)
numRUs++;
for (i = 0; i < numRUs; i++) {
p = mapPtr->status[i];
while (p != RU_NOTHING && p != RU_ALL) {
q = p;
p = p->next;
RF_Free(q, sizeof(*q));
}
}
rf_mutex_destroy(&mapPtr->mutex);
RF_Free(mapPtr->status, mapPtr->totalRUs *
sizeof(RF_ReconMapListElem_t *));
RF_Free(mapPtr, sizeof(RF_ReconMap_t));
}
void
rf_clean_mcpair(RF_MCPair_t *t)
{
rf_mutex_destroy(&t->mutex);
rf_cond_destroy(&t->cond);
}
