/**
* Remove all layer properties entrys from the list
*/
-static void loader_delete_layer_properties(struct loader_layer_list *layer_list)
+void loader_delete_layer_properties(struct loader_layer_list *layer_list)
{
uint32_t i;
return;
for (i = 0; i < layer_list->count; i++) {
- if (layer_list->list[i].lib_info.lib_name != NULL)
- free(layer_list->list[i].lib_info.lib_name);
loader_destroy_ext_list(&layer_list->list[i].instance_extension_list);
loader_destroy_ext_list(&layer_list->list[i].device_extension_list);
- layer_list->list[i].lib_info.lib_name = NULL;
}
layer_list->count = 0;
free(icd);
}
-static struct loader_icd * loader_icd_create(const struct loader_scanned_icds *scanned)
+static struct loader_icd * loader_icd_create()
{
struct loader_icd *icd;
memset(icd, 0, sizeof(*icd));
- icd->scanned_icds = scanned;
-
return icd;
}
static struct loader_icd *loader_icd_add(
struct loader_instance *ptr_inst,
- const struct loader_scanned_icds *scanned)
+ const struct loader_scanned_icds *icd_lib)
{
struct loader_icd *icd;
- icd = loader_icd_create(scanned);
+ icd = loader_icd_create();
if (!icd)
return NULL;
+ icd->this_icd_lib = icd_lib;
+ icd->this_instance = ptr_inst;
+
/* prepend to the list */
icd->next = ptr_inst->icds;
ptr_inst->icds = icd;
}
/**
+ * Do a deep copy of the loader_layer_properties structure.
+ */
+static void loader_copy_layer_properties(
+ struct loader_layer_properties *dst,
+ struct loader_layer_properties *src)
+{
+ memcpy(dst, src, sizeof (*src));
+ dst->instance_extension_list.list = malloc(sizeof(VkExtensionProperties) * src->instance_extension_list.count);
+ dst->instance_extension_list.capacity = sizeof(VkExtensionProperties) * src->instance_extension_list.count;
+ memcpy(dst->instance_extension_list.list, src->instance_extension_list.list, dst->instance_extension_list.capacity);
+ dst->device_extension_list.list = malloc(sizeof(VkExtensionProperties) * src->device_extension_list.count);
+ dst->device_extension_list.capacity = sizeof(VkExtensionProperties) * src->device_extension_list.count;
+ memcpy(dst->device_extension_list.list, src->device_extension_list.list, dst->device_extension_list.capacity);
+}
+
+/**
* Given a cJSON struct (json) of the top level JSON object from layer manifest
* file, add entry to the layer_list.
* Fill out the layer_properties in this list entry from the input cJSON object.
strncpy(props->info.layerName, name, sizeof (props->info.layerName));
props->info.layerName[sizeof (props->info.layerName) - 1] = '\0';
- char *fullpath = malloc(MAX_STRING_SIZE);
+ char *fullpath = props->lib_name;
char *rel_base;
if (strchr(library_path, DIRECTORY_SYMBOL) == NULL) {
// a filename which is assumed in the system directory
rel_base[len + 1] = '\0';
loader_expand_path(library_path, rel_base, MAX_STRING_SIZE, fullpath);
}
- props->lib_info.lib_name = fullpath;
props->info.specVersion = loader_make_version(abi_versions);
props->info.implVersion = loader_make_version(implementation_version);
strncpy((char *) props->info.description, description, sizeof (props->info.description));
}
dev_props = loader_get_next_layer_property(layer_device_list);
//copy into device layer list
- memcpy(dev_props, props, sizeof (*props));
+ loader_copy_layer_properties(dev_props, props);
}
layer_node = layer_node->next;
} while (layer_node != NULL);
* scanned_layer_libraries list.
*/
for (uint32_t i = 0; i < loader.loaded_layer_lib_count; i++) {
- if (strcmp(loader.loaded_layer_lib_list[i].lib_name, layer_prop->lib_info.lib_name) == 0) {
+ if (strcmp(loader.loaded_layer_lib_list[i].lib_name, layer_prop->lib_name) == 0) {
/* Have already loaded this library, just increment ref count */
loader.loaded_layer_lib_list[i].ref_count++;
loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
"%s Chain: Increment layer reference count for layer library %s",
- chain_type, layer_prop->lib_info.lib_name);
+ chain_type, layer_prop->lib_name);
return loader.loaded_layer_lib_list[i].lib_handle;
}
}
my_lib = &new_layer_lib_list[loader.loaded_layer_lib_count];
- /* NOTE: We require that the layer property be immutable */
- my_lib->lib_name = (char *) layer_prop->lib_info.lib_name;
+ strncpy(my_lib->lib_name, layer_prop->lib_name, sizeof(my_lib->lib_name));
+ my_lib->lib_name[sizeof(my_lib->lib_name) - 1] = '\0';
my_lib->ref_count = 0;
my_lib->lib_handle = NULL;
} else {
loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
"Chain: %s: Loading layer library %s",
- chain_type, layer_prop->lib_info.lib_name);
+ chain_type, layer_prop->lib_name);
}
loader.loaded_layer_lib_count++;
loader.loaded_layer_lib_list = new_layer_lib_list;
struct loader_lib_info *new_layer_lib_list, *my_lib = NULL;
for (uint32_t i = 0; i < loader.loaded_layer_lib_count; i++) {
- if (strcmp(loader.loaded_layer_lib_list[i].lib_name, layer_prop->lib_info.lib_name) == 0) {
+ if (strcmp(loader.loaded_layer_lib_list[i].lib_name, layer_prop->lib_name) == 0) {
/* found matching library */
idx = i;
my_lib = &loader.loaded_layer_lib_list[i];
my_lib->ref_count--;
if (my_lib->ref_count > 0) {
loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
- "Decrement reference count for layer library %s", layer_prop->lib_info.lib_name);
+ "Decrement reference count for layer library %s", layer_prop->lib_name);
return;
}
}
loader_platform_close_library(my_lib->lib_handle);
loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
- "Unloading layer library %s", layer_prop->lib_info.lib_name);
+ "Unloading layer library %s", layer_prop->lib_name);
/* Need to remove unused library from list */
new_layer_lib_list = malloc((loader.loaded_layer_lib_count - 1) * sizeof(struct loader_lib_info));
if ((nextGPA = (PFN_vkGetInstanceProcAddr) loader_platform_get_proc_address(lib_handle, funcStr)) == NULL)
nextGPA = (PFN_vkGetInstanceProcAddr) loader_platform_get_proc_address(lib_handle, "vkGetInstanceProcAddr");
if (!nextGPA) {
- loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to find vkGetInstanceProcAddr in layer %s", layer_prop->lib_info.lib_name);
+ loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to find vkGetInstanceProcAddr in layer %s", layer_prop->lib_name);
/* TODO: Should we return nextObj, nextGPA to previous? or decrement layer_list count*/
continue;
loader_log(VK_DBG_REPORT_INFO_BIT, 0,
"Insert instance layer %s (%s)",
layer_prop->info.layerName,
- layer_prop->lib_info.lib_name);
+ layer_prop->lib_name);
layer_idx--;
}
loader_log(VK_DBG_REPORT_INFO_BIT, 0,
"Insert device layer library %s (%s)",
layer_prop->info.layerName,
- layer_prop->lib_info.lib_name);
+ layer_prop->lib_name);
}
VkResult loader_validate_layers(
const uint32_t layer_count,
const char * const *ppEnabledLayerNames,
- struct loader_layer_list *list)
+ const struct loader_layer_list *list)
{
struct loader_layer_properties *prop;
icds = next_icd;
}
-
+ loader_delete_layer_properties(&ptr_instance->device_layer_list);
+ loader_delete_layer_properties(&ptr_instance->instance_layer_list);
loader_scanned_icd_clear(&ptr_instance->icd_libs);
loader_destroy_ext_list(&ptr_instance->ext_list);
return VK_SUCCESS;
loader_add_physical_device_extensions(
icd->GetPhysicalDeviceExtensionProperties,
icd->gpus[0],
- icd->scanned_icds->lib_name,
+ icd->this_icd_lib->lib_name,
&icd->device_extension_cache[i]);
}
VkDeviceCreateInfo device_create_info;
char **filtered_extension_names = NULL;
VkResult res;
- struct loader_layer_list device_layer_list;
if (!icd->CreateDevice) {
return VK_ERROR_INITIALIZATION_FAILED;
}
- /* Due to implicit layers might still need to get layer list even if
- * layerCount == 0 and VK_DEVICE_LAYERS is unset. For now always
- * get layer list via loader_layer_scan(). */
- memset(&device_layer_list, 0, sizeof(device_layer_list));
- loader_layer_scan(NULL, &device_layer_list);
-
/* validate any app enabled layers are available */
if (pCreateInfo->layerCount > 0) {
res = loader_validate_layers(pCreateInfo->layerCount,
pCreateInfo->ppEnabledLayerNames,
- &device_layer_list);
+ &icd->this_instance->device_layer_list);
if (res != VK_SUCCESS) {
return res;
}
}
- res = loader_validate_device_extensions(icd, gpu_index, &device_layer_list, pCreateInfo);
+ res = loader_validate_device_extensions(icd, gpu_index, &icd->this_instance->device_layer_list, pCreateInfo);
if (res != VK_SUCCESS) {
return res;
}
loader_init_dispatch(*pDevice, &dev->loader_dispatch);
/* activate any layers on device chain which terminates with device*/
- res = loader_enable_device_layers(icd, dev, pCreateInfo, &device_layer_list);
+ res = loader_enable_device_layers(icd, dev, pCreateInfo, &icd->this_instance->device_layer_list);
if (res != VK_SUCCESS) {
loader_destroy_logical_device(dev);
return res;
global_ext_list = &props->instance_extension_list;
}
}
+ loader_destroy_layer_list(&instance_layers);
}
else {
/* Scan/discover all ICD libraries */
if (pProperties == NULL) {
*pCount = instance_layer_list.count;
+ loader_destroy_layer_list(&instance_layer_list);
loader_platform_thread_unlock_mutex(&loader_lock);
return VK_SUCCESS;
}
memcpy(&pProperties[i], &instance_layer_list.list[i].info, sizeof(VkLayerProperties));
}
*pCount = copy_size;
-
+ loader_destroy_layer_list(&instance_layer_list);
loader_platform_thread_unlock_mutex(&loader_lock);
if (copy_size < instance_layer_list.count) {
uint32_t gpu_index;
struct loader_icd *icd = loader_get_icd(gpu, &gpu_index);
uint32_t copy_size;
- struct loader_layer_list device_layers;
if (pCount == NULL) {
return VK_ERROR_INVALID_POINTER;
/* get layer libraries if needed */
if (pLayerName && strlen(pLayerName) != 0) {
- memset(&device_layers, 0, sizeof(device_layers));
- loader_layer_scan(NULL, &device_layers);
- for (uint32_t i = 0; i < device_layers.count; i++) {
- struct loader_layer_properties *props = &device_layers.list[i];
+ for (uint32_t i = 0; i < icd->this_instance->device_layer_list.count; i++) {
+ struct loader_layer_properties *props = &icd->this_instance->device_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_layer_list device_layers;
+ uint32_t gpu_index;
+ struct loader_icd *icd = loader_get_icd(gpu, &gpu_index);
if (pCount == NULL) {
return VK_ERROR_INVALID_POINTER;
}
- /* get layer libraries */
- memset(&device_layers, 0, sizeof(struct loader_layer_list));
- loader_layer_scan(NULL, &device_layers);
-
- uint32_t count = device_layers.count;
+ uint32_t count = icd->this_instance->device_layer_list.count;
if (pProperties == NULL) {
*pCount = count;
copy_size = (*pCount < count) ? *pCount : count;
for (uint32_t i = 0; i < copy_size; i++) {
- memcpy(&pProperties[i], &(device_layers.list[i].info), sizeof(VkLayerProperties));
+ memcpy(&pProperties[i], &(icd->this_instance->device_layer_list.list[i].info), sizeof(VkLayerProperties));
}
*pCount = copy_size;
{
struct loader_instance *ptr_instance = NULL;
VkResult res = VK_ERROR_INITIALIZATION_FAILED;
- struct loader_layer_list instance_layer_list;
loader_platform_thread_once(&once_init, loader_initialize);
- /* Due to implicit layers might still need to get layer list even if
- * layerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
- * get layer list via loader_layer_scan(). */
- memset(&instance_layer_list, 0, sizeof(instance_layer_list));
- loader_layer_scan(&instance_layer_list, NULL);
-
- /* validate the app requested layers to be enabled */
- if (pCreateInfo->layerCount > 0) {
- res = loader_validate_layers(pCreateInfo->layerCount,
- pCreateInfo->ppEnabledLayerNames,
- &instance_layer_list);
- if (res != VK_SUCCESS) {
- return res;
- }
- }
-
if (pCreateInfo->pAllocCb
&& pCreateInfo->pAllocCb->pfnAlloc
&& pCreateInfo->pAllocCb->pfnFree) {
ptr_instance->alloc_callbacks.pfnFree = pCreateInfo->pAllocCb->pfnFree;
}
+ /* Due to implicit layers need to get layer list even if
+ * layerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
+ * get layer list (both instance and device) 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->instance_layer_list, &ptr_instance->device_layer_list);
+
+ /* validate the app requested layers to be enabled */
+ if (pCreateInfo->layerCount > 0) {
+ res = loader_validate_layers(pCreateInfo->layerCount,
+ pCreateInfo->ppEnabledLayerNames,
+ &ptr_instance->instance_layer_list);
+ if (res != VK_SUCCESS) {
+ return res;
+ }
+ }
+
/* Scan/discover all ICD libraries */
memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs));
loader_icd_scan(&ptr_instance->icd_libs);
/* get extensions from all ICD's, merge so no duplicates, then validate */
loader_get_icd_loader_instance_extensions(&ptr_instance->icd_libs, &ptr_instance->ext_list);
- res = loader_validate_instance_extensions(&ptr_instance->ext_list, &instance_layer_list, pCreateInfo);
+ res = loader_validate_instance_extensions(&ptr_instance->ext_list, &ptr_instance->instance_layer_list, pCreateInfo);
if (res != VK_SUCCESS) {
+ loader_delete_layer_properties(&ptr_instance->device_layer_list);
+ loader_delete_layer_properties(&ptr_instance->instance_layer_list);
loader_scanned_icd_clear(&ptr_instance->icd_libs);
loader_destroy_ext_list(&ptr_instance->ext_list);
loader_platform_thread_unlock_mutex(&loader_lock);
sizeof(VkLayerInstanceDispatchTable),
VK_SYSTEM_ALLOC_TYPE_INTERNAL);
if (ptr_instance->disp == NULL) {
+ loader_delete_layer_properties(&ptr_instance->device_layer_list);
+ loader_delete_layer_properties(&ptr_instance->instance_layer_list);
loader_scanned_icd_clear(&ptr_instance->icd_libs);
loader_destroy_ext_list(&ptr_instance->ext_list);
loader_platform_thread_unlock_mutex(&loader_lock);
loader.instances = ptr_instance;
/* activate any layers on instance chain */
- res = loader_enable_instance_layers(ptr_instance, pCreateInfo, &instance_layer_list);
+ res = loader_enable_instance_layers(ptr_instance, pCreateInfo, &ptr_instance->instance_layer_list);
if (res != VK_SUCCESS) {
+ loader_delete_layer_properties(&ptr_instance->device_layer_list);
+ loader_delete_layer_properties(&ptr_instance->instance_layer_list);
loader_scanned_icd_clear(&ptr_instance->icd_libs);
loader_destroy_ext_list(&ptr_instance->ext_list);
loader.instances = ptr_instance->next;
projects / platform / upstream / Vulkan-Tools.git / commitdiff