Lines Matching defs:inst
174 void loader_handle_load_library_error(const struct loader_instance *inst, const char *filename,
197 loader_log(inst, err_flag, 0, error_message);
201 struct loader_instance *inst = loader_get_instance(instance);
202 if (!inst) {
203 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "vkSetInstanceDispatch: Can not retrieve Instance dispatch table.");
206 loader_set_dispatch(object, inst->disp);
221 void loader_free_layer_properties(const struct loader_instance *inst, struct loader_layer_properties *layer_properties) {
222 loader_instance_heap_free(inst, layer_properties->manifest_file_name);
223 loader_instance_heap_free(inst, layer_properties->lib_name);
224 loader_instance_heap_free(inst, layer_properties->functions.str_gipa);
225 loader_instance_heap_free(inst, layer_properties->functions.str_gdpa);
226 loader_instance_heap_free(inst, layer_properties->functions.str_negotiate_interface);
227 loader_destroy_generic_list(inst, (struct loader_generic_list *)&layer_properties->instance_extension_list);
230 free_string_list(inst, &layer_properties->device_extension_list.list[i].entrypoints);
233 loader_destroy_generic_list(inst, (struct loader_generic_list *)&layer_properties->device_extension_list);
234 loader_instance_heap_free(inst, layer_properties->disable_env_var.name);
235 loader_instance_heap_free(inst, layer_properties->disable_env_var.value);
236 loader_instance_heap_free(inst, layer_properties->enable_env_var.name);
237 loader_instance_heap_free(inst, layer_properties->enable_env_var.value);
238 free_string_list(inst, &layer_properties->component_layer_names);
239 loader_instance_heap_free(inst, layer_properties->pre_instance_functions.enumerate_instance_extension_properties);
240 loader_instance_heap_free(inst, layer_properties->pre_instance_functions.enumerate_instance_layer_properties);
241 loader_instance_heap_free(inst, layer_properties->pre_instance_functions.enumerate_instance_version);
242 free_string_list(inst, &layer_properties->override_paths);
243 free_string_list(inst, &layer_properties->blacklist_layer_names);
244 free_string_list(inst, &layer_properties->app_key_paths);
260 VkResult loader_copy_to_new_str(const struct loader_instance *inst, const char *source_str, char **dest_str) {
263 *dest_str = loader_instance_heap_calloc(inst, str_len, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
270 VkResult create_string_list(const struct loader_instance *inst, uint32_t allocated_count, struct loader_string_list *string_list) {
272 string_list->list = loader_instance_heap_calloc(inst, sizeof(char *) * allocated_count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
281 VkResult append_str_to_string_list(const struct loader_instance *inst, struct loader_string_list *string_list, char *str) {
286 loader_instance_heap_calloc(inst, sizeof(char *) * string_list->allocated_count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
292 string_list->list = loader_instance_heap_realloc(inst, string_list->list, sizeof(char *) * string_list->allocated_count,
305 VkResult copy_str_to_string_list(const struct loader_instance *inst, struct loader_string_list *string_list, const char *str,
308 char *new_str = loader_instance_heap_calloc(inst, sizeof(char *) * str_len + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
314 VkResult res = append_str_to_string_list(inst, string_list, new_str);
317 loader_instance_heap_free(inst, new_str);
322 void free_string_list(const struct loader_instance *inst, struct loader_string_list *string_list) {
326 loader_instance_heap_free(inst, string_list->list[i]);
329 loader_instance_heap_free(inst, string_list->list);
398 VkResult loader_append_layer_property(const struct loader_instance *inst, struct loader_layer_list *layer_list,
402 res = loader_init_generic_list(inst, (struct loader_generic_list *)layer_list, sizeof(struct loader_layer_properties));
410 void *new_ptr = loader_instance_heap_realloc(inst, layer_list->list, layer_list->capacity, layer_list->capacity * 2,
413 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "loader_append_layer_property: realloc failed for layer list");
426 loader_free_layer_properties(inst, layer_property);
461 bool loader_find_layer_name_in_meta_layer(const struct loader_instance *inst, const char *layer_name,
470 return loader_find_layer_name_in_meta_layer(inst, layer_name, layer_list, comp_layer_props);
487 void loader_delete_layer_list_and_properties(const struct loader_instance *inst, struct loader_layer_list *layer_list) {
494 loader_log(inst, VULKAN_LOADER_DEBUG_BIT | VULKAN_LOADER_LAYER_BIT, 0, "Unloading layer library %s",
498 loader_free_layer_properties(inst, &(layer_list->list[i]));
504 loader_instance_heap_free(inst, layer_list->list);
509 void loader_remove_layer_in_list(const struct loader_instance *inst, struct loader_layer_list *layer_list,
514 loader_free_layer_properties(inst, &(layer_list->list[layer_to_remove]));
528 void loader_remove_layers_in_blacklist(const struct loader_instance *inst, struct loader_layer_list *layer_list) {
545 loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0,
549 loader_remove_layer_in_list(inst, layer_list, j);
559 void loader_remove_layers_not_in_implicit_meta_layers(const struct loader_instance *inst, struct loader_layer_list *layer_list) {
584 if (loader_find_layer_name_in_meta_layer(inst, cur_layer_prop->info.layerName, layer_list, layer_to_check)) {
597 inst, VULKAN_LOADER_DEBUG_BIT, 0,
601 loader_remove_layer_in_list(inst, layer_list, i);
607 VkResult loader_add_instance_extensions(const struct loader_instance *inst,
621 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
630 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
648 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "loader_add_instance_extensions: Error getting Instance extensions from %s",
656 res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
667 VkResult loader_add_device_extensions(const struct loader_instance *inst,
677 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
684 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
694 res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
704 VkResult loader_init_generic_list(const struct loader_instance *inst, struct loader_generic_list *list_info, size_t element_size) {
708 list_info->list = loader_instance_heap_calloc(inst, capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
710 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "loader_init_generic_list: Failed to allocate space for generic list");
717 void loader_destroy_generic_list(const struct loader_instance *inst, struct loader_generic_list *list) {
718 loader_instance_heap_free(inst, list->list);
724 VkResult loader_add_to_ext_list(const struct loader_instance *inst, struct loader_extension_list *ext_list,
727 VkResult res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list, sizeof(VkExtensionProperties));
744 void *new_ptr = loader_instance_heap_realloc(inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2,
747 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
767 VkResult loader_add_to_dev_ext_list(const struct loader_instance *inst, struct loader_device_extension_list *ext_list,
772 res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list, sizeof(struct loader_dev_ext_props));
787 void *new_ptr = loader_instance_heap_realloc(inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2,
791 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
810 free_string_list(inst, entrys);
816 bool loader_init_pointer_layer_list(const struct loader_instance *inst, struct loader_pointer_layer_list *list) {
818 list->list = loader_instance_heap_calloc(inst, list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
837 void loader_destroy_pointer_layer_list(const struct loader_instance *inst, struct loader_pointer_layer_list *layer_list) {
838 loader_instance_heap_free(inst, layer_list->list);
843 VkResult loader_add_layer_properties_to_list(const struct loader_instance *inst, struct loader_pointer_layer_list *list,
846 if (!loader_init_pointer_layer_list(inst, list)) {
855 loader_instance_heap_realloc(inst, list->list, list->capacity, new_capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
857 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
870 bool loader_layer_is_available(const struct loader_instance *inst, const struct loader_envvar_all_filters *filters,
884 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
894 VkResult loader_add_layer_names_to_list(const struct loader_instance *inst, const struct loader_envvar_all_filters *filters,
905 loader_log(inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_LAYER_BIT, 0,
916 if (!loader_layer_is_available(inst, filters, layer_prop)) {
922 err = loader_add_layer_properties_to_list(inst, output_list, layer_prop);
924 err = loader_add_layer_properties_to_list(inst, expanded_output_list, layer_prop);
927 err = loader_add_meta_layer(inst, filters, layer_prop, output_list, expanded_output_list, source_list, NULL);
937 bool loader_implicit_layer_is_enabled(const struct loader_instance *inst, const struct loader_envvar_all_filters *filters,
956 char *env_value = loader_getenv(prop->enable_env_var.name, inst);
962 loader_free_getenv(env_value, inst);
970 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
977 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
986 char *env_value = loader_getenv(prop->disable_env_var.name, inst);
990 loader_free_getenv(env_value, inst);
992 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
997 if (inst != NULL && inst->override_layer_present) {
999 for (uint32_t i = 0; i < inst->instance_layer_list.count; ++i) {
1000 if (strcmp(inst->instance_layer_list.list[i].info.layerName, VK_OVERRIDE_LAYER_NAME) == 0) {
1001 override = &inst->instance_layer_list.list[i];
1021 VkResult loader_add_implicit_layer(const struct loader_instance *inst, struct loader_layer_properties *prop,
1026 if (loader_implicit_layer_is_enabled(inst, filters, prop)) {
1033 result = loader_add_layer_properties_to_list(inst, target_list, prop);
1036 result = loader_add_layer_properties_to_list(inst, expanded_target_list, prop);
1039 result = loader_add_meta_layer(inst, filters, prop, target_list, expanded_target_list, source_list, NULL);
1046 VkResult loader_add_meta_layer(const struct loader_instance *inst, const struct loader_envvar_all_filters *filters,
1061 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
1068 if (!loader_layer_is_available(inst, filters, search_prop)) {
1069 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
1077 result = loader_add_implicit_layer(inst, search_prop, filters, target_list, expanded_target_list, source_list);
1082 result = loader_add_meta_layer(inst, filters, search_prop, target_list, expanded_target_list, source_list,
1088 result = loader_add_layer_properties_to_list(inst, target_list, search_prop);
1091 result = loader_add_layer_properties_to_list(inst, expanded_target_list, search_prop);
1097 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
1106 result = loader_add_layer_properties_to_list(inst, target_list, prop);
1148 VkResult loader_get_icd_loader_instance_extensions(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list,
1156 env_value = loader_getenv("VK_LOADER_DISABLE_INST_EXT_FILTER", inst);
1160 loader_free_getenv(env_value, inst);
1164 res = loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties));
1168 res = loader_add_instance_extensions(inst, icd_tramp_list->scanned_list[i].EnumerateInstanceExtensionProperties,
1194 res = loader_add_to_ext_list(inst, inst_exts, icd_exts.count, icd_exts.list);
1196 loader_destroy_generic_list(inst, (struct loader_generic_list *)&icd_exts);
1203 res = add_debug_extensions_to_ext_list(inst, inst_exts);
1211 res = loader_add_to_ext_list(inst, inst_exts, sizeof(portability_enumeration_extension_info) / sizeof(VkExtensionProperties),
1221 res = loader_add_to_ext_list(inst, inst_exts, sizeof(direct_driver_loading_extension_info) / sizeof(VkExtensionProperties),
1240 for (struct loader_instance *inst = loader.instances; inst; inst = inst->next) {
1242 for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) {
1269 struct loader_device *loader_create_logical_device(const struct loader_instance *inst, const VkAllocationCallbacks *pAllocator) {
1274 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "loader_create_logical_device: Failed to alloc struct loader_device");
1377 void loader_scanned_icd_clear(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) {
1384 loader_instance_heap_free(inst, icd_tramp_list->scanned_list[i].lib_name);
1386 loader_instance_heap_free(inst, icd_tramp_list->scanned_list);
1391 VkResult loader_scanned_icd_init(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) {
1393 loader_scanned_icd_clear(inst, icd_tramp_list);
1395 icd_tramp_list->scanned_list = loader_instance_heap_alloc(inst, icd_tramp_list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
1397 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
1404 VkResult loader_add_direct_driver(const struct loader_instance *inst, uint32_t index,
1410 inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
1433 loader_log(inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
1443 inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
1453 inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
1463 loader_log(inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
1472 loader_log(inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
1490 void *new_ptr = loader_instance_heap_realloc(inst, icd_tramp_list->scanned_list, icd_tramp_list->capacity,
1493 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
1530 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
1539 VkResult loader_scan_for_direct_drivers(const struct loader_instance *inst, const VkInstanceCreateInfo *pCreateInfo,
1547 // Skip this step if inst is NULL, aka when this function is being called before instance creation
1548 if (inst != NULL && pCreateInfo->ppEnabledExtensionNames && pCreateInfo->enabledExtensionCount > 0) {
1569 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
1580 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
1589 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
1595 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
1601 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
1610 VkResult res = loader_add_direct_driver(inst, i, &ddl_list->pDrivers[i], icd_tramp_list);
1619 VkResult loader_scanned_icd_add(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list,
1637 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "loader_scanned_icd_add: A NULL filename was used, skipping this ICD",
1651 loader_handle_load_library_error(inst, filename, lib_status);
1680 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
1696 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
1705 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
1711 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
1718 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
1724 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
1740 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
1748 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
1778 void *new_ptr = loader_instance_heap_realloc(inst, icd_tramp_list->scanned_list, icd_tramp_list->capacity,
1782 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "loader_scanned_icd_add: Realloc failed on icd library list for ICD %s",
1794 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
1812 res = loader_copy_to_new_str(inst, filename, &new_scanned_icd->lib_name);
1814 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "loader_scanned_icd_add: Out of memory can't add ICD %s", filename);
1929 VkResult combine_manifest_directory_and_library_path(const struct loader_instance *inst, char *library_path,
1955 *out_fullpath = loader_instance_heap_calloc(inst, new_str_len, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
1982 loader_instance_heap_free(inst, library_path);
2018 bool verify_meta_layer_component_layers(const struct loader_instance *inst, struct loader_layer_properties *prop,
2026 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2037 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2048 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2056 loader_log(inst, VULKAN_LOADER_INFO_BIT, 0,
2061 if (!verify_meta_layer_component_layers(inst, comp_prop, instance_layers)) {
2062 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2071 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_LAYER_BIT, 0,
2077 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " [%d] %s", comp_layer, prop->component_layer_names.list[comp_layer]);
2084 bool update_meta_layer_extensions_from_component_layers(const struct loader_instance *inst, struct loader_layer_properties *prop,
2093 loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0, "Meta-layer %s component layer %s adding instance extension %s",
2098 res = loader_add_to_ext_list(inst, &prop->instance_extension_list, 1,
2108 loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0, "Meta-layer %s component layer %s adding device extension %s",
2113 loader_add_to_dev_ext_list(inst, &prop->device_extension_list,
2126 VkResult verify_all_meta_layers(struct loader_instance *inst, const struct loader_envvar_all_filters *filters,
2135 if (verify_meta_layer_component_layers(inst, prop, instance_layers)) {
2137 res = update_meta_layer_extensions_from_component_layers(inst, prop, instance_layers);
2141 if (prop->is_override && loader_implicit_layer_is_enabled(inst, filters, prop)) {
2145 loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0,
2148 loader_remove_layer_in_list(inst, instance_layers, i);
2158 void remove_all_non_valid_override_layers(struct loader_instance *inst, struct loader_layer_list *instance_layers) {
2182 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
2188 loader_remove_layer_in_list(inst, instance_layers, i);
2194 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_LAYER_BIT, 0,
2198 loader_remove_layer_in_list(inst, instance_layers, i);
2206 inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
2209 loader_remove_layer_in_list(inst, instance_layers, i);
2217 loader_remove_layer_in_list(inst, instance_layers, global_layer_index);
2221 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_LAYER_BIT, 0, "Using the override layer for app key %s", cur_path);
2223 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_LAYER_BIT, 0, "Using the global override layer");
2238 VkResult loader_read_layer_json(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list,
2249 result = loader_parse_json_string_to_existing_str(inst, layer_node, "name", VK_MAX_EXTENSION_NAME_SIZE, props.info.layerName);
2252 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2264 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0, "Layer name %s does not conform to naming standard (Policy #LLP_LAYER_3)",
2273 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2281 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0, "Device layers are deprecated. Skipping this layer");
2303 inst, VULKAN_LOADER_WARN_BIT, 0,
2313 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_LAYER_BIT, 0,
2326 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2336 result = loader_parse_json_string_to_existing_str(inst, layer_node, "description", VK_MAX_EXTENSION_NAME_SIZE,
2341 inst, VULKAN_LOADER_WARN_BIT, 0,
2354 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2361 result = loader_copy_to_new_str(inst, filename, &props.manifest_file_name);
2366 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2373 result = combine_manifest_directory_and_library_path(inst, library_path_str, filename, &props.lib_name);
2381 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2385 result = loader_parse_json_array_of_strings(inst, layer_node, "component_layers", &(props.component_layer_names));
2390 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2397 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_LAYER_BIT, 0, "Encountered meta-layer \"%s\"",
2404 result = loader_parse_json_array_of_strings(inst, layer_node, "blacklisted_layers", &(props.blacklist_layer_names));
2412 result = loader_parse_json_array_of_strings(inst, layer_node, "override_paths", &(props.override_paths));
2417 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2426 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2433 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2439 result = loader_copy_to_new_str(inst, disable_environment->child->string, &(props.disable_env_var.name));
2441 result = loader_copy_to_new_str(inst, disable_environment->child->valuestring, &(props.disable_env_var.value));
2467 loader_log(inst, VULKAN_LOADER_INFO_BIT, 0,
2478 loader_log(inst, VULKAN_LOADER_INFO_BIT, 0,
2498 result = loader_parse_json_string_to_existing_str(inst, ext_item, "name", VK_MAX_EXTENSION_NAME_SIZE,
2508 loader_instance_heap_free(inst, spec_version);
2511 loader_add_to_ext_list(inst, &props.instance_extension_list, 1, &ext_prop);
2530 result = loader_parse_json_string_to_existing_str(inst, ext_item, "name", VK_MAX_EXTENSION_NAME_SIZE,
2540 loader_instance_heap_free(inst, spec_version);
2544 result = loader_add_to_dev_ext_list(inst, &props.device_extension_list, &ext_prop, NULL);
2550 result = loader_parse_json_array_of_strings(inst, ext_item, "entrypoints", &entrys);
2552 result = loader_add_to_dev_ext_list(inst, &props.device_extension_list, &ext_prop, &entrys);
2561 result = loader_copy_to_new_str(inst, enable_environment->child->string, &(props.enable_env_var.name));
2563 result = loader_copy_to_new_str(inst, enable_environment->child->valuestring, &(props.enable_env_var.value));
2573 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
2578 loader_log(inst, VULKAN_LOADER_WARN_BIT, 0,
2599 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
2605 result = loader_parse_json_array_of_strings(inst, layer_node, "app_keys", &props.app_key_paths);
2615 loader_log(inst, VULKAN_LOADER_INFO_BIT, 0,
2617 loader_instance_heap_free(inst, library_arch);
2621 loader_instance_heap_free(inst, library_arch);
2629 result = loader_append_layer_property(inst, layer_instance_list, &props);
2633 loader_free_layer_properties(inst, &props);
2635 loader_instance_heap_free(inst, type);
2636 loader_instance_heap_free(inst, api_version);
2637 loader_instance_heap_free(inst, implementation_version);
2660 VkResult loader_add_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list, cJSON *json,
2683 loader_log(inst, VULKAN_LOADER_INFO_BIT, 0, "Found manifest file %s (file version %s)", filename, file_vers);
2688 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_LAYER_BIT, 0,
2699 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
2707 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
2713 result = loader_read_layer_json(inst, layer_instance_list, layer_node, json_version, is_implicit, filename);
2719 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
2737 loader_log(inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_LAYER_BIT, 0,
2743 result = loader_read_layer_json(inst, layer_instance_list, layer_node, json_version, is_implicit, filename);
2750 loader_instance_heap_free(inst, file_vers);
2816 VkResult add_if_manifest_file(const struct loader_instance *inst, const char *file_name, struct loader_string_list *out_files) {
2831 vk_result = copy_str_to_string_list(inst, out_files, file_name, name_len);
2840 VkResult add_data_files(const struct loader_instance *inst, char *search_path, struct loader_string_list *out_files,
2874 loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0, "add_data_files: Path to %s too long", cur_file);
2886 local_res = add_if_manifest_file(inst, name, out_files);
2896 dir_stream = loader_opendir(inst, cur_file);
2911 local_res = add_if_manifest_file(inst, name, out_files);
2921 loader_closedir(inst, dir_stream);
2938 VkResult read_data_files_in_search_paths(const struct loader_instance *inst, enum loader_data_files_type manifest_type,
2958 char *xdg_config_home = loader_secure_getenv("XDG_CONFIG_HOME", inst);
2959 char *xdg_config_dirs = loader_secure_getenv("XDG_CONFIG_DIRS", inst);
2967 char *xdg_data_home = loader_secure_getenv("XDG_DATA_HOME", inst);
2968 char *xdg_data_dirs = loader_secure_getenv("XDG_DATA_DIRS", inst);
2983 home = loader_secure_getenv("HOME", inst);
2988 default_config_home = loader_instance_heap_calloc(inst, default_config_home_len, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
2999 default_data_home = loader_instance_heap_calloc(inst, default_data_home_len, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
3021 char *debug_layer_name = loader_secure_getenv("debug.graphic.debug_layer", inst); // squid squidsubcapture
3022 char *debug_hap_name = loader_secure_getenv("debug.graphic.debug_hap", inst);
3028 debug_layer_json_path = loader_secure_getenv("debug.graphic.vklayer_json_path",inst);
3033 debug_layer_json_path = loader_instance_heap_calloc(inst,debug_layer_json_path_len,VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
3042 loader_log(inst, VULKAN_LOADER_DEBUG_BIT, 0, "OHOS:: debug_layer_json_path: %s", debug_layer_json_path);
3052 override_env = loader_secure_getenv(VK_DRIVER_FILES_ENV_VAR, inst);
3055 override_env = loader_secure_getenv(VK_ICD_FILENAMES_ENV_VAR, inst);
3057 additional_env = loader_secure_getenv(VK_ADDITIONAL_DRIVER_FILES_ENV_VAR, inst);
3062 package_path = windows_get_app_package_manifest_path(inst);
3071 override_env = loader_secure_getenv(VK_LAYER_PATH_ENV_VAR, inst);
3072 additional_env = loader_secure_getenv(VK_ADDITIONAL_LAYER_PATH_ENV_VAR, inst);
3084 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_LAYER_BIT, 0,
3151 search_path = loader_instance_heap_calloc(inst, search_path_size, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
3153 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
3272 char *tmp_search_path = loader_instance_heap_alloc(inst, search_path_size + 1, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
3278 loader_log(inst, VULKAN_LOADER_DRIVER_BIT, 0, "Searching for driver manifest files");
3281 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, "Searching for %s layer manifest files",
3284 loader_log(inst, log_flags, 0, " In following locations:");
3290 loader_log(inst, log_flags, 0, " %s", cur_file);
3292 loader_instance_heap_free(inst, tmp_search_path);
3297 vk_result = add_data_files(inst, search_path, out_files, use_first_found_manifest);
3300 loader_log(inst, log_flags, 0, " Found the following files:");
3302 loader_log(inst, log_flags, 0, " %s", out_files->list[cur_file]);
3305 loader_log(inst, log_flags, 0, " Found no files");
3316 loader_free_getenv(additional_env, inst);
3317 loader_free_getenv(override_env, inst);
3319 loader_instance_heap_free(inst, package_path);
3321 loader_free_getenv(xdg_config_home, inst);
3322 loader_free_getenv(xdg_config_dirs, inst);
3323 loader_free_getenv(xdg_data_home, inst);
3324 loader_free_getenv(xdg_data_dirs, inst);
3325 loader_free_getenv(xdg_data_home, inst);
3326 loader_free_getenv(home, inst);
3327 loader_instance_heap_free(inst, default_data_home);
3328 loader_instance_heap_free(inst, default_config_home);
3331 loader_free_getenv(debug_layer_json_path, inst);
3333 loader_free_getenv(debug_layer_name, inst);
3334 loader_free_getenv(debug_hap_name, inst);
3339 loader_instance_heap_free(inst, search_path);
3367 VkResult loader_get_data_files(const struct loader_instance *inst, enum loader_data_files_type manifest_type,
3373 free_string_list(inst, out_files);
3375 res = read_data_files_in_search_paths(inst, manifest_type, path_override, &override_active, out_files);
3402 windows_read_data_files_in_registry(inst, manifest_type, warn_if_not_present, registry_location, out_files);
3414 free_string_list(inst, out_files);
3427 VkResult loader_parse_icd_manifest(const struct loader_instance *inst, char *file_str, struct ICDManifestInfo *icd,
3439 res = loader_get_json(inst, file_str, &json);
3450 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3460 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3466 loader_log(inst, VULKAN_LOADER_DRIVER_BIT, 0, "Found ICD manifest file %s, version %s", file_str, file_vers_str);
3473 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3480 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3488 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3496 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3503 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3510 loader_log(inst, VULKAN_LOADER_DEBUG_BIT | VULKAN_LOADER_DRIVER_BIT, 0, "Searching for ICD drivers named %s", library_path);
3512 res = combine_manifest_directory_and_library_path(inst, library_path, file_str, &icd->full_library_path);
3519 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3527 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3536 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3547 if (item != NULL && item->type == cJSON_True && inst && !inst->portability_enumeration_enabled) {
3562 loader_log(inst, VULKAN_LOADER_INFO_BIT, 0,
3575 loader_instance_heap_free(inst, file_vers_str);
3576 loader_instance_heap_free(inst, version_str);
3577 loader_instance_heap_free(inst, library_arch_str);
3595 VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list,
3604 res = loader_scanned_icd_init(inst, icd_tramp_list);
3610 res = loader_scan_for_direct_drivers(inst, pCreateInfo, icd_tramp_list, &direct_driver_loading_exclusive_mode);
3621 res = parse_generic_filter_environment_var(inst, VK_DRIVERS_SELECT_ENV_VAR, &select_filter);
3625 res = parse_generic_filter_environment_var(inst, VK_DRIVERS_DISABLE_ENV_VAR, &disable_filter);
3631 res = loader_get_data_files(inst, LOADER_DATA_FILE_MANIFEST_DRIVER, NULL, &manifest_files);
3646 icd_res = loader_parse_icd_manifest(inst, manifest_files.list[i], &icd_details[i], skipped_portability_drivers);
3671 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3677 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3686 loader_scanned_icd_add(inst, icd_tramp_list, icd_details[i].full_library_path, icd_details[i].version, &lib_status);
3694 loader_log(inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3699 loader_log(inst, VULKAN_LOADER_DRIVER_BIT, 0, "Requested ICD %s was wrong bit-type. Ignoring this JSON",
3706 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
3719 loader_instance_heap_free(inst, icd_details[i].full_library_path);
3722 free_string_list(inst, &manifest_files);
3729 VkResult loader_parse_instance_layers(struct loader_instance *inst, enum loader_data_files_type manifest_type,
3735 res = loader_get_data_files(inst, manifest_type, path_override, &manifest_files);
3748 VkResult local_res = loader_get_json(inst, file_str, &json);
3756 local_res = loader_add_layer_properties(inst, instance_layers, json,
3767 free_string_list(inst, &manifest_files);
3774 VkResult get_override_layer_override_paths(struct loader_instance *inst, struct loader_layer_properties *prop,
3782 *override_paths = loader_instance_heap_alloc(inst, override_path_size, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
3794 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0, "Override layer has override paths set to %s",
3800 VkResult loader_scan_for_layers(struct loader_instance *inst, struct loader_layer_list *instance_layers,
3809 res = get_settings_layers(inst, &settings_layers, &should_search_for_other_layers);
3822 res = loader_parse_instance_layers(inst, LOADER_DATA_FILE_MANIFEST_IMPLICIT_LAYER, NULL, ®ular_instance_layers);
3828 remove_all_non_valid_override_layers(inst, ®ular_instance_layers);
3833 if (prop->is_override && loader_implicit_layer_is_enabled(inst, filters, prop) && prop->override_paths.count > 0) {
3834 res = get_override_layer_override_paths(inst, prop, &override_paths);
3843 res = loader_parse_instance_layers(inst, LOADER_DATA_FILE_MANIFEST_EXPLICIT_LAYER, override_paths, ®ular_instance_layers);
3850 res = verify_all_meta_layers(inst, filters, ®ular_instance_layers, &override_layer_valid);
3856 loader_remove_layers_in_blacklist(inst, ®ular_instance_layers);
3857 if (NULL != inst) {
3858 inst->override_layer_present = true;
3864 if (!loader_layer_is_available(inst, filters, ®ular_instance_layers.list[i])) {
3865 loader_remove_layer_in_list(inst, ®ular_instance_layers, i);
3870 res = combine_settings_layers_with_regular_layers(inst, &settings_layers, ®ular_instance_layers, instance_layers);
3873 loader_delete_layer_list_and_properties(inst, &settings_layers);
3874 loader_delete_layer_list_and_properties(inst, ®ular_instance_layers);
3876 loader_instance_heap_free(inst, override_paths);
3880 VkResult loader_scan_for_implicit_layers(struct loader_instance *inst, struct loader_layer_list *instance_layers,
3890 res = get_settings_layers(inst, &settings_layers, &should_search_for_other_layers);
3903 res = loader_parse_instance_layers(inst, LOADER_DATA_FILE_MANIFEST_IMPLICIT_LAYER, NULL, ®ular_instance_layers);
3909 remove_all_non_valid_override_layers(inst, ®ular_instance_layers);
3915 if (prop->is_override && loader_implicit_layer_is_enabled(inst, layer_filters, prop)) {
3917 res = get_override_layer_override_paths(inst, prop, &override_paths);
3931 loader_parse_instance_layers(inst, LOADER_DATA_FILE_MANIFEST_EXPLICIT_LAYER, override_paths, ®ular_instance_layers);
3939 res = verify_all_meta_layers(inst, layer_filters, ®ular_instance_layers, &override_layer_valid);
3945 loader_remove_layers_not_in_implicit_meta_layers(inst, ®ular_instance_layers);
3946 if (override_layer_valid && inst != NULL) {
3947 inst->override_layer_present = true;
3953 if (!loader_implicit_layer_is_enabled(inst, layer_filters, ®ular_instance_layers.list[i])) {
3954 loader_remove_layer_in_list(inst, ®ular_instance_layers, i);
3959 res = combine_settings_layers_with_regular_layers(inst, &settings_layers, ®ular_instance_layers, instance_layers);
3962 loader_delete_layer_list_and_properties(inst, &settings_layers);
3963 loader_delete_layer_list_and_properties(inst, ®ular_instance_layers);
3965 loader_instance_heap_free(inst, override_paths);
3969 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpdpa_instance_terminator(VkInstance inst, const char *pName) {
3970 // inst is not wrapped
3971 if (inst == VK_NULL_HANDLE) {
3975 VkLayerInstanceDispatchTable *disp_table = *(VkLayerInstanceDispatchTable **)inst;
3979 struct loader_instance *loader_inst = loader_get_instance(inst);
3992 addr = loader_phys_dev_ext_gpa_term(loader_get_instance(inst), pName);
4000 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpa_instance_terminator(VkInstance inst, const char *pName) {
4021 // inst is not wrapped
4022 if (inst == VK_NULL_HANDLE) {
4025 VkLayerInstanceDispatchTable *disp_table = *(VkLayerInstanceDispatchTable **)inst;
4029 struct loader_instance *loader_inst = loader_get_instance(inst);
4080 addr = loader_phys_dev_ext_gpa_term(loader_get_instance(inst), pName);
4086 addr = loader_dev_ext_gpa_term(loader_get_instance(inst), pName);
4143 for (struct loader_instance *inst = loader.instances; inst; inst = inst->next) {
4144 if (&inst->disp->layer_inst_disp == disp) {
4145 ptr_instance = inst;
4154 loader_platform_dl_handle loader_open_layer_file(const struct loader_instance *inst, struct loader_layer_properties *prop) {
4157 char *debug_layer_name = loader_secure_getenv("debug.graphic.debug_layer", inst);
4158 char *debug_hap_name = loader_secure_getenv("debug.graphic.debug_hap", inst);
4165 char* layerSoName = loader_instance_heap_calloc(inst, totalLen, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
4167 loader_log(inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_LAYER_BIT, 0, "malloc layerSoName fail");
4175 debugLayerLibPath = GetDebugLayerLibPath(inst, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
4177 loader_instance_heap_free(inst, layerSoName);
4182 libPath = loader_instance_heap_calloc(inst, totalLength, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
4184 loader_log(inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_LAYER_BIT, 0, "malloc libPath fail");
4185 loader_instance_heap_free(inst, layerSoName);
4186 loader_instance_heap_free(inst, debugLayerLibPath);
4194 loader_log(inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_LAYER_BIT, 0, "layerSoName != libPath : %s != %s",
4197 loader_instance_heap_free(inst, layerSoName);
4200 loader_free_getenv(debug_layer_name, inst);
4201 loader_free_getenv(debug_hap_name, inst);
4203 loader_log(inst, VULKAN_LOADER_DEBUG_BIT | VULKAN_LOADER_LAYER_BIT, 0, "try to open libPath: %s", libPath);
4205 loader_handle_load_library_error(inst, prop->lib_name, &prop->lib_status);
4208 loader_log(inst, VULKAN_LOADER_DEBUG_BIT | VULKAN_LOADER_LAYER_BIT, 0, "Loading layer library %s", prop->lib_name);
4212 loader_instance_heap_free(inst, debugLayerLibPath);
4213 loader_instance_heap_free(inst, libPath);
4221 VkResult loader_add_implicit_layers(const struct loader_instance *inst, const struct loader_envvar_all_filters *filters,
4228 VkResult result = loader_add_implicit_layer(inst, prop, filters, target_list, expanded_target_list, source_list);
4235 void warn_if_layers_are_older_than_application(struct loader_instance *inst) {
4236 for (uint32_t i = 0; i < inst->expanded_activated_layer_list.count; i++) {
4239 struct loader_layer_properties *prop = inst->expanded_activated_layer_list.list[i];
4241 if (!loader_check_version_meets_required(inst->app_api_version, prop_spec_version)) {
4242 loader_log(inst, VULKAN_LOADER_WARN_BIT | VULKAN_LOADER_LAYER_BIT, 0,
4245 prop->info.layerName, prop_spec_version.major, prop_spec_version.minor, inst->app_api_version.major,
4246 inst->app_api_version.minor);
4251 VkResult loader_enable_instance_layers(struct loader_instance *inst, const VkInstanceCreateInfo *pCreateInfo,
4256 assert(inst && "Cannot have null instance");
4258 if (!loader_init_pointer_layer_list(inst, &inst->app_activated_layer_list)) {
4259 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
4265 if (!loader_init_pointer_layer_list(inst, &inst->expanded_activated_layer_list)) {
4266 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
4272 if (inst->settings.settings_active) {
4273 res = enable_correct_layers_from_settings(inst, layer_filters, pCreateInfo->enabledLayerCount,
4274 pCreateInfo->ppEnabledLayerNames, &inst->instance_layer_list,
4275 &inst->app_activated_layer_list, &inst->expanded_activated_layer_list);
4276 warn_if_layers_are_older_than_application(inst);
4282 res = loader_add_implicit_layers(inst, layer_filters, &inst->app_activated_layer_list, &inst->expanded_activated_layer_list,
4289 res = loader_add_environment_layers(inst, VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER, layer_filters, &inst->app_activated_layer_list,
4290 &inst->expanded_activated_layer_list, instance_layers);
4296 res = loader_add_layer_names_to_list(inst, layer_filters, &inst->app_activated_layer_list, &inst->expanded_activated_layer_list,
4299 warn_if_layers_are_older_than_application(inst);
4336 void setup_logical_device_enabled_layer_extensions(const struct loader_instance *inst, struct loader_device *dev,
4349 for (uint32_t j = 0; j < inst->app_activated_layer_list.count; j++) {
4350 struct loader_layer_properties *layer = inst->app_activated_layer_list.list[j];
4368 struct loader_instance *inst = NULL;
4371 inst = loader_get_instance(instance);
4376 inst = (struct loader_instance *)phys_dev->this_instance;
4382 res = loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties));
4384 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "vkCreateDevice: Failed to create ICD extension list");
4393 enumDeviceExtensionProperties = inst->disp->layer_inst_disp.EnumerateDeviceExtensionProperties;
4395 res = loader_add_device_extensions(inst, enumDeviceExtensionProperties, internal_device, "Unknown", &icd_exts);
4397 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "vkCreateDevice: Failed to add extensions to list");
4402 res = loader_validate_device_extensions(inst, &inst->expanded_activated_layer_list, &icd_exts, pCreateInfo);
4404 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "vkCreateDevice: Failed to validate extensions in list");
4408 dev = loader_create_logical_device(inst, pAllocator);
4414 setup_logical_device_enabled_layer_extensions(inst, dev, &icd_exts, pCreateInfo);
4416 res = loader_create_device_chain(internal_device, pCreateInfo, pAllocator, inst, dev, layerGIPA, nextGDPA);
4418 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "vkCreateDevice: Failed to create device chain.");
4425 loader_init_dispatch_dev_ext(inst, dev);
4429 loader_init_device_extension_dispatch_table(&dev->loader_dispatch, inst->disp->layer_inst_disp.GetInstanceProcAddr,
4430 dev->loader_dispatch.core_dispatch.GetDeviceProcAddr, inst->instance, *pDevice);
4441 struct loader_icd_term *icd_term = inst->icd_terms;
4468 loader_destroy_generic_list(inst, (struct loader_generic_list *)&icd_exts);
4508 struct loader_instance *inst, VkInstance *created_instance) {
4524 if (inst->expanded_activated_layer_list.count > 0) {
4531 layer_instance_link_info = loader_stack_alloc(sizeof(VkLayerInstanceLink) * inst->expanded_activated_layer_list.count);
4533 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
4538 activated_layers = loader_stack_alloc(sizeof(struct activated_layer_info) * inst->expanded_activated_layer_list.count);
4540 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
4546 for (int32_t i = inst->expanded_activated_layer_list.count - 1; i >= 0; i--) {
4547 struct loader_layer_properties *layer_prop = inst->expanded_activated_layer_list.list[i];
4555 lib_handle = loader_open_layer_file(inst, layer_prop);
4613 loader_log(inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_LAYER_BIT, 0,
4623 loader_log(inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_LAYER_BIT, 0,
4658 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_LAYER_BIT, 0, "Insert instance layer \"%s\" (%s)",
4666 for (uint32_t exp = 0; exp < inst->expanded_activated_layer_list.count; ++exp) {
4667 struct loader_layer_properties *exp_layer_prop = inst->expanded_activated_layer_list.list[exp];
4695 loader_log(inst, log_flag, 0, "Requested layer \"%s\" was not loaded%c", exp_layer_prop->info.layerName,
4699 loader_log(inst, log_flag, 0, "Requested layer \"%s\" was wrong bit-type%c", exp_layer_prop->info.layerName,
4704 loader_log(inst, log_flag, 0, "Requested layer \"%s\" failed to load%c", exp_layer_prop->info.layerName,
4710 loader_log(inst, log_flag, 0,
4752 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, "vkCreateInstance layer callstack setup to:");
4753 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " <Application>");
4754 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " ||");
4755 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " <Loader>");
4756 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " ||");
4759 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " %s", activated_layers[index].name);
4760 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " Type: %s",
4763 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " Disable Env Var: %s",
4766 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " Manifest: %s", activated_layers[index].manifest);
4767 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " Library: %s", activated_layers[index].library);
4768 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " ||");
4770 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " <Drivers>");
4774 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0, "loader_create_instance_chain: Failed to find \'vkCreateInstance\'");
4781 memcpy(&inst->terminator_dispatch, &inst->disp->layer_inst_disp, sizeof(VkLayerInstanceDispatchTable));
4783 loader_init_instance_core_dispatch_table(&inst->disp->layer_inst_disp, next_gipa, *created_instance);
4784 inst->instance = *created_instance;
4787 res = create_string_list(inst, pCreateInfo->enabledLayerCount, &inst->enabled_layer_names);
4793 res = copy_str_to_string_list(inst, &inst->enabled_layer_names, pCreateInfo->ppEnabledLayerNames[i],
4803 void loader_activate_instance_layer_extensions(struct loader_instance *inst, VkInstance created_inst) {
4804 loader_init_instance_extension_dispatch_table(&inst->disp->layer_inst_disp, inst->disp->layer_inst_disp.GetInstanceProcAddr,
4810 const VkAllocationCallbacks *pAllocator, const struct loader_instance *inst,
4815 const VkAllocationCallbacks *pAllocator, const struct loader_instance *inst,
4835 if (loader_create_info.enabledLayerCount != inst->enabled_layer_names.count && loader_create_info.enabledLayerCount > 0) {
4841 } else if (inst->enabled_layer_names.list != NULL) {
4845 if (strcmp(device_layer_names, inst->enabled_layer_names.list[i]) != 0) {
4854 inst, VULKAN_LOADER_WARN_BIT, 0,
4903 if (inst->expanded_activated_layer_list.count > 0) {
4904 layer_device_link_info = loader_stack_alloc(sizeof(VkLayerDeviceLink) * inst->expanded_activated_layer_list.count);
4906 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
4911 activated_layers = loader_stack_alloc(sizeof(struct activated_layer_info) * inst->expanded_activated_layer_list.count);
4913 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
4925 for (int32_t i = inst->expanded_activated_layer_list.count - 1; i >= 0; i--) {
4926 struct loader_layer_properties *layer_prop = inst->expanded_activated_layer_list.list[i];
4950 loader_log(inst, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_LAYER_BIT, 0,
4974 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_LAYER_BIT, 0,
4995 loader_log(inst, VULKAN_LOADER_INFO_BIT | VULKAN_LOADER_LAYER_BIT, 0, "Inserted device layer \"%s\" (%s)",
5003 PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)nextGIPA(inst->instance, "vkCreateDevice");
5015 loader_log(inst, layer_driver_bits, 0, "vkCreateDevice layer callstack setup to:");
5016 loader_log(inst, layer_driver_bits, 0, " <Application>");
5017 loader_log(inst, layer_driver_bits, 0, " ||");
5018 loader_log(inst, layer_driver_bits, 0, " <Loader>");
5019 loader_log(inst, layer_driver_bits, 0, " ||");
5022 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " %s", activated_layers[index].name);
5023 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " Type: %s",
5026 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " Disable Env Var: %s",
5029 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " Manifest: %s", activated_layers[index].manifest);
5030 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " Library: %s", activated_layers[index].library);
5031 loader_log(inst, VULKAN_LOADER_LAYER_BIT, 0, " ||");
5033 loader_log(inst, layer_driver_bits, 0, " <Device>");
5060 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
5075 VkResult loader_validate_layers(const struct loader_instance *inst, const uint32_t layer_count,
5080 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
5088 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
5095 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
5099 if (inst->settings.settings_active && prop->settings_control_value != LOADER_SETTINGS_LAYER_CONTROL_ON &&
5101 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
5110 VkResult loader_validate_instance_extensions(struct loader_instance *inst, const struct loader_extension_list *icd_exts,
5123 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
5128 if (!loader_init_pointer_layer_list(inst, &active_layers)) {
5132 if (!loader_init_pointer_layer_list(inst, &expanded_layers)) {
5137 if (inst->settings.settings_active) {
5138 res = enable_correct_layers_from_settings(inst, layer_filters, pCreateInfo->enabledLayerCount,
5147 res = loader_add_implicit_layers(inst, layer_filters, &active_layers, &expanded_layers, instance_layers);
5151 res = loader_add_environment_layers(inst, VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER, layer_filters, &active_layers,
5156 res = loader_add_layer_names_to_list(inst, layer_filters, &active_layers, &expanded_layers, pCreateInfo->enabledLayerCount,
5165 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
5173 env_value = loader_getenv("VK_LOADER_DISABLE_INST_EXT_FILTER", inst);
5177 loader_free_getenv(env_value, inst);
5191 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
5226 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
5236 loader_destroy_pointer_layer_list(inst, &active_layers);
5237 loader_destroy_pointer_layer_list(inst, &expanded_layers);
5965 VkResult setup_loader_tramp_phys_devs(struct loader_instance *inst, uint32_t phys_dev_count, VkPhysicalDevice *phys_devs) {
5968 uint32_t old_count = inst->phys_dev_count_tramp;
5969 uint32_t new_count = inst->total_gpu_count;
5997 if (inst->phys_devs_tramp[cur_idx]->phys_dev == phys_devs[new_idx]) {
6013 phys_devs[new_idx] = (VkPhysicalDevice)inst->phys_devs_tramp[cur_idx];
6024 new_phys_devs = loader_instance_heap_calloc(inst, sizeof(struct loader_physical_device_tramp *) * new_count,
6027 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6045 new_phys_devs[new_idx] = inst->phys_devs_tramp[cur_idx];
6052 new_phys_devs[new_idx] = loader_instance_heap_alloc(inst, sizeof(struct loader_physical_device_tramp),
6055 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6062 loader_set_dispatch((void *)new_phys_devs[new_idx], inst->disp);
6063 new_phys_devs[new_idx]->this_instance = inst;
6077 new_phys_devs[new_idx] = inst->phys_devs_tramp[cur_idx];
6096 for (uint32_t cur_idx = 0; cur_idx < inst->phys_dev_count_tramp; cur_idx++) {
6097 if (new_phys_devs[new_idx] == inst->phys_devs_tramp[cur_idx]) {
6103 loader_instance_heap_free(inst, new_phys_devs[new_idx]);
6106 loader_instance_heap_free(inst, new_phys_devs);
6108 if (new_count > inst->total_gpu_count) {
6109 inst->total_gpu_count = new_count;
6115 if (NULL != inst->phys_devs_tramp) {
6116 for (uint32_t i = 0; i < inst->phys_dev_count_tramp; i++) {
6118 for (uint32_t j = 0; j < inst->total_gpu_count; j++) {
6119 if (inst->phys_devs_tramp[i] == new_phys_devs[j]) {
6125 loader_instance_heap_free(inst, inst->phys_devs_tramp[i]);
6128 loader_instance_heap_free(inst, inst->phys_devs_tramp);
6130 inst->phys_devs_tramp = new_phys_devs;
6131 inst->phys_dev_count_tramp = found_count;
6135 inst->total_gpu_count = 0;
6142 bool is_linux_sort_enabled(struct loader_instance *inst) {
6143 bool sort_items = inst->supports_get_dev_prop_2;
6144 char *env_value = loader_getenv("VK_LOADER_DISABLE_SELECT", inst);
6147 loader_free_getenv(env_value, inst);
6171 VkResult check_and_add_to_new_phys_devs(struct loader_instance *inst, VkPhysicalDevice physical_device,
6182 if (find_phys_dev(physical_device, inst->phys_dev_count_term, inst->phys_devs_term, &out_idx)) {
6183 new_phys_devs[idx] = inst->phys_devs_term[out_idx];
6195 loader_instance_heap_alloc(inst, sizeof(struct loader_physical_device_term), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
6197 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6202 loader_set_dispatch((void *)new_phys_devs[idx], inst->disp);
6212 /* Enumerate all physical devices from ICDs and add them to inst->phys_devs_term
6220 * that is already in inst->phys_devs_term will be carried over.
6223 VkResult setup_loader_term_phys_devs(struct loader_instance *inst) {
6237 res = windows_read_sorted_physical_devices(inst, &windows_sorted_devices_count, &windows_sorted_devices_array);
6243 icd_count = inst->total_icd_count;
6249 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6259 icd_term = inst->icd_terms;
6263 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6272 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6300 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6308 new_phys_devs = loader_instance_heap_calloc(inst, sizeof(struct loader_physical_device_term *) * new_phys_devs_capacity,
6311 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6320 res = check_and_add_to_new_phys_devs(inst, windows_sorted_devices_array[i].physical_devices[j],
6331 if (is_linux_sort_enabled(inst)) {
6334 loader_instance_heap_alloc(inst, sizeof(struct loader_physical_device_term), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
6336 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6346 res = linux_read_sorted_physical_devices(inst, icd_count, icd_phys_dev_array, new_phys_devs_capacity - new_phys_devs_count,
6353 for (uint32_t old_idx = 0; old_idx < inst->phys_dev_count_term; old_idx++) {
6354 if (new_phys_devs[new_idx]->phys_dev == inst->phys_devs_term[old_idx]->phys_dev) {
6355 loader_log(inst, VULKAN_LOADER_DEBUG_BIT | VULKAN_LOADER_DRIVER_BIT, 0,
6358 loader_instance_heap_free(inst, new_phys_devs[new_idx]);
6359 new_phys_devs[new_idx] = inst->phys_devs_term[old_idx];
6373 res = check_and_add_to_new_phys_devs(inst, icd_phys_dev_array[i].physical_devices[j], &icd_phys_dev_array[i],
6397 if (NULL != inst->phys_devs_term) {
6398 for (uint32_t old_idx = 0; old_idx < inst->phys_dev_count_term; old_idx++) {
6399 if (new_phys_devs[i] == inst->phys_devs_term[old_idx]) {
6406 loader_instance_heap_free(inst, new_phys_devs[i]);
6409 loader_instance_heap_free(inst, new_phys_devs);
6411 inst->total_gpu_count = 0;
6413 if (NULL != inst->phys_devs_term) {
6418 for (uint32_t i = 0; i < inst->phys_dev_count_term; i++) {
6421 if (new_phys_devs != NULL && inst->phys_devs_term[i] == new_phys_devs[j]) {
6427 loader_instance_heap_free(inst, inst->phys_devs_term[i]);
6430 loader_instance_heap_free(inst, inst->phys_devs_term);
6434 inst->phys_dev_count_term = new_phys_devs_count;
6435 inst->phys_devs_term = new_phys_devs;
6436 inst->total_gpu_count = new_phys_devs_count;
6442 loader_instance_heap_free(inst, windows_sorted_devices_array[i].physical_devices);
6445 loader_instance_heap_free(inst, windows_sorted_devices_array);
6451 VkResult setup_loader_tramp_phys_dev_groups(struct loader_instance *inst, uint32_t group_count,
6479 res = setup_loader_tramp_phys_devs(inst, phys_dev_count, devices);
6497 struct loader_instance *inst = (struct loader_instance *)instance;
6502 res = setup_loader_term_phys_devs(inst);
6507 uint32_t copy_count = inst->phys_dev_count_term;
6511 loader_log(inst, VULKAN_LOADER_INFO_BIT, 0,
6512 "terminator_EnumeratePhysicalDevices : Trimming device count from %d to %d.", inst->phys_dev_count_term,
6518 pPhysicalDevices[i] = (VkPhysicalDevice)inst->phys_devs_term[i];
6547 const struct loader_instance *inst = phys_dev_term->this_icd_term->this_instance;
6552 for (uint32_t i = 0; i < inst->instance_layer_list.count; i++) {
6553 struct loader_layer_properties *props = &inst->instance_layer_list.list[i];
6562 loader_destroy_generic_list(inst, (struct loader_generic_list *)&local_ext_list);
6572 loader_destroy_generic_list(inst, (struct loader_generic_list *)&local_ext_list);
6577 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6885 struct loader_instance *inst = (struct loader_instance *)instance;
6899 icd_term = inst->icd_terms;
6904 if (inst->enabled_known_extensions.khr_device_group_creation) {
6914 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6924 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6935 if (0 == total_count || 0 == inst->total_gpu_count) {
6936 res = setup_loader_term_phys_devs(inst);
6946 inst, total_count * sizeof(VkPhysicalDeviceGroupProperties *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
6948 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
6963 res = windows_read_sorted_physical_devices(inst, &sorted_count, &sorted_phys_dev_array);
6970 icd_term = inst->icd_terms;
6975 if (inst->enabled_known_extensions.khr_device_group_creation) {
6987 inst, VULKAN_LOADER_ERROR_BIT, 0,
6996 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
7015 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
7028 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
7059 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
7073 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
7085 if (is_linux_sort_enabled(inst)) {
7087 res = linux_sort_physical_device_groups(inst, total_count, local_phys_dev_groups);
7094 windows_sort_physical_device_groups(inst, total_count, local_phys_dev_groups, sorted_count, sorted_phys_dev_array);
7101 if (NULL != inst->phys_devs_term) {
7106 for (uint32_t term_gpu = 0; term_gpu < inst->phys_dev_count_term; term_gpu++) {
7108 inst->phys_devs_term[term_gpu]->phys_dev) {
7110 (VkPhysicalDevice)inst->phys_devs_term[term_gpu];
7116 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
7140 for (uint32_t old_idx = 0; old_idx < inst->phys_dev_group_count_term; old_idx++) {
7141 if (NULL != group_properties && NULL != inst->phys_dev_groups_term[old_idx] &&
7142 group_properties->physicalDeviceCount == inst->phys_dev_groups_term[old_idx]->physicalDeviceCount) {
7144 for (uint32_t old_gpu = 0; old_gpu < inst->phys_dev_groups_term[old_idx]->physicalDeviceCount; old_gpu++) {
7148 inst->phys_dev_groups_term[old_idx]->physicalDevices[old_gpu]) {
7162 new_phys_dev_groups[idx] = inst->phys_dev_groups_term[old_idx];
7170 inst, sizeof(VkPhysicalDeviceGroupProperties), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
7172 loader_log(inst, VULKAN_LOADER_ERROR_BIT, 0,
7199 if (NULL != inst->phys_devs_term) {
7200 for (uint32_t old_idx = 0; old_idx < inst->phys_dev_group_count_term; old_idx++) {
7201 if (new_phys_dev_groups[i] == inst->phys_dev_groups_term[old_idx]) {
7208 loader_instance_heap_free(inst, new_phys_dev_groups[i]);
7211 loader_instance_heap_free(inst, new_phys_dev_groups);
7214 if (NULL != inst->phys_dev_groups_term) {
7219 for (uint32_t i = 0; i < inst->phys_dev_group_count_term; i++) {
7222 if (inst->phys_dev_groups_term[i] == new_phys_dev_groups[j]) {
7228 loader_instance_heap_free(inst, inst->phys_dev_groups_term[i]);
7231 loader_instance_heap_free(inst, inst->phys_dev_groups_term);
7235 inst->phys_dev_group_count_term = total_count;
7236 inst->phys_dev_groups_term = new_phys_dev_groups;
7242 loader_instance_heap_free(inst, sorted_phys_dev_array[i].physical_devices);
7245 loader_instance_heap_free(inst, sorted_phys_dev_array);
7248 uint32_t copy_count = inst->phys_dev_group_count_term;
7252 loader_log(inst, VULKAN_LOADER_INFO_BIT, 0,
7254 inst->phys_dev_group_count_term, copy_count);
7259 memcpy(&pPhysicalDeviceGroupProperties[i], inst->phys_dev_groups_term[i], sizeof(VkPhysicalDeviceGroupProperties));