openharmony/third_party_vulkan-loader
1
0
Fork 0
mirror of https://gitee.com/openharmony/third_party_vulkan-loader synced 2025-02-17 06:07:51 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

loader: GH370 - re-enable allocator usage

Browse Source 
This reverts commit 5876cc2b7563f909c8ac8cb49f51f7ef715877f8.

This adds the previous fixes as well as additional fixes if Implicit
layers aren't present.  This is not a case that gets tested on Windows
as most SDK installs have at least 1 Implicit layer (RenderDoc).

This change passes an individual run on Jenkins Linux system.

Change-Id: I466cc54b72946e2a9f6477bd4c3d4e4e72eb9579
This commit is contained in:
Mark Young 2016-06-30 13:02:42 -06:00
parent 4c81a240d0
commit 74dd5d177f
9 changed files with 1102 additions and 666 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
loader/cJSON.c
View File

@ -88,6 +88,10 @@ void cJSON_Delete(cJSON *c) {
}
}
void cJSON_Free(void *p) {
cJSON_free(p);
}
/* Parse the input text to generate a number, and populate the result into item.
*/
static const char *parse_number(cJSON *item, const char *num) {

2
loader/cJSON.h
View File

@ -84,6 +84,8 @@ extern char *cJSON_PrintUnformatted(cJSON *item);
extern char *cJSON_PrintBuffered(cJSON *item, int prebuffer, int fmt);
/* Delete a cJSON entity and all subentities. */
extern void cJSON_Delete(cJSON *c);
/* Delete an item allocated inside the JSON parser*/
extern void cJSON_Free(void *p);
/* Returns the number of items in an array (or object). */
extern int cJSON_GetArraySize(cJSON *array);

83
loader/debug_report.c
View File

@ -66,12 +66,16 @@ util_CreateDebugReportCallback(struct loader_instance *inst,
const VkAllocationCallbacks *pAllocator,
VkDebugReportCallbackEXT callback) {
VkLayerDbgFunctionNode *pNewDbgFuncNode;
#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
{
#else
if (pAllocator != NULL) {
pNewDbgFuncNode = (VkLayerDbgFunctionNode *)pAllocator->pfnAllocation(
pAllocator->pUserData, sizeof(VkLayerDbgFunctionNode),
sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
} else {
pNewDbgFuncNode = (VkLayerDbgFunctionNode *)loader_heap_alloc(
#endif
pNewDbgFuncNode = (VkLayerDbgFunctionNode *)loader_instance_heap_alloc(
inst, sizeof(VkLayerDbgFunctionNode),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
}
@ -137,10 +141,14 @@ void util_DestroyDebugReportCallback(struct loader_instance *inst,
pPrev->pNext = pTrav->pNext;
if (inst->DbgFunctionHead == pTrav)
inst->DbgFunctionHead = pTrav->pNext;
#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
{
#else
if (pAllocator != NULL) {
pAllocator->pfnFree(pAllocator->pUserData, pTrav);
} else {
loader_heap_free(inst, pTrav);
#endif
loader_instance_heap_free(inst, pTrav);
}
break;
}
@ -159,6 +167,8 @@ VkResult util_CopyDebugReportCreateInfos(
uint32_t *num_callbacks, VkDebugReportCallbackCreateInfoEXT **infos,
VkDebugReportCallbackEXT **callbacks) {
uint32_t n = *num_callbacks = 0;
VkDebugReportCallbackCreateInfoEXT *pInfos = NULL;
VkDebugReportCallbackEXT *pCallbacks = NULL;
// NOTE: The loader is not using pAllocator, and so this function doesn't
// either.
@ -176,17 +186,38 @@ VkResult util_CopyDebugReportCreateInfos(
return VK_SUCCESS;
}
// 2nd, allocate memory for each VkDebugReportCallbackCreateInfoEXT:
VkDebugReportCallbackCreateInfoEXT *pInfos = *infos =
((VkDebugReportCallbackCreateInfoEXT *)malloc(
// 2nd, allocate memory for each VkDebugReportCallbackCreateInfoEXT:
#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
{
#else
if (pAllocator != NULL) {
pInfos = *infos =
((VkDebugReportCallbackCreateInfoEXT *)pAllocator->pfnAllocation(
pAllocator->pUserData,
n * sizeof(VkDebugReportCallbackCreateInfoEXT), sizeof(void *),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
} else {
#endif
pInfos = *infos = ((VkDebugReportCallbackCreateInfoEXT *)malloc(
n * sizeof(VkDebugReportCallbackCreateInfoEXT)));
}
if (!pInfos) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
// 3rd, allocate memory for a unique handle for each callback:
VkDebugReportCallbackEXT *pCallbacks = *callbacks =
((VkDebugReportCallbackEXT *)malloc(n *
sizeof(VkDebugReportCallbackEXT)));
// 3rd, allocate memory for a unique handle for each callback:
#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
{
#else
if (pAllocator != NULL) {
pCallbacks = *callbacks =
((VkDebugReportCallbackEXT *)pAllocator->pfnAllocation(
pAllocator->pUserData, n * sizeof(VkDebugReportCallbackEXT),
sizeof(void *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
} else {
#endif
pCallbacks = *callbacks = ((VkDebugReportCallbackEXT *)malloc(
n * sizeof(VkDebugReportCallbackEXT)));
}
if (!pCallbacks) {
free(pInfos);
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -281,7 +312,21 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDebugReportCallback(
VkResult res = VK_SUCCESS;
uint32_t storage_idx;
icd_info = calloc(sizeof(VkDebugReportCallbackEXT), inst->total_icd_count);
#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
{
#else
if (pAllocator != NULL) {
icd_info = ((VkDebugReportCallbackEXT *)pAllocator->pfnAllocation(
pAllocator->pUserData,
inst->total_icd_count * sizeof(VkDebugReportCallbackEXT),
sizeof(void *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
memset(icd_info, 0,
inst->total_icd_count * sizeof(VkDebugReportCallbackEXT));
} else {
#endif
icd_info =
calloc(sizeof(VkDebugReportCallbackEXT), inst->total_icd_count);
}
if (!icd_info) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
@ -328,10 +373,9 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDebugReportCallback(
* This is the instance chain terminator function
* for DestroyDebugReportCallback
*/
VKAPI_ATTR void VKAPI_CALL
terminator_DestroyDebugReportCallback(VkInstance instance,
VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks *pAllocator) {
VKAPI_ATTR void VKAPI_CALL terminator_DestroyDebugReportCallback(
VkInstance instance, VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks *pAllocator) {
uint32_t storage_idx;
VkDebugReportCallbackEXT *icd_info;
const struct loader_icd *icd;
@ -356,11 +400,10 @@ terminator_DestroyDebugReportCallback(VkInstance instance,
* This is the instance chain terminator function
* for DebugReportMessage
*/
VKAPI_ATTR void VKAPI_CALL
terminator_DebugReportMessage(VkInstance instance, VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objType,
uint64_t object, size_t location, int32_t msgCode,
const char *pLayerPrefix, const char *pMsg) {
VKAPI_ATTR void VKAPI_CALL terminator_DebugReportMessage(
VkInstance instance, VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
const struct loader_icd *icd;
struct loader_instance *inst = (struct loader_instance *)instance;

16
loader/dirent_on_windows.c
View File

@ -36,9 +36,9 @@ DIR *opendir(const char *name) {
const char *all = /* search pattern must end with suitable wildcard */
strchr("/\\", name[base_length - 1]) ? "*" : "/*";
if ((dir = (DIR *)loader_tls_heap_alloc(sizeof *dir)) != 0 &&
(dir->name = (char *)loader_tls_heap_alloc(base_length +
strlen(all) + 1)) != 0) {
if ((dir = (DIR *)loader_instance_tls_heap_alloc(sizeof *dir)) != 0 &&
(dir->name = (char *)loader_instance_tls_heap_alloc(
base_length + strlen(all) + 1)) != 0) {
strcat(strcpy(dir->name, name), all);
if ((dir->handle =
@ -46,13 +46,13 @@ DIR *opendir(const char *name) {
dir->result.d_name = 0;
} else /* rollback */
{
loader_tls_heap_free(dir->name);
loader_tls_heap_free(dir);
loader_instance_tls_heap_free(dir->name);
loader_instance_tls_heap_free(dir);
dir = 0;
}
} else /* rollback */
{
loader_tls_heap_free(dir);
loader_instance_tls_heap_free(dir);
dir = 0;
errno = ENOMEM;
}
@ -71,8 +71,8 @@ int closedir(DIR *dir) {
result = _findclose(dir->handle);
}
loader_tls_heap_free(dir->name);
loader_tls_heap_free(dir);
loader_instance_tls_heap_free(dir->name);
loader_instance_tls_heap_free(dir);
}
if (result == -1) /* map all errors to EBADF */

1095
loader/loader.c
View File

File diff suppressed because it is too large Load Diff

51
loader/loader.h
View File

@ -44,6 +44,9 @@
#define LOADER_EXPORT
#endif
// A debug option to disable allocators at compile time to investigate future issues.
#define DEBUG_DISABLE_APP_ALLOCATORS 0
#define MAX_STRING_SIZE 1024
#define VK_MAJOR(version) (version >> 22)
#define VK_MINOR(version) ((version >> 12) & 0x3ff)
@ -170,6 +173,8 @@ struct loader_device {
struct loader_layer_list activated_layer_list;
VkAllocationCallbacks alloc_callbacks;
struct loader_device *next;
};
@ -393,14 +398,14 @@ struct loader_msg_callback_map_entry {
};
/* helper function definitions */
void *loader_heap_alloc(const struct loader_instance *instance, size_t size,
VkSystemAllocationScope allocationScope);
void loader_heap_free(const struct loader_instance *instance, void *pMemory);
void *loader_tls_heap_alloc(size_t size);
void loader_tls_heap_free(void *pMemory);
void *loader_instance_heap_alloc(const struct loader_instance *instance, size_t size, VkSystemAllocationScope allocationScope);
void loader_instance_heap_free(const struct loader_instance *instance, void *pMemory);
void *loader_instance_heap_realloc(const struct loader_instance *instance, void *pMemory, size_t orig_size, size_t size, VkSystemAllocationScope alloc_scope);
void *loader_instance_tls_heap_alloc(size_t size);
void loader_instance_tls_heap_free(void *pMemory);
void *loader_device_heap_alloc(const struct loader_device *device, size_t size, VkSystemAllocationScope allocationScope);
void loader_device_heap_free(const struct loader_device *device, void *pMemory);
void *loader_device_heap_realloc(const struct loader_device *device, void *pMemory, size_t orig_size, size_t size, VkSystemAllocationScope alloc_scope);
void loader_log(const struct loader_instance *inst, VkFlags msg_type,
int32_t msg_code, const char *format, ...);
@ -420,9 +425,9 @@ VkResult loader_validate_instance_extensions(
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);
VkResult 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);
@ -450,12 +455,13 @@ bool loader_init_generic_list(const struct loader_instance *inst,
void loader_destroy_generic_list(const struct loader_instance *inst,
struct loader_generic_list *list);
void loader_destroy_layer_list(const struct loader_instance *inst,
struct loader_device *device,
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(
VkResult loader_expand_layer_names(
struct loader_instance *inst, const char *key_name,
uint32_t expand_count,
const char expand_names[][VK_MAX_EXTENSION_NAME_SIZE],
@ -467,17 +473,17 @@ void loader_delete_shadow_dev_layer_names(const struct loader_instance *inst,
void loader_delete_shadow_inst_layer_names(const struct loader_instance *inst,
const VkInstanceCreateInfo *orig,
VkInstanceCreateInfo *ours);
void loader_add_to_layer_list(const struct loader_instance *inst,
struct loader_layer_list *list,
uint32_t prop_list_count,
const struct loader_layer_properties *props);
VkResult loader_add_to_layer_list(const struct loader_instance *inst,
struct loader_layer_list *list,
uint32_t prop_list_count,
const struct loader_layer_properties *props);
void loader_find_layer_name_add_list(
const struct loader_instance *inst, const char *name,
const enum layer_type type, const struct loader_layer_list *search_list,
struct loader_layer_list *found_list);
void loader_scanned_icd_clear(const struct loader_instance *inst,
struct loader_icd_libs *icd_libs);
void loader_icd_scan(const struct loader_instance *inst,
VkResult 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);
@ -494,15 +500,22 @@ void *loader_dev_ext_gpa(struct loader_instance *inst, const char *funcName);
void *loader_get_dev_ext_trampoline(uint32_t index);
struct loader_instance *loader_get_instance(const VkInstance instance);
void loader_deactivate_layers(const struct loader_instance *instance,
struct loader_device *device,
struct loader_layer_list *list);
struct loader_device *
loader_create_logical_device(const struct loader_instance *inst);
loader_create_logical_device(const struct loader_instance *inst, const VkAllocationCallbacks *pAllocator);
void loader_add_logical_device(const struct loader_instance *inst,
struct loader_icd *icd,
struct loader_device *found_dev);
void loader_remove_logical_device(const struct loader_instance *inst,
struct loader_icd *icd,
struct loader_device *found_dev);
struct loader_device *found_dev,
const VkAllocationCallbacks *pAllocator);
// NOTE: Outside of loader, this entry-point is only proivided for error cleanup.
void loader_destroy_logical_device(const struct loader_instance *inst,
struct loader_device *dev,
const VkAllocationCallbacks *pAllocator);
VkResult
loader_enable_instance_layers(struct loader_instance *inst,
const VkInstanceCreateInfo *pCreateInfo,

336
loader/trampoline.c
View File

@ -122,6 +122,7 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName,
struct loader_extension_list local_ext_list;
struct loader_icd_libs icd_libs;
uint32_t copy_size;
VkResult res = VK_SUCCESS;
tls_instance = NULL;
memset(&local_ext_list, 0, sizeof(local_ext_list));
@ -134,7 +135,8 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName,
VK_STRING_ERROR_NONE) {
assert(VK_FALSE && "vkEnumerateInstanceExtensionProperties: "
"pLayerName is too long or is badly formed");
return VK_ERROR_EXTENSION_NOT_PRESENT;
res = VK_ERROR_EXTENSION_NOT_PRESENT;
goto out;
}
loader_layer_scan(NULL, &instance_layers);
@ -154,7 +156,7 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName,
loader_add_to_ext_list(NULL, &local_ext_list, ext_list->count,
ext_list->list);
}
loader_destroy_layer_list(NULL, &local_list);
loader_destroy_layer_list(NULL, NULL, &local_list);
global_ext_list = &local_ext_list;
} else {
@ -170,7 +172,10 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName,
} else {
/* Scan/discover all ICD libraries */
memset(&icd_libs, 0, sizeof(struct loader_icd_libs));
loader_icd_scan(NULL, &icd_libs);
res = loader_icd_scan(NULL, &icd_libs);
if (VK_SUCCESS != res) {
goto out;
}
/* get extensions from all ICD's, merge so no duplicates */
loader_get_icd_loader_instance_extensions(NULL, &icd_libs,
&local_ext_list);
@ -189,16 +194,13 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName,
}
if (global_ext_list == NULL) {
loader_destroy_layer_list(NULL, &instance_layers);
return VK_ERROR_LAYER_NOT_PRESENT;
res = VK_ERROR_LAYER_NOT_PRESENT;
goto out;
}
if (pProperties == NULL) {
*pPropertyCount = global_ext_list->count;
loader_destroy_layer_list(NULL, &instance_layers);
loader_destroy_generic_list(
NULL, (struct loader_generic_list *)&local_ext_list);
return VK_SUCCESS;
goto out;
}
copy_size = *pPropertyCount < global_ext_list->count
@ -209,16 +211,16 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName,
sizeof(VkExtensionProperties));
}
*pPropertyCount = copy_size;
loader_destroy_generic_list(NULL,
(struct loader_generic_list *)&local_ext_list);
if (copy_size < global_ext_list->count) {
loader_destroy_layer_list(NULL, &instance_layers);
return VK_INCOMPLETE;
res = VK_INCOMPLETE;
goto out;
}
loader_destroy_layer_list(NULL, &instance_layers);
return VK_SUCCESS;
out:
loader_destroy_generic_list(NULL, (struct loader_generic_list *)&local_ext_list);
loader_destroy_layer_list(NULL, NULL, &instance_layers);
return res;
}
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
@ -238,7 +240,7 @@ vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount,
if (pProperties == NULL) {
*pPropertyCount = instance_layer_list.count;
loader_destroy_layer_list(NULL, &instance_layer_list);
loader_destroy_layer_list(NULL, NULL, &instance_layer_list);
return VK_SUCCESS;
}
@ -251,7 +253,7 @@ vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount,
}
*pPropertyCount = copy_size;
loader_destroy_layer_list(NULL, &instance_layer_list);
loader_destroy_layer_list(NULL, NULL, &instance_layer_list);
if (copy_size < instance_layer_list.count) {
return VK_INCOMPLETE;
@ -260,41 +262,43 @@ vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount,
return VK_SUCCESS;
}
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkInstance *pInstance) {
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
const VkInstanceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
struct loader_instance *ptr_instance = NULL;
VkInstance created_instance = VK_NULL_HANDLE;
bool loaderLocked = false;
VkResult res = VK_ERROR_INITIALIZATION_FAILED;
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(
pAllocator->pUserData,
sizeof(struct loader_instance),
sizeof(int *),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
{
#else
if (pAllocator) {
ptr_instance = (struct loader_instance *)pAllocator->pfnAllocation(
pAllocator->pUserData, sizeof(struct loader_instance),
sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
} else {
#endif
ptr_instance =
(struct loader_instance *)malloc(sizeof(struct loader_instance));
//}
ptr_instance =
(struct loader_instance *)malloc(sizeof(struct loader_instance));
}
VkInstanceCreateInfo ici = *pCreateInfo;
if (ptr_instance == NULL) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
res = VK_ERROR_OUT_OF_HOST_MEMORY;
goto out;
}
tls_instance = ptr_instance;
loader_platform_thread_lock_mutex(&loader_lock);
loaderLocked = true;
memset(ptr_instance, 0, sizeof(struct loader_instance));
#if 0
if (pAllocator) {
ptr_instance->alloc_callbacks = *pAllocator;
}
#endif
/*
* Look for one or more debug report create info structures
@ -309,9 +313,8 @@ vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
&ptr_instance->tmp_callbacks)) {
// One or more were found, but allocation failed. Therefore, clean up
// and fail this function:
loader_heap_free(ptr_instance, ptr_instance);
loader_platform_thread_unlock_mutex(&loader_lock);
return VK_ERROR_OUT_OF_HOST_MEMORY;
res = VK_ERROR_OUT_OF_HOST_MEMORY;
goto out;
} else if (ptr_instance->num_tmp_callbacks > 0) {
// Setup the temporary callback(s) here to catch early issues:
if (util_CreateDebugReportCallbacks(ptr_instance, pAllocator,
@ -320,12 +323,8 @@ vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
ptr_instance->tmp_callbacks)) {
// Failure of setting up one or more of the callback. Therefore,
// clean up and fail this function:
util_FreeDebugReportCreateInfos(pAllocator,
ptr_instance->tmp_dbg_create_infos,
ptr_instance->tmp_callbacks);
loader_heap_free(ptr_instance, ptr_instance);
loader_platform_thread_unlock_mutex(&loader_lock);
return VK_ERROR_OUT_OF_HOST_MEMORY;
res = VK_ERROR_OUT_OF_HOST_MEMORY;
goto out;
}
}
@ -343,28 +342,26 @@ vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
pCreateInfo->ppEnabledLayerNames,
&ptr_instance->instance_layer_list);
if (res != VK_SUCCESS) {
util_DestroyDebugReportCallbacks(ptr_instance, pAllocator,
ptr_instance->num_tmp_callbacks,
ptr_instance->tmp_callbacks);
util_FreeDebugReportCreateInfos(pAllocator,
ptr_instance->tmp_dbg_create_infos,
ptr_instance->tmp_callbacks);
loader_heap_free(ptr_instance, ptr_instance);
loader_platform_thread_unlock_mutex(&loader_lock);
return res;
goto out;
}
}
/* convert any meta layers to the actual layers makes a copy of layer name*/
VkInstanceCreateInfo ici = *pCreateInfo;
loader_expand_layer_names(
VkResult layerErr = loader_expand_layer_names(
ptr_instance, std_validation_str,
sizeof(std_validation_names) / sizeof(std_validation_names[0]),
std_validation_names, &ici.enabledLayerCount, &ici.ppEnabledLayerNames);
if (VK_SUCCESS != layerErr) {
res = layerErr;
goto out;
}
/* Scan/discover all ICD libraries */
memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs));
loader_icd_scan(ptr_instance, &ptr_instance->icd_libs);
res = loader_icd_scan(ptr_instance, &ptr_instance->icd_libs);
if (res != VK_SUCCESS) {
goto out;
}
/* get extensions from all ICD's, merge so no duplicates, then validate */
loader_get_icd_loader_instance_extensions(
@ -373,45 +370,15 @@ vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
ptr_instance, &ptr_instance->ext_list,
&ptr_instance->instance_layer_list, &ici);
if (res != VK_SUCCESS) {
loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo, &ici);
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(
ptr_instance,
(struct loader_generic_list *)&ptr_instance->ext_list);
util_DestroyDebugReportCallbacks(ptr_instance, pAllocator,
ptr_instance->num_tmp_callbacks,
ptr_instance->tmp_callbacks);
util_FreeDebugReportCreateInfos(pAllocator,
ptr_instance->tmp_dbg_create_infos,
ptr_instance->tmp_callbacks);
loader_platform_thread_unlock_mutex(&loader_lock);
loader_heap_free(ptr_instance, ptr_instance);
return res;
goto out;
}
ptr_instance->disp =
loader_heap_alloc(ptr_instance, sizeof(VkLayerInstanceDispatchTable),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
ptr_instance->disp = loader_instance_heap_alloc(
ptr_instance, sizeof(VkLayerInstanceDispatchTable),
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->instance_layer_list);
loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
loader_destroy_generic_list(
ptr_instance,
(struct loader_generic_list *)&ptr_instance->ext_list);
util_DestroyDebugReportCallbacks(ptr_instance, pAllocator,
ptr_instance->num_tmp_callbacks,
ptr_instance->tmp_callbacks);
util_FreeDebugReportCreateInfos(pAllocator,
ptr_instance->tmp_dbg_create_infos,
ptr_instance->tmp_callbacks);
loader_platform_thread_unlock_mutex(&loader_lock);
loader_heap_free(ptr_instance, ptr_instance);
return VK_ERROR_OUT_OF_HOST_MEMORY;
res = VK_ERROR_OUT_OF_HOST_MEMORY;
goto out;
}
memcpy(ptr_instance->disp, &instance_disp, sizeof(instance_disp));
ptr_instance->next = loader.instances;
@ -421,24 +388,7 @@ vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
res = loader_enable_instance_layers(ptr_instance, &ici,
&ptr_instance->instance_layer_list);
if (res != VK_SUCCESS) {
loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo, &ici);
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(
ptr_instance,
(struct loader_generic_list *)&ptr_instance->ext_list);
loader.instances = ptr_instance->next;
util_DestroyDebugReportCallbacks(ptr_instance, pAllocator,
ptr_instance->num_tmp_callbacks,
ptr_instance->tmp_callbacks);
util_FreeDebugReportCreateInfos(pAllocator,
ptr_instance->tmp_dbg_create_infos,
ptr_instance->tmp_callbacks);
loader_platform_thread_unlock_mutex(&loader_lock);
loader_heap_free(ptr_instance, ptr_instance->disp);
loader_heap_free(ptr_instance, ptr_instance);
return res;
goto out;
}
created_instance = (VkInstance)ptr_instance;
@ -462,18 +412,57 @@ vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
// TODO: cleanup here.
}
/* Remove temporary debug_report callback */
util_DestroyDebugReportCallbacks(ptr_instance, pAllocator,
ptr_instance->num_tmp_callbacks,
ptr_instance->tmp_callbacks);
loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo, &ici);
loader_platform_thread_unlock_mutex(&loader_lock);
out:
if (NULL != ptr_instance) {
if (res != VK_SUCCESS) {
if (NULL != ptr_instance->next) {
loader.instances = ptr_instance->next;
}
if (NULL != ptr_instance->disp) {
loader_instance_heap_free(ptr_instance, ptr_instance->disp);
}
if (ptr_instance->num_tmp_callbacks > 0) {
util_DestroyDebugReportCallbacks(
ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
ptr_instance->tmp_callbacks);
util_FreeDebugReportCreateInfos(
pAllocator, ptr_instance->tmp_dbg_create_infos,
ptr_instance->tmp_callbacks);
}
loader_deactivate_layers(ptr_instance, NULL,
&ptr_instance->activated_layer_list);
loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo,
&ici);
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(
ptr_instance,
(struct loader_generic_list *)&ptr_instance->ext_list);
loader_instance_heap_free(ptr_instance, ptr_instance);
} else {
/* Remove temporary debug_report callback */
util_DestroyDebugReportCallbacks(ptr_instance, pAllocator,
ptr_instance->num_tmp_callbacks,
ptr_instance->tmp_callbacks);
loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo,
&ici);
}
if (loaderLocked) {
loader_platform_thread_unlock_mutex(&loader_lock);
}
}
return res;
}
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
vkDestroyInstance(VkInstance instance,
const VkAllocationCallbacks *pAllocator) {
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
VkInstance instance, const VkAllocationCallbacks *pAllocator) {
const VkLayerInstanceDispatchTable *disp;
struct loader_instance *ptr_instance = NULL;
bool callback_setup = false;
@ -488,6 +477,10 @@ vkDestroyInstance(VkInstance instance,
ptr_instance = loader_get_instance(instance);
if (pAllocator) {
ptr_instance->alloc_callbacks = *pAllocator;
}
if (ptr_instance->num_tmp_callbacks > 0) {
// Setup the temporary callback(s) here to catch cleanup issues:
if (!util_CreateDebugReportCallbacks(ptr_instance, pAllocator,
@ -500,9 +493,11 @@ vkDestroyInstance(VkInstance instance,
disp->DestroyInstance(instance, pAllocator);
loader_deactivate_layers(ptr_instance, &ptr_instance->activated_layer_list);
if (ptr_instance->phys_devs)
loader_heap_free(ptr_instance, ptr_instance->phys_devs);
loader_deactivate_layers(ptr_instance, NULL,
&ptr_instance->activated_layer_list);
if (ptr_instance->phys_devs) {
loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs);
}
if (callback_setup) {
util_DestroyDebugReportCallbacks(ptr_instance, pAllocator,
ptr_instance->num_tmp_callbacks,
@ -511,8 +506,8 @@ vkDestroyInstance(VkInstance instance,
ptr_instance->tmp_dbg_create_infos,
ptr_instance->tmp_callbacks);
}
loader_heap_free(ptr_instance, ptr_instance->disp);
loader_heap_free(ptr_instance, ptr_instance);
loader_instance_heap_free(ptr_instance, ptr_instance->disp);
loader_instance_heap_free(ptr_instance, ptr_instance);
loader_platform_thread_unlock_mutex(&loader_lock);
}
@ -551,7 +546,7 @@ vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
*pPhysicalDeviceCount = count;
if (!inst->phys_devs) {
inst->phys_devs =
(struct loader_physical_device_tramp *)loader_heap_alloc(
(struct loader_physical_device_tramp *)loader_instance_heap_alloc(
inst, inst->total_gpu_count *
sizeof(struct loader_physical_device_tramp),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
@ -643,14 +638,13 @@ LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
pMemoryProperties);
}
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
vkCreateDevice(VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
VkResult res;
struct loader_physical_device_tramp *phys_dev;
struct loader_device *dev;
struct loader_instance *inst;
struct loader_physical_device_tramp *phys_dev = NULL;
struct loader_device *dev = NULL;
struct loader_instance *inst = NULL;
assert(pCreateInfo->queueCreateInfoCount >= 1);
@ -661,52 +655,51 @@ vkCreateDevice(VkPhysicalDevice physicalDevice,
/* Get the physical device (ICD) extensions */
struct loader_extension_list icd_exts;
icd_exts.list = NULL;
if (!loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts,
sizeof(VkExtensionProperties))) {
loader_platform_thread_unlock_mutex(&loader_lock);
return VK_ERROR_OUT_OF_HOST_MEMORY;
res = VK_ERROR_OUT_OF_HOST_MEMORY;
goto out;
}
res = loader_add_device_extensions(
inst, inst->disp->EnumerateDeviceExtensionProperties,
phys_dev->phys_dev, "Unknown", &icd_exts);
if (res != VK_SUCCESS) {
loader_platform_thread_unlock_mutex(&loader_lock);
return res;
goto out;
}
/* make sure requested extensions to be enabled are supported */
res = loader_validate_device_extensions(phys_dev, &inst->activated_layer_list,
&icd_exts, pCreateInfo);
res = loader_validate_device_extensions(
phys_dev, &inst->activated_layer_list, &icd_exts, pCreateInfo);
if (res != VK_SUCCESS) {
loader_platform_thread_unlock_mutex(&loader_lock);
return res;
goto out;
}
dev = loader_create_logical_device(inst);
dev = loader_create_logical_device(inst, pAllocator);
if (dev == NULL) {
loader_platform_thread_unlock_mutex(&loader_lock);
return VK_ERROR_OUT_OF_HOST_MEMORY;
res = VK_ERROR_OUT_OF_HOST_MEMORY;
goto out;
}
/* 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);
dev->activated_layer_list.list =
loader_device_heap_alloc(dev, inst->activated_layer_list.capacity,
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
if (dev->activated_layer_list.list == NULL) {
loader_platform_thread_unlock_mutex(&loader_lock);
return VK_ERROR_OUT_OF_HOST_MEMORY;
res = VK_ERROR_OUT_OF_HOST_MEMORY;
goto out;
}
memcpy(dev->activated_layer_list.list, inst->activated_layer_list.list,
sizeof(*dev->activated_layer_list.list) * dev->activated_layer_list.count);
sizeof(*dev->activated_layer_list.list) *
dev->activated_layer_list.count);
res = loader_create_device_chain(phys_dev, pCreateInfo, pAllocator, inst, dev);
res = loader_create_device_chain(phys_dev, pCreateInfo, pAllocator, inst,
dev);
if (res != VK_SUCCESS) {
loader_platform_thread_unlock_mutex(&loader_lock);
return res;
goto out;
}
*pDevice = dev->device;
@ -721,6 +714,19 @@ vkCreateDevice(VkPhysicalDevice physicalDevice,
&dev->loader_dispatch,
dev->loader_dispatch.core_dispatch.GetDeviceProcAddr, *pDevice);
out:
// Failure cleanup
if (VK_SUCCESS != res) {
if (NULL != dev) {
loader_destroy_logical_device(inst, dev, pAllocator);
}
}
if (NULL != icd_exts.list) {
loader_destroy_generic_list(inst,
(struct loader_generic_list *)&icd_exts);
}
loader_platform_thread_unlock_mutex(&loader_lock);
return res;
}
@ -742,7 +748,7 @@ vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
disp->DestroyDevice(device, pAllocator);
dev->device = NULL;
loader_remove_logical_device(inst, icd, dev);
loader_remove_logical_device(inst, icd, dev, pAllocator);
loader_platform_thread_unlock_mutex(&loader_lock);
}
@ -880,7 +886,7 @@ vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
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,
enabled_layers->list = loader_instance_heap_alloc(inst, enabled_layers->capacity,
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (!enabled_layers->list)
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -893,14 +899,21 @@ vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
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);
VkResult err = loader_copy_layer_properties(inst,
&enabled_layers->list[j],
&props);
if (err != VK_SUCCESS) {
return err;
}
i += std_val_count;
}
else {
loader_copy_layer_properties(inst,
&enabled_layers->list[j],
&inst->activated_layer_list.list[i++]);
VkResult err = loader_copy_layer_properties(inst,
&enabled_layers->list[j],
&inst->activated_layer_list.list[i++]);
if (err != VK_SUCCESS) {
return err;
}
}
}
}
@ -916,8 +929,9 @@ vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
}
*pPropertyCount = copy_size;
if (inst->activated_layers_are_std_val)
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;

29
loader/vk_loader_platform.h
View File

@ -136,12 +136,6 @@ static inline char *loader_platform_dirname(char *path) {
return dirname(path);
}
// Environment variables
static inline char *loader_getenv(const char *name) { return getenv(name); }
static inline void loader_free_getenv(const char *val) {}
// Dynamic Loading of libraries:
typedef void *loader_platform_dl_handle;
static inline loader_platform_dl_handle
@ -322,29 +316,6 @@ static char *loader_platform_basename(char *pathname) {
return current;
}
// Environment variables
static inline char *loader_getenv(const char *name) {
char *retVal;
DWORD valSize;
valSize = GetEnvironmentVariableA(name, NULL, 0);
// valSize DOES include the null terminator, so for any set variable
// will always be at least 1. If it's 0, the variable wasn't set.
if (valSize == 0)
return NULL;
// TODO; FIXME This should be using any app defined memory allocation
retVal = (char *)malloc(valSize);
GetEnvironmentVariableA(name, retVal, valSize);
return retVal;
}
static inline void loader_free_getenv(const char *val) { free((void *)val); }
// Dynamic Loading:
typedef HMODULE loader_platform_dl_handle;
static loader_platform_dl_handle

152
loader/wsi.c
View File

@ -214,7 +214,7 @@ terminator_DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
const VkAllocationCallbacks *pAllocator) {
struct loader_instance *ptr_instance = loader_get_instance(instance);
loader_heap_free(ptr_instance, (void *)surface);
loader_instance_heap_free(ptr_instance, (void *)surface);
}
/*
@ -431,11 +431,9 @@ terminator_GetPhysicalDeviceSurfacePresentModesKHR(
* This is the trampoline entrypoint
* for CreateSwapchainKHR
*/
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
vkCreateSwapchainKHR(VkDevice device,
const VkSwapchainCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkSwapchainKHR *pSwapchain) {
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
VkResult res =
@ -507,11 +505,9 @@ vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {
* This is the trampoline entrypoint
* for CreateWin32SurfaceKHR
*/
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
vkCreateWin32SurfaceKHR(VkInstance instance,
const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkSurfaceKHR *pSurface) {
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
const VkLayerInstanceDispatchTable *disp;
disp = loader_get_instance_dispatch(instance);
VkResult res;
@ -525,11 +521,9 @@ vkCreateWin32SurfaceKHR(VkInstance instance,
* This is the instance chain terminator function
* for CreateWin32SurfaceKHR
*/
VKAPI_ATTR VkResult VKAPI_CALL
terminator_CreateWin32SurfaceKHR(VkInstance instance,
const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkSurfaceKHR *pSurface) {
VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWin32SurfaceKHR(
VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
// First, check to ensure the appropriate extension was enabled:
struct loader_instance *ptr_instance = loader_get_instance(instance);
if (!ptr_instance->wsi_win32_surface_enabled) {
@ -542,8 +536,9 @@ terminator_CreateWin32SurfaceKHR(VkInstance instance,
// Next, if so, proceed with the implementation of this function:
VkIcdSurfaceWin32 *pIcdSurface = NULL;
pIcdSurface = loader_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceWin32),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
pIcdSurface =
loader_instance_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceWin32),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (pIcdSurface == NULL) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
@ -615,11 +610,9 @@ terminator_GetPhysicalDeviceWin32PresentationSupportKHR(
* This is the trampoline entrypoint
* for CreateMirSurfaceKHR
*/
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
vkCreateMirSurfaceKHR(VkInstance instance,
const VkMirSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkSurfaceKHR *pSurface) {
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
const VkLayerInstanceDispatchTable *disp;
disp = loader_get_instance_dispatch(instance);
VkResult res;
@ -633,11 +626,9 @@ vkCreateMirSurfaceKHR(VkInstance instance,
* This is the instance chain terminator function
* for CreateMirSurfaceKHR
*/
VKAPI_ATTR VkResult VKAPI_CALL
terminator_CreateMirSurfaceKHR(VkInstance instance,
const VkMirSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkSurfaceKHR *pSurface) {
VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMirSurfaceKHR(
VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
// First, check to ensure the appropriate extension was enabled:
struct loader_instance *ptr_instance = loader_get_instance(instance);
if (!ptr_instance->wsi_mir_surface_enabled) {
@ -650,8 +641,9 @@ terminator_CreateMirSurfaceKHR(VkInstance instance,
// Next, if so, proceed with the implementation of this function:
VkIcdSurfaceMir *pIcdSurface = NULL;
pIcdSurface = loader_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceMir),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
pIcdSurface =
loader_instance_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceMir),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (pIcdSurface == NULL) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
@ -743,8 +735,7 @@ vkCreateWaylandSurfaceKHR(VkInstance instance,
* This is the instance chain terminator function
* for CreateWaylandSurfaceKHR
*/
VKAPI_ATTR VkResult VKAPI_CALL
terminator_CreateWaylandSurfaceKHR(
VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWaylandSurfaceKHR(
VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
// First, check to ensure the appropriate extension was enabled:
@ -759,8 +750,9 @@ terminator_CreateWaylandSurfaceKHR(
// Next, if so, proceed with the implementation of this function:
VkIcdSurfaceWayland *pIcdSurface = NULL;
pIcdSurface = loader_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceWayland),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
pIcdSurface =
loader_instance_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceWayland),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (pIcdSurface == NULL) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
@ -834,11 +826,9 @@ terminator_GetPhysicalDeviceWaylandPresentationSupportKHR(
* This is the trampoline entrypoint
* for CreateXcbSurfaceKHR
*/
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
vkCreateXcbSurfaceKHR(VkInstance instance,
const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkSurfaceKHR *pSurface) {
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
const VkLayerInstanceDispatchTable *disp;
disp = loader_get_instance_dispatch(instance);
VkResult res;
@ -852,11 +842,9 @@ vkCreateXcbSurfaceKHR(VkInstance instance,
* This is the instance chain terminator function
* for CreateXcbSurfaceKHR
*/
VKAPI_ATTR VkResult VKAPI_CALL
terminator_CreateXcbSurfaceKHR(VkInstance instance,
const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkSurfaceKHR *pSurface) {
VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXcbSurfaceKHR(
VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
// First, check to ensure the appropriate extension was enabled:
struct loader_instance *ptr_instance = loader_get_instance(instance);
if (!ptr_instance->wsi_xcb_surface_enabled) {
@ -869,8 +857,9 @@ terminator_CreateXcbSurfaceKHR(VkInstance instance,
// Next, if so, proceed with the implementation of this function:
VkIcdSurfaceXcb *pIcdSurface = NULL;
pIcdSurface = loader_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceXcb),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
pIcdSurface =
loader_instance_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceXcb),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (pIcdSurface == NULL) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
@ -945,11 +934,9 @@ terminator_GetPhysicalDeviceXcbPresentationSupportKHR(
* This is the trampoline entrypoint
* for CreateXlibSurfaceKHR
*/
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
vkCreateXlibSurfaceKHR(VkInstance instance,
const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkSurfaceKHR *pSurface) {
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
const VkLayerInstanceDispatchTable *disp;
disp = loader_get_instance_dispatch(instance);
VkResult res;
@ -963,11 +950,9 @@ vkCreateXlibSurfaceKHR(VkInstance instance,
* This is the instance chain terminator function
* for CreateXlibSurfaceKHR
*/
VKAPI_ATTR VkResult VKAPI_CALL
terminator_CreateXlibSurfaceKHR(VkInstance instance,
const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkSurfaceKHR *pSurface) {
VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXlibSurfaceKHR(
VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
// First, check to ensure the appropriate extension was enabled:
struct loader_instance *ptr_instance = loader_get_instance(instance);
if (!ptr_instance->wsi_xlib_surface_enabled) {
@ -980,8 +965,9 @@ terminator_CreateXlibSurfaceKHR(VkInstance instance,
// Next, if so, proceed with the implementation of this function:
VkIcdSurfaceXlib *pIcdSurface = NULL;
pIcdSurface = loader_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceXlib),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
pIcdSurface =
loader_instance_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceXlib),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (pIcdSurface == NULL) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
@ -1055,10 +1041,9 @@ terminator_GetPhysicalDeviceXlibPresentationSupportKHR(
* This is the trampoline entrypoint
* for CreateAndroidSurfaceKHR
*/
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
vkCreateAndroidSurfaceKHR(VkInstance instance, ANativeWindow *window,
const VkAllocationCallbacks *pAllocator,
VkSurfaceKHR *pSurface) {
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
VkInstance instance, ANativeWindow *window,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
const VkLayerInstanceDispatchTable *disp;
disp = loader_get_instance_dispatch(instance);
VkResult res;
@ -1071,10 +1056,9 @@ vkCreateAndroidSurfaceKHR(VkInstance instance, ANativeWindow *window,
* This is the instance chain terminator function
* for CreateAndroidSurfaceKHR
*/
VKAPI_ATTR VkResult VKAPI_CALL
terminator_CreateAndroidSurfaceKHR(VkInstance instance, Window window,
const VkAllocationCallbacks *pAllocator,
VkSurfaceKHR *pSurface) {
VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateAndroidSurfaceKHR(
VkInstance instance, Window window, const VkAllocationCallbacks *pAllocator,
VkSurfaceKHR *pSurface) {
// First, check to ensure the appropriate extension was enabled:
struct loader_instance *ptr_instance = loader_get_instance(instance);
if (!ptr_instance->wsi_display_enabled) {
@ -1087,8 +1071,9 @@ terminator_CreateAndroidSurfaceKHR(VkInstance instance, Window window,
// Next, if so, proceed with the implementation of this function:
VkIcdSurfaceAndroid *pIcdSurface = NULL;
pIcdSurface = loader_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceAndroid),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
pIcdSurface =
loader_instance_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceAndroid),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (pIcdSurface == NULL) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
@ -1265,11 +1250,10 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayModePropertiesKHR(
pPropertyCount, pProperties);
}
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDisplayModeKHR *pMode) {
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
VkPhysicalDevice physicalDevice, VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) {
VkPhysicalDevice unwrapped_phys_dev =
loader_unwrap_physical_device(physicalDevice);
const VkLayerInstanceDispatchTable *disp;
@ -1279,12 +1263,10 @@ vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
return res;
}
VKAPI_ATTR VkResult VKAPI_CALL
terminator_CreateDisplayModeKHR(VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDisplayModeKHR *pMode) {
VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayModeKHR(
VkPhysicalDevice physicalDevice, VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) {
// First, check to ensure the appropriate extension was enabled:
struct loader_physical_device *phys_dev =
(struct loader_physical_device *)physicalDevice;
@ -1345,11 +1327,9 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilitiesKHR(
planeIndex, pCapabilities);
}
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
vkCreateDisplayPlaneSurfaceKHR(VkInstance instance,
const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkSurfaceKHR *pSurface) {
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
const VkLayerInstanceDispatchTable *disp;
disp = loader_get_instance_dispatch(instance);
VkResult res;
@ -1372,8 +1352,8 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayPlaneSurfaceKHR(
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
pIcdSurface = loader_heap_alloc(inst, sizeof(VkIcdSurfaceDisplay),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
pIcdSurface = loader_instance_heap_alloc(
inst, sizeof(VkIcdSurfaceDisplay), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (pIcdSurface == NULL) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}