3 * Copyright (c) 2014-2017 The Khronos Group Inc.
4 * Copyright (c) 2014-2017 Valve Corporation
5 * Copyright (c) 2014-2017 LunarG, Inc.
6 * Copyright (C) 2015 Google Inc.
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
20 * Author: Jon Ashburn <jon@lunarg.com>
21 * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
22 * Author: Chia-I Wu <olvaffe@gmail.com>
23 * Author: Chia-I Wu <olv@lunarg.com>
24 * Author: Mark Lobodzinski <mark@LunarG.com>
31 #include <vulkan/vulkan.h>
32 #include "vk_loader_platform.h"
33 #include "vk_loader_layer.h"
34 #include <vulkan/vk_layer.h>
35 #include <vulkan/vk_icd.h>
37 #include "vk_loader_extensions.h"
39 #if defined(__GNUC__) && __GNUC__ >= 4
40 #define LOADER_EXPORT __attribute__((visibility("default")))
41 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
42 #define LOADER_EXPORT __attribute__((visibility("default")))
47 // A debug option to disable allocators at compile time to investigate future issues.
48 #define DEBUG_DISABLE_APP_ALLOCATORS 0
50 #define MAX_STRING_SIZE 1024
52 // This is defined in vk_layer.h, but if there's problems we need to create the define
54 #ifndef MAX_NUM_UNKNOWN_EXTS
55 #define MAX_NUM_UNKNOWN_EXTS 250
58 enum layer_type_flags {
59 VK_LAYER_TYPE_FLAG_INSTANCE_LAYER = 0x1, // If not set, indicates Device layer
60 VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER = 0x2, // If not set, indicates Implicit layer
61 VK_LAYER_TYPE_FLAG_META_LAYER = 0x4, // If not set, indicates standard layer
64 typedef enum VkStringErrorFlagBits {
65 VK_STRING_ERROR_NONE = 0x00000000,
66 VK_STRING_ERROR_LENGTH = 0x00000001,
67 VK_STRING_ERROR_BAD_DATA = 0x00000002,
68 } VkStringErrorFlagBits;
69 typedef VkFlags VkStringErrorFlags;
71 static const int MaxLoaderStringLength = 256;
72 static const char UTF8_ONE_BYTE_CODE = 0xC0;
73 static const char UTF8_ONE_BYTE_MASK = 0xE0;
74 static const char UTF8_TWO_BYTE_CODE = 0xE0;
75 static const char UTF8_TWO_BYTE_MASK = 0xF0;
76 static const char UTF8_THREE_BYTE_CODE = 0xF0;
77 static const char UTF8_THREE_BYTE_MASK = 0xF8;
78 static const char UTF8_DATA_BYTE_CODE = 0x80;
79 static const char UTF8_DATA_BYTE_MASK = 0xC0;
81 struct VkStructureHeader {
82 VkStructureType sType;
86 // form of all dynamic lists/arrays
87 // only the list element should be changed
88 struct loader_generic_list {
94 struct loader_extension_list {
97 VkExtensionProperties *list;
100 struct loader_dev_ext_props {
101 VkExtensionProperties props;
102 uint32_t entrypoint_count;
106 struct loader_device_extension_list {
109 struct loader_dev_ext_props *list;
112 struct loader_name_value {
113 char name[MAX_STRING_SIZE];
114 char value[MAX_STRING_SIZE];
117 struct loader_layer_functions {
118 char str_gipa[MAX_STRING_SIZE];
119 char str_gdpa[MAX_STRING_SIZE];
120 char str_negotiate_interface[MAX_STRING_SIZE];
121 PFN_vkNegotiateLoaderLayerInterfaceVersion negotiate_layer_interface;
122 PFN_vkGetInstanceProcAddr get_instance_proc_addr;
123 PFN_vkGetDeviceProcAddr get_device_proc_addr;
124 PFN_GetPhysicalDeviceProcAddr get_physical_device_proc_addr;
127 struct loader_layer_properties {
128 VkLayerProperties info;
129 enum layer_type_flags type_flags;
130 uint32_t interface_version; // PFN_vkNegotiateLoaderLayerInterfaceVersion
131 char lib_name[MAX_STRING_SIZE];
132 loader_platform_dl_handle lib_handle;
133 struct loader_layer_functions functions;
134 struct loader_extension_list instance_extension_list;
135 struct loader_device_extension_list device_extension_list;
136 struct loader_name_value disable_env_var;
137 struct loader_name_value enable_env_var;
138 uint32_t num_component_layers;
139 char (*component_layer_names)[MAX_STRING_SIZE];
141 char enumerate_instance_extension_properties[MAX_STRING_SIZE];
142 char enumerate_instance_layer_properties[MAX_STRING_SIZE];
143 char enumerate_instance_version[MAX_STRING_SIZE];
144 } pre_instance_functions;
147 struct loader_layer_list {
150 struct loader_layer_properties *list;
153 struct loader_dispatch_hash_list {
156 uint32_t *index; // index into the dev_ext dispatch table
159 // loader_dispatch_hash_entry and loader_dev_ext_dispatch_table.dev_ext have
160 // one to one correspondence; one loader_dispatch_hash_entry for one dev_ext
162 // Also have a one to one correspondence with functions in dev_ext_trampoline.c
163 struct loader_dispatch_hash_entry {
165 struct loader_dispatch_hash_list list; // to handle hashing collisions
168 typedef void(VKAPI_PTR *PFN_vkDevExt)(VkDevice device);
169 struct loader_dev_ext_dispatch_table {
170 PFN_vkDevExt dev_ext[MAX_NUM_UNKNOWN_EXTS];
173 struct loader_dev_dispatch_table {
174 VkLayerDispatchTable core_dispatch;
175 struct loader_dev_ext_dispatch_table ext_dispatch;
178 // per CreateDevice structure
179 struct loader_device {
180 struct loader_dev_dispatch_table loader_dispatch;
181 VkDevice chain_device; // device object from the dispatch chain
182 VkDevice icd_device; // device object from the icd
183 struct loader_physical_device_term *phys_dev_term;
185 // List of activated layers.
186 // app_ is the version based on exactly what the application asked for.
187 // This is what must be returned to the application on Enumerate calls.
188 // expanded_ is the version based on expanding meta-layers into their
189 // individual component layers. This is what is used internally.
190 struct loader_layer_list app_activated_layer_list;
191 struct loader_layer_list expanded_activated_layer_list;
193 VkAllocationCallbacks alloc_callbacks;
195 // List of activated device extensions that have terminators implemented in the loader
197 bool khr_swapchain_enabled;
198 bool khr_display_swapchain_enabled;
199 bool ext_debug_marker_enabled;
200 bool ext_debug_utils_enabled;
203 struct loader_device *next;
206 // Per ICD information
209 struct loader_icd_term {
210 // pointers to find other structs
211 const struct loader_scanned_icd *scanned_icd;
212 const struct loader_instance *this_instance;
213 struct loader_device *logical_device_list;
214 VkInstance instance; // instance object from the icd
215 struct loader_icd_term_dispatch dispatch;
217 struct loader_icd_term *next;
219 PFN_PhysDevExt phys_dev_ext[MAX_NUM_UNKNOWN_EXTS];
222 // Per ICD library structure
223 struct loader_icd_tramp_list {
226 struct loader_scanned_icd *scanned_list;
229 struct loader_instance_dispatch_table {
230 VkLayerInstanceDispatchTable layer_inst_disp; // must be first entry in structure
232 // Physical device functions unknown to the loader
233 PFN_PhysDevExt phys_dev_ext[MAX_NUM_UNKNOWN_EXTS];
236 // Per instance structure
237 struct loader_instance {
238 struct loader_instance_dispatch_table *disp; // must be first entry in structure
240 // Vulkan API version the app is intending to use.
241 uint16_t app_api_major_version;
242 uint16_t app_api_minor_version;
244 // We need to manually track physical devices over time. If the user
245 // re-queries the information, we don't want to delete old data or
246 // create new data unless necessary.
247 uint32_t total_gpu_count;
248 uint32_t phys_dev_count_term;
249 struct loader_physical_device_term **phys_devs_term;
250 uint32_t phys_dev_count_tramp;
251 struct loader_physical_device_tramp **phys_devs_tramp;
253 // We also need to manually track physical device groups, but we don't need
254 // loader specific structures since we have that content in the physical
255 // device stored internal to the public structures.
256 uint32_t phys_dev_group_count_term;
257 struct VkPhysicalDeviceGroupProperties **phys_dev_groups_term;
258 uint32_t phys_dev_group_count_tramp;
259 struct VkPhysicalDeviceGroupProperties **phys_dev_groups_tramp;
261 struct loader_instance *next;
263 uint32_t total_icd_count;
264 struct loader_icd_term *icd_terms;
265 struct loader_icd_tramp_list icd_tramp_list;
267 struct loader_dispatch_hash_entry dev_ext_disp_hash[MAX_NUM_UNKNOWN_EXTS];
268 struct loader_dispatch_hash_entry phys_dev_ext_disp_hash[MAX_NUM_UNKNOWN_EXTS];
270 struct loader_msg_callback_map_entry *icd_msg_callback_map;
272 struct loader_layer_list instance_layer_list;
274 // List of activated layers.
275 // app_ is the version based on exactly what the application asked for.
276 // This is what must be returned to the application on Enumerate calls.
277 // expanded_ is the version based on expanding meta-layers into their
278 // individual component layers. This is what is used internally.
279 struct loader_layer_list app_activated_layer_list;
280 struct loader_layer_list expanded_activated_layer_list;
282 VkInstance instance; // layers/ICD instance returned to trampoline
284 struct loader_extension_list ext_list; // icds and loaders extensions
285 union loader_instance_extension_enables enabled_known_extensions;
287 VkLayerDbgFunctionNode *DbgFunctionHead;
288 uint32_t num_tmp_report_callbacks;
289 VkDebugReportCallbackCreateInfoEXT *tmp_report_create_infos;
290 VkDebugReportCallbackEXT *tmp_report_callbacks;
291 uint32_t num_tmp_messengers;
292 VkDebugUtilsMessengerCreateInfoEXT *tmp_messenger_create_infos;
293 VkDebugUtilsMessengerEXT *tmp_messengers;
295 VkAllocationCallbacks alloc_callbacks;
297 bool wsi_surface_enabled;
298 #ifdef VK_USE_PLATFORM_WIN32_KHR
299 bool wsi_win32_surface_enabled;
301 #ifdef VK_USE_PLATFORM_MIR_KHR
302 bool wsi_mir_surface_enabled;
304 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
305 bool wsi_wayland_surface_enabled;
307 #ifdef VK_USE_PLATFORM_XCB_KHR
308 bool wsi_xcb_surface_enabled;
310 #ifdef VK_USE_PLATFORM_XLIB_KHR
311 bool wsi_xlib_surface_enabled;
313 #ifdef VK_USE_PLATFORM_ANDROID_KHR
314 bool wsi_android_surface_enabled;
316 #ifdef VK_USE_PLATFORM_MACOS_MVK
317 bool wsi_macos_surface_enabled;
319 #ifdef VK_USE_PLATFORM_IOS_MVK
320 bool wsi_ios_surface_enabled;
322 bool wsi_display_enabled;
325 // VkPhysicalDevice requires special treatment by loader. Firstly, terminator
326 // code must be able to get the struct loader_icd_term to call into the proper
327 // driver (multiple ICD/gpu case). This can be accomplished by wrapping the
328 // created VkPhysicalDevice in loader terminate_EnumeratePhysicalDevices().
329 // Secondly, the loader must be able to handle wrapped by layer VkPhysicalDevice
330 // in trampoline code. This implies, that the loader trampoline code must also
331 // wrap the VkPhysicalDevice object in trampoline code. Thus, loader has to
332 // wrap the VkPhysicalDevice created object twice. In trampoline code it can't
333 // rely on the terminator object wrapping since a layer may also wrap. Since
334 // trampoline code wraps the VkPhysicalDevice this means all loader trampoline
335 // code that passes a VkPhysicalDevice should unwrap it.
337 // Per enumerated PhysicalDevice structure, used to wrap in trampoline code and
338 // also same structure used to wrap in terminator code
339 struct loader_physical_device_tramp {
340 struct loader_instance_dispatch_table *disp; // must be first entry in structure
341 struct loader_instance *this_instance;
342 VkPhysicalDevice phys_dev; // object from layers/loader terminator
345 // Per enumerated PhysicalDevice structure, used to wrap in terminator code
346 struct loader_physical_device_term {
347 struct loader_instance_dispatch_table *disp; // must be first entry in structure
348 struct loader_icd_term *this_icd_term;
350 VkPhysicalDevice phys_dev; // object from ICD
353 struct loader_struct {
354 struct loader_instance *instances;
357 struct loader_scanned_icd {
359 loader_platform_dl_handle handle;
360 uint32_t api_version;
361 uint32_t interface_version;
362 PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
363 PFN_GetPhysicalDeviceProcAddr GetPhysicalDeviceProcAddr;
364 PFN_vkCreateInstance CreateInstance;
365 PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties;
368 static inline struct loader_instance *loader_instance(VkInstance instance) { return (struct loader_instance *)instance; }
370 static inline VkPhysicalDevice loader_unwrap_physical_device(VkPhysicalDevice physicalDevice) {
371 struct loader_physical_device_tramp *phys_dev = (struct loader_physical_device_tramp *)physicalDevice;
372 return phys_dev->phys_dev;
375 static inline void loader_set_dispatch(void *obj, const void *data) { *((const void **)obj) = data; }
377 static inline VkLayerDispatchTable *loader_get_dispatch(const void *obj) { return *((VkLayerDispatchTable **)obj); }
379 static inline struct loader_dev_dispatch_table *loader_get_dev_dispatch(const void *obj) {
380 return *((struct loader_dev_dispatch_table **)obj);
383 static inline VkLayerInstanceDispatchTable *loader_get_instance_layer_dispatch(const void *obj) {
384 return *((VkLayerInstanceDispatchTable **)obj);
387 static inline struct loader_instance_dispatch_table *loader_get_instance_dispatch(const void *obj) {
388 return *((struct loader_instance_dispatch_table **)obj);
391 static inline void loader_init_dispatch(void *obj, const void *data) {
393 assert(valid_loader_magic_value(obj) &&
394 "Incompatible ICD, first dword must be initialized to "
395 "ICD_LOADER_MAGIC. See loader/README.md for details.");
398 loader_set_dispatch(obj, data);
401 // Global variables used across files
402 extern struct loader_struct loader;
403 extern THREAD_LOCAL_DECL struct loader_instance *tls_instance;
404 #if defined(_WIN32) && !defined(LOADER_DYNAMIC_LIB)
405 extern LOADER_PLATFORM_THREAD_ONCE_DEFINITION(once_init);
407 extern loader_platform_thread_mutex loader_lock;
408 extern loader_platform_thread_mutex loader_json_lock;
410 struct loader_msg_callback_map_entry {
411 VkDebugReportCallbackEXT icd_obj;
412 VkDebugReportCallbackEXT loader_obj;
415 // Helper function definitions
416 void *loader_instance_heap_alloc(const struct loader_instance *instance, size_t size, VkSystemAllocationScope allocationScope);
417 void loader_instance_heap_free(const struct loader_instance *instance, void *pMemory);
418 void *loader_instance_heap_realloc(const struct loader_instance *instance, void *pMemory, size_t orig_size, size_t size,
419 VkSystemAllocationScope alloc_scope);
420 void *loader_instance_tls_heap_alloc(size_t size);
421 void loader_instance_tls_heap_free(void *pMemory);
422 void *loader_device_heap_alloc(const struct loader_device *device, size_t size, VkSystemAllocationScope allocationScope);
423 void loader_device_heap_free(const struct loader_device *device, void *pMemory);
424 void *loader_device_heap_realloc(const struct loader_device *device, void *pMemory, size_t orig_size, size_t size,
425 VkSystemAllocationScope alloc_scope);
427 void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t msg_code, const char *format, ...);
429 bool compare_vk_extension_properties(const VkExtensionProperties *op1, const VkExtensionProperties *op2);
431 VkResult loader_validate_layers(const struct loader_instance *inst, const uint32_t layer_count,
432 const char *const *ppEnabledLayerNames, const struct loader_layer_list *list);
434 VkResult loader_validate_instance_extensions(const struct loader_instance *inst, const struct loader_extension_list *icd_exts,
435 const struct loader_layer_list *instance_layer,
436 const VkInstanceCreateInfo *pCreateInfo);
438 void loader_initialize(void);
439 VkResult loader_copy_layer_properties(const struct loader_instance *inst, struct loader_layer_properties *dst,
440 struct loader_layer_properties *src);
441 bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop, const uint32_t count,
442 const VkExtensionProperties *ext_array);
443 bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop, const struct loader_extension_list *ext_list);
445 VkResult loader_add_to_ext_list(const struct loader_instance *inst, struct loader_extension_list *ext_list,
446 uint32_t prop_list_count, const VkExtensionProperties *props);
447 VkResult loader_add_to_dev_ext_list(const struct loader_instance *inst, struct loader_device_extension_list *ext_list,
448 const VkExtensionProperties *props, uint32_t entry_count, char **entrys);
449 VkResult loader_add_device_extensions(const struct loader_instance *inst,
450 PFN_vkEnumerateDeviceExtensionProperties fpEnumerateDeviceExtensionProperties,
451 VkPhysicalDevice physical_device, const char *lib_name,
452 struct loader_extension_list *ext_list);
453 VkResult loader_init_generic_list(const struct loader_instance *inst, struct loader_generic_list *list_info, size_t element_size);
454 void loader_destroy_generic_list(const struct loader_instance *inst, struct loader_generic_list *list);
455 void loader_destroy_layer_list(const struct loader_instance *inst, struct loader_device *device,
456 struct loader_layer_list *layer_list);
457 void loader_delete_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_list);
458 bool loader_find_layer_name_array(const char *name, uint32_t layer_count, const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]);
459 VkResult loader_add_to_layer_list(const struct loader_instance *inst, struct loader_layer_list *list, uint32_t prop_list_count,
460 const struct loader_layer_properties *props);
461 void loader_find_layer_name_add_list(const struct loader_instance *inst, const char *name, const enum layer_type_flags type_flags,
462 const struct loader_layer_list *source_list, struct loader_layer_list *target_list,
463 struct loader_layer_list *expanded_target_list);
464 void loader_scanned_icd_clear(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list);
465 VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list);
466 void loader_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers);
467 void loader_implicit_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers);
468 bool loader_is_implicit_layer_enabled(const struct loader_instance *inst, const struct loader_layer_properties *prop);
469 VkResult loader_get_icd_loader_instance_extensions(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list,
470 struct loader_extension_list *inst_exts);
471 struct loader_icd_term *loader_get_icd_and_device(const VkDevice device, struct loader_device **found_dev, uint32_t *icd_index);
472 void loader_init_dispatch_dev_ext(struct loader_instance *inst, struct loader_device *dev);
473 void *loader_dev_ext_gpa(struct loader_instance *inst, const char *funcName);
474 void *loader_get_dev_ext_trampoline(uint32_t index);
475 bool loader_phys_dev_ext_gpa(struct loader_instance *inst, const char *funcName, bool perform_checking, void **tramp_addr,
477 void *loader_get_phys_dev_ext_tramp(uint32_t index);
478 void *loader_get_phys_dev_ext_termin(uint32_t index);
479 struct loader_instance *loader_get_instance(const VkInstance instance);
480 void loader_deactivate_layers(const struct loader_instance *instance, struct loader_device *device, struct loader_layer_list *list);
481 struct loader_device *loader_create_logical_device(const struct loader_instance *inst, const VkAllocationCallbacks *pAllocator);
482 void loader_add_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term,
483 struct loader_device *found_dev);
484 void loader_remove_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term,
485 struct loader_device *found_dev, const VkAllocationCallbacks *pAllocator);
486 // NOTE: Outside of loader, this entry-point is only provided for error
488 void loader_destroy_logical_device(const struct loader_instance *inst, struct loader_device *dev,
489 const VkAllocationCallbacks *pAllocator);
491 VkResult loader_enable_instance_layers(struct loader_instance *inst, const VkInstanceCreateInfo *pCreateInfo,
492 const struct loader_layer_list *instance_layers);
494 VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
495 struct loader_instance *inst, VkInstance *created_instance);
497 void loader_activate_instance_layer_extensions(struct loader_instance *inst, VkInstance created_inst);
499 VkResult loader_create_device_chain(const struct loader_physical_device_tramp *pd, const VkDeviceCreateInfo *pCreateInfo,
500 const VkAllocationCallbacks *pAllocator, const struct loader_instance *inst,
501 struct loader_device *dev);
503 VkResult loader_validate_device_extensions(struct loader_physical_device_tramp *phys_dev,
504 const struct loader_layer_list *activated_device_layers,
505 const struct loader_extension_list *icd_exts, const VkDeviceCreateInfo *pCreateInfo);
507 VkResult setupLoaderTrampPhysDevs(VkInstance instance);
508 VkResult setupLoaderTermPhysDevs(struct loader_instance *inst);
510 VkStringErrorFlags vk_string_validate(const int max_length, const char *char_array);