Merge pull request #411 from GameTechDev/feature/ipcv2

API backwards compatibility with dynamic loading + loader helper DLL

Author: markgalvan-intel

IntelPresentMon/AppCef/CefNano.args.json

@@ -36,6 +36,14 @@
       "Id": "8634f48b-7ed1-45af-8b73-5973c7b4b3c7",
       "Command": "--p2c-log-svc-pipe-enable"
     },
+    {
+      "Id": "b0fec119-97eb-46b4-bdd7-e1eb8b857c45",
+      "Command": "--p2c-middleware-dll-path .\\PresentMonAPI2.dll"
+    },
+    {
+      "Id": "0fb8cd38-1cf3-417f-a81c-894f60801ce8",
+      "Command": "--p2c-log-middleware-copy"
+    },
     {
       "Id": "bc2faf34-6d97-458c-8ff1-67f3102617da",
       "Command": "--p2c-enable-ui-dev-options"

IntelPresentMon/AppCef/source/winmain.cpp

@@ -11,6 +11,7 @@
 #include <Versioning/BuildId.h>
 #include <CommonUtilities/win/Utilities.h>
 #include <PresentMonAPIWrapper/DiagnosticHandler.h>
+#include <PresentMonAPI2Loader/Loader.h>
 #include <dwmapi.h>
 
 #pragma warning(push)
@@ -187,8 +188,6 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLi
 #else
     constexpr bool is_debug = true;
 #endif
-    // create logging system and ensure cleanup before main ext
-    LogChannelManager zLogMan_;
     // parse the command line arguments and make them globally available
     if (auto err = Options::Init(__argc, __argv, true)) {
         if (*err == 0) {
@@ -202,6 +201,12 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLi
         return *err;
     }
     const auto& opt = Options::Get();
+    // optionally override the middleware dll path (typically when running from IDE in dev cycle)
+    if (auto path = opt.middlewareDllPath.AsOptional()) {
+        pmLoaderSetPathToMiddlewareDll_(path->c_str());
+    }
+    // create logging system and ensure cleanup before main ext
+    LogChannelManager zLogMan_;
     // wait for debugger connection
     if ((opt.cefType && *opt.cefType == "renderer" && opt.debugWaitRender) ||
         (!opt.cefType && opt.debugWaitClient)) {
@@ -272,7 +277,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLi
 
         // code from here on is only executed by the root process (browser window process)
 
-        pmlog_info(std::format("== client section starting build#{} clean:{} ==", BuildIdShortHash(), BuildIdDirtyFlag()));
+        pmlog_info(std::format("== client section starting build#{} clean:{} ==", BuildIdShortHash(), !BuildIdDirtyFlag()));
 
         {
             auto& folderResolver = infra::util::FolderResolver::Get();

IntelPresentMon/CommonUtilities/Exception.cpp

@@ -68,14 +68,19 @@ namespace pmon::util
 		return PM_STATUS_FAILURE;
 	}
 
+	bool Exception::HasPmStatus() const noexcept
+	{
+		return false;
+	}
+
 	void DoCapture_(Exception& e)
 	{
 		if (log::GlobalPolicy::Get().GetExceptionTrace()) {
 			e.CaptureStackTrace();
 		}
 	}
 
-	std::string ReportException(std::string note, std::exception_ptr pEx) noexcept
+	std::pair<std::string, std::optional<PM_STATUS>> ReportException(std::string note, std::exception_ptr pEx) noexcept
 	{
 		if (!pEx) {
 			pEx = std::current_exception();
@@ -92,15 +97,26 @@ namespace pmon::util
 			try {
 				std::rethrow_exception(pEx);
 			}
+			catch (const pmon::util::Exception& e) {
+				try {
+					if (e.HasPmStatus()) {
+						return { concat(std::format("[{}] {}", typeid(e).name(), e.what())), e.GeneratePmStatus() };
+					}
+					else {
+						return { concat(std::format("[{}] {}", typeid(e).name(), e.what())), std::nullopt };
+					}
+				}
+				catch (...) { return {}; }
+			}
 			catch (const std::exception& e) {
-				try { return concat(std::format("[{}] {}", typeid(e).name(), e.what())); }
+				try { return { concat(std::format("[{}] {}", typeid(e).name(), e.what())), std::nullopt }; }
 				catch (...) { return {}; }
 			}
 			catch (...) {
-				return concat("Unrecognized exception");
+				return { concat("Unrecognized exception"), std::nullopt };
 			}
 		}
-		return concat("No exception in flight");
+		return { concat("No exception in flight"), std::nullopt };
 	}
 
 	PM_STATUS GeneratePmStatus(std::exception_ptr pEx) noexcept

IntelPresentMon/CommonUtilities/Exception.h

@@ -2,6 +2,7 @@
 #include "str/String.h"
 #include <exception>
 #include <memory>
+#include <optional>
 #include "../PresentMonAPI2/PresentMonAPI.h"
 
 namespace pmon::util
@@ -22,6 +23,7 @@ namespace pmon::util
 		std::string GetTraceString() const;
 		bool HasTrace() const noexcept;
 		virtual PM_STATUS GeneratePmStatus() const noexcept;
+		virtual bool HasPmStatus() const noexcept;
 	protected:
 		virtual std::string ComposeWhatString_() const noexcept;
 	private:
@@ -40,7 +42,7 @@ namespace pmon::util
 		return exception;
 	}
 
-	std::string ReportException(std::string note = {}, std::exception_ptr pEx = {}) noexcept;
+	std::pair<std::string, std::optional<PM_STATUS>> ReportException(std::string note = {}, std::exception_ptr pEx = {}) noexcept;
 
 	PM_STATUS GeneratePmStatus(std::exception_ptr pEx = {}) noexcept;
 

IntelPresentMon/CommonUtilities/cli/CliFramework.cpp

@@ -56,7 +56,7 @@ namespace pmon::util::cli
 		for (auto pWideStr : std::span{ wargv, size_t(argc) }) {
 			const auto narrow = str::ToNarrow(pWideStr);
 			auto pNarrowStr = new char[narrow.size() + 1];
-			strcpy_s(pNarrowStr, narrow.size() + 1, narrow.c_str());
+			strncpy_s(pNarrowStr, narrow.size() + 1, narrow.c_str(), _TRUNCATE);
 			stringPointerArray.push_back(pNarrowStr);
 		}
 	}

IntelPresentMon/CommonUtilities/log/DiagnosticDriver.cpp

@@ -26,7 +26,8 @@ namespace pmon::util::log
 	void DiagnosticDriver::Submit(const Entry& e)
 	{
 		// ignore non-diagnostic entries and low-priority levels
-		if (!e.diagnosticLayer_ || int(e.level_) > int(config_.filterLevel)) {
+		if ((!e.diagnosticLayer_ && !config_.disableDiagnosticFilter)
+			|| int(e.level_) > int(config_.filterLevel)) {
 			return;
 		}
 		// filtering by subsystem

IntelPresentMon/CommonUtilities/log/EntryBuilder.h

@@ -74,12 +74,22 @@ namespace pmon::util::log
 		EntryBuilder& diag() noexcept;
 		EntryBuilder& subsys(Subsystem sys) noexcept;
 		EntryStream stream() noexcept;
-		template<typename T>
-		EntryBuilder& code(const T& code) noexcept
+		template<typename C>
+		EntryBuilder& code(const C& code) noexcept
 		{
 			errorCode_ = { code };
 			return *this;
-		} 
+		}
+		template<typename C>
+		EntryBuilder& note(std::pair<std::string, std::optional<C>> noteWithCode) noexcept
+		{
+			auto&& [msg_, code_] = noteWithCode;
+			note(std::move(msg_));
+			if (code_) {
+				code(*code_);
+			}
+			return *this;
+		}
 	private:
 		// functions
 		void commit_() noexcept;

IntelPresentMon/CommonUtilities/log/Log.h

@@ -34,10 +34,11 @@ namespace pmon::util::log
 #endif
 #endif
 
-#define pmlog_(lvl) ((PMLOG_BUILD_LEVEL_ < lvl) || (::pmon::util::log::GlobalPolicy::Get().GetLogLevel() < lvl)) \
-	? (void)0 : ::pmon::util::log::Voidifier_{} & ::pmon::util::log::EntryBuilder{ lvl, __FILE__, __FUNCTION__, __LINE__ } \
+#define pmlog_from_(lvl, file, function, line) ((PMLOG_BUILD_LEVEL_ < lvl) || (::pmon::util::log::GlobalPolicy::Get().GetLogLevel() < lvl)) \
+	? (void)0 : ::pmon::util::log::Voidifier_{} & ::pmon::util::log::EntryBuilder{ lvl, file, function, line } \
 	.subsys(::pmon::util::log::GlobalPolicy::Get().GetSubsystem()) \
 	.to(::pmon::util::log::GetDefaultChannel())
+#define pmlog_(lvl) pmlog_from_(lvl, __FILE__, __FUNCTION__, __LINE__)
 #define pmlog_fatal	pmlog_(::pmon::util::log::Level::Fatal).note
 #define pmlog_error	pmlog_(::pmon::util::log::Level::Error).note
 #define pmlog_warn	pmlog_(::pmon::util::log::Level::Warning).note

IntelPresentMon/CommonUtilities/log/PanicLogger.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <string>
+#include <optional>
 
 #ifndef NDEBUG
 #define pmlog_panic_ PMLogPanic_
@@ -10,5 +11,10 @@
 namespace pmon::util::log
 {
 	void PMLogPanic_(const std::string& msg) noexcept;
+	template<class C>
+	void PMLogPanic_(const std::pair<std::string, std::optional<C>>& msg) noexcept
+	{
+		PMLogPanic_(msg.first);
+	}
 }
 

IntelPresentMon/CommonUtilities/reg/Registry.h

@@ -153,19 +153,20 @@ namespace pmon::util::reg
 			return key_.IsValid();
 		}
 	protected:
-		Registry(HKEY hive, std::wstring keyPath) noexcept
+		Registry(HKEY hive, std::wstring keyPath, bool readOnly) noexcept
 			:
 			hive_{ hive },
 			keyPath_{ keyPath }
 		{
 			// opening existing key
 			try {
-				key_.Open(hive_, keyPath_);
+				key_.Open(hive_, keyPath_, readOnly ? (KEY_READ) : (KEY_READ | KEY_WRITE));
 				return;
 			}
 			catch (const winreg::RegException& e) {
 				if (e.code().value() == 2) {
 					pmlog_warn(std::format("Registry key [{}] does not exist, creating...", str::ToNarrow(keyPath)));
+					// note the lack of return here, allowing us to continue on to the creation routine below
 				}
 				else {
 					pmlog_error(ReportException(std::format("Failed to open registry key [{}]", str::ToNarrow(keyPath))));
@@ -190,7 +191,7 @@ namespace pmon::util::reg
 		winreg::RegKey key_;
 	};
 
-	template<class T>
+	template<class T, HKEY Hive>
 	class RegistryBase : public Registry
 	{
 	public:
@@ -199,13 +200,13 @@ namespace pmon::util::reg
 			static T reg;
 			return reg;
 		}
-		static void SetPrivileged(bool privileged) noexcept
+		static void SetReadonly(bool readonly = true) noexcept
 		{
-			privileged_ = privileged;
+			readonly_ = readonly;
 		}
 	protected:
-		RegistryBase() : Registry{ privileged_ ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER, T::keyPath_ } {}
+		RegistryBase() : Registry{ Hive, T::keyPath_, readonly_ } {}
 	private:
-		inline static bool privileged_ = true;
+		inline static bool readonly_ = false;
 	};
 }