"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_LUNARG_core_validation",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": "./libVkLayer_core_validation.so",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_LUNARG_device_limits",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": "./libVkLayer_device_limits.so",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_LUNARG_image",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": "./libVkLayer_image.so",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_LUNARG_object_tracker",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": "./libVkLayer_object_tracker.so",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_LUNARG_parameter_validation",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": "./libVkLayer_parameter_validation.so",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_LUNARG_swapchain",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": "./libVkLayer_swapchain.so",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_GOOGLE_threading",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": "./libVkLayer_threading.so",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_GOOGLE_unique_objects",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": "./libVkLayer_unique_objects.so",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_LUNARG_core_validation",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": ".\\VkLayer_core_validation.dll",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_LUNARG_device_limits",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": ".\\VkLayer_device_limits.dll",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_LUNARG_image",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": ".\\VkLayer_image.dll",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_LUNARG_object_tracker",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": ".\\VkLayer_object_tracker.dll",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_LUNARG_parameter_validation",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": ".\\VkLayer_parameter_validation.dll",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_LUNARG_swapchain",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": ".\\VkLayer_swapchain.dll",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_GOOGLE_threading",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": ".\\VkLayer_threading.dll",
"api_version": "1.0.11",
"implementation_version": "1",
"file_format_version" : "1.0.0",
"layer" : {
"name": "VK_LAYER_GOOGLE_unique_objects",
- "type": "GLOBAL",
+ "type": "INSTANCE",
"library_path": ".\\VkLayer_unique_objects.dll",
"api_version": "1.0.11",
"implementation_version": "1",
return false;
}
-static inline bool loader_is_layer_type_device(const enum layer_type type) {
- if ((type & VK_LAYER_TYPE_DEVICE_EXPLICIT) ||
- (type & VK_LAYER_TYPE_DEVICE_IMPLICIT))
- return true;
- return false;
-}
-
/*
* Search the given layer list for a layer matching the given layer name
*/
/**
* Do a deep copy of the loader_layer_properties structure.
*/
-static void loader_copy_layer_properties(const struct loader_instance *inst,
+void loader_copy_layer_properties(const struct loader_instance *inst,
struct loader_layer_properties *dst,
struct loader_layer_properties *src) {
uint32_t cnt, i;
return false;
}
-static bool loader_find_layer_name_array(
+bool loader_find_layer_name_array(
const char *name, uint32_t layer_count,
const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]) {
if (!layer_list)
* @param ppp_layer_names
*/
void loader_expand_layer_names(
- const struct loader_instance *inst, const char *key_name,
+ struct loader_instance *inst, const char *key_name,
uint32_t expand_count,
const char expand_names[][VK_MAX_EXTENSION_NAME_SIZE],
uint32_t *layer_count, char const *const **ppp_layer_names) {
char const *const *pp_src_layers = *ppp_layer_names;
if (!loader_find_layer_name(key_name, *layer_count,
- (char const **)pp_src_layers))
+ (char const **)pp_src_layers)) {
+ inst->activated_layers_are_std_val = false;
return; // didn't find the key_name in the list.
+ }
loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
"Found meta layer %s, replacing with actual layer group",
key_name);
+ inst->activated_layers_are_std_val = true;
char const **pp_dst_layers = loader_heap_alloc(
inst, (expand_count + *layer_count - 1) * sizeof(char const *),
VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
*layer_count = dst_index;
}
-void loader_delete_shadow_dev_layer_names(const struct loader_instance *inst,
- const VkDeviceCreateInfo *orig,
- VkDeviceCreateInfo *ours) {
- /* Free the layer names array iff we had to reallocate it */
- if (orig->ppEnabledLayerNames != ours->ppEnabledLayerNames) {
- loader_heap_free(inst, (void *)ours->ppEnabledLayerNames);
- }
-}
-
void loader_delete_shadow_inst_layer_names(const struct loader_instance *inst,
const VkInstanceCreateInfo *orig,
VkInstanceCreateInfo *ours) {
}
}
+void loader_init_std_validation_props(struct loader_layer_properties *props) {
+ memset(props, 0, sizeof(struct loader_layer_properties));
+ props->type = VK_LAYER_TYPE_META_EXPLICT;
+ strncpy(props->info.description, "LunarG Standard Validation Layer",
+ sizeof (props->info.description));
+ props->info.implementationVersion = 1;
+ strncpy(props->info.layerName, std_validation_str,
+ sizeof (props->info.layerName));
+ // TODO what about specVersion? for now insert loader's built version
+ props->info.specVersion = VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION);
+}
+
/**
- * Searches through the existing instance and device layer lists looking for
+ * Searches through the existing instance layer lists looking for
* the set of required layer names. If found then it adds a meta property to the
* layer list.
* Assumes the required layers are the same for both instance and device lists.
* @param layer_count number of layers in layer_names
* @param layer_names array of required layer names
* @param layer_instance_list
- * @param layer_device_list
*/
static void loader_add_layer_property_meta(
const struct loader_instance *inst, uint32_t layer_count,
const char layer_names[][VK_MAX_EXTENSION_NAME_SIZE],
- struct loader_layer_list *layer_instance_list,
- struct loader_layer_list *layer_device_list) {
- uint32_t i, j;
+ struct loader_layer_list *layer_instance_list) {
+ uint32_t i;
bool found;
struct loader_layer_list *layer_list;
- if (0 == layer_count || (!layer_instance_list && !layer_device_list))
+ if (0 == layer_count || (!layer_instance_list))
return;
- if ((layer_instance_list && (layer_count > layer_instance_list->count)) &&
- (layer_device_list && (layer_count > layer_device_list->count)))
+ if (layer_instance_list && (layer_count > layer_instance_list->count))
return;
- for (j = 0; j < 2; j++) {
- if (j == 0)
- layer_list = layer_instance_list;
- else
- layer_list = layer_device_list;
- found = true;
- if (layer_list == NULL)
+
+ layer_list = layer_instance_list;
+
+ found = true;
+ if (layer_list == NULL)
+ return;
+ for (i = 0; i < layer_count; i++) {
+ if (loader_find_layer_name_list(layer_names[i], layer_list))
continue;
- for (i = 0; i < layer_count; i++) {
- if (loader_find_layer_name_list(layer_names[i], layer_list))
- continue;
- found = false;
- break;
- }
+ found = false;
+ break;
+ }
+
+ struct loader_layer_properties *props;
+ if (found) {
+ props = loader_get_next_layer_property(inst, layer_list);
+ loader_init_std_validation_props(props);
- struct loader_layer_properties *props;
- if (found) {
- props = loader_get_next_layer_property(inst, layer_list);
- props->type = VK_LAYER_TYPE_META_EXPLICT;
- strncpy(props->info.description, "LunarG Standard Validation Layer",
- sizeof(props->info.description));
- props->info.implementationVersion = 1;
- strncpy(props->info.layerName, std_validation_str,
- sizeof(props->info.layerName));
- // TODO what about specVersion? for now insert loader's built
- // version
- props->info.specVersion = VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION);
- }
}
+
}
/**
static void
loader_add_layer_properties(const struct loader_instance *inst,
struct loader_layer_list *layer_instance_list,
- struct loader_layer_list *layer_device_list,
cJSON *json, bool is_implicit, char *filename) {
/* Fields in layer manifest file that are required:
* (required) “file_format_version”
// add list entry
struct loader_layer_properties *props = NULL;
if (!strcmp(type, "DEVICE")) {
- if (layer_device_list == NULL) {
+ loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
+ "Device layers are deprecated skipping this layer");
layer_node = layer_node->next;
continue;
- }
- props = loader_get_next_layer_property(inst, layer_device_list);
- props->type = (is_implicit) ? VK_LAYER_TYPE_DEVICE_IMPLICIT
- : VK_LAYER_TYPE_DEVICE_EXPLICIT;
+
}
if (!strcmp(type, "INSTANCE")) {
if (layer_instance_list == NULL) {
: VK_LAYER_TYPE_INSTANCE_EXPLICIT;
}
if (!strcmp(type, "GLOBAL")) {
- if (layer_instance_list != NULL)
- props =
- loader_get_next_layer_property(inst, layer_instance_list);
- else if (layer_device_list != NULL)
- props = loader_get_next_layer_property(inst, layer_device_list);
- else {
+ loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
+ "Global layers are treated the same as instance layers");
+ if (layer_instance_list == NULL) {
layer_node = layer_node->next;
continue;
}
- props->type = (is_implicit) ? VK_LAYER_TYPE_GLOBAL_IMPLICIT
- : VK_LAYER_TYPE_GLOBAL_EXPLICIT;
+ props = loader_get_next_layer_property(inst, layer_instance_list);
+ props->type = (is_implicit) ? VK_LAYER_TYPE_INSTANCE_IMPLICIT
+ : VK_LAYER_TYPE_INSTANCE_EXPLICIT;
}
if (props == NULL) {
}
#undef GET_JSON_ITEM
#undef GET_JSON_OBJECT
- // for global layers need to add them to both device and instance list
- if (!strcmp(type, "GLOBAL")) {
- struct loader_layer_properties *dev_props;
- if (layer_instance_list == NULL || layer_device_list == NULL) {
- layer_node = layer_node->next;
- continue;
- }
- dev_props = loader_get_next_layer_property(inst, layer_device_list);
- // copy into device layer list
- loader_copy_layer_properties(inst, dev_props, props);
- }
layer_node = layer_node->next;
} while (layer_node != NULL);
return;
}
void loader_layer_scan(const struct loader_instance *inst,
- struct loader_layer_list *instance_layers,
- struct loader_layer_list *device_layers) {
+ struct loader_layer_list *instance_layers) {
char *file_str;
struct loader_manifest_files
manifest_files[2]; // [0] = explicit, [1] = implicit
/* cleanup any previously scanned libraries */
loader_delete_layer_properties(inst, instance_layers);
- loader_delete_layer_properties(inst, device_layers);
loader_platform_thread_lock_mutex(&loader_json_lock);
for (implicit = 0; implicit < 2; implicit++) {
continue;
}
- // TODO error if device layers expose instance_extensions
- // TODO error if instance layers expose device extensions
- loader_add_layer_properties(inst, instance_layers, device_layers,
- json, (implicit == 1), file_str);
+ loader_add_layer_properties(inst, instance_layers, json,
+ (implicit == 1), file_str);
loader_heap_free(inst, file_str);
cJSON_Delete(json);
// add a meta layer for validation if the validation layers are all present
loader_add_layer_property_meta(
inst, sizeof(std_validation_names) / sizeof(std_validation_names[0]),
- std_validation_names, instance_layers, device_layers);
+ std_validation_names, instance_layers);
loader_platform_thread_unlock_mutex(&loader_json_lock);
}
void loader_implicit_layer_scan(const struct loader_instance *inst,
- struct loader_layer_list *instance_layers,
- struct loader_layer_list *device_layers) {
+ struct loader_layer_list *instance_layers) {
char *file_str;
struct loader_manifest_files manifest_files;
cJSON *json;
/* cleanup any previously scanned libraries */
loader_delete_layer_properties(inst, instance_layers);
- loader_delete_layer_properties(inst, device_layers);
loader_platform_thread_lock_mutex(&loader_json_lock);
continue;
}
- loader_add_layer_properties(inst, instance_layers, device_layers, json,
+ loader_add_layer_properties(inst, instance_layers, json,
true, file_str);
loader_heap_free(inst, file_str);
// add a meta layer for validation if the validation layers are all present
loader_add_layer_property_meta(
inst, sizeof(std_validation_names) / sizeof(std_validation_names[0]),
- std_validation_names, instance_layers, device_layers);
+ std_validation_names, instance_layers);
loader_platform_thread_unlock_mutex(&loader_json_lock);
}
return true;
}
- if (loader_check_layer_list_for_address(&inst->device_layer_list,
- funcName)) {
- return true;
- }
-
return false;
}
* is found in search_list then add it to layer_list. But only add it to
* layer_list if type matches.
*/
-static void loader_add_layer_env(const struct loader_instance *inst,
+static void loader_add_layer_env(struct loader_instance *inst,
const enum layer_type type,
const char *env_name,
struct loader_layer_list *layer_list,
loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
"Expanding meta layer %s found in environment variable",
std_validation_str);
+ if (type == VK_LAYER_TYPE_INSTANCE_EXPLICIT)
+ inst->activated_layers_are_std_val = true;
for (uint32_t i = 0; i < sizeof(std_validation_names) /
sizeof(std_validation_names[0]);
i++) {
}
VkResult
-loader_enable_device_layers(const struct loader_instance *inst,
- struct loader_layer_list *activated_layer_list,
- const VkDeviceCreateInfo *pCreateInfo,
- const struct loader_layer_list *device_layers)
-
-{
- VkResult err;
-
- assert(activated_layer_list && "Cannot have null output layer list");
-
- if (activated_layer_list->list == NULL ||
- activated_layer_list->capacity == 0) {
- loader_init_layer_list(inst, activated_layer_list);
- }
-
- if (activated_layer_list->list == NULL) {
- loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
- "Failed to alloc device activated layer list");
- return VK_ERROR_OUT_OF_HOST_MEMORY;
- }
-
- /* Add any implicit layers first */
- loader_add_layer_implicit(inst, VK_LAYER_TYPE_DEVICE_IMPLICIT,
- activated_layer_list, device_layers);
-
- /* Add any layers specified via environment variable next */
- loader_add_layer_env(inst, VK_LAYER_TYPE_DEVICE_EXPLICIT,
- "VK_DEVICE_LAYERS", activated_layer_list,
- device_layers);
-
- /* Add layers specified by the application */
- err = loader_add_layer_names_to_list(
- inst, activated_layer_list, pCreateInfo->enabledLayerCount,
- pCreateInfo->ppEnabledLayerNames, device_layers);
-
- return err;
-}
-
-VkResult
loader_create_device_chain(const struct loader_physical_device_tramp *pd,
const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
icds = next_icd;
}
- loader_delete_layer_properties(ptr_instance,
- &ptr_instance->device_layer_list);
+
loader_delete_layer_properties(ptr_instance,
&ptr_instance->instance_layer_list);
loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
#define VK_PATCH(version) (version & 0xfff)
enum layer_type {
- VK_LAYER_TYPE_DEVICE_EXPLICIT = 0x1,
- VK_LAYER_TYPE_INSTANCE_EXPLICIT = 0x2,
- VK_LAYER_TYPE_GLOBAL_EXPLICIT = 0x3, // instance and device layer, bitwise
- VK_LAYER_TYPE_DEVICE_IMPLICIT = 0x4,
- VK_LAYER_TYPE_INSTANCE_IMPLICIT = 0x8,
- VK_LAYER_TYPE_GLOBAL_IMPLICIT = 0xc, // instance and device layer, bitwise
- VK_LAYER_TYPE_META_EXPLICT = 0x10,
+ VK_LAYER_TYPE_INSTANCE_EXPLICIT = 0x1,
+ VK_LAYER_TYPE_INSTANCE_IMPLICIT = 0x2,
+ VK_LAYER_TYPE_META_EXPLICT = 0x4,
};
typedef enum VkStringErrorFlagBits {
struct loader_extension_list ext_list; // icds and loaders extensions
struct loader_icd_libs icd_libs;
struct loader_layer_list instance_layer_list;
- struct loader_layer_list device_layer_list;
struct loader_dispatch_hash_entry disp_hash[MAX_NUM_DEV_EXTS];
struct loader_msg_callback_map_entry *icd_msg_callback_map;
struct loader_layer_list activated_layer_list;
-
+ bool activated_layers_are_std_val;
VkInstance instance; // layers/ICD instance returned to trampoline
bool debug_report_enabled;
const VkInstanceCreateInfo *pCreateInfo);
void loader_initialize(void);
+void loader_copy_layer_properties(const struct loader_instance *inst,
+ struct loader_layer_properties *dst,
+ struct loader_layer_properties *src);
bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop,
const uint32_t count,
const VkExtensionProperties *ext_array);
struct loader_layer_list *layer_list);
void loader_delete_layer_properties(const struct loader_instance *inst,
struct loader_layer_list *layer_list);
+bool loader_find_layer_name_array(const char *name, uint32_t layer_count,
+ const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]);
void loader_expand_layer_names(
- const struct loader_instance *inst, const char *key_name,
+ struct loader_instance *inst, const char *key_name,
uint32_t expand_count,
const char expand_names[][VK_MAX_EXTENSION_NAME_SIZE],
uint32_t *layer_count, char const *const **ppp_layer_names);
+void loader_init_std_validation_props(struct loader_layer_properties *props);
void loader_delete_shadow_dev_layer_names(const struct loader_instance *inst,
const VkDeviceCreateInfo *orig,
VkDeviceCreateInfo *ours);
void loader_icd_scan(const struct loader_instance *inst,
struct loader_icd_libs *icds);
void loader_layer_scan(const struct loader_instance *inst,
- struct loader_layer_list *instance_layers,
- struct loader_layer_list *device_layers);
+ struct loader_layer_list *instance_layers);
void loader_implicit_layer_scan(const struct loader_instance *inst,
- struct loader_layer_list *instance_layers,
- struct loader_layer_list *device_layers);
+ struct loader_layer_list *instance_layers);
void loader_get_icd_loader_instance_extensions(
const struct loader_instance *inst, struct loader_icd_libs *icd_libs,
struct loader_extension_list *inst_exts);
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
- loader_layer_scan(NULL, &instance_layers, NULL);
+ loader_layer_scan(NULL, &instance_layers);
if (strcmp(pLayerName, std_validation_str) == 0) {
struct loader_layer_list local_list;
memset(&local_list, 0, sizeof(local_list));
loader_scanned_icd_clear(NULL, &icd_libs);
// Append implicit layers.
- loader_implicit_layer_scan(NULL, &instance_layers, NULL);
+ loader_implicit_layer_scan(NULL, &instance_layers);
for (uint32_t i = 0; i < instance_layers.count; i++) {
struct loader_extension_list *ext_list =
&instance_layers.list[i].instance_extension_list;
/* get layer libraries */
memset(&instance_layer_list, 0, sizeof(instance_layer_list));
- loader_layer_scan(NULL, &instance_layer_list, NULL);
+ loader_layer_scan(NULL, &instance_layer_list);
if (pProperties == NULL) {
*pPropertyCount = instance_layer_list.count;
loader_platform_thread_once(&once_init, loader_initialize);
+ //TODO start handling the pAllocators again
#if 0
if (pAllocator) {
ptr_instance = (struct loader_instance *) pAllocator->pfnAllocation(
/* Due to implicit layers need to get layer list even if
* enabledLayerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
- * get layer list (both instance and device) via loader_layer_scan(). */
+ * get layer list via loader_layer_scan(). */
memset(&ptr_instance->instance_layer_list, 0,
sizeof(ptr_instance->instance_layer_list));
- memset(&ptr_instance->device_layer_list, 0,
- sizeof(ptr_instance->device_layer_list));
- loader_layer_scan(ptr_instance, &ptr_instance->instance_layer_list,
- &ptr_instance->device_layer_list);
+ loader_layer_scan(ptr_instance, &ptr_instance->instance_layer_list);
/* validate the app requested layers to be enabled */
if (pCreateInfo->enabledLayerCount > 0) {
if (res != VK_SUCCESS) {
loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo, &ici);
loader_delete_layer_properties(ptr_instance,
- &ptr_instance->device_layer_list);
- loader_delete_layer_properties(ptr_instance,
&ptr_instance->instance_layer_list);
loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
loader_destroy_generic_list(
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (ptr_instance->disp == NULL) {
loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo, &ici);
- loader_delete_layer_properties(ptr_instance,
- &ptr_instance->device_layer_list);
+
loader_delete_layer_properties(ptr_instance,
&ptr_instance->instance_layer_list);
loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
if (res != VK_SUCCESS) {
loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo, &ici);
loader_delete_layer_properties(ptr_instance,
- &ptr_instance->device_layer_list);
- loader_delete_layer_properties(ptr_instance,
&ptr_instance->instance_layer_list);
loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
loader_destroy_generic_list(
struct loader_physical_device_tramp *phys_dev;
struct loader_device *dev;
struct loader_instance *inst;
- struct loader_layer_list activated_layer_list = {0};
assert(pCreateInfo->queueCreateInfoCount >= 1);
phys_dev = (struct loader_physical_device_tramp *)physicalDevice;
inst = (struct loader_instance *)phys_dev->this_instance;
- /* validate any app enabled layers are available */
- if (pCreateInfo->enabledLayerCount > 0) {
- res = loader_validate_layers(inst, pCreateInfo->enabledLayerCount,
- pCreateInfo->ppEnabledLayerNames,
- &inst->device_layer_list);
- if (res != VK_SUCCESS) {
- loader_platform_thread_unlock_mutex(&loader_lock);
- return res;
- }
- }
-
/* Get the physical device (ICD) extensions */
struct loader_extension_list icd_exts;
if (!loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts,
return res;
}
- /* convert any meta layers to the actual layers makes a copy of layer name*/
- VkDeviceCreateInfo dci = *pCreateInfo;
- loader_expand_layer_names(
- inst, std_validation_str,
- sizeof(std_validation_names) / sizeof(std_validation_names[0]),
- std_validation_names, &dci.enabledLayerCount, &dci.ppEnabledLayerNames);
-
- /* fetch a list of all layers activated, explicit and implicit */
- res = loader_enable_device_layers(inst, &activated_layer_list, &dci,
- &inst->device_layer_list);
- if (res != VK_SUCCESS) {
- loader_delete_shadow_dev_layer_names(inst, pCreateInfo, &dci);
- loader_platform_thread_unlock_mutex(&loader_lock);
- return res;
- }
-
/* make sure requested extensions to be enabled are supported */
- res = loader_validate_device_extensions(phys_dev, &activated_layer_list,
- &icd_exts, &dci);
+ res = loader_validate_device_extensions(phys_dev, &inst->activated_layer_list,
+ &icd_exts, pCreateInfo);
if (res != VK_SUCCESS) {
- loader_delete_shadow_dev_layer_names(inst, pCreateInfo, &dci);
- loader_destroy_generic_list(
- inst, (struct loader_generic_list *)&activated_layer_list);
loader_platform_thread_unlock_mutex(&loader_lock);
return res;
}
dev = loader_create_logical_device(inst);
if (dev == NULL) {
- loader_delete_shadow_dev_layer_names(inst, pCreateInfo, &dci);
- loader_destroy_generic_list(
- inst, (struct loader_generic_list *)&activated_layer_list);
loader_platform_thread_unlock_mutex(&loader_lock);
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
- /* move the locally filled layer list into the device, and pass ownership of
- * the memory */
- dev->activated_layer_list.capacity = activated_layer_list.capacity;
- dev->activated_layer_list.count = activated_layer_list.count;
- dev->activated_layer_list.list = activated_layer_list.list;
- memset(&activated_layer_list, 0, sizeof(activated_layer_list));
-
- /* activate any layers on device chain which terminates with device*/
- res = loader_enable_device_layers(inst, &dev->activated_layer_list, &dci,
- &inst->device_layer_list);
- if (res != VK_SUCCESS) {
- loader_delete_shadow_dev_layer_names(inst, pCreateInfo, &dci);
+ /* copy the instance layer list into the device */
+ dev->activated_layer_list.capacity = inst->activated_layer_list.capacity;
+ dev->activated_layer_list.count = inst->activated_layer_list.count;
+ dev->activated_layer_list.list = loader_heap_alloc(inst,
+ inst->activated_layer_list.capacity,
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ if (dev->activated_layer_list.list == NULL) {
loader_platform_thread_unlock_mutex(&loader_lock);
- return res;
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
}
+ memcpy(dev->activated_layer_list.list, inst->activated_layer_list.list,
+ sizeof(*dev->activated_layer_list.list) * dev->activated_layer_list.count);
- res = loader_create_device_chain(phys_dev, &dci, pAllocator, inst, dev);
+
+ res = loader_create_device_chain(phys_dev, pCreateInfo, pAllocator, inst, dev);
if (res != VK_SUCCESS) {
- loader_delete_shadow_dev_layer_names(inst, pCreateInfo, &dci);
loader_platform_thread_unlock_mutex(&loader_lock);
return res;
}
&dev->loader_dispatch,
dev->loader_dispatch.core_dispatch.GetDeviceProcAddr, *pDevice);
- loader_delete_shadow_dev_layer_names(inst, pCreateInfo, &dci);
-
loader_platform_thread_unlock_mutex(&loader_lock);
return res;
}
i++) {
loader_find_layer_name_add_list(
NULL, std_validation_names[i],
- VK_LAYER_TYPE_DEVICE_EXPLICIT, &inst->device_layer_list,
+ VK_LAYER_TYPE_INSTANCE_EXPLICIT, &inst->instance_layer_list,
&local_list);
}
for (uint32_t i = 0; i < local_list.count; i++) {
dev_ext_list = &local_ext_list;
} else {
- for (uint32_t i = 0; i < inst->device_layer_list.count; i++) {
+ for (uint32_t i = 0; i < inst->instance_layer_list.count; i++) {
struct loader_layer_properties *props =
- &inst->device_layer_list.list[i];
+ &inst->instance_layer_list.list[i];
if (strcmp(props->info.layerName, pLayerName) == 0) {
dev_ext_list = &props->device_extension_list;
}
VkLayerProperties *pProperties) {
uint32_t copy_size;
struct loader_physical_device_tramp *phys_dev;
-
+ struct loader_layer_list *enabled_layers, layers_list;
+ uint32_t std_val_count = sizeof(std_validation_names) /
+ sizeof(std_validation_names[0]);
+ memset(&layers_list, 0, sizeof(layers_list));
loader_platform_thread_lock_mutex(&loader_lock);
/* Don't dispatch this call down the instance chain, want all device layers
enumerated and instance chain may not contain all device layers */
+ // TODO re-evaluate the above statement we maybe able to start calling
+ // down the chain
phys_dev = (struct loader_physical_device_tramp *)physicalDevice;
const struct loader_instance *inst = phys_dev->this_instance;
- uint32_t count = inst->device_layer_list.count;
+ uint32_t count = inst->activated_layer_list.count;
+ if (inst->activated_layers_are_std_val)
+ count = count - std_val_count + 1;
if (pProperties == NULL) {
*pPropertyCount = count;
loader_platform_thread_unlock_mutex(&loader_lock);
return VK_SUCCESS;
}
+ /* make sure to enumerate standard_validation if that is what was used
+ at the instance layer enablement */
+ if (inst->activated_layers_are_std_val) {
+ enabled_layers = &layers_list;
+ enabled_layers->count = count;
+ enabled_layers->capacity = enabled_layers->count *
+ sizeof(struct loader_layer_properties);
+ enabled_layers->list = loader_heap_alloc(inst, enabled_layers->capacity,
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ if (!enabled_layers->list)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+ uint32_t j = 0;
+ for (uint32_t i = 0; i < inst->activated_layer_list.count; j++) {
+
+ if (loader_find_layer_name_array(
+ inst->activated_layer_list.list[i].info.layerName,
+ std_val_count, std_validation_names)) {
+ struct loader_layer_properties props;
+ loader_init_std_validation_props(&props);
+ loader_copy_layer_properties(inst,
+ &enabled_layers->list[j], &props);
+ i += std_val_count;
+ }
+ else {
+ loader_copy_layer_properties(inst,
+ &enabled_layers->list[j],
+ &inst->activated_layer_list.list[i++]);
+ }
+ }
+ }
+ else {
+ enabled_layers = (struct loader_layer_list *) &inst->activated_layer_list;
+ }
+
copy_size = (*pPropertyCount < count) ? *pPropertyCount : count;
for (uint32_t i = 0; i < copy_size; i++) {
- memcpy(&pProperties[i], &(inst->device_layer_list.list[i].info),
+ memcpy(&pProperties[i], &(enabled_layers->list[i].info),
sizeof(VkLayerProperties));
}
*pPropertyCount = copy_size;
+ if (inst->activated_layers_are_std_val)
+ loader_delete_layer_properties(inst, enabled_layers);
if (copy_size < count) {
loader_platform_thread_unlock_mutex(&loader_lock);
return VK_INCOMPLETE;
projects / platform / upstream / Vulkan-Tools.git / commitdiff