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