/*
* _DoStdin - get stuff from stdin
*/
unsigned _DoStdin( LPWDATA w, void *in_buff, unsigned size )
{
unsigned rc;
char * buff;
buff = (char *)in_buff;
if( w == NULL ) return( 0 );
if( !w->active) _MakeWindowActive( w );
rc = _GetString( w, buff, size );
if( _GotEOF ) {
if( rc < size ) {
buff[rc++] = CTRL_Z;
}
} else {
if( (rc+2) < size ) {
buff[rc++] = 0x0d;
buff[rc++] = 0x0a;
} else if( ( rc == 0 ) && ( size == 1 ) ) {/* rc==0 ==> key was enter */
/* kludge to allow readers to get a single new line from the
* system
*/
buff[rc++] = 0x0a;
}
}
return( rc );
} /* _DoStdin */
HRESULT XmlProfileParser::_ParseRandomDataSource(IXMLDOMNode *pXmlNode, Target *pTarget)
{
CComPtr<IXMLDOMNodeList> spNodeList = nullptr;
CComVariant query("RandomDataSource");
HRESULT hr = pXmlNode->selectNodes(query.bstrVal, &spNodeList);
if (SUCCEEDED(hr))
{
long cNodes;
hr = spNodeList->get_length(&cNodes);
if (SUCCEEDED(hr) && (cNodes == 1))
{
CComPtr<IXMLDOMNode> spNode = nullptr;
hr = spNodeList->get_item(0, &spNode);
if (SUCCEEDED(hr))
{
UINT64 cb;
hr = _GetUINT64(spNode, "SizeInBytes", &cb);
if (SUCCEEDED(hr) && (S_FALSE != hr))
{
pTarget->SetRandomDataWriteBufferSize(cb);
string sPath;
hr = _GetString(spNode, "FilePath", &sPath);
if (SUCCEEDED(hr) && (S_FALSE != hr))
{
pTarget->SetRandomDataWriteBufferSourcePath(sPath);
}
}
}
}
}
return hr;
}
void
Language::Load()
{
String sTranslatedLanguageFile = IniFileSettings::Instance()->GetLanguageDirectory() + "\\" + m_sName + ".ini";
String sTranslatedContents = FileUtilities::ReadCompleteTextFile(sTranslatedLanguageFile);
std::vector<String> vecTranslatedStrings = StringParser::SplitString(sTranslatedContents, "\r\n");
std::vector<String>::iterator iterTranslatedString = vecTranslatedStrings.begin();
std::vector<String>::iterator iterTranslatedStringEnd = vecTranslatedStrings.end();
for (; iterTranslatedString != iterTranslatedStringEnd; iterTranslatedString++)
{
String sString = (*iterTranslatedString);
std::pair<int, String> translatedPair = _GetString(sString);
std::map<int, String>::iterator englishPair = mapEnglishContent.find(translatedPair.first);
if (englishPair != mapEnglishContent.end())
{
m_mapStrings[(*englishPair).second] = translatedPair.second;
}
}
m_bIsLoaded = true;
}
HRESULT XmlProfileParser::_ParseWriteBufferContent(IXMLDOMNode *pXmlNode, Target *pTarget)
{
CComPtr<IXMLDOMNodeList> spNodeList = nullptr;
CComVariant query("WriteBufferContent");
HRESULT hr = pXmlNode->selectNodes(query.bstrVal, &spNodeList);
if (SUCCEEDED(hr))
{
long cNodes;
hr = spNodeList->get_length(&cNodes);
if (SUCCEEDED(hr) && (cNodes == 1))
{
CComPtr<IXMLDOMNode> spNode = nullptr;
hr = spNodeList->get_item(0, &spNode);
if (SUCCEEDED(hr))
{
string sPattern;
hr = _GetString(spNode, "Pattern", &sPattern);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
if (sPattern == "sequential")
{
// that's the default option - do nothing
}
else if (sPattern == "zero")
{
pTarget->SetZeroWriteBuffers(true);
}
else if (sPattern == "random")
{
hr = _ParseRandomDataSource(spNode, pTarget);
}
else
{
hr = E_INVALIDARG;
}
}
}
}
}
return hr;
}
/*********************************************************************
*
* _BuildStringDesc
*
* Notes
* (1)
*/
static const U8 * _BuildStringDesc(unsigned StringIndex) {
USB_INFO_BUFFER InfoBuffer;
unsigned i;
unsigned NumChars;
const char * s;
//
// String Index == 0 means Language identifier.
//
if (StringIndex == 0) {
USB_DEBUGOUT(":Lang");
USB_IB_Init(&InfoBuffer, &_aDescBuffer[0], sizeof(_aDescBuffer));
USB_IB_AddU8(&InfoBuffer, 4);
USB_IB_AddU8(&InfoBuffer, USB_DESC_TYPE_STRING);
USB_IB_AddU16(&InfoBuffer, 0x409);
} else {
//
// Get string from application
//
s = _GetString(StringIndex);
if (s == NULL) {
return NULL;
}
//
// Build the descriptor from string
//
NumChars = _strlen(s);
USB_IB_Init(&InfoBuffer, &_aDescBuffer[0], sizeof(_aDescBuffer));
USB_IB_AddU8(&InfoBuffer, (U8)(2 + 2 * NumChars));
USB_IB_AddU8(&InfoBuffer, USB_DESC_TYPE_STRING);
for (i = 0; i < NumChars; i++) {
U16 Char16;
Char16 = *(s + i);
USB_IB_AddU16(&InfoBuffer, Char16);
}
}
return _aDescBuffer;
}
void
Language::LoadEnglish()
{
String sEnglishLanguageFile = IniFileSettings::Instance()->GetLanguageDirectory() + "\\english.ini";
String sEnglishContents = FileUtilities::ReadCompleteTextFile(sEnglishLanguageFile);
std::vector<String> vecEnglishStrings = StringParser::SplitString(sEnglishContents, "\r\n");
std::vector<String>::iterator iterEnglishString = vecEnglishStrings.begin();
std::vector<String>::iterator iterEnglishStringEnd = vecEnglishStrings.end();
for (; iterEnglishString != iterEnglishStringEnd; iterEnglishString++)
{
String sString = (*iterEnglishString);
if (sString.Left(7) != _T("String_"))
continue;
std::pair<int, String> pair = _GetString(sString);
mapEnglishContent[pair.first] = pair.second;
}
}
// GetName
void
CompoundCommand::GetName(BString& name)
{
name << _GetString(fNameIndex, fName.String());
}
bool XmlProfileParser::ParseFile(const char *pszPath, Profile *pProfile, HMODULE hModule)
{
assert(pszPath != nullptr);
assert(pProfile != nullptr);
// import schema from the named resource
HRSRC hSchemaXmlResource = FindResource(hModule, L"DISKSPD.XSD", RT_HTML);
assert(hSchemaXmlResource != NULL);
HGLOBAL hSchemaXml = LoadResource(hModule, hSchemaXmlResource);
assert(hSchemaXml != NULL);
LPVOID pSchemaXml = LockResource(hSchemaXml);
assert(pSchemaXml != NULL);
// convert from utf-8 produced by the xsd authoring tool to utf-16
int cchSchemaXml = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)pSchemaXml, -1, NULL, 0);
vector<WCHAR> vWideSchemaXml(cchSchemaXml);
int dwcchWritten = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)pSchemaXml, -1, vWideSchemaXml.data(), cchSchemaXml);
UNREFERENCED_PARAMETER(dwcchWritten);
assert(dwcchWritten == cchSchemaXml);
// ... and finally, packed in a bstr for the loadXml interface
CComBSTR bSchemaXml(vWideSchemaXml.data());
bool fComInitialized = false;
HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
if (SUCCEEDED(hr))
{
fComInitialized = true;
CComPtr<IXMLDOMDocument2> spXmlDoc = nullptr;
CComPtr<IXMLDOMDocument2> spXmlSchema = nullptr;
CComPtr<IXMLDOMSchemaCollection2> spXmlSchemaColl = nullptr;
CComPtr<IXMLDOMParseError> spXmlParseError = nullptr;
// create com objects and decorate
hr = CoCreateInstance(__uuidof(DOMDocument60), nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&spXmlSchema));
if (SUCCEEDED(hr))
{
hr = spXmlSchema->put_async(VARIANT_FALSE);
}
if (SUCCEEDED(hr))
{
hr = spXmlSchema->setProperty(CComBSTR("ProhibitDTD"), CComVariant(VARIANT_FALSE));
}
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(__uuidof(XMLSchemaCache60), nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&spXmlSchemaColl));
}
if (SUCCEEDED(hr))
{
hr = spXmlSchemaColl->put_validateOnLoad(VARIANT_TRUE);
}
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(__uuidof(DOMDocument60), nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&spXmlDoc));
}
if (SUCCEEDED(hr))
{
hr = spXmlDoc->put_async(VARIANT_FALSE);
}
if (SUCCEEDED(hr))
{
hr = spXmlDoc->put_validateOnParse(VARIANT_TRUE);
}
if (SUCCEEDED(hr))
{
VARIANT_BOOL fvIsOk;
hr = spXmlSchema->loadXML(bSchemaXml, &fvIsOk);
if (FAILED(hr) || fvIsOk != VARIANT_TRUE)
{
hr = spXmlSchema->get_parseError(&spXmlParseError);
if (SUCCEEDED(hr))
{
ReportXmlError("schema", spXmlParseError);
}
hr = E_FAIL;
}
}
if (SUCCEEDED(hr))
{
CComVariant vXmlSchema(spXmlSchema);
CComBSTR bNull("");
hr = spXmlSchemaColl->add(bNull, vXmlSchema);
}
if (SUCCEEDED(hr))
{
CComVariant vSchemaCache(spXmlSchemaColl);
hr = spXmlDoc->putref_schemas(vSchemaCache);
}
if (SUCCEEDED(hr))
{
VARIANT_BOOL fvIsOk;
CComVariant vPath(pszPath);
hr = spXmlDoc->load(vPath, &fvIsOk);
if (FAILED(hr) || fvIsOk != VARIANT_TRUE)
{
hr = spXmlDoc->get_parseError(&spXmlParseError);
if (SUCCEEDED(hr))
{
ReportXmlError("profile", spXmlParseError);
}
hr = E_FAIL;
}
}
// now parse the specification, if correct
if (SUCCEEDED(hr))
{
bool fVerbose;
hr = _GetVerbose(spXmlDoc, &fVerbose);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pProfile->SetVerbose(fVerbose);
}
if (SUCCEEDED(hr))
{
DWORD dwProgress;
hr = _GetProgress(spXmlDoc, &dwProgress);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pProfile->SetProgress(dwProgress);
}
}
if (SUCCEEDED(hr))
{
string sResultFormat;
hr = _GetString(spXmlDoc, "//Profile/ResultFormat", &sResultFormat);
if (SUCCEEDED(hr) && (hr != S_FALSE) && sResultFormat == "xml")
{
pProfile->SetResultsFormat(ResultsFormat::Xml);
}
}
if (SUCCEEDED(hr))
{
string sCreateFiles;
hr = _GetString(spXmlDoc, "//Profile/PrecreateFiles", &sCreateFiles);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
if (sCreateFiles == "UseMaxSize")
{
pProfile->SetPrecreateFiles(PrecreateFiles::UseMaxSize);
}
else if (sCreateFiles == "CreateOnlyFilesWithConstantSizes")
{
pProfile->SetPrecreateFiles(PrecreateFiles::OnlyFilesWithConstantSizes);
}
else if (sCreateFiles == "CreateOnlyFilesWithConstantOrZeroSizes")
{
pProfile->SetPrecreateFiles(PrecreateFiles::OnlyFilesWithConstantOrZeroSizes);
}
else
{
hr = E_INVALIDARG;
}
}
}
if (SUCCEEDED(hr))
{
hr = _ParseEtw(spXmlDoc, pProfile);
}
if (SUCCEEDED(hr))
{
hr = _ParseTimeSpans(spXmlDoc, pProfile);
}
}
}
if (fComInitialized)
{
CoUninitialize();
}
return SUCCEEDED(hr);
}
HRESULT XmlProfileParser::_ParseTarget(IXMLDOMNode *pXmlNode, Target *pTarget)
{
string sPath;
HRESULT hr = _GetString(pXmlNode, "Path", &sPath);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetPath(sPath);
}
if (SUCCEEDED(hr))
{
DWORD dwBlockSize;
hr = _GetDWORD(pXmlNode, "BlockSize", &dwBlockSize);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetBlockSizeInBytes(dwBlockSize);
}
}
if (SUCCEEDED(hr))
{
UINT64 ullStrideSize;
hr = _GetUINT64(pXmlNode, "StrideSize", &ullStrideSize);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetBlockAlignmentInBytes(ullStrideSize);
}
}
if (SUCCEEDED(hr))
{
bool fInterlockedSequential;
hr = _GetBool(pXmlNode, "InterlockedSequential", &fInterlockedSequential);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetUseInterlockedSequential(fInterlockedSequential);
}
}
if (SUCCEEDED(hr))
{
UINT64 ullBaseFileOffset;
hr = _GetUINT64(pXmlNode, "BaseFileOffset", &ullBaseFileOffset);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetBaseFileOffsetInBytes(ullBaseFileOffset);
}
}
if (SUCCEEDED(hr))
{
bool fBool;
hr = _GetBool(pXmlNode, "SequentialScan", &fBool);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetSequentialScanHint(fBool);
}
}
if (SUCCEEDED(hr))
{
bool fBool;
hr = _GetBool(pXmlNode, "RandomAccess", &fBool);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetRandomAccessHint(fBool);
}
}
if (SUCCEEDED(hr))
{
bool fBool;
hr = _GetBool(pXmlNode, "TemporaryFile", &fBool);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetTemporaryFileHint(fBool);
}
}
if (SUCCEEDED(hr))
{
bool fUseLargePages;
hr = _GetBool(pXmlNode, "UseLargePages", &fUseLargePages);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetUseLargePages(fUseLargePages);
}
}
if (SUCCEEDED(hr))
{
DWORD dwRequestCount;
hr = _GetDWORD(pXmlNode, "RequestCount", &dwRequestCount);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetRequestCount(dwRequestCount);
}
}
if (SUCCEEDED(hr))
{
UINT64 ullRandom;
hr = _GetUINT64(pXmlNode, "Random", &ullRandom);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetUseRandomAccessPattern(true);
pTarget->SetBlockAlignmentInBytes(ullRandom);
}
}
if (SUCCEEDED(hr))
{
bool fBool;
hr = _GetBool(pXmlNode, "DisableOSCache", &fBool);
if (SUCCEEDED(hr) && (hr != S_FALSE) && fBool)
{
pTarget->SetCacheMode(TargetCacheMode::DisableOSCache);
}
}
if (SUCCEEDED(hr))
{
bool fBool;
hr = _GetBool(pXmlNode, "DisableAllCache", &fBool);
if (SUCCEEDED(hr) && (hr != S_FALSE) && fBool)
{
pTarget->SetCacheMode(TargetCacheMode::DisableOSCache);
pTarget->SetWriteThroughMode(WriteThroughMode::On);
}
}
if (SUCCEEDED(hr))
{
bool fBool;
hr = _GetBool(pXmlNode, "DisableLocalCache", &fBool);
if (SUCCEEDED(hr) && (hr != S_FALSE) && fBool)
{
pTarget->SetCacheMode(TargetCacheMode::DisableLocalCache);
}
}
if (SUCCEEDED(hr))
{
bool fBool;
hr = _GetBool(pXmlNode, "WriteThrough", &fBool);
if (SUCCEEDED(hr) && (hr != S_FALSE) && fBool)
{
pTarget->SetWriteThroughMode(WriteThroughMode::On);
}
}
if (SUCCEEDED(hr))
{
hr = _ParseWriteBufferContent(pXmlNode, pTarget);
}
if (SUCCEEDED(hr))
{
DWORD dwBurstSize;
hr = _GetDWORD(pXmlNode, "BurstSize", &dwBurstSize);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetBurstSize(dwBurstSize);
pTarget->SetUseBurstSize(true);
}
}
if (SUCCEEDED(hr))
{
DWORD dwThinkTime;
hr = _GetDWORD(pXmlNode, "ThinkTime", &dwThinkTime);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetThinkTime(dwThinkTime);
pTarget->SetEnableThinkTime(true);
}
}
if (SUCCEEDED(hr))
{
DWORD dwThroughput;
hr = _GetDWORD(pXmlNode, "Throughput", &dwThroughput);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetThroughput(dwThroughput);
}
}
if (SUCCEEDED(hr))
{
DWORD dwThreadsPerFile;
hr = _GetDWORD(pXmlNode, "ThreadsPerFile", &dwThreadsPerFile);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetThreadsPerFile(dwThreadsPerFile);
}
}
if (SUCCEEDED(hr))
{
UINT64 ullFileSize;
hr = _GetUINT64(pXmlNode, "FileSize", &ullFileSize);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetFileSize(ullFileSize);
pTarget->SetCreateFile(true);
}
}
if (SUCCEEDED(hr))
{
UINT64 ullMaxFileSize;
hr = _GetUINT64(pXmlNode, "MaxFileSize", &ullMaxFileSize);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetMaxFileSize(ullMaxFileSize);
}
}
if (SUCCEEDED(hr))
{
UINT32 ulWriteRatio;
hr = _GetUINT32(pXmlNode, "WriteRatio", &ulWriteRatio);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetWriteRatio(ulWriteRatio);
}
}
if (SUCCEEDED(hr))
{
bool fParallelAsyncIO;
hr = _GetBool(pXmlNode, "ParallelAsyncIO", &fParallelAsyncIO);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetUseParallelAsyncIO(fParallelAsyncIO);
}
}
if (SUCCEEDED(hr))
{
UINT64 ullThreadStride;
hr = _GetUINT64(pXmlNode, "ThreadStride", &ullThreadStride);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetThreadStrideInBytes(ullThreadStride);
}
}
if (SUCCEEDED(hr))
{
UINT32 ulIOPriority;
hr = _GetUINT32(pXmlNode, "IOPriority", &ulIOPriority);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
PRIORITY_HINT hint[] = { IoPriorityHintVeryLow, IoPriorityHintLow, IoPriorityHintNormal };
pTarget->SetIOPriorityHint(hint[ulIOPriority - 1]);
}
}
if (SUCCEEDED(hr))
{
UINT32 ulWeight;
hr = _GetUINT32(pXmlNode, "Weight", &ulWeight);
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
pTarget->SetWeight(ulWeight);
}
}
if (SUCCEEDED(hr))
{
hr = _ParseThreadTargets(pXmlNode, pTarget);
}
return hr;
}
