bool GrpAdminSetGetFeatCombo::RestoreTLER(SharedASQPtr asq, SharedACQPtr acq) { SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); SharedSetFeaturesPtr setFeaturesCmd = SharedSetFeaturesPtr(new SetFeatures()); LOG_NRM("Restoring state with TLER = 0x%04X", mTimeLimErrRec); setFeaturesCmd->SetFID(FID[FID_ERR_RECOVERY]); getFeaturesCmd->SetFID(FID[FID_ERR_RECOVERY]); setFeaturesCmd->SetDword(mTimeLimErrRec, 11); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, setFeaturesCmd, "RestoreTLER", true); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "RestoreTLER", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); if (mTimeLimErrRec != ce.t.dw0) { LOG_ERR("TLER restore to original state failed. " "(Actual: Expected) = (0x%04X:0x%04X)", ce.t.dw0, mTimeLimErrRec); return false; } return true; }
bool GrpAdminSetGetFeatCombo::RestoreTMPTH(SharedASQPtr asq, SharedACQPtr acq) { SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); SharedSetFeaturesPtr setFeaturesCmd = SharedSetFeaturesPtr(new SetFeatures()); LOG_NRM("Restoring state with TMPTH = 0x%04X", mTmpThreshold); setFeaturesCmd->SetFID(BaseFeatures::FID_TEMP_THRESHOLD); getFeaturesCmd->SetFID(BaseFeatures::FID_TEMP_THRESHOLD); setFeaturesCmd->SetDword(mTmpThreshold, 11); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, setFeaturesCmd, "RestoreTMPTH", true); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "RestoreTMPTH", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); if (mTmpThreshold != ce.t.dw0) { LOG_ERR("TMPTH restore to original state failed. " "(Actual: Expected) = (0x%04X:0x%04X)", ce.t.dw0, mTmpThreshold); return false; } return true; }
bool GrpAdminSetGetFeatCombo::RestoreAsyncEvent(SharedASQPtr asq, SharedACQPtr acq) { SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); SharedSetFeaturesPtr setFeaturesCmd = SharedSetFeaturesPtr(new SetFeatures()); LOG_NRM("Restoring state with mAsyncEvent = 0x%04X", mAsyncEvent); setFeaturesCmd->SetFID(FID[FID_ASYNC_EVENT_CONFIG]); getFeaturesCmd->SetFID(FID[FID_ASYNC_EVENT_CONFIG]); setFeaturesCmd->SetDword(mAsyncEvent, 11); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, setFeaturesCmd, "RestoreWrAtomicity", true); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "RestoreAsyncEvent", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); if (mAsyncEvent != ce.t.dw0) { LOG_ERR("AsyncEvent restore to original state failed. " "(Actual: Expected) = (0x%04X:0x%04X)", ce.t.dw0, mAsyncEvent); return false; } return true; }
bool GrpAdminSetGetFeatCombo::RestoreIRQCoalescing(SharedASQPtr asq, SharedACQPtr acq) { SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); SharedSetFeaturesPtr setFeaturesCmd = SharedSetFeaturesPtr(new SetFeatures()); LOG_NRM("Restoring state with IRQCoalescing = 0x%04X", mIrqCoalescing); setFeaturesCmd->SetFID(FID[FID_IRQ_COALESCING]); getFeaturesCmd->SetFID(FID[FID_IRQ_COALESCING]); setFeaturesCmd->SetDword(mIrqCoalescing, 11); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, setFeaturesCmd, "RestoreIRQCoalescing", true); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "RestoreIRQCoalescing", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); if (mIrqCoalescing != ce.t.dw0) { LOG_ERR("IRQCoalescing restore to original state failed. " "(Actual: Expected) = (0x%04X:0x%04X)", ce.t.dw0, mIrqCoalescing); return false; } return true; }
void AdminQRollChkDiff_r10b::VerifyCESQValues(SharedACQPtr acq, uint16_t expectedVal) { union CE ce; struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); // The CQ's metrics after reaping holds head_ptr plus 1 needed. Also Take // Q roll over into account if (acqMetrics.head_ptr == 0) { ce = acq->PeekCE(acq->GetNumEntries() - 1); } else { ce = acq->PeekCE(acqMetrics.head_ptr - 1); } if (ce.n.SQID != 0) { acq->Dump( FileSystem::PrepDumpFile(mGrpName, mTestName, "acq", "CE.SQID"), "CE SQ ID Inconsistent"); throw FrmwkEx(HERE, "Expected CE.SQID = 0 in ACQ completion entry but actual " "CE.SQID = 0x%04X", ce.n.SQID); } if (ce.n.SQHD != expectedVal) { acq->Dump( FileSystem::PrepDumpFile(mGrpName, mTestName, "acq", "CE.SQHD"), "CE SQ Head Pointer Inconsistent"); throw FrmwkEx(HERE, "Expected CE.SQHD = 0x%04X in ACQ completion entry but actual " "CE.SQHD = 0x%04X", expectedVal, ce.n.SQHD); } }
bool GrpAdminSetGetFeatCombo::RestoreVolWrCache(SharedASQPtr asq, SharedACQPtr acq) { SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); SharedSetFeaturesPtr setFeaturesCmd = SharedSetFeaturesPtr(new SetFeatures()); LOG_NRM("Restoring state with VWC = 0x%04X", mVolWrCache); setFeaturesCmd->SetFID(FID[FID_VOL_WR_CACHE]); getFeaturesCmd->SetFID(FID[FID_VOL_WR_CACHE]); setFeaturesCmd->SetDword(mVolWrCache, 11); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, setFeaturesCmd, "RestoreVWC", true); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "RestoreVWC", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); if (mVolWrCache != ce.t.dw0) { LOG_ERR("VWC restore to original state failed. " "(Actual: Expected) = (0x%04X:0x%04X)", ce.t.dw0, mVolWrCache); return false; } return true; }
void GrpAdminSetGetFeatCombo::SavePowerState(SharedASQPtr asq, SharedACQPtr acq) { LOG_NRM("Create Get features cmd"); SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); getFeaturesCmd->SetFID(FID[FID_PWR_MGMT]); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "SaveFeatPwrMgmt", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); mPowerState = ce.t.dw0; LOG_NRM("Default power state using Get Features = 0x%04X", mPowerState); }
void GrpAdminSetGetFeatCombo::SaveTMPTH(SharedASQPtr asq, SharedACQPtr acq) { LOG_NRM("Create Get features cmd"); SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); getFeaturesCmd->SetFID(FID[FID_TEMP_THRESHOLD]); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "SaveFeatTmpThr", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); mTmpThreshold = ce.t.dw0; LOG_NRM("Default tmp threshold using Get Features = 0x%04X", mTmpThreshold); }
void GrpAdminSetGetFeatCombo::SaveTLER(SharedASQPtr asq, SharedACQPtr acq) { LOG_NRM("Create Get features cmd"); SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); getFeaturesCmd->SetFID(FID[FID_ERR_RECOVERY]); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "SaveFeatTler", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); mTimeLimErrRec = ce.t.dw0; LOG_NRM("Default time limited err recovery using Get Features = 0x%04X", mTimeLimErrRec); }
void GrpAdminSetGetFeatCombo::SaveArbitration(SharedASQPtr asq, SharedACQPtr acq) { LOG_NRM("Create Get features cmd"); SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); getFeaturesCmd->SetFID(FID[FID_ARBITRATION]); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "SaveFeatArb", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); mArbitration = ce.t.dw0; LOG_NRM("Default arbitration using Get Features = 0x%04X", mArbitration); }
void GrpAdminSetGetFeatCombo::SaveAsyncEvent(SharedASQPtr asq, SharedACQPtr acq) { LOG_NRM("Create Get features cmd"); SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); getFeaturesCmd->SetFID(FID[FID_ASYNC_EVENT_CONFIG]); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "SaveFeatAsyncEvent", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); mAsyncEvent = ce.t.dw0; LOG_NRM("Default Async Events using Get Features = 0x%04X", mAsyncEvent); }
void GrpAdminSetGetFeatCombo::SaveWrAtomicity(SharedASQPtr asq, SharedACQPtr acq) { LOG_NRM("Create Get features cmd"); SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); getFeaturesCmd->SetFID(FID[FID_WRITE_ATOMICITY]); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "SaveFeatWrAtomicity", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); mWrAtomicity = ce.t.dw0; LOG_NRM("Default WrAtomicity using Get Features = 0x%04X", mWrAtomicity); }
void GrpAdminSetGetFeatCombo::SaveVolWrCache(SharedASQPtr asq, SharedACQPtr acq) { LOG_NRM("Create Get features cmd"); SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); getFeaturesCmd->SetFID(FID[FID_VOL_WR_CACHE]); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "SaveFeatVWC", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); mVolWrCache = ce.t.dw0; LOG_NRM("Default volatile write cache using Get Features = 0x%04X", mVolWrCache); }
void GrpAdminSetGetFeatCombo::SaveIRQCoalescing(SharedASQPtr asq, SharedACQPtr acq) { LOG_NRM("Create Get features cmd"); SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); getFeaturesCmd->SetFID(FID[FID_IRQ_COALESCING]); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "SaveFeatIRQCoalescing", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); mIrqCoalescing = ce.t.dw0; LOG_NRM("Default irq coalescing using Get Features = 0x%04X", mIrqCoalescing); }
void AdminQRollChkDiff_r10b::VerifyQPointers(SharedACQPtr acq, SharedASQPtr asq) { union CE ce; struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); struct nvme_gen_sq asqMetrics = asq->GetQMetrics(); // The CQ's metrics after reaping holds head_ptr plus 1 needed. Also Take // Q roll over into account. if (acqMetrics.head_ptr == 0) { ce = acq->PeekCE(acq->GetNumEntries() - 1); } else { ce = acq->PeekCE(acqMetrics.head_ptr - 1); } uint16_t expectedVal = (2 + MAX(acq->GetNumEntries(), asq->GetNumEntries())) % acq->GetNumEntries(); if (acqMetrics.head_ptr != expectedVal) { acq->Dump( FileSystem::PrepDumpFile(mGrpName, mTestName, "acq", "head_ptr"), "CQ Metrics Head Pointer Inconsistent"); throw FrmwkEx(HERE, "Expected ACQ.head_ptr = 0x%04X but actual " "ACQ.head_ptr = 0x%04X", expectedVal, acqMetrics.head_ptr); } expectedVal = (2 + MAX(acq->GetNumEntries(), asq->GetNumEntries())) % asq->GetNumEntries(); if (asqMetrics.tail_ptr != expectedVal) { asq->Dump( FileSystem::PrepDumpFile(mGrpName, mTestName, "asq", "tail_ptr"), "SQ Metrics Tail Pointer Inconsistent"); throw FrmwkEx(HERE, "Expected ASQ.tail_ptr = 0x%04X but actual " "ASQ.tail_ptr = 0x%04X", expectedVal, asqMetrics.tail_ptr); } if (ce.n.SQHD != expectedVal) { acq->Dump( FileSystem::PrepDumpFile(mGrpName, mTestName, "acq", "CE.SQHD"), "CE SQ Head Pointer Inconsistent"); throw FrmwkEx(HERE, "Expected CE.SQHD = 0x%04X in ACQ completion entry but actual " "CE.SQHD = 0x%04X", expectedVal, ce.n.SQHD); } }
void GrpAdminSetGetFeatCombo::SaveIvecConf(SharedASQPtr asq, SharedACQPtr acq) { LOG_NRM("Create Get features cmd"); SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); getFeaturesCmd->SetFID(FID[FID_IRQ_VEC_CONFIG]); uint16_t max_ivec = IRQ::GetMaxIRQsSupportedAnyScheme(); for (uint16_t ivec = 0; ivec < max_ivec; ivec++) { getFeaturesCmd->SetIntVecConfigIV(ivec); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "SaveFeatIvecCOnf", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); mIvecConf[ivec] = ce.t.dw0; LOG_NRM("Default conf = 0x%04X using Get Features for ivec = 0x%02X", mIvecConf[ivec], ivec); } }
bool GrpAdminSetGetFeatCombo::RestoreSaveIvecConf(SharedASQPtr asq, SharedACQPtr acq) { SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); SharedSetFeaturesPtr setFeaturesCmd = SharedSetFeaturesPtr(new SetFeatures()); uint16_t max_ivec = IRQ::GetMaxIRQsSupportedAnyScheme(); for (uint16_t ivec = 0; ivec < max_ivec; ivec++) { LOG_NRM("Restoring state for ivec = 0x%02X with IvecConf = 0x%04X", ivec, mIvecConf[ivec]); setFeaturesCmd->SetFID(FID[FID_IRQ_VEC_CONFIG]); getFeaturesCmd->SetFID(FID[FID_IRQ_VEC_CONFIG]); setFeaturesCmd->SetDword(mIvecConf[ivec], 11); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, setFeaturesCmd, "RestoreIvecConf", true); getFeaturesCmd->SetIntVecConfigIV(ivec); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); IO::SendAndReapCmd(mGrpName, mGrpName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, "RestoreIvecConf", true); union CE ce = acq->PeekCE(acqMetrics.head_ptr); if (mIvecConf[ivec] != ce.t.dw0) { LOG_ERR("mIvecConf restore to original state failed. " "(Actual: Expected) = (0x%04X:0x%04X)", ce.t.dw0, mIvecConf[ivec]); return false; } } return true; }
void FIDPwrMgmt_r10b::RunCoreTest() { /** \verbatim * Assumptions: * None. * \endverbatim */ string work; union CE ce; struct nvme_gen_cq acqMetrics; if (gCtrlrConfig->SetState(ST_DISABLE_COMPLETELY) == false) throw FrmwkEx(HERE); LOG_NRM("Create admin queues ACQ and ASQ for test lifetime"); SharedACQPtr acq = SharedACQPtr(new ACQ(gDutFd)); acq->Init(5); SharedASQPtr asq = SharedASQPtr(new ASQ(gDutFd)); asq->Init(5); // All queues will use identical IRQ vector IRQ::SetAnySchemeSpecifyNum(1); gCtrlrConfig->SetCSS(CtrlrConfig::CSS_NVM_CMDSET); if (gCtrlrConfig->SetState(ST_ENABLE) == false) throw FrmwkEx(HERE); LOG_NRM("Create Get features and set features cmds"); SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); SharedSetFeaturesPtr setFeaturesCmd = SharedSetFeaturesPtr(new SetFeatures()); LOG_NRM("Set and Get features PSD (FID = 0x%x)", BaseFeatures::FID_PWR_MGMT); getFeaturesCmd->SetFID(BaseFeatures::FID_PWR_MGMT); setFeaturesCmd->SetFID(BaseFeatures::FID_PWR_MGMT); uint8_t npss = gInformative->GetIdentifyCmdCtrlr()-> GetValue(IDCTRLRCAP_NPSS); // 0-based LOG_NRM("Number of power states supported by the ctrlr (NPSS) = %d", npss); uint8_t psMismatch = 0; for (uint16_t ps = 0; ps <= npss; ps++) { LOG_NRM("Set and Get features for PS # %d", ps); setFeaturesCmd->SetPowerManagementPS(ps); LOG_NRM("Issue set features cmd with PS = %d", ps); work = str(boost::format("ps.%d") % ps); IO::SendAndReapCmd(mGrpName, mTestName, CALC_TIMEOUT_ms(1), asq, acq, setFeaturesCmd, work, true); acqMetrics = acq->GetQMetrics(); LOG_NRM("Issue get features cmd and check for ps = %d", ps); IO::SendAndReapCmd(mGrpName, mTestName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, work, false); ce = acq->PeekCE(acqMetrics.head_ptr); LOG_NRM("Power state descriptor using Get Features = %d", ce.t.dw0); if (ps != ce.t.dw0) { LOG_ERR("PSD get feat does not match set feat" "(expected, rcvd) = (%d, %d)", ps, ce.t.dw0); psMismatch = 0xFF; } } if (psMismatch) throw FrmwkEx(HERE, "Power state mismatched."); }
void FIDVolatileCash_r10b::RunCoreTest() { /** \verbatim * Assumptions: * None. * \endverbatim */ string work; union CE ce; struct nvme_gen_cq acqMetrics; if (gCtrlrConfig->SetState(ST_DISABLE_COMPLETELY) == false) throw FrmwkEx(HERE); LOG_NRM("Create admin queues ACQ and ASQ for test lifetime"); SharedACQPtr acq = SharedACQPtr(new ACQ(gDutFd)); acq->Init(5); SharedASQPtr asq = SharedASQPtr(new ASQ(gDutFd)); asq->Init(5); // All queues will use identical IRQ vector IRQ::SetAnySchemeSpecifyNum(1); gCtrlrConfig->SetCSS(CtrlrConfig::CSS_NVM_CMDSET); if (gCtrlrConfig->SetState(ST_ENABLE) == false) throw FrmwkEx(HERE); LOG_NRM("Create Get features and set features cmds"); SharedGetFeaturesPtr getFeaturesCmd = SharedGetFeaturesPtr(new GetFeatures()); SharedSetFeaturesPtr setFeaturesCmd = SharedSetFeaturesPtr(new SetFeatures()); LOG_NRM("Set and Get features for volatile write cache (FID = 0x%x)", BaseFeatures::FID_VOL_WR_CACHE); getFeaturesCmd->SetFID(BaseFeatures::FID_VOL_WR_CACHE); setFeaturesCmd->SetFID(BaseFeatures::FID_VOL_WR_CACHE); uint8_t wce = 0x0; // Disable volatile write cache LOG_NRM("Disable volatile wr cache # %d ", wce); setFeaturesCmd->SetVolatileWriteCacheWCE(wce); LOG_NRM("Issue set features cmd with WCE = %d", wce); work = str(boost::format("wce.%d") % wce); IO::SendAndReapCmd(mGrpName, mTestName, CALC_TIMEOUT_ms(1), asq, acq, setFeaturesCmd, work, true); acqMetrics = acq->GetQMetrics(); LOG_NRM("Issue get features cmd & check wce = %d", wce); IO::SendAndReapCmd(mGrpName, mTestName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, work, false); ce = acq->PeekCE(acqMetrics.head_ptr); LOG_NRM("Get Features volatile wr cache = %d", ce.t.dw0); if (wce != ce.t.dw0) { throw FrmwkEx(HERE, "WCE get feat does not match set feat" "(expected, rcvd) = (%d, %d)", wce, ce.t.dw0); } wce = 0x1; // Enable volatile write cache LOG_NRM("Enable volatile wr cache # %d ", wce); setFeaturesCmd->SetVolatileWriteCacheWCE(wce); LOG_NRM("Issue set features cmd with WCE = %d", wce); work = str(boost::format("wce.%d") % wce); IO::SendAndReapCmd(mGrpName, mTestName, CALC_TIMEOUT_ms(1), asq, acq, setFeaturesCmd, work, true); acqMetrics = acq->GetQMetrics(); LOG_NRM("Issue get features cmd & check wce = %d", wce); IO::SendAndReapCmd(mGrpName, mTestName, CALC_TIMEOUT_ms(1), asq, acq, getFeaturesCmd, work, false); ce = acq->PeekCE(acqMetrics.head_ptr); LOG_NRM("Get Features volatile wr cache = %d", ce.t.dw0); if (wce != ce.t.dw0) { throw FrmwkEx(HERE, "WCE get feat does not match set feat" "(expected, rcvd) = (%d, %d)", wce, ce.t.dw0); } }
bool SetFeaturesNumberOfQueues(Queues &queues, int fd) { uint16_t numCE; uint16_t ceRemain; uint16_t numReaped; try { // The objects to perform this work throw exceptions LOG_NRM("Setting number of Q's; ncqr=0x%04X, nsqr=0x%04X", queues.ncqr, queues.nsqr); if (gCtrlrConfig->SetState(ST_DISABLE_COMPLETELY) == false) throw exception(); LOG_NRM("Prepare the admin Q's to setup this request"); SharedACQPtr acq = SharedACQPtr(new ACQ(fd)); acq->Init(2); SharedASQPtr asq = SharedASQPtr(new ASQ(fd)); asq->Init(2); if (gCtrlrConfig->SetState(ST_ENABLE) == false) throw exception(); LOG_NRM("Create the cmd to carry this data to the DUT"); SharedSetFeaturesPtr sfNumOfQ = SharedSetFeaturesPtr(new SetFeatures(fd)); sfNumOfQ->SetFID(BaseFeatures::FID_NUM_QUEUES); sfNumOfQ->SetNumberOfQueues(queues.ncqr, queues.nsqr); LOG_NRM("Send the cmd to the ASQ, wait for it to complete"); asq->Send(sfNumOfQ); asq->Ring(); if (acq->ReapInquiryWaitSpecify(2000, 1, numCE) == false) { LOG_ERR("Unable to see completion of Set Features cmd"); throw exception(); } else if (numCE != 1) { LOG_ERR("The ACQ should only have 1 CE as a result of a cmd"); throw exception(); } LOG_NRM("The CQ's metrics before reaping holds head_ptr needed"); struct nvme_gen_cq acqMetrics = acq->GetQMetrics(); KernelAPI::LogCQMetrics(acqMetrics); LOG_NRM("Reaping CE from ACQ, requires memory to hold reaped CE"); SharedMemBufferPtr ceMemIOCQ = SharedMemBufferPtr(new MemBuffer()); if ((numReaped = acq->Reap(ceRemain, ceMemIOCQ, numCE, true)) != 1) { LOG_ERR("Verified there was 1 CE, but reaping produced %d", numReaped); throw exception(); } LOG_NRM("The reaped get features CE is..."); acq->LogCE(acqMetrics.head_ptr); union CE ce = acq->PeekCE(acqMetrics.head_ptr); if (ce.n.status != 0) { LOG_ERR("CE shows cmd failed: status = 0x%02X", ce.n.status); throw exception(); } printf("The operation succeeded to set number of queues\n"); } catch (...) { printf("Operation failed to set number of queues\n"); return false; } return true; }