loader: ghlvl #66, Ensure std_validationadvertises underlying layer extensions

Change-Id: If6b6b24fdf02b960c83148bd002114941eb1adc6

3 files changed, 97 insertions, 22 deletions

diff --git a/loader/loader.c b/loader/loader.c
index 81330aa5..e2939cf7 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -482,6 +482,18 @@ bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop,
     return false;
 }
 
+/**
+ * Search the given ext_list for a device extension matching the given ext_prop
+ */
+bool has_vk_dev_ext_property(const VkExtensionProperties *ext_prop,
+                        const struct loader_device_extension_list *ext_list) {
+    for (uint32_t i = 0; i < ext_list->count; i++) {
+        if (compare_vk_extension_properties(&ext_list->list[i].props, ext_prop))
+            return true;
+    }
+    return false;
+}
+
 static inline bool loader_is_layer_type_device(const enum layer_type type) {
     if ((type & VK_LAYER_TYPE_DEVICE_EXPLICIT) ||
         (type & VK_LAYER_TYPE_DEVICE_IMPLICIT))
@@ -781,7 +793,7 @@ VkResult loader_add_to_ext_list(const struct loader_instance *inst,
 
 /*
  * Append one extension property defined in props with entrypoints
- * defined in entrys to the given ext_list.
+ * defined in entrys to the given ext_list. Do not append if a duplicate
  * Return
  *  Vk_SUCCESS on success
  */
@@ -799,6 +811,11 @@ loader_add_to_dev_ext_list(const struct loader_instance *inst,
     if (ext_list->list == NULL)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
+    // look for duplicates
+    if (has_vk_dev_ext_property(props, ext_list)) {
+        return VK_SUCCESS;
+    }
+
     idx = ext_list->count;
     // add to list at end
     // check for enough capacity
@@ -1030,7 +1047,7 @@ void loader_add_to_layer_list(const struct loader_instance *inst,
  * Do not add if found loader_layer_properties is already
  * on the found_list.
  */
-static void
+void
 loader_find_layer_name_add_list(const struct loader_instance *inst,
                                 const char *name, const enum layer_type type,
                                 const struct loader_layer_list *search_list,
diff --git a/loader/loader.h b/loader/loader.h
index 6c192a21..b29c4506 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -460,6 +460,10 @@ VkResult loader_add_to_ext_list(const struct loader_instance *inst,
                                 struct loader_extension_list *ext_list,
                                 uint32_t prop_list_count,
                                 const VkExtensionProperties *props);
+VkResult loader_add_to_dev_ext_list(const struct loader_instance *inst,
+                                    struct loader_device_extension_list *ext_list,
+                                    const VkExtensionProperties *props,
+                                    uint32_t entry_count, char **entrys);
 VkResult loader_add_device_extensions(const struct loader_instance *inst,
                                       PFN_vkEnumerateDeviceExtensionProperties fpEnumerateDeviceExtensionProperties,
                                       VkPhysicalDevice physical_device,
@@ -489,6 +493,10 @@ void loader_add_to_layer_list(const struct loader_instance *inst,
                               struct loader_layer_list *list,
                               uint32_t prop_list_count,
                               const struct loader_layer_properties *props);
+void loader_find_layer_name_add_list(const struct loader_instance *inst,
+                                const char *name, const enum layer_type type,
+                                const struct loader_layer_list *search_list,
+                                struct loader_layer_list *found_list);
 void loader_scanned_icd_clear(const struct loader_instance *inst,
                               struct loader_icd_libs *icd_libs);
 void loader_icd_scan(const struct loader_instance *inst,
diff --git a/loader/trampoline.c b/loader/trampoline.c
index 1c998cac..c596cb7c 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -126,12 +126,12 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName,
                                        VkExtensionProperties *pProperties) {
     struct loader_extension_list *global_ext_list = NULL;
     struct loader_layer_list instance_layers;
-    struct loader_extension_list icd_extensions;
+    struct loader_extension_list local_ext_list;
     struct loader_icd_libs icd_libs;
     uint32_t copy_size;
 
     tls_instance = NULL;
-    memset(&icd_extensions, 0, sizeof(icd_extensions));
+    memset(&local_ext_list, 0, sizeof(local_ext_list));
     memset(&instance_layers, 0, sizeof(instance_layers));
     loader_platform_thread_once(&once_init, loader_initialize);
 
@@ -145,12 +145,33 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName,
         }
 
         loader_layer_scan(NULL, &instance_layers, NULL);
-        for (uint32_t i = 0; i < instance_layers.count; i++) {
-            struct loader_layer_properties *props =
-                &instance_layers.list[i];
-            if (strcmp(props->info.layerName, pLayerName) == 0) {
-                global_ext_list = &props->instance_extension_list;
-                break;
+        if (strcmp(pLayerName, std_validation_str) == 0) {
+            struct loader_layer_list local_list;
+            memset(&local_list, 0, sizeof(local_list));
+            for (uint32_t i = 0; i < sizeof(std_validation_names) /
+                                         sizeof(std_validation_names[0]);
+                 i++) {
+                loader_find_layer_name_add_list(NULL, std_validation_names[i],
+                                                VK_LAYER_TYPE_INSTANCE_EXPLICIT,
+                                                &instance_layers, &local_list);
+            }
+            for (uint32_t i = 0; i < local_list.count; i++) {
+                struct loader_extension_list *ext_list =
+                            &local_list.list[i].instance_extension_list;
+                loader_add_to_ext_list(NULL, &local_ext_list, ext_list->count,
+                                       ext_list->list);
+            }
+            loader_destroy_layer_list(NULL, &local_list);
+            global_ext_list = &local_ext_list;
+
+        } else {
+            for (uint32_t i = 0; i < instance_layers.count; i++) {
+                struct loader_layer_properties *props =
+                    &instance_layers.list[i];
+                if (strcmp(props->info.layerName, pLayerName) == 0) {
+                    global_ext_list = &props->instance_extension_list;
+                    break;
+                }
             }
         }
     } else {
@@ -159,17 +180,17 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName,
         loader_icd_scan(NULL, &icd_libs);
         /* get extensions from all ICD's, merge so no duplicates */
         loader_get_icd_loader_instance_extensions(NULL, &icd_libs,
-                                                  &icd_extensions);
+                                                  &local_ext_list);
         loader_scanned_icd_clear(NULL, &icd_libs);
 
         // Append implicit layers.
         loader_implicit_layer_scan(NULL, &instance_layers, NULL);
         for (uint32_t i = 0; i < instance_layers.count; i++) {
             struct loader_extension_list *ext_list = &instance_layers.list[i].instance_extension_list;
-            loader_add_to_ext_list(NULL, &icd_extensions, ext_list->count, ext_list->list);
+            loader_add_to_ext_list(NULL, &local_ext_list, ext_list->count, ext_list->list);
         }
 
-        global_ext_list = &icd_extensions;
+        global_ext_list = &local_ext_list;
     }
 
     if (global_ext_list == NULL) {
@@ -181,7 +202,7 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName,
         *pPropertyCount = global_ext_list->count;
         loader_destroy_layer_list(NULL, &instance_layers);
         loader_destroy_generic_list(
-            NULL, (struct loader_generic_list *)&icd_extensions);
+            NULL, (struct loader_generic_list *)&local_ext_list);
         return VK_SUCCESS;
     }
 
@@ -194,7 +215,7 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName,
     }
     *pPropertyCount = copy_size;
     loader_destroy_generic_list(NULL,
-                                (struct loader_generic_list *)&icd_extensions);
+                                (struct loader_generic_list *)&local_ext_list);
 
     if (copy_size < global_ext_list->count) {
         loader_destroy_layer_list(NULL, &instance_layers);
@@ -804,20 +825,47 @@ vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
         uint32_t count;
         uint32_t copy_size;
         const struct loader_instance *inst = phys_dev->this_instance;
+        struct loader_device_extension_list *dev_ext_list = NULL;
+        struct loader_device_extension_list local_ext_list;
+        memset(&local_ext_list, 0, sizeof(local_ext_list));
         if (vk_string_validate(MaxLoaderStringLength, pLayerName) ==
             VK_STRING_ERROR_NONE) {
-
-            struct loader_device_extension_list *dev_ext_list = NULL;
-            for (uint32_t i = 0; i < inst->device_layer_list.count; i++) {
-                struct loader_layer_properties *props =
-                    &inst->device_layer_list.list[i];
-                if (strcmp(props->info.layerName, pLayerName) == 0) {
-                    dev_ext_list = &props->device_extension_list;
+            if (strcmp(pLayerName, std_validation_str) == 0) {
+                struct loader_layer_list local_list;
+                memset(&local_list, 0, sizeof(local_list));
+                for (uint32_t i = 0; i < sizeof(std_validation_names) /
+                                             sizeof(std_validation_names[0]);
+                     i++) {
+                    loader_find_layer_name_add_list(NULL, std_validation_names[i],
+                                                VK_LAYER_TYPE_DEVICE_EXPLICIT,
+                                                &inst->device_layer_list, &local_list);
+                }
+                for (uint32_t i = 0; i < local_list.count; i++) {
+                    struct loader_device_extension_list *ext_list =
+                                &local_list.list[i].device_extension_list;
+                    for (uint32_t j = 0; j < ext_list->count; j++) {
+                        loader_add_to_dev_ext_list(NULL, &local_ext_list,
+                                                   &ext_list->list[j].props, 0,
+                                                   NULL);
+                    }
+                }
+                dev_ext_list = &local_ext_list;
+
+            } else {
+                for (uint32_t i = 0; i < inst->device_layer_list.count; i++) {
+                    struct loader_layer_properties *props =
+                        &inst->device_layer_list.list[i];
+                    if (strcmp(props->info.layerName, pLayerName) == 0) {
+                        dev_ext_list = &props->device_extension_list;
+                    }
                 }
             }
+
             count = (dev_ext_list == NULL) ? 0 : dev_ext_list->count;
             if (pProperties == NULL) {
                 *pPropertyCount = count;
+                loader_destroy_generic_list(inst,
+                        (struct loader_generic_list *) &local_ext_list);
                 loader_platform_thread_unlock_mutex(&loader_lock);
                 return VK_SUCCESS;
             }
@@ -829,6 +877,8 @@ vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
             }
             *pPropertyCount = copy_size;
 
+            loader_destroy_generic_list(inst,
+                        (struct loader_generic_list *) &local_ext_list);
             if (copy_size < count) {
                 loader_platform_thread_unlock_mutex(&loader_lock);
                 return VK_INCOMPLETE;