Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 1 | /* |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 2 | * |
Mark Young | f2079b9 | 2017-05-02 10:49:46 -0600 | [diff] [blame] | 3 | * Copyright (c) 2014-2017 The Khronos Group Inc. |
| 4 | * Copyright (c) 2014-2017 Valve Corporation |
| 5 | * Copyright (c) 2014-2017 LunarG, Inc. |
Courtney Goeltzenleuchter | f821dad | 2015-12-02 14:53:22 -0700 | [diff] [blame] | 6 | * Copyright (C) 2015 Google Inc. |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 7 | * |
Jon Ashburn | 3ebf125 | 2016-04-19 11:30:31 -0600 | [diff] [blame] | 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 |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 11 | * |
Jon Ashburn | 3ebf125 | 2016-04-19 11:30:31 -0600 | [diff] [blame] | 12 | * http://www.apache.org/licenses/LICENSE-2.0 |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 13 | * |
Jon Ashburn | 3ebf125 | 2016-04-19 11:30:31 -0600 | [diff] [blame] | 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. |
Jon Ashburn | 23d36b1 | 2016-02-02 17:47:28 -0700 | [diff] [blame] | 19 | * |
| 20 | * Author: Jon Ashburn <jon@lunarg.com> |
| 21 | * Author: Courtney Goeltzenleuchter <courtney@LunarG.com> |
Courtney Goeltzenleuchter | 0555952 | 2015-10-30 11:14:30 -0600 | [diff] [blame] | 22 | * Author: Chia-I Wu <olvaffe@gmail.com> |
| 23 | * Author: Chia-I Wu <olv@lunarg.com> |
Jon Ashburn | 23d36b1 | 2016-02-02 17:47:28 -0700 | [diff] [blame] | 24 | * Author: Mark Lobodzinski <mark@LunarG.com> |
Courtney Goeltzenleuchter | 0555952 | 2015-10-30 11:14:30 -0600 | [diff] [blame] | 25 | * |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 26 | */ |
| 27 | |
| 28 | #ifndef LOADER_H |
| 29 | #define LOADER_H |
| 30 | |
David Pinedo | 9316d3b | 2015-11-06 12:54:48 -0700 | [diff] [blame] | 31 | #include <vulkan/vulkan.h> |
Aaron Karp | 848bad4 | 2016-03-13 16:41:59 -0400 | [diff] [blame] | 32 | #include "vk_loader_platform.h" |
Mark Lobodzinski | b87f902 | 2016-05-24 16:04:56 -0600 | [diff] [blame] | 33 | #include "vk_loader_layer.h" |
David Pinedo | 9316d3b | 2015-11-06 12:54:48 -0700 | [diff] [blame] | 34 | #include <vulkan/vk_layer.h> |
| 35 | #include <vulkan/vk_icd.h> |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 36 | #include <assert.h> |
Mark Young | 0f183a8 | 2017-02-28 09:58:04 -0700 | [diff] [blame] | 37 | #include "vk_loader_extensions.h" |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 38 | |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 39 | #if defined(__GNUC__) && __GNUC__ >= 4 |
Jon Ashburn | 23d36b1 | 2016-02-02 17:47:28 -0700 | [diff] [blame] | 40 | #define LOADER_EXPORT __attribute__((visibility("default"))) |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 41 | #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) |
Jon Ashburn | 23d36b1 | 2016-02-02 17:47:28 -0700 | [diff] [blame] | 42 | #define LOADER_EXPORT __attribute__((visibility("default"))) |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 43 | #else |
Jon Ashburn | 23d36b1 | 2016-02-02 17:47:28 -0700 | [diff] [blame] | 44 | #define LOADER_EXPORT |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 45 | #endif |
| 46 | |
Mark Young | 0ad8313 | 2016-06-30 13:02:42 -0600 | [diff] [blame] | 47 | // A debug option to disable allocators at compile time to investigate future issues. |
| 48 | #define DEBUG_DISABLE_APP_ALLOCATORS 0 |
| 49 | |
Jon Ashburn | f73e921 | 2015-08-04 10:22:33 -0600 | [diff] [blame] | 50 | #define MAX_STRING_SIZE 1024 |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 51 | |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 52 | // This is defined in vk_layer.h, but if there's problems we need to create the define |
| 53 | // here. |
| 54 | #ifndef MAX_NUM_UNKNOWN_EXTS |
| 55 | #define MAX_NUM_UNKNOWN_EXTS 250 |
| 56 | #endif |
| 57 | |
Mark Young | f2079b9 | 2017-05-02 10:49:46 -0600 | [diff] [blame] | 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 |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 62 | }; |
| 63 | |
Mark Lobodzinski | e9f09ef | 2016-02-02 18:53:34 -0700 | [diff] [blame] | 64 | typedef enum VkStringErrorFlagBits { |
Jon Ashburn | f2b4e38 | 2016-02-10 20:50:19 -0700 | [diff] [blame] | 65 | VK_STRING_ERROR_NONE = 0x00000000, |
| 66 | VK_STRING_ERROR_LENGTH = 0x00000001, |
| 67 | VK_STRING_ERROR_BAD_DATA = 0x00000002, |
Mark Lobodzinski | e9f09ef | 2016-02-02 18:53:34 -0700 | [diff] [blame] | 68 | } VkStringErrorFlagBits; |
| 69 | typedef VkFlags VkStringErrorFlags; |
| 70 | |
Jon Ashburn | f2b4e38 | 2016-02-10 20:50:19 -0700 | [diff] [blame] | 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; |
Mark Lobodzinski | e9f09ef | 2016-02-02 18:53:34 -0700 | [diff] [blame] | 80 | |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 81 | struct VkStructureHeader { |
| 82 | VkStructureType sType; |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 83 | const void *pNext; |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 84 | }; |
| 85 | |
Jon Ashburn | 6e6a216 | 2015-12-10 08:51:10 -0700 | [diff] [blame] | 86 | // form of all dynamic lists/arrays |
| 87 | // only the list element should be changed |
| 88 | struct loader_generic_list { |
| 89 | size_t capacity; |
| 90 | uint32_t count; |
| 91 | void *list; |
| 92 | }; |
| 93 | |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 94 | struct loader_extension_list { |
| 95 | size_t capacity; |
| 96 | uint32_t count; |
Jon Ashburn | 5c042ea | 2015-08-04 11:14:18 -0600 | [diff] [blame] | 97 | VkExtensionProperties *list; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 98 | }; |
| 99 | |
Jon Ashburn | 39fbd4e | 2015-12-10 18:17:34 -0700 | [diff] [blame] | 100 | struct loader_dev_ext_props { |
| 101 | VkExtensionProperties props; |
| 102 | uint32_t entrypoint_count; |
| 103 | char **entrypoints; |
| 104 | }; |
| 105 | |
| 106 | struct loader_device_extension_list { |
| 107 | size_t capacity; |
| 108 | uint32_t count; |
| 109 | struct loader_dev_ext_props *list; |
| 110 | }; |
| 111 | |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 112 | struct loader_name_value { |
Jon Ashburn | f73e921 | 2015-08-04 10:22:33 -0600 | [diff] [blame] | 113 | char name[MAX_STRING_SIZE]; |
| 114 | char value[MAX_STRING_SIZE]; |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 115 | }; |
| 116 | |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 117 | struct loader_layer_functions { |
Jon Ashburn | f73e921 | 2015-08-04 10:22:33 -0600 | [diff] [blame] | 118 | char str_gipa[MAX_STRING_SIZE]; |
| 119 | char str_gdpa[MAX_STRING_SIZE]; |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 120 | char str_negotiate_interface[MAX_STRING_SIZE]; |
| 121 | PFN_vkNegotiateLoaderLayerInterfaceVersion negotiate_layer_interface; |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 122 | PFN_vkGetInstanceProcAddr get_instance_proc_addr; |
| 123 | PFN_vkGetDeviceProcAddr get_device_proc_addr; |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 124 | PFN_GetPhysicalDeviceProcAddr get_physical_device_proc_addr; |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 125 | }; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 126 | |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 127 | struct loader_layer_properties { |
Courtney Goeltzenleuchter | 110fdf9 | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 128 | VkLayerProperties info; |
Mark Young | f2079b9 | 2017-05-02 10:49:46 -0600 | [diff] [blame] | 129 | enum layer_type_flags type_flags; |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 130 | uint32_t interface_version; // PFN_vkNegotiateLoaderLayerInterfaceVersion |
Jon Ashburn | 3d00233 | 2015-08-20 16:35:30 -0600 | [diff] [blame] | 131 | char lib_name[MAX_STRING_SIZE]; |
Jon Ashburn | 4dc1d8a | 2016-04-20 13:21:17 -0600 | [diff] [blame] | 132 | loader_platform_dl_handle lib_handle; |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 133 | struct loader_layer_functions functions; |
| 134 | struct loader_extension_list instance_extension_list; |
Jon Ashburn | 39fbd4e | 2015-12-10 18:17:34 -0700 | [diff] [blame] | 135 | struct loader_device_extension_list device_extension_list; |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 136 | struct loader_name_value disable_env_var; |
| 137 | struct loader_name_value enable_env_var; |
Mark Young | f2079b9 | 2017-05-02 10:49:46 -0600 | [diff] [blame] | 138 | uint32_t num_component_layers; |
| 139 | char (*component_layer_names)[MAX_STRING_SIZE]; |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 140 | }; |
| 141 | |
| 142 | struct loader_layer_list { |
| 143 | size_t capacity; |
| 144 | uint32_t count; |
| 145 | struct loader_layer_properties *list; |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 146 | }; |
| 147 | |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 148 | struct loader_dispatch_hash_list { |
| 149 | size_t capacity; |
| 150 | uint32_t count; |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 151 | uint32_t *index; // index into the dev_ext dispatch table |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 152 | }; |
| 153 | |
Mark Young | 8191d9f | 2016-09-02 11:41:28 -0600 | [diff] [blame] | 154 | // loader_dispatch_hash_entry and loader_dev_ext_dispatch_table.dev_ext have |
| 155 | // one to one correspondence; one loader_dispatch_hash_entry for one dev_ext |
| 156 | // dispatch entry. |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 157 | // Also have a one to one correspondence with functions in dev_ext_trampoline.c |
| 158 | struct loader_dispatch_hash_entry { |
| 159 | char *func_name; |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 160 | struct loader_dispatch_hash_list list; // to handle hashing collisions |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 161 | }; |
| 162 | |
Jon Ashburn | 23d36b1 | 2016-02-02 17:47:28 -0700 | [diff] [blame] | 163 | typedef void(VKAPI_PTR *PFN_vkDevExt)(VkDevice device); |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 164 | struct loader_dev_ext_dispatch_table { |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 165 | PFN_vkDevExt dev_ext[MAX_NUM_UNKNOWN_EXTS]; |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 166 | }; |
| 167 | |
| 168 | struct loader_dev_dispatch_table { |
| 169 | VkLayerDispatchTable core_dispatch; |
| 170 | struct loader_dev_ext_dispatch_table ext_dispatch; |
| 171 | }; |
| 172 | |
Mark Young | 35159af | 2016-09-07 08:50:32 -0600 | [diff] [blame] | 173 | // per CreateDevice structure |
Jon Ashburn | dc6fcad | 2015-06-10 10:06:06 -0600 | [diff] [blame] | 174 | struct loader_device { |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 175 | struct loader_dev_dispatch_table loader_dispatch; |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 176 | VkDevice chain_device; // device object from the dispatch chain |
| 177 | VkDevice icd_device; // device object from the icd |
Mark Young | 65cb366 | 2016-11-07 13:27:02 -0700 | [diff] [blame] | 178 | struct loader_physical_device_term *phys_dev_term; |
Jon Ashburn | dc6fcad | 2015-06-10 10:06:06 -0600 | [diff] [blame] | 179 | |
Mark Young | 283fe1c | 2017-05-04 12:16:35 -0600 | [diff] [blame] | 180 | // List of activated layers. |
| 181 | // app_ is the version based on exactly what the application asked for. |
| 182 | // This is what must be returned to the application on Enumerate calls. |
| 183 | // expanded_ is the version based on expanding meta-layers into their |
| 184 | // individual component layers. This is what is used internally. |
| 185 | struct loader_layer_list app_activated_layer_list; |
| 186 | struct loader_layer_list expanded_activated_layer_list; |
Jon Ashburn | dc6fcad | 2015-06-10 10:06:06 -0600 | [diff] [blame] | 187 | |
Mark Young | 0ad8313 | 2016-06-30 13:02:42 -0600 | [diff] [blame] | 188 | VkAllocationCallbacks alloc_callbacks; |
| 189 | |
Jon Ashburn | dc6fcad | 2015-06-10 10:06:06 -0600 | [diff] [blame] | 190 | struct loader_device *next; |
| 191 | }; |
| 192 | |
Mark Young | 0f183a8 | 2017-02-28 09:58:04 -0700 | [diff] [blame] | 193 | // Per ICD information |
| 194 | |
| 195 | // Per ICD structure |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 196 | struct loader_icd_term { |
Jon Ashburn | 3d00233 | 2015-08-20 16:35:30 -0600 | [diff] [blame] | 197 | // pointers to find other structs |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 198 | const struct loader_scanned_icd *scanned_icd; |
Jon Ashburn | 3d00233 | 2015-08-20 16:35:30 -0600 | [diff] [blame] | 199 | const struct loader_instance *this_instance; |
Jon Ashburn | dc6fcad | 2015-06-10 10:06:06 -0600 | [diff] [blame] | 200 | struct loader_device *logical_device_list; |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 201 | VkInstance instance; // instance object from the icd |
Mark Young | 0f183a8 | 2017-02-28 09:58:04 -0700 | [diff] [blame] | 202 | struct loader_icd_term_dispatch dispatch; |
Mark Young | fa55278 | 2016-12-12 16:14:55 -0700 | [diff] [blame] | 203 | |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 204 | struct loader_icd_term *next; |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 205 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 206 | PFN_PhysDevExt phys_dev_ext[MAX_NUM_UNKNOWN_EXTS]; |
Jon Ashburn | 95a77ba | 2015-05-15 15:09:35 -0600 | [diff] [blame] | 207 | }; |
| 208 | |
Mark Young | 0f183a8 | 2017-02-28 09:58:04 -0700 | [diff] [blame] | 209 | // Per ICD library structure |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 210 | struct loader_icd_tramp_list { |
Jon Ashburn | 8810c5f | 2015-08-18 18:04:47 -0600 | [diff] [blame] | 211 | size_t capacity; |
| 212 | uint32_t count; |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 213 | struct loader_scanned_icd *scanned_list; |
Jon Ashburn | 8810c5f | 2015-08-18 18:04:47 -0600 | [diff] [blame] | 214 | }; |
| 215 | |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 216 | struct loader_instance_dispatch_table { |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 217 | VkLayerInstanceDispatchTable layer_inst_disp; // must be first entry in structure |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 218 | |
| 219 | // Physical device functions unknown to the loader |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 220 | PFN_PhysDevExt phys_dev_ext[MAX_NUM_UNKNOWN_EXTS]; |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 221 | }; |
| 222 | |
Mark Young | 0f183a8 | 2017-02-28 09:58:04 -0700 | [diff] [blame] | 223 | // Per instance structure |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 224 | struct loader_instance { |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 225 | struct loader_instance_dispatch_table *disp; // must be first entry in structure |
Jon Ashburn | 95a77ba | 2015-05-15 15:09:35 -0600 | [diff] [blame] | 226 | |
Mark Young | d66edd5 | 2017-03-10 17:31:18 -0700 | [diff] [blame] | 227 | // We need to manually track physical devices over time. If the user |
| 228 | // re-queries the information, we don't want to delete old data or |
| 229 | // create new data unless necessary. |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 230 | uint32_t total_gpu_count; |
Lenny Komow | 8a1f8a5 | 2016-12-20 15:35:11 -0700 | [diff] [blame] | 231 | uint32_t phys_dev_count_term; |
| 232 | struct loader_physical_device_term **phys_devs_term; |
Lenny Komow | b9f70c3 | 2016-12-19 17:11:40 -0700 | [diff] [blame] | 233 | uint32_t phys_dev_count_tramp; |
| 234 | struct loader_physical_device_tramp **phys_devs_tramp; |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 235 | |
Mark Young | d66edd5 | 2017-03-10 17:31:18 -0700 | [diff] [blame] | 236 | // We also need to manually track physical device groups, but we don't need |
| 237 | // loader specific structures since we have that content in the physical |
| 238 | // device stored internal to the public structures. |
| 239 | uint32_t phys_dev_group_count_term; |
| 240 | struct VkPhysicalDeviceGroupPropertiesKHX **phys_dev_groups_term; |
| 241 | uint32_t phys_dev_group_count_tramp; |
| 242 | struct VkPhysicalDeviceGroupPropertiesKHX **phys_dev_groups_tramp; |
| 243 | |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 244 | struct loader_instance *next; |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 245 | |
| 246 | uint32_t total_icd_count; |
| 247 | struct loader_icd_term *icd_terms; |
| 248 | struct loader_icd_tramp_list icd_tramp_list; |
| 249 | |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 250 | struct loader_dispatch_hash_entry dev_ext_disp_hash[MAX_NUM_UNKNOWN_EXTS]; |
| 251 | struct loader_dispatch_hash_entry phys_dev_ext_disp_hash[MAX_NUM_UNKNOWN_EXTS]; |
Jon Ashburn | 3d00233 | 2015-08-20 16:35:30 -0600 | [diff] [blame] | 252 | |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 253 | struct loader_msg_callback_map_entry *icd_msg_callback_map; |
| 254 | |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 255 | struct loader_layer_list instance_layer_list; |
Mark Young | 283fe1c | 2017-05-04 12:16:35 -0600 | [diff] [blame] | 256 | |
| 257 | // List of activated layers. |
| 258 | // app_ is the version based on exactly what the application asked for. |
| 259 | // This is what must be returned to the application on Enumerate calls. |
| 260 | // expanded_ is the version based on expanding meta-layers into their |
| 261 | // individual component layers. This is what is used internally. |
| 262 | struct loader_layer_list app_activated_layer_list; |
| 263 | struct loader_layer_list expanded_activated_layer_list; |
| 264 | |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 265 | VkInstance instance; // layers/ICD instance returned to trampoline |
Courtney Goeltzenleuchter | 00150eb | 2016-01-08 12:18:43 -0700 | [diff] [blame] | 266 | |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 267 | struct loader_extension_list ext_list; // icds and loaders extensions |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 268 | union loader_instance_extension_enables enabled_known_extensions; |
| 269 | |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 270 | VkLayerDbgFunctionNode *DbgFunctionHead; |
Ian Elliott | ad6300f | 2016-03-31 10:48:19 -0600 | [diff] [blame] | 271 | uint32_t num_tmp_callbacks; |
| 272 | VkDebugReportCallbackCreateInfoEXT *tmp_dbg_create_infos; |
| 273 | VkDebugReportCallbackEXT *tmp_callbacks; |
Courtney Goeltzenleuchter | 7f5aafc | 2015-07-05 11:28:29 -0600 | [diff] [blame] | 274 | |
Chia-I Wu | 3432a0c | 2015-10-27 18:04:07 +0800 | [diff] [blame] | 275 | VkAllocationCallbacks alloc_callbacks; |
Ian Elliott | d3ef02f | 2015-07-06 14:36:13 -0600 | [diff] [blame] | 276 | |
Ian Elliott | 954fa34 | 2015-10-30 15:28:23 -0600 | [diff] [blame] | 277 | bool wsi_surface_enabled; |
Mark Lobodzinski | a8a5f85 | 2015-12-10 16:25:21 -0700 | [diff] [blame] | 278 | #ifdef VK_USE_PLATFORM_WIN32_KHR |
Ian Elliott | 954fa34 | 2015-10-30 15:28:23 -0600 | [diff] [blame] | 279 | bool wsi_win32_surface_enabled; |
Mark Lobodzinski | a8a5f85 | 2015-12-10 16:25:21 -0700 | [diff] [blame] | 280 | #endif |
| 281 | #ifdef VK_USE_PLATFORM_MIR_KHR |
Ian Elliott | 954fa34 | 2015-10-30 15:28:23 -0600 | [diff] [blame] | 282 | bool wsi_mir_surface_enabled; |
Mark Lobodzinski | a8a5f85 | 2015-12-10 16:25:21 -0700 | [diff] [blame] | 283 | #endif |
| 284 | #ifdef VK_USE_PLATFORM_WAYLAND_KHR |
Ian Elliott | 954fa34 | 2015-10-30 15:28:23 -0600 | [diff] [blame] | 285 | bool wsi_wayland_surface_enabled; |
Mark Lobodzinski | a8a5f85 | 2015-12-10 16:25:21 -0700 | [diff] [blame] | 286 | #endif |
| 287 | #ifdef VK_USE_PLATFORM_XCB_KHR |
Ian Elliott | 954fa34 | 2015-10-30 15:28:23 -0600 | [diff] [blame] | 288 | bool wsi_xcb_surface_enabled; |
Mark Lobodzinski | a8a5f85 | 2015-12-10 16:25:21 -0700 | [diff] [blame] | 289 | #endif |
| 290 | #ifdef VK_USE_PLATFORM_XLIB_KHR |
Ian Elliott | 954fa34 | 2015-10-30 15:28:23 -0600 | [diff] [blame] | 291 | bool wsi_xlib_surface_enabled; |
Mark Lobodzinski | a8a5f85 | 2015-12-10 16:25:21 -0700 | [diff] [blame] | 292 | #endif |
| 293 | #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| 294 | bool wsi_android_surface_enabled; |
| 295 | #endif |
Jon Ashburn | c7d3e73 | 2016-03-08 09:30:30 -0700 | [diff] [blame] | 296 | bool wsi_display_enabled; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 297 | }; |
| 298 | |
Mark Young | 0f183a8 | 2017-02-28 09:58:04 -0700 | [diff] [blame] | 299 | // VkPhysicalDevice requires special treatment by loader. Firstly, terminator |
| 300 | // code must be able to get the struct loader_icd_term to call into the proper |
| 301 | // driver (multiple ICD/gpu case). This can be accomplished by wrapping the |
| 302 | // created VkPhysicalDevice in loader terminate_EnumeratePhysicalDevices(). |
| 303 | // Secondly, the loader must be able to handle wrapped by layer VkPhysicalDevice |
| 304 | // in trampoline code. This implies, that the loader trampoline code must also |
| 305 | // wrap the VkPhysicalDevice object in trampoline code. Thus, loader has to |
| 306 | // wrap the VkPhysicalDevice created object twice. In trampoline code it can't |
| 307 | // rely on the terminator object wrapping since a layer may also wrap. Since |
| 308 | // trampoline code wraps the VkPhysicalDevice this means all loader trampoline |
| 309 | // code that passes a VkPhysicalDevice should unwrap it. |
Jon Ashburn | 014438f | 2016-03-01 19:51:07 -0700 | [diff] [blame] | 310 | |
Mark Young | 0f183a8 | 2017-02-28 09:58:04 -0700 | [diff] [blame] | 311 | // Per enumerated PhysicalDevice structure, used to wrap in trampoline code and |
| 312 | // also same structure used to wrap in terminator code |
Jon Ashburn | 787eb25 | 2016-03-24 15:49:57 -0600 | [diff] [blame] | 313 | struct loader_physical_device_tramp { |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 314 | struct loader_instance_dispatch_table *disp; // must be first entry in structure |
Piers Daniell | 295fe40 | 2016-03-29 11:51:11 -0600 | [diff] [blame] | 315 | struct loader_instance *this_instance; |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 316 | VkPhysicalDevice phys_dev; // object from layers/loader terminator |
Jon Ashburn | 787eb25 | 2016-03-24 15:49:57 -0600 | [diff] [blame] | 317 | }; |
| 318 | |
Mark Young | 0f183a8 | 2017-02-28 09:58:04 -0700 | [diff] [blame] | 319 | // Per enumerated PhysicalDevice structure, used to wrap in terminator code |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 320 | struct loader_physical_device_term { |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 321 | struct loader_instance_dispatch_table *disp; // must be first entry in structure |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 322 | struct loader_icd_term *this_icd_term; |
Mark Young | 16573c7 | 2016-06-28 10:52:43 -0600 | [diff] [blame] | 323 | uint8_t icd_index; |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 324 | VkPhysicalDevice phys_dev; // object from ICD |
Jon Ashburn | 24cd4be | 2015-11-01 14:04:06 -0700 | [diff] [blame] | 325 | }; |
| 326 | |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 327 | struct loader_struct { |
| 328 | struct loader_instance *instances; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 329 | }; |
| 330 | |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 331 | struct loader_scanned_icd { |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 332 | char *lib_name; |
| 333 | loader_platform_dl_handle handle; |
Jon Ashburn | 005617f | 2015-11-17 17:35:40 -0700 | [diff] [blame] | 334 | uint32_t api_version; |
Jon Ashburn | 17b4c86 | 2016-04-25 11:09:37 -0600 | [diff] [blame] | 335 | uint32_t interface_version; |
Jon Ashburn | c624c88 | 2015-07-16 10:17:29 -0600 | [diff] [blame] | 336 | PFN_vkGetInstanceProcAddr GetInstanceProcAddr; |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 337 | PFN_GetPhysicalDeviceProcAddr GetPhysicalDeviceProcAddr; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 338 | PFN_vkCreateInstance CreateInstance; |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 339 | PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties; |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 340 | }; |
| 341 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 342 | static inline struct loader_instance *loader_instance(VkInstance instance) { return (struct loader_instance *)instance; } |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 343 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 344 | static inline VkPhysicalDevice loader_unwrap_physical_device(VkPhysicalDevice physicalDevice) { |
| 345 | struct loader_physical_device_tramp *phys_dev = (struct loader_physical_device_tramp *)physicalDevice; |
Jon Ashburn | 014438f | 2016-03-01 19:51:07 -0700 | [diff] [blame] | 346 | return phys_dev->phys_dev; |
| 347 | } |
| 348 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 349 | static inline void loader_set_dispatch(void *obj, const void *data) { *((const void **)obj) = data; } |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 350 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 351 | static inline VkLayerDispatchTable *loader_get_dispatch(const void *obj) { return *((VkLayerDispatchTable **)obj); } |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 352 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 353 | static inline struct loader_dev_dispatch_table *loader_get_dev_dispatch(const void *obj) { |
Jon Ashburn | 23d36b1 | 2016-02-02 17:47:28 -0700 | [diff] [blame] | 354 | return *((struct loader_dev_dispatch_table **)obj); |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 355 | } |
| 356 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 357 | static inline VkLayerInstanceDispatchTable *loader_get_instance_layer_dispatch(const void *obj) { |
Jon Ashburn | 23d36b1 | 2016-02-02 17:47:28 -0700 | [diff] [blame] | 358 | return *((VkLayerInstanceDispatchTable **)obj); |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 359 | } |
| 360 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 361 | static inline struct loader_instance_dispatch_table *loader_get_instance_dispatch(const void *obj) { |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 362 | return *((struct loader_instance_dispatch_table **)obj); |
| 363 | } |
| 364 | |
Jon Ashburn | 23d36b1 | 2016-02-02 17:47:28 -0700 | [diff] [blame] | 365 | static inline void loader_init_dispatch(void *obj, const void *data) { |
Jon Ashburn | 4006664 | 2015-04-15 13:34:33 -0600 | [diff] [blame] | 366 | #ifdef DEBUG |
Mark Lobodzinski | 64318ba | 2017-01-26 13:34:13 -0700 | [diff] [blame] | 367 | assert(valid_loader_magic_value(obj) && |
| 368 | "Incompatible ICD, first dword must be initialized to " |
| 369 | "ICD_LOADER_MAGIC. See loader/README.md for details."); |
Jon Ashburn | 4006664 | 2015-04-15 13:34:33 -0600 | [diff] [blame] | 370 | #endif |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 371 | |
Jon Ashburn | 1ed042c | 2015-05-01 18:00:33 -0600 | [diff] [blame] | 372 | loader_set_dispatch(obj, data); |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 373 | } |
| 374 | |
Mark Young | 0f183a8 | 2017-02-28 09:58:04 -0700 | [diff] [blame] | 375 | // Global variables used across files |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 376 | extern struct loader_struct loader; |
Jon Ashburn | 87d6aa9 | 2015-08-28 15:19:27 -0600 | [diff] [blame] | 377 | extern THREAD_LOCAL_DECL struct loader_instance *tls_instance; |
Jon Ashburn | 8810c5f | 2015-08-18 18:04:47 -0600 | [diff] [blame] | 378 | extern LOADER_PLATFORM_THREAD_ONCE_DEFINITION(once_init); |
Jon Ashburn | 6301a0f | 2015-05-29 13:15:39 -0600 | [diff] [blame] | 379 | extern loader_platform_thread_mutex loader_lock; |
Jon Ashburn | 6461ef2 | 2015-09-22 13:11:00 -0600 | [diff] [blame] | 380 | extern loader_platform_thread_mutex loader_json_lock; |
Jon Ashburn | bacb0f5 | 2015-04-06 10:58:22 -0600 | [diff] [blame] | 381 | |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 382 | struct loader_msg_callback_map_entry { |
Courtney Goeltzenleuchter | 7415d5a | 2015-12-09 15:48:16 -0700 | [diff] [blame] | 383 | VkDebugReportCallbackEXT icd_obj; |
| 384 | VkDebugReportCallbackEXT loader_obj; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 385 | }; |
| 386 | |
Mark Young | 0f183a8 | 2017-02-28 09:58:04 -0700 | [diff] [blame] | 387 | // Helper function definitions |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 388 | void *loader_instance_heap_alloc(const struct loader_instance *instance, size_t size, VkSystemAllocationScope allocationScope); |
| 389 | void loader_instance_heap_free(const struct loader_instance *instance, void *pMemory); |
| 390 | void *loader_instance_heap_realloc(const struct loader_instance *instance, void *pMemory, size_t orig_size, size_t size, |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 391 | VkSystemAllocationScope alloc_scope); |
Mark Young | 0ad8313 | 2016-06-30 13:02:42 -0600 | [diff] [blame] | 392 | void *loader_instance_tls_heap_alloc(size_t size); |
| 393 | void loader_instance_tls_heap_free(void *pMemory); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 394 | void *loader_device_heap_alloc(const struct loader_device *device, size_t size, VkSystemAllocationScope allocationScope); |
Mark Young | 0ad8313 | 2016-06-30 13:02:42 -0600 | [diff] [blame] | 395 | void loader_device_heap_free(const struct loader_device *device, void *pMemory); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 396 | void *loader_device_heap_realloc(const struct loader_device *device, void *pMemory, size_t orig_size, size_t size, |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 397 | VkSystemAllocationScope alloc_scope); |
Jon Ashburn | 1530c34 | 2016-02-26 13:14:27 -0700 | [diff] [blame] | 398 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 399 | void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t msg_code, const char *format, ...); |
Jon Ashburn | 2e37d75 | 2016-02-12 08:20:06 -0700 | [diff] [blame] | 400 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 401 | bool compare_vk_extension_properties(const VkExtensionProperties *op1, const VkExtensionProperties *op2); |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 402 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 403 | VkResult loader_validate_layers(const struct loader_instance *inst, const uint32_t layer_count, |
| 404 | const char *const *ppEnabledLayerNames, const struct loader_layer_list *list); |
Courtney Goeltzenleuchter | 3b8c5ff | 2015-07-06 17:45:08 -0600 | [diff] [blame] | 405 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 406 | VkResult loader_validate_instance_extensions(const struct loader_instance *inst, const struct loader_extension_list *icd_exts, |
| 407 | const struct loader_layer_list *instance_layer, |
| 408 | const VkInstanceCreateInfo *pCreateInfo); |
Courtney Goeltzenleuchter | 3b8c5ff | 2015-07-06 17:45:08 -0600 | [diff] [blame] | 409 | |
Jon Ashburn | 8810c5f | 2015-08-18 18:04:47 -0600 | [diff] [blame] | 410 | void loader_initialize(void); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 411 | VkResult loader_copy_layer_properties(const struct loader_instance *inst, struct loader_layer_properties *dst, |
Mark Young | 0ad8313 | 2016-06-30 13:02:42 -0600 | [diff] [blame] | 412 | struct loader_layer_properties *src); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 413 | bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop, const uint32_t count, |
Jon Ashburn | 23d36b1 | 2016-02-02 17:47:28 -0700 | [diff] [blame] | 414 | const VkExtensionProperties *ext_array); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 415 | bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop, const struct loader_extension_list *ext_list); |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 416 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 417 | VkResult loader_add_to_ext_list(const struct loader_instance *inst, struct loader_extension_list *ext_list, |
| 418 | uint32_t prop_list_count, const VkExtensionProperties *props); |
| 419 | VkResult loader_add_to_dev_ext_list(const struct loader_instance *inst, struct loader_device_extension_list *ext_list, |
| 420 | const VkExtensionProperties *props, uint32_t entry_count, char **entrys); |
Jon Ashburn | 1530c34 | 2016-02-26 13:14:27 -0700 | [diff] [blame] | 421 | VkResult loader_add_device_extensions(const struct loader_instance *inst, |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 422 | PFN_vkEnumerateDeviceExtensionProperties fpEnumerateDeviceExtensionProperties, |
| 423 | VkPhysicalDevice physical_device, const char *lib_name, |
Jon Ashburn | 1530c34 | 2016-02-26 13:14:27 -0700 | [diff] [blame] | 424 | struct loader_extension_list *ext_list); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 425 | VkResult loader_init_generic_list(const struct loader_instance *inst, struct loader_generic_list *list_info, size_t element_size); |
| 426 | void loader_destroy_generic_list(const struct loader_instance *inst, struct loader_generic_list *list); |
| 427 | void loader_destroy_layer_list(const struct loader_instance *inst, struct loader_device *device, |
Jon Ashburn | 1530c34 | 2016-02-26 13:14:27 -0700 | [diff] [blame] | 428 | struct loader_layer_list *layer_list); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 429 | void loader_delete_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_list); |
| 430 | bool loader_find_layer_name_array(const char *name, uint32_t layer_count, const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 431 | VkResult loader_add_to_layer_list(const struct loader_instance *inst, struct loader_layer_list *list, uint32_t prop_list_count, |
Mark Young | 0ad8313 | 2016-06-30 13:02:42 -0600 | [diff] [blame] | 432 | const struct loader_layer_properties *props); |
Mark Young | f2079b9 | 2017-05-02 10:49:46 -0600 | [diff] [blame] | 433 | void loader_find_layer_name_add_list(const struct loader_instance *inst, const char *name, const enum layer_type_flags type_flags, |
Mark Young | 283fe1c | 2017-05-04 12:16:35 -0600 | [diff] [blame] | 434 | const struct loader_layer_list *source_list, struct loader_layer_list *target_list, |
| 435 | struct loader_layer_list *expanded_target_list); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 436 | void loader_scanned_icd_clear(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list); |
| 437 | VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list); |
| 438 | void loader_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers); |
| 439 | void loader_implicit_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers); |
Jean-Francois Roy | bd7ceab | 2017-07-06 14:10:13 -0700 | [diff] [blame] | 440 | bool loader_is_implicit_layer_enabled(const struct loader_instance *inst, const struct loader_layer_properties *prop); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 441 | VkResult loader_get_icd_loader_instance_extensions(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list, |
| 442 | struct loader_extension_list *inst_exts); |
| 443 | struct loader_icd_term *loader_get_icd_and_device(const VkDevice device, struct loader_device **found_dev, uint32_t *icd_index); |
| 444 | void loader_init_dispatch_dev_ext(struct loader_instance *inst, struct loader_device *dev); |
Jon Ashburn | 23d36b1 | 2016-02-02 17:47:28 -0700 | [diff] [blame] | 445 | void *loader_dev_ext_gpa(struct loader_instance *inst, const char *funcName); |
| 446 | void *loader_get_dev_ext_trampoline(uint32_t index); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 447 | bool loader_phys_dev_ext_gpa(struct loader_instance *inst, const char *funcName, bool perform_checking, void **tramp_addr, |
| 448 | void **term_addr); |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 449 | void *loader_get_phys_dev_ext_tramp(uint32_t index); |
| 450 | void *loader_get_phys_dev_ext_termin(uint32_t index); |
Jon Ashburn | 23d36b1 | 2016-02-02 17:47:28 -0700 | [diff] [blame] | 451 | struct loader_instance *loader_get_instance(const VkInstance instance); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 452 | void loader_deactivate_layers(const struct loader_instance *instance, struct loader_device *device, struct loader_layer_list *list); |
| 453 | struct loader_device *loader_create_logical_device(const struct loader_instance *inst, const VkAllocationCallbacks *pAllocator); |
| 454 | void loader_add_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term, |
Piers Daniell | 295fe40 | 2016-03-29 11:51:11 -0600 | [diff] [blame] | 455 | struct loader_device *found_dev); |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 456 | void loader_remove_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term, |
| 457 | struct loader_device *found_dev, const VkAllocationCallbacks *pAllocator); |
Mark Young | dee312c | 2017-03-08 13:38:35 -0700 | [diff] [blame] | 458 | // NOTE: Outside of loader, this entry-point is only provided for error |
Mark Young | 0153e0b | 2016-11-03 14:27:13 -0600 | [diff] [blame] | 459 | // cleanup. |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 460 | void loader_destroy_logical_device(const struct loader_instance *inst, struct loader_device *dev, |
Mark Young | 0ad8313 | 2016-06-30 13:02:42 -0600 | [diff] [blame] | 461 | const VkAllocationCallbacks *pAllocator); |
| 462 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 463 | VkResult loader_enable_instance_layers(struct loader_instance *inst, const VkInstanceCreateInfo *pCreateInfo, |
| 464 | const struct loader_layer_list *instance_layers); |
Courtney Goeltzenleuchter | 00150eb | 2016-01-08 12:18:43 -0700 | [diff] [blame] | 465 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 466 | VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, |
| 467 | struct loader_instance *inst, VkInstance *created_instance); |
Courtney Goeltzenleuchter | 00150eb | 2016-01-08 12:18:43 -0700 | [diff] [blame] | 468 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 469 | void loader_activate_instance_layer_extensions(struct loader_instance *inst, VkInstance created_inst); |
Courtney Goeltzenleuchter | 7f5aafc | 2015-07-05 11:28:29 -0600 | [diff] [blame] | 470 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 471 | VkResult loader_create_device_chain(const struct loader_physical_device_tramp *pd, const VkDeviceCreateInfo *pCreateInfo, |
| 472 | const VkAllocationCallbacks *pAllocator, const struct loader_instance *inst, |
| 473 | struct loader_device *dev); |
Mark Young | 3938987 | 2017-01-19 21:10:49 -0700 | [diff] [blame] | 474 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 475 | VkResult loader_validate_device_extensions(struct loader_physical_device_tramp *phys_dev, |
| 476 | const struct loader_layer_list *activated_device_layers, |
| 477 | const struct loader_extension_list *icd_exts, const VkDeviceCreateInfo *pCreateInfo); |
Courtney Goeltzenleuchter | 7f5aafc | 2015-07-05 11:28:29 -0600 | [diff] [blame] | 478 | |
Mark Young | 6267ae6 | 2017-01-12 12:27:19 -0700 | [diff] [blame] | 479 | VkResult setupLoaderTrampPhysDevs(VkInstance instance); |
| 480 | VkResult setupLoaderTermPhysDevs(struct loader_instance *inst); |
| 481 | |
Mark Lobodzinski | 729a8d3 | 2017-01-26 12:16:30 -0700 | [diff] [blame] | 482 | VkStringErrorFlags vk_string_validate(const int max_length, const char *char_array); |
Mark Lobodzinski | e9f09ef | 2016-02-02 18:53:34 -0700 | [diff] [blame] | 483 | |
Mark Young | f2079b9 | 2017-05-02 10:49:46 -0600 | [diff] [blame] | 484 | #endif // LOADER_H |