1 /*
2  *
3  * Copyright (c) 2014-2016 The Khronos Group Inc.
4  * Copyright (c) 2014-2016 Valve Corporation
5  * Copyright (c) 2014-2016 LunarG, Inc.
6  * Copyright (C) 2015 Google Inc.
7  *
8  * Permission is hereby granted, free of charge, to any person obtaining a copy
9  * of this software and/or associated documentation files (the "Materials"), to
10  * deal in the Materials without restriction, including without limitation the
11  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
12  * sell copies of the Materials, and to permit persons to whom the Materials are
13  * furnished to do so, subject to the following conditions:
14  *
15  * The above copyright notice(s) and this permission notice shall be included in
16  * all copies or substantial portions of the Materials.
17  *
18  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21  *
22  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
23  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
24  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
25  * USE OR OTHER DEALINGS IN THE MATERIALS.
26  *
27  * Author: Jon Ashburn <jon@lunarg.com>
28  * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
29  * Author: Chia-I Wu <olvaffe@gmail.com>
30  * Author: Chia-I Wu <olv@lunarg.com>
31  * Author: Mark Lobodzinski <mark@LunarG.com>
32  *
33  */
34 
35 #ifndef LOADER_H
36 #define LOADER_H
37 
38 #include <vulkan/vulkan.h>
39 #include "vk_loader_platform.h"
40 
41 #include <vulkan/vk_layer.h>
42 #include <vulkan/vk_icd.h>
43 #include <assert.h>
44 
45 #if defined(__GNUC__) && __GNUC__ >= 4
46 #define LOADER_EXPORT __attribute__((visibility("default")))
47 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
48 #define LOADER_EXPORT __attribute__((visibility("default")))
49 #else
50 #define LOADER_EXPORT
51 #endif
52 
53 #define MAX_STRING_SIZE 1024
54 #define VK_MAJOR(version) (version >> 22)
55 #define VK_MINOR(version) ((version >> 12) & 0x3ff)
56 #define VK_PATCH(version) (version & 0xfff)
57 
58 enum layer_type {
59     VK_LAYER_TYPE_DEVICE_EXPLICIT = 0x1,
60     VK_LAYER_TYPE_INSTANCE_EXPLICIT = 0x2,
61     VK_LAYER_TYPE_GLOBAL_EXPLICIT = 0x3, // instance and device layer, bitwise
62     VK_LAYER_TYPE_DEVICE_IMPLICIT = 0x4,
63     VK_LAYER_TYPE_INSTANCE_IMPLICIT = 0x8,
64     VK_LAYER_TYPE_GLOBAL_IMPLICIT = 0xc, // instance and device layer, bitwise
65     VK_LAYER_TYPE_META_EXPLICT = 0x10,
66 };
67 
68 typedef enum VkStringErrorFlagBits {
69     VK_STRING_ERROR_NONE = 0x00000000,
70     VK_STRING_ERROR_LENGTH = 0x00000001,
71     VK_STRING_ERROR_BAD_DATA = 0x00000002,
72 } VkStringErrorFlagBits;
73 typedef VkFlags VkStringErrorFlags;
74 
75 static const int MaxLoaderStringLength = 256;
76 static const char UTF8_ONE_BYTE_CODE = 0xC0;
77 static const char UTF8_ONE_BYTE_MASK = 0xE0;
78 static const char UTF8_TWO_BYTE_CODE = 0xE0;
79 static const char UTF8_TWO_BYTE_MASK = 0xF0;
80 static const char UTF8_THREE_BYTE_CODE = 0xF0;
81 static const char UTF8_THREE_BYTE_MASK = 0xF8;
82 static const char UTF8_DATA_BYTE_CODE = 0x80;
83 static const char UTF8_DATA_BYTE_MASK = 0xC0;
84 
85 static const char std_validation_names[8][VK_MAX_EXTENSION_NAME_SIZE] = {
86     "VK_LAYER_GOOGLE_threading",     "VK_LAYER_LUNARG_parameter_validation",
87     "VK_LAYER_LUNARG_device_limits", "VK_LAYER_LUNARG_object_tracker",
88     "VK_LAYER_LUNARG_image",         "VK_LAYER_LUNARG_core_validation",
89     "VK_LAYER_LUNARG_swapchain",     "VK_LAYER_GOOGLE_unique_objects"};
90 
91 // form of all dynamic lists/arrays
92 // only the list element should be changed
93 struct loader_generic_list {
94     size_t capacity;
95     uint32_t count;
96     void *list;
97 };
98 
99 struct loader_extension_list {
100     size_t capacity;
101     uint32_t count;
102     VkExtensionProperties *list;
103 };
104 
105 struct loader_dev_ext_props {
106     VkExtensionProperties props;
107     uint32_t entrypoint_count;
108     char **entrypoints;
109 };
110 
111 struct loader_device_extension_list {
112     size_t capacity;
113     uint32_t count;
114     struct loader_dev_ext_props *list;
115 };
116 
117 struct loader_name_value {
118     char name[MAX_STRING_SIZE];
119     char value[MAX_STRING_SIZE];
120 };
121 
122 struct loader_lib_info {
123     char lib_name[MAX_STRING_SIZE];
124     uint32_t ref_count;
125     loader_platform_dl_handle lib_handle;
126 };
127 
128 struct loader_layer_functions {
129     char str_gipa[MAX_STRING_SIZE];
130     char str_gdpa[MAX_STRING_SIZE];
131     PFN_vkGetInstanceProcAddr get_instance_proc_addr;
132     PFN_vkGetDeviceProcAddr get_device_proc_addr;
133 };
134 
135 struct loader_layer_properties {
136     VkLayerProperties info;
137     enum layer_type type;
138     char lib_name[MAX_STRING_SIZE];
139     struct loader_layer_functions functions;
140     struct loader_extension_list instance_extension_list;
141     struct loader_device_extension_list device_extension_list;
142     struct loader_name_value disable_env_var;
143     struct loader_name_value enable_env_var;
144 };
145 
146 struct loader_layer_list {
147     size_t capacity;
148     uint32_t count;
149     struct loader_layer_properties *list;
150 };
151 
152 struct loader_layer_library_list {
153     size_t capacity;
154     uint32_t count;
155     struct loader_lib_info *list;
156 };
157 
158 struct loader_dispatch_hash_list {
159     size_t capacity;
160     uint32_t count;
161     uint32_t *index; // index into the dev_ext dispatch table
162 };
163 
164 #define MAX_NUM_DEV_EXTS 250
165 // loader_dispatch_hash_entry and loader_dev_ext_dispatch_table.DevExt have one
166 // to one
167 // correspondence; one loader_dispatch_hash_entry for one DevExt dispatch entry.
168 // Also have a one to one correspondence with functions in dev_ext_trampoline.c
169 struct loader_dispatch_hash_entry {
170     char *func_name;
171     struct loader_dispatch_hash_list list; // to handle hashing collisions
172 };
173 
174 typedef void(VKAPI_PTR *PFN_vkDevExt)(VkDevice device);
175 struct loader_dev_ext_dispatch_table {
176     PFN_vkDevExt DevExt[MAX_NUM_DEV_EXTS];
177 };
178 
179 struct loader_dev_dispatch_table {
180     VkLayerDispatchTable core_dispatch;
181     struct loader_dev_ext_dispatch_table ext_dispatch;
182 };
183 
184 /* per CreateDevice structure */
185 struct loader_device {
186     struct loader_dev_dispatch_table loader_dispatch;
187     VkDevice device; // device object from the icd
188 
189     uint32_t app_extension_count;
190     VkExtensionProperties *app_extension_props;
191 
192     struct loader_layer_list activated_layer_list;
193 
194     struct loader_device *next;
195 };
196 
197 /* per ICD structure */
198 struct loader_icd {
199     // pointers to find other structs
200     const struct loader_scanned_icds *this_icd_lib;
201     const struct loader_instance *this_instance;
202     VkPhysicalDevice *phys_devs;  // physicalDevice object from icd
203     struct loader_device *logical_device_list;
204     VkInstance instance; // instance object from the icd
205     PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
206     PFN_vkDestroyInstance DestroyInstance;
207     PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
208     PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
209     PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
210     PFN_vkGetPhysicalDeviceImageFormatProperties
211         GetPhysicalDeviceImageFormatProperties;
212     PFN_vkCreateDevice CreateDevice;
213     PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
214     PFN_vkGetPhysicalDeviceQueueFamilyProperties
215         GetPhysicalDeviceQueueFamilyProperties;
216     PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
217     PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
218     PFN_vkGetPhysicalDeviceSparseImageFormatProperties
219         GetPhysicalDeviceSparseImageFormatProperties;
220     PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT;
221     PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT;
222     PFN_vkDebugReportMessageEXT DebugReportMessageEXT;
223     PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
224     PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR
225         GetPhysicalDeviceSurfaceCapabilitiesKHR;
226     PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
227     PFN_vkGetPhysicalDeviceSurfacePresentModesKHR
228         GetPhysicalDeviceSurfacePresentModesKHR;
229 #ifdef VK_USE_PLATFORM_WIN32_KHR
230     PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR
231         GetPhysicalDeviceWin32PresentationSupportKHR;
232 #endif
233 #ifdef VK_USE_PLATFORM_MIR_KHR
234     PFN_vkGetPhysicalDeviceMirPresentationSupportKHR
235         GetPhysicalDeviceMirPresentvationSupportKHR;
236 #endif
237 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
238     PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR
239         GetPhysicalDeviceWaylandPresentationSupportKHR;
240 #endif
241 #ifdef VK_USE_PLATFORM_XCB_KHR
242     PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR
243         GetPhysicalDeviceXcbPresentationSupportKHR;
244 #endif
245 #ifdef VK_USE_PLATFORM_XLIB_KHR
246     PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR
247         GetPhysicalDeviceXlibPresentationSupportKHR;
248 #endif
249     PFN_vkGetPhysicalDeviceDisplayPropertiesKHR
250         GetPhysicalDeviceDisplayPropertiesKHR;
251     PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR
252         GetPhysicalDeviceDisplayPlanePropertiesKHR;
253     PFN_vkGetDisplayPlaneSupportedDisplaysKHR
254         GetDisplayPlaneSupportedDisplaysKHR;
255     PFN_vkGetDisplayModePropertiesKHR
256         GetDisplayModePropertiesKHR;
257     PFN_vkCreateDisplayModeKHR
258         CreateDisplayModeKHR;
259     PFN_vkGetDisplayPlaneCapabilitiesKHR
260         GetDisplayPlaneCapabilitiesKHR;
261     PFN_vkCreateDisplayPlaneSurfaceKHR
262         CreateDisplayPlaneSurfaceKHR;
263     struct loader_icd *next;
264 };
265 
266 /* per ICD library structure */
267 struct loader_icd_libs {
268     size_t capacity;
269     uint32_t count;
270     struct loader_scanned_icds *list;
271 };
272 
273 /* per instance structure */
274 struct loader_instance {
275     VkLayerInstanceDispatchTable *disp; // must be first entry in structure
276 
277     uint32_t total_gpu_count; // count of the next two arrays
278     struct loader_physical_device *phys_devs_term;
279     struct loader_physical_device *phys_devs; // tramp wrapped physDev obj list
280     uint32_t total_icd_count;
281     struct loader_icd *icds;
282     struct loader_instance *next;
283     struct loader_extension_list ext_list; // icds and loaders extensions
284     struct loader_icd_libs icd_libs;
285     struct loader_layer_list instance_layer_list;
286     struct loader_layer_list device_layer_list;
287     struct loader_dispatch_hash_entry disp_hash[MAX_NUM_DEV_EXTS];
288 
289     struct loader_msg_callback_map_entry *icd_msg_callback_map;
290 
291     struct loader_layer_list activated_layer_list;
292 
293     VkInstance instance;  // layers/ICD instance returned to trampoline
294 
295     bool debug_report_enabled;
296     VkLayerDbgFunctionNode *DbgFunctionHead;
297 
298     VkAllocationCallbacks alloc_callbacks;
299 
300     bool wsi_surface_enabled;
301 #ifdef VK_USE_PLATFORM_WIN32_KHR
302     bool wsi_win32_surface_enabled;
303 #endif
304 #ifdef VK_USE_PLATFORM_MIR_KHR
305     bool wsi_mir_surface_enabled;
306 #endif
307 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
308     bool wsi_wayland_surface_enabled;
309 #endif
310 #ifdef VK_USE_PLATFORM_XCB_KHR
311     bool wsi_xcb_surface_enabled;
312 #endif
313 #ifdef VK_USE_PLATFORM_XLIB_KHR
314     bool wsi_xlib_surface_enabled;
315 #endif
316 #ifdef VK_USE_PLATFORM_ANDROID_KHR
317     bool wsi_android_surface_enabled;
318 #endif
319     bool wsi_display_enabled;
320 };
321 
322 /* VkPhysicalDevice requires special treatment by loader.  Firstly, terminator
323  * code must be able to get the struct loader_icd  to call into the proper
324  * driver  (multiple ICD/gpu case). This can be accomplished by wrapping the
325  * created VkPhysicalDevice in loader terminate_EnumeratePhysicalDevices().
326  * Secondly, loader must be able to find the instance and icd in trampoline
327  * code.
328  * Thirdly, the loader must be able to handle wrapped by layer VkPhysicalDevice
329  * in trampoline code.  This implies, that the loader trampoline code must also
330  * wrap the VkPhysicalDevice object in trampoline code.  Thus, loader has to
331  * wrap the VkPhysicalDevice created object twice. In trampoline code it can't
332  * rely on the terminator object wrapping since a layer may also wrap. Since
333  * trampoline code wraps the VkPhysicalDevice this means all loader trampoline
334  * code that passes a VkPhysicalDevice should unwrap it. */
335 
336 /* per enumerated PhysicalDevice structure, used to wrap in trampoline code and
337    also same structure used to wrap in terminator code */
338 struct loader_physical_device {
339     VkLayerInstanceDispatchTable *disp; // must be first entry in structure
340     struct loader_icd *this_icd;
341     VkPhysicalDevice phys_dev; // object from ICD/layers/loader terminator
342 };
343 
344 struct loader_struct {
345     struct loader_instance *instances;
346 
347     unsigned int loaded_layer_lib_count;
348     size_t loaded_layer_lib_capacity;
349     struct loader_lib_info *loaded_layer_lib_list;
350     // TODO add ref counting of ICD libraries
351     // TODO use this struct loader_layer_library_list scanned_layer_libraries;
352     // TODO add list of icd libraries for ref counting them for closure
353 };
354 
355 struct loader_scanned_icds {
356     char *lib_name;
357     loader_platform_dl_handle handle;
358     uint32_t api_version;
359     PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
360     PFN_vkCreateInstance CreateInstance;
361     PFN_vkEnumerateInstanceExtensionProperties
362         EnumerateInstanceExtensionProperties;
363 };
364 
loader_instance(VkInstance instance)365 static inline struct loader_instance *loader_instance(VkInstance instance) {
366     return (struct loader_instance *)instance;
367 }
368 
369 static inline VkPhysicalDevice
loader_unwrap_physical_device(VkPhysicalDevice physicalDevice)370 loader_unwrap_physical_device(VkPhysicalDevice physicalDevice) {
371     struct loader_physical_device *phys_dev =
372         (struct loader_physical_device *)physicalDevice;
373     return phys_dev->phys_dev;
374 }
375 
loader_set_dispatch(void * obj,const void * data)376 static inline void loader_set_dispatch(void *obj, const void *data) {
377     *((const void **)obj) = data;
378 }
379 
loader_get_dispatch(const void * obj)380 static inline VkLayerDispatchTable *loader_get_dispatch(const void *obj) {
381     return *((VkLayerDispatchTable **)obj);
382 }
383 
384 static inline struct loader_dev_dispatch_table *
loader_get_dev_dispatch(const void * obj)385 loader_get_dev_dispatch(const void *obj) {
386     return *((struct loader_dev_dispatch_table **)obj);
387 }
388 
389 static inline VkLayerInstanceDispatchTable *
loader_get_instance_dispatch(const void * obj)390 loader_get_instance_dispatch(const void *obj) {
391     return *((VkLayerInstanceDispatchTable **)obj);
392 }
393 
loader_init_dispatch(void * obj,const void * data)394 static inline void loader_init_dispatch(void *obj, const void *data) {
395 #ifdef DEBUG
396     assert(valid_loader_magic_value(obj) &&
397            "Incompatible ICD, first dword must be initialized to "
398            "ICD_LOADER_MAGIC. See loader/README.md for details.");
399 #endif
400 
401     loader_set_dispatch(obj, data);
402 }
403 
404 /* global variables used across files */
405 extern struct loader_struct loader;
406 extern THREAD_LOCAL_DECL struct loader_instance *tls_instance;
407 extern LOADER_PLATFORM_THREAD_ONCE_DEFINITION(once_init);
408 extern loader_platform_thread_mutex loader_lock;
409 extern loader_platform_thread_mutex loader_json_lock;
410 extern const VkLayerInstanceDispatchTable instance_disp;
411 extern const char *std_validation_str;
412 
413 struct loader_msg_callback_map_entry {
414     VkDebugReportCallbackEXT icd_obj;
415     VkDebugReportCallbackEXT loader_obj;
416 };
417 
418 /* helper function definitions */
419 void *loader_heap_alloc(const struct loader_instance *instance, size_t size,
420                         VkSystemAllocationScope allocationScope);
421 
422 void loader_heap_free(const struct loader_instance *instance, void *pMemory);
423 
424 void *loader_tls_heap_alloc(size_t size);
425 
426 void loader_tls_heap_free(void *pMemory);
427 
428 void loader_log(const struct loader_instance *inst, VkFlags msg_type,
429                 int32_t msg_code, const char *format, ...);
430 
431 bool compare_vk_extension_properties(const VkExtensionProperties *op1,
432                                      const VkExtensionProperties *op2);
433 
434 VkResult loader_validate_layers(const struct loader_instance *inst,
435                                 const uint32_t layer_count,
436                                 const char *const *ppEnabledLayerNames,
437                                 const struct loader_layer_list *list);
438 
439 VkResult loader_validate_instance_extensions(
440     const struct loader_instance *inst,
441     const struct loader_extension_list *icd_exts,
442     const struct loader_layer_list *instance_layer,
443     const VkInstanceCreateInfo *pCreateInfo);
444 
445 void loader_initialize(void);
446 bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop,
447                                      const uint32_t count,
448                                      const VkExtensionProperties *ext_array);
449 bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop,
450                                const struct loader_extension_list *ext_list);
451 
452 VkResult loader_add_to_ext_list(const struct loader_instance *inst,
453                                 struct loader_extension_list *ext_list,
454                                 uint32_t prop_list_count,
455                                 const VkExtensionProperties *props);
456 VkResult loader_add_device_extensions(const struct loader_instance *inst,
457                                       struct loader_icd *icd,
458                                       VkPhysicalDevice physical_device,
459                                       const char *lib_name,
460                                       struct loader_extension_list *ext_list);
461 bool loader_init_generic_list(const struct loader_instance *inst,
462                               struct loader_generic_list *list_info,
463                               size_t element_size);
464 void loader_destroy_generic_list(const struct loader_instance *inst,
465                                  struct loader_generic_list *list);
466 void loader_destroy_layer_list(const struct loader_instance *inst,
467                                struct loader_layer_list *layer_list);
468 void loader_delete_layer_properties(const struct loader_instance *inst,
469                                     struct loader_layer_list *layer_list);
470 void loader_expand_layer_names(
471     const struct loader_instance *inst, const char *key_name,
472     uint32_t expand_count,
473     const char expand_names[][VK_MAX_EXTENSION_NAME_SIZE],
474     uint32_t *layer_count, char ***ppp_layer_names);
475 void loader_unexpand_dev_layer_names(const struct loader_instance *inst,
476                                      uint32_t layer_count, char **layer_names,
477                                      char **layer_ptr,
478                                      const VkDeviceCreateInfo *pCreateInfo);
479 void loader_unexpand_inst_layer_names(const struct loader_instance *inst,
480                                       uint32_t layer_count, char **layer_names,
481                                       char **layer_ptr,
482                                       const VkInstanceCreateInfo *pCreateInfo);
483 void loader_add_to_layer_list(const struct loader_instance *inst,
484                               struct loader_layer_list *list,
485                               uint32_t prop_list_count,
486                               const struct loader_layer_properties *props);
487 void loader_scanned_icd_clear(const struct loader_instance *inst,
488                               struct loader_icd_libs *icd_libs);
489 void loader_icd_scan(const struct loader_instance *inst,
490                      struct loader_icd_libs *icds);
491 void loader_layer_scan(const struct loader_instance *inst,
492                        struct loader_layer_list *instance_layers,
493                        struct loader_layer_list *device_layers);
494 void loader_get_icd_loader_instance_extensions(
495     const struct loader_instance *inst, struct loader_icd_libs *icd_libs,
496     struct loader_extension_list *inst_exts);
497 struct loader_icd *loader_get_icd_and_device(const VkDevice device,
498                                              struct loader_device **found_dev);
499 void loader_init_dispatch_dev_ext(struct loader_instance *inst,
500                                   struct loader_device *dev);
501 void *loader_dev_ext_gpa(struct loader_instance *inst, const char *funcName);
502 void *loader_get_dev_ext_trampoline(uint32_t index);
503 struct loader_instance *loader_get_instance(const VkInstance instance);
504 struct loader_device *
505 loader_add_logical_device(const struct loader_instance *inst,
506                           struct loader_device **device_list);
507 void loader_remove_logical_device(const struct loader_instance *inst,
508                                   struct loader_icd *icd,
509                                   struct loader_device *found_dev);
510 VkResult
511 loader_enable_instance_layers(struct loader_instance *inst,
512                               const VkInstanceCreateInfo *pCreateInfo,
513                               const struct loader_layer_list *instance_layers);
514 void loader_deactivate_instance_layers(struct loader_instance *instance);
515 
516 VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo,
517                                       const VkAllocationCallbacks *pAllocator,
518                                       struct loader_instance *inst,
519                                       VkInstance *created_instance);
520 
521 void loader_activate_instance_layer_extensions(struct loader_instance *inst,
522                                                VkInstance created_inst);
523 VkResult
524 loader_enable_device_layers(const struct loader_instance *inst,
525                             struct loader_icd *icd,
526                             struct loader_layer_list *activated_layer_list,
527                             const VkDeviceCreateInfo *pCreateInfo,
528                             const struct loader_layer_list *device_layers);
529 
530 VkResult loader_create_device_chain(const struct loader_physical_device *pd,
531                                     const VkDeviceCreateInfo *pCreateInfo,
532                                     const VkAllocationCallbacks *pAllocator,
533                                     const struct loader_instance *inst,
534                                     struct loader_icd *icd,
535                                     struct loader_device *dev);
536 VkResult loader_validate_device_extensions(
537     struct loader_physical_device *phys_dev,
538     const struct loader_layer_list *activated_device_layers,
539     const struct loader_extension_list *icd_exts,
540     const VkDeviceCreateInfo *pCreateInfo);
541 
542 /* instance layer chain termination entrypoint definitions */
543 VKAPI_ATTR VkResult VKAPI_CALL
544 terminator_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
545                           const VkAllocationCallbacks *pAllocator,
546                           VkInstance *pInstance);
547 
548 VKAPI_ATTR void VKAPI_CALL
549 terminator_DestroyInstance(VkInstance instance,
550                            const VkAllocationCallbacks *pAllocator);
551 
552 VKAPI_ATTR VkResult VKAPI_CALL
553 terminator_EnumeratePhysicalDevices(VkInstance instance,
554                                     uint32_t *pPhysicalDeviceCount,
555                                     VkPhysicalDevice *pPhysicalDevices);
556 
557 VKAPI_ATTR void VKAPI_CALL
558 terminator_GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
559                                      VkPhysicalDeviceFeatures *pFeatures);
560 
561 VKAPI_ATTR void VKAPI_CALL
562 terminator_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
563                                              VkFormat format,
564                                              VkFormatProperties *pFormatInfo);
565 
566 VKAPI_ATTR VkResult VKAPI_CALL
567 terminator_GetPhysicalDeviceImageFormatProperties(
568     VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
569     VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
570     VkImageFormatProperties *pImageFormatProperties);
571 
572 VKAPI_ATTR void VKAPI_CALL
573 terminator_GetPhysicalDeviceSparseImageFormatProperties(
574     VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
575     VkSampleCountFlagBits samples, VkImageUsageFlags usage,
576     VkImageTiling tiling, uint32_t *pNumProperties,
577     VkSparseImageFormatProperties *pProperties);
578 
579 VKAPI_ATTR void VKAPI_CALL
580 terminator_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
581                                        VkPhysicalDeviceProperties *pProperties);
582 
583 VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceExtensionProperties(
584     VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pCount,
585     VkExtensionProperties *pProperties);
586 
587 VKAPI_ATTR VkResult VKAPI_CALL
588 terminator_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
589                                           uint32_t *pCount,
590                                           VkLayerProperties *pProperties);
591 
592 VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties(
593     VkPhysicalDevice physicalDevice, uint32_t *pCount,
594     VkQueueFamilyProperties *pProperties);
595 
596 VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties(
597     VkPhysicalDevice physicalDevice,
598     VkPhysicalDeviceMemoryProperties *pProperties);
599 
600 VKAPI_ATTR VkResult VKAPI_CALL
601 terminator_CreateDevice(VkPhysicalDevice gpu,
602                         const VkDeviceCreateInfo *pCreateInfo,
603                         const VkAllocationCallbacks *pAllocator,
604                         VkDevice *pDevice);
605 
606 VkStringErrorFlags vk_string_validate(const int max_length,
607                                       const char *char_array);
608 
609 #endif /* LOADER_H */
610