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