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