second batch of original vulkan pointers alongside basic hooks

CMakeLists.txt

@@ -20,6 +20,7 @@ add_subdirectory(lsfg-vk-gen)
 
 file(GLOB SOURCES
     "src/loader/*.cpp"
+    "src/vulkan/*.cpp"
     "src/*.cpp"
 )
 

include/vulkan/funcs.hpp

@@ -10,17 +10,44 @@ namespace Vulkan::Funcs {
     ///
     void initialize();
 
+    ///
+    /// Initialize the instance Vulkan function pointers.
+    ///
+    /// @param instance The Vulkan instance to initialize.
+    ///
+    void initializeInstance(VkInstance instance);
+
+    ///
+    /// Initialize the device Vulkan function pointers.
+    ///
+    /// @param device The Vulkan device to initialize.
+    ///
+    void initializeDevice(VkDevice device);
+
     /// Call to the original vkCreateInstance function.
-    VkResult vkCreateInstanceOriginal(
+    VkResult ovkCreateInstance(
         const VkInstanceCreateInfo* pCreateInfo,
         const VkAllocationCallbacks* pAllocator,
         VkInstance* pInstance
     );
     /// Call to the original vkDestroyInstance function.
-    void vkDestroyInstanceOriginal(
+    void ovkDestroyInstance(
         VkInstance instance,
         const VkAllocationCallbacks* pAllocator
     );
+
+    /// Call to the original vkCreateDevice function.
+    VkResult ovkCreateDevice(
+        VkPhysicalDevice physicalDevice,
+        const VkDeviceCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDevice* pDevice
+    );
+    /// Call to the original vkDestroyDevice function.
+    void ovkDestroyDevice(
+        VkDevice device,
+        const VkAllocationCallbacks* pAllocator
+    );
 }
 
 #endif // FUNCS_HPP

include/vulkan/hooks.hpp

@@ -0,0 +1,13 @@
+#ifndef HOOKS_HPP
+#define HOOKS_HPP
+
+namespace Vulkan::Hooks {
+
+    ///
+    /// Install overrides for hooked Vulkan functions.
+    ///
+    void initialize();
+
+}
+
+#endif // HOOKS_HPP

src/init.cpp

@@ -1,5 +1,7 @@
 #include "loader/dl.hpp"
 #include "loader/vk.hpp"
+#include "vulkan/funcs.hpp"
+#include "vulkan/hooks.hpp"
 #include "log.hpp"
 
 extern "C" void __attribute__((constructor)) init();
@@ -11,6 +13,12 @@ void init() {
     // hook loaders
     Loader::DL::initialize();
     Loader::VK::initialize();
+
+    // setup vulkan stuff
+    Vulkan::Funcs::initialize();
+    Vulkan::Hooks::initialize();
+
+    Log::info("lsfg-vk: init() completed successfully");
 }
 
 void deinit() {

src/vulkan/funcs.cpp

@@ -1,5 +1,6 @@
 #include "vulkan/funcs.hpp"
 #include "loader/dl.hpp"
+#include "loader/vk.hpp"
 #include "log.hpp"
 
 using namespace Vulkan;
@@ -7,6 +8,9 @@ using namespace Vulkan;
 namespace {
     PFN_vkCreateInstance vkCreateInstance_ptr{};
     PFN_vkDestroyInstance vkDestroyInstance_ptr{};
+
+    PFN_vkCreateDevice vkCreateDevice_ptr{};
+    PFN_vkDestroyDevice vkDestroyDevice_ptr{};
 }
 
 void Funcs::initialize() {
@@ -28,17 +32,53 @@ void Funcs::initialize() {
     Log::debug("lsfg-vk(funcs): Initialized global Vulkan functions with original pointers");
 }
 
+void Funcs::initializeInstance(VkInstance instance) {
+    if (vkCreateDevice_ptr || vkDestroyDevice_ptr) {
+        Log::warn("lsfg-vk(funcs): Instance Vulkan functions already initialized, did you call it twice?");
+        return;
+    }
+
+    vkCreateDevice_ptr = reinterpret_cast<PFN_vkCreateDevice>(
+        Loader::VK::ovkGetInstanceProcAddr(instance, "vkCreateDevice"));
+    vkDestroyDevice_ptr = reinterpret_cast<PFN_vkDestroyDevice>(
+        Loader::VK::ovkGetInstanceProcAddr(instance, "vkDestroyDevice"));
+    if (!vkCreateDevice_ptr || !vkDestroyDevice_ptr) {
+        Log::error("lsfg-vk(funcs): Failed to initialize Vulkan instance functions, missing symbols");
+        exit(EXIT_FAILURE);
+    }
+
+    Log::debug("lsfg-vk(funcs): Initialized instance Vulkan functions with original pointers");
+}
+
+void Funcs::initializeDevice(VkDevice device) {
+    Log::debug("lsfg-vk(funcs): Initialized device Vulkan functions with original pointers");
+}
+
 // original function calls
 
-VkResult Funcs::vkCreateInstanceOriginal(
+VkResult Funcs::ovkCreateInstance(
         const VkInstanceCreateInfo* pCreateInfo,
         const VkAllocationCallbacks* pAllocator,
         VkInstance* pInstance) {
     return vkCreateInstance_ptr(pCreateInfo, pAllocator, pInstance);
 }
 
-void Funcs::vkDestroyInstanceOriginal(
+void Funcs::ovkDestroyInstance(
         VkInstance instance,
         const VkAllocationCallbacks* pAllocator) {
     vkDestroyInstance_ptr(instance, pAllocator);
 }
+
+VkResult Funcs::ovkCreateDevice(
+        VkPhysicalDevice physicalDevice,
+        const VkDeviceCreateInfo* pCreateInfo,
+        const VkAllocationCallbacks* pAllocator,
+        VkDevice* pDevice) {
+    return vkCreateDevice_ptr(physicalDevice, pCreateInfo, pAllocator, pDevice);
+}
+
+void Funcs::ovkDestroyDevice(
+        VkDevice device,
+        const VkAllocationCallbacks* pAllocator) {
+    vkDestroyDevice_ptr(device, pAllocator);
+}

src/vulkan/hooks.cpp

@@ -0,0 +1,66 @@
+#include "vulkan/hooks.hpp"
+#include "vulkan/funcs.hpp"
+#include "loader/dl.hpp"
+#include "loader/vk.hpp"
+#include "log.hpp"
+
+#include <vulkan/vulkan_core.h>
+
+using namespace Vulkan;
+
+namespace {
+    bool initialized{false};
+
+    VkResult myvkCreateInstance(
+            const VkInstanceCreateInfo* pCreateInfo,
+            const VkAllocationCallbacks* pAllocator,
+            VkInstance* pInstance) {
+        auto res = Funcs::ovkCreateInstance(pCreateInfo, pAllocator, pInstance);
+
+        Funcs::initializeInstance(*pInstance);
+
+        return res;
+    }
+
+    VkResult myvkCreateDevice(
+            VkPhysicalDevice physicalDevice,
+            const VkDeviceCreateInfo* pCreateInfo,
+            const VkAllocationCallbacks* pAllocator,
+            VkDevice* pDevice) {
+        auto res = Funcs::ovkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+
+        Funcs::initializeDevice(*pDevice);
+
+        return res;
+    }
+
+}
+
+void Hooks::initialize() {
+    if (initialized) {
+        Log::warn("Vulkan hooks already initialized, did you call it twice?");
+        return;
+    }
+
+    // register hooks to vulkan loader
+    Loader::VK::registerSymbol("vkCreateInstance",
+        reinterpret_cast<void*>(myvkCreateInstance));
+    Loader::VK::registerSymbol("vkCreateDevice",
+        reinterpret_cast<void*>(myvkCreateDevice));
+
+    // register hooks to dynamic loader under libvulkan.so.1
+    Loader::DL::File vk1("libvulkan.so.1");
+    vk1.defineSymbol("vkCreateInstance",
+        reinterpret_cast<void*>(myvkCreateInstance));
+    vk1.defineSymbol("vkCreateDevice",
+        reinterpret_cast<void*>(myvkCreateDevice));
+    Loader::DL::registerFile(vk1);
+
+    // register hooks to dynamic loader under libvulkan.so
+    Loader::DL::File vk2("libvulkan.so");
+    vk2.defineSymbol("vkCreateInstance",
+        reinterpret_cast<void*>(myvkCreateInstance));
+    vk2.defineSymbol("vkCreateDevice",
+        reinterpret_cast<void*>(myvkCreateDevice));
+    Loader::DL::registerFile(vk2);
+}