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);
}
int
rf_ConfigureAccessTrace(RF_ShutdownList_t **listp)
{
numTracesSoFar = 0;
rf_init_mutex2(rf_tracing_mutex, IPL_VM);
rf_ShutdownCreate(listp, rf_ShutdownAccessTrace, NULL);
return (0);
}
int
rf_ConfigureNWayXor(RF_ShutdownList_t **listp)
{
int i;
for (i = 0; i < 10; i++)
callcount[i] = 0;
rf_ShutdownCreate(listp, rf_ShutdownNWayXor, NULL);
return (0);
}
static int
rf_ConfigureRDFreeList(RF_ShutdownList_t **listp)
{
rf_pool_init(&rf_pools.rad, sizeof(RF_RaidAccessDesc_t),
"rf_rad_pl", RF_MIN_FREE_RAD, RF_MAX_FREE_RAD);
rf_ShutdownCreate(listp, rf_ShutdownRDFreeList, NULL);
simple_lock_init(&rf_rad_lock);
return (0);
}
int
rf_ConfigurePSStatus(RF_ShutdownList_t **listp)
{
rf_pool_init(&rf_pools.pss, sizeof(RF_ReconParityStripeStatus_t),
"raidpsspl", RF_MIN_FREE_PSS, RF_MAX_FREE_PSS);
rf_ShutdownCreate(listp, rf_ShutdownPSStatus, NULL);
return (0);
}
int
rf_ConfigureDiskQueueSystem(RF_ShutdownList_t **listp)
{
rf_pool_init(&rf_pools.dqd, sizeof(RF_DiskQueueData_t),
"rf_dqd_pl", RF_MIN_FREE_DQD, RF_MAX_FREE_DQD);
rf_ShutdownCreate(listp, rf_ShutdownDiskQueueSystem, NULL);
return (0);
}
int
rf_ConfigureReconEvent(RF_ShutdownList_t **listp)
{
rf_pool_init(&rf_pools.revent, sizeof(RF_ReconEvent_t),
"rf_revent_pl", RF_MIN_FREE_REVENT, RF_MAX_FREE_REVENT);
rf_ShutdownCreate(listp, rf_ShutdownReconEvent, NULL);
return (0);
}
int
rf_ConfigureDeclusteredDS(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
RF_Config_t *cfgPtr)
{
int rc;
rc = rf_ConfigureDeclustered(listp, raidPtr, cfgPtr);
if (rc)
return (rc);
rf_ShutdownCreate(listp, rf_ShutdownDeclusteredDS, raidPtr);
return (0);
}
int
rf_ConfigureEngine(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
RF_Config_t *cfgPtr)
{
rf_mutex_init(&raidPtr->node_queue_mutex);
raidPtr->node_queue = NULL;
raidPtr->dags_in_flight = 0;
/* we create the execution thread only once per system boot. no need
* to check return code b/c the kernel panics if it can't create the
* thread. */
#if RF_DEBUG_ENGINE
if (rf_engineDebug) {
printf("raid%d: Creating engine thread\n", raidPtr->raidid);
}
#endif
if (RF_CREATE_ENGINE_THREAD(raidPtr->engine_thread,
DAGExecutionThread, raidPtr,
"raid%d", raidPtr->raidid)) {
printf("raid%d: Unable to create engine thread\n",
raidPtr->raidid);
return (ENOMEM);
}
if (RF_CREATE_ENGINE_THREAD(raidPtr->engine_helper_thread,
rf_RaidIOThread, raidPtr,
"raidio%d", raidPtr->raidid)) {
printf("raid%d: Unable to create raidio thread\n",
raidPtr->raidid);
return (ENOMEM);
}
#if RF_DEBUG_ENGINE
if (rf_engineDebug) {
printf("raid%d: Created engine thread\n", raidPtr->raidid);
}
#endif
/* engine thread is now running and waiting for work */
#if RF_DEBUG_ENGINE
if (rf_engineDebug) {
printf("raid%d: Engine thread running and waiting for events\n", raidPtr->raidid);
}
#endif
rf_ShutdownCreate(listp, rf_ShutdownEngine, raidPtr);
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);
}
int
rf_Configure(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr, RF_AutoConfig_t *ac)
{
RF_RowCol_t col;
int rc;
RF_LOCK_LKMGR_MUTEX(configureMutex);
configureCount++;
if (isconfigged == 0) {
rf_mutex_init(&rf_printf_mutex);
/* initialize globals */
DO_INIT_CONFIGURE(rf_ConfigureAllocList);
/*
* Yes, this does make debugging general to the whole
* system instead of being array specific. Bummer, drag.
*/
rf_ConfigureDebug(cfgPtr);
DO_INIT_CONFIGURE(rf_ConfigureDebugMem);
#if RF_ACC_TRACE > 0
DO_INIT_CONFIGURE(rf_ConfigureAccessTrace);
#endif
DO_INIT_CONFIGURE(rf_ConfigureMapModule);
DO_INIT_CONFIGURE(rf_ConfigureReconEvent);
DO_INIT_CONFIGURE(rf_ConfigureCallback);
DO_INIT_CONFIGURE(rf_ConfigureRDFreeList);
DO_INIT_CONFIGURE(rf_ConfigureNWayXor);
DO_INIT_CONFIGURE(rf_ConfigureStripeLockFreeList);
DO_INIT_CONFIGURE(rf_ConfigureMCPair);
DO_INIT_CONFIGURE(rf_ConfigureDAGs);
DO_INIT_CONFIGURE(rf_ConfigureDAGFuncs);
DO_INIT_CONFIGURE(rf_ConfigureReconstruction);
DO_INIT_CONFIGURE(rf_ConfigureCopyback);
DO_INIT_CONFIGURE(rf_ConfigureDiskQueueSystem);
DO_INIT_CONFIGURE(rf_ConfigurePSStatus);
isconfigged = 1;
}
RF_UNLOCK_LKMGR_MUTEX(configureMutex);
DO_RAID_MUTEX(&raidPtr->mutex);
/* set up the cleanup list. Do this after ConfigureDebug so that
* value of memDebug will be set */
rf_MakeAllocList(raidPtr->cleanupList);
if (raidPtr->cleanupList == NULL) {
DO_RAID_FAIL();
return (ENOMEM);
}
rf_ShutdownCreate(&raidPtr->shutdownList,
(void (*) (void *)) rf_FreeAllocList,
raidPtr->cleanupList);
raidPtr->numCol = cfgPtr->numCol;
raidPtr->numSpare = cfgPtr->numSpare;
raidPtr->status = rf_rs_optimal;
raidPtr->reconControl = NULL;
TAILQ_INIT(&(raidPtr->iodone));
simple_lock_init(&(raidPtr->iodone_lock));
DO_RAID_INIT_CONFIGURE(rf_ConfigureEngine);
DO_RAID_INIT_CONFIGURE(rf_ConfigureStripeLocks);
raidPtr->outstandingCond = 0;
raidPtr->nAccOutstanding = 0;
raidPtr->waitShutdown = 0;
DO_RAID_MUTEX(&raidPtr->access_suspend_mutex);
raidPtr->waitForReconCond = 0;
if (ac!=NULL) {
/* We have an AutoConfig structure.. Don't do the
normal disk configuration... call the auto config
stuff */
rf_AutoConfigureDisks(raidPtr, cfgPtr, ac);
} else {
DO_RAID_INIT_CONFIGURE(rf_ConfigureDisks);
DO_RAID_INIT_CONFIGURE(rf_ConfigureSpareDisks);
}
/* do this after ConfigureDisks & ConfigureSpareDisks to be sure dev
* no. is set */
DO_RAID_INIT_CONFIGURE(rf_ConfigureDiskQueues);
DO_RAID_INIT_CONFIGURE(rf_ConfigureLayout);
/* Initialize per-RAID PSS bits */
rf_InitPSStatus(raidPtr);
#if RF_INCLUDE_CHAINDECLUSTER > 0
for (col = 0; col < raidPtr->numCol; col++) {
/*
* XXX better distribution
*/
raidPtr->hist_diskreq[col] = 0;
}
#endif
raidPtr->numNewFailures = 0;
raidPtr->copyback_in_progress = 0;
raidPtr->parity_rewrite_in_progress = 0;
raidPtr->adding_hot_spare = 0;
raidPtr->recon_in_progress = 0;
raidPtr->maxOutstanding = cfgPtr->maxOutstandingDiskReqs;
/* autoconfigure and root_partition will actually get filled in
after the config is done */
raidPtr->autoconfigure = 0;
raidPtr->root_partition = 0;
raidPtr->last_unit = raidPtr->raidid;
raidPtr->config_order = 0;
if (rf_keepAccTotals) {
raidPtr->keep_acc_totals = 1;
}
/* Allocate a bunch of buffers to be used in low-memory conditions */
raidPtr->iobuf = NULL;
rc = rf_AllocEmergBuffers(raidPtr);
if (rc) {
printf("raid%d: Unable to allocate emergency buffers.\n",
raidPtr->raidid);
DO_RAID_FAIL();
return(rc);
}
/* Set up parity map stuff, if applicable. */
#ifndef RF_NO_PARITY_MAP
rf_paritymap_attach(raidPtr, cfgPtr->force);
#endif
raidPtr->valid = 1;
printf("raid%d: %s\n", raidPtr->raidid,
raidPtr->Layout.map->configName);
printf("raid%d: Components:", raidPtr->raidid);
for (col = 0; col < raidPtr->numCol; col++) {
printf(" %s", raidPtr->Disks[col].devname);
if (RF_DEAD_DISK(raidPtr->Disks[col].status)) {
printf("[**FAILED**]");
}
}
printf("\n");
printf("raid%d: Total Sectors: %" PRIu64 " (%" PRIu64 " MB)\n",
raidPtr->raidid,
raidPtr->totalSectors,
(raidPtr->totalSectors / 1024 *
(1 << raidPtr->logBytesPerSector) / 1024));
return (0);
}
