void CordbAppDomain::AddToTypeList(CordbBase *pObject) { INTERNAL_API_ENTRY(this); _ASSERTE(pObject != NULL); RSLockHolder lockHolder(GetProcess()->GetProcessLock()); this->m_TypeNeuterList.Add(GetProcess(), pObject); }
void _RegisterConcRTEventTracing() { #if defined(_ONECORE) || defined(_KERNELX) g_pEtw = NULL; #else // Initialize ETW dynamically, and only once, to avoid a static dependency on Advapi32.dll. _StaticLock::_Scoped_lock lockHolder(Etw::s_lock); if (g_pEtw == NULL) { g_pEtw = _concrt_new Etw(); static TRACE_GUID_REGISTRATION eventGuidRegistration[] = { { &Concurrency::ConcRTEventGuid, NULL }, { &Concurrency::SchedulerEventGuid, NULL }, { &Concurrency::ScheduleGroupEventGuid, NULL }, { &Concurrency::ContextEventGuid, NULL }, { &Concurrency::ChoreEventGuid, NULL }, { &Concurrency::LockEventGuid, NULL }, { &Concurrency::ResourceManagerEventGuid, NULL } }; ULONG eventGuidCount = sizeof eventGuidRegistration / sizeof eventGuidRegistration[0]; g_pEtw->RegisterGuids(Concurrency::details::ControlCallback, &ConcRT_ProviderGuid, eventGuidCount, eventGuidRegistration, &g_ConcRTPRoviderHandle); } #endif // defined(_ONECORE) || defined(_KERNELX) }
void CordbAppDomain::PrepopulateAssembliesOrThrow() { INTERNAL_API_ENTRY(GetProcess()); RSLockHolder lockHolder(GetProcess()->GetProcessLock()); if (!GetProcess()->IsDacInitialized()) { return; } // DD-primitive that invokes a callback. GetProcess()->GetDAC()->EnumerateAssembliesInAppDomain( this->m_vmAppDomain, CordbAppDomain::AssemblyEnumerationCallback, this); // user data }
// Gets a CordbModule that has the given metadata interface // // Arguments: // pIMetaData - metadata interface // // Returns: // CordbModule whose associated metadata matches the metadata interface provided here // Throws on error. Returns non-null // CordbModule * CordbAppDomain::GetModuleFromMetaDataInterface(IUnknown *pIMetaData) { HRESULT hr = S_OK; RSExtSmartPtr<IMetaDataImport> pImport; RSLockHolder lockHolder(GetProcess()->GetProcessLock()); // need for module enumeration // Grab the interface we need... hr = pIMetaData->QueryInterface(IID_IMetaDataImport, (void**)&pImport); if (FAILED(hr)) { ThrowHR(E_INVALIDARG); } // Get the mvid of the given module. GUID matchMVID; hr = pImport->GetScopeProps(NULL, 0, 0, &matchMVID); IfFailThrow(hr); CordbModule* pModule; HASHFIND findmodule; PrepopulateModules(); for (pModule = m_modules.FindFirst(&findmodule); pModule != NULL; pModule = m_modules.FindNext(&findmodule)) { IMetaDataImport * pImportCurrent = pModule->GetMetaDataImporter(); // throws _ASSERTE(pImportCurrent != NULL); // Get the mvid of this module GUID MVID; hr = pImportCurrent->GetScopeProps(NULL, 0, 0, &MVID); IfFailThrow(hr); if (MVID == matchMVID) { return pModule; } } ThrowHR(E_INVALIDARG); }
bool AuthzManagerExternalStateMongos::tryAcquireAuthzUpdateLock(const StringData& why) { boost::lock_guard<boost::mutex> lkLocal(_distLockGuard); if (_authzDataUpdateLock.get()) { return false; } // Temporarily put into an auto_ptr just in case there is an exception thrown during // lock acquisition. std::auto_ptr<ScopedDistributedLock> lockHolder(new ScopedDistributedLock( configServer.getConnectionString(), "authorizationData")); lockHolder->setLockMessage(why.toString()); std::string errmsg; if (!lockHolder->acquire(_authzUpdateLockAcquisitionTimeoutMillis, &errmsg)) { warning() << "Error while attempting to acquire distributed lock for user modification: " << errmsg << endl; return false; } _authzDataUpdateLock.reset(lockHolder.release()); return true; }
HeapTimer::HeapTimer(VM* vm) : m_vm(vm) { RefPtr<JSLock> lockProtector(&m_vm->apiLock()); m_timer.initialize("[JSC] HeapTimer", [this, lockProtector] { auto& apiLock = *lockProtector; apiLock.lock(); VM* vm = apiLock.vm(); if (!vm) { apiLock.unlock(); return; } { JSLockHolder lockHolder(vm); doWork(); } apiLock.unlock(); }); }
BOOL PAL_VirtualUnwindOutOfProc(CONTEXT *context, KNONVOLATILE_CONTEXT_POINTERS *contextPointers, DWORD pid, ReadMemoryWordCallback readMemCallback) { // This function can be executed only by one thread at a time. // The reason for this is that we need to pass context and read mem function to libunwind callbacks // but "arg" is already used by the pointer returned from _UPT_create(). // So we resort to using global variables and a lock. struct Lock { CRITICAL_SECTION cs; Lock() { // ctor of a static variable is a thread-safe way to initialize critical section exactly once (clang,gcc) InitializeCriticalSection(&cs); } }; struct LockHolder { CRITICAL_SECTION *cs; LockHolder(CRITICAL_SECTION *cs) { this->cs = cs; EnterCriticalSection(cs); } ~LockHolder() { LeaveCriticalSection(cs); cs = NULL; } }; static Lock lock; LockHolder lockHolder(&lock.cs); int st; unw_context_t unwContext; unw_cursor_t cursor; unw_addr_space_t addrSpace = 0; void *libunwindUptPtr = NULL; BOOL result = FALSE; LibunwindCallbacksInfo.Context = context; LibunwindCallbacksInfo.readMemCallback = readMemCallback; WinContextToUnwindContext(context, &unwContext); addrSpace = unw_create_addr_space(&unwind_accessors, 0); libunwindUptPtr = _UPT_create(pid); st = unw_init_remote(&cursor, addrSpace, libunwindUptPtr); if (st < 0) { result = FALSE; goto Exit; } st = unw_step(&cursor); if (st < 0) { result = FALSE; goto Exit; } UnwindContextToWinContext(&cursor, context); if (contextPointers != NULL) { GetContextPointers(&cursor, &unwContext, contextPointers); } result = TRUE; Exit: if (libunwindUptPtr != nullptr) { _UPT_destroy(libunwindUptPtr); } if (addrSpace != 0) { unw_destroy_addr_space(addrSpace); } return result; }
size_t ExecutableAllocator::committedByteCount() { SpinLockHolder lockHolder(&spinlock); return committedBytesCount; }