/*++ Copyright (C) 2000-2001 Microsoft Corporation --*/ #include #include #include #define WIN32_NO_STATUS #include #include #include #include #include #include #include #include "a51rep.h" #include #include #include "lock.h" #include #include "a51fib.h" #include "RepositoryPackager.h" #include "Win9xSecurity.h" #include #include CLock g_readWriteLock; bool g_bShuttingDown = false; CNamespaceHandle *g_pSystemClassNamespace = NULL; DWORD g_dwOldRepositoryVersion = 0; DWORD g_dwCurrentRepositoryVersion = 0; DWORD CRepository::m_ShutDownFlags = 0; HANDLE CRepository::m_hShutdownEvent = 0; HANDLE CRepository::m_hFlusherThread = 0; LONG CRepository::m_ulReadCount = 0; LONG CRepository::m_ulWriteCount = 0; HANDLE CRepository::m_hWriteEvent = 0; HANDLE CRepository::m_hReadEvent = 0; int CRepository::m_threadState = CRepository::ThreadStateDead; CCritSec CRepository::m_cs; LONG CRepository::m_threadCount = 0; //***************************************************************************** HRESULT CRepository::Initialize() { HRESULT hRes = WBEM_S_NO_ERROR; InitializeRepositoryVersions(); // // Initialize time index // if (SUCCEEDED(hRes)) { FILETIME ft; GetSystemTimeAsFileTime(&ft); g_nCurrentTime = ft.dwLowDateTime + ((__int64)ft.dwHighDateTime << 32); } // // Get the repository directory // if (SUCCEEDED(hRes)) hRes = GetRepositoryDirectory(); //Do the upgrade of the repository if necessary if (SUCCEEDED(hRes)) hRes = UpgradeRepositoryFormat(); // // initialze all our global resources // if (SUCCEEDED(hRes)) hRes = InitializeGlobalVariables(); if (SUCCEEDED(hRes)) { long lRes = g_Glob.GetFileCache()->Initialize(g_Glob.GetRootDir()); hRes = A51TranslateErrorCode(lRes); } // // Initialize class cache. It will read the registry itself to find out // its size limitations // if (SUCCEEDED(hRes)) { hRes = g_Glob.Initialize(); if(hRes != ERROR_SUCCESS) { hRes = WBEM_E_FAILED; } } //If we need to create the system class namespace then go ahead and do that... if (SUCCEEDED(hRes)) { g_pSystemClassNamespace = new CNamespaceHandle(m_pControl, this); if (g_pSystemClassNamespace == NULL) { hRes = WBEM_E_OUT_OF_MEMORY; } } if (SUCCEEDED(hRes)) { g_pSystemClassNamespace->AddRef(); hRes = g_pSystemClassNamespace->Initialize(A51_SYSTEMCLASS_NS); } if (SUCCEEDED(hRes)) { m_hWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL); if (m_hWriteEvent == NULL) hRes = WBEM_E_CRITICAL_ERROR; } if (SUCCEEDED(hRes)) { m_hReadEvent = CreateEvent(NULL, FALSE, FALSE, NULL); if (m_hReadEvent == NULL) hRes = WBEM_E_CRITICAL_ERROR; } if (SUCCEEDED(hRes)) { m_hShutdownEvent = CreateEvent(NULL, FALSE, FALSE, NULL); if (m_hShutdownEvent == NULL) hRes = WBEM_E_CRITICAL_ERROR; } // *** Don't need to create the thread here because the read/write operation // *** will create it on demand... // if (SUCCEEDED(hRes)) // { // m_hFlusherThread = CreateThread(NULL, 0, _FlusherThread, 0, 0, NULL); // if (m_hFlusherThread == NULL) // hRes = WBEM_E_CRITICAL_ERROR; // else // m_threadState = ThreadStateOperationPending; // } //We need to reset the shutting down flag as the flusher thread //will not start without it. The problem is that the next 2 //operations (CreateSystemClasses and Import security do things //that will re-create the thread even though we don't do it above // if (SUCCEEDED(hRes)) g_bShuttingDown = false; if (SUCCEEDED(hRes)) { CAutoWriteLock lock(&g_readWriteLock); if (!lock.Lock()) hRes = WBEM_E_FAILED; else hRes = g_pSystemClassNamespace->CreateSystemClasses(m_aSystemClasses); } if (SUCCEEDED(hRes)) { // import Win9x security data if necessary CWin9xSecurity win9xSecurity(m_pControl, this); if (win9xSecurity.Win9xBlobFileExists()) hRes = win9xSecurity.ImportWin9xSecurity(); } if (SUCCEEDED(hRes)) g_bShuttingDown = false; else { g_bShuttingDown = true; //Reset to true as we cleared it earlier! g_Glob.GetFileCache()->Uninitialize(0); g_Glob.GetForestCache()->Deinitialize(); if (g_pSystemClassNamespace) { delete g_pSystemClassNamespace; g_pSystemClassNamespace = NULL; } if (m_hWriteEvent != NULL) { CloseHandle(m_hWriteEvent); m_hWriteEvent = NULL; } if (m_hReadEvent != NULL) { CloseHandle(m_hReadEvent); m_hReadEvent = NULL; } if (m_hShutdownEvent != NULL) { CloseHandle(m_hShutdownEvent); m_hShutdownEvent = NULL; } if (m_hFlusherThread != NULL) { CloseHandle(m_hFlusherThread); m_hFlusherThread = NULL; } } return hRes; } HRESULT CRepository::InitializeRepositoryVersions() { DWORD dwVal = 0; CPersistentConfig cfg; cfg.GetPersistentCfgValue(PERSIST_CFGVAL_CORE_FSREP_VERSION, dwVal); if (dwVal == 0) dwVal = A51_REP_FS_VERSION; g_dwOldRepositoryVersion = dwVal; g_dwCurrentRepositoryVersion = A51_REP_FS_VERSION; return WBEM_S_NO_ERROR; } HRESULT CRepository::UpgradeRepositoryFormat() { HRESULT hRes = WBEM_E_DATABASE_VER_MISMATCH; CPersistentConfig cfg; DWORD dwVal = 0; cfg.GetPersistentCfgValue(PERSIST_CFGVAL_CORE_FSREP_VERSION, dwVal); if (dwVal == 0) { // // First time --- write the right version in // hRes = WBEM_S_NO_ERROR; cfg.SetPersistentCfgValue(PERSIST_CFGVAL_CORE_FSREP_VERSION, A51_REP_FS_VERSION); } else if ((dwVal > 0) && (dwVal < 5)) { ERRORTRACE((LOG_WBEMCORE, "Repository cannot upgrade this version of the repository. Version found = <%ld>, version expected = <%ld>\n", dwVal, A51_REP_FS_VERSION )); hRes = WBEM_E_DATABASE_VER_MISMATCH; } else if (dwVal == 5) { ERRORTRACE((LOG_WBEMCORE, "Repository does not support upgrade from version 5. We are deleting the old version and re-initializing it. Version found = <%ld>, version expected = <%ld>\n", dwVal, A51_REP_FS_VERSION )); //Need to delete the old repostiory CFileName fn; if (fn == NULL) hRes = WBEM_E_OUT_OF_MEMORY; else { wcscpy(fn, g_Glob.GetRootDir()); wcscat(fn, L"\\index.btr"); DeleteFileW(fn); wcscpy(fn, g_Glob.GetRootDir()); wcscat(fn, L"\\lowstage.dat"); DeleteFileW(fn); wcscpy(fn, g_Glob.GetRootDir()); wcscat(fn, L"\\objheap.fre"); DeleteFileW(fn); wcscpy(fn, g_Glob.GetRootDir()); wcscat(fn, L"\\objheap.hea"); DeleteFileW(fn); cfg.SetPersistentCfgValue(PERSIST_CFGVAL_CORE_FSREP_VERSION, A51_REP_FS_VERSION); hRes = WBEM_S_NO_ERROR; } } else if (dwVal == A51_REP_FS_VERSION) hRes = WBEM_S_NO_ERROR; if (hRes == WBEM_E_DATABASE_VER_MISMATCH) { // // Unsupported version // ERRORTRACE((LOG_WBEMCORE, "Repository cannot initialize " "due to the detection of an unknown repository version. Version found = <%ld>, version expected = <%ld>\n", dwVal, A51_REP_FS_VERSION )); return WBEM_E_DATABASE_VER_MISMATCH; } return hRes; } HRESULT CRepository::GetRepositoryDirectory() { HKEY hKey; long lRes = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\WBEM\\CIMOM", 0, KEY_READ, &hKey); if(lRes) return WBEM_E_FAILED; CFileName wszTmp; if (wszTmp == NULL) return WBEM_E_OUT_OF_MEMORY; DWORD dwLen = wszTmp.Length(); lRes = RegQueryValueExW(hKey, L"Repository Directory", NULL, NULL, (LPBYTE)(wchar_t*)wszTmp, &dwLen); RegCloseKey(hKey); if(lRes) return WBEM_E_FAILED; CFileName wszRepDir; if (wszRepDir == NULL) return WBEM_E_OUT_OF_MEMORY; if (ExpandEnvironmentStringsW(wszTmp,wszRepDir,wszTmp.Length()) == 0) return WBEM_E_FAILED; lRes = EnsureDirectory(wszRepDir); if(lRes != ERROR_SUCCESS) return WBEM_E_FAILED; // // Append standard postfix --- that is our root // wcscpy(g_Glob.GetRootDir(), wszRepDir); wcscat(g_Glob.GetRootDir(), L"\\FS"); g_Glob.SetRootDirLen(wcslen(g_Glob.GetRootDir())); // // Ensure the directory is there // lRes = EnsureDirectory(g_Glob.GetRootDir()); if(lRes != ERROR_SUCCESS) return WBEM_E_FAILED; SetFileAttributesW(g_Glob.GetRootDir(), FILE_ATTRIBUTE_NOT_CONTENT_INDEXED); return WBEM_S_NO_ERROR; } HRESULT CRepository::InitializeGlobalVariables() { return WBEM_S_NO_ERROR; } HRESULT DoAutoDatabaseRestore() { HRESULT hRes = WBEM_S_NO_ERROR; //We may need to do a database restore! CFileName wszBackupFile; if (wszBackupFile == NULL) { return WBEM_E_OUT_OF_MEMORY; } int nLen = g_Glob.GetRootDirLen(); wcsncpy(wszBackupFile, g_Glob.GetRootDir(), nLen - 3); // exclude "\FS" from path wszBackupFile[nLen - 3] = '\0'; wcscat(wszBackupFile, L"\\repdrvfs.rec"); DWORD dwAttributes = GetFileAttributesW(wszBackupFile); if (dwAttributes != -1) { DWORD dwMask = FILE_ATTRIBUTE_DEVICE | FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_SPARSE_FILE; if (!(dwAttributes & dwMask)) { CRepositoryPackager packager; hRes = packager.UnpackageRepository(wszBackupFile); //We are going to ignore the error so if there was a problem we will just //load all the standard MOFs. if (hRes != WBEM_E_OUT_OF_MEMORY) hRes = WBEM_S_NO_ERROR; } } return hRes; } HRESULT STDMETHODCALLTYPE CRepository::Logon( WMIDB_LOGON_TEMPLATE *pLogonParms, DWORD dwFlags, DWORD dwRequestedHandleType, IWmiDbSession **ppSession, IWmiDbHandle **ppRootNamespace ) { //If not initialized, initialize all subsystems... if (!g_Glob.IsInit()) { HRESULT hres = Initialize(); if (FAILED(hres)) return hres; } CSession* pSession = new CSession(m_pControl); if (pSession == NULL) return WBEM_E_OUT_OF_MEMORY; pSession->AddRef(); CReleaseMe rm1(pSession); CNamespaceHandle* pHandle = new CNamespaceHandle(m_pControl, this); if (pHandle == NULL) return WBEM_E_OUT_OF_MEMORY; pHandle->AddRef(); CTemplateReleaseMe rm2(pHandle); HRESULT hres = pHandle->Initialize(L""); if(FAILED(hres)) return hres; *ppRootNamespace = pHandle; pHandle->AddRef(); *ppSession = pSession; pSession->AddRef(); return S_OK; } HRESULT STDMETHODCALLTYPE CRepository::GetLogonTemplate( LCID lLocale, DWORD dwFlags, WMIDB_LOGON_TEMPLATE **ppLogonTemplate ) { WMIDB_LOGON_TEMPLATE* lt = (WMIDB_LOGON_TEMPLATE*)CoTaskMemAlloc(sizeof(WMIDB_LOGON_TEMPLATE)); lt->dwArraySize = 0; lt->pParm = NULL; *ppLogonTemplate = lt; return S_OK; } HRESULT STDMETHODCALLTYPE CRepository::FreeLogonTemplate( WMIDB_LOGON_TEMPLATE **ppTemplate ) { CoTaskMemFree(*ppTemplate); *ppTemplate = NULL; return S_OK; } HRESULT STDMETHODCALLTYPE CRepository::Shutdown( DWORD dwFlags ) { g_bShuttingDown = true; m_ShutDownFlags = dwFlags; //Trigger the flusher thread to shutdown SetEvent(m_hShutdownEvent); SetEvent(m_hWriteEvent); if (m_hFlusherThread) WaitForSingleObject(m_hFlusherThread, INFINITE); bool bUnlock = (CLock::NoError == g_readWriteLock.WriteLock()); //Mark thread as dead m_threadState = ThreadStateDead; if (WMIDB_SHUTDOWN_MACHINE_DOWN != dwFlags) { if (g_pSystemClassNamespace) g_pSystemClassNamespace->Release(); g_pSystemClassNamespace = NULL; g_Glob.GetForestCache()->Deinitialize(); } g_Glob.GetFileCache()->Flush(); g_Glob.GetFileCache()->Uninitialize(dwFlags); if (WMIDB_SHUTDOWN_MACHINE_DOWN != dwFlags) { g_Glob.Deinitialize(); if (bUnlock) g_readWriteLock.WriteUnlock(); } if (m_hShutdownEvent != NULL) { CloseHandle(m_hShutdownEvent); m_hShutdownEvent = NULL; } if (m_hWriteEvent != NULL) { CloseHandle(m_hWriteEvent); m_hWriteEvent = NULL; } if (m_hReadEvent != NULL) { CloseHandle(m_hReadEvent); m_hReadEvent = NULL; } if (m_hFlusherThread != NULL) { CloseHandle(m_hFlusherThread); m_hFlusherThread = NULL; } return S_OK; } HRESULT STDMETHODCALLTYPE CRepository::SetCallTimeout( DWORD dwMaxTimeout ) { return S_OK; } HRESULT STDMETHODCALLTYPE CRepository::SetCacheValue( DWORD dwMaxBytes ) { HKEY hKey; long lRes = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\WBEM\\CIMOM", 0, KEY_READ | KEY_WRITE, &hKey); if(lRes) return lRes; CRegCloseMe cm(hKey); DWORD dwLen = sizeof(DWORD); DWORD dwMaxAge; lRes = RegQueryValueExW(hKey, L"Max Class Cache Item Age (ms)", NULL, NULL, (LPBYTE)&dwMaxAge, &dwLen); if(lRes != ERROR_SUCCESS) { dwMaxAge = 10000; lRes = RegSetValueExW(hKey, L"Max Class Cache Item Age (ms)", 0, REG_DWORD, (LPBYTE)&dwMaxAge, sizeof(DWORD)); } g_Glob.GetForestCache()->SetMaxMemory(dwMaxBytes, dwMaxAge); return S_OK; } HRESULT STDMETHODCALLTYPE CRepository::FlushCache( DWORD dwFlags ) { return S_OK; } HRESULT STDMETHODCALLTYPE CRepository::GetStatistics( DWORD dwParameter, DWORD *pdwValue ) { return S_OK; } HRESULT STDMETHODCALLTYPE CRepository::GetRepositoryVersions(DWORD *pdwOldVersion, DWORD *pdwCurrentVersion) { *pdwOldVersion = g_dwOldRepositoryVersion; *pdwCurrentVersion = g_dwCurrentRepositoryVersion; return S_OK; } HRESULT CRepository::GetNamespaceHandle(LPCWSTR wszNamespaceName, RELEASE_ME CNamespaceHandle** ppHandle) { HRESULT hres; // // No validation --- that would be too hard. Just create a handle and // return // CNamespaceHandle* pNewHandle = new CNamespaceHandle(m_pControl, this); if (pNewHandle == NULL) return WBEM_E_OUT_OF_MEMORY; pNewHandle->AddRef(); CReleaseMe rm1(pNewHandle); hres = pNewHandle->Initialize(wszNamespaceName); if(FAILED(hres)) return hres; *ppHandle = pNewHandle; pNewHandle->AddRef(); return S_OK; } HRESULT CRepository::Backup(LPCWSTR wszBackupFile, long lFlags) { HRESULT hRes = WBEM_S_NO_ERROR; // params have already been verified by the calling method (CWbemBackupRestore::DoBackup), // but do it again just in case things change and this is no longer the case if (NULL == wszBackupFile || (lFlags != 0)) return WBEM_E_INVALID_PARAMETER; if (FAILED(hRes = LockRepository())) return hRes; CRepositoryPackager packager; hRes = packager.PackageRepository(wszBackupFile); UnlockRepository(); return hRes; } HRESULT CRepository::Restore(LPCWSTR wszBackupFile, long lFlags) { return WBEM_E_NOT_SUPPORTED; } #define MaxTraceSizeBackup (11) struct BackUpTraces { DWORD ThreadId; PVOID Trace[MaxTraceSizeBackup]; } g_Backup[2]; LONG g_NumTimes; HRESULT CRepository::LockRepository() { #ifdef _X86_ DWORD * pDW = (DWORD *)_alloca(sizeof(DWORD)); #endif //Lock the database so no one writes to it if (CLock::NoError != g_readWriteLock.WriteLock()) return WBEM_E_FAILED; ScopeGuard lockGuard = MakeObjGuard(g_readWriteLock, &CLock::WriteUnlock); if (g_bShuttingDown) { return WBEM_E_SHUTTING_DOWN; } InterlockedIncrement(&g_NumTimes); g_Backup[0].ThreadId = GetCurrentThreadId(); ULONG Hash; RtlCaptureStackBackTrace(0,MaxTraceSizeBackup,g_Backup[0].Trace,&Hash); g_Backup[1].ThreadId = 0; //We need to wait for the transaction manager write to flush... long lRes = g_Glob.GetFileCache()->Flush(); if (lRes != ERROR_SUCCESS) return WBEM_E_FAILED; if (CLock::NoError != g_readWriteLock.DowngradeLock()) return WBEM_E_FAILED; lockGuard.Dismiss(); return WBEM_S_NO_ERROR; } HRESULT CRepository::UnlockRepository() { #ifdef _X86_ DWORD * pDW = (DWORD *)_alloca(sizeof(DWORD)); #endif g_readWriteLock.ReadUnlock(); InterlockedDecrement(&g_NumTimes); g_Backup[1].ThreadId = GetCurrentThreadId(); ULONG Hash; RtlCaptureStackBackTrace(0,MaxTraceSizeBackup,g_Backup[1].Trace,&Hash); g_Backup[0].ThreadId = 0; return WBEM_S_NO_ERROR; } #define A51REP_CACHE_FLUSH_TIMEOUT 60000 #define A51REP_THREAD_IDLE_TIMEOUT 60000 DWORD WINAPI CRepository::_FlusherThread(void *) { // ERRORTRACE((LOG_REPDRV, "Flusher thread stated, thread = %lu\n", GetCurrentThreadId())); if (InterlockedIncrement(&m_threadCount) != 1) { ERRORTRACE((LOG_REPDRV, "Too many flusher threads detected in startup of thread!\n")); OutputDebugString(L"WinMgmt: Too many flusher threads detected in startup of thread!\n"); DebugBreak(); } HANDLE aHandles[2]; aHandles[0] = m_hWriteEvent; aHandles[1] = m_hReadEvent; DWORD dwTimeout = INFINITE; LONG ulPreviousReadCount = m_ulReadCount; LONG ulPreviousWriteCount = m_ulWriteCount; bool bShutdownThread = false; while (!g_bShuttingDown && !bShutdownThread) { DWORD dwRet = WaitForMultipleObjects(2, aHandles, FALSE, dwTimeout); switch(dwRet) { case WAIT_OBJECT_0: //Write event { dwRet = WaitForSingleObject(m_hShutdownEvent, 15000); switch (dwRet) { case WAIT_OBJECT_0: break; //Shutting down, we cannot grab the lock so let the //initiator of shutdown do the flush for us case WAIT_TIMEOUT: { //We need to do a flush... either shutting down or idle CAutoWriteLock lock(&g_readWriteLock); if (lock.Lock()) { if (g_Glob.GetFileCache()->Flush() != NO_ERROR) { RecoverCheckpoint(); } } break; } case WAIT_FAILED: break; } //Transition to flush mode dwTimeout = A51REP_CACHE_FLUSH_TIMEOUT; ulPreviousReadCount = m_ulReadCount; m_threadState = ThreadStateFlush; break; } case WAIT_OBJECT_0+1: //Read event //Reset the flush mode as read happened dwTimeout = A51REP_CACHE_FLUSH_TIMEOUT; ulPreviousReadCount = m_ulReadCount; m_threadState = ThreadStateFlush; break; case WAIT_TIMEOUT: //Timeout, so flush caches { //Check for if we are in an idle shutdown state... m_cs.Enter(); if (m_threadState == ThreadStateIdle) { m_threadState = ThreadStateDead; bShutdownThread = true; } m_cs.Leave(); if (bShutdownThread) break; //Not thread shutdown, so we check for cache flush if (ulPreviousReadCount == m_ulReadCount) { //Mark the idle for the next phase so if another //request comes in while we are doing this we will //be brought out of the idle state... dwTimeout = A51REP_THREAD_IDLE_TIMEOUT; m_threadState = ThreadStateIdle; m_ulReadCount = 0; //Flush the caches CAutoWriteLock lock(&g_readWriteLock); if (lock.Lock()) { g_Glob.GetForestCache()->Clear(); g_Glob.GetFileCache()->EmptyCaches(); //Recover the transaction manager if it has got into a bad state! g_Glob.GetFileCache()->RollbackCheckpointIfNeeded(); } } else { //We need to sleep for some more as some more reads happened ulPreviousReadCount = m_ulReadCount; dwTimeout = A51REP_CACHE_FLUSH_TIMEOUT; } break; } } } // ERRORTRACE((LOG_REPDRV, "Flusher thread quiting, thread = %lu\n", GetCurrentThreadId())); if (InterlockedDecrement(&m_threadCount) != 0) { ERRORTRACE((LOG_REPDRV, "Too many flusher threads detected on shutdown of thread\n")); OutputDebugString(L"WinMgmt: Too many flusher threads detected on shutdown of thread!\n"); DebugBreak(); } return 0; } HRESULT CRepository::ReadOperationNotification() { // ERRORTRACE((LOG_REPDRV, "Read Operation logged\n")); //Check to make sure the thread is active, if not we need to activate it! m_cs.Enter(); if (m_threadState == ThreadStateDead) { m_threadState = ThreadStateOperationPending; if (m_hFlusherThread) CloseHandle(m_hFlusherThread); m_hFlusherThread = CreateThread(NULL, 0, _FlusherThread, 0, 0, NULL); } m_threadState = ThreadStateOperationPending; m_cs.Leave(); if (InterlockedIncrement(&m_ulReadCount) == 1) SetEvent(m_hReadEvent); return NO_ERROR; } HRESULT CRepository::WriteOperationNotification() { // ERRORTRACE((LOG_REPDRV, "Write Operation logged\n")); //Check to make sure the thread is active, if not we need to activate it! m_cs.Enter(); if (m_threadState == ThreadStateDead) { m_threadState = ThreadStateOperationPending; if (m_hFlusherThread) CloseHandle(m_hFlusherThread); m_hFlusherThread = CreateThread(NULL, 0, _FlusherThread, 0, 0, NULL); } m_threadState = ThreadStateOperationPending; m_cs.Leave(); SetEvent(m_hWriteEvent); return NO_ERROR; } HRESULT CRepository::RecoverCheckpoint() { LONG lRes = g_Glob.GetFileCache()->RollbackCheckpoint(); g_Glob.GetForestCache()->Clear(); g_Glob.GetFileCache()->EmptyCaches(); if (lRes != 0) return WBEM_E_FAILED; else return WBEM_S_NO_ERROR; } // // // // ////////////////////////////////////////////////////////////////////// CGlobals g_Glob; HRESULT CGlobals::Initialize() { CInCritSec ics(&m_cs); if (m_bInit) return S_OK; HRESULT hRes; hRes = CoCreateInstance(CLSID_IWmiCoreServices, NULL, CLSCTX_INPROC_SERVER, IID__IWmiCoreServices, (void**)&m_pCoreServices); if (SUCCEEDED(hRes)) { hRes = m_ForestCache.Initialize(); if (SUCCEEDED(hRes)) { m_bInit = TRUE; } else { m_pCoreServices->Release(); m_pCoreServices = NULL; } } return hRes; } HRESULT CGlobals::Deinitialize() { CInCritSec ics(&m_cs); if (!m_bInit) return S_OK; HRESULT hRes; m_pCoreServices->Release(); m_pCoreServices = NULL; hRes = m_ForestCache.Deinitialize(); m_bInit = FALSE; return hRes; } _IWmiCoreServices * CGlobals::GetCoreSvcs() { if (m_pCoreServices) { m_pCoreServices->AddRef(); } return m_pCoreServices; } CForestCache * CGlobals::GetForestCache() { return &m_ForestCache; } CFileCache * CGlobals::GetFileCache() { return &m_FileCache; }