Check handles in PhysicalDeviceFunctionErrorPath

Add an internal function to the test_icd which validates that the passed
in physical device is one from the driver.

Author: charles-lunarg

tests/framework/icd/test_icd.cpp

@@ -1624,6 +1624,11 @@ VKAPI_ATTR VkResult VKAPI_CALL test_vkGetCalibratedTimestampsEXT(VkDevice device
     return VK_SUCCESS;
 }
 
+VKAPI_ATTR VkResult VKAPI_CALL test_icd_internal_function(VkPhysicalDevice physicalDevice, uint32_t a, uint32_t b, float c) {
+    check_valid_physical_device(physicalDevice);
+    return VK_SUCCESS;
+}
+
 #if defined(WIN32)
 VKAPI_ATTR VkResult VKAPI_CALL test_vk_icdEnumerateAdapterPhysicalDevices(VkInstance instance, LUID adapterLUID,
                                                                           uint32_t* pPhysicalDeviceCount,
@@ -1955,7 +1960,9 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL get_physical_device_func(VkInstance ins
         if (string_eq(pName, "vkGetPhysicalDeviceToolPropertiesEXT"))
             return to_vkVoidFunction(test_vkGetPhysicalDeviceToolPropertiesEXT);
     }
-
+    if (icd.supports_internal_function && string_eq(pName, TEST_ICD_INTERNAL_FUNCTION_NAME_STRING)) {
+        return to_vkVoidFunction(test_icd_internal_function);
+    }
     for (auto const& [phys_dev_handle, phys_dev] : icd.created_physical_device_details) {
         if (phys_dev.instance_created_from != instance) {
             continue;

tests/framework/icd/test_icd.h

@@ -83,6 +83,8 @@ inline std::ostream& operator<<(std::ostream& os, const InterfaceVersionCheck& r
 
 using VulkanUUID = std::array<uint8_t, VK_UUID_SIZE>;
 
+using PFN_test_icd_internal_function = VKAPI_ATTR VkResult (VKAPI_CALL *)(VkPhysicalDevice physicalDevice, uint32_t a, uint32_t b, float c);
+#define TEST_ICD_INTERNAL_FUNCTION_NAME_STRING "TEST_ICD_INTERNAL_FUNCTION_NAME"
 // clang-format on
 
 // Move only type because it holds a DispatchableHandle<VkPhysicalDevice>
@@ -288,6 +290,9 @@ struct TestICD {
     // known_device_functions member)
     BUILDER_VECTOR(VulkanFunction, custom_instance_functions, custom_instance_function)
 
+    // When true, this ICD returns function pointers when TEST_ICD_INTERNAL_FUNCTION_NAME is queried.
+    BUILDER_VALUE(bool, supports_internal_function)
+
     // Must explicitely state support for the tooling info extension, that way we can control if vkGetInstanceProcAddr returns a
     // function pointer for vkGetPhysicalDeviceToolPropertiesEXT or vkGetPhysicalDeviceToolProperties (core version)
     BUILDER_VALUE(bool, supports_tooling_info_ext);

tests/loader_unknown_ext_tests.cpp

@@ -390,39 +390,34 @@ TEST(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupport) {
     }
 }
 
-// Add unknown functions to driver 0, and try to use them on driver 1.
+// Add unknown functions to driver 0, and try to use them on driver 1. Needs TestICD to implement the unknown function so that it
+// can validate the passed in VkPhysicalDevice
 TEST(UnknownFunctionDeathTests, PhysicalDeviceFunctionErrorPath) {
     FrameworkEnvironment env{};
     auto& driver_0 = env.add_icd(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA);
-    auto& driver_1 = env.add_icd(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA);
-    std::vector<std::string> function_names;
-    add_function_names(function_names, 1);
+    auto& driver_1 = env.add_icd(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_supports_internal_function(true);
 
     // used to identify the GPUs
-    auto& test_physical_driver_0 = driver_0.add_and_get_physical_device("physical_device_0");
-    test_physical_driver_0.properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
-    auto& test_physical_driver_1 = driver_1.add_and_get_physical_device("physical_device_1");
-    test_physical_driver_1.properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
-    function_names.push_back(std::string("vkNotIntRealFuncTEST_0"));
-
-    custom_physical_device_functions funcs{};
-    test_physical_driver_0.custom_physical_device_functions.push_back(
-        VulkanFunction{function_names.back(), to_vkVoidFunction(funcs.func_zero)});
+    driver_0.add_and_get_physical_device("physical_device_0").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
+    driver_1.add_and_get_physical_device("physical_device_1").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
 
     InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     auto phys_devs = inst.GetPhysDevs(2);
-    VkPhysicalDevice phys_dev_to_use = phys_devs[1];
     VkPhysicalDeviceProperties props{};
+    env.vulkan_functions.vkGetPhysicalDeviceProperties(phys_devs[0], &props);
+    ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU);
+
     env.vulkan_functions.vkGetPhysicalDeviceProperties(phys_devs[1], &props);
-    if (props.deviceType != VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) phys_dev_to_use = phys_devs[0];
-    // use the wrong GPU to query the functions, should get 5 errors
+    ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU);
 
-    decltype(custom_physical_device_functions::func_zero)* returned_func_i =
-        env.vulkan_functions.load(inst.inst, function_names.at(0).c_str());
+    // GPU that supports the unknown function is enumerated first (gpus are enumerated in reverse order)
+    PFN_test_icd_internal_function returned_func_i = env.vulkan_functions.load(inst.inst, TEST_ICD_INTERNAL_FUNCTION_NAME_STRING);
     ASSERT_NE(returned_func_i, nullptr);
-    ASSERT_DEATH(returned_func_i(phys_dev_to_use, 0), "Function vkNotIntRealFuncTEST_0 not supported for this physical device");
+    ASSERT_EQ(returned_func_i(phys_devs[0], 0, 1, 2.2f), VK_SUCCESS);
+    ASSERT_DEATH(returned_func_i(phys_devs[1], 0, 1, 2.2f),
+                 "Function " TEST_ICD_INTERNAL_FUNCTION_NAME_STRING " not supported for this physical device");
 }
 
 TEST(UnknownFunction, PhysicalDeviceFunctionWithImplicitLayerImplementation) {