loader: Make a layer properties structure for manifest file.

Make the scanned layer list use this layer properties structure.
Make the list dynamically sized so can get rid of the current static array
and it's limited fix size.

3 files changed, 101 insertions, 68 deletions

diff --git a/loader/loader.c b/loader/loader.c
index a82b1c4d..fffe953b 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -381,7 +381,7 @@ static void loader_get_global_extensions(
 static void loader_get_physical_device_layer_extensions(
         struct loader_instance *ptr_instance,
         VkPhysicalDevice physical_device,
-        const uint32_t layer_index,
+        const struct loader_layer_properties *layer_props,
         struct loader_extension_list *ext_list)
 {
     uint32_t i, count;
@@ -393,12 +393,12 @@ static void loader_get_physical_device_layer_extensions(
     PFN_vkGPA ext_get_proc_addr;
     PFN_vkGetDeviceProcAddr get_device_proc_addr;
 
-    if (!loader.scanned_layers[layer_index].physical_device_extensions_supported) {
+    if (layer_props->device_extension_list.count == 0) {
         return;
     }
 
     ext_props.origin = VK_EXTENSION_ORIGIN_LAYER;
-    ext_props.lib_name = loader.scanned_layers[layer_index].lib_name;
+    ext_props.lib_name = layer_props->lib_info.lib_name;
     char funcStr[MAX_EXTENSION_NAME_SIZE+1];  // add one character for 0 termination
 
     lib_handle = loader_add_layer_lib("device", &ext_props);
@@ -420,7 +420,7 @@ static void loader_get_physical_device_layer_extensions(
                     if ((ext_get_proc_addr = (PFN_vkGPA) loader_platform_get_proc_address(lib_handle, funcStr)) == NULL)
                         ext_get_proc_addr = get_device_proc_addr;
                     ext_props.get_proc_addr = ext_get_proc_addr;
-                    ext_props.lib_name = loader.scanned_layers[layer_index].lib_name;
+                    ext_props.lib_name = layer_props->lib_info.lib_name;
                     loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
                                "PhysicalDevice Extension: %s: %s", ext_props.info.name, ext_props.info.description);
                     loader_add_to_ext_list(ext_list, 1, &ext_props);
@@ -587,10 +587,10 @@ void loader_coalesce_extensions(void)
     };
 
     //Traverse layers list adding non-duplicate extensions to the list
-    for (i = 0; i < loader.scanned_layer_count; i++) {
+    for (i = 0; i < loader.scanned_layers.count; i++) {
         loader_add_to_ext_list(&loader.global_extensions,
-                               loader.scanned_layers[i].global_extension_list.count,
-                               loader.scanned_layers[i].global_extension_list.list);
+                               loader.scanned_layers.list[i].instance_extension_list.count,
+                               loader.scanned_layers.list[i].instance_extension_list.list);
     }
 
     // Traverse loader's extensions, adding non-duplicate extensions to the list
@@ -1200,7 +1200,7 @@ void loader_icd_scan(void)
 }
 
 
-void layer_lib_scan(void)
+void loader_layer_scan(void)
 {
     const char *p, *next;
     char *libPaths = NULL;
@@ -1255,14 +1255,28 @@ void layer_lib_scan(void)
 #endif // WIN32
     libPaths = loader.layer_dirs;
 
-    /* cleanup any previously scanned libraries */
-    for (i = 0; i < loader.scanned_layer_count; i++) {
-        if (loader.scanned_layers[i].lib_name != NULL)
-            free(loader.scanned_layers[i].lib_name);
-        loader_destroy_ext_list(&loader.scanned_layers[i].global_extension_list);
-        loader.scanned_layers[i].lib_name = NULL;
+    if (loader.scanned_layers.capacity == 0) {
+        loader.scanned_layers.list = malloc(sizeof(struct loader_layer_properties) * 64);
+        if (loader.scanned_layers.list == NULL) {
+            //TODO ERR log
+            return;
+        }
+        memset(loader.scanned_layers.list, 0, sizeof(struct loader_layer_properties) * 64);
+        loader.scanned_layers.capacity = sizeof(struct loader_layer_properties) * 64;
+    }
+    else {
+        /* cleanup any previously scanned libraries */
+        //TODO make sure everything is cleaned up properly
+        for (i = 0; i < loader.scanned_layers.count; i++) {
+            if (loader.scanned_layers.list[i].lib_info.lib_name != NULL)
+                free(loader.scanned_layers.list[i].lib_info.lib_name);
+            free(loader.scanned_layers.list[i].name);
+            loader_destroy_ext_list(&loader.scanned_layers.list[i].instance_extension_list);
+            loader_destroy_ext_list(&loader.scanned_layers.list[i].device_extension_list);
+            loader.scanned_layers.list[i].lib_info.lib_name = NULL;
+        }
+        loader.scanned_layers.count = 0;
     }
-    loader.scanned_layer_count = 0;
     count = 0;
 
     for (p = libPaths; *p; p = next) {
@@ -1307,12 +1321,15 @@ void layer_lib_scan(void)
                         loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
                                    "Opened library: %s", temp_str);
 
-                        /* TODO: Remove fixed count */
-                        if (count == MAX_LAYER_LIBRARIES) {
-                            loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
-                                       "%s ignored: max layer libraries exceed",
-                                       temp_str);
-                            break;
+                        if (count * sizeof(struct loader_layer_properties) >= loader.scanned_layers.capacity) {
+                            loader.scanned_layers.list = realloc(loader.scanned_layers.list,
+                                        loader.scanned_layers.capacity * 2);
+                            if (loader.scanned_layers.list == NULL) {
+                                loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
+                                       "realloc failed for scanned layers");
+                                break;
+                            }
+                            loader.scanned_layers.capacity *= 2;
                         }
 
                         fp_get_count = loader_platform_get_proc_address(handle, "vkGetGlobalExtensionCount");
@@ -1326,32 +1343,25 @@ void layer_lib_scan(void)
                             continue;
                         }
 
-                        loader.scanned_layers[count].lib_name =
+                        loader.scanned_layers.list[count].lib_info.lib_name =
                                 malloc(strlen(temp_str) + 1);
-                        if (loader.scanned_layers[count].lib_name == NULL) {
+                        if (loader.scanned_layers.list[count].lib_info.lib_name == NULL) {
                             loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "%s ignored: out of memory", temp_str);
                             break;
                         }
 
-                        strcpy(loader.scanned_layers[count].lib_name, temp_str);
+                        strcpy(loader.scanned_layers.list[count].lib_info.lib_name, temp_str);
 
                         loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, "Collecting global extensions for %s", temp_str);
                         loader_get_global_extensions(
                                     fp_get_count,
                                     fp_get_props,
                                     NULL,
-                                    loader.scanned_layers[count].lib_name,
+                                    loader.scanned_layers.list[count].lib_info.lib_name,
                                     handle,
                                     VK_EXTENSION_ORIGIN_LAYER,
-                                    &loader.scanned_layers[count].global_extension_list);
-
-                        fp_get_count = loader_platform_get_proc_address(handle,
-                                                                      "vkGetPhysicalDeviceExtensionCount");
-                        fp_get_props = loader_platform_get_proc_address(handle,
-                                                                      "vkGetPhysicalDeviceExtensionProperties");
-                        if (fp_get_props && fp_get_count) {
-                            loader.scanned_layers[count].physical_device_extensions_supported = true;
-                        }
+                                    &loader.scanned_layers.list[count].instance_extension_list);
+
 
                         count++;
                         loader_platform_close_library(handle);
@@ -1360,13 +1370,11 @@ void layer_lib_scan(void)
 
                 dent = readdir(curdir);
             } // while (dir_entry)
-            if (count == MAX_LAYER_LIBRARIES)
-                break;
             closedir(curdir);
         } // if (curdir))
     } // for (libpaths)
 
-    loader.scanned_layer_count = count;
+    loader.scanned_layers.count = count;
 }
 
 static void* VKAPI loader_gpa_instance_internal(VkInstance inst, const char * pName)
@@ -1443,7 +1451,7 @@ static loader_platform_dl_handle loader_add_layer_lib(
     my_lib = &new_layer_lib_list[loader.loaded_layer_lib_count];
 
     /* NOTE: We require that the extension property be immutable */
-    my_lib->lib_name = ext_prop->lib_name;
+    my_lib->lib_name = (char *) ext_prop->lib_name;
     my_lib->ref_count = 0;
     my_lib->lib_handle = NULL;
 
@@ -1989,8 +1997,12 @@ VkResult loader_init_physical_device_info(
                         }
 
                         // Traverse layers list adding non-duplicate extensions to the list
-                        for (uint32_t l = 0; l < loader.scanned_layer_count; l++) {
-                            loader_get_physical_device_layer_extensions(ptr_instance, icd->gpus[i], l, &icd->device_extension_cache[i]);
+                        for (uint32_t l = 0; l < loader.scanned_layers.count; l++) {
+                            loader_get_physical_device_layer_extensions(
+                                                ptr_instance,
+                                                icd->gpus[i],
+                                                &loader.scanned_layers.list[i],
+                                                &icd->device_extension_cache[i]);
                         }
                     }
                 }
@@ -2309,7 +2321,7 @@ LOADER_EXPORT VkResult VKAPI vkGetGlobalExtensionCount(
     loader_platform_thread_once(&once_icd, loader_icd_scan);
 
     /* get layer libraries in a single-threaded manner */
-    loader_platform_thread_once(&once_layer, layer_lib_scan);
+    loader_platform_thread_once(&once_layer, loader_layer_scan);
 
     /* merge any duplicate extensions */
     loader_platform_thread_once(&once_exts, loader_coalesce_extensions);
@@ -2329,7 +2341,7 @@ LOADER_EXPORT VkResult VKAPI vkGetGlobalExtensionProperties(
     loader_platform_thread_once(&once_icd, loader_icd_scan);
 
     /* get layer libraries in a single-threaded manner */
-    loader_platform_thread_once(&once_layer, layer_lib_scan);
+    loader_platform_thread_once(&once_layer, loader_layer_scan);
 
     /* merge any duplicate extensions */
     loader_platform_thread_once(&once_exts, loader_coalesce_extensions);
diff --git a/loader/loader.h b/loader/loader.h
index 6fd87687..f54f44f9 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -44,7 +44,6 @@
 #endif
 
 #define MAX_EXTENSION_NAME_SIZE 255
-#define MAX_LAYER_LIBRARIES 64
 #define MAX_GPUS_PER_ICD 16
 
 enum extension_origin {
@@ -53,6 +52,15 @@ enum extension_origin {
     VK_EXTENSION_ORIGIN_LOADER
 };
 
+enum layer_type {
+    VK_LAYER_TYPE_DEVICE_EXPLICIT,
+    VK_LAYER_TYPE_INSTANCE_EXPLICIT,
+    VK_LAYER_TYPE_GLOBAL_EXPLICIT,   // both instance and device layer
+    VK_LAYER_TYPE_DEVICE_IMPLICIT,
+    VK_LAYER_TYPE_INSTANCE_IMPLICIT,
+    VK_LAYER_TYPE_GLOBAL_IMPLICIT,   // both instance and device layer
+};
+
 struct loader_extension_property {
     VkExtensionProperties info;
     const char *lib_name;
@@ -77,18 +85,40 @@ struct loader_extension_list {
     struct loader_extension_property *list;
 };
 
-struct loader_scanned_layers {
+struct loader_name_value {
+    char *name;
+    char *value;
+};
+
+struct loader_lib_info {
     char *lib_name;
+    uint32_t ref_count;
+    loader_platform_dl_handle lib_handle;
+};
 
-    /* cache of global extensions for a specific layer */
-    struct loader_extension_list global_extension_list;
+struct loader_layer_functions {
+    PFN_vkGetInstanceProcAddr get_instance_proc_addr;
+    PFN_vkGetDeviceProcAddr get_device_proc_addr;
+};
 
-    bool physical_device_extensions_supported;
-    /*
-     * cache of device extensions for a specific layer,
-     * filled in at CreateInstance time
-     */
-    struct loader_extension_list physical_device_extension_list;
+struct loader_layer_properties {
+    char *name;
+    enum layer_type type;
+    struct loader_lib_info lib_info;
+    char *abi_versions;
+    char *impl_version;
+    char *description;
+    struct loader_layer_functions functions;
+    struct loader_extension_list instance_extension_list;
+    struct loader_extension_list device_extension_list;
+    struct loader_name_value disable_env_var;
+    struct loader_name_value enable_env_var;
+};
+
+struct loader_layer_list {
+    size_t capacity;
+    uint32_t count;
+    struct loader_layer_properties *list;
 };
 
 /* per CreateDevice structure */
@@ -222,16 +252,6 @@ struct loader_instance {
     VkLayerDbgFunctionNode *DbgFunctionHead;
 };
 
-static inline struct loader_instance *loader_instance(VkInstance instance) {
-    return (struct loader_instance *) instance;
-}
-
-struct loader_lib_info {
-    const char *lib_name;
-    uint32_t ref_count;
-    loader_platform_dl_handle lib_handle;
-};
-
 struct loader_struct {
     struct loader_instance *instances;
     struct loader_scanned_icds *scanned_icd_list;
@@ -241,10 +261,7 @@ struct loader_struct {
 
     char *layer_dirs;
 
-    /* TODO: eliminate fixed limit */
-    unsigned int scanned_layer_count;   // indicate number of scanned layers
-    size_t scanned_ext_list_capacity;
-    struct loader_scanned_layers scanned_layers[MAX_LAYER_LIBRARIES];
+    struct loader_layer_list scanned_layers;
 
     /* Keep track of all the extensions available via GetGlobalExtensionProperties */
     struct loader_extension_list global_extensions;
@@ -274,6 +291,10 @@ struct loader_scanned_icds {
     struct loader_extension_list device_extension_list;
 };
 
+static inline struct loader_instance *loader_instance(VkInstance instance) {
+    return (struct loader_instance *) instance;
+}
+
 static inline void loader_set_dispatch(VkObject obj, const void *data)
 {
     *((const void **) obj) = data;
@@ -391,7 +412,7 @@ void loader_destroy_ext_list(struct loader_extension_list *ext_info);
 
 bool loader_is_extension_scanned(const VkExtensionProperties *ext_prop);
 void loader_icd_scan(void);
-void layer_lib_scan(void);
+void loader_layer_scan(void);
 void loader_coalesce_extensions(void);
 
 struct loader_icd * loader_get_icd(const VkPhysicalDevice gpu,
diff --git a/loader/trampoline.c b/loader/trampoline.c
index 80c43c06..07d33794 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -47,7 +47,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateInstance(
     loader_platform_thread_once(&once_icd, loader_icd_scan);
 
     /* get layer libraries in a single-threaded manner */
-    loader_platform_thread_once(&once_layer, layer_lib_scan);
+    loader_platform_thread_once(&once_layer, loader_layer_scan);
 
     /* merge any duplicate extensions */
     loader_platform_thread_once(&once_exts, loader_coalesce_extensions);