1 // Copyright 2018 The Chromium Authors 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef BASE_WIN_SCOPED_HANDLE_VERIFIER_H_ 6 #define BASE_WIN_SCOPED_HANDLE_VERIFIER_H_ 7 8 #include <memory> 9 #include <unordered_map> 10 11 #include "base/base_export.h" 12 #include "base/debug/stack_trace.h" 13 #include "base/hash/hash.h" 14 #include "base/memory/raw_ptr.h" 15 #include "base/synchronization/lock_impl.h" 16 #include "base/win/windows_types.h" 17 18 namespace base { 19 namespace win { 20 enum class HandleOperation; 21 namespace internal { 22 23 struct HandleHash { operatorHandleHash24 size_t operator()(const HANDLE& handle) const { 25 return base::FastHash(as_bytes(make_span(&handle, 1u))); 26 } 27 }; 28 29 struct ScopedHandleVerifierInfo { 30 ScopedHandleVerifierInfo(const void* owner, 31 const void* pc1, 32 const void* pc2, 33 std::unique_ptr<debug::StackTrace> stack, 34 DWORD thread_id); 35 ~ScopedHandleVerifierInfo(); 36 37 ScopedHandleVerifierInfo(const ScopedHandleVerifierInfo&) = delete; 38 ScopedHandleVerifierInfo& operator=(const ScopedHandleVerifierInfo&) = delete; 39 ScopedHandleVerifierInfo(ScopedHandleVerifierInfo&&) noexcept; 40 ScopedHandleVerifierInfo& operator=(ScopedHandleVerifierInfo&&) noexcept; 41 42 raw_ptr<const void> owner; 43 raw_ptr<const void> pc1; 44 raw_ptr<const void> pc2; 45 std::unique_ptr<debug::StackTrace> stack; 46 DWORD thread_id; 47 }; 48 49 // Implements the actual object that is verifying handles for this process. 50 // The active instance is shared across the module boundary but there is no 51 // way to delete this object from the wrong side of it (or any side, actually). 52 // We need [[clang::lto_visibility_public]] because instances of this class are 53 // passed across module boundaries. This means different modules must have 54 // compatible definitions of the class even when whole program optimization is 55 // enabled - which is what this attribute accomplishes. The pragma stops MSVC 56 // from emitting an unrecognized attribute warning. 57 #pragma warning(push) 58 #pragma warning(disable : 5030) 59 class [[clang::lto_visibility_public, nodiscard]] ScopedHandleVerifier { 60 #pragma warning(pop) 61 public: 62 ScopedHandleVerifier(const ScopedHandleVerifier&) = delete; 63 ScopedHandleVerifier& operator=(const ScopedHandleVerifier&) = delete; 64 65 // Retrieves the current verifier. 66 static ScopedHandleVerifier* Get(); 67 68 // The methods required by HandleTraits. They are virtual because we need to 69 // forward the call execution to another module, instead of letting the 70 // compiler call the version that is linked in the current module. 71 virtual bool CloseHandle(HANDLE handle); 72 virtual void StartTracking(HANDLE handle, const void* owner, const void* pc1, 73 const void* pc2); 74 virtual void StopTracking(HANDLE handle, const void* owner, const void* pc1, 75 const void* pc2); 76 virtual void Disable(); 77 virtual void OnHandleBeingClosed(HANDLE handle, HandleOperation operation); 78 virtual HMODULE GetModule() const; 79 80 private: 81 explicit ScopedHandleVerifier(bool enabled); 82 ~ScopedHandleVerifier(); // Not implemented. 83 84 void StartTrackingImpl(HANDLE handle, const void* owner, const void* pc1, 85 const void* pc2); 86 void StopTrackingImpl(HANDLE handle, const void* owner, const void* pc1, 87 const void* pc2); 88 void OnHandleBeingClosedImpl(HANDLE handle, HandleOperation operation); 89 90 static base::internal::LockImpl* GetLock(); 91 static void InstallVerifier(); 92 static void ThreadSafeAssignOrCreateScopedHandleVerifier( 93 ScopedHandleVerifier * existing_verifier, bool enabled); 94 95 base::debug::StackTrace creation_stack_; 96 bool enabled_; 97 raw_ptr<base::internal::LockImpl> lock_; 98 std::unordered_map<HANDLE, ScopedHandleVerifierInfo, HandleHash> map_; 99 }; 100 101 // This testing function returns the module that the HandleVerifier concrete 102 // implementation was instantiated in. 103 BASE_EXPORT HMODULE GetHandleVerifierModuleForTesting(); 104 105 } // namespace internal 106 } // namespace win 107 } // namespace base 108 109 #endif // BASE_WIN_SCOPED_HANDLE_VERIFIER_H_ 110