Add drivers field to settings file

Allows the settings file to contain 'additional drivers' which are just paths
to ICD manifest files.

Author: charles-lunarg

loader/loader.c

@@ -3818,6 +3818,12 @@ VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_t
         goto out;
     }
 
+    // Add any drivers provided by the loader settings file
+    res = loader_settings_get_additional_driver_files(inst, &manifest_files);
+    if (VK_SUCCESS != res) {
+        goto out;
+    }
+
     icd_details = loader_stack_alloc(sizeof(struct ICDManifestInfo) * manifest_files.count);
     if (NULL == icd_details) {
         res = VK_ERROR_OUT_OF_HOST_MEMORY;

loader/settings.c

@@ -44,13 +44,24 @@ void free_layer_configuration(const struct loader_instance* inst, loader_setting
     memset(layer_configuration, 0, sizeof(loader_settings_layer_configuration));
 }
 
+void free_driver_configuration(const struct loader_instance* inst, loader_settings_driver_configuration* driver_configuration) {
+    loader_instance_heap_free(inst, driver_configuration->path);
+    memset(driver_configuration, 0, sizeof(loader_settings_driver_configuration));
+}
+
 void free_loader_settings(const struct loader_instance* inst, loader_settings* settings) {
     if (NULL != settings->layer_configurations) {
         for (uint32_t i = 0; i < settings->layer_configuration_count; i++) {
             free_layer_configuration(inst, &settings->layer_configurations[i]);
         }
+        loader_instance_heap_free(inst, settings->layer_configurations);
+    }
+    if (NULL != settings->additional_drivers) {
+        for (uint32_t i = 0; i < settings->additional_driver_count; i++) {
+            free_driver_configuration(inst, &settings->additional_drivers[i]);
+        }
+        loader_instance_heap_free(inst, settings->additional_drivers);
     }
-    loader_instance_heap_free(inst, settings->layer_configurations);
     loader_instance_heap_free(inst, settings->settings_file_path);
     memset(settings, 0, sizeof(loader_settings));
 }
@@ -207,6 +218,74 @@ VkResult parse_layer_configurations(const struct loader_instance* inst, cJSON* s
     return res;
 }
 
+VkResult parse_additional_driver(const struct loader_instance* inst, cJSON* additional_driver_json,
+                                 loader_settings_driver_configuration* additional_driver) {
+    VkResult res = VK_SUCCESS;
+    res = loader_parse_json_string(additional_driver_json, "path", &(additional_driver->path));
+    if (res != VK_SUCCESS) {
+        goto out;
+    }
+out:
+    if (res != VK_SUCCESS) {
+        free_driver_configuration(inst, additional_driver);
+    }
+    return res;
+}
+
+VkResult parse_additional_drivers(const struct loader_instance* inst, cJSON* settings_object, loader_settings* loader_settings) {
+    VkResult res = VK_SUCCESS;
+
+    cJSON* use_additional_drivers_exclusively_json =
+        loader_cJSON_GetObjectItem(settings_object, "use_additional_drivers_exclusively");
+    if (use_additional_drivers_exclusively_json && use_additional_drivers_exclusively_json->type == cJSON_True) {
+        loader_settings->use_additional_drivers_exclusively = true;
+    }
+
+    cJSON* additional_drivers_json = loader_cJSON_GetObjectItem(settings_object, "additional_drivers");
+    if (NULL == additional_drivers_json) {
+        return VK_SUCCESS;
+    }
+
+    uint32_t additional_driver_count = loader_cJSON_GetArraySize(additional_drivers_json);
+    if (additional_driver_count == 0) {
+        return VK_SUCCESS;
+    }
+
+    loader_settings->additional_driver_count = additional_driver_count;
+
+    loader_settings->additional_drivers = loader_instance_heap_calloc(
+        inst, sizeof(loader_settings_layer_configuration) * additional_driver_count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+    if (NULL == loader_settings->additional_drivers) {
+        res = VK_ERROR_OUT_OF_HOST_MEMORY;
+        goto out;
+    }
+
+    cJSON* driver = NULL;
+    size_t i = 0;
+    cJSON_ArrayForEach(driver, additional_drivers_json) {
+        if (driver->type != cJSON_Object) {
+            res = VK_ERROR_INITIALIZATION_FAILED;
+            goto out;
+        }
+        res = parse_additional_driver(inst, driver, &(loader_settings->additional_drivers[i++]));
+        if (VK_SUCCESS != res) {
+            goto out;
+        }
+    }
+out:
+    if (res != VK_SUCCESS) {
+        if (loader_settings->additional_drivers) {
+            for (size_t index = 0; index < loader_settings->additional_driver_count; index++) {
+                free_driver_configuration(inst, &(loader_settings->additional_drivers[index]));
+            }
+            loader_settings->additional_driver_count = 0;
+            loader_instance_heap_free(inst, loader_settings->additional_drivers);
+            loader_settings->additional_drivers = NULL;
+        }
+    }
+    return res;
+}
+
 VkResult check_if_settings_path_exists(const struct loader_instance* inst, const char* base, const char* suffix,
                                        char** settings_file_path) {
     if (NULL == base || NULL == suffix) {
@@ -248,6 +327,23 @@ VkResult get_unix_settings_path(const struct loader_instance* inst, char** setti
                                          settings_file_path);
 }
 
+bool check_if_layer_configurations_are_equal(loader_settings_layer_configuration* a, loader_settings_layer_configuration* b) {
+    if (!a->name || !b->name || 0 != strcmp(a->name, b->name)) {
+        return false;
+    }
+    if (!a->path || !b->path || 0 != strcmp(a->path, b->path)) {
+        return false;
+    }
+    return a->control == b->control;
+}
+
+bool check_if_driver_configurations_are_equal(loader_settings_driver_configuration* a, loader_settings_driver_configuration* b) {
+    if (!a->path || !b->path || 0 != strcmp(a->path, b->path)) {
+        return false;
+    }
+    return true;
+}
+
 bool check_if_settings_are_equal(loader_settings* a, loader_settings* b) {
     // If either pointer is null, return true
     if (NULL == a || NULL == b) return false;
@@ -256,19 +352,13 @@ bool check_if_settings_are_equal(loader_settings* a, loader_settings* b) {
     are_equal &= a->has_unordered_layer_location == b->has_unordered_layer_location;
     are_equal &= a->debug_level == b->debug_level;
     are_equal &= a->layer_configuration_count == b->layer_configuration_count;
+    are_equal &= a->additional_driver_count == b->additional_driver_count;
     if (!are_equal) return false;
     for (uint32_t i = 0; i < a->layer_configuration_count && i < b->layer_configuration_count; i++) {
-        if (a->layer_configurations[i].name && b->layer_configurations[i].name) {
-            are_equal &= 0 == strcmp(a->layer_configurations[i].name, b->layer_configurations[i].name);
-        } else {
-            are_equal = false;
-        }
-        if (a->layer_configurations[i].path && b->layer_configurations[i].path) {
-            are_equal &= 0 == strcmp(a->layer_configurations[i].path, b->layer_configurations[i].path);
-        } else {
-            are_equal = false;
-        }
-        are_equal &= a->layer_configurations[i].control == b->layer_configurations[i].control;
+        are_equal &= check_if_layer_configurations_are_equal(&a->layer_configurations[i], &b->layer_configurations[i]);
+    }
+    for (uint32_t i = 0; i < a->additional_driver_count && i < b->additional_driver_count; i++) {
+        are_equal &= check_if_driver_configurations_are_equal(&a->additional_drivers[i], &b->additional_drivers[i]);
     }
     return are_equal;
 }
@@ -302,6 +392,17 @@ void log_settings(const struct loader_instance* inst, loader_settings* settings)
         loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0, "Control: %s",
                    loader_settings_layer_control_to_string(settings->layer_configurations[i].control));
     }
+    if (settings->additional_driver_count > 0) {
+        loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0, "----");
+        loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0, "Use Additional Drivers Exclusively = %s",
+                   settings->use_additional_drivers_exclusively ? "true" : "false");
+        loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0, "Additional Driver Configurations count = %d",
+                   settings->additional_driver_count);
+        for (uint32_t i = 0; i < settings->additional_driver_count; i++) {
+            loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0, "---- Driver Configuration [%d] ----", i);
+            loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0, "Path: %s", settings->additional_drivers[i].path);
+        }
+    }
     loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0, "---------------------------------");
 }
 
@@ -471,6 +572,11 @@ VkResult get_loader_settings(const struct loader_instance* inst, loader_settings
         }
     }
 
+    res = parse_additional_drivers(inst, settings_to_use, loader_settings);
+    if (res != VK_SUCCESS) {
+        goto out;
+    }
+
     loader_settings->settings_file_path = settings_file_path;
     settings_file_path = NULL;
     loader_settings->settings_active = true;
@@ -866,3 +972,25 @@ VkResult enable_correct_layers_from_settings(const struct loader_instance* inst,
 out:
     return res;
 }
+
+VkResult loader_settings_get_additional_driver_files(const struct loader_instance* inst, struct loader_string_list* out_files) {
+    VkResult res = VK_SUCCESS;
+
+    const loader_settings* settings = get_current_settings_and_lock(inst);
+
+    if (NULL == settings || !settings->settings_active) {
+        goto out;
+    }
+
+    if (settings->use_additional_drivers_exclusively) {
+        free_string_list(inst, out_files);
+    }
+
+    for (uint32_t i = 0; i < settings->additional_driver_count; i++) {
+        res = prepend_if_manifest_file(inst, settings->additional_drivers[i].path, out_files);
+    }
+
+out:
+    release_current_settings_lock(inst);
+    return res;
+}

loader/settings.h

@@ -34,6 +34,7 @@
 
 struct loader_instance;
 struct loader_layer_list;
+struct loader_string_list;
 struct loader_pointer_layer_list;
 struct loader_envvar_all_filters;
 typedef struct log_configuration log_configuration;
@@ -61,6 +62,10 @@ typedef struct loader_settings_layer_configuration {
 
 } loader_settings_layer_configuration;
 
+typedef struct loader_settings_driver_configuration {
+    char* path;
+} loader_settings_driver_configuration;
+
 typedef struct loader_settings {
     bool settings_active;
     bool has_unordered_layer_location;
@@ -69,6 +74,10 @@ typedef struct loader_settings {
     uint32_t layer_configuration_count;
     loader_settings_layer_configuration* layer_configurations;
 
+    bool use_additional_drivers_exclusively;
+    uint32_t additional_driver_count;
+    loader_settings_driver_configuration* additional_drivers;
+
     char* settings_file_path;
 } loader_settings;
 
@@ -112,3 +121,7 @@ VkResult enable_correct_layers_from_settings(const struct loader_instance* inst,
                                              const struct loader_layer_list* instance_layers,
                                              struct loader_pointer_layer_list* target_layer_list,
                                              struct loader_pointer_layer_list* activated_layer_list);
+
+// Add any drivers that the loader settings file contains to the out_files list. If the use_additional_drivers_exclusively field is
+// true, clear the out_files list before adding any additional drivers
+VkResult loader_settings_get_additional_driver_files(const struct loader_instance* inst, struct loader_string_list* out_files);

tests/framework/test_environment.cpp

@@ -687,12 +687,12 @@ TestICD& FrameworkEnvironment::add_icd(TestICDDetails icd_details) noexcept {
             case (ManifestDiscoveryType::unsecured_generic):
                 platform_shim->add_unsecured_manifest(ManifestCategory::icd, icds.back().manifest_path);
                 break;
-            case (ManifestDiscoveryType::null_dir):
-            case (ManifestDiscoveryType::none):
-                break;
             case (ManifestDiscoveryType::windows_app_package):
                 platform_shim->set_app_package_path(folder.location());
                 break;
+            case (ManifestDiscoveryType::null_dir):
+            case (ManifestDiscoveryType::none):
+                break;
         }
     }
     return icds.back().get_test_icd();
@@ -907,6 +907,16 @@ std::string get_loader_settings_file_contents(const LoaderSettings& loader_setti
             }
             writer.EndArray();
         }
+        if (!setting.driver_configurations.empty()) {
+            writer.AddKeyedBool("use_additional_drivers_exclusively", setting.use_additional_drivers_exclusively);
+            writer.StartKeyedArray("additional_drivers");
+            for (const auto& driver : setting.driver_configurations) {
+                writer.StartObject();
+                writer.AddKeyedString("path", driver.path);
+                writer.EndObject();
+            }
+            writer.EndArray();
+        }
         writer.EndObject();
     }
     if (!one_setting_file) {

tests/framework/test_environment.h

@@ -513,6 +513,7 @@ struct LoaderSettingsLayerConfiguration {
     BUILDER_VALUE(std::string, control)
     BUILDER_VALUE(bool, treat_as_implicit_manifest)
 };
+// Needed for next_permutation
 inline bool operator==(LoaderSettingsLayerConfiguration const& a, LoaderSettingsLayerConfiguration const& b) {
     return a.name == b.name && a.path == b.path && a.control == b.control &&
            a.treat_as_implicit_manifest == b.treat_as_implicit_manifest;
@@ -525,6 +526,10 @@ inline bool operator>(LoaderSettingsLayerConfiguration const& a, LoaderSettingsL
 inline bool operator<=(LoaderSettingsLayerConfiguration const& a, LoaderSettingsLayerConfiguration const& b) { return !(b < a); }
 inline bool operator>=(LoaderSettingsLayerConfiguration const& a, LoaderSettingsLayerConfiguration const& b) { return !(a < b); }
 
+struct LoaderSettingsDriverConfiguration {
+    BUILDER_VALUE(std::string, path)
+};
+
 // Log files and their associated filter
 struct LoaderLogConfiguration {
     BUILDER_VECTOR(std::string, destinations, destination)
@@ -533,6 +538,8 @@ struct LoaderLogConfiguration {
 struct AppSpecificSettings {
     BUILDER_VECTOR(std::string, app_keys, app_key)
     BUILDER_VECTOR(LoaderSettingsLayerConfiguration, layer_configurations, layer_configuration)
+    BUILDER_VECTOR(LoaderSettingsDriverConfiguration, driver_configurations, driver_configuration)
+    BUILDER_VALUE(bool, use_additional_drivers_exclusively)
     BUILDER_VECTOR(std::string, stderr_log, stderr_log_filter)
     BUILDER_VECTOR(LoaderLogConfiguration, log_configurations, log_configuration)
 };